Changeset 6692


Ignore:
Timestamp:
Sep 3, 2008, 4:29:59 PM (13 years ago)
Author:
charles
Message:

(gtk) unclutter the prefs dialog a bit

Location:
trunk/gtk
Files:
5 edited

Legend:

Unmodified
Added
Removed
  • trunk/gtk/main.c

    r6691 r6692  
    828828
    829829    b = gtk_alignment_new(0.0, 1.0, 0.01, 0.01);
    830     w = tr_button_new_from_stock( GTK_STOCK_QUIT, _( "_Quit Now" ) );
     830    w = gtr_button_new_from_stock( GTK_STOCK_QUIT, _( "_Quit Now" ) );
    831831    g_signal_connect(w, "clicked", G_CALLBACK(do_exit_cb), NULL);
    832832    gtk_container_add(GTK_CONTAINER(b), w);
  • trunk/gtk/makemeta-ui.c

    r6358 r6692  
    348348        gtk_box_pack_start_defaults( GTK_BOX( h ), v );
    349349        v = gtk_vbox_new( FALSE, GUI_PAD_SMALL );
    350         w = tr_button_new_from_stock( GTK_STOCK_DIRECTORY, _( "F_older" ) );
     350        w = gtr_button_new_from_stock( GTK_STOCK_DIRECTORY, _( "F_older" ) );
    351351        focusMe = w;
    352352        g_signal_connect( w, "clicked", G_CALLBACK( onChooseDirectoryClicked ), ui );
    353353        gtk_box_pack_start_defaults( GTK_BOX( v ), w );
    354         w = tr_button_new_from_stock( GTK_STOCK_FILE, _( "_File" ) );
     354        w = gtr_button_new_from_stock( GTK_STOCK_FILE, _( "_File" ) );
    355355        g_signal_connect( w, "clicked", G_CALLBACK( onChooseFileClicked ), ui );
    356356        gtk_box_pack_start_defaults( GTK_BOX( v ), w );
  • trunk/gtk/tr-prefs.c

    r6687 r6692  
    175175}
    176176
     177
     178#define IDLE_DATA "idle-data"
     179
     180struct spin_idle_data
     181{
     182    gpointer core;
     183    GTimer * last_change;
     184};
     185
     186static void
     187spin_idle_data_free( gpointer gdata )
     188{
     189    struct spin_idle_data * data = gdata;
     190    g_timer_destroy( data->last_change );
     191    g_free( data );
     192}
     193
     194static gboolean
     195spun_cb_idle( gpointer spin )
     196{
     197    gboolean keep_waiting = TRUE;
     198    GObject * o = G_OBJECT( spin );
     199    struct spin_idle_data * data = g_object_get_data( o, IDLE_DATA );
     200
     201    /* has it been at least a half-second since the user stopped making changes? */
     202    if( g_timer_elapsed( data->last_change, NULL ) > 0.5f )
     203    {
     204        /* update the core */
     205        const char * key = g_object_get_data( o, PREF_KEY );
     206        const int value = gtk_spin_button_get_value_as_int( GTK_SPIN_BUTTON( spin ) );
     207        tr_core_set_pref_int( TR_CORE( data->core ), key, value );
     208
     209        /* cleanup */
     210        g_object_set_data( o, IDLE_DATA, NULL );
     211        keep_waiting = FALSE;
     212    }
     213
     214    return keep_waiting;
     215}
     216
    177217static void
    178218spun_cb( GtkSpinButton * w, gpointer core )
    179219{
    180     const char * key = g_object_get_data( G_OBJECT(w), PREF_KEY );
    181     const int value = gtk_spin_button_get_value_as_int( w );
    182     tr_core_set_pref_int( TR_CORE(core), key, value );
     220    /* user may be spinning through many values, so let's hold off
     221       for a moment to keep from flooding the core with changes */
     222    GObject * o = G_OBJECT( w );
     223    struct spin_idle_data * data = g_object_get_data( o, IDLE_DATA );
     224    if( data == NULL )
     225    {
     226        data = g_new( struct spin_idle_data, 1 );
     227        data->core = core;
     228        data->last_change = g_timer_new( );
     229        g_object_set_data_full( o, IDLE_DATA, data, spin_idle_data_free );
     230        g_timeout_add( 500, spun_cb_idle, w );
     231    }
     232    g_timer_start( data->last_change );
    183233}
    184234
     
    242292}
    243293
    244 struct test_port_data
    245 {
    246     GtkWidget * label;
    247     gboolean * alive;
    248 };
    249 
    250 static void
    251 testing_port_done( tr_handle   * handle         UNUSED,
    252                    long          response_code  UNUSED,
    253                    const void  * response,
    254                    size_t        response_len,
    255                    void        * gdata )
    256 {
    257     struct test_port_data * data = gdata;
    258     if( *data->alive )
    259     {
    260         const int isOpen = response_len && *(char*)response=='1';
    261         gtk_label_set_markup( GTK_LABEL( data->label ), isOpen
    262                               ? _("Port is <b>open</b>")
    263                               : _("Port is <b>closed</b>") );
    264     }
    265 }
    266 
    267 static gboolean
    268 testing_port_begin( gpointer gdata )
    269 {
    270     struct test_port_data * data = gdata;
    271     if( *data->alive )
    272     {
    273         GtkSpinButton * spin = g_object_get_data( G_OBJECT( data->label ), "tr-port-spin" );
    274         tr_handle * handle = g_object_get_data( G_OBJECT( data->label ), "handle" );
    275         const int port = gtk_spin_button_get_value_as_int( spin );
    276         char url[256];
    277         g_snprintf( url, sizeof(url), "http://portcheck.transmissionbt.com/%d", port );
    278         tr_webRun( handle, url, NULL, testing_port_done, data );
    279     }
    280     return FALSE;
    281 }
    282 
    283 static void
    284 testing_port_cb( GtkWidget * unused UNUSED, gpointer l )
    285 {
    286     struct test_port_data * data;
    287 
    288     gtk_label_set_markup( GTK_LABEL( l ), _( "<i>Testing port...</i>" ) );
    289 
    290     /* wait three seconds to give the port forwarding time to kick in */
    291     data = g_new0( struct test_port_data, 1 );
    292     data->label = l;
    293     data->alive = g_object_get_data( G_OBJECT( l ), "alive" );
    294     g_timeout_add( 3000, testing_port_begin, data );
    295 }
    296 
    297 static void
    298 dialogDestroyed( gpointer alive, GObject * dialog UNUSED )
    299 {
    300     *(gboolean*)alive = FALSE;
    301 }
     294/****
     295*****  Torrent Tab
     296****/
    302297
    303298static GtkWidget*
     
    343338}
    344339
    345 /***
    346 ****
    347 ***/
     340/****
     341*****  Peer Tab
     342****/
    348343
    349344struct blocklist_data
     
    363358    char buf[512];
    364359    g_snprintf( buf, sizeof( buf ),
    365                 ngettext( "Ignore the %'d _blocklisted peer",
    366                           "Ignore the %'d _blocklisted peers", n ), n );
     360                ngettext( "Enable _blocklist (contains %'d rule)",
     361                          "Enable _blocklist (contains %'d rules)", n ), n );
    367362    gtk_button_set_label( GTK_BUTTON( w ), buf );
    368363}
     
    427422
    428423static GtkWidget*
    429 peerPage( GObject * core, gboolean * alive )
     424peerPage( GObject * core )
    430425{
    431426    int row = 0;
     
    433428    GtkWidget * t;
    434429    GtkWidget * w;
    435     GtkWidget * w2;
    436430    GtkWidget * b;
    437431    GtkWidget * h;
    438     GtkWidget * l;
    439432    struct blocklist_data * data;
    440433
     
    443436
    444437    t = hig_workarea_create( );
    445     hig_workarea_add_section_title (t, &row, _("Options"));
    446 
    447         s = _("_Ignore unencrypted peers");
    448         w = gtk_check_button_new_with_mnemonic( s );
    449         gtk_toggle_button_set_active( GTK_TOGGLE_BUTTON(w),
    450                                       pref_int_get(PREF_KEY_ENCRYPTION)==TR_ENCRYPTION_REQUIRED );
    451         g_signal_connect( w, "toggled", G_CALLBACK(onEncryptionToggled), core );
    452         hig_workarea_add_wide_control( t, &row, w );
    453 
    454         s = _("Use peer e_xchange");
    455         w = new_check_button( s, PREF_KEY_PEX, core );
    456         hig_workarea_add_wide_control( t, &row, w );
    457 
    458         h = gtk_hbox_new( FALSE, GUI_PAD_BIG );
    459         w2 = new_spin_button( PREF_KEY_PORT, core, 1, INT_MAX, 1 );
    460         gtk_box_pack_start( GTK_BOX(h), w2, FALSE, FALSE, 0 );
    461         l = gtk_label_new( NULL );
    462         gtk_misc_set_alignment( GTK_MISC(l), 0.0f, 0.5f );
    463         gtk_box_pack_start( GTK_BOX(h), l, FALSE, FALSE, 0 );
    464         hig_workarea_add_row( t, &row, _("Listening _port:"), h, w2 );
    465 
    466         g_object_set_data( G_OBJECT(l), "tr-port-spin", w2 );
    467         g_object_set_data( G_OBJECT(l), "alive", alive );
    468         g_object_set_data( G_OBJECT(l), "handle", tr_core_handle( TR_CORE( core ) ) );
    469         testing_port_cb( NULL, l );
    470         g_signal_connect( w2, "value-changed", G_CALLBACK(testing_port_cb), l );
    471        
    472     hig_workarea_add_section_divider( t, &row );
    473438    hig_workarea_add_section_title( t, &row, _( "Blocklist" ) );
    474439
     
    477442        h = gtk_hbox_new( FALSE, GUI_PAD_BIG );
    478443        gtk_box_pack_start_defaults( GTK_BOX(h), w );
    479         b = gtk_button_new_with_mnemonic( _( "_Update Blocklist" ) );
     444        b = gtr_button_new_from_stock( GTK_STOCK_REFRESH, _( "_Update" ) );
    480445        data->check = w;
    481446        g_object_set_data( G_OBJECT( b ), "handle", tr_core_handle( TR_CORE( core ) ) );
     
    486451        hig_workarea_add_wide_control( t, &row, h );
    487452       
    488         s = _( "_Enable automatic updates" );
     453        s = _( "Enable _automatic updates" );
    489454        w = new_check_button( s, PREF_KEY_BLOCKLIST_UPDATES_ENABLED, core );
    490455        hig_workarea_add_wide_control( t, &row, w );
     
    500465        hig_workarea_add_row( t, &row, _( "Maximum peers per _torrent:" ), w, NULL );
    501466
     467    hig_workarea_add_section_divider( t, &row );
     468    hig_workarea_add_section_title (t, &row, _("Options"));
     469
     470        s = _("_Ignore unencrypted peers");
     471        w = gtk_check_button_new_with_mnemonic( s );
     472        gtk_toggle_button_set_active( GTK_TOGGLE_BUTTON(w),
     473                                      pref_int_get(PREF_KEY_ENCRYPTION)==TR_ENCRYPTION_REQUIRED );
     474        g_signal_connect( w, "toggled", G_CALLBACK(onEncryptionToggled), core );
     475        hig_workarea_add_wide_control( t, &row, w );
     476
     477        s = _("Use peer e_xchange");
     478        w = new_check_button( s, PREF_KEY_PEX, core );
     479        hig_workarea_add_wide_control( t, &row, w );
     480
    502481    hig_workarea_finish( t, &row );
    503482    return t;
    504483}
     484
     485/****
     486*****  Web Tab
     487****/
    505488
    506489static GtkTreeModel*
     
    846829}
    847830
     831/****
     832*****  Proxy Tab
     833****/
     834
    848835struct ProxyPage
    849836{
     
    981968}
    982969
    983 struct NetworkPage
     970/****
     971*****  Bandwidth Tab
     972****/
     973
     974struct BandwidthPage
    984975{
    985976    TrCore * core;
     
    988979
    989980static void
    990 refreshNetworkSensitivity( struct NetworkPage * p )
     981refreshSchedSensitivity( struct BandwidthPage * p )
    991982{
    992983    GSList * l;
     
    998989
    999990static void
    1000 onNetworkToggled( GtkToggleButton * tb UNUSED, gpointer user_data )
    1001 {
    1002     refreshNetworkSensitivity( user_data );
     991onSchedToggled( GtkToggleButton * tb UNUSED, gpointer user_data )
     992{
     993    refreshSchedSensitivity( user_data );
    1003994}
    1004995
     
    10551046
    10561047static void
    1057 networkPageFree( gpointer gpage )
    1058 {
    1059     struct NetworkPage * page = gpage;
     1048bandwidthPageFree( gpointer gpage )
     1049{
     1050    struct BandwidthPage * page = gpage;
    10601051    g_slist_free( page->sched_widgets );
    10611052    g_free( page );
     
    10631054
    10641055static GtkWidget*
    1065 networkPage( GObject * core )
     1056bandwidthPage( GObject * core )
    10661057{
    10671058    int row = 0;
    10681059    const char * s;
    10691060    GtkWidget * t;
    1070     GtkWidget * w, * w2, * h;
    1071     struct NetworkPage * page = tr_new0( struct NetworkPage, 1 );
     1061    GtkWidget * w, * w2, * h, * l;
     1062    struct BandwidthPage * page = tr_new0( struct BandwidthPage, 1 );
    10721063
    10731064    page->core = TR_CORE( core );
    10741065
    10751066    t = hig_workarea_create( );
    1076     hig_workarea_add_section_title (t, &row, _( "Router" ) );
    1077 
    1078         s = _("Use UPnP or NAT-PMP port _forwarding from my router" );
    1079         w = new_check_button( s, PREF_KEY_PORT_FORWARDING, core );
    1080         hig_workarea_add_wide_control( t, &row, w );
    1081 
    1082     hig_workarea_add_section_divider( t, &row );
    1083     hig_workarea_add_section_title (t, &row, _("Bandwidth Limits"));
    1084 
    1085         s = _("Limit _download speed (KB/s):");
     1067    hig_workarea_add_section_title( t, &row, _( "Limits" ) );
     1068
     1069        s = _( "Limit _download speed (KB/s):" );
    10861070        w = new_check_button( s, PREF_KEY_DL_LIMIT_ENABLED, core );
    10871071        w2 = new_spin_button( PREF_KEY_DL_LIMIT, core, 0, INT_MAX, 5 );
     
    10901074        hig_workarea_add_row_w( t, &row, w, w2, NULL );
    10911075
    1092         s = _("Limit _upload speed (KB/s):");
     1076        s = _( "Limit _upload speed (KB/s):" );
    10931077        w = new_check_button( s, PREF_KEY_UL_LIMIT_ENABLED, core );
    10941078        w2 = new_spin_button( PREF_KEY_UL_LIMIT, core, 0, INT_MAX, 5 );
     
    10981082
    10991083    hig_workarea_add_section_divider( t, &row );
    1100     hig_workarea_add_section_title( t, &row, _( "Scheduled Bandwidth Limits" ) );
     1084    hig_workarea_add_section_title( t, &row, _( "Scheduled Limits" ) );
    11011085
    11021086        h = gtk_hbox_new( FALSE, 0 );
     
    11131097        s = _( "_Limit bandwidth between" );
    11141098        w = new_check_button( s, PREF_KEY_SCHED_LIMIT_ENABLED, core );
    1115         g_signal_connect( w, "toggled", G_CALLBACK(onNetworkToggled), page );
     1099        g_signal_connect( w, "toggled", G_CALLBACK(onSchedToggled), page );
    11161100        hig_workarea_add_row_w( t, &row, w, h, NULL );
    11171101
    11181102        w = new_spin_button( PREF_KEY_SCHED_DL_LIMIT, core, 0, INT_MAX, 5 );
    11191103        page->sched_widgets = g_slist_append( page->sched_widgets, w );
    1120         hig_workarea_add_row( t, &row, _( "Limit d_ownload speed (KB/s):" ), w, NULL );
     1104        l = hig_workarea_add_row( t, &row, _( "Limit d_ownload speed (KB/s):" ), w, NULL );
     1105        page->sched_widgets = g_slist_append( page->sched_widgets, l );
     1106
    11211107        w = new_spin_button( PREF_KEY_SCHED_UL_LIMIT, core, 0, INT_MAX, 5 );
    11221108        page->sched_widgets = g_slist_append( page->sched_widgets, w );
    1123         hig_workarea_add_row( t, &row, _( "Limit u_pload speed (KB/s):" ), w, NULL );
     1109        l = hig_workarea_add_row( t, &row, _( "Limit u_pload speed (KB/s):" ), w, NULL );
     1110        page->sched_widgets = g_slist_append( page->sched_widgets, l );
    11241111
    11251112    hig_workarea_finish( t, &row );
    1126     g_object_set_data_full( G_OBJECT( t ), "page", page, networkPageFree );
    1127 
    1128     refreshNetworkSensitivity( page );
     1113    g_object_set_data_full( G_OBJECT( t ), "page", page, bandwidthPageFree );
     1114
     1115    refreshSchedSensitivity( page );
    11291116    return t;
    11301117}
     1118
     1119/****
     1120*****  Network Tab
     1121****/
     1122
     1123struct test_port_data
     1124{
     1125    GtkWidget * label;
     1126    gboolean * alive;
     1127};
     1128
     1129static void
     1130testing_port_done( tr_handle   * handle         UNUSED,
     1131                   long          response_code  UNUSED,
     1132                   const void  * response,
     1133                   size_t        response_len,
     1134                   void        * gdata )
     1135{
     1136    struct test_port_data * data = gdata;
     1137    if( *data->alive )
     1138    {
     1139        const int isOpen = response_len && *(char*)response=='1';
     1140        gdk_threads_enter( );
     1141        gtk_label_set_markup( GTK_LABEL( data->label ), isOpen
     1142                              ? _("Port is <b>open</b>")
     1143                              : _("Port is <b>closed</b>") );
     1144        gdk_threads_leave( );
     1145    }
     1146}
     1147
     1148static gboolean
     1149testing_port_begin( gpointer gdata )
     1150{
     1151    struct test_port_data * data = gdata;
     1152    if( *data->alive )
     1153    {
     1154        GtkSpinButton * spin = g_object_get_data( G_OBJECT( data->label ), "tr-port-spin" );
     1155        tr_handle * handle = g_object_get_data( G_OBJECT( data->label ), "handle" );
     1156        const int port = gtk_spin_button_get_value_as_int( spin );
     1157        char url[256];
     1158        g_snprintf( url, sizeof(url), "http://portcheck.transmissionbt.com/%d", port );
     1159        tr_webRun( handle, url, NULL, testing_port_done, data );
     1160    }
     1161    return FALSE;
     1162}
     1163
     1164static void
     1165testing_port_cb( GtkWidget * unused UNUSED, gpointer l )
     1166{
     1167    struct test_port_data * data;
     1168
     1169    gtk_label_set_markup( GTK_LABEL( l ), _( "<i>Testing port...</i>" ) );
     1170
     1171    /* wait three seconds to give the port forwarding time to kick in */
     1172    data = g_new0( struct test_port_data, 1 );
     1173    data->label = l;
     1174    data->alive = g_object_get_data( G_OBJECT( l ), "alive" );
     1175    g_timeout_add( 3000, testing_port_begin, data );
     1176}
     1177
     1178static void
     1179dialogDestroyed( gpointer alive, GObject * dialog UNUSED )
     1180{
     1181    *(gboolean*)alive = FALSE;
     1182}
     1183
     1184static GtkWidget*
     1185networkPage( GObject * core, gboolean * alive )
     1186{
     1187    int row = 0;
     1188    const char * s;
     1189    GtkWidget * t;
     1190    GtkWidget * w;
     1191    GtkWidget * w2;
     1192    GtkWidget * h;
     1193    GtkWidget * l;
     1194    struct blocklist_data * data;
     1195
     1196    data = g_new0( struct blocklist_data, 1 );
     1197    data->core = TR_CORE( core );
     1198
     1199    t = hig_workarea_create( );
     1200    hig_workarea_add_section_title( t, &row, _( "Incoming Peers" ) );
     1201
     1202        h = gtk_hbox_new( FALSE, GUI_PAD_BIG );
     1203        w2 = new_spin_button( PREF_KEY_PORT, core, 1, 65535, 1 );
     1204        gtk_box_pack_start( GTK_BOX(h), w2, FALSE, FALSE, 0 );
     1205        l = gtk_label_new( NULL );
     1206        gtk_misc_set_alignment( GTK_MISC(l), 0.0f, 0.5f );
     1207        gtk_box_pack_start( GTK_BOX(h), l, FALSE, FALSE, 0 );
     1208        hig_workarea_add_row( t, &row, _("Listening _port:"), h, w2 );
     1209
     1210        g_object_set_data( G_OBJECT(l), "tr-port-spin", w2 );
     1211        g_object_set_data( G_OBJECT(l), "alive", alive );
     1212        g_object_set_data( G_OBJECT(l), "handle", tr_core_handle( TR_CORE( core ) ) );
     1213        testing_port_cb( NULL, l );
     1214        g_signal_connect( w2, "value-changed", G_CALLBACK(testing_port_cb), l );
     1215
     1216        s = _("Use UPnP or NAT-PMP port _forwarding from my router" );
     1217        w = new_check_button( s, PREF_KEY_PORT_FORWARDING, core );
     1218        hig_workarea_add_wide_control( t, &row, w );
     1219
     1220    hig_workarea_finish( t, &row );
     1221    return t;
     1222}
     1223
     1224/****
     1225*****
     1226****/
    11311227
    11321228GtkWidget *
     
    11571253                              gtk_label_new (_("Torrents")) );
    11581254    gtk_notebook_append_page( GTK_NOTEBOOK( n ),
    1159                               peerPage( core, alive ),
     1255                              peerPage( core ),
    11601256                              gtk_label_new (_("Peers")) );
    11611257    gtk_notebook_append_page( GTK_NOTEBOOK( n ),
     
    11631259                              gtk_label_new (_("Trackers")) );
    11641260    gtk_notebook_append_page( GTK_NOTEBOOK( n ),
    1165                               networkPage( core ),
     1261                              bandwidthPage( core ),
     1262                              gtk_label_new (_("Bandwidth")) );
     1263    gtk_notebook_append_page( GTK_NOTEBOOK( n ),
     1264                              networkPage( core, alive ),
    11661265                              gtk_label_new (_("Network")) );
    11671266    gtk_notebook_append_page( GTK_NOTEBOOK( n ),
  • trunk/gtk/util.c

    r6687 r6692  
    530530
    531531GtkWidget *
    532 tr_button_new_from_stock( const char * stock,
    533                           const char * mnemonic )
     532gtr_button_new_from_stock( const char * stock,
     533                           const char * mnemonic )
    534534{
    535535    GtkWidget * image = gtk_image_new_from_stock( stock, GTK_ICON_SIZE_BUTTON );
  • trunk/gtk/util.h

    r6687 r6692  
    8686#ifdef GTK_MAJOR_VERSION
    8787
    88 GtkWidget * tr_button_new_from_stock( const char * stock,
    89                                       const char * mnemonic );
     88GtkWidget * gtr_button_new_from_stock( const char * stock,
     89                                       const char * mnemonic );
    9090
    9191void addTorrentErrorDialog( GtkWidget  * window_or_child,
Note: See TracChangeset for help on using the changeset viewer.