shell/ev-metadata-manager.c

   1 /* -*- Mode: C; tab-width: 8; indent-tabs-mode: t; c-basic-offset: 8 -*- */
   2 /*
   3  * ev-metadata-manager.c
   4  * This file is part of ev
   5  *
   6  * Copyright (C) 2003  Paolo Maggi
   7  *
   8  * This program is free software; you can redistribute it and/or modify
   9  * it under the terms of the GNU General Public License as published by
  10  * the Free Software Foundation; either version 2 of the License, or
  11  * (at your option) any later version.
  12  *
  13  * This program is distributed in the hope that it will be useful,
  14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16  * GNU General Public License for more details.
  17  *
  18  * You should have received a copy of the GNU General Public License
  19  * along with this program; if not, write to the Free Software
  20  * Foundation, Inc., 59 Temple Place, Suite 330,
  21  * Boston, MA 02111-1307, USA.
  22  */
  23
  24 /*
  25  * Modified by the ev Team, 2003. See the AUTHORS file for a
  26  * list of people on the ev Team.
  27  * See the ChangeLog files for a list of changes.
  28  */
  29
  30 #ifdef HAVE_CONFIG_H
  31 #include <config.h>
  32 #endif
  33
  34 #include <time.h>
  35 #include <stdlib.h>
  36
  37 #include <libxml/xmlreader.h>
  38
  39 #include "ev-metadata-manager.h"
  40 #include "ev-file-helpers.h"
  41
  42 #define METADATA_FILE   "ev-metadata.xml"
  43
  44 #define MAX_ITEMS       50
  45
  46 typedef struct _GeditMetadataManager GeditMetadataManager;
  47
  48 typedef struct _Item Item;
  49
  50 struct _Item
  51 {
  52         time_t           atime; /* time of last access */
  53
  54         GHashTable      *values;
  55 };
  56
  57 struct _GeditMetadataManager
  58 {
  59         gboolean         values_loaded; /* It is true if the file
  60                                            has been read */
  61
  62         gboolean         modified;      /* It is true if the file
  63                                            has top be written */
  64
  65         guint            timeout_id;
  66
  67         GHashTable      *items;
  68 };
  69
  70 static gboolean ev_metadata_manager_save (gpointer data);
  71
  72
  73 static GeditMetadataManager *ev_metadata_manager = NULL;
  74
  75 static void
  76 item_free (gpointer data)
  77 {
  78         Item *item;
  79
  80         g_return_if_fail (data != NULL);
  81
  82         item = (Item *)data;
  83
  84         if (item->values != NULL)
  85                 g_hash_table_destroy (item->values);
  86
  87         g_free (item);
  88 }
  89
  90 void
  91 ev_metadata_manager_init (void)
  92 {
  93         ev_metadata_manager = g_new0 (GeditMetadataManager, 1);
  94
  95         ev_metadata_manager->values_loaded = FALSE;
  96         ev_metadata_manager->modified = FALSE;
  97
  98         ev_metadata_manager->items =
  99                 g_hash_table_new_full (g_str_hash,
 100                                        g_str_equal,
 101                                        g_free,
 102                                        item_free);
 103
 104         ev_metadata_manager->timeout_id =
 105                 g_timeout_add_full (G_PRIORITY_DEFAULT_IDLE,
 106                                     2000, /* 2 sec */
 107                                     (GSourceFunc)ev_metadata_manager_save,
 108                                     NULL,
 109                                     NULL);
 110 }
 111
 112 /* This function must be called before exiting ev */
 113 void
 114 ev_metadata_manager_shutdown (void)
 115 {
 116         if (ev_metadata_manager == NULL)
 117                 return;
 118
 119         g_source_remove (ev_metadata_manager->timeout_id);
 120
 121         ev_metadata_manager_save (NULL);
 122
 123         if (ev_metadata_manager->items != NULL)
 124                 g_hash_table_destroy (ev_metadata_manager->items);
 125
 126         g_free (ev_metadata_manager);
 127         ev_metadata_manager = NULL;
 128 }
 129
 130 static GValue *
 131 parse_value (xmlChar *value, xmlChar *type)
 132 {
 133         GType ret_type;
 134         GValue *ret;
 135
 136         ret_type = g_type_from_name ((char *)type);
 137         ret = g_new0 (GValue, 1);
 138         g_value_init (ret, ret_type);
 139
 140         switch (ret_type) {
 141                 case G_TYPE_STRING:
 142                         g_value_set_string (ret, (char *)value);
 143                         break;
 144                 case G_TYPE_INT:
 145                         g_value_set_int (ret, atoi ((char *)value));
 146                         break;
 147                 case G_TYPE_DOUBLE:
 148                         g_value_set_double (ret, atof ((char *)value));
 149                         break;
 150                 case G_TYPE_BOOLEAN:
 151                         g_value_set_boolean (ret, atoi ((char *)value));
 152                         break;
 153         }
 154
 155         return ret;
 156 }
 157
 158 static void
 159 parseItem (xmlDocPtr doc, xmlNodePtr cur)
 160 {
 161         Item *item;
 162
 163         xmlChar *uri;
 164         xmlChar *atime;
 165
 166         if (xmlStrcmp (cur->name, (const xmlChar *)"document") != 0)
 167                         return;
 168
 169         uri = xmlGetProp (cur, (const xmlChar *)"uri");
 170         if (uri == NULL)
 171                 return;
 172
 173         atime = xmlGetProp (cur, (const xmlChar *)"atime");
 174         if (atime == NULL)
 175         {
 176                 xmlFree (uri);
 177                 return;
 178         }
 179
 180         item = g_new0 (Item, 1);
 181
 182         item->atime = atol ((char *)atime);
 183
 184         item->values = g_hash_table_new_full (g_str_hash,
 185                                               g_str_equal,
 186                                               g_free,
 187                                               g_free);
 188
 189         cur = cur->xmlChildrenNode;
 190
 191         while (cur != NULL)
 192         {
 193                 if (xmlStrcmp (cur->name, (const xmlChar *)"entry") == 0)
 194                 {
 195                         xmlChar *key;
 196                         xmlChar *xml_value;
 197                         xmlChar *type;
 198                         GValue *value;
 199
 200                         key = xmlGetProp (cur, (const xmlChar *)"key");
 201                         xml_value = xmlGetProp (cur, (const xmlChar *)"value");
 202                         type = xmlGetProp (cur, (const xmlChar *)"type");
 203                         value = parse_value (xml_value, type);
 204
 205                         if ((key != NULL) && (value != NULL))
 206                                 g_hash_table_insert (item->values,
 207                                                      xmlStrdup (key),
 208                                                      value);
 209
 210                         if (key != NULL)
 211                                 xmlFree (key);
 212                         if (xml_value != NULL)
 213                                 xmlFree (xml_value);
 214                 }
 215
 216                 cur = cur->next;
 217         }
 218
 219         g_hash_table_insert (ev_metadata_manager->items,
 220                              xmlStrdup (uri),
 221                              item);
 222
 223         xmlFree (uri);
 224         xmlFree (atime);
 225 }
 226
 227 static gboolean
 228 load_values ()
 229 {
 230         xmlDocPtr doc;
 231         xmlNodePtr cur;
 232         gchar *file_name;
 233
 234         g_return_val_if_fail (ev_metadata_manager != NULL, FALSE);
 235         g_return_val_if_fail (ev_metadata_manager->values_loaded == FALSE, FALSE);
 236
 237         ev_metadata_manager->values_loaded = TRUE;
 238
 239         xmlKeepBlanksDefault (0);
 240
 241         /* FIXME: file locking - Paolo */
 242         file_name = g_build_filename (ev_dot_dir (), METADATA_FILE, NULL);
 243         if (!g_file_test (file_name, G_FILE_TEST_EXISTS))
 244         {
 245                 g_free (file_name);
 246                 return FALSE;
 247         }
 248
 249         doc = xmlParseFile (file_name);
 250         g_free (file_name);
 251
 252         if (doc == NULL)
 253         {
 254                 return FALSE;
 255         }
 256
 257         cur = xmlDocGetRootElement (doc);
 258         if (cur == NULL)
 259         {
 260                 g_message ("The metadata file '%s' is empty", METADATA_FILE);
 261                 xmlFreeDoc (doc);
 262
 263                 return FALSE;
 264         }
 265
 266         if (xmlStrcmp (cur->name, (const xmlChar *) "metadata"))
 267         {
 268                 g_message ("File '%s' is of the wrong type", METADATA_FILE);
 269                 xmlFreeDoc (doc);
 270
 271                 return FALSE;
 272         }
 273
 274         cur = xmlDocGetRootElement (doc);
 275         cur = cur->xmlChildrenNode;
 276
 277         while (cur != NULL)
 278         {
 279                 parseItem (doc, cur);
 280
 281                 cur = cur->next;
 282         }
 283
 284         xmlFreeDoc (doc);
 285
 286         return TRUE;
 287 }
 288
 289 gboolean
 290 ev_metadata_manager_get (const gchar *uri,
 291                          const gchar *key,
 292                          GValue      *value)
 293 {
 294         Item *item;
 295         GValue *ret;
 296
 297         g_return_val_if_fail (uri != NULL, FALSE);
 298         g_return_val_if_fail (key != NULL, FALSE);
 299
 300         if (ev_metadata_manager == NULL)
 301                 return FALSE;
 302
 303         if (!ev_metadata_manager->values_loaded)
 304         {
 305                 gboolean res;
 306
 307                 res = load_values ();
 308
 309                 if (!res)
 310                         return FALSE;
 311         }
 312
 313         item = (Item *)g_hash_table_lookup (ev_metadata_manager->items,
 314                                             uri);
 315
 316         if (item == NULL)
 317                 return FALSE;
 318
 319         item->atime = time (NULL);
 320
 321         if (item->values == NULL)
 322                 return FALSE;
 323
 324         ret = (GValue *)g_hash_table_lookup (item->values, key);
 325
 326         if (ret == NULL) {
 327                 return FALSE;
 328         } else {
 329                 g_value_init (value, G_VALUE_TYPE (ret));
 330                 g_value_copy (ret, value);
 331
 332                 return TRUE;
 333         }
 334 }
 335
 336 static void
 337 value_free (gpointer data)
 338 {
 339         GValue *value = (GValue *)data;
 340
 341         g_value_unset (value);
 342         g_free (value);
 343 }
 344
 345 void
 346 ev_metadata_manager_set (const gchar  *uri,
 347                          const gchar  *key,
 348                          const GValue *value)
 349 {
 350         Item *item;
 351
 352         g_return_if_fail (uri != NULL);
 353         g_return_if_fail (key != NULL);
 354
 355         if (ev_metadata_manager == NULL)
 356                 return;
 357
 358         if (!ev_metadata_manager->values_loaded)
 359         {
 360                 gboolean res;
 361
 362                 res = load_values ();
 363
 364                 if (!res)
 365                         return;
 366         }
 367
 368         item = (Item *)g_hash_table_lookup (ev_metadata_manager->items,
 369                                             uri);
 370
 371         if (item == NULL)
 372         {
 373                 item = g_new0 (Item, 1);
 374
 375                 g_hash_table_insert (ev_metadata_manager->items,
 376                                      g_strdup (uri),
 377                                      item);
 378         }
 379
 380         if (item->values == NULL)
 381                  item->values = g_hash_table_new_full (g_str_hash,
 382                                                        g_str_equal,
 383                                                        g_free,
 384                                                        value_free);
 385         if (value != NULL) {
 386                 GValue *new;
 387
 388                 new = g_new0 (GValue, 1);
 389                 g_value_init (new, G_VALUE_TYPE (value));
 390                 g_value_copy (value, new);
 391
 392                 g_hash_table_insert (item->values,
 393                                      g_strdup (key),
 394                                      new);
 395         } else {
 396                 g_hash_table_remove (item->values,
 397                                      key);
 398         }
 399
 400         item->atime = time (NULL);
 401
 402         ev_metadata_manager->modified = TRUE;
 403 }
 404
 405 static void
 406 save_values (const gchar *key, GValue *value, xmlNodePtr parent)
 407 {
 408         char *string_value;
 409         xmlNodePtr xml_node;
 410
 411         g_return_if_fail (key != NULL);
 412
 413         if (value == NULL)
 414                 return;
 415
 416         xml_node = xmlNewChild (parent, NULL, (const xmlChar *)"entry", NULL);
 417
 418         xmlSetProp (xml_node, (const xmlChar *)"key", (const xmlChar *)key);
 419         xmlSetProp (xml_node,
 420                     (const xmlChar *)"type",
 421                     (const xmlChar *)g_type_name (G_VALUE_TYPE (value)));
 422
 423         switch (G_VALUE_TYPE (value)) {
 424                 case G_TYPE_STRING:
 425                         string_value = g_strdup (g_value_get_string (value));
 426                         break;
 427                 case G_TYPE_INT:
 428                         string_value = g_strdup_printf ("%d", g_value_get_int (value));
 429                         break;
 430                 case G_TYPE_DOUBLE:
 431                         string_value = g_strdup_printf ("%f", g_value_get_double (value));
 432                         break;
 433                 case G_TYPE_BOOLEAN:
 434                         string_value = g_strdup_printf ("%d", g_value_get_boolean (value));
 435                         break;
 436                 default:
 437                         string_value = NULL;
 438                         g_assert_not_reached ();
 439         }
 440
 441         xmlSetProp (xml_node, (const xmlChar *)"value", (const xmlChar *)string_value);
 442
 443         g_free (string_value);
 444 }
 445
 446 static void
 447 save_item (const gchar *key, const gpointer *data, xmlNodePtr parent)
 448 {
 449         xmlNodePtr xml_node;
 450         const Item *item = (const Item *)data;
 451         gchar *atime;
 452
 453         g_return_if_fail (key != NULL);
 454
 455         if (item == NULL)
 456                 return;
 457
 458         xml_node = xmlNewChild (parent, NULL, (const xmlChar *)"document", NULL);
 459
 460         xmlSetProp (xml_node, (const xmlChar *)"uri", (const xmlChar *)key);
 461
 462         /* FIXME: is the cast right? - Paolo */
 463         atime = g_strdup_printf ("%d", (int)item->atime);
 464         xmlSetProp (xml_node, (const xmlChar *)"atime", (const xmlChar *)atime);
 465
 466         g_free (atime);
 467
 468         g_hash_table_foreach (item->values,
 469                               (GHFunc)save_values, xml_node);
 470 }
 471
 472 static void
 473 get_oldest (const gchar *key, const gpointer value, const gchar ** key_to_remove)
 474 {
 475         const Item *item = (const Item *)value;
 476
 477         if (*key_to_remove == NULL)
 478         {
 479                 *key_to_remove = key;
 480         }
 481         else
 482         {
 483                 const Item *item_to_remove =
 484                         g_hash_table_lookup (ev_metadata_manager->items,
 485                                              *key_to_remove);
 486
 487                 g_return_if_fail (item_to_remove != NULL);
 488
 489                 if (item->atime < item_to_remove->atime)
 490                 {
 491                         *key_to_remove = key;
 492                 }
 493         }
 494 }
 495
 496 static void
 497 resize_items ()
 498 {
 499         while (g_hash_table_size (ev_metadata_manager->items) > MAX_ITEMS)
 500         {
 501                 gpointer key_to_remove = NULL;
 502
 503                 g_hash_table_foreach (ev_metadata_manager->items,
 504                                       (GHFunc)get_oldest,
 505                                       &key_to_remove);
 506
 507                 g_return_if_fail (key_to_remove != NULL);
 508
 509                 g_hash_table_remove (ev_metadata_manager->items,
 510                                      key_to_remove);
 511         }
 512 }
 513
 514 static gboolean
 515 ev_metadata_manager_save (gpointer data)
 516 {
 517         xmlDocPtr  doc;
 518         xmlNodePtr root;
 519         gchar *file_name;
 520
 521         if (!ev_metadata_manager->modified)
 522                 return TRUE;
 523
 524         resize_items ();
 525
 526         xmlIndentTreeOutput = TRUE;
 527
 528         doc = xmlNewDoc ((const xmlChar *)"1.0");
 529         if (doc == NULL)
 530                 return TRUE;
 531
 532         /* Create metadata root */
 533         root = xmlNewDocNode (doc, NULL, (const xmlChar *)"metadata", NULL);
 534         xmlDocSetRootElement (doc, root);
 535
 536         g_hash_table_foreach (ev_metadata_manager->items,
 537                           (GHFunc)save_item, root);
 538
 539         /* FIXME: lock file - Paolo */
 540         file_name = g_build_filename (ev_dot_dir (), METADATA_FILE, NULL);
 541         xmlSaveFormatFile (file_name, doc, 1);
 542         g_free (file_name);
 543
 544         xmlFreeDoc (doc);
 545
 546         ev_metadata_manager->modified = FALSE;
 547
 548         return TRUE;
 549 }
 550
 551 void
 552 ev_metadata_manager_set_int (const gchar *uri, const gchar *key, int value)
 553 {
 554         GValue val = { 0, };
 555
 556         g_value_init (&val, G_TYPE_INT);
 557         g_value_set_int (&val, value);
 558
 559         ev_metadata_manager_set (uri, key, &val);
 560
 561         g_value_unset (&val);
 562 }
 563
 564 void
 565 ev_metadata_manager_set_double (const gchar *uri, const gchar *key, double value)
 566 {
 567         GValue val = { 0, };
 568
 569         g_value_init (&val, G_TYPE_DOUBLE);
 570         g_value_set_double (&val, value);
 571
 572         ev_metadata_manager_set (uri, key, &val);
 573
 574         g_value_unset (&val);
 575 }
 576
 577 void
 578 ev_metadata_manager_set_string (const gchar *uri, const gchar *key, const gchar *value)
 579 {
 580         GValue val = { 0, };
 581
 582         g_value_init (&val, G_TYPE_STRING);
 583         g_value_set_string (&val, value);
 584
 585         ev_metadata_manager_set (uri, key, &val);
 586
 587         g_value_unset (&val);
 588 }
 589
 590 void
 591 ev_metadata_manager_set_boolean (const gchar *uri, const gchar *key, gboolean value)
 592 {
 593         GValue val = { 0, };
 594
 595         g_value_init (&val, G_TYPE_BOOLEAN);
 596         g_value_set_boolean (&val, value);
 597
 598         ev_metadata_manager_set (uri, key, &val);
 599
 600         g_value_unset (&val);
 601 }