src/gtk1/win_gtk.c

   1 /* ///////////////////////////////////////////////////////////////////////////
   2 // Name:        win_gtk.c
   3 // Purpose:     native GTK+ widget for wxWindows
   4 // Author:      Robert Roebling
   5 // Id:          $Id$
   6 // Copyright:   (c) 1998 Robert Roebling
   7 // Licence:     wxWindows licence
   8 /////////////////////////////////////////////////////////////////////////// */
   9
  10 #include "wx/gtk/win_gtk.h"
  11 #include "gtk/gtksignal.h"
  12 #include "gtk/gtknotebook.h"
  13
  14 #ifdef __cplusplus
  15 extern "C" {
  16 #endif /* __cplusplus */
  17
  18 static void gtk_myfixed_class_init    (GtkMyFixedClass    *klass);
  19 static void gtk_myfixed_init          (GtkMyFixed         *myfixed);
  20 static void gtk_myfixed_map           (GtkWidget        *widget);
  21 #if (GTK_MINOR_VERSION == 0)
  22 static void gtk_myfixed_unmap         (GtkWidget        *widget);
  23 #endif
  24 static void gtk_myfixed_realize       (GtkWidget        *widget);
  25 static void gtk_myfixed_size_request  (GtkWidget        *widget,
  26                                      GtkRequisition   *requisition);
  27 static void gtk_myfixed_size_allocate (GtkWidget        *widget,
  28                                      GtkAllocation    *allocation);
  29 static void gtk_myfixed_paint         (GtkWidget        *widget,
  30                                      GdkRectangle     *area);
  31 static void gtk_myfixed_draw          (GtkWidget        *widget,
  32                                      GdkRectangle     *area);
  33 static gint gtk_myfixed_expose        (GtkWidget        *widget,
  34                                      GdkEventExpose   *event);
  35 static void gtk_myfixed_add           (GtkContainer     *container,
  36                                      GtkWidget        *widget);
  37 static void gtk_myfixed_remove        (GtkContainer     *container,
  38                                      GtkWidget        *widget);
  39 static void gtk_myfixed_foreach       (GtkContainer     *container,
  40 #if (GTK_MINOR_VERSION > 0)
  41                                      gboolean         include_internals,
  42 #endif
  43                                      GtkCallback      callback,
  44                                      gpointer         callback_data);
  45 #if (GTK_MINOR_VERSION > 0)
  46 static GtkType gtk_myfixed_child_type (GtkContainer     *container);
  47 #endif
  48
  49 #if (GTK_MINOR_VERSION > 0)
  50 static void  gtk_myfixed_scroll_set_adjustments    (GtkMyFixed   *myfixed,
  51                                                GtkAdjustment *hadj,
  52                                                GtkAdjustment *vadj);
  53 #endif
  54
  55
  56
  57 static GtkContainerClass *parent_class = NULL;
  58
  59 guint
  60 gtk_myfixed_get_type ()
  61 {
  62     static guint myfixed_type = 0;
  63
  64     if (!myfixed_type)
  65     {
  66         GtkTypeInfo myfixed_info =
  67         {
  68            "GtkMyFixed",
  69            sizeof (GtkMyFixed),
  70            sizeof (GtkMyFixedClass),
  71            (GtkClassInitFunc) gtk_myfixed_class_init,
  72            (GtkObjectInitFunc) gtk_myfixed_init,
  73 #if (GTK_MINOR_VERSION > 0)
  74            /* reserved_1 */ NULL,
  75            /* reserved_2 */ NULL,
  76            (GtkClassInitFunc) NULL,
  77 #else
  78            (GtkArgSetFunc) NULL,
  79            (GtkArgGetFunc) NULL,
  80 #endif
  81         };
  82         myfixed_type = gtk_type_unique (gtk_container_get_type (), &myfixed_info);
  83     }
  84
  85     return myfixed_type;
  86 }
  87
  88 static void
  89 gtk_myfixed_class_init (GtkMyFixedClass *klass)
  90 {
  91     GtkObjectClass *object_class;
  92     GtkWidgetClass *widget_class;
  93     GtkContainerClass *container_class;
  94
  95     object_class = (GtkObjectClass*) klass;
  96     widget_class = (GtkWidgetClass*) klass;
  97     container_class = (GtkContainerClass*) klass;
  98
  99 #if (GTK_MINOR_VERSION > 0)
 100     parent_class = gtk_type_class (GTK_TYPE_CONTAINER);
 101 #else
 102     parent_class = gtk_type_class (gtk_container_get_type ());
 103 #endif
 104
 105     widget_class->map = gtk_myfixed_map;
 106 #if (GTK_MINOR_VERSION == 0)
 107     widget_class->unmap = gtk_myfixed_unmap;
 108 #endif
 109     widget_class->realize = gtk_myfixed_realize;
 110     widget_class->size_request = gtk_myfixed_size_request;
 111     widget_class->size_allocate = gtk_myfixed_size_allocate;
 112     widget_class->draw = gtk_myfixed_draw;
 113     widget_class->expose_event = gtk_myfixed_expose;
 114
 115     container_class->add = gtk_myfixed_add;
 116     container_class->remove = gtk_myfixed_remove;
 117 #if (GTK_MINOR_VERSION > 0)
 118     container_class->forall = gtk_myfixed_foreach;
 119 #else
 120     container_class->foreach = gtk_myfixed_foreach;
 121 #endif
 122
 123 #if (GTK_MINOR_VERSION > 0)
 124     container_class->child_type = gtk_myfixed_child_type;
 125 #endif
 126
 127 #if (GTK_MINOR_VERSION > 0)
 128     klass->set_scroll_adjustments = gtk_myfixed_scroll_set_adjustments;
 129
 130     widget_class->set_scroll_adjustments_signal =
 131     gtk_signal_new ("set_scroll_adjustments",
 132                     GTK_RUN_LAST,
 133                     object_class->type,
 134                     GTK_SIGNAL_OFFSET (GtkMyFixedClass, set_scroll_adjustments),
 135                     gtk_marshal_NONE__POINTER_POINTER,
 136                     GTK_TYPE_NONE, 2, GTK_TYPE_ADJUSTMENT, GTK_TYPE_ADJUSTMENT);
 137 #endif
 138 }
 139
 140 #if (GTK_MINOR_VERSION > 0)
 141 static GtkType
 142 gtk_myfixed_child_type (GtkContainer     *container)
 143 {
 144     return GTK_TYPE_WIDGET;
 145 }
 146 #endif
 147
 148 static void
 149 gtk_myfixed_init (GtkMyFixed *myfixed)
 150 {
 151     GTK_WIDGET_UNSET_FLAGS (myfixed, GTK_NO_WINDOW);
 152
 153 #if (GTK_MINOR_VERSION == 0)
 154     GTK_WIDGET_SET_FLAGS (myfixed, GTK_BASIC);
 155 #endif
 156
 157 #if (GTK_MINOR_VERSION > 0)
 158     myfixed->shadow_type = GTK_SHADOW_NONE;
 159 #endif
 160
 161     myfixed->children = NULL;
 162 }
 163
 164 GtkWidget*
 165 gtk_myfixed_new ()
 166 {
 167     GtkMyFixed *myfixed;
 168
 169     myfixed = gtk_type_new (gtk_myfixed_get_type ());
 170
 171     return GTK_WIDGET (myfixed);
 172 }
 173
 174 #if (GTK_MINOR_VERSION > 0)
 175 void
 176 gtk_myfixed_scroll_set_adjustments (GtkMyFixed     *myfixed,
 177                                     GtkAdjustment  *hadj,
 178                                     GtkAdjustment  *vadj)
 179 {
 180    /* OK, this is embarassing, but this function has to be here */
 181 }
 182
 183 void
 184 gtk_myfixed_set_shadow_type (GtkMyFixed    *myfixed,
 185                              GtkShadowType  type)
 186 {
 187     g_return_if_fail (myfixed != NULL);
 188     g_return_if_fail (GTK_IS_MYFIXED (myfixed));
 189
 190     if ((GtkShadowType) myfixed->shadow_type != type)
 191     {
 192         myfixed->shadow_type = type;
 193
 194         if (GTK_WIDGET_VISIBLE (myfixed))
 195         {
 196             gtk_widget_size_allocate (GTK_WIDGET (myfixed), &(GTK_WIDGET (myfixed)->allocation));
 197             gtk_widget_queue_draw (GTK_WIDGET (myfixed));
 198         }
 199     }
 200 }
 201 #endif
 202
 203 void
 204 gtk_myfixed_put (GtkMyFixed    *myfixed,
 205                  GtkWidget     *widget,
 206                  gint16         x,
 207                  gint16         y,
 208                  gint16         width,
 209                  gint16         height)
 210 {
 211     GtkMyFixedChild *child_info;
 212
 213     g_return_if_fail (myfixed != NULL);
 214     g_return_if_fail (GTK_IS_MYFIXED (myfixed));
 215     g_return_if_fail (widget != NULL);
 216
 217     child_info = g_new (GtkMyFixedChild, 1);
 218     child_info->widget = widget;
 219     child_info->x = x;
 220     child_info->y = y;
 221     child_info->width = width;
 222     child_info->height = height;
 223
 224     gtk_widget_set_parent (widget, GTK_WIDGET (myfixed));
 225
 226     myfixed->children = g_list_append (myfixed->children, child_info);
 227
 228     if (GTK_WIDGET_REALIZED (myfixed))
 229         gtk_widget_realize (widget);
 230
 231     if (GTK_WIDGET_VISIBLE (myfixed) && GTK_WIDGET_VISIBLE (widget))
 232     {
 233         if (GTK_WIDGET_MAPPED (myfixed))
 234             gtk_widget_map (widget);
 235
 236         gtk_widget_queue_resize (GTK_WIDGET (myfixed));
 237     }
 238 }
 239
 240 void
 241 gtk_myfixed_move (GtkMyFixed    *myfixed,
 242                   GtkWidget     *widget,
 243                   gint16         x,
 244                   gint16         y)
 245 {
 246     GtkMyFixedChild *child;
 247     GList *children;
 248
 249     g_return_if_fail (myfixed != NULL);
 250     g_return_if_fail (GTK_IS_MYFIXED (myfixed));
 251     g_return_if_fail (widget != NULL);
 252
 253     children = myfixed->children;
 254     while (children)
 255     {
 256         child = children->data;
 257         children = children->next;
 258
 259         if (child->widget == widget)
 260         {
 261             gtk_myfixed_set_size( myfixed, widget, x, y, child->width, child->height );
 262             break;
 263         }
 264     }
 265 }
 266
 267 void
 268 gtk_myfixed_resize (GtkMyFixed     *myfixed,
 269                     GtkWidget      *widget,
 270                     gint16         width,
 271                     gint16         height)
 272 {
 273     GtkMyFixedChild *child;
 274     GList *children;
 275
 276     g_return_if_fail (myfixed != NULL);
 277     g_return_if_fail (GTK_IS_MYFIXED (myfixed));
 278     g_return_if_fail (widget != NULL);
 279
 280     children = myfixed->children;
 281     while (children)
 282     {
 283         child = children->data;
 284         children = children->next;
 285
 286         if (child->widget == widget)
 287         {
 288              gtk_myfixed_set_size( myfixed, widget, child->x, child->y, width, height );
 289              break;
 290         }
 291     }
 292 }
 293
 294 void
 295 gtk_myfixed_set_size (GtkMyFixed    *myfixed,
 296                       GtkWidget     *widget,
 297                       gint16         x,
 298                       gint16         y,
 299                       gint16         width,
 300                       gint16         height)
 301 {
 302     GtkMyFixedChild *child;
 303     GList *children;
 304     GtkAllocation child_allocation;
 305
 306     g_return_if_fail (myfixed != NULL);
 307     g_return_if_fail (GTK_IS_MYFIXED (myfixed));
 308     g_return_if_fail (widget != NULL);
 309
 310     children = myfixed->children;
 311     while (children)
 312     {
 313         child = children->data;
 314         children = children->next;
 315
 316         if (child->widget == widget)
 317         {
 318             if ((child->x == x) &&
 319                 (child->y == y) &&
 320                 (child->width == width) &&
 321                 (child->height == height)) return;
 322
 323             child->x = x;
 324             child->y = y;
 325             child->width = width;
 326             child->height = height;
 327
 328             if (GTK_WIDGET_VISIBLE (widget) && GTK_WIDGET_VISIBLE (myfixed))
 329             {
 330                 if ((child->width > 1) && (child->height > 1) && (GTK_WIDGET_REALIZED(widget)))
 331                 {
 332                     child_allocation.x = child->x;
 333                     child_allocation.y = child->y;
 334                     child_allocation.width = MAX( child->width, 1 );
 335                     child_allocation.height = MAX( child->height, 1 );
 336
 337                     /* work around for GTK bug when moving widgets outside
 338                        the X window -> do NOT move them entirely outside */
 339                     if (child_allocation.y + child_allocation.height < 0)
 340                         child_allocation.y = -child_allocation.height;
 341                     if (child_allocation.x + child_allocation.width < 0)
 342                         child_allocation.x = -child_allocation.width;
 343
 344                     gtk_widget_size_allocate (widget, &child_allocation);
 345                 }
 346                 else
 347                 {
 348                     gtk_widget_queue_resize (GTK_WIDGET (myfixed));
 349                 }
 350             }
 351             break;
 352         }
 353     }
 354 }
 355
 356 static void
 357 gtk_myfixed_map (GtkWidget *widget)
 358 {
 359     GtkMyFixed *myfixed;
 360     GtkMyFixedChild *child;
 361     GList *children;
 362
 363     g_return_if_fail (widget != NULL);
 364     g_return_if_fail (GTK_IS_MYFIXED (widget));
 365
 366     GTK_WIDGET_SET_FLAGS (widget, GTK_MAPPED);
 367     myfixed = GTK_MYFIXED (widget);
 368
 369     children = myfixed->children;
 370     while (children)
 371     {
 372         child = children->data;
 373         children = children->next;
 374
 375         if (GTK_WIDGET_VISIBLE (child->widget) && !GTK_WIDGET_MAPPED (child->widget))
 376             gtk_widget_map (child->widget);
 377     }
 378
 379     gdk_window_show (widget->window);
 380 }
 381
 382 #if (GTK_MINOR_VERSION == 0)
 383 static void
 384 gtk_myfixed_unmap (GtkWidget *widget)
 385 {
 386     g_return_if_fail (widget != NULL);
 387     g_return_if_fail (GTK_IS_MYFIXED (widget));
 388
 389     GTK_WIDGET_UNSET_FLAGS (widget, GTK_MAPPED);
 390 }
 391 #endif
 392
 393 static void
 394 gtk_myfixed_realize (GtkWidget *widget)
 395 {
 396     GtkMyFixed *myfixed;
 397     GdkWindowAttr attributes;
 398     gint attributes_mask;
 399
 400     g_return_if_fail (widget != NULL);
 401     g_return_if_fail (GTK_IS_MYFIXED (widget));
 402
 403     myfixed = GTK_MYFIXED (widget);
 404
 405     GTK_WIDGET_SET_FLAGS (widget, GTK_REALIZED);
 406
 407     attributes.window_type = GDK_WINDOW_CHILD;
 408
 409 #if (GTK_MINOR_VERSION > 0)
 410     attributes.x = widget->allocation.x;
 411     attributes.y = widget->allocation.y;
 412     attributes.width = widget->allocation.width;
 413     attributes.height = widget->allocation.height;
 414
 415     if (myfixed->shadow_type != GTK_SHADOW_NONE)
 416     {
 417         attributes.x += 2;
 418         attributes.y += 2;
 419         attributes.width -= 4;
 420         attributes.height -= 4;
 421     }
 422
 423     if (attributes.width < 2) attributes.width = 2;
 424     if (attributes.height < 2) attributes.height = 2;
 425 #else
 426     attributes.x = widget->allocation.x;
 427     attributes.y = widget->allocation.y;
 428     attributes.width = 32000;
 429     attributes.height = 32000;
 430 #endif
 431     attributes.wclass = GDK_INPUT_OUTPUT;
 432     attributes.visual = gtk_widget_get_visual (widget);
 433     attributes.colormap = gtk_widget_get_colormap (widget);
 434     attributes.event_mask = gtk_widget_get_events (widget);
 435     attributes.event_mask |=
 436        GDK_EXPOSURE_MASK        |
 437        GDK_POINTER_MOTION_MASK  |
 438        GDK_POINTER_MOTION_HINT_MASK  |
 439        GDK_BUTTON_MOTION_MASK   |
 440        GDK_BUTTON1_MOTION_MASK  |
 441        GDK_BUTTON2_MOTION_MASK  |
 442        GDK_BUTTON3_MOTION_MASK  |
 443        GDK_BUTTON_PRESS_MASK    |
 444        GDK_BUTTON_RELEASE_MASK  |
 445        GDK_KEY_PRESS_MASK       |
 446        GDK_KEY_RELEASE_MASK     |
 447        GDK_ENTER_NOTIFY_MASK    |
 448        GDK_LEAVE_NOTIFY_MASK    |
 449        GDK_FOCUS_CHANGE_MASK;
 450     attributes_mask = GDK_WA_X | GDK_WA_Y | GDK_WA_VISUAL | GDK_WA_COLORMAP;
 451
 452     widget->window = gdk_window_new( gtk_widget_get_parent_window (widget), &attributes,
 453                                      attributes_mask);
 454     gdk_window_set_user_data (widget->window, widget);
 455
 456     widget->style = gtk_style_attach (widget->style, widget->window);
 457     gtk_style_set_background (widget->style, widget->window, GTK_STATE_NORMAL);
 458 }
 459
 460 static void
 461 gtk_myfixed_size_request (GtkWidget      *widget,
 462                           GtkRequisition *requisition)
 463 {
 464     GtkMyFixed *myfixed;
 465     GtkMyFixedChild *child;
 466     GList *children;
 467     GtkRequisition child_requisition;
 468
 469     g_return_if_fail (widget != NULL);
 470     g_return_if_fail (GTK_IS_MYFIXED (widget));
 471     g_return_if_fail (requisition != NULL);
 472
 473     myfixed = GTK_MYFIXED (widget);
 474
 475     children = myfixed->children;
 476     while (children)
 477     {
 478         child = children->data;
 479         children = children->next;
 480
 481         if (GTK_WIDGET_VISIBLE (child->widget))
 482         {
 483             gtk_widget_size_request (child->widget, &child_requisition);
 484         }
 485     }
 486
 487     /* request very little, I'm not sure if requesting nothing
 488        will always have positive effects on stability... */
 489     requisition->width = 2;
 490     requisition->height = 2;
 491 }
 492
 493 static void
 494 gtk_myfixed_size_allocate (GtkWidget     *widget,
 495                            GtkAllocation *allocation)
 496 {
 497     GtkMyFixed *myfixed;
 498     gint border;
 499     GtkMyFixedChild *child;
 500     GtkAllocation child_allocation;
 501     GList *children;
 502
 503     g_return_if_fail (widget != NULL);
 504     g_return_if_fail (GTK_IS_MYFIXED(widget));
 505     g_return_if_fail (allocation != NULL);
 506
 507     myfixed = GTK_MYFIXED (widget);
 508
 509     widget->allocation = *allocation;
 510 #if (GTK_MINOR_VERSION > 0)
 511     if (myfixed->shadow_type == GTK_SHADOW_NONE)
 512         border = 0;
 513     else
 514         border = 2;
 515 #else
 516     border = 0;
 517 #endif
 518
 519     if (GTK_WIDGET_REALIZED (widget))
 520     {
 521         gdk_window_move_resize( widget->window,
 522                                 allocation->x+border, allocation->y+border,
 523 #if (GTK_MINOR_VERSION > 0)
 524                                 allocation->width-border*2, allocation->height-border*2
 525 #else
 526                                 32000, 32000
 527 #endif
 528                               );
 529     }
 530
 531     children = myfixed->children;
 532     while (children)
 533     {
 534         child = children->data;
 535         children = children->next;
 536
 537         /* please look at the text in wxWindow::DoSetSize() on why the
 538            test GTK_WIDGET_REALIZED() has to be here */
 539         if (GTK_WIDGET_VISIBLE (child->widget))
 540         {
 541 /*          if (GTK_IS_NOTEBOOK(child->widget) && !GTK_WIDGET_REALIZED(child->widget))
 542             {
 543                 gtk_widget_queue_resize( child->widget );
 544             }
 545             else */
 546             {
 547                 child_allocation.x = child->x;
 548                 child_allocation.y = child->y;
 549                 child_allocation.width = MAX( child->width, 1 );
 550                 child_allocation.height = MAX( child->height, 1 );
 551
 552                 /* work around for GTK bug when moving widgets outside
 553                    the X window -> do NOT move them entirely outside */
 554                 if (child_allocation.y + child_allocation.height < 0)
 555                     child_allocation.y = -child_allocation.height;
 556                 if (child_allocation.x + child_allocation.width < 0)
 557                     child_allocation.x = -child_allocation.width;
 558
 559                 gtk_widget_size_allocate (child->widget, &child_allocation);
 560             }
 561         }
 562     }
 563 }
 564
 565 static void
 566 gtk_myfixed_paint (GtkWidget    *widget,
 567                    GdkRectangle *area)
 568 {
 569     g_return_if_fail (widget != NULL);
 570     g_return_if_fail (GTK_IS_MYFIXED (widget));
 571     g_return_if_fail (area != NULL);
 572
 573     if (GTK_WIDGET_DRAWABLE (widget))
 574         gdk_window_clear_area (widget->window,
 575                                area->x, area->y,
 576                                area->width, area->height);
 577 }
 578
 579 static void
 580 gtk_myfixed_draw (GtkWidget    *widget,
 581                   GdkRectangle *area)
 582 {
 583   GtkMyFixed *myfixed;
 584   GtkMyFixedChild *child;
 585   GdkRectangle child_area;
 586   GList *children;
 587
 588   g_return_if_fail (widget != NULL);
 589   g_return_if_fail (GTK_IS_MYFIXED (widget));
 590
 591   if (GTK_WIDGET_DRAWABLE (widget))
 592     {
 593       myfixed = GTK_MYFIXED (widget);
 594       gtk_myfixed_paint (widget, area);
 595
 596       children = myfixed->children;
 597       while (children)
 598         {
 599           child = children->data;
 600           children = children->next;
 601
 602           if (gtk_widget_intersect (child->widget, area, &child_area))
 603             gtk_widget_draw (child->widget, &child_area);
 604         }
 605     }
 606 }
 607
 608 static gint
 609 gtk_myfixed_expose (GtkWidget      *widget,
 610                     GdkEventExpose *event)
 611 {
 612   GtkMyFixed *myfixed;
 613   GtkMyFixedChild *child;
 614   GdkEventExpose child_event;
 615   GList *children;
 616
 617   g_return_val_if_fail (widget != NULL, FALSE);
 618   g_return_val_if_fail (GTK_IS_MYFIXED (widget), FALSE);
 619   g_return_val_if_fail (event != NULL, FALSE);
 620
 621   if (GTK_WIDGET_DRAWABLE (widget))
 622     {
 623       myfixed = GTK_MYFIXED (widget);
 624
 625       child_event = *event;
 626
 627       children = myfixed->children;
 628       while (children)
 629         {
 630           child = children->data;
 631           children = children->next;
 632
 633           if (GTK_WIDGET_NO_WINDOW (child->widget) &&
 634               gtk_widget_intersect (child->widget, &event->area,
 635                                     &child_event.area))
 636             gtk_widget_event (child->widget, (GdkEvent*) &child_event);
 637         }
 638     }
 639
 640   return FALSE;
 641 }
 642
 643 static void
 644 gtk_myfixed_add (GtkContainer *container,
 645                GtkWidget    *widget)
 646 {
 647   g_return_if_fail (container != NULL);
 648   g_return_if_fail (GTK_IS_MYFIXED (container));
 649   g_return_if_fail (widget != NULL);
 650
 651   gtk_myfixed_put (GTK_MYFIXED (container), widget, 0, 0, 20, 20 );
 652 }
 653
 654 static void
 655 gtk_myfixed_remove (GtkContainer *container,
 656                   GtkWidget    *widget)
 657 {
 658   GtkMyFixed *myfixed;
 659   GtkMyFixedChild *child;
 660   GList *children;
 661
 662   g_return_if_fail (container != NULL);
 663   g_return_if_fail (GTK_IS_MYFIXED (container));
 664   g_return_if_fail (widget != NULL);
 665
 666   myfixed = GTK_MYFIXED (container);
 667
 668   children = myfixed->children;
 669   while (children)
 670     {
 671       child = children->data;
 672
 673       if (child->widget == widget)
 674         {
 675           gboolean was_visible = GTK_WIDGET_VISIBLE (widget);
 676
 677           gtk_widget_unparent (widget);
 678
 679           myfixed->children = g_list_remove_link (myfixed->children, children);
 680           g_list_free (children);
 681           g_free (child);
 682
 683           if (was_visible && GTK_WIDGET_VISIBLE (container))
 684             gtk_widget_queue_resize (GTK_WIDGET (container));
 685
 686           break;
 687         }
 688
 689       children = children->next;
 690     }
 691 }
 692
 693 static void
 694 gtk_myfixed_foreach (GtkContainer *container,
 695 #if (GTK_MINOR_VERSION > 0)
 696                    gboolean      include_internals,
 697 #endif
 698                    GtkCallback   callback,
 699                    gpointer      callback_data)
 700 {
 701   GtkMyFixed *myfixed;
 702   GtkMyFixedChild *child;
 703   GList *children;
 704
 705   g_return_if_fail (container != NULL);
 706   g_return_if_fail (GTK_IS_MYFIXED (container));
 707   g_return_if_fail (callback != NULL);
 708
 709   myfixed = GTK_MYFIXED (container);
 710
 711   children = myfixed->children;
 712   while (children)
 713     {
 714       child = children->data;
 715       children = children->next;
 716
 717       (* callback) (child->widget, callback_data);
 718     }
 719 }
 720
 721
 722 #ifdef __cplusplus
 723 }
 724 #endif /* __cplusplus */
 725