Changeset 5276


Ignore:
Timestamp:
Mar 18, 2008, 1:22:11 AM (14 years ago)
Author:
charles
Message:

(gtk) try to iron out the remaining "add torrent" issues reported by wereHamster and Lacrocivous

Location:
trunk/gtk
Files:
13 edited

Legend:

Unmodified
Added
Removed
  • trunk/gtk/dialogs.c

    r5230 r5276  
    3333#include "tr-core.h"
    3434#include "tr-prefs.h"
    35 
    36 struct dirdata
    37 {
    38     GtkWidget  * widget;
    39     TrCore     * core;
    40     GList      * files;
    41     tr_ctor    * ctor;
    42 };
    43 
    44 static void
    45 promptdirnocore( gpointer gdata, GObject * core UNUSED )
    46 {
    47     struct dirdata * stuff = gdata;
    48 
    49     /* prevent the response callback from trying to remove the weak
    50        reference which no longer exists */
    51     stuff->core = NULL;
    52 
    53     gtk_dialog_response( GTK_DIALOG( stuff->widget ), GTK_RESPONSE_NONE );
    54 }
    55 
    56 static void
    57 promptresp( GtkWidget * widget, gint resp, gpointer data )
    58 {
    59     struct dirdata * stuff;
    60 
    61     stuff = data;
    62 
    63     if( GTK_RESPONSE_ACCEPT == resp )
    64     {
    65         char * dir;
    66         GList * l;
    67 
    68         /* update the destination */
    69         dir = gtk_file_chooser_get_filename( GTK_FILE_CHOOSER( widget ) );
    70         tr_ctorSetDestination( stuff->ctor, TR_FORCE, dir );
    71         g_free( dir );
    72 
    73         /* if there's metainfo in the ctor already, use it */
    74         if( !tr_ctorGetMetainfo( stuff->ctor, NULL ) )
    75             tr_core_add_ctor( stuff->core, stuff->ctor );
    76 
    77         /* if there's a list of files, use them too */
    78         for( l=stuff->files; l!=NULL; l=l->next )
    79             if( !tr_ctorSetMetainfoFromFile( stuff->ctor, l->data ) )
    80                 tr_core_add_ctor( stuff->core, stuff->ctor );
    81     }
    82 
    83     if( stuff->core )
    84         g_object_weak_unref( G_OBJECT( stuff->core ), promptdirnocore, stuff );
    85 
    86     gtk_widget_destroy( widget );
    87     freestrlist( stuff->files );
    88     tr_ctorFree( stuff->ctor );
    89     g_free( stuff );
    90 }
    91 
    92 void
    93 fmtpeercount( GtkLabel * label, int count )
    94 {
    95     char str[16];
    96 
    97     if( 0 > count )
    98     {
    99         gtk_label_set_text( label, "?" );
    100     }
    101     else
    102     {
    103         g_snprintf( str, sizeof str, "%i", count );
    104         gtk_label_set_text( label, str );
    105     }
    106 }
    107 
    108 static void
    109 deleteToggled( GtkToggleButton * tb, gpointer ctor )
    110 {
    111     tr_ctorSetDeleteSource( ctor, gtk_toggle_button_get_active( tb ) );
    112 }
    113 
    114 static void
    115 startToggled( GtkToggleButton * tb, gpointer ctor )
    116 {
    117     tr_ctorSetPaused( ctor, TR_FORCE, !gtk_toggle_button_get_active( tb ) );
    118 }
    119 
    120 GtkWidget*
    121 promptfordir( GtkWindow * parent, TrCore * core, GList * files, tr_ctor * ctor )
    122 {
    123     uint8_t          flag = 0;
    124     const char     * str;
    125     struct dirdata * stuff;
    126     GtkWidget      * wind;
    127     GtkWidget      * v;
    128     GtkWidget      * w;
    129 
    130     stuff = g_new0( struct dirdata, 1 );
    131     stuff->core   = core;
    132     stuff->ctor   = ctor;
    133     stuff->files  = dupstrlist( files );
    134 
    135     g_object_weak_ref( G_OBJECT( core ), promptdirnocore, stuff );
    136 
    137     wind =  gtk_file_chooser_dialog_new( _("Destination folder"), parent,
    138                                          GTK_FILE_CHOOSER_ACTION_SELECT_FOLDER,
    139                                          GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
    140                                          GTK_STOCK_OPEN, GTK_RESPONSE_ACCEPT,
    141                                          NULL );
    142     gtk_dialog_set_alternative_button_order( GTK_DIALOG( wind ),
    143                                              GTK_RESPONSE_ACCEPT,
    144                                              GTK_RESPONSE_CANCEL,
    145                                              -1 );
    146     gtk_file_chooser_set_local_only( GTK_FILE_CHOOSER( wind ), TRUE );
    147     gtk_file_chooser_set_select_multiple( GTK_FILE_CHOOSER( wind ), FALSE );
    148     if( tr_ctorGetDestination( ctor, TR_FORCE, &str ) )
    149         g_assert_not_reached( );
    150     if( !gtk_file_chooser_set_filename( GTK_FILE_CHOOSER( wind ), str ) )
    151         g_warning( "couldn't set destination '%s'", str );
    152 
    153     v = gtk_vbox_new( FALSE, GUI_PAD );
    154 
    155         flag = 0;
    156         w = gtk_check_button_new_with_mnemonic( _( "_Trash original torrent files" ) );
    157         g_signal_connect( w, "toggled", G_CALLBACK( deleteToggled ), ctor );
    158         if( tr_ctorGetDeleteSource( ctor, &flag ) )
    159             g_assert_not_reached( );
    160         gtk_toggle_button_set_active( GTK_TOGGLE_BUTTON( w ), flag );
    161         gtk_box_pack_start( GTK_BOX( v ), w, FALSE, FALSE, 0 );
    162 
    163         flag = 1;
    164         w = gtk_check_button_new_with_mnemonic( _( "_Start when added" ) );
    165         g_signal_connect( w, "toggled", G_CALLBACK( startToggled ), ctor );
    166         if( tr_ctorGetPaused( ctor, TR_FORCE, &flag ) )
    167             g_assert_not_reached( );
    168         gtk_toggle_button_set_active( GTK_TOGGLE_BUTTON( w ), !flag );
    169         gtk_box_pack_start( GTK_BOX( v ), w, FALSE, FALSE, 0 );
    170 
    171     gtk_file_chooser_set_extra_widget( GTK_FILE_CHOOSER( wind ), v );
    172 
    173     stuff->widget = wind;
    174 
    175     g_signal_connect( G_OBJECT( wind ), "response",
    176                       G_CALLBACK( promptresp ), stuff );
    177 
    178     gtk_widget_show_all( wind );
    179     return wind;
    180 }
    18135
    18236/***
     
    288142{
    289143    gboolean delete_files;
    290     GList * torrents;
     144    GSList * torrents;
    291145    TrCore * core;
    292146};
     
    295149removeTorrents( struct DeleteData * data )
    296150{
    297     GList * l;
     151    GSList * l;
    298152    for( l=data->torrents; l!=NULL; l=l->next )
    299153        tr_core_remove_torrent( data->core, l->data, data->delete_files );
    300     g_list_free( data->torrents );
     154    g_slist_free( data->torrents );
    301155}
    302156
     
    310164        removeTorrents( data );
    311165    else
    312         g_list_foreach( data->torrents, (GFunc)g_object_unref, NULL );
     166        g_slist_foreach( data->torrents, (GFunc)g_object_unref, NULL );
    313167
    314168    gtk_widget_destroy( GTK_WIDGET( dialog ) );
     
    328182confirmRemove( GtkWindow * parent,
    329183               TrCore    * core,
    330                GList     * torrents,
     184               GSList    * torrents,
    331185               gboolean    delete_files )
    332186{
     
    334188    struct DeleteData * dd;
    335189    int busyCount;
    336     const int count = g_list_length( torrents );
     190    const int count = g_slist_length( torrents );
    337191    const char * primary_text;
    338192    const char * secondary_text;
     
    347201
    348202    busyCount = 0;
    349     g_list_foreach( torrents, countBusyTorrents, &busyCount );
     203    g_slist_foreach( torrents, countBusyTorrents, &busyCount );
    350204
    351205    if( !busyCount && !delete_files ) /* don't prompt boring torrents */
  • trunk/gtk/dialogs.h

    r5216 r5276  
    3030#include "util.h"
    3131
    32 /* prompt for a download folder for torrents, then add them */
    33 GtkWidget* promptfordir( GtkWindow  * parent,
    34                          TrCore     * core,
    35                          GList      * filenames,
    36                          tr_ctor    * ctor );
    37 
    3832/* prompt if the user wants to quit, calls func with cbdata if they do */
    3933void askquit( TrCore*, GtkWindow* parent, callbackfunc_t func, void* cbdata );
     
    4135void confirmRemove( GtkWindow * parent,
    4236                    TrCore    * core,
    43                     GList     * gtorrents,
     37                    GSList    * gtorrents,
    4438                    gboolean    doDelete );
    4539
  • trunk/gtk/ipc.c

    r5230 r5276  
    7373    GMainLoop  * loop;
    7474    enum ipc_msg msg;
    75     GList      * files;
     75    GSList     * files;
    7676    gboolean   * succeeded;
    7777    unsigned int msgid;
     
    163163{
    164164    struct constate_client * cli = &con->u.client;
    165     GList                  * ii;
     165    GSList                 * ii;
    166166    uint8_t                * buf;
    167167    size_t                   size;
     
    174174            val = ipc_initval( con->ipc, cli->msg, -1, &packet, TYPE_LIST );
    175175            if( NULL == val ||
    176                 tr_bencListReserve( val, g_list_length( cli->files ) ) )
     176                tr_bencListReserve( val, g_slist_length( cli->files ) ) )
    177177            {
    178178                perror( "malloc" );
     
    187187            saved = errno;
    188188            tr_bencFree( &packet );
    189             g_list_free( cli->files );
     189            g_slist_free( cli->files );
    190190            cli->files = NULL;
    191191            break;
     
    299299
    300300static gboolean
    301 blocking_client( enum ipc_msg msgid, GList * files )
     301blocking_client( enum ipc_msg msgid, GSList * files )
    302302{
    303303
     
    348348
    349349gboolean
    350 ipc_sendfiles_blocking( GList * files )
     350ipc_sendfiles_blocking( GSList * files )
    351351{
    352352    return blocking_client( IPC_MSG_ADDMANYFILES, files );
     
    499499    tr_benc           * path;
    500500    int                    ii;
    501     tr_ctor              * ctor;
    502     GList                * list = NULL;
     501    GSList               * list = NULL;
    503502
    504503    if( NULL == val || TYPE_LIST != val->type )
     
    507506        return;
    508507    }
    509 
    510     ctor = tr_ctorNew( srv->core );
    511508
    512509    for( ii = 0; ii < val->val.l.count; ii++ )
     
    517514            g_utf8_validate( path->val.s.s, path->val.s.i, NULL ) )
    518515        {
    519             list = g_list_append( list, g_strndup( path->val.s.s, path->val.s.i ) );
     516            list = g_slist_prepend( list, g_strndup( path->val.s.s, path->val.s.i ) );
    520517        }
    521518    }
    522519
    523520    if( list ) {
    524         tr_core_add_list( srv->core, list, ctor );
     521        list = g_slist_reverse( list );
     522        tr_core_add_list( srv->core, list, FALSE );
    525523        tr_core_torrents_added( TR_CORE( srv->core ) );
    526524    }
  • trunk/gtk/ipc.h

    r5122 r5276  
    3434
    3535gboolean
    36 ipc_sendfiles_blocking( GList * files );
     36ipc_sendfiles_blocking( GSList * files );
    3737
    3838gboolean
  • trunk/gtk/main.c

    r5268 r5276  
    113113    GtkWidget    * msgwin;
    114114    GtkWidget    * prefs;
    115     GList        * errqueue;
     115    GSList       * errqueue;
    116116    GHashTable   * tor2details;
    117117    GHashTable   * details2tor;
     
    123123
    124124static gboolean
    125 sendremote( GList * files, gboolean sendquit );
    126 static void
    127 appsetup( TrWindow * wind, GList * args,
     125sendremote( GSList * files, gboolean sendquit );
     126static void
     127appsetup( TrWindow * wind, GSList * args,
    128128          struct cbdata *,
    129129          gboolean paused, gboolean minimized );
     
    142142         gpointer gdata );
    143143static void
    144 coreprompt( TrCore *, GList *, gpointer, gpointer );
     144onAddTorrent( TrCore *, tr_ctor *, gpointer );
    145145static void
    146146prefschanged( TrCore * core, const char * key, gpointer data );
     
    257257    char * err;
    258258    struct cbdata * cbdata;
    259     GList * argfiles;
     259    GSList * argfiles;
    260260    GError * gerr;
    261261    gboolean didinit = FALSE;
     
    336336
    337337static gboolean
    338 sendremote( GList * files, gboolean sendquit )
     338sendremote( GSList * files, gboolean sendquit )
    339339{
    340340    const gboolean didlock = cf_lock( NULL );
     
    352352
    353353static void
    354 appsetup( TrWindow * wind, GList * args,
     354appsetup( TrWindow * wind, GSList * torrentFiles,
    355355          struct cbdata * cbdata,
    356356          gboolean forcepause, gboolean minimized )
     
    370370    /* set up core handlers */
    371371    g_signal_connect( cbdata->core, "error", G_CALLBACK( coreerr ), cbdata );
    372     g_signal_connect( cbdata->core, "destination-prompt",
    373                       G_CALLBACK( coreprompt ), cbdata );
     372    g_signal_connect( cbdata->core, "add-torrent-prompt",
     373                      G_CALLBACK( onAddTorrent ), cbdata );
    374374    g_signal_connect_swapped( cbdata->core, "quit",
    375375                              G_CALLBACK( wannaquit ), cbdata );
     
    379379    /* add torrents from command-line and saved state */
    380380    tr_core_load( cbdata->core, forcepause );
    381 
    382     if( NULL != args )
    383     {
    384         tr_ctor * ctor = tr_ctorNew( tr_core_handle( cbdata->core ) );
    385         if( forcepause )
    386             tr_ctorSetPaused( ctor, TR_FORCE, TRUE );
    387         tr_core_add_list( cbdata->core, args, ctor );
    388     }
     381    tr_core_add_list( cbdata->core, torrentFiles, forcepause );
     382    torrentFiles = NULL;
    389383    tr_core_torrents_added( cbdata->core );
    390384
     
    546540        g_object_unref( cbdata->icon );
    547541    if( cbdata->errqueue ) {
    548         g_list_foreach( cbdata->errqueue, (GFunc)g_free, NULL );
    549         g_list_free( cbdata->errqueue );
     542        g_slist_foreach( cbdata->errqueue, (GFunc)g_free, NULL );
     543        g_slist_free( cbdata->errqueue );
    550544    }
    551545
     
    638632{
    639633    struct cbdata * data = gdata;
    640     GList * paths = NULL;
    641     GList * freeme = NULL;
     634    GSList * paths = NULL;
     635    GSList * freeme = NULL;
    642636
    643637#if 0
     
    673667            /* decode the filename */
    674668            filename = decode_uri( files[i] );
    675             freeme = g_list_prepend( freeme, filename );
     669            freeme = g_slist_prepend( freeme, filename );
    676670            if( !g_utf8_validate( filename, -1, NULL ) )
    677671                continue;
     
    694688            /* finally, add it to the list of torrents to try adding */
    695689            if( g_file_test( filename, G_FILE_TEST_EXISTS ) )
    696                 paths = g_list_prepend( paths, filename );
     690                paths = g_slist_prepend( paths, g_strdup( filename ) );
    697691        }
    698692
    699693        /* try to add any torrents we found */
    700         if( paths != NULL )
     694        if( paths )
    701695        {
    702             tr_ctor * ctor = tr_ctorNew( tr_core_handle( data->core ) );
    703             paths = g_list_reverse( paths );
    704             tr_core_add_list( data->core, paths, ctor );
     696            paths = g_slist_reverse( paths );
     697            tr_core_add_list( data->core, paths, FALSE );
    705698            tr_core_torrents_added( data->core );
    706             g_list_free( paths );
    707699        }
    708700
     
    739731    {
    740732        case TR_CORE_ERR_ADD_TORRENT:
    741             cbdata->errqueue = g_list_append( cbdata->errqueue,
    742                                               g_strdup( msg ) );
     733            cbdata->errqueue = g_slist_append( cbdata->errqueue,
     734                                               g_strdup( msg ) );
    743735            return;
    744736        case TR_CORE_ERR_NO_MORE_TORRENTS:
    745             if( NULL != cbdata->errqueue )
     737            if( cbdata->errqueue )
    746738            {
    747739                joined = joinstrlist( cbdata->errqueue, "\n" );
     
    749741                        ngettext( "Failed to load torrent file: %s",
    750742                                  "Failed to load torrent files: %s",
    751                                   g_list_length( cbdata->errqueue ) ),
     743                                  g_slist_length( cbdata->errqueue ) ),
    752744                        joined );
    753                 g_list_foreach( cbdata->errqueue, (GFunc) g_free, NULL );
    754                 g_list_free( cbdata->errqueue );
     745                g_slist_foreach( cbdata->errqueue, (GFunc) g_free, NULL );
     746                g_slist_free( cbdata->errqueue );
    755747                cbdata->errqueue = NULL;
    756748                g_free( joined );
     
    777769
    778770static void
    779 coreprompt( TrCore                 * core,
    780             GList                  * paths,
    781             gpointer                 ctor,
    782             gpointer                 gdata )
     771onAddTorrent( TrCore * core, tr_ctor * ctor, gpointer gdata )
    783772{
    784773    struct cbdata * cbdata = gdata;
    785     const int len = g_list_length( paths );
    786     GtkWidget * w;
    787 
    788     if( len > 1 )
    789         w = promptfordir( cbdata->wind, core, paths, ctor );
    790     else {
    791         if( len == 1 )
    792             tr_ctorSetMetainfoFromFile( ctor, paths->data );
    793         w = makeaddwind( cbdata->wind, core, ctor );
    794     }
    795 
     774    GtkWidget * w = openSingleTorrentDialog( cbdata->wind, core, ctor );
    796775#if GTK_CHECK_VERSION(2,8,0)
    797     if( w )
    798     if( cbdata->wind )
    799         gtk_window_set_urgency_hint( GTK_WINDOW( w ), TRUE );
    800     g_signal_connect( w, "focus-in-event",
    801                       G_CALLBACK(on_main_window_focus_in),  cbdata );
     776    g_signal_connect( w, "focus-in-event", G_CALLBACK(on_main_window_focus_in),  cbdata );
     777    gtk_window_set_urgency_hint( cbdata->wind, TRUE );
    802778#endif
    803779}
     
    1000976                            gpointer       gdata )
    1001977{
    1002     GList ** data = ( GList** ) gdata;
     978    GSList ** data = ( GSList** ) gdata;
    1003979    TrTorrent * tor = NULL;
    1004980    gtk_tree_model_get( model, iter, MC_TORRENT, &tor, -1 );
    1005     *data = g_list_append( *data, tor );
     981    *data = g_slist_prepend( *data, tor );
    1006982}
    1007983
     
    1009985removeSelected( struct cbdata * data, gboolean delete_files )
    1010986{
    1011     GList * l = NULL;
     987    GSList * l = NULL;
    1012988    GtkTreeSelection * s = tr_window_get_selection( data->wind );
    1013989    gtk_tree_selection_selected_foreach( s, accumulateSelectedTorrents, &l );
    1014990    gtk_tree_selection_unselect_all( s );
    1015     if( l )
     991    if( l ) {
     992        l = g_slist_reverse( l );
    1016993        confirmRemove( data->wind, data->core, l, delete_files );
     994    }
    1017995}
    1018996
     
    10251003    if ( !strcmp (action_name, "open-torrent-menu") || !strcmp( action_name, "open-torrent-toolbar" ))
    10261004    {
    1027         tr_core_add_list( data->core, NULL,
    1028                           tr_ctorNew( tr_core_handle( data->core ) ) );
     1005        openDialog( data->wind, data->core );
    10291006    }
    10301007    else if (!strcmp (action_name, "show-stats"))
  • trunk/gtk/open-dialog.c

    r5230 r5276  
    127127
    128128GtkWidget*
    129 makeaddwind( GtkWindow  * parent,
    130              TrCore     * core,
    131              tr_ctor    * ctor )
     129openSingleTorrentDialog( GtkWindow  * parent,
     130                         TrCore     * core,
     131                         tr_ctor    * ctor )
    132132{
    133133    int row;
     
    241241    return d;
    242242}
     243
     244/****
     245*****
     246****/
     247
     248static void
     249onOpenDialogResponse( GtkDialog * dialog, int response, gpointer core )
     250{
     251    if( response == GTK_RESPONSE_ACCEPT )
     252    {
     253        GSList * l = gtk_file_chooser_get_filenames( GTK_FILE_CHOOSER( dialog ) );
     254        tr_core_add_list( core, l, FALSE );
     255    }
     256
     257    gtk_widget_destroy( GTK_WIDGET( dialog ) );
     258}
     259
     260GtkWidget*
     261openDialog( GtkWindow * parent,
     262            TrCore    * core )
     263{
     264    GtkWidget * w;
     265
     266    w = gtk_file_chooser_dialog_new( _( "Select Torrents" ), parent,
     267                                     GTK_FILE_CHOOSER_ACTION_OPEN,
     268                                     GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
     269                                     GTK_STOCK_OPEN, GTK_RESPONSE_ACCEPT,
     270                                     NULL );
     271    gtk_dialog_set_alternative_button_order( GTK_DIALOG( w ),
     272                                             GTK_RESPONSE_ACCEPT,
     273                                             GTK_RESPONSE_CANCEL,
     274                                             -1 );
     275    gtk_file_chooser_set_select_multiple( GTK_FILE_CHOOSER( w ), TRUE );
     276
     277    g_signal_connect( w, "response", G_CALLBACK(onOpenDialogResponse), core );
     278
     279    gtk_widget_show( w );
     280    return w;
     281}
  • trunk/gtk/open-dialog.h

    r5126 r5276  
    1717#include "tr-core.h"
    1818
    19 GtkWidget* makeaddwind( GtkWindow  * parent,
    20                         TrCore     * core,
    21                         tr_ctor    * ctor );
     19/* This dialog assumes ownership of the ctor */
     20GtkWidget* openSingleTorrentDialog( GtkWindow  * parent,
     21                                    TrCore     * core,
     22                                    tr_ctor    * ctor );
     23
     24GtkWidget* openDialog( GtkWindow * parent,
     25                       TrCore    * core );
    2226
    2327#endif /* TR_GTK_OPEN_DIALOG */
  • trunk/gtk/tr-core.c

    r5262 r5276  
    4646    gulong             monitor_tag;
    4747    char             * monitor_path;
    48     GList            * monitor_files;
     48    GSList           * monitor_files;
    4949    guint              monitor_idle_tag;
    5050#endif
     
    8484                        gpointer hint UNUSED, gpointer marshal )
    8585{
    86     typedef void (*TRMarshalPrompt)( gpointer, GList *, gpointer, gpointer );
     86    typedef void (*TRMarshalPrompt)( gpointer, tr_ctor *, gpointer );
    8787    TRMarshalPrompt        callback;
    8888    GCClosure            * cclosure = (GCClosure*) closure;
    89     GList                * paths;
    9089    gpointer               ctor;
    9190    gpointer               inst, gdata;
    9291
    93     g_return_if_fail( count == 3 );
     92    g_return_if_fail( count == 2 );
    9493
    9594    inst      = g_value_peek_pointer( vals );
    96     paths     = g_value_peek_pointer( vals + 1 );
    97     ctor      = g_value_peek_pointer( vals + 2 );
     95    ctor      = g_value_peek_pointer( vals + 1 );
    9896    gdata     = closure->data;
    9997
    10098    callback = (TRMarshalPrompt)( marshal ? marshal : cclosure->callback );
    101     callback( inst, paths, ctor, gdata );
     99    callback( inst, ctor, gdata );
    102100}
    103101
     
    142140                                       tr_core_marshal_err, G_TYPE_NONE,
    143141                                       2, G_TYPE_INT, G_TYPE_STRING );
    144     core_class->promptsig = g_signal_new( "destination-prompt",
     142    core_class->promptsig = g_signal_new( "add-torrent-prompt",
    145143                                          G_TYPE_FROM_CLASS( g_class ),
    146144                                          G_SIGNAL_RUN_LAST, 0, NULL, NULL,
    147145                                          tr_core_marshal_prompt, G_TYPE_NONE,
    148                                           2, G_TYPE_POINTER, G_TYPE_POINTER );
     146                                          1, G_TYPE_POINTER );
    149147    core_class->quitsig = g_signal_new( "quit", G_TYPE_FROM_CLASS( g_class ),
    150148                                        G_SIGNAL_RUN_LAST, 0, NULL, NULL,
     
    312310watchFolderIdle( gpointer gcore )
    313311{
    314     TrCore * core;
    315     tr_ctor * ctor;
    316 
    317     /* add these files */
    318     core = TR_CORE( gcore );
    319     ctor = tr_ctorNew( core->priv->handle );
    320     tr_core_add_list( core, core->priv->monitor_files, ctor );
     312    TrCore * core = TR_CORE( gcore );
     313    tr_core_add_list( core, core->priv->monitor_files, FALSE );
    321314
    322315    /* cleanup */
     
    335328        struct TrCorePrivate * p = core->priv;
    336329
    337         if( !g_list_find_custom( p->monitor_files, filename, (GCompareFunc)strcmp ) )
    338             p->monitor_files = g_list_append( p->monitor_files, g_strdup( filename ) );
     330        if( !g_slist_find_custom( p->monitor_files, filename, (GCompareFunc)strcmp ) )
     331            p->monitor_files = g_slist_append( p->monitor_files, g_strdup( filename ) );
    339332        if( !p->monitor_idle_tag )
    340333            p->monitor_idle_tag = g_timeout_add( 1000, watchFolderIdle, core );
     
    626619
    627620static void
    628 tr_core_errsig( TrCore * self, enum tr_core_err type, const char * msg )
    629 {
    630     TrCoreClass * class = g_type_class_peek( TR_CORE_TYPE );
    631     g_signal_emit( self, class->errsig, 0, type, msg );
     621tr_core_errsig( TrCore * core, enum tr_core_err type, const char * msg )
     622{
     623    g_signal_emit( core, TR_CORE_GET_CLASS(core)->errsig, 0, type, msg );
    632624}
    633625
     
    646638        g_free( errstr );
    647639    }
    648 }
    649 
    650 void
    651 tr_core_add_list( TrCore   * self,
    652                   GList    * paths,
    653                   tr_ctor  * ctor )
    654 {
    655     tr_core_apply_defaults( ctor );
    656 
    657     if( pref_flag_get( PREF_KEY_OPTIONS_PROMPT ) )
    658     {
    659         TrCoreClass * class = g_type_class_peek( TR_CORE_TYPE );
    660         g_signal_emit( self, class->promptsig, 0, paths, ctor );
    661     }
    662     else
    663     {
    664         for( ; paths; paths=paths->next )
    665             if( !tr_ctorSetMetainfoFromFile( ctor, paths->data ) )
    666                 tr_core_add_ctor( self, ctor );
    667         tr_ctorFree( ctor );
    668     }
     640
     641    /* cleanup */
     642    tr_ctorFree( ctor );
     643}
     644
     645void
     646tr_core_add_list( TrCore   * core,
     647                  GSList   * torrentFiles,
     648                  gboolean   forcePaused )
     649{
     650    if( torrentFiles && !isDisposed( core ) )
     651    {
     652        GSList * l;
     653        const gboolean doPrompt = pref_flag_get( PREF_KEY_OPTIONS_PROMPT );
     654
     655        for( l=torrentFiles; l!=NULL; l=l->next )
     656        {
     657            tr_ctor * ctor = tr_ctorNew( core->priv->handle );
     658            tr_core_apply_defaults( ctor );
     659            if( forcePaused )
     660                tr_ctorSetPaused( ctor, TR_FORCE, TRUE );
     661            if( tr_ctorSetMetainfoFromFile( ctor, l->data ) )
     662                tr_ctorFree( ctor );
     663            else if( doPrompt )
     664                g_signal_emit( core, TR_CORE_GET_CLASS(core)->promptsig, 0, ctor );
     665            else
     666                tr_core_add_ctor( core, ctor );
     667        }
     668    }
     669
     670    freestrlist( torrentFiles );
    669671}
    670672
     
    794796
    795797void
    796 tr_core_quit( TrCore * self )
    797 {
    798     TrCoreClass * class = g_type_class_peek( TR_CORE_TYPE );
    799     g_signal_emit( self, class->quitsig, 0 );
     798tr_core_quit( TrCore * core )
     799{
     800    g_signal_emit( core, TR_CORE_GET_CLASS(core)->quitsig, 0 );
    800801}
    801802
     
    805806
    806807static void
    807 commitPrefsChange( TrCore * self, const char * key )
    808 {
    809     TrCoreClass * class = g_type_class_peek( TR_CORE_TYPE );
     808commitPrefsChange( TrCore * core, const char * key )
     809{
    810810    pref_save( NULL );
    811     g_signal_emit( self, class->prefsig, 0, key );
     811    g_signal_emit( core, TR_CORE_GET_CLASS(core)->prefsig, 0, key );
    812812}
    813813
  • trunk/gtk/tr-core.h

    r5207 r5276  
    6666    int errsig;
    6767
    68     /* "destination-prompt" signal:
    69        void handler( TrCore *, GList *, gpointer ctor, gpointer userData ) */
     68    /* "add-torrent-prompt" signal:
     69       void handler( TrCore *, gpointer ctor, gpointer userData )
     70       The handler assumes ownership of ctor and must free when done */
    7071    int promptsig;
    7172
     
    111112/**
    112113 * Add a torrent.
     114 * This function assumes ownership of ctor
     115 *
    113116 * May trigger an "error" signal with TR_CORE_ERR_ADD_TORRENT
    114  * Caller must free the ctor.
    115117 */
    116118void tr_core_add_ctor( TrCore * self, tr_ctor * ctor );
     
    118120/**
    119121 * Add a list of torrents.
     122 * This function assumes ownership of torrentFiles
     123 *
     124 * May pop up dialogs for each torrent if that preference is enabled.
    120125 * May trigger one or more "error" signals with TR_CORE_ERR_ADD_TORRENT
    121126 */
    122 void tr_core_add_list( TrCore   * self,
    123                        GList    * torrentFiles,
    124                        tr_ctor  * ctor );
     127void tr_core_add_list( TrCore  * self,
     128                       GSList  * torrentFiles,
     129                       gboolean  forcePaused );
    125130
    126131/**
  • trunk/gtk/tr-io.c

    r5125 r5276  
    5050  size_t inused;
    5151  size_t inmax;
    52   GList *outbufs;
     52  GSList *outbufs;
    5353  unsigned int lastid;
    5454};
     
    184184
    185185    if(buf->off >= buf->len) {
    186       io->outbufs = g_list_remove(io->outbufs, buf);
     186      io->outbufs = g_slist_remove(io->outbufs, buf);
    187187      if(NULL == io->outbufs)
    188188        g_source_remove_poll((GSource*)io, &io->outfd);
     
    221221  struct iosource *io = (struct iosource*)source;
    222222
    223   if(NULL != io->outbufs) {
    224     g_list_foreach(io->outbufs, (GFunc)freeoutbuf, NULL);
    225     g_list_free(io->outbufs);
    226   }
    227 
    228   if(NULL != io->inbuf)
    229     g_free(io->inbuf);
     223  g_slist_foreach(io->outbufs, (GFunc)freeoutbuf, NULL);
     224  g_slist_free(io->outbufs);
     225  g_free(io->inbuf);
     226
     227  io->outbufs = NULL;
     228  io->inbuf = NULL;
    230229}
    231230
     
    326325
    327326  if(NULL != io->outbufs)
    328     io->outbufs = g_list_append(io->outbufs, buf);
     327    io->outbufs = g_slist_append(io->outbufs, buf);
    329328  else {
    330     io->outbufs = g_list_append(io->outbufs, buf);
     329    io->outbufs = g_slist_append(io->outbufs, buf);
    331330    g_source_add_poll(source, &io->outfd);
    332331  }
  • trunk/gtk/tr-prefs.c

    r5275 r5276  
    1111 */
    1212
     13#include <stdlib.h> /* free() */
    1314#include <glib/gi18n.h>
    1415#include <gtk/gtk.h>
  • trunk/gtk/util.c

    r5240 r5276  
    188188}
    189189
    190 GList *
    191 dupstrlist( GList * l )
    192 {
    193     GList * ret = NULL;
     190GSList *
     191dupstrlist( GSList * l )
     192{
     193    GSList * ret = NULL;
    194194    for( ; l!=NULL; l=l->next )
    195         ret = g_list_prepend( ret, g_strdup( l->data ) );
    196     return g_list_reverse( ret );
     195        ret = g_slist_prepend( ret, g_strdup( l->data ) );
     196    return g_slist_reverse( ret );
    197197}
    198198
    199199char *
    200 joinstrlist(GList *list, char *sep)
    201 {
    202   GList *l;
     200joinstrlist(GSList *list, char *sep)
     201{
     202  GSList *l;
    203203  GString *gstr = g_string_new (NULL);
    204204  for (l=list; l!=NULL; l=l->next) {
     
    211211
    212212void
    213 freestrlist(GList *list)
    214 {
    215   g_list_foreach (list, (GFunc)g_free, NULL);
    216   g_list_free (list);
     213freestrlist(GSList *list)
     214{
     215  g_slist_foreach (list, (GFunc)g_free, NULL);
     216  g_slist_free (list);
    217217}
    218218
     
    226226}
    227227
    228 GList *
     228GSList *
    229229checkfilenames( int argc, char **argv )
    230230{
    231231    int i;
    232     GList * ret = NULL;
     232    GSList * ret = NULL;
    233233    char * pwd = g_get_current_dir( );
    234234
     
    240240
    241241        if( g_file_test( filename, G_FILE_TEST_EXISTS ) )
    242             ret = g_list_append( ret, filename );
     242            ret = g_slist_prepend( ret, filename );
    243243        else
    244244            g_free( filename );
     
    246246
    247247    g_free( pwd );
    248     return ret;
     248    return g_slist_reverse( ret );
    249249}
    250250
     
    295295
    296296static void
    297 errcb(GtkWidget *widget, int resp UNUSED, gpointer data) {
    298   GList *funcdata;
    299   callbackfunc_t func;
    300 
    301   if(NULL != data) {
    302     funcdata = g_list_first(data);
    303     func = (callbackfunc_t) funcdata->data;
    304     data = funcdata->next->data;
    305     func(data);
    306     g_list_free(funcdata);
    307   }
    308 
    309   gtk_widget_destroy(widget);
     297onErrorResponse(GtkWidget * dialog, int resp UNUSED, gpointer glist)
     298{
     299    GSList * list = glist;
     300    if( list )
     301    {
     302        callbackfunc_t func = list->data;
     303        gpointer user_data = list->next->data;
     304        func( user_data );
     305        g_slist_free( list );
     306    }
     307
     308    gtk_widget_destroy( dialog );
    310309}
    311310
     
    316315  GtkWidget *dialog;
    317316  char *msg;
    318   GList *funcdata;
     317  GSList *funcdata = NULL;
    319318
    320319  msg = g_strdup_vprintf(format, ap);
     
    328327      GTK_MESSAGE_ERROR, GTK_BUTTONS_OK, "%s", msg);
    329328
    330   if(NULL == func)
    331     funcdata = NULL;
    332   else
    333       funcdata = g_list_append(g_list_append(NULL, (void *) func), data);
    334   g_signal_connect(dialog, "response", G_CALLBACK(errcb), funcdata);
     329  if( func ) {
     330    funcdata = g_slist_append( funcdata, (gpointer)func );
     331    funcdata = g_slist_append( funcdata, data );
     332  }
     333  g_signal_connect(dialog, "response", G_CALLBACK(onErrorResponse), funcdata);
    335334  g_free(msg);
    336335
  • trunk/gtk/util.h

    r5230 r5276  
    6060mkdir_p(const char *name, mode_t mode);
    6161
    62 /* create a copy of a GList of strings, this dups the actual strings too */
    63 GList *
    64 dupstrlist( GList * list );
     62/* create a copy of a GSList of strings, this dups the actual strings too */
     63GSList *
     64dupstrlist( GSList * list );
    6565
    66 /* joins a GList of strings into one string using an optional separator */
     66/* joins a GSList of strings into one string using an optional separator */
    6767char *
    68 joinstrlist(GList *list, char *sep);
     68joinstrlist(GSList *list, char *sep);
    6969
    70 /* free a GList of strings */
     70/* free a GSList of strings */
    7171void
    72 freestrlist(GList *list);
     72freestrlist(GSList *list);
    7373
    7474/* decodes a string that has been urlencoded */
     
    7777
    7878/* return a list of cleaned-up paths, with invalid directories removed */
    79 GList *
     79GSList *
    8080checkfilenames( int argc, char ** argv );
    8181
Note: See TracChangeset for help on using the changeset viewer.