Pileus Git - ~andy/gtk/blob - gtk/gtkmenubar.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 /**
  28  * SECTION:gtkmenubar
  29  * @Title: GtkMenuBar
  30  * @Short_description: A subclass of GtkMenuShell which holds GtkMenuItem widgets
  31  * @See_also: #GtkMenuShell, #GtkMenu, #GtkMenuItem
  32  *
  33  * The #GtkMenuBar is a subclass of #GtkMenuShell which contains one or
  34  * more #GtkMenuItems. The result is a standard menu bar which can hold
  35  * many menu items.
  36  */
  37
  38 #include "config.h"
  39
  40 #include "gtkmenubar.h"
  41
  42 #include "gtkbindings.h"
  43 #include "gtkmain.h"
  44 #include "gtkmarshalers.h"
  45 #include "gtkmenuitemprivate.h"
  46 #include "gtkmenuprivate.h"
  47 #include "gtkmenushellprivate.h"
  48 #include "gtksettings.h"
  49 #include "gtksizerequest.h"
  50 #include "gtkwindow.h"
  51 #include "gtkintl.h"
  52 #include "gtkprivate.h"
  53 #include "gtktypebuiltins.h"
  54
  55 #define BORDER_SPACING  0
  56 #define DEFAULT_IPADDING 1
  57
  58 /* Properties */
  59 enum {
  60   PROP_0,
  61   PROP_PACK_DIRECTION,
  62   PROP_CHILD_PACK_DIRECTION
  63 };
  64
  65 struct _GtkMenuBarPrivate
  66 {
  67   GtkPackDirection pack_direction;
  68   GtkPackDirection child_pack_direction;
  69 };
  70
  71
  72 static void gtk_menu_bar_set_property      (GObject             *object,
  73                                             guint                prop_id,
  74                                             const GValue        *value,
  75                                             GParamSpec          *pspec);
  76 static void gtk_menu_bar_get_property      (GObject             *object,
  77                                             guint                prop_id,
  78                                             GValue              *value,
  79                                             GParamSpec          *pspec);
  80 static void gtk_menu_bar_get_preferred_width (GtkWidget     *widget,
  81                                               gint          *minimum,
  82                                               gint          *natural);
  83 static void gtk_menu_bar_get_preferred_height (GtkWidget    *widget,
  84                                                gint         *minimum,
  85                                                gint         *natural);
  86 static void gtk_menu_bar_get_preferred_width_for_height (GtkWidget    *widget,
  87                                                          gint          height,
  88                                                          gint         *minimum,
  89                                                          gint         *natural);
  90 static void gtk_menu_bar_get_preferred_height_for_width (GtkWidget    *widget,
  91                                                          gint          width,
  92                                                          gint         *minimum,
  93                                                          gint         *natural);
  94 static void gtk_menu_bar_size_allocate     (GtkWidget       *widget,
  95                                             GtkAllocation   *allocation);
  96 static gint gtk_menu_bar_draw              (GtkWidget       *widget,
  97                                             cairo_t         *cr);
  98 static void gtk_menu_bar_hierarchy_changed (GtkWidget       *widget,
  99                                             GtkWidget       *old_toplevel);
 100 static gint gtk_menu_bar_get_popup_delay   (GtkMenuShell    *menu_shell);
 101 static void gtk_menu_bar_move_current      (GtkMenuShell     *menu_shell,
 102                                             GtkMenuDirectionType direction);
 103
 104 static GtkShadowType get_shadow_type   (GtkMenuBar      *menubar);
 105
 106 G_DEFINE_TYPE (GtkMenuBar, gtk_menu_bar, GTK_TYPE_MENU_SHELL)
 107
 108 static void
 109 gtk_menu_bar_class_init (GtkMenuBarClass *class)
 110 {
 111   GObjectClass *gobject_class;
 112   GtkWidgetClass *widget_class;
 113   GtkMenuShellClass *menu_shell_class;
 114
 115   GtkBindingSet *binding_set;
 116
 117   gobject_class = (GObjectClass*) class;
 118   widget_class = (GtkWidgetClass*) class;
 119   menu_shell_class = (GtkMenuShellClass*) class;
 120
 121   gobject_class->get_property = gtk_menu_bar_get_property;
 122   gobject_class->set_property = gtk_menu_bar_set_property;
 123
 124   widget_class->get_preferred_width = gtk_menu_bar_get_preferred_width;
 125   widget_class->get_preferred_height = gtk_menu_bar_get_preferred_height;
 126   widget_class->get_preferred_width_for_height = gtk_menu_bar_get_preferred_width_for_height;
 127   widget_class->get_preferred_height_for_width = gtk_menu_bar_get_preferred_height_for_width;
 128   widget_class->size_allocate = gtk_menu_bar_size_allocate;
 129   widget_class->draw = gtk_menu_bar_draw;
 130   widget_class->hierarchy_changed = gtk_menu_bar_hierarchy_changed;
 131
 132   menu_shell_class->submenu_placement = GTK_TOP_BOTTOM;
 133   menu_shell_class->get_popup_delay = gtk_menu_bar_get_popup_delay;
 134   menu_shell_class->move_current = gtk_menu_bar_move_current;
 135
 136   binding_set = gtk_binding_set_by_class (class);
 137   gtk_binding_entry_add_signal (binding_set,
 138                                 GDK_KEY_Left, 0,
 139                                 "move-current", 1,
 140                                 GTK_TYPE_MENU_DIRECTION_TYPE,
 141                                 GTK_MENU_DIR_PREV);
 142   gtk_binding_entry_add_signal (binding_set,
 143                                 GDK_KEY_KP_Left, 0,
 144                                 "move-current", 1,
 145                                 GTK_TYPE_MENU_DIRECTION_TYPE,
 146                                 GTK_MENU_DIR_PREV);
 147   gtk_binding_entry_add_signal (binding_set,
 148                                 GDK_KEY_Right, 0,
 149                                 "move-current", 1,
 150                                 GTK_TYPE_MENU_DIRECTION_TYPE,
 151                                 GTK_MENU_DIR_NEXT);
 152   gtk_binding_entry_add_signal (binding_set,
 153                                 GDK_KEY_KP_Right, 0,
 154                                 "move-current", 1,
 155                                 GTK_TYPE_MENU_DIRECTION_TYPE,
 156                                 GTK_MENU_DIR_NEXT);
 157   gtk_binding_entry_add_signal (binding_set,
 158                                 GDK_KEY_Up, 0,
 159                                 "move-current", 1,
 160                                 GTK_TYPE_MENU_DIRECTION_TYPE,
 161                                 GTK_MENU_DIR_PARENT);
 162   gtk_binding_entry_add_signal (binding_set,
 163                                 GDK_KEY_KP_Up, 0,
 164                                 "move-current", 1,
 165                                 GTK_TYPE_MENU_DIRECTION_TYPE,
 166                                 GTK_MENU_DIR_PARENT);
 167   gtk_binding_entry_add_signal (binding_set,
 168                                 GDK_KEY_Down, 0,
 169                                 "move-current", 1,
 170                                 GTK_TYPE_MENU_DIRECTION_TYPE,
 171                                 GTK_MENU_DIR_CHILD);
 172   gtk_binding_entry_add_signal (binding_set,
 173                                 GDK_KEY_KP_Down, 0,
 174                                 "move-current", 1,
 175                                 GTK_TYPE_MENU_DIRECTION_TYPE,
 176                                 GTK_MENU_DIR_CHILD);
 177
 178   /**
 179    * GtkMenuBar:pack-direction:
 180    *
 181    * The pack direction of the menubar. It determines how
 182    * menuitems are arranged in the menubar.
 183    *
 184    * Since: 2.8
 185    */
 186   g_object_class_install_property (gobject_class,
 187                                    PROP_PACK_DIRECTION,
 188                                    g_param_spec_enum ("pack-direction",
 189                                                       P_("Pack direction"),
 190                                                       P_("The pack direction of the menubar"),
 191                                                       GTK_TYPE_PACK_DIRECTION,
 192                                                       GTK_PACK_DIRECTION_LTR,
 193                                                       GTK_PARAM_READWRITE));
 194
 195   /**
 196    * GtkMenuBar:child-pack-direction:
 197    *
 198    * The child pack direction of the menubar. It determines how
 199    * the widgets contained in child menuitems are arranged.
 200    *
 201    * Since: 2.8
 202    */
 203   g_object_class_install_property (gobject_class,
 204                                    PROP_CHILD_PACK_DIRECTION,
 205                                    g_param_spec_enum ("child-pack-direction",
 206                                                       P_("Child Pack direction"),
 207                                                       P_("The child pack direction of the menubar"),
 208                                                       GTK_TYPE_PACK_DIRECTION,
 209                                                       GTK_PACK_DIRECTION_LTR,
 210                                                       GTK_PARAM_READWRITE));
 211
 212
 213   gtk_widget_class_install_style_property (widget_class,
 214                                            g_param_spec_enum ("shadow-type",
 215                                                               P_("Shadow type"),
 216                                                               P_("Style of bevel around the menubar"),
 217                                                               GTK_TYPE_SHADOW_TYPE,
 218                                                               GTK_SHADOW_OUT,
 219                                                               GTK_PARAM_READABLE));
 220
 221   gtk_widget_class_install_style_property (widget_class,
 222                                            g_param_spec_int ("internal-padding",
 223                                                              P_("Internal padding"),
 224                                                              P_("Amount of border space between the menubar shadow and the menu items"),
 225                                                              0,
 226                                                              G_MAXINT,
 227                                                              DEFAULT_IPADDING,
 228                                                              GTK_PARAM_READABLE));
 229
 230   g_type_class_add_private (gobject_class, sizeof (GtkMenuBarPrivate));
 231 }
 232
 233 static void
 234 gtk_menu_bar_init (GtkMenuBar *menu_bar)
 235 {
 236   GtkStyleContext *context;
 237
 238   menu_bar->priv = G_TYPE_INSTANCE_GET_PRIVATE (menu_bar,
 239                                                 GTK_TYPE_MENU_BAR,
 240                                                 GtkMenuBarPrivate);
 241
 242   context = gtk_widget_get_style_context (GTK_WIDGET (menu_bar));
 243   gtk_style_context_add_class (context, GTK_STYLE_CLASS_MENUBAR);
 244 }
 245
 246 /**
 247  * gtk_menu_bar_new:
 248  *
 249  * Creates a new #GtkMenuBar
 250  *
 251  * Returns: the new menu bar, as a #GtkWidget
 252  */
 253 GtkWidget*
 254 gtk_menu_bar_new (void)
 255 {
 256   return g_object_new (GTK_TYPE_MENU_BAR, NULL);
 257 }
 258
 259 static void
 260 gtk_menu_bar_set_property (GObject      *object,
 261                            guint         prop_id,
 262                            const GValue *value,
 263                            GParamSpec   *pspec)
 264 {
 265   GtkMenuBar *menubar = GTK_MENU_BAR (object);
 266
 267   switch (prop_id)
 268     {
 269     case PROP_PACK_DIRECTION:
 270       gtk_menu_bar_set_pack_direction (menubar, g_value_get_enum (value));
 271       break;
 272     case PROP_CHILD_PACK_DIRECTION:
 273       gtk_menu_bar_set_child_pack_direction (menubar, g_value_get_enum (value));
 274       break;
 275     default:
 276       G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
 277       break;
 278     }
 279 }
 280
 281 static void
 282 gtk_menu_bar_get_property (GObject    *object,
 283                            guint       prop_id,
 284                            GValue     *value,
 285                            GParamSpec *pspec)
 286 {
 287   GtkMenuBar *menubar = GTK_MENU_BAR (object);
 288
 289   switch (prop_id)
 290     {
 291     case PROP_PACK_DIRECTION:
 292       g_value_set_enum (value, gtk_menu_bar_get_pack_direction (menubar));
 293       break;
 294     case PROP_CHILD_PACK_DIRECTION:
 295       g_value_set_enum (value, gtk_menu_bar_get_child_pack_direction (menubar));
 296       break;
 297     default:
 298       G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
 299       break;
 300     }
 301 }
 302
 303 static void
 304 get_preferred_size_for_size (GtkWidget      *widget,
 305                              GtkOrientation  orientation,
 306                              gint            size,
 307                              gint           *minimum,
 308                              gint           *natural)
 309 {
 310   if (orientation == GTK_ORIENTATION_HORIZONTAL)
 311     if (size < 0)
 312       gtk_widget_get_preferred_width (widget, minimum, natural);
 313     else
 314       gtk_widget_get_preferred_width_for_height (widget, size, minimum, natural);
 315   else
 316     if (size < 0)
 317       gtk_widget_get_preferred_height (widget, minimum, natural);
 318     else
 319       gtk_widget_get_preferred_height_for_width (widget, size, minimum, natural);
 320 }
 321
 322 static void
 323 gtk_menu_bar_size_request (GtkWidget      *widget,
 324                            GtkOrientation  orientation,
 325                            gint            size,
 326                            gint           *minimum,
 327                            gint           *natural)
 328 {
 329   GtkMenuBar *menu_bar;
 330   GtkMenuBarPrivate *priv;
 331   GtkMenuShell *menu_shell;
 332   GtkWidget *child;
 333   GList *children;
 334   gint ipadding;
 335   guint border_width;
 336   gboolean use_toggle_size, use_maximize;
 337   gint child_minimum, child_natural;
 338
 339   *minimum = 0;
 340   *natural = 0;
 341
 342   menu_bar = GTK_MENU_BAR (widget);
 343   menu_shell = GTK_MENU_SHELL (widget);
 344   priv = menu_bar->priv;
 345
 346   children = menu_shell->priv->children;
 347
 348   if (priv->child_pack_direction == GTK_PACK_DIRECTION_LTR ||
 349       priv->child_pack_direction == GTK_PACK_DIRECTION_RTL)
 350     use_toggle_size = (orientation == GTK_ORIENTATION_HORIZONTAL);
 351   else
 352     use_toggle_size = (orientation == GTK_ORIENTATION_VERTICAL);
 353
 354   if (priv->pack_direction == GTK_PACK_DIRECTION_LTR ||
 355       priv->pack_direction == GTK_PACK_DIRECTION_RTL)
 356     use_maximize = (orientation == GTK_ORIENTATION_VERTICAL);
 357   else
 358     use_maximize = (orientation == GTK_ORIENTATION_HORIZONTAL);
 359
 360   while (children)
 361     {
 362       child = children->data;
 363       children = children->next;
 364
 365       if (gtk_widget_get_visible (child))
 366         {
 367           get_preferred_size_for_size (child, orientation, size, &child_minimum, &child_natural);
 368
 369           if (use_toggle_size)
 370             {
 371               gint toggle_size;
 372
 373               gtk_menu_item_toggle_size_request (GTK_MENU_ITEM (child),
 374                                                  &toggle_size);
 375
 376               child_minimum += toggle_size;
 377               child_natural += toggle_size;
 378             }
 379
 380           if (use_maximize)
 381             {
 382               *minimum = MAX (*minimum, child_minimum);
 383               *natural = MAX (*natural, child_natural);
 384             }
 385           else
 386             {
 387               *minimum += child_minimum;
 388               *natural += child_natural;
 389             }
 390         }
 391     }
 392
 393   gtk_widget_style_get (widget, "internal-padding", &ipadding, NULL);
 394   border_width = gtk_container_get_border_width (GTK_CONTAINER (menu_bar));
 395   *minimum += (border_width + ipadding + BORDER_SPACING) * 2;
 396   *natural += (border_width + ipadding + BORDER_SPACING) * 2;
 397
 398   if (get_shadow_type (menu_bar) != GTK_SHADOW_NONE)
 399     {
 400       GtkStyleContext *context;
 401       GtkBorder border;
 402
 403       context = gtk_widget_get_style_context (widget);
 404       gtk_style_context_get_border (context, gtk_widget_get_state_flags (widget),
 405                                     &border);
 406
 407       if (orientation == GTK_ORIENTATION_HORIZONTAL)
 408         {
 409           *minimum += border.left + border.right;
 410           *natural += border.left + border.right;
 411         }
 412       else
 413         {
 414           *minimum += border.top + border.bottom;
 415           *natural += border.top + border.bottom;
 416         }
 417     }
 418 }
 419
 420 static void
 421 gtk_menu_bar_get_preferred_width (GtkWidget *widget,
 422                                   gint      *minimum,
 423                                   gint      *natural)
 424 {
 425   gtk_menu_bar_size_request (widget, GTK_ORIENTATION_HORIZONTAL, -1, minimum, natural);
 426 }
 427
 428 static void
 429 gtk_menu_bar_get_preferred_height (GtkWidget *widget,
 430                                    gint      *minimum,
 431                                    gint      *natural)
 432 {
 433   gtk_menu_bar_size_request (widget, GTK_ORIENTATION_VERTICAL, -1, minimum, natural);
 434 }
 435
 436 static void
 437 gtk_menu_bar_get_preferred_width_for_height (GtkWidget *widget,
 438                                              gint       height,
 439                                              gint      *minimum,
 440                                              gint      *natural)
 441 {
 442   gtk_menu_bar_size_request (widget, GTK_ORIENTATION_HORIZONTAL, height, minimum, natural);
 443 }
 444
 445 static void
 446 gtk_menu_bar_get_preferred_height_for_width (GtkWidget *widget,
 447                                              gint       width,
 448                                              gint      *minimum,
 449                                              gint      *natural)
 450 {
 451   gtk_menu_bar_size_request (widget, GTK_ORIENTATION_VERTICAL, width, minimum, natural);
 452 }
 453
 454 static void
 455 gtk_menu_bar_size_allocate (GtkWidget     *widget,
 456                             GtkAllocation *allocation)
 457 {
 458   GtkMenuBar *menu_bar;
 459   GtkMenuShell *menu_shell;
 460   GtkMenuBarPrivate *priv;
 461   GtkWidget *child;
 462   GList *children;
 463   GtkAllocation remaining_space;
 464   gint ipadding;
 465   guint border_width;
 466   GArray *requested_sizes;
 467   gint toggle_size;
 468   guint i;
 469
 470   g_return_if_fail (GTK_IS_MENU_BAR (widget));
 471   g_return_if_fail (allocation != NULL);
 472
 473   menu_bar = GTK_MENU_BAR (widget);
 474   menu_shell = GTK_MENU_SHELL (widget);
 475   priv = menu_bar->priv;
 476
 477   gtk_widget_set_allocation (widget, allocation);
 478
 479   if (gtk_widget_get_realized (widget))
 480     gdk_window_move_resize (gtk_widget_get_window (widget),
 481                             allocation->x, allocation->y,
 482                             allocation->width, allocation->height);
 483
 484   if (menu_shell->priv->children)
 485     {
 486       gtk_widget_style_get (widget, "internal-padding", &ipadding, NULL);
 487
 488       border_width = gtk_container_get_border_width (GTK_CONTAINER (menu_bar));
 489       remaining_space.x = (border_width +
 490                             ipadding +
 491                             BORDER_SPACING);
 492       remaining_space.y = (border_width +
 493                             ipadding +
 494                             BORDER_SPACING);
 495       remaining_space.width = allocation->width -
 496                                2 * (border_width + ipadding + BORDER_SPACING);
 497       remaining_space.height = allocation->height -
 498                                 2 * (border_width + ipadding + BORDER_SPACING);
 499
 500       if (get_shadow_type (menu_bar) != GTK_SHADOW_NONE)
 501         {
 502           GtkStyleContext *context;
 503           GtkBorder border;
 504
 505           context = gtk_widget_get_style_context (widget);
 506           gtk_style_context_get_border (context, gtk_widget_get_state_flags (widget),
 507                                         &border);
 508
 509           remaining_space.x += border.left;
 510           remaining_space.y += border.top;
 511           remaining_space.width -= border.left + border.right;
 512           remaining_space.height -= border.top + border.bottom;
 513         }
 514
 515       requested_sizes = g_array_new (FALSE, FALSE, sizeof (GtkRequestedSize));
 516
 517       if (priv->pack_direction == GTK_PACK_DIRECTION_LTR ||
 518           priv->pack_direction == GTK_PACK_DIRECTION_RTL)
 519         {
 520           int size = remaining_space.width;
 521           gboolean ltr = (gtk_widget_get_direction (widget) == GTK_TEXT_DIR_LTR) == (priv->pack_direction == GTK_PACK_DIRECTION_LTR);
 522
 523           for (children = menu_shell->priv->children; children; children = children->next)
 524             {
 525               GtkRequestedSize request;
 526               child = children->data;
 527
 528               if (!gtk_widget_get_visible (child))
 529                 continue;
 530
 531               request.data = child;
 532               gtk_widget_get_preferred_width_for_height (child,
 533                                                          remaining_space.height,
 534                                                          &request.minimum_size,
 535                                                          &request.natural_size);
 536               gtk_menu_item_toggle_size_request (GTK_MENU_ITEM (child),
 537                                                  &toggle_size);
 538               request.minimum_size += toggle_size;
 539               request.natural_size += toggle_size;
 540
 541               gtk_menu_item_toggle_size_allocate (GTK_MENU_ITEM (child), toggle_size);
 542
 543               g_array_append_val (requested_sizes, request);
 544
 545               size -= request.minimum_size;
 546             }
 547
 548           size = gtk_distribute_natural_allocation (size,
 549                                                     requested_sizes->len,
 550                                                     (GtkRequestedSize *) requested_sizes->data);
 551
 552           for (i = 0; i < requested_sizes->len; i++)
 553             {
 554               GtkAllocation child_allocation = remaining_space;
 555               GtkRequestedSize *request = &g_array_index (requested_sizes, GtkRequestedSize, i);
 556
 557               child_allocation.width = request->minimum_size;
 558               remaining_space.width -= request->minimum_size;
 559
 560               if (i + 1 == requested_sizes->len && GTK_IS_MENU_ITEM (request->data) &&
 561                   GTK_MENU_ITEM (request->data)->priv->right_justify)
 562                 ltr = !ltr;
 563
 564               if (ltr)
 565                 remaining_space.x += request->minimum_size;
 566               else
 567                 child_allocation.x += remaining_space.width;
 568
 569               gtk_widget_size_allocate (request->data, &child_allocation);
 570             }
 571         }
 572       else
 573         {
 574           int size = remaining_space.height;
 575           gboolean ttb = (priv->pack_direction == GTK_PACK_DIRECTION_TTB);
 576
 577           for (children = menu_shell->priv->children; children; children = children->next)
 578             {
 579               GtkRequestedSize request;
 580               child = children->data;
 581
 582               if (!gtk_widget_get_visible (child))
 583                 continue;
 584
 585               request.data = child;
 586               gtk_widget_get_preferred_height_for_width (child,
 587                                                          remaining_space.width,
 588                                                          &request.minimum_size,
 589                                                          &request.natural_size);
 590               gtk_menu_item_toggle_size_request (GTK_MENU_ITEM (child),
 591                                                  &toggle_size);
 592               request.minimum_size += toggle_size;
 593               request.natural_size += toggle_size;
 594
 595               gtk_menu_item_toggle_size_allocate (GTK_MENU_ITEM (child), toggle_size);
 596
 597               g_array_append_val (requested_sizes, request);
 598
 599               size -= request.minimum_size;
 600             }
 601
 602           size = gtk_distribute_natural_allocation (size,
 603                                                     requested_sizes->len,
 604                                                     (GtkRequestedSize *) requested_sizes->data);
 605
 606           for (i = 0; i < requested_sizes->len; i++)
 607             {
 608               GtkAllocation child_allocation = remaining_space;
 609               GtkRequestedSize *request = &g_array_index (requested_sizes, GtkRequestedSize, i);
 610
 611               child_allocation.height = request->minimum_size;
 612               remaining_space.height -= request->minimum_size;
 613
 614               if (i + 1 == requested_sizes->len && GTK_IS_MENU_ITEM (request->data) &&
 615                   GTK_MENU_ITEM (request->data)->priv->right_justify)
 616                 ttb = !ttb;
 617
 618               if (ttb)
 619                 remaining_space.y += request->minimum_size;
 620               else
 621                 child_allocation.y += remaining_space.height;
 622
 623               gtk_widget_size_allocate (request->data, &child_allocation);
 624             }
 625         }
 626
 627       g_array_free (requested_sizes, TRUE);
 628     }
 629 }
 630
 631 static gint
 632 gtk_menu_bar_draw (GtkWidget *widget,
 633                    cairo_t   *cr)
 634 {
 635   GtkStyleContext *context;
 636   GtkStateFlags state;
 637   int border;
 638
 639   border = gtk_container_get_border_width (GTK_CONTAINER (widget));
 640   context = gtk_widget_get_style_context (widget);
 641
 642   state = gtk_widget_get_state_flags (widget);
 643   gtk_style_context_set_state (context, state);
 644
 645   if (get_shadow_type (GTK_MENU_BAR (widget)) != GTK_SHADOW_NONE)
 646     gtk_render_background (context, cr,
 647                            border, border,
 648                            gtk_widget_get_allocated_width (widget) - border * 2,
 649                            gtk_widget_get_allocated_height (widget) - border * 2);
 650
 651   gtk_render_frame (context, cr,
 652                     border, border,
 653                     gtk_widget_get_allocated_width (widget) - border * 2,
 654                     gtk_widget_get_allocated_height (widget) - border * 2);
 655
 656   GTK_WIDGET_CLASS (gtk_menu_bar_parent_class)->draw (widget, cr);
 657
 658   return FALSE;
 659 }
 660
 661 static GList *
 662 get_menu_bars (GtkWindow *window)
 663 {
 664   return g_object_get_data (G_OBJECT (window), "gtk-menu-bar-list");
 665 }
 666
 667 static GList *
 668 get_viewable_menu_bars (GtkWindow *window)
 669 {
 670   GList *menu_bars;
 671   GList *viewable_menu_bars = NULL;
 672
 673   for (menu_bars = get_menu_bars (window);
 674        menu_bars;
 675        menu_bars = menu_bars->next)
 676     {
 677       GtkWidget *widget = menu_bars->data;
 678       gboolean viewable = TRUE;
 679
 680       while (widget)
 681         {
 682           if (!gtk_widget_get_mapped (widget))
 683             viewable = FALSE;
 684
 685           widget = gtk_widget_get_parent (widget);
 686         }
 687
 688       if (viewable)
 689         viewable_menu_bars = g_list_prepend (viewable_menu_bars, menu_bars->data);
 690     }
 691
 692   return g_list_reverse (viewable_menu_bars);
 693 }
 694
 695 static void
 696 set_menu_bars (GtkWindow *window,
 697                GList     *menubars)
 698 {
 699   g_object_set_data (G_OBJECT (window), I_("gtk-menu-bar-list"), menubars);
 700 }
 701
 702 static gboolean
 703 window_key_press_handler (GtkWidget   *widget,
 704                           GdkEventKey *event,
 705                           gpointer     data)
 706 {
 707   gchar *accel = NULL;
 708   gboolean retval = FALSE;
 709
 710   g_object_get (gtk_widget_get_settings (widget),
 711                 "gtk-menu-bar-accel", &accel,
 712                 NULL);
 713
 714   if (accel && *accel)
 715     {
 716       guint keyval = 0;
 717       GdkModifierType mods = 0;
 718
 719       gtk_accelerator_parse (accel, &keyval, &mods);
 720
 721       if (keyval == 0)
 722         g_warning ("Failed to parse menu bar accelerator '%s'\n", accel);
 723
 724       /* FIXME this is wrong, needs to be in the global accel resolution
 725        * thing, to properly consider i18n etc., but that probably requires
 726        * AccelGroup changes etc.
 727        */
 728       if (event->keyval == keyval &&
 729           ((event->state & gtk_accelerator_get_default_mod_mask ()) ==
 730            (mods & gtk_accelerator_get_default_mod_mask ())))
 731         {
 732           GList *tmp_menubars = get_viewable_menu_bars (GTK_WINDOW (widget));
 733           GList *menubars;
 734
 735           menubars = _gtk_container_focus_sort (GTK_CONTAINER (widget), tmp_menubars,
 736                                                 GTK_DIR_TAB_FORWARD, NULL);
 737           g_list_free (tmp_menubars);
 738
 739           if (menubars)
 740             {
 741               GtkMenuShell *menu_shell = GTK_MENU_SHELL (menubars->data);
 742
 743               _gtk_menu_shell_set_keyboard_mode (menu_shell, TRUE);
 744               gtk_menu_shell_select_first (menu_shell, FALSE);
 745
 746               g_list_free (menubars);
 747
 748               retval = TRUE;
 749             }
 750         }
 751     }
 752
 753   g_free (accel);
 754
 755   return retval;
 756 }
 757
 758 static void
 759 add_to_window (GtkWindow  *window,
 760                GtkMenuBar *menubar)
 761 {
 762   GList *menubars = get_menu_bars (window);
 763
 764   if (!menubars)
 765     {
 766       g_signal_connect (window,
 767                         "key-press-event",
 768                         G_CALLBACK (window_key_press_handler),
 769                         NULL);
 770     }
 771
 772   set_menu_bars (window, g_list_prepend (menubars, menubar));
 773 }
 774
 775 static void
 776 remove_from_window (GtkWindow  *window,
 777                     GtkMenuBar *menubar)
 778 {
 779   GList *menubars = get_menu_bars (window);
 780
 781   menubars = g_list_remove (menubars, menubar);
 782
 783   if (!menubars)
 784     {
 785       g_signal_handlers_disconnect_by_func (window,
 786                                             window_key_press_handler,
 787                                             NULL);
 788     }
 789
 790   set_menu_bars (window, menubars);
 791 }
 792
 793 static void
 794 gtk_menu_bar_hierarchy_changed (GtkWidget *widget,
 795                                 GtkWidget *old_toplevel)
 796 {
 797   GtkWidget *toplevel;
 798   GtkMenuBar *menubar;
 799
 800   menubar = GTK_MENU_BAR (widget);
 801
 802   toplevel = gtk_widget_get_toplevel (widget);
 803
 804   if (old_toplevel)
 805     remove_from_window (GTK_WINDOW (old_toplevel), menubar);
 806
 807   if (gtk_widget_is_toplevel (toplevel))
 808     add_to_window (GTK_WINDOW (toplevel), menubar);
 809 }
 810
 811 /**
 812  * _gtk_menu_bar_cycle_focus:
 813  * @menubar: a #GtkMenuBar
 814  * @dir: direction in which to cycle the focus
 815  *
 816  * Move the focus between menubars in the toplevel.
 817  **/
 818 void
 819 _gtk_menu_bar_cycle_focus (GtkMenuBar       *menubar,
 820                            GtkDirectionType  dir)
 821 {
 822   GtkWidget *toplevel = gtk_widget_get_toplevel (GTK_WIDGET (menubar));
 823   GtkMenuItem *to_activate = NULL;
 824
 825   if (gtk_widget_is_toplevel (toplevel))
 826     {
 827       GList *tmp_menubars = get_viewable_menu_bars (GTK_WINDOW (toplevel));
 828       GList *menubars;
 829       GList *current;
 830
 831       menubars = _gtk_container_focus_sort (GTK_CONTAINER (toplevel), tmp_menubars,
 832                                             dir, GTK_WIDGET (menubar));
 833       g_list_free (tmp_menubars);
 834
 835       if (menubars)
 836         {
 837           current = g_list_find (menubars, menubar);
 838
 839           if (current && current->next)
 840             {
 841               GtkMenuShell *new_menushell = GTK_MENU_SHELL (current->next->data);
 842               if (new_menushell->priv->children)
 843                 to_activate = new_menushell->priv->children->data;
 844             }
 845         }
 846
 847       g_list_free (menubars);
 848     }
 849
 850   gtk_menu_shell_cancel (GTK_MENU_SHELL (menubar));
 851
 852   if (to_activate)
 853     g_signal_emit_by_name (to_activate, "activate_item");
 854 }
 855
 856 static GtkShadowType
 857 get_shadow_type (GtkMenuBar *menubar)
 858 {
 859   GtkShadowType shadow_type = GTK_SHADOW_OUT;
 860
 861   gtk_widget_style_get (GTK_WIDGET (menubar),
 862                         "shadow-type", &shadow_type,
 863                         NULL);
 864
 865   return shadow_type;
 866 }
 867
 868 static gint
 869 gtk_menu_bar_get_popup_delay (GtkMenuShell *menu_shell)
 870 {
 871   gint popup_delay;
 872
 873   g_object_get (gtk_widget_get_settings (GTK_WIDGET (menu_shell)),
 874                 "gtk-menu-bar-popup-delay", &popup_delay,
 875                 NULL);
 876
 877   return popup_delay;
 878 }
 879
 880 static void
 881 gtk_menu_bar_move_current (GtkMenuShell         *menu_shell,
 882                            GtkMenuDirectionType  direction)
 883 {
 884   GtkMenuBar *menubar = GTK_MENU_BAR (menu_shell);
 885   GtkTextDirection text_dir;
 886   GtkPackDirection pack_dir;
 887
 888   text_dir = gtk_widget_get_direction (GTK_WIDGET (menubar));
 889   pack_dir = gtk_menu_bar_get_pack_direction (menubar);
 890
 891   if (pack_dir == GTK_PACK_DIRECTION_LTR || pack_dir == GTK_PACK_DIRECTION_RTL)
 892      {
 893       if ((text_dir == GTK_TEXT_DIR_RTL) == (pack_dir == GTK_PACK_DIRECTION_LTR))
 894         {
 895           switch (direction)
 896             {
 897             case GTK_MENU_DIR_PREV:
 898               direction = GTK_MENU_DIR_NEXT;
 899               break;
 900             case GTK_MENU_DIR_NEXT:
 901               direction = GTK_MENU_DIR_PREV;
 902               break;
 903             default: ;
 904             }
 905         }
 906     }
 907   else
 908     {
 909       switch (direction)
 910         {
 911         case GTK_MENU_DIR_PARENT:
 912           if ((text_dir == GTK_TEXT_DIR_LTR) == (pack_dir == GTK_PACK_DIRECTION_TTB))
 913             direction = GTK_MENU_DIR_PREV;
 914           else
 915             direction = GTK_MENU_DIR_NEXT;
 916           break;
 917         case GTK_MENU_DIR_CHILD:
 918           if ((text_dir == GTK_TEXT_DIR_LTR) == (pack_dir == GTK_PACK_DIRECTION_TTB))
 919             direction = GTK_MENU_DIR_NEXT;
 920           else
 921             direction = GTK_MENU_DIR_PREV;
 922           break;
 923         case GTK_MENU_DIR_PREV:
 924           if (text_dir == GTK_TEXT_DIR_RTL)
 925             direction = GTK_MENU_DIR_CHILD;
 926           else
 927             direction = GTK_MENU_DIR_PARENT;
 928           break;
 929         case GTK_MENU_DIR_NEXT:
 930           if (text_dir == GTK_TEXT_DIR_RTL)
 931             direction = GTK_MENU_DIR_PARENT;
 932           else
 933             direction = GTK_MENU_DIR_CHILD;
 934           break;
 935         default: ;
 936         }
 937     }
 938
 939   GTK_MENU_SHELL_CLASS (gtk_menu_bar_parent_class)->move_current (menu_shell, direction);
 940 }
 941
 942 /**
 943  * gtk_menu_bar_get_pack_direction:
 944  * @menubar: a #GtkMenuBar
 945  *
 946  * Retrieves the current pack direction of the menubar.
 947  * See gtk_menu_bar_set_pack_direction().
 948  *
 949  * Return value: the pack direction
 950  *
 951  * Since: 2.8
 952  */
 953 GtkPackDirection
 954 gtk_menu_bar_get_pack_direction (GtkMenuBar *menubar)
 955 {
 956   g_return_val_if_fail (GTK_IS_MENU_BAR (menubar),
 957                         GTK_PACK_DIRECTION_LTR);
 958
 959   return menubar->priv->pack_direction;
 960 }
 961
 962 /**
 963  * gtk_menu_bar_set_pack_direction:
 964  * @menubar: a #GtkMenuBar
 965  * @pack_dir: a new #GtkPackDirection
 966  *
 967  * Sets how items should be packed inside a menubar.
 968  *
 969  * Since: 2.8
 970  */
 971 void
 972 gtk_menu_bar_set_pack_direction (GtkMenuBar       *menubar,
 973                                  GtkPackDirection  pack_dir)
 974 {
 975   GtkMenuBarPrivate *priv;
 976   GList *l;
 977
 978   g_return_if_fail (GTK_IS_MENU_BAR (menubar));
 979
 980   priv = menubar->priv;
 981
 982   if (priv->pack_direction != pack_dir)
 983     {
 984       priv->pack_direction = pack_dir;
 985
 986       gtk_widget_queue_resize (GTK_WIDGET (menubar));
 987
 988       for (l = GTK_MENU_SHELL (menubar)->priv->children; l; l = l->next)
 989         gtk_widget_queue_resize (GTK_WIDGET (l->data));
 990
 991       g_object_notify (G_OBJECT (menubar), "pack-direction");
 992     }
 993 }
 994
 995 /**
 996  * gtk_menu_bar_get_child_pack_direction:
 997  * @menubar: a #GtkMenuBar
 998  *
 999  * Retrieves the current child pack direction of the menubar.
1000  * See gtk_menu_bar_set_child_pack_direction().
1001  *
1002  * Return value: the child pack direction
1003  *
1004  * Since: 2.8
1005  */
1006 GtkPackDirection
1007 gtk_menu_bar_get_child_pack_direction (GtkMenuBar *menubar)
1008 {
1009   g_return_val_if_fail (GTK_IS_MENU_BAR (menubar),
1010                         GTK_PACK_DIRECTION_LTR);
1011
1012   return menubar->priv->child_pack_direction;
1013 }
1014
1015 /**
1016  * gtk_menu_bar_set_child_pack_direction:
1017  * @menubar: a #GtkMenuBar
1018  * @child_pack_dir: a new #GtkPackDirection
1019  *
1020  * Sets how widgets should be packed inside the children of a menubar.
1021  *
1022  * Since: 2.8
1023  */
1024 void
1025 gtk_menu_bar_set_child_pack_direction (GtkMenuBar       *menubar,
1026                                        GtkPackDirection  child_pack_dir)
1027 {
1028   GtkMenuBarPrivate *priv;
1029   GList *l;
1030
1031   g_return_if_fail (GTK_IS_MENU_BAR (menubar));
1032
1033   priv = menubar->priv;
1034
1035   if (priv->child_pack_direction != child_pack_dir)
1036     {
1037       priv->child_pack_direction = child_pack_dir;
1038
1039       gtk_widget_queue_resize (GTK_WIDGET (menubar));
1040
1041       for (l = GTK_MENU_SHELL (menubar)->priv->children; l; l = l->next)
1042         gtk_widget_queue_resize (GTK_WIDGET (l->data));
1043
1044       g_object_notify (G_OBJECT (menubar), "child-pack-direction");
1045     }
1046 }