mirror
/
transmission
mirror of https://github.com/transmission/transmission
1
0
Fork 0
Code Issues Releases Wiki Activity

(trunk gtk) more gtr_ naming cleanup

This commit is contained in:
Charles Kerr 2010-12-22 06:25:30 +00:00
parent b86e1e1056
commit 057487d18e
16 changed files with 200 additions and 208 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
gtk/actions.c
View File

@ -213,7 +213,7 @@ gtr_actions_init( GtkUIManager * ui_manager, gpointer callback_user_data )
gtk_action_group_set_translation_domain( action_group, NULL );
match = pref_string_get( PREF_KEY_SORT_MODE );
match = gtr_pref_string_get( PREF_KEY_SORT_MODE );
for( i = 0, n = G_N_ELEMENTS( sort_radio_entries ), active = -1;
active == -1 && i < n; ++i )
if( !strcmp( sort_radio_entries[i].name, match ) )
@ -233,7 +233,7 @@ gtr_actions_init( GtkUIManager * ui_manager, gpointer callback_user_data )
for( i = 0, n = G_N_ELEMENTS( pref_toggle_entries ); i < n; ++i )
pref_toggle_entries[i].is_active =
pref_flag_get( pref_toggle_entries[i].name );
gtr_pref_flag_get( pref_toggle_entries[i].name );
gtk_action_group_add_toggle_actions( action_group,
pref_toggle_entries,

24
gtk/add-dialog.c
View File

@ -38,7 +38,7 @@ get_recent_destinations( void )
char key[64];
const char * val;
g_snprintf( key, sizeof( key ), "recent-download-dir-%d", i+1 );
if(( val = pref_string_get( key )))
if(( val = gtr_pref_string_get( key )))
list = g_slist_append( list, (void*)val );
}
return list;
@ -62,7 +62,7 @@ save_recent_destination( TrCore * core, const char * dir )
list = g_slist_prepend( list, (void*)dir );
/* make local copies of the strings that aren't
* invalidated by pref_string_set() */
* invalidated by gtr_pref_string_set() */
for( l=list; l; l=l->next )
l->data = g_strdup( l->data );
@ -70,9 +70,9 @@ save_recent_destination( TrCore * core, const char * dir )
for( l=list, i=0; l && ( i<N_RECENT ); ++i, l=l->next ) {
char key[64];
g_snprintf( key, sizeof( key ), "recent-download-dir-%d", i + 1 );
pref_string_set( key, l->data );
gtr_pref_string_set( key, l->data );
}
pref_save( tr_core_session( core ) );
gtr_pref_save( tr_core_session( core ) );
/* cleanup */
g_slist_foreach( list, (GFunc)g_free, NULL );
@ -101,7 +101,7 @@ removeOldTorrent( struct AddData * data )
{
if( data->gtor )
{
file_list_clear( data->file_list );
gtr_file_list_clear( data->file_list );
tr_torrent_set_remove_flag( data->gtor, TRUE );
g_object_unref( G_OBJECT( data->gtor ) );
data->gtor = NULL;
@ -154,7 +154,7 @@ updateTorrent( struct AddData * o )
if( !o->gtor )
{
file_list_clear( o->file_list );
gtr_file_list_clear( o->file_list );
gtk_widget_set_sensitive( o->file_list, FALSE );
}
else
@ -162,7 +162,7 @@ updateTorrent( struct AddData * o )
tr_torrent * tor = tr_torrent_handle( o->gtor );
tr_torrentSetDownloadDir( tor, o->downloadDir );
gtk_widget_set_sensitive( o->file_list, tr_torrentHasMetadata( tor ) );
file_list_set_torrent( o->file_list, tr_torrentId( tor ) );
gtr_file_list_set_torrent( o->file_list, tr_torrentId( tor ) );
tr_torrentVerify( tor );
}
}
@ -291,7 +291,7 @@ gtr_torrent_options_dialog_new( GtkWindow * parent, TrCore * core, tr_ctor * cto
data->ctor = ctor;
data->filename = g_strdup( tr_ctorGetSourceFile( ctor ) );
data->downloadDir = g_strdup( str );
data->file_list = file_list_new( core, 0 );
data->file_list = gtr_file_list_new( core, 0 );
str = _( "Mo_ve .torrent file to the trash" );
data->trash_check = gtk_check_button_new_with_mnemonic( str );
str = _( "_Start when added" );
@ -399,7 +399,7 @@ onAddDialogResponse( GtkDialog * dialog,
/* remember this folder the next time we use this dialog */
folder = gtk_file_chooser_get_current_folder( GTK_FILE_CHOOSER( dialog ) );
pref_string_set( PREF_KEY_OPEN_DIALOG_FOLDER, folder );
gtr_pref_string_set( PREF_KEY_OPEN_DIALOG_FOLDER, folder );
g_free( folder );
if( response == GTK_RESPONSE_ACCEPT )
@ -407,7 +407,7 @@ onAddDialogResponse( GtkDialog * dialog,
GtkFileChooser * chooser = GTK_FILE_CHOOSER( dialog );
GtkWidget * w = gtk_file_chooser_get_extra_widget( chooser );
GtkToggleButton * tb = GTK_TOGGLE_BUTTON( w );
const gboolean doStart = pref_flag_get( TR_PREFS_KEY_START );
const gboolean doStart = gtr_pref_flag_get( TR_PREFS_KEY_START );
const gboolean doPrompt = gtk_toggle_button_get_active( tb );
const gboolean doNotify = FALSE;
GSList * l = gtk_file_chooser_get_filenames( chooser );
@ -439,12 +439,12 @@ gtr_torrent_add_from_file_dialog_new( GtkWindow * parent, TrCore * core )
g_signal_connect( w, "response", G_CALLBACK(
onAddDialogResponse ), core );
if( ( folder = pref_string_get( PREF_KEY_OPEN_DIALOG_FOLDER ) ) )
if( ( folder = gtr_pref_string_get( PREF_KEY_OPEN_DIALOG_FOLDER ) ) )
gtk_file_chooser_set_current_folder( GTK_FILE_CHOOSER( w ), folder );
c = gtk_check_button_new_with_mnemonic( _( "Show _options dialog" ) );
gtk_toggle_button_set_active( GTK_TOGGLE_BUTTON( c ),
pref_flag_get( PREF_KEY_OPTIONS_PROMPT ) );
gtr_pref_flag_get( PREF_KEY_OPTIONS_PROMPT ) );
gtk_file_chooser_set_extra_widget( GTK_FILE_CHOOSER( w ), c );
gtk_widget_show( c );

20
gtk/conf.c
View File

@ -229,13 +229,13 @@ getPrefs( void )
***/
tr_benc*
pref_get_all( void )
gtr_pref_get_all( void )
{
return getPrefs( );
}
int64_t
pref_int_get( const char * key )
gtr_pref_int_get( const char * key )
{
int64_t i = 0;
@ -244,13 +244,13 @@ pref_int_get( const char * key )
}
void
pref_int_set( const char * key, int64_t value )
gtr_pref_int_set( const char * key, int64_t value )
{
tr_bencDictAddInt( getPrefs( ), key, value );
}
double
pref_double_get( const char * key )
gtr_pref_double_get( const char * key )
{
double d = 0.0;
tr_bencDictFindReal( getPrefs( ), key, &d );
@ -258,7 +258,7 @@ pref_double_get( const char * key )
}
void
pref_double_set( const char * key, double value )
gtr_pref_double_set( const char * key, double value )
{
tr_bencDictAddReal( getPrefs( ), key, value );
}
@ -268,7 +268,7 @@ pref_double_set( const char * key, double value )
***/
gboolean
pref_flag_get( const char * key )
gtr_pref_flag_get( const char * key )
{
tr_bool boolVal;
tr_bencDictFindBool( getPrefs( ), key, &boolVal );
@ -276,7 +276,7 @@ pref_flag_get( const char * key )
}
void
pref_flag_set( const char * key, gboolean value )
gtr_pref_flag_set( const char * key, gboolean value )
{
tr_bencDictAddBool( getPrefs( ), key, value );
}
@ -286,7 +286,7 @@ pref_flag_set( const char * key, gboolean value )
***/
const char*
pref_string_get( const char * key )
gtr_pref_string_get( const char * key )
{
const char * str = NULL;
tr_bencDictFindStr( getPrefs( ), key, &str );
@ -294,7 +294,7 @@ pref_string_get( const char * key )
}
void
pref_string_set( const char * key, const char * value )
gtr_pref_string_set( const char * key, const char * value )
{
tr_bencDictAddStr( getPrefs( ), key, value );
}
@ -304,7 +304,7 @@ pref_string_set( const char * key, const char * value )
***/
void
pref_save( tr_session * session )
gtr_pref_save( tr_session * session )
{
tr_sessionSaveSettings( session, gl_confdir, getPrefs( ) );
}

30
gtk/conf.h
View File

@ -29,33 +29,27 @@
#include <libtransmission/transmission.h>
#include "util.h" /* gtr_lockfile */
int64_t pref_int_get ( const char * key );
void pref_int_set ( const char * key, int64_t value );
int64_t gtr_pref_int_get ( const char * key );
void gtr_pref_int_set ( const char * key, int64_t value );
double pref_double_get ( const char * key );
void pref_double_set ( const char * key, double value );
double gtr_pref_double_get ( const char * key );
void gtr_pref_double_set ( const char * key, double value );
gboolean pref_flag_get ( const char * key );
void pref_flag_set ( const char * key, gboolean value );
gboolean gtr_pref_flag_get ( const char * key );
void gtr_pref_flag_set ( const char * key, gboolean value );
const char* pref_string_get ( const char * key );
void pref_string_set ( const char * key, const char * value );
const char* gtr_pref_string_get ( const char * key );
void gtr_pref_string_set ( const char * key, const char * value );
void pref_save ( tr_session * );
struct tr_benc* pref_get_all ( void );
void gtr_pref_save ( tr_session * );
struct tr_benc* gtr_pref_get_all ( void );
/**
***
**/
/**
***
**/
gboolean cf_init( const char *confdir, char ** errstr );
gboolean cf_init( const char *confdir,
char ** errstr );
gboolean cf_lock( gtr_lockfile_state_t * tr_state,
char ** errstr );
gboolean cf_lock( gtr_lockfile_state_t * tr_state, char ** errstr );
#endif /* GTR_CONFIG_H */

14
gtk/details.c
View File

@ -1501,7 +1501,7 @@ setPeerViewColumns( GtkTreeView * peer_view )
{
int i;
int n = 0;
const tr_bool more = pref_flag_get( PREF_KEY_SHOW_MORE_PEER_INFO );
const tr_bool more = gtr_pref_flag_get( PREF_KEY_SHOW_MORE_PEER_INFO );
int view_columns[32];
GtkTreeViewColumn * c;
GtkCellRenderer * r;
@ -1738,7 +1738,7 @@ peer_page_new( struct DetailsImpl * di )
w = gtk_check_button_new_with_mnemonic( _( "Show _more details" ) );
di->more_peer_details_check = w;
b = pref_flag_get( PREF_KEY_SHOW_MORE_PEER_INFO );
b = gtr_pref_flag_get( PREF_KEY_SHOW_MORE_PEER_INFO );
gtk_toggle_button_set_active( GTK_TOGGLE_BUTTON( w ), b );
g_signal_connect( w, "toggled", G_CALLBACK( onMorePeerInfoToggled ), di );
gtk_box_pack_start( GTK_BOX( vbox ), w, FALSE, FALSE, 0 );
@ -2257,7 +2257,7 @@ tracker_page_new( struct DetailsImpl * di )
w = gtk_check_button_new_with_mnemonic( _( "Show _more details" ) );
di->scrape_check = w;
b = pref_flag_get( PREF_KEY_SHOW_MORE_TRACKER_INFO );
b = gtr_pref_flag_get( PREF_KEY_SHOW_MORE_TRACKER_INFO );
gtk_toggle_button_set_active( GTK_TOGGLE_BUTTON( w ), b );
g_signal_connect( w, "toggled", G_CALLBACK( onScrapeToggled ), di );
gtk_box_pack_start( GTK_BOX( hbox ), w, FALSE, FALSE, 0 );
@ -2272,7 +2272,7 @@ tracker_page_new( struct DetailsImpl * di )
w = gtk_check_button_new_with_mnemonic( _( "Show _backup trackers" ) );
di->all_check = w;
b = pref_flag_get( PREF_KEY_SHOW_BACKUP_TRACKERS );
b = gtr_pref_flag_get( PREF_KEY_SHOW_BACKUP_TRACKERS );
gtk_toggle_button_set_active( GTK_TOGGLE_BUTTON( w ), b );
g_signal_connect( w, "toggled", G_CALLBACK( onBackupToggled ), di );
gtk_box_pack_start( GTK_BOX( vbox ), w, FALSE, FALSE, 0 );
@ -2355,7 +2355,7 @@ gtr_torrent_details_dialog_new( GtkWindow * parent, TrCore * core )
{
GtkWidget * v = gtk_vbox_new( FALSE, 0 );
di->file_list = file_list_new( core, 0 );
di->file_list = gtr_file_list_new( core, 0 );
di->file_label = gtk_label_new( _( "File listing not available for combined torrent properties" ) );
gtk_box_pack_start( GTK_BOX( v ), di->file_list, TRUE, TRUE, 0 );
gtk_box_pack_start( GTK_BOX( v ), di->file_label, TRUE, TRUE, 0 );
@ -2392,13 +2392,13 @@ gtr_torrent_details_dialog_set_torrents( GtkWidget * w, GSList * ids )
const tr_info * inf = tr_torrentInfo( tor );
g_snprintf( title, sizeof( title ), _( "%s Properties" ), inf->name );
file_list_set_torrent( di->file_list, id );
gtr_file_list_set_torrent( di->file_list, id );
gtk_widget_show( di->file_list );
gtk_widget_hide( di->file_label );
}
else
{
file_list_clear( di->file_list );
gtr_file_list_clear( di->file_list );
gtk_widget_hide( di->file_list );
gtk_widget_show( di->file_label );
g_snprintf( title, sizeof( title ), _( "%'d Torrent Properties" ), len );

12
gtk/file-list.c
View File

@ -241,7 +241,7 @@ refresh( FileData * data )
if( tor == NULL )
{
file_list_clear( data->top );
gtr_file_list_clear( data->top );
}
else
{
@ -400,9 +400,9 @@ getActiveFilesForPath( GtkTreeView * view, GtkTreePath * path )
***/
void
file_list_clear( GtkWidget * w )
gtr_file_list_clear( GtkWidget * w )
{
file_list_set_torrent( w, -1 );
gtr_file_list_set_torrent( w, -1 );
}
struct build_data
@ -482,7 +482,7 @@ find_child( GNode* parent, const char * name )
}
void
file_list_set_torrent( GtkWidget * w, int torrentId )
gtr_file_list_set_torrent( GtkWidget * w, int torrentId )
{
GtkTreeStore * store;
FileData * data = g_object_get_data( G_OBJECT( w ), "file-data" );
@ -774,7 +774,7 @@ onViewButtonPressed( GtkWidget * w, GdkEventButton * event, gpointer gdata )
}
GtkWidget *
file_list_new( TrCore * core, int torrentId )
gtr_file_list_new( TrCore * core, int torrentId )
{
int width;
GtkWidget * ret;
@ -883,7 +883,7 @@ file_list_new( TrCore * core, int torrentId )
data->view = view;
data->top = scroll;
g_object_set_data_full( G_OBJECT( ret ), "file-data", data, freeData );
file_list_set_torrent( ret, torrentId );
gtr_file_list_set_torrent( ret, torrentId );
return ret;
}

8
gtk/file-list.h
View File

@ -16,10 +16,8 @@
#include <gtk/gtk.h>
#include "tr-core.h"
GtkWidget * file_list_new( TrCore *, int torrentId );
void file_list_clear( GtkWidget * );
void file_list_set_torrent( GtkWidget *, int torrentId );
GtkWidget * gtr_file_list_new ( TrCore *, int torrent_id );
void gtr_file_list_clear ( GtkWidget * );
void gtr_file_list_set_torrent ( GtkWidget *, int torrent_id );
#endif

6
gtk/icons.h
View File

@ -13,8 +13,8 @@
const char * gtr_get_mime_type_from_filename( const char *file );
GdkPixbuf * gtr_get_mime_type_icon( const char * mime_type,
GtkIconSize icon_size,
GtkWidget * for_widget );
GdkPixbuf * gtr_get_mime_type_icon( const char * mime_type,
GtkIconSize icon_size,
GtkWidget * for_widget );
#endif

134
gtk/main.c
View File

@ -358,17 +358,17 @@ onMainWindowSizeAllocated( GtkWidget * window,
&& ( gdk_window_get_state( window->window )
& GDK_WINDOW_STATE_MAXIMIZED );
pref_int_set( PREF_KEY_MAIN_WINDOW_IS_MAXIMIZED, isMaximized );
gtr_pref_int_set( PREF_KEY_MAIN_WINDOW_IS_MAXIMIZED, isMaximized );
if( !isMaximized )
{
int x, y, w, h;
gtk_window_get_position( GTK_WINDOW( window ), &x, &y );
gtk_window_get_size( GTK_WINDOW( window ), &w, &h );
pref_int_set( PREF_KEY_MAIN_WINDOW_X, x );
pref_int_set( PREF_KEY_MAIN_WINDOW_Y, y );
pref_int_set( PREF_KEY_MAIN_WINDOW_WIDTH, w );
pref_int_set( PREF_KEY_MAIN_WINDOW_HEIGHT, h );
gtr_pref_int_set( PREF_KEY_MAIN_WINDOW_X, x );
gtr_pref_int_set( PREF_KEY_MAIN_WINDOW_Y, y );
gtr_pref_int_set( PREF_KEY_MAIN_WINDOW_WIDTH, w );
gtr_pref_int_set( PREF_KEY_MAIN_WINDOW_HEIGHT, h );
}
}
@ -448,7 +448,7 @@ onRPCChanged( tr_session * session,
int i;
tr_benc tmp;
tr_benc * newval;
tr_benc * oldvals = pref_get_all( );
tr_benc * oldvals = gtr_pref_get_all( );
const char * key;
GSList * l;
GSList * changed_keys = NULL;
@ -727,7 +727,7 @@ main( int argc, char ** argv )
* if that goes well, then our work is done. */
GSList * l;
gboolean delegated = FALSE;
const gboolean trash_originals = pref_flag_get( TR_PREFS_KEY_TRASH_ORIGINAL );
const gboolean trash_originals = gtr_pref_flag_get( TR_PREFS_KEY_TRASH_ORIGINAL );
for( l=argfiles; l!=NULL; l=l->next )
{
@ -774,17 +774,17 @@ main( int argc, char ** argv )
sighandler_cbdata = cbdata;
/* ensure the directories are created */
if(( str = pref_string_get( TR_PREFS_KEY_DOWNLOAD_DIR )))
if(( str = gtr_pref_string_get( TR_PREFS_KEY_DOWNLOAD_DIR )))
gtr_mkdir_with_parents( str, 0777 );
if(( str = pref_string_get( TR_PREFS_KEY_INCOMPLETE_DIR )))
if(( str = gtr_pref_string_get( TR_PREFS_KEY_INCOMPLETE_DIR )))
gtr_mkdir_with_parents( str, 0777 );
/* initialize the libtransmission session */
session = tr_sessionInit( "gtk", configDir, TRUE, pref_get_all( ) );
session = tr_sessionInit( "gtk", configDir, TRUE, gtr_pref_get_all( ) );
tr_sessionSetWebConfigFunc( session, curlConfigFunc );
pref_flag_set( TR_PREFS_KEY_ALT_SPEED_ENABLED, tr_sessionUsesAltSpeed( session ) );
pref_int_set( TR_PREFS_KEY_PEER_PORT, tr_sessionGetPeerPort( session ) );
gtr_pref_flag_set( TR_PREFS_KEY_ALT_SPEED_ENABLED, tr_sessionUsesAltSpeed( session ) );
gtr_pref_int_set( TR_PREFS_KEY_PEER_PORT, tr_sessionGetPeerPort( session ) );
cbdata->core = tr_core_new( session );
/* init the ui manager */
@ -802,9 +802,9 @@ main( int argc, char ** argv )
tr_sessionSetRPCCallback( session, onRPCChanged, cbdata );
/* on startup, check & see if it's time to update the blocklist */
if( pref_flag_get( TR_PREFS_KEY_BLOCKLIST_ENABLED ) ) {
if( pref_flag_get( PREF_KEY_BLOCKLIST_UPDATES_ENABLED ) ) {
const int64_t last_time = pref_int_get( "blocklist-date" );
if( gtr_pref_flag_get( TR_PREFS_KEY_BLOCKLIST_ENABLED ) ) {
if( gtr_pref_flag_get( PREF_KEY_BLOCKLIST_UPDATES_ENABLED ) ) {
const int64_t last_time = gtr_pref_int_get( "blocklist-date" );
const int SECONDS_IN_A_WEEK = 7 * 24 * 60 * 60;
const time_t now = time( NULL );
if( last_time + SECONDS_IN_A_WEEK < now )
@ -844,8 +844,8 @@ appsetup( TrWindow * wind,
gboolean forcepause,
gboolean isIconified )
{
const gboolean doStart = pref_flag_get( TR_PREFS_KEY_START ) && !forcepause;
const gboolean doPrompt = pref_flag_get( PREF_KEY_OPTIONS_PROMPT );
const gboolean doStart = gtr_pref_flag_get( TR_PREFS_KEY_START ) && !forcepause;
const gboolean doPrompt = gtr_pref_flag_get( PREF_KEY_OPTIONS_PROMPT );
const gboolean doNotify = TRUE;
/* fill out cbdata */
@ -860,7 +860,7 @@ appsetup( TrWindow * wind,
cbdata->isIconified = isIconified;
if( isIconified )
pref_flag_set( PREF_KEY_SHOW_TRAY_ICON, TRUE );
gtr_pref_flag_set( PREF_KEY_SHOW_TRAY_ICON, TRUE );
gtr_actions_set_core( cbdata->core );
@ -898,7 +898,7 @@ appsetup( TrWindow * wind,
gtr_action_set_toggled( "toggle-main-window", FALSE );
}
if( !pref_flag_get( PREF_KEY_USER_HAS_GIVEN_INFORMED_CONSENT ) )
if( !gtr_pref_flag_get( PREF_KEY_USER_HAS_GIVEN_INFORMED_CONSENT ) )
{
GtkWidget * w = gtk_message_dialog_new( GTK_WINDOW( wind ),
GTK_DIALOG_DESTROY_WITH_PARENT,
@ -912,7 +912,7 @@ appsetup( TrWindow * wind,
switch( gtk_dialog_run( GTK_DIALOG( w ) ) ) {
case GTK_RESPONSE_ACCEPT:
/* only show it once */
pref_flag_set( PREF_KEY_USER_HAS_GIVEN_INFORMED_CONSENT, TRUE );
gtr_pref_flag_set( PREF_KEY_USER_HAS_GIVEN_INFORMED_CONSENT, TRUE );
gtk_widget_destroy( w );
break;
default:
@ -959,7 +959,7 @@ toggleMainWindow( struct cbdata * cbdata )
static gboolean
shouldConfirmBeforeExiting( struct cbdata * data )
{
return pref_flag_get( PREF_KEY_ASKQUIT )
return gtr_pref_flag_get( PREF_KEY_ASKQUIT )
&& tr_core_get_active_torrent_count( data->core );
}
@ -1175,10 +1175,10 @@ wannaquit( gpointer vdata )
/* ensure the window is in its previous position & size.
* this seems to be necessary because changing the main window's
* child seems to unset the size */
gtk_window_resize( cbdata->wind, pref_int_get( PREF_KEY_MAIN_WINDOW_WIDTH ),
pref_int_get( PREF_KEY_MAIN_WINDOW_HEIGHT ) );
gtk_window_move( cbdata->wind, pref_int_get( PREF_KEY_MAIN_WINDOW_X ),
pref_int_get( PREF_KEY_MAIN_WINDOW_Y ) );
gtk_window_resize( cbdata->wind, gtr_pref_int_get( PREF_KEY_MAIN_WINDOW_WIDTH ),
gtr_pref_int_get( PREF_KEY_MAIN_WINDOW_HEIGHT ) );
gtk_window_move( cbdata->wind, gtr_pref_int_get( PREF_KEY_MAIN_WINDOW_X ),
gtr_pref_int_get( PREF_KEY_MAIN_WINDOW_Y ) );
/* shut down libT */
g_thread_create( sessionCloseThreadFunc, vdata, TRUE, NULL );
@ -1297,31 +1297,31 @@ prefschanged( TrCore * core UNUSED, const char * key, gpointer data )
if( !strcmp( key, TR_PREFS_KEY_ENCRYPTION ) )
{
tr_sessionSetEncryption( tr, pref_int_get( key ) );
tr_sessionSetEncryption( tr, gtr_pref_int_get( key ) );
}
else if( !strcmp( key, TR_PREFS_KEY_DOWNLOAD_DIR ) )
{
tr_sessionSetDownloadDir( tr, pref_string_get( key ) );
tr_sessionSetDownloadDir( tr, gtr_pref_string_get( key ) );
}
else if( !strcmp( key, TR_PREFS_KEY_MSGLEVEL ) )
{
tr_setMessageLevel( pref_int_get( key ) );
tr_setMessageLevel( gtr_pref_int_get( key ) );
}
else if( !strcmp( key, TR_PREFS_KEY_PEER_PORT ) )
{
tr_sessionSetPeerPort( tr, pref_int_get( key ) );
tr_sessionSetPeerPort( tr, gtr_pref_int_get( key ) );
}
else if( !strcmp( key, TR_PREFS_KEY_BLOCKLIST_ENABLED ) )
{
tr_blocklistSetEnabled( tr, pref_flag_get( key ) );
tr_blocklistSetEnabled( tr, gtr_pref_flag_get( key ) );
}
else if( !strcmp( key, TR_PREFS_KEY_BLOCKLIST_URL ) )
{
tr_blocklistSetURL( tr, pref_string_get( key ) );
tr_blocklistSetURL( tr, gtr_pref_string_get( key ) );
}
else if( !strcmp( key, PREF_KEY_SHOW_TRAY_ICON ) )
{
const int show = pref_flag_get( key );
const int show = gtr_pref_flag_get( key );
if( show && !cbdata->icon )
cbdata->icon = gtr_icon_new( cbdata->core );
else if( !show && cbdata->icon ) {
@ -1331,141 +1331,141 @@ prefschanged( TrCore * core UNUSED, const char * key, gpointer data )
}
else if( !strcmp( key, TR_PREFS_KEY_DSPEED_ENABLED ) )
{
tr_sessionLimitSpeed( tr, TR_DOWN, pref_flag_get( key ) );
tr_sessionLimitSpeed( tr, TR_DOWN, gtr_pref_flag_get( key ) );
}
else if( !strcmp( key, TR_PREFS_KEY_DSPEED_KBps ) )
{
tr_sessionSetSpeedLimit_KBps( tr, TR_DOWN, pref_int_get( key ) );
tr_sessionSetSpeedLimit_KBps( tr, TR_DOWN, gtr_pref_int_get( key ) );
}
else if( !strcmp( key, TR_PREFS_KEY_USPEED_ENABLED ) )
{
tr_sessionLimitSpeed( tr, TR_UP, pref_flag_get( key ) );
tr_sessionLimitSpeed( tr, TR_UP, gtr_pref_flag_get( key ) );
}
else if( !strcmp( key, TR_PREFS_KEY_USPEED_KBps ) )
{
tr_sessionSetSpeedLimit_KBps( tr, TR_UP, pref_int_get( key ) );
tr_sessionSetSpeedLimit_KBps( tr, TR_UP, gtr_pref_int_get( key ) );
}
else if( !strcmp( key, TR_PREFS_KEY_RATIO_ENABLED ) )
{
tr_sessionSetRatioLimited( tr, pref_flag_get( key ) );
tr_sessionSetRatioLimited( tr, gtr_pref_flag_get( key ) );
}
else if( !strcmp( key, TR_PREFS_KEY_RATIO ) )
{
tr_sessionSetRatioLimit( tr, pref_double_get( key ) );
tr_sessionSetRatioLimit( tr, gtr_pref_double_get( key ) );
}
else if( !strcmp( key, TR_PREFS_KEY_IDLE_LIMIT ) )
{
tr_sessionSetIdleLimit( tr, pref_int_get( key ) );
tr_sessionSetIdleLimit( tr, gtr_pref_int_get( key ) );
}
else if( !strcmp( key, TR_PREFS_KEY_IDLE_LIMIT_ENABLED ) )
{
tr_sessionSetIdleLimited( tr, pref_flag_get( key ) );
tr_sessionSetIdleLimited( tr, gtr_pref_flag_get( key ) );
}
else if( !strcmp( key, TR_PREFS_KEY_PORT_FORWARDING ) )
{
tr_sessionSetPortForwardingEnabled( tr, pref_flag_get( key ) );
tr_sessionSetPortForwardingEnabled( tr, gtr_pref_flag_get( key ) );
}
else if( !strcmp( key, TR_PREFS_KEY_PEX_ENABLED ) )
{
tr_sessionSetPexEnabled( tr, pref_flag_get( key ) );
tr_sessionSetPexEnabled( tr, gtr_pref_flag_get( key ) );
}
else if( !strcmp( key, TR_PREFS_KEY_RENAME_PARTIAL_FILES ) )
{
tr_sessionSetIncompleteFileNamingEnabled( tr, pref_flag_get( key ) );
tr_sessionSetIncompleteFileNamingEnabled( tr, gtr_pref_flag_get( key ) );
}
else if( !strcmp( key, TR_PREFS_KEY_DHT_ENABLED ) )
{
tr_sessionSetDHTEnabled( tr, pref_flag_get( key ) );
tr_sessionSetDHTEnabled( tr, gtr_pref_flag_get( key ) );
}
else if( !strcmp( key, TR_PREFS_KEY_LPD_ENABLED ) )
{
tr_sessionSetLPDEnabled( tr, pref_flag_get( key ) );
tr_sessionSetLPDEnabled( tr, gtr_pref_flag_get( key ) );
}
else if( !strcmp( key, TR_PREFS_KEY_RPC_PORT ) )
{
tr_sessionSetRPCPort( tr, pref_int_get( key ) );
tr_sessionSetRPCPort( tr, gtr_pref_int_get( key ) );
}
else if( !strcmp( key, TR_PREFS_KEY_RPC_ENABLED ) )
{
tr_sessionSetRPCEnabled( tr, pref_flag_get( key ) );
tr_sessionSetRPCEnabled( tr, gtr_pref_flag_get( key ) );
}
else if( !strcmp( key, TR_PREFS_KEY_RPC_WHITELIST ) )
{
tr_sessionSetRPCWhitelist( tr, pref_string_get( key ) );
tr_sessionSetRPCWhitelist( tr, gtr_pref_string_get( key ) );
}
else if( !strcmp( key, TR_PREFS_KEY_RPC_WHITELIST_ENABLED ) )
{
tr_sessionSetRPCWhitelistEnabled( tr, pref_flag_get( key ) );
tr_sessionSetRPCWhitelistEnabled( tr, gtr_pref_flag_get( key ) );
}
else if( !strcmp( key, TR_PREFS_KEY_RPC_USERNAME ) )
{
tr_sessionSetRPCUsername( tr, pref_string_get( key ) );
tr_sessionSetRPCUsername( tr, gtr_pref_string_get( key ) );
}
else if( !strcmp( key, TR_PREFS_KEY_RPC_PASSWORD ) )
{
tr_sessionSetRPCPassword( tr, pref_string_get( key ) );
tr_sessionSetRPCPassword( tr, gtr_pref_string_get( key ) );
}
else if( !strcmp( key, TR_PREFS_KEY_RPC_AUTH_REQUIRED ) )
{
tr_sessionSetRPCPasswordEnabled( tr, pref_flag_get( key ) );
tr_sessionSetRPCPasswordEnabled( tr, gtr_pref_flag_get( key ) );
}
else if( !strcmp( key, TR_PREFS_KEY_ALT_SPEED_UP_KBps ) )
{
tr_sessionSetAltSpeed_KBps( tr, TR_UP, pref_int_get( key ) );
tr_sessionSetAltSpeed_KBps( tr, TR_UP, gtr_pref_int_get( key ) );
}
else if( !strcmp( key, TR_PREFS_KEY_ALT_SPEED_DOWN_KBps ) )
{
tr_sessionSetAltSpeed_KBps( tr, TR_DOWN, pref_int_get( key ) );
tr_sessionSetAltSpeed_KBps( tr, TR_DOWN, gtr_pref_int_get( key ) );
}
else if( !strcmp( key, TR_PREFS_KEY_ALT_SPEED_ENABLED ) )
{
const gboolean b = pref_flag_get( key );
const gboolean b = gtr_pref_flag_get( key );
tr_sessionUseAltSpeed( tr, b );
gtr_action_set_toggled( key, b );
}
else if( !strcmp( key, TR_PREFS_KEY_ALT_SPEED_TIME_BEGIN ) )
{
tr_sessionSetAltSpeedBegin( tr, pref_int_get( key ) );
tr_sessionSetAltSpeedBegin( tr, gtr_pref_int_get( key ) );
}
else if( !strcmp( key, TR_PREFS_KEY_ALT_SPEED_TIME_END ) )
{
tr_sessionSetAltSpeedEnd( tr, pref_int_get( key ) );
tr_sessionSetAltSpeedEnd( tr, gtr_pref_int_get( key ) );
}
else if( !strcmp( key, TR_PREFS_KEY_ALT_SPEED_TIME_ENABLED ) )
{
tr_sessionUseAltSpeedTime( tr, pref_flag_get( key ) );
tr_sessionUseAltSpeedTime( tr, gtr_pref_flag_get( key ) );
}
else if( !strcmp( key, TR_PREFS_KEY_ALT_SPEED_TIME_DAY ) )
{
tr_sessionSetAltSpeedDay( tr, pref_int_get( key ) );
tr_sessionSetAltSpeedDay( tr, gtr_pref_int_get( key ) );
}
else if( !strcmp( key, TR_PREFS_KEY_PEER_PORT_RANDOM_ON_START ) )
{
tr_sessionSetPeerPortRandomOnStart( tr, pref_flag_get( key ) );
tr_sessionSetPeerPortRandomOnStart( tr, gtr_pref_flag_get( key ) );
}
else if( !strcmp( key, TR_PREFS_KEY_INCOMPLETE_DIR ) )
{
tr_sessionSetIncompleteDir( tr, pref_string_get( key ) );
tr_sessionSetIncompleteDir( tr, gtr_pref_string_get( key ) );
}
else if( !strcmp( key, TR_PREFS_KEY_INCOMPLETE_DIR_ENABLED ) )
{
tr_sessionSetIncompleteDirEnabled( tr, pref_flag_get( key ) );
tr_sessionSetIncompleteDirEnabled( tr, gtr_pref_flag_get( key ) );
}
else if( !strcmp( key, TR_PREFS_KEY_SCRIPT_TORRENT_DONE_ENABLED ) )
{
tr_sessionSetTorrentDoneScriptEnabled( tr, pref_flag_get( key ) );
tr_sessionSetTorrentDoneScriptEnabled( tr, gtr_pref_flag_get( key ) );
}
else if( !strcmp( key, TR_PREFS_KEY_SCRIPT_TORRENT_DONE_FILENAME ) )
{
tr_sessionSetTorrentDoneScript( tr, pref_string_get( key ) );
tr_sessionSetTorrentDoneScript( tr, gtr_pref_string_get( key ) );
}
else if( !strcmp( key, TR_PREFS_KEY_START) )
{
tr_sessionSetPaused( tr, !pref_flag_get( key ) );
tr_sessionSetPaused( tr, !gtr_pref_flag_get( key ) );
}
else if( !strcmp( key, TR_PREFS_KEY_TRASH_ORIGINAL ) )
{
tr_sessionSetDeleteSource( tr, pref_flag_get( key ) );
tr_sessionSetDeleteSource( tr, gtr_pref_flag_get( key ) );
}
}
@ -1824,7 +1824,7 @@ gtr_actions_handler( const char * action_name, gpointer user_data )
{
if( !data->msgwin )
{
GtkWidget * win = gtr_message_log_window_new( data->core, data->wind );
GtkWidget * win = gtr_message_log_window_new( data->wind, data->core );
g_signal_connect( win, "destroy", G_CALLBACK( msgwinclosed ), NULL );
data->msgwin = win;
}

6
gtk/msgwin.c
View File

@ -365,7 +365,7 @@ debug_level_combo_new( void )
_( "Information" ), TR_MSG_INF,
_( "Debug" ), TR_MSG_DBG,
NULL );
gtr_combo_box_set_active_enum( GTK_COMBO_BOX( w ), pref_int_get( TR_PREFS_KEY_MSGLEVEL ) );
gtr_combo_box_set_active_enum( GTK_COMBO_BOX( w ), gtr_pref_int_get( TR_PREFS_KEY_MSGLEVEL ) );
return w;
}
@ -374,7 +374,7 @@ debug_level_combo_new( void )
**/
GtkWidget *
gtr_message_log_window_new( TrCore * core, GtkWindow * parent )
gtr_message_log_window_new( GtkWindow * parent, TrCore * core )
{
GtkWidget * win;
GtkWidget * vbox;
@ -456,7 +456,7 @@ gtr_message_log_window_new( TrCore * core, GtkWindow * parent )
gtk_tree_sortable_set_sort_column_id( GTK_TREE_SORTABLE( data->sort ),
COL_SEQUENCE,
GTK_SORT_ASCENDING );
data->maxLevel = pref_int_get( TR_PREFS_KEY_MSGLEVEL );
data->maxLevel = gtr_pref_int_get( TR_PREFS_KEY_MSGLEVEL );
gtk_tree_model_filter_set_visible_func( GTK_TREE_MODEL_FILTER( data->
filter ),
isRowVisible, data, NULL );

2
gtk/msgwin.h
View File

@ -13,6 +13,6 @@
#ifndef GTR_MSGWIN_H
#define GTR_MSGWIN_H
GtkWidget * gtr_message_log_window_new( TrCore * core, GtkWindow * parent );
GtkWidget * gtr_message_log_window_new( GtkWindow * parent, TrCore * core );
#endif

6
gtk/notify.c
View File

@ -112,7 +112,7 @@ void
gtr_notify_send( TrTorrent *tor )
{
#ifdef HAVE_LIBCANBERRA
if( pref_flag_get( PREF_KEY_PLAY_DOWNLOAD_COMPLETE_SOUND ) )
if( gtr_pref_flag_get( PREF_KEY_PLAY_DOWNLOAD_COMPLETE_SOUND ) )
{
/* play the sound, using sounds from the naming spec */
ca_context_play( ca_gtk_context_get (), 0,
@ -123,7 +123,7 @@ gtr_notify_send( TrTorrent *tor )
}
#endif
if( pref_flag_get( PREF_KEY_SHOW_DESKTOP_NOTIFICATION ) )
if( gtr_pref_flag_get( PREF_KEY_SHOW_DESKTOP_NOTIFICATION ) )
{
const tr_info * info = tr_torrent_info( tor );
NotifyNotification * n;
@ -157,7 +157,7 @@ gtr_notify_send( TrTorrent *tor )
void
gtr_notify_added( const char * name )
{
if( pref_flag_get( PREF_KEY_SHOW_DESKTOP_NOTIFICATION ) )
if( gtr_pref_flag_get( PREF_KEY_SHOW_DESKTOP_NOTIFICATION ) )
{
NotifyNotification * n = notify_notification_new(
_( "Torrent Added" ), name, NULL

4
gtk/relocate.c
View File

@ -15,7 +15,7 @@
#include <glib/gi18n.h>
#include <gtk/gtk.h>
#include "conf.h" /* pref_string_get */
#include "conf.h" /* gtr_pref_string_get */
#include "hig.h"
#include "relocate.h"
#include "util.h"
@ -175,7 +175,7 @@ gtr_relocate_dialog_new( GtkWindow * parent,
hig_workarea_add_section_title( t, &row, _( "Location" ) );
if( previousLocation == NULL )
previousLocation = g_strdup( pref_string_get( TR_PREFS_KEY_DOWNLOAD_DIR ) );
previousLocation = g_strdup( gtr_pref_string_get( TR_PREFS_KEY_DOWNLOAD_DIR ) );
w = gtk_file_chooser_button_new( _( "Set Torrent Location" ), GTK_FILE_CHOOSER_ACTION_SELECT_FOLDER );
gtk_file_chooser_set_current_folder( GTK_FILE_CHOOSER( w ), previousLocation );
g_object_set_data( G_OBJECT( d ), "chooser", w );

60
gtk/tr-core.c
View File

@ -505,19 +505,19 @@ static void
tr_core_apply_defaults( tr_ctor * ctor )
{
if( tr_ctorGetPaused( ctor, TR_FORCE, NULL ) )
tr_ctorSetPaused( ctor, TR_FORCE, !pref_flag_get( TR_PREFS_KEY_START ) );
tr_ctorSetPaused( ctor, TR_FORCE, !gtr_pref_flag_get( TR_PREFS_KEY_START ) );
if( tr_ctorGetDeleteSource( ctor, NULL ) )
tr_ctorSetDeleteSource( ctor,
pref_flag_get( TR_PREFS_KEY_TRASH_ORIGINAL ) );
gtr_pref_flag_get( TR_PREFS_KEY_TRASH_ORIGINAL ) );
if( tr_ctorGetPeerLimit( ctor, TR_FORCE, NULL ) )
tr_ctorSetPeerLimit( ctor, TR_FORCE,
pref_int_get( TR_PREFS_KEY_PEER_LIMIT_TORRENT ) );
gtr_pref_int_get( TR_PREFS_KEY_PEER_LIMIT_TORRENT ) );
if( tr_ctorGetDownloadDir( ctor, TR_FORCE, NULL ) )
{
const char * path = pref_string_get( TR_PREFS_KEY_DOWNLOAD_DIR );
const char * path = gtr_pref_string_get( TR_PREFS_KEY_DOWNLOAD_DIR );
tr_ctorSetDownloadDir( ctor, TR_FORCE, path );
}
}
@ -667,11 +667,11 @@ watchFolderChanged( GFileMonitor * monitor UNUSED,
static void
scanWatchDir( TrCore * core )
{
const gboolean isEnabled = pref_flag_get( PREF_KEY_DIR_WATCH_ENABLED );
const gboolean isEnabled = gtr_pref_flag_get( PREF_KEY_DIR_WATCH_ENABLED );
if( isEnabled )
{
const char * dirname = pref_string_get( PREF_KEY_DIR_WATCH );
const char * dirname = gtr_pref_string_get( PREF_KEY_DIR_WATCH );
GDir * dir = g_dir_open( dirname, 0, NULL );
if( dir != NULL )
@ -692,8 +692,8 @@ scanWatchDir( TrCore * core )
static void
updateWatchDir( TrCore * core )
{
const char * filename = pref_string_get( PREF_KEY_DIR_WATCH );
const gboolean isEnabled = pref_flag_get(
const char * filename = gtr_pref_string_get( PREF_KEY_DIR_WATCH );
const gboolean isEnabled = gtr_pref_flag_get(
PREF_KEY_DIR_WATCH_ENABLED );
struct TrCorePrivate * p = TR_CORE( core )->priv;
@ -731,18 +731,18 @@ prefsChanged( TrCore * core,
if( !strcmp( key, PREF_KEY_SORT_MODE )
|| !strcmp( key, PREF_KEY_SORT_REVERSED ) )
{
const char * mode = pref_string_get( PREF_KEY_SORT_MODE );
gboolean isReversed = pref_flag_get( PREF_KEY_SORT_REVERSED );
const char * mode = gtr_pref_string_get( PREF_KEY_SORT_MODE );
gboolean isReversed = gtr_pref_flag_get( PREF_KEY_SORT_REVERSED );
setSort( core, mode, isReversed );
}
else if( !strcmp( key, TR_PREFS_KEY_PEER_LIMIT_GLOBAL ) )
{
const uint16_t val = pref_int_get( key );
const uint16_t val = gtr_pref_int_get( key );
tr_sessionSetPeerLimit( tr_core_session( core ), val );
}
else if( !strcmp( key, TR_PREFS_KEY_PEER_LIMIT_TORRENT ) )
{
const uint16_t val = pref_int_get( key );
const uint16_t val = gtr_pref_int_get( key );
tr_sessionSetPeerLimitPerTorrent( tr_core_session( core ), val );
}
else if( !strcmp( key, PREF_KEY_INHIBIT_HIBERNATION ) )
@ -859,7 +859,7 @@ tr_core_close( TrCore * core )
if( session )
{
core->priv->session = NULL;
pref_save( session );
gtr_pref_save( session );
tr_sessionClose( session );
}
}
@ -924,7 +924,7 @@ tr_core_load( TrCore * self, gboolean forcePaused )
if( forcePaused )
tr_ctorSetPaused( ctor, TR_FORCE, TRUE );
tr_ctorSetPeerLimit( ctor, TR_FALLBACK,
pref_int_get( TR_PREFS_KEY_PEER_LIMIT_TORRENT ) );
gtr_pref_int_get( TR_PREFS_KEY_PEER_LIMIT_TORRENT ) );
torrents = tr_sessionLoadTorrents ( tr_core_session( self ), ctor, &count );
for( i=0; i<count; ++i )
@ -995,7 +995,7 @@ add_ctor( TrCore * core, tr_ctor * ctor, gboolean doPrompt, gboolean doNotify )
void
tr_core_add_ctor( TrCore * core, tr_ctor * ctor )
{
const gboolean doPrompt = pref_flag_get( PREF_KEY_OPTIONS_PROMPT );
const gboolean doPrompt = gtr_pref_flag_get( PREF_KEY_OPTIONS_PROMPT );
const gboolean doNotify = FALSE;
tr_core_apply_defaults( ctor );
add_ctor( core, ctor, doPrompt, doNotify );
@ -1024,7 +1024,7 @@ tr_core_add_metainfo( TrCore * core,
int file_length;
tr_ctor * ctor;
char * file_contents;
gboolean do_prompt = pref_flag_get( PREF_KEY_OPTIONS_PROMPT );
gboolean do_prompt = gtr_pref_flag_get( PREF_KEY_OPTIONS_PROMPT );
ctor = tr_ctorNew( session );
tr_core_apply_defaults( ctor );
@ -1064,7 +1064,7 @@ onURLDoneIdle( gpointer vdata )
}
else
{
const gboolean doPrompt = pref_flag_get( PREF_KEY_OPTIONS_PROMPT );
const gboolean doPrompt = gtr_pref_flag_get( PREF_KEY_OPTIONS_PROMPT );
const gboolean doNotify = FALSE;
const int err = add_ctor( data->core, data->ctor, doPrompt, doNotify );
@ -1210,8 +1210,8 @@ tr_core_add_list( TrCore * core,
void
tr_core_add_list_defaults( TrCore * core, GSList * torrentFiles, gboolean doNotify )
{
const gboolean doStart = pref_flag_get( TR_PREFS_KEY_START );
const gboolean doPrompt = pref_flag_get( PREF_KEY_OPTIONS_PROMPT );
const gboolean doStart = gtr_pref_flag_get( TR_PREFS_KEY_START );
const gboolean doPrompt = gtr_pref_flag_get( PREF_KEY_OPTIONS_PROMPT );
tr_core_add_list( core, torrentFiles, doStart, doPrompt, doNotify );
}
@ -1508,7 +1508,7 @@ maybeInhibitHibernation( TrCore * core )
/* hibernation is allowed if EITHER
* (a) the "inhibit" pref is turned off OR
* (b) there aren't any active torrents */
const gboolean hibernation_allowed = !pref_flag_get( PREF_KEY_INHIBIT_HIBERNATION )
const gboolean hibernation_allowed = !gtr_pref_flag_get( PREF_KEY_INHIBIT_HIBERNATION )
|| !tr_core_get_active_torrent_count( core );
tr_core_set_hibernation_allowed( core, hibernation_allowed );
}
@ -1521,17 +1521,17 @@ static void
commitPrefsChange( TrCore * core, const char * key )
{
g_signal_emit( core, core_signals[PREFS_SIGNAL], 0, key );
pref_save( tr_core_session( core ) );
gtr_pref_save( tr_core_session( core ) );
}
void
tr_core_set_pref( TrCore * self, const char * key, const char * newval )
{
const char * oldval = pref_string_get( key );
const char * oldval = gtr_pref_string_get( key );
if( gtr_strcmp0( oldval, newval ) )
{
pref_string_set( key, newval );
gtr_pref_string_set( key, newval );
commitPrefsChange( self, key );
}
}
@ -1541,11 +1541,11 @@ tr_core_set_pref_bool( TrCore * self,
const char * key,
gboolean newval )
{
const gboolean oldval = pref_flag_get( key );
const gboolean oldval = gtr_pref_flag_get( key );
if( oldval != newval )
{
pref_flag_set( key, newval );
gtr_pref_flag_set( key, newval );
commitPrefsChange( self, key );
}
}
@ -1555,11 +1555,11 @@ tr_core_set_pref_int( TrCore * self,
const char * key,
int newval )
{
const int oldval = pref_int_get( key );
const int oldval = gtr_pref_int_get( key );
if( oldval != newval )
{
pref_int_set( key, newval );
gtr_pref_int_set( key, newval );
commitPrefsChange( self, key );
}
}
@ -1569,11 +1569,11 @@ tr_core_set_pref_double( TrCore * self,
const char * key,
double newval )
{
const double oldval = pref_double_get( key );
const double oldval = gtr_pref_double_get( key );
if( gtr_compare_double( oldval, newval, 4 ) )
{
pref_double_set( key, newval );
gtr_pref_double_set( key, newval );
commitPrefsChange( self, key );
}
}
@ -1706,7 +1706,7 @@ blocklistResponseFunc( TrCore * core, tr_benc * response, gpointer userData UNUS
tr_bencDictFindInt( args, "blocklist-size", &ruleCount );
if( ruleCount > 0 )
pref_int_set( "blocklist-date", time( NULL ) );
gtr_pref_int_set( "blocklist-date", time( NULL ) );
emitBlocklistUpdated( core, ruleCount );
}

38
gtk/tr-prefs.c
View File

@ -68,7 +68,7 @@ new_check_button( const char * mnemonic,
g_object_set_data_full( G_OBJECT( w ), PREF_KEY, g_strdup(
key ), g_free );
gtk_toggle_button_set_active( GTK_TOGGLE_BUTTON( w ),
pref_flag_get( key ) );
gtr_pref_flag_get( key ) );
g_signal_connect( w, "toggled", G_CALLBACK( toggled_cb ), core );
return w;
}
@ -167,7 +167,7 @@ new_spin_button( const char * key,
GtkWidget * w = gtk_spin_button_new_with_range( low, high, step );
g_object_set_data_full( G_OBJECT( w ), PREF_KEY, g_strdup( key ), g_free );
gtk_spin_button_set_digits( GTK_SPIN_BUTTON( w ), 0 );
gtk_spin_button_set_value( GTK_SPIN_BUTTON( w ), pref_int_get( key ) );
gtk_spin_button_set_value( GTK_SPIN_BUTTON( w ), gtr_pref_int_get( key ) );
g_signal_connect( w, "value-changed", G_CALLBACK( spun_cb_int ), core );
return w;
}
@ -182,7 +182,7 @@ new_spin_button_double( const char * key,
GtkWidget * w = gtk_spin_button_new_with_range( low, high, step );
g_object_set_data_full( G_OBJECT( w ), PREF_KEY, g_strdup( key ), g_free );
gtk_spin_button_set_digits( GTK_SPIN_BUTTON( w ), 2 );
gtk_spin_button_set_value( GTK_SPIN_BUTTON( w ), pref_double_get( key ) );
gtk_spin_button_set_value( GTK_SPIN_BUTTON( w ), gtr_pref_double_get( key ) );
g_signal_connect( w, "value-changed", G_CALLBACK( spun_cb_double ), core );
return w;
}
@ -201,7 +201,7 @@ new_entry( const char * key,
gpointer core )
{
GtkWidget * w = gtk_entry_new( );
const char * value = pref_string_get( key );
const char * value = gtr_pref_string_get( key );
if( value )
gtk_entry_set_text( GTK_ENTRY( w ), value );
@ -224,7 +224,7 @@ static GtkWidget*
new_path_chooser_button( const char * key, gpointer core )
{
GtkWidget * w = gtk_file_chooser_button_new( NULL, GTK_FILE_CHOOSER_ACTION_SELECT_FOLDER );
const char * path = pref_string_get( key );
const char * path = gtr_pref_string_get( key );
g_object_set_data_full( G_OBJECT( w ), PREF_KEY, g_strdup( key ), g_free );
g_signal_connect( w, "selection-changed", G_CALLBACK( chosen_cb ), core );
if( path != NULL )
@ -236,7 +236,7 @@ static GtkWidget*
new_file_chooser_button( const char * key, gpointer core )
{
GtkWidget * w = gtk_file_chooser_button_new( NULL, GTK_FILE_CHOOSER_ACTION_OPEN );
const char * path = pref_string_get( key );
const char * path = gtr_pref_string_get( key );
g_object_set_data_full( G_OBJECT( w ), PREF_KEY, g_strdup( key ), g_free );
if( path != NULL )
gtk_file_chooser_set_filename( GTK_FILE_CHOOSER( w ), path );
@ -286,7 +286,7 @@ torrentPage( GObject * core )
l = new_check_button( s, PREF_KEY_DIR_WATCH_ENABLED, core );
w = new_path_chooser_button( PREF_KEY_DIR_WATCH, core );
gtk_widget_set_sensitive( GTK_WIDGET( w ),
pref_flag_get( PREF_KEY_DIR_WATCH_ENABLED ) );
gtr_pref_flag_get( PREF_KEY_DIR_WATCH_ENABLED ) );
g_signal_connect( l, "toggled", G_CALLBACK( target_cb ), w );
hig_workarea_add_row_w( t, &row, l, w, NULL );
#endif
@ -304,14 +304,14 @@ torrentPage( GObject * core )
s = _( "Keep _incomplete torrents in:" );
l = new_check_button( s, TR_PREFS_KEY_INCOMPLETE_DIR_ENABLED, core );
w = new_path_chooser_button( TR_PREFS_KEY_INCOMPLETE_DIR, core );
gtk_widget_set_sensitive( GTK_WIDGET( w ), pref_flag_get( TR_PREFS_KEY_INCOMPLETE_DIR_ENABLED ) );
gtk_widget_set_sensitive( GTK_WIDGET( w ), gtr_pref_flag_get( TR_PREFS_KEY_INCOMPLETE_DIR_ENABLED ) );
g_signal_connect( l, "toggled", G_CALLBACK( target_cb ), w );
hig_workarea_add_row_w( t, &row, l, w, NULL );
s = _( "Call scrip_t when torrent is completed:" );
l = new_check_button( s, TR_PREFS_KEY_SCRIPT_TORRENT_DONE_ENABLED, core );
w = new_file_chooser_button( TR_PREFS_KEY_SCRIPT_TORRENT_DONE_FILENAME, core );
gtk_widget_set_sensitive( GTK_WIDGET( w ), pref_flag_get( TR_PREFS_KEY_SCRIPT_TORRENT_DONE_ENABLED ) );
gtk_widget_set_sensitive( GTK_WIDGET( w ), gtr_pref_flag_get( TR_PREFS_KEY_SCRIPT_TORRENT_DONE_ENABLED ) );
g_signal_connect( l, "toggled", G_CALLBACK( target_cb ), w );
hig_workarea_add_row_w( t, &row, l, w, NULL );
@ -321,14 +321,14 @@ torrentPage( GObject * core )
s = _( "Stop seeding at _ratio:" );
w = new_check_button( s, TR_PREFS_KEY_RATIO_ENABLED, core );
w2 = new_spin_button_double( TR_PREFS_KEY_RATIO, core, 0, 1000, .05 );
gtk_widget_set_sensitive( GTK_WIDGET( w2 ), pref_flag_get( TR_PREFS_KEY_RATIO_ENABLED ) );
gtk_widget_set_sensitive( GTK_WIDGET( w2 ), gtr_pref_flag_get( TR_PREFS_KEY_RATIO_ENABLED ) );
g_signal_connect( w, "toggled", G_CALLBACK( target_cb ), w2 );
hig_workarea_add_row_w( t, &row, w, w2, NULL );
s = _( "Stop seeding if idle for _N minutes:" );
w = new_check_button( s, TR_PREFS_KEY_IDLE_LIMIT_ENABLED, core );
w2 = new_spin_button( TR_PREFS_KEY_IDLE_LIMIT, core, 1, 9999, 5 );
gtk_widget_set_sensitive( GTK_WIDGET( w2 ), pref_flag_get( TR_PREFS_KEY_IDLE_LIMIT_ENABLED ) );
gtk_widget_set_sensitive( GTK_WIDGET( w2 ), gtr_pref_flag_get( TR_PREFS_KEY_IDLE_LIMIT_ENABLED ) );
g_signal_connect( w, "toggled", G_CALLBACK( target_cb ), w2 );
hig_workarea_add_row_w( t, &row, w, w2, NULL );
@ -471,7 +471,7 @@ new_encryption_combo( GObject * core, const char * key )
_( "Prefer encryption" ), TR_ENCRYPTION_PREFERRED,
_( "Require encryption" ), TR_ENCRYPTION_REQUIRED,
NULL );
gtr_combo_box_set_active_enum( GTK_COMBO_BOX( w ), pref_int_get( key ) );
gtr_combo_box_set_active_enum( GTK_COMBO_BOX( w ), gtr_pref_int_get( key ) );
g_object_set_data_full( G_OBJECT( w ), PREF_KEY, tr_strdup( key ), g_free );
g_signal_connect( w, "changed", G_CALLBACK( onIntComboChanged ), core );
return w;
@ -729,7 +729,7 @@ onWhitelistSelectionChanged( GtkTreeSelection * sel UNUSED,
static void
onLaunchClutchCB( GtkButton * w UNUSED, gpointer data UNUSED )
{
const int port = pref_int_get( TR_PREFS_KEY_RPC_PORT );
const int port = gtr_pref_int_get( TR_PREFS_KEY_RPC_PORT );
char * uri = g_strdup_printf( "http://localhost:%d/transmission/web", port );
gtr_open_uri( uri );
@ -816,7 +816,7 @@ webPage( GObject * core )
/* access control list */
{
const char * val = pref_string_get( TR_PREFS_KEY_RPC_WHITELIST );
const char * val = gtr_pref_string_get( TR_PREFS_KEY_RPC_WHITELIST );
GtkTreeModel * m = whitelist_tree_model_new( val );
GtkTreeViewColumn * c;
GtkCellRenderer * r;
@ -897,7 +897,7 @@ static void
refreshSchedSensitivity( struct BandwidthPage * p )
{
GSList * l;
const gboolean sched_enabled = pref_flag_get( TR_PREFS_KEY_ALT_SPEED_TIME_ENABLED );
const gboolean sched_enabled = gtr_pref_flag_get( TR_PREFS_KEY_ALT_SPEED_TIME_ENABLED );
for( l = p->sched_widgets; l != NULL; l = l->next )
gtk_widget_set_sensitive( GTK_WIDGET( l->data ), sched_enabled );
@ -960,7 +960,7 @@ new_time_combo( GObject * core,
w ), r, "text", 1, NULL );
g_object_set_data_full( G_OBJECT( w ), PREF_KEY, tr_strdup(
key ), g_free );
val = pref_int_get( key );
val = gtr_pref_int_get( key );
gtk_combo_box_set_active( GTK_COMBO_BOX( w ), val / ( 15 ) );
g_signal_connect( w, "changed", G_CALLBACK( onTimeComboChanged ), core );
@ -983,7 +983,7 @@ new_week_combo( GObject * core, const char * key )
_( "Friday" ), TR_SCHED_FRI,
_( "Saturday" ), TR_SCHED_SAT,
NULL );
gtr_combo_box_set_active_enum( GTK_COMBO_BOX( w ), pref_int_get( key ) );
gtr_combo_box_set_active_enum( GTK_COMBO_BOX( w ), gtr_pref_int_get( key ) );
g_object_set_data_full( G_OBJECT( w ), PREF_KEY, tr_strdup( key ), g_free );
g_signal_connect( w, "changed", G_CALLBACK( onIntComboChanged ), core );
return w;
@ -1017,14 +1017,14 @@ bandwidthPage( GObject * core )
g_snprintf( buf, sizeof( buf ), _( "_Upload (%s):" ), _(speed_K_str) );
w = new_check_button( buf, TR_PREFS_KEY_USPEED_ENABLED, core );
w2 = new_spin_button( TR_PREFS_KEY_USPEED_KBps, core, 0, INT_MAX, 5 );
gtk_widget_set_sensitive( GTK_WIDGET( w2 ), pref_flag_get( TR_PREFS_KEY_USPEED_ENABLED ) );
gtk_widget_set_sensitive( GTK_WIDGET( w2 ), gtr_pref_flag_get( TR_PREFS_KEY_USPEED_ENABLED ) );
g_signal_connect( w, "toggled", G_CALLBACK( target_cb ), w2 );
hig_workarea_add_row_w( t, &row, w, w2, NULL );
g_snprintf( buf, sizeof( buf ), _( "_Download (%s):" ), _(speed_K_str) );
w = new_check_button( buf, TR_PREFS_KEY_DSPEED_ENABLED, core );
w2 = new_spin_button( TR_PREFS_KEY_DSPEED_KBps, core, 0, INT_MAX, 5 );
gtk_widget_set_sensitive( GTK_WIDGET( w2 ), pref_flag_get( TR_PREFS_KEY_DSPEED_ENABLED ) );
gtk_widget_set_sensitive( GTK_WIDGET( w2 ), gtr_pref_flag_get( TR_PREFS_KEY_DSPEED_ENABLED ) );
g_signal_connect( w, "toggled", G_CALLBACK( target_cb ), w2 );
hig_workarea_add_row_w( t, &row, w, w2, NULL );

40
gtk/tr-window.c
View File

@ -173,7 +173,7 @@ prefsChanged( TrCore * core UNUSED,
if( !strcmp( key, PREF_KEY_COMPACT_VIEW ) )
{
g_object_set( p->renderer, "compact", pref_flag_get( key ), NULL );
g_object_set( p->renderer, "compact", gtr_pref_flag_get( key ), NULL );
/* since the cell size has changed, we need gtktreeview to revalidate
* its fixed-height mode values. Unfortunately there's not an API call
* for that, but it *does* revalidate when it thinks the style's been tweaked */
@ -181,17 +181,17 @@ prefsChanged( TrCore * core UNUSED,
}
else if( !strcmp( key, PREF_KEY_STATUSBAR ) )
{
const gboolean isEnabled = pref_flag_get( key );
const gboolean isEnabled = gtr_pref_flag_get( key );
g_object_set( p->status, "visible", isEnabled, NULL );
}
else if( !strcmp( key, PREF_KEY_FILTERBAR ) )
{
const gboolean isEnabled = pref_flag_get( key );
const gboolean isEnabled = gtr_pref_flag_get( key );
g_object_set( p->filter, "visible", isEnabled, NULL );
}
else if( !strcmp( key, PREF_KEY_TOOLBAR ) )
{
const gboolean isEnabled = pref_flag_get( key );
const gboolean isEnabled = gtr_pref_flag_get( key );
g_object_set( p->toolbar, "visible", isEnabled, NULL );
}
else if( !strcmp( key, PREF_KEY_STATUSBAR_STATS ) )
@ -256,12 +256,12 @@ syncAltSpeedButton( PrivateData * p )
char d[32];
char * str;
const char * fmt;
const gboolean b = pref_flag_get( TR_PREFS_KEY_ALT_SPEED_ENABLED );
const gboolean b = gtr_pref_flag_get( TR_PREFS_KEY_ALT_SPEED_ENABLED );
const char * stock = b ? "alt-speed-on" : "alt-speed-off";
GtkWidget * w = p->alt_speed_button;
tr_formatter_speed_KBps( u, pref_int_get( TR_PREFS_KEY_ALT_SPEED_UP_KBps ), sizeof( u ) );
tr_formatter_speed_KBps( d, pref_int_get( TR_PREFS_KEY_ALT_SPEED_DOWN_KBps ), sizeof( d ) );
tr_formatter_speed_KBps( u, gtr_pref_int_get( TR_PREFS_KEY_ALT_SPEED_UP_KBps ), sizeof( u ) );
tr_formatter_speed_KBps( d, gtr_pref_int_get( TR_PREFS_KEY_ALT_SPEED_DOWN_KBps ), sizeof( d ) );
fmt = b ? _( "Click to disable Alternative Speed Limits\n(%1$s down, %2$s up)" )
: _( "Click to enable Alternative Speed Limits\n(%1$s down, %2$s up)" );
str = g_strdup_printf( fmt, d, u );
@ -535,26 +535,26 @@ onOptionsClicked( GtkButton * button UNUSED, gpointer vp )
PrivateData * p = vp;
w = p->speedlimit_on_item[TR_DOWN];
tr_formatter_speed_KBps( buf1, pref_int_get( TR_PREFS_KEY_DSPEED_KBps ), sizeof( buf1 ) );
tr_formatter_speed_KBps( buf1, gtr_pref_int_get( TR_PREFS_KEY_DSPEED_KBps ), sizeof( buf1 ) );
gtk_label_set_text( GTK_LABEL( gtk_bin_get_child( GTK_BIN( w ) ) ), buf1 );
b = pref_flag_get( TR_PREFS_KEY_DSPEED_ENABLED );
b = gtr_pref_flag_get( TR_PREFS_KEY_DSPEED_ENABLED );
w = b ? p->speedlimit_on_item[TR_DOWN] : p->speedlimit_off_item[TR_DOWN];
gtk_check_menu_item_set_active( GTK_CHECK_MENU_ITEM( w ), TRUE );
w = p->speedlimit_on_item[TR_UP];
tr_formatter_speed_KBps( buf1, pref_int_get( TR_PREFS_KEY_USPEED_KBps ), sizeof( buf1 ) );
tr_formatter_speed_KBps( buf1, gtr_pref_int_get( TR_PREFS_KEY_USPEED_KBps ), sizeof( buf1 ) );
gtk_label_set_text( GTK_LABEL( gtk_bin_get_child( GTK_BIN( w ) ) ), buf1 );
b = pref_flag_get( TR_PREFS_KEY_USPEED_ENABLED );
b = gtr_pref_flag_get( TR_PREFS_KEY_USPEED_ENABLED );
w = b ? p->speedlimit_on_item[TR_UP] : p->speedlimit_off_item[TR_UP];
gtk_check_menu_item_set_active( GTK_CHECK_MENU_ITEM( w ), TRUE );
tr_strlratio( buf1, pref_double_get( TR_PREFS_KEY_RATIO ), sizeof( buf1 ) );
tr_strlratio( buf1, gtr_pref_double_get( TR_PREFS_KEY_RATIO ), sizeof( buf1 ) );
g_snprintf( buf2, sizeof( buf2 ), _( "Stop at Ratio (%s)" ), buf1 );
gtk_label_set_text( GTK_LABEL( gtk_bin_get_child( GTK_BIN( p->ratio_on_item ) ) ), buf2 );
b = pref_flag_get( TR_PREFS_KEY_RATIO_ENABLED );
b = gtr_pref_flag_get( TR_PREFS_KEY_RATIO_ENABLED );
gtk_check_menu_item_set_active( GTK_CHECK_MENU_ITEM( b ? p->ratio_on_item : p->ratio_off_item ), TRUE );
gtk_menu_popup ( GTK_MENU( p->options_menu ), NULL, NULL, NULL, NULL, 0, gtk_get_current_event_time( ) );
@ -585,11 +585,11 @@ gtr_window_new( GtkUIManager * ui_mgr, TrCore * core )
gtk_window_set_title( win, g_get_application_name( ) );
gtk_window_set_role( win, "tr-main" );
gtk_window_set_default_size( win,
pref_int_get( PREF_KEY_MAIN_WINDOW_WIDTH ),
pref_int_get( PREF_KEY_MAIN_WINDOW_HEIGHT ) );
gtk_window_move( win, pref_int_get( PREF_KEY_MAIN_WINDOW_X ),
pref_int_get( PREF_KEY_MAIN_WINDOW_Y ) );
if( pref_flag_get( PREF_KEY_MAIN_WINDOW_IS_MAXIMIZED ) )
gtr_pref_int_get( PREF_KEY_MAIN_WINDOW_WIDTH ),
gtr_pref_int_get( PREF_KEY_MAIN_WINDOW_HEIGHT ) );
gtk_window_move( win, gtr_pref_int_get( PREF_KEY_MAIN_WINDOW_X ),
gtr_pref_int_get( PREF_KEY_MAIN_WINDOW_Y ) );
if( gtr_pref_flag_get( PREF_KEY_MAIN_WINDOW_IS_MAXIMIZED ) )
gtk_window_maximize( win );
gtk_window_add_accel_group( win, gtk_ui_manager_get_accel_group( ui_mgr ) );
@ -619,7 +619,7 @@ gtr_window_new( GtkUIManager * ui_mgr, TrCore * core )
/* status menu */
menu = p->status_menu = gtk_menu_new( );
l = NULL;
pch = pref_string_get( PREF_KEY_STATUSBAR_STATS );
pch = gtr_pref_string_get( PREF_KEY_STATUSBAR_STATS );
for( i = 0, n = G_N_ELEMENTS( stats_modes ); i < n; ++i )
{
const char * val = stats_modes[i].val;
@ -772,7 +772,7 @@ updateStats( PrivateData * p )
tr_session * session = tr_core_session( p->core );
/* update the stats */
pch = pref_string_get( PREF_KEY_STATUSBAR_STATS );
pch = gtr_pref_string_get( PREF_KEY_STATUSBAR_STATS );
if( !strcmp( pch, "session-ratio" ) )
{
tr_sessionGetStats( session, &stats );