Changeset 5036


Ignore:
Timestamp:
Feb 14, 2008, 5:18:00 PM (14 years ago)
Author:
charles
Message:

code cleanup

Location:
trunk/gtk
Files:
7 edited

Legend:

Unmodified
Added
Removed
  • trunk/gtk/hig.c

    r5024 r5036  
    1818{
    1919    GtkWidget * t = gtk_table_new( 1, 2, FALSE );
    20     gtk_container_set_border_width( GTK_CONTAINER( t ), 12 );
    21     gtk_table_set_col_spacing( GTK_TABLE( t ), 0, 12 );
    22     gtk_table_set_row_spacings( GTK_TABLE( t ), 6 );
     20    gtk_container_set_border_width( GTK_CONTAINER( t ), GUI_PAD_BIG );
     21    gtk_table_set_col_spacing( GTK_TABLE( t ), 0, GUI_PAD_BIG );
     22    gtk_table_set_row_spacings( GTK_TABLE( t ), GUI_PAD );
    2323    return t;
    2424}
     
    4646    gtk_misc_set_alignment( GTK_MISC( l ), 0.0f, 0.5f );
    4747    gtk_label_set_use_markup( GTK_LABEL( l ), TRUE );
    48     gtk_table_attach( GTK_TABLE( t ), l, 0, 2, *row, *row+1, GTK_FILL, 0, 0, 0 );
     48    gtk_table_attach( GTK_TABLE( t ), l, 0, 2, *row, *row+1, ~0, 0, 0, 0 );
    4949    ++*row;
    5050}
    5151
    5252static GtkWidget*
    53 control_row_new( GtkWidget * w )
     53rowNew( GtkWidget * w )
    5454{
    5555    GtkWidget * a;
     
    7676                               GtkWidget * w )
    7777{
    78     GtkWidget * r = control_row_new( w );
     78    GtkWidget * r = rowNew( w );
    7979    gtk_table_attach( GTK_TABLE( t ), r, 0, 2, *row, *row+1, GTK_FILL, 0, 0, 0 );
    8080    ++*row;
     
    9898                          GtkWidget   * l )
    9999{
    100     GtkWidget * w = control_row_new( l );
     100    GtkWidget * w = rowNew( l );
    101101    gtk_table_attach( GTK_TABLE( t ), w, 0, 1, row, row+1, GTK_FILL, GTK_FILL, 0, 0 );
    102102}
     
    118118{
    119119    if ( GTK_IS_MISC( control ) )
    120         gtk_misc_set_alignment( GTK_MISC(control), 0.0f, 0.5f );
     120        gtk_misc_set_alignment( GTK_MISC( control ), 0.0f, 0.5f );
    121121
    122122    gtk_table_attach( GTK_TABLE( t ), control,
  • trunk/gtk/hig.h

    r5007 r5036  
    1717
    1818/**
    19 *** utility code to make it slightly less painful to create
    20 *** dialogs compliant with Gnome's Human Interface Guidelines
     19*** utility code for making dialog layout that follows the Gnome HIG.
     20*** see section 8.2.2, Visual Design > Window Layout > Dialogs.
    2121**/
    2222
    23 GtkWidget* hig_workarea_create (void);
     23GtkWidget* hig_workarea_create( void );
    2424
    25 void
    26 hig_workarea_add_section_divider (GtkWidget   * table,
    27                                   int         * row);
     25void hig_workarea_add_section_divider( GtkWidget   * table,
     26                                       int         * row );
    2827
    29 void
    30 hig_workarea_add_section_title (GtkWidget   * table,
    31                                 int         * row,
    32                                 const char  * section_title);
     28void hig_workarea_add_section_title( GtkWidget   * table,
     29                                     int         * row,
     30                                     const char  * section_title );
    3331
    34 void
    35 hig_workarea_add_wide_control (GtkWidget   * table,
    36                                int         * row,
    37                                GtkWidget   * w);
     32void hig_workarea_add_wide_control( GtkWidget   * table,
     33                                    int         * row,
     34                                    GtkWidget   * w );
    3835
    39 GtkWidget*
    40 hig_workarea_add_wide_checkbutton (GtkWidget   * table,
    41                                    int         * row,
    42                                    const char  * mnemonic_string,
    43                                    gboolean      is_active);
     36GtkWidget* hig_workarea_add_wide_checkbutton( GtkWidget   * table,
     37                                              int         * row,
     38                                              const char  * mnemonic_string,
     39                                              gboolean      is_active );
    4440
    45 GtkWidget*
    46 hig_workarea_add_label (GtkWidget   * table,
    47                         int           row,
    48                         const char  * mnemonic_string);
     41GtkWidget* hig_workarea_add_label( GtkWidget   * table,
     42                                   int           row,
     43                                   const char  * mnemonic_string );
    4944
    50 void
    51 hig_workarea_add_label_w (GtkWidget   * table,
    52                           int           row,
    53                           GtkWidget   * label_widget);
     45void hig_workarea_add_label_w( GtkWidget   * table,
     46                               int           row,
     47                               GtkWidget   * label_widget );
    5448
    55 void
    56 hig_workarea_add_control (GtkWidget   * table,
    57                           int           row,
    58                           GtkWidget   * control);
     49void hig_workarea_add_control( GtkWidget   * table,
     50                               int           row,
     51                               GtkWidget   * control );
    5952
    60 GtkWidget*
    61 hig_workarea_add_row (GtkWidget   * table,
    62                       int         * row,
    63                       const char  * mnemonic_string,
    64                       GtkWidget   * control,
    65                       GtkWidget   * mnemonic_or_null_if_control_is_mnemonic);
     53GtkWidget* hig_workarea_add_row (GtkWidget   * table,
     54                                 int         * row,
     55                                 const char  * mnemonic_string,
     56                                 GtkWidget   * control,
     57                                 GtkWidget   * mnemonic_or_null_for_control );
    6658
    67 void
    68 hig_workarea_add_row_w (GtkWidget   * table,
    69                         int         * row,
    70                         GtkWidget   * label,
    71                         GtkWidget   * control,
    72                         GtkWidget   * mnemonic_or_null_if_control_is_mnemonic);
     59void hig_workarea_add_row_w( GtkWidget   * table,
     60                             int         * row,
     61                             GtkWidget   * label,
     62                             GtkWidget   * control,
     63                             GtkWidget   * mnemonic_or_null_for_control );
    7364
    74 void
    75 hig_workarea_finish (GtkWidget   * table,
    76                      int         * row);
     65void hig_workarea_finish( GtkWidget   * table,
     66                          int         * row );
    7767
    78 void
    79 hig_message_dialog_set_text (GtkMessageDialog * dialog,
    80                              const char       * primary,
    81                              const char       * secondary);
    82 
    83 
    84 /**
    85 ***
    86 **/
     68void hig_message_dialog_set_text( GtkMessageDialog * dialog,
     69                                  const char       * primary,
     70                                  const char       * secondary );
    8771
    8872enum
  • trunk/gtk/open.c

    r5021 r5036  
    1212
    1313#include <glib/gi18n.h>
     14#include <glib/gstdio.h>
    1415#include <gtk/gtk.h>
    1516#include "file-list.h"
     
    2122    TrCore * core;
    2223    GtkWidget * list;
    23     GtkWidget * run_check;
     24    GtkToggleButton * run_check;
     25    GtkToggleButton * delete_check;
    2426    char * filename;
    2527    char * destination;
     
    5153            deleteOldTorrent( data );
    5254        else {
    53             if( gtk_toggle_button_get_active( GTK_TOGGLE_BUTTON( data->run_check ) ) )
     55            if( gtk_toggle_button_get_active( data->run_check ) )
    5456                tr_torrentStart( tr_torrent_handle( data->gtor ) );
    5557            tr_core_add_torrent( data->core, data->gtor );
     58            if( gtk_toggle_button_get_active( data->delete_check ) )
     59                g_unlink( data->filename );
    5660        }
    5761    }
     
    6569
    6670static void
    67 updateTorrent( struct OpenData * data )
    68 {
    69     if( data->gtor )
    70         tr_torrentSetFolder( tr_torrent_handle( data->gtor ), data->destination );
    71 
    72     file_list_set_torrent( data->list, data->gtor );
     71updateTorrent( struct OpenData * o )
     72{
     73    if( o->gtor )
     74        tr_torrentSetFolder( tr_torrent_handle( o->gtor ), o->destination );
     75
     76    file_list_set_torrent( o->list, o->gtor );
    7377}
    7478
     
    8084    deleteOldTorrent( data );
    8185
    82     /* update the filename */
    8386    g_free( data->filename );
    8487    data->filename = gtk_file_chooser_get_filename( GTK_FILE_CHOOSER( b ) );
     
    9093        tr_handle * handle = tr_core_handle( data->core );
    9194        tr_ctorSetMetainfoFromFile( data->ctor, data->filename );
     95        tr_ctorSetDestination( data->ctor, TR_FORCE, data->destination );
    9296        tr_ctorSetPaused( data->ctor, TR_FORCE, TRUE );
    93         tr_ctorSetDestination( data->ctor, TR_FORCE, data->destination );
     97        tr_ctorSetDeleteSource( data->ctor, FALSE );
    9498        if(( torrent = tr_torrentNew( handle, data->ctor, &err )))
    9599            data->gtor = tr_torrent_new_preexisting( torrent );
     
    111115{
    112116    struct OpenData * data = gdata;
     117
    113118    g_free( data->destination );
    114119    data->destination = gtk_file_chooser_get_filename( GTK_FILE_CHOOSER( b ) );
     
    139144
    140145    /* make the dialog */
    141     d = gtk_dialog_new_with_buttons( _( "Open Torrent" ),
    142                                      parent,
    143                                      GTK_DIALOG_DESTROY_WITH_PARENT|GTK_DIALOG_NO_SEPARATOR,
    144                                      GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
    145                                      GTK_STOCK_OPEN, GTK_RESPONSE_ACCEPT,
    146                                      NULL );
     146    d = gtk_dialog_new_with_buttons( _( "Open Torrent" ), parent,
     147            GTK_DIALOG_DESTROY_WITH_PARENT|GTK_DIALOG_NO_SEPARATOR,
     148            GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
     149            GTK_STOCK_OPEN, GTK_RESPONSE_ACCEPT,
     150            NULL );
    147151
    148152    if( tr_ctorGetDestination( ctor, TR_FORCE, &str ) )
     
    153157    data->filename = g_strdup( tr_ctorGetSourceFile( ctor ) );
    154158    data->destination = g_strdup( str );
    155     g_signal_connect( G_OBJECT( d ), "response", G_CALLBACK( openResponseCB ), data );
     159    g_signal_connect( G_OBJECT( d ), "response",
     160                      G_CALLBACK( openResponseCB ), data );
    156161
    157162    t = gtk_table_new( 6, 2, FALSE );
     
    165170    gtk_table_attach( GTK_TABLE( t ), l, col, col+1, row, row+1, GTK_FILL, 0, 0, 0 );
    166171    ++col;
    167     w = gtk_file_chooser_button_new( _( "Select Torrent" ), GTK_FILE_CHOOSER_ACTION_OPEN );
     172    w = gtk_file_chooser_button_new( _( "Select Torrent" ),
     173                                     GTK_FILE_CHOOSER_ACTION_OPEN );
    168174    gtk_table_attach( GTK_TABLE( t ), w, col, col+1, row, row+1, ~0, 0, 0, 0 );
    169175    gtk_label_set_mnemonic_widget( GTK_LABEL( l ), w );
     
    176182    gtk_file_filter_add_pattern( filter, "*" );
    177183    gtk_file_chooser_add_filter( GTK_FILE_CHOOSER( w ), filter );
    178     g_signal_connect( w, "selection-changed", G_CALLBACK( sourceChanged ), data );
     184    g_signal_connect( w, "selection-changed",
     185                      G_CALLBACK( sourceChanged ), data );
    179186    if( data->filename )
    180187        if( !gtk_file_chooser_set_filename( GTK_FILE_CHOOSER( w ), data->filename ) )
     
    210217    col = 0;
    211218    w = gtk_check_button_new_with_mnemonic( _( "_Delete original torrent file" ) );
     219    data->delete_check = GTK_TOGGLE_BUTTON( w );
    212220    if( tr_ctorGetDeleteSource( ctor, &flag ) )
    213221        g_assert_not_reached( );
     
    218226    col = 0;
    219227    w = gtk_check_button_new_with_mnemonic( _( "_Start when added" ) );
    220     data->run_check = w;
     228    data->run_check = GTK_TOGGLE_BUTTON( w );
    221229    if( tr_ctorGetPaused( ctor, TR_FORCE, &flag ) )
    222230        g_assert_not_reached( );
  • trunk/gtk/torrent-inspector.c

    r5009 r5036  
    699699    g_snprintf (name, sizeof(name), namefmt, _("Comment"));
    700700    b = gtk_text_buffer_new (NULL);
    701     gtk_text_buffer_set_text (b, info->comment, -1);
     701    if( info->comment )
     702        gtk_text_buffer_set_text (b, info->comment, -1);
    702703    w = gtk_text_view_new_with_buffer (b);
    703704    gtk_widget_set_size_request (w, 0u, 100u);
  • trunk/gtk/tr_core.c

    r5015 r5036  
    2323 *****************************************************************************/
    2424
    25 #include <inttypes.h>
    26 #include <stdio.h>
    27 #include <string.h>
     25#include <string.h> /* strcmp, strlen */
    2826
    2927#include <gtk/gtk.h>
     
    3129
    3230#include <libtransmission/transmission.h>
    33 #include <libtransmission/utils.h>
     31#include <libtransmission/utils.h> /* tr_strcmp */
    3432
    3533#include "conf.h"
     
    4442    tr_handle        * handle;
    4543    int                nextid;
    46     gboolean           quitting;
    4744    struct core_stats  stats;
    4845};
    4946
    5047static void
    51 tr_core_marshal_err( GClosure * closure, GValue * ret UNUSED, guint count,
    52                      const GValue * vals, gpointer hint UNUSED,
    53                      gpointer marshal )
     48tr_core_marshal_err( GClosure * closure, GValue * ret UNUSED,
     49                     guint count, const GValue * vals,
     50                     gpointer hint UNUSED, gpointer marshal )
    5451{
    5552    typedef void (*TRMarshalErr)
     
    6158    gpointer         inst, gdata;
    6259
    63     g_return_if_fail( 3 == count );
     60    g_return_if_fail( count == 3 );
    6461
    6562    inst    = g_value_peek_pointer( vals );
     
    6865    gdata   = closure->data;
    6966
    70     callback = (TRMarshalErr) ( NULL == marshal ?
    71                                 cclosure->callback : marshal );
     67    callback = (TRMarshalErr)( marshal ? marshal : cclosure->callback );
    7268    callback( inst, errcode, errstr, gdata );
    7369}
    7470
    7571static void
    76 tr_core_marshal_prompt( GClosure * closure, GValue * ret UNUSED, guint count,
    77                         const GValue * vals, gpointer hint UNUSED,
    78                         gpointer marshal )
     72tr_core_marshal_prompt( GClosure * closure, GValue * ret UNUSED,
     73                        guint count, const GValue * vals,
     74                        gpointer hint UNUSED, gpointer marshal )
    7975{
    8076    typedef void (*TRMarshalPrompt)( gpointer, GList *, gpointer, gpointer );
     
    8581    gpointer               inst, gdata;
    8682
    87     g_return_if_fail( 3 == count );
     83    g_return_if_fail( count == 3 );
    8884
    8985    inst      = g_value_peek_pointer( vals );
    90     paths     = g_value_get_pointer( vals + 1 );
    91     ctor      = g_value_get_pointer( vals + 2 );
     86    paths     = g_value_peek_pointer( vals + 1 );
     87    ctor      = g_value_peek_pointer( vals + 2 );
    9288    gdata     = closure->data;
    9389
    94     callback = (TRMarshalPrompt) ( NULL == marshal ?
    95                                    cclosure->callback : marshal );
     90    callback = (TRMarshalPrompt)( marshal ? marshal : cclosure->callback );
    9691    callback( inst, paths, ctor, gdata );
    9792}
     
    107102{
    108103    TrCore * core = TR_CORE( obj );
    109     GObjectClass * parent;
    110104
    111105    if( !isDisposed( core ) )
    112106    {
     107        GObjectClass * parent;
     108
    113109        pref_save( NULL );
    114110        core->priv = NULL;
    115     }
    116 
    117     parent = g_type_class_peek( g_type_parent( TR_CORE_TYPE ) );
    118     parent->dispose( obj );
    119 }
    120 
     111
     112        parent = g_type_class_peek( g_type_parent( TR_CORE_TYPE ) );
     113        parent->dispose( obj );
     114    }
     115}
    121116
    122117static void
     
    126121    TrCoreClass  * core_class;
    127122
     123    g_type_class_add_private( g_class, sizeof(struct TrCorePrivate) );
     124
    128125    gobject_class = G_OBJECT_CLASS( g_class );
    129126    gobject_class->dispose = tr_core_dispose;
    130 
    131     g_type_class_add_private( g_class,
    132                               sizeof(struct TrCorePrivate) );
    133127
    134128
     
    154148}
    155149
     150/***
     151****  SORTING
     152***/
     153
    156154static int
    157155compareDouble( double a, double b )
    158156{
    159157    if( a < b ) return -1;
    160     if( b < a ) return 1;
     158    if( a > b ) return 1;
    161159    return 0;
    162160}
     
    186184
    187185    return 0;
    188 }
    189 
    190 static int
    191 compareByDateAdded( GtkTreeModel   * model UNUSED,
    192                     GtkTreeIter    * a UNUSED,
    193                     GtkTreeIter    * b UNUSED,
    194                     gpointer         user_data UNUSED )
    195 {
    196     return 0; /* FIXME */
    197186}
    198187
     
    265254}
    266255
    267 /***
    268 ****
    269 ***/
    270 
    271 
    272256static void
    273257setSort( TrCore * core, const char * mode, gboolean isReversed  )
     
    280264    if( !strcmp( mode, "sort-by-activity" ) )
    281265        gtk_tree_sortable_set_sort_func( sortable, col, compareByActivity, NULL, NULL );
    282     else if( !strcmp( mode, "sort-by-date-added" ) )
    283         gtk_tree_sortable_set_sort_func( sortable, col, compareByDateAdded, NULL, NULL );
    284266    else if( !strcmp( mode, "sort-by-progress" ) )
    285267        gtk_tree_sortable_set_sort_func( sortable, col, compareByProgress, NULL, NULL );
     
    299281prefsChanged( TrCore * core, const char * key, gpointer data UNUSED )
    300282{
    301     if( !strcmp( key, PREF_KEY_SORT_MODE ) || !strcmp( key, PREF_KEY_SORT_REVERSED ) )
     283    if( !strcmp( key, PREF_KEY_SORT_MODE ) ||
     284        !strcmp( key, PREF_KEY_SORT_REVERSED ) )
    302285    {
    303286        char * mode = pref_string_get( PREF_KEY_SORT_MODE );
     
    351334                     pref_int_get( PREF_KEY_MAX_PEERS_GLOBAL ),
    352335                     pref_int_get( PREF_KEY_MSGLEVEL ),
    353                      TRUE );
     336                     TRUE /* message queueing */ );
    354337
    355338    /* create the model used to store torrent data */
     
    360343    p->handle   = h;
    361344    p->nextid   = 1;
    362     p->quitting = FALSE;
    363345}
    364346
     
    447429    ret = g_utf8_collate_key( casefold, -1 );
    448430    g_free( casefold );
     431
    449432    return ret;
    450433}
     
    484467    tr_ctor * ctor;
    485468
    486     TR_IS_CORE( self );
    487 
    488469    path = getdownloaddir( );
    489470
     
    492473        tr_ctorSetPaused( ctor, TR_FORCE, TRUE );
    493474    tr_ctorSetDestination( ctor, TR_FALLBACK, path );
    494     tr_ctorSetMaxConnectedPeers( ctor, TR_FALLBACK, pref_int_get( PREF_KEY_MAX_PEERS_PER_TORRENT ) );
     475    tr_ctorSetMaxConnectedPeers( ctor, TR_FALLBACK,
     476                                 pref_int_get( PREF_KEY_MAX_PEERS_PER_TORRENT ) );
    495477
    496478    torrents = tr_loadTorrents ( tr_core_handle( self ), ctor, &count );
     
    508490tr_core_errsig( TrCore * self, enum tr_core_err type, const char * msg )
    509491{
    510     TrCoreClass * class;
    511 
    512     class = g_type_class_peek( TR_CORE_TYPE );
     492    TrCoreClass * class = g_type_class_peek( TR_CORE_TYPE );
    513493    g_signal_emit( self, class->errsig, 0, type, msg );
    514494}
     
    521501
    522502    if( tr_ctorGetDeleteSource( ctor, NULL ) )
    523         tr_ctorSetDeleteSource( ctor, pref_flag_get( PREF_KEY_DELETE_ORIGINAL ) );
     503        tr_ctorSetDeleteSource( ctor,
     504                                pref_flag_get( PREF_KEY_DELETE_ORIGINAL ) );
    524505
    525506    if( tr_ctorGetMaxConnectedPeers( ctor, TR_FORCE, NULL ) )
    526         tr_ctorSetMaxConnectedPeers( ctor, TR_FORCE, pref_int_get( PREF_KEY_MAX_PEERS_PER_TORRENT ) );
     507        tr_ctorSetMaxConnectedPeers( ctor, TR_FORCE,
     508                              pref_int_get( PREF_KEY_MAX_PEERS_PER_TORRENT ) );
    527509
    528510    if( tr_ctorGetDestination( ctor, TR_FORCE, NULL ) ) {
     
    537519{
    538520    TrTorrent * tor;
    539     char      * errstr;
    540 
    541     errstr = NULL;
     521    char      * errstr = NULL;
    542522
    543523    tr_core_apply_defaults( ctor );
    544     tor = tr_torrent_new_ctor( tr_core_handle( self ), ctor, &errstr );
    545     if( !tor )
    546     {
     524
     525    if(( tor = tr_torrent_new_ctor( tr_core_handle( self ), ctor, &errstr )))
     526        tr_core_add_torrent( self, tor );
     527    else{
    547528        tr_core_errsig( self, TR_CORE_ERR_ADD_TORRENT, errstr );
    548529        g_free( errstr );
    549         errstr = NULL;
    550     }
    551     else
    552     {
    553         g_assert( !errstr );
    554         tr_core_add_torrent( self, tor );
    555530    }
    556531}
  • trunk/gtk/tr_core.h

    r5015 r5036  
    8888};
    8989
    90 GType
    91 tr_core_get_type( void );
     90GType tr_core_get_type( void );
    9291
    93 TrCore *
    94 tr_core_new( void );
     92TrCore * tr_core_new( void );
    9593
    9694/* Return the model used without incrementing the reference count */
    97 GtkTreeModel *
    98 tr_core_model( TrCore * self );
     95GtkTreeModel * tr_core_model( TrCore * self );
    9996
    100 /* Returns the libtransmission handle */
    101 tr_handle *
    102 tr_core_handle( TrCore * self );
     97tr_handle * tr_core_handle( TrCore * self );
    10398
    104 const struct core_stats*
    105 tr_core_get_stats( const TrCore * self );
     99const struct core_stats* tr_core_get_stats( const TrCore * self );
    106100
    107101/******
     
    145139******/
    146140
    147 /* remove a torrent, waiting for it to pause if necessary */
    148 void
    149 tr_core_delete_torrent( TrCore * self, GtkTreeIter * iter /* XXX */ );
     141void tr_core_delete_torrent( TrCore * self, GtkTreeIter * iter );
    150142
    151143/* update the model with current torrent status */
    152 void
    153 tr_core_update( TrCore * self );
     144void tr_core_update( TrCore * self );
    154145
    155146/* emit the "quit" signal */
    156 void
    157 tr_core_quit( TrCore * self );
     147void tr_core_quit( TrCore * self );
    158148
    159149/* Set a preference value, save the prefs file, and emit the
    160150   "prefs-changed" signal */
    161 void
    162 tr_core_set_pref( TrCore * self, const char * key, const char * val );
     151void tr_core_set_pref( TrCore * self, const char * key, const char * val );
    163152
    164153/* Set a boolean preference value, save the prefs file, and emit the
    165154   "prefs-changed" signal */
    166 void
    167 tr_core_set_pref_bool( TrCore * self, const char * key, gboolean val );
     155void tr_core_set_pref_bool( TrCore * self, const char * key, gboolean val );
    168156
    169157/* Set an integer preference value, save the prefs file, and emit the
    170158   "prefs-changed" signal */
    171 void
    172 tr_core_set_pref_int( TrCore * self, const char * key, int val );
     159void tr_core_set_pref_int( TrCore * self, const char * key, int val );
     160
     161/**
     162***
     163**/
    173164
    174165/* column names for the model used to store torrent information */
  • trunk/gtk/tr_prefs.c

    r5024 r5036  
    7070**/
    7171
    72 #define PREFS_KEY "prefs-key"
     72#define PREF_KEY "pref-key"
    7373
    7474static void
     
    8181toggled_cb( GtkToggleButton * w, gpointer core )
    8282{
    83     const char * key = g_object_get_data( G_OBJECT(w), PREFS_KEY );
     83    const char * key = g_object_get_data( G_OBJECT(w), PREF_KEY );
    8484    const gboolean flag = gtk_toggle_button_get_active( w );
    8585    tr_core_set_pref_bool( TR_CORE(core), key, flag );
     
    9090{
    9191    GtkWidget * w = gtk_check_button_new_with_mnemonic( mnemonic );
    92     g_object_set_data_full( G_OBJECT(w), PREFS_KEY, g_strdup(key), g_free );
     92    g_object_set_data_full( G_OBJECT(w), PREF_KEY, g_strdup(key), g_free );
    9393    gtk_toggle_button_set_active( GTK_TOGGLE_BUTTON(w), pref_flag_get(key) );
    9494    g_signal_connect( w, "toggled", G_CALLBACK(toggled_cb), core );
     
    9999spun_cb( GtkSpinButton * w, gpointer core )
    100100{
    101     const char * key = g_object_get_data( G_OBJECT(w), PREFS_KEY );
     101    const char * key = g_object_get_data( G_OBJECT(w), PREF_KEY );
    102102    const int value = gtk_spin_button_get_value_as_int( w );
    103103    tr_core_set_pref_int( TR_CORE(core), key, value );
     
    108108{
    109109    GtkWidget * w = gtk_spin_button_new_with_range( low, high, step );
    110     g_object_set_data_full( G_OBJECT(w), PREFS_KEY, g_strdup(key), g_free );
     110    g_object_set_data_full( G_OBJECT(w), PREF_KEY, g_strdup(key), g_free );
    111111    gtk_spin_button_set_digits( GTK_SPIN_BUTTON(w), 0 );
    112112    gtk_spin_button_set_value( GTK_SPIN_BUTTON(w), pref_int_get(key) );
     
    118118chosen_cb( GtkFileChooser * w, gpointer core )
    119119{
    120     const char * key = g_object_get_data( G_OBJECT(w), PREFS_KEY );
     120    const char * key = g_object_get_data( G_OBJECT(w), PREF_KEY );
    121121    char * value = gtk_file_chooser_get_filename( GTK_FILE_CHOOSER(w) );
    122122    tr_core_set_pref( TR_CORE(core), key, value );
     
    130130                                    GTK_FILE_CHOOSER_ACTION_SELECT_FOLDER );
    131131    char * path = pref_string_get( key );
    132     g_object_set_data_full( G_OBJECT(w), PREFS_KEY, g_strdup(key), g_free );
     132    g_object_set_data_full( G_OBJECT(w), PREF_KEY, g_strdup(key), g_free );
    133133    g_signal_connect( w, "selection-changed", G_CALLBACK(chosen_cb), core );
    134134    gtk_file_chooser_set_current_folder( GTK_FILE_CHOOSER(w), path );
     
    137137
    138138static void
    139 target_cb( GtkWidget * widget, gpointer target )
    140 {
    141     gtk_widget_set_sensitive( GTK_WIDGET(target), gtk_toggle_button_get_active( GTK_TOGGLE_BUTTON(widget) ) );
     139target_cb( GtkWidget * tb, gpointer target )
     140{
     141    const gboolean b = gtk_toggle_button_get_active( GTK_TOGGLE_BUTTON( tb ) );
     142    gtk_widget_set_sensitive( GTK_WIDGET(target), b );
    142143}
    143144
     
    156157    {
    157158        GObject * o = G_OBJECT( data->label );
    158         GtkSpinButton * spin = GTK_SPIN_BUTTON( g_object_get_data( o, "tr-port-spin" ) );
     159        GtkSpinButton * spin = g_object_get_data( o, "tr-port-spin" );
    159160        const int port = gtk_spin_button_get_value_as_int( spin );
    160161        int isOpen;
     
    203204    GtkWidget * w;
    204205
    205     t = hig_workarea_create ();
    206 
    207     hig_workarea_add_section_title (t, &row, _("Windows"));
     206    t = hig_workarea_create( );
     207    hig_workarea_add_section_title( t, &row, _( "Windows" ) );
    208208       
    209209        s = _("Show an _icon in the system tray");
     
    215215        hig_workarea_add_wide_control( t, &row, w );
    216216
    217     hig_workarea_finish (t, &row);
     217    hig_workarea_finish( t, &row );
    218218    return t;
    219219}
     
    227227    GtkWidget * w;
    228228
    229     t = hig_workarea_create ();
    230 
     229    t = hig_workarea_create( );
    231230    hig_workarea_add_section_title( t, &row, _( "Location" ) );
    232231
     
    249248        hig_workarea_add_wide_control( t, &row, w );
    250249
    251     hig_workarea_finish (t, &row);
     250    hig_workarea_finish( t, &row );
    252251    return t;
    253252}
     
    261260    GtkWidget * w;
    262261
    263     t = hig_workarea_create ();
     262    t = hig_workarea_create( );
    264263    hig_workarea_add_section_title (t, &row, _("Options"));
    265264       
     
    280279        hig_workarea_add_row( t, &row, _( "Maximum peers per _torrent:" ), w, NULL );
    281280
    282     hig_workarea_finish (t, &row);
     281    hig_workarea_finish( t, &row );
    283282    return t;
    284283}
     
    293292    GtkWidget * l;
    294293    GtkWidget * h;
    295     GtkTooltips * tips = gtk_tooltips_new( );
    296 
    297     t = hig_workarea_create ();
     294
     295    t = hig_workarea_create( );
    298296
    299297    hig_workarea_add_section_title (t, &row, _("Bandwidth"));
     
    315313    hig_workarea_add_section_title (t, &row, _("Ports"));
    316314       
    317         s = _("Automatically _map port" );
     315        s = _("_Map port with UPnP or NAT-PMP" );
    318316        w = new_check_button( s, PREF_KEY_NAT, core );
    319317        hig_workarea_add_wide_control( t, &row, w );
    320         gtk_tooltips_set_tip( GTK_TOOLTIPS( tips ), w, _( "NAT traversal uses either NAT-PMP or UPnP" ), NULL );
    321318
    322319        h = gtk_hbox_new( FALSE, GUI_PAD );
     
    335332        g_signal_connect( w2, "value-changed", G_CALLBACK(testing_port_cb), l );
    336333
    337     hig_workarea_finish (t, &row);
     334    hig_workarea_finish( t, &row );
    338335    return t;
    339336}
     
    344341    GtkWidget * d;
    345342    GtkWidget * n;
    346     GtkWidget * w;
    347343    gboolean * alive;
    348344
     
    361357    n = gtk_notebook_new( );
    362358
    363     w = torrentPage( core );
    364     gtk_notebook_append_page( GTK_NOTEBOOK( n ), w, gtk_label_new (_("Torrents")) );
    365     w = peerPage( core );
    366     gtk_notebook_append_page( GTK_NOTEBOOK( n ), w, gtk_label_new (_("Peers")) );
    367     w = networkPage( core, alive );
    368     gtk_notebook_append_page( GTK_NOTEBOOK( n ), w, gtk_label_new (_("Network")) );
    369     w = generalPage( core );
    370     gtk_notebook_append_page( GTK_NOTEBOOK( n ), w, gtk_label_new (_("General")) );
    371 
     359    gtk_notebook_append_page( GTK_NOTEBOOK( n ),
     360                              torrentPage( core ),
     361                              gtk_label_new (_("Torrents")) );
     362    gtk_notebook_append_page( GTK_NOTEBOOK( n ),
     363                              peerPage( core ),
     364                              gtk_label_new (_("Peers")) );
     365    gtk_notebook_append_page( GTK_NOTEBOOK( n ),
     366                              networkPage( core, alive ),
     367                              gtk_label_new (_("Network")) );
     368    gtk_notebook_append_page( GTK_NOTEBOOK( n ),
     369                              generalPage( core ),
     370                              gtk_label_new (_("General")) );
    372371
    373372    g_signal_connect( d, "response", G_CALLBACK(response_cb), core );
Note: See TracChangeset for help on using the changeset viewer.