Changeset 1654


Ignore:
Timestamp:
Apr 4, 2007, 12:32:58 AM (15 years ago)
Author:
joshe
Message:

Add files window to properties window as a tab.
Update properties dialog at regular intervals.

Location:
trunk/gtk
Files:
6 edited

Legend:

Unmodified
Added
Removed
  • trunk/gtk/dialogs.c

    r1647 r1654  
    6969};
    7070
    71 struct fileswind
    72 {
    73     GtkWidget    * widget;
    74     TrTorrent    * tor;
    75     GtkTreeModel * model;
    76     guint          timer;
     71struct infowind
     72{
     73    GtkWidget             * widget;
     74    TrTorrent             * tor;
     75    int64_t                 size;
     76    GtkTreeModel          * model;
     77    GtkTreeRowReference   * row;
     78    GtkTreeModel          * filesmodel;
     79    guint                   timer;
     80    struct
     81    {
     82        tr_tracker_info_t * track;
     83        GtkLabel          * trackwid;
     84        GtkLabel          * annwid;
     85        GtkLabel          * scrwid;
     86        int                 seed;
     87        GtkLabel          * seedwid;
     88        int                 leech;
     89        GtkLabel          * leechwid;
     90        int                 done;
     91        GtkLabel          * donewid;
     92        uint64_t            up;
     93        GtkLabel          * upwid;
     94        uint64_t            down;
     95        GtkLabel          * downwid;
     96    }                       inf;
    7797};
    7898
     
    83103static void
    84104addresp(GtkWidget *widget, gint resp, gpointer gdata);
     105static GtkWidget *
     106makeinfotab( TrTorrent * tor, struct infowind * iw );
     107static void
     108infoupdate( struct infowind * iw, int force );
     109void
     110fmtpeercount( GtkLabel * label, int count );
    85111static void
    86112promptresp( GtkWidget * widget, gint resp, gpointer data );
    87113static void
    88114quitresp( GtkWidget * widget, gint resp, gpointer data );
     115GtkWidget *
     116makefilestab( TrTorrent * tor, GtkTreeModel ** modelret );
    89117static void
    90118stylekludge( GObject * obj, GParamSpec * spec, gpointer data );
    91119static void
    92 fileswinddead( GtkWidget * widget, gpointer data );
    93 static void
    94 filestorclosed( gpointer data, GObject * tor );
     120infowinddead( GtkWidget * widget, gpointer data );
     121static void
     122infotorclosed( gpointer data, GObject * tor );
    95123static void
    96124parsepath( GtkTreeStore * store, GtkTreeIter * ret,
     
    99127getdirtotals( GtkTreeStore * store, GtkTreeIter * parent );
    100128static gboolean
    101 fileswindupdate( gpointer data );
     129infowindupdate( gpointer data );
    102130static float
    103131updateprogress( GtkTreeModel * model, GtkTreeIter * parent,
     
    207235}
    208236
    209 #define INFOLINE(tab, ii, nam, val) \
    210   do { \
    211     char *txt = g_markup_printf_escaped("<b>%s</b>", nam); \
    212     GtkWidget *wid = gtk_label_new(NULL); \
    213     gtk_misc_set_alignment(GTK_MISC(wid), 0, .5); \
    214     gtk_label_set_markup(GTK_LABEL(wid), txt); \
    215     gtk_table_attach_defaults(GTK_TABLE(tab), wid, 0, 1, ii, ii + 1); \
    216     wid = gtk_label_new(val); \
    217     gtk_label_set_selectable(GTK_LABEL(wid), TRUE); \
    218     gtk_misc_set_alignment(GTK_MISC(wid), 0, .5); \
    219     gtk_table_attach_defaults(GTK_TABLE(tab), wid, 1, 2, ii, ii + 1); \
    220     ii++; \
    221     g_free(txt); \
    222   } while(0)
    223 
    224 #define INFOLINEF(tab, ii, fmt, nam, val) \
    225   do { \
    226     char *buf = g_strdup_printf(fmt, val); \
    227     INFOLINE(tab, ii, nam, buf); \
    228     g_free(buf); \
    229   } while(0)
    230 
    231 #define INFOLINEA(tab, ii, nam, val) \
    232   do { \
    233     char *buf = val; \
    234     INFOLINE(tab, ii, nam, buf); \
    235     g_free(buf); \
    236   } while(0)
    237 
    238 #define INFOSEP(tab, ii) \
    239   do { \
    240     GtkWidget *wid = gtk_hseparator_new(); \
    241     gtk_table_attach_defaults(GTK_TABLE(tab), wid, 0, 2, ii, ii + 1); \
    242     ii++; \
    243   } while(0)
    244 
    245237void
    246 makeinfowind(GtkWindow *parent, TrTorrent *tor) {
    247   tr_stat_t *sb;
    248   tr_info_t *in;
    249   GtkWidget *wind, *label;
    250   int ii;
    251   char *str;
    252   const int rowcount = 15;
    253   GtkWidget *table = gtk_table_new(rowcount, 2, FALSE);
    254 
    255   /* XXX should use model and update this window regularly */
    256 
    257   sb = tr_torrent_stat(tor);
    258   in = tr_torrent_info(tor);
    259   str = g_strdup_printf(_("%s Properties"), in->name);
    260   wind = gtk_dialog_new_with_buttons(str, parent,
    261     GTK_DIALOG_DESTROY_WITH_PARENT | GTK_DIALOG_NO_SEPARATOR,
    262     GTK_STOCK_OK, GTK_RESPONSE_ACCEPT, NULL);
    263   g_free(str);
    264 
    265   gtk_window_set_role( GTK_WINDOW( wind ), "tr-info" );
    266   gtk_widget_set_name(wind, "TransmissionDialog");
    267   gtk_table_set_col_spacings(GTK_TABLE(table), 12);
    268   gtk_table_set_row_spacings(GTK_TABLE(table), 12);
    269   gtk_dialog_set_default_response(GTK_DIALOG(wind), GTK_RESPONSE_ACCEPT);
    270   gtk_container_set_border_width(GTK_CONTAINER(table), 6);
    271   gtk_window_set_resizable(GTK_WINDOW(wind), FALSE);
    272 
    273   label = gtk_label_new(NULL);
    274   gtk_label_set_selectable(GTK_LABEL(label), TRUE);
    275   str = g_markup_printf_escaped("<big>%s</big>", in->name);
    276   gtk_label_set_markup(GTK_LABEL(label), str);
    277   g_free(str);
    278   gtk_table_attach_defaults(GTK_TABLE(table), label, 0, 2, 0, 1);
    279 
    280   ii = 1;
    281 
    282   INFOSEP(table, ii);
    283 
    284   if(80 == sb->tracker->port)
    285     INFOLINEA(table, ii, _("Tracker:"), g_strdup_printf("http://%s",
    286               sb->tracker->address));
    287   else
    288     INFOLINEA(table, ii, _("Tracker:"), g_strdup_printf("http://%s:%i",
    289               sb->tracker->address, sb->tracker->port));
    290   INFOLINE(table, ii, _("Announce:"), sb->tracker->announce);
    291   INFOLINEA(table, ii, _("Piece Size:"), readablesize(in->pieceSize));
    292   INFOLINEF(table, ii, "%i", _("Pieces:"), in->pieceCount);
    293   INFOLINEA(table, ii, _("Total Size:"), readablesize(in->totalSize));
    294   if(0 > sb->seeders)
    295     INFOLINE(table, ii, _("Seeders:"), _("?"));
    296   else
    297     INFOLINEF(table, ii, "%i", _("Seeders:"), sb->seeders);
    298   if(0 > sb->leechers)
    299     INFOLINE(table, ii, _("Leechers:"), _("?"));
    300   else
    301     INFOLINEF(table, ii, "%i", _("Leechers:"), sb->leechers);
    302   if(0 > sb->completedFromTracker)
    303     INFOLINE(table, ii, _("Completed:"), _("?"));
    304   else
    305     INFOLINEF(table, ii, "%i", _("Completed:"), sb->completedFromTracker);
    306 
    307   INFOSEP(table, ii);
    308 
    309   INFOLINE(table, ii, _("Directory:"), tr_torrentGetFolder(tr_torrent_handle(tor)));
    310   INFOLINEA(table, ii, _("Downloaded:"), readablesize(sb->downloaded));
    311   INFOLINEA(table, ii, _("Uploaded:"), readablesize(sb->uploaded));
    312 
    313   INFOSEP(table, ii);
    314 
    315   g_assert(rowcount == ii);
    316 
    317   gtk_box_pack_start_defaults(GTK_BOX(GTK_DIALOG(wind)->vbox), table);
    318   g_signal_connect(G_OBJECT(wind), "response",
    319                    G_CALLBACK(gtk_widget_destroy), NULL);
    320   gtk_widget_show_all(wind);
     238makeinfowind( GtkWindow * parent, GtkTreeModel * model, GtkTreePath * path,
     239              TrTorrent * tor )
     240{
     241    struct infowind   * iw;
     242    GtkWidget         * wind, * box, * label, * sep, * tabs, * page;
     243    tr_info_t         * inf;
     244    char              * name, * size;
     245
     246    iw   = g_new0( struct infowind, 1 );
     247    inf  = tr_torrent_info( tor );
     248    name = g_strdup_printf( _("%s - Properties for %s"),
     249                            g_get_application_name(), inf->name );
     250    wind = gtk_dialog_new_with_buttons( name, parent,
     251                                        GTK_DIALOG_DESTROY_WITH_PARENT |
     252                                        GTK_DIALOG_NO_SEPARATOR,
     253                                        GTK_STOCK_OK, GTK_RESPONSE_ACCEPT,
     254                                        NULL );
     255    g_free( name );
     256    gtk_dialog_set_default_response( GTK_DIALOG( wind ), GTK_RESPONSE_ACCEPT );
     257    gtk_window_set_resizable( GTK_WINDOW( wind ), TRUE );
     258    gtk_window_set_role( GTK_WINDOW( wind ), "tr-info" );
     259    gtk_widget_set_name( wind, "TransmissionDialog" );
     260    box = GTK_DIALOG( wind )->vbox;
     261
     262    /* add label with file name and size */
     263    label = gtk_label_new( NULL );
     264    size = readablesize( inf->totalSize );
     265    name = g_markup_printf_escaped( "<big>%s (%s)</big>", inf->name, size );
     266    free( size );
     267    gtk_label_set_markup( GTK_LABEL( label ), name );
     268    g_free( name );
     269    gtk_label_set_selectable( GTK_LABEL( label ), TRUE );
     270    gtk_widget_show( label );
     271    gtk_box_pack_start( GTK_BOX( box ), label, FALSE, FALSE, 6 );
     272
     273    /* add separator */
     274    sep = gtk_hseparator_new();
     275    gtk_widget_show( sep );
     276    gtk_box_pack_start( GTK_BOX( box ), sep, FALSE, FALSE, 6 );
     277
     278    /* add tab bar */
     279    tabs = gtk_notebook_new();
     280    gtk_widget_show( tabs );
     281    gtk_box_pack_start( GTK_BOX( box ), tabs, TRUE, TRUE, 6 );
     282
     283    /* add general tab */
     284    label = gtk_label_new( _("General") );
     285    gtk_widget_show( label );
     286    page = makeinfotab( tor, iw );
     287    gtk_notebook_append_page( GTK_NOTEBOOK( tabs ), page, label );
     288
     289    /* add files tab */
     290    label = gtk_label_new( _("Files") );
     291    gtk_widget_show( label );
     292    /* XXX should use sizingmagic() here */
     293    page = makefilestab( tor, &iw->filesmodel );
     294    gtk_notebook_append_page( GTK_NOTEBOOK( tabs ), page, label );
     295
     296    /* set up the callback data */
     297    iw->widget     = wind;
     298    iw->tor        = tor;
     299    iw->size       = inf->totalSize;
     300    iw->model      = model;
     301    iw->row        = gtk_tree_row_reference_new( model, path );
     302    iw->timer      = g_timeout_add( UPDATE_INTERVAL, infowindupdate, iw );
     303
     304    g_object_ref( model );
     305    g_object_weak_ref( G_OBJECT( tor ), infotorclosed, iw );
     306    g_signal_connect( wind, "destroy", G_CALLBACK( infowinddead ), iw );
     307    g_signal_connect( wind, "response", G_CALLBACK( gtk_widget_destroy ), 0 );
     308    infoupdate( iw, 1 );
     309    infowindupdate( iw );
     310
     311    gtk_widget_show( wind );
     312}
     313
     314#define INFOLINE( tab, ii, nam, val )                                         \
     315    do                                                                        \
     316    {                                                                         \
     317        char     * txt = g_markup_printf_escaped( "<b>%s</b>", (nam) );       \
     318        GtkWidget * wid = gtk_label_new( NULL );                              \
     319        gtk_misc_set_alignment( GTK_MISC( wid ), 0, .5 );                     \
     320        gtk_label_set_markup( GTK_LABEL( wid ), txt );                        \
     321        gtk_table_attach( GTK_TABLE( (tab) ), wid, 0, 1, (ii), (ii) + 1,      \
     322                          GTK_FILL, GTK_FILL, 0, 0 );                         \
     323        gtk_label_set_selectable( GTK_LABEL( (val) ), TRUE );                 \
     324        gtk_misc_set_alignment( GTK_MISC( (val) ), 0, .5 );                   \
     325        gtk_table_attach( GTK_TABLE( (tab) ), (val), 1, 2, (ii), (ii) + 1,    \
     326                          GTK_FILL, GTK_FILL, 0, 0);                          \
     327        (ii)++;                                                               \
     328        g_free( txt );                                                        \
     329    } while( 0 )
     330
     331#define INFOLINEF( tab, ii, fmt, nam, val )                                   \
     332    do                                                                        \
     333    {                                                                         \
     334        char      * buf = g_strdup_printf( fmt, val );                        \
     335        GtkWidget * lwid = gtk_label_new( buf );                              \
     336        g_free( buf );                                                        \
     337        INFOLINE( tab, ii, nam, lwid );                                       \
     338    } while( 0 )
     339
     340#define INFOLINEW( tab, ii, nam, val )                                        \
     341    do                                                                        \
     342    {                                                                         \
     343        GtkWidget * lwid = gtk_label_new( (val) );                            \
     344        INFOLINE( (tab), (ii), (nam), lwid );                                 \
     345    } while( 0 )
     346
     347#define INFOLINEA( tab, ii, nam, val )                                        \
     348    do                                                                        \
     349    {                                                                         \
     350        GtkWidget * lwid = gtk_label_new( (val) );                            \
     351        g_free( val );                                                        \
     352        INFOLINE( (tab), (ii), (nam), lwid );                                 \
     353    } while( 0 )
     354
     355#define INFOLINEU( tab, ii, nam, stor )                                       \
     356    do                                                                        \
     357    {                                                                         \
     358        GtkWidget * lwid = gtk_label_new( NULL );                             \
     359        (stor) = GTK_LABEL( lwid );                                           \
     360        INFOLINE( (tab), (ii), (nam), lwid);                                  \
     361    } while( 0 )
     362
     363#define INFOSEP( tab, ii )                                                    \
     364    do                                                                        \
     365    {                                                                         \
     366        GtkWidget * wid = gtk_hseparator_new();                               \
     367        gtk_table_attach( GTK_TABLE( (tab) ), wid, 0, 2, (ii), (ii) + 1,      \
     368                          GTK_EXPAND | GTK_FILL, GTK_FILL, 0, 0 );            \
     369        (ii)++;                                                               \
     370    } while( 0 )
     371
     372GtkWidget *
     373makeinfotab( TrTorrent * tor, struct infowind * iw )
     374{
     375    const int   rowcount = 16;
     376    tr_info_t * inf;
     377    int         ii;
     378    GtkWidget * table;
     379
     380    inf   = tr_torrent_info( tor );
     381    table = gtk_table_new( rowcount, 2, FALSE );
     382    gtk_table_set_col_spacings( GTK_TABLE( table ), 12 );
     383    gtk_table_set_row_spacings( GTK_TABLE( table ), 12 );
     384    gtk_container_set_border_width( GTK_CONTAINER( table ), 6 );
     385
     386    ii = 0;
     387
     388    INFOLINEU( table, ii, _("Tracker:"),      iw->inf.trackwid );
     389    INFOLINEU( table, ii, _("Announce:"),     iw->inf.annwid );
     390    INFOLINEU( table, ii, _("Scrape:"),       iw->inf.scrwid );
     391    INFOSEP(   table, ii );
     392    INFOLINEW( table, ii, _("Info Hash:"),    inf->hashString );
     393    INFOLINEA( table, ii, _("Piece Size:"),   readablesize( inf->pieceSize ) );
     394    INFOLINEF( table, ii, "%i", _("Pieces:"), inf->pieceCount );
     395    INFOLINEA( table, ii, _("Total Size:"),   readablesize( inf->totalSize ) );
     396    INFOSEP(   table, ii );
     397    INFOLINEU( table, ii, _("Seeders:"),      iw->inf.seedwid );
     398    INFOLINEU( table, ii, _("Leechers:"),     iw->inf.leechwid );
     399    INFOLINEU( table, ii, _("Completed:"),    iw->inf.donewid );
     400    INFOSEP(   table, ii );
     401    INFOLINEW( table, ii, _("Directory:"),
     402               tr_torrentGetFolder( tr_torrent_handle( tor ) ) );
     403    INFOLINEU( table, ii, _("Downloaded:"),   iw->inf.downwid );
     404    INFOLINEU( table, ii, _("Uploaded:"),     iw->inf.upwid );
     405
     406    g_assert( rowcount == ii );
     407
     408    gtk_widget_show_all( table );
     409
     410    return table;
     411}
     412
     413void
     414infoupdate( struct infowind * iw, int force )
     415{
     416    int                 seed, leech, done;
     417    uint64_t            up, down;
     418    tr_tracker_info_t * track;
     419    GtkTreePath       * path;
     420    GtkTreeIter         iter;
     421    char              * str;
     422
     423    path = gtk_tree_row_reference_get_path( iw->row );
     424    if( NULL == path || !gtk_tree_model_get_iter( iw->model, &iter, path ) )
     425    {
     426        g_free( path );
     427        return;
     428    }
     429    gtk_tree_model_get( iw->model, &iter, MC_TRACKER, &track,
     430                        MC_SEED, &seed, MC_LEECH, &leech, MC_DONE, &done,
     431                        MC_DOWN, &down, MC_UP, &up, -1 );
     432
     433    if( track != iw->inf.track || force )
     434    {
     435        if( 80 == track->port )
     436        {
     437            str = g_strdup_printf( "http://%s", track->address );
     438        }
     439        else
     440        {
     441            str = g_strdup_printf( "http://%s:%i",
     442                                   track->address, track->port );
     443        }
     444        gtk_label_set_text( iw->inf.trackwid, str );
     445        g_free( str );
     446        gtk_label_set_text( iw->inf.annwid, track->announce );
     447        gtk_label_set_text( iw->inf.scrwid, track->scrape );
     448    }
     449    if( seed != iw->inf.seed || force )
     450    {
     451        fmtpeercount( iw->inf.seedwid, seed );
     452        iw->inf.seed = seed;
     453    }
     454    if( leech != iw->inf.leech || force )
     455    {
     456        fmtpeercount( iw->inf.leechwid, leech );
     457        iw->inf.leech = leech;
     458    }
     459    if( done != iw->inf.done || force )
     460    {
     461        fmtpeercount( iw->inf.donewid, done );
     462        iw->inf.done = done;
     463    }
     464    if( down != iw->inf.down || force )
     465    {
     466        str = readablesize( down );
     467        gtk_label_set_text( iw->inf.downwid, str );
     468        g_free( str );
     469        iw->inf.down = down;
     470    }
     471    if( up != iw->inf.up || force )
     472    {
     473        str = readablesize( up );
     474        gtk_label_set_text( iw->inf.upwid, str );
     475        g_free( str );
     476        iw->inf.up = up;
     477    }
     478}
     479
     480void
     481fmtpeercount( GtkLabel * label, int count )
     482{
     483    char str[16];
     484
     485    if( 0 > count )
     486    {
     487        gtk_label_set_text( label, _("?") );
     488    }
     489    else
     490    {
     491        snprintf( str, sizeof str, "%i", count );
     492        gtk_label_set_text( label, str );
     493    }
    321494}
    322495
     
    414587};
    415588
    416 void
    417 makefileswind( GtkWindow * parent, TrTorrent * tor )
     589GtkWidget *
     590makefilestab( TrTorrent * tor, GtkTreeModel ** modelret )
    418591{
    419592    GType cols[] =
     
    425598    GtkTreeStore      * store;
    426599    int                 ii;
    427     GtkWidget         * view, * scroll, * frame, * wind;
    428     GtkCellRenderer   * rend, * elip;
     600    GtkWidget         * view, * scroll, * frame;
     601    GtkCellRenderer   * rend;
    429602    GtkTreeViewColumn * col;
    430603    GtkTreeSelection  * sel;
    431604    char              * label;
    432     struct fileswind  * fw;
    433605
    434606    g_assert( ALEN( cols ) == FC__MAX );
    435607
    436608    /* set up the model */
    437     inf   = tr_torrent_info( tor );
    438     store = gtk_tree_store_newv( FC__MAX, cols );
     609    inf       = tr_torrent_info( tor );
     610    store     = gtk_tree_store_newv( FC__MAX, cols );
     611    *modelret = GTK_TREE_MODEL( store );
    439612    for( ii = 0; ii < inf->fileCount; ii++ )
    440613    {
     
    459632    /* add text renderer */
    460633    rend = gtk_cell_renderer_text_new();
    461     elip = rend;
     634    g_object_set( rend, "ellipsize", PANGO_ELLIPSIZE_END, NULL );
    462635    gtk_tree_view_column_pack_start( col, rend, TRUE );
    463636    gtk_tree_view_column_add_attribute( col, rend, "markup", FC_LABEL );
     
    485658    /* create the scrolled window and stick the view in it */
    486659    scroll = gtk_scrolled_window_new( NULL, NULL );
     660    gtk_scrolled_window_set_policy( GTK_SCROLLED_WINDOW( scroll ),
     661                                    GTK_POLICY_NEVER, GTK_POLICY_AUTOMATIC );
    487662    gtk_container_add( GTK_CONTAINER( scroll ), view );
    488663    gtk_widget_show( scroll );
     
    494669    gtk_widget_show( frame );
    495670
    496     /* create the window */
    497     label = g_strdup_printf( _("%s - Files for %s"),
    498                              g_get_application_name(), inf->name );
    499     wind = gtk_dialog_new_with_buttons( label, parent,
    500                                         GTK_DIALOG_DESTROY_WITH_PARENT |
    501                                         GTK_DIALOG_NO_SEPARATOR,
    502                                         GTK_STOCK_OK, GTK_RESPONSE_ACCEPT,
    503                                         NULL );
    504     g_free( label );
    505     gtk_dialog_set_default_response( GTK_DIALOG( wind ), GTK_RESPONSE_ACCEPT );
    506     gtk_window_set_resizable( GTK_WINDOW( wind ), TRUE );
    507     gtk_box_pack_start_defaults( GTK_BOX( GTK_DIALOG( wind )->vbox ), frame );
    508     gtk_window_set_role( GTK_WINDOW( wind ), "tr-files" );
    509 
    510     /* set up the callback data */
    511     fw         = g_new0( struct fileswind, 1 );
    512     fw->widget = wind;
    513     fw->tor    = tor;
    514     fw->model  = GTK_TREE_MODEL( store );
    515     fw->timer  = g_timeout_add( UPDATE_INTERVAL, fileswindupdate, fw );
    516 
    517     g_object_weak_ref( G_OBJECT( tor ), filestorclosed, fw );
    518     g_signal_connect( wind, "destroy", G_CALLBACK( fileswinddead ), fw );
    519     g_signal_connect( wind, "response", G_CALLBACK( gtk_widget_destroy ), 0 );
    520     fileswindupdate( fw );
    521 
    522     sizingmagic( GTK_WINDOW( wind ), GTK_SCROLLED_WINDOW( scroll ),
    523                  GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC );
    524     g_object_set( elip, "ellipsize", PANGO_ELLIPSIZE_END, NULL );
    525     gtk_widget_show( wind );
     671    return frame;
    526672}
    527673
     
    540686
    541687static void
    542 fileswinddead( GtkWidget * widget SHUTUP, gpointer data )
    543 {
    544     struct fileswind * fw = data;
    545 
    546     g_object_weak_unref( G_OBJECT( fw->tor ), filestorclosed, fw );
    547     filestorclosed( fw, G_OBJECT( fw->tor ) );
    548 }
    549 
    550 static void
    551 filestorclosed( gpointer data, GObject * tor SHUTUP )
    552 {
    553     struct fileswind * fw = data;
    554 
    555     g_source_remove( fw->timer );
    556     g_object_unref( fw->model );
    557     gtk_widget_destroy( fw->widget );
    558     g_free( fw );
     688infowinddead( GtkWidget * widget SHUTUP, gpointer data )
     689{
     690    struct infowind * iw = data;
     691
     692    g_object_weak_unref( G_OBJECT( iw->tor ), infotorclosed, iw );
     693    infotorclosed( iw, G_OBJECT( iw->tor ) );
     694}
     695
     696static void
     697infotorclosed( gpointer data, GObject * tor SHUTUP )
     698{
     699    struct infowind * iw = data;
     700
     701    g_source_remove( iw->timer );
     702    g_object_unref( iw->filesmodel );
     703    g_object_unref( iw->model );
     704    gtk_tree_row_reference_free( iw->row );
     705    gtk_widget_destroy( iw->widget );
     706    g_free( iw );
    559707}
    560708
     
    657805
    658806static gboolean
    659 fileswindupdate( gpointer data )
    660 {
    661     struct fileswind * fw;
    662     tr_info_t        * inf;
     807infowindupdate( gpointer data )
     808{
     809    struct infowind  * iw;
    663810    float            * progress;
    664811
    665     fw       = data;
    666     inf      = tr_torrent_info( fw->tor );
    667     progress = tr_torrentCompletion( tr_torrent_handle( fw->tor ) );
    668     updateprogress( fw->model, NULL, inf->totalSize, progress );
     812    iw       = data;
     813    progress = tr_torrentCompletion( tr_torrent_handle( iw->tor ) );
     814    updateprogress( iw->filesmodel, NULL, iw->size, progress );
    669815    free( progress );
     816    infoupdate( iw, 0 );
    670817
    671818    return TRUE;
  • trunk/gtk/dialogs.h

    r1506 r1654  
    4343/* show the info window for a torrent */
    4444void
    45 makeinfowind(GtkWindow *parent, TrTorrent *tor);
     45makeinfowind( GtkWindow * parent, GtkTreeModel * model, GtkTreePath * path,
     46              TrTorrent * tor );
    4647
    4748/* prompt for a download directory for torrents, then add them */
     
    5455askquit( GtkWindow * parent, callbackfunc_t func, void * cbdata );
    5556
    56 /* create a window listing a torrent's files */
    57 void
    58 makefileswind( GtkWindow * parent, TrTorrent * tor );
    59 
    6057#endif /* TG_PREFS_H */
  • trunk/gtk/main.c

    r1647 r1654  
    9090    ACT_SEPARATOR1,
    9191    ACT_INFO,
    92     ACT_FILES,
    9392    ACT_DEBUG,
    9493    ACT_SEPARATOR2,
     
    122121    { NULL,        GTK_STOCK_PROPERTIES,  0, ACTF_WHEREVER | ACTF_WHATEVER,
    123122      N_("Show additional information about a torrent") },
    124     { N_("Files"), NULL,                  0, ACTF_MENU     | ACTF_WHATEVER,
    125       N_("Show a list of the files in a torrent"), },
    126123    { N_("Open debug window"), NULL,      0, ACTF_MENU     | ACTF_ALWAYS,
    127124      NULL },
     
    381378        /* progress,  rateDownload, rateUpload,   eta,        peersTotal, */
    382379        G_TYPE_FLOAT, G_TYPE_FLOAT, G_TYPE_FLOAT, G_TYPE_INT, G_TYPE_INT,
    383         /* peersUploading, peersDownloading, downloaded,    uploaded */
    384         G_TYPE_INT,        G_TYPE_INT,       G_TYPE_UINT64, G_TYPE_UINT64,
    385         /* the TrTorrent object */
    386         TR_TORRENT_TYPE,
     380        /* peersUploading, peersDownloading, seeders,    leechers */
     381        G_TYPE_INT,        G_TYPE_INT,       G_TYPE_INT, G_TYPE_INT,
     382        /* completedFromTracker, downloaded,    uploaded */
     383        G_TYPE_INT,              G_TYPE_UINT64, G_TYPE_UINT64,
     384        /* tracker,            the TrTorrent object */
     385        TR_TRACKER_BOXED_TYPE, TR_TORRENT_TYPE,
    387386    };
    388387    struct cbdata * cbdata;
     
    827826  TrTorrent *tor;
    828827  tr_stat_t *st;
    829   tr_info_t *in;
    830828  GtkTreeIter iter;
    831829  float up, down;
     
    841839      gtk_tree_model_get(data->model, &iter, MC_TORRENT, &tor, -1);
    842840      st = tr_torrent_stat(tor);
    843       in = tr_torrent_info(tor);
    844841      g_object_unref(tor);
    845842      /* XXX find out if setting the same data emits changed signal */
    846       gtk_list_store_set(GTK_LIST_STORE(data->model), &iter, MC_NAME, in->name,
    847         MC_SIZE, in->totalSize, MC_STAT, st->status, MC_ERR, st->error,
    848         MC_TERR, st->errorString, MC_PROG, st->progress,
    849         MC_DRATE, st->rateDownload, MC_URATE, st->rateUpload, MC_ETA, st->eta,
    850         MC_PEERS, st->peersTotal, MC_UPEERS, st->peersUploading,
    851         MC_DPEERS, st->peersDownloading, MC_DOWN, st->downloaded,
    852         MC_UP, st->uploaded, -1);
     843      gtk_list_store_set( GTK_LIST_STORE( data->model ), &iter,
     844          MC_STAT,   st->status,               MC_ERR,     st->error,
     845          MC_TERR,   st->errorString,          MC_PROG,    st->progress,
     846          MC_DRATE,  st->rateDownload,         MC_URATE,   st->rateUpload,
     847          MC_ETA,    st->eta,                  MC_PEERS,   st->peersTotal,
     848          MC_UPEERS, st->peersUploading,       MC_DPEERS,  st->peersDownloading,
     849          MC_SEED,   st->seeders,              MC_LEECH,   st->leechers,
     850          MC_DONE,   st->completedFromTracker, MC_TRACKER, st->tracker,
     851          MC_DOWN,   st->downloaded,           MC_UP,      st->uploaded, -1);
    853852    } while(gtk_tree_model_iter_next(data->model, &iter));
    854853  }
     
    970969      case ACT_DELETE:
    971970      case ACT_INFO:
    972       case ACT_FILES:
    973971      case ACTION_COUNT:
    974972          break;
     
    10101008                  break;
    10111009              case ACT_INFO:
    1012                   makeinfowind( data->wind, tor );
    1013                   break;
    1014               case ACT_FILES:
    1015                   makefileswind( data->wind, tor );
     1010                  makeinfowind( data->wind, data->model, path, tor );
    10161011                  break;
    10171012              case ACT_OPEN:
     
    10511046  GtkTreeIter iter;
    10521047  const char * pref;
     1048  tr_info_t *in;
    10531049
    10541050  errlist = NULL;
     
    10821078  }
    10831079
    1084   for(ii = g_list_first(torlist); NULL != ii; ii = ii->next) {
    1085     gtk_list_store_append(GTK_LIST_STORE(data->model), &iter);
    1086     gtk_list_store_set(GTK_LIST_STORE(data->model), &iter,
    1087                        MC_TORRENT, ii->data, -1);
    1088     /* we will always ref a torrent before politely stopping it */
    1089     g_signal_connect(ii->data, "politely_stopped",
    1090                      G_CALLBACK(g_object_unref), data);
    1091     g_object_unref(ii->data);
     1080  for( ii = g_list_first( torlist ); NULL != ii; ii = ii->next )
     1081  {
     1082      gtk_list_store_append( GTK_LIST_STORE( data->model ), &iter );
     1083      in = tr_torrent_info( ii->data );
     1084      gtk_list_store_set( GTK_LIST_STORE( data->model ), &iter,
     1085                          MC_NAME,    in->name,
     1086                          MC_SIZE,    in->totalSize,
     1087                          MC_TORRENT, ii->data, -1);
     1088      /* we will always ref a torrent before politely stopping it */
     1089      g_signal_connect( ii->data, "politely_stopped",
     1090                        G_CALLBACK( g_object_unref ), data );
     1091      g_object_unref( ii->data );
    10921092  }
    10931093
  • trunk/gtk/tr_torrent.c

    r1615 r1654  
    6363tr_torrent_paused(TrTorrent *tor);
    6464
     65static gpointer
     66tracker_boxed_fake_copy( gpointer boxed )
     67{
     68    return boxed;
     69}
     70
     71static void
     72tracker_boxed_fake_free( gpointer boxed SHUTUP )
     73{
     74}
     75
     76GType
     77tr_tracker_boxed_get_type( void )
     78{
     79    static GType type = 0;
     80
     81    if( 0 == type )
     82    {
     83        type = g_boxed_type_register_static( "TrTrackerBoxed",
     84                                             tracker_boxed_fake_copy,
     85                                             tracker_boxed_fake_free );
     86    }
     87
     88    return type;
     89}
     90
    6591GType
    6692tr_torrent_get_type(void) {
  • trunk/gtk/tr_torrent.h

    r1504 r1654  
    3030#include "transmission.h"
    3131#include "bencode.h"
     32
     33/* boxed type for tr_tracker_info_t */
     34#define TR_TRACKER_BOXED_TYPE (tr_tracker_boxed_get_type ())
     35GType
     36tr_tracker_boxed_get_type( void );
    3237
    3338#define TR_TORRENT_TYPE           (tr_torrent_get_type ())
  • trunk/gtk/util.h

    r1647 r1654  
    6666  MC_NAME, MC_SIZE, MC_STAT, MC_ERR, MC_TERR,
    6767  MC_PROG, MC_DRATE, MC_URATE, MC_ETA, MC_PEERS,
    68   MC_UPEERS, MC_DPEERS, MC_DOWN, MC_UP,
    69   MC_TORRENT, MC_ROW_COUNT,
     68  MC_UPEERS, MC_DPEERS, MC_SEED, MC_LEECH, MC_DONE,
     69  MC_DOWN, MC_UP, MC_TRACKER, MC_TORRENT, MC_ROW_COUNT,
    7070};
    7171
Note: See TracChangeset for help on using the changeset viewer.