libnautilus-private/nautilus-search-engine-tracker.c

   1 /* -*- Mode: C; indent-tabs-mode: t; c-basic-offset: 8; tab-width: 8 -*- */
   2 /*
   3  * Copyright (C) 2005 Mr Jamie McCracken
   4  *
   5  * Nautilus is free software; you can redistribute it and/or
   6  * modify it under the terms of the GNU General Public License as
   7  * published by the Free Software Foundation; either version 2 of the
   8  * License, or (at your option) any later version.
   9  *
  10  * Nautilus is distributed in the hope that it will be useful,
  11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  13  * General Public License for more details.
  14  *
  15  * You should have received a copy of the GNU General Public
  16  * License along with this program; see the file COPYING.  If not,
  17  * write to the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
  18  * Boston, MA 02111-1307, USA.
  19  *
  20  * Author: Jamie McCracken <jamiemcc@gnome.org>
  21  *
  22  */
  23
  24 #include <config.h>
  25 #include "nautilus-search-engine-tracker.h"
  26 #include <tracker.h>
  27 #include <eel/eel-gtk-macros.h>
  28 #include <eel/eel-glib-extensions.h>
  29
  30
  31
  32 struct NautilusSearchEngineTrackerDetails {
  33         NautilusQuery   *query;
  34         TrackerClient   *client;
  35         gboolean        query_pending;
  36 };
  37
  38
  39 static void  nautilus_search_engine_tracker_class_init       (NautilusSearchEngineTrackerClass *class);
  40 static void  nautilus_search_engine_tracker_init             (NautilusSearchEngineTracker      *engine);
  41
  42 G_DEFINE_TYPE (NautilusSearchEngineTracker,
  43                nautilus_search_engine_tracker,
  44                NAUTILUS_TYPE_SEARCH_ENGINE);
  45
  46 static NautilusSearchEngineClass *parent_class = NULL;
  47
  48 static void
  49 finalize (GObject *object)
  50 {
  51         NautilusSearchEngineTracker *tracker;
  52
  53         tracker = NAUTILUS_SEARCH_ENGINE_TRACKER (object);
  54
  55         if (tracker->details->query) {
  56                 g_object_unref (tracker->details->query);
  57                 tracker->details->query = NULL;
  58         }
  59
  60         tracker_disconnect (tracker->details->client);
  61
  62         g_free (tracker->details);
  63
  64         EEL_CALL_PARENT (G_OBJECT_CLASS, finalize, (object));
  65 }
  66
  67
  68 static void
  69 search_callback (char **results, GError *error, gpointer user_data)
  70 {
  71         NautilusSearchEngineTracker *tracker;
  72         char **results_p;
  73         GList *hit_uris;
  74
  75         tracker = NAUTILUS_SEARCH_ENGINE_TRACKER (user_data);
  76         hit_uris = NULL;
  77
  78         tracker->details->query_pending = FALSE;
  79
  80         if (error) {
  81                 nautilus_search_engine_error ( NAUTILUS_SEARCH_ENGINE (tracker), error->message);
  82                 g_error_free (error);
  83                 return;
  84         }
  85
  86         if (!results) {
  87                 return;
  88         }
  89
  90         for (results_p = results; *results_p; results_p++) {
  91
  92                 char *uri;
  93
  94                 uri = g_filename_to_uri ((char *)*results_p, NULL, NULL);
  95                 if (uri) {
  96                         hit_uris = g_list_prepend (hit_uris, (char *)uri);
  97                 }
  98         }
  99
 100         nautilus_search_engine_hits_added (NAUTILUS_SEARCH_ENGINE (tracker), hit_uris);
 101         nautilus_search_engine_finished (NAUTILUS_SEARCH_ENGINE (tracker));
 102         g_strfreev  (results);
 103         eel_g_list_free_deep (hit_uris);
 104
 105 }
 106
 107
 108 static void
 109 nautilus_search_engine_tracker_start (NautilusSearchEngine *engine)
 110 {
 111         NautilusSearchEngineTracker *tracker;
 112         GList   *mimetypes, *l;
 113         char    *search_text, *location, *location_uri;
 114         char    **mimes;
 115         int     i, mime_count;
 116
 117         tracker = NAUTILUS_SEARCH_ENGINE_TRACKER (engine);
 118
 119         if (tracker->details->query_pending) {
 120                 return;
 121         }
 122
 123         if (tracker->details->query == NULL) {
 124                 return;
 125         }
 126
 127         search_text = nautilus_query_get_text (tracker->details->query);
 128
 129         mimetypes = nautilus_query_get_mime_types (tracker->details->query);
 130
 131         location_uri = nautilus_query_get_location (tracker->details->query);
 132
 133         if (location_uri) {
 134                 location = g_filename_from_uri (location_uri, NULL, NULL);
 135                 g_free (location_uri);
 136         } else {
 137                 location = NULL;
 138         }
 139
 140         mime_count  = g_list_length (mimetypes);
 141
 142         i = 0;
 143
 144         /* convert list into array */
 145         if (mime_count > 0) {
 146
 147                 mimes = g_new (char *, (mime_count + 1));
 148
 149                 for (l = mimetypes; l != NULL; l = l->next) {
 150                         mimes[i] = g_strdup (l->data);
 151                         i++;
 152                 }
 153
 154                 mimes[mime_count] = NULL;
 155
 156                 if (location) {
 157                         tracker_search_metadata_by_text_and_mime_and_location_async (tracker->details->client,
 158                                                                                      search_text, (const char **)mimes, location,
 159                                                                                      search_callback,
 160                                                                                      tracker);
 161                         g_free (location);
 162                 } else {
 163                         tracker_search_metadata_by_text_and_mime_async (tracker->details->client,
 164                                                                         search_text, (const char**)mimes,
 165                                                                         search_callback,
 166                                                                         tracker);
 167                 }
 168
 169                 g_strfreev (mimes);
 170
 171
 172         } else {
 173                 if (location) {
 174                         tracker_search_metadata_by_text_and_location_async (tracker->details->client,
 175                                                                             search_text,
 176                                                                             location,
 177                                                                             search_callback,
 178                                                                             tracker);
 179                         g_free (location);
 180                 } else {
 181                         tracker_search_metadata_by_text_async (tracker->details->client,
 182                                                                search_text,
 183                                                                search_callback,
 184                                                                tracker);
 185                 }
 186
 187         }
 188
 189         tracker->details->query_pending = TRUE;
 190         g_free (search_text);
 191         eel_g_list_free_deep (mimetypes);
 192 }
 193
 194 static void
 195 nautilus_search_engine_tracker_stop (NautilusSearchEngine *engine)
 196 {
 197         NautilusSearchEngineTracker *tracker;
 198
 199         tracker = NAUTILUS_SEARCH_ENGINE_TRACKER (engine);
 200
 201         if (tracker->details->query && tracker->details->query_pending) {
 202                 tracker_cancel_last_call (tracker->details->client);
 203                 tracker->details->query_pending = FALSE;
 204         }
 205 }
 206
 207 static gboolean
 208 nautilus_search_engine_tracker_is_indexed (NautilusSearchEngine *engine)
 209 {
 210         return TRUE;
 211 }
 212
 213 static void
 214 nautilus_search_engine_tracker_set_query (NautilusSearchEngine *engine, NautilusQuery *query)
 215 {
 216         NautilusSearchEngineTracker *tracker;
 217
 218         tracker = NAUTILUS_SEARCH_ENGINE_TRACKER (engine);
 219
 220         if (query) {
 221                 g_object_ref (query);
 222         }
 223
 224         if (tracker->details->query) {
 225                 g_object_unref (tracker->details->query);
 226         }
 227
 228         tracker->details->query = query;
 229 }
 230
 231 static void
 232 nautilus_search_engine_tracker_class_init (NautilusSearchEngineTrackerClass *class)
 233 {
 234         GObjectClass *gobject_class;
 235         NautilusSearchEngineClass *engine_class;
 236
 237         parent_class = g_type_class_peek_parent (class);
 238
 239         gobject_class = G_OBJECT_CLASS (class);
 240         gobject_class->finalize = finalize;
 241
 242         engine_class = NAUTILUS_SEARCH_ENGINE_CLASS (class);
 243         engine_class->set_query = nautilus_search_engine_tracker_set_query;
 244         engine_class->start = nautilus_search_engine_tracker_start;
 245         engine_class->stop = nautilus_search_engine_tracker_stop;
 246         engine_class->is_indexed = nautilus_search_engine_tracker_is_indexed;
 247 }
 248
 249 static void
 250 nautilus_search_engine_tracker_init (NautilusSearchEngineTracker *engine)
 251 {
 252         engine->details = g_new0 (NautilusSearchEngineTrackerDetails, 1);
 253 }
 254
 255
 256 NautilusSearchEngine *
 257 nautilus_search_engine_tracker_new (void)
 258 {
 259         NautilusSearchEngineTracker *engine;
 260         TrackerClient *tracker_client;
 261
 262         tracker_client =  tracker_connect (FALSE);
 263
 264         if (!tracker_client) {
 265                 return NULL;
 266         }
 267
 268         engine = g_object_new (NAUTILUS_TYPE_SEARCH_ENGINE_TRACKER, NULL);
 269
 270         engine->details->client = tracker_client;
 271
 272         engine->details->query_pending = FALSE;
 273
 274         return NAUTILUS_SEARCH_ENGINE (engine);
 275 }