Changeset 12068


Ignore:
Timestamp:
Mar 3, 2011, 1:59:25 AM (11 years ago)
Author:
jordan
Message:

(trunk gtk) remove the TrTorrent? GObject subclass.

Location:
trunk/gtk
Files:
2 deleted
25 edited

Legend:

Unmodified
Added
Removed
  • trunk/gtk/Makefile.am

    r11920 r12068  
    5757    tr-icon.h \
    5858    tr-prefs.h \
    59     tr-torrent.h \
    6059    tr-window.h \
    6160    ui.h \
     
    8786    tr-icon.c \
    8887    tr-prefs.c \
    89     tr-torrent.c \
    9088    tr-window.c \
    9189    util.c \
     
    137135
    138136tr-core-dbus.h: $(srcdir)/tr-core-dbus.xml
    139         $(DBUS_BINDING_TOOL) --mode=glib-server --prefix=tr_core $< > $(@F)
     137        $(DBUS_BINDING_TOOL) --mode=glib-server --prefix=gtr_core $< > $(@F)
    140138
    141139if WIN32
  • trunk/gtk/actions.c

    r11726 r12068  
    7070    const char * val = sort_radio_entries[i].name;
    7171
    72     tr_core_set_pref( myCore, key, val );
     72    gtr_core_set_pref( myCore, key, val );
    7373}
    7474
     
    8686    const gboolean val = gtk_toggle_action_get_active( action );
    8787
    88     tr_core_set_pref_bool( myCore, key, val );
     88    gtr_core_set_pref_bool( myCore, key, val );
    8989}
    9090
  • trunk/gtk/conf.c

    r11709 r12068  
    194194    tr_bencDictAddStr( d, TR_PREFS_KEY_DOWNLOAD_DIR, str );
    195195
    196     tr_bencDictAddBool( d, PREF_KEY_ASKQUIT, TRUE );
    197 
    198196    tr_bencDictAddStr( d, PREF_KEY_SORT_MODE, "sort-by-name" );
    199197    tr_bencDictAddBool( d, PREF_KEY_SORT_REVERSED, FALSE );
  • trunk/gtk/details.c

    r11983 r12068  
    106106getTorrents( struct DetailsImpl * d, int * setmeCount )
    107107{
    108     int n = g_slist_length( d->ids );
     108    GSList * l;
    109109    int torrentCount = 0;
    110     tr_session * session = tr_core_session( d->core );
    111     tr_torrent ** torrents = NULL;
    112 
    113     if( session != NULL )
    114     {
    115         GSList * l;
    116 
    117         torrents = g_new( tr_torrent*, n );
    118 
    119         for( l=d->ids; l!=NULL; l=l->next ) {
    120             const int id = GPOINTER_TO_INT( l->data );
    121             tr_torrent * tor = tr_torrentFindFromId( session, id );
    122             if( tor )
    123                 torrents[torrentCount++] = tor;
    124         }
    125     }
     110    const int n = g_slist_length( d->ids );
     111    tr_torrent ** torrents = g_new( tr_torrent*, n );
     112
     113    for( l=d->ids; l!=NULL; l=l->next )
     114        if(( torrents[torrentCount] = gtr_core_find_torrent( d->core, GPOINTER_TO_INT( l->data ))))
     115            ++torrentCount;
    126116
    127117    *setmeCount = torrentCount;
     
    334324        tr_bencListAddInt( ids, GPOINTER_TO_INT( l->data ) );
    335325
    336     tr_core_exec( di->core, &top );
     326    gtr_core_exec( di->core, &top );
    337327    tr_bencFree( &top );
    338328}
     
    352342        tr_bencListAddInt( ids, GPOINTER_TO_INT( l->data ) );
    353343
    354     tr_core_exec( di->core, &top );
     344    gtr_core_exec( di->core, &top );
    355345    tr_bencFree( &top );
    356346}
     
    370360        tr_bencListAddInt( ids, GPOINTER_TO_INT( l->data ) );
    371361
    372     tr_core_exec( di->core, &top );
     362    gtr_core_exec( di->core, &top );
    373363    tr_bencFree( &top );
    374364}
     
    16541644    const char * key = PREF_KEY_SHOW_MORE_PEER_INFO;
    16551645    const gboolean value = gtk_toggle_button_get_active( button );
    1656     tr_core_set_pref_bool( di->core, key, value );
     1646    gtr_core_set_pref_bool( di->core, key, value );
    16571647    setPeerViewColumns( GTK_TREE_VIEW( di->peer_view ) );
    16581648}
     
    19501940{
    19511941    const int torrent_id = tracker_list_get_current_torrent_id( di );
    1952     tr_session * session = tr_core_session( di->core );
    1953     return tr_torrentFindFromId( session, torrent_id );
     1942    return gtr_core_find_torrent( di->core, torrent_id );
    19541943}
    19551944
     
    19881977    GHashTable * hash = di->tracker_hash;
    19891978    GtkListStore * store = di->tracker_store;
    1990     tr_session * session = tr_core_session( di->core );
     1979    tr_session * session = gtr_core_session( di->core );
    19911980    const gboolean showScrape = gtk_toggle_button_get_active( GTK_TOGGLE_BUTTON( di->scrape_check ) );
    19921981
     
    20922081    const char * key = PREF_KEY_SHOW_MORE_TRACKER_INFO;
    20932082    const gboolean value = gtk_toggle_button_get_active( button );
    2094     tr_core_set_pref_bool( di->core, key, value );
     2083    gtr_core_set_pref_bool( di->core, key, value );
    20952084    refresh( di );
    20962085}
     
    21012090    const char * key = PREF_KEY_SHOW_BACKUP_TRACKERS;
    21022091    const gboolean value = gtk_toggle_button_get_active( button );
    2103     tr_core_set_pref_bool( di->core, key, value );
     2092    gtr_core_set_pref_bool( di->core, key, value );
    21042093    refresh( di );
    21052094}
     
    21182107        const int torrent_id = GPOINTER_TO_INT( g_object_get_data( G_OBJECT( dialog ), "torrent-id" ) );
    21192108        GtkTextBuffer * text_buffer = g_object_get_data( G_OBJECT( dialog ), "text-buffer" );
    2120         tr_session * session = tr_core_session( di->core );
    2121         tr_torrent * tor = tr_torrentFindFromId( session, torrent_id );
     2109        tr_torrent * tor = gtr_core_find_torrent( di->core, torrent_id );
    21222110
    21232111        if( tor != NULL )
     
    22852273                    "}\n",
    22862274                    torrent_id, url );
    2287                 tr_core_exec_json( di->core, json );
     2275                gtr_core_exec_json( di->core, json );
    22882276                refresh( di );
    22892277                g_free( json );
     
    23662354                                "}\n",
    23672355                                torrent_id, tracker_id );
    2368         tr_core_exec_json( di->core, json );
     2356        gtr_core_exec_json( di->core, json );
    23692357        refresh( di );
    23702358        g_free( json );
     
    25792567    {
    25802568        const int id = GPOINTER_TO_INT( ids->data );
    2581         tr_session * session = tr_core_session( di->core );
    2582         tr_torrent * tor = tr_torrentFindFromId( session, id );
     2569        tr_torrent * tor = gtr_core_find_torrent( di->core, id );
    25832570        const tr_info * inf = tr_torrentInfo( tor );
    25842571        g_snprintf( title, sizeof( title ), _( "%s Properties" ), inf->name );
  • trunk/gtk/dialogs.c

    r11709 r12068  
    2828#include <libtransmission/transmission.h>
    2929
    30 #include "conf.h"
    3130#include "dialogs.h"
    32 #include "hig.h"
    3331#include "tr-core.h"
    34 #include "tr-prefs.h"
    3532
    3633/***
     
    3835***/
    3936
    40 struct quitdata
     37struct delete_data
    4138{
    42     TrCore *          core;
    43     callbackfunc_t    func;
    44     void *            cbdata;
    45     GtkWidget *       dontask;
     39    gboolean   delete_files;
     40    GSList   * torrent_ids;
     41    TrCore   * core;
    4642};
    4743
    4844static void
    49 quitresp( GtkWidget * widget,
    50           int         response,
    51           gpointer    data )
     45on_remove_dialog_response( GtkDialog * dialog, gint response, gpointer gdd )
    5246{
    53     struct quitdata * stuff = data;
    54     GtkToggleButton * tb = GTK_TOGGLE_BUTTON( stuff->dontask );
    55 
    56     tr_core_set_pref_bool( stuff->core,
    57                           PREF_KEY_ASKQUIT,
    58                           !gtk_toggle_button_get_active( tb ) );
     47    GSList * l;
     48    struct delete_data * dd = gdd;
    5949
    6050    if( response == GTK_RESPONSE_ACCEPT )
    61         stuff->func( stuff->cbdata );
    62 
    63     g_free( stuff );
    64     gtk_widget_destroy( widget );
    65 }
    66 
    67 GtkWidget *
    68 gtr_confirm_quit( GtkWindow *    parent,
    69                   TrCore *       core,
    70                   callbackfunc_t func,
    71                   void *         cbdata )
    72 {
    73     struct quitdata * stuff;
    74     GtkWidget *       w;
    75     GtkWidget *       wind;
    76     GtkWidget *       dontask;
    77 
    78     stuff          = g_new( struct quitdata, 1 );
    79     stuff->func    = func;
    80     stuff->cbdata  = cbdata;
    81     stuff->core    = core;
    82 
    83     wind = gtk_message_dialog_new_with_markup(
    84          parent,
    85         GTK_DIALOG_DESTROY_WITH_PARENT,
    86         GTK_MESSAGE_WARNING,
    87         GTK_BUTTONS_NONE,
    88         _(
    89             "<big><b>Quit Transmission?</b></big>" ) );
    90 
    91     gtk_dialog_add_button( GTK_DIALOG( wind ), GTK_STOCK_CANCEL,
    92                                                GTK_RESPONSE_CANCEL );
    93     w = gtk_dialog_add_button( GTK_DIALOG( wind ), GTK_STOCK_QUIT,
    94                                                    GTK_RESPONSE_ACCEPT );
    95     gtk_dialog_set_default_response( GTK_DIALOG( wind ),
    96                                      GTK_RESPONSE_ACCEPT );
    97     gtk_dialog_set_alternative_button_order( GTK_DIALOG( wind ),
    98                                              GTK_RESPONSE_ACCEPT,
    99                                              GTK_RESPONSE_CANCEL,
    100                                              -1 );
    101     dontask = gtk_check_button_new_with_mnemonic( _( "_Don't ask me again" ) );
    102     stuff->dontask = dontask;
    103 
    104     gtr_dialog_set_content( GTK_DIALOG( wind ), dontask );
    105 
    106     g_signal_connect( G_OBJECT( wind ), "response",
    107                       G_CALLBACK( quitresp ), stuff );
    108     gtk_widget_grab_focus( w );
    109 
    110     gtk_widget_show( wind );
    111     return wind;
    112 }
    113 
    114 /***
    115 ****
    116 ***/
    117 
    118 struct DeleteData
    119 {
    120     gboolean    delete_files;
    121     GSList *    torrents;
    122     TrCore *    core;
    123 };
    124 
    125 static void
    126 removeTorrents( struct DeleteData * data )
    127 {
    128     GSList * l;
    129 
    130     for( l = data->torrents; l != NULL; l = l->next )
    131         tr_core_remove_torrent( data->core, l->data, data->delete_files );
    132     g_slist_free( data->torrents );
    133     data->torrents = NULL;
    134 }
    135 
    136 static void
    137 removeResponse( GtkDialog * dialog,
    138                 gint        response,
    139                 gpointer    gdata )
    140 {
    141     struct DeleteData * data = gdata;
    142 
    143     if( response == GTK_RESPONSE_ACCEPT )
    144         removeTorrents( data );
     51        for( l=dd->torrent_ids; l!=NULL; l=l->next )
     52            gtr_core_remove_torrent( dd->core, GPOINTER_TO_INT( l->data ), dd->delete_files );
    14553
    14654    gtk_widget_destroy( GTK_WIDGET( dialog ) );
    147     g_slist_free( data->torrents );
    148     g_free( data );
    149 }
    150 
    151 struct count_data
    152 {
    153     int incomplete;
    154     int connected;
    155 };
    156 
    157 static void
    158 countBusyTorrents( gpointer gtor, gpointer gdata )
    159 {
    160     const tr_stat * stat = tr_torrent_stat( gtor );
    161     struct count_data * data = gdata;
    162 
    163     if( stat->leftUntilDone ) ++data->incomplete;
    164     if( stat->peersConnected ) ++data->connected;
     55    g_slist_free( dd->torrent_ids );
     56    g_free( dd );
    16557}
    16658
     
    16860gtr_confirm_remove( GtkWindow  * parent,
    16961                    TrCore     * core,
    170                     GSList     * torrents,
     62                    GSList     * torrent_ids,
    17163                    gboolean     delete_files )
    17264{
    173     GtkWidget *         d;
    174     const int           count = g_slist_length( torrents );
    175     struct count_data   counts;
    176     GString           * primary_text;
    177     GString           * secondary_text;
    178     struct DeleteData * dd;
     65    GSList * l;
     66    GtkWidget * d;
     67    GString * primary_text;
     68    GString * secondary_text;
     69    struct delete_data * dd;
     70    int connected = 0;
     71    int incomplete = 0;
     72    const int count = g_slist_length( torrent_ids );
    17973
    18074    if( !count )
    18175        return;
    18276
    183     dd = g_new0( struct DeleteData, 1 );
     77    dd = g_new0( struct delete_data, 1 );
    18478    dd->core = core;
    185     dd->torrents = torrents;
     79    dd->torrent_ids = torrent_ids;
    18680    dd->delete_files = delete_files;
    18781
    188     counts.incomplete = 0;
    189     counts.connected = 0;
    190     g_slist_foreach( torrents, countBusyTorrents, &counts );
     82    for( l=torrent_ids; l!=NULL; l=l->next )
     83    {
     84        const int id = GPOINTER_TO_INT( l->data );
     85        tr_torrent * tor = gtr_core_find_torrent( core, id );
     86        const tr_stat * stat = tr_torrentStat( tor );
     87        if( stat->leftUntilDone ) ++incomplete;
     88        if( stat->peersConnected ) ++connected;
     89    }
    19190
    19291    primary_text = g_string_new( NULL );
     
    207106    secondary_text = g_string_new( NULL );
    208107
    209     if( !counts.incomplete && !counts.connected )
     108    if( !incomplete && !connected )
    210109    {
    211110        g_string_assign( secondary_text, gtr_ngettext(
     
    214113                count ) );
    215114    }
    216     else if( count == counts.incomplete )
     115    else if( count == incomplete )
    217116    {
    218117        g_string_assign( secondary_text, gtr_ngettext( "This torrent has not finished downloading.",
     
    220119                                                       count ) );
    221120    }
    222     else if( count == counts.connected )
     121    else if( count == connected )
    223122    {
    224123        g_string_assign( secondary_text, gtr_ngettext( "This torrent is connected to peers.",
     
    228127    else
    229128    {
    230         if( counts.connected )
     129        if( connected )
    231130            g_string_append( secondary_text, gtr_ngettext( "One of these torrents is connected to peers.",
    232131                                                           "Some of these torrents are connected to peers.",
    233                                                        counts.connected ) );
    234         if( counts.connected && counts.incomplete )
     132                                                       connected ) );
     133        if( connected && incomplete )
    235134            g_string_append( secondary_text, "\n" );
    236135
    237         if( counts.incomplete )
     136        if( incomplete )
    238137            g_string_assign( secondary_text, gtr_ngettext( "One of these torrents has not finished downloading.",
    239138                                                           "Some of these torrents have not finished downloading.",
    240                                                        counts.incomplete ) );
     139                                                       incomplete ) );
    241140    }
    242141
     
    261160                                             GTK_RESPONSE_CANCEL,
    262161                                             -1 );
    263     g_signal_connect( d, "response", G_CALLBACK( removeResponse ), dd );
     162    g_signal_connect( d, "response", G_CALLBACK( on_remove_dialog_response ), dd );
    264163    gtk_widget_show_all( d );
    265164
  • trunk/gtk/dialogs.h

    r11709 r12068  
    2727
    2828#include "tr-core.h"
    29 #include "tr-torrent.h"
    3029#include "util.h"
    31 
    32 
    33 /* used for a callback function with a data parameter */
    34 typedef void ( *callbackfunc_t )( gpointer );
    35 
    36 /**
    37  * Prompt the user to confirm exiting the app.
    38  * Call func(cbdata) if user confirms.
    39  */
    40 GtkWidget * gtr_confirm_quit   ( GtkWindow       * parent,
    41                                  TrCore          * core,
    42                                  callbackfunc_t    func,
    43                                  gpointer          cbdata );
    4430
    4531/**
    4632 * Prompt the user to confirm removing a torrent.
    4733 */
    48 void        gtr_confirm_remove ( GtkWindow * parent,
    49                                  TrCore    * core,
    50                                  GSList    * gtorrents,
    51                                  gboolean    doDelete );
     34void gtr_confirm_remove ( GtkWindow * parent,
     35                          TrCore    * core,
     36                          GSList    * gtorrents,
     37                          gboolean    doDelete );
    5238
    5339#endif /* GTR_DIALOGS_H */
  • trunk/gtk/file-list.c

    r11891 r12068  
    1919
    2020#include <libtransmission/transmission.h>
     21#include <libtransmission/utils.h>
    2122
    2223#include "file-list.h"
     
    2425#include "icons.h"
    2526#include "tr-prefs.h"
     27#include "util.h"
    2628
    2729#define TR_DOWNLOAD_KEY  "tr-download-key"
     
    244246refresh( FileData * data )
    245247{
    246     tr_torrent * tor = NULL;
    247     tr_session * session = tr_core_session( data->core );
    248 
    249     if( session != NULL )
    250         tor = tr_torrentFindFromId( session, data->torrentId );
     248    tr_torrent * tor = gtr_core_find_torrent( data->core, data->torrentId );
    251249
    252250    if( tor == NULL )
     
    266264        refresh_data.resort_needed = FALSE;
    267265        refresh_data.refresh_file_stat = tr_torrentFiles( tor, &fileCount );
    268         refresh_data.tor = tr_torrentFindFromId( session, data->torrentId );
     266        refresh_data.tor = tor;
    269267        refresh_data.file_data = data;
    270268
     
    528526    if( torrentId > 0 )
    529527    {
    530         tr_session * session = tr_core_session( data->core );
    531         tr_torrent * tor = tr_torrentFindFromId( session, torrentId );
     528        tr_torrent * tor = gtr_core_find_torrent( data->core, torrentId );
    532529        if( tor != NULL )
    533530        {
     
    650647    gboolean handled = FALSE;
    651648    FileData * data = gdata;
    652     tr_torrent * tor = tr_torrentFindFromId( tr_core_session( data->core ), data->torrentId );
     649    tr_torrent * tor = gtr_core_find_torrent( data->core, data->torrentId );
    653650
    654651    if( tor != NULL )
     
    695692
    696693    cid = GPOINTER_TO_INT( g_object_get_data( G_OBJECT( col ), TR_COLUMN_ID_KEY ) );
    697     tor = tr_torrentFindFromId( tr_core_session( data->core ), data->torrentId );
     694    tor = gtr_core_find_torrent( data->core, data->torrentId );
    698695    if( ( tor != NULL ) && ( ( cid == FC_PRIORITY ) || ( cid == FC_ENABLED ) ) )
    699696    {
     
    768765onViewButtonPressed( GtkWidget * w, GdkEventButton * event, gpointer gdata )
    769766{
    770     tr_torrent        * tor;
    771     GtkTreeViewColumn * col = NULL;
    772     GtkTreePath       * path = NULL;
    773     FileData          * data = gdata;
    774     gboolean            handled = FALSE;
    775     GtkTreeView       * treeview = GTK_TREE_VIEW( w );
    776 
    777     tor = tr_torrentFindFromId( tr_core_session( data->core ),
    778                                 data->torrentId );
    779     if( tor == NULL )
    780         return FALSE;
    781 
    782     if( event->type == GDK_BUTTON_PRESS && event->button == 1
    783         && !( event->state & ( GDK_SHIFT_MASK | GDK_CONTROL_MASK ) )
    784         && getAndSelectEventPath( treeview, event, &col, &path ) )
    785     {
    786         handled = onViewPathToggled( treeview, col, path, data );
    787     }
    788 
    789     gtk_tree_path_free( path );
     767    tr_torrent * tor;
     768    gboolean handled = FALSE;
     769    FileData * data = gdata;
     770
     771    if(( tor = gtr_core_find_torrent( data->core, data->torrentId )))
     772    {
     773        GtkTreePath * path;
     774        GtkTreeViewColumn * col;
     775        GtkTreeView * treeview = GTK_TREE_VIEW( w );
     776
     777        if( event->type == GDK_BUTTON_PRESS && event->button == 1
     778            && !( event->state & ( GDK_SHIFT_MASK | GDK_CONTROL_MASK ) )
     779            && getAndSelectEventPath( treeview, event, &col, &path ) )
     780            handled = onViewPathToggled( treeview, col, path, data );
     781
     782        gtk_tree_path_free( path );
     783    }
     784
    790785    return handled;
    791786}
  • trunk/gtk/filter.c

    r11801 r12068  
    2020#include "filter.h"
    2121#include "hig.h" /* GUI_PAD */
    22 #include "tr-core.h" /* MC_TORRENT_RAW */
     22#include "tr-core.h" /* MC_TORRENT */
    2323#include "util.h" /* gtr_idle_add() */
    2424
     
    150150        char ** keys;
    151151
    152         gtk_tree_model_get( tmodel, &iter, MC_TORRENT_RAW, &tor, -1 );
     152        gtk_tree_model_get( tmodel, &iter, MC_TORRENT, &tor, -1 );
    153153        inf = tr_torrentInfo( tor );
    154154        keyCount = 0;
     
    693693        if( gtk_tree_model_get_iter_first( tmodel, &torrent_iter )) do {
    694694            tr_torrent * tor;
    695             gtk_tree_model_get( tmodel, &torrent_iter, MC_TORRENT_RAW, &tor, -1 );
     695            gtk_tree_model_get( tmodel, &torrent_iter, MC_TORRENT, &tor, -1 );
    696696            if( test_torrent_activity( tor, type ) )
    697697                ++hits;
     
    911911    GObject * o = G_OBJECT( data->filter_model );
    912912
    913     gtk_tree_model_get( model, iter, MC_TORRENT_RAW, &tor, -1 );
     913    gtk_tree_model_get( model, iter, MC_TORRENT, &tor, -1 );
    914914
    915915    text = (const char*) g_object_get_data( o, TEXT_KEY );
  • trunk/gtk/main.c

    r11923 r12068  
    6363#include "tr-icon.h"
    6464#include "tr-prefs.h"
    65 #include "tr-torrent.h"
    6665#include "tr-window.h"
    6766#include "util.h"
     
    8281struct cbdata
    8382{
    84     gboolean            isIconified;
    85     gboolean            isClosing;
     83    gboolean            is_iconified;
    8684    guint               timer;
    8785    guint               refresh_actions_tag;
     
    169167        GtkTreeIter iter;
    170168        if( gtk_tree_model_get_iter( model, &iter, l->data ) ) {
    171             tr_torrent * tor;
    172             gtk_tree_model_get( model, &iter, MC_TORRENT_RAW, &tor, -1 );
    173             ids = g_slist_append( ids, GINT_TO_POINTER( tr_torrentId( tor ) ) );
     169            int id;
     170            gtk_tree_model_get( model, &iter, MC_TORRENT_ID, &id, -1 );
     171            ids = g_slist_append( ids, GINT_TO_POINTER( id ) );
    174172        }
    175173    }
     
    294292{
    295293    tr_torrent * tor;
    296     gtk_tree_model_get( model, iter, MC_TORRENT_RAW, &tor, -1 );
     294    gtk_tree_model_get( model, iter, MC_TORRENT, &tor, -1 );
    297295    *(int*)accumulated_status |= tr_torrentCanManualUpdate( tor );
    298296}
     
    304302    struct counts_data sel_counts;
    305303    struct cbdata * data = gdata;
    306     const size_t total = tr_core_get_torrent_count( data->core );
    307     const size_t active = tr_core_get_active_torrent_count( data->core );
    308     const int torrent_count = gtk_tree_model_iter_n_children( tr_core_model( data->core ), NULL );
     304    const size_t total = gtr_core_get_torrent_count( data->core );
     305    const size_t active = gtr_core_get_active_torrent_count( data->core );
     306    const int torrent_count = gtk_tree_model_iter_n_children( gtr_core_model( data->core ), NULL );
    309307
    310308    gtr_action_set_sensitive( "select-all", torrent_count != 0 );
     
    346344***/
    347345
    348 static void appsetup( TrWindow       * wind,
    349                       GSList         * args,
    350                       struct cbdata  * cbdata,
    351                       gboolean         paused,
    352                       gboolean         minimized );
    353 
    354 static void winsetup( struct cbdata * cbdata, TrWindow * wind );
    355 
    356 static void wannaquit( gpointer vdata );
     346static void app_setup( TrWindow       * wind,
     347                       GSList         * args,
     348                       struct cbdata  * cbdata,
     349                       gboolean         paused,
     350                       gboolean         minimized );
     351
     352static void main_window_setup( struct cbdata * cbdata, TrWindow * wind );
     353
     354static void on_app_exit( gpointer vdata );
    357355
    358356static void on_core_error( TrCore *, guint, const char *, struct cbdata * );
     
    362360static void on_prefs_changed( TrCore * core, const char * key, gpointer );
    363361
    364 static gboolean updatemodel( gpointer gdata );
     362static gboolean update_model( gpointer gdata );
    365363
    366364/***
     
    369367
    370368static void
    371 registerMagnetLinkHandler( void )
     369register_magnet_link_handler( void )
    372370{
    373371#ifdef HAVE_GCONF2
     
    403401
    404402static void
    405 onMainWindowSizeAllocated( GtkWidget      * gtk_window,
    406                            GtkAllocation  * alloc UNUSED,
    407                            gpointer         gdata UNUSED )
     403on_main_window_size_allocated( GtkWidget      * gtk_window,
     404                               GtkAllocation  * alloc UNUSED,
     405                               gpointer         gdata UNUSED )
    408406{
    409407    GdkWindow * gdk_window = gtr_widget_get_window( gtk_window );
     
    425423}
    426424
    427 static sig_atomic_t global_sigcount = 0;
    428 static struct cbdata * sighandler_cbdata = NULL;
    429 
    430 static void
    431 signal_handler( int sig )
    432 {
    433     if( ++global_sigcount > 1 )
    434     {
    435         signal( sig, SIG_DFL );
    436         raise( sig );
    437     }
    438     else switch( sig )
    439     {
    440         case SIGINT:
    441         case SIGTERM:
    442             g_message( _( "Got signal %d; trying to shut down cleanly. Do it again if it gets stuck." ), sig );
    443             gtr_actions_handler( "quit", sighandler_cbdata );
    444             break;
    445 
    446         default:
    447             g_message( "unhandled signal" );
    448             break;
    449     }
    450 }
     425/***
     426**** listen to changes that come from RPC
     427***/
    451428
    452429struct torrent_idle_data
     
    462439    struct torrent_idle_data * data = gdata;
    463440
    464     tr_core_remove_torrent_from_id( data->core, data->id, data->delete_files );
     441    gtr_core_remove_torrent( data->core, data->id, data->delete_files );
    465442
    466443    g_free( data );
     
    474451    struct torrent_idle_data * data = gdata;
    475452
    476     if(( tor = tr_torrentFindFromId( tr_core_session( data->core ), data->id )))
    477         tr_core_add_torrent( data->core, tr_torrent_new_preexisting( tor ), TRUE );
     453    if(( tor = gtr_core_find_torrent( data->core, data->id )))
     454        gtr_core_add_torrent( data->core, tor, TRUE );
    478455
    479456    g_free( data );
     
    481458}
    482459
    483 
    484 static void
    485 setupsighandlers( void )
    486 {
    487     signal( SIGINT, signal_handler );
    488     signal( SIGKILL, signal_handler );
    489 }
    490 
    491460static tr_rpc_callback_status
    492 onRPCChanged( tr_session            * session,
    493               tr_rpc_callback_type    type,
    494               struct tr_torrent     * tor,
    495               void                  * gdata )
     461on_rpc_changed( tr_session            * session,
     462                tr_rpc_callback_type    type,
     463                struct tr_torrent     * tor,
     464                void                  * gdata )
    496465{
    497466    tr_rpc_callback_status status = TR_RPC_OK;
     
    573542}
    574543
     544/***
     545****  signal handling
     546***/
     547
     548static sig_atomic_t global_sigcount = 0;
     549static struct cbdata * sighandler_cbdata = NULL;
     550
     551static void
     552signal_handler( int sig )
     553{
     554    if( ++global_sigcount > 1 )
     555    {
     556        signal( sig, SIG_DFL );
     557        raise( sig );
     558    }
     559    else switch( sig )
     560    {
     561        case SIGINT:
     562        case SIGTERM:
     563            g_message( _( "Got signal %d; trying to shut down cleanly. Do it again if it gets stuck." ), sig );
     564            gtr_actions_handler( "quit", sighandler_cbdata );
     565            break;
     566
     567        default:
     568            g_message( "unhandled signal" );
     569            break;
     570    }
     571}
     572
     573static void
     574setupsighandlers( void )
     575{
     576    signal( SIGINT, signal_handler );
     577    signal( SIGKILL, signal_handler );
     578}
     579
     580/***
     581****
     582***/
     583
    575584static GSList *
    576585checkfilenames( int argc, char **argv )
     
    609618#ifdef HAVE_GCONF2
    610619static void
    611 applyDesktopProxySettings( CURL * easy, GConfClient * client, const char * host_key, const char * port_key )
     620apply_desktop_proxy_settings( CURL * easy, GConfClient * client, const char * host_key, const char * port_key )
    612621{
    613622    int port;
     
    668677
    669678static void
    670 curlConfigFunc( tr_session * session UNUSED, void * vcurl UNUSED, const char * destination )
     679curl_config_func( tr_session * session UNUSED, void * vcurl UNUSED, const char * destination )
    671680{
    672681#ifdef HAVE_GCONF2
     
    683692        if( !gtr_strcmp0( mode, "auto" ) )
    684693        {
    685             applyDesktopProxySettings( easy, client, "/system/proxy/autoconfig_url", NULL );
     694            apply_desktop_proxy_settings( easy, client, "/system/proxy/autoconfig_url", NULL );
    686695            use_http_proxy = FALSE;
    687696        }
     
    693702                if( !gtr_strcmp0( scheme, "ftp" ) )
    694703                {
    695                     applyDesktopProxySettings( easy, client, "/system/proxy/ftp_host", "/system/proxy/ftp_port" );
     704                    apply_desktop_proxy_settings( easy, client, "/system/proxy/ftp_host", "/system/proxy/ftp_port" );
    696705                    use_http_proxy = FALSE;
    697706                }
    698707                else if( !gtr_strcmp0( scheme, "https" ) )
    699708                {
    700                     applyDesktopProxySettings( easy, client, "/system/proxy/secure_host", "/system/proxy/secure_port" );
     709                    apply_desktop_proxy_settings( easy, client, "/system/proxy/secure_host", "/system/proxy/secure_port" );
    701710                    use_http_proxy = FALSE;
    702711                }
     
    719728    {
    720729        gboolean auth = FALSE;
    721         applyDesktopProxySettings( easy, client, "/system/http_proxy/host", "/system/http_proxy/port" );
     730        apply_desktop_proxy_settings( easy, client, "/system/http_proxy/host", "/system/http_proxy/port" );
    722731
    723732        if(( value = gconf_client_get( client, "/system/http_proxy/use_authentication", NULL )))
     
    882891        /* initialize the libtransmission session */
    883892        session = tr_sessionInit( "gtk", configDir, TRUE, gtr_pref_get_all( ) );
    884         tr_sessionSetWebConfigFunc( session, curlConfigFunc );
     893        tr_sessionSetWebConfigFunc( session, curl_config_func );
    885894
    886895        gtr_pref_flag_set( TR_PREFS_KEY_ALT_SPEED_ENABLED, tr_sessionUsesAltSpeed( session ) );
    887896        gtr_pref_int_set( TR_PREFS_KEY_PEER_PORT, tr_sessionGetPeerPort( session ) );
    888         cbdata->core = tr_core_new( session );
     897        cbdata->core = gtr_core_new( session );
    889898
    890899        /* init the ui manager */
     
    897906        /* create main window now to be a parent to any error dialogs */
    898907        win = GTK_WINDOW( gtr_window_new( myUIManager, cbdata->core ) );
    899         g_signal_connect( win, "size-allocate", G_CALLBACK( onMainWindowSizeAllocated ), cbdata );
    900 
    901         appsetup( win, argfiles, cbdata, startpaused, startminimized );
    902         tr_sessionSetRPCCallback( session, onRPCChanged, cbdata );
     908        g_signal_connect( win, "size-allocate", G_CALLBACK( on_main_window_size_allocated ), cbdata );
     909
     910        app_setup( win, argfiles, cbdata, startpaused, startminimized );
     911        tr_sessionSetRPCCallback( session, on_rpc_changed, cbdata );
    903912
    904913        /* on startup, check & see if it's time to update the blocklist */
     
    909918                const time_t now = time( NULL );
    910919                if( last_time + SECONDS_IN_A_WEEK < now )
    911                     tr_core_blocklist_update( cbdata->core );
     920                    gtr_core_blocklist_update( cbdata->core );
    912921            }
    913922        }
    914923
    915924        /* if there's no magnet link handler registered, register us */
    916         registerMagnetLinkHandler( );
     925        register_magnet_link_handler( );
    917926
    918927        gtk_main( );
     
    939948
    940949static void
    941 appsetup( TrWindow      * wind,
    942           GSList        * torrentFiles,
    943           struct cbdata * cbdata,
    944           gboolean        forcepause,
    945           gboolean        isIconified )
    946 {
    947     const gboolean doStart = gtr_pref_flag_get( TR_PREFS_KEY_START ) && !forcepause;
     950app_setup( TrWindow      * wind,
     951           GSList        * torrentFiles,
     952           struct cbdata * cbdata,
     953           gboolean        pause_all,
     954           gboolean        is_iconified )
     955{
     956    const gboolean doStart = gtr_pref_flag_get( TR_PREFS_KEY_START ) && !pause_all;
    948957    const gboolean doPrompt = gtr_pref_flag_get( PREF_KEY_OPTIONS_PROMPT );
    949958    const gboolean doNotify = TRUE;
    950959
    951     cbdata->isIconified  = isIconified;
    952 
    953     if( isIconified )
     960    cbdata->is_iconified  = is_iconified;
     961
     962    if( is_iconified )
    954963        gtr_pref_flag_set( PREF_KEY_SHOW_TRAY_ICON, TRUE );
    955964
     
    963972
    964973    /* add torrents from command-line and saved state */
    965     tr_core_load( cbdata->core, forcepause );
    966     tr_core_add_list( cbdata->core, torrentFiles, doStart, doPrompt, doNotify );
     974    gtr_core_load( cbdata->core, pause_all );
     975    gtr_core_add_list( cbdata->core, torrentFiles, doStart, doPrompt, doNotify );
    967976    torrentFiles = NULL;
    968     tr_core_torrents_added( cbdata->core );
     977    gtr_core_torrents_added( cbdata->core );
    969978
    970979    /* set up main window */
    971     winsetup( cbdata, wind );
     980    main_window_setup( cbdata, wind );
    972981
    973982    /* set up the icon */
     
    975984
    976985    /* start model update timer */
    977     cbdata->timer = gtr_timeout_add_seconds( MAIN_WINDOW_REFRESH_INTERVAL_SECONDS, updatemodel, cbdata );
    978     updatemodel( cbdata );
     986    cbdata->timer = gtr_timeout_add_seconds( MAIN_WINDOW_REFRESH_INTERVAL_SECONDS, update_model, cbdata );
     987    update_model( cbdata );
    979988
    980989    /* either show the window or iconify it */
    981     if( !isIconified )
     990    if( !is_iconified )
    982991        gtk_widget_show( GTK_WIDGET( wind ) );
    983992    else
     
    985994        gtk_window_set_skip_taskbar_hint( cbdata->wind,
    986995                                          cbdata->icon != NULL );
    987         cbdata->isIconified = FALSE; // ensure that the next toggle iconifies
     996        cbdata->is_iconified = FALSE; // ensure that the next toggle iconifies
    988997        gtr_action_set_toggled( "toggle-main-window", FALSE );
    989998    }
     
    10161025{
    10171026    GtkWindow * window = cbdata->wind;
    1018     const int   doShow = cbdata->isIconified;
     1027    const int   doShow = cbdata->is_iconified;
    10191028    static int  x = 0;
    10201029    static int  y = 0;
     
    10221031    if( doShow )
    10231032    {
    1024         cbdata->isIconified = 0;
     1033        cbdata->is_iconified = 0;
    10251034        gtk_window_set_skip_taskbar_hint( window, FALSE );
    10261035        gtk_window_move( window, x, y );
     
    10331042        gtk_window_set_skip_taskbar_hint( window, TRUE );
    10341043        gtr_widget_set_visible( GTK_WIDGET( window ), FALSE );
    1035         cbdata->isIconified = 1;
    1036     }
    1037 }
    1038 
    1039 static gboolean
    1040 shouldConfirmBeforeExiting( struct cbdata * data )
    1041 {
    1042     return gtr_pref_flag_get( PREF_KEY_ASKQUIT )
    1043         && tr_core_get_active_torrent_count( data->core );
    1044 }
    1045 
    1046 static void
    1047 maybeaskquit( struct cbdata * cbdata )
    1048 {
    1049     if( !shouldConfirmBeforeExiting( cbdata ) )
    1050         wannaquit( cbdata );
    1051     else {
    1052         if( cbdata->quit_dialog == NULL ) {
    1053             cbdata->quit_dialog = gtr_confirm_quit( cbdata->wind, cbdata->core, wannaquit, cbdata );
    1054             g_object_add_weak_pointer( G_OBJECT( cbdata->quit_dialog ), &cbdata->quit_dialog );
    1055         }
    1056         gtr_window_present( GTK_WINDOW( cbdata->quit_dialog ) );
     1044        cbdata->is_iconified = 1;
    10571045    }
    10581046}
     
    10681056        gtr_action_activate ( "toggle-main-window" );
    10691057    else
    1070         maybeaskquit( cbdata );
     1058        on_app_exit( cbdata );
    10711059
    10721060    return TRUE; /* don't propagate event further */
     
    11131101        else if( tr_urlIsValid( uri, -1 ) || gtr_is_magnet_link( uri ) )
    11141102        {
    1115             tr_core_add_from_url( data->core, uri );
     1103            gtr_core_add_from_url( data->core, uri );
    11161104            success = TRUE;
    11171105        }
     
    11191107
    11201108    if( filenames )
    1121         tr_core_add_list_defaults( data->core, g_slist_reverse( filenames ), TRUE );
    1122 
    1123     tr_core_torrents_added( data->core );
     1109        gtr_core_add_list_defaults( data->core, g_slist_reverse( filenames ), TRUE );
     1110
     1111    gtr_core_torrents_added( data->core );
    11241112    gtk_drag_finish( drag_context, success, FALSE, time_ );
    11251113
     
    11291117
    11301118static void
    1131 winsetup( struct cbdata * cbdata, TrWindow * wind )
     1119main_window_setup( struct cbdata * cbdata, TrWindow * wind )
    11321120{
    11331121    GtkWidget * w;
     
    11411129    g_signal_connect( sel, "changed", G_CALLBACK( on_selection_changed ), cbdata );
    11421130    on_selection_changed( sel, cbdata );
    1143     model = tr_core_model( cbdata->core );
     1131    model = gtr_core_model( cbdata->core );
    11441132    g_signal_connect( model, "row-changed", G_CALLBACK( rowChangedCB ), cbdata );
    11451133    g_signal_connect( wind, "delete-event", G_CALLBACK( winclose ), cbdata );
     
    11541142
    11551143static gboolean
    1156 onSessionClosed( gpointer gdata )
     1144on_session_closed( gpointer gdata )
    11571145{
    11581146    struct cbdata * cbdata = gdata;
     
    11831171
    11841172static gpointer
    1185 sessionCloseThreadFunc( gpointer gdata )
     1173session_close_threadfunc( gpointer gdata )
    11861174{
    11871175    /* since tr_sessionClose() is a blocking function,
     
    11901178    struct cbdata * cbdata = gdata;
    11911179    gdk_threads_enter( );
    1192     tr_core_close( cbdata->core );
    1193     gtr_idle_add( onSessionClosed, gdata );
     1180    gtr_core_close( cbdata->core );
     1181    gtr_idle_add( on_session_closed, gdata );
    11941182    gdk_threads_leave( );
    11951183    return NULL;
     
    12031191
    12041192static void
    1205 wannaquit( gpointer vdata )
     1193on_app_exit( gpointer vdata )
    12061194{
    12071195    GtkWidget *r, *p, *b, *w, *c;
     
    12471235
    12481236    /* clear the UI */
    1249     tr_core_clear( cbdata->core );
     1237    gtr_core_clear( cbdata->core );
    12501238
    12511239    /* ensure the window is in its previous position & size.
     
    12581246
    12591247    /* shut down libT */
    1260     g_thread_create( sessionCloseThreadFunc, vdata, TRUE, NULL );
     1248    g_thread_create( session_close_threadfunc, vdata, TRUE, NULL );
    12611249}
    12621250
     
    13681356{
    13691357    struct cbdata * cbdata = data;
    1370     tr_session * tr = tr_core_session( cbdata->core );
     1358    tr_session * tr = gtr_core_session( cbdata->core );
    13711359
    13721360    if( !strcmp( key, TR_PREFS_KEY_ENCRYPTION ) )
     
    15491537
    15501538static gboolean
    1551 updatemodel( gpointer gdata )
     1539update_model( gpointer gdata )
    15521540{
    15531541    struct cbdata *data = gdata;
    1554     const gboolean done = data->isClosing || global_sigcount;
     1542    const gboolean done = global_sigcount;
    15551543
    15561544    if( !done )
    15571545    {
    15581546        /* update the torrent data in the model */
    1559         tr_core_update( data->core );
     1547        gtr_core_update( data->core );
    15601548
    15611549        /* refresh the main window's statusbar and toolbar buttons */
     
    15751563
    15761564static void
    1577 onUriClicked( GtkAboutDialog * u UNUSED, const gchar * uri, gpointer u2 UNUSED )
     1565on_uri_clicked( GtkAboutDialog * u UNUSED, const gchar * uri, gpointer u2 UNUSED )
    15781566{
    15791567    gtr_open_uri( uri );
     
    15811569
    15821570static void
    1583 about( GtkWindow * parent )
     1571show_about_dialog( GtkWindow * parent )
    15841572{
    15851573    GtkWidget * d;
     
    15911579    };
    15921580
    1593     gtk_about_dialog_set_url_hook( onUriClicked, NULL, NULL );
     1581    gtk_about_dialog_set_url_hook( on_uri_clicked, NULL, NULL );
    15941582
    15951583    d = g_object_new( GTK_TYPE_ABOUT_DIALOG,
     
    16171605
    16181606static void
    1619 appendIdToBencList( GtkTreeModel * m, GtkTreePath * path UNUSED,
    1620                     GtkTreeIter * iter, gpointer list )
     1607append_id_to_benc_list( GtkTreeModel * m, GtkTreePath * path UNUSED,
     1608                        GtkTreeIter * iter, gpointer list )
    16211609{
    16221610    tr_torrent * tor = NULL;
    1623     gtk_tree_model_get( m, iter, MC_TORRENT_RAW, &tor, -1 );
     1611    gtk_tree_model_get( m, iter, MC_TORRENT, &tor, -1 );
    16241612    tr_bencListAddInt( list, tr_torrentId( tor ) );
    16251613}
    16261614
    16271615static gboolean
    1628 rpcOnSelectedTorrents( struct cbdata * data, const char * method )
     1616call_rpc_for_selected_torrents( struct cbdata * data, const char * method )
    16291617{
    16301618    tr_benc top, *args, *ids;
    16311619    gboolean invoked = FALSE;
    16321620    GtkTreeSelection * s = data->sel;
    1633     tr_session * session = tr_core_session( data->core );
     1621    tr_session * session = gtr_core_session( data->core );
    16341622
    16351623    tr_bencInitDict( &top, 2 );
     
    16371625    args = tr_bencDictAddDict( &top, "arguments", 1 );
    16381626    ids = tr_bencDictAddList( args, "ids", 0 );
    1639     gtk_tree_selection_selected_foreach( s, appendIdToBencList, ids );
     1627    gtk_tree_selection_selected_foreach( s, append_id_to_benc_list, ids );
    16401628
    16411629    if( tr_bencListSize( ids ) != 0 )
     
    16531641
    16541642static void
    1655 openFolderForeach( GtkTreeModel * model, GtkTreePath * path UNUSED,
    1656                    GtkTreeIter * iter, gpointer user_data UNUSED )
    1657 {
    1658     TrTorrent * gtor = NULL;
    1659 
    1660     gtk_tree_model_get( model, iter, MC_TORRENT, &gtor, -1 );
    1661     tr_torrent_open_folder( gtor );
    1662     g_object_unref( G_OBJECT( gtor ) );
     1643open_folder_foreach( GtkTreeModel * model, GtkTreePath * path UNUSED,
     1644                     GtkTreeIter * iter, gpointer core )
     1645{
     1646    int id;
     1647    gtk_tree_model_get( model, iter, MC_TORRENT_ID, &id, -1 );
     1648    gtr_core_open_folder( core, id );
    16631649}
    16641650
    16651651static gboolean
    1666 msgwinclosed( void )
     1652on_message_window_closed( void )
    16671653{
    16681654    gtr_action_set_toggled( "toggle-message-log", FALSE );
     
    16711657
    16721658static void
    1673 accumulateSelectedTorrents( GtkTreeModel * model, GtkTreePath * path UNUSED,
    1674                             GtkTreeIter * iter, gpointer gdata )
    1675 {
     1659accumulate_selected_torrents( GtkTreeModel  * model, GtkTreePath   * path UNUSED,
     1660                              GtkTreeIter   * iter, gpointer        gdata )
     1661{
     1662    int id;
    16761663    GSList ** data = ( GSList** ) gdata;
    1677     TrTorrent * gtor = NULL;
    1678 
    1679     gtk_tree_model_get( model, iter, MC_TORRENT, &gtor, -1 );
    1680     *data = g_slist_append( *data, gtor );
    1681     g_object_unref( G_OBJECT( gtor ) );
    1682 }
    1683 
    1684 static void
    1685 removeSelected( struct cbdata * data, gboolean delete_files )
     1664
     1665    gtk_tree_model_get( model, iter, MC_TORRENT_ID, &id, -1 );
     1666    *data = g_slist_append( *data, GINT_TO_POINTER( id ) );
     1667}
     1668
     1669static void
     1670remove_selected( struct cbdata * data, gboolean delete_files )
    16861671{
    16871672    GSList * l = NULL;
    16881673
    1689     gtk_tree_selection_selected_foreach( data->sel, accumulateSelectedTorrents, &l );
     1674    gtk_tree_selection_selected_foreach( data->sel, accumulate_selected_torrents, &l );
    16901675
    16911676    if( l != NULL )
     
    16941679
    16951680static void
    1696 startAllTorrents( struct cbdata * data )
    1697 {
    1698     tr_session * session = tr_core_session( data->core );
     1681start_all_torrents( struct cbdata * data )
     1682{
     1683    tr_session * session = gtr_core_session( data->core );
    16991684    const char * cmd = "{ \"method\": \"torrent-start\" }";
    17001685    tr_rpc_request_exec_json( session, cmd, strlen( cmd ), NULL, NULL );
     
    17021687
    17031688static void
    1704 pauseAllTorrents( struct cbdata * data )
    1705 {
    1706     tr_session * session = tr_core_session( data->core );
     1689pause_all_torrents( struct cbdata * data )
     1690{
     1691    tr_session * session = gtr_core_session( data->core );
    17071692    const char * cmd = "{ \"method\": \"torrent-stop\" }";
    17081693    tr_rpc_request_exec_json( session, cmd, strlen( cmd ), NULL, NULL );
     
    17101695
    17111696static tr_torrent*
    1712 getFirstSelectedTorrent( struct cbdata * data )
     1697get_first_selected_torrent( struct cbdata * data )
    17131698{
    17141699    tr_torrent * tor = NULL;
     
    17191704        GtkTreeIter i;
    17201705        if( gtk_tree_model_get_iter( m, &i, p ) )
    1721             gtk_tree_model_get( m, &i, MC_TORRENT_RAW, &tor, -1 );
     1706            gtk_tree_model_get( m, &i, MC_TORRENT, &tor, -1 );
    17221707    }
    17231708    g_list_foreach( l, (GFunc)gtk_tree_path_free, NULL );
     
    17271712
    17281713static void
    1729 copyMagnetLinkToClipboard( GtkWidget * w, tr_torrent * tor )
     1714copy_magnet_link_to_clipboard( GtkWidget * w, tr_torrent * tor )
    17301715{
    17311716    char * magnet = tr_torrentGetMagnetLink( tor );
     
    17761761    else if( !strcmp( action_name, "pause-all-torrents" ) )
    17771762    {
    1778         pauseAllTorrents( data );
     1763        pause_all_torrents( data );
    17791764    }
    17801765    else if( !strcmp( action_name, "start-all-torrents" ) )
    17811766    {
    1782         startAllTorrents( data );
     1767        start_all_torrents( data );
    17831768    }
    17841769    else if( !strcmp( action_name, "copy-magnet-link-to-clipboard" ) )
    17851770    {
    1786         tr_torrent * tor = getFirstSelectedTorrent( data );
     1771        tr_torrent * tor = get_first_selected_torrent( data );
    17871772        if( tor != NULL )
    17881773        {
    1789             copyMagnetLinkToClipboard( GTK_WIDGET( data->wind ), tor );
     1774            copy_magnet_link_to_clipboard( GTK_WIDGET( data->wind ), tor );
    17901775        }
    17911776    }
     
    18021787    else if( !strcmp( action_name, "start-torrent" ) )
    18031788    {
    1804         changed |= rpcOnSelectedTorrents( data, "torrent-start" );
     1789        changed |= call_rpc_for_selected_torrents( data, "torrent-start" );
    18051790    }
    18061791    else if( !strcmp( action_name, "pause-torrent" ) )
    18071792    {
    1808         changed |= rpcOnSelectedTorrents( data, "torrent-stop" );
     1793        changed |= call_rpc_for_selected_torrents( data, "torrent-stop" );
    18091794    }
    18101795    else if( !strcmp( action_name, "verify-torrent" ) )
    18111796    {
    1812         changed |= rpcOnSelectedTorrents( data, "torrent-verify" );
     1797        changed |= call_rpc_for_selected_torrents( data, "torrent-verify" );
    18131798    }
    18141799    else if( !strcmp( action_name, "update-tracker" ) )
    18151800    {
    1816         changed |= rpcOnSelectedTorrents( data, "torrent-reannounce" );
     1801        changed |= call_rpc_for_selected_torrents( data, "torrent-reannounce" );
    18171802    }
    18181803    else if( !strcmp( action_name, "open-torrent-folder" ) )
    18191804    {
    1820         gtk_tree_selection_selected_foreach( data->sel, openFolderForeach, data );
     1805        gtk_tree_selection_selected_foreach( data->sel, open_folder_foreach, data->core );
    18211806    }
    18221807    else if( !strcmp( action_name, "show-torrent-properties" ) )
     
    18311816    else if( !strcmp( action_name, "remove-torrent" ) )
    18321817    {
    1833         removeSelected( data, FALSE );
     1818        remove_selected( data, FALSE );
    18341819    }
    18351820    else if( !strcmp( action_name, "delete-torrent" ) )
    18361821    {
    1837         removeSelected( data, TRUE );
     1822        remove_selected( data, TRUE );
    18381823    }
    18391824    else if( !strcmp( action_name, "quit" ) )
    18401825    {
    1841         maybeaskquit( data );
     1826        on_app_exit( data );
    18421827    }
    18431828    else if( !strcmp( action_name, "select-all" ) )
     
    18641849        {
    18651850            GtkWidget * win = gtr_message_log_window_new( data->wind, data->core );
    1866             g_signal_connect( win, "destroy", G_CALLBACK( msgwinclosed ), NULL );
     1851            g_signal_connect( win, "destroy", G_CALLBACK( on_message_window_closed ), NULL );
    18671852            data->msgwin = win;
    18681853        }
     
    18761861    else if( !strcmp( action_name, "show-about-dialog" ) )
    18771862    {
    1878         about( data->wind );
     1863        show_about_dialog( data->wind );
    18791864    }
    18801865    else if( !strcmp ( action_name, "help" ) )
     
    18891874
    18901875    if( changed )
    1891         updatemodel( data );
    1892 }
     1876        update_model( data );
     1877}
  • trunk/gtk/makemeta-ui.c

    r11738 r12068  
    130130    char * path;
    131131    const tr_metainfo_builder * b = ui->builder;
    132     tr_ctor * ctor = tr_ctorNew( tr_core_session( ui->core ) );
     132    tr_ctor * ctor = tr_ctorNew( gtr_core_session( ui->core ) );
    133133
    134134    tr_ctorSetMetainfoFromFile( ctor, ui->target );
     
    138138    g_free( path );
    139139
    140     tr_core_add_ctor( ui->core, ctor );
     140    gtr_core_add_ctor( ui->core, ctor );
    141141}
    142142
  • trunk/gtk/msgwin.c

    r11861 r12068  
    2222#include "conf.h"
    2323#include "hig.h"
     24#include "msgwin.h"
    2425#include "tr-core.h"
    25 #include "msgwin.h"
    2626#include "tr-prefs.h"
    2727#include "util.h"
     
    113113
    114114    tr_setMessageLevel( level );
    115     tr_core_set_pref_int( data->core, TR_PREFS_KEY_MSGLEVEL, level );
     115    gtr_core_set_pref_int( data->core, TR_PREFS_KEY_MSGLEVEL, level );
    116116    data->maxLevel = level;
    117117    gtk_tree_model_filter_refilter( GTK_TREE_MODEL_FILTER( data->filter ) );
     
    217217getForegroundColor( int msgLevel )
    218218{
    219     const char * foreground;
    220 
    221219    switch( msgLevel )
    222220    {
    223         case TR_MSG_DBG:
    224             foreground = "forestgreen"; break;
    225 
    226         case TR_MSG_INF:
    227             foreground = "black"; break;
    228 
    229         case TR_MSG_ERR:
    230             foreground = "red"; break;
    231 
    232         default:
    233             g_assert_not_reached( );
    234     }
    235     return foreground;
     221        case TR_MSG_DBG: return "forestgreen";
     222        case TR_MSG_INF: return "black";
     223        case TR_MSG_ERR: return "red";
     224        default: g_assert_not_reached( ); return "black";
     225    }
    236226}
    237227
  • trunk/gtk/msgwin.h

    r11709 r12068  
    1414#define GTR_MSGWIN_H
    1515
     16#include "tr-core.h"
     17
    1618GtkWidget * gtr_message_log_window_new( GtkWindow * parent, TrCore * core );
    1719
  • trunk/gtk/notify.c

    r11890 r12068  
    3131
    3232void gtr_notify_init( void ) { }
    33 void gtr_notify_send( TrTorrent * tor UNUSED ) { }
    34 void gtr_notify_added( const char * name UNUSED ) { }
     33void gtr_notify_torrent_completed( TrCore * core UNUSED, int torrent_id UNUSED ) { }
     34void gtr_notify_torrent_added( const char * name UNUSED ) { }
    3535
    3636#else
     
    4343}
    4444
     45struct notify_callback_data
     46{
     47    TrCore * core;
     48    int torrent_id;
     49};
     50
    4551static void
    46 notifyCallback( NotifyNotification * n UNUSED,
    47                 const char *           action,
    48                 gpointer               gdata )
    49 {
    50     TrTorrent * gtor = TR_TORRENT( gdata );
    51 
    52     if( !strcmp( action, "folder" ) )
    53     {
    54         tr_torrent_open_folder( gtor );
    55     }
    56     else if( !strcmp( action, "file" ) )
    57     {
    58         tr_torrent * tor = tr_torrent_handle( gtor );
    59         const tr_info * info = tr_torrent_info( gtor );
    60         if( tor && info )
     52notify_callback_data_free( gpointer gdata )
     53{
     54    struct notify_callback_data * data = gdata;
     55    g_object_unref( G_OBJECT( data->core ) );
     56    g_free( data );
     57}
     58
     59static struct notify_callback_data *
     60notify_callback_data_new( TrCore * core, int torrent_id )
     61{
     62    struct notify_callback_data * data = g_new( struct notify_callback_data, 1 );
     63    data->core = core;
     64    data->torrent_id = torrent_id;
     65    g_object_ref( G_OBJECT( data->core ) );
     66    return data;
     67}
     68
     69static void
     70notifyCallback( NotifyNotification  * n UNUSED,
     71                const char          * action,
     72                gpointer              gdata )
     73{
     74    struct notify_callback_data * data = gdata;
     75    tr_torrent * tor = gtr_core_find_torrent( data->core, data->torrent_id );
     76
     77    if( tor != NULL )
     78    {
     79        if( !strcmp( action, "folder" ) )
    6180        {
     81            gtr_core_open_folder( data->core, data->torrent_id );
     82        }
     83        else if( !strcmp( action, "file" ) )
     84        {
     85            const tr_info * inf = tr_torrentInfo( tor );
    6286            const char * dir = tr_torrentGetDownloadDir( tor );
    63             char * path = g_build_filename( dir, info->files[0].name, NULL );
     87            char * path = g_build_filename( dir, inf->files[0].name, NULL );
    6488            gtr_open_file( path );
    6589            g_free( path );
     
    109133}
    110134
     135static NotifyNotification *
     136tr_notify_notification_new( const char * summary,
     137                            const char * body,
     138                            const char * icon )
     139{
     140    NotifyNotification * n = notify_notification_new( summary, body, icon
     141/* the fourth argument was removed in libnotify 0.7.0 */
     142#if !defined(NOTIFY_VERSION_MINOR) || (NOTIFY_VERSION_MAJOR == 0 && NOTIFY_VERSION_MINOR < 7)
     143                                                     , NULL
     144#endif
     145                                                            );
     146    return n;
     147}
     148
    111149void
    112 gtr_notify_send( TrTorrent *tor )
     150gtr_notify_torrent_completed( TrCore * core, int torrent_id )
    113151{
    114152#ifdef HAVE_LIBCANBERRA
     
    126164    if( gtr_pref_flag_get( PREF_KEY_SHOW_DESKTOP_NOTIFICATION ) )
    127165    {
    128         const tr_info * info = tr_torrent_info( tor );
    129166        NotifyNotification * n;
    130 
    131         n = notify_notification_new( _( "Torrent Complete" ),
    132                                      tr_torrentName( tr_torrent_handle( tor ) ), NULL
    133 /* the fourth argument was removed in libnotify 0.7.0 */
    134 #if !defined(NOTIFY_VERSION_MINOR) || (NOTIFY_VERSION_MAJOR == 0 && NOTIFY_VERSION_MINOR < 7)
    135                                                      , NULL
    136 #endif
    137                                                             );
     167        tr_torrent * tor = gtr_core_find_torrent( core, torrent_id );
     168
     169        n = tr_notify_notification_new( _( "Torrent Complete" ), tr_torrentName( tor ), NULL );
    138170        addIcon( n );
    139171
    140172        if( can_support_actions( ) )
    141173        {
    142             if( info->fileCount == 1 )
     174            const tr_info * inf = tr_torrentInfo( tor );
     175            if( inf->fileCount == 1 )
    143176                notify_notification_add_action(
    144177                    n, "file", _( "Open File" ),
    145                     NOTIFY_ACTION_CALLBACK( notifyCallback ), tor,
    146                     NULL );
     178                    NOTIFY_ACTION_CALLBACK( notifyCallback ),
     179                    notify_callback_data_new( core, torrent_id ),
     180                    notify_callback_data_free );
    147181
    148182            notify_notification_add_action(
    149183                n, "folder", _( "Open Folder" ),
    150                 NOTIFY_ACTION_CALLBACK( notifyCallback ), tor, NULL );
     184                NOTIFY_ACTION_CALLBACK( notifyCallback ),
     185                notify_callback_data_new( core, torrent_id ),
     186                notify_callback_data_free );
    151187        }
    152188
     
    156192
    157193void
    158 gtr_notify_added( const char * name )
     194gtr_notify_torrent_added( const char * name )
    159195{
    160196    if( gtr_pref_flag_get( PREF_KEY_SHOW_DESKTOP_NOTIFICATION ) )
    161197    {
    162         NotifyNotification * n = notify_notification_new(
    163             _( "Torrent Added" ), name, NULL
    164 /* the fourth argument was removed in libnotify 0.7.0 */
    165 #if !defined(NOTIFY_VERSION_MINOR) || (NOTIFY_VERSION_MAJOR == 0 && NOTIFY_VERSION_MINOR < 7)
    166             , NULL
    167 #endif
    168             );
     198        NotifyNotification * n = tr_notify_notification_new( _( "Torrent Added" ), name, NULL );
    169199        addIcon( n );
    170200        notify_notification_set_timeout( n, NOTIFY_EXPIRES_DEFAULT );
  • trunk/gtk/notify.h

    r11709 r12068  
    1414#define GTR_NOTIFY_H
    1515
    16 #include "tr-torrent.h"
     16#include "tr-core.h"
    1717
    1818void gtr_notify_init( void );
    1919
    20 void gtr_notify_send( TrTorrent * tor );
     20void gtr_notify_torrent_added     ( const char * name );
    2121
    22 void gtr_notify_added( const char * name );
     22void gtr_notify_torrent_completed ( TrCore * core, int torrent_id );
    2323
    2424#endif
  • trunk/gtk/open-dialog.c

    r11721 r12068  
    7676        gtr_pref_string_set( key, l->data );
    7777    }
    78     gtr_pref_save( tr_core_session( core ) );
     78    gtr_pref_save( gtr_core_session( core ) );
    7979
    8080    /* cleanup */
     
    9696    char *       filename;
    9797    char *       downloadDir;
    98     TrTorrent *  gtor;
     98    tr_torrent * tor;
    9999    tr_ctor *    ctor;
    100100};
    101101
    102102static void
    103 removeOldTorrent( struct OpenData * data )
    104 {
    105     if( data->gtor )
    106     {
    107         gtr_file_list_clear( data->file_list );
    108         tr_torrent_set_remove_flag( data->gtor, TRUE );
    109         g_object_unref( G_OBJECT( data->gtor ) );
    110         data->gtor = NULL;
     103removeOldTorrent( struct OpenData * o )
     104{
     105    if( o->tor )
     106    {
     107        gtr_file_list_clear( o->file_list );
     108        tr_torrentRemove( o->tor, FALSE, NULL );
     109        o->tor = NULL;
    111110    }
    112111}
     
    117116               gpointer    gdata )
    118117{
    119     struct OpenData * data = gdata;
    120 
    121     if( data->gtor )
     118    struct OpenData * o = gdata;
     119
     120    if( o->tor )
    122121    {
    123122        if( response != GTK_RESPONSE_ACCEPT )
    124123        {
    125             removeOldTorrent( data );
     124            removeOldTorrent( o );
    126125        }
    127126        else
    128127        {
    129             tr_torrent * tor = tr_torrent_handle( data->gtor );
    130 
    131             tr_torrentSetPriority( tor, gtr_priority_combo_get_value( GTK_COMBO_BOX( data->priority_combo ) ) );
    132 
    133             if( gtk_toggle_button_get_active( GTK_TOGGLE_BUTTON( data->run_check ) ) )
    134                 tr_torrentStart( tor );
    135 
    136             tr_core_add_torrent( data->core, data->gtor, FALSE );
    137 
    138             if( gtk_toggle_button_get_active( GTK_TOGGLE_BUTTON( data->trash_check ) ) )
    139                 gtr_file_trash_or_remove( data->filename );
    140 
    141             save_recent_destination( data->core, data->downloadDir );
     128            tr_torrentSetPriority( o->tor, gtr_priority_combo_get_value( GTK_COMBO_BOX( o->priority_combo ) ) );
     129
     130            if( gtk_toggle_button_get_active( GTK_TOGGLE_BUTTON( o->run_check ) ) )
     131                tr_torrentStart( o->tor );
     132
     133            gtr_core_add_torrent( o->core, o->tor, FALSE );
     134
     135            if( gtk_toggle_button_get_active( GTK_TOGGLE_BUTTON( o->trash_check ) ) )
     136                gtr_file_trash_or_remove( o->filename );
     137
     138            save_recent_destination( o->core, o->downloadDir );
    142139        }
    143140    }
    144141
    145     tr_ctorFree( data->ctor );
    146     g_free( data->filename );
    147     g_free( data->downloadDir );
    148     g_free( data );
     142    tr_ctorFree( o->ctor );
     143    g_free( o->filename );
     144    g_free( o->downloadDir );
     145    g_free( o );
    149146    gtk_widget_destroy( GTK_WIDGET( dialog ) );
    150147}
     
    156153    gtk_widget_set_sensitive( o->trash_check, isLocalFile );
    157154
    158     if( !o->gtor )
     155    if( !o->tor )
    159156    {
    160157        gtr_file_list_clear( o->file_list );
     
    163160    else
    164161    {
    165         tr_torrent * tor = tr_torrent_handle( o->gtor );
    166         tr_torrentSetDownloadDir( tor, o->downloadDir );
    167         gtk_widget_set_sensitive( o->file_list, tr_torrentHasMetadata( tor ) );
    168         gtr_file_list_set_torrent( o->file_list, tr_torrentId( tor ) );
    169         tr_torrentVerify( tor );
     162        tr_torrentSetDownloadDir( o->tor, o->downloadDir );
     163        gtk_widget_set_sensitive( o->file_list, tr_torrentHasMetadata( o->tor ) );
     164        gtr_file_list_set_torrent( o->file_list, tr_torrentId( o->tor ) );
     165        tr_torrentVerify( o->tor );
    170166    }
    171167}
     
    181177sourceChanged( GtkFileChooserButton * b, gpointer gdata )
    182178{
    183     struct OpenData * data = gdata;
     179    struct OpenData * o = gdata;
    184180    char * filename = gtk_file_chooser_get_filename( GTK_FILE_CHOOSER( b ) );
    185181
    186182    /* maybe instantiate a torrent */
    187     if( filename || !data->gtor )
     183    if( filename || !o->tor )
    188184    {
    189185        int err = 0;
     
    191187        tr_torrent * torrent;
    192188
    193         if( filename && ( !data->filename || !tr_is_same_file( filename, data->filename ) ) )
     189        if( filename && ( !o->filename || !tr_is_same_file( filename, o->filename ) ) )
    194190        {
    195             g_free( data->filename );
    196             data->filename = g_strdup( filename );
    197             tr_ctorSetMetainfoFromFile( data->ctor, data->filename );
     191            g_free( o->filename );
     192            o->filename = g_strdup( filename );
     193            tr_ctorSetMetainfoFromFile( o->ctor, o->filename );
    198194            new_file = 1;
    199195        }
    200196
    201         tr_ctorSetDownloadDir( data->ctor, TR_FORCE, data->downloadDir );
    202         tr_ctorSetPaused( data->ctor, TR_FORCE, TRUE );
    203         tr_ctorSetDeleteSource( data->ctor, FALSE );
    204 
    205         if( ( torrent = tr_torrentNew( data->ctor, &err ) ) )
     197        tr_ctorSetDownloadDir( o->ctor, TR_FORCE, o->downloadDir );
     198        tr_ctorSetPaused( o->ctor, TR_FORCE, TRUE );
     199        tr_ctorSetDeleteSource( o->ctor, FALSE );
     200
     201        if(( torrent = tr_torrentNew( o->ctor, &err ) ) )
    206202        {
    207             removeOldTorrent( data );
    208             data->gtor = tr_torrent_new_preexisting( torrent );
     203            removeOldTorrent( o );
     204            o->tor = torrent;
    209205        }
    210206        else if( new_file )
    211207        {
    212             gtr_add_torrent_error_dialog( GTK_WIDGET( b ), err, data->filename );
     208            gtr_add_torrent_error_dialog( GTK_WIDGET( b ), err, o->filename );
    213209        }
    214210
    215         updateTorrent( data );
     211        updateTorrent( o );
    216212    }
    217213
     
    413409        GSList * l = gtk_file_chooser_get_filenames( chooser );
    414410
    415         tr_core_add_list( core, l, doStart, doPrompt, doNotify );
     411        gtr_core_add_list( core, l, doStart, doPrompt, doNotify );
    416412    }
    417413
     
    473469                                            || gtr_is_hex_hashcode( url ) )
    474470            {
    475                 tr_core_add_from_url( core, url );
     471                gtr_core_add_from_url( core, url );
    476472            }
    477473            else
  • trunk/gtk/relocate.c

    r11890 r12068  
    5353    const int id = GPOINTER_TO_INT( data->torrent_ids->data );
    5454
    55     tr_session * session = tr_core_session( data->core );
    56 
    57     tr_torrent * tor = tr_torrentFindFromId( session, id );
     55    tr_torrent * tor = gtr_core_find_torrent( data->core, id );
    5856    if( tor != NULL )
    5957        tr_torrentSetLocation( tor, previousLocation, data->do_move, NULL, &data->done );
  • trunk/gtk/stats.c

    r11741 r12068  
    1717#include "tr-core.h"
    1818#include "tr-prefs.h"
     19#include "util.h"
    1920
    2021enum
     
    6364    tr_session_stats one, all;
    6465
    65     tr_sessionGetStats( tr_core_session( ui->core ), &one );
    66     tr_sessionGetCumulativeStats( tr_core_session( ui->core ), &all );
     66    tr_sessionGetStats( gtr_core_session( ui->core ), &one );
     67    tr_sessionGetCumulativeStats( gtr_core_session( ui->core ), &all );
    6768
    6869    setLabel( ui->one_up_lb,
     
    122123        if( gtk_dialog_run( GTK_DIALOG( w ) ) == TR_RESPONSE_RESET )
    123124        {
    124             tr_sessionClearStats( tr_core_session( ui->core ) );
     125            tr_sessionClearStats( gtr_core_session( ui->core ) );
    125126            updateStats( ui );
    126127        }
  • trunk/gtk/torrent-cell-renderer.c

    r11890 r12068  
    1919#include "icons.h"
    2020#include "torrent-cell-renderer.h"
    21 #include "tr-torrent.h"
    2221#include "util.h"
    2322
  • trunk/gtk/tr-core.c

    r11896 r12068  
    5050#endif
    5151#include "tr-prefs.h"
    52 #include "tr-torrent.h"
    5352#include "util.h"
    5453#include "actions.h"
     
    7271static guint core_signals[LAST_SIGNAL] = { 0 };
    7372
    74 static void maybeInhibitHibernation( TrCore * core );
     73static void maybe_inhibit_hibernation( TrCore * core );
    7574
    7675static gboolean our_instance_adds_remote_torrents = FALSE;
     
    7978{
    8079#ifdef HAVE_GIO
    81     GFileMonitor *  monitor;
    82     gulong          monitor_tag;
    83     char *          monitor_path;
    84     GSList *        monitor_files;
    85     guint           monitor_idle_tag;
     80    GFileMonitor * monitor;
     81    gulong         monitor_tag;
     82    char         * monitor_path;
     83    GSList       * monitor_files;
     84    guint          monitor_idle_tag;
    8685#endif
    87     gboolean        adding_from_watch_dir;
    88     gboolean        inhibit_allowed;
    89     gboolean        have_inhibit_cookie;
    90     gboolean        dbus_error;
    91     guint           inhibit_cookie;
    92     gint            busy_count;
    93     GtkTreeModel *  raw_model;
    94     GtkTreeModel *  sorted_model;
    95     tr_session *    session;
     86    gboolean       adding_from_watch_dir;
     87    gboolean       inhibit_allowed;
     88    gboolean       have_inhibit_cookie;
     89    gboolean       dbus_error;
     90    guint          inhibit_cookie;
     91    gint           busy_count;
     92    GtkTreeModel * raw_model;
     93    GtkTreeModel * sorted_model;
     94    tr_session   * session;
    9695};
    9796
    9897static int
    99 isDisposed( const TrCore * core )
     98core_is_disposed( const TrCore * core )
    10099{
    101100    return !core || !core->priv;
     
    103102
    104103static void
    105 tr_core_dispose( GObject * obj )
     104core_dispose( GObject * obj )
    106105{
    107106    TrCore * core = TR_CORE( obj );
    108107
    109     if( !isDisposed( core ) )
     108    if( !core_is_disposed( core ) )
    110109    {
    111110        GObjectClass * parent;
     
    119118
    120119static void
    121 tr_core_class_init( gpointer              g_class,
    122                     gpointer g_class_data UNUSED )
     120gtr_core_class_init( gpointer g_class, gpointer g_class_data UNUSED )
    123121{
    124122    GObjectClass * gobject_class;
     
    127125
    128126    gobject_class = G_OBJECT_CLASS( g_class );
    129     gobject_class->dispose = tr_core_dispose;
     127    gobject_class->dispose = core_dispose;
    130128
    131129    core_signals[ADD_ERROR_SIGNAL] = g_signal_new(
     
    211209                dbus_g_object_type_install_info(
    212210                    TR_CORE_TYPE,
    213                     &
    214                     dbus_glib_tr_core_object_info );
     211                    &dbus_glib_gtr_core_object_info );
    215212        }
    216213    }
     
    223220
    224221static GtkTreeModel *
    225 tr_core_raw_model( TrCore * core )
    226 {
    227     return isDisposed( core ) ? NULL : core->priv->raw_model;
     222core_raw_model( TrCore * core )
     223{
     224    return core_is_disposed( core ) ? NULL : core->priv->raw_model;
    228225}
    229226
    230227GtkTreeModel *
    231 tr_core_model( TrCore * core )
    232 {
    233     return isDisposed( core ) ? NULL : core->priv->sorted_model;
     228gtr_core_model( TrCore * core )
     229{
     230    return core_is_disposed( core ) ? NULL : core->priv->sorted_model;
    234231}
    235232
    236233tr_session *
    237 tr_core_session( TrCore * core )
    238 {
    239     return isDisposed( core ) ? NULL : core->priv->session;
     234gtr_core_session( TrCore * core )
     235{
     236    return core_is_disposed( core ) ? NULL : core->priv->session;
    240237}
    241238
     
    245242
    246243static tr_bool
    247 coreIsBusy( TrCore * core )
     244core_is_busy( TrCore * core )
    248245{
    249246    return core->priv->busy_count > 0;
     
    251248
    252249static void
    253 emitBusy( TrCore * core )
    254 {
    255     g_signal_emit( core, core_signals[BUSY_SIGNAL], 0, coreIsBusy( core ) );
    256 }
    257 
    258 static void
    259 coreAddToBusy( TrCore * core, int addMe )
    260 {
    261     const tr_bool wasBusy = coreIsBusy( core );
     250core_emit_busy( TrCore * core )
     251{
     252    g_signal_emit( core, core_signals[BUSY_SIGNAL], 0, core_is_busy( core ) );
     253}
     254
     255static void
     256core_add_to_busy( TrCore * core, int addMe )
     257{
     258    const tr_bool wasBusy = core_is_busy( core );
    262259
    263260    core->priv->busy_count += addMe;
    264261
    265     if( wasBusy != coreIsBusy( core ) )
    266         emitBusy( core );
    267 }
    268 
    269 static void coreIncBusy( TrCore * core ) { coreAddToBusy( core, 1 ); }
    270 static void coreDecBusy( TrCore * core ) { coreAddToBusy( core, -1 ); }
     262    if( wasBusy != core_is_busy( core ) )
     263        core_emit_busy( core );
     264}
     265
     266static void core_inc_busy( TrCore * core ) { core_add_to_busy( core, 1 ); }
     267static void core_dec_busy( TrCore * core ) { core_add_to_busy( core, -1 ); }
    271268
    272269/***
     
    357354    const tr_stat *sa, *sb;
    358355
    359     gtk_tree_model_get( m, a, MC_TORRENT_RAW, &ta, -1 );
     356    gtk_tree_model_get( m, a, MC_TORRENT, &ta, -1 );
    360357    sa = tr_torrentStatCached( ta );
    361     gtk_tree_model_get( m, b, MC_TORRENT_RAW, &tb, -1 );
     358    gtk_tree_model_get( m, b, MC_TORRENT, &tb, -1 );
    362359    sb = tr_torrentStatCached( tb );
    363360
     
    377374    gtk_tree_model_get( m, a, MC_SPEED_UP, &aUp,
    378375                              MC_SPEED_DOWN, &aDown,
    379                               MC_TORRENT_RAW, &ta,
     376                              MC_TORRENT, &ta,
    380377                              -1 );
    381378    gtk_tree_model_get( m, b, MC_SPEED_UP, &bUp,
    382379                              MC_SPEED_DOWN, &bDown,
    383                               MC_TORRENT_RAW, &tb,
     380                              MC_TORRENT, &tb,
    384381                              -1 );
    385382    sa = tr_torrentStatCached( ta );
     
    398395    tr_torrent *ta, *tb;
    399396
    400     gtk_tree_model_get( m, a, MC_TORRENT_RAW, &ta, -1 );
    401     gtk_tree_model_get( m, b, MC_TORRENT_RAW, &tb, -1 );
     397    gtk_tree_model_get( m, a, MC_TORRENT, &ta, -1 );
     398    gtk_tree_model_get( m, b, MC_TORRENT, &tb, -1 );
    402399
    403400    if( !ret ) ret = compareTime( tr_torrentStatCached( ta )->addedDate, tr_torrentStatCached( tb )->addedDate );
     
    413410    const tr_info *ia, *ib;
    414411
    415     gtk_tree_model_get( m, a, MC_TORRENT_RAW, &t, -1 );
     412    gtk_tree_model_get( m, a, MC_TORRENT, &t, -1 );
    416413    ia = tr_torrentInfo( t );
    417     gtk_tree_model_get( m, b, MC_TORRENT_RAW, &t, -1 );
     414    gtk_tree_model_get( m, b, MC_TORRENT, &t, -1 );
    418415    ib = tr_torrentInfo( t );
    419416
     
    430427    const tr_stat *sa, *sb;
    431428
    432     gtk_tree_model_get( m, a, MC_TORRENT_RAW, &t, -1 );
     429    gtk_tree_model_get( m, a, MC_TORRENT, &t, -1 );
    433430    sa = tr_torrentStatCached( t );
    434     gtk_tree_model_get( m, b, MC_TORRENT_RAW, &t, -1 );
     431    gtk_tree_model_get( m, b, MC_TORRENT, &t, -1 );
    435432    sb = tr_torrentStatCached( t );
    436433
     
    447444    tr_torrent *ta, *tb;
    448445
    449     gtk_tree_model_get( m, a, MC_TORRENT_RAW, &ta, -1 );
    450     gtk_tree_model_get( m, b, MC_TORRENT_RAW, &tb, -1 );
     446    gtk_tree_model_get( m, a, MC_TORRENT, &ta, -1 );
     447    gtk_tree_model_get( m, b, MC_TORRENT, &tb, -1 );
    451448
    452449    if( !ret ) ret = compareETA( tr_torrentStatCached( ta )->eta, tr_torrentStatCached( tb )->eta );
     
    472469setSort( TrCore * core, const char * mode, gboolean isReversed  )
    473470{
    474     const int col = MC_TORRENT_RAW;
     471    const int col = MC_TORRENT;
    475472    GtkTreeIterCompareFunc sort_func;
    476473    GtkSortType type = isReversed ? GTK_SORT_ASCENDING : GTK_SORT_DESCENDING;
    477     GtkTreeSortable * sortable = GTK_TREE_SORTABLE( tr_core_model( core ) );
     474    GtkTreeSortable * sortable = GTK_TREE_SORTABLE( gtr_core_model( core ) );
    478475
    479476    if( !strcmp( mode, "sort-by-activity" ) )
     
    501498
    502499static void
    503 tr_core_apply_defaults( tr_ctor * ctor )
     500gtr_core_apply_defaults( tr_ctor * ctor )
    504501{
    505502    if( tr_ctorGetPaused( ctor, TR_FORCE, NULL ) )
     
    519516        tr_ctorSetDownloadDir( ctor, TR_FORCE, path );
    520517    }
    521 }
    522 
    523 static char *
    524 torrentTrackerString( tr_torrent * tor )
    525 {
    526     int i;
    527     GString * str = g_string_new( NULL );
    528     const tr_info * inf = tr_torrentInfo( tor );
    529 
    530     for( i = 0; i < inf->trackerCount; ++i )
    531     {
    532         const tr_tracker_info * t = &inf->trackers[i];
    533         g_string_append( str, t->announce );
    534     }
    535 
    536     return g_string_free( str, FALSE );
    537 }
    538 
    539 static gboolean
    540 isTorrentActive( const tr_stat * st )
    541 {
    542     return ( st->peersSendingToUs > 0 )
    543         || ( st->peersGettingFromUs > 0 )
    544         || ( st->activity == TR_STATUS_CHECK );
    545518}
    546519
     
    615588    /* add the torrents from that list */
    616589    core->priv->adding_from_watch_dir = TRUE;
    617     tr_core_add_list_defaults( core, addme, TRUE );
     590    gtr_core_add_list_defaults( core, addme, TRUE );
    618591    core->priv->adding_from_watch_dir = FALSE;
    619592
     
    736709    {
    737710        const uint16_t val = gtr_pref_int_get( key );
    738         tr_sessionSetPeerLimit( tr_core_session( core ), val );
     711        tr_sessionSetPeerLimit( gtr_core_session( core ), val );
    739712    }
    740713    else if( !strcmp( key, TR_PREFS_KEY_PEER_LIMIT_TORRENT ) )
    741714    {
    742715        const uint16_t val = gtr_pref_int_get( key );
    743         tr_sessionSetPeerLimitPerTorrent( tr_core_session( core ), val );
     716        tr_sessionSetPeerLimitPerTorrent( gtr_core_session( core ), val );
    744717    }
    745718    else if( !strcmp( key, PREF_KEY_INHIBIT_HIBERNATION ) )
    746719    {
    747         maybeInhibitHibernation( core );
     720        maybe_inhibit_hibernation( core );
    748721    }
    749722#ifdef HAVE_GIO
     
    757730
    758731static void
    759 tr_core_init( GTypeInstance *  instance,
    760               gpointer g_class UNUSED )
     732gtr_core_init( GTypeInstance * instance, gpointer g_class UNUSED )
    761733{
    762734    GtkListStore * store;
     
    768740    GType types[] = { G_TYPE_STRING,    /* name */
    769741                      G_TYPE_STRING,    /* collated name */
    770                       TR_TORRENT_TYPE,  /* TrTorrent object */
    771742                      G_TYPE_POINTER,   /* tr_torrent* */
     743                      G_TYPE_INT,       /* torrent id */
    772744                      G_TYPE_DOUBLE,    /* tr_stat.pieceUploadSpeed_KBps */
    773745                      G_TYPE_DOUBLE,    /* tr_stat.pieceDownloadSpeed_KBps */
     
    806778
    807779GType
    808 tr_core_get_type( void )
     780gtr_core_get_type( void )
    809781{
    810782    static GType type = 0;
     
    817789            NULL,                 /* base_init */
    818790            NULL,                 /* base_finalize */
    819             tr_core_class_init,   /* class_init */
     791            gtr_core_class_init,  /* class_init */
    820792            NULL,                 /* class_finalize */
    821793            NULL,                 /* class_data */
    822794            sizeof( TrCore ),
    823795            0,                    /* n_preallocs */
    824             tr_core_init,         /* instance_init */
     796            gtr_core_init,        /* instance_init */
    825797            NULL,
    826798        };
     
    836808
    837809TrCore *
    838 tr_core_new( tr_session * session )
     810gtr_core_new( tr_session * session )
    839811{
    840812    TrCore * core = TR_CORE( g_object_new( TR_CORE_TYPE, NULL ) );
     
    854826
    855827void
    856 tr_core_close( TrCore * core )
    857 {
    858     tr_session * session = tr_core_session( core );
     828gtr_core_close( TrCore * core )
     829{
     830    tr_session * session = gtr_core_session( core );
    859831
    860832    if( session )
     
    877849}
    878850
    879 void
    880 tr_core_add_torrent( TrCore * self, TrTorrent * gtor, gboolean doNotify )
    881 {
    882     const tr_stat * st = tr_torrent_stat( gtor );
    883     tr_torrent * tor = tr_torrent_handle( gtor );
    884     const char * name = tr_torrentName( tor );
    885     char * collated = get_collated_name( tor );
    886     char *  trackers = torrentTrackerString( tor );
    887     GtkListStore *  store = GTK_LIST_STORE( tr_core_raw_model( self ) );
    888     GtkTreeIter  unused;
    889 
    890     gtk_list_store_insert_with_values( store, &unused, 0,
    891         MC_NAME,              name,
    892         MC_NAME_COLLATED,     collated,
    893         MC_TORRENT,           gtor,
    894         MC_TORRENT_RAW,       tor,
    895         MC_SPEED_UP,          st->pieceUploadSpeed_KBps,
    896         MC_SPEED_DOWN,        st->pieceDownloadSpeed_KBps,
    897         MC_RECHECK_PROGRESS,  st->recheckProgress,
    898         MC_ACTIVE,            isTorrentActive( st ),
    899         MC_ACTIVITY,          st->activity,
    900         MC_FINISHED,          st->finished,
    901         MC_PRIORITY,          tr_torrentGetPriority( tor ),
    902         MC_TRACKERS,          trackers,
    903         -1 );
    904 
    905     if( doNotify )
    906         gtr_notify_added( name );
    907 
    908     /* cleanup */
    909     g_object_unref( G_OBJECT( gtor ) );
    910     g_free( collated );
    911     g_free( trackers );
    912 }
    913 
    914 void
    915 tr_core_load( TrCore * self, gboolean forcePaused )
     851struct notify_callback_data
     852{
     853    TrCore * core;
     854    int torrent_id;
     855};
     856
     857static gboolean
     858on_torrent_completeness_changed_idle( gpointer gdata )
     859{
     860    struct notify_callback_data * data = gdata;
     861    gtr_notify_torrent_completed( data->core, data->torrent_id );
     862    g_object_unref( G_OBJECT( data->core ) );
     863    g_free( data );
     864    return FALSE;
     865}
     866
     867/* this is called in the libtransmission thread, *NOT* the GTK+ thread,
     868   so delegate to the GTK+ thread before calling notify's dbus code... */
     869static void
     870on_torrent_completeness_changed( tr_torrent       * tor,
     871                                 tr_completeness    completeness,
     872                                 tr_bool            was_running,
     873                                 void             * gcore )
     874{
     875    if( was_running && ( completeness != TR_LEECH ) && ( tr_torrentStat( tor )->sizeWhenDone != 0 ) )
     876    {
     877        struct notify_callback_data * data = g_new( struct notify_callback_data, 1 );
     878        data->core = gcore;
     879        data->torrent_id = tr_torrentId( tor );
     880        g_object_ref( G_OBJECT( data->core ) );
     881        gtr_idle_add( on_torrent_completeness_changed_idle, data );
     882    }
     883}
     884
     885static char *
     886torrentTrackerString( tr_torrent * tor )
     887{
     888    int i;
     889    GString * str = g_string_new( NULL );
     890    const tr_info * inf = tr_torrentInfo( tor );
     891
     892    for( i = 0; i < inf->trackerCount; ++i )
     893    {
     894        const tr_tracker_info * t = &inf->trackers[i];
     895        g_string_append( str, t->announce );
     896    }
     897
     898    return g_string_free( str, FALSE );
     899}
     900
     901static gboolean
     902isTorrentActive( const tr_stat * st )
     903{
     904    return ( st->peersSendingToUs > 0 )
     905        || ( st->peersGettingFromUs > 0 )
     906        || ( st->activity == TR_STATUS_CHECK );
     907}
     908
     909void
     910gtr_core_add_torrent( TrCore * core, tr_torrent * tor, gboolean doNotify )
     911{
     912    if( tor != NULL )
     913    {
     914        const tr_stat * st = tr_torrentStat( tor );
     915        const char * name = tr_torrentName( tor );
     916        char * collated = get_collated_name( tor );
     917        char *  trackers = torrentTrackerString( tor );
     918        GtkListStore *  store = GTK_LIST_STORE( core_raw_model( core ) );
     919        GtkTreeIter  unused;
     920
     921        gtk_list_store_insert_with_values( store, &unused, 0,
     922            MC_NAME,              name,
     923            MC_NAME_COLLATED,     collated,
     924            MC_TORRENT,           tor,
     925            MC_TORRENT_ID,        tr_torrentId( tor ),
     926            MC_SPEED_UP,          st->pieceUploadSpeed_KBps,
     927            MC_SPEED_DOWN,        st->pieceDownloadSpeed_KBps,
     928            MC_RECHECK_PROGRESS,  st->recheckProgress,
     929            MC_ACTIVE,            isTorrentActive( st ),
     930            MC_ACTIVITY,          st->activity,
     931            MC_FINISHED,          st->finished,
     932            MC_PRIORITY,          tr_torrentGetPriority( tor ),
     933            MC_TRACKERS,          trackers,
     934            -1 );
     935
     936        if( doNotify )
     937            gtr_notify_torrent_added( name );
     938
     939        tr_torrentSetCompletenessCallback( tor, on_torrent_completeness_changed, core );
     940
     941        /* cleanup */
     942        g_free( collated );
     943        g_free( trackers );
     944    }
     945}
     946
     947void
     948gtr_core_load( TrCore * self, gboolean forcePaused )
    916949{
    917950    int i;
     
    920953    int count = 0;
    921954
    922     ctor = tr_ctorNew( tr_core_session( self ) );
     955    ctor = tr_ctorNew( gtr_core_session( self ) );
    923956    if( forcePaused )
    924957        tr_ctorSetPaused( ctor, TR_FORCE, TRUE );
     
    926959                         gtr_pref_int_get( TR_PREFS_KEY_PEER_LIMIT_TORRENT ) );
    927960
    928     torrents = tr_sessionLoadTorrents ( tr_core_session( self ), ctor, &count );
     961    torrents = tr_sessionLoadTorrents ( gtr_core_session( self ), ctor, &count );
    929962    for( i=0; i<count; ++i )
    930         tr_core_add_torrent( self, tr_torrent_new_preexisting( torrents[i] ), FALSE );
     963        gtr_core_add_torrent( self, torrents[i], FALSE );
    931964
    932965    tr_free( torrents );
     
    935968
    936969void
    937 tr_core_clear( TrCore * self )
    938 {
    939     gtk_list_store_clear( GTK_LIST_STORE( tr_core_raw_model( self ) ) );
     970gtr_core_clear( TrCore * self )
     971{
     972    gtk_list_store_clear( GTK_LIST_STORE( core_raw_model( self ) ) );
    940973}
    941974
     
    945978
    946979static void
    947 emitBlocklistUpdated( TrCore * core, int ruleCount )
     980core_emit_blocklist_udpated( TrCore * core, int ruleCount )
    948981{
    949982    g_signal_emit( core, core_signals[BLOCKLIST_SIGNAL], 0, ruleCount );
     
    951984
    952985static void
    953 emitPortTested( TrCore * core, gboolean isOpen )
     986core_emit_port_tested( TrCore * core, gboolean isOpen )
    954987{
    955988    g_signal_emit( core, core_signals[PORT_SIGNAL], 0, isOpen );
     
    957990
    958991static void
    959 tr_core_errsig( TrCore * core, enum tr_core_err type, const char * msg )
     992gtr_core_errsig( TrCore * core, enum tr_core_err type, const char * msg )
    960993{
    961994    g_signal_emit( core, core_signals[ADD_ERROR_SIGNAL], 0, type, msg );
    962995}
     996
     997static tr_torrent *
     998torrent_new_from_ctor( TrCore * core, tr_ctor * ctor )
     999{
     1000    int errcode = 0;
     1001    tr_torrent * tor;
     1002    uint8_t      doTrash = FALSE;
     1003    tr_session * session = gtr_core_session( core );
     1004
     1005    /* let the gtk client handle the removal, since libT
     1006     * doesn't have any concept of the glib trash API */
     1007    tr_ctorGetDeleteSource( ctor, &doTrash );
     1008    tr_ctorSetDeleteSource( ctor, FALSE );
     1009    tor = tr_torrentNew( ctor, &errcode );
     1010
     1011    if( tor && doTrash )
     1012    {
     1013        const char * config = tr_sessionGetConfigDir( session );
     1014        const char * source = tr_ctorGetSourceFile( ctor );
     1015        const int is_internal = source && ( strstr( source, config ) == source );
     1016
     1017        /* #1294: don't delete the source .torrent file if it's our internal copy */
     1018        if( !is_internal )
     1019            gtr_file_trash_or_remove( source );
     1020    }
     1021
     1022    return tor;
     1023}
     1024
    9631025
    9641026static int
     
    9781040             * don't want to be nagging users to clean up their watch dirs */
    9791041            if( !tr_ctorGetSourceFile(ctor) || !core->priv->adding_from_watch_dir )
    980                 tr_core_errsig( core, err, inf.name );
     1042                gtr_core_errsig( core, err, inf.name );
    9811043            tr_metainfoFree( &inf );
    9821044            break;
     
    9851047            if( doPrompt )
    9861048                g_signal_emit( core, core_signals[ADD_PROMPT_SIGNAL], 0, ctor );
    987             else {
    988                 tr_session * session = tr_core_session( core );
    989                 TrTorrent * gtor = tr_torrent_new_ctor( session, ctor, &err );
    990                 if( !err )
    991                     tr_core_add_torrent( core, gtor, doNotify );
    992             }
     1049            else
     1050                gtr_core_add_torrent( core, torrent_new_from_ctor( core, ctor ), doNotify );
    9931051            tr_metainfoFree( &inf );
    9941052            break;
    9951053    }
    9961054
     1055    tr_ctorFree( ctor );
    9971056    return err;
    9981057}
    9991058
    10001059void
    1001 tr_core_add_ctor( TrCore * core, tr_ctor * ctor )
     1060gtr_core_add_ctor( TrCore * core, tr_ctor * ctor )
    10021061{
    10031062    const gboolean doPrompt = gtr_pref_flag_get( PREF_KEY_OPTIONS_PROMPT );
    10041063    const gboolean doNotify = FALSE;
    1005     tr_core_apply_defaults( ctor );
     1064    gtr_core_apply_defaults( ctor );
    10061065    add_ctor( core, ctor, doPrompt, doNotify );
    10071066}
     
    10091068/* invoked remotely via dbus. */
    10101069gboolean
    1011 tr_core_add_metainfo( TrCore      * core,
    1012                       const char  * payload,
    1013                       gboolean    * setme_handled,
    1014                       GError     ** gerr UNUSED )
    1015 {
    1016     tr_session * session = tr_core_session( core );
     1070gtr_core_add_metainfo( TrCore      * core,
     1071                       const char  * payload,
     1072                       gboolean    * setme_handled,
     1073                       GError     ** gerr UNUSED )
     1074{
     1075    tr_session * session = gtr_core_session( core );
    10171076
    10181077    if( !session )
     
    10221081    else if( gtr_is_supported_url( payload ) || gtr_is_magnet_link( payload ) )
    10231082    {
    1024         tr_core_add_from_url( core, payload );
     1083        gtr_core_add_from_url( core, payload );
    10251084        *setme_handled = TRUE;
    10261085    }
     
    10331092
    10341093        ctor = tr_ctorNew( session );
    1035         tr_core_apply_defaults( ctor );
     1094        gtr_core_apply_defaults( ctor );
    10361095
    10371096        file_contents = tr_base64_decode( payload, -1, &file_length );
     
    10401099
    10411100        tr_free( file_contents );
    1042         tr_core_torrents_added( core );
     1101        gtr_core_torrents_added( core );
    10431102        *setme_handled = TRUE;
    10441103    }
     
    10631122
    10641123static gboolean
    1065 onURLDoneIdle( gpointer vdata )
     1124on_url_done_idle( gpointer vdata )
    10661125{
    10671126    struct url_dialog_data * data = vdata;
     
    10781137
    10791138        if( err == TR_PARSE_ERR )
    1080             tr_core_errsig( data->core, TR_PARSE_ERR, data->url );
    1081 
    1082         tr_core_torrents_added( data->core );
     1139            gtr_core_errsig( data->core, TR_PARSE_ERR, data->url );
     1140
     1141        gtr_core_torrents_added( data->core );
    10831142    }
    10841143
    10851144    /* cleanup */
    1086     coreDecBusy( data->core );
     1145    core_dec_busy( data->core );
    10871146    g_free( data->url );
    10881147    g_free( data );
     
    10911150
    10921151static void
    1093 onURLDone( tr_session   * session,
    1094            tr_bool        did_connect,
    1095            tr_bool        did_timeout,
    1096            long           response_code,
    1097            const void   * response,
    1098            size_t         response_byte_count,
    1099            void         * vdata )
     1152on_url_done( tr_session   * session,
     1153             tr_bool        did_connect,
     1154             tr_bool        did_timeout,
     1155             long           response_code,
     1156             const void   * response,
     1157             size_t         response_byte_count,
     1158             void         * vdata )
    11001159{
    11011160    struct url_dialog_data * data = vdata;
     
    11051164    data->response_code = response_code;
    11061165    data->ctor = tr_ctorNew( session );
    1107     tr_core_apply_defaults( data->ctor );
     1166    gtr_core_apply_defaults( data->ctor );
    11081167    tr_ctorSetMetainfo( data->ctor, response, response_byte_count );
    11091168
    1110     gtr_idle_add( onURLDoneIdle, data );
    1111 }
    1112 
    1113 void
    1114 tr_core_add_from_url( TrCore * core, const char * url )
    1115 {
    1116     tr_session * session = tr_core_session( core );
     1169    gtr_idle_add( on_url_done_idle, data );
     1170}
     1171
     1172void
     1173gtr_core_add_from_url( TrCore * core, const char * url )
     1174{
     1175    tr_session * session = gtr_core_session( core );
    11171176    const gboolean is_magnet_link = gtr_is_magnet_link( url );
    11181177
     
    11291188
    11301189        if( !err )
    1131             tr_core_add_ctor( core, ctor );
     1190            gtr_core_add_ctor( core, ctor );
    11321191        else {
    11331192            gtr_unrecognized_url_dialog( NULL, url );
     
    11421201        data->core = core;
    11431202        data->url = g_strdup( url );
    1144         coreIncBusy( data->core );
    1145         tr_webRun( session, url, NULL, onURLDone, data );
     1203        core_inc_busy( data->core );
     1204        tr_webRun( session, url, NULL, on_url_done, data );
    11461205    }
    11471206}
     
    11581217              gboolean      doNotify )
    11591218{
    1160     tr_session * session = tr_core_session( core );
     1219    tr_session * session = gtr_core_session( core );
    11611220
    11621221    if( session == NULL )
     
    11651224    if( gtr_is_supported_url( filename ) || gtr_is_magnet_link( filename ) )
    11661225    {
    1167         tr_core_add_from_url( core, filename );
     1226        gtr_core_add_from_url( core, filename );
    11681227    }
    11691228    else if( g_file_test( filename, G_FILE_TEST_EXISTS ) )
     
    11731232        tr_ctor * ctor = tr_ctorNew( session );
    11741233        tr_ctorSetMetainfoFromFile( ctor, filename );
    1175         tr_core_apply_defaults( ctor );
     1234        gtr_core_apply_defaults( ctor );
    11761235        tr_ctorSetPaused( ctor, TR_FORCE, !doStart );
    11771236
    11781237        err = add_ctor( core, ctor, doPrompt, doNotify );
    11791238        if( err == TR_PARSE_ERR )
    1180             tr_core_errsig( core, TR_PARSE_ERR, filename );
     1239            gtr_core_errsig( core, TR_PARSE_ERR, filename );
    11811240    }
    11821241    else if( gtr_is_hex_hashcode( filename ) )
    11831242    {
    1184         tr_core_add_from_url( core, filename );
     1243        gtr_core_add_from_url( core, filename );
    11851244    }
    11861245}
    11871246
    11881247gboolean
    1189 tr_core_present_window( TrCore      * core UNUSED,
    1190                         gboolean *        success,
    1191                         GError     ** err  UNUSED )
     1248gtr_core_present_window( TrCore      * core UNUSED,
     1249                         gboolean    * success,
     1250                         GError     ** err  UNUSED )
    11921251{
    11931252    /* Setting the toggle-main-window GtkCheckMenuItem to
     
    12001259
    12011260void
    1202 tr_core_add_list( TrCore       * core,
    1203                   GSList       * torrentFiles,
    1204                   gboolean       doStart,
    1205                   gboolean       doPrompt,
    1206                   gboolean       doNotify )
     1261gtr_core_add_list( TrCore    * core,
     1262                   GSList    * torrentFiles,
     1263                   gboolean    doStart,
     1264                   gboolean    doPrompt,
     1265                   gboolean    doNotify )
    12071266{
    12081267    GSList * l;
     
    12151274    }
    12161275
    1217     tr_core_torrents_added( core );
     1276    gtr_core_torrents_added( core );
    12181277
    12191278    g_slist_free( torrentFiles );
     
    12211280
    12221281void
    1223 tr_core_add_list_defaults( TrCore * core, GSList * torrentFiles, gboolean doNotify )
     1282gtr_core_add_list_defaults( TrCore * core, GSList * torrentFiles, gboolean doNotify )
    12241283{
    12251284    const gboolean doStart = gtr_pref_flag_get( TR_PREFS_KEY_START );
    12261285    const gboolean doPrompt = gtr_pref_flag_get( PREF_KEY_OPTIONS_PROMPT );
    12271286
    1228     tr_core_add_list( core, torrentFiles, doStart, doPrompt, doNotify );
    1229 }
    1230 
    1231 void
    1232 tr_core_torrents_added( TrCore * self )
    1233 {
    1234     tr_core_update( self );
    1235     tr_core_errsig( self, TR_CORE_ERR_NO_MORE_TORRENTS, NULL );
     1287    gtr_core_add_list( core, torrentFiles, doStart, doPrompt, doNotify );
     1288}
     1289
     1290void
     1291gtr_core_torrents_added( TrCore * self )
     1292{
     1293    gtr_core_update( self );
     1294    gtr_core_errsig( self, TR_CORE_ERR_NO_MORE_TORRENTS, NULL );
    12361295}
    12371296
    12381297static gboolean
    1239 findTorrentInRawModel( TrCore * core, int id, GtkTreeIter * setme )
    1240 {
    1241     int match = 0;
     1298find_row_from_torrent_id( GtkTreeModel * model, int id, GtkTreeIter * setme )
     1299{
    12421300    GtkTreeIter iter;
    1243     GtkTreeModel * model = tr_core_raw_model( core );
     1301    gboolean match = FALSE;
    12441302
    12451303    if( gtk_tree_model_iter_children( model, &iter, NULL ) ) do
    12461304    {
    1247         tr_torrent * tor;
    1248         gtk_tree_model_get( model, &iter, MC_TORRENT_RAW, &tor, -1 );
    1249         match = tr_torrentId( tor ) == id;
     1305        int row_id;
     1306        gtk_tree_model_get( model, &iter, MC_TORRENT_ID, &row_id, -1 );
     1307        match = id == row_id;
    12501308    }
    12511309    while( !match && gtk_tree_model_iter_next( model, &iter ) );
     
    12581316
    12591317void
    1260 tr_core_remove_torrent( TrCore * core, TrTorrent * gtor, gboolean deleteFiles )
    1261 {
    1262     const tr_torrent * tor = tr_torrent_handle( gtor );
     1318gtr_core_remove_torrent( TrCore * core, int id, gboolean delete_local_data )
     1319{
     1320    tr_torrent * tor = gtr_core_find_torrent( core, id );
    12631321
    12641322    if( tor != NULL )
    1265         tr_core_remove_torrent_from_id( core, tr_torrentId( tor ), deleteFiles );
    1266 }
    1267 
    1268 void
    1269 tr_core_remove_torrent_from_id( TrCore * core, int id, gboolean deleteFiles )
    1270 {
    1271     GtkTreeIter iter;
    1272 
    1273     if( findTorrentInRawModel( core, id, &iter ) )
    1274     {
    1275         TrTorrent * gtor = NULL;
    1276         tr_torrent * tor = NULL;
    1277         GtkTreeModel * model = tr_core_raw_model( core );
    1278 
    1279         gtk_tree_model_get( model, &iter, MC_TORRENT, &gtor,
    1280                                           MC_TORRENT_RAW, &tor,
    1281                                           -1 );
    1282 
     1323    {
    12831324        /* remove from the gui */
    1284         gtk_list_store_remove( GTK_LIST_STORE( model ), &iter );
     1325        GtkTreeIter iter;
     1326        GtkTreeModel * model = core_raw_model( core );
     1327        if( find_row_from_torrent_id( model, id, &iter ) )
     1328            gtk_list_store_remove( GTK_LIST_STORE( model ), &iter );
    12851329
    12861330        /* remove the torrent */
    1287         tr_torrent_set_delete_local_data_flag( gtor, deleteFiles );
    1288         tr_torrent_set_remove_flag( gtor, TRUE );
    1289         gtr_warn_if_fail( G_OBJECT( gtor )->ref_count == 1 );
    1290         g_object_unref( G_OBJECT( gtor ) ); /* remove the last refcount */
     1331        tr_torrentRemove( tor, delete_local_data, gtr_file_trash_or_remove );
    12911332    }
    12921333}
     
    13141355    gboolean oldActive, newActive;
    13151356    const tr_stat * st;
    1316     TrTorrent * gtor;
    13171357    tr_torrent * tor;
    13181358
    13191359    /* get the old states */
    13201360    gtk_tree_model_get( model, iter,
    1321                         MC_TORRENT, &gtor,
     1361                        MC_TORRENT,  &tor,
    13221362                        MC_NAME_COLLATED, &oldCollatedName,
    13231363                        MC_ACTIVE, &oldActive,
     
    13341374
    13351375    /* get the new states */
    1336     tor = tr_torrent_handle( gtor );
    13371376    st = tr_torrentStat( tor );
    13381377    newActive = isTorrentActive( st );
     
    13781417
    13791418    /* cleanup */
    1380     g_object_unref( gtor );
    13811419    g_free( newCollatedName );
    13821420    g_free( oldCollatedName );
     
    13871425
    13881426void
    1389 tr_core_update( TrCore * core )
     1427gtr_core_update( TrCore * core )
    13901428{
    13911429    /* refresh the model */
    1392     gtk_tree_model_foreach( tr_core_raw_model( core ), update_foreach, NULL );
    1393 
    1394     /* maybe inhibit hibernation */
    1395     maybeInhibitHibernation( core );
     1430    gtk_tree_model_foreach( core_raw_model( core ), update_foreach, NULL );
     1431
     1432    maybe_inhibit_hibernation( core );
    13961433}
    13971434
     
    14881525
    14891526static void
    1490 tr_core_set_hibernation_allowed( TrCore * core,
    1491                                  gboolean allowed )
     1527gtr_core_set_hibernation_allowed( TrCore * core, gboolean allowed )
    14921528{
    14931529#ifdef HAVE_DBUS_GLIB
     
    15161552
    15171553static void
    1518 maybeInhibitHibernation( TrCore * core )
     1554maybe_inhibit_hibernation( TrCore * core )
    15191555{
    15201556    /* hibernation is allowed if EITHER
     
    15221558     * (b) there aren't any active torrents */
    15231559    const gboolean hibernation_allowed = !gtr_pref_flag_get( PREF_KEY_INHIBIT_HIBERNATION )
    1524                                       || !tr_core_get_active_torrent_count( core );
    1525     tr_core_set_hibernation_allowed( core, hibernation_allowed );
     1560                                      || !gtr_core_get_active_torrent_count( core );
     1561    gtr_core_set_hibernation_allowed( core, hibernation_allowed );
    15261562}
    15271563
     
    15311567
    15321568static void
    1533 commitPrefsChange( TrCore * core, const char * key )
     1569core_commit_prefs_change( TrCore * core, const char * key )
    15341570{
    15351571    g_signal_emit( core, core_signals[PREFS_SIGNAL], 0, key );
    1536     gtr_pref_save( tr_core_session( core ) );
    1537 }
    1538 
    1539 void
    1540 tr_core_set_pref( TrCore * self, const char * key, const char * newval )
    1541 {
    1542     const char * oldval = gtr_pref_string_get( key );
    1543 
    1544     if( gtr_strcmp0( oldval, newval ) )
     1572    gtr_pref_save( gtr_core_session( core ) );
     1573}
     1574
     1575void
     1576gtr_core_set_pref( TrCore * self, const char * key, const char * newval )
     1577{
     1578    if( gtr_strcmp0( newval, gtr_pref_string_get( key ) ) )
    15451579    {
    15461580        gtr_pref_string_set( key, newval );
    1547         commitPrefsChange( self, key );
    1548     }
    1549 }
    1550 
    1551 void
    1552 tr_core_set_pref_bool( TrCore *     self,
    1553                        const char * key,
    1554                        gboolean     newval )
    1555 {
    1556     const gboolean oldval = gtr_pref_flag_get( key );
    1557 
    1558     if( oldval != newval )
     1581        core_commit_prefs_change( self, key );
     1582    }
     1583}
     1584
     1585void
     1586gtr_core_set_pref_bool( TrCore * self, const char * key, gboolean newval )
     1587{
     1588    if( newval != gtr_pref_flag_get( key ) )
    15591589    {
    15601590        gtr_pref_flag_set( key, newval );
    1561         commitPrefsChange( self, key );
    1562     }
    1563 }
    1564 
    1565 void
    1566 tr_core_set_pref_int( TrCore *     self,
    1567                       const char * key,
    1568                       int          newval )
    1569 {
    1570     const int oldval = gtr_pref_int_get( key );
    1571 
    1572     if( oldval != newval )
     1591        core_commit_prefs_change( self, key );
     1592    }
     1593}
     1594
     1595void
     1596gtr_core_set_pref_int( TrCore * self, const char * key, int newval )
     1597{
     1598    if( newval != gtr_pref_int_get( key ) )
    15731599    {
    15741600        gtr_pref_int_set( key, newval );
    1575         commitPrefsChange( self, key );
    1576     }
    1577 }
    1578 
    1579 void
    1580 tr_core_set_pref_double( TrCore *     self,
    1581                          const char * key,
    1582                          double       newval )
    1583 {
    1584     const double oldval = gtr_pref_double_get( key );
    1585 
    1586     if( gtr_compare_double( oldval, newval, 4 ) )
     1601        core_commit_prefs_change( self, key );
     1602    }
     1603}
     1604
     1605void
     1606gtr_core_set_pref_double( TrCore * self, const char * key, double newval )
     1607{
     1608    if( gtr_compare_double( newval, gtr_pref_double_get( key ), 4 ) )
    15871609    {
    15881610        gtr_pref_double_set( key, newval );
    1589         commitPrefsChange( self, key );
     1611        core_commit_prefs_change( self, key );
    15901612    }
    15911613}
     
    16131635
    16141636static gboolean
    1615 readResponseIdle( void * vresponse )
     1637core_read_rpc_response_idle( void * vresponse )
    16161638{
    16171639    tr_benc top;
     
    16381660
    16391661static void
    1640 readResponse( tr_session  * session UNUSED,
    1641               struct evbuffer * response,
    1642               void        * unused UNUSED )
     1662core_read_rpc_response( tr_session       * session UNUSED,
     1663                        struct evbuffer * response,
     1664                        void             * unused UNUSED )
    16431665{
    16441666    struct evbuffer * buf = evbuffer_new( );
    16451667    evbuffer_add_buffer( buf, response );
    1646     gtr_idle_add( readResponseIdle, buf );
    1647 }
    1648 
    1649 static void
    1650 sendRequest( TrCore * core, const char * json, int tag,
    1651              server_response_func * responseFunc, void * responseFuncUserData )
    1652 {
    1653     tr_session * session = tr_core_session( core );
     1668    gtr_idle_add( core_read_rpc_response_idle, buf );
     1669}
     1670
     1671static void
     1672core_send_rpc_request( TrCore * core, const char * json, int tag,
     1673                       server_response_func * responseFunc,
     1674                       void * responseFuncUserData )
     1675{
     1676    tr_session * session = gtr_core_session( core );
    16541677
    16551678    if( pendingRequests == NULL )
     
    16761699        g_message( "request: [%s]", json );
    16771700#endif
    1678         tr_rpc_request_exec_json( session, json, strlen( json ), readResponse, GINT_TO_POINTER(tag) );
     1701        tr_rpc_request_exec_json( session, json, strlen( json ), core_read_rpc_response, GINT_TO_POINTER(tag) );
    16791702    }
    16801703}
     
    16851708
    16861709static void
    1687 portTestResponseFunc( TrCore * core, tr_benc * response, gpointer userData UNUSED )
     1710on_port_test_response( TrCore * core, tr_benc * response, gpointer userData UNUSED )
    16881711{
    16891712    tr_benc * args;
     
    16931716        tr_bencDictFindBool( args, "port-is-open", &isOpen );
    16941717
    1695     emitPortTested( core, isOpen );
    1696 }
    1697 
    1698 void
    1699 tr_core_port_test( TrCore * core )
     1718    core_emit_port_tested( core, isOpen );
     1719}
     1720
     1721void
     1722gtr_core_port_test( TrCore * core )
    17001723{
    17011724    char buf[128];
    17021725    const int tag = nextTag++;
    17031726    g_snprintf( buf, sizeof( buf ), "{ \"method\": \"port-test\", \"tag\": %d }", tag );
    1704     sendRequest( core, buf, tag, portTestResponseFunc, NULL );
     1727    core_send_rpc_request( core, buf, tag, on_port_test_response, NULL );
    17051728}
    17061729
     
    17211744        gtr_pref_int_set( "blocklist-date", time( NULL ) );
    17221745
    1723     emitBlocklistUpdated( core, ruleCount );
    1724 }
    1725 
    1726 void
    1727 tr_core_blocklist_update( TrCore * core )
     1746    core_emit_blocklist_udpated( core, ruleCount );
     1747}
     1748
     1749void
     1750gtr_core_blocklist_update( TrCore * core )
    17281751{
    17291752    char buf[128];
    17301753    const int tag = nextTag++;
    17311754    g_snprintf( buf, sizeof( buf ), "{ \"method\": \"blocklist-update\", \"tag\": %d }", tag );
    1732     sendRequest( core, buf, tag, blocklistResponseFunc, NULL );
     1755    core_send_rpc_request( core, buf, tag, blocklistResponseFunc, NULL );
    17331756}
    17341757
     
    17381761
    17391762void
    1740 tr_core_exec_json( TrCore * core, const char * json )
     1763gtr_core_exec_json( TrCore * core, const char * json )
    17411764{
    17421765    const int tag = nextTag++;
    1743     sendRequest( core, json, tag, NULL, NULL );
    1744 }
    1745 
    1746 void
    1747 tr_core_exec( TrCore * core, const tr_benc * top )
     1766    core_send_rpc_request( core, json, tag, NULL, NULL );
     1767}
     1768
     1769void
     1770gtr_core_exec( TrCore * core, const tr_benc * top )
    17481771{
    17491772    char * json = tr_bencToStr( top, TR_FMT_JSON_LEAN, NULL );
    1750     tr_core_exec_json( core, json );
     1773    gtr_core_exec_json( core, json );
    17511774    tr_free( json );
    17521775}
     
    17561779***/
    17571780
    1758 void
    1759 tr_core_torrent_changed( TrCore * core, int id )
    1760 {
    1761     GtkTreeIter iter;
    1762     GtkTreeModel * model = tr_core_raw_model( core );
    1763 
    1764     if( gtk_tree_model_get_iter_first( model, &iter ) ) do
    1765     {
    1766         tr_torrent * tor;
    1767         gtk_tree_model_get( model, &iter, MC_TORRENT_RAW, &tor, -1 );
    1768         if( tr_torrentId( tor ) == id )
    1769         {
    1770             GtkTreePath * path = gtk_tree_model_get_path( model, &iter );
    1771             gtk_tree_model_row_changed( model, path, &iter );
    1772             gtk_tree_path_free( path );
    1773             break;
    1774         }
    1775     }
    1776     while( gtk_tree_model_iter_next( model, &iter ) );
    1777 }
    1778 
    17791781size_t
    1780 tr_core_get_torrent_count( TrCore * core )
    1781 {
    1782     return gtk_tree_model_iter_n_children( tr_core_raw_model( core ), NULL );
     1782gtr_core_get_torrent_count( TrCore * core )
     1783{
     1784    return gtk_tree_model_iter_n_children( core_raw_model( core ), NULL );
    17831785}
    17841786
    17851787size_t
    1786 tr_core_get_active_torrent_count( TrCore * core )
     1788gtr_core_get_active_torrent_count( TrCore * core )
    17871789{
    17881790    GtkTreeIter iter;
    17891791    size_t activeCount = 0;
    1790     GtkTreeModel * model = tr_core_raw_model( core );
     1792    GtkTreeModel * model = core_raw_model( core );
    17911793
    17921794    if( gtk_tree_model_get_iter_first( model, &iter ) ) do
     
    18031805}
    18041806
     1807tr_torrent *
     1808gtr_core_find_torrent( TrCore * core, int id )
     1809{
     1810    tr_session * session;
     1811    tr_torrent * tor = NULL;
     1812
     1813    if(( session = gtr_core_session( core )))
     1814        tor = tr_torrentFindFromId( session, id );
     1815
     1816    return tor;
     1817}
     1818
     1819void
     1820gtr_core_open_folder( TrCore * core, int torrent_id )
     1821{
     1822    const tr_torrent * tor = gtr_core_find_torrent( core, torrent_id );
     1823
     1824    if( tor != NULL )
     1825    {
     1826        const gboolean single = tr_torrentInfo( tor )->fileCount == 1;
     1827        const char * currentDir = tr_torrentGetCurrentDir( tor );
     1828        if( single )
     1829            gtr_open_file( currentDir );
     1830        else {
     1831            char * path = g_build_filename( currentDir, tr_torrentName( tor ), NULL );
     1832            gtr_open_file( path );
     1833            g_free( path );
     1834        }
     1835    }
     1836}
  • trunk/gtk/tr-core.h

    r11808 r12068  
    3030
    3131#include <libtransmission/transmission.h>
    32 #include "tr-torrent.h"
    33 
    34 #define TR_CORE_TYPE ( tr_core_get_type( ) )
    35 #define TR_CORE( o ) G_TYPE_CHECK_INSTANCE_CAST( ( o ), TR_CORE_TYPE,\
    36                                                 TrCore )
    37 #define TR_IS_CORE( o ) G_TYPE_CHECK_INSTANCE_TYPE( ( o ), TR_CORE_TYPE )
    38 #define TR_CORE_CLASS( k ) G_TYPE_CHECK_CLASS_CAST( ( k ), TR_CORE_TYPE,\
    39                                                    TrCoreClass )
    40 #define TR_IS_CORE_CLASS( k ) G_TYPE_CHECK_CLASS_TYPE( ( k ), TR_CORE_TYPE )
    41 #define TR_CORE_GET_CLASS( o ) G_TYPE_INSTANCE_GET_CLASS( ( o ),\
    42                                                          TR_CORE_TYPE, \
    43                                                          TrCoreClass )
     32#include <libtransmission/bencode.h>
     33
     34#define TR_CORE_TYPE ( gtr_core_get_type() )
     35#define TR_CORE(o) G_TYPE_CHECK_INSTANCE_CAST((o), TR_CORE_TYPE, TrCore)
     36#define TR_IS_CORE(o) G_TYPE_CHECK_INSTANCE_TYPE((o), TR_CORE_TYPE )
     37#define TR_CORE_CLASS(k) G_TYPE_CHECK_CLASS_CAST((k), TR_CORE_TYPE, TrCoreClass)
     38#define TR_IS_CORE_CLASS(k) G_TYPE_CHECK_CLASS_TYPE((k), TR_CORE_TYPE )
     39#define TR_CORE_GET_CLASS(o) G_TYPE_INSTANCE_GET_CLASS((o), TR_CORE_TYPE, TrCoreClass)
    4440
    4541typedef struct _TrCore
     
    6561    void (* add_prompt)        (TrCore*, gpointer ctor);
    6662    void (* blocklist_updated) (TrCore*, int ruleCount );
    67     void (* busy)              (TrCore*, gboolean isBusy);
     63    void (* busy)              (TrCore*, gboolean is_busy);
    6864    void (* prefs_changed)     (TrCore*, const char* key);
    69     void (* port_tested)       (TrCore*, gboolean isOpen);
     65    void (* port_tested)       (TrCore*, gboolean is_open);
    7066    void (* quit)              (TrCore*);
    7167}
    7268TrCoreClass;
    7369
    74 GType          tr_core_get_type( void );
    75 
    76 TrCore *       tr_core_new( tr_session * );
    77 
    78 void           tr_core_close( TrCore* );
     70GType          gtr_core_get_type( void );
     71
     72TrCore *       gtr_core_new( tr_session * );
     73
     74void           gtr_core_close( TrCore* );
    7975
    8076/* Return the model used without incrementing the reference count */
    81 GtkTreeModel * tr_core_model( TrCore * self );
    82 
    83 void           tr_core_clear( TrCore * self );
    84 
    85 tr_session *   tr_core_session( TrCore * self );
    86 
    87 size_t         tr_core_get_active_torrent_count( TrCore * self );
    88 
    89 size_t         tr_core_get_torrent_count( TrCore * self );
     77GtkTreeModel * gtr_core_model( TrCore * self );
     78
     79void           gtr_core_clear( TrCore * self );
     80
     81tr_session *   gtr_core_session( TrCore * self );
     82
     83size_t         gtr_core_get_active_torrent_count( TrCore * self );
     84
     85size_t         gtr_core_get_torrent_count( TrCore * self );
     86
     87tr_torrent *   gtr_core_find_torrent( TrCore * core, int id );
    9088
    9189/******
     
    9795 * May trigger one or more "error" signals with TR_CORE_ERR_ADD_TORRENT
    9896 */
    99 void tr_core_load( TrCore * self, gboolean forcepaused );
     97void gtr_core_load( TrCore * self, gboolean forcepaused );
    10098
    10199/**
     
    106104 * May trigger one or more "error" signals with TR_CORE_ERR_ADD_TORRENT
    107105 */
    108 void tr_core_add_list( TrCore *    self,
    109                        GSList *    torrentFiles,
    110                        gboolean    doStart,
    111                        gboolean    doPrompt,
    112                        gboolean    doNotify );
    113 
    114 void tr_core_add_list_defaults( TrCore    * core,
    115                                 GSList    * torrentFiles,
    116                                 gboolean    doNotify );
    117 
     106void gtr_core_add_list( TrCore *    self,
     107                        GSList *    torrentFiles,
     108                        gboolean    doStart,
     109                        gboolean    doPrompt,
     110                        gboolean    doNotify );
     111
     112void gtr_core_add_list_defaults( TrCore    * core,
     113                                 GSList    * torrentFiles,
     114                                 gboolean    doNotify );
    118115
    119116/** @brief Add a torrent. */
    120 gboolean tr_core_add_metainfo( TrCore      * core,
    121                                const char  * base64_metainfo,
    122                                gboolean    * setme_success,
    123                                GError     ** err );
     117gboolean gtr_core_add_metainfo( TrCore      * core,
     118                                const char  * base64_metainfo,
     119                                gboolean    * setme_success,
     120                                GError     ** err );
    124121
    125122/** @brief Add a torrent from a URL */
    126 void tr_core_add_from_url( TrCore * core, const char * url );
     123void gtr_core_add_from_url( TrCore * core, const char * url );
    127124
    128125/** @brief Add a torrent.
    129126    @param ctor this function assumes ownership of the ctor */
    130 void tr_core_add_ctor( TrCore  * core,
    131                        tr_ctor * ctor );
    132 
     127void gtr_core_add_ctor( TrCore * core, tr_ctor * ctor );
    133128
    134129/** Add a torrent. */
    135 void tr_core_add_torrent( TrCore*, TrTorrent*, gboolean doNotify );
     130void gtr_core_add_torrent( TrCore*, tr_torrent*, gboolean doNotify );
    136131
    137132/** Present the main window */
    138 gboolean tr_core_present_window( TrCore*, gboolean * setme_success, GError ** err );
    139 
     133gboolean gtr_core_present_window( TrCore*, gboolean * setme_success, GError ** err );
    140134
    141135/**
     
    143137 * This should be called after one or more tr_core_add*() calls.
    144138 */
    145 void     tr_core_torrents_added( TrCore * self );
     139void gtr_core_torrents_added( TrCore * self );
    146140
    147141/******
     
    150144
    151145/* remove a torrent */
    152 void  tr_core_remove_torrent( TrCore * self, TrTorrent * gtor, gboolean deleteFiles );
    153 void  tr_core_remove_torrent_from_id( TrCore * self, int id, gboolean deleteFiles );
     146void gtr_core_remove_torrent( TrCore * self, int id, gboolean delete_files );
    154147
    155148/* update the model with current torrent status */
    156 void  tr_core_update( TrCore * self );
     149void gtr_core_update( TrCore * self );
    157150
    158151/**
     
    160153**/
    161154
    162 void tr_core_set_pref     ( TrCore * self, const char * key, const char * val );
    163 void tr_core_set_pref_bool( TrCore * self, const char * key, gboolean val );
    164 void tr_core_set_pref_int ( TrCore * self, const char * key, int val );
    165 void tr_core_set_pref_double( TrCore * self, const char * key, double val );
     155void gtr_core_set_pref       ( TrCore * self, const char * key, const char * val );
     156void gtr_core_set_pref_bool  ( TrCore * self, const char * key, gboolean val );
     157void gtr_core_set_pref_int  ( TrCore * self, const char * key, int val );
     158void gtr_core_set_pref_double( TrCore * self, const char * key, double val );
    166159
    167160/**
     
    169162**/
    170163
    171 void tr_core_torrent_changed( TrCore * core, int id );
    172 
    173 void tr_core_port_test( TrCore * core );
    174 
    175 void tr_core_blocklist_update( TrCore * core );
    176 
    177 void tr_core_exec( TrCore * core, const tr_benc * benc );
    178 
    179 void tr_core_exec_json( TrCore * core, const char * json );
     164void gtr_core_port_test( TrCore * core );
     165
     166void gtr_core_blocklist_update( TrCore * core );
     167
     168void gtr_core_exec( TrCore * core, const tr_benc * benc );
     169
     170void gtr_core_exec_json( TrCore * core, const char * json );
     171
     172void gtr_core_open_folder( TrCore * core, int torrent_id );
    180173
    181174
     
    191184    MC_NAME_COLLATED,
    192185    MC_TORRENT,
    193     MC_TORRENT_RAW,
     186    MC_TORRENT_ID,
    194187    MC_SPEED_UP,
    195188    MC_SPEED_DOWN,
     
    209202    MC_ACTIVE_PEER_COUNT,
    210203
    211 
    212204    MC_ROW_COUNT
    213205};
  • trunk/gtk/tr-icon.c

    r11709 r12068  
    6666    const char * idle = _( "Idle" );
    6767    GtkStatusIcon * icon = GTK_STATUS_ICON( vicon );
    68     tr_session * session = tr_core_session( g_object_get_data( G_OBJECT( icon ), "tr-core" ) );
     68    tr_session * session = gtr_core_session( g_object_get_data( G_OBJECT( icon ), "tr-core" ) );
    6969
    7070    /* up */
  • trunk/gtk/tr-prefs.c

    r11979 r12068  
    5656    const gboolean flag = gtk_toggle_button_get_active( w );
    5757
    58     tr_core_set_pref_bool( TR_CORE( core ), key, flag );
     58    gtr_core_set_pref_bool( TR_CORE( core ), key, flag );
    5959}
    6060
     
    108108        {
    109109            const double value = gtk_spin_button_get_value( GTK_SPIN_BUTTON( spin ) );
    110             tr_core_set_pref_double( TR_CORE( data->core ), key, value );
     110            gtr_core_set_pref_double( TR_CORE( data->core ), key, value );
    111111        }
    112112        else
    113113        {
    114114            const int value = gtk_spin_button_get_value_as_int( GTK_SPIN_BUTTON( spin ) );
    115             tr_core_set_pref_int( TR_CORE( data->core ), key, value );
     115            gtr_core_set_pref_int( TR_CORE( data->core ), key, value );
    116116        }
    117117
     
    194194    const char * value = gtk_entry_get_text( w );
    195195
    196     tr_core_set_pref( TR_CORE( core ), key, value );
     196    gtr_core_set_pref( TR_CORE( core ), key, value );
    197197}
    198198
     
    217217    const char * key = g_object_get_data( G_OBJECT( w ), PREF_KEY );
    218218    char * value = gtk_file_chooser_get_filename( GTK_FILE_CHOOSER( w ) );
    219     tr_core_set_pref( TR_CORE( core ), key, value );
     219    gtr_core_set_pref( TR_CORE( core ), key, value );
    220220    g_free( value );
    221221}
     
    393393    char buf1[512];
    394394    char buf2[512];
    395     const int n = tr_blocklistGetRuleCount( tr_core_session( core ) );
     395    const int n = tr_blocklistGetRuleCount( gtr_core_session( core ) );
    396396    g_snprintf( buf1, sizeof( buf1 ),
    397397                gtr_ngettext( "Blocklist contains %'d rule",
     
    427427{
    428428    const tr_bool success = n >= 0;
    429     const int count = n >=0 ? n : tr_blocklistGetRuleCount( tr_core_session( core ) );
     429    const int count = n >=0 ? n : tr_blocklistGetRuleCount( gtr_core_session( core ) );
    430430    const char * s = gtr_ngettext( "Blocklist has %'d rule.", "Blocklist has %'d rules.", count );
    431431    struct blocklist_data * data = gdata;
     
    453453    g_signal_connect( d, "response", G_CALLBACK(onBlocklistUpdateResponse), data );
    454454    gtk_widget_show( d );
    455     tr_core_blocklist_update( data->core );
     455    gtr_core_blocklist_update( data->core );
    456456    data->updateBlocklistTag = g_signal_connect( data->core, "blocklist-updated", G_CALLBACK( onBlocklistUpdated ), data );
    457457}
     
    471471    const int val = gtr_combo_box_get_active_enum( combo_box );
    472472    const char * key = g_object_get_data( G_OBJECT( combo_box ), PREF_KEY );
    473     tr_core_set_pref_int( TR_CORE( core ), key, val );
     473    gtr_core_set_pref_int( TR_CORE( core ), key, val );
    474474}
    475475
     
    520520    gtk_box_pack_start( GTK_BOX( h ), w, TRUE, TRUE, 0 );
    521521    b = data->updateBlocklistButton = gtk_button_new_with_mnemonic( _( "_Update" ) );
    522     g_object_set_data( G_OBJECT( b ), "session", tr_core_session( TR_CORE( core ) ) );
     522    g_object_set_data( G_OBJECT( b ), "session", gtr_core_session( TR_CORE( core ) ) );
    523523    g_signal_connect( b, "clicked", G_CALLBACK( onBlocklistUpdate ), data );
    524524    g_signal_connect( data->check, "toggled", G_CALLBACK( target_cb ), b ); target_cb( data->check, b );
     
    633633    g_string_truncate( gstr, gstr->len - 1 ); /* remove the trailing comma */
    634634
    635     tr_core_set_pref( page->core, TR_PREFS_KEY_RPC_WHITELIST, gstr->str );
     635    gtr_core_set_pref( page->core, TR_PREFS_KEY_RPC_WHITELIST, gstr->str );
    636636
    637637    g_string_free( gstr, TRUE );
     
    934934        gtk_tree_model_get( gtk_combo_box_get_model(
    935935                                w ), &iter, 0, &val, -1 );
    936         tr_core_set_pref_int( TR_CORE( core ), key, val );
     936        gtr_core_set_pref_int( TR_CORE( core ), key, val );
    937937    }
    938938}
     
    11551155    if( !data->portTag )
    11561156        data->portTag = g_signal_connect( data->core, "port-tested", G_CALLBACK(onPortTested), data );
    1157     tr_core_port_test( data->core );
     1157    gtr_core_port_test( data->core );
    11581158}
    11591159
  • trunk/gtk/tr-prefs.h

    r11709 r12068  
    3333#define PREF_KEY_SHOW_MORE_PEER_INFO               "show-extra-peer-details"
    3434#define PREF_KEY_SHOW_BACKUP_TRACKERS              "show-backup-trackers"
    35 #define PREF_KEY_ASKQUIT                           "prompt-before-exit"
    3635#define PREF_KEY_SORT_MODE                         "sort-mode"
    3736#define PREF_KEY_SORT_REVERSED                     "sort-reversed"
  • trunk/gtk/tr-window.c

    r11741 r12068  
    3737#include "torrent-cell-renderer.h"
    3838#include "tr-prefs.h"
    39 #include "tr-torrent.h"
    4039#include "tr-window.h"
    4140#include "util.h"
     
    135134    p->renderer = r = torrent_cell_renderer_new( );
    136135    gtk_tree_view_column_pack_start( col, r, FALSE );
    137     gtk_tree_view_column_add_attribute( col, r, "torrent", MC_TORRENT_RAW );
     136    gtk_tree_view_column_add_attribute( col, r, "torrent", MC_TORRENT );
    138137    gtk_tree_view_column_add_attribute( col, r, "piece-upload-speed", MC_SPEED_UP );
    139138    gtk_tree_view_column_add_attribute( col, r, "piece-download-speed", MC_SPEED_DOWN );
     
    246245        const char *  val = g_object_get_data( G_OBJECT(
    247246                                                   menu_item ), STATS_MODE );
    248         tr_core_set_pref( p->core, PREF_KEY_STATUSBAR_STATS, val );
     247        gtr_core_set_pref( p->core, PREF_KEY_STATUSBAR_STATS, val );
    249248    }
    250249}
     
    280279    PrivateData * p = vprivate;
    281280    const gboolean b = gtk_toggle_button_get_active( button );
    282     tr_core_set_pref_bool( p->core, TR_PREFS_KEY_ALT_SPEED_ENABLED,  b );
     281    gtr_core_set_pref_bool( p->core, TR_PREFS_KEY_ALT_SPEED_ENABLED,  b );
    283282}
    284283
     
    299298    time_t *        maxTime = gmaxTime;
    300299
    301     gtk_tree_model_get( model, iter, MC_TORRENT_RAW, &tor, -1 );
     300    gtk_tree_model_get( model, iter, MC_TORRENT, &tor, -1 );
    302301    torStat = tr_torrentStatCached( tor );
    303302    *maxTime = MAX( *maxTime, torStat->manualAnnounceTime );
     
    343342{
    344343    PrivateData * p = vp;
    345     gboolean b = tr_sessionUsesAltSpeed( tr_core_session( p->core ) );
    346     tr_core_set_pref_bool( p->core, TR_PREFS_KEY_ALT_SPEED_ENABLED, b );
     344    gboolean b = tr_sessionUsesAltSpeed( gtr_core_session( p->core ) );
     345    gtr_core_set_pref_bool( p->core, TR_PREFS_KEY_ALT_SPEED_ENABLED, b );
    347346
    348347    return FALSE;
     
    374373
    375374    if( gtk_check_menu_item_get_active( check ) )
    376         tr_core_set_pref_bool( p->core, key, isEnabled );
     375        gtr_core_set_pref_bool( p->core, key, isEnabled );
    377376}
    378377
     
    387386
    388387    key = dir==TR_UP ? TR_PREFS_KEY_USPEED_KBps : TR_PREFS_KEY_DSPEED_KBps;
    389     tr_core_set_pref_int( p->core, key, KBps );
     388    gtr_core_set_pref_int( p->core, key, KBps );
    390389
    391390    key = dir==TR_UP ? TR_PREFS_KEY_USPEED_ENABLED : TR_PREFS_KEY_DSPEED_ENABLED;
    392     tr_core_set_pref_bool( p->core, key, TRUE );
     391    gtr_core_set_pref_bool( p->core, key, TRUE );
    393392}
    394393
     
    448447    {
    449448        gboolean f = g_object_get_data( G_OBJECT( check ), ENABLED_KEY ) != 0;
    450         tr_core_set_pref_bool( p->core, TR_PREFS_KEY_RATIO_ENABLED, f );
     449        gtr_core_set_pref_bool( p->core, TR_PREFS_KEY_RATIO_ENABLED, f );
    451450    }
    452451}
     
    457456    int i = GPOINTER_TO_INT( g_object_get_data( G_OBJECT( check ), RATIO_KEY ) );
    458457    const double ratio = stockRatios[i];
    459     tr_core_set_pref_double( p->core, TR_PREFS_KEY_RATIO, ratio );
    460     tr_core_set_pref_bool  ( p->core, TR_PREFS_KEY_RATIO_ENABLED, TRUE );
     458    gtr_core_set_pref_double( p->core, TR_PREFS_KEY_RATIO, ratio );
     459    gtr_core_set_pref_bool  ( p->core, TR_PREFS_KEY_RATIO_ENABLED, TRUE );
    461460}
    462461
     
    612611
    613612    /* filter */
    614     h = filter = p->filter = gtr_filter_bar_new( tr_core_session( core ),
    615                                                  tr_core_model( core ),
     613    h = filter = p->filter = gtr_filter_bar_new( gtr_core_session( core ),
     614                                                 gtr_core_model( core ),
    616615                                                 &p->filter_model );
    617616    gtk_container_set_border_width( GTK_CONTAINER( h ), GUI_PAD_SMALL );
     
    738737                                           G_CALLBACK( prefsChanged ), self );
    739738
    740     tr_sessionSetAltSpeedFunc( tr_core_session( core ), onAltSpeedToggled, p );
     739    tr_sessionSetAltSpeedFunc( gtr_core_session( core ), onAltSpeedToggled, p );
    741740
    742741    return self;
     
    749748    {
    750749        char      buf[512];
    751         const int torrentCount = gtk_tree_model_iter_n_children( tr_core_model( p->core ), NULL );
     750        const int torrentCount = gtk_tree_model_iter_n_children( gtr_core_model( p->core ), NULL );
    752751        const int visibleCount = gtk_tree_model_iter_n_children( p->filter_model, NULL );
    753752
     
    774773    char                    up[32], down[32], ratio[32], buf[512];
    775774    struct tr_session_stats stats;
    776     tr_session *            session = tr_core_session( p->core );
     775    tr_session *            session = gtr_core_session( p->core );
    777776
    778777    /* update the stats */
     
    818817updateSpeeds( PrivateData * p )
    819818{
    820     tr_session * session = tr_core_session( p->core );
     819    tr_session * session = gtr_core_session( p->core );
    821820
    822821    if( session != NULL )
     
    825824        double up=0, down=0;
    826825        GtkTreeIter iter;
    827         GtkTreeModel * model = tr_core_model( p->core );
     826        GtkTreeModel * model = gtr_core_model( p->core );
    828827
    829828        if( gtk_tree_model_get_iter_first( model, &iter ) ) do
     
    851850    PrivateData * p = get_private_data( self );
    852851
    853     if( p && p->core && tr_core_session( p->core ) )
     852    if( p && p->core && gtr_core_session( p->core ) )
    854853    {
    855854        updateSpeeds( p );
  • trunk/gtk/util.c

    r11801 r12068  
    184184    g_snprintf( s, sizeof( s ), gtr_ngettext( "%'d second", "%'d seconds", seconds ), seconds );
    185185
    186     if( days )
    187     {
    188         if( days >= 4 || !hours )
    189         {
    190             g_strlcpy( buf, d, buflen );
    191         }
    192         else
    193         {
    194             g_snprintf( buf, buflen, "%s, %s", d, h );
    195         }
    196     }
     186    if( days >= 4 || !hours )
     187        g_strlcpy( buf, d, buflen );
     188    else if( days )
     189        g_snprintf( buf, buflen, "%s, %s", d, h );
     190    else if( hours >= 4 || !minutes )
     191        g_strlcpy( buf, h, buflen );
    197192    else if( hours )
    198     {
    199         if( hours >= 4 || !minutes )
    200         {
    201             g_strlcpy( buf, h, buflen );
    202         }
    203         else
    204         {
    205             g_snprintf( buf, buflen, "%s, %s", h, m );
    206         }
    207     }
     193        g_snprintf( buf, buflen, "%s, %s", h, m );
     194    else if( minutes >= 4 || !seconds )
     195        g_strlcpy( buf, m, buflen );
    208196    else if( minutes )
    209     {
    210         if( minutes >= 4 || !seconds )
    211         {
    212             g_strlcpy( buf, m, buflen );
    213         }
    214         else
    215         {
    216             g_snprintf( buf, buflen, "%s, %s", m, s );
    217         }
    218     }
     197        g_snprintf( buf, buflen, "%s, %s", m, s );
    219198    else
    220     {
    221199        g_strlcpy( buf, s, buflen );
    222     }
    223200
    224201    return buf;
     
    228205gtr_localtime( time_t time )
    229206{
     207    char buf[256], *eoln;
    230208    const struct tm tm = *localtime( &time );
    231     char            buf[256], *eoln;
    232209
    233210    g_strlcpy( buf, asctime( &tm ), sizeof( buf ) );
     
    252229gtr_get_host_from_url( const char * url )
    253230{
     231    char * name;
    254232    char * h = NULL;
    255     char * name;
    256233
    257234    tr_urlParse( url, -1, NULL, &h, NULL, NULL );
Note: See TracChangeset for help on using the changeset viewer.