← Back to branch summary

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

« back to all changes in this revision

Viewing changes to src/brasero-search-tracker.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-tracker.c
 
1
/* -*- Mode: C; indent-tabs-mode: t; c-basic-offset: 8; tab-width: 8 -*- */
 
2
/*
 
3
 * brasero
 
4
 * Copyright (C) Rouquier Philippe 2009 <bonfire-app@wanadoo.fr>
 
5
 * 
 
6
 * brasero is free software: you can redistribute it and/or modify it
 
7
 * under the terms of the GNU General Public License as published by the
 
8
 * Free Software Foundation, either version 3 of the License, or
 
9
 * (at your option) any later version.
 
10
 * 
 
11
 * brasero is distributed in the hope that it will be useful, but
 
12
 * WITHOUT ANY WARRANTY; without even the implied warranty of
 
13
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
 
14
 * See the GNU General Public License for more details.
 
15
 * 
 
16
 * You should have received a copy of the GNU General Public License along
 
17
 * with this program.  If not, see <http://www.gnu.org/licenses/>.
 
18
 */
 
19
 
 
20
#include <stdlib.h>
 
21
 
 
22
#include <libtracker-client/tracker.h>
 
23
 
 
24
#include "brasero-search-tracker.h"
 
25
#include "brasero-search-engine.h"
 
26
 
 
27
typedef struct _BraseroSearchTrackerPrivate BraseroSearchTrackerPrivate;
 
28
struct _BraseroSearchTrackerPrivate
 
29
{
 
30
        TrackerClient *client;
 
31
        GPtrArray *results;
 
32
 
 
33
        BraseroSearchScope scope;
 
34
 
 
35
        gchar **mimes;
 
36
        gchar *keywords;
 
37
};
 
38
 
 
39
#define BRASERO_SEARCH_TRACKER_PRIVATE(o)  (G_TYPE_INSTANCE_GET_PRIVATE ((o), BRASERO_TYPE_SEARCH_TRACKER, BraseroSearchTrackerPrivate))
 
40
 
 
41
static void brasero_search_tracker_init_engine (BraseroSearchEngineIface *iface);
 
42
 
 
43
G_DEFINE_TYPE_WITH_CODE (BraseroSearchTracker,
 
44
                         brasero_search_tracker,
 
45
                         G_TYPE_OBJECT,
 
46
                         G_IMPLEMENT_INTERFACE (BRASERO_TYPE_SEARCH_ENGINE,
 
47
                                                brasero_search_tracker_init_engine));
 
48
 
 
49
static gboolean
 
50
brasero_search_tracker_is_available (BraseroSearchEngine *engine)
 
51
{
 
52
        BraseroSearchTrackerPrivate *priv;
 
53
 
 
54
        priv = BRASERO_SEARCH_TRACKER_PRIVATE (engine);
 
55
        if (priv->client)
 
56
                return TRUE;
 
57
 
 
58
        priv->client = tracker_connect (TRUE, 30000);
 
59
        return (priv->client != NULL);
 
60
}
 
61
 
 
62
static gint
 
63
brasero_search_tracker_num_hits (BraseroSearchEngine *engine)
 
64
{
 
65
        BraseroSearchTrackerPrivate *priv;
 
66
 
 
67
        priv = BRASERO_SEARCH_TRACKER_PRIVATE (engine);
 
68
        if (!priv->results)
 
69
                return 0;
 
70
 
 
71
        return priv->results->len;
 
72
}
 
73
 
 
74
static const gchar *
 
75
brasero_search_tracker_uri_from_hit (BraseroSearchEngine *engine,
 
76
                                     gpointer hit)
 
77
{
 
78
        gchar **tracker_hit;
 
79
 
 
80
        tracker_hit = hit;
 
81
 
 
82
        if (!tracker_hit)
 
83
                return NULL;
 
84
 
 
85
        if (g_strv_length (tracker_hit) >= 1)
 
86
                return tracker_hit [0];
 
87
 
 
88
        return NULL;
 
89
}
 
90
 
 
91
static const gchar *
 
92
brasero_search_tracker_mime_from_hit (BraseroSearchEngine *engine,
 
93
                                      gpointer hit)
 
94
{
 
95
        gchar **tracker_hit;
 
96
 
 
97
        tracker_hit = hit;
 
98
 
 
99
        if (!tracker_hit)
 
100
                return NULL;
 
101
 
 
102
        if (g_strv_length (tracker_hit) >= 2)
 
103
                return tracker_hit [1];
 
104
 
 
105
        return NULL;
 
106
}
 
107
 
 
108
static int
 
109
brasero_search_tracker_score_from_hit (BraseroSearchEngine *engine,
 
110
                                       gpointer hit)
 
111
{
 
112
        gchar **tracker_hit;
 
113
 
 
114
        tracker_hit = hit;
 
115
 
 
116
        if (!tracker_hit)
 
117
                return 0;
 
118
 
 
119
        if (g_strv_length (tracker_hit) >= 3)
 
120
                return (int) strtof (tracker_hit [2], NULL);
 
121
 
 
122
        return 0;
 
123
}
 
124
 
 
125
static void
 
126
brasero_search_tracker_reply (GPtrArray *results,
 
127
                              GError *error,
 
128
                              gpointer user_data)
 
129
{
 
130
        BraseroSearchEngine *search = BRASERO_SEARCH_ENGINE (user_data);
 
131
        BraseroSearchTrackerPrivate *priv;
 
132
        int i;
 
133
 
 
134
        priv = BRASERO_SEARCH_TRACKER_PRIVATE (search);
 
135
 
 
136
        if (error) {
 
137
                brasero_search_engine_query_error (search, error);
 
138
                return;
 
139
        }
 
140
 
 
141
        if (!results) {
 
142
                brasero_search_engine_query_finished (search);
 
143
                return;
 
144
        }
 
145
 
 
146
        priv->results = results;
 
147
        for (i = 0; i < results->len; i ++)
 
148
                brasero_search_engine_hit_added (search, g_ptr_array_index (results, i));
 
149
 
 
150
        brasero_search_engine_query_finished (search);
 
151
}
 
152
 
 
153
static gboolean
 
154
brasero_search_tracker_query_start_real (BraseroSearchEngine *search,
 
155
                                         gint index)
 
156
{
 
157
        BraseroSearchTrackerPrivate *priv;
 
158
        gboolean res = FALSE;
 
159
        GString *query = NULL;
 
160
 
 
161
        priv = BRASERO_SEARCH_TRACKER_PRIVATE (search);
 
162
 
 
163
        query = g_string_new ("SELECT ?file ?mime fts:rank(?file) "             /* Which variables should be returned */
 
164
                              "WHERE {"                                         /* Start defining the search and its scope */
 
165
                              "  ?file a nfo:FileDataObject . "                 /* File must be a file (not a stream, ...) */
 
166
                              "  ?file nie:mimeType ?mime . ");                 /* Get its mime */
 
167
 
 
168
        if (priv->mimes) {
 
169
                int i;
 
170
 
 
171
                g_string_append (query, " FILTER ( ");
 
172
                for (i = 0; priv->mimes [i]; i ++) {                            /* Filter files according to their mime type */
 
173
                        if (i > 0)
 
174
                                g_string_append (query, " || ");
 
175
                        g_string_append_printf (query,
 
176
                                                "?mime = \"%s\"",
 
177
                                                priv->mimes [i]);
 
178
                }
 
179
                g_string_append (query, " ) ");
 
180
        }
 
181
 
 
182
        if (priv->scope) {
 
183
                gboolean param_added = FALSE;
 
184
 
 
185
                g_string_append (query,
 
186
                                 "  ?file a ?type . "
 
187
                                 "  FILTER ( ");
 
188
 
 
189
                if (priv->scope & BRASERO_SEARCH_SCOPE_MUSIC) {
 
190
                        query = g_string_append (query, "?type = nmm:MusicPiece");
 
191
                        param_added = TRUE;
 
192
                }
 
193
 
 
194
                if (priv->scope & BRASERO_SEARCH_SCOPE_VIDEO) {
 
195
                        if (param_added)
 
196
                                g_string_append (query, " || ");
 
197
                        query = g_string_append (query, "?type = nfo:Video");
 
198
 
 
199
                        param_added = TRUE;
 
200
                }
 
201
        
 
202
                if (priv->scope & BRASERO_SEARCH_SCOPE_PICTURES) {
 
203
                        if (param_added)
 
204
                                g_string_append (query, " || ");
 
205
                        query = g_string_append (query, "?type = nfo:Image");
 
206
 
 
207
                        param_added = TRUE;
 
208
                }
 
209
 
 
210
                if (priv->scope & BRASERO_SEARCH_SCOPE_DOCUMENTS) {
 
211
                        if (param_added)
 
212
                                g_string_append (query, " || ");
 
213
                        query = g_string_append (query, "?type = nfo:Document");
 
214
                }
 
215
 
 
216
                g_string_append (query,
 
217
                                 " ) ");
 
218
        }
 
219
 
 
220
        if (priv->keywords)
 
221
                g_string_append_printf (query,
 
222
                                        "  ?file fts:match \"%s\" ",            /* File must match possible keywords */
 
223
                                        priv->keywords);
 
224
 
 
225
        g_string_append (query,
 
226
                         " } "
 
227
                         "ORDER BY ASC(fts:rank(?file)) "
 
228
                         "OFFSET 0 "
 
229
                         "LIMIT 10000");
 
230
 
 
231
        res = tracker_resources_sparql_query_async (priv->client,
 
232
                                                    query->str,
 
233
                                                    brasero_search_tracker_reply,
 
234
                                                    search);
 
235
        g_string_free (query, TRUE);
 
236
 
 
237
        return res;
 
238
}
 
239
 
 
240
static gboolean
 
241
brasero_search_tracker_query_start (BraseroSearchEngine *search)
 
242
{
 
243
        return brasero_search_tracker_query_start_real (search, 0);
 
244
}
 
245
 
 
246
static gboolean
 
247
brasero_search_tracker_add_hit_to_tree (BraseroSearchEngine *search,
 
248
                                        GtkTreeModel *model,
 
249
                                        gint range_start,
 
250
                                        gint range_end)
 
251
{
 
252
        BraseroSearchTrackerPrivate *priv;
 
253
        gint i;
 
254
 
 
255
        priv = BRASERO_SEARCH_TRACKER_PRIVATE (search);
 
256
 
 
257
        if (!priv->results)
 
258
                return FALSE;
 
259
 
 
260
        for (i = range_start; g_ptr_array_index (priv->results, i) && i < range_end; i ++) {
 
261
                gchar **hit;
 
262
                GtkTreeIter row;
 
263
 
 
264
                hit = g_ptr_array_index (priv->results, i);
 
265
                gtk_list_store_insert_with_values (GTK_LIST_STORE (model), &row, -1,
 
266
                                                   BRASERO_SEARCH_TREE_HIT_COL, hit,
 
267
                                                   -1);
 
268
        }
 
269
 
 
270
        return TRUE;
 
271
}
 
272
 
 
273
static gboolean
 
274
brasero_search_tracker_query_set_scope (BraseroSearchEngine *search,
 
275
                                        BraseroSearchScope scope)
 
276
{
 
277
        BraseroSearchTrackerPrivate *priv;
 
278
 
 
279
        priv = BRASERO_SEARCH_TRACKER_PRIVATE (search);
 
280
        priv->scope = scope;
 
281
        return TRUE;
 
282
}
 
283
 
 
284
static gboolean
 
285
brasero_search_tracker_set_query_mime (BraseroSearchEngine *search,
 
286
                                       const gchar **mimes)
 
287
{
 
288
        BraseroSearchTrackerPrivate *priv;
 
289
 
 
290
        priv = BRASERO_SEARCH_TRACKER_PRIVATE (search);
 
291
 
 
292
        if (priv->mimes) {
 
293
                g_strfreev (priv->mimes);
 
294
                priv->mimes = NULL;
 
295
        }
 
296
 
 
297
        priv->mimes = g_strdupv ((gchar **) mimes);
 
298
        return TRUE;
 
299
}
 
300
 
 
301
static void
 
302
brasero_search_tracker_clean (BraseroSearchTracker *search)
 
303
{
 
304
        BraseroSearchTrackerPrivate *priv;
 
305
 
 
306
        priv = BRASERO_SEARCH_TRACKER_PRIVATE (search);
 
307
 
 
308
        tracker_cancel_last_call (priv->client);
 
309
 
 
310
        if (priv->results) {
 
311
                g_ptr_array_foreach (priv->results, (GFunc) g_strfreev, NULL);
 
312
                g_ptr_array_free (priv->results, TRUE);
 
313
                priv->results = NULL;
 
314
        }
 
315
 
 
316
        if (priv->keywords) {
 
317
                g_free (priv->keywords);
 
318
                priv->keywords = NULL;
 
319
        }
 
320
 
 
321
        if (priv->mimes) {
 
322
                g_strfreev (priv->mimes);
 
323
                priv->mimes = NULL;
 
324
        }
 
325
}
 
326
 
 
327
static gboolean
 
328
brasero_search_tracker_query_new (BraseroSearchEngine *search,
 
329
                                  const gchar *keywords)
 
330
{
 
331
        BraseroSearchTrackerPrivate *priv;
 
332
 
 
333
        priv = BRASERO_SEARCH_TRACKER_PRIVATE (search);
 
334
 
 
335
        brasero_search_tracker_clean (BRASERO_SEARCH_TRACKER (search));
 
336
        priv->keywords = g_strdup (keywords);
 
337
 
 
338
        return TRUE;
 
339
}
 
340
 
 
341
static void
 
342
brasero_search_tracker_init_engine (BraseroSearchEngineIface *iface)
 
343
{
 
344
        iface->is_available = brasero_search_tracker_is_available;
 
345
        iface->query_new = brasero_search_tracker_query_new;
 
346
        iface->query_set_mime = brasero_search_tracker_set_query_mime;
 
347
        iface->query_set_scope = brasero_search_tracker_query_set_scope;
 
348
        iface->query_start = brasero_search_tracker_query_start;
 
349
 
 
350
        iface->uri_from_hit = brasero_search_tracker_uri_from_hit;
 
351
        iface->mime_from_hit = brasero_search_tracker_mime_from_hit;
 
352
        iface->score_from_hit = brasero_search_tracker_score_from_hit;
 
353
 
 
354
        iface->add_hits = brasero_search_tracker_add_hit_to_tree;
 
355
        iface->num_hits = brasero_search_tracker_num_hits;
 
356
}
 
357
 
 
358
static void
 
359
brasero_search_tracker_init (BraseroSearchTracker *object)
 
360
{
 
361
        BraseroSearchTrackerPrivate *priv;
 
362
 
 
363
        priv = BRASERO_SEARCH_TRACKER_PRIVATE (object);
 
364
        priv->client = tracker_connect (TRUE, 30000);
 
365
}
 
366
 
 
367
static void
 
368
brasero_search_tracker_finalize (GObject *object)
 
369
{
 
370
        BraseroSearchTrackerPrivate *priv;
 
371
 
 
372
        priv = BRASERO_SEARCH_TRACKER_PRIVATE (object);
 
373
 
 
374
        brasero_search_tracker_clean (BRASERO_SEARCH_TRACKER (object));
 
375
 
 
376
        if (priv->client) {
 
377
                tracker_disconnect (priv->client);
 
378
                priv->client = NULL;
 
379
        }
 
380
 
 
381
        G_OBJECT_CLASS (brasero_search_tracker_parent_class)->finalize (object);
 
382
}
 
383
 
 
384
static void
 
385
brasero_search_tracker_class_init (BraseroSearchTrackerClass *klass)
 
386
{
 
387
        GObjectClass* object_class = G_OBJECT_CLASS (klass);
 
388
 
 
389
 
 
390
        g_type_class_add_private (klass, sizeof (BraseroSearchTrackerPrivate));
 
391
 
 
392
        object_class->finalize = brasero_search_tracker_finalize;
 
393
}
 
394