logview/logview-manager.c

   1 /* -*- Mode: C; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2; -*- */
   2 /* logview-manager.c - manager for the opened log objects
   3  *
   4  * Copyright (C) 2008 Cosimo Cecchi <cosimoc@gnome.org>
   5  *
   6  * This program is free software; you can redistribute it and/or
   7  * modify it under the terms of the GNU General Public License as
   8  * published by the Free Software Foundation; either version 2 of the
   9  * License, or (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 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., 551 Franklin Street, Fifth Floor, Boston, MA  02110-1301,
  19  * USA.
  20  */
  21
  22 /* logview-manager.c */
  23
  24 #ifdef HAVE_CONFIG_H
  25 #include <config.h>
  26 #endif
  27
  28 #include "logview-manager.h"
  29
  30 #include <glib/gi18n.h>
  31
  32 #include "logview-prefs.h"
  33 #include "logview-marshal.h"
  34 #include "logview-app.h"
  35
  36 enum {
  37   LOG_ADDED,
  38   LOG_CLOSED,
  39   ACTIVE_CHANGED,
  40   LAST_SIGNAL
  41 };
  42
  43 typedef struct {
  44   LogviewManager *manager;
  45   gboolean set_active;
  46   gboolean is_multiple;
  47   GFile *file;
  48 } CreateCBData;
  49
  50 typedef struct {
  51   int total;
  52   int current;
  53   GPtrArray *errors;
  54 } MultipleCreation;
  55
  56 struct _LogviewManagerPrivate {
  57   GHashTable *logs;
  58   LogviewLog *active_log;
  59 };
  60
  61 static LogviewManager *singleton = NULL;
  62 static MultipleCreation *op = NULL;
  63 static guint signals[LAST_SIGNAL] = { 0 };
  64
  65 G_DEFINE_TYPE (LogviewManager, logview_manager, G_TYPE_OBJECT);
  66
  67 #define GET_PRIVATE(o) \
  68   (G_TYPE_INSTANCE_GET_PRIVATE ((o), LOGVIEW_TYPE_MANAGER, LogviewManagerPrivate))
  69
  70 static void
  71 logview_manager_finalize (GObject *object)
  72 {
  73   LogviewManager *manager;
  74
  75   manager = LOGVIEW_MANAGER (object);
  76
  77   if (manager->priv->active_log) {
  78    g_object_unref (manager->priv->active_log);
  79   }
  80
  81   g_hash_table_destroy (manager->priv->logs);
  82
  83   G_OBJECT_CLASS (logview_manager_parent_class)->finalize (object);
  84 }
  85
  86 static void
  87 logview_manager_class_init (LogviewManagerClass *klass)
  88 {
  89   GObjectClass *object_class = G_OBJECT_CLASS (klass);
  90
  91   object_class->finalize = logview_manager_finalize;
  92
  93   signals[LOG_ADDED] = g_signal_new ("log-added",
  94                                      G_OBJECT_CLASS_TYPE (object_class),
  95                                      G_SIGNAL_RUN_LAST,
  96                                      G_STRUCT_OFFSET (LogviewManagerClass, log_added),
  97                                      NULL, NULL,
  98                                      g_cclosure_marshal_VOID__OBJECT,
  99                                      G_TYPE_NONE, 1,
 100                                      LOGVIEW_TYPE_LOG);
 101
 102   signals[LOG_CLOSED] = g_signal_new ("log-closed",
 103                                       G_OBJECT_CLASS_TYPE (object_class),
 104                                       G_SIGNAL_RUN_LAST,
 105                                       G_STRUCT_OFFSET (LogviewManagerClass, log_closed),
 106                                       NULL, NULL,
 107                                       g_cclosure_marshal_VOID__OBJECT,
 108                                       G_TYPE_NONE, 1,
 109                                       LOGVIEW_TYPE_LOG);
 110
 111   signals[ACTIVE_CHANGED] = g_signal_new ("active-changed",
 112                                           G_OBJECT_CLASS_TYPE (object_class),
 113                                           G_SIGNAL_RUN_LAST,
 114                                           G_STRUCT_OFFSET (LogviewManagerClass, active_changed),
 115                                           NULL, NULL,
 116                                           logview_marshal_VOID__OBJECT_OBJECT,
 117                                           G_TYPE_NONE, 2,
 118                                           LOGVIEW_TYPE_LOG,
 119                                           LOGVIEW_TYPE_LOG);
 120
 121   g_type_class_add_private (klass, sizeof (LogviewManagerPrivate));
 122 }
 123
 124 static void
 125 logview_manager_init (LogviewManager *self)
 126 {
 127   LogviewManagerPrivate *priv = self->priv = GET_PRIVATE (self);
 128
 129   priv->active_log = NULL;
 130   priv->logs = g_hash_table_new_full (g_str_hash, g_str_equal,
 131                                       (GDestroyNotify) g_free, (GDestroyNotify) g_object_unref);
 132 }
 133
 134 static MultipleCreation *
 135 multiple_creation_op_new (int total)
 136 {
 137   MultipleCreation *retval;
 138
 139   retval = g_slice_new0 (MultipleCreation);
 140   retval->total = total;
 141   retval->current = 0;
 142   retval->errors = g_ptr_array_new ();
 143
 144   return retval;
 145 }
 146
 147 static void
 148 multiple_creation_op_free (MultipleCreation *mc)
 149 {
 150   g_ptr_array_foreach (mc->errors, (GFunc) g_strfreev, NULL);
 151   g_ptr_array_free (mc->errors, TRUE);
 152
 153   g_slice_free (MultipleCreation, mc);
 154 }
 155
 156 static void
 157 create_log_cb (LogviewLog *log,
 158                GError *error,
 159                gpointer user_data)
 160 {
 161   CreateCBData *data = user_data;
 162
 163   if (log) {
 164     char *log_uri;
 165     LogviewPrefs *prefs;
 166     GFile *file;
 167
 168     log_uri = logview_log_get_uri (log);
 169
 170     /* creation went well, store the log and notify */
 171     g_hash_table_insert (data->manager->priv->logs,
 172                          log_uri, log);
 173
 174     prefs = logview_prefs_get ();
 175     file = logview_log_get_gfile (log);
 176     logview_prefs_store_log (prefs, file);
 177
 178     g_object_unref (file);
 179
 180     g_signal_emit (data->manager, signals[LOG_ADDED], 0, log, NULL);
 181
 182     if (data->set_active) {
 183       logview_manager_set_active_log (data->manager, log);
 184     }
 185   } else {
 186     char *path;
 187
 188     /* notify the error */
 189     path = g_file_get_path (data->file);
 190
 191     if (!data->is_multiple) {
 192       logview_app_add_error (logview_app_get (),
 193                              path, error->message);
 194     } else {
 195       char **error_arr = g_new0 (char *, 3);
 196
 197       error_arr[0] = g_strdup (path);
 198       error_arr[1] = g_strdup (error->message);
 199       error_arr[2] = NULL;
 200
 201       g_ptr_array_add (op->errors, error_arr);
 202     }
 203
 204     g_free (path);
 205   }
 206
 207   if (data->is_multiple) {
 208     op->current++;
 209
 210     if (op->total == op->current) {
 211       logview_app_add_errors (logview_app_get (), op->errors);
 212       multiple_creation_op_free (op);
 213       op = NULL;
 214     }
 215   }
 216
 217   g_object_unref (data->file);
 218   g_slice_free (CreateCBData, data);
 219 }
 220
 221 static void
 222 add_log_from_gfile_internal (LogviewManager *manager,
 223                              GFile *file,
 224                              gboolean set_active,
 225                              gboolean is_multiple)
 226 {
 227   char *file_uri;
 228   LogviewLog *log;
 229   CreateCBData *data;
 230
 231   file_uri = g_file_get_uri (file);
 232
 233   if (set_active == FALSE) {
 234     /* if it's the first log being added, set it as active anyway */
 235     set_active = (manager->priv->logs == NULL);
 236   }
 237
 238   if ((log = g_hash_table_lookup (manager->priv->logs, file_uri)) != NULL) {
 239     /* log already exists, don't load it */
 240     if (set_active) {
 241       logview_manager_set_active_log (manager, log);
 242     }
 243   } else {
 244     data = g_slice_new0 (CreateCBData);
 245     data->manager = manager;
 246     data->set_active = set_active;
 247     data->is_multiple = is_multiple;
 248     data->file = g_object_ref (file);
 249
 250     logview_log_create_from_gfile (file, create_log_cb, data);
 251   }
 252
 253   g_free (file_uri);
 254 }
 255
 256 static void
 257 logview_manager_add_log_from_name (LogviewManager *manager,
 258                                    const char *filename, gboolean set_active,
 259                                    gboolean is_multiple)
 260 {
 261   GFile *file;
 262
 263   file = g_file_new_for_path (filename);
 264
 265   add_log_from_gfile_internal (manager, file, set_active, is_multiple);
 266
 267   g_object_unref (file);
 268 }
 269
 270 /* public methods */
 271
 272 LogviewManager*
 273 logview_manager_get (void)
 274 {
 275   if (!singleton) {
 276     singleton = g_object_new (LOGVIEW_TYPE_MANAGER, NULL);
 277   }
 278
 279   return singleton;
 280 }
 281
 282 void
 283 logview_manager_set_active_log (LogviewManager *manager,
 284                                 LogviewLog *log)
 285 {
 286   LogviewLog *old_log = NULL;
 287
 288   g_assert (LOGVIEW_IS_MANAGER (manager));
 289
 290   if (manager->priv->active_log) {
 291     old_log = manager->priv->active_log;
 292   }
 293
 294   manager->priv->active_log = g_object_ref (log);
 295
 296   g_signal_emit (manager, signals[ACTIVE_CHANGED], 0, log, old_log, NULL);
 297
 298   if (old_log) {
 299     g_object_unref (old_log);
 300   }
 301 }
 302
 303 LogviewLog *
 304 logview_manager_get_active_log (LogviewManager *manager)
 305 {
 306   g_assert (LOGVIEW_IS_MANAGER (manager));
 307
 308   return (manager->priv->active_log != NULL) ?
 309     g_object_ref (manager->priv->active_log) :
 310     NULL;
 311 }
 312
 313 void
 314 logview_manager_add_log_from_gfile (LogviewManager *manager,
 315                                     GFile *file,
 316                                     gboolean set_active)
 317 {
 318   g_assert (LOGVIEW_IS_MANAGER (manager));
 319
 320   add_log_from_gfile_internal (manager, file, set_active, FALSE);
 321 }
 322
 323 void
 324 logview_manager_add_logs_from_name_list (LogviewManager *manager,
 325                                          GSList *names,
 326                                          const char *active)
 327 {
 328   GSList *l;
 329
 330   g_assert (LOGVIEW_IS_MANAGER (manager));
 331   g_assert (op == NULL);
 332
 333   op = multiple_creation_op_new (g_slist_length (names));
 334
 335   for (l = names; l; l = l->next) {
 336     logview_manager_add_log_from_name (manager, l->data,
 337                                        (g_ascii_strcasecmp (active, l->data) == 0),
 338                                        TRUE);
 339   }
 340 }
 341
 342 void
 343 logview_manager_add_logs_from_names (LogviewManager *manager,
 344                                      char ** names,
 345                                      const gchar *active)
 346 {
 347   int i;
 348   gboolean set_active;
 349
 350   g_assert (LOGVIEW_IS_MANAGER (manager));
 351   g_assert (op == NULL);
 352
 353   op = multiple_creation_op_new (g_strv_length (names));
 354
 355   for (i = 0; names[i]; i++) {
 356     set_active = (active != NULL) && (g_ascii_strcasecmp (active, names[i]));
 357     logview_manager_add_log_from_name (manager, names[i], set_active,
 358                                        TRUE);
 359   }
 360 }
 361
 362 int
 363 logview_manager_get_log_count (LogviewManager *manager)
 364 {
 365   g_assert (LOGVIEW_IS_MANAGER (manager));
 366
 367   return g_hash_table_size (manager->priv->logs);
 368 }
 369
 370 LogviewLog *
 371 logview_manager_get_if_loaded (LogviewManager *manager, char *uri)
 372 {
 373   LogviewLog *log;
 374
 375   g_assert (LOGVIEW_IS_MANAGER (manager));
 376
 377   log = g_hash_table_lookup (manager->priv->logs, uri);
 378
 379   if (log != NULL) {
 380     return g_object_ref (log);
 381   }
 382
 383   return NULL;
 384 }
 385
 386 void
 387 logview_manager_close_active_log (LogviewManager *manager)
 388 {
 389   LogviewLog *active_log;
 390   char *log_uri;
 391   GFile *file;
 392
 393   g_assert (LOGVIEW_IS_MANAGER (manager));
 394
 395   active_log = manager->priv->active_log;
 396   log_uri = logview_log_get_uri (active_log);
 397   file = logview_log_get_gfile (active_log);
 398
 399   g_signal_emit (manager, signals[LOG_CLOSED], 0, active_log, NULL);
 400
 401   logview_prefs_remove_stored_log (logview_prefs_get (), file);
 402
 403   g_object_unref (file);
 404
 405   /* we own two refs to the active log; one is inside the hash table */
 406   g_object_unref (active_log);
 407   g_hash_table_remove (manager->priv->logs, log_uri);
 408
 409   g_free (log_uri);
 410
 411   /* someone else will take care of setting the next active log to us */
 412 }
 413
 414 gboolean
 415 logview_manager_log_is_active (LogviewManager *manager,
 416                                LogviewLog *log)
 417 {
 418   g_assert (LOGVIEW_IS_MANAGER (manager));
 419
 420   return (manager->priv->active_log == log);
 421 }