app/gtkwrapbox.c

   1 /* GTK - The GIMP Toolkit
   2  * Copyright (C) 1995-1997 Peter Mattis, Spencer Kimball and Josh MacDonald
   3  *
   4  * GtkWrapBox: Wrapping box widget
   5  * Copyright (C) 1999 Tim Janik
   6  *
   7  * This library is free software; you can redistribute it and/or
   8  * modify it under the terms of the GNU Library General Public
   9  * License as published by the Free Software Foundation; either
  10  * version 2 of the License, or (at your option) any later version.
  11  *
  12  * This library is distributed in the hope that it will be useful,
  13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  15  * Library General Public License for more details.
  16  *
  17  * You should have received a copy of the GNU Library General Public
  18  * License along with this library; if not, write to the
  19  * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
  20  * Boston, MA 02111-1307, USA.
  21  */
  22 #include <config.h>
  23
  24 #include <math.h>
  25
  26 #include "gtkwrapbox.h"
  27
  28
  29 /* --- arguments --- */
  30 enum {
  31   ARG_0,
  32   ARG_HOMOGENEOUS,
  33   ARG_JUSTIFY,
  34   ARG_HSPACING,
  35   ARG_VSPACING,
  36   ARG_LINE_JUSTIFY,
  37   ARG_ASPECT_RATIO,
  38   ARG_CURRENT_RATIO,
  39   ARG_CHILD_LIMIT
  40 };
  41 enum {
  42   CHILD_ARG_0,
  43   CHILD_ARG_POSITION,
  44   CHILD_ARG_HEXPAND,
  45   CHILD_ARG_HFILL,
  46   CHILD_ARG_VEXPAND,
  47   CHILD_ARG_VFILL,
  48   CHILD_ARG_FORCED_BREAK
  49 };
  50
  51
  52 /* --- prototypes --- */
  53 static void gtk_wrap_box_class_init    (GtkWrapBoxClass    *klass);
  54 static void gtk_wrap_box_init          (GtkWrapBox         *wbox);
  55 static void gtk_wrap_box_get_arg       (GtkObject          *object,
  56                                         GtkArg             *arg,
  57                                         guint               arg_id);
  58 static void gtk_wrap_box_set_arg       (GtkObject          *object,
  59                                         GtkArg             *arg,
  60                                         guint               arg_id);
  61 static void gtk_wrap_box_set_child_arg (GtkContainer       *container,
  62                                         GtkWidget          *child,
  63                                         GtkArg             *arg,
  64                                         guint               arg_id);
  65 static void gtk_wrap_box_get_child_arg (GtkContainer       *container,
  66                                         GtkWidget          *child,
  67                                         GtkArg             *arg,
  68                                         guint               arg_id);
  69 static void gtk_wrap_box_map           (GtkWidget          *widget);
  70 static void gtk_wrap_box_unmap         (GtkWidget          *widget);
  71 static void gtk_wrap_box_draw          (GtkWidget          *widget,
  72                                         GdkRectangle       *area);
  73 static gint gtk_wrap_box_expose        (GtkWidget          *widget,
  74                                         GdkEventExpose     *event);
  75 static void gtk_wrap_box_add           (GtkContainer       *container,
  76                                         GtkWidget          *widget);
  77 static void gtk_wrap_box_remove        (GtkContainer       *container,
  78                                         GtkWidget          *widget);
  79 static void gtk_wrap_box_forall        (GtkContainer       *container,
  80                                         gboolean            include_internals,
  81                                         GtkCallback         callback,
  82                                         gpointer            callback_data);
  83 static GtkType gtk_wrap_box_child_type (GtkContainer       *container);
  84
  85
  86 /* --- variables --- */
  87 static gpointer parent_class = NULL;
  88
  89
  90 /* --- functions --- */
  91 GtkType
  92 gtk_wrap_box_get_type (void)
  93 {
  94   static GtkType wrap_box_type = 0;
  95
  96   if (!wrap_box_type)
  97     {
  98       static const GtkTypeInfo wrap_box_info =
  99       {
 100         "GtkWrapBox",
 101         sizeof (GtkWrapBox),
 102         sizeof (GtkWrapBoxClass),
 103         (GtkClassInitFunc) gtk_wrap_box_class_init,
 104         (GtkObjectInitFunc) gtk_wrap_box_init,
 105         /* reserved_1 */ NULL,
 106         /* reserved_2 */ NULL,
 107         (GtkClassInitFunc) NULL,
 108       };
 109
 110       wrap_box_type = gtk_type_unique (GTK_TYPE_CONTAINER, &wrap_box_info);
 111     }
 112
 113   return wrap_box_type;
 114 }
 115
 116 static void
 117 gtk_wrap_box_class_init (GtkWrapBoxClass *class)
 118 {
 119   GtkObjectClass *object_class;
 120   GtkWidgetClass *widget_class;
 121   GtkContainerClass *container_class;
 122
 123   object_class = GTK_OBJECT_CLASS (class);
 124   widget_class = GTK_WIDGET_CLASS (class);
 125   container_class = GTK_CONTAINER_CLASS (class);
 126
 127   parent_class = gtk_type_class (GTK_TYPE_CONTAINER);
 128
 129   object_class->set_arg = gtk_wrap_box_set_arg;
 130   object_class->get_arg = gtk_wrap_box_get_arg;
 131
 132   widget_class->map = gtk_wrap_box_map;
 133   widget_class->unmap = gtk_wrap_box_unmap;
 134   widget_class->draw = gtk_wrap_box_draw;
 135   widget_class->expose_event = gtk_wrap_box_expose;
 136
 137   container_class->add = gtk_wrap_box_add;
 138   container_class->remove = gtk_wrap_box_remove;
 139   container_class->forall = gtk_wrap_box_forall;
 140   container_class->child_type = gtk_wrap_box_child_type;
 141   container_class->set_child_arg = gtk_wrap_box_set_child_arg;
 142   container_class->get_child_arg = gtk_wrap_box_get_child_arg;
 143
 144   class->rlist_line_children = NULL;
 145
 146   gtk_object_add_arg_type ("GtkWrapBox::homogeneous",
 147                            GTK_TYPE_BOOL, GTK_ARG_READWRITE, ARG_HOMOGENEOUS);
 148   gtk_object_add_arg_type ("GtkWrapBox::justify",
 149                            GTK_TYPE_JUSTIFICATION, GTK_ARG_READWRITE, ARG_JUSTIFY);
 150   gtk_object_add_arg_type ("GtkWrapBox::hspacing",
 151                            GTK_TYPE_UINT, GTK_ARG_READWRITE, ARG_HSPACING);
 152   gtk_object_add_arg_type ("GtkWrapBox::vspacing",
 153                            GTK_TYPE_UINT, GTK_ARG_READWRITE, ARG_VSPACING);
 154   gtk_object_add_arg_type ("GtkWrapBox::line_justify",
 155                            GTK_TYPE_JUSTIFICATION, GTK_ARG_READWRITE, ARG_LINE_JUSTIFY);
 156   gtk_object_add_arg_type ("GtkWrapBox::aspect_ratio",
 157                            GTK_TYPE_FLOAT, GTK_ARG_READWRITE, ARG_ASPECT_RATIO);
 158   gtk_object_add_arg_type ("GtkWrapBox::current_ratio",
 159                            GTK_TYPE_FLOAT, GTK_ARG_READABLE, ARG_CURRENT_RATIO);
 160   gtk_object_add_arg_type ("GtkWrapBox::max_children_per_line",
 161                            GTK_TYPE_UINT, GTK_ARG_READWRITE, ARG_CHILD_LIMIT);
 162   gtk_container_add_child_arg_type ("GtkWrapBox::position",
 163                                     GTK_TYPE_INT, GTK_ARG_READWRITE, CHILD_ARG_POSITION);
 164   gtk_container_add_child_arg_type ("GtkWrapBox::hexpand",
 165                                     GTK_TYPE_BOOL, GTK_ARG_READWRITE, CHILD_ARG_HEXPAND);
 166   gtk_container_add_child_arg_type ("GtkWrapBox::hfill",
 167                                     GTK_TYPE_BOOL, GTK_ARG_READWRITE, CHILD_ARG_HFILL);
 168   gtk_container_add_child_arg_type ("GtkWrapBox::vexpand",
 169                                     GTK_TYPE_BOOL, GTK_ARG_READWRITE, CHILD_ARG_VEXPAND);
 170   gtk_container_add_child_arg_type ("GtkWrapBox::vfill",
 171                                     GTK_TYPE_BOOL, GTK_ARG_READWRITE, CHILD_ARG_VFILL);
 172   gtk_container_add_child_arg_type ("GtkWrapBox::forcebreak",
 173                                     GTK_TYPE_BOOL, GTK_ARG_READWRITE, CHILD_ARG_FORCED_BREAK);
 174 }
 175
 176 static void
 177 gtk_wrap_box_init (GtkWrapBox *wbox)
 178 {
 179   GTK_WIDGET_SET_FLAGS (wbox, GTK_NO_WINDOW);
 180
 181   wbox->homogeneous = FALSE;
 182   wbox->hspacing = 0;
 183   wbox->vspacing = 0;
 184   wbox->justify = GTK_JUSTIFY_LEFT;
 185   wbox->line_justify = GTK_JUSTIFY_BOTTOM;
 186   wbox->n_children = 0;
 187   wbox->children = NULL;
 188   wbox->aspect_ratio = 1;
 189   wbox->child_limit = 32767;
 190 }
 191
 192 static void
 193 gtk_wrap_box_set_arg (GtkObject *object,
 194                       GtkArg    *arg,
 195                       guint      arg_id)
 196 {
 197   GtkWrapBox *wbox = GTK_WRAP_BOX (object);
 198
 199   switch (arg_id)
 200     {
 201     case ARG_HOMOGENEOUS:
 202       gtk_wrap_box_set_homogeneous (wbox, GTK_VALUE_BOOL (*arg));
 203       break;
 204     case ARG_JUSTIFY:
 205       gtk_wrap_box_set_justify (wbox, GTK_VALUE_ENUM (*arg));
 206       break;
 207     case ARG_LINE_JUSTIFY:
 208       gtk_wrap_box_set_line_justify (wbox, GTK_VALUE_ENUM (*arg));
 209       break;
 210     case ARG_HSPACING:
 211       gtk_wrap_box_set_hspacing (wbox, GTK_VALUE_UINT (*arg));
 212       break;
 213     case ARG_VSPACING:
 214       gtk_wrap_box_set_vspacing (wbox, GTK_VALUE_UINT (*arg));
 215       break;
 216     case ARG_ASPECT_RATIO:
 217       gtk_wrap_box_set_aspect_ratio (wbox, GTK_VALUE_FLOAT (*arg));
 218       break;
 219     case ARG_CHILD_LIMIT:
 220       if (wbox->child_limit != GTK_VALUE_UINT (*arg))
 221         {
 222           wbox->child_limit = CLAMP (GTK_VALUE_UINT (*arg), 1, 32767);
 223           gtk_widget_queue_resize (GTK_WIDGET (wbox));
 224         }
 225       break;
 226     }
 227 }
 228
 229 static void
 230 gtk_wrap_box_get_arg (GtkObject *object,
 231                       GtkArg    *arg,
 232                       guint      arg_id)
 233 {
 234   GtkWrapBox *wbox = GTK_WRAP_BOX (object);
 235   GtkWidget *widget = GTK_WIDGET (object);
 236
 237   switch (arg_id)
 238     {
 239     case ARG_HOMOGENEOUS:
 240       GTK_VALUE_BOOL (*arg) = wbox->homogeneous;
 241       break;
 242     case ARG_JUSTIFY:
 243       GTK_VALUE_ENUM (*arg) = wbox->justify;
 244       break;
 245     case ARG_LINE_JUSTIFY:
 246       GTK_VALUE_ENUM (*arg) = wbox->line_justify;
 247       break;
 248     case ARG_HSPACING:
 249       GTK_VALUE_UINT (*arg) = wbox->hspacing;
 250       break;
 251     case ARG_VSPACING:
 252       GTK_VALUE_UINT (*arg) = wbox->vspacing;
 253       break;
 254     case ARG_ASPECT_RATIO:
 255       GTK_VALUE_FLOAT (*arg) = wbox->aspect_ratio;
 256       break;
 257     case ARG_CURRENT_RATIO:
 258       GTK_VALUE_FLOAT (*arg) = (((gfloat) widget->allocation.width) /
 259                                 ((gfloat) widget->allocation.height));
 260       break;
 261     case ARG_CHILD_LIMIT:
 262       GTK_VALUE_UINT (*arg) = wbox->child_limit;
 263       break;
 264     default:
 265       arg->type = GTK_TYPE_INVALID;
 266       break;
 267     }
 268 }
 269
 270 static void
 271 gtk_wrap_box_set_child_arg (GtkContainer *container,
 272                             GtkWidget    *child,
 273                             GtkArg       *arg,
 274                             guint         arg_id)
 275 {
 276   GtkWrapBox *wbox = GTK_WRAP_BOX (container);
 277   gboolean hexpand = FALSE, hfill = FALSE, vexpand = FALSE, vfill = FALSE;
 278
 279   if (arg_id != CHILD_ARG_POSITION)
 280     gtk_wrap_box_query_child_packing (wbox, child, &hexpand, &hfill, &vexpand, &vfill);
 281
 282   switch (arg_id)
 283     {
 284     case CHILD_ARG_POSITION:
 285       gtk_wrap_box_reorder_child (wbox, child, GTK_VALUE_INT (*arg));
 286       break;
 287     case CHILD_ARG_HEXPAND:
 288       gtk_wrap_box_set_child_packing (wbox, child,
 289                                       GTK_VALUE_BOOL (*arg), hfill,
 290                                       vexpand, vfill);
 291       break;
 292     case CHILD_ARG_HFILL:
 293       gtk_wrap_box_set_child_packing (wbox, child,
 294                                       hexpand, GTK_VALUE_BOOL (*arg),
 295                                       vexpand, vfill);
 296       break;
 297     case CHILD_ARG_VEXPAND:
 298       gtk_wrap_box_set_child_packing (wbox, child,
 299                                       hexpand, hfill,
 300                                       GTK_VALUE_BOOL (*arg), vfill);
 301       break;
 302     case CHILD_ARG_VFILL:
 303       gtk_wrap_box_set_child_packing (wbox, child,
 304                                       hexpand, hfill,
 305                                       vexpand, GTK_VALUE_BOOL (*arg));
 306       break;
 307     case CHILD_ARG_FORCED_BREAK:
 308       gtk_wrap_box_set_child_forced_break (wbox, child,
 309                                            GTK_VALUE_BOOL (*arg));
 310       break;
 311     default:
 312       break;
 313     }
 314 }
 315
 316 static void
 317 gtk_wrap_box_get_child_arg (GtkContainer *container,
 318                             GtkWidget    *child,
 319                             GtkArg       *arg,
 320                             guint         arg_id)
 321 {
 322   GtkWrapBox *wbox = GTK_WRAP_BOX (container);
 323   gboolean hexpand = FALSE, hfill = FALSE, vexpand = FALSE, vfill = FALSE;
 324
 325   if (arg_id != CHILD_ARG_POSITION)
 326     gtk_wrap_box_query_child_packing (wbox, child, &hexpand, &hfill, &vexpand, &vfill);
 327
 328   switch (arg_id)
 329     {
 330       GtkWrapBoxChild *child_info;
 331     case CHILD_ARG_POSITION:
 332       GTK_VALUE_INT (*arg) = 0;
 333       for (child_info = wbox->children; child_info; child_info = child_info->next)
 334         {
 335           if (child_info->widget == child)
 336             break;
 337           GTK_VALUE_INT (*arg)++;
 338         }
 339       if (!child_info)
 340         GTK_VALUE_INT (*arg) = -1;
 341       break;
 342     case CHILD_ARG_HEXPAND:
 343       GTK_VALUE_BOOL (*arg) = hexpand;
 344       break;
 345     case CHILD_ARG_HFILL:
 346       GTK_VALUE_BOOL (*arg) = hfill;
 347       break;
 348     case CHILD_ARG_VEXPAND:
 349       GTK_VALUE_BOOL (*arg) = vexpand;
 350       break;
 351     case CHILD_ARG_VFILL:
 352       GTK_VALUE_BOOL (*arg) = vfill;
 353       break;
 354     default:
 355       arg->type = GTK_TYPE_INVALID;
 356       break;
 357     }
 358 }
 359
 360 static GtkType
 361 gtk_wrap_box_child_type (GtkContainer *container)
 362 {
 363   return GTK_TYPE_WIDGET;
 364 }
 365
 366 void
 367 gtk_wrap_box_set_homogeneous (GtkWrapBox *wbox,
 368                               gboolean    homogeneous)
 369 {
 370   g_return_if_fail (GTK_IS_WRAP_BOX (wbox));
 371
 372   homogeneous = homogeneous != FALSE;
 373   if (wbox->homogeneous != homogeneous)
 374     {
 375       wbox->homogeneous = homogeneous;
 376       gtk_widget_queue_resize (GTK_WIDGET (wbox));
 377     }
 378 }
 379
 380 void
 381 gtk_wrap_box_set_hspacing (GtkWrapBox *wbox,
 382                            guint       hspacing)
 383 {
 384   g_return_if_fail (GTK_IS_WRAP_BOX (wbox));
 385
 386   if (wbox->hspacing != hspacing)
 387     {
 388       wbox->hspacing = hspacing;
 389       gtk_widget_queue_resize (GTK_WIDGET (wbox));
 390     }
 391 }
 392
 393 void
 394 gtk_wrap_box_set_vspacing (GtkWrapBox *wbox,
 395                            guint       vspacing)
 396 {
 397   g_return_if_fail (GTK_IS_WRAP_BOX (wbox));
 398
 399   if (wbox->vspacing != vspacing)
 400     {
 401       wbox->vspacing = vspacing;
 402       gtk_widget_queue_resize (GTK_WIDGET (wbox));
 403     }
 404 }
 405
 406 void
 407 gtk_wrap_box_set_justify (GtkWrapBox      *wbox,
 408                           GtkJustification justify)
 409 {
 410   g_return_if_fail (GTK_IS_WRAP_BOX (wbox));
 411   g_return_if_fail (justify <= GTK_JUSTIFY_FILL);
 412
 413   if (wbox->justify != justify)
 414     {
 415       wbox->justify = justify;
 416       gtk_widget_queue_resize (GTK_WIDGET (wbox));
 417     }
 418 }
 419
 420 void
 421 gtk_wrap_box_set_line_justify (GtkWrapBox      *wbox,
 422                                GtkJustification line_justify)
 423 {
 424   g_return_if_fail (GTK_IS_WRAP_BOX (wbox));
 425   g_return_if_fail (line_justify <= GTK_JUSTIFY_FILL);
 426
 427   if (wbox->line_justify != line_justify)
 428     {
 429       wbox->line_justify = line_justify;
 430       gtk_widget_queue_resize (GTK_WIDGET (wbox));
 431     }
 432 }
 433
 434 void
 435 gtk_wrap_box_set_aspect_ratio (GtkWrapBox *wbox,
 436                                gfloat      aspect_ratio)
 437 {
 438   g_return_if_fail (GTK_IS_WRAP_BOX (wbox));
 439
 440   aspect_ratio = CLAMP (aspect_ratio, 1.0 / 256.0, 256.0);
 441
 442   if (wbox->aspect_ratio != aspect_ratio)
 443     {
 444       wbox->aspect_ratio = aspect_ratio;
 445       gtk_widget_queue_resize (GTK_WIDGET (wbox));
 446     }
 447 }
 448
 449 void
 450 gtk_wrap_box_pack (GtkWrapBox *wbox,
 451                    GtkWidget  *child,
 452                    gboolean    hexpand,
 453                    gboolean    hfill,
 454                    gboolean    vexpand,
 455                    gboolean    vfill)
 456 {
 457   GtkWrapBoxChild *child_info;
 458
 459   g_return_if_fail (GTK_IS_WRAP_BOX (wbox));
 460   g_return_if_fail (GTK_IS_WIDGET (child));
 461   g_return_if_fail (child->parent == NULL);
 462
 463   child_info = g_new (GtkWrapBoxChild, 1);
 464   child_info->widget = child;
 465   child_info->hexpand = hexpand ? TRUE : FALSE;
 466   child_info->hfill = hfill ? TRUE : FALSE;
 467   child_info->vexpand = vexpand ? TRUE : FALSE;
 468   child_info->vfill = vfill ? TRUE : FALSE;
 469   child_info->forced_break = FALSE;
 470   child_info->next = NULL;
 471   if (wbox->children)
 472     {
 473       GtkWrapBoxChild *last = wbox->children;
 474
 475       while (last->next)
 476         last = last->next;
 477       last->next = child_info;
 478     }
 479   else
 480     wbox->children = child_info;
 481   wbox->n_children++;
 482
 483   gtk_widget_set_parent (child, GTK_WIDGET (wbox));
 484
 485   if (GTK_WIDGET_REALIZED (wbox))
 486     gtk_widget_realize (child);
 487
 488   if (GTK_WIDGET_VISIBLE (wbox) && GTK_WIDGET_VISIBLE (child))
 489     {
 490       if (GTK_WIDGET_MAPPED (wbox))
 491         gtk_widget_map (child);
 492
 493       gtk_widget_queue_resize (child);
 494     }
 495 }
 496
 497 void
 498 gtk_wrap_box_reorder_child (GtkWrapBox *wbox,
 499                             GtkWidget  *child,
 500                             gint        position)
 501 {
 502   GtkWrapBoxChild *child_info, *last = NULL;
 503
 504   g_return_if_fail (GTK_IS_WRAP_BOX (wbox));
 505   g_return_if_fail (GTK_IS_WIDGET (child));
 506
 507   for (child_info = wbox->children; child_info; last = child_info, child_info = last->next)
 508     if (child_info->widget == child)
 509       break;
 510
 511   if (child_info && wbox->children->next)
 512     {
 513       GtkWrapBoxChild *tmp;
 514
 515       if (last)
 516         last->next = child_info->next;
 517       else
 518         wbox->children = child_info->next;
 519
 520       last = NULL;
 521       tmp = wbox->children;
 522       while (position && tmp->next)
 523         {
 524           position--;
 525           last = tmp;
 526           tmp = last->next;
 527         }
 528
 529       if (position)
 530         {
 531           tmp->next = child_info;
 532           child_info->next = NULL;
 533         }
 534       else
 535         {
 536           child_info->next = tmp;
 537           if (last)
 538             last->next = child_info;
 539           else
 540             wbox->children = child_info;
 541         }
 542
 543       if (GTK_WIDGET_VISIBLE (child) && GTK_WIDGET_VISIBLE (wbox))
 544         gtk_widget_queue_resize (child);
 545     }
 546 }
 547
 548 void
 549 gtk_wrap_box_query_child_packing (GtkWrapBox *wbox,
 550                                   GtkWidget  *child,
 551                                   gboolean   *hexpand,
 552                                   gboolean   *hfill,
 553                                   gboolean   *vexpand,
 554                                   gboolean   *vfill)
 555 {
 556   GtkWrapBoxChild *child_info;
 557
 558   g_return_if_fail (GTK_IS_WRAP_BOX (wbox));
 559   g_return_if_fail (GTK_IS_WIDGET (child));
 560
 561   for (child_info = wbox->children; child_info; child_info = child_info->next)
 562     if (child_info->widget == child)
 563       break;
 564
 565   if (child_info)
 566     {
 567       if (hexpand)
 568         *hexpand = child_info->hexpand;
 569       if (hfill)
 570         *hfill = child_info->hfill;
 571       if (vexpand)
 572         *vexpand = child_info->vexpand;
 573       if (vfill)
 574         *vfill = child_info->vfill;
 575     }
 576 }
 577
 578 void
 579 gtk_wrap_box_query_child_forced_break (GtkWrapBox *wbox,
 580                                        GtkWidget  *child,
 581                                        gboolean   *forced_break)
 582 {
 583   GtkWrapBoxChild *child_info;
 584
 585   g_return_if_fail (GTK_IS_WRAP_BOX (wbox));
 586   g_return_if_fail (GTK_IS_WIDGET (child));
 587
 588   for (child_info = wbox->children; child_info; child_info = child_info->next)
 589     if (child_info->widget == child)
 590       break;
 591
 592   if (child_info)
 593     {
 594       if (forced_break)
 595         *forced_break = child_info->forced_break;
 596     }
 597 }
 598
 599 void
 600 gtk_wrap_box_set_child_packing (GtkWrapBox *wbox,
 601                                 GtkWidget  *child,
 602                                 gboolean    hexpand,
 603                                 gboolean    hfill,
 604                                 gboolean    vexpand,
 605                                 gboolean    vfill)
 606 {
 607   GtkWrapBoxChild *child_info;
 608
 609   g_return_if_fail (GTK_IS_WRAP_BOX (wbox));
 610   g_return_if_fail (GTK_IS_WIDGET (child));
 611
 612   hexpand = hexpand != FALSE;
 613   hfill = hfill != FALSE;
 614   vexpand = vexpand != FALSE;
 615   vfill = vfill != FALSE;
 616
 617   for (child_info = wbox->children; child_info; child_info = child_info->next)
 618     if (child_info->widget == child)
 619       break;
 620
 621   if (child_info &&
 622       (child_info->hexpand != hexpand || child_info->vexpand != vexpand ||
 623        child_info->hfill != hfill || child_info->vfill != vfill))
 624     {
 625       child_info->hexpand = hexpand;
 626       child_info->hfill = hfill;
 627       child_info->vexpand = vexpand;
 628       child_info->vfill = vfill;
 629
 630       if (GTK_WIDGET_VISIBLE (child) && GTK_WIDGET_VISIBLE (wbox))
 631         gtk_widget_queue_resize (child);
 632     }
 633 }
 634
 635 void
 636 gtk_wrap_box_set_child_forced_break (GtkWrapBox *wbox,
 637                                      GtkWidget  *child,
 638                                      gboolean    forced_break)
 639 {
 640   GtkWrapBoxChild *child_info;
 641
 642   g_return_if_fail (GTK_IS_WRAP_BOX (wbox));
 643   g_return_if_fail (GTK_IS_WIDGET (child));
 644
 645   forced_break = forced_break != FALSE;
 646
 647   for (child_info = wbox->children; child_info; child_info = child_info->next)
 648     if (child_info->widget == child)
 649       break;
 650
 651   if (child_info &&
 652       (child_info->forced_break != forced_break))
 653     {
 654       child_info->forced_break = forced_break;
 655
 656       if (GTK_WIDGET_VISIBLE (child) && GTK_WIDGET_VISIBLE (wbox))
 657         gtk_widget_queue_resize (child);
 658     }
 659 }
 660
 661 guint*
 662 gtk_wrap_box_query_line_lengths (GtkWrapBox *wbox,
 663                                  guint      *_n_lines)
 664 {
 665   GtkWrapBoxChild *next_child = NULL;
 666   GtkAllocation area, *allocation;
 667   gboolean expand_line;
 668   GSList *slist;
 669   guint max_child_size, border, n_lines = 0, *lines = NULL;
 670
 671   if (_n_lines)
 672     *_n_lines = 0;
 673   g_return_val_if_fail (GTK_IS_WRAP_BOX (wbox), NULL);
 674
 675   allocation = &GTK_WIDGET (wbox)->allocation;
 676   border = GTK_CONTAINER (wbox)->border_width;
 677   area.x = allocation->x + border;
 678   area.y = allocation->y + border;
 679   area.width = MAX (1, (gint) allocation->width - border * 2);
 680   area.height = MAX (1, (gint) allocation->height - border * 2);
 681
 682   next_child = wbox->children;
 683   slist = GTK_WRAP_BOX_GET_CLASS (wbox)->rlist_line_children (wbox,
 684                                                               &next_child,
 685                                                               &area,
 686                                                               &max_child_size,
 687                                                               &expand_line);
 688   while (slist)
 689     {
 690       guint l = n_lines++;
 691
 692       lines = g_renew (guint, lines, n_lines);
 693       lines[l] = g_slist_length (slist);
 694       g_slist_free (slist);
 695
 696       slist = GTK_WRAP_BOX_GET_CLASS (wbox)->rlist_line_children (wbox,
 697                                                                   &next_child,
 698                                                                   &area,
 699                                                                   &max_child_size,
 700                                                                   &expand_line);
 701     }
 702
 703   if (_n_lines)
 704     *_n_lines = n_lines;
 705
 706   return lines;
 707 }
 708
 709 static void
 710 gtk_wrap_box_map (GtkWidget *widget)
 711 {
 712   GtkWrapBox *wbox = GTK_WRAP_BOX (widget);
 713   GtkWrapBoxChild *child;
 714
 715   GTK_WIDGET_SET_FLAGS (wbox, GTK_MAPPED);
 716
 717   for (child = wbox->children; child; child = child->next)
 718     if (GTK_WIDGET_VISIBLE (child->widget) &&
 719         !GTK_WIDGET_MAPPED (child->widget))
 720       gtk_widget_map (child->widget);
 721 }
 722
 723 static void
 724 gtk_wrap_box_unmap (GtkWidget *widget)
 725 {
 726   GtkWrapBox *wbox = GTK_WRAP_BOX (widget);
 727   GtkWrapBoxChild *child;
 728
 729   GTK_WIDGET_UNSET_FLAGS (wbox, GTK_MAPPED);
 730
 731   for (child = wbox->children; child; child = child->next)
 732     if (GTK_WIDGET_VISIBLE (child->widget) &&
 733         GTK_WIDGET_MAPPED (child->widget))
 734       gtk_widget_unmap (child->widget);
 735 }
 736
 737 static void
 738 gtk_wrap_box_draw (GtkWidget    *widget,
 739                    GdkRectangle *area)
 740 {
 741   GtkWrapBox *wbox = GTK_WRAP_BOX (widget);
 742   GtkWrapBoxChild *child;
 743   GdkRectangle child_area;
 744
 745   if (GTK_WIDGET_DRAWABLE (widget))
 746     for (child = wbox->children; child; child = child->next)
 747       if (GTK_WIDGET_DRAWABLE (child->widget) &&
 748           gtk_widget_intersect (child->widget, area, &child_area))
 749         gtk_widget_draw (child->widget, &child_area);
 750 }
 751
 752 static gint
 753 gtk_wrap_box_expose (GtkWidget      *widget,
 754                      GdkEventExpose *event)
 755 {
 756   GtkWrapBox *wbox = GTK_WRAP_BOX (widget);
 757   GtkWrapBoxChild *child;
 758   GdkEventExpose child_event = *event;
 759
 760   g_return_val_if_fail (event != NULL, FALSE);
 761
 762   if (GTK_WIDGET_DRAWABLE (widget))
 763     for (child = wbox->children; child; child = child->next)
 764       if (GTK_WIDGET_DRAWABLE (child->widget) &&
 765           GTK_WIDGET_NO_WINDOW (child->widget) &&
 766           gtk_widget_intersect (child->widget, &event->area, &child_event.area))
 767         gtk_widget_event (child->widget, (GdkEvent*) &child_event);
 768
 769   return TRUE;
 770 }
 771
 772 static void
 773 gtk_wrap_box_add (GtkContainer *container,
 774                   GtkWidget    *widget)
 775 {
 776   gtk_wrap_box_pack (GTK_WRAP_BOX (container), widget, FALSE, TRUE, FALSE, TRUE);
 777 }
 778
 779 static void
 780 gtk_wrap_box_remove (GtkContainer *container,
 781                      GtkWidget    *widget)
 782 {
 783   GtkWrapBox *wbox = GTK_WRAP_BOX (container);
 784   GtkWrapBoxChild *child, *last = NULL;
 785
 786   child = wbox->children;
 787   while (child)
 788     {
 789       if (child->widget == widget)
 790         {
 791           gboolean was_visible;
 792
 793           was_visible = GTK_WIDGET_VISIBLE (widget);
 794           gtk_widget_unparent (widget);
 795
 796           if (last)
 797             last->next = child->next;
 798           else
 799             wbox->children = child->next;
 800           g_free (child);
 801           wbox->n_children--;
 802
 803           if (was_visible)
 804             gtk_widget_queue_resize (GTK_WIDGET (container));
 805
 806           break;
 807         }
 808
 809       last = child;
 810       child = last->next;
 811     }
 812 }
 813
 814 static void
 815 gtk_wrap_box_forall (GtkContainer *container,
 816                      gboolean      include_internals,
 817                      GtkCallback   callback,
 818                      gpointer      callback_data)
 819 {
 820   GtkWrapBox *wbox = GTK_WRAP_BOX (container);
 821   GtkWrapBoxChild *child;
 822
 823   child = wbox->children;
 824   while (child)
 825     {
 826       GtkWidget *widget = child->widget;
 827
 828       child = child->next;
 829
 830       callback (widget, callback_data);
 831     }
 832 }