← Back to branch summary

~ubuntu-branches/ubuntu/maverick/brasero/maverick

« back to all changes in this revision

Viewing changes to src/brasero-search.c

  • Committer: Bazaar Package Importer
  • Author(s): Robert Ancell
  • Date: 2009-11-26 16:20:01 UTC
  • mfrom: (1.1.34 upstream)
  • Revision ID: james.westby@ubuntu.com-20091126162001-adzp6h0x5ow9bc4b
Tags: 2.29.2-0ubuntu1
* New upstream release:
  - Integrate Brasero with PackageKit
  - Gobject-introspection support for libbrasero-media and libbrasero-burn
  - Added Tracker support for searches besides Beagle
  - Fix compile failure using --disable-introspection see bgo #602027
  - Removed deprecated GLib symbols fixes bgo #601040
  - Fix #601871 - Wrong remaining space when audio CD of size greater than 70
    min
  - Fix #601496 - Select disc image selector allows to selecd pictures
  - Fix #601109 - burning disks with burn:// doesn't set the disk label
  - Fix #601259 - Problems with folder depth
  - Fix #599655 - brasero crashed with SIGSEGV in g_main_context_dispatch()
  - Fix #588323 - crash in Disc Copier: Dragging a track from Banshee
  - Fix #600007 - Memory leaks in brasero
  - Fix #600293 - Fails to build error: cannot convert to a pointer type
* debian/control.in:
  - Bump build-depends on libglib2.0-dev
* debian/patches/012_build_error.patch:
  - Applied upstream
* debian/patches/010_lpi.patch:
* debian/patches/011_nautilus_menu_move.patch:
* debian/patches/99_autoconf.patch:
  - Refreshed

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/brasero-search.c
 
1
/* -*- Mode: C; indent-tabs-mode: t; c-basic-offset: 8; tab-width: 8 -*- */
 
2
 
 
3
/***************************************************************************
 
4
*            search.c
 
5
*
 
6
*  dim mai 22 11:20:54 2005
 
7
*  Copyright  2005  Philippe Rouquier
 
8
*  brasero-app@wanadoo.fr
 
9
****************************************************************************/
 
10
 
 
11
/*
 
12
 *  Brasero is free software; you can redistribute it and/or modify
 
13
 *  it under the terms of the GNU General Public License as published by
 
14
 *  the Free Software Foundation; either version 2 of the License, or
 
15
 *  (at your option) any later version.
 
16
 *
 
17
 *  Brasero is distributed in the hope that it will be useful,
 
18
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 
19
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 
20
 *  GNU Library General Public License for more details.
 
21
 *
 
22
 *  You should have received a copy of the GNU General Public License
 
23
 *  along with this program; if not, write to:
 
24
 *      The Free Software Foundation, Inc.,
 
25
 *      51 Franklin Street, Fifth Floor
 
26
 *      Boston, MA  02110-1301, USA.
 
27
 */
 
28
 
 
29
 
 
30
#ifdef HAVE_CONFIG_H
 
31
#  include <config.h>
 
32
#endif
 
33
 
 
34
#include <string.h>
 
35
 
 
36
#include <glib.h>
 
37
#include <glib/gi18n-lib.h>
 
38
#include <glib-object.h>
 
39
 
 
40
#include <gio/gio.h>
 
41
 
 
42
#include <gtk/gtk.h>
 
43
 
 
44
#include "brasero-search.h"
 
45
#include "brasero-search-engine.h"
 
46
 
 
47
#include "brasero-misc.h"
 
48
 
 
49
#include "brasero-app.h"
 
50
#include "brasero-utils.h"
 
51
#include "brasero-search-entry.h"
 
52
#include "brasero-mime-filter.h"
 
53
#include "brasero-search-engine.h"
 
54
#include "eggtreemultidnd.h"
 
55
 
 
56
#include "brasero-uri-container.h"
 
57
#include "brasero-layout-object.h"
 
58
 
 
59
 
 
60
struct BraseroSearchPrivate {
 
61
        GtkTreeViewColumn *sort_column;
 
62
 
 
63
        GtkWidget *tree;
 
64
        GtkWidget *entry;
 
65
        GtkWidget *filter;
 
66
        GtkWidget *filters;
 
67
        GtkWidget *right;
 
68
        GtkWidget *left;
 
69
        GtkWidget *results_label;
 
70
 
 
71
        BraseroSearchEngine *engine;
 
72
        gint first_hit;
 
73
 
 
74
        gint max_results;
 
75
 
 
76
        int id;
 
77
};
 
78
 
 
79
enum {
 
80
        TARGET_URIS_LIST,
 
81
};
 
82
 
 
83
static GtkTargetEntry ntables_find[] = {
 
84
        {"text/uri-list", 0, TARGET_URIS_LIST}
 
85
};
 
86
static guint nb_ntables_find = sizeof (ntables_find) / sizeof (ntables_find[0]);
 
87
 
 
88
#define BRASERO_SEARCH_SPACING 6
 
89
 
 
90
static void brasero_search_iface_uri_container_init (BraseroURIContainerIFace *iface);
 
91
static void brasero_search_iface_layout_object_init (BraseroLayoutObjectIFace *iface);
 
92
 
 
93
G_DEFINE_TYPE_WITH_CODE (BraseroSearch,
 
94
                         brasero_search,
 
95
                         GTK_TYPE_VBOX,
 
96
                         G_IMPLEMENT_INTERFACE (BRASERO_TYPE_URI_CONTAINER,
 
97
                                                brasero_search_iface_uri_container_init)
 
98
                         G_IMPLEMENT_INTERFACE (BRASERO_TYPE_LAYOUT_OBJECT,
 
99
                                                brasero_search_iface_layout_object_init));
 
100
 
 
101
 
 
102
 
 
103
static void
 
104
brasero_search_column_icon_cb (GtkTreeViewColumn *tree_column,
 
105
                               GtkCellRenderer *cell,
 
106
                               GtkTreeModel *model,
 
107
                               GtkTreeIter *iter,
 
108
                               gpointer data)
 
109
{
 
110
        GIcon *icon;
 
111
        const gchar *mime;
 
112
        gpointer hit = NULL;
 
113
 
 
114
        gtk_tree_model_get (model, iter,
 
115
                            BRASERO_SEARCH_TREE_HIT_COL, &hit,
 
116
                            -1);
 
117
 
 
118
        mime = brasero_search_engine_mime_from_hit (BRASERO_SEARCH (data)->priv->engine, hit);
 
119
        if (!mime)
 
120
                return;
 
121
        
 
122
        if (!strcmp (mime, "inode/directory"))
 
123
                mime = "x-directory/normal";
 
124
 
 
125
        icon = g_content_type_get_icon (mime);
 
126
        g_object_set (G_OBJECT (cell),
 
127
                      "gicon", icon,
 
128
                      NULL);
 
129
        g_object_unref (icon);
 
130
}
 
131
 
 
132
static gchar *
 
133
brasero_search_name_from_hit (BraseroSearch *search,
 
134
                              gpointer hit)
 
135
{
 
136
        gchar *name;
 
137
        const gchar *uri;
 
138
        gchar *unescaped_uri;
 
139
 
 
140
        uri = brasero_search_engine_uri_from_hit (search->priv->engine, hit);
 
141
 
 
142
        /* beagle can return badly formed uri not
 
143
         * encoded in UTF-8 locale charset so we
 
144
         * check them just in case */
 
145
        unescaped_uri = g_uri_unescape_string (uri, NULL);
 
146
        if (!g_utf8_validate (unescaped_uri, -1, NULL)) {
 
147
                g_free (unescaped_uri);
 
148
                return NULL;
 
149
        }
 
150
 
 
151
        name = g_path_get_basename (unescaped_uri);
 
152
        g_free (unescaped_uri);
 
153
        return name;
 
154
}
 
155
 
 
156
static void
 
157
brasero_search_column_name_cb (GtkTreeViewColumn *tree_column,
 
158
                               GtkCellRenderer *cell,
 
159
                               GtkTreeModel *model,
 
160
                               GtkTreeIter *iter,
 
161
                               gpointer data)
 
162
{
 
163
        gchar *name;
 
164
        gpointer hit = NULL;
 
165
 
 
166
        gtk_tree_model_get (model, iter,
 
167
                            BRASERO_SEARCH_TREE_HIT_COL, &hit,
 
168
                            -1);
 
169
 
 
170
        name = brasero_search_name_from_hit (data, hit);
 
171
        g_object_set (G_OBJECT (cell),
 
172
                      "text", name,
 
173
                      NULL);
 
174
        g_free (name);
 
175
}
 
176
 
 
177
static const gchar*
 
178
brasero_search_description_from_hit (BraseroSearch *search,
 
179
                                     gpointer hit)
 
180
{
 
181
        const gchar *mime;
 
182
 
 
183
        mime = brasero_search_engine_mime_from_hit (search->priv->engine, hit);
 
184
        if (!mime)
 
185
                return NULL;
 
186
 
 
187
        return g_content_type_get_description (mime);
 
188
}
 
189
 
 
190
static void
 
191
brasero_search_column_description_cb (GtkTreeViewColumn *tree_column,
 
192
                                      GtkCellRenderer *cell,
 
193
                                      GtkTreeModel *model,
 
194
                                      GtkTreeIter *iter,
 
195
                                      gpointer data)
 
196
{
 
197
        const gchar *description;
 
198
        gpointer hit = NULL;
 
199
 
 
200
        gtk_tree_model_get (model, iter,
 
201
                            BRASERO_SEARCH_TREE_HIT_COL, &hit,
 
202
                            -1);
 
203
 
 
204
        description = brasero_search_description_from_hit (data, hit);
 
205
        g_object_set (G_OBJECT (cell),
 
206
                      "text", description,
 
207
                      NULL);
 
208
}
 
209
 
 
210
static void
 
211
brasero_search_increase_activity (BraseroSearch *search)
 
212
{
 
213
        GdkCursor *cursor;
 
214
 
 
215
        cursor = gdk_cursor_new (GDK_WATCH);
 
216
        gdk_window_set_cursor (GTK_WIDGET (search)->window, cursor);
 
217
        gdk_cursor_unref (cursor);
 
218
}
 
219
 
 
220
static void
 
221
brasero_search_decrease_activity (BraseroSearch *search)
 
222
{
 
223
        gdk_window_set_cursor (GTK_WIDGET (search)->window, NULL);
 
224
}
 
225
 
 
226
static void
 
227
brasero_search_update_header (BraseroSearch *search)
 
228
{
 
229
        gchar *string;
 
230
        gint num_hits;
 
231
 
 
232
        num_hits = brasero_search_engine_num_hits (search->priv->engine);
 
233
        if (num_hits) {
 
234
                gint last;
 
235
                gchar *tmp;
 
236
 
 
237
                last = search->priv->first_hit + search->priv->max_results;
 
238
                last = MIN (last, num_hits);
 
239
 
 
240
                tmp = g_strdup_printf (_("Results %i–%i (out of %i)"),
 
241
                                       search->priv->first_hit + 1,
 
242
                                       last,
 
243
                                       num_hits);
 
244
                string = g_strdup_printf ("<b>%s</b>", tmp);
 
245
                g_free (tmp);
 
246
        }
 
247
        else
 
248
                string = g_strdup_printf ("<b>%s</b>", _("No results"));
 
249
 
 
250
        gtk_label_set_markup (GTK_LABEL (search->priv->results_label), string);
 
251
        g_free (string);
 
252
 
 
253
        if (search->priv->first_hit + search->priv->max_results < num_hits)
 
254
                gtk_widget_set_sensitive (search->priv->right, TRUE);
 
255
        else
 
256
                gtk_widget_set_sensitive (search->priv->right, FALSE);
 
257
 
 
258
        if (search->priv->first_hit > 0)
 
259
                gtk_widget_set_sensitive (search->priv->left, TRUE);
 
260
        else
 
261
                gtk_widget_set_sensitive (search->priv->left, FALSE);
 
262
}
 
263
 
 
264
static void
 
265
brasero_search_empty_tree (BraseroSearch *search)
 
266
{
 
267
        GtkTreeModel *model;
 
268
        GtkTreeModel *sort;
 
269
        GtkTreeIter row;
 
270
 
 
271
        sort = gtk_tree_view_get_model (GTK_TREE_VIEW (search->priv->tree));
 
272
        model = gtk_tree_model_filter_get_model (GTK_TREE_MODEL_FILTER (sort));
 
273
 
 
274
        if (gtk_tree_model_get_iter_first (model, &row)) {
 
275
                do {
 
276
                        gpointer hit;
 
277
                        const gchar *mime;
 
278
 
 
279
                        hit = NULL;
 
280
                        gtk_tree_model_get (model, &row,
 
281
                                            BRASERO_SEARCH_TREE_HIT_COL, &hit,
 
282
                                            -1);
 
283
 
 
284
                        if (!hit)
 
285
                                continue;
 
286
 
 
287
                        mime = brasero_search_engine_mime_from_hit (search->priv->engine, hit);
 
288
                        if (!mime)
 
289
                                continue;
 
290
 
 
291
                        brasero_mime_filter_unref_mime (BRASERO_MIME_FILTER (search->priv->filter), mime);
 
292
                } while (gtk_list_store_remove (GTK_LIST_STORE (model), &row));
 
293
        }
 
294
}
 
295
 
 
296
static void
 
297
brasero_search_row_inserted (GtkTreeModel *model,
 
298
                             GtkTreePath *path,
 
299
                             GtkTreeIter *iter,
 
300
                             BraseroSearch *search)
 
301
{
 
302
        const gchar *mime;
 
303
        gpointer hit = NULL;
 
304
 
 
305
        gtk_tree_model_get (model, iter,
 
306
                            BRASERO_SEARCH_TREE_HIT_COL, &hit,
 
307
                            -1);
 
308
 
 
309
        if (!hit)
 
310
                return;
 
311
 
 
312
        mime = brasero_search_engine_mime_from_hit (search->priv->engine, hit);
 
313
 
 
314
        if (mime) {
 
315
                /* add the mime type to the filter combo */
 
316
                brasero_mime_filter_add_mime (BRASERO_MIME_FILTER (search->priv->filter), mime);
 
317
        }
 
318
}
 
319
 
 
320
static gboolean
 
321
brasero_search_update_tree (BraseroSearch *search)
 
322
{
 
323
        GtkTreeModel *model;
 
324
        GtkTreeModel *sort;
 
325
        gint max_hits;
 
326
        gint last_hit;
 
327
 
 
328
        if (search->priv->first_hit < 0)
 
329
                search->priv->first_hit = 0;
 
330
 
 
331
        max_hits = brasero_search_engine_num_hits (search->priv->engine);
 
332
        if (search->priv->first_hit > max_hits) {
 
333
                search->priv->first_hit = max_hits;
 
334
                return FALSE;
 
335
        }
 
336
 
 
337
        last_hit = MIN (max_hits, search->priv->max_results + search->priv->first_hit);
 
338
 
 
339
        brasero_search_empty_tree (search);
 
340
 
 
341
        sort = gtk_tree_view_get_model (GTK_TREE_VIEW (search->priv->tree));
 
342
        model = gtk_tree_model_filter_get_model (GTK_TREE_MODEL_FILTER (sort));
 
343
 
 
344
        brasero_search_engine_add_hits (search->priv->engine,
 
345
                                        model,
 
346
                                        search->priv->first_hit,
 
347
                                        last_hit);
 
348
 
 
349
        brasero_search_update_header (search);
 
350
        return TRUE;
 
351
}
 
352
 
 
353
static void
 
354
brasero_search_left_button_clicked_cb (GtkButton *button,
 
355
                                       BraseroSearch *search)
 
356
{
 
357
        search->priv->first_hit -= search->priv->max_results;
 
358
        brasero_search_update_tree (search);
 
359
}
 
360
 
 
361
static void
 
362
brasero_search_right_button_clicked_cb (GtkButton *button,
 
363
                                        BraseroSearch *search)
 
364
{
 
365
        search->priv->first_hit += search->priv->max_results;
 
366
        brasero_search_update_tree (search);
 
367
}
 
368
 
 
369
static void
 
370
brasero_search_max_results_num_changed_cb (GtkComboBox *combo,
 
371
                                           BraseroSearch *search)
 
372
{
 
373
        gint index;
 
374
        gint page_num;
 
375
 
 
376
        if (search->priv->max_results)
 
377
                page_num = search->priv->first_hit / search->priv->max_results;
 
378
        else
 
379
                page_num = 0;
 
380
 
 
381
        index = gtk_combo_box_get_active (combo);
 
382
        switch (index) {
 
383
        case 0:
 
384
                search->priv->max_results = 20;
 
385
                break;
 
386
        case 1:
 
387
                search->priv->max_results = 50;
 
388
                break;
 
389
        case 2:
 
390
                search->priv->max_results = 100;
 
391
                break;
 
392
        }
 
393
 
 
394
        search->priv->first_hit = page_num * search->priv->max_results;
 
395
        brasero_search_update_tree (search);
 
396
}
 
397
 
 
398
static void
 
399
brasero_search_finished_cb (BraseroSearchEngine *engine,
 
400
                            BraseroSearch *search)
 
401
{
 
402
        brasero_search_decrease_activity (search);
 
403
}
 
404
 
 
405
static void
 
406
brasero_search_error_cb (BraseroSearchEngine *engine,
 
407
                         GError *error,
 
408
                         BraseroSearch *search)
 
409
{
 
410
        brasero_search_update_header (search);
 
411
        if (error)
 
412
                brasero_app_alert (brasero_app_get_default (),
 
413
                                   _("Error querying for keywords."),
 
414
                                   error->message,
 
415
                                   GTK_MESSAGE_ERROR);
 
416
 
 
417
        brasero_search_decrease_activity (search);
 
418
}
 
419
 
 
420
static void
 
421
brasero_search_hit_added_cb (BraseroSearchEngine *engine,
 
422
                             gpointer hit,
 
423
                             BraseroSearch *search)
 
424
{
 
425
        gint num;
 
426
        gint hit_num;
 
427
        GtkTreeIter iter;
 
428
        const gchar *mime;
 
429
        GtkTreeModel *model;
 
430
 
 
431
        hit_num = brasero_search_engine_num_hits (search->priv->engine);
 
432
        if (hit_num < search->priv->first_hit
 
433
        && hit_num >= search->priv->first_hit + search->priv->max_results) {
 
434
                brasero_search_update_header (search);
 
435
                return;
 
436
        }
 
437
 
 
438
        model = gtk_tree_view_get_model (GTK_TREE_VIEW (search->priv->tree));
 
439
        model = gtk_tree_model_filter_get_model (GTK_TREE_MODEL_FILTER (model));
 
440
 
 
441
        num = gtk_tree_model_iter_n_children (model, NULL);
 
442
        if (num >= search->priv->max_results) {
 
443
                brasero_search_update_header (search);
 
444
                return;
 
445
        }
 
446
 
 
447
        gtk_list_store_insert_with_values (GTK_LIST_STORE (model), &iter, -1,
 
448
                                           BRASERO_SEARCH_TREE_HIT_COL, hit,
 
449
                                           -1);
 
450
 
 
451
        mime = brasero_search_engine_mime_from_hit (search->priv->engine, hit);
 
452
        brasero_search_update_header (search);
 
453
}
 
454
 
 
455
static void
 
456
brasero_search_hit_removed_cb (BraseroSearchEngine *engine,
 
457
                               gpointer hit,
 
458
                               BraseroSearch *search)
 
459
{
 
460
        int num = 0;
 
461
        int range_end;
 
462
        int range_start;
 
463
        GtkTreeIter iter;
 
464
        GtkTreeModel *model;
 
465
 
 
466
        model = gtk_tree_view_get_model (GTK_TREE_VIEW (search->priv->tree));
 
467
        model = gtk_tree_model_filter_get_model (GTK_TREE_MODEL_FILTER (model));
 
468
 
 
469
        if (!gtk_tree_model_get_iter_first (model, &iter))
 
470
                return;
 
471
 
 
472
        do {
 
473
                gpointer model_hit;
 
474
 
 
475
                model_hit = NULL;
 
476
                gtk_tree_model_get (model, &iter,
 
477
                                    BRASERO_SEARCH_TREE_HIT_COL, &model_hit,
 
478
                                    -1);
 
479
 
 
480
                if (hit == model_hit) {
 
481
                        const gchar *mime;
 
482
 
 
483
                        mime = brasero_search_engine_mime_from_hit (search->priv->engine, hit);
 
484
                        brasero_mime_filter_unref_mime (BRASERO_MIME_FILTER (search->priv->filter), mime);
 
485
 
 
486
                        gtk_list_store_remove (GTK_LIST_STORE (model), &iter);
 
487
                        break;
 
488
                }
 
489
 
 
490
                num ++;
 
491
        } while (gtk_tree_model_iter_next (model, &iter));
 
492
 
 
493
        if (num < search->priv->first_hit
 
494
        && num >= search->priv->first_hit + search->priv->max_results) {
 
495
                brasero_search_update_header (search);
 
496
                return;
 
497
        }
 
498
 
 
499
        range_start = search->priv->first_hit + search->priv->max_results - 1;
 
500
        range_end = search->priv->first_hit + search->priv->max_results;
 
501
        brasero_search_engine_add_hits (search->priv->engine,
 
502
                                        model,
 
503
                                        range_start,
 
504
                                        range_end);
 
505
 
 
506
        brasero_search_update_header (search);
 
507
}
 
508
 
 
509
static void
 
510
brasero_search_entry_activated_cb (BraseroSearchEntry *entry,
 
511
                                   BraseroSearch *search)
 
512
{
 
513
        brasero_search_increase_activity (search);
 
514
 
 
515
        /* we first empty everything including the filter box */
 
516
        brasero_search_empty_tree (search);
 
517
        brasero_search_entry_set_query (entry, search->priv->engine);
 
518
        brasero_search_engine_start_query (search->priv->engine);
 
519
        brasero_search_update_header (search);
 
520
}
 
521
 
 
522
static gboolean
 
523
brasero_search_is_visible_cb (GtkTreeModel *model,
 
524
                              GtkTreeIter *iter,
 
525
                              BraseroSearch *search)
 
526
{
 
527
        const gchar *uri, *mime;
 
528
        gpointer hit = NULL;
 
529
        gboolean result;
 
530
        gchar *name;
 
531
 
 
532
        gtk_tree_model_get (model, iter,
 
533
                            BRASERO_SEARCH_TREE_HIT_COL, &hit,
 
534
                            -1);
 
535
 
 
536
        name = brasero_search_name_from_hit (search, hit);
 
537
        uri = brasero_search_engine_uri_from_hit (search->priv->engine, hit);
 
538
        mime = brasero_search_engine_mime_from_hit (search->priv->engine, hit);
 
539
        result = brasero_mime_filter_filter (BRASERO_MIME_FILTER (search->priv->filter),
 
540
                                             name,
 
541
                                             uri,
 
542
                                             name,
 
543
                                             mime);
 
544
 
 
545
        g_free (name);
 
546
        return result;
 
547
}
 
548
 
 
549
static void
 
550
brasero_search_mime_filter_changed (GtkComboBox *combo,
 
551
                                    BraseroSearch *search)
 
552
{
 
553
        gtk_tree_model_filter_refilter (GTK_TREE_MODEL_FILTER (gtk_tree_view_get_model (GTK_TREE_VIEW (search->priv->tree))));
 
554
}
 
555
 
 
556
static void
 
557
brasero_search_tree_activated_cb (GtkTreeView *tree,
 
558
                                  GtkTreeIter *row,
 
559
                                  GtkTreeViewColumn *column,
 
560
                                  BraseroSearch *search)
 
561
{
 
562
        brasero_uri_container_uri_activated (BRASERO_URI_CONTAINER (search));
 
563
}
 
564
 
 
565
static char **
 
566
brasero_search_get_selected_rows (BraseroSearch *search)
 
567
{
 
568
        GtkTreeSelection *selection;
 
569
        GtkTreeModel *model;
 
570
        gchar **uris = NULL;
 
571
        GList *rows, *iter;
 
572
        GtkTreeIter row;
 
573
        int i;
 
574
 
 
575
        selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (search->priv->tree));
 
576
        rows = gtk_tree_selection_get_selected_rows (selection, &model);
 
577
        if (rows == NULL)
 
578
                return NULL;
 
579
 
 
580
        uris = g_new0 (char *, g_list_length (rows) + 1);
 
581
        for (iter = rows, i = 0; iter != NULL; iter = iter->next, i++) {
 
582
                gpointer hit;
 
583
 
 
584
                gtk_tree_model_get_iter (model,
 
585
                                         &row,
 
586
                                         (GtkTreePath *) iter->data);
 
587
                gtk_tree_path_free (iter->data);
 
588
 
 
589
                hit = NULL;
 
590
                gtk_tree_model_get (model, &row,
 
591
                                    BRASERO_SEARCH_TREE_HIT_COL, &hit,
 
592
                                    -1);
 
593
                uris[i] = g_strdup (brasero_search_engine_uri_from_hit (search->priv->engine, hit));
 
594
        }
 
595
 
 
596
        g_list_free (rows);
 
597
        return uris;
 
598
}
 
599
 
 
600
static void
 
601
brasero_search_drag_data_get_cb (GtkTreeView *tree,
 
602
                                 GdkDragContext *drag_context,
 
603
                                 GtkSelectionData *selection_data,
 
604
                                 guint info,
 
605
                                 guint time, BraseroSearch *search)
 
606
{
 
607
        gchar **uris;
 
608
 
 
609
        uris = brasero_search_get_selected_rows (search);
 
610
        gtk_selection_data_set_uris (selection_data, uris);
 
611
        g_strfreev (uris);
 
612
}
 
613
 
 
614
static gchar *
 
615
brasero_search_get_selected_uri (BraseroURIContainer *container)
 
616
{
 
617
        BraseroSearch *search;
 
618
        gchar **uris = NULL;
 
619
        gchar *uri;
 
620
 
 
621
        search = BRASERO_SEARCH (container);
 
622
        uris = brasero_search_get_selected_rows (search);
 
623
 
 
624
        if (uris) {
 
625
                uri = g_strdup (uris [0]);
 
626
                g_strfreev (uris);
 
627
                return uri;
 
628
        }
 
629
 
 
630
        return NULL;
 
631
}
 
632
 
 
633
static gchar **
 
634
brasero_search_get_selected_uris (BraseroURIContainer *container)
 
635
{
 
636
        BraseroSearch *search;
 
637
 
 
638
        search = BRASERO_SEARCH (container);
 
639
        return brasero_search_get_selected_rows (search);
 
640
}
 
641
 
 
642
static void
 
643
brasero_search_tree_selection_changed_cb (GtkTreeSelection *selection,
 
644
                                          BraseroSearch *search)
 
645
{
 
646
        brasero_uri_container_uri_selected (BRASERO_URI_CONTAINER (search));
 
647
}
 
648
 
 
649
static void
 
650
brasero_search_get_proportion (BraseroLayoutObject *object,
 
651
                               gint *header,
 
652
                               gint *center,
 
653
                               gint *footer) 
 
654
{
 
655
        GtkRequisition requisition;
 
656
 
 
657
        gtk_widget_size_request (BRASERO_SEARCH (object)->priv->filters,
 
658
                                 &requisition);
 
659
        *footer = requisition.height + BRASERO_SEARCH_SPACING;
 
660
}
 
661
 
 
662
static void
 
663
brasero_search_set_context (BraseroLayoutObject *object,
 
664
                            BraseroLayoutType type)
 
665
{
 
666
        BraseroSearch *self;
 
667
 
 
668
        self = BRASERO_SEARCH (object);
 
669
        brasero_search_entry_set_context (BRASERO_SEARCH_ENTRY (self->priv->entry), type);
 
670
}
 
671
 
 
672
static gint
 
673
brasero_search_sort_name (GtkTreeModel *model,
 
674
                          GtkTreeIter  *iter1,
 
675
                          GtkTreeIter  *iter2,
 
676
                          gpointer user_data)
 
677
{
 
678
        gint res;
 
679
        gpointer hit1, hit2;
 
680
        gchar *name1, *name2;
 
681
        BraseroSearch *search = BRASERO_SEARCH (user_data);
 
682
 
 
683
        gtk_tree_model_get (model, iter1,
 
684
                            BRASERO_SEARCH_TREE_HIT_COL, &hit1,
 
685
                            -1);
 
686
        gtk_tree_model_get (model, iter2,
 
687
                            BRASERO_SEARCH_TREE_HIT_COL, &hit2,
 
688
                            -1);
 
689
 
 
690
        name1 = brasero_search_name_from_hit (search, hit1);
 
691
        name2 = brasero_search_name_from_hit (search, hit2);
 
692
 
 
693
        res = g_strcmp0 (name1, name2);
 
694
        g_free (name1);
 
695
        g_free (name2);
 
696
 
 
697
        return res;
 
698
}
 
699
 
 
700
static gint
 
701
brasero_search_sort_description (GtkTreeModel *model,
 
702
                                 GtkTreeIter  *iter1,
 
703
                                 GtkTreeIter  *iter2,
 
704
                                 gpointer user_data)
 
705
{
 
706
        gpointer hit1, hit2;
 
707
        BraseroSearch *search = BRASERO_SEARCH (user_data);
 
708
 
 
709
        gtk_tree_model_get (model, iter1,
 
710
                            BRASERO_SEARCH_TREE_HIT_COL, &hit1,
 
711
                            -1);
 
712
        gtk_tree_model_get (model, iter2,
 
713
                            BRASERO_SEARCH_TREE_HIT_COL, &hit2,
 
714
                            -1);
 
715
 
 
716
        return g_strcmp0 (brasero_search_description_from_hit (search, hit1),
 
717
                          brasero_search_description_from_hit (search, hit2));
 
718
}
 
719
 
 
720
static gint
 
721
brasero_search_sort_score (GtkTreeModel *model,
 
722
                           GtkTreeIter  *iter1,
 
723
                           GtkTreeIter  *iter2,
 
724
                           gpointer user_data)
 
725
{
 
726
        gpointer hit1, hit2;
 
727
        BraseroSearch *search = BRASERO_SEARCH (user_data);
 
728
 
 
729
        gtk_tree_model_get (model, iter1,
 
730
                            BRASERO_SEARCH_TREE_HIT_COL, &hit1,
 
731
                            -1);
 
732
        gtk_tree_model_get (model, iter2,
 
733
                            BRASERO_SEARCH_TREE_HIT_COL, &hit2,
 
734
                            -1);
 
735
 
 
736
        return brasero_search_engine_score_from_hit (search->priv->engine, hit2) -
 
737
               brasero_search_engine_score_from_hit (search->priv->engine, hit1);
 
738
}
 
739
 
 
740
static void
 
741
brasero_search_column_clicked (GtkTreeViewColumn *column,
 
742
                               BraseroSearch *search)
 
743
{
 
744
        GtkTreeModel *sort;
 
745
        GtkTreeModel *model;
 
746
        GtkSortType model_order;
 
747
 
 
748
        sort = gtk_tree_view_get_model (GTK_TREE_VIEW (search->priv->tree));
 
749
        model = gtk_tree_model_filter_get_model (GTK_TREE_MODEL_FILTER (sort));
 
750
 
 
751
        gtk_tree_sortable_get_sort_column_id (GTK_TREE_SORTABLE (model),
 
752
                                              NULL,
 
753
                                              &model_order);
 
754
 
 
755
        if (!gtk_tree_view_column_get_sort_indicator (column)) {
 
756
                GtkTreeIterCompareFunc sort_func;
 
757
 
 
758
                if (search->priv->sort_column)
 
759
                        gtk_tree_view_column_set_sort_indicator (search->priv->sort_column, FALSE);
 
760
 
 
761
                search->priv->sort_column = column;
 
762
                gtk_tree_view_column_set_sort_indicator (column, TRUE);
 
763
 
 
764
                gtk_tree_view_column_set_sort_order (column, GTK_SORT_ASCENDING);
 
765
                gtk_tree_sortable_set_sort_column_id (GTK_TREE_SORTABLE (model),
 
766
                                                      GTK_TREE_SORTABLE_DEFAULT_SORT_COLUMN_ID,
 
767
                                                      GTK_SORT_ASCENDING);
 
768
 
 
769
                sort_func = g_object_get_data (G_OBJECT (column), "SortFunc");
 
770
                gtk_tree_sortable_set_default_sort_func (GTK_TREE_SORTABLE (model),
 
771
                                                         sort_func,
 
772
                                                         search,
 
773
                                                         NULL);
 
774
        }
 
775
        else if (model_order == GTK_SORT_DESCENDING) {
 
776
                gtk_tree_view_column_set_sort_indicator (column, FALSE);
 
777
                gtk_tree_sortable_set_default_sort_func (GTK_TREE_SORTABLE (model),
 
778
                                                         brasero_search_sort_score,
 
779
                                                         search,
 
780
                                                         NULL);
 
781
                gtk_tree_sortable_set_sort_column_id (GTK_TREE_SORTABLE (model),
 
782
                                                      GTK_TREE_SORTABLE_DEFAULT_SORT_COLUMN_ID,
 
783
                                                      GTK_SORT_ASCENDING);
 
784
        }
 
785
        else {
 
786
                gtk_tree_view_column_set_sort_order (column, GTK_SORT_DESCENDING);
 
787
                gtk_tree_sortable_set_sort_column_id (GTK_TREE_SORTABLE (model),
 
788
                                                      GTK_TREE_SORTABLE_DEFAULT_SORT_COLUMN_ID,
 
789
                                                      GTK_SORT_DESCENDING);
 
790
        }
 
791
 
 
792
        g_signal_stop_emission_by_name (column, "clicked");
 
793
}
 
794
 
 
795
static gboolean
 
796
brasero_search_try_again (BraseroSearch *search)
 
797
{
 
798
        if (brasero_search_engine_is_available (search->priv->engine)) {
 
799
                gtk_widget_set_sensitive (GTK_WIDGET (search), TRUE);
 
800
                search->priv->id = 0;
 
801
                return FALSE;
 
802
        }
 
803
 
 
804
        return TRUE;
 
805
}
 
806
 
 
807
static void
 
808
brasero_search_init (BraseroSearch *obj)
 
809
{
 
810
        gchar *string;
 
811
        GtkWidget *box;
 
812
        GtkWidget *box1;
 
813
        GtkWidget *label;
 
814
        GtkWidget *combo;
 
815
        GtkWidget *button;
 
816
        GtkWidget *scroll;
 
817
        GtkListStore *store;
 
818
        GtkTreeModel *model;
 
819
        GtkWidget *separator;
 
820
        GtkTreeViewColumn *column;
 
821
        GtkCellRenderer *renderer;
 
822
        GtkFileFilter *file_filter;
 
823
        GtkTreeSelection *selection;
 
824
 
 
825
        gtk_box_set_spacing (GTK_BOX (obj), BRASERO_SEARCH_SPACING);
 
826
        obj->priv = g_new0 (BraseroSearchPrivate, 1);
 
827
 
 
828
        obj->priv->engine = brasero_search_engine_new_default ();
 
829
        g_signal_connect (obj->priv->engine,
 
830
                          "search-finished",
 
831
                          G_CALLBACK (brasero_search_finished_cb),
 
832
                          obj);
 
833
        g_signal_connect (obj->priv->engine,
 
834
                          "search-error",
 
835
                          G_CALLBACK (brasero_search_error_cb),
 
836
                          obj);
 
837
        g_signal_connect (obj->priv->engine,
 
838
                          "hit-removed",
 
839
                          G_CALLBACK (brasero_search_hit_removed_cb),
 
840
                          obj);
 
841
        g_signal_connect (obj->priv->engine,
 
842
                          "hit-added",
 
843
                          G_CALLBACK (brasero_search_hit_added_cb),
 
844
                          obj);
 
845
 
 
846
        /* separator */
 
847
        separator = gtk_hseparator_new ();
 
848
        gtk_box_pack_start (GTK_BOX (obj), separator, FALSE, FALSE, 0);
 
849
 
 
850
        /* Entry */
 
851
        obj->priv->entry = brasero_search_entry_new ();
 
852
        g_signal_connect (G_OBJECT (obj->priv->entry), 
 
853
                          "activated",
 
854
                          G_CALLBACK (brasero_search_entry_activated_cb),
 
855
                          obj);
 
856
        gtk_box_pack_start (GTK_BOX (obj), obj->priv->entry, FALSE, FALSE, 0);
 
857
 
 
858
        /* separator */
 
859
        separator = gtk_hseparator_new ();
 
860
        gtk_box_pack_start (GTK_BOX (obj), separator, FALSE, FALSE, 0);
 
861
 
 
862
        /* results navigation */
 
863
        box = gtk_hbox_new (FALSE, 6);
 
864
        gtk_box_pack_start (GTK_BOX (obj), box, FALSE, FALSE, 0);
 
865
 
 
866
        button = brasero_utils_make_button (_("Previous Results"),
 
867
                                            GTK_STOCK_GO_BACK,
 
868
                                            NULL,
 
869
                                            GTK_ICON_SIZE_BUTTON);
 
870
        gtk_button_set_alignment (GTK_BUTTON (button), 0.0, 0.5);
 
871
        gtk_widget_set_sensitive (button, FALSE);
 
872
        g_signal_connect (G_OBJECT (button), 
 
873
                          "clicked",
 
874
                          G_CALLBACK (brasero_search_left_button_clicked_cb),
 
875
                          obj);
 
876
        gtk_box_pack_start (GTK_BOX (box), button, FALSE, TRUE, 0);
 
877
        obj->priv->left = button;
 
878
 
 
879
        string = g_strdup_printf ("<b>%s</b>", _("No results"));
 
880
        label = gtk_label_new (string);
 
881
        g_free (string);
 
882
 
 
883
        gtk_label_set_use_markup (GTK_LABEL (label), TRUE);
 
884
        gtk_box_pack_start (GTK_BOX (box), label, TRUE, TRUE, 0);
 
885
        obj->priv->results_label = label;
 
886
 
 
887
        button = brasero_utils_make_button (_("Next Results"),
 
888
                                            GTK_STOCK_GO_FORWARD,
 
889
                                            NULL,
 
890
                                            GTK_ICON_SIZE_BUTTON);
 
891
        gtk_button_set_alignment (GTK_BUTTON (button), 1.0, 0.5);
 
892
        gtk_widget_set_sensitive (button, FALSE);
 
893
        g_signal_connect (G_OBJECT (button), 
 
894
                          "clicked",
 
895
                          G_CALLBACK (brasero_search_right_button_clicked_cb),
 
896
                          obj);
 
897
        gtk_box_pack_start (GTK_BOX (box), button, FALSE, TRUE, 0);
 
898
        obj->priv->right = button;
 
899
 
 
900
        /* Tree */
 
901
        store = gtk_list_store_new (BRASERO_SEARCH_TREE_NB_COL,
 
902
                                    G_TYPE_POINTER);
 
903
 
 
904
        gtk_tree_sortable_set_default_sort_func (GTK_TREE_SORTABLE (store),
 
905
                                                 brasero_search_sort_score,
 
906
                                                 obj,
 
907
                                                 NULL);
 
908
 
 
909
        gtk_tree_sortable_set_sort_column_id (GTK_TREE_SORTABLE (store),
 
910
                                              GTK_TREE_SORTABLE_DEFAULT_SORT_COLUMN_ID,
 
911
                                              GTK_SORT_ASCENDING);
 
912
 
 
913
        g_signal_connect (store,
 
914
                          "row-inserted",
 
915
                          G_CALLBACK (brasero_search_row_inserted),
 
916
                          obj);
 
917
 
 
918
        model = gtk_tree_model_filter_new (GTK_TREE_MODEL (store), NULL);
 
919
        g_object_unref (G_OBJECT (store));
 
920
 
 
921
        gtk_tree_model_filter_set_visible_func (GTK_TREE_MODEL_FILTER (model),
 
922
                                                (GtkTreeModelFilterVisibleFunc) brasero_search_is_visible_cb,
 
923
                                                obj,
 
924
                                                NULL);
 
925
 
 
926
        obj->priv->tree = gtk_tree_view_new_with_model (model);
 
927
        g_object_unref (G_OBJECT (model));
 
928
 
 
929
        gtk_tree_view_set_rubber_banding (GTK_TREE_VIEW (obj->priv->tree), TRUE);
 
930
        egg_tree_multi_drag_add_drag_support (GTK_TREE_VIEW (obj->priv->tree));
 
931
 
 
932
        selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (obj->priv->tree));
 
933
        gtk_tree_selection_set_mode (selection, GTK_SELECTION_MULTIPLE);
 
934
 
 
935
        gtk_tree_view_set_rules_hint (GTK_TREE_VIEW (obj->priv->tree), TRUE);
 
936
        g_signal_connect (G_OBJECT (obj->priv->tree), 
 
937
                          "row-activated",
 
938
                          G_CALLBACK (brasero_search_tree_activated_cb),
 
939
                          obj);
 
940
        g_signal_connect (G_OBJECT (gtk_tree_view_get_selection (GTK_TREE_VIEW (obj->priv->tree))),
 
941
                          "changed",
 
942
                          G_CALLBACK (brasero_search_tree_selection_changed_cb),
 
943
                          obj);
 
944
 
 
945
        gtk_tree_view_set_headers_clickable (GTK_TREE_VIEW (obj->priv->tree), TRUE);
 
946
 
 
947
        column = gtk_tree_view_column_new ();
 
948
 
 
949
        gtk_tree_view_column_set_clickable (column, TRUE);
 
950
        gtk_tree_view_column_set_resizable (column, TRUE);
 
951
        gtk_tree_view_column_set_title (column, _("Files"));
 
952
        gtk_tree_view_column_set_min_width (column, 128);
 
953
 
 
954
        g_object_set_data (G_OBJECT (column), "SortFunc", brasero_search_sort_name);
 
955
        g_signal_connect (column,
 
956
                          "clicked",
 
957
                          G_CALLBACK (brasero_search_column_clicked),
 
958
                          obj);
 
959
 
 
960
        renderer = gtk_cell_renderer_pixbuf_new ();
 
961
        gtk_tree_view_column_pack_start (column, renderer, FALSE);
 
962
        gtk_tree_view_column_set_cell_data_func (column,
 
963
                                                 renderer,
 
964
                                                 brasero_search_column_icon_cb,
 
965
                                                 obj,
 
966
                                                 NULL);
 
967
 
 
968
        renderer = gtk_cell_renderer_text_new ();
 
969
        gtk_tree_view_column_pack_start (column, renderer, TRUE);
 
970
        gtk_tree_view_column_set_cell_data_func (column,
 
971
                                                 renderer,
 
972
                                                 brasero_search_column_name_cb,
 
973
                                                 obj,
 
974
                                                 NULL);
 
975
 
 
976
        gtk_tree_view_append_column (GTK_TREE_VIEW (obj->priv->tree),
 
977
                                     column);
 
978
 
 
979
        column = gtk_tree_view_column_new ();
 
980
        gtk_tree_view_column_set_title (column, _("Description"));
 
981
        gtk_tree_view_column_set_clickable (column, TRUE);
 
982
        gtk_tree_view_column_set_resizable (column, TRUE);
 
983
        gtk_tree_view_column_set_min_width (column, 128);
 
984
 
 
985
        g_object_set_data (G_OBJECT (column), "SortFunc", brasero_search_sort_description);
 
986
        g_signal_connect (column,
 
987
                          "clicked",
 
988
                          G_CALLBACK (brasero_search_column_clicked),
 
989
                          obj);
 
990
 
 
991
        renderer = gtk_cell_renderer_text_new ();
 
992
        gtk_tree_view_column_pack_start (column, renderer, TRUE);
 
993
        gtk_tree_view_column_set_cell_data_func (column,
 
994
                                                 renderer,
 
995
                                                 brasero_search_column_description_cb,
 
996
                                                 obj,
 
997
                                                 NULL);
 
998
        gtk_tree_view_append_column (GTK_TREE_VIEW (obj->priv->tree),
 
999
                                     column);
 
1000
        /* dnd */
 
1001
        gtk_tree_view_enable_model_drag_source (GTK_TREE_VIEW (obj->priv->tree),
 
1002
                                                GDK_BUTTON1_MASK,
 
1003
                                                ntables_find,
 
1004
                                                nb_ntables_find,
 
1005
                                                GDK_ACTION_COPY);
 
1006
 
 
1007
        g_signal_connect (G_OBJECT (obj->priv->tree), 
 
1008
                          "drag-data-get",
 
1009
                          G_CALLBACK (brasero_search_drag_data_get_cb),
 
1010
                          obj);
 
1011
 
 
1012
        scroll = gtk_scrolled_window_new (NULL, NULL);
 
1013
        gtk_container_add (GTK_CONTAINER (scroll), obj->priv->tree);
 
1014
        gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (scroll),
 
1015
                                             GTK_SHADOW_IN);
 
1016
        gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scroll),
 
1017
                                        GTK_POLICY_AUTOMATIC,
 
1018
                                        GTK_POLICY_AUTOMATIC);
 
1019
        gtk_box_pack_start (GTK_BOX (obj), scroll, TRUE, TRUE, 0);
 
1020
 
 
1021
        /* filter combo */
 
1022
        box = gtk_hbox_new (FALSE, 32);
 
1023
        obj->priv->filters = box;
 
1024
        gtk_box_pack_end (GTK_BOX (obj), box, FALSE, FALSE, 0);
 
1025
 
 
1026
        obj->priv->filter = brasero_mime_filter_new ();
 
1027
        g_signal_connect (G_OBJECT (BRASERO_MIME_FILTER (obj->priv->filter)->combo),
 
1028
                          "changed",
 
1029
                          G_CALLBACK (brasero_search_mime_filter_changed),
 
1030
                          obj);
 
1031
 
 
1032
        file_filter = gtk_file_filter_new ();
 
1033
        gtk_file_filter_set_name (file_filter, _("All files"));
 
1034
        gtk_file_filter_add_pattern (file_filter, "*");
 
1035
        brasero_mime_filter_add_filter (BRASERO_MIME_FILTER (obj->priv->filter),
 
1036
                                        file_filter);
 
1037
        g_object_unref (file_filter);
 
1038
 
 
1039
        gtk_box_pack_end (GTK_BOX (box), obj->priv->filter, FALSE, FALSE, 0);
 
1040
 
 
1041
        box1 = gtk_hbox_new (FALSE, 6);
 
1042
        gtk_box_pack_end (GTK_BOX (box), box1, FALSE, FALSE, 0);
 
1043
 
 
1044
        label = gtk_label_new (_("Number of results displayed"));
 
1045
        gtk_box_pack_start (GTK_BOX (box1), label, FALSE, FALSE, 0);
 
1046
 
 
1047
        combo = gtk_combo_box_new_text ();
 
1048
        g_signal_connect (combo,
 
1049
                          "changed",
 
1050
                          G_CALLBACK (brasero_search_max_results_num_changed_cb),
 
1051
                          obj);
 
1052
        gtk_combo_box_append_text (GTK_COMBO_BOX (combo), "20");
 
1053
        gtk_combo_box_append_text (GTK_COMBO_BOX (combo), "50");
 
1054
        gtk_combo_box_append_text (GTK_COMBO_BOX (combo), "100");
 
1055
 
 
1056
        gtk_combo_box_set_active (GTK_COMBO_BOX (combo), 1);
 
1057
        obj->priv->max_results = 50;
 
1058
 
 
1059
        gtk_box_pack_start (GTK_BOX (box1), combo, FALSE, FALSE, 0);
 
1060
 
 
1061
        if (!brasero_search_engine_is_available (obj->priv->engine)) {
 
1062
                gtk_widget_set_sensitive (GTK_WIDGET (obj), FALSE);
 
1063
 
 
1064
                /* we will retry in 10 seconds */
 
1065
                obj->priv->id = g_timeout_add_seconds (10,
 
1066
                                                       (GSourceFunc) brasero_search_try_again,
 
1067
                                                       obj);
 
1068
        } 
 
1069
}
 
1070
 
 
1071
static void
 
1072
brasero_search_destroy (GtkObject *object)
 
1073
{
 
1074
        BraseroSearch *search;
 
1075
 
 
1076
        search = BRASERO_SEARCH (object);
 
1077
        if (search->priv->tree) {
 
1078
                g_signal_handlers_disconnect_by_func (gtk_tree_view_get_selection (GTK_TREE_VIEW (search->priv->tree)),
 
1079
                                                      brasero_search_tree_selection_changed_cb,
 
1080
                                                      search);
 
1081
 
 
1082
                g_signal_handlers_disconnect_by_func (search->priv->filter,
 
1083
                                                      brasero_search_mime_filter_changed,
 
1084
                                                      search);
 
1085
 
 
1086
                brasero_search_empty_tree (search);
 
1087
                search->priv->filter = NULL;
 
1088
                search->priv->tree = NULL;
 
1089
        }
 
1090
 
 
1091
        if (search->priv->id) {
 
1092
                g_source_remove (search->priv->id);
 
1093
                search->priv->id = 0;
 
1094
        }
 
1095
 
 
1096
        if (search->priv->engine) {
 
1097
                g_object_unref (search->priv->engine);
 
1098
                search->priv->engine = NULL;
 
1099
        }
 
1100
 
 
1101
        if (GTK_OBJECT_CLASS (brasero_search_parent_class)->destroy)
 
1102
                GTK_OBJECT_CLASS (brasero_search_parent_class)->destroy (object);
 
1103
}
 
1104
 
 
1105
static void
 
1106
brasero_search_finalize (GObject *object)
 
1107
{
 
1108
        BraseroSearch *cobj;
 
1109
 
 
1110
        cobj = BRASERO_SEARCH (object);
 
1111
 
 
1112
        g_free (cobj->priv);
 
1113
        G_OBJECT_CLASS (brasero_search_parent_class)->finalize (object);
 
1114
}
 
1115
 
 
1116
static void
 
1117
brasero_search_iface_layout_object_init (BraseroLayoutObjectIFace *iface)
 
1118
{
 
1119
        iface->get_proportion = brasero_search_get_proportion;
 
1120
        iface->set_context = brasero_search_set_context;
 
1121
}
 
1122
 
 
1123
static void
 
1124
brasero_search_iface_uri_container_init (BraseroURIContainerIFace *iface)
 
1125
{
 
1126
        iface->get_selected_uri = brasero_search_get_selected_uri;
 
1127
        iface->get_selected_uris = brasero_search_get_selected_uris;
 
1128
}
 
1129
 
 
1130
static void
 
1131
brasero_search_class_init (BraseroSearchClass *klass)
 
1132
{
 
1133
        GObjectClass *object_class = G_OBJECT_CLASS (klass);
 
1134
        GtkObjectClass *gtkobject_class = GTK_OBJECT_CLASS (klass);
 
1135
 
 
1136
        object_class->finalize = brasero_search_finalize;
 
1137
        gtkobject_class->destroy = brasero_search_destroy;
 
1138
}
 
1139
 
 
1140
GtkWidget *
 
1141
brasero_search_new ()
 
1142
{
 
1143
        return g_object_new (BRASERO_TYPE_SEARCH, NULL);
 
1144
}
 
1145