← Back to branch summary

~ubuntu-branches/ubuntu/hardy/avidemux/hardy

« back to all changes in this revision

Viewing changes to avidemux/ADM_filter/gui_filtermanager.cpp

  • Committer: Bazaar Package Importer
  • Author(s): Daniel T Chen
  • Date: 2006-12-15 17:13:20 UTC
  • mfrom: (1.1.6 upstream)
  • Revision ID: james.westby@ubuntu.com-20061215171320-w79pvpehxx2fr217
Tags: 1:2.3.0-0.0ubuntu1
* Merge from debian-multimedia.org, remaining Ubuntu change:
  - desktop file,
  - no support for ccache and make -j.
* Closes Ubuntu: #69614.

Show diffs side-by-side

added added

removed removed

Lines of Context:
avidemux/ADM_filter/gui_filtermanager.cpp
 
1
/***************************************************************************
 
2
 *                                                                         *
 
3
 *   This program is free software; you can redistribute it and/or modify  *
 
4
 *   it under the terms of the GNU General Public License as published by  *
 
5
 *   the Free Software Foundation; either version 2 of the License, or     *
 
6
 *   (at your option) any later version.                                   *
 
7
 *                                                                         *
 
8
 ***************************************************************************/
 
9
#include "config.h"
 
10
//#include "prototype.h"
 
11
#include <gtk/gtk.h>
 
12
#include <gdk/gdkkeysyms.h>
 
13
#include "avi_vars.h"
 
14
#include "ADM_toolkit/toolkit.hxx"
 
15
#include <ADM_assert.h>
 
16
#include "ADM_toolkit/filesel.h"
 
17
#include "ADM_video/ADM_genvideo.hxx"
 
18
#include "ADM_filter/video_filters.h"
 
19
#include "ADM_video/ADM_vidPartial.h"
 
20
#include "ADM_gui2/support.h"
 
21
#include "ADM_toolkit/toolkit_gtk.h"
 
22
#include "ADM_filter/vidVCD.h"
 
23
//___________________________________________
 
24
typedef enum gui_act
 
25
{
 
26
  A_BEGIN = 10,
 
27
  A_ADD,
 
28
  A_CONFIGURE,
 
29
  A_UP,
 
30
  A_DOWN,
 
31
  A_REMOVE,
 
32
  A_DONE,
 
33
  A_VCD,
 
34
  A_SVCD,
 
35
  A_DVD,
 
36
  A_HALFD1,
 
37
  A_LOAD,
 
38
  A_SAVE,
 
39
  A_PREVIEW,
 
40
  A_PARTIAL,
 
41
  A_SCRIPT,
 
42
  A_CLOSE,
 
43
  A_DOUBLECLICK,
 
44
  A_END
 
45
};
 
46
//___________________________________________
 
47
extern AVDMGenericVideoStream *filterCreateFromTag (VF_FILTERS tag,
 
48
                                                    CONFcouple * conf,
 
49
                                                    AVDMGenericVideoStream *
 
50
                                                    in);
 
51
extern const char  *filterGetNameFromTag(VF_FILTERS tag);
 
52
//___________________________________________
 
53
extern FILTER_ENTRY allfilters[MAX_FILTER];
 
54
extern uint32_t nb_video_filter;
 
55
extern FILTER videofilters[MAX_FILTER];
 
56
extern uint32_t nb_active_filter;
 
57
extern ADM_Composer *video_body;
 
58
//___________________________________________
 
59
static gulong row_inserted_id;
 
60
static gulong row_deleted_id;
 
61
 
 
62
static void on_treeview0_row_deleted(GtkTreeModel *treemodel, GtkTreePath *arg1, gpointer user_data);
 
63
static void on_treeview0_row_inserted(GtkTreeModel *treemodel, GtkTreePath *arg1, GtkTreeIter *arg2, gpointer user_data);
 
64
static void on_treeview1_size_allocate(GtkWidget *widget, GtkAllocation *allocation, GtkCellRenderer *cell);
 
65
static void on_action (gui_act action);
 
66
static void on_action_double_click (GtkButton * button, gpointer user_data);
 
67
static void on_action_double_click_1 (GtkButton * button, gpointer user_data);
 
68
static void updateFilterList (void);
 
69
static VF_FILTERS getFilterFromSelection (void);
 
70
static void wrapToolButton(GtkWidget * wid, gpointer user_data);
 
71
//___________________________________________
 
72
#define NB_TREE 8
 
73
static  uint32_t max = 0;
 
74
static  GtkWidget *trees[NB_TREE];
 
75
static  GtkListStore *stores[NB_TREE];
 
76
static  GtkTreeViewColumn *columns[NB_TREE];
 
77
static  GtkCellRenderer *renderers[NB_TREE];
 
78
static  int startFilter[NB_TREE];
 
79
//___________________________________________
 
80
static GtkWidget *createFilterDialog (void);
 
81
extern GtkWidget *create_dialog1 (void);
 
82
static GtkWidget *dialog = 0;
 
83
//___________________________________________
 
84
 
 
85
 
 
86
// Open the main filter dialog and call the handlers
 
87
// if needed.
 
88
int
 
89
GUI_handleVFilter (void)
 
90
{
 
91
 
 
92
#ifndef HAVE_ENCODER
 
93
    return 0;
 
94
}
 
95
#else
 
96
    getLastVideoFilter ();      // expand video to full size
 
97
 
 
98
    // sanity check
 
99
    if (nb_active_filter == 0)
 
100
    {
 
101
        nb_active_filter = 1;
 
102
        videofilters[0].filter =
 
103
        new AVDMVideoStreamNull (video_body, frameStart,
 
104
                                 frameEnd - frameStart);
 
105
    }
 
106
        dialog = createFilterDialog();
 
107
        GdkWMDecoration decorations=(GdkWMDecoration)0;
 
108
        gtk_widget_realize(dialog);
 
109
        gdk_window_set_decorations(dialog->window, (GdkWMDecoration)(GDK_DECOR_ALL | GDK_DECOR_MINIMIZE));
 
110
        GdkScreen* screen = gdk_screen_get_default();
 
111
        gint width = gdk_screen_get_width(screen);
 
112
        if(width>=1024)
 
113
            gtk_window_set_default_size(GTK_WINDOW(dialog), 900, 600);
 
114
        updateFilterList ();
 
115
        gtk_register_dialog (dialog);
 
116
        //gtk_widget_show (dialog);
 
117
        int r;
 
118
        while(1)
 
119
        {
 
120
          r=gtk_dialog_run(GTK_DIALOG(dialog));
 
121
          if(r>A_BEGIN && r<A_END)
 
122
          {
 
123
            on_action((gui_act)r);
 
124
          }
 
125
          else break;
 
126
        };
 
127
        gtk_unregister_dialog (dialog);
 
128
        gtk_widget_destroy(dialog);
 
129
        dialog=NULL;
 
130
        
 
131
    return 1;
 
132
    
 
133
}
 
134
 
 
135
// gtk_dialog_add_action_widget seems buggy for toolbar button
 
136
// workaround it...
 
137
void
 
138
wrapToolButton(GtkWidget * wid, gpointer user_data)
 
139
{
 
140
        gui_act action;
 
141
#ifdef ARCH_64_BITS
 
142
#define TPE long long int
 
143
        long long int dummy;
 
144
#else
 
145
        int dummy;
 
146
#define TPE int
 
147
#endif
 
148
 
 
149
        dummy=(TPE)user_data;
 
150
 
 
151
        action=(gui_act) dummy;
 
152
        on_action(action);
 
153
}
 
154
//
 
155
// One of the button of the main dialog was pressed
 
156
// Retrieve also the associated filter and handle
 
157
// the action
 
158
//______________________________________________________
 
159
void on_action (gui_act action)
 
160
{
 
161
    uint32_t action_parameter;
 
162
    VF_FILTERS tag = VF_INVALID;
 
163
 
 
164
    action_parameter = 0;
 
165
    if (nb_active_filter > 1)
 
166
        if (getSelectionNumber(nb_active_filter - 1,
 
167
                                WID(treeview0),
 
168
                                stores[0],
 
169
                                &action_parameter))
 
170
            action_parameter++;
 
171
 
 
172
    switch (action)
 
173
    {
 
174
 
 
175
    case A_ADD:
 
176
        tag = getFilterFromSelection();
 
177
        if (tag == VF_INVALID) break;
 
178
        CONFcouple *coup;
 
179
        videofilters[nb_active_filter].filter =
 
180
            filterCreateFromTag (tag, NULL, videofilters[nb_active_filter - 1].filter);
 
181
        if(!videofilters[nb_active_filter].filter->
 
182
                    configure (videofilters[nb_active_filter - 1].filter))
 
183
        {
 
184
            delete videofilters[nb_active_filter].filter;
 
185
            break;
 
186
        }
 
187
        videofilters[nb_active_filter].filter->getCoupledConf (&coup);
 
188
        videofilters[nb_active_filter].tag = tag;
 
189
        videofilters[nb_active_filter].conf = coup;
 
190
        nb_active_filter++;
 
191
        updateFilterList ();
 
192
        setSelectionNumber(nb_active_filter-1, WID(treeview0), stores[0], nb_active_filter-2);
 
193
        break;
 
194
 
 
195
    case A_VCD:
 
196
        setVCD ();
 
197
        updateFilterList ();
 
198
        setSelectionNumber(nb_active_filter-1, WID(treeview0), stores[0], nb_active_filter-2);
 
199
        break;
 
200
 
 
201
    case A_SVCD:
 
202
        setSVCD ();
 
203
        updateFilterList ();
 
204
        setSelectionNumber(nb_active_filter-1, WID(treeview0), stores[0], nb_active_filter-2);
 
205
        break;
 
206
 
 
207
    case A_DVD:
 
208
        setDVD ();
 
209
        updateFilterList ();
 
210
        setSelectionNumber(nb_active_filter-1, WID(treeview0), stores[0], nb_active_filter-2);
 
211
        break;
 
212
 
 
213
    case A_HALFD1:
 
214
        setHalfD1 ();
 
215
        updateFilterList ();
 
216
        setSelectionNumber(nb_active_filter-1, WID(treeview0), stores[0], nb_active_filter-2);
 
217
        break;
 
218
 
 
219
    default:
 
220
    case A_DOUBLECLICK:
 
221
        printf ("Double clicked..");
 
222
    case A_CONFIGURE:
 
223
        if(!action_parameter) break;
 
224
        if(!videofilters[action_parameter].filter->
 
225
            configure (videofilters[action_parameter - 1].filter)) break;
 
226
        CONFcouple *couple;
 
227
        videofilters[action_parameter].filter->getCoupledConf (&couple);
 
228
        videofilters[action_parameter].conf = couple;
 
229
        getFirstVideoFilter ();
 
230
        updateFilterList ();
 
231
        setSelectionNumber(nb_active_filter-1, WID(treeview0), stores[0], action_parameter-1);
 
232
        break;
 
233
 
 
234
    case A_PARTIAL:
 
235
        if (!action_parameter) break;
 
236
        AVDMGenericVideoStream *replace;
 
237
        CONFcouple *conf;
 
238
        conf = videofilters[action_parameter].conf;
 
239
        if (videofilters[action_parameter].tag == VF_PARTIAL)   // cannot recurse
 
240
        {
 
241
            GUI_Error_HIG (_("The filter is already partial"), NULL);
 
242
            break;
 
243
            }
 
244
        replace =
 
245
                new ADMVideoPartial (videofilters[action_parameter - 1].
 
246
                                     filter,
 
247
                                     videofilters[action_parameter].tag,
 
248
                                     conf);
 
249
        if(replace->configure (videofilters[action_parameter - 1].filter))
 
250
        {
 
251
            delete videofilters[action_parameter].filter;
 
252
                        if (conf) delete conf;
 
253
                        videofilters[action_parameter].filter = replace;
 
254
                        replace->getCoupledConf (&conf);
 
255
                        videofilters[action_parameter].conf = conf;
 
256
                        videofilters[action_parameter].tag = VF_PARTIAL;
 
257
                        getFirstVideoFilter ();
 
258
                        updateFilterList ();
 
259
                        setSelectionNumber(nb_active_filter-1, WID(treeview0), stores[0], action_parameter-1);
 
260
        }
 
261
        else delete replace;
 
262
        break;
 
263
 
 
264
    case A_UP:
 
265
        if (action_parameter < 2) break;
 
266
        // swap action parameter & action parameter -1
 
267
        FILTER tmp;
 
268
        memcpy (&tmp, &videofilters[action_parameter - 1], sizeof (FILTER));
 
269
        memcpy (&videofilters[action_parameter - 1],
 
270
            &videofilters[action_parameter], sizeof (FILTER));
 
271
        memcpy (&videofilters[action_parameter], &tmp, sizeof (FILTER));
 
272
        getFirstVideoFilter ();
 
273
        // select action_parameter -1
 
274
        updateFilterList ();
 
275
        setSelectionNumber (nb_active_filter - 1,
 
276
                              WID(treeview0),
 
277
                              stores[0], action_parameter - 2);
 
278
        break;
 
279
 
 
280
    case A_DOWN:
 
281
        if (((int) action_parameter < (int) (nb_active_filter - 1)) && (action_parameter))
 
282
        {
 
283
            // swap action parameter & action parameter -1
 
284
            FILTER tmp;
 
285
            memcpy (&tmp, &videofilters[action_parameter + 1], sizeof (FILTER));
 
286
            memcpy (&videofilters[action_parameter + 1],
 
287
                        &videofilters[action_parameter], sizeof (FILTER));
 
288
            memcpy (&videofilters[action_parameter], &tmp, sizeof (FILTER));
 
289
            getFirstVideoFilter ();
 
290
            updateFilterList ();
 
291
            setSelectionNumber (nb_active_filter - 1,
 
292
                              WID(treeview0),
 
293
                              stores[0], action_parameter);
 
294
        }
 
295
        break;
 
296
 
 
297
    case A_REMOVE:
 
298
                VF_FILTERS tag;
 
299
                AVDMGenericVideoStream *old;
 
300
                // we store the one we will delete
 
301
                if (action_parameter < 1) break;
 
302
                if (videofilters[action_parameter].conf)
 
303
                {
 
304
                        delete videofilters[action_parameter].conf;
 
305
                        videofilters[action_parameter].conf = NULL;
 
306
                }
 
307
                // recreate derivated filters
 
308
                for (uint32_t i = action_parameter + 1; i < nb_active_filter; i++)
 
309
            {
 
310
                        delete videofilters[i - 1].filter;
 
311
                        videofilters[i - 1].filter = filterCreateFromTag(videofilters[i].tag,
 
312
                                                                                                                         videofilters[i].conf,
 
313
                                                                                                                         videofilters[i - 2].filter);
 
314
                        videofilters[i - 1].conf = videofilters[i].conf;
 
315
                        videofilters[i - 1].tag = videofilters[i].tag;
 
316
            }
 
317
                delete videofilters[nb_active_filter - 1].filter;
 
318
                videofilters[nb_active_filter - 1].filter = NULL;
 
319
                nb_active_filter--;
 
320
        updateFilterList ();
 
321
        if(!setSelectionNumber(nb_active_filter-1, WID(treeview0), stores[0], action_parameter-1))
 
322
            setSelectionNumber(nb_active_filter-1, WID(treeview0), stores[0], action_parameter-2);
 
323
                break;
 
324
 
 
325
    case A_DONE:
 
326
 
 
327
        break;
 
328
 
 
329
    case A_PREVIEW:
 
330
        if (!action_parameter) break;
 
331
        AVDMGenericVideoStream *in;
 
332
        uint32_t w, h, l, f;
 
333
        ADMImage *data;
 
334
        extern uint32_t curframe;
 
335
        in = videofilters[action_parameter].filter;
 
336
        w = in->getInfo ()->width;
 
337
        h = in->getInfo ()->height;
 
338
        data = new ADMImage (w, h);     //(uint8_t *) malloc (w * h * 3);
 
339
        ADM_assert (data);
 
340
        in->getFrameNumberNoAlloc (curframe, &l, data, &f);
 
341
        GUI_PreviewShow(w,h,data->data);
 
342
        ADM_dealloc (data);
 
343
        break;
 
344
 
 
345
    case A_LOAD:
 
346
#ifdef USE_LIBXML2
 
347
        GUI_FileSelRead (_("Load set of filters"), filterLoadXml);
 
348
#else
 
349
        GUI_FileSelRead (_("Load set of filters"), filterLoad);
 
350
#endif
 
351
        updateFilterList ();
 
352
        setSelectionNumber(nb_active_filter-1, WID(treeview0), stores[0], 0);
 
353
        break;
 
354
    case A_CLOSE:
 
355
        //gtk_widget_destroy(dialog);
 
356
      gtk_signal_emit_by_name(GTK_OBJECT(dialog),"delete-event");
 
357
        
 
358
        break;
 
359
    case A_SAVE:
 
360
        if (nb_active_filter < 2)
 
361
        {
 
362
            GUI_Error_HIG (_("Nothing to save"), NULL);
 
363
        }
 
364
        else
 
365
#ifdef USE_LIBXML2
 
366
            GUI_FileSelWrite (_("Save set of filters"), filterSaveXml);
 
367
#else
 
368
            GUI_FileSelWrite (_("Save set of filters"), filterSave);
 
369
#endif
 
370
        break;
 
371
#if 0
 
372
    default:
 
373
        printf ("Unknown action :%d, action param %d\n", action, action_parameter);
 
374
        ADM_assert (0);
 
375
#endif
 
376
    } //end of switch
 
377
}
 
378
/*
 
379
        Pop-up a list of all available filters
 
380
        Return the tag identifying the filter selected
 
381
*/
 
382
VF_FILTERS
 
383
getFilterFromSelection (void)
 
384
{
 
385
    uint32_t sel = 0;
 
386
        uint8_t ret = 0;
 
387
    VF_FILTERS tag = VF_INVALID;
 
388
    // 1- identify the current tab/treeview we are in
 
389
    int page = gtk_notebook_get_current_page(GTK_NOTEBOOK(lookup_widget(dialog,"notebook1")));
 
390
    // then get the selection
 
391
    page++;
 
392
    if ((ret = getSelectionNumber (max, trees[page], stores[page], &sel)))
 
393
        {
 
394
        tag = allfilters[sel+startFilter[page]].tag;
 
395
        }
 
396
    return tag;
 
397
}
 
398
 
 
399
GtkWidget *
 
400
createFilterDialog (void)
 
401
{
 
402
    dialog = create_dialog1();
 
403
 
 
404
    //connect toolbar
 
405
#define CALLME_TOOLBAR(x,y) gtk_signal_connect(GTK_OBJECT(WID(x)),"clicked",  GTK_SIGNAL_FUNC(wrapToolButton), (void *) y);
 
406
#define CALLME(x,y) gtk_dialog_add_action_widget (GTK_DIALOG (dialog), WID(x), y)
 
407
 
 
408
        //CALLME (toolbuttonAdd, A_ADD);
 
409
        CALLME (buttonRemove,           A_REMOVE);
 
410
        CALLME (buttonProperties,       A_CONFIGURE);
 
411
        CALLME (buttonUp,               A_UP);
 
412
        CALLME (buttonDown,             A_DOWN);
 
413
        CALLME (buttonPreview,          A_PREVIEW);
 
414
        CALLME (buttonPartial,          A_PARTIAL);
 
415
        CALLME (buttonAdd,              A_ADD);
 
416
        
 
417
        CALLME_TOOLBAR (toolbuttonHalfD1,       A_HALFD1);
 
418
        CALLME_TOOLBAR (toolbuttonScript,       A_SCRIPT);
 
419
        CALLME_TOOLBAR (toolbuttonVCD,          A_VCD);
 
420
        CALLME_TOOLBAR (toolbuttonSVCD,         A_SVCD);
 
421
        CALLME_TOOLBAR (toolbuttonDVD,          A_DVD);
 
422
        CALLME_TOOLBAR (toolbuttonSave,         A_SAVE);
 
423
        CALLME_TOOLBAR (toolbuttonScript,       A_SAVE);
 
424
        CALLME_TOOLBAR (toolbuttonOpen,         A_LOAD);
 
425
        
 
426
 
 
427
    //create treeviews
 
428
    trees[0]=lookup_widget(dialog,"treeview0");
 
429
    stores[0]=gtk_list_store_new (3, G_TYPE_STRING, G_TYPE_INT, G_TYPE_POINTER);
 
430
    #define LOOK(x) {trees[x]=lookup_widget(dialog,"treeview"#x);\
 
431
                    stores[x]=gtk_list_store_new (1, G_TYPE_STRING);}
 
432
    LOOK(1);
 
433
    LOOK(2);
 
434
    LOOK(3);
 
435
    LOOK(4);
 
436
    LOOK(5);
 
437
    LOOK(6);
 
438
    LOOK(7);
 
439
 
 
440
    //load stores with filter names, get start filter for each page
 
441
    char *str=NULL;
 
442
    GtkTreeIter iter;
 
443
    int current_tree=0;
 
444
    for (uint32_t i = 0; i < nb_video_filter; i++)
 
445
    {
 
446
        if (allfilters[i].viewable==1)
 
447
        {
 
448
                
 
449
                 str = g_strconcat(
 
450
                                 "<span weight=\"bold\">", allfilters[i].name, "</span>\n",
 
451
                                //      "", allfilters[i].description, "", NULL);
 
452
                                        "<span size=\"smaller\">", allfilters[i].description, "</span>", NULL);
 
453
                                
 
454
            gtk_list_store_append (stores[current_tree], &iter);
 
455
            gtk_list_store_set (stores[current_tree], &iter, 0, str ,-1);
 
456
            g_free(str);
 
457
            max++;
 
458
        }else
 
459
        {
 
460
                current_tree++;
 
461
                if(current_tree>=NB_TREE) break;
 
462
                startFilter[current_tree]=i+1;
 
463
        }
 
464
    }
 
465
 
 
466
    //setup treeviews
 
467
    for(int i=0;i<NB_TREE;i++)
 
468
    {
 
469
        renderers[i] = gtk_cell_renderer_text_new();
 
470
                columns[i] = gtk_tree_view_column_new_with_attributes (
 
471
                            "",
 
472
                            renderers[i],
 
473
                            "markup", (GdkModifierType) 0,
 
474
                            NULL);
 
475
                gtk_cell_renderer_text_set_fixed_height_from_font
 
476
                        (GTK_CELL_RENDERER_TEXT(renderers[i]), 3);
 
477
        g_object_set(renderers[i], "wrap-width", 0, NULL);
 
478
        gtk_tree_view_append_column(GTK_TREE_VIEW (trees[i]), columns[i]);
 
479
        gtk_tree_view_set_model(GTK_TREE_VIEW(trees[i]),GTK_TREE_MODEL (stores[i]));
 
480
 
 
481
                // Add double click, 0 is active filter tree
 
482
        if(i)
 
483
                g_signal_connect (G_OBJECT(trees[i]),
 
484
                      "row-activated",
 
485
                      G_CALLBACK(on_action_double_click),
 
486
                      (void *) dialog);
 
487
                else
 
488
                {
 
489
            gtk_tree_view_set_reorderable(GTK_TREE_VIEW(trees[i]), true);
 
490
                        g_signal_connect(G_OBJECT(WID(treeview0)),
 
491
                                                "row-activated",
 
492
                                        G_CALLBACK(on_action_double_click_1),
 
493
                                        (void *)NULL);
 
494
                        row_inserted_id=g_signal_connect(G_OBJECT(stores[i]),
 
495
                                                "row-inserted",
 
496
                                        G_CALLBACK(on_treeview0_row_inserted),
 
497
                                        (void *)NULL);
 
498
                        row_deleted_id=g_signal_connect(G_OBJECT(stores[i]),
 
499
                                                "row-deleted",
 
500
                                        G_CALLBACK(on_treeview0_row_deleted),
 
501
                                        (void *)NULL);
 
502
                }
 
503
        g_signal_connect(G_OBJECT(trees[i]),
 
504
                      "size-allocate",
 
505
                      G_CALLBACK(on_treeview1_size_allocate),
 
506
                      renderers[i]);
 
507
    }
 
508
    return dialog;
 
509
}
 
510
 
 
511
void
 
512
updateFilterList (void)
 
513
{
 
514
    g_signal_handler_block(stores[0], row_inserted_id);
 
515
    g_signal_handler_block(stores[0], row_deleted_id);
 
516
    GtkTreeIter iter;
 
517
    char *str;
 
518
    VF_FILTERS fil;
 
519
    gtk_list_store_clear (stores[0]);
 
520
    for (uint32_t i = 1; i < nb_active_filter; i++)
 
521
    {
 
522
        gtk_list_store_append (stores[0], &iter);
 
523
        fil=videofilters[i].tag;
 
524
        str = g_strconcat("<span  weight=\"bold\">",
 
525
                            filterGetNameFromTag(fil),
 
526
                            "</span>\n",
 
527
                            "<span size=\"smaller\">", videofilters[i].filter->printConf (), "</span>",  NULL);
 
528
        gtk_list_store_set (stores[0], &iter,
 
529
                            0, str,
 
530
                            1, videofilters[i].tag,
 
531
                            2, videofilters[i].conf,
 
532
                            -1);
 
533
        g_free(str);
 
534
    }
 
535
    g_signal_handler_unblock(stores[0], row_inserted_id);
 
536
    g_signal_handler_unblock(stores[0], row_deleted_id);
 
537
}
 
538
 
 
539
void
 
540
on_action_double_click (GtkButton * button, gpointer user_data)
 
541
{
 
542
    on_action(A_ADD);
 
543
}
 
544
 
 
545
void
 
546
on_action_double_click_1 (GtkButton * button, gpointer user_data)
 
547
{
 
548
    on_action(A_DOUBLECLICK);
 
549
}
 
550
 
 
551
void
 
552
on_treeview1_size_allocate(GtkWidget *widget, GtkAllocation *allocation, GtkCellRenderer *cell)
 
553
{
 
554
    g_object_set(cell,
 
555
              "wrap-width", allocation->width-8,
 
556
              NULL);
 
557
}
 
558
 
 
559
void
 
560
on_treeview0_row_deleted(GtkTreeModel *treemodel, GtkTreePath *arg1, gpointer user_data)
 
561
{
 
562
    GtkTreeIter iter;
 
563
    VF_FILTERS                          tag;
 
564
        CONFcouple                              *conf = 0;
 
565
 
 
566
        gtk_tree_model_get_iter_first(GTK_TREE_MODEL(stores[0]), &iter);
 
567
                AVDMGenericVideoStream  *prevfilter = videofilters[0].filter;
 
568
                for (uint32_t i = 1; i < nb_active_filter; i++)
 
569
            {
 
570
            gtk_tree_model_get (GTK_TREE_MODEL(stores[0]), &iter,
 
571
                            1, &tag,
 
572
                            2, &conf,
 
573
                            -1);
 
574
                        delete videofilters[i].filter;
 
575
                        videofilters[i].filter = filterCreateFromTag(tag,
 
576
                                                        conf,
 
577
                                                        prevfilter);
 
578
                        videofilters[i].conf = conf;
 
579
                        videofilters[i].tag = tag;
 
580
                        prevfilter = videofilters[i].filter;
 
581
            gtk_tree_model_iter_next (GTK_TREE_MODEL(stores[0]), &iter);
 
582
            }
 
583
    updateFilterList();
 
584
    //on_action(A_REORDERED);
 
585
}
 
586
void
 
587
on_treeview0_row_inserted(GtkTreeModel *treemodel, GtkTreePath *arg1, GtkTreeIter *arg2, gpointer user_data)
 
588
{
 
589
 
 
590
 
 
591
}
 
592
 
 
593
#endif