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