Changeset 12090


Ignore:
Timestamp:
Mar 4, 2011, 2:31:23 PM (11 years ago)
Author:
jordan
Message:

(trunk gtk) minor copyediting for clarity/readability

Location:
trunk/gtk
Files:
6 edited

Legend:

Unmodified
Added
Removed
  • trunk/gtk/details.c

    r12068 r12090  
    23982398        sel = gtk_tree_view_get_selection( GTK_TREE_VIEW( v ) );
    23992399        g_signal_connect( sel, "changed", G_CALLBACK( on_tracker_list_selection_changed ), di );
    2400        
     2400
    24012401        c = gtk_tree_view_column_new( );
    24022402        gtk_tree_view_column_set_title( c, _( "Trackers" ) );
  • trunk/gtk/main.c

    r12087 r12090  
    345345
    346346static void app_setup( TrWindow       * wind,
    347                        GSList         * args,
     347                       GSList         * torrent_files,
    348348                       struct cbdata  * cbdata,
    349349                       gboolean         paused,
     
    949949static void
    950950app_setup( TrWindow      * wind,
    951            GSList        * torrentFiles,
     951           GSList        * files,
    952952           struct cbdata * cbdata,
    953953           gboolean        pause_all,
    954954           gboolean        is_iconified )
    955955{
    956     const gboolean doStart = gtr_pref_flag_get( TR_PREFS_KEY_START ) && !pause_all;
    957     const gboolean doPrompt = gtr_pref_flag_get( PREF_KEY_OPTIONS_PROMPT );
    958     const gboolean doNotify = TRUE;
    959 
    960     cbdata->is_iconified  = is_iconified;
     956    const gboolean do_start = gtr_pref_flag_get( TR_PREFS_KEY_START ) && !pause_all;
     957    const gboolean do_prompt = gtr_pref_flag_get( PREF_KEY_OPTIONS_PROMPT );
     958    const gboolean do_notify = TRUE;
     959
     960    cbdata->is_iconified = is_iconified;
    961961
    962962    if( is_iconified )
     
    973973    /* add torrents from command-line and saved state */
    974974    gtr_core_load( cbdata->core, pause_all );
    975     gtr_core_add_list( cbdata->core, torrentFiles, doStart, doPrompt, doNotify );
    976     torrentFiles = NULL;
     975    gtr_core_add_list( cbdata->core, files, do_start, do_prompt, do_notify );
     976    files = NULL;
    977977    gtr_core_torrents_added( cbdata->core );
    978978
     
    10841084    int i;
    10851085    gboolean success = FALSE;
    1086     GSList * filenames = NULL;
     1086    GSList * files = NULL;
    10871087    struct cbdata * data = gdata;
    10881088    char ** uris = gtk_selection_data_get_uris( selection_data );
     
    10961096        if( filename && g_file_test( filename, G_FILE_TEST_EXISTS ) )
    10971097        {
    1098             filenames = g_slist_append( filenames, g_strdup( filename ) );
     1098            files = g_slist_append( files, g_strdup( filename ) );
    10991099            success = TRUE;
    11001100        }
     
    11061106    }
    11071107
    1108     if( filenames )
    1109         gtr_core_add_list_defaults( data->core, g_slist_reverse( filenames ), TRUE );
     1108    if( files )
     1109        gtr_core_add_list_defaults( data->core, g_slist_reverse( files ), TRUE );
    11101110
    11111111    gtr_core_torrents_added( data->core );
     
    18411841            g_signal_connect( data->prefs, "destroy",
    18421842                              G_CALLBACK( gtk_widget_destroyed ), &data->prefs );
    1843             gtk_widget_show( GTK_WIDGET( data->prefs ) );
    1844         }
     1843        }
     1844        gtr_window_present( GTK_WINDOW( data->prefs ) );
    18451845    }
    18461846    else if( !strcmp( action_name, "toggle-message-log" ) )
  • trunk/gtk/msgwin.c

    r12068 r12090  
    394394            scroll_to_bottom( data );
    395395    }
    396        
     396
    397397    return TRUE;
    398398}
  • trunk/gtk/tr-core.c

    r12087 r12090  
    8080    GFileMonitor * monitor;
    8181    gulong         monitor_tag;
    82     char         * monitor_path;
     82    char         * monitor_dir;
    8383    GSList       * monitor_files;
    8484    guint          monitor_idle_tag;
     
    148148
    149149    core_signals[BUSY_SIGNAL] = g_signal_new(
    150         "busy",                             /* signal name */
    151         G_TYPE_FROM_CLASS( g_class ),       /* applies to TrCore */
    152         G_SIGNAL_RUN_FIRST,                 /* when to invoke */
    153         G_STRUCT_OFFSET(TrCoreClass, busy), /* class_offset */
    154         NULL, NULL,                         /* accumulator */
    155         g_cclosure_marshal_VOID__BOOLEAN    /* marshaler */,
    156         G_TYPE_NONE,                        /* return type */
    157         1, G_TYPE_BOOLEAN );                /* signal arguments */
     150        "busy",
     151        G_TYPE_FROM_CLASS( g_class ),
     152        G_SIGNAL_RUN_FIRST,
     153        G_STRUCT_OFFSET(TrCoreClass, busy),
     154        NULL, NULL,
     155        g_cclosure_marshal_VOID__BOOLEAN,
     156        G_TYPE_NONE,
     157        1, G_TYPE_BOOLEAN );
    158158
    159159    core_signals[BLOCKLIST_SIGNAL] = g_signal_new(
    160         "blocklist-updated",                          /* signal name */
    161         G_TYPE_FROM_CLASS( g_class ),                     /* applies to TrCore */
    162         G_SIGNAL_RUN_FIRST,                               /* when to invoke */
    163         G_STRUCT_OFFSET(TrCoreClass, blocklist_updated),  /* class_offset */
    164         NULL, NULL,                                       /* accumulator */
    165         g_cclosure_marshal_VOID__INT,                     /* marshaler */
    166         G_TYPE_NONE,                                      /* return type */
    167         1, G_TYPE_INT );                                  /* signal arguments */
     160        "blocklist-updated",
     161        G_TYPE_FROM_CLASS( g_class ),
     162        G_SIGNAL_RUN_FIRST,
     163        G_STRUCT_OFFSET(TrCoreClass, blocklist_updated),
     164        NULL, NULL,
     165        g_cclosure_marshal_VOID__INT,
     166        G_TYPE_NONE,
     167        1, G_TYPE_INT );
    168168
    169169    core_signals[PORT_SIGNAL] = g_signal_new(
     
    290290
    291291/***
    292 ****
     292****  EMIT SIGNALS
    293293***/
    294294
     
    300300
    301301static inline void
    302 core_emit_port_tested( TrCore * core, gboolean isOpen )
    303 {
    304     g_signal_emit( core, core_signals[PORT_SIGNAL], 0, isOpen );
     302core_emit_port_tested( TrCore * core, gboolean is_open )
     303{
     304    g_signal_emit( core, core_signals[PORT_SIGNAL], 0, is_open );
    305305}
    306306
     
    346346
    347347/***
    348 ****
     348****  BUSY
    349349***/
    350350
     
    494494
    495495static int
    496 compare_by_age( GtkTreeModel * m, GtkTreeIter * a, GtkTreeIter * b, gpointer user_data )
     496compare_by_age( GtkTreeModel * m, GtkTreeIter * a, GtkTreeIter * b, gpointer u )
    497497{
    498498    int ret = 0;
     
    502502    gtk_tree_model_get( m, b, MC_TORRENT, &tb, -1 );
    503503
    504     if( !ret ) ret = compare_time( tr_torrentStatCached( ta )->addedDate, tr_torrentStatCached( tb )->addedDate );
    505     if( !ret ) ret = compare_by_name( m, a, b, user_data );
     504    if( !ret ) ret = compare_time( tr_torrentStatCached( ta )->addedDate,
     505                                   tr_torrentStatCached( tb )->addedDate );
     506    if( !ret ) ret = compare_by_name( m, a, b, u );
    506507    return ret;
    507508}
    508509
    509510static int
    510 compare_by_size( GtkTreeModel * m, GtkTreeIter * a, GtkTreeIter * b, gpointer user_data )
     511compare_by_size( GtkTreeModel * m, GtkTreeIter * a, GtkTreeIter * b, gpointer u )
    511512{
    512513    int ret = 0;
     
    520521
    521522    if( !ret ) ret = compare_uint64( ia->totalSize, ib->totalSize );
    522     if( !ret ) ret = compare_by_name( m, a, b, user_data );
     523    if( !ret ) ret = compare_by_name( m, a, b, u );
    523524    return ret;
    524525}
    525526
    526527static int
    527 compare_by_progress( GtkTreeModel * m, GtkTreeIter * a, GtkTreeIter * b, gpointer user_data )
     528compare_by_progress( GtkTreeModel * m, GtkTreeIter * a, GtkTreeIter * b, gpointer u )
    528529{
    529530    int ret = 0;
     
    538539    if( !ret ) ret = compare_double( sa->percentComplete, sb->percentComplete );
    539540    if( !ret ) ret = compare_double( sa->seedRatioPercentDone, sb->seedRatioPercentDone );
    540     if( !ret ) ret = compare_by_ratio( m, a, b, user_data );
     541    if( !ret ) ret = compare_by_ratio( m, a, b, u );
    541542    return ret;
    542543}
    543544
    544545static int
    545 compare_by_eta( GtkTreeModel * m, GtkTreeIter  * a, GtkTreeIter  * b, gpointer user_data )
     546compare_by_eta( GtkTreeModel * m, GtkTreeIter  * a, GtkTreeIter  * b, gpointer u )
    546547{
    547548    int ret = 0;
     
    551552    gtk_tree_model_get( m, b, MC_TORRENT, &tb, -1 );
    552553
    553     if( !ret ) ret = compare_eta( tr_torrentStatCached( ta )->eta, tr_torrentStatCached( tb )->eta );
    554     if( !ret ) ret = compare_by_name( m, a, b, user_data );
     554    if( !ret ) ret = compare_eta( tr_torrentStatCached( ta )->eta,
     555                                  tr_torrentStatCached( tb )->eta );
     556    if( !ret ) ret = compare_by_name( m, a, b, u );
    555557    return ret;
    556558}
    557559
    558560static int
    559 compare_by_state( GtkTreeModel * m, GtkTreeIter * a, GtkTreeIter * b, gpointer user_data )
     561compare_by_state( GtkTreeModel * m, GtkTreeIter * a, GtkTreeIter * b, gpointer u )
    560562{
    561563    int ret = 0;
     
    566568
    567569    if( !ret ) ret = compare_int( sa, sb );
    568     if( !ret ) ret = compare_by_progress( m, a, b, user_data );
     570    if( !ret ) ret = compare_by_progress( m, a, b, u );
    569571    return ret;
    570572}
    571573
    572574static void
    573 core_set_sort_mode( TrCore * core, const char * mode, gboolean is_reversed  )
     575core_set_sort_mode( TrCore * core, const char * mode, gboolean is_reversed )
    574576{
    575577    const int col = MC_TORRENT;
     
    621623}
    622624
    623 static void
    624 watchdir_file_update_mtime( struct watchdir_file * file )
    625 {
    626     GFile * gfile = g_file_new_for_path( file->filename );
     625static time_t
     626get_file_mtime( const char * filename )
     627{
     628    time_t mtime;
     629    GFile * gfile = g_file_new_for_path( filename );
    627630    GFileInfo * info = g_file_query_info( gfile, G_FILE_ATTRIBUTE_TIME_MODIFIED, 0, NULL, NULL );
    628 
    629     file->mtime = g_file_info_get_attribute_uint64( info, G_FILE_ATTRIBUTE_TIME_MODIFIED );
    630 
     631    mtime = g_file_info_get_attribute_uint64( info, G_FILE_ATTRIBUTE_TIME_MODIFIED );
    631632    g_object_unref( G_OBJECT( info ) );
    632633    g_object_unref( G_OBJECT( gfile ) );
     634    return mtime;
    633635}
    634636
     
    637639{
    638640    struct watchdir_file * f;
    639 
    640641    f = g_new( struct watchdir_file, 1 );
    641642    f->filename = g_strdup( filename );
    642     watchdir_file_update_mtime( f );
    643 
     643    f->mtime = get_file_mtime( filename );
    644644    return f;
    645645}
     
    659659    GSList * monitor_files = NULL;
    660660    TrCore * core = TR_CORE( gcore );
    661     const time_t now = time( NULL );
     661    const time_t now = tr_time( );
    662662    struct TrCorePrivate * p = core->priv;
    663663
     
    666666    for( l=p->monitor_files; l!=NULL; l=l->next ) {
    667667        struct watchdir_file * f = l->data;
    668         watchdir_file_update_mtime( f );
     668        f->mtime = get_file_mtime( f->filename );
    669669        if( f->mtime + 2 >= now )
    670670            monitor_files = g_slist_prepend( monitor_files, f );
     
    752752core_watchdir_update( TrCore * core )
    753753{
    754     const char * filename = gtr_pref_string_get( PREF_KEY_DIR_WATCH );
     754    const char * dir = gtr_pref_string_get( PREF_KEY_DIR_WATCH );
    755755    const gboolean is_enabled = gtr_pref_flag_get( PREF_KEY_DIR_WATCH_ENABLED );
    756756    struct TrCorePrivate * p = TR_CORE( core )->priv;
    757757
    758     if( p->monitor && ( !is_enabled || gtr_strcmp0( filename, p->monitor_path ) ) )
     758    if( p->monitor && ( !is_enabled || gtr_strcmp0( dir, p->monitor_dir ) ) )
    759759    {
    760760        g_signal_handler_disconnect( p->monitor, p->monitor_tag );
    761         g_free( p->monitor_path );
     761        g_free( p->monitor_dir );
    762762        g_file_monitor_cancel( p->monitor );
    763763        g_object_unref( G_OBJECT( p->monitor ) );
    764         p->monitor_path = NULL;
     764        p->monitor_dir = NULL;
    765765        p->monitor = NULL;
    766766        p->monitor_tag = 0;
     
    769769    if( is_enabled && !p->monitor )
    770770    {
    771         GFile * file = g_file_new_for_path( filename );
     771        GFile * file = g_file_new_for_path( dir );
    772772        GFileMonitor * m = g_file_monitor_directory( file, 0, NULL, NULL );
    773773        core_watchdir_scan( core );
    774774        p->monitor = m;
    775         p->monitor_path = g_strdup( filename );
     775        p->monitor_dir = g_strdup( dir );
    776776        p->monitor_tag = g_signal_connect( m, "changed",
    777777                                           G_CALLBACK( on_file_changed_in_watchdir ), core );
     
    797797    else if( !strcmp( key, TR_PREFS_KEY_PEER_LIMIT_GLOBAL ) )
    798798    {
    799         const uint16_t val = gtr_pref_int_get( key );
    800         tr_sessionSetPeerLimit( gtr_core_session( core ), val );
     799        tr_sessionSetPeerLimit( gtr_core_session( core ),
     800                                gtr_pref_int_get( key ) );
    801801    }
    802802    else if( !strcmp( key, TR_PREFS_KEY_PEER_LIMIT_TORRENT ) )
    803803    {
    804         const uint16_t val = gtr_pref_int_get( key );
    805         tr_sessionSetPeerLimitPerTorrent( gtr_core_session( core ), val );
     804        tr_sessionSetPeerLimitPerTorrent( gtr_core_session( core ),
     805                                          gtr_pref_int_get( key ) );
    806806    }
    807807    else if( !strcmp( key, PREF_KEY_INHIBIT_HIBERNATION ) )
     
    827827    TrCore * core = TR_CORE( g_object_new( TR_CORE_TYPE, NULL ) );
    828828
    829     core->priv->session  = session;
     829    core->priv->session = session;
    830830
    831831    /* init from prefs & listen to pref changes */
     
    854854
    855855/***
     856****  COMPLETENESS CALLBACK
     857***/
     858
     859struct notify_callback_data
     860{
     861    TrCore * core;
     862    int torrent_id;
     863};
     864
     865static gboolean
     866on_torrent_completeness_changed_idle( gpointer gdata )
     867{
     868    struct notify_callback_data * data = gdata;
     869    gtr_notify_torrent_completed( data->core, data->torrent_id );
     870    g_object_unref( G_OBJECT( data->core ) );
     871    g_free( data );
     872    return FALSE;
     873}
     874
     875/* this is called in the libtransmission thread, *NOT* the GTK+ thread,
     876   so delegate to the GTK+ thread before calling notify's dbus code... */
     877static void
     878on_torrent_completeness_changed( tr_torrent       * tor,
     879                                 tr_completeness    completeness,
     880                                 tr_bool            was_running,
     881                                 void             * gcore )
     882{
     883    if( was_running && ( completeness != TR_LEECH ) && ( tr_torrentStat( tor )->sizeWhenDone != 0 ) )
     884    {
     885        struct notify_callback_data * data = g_new( struct notify_callback_data, 1 );
     886        data->core = gcore;
     887        data->torrent_id = tr_torrentId( tor );
     888        g_object_ref( G_OBJECT( data->core ) );
     889        gtr_idle_add( on_torrent_completeness_changed_idle, data );
     890    }
     891}
     892
     893/***
    856894****
    857895****  ADDING TORRENTS
     
    870908}
    871909
    872 struct notify_callback_data
    873 {
    874     TrCore * core;
    875     int torrent_id;
    876 };
    877 
    878 static gboolean
    879 on_torrent_completeness_changed_idle( gpointer gdata )
    880 {
    881     struct notify_callback_data * data = gdata;
    882     gtr_notify_torrent_completed( data->core, data->torrent_id );
    883     g_object_unref( G_OBJECT( data->core ) );
    884     g_free( data );
    885     return FALSE;
    886 }
    887 
    888 /* this is called in the libtransmission thread, *NOT* the GTK+ thread,
    889    so delegate to the GTK+ thread before calling notify's dbus code... */
    890 static void
    891 on_torrent_completeness_changed( tr_torrent       * tor,
    892                                  tr_completeness    completeness,
    893                                  tr_bool            was_running,
    894                                  void             * gcore )
    895 {
    896     if( was_running && ( completeness != TR_LEECH ) && ( tr_torrentStat( tor )->sizeWhenDone != 0 ) )
    897     {
    898         struct notify_callback_data * data = g_new( struct notify_callback_data, 1 );
    899         data->core = gcore;
    900         data->torrent_id = tr_torrentId( tor );
    901         g_object_ref( G_OBJECT( data->core ) );
    902         gtr_idle_add( on_torrent_completeness_changed_idle, data );
    903     }
    904 }
    905 
    906910static char *
    907911build_torrent_tracker_string( tr_torrent * tor )
     
    911915    const tr_info * inf = tr_torrentInfo( tor );
    912916
    913     for( i = 0; i < inf->trackerCount; ++i )
    914     {
    915         const tr_tracker_info * t = &inf->trackers[i];
    916         g_string_append( str, t->announce );
    917     }
     917    for( i=0; i<inf->trackerCount; ++i )
     918        g_string_append( str, inf->trackers[i].announce );
    918919
    919920    return g_string_free( str, FALSE );
     
    986987        const int is_internal = source && ( strstr( source, config ) == source );
    987988
    988         /* #1294: don't delete the source .torrent file if it's our internal copy */
     989        /* #1294: don't delete the .torrent file if it's our internal copy */
    989990        if( !is_internal )
    990991            gtr_file_trash_or_remove( source );
     
    995996
    996997static int
    997 core_add_ctor( TrCore * core, tr_ctor * ctor, gboolean do_prompt, gboolean do_notify )
     998core_add_ctor( TrCore * core, tr_ctor * ctor,
     999               gboolean do_prompt, gboolean do_notify )
    9981000{
    9991001    tr_info inf;
     
    11421144static void
    11431145on_url_done( tr_session   * session,
    1144              tr_bool        did_connect, 
     1146             tr_bool        did_connect,
    11451147             tr_bool        did_timeout,
    11461148             long           response_code,
     
    12381240void
    12391241gtr_core_add_list( TrCore    * core,
    1240                    GSList    * torrent_files,
     1242                   GSList    * files,
    12411243                   gboolean    do_start,
    12421244                   gboolean    do_prompt,
     
    12451247    GSList * l;
    12461248
    1247     for( l=torrent_files; l!=NULL; l=l->next )
     1249    for( l=files; l!=NULL; l=l->next )
    12481250    {
    12491251        char * filename = l->data;
     
    12541256    gtr_core_torrents_added( core );
    12551257
    1256     g_slist_free( torrent_files );
    1257 }
    1258 
    1259 void
    1260 gtr_core_add_list_defaults( TrCore * core, GSList * torrentFiles, gboolean do_notify )
     1258    g_slist_free( files );
     1259}
     1260
     1261void
     1262gtr_core_add_list_defaults( TrCore * core, GSList * files, gboolean do_notify )
    12611263{
    12621264    const gboolean do_start = gtr_pref_flag_get( TR_PREFS_KEY_START );
    12631265    const gboolean do_prompt = gtr_pref_flag_get( PREF_KEY_OPTIONS_PROMPT );
    12641266
    1265     gtr_core_add_list( core, torrentFiles, do_start, do_prompt, do_notify );
     1267    gtr_core_add_list( core, files, do_start, do_prompt, do_notify );
    12661268}
    12671269
     
    16331635{
    16341636    TrCore * core;
    1635     server_response_func * responseFunc;
    1636     gpointer responseFuncUserData;
     1637    server_response_func * response_func;
     1638    gpointer response_func_user_data;
    16371639};
    16381640
     
    16531655        struct pending_request_data * data = g_hash_table_lookup( pendingRequests, &tag );
    16541656        if( data ) {
    1655             if( data->responseFunc )
    1656                 (*data->responseFunc)(data->core, &top, data->responseFuncUserData );
     1657            if( data->response_func )
     1658                (*data->response_func)(data->core, &top, data->response_func_user_data );
    16571659            g_hash_table_remove( pendingRequests, &tag );
    16581660        }
     
    16761678static void
    16771679core_send_rpc_request( TrCore * core, const char * json, int tag,
    1678                        server_response_func * responseFunc,
    1679                        void * responseFuncUserData )
     1680                       server_response_func * response_func,
     1681                       void * response_func_user_data )
    16801682{
    16811683    tr_session * session = gtr_core_session( core );
     
    16961698        data = g_new0( struct pending_request_data, 1 );
    16971699        data->core = core;
    1698         data->responseFunc = responseFunc;
    1699         data->responseFuncUserData = responseFuncUserData;
     1700        data->response_func = response_func;
     1701        data->response_func_user_data = response_func_user_data;
    17001702        g_hash_table_insert( pendingRequests, g_memdup( &tag, sizeof( int ) ), data );
    17011703
     
    17131715
    17141716static void
    1715 on_port_test_response( TrCore * core, tr_benc * response, gpointer userData UNUSED )
     1717on_port_test_response( TrCore * core, tr_benc * response, gpointer u UNUSED )
    17161718{
    17171719    tr_benc * args;
    1718     tr_bool isOpen = FALSE;
     1720    tr_bool is_open = FALSE;
    17191721
    17201722    if( tr_bencDictFindDict( response, "arguments", &args ) )
    1721         tr_bencDictFindBool( args, "port-is-open", &isOpen );
    1722 
    1723     core_emit_port_tested( core, isOpen );
     1723        tr_bencDictFindBool( args, "port-is-open", &is_open );
     1724
     1725    core_emit_port_tested( core, is_open );
    17241726}
    17251727
     
    17271729gtr_core_port_test( TrCore * core )
    17281730{
    1729     char buf[128];
     1731    char buf[64];
    17301732    const int tag = nextTag++;
    17311733    g_snprintf( buf, sizeof( buf ), "{ \"method\": \"port-test\", \"tag\": %d }", tag );
     
    17471749
    17481750    if( ruleCount > 0 )
    1749         gtr_pref_int_set( "blocklist-date", time( NULL ) );
     1751        gtr_pref_int_set( "blocklist-date", tr_time( ) );
    17501752
    17511753    core_emit_blocklist_udpated( core, ruleCount );
     
    17551757gtr_core_blocklist_update( TrCore * core )
    17561758{
    1757     char buf[128];
     1759    char buf[64];
    17581760    const int tag = nextTag++;
    17591761    g_snprintf( buf, sizeof( buf ), "{ \"method\": \"blocklist-update\", \"tag\": %d }", tag );
  • trunk/gtk/tr-core.h

    r12087 r12090  
    109109void gtr_core_add_list( TrCore *    self,
    110110                        GSList *    torrentFiles,
    111                         gboolean    doStart,
    112                         gboolean    doPrompt,
    113                         gboolean    doNotify );
     111                        gboolean    do_start,
     112                        gboolean    do_prompt,
     113                        gboolean    do_notify );
    114114
    115115void gtr_core_add_list_defaults( TrCore    * core,
    116116                                 GSList    * torrentFiles,
    117                                  gboolean    doNotify );
     117                                 gboolean    do_notify );
    118118
    119119/** @brief Add a torrent. */
     
    131131
    132132/** Add a torrent. */
    133 void gtr_core_add_torrent( TrCore*, tr_torrent*, gboolean doNotify );
     133void gtr_core_add_torrent( TrCore*, tr_torrent*, gboolean do_notify );
    134134
    135135/** Present the main window */
  • trunk/gtk/tr-icon.c

    r12068 r12090  
    2626#ifndef STATUS_ICON_SUPPORTED
    2727gpointer gtr_icon_new( TrCore * core UNUSED ) { return NULL; }
    28 void gtr_icon_refresh( gpointer vicon UNUSED ) { } 
     28void gtr_icon_refresh( gpointer vicon UNUSED ) { }
    2929#else
    3030
Note: See TracChangeset for help on using the changeset viewer.