Pileus Git - ~andy/gtk/blob - gtk/gtkwindow.c

   1 /* GTK - The GIMP Toolkit
   2  * Copyright (C) 1995-1997 Peter Mattis, Spencer Kimball and Josh MacDonald
   3  *
   4  * This library is free software; you can redistribute it and/or
   5  * modify it under the terms of the GNU Library General Public
   6  * License as published by the Free Software Foundation; either
   7  * version 2 of the License, or (at your option) any later version.
   8  *
   9  * This library is distributed in the hope that it will be useful,
  10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  12  * Library General Public License for more details.
  13  *
  14  * You should have received a copy of the GNU Library General Public
  15  * License along with this library; if not, write to the Free
  16  * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  17  */
  18 #include <string.h>
  19 #include <limits.h>
  20 #include "gdk/gdk.h"
  21 #include "gdk/gdkkeysyms.h"
  22 #include "gdk/gdkx.h"
  23 #include "gtksignal.h"
  24 #include "gtkwindow.h"
  25
  26 enum {
  27   MOVE_RESIZE,
  28   SET_FOCUS,
  29   LAST_SIGNAL
  30 };
  31
  32
  33 typedef gint (*GtkWindowSignal1) (GtkObject *object,
  34                                   gpointer   arg1,
  35                                   gpointer   arg2,
  36                                   gint       arg3,
  37                                   gint       arg4,
  38                                   gpointer   data);
  39 typedef void (*GtkWindowSignal2) (GtkObject *object,
  40                                   gpointer   arg1,
  41                                   gpointer   data);
  42
  43 static void gtk_window_marshal_signal_1 (GtkObject      *object,
  44                                          GtkSignalFunc   func,
  45                                          gpointer        func_data,
  46                                          GtkArg         *args);
  47 static void gtk_window_marshal_signal_2 (GtkObject      *object,
  48                                          GtkSignalFunc   func,
  49                                          gpointer        func_data,
  50                                          GtkArg         *args);
  51 static void gtk_window_class_init         (GtkWindowClass    *klass);
  52 static void gtk_window_init               (GtkWindow         *window);
  53 static void gtk_window_arg                (GtkWindow         *window,
  54                                            GtkArg            *arg);
  55 static void gtk_window_destroy            (GtkObject         *object);
  56 static void gtk_window_show               (GtkWidget         *widget);
  57 static void gtk_window_hide               (GtkWidget         *widget);
  58 static void gtk_window_map                (GtkWidget         *widget);
  59 static void gtk_window_unmap              (GtkWidget         *widget);
  60 static void gtk_window_realize            (GtkWidget         *widget);
  61 static void gtk_window_size_request       (GtkWidget         *widget,
  62                                            GtkRequisition    *requisition);
  63 static void gtk_window_size_allocate      (GtkWidget         *widget,
  64                                            GtkAllocation     *allocation);
  65 static gint gtk_window_expose_event       (GtkWidget         *widget,
  66                                            GdkEventExpose    *event);
  67 static gint gtk_window_configure_event    (GtkWidget         *widget,
  68                                            GdkEventConfigure *event);
  69 static gint gtk_window_key_press_event    (GtkWidget         *widget,
  70                                            GdkEventKey       *event);
  71 static gint gtk_window_key_release_event  (GtkWidget         *widget,
  72                                            GdkEventKey       *event);
  73 static gint gtk_window_enter_notify_event (GtkWidget         *widget,
  74                                            GdkEventCrossing  *event);
  75 static gint gtk_window_leave_notify_event (GtkWidget         *widget,
  76                                            GdkEventCrossing  *event);
  77 static gint gtk_window_focus_in_event     (GtkWidget         *widget,
  78                                            GdkEventFocus     *event);
  79 static gint gtk_window_focus_out_event    (GtkWidget         *widget,
  80                                            GdkEventFocus     *event);
  81 static gint gtk_window_client_event       (GtkWidget         *widget,
  82                                            GdkEventClient    *event);
  83 static gint gtk_window_need_resize        (GtkContainer      *container);
  84 static gint gtk_real_window_move_resize   (GtkWindow         *window,
  85                                            gint              *x,
  86                                            gint              *y,
  87                                            gint               width,
  88                                            gint               height);
  89 static void gtk_real_window_set_focus     (GtkWindow         *window,
  90                                            GtkWidget         *focus);
  91 static gint gtk_window_move_resize        (GtkWidget         *widget);
  92 static void gtk_window_set_hints          (GtkWidget         *widget,
  93                                            GtkRequisition    *requisition);
  94 static gint gtk_window_check_accelerator  (GtkWindow         *window,
  95                                            gint               key,
  96                                            guint              mods);
  97
  98
  99 static GtkBinClass *parent_class = NULL;
 100 static gint window_signals[LAST_SIGNAL] = { 0 };
 101
 102
 103 guint
 104 gtk_window_get_type ()
 105 {
 106   static guint window_type = 0;
 107
 108   if (!window_type)
 109     {
 110       GtkTypeInfo window_info =
 111       {
 112         "GtkWindow",
 113         sizeof (GtkWindow),
 114         sizeof (GtkWindowClass),
 115         (GtkClassInitFunc) gtk_window_class_init,
 116         (GtkObjectInitFunc) gtk_window_init,
 117         (GtkArgFunc) gtk_window_arg,
 118       };
 119
 120       window_type = gtk_type_unique (gtk_bin_get_type (), &window_info);
 121     }
 122
 123   return window_type;
 124 }
 125
 126 static void
 127 gtk_window_class_init (GtkWindowClass *klass)
 128 {
 129   GtkObjectClass *object_class;
 130   GtkWidgetClass *widget_class;
 131   GtkContainerClass *container_class;
 132
 133   object_class = (GtkObjectClass*) klass;
 134   widget_class = (GtkWidgetClass*) klass;
 135   container_class = (GtkContainerClass*) klass;
 136
 137   parent_class = gtk_type_class (gtk_bin_get_type ());
 138
 139   gtk_object_add_arg_type ("GtkWindow::type", GTK_TYPE_WINDOW_TYPE);
 140   gtk_object_add_arg_type ("GtkWindow::title", GTK_TYPE_STRING);
 141   gtk_object_add_arg_type ("GtkWindow::auto_shrink", GTK_TYPE_BOOL);
 142   gtk_object_add_arg_type ("GtkWindow::allow_shrink", GTK_TYPE_BOOL);
 143   gtk_object_add_arg_type ("GtkWindow::allow_grow", GTK_TYPE_BOOL);
 144
 145   window_signals[MOVE_RESIZE] =
 146     gtk_signal_new ("move_resize",
 147                     GTK_RUN_LAST,
 148                     object_class->type,
 149                     GTK_SIGNAL_OFFSET (GtkWindowClass, move_resize),
 150                     gtk_window_marshal_signal_1,
 151                     GTK_TYPE_BOOL, 4,
 152                     GTK_TYPE_POINTER, GTK_TYPE_POINTER,
 153                     GTK_TYPE_INT, GTK_TYPE_INT);
 154
 155   window_signals[SET_FOCUS] =
 156     gtk_signal_new ("set_focus",
 157                     GTK_RUN_LAST,
 158                     object_class->type,
 159                     GTK_SIGNAL_OFFSET (GtkWindowClass, set_focus),
 160                     gtk_window_marshal_signal_2,
 161                     GTK_TYPE_NONE, 1,
 162                     GTK_TYPE_POINTER);
 163
 164   gtk_object_class_add_signals (object_class, window_signals, LAST_SIGNAL);
 165
 166   object_class->destroy = gtk_window_destroy;
 167
 168   widget_class->show = gtk_window_show;
 169   widget_class->hide = gtk_window_hide;
 170   widget_class->map = gtk_window_map;
 171   widget_class->unmap = gtk_window_unmap;
 172   widget_class->realize = gtk_window_realize;
 173   widget_class->size_request = gtk_window_size_request;
 174   widget_class->size_allocate = gtk_window_size_allocate;
 175   widget_class->expose_event = gtk_window_expose_event;
 176   widget_class->configure_event = gtk_window_configure_event;
 177   widget_class->key_press_event = gtk_window_key_press_event;
 178   widget_class->key_release_event = gtk_window_key_release_event;
 179   widget_class->enter_notify_event = gtk_window_enter_notify_event;
 180   widget_class->leave_notify_event = gtk_window_leave_notify_event;
 181   widget_class->focus_in_event = gtk_window_focus_in_event;
 182   widget_class->focus_out_event = gtk_window_focus_out_event;
 183   widget_class->client_event = gtk_window_client_event;
 184
 185   container_class->need_resize = gtk_window_need_resize;
 186
 187   klass->move_resize = gtk_real_window_move_resize;
 188   klass->set_focus = gtk_real_window_set_focus;
 189 }
 190
 191 static void
 192 gtk_window_init (GtkWindow *window)
 193 {
 194   GTK_WIDGET_UNSET_FLAGS (window, GTK_NO_WINDOW);
 195   GTK_WIDGET_SET_FLAGS (window, GTK_ANCHORED);
 196
 197   window->title = NULL;
 198   window->wmclass_name = NULL;
 199   window->wmclass_class = NULL;
 200   window->type = GTK_WINDOW_TOPLEVEL;
 201   window->accelerator_tables = NULL;
 202   window->focus_widget = NULL;
 203   window->default_widget = NULL;
 204   window->resize_count = 0;
 205   window->need_resize = FALSE;
 206   window->allow_shrink = FALSE;
 207   window->allow_grow = TRUE;
 208   window->auto_shrink = FALSE;
 209   window->handling_resize = FALSE;
 210   window->position = GTK_WIN_POS_NONE;
 211   window->use_uposition = TRUE;
 212 }
 213
 214 static void
 215 gtk_window_arg (GtkWindow *window,
 216                 GtkArg    *arg)
 217 {
 218   if (strcmp (arg->name, "type") == 0)
 219     {
 220       window->type = GTK_VALUE_ENUM(*arg);
 221     }
 222   else if (strcmp (arg->name, "title") == 0)
 223     {
 224       gtk_window_set_title (window, GTK_VALUE_STRING(*arg));
 225     }
 226   else if (strcmp (arg->name, "auto_shrink") == 0)
 227     {
 228       window->auto_shrink = (GTK_VALUE_BOOL(*arg) != FALSE);
 229     }
 230   else if (strcmp (arg->name, "allow_shrink") == 0)
 231     {
 232       window->allow_shrink = (GTK_VALUE_BOOL(*arg) != FALSE);
 233     }
 234   else if (strcmp (arg->name, "allow_grow") == 0)
 235     {
 236       window->allow_grow = (GTK_VALUE_BOOL(*arg) != FALSE);
 237     }
 238 }
 239
 240 GtkWidget*
 241 gtk_window_new (GtkWindowType type)
 242 {
 243   GtkWindow *window;
 244
 245   window = gtk_type_new (gtk_window_get_type ());
 246
 247   window->type = type;
 248
 249   return GTK_WIDGET (window);
 250 }
 251
 252 void
 253 gtk_window_set_title (GtkWindow   *window,
 254                       const gchar *title)
 255 {
 256   g_return_if_fail (window != NULL);
 257   g_return_if_fail (GTK_IS_WINDOW (window));
 258
 259   if (window->title)
 260     g_free (window->title);
 261   window->title = g_strdup (title);
 262
 263   if (GTK_WIDGET_REALIZED (window))
 264     gdk_window_set_title (GTK_WIDGET (window)->window, window->title);
 265 }
 266
 267 void
 268 gtk_window_set_wmclass (GtkWindow *window,
 269                         gchar     *wmclass_name,
 270                         gchar     *wmclass_class)
 271 {
 272   g_return_if_fail (window != NULL);
 273   g_return_if_fail (GTK_IS_WINDOW (window));
 274
 275   if (window->wmclass_name)
 276     g_free (window->wmclass_name);
 277   window->wmclass_name = g_strdup (wmclass_name);
 278
 279   if (window->wmclass_class)
 280     g_free (window->wmclass_class);
 281   window->wmclass_class = g_strdup (wmclass_class);
 282
 283   if (GTK_WIDGET_REALIZED (window))
 284     g_warning ("shouldn't set wmclass after window is realized!\n");
 285 }
 286
 287 void
 288 gtk_window_set_focus (GtkWindow *window,
 289                       GtkWidget *focus)
 290 {
 291   gtk_signal_emit (GTK_OBJECT (window), window_signals[SET_FOCUS], focus);
 292 }
 293
 294 void
 295 gtk_window_set_default (GtkWindow *window,
 296                         GtkWidget *defaultw)
 297 {
 298   g_return_if_fail (window != NULL);
 299   g_return_if_fail (GTK_IS_WINDOW (window));
 300   g_return_if_fail (GTK_WIDGET_CAN_DEFAULT (defaultw));
 301
 302   if (window->default_widget != defaultw)
 303     {
 304       if (window->default_widget)
 305         {
 306           GTK_WIDGET_UNSET_FLAGS (window->default_widget, GTK_HAS_DEFAULT);
 307           gtk_widget_draw_default (window->default_widget);
 308         }
 309
 310       window->default_widget = defaultw;
 311
 312       if (window->default_widget)
 313         {
 314           GTK_WIDGET_SET_FLAGS (window->default_widget, GTK_HAS_DEFAULT);
 315           gtk_widget_draw_default (window->default_widget);
 316         }
 317     }
 318 }
 319
 320 void
 321 gtk_window_set_policy (GtkWindow *window,
 322                        gint       allow_shrink,
 323                        gint       allow_grow,
 324                        gint       auto_shrink)
 325 {
 326   g_return_if_fail (window != NULL);
 327   g_return_if_fail (GTK_IS_WINDOW (window));
 328
 329   window->allow_shrink = (allow_shrink != FALSE);
 330   window->allow_grow = (allow_grow != FALSE);
 331   window->auto_shrink = (auto_shrink != FALSE);
 332 }
 333
 334 void
 335 gtk_window_add_accelerator_table (GtkWindow           *window,
 336                                   GtkAcceleratorTable *table)
 337 {
 338   g_return_if_fail (window != NULL);
 339   g_return_if_fail (GTK_IS_WINDOW (window));
 340
 341   gtk_accelerator_table_ref (table);
 342   window->accelerator_tables = g_list_prepend (window->accelerator_tables,
 343                                                table);
 344 }
 345
 346 void
 347 gtk_window_remove_accelerator_table (GtkWindow           *window,
 348                                      GtkAcceleratorTable *table)
 349 {
 350   g_return_if_fail (window != NULL);
 351   g_return_if_fail (GTK_IS_WINDOW (window));
 352
 353   window->accelerator_tables = g_list_remove (window->accelerator_tables,
 354                                               table);
 355   gtk_accelerator_table_unref (table);
 356 }
 357
 358 void
 359 gtk_window_position (GtkWindow         *window,
 360                      GtkWindowPosition  position)
 361 {
 362   g_return_if_fail (window != NULL);
 363   g_return_if_fail (GTK_IS_WINDOW (window));
 364
 365   window->position = position;
 366 }
 367
 368 static void
 369 gtk_window_marshal_signal_1 (GtkObject      *object,
 370                              GtkSignalFunc   func,
 371                              gpointer        func_data,
 372                              GtkArg         *args)
 373 {
 374   GtkWindowSignal1 rfunc;
 375   gint *return_val;
 376
 377   rfunc = (GtkWindowSignal1) func;
 378   return_val = GTK_RETLOC_BOOL (args[4]);
 379
 380   *return_val = (* rfunc) (object,
 381                            GTK_VALUE_POINTER (args[0]),
 382                            GTK_VALUE_POINTER (args[1]),
 383                            GTK_VALUE_INT (args[2]),
 384                            GTK_VALUE_INT (args[3]),
 385                            func_data);
 386 }
 387
 388 static void
 389 gtk_window_marshal_signal_2 (GtkObject      *object,
 390                              GtkSignalFunc   func,
 391                              gpointer        func_data,
 392                              GtkArg         *args)
 393 {
 394   GtkWindowSignal2 rfunc;
 395
 396   rfunc = (GtkWindowSignal2) func;
 397
 398   (* rfunc) (object, GTK_VALUE_POINTER (args[0]), func_data);
 399 }
 400
 401 static void
 402 gtk_window_destroy (GtkObject *object)
 403 {
 404   GtkWindow *window;
 405
 406   g_return_if_fail (object != NULL);
 407   g_return_if_fail (GTK_IS_WINDOW (object));
 408
 409   window = GTK_WINDOW (object);
 410   g_free (window->title);
 411
 412   if (GTK_OBJECT_CLASS (parent_class)->destroy)
 413     (* GTK_OBJECT_CLASS (parent_class)->destroy) (object);
 414 }
 415
 416 static void
 417 gtk_window_show (GtkWidget *widget)
 418 {
 419   g_return_if_fail (widget != NULL);
 420   g_return_if_fail (GTK_IS_WINDOW (widget));
 421
 422   GTK_WIDGET_SET_FLAGS (widget, GTK_VISIBLE);
 423   gtk_container_need_resize (GTK_CONTAINER (widget));
 424   gtk_widget_map (widget);
 425 }
 426
 427 static void
 428 gtk_window_hide (GtkWidget *widget)
 429 {
 430   g_return_if_fail (widget != NULL);
 431   g_return_if_fail (GTK_IS_WINDOW (widget));
 432
 433   GTK_WIDGET_UNSET_FLAGS (widget, GTK_VISIBLE);
 434   gtk_widget_unmap (widget);
 435 }
 436
 437 static void
 438 gtk_window_map (GtkWidget *widget)
 439 {
 440   GtkWindow *window;
 441
 442   g_return_if_fail (widget != NULL);
 443   g_return_if_fail (GTK_IS_WINDOW (widget));
 444
 445   GTK_WIDGET_SET_FLAGS (widget, GTK_MAPPED);
 446   GTK_WIDGET_UNSET_FLAGS (widget, GTK_UNMAPPED);
 447
 448   gtk_window_move_resize (widget);
 449   window = GTK_WINDOW (widget);
 450
 451   if (window->bin.child &&
 452       GTK_WIDGET_VISIBLE (window->bin.child) &&
 453       !GTK_WIDGET_MAPPED (window->bin.child))
 454     gtk_widget_map (window->bin.child);
 455
 456   gtk_window_set_hints (widget, &widget->requisition);
 457   gdk_window_show (widget->window);
 458 }
 459
 460 static void
 461 gtk_window_unmap (GtkWidget *widget)
 462 {
 463   GtkWindow *window;
 464
 465   g_return_if_fail (widget != NULL);
 466   g_return_if_fail (GTK_IS_WINDOW (widget));
 467
 468   GTK_WIDGET_UNSET_FLAGS (widget, GTK_MAPPED);
 469   GTK_WIDGET_SET_FLAGS (widget, GTK_UNMAPPED);
 470   gdk_window_hide (widget->window);
 471
 472   window = GTK_WINDOW (widget);
 473   window->use_uposition = TRUE;
 474 }
 475
 476 static void
 477 gtk_window_realize (GtkWidget *widget)
 478 {
 479   GtkWindow *window;
 480   GdkWindowAttr attributes;
 481   gint attributes_mask;
 482
 483   g_return_if_fail (widget != NULL);
 484   g_return_if_fail (GTK_IS_WINDOW (widget));
 485
 486   GTK_WIDGET_SET_FLAGS (widget, GTK_REALIZED);
 487   window = GTK_WINDOW (widget);
 488
 489   switch (window->type)
 490     {
 491     case GTK_WINDOW_TOPLEVEL:
 492       attributes.window_type = GDK_WINDOW_TOPLEVEL;
 493       break;
 494     case GTK_WINDOW_DIALOG:
 495       attributes.window_type = GDK_WINDOW_DIALOG;
 496       break;
 497     case GTK_WINDOW_POPUP:
 498       attributes.window_type = GDK_WINDOW_TEMP;
 499       break;
 500     }
 501
 502   attributes.title = window->title;
 503   attributes.wmclass_name = window->wmclass_name;
 504   attributes.wmclass_class = window->wmclass_class;
 505   attributes.width = widget->allocation.width;
 506   attributes.height = widget->allocation.height;
 507   attributes.wclass = GDK_INPUT_OUTPUT;
 508   attributes.visual = gtk_widget_get_visual (widget);
 509   attributes.colormap = gtk_widget_get_colormap (widget);
 510   attributes.event_mask = gtk_widget_get_events (widget);
 511   attributes.event_mask |= (GDK_EXPOSURE_MASK |
 512                             GDK_KEY_PRESS_MASK |
 513                             GDK_ENTER_NOTIFY_MASK |
 514                             GDK_LEAVE_NOTIFY_MASK |
 515                             GDK_FOCUS_CHANGE_MASK |
 516                             GDK_STRUCTURE_MASK);
 517
 518   attributes_mask = GDK_WA_VISUAL | GDK_WA_COLORMAP;
 519   attributes_mask |= (window->title ? GDK_WA_TITLE : 0);
 520   attributes_mask |= (window->wmclass_name ? GDK_WA_WMCLASS : 0);
 521
 522   widget->window = gdk_window_new (NULL, &attributes, attributes_mask);
 523   gdk_window_set_user_data (widget->window, window);
 524
 525   widget->style = gtk_style_attach (widget->style, widget->window);
 526   gtk_style_set_background (widget->style, widget->window, GTK_STATE_NORMAL);
 527 }
 528
 529 static void
 530 gtk_window_size_request (GtkWidget      *widget,
 531                          GtkRequisition *requisition)
 532 {
 533   GtkWindow *window;
 534
 535   g_return_if_fail (widget != NULL);
 536   g_return_if_fail (GTK_IS_WINDOW (widget));
 537   g_return_if_fail (requisition != NULL);
 538
 539   window = GTK_WINDOW (widget);
 540
 541   if (window->bin.child)
 542     {
 543       requisition->width = GTK_CONTAINER (window)->border_width * 2;
 544       requisition->height = GTK_CONTAINER (window)->border_width * 2;
 545
 546       gtk_widget_size_request (window->bin.child, &window->bin.child->requisition);
 547
 548       requisition->width += window->bin.child->requisition.width;
 549       requisition->height += window->bin.child->requisition.height;
 550     }
 551   else
 552     {
 553       if (!GTK_WIDGET_VISIBLE (window))
 554         window->need_resize = TRUE;
 555     }
 556 }
 557
 558 static void
 559 gtk_window_size_allocate (GtkWidget     *widget,
 560                           GtkAllocation *allocation)
 561 {
 562   GtkWindow *window;
 563   GtkAllocation child_allocation;
 564
 565   g_return_if_fail (widget != NULL);
 566   g_return_if_fail (GTK_IS_WINDOW (widget));
 567   g_return_if_fail (allocation != NULL);
 568
 569   window = GTK_WINDOW (widget);
 570   widget->allocation = *allocation;
 571
 572   if (window->bin.child && GTK_WIDGET_VISIBLE (window->bin.child))
 573     {
 574       child_allocation.x = GTK_CONTAINER (window)->border_width;
 575       child_allocation.y = GTK_CONTAINER (window)->border_width;
 576       child_allocation.width = allocation->width - child_allocation.x * 2;
 577       child_allocation.height = allocation->height - child_allocation.y * 2;
 578
 579       gtk_widget_size_allocate (window->bin.child, &child_allocation);
 580     }
 581 }
 582
 583 static gint
 584 gtk_window_expose_event (GtkWidget      *widget,
 585                          GdkEventExpose *event)
 586 {
 587   g_return_val_if_fail (widget != NULL, FALSE);
 588   g_return_val_if_fail (GTK_IS_WINDOW (widget), FALSE);
 589   g_return_val_if_fail (event != NULL, FALSE);
 590
 591   if (!GTK_WIDGET_UNMAPPED (widget))
 592     GTK_WIDGET_SET_FLAGS (widget, GTK_MAPPED);
 593
 594   if (GTK_WIDGET_DRAWABLE (widget))
 595     if (GTK_WIDGET_CLASS (parent_class)->expose_event)
 596       return (* GTK_WIDGET_CLASS (parent_class)->expose_event) (widget, event);
 597
 598   return FALSE;
 599 }
 600
 601 static gint
 602 gtk_window_configure_event (GtkWidget         *widget,
 603                             GdkEventConfigure *event)
 604 {
 605   GtkWindow *window;
 606   GtkAllocation allocation;
 607
 608   g_return_val_if_fail (widget != NULL, FALSE);
 609   g_return_val_if_fail (GTK_IS_WINDOW (widget), FALSE);
 610   g_return_val_if_fail (event != NULL, FALSE);
 611
 612   window = GTK_WINDOW (widget);
 613   window->handling_resize = TRUE;
 614
 615   allocation.x = 0;
 616   allocation.y = 0;
 617   allocation.width = event->width;
 618   allocation.height = event->height;
 619
 620   gtk_widget_size_allocate (widget, &allocation);
 621
 622   if (window->bin.child &&
 623       GTK_WIDGET_VISIBLE (window->bin.child) &&
 624       !GTK_WIDGET_MAPPED (window->bin.child))
 625     gtk_widget_map (window->bin.child);
 626
 627   window->resize_count -= 1;
 628   if (window->resize_count == 0)
 629     {
 630       if ((event->width != widget->requisition.width) ||
 631           (event->height != widget->requisition.height))
 632         {
 633           window->resize_count += 1;
 634           gdk_window_resize (widget->window,
 635                              widget->requisition.width,
 636                              widget->requisition.height);
 637         }
 638     }
 639   else if (window->resize_count < 0)
 640     {
 641       window->resize_count = 0;
 642     }
 643
 644   window->handling_resize = FALSE;
 645
 646   return FALSE;
 647 }
 648
 649 static gint
 650 gtk_window_key_press_event (GtkWidget   *widget,
 651                             GdkEventKey *event)
 652 {
 653   GtkWindow *window;
 654   GtkDirectionType direction = 0;
 655   gint return_val;
 656
 657   g_return_val_if_fail (widget != NULL, FALSE);
 658   g_return_val_if_fail (GTK_IS_WINDOW (widget), FALSE);
 659   g_return_val_if_fail (event != NULL, FALSE);
 660
 661   window = GTK_WINDOW (widget);
 662
 663   return_val = FALSE;
 664   if (window->focus_widget)
 665     return_val = gtk_widget_event (window->focus_widget, (GdkEvent*) event);
 666
 667   if (!return_val && gtk_window_check_accelerator (window, event->keyval, event->state))
 668     return_val = TRUE;
 669
 670   if (!return_val)
 671     {
 672       switch (event->keyval)
 673         {
 674         case GDK_space:
 675           if (window->focus_widget)
 676             {
 677               gtk_widget_activate (window->focus_widget);
 678               return_val = TRUE;
 679             }
 680           break;
 681         case GDK_Return:
 682         case GDK_KP_Enter:
 683           if (window->default_widget)
 684             {
 685               gtk_widget_activate (window->default_widget);
 686               return_val = TRUE;
 687             }
 688           else if (window->focus_widget)
 689             {
 690               gtk_widget_activate (window->focus_widget);
 691               return_val = TRUE;
 692             }
 693           break;
 694         case GDK_Up:
 695         case GDK_Down:
 696         case GDK_Left:
 697         case GDK_Right:
 698         case GDK_Tab:
 699           switch (event->keyval)
 700             {
 701             case GDK_Up:
 702               direction = GTK_DIR_UP;
 703               break;
 704             case GDK_Down:
 705               direction = GTK_DIR_DOWN;
 706               break;
 707             case GDK_Left:
 708               direction = GTK_DIR_LEFT;
 709               break;
 710             case GDK_Right:
 711               direction = GTK_DIR_RIGHT;
 712               break;
 713             case GDK_Tab:
 714               if (event->state & GDK_SHIFT_MASK)
 715                 direction = GTK_DIR_TAB_BACKWARD;
 716               else
 717                 direction = GTK_DIR_TAB_FORWARD;
 718               break;
 719             default :
 720               direction = GTK_DIR_UP; /* never reached, but makes compiler happy */
 721             }
 722
 723           gtk_container_focus (GTK_CONTAINER (widget), direction);
 724
 725           if (!GTK_CONTAINER (window)->focus_child)
 726             gtk_window_set_focus (GTK_WINDOW (widget), NULL);
 727           else
 728             return_val = TRUE;
 729           break;
 730         }
 731     }
 732
 733   return return_val;
 734 }
 735
 736 static gint
 737 gtk_window_key_release_event (GtkWidget   *widget,
 738                               GdkEventKey *event)
 739 {
 740   GtkWindow *window;
 741   gint return_val;
 742
 743   g_return_val_if_fail (widget != NULL, FALSE);
 744   g_return_val_if_fail (GTK_IS_WINDOW (widget), FALSE);
 745   g_return_val_if_fail (event != NULL, FALSE);
 746
 747   window = GTK_WINDOW (widget);
 748   return_val = FALSE;
 749   if (window->focus_widget)
 750     return_val = gtk_widget_event (window->focus_widget, (GdkEvent*) event);
 751
 752   return return_val;
 753 }
 754
 755 static gint
 756 gtk_window_enter_notify_event (GtkWidget        *widget,
 757                                GdkEventCrossing *event)
 758 {
 759   g_return_val_if_fail (widget != NULL, FALSE);
 760   g_return_val_if_fail (GTK_IS_WINDOW (widget), FALSE);
 761   g_return_val_if_fail (event != NULL, FALSE);
 762
 763   return FALSE;
 764 }
 765
 766 static gint
 767 gtk_window_leave_notify_event (GtkWidget        *widget,
 768                                GdkEventCrossing *event)
 769 {
 770   g_return_val_if_fail (widget != NULL, FALSE);
 771   g_return_val_if_fail (GTK_IS_WINDOW (widget), FALSE);
 772   g_return_val_if_fail (event != NULL, FALSE);
 773
 774   return FALSE;
 775 }
 776
 777 static gint
 778 gtk_window_focus_in_event (GtkWidget     *widget,
 779                            GdkEventFocus *event)
 780 {
 781   GtkWindow *window;
 782   GdkEventFocus fevent;
 783
 784   g_return_val_if_fail (widget != NULL, FALSE);
 785   g_return_val_if_fail (GTK_IS_WINDOW (widget), FALSE);
 786   g_return_val_if_fail (event != NULL, FALSE);
 787
 788   /* It appears spurious focus in events can occur when
 789    *  the window is hidden. So we'll just check to see if
 790    *  the window is visible before actually handling the
 791    *  event
 792    */
 793   if (GTK_WIDGET_VISIBLE (widget))
 794     {
 795       window = GTK_WINDOW (widget);
 796       if (window->focus_widget && !GTK_WIDGET_HAS_FOCUS (window->focus_widget))
 797         {
 798           fevent.type = GDK_FOCUS_CHANGE;
 799           fevent.window = window->focus_widget->window;
 800           fevent.in = TRUE;
 801
 802           gtk_widget_event (window->focus_widget, (GdkEvent*) &fevent);
 803         }
 804     }
 805
 806   return FALSE;
 807 }
 808
 809 static gint
 810 gtk_window_focus_out_event (GtkWidget     *widget,
 811                             GdkEventFocus *event)
 812 {
 813   GtkWindow *window;
 814   GdkEventFocus fevent;
 815
 816   g_return_val_if_fail (widget != NULL, FALSE);
 817   g_return_val_if_fail (GTK_IS_WINDOW (widget), FALSE);
 818   g_return_val_if_fail (event != NULL, FALSE);
 819
 820   window = GTK_WINDOW (widget);
 821   if (window->focus_widget && GTK_WIDGET_HAS_FOCUS (window->focus_widget))
 822     {
 823       fevent.type = GDK_FOCUS_CHANGE;
 824       fevent.window = window->focus_widget->window;
 825       fevent.in = FALSE;
 826
 827       gtk_widget_event (window->focus_widget, (GdkEvent*) &fevent);
 828     }
 829
 830   return FALSE;
 831 }
 832
 833 static void
 834 gtk_window_style_set_event (GtkWidget *widget,
 835                             GdkEventClient *event)
 836 {
 837   GdkAtom atom_default_colors;
 838   GtkStyle *style_newdefault;
 839   GdkAtom realtype;
 840   gint retfmt, retlen;
 841   GdkColor *data, *stylecolors;
 842   int i = 0;
 843   GdkColormap *widget_cmap;
 844
 845   atom_default_colors = gdk_atom_intern("_GTK_DEFAULT_COLORS", FALSE);
 846
 847   if(gdk_property_get (GDK_ROOT_PARENT(),
 848                        atom_default_colors,
 849                        gdk_atom_intern("STRING", FALSE),
 850                        0,
 851                        sizeof(GdkColor) * GTK_STYLE_NUM_STYLECOLORS(),
 852                        FALSE,
 853                        &realtype,
 854                        &retfmt,
 855                        &retlen,
 856                        (guchar **)&data) != TRUE) {
 857     g_warning("gdk_property_get() failed in _GTK_STYLE_CHANGED handler\n");
 858     return;
 859   }
 860   if(retfmt != sizeof(gushort)*8) {
 861     g_warning("retfmt (%d) != sizeof(gushort)*8 (%d)\n", retfmt,
 862         sizeof(gushort)*8);
 863     return;
 864   }
 865   /* We have the color data, now let's interpret it */
 866   style_newdefault = gtk_widget_get_default_style();
 867   gtk_style_ref(style_newdefault);
 868   stylecolors = (GdkColor *) style_newdefault;
 869
 870   widget_cmap = gtk_widget_get_colormap(widget);
 871   for(i = 0; i < GTK_STYLE_NUM_STYLECOLORS(); i++) {
 872     stylecolors[i] = data[i];
 873     gdk_color_alloc(widget_cmap, &stylecolors[i]);
 874   }
 875
 876   gtk_widget_set_default_style(style_newdefault);
 877   gtk_style_unref(style_newdefault);
 878
 879   /* Now we need to redraw everything */
 880   gtk_widget_draw(widget, NULL);
 881   gtk_widget_draw_children(widget);
 882 }
 883
 884 static gint
 885 gtk_window_client_event (GtkWidget      *widget,
 886                          GdkEventClient *event)
 887 {
 888   GdkAtom atom_styleset;
 889   g_return_val_if_fail (widget != NULL, FALSE);
 890   g_return_val_if_fail (GTK_IS_WINDOW (widget), FALSE);
 891   g_return_val_if_fail (event != NULL, FALSE);
 892
 893   atom_styleset = gdk_atom_intern("_GTK_STYLE_CHANGED", FALSE);
 894
 895   if(event->message_type == atom_styleset) {
 896     gtk_window_style_set_event(widget, event);
 897   }
 898   return FALSE;
 899 }
 900
 901 static gint
 902 gtk_window_need_resize (GtkContainer *container)
 903 {
 904   GtkWindow *window;
 905   gint return_val;
 906
 907   g_return_val_if_fail (container != NULL, FALSE);
 908   g_return_val_if_fail (GTK_IS_WINDOW (container), FALSE);
 909
 910   return_val = FALSE;
 911
 912   window = GTK_WINDOW (container);
 913   if (window->handling_resize)
 914     return return_val;
 915
 916   if (GTK_WIDGET_VISIBLE (container))
 917     {
 918       window->need_resize = TRUE;
 919       return_val = gtk_window_move_resize (GTK_WIDGET (window));
 920       window->need_resize = FALSE;
 921     }
 922
 923   return return_val;
 924 }
 925
 926 static gint
 927 gtk_real_window_move_resize (GtkWindow *window,
 928                              gint      *x,
 929                              gint      *y,
 930                              gint       width,
 931                              gint       height)
 932 {
 933   GtkWidget *widget;
 934   GtkWidget *resize_container;
 935   GSList *resize_widgets;
 936   GSList *resize_containers;
 937   GSList *tmp_list;
 938   gint return_val;
 939
 940   g_return_val_if_fail (window != NULL, FALSE);
 941   g_return_val_if_fail (GTK_IS_WINDOW (window), FALSE);
 942   g_return_val_if_fail ((x != NULL) || (y != NULL), FALSE);
 943
 944   return_val = FALSE;
 945
 946   widget = GTK_WIDGET (window);
 947
 948   if ((*x != -1) && (*y != -1))
 949     gdk_window_move (widget->window, *x, *y);
 950
 951   if ((widget->requisition.width == 0) ||
 952       (widget->requisition.height == 0))
 953     {
 954       widget->requisition.width = 200;
 955       widget->requisition.height = 200;
 956     }
 957
 958   gdk_window_get_geometry (widget->window, NULL, NULL, &width, &height, NULL);
 959
 960   resize_containers = NULL;
 961
 962   if ((window->auto_shrink &&
 963        ((width != widget->requisition.width) ||
 964         (height != widget->requisition.height))) ||
 965       (width < widget->requisition.width) ||
 966       (height < widget->requisition.height))
 967     {
 968       if (window->resize_count == 0)
 969         {
 970           window->resize_count += 1;
 971           gdk_window_resize (widget->window,
 972                              widget->requisition.width,
 973                              widget->requisition.height);
 974         }
 975     }
 976   else
 977     {
 978       /* The window hasn't changed size but one of its children
 979        *  queued a resize request. Which means that the allocation
 980        *  is not sufficient for the requisition of some child.
 981        *  We've already performed a size request at this point,
 982        *  so we simply need to run through the list of resize
 983        *  widgets and reallocate their sizes appropriately. We
 984        *  make the optimization of not performing reallocation
 985        *  for a widget who also has a parent in the resize widgets
 986        *  list.
 987        */
 988       resize_widgets = gtk_object_get_data (GTK_OBJECT (window), "resize_widgets");
 989       gtk_object_set_data (GTK_OBJECT (window), "resize_widgets", NULL);
 990
 991       tmp_list = resize_widgets;
 992       while (tmp_list)
 993        {
 994          widget = tmp_list->data;
 995          tmp_list = tmp_list->next;
 996
 997          /* referencing needed? */
 998          GTK_WIDGET_UNSET_FLAGS (widget, GTK_RESIZE_NEEDED);
 999          gtk_object_unref (GTK_OBJECT (widget));
1000
1001          widget = widget->parent;
1002
1003          while (widget &&
1004                 ((widget->allocation.width < widget->requisition.width) ||
1005                  (widget->allocation.height < widget->requisition.height)))
1006            widget = widget->parent;
1007
1008          if (widget)
1009            GTK_WIDGET_SET_FLAGS (widget, GTK_RESIZE_NEEDED);
1010        }
1011
1012       tmp_list = resize_widgets;
1013       while (tmp_list)
1014        {
1015          widget = tmp_list->data;
1016          tmp_list = tmp_list->next;
1017
1018          resize_container = widget->parent;
1019          while (resize_container &&
1020                 !GTK_WIDGET_RESIZE_NEEDED (resize_container))
1021            resize_container = resize_container->parent;
1022
1023          if (resize_container)
1024            widget = resize_container->parent;
1025          else
1026            widget = NULL;
1027
1028          while (widget)
1029            {
1030              if (GTK_WIDGET_RESIZE_NEEDED (widget))
1031                {
1032                  GTK_WIDGET_UNSET_FLAGS (resize_container, GTK_RESIZE_NEEDED);
1033                  resize_container = widget;
1034                }
1035              widget = widget->parent;
1036            }
1037
1038          if (resize_container &&
1039              !g_slist_find (resize_containers, resize_container))
1040            resize_containers = g_slist_prepend (resize_containers, resize_container);
1041        }
1042
1043       g_slist_free (resize_widgets);
1044
1045       tmp_list = resize_containers;
1046       while (tmp_list)
1047        {
1048          widget = tmp_list->data;
1049          tmp_list = tmp_list->next;
1050
1051          GTK_WIDGET_UNSET_FLAGS (widget, GTK_RESIZE_NEEDED);
1052          gtk_widget_size_allocate (widget, &widget->allocation);
1053          gtk_widget_queue_draw (widget);
1054        }
1055
1056       g_slist_free (resize_containers);
1057     }
1058
1059   return return_val;
1060 }
1061
1062 static gint
1063 gtk_window_move_resize (GtkWidget *widget)
1064 {
1065   GtkWindow *window;
1066   gint x, y;
1067   gint width, height;
1068   gint screen_width;
1069   gint screen_height;
1070   gint return_val;
1071
1072   g_return_val_if_fail (widget != NULL, FALSE);
1073   g_return_val_if_fail (GTK_IS_WINDOW (widget), FALSE);
1074
1075   return_val = FALSE;
1076
1077   if (GTK_WIDGET_REALIZED (widget))
1078     {
1079       window = GTK_WINDOW (widget);
1080
1081       /* Remember old size, to know if we have to reset hints */
1082       width = widget->requisition.width;
1083       height = widget->requisition.height;
1084       gtk_widget_size_request (widget, &widget->requisition);
1085
1086       if (GTK_WIDGET_MAPPED (widget) &&
1087           (width != widget->requisition.width ||
1088            height != widget->requisition.height))
1089         gtk_window_set_hints (widget, &widget->requisition);
1090
1091       x = -1;
1092       y = -1;
1093       width = widget->requisition.width;
1094       height = widget->requisition.height;
1095
1096       if (window->use_uposition)
1097         switch (window->position)
1098           {
1099           case GTK_WIN_POS_CENTER:
1100             x = (gdk_screen_width () - width) / 2;
1101             y = (gdk_screen_height () - height) / 2;
1102             gtk_widget_set_uposition (widget, x, y);
1103             break;
1104           case GTK_WIN_POS_MOUSE:
1105             gdk_window_get_pointer (NULL, &x, &y, NULL);
1106
1107             x -= width / 2;
1108             y -= height / 2;
1109
1110             screen_width = gdk_screen_width ();
1111             screen_height = gdk_screen_height ();
1112
1113             if (x < 0)
1114               x = 0;
1115             else if (x > (screen_width - width))
1116               x = screen_width - width;
1117
1118             if (y < 0)
1119               y = 0;
1120             else if (y > (screen_height - height))
1121               y = screen_height - height;
1122
1123             gtk_widget_set_uposition (widget, x, y);
1124             break;
1125           }
1126
1127       gtk_signal_emit (GTK_OBJECT (widget), window_signals[MOVE_RESIZE],
1128                        &x, &y, width, height, &return_val);
1129     }
1130
1131   return return_val;
1132 }
1133
1134 static void
1135 gtk_real_window_set_focus (GtkWindow *window,
1136                            GtkWidget *focus)
1137 {
1138   GdkEventFocus event;
1139
1140   g_return_if_fail (window != NULL);
1141   g_return_if_fail (GTK_IS_WINDOW (window));
1142
1143   if (focus && !GTK_WIDGET_CAN_FOCUS (focus))
1144     return;
1145
1146   if (window->focus_widget != focus)
1147     {
1148       if (window->focus_widget)
1149         {
1150           event.type = GDK_FOCUS_CHANGE;
1151           event.window = window->focus_widget->window;
1152           event.in = FALSE;
1153
1154           gtk_widget_event (window->focus_widget, (GdkEvent*) &event);
1155         }
1156
1157       window->focus_widget = focus;
1158
1159       if (window->focus_widget)
1160         {
1161           event.type = GDK_FOCUS_CHANGE;
1162           event.window = window->focus_widget->window;
1163           event.in = TRUE;
1164
1165           gtk_widget_event (window->focus_widget, (GdkEvent*) &event);
1166         }
1167     }
1168 }
1169
1170 static void
1171 gtk_window_set_hints (GtkWidget      *widget,
1172                       GtkRequisition *requisition)
1173 {
1174   GtkWindow *window;
1175   GtkWidgetAuxInfo *aux_info;
1176   gint flags;
1177   gint ux, uy;
1178
1179   g_return_if_fail (widget != NULL);
1180   g_return_if_fail (GTK_IS_WINDOW (widget));
1181   g_return_if_fail (requisition != NULL);
1182
1183   if (GTK_WIDGET_REALIZED (widget))
1184     {
1185       window = GTK_WINDOW (widget);
1186
1187       flags = 0;
1188       ux = 0;
1189       uy = 0;
1190
1191       aux_info = gtk_object_get_data (GTK_OBJECT (widget), "aux_info");
1192       if (aux_info && (aux_info->x != -1) && (aux_info->y != -1))
1193         {
1194           ux = aux_info->x;
1195           uy = aux_info->y;
1196           flags |= GDK_HINT_POS;
1197         }
1198       if (!window->allow_shrink)
1199         flags |= GDK_HINT_MIN_SIZE;
1200       if (!window->allow_grow)
1201         flags |= GDK_HINT_MAX_SIZE;
1202
1203       gdk_window_set_hints (widget->window, ux, uy,
1204                             requisition->width, requisition->height,
1205                             requisition->width, requisition->height,
1206                             flags);
1207
1208       if (window->use_uposition && (flags & GDK_HINT_POS))
1209         {
1210           window->use_uposition = FALSE;
1211           gdk_window_move (widget->window, ux, uy);
1212         }
1213     }
1214 }
1215
1216 static gint
1217 gtk_window_check_accelerator (GtkWindow *window,
1218                               gint       key,
1219                               guint      mods)
1220 {
1221   GtkAcceleratorTable *table;
1222   GList *tmp;
1223
1224   if ((key >= 0x20) && (key <= 0xFF))
1225     {
1226       tmp = window->accelerator_tables;
1227       while (tmp)
1228         {
1229           table = tmp->data;
1230           tmp = tmp->next;
1231
1232           if (gtk_accelerator_table_check (table, key, mods))
1233             return TRUE;
1234         }
1235
1236       if (gtk_accelerator_table_check (NULL, key, mods))
1237         return TRUE;
1238     }
1239
1240   return FALSE;
1241 }