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

   1 /* GTK - The GIMP Toolkit
   2  * Copyright (C) 1995-1997 Peter Mattis, Spencer Kimball and Josh MacDonald
   3  *
   4  * This library is free software; you can redistribute it and/or
   5  * modify it under the terms of the GNU Library General Public
   6  * License as published by the Free Software Foundation; either
   7  * version 2 of the License, or (at your option) any later version.
   8  *
   9  * This library is distributed in the hope that it will be useful,
  10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  12  * Library General Public License for more details.
  13  *
  14  * You should have received a copy of the GNU Library General Public
  15  * License along with this library; if not, write to the Free
  16  * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  17  */
  18 #include "gtkbox.h"
  19
  20
  21 static void gtk_box_class_init (GtkBoxClass    *klass);
  22 static void gtk_box_init       (GtkBox         *box);
  23 static void gtk_box_destroy    (GtkObject      *object);
  24 static void gtk_box_map        (GtkWidget      *widget);
  25 static void gtk_box_unmap      (GtkWidget      *widget);
  26 static void gtk_box_draw       (GtkWidget      *widget,
  27                                 GdkRectangle   *area);
  28 static gint gtk_box_expose     (GtkWidget      *widget,
  29                                 GdkEventExpose *event);
  30 static void gtk_box_add        (GtkContainer   *container,
  31                                 GtkWidget      *widget);
  32 static void gtk_box_remove     (GtkContainer   *container,
  33                                 GtkWidget      *widget);
  34 static void gtk_box_foreach    (GtkContainer   *container,
  35                                 GtkCallback     callback,
  36                                 gpointer        callback_data);
  37
  38
  39 static GtkContainerClass *parent_class = NULL;
  40
  41
  42 guint
  43 gtk_box_get_type ()
  44 {
  45   static guint box_type = 0;
  46
  47   if (!box_type)
  48     {
  49       GtkTypeInfo box_info =
  50       {
  51         "GtkBox",
  52         sizeof (GtkBox),
  53         sizeof (GtkBoxClass),
  54         (GtkClassInitFunc) gtk_box_class_init,
  55         (GtkObjectInitFunc) gtk_box_init,
  56         (GtkArgFunc) NULL,
  57       };
  58
  59       box_type = gtk_type_unique (gtk_container_get_type (), &box_info);
  60     }
  61
  62   return box_type;
  63 }
  64
  65 static void
  66 gtk_box_class_init (GtkBoxClass *class)
  67 {
  68   GtkObjectClass *object_class;
  69   GtkWidgetClass *widget_class;
  70   GtkContainerClass *container_class;
  71
  72   object_class = (GtkObjectClass*) class;
  73   widget_class = (GtkWidgetClass*) class;
  74   container_class = (GtkContainerClass*) class;
  75
  76   parent_class = gtk_type_class (gtk_container_get_type ());
  77
  78   object_class->destroy = gtk_box_destroy;
  79
  80   widget_class->map = gtk_box_map;
  81   widget_class->unmap = gtk_box_unmap;
  82   widget_class->draw = gtk_box_draw;
  83   widget_class->expose_event = gtk_box_expose;
  84
  85   container_class->add = gtk_box_add;
  86   container_class->remove = gtk_box_remove;
  87   container_class->foreach = gtk_box_foreach;
  88 }
  89
  90 static void
  91 gtk_box_init (GtkBox *box)
  92 {
  93   GTK_WIDGET_SET_FLAGS (box, GTK_NO_WINDOW | GTK_BASIC);
  94
  95   box->children = NULL;
  96   box->spacing = 0;
  97   box->homogeneous = FALSE;
  98 }
  99
 100 void
 101 gtk_box_pack_start (GtkBox    *box,
 102                     GtkWidget *child,
 103                     gint       expand,
 104                     gint       fill,
 105                     gint       padding)
 106 {
 107   GtkBoxChild *child_info;
 108
 109   g_return_if_fail (box != NULL);
 110   g_return_if_fail (GTK_IS_BOX (box));
 111   g_return_if_fail (child != NULL);
 112
 113   child_info = g_new (GtkBoxChild, 1);
 114   child_info->widget = child;
 115   child_info->padding = padding;
 116   child_info->expand = expand ? TRUE : FALSE;
 117   child_info->fill = fill ? TRUE : FALSE;
 118   child_info->pack = GTK_PACK_START;
 119
 120   box->children = g_list_append (box->children, child_info);
 121
 122   gtk_widget_set_parent (child, GTK_WIDGET (box));
 123
 124   if (GTK_WIDGET_VISIBLE (GTK_WIDGET (box)))
 125     {
 126       if (GTK_WIDGET_REALIZED (GTK_WIDGET (box)) &&
 127           !GTK_WIDGET_REALIZED (child))
 128         gtk_widget_realize (child);
 129
 130       if (GTK_WIDGET_MAPPED (GTK_WIDGET (box)) &&
 131           !GTK_WIDGET_MAPPED (child))
 132         gtk_widget_map (child);
 133     }
 134
 135   if (GTK_WIDGET_VISIBLE (child) && GTK_WIDGET_VISIBLE (box))
 136     gtk_widget_queue_resize (child);
 137 }
 138
 139 void
 140 gtk_box_pack_end (GtkBox    *box,
 141                   GtkWidget *child,
 142                   gint       expand,
 143                   gint       fill,
 144                   gint       padding)
 145 {
 146   GtkBoxChild *child_info;
 147
 148   g_return_if_fail (box != NULL);
 149   g_return_if_fail (GTK_IS_BOX (box));
 150   g_return_if_fail (child != NULL);
 151
 152   child_info = g_new (GtkBoxChild, 1);
 153   child_info->widget = child;
 154   child_info->padding = padding;
 155   child_info->expand = expand ? TRUE : FALSE;
 156   child_info->fill = fill ? TRUE : FALSE;
 157   child_info->pack = GTK_PACK_END;
 158
 159   box->children = g_list_append (box->children, child_info);
 160
 161   gtk_widget_set_parent (child, GTK_WIDGET (box));
 162
 163   if (GTK_WIDGET_VISIBLE (GTK_WIDGET (box)))
 164     {
 165       if (GTK_WIDGET_REALIZED (GTK_WIDGET (box)) &&
 166           !GTK_WIDGET_REALIZED (child))
 167         gtk_widget_realize (child);
 168
 169       if (GTK_WIDGET_MAPPED (GTK_WIDGET (box)) &&
 170           !GTK_WIDGET_MAPPED (child))
 171         gtk_widget_map (child);
 172     }
 173
 174   if (GTK_WIDGET_VISIBLE (child) && GTK_WIDGET_VISIBLE (box))
 175     gtk_widget_queue_resize (child);
 176 }
 177
 178 void
 179 gtk_box_pack_start_defaults (GtkBox    *box,
 180                              GtkWidget *child)
 181 {
 182   g_return_if_fail (box != NULL);
 183   g_return_if_fail (GTK_IS_BOX (box));
 184   g_return_if_fail (child != NULL);
 185
 186   gtk_box_pack_start (box, child, TRUE, TRUE, 0);
 187 }
 188
 189 void
 190 gtk_box_pack_end_defaults (GtkBox    *box,
 191                            GtkWidget *child)
 192 {
 193   g_return_if_fail (box != NULL);
 194   g_return_if_fail (GTK_IS_BOX (box));
 195   g_return_if_fail (child != NULL);
 196
 197   gtk_box_pack_end (box, child, TRUE, TRUE, 0);
 198 }
 199
 200 void
 201 gtk_box_set_homogeneous (GtkBox *box,
 202                          gint    homogeneous)
 203 {
 204   g_return_if_fail (box != NULL);
 205   g_return_if_fail (GTK_IS_BOX (box));
 206
 207   if ((homogeneous ? TRUE : FALSE) != box->homogeneous)
 208     {
 209       box->homogeneous = homogeneous ? TRUE : FALSE;
 210       gtk_widget_queue_resize (GTK_WIDGET (box));
 211     }
 212 }
 213
 214 void
 215 gtk_box_set_spacing (GtkBox *box,
 216                      gint    spacing)
 217 {
 218   g_return_if_fail (box != NULL);
 219   g_return_if_fail (GTK_IS_BOX (box));
 220
 221   if (spacing != box->spacing)
 222     {
 223       box->spacing = spacing;
 224       gtk_widget_queue_resize (GTK_WIDGET (box));
 225     }
 226 }
 227
 228
 229 static void
 230 gtk_box_destroy (GtkObject *object)
 231 {
 232   GtkBox *box;
 233   GtkBoxChild *child;
 234   GList *children;
 235
 236   g_return_if_fail (object != NULL);
 237   g_return_if_fail (GTK_IS_BOX (object));
 238
 239   box = GTK_BOX (object);
 240
 241   children = box->children;
 242   while (children)
 243     {
 244       child = children->data;
 245       children = children->next;
 246
 247       child->widget->parent = NULL;
 248       gtk_object_unref (GTK_OBJECT (child->widget));
 249       gtk_widget_destroy (child->widget);
 250       g_free (child);
 251     }
 252
 253   g_list_free (box->children);
 254
 255   if (GTK_OBJECT_CLASS (parent_class)->destroy)
 256     (* GTK_OBJECT_CLASS (parent_class)->destroy) (object);
 257 }
 258
 259 static void
 260 gtk_box_map (GtkWidget *widget)
 261 {
 262   GtkBox *box;
 263   GtkBoxChild *child;
 264   GList *children;
 265
 266   g_return_if_fail (widget != NULL);
 267   g_return_if_fail (GTK_IS_BOX (widget));
 268
 269   box = GTK_BOX (widget);
 270   GTK_WIDGET_SET_FLAGS (box, GTK_MAPPED);
 271
 272   children = box->children;
 273   while (children)
 274     {
 275       child = children->data;
 276       children = children->next;
 277
 278       if (GTK_WIDGET_VISIBLE (child->widget) &&
 279           !GTK_WIDGET_MAPPED (child->widget))
 280         gtk_widget_map (child->widget);
 281     }
 282 }
 283
 284 static void
 285 gtk_box_unmap (GtkWidget *widget)
 286 {
 287   GtkBox *box;
 288   GtkBoxChild *child;
 289   GList *children;
 290
 291   g_return_if_fail (widget != NULL);
 292   g_return_if_fail (GTK_IS_BOX (widget));
 293
 294   box = GTK_BOX (widget);
 295   GTK_WIDGET_UNSET_FLAGS (box, GTK_MAPPED);
 296
 297   children = box->children;
 298   while (children)
 299     {
 300       child = children->data;
 301       children = children->next;
 302
 303       if (GTK_WIDGET_VISIBLE (child->widget) &&
 304           GTK_WIDGET_MAPPED (child->widget))
 305         gtk_widget_unmap (child->widget);
 306     }
 307 }
 308
 309 static void
 310 gtk_box_draw (GtkWidget    *widget,
 311               GdkRectangle *area)
 312 {
 313   GtkBox *box;
 314   GtkBoxChild *child;
 315   GdkRectangle child_area;
 316   GList *children;
 317
 318   g_return_if_fail (widget != NULL);
 319   g_return_if_fail (GTK_IS_BOX (widget));
 320
 321   if (GTK_WIDGET_DRAWABLE (widget))
 322     {
 323       box = GTK_BOX (widget);
 324
 325       children = box->children;
 326       while (children)
 327         {
 328           child = children->data;
 329           children = children->next;
 330
 331           if (gtk_widget_intersect (child->widget, area, &child_area))
 332             gtk_widget_draw (child->widget, &child_area);
 333         }
 334     }
 335 }
 336
 337 static gint
 338 gtk_box_expose (GtkWidget      *widget,
 339                 GdkEventExpose *event)
 340 {
 341   GtkBox *box;
 342   GtkBoxChild *child;
 343   GdkEventExpose child_event;
 344   GList *children;
 345
 346   g_return_val_if_fail (widget != NULL, FALSE);
 347   g_return_val_if_fail (GTK_IS_BOX (widget), FALSE);
 348   g_return_val_if_fail (event != NULL, FALSE);
 349
 350   if (GTK_WIDGET_DRAWABLE (widget))
 351     {
 352       box = GTK_BOX (widget);
 353
 354       child_event = *event;
 355
 356       children = box->children;
 357       while (children)
 358         {
 359           child = children->data;
 360           children = children->next;
 361
 362           if (GTK_WIDGET_NO_WINDOW (child->widget) &&
 363               gtk_widget_intersect (child->widget, &event->area, &child_event.area))
 364             gtk_widget_event (child->widget, (GdkEvent*) &child_event);
 365         }
 366     }
 367
 368   return FALSE;
 369 }
 370
 371 static void
 372 gtk_box_add (GtkContainer *container,
 373              GtkWidget    *widget)
 374 {
 375   g_return_if_fail (container != NULL);
 376   g_return_if_fail (GTK_IS_BOX (container));
 377   g_return_if_fail (widget != NULL);
 378
 379   gtk_box_pack_start_defaults (GTK_BOX (container), widget);
 380 }
 381
 382 static void
 383 gtk_box_remove (GtkContainer *container,
 384                 GtkWidget    *widget)
 385 {
 386   GtkBox *box;
 387   GtkBoxChild *child;
 388   GList *children;
 389
 390   g_return_if_fail (container != NULL);
 391   g_return_if_fail (GTK_IS_BOX (container));
 392   g_return_if_fail (widget != NULL);
 393
 394   box = GTK_BOX (container);
 395
 396   children = box->children;
 397   while (children)
 398     {
 399       child = children->data;
 400
 401       if (child->widget == widget)
 402         {
 403           gtk_widget_unparent (widget);
 404
 405           box->children = g_list_remove_link (box->children, children);
 406           g_list_free (children);
 407           g_free (child);
 408
 409           if (GTK_WIDGET_VISIBLE (widget) && GTK_WIDGET_VISIBLE (container))
 410             gtk_widget_queue_resize (GTK_WIDGET (container));
 411
 412           break;
 413         }
 414
 415       children = children->next;
 416     }
 417 }
 418
 419 static void
 420 gtk_box_foreach (GtkContainer *container,
 421                  GtkCallback   callback,
 422                  gpointer      callback_data)
 423 {
 424   GtkBox *box;
 425   GtkBoxChild *child;
 426   GList *children;
 427
 428   g_return_if_fail (container != NULL);
 429   g_return_if_fail (GTK_IS_BOX (container));
 430   g_return_if_fail (callback != NULL);
 431
 432   box = GTK_BOX (container);
 433
 434   children = box->children;
 435   while (children)
 436     {
 437       child = children->data;
 438       children = children->next;
 439
 440       if (child->pack == GTK_PACK_START)
 441         (* callback) (child->widget, callback_data);
 442     }
 443
 444   children = g_list_last (box->children);
 445   while (children)
 446     {
 447       child = children->data;
 448       children = children->prev;
 449
 450       if (child->pack == GTK_PACK_END)
 451         (* callback) (child->widget, callback_data);
 452     }
 453 }