Pileus Git - ~andy/gtk/blob - gtk/gtksearchenginetracker.c

   1 /*
   2  * Copyright (C) 2005 Mr Jamie McCracken
   3  *
   4  * This library is free software; you can redistribute it and/or
   5  * modify it under the terms of the GNU Lesser General Public
   6  * License as published by the Free Software Foundation; either
   7  * version 2 of the License, or (at your option) any later version.
   8  *
   9  * This library is distributed in the hope that it will be useful,
  10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  12  * Lesser General Public License for more details.
  13  *
  14  * You should have received a copy of the GNU Lesser General Public
  15  * License along with this library; if not, write to the
  16  * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
  17  *
  18  * Author: Jamie McCracken <jamiemcc@gnome.org>
  19  *
  20  * Based on nautilus-search-engine-tracker.c
  21  */
  22
  23 #include <config.h>
  24 #include <gmodule.h>
  25 #include "gtksearchenginetracker.h"
  26 #if 0
  27 #include <tracker.h>
  28 #endif
  29
  30 /* we dlopen() libtracker at runtime */
  31
  32 typedef struct _TrackerClient TrackerClient;
  33
  34 typedef void (*TrackerArrayReply) (char **result, GError *error, gpointer user_data);
  35
  36 static TrackerClient * (*tracker_connect) (gboolean enable_warnings) = NULL;
  37 static void            (*tracker_disconnect) (TrackerClient *client) = NULL;
  38 static void            (*tracker_cancel_last_call) (TrackerClient *client) = NULL;
  39
  40 static void (*tracker_search_metadata_by_text_async) (TrackerClient *client,
  41                                                       const char *query,
  42                                                       TrackerArrayReply callback,
  43                                                       gpointer user_data) = NULL;
  44 static void (*tracker_search_metadata_by_text_and_location_async) (TrackerClient *client,
  45                                                                    const char *query,
  46                                                                    const char *location,
  47                                                                    TrackerArrayReply callback,
  48                                                                    gpointer user_data) = NULL;
  49
  50 static struct TrackerDlMapping
  51 {
  52   const char *fn_name;
  53   gpointer *fn_ptr_ref;
  54 } tracker_dl_mapping[] =
  55 {
  56 #define MAP(a) { #a, (gpointer *)&a }
  57   MAP (tracker_connect),
  58   MAP (tracker_disconnect),
  59   MAP (tracker_cancel_last_call),
  60   MAP (tracker_search_metadata_by_text_async),
  61   MAP (tracker_search_metadata_by_text_and_location_async),
  62 #undef MAP
  63 };
  64
  65 static void
  66 open_libtracker (void)
  67 {
  68   static gboolean done = FALSE;
  69
  70   if (!done)
  71     {
  72       int i;
  73       GModule *tracker;
  74
  75       done = TRUE;
  76
  77       tracker = g_module_open ("libtracker.so.0", G_MODULE_BIND_LAZY | G_MODULE_BIND_LOCAL);
  78       if (!tracker)
  79         return;
  80
  81       for (i = 0; i < G_N_ELEMENTS (tracker_dl_mapping); i++)
  82         {
  83           if (!g_module_symbol (tracker, tracker_dl_mapping[i].fn_name,
  84                                 tracker_dl_mapping[i].fn_ptr_ref))
  85             {
  86               g_warning ("Missing symbol '%s' in libtracker\n",
  87                          tracker_dl_mapping[i].fn_name);
  88               g_module_close (tracker);
  89
  90               for (i = 0; i < G_N_ELEMENTS (tracker_dl_mapping); i++)
  91                 tracker_dl_mapping[i].fn_ptr_ref = NULL;
  92
  93               return;
  94             }
  95         }
  96     }
  97 }
  98
  99 struct _GtkSearchEngineTrackerPrivate
 100 {
 101   GtkQuery      *query;
 102   TrackerClient *client;
 103   gboolean       query_pending;
 104 };
 105
 106 G_DEFINE_TYPE (GtkSearchEngineTracker, _gtk_search_engine_tracker, GTK_TYPE_SEARCH_ENGINE);
 107
 108
 109 static void
 110 finalize (GObject *object)
 111 {
 112   GtkSearchEngineTracker *tracker;
 113
 114   tracker = GTK_SEARCH_ENGINE_TRACKER (object);
 115
 116   if (tracker->priv->query)
 117     {
 118       g_object_unref (tracker->priv->query);
 119       tracker->priv->query = NULL;
 120     }
 121
 122   tracker_disconnect (tracker->priv->client);
 123
 124   G_OBJECT_CLASS (_gtk_search_engine_tracker_parent_class)->finalize (object);
 125 }
 126
 127
 128 static void
 129 search_callback (gchar  **results,
 130                  GError  *error,
 131                  gpointer user_data)
 132 {
 133   GtkSearchEngineTracker *tracker;
 134   gchar **results_p;
 135   GList *hit_uris;
 136
 137   tracker = GTK_SEARCH_ENGINE_TRACKER (user_data);
 138   hit_uris = NULL;
 139
 140   tracker->priv->query_pending = FALSE;
 141
 142   if (error)
 143     {
 144       _gtk_search_engine_error ( GTK_SEARCH_ENGINE (tracker), error->message);
 145       g_error_free (error);
 146       return;
 147     }
 148
 149   if (!results)
 150     return;
 151
 152   for (results_p = results; *results_p; results_p++)
 153     {
 154       gchar *uri;
 155
 156       uri = g_filename_to_uri (*results_p, NULL, NULL);
 157       if (uri)
 158         hit_uris = g_list_prepend (hit_uris, uri);
 159     }
 160
 161   _gtk_search_engine_hits_added (GTK_SEARCH_ENGINE (tracker), hit_uris);
 162   _gtk_search_engine_finished (GTK_SEARCH_ENGINE (tracker));
 163
 164   g_strfreev  (results);
 165   g_list_foreach (hit_uris, (GFunc)g_free, NULL);
 166   g_list_free (hit_uris);
 167 }
 168
 169
 170 static void
 171 gtk_search_engine_tracker_start (GtkSearchEngine *engine)
 172 {
 173   GtkSearchEngineTracker *tracker;
 174   gchar *search_text, *location, *location_uri;
 175
 176   tracker = GTK_SEARCH_ENGINE_TRACKER (engine);
 177
 178   if (tracker->priv->query_pending)
 179     return;
 180
 181   if (tracker->priv->query == NULL)
 182     return;
 183
 184   search_text = _gtk_query_get_text (tracker->priv->query);
 185   location_uri = _gtk_query_get_location (tracker->priv->query);
 186
 187   location = NULL;
 188   if (location_uri)
 189     {
 190       location = g_filename_from_uri (location_uri, NULL, NULL);
 191       g_free (location_uri);
 192     }
 193
 194   if (location)
 195     {
 196       tracker_search_metadata_by_text_and_location_async (tracker->priv->client,
 197                                                           search_text,
 198                                                           location,
 199                                                           search_callback,
 200                                                           tracker);
 201       g_free (location);
 202     }
 203   else
 204     {
 205       tracker_search_metadata_by_text_async (tracker->priv->client,
 206                                              search_text,
 207                                              search_callback,
 208                                              tracker);
 209     }
 210
 211   tracker->priv->query_pending = TRUE;
 212   g_free (search_text);
 213 }
 214
 215 static void
 216 gtk_search_engine_tracker_stop (GtkSearchEngine *engine)
 217 {
 218   GtkSearchEngineTracker *tracker;
 219
 220   tracker = GTK_SEARCH_ENGINE_TRACKER (engine);
 221
 222   if (tracker->priv->query && tracker->priv->query_pending)
 223     {
 224       tracker_cancel_last_call (tracker->priv->client);
 225       tracker->priv->query_pending = FALSE;
 226     }
 227 }
 228
 229 static gboolean
 230 gtk_search_engine_tracker_is_indexed (GtkSearchEngine *engine)
 231 {
 232   return TRUE;
 233 }
 234
 235 static void
 236 gtk_search_engine_tracker_set_query (GtkSearchEngine *engine,
 237                                      GtkQuery        *query)
 238 {
 239   GtkSearchEngineTracker *tracker;
 240
 241   tracker = GTK_SEARCH_ENGINE_TRACKER (engine);
 242
 243   if (query)
 244     g_object_ref (query);
 245
 246   if (tracker->priv->query)
 247     g_object_unref (tracker->priv->query);
 248
 249   tracker->priv->query = query;
 250 }
 251
 252 static void
 253 _gtk_search_engine_tracker_class_init (GtkSearchEngineTrackerClass *class)
 254 {
 255   GObjectClass *gobject_class;
 256   GtkSearchEngineClass *engine_class;
 257
 258   gobject_class = G_OBJECT_CLASS (class);
 259   gobject_class->finalize = finalize;
 260
 261   engine_class = GTK_SEARCH_ENGINE_CLASS (class);
 262   engine_class->set_query = gtk_search_engine_tracker_set_query;
 263   engine_class->start = gtk_search_engine_tracker_start;
 264   engine_class->stop = gtk_search_engine_tracker_stop;
 265   engine_class->is_indexed = gtk_search_engine_tracker_is_indexed;
 266
 267   g_type_class_add_private (gobject_class, sizeof (GtkSearchEngineTrackerPrivate));
 268 }
 269
 270 static void
 271 _gtk_search_engine_tracker_init (GtkSearchEngineTracker *engine)
 272 {
 273   engine->priv = G_TYPE_INSTANCE_GET_PRIVATE (engine, GTK_TYPE_SEARCH_ENGINE_TRACKER, GtkSearchEngineTrackerPrivate);
 274 }
 275
 276
 277 GtkSearchEngine *
 278 _gtk_search_engine_tracker_new (void)
 279 {
 280   GtkSearchEngineTracker *engine;
 281   TrackerClient *tracker_client;
 282
 283   open_libtracker ();
 284
 285   if (!tracker_connect)
 286     return NULL;
 287
 288   tracker_client = tracker_connect (FALSE);
 289
 290   if (!tracker_client)
 291     return NULL;
 292
 293   engine = g_object_new (GTK_TYPE_SEARCH_ENGINE_TRACKER, NULL);
 294
 295   engine->priv->client = tracker_client;
 296   engine->priv->query_pending = FALSE;
 297
 298   return GTK_SEARCH_ENGINE (engine);
 299 }