libempathy/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., 51 Franklin St, Fifth Floor,
  18  * Boston, MA  02110-1301  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-lib.h>
  31
  32 #include <libxml/parser.h>
  33 #include <libxml/tree.h>
  34
  35 #include "empathy-utils.h"
  36 #include "empathy-status-presets.h"
  37
  38 #define DEBUG_FLAG EMPATHY_DEBUG_OTHER
  39 #include "empathy-debug.h"
  40
  41 #define STATUS_PRESETS_XML_FILENAME "status-presets.xml"
  42 #define STATUS_PRESETS_DTD_FILENAME "empathy-status-presets.dtd"
  43 #define STATUS_PRESETS_MAX_EACH     15
  44
  45 typedef struct {
  46         gchar      *status;
  47         TpConnectionPresenceType  state;
  48 } StatusPreset;
  49
  50 static StatusPreset *status_preset_new          (TpConnectionPresenceType    state,
  51                                                  const gchar  *status);
  52 static void     status_preset_free              (StatusPreset *status);
  53 static void     status_presets_file_parse       (const gchar  *filename);
  54 const gchar *   status_presets_get_state_as_str (TpConnectionPresenceType    state);
  55 static gboolean status_presets_file_save        (void);
  56 static void     status_presets_set_default      (TpConnectionPresenceType    state,
  57                                                  const gchar  *status);
  58
  59 static GList        *presets = NULL;
  60 static StatusPreset *default_preset = NULL;
  61
  62 static StatusPreset *
  63 status_preset_new (TpConnectionPresenceType   state,
  64                    const gchar *status)
  65 {
  66         StatusPreset *preset;
  67
  68         preset = g_new0 (StatusPreset, 1);
  69
  70         preset->status = g_strdup (status);
  71         preset->state = state;
  72
  73         return preset;
  74 }
  75
  76 static void
  77 status_preset_free (StatusPreset *preset)
  78 {
  79         g_free (preset->status);
  80         g_free (preset);
  81 }
  82
  83 static void
  84 status_presets_file_parse (const gchar *filename)
  85 {
  86         xmlParserCtxtPtr ctxt;
  87         xmlDocPtr        doc;
  88         xmlNodePtr       presets_node;
  89         xmlNodePtr       node;
  90
  91         DEBUG ("Attempting to parse file:'%s'...", filename);
  92
  93         ctxt = xmlNewParserCtxt ();
  94
  95         /* Parse and validate the file. */
  96         doc = xmlCtxtReadFile (ctxt, filename, NULL, 0);
  97         if (!doc) {
  98                 g_warning ("Failed to parse file:'%s'", filename);
  99                 xmlFreeParserCtxt (ctxt);
 100                 return;
 101         }
 102
 103         if (!empathy_xml_validate (doc, STATUS_PRESETS_DTD_FILENAME)) {
 104                 g_warning ("Failed to validate file:'%s'", filename);
 105                 xmlFreeDoc (doc);
 106                 xmlFreeParserCtxt (ctxt);
 107                 return;
 108         }
 109
 110         /* The root node, presets. */
 111         presets_node = xmlDocGetRootElement (doc);
 112
 113         node = presets_node->children;
 114         while (node) {
 115                 if (strcmp ((gchar *) node->name, "status") == 0 ||
 116                     strcmp ((gchar *) node->name, "default") == 0) {
 117                         TpConnectionPresenceType    state;
 118                         gchar        *status;
 119                         gchar        *state_str;
 120                         StatusPreset *preset;
 121                         gboolean      is_default = FALSE;
 122
 123                         if (strcmp ((gchar *) node->name, "default") == 0) {
 124                                 is_default = TRUE;
 125                         }
 126
 127                         status = (gchar *) xmlNodeGetContent (node);
 128                         state_str = (gchar *) xmlGetProp (node, (const xmlChar *) "presence");
 129
 130                         if (state_str) {
 131                                 state = empathy_presence_from_str (state_str);
 132                                 if (empathy_status_presets_is_valid (state)) {
 133                                         if (is_default) {
 134                                                 DEBUG ("Default status preset state is:"
 135                                                         " '%s', status:'%s'", state_str,
 136                                                         status);
 137
 138                                                 status_presets_set_default (state, status);
 139                                         } else {
 140                                                 preset = status_preset_new (state, status);
 141                                                 presets = g_list_append (presets, preset);
 142                                         }
 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 (TP_CONNECTION_PRESENCE_TYPE_OFFLINE, NULL);
 156         }
 157
 158         DEBUG ("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_user_config_dir (), 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[NUM_TP_CONNECTION_PRESENCE_TYPES];
 198         gint        i;
 199
 200         for (i = 0; i < NUM_TP_CONNECTION_PRESENCE_TYPES; i++) {
 201                 count[i] = 0;
 202         }
 203
 204         dir = g_build_filename (g_get_user_config_dir (), 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 ((const xmlChar *) "1.0");
 210         root = xmlNewNode (NULL, (const xmlChar *) "presets");
 211         xmlDocSetRootElement (doc, root);
 212
 213         if (default_preset) {
 214                 xmlNodePtr  subnode;
 215                 xmlChar    *state;
 216
 217                 state = (xmlChar *) empathy_presence_to_str (default_preset->state);
 218
 219                 subnode = xmlNewTextChild (root, NULL, (const xmlChar *) "default",
 220                                           (const xmlChar *) default_preset->status);
 221                 xmlNewProp (subnode, (const xmlChar *) "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 = (xmlChar *) empathy_presence_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                                            (const xmlChar *) "status", (const xmlChar *) sp->status);
 239                 xmlNewProp (subnode, (const xmlChar *) "presence", state);
 240         }
 241
 242         /* Make sure the XML is indented properly */
 243         xmlIndentTreeOutput = 1;
 244
 245         DEBUG ("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 (TpConnectionPresenceType 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 (TpConnectionPresenceType   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                     !tp_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 (TpConnectionPresenceType   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                     !tp_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 (TP_CONNECTION_PRESENCE_TYPE_AVAILABLE, NULL);
 353
 354         status_presets_file_save ();
 355 }
 356
 357 TpConnectionPresenceType
 358 empathy_status_presets_get_default_state (void)
 359 {
 360         if (!default_preset) {
 361                 return TP_CONNECTION_PRESENCE_TYPE_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 (TpConnectionPresenceType   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 (TpConnectionPresenceType   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 }
 407
 408 /**
 409  * empathy_status_presets_is_valid:
 410  * @state: a #TpConnectionPresenceType
 411  *
 412  * Check if a presence type can be used as a preset.
 413  *
 414  * Returns: %TRUE if the presence type can be used as a preset.
 415  */
 416 gboolean
 417 empathy_status_presets_is_valid (TpConnectionPresenceType state)
 418 {
 419         switch (state) {
 420                 case TP_CONNECTION_PRESENCE_TYPE_UNSET:
 421                 case TP_CONNECTION_PRESENCE_TYPE_OFFLINE:
 422                 case TP_CONNECTION_PRESENCE_TYPE_UNKNOWN:
 423                 case TP_CONNECTION_PRESENCE_TYPE_ERROR:
 424                         return FALSE;
 425
 426                 case TP_CONNECTION_PRESENCE_TYPE_AVAILABLE:
 427                 case TP_CONNECTION_PRESENCE_TYPE_AWAY:
 428                 case TP_CONNECTION_PRESENCE_TYPE_EXTENDED_AWAY:
 429                 case TP_CONNECTION_PRESENCE_TYPE_HIDDEN:
 430                 case TP_CONNECTION_PRESENCE_TYPE_BUSY:
 431                         return TRUE;
 432
 433                 default:
 434                         return FALSE;
 435         }
 436 }