Pileus Git - ~andy/gtk/blob - gtk/gtkwidget.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 <stdarg.h>
  19 #include <string.h>
  20 #include "gtkcontainer.h"
  21 #include "gtkmain.h"
  22 #include "gtkrc.h"
  23 #include "gtkselection.h"
  24 #include "gtksignal.h"
  25 #include "gtkwidget.h"
  26 #include "gtkwindow.h"
  27 #include "gtkprivate.h"
  28 #include "gdk/gdk.h"
  29 #include "gdk/gdkx.h"
  30
  31
  32 #define WIDGET_CLASS(w)  GTK_WIDGET_CLASS (GTK_OBJECT (w)->klass)
  33
  34
  35 enum {
  36   SHOW,
  37   HIDE,
  38   MAP,
  39   UNMAP,
  40   REALIZE,
  41   UNREALIZE,
  42   DRAW,
  43   DRAW_FOCUS,
  44   DRAW_DEFAULT,
  45   SIZE_REQUEST,
  46   SIZE_ALLOCATE,
  47   STATE_CHANGED,
  48   PARENT_SET,
  49   STYLE_SET,
  50   INSTALL_ACCELERATOR,
  51   REMOVE_ACCELERATOR,
  52   EVENT,
  53   BUTTON_PRESS_EVENT,
  54   BUTTON_RELEASE_EVENT,
  55   MOTION_NOTIFY_EVENT,
  56   DELETE_EVENT,
  57   DESTROY_EVENT,
  58   EXPOSE_EVENT,
  59   KEY_PRESS_EVENT,
  60   KEY_RELEASE_EVENT,
  61   ENTER_NOTIFY_EVENT,
  62   LEAVE_NOTIFY_EVENT,
  63   CONFIGURE_EVENT,
  64   FOCUS_IN_EVENT,
  65   FOCUS_OUT_EVENT,
  66   MAP_EVENT,
  67   UNMAP_EVENT,
  68   PROPERTY_NOTIFY_EVENT,
  69   SELECTION_CLEAR_EVENT,
  70   SELECTION_REQUEST_EVENT,
  71   SELECTION_NOTIFY_EVENT,
  72   SELECTION_RECEIVED,
  73   PROXIMITY_IN_EVENT,
  74   PROXIMITY_OUT_EVENT,
  75   DRAG_BEGIN_EVENT,
  76   DRAG_REQUEST_EVENT,
  77   DROP_ENTER_EVENT,
  78   DROP_LEAVE_EVENT,
  79   DROP_DATA_AVAILABLE_EVENT,
  80   OTHER_EVENT,
  81   CLIENT_EVENT,
  82   NO_EXPOSE_EVENT,
  83   LAST_SIGNAL
  84 };
  85
  86 enum {
  87   ARG_0,
  88   ARG_X,
  89   ARG_Y,
  90   ARG_WIDTH,
  91   ARG_HEIGHT,
  92   ARG_VISIBLE,
  93   ARG_SENSITIVE,
  94   ARG_CAN_FOCUS,
  95   ARG_HAS_FOCUS,
  96   ARG_CAN_DEFAULT,
  97   ARG_HAS_DEFAULT,
  98   ARG_EVENTS,
  99   ARG_EXTENSION_EVENTS,
 100   ARG_NAME,
 101   ARG_STYLE,
 102   ARG_PARENT
 103 };
 104
 105
 106 typedef void (*GtkWidgetSignal1) (GtkObject *object,
 107                                   gpointer   arg1,
 108                                   gpointer   data);
 109 typedef gint (*GtkWidgetSignal2) (GtkObject *object,
 110                                   gpointer   arg1,
 111                                   gchar      arg2,
 112                                   gchar      arg3,
 113                                   gpointer   data);
 114 typedef void (*GtkWidgetSignal3) (GtkObject *object,
 115                                   gpointer   arg1,
 116                                   gpointer   data);
 117 typedef gint (*GtkWidgetSignal4) (GtkObject *object,
 118                                   gpointer   arg1,
 119                                   gpointer   data);
 120 typedef void (*GtkWidgetSignal5) (GtkObject *object,
 121                                   guint      arg1,
 122                                   gpointer   data);
 123 typedef void (*GtkWidgetSignal6) (GtkObject *object,
 124                                   GtkObject *arg1,
 125                                   gpointer   data);
 126 typedef void (*GtkWidgetSignal7) (GtkObject *object,
 127                                   gpointer  *arg1,
 128                                   gpointer   data);
 129
 130 typedef struct  _GtkStateData    GtkStateData;
 131
 132 struct _GtkStateData
 133 {
 134   GtkStateType  state;
 135   gint          parent_sensitive;
 136 };
 137
 138
 139 static void gtk_widget_marshal_signal_1 (GtkObject      *object,
 140                                          GtkSignalFunc   func,
 141                                          gpointer        func_data,
 142                                          GtkArg         *args);
 143 static void gtk_widget_marshal_signal_2 (GtkObject      *object,
 144                                          GtkSignalFunc   func,
 145                                          gpointer        func_data,
 146                                          GtkArg         *args);
 147 static void gtk_widget_marshal_signal_3 (GtkObject      *object,
 148                                          GtkSignalFunc   func,
 149                                          gpointer        func_data,
 150                                          GtkArg         *args);
 151 static void gtk_widget_marshal_signal_4 (GtkObject      *object,
 152                                          GtkSignalFunc   func,
 153                                          gpointer        func_data,
 154                                          GtkArg         *args);
 155 static void gtk_widget_marshal_signal_5 (GtkObject      *object,
 156                                          GtkSignalFunc   func,
 157                                          gpointer        func_data,
 158                                          GtkArg         *args);
 159 static void gtk_widget_marshal_signal_6 (GtkObject      *object,
 160                                          GtkSignalFunc   func,
 161                                          gpointer        func_data,
 162                                          GtkArg         *args);
 163 static void gtk_widget_marshal_signal_7 (GtkObject      *object,
 164                                          GtkSignalFunc   func,
 165                                          gpointer        func_data,
 166                                          GtkArg         *args);
 167
 168 static void gtk_widget_class_init                (GtkWidgetClass    *klass);
 169 static void gtk_widget_init                      (GtkWidget         *widget);
 170 static void gtk_widget_set_arg                   (GtkWidget         *widget,
 171                                                   GtkArg            *arg,
 172                                                   guint              arg_id);
 173 static void gtk_widget_get_arg                   (GtkWidget         *widget,
 174                                                   GtkArg            *arg,
 175                                                   guint              arg_id);
 176 static void gtk_widget_real_destroy              (GtkObject         *object);
 177 static void gtk_widget_real_finalize             (GtkObject         *object);
 178 static void gtk_widget_real_show                 (GtkWidget         *widget);
 179 static void gtk_widget_real_hide                 (GtkWidget         *widget);
 180 static void gtk_widget_real_map                  (GtkWidget         *widget);
 181 static void gtk_widget_real_unmap                (GtkWidget         *widget);
 182 static void gtk_widget_real_realize              (GtkWidget         *widget);
 183 static void gtk_widget_real_unrealize            (GtkWidget         *widget);
 184 static void gtk_widget_real_draw                 (GtkWidget         *widget,
 185                                                   GdkRectangle      *area);
 186 static gint gtk_widget_real_queue_draw           (GtkWidget         *widget);
 187 static void gtk_widget_real_size_allocate        (GtkWidget         *widget,
 188                                                   GtkAllocation     *allocation);
 189 static void gtk_widget_style_set                 (GtkWidget         *widget,
 190                                                   GtkStyle          *previous_style);
 191
 192 static GdkColormap* gtk_widget_peek_colormap (void);
 193 static GdkVisual*   gtk_widget_peek_visual   (void);
 194 static GtkStyle*    gtk_widget_peek_style    (void);
 195
 196 static void gtk_widget_reparent_container_child  (GtkWidget     *widget,
 197                                                   gpointer       client_data);
 198 static void gtk_widget_propagate_state           (GtkWidget     *widget,
 199                                                   GtkStateData  *data);
 200 static void gtk_widget_draw_children_recurse     (GtkWidget     *widget,
 201                                                   gpointer       client_data);
 202 static void gtk_widget_set_style_internal        (GtkWidget     *widget,
 203                                                   GtkStyle      *style);
 204 static void gtk_widget_set_style_recurse         (GtkWidget     *widget,
 205                                                   gpointer       client_data);
 206
 207 extern GtkArg* gtk_object_collect_args (guint   *nargs,
 208                                         va_list  args1,
 209                                         va_list  args2);
 210
 211 static GtkWidgetAuxInfo* gtk_widget_aux_info_new     (void);
 212 static void              gtk_widget_aux_info_destroy (GtkWidgetAuxInfo *aux_info);
 213
 214 static GtkObjectClass *parent_class = NULL;
 215 static gint widget_signals[LAST_SIGNAL] = { 0 };
 216
 217 static GMemChunk *aux_info_mem_chunk = NULL;
 218
 219 static GdkColormap *default_colormap = NULL;
 220 static GdkVisual *default_visual = NULL;
 221 static GtkStyle *default_style = NULL;
 222
 223 static GSList *colormap_stack = NULL;
 224 static GSList *visual_stack = NULL;
 225 static GSList *style_stack = NULL;
 226
 227 static GSList *gtk_widget_redraw_queue = NULL;
 228 static GSList *gtk_widget_resize_queue = NULL;
 229
 230 static const gchar *aux_info_key = "gtk-aux-info";
 231 static const gchar *colormap_key = "gtk-colormap";
 232 static const gchar *visual_key = "gtk-visual";
 233 static const gchar *event_key = "gtk-event-mask";
 234 static const gchar *extension_event_key = "gtk-extension-event-mode";
 235 static const gchar *parent_window_key = "gtk-parent-window";
 236 static const gchar *shape_info_key = "gtk-shape-info";
 237 static const gchar *saved_default_style = "gtk-saved-default-style";
 238
 239
 240
 241 /*****************************************
 242  * gtk_widget_get_type:
 243  *
 244  *   arguments:
 245  *
 246  *   results:
 247  *****************************************/
 248
 249 guint
 250 gtk_widget_get_type ()
 251 {
 252   static guint widget_type = 0;
 253
 254   if (!widget_type)
 255     {
 256       GtkTypeInfo widget_info =
 257       {
 258         "GtkWidget",
 259         sizeof (GtkWidget),
 260         sizeof (GtkWidgetClass),
 261         (GtkClassInitFunc) gtk_widget_class_init,
 262         (GtkObjectInitFunc) gtk_widget_init,
 263         (GtkArgSetFunc) gtk_widget_set_arg,
 264         (GtkArgGetFunc) gtk_widget_get_arg,
 265       };
 266
 267       widget_type = gtk_type_unique (gtk_object_get_type (), &widget_info);
 268     }
 269
 270   return widget_type;
 271 }
 272
 273 /*****************************************
 274  * gtk_widget_class_init:
 275  *
 276  *   arguments:
 277  *
 278  *   results:
 279  *****************************************/
 280
 281 static void
 282 gtk_widget_class_init (GtkWidgetClass *klass)
 283 {
 284   GtkObjectClass *object_class;
 285
 286   object_class = (GtkObjectClass*) klass;
 287
 288   parent_class = gtk_type_class (gtk_object_get_type ());
 289
 290   gtk_object_add_arg_type ("GtkWidget::x", GTK_TYPE_INT, GTK_ARG_READWRITE, ARG_X);
 291   gtk_object_add_arg_type ("GtkWidget::y", GTK_TYPE_INT, GTK_ARG_READWRITE, ARG_Y);
 292   gtk_object_add_arg_type ("GtkWidget::width", GTK_TYPE_INT, GTK_ARG_READWRITE, ARG_WIDTH);
 293   gtk_object_add_arg_type ("GtkWidget::height", GTK_TYPE_INT, GTK_ARG_READWRITE, ARG_HEIGHT);
 294   gtk_object_add_arg_type ("GtkWidget::visible", GTK_TYPE_BOOL, GTK_ARG_READWRITE, ARG_VISIBLE);
 295   gtk_object_add_arg_type ("GtkWidget::sensitive", GTK_TYPE_BOOL, GTK_ARG_READWRITE, ARG_SENSITIVE);
 296   gtk_object_add_arg_type ("GtkWidget::can_focus", GTK_TYPE_BOOL, GTK_ARG_READWRITE, ARG_CAN_FOCUS);
 297   gtk_object_add_arg_type ("GtkWidget::has_focus", GTK_TYPE_BOOL, GTK_ARG_READWRITE, ARG_HAS_FOCUS);
 298   gtk_object_add_arg_type ("GtkWidget::can_default", GTK_TYPE_BOOL, GTK_ARG_READWRITE, ARG_CAN_DEFAULT);
 299   gtk_object_add_arg_type ("GtkWidget::has_default", GTK_TYPE_BOOL, GTK_ARG_READWRITE, ARG_HAS_DEFAULT);
 300   gtk_object_add_arg_type ("GtkWidget::events", GTK_TYPE_GDK_EVENT_MASK, GTK_ARG_READWRITE, ARG_EVENTS);
 301   gtk_object_add_arg_type ("GtkWidget::extension_events", GTK_TYPE_GDK_EVENT_MASK, GTK_ARG_READWRITE, ARG_EXTENSION_EVENTS);
 302   gtk_object_add_arg_type ("GtkWidget::name", GTK_TYPE_STRING, GTK_ARG_READWRITE, ARG_NAME);
 303   gtk_object_add_arg_type ("GtkWidget::style", GTK_TYPE_STYLE, GTK_ARG_READWRITE, ARG_STYLE);
 304   gtk_object_add_arg_type ("GtkWidget::parent", GTK_TYPE_CONTAINER, GTK_ARG_READWRITE, ARG_PARENT);
 305
 306   widget_signals[SHOW] =
 307     gtk_signal_new ("show",
 308                     GTK_RUN_FIRST,
 309                     object_class->type,
 310                     GTK_SIGNAL_OFFSET (GtkWidgetClass, show),
 311                     gtk_signal_default_marshaller,
 312                     GTK_TYPE_NONE, 0);
 313   widget_signals[HIDE] =
 314     gtk_signal_new ("hide",
 315                     GTK_RUN_FIRST,
 316                     object_class->type,
 317                     GTK_SIGNAL_OFFSET (GtkWidgetClass, hide),
 318                     gtk_signal_default_marshaller,
 319                     GTK_TYPE_NONE, 0);
 320   widget_signals[MAP] =
 321     gtk_signal_new ("map",
 322                     GTK_RUN_FIRST,
 323                     object_class->type,
 324                     GTK_SIGNAL_OFFSET (GtkWidgetClass, map),
 325                     gtk_signal_default_marshaller,
 326                     GTK_TYPE_NONE, 0);
 327   widget_signals[UNMAP] =
 328     gtk_signal_new ("unmap",
 329                     GTK_RUN_FIRST,
 330                     object_class->type,
 331                     GTK_SIGNAL_OFFSET (GtkWidgetClass, unmap),
 332                     gtk_signal_default_marshaller,
 333                     GTK_TYPE_NONE, 0);
 334   widget_signals[REALIZE] =
 335     gtk_signal_new ("realize",
 336                     GTK_RUN_FIRST,
 337                     object_class->type,
 338                     GTK_SIGNAL_OFFSET (GtkWidgetClass, realize),
 339                     gtk_signal_default_marshaller,
 340                     GTK_TYPE_NONE, 0);
 341   widget_signals[UNREALIZE] =
 342     gtk_signal_new ("unrealize",
 343                     GTK_RUN_FIRST,
 344                     object_class->type,
 345                     GTK_SIGNAL_OFFSET (GtkWidgetClass, unrealize),
 346                     gtk_signal_default_marshaller,
 347                     GTK_TYPE_NONE, 0);
 348   widget_signals[DRAW] =
 349     gtk_signal_new ("draw",
 350                     GTK_RUN_FIRST,
 351                     object_class->type,
 352                     GTK_SIGNAL_OFFSET (GtkWidgetClass, draw),
 353                     gtk_widget_marshal_signal_1,
 354                     GTK_TYPE_NONE, 1,
 355                     GTK_TYPE_POINTER);
 356   widget_signals[DRAW_FOCUS] =
 357     gtk_signal_new ("draw_focus",
 358                     GTK_RUN_FIRST,
 359                     object_class->type,
 360                     GTK_SIGNAL_OFFSET (GtkWidgetClass, draw_focus),
 361                     gtk_signal_default_marshaller,
 362                     GTK_TYPE_NONE, 0);
 363   widget_signals[DRAW_DEFAULT] =
 364     gtk_signal_new ("draw_default",
 365                     GTK_RUN_FIRST,
 366                     object_class->type,
 367                     GTK_SIGNAL_OFFSET (GtkWidgetClass, draw_default),
 368                     gtk_signal_default_marshaller,
 369                     GTK_TYPE_NONE, 0);
 370   widget_signals[SIZE_REQUEST] =
 371     gtk_signal_new ("size_request",
 372                     GTK_RUN_FIRST,
 373                     object_class->type,
 374                     GTK_SIGNAL_OFFSET (GtkWidgetClass, size_request),
 375                     gtk_widget_marshal_signal_1,
 376                     GTK_TYPE_NONE, 1,
 377                     GTK_TYPE_POINTER);
 378   widget_signals[SIZE_ALLOCATE] =
 379     gtk_signal_new ("size_allocate",
 380                     GTK_RUN_FIRST,
 381                     object_class->type,
 382                     GTK_SIGNAL_OFFSET (GtkWidgetClass, size_allocate),
 383                     gtk_widget_marshal_signal_1,
 384                     GTK_TYPE_NONE, 1,
 385                     GTK_TYPE_POINTER);
 386   widget_signals[STATE_CHANGED] =
 387     gtk_signal_new ("state_changed",
 388                     GTK_RUN_FIRST,
 389                     object_class->type,
 390                     GTK_SIGNAL_OFFSET (GtkWidgetClass, state_changed),
 391                     gtk_widget_marshal_signal_5,
 392                     GTK_TYPE_NONE, 1,
 393                     GTK_TYPE_UINT);
 394   widget_signals[PARENT_SET] =
 395     gtk_signal_new ("parent_set",
 396                     GTK_RUN_FIRST,
 397                     object_class->type,
 398                     GTK_SIGNAL_OFFSET (GtkWidgetClass, parent_set),
 399                     gtk_widget_marshal_signal_6,
 400                     GTK_TYPE_NONE, 1,
 401                     GTK_TYPE_OBJECT);
 402   widget_signals[STYLE_SET] =
 403     gtk_signal_new ("style_set",
 404                     GTK_RUN_FIRST,
 405                     object_class->type,
 406                     GTK_SIGNAL_OFFSET (GtkWidgetClass, style_set),
 407                     gtk_widget_marshal_signal_7,
 408                     GTK_TYPE_NONE, 1,
 409                     GTK_TYPE_BOXED);
 410   widget_signals[INSTALL_ACCELERATOR] =
 411     gtk_signal_new ("install_accelerator",
 412                     GTK_RUN_FIRST,
 413                     object_class->type,
 414                     GTK_SIGNAL_OFFSET (GtkWidgetClass, install_accelerator),
 415                     gtk_widget_marshal_signal_2,
 416                     GTK_TYPE_BOOL, 3,
 417                     GTK_TYPE_STRING,
 418                     GTK_TYPE_CHAR,
 419                     GTK_TYPE_INT);
 420   widget_signals[REMOVE_ACCELERATOR] =
 421     gtk_signal_new ("remove_accelerator",
 422                     GTK_RUN_FIRST,
 423                     object_class->type,
 424                     GTK_SIGNAL_OFFSET (GtkWidgetClass, remove_accelerator),
 425                     gtk_widget_marshal_signal_3,
 426                     GTK_TYPE_NONE, 1,
 427                     GTK_TYPE_STRING);
 428   widget_signals[EVENT] =
 429     gtk_signal_new ("event",
 430                     GTK_RUN_LAST,
 431                     object_class->type,
 432                     GTK_SIGNAL_OFFSET (GtkWidgetClass, event),
 433                     gtk_widget_marshal_signal_4,
 434                     GTK_TYPE_BOOL, 1,
 435                     GTK_TYPE_GDK_EVENT);
 436   widget_signals[BUTTON_PRESS_EVENT] =
 437     gtk_signal_new ("button_press_event",
 438                     GTK_RUN_LAST,
 439                     object_class->type,
 440                     GTK_SIGNAL_OFFSET (GtkWidgetClass, button_press_event),
 441                     gtk_widget_marshal_signal_4,
 442                     GTK_TYPE_BOOL, 1,
 443                     GTK_TYPE_GDK_EVENT);
 444   widget_signals[BUTTON_RELEASE_EVENT] =
 445     gtk_signal_new ("button_release_event",
 446                     GTK_RUN_LAST,
 447                     object_class->type,
 448                     GTK_SIGNAL_OFFSET (GtkWidgetClass, button_release_event),
 449                     gtk_widget_marshal_signal_4,
 450                     GTK_TYPE_BOOL, 1,
 451                     GTK_TYPE_GDK_EVENT);
 452   widget_signals[MOTION_NOTIFY_EVENT] =
 453     gtk_signal_new ("motion_notify_event",
 454                     GTK_RUN_LAST,
 455                     object_class->type,
 456                     GTK_SIGNAL_OFFSET (GtkWidgetClass, motion_notify_event),
 457                     gtk_widget_marshal_signal_4,
 458                     GTK_TYPE_BOOL, 1,
 459                     GTK_TYPE_GDK_EVENT);
 460   widget_signals[DELETE_EVENT] =
 461     gtk_signal_new ("delete_event",
 462                     GTK_RUN_LAST,
 463                     object_class->type,
 464                     GTK_SIGNAL_OFFSET (GtkWidgetClass, delete_event),
 465                     gtk_widget_marshal_signal_4,
 466                     GTK_TYPE_BOOL, 1,
 467                     GTK_TYPE_GDK_EVENT);
 468   widget_signals[DESTROY_EVENT] =
 469     gtk_signal_new ("destroy_event",
 470                     GTK_RUN_LAST,
 471                     object_class->type,
 472                     GTK_SIGNAL_OFFSET (GtkWidgetClass, destroy_event),
 473                     gtk_widget_marshal_signal_4,
 474                     GTK_TYPE_BOOL, 1,
 475                     GTK_TYPE_GDK_EVENT);
 476   widget_signals[EXPOSE_EVENT] =
 477     gtk_signal_new ("expose_event",
 478                     GTK_RUN_LAST,
 479                     object_class->type,
 480                     GTK_SIGNAL_OFFSET (GtkWidgetClass, expose_event),
 481                     gtk_widget_marshal_signal_4,
 482                     GTK_TYPE_BOOL, 1,
 483                     GTK_TYPE_GDK_EVENT);
 484   widget_signals[KEY_PRESS_EVENT] =
 485     gtk_signal_new ("key_press_event",
 486                     GTK_RUN_LAST,
 487                     object_class->type,
 488                     GTK_SIGNAL_OFFSET (GtkWidgetClass, key_press_event),
 489                     gtk_widget_marshal_signal_4,
 490                     GTK_TYPE_BOOL, 1,
 491                     GTK_TYPE_GDK_EVENT);
 492   widget_signals[KEY_RELEASE_EVENT] =
 493     gtk_signal_new ("key_release_event",
 494                     GTK_RUN_LAST,
 495                     object_class->type,
 496                     GTK_SIGNAL_OFFSET (GtkWidgetClass, key_release_event),
 497                     gtk_widget_marshal_signal_4,
 498                     GTK_TYPE_BOOL, 1,
 499                     GTK_TYPE_GDK_EVENT);
 500   widget_signals[ENTER_NOTIFY_EVENT] =
 501     gtk_signal_new ("enter_notify_event",
 502                     GTK_RUN_LAST,
 503                     object_class->type,
 504                     GTK_SIGNAL_OFFSET (GtkWidgetClass, enter_notify_event),
 505                     gtk_widget_marshal_signal_4,
 506                     GTK_TYPE_BOOL, 1,
 507                     GTK_TYPE_GDK_EVENT);
 508   widget_signals[LEAVE_NOTIFY_EVENT] =
 509     gtk_signal_new ("leave_notify_event",
 510                     GTK_RUN_LAST,
 511                     object_class->type,
 512                     GTK_SIGNAL_OFFSET (GtkWidgetClass, leave_notify_event),
 513                     gtk_widget_marshal_signal_4,
 514                     GTK_TYPE_BOOL, 1,
 515                     GTK_TYPE_GDK_EVENT);
 516   widget_signals[CONFIGURE_EVENT] =
 517     gtk_signal_new ("configure_event",
 518                     GTK_RUN_LAST,
 519                     object_class->type,
 520                     GTK_SIGNAL_OFFSET (GtkWidgetClass, configure_event),
 521                     gtk_widget_marshal_signal_4,
 522                     GTK_TYPE_BOOL, 1,
 523                     GTK_TYPE_GDK_EVENT);
 524   widget_signals[FOCUS_IN_EVENT] =
 525     gtk_signal_new ("focus_in_event",
 526                     GTK_RUN_LAST,
 527                     object_class->type,
 528                     GTK_SIGNAL_OFFSET (GtkWidgetClass, focus_in_event),
 529                     gtk_widget_marshal_signal_4,
 530                     GTK_TYPE_BOOL, 1,
 531                     GTK_TYPE_GDK_EVENT);
 532   widget_signals[FOCUS_OUT_EVENT] =
 533     gtk_signal_new ("focus_out_event",
 534                     GTK_RUN_LAST,
 535                     object_class->type,
 536                     GTK_SIGNAL_OFFSET (GtkWidgetClass, focus_out_event),
 537                     gtk_widget_marshal_signal_4,
 538                     GTK_TYPE_BOOL, 1,
 539                     GTK_TYPE_GDK_EVENT);
 540   widget_signals[MAP_EVENT] =
 541     gtk_signal_new ("map_event",
 542                     GTK_RUN_LAST,
 543                     object_class->type,
 544                     GTK_SIGNAL_OFFSET (GtkWidgetClass, map_event),
 545                     gtk_widget_marshal_signal_4,
 546                     GTK_TYPE_BOOL, 1,
 547                     GTK_TYPE_GDK_EVENT);
 548   widget_signals[UNMAP_EVENT] =
 549     gtk_signal_new ("unmap_event",
 550                     GTK_RUN_LAST,
 551                     object_class->type,
 552                     GTK_SIGNAL_OFFSET (GtkWidgetClass, unmap_event),
 553                     gtk_widget_marshal_signal_4,
 554                     GTK_TYPE_BOOL, 1,
 555                     GTK_TYPE_GDK_EVENT);
 556   widget_signals[PROPERTY_NOTIFY_EVENT] =
 557     gtk_signal_new ("property_notify_event",
 558                     GTK_RUN_LAST,
 559                     object_class->type,
 560                     GTK_SIGNAL_OFFSET (GtkWidgetClass, property_notify_event),
 561                     gtk_widget_marshal_signal_4,
 562                     GTK_TYPE_BOOL, 1,
 563                     GTK_TYPE_GDK_EVENT);
 564   widget_signals[SELECTION_CLEAR_EVENT] =
 565     gtk_signal_new ("selection_clear_event",
 566                     GTK_RUN_LAST,
 567                     object_class->type,
 568                     GTK_SIGNAL_OFFSET (GtkWidgetClass, selection_clear_event),
 569                     gtk_widget_marshal_signal_4,
 570                     GTK_TYPE_BOOL, 1,
 571                     GTK_TYPE_GDK_EVENT);
 572   widget_signals[SELECTION_REQUEST_EVENT] =
 573     gtk_signal_new ("selection_request_event",
 574                     GTK_RUN_LAST,
 575                     object_class->type,
 576                     GTK_SIGNAL_OFFSET (GtkWidgetClass, selection_request_event),
 577                     gtk_widget_marshal_signal_4,
 578                     GTK_TYPE_BOOL, 1,
 579                     GTK_TYPE_GDK_EVENT);
 580   widget_signals[SELECTION_NOTIFY_EVENT] =
 581     gtk_signal_new ("selection_notify_event",
 582                     GTK_RUN_LAST,
 583                     object_class->type,
 584                     GTK_SIGNAL_OFFSET (GtkWidgetClass, selection_notify_event),
 585                     gtk_widget_marshal_signal_4,
 586                     GTK_TYPE_BOOL, 1,
 587                     GTK_TYPE_GDK_EVENT);
 588   widget_signals[SELECTION_RECEIVED] =
 589     gtk_signal_new ("selection_received",
 590                     GTK_RUN_LAST,
 591                     object_class->type,
 592                     GTK_SIGNAL_OFFSET (GtkWidgetClass, selection_received),
 593                     gtk_widget_marshal_signal_1,
 594                     GTK_TYPE_BOOL, 1,
 595                     GTK_TYPE_GDK_EVENT);
 596   widget_signals[PROXIMITY_IN_EVENT] =
 597     gtk_signal_new ("proximity_in_event",
 598                     GTK_RUN_FIRST,
 599                     object_class->type,
 600                     GTK_SIGNAL_OFFSET (GtkWidgetClass, proximity_in_event),
 601                     gtk_widget_marshal_signal_4,
 602                     GTK_TYPE_BOOL, 1,
 603                     GTK_TYPE_GDK_EVENT);
 604   widget_signals[PROXIMITY_OUT_EVENT] =
 605     gtk_signal_new ("proximity_out_event",
 606                     GTK_RUN_LAST,
 607                     object_class->type,
 608                     GTK_SIGNAL_OFFSET (GtkWidgetClass, proximity_out_event),
 609                     gtk_widget_marshal_signal_4,
 610                     GTK_TYPE_BOOL, 1,
 611                     GTK_TYPE_GDK_EVENT);
 612   widget_signals[DRAG_BEGIN_EVENT] =
 613     gtk_signal_new ("drag_begin_event",
 614                     GTK_RUN_LAST,
 615                     object_class->type,
 616                     GTK_SIGNAL_OFFSET (GtkWidgetClass, drag_begin_event),
 617                     gtk_widget_marshal_signal_4,
 618                     GTK_TYPE_BOOL, 1,
 619                     GTK_TYPE_GDK_EVENT);
 620   widget_signals[DRAG_REQUEST_EVENT] =
 621     gtk_signal_new ("drag_request_event",
 622                     GTK_RUN_LAST,
 623                     object_class->type,
 624                     GTK_SIGNAL_OFFSET (GtkWidgetClass, drag_request_event),
 625                     gtk_widget_marshal_signal_4,
 626                     GTK_TYPE_BOOL, 1,
 627                     GTK_TYPE_GDK_EVENT);
 628   widget_signals[DROP_ENTER_EVENT] =
 629     gtk_signal_new ("drop_enter_event",
 630                     GTK_RUN_FIRST,
 631                     object_class->type,
 632                     GTK_SIGNAL_OFFSET (GtkWidgetClass, drop_enter_event),
 633                     gtk_widget_marshal_signal_4,
 634                     GTK_TYPE_BOOL, 1,
 635                     GTK_TYPE_GDK_EVENT);
 636   widget_signals[DROP_LEAVE_EVENT] =
 637     gtk_signal_new ("drop_leave_event",
 638                     GTK_RUN_FIRST,
 639                     object_class->type,
 640                     GTK_SIGNAL_OFFSET (GtkWidgetClass, drop_leave_event),
 641                     gtk_widget_marshal_signal_4,
 642                     GTK_TYPE_BOOL, 1,
 643                     GTK_TYPE_GDK_EVENT);
 644   widget_signals[DROP_DATA_AVAILABLE_EVENT] =
 645     gtk_signal_new ("drop_data_available_event",
 646                     GTK_RUN_FIRST,
 647                     object_class->type,
 648                     GTK_SIGNAL_OFFSET (GtkWidgetClass,
 649                                        drop_data_available_event),
 650                     gtk_widget_marshal_signal_4,
 651                     GTK_TYPE_BOOL, 1,
 652                     GTK_TYPE_GDK_EVENT);
 653   widget_signals[OTHER_EVENT] =
 654     gtk_signal_new ("other_event",
 655                     GTK_RUN_LAST,
 656                     object_class->type,
 657                     GTK_SIGNAL_OFFSET (GtkWidgetClass, other_event),
 658                     gtk_widget_marshal_signal_4,
 659                     GTK_TYPE_BOOL, 1,
 660                     GTK_TYPE_GDK_EVENT);
 661   widget_signals[CLIENT_EVENT] =
 662     gtk_signal_new ("client_event",
 663                     GTK_RUN_LAST,
 664                     object_class->type,
 665                     GTK_SIGNAL_OFFSET (GtkWidgetClass, client_event),
 666                     gtk_widget_marshal_signal_4,
 667                     GTK_TYPE_BOOL, 1,
 668                     GTK_TYPE_GDK_EVENT);
 669   widget_signals[NO_EXPOSE_EVENT] =
 670     gtk_signal_new ("no_expose_event",
 671                     GTK_RUN_LAST,
 672                     object_class->type,
 673                     GTK_SIGNAL_OFFSET (GtkWidgetClass, no_expose_event),
 674                     gtk_widget_marshal_signal_4,
 675                     GTK_TYPE_BOOL, 1,
 676                     GTK_TYPE_GDK_EVENT);
 677
 678   gtk_object_class_add_signals (object_class, widget_signals, LAST_SIGNAL);
 679
 680   object_class->destroy = gtk_widget_real_destroy;
 681   object_class->finalize = gtk_widget_real_finalize;
 682
 683   klass->activate_signal = 0;
 684   klass->show = gtk_widget_real_show;
 685   klass->hide = gtk_widget_real_hide;
 686   klass->show_all = gtk_widget_real_show;
 687   klass->hide_all = gtk_widget_real_hide;
 688   klass->map = gtk_widget_real_map;
 689   klass->unmap = gtk_widget_real_unmap;
 690   klass->realize = gtk_widget_real_realize;
 691   klass->unrealize = gtk_widget_real_unrealize;
 692   klass->draw = gtk_widget_real_draw;
 693   klass->draw_focus = NULL;
 694   klass->size_request = NULL;
 695   klass->size_allocate = gtk_widget_real_size_allocate;
 696   klass->state_changed = NULL;
 697   klass->parent_set = NULL;
 698   klass->style_set = gtk_widget_style_set;
 699   klass->install_accelerator = NULL;
 700   klass->remove_accelerator = NULL;
 701   klass->event = NULL;
 702   klass->button_press_event = NULL;
 703   klass->button_release_event = NULL;
 704   klass->motion_notify_event = NULL;
 705   klass->delete_event = NULL;
 706   klass->destroy_event = NULL;
 707   klass->expose_event = NULL;
 708   klass->key_press_event = NULL;
 709   klass->key_release_event = NULL;
 710   klass->enter_notify_event = NULL;
 711   klass->leave_notify_event = NULL;
 712   klass->configure_event = NULL;
 713   klass->focus_in_event = NULL;
 714   klass->focus_out_event = NULL;
 715   klass->map_event = NULL;
 716   klass->unmap_event = NULL;
 717   klass->property_notify_event = gtk_selection_property_notify;
 718   klass->selection_clear_event = gtk_selection_clear;
 719   klass->selection_request_event = gtk_selection_request;
 720   klass->selection_notify_event = gtk_selection_notify;
 721   klass->selection_received = NULL;
 722   klass->proximity_in_event = NULL;
 723   klass->proximity_out_event = NULL;
 724   klass->drag_begin_event = NULL;
 725   klass->drag_request_event = NULL;
 726   klass->drop_enter_event = NULL;
 727   klass->drop_leave_event = NULL;
 728   klass->drop_data_available_event = NULL;
 729   klass->other_event = NULL;
 730   klass->no_expose_event = NULL;
 731 }
 732
 733 /*****************************************
 734  * gtk_widget_set_arg:
 735  *
 736  *   arguments:
 737  *
 738  *   results:
 739  *****************************************/
 740
 741 static void
 742 gtk_widget_set_arg (GtkWidget   *widget,
 743                     GtkArg      *arg,
 744                     guint        arg_id)
 745 {
 746   switch (arg_id)
 747     {
 748     case ARG_X:
 749       gtk_widget_set_uposition (widget, GTK_VALUE_INT (*arg), -2);
 750       break;
 751     case ARG_Y:
 752       gtk_widget_set_uposition (widget, -2, GTK_VALUE_INT (*arg));
 753       break;
 754     case ARG_WIDTH:
 755       gtk_widget_set_usize (widget, GTK_VALUE_INT (*arg), -1);
 756       break;
 757     case ARG_HEIGHT:
 758       gtk_widget_set_usize (widget, -1, GTK_VALUE_INT (*arg));
 759       break;
 760     case ARG_VISIBLE:
 761       if (GTK_VALUE_BOOL(*arg))
 762         gtk_widget_show (widget);
 763       else
 764         gtk_widget_hide (widget);
 765       break;
 766     case ARG_SENSITIVE:
 767       gtk_widget_set_sensitive (widget, GTK_VALUE_BOOL (*arg));
 768       break;
 769     case ARG_CAN_FOCUS:
 770       if (GTK_VALUE_BOOL (*arg))
 771         GTK_WIDGET_SET_FLAGS (widget, GTK_CAN_FOCUS);
 772       else
 773         GTK_WIDGET_UNSET_FLAGS (widget, GTK_CAN_FOCUS);
 774       break;
 775     case ARG_HAS_FOCUS:
 776       if (GTK_VALUE_BOOL (*arg))
 777         gtk_widget_grab_focus (widget);
 778       break;
 779     case ARG_CAN_DEFAULT:
 780       if (GTK_VALUE_BOOL (*arg))
 781         GTK_WIDGET_SET_FLAGS (widget, GTK_CAN_DEFAULT);
 782       else
 783         GTK_WIDGET_UNSET_FLAGS (widget, GTK_CAN_DEFAULT);
 784       break;
 785     case ARG_HAS_DEFAULT:
 786       if (GTK_VALUE_BOOL (*arg))
 787         gtk_widget_grab_default (widget);
 788       break;
 789     case ARG_EVENTS:
 790       gtk_widget_set_events (widget, GTK_VALUE_FLAGS (*arg));
 791       break;
 792     case ARG_EXTENSION_EVENTS:
 793       gtk_widget_set_extension_events (widget, GTK_VALUE_FLAGS (*arg));
 794       break;
 795     case ARG_NAME:
 796       gtk_widget_set_name (widget, GTK_VALUE_STRING (*arg));
 797       break;
 798     case ARG_STYLE:
 799       gtk_widget_set_style (widget, (GtkStyle*) GTK_VALUE_BOXED (*arg));
 800       break;
 801     case ARG_PARENT:
 802       gtk_container_add (GTK_CONTAINER (GTK_VALUE_OBJECT (*arg)), widget);
 803       break;
 804     default:
 805       arg->type = GTK_TYPE_INVALID;
 806       break;
 807     }
 808 }
 809
 810 /*****************************************
 811  * gtk_widget_get_arg:
 812  *
 813  *   arguments:
 814  *
 815  *   results:
 816  *****************************************/
 817
 818 static void
 819 gtk_widget_get_arg (GtkWidget   *widget,
 820                     GtkArg      *arg,
 821                     guint        arg_id)
 822 {
 823   GtkWidgetAuxInfo *aux_info;
 824   gint *eventp;
 825   GdkExtensionMode *modep;
 826
 827   switch (arg_id)
 828     {
 829     case ARG_X:
 830       aux_info = gtk_object_get_data (GTK_OBJECT (widget), aux_info_key);
 831       if (!aux_info)
 832         GTK_VALUE_INT (*arg) = -2;
 833       else
 834         GTK_VALUE_INT (*arg) = aux_info->x;
 835       break;
 836     case ARG_Y:
 837       aux_info = gtk_object_get_data (GTK_OBJECT (widget), aux_info_key);
 838       if (!aux_info)
 839         GTK_VALUE_INT (*arg) = -2;
 840       else
 841         GTK_VALUE_INT (*arg) = aux_info->y;
 842       break;
 843     case ARG_WIDTH:
 844       aux_info = gtk_object_get_data (GTK_OBJECT (widget), aux_info_key);
 845       if (!aux_info)
 846         GTK_VALUE_INT (*arg) = -2;
 847       else
 848         GTK_VALUE_INT (*arg) = aux_info->width;
 849       break;
 850     case ARG_HEIGHT:
 851       aux_info = gtk_object_get_data (GTK_OBJECT (widget), aux_info_key);
 852       if (!aux_info)
 853         GTK_VALUE_INT (*arg) = -2;
 854       else
 855         GTK_VALUE_INT (*arg) = aux_info->height;
 856       break;
 857     case ARG_VISIBLE:
 858       GTK_VALUE_BOOL (*arg) = GTK_WIDGET_VISIBLE (widget);
 859       break;
 860     case ARG_SENSITIVE:
 861       GTK_VALUE_BOOL (*arg) = GTK_WIDGET_SENSITIVE (widget);
 862       break;
 863     case ARG_CAN_FOCUS:
 864       GTK_VALUE_BOOL (*arg) = GTK_WIDGET_CAN_FOCUS (widget);
 865       break;
 866     case ARG_HAS_FOCUS:
 867       GTK_VALUE_BOOL (*arg) = GTK_WIDGET_HAS_FOCUS (widget);
 868       break;
 869     case ARG_CAN_DEFAULT:
 870       GTK_VALUE_BOOL (*arg) = GTK_WIDGET_CAN_DEFAULT (widget);
 871       break;
 872     case ARG_HAS_DEFAULT:
 873       GTK_VALUE_BOOL (*arg) = GTK_WIDGET_HAS_DEFAULT (widget);
 874       break;
 875     case ARG_EVENTS:
 876       eventp = gtk_object_get_data (GTK_OBJECT (widget), event_key);
 877       if (!eventp)
 878         GTK_VALUE_FLAGS (*arg) = 0;
 879       else
 880         GTK_VALUE_FLAGS (*arg) = *eventp;
 881       break;
 882     case ARG_EXTENSION_EVENTS:
 883       modep = gtk_object_get_data (GTK_OBJECT (widget), extension_event_key);
 884       if (!modep)
 885         GTK_VALUE_FLAGS (*arg) = 0;
 886       else
 887         GTK_VALUE_FLAGS (*arg) = *modep;
 888       break;
 889     case ARG_NAME:
 890       if (widget->name)
 891         GTK_VALUE_STRING (*arg) = g_strdup (widget->name);
 892       else
 893         GTK_VALUE_STRING (*arg) = g_strdup ("");
 894       break;
 895     case ARG_STYLE:
 896       GTK_VALUE_BOXED (*arg) = (gpointer) gtk_widget_get_style (widget);
 897       break;
 898     case ARG_PARENT:
 899       GTK_VALUE_OBJECT (*arg) = (GtkObject*) widget->parent;
 900       break;
 901     default:
 902       arg->type = GTK_TYPE_INVALID;
 903       break;
 904     }
 905 }
 906
 907 /*****************************************
 908  * gtk_widget_init:
 909  *
 910  *   arguments:
 911  *
 912  *   results:
 913  *****************************************/
 914
 915 static void
 916 gtk_widget_init (GtkWidget *widget)
 917 {
 918   GdkColormap *colormap;
 919   GdkVisual *visual;
 920
 921   GTK_PRIVATE_FLAGS (widget) = 0;
 922   widget->state = GTK_STATE_NORMAL;
 923   widget->saved_state = GTK_STATE_NORMAL;
 924   widget->name = NULL;
 925   widget->requisition.width = 0;
 926   widget->requisition.height = 0;
 927   widget->allocation.x = -1;
 928   widget->allocation.y = -1;
 929   widget->allocation.width = 1;
 930   widget->allocation.height = 1;
 931   widget->window = NULL;
 932   widget->parent = NULL;
 933
 934   GTK_WIDGET_SET_FLAGS (widget, GTK_SENSITIVE | GTK_PARENT_SENSITIVE);
 935
 936   widget->style = gtk_widget_peek_style ();
 937   gtk_style_ref (widget->style);
 938
 939   colormap = gtk_widget_peek_colormap ();
 940   visual = gtk_widget_peek_visual ();
 941
 942   /* XXX - should we ref the colormap and visual, too? */
 943
 944   if (colormap != gtk_widget_get_default_colormap ())
 945     {
 946       /* gdk_colormap_ref (colormap); */
 947       gtk_object_set_data (GTK_OBJECT (widget), colormap_key, colormap);
 948     }
 949
 950   if (visual != gtk_widget_get_default_visual ())
 951     {
 952       /* gdk_visual_ref (visual); */
 953       gtk_object_set_data (GTK_OBJECT (widget), visual_key, visual);
 954     }
 955 }
 956
 957 /*****************************************
 958  * gtk_widget_new:
 959  *
 960  *   arguments:
 961  *
 962  *   results:
 963  *****************************************/
 964
 965 GtkWidget*
 966 gtk_widget_new (guint type,
 967                 ...)
 968 {
 969   GtkObject *obj;
 970   GtkArg *args;
 971   guint nargs;
 972   va_list args1;
 973   va_list args2;
 974
 975   g_return_val_if_fail (gtk_type_is_a (type, gtk_widget_get_type ()), NULL);
 976
 977   obj = gtk_type_new (type);
 978
 979   va_start (args1, type);
 980   va_start (args2, type);
 981
 982   args = gtk_object_collect_args (&nargs, args1, args2);
 983   gtk_object_setv (obj, nargs, args);
 984   g_free (args);
 985
 986   va_end (args1);
 987   va_end (args2);
 988
 989   return GTK_WIDGET (obj);
 990 }
 991
 992 /*****************************************
 993  * gtk_widget_newv:
 994  *
 995  *   arguments:
 996  *
 997  *   results:
 998  *****************************************/
 999
1000 GtkWidget*
1001 gtk_widget_newv (guint   type,
1002                  guint   nargs,
1003                  GtkArg *args)
1004 {
1005   g_return_val_if_fail (gtk_type_is_a (type, gtk_widget_get_type ()), NULL);
1006
1007   return GTK_WIDGET (gtk_object_newv (type, nargs, args));
1008 }
1009
1010 /*****************************************
1011  * gtk_widget_get:
1012  *
1013  *   arguments:
1014  *
1015  *   results:
1016  *****************************************/
1017
1018 void
1019 gtk_widget_get (GtkWidget       *widget,
1020                 GtkArg          *arg)
1021 {
1022   g_return_if_fail (widget != NULL);
1023   g_return_if_fail (arg != NULL);
1024
1025   gtk_object_getv (GTK_OBJECT (widget), 1, arg);
1026 }
1027
1028 /*****************************************
1029  * gtk_widget_getv:
1030  *
1031  *   arguments:
1032  *
1033  *   results:
1034  *****************************************/
1035
1036 void
1037 gtk_widget_getv (GtkWidget      *widget,
1038                  guint           nargs,
1039                  GtkArg         *args)
1040 {
1041   gtk_object_getv (GTK_OBJECT (widget), nargs, args);
1042 }
1043
1044 /*****************************************
1045  * gtk_widget_set:
1046  *
1047  *   arguments:
1048  *
1049  *   results:
1050  *****************************************/
1051
1052 void
1053 gtk_widget_set (GtkWidget *widget,
1054                 ...)
1055 {
1056   GtkArg *args;
1057   guint nargs;
1058   va_list args1;
1059   va_list args2;
1060
1061   g_return_if_fail (widget != NULL);
1062
1063   va_start (args1, widget);
1064   va_start (args2, widget);
1065
1066   args = gtk_object_collect_args (&nargs, args1, args2);
1067   gtk_object_setv (GTK_OBJECT (widget), nargs, args);
1068   g_free (args);
1069
1070   va_end (args1);
1071   va_end (args2);
1072 }
1073
1074 /*****************************************
1075  * gtk_widget_setv:
1076  *
1077  *   arguments:
1078  *
1079  *   results:
1080  *****************************************/
1081
1082 void
1083 gtk_widget_setv (GtkWidget *widget,
1084                  guint      nargs,
1085                  GtkArg    *args)
1086 {
1087   gtk_object_setv (GTK_OBJECT (widget), nargs, args);
1088 }
1089
1090 /*****************************************
1091  * gtk_widget_unparent:
1092  *   do any cleanup necessary necessary
1093  *   for setting parent = NULL.
1094  *
1095  *   arguments:
1096  *
1097  *   results:
1098  *****************************************/
1099
1100 void
1101 gtk_widget_unparent (GtkWidget *widget)
1102 {
1103   GtkWidget *toplevel;
1104   GtkWidget *child;
1105   GtkWidget *old_parent;
1106
1107   g_return_if_fail (widget != NULL);
1108   if (widget->parent == NULL)
1109     return;
1110
1111   /* keep this function in sync with gtk_menu_detach()
1112    */
1113
1114   toplevel = gtk_widget_get_toplevel (widget);
1115   if (GTK_IS_WINDOW (toplevel))
1116     {
1117       child = GTK_WINDOW (toplevel)->focus_widget;
1118
1119       while (child && child != widget)
1120         child = child->parent;
1121
1122       if (child == widget)
1123         gtk_window_set_focus (GTK_WINDOW (toplevel), NULL);
1124     }
1125
1126   if (GTK_WIDGET_RESIZE_NEEDED (widget))
1127     {
1128       GTK_CONTAINER (toplevel)->resize_widgets =
1129         g_slist_remove (GTK_CONTAINER (toplevel)->resize_widgets, widget);
1130       GTK_PRIVATE_UNSET_FLAG (widget, GTK_RESIZE_NEEDED);
1131     }
1132
1133   if (widget->window &&
1134       GTK_WIDGET_NO_WINDOW (widget) &&
1135       GTK_WIDGET_DRAWABLE (widget))
1136     gdk_window_clear_area (widget->window,
1137                            widget->allocation.x,
1138                            widget->allocation.y,
1139                            widget->allocation.width,
1140                            widget->allocation.height);
1141
1142   if (GTK_WIDGET_REALIZED (widget) && !GTK_WIDGET_IN_REPARENT (widget))
1143     gtk_widget_unrealize (widget);
1144
1145   old_parent = widget->parent;
1146   widget->parent = NULL;
1147   gtk_signal_emit (GTK_OBJECT (widget), widget_signals[PARENT_SET], old_parent);
1148
1149   gtk_widget_unref (widget);
1150 }
1151
1152 /*****************************************
1153  * gtk_widget_destroy:
1154  *
1155  *   arguments:
1156  *
1157  *   results:
1158  *****************************************/
1159
1160 void
1161 gtk_widget_destroy (GtkWidget *widget)
1162 {
1163   g_return_if_fail (widget != NULL);
1164   g_return_if_fail (GTK_IS_WIDGET (widget));
1165
1166   GTK_WIDGET_UNSET_FLAGS (widget, GTK_VISIBLE);
1167   if (GTK_WIDGET_REALIZED (widget))
1168     gtk_widget_unrealize (widget);
1169
1170   gtk_object_destroy (GTK_OBJECT (widget));
1171 }
1172
1173 /*****************************************
1174  * gtk_widget_destroyed:
1175  *   Utility function: sets widget_pointer
1176  *   to NULL when widget is destroyed.
1177  *
1178  *   arguments:
1179  *
1180  *   results:
1181  *****************************************/
1182
1183 void
1184 gtk_widget_destroyed (GtkWidget      *widget,
1185                       GtkWidget      **widget_pointer)
1186 {
1187   /* Don't make any assumptions about the
1188    *  value of widget!
1189    *  Even check widget_pointer.
1190    */
1191   if (widget_pointer)
1192     *widget_pointer = NULL;
1193 }
1194
1195 /*****************************************
1196  * gtk_widget_show:
1197  *
1198  *   arguments:
1199  *
1200  *   results:
1201  *****************************************/
1202
1203 void
1204 gtk_widget_show (GtkWidget *widget)
1205 {
1206   g_return_if_fail (widget != NULL);
1207
1208   if (!GTK_WIDGET_VISIBLE (widget))
1209     gtk_signal_emit (GTK_OBJECT (widget), widget_signals[SHOW]);
1210 }
1211
1212 /*****************************************
1213  * gtk_widget_hide:
1214  *
1215  *   arguments:
1216  *
1217  *   results:
1218  *****************************************/
1219
1220 void
1221 gtk_widget_hide (GtkWidget *widget)
1222 {
1223   g_return_if_fail (widget != NULL);
1224
1225   if (GTK_WIDGET_VISIBLE (widget))
1226     gtk_signal_emit (GTK_OBJECT (widget), widget_signals[HIDE]);
1227 }
1228
1229 /*****************************************
1230  * gtk_widget_show_all:
1231  *
1232  *   Shows the widget and all children.
1233  *
1234  *   Container classes overwrite
1235  *   show_all and hide_all to call
1236  *   show_all (hide_all) on both themselves
1237  *   and on their child widgets.
1238  *
1239  *   arguments:
1240  *
1241  *   results:
1242  *****************************************/
1243
1244 void
1245 gtk_widget_show_all (GtkWidget *widget)
1246 {
1247   GtkWidgetClass *widget_class;
1248
1249   g_return_if_fail (widget != NULL);
1250
1251   /* show_all shouldn't be invoked through a signal,
1252      because in this case it would be quite slow - there would
1253      be a show and show_all signal emitted for every child widget.
1254    */
1255   widget_class = GTK_WIDGET_CLASS(GTK_OBJECT(widget)->klass);
1256   widget_class->show_all (widget);
1257 }
1258
1259 /*****************************************
1260  * gtk_widget_hide_all:
1261  *
1262  *   Hides the widget and all children.
1263  *   See gtk_widget_show_all.
1264  *
1265  *   arguments:
1266  *
1267  *   results:
1268  *****************************************/
1269
1270 void
1271 gtk_widget_hide_all (GtkWidget *widget)
1272 {
1273   GtkWidgetClass *widget_class;
1274
1275   g_return_if_fail (widget != NULL);
1276   g_assert (widget->parent);
1277
1278   if (GTK_WIDGET_RESIZE_NEEDED (widget))
1279     {
1280       GtkWidget *toplevel;
1281
1282       toplevel = gtk_widget_get_toplevel (widget);
1283       if (toplevel != widget)
1284         GTK_CONTAINER (toplevel)->resize_widgets =
1285           g_slist_remove (GTK_CONTAINER (toplevel)->resize_widgets, widget);
1286       GTK_PRIVATE_UNSET_FLAG (widget, GTK_RESIZE_NEEDED);
1287     }
1288
1289   widget_class = GTK_WIDGET_CLASS(GTK_OBJECT(widget)->klass);
1290   widget_class->hide_all (widget);
1291 }
1292
1293 /*****************************************
1294  * gtk_widget_map:
1295  *
1296  *   arguments:
1297  *
1298  *   results:
1299  *****************************************/
1300
1301 void
1302 gtk_widget_map (GtkWidget *widget)
1303 {
1304   g_return_if_fail (widget != NULL);
1305
1306   if (!GTK_WIDGET_MAPPED (widget))
1307     {
1308       if (!GTK_WIDGET_REALIZED (widget))
1309         gtk_widget_realize (widget);
1310
1311       gtk_signal_emit (GTK_OBJECT (widget), widget_signals[MAP]);
1312     }
1313 }
1314
1315 /*****************************************
1316  * gtk_widget_unmap:
1317  *
1318  *   arguments:
1319  *
1320  *   results:
1321  *****************************************/
1322
1323 void
1324 gtk_widget_unmap (GtkWidget *widget)
1325 {
1326   g_return_if_fail (widget != NULL);
1327
1328   if (GTK_WIDGET_MAPPED (widget))
1329     gtk_signal_emit (GTK_OBJECT (widget), widget_signals[UNMAP]);
1330 }
1331
1332 /*****************************************
1333  * gtk_widget_realize:
1334  *
1335  *   arguments:
1336  *
1337  *   results:
1338  *****************************************/
1339
1340 void
1341 gtk_widget_realize (GtkWidget *widget)
1342 {
1343   gint events;
1344   GdkExtensionMode mode;
1345   GtkWidgetShapeInfo *shape_info;
1346
1347   g_return_if_fail (widget != NULL);
1348
1349   if (!GTK_WIDGET_REALIZED (widget))
1350     {
1351       /*
1352         if (GTK_IS_CONTAINER (widget) && !GTK_WIDGET_NO_WINDOW (widget))
1353           g_print ("%s\n", gtk_type_name (GTK_WIDGET_TYPE (widget)));
1354       */
1355
1356       if (widget->parent && !GTK_WIDGET_REALIZED (widget->parent))
1357         gtk_widget_realize (widget->parent);
1358
1359       gtk_widget_ensure_style (widget);
1360
1361       gtk_signal_emit (GTK_OBJECT (widget), widget_signals[REALIZE]);
1362
1363       if (GTK_WIDGET_HAS_SHAPE_MASK (widget))
1364         {
1365           shape_info = gtk_object_get_data (GTK_OBJECT (widget),
1366                                             shape_info_key);
1367           gdk_window_shape_combine_mask (widget->window,
1368                                          shape_info->shape_mask,
1369                                          shape_info->offset_x,
1370                                          shape_info->offset_y);
1371         }
1372
1373       if (!GTK_WIDGET_NO_WINDOW (widget))
1374         {
1375           mode = gtk_widget_get_extension_events (widget);
1376           if (mode != GDK_EXTENSION_EVENTS_NONE)
1377             {
1378               events = gtk_widget_get_events (widget);
1379               gdk_input_set_extension_events (widget->window, events, mode);
1380             }
1381         }
1382
1383     }
1384 }
1385
1386 /*****************************************
1387  * gtk_widget_unrealize:
1388  *
1389  *   arguments:
1390  *
1391  *   results:
1392  *****************************************/
1393
1394 void
1395 gtk_widget_unrealize (GtkWidget *widget)
1396 {
1397   g_return_if_fail (widget != NULL);
1398
1399   if (GTK_WIDGET_REALIZED (widget))
1400     gtk_signal_emit (GTK_OBJECT (widget), widget_signals[UNREALIZE]);
1401 }
1402
1403 /*****************************************
1404  * gtk_widget_queue_draw:
1405  *
1406  *   arguments:
1407  *
1408  *   results:
1409  *****************************************/
1410
1411 static gint
1412 gtk_widget_idle_draw (void *data)
1413 {
1414   GSList *node;
1415
1416   node = gtk_widget_redraw_queue;
1417   gtk_widget_redraw_queue = NULL;
1418   while (node)
1419     {
1420       gtk_widget_real_queue_draw ((GtkWidget*) node->data);
1421       node = node->next;
1422     }
1423
1424   return gtk_widget_redraw_queue != NULL;
1425 }
1426
1427 void
1428 gtk_widget_queue_draw (GtkWidget *widget)
1429 {
1430   GtkWidget *parent;
1431
1432   g_return_if_fail (widget != NULL);
1433
1434   if (GTK_WIDGET_DRAWABLE (widget))
1435     {
1436       /* We queue the redraw if:
1437        *  a) the widget is not already queued for redraw and
1438        *  b) non of the widgets ancestors are queued for redraw.
1439        */
1440       parent = widget;
1441       while (parent)
1442         {
1443           if (GTK_WIDGET_REDRAW_PENDING (parent))
1444             return;
1445           parent = parent->parent;
1446         }
1447
1448       GTK_PRIVATE_SET_FLAG (widget, GTK_REDRAW_PENDING);
1449       if (gtk_widget_redraw_queue == NULL)
1450         gtk_idle_add_priority (GTK_PRIORITY_INTERNAL,
1451                                (GtkFunction) gtk_widget_idle_draw, NULL);
1452
1453       gtk_widget_redraw_queue = g_slist_prepend (gtk_widget_redraw_queue, widget);
1454     }
1455 }
1456
1457 /*****************************************
1458  * gtk_widget_queue_resize:
1459  *
1460  *   arguments:
1461  *
1462  *   results:
1463  *****************************************/
1464
1465 static gint
1466 gtk_widget_idle_sizer (void *data)
1467 {
1468   GSList *slist, *free_slist;
1469
1470   free_slist = gtk_widget_resize_queue;
1471   gtk_widget_resize_queue = NULL;
1472   slist = free_slist;
1473   while (slist)
1474     {
1475       GtkWidget *widget;
1476
1477       widget = slist->data;
1478
1479       GTK_PRIVATE_UNSET_FLAG (widget, GTK_RESIZE_PENDING);
1480       if (gtk_container_need_resize (GTK_CONTAINER (widget)))
1481         gtk_widget_queue_resize (widget);
1482
1483       slist = slist->next;
1484     }
1485   g_slist_free (free_slist);
1486
1487   return gtk_widget_resize_queue != NULL;
1488 }
1489
1490 void
1491 gtk_widget_queue_resize (GtkWidget *widget)
1492 {
1493   GtkWidget *toplevel;
1494
1495   g_return_if_fail (widget != NULL);
1496
1497   toplevel = gtk_widget_get_toplevel (widget);
1498   if (GTK_WIDGET_TOPLEVEL (toplevel))
1499     {
1500       if (GTK_WIDGET_VISIBLE (toplevel))
1501         {
1502           if (!GTK_CONTAINER_RESIZE_PENDING (toplevel))
1503             {
1504               GTK_PRIVATE_SET_FLAG (toplevel, GTK_RESIZE_PENDING);
1505               if (gtk_widget_resize_queue == NULL)
1506                 gtk_idle_add_priority (GTK_PRIORITY_INTERNAL,
1507                                        (GtkFunction) gtk_widget_idle_sizer, NULL);
1508               gtk_widget_resize_queue = g_slist_prepend (gtk_widget_resize_queue, toplevel);
1509             }
1510
1511           if (!GTK_WIDGET_RESIZE_NEEDED (widget))
1512             {
1513               GTK_PRIVATE_SET_FLAG (widget, GTK_RESIZE_NEEDED);
1514               GTK_CONTAINER (toplevel)->resize_widgets =
1515                 g_slist_prepend (GTK_CONTAINER (toplevel)->resize_widgets, widget);
1516             }
1517           else
1518             g_assert (g_slist_find (GTK_CONTAINER (toplevel)->resize_widgets, widget)); /* paranoid */
1519         }
1520       else
1521         gtk_container_need_resize (GTK_CONTAINER (toplevel));
1522     }
1523 }
1524
1525 /*****************************************
1526  * gtk_widget_draw:
1527  *
1528  *   arguments:
1529  *
1530  *   results:
1531  *****************************************/
1532
1533 void
1534 gtk_widget_draw (GtkWidget    *widget,
1535                  GdkRectangle *area)
1536 {
1537   GdkRectangle temp_area;
1538
1539   g_return_if_fail (widget != NULL);
1540
1541   if (GTK_WIDGET_DRAWABLE (widget) &&
1542       !GTK_WIDGET_REDRAW_PENDING (widget))
1543     {
1544       if (!area)
1545         {
1546           if (GTK_WIDGET_NO_WINDOW (widget))
1547             {
1548               temp_area.x = widget->allocation.x;
1549               temp_area.y = widget->allocation.y;
1550             }
1551           else
1552             {
1553               temp_area.x = 0;
1554               temp_area.y = 0;
1555             }
1556
1557           temp_area.width = widget->allocation.width;
1558           temp_area.height = widget->allocation.height;
1559           area = &temp_area;
1560         }
1561
1562       gtk_signal_emit (GTK_OBJECT (widget), widget_signals[DRAW], area);
1563     }
1564 }
1565
1566 /*****************************************
1567  * gtk_widget_draw_focus:
1568  *
1569  *   arguments:
1570  *
1571  *   results:
1572  *****************************************/
1573
1574 void
1575 gtk_widget_draw_focus (GtkWidget *widget)
1576 {
1577   g_return_if_fail (widget != NULL);
1578
1579   gtk_signal_emit (GTK_OBJECT (widget), widget_signals[DRAW_FOCUS]);
1580 }
1581
1582 /*****************************************
1583  * gtk_widget_draw_default:
1584  *
1585  *   arguments:
1586  *
1587  *   results:
1588  *****************************************/
1589
1590 void
1591 gtk_widget_draw_default (GtkWidget *widget)
1592 {
1593   g_return_if_fail (widget != NULL);
1594
1595   gtk_signal_emit (GTK_OBJECT (widget), widget_signals[DRAW_DEFAULT]);
1596 }
1597
1598 /*****************************************
1599  * gtk_widget_draw_children:
1600  *
1601  *   arguments:
1602  *
1603  *   results:
1604  *****************************************/
1605
1606 void
1607 gtk_widget_draw_children (GtkWidget *widget)
1608 {
1609   g_return_if_fail (widget != NULL);
1610
1611   if (GTK_IS_CONTAINER (widget))
1612     gtk_container_foreach (GTK_CONTAINER (widget),
1613                            gtk_widget_draw_children_recurse,
1614                            NULL);
1615 }
1616
1617 /*****************************************
1618  * gtk_widget_size_request:
1619  *
1620  *   arguments:
1621  *
1622  *   results:
1623  *****************************************/
1624
1625 void
1626 gtk_widget_size_request (GtkWidget      *widget,
1627                          GtkRequisition *requisition)
1628 {
1629   GtkWidgetAuxInfo *aux_info;
1630
1631   g_return_if_fail (widget != NULL);
1632
1633   gtk_widget_ref (widget);
1634   gtk_signal_emit (GTK_OBJECT (widget), widget_signals[SIZE_REQUEST],
1635                    requisition);
1636   aux_info = gtk_object_get_data (GTK_OBJECT (widget), aux_info_key);
1637   if (aux_info)
1638     {
1639       if (aux_info->width > 0)
1640         requisition->width = aux_info->width;
1641       if (aux_info->height > 0)
1642         requisition->height = aux_info->height;
1643     }
1644   gtk_widget_unref (widget);
1645 }
1646
1647 /*****************************************
1648  * gtk_widget_size_allocate:
1649  *
1650  *   arguments:
1651  *
1652  *   results:
1653  *****************************************/
1654
1655 void
1656 gtk_widget_size_allocate (GtkWidget     *widget,
1657                           GtkAllocation *allocation)
1658 {
1659   GtkWidgetAuxInfo *aux_info;
1660   GtkAllocation real_allocation;
1661
1662   g_return_if_fail (widget != NULL);
1663
1664   real_allocation = *allocation;
1665   aux_info = gtk_object_get_data (GTK_OBJECT (widget), aux_info_key);
1666
1667   if (aux_info)
1668     {
1669       if (aux_info->x != -1)
1670         real_allocation.x = aux_info->x;
1671       if (aux_info->y != -1)
1672         real_allocation.y = aux_info->y;
1673     }
1674
1675   gtk_signal_emit (GTK_OBJECT (widget), widget_signals[SIZE_ALLOCATE], &real_allocation);
1676 }
1677
1678 /*****************************************
1679  * gtk_widget_install_accelerator:
1680  *
1681  *   arguments:
1682  *
1683  *   results:
1684  *****************************************/
1685
1686 void
1687 gtk_widget_install_accelerator (GtkWidget           *widget,
1688                                 GtkAcceleratorTable *table,
1689                                 const gchar         *signal_name,
1690                                 gchar                key,
1691                                 guint8               modifiers)
1692 {
1693   gint return_val;
1694
1695   g_return_if_fail (widget != NULL);
1696
1697   gtk_widget_ref (widget);
1698   return_val = TRUE;
1699   gtk_signal_emit (GTK_OBJECT (widget), widget_signals[INSTALL_ACCELERATOR],
1700                    signal_name, key, modifiers, &return_val);
1701   if (return_val)
1702     gtk_accelerator_table_install (table,
1703                                    GTK_OBJECT (widget),
1704                                    signal_name,
1705                                    key,
1706                                    modifiers);
1707   gtk_widget_unref (widget);
1708 }
1709
1710 /*****************************************
1711  * gtk_widget_remove_accelerator:
1712  *
1713  *   arguments:
1714  *
1715  *   results:
1716  *****************************************/
1717
1718 void
1719 gtk_widget_remove_accelerator (GtkWidget           *widget,
1720                                GtkAcceleratorTable *table,
1721                                const gchar         *signal_name)
1722 {
1723   g_return_if_fail (widget != NULL);
1724
1725   gtk_widget_ref (widget);
1726   gtk_signal_emit (GTK_OBJECT (widget), widget_signals[REMOVE_ACCELERATOR],
1727                    signal_name);
1728   gtk_accelerator_table_remove (table, GTK_OBJECT (widget), signal_name);
1729   gtk_widget_unref (widget);
1730 }
1731
1732 /*****************************************
1733  * gtk_widget_event:
1734  *
1735  *   arguments:
1736  *
1737  *   results:
1738  *****************************************/
1739
1740 gint
1741 gtk_widget_event (GtkWidget *widget,
1742                   GdkEvent  *event)
1743 {
1744   gint return_val;
1745   gint signal_num;
1746
1747   g_return_val_if_fail (widget != NULL, TRUE);
1748
1749   gtk_widget_ref (widget);
1750   return_val = FALSE;
1751   gtk_signal_emit (GTK_OBJECT (widget), widget_signals[EVENT], event,
1752                    &return_val);
1753   if (return_val || GTK_OBJECT_DESTROYED (widget))
1754     {
1755       gtk_widget_unref (widget);
1756       return TRUE;
1757     }
1758
1759   switch (event->type)
1760     {
1761     case GDK_NOTHING:
1762       signal_num = -1;
1763       break;
1764     case GDK_BUTTON_PRESS:
1765     case GDK_2BUTTON_PRESS:
1766     case GDK_3BUTTON_PRESS:
1767       signal_num = BUTTON_PRESS_EVENT;
1768       break;
1769     case GDK_BUTTON_RELEASE:
1770       signal_num = BUTTON_RELEASE_EVENT;
1771       break;
1772     case GDK_MOTION_NOTIFY:
1773       signal_num = MOTION_NOTIFY_EVENT;
1774       break;
1775     case GDK_DELETE:
1776       signal_num = DELETE_EVENT;
1777       break;
1778     case GDK_DESTROY:
1779       signal_num = DESTROY_EVENT;
1780       break;
1781     case GDK_KEY_PRESS:
1782       signal_num = KEY_PRESS_EVENT;
1783       break;
1784     case GDK_KEY_RELEASE:
1785       signal_num = KEY_RELEASE_EVENT;
1786       break;
1787     case GDK_ENTER_NOTIFY:
1788       signal_num = ENTER_NOTIFY_EVENT;
1789       break;
1790     case GDK_LEAVE_NOTIFY:
1791       signal_num = LEAVE_NOTIFY_EVENT;
1792       break;
1793     case GDK_FOCUS_CHANGE:
1794       if (event->focus_change.in)
1795         signal_num = FOCUS_IN_EVENT;
1796       else
1797         signal_num = FOCUS_OUT_EVENT;
1798       break;
1799     case GDK_CONFIGURE:
1800       signal_num = CONFIGURE_EVENT;
1801       break;
1802     case GDK_MAP:
1803       signal_num = MAP_EVENT;
1804       break;
1805     case GDK_UNMAP:
1806       signal_num = UNMAP_EVENT;
1807       break;
1808     case GDK_PROPERTY_NOTIFY:
1809       signal_num = PROPERTY_NOTIFY_EVENT;
1810       break;
1811     case GDK_SELECTION_CLEAR:
1812       signal_num = SELECTION_CLEAR_EVENT;
1813       break;
1814     case GDK_SELECTION_REQUEST:
1815       signal_num = SELECTION_REQUEST_EVENT;
1816       break;
1817     case GDK_SELECTION_NOTIFY:
1818       signal_num = SELECTION_NOTIFY_EVENT;
1819       break;
1820     case GDK_PROXIMITY_IN:
1821       signal_num = PROXIMITY_IN_EVENT;
1822       break;
1823     case GDK_PROXIMITY_OUT:
1824       signal_num = PROXIMITY_OUT_EVENT;
1825       break;
1826     case GDK_DRAG_BEGIN:
1827       signal_num = DRAG_BEGIN_EVENT;
1828       break;
1829     case GDK_DRAG_REQUEST:
1830       signal_num = DRAG_REQUEST_EVENT;
1831       break;
1832     case GDK_DROP_ENTER:
1833       signal_num = DROP_ENTER_EVENT;
1834       break;
1835     case GDK_DROP_LEAVE:
1836       signal_num = DROP_LEAVE_EVENT;
1837       break;
1838     case GDK_DROP_DATA_AVAIL:
1839       signal_num = DROP_DATA_AVAILABLE_EVENT;
1840       break;
1841     case GDK_OTHER_EVENT:
1842       signal_num = OTHER_EVENT;
1843       break;
1844     case GDK_NO_EXPOSE:
1845       signal_num = NO_EXPOSE_EVENT;
1846       break;
1847     case GDK_CLIENT_EVENT:
1848       signal_num = CLIENT_EVENT;
1849       break;
1850     case GDK_EXPOSE:
1851       /* there is no sense in providing a widget with bogus expose events
1852        */
1853       if (!event->any.window)
1854         {
1855           gtk_widget_unref (widget);
1856           return TRUE;
1857         }
1858       signal_num = EXPOSE_EVENT;
1859       break;
1860     default:
1861       g_warning ("could not determine signal number for event: %d", event->type);
1862       gtk_widget_unref (widget);
1863       return TRUE;
1864     }
1865
1866   if (signal_num != -1)
1867     gtk_signal_emit (GTK_OBJECT (widget), widget_signals[signal_num], event, &return_val);
1868
1869   return_val |= GTK_OBJECT_DESTROYED (widget);
1870
1871   gtk_widget_unref (widget);
1872
1873   return return_val;
1874 }
1875
1876 /*****************************************
1877  * gtk_widget_activate:
1878  *
1879  *   arguments:
1880  *
1881  *   results:
1882  *****************************************/
1883
1884 void
1885 gtk_widget_activate (GtkWidget *widget)
1886 {
1887   g_return_if_fail (widget != NULL);
1888   g_return_if_fail (GTK_IS_WIDGET (widget));
1889
1890   if (WIDGET_CLASS (widget)->activate_signal)
1891     gtk_signal_emit (GTK_OBJECT (widget), WIDGET_CLASS (widget)->activate_signal);
1892 }
1893
1894 /*****************************************
1895  * gtk_widget_reparent_container_child:
1896  *   assistent function to gtk_widget_reparent
1897  *
1898  *   arguments:
1899  *
1900  *   results:
1901  *****************************************/
1902
1903 static void
1904 gtk_widget_reparent_container_child(GtkWidget *widget,
1905                                    gpointer   client_data)
1906 {
1907   g_return_if_fail (widget != NULL);
1908   g_return_if_fail (client_data != NULL);
1909
1910   if (GTK_WIDGET_NO_WINDOW (widget))
1911     {
1912       if (widget->window)
1913         gdk_window_unref (widget->window);
1914       widget->window = (GdkWindow*) client_data;
1915       if (widget->window)
1916         gdk_window_ref (widget->window);
1917
1918       if (GTK_IS_CONTAINER (widget))
1919         gtk_container_foreach (GTK_CONTAINER (widget),
1920                                gtk_widget_reparent_container_child,
1921                                client_data);
1922     }
1923   else
1924     gdk_window_reparent (widget->window,
1925                          (GdkWindow*) client_data, 0, 0);
1926 }
1927
1928 /*****************************************
1929  * gtk_widget_reparent:
1930  *
1931  *   arguments:
1932  *
1933  *   results:
1934  *****************************************/
1935
1936 void
1937 gtk_widget_reparent (GtkWidget *widget,
1938                      GtkWidget *new_parent)
1939 {
1940   g_return_if_fail (widget != NULL);
1941   g_return_if_fail (GTK_IS_WIDGET (widget));
1942   g_return_if_fail (new_parent != NULL);
1943   g_return_if_fail (GTK_IS_CONTAINER (new_parent));
1944   g_return_if_fail (widget->parent != NULL);
1945
1946   if (widget->parent != new_parent)
1947     {
1948       /* First try to see if we can get away without unrealizing
1949        * the widget as we reparent it. if so we set a flag so
1950        * that gtk_widget_unparent doesn't unrealize widget
1951        */
1952       if (GTK_WIDGET_REALIZED (widget) && GTK_WIDGET_REALIZED (new_parent))
1953         GTK_PRIVATE_SET_FLAG (widget, GTK_IN_REPARENT);
1954
1955       gtk_widget_ref (widget);
1956       gtk_container_remove (GTK_CONTAINER (widget->parent), widget);
1957       gtk_container_add (GTK_CONTAINER (new_parent), widget);
1958       gtk_widget_unref (widget);
1959
1960       if (GTK_WIDGET_IN_REPARENT (widget))
1961         {
1962           GTK_PRIVATE_UNSET_FLAG (widget, GTK_IN_REPARENT);
1963
1964           /* OK, now fix up the widget's window. (And that for any
1965            * children, if the widget is NO_WINDOW and a container)
1966            */
1967           if (GTK_WIDGET_NO_WINDOW (widget))
1968             {
1969               if (GTK_IS_CONTAINER (widget))
1970                 gtk_container_foreach (GTK_CONTAINER (widget),
1971                                        gtk_widget_reparent_container_child,
1972                                        gtk_widget_get_parent_window (widget));
1973               else
1974                 {
1975                   GdkWindow *parent_window;
1976
1977                   parent_window = gtk_widget_get_parent_window (widget);
1978                   if (parent_window != widget->window)
1979                     {
1980                       if (widget->window)
1981                         gdk_window_unref (widget->window);
1982                       widget->window = parent_window;
1983                       if (widget->window)
1984                         gdk_window_ref (widget->window);
1985                     }
1986                 }
1987             }
1988           else
1989             gdk_window_reparent (widget->window, gtk_widget_get_parent_window (widget), 0, 0);
1990         }
1991     }
1992 }
1993
1994 /*****************************************
1995  * gtk_widget_popup:
1996  *
1997  *   arguments:
1998  *
1999  *   results:
2000  *****************************************/
2001
2002 void
2003 gtk_widget_popup (GtkWidget *widget,
2004                   gint       x,
2005                   gint       y)
2006 {
2007   g_return_if_fail (widget != NULL);
2008
2009   if (!GTK_WIDGET_VISIBLE (widget))
2010     {
2011       if (!GTK_WIDGET_REALIZED (widget))
2012         gtk_widget_realize (widget);
2013       if (!GTK_WIDGET_NO_WINDOW (widget))
2014         gdk_window_move (widget->window, x, y);
2015       gtk_widget_show (widget);
2016     }
2017 }
2018
2019 /*****************************************
2020  * gtk_widget_intersect:
2021  *
2022  *   arguments:
2023  *
2024  *   results:
2025  *****************************************/
2026
2027 gint
2028 gtk_widget_intersect (GtkWidget    *widget,
2029                       GdkRectangle *area,
2030                       GdkRectangle *intersection)
2031 {
2032   GdkRectangle *dest;
2033   GdkRectangle tmp;
2034   gint return_val;
2035
2036   g_return_val_if_fail (widget != NULL, FALSE);
2037   g_return_val_if_fail (area != NULL, FALSE);
2038
2039   if (intersection)
2040     dest = intersection;
2041   else
2042     dest = &tmp;
2043
2044   return_val = gdk_rectangle_intersect ((GdkRectangle*) &widget->allocation, area, dest);
2045
2046   if (return_val && intersection && !GTK_WIDGET_NO_WINDOW (widget))
2047     {
2048       intersection->x -= widget->allocation.x;
2049       intersection->y -= widget->allocation.y;
2050     }
2051
2052   return return_val;
2053 }
2054
2055
2056 gint
2057 gtk_widget_basic (GtkWidget *widget)
2058 {
2059   GList *children;
2060   GList *tmp_list;
2061   gint return_val;
2062
2063   g_return_val_if_fail (widget != NULL, FALSE);
2064
2065   if (!GTK_WIDGET_BASIC (widget))
2066     return FALSE;
2067   else if (GTK_IS_CONTAINER (widget))
2068     {
2069       children = gtk_container_children (GTK_CONTAINER (widget));
2070       if (children)
2071         {
2072           return_val = TRUE;
2073           tmp_list = children;
2074
2075           while (tmp_list)
2076             {
2077               if (!gtk_widget_basic (GTK_WIDGET (tmp_list->data)))
2078                 {
2079                   return_val = FALSE;
2080                   break;
2081                 }
2082
2083               tmp_list = tmp_list->next;
2084             }
2085
2086           g_list_free (children);
2087           return return_val;
2088         }
2089     }
2090
2091   return TRUE;
2092 }
2093
2094
2095 /*****************************************
2096  * gtk_widget_grab_focus:
2097  *
2098  *   arguments:
2099  *
2100  *   results:
2101  *****************************************/
2102
2103 void
2104 gtk_widget_grab_focus (GtkWidget *widget)
2105 {
2106   GtkWidget *window;
2107   GtkWidget *child;
2108   gint window_type;
2109
2110   g_return_if_fail (widget != NULL);
2111
2112   window_type = gtk_window_get_type ();
2113   window = widget->parent;
2114   child = widget;
2115
2116   while (window && !gtk_type_is_a (GTK_WIDGET_TYPE (window), window_type))
2117     {
2118       GTK_CONTAINER (window)->focus_child = child;
2119       child = window;
2120       window = window->parent;
2121     }
2122
2123   if (window && gtk_type_is_a (GTK_WIDGET_TYPE (window), window_type))
2124     {
2125       GTK_CONTAINER (window)->focus_child = child;
2126       gtk_window_set_focus (GTK_WINDOW (window), widget);
2127     }
2128 }
2129
2130 /*****************************************
2131  * gtk_widget_grab_default:
2132  *
2133  *   arguments:
2134  *
2135  *   results:
2136  *****************************************/
2137
2138 void
2139 gtk_widget_grab_default (GtkWidget *widget)
2140 {
2141   GtkWidget *window;
2142   gint window_type;
2143
2144   g_return_if_fail (widget != NULL);
2145   g_return_if_fail (GTK_WIDGET_CAN_DEFAULT (widget));
2146
2147   window_type = gtk_window_get_type ();
2148   window = widget->parent;
2149
2150   while (window && !gtk_type_is_a (GTK_WIDGET_TYPE (window), window_type))
2151     window = window->parent;
2152
2153   if (window && gtk_type_is_a (GTK_WIDGET_TYPE (window), window_type))
2154     gtk_window_set_default (GTK_WINDOW (window), widget);
2155 }
2156
2157 /*****************************************
2158  * gtk_widget_set_name:
2159  *
2160  *   arguments:
2161  *
2162  *   results:
2163  *****************************************/
2164
2165 void
2166 gtk_widget_set_name (GtkWidget   *widget,
2167                      const gchar *name)
2168 {
2169   g_return_if_fail (widget != NULL);
2170
2171   if (widget->name)
2172     g_free (widget->name);
2173   widget->name = g_strdup (name);
2174
2175   if (!GTK_WIDGET_USER_STYLE (widget))
2176     gtk_widget_set_rc_style (widget);
2177 }
2178
2179 /*****************************************
2180  * gtk_widget_get_name:
2181  *
2182  *   arguments:
2183  *
2184  *   results:
2185  *****************************************/
2186
2187 gchar*
2188 gtk_widget_get_name (GtkWidget *widget)
2189 {
2190   g_return_val_if_fail (widget != NULL, NULL);
2191
2192   if (widget->name)
2193     return widget->name;
2194   return gtk_type_name (GTK_WIDGET_TYPE (widget));
2195 }
2196
2197 /*****************************************
2198  * gtk_widget_set_state:
2199  *
2200  *   arguments:
2201  *     widget
2202  *     state
2203  *
2204  *   results:
2205  *****************************************/
2206
2207 void
2208 gtk_widget_set_state (GtkWidget           *widget,
2209                       GtkStateType         state)
2210 {
2211   g_return_if_fail (widget != NULL);
2212
2213   if (state == GTK_WIDGET_STATE (widget))
2214     return;
2215
2216   if (state == GTK_STATE_INSENSITIVE)
2217     gtk_widget_set_sensitive (widget, FALSE);
2218   else
2219     {
2220       GtkStateData data;
2221       GtkStateType old_state;
2222
2223       data.state = state;
2224       if (widget->parent)
2225         data.parent_sensitive = GTK_WIDGET_IS_SENSITIVE (widget->parent);
2226       else
2227         data.parent_sensitive = GTK_PARENT_SENSITIVE;
2228
2229       old_state = GTK_WIDGET_STATE (widget);
2230
2231       gtk_widget_propagate_state (widget, &data);
2232       if (old_state != GTK_WIDGET_STATE (widget))
2233         gtk_widget_queue_draw (widget);
2234     }
2235 }
2236
2237 /*****************************************
2238  * gtk_widget_set_sensitive:
2239  *
2240  *   arguments:
2241  *     widget
2242  *     boolean value for sensitivity
2243  *
2244  *   results:
2245  *****************************************/
2246
2247 void
2248 gtk_widget_set_sensitive (GtkWidget *widget,
2249                           gint       sensitive)
2250 {
2251   GtkStateData data;
2252   GtkStateType old_state;
2253
2254   g_return_if_fail (widget != NULL);
2255
2256   if (sensitive)
2257     {
2258       GTK_WIDGET_SET_FLAGS (widget, GTK_SENSITIVE);
2259       if (GTK_WIDGET_STATE (widget) == GTK_STATE_INSENSITIVE)
2260         data.state = GTK_WIDGET_SAVED_STATE (widget);
2261       else
2262         data.state = GTK_WIDGET_STATE (widget);
2263     }
2264   else
2265     {
2266       GTK_WIDGET_UNSET_FLAGS (widget, GTK_SENSITIVE);
2267       data.state = GTK_WIDGET_STATE (widget);
2268     }
2269
2270   if (widget->parent)
2271     data.parent_sensitive = GTK_WIDGET_IS_SENSITIVE (widget->parent);
2272   else
2273     data.parent_sensitive = GTK_PARENT_SENSITIVE;
2274
2275   old_state = GTK_WIDGET_STATE (widget);
2276   gtk_widget_propagate_state (widget, &data);
2277   if (old_state != GTK_WIDGET_STATE (widget))
2278     gtk_widget_queue_draw (widget);
2279 }
2280
2281 /*****************************************
2282  * gtk_widget_set_parent:
2283  *
2284  *   arguments:
2285  *
2286  *   results:
2287  *****************************************/
2288
2289 void
2290 gtk_widget_set_parent (GtkWidget *widget,
2291                        GtkWidget *parent)
2292 {
2293   GtkStateData data;
2294
2295   g_return_if_fail (widget != NULL);
2296   g_return_if_fail (widget->parent == NULL);
2297   g_return_if_fail (!GTK_WIDGET_TOPLEVEL (widget));
2298   g_return_if_fail (parent != NULL);
2299
2300   /* keep this function in sync with gtk_menu_attach_to_widget()
2301    */
2302
2303   gtk_widget_ref (widget);
2304   gtk_object_sink (GTK_OBJECT (widget));
2305   widget->parent = parent;
2306
2307   if (GTK_WIDGET_STATE (parent) != GTK_STATE_NORMAL)
2308     data.state = GTK_WIDGET_STATE (parent);
2309   else
2310     data.state = GTK_WIDGET_STATE (widget);
2311   data.parent_sensitive = GTK_WIDGET_IS_SENSITIVE (parent);
2312
2313   gtk_widget_propagate_state (widget, &data);
2314
2315   while (parent->parent != NULL)
2316     parent = parent->parent;
2317
2318   if (GTK_WIDGET_TOPLEVEL (parent))
2319     {
2320       gtk_widget_ensure_style (widget);
2321
2322       if (GTK_IS_CONTAINER (widget))
2323         gtk_container_foreach (GTK_CONTAINER (widget),
2324                                gtk_widget_set_style_recurse,
2325                                NULL);
2326     }
2327
2328   gtk_signal_emit (GTK_OBJECT (widget), widget_signals[PARENT_SET], NULL);
2329 }
2330
2331 /*****************************************
2332  * Widget styles
2333  * see docs/styles.txt
2334  *****************************************/
2335 void
2336 gtk_widget_set_style (GtkWidget *widget,
2337                       GtkStyle  *style)
2338 {
2339   GtkStyle *default_style;
2340
2341   g_return_if_fail (widget != NULL);
2342   g_return_if_fail (style != NULL);
2343
2344   GTK_WIDGET_UNSET_FLAGS (widget, GTK_RC_STYLE);
2345   GTK_PRIVATE_SET_FLAG (widget, GTK_USER_STYLE);
2346
2347   default_style = gtk_object_get_data (GTK_OBJECT (widget), saved_default_style);
2348   if (!default_style)
2349     {
2350       gtk_style_ref (widget->style);
2351       gtk_object_set_data (GTK_OBJECT (widget), saved_default_style, widget->style);
2352     }
2353
2354   gtk_widget_set_style_internal (widget, style);
2355 }
2356
2357 void
2358 gtk_widget_ensure_style (GtkWidget *widget)
2359 {
2360   if (!GTK_WIDGET_USER_STYLE (widget) &&
2361       !GTK_WIDGET_RC_STYLE (widget))
2362     gtk_widget_set_rc_style (widget);
2363 }
2364
2365 void
2366 gtk_widget_set_rc_style (GtkWidget *widget)
2367 {
2368   GtkStyle *saved_style;
2369   GtkStyle *new_style;
2370
2371   g_return_if_fail (widget != NULL);
2372
2373   GTK_PRIVATE_UNSET_FLAG (widget, GTK_USER_STYLE);
2374   GTK_WIDGET_SET_FLAGS (widget, GTK_RC_STYLE);
2375
2376   saved_style = gtk_object_get_data (GTK_OBJECT (widget), saved_default_style);
2377   new_style = gtk_rc_get_style (widget);
2378   if (new_style)
2379     {
2380       if (!saved_style)
2381         {
2382           gtk_style_ref (widget->style);
2383           gtk_object_set_data (GTK_OBJECT (widget), saved_default_style, widget->style);
2384         }
2385       gtk_widget_set_style_internal (widget, new_style);
2386     }
2387   else
2388     {
2389       if (saved_style)
2390         {
2391           gtk_object_remove_data (GTK_OBJECT (widget), saved_default_style);
2392           gtk_widget_set_style_internal (widget, saved_style);
2393           gtk_style_unref (saved_style);
2394         }
2395     }
2396 }
2397
2398 GtkStyle*
2399 gtk_widget_get_style (GtkWidget *widget)
2400 {
2401   g_return_val_if_fail (widget != NULL, NULL);
2402
2403   return widget->style;
2404 }
2405
2406 static void
2407 gtk_widget_style_set (GtkWidget *widget,
2408                       GtkStyle  *previous_style)
2409 {
2410   if (GTK_WIDGET_REALIZED (widget) &&
2411       !GTK_WIDGET_NO_WINDOW (widget))
2412     gtk_style_set_background (widget->style, widget->window, widget->state);
2413 }
2414
2415 static void
2416 gtk_widget_set_style_internal (GtkWidget *widget,
2417                                GtkStyle  *style)
2418 {
2419   g_return_if_fail (widget != NULL);
2420   g_return_if_fail (style != NULL);
2421
2422   if (widget->style != style)
2423     {
2424       GtkStyle *previous_style;
2425
2426       if (GTK_WIDGET_REALIZED (widget))
2427         gtk_style_detach (widget->style);
2428
2429       previous_style = widget->style;
2430       widget->style = style;
2431       gtk_style_ref (widget->style);
2432
2433       if (GTK_WIDGET_REALIZED (widget))
2434         widget->style = gtk_style_attach (widget->style, widget->window);
2435
2436       gtk_signal_emit (GTK_OBJECT (widget), widget_signals[STYLE_SET], previous_style);
2437       gtk_style_unref (previous_style);
2438
2439       if (widget->parent)
2440         {
2441           GtkRequisition old_requisition;
2442
2443           old_requisition = widget->requisition;
2444           gtk_widget_size_request (widget, &widget->requisition);
2445
2446           if ((old_requisition.width != widget->requisition.width) ||
2447               (old_requisition.height != widget->requisition.height))
2448             gtk_widget_queue_resize (widget);
2449           else if (GTK_WIDGET_DRAWABLE (widget))
2450             gtk_widget_queue_draw (widget);
2451         }
2452     }
2453 }
2454
2455 static void
2456 gtk_widget_set_style_recurse (GtkWidget *widget,
2457                               gpointer   client_data)
2458 {
2459   if (!GTK_WIDGET_USER_STYLE (widget))
2460     gtk_widget_set_rc_style (widget);
2461
2462   if (GTK_IS_CONTAINER (widget))
2463     gtk_container_foreach (GTK_CONTAINER (widget),
2464                            gtk_widget_set_style_recurse,
2465                            NULL);
2466 }
2467
2468 void
2469 gtk_widget_set_default_style (GtkStyle *style)
2470 {
2471    if (style != default_style)
2472      {
2473        if (default_style)
2474          gtk_style_unref (default_style);
2475        default_style = style;
2476        if (default_style)
2477          gtk_style_ref (default_style);
2478      }
2479 }
2480
2481 GtkStyle*
2482 gtk_widget_get_default_style ()
2483 {
2484   if (!default_style)
2485     {
2486       default_style = gtk_style_new ();
2487       gtk_style_ref (default_style);
2488     }
2489
2490   return default_style;
2491 }
2492
2493 void
2494 gtk_widget_push_style (GtkStyle *style)
2495 {
2496   g_return_if_fail (style != NULL);
2497
2498   gtk_style_ref (style);
2499   style_stack = g_slist_prepend (style_stack, style);
2500 }
2501
2502 static GtkStyle*
2503 gtk_widget_peek_style ()
2504 {
2505   if (style_stack)
2506     return (GtkStyle*) style_stack->data;
2507   else
2508     return gtk_widget_get_default_style ();
2509 }
2510
2511 void
2512 gtk_widget_pop_style ()
2513 {
2514   GSList *tmp;
2515
2516   if (style_stack)
2517     {
2518       tmp = style_stack;
2519       style_stack = style_stack->next;
2520       gtk_style_unref ((GtkStyle*) tmp->data);
2521       g_slist_free_1 (tmp);
2522     }
2523 }
2524
2525 /* Basically, send a message to all toplevel windows telling them
2526  * that a new _GTK_STYLE_COLORS property is available on the root
2527  * window
2528  */
2529 void
2530 gtk_widget_propagate_default_style (void)
2531 {
2532   GdkEventClient sev;
2533   int i;
2534
2535   /* Set the property on the root window */
2536   gdk_property_change(GDK_ROOT_PARENT(),
2537                       gdk_atom_intern("_GTK_DEFAULT_COLORS", FALSE),
2538                       gdk_atom_intern("STRING", FALSE),
2539                       8*sizeof(gushort),
2540                       GDK_PROP_MODE_REPLACE,
2541                       (guchar *)gtk_widget_get_default_style(),
2542                       GTK_STYLE_NUM_STYLECOLORS() * sizeof(GdkColor));
2543
2544   for(i = 0; i < 5; i++)
2545     sev.data.l[i] = 0;
2546   sev.data_format = 32;
2547   sev.message_type = gdk_atom_intern ("_GTK_STYLE_CHANGED", FALSE);
2548   gdk_event_send_clientmessage_toall ((GdkEvent *) &sev);
2549 }
2550
2551 /*************************************************************
2552  * gtk_widget_set_parent_window:
2553  *     Set a non default parent window for widget
2554  *
2555  *   arguments:
2556  *     widget:
2557  *     parent_window
2558  *
2559  *   results:
2560  *************************************************************/
2561
2562 void
2563 gtk_widget_set_parent_window   (GtkWidget           *widget,
2564                                 GdkWindow           *parent_window)
2565 {
2566   GdkWindow *old_parent_window;
2567
2568   g_return_if_fail (widget != NULL);
2569
2570   old_parent_window = gtk_object_get_data (GTK_OBJECT (widget),
2571                                            parent_window_key);
2572
2573   if (parent_window != old_parent_window)
2574     {
2575       gtk_object_set_data (GTK_OBJECT (widget), parent_window_key,
2576                            parent_window);
2577       if (old_parent_window)
2578         gdk_window_unref (old_parent_window);
2579       if (parent_window)
2580         gdk_window_ref (parent_window);
2581     }
2582 }
2583
2584 /*************************************************************
2585  * gtk_widget_get_parent_window:
2586  *     Get widget's parent window
2587  *
2588  *   arguments:
2589  *     widget:
2590  *
2591  *   results:
2592  *     parent window
2593  *************************************************************/
2594
2595 GdkWindow *
2596 gtk_widget_get_parent_window   (GtkWidget           *widget)
2597 {
2598   GdkWindow *parent_window;
2599
2600   g_return_val_if_fail (widget != NULL, NULL);
2601   g_return_val_if_fail (GTK_IS_WIDGET (widget), NULL);
2602   g_return_val_if_fail (widget->parent != NULL, NULL);
2603
2604   parent_window = gtk_object_get_data (GTK_OBJECT (widget),
2605                                        parent_window_key);
2606
2607   return (parent_window != NULL) ? parent_window : widget->parent->window;
2608 }
2609
2610 /*****************************************
2611  * gtk_widget_set_uposition:
2612  *
2613  *   arguments:
2614  *
2615  *   results:
2616  *****************************************/
2617
2618 void
2619 gtk_widget_set_uposition (GtkWidget *widget,
2620                           gint       x,
2621                           gint       y)
2622 {
2623   GtkWidgetAuxInfo *aux_info;
2624
2625   g_return_if_fail (widget != NULL);
2626
2627   aux_info = gtk_object_get_data (GTK_OBJECT (widget), aux_info_key);
2628   if (!aux_info)
2629     {
2630       aux_info = gtk_widget_aux_info_new ();
2631       gtk_object_set_data (GTK_OBJECT (widget), aux_info_key, aux_info);
2632     }
2633
2634   if (x > -2)
2635     aux_info->x = x;
2636   if (y > -2)
2637     aux_info->y = y;
2638
2639   if (GTK_WIDGET_REALIZED (widget) && GTK_IS_WINDOW (widget) &&
2640       (aux_info->x != -1) && (aux_info->y != -1))
2641     {
2642       gdk_window_set_hints (widget->window, aux_info->x, aux_info->y, 0, 0, 0, 0, GDK_HINT_POS);
2643       gdk_window_move (widget->window, aux_info->x, aux_info->y);
2644     }
2645
2646   if (GTK_WIDGET_VISIBLE (widget) && widget->parent)
2647     gtk_widget_size_allocate (widget, &widget->allocation);
2648 }
2649
2650 /*****************************************
2651  * gtk_widget_set_usize:
2652  *
2653  *   arguments:
2654  *
2655  *   results:
2656  *****************************************/
2657
2658 void
2659 gtk_widget_set_usize (GtkWidget *widget,
2660                       gint       width,
2661                       gint       height)
2662 {
2663   GtkWidgetAuxInfo *aux_info;
2664
2665   g_return_if_fail (widget != NULL);
2666
2667   aux_info = gtk_object_get_data (GTK_OBJECT (widget), aux_info_key);
2668   if (!aux_info)
2669     {
2670       aux_info = gtk_widget_aux_info_new ();
2671       gtk_object_set_data (GTK_OBJECT (widget), aux_info_key, aux_info);
2672     }
2673
2674   if (width > -1)
2675     aux_info->width = width;
2676   if (height > -1)
2677     aux_info->height = height;
2678
2679   if (GTK_WIDGET_VISIBLE (widget))
2680     gtk_widget_queue_resize (widget);
2681 }
2682
2683 /*****************************************
2684  * gtk_widget_set_events:
2685  *
2686  *   arguments:
2687  *
2688  *   results:
2689  *****************************************/
2690
2691 void
2692 gtk_widget_set_events (GtkWidget *widget,
2693                        gint       events)
2694 {
2695   gint *eventp;
2696
2697   g_return_if_fail (widget != NULL);
2698   g_return_if_fail (!GTK_WIDGET_NO_WINDOW (widget));
2699   g_return_if_fail (!GTK_WIDGET_REALIZED (widget));
2700
2701   eventp = gtk_object_get_data (GTK_OBJECT (widget), event_key);
2702
2703   if (events)
2704     {
2705       if (!eventp)
2706         eventp = g_new (gint, 1);
2707
2708       *eventp = events;
2709       gtk_object_set_data (GTK_OBJECT (widget), event_key, eventp);
2710     }
2711   else
2712     {
2713       if (eventp)
2714         g_free (eventp);
2715
2716       gtk_object_remove_data (GTK_OBJECT (widget), event_key);
2717     }
2718 }
2719
2720 /*****************************************
2721  * gtk_widget_set_extension_events:
2722  *
2723  *   arguments:
2724  *
2725  *   results:
2726  *****************************************/
2727
2728 void
2729 gtk_widget_set_extension_events (GtkWidget *widget,
2730                                  GdkExtensionMode mode)
2731 {
2732   GdkExtensionMode *modep;
2733
2734   g_return_if_fail (widget != NULL);
2735
2736   modep = gtk_object_get_data (GTK_OBJECT (widget), extension_event_key);
2737
2738   if (!modep)
2739     modep = g_new (GdkExtensionMode, 1);
2740
2741   *modep = mode;
2742   gtk_object_set_data (GTK_OBJECT (widget), extension_event_key, modep);
2743 }
2744
2745
2746 /*****************************************
2747  * gtk_widget_get_toplevel:
2748  *
2749  *   arguments:
2750  *
2751  *   results:
2752  *****************************************/
2753
2754 GtkWidget*
2755 gtk_widget_get_toplevel (GtkWidget *widget)
2756 {
2757   g_return_val_if_fail (widget != NULL, NULL);
2758
2759   while (widget->parent)
2760     widget = widget->parent;
2761
2762   return widget;
2763 }
2764
2765 /*****************************************
2766  * gtk_widget_get_ancestor:
2767  *
2768  *   arguments:
2769  *
2770  *   results:
2771  *****************************************/
2772
2773 GtkWidget*
2774 gtk_widget_get_ancestor (GtkWidget *widget,
2775                          gint       type)
2776 {
2777   g_return_val_if_fail (widget != NULL, NULL);
2778
2779   while (widget && !gtk_type_is_a (GTK_WIDGET_TYPE (widget), type))
2780     widget = widget->parent;
2781
2782   if (!(widget && gtk_type_is_a (GTK_WIDGET_TYPE (widget), type)))
2783     return NULL;
2784
2785   return widget;
2786 }
2787
2788 /*****************************************
2789  * gtk_widget_get_colormap:
2790  *
2791  *   arguments:
2792  *
2793  *   results:
2794  *****************************************/
2795
2796 GdkColormap*
2797 gtk_widget_get_colormap (GtkWidget *widget)
2798 {
2799   GdkColormap *colormap;
2800
2801   g_return_val_if_fail (widget != NULL, NULL);
2802
2803   if (!widget->window)
2804     {
2805       colormap = gtk_object_get_data (GTK_OBJECT (widget), colormap_key);
2806       if (colormap)
2807         return colormap;
2808       return gtk_widget_get_default_colormap ();
2809     }
2810
2811   return gdk_window_get_colormap (widget->window);
2812 }
2813
2814 /*****************************************
2815  * gtk_widget_get_visual:
2816  *
2817  *   arguments:
2818  *
2819  *   results:
2820  *****************************************/
2821
2822 GdkVisual*
2823 gtk_widget_get_visual (GtkWidget *widget)
2824 {
2825   GdkVisual *visual;
2826
2827   g_return_val_if_fail (widget != NULL, NULL);
2828
2829   if (!widget->window)
2830     {
2831       visual = gtk_object_get_data (GTK_OBJECT (widget), visual_key);
2832       if (visual)
2833         return visual;
2834       return gtk_widget_get_default_visual ();
2835     }
2836
2837   return gdk_window_get_visual (widget->window);
2838 }
2839
2840 /*****************************************
2841  * gtk_widget_get_events:
2842  *
2843  *   arguments:
2844  *
2845  *   results:
2846  *****************************************/
2847
2848 gint
2849 gtk_widget_get_events (GtkWidget *widget)
2850 {
2851   gint *events;
2852
2853   g_return_val_if_fail (widget != NULL, 0);
2854
2855   events = gtk_object_get_data (GTK_OBJECT (widget), event_key);
2856   if (events)
2857     return *events;
2858
2859   return 0;
2860 }
2861
2862 /*****************************************
2863  * gtk_widget_get_extension_events:
2864  *
2865  *   arguments:
2866  *
2867  *   results:
2868  *****************************************/
2869
2870 GdkExtensionMode
2871 gtk_widget_get_extension_events (GtkWidget *widget)
2872 {
2873   GdkExtensionMode *mode;
2874
2875   g_return_val_if_fail (widget != NULL, 0);
2876
2877   mode = gtk_object_get_data (GTK_OBJECT (widget), extension_event_key);
2878   if (mode)
2879     return *mode;
2880
2881   return 0;
2882 }
2883
2884 /*****************************************
2885  * gtk_widget_get_pointer:
2886  *
2887  *   arguments:
2888  *
2889  *   results:
2890  *****************************************/
2891
2892 void
2893 gtk_widget_get_pointer (GtkWidget *widget,
2894                         gint      *x,
2895                         gint      *y)
2896 {
2897   g_return_if_fail (widget != NULL);
2898
2899   if (x)
2900     *x = -1;
2901   if (y)
2902     *y = -1;
2903
2904   if (GTK_WIDGET_REALIZED (widget))
2905     {
2906       gdk_window_get_pointer (widget->window, x, y, NULL);
2907
2908       if (GTK_WIDGET_NO_WINDOW (widget))
2909         {
2910           if (x)
2911             *x -= widget->allocation.x;
2912           if (y)
2913             *y -= widget->allocation.y;
2914         }
2915     }
2916 }
2917
2918 /*****************************************
2919  * gtk_widget_is_ancestor:
2920  *
2921  *   arguments:
2922  *
2923  *   results:
2924  *****************************************/
2925
2926 gint
2927 gtk_widget_is_ancestor (GtkWidget *widget,
2928                         GtkWidget *ancestor)
2929 {
2930   g_return_val_if_fail (widget != NULL, FALSE);
2931   g_return_val_if_fail (ancestor != NULL, FALSE);
2932
2933   while (widget)
2934     {
2935       if (widget->parent == ancestor)
2936         return TRUE;
2937       widget = widget->parent;
2938     }
2939
2940   return FALSE;
2941 }
2942
2943 /*****************************************
2944  * gtk_widget_is_child:
2945  *
2946  *   arguments:
2947  *
2948  *   results:
2949  *****************************************/
2950
2951 gint
2952 gtk_widget_is_child (GtkWidget *widget,
2953                      GtkWidget *child)
2954 {
2955   g_return_val_if_fail (widget != NULL, FALSE);
2956   g_return_val_if_fail (child != NULL, FALSE);
2957
2958   return (child->parent == widget);
2959 }
2960
2961 /*****************************************
2962  * gtk_widget_push_colormap:
2963  *
2964  *   arguments:
2965  *
2966  *   results:
2967  *****************************************/
2968
2969 void
2970 gtk_widget_push_colormap (GdkColormap *cmap)
2971 {
2972   g_return_if_fail (cmap != NULL);
2973
2974   colormap_stack = g_slist_prepend (colormap_stack, cmap);
2975 }
2976
2977 /*****************************************
2978  * gtk_widget_push_visual:
2979  *
2980  *   arguments:
2981  *
2982  *   results:
2983  *****************************************/
2984
2985 void
2986 gtk_widget_push_visual (GdkVisual *visual)
2987 {
2988   g_return_if_fail (visual != NULL);
2989
2990   visual_stack = g_slist_prepend (visual_stack, visual);
2991 }
2992
2993 /*****************************************
2994  * gtk_widget_pop_colormap:
2995  *
2996  *   arguments:
2997  *
2998  *   results:
2999  *****************************************/
3000
3001 void
3002 gtk_widget_pop_colormap ()
3003 {
3004   GSList *tmp;
3005
3006   if (colormap_stack)
3007     {
3008       tmp = colormap_stack;
3009       colormap_stack = colormap_stack->next;
3010       g_slist_free_1 (tmp);
3011     }
3012 }
3013
3014 /*****************************************
3015  * gtk_widget_pop_visual:
3016  *
3017  *   arguments:
3018  *
3019  *   results:
3020  *****************************************/
3021
3022 void
3023 gtk_widget_pop_visual ()
3024 {
3025   GSList *tmp;
3026
3027   if (visual_stack)
3028     {
3029       tmp = visual_stack;
3030       visual_stack = visual_stack->next;
3031       g_slist_free_1 (tmp);
3032     }
3033 }
3034
3035 /*****************************************
3036  * gtk_widget_set_default_colormap:
3037  *
3038  *   arguments:
3039  *
3040  *   results:
3041  *****************************************/
3042
3043 void
3044 gtk_widget_set_default_colormap (GdkColormap *colormap)
3045 {
3046   if (default_colormap != colormap)
3047     {
3048       if (default_colormap)
3049         gdk_colormap_unref (default_colormap);
3050       default_colormap = colormap;
3051       if (default_colormap)
3052         gdk_colormap_ref (default_colormap);
3053     }
3054 }
3055
3056 /*****************************************
3057  * gtk_widget_set_default_visual:
3058  *
3059  *   arguments:
3060  *
3061  *   results:
3062  *****************************************/
3063
3064 void
3065 gtk_widget_set_default_visual (GdkVisual *visual)
3066 {
3067   default_visual = visual;
3068 }
3069
3070 /*****************************************
3071  * gtk_widget_get_default_colormap:
3072  *
3073  *   arguments:
3074  *
3075  *   results:
3076  *****************************************/
3077
3078 GdkColormap*
3079 gtk_widget_get_default_colormap ()
3080 {
3081   if (!default_colormap)
3082     default_colormap = gdk_colormap_get_system ();
3083
3084   return default_colormap;
3085 }
3086
3087 /*****************************************
3088  * gtk_widget_get_default_visual:
3089  *
3090  *   arguments:
3091  *
3092  *   results:
3093  *****************************************/
3094
3095 GdkVisual*
3096 gtk_widget_get_default_visual ()
3097 {
3098   if (!default_visual)
3099     default_visual = gdk_visual_get_system ();
3100
3101   return default_visual;
3102 }
3103
3104 /*****************************************
3105  * gtk_widget_marshal_signal_1:
3106  *
3107  *   arguments:
3108  *
3109  *   results:
3110  *****************************************/
3111
3112 static void
3113 gtk_widget_marshal_signal_1 (GtkObject      *object,
3114                              GtkSignalFunc   func,
3115                              gpointer        func_data,
3116                              GtkArg         *args)
3117 {
3118   GtkWidgetSignal1 rfunc;
3119
3120   rfunc = (GtkWidgetSignal1) func;
3121
3122   (* rfunc) (object,
3123              GTK_VALUE_POINTER (args[0]),
3124              func_data);
3125 }
3126
3127 /*****************************************
3128  * gtk_widget_marshal_signal_2:
3129  *
3130  *   arguments:
3131  *
3132  *   results:
3133  *****************************************/
3134
3135 static void
3136 gtk_widget_marshal_signal_2 (GtkObject      *object,
3137                              GtkSignalFunc   func,
3138                              gpointer        func_data,
3139                              GtkArg         *args)
3140 {
3141   GtkWidgetSignal2 rfunc;
3142   gint *return_val;
3143
3144   rfunc = (GtkWidgetSignal2) func;
3145   return_val = GTK_RETLOC_BOOL (args[3]);
3146
3147   *return_val = (* rfunc) (object,
3148                            GTK_VALUE_STRING (args[0]),
3149                            GTK_VALUE_CHAR (args[1]),
3150                            GTK_VALUE_INT (args[2]),
3151                            func_data);
3152 }
3153
3154 /*****************************************
3155  * gtk_widget_marshal_signal_3:
3156  *
3157  *   arguments:
3158  *
3159  *   results:
3160  *****************************************/
3161
3162 static void
3163 gtk_widget_marshal_signal_3 (GtkObject      *object,
3164                              GtkSignalFunc   func,
3165                              gpointer        func_data,
3166                              GtkArg         *args)
3167 {
3168   GtkWidgetSignal3 rfunc;
3169
3170   rfunc = (GtkWidgetSignal3) func;
3171
3172   (* rfunc) (object,
3173              GTK_VALUE_STRING (args[0]),
3174              func_data);
3175 }
3176
3177 /*****************************************
3178  * gtk_widget_marshal_signal_4:
3179  *
3180  *   arguments:
3181  *
3182  *   results:
3183  *****************************************/
3184
3185 static void
3186 gtk_widget_marshal_signal_4 (GtkObject      *object,
3187                              GtkSignalFunc   func,
3188                              gpointer        func_data,
3189                              GtkArg         *args)
3190 {
3191   GtkWidgetSignal4 rfunc;
3192   gint *return_val;
3193
3194   rfunc = (GtkWidgetSignal4) func;
3195   return_val = GTK_RETLOC_BOOL (args[1]);
3196
3197   *return_val = (* rfunc) (object,
3198                            GTK_VALUE_BOXED (args[0]),
3199                            func_data);
3200 }
3201
3202 /*****************************************
3203  * gtk_widget_marshal_signal_5:
3204  *
3205  *   arguments:
3206  *
3207  *   results:
3208  *****************************************/
3209
3210 static void
3211 gtk_widget_marshal_signal_5 (GtkObject      *object,
3212                              GtkSignalFunc   func,
3213                              gpointer        func_data,
3214                              GtkArg         *args)
3215 {
3216   GtkWidgetSignal5 rfunc;
3217
3218   rfunc = (GtkWidgetSignal5) func;
3219
3220   (* rfunc) (object,
3221              GTK_VALUE_UINT (args[0]),
3222              func_data);
3223 }
3224
3225 /*****************************************
3226  * gtk_widget_marshal_signal_6:
3227  *
3228  *   arguments:
3229  *
3230  *   results:
3231  *****************************************/
3232
3233 static void
3234 gtk_widget_marshal_signal_6 (GtkObject      *object,
3235                              GtkSignalFunc   func,
3236                              gpointer        func_data,
3237                              GtkArg         *args)
3238 {
3239   GtkWidgetSignal6 rfunc;
3240
3241   rfunc = (GtkWidgetSignal6) func;
3242
3243   (* rfunc) (object,
3244              GTK_VALUE_OBJECT (args[0]),
3245              func_data);
3246 }
3247
3248 /*****************************************
3249  * gtk_widget_marshal_signal_7:
3250  *
3251  *   arguments:
3252  *
3253  *   results:
3254  *****************************************/
3255
3256 static void
3257 gtk_widget_marshal_signal_7 (GtkObject      *object,
3258                              GtkSignalFunc   func,
3259                              gpointer        func_data,
3260                              GtkArg         *args)
3261 {
3262   GtkWidgetSignal7 rfunc;
3263
3264   rfunc = (GtkWidgetSignal7) func;
3265
3266   (* rfunc) (object,
3267              GTK_VALUE_BOXED (args[0]),
3268              func_data);
3269 }
3270
3271 static void
3272 gtk_widget_real_destroy (GtkObject *object)
3273 {
3274   GtkWidget *widget = GTK_WIDGET (object);
3275
3276   gtk_widget_ref (widget);
3277
3278   if (GTK_WIDGET_REDRAW_PENDING (widget))
3279     {
3280       gtk_widget_redraw_queue = g_slist_remove (gtk_widget_redraw_queue, widget);
3281       GTK_PRIVATE_UNSET_FLAG (widget, GTK_REDRAW_PENDING);
3282     }
3283
3284   if (GTK_CONTAINER_RESIZE_PENDING (widget))
3285     {
3286       gtk_widget_resize_queue = g_slist_remove (gtk_widget_resize_queue, widget);
3287       GTK_PRIVATE_UNSET_FLAG (widget, GTK_RESIZE_PENDING);
3288     }
3289
3290   if (GTK_WIDGET_HAS_SHAPE_MASK (widget))
3291     gtk_widget_shape_combine_mask (widget, NULL, -1, -1);
3292
3293   gtk_grab_remove (widget);
3294   gtk_selection_remove_all (widget);
3295
3296   if (widget->parent)
3297     gtk_container_remove (GTK_CONTAINER (widget->parent), widget);
3298
3299   gtk_style_unref (widget->style);
3300   widget->style = NULL;
3301
3302   parent_class->destroy (object);
3303
3304   gtk_widget_unref (widget);
3305 }
3306
3307 static void
3308 gtk_widget_real_finalize (GtkObject *object)
3309 {
3310   GtkWidget *widget;
3311   GtkWidgetAuxInfo *aux_info;
3312   gint *events;
3313   GdkExtensionMode *mode;
3314
3315   g_return_if_fail (object != NULL);
3316   g_return_if_fail (GTK_IS_WIDGET (object));
3317
3318   widget = GTK_WIDGET (object);
3319
3320   if (widget->name)
3321     {
3322       g_free (widget->name);
3323       widget->name = NULL;
3324     }
3325
3326   aux_info = gtk_object_get_data (GTK_OBJECT (widget), aux_info_key);
3327   if (aux_info)
3328     {
3329       gtk_widget_aux_info_destroy (aux_info);
3330       gtk_object_remove_data (GTK_OBJECT (widget), aux_info_key);
3331     }
3332
3333   events = gtk_object_get_data (GTK_OBJECT (widget), event_key);
3334   if (events)
3335     {
3336       g_free (events);
3337       gtk_object_remove_data (GTK_OBJECT (widget), event_key);
3338     }
3339
3340   mode = gtk_object_get_data (GTK_OBJECT (widget), extension_event_key);
3341   if (mode)
3342     {
3343       g_free (mode);
3344       gtk_object_remove_data (GTK_OBJECT (widget), extension_event_key);
3345     }
3346
3347   parent_class->finalize (object);
3348 }
3349
3350 /*****************************************
3351  * gtk_widget_real_show:
3352  *
3353  *   arguments:
3354  *
3355  *   results:
3356  *****************************************/
3357
3358 static void
3359 gtk_widget_real_show (GtkWidget *widget)
3360 {
3361   g_return_if_fail (widget != NULL);
3362   g_return_if_fail (GTK_IS_WIDGET (widget));
3363
3364   if (!GTK_WIDGET_VISIBLE (widget))
3365     {
3366       GTK_WIDGET_SET_FLAGS (widget, GTK_VISIBLE);
3367
3368       if (widget->parent)
3369         {
3370           gtk_widget_queue_resize (widget);
3371
3372           if (GTK_WIDGET_MAPPED (widget->parent))
3373             gtk_widget_map (widget);
3374         }
3375     }
3376 }
3377
3378 /*****************************************
3379  * gtk_widget_real_hide:
3380  *
3381  *   arguments:
3382  *
3383  *   results:
3384  *****************************************/
3385
3386 static void
3387 gtk_widget_real_hide (GtkWidget *widget)
3388 {
3389   g_return_if_fail (widget != NULL);
3390   g_return_if_fail (GTK_IS_WIDGET (widget));
3391
3392   if (GTK_WIDGET_VISIBLE (widget))
3393     {
3394       GTK_WIDGET_UNSET_FLAGS (widget, GTK_VISIBLE);
3395
3396       if (GTK_WIDGET_MAPPED (widget))
3397         gtk_widget_unmap (widget);
3398
3399       if (widget->parent)
3400         gtk_widget_queue_resize (widget);
3401     }
3402 }
3403
3404 /*****************************************
3405  * gtk_widget_real_map:
3406  *
3407  *   arguments:
3408  *
3409  *   results:
3410  *****************************************/
3411
3412 static void
3413 gtk_widget_real_map (GtkWidget *widget)
3414 {
3415   g_return_if_fail (widget != NULL);
3416   g_return_if_fail (GTK_IS_WIDGET (widget));
3417
3418   if (GTK_WIDGET_REALIZED (widget) && !GTK_WIDGET_MAPPED (widget))
3419     {
3420       GTK_WIDGET_SET_FLAGS (widget, GTK_MAPPED);
3421
3422       if (!GTK_WIDGET_NO_WINDOW (widget))
3423         gdk_window_show (widget->window);
3424       else
3425         gtk_widget_queue_draw (widget);
3426     }
3427 }
3428
3429 /*****************************************
3430  * gtk_widget_real_unmap:
3431  *
3432  *   arguments:
3433  *
3434  *   results:
3435  *****************************************/
3436
3437 static void
3438 gtk_widget_real_unmap (GtkWidget *widget)
3439 {
3440   g_return_if_fail (widget != NULL);
3441   g_return_if_fail (GTK_IS_WIDGET (widget));
3442
3443   if (GTK_WIDGET_MAPPED (widget))
3444     {
3445       GTK_WIDGET_UNSET_FLAGS (widget, GTK_MAPPED);
3446
3447       if (GTK_WIDGET_NO_WINDOW (widget))
3448         gdk_window_clear_area (widget->window,
3449                                widget->allocation.x,
3450                                widget->allocation.y,
3451                                widget->allocation.width,
3452                                widget->allocation.height);
3453       else
3454         gdk_window_hide (widget->window);
3455     }
3456 }
3457
3458 /*****************************************
3459  * gtk_widget_real_realize:
3460  *
3461  *   arguments:
3462  *
3463  *   results:
3464  *****************************************/
3465
3466 static void
3467 gtk_widget_real_realize (GtkWidget *widget)
3468 {
3469   g_return_if_fail (widget != NULL);
3470   g_return_if_fail (GTK_IS_WIDGET (widget));
3471   g_return_if_fail (GTK_WIDGET_NO_WINDOW (widget));
3472
3473   GTK_WIDGET_SET_FLAGS (widget, GTK_REALIZED);
3474   if (widget->parent)
3475     {
3476       widget->window = gtk_widget_get_parent_window (widget);
3477       gdk_window_ref (widget->window);
3478     }
3479   widget->style = gtk_style_attach (widget->style, widget->window);
3480 }
3481
3482 /*****************************************
3483  * gtk_widget_real_unrealize:
3484  *
3485  *   arguments:
3486  *
3487  *   results:
3488  *****************************************/
3489
3490 static void
3491 gtk_widget_real_unrealize (GtkWidget *widget)
3492 {
3493   g_return_if_fail (widget != NULL);
3494   g_return_if_fail (GTK_IS_WIDGET (widget));
3495
3496   if (GTK_WIDGET_NO_WINDOW (widget) && GTK_WIDGET_MAPPED (widget))
3497     gtk_widget_real_unmap (widget);
3498
3499   GTK_WIDGET_UNSET_FLAGS (widget, GTK_REALIZED | GTK_MAPPED);
3500
3501   /* printf ("unrealizing %s\n", gtk_type_name (GTK_OBJECT(widget)->klass->type));
3502    */
3503
3504   gtk_style_detach (widget->style);
3505   if (!GTK_WIDGET_NO_WINDOW (widget))
3506     {
3507       gdk_window_set_user_data (widget->window, NULL);
3508       gdk_window_destroy (widget->window);
3509     }
3510   else
3511     {
3512       gdk_window_unref (widget->window);
3513     }
3514
3515   /* Unrealize afterwards to improve visual effect */
3516
3517   if (GTK_IS_CONTAINER (widget))
3518     gtk_container_foreach (GTK_CONTAINER (widget),
3519                            (GtkCallback)gtk_widget_unrealize,
3520                            NULL);
3521
3522   widget->window = NULL;
3523 }
3524
3525 /*****************************************
3526  * gtk_widget_real_draw:
3527  *
3528  *   arguments:
3529  *
3530  *   results:
3531  *****************************************/
3532
3533 static void
3534 gtk_widget_real_draw (GtkWidget    *widget,
3535                       GdkRectangle *area)
3536 {
3537   GdkEventExpose event;
3538
3539   g_return_if_fail (widget != NULL);
3540   g_return_if_fail (GTK_IS_WIDGET (widget));
3541   g_return_if_fail (area != NULL);
3542
3543   if (GTK_WIDGET_DRAWABLE (widget))
3544     {
3545       event.type = GDK_EXPOSE;
3546       event.window = widget->window;
3547       event.area = *area;
3548
3549       gdk_window_ref (event.window);
3550       gtk_widget_event (widget, (GdkEvent*) &event);
3551       gdk_window_unref (event.window);
3552     }
3553 }
3554
3555 /*****************************************
3556  * gtk_widget_real_queue_draw:
3557  *
3558  *   arguments:
3559  *
3560  *   results:
3561  *****************************************/
3562
3563 static gint
3564 gtk_widget_real_queue_draw (GtkWidget *widget)
3565 {
3566   g_return_val_if_fail (widget != NULL, FALSE);
3567   g_return_val_if_fail (GTK_IS_WIDGET (widget), FALSE);
3568
3569   GTK_PRIVATE_UNSET_FLAG (widget, GTK_REDRAW_PENDING);
3570   gtk_widget_draw (widget, NULL);
3571
3572   return FALSE;
3573 }
3574
3575 /*****************************************
3576  * gtk_widget_real_size_allocate:
3577  *
3578  *   arguments:
3579  *
3580  *   results:
3581  *****************************************/
3582
3583 static void
3584 gtk_widget_real_size_allocate (GtkWidget     *widget,
3585                                GtkAllocation *allocation)
3586 {
3587   g_return_if_fail (widget != NULL);
3588   g_return_if_fail (GTK_IS_WIDGET (widget));
3589
3590   if (GTK_WIDGET_NO_WINDOW (widget) &&
3591       GTK_WIDGET_MAPPED (widget) &&
3592       ((widget->allocation.x != allocation->x) ||
3593        (widget->allocation.y != allocation->y) ||
3594        (widget->allocation.width != allocation->width) ||
3595        (widget->allocation.height != allocation->height)) &&
3596       (widget->allocation.width != 0) &&
3597       (widget->allocation.height != 0))
3598     gdk_window_clear_area (widget->window,
3599                            widget->allocation.x,
3600                            widget->allocation.y,
3601                            widget->allocation.width,
3602                            widget->allocation.height);
3603
3604   widget->allocation = *allocation;
3605
3606   if (GTK_WIDGET_REALIZED (widget) &&
3607       !GTK_WIDGET_NO_WINDOW (widget))
3608     gdk_window_move_resize (widget->window,
3609                             allocation->x, allocation->y,
3610                             allocation->width, allocation->height);
3611 }
3612
3613 /*****************************************
3614  * gtk_widget_peek_colormap:
3615  *
3616  *   arguments:
3617  *
3618  *   results:
3619  *****************************************/
3620
3621 static GdkColormap*
3622 gtk_widget_peek_colormap ()
3623 {
3624   if (colormap_stack)
3625     return (GdkColormap*) colormap_stack->data;
3626   return gtk_widget_get_default_colormap ();
3627 }
3628
3629 /*****************************************
3630  * gtk_widget_peek_visual:
3631  *
3632  *   arguments:
3633  *
3634  *   results:
3635  *****************************************/
3636
3637 static GdkVisual*
3638 gtk_widget_peek_visual ()
3639 {
3640   if (visual_stack)
3641     return (GdkVisual*) visual_stack->data;
3642   return gtk_widget_get_default_visual ();
3643 }
3644
3645 /*************************************************************
3646  * gtk_widget_propagate_state:
3647  *     Propagate a change in the widgets state down the tree
3648  *
3649  *   arguments:
3650  *     widget
3651  *     GtkStateData: state
3652  *                   parent_sensitive
3653  *
3654  *   results:
3655  *************************************************************/
3656
3657 static void
3658 gtk_widget_propagate_state (GtkWidget           *widget,
3659                             GtkStateData        *data)
3660 {
3661   guint8 old_state;
3662
3663   /* don't call this function with state=GTK_STATE_INSENSITIVE,
3664    * parent_sensitive=TRUE and a sensitive widget
3665    */
3666
3667   old_state = GTK_WIDGET_STATE (widget);
3668
3669   if (data->parent_sensitive)
3670     {
3671       GTK_WIDGET_SET_FLAGS (widget, GTK_PARENT_SENSITIVE);
3672
3673       if (GTK_WIDGET_IS_SENSITIVE (widget))
3674         GTK_WIDGET_STATE (widget) = data->state;
3675       else
3676         {
3677           GTK_WIDGET_STATE (widget) = GTK_STATE_INSENSITIVE;
3678           if (data->state != GTK_STATE_INSENSITIVE)
3679             GTK_WIDGET_SAVED_STATE (widget) = data->state;
3680         }
3681     }
3682   else
3683     {
3684       GTK_WIDGET_UNSET_FLAGS (widget, GTK_PARENT_SENSITIVE);
3685       GTK_WIDGET_STATE (widget) = GTK_STATE_INSENSITIVE;
3686       if (data->state != GTK_STATE_INSENSITIVE)
3687         GTK_WIDGET_SAVED_STATE (widget) = data->state;
3688     }
3689
3690   if (GTK_WIDGET_HAS_FOCUS (widget) && !GTK_WIDGET_IS_SENSITIVE (widget))
3691     {
3692       GtkWidget *window;
3693
3694       window = gtk_widget_get_ancestor (widget, gtk_window_get_type ());
3695       if (window)
3696         gtk_window_set_focus (GTK_WINDOW (window), NULL);
3697     }
3698
3699   if (old_state != GTK_WIDGET_STATE (widget))
3700     {
3701       gtk_widget_ref (widget);
3702       gtk_signal_emit (GTK_OBJECT (widget), widget_signals[STATE_CHANGED], old_state);
3703
3704       if (GTK_IS_CONTAINER (widget))
3705         {
3706           data->parent_sensitive = GTK_WIDGET_IS_SENSITIVE (widget);
3707           data->state = GTK_WIDGET_STATE (widget);
3708           gtk_container_foreach (GTK_CONTAINER (widget),
3709                                  (GtkCallback) gtk_widget_propagate_state,
3710                                  data);
3711         }
3712       gtk_widget_unref (widget);
3713     }
3714 }
3715
3716 /*****************************************
3717  * gtk_widget_draw_children_recurse:
3718  *
3719  *   arguments:
3720  *
3721  *   results:
3722  *****************************************/
3723
3724 static void
3725 gtk_widget_draw_children_recurse (GtkWidget *widget,
3726                                   gpointer   client_data)
3727 {
3728   gtk_widget_draw (widget, NULL);
3729   gtk_widget_draw_children (widget);
3730 }
3731
3732 /*****************************************
3733  * gtk_widget_aux_info_new:
3734  *
3735  *   arguments:
3736  *
3737  *   results:
3738  *****************************************/
3739
3740 static GtkWidgetAuxInfo*
3741 gtk_widget_aux_info_new ()
3742 {
3743   GtkWidgetAuxInfo *aux_info;
3744
3745   if (!aux_info_mem_chunk)
3746     aux_info_mem_chunk = g_mem_chunk_new ("widget aux info mem chunk",
3747                                           sizeof (GtkWidgetAuxInfo),
3748                                           1024, G_ALLOC_AND_FREE);
3749
3750   aux_info = g_chunk_new (GtkWidgetAuxInfo, aux_info_mem_chunk);
3751
3752   aux_info->x = -1;
3753   aux_info->y = -1;
3754   aux_info->width = 0;
3755   aux_info->height = 0;
3756
3757   return aux_info;
3758 }
3759
3760 /*****************************************
3761  * gtk_widget_aux_info_destroy:
3762  *
3763  *   arguments:
3764  *
3765  *   results:
3766  *****************************************/
3767
3768 static void
3769 gtk_widget_aux_info_destroy (GtkWidgetAuxInfo *aux_info)
3770 {
3771   g_return_if_fail (aux_info != NULL);
3772
3773   g_mem_chunk_free (aux_info_mem_chunk, aux_info);
3774 }
3775
3776 /*****************************************
3777  * gtk_widget_shape_combine_mask:
3778  *   set a shape for this widgets' gdk window, this allows for
3779  *   transparent windows etc., see gdk_window_shape_combine_mask
3780  *   for more information
3781  *
3782  *   arguments:
3783  *
3784  *   results:
3785  *****************************************/
3786 void
3787 gtk_widget_shape_combine_mask (GtkWidget *widget,
3788                                GdkBitmap *shape_mask,
3789                                gint       offset_x,
3790                                gint       offset_y)
3791 {
3792   GtkWidgetShapeInfo* shape_info;
3793
3794   g_return_if_fail (widget != NULL);
3795   /*  set_shape doesn't work on widgets without gdk window */
3796   g_return_if_fail (!GTK_WIDGET_NO_WINDOW (widget));
3797
3798   if (!shape_mask)
3799     {
3800       GTK_PRIVATE_UNSET_FLAG (widget, GTK_HAS_SHAPE_MASK);
3801
3802       if (widget->window)
3803         gdk_window_shape_combine_mask (widget->window, NULL, 0, 0);
3804
3805       shape_info = gtk_object_get_data (GTK_OBJECT (widget), shape_info_key);
3806       gtk_object_remove_data (GTK_OBJECT (widget), shape_info_key);
3807       g_free (shape_info);
3808     }
3809   else
3810     {
3811       GTK_PRIVATE_SET_FLAG (widget, GTK_HAS_SHAPE_MASK);
3812
3813       shape_info = gtk_object_get_data (GTK_OBJECT (widget), shape_info_key);
3814       if (!shape_info)
3815         {
3816           shape_info = g_new (GtkWidgetShapeInfo, 1);
3817           gtk_object_set_data (GTK_OBJECT (widget), shape_info_key, shape_info);
3818         }
3819       shape_info->shape_mask = shape_mask;
3820       shape_info->offset_x = offset_x;
3821       shape_info->offset_y = offset_y;
3822
3823       /* set shape if widget has a gdk window allready.
3824        * otherwise the shape is scheduled to be set by gtk_widget_realize.
3825        */
3826       if (widget->window)
3827         gdk_window_shape_combine_mask (widget->window, shape_mask,
3828                                        offset_x, offset_y);
3829     }
3830 }
3831
3832 /*****************************************
3833  * gtk_widget_dnd_drag_add:
3834  *   when you get a DRAG_ENTER event, you can use this
3835  *   to tell Gtk ofother widgets that are to be dragged as well
3836  *
3837  *   arguments:
3838  *
3839  *   results:
3840  *****************************************/
3841 void
3842 gtk_widget_dnd_drag_add (GtkWidget *widget)
3843 {
3844 }
3845
3846 /*****************************************
3847  * gtk_widget_dnd_drag_set:
3848  *   these two functions enable drag and/or drop on a
3849  *   widget and also let Gtk know what data types will be accepted
3850  *   use MIME type naming,plus tacking "URL:" on the front for link
3851  *   dragging
3852  *
3853  *
3854  *   arguments:
3855  *
3856  *   results:
3857  *****************************************/
3858 void
3859 gtk_widget_dnd_drag_set (GtkWidget   *widget,
3860                          guint8       drag_enable,
3861                          gchar      **type_accept_list,
3862                          guint        numtypes)
3863 {
3864   g_return_if_fail(widget != NULL);
3865
3866   if (!widget->window)
3867     gtk_widget_realize (widget);
3868
3869   g_return_if_fail (widget->window != NULL);
3870   gdk_window_dnd_drag_set (widget->window,
3871                            drag_enable,
3872                            type_accept_list,
3873                            numtypes);
3874 }
3875
3876 /*****************************************
3877  * gtk_widget_dnd_drop_set:
3878  *
3879  *   arguments:
3880  *
3881  *   results:
3882  *****************************************/
3883 void
3884 gtk_widget_dnd_drop_set (GtkWidget   *widget,
3885                          guint8       drop_enable,
3886                          gchar      **type_accept_list,
3887                          guint        numtypes,
3888                          guint8       is_destructive_operation)
3889 {
3890   g_return_if_fail(widget != NULL);
3891
3892   if (!widget->window)
3893     gtk_widget_realize (widget);
3894
3895   g_return_if_fail (widget->window != NULL);
3896   gdk_window_dnd_drop_set (widget->window,
3897                            drop_enable,
3898                            type_accept_list,
3899                            numtypes,
3900                            is_destructive_operation);
3901 }
3902
3903 /*****************************************
3904  * gtk_widget_dnd_data_set:
3905  *
3906  *   arguments:
3907  *
3908  *   results:
3909  *****************************************/
3910 void
3911 gtk_widget_dnd_data_set (GtkWidget   *widget,
3912                          GdkEvent    *event,
3913                          gpointer     data,
3914                          gulong       data_numbytes)
3915 {
3916   g_return_if_fail (widget != NULL);
3917   g_return_if_fail (widget->window != NULL);
3918
3919   gdk_window_dnd_data_set (widget->window, event, data, data_numbytes);
3920 }
3921
3922
3923 #undef  gtk_widget_ref
3924 #undef  gtk_widget_unref
3925
3926
3927 void
3928 gtk_widget_ref (GtkWidget *widget)
3929 {
3930   gtk_object_ref (GTK_OBJECT (widget));
3931 }
3932
3933 void
3934 gtk_widget_unref (GtkWidget *widget)
3935 {
3936   gtk_object_unref (GTK_OBJECT (widget));
3937 }
3938