Pileus Git - ~andy/gtk/blob - gtk/gtkstatusbar.c

   1 /* GTK - The GIMP Toolkit
   2  * Copyright (C) 1995-1997 Peter Mattis, Spencer Kimball and Josh MacDonald
   3  * GtkStatusbar Copyright (C) 1998 Shawn T. Amundson
   4  *
   5  * This library is free software; you can redistribute it and/or
   6  * modify it under the terms of the GNU Library General Public
   7  * License as published by the Free Software Foundation; either
   8  * version 2 of the License, or (at your option) any later version.
   9  *
  10  * This library 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  * Library General Public License for more details.
  14  *
  15  * You should have received a copy of the GNU Library General Public
  16  * License along with this library; if not, write to the
  17  * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
  18  * Boston, MA 02111-1307, USA.
  19  */
  20
  21 #include "gtkframe.h"
  22 #include "gtklabel.h"
  23 #include "gtksignal.h"
  24 #include "gtkstatusbar.h"
  25
  26
  27 enum
  28 {
  29   SIGNAL_TEXT_PUSHED,
  30   SIGNAL_TEXT_POPPED,
  31   SIGNAL_LAST
  32 };
  33
  34 typedef void    (*SignalTextP)                    (GtkObject          *object,
  35                                                    guint               context_id,
  36                                                    const gchar        *text,
  37                                                    gpointer            func_data);
  38
  39 static void gtk_statusbar_class_init               (GtkStatusbarClass *class);
  40 static void gtk_statusbar_init                     (GtkStatusbar      *statusbar);
  41 static void gtk_statusbar_destroy                  (GtkObject         *object);
  42 static void gtk_statusbar_finalize                 (GtkObject         *object);
  43 static void gtk_statusbar_update                   (GtkStatusbar      *statusbar,
  44                                                     guint              context_id,
  45                                                     const gchar       *text);
  46
  47 static GtkContainerClass *parent_class;
  48 static guint              statusbar_signals[SIGNAL_LAST] = { 0 };
  49
  50 guint
  51 gtk_statusbar_get_type (void)
  52 {
  53   static guint statusbar_type = 0;
  54
  55   if (!statusbar_type)
  56     {
  57       GtkTypeInfo statusbar_info =
  58       {
  59         "GtkStatusbar",
  60         sizeof (GtkStatusbar),
  61         sizeof (GtkStatusbarClass),
  62         (GtkClassInitFunc) gtk_statusbar_class_init,
  63         (GtkObjectInitFunc) gtk_statusbar_init,
  64         /* reversed_1 */ NULL,
  65         /* reversed_2 */ NULL,
  66         (GtkClassInitFunc) NULL,
  67       };
  68
  69       statusbar_type = gtk_type_unique (gtk_hbox_get_type (), &statusbar_info);
  70     }
  71
  72   return statusbar_type;
  73 }
  74
  75 static void
  76 gtk_statusbar_marshal_text_p (GtkObject      *object,
  77                               GtkSignalFunc  func,
  78                               gpointer       func_data,
  79                               GtkArg         *args)
  80 {
  81   SignalTextP sfunc = (SignalTextP) func;
  82
  83   (* sfunc) (object,
  84              GTK_VALUE_UINT (args[0]),
  85              GTK_VALUE_STRING (args[1]),
  86              func_data);
  87 }
  88
  89 static void
  90 gtk_statusbar_class_init (GtkStatusbarClass *class)
  91 {
  92   GtkObjectClass *object_class;
  93   GtkWidgetClass *widget_class;
  94   GtkContainerClass *container_class;
  95
  96   object_class = (GtkObjectClass *) class;
  97   widget_class = (GtkWidgetClass *) class;
  98   container_class = (GtkContainerClass *) class;
  99
 100   parent_class = gtk_type_class (gtk_hbox_get_type ());
 101
 102   statusbar_signals[SIGNAL_TEXT_PUSHED] =
 103     gtk_signal_new ("text_pushed",
 104                     GTK_RUN_LAST,
 105                     object_class->type,
 106                     GTK_SIGNAL_OFFSET (GtkStatusbarClass, text_pushed),
 107                     gtk_statusbar_marshal_text_p,
 108                     GTK_TYPE_NONE, 2,
 109                     GTK_TYPE_UINT,
 110                     GTK_TYPE_STRING);
 111   statusbar_signals[SIGNAL_TEXT_POPPED] =
 112     gtk_signal_new ("text_popped",
 113                     GTK_RUN_LAST,
 114                     object_class->type,
 115                     GTK_SIGNAL_OFFSET (GtkStatusbarClass, text_popped),
 116                     gtk_statusbar_marshal_text_p,
 117                     GTK_TYPE_NONE, 2,
 118                     GTK_TYPE_UINT,
 119                     GTK_TYPE_STRING);
 120   gtk_object_class_add_signals (object_class, statusbar_signals, SIGNAL_LAST);
 121
 122   object_class->destroy = gtk_statusbar_destroy;
 123   object_class->finalize = gtk_statusbar_finalize;
 124
 125   class->messages_mem_chunk = g_mem_chunk_new ("GtkStatusBar messages mem chunk",
 126                                                sizeof (GtkStatusbarMsg),
 127                                                sizeof (GtkStatusbarMsg) * 64,
 128                                                G_ALLOC_AND_FREE);
 129
 130   class->text_pushed = gtk_statusbar_update;
 131   class->text_popped = gtk_statusbar_update;
 132 }
 133
 134 static void
 135 gtk_statusbar_init (GtkStatusbar *statusbar)
 136 {
 137   GtkBox *box;
 138
 139   box = GTK_BOX (statusbar);
 140
 141   box->spacing = 2;
 142   box->homogeneous = FALSE;
 143
 144   statusbar->frame = gtk_frame_new (NULL);
 145   gtk_frame_set_shadow_type (GTK_FRAME (statusbar->frame), GTK_SHADOW_IN);
 146   gtk_box_pack_start (box, statusbar->frame, TRUE, TRUE, 0);
 147   gtk_widget_show (statusbar->frame);
 148
 149   statusbar->label = gtk_label_new ("");
 150   gtk_misc_set_alignment (GTK_MISC (statusbar->label), 0.0, 0.0);
 151   gtk_container_add (GTK_CONTAINER (statusbar->frame), statusbar->label);
 152   gtk_widget_show (statusbar->label);
 153
 154   statusbar->seq_context_id = 1;
 155   statusbar->seq_message_id = 1;
 156   statusbar->messages = NULL;
 157   statusbar->keys = NULL;
 158 }
 159
 160 GtkWidget*
 161 gtk_statusbar_new (void)
 162 {
 163   return gtk_type_new (gtk_statusbar_get_type ());
 164 }
 165
 166 static void
 167 gtk_statusbar_update (GtkStatusbar *statusbar,
 168                       guint         context_id,
 169                       const gchar  *text)
 170 {
 171   g_return_if_fail (statusbar != NULL);
 172   g_return_if_fail (GTK_IS_STATUSBAR (statusbar));
 173
 174   if (!text)
 175     text = "";
 176
 177   gtk_label_set (GTK_LABEL (statusbar->label), text);
 178 }
 179
 180 guint
 181 gtk_statusbar_get_context_id (GtkStatusbar *statusbar,
 182                               const gchar  *context_description)
 183 {
 184   gchar *string;
 185   guint *id;
 186
 187   g_return_val_if_fail (statusbar != NULL, 0);
 188   g_return_val_if_fail (GTK_IS_STATUSBAR (statusbar), 0);
 189   g_return_val_if_fail (context_description != NULL, 0);
 190
 191   /* we need to preserve namespaces on object datas */
 192   string = g_strconcat ("gtk-status-bar-context:", context_description, NULL);
 193
 194   id = gtk_object_get_data (GTK_OBJECT (statusbar), string);
 195   if (!id)
 196     {
 197       id = g_new (guint, 1);
 198       *id = statusbar->seq_context_id++;
 199       gtk_object_set_data_full (GTK_OBJECT (statusbar), string, id, (GtkDestroyNotify) g_free);
 200       statusbar->keys = g_slist_prepend (statusbar->keys, string);
 201     }
 202   else
 203     g_free (string);
 204
 205   return *id;
 206 }
 207
 208 guint
 209 gtk_statusbar_push (GtkStatusbar *statusbar,
 210                     guint         context_id,
 211                     const gchar  *text)
 212 {
 213   GtkStatusbarMsg *msg;
 214   GtkStatusbarClass *class;
 215
 216   g_return_val_if_fail (statusbar != NULL, 0);
 217   g_return_val_if_fail (GTK_IS_STATUSBAR (statusbar), 0);
 218   g_return_val_if_fail (text != NULL, 0);
 219   g_return_val_if_fail (context_id > 0, 0);
 220
 221   class = GTK_STATUSBAR_CLASS (GTK_OBJECT (statusbar)->klass);
 222   msg = g_chunk_new (GtkStatusbarMsg, class->messages_mem_chunk);
 223   msg->text = g_strdup (text);
 224   msg->context_id = context_id;
 225   msg->message_id = statusbar->seq_message_id++;
 226
 227   statusbar->messages = g_slist_prepend (statusbar->messages, msg);
 228
 229   gtk_signal_emit (GTK_OBJECT (statusbar),
 230                    statusbar_signals[SIGNAL_TEXT_PUSHED],
 231                    msg->context_id,
 232                    msg->text);
 233
 234   return msg->message_id;
 235 }
 236
 237 void
 238 gtk_statusbar_pop (GtkStatusbar *statusbar,
 239                    guint         context_id)
 240 {
 241   GtkStatusbarMsg *msg;
 242
 243   g_return_if_fail (statusbar != NULL);
 244   g_return_if_fail (GTK_IS_STATUSBAR (statusbar));
 245   g_return_if_fail (context_id > 0);
 246
 247   if (statusbar->messages)
 248     {
 249       GSList *list;
 250
 251       for (list = statusbar->messages; list; list = list->next)
 252         {
 253           msg = list->data;
 254
 255           if (msg->context_id == context_id)
 256             {
 257               GtkStatusbarClass *class;
 258
 259               class = GTK_STATUSBAR_CLASS (GTK_OBJECT (statusbar)->klass);
 260
 261               statusbar->messages = g_slist_remove_link (statusbar->messages,
 262                                                          list);
 263               g_free (msg->text);
 264               g_mem_chunk_free (class->messages_mem_chunk, msg);
 265               g_slist_free_1 (list);
 266               break;
 267             }
 268         }
 269     }
 270
 271   msg = statusbar->messages ? statusbar->messages->data : NULL;
 272
 273   gtk_signal_emit (GTK_OBJECT (statusbar),
 274                    statusbar_signals[SIGNAL_TEXT_POPPED],
 275                    (guint) (msg ? msg->context_id : 0),
 276                    msg ? msg->text : NULL);
 277 }
 278
 279 void
 280 gtk_statusbar_remove (GtkStatusbar *statusbar,
 281                       guint        context_id,
 282                       guint        message_id)
 283 {
 284   GtkStatusbarMsg *msg;
 285
 286   g_return_if_fail (statusbar != NULL);
 287   g_return_if_fail (GTK_IS_STATUSBAR (statusbar));
 288   g_return_if_fail (context_id > 0);
 289   g_return_if_fail (message_id > 0);
 290
 291   msg = statusbar->messages ? statusbar->messages->data : NULL;
 292   if (msg)
 293     {
 294       GSList *list;
 295
 296       /* care about signal emission if the topmost item is removed */
 297       if (msg->context_id == context_id &&
 298           msg->message_id == message_id)
 299         {
 300           gtk_statusbar_pop (statusbar, context_id);
 301           return;
 302         }
 303
 304       for (list = statusbar->messages; list; list = list->next)
 305         {
 306           msg = list->data;
 307
 308           if (msg->context_id == context_id &&
 309               msg->message_id == message_id)
 310             {
 311               GtkStatusbarClass *class;
 312
 313               class = GTK_STATUSBAR_CLASS (GTK_OBJECT (statusbar)->klass);
 314               statusbar->messages = g_slist_remove_link (statusbar->messages, list);
 315               g_free (msg->text);
 316               g_mem_chunk_free (class->messages_mem_chunk, msg);
 317               g_slist_free_1 (list);
 318
 319               break;
 320             }
 321         }
 322     }
 323 }
 324
 325 static void
 326 gtk_statusbar_destroy (GtkObject *object)
 327 {
 328   GtkStatusbar *statusbar;
 329   GtkStatusbarClass *class;
 330   GSList *list;
 331
 332   g_return_if_fail (object != NULL);
 333   g_return_if_fail (GTK_IS_STATUSBAR (object));
 334
 335   statusbar = GTK_STATUSBAR (object);
 336   class = GTK_STATUSBAR_CLASS (GTK_OBJECT (statusbar)->klass);
 337
 338   for (list = statusbar->messages; list; list = list->next)
 339     {
 340       GtkStatusbarMsg *msg;
 341
 342       msg = list->data;
 343       g_free (msg->text);
 344       g_mem_chunk_free (class->messages_mem_chunk, msg);
 345     }
 346   g_slist_free (statusbar->messages);
 347   statusbar->messages = NULL;
 348
 349   for (list = statusbar->keys; list; list = list->next)
 350     g_free (list->data);
 351   g_slist_free (statusbar->keys);
 352   statusbar->keys = NULL;
 353
 354   GTK_OBJECT_CLASS (parent_class)->destroy (object);
 355 }
 356
 357 static void
 358 gtk_statusbar_finalize (GtkObject *object)
 359 {
 360   GtkStatusbar *statusbar;
 361
 362   g_return_if_fail (object != NULL);
 363   g_return_if_fail (GTK_IS_STATUSBAR (object));
 364
 365   statusbar = GTK_STATUSBAR (object);
 366
 367   GTK_OBJECT_CLASS (parent_class)->finalize (object);
 368 }