Changeset 11572


Ignore:
Timestamp:
Dec 22, 2010, 6:25:30 AM (11 years ago)
Author:
charles
Message:

(trunk gtk) more gtr_ naming cleanup

Location:
trunk/gtk
Files:
16 edited

Legend:

Unmodified
Added
Removed
  • trunk/gtk/actions.c

    r11563 r11572  
    214214
    215215
    216     match = pref_string_get( PREF_KEY_SORT_MODE );
     216    match = gtr_pref_string_get( PREF_KEY_SORT_MODE );
    217217    for( i = 0, n = G_N_ELEMENTS( sort_radio_entries ), active = -1;
    218218         active == -1 && i < n; ++i )
     
    234234    for( i = 0, n = G_N_ELEMENTS( pref_toggle_entries ); i < n; ++i )
    235235        pref_toggle_entries[i].is_active =
    236             pref_flag_get( pref_toggle_entries[i].name );
     236            gtr_pref_flag_get( pref_toggle_entries[i].name );
    237237
    238238    gtk_action_group_add_toggle_actions( action_group,
  • trunk/gtk/add-dialog.c

    r11571 r11572  
    3939        const char * val;
    4040        g_snprintf( key, sizeof( key ), "recent-download-dir-%d", i+1 );
    41         if(( val = pref_string_get( key )))
     41        if(( val = gtr_pref_string_get( key )))
    4242            list = g_slist_append( list, (void*)val );
    4343    }
     
    6363
    6464    /* make local copies of the strings that aren't
    65      * invalidated by pref_string_set() */
     65     * invalidated by gtr_pref_string_set() */
    6666    for( l=list; l; l=l->next )
    6767        l->data = g_strdup( l->data );
     
    7171        char key[64];
    7272        g_snprintf( key, sizeof( key ), "recent-download-dir-%d", i + 1 );
    73         pref_string_set( key, l->data );
    74     }
    75     pref_save( tr_core_session( core ) );
     73        gtr_pref_string_set( key, l->data );
     74    }
     75    gtr_pref_save( tr_core_session( core ) );
    7676
    7777    /* cleanup */
     
    102102    if( data->gtor )
    103103    {
    104         file_list_clear( data->file_list );
     104        gtr_file_list_clear( data->file_list );
    105105        tr_torrent_set_remove_flag( data->gtor, TRUE );
    106106        g_object_unref( G_OBJECT( data->gtor ) );
     
    155155    if( !o->gtor )
    156156    {
    157         file_list_clear( o->file_list );
     157        gtr_file_list_clear( o->file_list );
    158158        gtk_widget_set_sensitive( o->file_list, FALSE );
    159159    }
     
    163163        tr_torrentSetDownloadDir( tor, o->downloadDir );
    164164        gtk_widget_set_sensitive( o->file_list, tr_torrentHasMetadata( tor ) );
    165         file_list_set_torrent( o->file_list, tr_torrentId( tor ) );
     165        gtr_file_list_set_torrent( o->file_list, tr_torrentId( tor ) );
    166166        tr_torrentVerify( tor );
    167167    }
     
    292292    data->filename = g_strdup( tr_ctorGetSourceFile( ctor ) );
    293293    data->downloadDir = g_strdup( str );
    294     data->file_list = file_list_new( core, 0 );
     294    data->file_list = gtr_file_list_new( core, 0 );
    295295    str = _( "Mo_ve .torrent file to the trash" );
    296296    data->trash_check = gtk_check_button_new_with_mnemonic( str );
     
    400400    /* remember this folder the next time we use this dialog */
    401401    folder = gtk_file_chooser_get_current_folder( GTK_FILE_CHOOSER( dialog ) );
    402     pref_string_set( PREF_KEY_OPEN_DIALOG_FOLDER, folder );
     402    gtr_pref_string_set( PREF_KEY_OPEN_DIALOG_FOLDER, folder );
    403403    g_free( folder );
    404404
     
    408408        GtkWidget       * w = gtk_file_chooser_get_extra_widget( chooser );
    409409        GtkToggleButton * tb = GTK_TOGGLE_BUTTON( w );
    410         const gboolean    doStart = pref_flag_get( TR_PREFS_KEY_START );
     410        const gboolean    doStart = gtr_pref_flag_get( TR_PREFS_KEY_START );
    411411        const gboolean    doPrompt = gtk_toggle_button_get_active( tb );
    412412        const gboolean    doNotify = FALSE;
     
    440440                          onAddDialogResponse ), core );
    441441
    442     if( ( folder = pref_string_get( PREF_KEY_OPEN_DIALOG_FOLDER ) ) )
     442    if( ( folder = gtr_pref_string_get( PREF_KEY_OPEN_DIALOG_FOLDER ) ) )
    443443        gtk_file_chooser_set_current_folder( GTK_FILE_CHOOSER( w ), folder );
    444444
    445445    c = gtk_check_button_new_with_mnemonic( _( "Show _options dialog" ) );
    446446    gtk_toggle_button_set_active( GTK_TOGGLE_BUTTON( c ),
    447                                  pref_flag_get( PREF_KEY_OPTIONS_PROMPT ) );
     447                                 gtr_pref_flag_get( PREF_KEY_OPTIONS_PROMPT ) );
    448448    gtk_file_chooser_set_extra_widget( GTK_FILE_CHOOSER( w ), c );
    449449    gtk_widget_show( c );
  • trunk/gtk/conf.c

    r11571 r11572  
    230230
    231231tr_benc*
    232 pref_get_all( void )
     232gtr_pref_get_all( void )
    233233{
    234234    return getPrefs( );
     
    236236
    237237int64_t
    238 pref_int_get( const char * key )
     238gtr_pref_int_get( const char * key )
    239239{
    240240    int64_t i = 0;
     
    245245
    246246void
    247 pref_int_set( const char * key, int64_t value )
     247gtr_pref_int_set( const char * key, int64_t value )
    248248{
    249249    tr_bencDictAddInt( getPrefs( ), key, value );
     
    251251
    252252double
    253 pref_double_get( const char * key )
     253gtr_pref_double_get( const char * key )
    254254{
    255255    double d = 0.0;
     
    259259
    260260void
    261 pref_double_set( const char * key, double value )
     261gtr_pref_double_set( const char * key, double value )
    262262{
    263263    tr_bencDictAddReal( getPrefs( ), key, value );
     
    269269
    270270gboolean
    271 pref_flag_get( const char * key )
     271gtr_pref_flag_get( const char * key )
    272272{
    273273    tr_bool boolVal;
     
    277277
    278278void
    279 pref_flag_set( const char * key, gboolean value )
     279gtr_pref_flag_set( const char * key, gboolean value )
    280280{
    281281    tr_bencDictAddBool( getPrefs( ), key, value );
     
    287287
    288288const char*
    289 pref_string_get( const char * key )
     289gtr_pref_string_get( const char * key )
    290290{
    291291    const char * str = NULL;
     
    295295
    296296void
    297 pref_string_set( const char * key, const char * value )
     297gtr_pref_string_set( const char * key, const char * value )
    298298{
    299299    tr_bencDictAddStr( getPrefs( ), key, value );
     
    305305
    306306void
    307 pref_save( tr_session * session )
     307gtr_pref_save( tr_session * session )
    308308{
    309309    tr_sessionSaveSettings( session, gl_confdir, getPrefs( ) );
  • trunk/gtk/conf.h

    r11571 r11572  
    3030#include "util.h" /* gtr_lockfile */
    3131
    32 int64_t          pref_int_get           ( const char * key );
    33 void             pref_int_set           ( const char * key, int64_t value );
     32int64_t          gtr_pref_int_get           ( const char * key );
     33void             gtr_pref_int_set           ( const char * key, int64_t value );
    3434
    35 double           pref_double_get        ( const char * key );
    36 void             pref_double_set        ( const char * key, double value );
     35double           gtr_pref_double_get        ( const char * key );
     36void             gtr_pref_double_set        ( const char * key, double value );
    3737
    38 gboolean         pref_flag_get          ( const char * key );
    39 void             pref_flag_set          ( const char * key, gboolean value );
     38gboolean         gtr_pref_flag_get          ( const char * key );
     39void             gtr_pref_flag_set          ( const char * key, gboolean value );
    4040
    41 const char*      pref_string_get        ( const char * key );
    42 void             pref_string_set        ( const char * key, const char * value );
     41const char*      gtr_pref_string_get        ( const char * key );
     42void             gtr_pref_string_set        ( const char * key, const char * value );
    4343
    44 void             pref_save              ( tr_session * );
    45 struct tr_benc*  pref_get_all           ( void );
     44void             gtr_pref_save              ( tr_session * );
     45struct tr_benc*  gtr_pref_get_all           ( void );
    4646
    4747/**
     
    4949**/
    5050
    51 /**
    52 ***
    53 **/
     51gboolean cf_init( const char *confdir, char ** errstr );
    5452
    55 gboolean cf_init( const char *confdir,
    56                   char **     errstr );
    57 
    58 gboolean cf_lock( gtr_lockfile_state_t  * tr_state,
    59                   char                 ** errstr );
     53gboolean cf_lock( gtr_lockfile_state_t * tr_state, char ** errstr );
    6054
    6155#endif /* GTR_CONFIG_H */
  • trunk/gtk/details.c

    r11571 r11572  
    15021502    int i;
    15031503    int n = 0;
    1504     const tr_bool more = pref_flag_get( PREF_KEY_SHOW_MORE_PEER_INFO );
     1504    const tr_bool more = gtr_pref_flag_get( PREF_KEY_SHOW_MORE_PEER_INFO );
    15051505    int view_columns[32];
    15061506    GtkTreeViewColumn * c;
     
    17391739    w = gtk_check_button_new_with_mnemonic( _( "Show _more details" ) );
    17401740    di->more_peer_details_check = w;
    1741     b = pref_flag_get( PREF_KEY_SHOW_MORE_PEER_INFO );
     1741    b = gtr_pref_flag_get( PREF_KEY_SHOW_MORE_PEER_INFO );
    17421742    gtk_toggle_button_set_active( GTK_TOGGLE_BUTTON( w ), b );
    17431743    g_signal_connect( w, "toggled", G_CALLBACK( onMorePeerInfoToggled ), di );
     
    22582258      w = gtk_check_button_new_with_mnemonic( _( "Show _more details" ) );
    22592259      di->scrape_check = w;
    2260       b = pref_flag_get( PREF_KEY_SHOW_MORE_TRACKER_INFO );
     2260      b = gtr_pref_flag_get( PREF_KEY_SHOW_MORE_TRACKER_INFO );
    22612261      gtk_toggle_button_set_active( GTK_TOGGLE_BUTTON( w ), b );
    22622262      g_signal_connect( w, "toggled", G_CALLBACK( onScrapeToggled ), di );
     
    22732273    w = gtk_check_button_new_with_mnemonic( _( "Show _backup trackers" ) );
    22742274    di->all_check = w;
    2275     b = pref_flag_get( PREF_KEY_SHOW_BACKUP_TRACKERS );
     2275    b = gtr_pref_flag_get( PREF_KEY_SHOW_BACKUP_TRACKERS );
    22762276    gtk_toggle_button_set_active( GTK_TOGGLE_BUTTON( w ), b );
    22772277    g_signal_connect( w, "toggled", G_CALLBACK( onBackupToggled ), di );
     
    23562356    {
    23572357        GtkWidget * v = gtk_vbox_new( FALSE, 0 );
    2358         di->file_list = file_list_new( core, 0 );
     2358        di->file_list = gtr_file_list_new( core, 0 );
    23592359        di->file_label = gtk_label_new( _( "File listing not available for combined torrent properties" ) );
    23602360        gtk_box_pack_start( GTK_BOX( v ), di->file_list, TRUE, TRUE, 0 );
     
    23932393        g_snprintf( title, sizeof( title ), _( "%s Properties" ), inf->name );
    23942394
    2395         file_list_set_torrent( di->file_list, id );
     2395        gtr_file_list_set_torrent( di->file_list, id );
    23962396        gtk_widget_show( di->file_list );
    23972397        gtk_widget_hide( di->file_label );
     
    23992399   else
    24002400   {
    2401         file_list_clear( di->file_list );
     2401        gtr_file_list_clear( di->file_list );
    24022402        gtk_widget_hide( di->file_list );
    24032403        gtk_widget_show( di->file_label );
  • trunk/gtk/file-list.c

    r11563 r11572  
    242242    if( tor == NULL )
    243243    {
    244         file_list_clear( data->top );
     244        gtr_file_list_clear( data->top );
    245245    }
    246246    else
     
    401401
    402402void
    403 file_list_clear( GtkWidget * w )
    404 {
    405     file_list_set_torrent( w, -1 );
     403gtr_file_list_clear( GtkWidget * w )
     404{
     405    gtr_file_list_set_torrent( w, -1 );
    406406}
    407407
     
    483483
    484484void
    485 file_list_set_torrent( GtkWidget * w, int torrentId )
     485gtr_file_list_set_torrent( GtkWidget * w, int torrentId )
    486486{
    487487    GtkTreeStore * store;
     
    775775
    776776GtkWidget *
    777 file_list_new( TrCore * core, int torrentId )
     777gtr_file_list_new( TrCore * core, int torrentId )
    778778{
    779779    int width;
     
    884884    data->top = scroll;
    885885    g_object_set_data_full( G_OBJECT( ret ), "file-data", data, freeData );
    886     file_list_set_torrent( ret, torrentId );
     886    gtr_file_list_set_torrent( ret, torrentId );
    887887
    888888    return ret;
  • trunk/gtk/file-list.h

    r9868 r11572  
    1717#include "tr-core.h"
    1818
    19 GtkWidget * file_list_new( TrCore *, int torrentId );
    20 
    21 void        file_list_clear( GtkWidget * );
    22 
    23 void        file_list_set_torrent( GtkWidget *, int torrentId );
     19GtkWidget * gtr_file_list_new         ( TrCore *, int torrent_id );
     20void        gtr_file_list_clear       ( GtkWidget * );
     21void        gtr_file_list_set_torrent ( GtkWidget *, int torrent_id );
    2422
    2523#endif
  • trunk/gtk/icons.h

    r11563 r11572  
    1414const char * gtr_get_mime_type_from_filename( const char *file );
    1515
    16 GdkPixbuf * gtr_get_mime_type_icon( const char   * mime_type,
    17                                     GtkIconSize    icon_size,
    18                                     GtkWidget    * for_widget );
     16GdkPixbuf  * gtr_get_mime_type_icon( const char   * mime_type,
     17                                     GtkIconSize    icon_size,
     18                                     GtkWidget    * for_widget );
    1919
    2020#endif
  • trunk/gtk/main.c

    r11571 r11572  
    359359                                 & GDK_WINDOW_STATE_MAXIMIZED );
    360360
    361     pref_int_set( PREF_KEY_MAIN_WINDOW_IS_MAXIMIZED, isMaximized );
     361    gtr_pref_int_set( PREF_KEY_MAIN_WINDOW_IS_MAXIMIZED, isMaximized );
    362362
    363363    if( !isMaximized )
     
    366366        gtk_window_get_position( GTK_WINDOW( window ), &x, &y );
    367367        gtk_window_get_size( GTK_WINDOW( window ), &w, &h );
    368         pref_int_set( PREF_KEY_MAIN_WINDOW_X, x );
    369         pref_int_set( PREF_KEY_MAIN_WINDOW_Y, y );
    370         pref_int_set( PREF_KEY_MAIN_WINDOW_WIDTH, w );
    371         pref_int_set( PREF_KEY_MAIN_WINDOW_HEIGHT, h );
     368        gtr_pref_int_set( PREF_KEY_MAIN_WINDOW_X, x );
     369        gtr_pref_int_set( PREF_KEY_MAIN_WINDOW_Y, y );
     370        gtr_pref_int_set( PREF_KEY_MAIN_WINDOW_WIDTH, w );
     371        gtr_pref_int_set( PREF_KEY_MAIN_WINDOW_HEIGHT, h );
    372372    }
    373373}
     
    449449            tr_benc tmp;
    450450            tr_benc * newval;
    451             tr_benc * oldvals = pref_get_all( );
     451            tr_benc * oldvals = gtr_pref_get_all( );
    452452            const char * key;
    453453            GSList * l;
     
    728728        GSList * l;
    729729        gboolean delegated = FALSE;
    730         const gboolean trash_originals = pref_flag_get( TR_PREFS_KEY_TRASH_ORIGINAL );
     730        const gboolean trash_originals = gtr_pref_flag_get( TR_PREFS_KEY_TRASH_ORIGINAL );
    731731
    732732        for( l=argfiles; l!=NULL; l=l->next )
     
    775775
    776776        /* ensure the directories are created */
    777         if(( str = pref_string_get( TR_PREFS_KEY_DOWNLOAD_DIR )))
     777        if(( str = gtr_pref_string_get( TR_PREFS_KEY_DOWNLOAD_DIR )))
    778778            gtr_mkdir_with_parents( str, 0777 );
    779         if(( str = pref_string_get( TR_PREFS_KEY_INCOMPLETE_DIR )))
     779        if(( str = gtr_pref_string_get( TR_PREFS_KEY_INCOMPLETE_DIR )))
    780780            gtr_mkdir_with_parents( str, 0777 );
    781781
    782782        /* initialize the libtransmission session */
    783         session = tr_sessionInit( "gtk", configDir, TRUE, pref_get_all( ) );
     783        session = tr_sessionInit( "gtk", configDir, TRUE, gtr_pref_get_all( ) );
    784784        tr_sessionSetWebConfigFunc( session, curlConfigFunc );
    785785
    786         pref_flag_set( TR_PREFS_KEY_ALT_SPEED_ENABLED, tr_sessionUsesAltSpeed( session ) );
    787         pref_int_set( TR_PREFS_KEY_PEER_PORT, tr_sessionGetPeerPort( session ) );
     786        gtr_pref_flag_set( TR_PREFS_KEY_ALT_SPEED_ENABLED, tr_sessionUsesAltSpeed( session ) );
     787        gtr_pref_int_set( TR_PREFS_KEY_PEER_PORT, tr_sessionGetPeerPort( session ) );
    788788        cbdata->core = tr_core_new( session );
    789789
     
    803803
    804804        /* on startup, check & see if it's time to update the blocklist */
    805         if( pref_flag_get( TR_PREFS_KEY_BLOCKLIST_ENABLED ) ) {
    806             if( pref_flag_get( PREF_KEY_BLOCKLIST_UPDATES_ENABLED ) ) {
    807                 const int64_t last_time = pref_int_get( "blocklist-date" );
     805        if( gtr_pref_flag_get( TR_PREFS_KEY_BLOCKLIST_ENABLED ) ) {
     806            if( gtr_pref_flag_get( PREF_KEY_BLOCKLIST_UPDATES_ENABLED ) ) {
     807                const int64_t last_time = gtr_pref_int_get( "blocklist-date" );
    808808                const int SECONDS_IN_A_WEEK = 7 * 24 * 60 * 60;
    809809                const time_t now = time( NULL );
     
    845845          gboolean        isIconified )
    846846{
    847     const gboolean doStart = pref_flag_get( TR_PREFS_KEY_START ) && !forcepause;
    848     const gboolean doPrompt = pref_flag_get( PREF_KEY_OPTIONS_PROMPT );
     847    const gboolean doStart = gtr_pref_flag_get( TR_PREFS_KEY_START ) && !forcepause;
     848    const gboolean doPrompt = gtr_pref_flag_get( PREF_KEY_OPTIONS_PROMPT );
    849849    const gboolean doNotify = TRUE;
    850850
     
    861861
    862862    if( isIconified )
    863         pref_flag_set( PREF_KEY_SHOW_TRAY_ICON, TRUE );
     863        gtr_pref_flag_set( PREF_KEY_SHOW_TRAY_ICON, TRUE );
    864864
    865865    gtr_actions_set_core( cbdata->core );
     
    899899    }
    900900
    901     if( !pref_flag_get( PREF_KEY_USER_HAS_GIVEN_INFORMED_CONSENT ) )
     901    if( !gtr_pref_flag_get( PREF_KEY_USER_HAS_GIVEN_INFORMED_CONSENT ) )
    902902    {
    903903        GtkWidget * w = gtk_message_dialog_new( GTK_WINDOW( wind ),
     
    913913            case GTK_RESPONSE_ACCEPT:
    914914                /* only show it once */
    915                 pref_flag_set( PREF_KEY_USER_HAS_GIVEN_INFORMED_CONSENT, TRUE );
     915                gtr_pref_flag_set( PREF_KEY_USER_HAS_GIVEN_INFORMED_CONSENT, TRUE );
    916916                gtk_widget_destroy( w );
    917917                break;
     
    960960shouldConfirmBeforeExiting( struct cbdata * data )
    961961{
    962     return pref_flag_get( PREF_KEY_ASKQUIT )
     962    return gtr_pref_flag_get( PREF_KEY_ASKQUIT )
    963963        && tr_core_get_active_torrent_count( data->core );
    964964}
     
    11761176     * this seems to be necessary because changing the main window's
    11771177     * child seems to unset the size */
    1178     gtk_window_resize( cbdata->wind, pref_int_get( PREF_KEY_MAIN_WINDOW_WIDTH ),
    1179                                      pref_int_get( PREF_KEY_MAIN_WINDOW_HEIGHT ) );
    1180     gtk_window_move( cbdata->wind, pref_int_get( PREF_KEY_MAIN_WINDOW_X ),
    1181                                    pref_int_get( PREF_KEY_MAIN_WINDOW_Y ) );
     1178    gtk_window_resize( cbdata->wind, gtr_pref_int_get( PREF_KEY_MAIN_WINDOW_WIDTH ),
     1179                                     gtr_pref_int_get( PREF_KEY_MAIN_WINDOW_HEIGHT ) );
     1180    gtk_window_move( cbdata->wind, gtr_pref_int_get( PREF_KEY_MAIN_WINDOW_X ),
     1181                                   gtr_pref_int_get( PREF_KEY_MAIN_WINDOW_Y ) );
    11821182
    11831183    /* shut down libT */
     
    12981298    if( !strcmp( key, TR_PREFS_KEY_ENCRYPTION ) )
    12991299    {
    1300         tr_sessionSetEncryption( tr, pref_int_get( key ) );
     1300        tr_sessionSetEncryption( tr, gtr_pref_int_get( key ) );
    13011301    }
    13021302    else if( !strcmp( key, TR_PREFS_KEY_DOWNLOAD_DIR ) )
    13031303    {
    1304         tr_sessionSetDownloadDir( tr, pref_string_get( key ) );
     1304        tr_sessionSetDownloadDir( tr, gtr_pref_string_get( key ) );
    13051305    }
    13061306    else if( !strcmp( key, TR_PREFS_KEY_MSGLEVEL ) )
    13071307    {
    1308         tr_setMessageLevel( pref_int_get( key ) );
     1308        tr_setMessageLevel( gtr_pref_int_get( key ) );
    13091309    }
    13101310    else if( !strcmp( key, TR_PREFS_KEY_PEER_PORT ) )
    13111311    {
    1312         tr_sessionSetPeerPort( tr, pref_int_get( key ) );
     1312        tr_sessionSetPeerPort( tr, gtr_pref_int_get( key ) );
    13131313    }
    13141314    else if( !strcmp( key, TR_PREFS_KEY_BLOCKLIST_ENABLED ) )
    13151315    {
    1316         tr_blocklistSetEnabled( tr, pref_flag_get( key ) );
     1316        tr_blocklistSetEnabled( tr, gtr_pref_flag_get( key ) );
    13171317    }
    13181318    else if( !strcmp( key, TR_PREFS_KEY_BLOCKLIST_URL ) )
    13191319    {
    1320         tr_blocklistSetURL( tr, pref_string_get( key ) );
     1320        tr_blocklistSetURL( tr, gtr_pref_string_get( key ) );
    13211321    }
    13221322    else if( !strcmp( key, PREF_KEY_SHOW_TRAY_ICON ) )
    13231323    {
    1324         const int show = pref_flag_get( key );
     1324        const int show = gtr_pref_flag_get( key );
    13251325        if( show && !cbdata->icon )
    13261326            cbdata->icon = gtr_icon_new( cbdata->core );
     
    13321332    else if( !strcmp( key, TR_PREFS_KEY_DSPEED_ENABLED ) )
    13331333    {
    1334         tr_sessionLimitSpeed( tr, TR_DOWN, pref_flag_get( key ) );
     1334        tr_sessionLimitSpeed( tr, TR_DOWN, gtr_pref_flag_get( key ) );
    13351335    }
    13361336    else if( !strcmp( key, TR_PREFS_KEY_DSPEED_KBps ) )
    13371337    {
    1338         tr_sessionSetSpeedLimit_KBps( tr, TR_DOWN, pref_int_get( key ) );
     1338        tr_sessionSetSpeedLimit_KBps( tr, TR_DOWN, gtr_pref_int_get( key ) );
    13391339    }
    13401340    else if( !strcmp( key, TR_PREFS_KEY_USPEED_ENABLED ) )
    13411341    {
    1342         tr_sessionLimitSpeed( tr, TR_UP, pref_flag_get( key ) );
     1342        tr_sessionLimitSpeed( tr, TR_UP, gtr_pref_flag_get( key ) );
    13431343    }
    13441344    else if( !strcmp( key, TR_PREFS_KEY_USPEED_KBps ) )
    13451345    {
    1346         tr_sessionSetSpeedLimit_KBps( tr, TR_UP, pref_int_get( key ) );
     1346        tr_sessionSetSpeedLimit_KBps( tr, TR_UP, gtr_pref_int_get( key ) );
    13471347    }
    13481348    else if( !strcmp( key, TR_PREFS_KEY_RATIO_ENABLED ) )
    13491349    {
    1350         tr_sessionSetRatioLimited( tr, pref_flag_get( key ) );
     1350        tr_sessionSetRatioLimited( tr, gtr_pref_flag_get( key ) );
    13511351    }
    13521352    else if( !strcmp( key, TR_PREFS_KEY_RATIO ) )
    13531353    {
    1354         tr_sessionSetRatioLimit( tr, pref_double_get( key ) );
     1354        tr_sessionSetRatioLimit( tr, gtr_pref_double_get( key ) );
    13551355    }
    13561356    else if( !strcmp( key, TR_PREFS_KEY_IDLE_LIMIT ) )
    13571357    {
    1358         tr_sessionSetIdleLimit( tr, pref_int_get( key ) );
     1358        tr_sessionSetIdleLimit( tr, gtr_pref_int_get( key ) );
    13591359    }
    13601360    else if( !strcmp( key, TR_PREFS_KEY_IDLE_LIMIT_ENABLED ) )
    13611361    {
    1362         tr_sessionSetIdleLimited( tr, pref_flag_get( key ) );
     1362        tr_sessionSetIdleLimited( tr, gtr_pref_flag_get( key ) );
    13631363    }
    13641364    else if( !strcmp( key, TR_PREFS_KEY_PORT_FORWARDING ) )
    13651365    {
    1366         tr_sessionSetPortForwardingEnabled( tr, pref_flag_get( key ) );
     1366        tr_sessionSetPortForwardingEnabled( tr, gtr_pref_flag_get( key ) );
    13671367    }
    13681368    else if( !strcmp( key, TR_PREFS_KEY_PEX_ENABLED ) )
    13691369    {
    1370         tr_sessionSetPexEnabled( tr, pref_flag_get( key ) );
     1370        tr_sessionSetPexEnabled( tr, gtr_pref_flag_get( key ) );
    13711371    }
    13721372    else if( !strcmp( key, TR_PREFS_KEY_RENAME_PARTIAL_FILES ) )
    13731373    {
    1374         tr_sessionSetIncompleteFileNamingEnabled( tr, pref_flag_get( key ) );
     1374        tr_sessionSetIncompleteFileNamingEnabled( tr, gtr_pref_flag_get( key ) );
    13751375    }
    13761376    else if( !strcmp( key, TR_PREFS_KEY_DHT_ENABLED ) )
    13771377    {
    1378         tr_sessionSetDHTEnabled( tr, pref_flag_get( key ) );
     1378        tr_sessionSetDHTEnabled( tr, gtr_pref_flag_get( key ) );
    13791379    }
    13801380    else if( !strcmp( key, TR_PREFS_KEY_LPD_ENABLED ) )
    13811381    {
    1382         tr_sessionSetLPDEnabled( tr, pref_flag_get( key ) );
     1382        tr_sessionSetLPDEnabled( tr, gtr_pref_flag_get( key ) );
    13831383    }
    13841384    else if( !strcmp( key, TR_PREFS_KEY_RPC_PORT ) )
    13851385    {
    1386         tr_sessionSetRPCPort( tr, pref_int_get( key ) );
     1386        tr_sessionSetRPCPort( tr, gtr_pref_int_get( key ) );
    13871387    }
    13881388    else if( !strcmp( key, TR_PREFS_KEY_RPC_ENABLED ) )
    13891389    {
    1390         tr_sessionSetRPCEnabled( tr, pref_flag_get( key ) );
     1390        tr_sessionSetRPCEnabled( tr, gtr_pref_flag_get( key ) );
    13911391    }
    13921392    else if( !strcmp( key, TR_PREFS_KEY_RPC_WHITELIST ) )
    13931393    {
    1394         tr_sessionSetRPCWhitelist( tr, pref_string_get( key ) );
     1394        tr_sessionSetRPCWhitelist( tr, gtr_pref_string_get( key ) );
    13951395    }
    13961396    else if( !strcmp( key, TR_PREFS_KEY_RPC_WHITELIST_ENABLED ) )
    13971397    {
    1398         tr_sessionSetRPCWhitelistEnabled( tr, pref_flag_get( key ) );
     1398        tr_sessionSetRPCWhitelistEnabled( tr, gtr_pref_flag_get( key ) );
    13991399    }
    14001400    else if( !strcmp( key, TR_PREFS_KEY_RPC_USERNAME ) )
    14011401    {
    1402         tr_sessionSetRPCUsername( tr, pref_string_get( key ) );
     1402        tr_sessionSetRPCUsername( tr, gtr_pref_string_get( key ) );
    14031403    }
    14041404    else if( !strcmp( key, TR_PREFS_KEY_RPC_PASSWORD ) )
    14051405    {
    1406         tr_sessionSetRPCPassword( tr, pref_string_get( key ) );
     1406        tr_sessionSetRPCPassword( tr, gtr_pref_string_get( key ) );
    14071407    }
    14081408    else if( !strcmp( key, TR_PREFS_KEY_RPC_AUTH_REQUIRED ) )
    14091409    {
    1410         tr_sessionSetRPCPasswordEnabled( tr, pref_flag_get( key ) );
     1410        tr_sessionSetRPCPasswordEnabled( tr, gtr_pref_flag_get( key ) );
    14111411    }
    14121412    else if( !strcmp( key, TR_PREFS_KEY_ALT_SPEED_UP_KBps ) )
    14131413    {
    1414         tr_sessionSetAltSpeed_KBps( tr, TR_UP, pref_int_get( key ) );
     1414        tr_sessionSetAltSpeed_KBps( tr, TR_UP, gtr_pref_int_get( key ) );
    14151415    }
    14161416    else if( !strcmp( key, TR_PREFS_KEY_ALT_SPEED_DOWN_KBps ) )
    14171417    {
    1418         tr_sessionSetAltSpeed_KBps( tr, TR_DOWN, pref_int_get( key ) );
     1418        tr_sessionSetAltSpeed_KBps( tr, TR_DOWN, gtr_pref_int_get( key ) );
    14191419    }
    14201420    else if( !strcmp( key, TR_PREFS_KEY_ALT_SPEED_ENABLED ) )
    14211421    {
    1422         const gboolean b = pref_flag_get( key );
     1422        const gboolean b = gtr_pref_flag_get( key );
    14231423        tr_sessionUseAltSpeed( tr, b );
    14241424        gtr_action_set_toggled( key, b );
     
    14261426    else if( !strcmp( key, TR_PREFS_KEY_ALT_SPEED_TIME_BEGIN ) )
    14271427    {
    1428         tr_sessionSetAltSpeedBegin( tr, pref_int_get( key ) );
     1428        tr_sessionSetAltSpeedBegin( tr, gtr_pref_int_get( key ) );
    14291429    }
    14301430    else if( !strcmp( key, TR_PREFS_KEY_ALT_SPEED_TIME_END ) )
    14311431    {
    1432         tr_sessionSetAltSpeedEnd( tr, pref_int_get( key ) );
     1432        tr_sessionSetAltSpeedEnd( tr, gtr_pref_int_get( key ) );
    14331433    }
    14341434    else if( !strcmp( key, TR_PREFS_KEY_ALT_SPEED_TIME_ENABLED ) )
    14351435    {
    1436         tr_sessionUseAltSpeedTime( tr, pref_flag_get( key ) );
     1436        tr_sessionUseAltSpeedTime( tr, gtr_pref_flag_get( key ) );
    14371437    }
    14381438    else if( !strcmp( key, TR_PREFS_KEY_ALT_SPEED_TIME_DAY ) )
    14391439    {
    1440         tr_sessionSetAltSpeedDay( tr, pref_int_get( key ) );
     1440        tr_sessionSetAltSpeedDay( tr, gtr_pref_int_get( key ) );
    14411441    }
    14421442    else if( !strcmp( key, TR_PREFS_KEY_PEER_PORT_RANDOM_ON_START ) )
    14431443    {
    1444         tr_sessionSetPeerPortRandomOnStart( tr, pref_flag_get( key ) );
     1444        tr_sessionSetPeerPortRandomOnStart( tr, gtr_pref_flag_get( key ) );
    14451445    }
    14461446    else if( !strcmp( key, TR_PREFS_KEY_INCOMPLETE_DIR ) )
    14471447    {
    1448         tr_sessionSetIncompleteDir( tr, pref_string_get( key ) );
     1448        tr_sessionSetIncompleteDir( tr, gtr_pref_string_get( key ) );
    14491449    }
    14501450    else if( !strcmp( key, TR_PREFS_KEY_INCOMPLETE_DIR_ENABLED ) )
    14511451    {
    1452         tr_sessionSetIncompleteDirEnabled( tr, pref_flag_get( key ) );
     1452        tr_sessionSetIncompleteDirEnabled( tr, gtr_pref_flag_get( key ) );
    14531453    }
    14541454    else if( !strcmp( key, TR_PREFS_KEY_SCRIPT_TORRENT_DONE_ENABLED ) )
    14551455    {
    1456         tr_sessionSetTorrentDoneScriptEnabled( tr, pref_flag_get( key ) );
     1456        tr_sessionSetTorrentDoneScriptEnabled( tr, gtr_pref_flag_get( key ) );
    14571457    }
    14581458    else if( !strcmp( key, TR_PREFS_KEY_SCRIPT_TORRENT_DONE_FILENAME ) )
    14591459    {
    1460         tr_sessionSetTorrentDoneScript( tr, pref_string_get( key ) );
     1460        tr_sessionSetTorrentDoneScript( tr, gtr_pref_string_get( key ) );
    14611461    }
    14621462    else if( !strcmp( key, TR_PREFS_KEY_START) )
    14631463    {
    1464         tr_sessionSetPaused( tr, !pref_flag_get( key ) );
     1464        tr_sessionSetPaused( tr, !gtr_pref_flag_get( key ) );
    14651465    }
    14661466    else if( !strcmp( key, TR_PREFS_KEY_TRASH_ORIGINAL ) )
    14671467    {
    1468         tr_sessionSetDeleteSource( tr, pref_flag_get( key ) );
     1468        tr_sessionSetDeleteSource( tr, gtr_pref_flag_get( key ) );
    14691469    }
    14701470}
     
    18251825        if( !data->msgwin )
    18261826        {
    1827             GtkWidget * win = gtr_message_log_window_new( data->core, data->wind );
     1827            GtkWidget * win = gtr_message_log_window_new( data->wind, data->core );
    18281828            g_signal_connect( win, "destroy", G_CALLBACK( msgwinclosed ), NULL );
    18291829            data->msgwin = win;
  • trunk/gtk/msgwin.c

    r11563 r11572  
    366366                                            _( "Debug" ),       TR_MSG_DBG,
    367367                                            NULL );
    368     gtr_combo_box_set_active_enum( GTK_COMBO_BOX( w ), pref_int_get( TR_PREFS_KEY_MSGLEVEL ) );
     368    gtr_combo_box_set_active_enum( GTK_COMBO_BOX( w ), gtr_pref_int_get( TR_PREFS_KEY_MSGLEVEL ) );
    369369    return w;
    370370}
     
    375375
    376376GtkWidget *
    377 gtr_message_log_window_new( TrCore * core, GtkWindow * parent )
     377gtr_message_log_window_new( GtkWindow * parent, TrCore * core )
    378378{
    379379    GtkWidget *      win;
     
    457457                                          COL_SEQUENCE,
    458458                                          GTK_SORT_ASCENDING );
    459     data->maxLevel = pref_int_get( TR_PREFS_KEY_MSGLEVEL );
     459    data->maxLevel = gtr_pref_int_get( TR_PREFS_KEY_MSGLEVEL );
    460460    gtk_tree_model_filter_set_visible_func( GTK_TREE_MODEL_FILTER( data->
    461461                                                                   filter ),
  • trunk/gtk/msgwin.h

    r11563 r11572  
    1414#define GTR_MSGWIN_H
    1515
    16 GtkWidget * gtr_message_log_window_new( TrCore * core, GtkWindow * parent );
     16GtkWidget * gtr_message_log_window_new( GtkWindow * parent, TrCore * core );
    1717
    1818#endif
  • trunk/gtk/notify.c

    r11563 r11572  
    113113{
    114114#ifdef HAVE_LIBCANBERRA
    115     if( pref_flag_get( PREF_KEY_PLAY_DOWNLOAD_COMPLETE_SOUND ) )
     115    if( gtr_pref_flag_get( PREF_KEY_PLAY_DOWNLOAD_COMPLETE_SOUND ) )
    116116    {
    117117        /* play the sound, using sounds from the naming spec */
     
    124124#endif
    125125
    126     if( pref_flag_get( PREF_KEY_SHOW_DESKTOP_NOTIFICATION ) )
     126    if( gtr_pref_flag_get( PREF_KEY_SHOW_DESKTOP_NOTIFICATION ) )
    127127    {
    128128        const tr_info * info = tr_torrent_info( tor );
     
    158158gtr_notify_added( const char * name )
    159159{
    160     if( pref_flag_get( PREF_KEY_SHOW_DESKTOP_NOTIFICATION ) )
     160    if( gtr_pref_flag_get( PREF_KEY_SHOW_DESKTOP_NOTIFICATION ) )
    161161    {
    162162        NotifyNotification * n = notify_notification_new(
  • trunk/gtk/relocate.c

    r11567 r11572  
    1616#include <gtk/gtk.h>
    1717
    18 #include "conf.h" /* pref_string_get */
     18#include "conf.h" /* gtr_pref_string_get */
    1919#include "hig.h"
    2020#include "relocate.h"
     
    176176
    177177    if( previousLocation == NULL )
    178         previousLocation = g_strdup( pref_string_get( TR_PREFS_KEY_DOWNLOAD_DIR ) );
     178        previousLocation = g_strdup( gtr_pref_string_get( TR_PREFS_KEY_DOWNLOAD_DIR ) );
    179179    w = gtk_file_chooser_button_new( _( "Set Torrent Location" ), GTK_FILE_CHOOSER_ACTION_SELECT_FOLDER );
    180180    gtk_file_chooser_set_current_folder( GTK_FILE_CHOOSER( w ), previousLocation );
  • trunk/gtk/tr-core.c

    r11571 r11572  
    506506{
    507507    if( tr_ctorGetPaused( ctor, TR_FORCE, NULL ) )
    508         tr_ctorSetPaused( ctor, TR_FORCE, !pref_flag_get( TR_PREFS_KEY_START ) );
     508        tr_ctorSetPaused( ctor, TR_FORCE, !gtr_pref_flag_get( TR_PREFS_KEY_START ) );
    509509
    510510    if( tr_ctorGetDeleteSource( ctor, NULL ) )
    511511        tr_ctorSetDeleteSource( ctor,
    512                                pref_flag_get( TR_PREFS_KEY_TRASH_ORIGINAL ) );
     512                               gtr_pref_flag_get( TR_PREFS_KEY_TRASH_ORIGINAL ) );
    513513
    514514    if( tr_ctorGetPeerLimit( ctor, TR_FORCE, NULL ) )
    515515        tr_ctorSetPeerLimit( ctor, TR_FORCE,
    516                              pref_int_get( TR_PREFS_KEY_PEER_LIMIT_TORRENT ) );
     516                             gtr_pref_int_get( TR_PREFS_KEY_PEER_LIMIT_TORRENT ) );
    517517
    518518    if( tr_ctorGetDownloadDir( ctor, TR_FORCE, NULL ) )
    519519    {
    520         const char * path = pref_string_get( TR_PREFS_KEY_DOWNLOAD_DIR );
     520        const char * path = gtr_pref_string_get( TR_PREFS_KEY_DOWNLOAD_DIR );
    521521        tr_ctorSetDownloadDir( ctor, TR_FORCE, path );
    522522    }
     
    668668scanWatchDir( TrCore * core )
    669669{
    670     const gboolean isEnabled = pref_flag_get( PREF_KEY_DIR_WATCH_ENABLED );
     670    const gboolean isEnabled = gtr_pref_flag_get( PREF_KEY_DIR_WATCH_ENABLED );
    671671
    672672    if( isEnabled )
    673673    {
    674         const char * dirname = pref_string_get( PREF_KEY_DIR_WATCH );
     674        const char * dirname = gtr_pref_string_get( PREF_KEY_DIR_WATCH );
    675675        GDir * dir = g_dir_open( dirname, 0, NULL );
    676676
     
    693693updateWatchDir( TrCore * core )
    694694{
    695     const char *           filename = pref_string_get( PREF_KEY_DIR_WATCH );
    696     const gboolean         isEnabled = pref_flag_get(
     695    const char *           filename = gtr_pref_string_get( PREF_KEY_DIR_WATCH );
     696    const gboolean         isEnabled = gtr_pref_flag_get(
    697697        PREF_KEY_DIR_WATCH_ENABLED );
    698698    struct TrCorePrivate * p = TR_CORE( core )->priv;
     
    732732      || !strcmp( key, PREF_KEY_SORT_REVERSED ) )
    733733    {
    734         const char * mode = pref_string_get( PREF_KEY_SORT_MODE );
    735         gboolean     isReversed = pref_flag_get( PREF_KEY_SORT_REVERSED );
     734        const char * mode = gtr_pref_string_get( PREF_KEY_SORT_MODE );
     735        gboolean     isReversed = gtr_pref_flag_get( PREF_KEY_SORT_REVERSED );
    736736        setSort( core, mode, isReversed );
    737737    }
    738738    else if( !strcmp( key, TR_PREFS_KEY_PEER_LIMIT_GLOBAL ) )
    739739    {
    740         const uint16_t val = pref_int_get( key );
     740        const uint16_t val = gtr_pref_int_get( key );
    741741        tr_sessionSetPeerLimit( tr_core_session( core ), val );
    742742    }
    743743    else if( !strcmp( key, TR_PREFS_KEY_PEER_LIMIT_TORRENT ) )
    744744    {
    745         const uint16_t val = pref_int_get( key );
     745        const uint16_t val = gtr_pref_int_get( key );
    746746        tr_sessionSetPeerLimitPerTorrent( tr_core_session( core ), val );
    747747    }
     
    860860    {
    861861        core->priv->session = NULL;
    862         pref_save( session );
     862        gtr_pref_save( session );
    863863        tr_sessionClose( session );
    864864    }
     
    925925        tr_ctorSetPaused( ctor, TR_FORCE, TRUE );
    926926    tr_ctorSetPeerLimit( ctor, TR_FALLBACK,
    927                          pref_int_get( TR_PREFS_KEY_PEER_LIMIT_TORRENT ) );
     927                         gtr_pref_int_get( TR_PREFS_KEY_PEER_LIMIT_TORRENT ) );
    928928
    929929    torrents = tr_sessionLoadTorrents ( tr_core_session( self ), ctor, &count );
     
    996996tr_core_add_ctor( TrCore * core, tr_ctor * ctor )
    997997{
    998     const gboolean doPrompt = pref_flag_get( PREF_KEY_OPTIONS_PROMPT );
     998    const gboolean doPrompt = gtr_pref_flag_get( PREF_KEY_OPTIONS_PROMPT );
    999999    const gboolean doNotify = FALSE;
    10001000    tr_core_apply_defaults( ctor );
     
    10251025        tr_ctor * ctor;
    10261026        char * file_contents;
    1027         gboolean do_prompt = pref_flag_get( PREF_KEY_OPTIONS_PROMPT );
     1027        gboolean do_prompt = gtr_pref_flag_get( PREF_KEY_OPTIONS_PROMPT );
    10281028
    10291029        ctor = tr_ctorNew( session );
     
    10651065    else
    10661066    {
    1067         const gboolean doPrompt = pref_flag_get( PREF_KEY_OPTIONS_PROMPT );
     1067        const gboolean doPrompt = gtr_pref_flag_get( PREF_KEY_OPTIONS_PROMPT );
    10681068        const gboolean doNotify = FALSE;
    10691069        const int err = add_ctor( data->core, data->ctor, doPrompt, doNotify );
     
    12111211tr_core_add_list_defaults( TrCore * core, GSList * torrentFiles, gboolean doNotify )
    12121212{
    1213     const gboolean doStart = pref_flag_get( TR_PREFS_KEY_START );
    1214     const gboolean doPrompt = pref_flag_get( PREF_KEY_OPTIONS_PROMPT );
     1213    const gboolean doStart = gtr_pref_flag_get( TR_PREFS_KEY_START );
     1214    const gboolean doPrompt = gtr_pref_flag_get( PREF_KEY_OPTIONS_PROMPT );
    12151215
    12161216    tr_core_add_list( core, torrentFiles, doStart, doPrompt, doNotify );
     
    15091509     * (a) the "inhibit" pref is turned off OR
    15101510     * (b) there aren't any active torrents */
    1511     const gboolean hibernation_allowed = !pref_flag_get( PREF_KEY_INHIBIT_HIBERNATION )
     1511    const gboolean hibernation_allowed = !gtr_pref_flag_get( PREF_KEY_INHIBIT_HIBERNATION )
    15121512                                      || !tr_core_get_active_torrent_count( core );
    15131513    tr_core_set_hibernation_allowed( core, hibernation_allowed );
     
    15221522{
    15231523    g_signal_emit( core, core_signals[PREFS_SIGNAL], 0, key );
    1524     pref_save( tr_core_session( core ) );
     1524    gtr_pref_save( tr_core_session( core ) );
    15251525}
    15261526
     
    15281528tr_core_set_pref( TrCore * self, const char * key, const char * newval )
    15291529{
    1530     const char * oldval = pref_string_get( key );
     1530    const char * oldval = gtr_pref_string_get( key );
    15311531
    15321532    if( gtr_strcmp0( oldval, newval ) )
    15331533    {
    1534         pref_string_set( key, newval );
     1534        gtr_pref_string_set( key, newval );
    15351535        commitPrefsChange( self, key );
    15361536    }
     
    15421542                       gboolean     newval )
    15431543{
    1544     const gboolean oldval = pref_flag_get( key );
     1544    const gboolean oldval = gtr_pref_flag_get( key );
    15451545
    15461546    if( oldval != newval )
    15471547    {
    1548         pref_flag_set( key, newval );
     1548        gtr_pref_flag_set( key, newval );
    15491549        commitPrefsChange( self, key );
    15501550    }
     
    15561556                      int          newval )
    15571557{
    1558     const int oldval = pref_int_get( key );
     1558    const int oldval = gtr_pref_int_get( key );
    15591559
    15601560    if( oldval != newval )
    15611561    {
    1562         pref_int_set( key, newval );
     1562        gtr_pref_int_set( key, newval );
    15631563        commitPrefsChange( self, key );
    15641564    }
     
    15701570                         double       newval )
    15711571{
    1572     const double oldval = pref_double_get( key );
     1572    const double oldval = gtr_pref_double_get( key );
    15731573
    15741574    if( gtr_compare_double( oldval, newval, 4 ) )
    15751575    {
    1576         pref_double_set( key, newval );
     1576        gtr_pref_double_set( key, newval );
    15771577        commitPrefsChange( self, key );
    15781578    }
     
    17071707
    17081708    if( ruleCount > 0 )
    1709         pref_int_set( "blocklist-date", time( NULL ) );
     1709        gtr_pref_int_set( "blocklist-date", time( NULL ) );
    17101710
    17111711    emitBlocklistUpdated( core, ruleCount );
  • trunk/gtk/tr-prefs.c

    r11567 r11572  
    6969                                key ), g_free );
    7070    gtk_toggle_button_set_active( GTK_TOGGLE_BUTTON( w ),
    71                                  pref_flag_get( key ) );
     71                                 gtr_pref_flag_get( key ) );
    7272    g_signal_connect( w, "toggled", G_CALLBACK( toggled_cb ), core );
    7373    return w;
     
    168168    g_object_set_data_full( G_OBJECT( w ), PREF_KEY, g_strdup( key ), g_free );
    169169    gtk_spin_button_set_digits( GTK_SPIN_BUTTON( w ), 0 );
    170     gtk_spin_button_set_value( GTK_SPIN_BUTTON( w ), pref_int_get( key ) );
     170    gtk_spin_button_set_value( GTK_SPIN_BUTTON( w ), gtr_pref_int_get( key ) );
    171171    g_signal_connect( w, "value-changed", G_CALLBACK( spun_cb_int ), core );
    172172    return w;
     
    183183    g_object_set_data_full( G_OBJECT( w ), PREF_KEY, g_strdup( key ), g_free );
    184184    gtk_spin_button_set_digits( GTK_SPIN_BUTTON( w ), 2 );
    185     gtk_spin_button_set_value( GTK_SPIN_BUTTON( w ), pref_double_get( key ) );
     185    gtk_spin_button_set_value( GTK_SPIN_BUTTON( w ), gtr_pref_double_get( key ) );
    186186    g_signal_connect( w, "value-changed", G_CALLBACK( spun_cb_double ), core );
    187187    return w;
     
    202202{
    203203    GtkWidget *  w = gtk_entry_new( );
    204     const char * value = pref_string_get( key );
     204    const char * value = gtr_pref_string_get( key );
    205205
    206206    if( value )
     
    225225{
    226226    GtkWidget *  w = gtk_file_chooser_button_new( NULL, GTK_FILE_CHOOSER_ACTION_SELECT_FOLDER );
    227     const char * path = pref_string_get( key );
     227    const char * path = gtr_pref_string_get( key );
    228228    g_object_set_data_full( G_OBJECT( w ), PREF_KEY, g_strdup( key ), g_free );
    229229    g_signal_connect( w, "selection-changed", G_CALLBACK( chosen_cb ), core );
     
    237237{
    238238    GtkWidget *  w = gtk_file_chooser_button_new( NULL, GTK_FILE_CHOOSER_ACTION_OPEN );
    239     const char * path = pref_string_get( key );
     239    const char * path = gtr_pref_string_get( key );
    240240    g_object_set_data_full( G_OBJECT( w ), PREF_KEY, g_strdup( key ), g_free );
    241241    if( path != NULL )
     
    287287    w = new_path_chooser_button( PREF_KEY_DIR_WATCH, core );
    288288    gtk_widget_set_sensitive( GTK_WIDGET( w ),
    289                              pref_flag_get( PREF_KEY_DIR_WATCH_ENABLED ) );
     289                             gtr_pref_flag_get( PREF_KEY_DIR_WATCH_ENABLED ) );
    290290    g_signal_connect( l, "toggled", G_CALLBACK( target_cb ), w );
    291291    hig_workarea_add_row_w( t, &row, l, w, NULL );
     
    305305    l = new_check_button( s, TR_PREFS_KEY_INCOMPLETE_DIR_ENABLED, core );
    306306    w = new_path_chooser_button( TR_PREFS_KEY_INCOMPLETE_DIR, core );
    307     gtk_widget_set_sensitive( GTK_WIDGET( w ), pref_flag_get( TR_PREFS_KEY_INCOMPLETE_DIR_ENABLED ) );
     307    gtk_widget_set_sensitive( GTK_WIDGET( w ), gtr_pref_flag_get( TR_PREFS_KEY_INCOMPLETE_DIR_ENABLED ) );
    308308    g_signal_connect( l, "toggled", G_CALLBACK( target_cb ), w );
    309309    hig_workarea_add_row_w( t, &row, l, w, NULL );
     
    312312    l = new_check_button( s, TR_PREFS_KEY_SCRIPT_TORRENT_DONE_ENABLED, core );
    313313    w = new_file_chooser_button( TR_PREFS_KEY_SCRIPT_TORRENT_DONE_FILENAME, core );
    314     gtk_widget_set_sensitive( GTK_WIDGET( w ), pref_flag_get( TR_PREFS_KEY_SCRIPT_TORRENT_DONE_ENABLED ) );
     314    gtk_widget_set_sensitive( GTK_WIDGET( w ), gtr_pref_flag_get( TR_PREFS_KEY_SCRIPT_TORRENT_DONE_ENABLED ) );
    315315    g_signal_connect( l, "toggled", G_CALLBACK( target_cb ), w );
    316316    hig_workarea_add_row_w( t, &row, l, w, NULL );
     
    322322    w = new_check_button( s, TR_PREFS_KEY_RATIO_ENABLED, core );
    323323    w2 = new_spin_button_double( TR_PREFS_KEY_RATIO, core, 0, 1000, .05 );
    324     gtk_widget_set_sensitive( GTK_WIDGET( w2 ), pref_flag_get( TR_PREFS_KEY_RATIO_ENABLED ) );
     324    gtk_widget_set_sensitive( GTK_WIDGET( w2 ), gtr_pref_flag_get( TR_PREFS_KEY_RATIO_ENABLED ) );
    325325    g_signal_connect( w, "toggled", G_CALLBACK( target_cb ), w2 );
    326326    hig_workarea_add_row_w( t, &row, w, w2, NULL );
     
    329329    w = new_check_button( s, TR_PREFS_KEY_IDLE_LIMIT_ENABLED, core );
    330330    w2 = new_spin_button( TR_PREFS_KEY_IDLE_LIMIT, core, 1, 9999, 5 );
    331     gtk_widget_set_sensitive( GTK_WIDGET( w2 ), pref_flag_get( TR_PREFS_KEY_IDLE_LIMIT_ENABLED ) );
     331    gtk_widget_set_sensitive( GTK_WIDGET( w2 ), gtr_pref_flag_get( TR_PREFS_KEY_IDLE_LIMIT_ENABLED ) );
    332332    g_signal_connect( w, "toggled", G_CALLBACK( target_cb ), w2 );
    333333    hig_workarea_add_row_w( t, &row, w, w2, NULL );
     
    472472                                            _( "Require encryption" ), TR_ENCRYPTION_REQUIRED,
    473473                                            NULL );
    474     gtr_combo_box_set_active_enum( GTK_COMBO_BOX( w ), pref_int_get( key ) );
     474    gtr_combo_box_set_active_enum( GTK_COMBO_BOX( w ), gtr_pref_int_get( key ) );
    475475    g_object_set_data_full( G_OBJECT( w ), PREF_KEY, tr_strdup( key ), g_free );
    476476    g_signal_connect( w, "changed", G_CALLBACK( onIntComboChanged ), core );
     
    730730onLaunchClutchCB( GtkButton * w UNUSED, gpointer data UNUSED )
    731731{
    732     const int port = pref_int_get( TR_PREFS_KEY_RPC_PORT );
     732    const int port = gtr_pref_int_get( TR_PREFS_KEY_RPC_PORT );
    733733    char * uri = g_strdup_printf( "http://localhost:%d/transmission/web", port );
    734734
     
    817817    /* access control list */
    818818    {
    819         const char *        val = pref_string_get( TR_PREFS_KEY_RPC_WHITELIST );
     819        const char *        val = gtr_pref_string_get( TR_PREFS_KEY_RPC_WHITELIST );
    820820        GtkTreeModel *      m = whitelist_tree_model_new( val );
    821821        GtkTreeViewColumn * c;
     
    898898{
    899899    GSList *       l;
    900     const gboolean sched_enabled = pref_flag_get( TR_PREFS_KEY_ALT_SPEED_TIME_ENABLED );
     900    const gboolean sched_enabled = gtr_pref_flag_get( TR_PREFS_KEY_ALT_SPEED_TIME_ENABLED );
    901901
    902902    for( l = p->sched_widgets; l != NULL; l = l->next )
     
    961961    g_object_set_data_full( G_OBJECT( w ), PREF_KEY, tr_strdup(
    962962                                key ), g_free );
    963     val = pref_int_get( key );
     963    val = gtr_pref_int_get( key );
    964964    gtk_combo_box_set_active( GTK_COMBO_BOX( w ), val / ( 15 ) );
    965965    g_signal_connect( w, "changed", G_CALLBACK( onTimeComboChanged ), core );
     
    984984                                            _( "Saturday" ),  TR_SCHED_SAT,
    985985                                            NULL );
    986     gtr_combo_box_set_active_enum( GTK_COMBO_BOX( w ), pref_int_get( key ) );
     986    gtr_combo_box_set_active_enum( GTK_COMBO_BOX( w ), gtr_pref_int_get( key ) );
    987987    g_object_set_data_full( G_OBJECT( w ), PREF_KEY, tr_strdup( key ), g_free );
    988988    g_signal_connect( w, "changed", G_CALLBACK( onIntComboChanged ), core );
     
    10181018        w = new_check_button( buf, TR_PREFS_KEY_USPEED_ENABLED, core );
    10191019        w2 = new_spin_button( TR_PREFS_KEY_USPEED_KBps, core, 0, INT_MAX, 5 );
    1020         gtk_widget_set_sensitive( GTK_WIDGET( w2 ), pref_flag_get( TR_PREFS_KEY_USPEED_ENABLED ) );
     1020        gtk_widget_set_sensitive( GTK_WIDGET( w2 ), gtr_pref_flag_get( TR_PREFS_KEY_USPEED_ENABLED ) );
    10211021        g_signal_connect( w, "toggled", G_CALLBACK( target_cb ), w2 );
    10221022        hig_workarea_add_row_w( t, &row, w, w2, NULL );
     
    10251025        w = new_check_button( buf, TR_PREFS_KEY_DSPEED_ENABLED, core );
    10261026        w2 = new_spin_button( TR_PREFS_KEY_DSPEED_KBps, core, 0, INT_MAX, 5 );
    1027         gtk_widget_set_sensitive( GTK_WIDGET( w2 ), pref_flag_get( TR_PREFS_KEY_DSPEED_ENABLED ) );
     1027        gtk_widget_set_sensitive( GTK_WIDGET( w2 ), gtr_pref_flag_get( TR_PREFS_KEY_DSPEED_ENABLED ) );
    10281028        g_signal_connect( w, "toggled", G_CALLBACK( target_cb ), w2 );
    10291029        hig_workarea_add_row_w( t, &row, w, w2, NULL );
  • trunk/gtk/tr-window.c

    r11563 r11572  
    174174    if( !strcmp( key, PREF_KEY_COMPACT_VIEW ) )
    175175    {
    176         g_object_set( p->renderer, "compact", pref_flag_get( key ), NULL );
     176        g_object_set( p->renderer, "compact", gtr_pref_flag_get( key ), NULL );
    177177        /* since the cell size has changed, we need gtktreeview to revalidate
    178178         * its fixed-height mode values.  Unfortunately there's not an API call
     
    182182    else if( !strcmp( key, PREF_KEY_STATUSBAR ) )
    183183    {
    184         const gboolean isEnabled = pref_flag_get( key );
     184        const gboolean isEnabled = gtr_pref_flag_get( key );
    185185        g_object_set( p->status, "visible", isEnabled, NULL );
    186186    }
    187187    else if( !strcmp( key, PREF_KEY_FILTERBAR ) )
    188188    {
    189         const gboolean isEnabled = pref_flag_get( key );
     189        const gboolean isEnabled = gtr_pref_flag_get( key );
    190190        g_object_set( p->filter, "visible", isEnabled, NULL );
    191191    }
    192192    else if( !strcmp( key, PREF_KEY_TOOLBAR ) )
    193193    {
    194         const gboolean isEnabled = pref_flag_get( key );
     194        const gboolean isEnabled = gtr_pref_flag_get( key );
    195195        g_object_set( p->toolbar, "visible", isEnabled, NULL );
    196196    }
     
    257257    char * str;
    258258    const char * fmt;
    259     const gboolean b = pref_flag_get( TR_PREFS_KEY_ALT_SPEED_ENABLED );
     259    const gboolean b = gtr_pref_flag_get( TR_PREFS_KEY_ALT_SPEED_ENABLED );
    260260    const char * stock = b ? "alt-speed-on" : "alt-speed-off";
    261261    GtkWidget * w = p->alt_speed_button;
    262262
    263     tr_formatter_speed_KBps( u, pref_int_get( TR_PREFS_KEY_ALT_SPEED_UP_KBps ), sizeof( u ) );
    264     tr_formatter_speed_KBps( d, pref_int_get( TR_PREFS_KEY_ALT_SPEED_DOWN_KBps ), sizeof( d ) );
     263    tr_formatter_speed_KBps( u, gtr_pref_int_get( TR_PREFS_KEY_ALT_SPEED_UP_KBps ), sizeof( u ) );
     264    tr_formatter_speed_KBps( d, gtr_pref_int_get( TR_PREFS_KEY_ALT_SPEED_DOWN_KBps ), sizeof( d ) );
    265265    fmt = b ? _( "Click to disable Alternative Speed Limits\n(%1$s down, %2$s up)" )
    266266            : _( "Click to enable Alternative Speed Limits\n(%1$s down, %2$s up)" );
     
    536536
    537537    w = p->speedlimit_on_item[TR_DOWN];
    538     tr_formatter_speed_KBps( buf1, pref_int_get( TR_PREFS_KEY_DSPEED_KBps ), sizeof( buf1 ) );
     538    tr_formatter_speed_KBps( buf1, gtr_pref_int_get( TR_PREFS_KEY_DSPEED_KBps ), sizeof( buf1 ) );
    539539    gtk_label_set_text( GTK_LABEL( gtk_bin_get_child( GTK_BIN( w ) ) ), buf1 );
    540540
    541     b = pref_flag_get( TR_PREFS_KEY_DSPEED_ENABLED );
     541    b = gtr_pref_flag_get( TR_PREFS_KEY_DSPEED_ENABLED );
    542542    w = b ? p->speedlimit_on_item[TR_DOWN] : p->speedlimit_off_item[TR_DOWN];
    543543    gtk_check_menu_item_set_active( GTK_CHECK_MENU_ITEM( w ), TRUE );
    544544
    545545    w = p->speedlimit_on_item[TR_UP];
    546     tr_formatter_speed_KBps( buf1, pref_int_get( TR_PREFS_KEY_USPEED_KBps ), sizeof( buf1 ) );
     546    tr_formatter_speed_KBps( buf1, gtr_pref_int_get( TR_PREFS_KEY_USPEED_KBps ), sizeof( buf1 ) );
    547547    gtk_label_set_text( GTK_LABEL( gtk_bin_get_child( GTK_BIN( w ) ) ), buf1 );
    548548
    549     b = pref_flag_get( TR_PREFS_KEY_USPEED_ENABLED );
     549    b = gtr_pref_flag_get( TR_PREFS_KEY_USPEED_ENABLED );
    550550    w = b ? p->speedlimit_on_item[TR_UP] : p->speedlimit_off_item[TR_UP];
    551551    gtk_check_menu_item_set_active( GTK_CHECK_MENU_ITEM( w ), TRUE );
    552552
    553     tr_strlratio( buf1, pref_double_get( TR_PREFS_KEY_RATIO ), sizeof( buf1 ) );
     553    tr_strlratio( buf1, gtr_pref_double_get( TR_PREFS_KEY_RATIO ), sizeof( buf1 ) );
    554554    g_snprintf( buf2, sizeof( buf2 ), _( "Stop at Ratio (%s)" ), buf1 );
    555555    gtk_label_set_text( GTK_LABEL( gtk_bin_get_child( GTK_BIN( p->ratio_on_item ) ) ), buf2 );
    556556
    557     b = pref_flag_get( TR_PREFS_KEY_RATIO_ENABLED );
     557    b = gtr_pref_flag_get( TR_PREFS_KEY_RATIO_ENABLED );
    558558    gtk_check_menu_item_set_active( GTK_CHECK_MENU_ITEM( b ? p->ratio_on_item : p->ratio_off_item ), TRUE );
    559559
     
    586586    gtk_window_set_role( win, "tr-main" );
    587587    gtk_window_set_default_size( win,
    588                                  pref_int_get( PREF_KEY_MAIN_WINDOW_WIDTH ),
    589                                  pref_int_get( PREF_KEY_MAIN_WINDOW_HEIGHT ) );
    590     gtk_window_move( win, pref_int_get( PREF_KEY_MAIN_WINDOW_X ),
    591                           pref_int_get( PREF_KEY_MAIN_WINDOW_Y ) );
    592     if( pref_flag_get( PREF_KEY_MAIN_WINDOW_IS_MAXIMIZED ) )
     588                                 gtr_pref_int_get( PREF_KEY_MAIN_WINDOW_WIDTH ),
     589                                 gtr_pref_int_get( PREF_KEY_MAIN_WINDOW_HEIGHT ) );
     590    gtk_window_move( win, gtr_pref_int_get( PREF_KEY_MAIN_WINDOW_X ),
     591                          gtr_pref_int_get( PREF_KEY_MAIN_WINDOW_Y ) );
     592    if( gtr_pref_flag_get( PREF_KEY_MAIN_WINDOW_IS_MAXIMIZED ) )
    593593        gtk_window_maximize( win );
    594594    gtk_window_add_accel_group( win, gtk_ui_manager_get_accel_group( ui_mgr ) );
     
    620620    menu = p->status_menu = gtk_menu_new( );
    621621    l = NULL;
    622     pch = pref_string_get( PREF_KEY_STATUSBAR_STATS );
     622    pch = gtr_pref_string_get( PREF_KEY_STATUSBAR_STATS );
    623623    for( i = 0, n = G_N_ELEMENTS( stats_modes ); i < n; ++i )
    624624    {
     
    773773
    774774    /* update the stats */
    775     pch = pref_string_get( PREF_KEY_STATUSBAR_STATS );
     775    pch = gtr_pref_string_get( PREF_KEY_STATUSBAR_STATS );
    776776    if( !strcmp( pch, "session-ratio" ) )
    777777    {
Note: See TracChangeset for help on using the changeset viewer.