Pileus Git - ~andy/gtk/blob - gtk/gtkoptionmenu.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 Lesser 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  * Lesser General Public License for more details.
  13  *
  14  * You should have received a copy of the GNU Lesser General Public
  15  * License along with this library; if not, write to the
  16  * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
  17  * Boston, MA 02111-1307, USA.
  18  */
  19
  20 /*
  21  * Modified by the GTK+ Team and others 1997-2000.  See the AUTHORS
  22  * file for a list of people on the GTK+ Team.  See the ChangeLog
  23  * files for a list of changes.  These files are distributed with
  24  * GTK+ at ftp://ftp.gtk.org/pub/gtk/.
  25  */
  26
  27 #include "gtkintl.h"
  28 #include "gtkmenu.h"
  29 #include "gtkmenuitem.h"
  30 #include "gtkoptionmenu.h"
  31 #include "gtkmarshalers.h"
  32 #include "gdk/gdkkeysyms.h"
  33
  34
  35 #define CHILD_LEFT_SPACING        4
  36 #define CHILD_RIGHT_SPACING       1
  37 #define CHILD_TOP_SPACING         1
  38 #define CHILD_BOTTOM_SPACING      1
  39
  40 typedef struct _GtkOptionMenuProps GtkOptionMenuProps;
  41
  42 struct _GtkOptionMenuProps
  43 {
  44   gboolean interior_focus;
  45   GtkRequisition indicator_size;
  46   GtkBorder indicator_spacing;
  47   gint focus_width;
  48   gint focus_pad;
  49 };
  50
  51 static const GtkOptionMenuProps default_props = {
  52   TRUE,
  53   { 7, 13 },
  54   { 7, 5, 2, 2 },               /* Left, right, top, bottom */
  55   1,
  56   0
  57 };
  58
  59 static void gtk_option_menu_class_init      (GtkOptionMenuClass *klass);
  60 static void gtk_option_menu_init            (GtkOptionMenu      *option_menu);
  61 static void gtk_option_menu_destroy         (GtkObject          *object);
  62 static void gtk_option_menu_set_property    (GObject            *object,
  63                                              guint               prop_id,
  64                                              const GValue       *value,
  65                                              GParamSpec         *pspec);
  66 static void gtk_option_menu_get_property    (GObject            *object,
  67                                              guint               prop_id,
  68                                              GValue             *value,
  69                                              GParamSpec         *pspec);
  70 static void gtk_option_menu_size_request    (GtkWidget          *widget,
  71                                              GtkRequisition     *requisition);
  72 static void gtk_option_menu_size_allocate   (GtkWidget          *widget,
  73                                              GtkAllocation      *allocation);
  74 static void gtk_option_menu_paint           (GtkWidget          *widget,
  75                                              GdkRectangle       *area);
  76 static gint gtk_option_menu_expose          (GtkWidget          *widget,
  77                                              GdkEventExpose     *event);
  78 static gint gtk_option_menu_button_press    (GtkWidget          *widget,
  79                                              GdkEventButton     *event);
  80 static gint gtk_option_menu_key_press       (GtkWidget          *widget,
  81                                              GdkEventKey        *event);
  82 static void gtk_option_menu_selection_done  (GtkMenuShell       *menu_shell,
  83                                              GtkOptionMenu      *option_menu);
  84 static void gtk_option_menu_update_contents (GtkOptionMenu      *option_menu);
  85 static void gtk_option_menu_remove_contents (GtkOptionMenu      *option_menu);
  86 static void gtk_option_menu_calc_size       (GtkOptionMenu      *option_menu);
  87 static void gtk_option_menu_position        (GtkMenu            *menu,
  88                                              gint               *x,
  89                                              gint               *y,
  90                                              gint               *scroll_offet,
  91                                              gpointer            user_data);
  92 static void gtk_option_menu_show_all        (GtkWidget          *widget);
  93 static void gtk_option_menu_hide_all        (GtkWidget          *widget);
  94 static gboolean gtk_option_menu_mnemonic_activate (GtkWidget    *widget,
  95                                                    gboolean      group_cycling);
  96 static GType gtk_option_menu_child_type   (GtkContainer       *container);
  97 static gint gtk_option_menu_scroll_event    (GtkWidget          *widget,
  98                                              GdkEventScroll     *event);
  99
 100 enum
 101 {
 102   CHANGED,
 103   LAST_SIGNAL
 104 };
 105
 106 enum
 107 {
 108   PROP_0,
 109   PROP_MENU,
 110   LAST_PROP
 111 };
 112
 113 static GtkButtonClass *parent_class = NULL;
 114 static guint           signals[LAST_SIGNAL] = { 0 };
 115
 116
 117 GType
 118 gtk_option_menu_get_type (void)
 119 {
 120   static GType option_menu_type = 0;
 121
 122   if (!option_menu_type)
 123     {
 124       static const GTypeInfo option_menu_info =
 125       {
 126         sizeof (GtkOptionMenuClass),
 127         NULL,           /* base_init */
 128         NULL,           /* base_finalize */
 129         (GClassInitFunc) gtk_option_menu_class_init,
 130         NULL,           /* class_finalize */
 131         NULL,           /* class_data */
 132         sizeof (GtkOptionMenu),
 133         0,              /* n_preallocs */
 134         (GInstanceInitFunc) gtk_option_menu_init,
 135       };
 136
 137       option_menu_type =
 138         g_type_register_static (GTK_TYPE_BUTTON, "GtkOptionMenu",
 139                                 &option_menu_info, 0);
 140     }
 141
 142   return option_menu_type;
 143 }
 144
 145 static void
 146 gtk_option_menu_class_init (GtkOptionMenuClass *class)
 147 {
 148   GObjectClass *gobject_class;
 149   GtkObjectClass *object_class;
 150   GtkWidgetClass *widget_class;
 151   GtkButtonClass *button_class;
 152   GtkContainerClass *container_class;
 153
 154   gobject_class = (GObjectClass*) class;
 155   object_class = (GtkObjectClass*) class;
 156   widget_class = (GtkWidgetClass*) class;
 157   button_class = (GtkButtonClass*) class;
 158   container_class = (GtkContainerClass*) class;
 159
 160   parent_class = g_type_class_peek_parent (class);
 161
 162   signals[CHANGED] =
 163     g_signal_new ("changed",
 164                   G_OBJECT_CLASS_TYPE (class),
 165                   G_SIGNAL_RUN_LAST,
 166                   G_STRUCT_OFFSET (GtkOptionMenuClass, changed),
 167                   NULL, NULL,
 168                   _gtk_marshal_VOID__VOID,
 169                   G_TYPE_NONE, 0);
 170
 171   gobject_class->set_property = gtk_option_menu_set_property;
 172   gobject_class->get_property = gtk_option_menu_get_property;
 173   object_class->destroy = gtk_option_menu_destroy;
 174
 175   widget_class->size_request = gtk_option_menu_size_request;
 176   widget_class->size_allocate = gtk_option_menu_size_allocate;
 177   widget_class->expose_event = gtk_option_menu_expose;
 178   widget_class->button_press_event = gtk_option_menu_button_press;
 179   widget_class->key_press_event = gtk_option_menu_key_press;
 180   widget_class->scroll_event = gtk_option_menu_scroll_event;
 181   widget_class->show_all = gtk_option_menu_show_all;
 182   widget_class->hide_all = gtk_option_menu_hide_all;
 183   widget_class->mnemonic_activate = gtk_option_menu_mnemonic_activate;
 184
 185   container_class->child_type = gtk_option_menu_child_type;
 186
 187   g_object_class_install_property (gobject_class,
 188                                    PROP_MENU,
 189                                    g_param_spec_object ("menu",
 190                                                         _("Menu"),
 191                                                         _("The menu of options"),
 192                                                         GTK_TYPE_MENU,
 193                                                         G_PARAM_READABLE | G_PARAM_WRITABLE));
 194
 195   gtk_widget_class_install_style_property (widget_class,
 196                                            g_param_spec_boxed ("indicator_size",
 197                                                                _("Indicator Size"),
 198                                                                _("Size of dropdown indicator"),
 199                                                                GTK_TYPE_REQUISITION,
 200                                                                G_PARAM_READABLE));
 201   gtk_widget_class_install_style_property (widget_class,
 202                                            g_param_spec_boxed ("indicator_spacing",
 203                                                                _("Indicator Spacing"),
 204                                                                _("Spacing around indicator"),
 205                                                                GTK_TYPE_BORDER,
 206                                                                G_PARAM_READABLE));
 207 }
 208
 209 static GType
 210 gtk_option_menu_child_type (GtkContainer       *container)
 211 {
 212   return G_TYPE_NONE;
 213 }
 214
 215 static void
 216 gtk_option_menu_init (GtkOptionMenu *option_menu)
 217 {
 218   GTK_WIDGET_SET_FLAGS (option_menu, GTK_CAN_FOCUS);
 219   GTK_WIDGET_UNSET_FLAGS (option_menu, GTK_CAN_DEFAULT | GTK_RECEIVES_DEFAULT);
 220
 221   option_menu->menu = NULL;
 222   option_menu->menu_item = NULL;
 223   option_menu->width = 0;
 224   option_menu->height = 0;
 225 }
 226
 227 GtkWidget*
 228 gtk_option_menu_new (void)
 229 {
 230   return g_object_new (GTK_TYPE_OPTION_MENU, NULL);
 231 }
 232
 233 GtkWidget*
 234 gtk_option_menu_get_menu (GtkOptionMenu *option_menu)
 235 {
 236   g_return_val_if_fail (GTK_IS_OPTION_MENU (option_menu), NULL);
 237
 238   return option_menu->menu;
 239 }
 240
 241 static void
 242 gtk_option_menu_detacher (GtkWidget     *widget,
 243                           GtkMenu       *menu)
 244 {
 245   GtkOptionMenu *option_menu;
 246
 247   g_return_if_fail (GTK_IS_OPTION_MENU (widget));
 248
 249   option_menu = GTK_OPTION_MENU (widget);
 250   g_return_if_fail (option_menu->menu == (GtkWidget*) menu);
 251
 252   gtk_option_menu_remove_contents (option_menu);
 253   g_signal_handlers_disconnect_by_func (option_menu->menu,
 254                                         gtk_option_menu_selection_done,
 255                                         option_menu);
 256   g_signal_handlers_disconnect_by_func (option_menu->menu,
 257                                         gtk_option_menu_calc_size,
 258                                         option_menu);
 259
 260   option_menu->menu = NULL;
 261   g_object_notify (G_OBJECT (option_menu), "menu");
 262 }
 263
 264 void
 265 gtk_option_menu_set_menu (GtkOptionMenu *option_menu,
 266                           GtkWidget     *menu)
 267 {
 268   g_return_if_fail (GTK_IS_OPTION_MENU (option_menu));
 269   g_return_if_fail (GTK_IS_MENU (menu));
 270
 271   if (option_menu->menu != menu)
 272     {
 273       gtk_option_menu_remove_menu (option_menu);
 274
 275       option_menu->menu = menu;
 276       gtk_menu_attach_to_widget (GTK_MENU (menu),
 277                                  GTK_WIDGET (option_menu),
 278                                  gtk_option_menu_detacher);
 279
 280       gtk_option_menu_calc_size (option_menu);
 281
 282       g_signal_connect_after (option_menu->menu, "selection_done",
 283                               G_CALLBACK (gtk_option_menu_selection_done),
 284                               option_menu);
 285       g_signal_connect_swapped (option_menu->menu, "size_request",
 286                                 G_CALLBACK (gtk_option_menu_calc_size),
 287                                 option_menu);
 288
 289       if (GTK_WIDGET (option_menu)->parent)
 290         gtk_widget_queue_resize (GTK_WIDGET (option_menu));
 291
 292       gtk_option_menu_update_contents (option_menu);
 293
 294       g_object_notify (G_OBJECT (option_menu), "menu");
 295     }
 296 }
 297
 298 void
 299 gtk_option_menu_remove_menu (GtkOptionMenu *option_menu)
 300 {
 301   g_return_if_fail (GTK_IS_OPTION_MENU (option_menu));
 302
 303   if (option_menu->menu)
 304     {
 305       if (GTK_MENU_SHELL (option_menu->menu)->active)
 306         g_signal_emit_by_name (option_menu->menu, "cancel", 0);
 307
 308       gtk_menu_detach (GTK_MENU (option_menu->menu));
 309     }
 310 }
 311
 312 void
 313 gtk_option_menu_set_history (GtkOptionMenu *option_menu,
 314                              guint          index)
 315 {
 316   GtkWidget *menu_item;
 317
 318   g_return_if_fail (GTK_IS_OPTION_MENU (option_menu));
 319
 320   if (option_menu->menu)
 321     {
 322       gtk_menu_set_active (GTK_MENU (option_menu->menu), index);
 323       menu_item = gtk_menu_get_active (GTK_MENU (option_menu->menu));
 324
 325       if (menu_item != option_menu->menu_item)
 326         gtk_option_menu_update_contents (option_menu);
 327     }
 328 }
 329
 330 /**
 331  * gtk_option_menu_get_history:
 332  * @option_menu: a #GtkOptionMenu
 333  *
 334  * Retrieves the index of the currently selected menu item. The menu
 335  * items are numbered from top to bottom, starting with 0.
 336  *
 337  * Return value: index of the selected menu item, or -1 if there are no menu items
 338  **/
 339 gint
 340 gtk_option_menu_get_history (GtkOptionMenu *option_menu)
 341 {
 342   GtkWidget *active_widget;
 343
 344   g_return_val_if_fail (GTK_IS_OPTION_MENU (option_menu), -1);
 345
 346   if (option_menu->menu)
 347     {
 348       active_widget = gtk_menu_get_active (GTK_MENU (option_menu->menu));
 349
 350       if (active_widget)
 351         return g_list_index (GTK_MENU_SHELL (option_menu->menu)->children,
 352                              active_widget);
 353       else
 354         return -1;
 355     }
 356   else
 357     return -1;
 358 }
 359
 360 static void
 361 gtk_option_menu_set_property (GObject            *object,
 362                               guint               prop_id,
 363                               const GValue       *value,
 364                               GParamSpec         *pspec)
 365 {
 366   GtkOptionMenu *option_menu = GTK_OPTION_MENU (object);
 367
 368   switch (prop_id)
 369     {
 370     case PROP_MENU:
 371       gtk_option_menu_set_menu (option_menu, g_value_get_object (value));
 372       break;
 373
 374     default:
 375       G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
 376       break;
 377     }
 378 }
 379
 380 static void
 381 gtk_option_menu_get_property (GObject            *object,
 382                               guint               prop_id,
 383                               GValue             *value,
 384                               GParamSpec         *pspec)
 385 {
 386   GtkOptionMenu *option_menu = GTK_OPTION_MENU (object);
 387
 388   switch (prop_id)
 389     {
 390     case PROP_MENU:
 391       g_value_set_object (value, option_menu->menu);
 392       break;
 393
 394     default:
 395       G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
 396       break;
 397     }
 398 }
 399
 400 static void
 401 gtk_option_menu_destroy (GtkObject *object)
 402 {
 403   GtkOptionMenu *option_menu;
 404
 405   g_return_if_fail (GTK_IS_OPTION_MENU (object));
 406
 407   option_menu = GTK_OPTION_MENU (object);
 408
 409   if (option_menu->menu)
 410     gtk_widget_destroy (option_menu->menu);
 411
 412   if (GTK_OBJECT_CLASS (parent_class)->destroy)
 413     (* GTK_OBJECT_CLASS (parent_class)->destroy) (object);
 414 }
 415
 416 static void
 417 gtk_option_menu_get_props (GtkOptionMenu       *option_menu,
 418                            GtkOptionMenuProps  *props)
 419 {
 420   GtkRequisition *indicator_size;
 421   GtkBorder *indicator_spacing;
 422
 423   gtk_widget_style_get (GTK_WIDGET (option_menu),
 424                         "indicator_size", &indicator_size,
 425                         "indicator_spacing", &indicator_spacing,
 426                         "interior_focus", &props->interior_focus,
 427                         "focus_line_width", &props->focus_width,
 428                         "focus_padding", &props->focus_pad,
 429                         NULL);
 430
 431   if (indicator_size)
 432     props->indicator_size = *indicator_size;
 433   else
 434     props->indicator_size = default_props.indicator_size;
 435
 436   if (indicator_spacing)
 437     props->indicator_spacing = *indicator_spacing;
 438   else
 439     props->indicator_spacing = default_props.indicator_spacing;
 440
 441   g_free (indicator_size);
 442   g_free (indicator_spacing);
 443 }
 444
 445 static void
 446 gtk_option_menu_size_request (GtkWidget      *widget,
 447                               GtkRequisition *requisition)
 448 {
 449   GtkOptionMenu *option_menu = GTK_OPTION_MENU (widget);
 450   GtkOptionMenuProps props;
 451   gint tmp;
 452   GtkRequisition child_requisition = { 0, 0 };
 453
 454   gtk_option_menu_get_props (option_menu, &props);
 455
 456   if (GTK_BIN (option_menu)->child && GTK_WIDGET_VISIBLE (GTK_BIN (option_menu)->child))
 457     {
 458       gtk_widget_size_request (GTK_BIN (option_menu)->child, &child_requisition);
 459
 460       requisition->width += child_requisition.width;
 461       requisition->height += child_requisition.height;
 462     }
 463
 464   requisition->width = ((GTK_CONTAINER (widget)->border_width +
 465                          GTK_WIDGET (widget)->style->xthickness + props.focus_pad) * 2 +
 466                         MAX (child_requisition.width, option_menu->width) +
 467                         props.indicator_size.width +
 468                         props.indicator_spacing.left + props.indicator_spacing.right +
 469                         CHILD_LEFT_SPACING + CHILD_RIGHT_SPACING + props.focus_width * 2);
 470   requisition->height = ((GTK_CONTAINER (widget)->border_width +
 471                           GTK_WIDGET (widget)->style->ythickness + props.focus_pad) * 2 +
 472                          MAX (child_requisition.height, option_menu->height) +
 473                          CHILD_TOP_SPACING + CHILD_BOTTOM_SPACING + props.focus_width * 2);
 474
 475   tmp = (requisition->height - MAX (child_requisition.height, option_menu->height) +
 476          props.indicator_size.height + props.indicator_spacing.top + props.indicator_spacing.bottom);
 477   requisition->height = MAX (requisition->height, tmp);
 478 }
 479
 480 static void
 481 gtk_option_menu_size_allocate (GtkWidget     *widget,
 482                                GtkAllocation *allocation)
 483 {
 484   GtkWidget *child;
 485   GtkButton *button = GTK_BUTTON (widget);
 486   GtkAllocation child_allocation;
 487   GtkOptionMenuProps props;
 488   gint border_width;
 489
 490   gtk_option_menu_get_props (GTK_OPTION_MENU (widget), &props);
 491   border_width = GTK_CONTAINER (widget)->border_width;
 492
 493   widget->allocation = *allocation;
 494   if (GTK_WIDGET_REALIZED (widget))
 495     gdk_window_move_resize (button->event_window,
 496                             allocation->x + border_width, allocation->y + border_width,
 497                             allocation->width - border_width * 2, allocation->height - border_width * 2);
 498
 499   child = GTK_BIN (widget)->child;
 500   if (child && GTK_WIDGET_VISIBLE (child))
 501     {
 502       gint xthickness = GTK_WIDGET (widget)->style->xthickness;
 503       gint ythickness = GTK_WIDGET (widget)->style->ythickness;
 504
 505       child_allocation.x = widget->allocation.x + border_width + xthickness + props.focus_width + props.focus_pad + CHILD_LEFT_SPACING;
 506       child_allocation.y = widget->allocation.y + border_width + ythickness + props.focus_width + props.focus_pad + CHILD_TOP_SPACING;
 507       child_allocation.width = MAX (1, allocation->width - (border_width + xthickness + props.focus_width + props.focus_pad) * 2 -
 508                                     props.indicator_size.width - props.indicator_spacing.left - props.indicator_spacing.right -
 509                                     CHILD_LEFT_SPACING - CHILD_RIGHT_SPACING);
 510       child_allocation.height = MAX (1, allocation->height - (border_width + ythickness + props.focus_width + props.focus_pad) * 2 -
 511                                      CHILD_TOP_SPACING - CHILD_BOTTOM_SPACING);
 512
 513       if (gtk_widget_get_direction (GTK_WIDGET (widget)) == GTK_TEXT_DIR_RTL)
 514         child_allocation.x += props.indicator_size.width + props.indicator_spacing.left + props.indicator_spacing.right;
 515
 516       gtk_widget_size_allocate (child, &child_allocation);
 517     }
 518 }
 519
 520 static void
 521 gtk_option_menu_paint (GtkWidget    *widget,
 522                        GdkRectangle *area)
 523 {
 524   GdkRectangle button_area;
 525   GtkOptionMenuProps props;
 526   gint border_width;
 527   gint tab_x;
 528
 529   g_return_if_fail (GTK_IS_OPTION_MENU (widget));
 530   g_return_if_fail (area != NULL);
 531
 532   if (GTK_WIDGET_DRAWABLE (widget))
 533     {
 534       border_width = GTK_CONTAINER (widget)->border_width;
 535       gtk_option_menu_get_props (GTK_OPTION_MENU (widget), &props);
 536
 537       button_area.x = widget->allocation.x + border_width;
 538       button_area.y = widget->allocation.y + border_width;
 539       button_area.width = widget->allocation.width - 2 * border_width;
 540       button_area.height = widget->allocation.height - 2 * border_width;
 541
 542       if (!props.interior_focus && GTK_WIDGET_HAS_FOCUS (widget))
 543         {
 544           button_area.x += props.focus_width + props.focus_pad;
 545           button_area.y += props.focus_width + props.focus_pad;
 546           button_area.width -= 2 * (props.focus_width + props.focus_pad);
 547           button_area.height -= 2 * (props.focus_width + props.focus_pad);
 548         }
 549
 550       gtk_paint_box (widget->style, widget->window,
 551                      GTK_WIDGET_STATE (widget), GTK_SHADOW_OUT,
 552                      area, widget, "optionmenu",
 553                      button_area.x, button_area.y,
 554                      button_area.width, button_area.height);
 555
 556       if (gtk_widget_get_direction (GTK_WIDGET (widget)) == GTK_TEXT_DIR_RTL)
 557         tab_x = button_area.x + props.indicator_spacing.right +
 558           widget->style->xthickness;
 559       else
 560         tab_x = button_area.x + button_area.width -
 561           props.indicator_size.width - props.indicator_spacing.right -
 562           widget->style->xthickness;
 563
 564       gtk_paint_tab (widget->style, widget->window,
 565                      GTK_WIDGET_STATE (widget), GTK_SHADOW_OUT,
 566                      area, widget, "optionmenutab",
 567                      tab_x,
 568                      button_area.y + (button_area.height - props.indicator_size.height) / 2,
 569                      props.indicator_size.width, props.indicator_size.height);
 570
 571       if (GTK_WIDGET_HAS_FOCUS (widget))
 572         {
 573           if (props.interior_focus)
 574             {
 575               button_area.x += widget->style->xthickness + props.focus_pad;
 576               button_area.y += widget->style->ythickness + props.focus_pad;
 577               button_area.width -= 2 * (widget->style->xthickness + props.focus_pad) +
 578                       props.indicator_spacing.left +
 579                       props.indicator_spacing.right +
 580                       props.indicator_size.width;
 581               button_area.height -= 2 * (widget->style->ythickness + props.focus_pad);
 582               if (gtk_widget_get_direction (GTK_WIDGET (widget)) == GTK_TEXT_DIR_RTL)
 583                 button_area.x += props.indicator_spacing.left +
 584                   props.indicator_spacing.right +
 585                   props.indicator_size.width;
 586             }
 587           else
 588             {
 589               button_area.x -= props.focus_width + props.focus_pad;
 590               button_area.y -= props.focus_width + props.focus_pad;
 591               button_area.width += 2 * (props.focus_width + props.focus_pad);
 592               button_area.height += 2 * (props.focus_width + props.focus_pad);
 593             }
 594
 595           gtk_paint_focus (widget->style, widget->window, GTK_WIDGET_STATE (widget),
 596                            area, widget, "button",
 597                            button_area.x,
 598                            button_area.y,
 599                            button_area.width,
 600                            button_area.height);
 601         }
 602     }
 603 }
 604
 605 static gint
 606 gtk_option_menu_expose (GtkWidget      *widget,
 607                         GdkEventExpose *event)
 608 {
 609   g_return_val_if_fail (GTK_IS_OPTION_MENU (widget), FALSE);
 610   g_return_val_if_fail (event != NULL, FALSE);
 611
 612   if (GTK_WIDGET_DRAWABLE (widget))
 613     {
 614       gtk_option_menu_paint (widget, &event->area);
 615
 616
 617       /* The following code tries to draw the child in two places at
 618        * once. It fails miserably for several reasons
 619        *
 620        * - If the child is not no-window, removing generates
 621        *   more expose events. Bad, bad, bad.
 622        *
 623        * - Even if the child is no-window, removing it now (properly)
 624        *   clears the space where it was, so it does no good
 625        */
 626
 627 #if 0
 628       remove_child = FALSE;
 629       child = GTK_BUTTON (widget)->child;
 630
 631       if (!child)
 632         {
 633           if (!GTK_OPTION_MENU (widget)->menu)
 634             return FALSE;
 635           gtk_option_menu_update_contents (GTK_OPTION_MENU (widget));
 636           child = GTK_BUTTON (widget)->child;
 637           if (!child)
 638             return FALSE;
 639           remove_child = TRUE;
 640         }
 641
 642       child_event = *event;
 643
 644       if (GTK_WIDGET_NO_WINDOW (child) &&
 645           gtk_widget_intersect (child, &event->area, &child_event.area))
 646         gtk_widget_event (child, (GdkEvent*) &child_event);
 647
 648       if (remove_child)
 649         gtk_option_menu_remove_contents (GTK_OPTION_MENU (widget));
 650 #else
 651       if (GTK_BIN (widget)->child)
 652         gtk_container_propagate_expose (GTK_CONTAINER (widget),
 653                                         GTK_BIN (widget)->child,
 654                                         event);
 655 #endif /* 0 */
 656     }
 657
 658   return FALSE;
 659 }
 660
 661 static gint
 662 gtk_option_menu_button_press (GtkWidget      *widget,
 663                               GdkEventButton *event)
 664 {
 665   GtkOptionMenu *option_menu;
 666   GtkWidget *menu_item;
 667
 668   g_return_val_if_fail (GTK_IS_OPTION_MENU (widget), FALSE);
 669   g_return_val_if_fail (event != NULL, FALSE);
 670
 671   option_menu = GTK_OPTION_MENU (widget);
 672
 673   if ((event->type == GDK_BUTTON_PRESS) &&
 674       (event->button == 1))
 675     {
 676       gtk_option_menu_remove_contents (option_menu);
 677       gtk_menu_popup (GTK_MENU (option_menu->menu), NULL, NULL,
 678                       gtk_option_menu_position, option_menu,
 679                       event->button, event->time);
 680       menu_item = gtk_menu_get_active (GTK_MENU (option_menu->menu));
 681       if (menu_item)
 682         gtk_menu_shell_select_item (GTK_MENU_SHELL (option_menu->menu), menu_item);
 683       return TRUE;
 684     }
 685
 686   return FALSE;
 687 }
 688
 689 static gint
 690 gtk_option_menu_key_press (GtkWidget   *widget,
 691                            GdkEventKey *event)
 692 {
 693   GtkOptionMenu *option_menu;
 694   GtkWidget *menu_item;
 695
 696   g_return_val_if_fail (GTK_IS_OPTION_MENU (widget), FALSE);
 697   g_return_val_if_fail (event != NULL, FALSE);
 698
 699   option_menu = GTK_OPTION_MENU (widget);
 700
 701   switch (event->keyval)
 702     {
 703     case GDK_KP_Space:
 704     case GDK_space:
 705       gtk_option_menu_remove_contents (option_menu);
 706       gtk_menu_popup (GTK_MENU (option_menu->menu), NULL, NULL,
 707                       gtk_option_menu_position, option_menu,
 708                       0, event->time);
 709       menu_item = gtk_menu_get_active (GTK_MENU (option_menu->menu));
 710       if (menu_item)
 711         gtk_menu_shell_select_item (GTK_MENU_SHELL (option_menu->menu), menu_item);
 712       return TRUE;
 713     }
 714
 715   return FALSE;
 716 }
 717
 718 static void
 719 gtk_option_menu_selection_done (GtkMenuShell  *menu_shell,
 720                                 GtkOptionMenu *option_menu)
 721 {
 722   g_return_if_fail (menu_shell != NULL);
 723   g_return_if_fail (GTK_IS_OPTION_MENU (option_menu));
 724
 725   gtk_option_menu_update_contents (option_menu);
 726 }
 727
 728 static void
 729 gtk_option_menu_changed (GtkOptionMenu *option_menu)
 730 {
 731   g_return_if_fail (GTK_IS_OPTION_MENU (option_menu));
 732
 733   g_signal_emit (option_menu, signals[CHANGED], 0);
 734 }
 735
 736 static void
 737 gtk_option_menu_select_first_sensitive (GtkOptionMenu *option_menu)
 738 {
 739   if (option_menu->menu)
 740     {
 741       GList *children = GTK_MENU_SHELL (option_menu->menu)->children;
 742       gint index = 0;
 743
 744       while (children)
 745         {
 746           if (GTK_WIDGET_SENSITIVE (children->data))
 747             {
 748               gtk_option_menu_set_history (option_menu, index);
 749               return;
 750             }
 751
 752           children = children->next;
 753           index++;
 754         }
 755     }
 756 }
 757
 758 static void
 759 gtk_option_menu_item_state_changed_cb (GtkWidget      *widget,
 760                                        GtkStateType    previous_state,
 761                                        GtkOptionMenu  *option_menu)
 762 {
 763   GtkWidget *child = GTK_BIN (option_menu)->child;
 764
 765   if (child && GTK_WIDGET_SENSITIVE (child) != GTK_WIDGET_IS_SENSITIVE (widget))
 766     gtk_widget_set_sensitive (child, GTK_WIDGET_IS_SENSITIVE (widget));
 767 }
 768
 769 static void
 770 gtk_option_menu_item_destroy_cb (GtkWidget     *widget,
 771                                  GtkOptionMenu *option_menu)
 772 {
 773   GtkWidget *child = GTK_BIN (option_menu)->child;
 774
 775   if (child)
 776     {
 777       g_object_ref (child);
 778       gtk_option_menu_remove_contents (option_menu);
 779       gtk_widget_destroy (child);
 780       g_object_unref (child);
 781
 782       gtk_option_menu_select_first_sensitive (option_menu);
 783     }
 784 }
 785
 786 static void
 787 gtk_option_menu_update_contents (GtkOptionMenu *option_menu)
 788 {
 789   GtkWidget *child;
 790   GtkRequisition child_requisition;
 791
 792   g_return_if_fail (GTK_IS_OPTION_MENU (option_menu));
 793
 794   if (option_menu->menu)
 795     {
 796       GtkWidget *old_item = option_menu->menu_item;
 797
 798       gtk_option_menu_remove_contents (option_menu);
 799
 800       option_menu->menu_item = gtk_menu_get_active (GTK_MENU (option_menu->menu));
 801       if (option_menu->menu_item)
 802         {
 803           g_object_ref (option_menu->menu_item);
 804           child = GTK_BIN (option_menu->menu_item)->child;
 805           if (child)
 806             {
 807               if (!GTK_WIDGET_IS_SENSITIVE (option_menu->menu_item))
 808                 gtk_widget_set_sensitive (child, FALSE);
 809               gtk_widget_reparent (child, GTK_WIDGET (option_menu));
 810             }
 811
 812           g_signal_connect (option_menu->menu_item, "state_changed",
 813                             G_CALLBACK (gtk_option_menu_item_state_changed_cb), option_menu);
 814           g_signal_connect (option_menu->menu_item, "destroy",
 815                             G_CALLBACK (gtk_option_menu_item_destroy_cb), option_menu);
 816
 817           gtk_widget_size_request (child, &child_requisition);
 818           gtk_widget_size_allocate (GTK_WIDGET (option_menu),
 819                                     &(GTK_WIDGET (option_menu)->allocation));
 820
 821           if (GTK_WIDGET_DRAWABLE (option_menu))
 822             gtk_widget_queue_draw (GTK_WIDGET (option_menu));
 823         }
 824
 825       if (old_item != option_menu->menu_item)
 826         gtk_option_menu_changed (option_menu);
 827     }
 828 }
 829
 830 static void
 831 gtk_option_menu_remove_contents (GtkOptionMenu *option_menu)
 832 {
 833   GtkWidget *child;
 834
 835   g_return_if_fail (GTK_IS_OPTION_MENU (option_menu));
 836
 837   if (option_menu->menu_item)
 838     {
 839       child = GTK_BIN (option_menu)->child;
 840
 841       if (child)
 842         {
 843           gtk_widget_set_sensitive (child, TRUE);
 844           gtk_widget_reparent (child, option_menu->menu_item);
 845         }
 846
 847       g_signal_handlers_disconnect_by_func (option_menu->menu_item,
 848                                             gtk_option_menu_item_state_changed_cb,
 849                                             option_menu);
 850       g_signal_handlers_disconnect_by_func (option_menu->menu_item,
 851                                             gtk_option_menu_item_destroy_cb,
 852                                             option_menu);
 853
 854       g_object_unref (option_menu->menu_item);
 855       option_menu->menu_item = NULL;
 856     }
 857 }
 858
 859 static void
 860 gtk_option_menu_calc_size (GtkOptionMenu *option_menu)
 861 {
 862   GtkWidget *child;
 863   GList *children;
 864   GtkRequisition child_requisition;
 865   gint old_width = option_menu->width;
 866   gint old_height = option_menu->height;
 867
 868   g_return_if_fail (GTK_IS_OPTION_MENU (option_menu));
 869
 870   option_menu->width = 0;
 871   option_menu->height = 0;
 872
 873   if (option_menu->menu)
 874     {
 875       children = GTK_MENU_SHELL (option_menu->menu)->children;
 876       while (children)
 877         {
 878           child = children->data;
 879           children = children->next;
 880
 881           if (GTK_WIDGET_VISIBLE (child))
 882             {
 883               GtkWidget *inner = GTK_BIN (child)->child;
 884
 885               if (inner)
 886                 {
 887                   gtk_widget_size_request (inner, &child_requisition);
 888
 889                   option_menu->width = MAX (option_menu->width, child_requisition.width);
 890                   option_menu->height = MAX (option_menu->height, child_requisition.height);
 891                 }
 892             }
 893         }
 894     }
 895
 896   if (old_width != option_menu->width || old_height != option_menu->height)
 897     gtk_widget_queue_resize (GTK_WIDGET (option_menu));
 898 }
 899
 900 static void
 901 gtk_option_menu_position (GtkMenu  *menu,
 902                           gint     *x,
 903                           gint     *y,
 904                           gboolean *push_in,
 905                           gpointer  user_data)
 906 {
 907   GtkOptionMenu *option_menu;
 908   GtkWidget *active;
 909   GtkWidget *child;
 910   GtkWidget *widget;
 911   GtkRequisition requisition;
 912   GList *children;
 913   gint screen_width;
 914   gint menu_xpos;
 915   gint menu_ypos;
 916   gint menu_width;
 917
 918   g_return_if_fail (GTK_IS_OPTION_MENU (user_data));
 919
 920   option_menu = GTK_OPTION_MENU (user_data);
 921   widget = GTK_WIDGET (option_menu);
 922
 923   gtk_widget_get_child_requisition (GTK_WIDGET (menu), &requisition);
 924   menu_width = requisition.width;
 925
 926   active = gtk_menu_get_active (GTK_MENU (option_menu->menu));
 927   gdk_window_get_origin (widget->window, &menu_xpos, &menu_ypos);
 928
 929   menu_xpos += widget->allocation.x;
 930   menu_ypos += widget->allocation.y + widget->allocation.height / 2 - 2;
 931
 932   if (active != NULL)
 933     {
 934       gtk_widget_get_child_requisition (active, &requisition);
 935       menu_ypos -= requisition.height / 2;
 936     }
 937
 938   children = GTK_MENU_SHELL (option_menu->menu)->children;
 939   while (children)
 940     {
 941       child = children->data;
 942
 943       if (active == child)
 944         break;
 945
 946       if (GTK_WIDGET_VISIBLE (child))
 947         {
 948           gtk_widget_get_child_requisition (child, &requisition);
 949           menu_ypos -= requisition.height;
 950         }
 951
 952       children = children->next;
 953     }
 954
 955   screen_width = gdk_screen_get_width (gtk_widget_get_screen (widget));
 956
 957   if (menu_xpos < 0)
 958     menu_xpos = 0;
 959   else if ((menu_xpos + menu_width) > screen_width)
 960     menu_xpos -= ((menu_xpos + menu_width) - screen_width);
 961
 962   *x = menu_xpos;
 963   *y = menu_ypos;
 964   *push_in = TRUE;
 965 }
 966
 967
 968 static void
 969 gtk_option_menu_show_all (GtkWidget *widget)
 970 {
 971   GtkContainer *container;
 972   GtkOptionMenu *option_menu;
 973
 974   g_return_if_fail (GTK_IS_OPTION_MENU (widget));
 975   container = GTK_CONTAINER (widget);
 976   option_menu = GTK_OPTION_MENU (widget);
 977
 978   gtk_widget_show (widget);
 979   gtk_container_foreach (container, (GtkCallback) gtk_widget_show_all, NULL);
 980   if (option_menu->menu)
 981     gtk_widget_show_all (option_menu->menu);
 982   if (option_menu->menu_item)
 983     gtk_widget_show_all (option_menu->menu_item);
 984 }
 985
 986
 987 static void
 988 gtk_option_menu_hide_all (GtkWidget *widget)
 989 {
 990   GtkContainer *container;
 991
 992   g_return_if_fail (GTK_IS_OPTION_MENU (widget));
 993   container = GTK_CONTAINER (widget);
 994
 995   gtk_widget_hide (widget);
 996   gtk_container_foreach (container, (GtkCallback) gtk_widget_hide_all, NULL);
 997 }
 998
 999 static gboolean
1000 gtk_option_menu_mnemonic_activate (GtkWidget *widget,
1001                                    gboolean   group_cycling)
1002 {
1003   gtk_widget_grab_focus (widget);
1004   return TRUE;
1005 }
1006
1007 static gint
1008 gtk_option_menu_scroll_event (GtkWidget          *widget,
1009                               GdkEventScroll     *event)
1010 {
1011   GtkOptionMenu *option_menu = GTK_OPTION_MENU (widget);
1012   gint index;
1013   gint n_children;
1014   gint index_dir;
1015   GList *l;
1016   GtkMenuItem *item;
1017
1018   index = gtk_option_menu_get_history (option_menu);
1019
1020   if (index != -1)
1021     {
1022       n_children = g_list_length (GTK_MENU_SHELL (option_menu->menu)->children);
1023
1024       if (event->direction == GDK_SCROLL_UP)
1025         index_dir = -1;
1026       else
1027         index_dir = 1;
1028
1029
1030       while (TRUE)
1031         {
1032           index += index_dir;
1033
1034           if (index < 0)
1035             break;
1036           if (index >= n_children)
1037             break;
1038
1039           l = g_list_nth (GTK_MENU_SHELL (option_menu->menu)->children, index);
1040           item = GTK_MENU_ITEM (l->data);
1041           if (GTK_WIDGET_VISIBLE (item) && GTK_WIDGET_IS_SENSITIVE (item))
1042             {
1043               gtk_option_menu_set_history (option_menu, index);
1044               gtk_menu_item_activate (GTK_MENU_ITEM (item));
1045               break;
1046             }
1047
1048         }
1049     }
1050
1051   return TRUE;
1052 }
1053