← Back to branch summary

~ubuntu-branches/debian/experimental/brasero/experimental

« back to all changes in this revision

Viewing changes to src/brasero-search-tracker.c

  • Committer: Bazaar Package Importer
  • Author(s): Josselin Mouette
  • Date: 2011-03-29 16:33:51 UTC
  • mfrom: (1.3.18 upstream) (5.2.8 sid)
  • Revision ID: james.westby@ubuntu.com-20110329163351-ac3wgbh4mplmhnht
Tags: 2.91.93-1
* Only depend on growisofs instead of dvd+rw-tools.
* New upstream pre-release.
* Update build-dependencies, package names, and paths.
* Require totem-plparser 2.32 since its soname changed.
* Do not include GIR package for now, since the versioning is broken 
  (see Bugzilla #646069).
* 01_pkglibdir.patch: dropped, upstream now has a variable we can use 
  for that effect.
* 11_nautilus_menu_no_display.patch, 31_link_libice.patch, 
  50_checksum.patch: dropped, merged upstream.
* 90_relibtoolize.patch: dropped, unnecessary.

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-client.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
        guint current_call_id;
 
39
};
 
40
 
 
41
#define BRASERO_SEARCH_TRACKER_PRIVATE(o)  (G_TYPE_INSTANCE_GET_PRIVATE ((o), BRASERO_TYPE_SEARCH_TRACKER, BraseroSearchTrackerPrivate))
 
42
 
 
43
static void brasero_search_tracker_init_engine (BraseroSearchEngineIface *iface);
 
44
 
 
45
G_DEFINE_TYPE_WITH_CODE (BraseroSearchTracker,
 
46
                         brasero_search_tracker,
 
47
                         G_TYPE_OBJECT,
 
48
                         G_IMPLEMENT_INTERFACE (BRASERO_TYPE_SEARCH_ENGINE,
 
49
                                                brasero_search_tracker_init_engine));
 
50
 
 
51
static gboolean
 
52
brasero_search_tracker_is_available (BraseroSearchEngine *engine)
 
53
{
 
54
        BraseroSearchTrackerPrivate *priv;
 
55
 
 
56
        priv = BRASERO_SEARCH_TRACKER_PRIVATE (engine);
 
57
        if (priv->client)
 
58
                return TRUE;
 
59
 
 
60
        priv->client = tracker_client_new (1, 30000);
 
61
        return (priv->client != NULL);
 
62
}
 
63
 
 
64
static gint
 
65
brasero_search_tracker_num_hits (BraseroSearchEngine *engine)
 
66
{
 
67
        BraseroSearchTrackerPrivate *priv;
 
68
 
 
69
        priv = BRASERO_SEARCH_TRACKER_PRIVATE (engine);
 
70
        if (!priv->results)
 
71
                return 0;
 
72
 
 
73
        return priv->results->len;
 
74
}
 
75
 
 
76
static const gchar *
 
77
brasero_search_tracker_uri_from_hit (BraseroSearchEngine *engine,
 
78
                                     gpointer hit)
 
79
{
 
80
        gchar **tracker_hit;
 
81
 
 
82
        tracker_hit = hit;
 
83
 
 
84
        if (!tracker_hit)
 
85
                return NULL;
 
86
 
 
87
        if (g_strv_length (tracker_hit) >= 2)
 
88
                return tracker_hit [1];
 
89
 
 
90
        return NULL;
 
91
}
 
92
 
 
93
static const gchar *
 
94
brasero_search_tracker_mime_from_hit (BraseroSearchEngine *engine,
 
95
                                      gpointer hit)
 
96
{
 
97
        gchar **tracker_hit;
 
98
 
 
99
        tracker_hit = hit;
 
100
 
 
101
        if (!tracker_hit)
 
102
                return NULL;
 
103
 
 
104
        if (g_strv_length (tracker_hit) >= 3)
 
105
                return tracker_hit [2];
 
106
 
 
107
        return NULL;
 
108
}
 
109
 
 
110
static int
 
111
brasero_search_tracker_score_from_hit (BraseroSearchEngine *engine,
 
112
                                       gpointer hit)
 
113
{
 
114
        gchar **tracker_hit;
 
115
 
 
116
        tracker_hit = hit;
 
117
 
 
118
        if (!tracker_hit)
 
119
                return 0;
 
120
 
 
121
        if (g_strv_length (tracker_hit) >= 4)
 
122
                return (int) strtof (tracker_hit [3], NULL);
 
123
 
 
124
        return 0;
 
125
}
 
126
 
 
127
static void
 
128
brasero_search_tracker_reply (GPtrArray *results,
 
129
                              GError *error,
 
130
                              gpointer user_data)
 
131
{
 
132
        BraseroSearchEngine *search = BRASERO_SEARCH_ENGINE (user_data);
 
133
        BraseroSearchTrackerPrivate *priv;
 
134
        int i;
 
135
 
 
136
        priv = BRASERO_SEARCH_TRACKER_PRIVATE (search);
 
137
 
 
138
        if (error) {
 
139
                brasero_search_engine_query_error (search, error);
 
140
                return;
 
141
        }
 
142
 
 
143
        if (!results) {
 
144
                brasero_search_engine_query_finished (search);
 
145
                return;
 
146
        }
 
147
 
 
148
        priv->results = results;
 
149
        for (i = 0; i < results->len; i ++)
 
150
                brasero_search_engine_hit_added (search, g_ptr_array_index (results, i));
 
151
 
 
152
        brasero_search_engine_query_finished (search);
 
153
}
 
154
 
 
155
static gboolean
 
156
brasero_search_tracker_query_start_real (BraseroSearchEngine *search,
 
157
                                         gint index)
 
158
{
 
159
        BraseroSearchTrackerPrivate *priv;
 
160
        gboolean res = FALSE;
 
161
        GString *query = NULL;
 
162
 
 
163
        priv = BRASERO_SEARCH_TRACKER_PRIVATE (search);
 
164
 
 
165
        query = g_string_new ("SELECT ?file ?url ?mime fts:rank(?file) "        /* Which variables should be returned */
 
166
                              "WHERE {"                                         /* Start defining the search and its scope */
 
167
                              "  ?file a nfo:FileDataObject . "                 /* File must be a file (not a stream, ...) */
 
168
                              "  ?file nie:url ?url . "                         /* Get the url of the file */
 
169
                              "  ?file nie:mimeType ?mime . ");                 /* Get its mime */
 
170
 
 
171
        if (priv->mimes) {
 
172
                int i;
 
173
 
 
174
                g_string_append (query, " FILTER ( ");
 
175
                for (i = 0; priv->mimes [i]; i ++) {                            /* Filter files according to their mime type */
 
176
                        if (i > 0)
 
177
                                g_string_append (query, " || ");
 
178
 
 
179
                        g_string_append_printf (query,
 
180
                                                "?mime = \"%s\"",
 
181
                                                priv->mimes [i]);
 
182
                }
 
183
                g_string_append (query, " ) ");
 
184
        }
 
185
 
 
186
        if (priv->scope) {
 
187
                gboolean param_added = FALSE;
 
188
 
 
189
                g_string_append (query,
 
190
                                 "  ?file a ?type . "
 
191
                                 "  FILTER ( ");
 
192
 
 
193
                if (priv->scope & BRASERO_SEARCH_SCOPE_MUSIC) {
 
194
                        query = g_string_append (query, "?type = nmm:MusicPiece");
 
195
                        param_added = TRUE;
 
196
                }
 
197
 
 
198
                if (priv->scope & BRASERO_SEARCH_SCOPE_VIDEO) {
 
199
                        if (param_added)
 
200
                                g_string_append (query, " || ");
 
201
                        query = g_string_append (query, "?type = nfo:Video");
 
202
 
 
203
                        param_added = TRUE;
 
204
                }
 
205
        
 
206
                if (priv->scope & BRASERO_SEARCH_SCOPE_PICTURES) {
 
207
                        if (param_added)
 
208
                                g_string_append (query, " || ");
 
209
                        query = g_string_append (query, "?type = nfo:Image");
 
210
 
 
211
                        param_added = TRUE;
 
212
                }
 
213
 
 
214
                if (priv->scope & BRASERO_SEARCH_SCOPE_DOCUMENTS) {
 
215
                        if (param_added)
 
216
                                g_string_append (query, " || ");
 
217
                        query = g_string_append (query, "?type = nfo:Document");
 
218
                }
 
219
 
 
220
                g_string_append (query,
 
221
                                 " ) ");
 
222
        }
 
223
 
 
224
        if (priv->keywords)
 
225
                g_string_append_printf (query,
 
226
                                        "  ?file fts:match \"%s\" ",            /* File must match possible keywords */
 
227
                                        priv->keywords);
 
228
 
 
229
        g_string_append (query,
 
230
                         " } "
 
231
                         "ORDER BY ASC(fts:rank(?file)) "
 
232
                         "OFFSET 0 "
 
233
                         "LIMIT 10000");
 
234
 
 
235
        priv->current_call_id = tracker_resources_sparql_query_async (priv->client,
 
236
                                                                      query->str,
 
237
                                                                      brasero_search_tracker_reply,
 
238
                                                                      search);
 
239
        g_string_free (query, TRUE);
 
240
 
 
241
        return res;
 
242
}
 
243
 
 
244
static gboolean
 
245
brasero_search_tracker_query_start (BraseroSearchEngine *search)
 
246
{
 
247
        return brasero_search_tracker_query_start_real (search, 0);
 
248
}
 
249
 
 
250
static gboolean
 
251
brasero_search_tracker_add_hit_to_tree (BraseroSearchEngine *search,
 
252
                                        GtkTreeModel *model,
 
253
                                        gint range_start,
 
254
                                        gint range_end)
 
255
{
 
256
        BraseroSearchTrackerPrivate *priv;
 
257
        gint i;
 
258
 
 
259
        priv = BRASERO_SEARCH_TRACKER_PRIVATE (search);
 
260
 
 
261
        if (!priv->results)
 
262
                return FALSE;
 
263
 
 
264
        for (i = range_start; g_ptr_array_index (priv->results, i) && i < range_end; i ++) {
 
265
                gchar **hit;
 
266
                GtkTreeIter row;
 
267
 
 
268
                hit = g_ptr_array_index (priv->results, i);
 
269
                gtk_list_store_insert_with_values (GTK_LIST_STORE (model), &row, -1,
 
270
                                                   BRASERO_SEARCH_TREE_HIT_COL, hit,
 
271
                                                   -1);
 
272
        }
 
273
 
 
274
        return TRUE;
 
275
}
 
276
 
 
277
static gboolean
 
278
brasero_search_tracker_query_set_scope (BraseroSearchEngine *search,
 
279
                                        BraseroSearchScope scope)
 
280
{
 
281
        BraseroSearchTrackerPrivate *priv;
 
282
 
 
283
        priv = BRASERO_SEARCH_TRACKER_PRIVATE (search);
 
284
        priv->scope = scope;
 
285
        return TRUE;
 
286
}
 
287
 
 
288
static gboolean
 
289
brasero_search_tracker_set_query_mime (BraseroSearchEngine *search,
 
290
                                       const gchar **mimes)
 
291
{
 
292
        BraseroSearchTrackerPrivate *priv;
 
293
 
 
294
        priv = BRASERO_SEARCH_TRACKER_PRIVATE (search);
 
295
 
 
296
        if (priv->mimes) {
 
297
                g_strfreev (priv->mimes);
 
298
                priv->mimes = NULL;
 
299
        }
 
300
 
 
301
        priv->mimes = g_strdupv ((gchar **) mimes);
 
302
        return TRUE;
 
303
}
 
304
 
 
305
static void
 
306
brasero_search_tracker_clean (BraseroSearchTracker *search)
 
307
{
 
308
        BraseroSearchTrackerPrivate *priv;
 
309
 
 
310
        priv = BRASERO_SEARCH_TRACKER_PRIVATE (search);
 
311
 
 
312
        if (priv->current_call_id)
 
313
                tracker_cancel_call (priv->client, priv->current_call_id);
 
314
 
 
315
        if (priv->results) {
 
316
                g_ptr_array_foreach (priv->results, (GFunc) g_strfreev, NULL);
 
317
                g_ptr_array_free (priv->results, TRUE);
 
318
                priv->results = NULL;
 
319
        }
 
320
 
 
321
        if (priv->keywords) {
 
322
                g_free (priv->keywords);
 
323
                priv->keywords = NULL;
 
324
        }
 
325
 
 
326
        if (priv->mimes) {
 
327
                g_strfreev (priv->mimes);
 
328
                priv->mimes = NULL;
 
329
        }
 
330
}
 
331
 
 
332
static gboolean
 
333
brasero_search_tracker_query_new (BraseroSearchEngine *search,
 
334
                                  const gchar *keywords)
 
335
{
 
336
        BraseroSearchTrackerPrivate *priv;
 
337
 
 
338
        priv = BRASERO_SEARCH_TRACKER_PRIVATE (search);
 
339
 
 
340
        brasero_search_tracker_clean (BRASERO_SEARCH_TRACKER (search));
 
341
        priv->keywords = g_strdup (keywords);
 
342
 
 
343
        return TRUE;
 
344
}
 
345
 
 
346
static void
 
347
brasero_search_tracker_init_engine (BraseroSearchEngineIface *iface)
 
348
{
 
349
        iface->is_available = brasero_search_tracker_is_available;
 
350
        iface->query_new = brasero_search_tracker_query_new;
 
351
        iface->query_set_mime = brasero_search_tracker_set_query_mime;
 
352
        iface->query_set_scope = brasero_search_tracker_query_set_scope;
 
353
        iface->query_start = brasero_search_tracker_query_start;
 
354
 
 
355
        iface->uri_from_hit = brasero_search_tracker_uri_from_hit;
 
356
        iface->mime_from_hit = brasero_search_tracker_mime_from_hit;
 
357
        iface->score_from_hit = brasero_search_tracker_score_from_hit;
 
358
 
 
359
        iface->add_hits = brasero_search_tracker_add_hit_to_tree;
 
360
        iface->num_hits = brasero_search_tracker_num_hits;
 
361
}
 
362
 
 
363
static void
 
364
brasero_search_tracker_init (BraseroSearchTracker *object)
 
365
{
 
366
        BraseroSearchTrackerPrivate *priv;
 
367
 
 
368
        priv = BRASERO_SEARCH_TRACKER_PRIVATE (object);
 
369
        priv->client = tracker_client_new (1, 30000);
 
370
}
 
371
 
 
372
static void
 
373
brasero_search_tracker_finalize (GObject *object)
 
374
{
 
375
        BraseroSearchTrackerPrivate *priv;
 
376
 
 
377
        priv = BRASERO_SEARCH_TRACKER_PRIVATE (object);
 
378
 
 
379
        brasero_search_tracker_clean (BRASERO_SEARCH_TRACKER (object));
 
380
 
 
381
        if (priv->client) {
 
382
                g_object_unref (priv->client);
 
383
                priv->client = NULL;
 
384
        }
 
385
 
 
386
        G_OBJECT_CLASS (brasero_search_tracker_parent_class)->finalize (object);
 
387
}
 
388
 
 
389
static void
 
390
brasero_search_tracker_class_init (BraseroSearchTrackerClass *klass)
 
391
{
 
392
        GObjectClass* object_class = G_OBJECT_CLASS (klass);
 
393
 
 
394
 
 
395
        g_type_class_add_private (klass, sizeof (BraseroSearchTrackerPrivate));
 
396
 
 
397
        object_class->finalize = brasero_search_tracker_finalize;
 
398
}
 
399