libanjuta/anjuta-status.c

   1 /* -*- Mode: C; indent-tabs-mode: t; c-basic-offset: 4; tab-width: 4 -*- */
   2 /*
   3  * anjuta-status.c
   4  * Copyright (C) 2004 Naba Kumar  <naba@gnome.org>
   5  *
   6  * This program is free software; you can redistribute it and/or modify it
   7  * under the terms of the GNU General Public License as published by the Free
   8  * Software Foundation; either version 2 of the License, or (at your option)
   9  * any later version.
  10  *
  11  * This program is distributed in the hope that it will be useful, but
  12  * WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
  13  * or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  14  * for more details.
  15  *
  16  * You should have received a copy of the GNU General Public License along
  17  * with this program; if not, write to the Free Software Foundation, Inc., 59
  18  * 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
  19  */
  20
  21 /**
  22  * SECTION:anjuta-status
  23  * @short_description: Program status such as status message, progress etc.
  24  * @see_also:
  25  * @stability: Unstable
  26  * @include: libanjuta/anjuta-status.h
  27  *
  28  */
  29
  30 #include <config.h>
  31 #include <gtk/gtkwindow.h>
  32 #include <libanjuta/anjuta-status.h>
  33 #include <libanjuta/anjuta-utils.h>
  34 #include <libanjuta/resources.h>
  35 #include <libanjuta/e-splash.h>
  36
  37 struct _AnjutaStatusPriv
  38 {
  39         GHashTable *default_status_items;
  40         gint busy_count;
  41         GHashTable *widgets;
  42
  43         /* Progress bar */
  44         gint total_ticks;
  45         gint current_ticks;
  46
  47         /* Splash */
  48         GtkWidget *splash;
  49         gboolean disable_splash;
  50         gchar *splash_file;
  51         gint splash_progress_position;
  52
  53         /* Title window */
  54         GtkWindow *window;
  55 };
  56
  57 enum {
  58         BUSY,
  59         LAST_SIGNAL
  60 };
  61
  62 static gpointer parent_class = NULL;
  63 static guint status_signals[LAST_SIGNAL] = { 0 };
  64
  65 static void on_widget_destroy (AnjutaStatus *status, GObject *widget);
  66
  67 static void
  68 anjuta_status_finalize (GObject *widget)
  69 {
  70         g_free(ANJUTA_STATUS(widget)->priv);
  71         GNOME_CALL_PARENT(G_OBJECT_CLASS, finalize, (widget));
  72 }
  73
  74 static void
  75 foreach_widget_unref (gpointer key, gpointer value, gpointer data)
  76 {
  77         g_object_weak_unref (G_OBJECT (key), (GWeakNotify) on_widget_destroy, data);
  78 }
  79
  80 static void
  81 anjuta_status_dispose (GObject *widget)
  82 {
  83         AnjutaStatus *status;
  84
  85         status = ANJUTA_STATUS (widget);
  86
  87         if (status->priv->default_status_items)
  88         {
  89                 g_hash_table_destroy (status->priv->default_status_items);
  90                 status->priv->default_status_items = NULL;
  91         }
  92         if (status->priv->splash != NULL) {
  93                 gtk_widget_destroy (status->priv->splash);
  94                 status->priv->splash = NULL;
  95         }
  96         if (status->priv->splash_file)
  97         {
  98                 g_free (status->priv->splash_file);
  99                 status->priv->splash_file = NULL;
 100         }
 101         if (status->priv->widgets)
 102         {
 103                 g_hash_table_foreach (status->priv->widgets,
 104                                                           foreach_widget_unref, widget);
 105                 g_hash_table_destroy (status->priv->widgets);
 106                 status->priv->widgets = NULL;
 107         }
 108
 109         GNOME_CALL_PARENT(G_OBJECT_CLASS, dispose, (widget));
 110 }
 111
 112 static void
 113 anjuta_status_instance_init (AnjutaStatus *status)
 114 {
 115         status->priv = g_new0 (AnjutaStatusPriv, 1);
 116         status->priv->splash_file = NULL;
 117         status->priv->splash_progress_position = 0;
 118         status->priv->disable_splash = FALSE;
 119         status->priv->total_ticks = 0;
 120         status->priv->current_ticks = 0;
 121         status->priv->splash = NULL;
 122         status->priv->default_status_items =
 123                 g_hash_table_new_full (g_str_hash, g_str_equal,
 124                                                            g_free, g_free);
 125 }
 126
 127 static void
 128 anjuta_status_class_init (AnjutaStatusClass *class)
 129 {
 130         GObjectClass *object_class;
 131
 132         parent_class = g_type_class_peek_parent (class);
 133         object_class = (GObjectClass*) class;
 134         object_class->finalize = anjuta_status_finalize;
 135         object_class->dispose = anjuta_status_dispose;
 136
 137         status_signals[BUSY] =
 138                 g_signal_new ("busy",
 139                                   ANJUTA_TYPE_STATUS,
 140                                   G_SIGNAL_RUN_LAST,
 141                                   G_STRUCT_OFFSET (AnjutaStatusClass, busy),
 142                                   NULL, NULL,
 143                                   g_cclosure_marshal_VOID__BOOLEAN,
 144                                   G_TYPE_NONE, 1,
 145                                   G_TYPE_BOOLEAN);
 146 }
 147
 148 GtkWidget *
 149 anjuta_status_new (void)
 150 {
 151         GtkWidget *status;
 152
 153         status = GTK_WIDGET (g_object_new (ANJUTA_TYPE_STATUS,
 154                                                  "has-progress", TRUE, "has-status", TRUE,
 155                                                  "interactivity", GNOME_PREFERENCES_NEVER, NULL));
 156         return status;
 157 }
 158
 159 void
 160 anjuta_status_set (AnjutaStatus *status, const gchar * mesg, ...)
 161 {
 162         gchar* message;
 163         va_list args;
 164
 165         g_return_if_fail (ANJUTA_IS_STATUS (status));
 166         g_return_if_fail (mesg != NULL);
 167
 168         va_start (args, mesg);
 169         message = g_strdup_vprintf (mesg, args);
 170         va_end (args);
 171         gnome_appbar_set_status (GNOME_APPBAR (status), message);
 172         g_free(message);
 173 }
 174
 175 void
 176 anjuta_status_push (AnjutaStatus *status, const gchar * mesg, ...)
 177 {
 178         gchar* message;
 179         va_list args;
 180
 181         g_return_if_fail (ANJUTA_IS_STATUS (status));
 182         g_return_if_fail (mesg != NULL);
 183
 184         va_start (args, mesg);
 185         message = g_strdup_vprintf (mesg, args);
 186         va_end (args);
 187         gnome_appbar_push (GNOME_APPBAR (status), message);
 188         g_free(message);
 189 }
 190
 191 static void
 192 foreach_widget_set_cursor (gpointer widget, gpointer value, gpointer cursor)
 193 {
 194         if (GTK_WIDGET (widget)->window)
 195                 gdk_window_set_cursor (GTK_WIDGET (widget)->window, (GdkCursor*)cursor);
 196 }
 197
 198 void
 199 anjuta_status_busy_push (AnjutaStatus *status)
 200 {
 201         GtkWidget *top;
 202         GdkCursor *cursor;
 203
 204         g_return_if_fail (ANJUTA_IS_STATUS (status));
 205
 206         top = gtk_widget_get_toplevel (GTK_WIDGET (status));
 207         if (top == NULL)
 208                 return;
 209
 210         status->priv->busy_count++;
 211         if (status->priv->busy_count > 1)
 212                 return;
 213         cursor = gdk_cursor_new (GDK_WATCH);
 214         if (GTK_WIDGET (top)->window)
 215                 gdk_window_set_cursor (GTK_WIDGET (top)->window, cursor);
 216         if (status->priv->widgets)
 217                 g_hash_table_foreach (status->priv->widgets,
 218                                                           foreach_widget_set_cursor, cursor);
 219         gdk_cursor_unref (cursor);
 220         gdk_flush ();
 221         g_signal_emit_by_name (G_OBJECT (status), "busy", TRUE);
 222 }
 223
 224 void
 225 anjuta_status_busy_pop (AnjutaStatus *status)
 226 {
 227         GtkWidget *top;
 228
 229         g_return_if_fail (ANJUTA_IS_STATUS (status));
 230
 231         top = gtk_widget_get_toplevel (GTK_WIDGET (status));
 232         if (top == NULL)
 233                 return;
 234
 235         status->priv->busy_count--;
 236         if (status->priv->busy_count > 0)
 237                 return;
 238
 239         status->priv->busy_count = 0;
 240         if (GTK_WIDGET (top)->window)
 241                 gdk_window_set_cursor (GTK_WIDGET (top)->window, NULL);
 242         if (status->priv->widgets)
 243                 g_hash_table_foreach (status->priv->widgets,
 244                                                           foreach_widget_set_cursor, NULL);
 245         g_signal_emit_by_name (G_OBJECT (status), "busy", FALSE);
 246 }
 247
 248 static void
 249 foreach_hash (gpointer key, gpointer value, gpointer userdata)
 250 {
 251         GString *str = (GString*)(userdata);
 252         const gchar *divider = ": ";
 253         const gchar *separator = "    ";
 254
 255         g_string_append (str, separator);
 256         g_string_append (str, (const gchar*)key);
 257         g_string_append (str, divider);
 258         g_string_append (str, (const gchar*)value);
 259 }
 260
 261 void
 262 anjuta_status_set_default (AnjutaStatus *status, const gchar *label,
 263                                                    const gchar *value_format, ...)
 264 {
 265         GString *str;
 266         gchar *status_str;
 267
 268         g_return_if_fail (ANJUTA_IS_STATUS (status));
 269         g_return_if_fail (label != NULL);
 270
 271         if (value_format)
 272         {
 273                 gchar* value;
 274                 va_list args;
 275
 276                 va_start (args, value_format);
 277                 value = g_strdup_vprintf (value_format, args);
 278                 va_end (args);
 279                 g_hash_table_replace (status->priv->default_status_items,
 280                                                           g_strdup (label), value);
 281         }
 282         else
 283         {
 284                 if (g_hash_table_lookup (status->priv->default_status_items, label))
 285                 {
 286                         g_hash_table_remove (status->priv->default_status_items, label);
 287                 }
 288         }
 289
 290         /* Update default status */
 291         str = g_string_new (NULL);
 292         g_hash_table_foreach (status->priv->default_status_items, foreach_hash, str);
 293         status_str = g_string_free (str, FALSE);
 294         gnome_appbar_set_default (GNOME_APPBAR (status), status_str);
 295         g_free (status_str);
 296 }
 297
 298 static void
 299 on_widget_destroy (AnjutaStatus *status, GObject *widget)
 300 {
 301         if (g_hash_table_lookup (status->priv->widgets, widget))
 302                 g_hash_table_remove (status->priv->widgets, widget);
 303 }
 304
 305 void
 306 anjuta_status_add_widget (AnjutaStatus *status, GtkWidget *widget)
 307 {
 308         g_return_if_fail (ANJUTA_IS_STATUS (status));
 309         g_return_if_fail (GTK_IS_WIDGET (widget));
 310
 311         if (status->priv->widgets == NULL)
 312                 status->priv->widgets =
 313                         g_hash_table_new (g_direct_hash, g_direct_equal);
 314
 315         g_hash_table_insert (status->priv->widgets, widget, widget);
 316         g_object_weak_ref (G_OBJECT (widget),
 317                                            (GWeakNotify) (on_widget_destroy), status);
 318 }
 319
 320 void
 321 anjuta_status_set_splash (AnjutaStatus *status, const gchar *splash_file,
 322                                                   gint splash_progress_position)
 323 {
 324         g_return_if_fail (ANJUTA_IS_STATUS (status));
 325         g_return_if_fail (splash_file != NULL);
 326         g_return_if_fail (splash_progress_position >= 0);
 327         if (status->priv->splash_file)
 328                 g_free (status->priv->splash_file);
 329         status->priv->splash_file = g_strdup (splash_file);
 330         status->priv->splash_progress_position = splash_progress_position;
 331 }
 332
 333 void
 334 anjuta_status_disable_splash (AnjutaStatus *status,
 335                                                           gboolean disable_splash)
 336 {
 337         g_return_if_fail (ANJUTA_IS_STATUS (status));
 338
 339         status->priv->disable_splash = disable_splash;
 340         if (status->priv->splash)
 341         {
 342                 gtk_widget_destroy (status->priv->splash);
 343                 status->priv->splash = NULL;
 344                 anjuta_status_progress_add_ticks (status, 0);
 345         }
 346 }
 347
 348 void
 349 anjuta_status_progress_add_ticks (AnjutaStatus *status, gint ticks)
 350 {
 351         gfloat percentage;
 352
 353         g_return_if_fail (ANJUTA_IS_STATUS (status));
 354         g_return_if_fail (ticks >= 0);
 355
 356         status->priv->total_ticks += ticks;
 357         if (!GTK_WIDGET_REALIZED (status))
 358         {
 359                 if (status->priv->splash == NULL &&
 360                         status->priv->splash_file &&
 361                         !status->priv->disable_splash)
 362                 {
 363                         status->priv->splash = e_splash_new (status->priv->splash_file, 100);
 364                         if (status->priv->splash)
 365                                         gtk_widget_show (status->priv->splash);
 366                 }
 367         }
 368         percentage = ((gfloat)status->priv->current_ticks)/status->priv->total_ticks;
 369         if (status->priv->splash)
 370         {
 371                 e_splash_set (E_SPLASH(status->priv->splash), NULL, NULL, NULL,
 372                                           percentage);
 373                 while (g_main_context_iteration(NULL, FALSE));
 374         }
 375         else
 376         {
 377                 GtkProgressBar *progressbar;
 378                 GtkWidget *statusbar;
 379
 380                 gnome_appbar_set_progress_percentage (GNOME_APPBAR (status),
 381                                                                                           percentage);
 382                 progressbar = gnome_appbar_get_progress (GNOME_APPBAR (status));
 383                 statusbar = gnome_appbar_get_status (GNOME_APPBAR (status));
 384                 gtk_widget_queue_draw (GTK_WIDGET (statusbar));
 385                 gtk_widget_queue_draw (GTK_WIDGET (progressbar));
 386                 if (GTK_WIDGET(progressbar)->window != NULL &&
 387                         GDK_IS_WINDOW(GTK_WIDGET(progressbar)->window))
 388                         gdk_window_process_updates (GTK_WIDGET(progressbar)->window, TRUE);
 389                 if (GTK_WIDGET(statusbar)->window != NULL &&
 390                         GDK_IS_WINDOW(GTK_WIDGET(statusbar)->window))
 391                         gdk_window_process_updates (GTK_WIDGET(statusbar)->window, TRUE);
 392         }
 393 }
 394
 395 void
 396 anjuta_status_progress_tick (AnjutaStatus *status,
 397                                                          GdkPixbuf *icon, const gchar *text)
 398 {
 399         gfloat percentage;
 400
 401         g_return_if_fail (ANJUTA_IS_STATUS (status));
 402         g_return_if_fail (status->priv->total_ticks != 0);
 403
 404         status->priv->current_ticks++;
 405         percentage = ((gfloat)status->priv->current_ticks)/status->priv->total_ticks;
 406
 407         if (status->priv->splash)
 408         {
 409                 e_splash_set (E_SPLASH(status->priv->splash), icon, text, NULL, percentage);
 410                 while (g_main_context_iteration(NULL, FALSE));
 411         }
 412         else
 413         {
 414                 GtkProgressBar *progressbar;
 415                 GtkWidget *statusbar;
 416
 417                 if (text)
 418                         anjuta_status_set (status, "%s", text);
 419                 gnome_appbar_set_progress_percentage (GNOME_APPBAR (status),
 420                                                                                           percentage);
 421                 progressbar = gnome_appbar_get_progress (GNOME_APPBAR (status));
 422                 statusbar = gnome_appbar_get_status (GNOME_APPBAR (status));
 423                 gtk_widget_queue_draw (GTK_WIDGET (statusbar));
 424                 gtk_widget_queue_draw (GTK_WIDGET (progressbar));
 425                 if (GTK_WIDGET(progressbar)->window != NULL &&
 426                         GDK_IS_WINDOW(GTK_WIDGET(progressbar)->window))
 427                         gdk_window_process_updates (GTK_WIDGET(progressbar)->window, TRUE);
 428                 if (GTK_WIDGET(statusbar)->window != NULL &&
 429                         GDK_IS_WINDOW(GTK_WIDGET(statusbar)->window))
 430                         gdk_window_process_updates (GTK_WIDGET(statusbar)->window, TRUE);
 431         }
 432         if (status->priv->current_ticks >= status->priv->total_ticks)
 433                 anjuta_status_progress_reset (status);
 434 }
 435
 436 void
 437 anjuta_status_progress_reset (AnjutaStatus *status)
 438 {
 439         g_return_if_fail (ANJUTA_IS_STATUS (status));
 440         if (status->priv->splash)
 441         {
 442                 gtk_widget_destroy (status->priv->splash);
 443                 status->priv->splash = NULL;
 444         }
 445         status->priv->current_ticks = 0;
 446         status->priv->total_ticks = 0;
 447         gnome_appbar_set_progress_percentage (GNOME_APPBAR (status), 0);
 448         gnome_appbar_refresh (GNOME_APPBAR(status));
 449 }
 450
 451 static gboolean
 452 anjuta_status_timeout (AnjutaStatus *status)
 453 {
 454         anjuta_status_pop (status);
 455         return FALSE;
 456 }
 457
 458 /* Display message in status until timeout (secondes) */
 459 void
 460 anjuta_status (AnjutaStatus *status, const gchar *mesg, gint timeout)
 461 {
 462         g_return_if_fail (ANJUTA_IS_STATUS (status));
 463         g_return_if_fail (mesg != NULL);
 464         anjuta_status_push (status, "%s", mesg);
 465         g_timeout_add (timeout * 1000, (void*) anjuta_status_timeout, status);
 466 }
 467
 468 void
 469 anjuta_status_set_title_window (AnjutaStatus *status, GtkWidget *window)
 470 {
 471         g_return_if_fail (ANJUTA_IS_STATUS (status));
 472         g_return_if_fail (GTK_IS_WINDOW (window));
 473         status->priv->window = GTK_WINDOW (window);
 474         g_object_add_weak_pointer (G_OBJECT (window),
 475                                                            (gpointer*)(gpointer)&status->priv->window);
 476 }
 477
 478 void
 479 anjuta_status_set_title (AnjutaStatus *status, const gchar *title)
 480 {
 481         g_return_if_fail (ANJUTA_IS_STATUS (status));
 482
 483         if (!status->priv->window)
 484                 return;
 485
 486         const gchar *app_name = g_get_application_name();
 487         if (title)
 488         {
 489                 gchar* str = g_strconcat (app_name, " - ", title, NULL);
 490                 gtk_window_set_title (status->priv->window, str);
 491                 g_free (str);
 492         }
 493         else
 494         {
 495                 gtk_window_set_title (status->priv->window, app_name);
 496         }
 497 }
 498
 499 ANJUTA_TYPE_BEGIN(AnjutaStatus, anjuta_status, GNOME_TYPE_APPBAR);
 500 ANJUTA_TYPE_END;