libanjuta/anjuta-session.c

   1 /* -*- Mode: C; indent-tabs-mode: t; c-basic-offset: 4; tab-width: 4 -*- */
   2 /*
   3  * anjuta-session.c
   4  * Copyright (c) 2005 Naba Kumar  <naba@gnome.org>
   5  *
   6  * This program is free software; you can redistribute it and/or modify
   7  * it under the terms of the GNU General Public License as published by
   8  * the Free Software Foundation; either version 2 of the License, or
   9  * (at your option) any later version.
  10  *
  11  * This program is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14  * GNU Library General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU General Public License
  17  * along with this program; if not, write to the Free Software
  18  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  19  */
  20
  21 /**
  22  * SECTION:anjuta-session
  23  * @short_description: Program session
  24  * @see_also:
  25  * @stability: Unstable
  26  * @include: libanjuta/anjuta-session.h
  27  *
  28  */
  29
  30 #include <stdlib.h>
  31 #include <string.h>
  32
  33 #include "anjuta-session.h"
  34 #include "anjuta-utils.h"
  35
  36 struct _AnjutaSessionPriv {
  37         gchar *dir_path;
  38         GKeyFile *key_file;
  39 };
  40
  41 static gpointer *parent_class = NULL;
  42
  43 static void
  44 anjuta_session_finalize (GObject *object)
  45 {
  46         AnjutaSession *cobj;
  47         cobj = ANJUTA_SESSION (object);
  48
  49         g_free (cobj->priv->dir_path);
  50         g_key_file_free (cobj->priv->key_file);
  51         g_free (cobj->priv);
  52
  53         G_OBJECT_CLASS(parent_class)->finalize(object);
  54 }
  55
  56 static void
  57 anjuta_session_class_init (AnjutaSessionClass *klass)
  58 {
  59         GObjectClass *object_class = G_OBJECT_CLASS (klass);
  60
  61         parent_class = g_type_class_peek_parent (klass);
  62         object_class->finalize = anjuta_session_finalize;
  63 }
  64
  65 static void
  66 anjuta_session_instance_init (AnjutaSession *obj)
  67 {
  68         obj->priv = g_new0 (AnjutaSessionPriv, 1);
  69         obj->priv->dir_path = NULL;
  70 }
  71
  72 /**
  73  * anjuta_session_new:
  74  * @session_directory: Directory where session is loaded from/saved to.
  75  *
  76  * Created a new session object. @session_directory is the directory
  77  * where session information will be stored or loaded in case of existing
  78  * session.
  79  *
  80  * Returns: an #AnjutaSession Object
  81  */
  82 AnjutaSession*
  83 anjuta_session_new (const gchar *session_directory)
  84 {
  85         AnjutaSession *obj;
  86         gchar *filename;
  87
  88         g_return_val_if_fail (session_directory != NULL, NULL);
  89         g_return_val_if_fail (g_path_is_absolute (session_directory), NULL);
  90
  91         obj = ANJUTA_SESSION (g_object_new (ANJUTA_TYPE_SESSION, NULL));
  92         obj->priv->dir_path = g_strdup (session_directory);
  93
  94         obj->priv->key_file = g_key_file_new ();
  95
  96         filename = anjuta_session_get_session_filename (obj);
  97         g_key_file_load_from_file (obj->priv->key_file, filename,
  98                                                            G_KEY_FILE_NONE, NULL);
  99         g_free (filename);
 100
 101         return obj;
 102 }
 103
 104 ANJUTA_TYPE_BOILERPLATE (AnjutaSession, anjuta_session, G_TYPE_OBJECT)
 105
 106 /**
 107  * anjuta_session_get_session_directory:
 108  * @session: an #AnjutaSession object
 109  *
 110  * Returns the directory corresponding to this session object.
 111  *
 112  * Returns: session directory
 113  */
 114 const gchar*
 115 anjuta_session_get_session_directory (AnjutaSession *session)
 116 {
 117         return session->priv->dir_path;
 118 }
 119
 120 /**
 121  * anjuta_session_get_session_filename:
 122  * @session: an #AnjutaSession object
 123  *
 124  * Gets the session filename corresponding to this session object.
 125  *
 126  * Returns: session (absolute) filename
 127  */
 128 gchar*
 129 anjuta_session_get_session_filename (AnjutaSession *session)
 130 {
 131         g_return_val_if_fail (ANJUTA_IS_SESSION (session), NULL);
 132
 133         return g_build_filename (session->priv->dir_path,
 134                                                          "anjuta.session", NULL);
 135 }
 136
 137 /**
 138  * anjuta_session_sync:
 139  * @session: an #AnjutaSession object
 140  *
 141  * Synchronizes session object with session file
 142  */
 143 void
 144 anjuta_session_sync (AnjutaSession *session)
 145 {
 146         gchar *filename, *data;
 147
 148         g_return_if_fail (ANJUTA_IS_SESSION (session));
 149
 150         filename = anjuta_session_get_session_filename (session);
 151         data = g_key_file_to_data (session->priv->key_file, NULL, NULL);
 152         g_file_set_contents (filename, data, -1, NULL);
 153
 154         g_free (filename);
 155         g_free (data);
 156 }
 157
 158 /**
 159  * anjuta_session_clear:
 160  * @session: an #AnjutaSession object
 161  *
 162  * Clears the session.
 163  */
 164 void
 165 anjuta_session_clear (AnjutaSession *session)
 166 {
 167         gchar *cmd;
 168         gint ret;
 169
 170         g_return_if_fail (ANJUTA_IS_SESSION (session));
 171
 172         g_key_file_free (session->priv->key_file);
 173         session->priv->key_file = g_key_file_new ();
 174
 175         anjuta_session_sync (session);
 176
 177         cmd = g_strconcat ("mkdir -p ", session->priv->dir_path, NULL);
 178         ret = system (cmd);
 179         g_free (cmd);
 180
 181         cmd = g_strconcat ("rm -fr ", session->priv->dir_path, "/*", NULL);
 182         ret = system (cmd);
 183         g_free (cmd);
 184 }
 185
 186 /**
 187  * anjuta_session_clear_section:
 188  * @session: an #AnjutaSession object.
 189  * @section: Section to clear.
 190  *
 191  * Clears the given section in session object.
 192  */
 193 void
 194 anjuta_session_clear_section (AnjutaSession *session,
 195                                                           const gchar *section)
 196 {
 197         g_return_if_fail (ANJUTA_IS_SESSION (session));
 198         g_return_if_fail (section != NULL);
 199
 200         g_key_file_remove_group (session->priv->key_file, section, NULL);
 201 }
 202
 203 /**
 204  * anjuta_session_set_int:
 205  * @session: an #AnjutaSession object
 206  * @section: Section.
 207  * @key: Key name.
 208  * @value: Key value
 209  *
 210  * Set an integer @value to @key in given @section.
 211  */
 212 void
 213 anjuta_session_set_int (AnjutaSession *session, const gchar *section,
 214                                                 const gchar *key, gint value)
 215 {
 216         g_return_if_fail (ANJUTA_IS_SESSION (session));
 217         g_return_if_fail (section != NULL);
 218         g_return_if_fail (key != NULL);
 219
 220         if (!value)
 221         {
 222                 g_key_file_remove_key (session->priv->key_file, section, key, NULL);
 223                 return;
 224         }
 225
 226         g_key_file_set_integer (session->priv->key_file, section, key, value);
 227 }
 228
 229 /**
 230  * anjuta_session_set_float:
 231  * @session: an #AnjutaSession object
 232  * @section: Section.
 233  * @key: Key name.
 234  * @value: Key value
 235  *
 236  * Set a float @value to @key in given @section.
 237  */
 238 void
 239 anjuta_session_set_float (AnjutaSession *session, const gchar *section,
 240                                                   const gchar *key, gfloat value)
 241 {
 242         g_return_if_fail (ANJUTA_IS_SESSION (session));
 243         g_return_if_fail (section != NULL);
 244         g_return_if_fail (key != NULL);
 245
 246         if (!value)
 247         {
 248                 g_key_file_remove_key (session->priv->key_file, section, key, NULL);
 249                 return;
 250         }
 251
 252         g_key_file_set_double (session->priv->key_file, section, key, value);
 253 }
 254
 255 /**
 256  * anjuta_session_set_string:
 257  * @session: an #AnjutaSession object
 258  * @section: Section.
 259  * @key: Key name.
 260  * @value: Key value
 261  *
 262  * Set a string @value to @key in given @section.
 263  */
 264 void
 265 anjuta_session_set_string (AnjutaSession *session, const gchar *section,
 266                                                    const gchar *key, const gchar *value)
 267 {
 268         g_return_if_fail (ANJUTA_IS_SESSION (session));
 269         g_return_if_fail (section != NULL);
 270         g_return_if_fail (key != NULL);
 271
 272         if (!value)
 273         {
 274                 g_key_file_remove_key (session->priv->key_file, section, key, NULL);
 275                 return;
 276         }
 277
 278         g_key_file_set_string (session->priv->key_file, section, key, value);
 279 }
 280
 281 /**
 282  * anjuta_session_set_string_list:
 283  * @session: an #AnjutaSession object
 284  * @section: Section.
 285  * @key: Key name.
 286  * @value: Key value
 287  *
 288  * Set a list of strings @value to @key in given @section.
 289  */
 290 void
 291 anjuta_session_set_string_list (AnjutaSession *session,
 292                                                                 const gchar *section,
 293                                                                 const gchar *key, GList *value)
 294 {
 295         gchar *value_str;
 296         GString *str;
 297         GList *node;
 298         gboolean first_item = TRUE;
 299
 300         g_return_if_fail (ANJUTA_IS_SESSION (session));
 301         g_return_if_fail (section != NULL);
 302         g_return_if_fail (key != NULL);
 303
 304         if (!value)
 305         {
 306                 g_key_file_remove_key (session->priv->key_file, section, key, NULL);
 307                 return;
 308         }
 309
 310         str = g_string_new ("");
 311         node = value;
 312         while (node)
 313         {
 314                 if (node->data && strlen (node->data) > 0)
 315                 {
 316                         if (first_item)
 317                                 first_item = FALSE;
 318                         else
 319                                 g_string_append (str, "%%%");
 320                         g_string_append (str, node->data);
 321                 }
 322                 node = g_list_next (node);
 323         }
 324
 325         value_str = g_string_free (str, FALSE);
 326         g_key_file_set_string (session->priv->key_file, section, key, value_str);
 327
 328         g_free (value_str);
 329 }
 330
 331 /**
 332  * anjuta_session_get_int:
 333  * @session: an #AnjutaSession object
 334  * @section: Section.
 335  * @key: Key name.
 336  *
 337  * Get an integer @value of @key in given @section.
 338  *
 339  * Returns: Key value
 340  */
 341 gint
 342 anjuta_session_get_int (AnjutaSession *session, const gchar *section,
 343                                                 const gchar *key)
 344 {
 345         gint value;
 346
 347         g_return_val_if_fail (ANJUTA_IS_SESSION (session), 0);
 348         g_return_val_if_fail (section != NULL, 0);
 349         g_return_val_if_fail (key != NULL, 0);
 350
 351         value = g_key_file_get_integer (session->priv->key_file, section, key, NULL);
 352
 353         return value;
 354 }
 355
 356 /**
 357  * anjuta_session_get_float:
 358  * @session: an #AnjutaSession object
 359  * @section: Section.
 360  * @key: Key name.
 361  *
 362  * Get a float @value of @key in given @section.
 363  *
 364  * Returns: Key value
 365  */
 366 gfloat
 367 anjuta_session_get_float (AnjutaSession *session, const gchar *section,
 368                                                   const gchar *key)
 369 {
 370         gfloat value;
 371
 372         g_return_val_if_fail (ANJUTA_IS_SESSION (session), 0);
 373         g_return_val_if_fail (section != NULL, 0);
 374         g_return_val_if_fail (key != NULL, 0);
 375
 376         value = (float)g_key_file_get_double (session->priv->key_file, section, key, NULL);
 377
 378         return value;
 379 }
 380
 381 /**
 382  * anjuta_session_get_string:
 383  * @session: an #AnjutaSession object
 384  * @section: Section.
 385  * @key: Key name.
 386  *
 387  * Get a string @value of @key in given @section.
 388  *
 389  * Returns: Key value
 390  */
 391 gchar*
 392 anjuta_session_get_string (AnjutaSession *session, const gchar *section,
 393                                                    const gchar *key)
 394 {
 395         gchar *value;
 396
 397         g_return_val_if_fail (ANJUTA_IS_SESSION (session), NULL);
 398         g_return_val_if_fail (section != NULL, NULL);
 399         g_return_val_if_fail (key != NULL, NULL);
 400
 401         value = g_key_file_get_string (session->priv->key_file, section, key, NULL);
 402
 403         return value;
 404 }
 405
 406 /**
 407  * anjuta_session_get_string_list:
 408  * @session: an #AnjutaSession object
 409  * @section: Section.
 410  * @key: Key name.
 411  *
 412  * Get a list of strings @value of @key in given @section.
 413  *
 414  * Returns: Key value
 415  */
 416 GList*
 417 anjuta_session_get_string_list (AnjutaSession *session,
 418                                                                 const gchar *section,
 419                                                                 const gchar *key)
 420 {
 421         gchar *val, **str, **ptr;
 422         GList *value;
 423
 424         g_return_val_if_fail (ANJUTA_IS_SESSION (session), NULL);
 425         g_return_val_if_fail (section != NULL, NULL);
 426         g_return_val_if_fail (key != NULL, NULL);
 427
 428         val = g_key_file_get_string (session->priv->key_file, section, key, NULL);
 429
 430
 431         value = NULL;
 432         if (val)
 433         {
 434                 str = g_strsplit (val, "%%%", -1);
 435                 if (str)
 436                 {
 437                         ptr = str;
 438                         while (*ptr)
 439                         {
 440                                 if (strlen (*ptr) > 0)
 441                                         value = g_list_prepend (value, g_strdup (*ptr));
 442                                 ptr++;
 443                         }
 444                         g_strfreev (str);
 445                 }
 446                 g_free (val);
 447         }
 448
 449         return g_list_reverse (value);
 450 }