libempathy-gtk/empathy-status-presets.c

   1 /* -*- Mode: C; tab-width: 8; indent-tabs-mode: t; c-basic-offset: 8 -*- */
   2 /*
   3  * Copyright (C) 2005-2007 Imendio AB
   4  *
   5  * This program 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  * This program 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; if not, write to the
  17  * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
  18  * Boston, MA 02111-1307, USA.
  19  *
  20  * Author: Martyn Russell <martyn@imendio.com>
  21  */
  22
  23 #include "config.h"
  24
  25 #include <sys/types.h>
  26 #include <sys/stat.h>
  27 #include <string.h>
  28
  29 #include <glib.h>
  30 #include <glib/gi18n.h>
  31
  32 #include <libxml/parser.h>
  33 #include <libxml/tree.h>
  34
  35 #include <libempathy/empathy-debug.h>
  36 #include <libempathy/empathy-utils.h>
  37
  38 #include "empathy-status-presets.h"
  39
  40 #define DEBUG_DOMAIN "StatusPresets"
  41
  42 #define STATUS_PRESETS_XML_FILENAME "status-presets.xml"
  43 #define STATUS_PRESETS_DTD_FILENAME "empathy-status-presets.dtd"
  44 #define STATUS_PRESETS_MAX_EACH     15
  45
  46 typedef struct {
  47         gchar      *status;
  48         McPresence  state;
  49 } StatusPreset;
  50
  51 static StatusPreset *status_preset_new          (McPresence    state,
  52                                                  const gchar  *status);
  53 static void     status_preset_free              (StatusPreset *status);
  54 static void     status_presets_file_parse       (const gchar  *filename);
  55 const gchar *   status_presets_get_state_as_str (McPresence    state);
  56 static gboolean status_presets_file_save        (void);
  57 static void     status_presets_set_default      (McPresence    state,
  58                                                  const gchar  *status);
  59
  60 static GList        *presets = NULL;
  61 static StatusPreset *default_preset = NULL;
  62
  63 static StatusPreset *
  64 status_preset_new (McPresence   state,
  65                    const gchar *status)
  66 {
  67         StatusPreset *preset;
  68
  69         preset = g_new0 (StatusPreset, 1);
  70
  71         preset->status = g_strdup (status);
  72         preset->state = state;
  73
  74         return preset;
  75 }
  76
  77 static void
  78 status_preset_free (StatusPreset *preset)
  79 {
  80         g_free (preset->status);
  81         g_free (preset);
  82 }
  83
  84 static void
  85 status_presets_file_parse (const gchar *filename)
  86 {
  87         xmlParserCtxtPtr ctxt;
  88         xmlDocPtr        doc;
  89         xmlNodePtr       presets_node;
  90         xmlNodePtr       node;
  91
  92         empathy_debug (DEBUG_DOMAIN, "Attempting to parse file:'%s'...", filename);
  93
  94         ctxt = xmlNewParserCtxt ();
  95
  96         /* Parse and validate the file. */
  97         doc = xmlCtxtReadFile (ctxt, filename, NULL, 0);
  98         if (!doc) {
  99                 g_warning ("Failed to parse file:'%s'", filename);
 100                 xmlFreeParserCtxt (ctxt);
 101                 return;
 102         }
 103
 104         if (!empathy_xml_validate (doc, STATUS_PRESETS_DTD_FILENAME)) {
 105                 g_warning ("Failed to validate file:'%s'", filename);
 106                 xmlFreeDoc(doc);
 107                 xmlFreeParserCtxt (ctxt);
 108                 return;
 109         }
 110
 111         /* The root node, presets. */
 112         presets_node = xmlDocGetRootElement (doc);
 113
 114         node = presets_node->children;
 115         while (node) {
 116                 if (strcmp ((gchar *) node->name, "status") == 0 ||
 117                     strcmp ((gchar *) node->name, "default") == 0) {
 118                         McPresence    state;
 119                         gchar        *status;
 120                         gchar        *state_str;
 121                         StatusPreset *preset;
 122                         gboolean      is_default = FALSE;
 123
 124                         if (strcmp ((gchar *) node->name, "default") == 0) {
 125                                 is_default = TRUE;
 126                         }
 127
 128                         status = (gchar *) xmlNodeGetContent (node);
 129                         state_str = (gchar *) xmlGetProp (node, "presence");
 130
 131                         if (state_str) {
 132                                 state = empathy_presence_state_from_str (state_str);
 133
 134                                 if (is_default) {
 135                                         empathy_debug (DEBUG_DOMAIN,
 136                                                       "Default status preset state is:'%s', status:'%s'",
 137                                                       state_str, status);
 138
 139                                         status_presets_set_default (state, status);
 140                                 } else {
 141                                         preset = status_preset_new (state, status);
 142                                         presets = g_list_append (presets, preset);
 143                                 }
 144                         }
 145
 146                         xmlFree (status);
 147                         xmlFree (state_str);
 148                 }
 149
 150                 node = node->next;
 151         }
 152
 153         /* Use the default if not set */
 154         if (!default_preset) {
 155                 status_presets_set_default (MC_PRESENCE_OFFLINE, NULL);
 156         }
 157
 158         empathy_debug (DEBUG_DOMAIN, "Parsed %d status presets", g_list_length (presets));
 159
 160         xmlFreeDoc (doc);
 161         xmlFreeParserCtxt (ctxt);
 162 }
 163
 164 void
 165 empathy_status_presets_get_all (void)
 166 {
 167         gchar *dir;
 168         gchar *file_with_path;
 169
 170         /* If already set up clean up first. */
 171         if (presets) {
 172                 g_list_foreach (presets, (GFunc) status_preset_free, NULL);
 173                 g_list_free (presets);
 174                 presets = NULL;
 175         }
 176
 177         dir = g_build_filename (g_get_home_dir (), ".gnome2", PACKAGE_NAME, NULL);
 178         g_mkdir_with_parents (dir, S_IRUSR | S_IWUSR | S_IXUSR);
 179         file_with_path = g_build_filename (dir, STATUS_PRESETS_XML_FILENAME, NULL);
 180         g_free (dir);
 181
 182         if (g_file_test (file_with_path, G_FILE_TEST_EXISTS)) {
 183                 status_presets_file_parse (file_with_path);
 184         }
 185
 186         g_free (file_with_path);
 187 }
 188
 189 static gboolean
 190 status_presets_file_save (void)
 191 {
 192         xmlDocPtr   doc;
 193         xmlNodePtr  root;
 194         GList      *l;
 195         gchar      *dir;
 196         gchar      *file;
 197         gint        count[LAST_MC_PRESENCE];
 198         gint        i;
 199
 200         for (i = 0; i < LAST_MC_PRESENCE; i++) {
 201                 count[i] = 0;
 202         }
 203
 204         dir = g_build_filename (g_get_home_dir (), ".gnome2", PACKAGE_NAME, NULL);
 205         g_mkdir_with_parents (dir, S_IRUSR | S_IWUSR | S_IXUSR);
 206         file = g_build_filename (dir, STATUS_PRESETS_XML_FILENAME, NULL);
 207         g_free (dir);
 208
 209         doc = xmlNewDoc ("1.0");
 210         root = xmlNewNode (NULL, "presets");
 211         xmlDocSetRootElement (doc, root);
 212
 213         if (default_preset) {
 214                 xmlNodePtr  subnode;
 215                 xmlChar    *state;
 216
 217                 state = (gchar*) empathy_presence_state_to_str (default_preset->state);
 218
 219                 subnode = xmlNewTextChild (root, NULL, "default",
 220                                            default_preset->status);
 221                 xmlNewProp (subnode, "presence", state);
 222         }
 223
 224         for (l = presets; l; l = l->next) {
 225                 StatusPreset *sp;
 226                 xmlNodePtr    subnode;
 227                 xmlChar      *state;
 228
 229                 sp = l->data;
 230                 state = (gchar*) empathy_presence_state_to_str (sp->state);
 231
 232                 count[sp->state]++;
 233                 if (count[sp->state] > STATUS_PRESETS_MAX_EACH) {
 234                         continue;
 235                 }
 236
 237                 subnode = xmlNewTextChild (root, NULL,
 238                                            "status", sp->status);
 239                 xmlNewProp (subnode, "presence", state);
 240         }
 241
 242         /* Make sure the XML is indented properly */
 243         xmlIndentTreeOutput = 1;
 244
 245         empathy_debug (DEBUG_DOMAIN, "Saving file:'%s'", file);
 246         xmlSaveFormatFileEnc (file, doc, "utf-8", 1);
 247         xmlFreeDoc (doc);
 248
 249         g_free (file);
 250
 251         return TRUE;
 252 }
 253
 254 GList *
 255 empathy_status_presets_get (McPresence state,
 256                            gint       max_number)
 257 {
 258         GList *list = NULL;
 259         GList *l;
 260         gint   i;
 261
 262         i = 0;
 263         for (l = presets; l; l = l->next) {
 264                 StatusPreset *sp;
 265
 266                 sp = l->data;
 267
 268                 if (sp->state != state) {
 269                         continue;
 270                 }
 271
 272                 list = g_list_append (list, sp->status);
 273                 i++;
 274
 275                 if (max_number != -1 && i >= max_number) {
 276                         break;
 277                 }
 278         }
 279
 280         return list;
 281 }
 282
 283 void
 284 empathy_status_presets_set_last (McPresence   state,
 285                                 const gchar *status)
 286 {
 287         GList        *l;
 288         StatusPreset *preset;
 289         gint          num;
 290
 291         /* Check if duplicate */
 292         for (l = presets; l; l = l->next) {
 293                 preset = l->data;
 294
 295                 if (state == preset->state &&
 296                     !empathy_strdiff (status, preset->status)) {
 297                         return;
 298                 }
 299         }
 300
 301         preset = status_preset_new (state, status);
 302         presets = g_list_prepend (presets, preset);
 303
 304         num = 0;
 305         for (l = presets; l; l = l->next) {
 306                 preset = l->data;
 307
 308                 if (state != preset->state) {
 309                         continue;
 310                 }
 311
 312                 num++;
 313
 314                 if (num > STATUS_PRESETS_MAX_EACH) {
 315                         status_preset_free (preset);
 316                         presets = g_list_delete_link (presets, l);
 317                         break;
 318                 }
 319         }
 320
 321         status_presets_file_save ();
 322 }
 323
 324 void
 325 empathy_status_presets_remove (McPresence   state,
 326                                const gchar *status)
 327 {
 328         StatusPreset *preset;
 329         GList        *l;
 330
 331         for (l = presets; l; l = l->next) {
 332                 preset = l->data;
 333
 334                 if (state == preset->state &&
 335                     !empathy_strdiff (status, preset->status)) {
 336                         status_preset_free (preset);
 337                         presets = g_list_delete_link (presets, l);
 338                         status_presets_file_save ();
 339                         break;
 340                 }
 341         }
 342 }
 343
 344 void
 345 empathy_status_presets_reset (void)
 346 {
 347         g_list_foreach (presets, (GFunc) status_preset_free, NULL);
 348         g_list_free (presets);
 349
 350         presets = NULL;
 351
 352         status_presets_set_default (MC_PRESENCE_AVAILABLE, NULL);
 353
 354         status_presets_file_save ();
 355 }
 356
 357 McPresence
 358 empathy_status_presets_get_default_state (void)
 359 {
 360         if (!default_preset) {
 361                 return MC_PRESENCE_OFFLINE;
 362         }
 363
 364         return default_preset->state;
 365 }
 366
 367 const gchar *
 368 empathy_status_presets_get_default_status (void)
 369 {
 370         if (!default_preset ||
 371             !default_preset->status) {
 372                 return NULL;
 373         }
 374
 375         return default_preset->status;
 376 }
 377
 378 static void
 379 status_presets_set_default (McPresence   state,
 380                             const gchar *status)
 381 {
 382         if (default_preset) {
 383                 status_preset_free (default_preset);
 384         }
 385
 386         default_preset = status_preset_new (state, status);
 387 }
 388
 389 void
 390 empathy_status_presets_set_default (McPresence   state,
 391                                    const gchar *status)
 392 {
 393         status_presets_set_default (state, status);
 394         status_presets_file_save ();
 395 }
 396
 397 void
 398 empathy_status_presets_clear_default (void)
 399 {
 400         if (default_preset) {
 401                 status_preset_free (default_preset);
 402                 default_preset = NULL;
 403         }
 404
 405         status_presets_file_save ();
 406 }