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 enum {
  21   ARG_0,
  22   ARG_SPACING,
  23   ARG_HOMOGENEOUS
  24 };
  25
  26 static void gtk_box_class_init (GtkBoxClass    *klass);
  27 static void gtk_box_init       (GtkBox         *box);
  28 static void gtk_box_get_arg    (GtkBox         *box,
  29                                 GtkArg         *arg,
  30                                 guint           arg_id);
  31 static void gtk_box_set_arg    (GtkBox         *box,
  32                                 GtkArg         *arg,
  33                                 guint           arg_id);
  34 static void gtk_box_destroy    (GtkObject      *object);
  35 static void gtk_box_map        (GtkWidget      *widget);
  36 static void gtk_box_unmap      (GtkWidget      *widget);
  37 static void gtk_box_draw       (GtkWidget      *widget,
  38                                 GdkRectangle   *area);
  39 static gint gtk_box_expose     (GtkWidget      *widget,
  40                                 GdkEventExpose *event);
  41 static void gtk_box_add        (GtkContainer   *container,
  42                                 GtkWidget      *widget);
  43 static void gtk_box_remove     (GtkContainer   *container,
  44                                 GtkWidget      *widget);
  45 static void gtk_box_foreach    (GtkContainer   *container,
  46                                 GtkCallback     callback,
  47                                 gpointer        callback_data);
  48
  49
  50 static GtkContainerClass *parent_class = NULL;
  51
  52
  53 guint
  54 gtk_box_get_type ()
  55 {
  56   static guint box_type = 0;
  57
  58   if (!box_type)
  59     {
  60       GtkTypeInfo box_info =
  61       {
  62         "GtkBox",
  63         sizeof (GtkBox),
  64         sizeof (GtkBoxClass),
  65         (GtkClassInitFunc) gtk_box_class_init,
  66         (GtkObjectInitFunc) gtk_box_init,
  67         (GtkArgSetFunc) gtk_box_set_arg,
  68         (GtkArgGetFunc) gtk_box_get_arg,
  69       };
  70
  71       box_type = gtk_type_unique (gtk_container_get_type (), &box_info);
  72     }
  73
  74   return box_type;
  75 }
  76
  77 static void
  78 gtk_box_class_init (GtkBoxClass *class)
  79 {
  80   GtkObjectClass *object_class;
  81   GtkWidgetClass *widget_class;
  82   GtkContainerClass *container_class;
  83
  84   object_class = (GtkObjectClass*) class;
  85   widget_class = (GtkWidgetClass*) class;
  86   container_class = (GtkContainerClass*) class;
  87
  88   parent_class = gtk_type_class (gtk_container_get_type ());
  89
  90   gtk_object_add_arg_type ("GtkBox::spacing", GTK_TYPE_INT, ARG_SPACING);
  91   gtk_object_add_arg_type ("GtkBox::homogeneous", GTK_TYPE_BOOL, ARG_HOMOGENEOUS);
  92
  93   object_class->destroy = gtk_box_destroy;
  94
  95   widget_class->map = gtk_box_map;
  96   widget_class->unmap = gtk_box_unmap;
  97   widget_class->draw = gtk_box_draw;
  98   widget_class->expose_event = gtk_box_expose;
  99
 100   container_class->add = gtk_box_add;
 101   container_class->remove = gtk_box_remove;
 102   container_class->foreach = gtk_box_foreach;
 103 }
 104
 105 static void
 106 gtk_box_init (GtkBox *box)
 107 {
 108   GTK_WIDGET_SET_FLAGS (box, GTK_NO_WINDOW | GTK_BASIC);
 109
 110   box->children = NULL;
 111   box->spacing = 0;
 112   box->homogeneous = FALSE;
 113 }
 114
 115 static void
 116 gtk_box_set_arg (GtkBox       *box,
 117                  GtkArg       *arg,
 118                  guint         arg_id)
 119 {
 120   switch (arg_id)
 121     {
 122     case ARG_SPACING:
 123       gtk_box_set_spacing (box, GTK_VALUE_INT (*arg));
 124       break;
 125     case ARG_HOMOGENEOUS:
 126       gtk_box_set_homogeneous (box, GTK_VALUE_BOOL (*arg));
 127       break;
 128     }
 129 }
 130
 131 static void
 132 gtk_box_get_arg (GtkBox       *box,
 133                  GtkArg       *arg,
 134                  guint         arg_id)
 135 {
 136   switch (arg_id)
 137     {
 138     case ARG_SPACING:
 139       GTK_VALUE_INT (*arg) = box->spacing;
 140       break;
 141     case ARG_HOMOGENEOUS:
 142       GTK_VALUE_BOOL (*arg) = box->homogeneous;
 143       break;
 144     default:
 145       arg->type = GTK_TYPE_INVALID;
 146       break;
 147     }
 148 }
 149
 150 void
 151 gtk_box_pack_start (GtkBox    *box,
 152                     GtkWidget *child,
 153                     gint       expand,
 154                     gint       fill,
 155                     gint       padding)
 156 {
 157   GtkBoxChild *child_info;
 158
 159   g_return_if_fail (box != NULL);
 160   g_return_if_fail (GTK_IS_BOX (box));
 161   g_return_if_fail (child != NULL);
 162
 163   child_info = g_new (GtkBoxChild, 1);
 164   child_info->widget = child;
 165   child_info->padding = padding;
 166   child_info->expand = expand ? TRUE : FALSE;
 167   child_info->fill = fill ? TRUE : FALSE;
 168   child_info->pack = GTK_PACK_START;
 169
 170   box->children = g_list_append (box->children, child_info);
 171
 172   gtk_widget_set_parent (child, GTK_WIDGET (box));
 173
 174   if (GTK_WIDGET_VISIBLE (GTK_WIDGET (box)))
 175     {
 176       if (GTK_WIDGET_REALIZED (GTK_WIDGET (box)) &&
 177           !GTK_WIDGET_REALIZED (child))
 178         gtk_widget_realize (child);
 179
 180       if (GTK_WIDGET_MAPPED (GTK_WIDGET (box)) &&
 181           !GTK_WIDGET_MAPPED (child))
 182         gtk_widget_map (child);
 183     }
 184
 185   if (GTK_WIDGET_VISIBLE (child) && GTK_WIDGET_VISIBLE (box))
 186     gtk_widget_queue_resize (child);
 187 }
 188
 189 void
 190 gtk_box_pack_end (GtkBox    *box,
 191                   GtkWidget *child,
 192                   gint       expand,
 193                   gint       fill,
 194                   gint       padding)
 195 {
 196   GtkBoxChild *child_info;
 197
 198   g_return_if_fail (box != NULL);
 199   g_return_if_fail (GTK_IS_BOX (box));
 200   g_return_if_fail (child != NULL);
 201
 202   child_info = g_new (GtkBoxChild, 1);
 203   child_info->widget = child;
 204   child_info->padding = padding;
 205   child_info->expand = expand ? TRUE : FALSE;
 206   child_info->fill = fill ? TRUE : FALSE;
 207   child_info->pack = GTK_PACK_END;
 208
 209   box->children = g_list_append (box->children, child_info);
 210
 211   gtk_widget_set_parent (child, GTK_WIDGET (box));
 212
 213   if (GTK_WIDGET_VISIBLE (GTK_WIDGET (box)))
 214     {
 215       if (GTK_WIDGET_REALIZED (GTK_WIDGET (box)) &&
 216           !GTK_WIDGET_REALIZED (child))
 217         gtk_widget_realize (child);
 218
 219       if (GTK_WIDGET_MAPPED (GTK_WIDGET (box)) &&
 220           !GTK_WIDGET_MAPPED (child))
 221         gtk_widget_map (child);
 222     }
 223
 224   if (GTK_WIDGET_VISIBLE (child) && GTK_WIDGET_VISIBLE (box))
 225     gtk_widget_queue_resize (child);
 226 }
 227
 228 void
 229 gtk_box_pack_start_defaults (GtkBox    *box,
 230                              GtkWidget *child)
 231 {
 232   g_return_if_fail (box != NULL);
 233   g_return_if_fail (GTK_IS_BOX (box));
 234   g_return_if_fail (child != NULL);
 235
 236   gtk_box_pack_start (box, child, TRUE, TRUE, 0);
 237 }
 238
 239 void
 240 gtk_box_pack_end_defaults (GtkBox    *box,
 241                            GtkWidget *child)
 242 {
 243   g_return_if_fail (box != NULL);
 244   g_return_if_fail (GTK_IS_BOX (box));
 245   g_return_if_fail (child != NULL);
 246
 247   gtk_box_pack_end (box, child, TRUE, TRUE, 0);
 248 }
 249
 250 void
 251 gtk_box_set_homogeneous (GtkBox *box,
 252                          gint    homogeneous)
 253 {
 254   g_return_if_fail (box != NULL);
 255   g_return_if_fail (GTK_IS_BOX (box));
 256
 257   if ((homogeneous ? TRUE : FALSE) != box->homogeneous)
 258     {
 259       box->homogeneous = homogeneous ? TRUE : FALSE;
 260       gtk_widget_queue_resize (GTK_WIDGET (box));
 261     }
 262 }
 263
 264 void
 265 gtk_box_set_spacing (GtkBox *box,
 266                      gint    spacing)
 267 {
 268   g_return_if_fail (box != NULL);
 269   g_return_if_fail (GTK_IS_BOX (box));
 270
 271   if (spacing != box->spacing)
 272     {
 273       box->spacing = spacing;
 274       gtk_widget_queue_resize (GTK_WIDGET (box));
 275     }
 276 }
 277
 278
 279 static void
 280 gtk_box_destroy (GtkObject *object)
 281 {
 282   GtkBox *box;
 283   GtkBoxChild *child;
 284   GList *children;
 285
 286   g_return_if_fail (object != NULL);
 287   g_return_if_fail (GTK_IS_BOX (object));
 288
 289   box = GTK_BOX (object);
 290
 291   children = box->children;
 292   while (children)
 293     {
 294       child = children->data;
 295       children = children->next;
 296
 297       child->widget->parent = NULL;
 298       gtk_object_unref (GTK_OBJECT (child->widget));
 299       gtk_widget_destroy (child->widget);
 300       g_free (child);
 301     }
 302
 303   g_list_free (box->children);
 304
 305   if (GTK_OBJECT_CLASS (parent_class)->destroy)
 306     (* GTK_OBJECT_CLASS (parent_class)->destroy) (object);
 307 }
 308
 309 static void
 310 gtk_box_map (GtkWidget *widget)
 311 {
 312   GtkBox *box;
 313   GtkBoxChild *child;
 314   GList *children;
 315
 316   g_return_if_fail (widget != NULL);
 317   g_return_if_fail (GTK_IS_BOX (widget));
 318
 319   box = GTK_BOX (widget);
 320   GTK_WIDGET_SET_FLAGS (box, GTK_MAPPED);
 321
 322   children = box->children;
 323   while (children)
 324     {
 325       child = children->data;
 326       children = children->next;
 327
 328       if (GTK_WIDGET_VISIBLE (child->widget) &&
 329           !GTK_WIDGET_MAPPED (child->widget))
 330         gtk_widget_map (child->widget);
 331     }
 332 }
 333
 334 static void
 335 gtk_box_unmap (GtkWidget *widget)
 336 {
 337   GtkBox *box;
 338   GtkBoxChild *child;
 339   GList *children;
 340
 341   g_return_if_fail (widget != NULL);
 342   g_return_if_fail (GTK_IS_BOX (widget));
 343
 344   box = GTK_BOX (widget);
 345   GTK_WIDGET_UNSET_FLAGS (box, GTK_MAPPED);
 346
 347   children = box->children;
 348   while (children)
 349     {
 350       child = children->data;
 351       children = children->next;
 352
 353       if (GTK_WIDGET_VISIBLE (child->widget) &&
 354           GTK_WIDGET_MAPPED (child->widget))
 355         gtk_widget_unmap (child->widget);
 356     }
 357 }
 358
 359 static void
 360 gtk_box_draw (GtkWidget    *widget,
 361               GdkRectangle *area)
 362 {
 363   GtkBox *box;
 364   GtkBoxChild *child;
 365   GdkRectangle child_area;
 366   GList *children;
 367
 368   g_return_if_fail (widget != NULL);
 369   g_return_if_fail (GTK_IS_BOX (widget));
 370
 371   if (GTK_WIDGET_DRAWABLE (widget))
 372     {
 373       box = GTK_BOX (widget);
 374
 375       children = box->children;
 376       while (children)
 377         {
 378           child = children->data;
 379           children = children->next;
 380
 381           if (gtk_widget_intersect (child->widget, area, &child_area))
 382             gtk_widget_draw (child->widget, &child_area);
 383         }
 384     }
 385 }
 386
 387 static gint
 388 gtk_box_expose (GtkWidget      *widget,
 389                 GdkEventExpose *event)
 390 {
 391   GtkBox *box;
 392   GtkBoxChild *child;
 393   GdkEventExpose child_event;
 394   GList *children;
 395
 396   g_return_val_if_fail (widget != NULL, FALSE);
 397   g_return_val_if_fail (GTK_IS_BOX (widget), FALSE);
 398   g_return_val_if_fail (event != NULL, FALSE);
 399
 400   if (GTK_WIDGET_DRAWABLE (widget))
 401     {
 402       box = GTK_BOX (widget);
 403
 404       child_event = *event;
 405
 406       children = box->children;
 407       while (children)
 408         {
 409           child = children->data;
 410           children = children->next;
 411
 412           if (GTK_WIDGET_NO_WINDOW (child->widget) &&
 413               gtk_widget_intersect (child->widget, &event->area, &child_event.area))
 414             gtk_widget_event (child->widget, (GdkEvent*) &child_event);
 415         }
 416     }
 417
 418   return FALSE;
 419 }
 420
 421 static void
 422 gtk_box_add (GtkContainer *container,
 423              GtkWidget    *widget)
 424 {
 425   g_return_if_fail (container != NULL);
 426   g_return_if_fail (GTK_IS_BOX (container));
 427   g_return_if_fail (widget != NULL);
 428
 429   gtk_box_pack_start_defaults (GTK_BOX (container), widget);
 430 }
 431
 432 static void
 433 gtk_box_remove (GtkContainer *container,
 434                 GtkWidget    *widget)
 435 {
 436   GtkBox *box;
 437   GtkBoxChild *child;
 438   GList *children;
 439
 440   g_return_if_fail (container != NULL);
 441   g_return_if_fail (GTK_IS_BOX (container));
 442   g_return_if_fail (widget != NULL);
 443
 444   box = GTK_BOX (container);
 445
 446   children = box->children;
 447   while (children)
 448     {
 449       child = children->data;
 450
 451       if (child->widget == widget)
 452         {
 453           gtk_widget_unparent (widget);
 454
 455           box->children = g_list_remove_link (box->children, children);
 456           g_list_free (children);
 457           g_free (child);
 458
 459           if (GTK_WIDGET_VISIBLE (widget) && GTK_WIDGET_VISIBLE (container))
 460             gtk_widget_queue_resize (GTK_WIDGET (container));
 461
 462           break;
 463         }
 464
 465       children = children->next;
 466     }
 467 }
 468
 469 static void
 470 gtk_box_foreach (GtkContainer *container,
 471                  GtkCallback   callback,
 472                  gpointer      callback_data)
 473 {
 474   GtkBox *box;
 475   GtkBoxChild *child;
 476   GList *children;
 477
 478   g_return_if_fail (container != NULL);
 479   g_return_if_fail (GTK_IS_BOX (container));
 480   g_return_if_fail (callback != NULL);
 481
 482   box = GTK_BOX (container);
 483
 484   children = box->children;
 485   while (children)
 486     {
 487       child = children->data;
 488       children = children->next;
 489
 490       if (child->pack == GTK_PACK_START)
 491         (* callback) (child->widget, callback_data);
 492     }
 493
 494   children = g_list_last (box->children);
 495   while (children)
 496     {
 497       child = children->data;
 498       children = children->prev;
 499
 500       if (child->pack == GTK_PACK_END)
 501         (* callback) (child->widget, callback_data);
 502     }
 503 }