source: trunk/gtk/file-list.c @ 6612

Last change on this file since 6612 was 6612, checked in by charles, 13 years ago

bencode cleanup: remove unused functions and unnecessary #includes

  • Property svn:keywords set to Date Rev Author Id
File size: 23.0 KB
Line 
1/******************************************************************************
2 * $Id: file-list.c 6612 2008-08-21 14:57:59Z charles $
3 *
4 * Copyright (c) 2005-2008 Transmission authors and contributors
5 *
6 * Permission is hereby granted, free of charge, to any person obtaining a
7 * copy of this software and associated documentation files (the "Software"),
8 * to deal in the Software without restriction, including without limitation
9 * the rights to use, copy, modify, merge, publish, distribute, sublicense,
10 * and/or sell copies of the Software, and to permit persons to whom the
11 * Software is furnished to do so, subject to the following conditions:
12 *
13 * The above copyright notice and this permission notice shall be included in
14 * all copies or substantial portions of the Software.
15 *
16 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
17 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
18 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
19 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
20 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
21 * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
22 * DEALINGS IN THE SOFTWARE.
23 *****************************************************************************/
24
25#include <stddef.h>
26#include <stdio.h>
27#include <stdlib.h>
28#include <string.h>
29#include <glib/gi18n.h>
30#include <gtk/gtk.h>
31
32#include <libtransmission/transmission.h>
33#include <libtransmission/utils.h> /* tr_getRatio */
34
35#include "file-list.h"
36#include "hig.h"
37
38enum
39{
40    SUB_STATE_HIGH          = (1<<0),
41    SUB_STATE_NORMAL        = (1<<1),
42    SUB_STATE_LOW           = (1<<2),
43    SUB_STATE_PRIORITY_MASK = (SUB_STATE_HIGH|SUB_STATE_NORMAL|SUB_STATE_LOW),
44    SUB_STATE_DOWNLOAD      = (1<<4),
45    SUB_STATE_IGNORE        = (1<<5),
46    SUB_STATE_DOWNLOAD_MASK = (SUB_STATE_DOWNLOAD|SUB_STATE_IGNORE)
47};
48
49enum
50{
51    FC_STOCK,
52    FC_LABEL,
53    FC_PROG,
54    FC_KEY,
55    FC_INDEX,
56    FC_SIZE,
57    FC_HAVE,
58    FC_PRIORITY,
59    FC_ENABLED,
60    FC_IS_FILE,
61    FC_SUB_SIZE,
62    FC_SUB_HAVE,
63    FC_SUB_STATE,
64    N_FILE_COLS
65};
66
67typedef struct
68{
69    TrTorrent * gtor;
70    GtkWidget * top;
71    GtkWidget * view;
72    GtkTreeModel * model; /* same object as store, but recast */
73    GtkTreeStore * store; /* same object as model, but recast */
74    tr_file_stat * refresh_file_stat;
75    guint timeout_tag;
76}
77FileData;
78
79static void
80clearData( FileData * data )
81{
82    data->gtor = NULL;
83
84    if( data->timeout_tag ) {
85        g_source_remove( data->timeout_tag );
86        data->timeout_tag = 0;
87    }
88}
89
90static void
91freeData( gpointer gdata )
92{
93    FileData * data = gdata;
94    clearData( data );
95    g_free( data );
96}
97
98/***
99****
100***/
101
102static void
103parsepath( const tr_torrent  * tor,
104           GtkTreeStore      * store,
105           GtkTreeIter       * ret,
106           const char        * path,
107           tr_file_index_t     index,
108           uint64_t            size )
109{
110    GtkTreeModel * model;
111    GtkTreeIter  * parent, start, iter;
112    char         * file, * lower, * mykey;
113    const char   * stock;
114    int            priority = 0;
115    gboolean       enabled = TRUE;
116    gboolean       is_file;
117
118    model  = GTK_TREE_MODEL( store );
119    parent = NULL;
120    file   = g_path_get_basename( path );
121    if( 0 != strcmp( file, path ) )
122    {
123        char * dir = g_path_get_dirname( path );
124        parsepath( tor, store, &start, dir, index, size );
125        parent = &start;
126        g_free( dir );
127    }
128
129    lower = g_utf8_casefold( file, -1 );
130    mykey = g_utf8_collate_key( lower, -1 );
131    if( gtk_tree_model_iter_children( model, &iter, parent ) ) do
132    {
133        gboolean stop;
134        char * modelkey;
135        gtk_tree_model_get( model, &iter, FC_KEY, &modelkey, -1 );
136        stop = (modelkey!=NULL) && !strcmp(mykey,modelkey);
137        g_free (modelkey);
138        if (stop) goto done;
139    }
140    while( gtk_tree_model_iter_next( model, &iter ) );
141
142    gtk_tree_store_append( store, &iter, parent );
143    if(( is_file = !ret ))
144    {
145        stock = GTK_STOCK_FILE;
146        priority = tr_torrentGetFilePriority( tor, index );
147        enabled  = tr_torrentGetFileDL( tor, index );
148    }
149    else
150    {
151        stock = GTK_STOCK_DIRECTORY;
152        size  = 0;
153    }
154
155#if 0
156    gtk_tree_store_set( store, &iter, FC_INDEX, index,
157                                      FC_LABEL, file,
158                                      FC_KEY, mykey,
159                                      FC_STOCK, stock,
160                                      FC_PRIORITY, priority,
161                                      FC_ENABLED, enabled,
162                                      FC_IS_FILE, is_file,
163                                      FC_SIZE, size,
164                                      FC_HAVE, 0,
165                                      -1 );
166#else
167    gtk_tree_store_set( store, &iter, FC_INDEX, index, -1 );
168    gtk_tree_store_set( store, &iter, FC_LABEL, file, -1 );
169    gtk_tree_store_set( store, &iter, FC_KEY, mykey, -1 );
170    gtk_tree_store_set( store, &iter, FC_STOCK, stock, -1 );
171    gtk_tree_store_set( store, &iter, FC_PRIORITY, priority, -1 );
172    gtk_tree_store_set( store, &iter, FC_ENABLED, enabled, -1 );
173    gtk_tree_store_set( store, &iter, FC_IS_FILE, is_file, -1 );
174    gtk_tree_store_set( store, &iter, FC_SIZE, size, -1 );
175    gtk_tree_store_set( store, &iter, FC_HAVE, 0, -1 );
176#endif
177
178  done:
179    g_free( mykey );
180    g_free( lower );
181    g_free( file );
182    if( NULL != ret )
183      *ret = iter;
184}
185
186
187/***
188****
189***/
190
191static gboolean
192refreshFilesForeach( GtkTreeModel  * model,
193                     GtkTreePath   * path UNUSED,
194                     GtkTreeIter   * iter,
195                     gpointer        gdata )
196{
197    FileData * data = gdata;
198    gboolean is_file;
199    unsigned int index;
200    gtk_tree_model_get( model, iter, FC_IS_FILE, &is_file, FC_INDEX, &index, -1  );
201    if( is_file ) {
202        GtkTreeStore * store = GTK_TREE_STORE( model );
203        tr_torrent * tor = tr_torrent_handle( data->gtor );
204        int download = tr_torrentGetFileDL( tor, index );
205        int priority = tr_torrentGetFilePriority( tor, index );
206        uint64_t have = data->refresh_file_stat[index].bytesCompleted;
207        gtk_tree_store_set( store, iter, FC_PRIORITY, priority,
208                                         FC_ENABLED, download,
209                                         FC_HAVE, have,
210                                         -1 );
211    }
212    return FALSE; /* keep walking */
213}
214
215static gboolean
216resetSubForeach( GtkTreeModel  * model,
217                 GtkTreePath   * path UNUSED,
218                 GtkTreeIter   * iter,
219                 gpointer        gdata UNUSED )
220{
221    /* set the subs to the lowest values... */
222    gtk_tree_store_set( GTK_TREE_STORE( model ), iter,
223                        FC_SUB_STATE, 0,
224                        FC_SUB_SIZE, (uint64_t)0,
225                        FC_SUB_HAVE, (uint64_t)0,
226                        -1 );
227    return FALSE; /* keep walking */
228}
229
230static gboolean
231addSubForeach( GtkTreeModel  * model,
232               GtkTreePath   * path UNUSED,
233               GtkTreeIter   * iter,
234               gpointer        gdata UNUSED )
235{
236    uint64_t size;
237    uint64_t have;
238    int priority;
239    gboolean enabled;
240    gboolean is_file;
241    gtk_tree_model_get( model, iter, FC_SIZE, &size,
242                                     FC_HAVE, &have,
243                                     FC_PRIORITY, &priority,
244                                     FC_ENABLED, &enabled,
245                                     FC_IS_FILE, &is_file,
246                                     -1 );
247    if( is_file )
248    {
249        GtkTreeIter child = *iter;
250        GtkTreeIter parent;
251        while(( gtk_tree_model_iter_parent( model, &parent, &child )))
252        {
253            uint64_t sub_size;
254            uint64_t sub_have;
255            int sub_state;
256            gtk_tree_model_get( model, &parent, FC_SUB_SIZE, &sub_size,
257                                                FC_SUB_HAVE, &sub_have,
258                                                FC_SUB_STATE, &sub_state,
259                                                -1 );
260            sub_have += have;
261            sub_size += size;
262            switch( priority ) {
263                case TR_PRI_HIGH:   sub_state |= SUB_STATE_HIGH;   break;
264                case TR_PRI_NORMAL: sub_state |= SUB_STATE_NORMAL; break;
265                case TR_PRI_LOW:    sub_state |= SUB_STATE_LOW;    break;
266            }
267            sub_state |= ( enabled ? SUB_STATE_DOWNLOAD : SUB_STATE_IGNORE );
268            gtk_tree_store_set( GTK_TREE_STORE( model ), &parent,
269                                FC_SUB_SIZE, sub_size,
270                                FC_SUB_HAVE, sub_have,
271                                FC_SUB_STATE, sub_state,
272                                -1 );
273            child = parent;
274        }
275    }
276    return FALSE; /* keep walking */
277}
278
279static void
280refresh( FileData * data )
281{
282    tr_file_index_t fileCount;
283    tr_torrent * tor = tr_torrent_handle( data->gtor );
284    data->refresh_file_stat = tr_torrentFiles( tor, &fileCount );
285
286    gtk_tree_model_foreach( data->model, refreshFilesForeach, data );
287    gtk_tree_model_foreach( data->model, resetSubForeach, data );
288    gtk_tree_model_foreach( data->model, addSubForeach, data );
289
290    tr_torrentFilesFree( data->refresh_file_stat, fileCount );
291    data->refresh_file_stat = NULL;
292}
293
294static gboolean
295refreshModel( gpointer file_data )
296{
297    refresh( file_data );
298    return TRUE;
299}
300
301/***
302****
303***/
304
305struct ActiveData
306{
307    GtkTreeSelection * sel;
308    GArray * array;
309};
310
311static gboolean
312getActiveFilesForeach( GtkTreeModel  * model,
313                       GtkTreePath   * path UNUSED,
314                       GtkTreeIter   * iter,
315                       gpointer        gdata )
316{
317    struct ActiveData * data = gdata;
318    unsigned int i;
319    gboolean is_file = FALSE;
320    gboolean is_active = FALSE;
321
322    /* active == if it's selected, or any ancestor is selected */
323    gtk_tree_model_get( model, iter, FC_IS_FILE, &is_file, FC_INDEX, &i, -1 );
324    if( is_file ) {
325        is_active = gtk_tree_selection_iter_is_selected( data->sel, iter );
326        if( !is_active ) {
327            GtkTreeIter walk = *iter;
328            GtkTreeIter parent;
329            while( !is_active && gtk_tree_model_iter_parent( model, &parent, &walk )) {
330                is_active = gtk_tree_selection_iter_is_selected( data->sel, &parent );
331                walk = parent;
332            }
333        }
334    }
335
336    if( is_active )
337        g_array_append_val( data->array, i );
338
339    return FALSE; /* keep walking */
340}
341
342static GArray*
343getActiveFiles( GtkTreeView * view )
344{
345    struct ActiveData data;
346    data.sel = gtk_tree_view_get_selection( view );
347    data.array  = g_array_new( FALSE, FALSE, sizeof( tr_file_index_t ) );
348    gtk_tree_model_foreach( gtk_tree_view_get_model( view ), getActiveFilesForeach, &data );
349    return data.array;
350}
351
352static void
353setPriority( FileData * data, int priority )
354{
355    GtkTreeView * view = GTK_TREE_VIEW( data->view );
356    GArray * a = getActiveFiles( view );
357    tr_torrentSetFilePriorities( tr_torrent_handle( data->gtor ),
358                                 (tr_file_index_t*)a->data,
359                                 (tr_file_index_t)a->len,
360                                 priority );
361    refresh( data );
362    g_array_free( a, TRUE );
363}
364
365
366static void
367setDownload( FileData * data, int do_download )
368{
369    GtkTreeView * view = GTK_TREE_VIEW( data->view );
370    GArray * a = getActiveFiles( view );
371    tr_torrentSetFileDLs ( tr_torrent_handle( data->gtor ),
372                           (tr_file_index_t*)a->data,
373                           (tr_file_index_t)a->len,
374                           do_download );
375    refresh( data );
376    g_array_free( a, TRUE );
377}
378
379static void
380onHighClicked( GtkButton * button UNUSED, gpointer gdata )
381{
382    setPriority( gdata, TR_PRI_HIGH );
383}
384static void
385onNormalClicked( GtkButton * button UNUSED, gpointer gdata )
386{
387    setPriority( gdata, TR_PRI_NORMAL );
388}
389static void
390onLowClicked( GtkButton * button UNUSED, gpointer gdata )
391{
392    setPriority( gdata, TR_PRI_LOW );
393}
394static void
395onDownloadClicked( GtkButton * button UNUSED, gpointer gdata )
396{
397    setDownload( gdata, TRUE );
398}
399static void
400onIgnoreClicked( GtkButton * button UNUSED, gpointer gdata )
401{
402    setDownload( gdata, FALSE );
403}
404
405/***
406****
407***/
408
409void
410file_list_set_torrent( GtkWidget * w, TrTorrent * gtor )
411{
412    GtkTreeStore        * store;
413    FileData            * data;
414
415    data = g_object_get_data( G_OBJECT( w ), "file-data" );
416
417    /* unset the old fields */
418    clearData( data );
419
420    /* instantiate the model */
421    store = gtk_tree_store_new ( N_FILE_COLS,
422                                 G_TYPE_STRING,    /* stock */
423                                 G_TYPE_STRING,    /* label */
424                                 G_TYPE_INT,       /* prog [0..100] */
425                                 G_TYPE_STRING,    /* key */
426                                 G_TYPE_UINT,      /* index */
427                                 G_TYPE_UINT64,    /* size */
428                                 G_TYPE_UINT64,    /* have */
429                                 G_TYPE_INT,       /* priority */
430                                 G_TYPE_BOOLEAN,   /* dl enabled */
431                                 G_TYPE_BOOLEAN,   /* is file */
432                                 G_TYPE_UINT64,    /* sub size */
433                                 G_TYPE_UINT64,    /* sub have */
434                                 G_TYPE_INT );     /* sub state */
435    data->store = store;
436    data->model = GTK_TREE_MODEL( store );
437    data->gtor = gtor;
438
439
440    /* populate the model */
441    if( gtor )
442    {
443        tr_file_index_t i;
444        const tr_info * inf = tr_torrent_info( gtor );
445        tr_torrent * tor = tr_torrent_handle( gtor );
446
447        for( i=0; inf && i<inf->fileCount; ++i )
448        {
449            const char * path = inf->files[i].name;
450            const char * base = g_path_is_absolute( path ) ? g_path_skip_root( path ) : path;
451            parsepath( tor, store, NULL, base, i, inf->files[i].length );
452        }
453
454        refresh( data );
455
456        data->timeout_tag = g_timeout_add( 2500, refreshModel, data );
457    }
458
459    gtk_tree_view_set_model( GTK_TREE_VIEW( data->view ), GTK_TREE_MODEL( store ) );
460    gtk_tree_view_expand_all( GTK_TREE_VIEW( data->view ) );
461}
462
463/***
464****
465***/
466
467static void
468renderProgress( GtkTreeViewColumn  * column UNUSED,
469                GtkCellRenderer    * renderer,
470                GtkTreeModel       * model,
471                GtkTreeIter        * iter,
472                gpointer             data UNUSED)
473{
474    gboolean is_file;
475    uint64_t size, have, subsize, subhave;
476    double progress;
477    gtk_tree_model_get( model, iter, FC_SIZE, &size,
478                                     FC_HAVE, &have,
479                                     FC_SUB_SIZE, &subsize,
480                                     FC_SUB_HAVE, &subhave,
481                                     FC_IS_FILE, &is_file,
482                                     -1 );
483    progress = is_file ? tr_getRatio( have, size )
484                       : tr_getRatio( subhave, subsize );
485    g_object_set( renderer, "value", (int)(progress*100), NULL );
486}
487
488static void
489renderFilename( GtkTreeViewColumn  * column UNUSED,
490                GtkCellRenderer    * renderer,
491                GtkTreeModel       * model,
492                GtkTreeIter        * iter,
493                gpointer             data UNUSED)
494{
495    char * filename;
496    char * str;
497    int64_t size;
498    int64_t subsize;
499    gboolean is_file;
500    char buf[64];
501    gtk_tree_model_get( model, iter, FC_LABEL, &filename,
502                                     FC_SIZE, &size,
503                                     FC_SUB_SIZE, &subsize,
504                                     FC_IS_FILE, &is_file,
505                                     -1 );
506    tr_strlsize( buf, is_file ? size : subsize, sizeof( buf ) );
507    str = g_markup_printf_escaped( "<small>%s (%s)</small>",
508                                   filename, buf );
509    g_object_set( renderer, "markup", str, NULL );
510    g_free( str );
511    g_free( filename );
512}
513
514static void
515renderDownload( GtkTreeViewColumn  * column UNUSED,
516                GtkCellRenderer    * renderer,
517                GtkTreeModel       * model,
518                GtkTreeIter        * iter,
519                gpointer             data UNUSED)
520{
521    int sub_state;
522    gboolean enabled;
523    gboolean is_file = FALSE;
524    const char * text;
525
526    gtk_tree_model_get( model, iter, FC_IS_FILE, &is_file,
527                                     FC_ENABLED, &enabled,
528                                     FC_SUB_STATE, &sub_state,
529                                     -1 );
530    if( is_file && enabled )
531        text = _( "Yes" );
532    else if( is_file )
533        text = _( "No" );
534    else switch( sub_state & SUB_STATE_DOWNLOAD_MASK ) {
535        case SUB_STATE_DOWNLOAD: text = _( "Yes" );   break;
536        case SUB_STATE_IGNORE:   text = _( "No" );    break;
537        default:                 text = _( "Mixed" ); break;
538    }
539
540    g_object_set( renderer, "text", text,
541                            "xalign", (gfloat)0.5,
542                            "yalign", (gfloat)0.5,
543                            NULL );
544}
545
546static void
547renderPriority( GtkTreeViewColumn  * column UNUSED,
548                GtkCellRenderer    * renderer,
549                GtkTreeModel       * model,
550                GtkTreeIter        * iter,
551                gpointer             data UNUSED)
552{
553    int priority;
554    int sub_state;
555    gboolean is_file = FALSE;
556    const char * text = "";
557    gtk_tree_model_get( model, iter, FC_IS_FILE, &is_file,
558                                     FC_PRIORITY, &priority,
559                                     FC_SUB_STATE, &sub_state,
560                                     -1 );
561    if( !is_file )
562    {
563        switch( sub_state & SUB_STATE_PRIORITY_MASK )
564        {
565            case SUB_STATE_HIGH:   priority = TR_PRI_HIGH;   break;
566            case SUB_STATE_NORMAL: priority = TR_PRI_NORMAL; break;
567            case SUB_STATE_LOW:    priority = TR_PRI_LOW;    break;
568            default:               priority = 666;           break;
569        }
570    }
571
572    switch( priority )
573    {
574        case TR_PRI_HIGH: text = _( "High" );
575                          break;
576        case TR_PRI_NORMAL: text = _( "Normal" );
577                            break;
578        case TR_PRI_LOW: text = _( "Low" );
579                         break;
580        default: text = _( "Mixed" );
581                 break;
582    }
583
584    g_object_set( renderer, "text", text,
585                            "xalign", (gfloat)0.5,
586                            "yalign", (gfloat)0.5,
587                            NULL );
588}
589
590GtkWidget *
591file_list_new( TrTorrent * gtor )
592{
593    GtkWidget           * ret;
594    FileData            * data;
595    GtkWidget           * view, * scroll;
596    GtkCellRenderer     * rend;
597    GtkTreeViewColumn   * col;
598    GtkTreeSelection    * sel;
599    GtkWidget           * hbox;
600    GtkWidget           * vbox;
601    GtkWidget           * w;
602
603    /* create the view */
604    view = gtk_tree_view_new( );
605    gtk_tree_view_set_rules_hint( GTK_TREE_VIEW( view ), TRUE );
606    gtk_container_set_border_width( GTK_CONTAINER( view ), GUI_PAD_BIG );
607
608    /* set up view */
609    sel = gtk_tree_view_get_selection( GTK_TREE_VIEW( view ) );
610    gtk_tree_selection_set_mode( sel, GTK_SELECTION_MULTIPLE );
611    gtk_tree_view_expand_all( GTK_TREE_VIEW( view ) );
612    gtk_tree_view_set_search_column( GTK_TREE_VIEW( view ), FC_LABEL );
613
614    /* add file column */
615   
616    col = GTK_TREE_VIEW_COLUMN (g_object_new (GTK_TYPE_TREE_VIEW_COLUMN,
617        "expand", TRUE,
618    /* Translators: this is a column header in Files tab, Details dialog;
619       Don't include the prefix "filedetails|" in the translation. */                                 
620        "title", Q_("filedetails|File"),
621        NULL));
622    rend = gtk_cell_renderer_pixbuf_new();
623    gtk_tree_view_column_pack_start( col, rend, FALSE );
624    gtk_tree_view_column_add_attribute( col, rend, "stock-id", FC_STOCK );
625    /* add text renderer */
626    rend = gtk_cell_renderer_text_new();
627    g_object_set( rend, "ellipsize", PANGO_ELLIPSIZE_END, NULL );
628    gtk_tree_view_column_pack_start( col, rend, TRUE );
629    gtk_tree_view_column_set_cell_data_func( col, rend, renderFilename, NULL, NULL);
630    gtk_tree_view_append_column( GTK_TREE_VIEW( view ), col );
631
632
633    rend = gtk_cell_renderer_progress_new( );
634    /* Translators: this is a column header in Files tab, Details dialog;
635       Don't include the prefix "filedetails|" in the translation. */ 
636    col = gtk_tree_view_column_new_with_attributes( Q_("filedetails|Progress"), rend, NULL );
637    gtk_tree_view_column_set_cell_data_func( col, rend, renderProgress, NULL, NULL);
638    gtk_tree_view_append_column ( GTK_TREE_VIEW( view ), col);
639
640    /* add "enabled" column */
641    rend = gtk_cell_renderer_text_new( );
642    /* Translators: this is a column header in Files tab, Details dialog;
643       Don't include the prefix "filedetails|" in the translation.
644       The items for this column are checkboxes (yes/no) */ 
645    col = gtk_tree_view_column_new_with_attributes( Q_( "filedetails|Download" ), rend, NULL );
646    gtk_tree_view_column_set_cell_data_func( col, rend, renderDownload, NULL, NULL);
647    gtk_tree_view_append_column ( GTK_TREE_VIEW( view ), col);
648
649    /* add priority column */
650    rend = gtk_cell_renderer_text_new( );
651    col = gtk_tree_view_column_new_with_attributes( _( "Priority" ), rend, NULL );
652    gtk_tree_view_column_set_cell_data_func( col, rend, renderPriority, NULL, NULL);
653    gtk_tree_view_append_column ( GTK_TREE_VIEW( view ), col);
654
655    /* create the scrolled window and stick the view in it */
656    scroll = gtk_scrolled_window_new( NULL, NULL );
657    gtk_scrolled_window_set_policy( GTK_SCROLLED_WINDOW( scroll ),
658                                    GTK_POLICY_NEVER, GTK_POLICY_AUTOMATIC );
659    gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW(scroll),
660                                         GTK_SHADOW_IN);
661    gtk_container_add( GTK_CONTAINER( scroll ), view );
662    gtk_widget_set_size_request (scroll, -1, 200 );
663
664    data = g_new0( FileData, 1 );
665
666    vbox = gtk_vbox_new( FALSE, GUI_PAD );
667        w = gtk_button_new_with_mnemonic( _( "_High" ) );
668        g_signal_connect( w, "clicked", G_CALLBACK(onHighClicked), data );
669        gtk_box_pack_start( GTK_BOX( vbox ), w, FALSE, FALSE, 0 );
670        w = gtk_button_new_with_mnemonic( _( "_Normal" ) );
671        g_signal_connect( w, "clicked", G_CALLBACK(onNormalClicked), data );
672        gtk_box_pack_start( GTK_BOX( vbox ), w, FALSE, FALSE, 0 );
673        w = gtk_button_new_with_mnemonic( _( "_Low" ) );
674        g_signal_connect( w, "clicked", G_CALLBACK(onLowClicked), data );
675        gtk_box_pack_start( GTK_BOX( vbox ), w, FALSE, FALSE, 0 );
676        w = gtk_button_new_with_mnemonic( _( "_Ignore" ) );
677        g_signal_connect( w, "clicked", G_CALLBACK(onIgnoreClicked), data );
678        gtk_box_pack_end( GTK_BOX( vbox ), w, FALSE, FALSE, 0 );
679        w = gtk_button_new_with_mnemonic( _( "_Download" ) );
680        g_signal_connect( w, "clicked", G_CALLBACK(onDownloadClicked), data );
681        gtk_box_pack_end( GTK_BOX( vbox ), w, FALSE, FALSE, 0 );
682    hbox = gtk_hbox_new( FALSE, GUI_PAD );
683    gtk_box_pack_start_defaults( GTK_BOX( hbox ), scroll );
684    gtk_box_pack_start( GTK_BOX( hbox ), vbox, 0, 0, 0 );
685
686    ret = hbox;
687    data->view = view;
688    data->top = scroll;
689    g_object_set_data_full( G_OBJECT( ret ), "file-data", data, freeData );
690    file_list_set_torrent( ret, gtor );
691
692    return ret;
693}
Note: See TracBrowser for help on using the repository browser.