src/gui_gtk_f.c

   1 /* vi:set ts=8 sts=4 sw=4:
   2  *
   3  * VIM - Vi IMproved            by Bram Moolenaar
   4  *
   5  * Do ":help uganda"  in Vim to read copying and usage conditions.
   6  * Do ":help credits" in Vim to see a list of people who contributed.
   7  * See README.txt for an overview of the Vim source code.
   8  */
   9
  10 /*
  11  * (C) 1998,1999 by Marcin Dalecki <martin@dalecki.de>
  12  *
  13  * Support for GTK+ 2 was added by:
  14  *
  15  * (C) 2002,2003  Jason Hildebrand  <jason@peaceworks.ca>
  16  *                Daniel Elstner  <daniel.elstner@gmx.net>
  17  *
  18  * This is a special purpose container widget, which manages arbitrary
  19  * children at arbitrary positions width arbitrary sizes.  This finally puts
  20  * an end on our resize problems with which we where struggling for such a
  21  * long time.
  22  */
  23
  24 #include "vim.h"
  25 #include <gtk/gtk.h>    /* without this it compiles, but gives errors at
  26                            runtime! */
  27 #include "gui_gtk_f.h"
  28 #include <gtk/gtksignal.h>
  29 #ifdef WIN3264
  30 # include <gdk/gdkwin32.h>
  31 #else
  32 # include <gdk/gdkx.h>
  33 #endif
  34
  35 typedef struct _GtkFormChild GtkFormChild;
  36
  37 struct _GtkFormChild
  38 {
  39     GtkWidget *widget;
  40     GdkWindow *window;
  41     gint x;             /* relative subwidget x position */
  42     gint y;             /* relative subwidget y position */
  43     gint mapped;
  44 };
  45
  46
  47 static void gtk_form_class_init(GtkFormClass *klass);
  48 static void gtk_form_init(GtkForm *form);
  49
  50 static void gtk_form_realize(GtkWidget *widget);
  51 static void gtk_form_unrealize(GtkWidget *widget);
  52 static void gtk_form_map(GtkWidget *widget);
  53 static void gtk_form_size_request(GtkWidget *widget,
  54                                   GtkRequisition *requisition);
  55 static void gtk_form_size_allocate(GtkWidget *widget,
  56                                    GtkAllocation *allocation);
  57 #ifndef HAVE_GTK2  /* this isn't needed in gtk2 */
  58 static void gtk_form_draw(GtkWidget *widget,
  59                           GdkRectangle *area);
  60 #endif
  61 static gint gtk_form_expose(GtkWidget *widget,
  62                             GdkEventExpose *event);
  63
  64 static void gtk_form_remove(GtkContainer *container,
  65                             GtkWidget *widget);
  66 static void gtk_form_forall(GtkContainer *container,
  67                             gboolean include_internals,
  68                             GtkCallback callback,
  69                             gpointer callback_data);
  70
  71 static void gtk_form_attach_child_window(GtkForm *form,
  72                                          GtkFormChild *child);
  73 static void gtk_form_realize_child(GtkForm *form,
  74                                    GtkFormChild *child);
  75 static void gtk_form_position_child(GtkForm *form,
  76                                     GtkFormChild *child,
  77                                     gboolean force_allocate);
  78 static void gtk_form_position_children(GtkForm *form);
  79
  80 static GdkFilterReturn gtk_form_filter(GdkXEvent *gdk_xevent,
  81                                        GdkEvent *event,
  82                                        gpointer data);
  83 static GdkFilterReturn gtk_form_main_filter(GdkXEvent *gdk_xevent,
  84                                             GdkEvent *event,
  85                                             gpointer data);
  86
  87 static void gtk_form_set_static_gravity(GdkWindow *window,
  88                                         gboolean use_static);
  89
  90 static void gtk_form_send_configure(GtkForm *form);
  91
  92 static void gtk_form_child_map(GtkWidget *widget, gpointer user_data);
  93 static void gtk_form_child_unmap(GtkWidget *widget, gpointer user_data);
  94
  95 static GtkWidgetClass *parent_class = NULL;
  96
  97 /* Public interface
  98  */
  99
 100     GtkWidget *
 101 gtk_form_new(void)
 102 {
 103     GtkForm *form;
 104
 105     form = gtk_type_new(gtk_form_get_type());
 106
 107     return GTK_WIDGET(form);
 108 }
 109
 110     void
 111 gtk_form_put(GtkForm    *form,
 112              GtkWidget  *child_widget,
 113              gint       x,
 114              gint       y)
 115 {
 116     GtkFormChild *child;
 117
 118     g_return_if_fail(GTK_IS_FORM(form));
 119
 120     /* LINTED: avoid warning: conversion to 'unsigned long' */
 121     child = g_new(GtkFormChild, 1);
 122
 123     child->widget = child_widget;
 124     child->window = NULL;
 125     child->x = x;
 126     child->y = y;
 127     child->widget->requisition.width = 0;
 128     child->widget->requisition.height = 0;
 129     child->mapped = FALSE;
 130
 131     form->children = g_list_append(form->children, child);
 132
 133     /* child->window must be created and attached to the widget _before_
 134      * it has been realized, or else things will break with GTK2.  Note
 135      * that gtk_widget_set_parent() realizes the widget if it's visible
 136      * and its parent is mapped.
 137      */
 138     if (GTK_WIDGET_REALIZED(form))
 139         gtk_form_attach_child_window(form, child);
 140
 141     gtk_widget_set_parent(child_widget, GTK_WIDGET(form));
 142     gtk_widget_size_request(child->widget, NULL);
 143
 144     if (GTK_WIDGET_REALIZED(form) && !GTK_WIDGET_REALIZED(child_widget))
 145         gtk_form_realize_child(form, child);
 146
 147     gtk_form_position_child(form, child, TRUE);
 148 }
 149
 150     void
 151 gtk_form_move(GtkForm   *form,
 152               GtkWidget *child_widget,
 153               gint      x,
 154               gint      y)
 155 {
 156     GList *tmp_list;
 157     GtkFormChild *child;
 158
 159     g_return_if_fail(GTK_IS_FORM(form));
 160
 161     for (tmp_list = form->children; tmp_list; tmp_list = tmp_list->next)
 162     {
 163         child = tmp_list->data;
 164         if (child->widget == child_widget)
 165         {
 166             child->x = x;
 167             child->y = y;
 168
 169             gtk_form_position_child(form, child, TRUE);
 170             return;
 171         }
 172     }
 173 }
 174
 175     void
 176 gtk_form_set_size(GtkForm *form, guint width, guint height)
 177 {
 178     g_return_if_fail(GTK_IS_FORM(form));
 179
 180     /* prevent unneccessary calls */
 181     if (form->width == width && form->height == height)
 182         return;
 183     form->width = width;
 184     form->height = height;
 185
 186     /* signal the change */
 187 #ifdef HAVE_GTK2
 188     gtk_widget_queue_resize(gtk_widget_get_parent(GTK_WIDGET(form)));
 189 #else
 190     gtk_container_queue_resize(GTK_CONTAINER(GTK_WIDGET(form)->parent));
 191 #endif
 192 }
 193
 194     void
 195 gtk_form_freeze(GtkForm *form)
 196 {
 197     g_return_if_fail(GTK_IS_FORM(form));
 198
 199     ++form->freeze_count;
 200 }
 201
 202     void
 203 gtk_form_thaw(GtkForm *form)
 204 {
 205     g_return_if_fail(GTK_IS_FORM(form));
 206
 207     if (form->freeze_count)
 208     {
 209         if (!(--form->freeze_count))
 210         {
 211             gtk_form_position_children(form);
 212 #ifdef HAVE_GTK2
 213             gtk_widget_queue_draw(GTK_WIDGET(form));
 214 #else
 215             gtk_widget_draw(GTK_WIDGET(form), NULL);
 216 #endif
 217         }
 218     }
 219 }
 220
 221 /* Basic Object handling procedures
 222  */
 223     GtkType
 224 gtk_form_get_type(void)
 225 {
 226     static GtkType form_type = 0;
 227
 228     if (!form_type)
 229     {
 230         GtkTypeInfo form_info =
 231         {
 232             "GtkForm",
 233             sizeof(GtkForm),
 234             sizeof(GtkFormClass),
 235             (GtkClassInitFunc) gtk_form_class_init,
 236             (GtkObjectInitFunc) gtk_form_init
 237         };
 238
 239         form_type = gtk_type_unique(GTK_TYPE_CONTAINER, &form_info);
 240     }
 241     return form_type;
 242 }
 243
 244     static void
 245 gtk_form_class_init(GtkFormClass *klass)
 246 {
 247     GtkWidgetClass *widget_class;
 248     GtkContainerClass *container_class;
 249
 250     widget_class = (GtkWidgetClass *) klass;
 251     container_class = (GtkContainerClass *) klass;
 252
 253     parent_class = gtk_type_class(gtk_container_get_type());
 254
 255     widget_class->realize = gtk_form_realize;
 256     widget_class->unrealize = gtk_form_unrealize;
 257     widget_class->map = gtk_form_map;
 258     widget_class->size_request = gtk_form_size_request;
 259     widget_class->size_allocate = gtk_form_size_allocate;
 260 #ifndef HAVE_GTK2 /* not needed for GTK2 */
 261     widget_class->draw = gtk_form_draw;
 262 #endif
 263     widget_class->expose_event = gtk_form_expose;
 264
 265     container_class->remove = gtk_form_remove;
 266     container_class->forall = gtk_form_forall;
 267 }
 268
 269     static void
 270 gtk_form_init(GtkForm *form)
 271 {
 272     form->children = NULL;
 273
 274     form->width = 1;
 275     form->height = 1;
 276
 277     form->bin_window = NULL;
 278
 279     form->configure_serial = 0;
 280     form->visibility = GDK_VISIBILITY_PARTIAL;
 281
 282     form->freeze_count = 0;
 283 }
 284
 285 /*
 286  * Widget methods
 287  */
 288
 289     static void
 290 gtk_form_realize(GtkWidget *widget)
 291 {
 292     GList *tmp_list;
 293     GtkForm *form;
 294     GdkWindowAttr attributes;
 295     gint attributes_mask;
 296
 297     g_return_if_fail(GTK_IS_FORM(widget));
 298
 299     form = GTK_FORM(widget);
 300     GTK_WIDGET_SET_FLAGS(form, GTK_REALIZED);
 301
 302     attributes.window_type = GDK_WINDOW_CHILD;
 303     attributes.x = widget->allocation.x;
 304     attributes.y = widget->allocation.y;
 305     attributes.width = widget->allocation.width;
 306     attributes.height = widget->allocation.height;
 307     attributes.wclass = GDK_INPUT_OUTPUT;
 308     attributes.visual = gtk_widget_get_visual(widget);
 309     attributes.colormap = gtk_widget_get_colormap(widget);
 310     attributes.event_mask = GDK_VISIBILITY_NOTIFY_MASK;
 311
 312     attributes_mask = GDK_WA_X | GDK_WA_Y | GDK_WA_VISUAL | GDK_WA_COLORMAP;
 313
 314     widget->window = gdk_window_new(gtk_widget_get_parent_window(widget),
 315                                     &attributes, attributes_mask);
 316     gdk_window_set_user_data(widget->window, widget);
 317
 318     attributes.x = 0;
 319     attributes.y = 0;
 320     attributes.event_mask = gtk_widget_get_events(widget);
 321
 322     form->bin_window = gdk_window_new(widget->window,
 323                                       &attributes, attributes_mask);
 324     gdk_window_set_user_data(form->bin_window, widget);
 325
 326     gtk_form_set_static_gravity(form->bin_window, TRUE);
 327
 328     widget->style = gtk_style_attach(widget->style, widget->window);
 329     gtk_style_set_background(widget->style, widget->window, GTK_STATE_NORMAL);
 330     gtk_style_set_background(widget->style, form->bin_window, GTK_STATE_NORMAL);
 331
 332     gdk_window_add_filter(widget->window, gtk_form_main_filter, form);
 333     gdk_window_add_filter(form->bin_window, gtk_form_filter, form);
 334
 335     for (tmp_list = form->children; tmp_list; tmp_list = tmp_list->next)
 336     {
 337         GtkFormChild *child = tmp_list->data;
 338
 339         gtk_form_attach_child_window(form, child);
 340
 341         if (GTK_WIDGET_VISIBLE(child->widget))
 342             gtk_form_realize_child(form, child);
 343     }
 344 }
 345
 346
 347 /* After reading the documentation at
 348  * http://developer.gnome.org/doc/API/2.0/gtk/gtk-changes-2-0.html
 349  * I think it should be possible to remove this function when compiling
 350  * against gtk-2.0.  It doesn't seem to cause problems, though.
 351  *
 352  * Well, I reckon at least the gdk_window_show(form->bin_window)
 353  * is necessary.  GtkForm is anything but a usual container widget.
 354  */
 355     static void
 356 gtk_form_map(GtkWidget *widget)
 357 {
 358     GList *tmp_list;
 359     GtkForm *form;
 360
 361     g_return_if_fail(GTK_IS_FORM(widget));
 362
 363     form = GTK_FORM(widget);
 364
 365     GTK_WIDGET_SET_FLAGS(widget, GTK_MAPPED);
 366
 367     gdk_window_show(widget->window);
 368     gdk_window_show(form->bin_window);
 369
 370     for (tmp_list = form->children; tmp_list; tmp_list = tmp_list->next)
 371     {
 372         GtkFormChild *child = tmp_list->data;
 373
 374         if (GTK_WIDGET_VISIBLE(child->widget)
 375                 && !GTK_WIDGET_MAPPED(child->widget))
 376             gtk_widget_map(child->widget);
 377     }
 378 }
 379
 380     static void
 381 gtk_form_unrealize(GtkWidget *widget)
 382 {
 383     GList *tmp_list;
 384     GtkForm *form;
 385
 386     g_return_if_fail(GTK_IS_FORM(widget));
 387
 388     form = GTK_FORM(widget);
 389
 390     tmp_list = form->children;
 391
 392     gdk_window_set_user_data(form->bin_window, NULL);
 393     gdk_window_destroy(form->bin_window);
 394     form->bin_window = NULL;
 395
 396     while (tmp_list)
 397     {
 398         GtkFormChild *child = tmp_list->data;
 399
 400         if (child->window != NULL)
 401         {
 402             gtk_signal_disconnect_by_func(GTK_OBJECT(child->widget),
 403                                           GTK_SIGNAL_FUNC(gtk_form_child_map),
 404                                           child);
 405             gtk_signal_disconnect_by_func(GTK_OBJECT(child->widget),
 406                                           GTK_SIGNAL_FUNC(gtk_form_child_unmap),
 407                                           child);
 408
 409             gdk_window_set_user_data(child->window, NULL);
 410             gdk_window_destroy(child->window);
 411
 412             child->window = NULL;
 413         }
 414
 415         tmp_list = tmp_list->next;
 416     }
 417
 418     if (GTK_WIDGET_CLASS (parent_class)->unrealize)
 419          (* GTK_WIDGET_CLASS (parent_class)->unrealize) (widget);
 420 }
 421
 422 #ifndef HAVE_GTK2
 423     static void
 424 gtk_form_draw(GtkWidget *widget, GdkRectangle *area)
 425 {
 426     GtkForm             *form;
 427     GList               *children;
 428     GtkFormChild        *child;
 429     GdkRectangle        child_area;
 430
 431     g_return_if_fail(GTK_IS_FORM(widget));
 432
 433     if (GTK_WIDGET_DRAWABLE(widget))
 434     {
 435         form = GTK_FORM(widget);
 436
 437         children = form->children;
 438
 439         while (children)
 440         {
 441             child = children->data;
 442
 443             if (GTK_WIDGET_DRAWABLE(child->widget)
 444                     && gtk_widget_intersect(child->widget, area, &child_area))
 445                 gtk_widget_draw(child->widget, &child_area);
 446
 447             children = children->next;
 448         }
 449     }
 450 }
 451 #endif /* !HAVE_GTK2 */
 452
 453     static void
 454 gtk_form_size_request(GtkWidget *widget, GtkRequisition *requisition)
 455 {
 456     GList *tmp_list;
 457     GtkForm *form;
 458
 459     g_return_if_fail(GTK_IS_FORM(widget));
 460
 461     form = GTK_FORM(widget);
 462
 463     requisition->width = form->width;
 464     requisition->height = form->height;
 465
 466     tmp_list = form->children;
 467
 468     while (tmp_list)
 469     {
 470         GtkFormChild *child = tmp_list->data;
 471         gtk_widget_size_request(child->widget, NULL);
 472         tmp_list = tmp_list->next;
 473     }
 474 }
 475
 476     static void
 477 gtk_form_size_allocate(GtkWidget *widget, GtkAllocation *allocation)
 478 {
 479     GList *tmp_list;
 480     GtkForm *form;
 481     gboolean need_reposition;
 482
 483     g_return_if_fail(GTK_IS_FORM(widget));
 484
 485     if (widget->allocation.x == allocation->x
 486             && widget->allocation.y == allocation->y
 487             && widget->allocation.width == allocation->width
 488             && widget->allocation.height == allocation->height)
 489         return;
 490
 491     need_reposition = widget->allocation.width != allocation->width
 492                    || widget->allocation.height != allocation->height;
 493     form = GTK_FORM(widget);
 494
 495     if (need_reposition)
 496     {
 497         tmp_list = form->children;
 498
 499         while (tmp_list)
 500         {
 501             GtkFormChild *child = tmp_list->data;
 502             gtk_form_position_child(form, child, TRUE);
 503
 504             tmp_list = tmp_list->next;
 505         }
 506     }
 507
 508     if (GTK_WIDGET_REALIZED(widget))
 509     {
 510         gdk_window_move_resize(widget->window,
 511                                allocation->x, allocation->y,
 512                                allocation->width, allocation->height);
 513         gdk_window_move_resize(GTK_FORM(widget)->bin_window,
 514                                0, 0,
 515                                allocation->width, allocation->height);
 516     }
 517     widget->allocation = *allocation;
 518     if (need_reposition)
 519         gtk_form_send_configure(form);
 520 }
 521
 522     static gint
 523 gtk_form_expose(GtkWidget *widget, GdkEventExpose *event)
 524 {
 525     GList   *tmp_list;
 526     GtkForm *form;
 527
 528     g_return_val_if_fail(GTK_IS_FORM(widget), FALSE);
 529
 530     form = GTK_FORM(widget);
 531
 532     if (event->window == form->bin_window)
 533         return FALSE;
 534
 535     for (tmp_list = form->children; tmp_list; tmp_list = tmp_list->next)
 536     {
 537 #ifdef HAVE_GTK2
 538         GtkFormChild    *formchild = tmp_list->data;
 539         GtkWidget       *child     = formchild->widget;
 540         /*
 541          * The following chunk of code is taken from gtkcontainer.c.  The
 542          * gtk1.x code synthesized expose events directly on the child widgets,
 543          * which can't be done in gtk2
 544          */
 545         if (GTK_WIDGET_DRAWABLE(child) && GTK_WIDGET_NO_WINDOW(child)
 546                 && child->window == event->window)
 547         {
 548             GdkEventExpose child_event;
 549             child_event = *event;
 550
 551             child_event.region = gtk_widget_region_intersect(child, event->region);
 552             if (!gdk_region_empty(child_event.region))
 553             {
 554                 gdk_region_get_clipbox(child_event.region, &child_event.area);
 555                 gtk_widget_send_expose(child, (GdkEvent *)&child_event);
 556             }
 557         }
 558 #else /* !HAVE_GTK2 */
 559         GtkFormChild *child = tmp_list->data;
 560
 561         if (event->window == child->window)
 562             return gtk_widget_event(child->widget, (GdkEvent *) event);
 563 #endif /* !HAVE_GTK2 */
 564     }
 565
 566     return FALSE;
 567 }
 568
 569 /* Container method
 570  */
 571     static void
 572 gtk_form_remove(GtkContainer *container, GtkWidget *widget)
 573 {
 574     GList *tmp_list;
 575     GtkForm *form;
 576     GtkFormChild *child = NULL;     /* init for gcc */
 577
 578     g_return_if_fail(GTK_IS_FORM(container));
 579
 580     form = GTK_FORM(container);
 581
 582     tmp_list = form->children;
 583     while (tmp_list)
 584     {
 585         child = tmp_list->data;
 586         if (child->widget == widget)
 587             break;
 588         tmp_list = tmp_list->next;
 589     }
 590
 591     if (tmp_list)
 592     {
 593         if (child->window)
 594         {
 595             gtk_signal_disconnect_by_func(GTK_OBJECT(child->widget),
 596                                           GTK_SIGNAL_FUNC(&gtk_form_child_map), child);
 597             gtk_signal_disconnect_by_func(GTK_OBJECT(child->widget),
 598                                           GTK_SIGNAL_FUNC(&gtk_form_child_unmap), child);
 599
 600             /* FIXME: This will cause problems for reparenting NO_WINDOW
 601              * widgets out of a GtkForm
 602              */
 603             gdk_window_set_user_data(child->window, NULL);
 604             gdk_window_destroy(child->window);
 605         }
 606         gtk_widget_unparent(widget);
 607
 608         form->children = g_list_remove_link(form->children, tmp_list);
 609         g_list_free_1(tmp_list);
 610         g_free(child);
 611     }
 612 }
 613
 614 /*ARGSUSED1*/
 615     static void
 616 gtk_form_forall(GtkContainer    *container,
 617                 gboolean        include_internals,
 618                 GtkCallback     callback,
 619                 gpointer        callback_data)
 620 {
 621     GtkForm *form;
 622     GtkFormChild *child;
 623     GList *tmp_list;
 624
 625     g_return_if_fail(GTK_IS_FORM(container));
 626     g_return_if_fail(callback != NULL);
 627
 628     form = GTK_FORM(container);
 629
 630     tmp_list = form->children;
 631     while (tmp_list)
 632     {
 633         child = tmp_list->data;
 634         tmp_list = tmp_list->next;
 635
 636         (*callback) (child->widget, callback_data);
 637     }
 638 }
 639
 640 /* Operations on children
 641  */
 642
 643     static void
 644 gtk_form_attach_child_window(GtkForm *form, GtkFormChild *child)
 645 {
 646     if (child->window != NULL)
 647         return; /* been there, done that */
 648
 649     if (GTK_WIDGET_NO_WINDOW(child->widget))
 650     {
 651         GtkWidget       *widget;
 652         GdkWindowAttr   attributes;
 653         gint            attributes_mask;
 654
 655         widget = GTK_WIDGET(form);
 656
 657         attributes.window_type = GDK_WINDOW_CHILD;
 658         attributes.x = child->x;
 659         attributes.y = child->y;
 660         attributes.width = child->widget->requisition.width;
 661         attributes.height = child->widget->requisition.height;
 662         attributes.wclass = GDK_INPUT_OUTPUT;
 663         attributes.visual = gtk_widget_get_visual(widget);
 664         attributes.colormap = gtk_widget_get_colormap(widget);
 665         attributes.event_mask = GDK_EXPOSURE_MASK;
 666
 667         attributes_mask = GDK_WA_X | GDK_WA_Y | GDK_WA_VISUAL | GDK_WA_COLORMAP;
 668         child->window = gdk_window_new(form->bin_window,
 669                                        &attributes, attributes_mask);
 670         gdk_window_set_user_data(child->window, widget);
 671
 672         gtk_style_set_background(widget->style,
 673                                  child->window,
 674                                  GTK_STATE_NORMAL);
 675
 676         gtk_widget_set_parent_window(child->widget, child->window);
 677         gtk_form_set_static_gravity(child->window, TRUE);
 678         /*
 679          * Install signal handlers to map/unmap child->window
 680          * alongside with the actual widget.
 681          */
 682         gtk_signal_connect(GTK_OBJECT(child->widget), "map",
 683                            GTK_SIGNAL_FUNC(&gtk_form_child_map), child);
 684         gtk_signal_connect(GTK_OBJECT(child->widget), "unmap",
 685                            GTK_SIGNAL_FUNC(&gtk_form_child_unmap), child);
 686     }
 687     else if (!GTK_WIDGET_REALIZED(child->widget))
 688     {
 689         gtk_widget_set_parent_window(child->widget, form->bin_window);
 690     }
 691 }
 692
 693     static void
 694 gtk_form_realize_child(GtkForm *form, GtkFormChild *child)
 695 {
 696     gtk_form_attach_child_window(form, child);
 697     gtk_widget_realize(child->widget);
 698
 699     if (child->window == NULL) /* might be already set, see above */
 700         gtk_form_set_static_gravity(child->widget->window, TRUE);
 701 }
 702
 703     static void
 704 gtk_form_position_child(GtkForm *form, GtkFormChild *child,
 705                         gboolean force_allocate)
 706 {
 707     gint x;
 708     gint y;
 709
 710     x = child->x;
 711     y = child->y;
 712
 713     if ((x >= G_MINSHORT) && (x <= G_MAXSHORT) &&
 714         (y >= G_MINSHORT) && (y <= G_MAXSHORT))
 715     {
 716         if (!child->mapped)
 717         {
 718             if (GTK_WIDGET_MAPPED(form) && GTK_WIDGET_VISIBLE(child->widget))
 719             {
 720                 if (!GTK_WIDGET_MAPPED(child->widget))
 721                     gtk_widget_map(child->widget);
 722
 723                 child->mapped = TRUE;
 724                 force_allocate = TRUE;
 725             }
 726         }
 727
 728         if (force_allocate)
 729         {
 730             GtkAllocation allocation;
 731
 732             if (GTK_WIDGET_NO_WINDOW(child->widget))
 733             {
 734                 if (child->window)
 735                 {
 736                     gdk_window_move_resize(child->window,
 737                             x, y,
 738                             child->widget->requisition.width,
 739                             child->widget->requisition.height);
 740                 }
 741
 742                 allocation.x = 0;
 743                 allocation.y = 0;
 744             }
 745             else
 746             {
 747                 allocation.x = x;
 748                 allocation.y = y;
 749             }
 750
 751             allocation.width = child->widget->requisition.width;
 752             allocation.height = child->widget->requisition.height;
 753
 754             gtk_widget_size_allocate(child->widget, &allocation);
 755         }
 756     }
 757     else
 758     {
 759         if (child->mapped)
 760         {
 761             child->mapped = FALSE;
 762
 763             if (GTK_WIDGET_MAPPED(child->widget))
 764                 gtk_widget_unmap(child->widget);
 765         }
 766     }
 767 }
 768
 769     static void
 770 gtk_form_position_children(GtkForm *form)
 771 {
 772     GList *tmp_list;
 773
 774     for (tmp_list = form->children; tmp_list; tmp_list = tmp_list->next)
 775         gtk_form_position_child(form, tmp_list->data, FALSE);
 776 }
 777
 778 /* Callbacks */
 779
 780 /* The main event filter. Actually, we probably don't really need
 781  * to install this as a filter at all, since we are calling it
 782  * directly above in the expose-handling hack.
 783  *
 784  * This routine identifies expose events that are generated when
 785  * we've temporarily moved the bin_window_origin, and translates
 786  * them or discards them, depending on whether we are obscured
 787  * or not.
 788  */
 789 /*ARGSUSED1*/
 790     static GdkFilterReturn
 791 gtk_form_filter(GdkXEvent *gdk_xevent, GdkEvent *event, gpointer data)
 792 {
 793     XEvent *xevent;
 794     GtkForm *form;
 795
 796     xevent = (XEvent *) gdk_xevent;
 797     form = GTK_FORM(data);
 798
 799     switch (xevent->type)
 800     {
 801     case Expose:
 802         if (xevent->xexpose.serial == form->configure_serial)
 803         {
 804             if (form->visibility == GDK_VISIBILITY_UNOBSCURED)
 805                 return GDK_FILTER_REMOVE;
 806             else
 807                 break;
 808         }
 809         break;
 810
 811     case ConfigureNotify:
 812         if ((xevent->xconfigure.x != 0) || (xevent->xconfigure.y != 0))
 813             form->configure_serial = xevent->xconfigure.serial;
 814         break;
 815     }
 816
 817     return GDK_FILTER_CONTINUE;
 818 }
 819
 820 /* Although GDK does have a GDK_VISIBILITY_NOTIFY event,
 821  * there is no corresponding event in GTK, so we have
 822  * to get the events from a filter
 823  */
 824 /*ARGSUSED1*/
 825     static GdkFilterReturn
 826 gtk_form_main_filter(GdkXEvent *gdk_xevent, GdkEvent *event, gpointer data)
 827 {
 828     XEvent *xevent;
 829     GtkForm *form;
 830
 831     xevent = (XEvent *) gdk_xevent;
 832     form = GTK_FORM(data);
 833
 834     if (xevent->type == VisibilityNotify)
 835     {
 836         switch (xevent->xvisibility.state)
 837         {
 838         case VisibilityFullyObscured:
 839             form->visibility = GDK_VISIBILITY_FULLY_OBSCURED;
 840             break;
 841
 842         case VisibilityPartiallyObscured:
 843             form->visibility = GDK_VISIBILITY_PARTIAL;
 844             break;
 845
 846         case VisibilityUnobscured:
 847             form->visibility = GDK_VISIBILITY_UNOBSCURED;
 848             break;
 849         }
 850
 851         return GDK_FILTER_REMOVE;
 852     }
 853     return GDK_FILTER_CONTINUE;
 854 }
 855
 856 /* Routines to set the window gravity, and check whether it is
 857  * functional. Extra capabilities need to be added to GDK, so
 858  * we don't have to use Xlib here.
 859  */
 860     static void
 861 gtk_form_set_static_gravity(GdkWindow *window, gboolean use_static)
 862 {
 863 #ifdef HAVE_GTK2
 864     gboolean static_gravity_supported;
 865
 866     static_gravity_supported = gdk_window_set_static_gravities(window,
 867                                                                use_static);
 868     g_return_if_fail(static_gravity_supported);
 869 #else
 870     XSetWindowAttributes xattributes;
 871
 872     xattributes.win_gravity = (use_static) ? StaticGravity : NorthWestGravity;
 873     xattributes.bit_gravity = (use_static) ? StaticGravity : NorthWestGravity;
 874
 875     XChangeWindowAttributes(GDK_WINDOW_XDISPLAY(window),
 876                             GDK_WINDOW_XWINDOW(window),
 877                             CWBitGravity | CWWinGravity,
 878                             &xattributes);
 879 #endif
 880 }
 881
 882     void
 883 gtk_form_move_resize(GtkForm *form, GtkWidget *widget,
 884                      gint x, gint y, gint w, gint h)
 885 {
 886     widget->requisition.width  = w;
 887     widget->requisition.height = h;
 888
 889     gtk_form_move(form, widget, x, y);
 890 }
 891
 892     static void
 893 gtk_form_send_configure(GtkForm *form)
 894 {
 895     GtkWidget *widget;
 896     GdkEventConfigure event;
 897
 898     widget = GTK_WIDGET(form);
 899
 900     event.type = GDK_CONFIGURE;
 901     event.window = widget->window;
 902     event.x = widget->allocation.x;
 903     event.y = widget->allocation.y;
 904     event.width = widget->allocation.width;
 905     event.height = widget->allocation.height;
 906
 907 #ifdef HAVE_GTK2
 908     gtk_main_do_event((GdkEvent*)&event);
 909 #else
 910     gtk_widget_event(widget, (GdkEvent*)&event);
 911 #endif
 912 }
 913
 914 /*ARGSUSED0*/
 915     static void
 916 gtk_form_child_map(GtkWidget *widget, gpointer user_data)
 917 {
 918     GtkFormChild *child;
 919
 920     child = (GtkFormChild *)user_data;
 921
 922     child->mapped = TRUE;
 923     gdk_window_show(child->window);
 924 }
 925
 926 /*ARGSUSED0*/
 927     static void
 928 gtk_form_child_unmap(GtkWidget *widget, gpointer user_data)
 929 {
 930     GtkFormChild *child;
 931
 932     child = (GtkFormChild *)user_data;
 933
 934     child->mapped = FALSE;
 935     gdk_window_hide(child->window);
 936 }
 937