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
 405       gtk_style_context_get (context, 0,
 406                              "border-width", &border,
 407                              NULL);
 408
 409       if (orientation == GTK_ORIENTATION_HORIZONTAL)
 410         {
 411           *minimum += border->left + border->right;
 412           *natural += border->left + border->right;
 413         }
 414       else
 415         {
 416           *minimum += border->top + border->bottom;
 417           *natural += border->top + border->bottom;
 418         }
 419       gtk_border_free (border);
 420     }
 421 }
 422
 423 static void
 424 gtk_menu_bar_get_preferred_width (GtkWidget *widget,
 425                                   gint      *minimum,
 426                                   gint      *natural)
 427 {
 428   gtk_menu_bar_size_request (widget, GTK_ORIENTATION_HORIZONTAL, -1, minimum, natural);
 429 }
 430
 431 static void
 432 gtk_menu_bar_get_preferred_height (GtkWidget *widget,
 433                                    gint      *minimum,
 434                                    gint      *natural)
 435 {
 436   gtk_menu_bar_size_request (widget, GTK_ORIENTATION_VERTICAL, -1, minimum, natural);
 437 }
 438
 439 static void
 440 gtk_menu_bar_get_preferred_width_for_height (GtkWidget *widget,
 441                                              gint       height,
 442                                              gint      *minimum,
 443                                              gint      *natural)
 444 {
 445   gtk_menu_bar_size_request (widget, GTK_ORIENTATION_HORIZONTAL, height, minimum, natural);
 446 }
 447
 448 static void
 449 gtk_menu_bar_get_preferred_height_for_width (GtkWidget *widget,
 450                                              gint       width,
 451                                              gint      *minimum,
 452                                              gint      *natural)
 453 {
 454   gtk_menu_bar_size_request (widget, GTK_ORIENTATION_VERTICAL, width, minimum, natural);
 455 }
 456
 457 static void
 458 gtk_menu_bar_size_allocate (GtkWidget     *widget,
 459                             GtkAllocation *allocation)
 460 {
 461   GtkMenuBar *menu_bar;
 462   GtkMenuShell *menu_shell;
 463   GtkMenuBarPrivate *priv;
 464   GtkWidget *child;
 465   GList *children;
 466   GtkAllocation remaining_space;
 467   gint ipadding;
 468   guint border_width;
 469   GArray *requested_sizes;
 470   gint toggle_size;
 471   guint i;
 472
 473   g_return_if_fail (GTK_IS_MENU_BAR (widget));
 474   g_return_if_fail (allocation != NULL);
 475
 476   menu_bar = GTK_MENU_BAR (widget);
 477   menu_shell = GTK_MENU_SHELL (widget);
 478   priv = menu_bar->priv;
 479
 480   gtk_widget_set_allocation (widget, allocation);
 481
 482   if (gtk_widget_get_realized (widget))
 483     gdk_window_move_resize (gtk_widget_get_window (widget),
 484                             allocation->x, allocation->y,
 485                             allocation->width, allocation->height);
 486
 487   if (menu_shell->priv->children)
 488     {
 489       gtk_widget_style_get (widget, "internal-padding", &ipadding, NULL);
 490
 491       border_width = gtk_container_get_border_width (GTK_CONTAINER (menu_bar));
 492       remaining_space.x = (border_width +
 493                             ipadding +
 494                             BORDER_SPACING);
 495       remaining_space.y = (border_width +
 496                             ipadding +
 497                             BORDER_SPACING);
 498       remaining_space.width = allocation->width -
 499                                2 * (border_width + ipadding + BORDER_SPACING);
 500       remaining_space.height = allocation->height -
 501                                 2 * (border_width + ipadding + BORDER_SPACING);
 502
 503       if (get_shadow_type (menu_bar) != GTK_SHADOW_NONE)
 504         {
 505           GtkStyleContext *context;
 506           GtkBorder *border;
 507
 508           context = gtk_widget_get_style_context (widget);
 509           gtk_style_context_get (context, 0,
 510                                  "border-width", &border,
 511                                  NULL);
 512
 513           remaining_space.x += border->left;
 514           remaining_space.y += border->top;
 515           remaining_space.width -= border->left + border->right;
 516           remaining_space.height -= border->top + border->bottom;
 517
 518           gtk_border_free (border);
 519         }
 520
 521       requested_sizes = g_array_new (FALSE, FALSE, sizeof (GtkRequestedSize));
 522
 523       if (priv->pack_direction == GTK_PACK_DIRECTION_LTR ||
 524           priv->pack_direction == GTK_PACK_DIRECTION_RTL)
 525         {
 526           int size = remaining_space.width;
 527           gboolean ltr = (gtk_widget_get_direction (widget) == GTK_TEXT_DIR_LTR) == (priv->pack_direction == GTK_PACK_DIRECTION_LTR);
 528
 529           for (children = menu_shell->priv->children; children; children = children->next)
 530             {
 531               GtkRequestedSize request;
 532               child = children->data;
 533
 534               if (!gtk_widget_get_visible (child))
 535                 continue;
 536
 537               request.data = child;
 538               gtk_widget_get_preferred_width_for_height (child,
 539                                                          remaining_space.height,
 540                                                          &request.minimum_size,
 541                                                          &request.natural_size);
 542               gtk_menu_item_toggle_size_request (GTK_MENU_ITEM (child),
 543                                                  &toggle_size);
 544               request.minimum_size += toggle_size;
 545               request.natural_size += toggle_size;
 546
 547               gtk_menu_item_toggle_size_allocate (GTK_MENU_ITEM (child), toggle_size);
 548
 549               g_array_append_val (requested_sizes, request);
 550
 551               size -= request.minimum_size;
 552             }
 553
 554           size = gtk_distribute_natural_allocation (size,
 555                                                     requested_sizes->len,
 556                                                     (GtkRequestedSize *) requested_sizes->data);
 557
 558           for (i = 0; i < requested_sizes->len; i++)
 559             {
 560               GtkAllocation child_allocation = remaining_space;
 561               GtkRequestedSize *request = &g_array_index (requested_sizes, GtkRequestedSize, i);
 562
 563               child_allocation.width = request->minimum_size;
 564               remaining_space.width -= request->minimum_size;
 565
 566               if (i + 1 == requested_sizes->len && GTK_IS_MENU_ITEM (request->data) &&
 567                   gtk_menu_item_get_right_justified (request->data))
 568                 ltr = !ltr;
 569
 570               if (ltr)
 571                 remaining_space.x += request->minimum_size;
 572               else
 573                 child_allocation.x += remaining_space.width;
 574
 575               gtk_widget_size_allocate (request->data, &child_allocation);
 576             }
 577         }
 578       else
 579         {
 580           int size = remaining_space.height;
 581           gboolean ttb = (priv->pack_direction == GTK_PACK_DIRECTION_TTB);
 582
 583           for (children = menu_shell->priv->children; children; children = children->next)
 584             {
 585               GtkRequestedSize request;
 586               child = children->data;
 587
 588               if (!gtk_widget_get_visible (child))
 589                 continue;
 590
 591               request.data = child;
 592               gtk_widget_get_preferred_height_for_width (child,
 593                                                          remaining_space.width,
 594                                                          &request.minimum_size,
 595                                                          &request.natural_size);
 596               gtk_menu_item_toggle_size_request (GTK_MENU_ITEM (child),
 597                                                  &toggle_size);
 598               request.minimum_size += toggle_size;
 599               request.natural_size += toggle_size;
 600
 601               gtk_menu_item_toggle_size_allocate (GTK_MENU_ITEM (child), toggle_size);
 602
 603               g_array_append_val (requested_sizes, request);
 604
 605               size -= request.minimum_size;
 606             }
 607
 608           size = gtk_distribute_natural_allocation (size,
 609                                                     requested_sizes->len,
 610                                                     (GtkRequestedSize *) requested_sizes->data);
 611
 612           for (i = 0; i < requested_sizes->len; i++)
 613             {
 614               GtkAllocation child_allocation = remaining_space;
 615               GtkRequestedSize *request = &g_array_index (requested_sizes, GtkRequestedSize, i);
 616
 617               child_allocation.height = request->minimum_size;
 618               remaining_space.height -= request->minimum_size;
 619
 620               if (i + 1 == requested_sizes->len && GTK_IS_MENU_ITEM (request->data) &&
 621                   gtk_menu_item_get_right_justified (request->data))
 622                 ttb = !ttb;
 623
 624               if (ttb)
 625                 remaining_space.y += request->minimum_size;
 626               else
 627                 child_allocation.y += remaining_space.height;
 628
 629               gtk_widget_size_allocate (request->data, &child_allocation);
 630             }
 631         }
 632
 633       g_array_free (requested_sizes, TRUE);
 634     }
 635 }
 636
 637 static gint
 638 gtk_menu_bar_draw (GtkWidget *widget,
 639                    cairo_t   *cr)
 640 {
 641   GtkStyleContext *context;
 642   GtkStateFlags state;
 643   int border;
 644
 645   border = gtk_container_get_border_width (GTK_CONTAINER (widget));
 646   context = gtk_widget_get_style_context (widget);
 647
 648   state = gtk_widget_get_state_flags (widget);
 649   gtk_style_context_set_state (context, state);
 650
 651   if (get_shadow_type (GTK_MENU_BAR (widget)) != GTK_SHADOW_NONE)
 652     gtk_render_background (context, cr,
 653                            border, border,
 654                            gtk_widget_get_allocated_width (widget) - border * 2,
 655                            gtk_widget_get_allocated_height (widget) - border * 2);
 656
 657   gtk_render_frame (context, cr,
 658                     border, border,
 659                     gtk_widget_get_allocated_width (widget) - border * 2,
 660                     gtk_widget_get_allocated_height (widget) - border * 2);
 661
 662   GTK_WIDGET_CLASS (gtk_menu_bar_parent_class)->draw (widget, cr);
 663
 664   return FALSE;
 665 }
 666
 667 static GList *
 668 get_menu_bars (GtkWindow *window)
 669 {
 670   return g_object_get_data (G_OBJECT (window), "gtk-menu-bar-list");
 671 }
 672
 673 static GList *
 674 get_viewable_menu_bars (GtkWindow *window)
 675 {
 676   GList *menu_bars;
 677   GList *viewable_menu_bars = NULL;
 678
 679   for (menu_bars = get_menu_bars (window);
 680        menu_bars;
 681        menu_bars = menu_bars->next)
 682     {
 683       GtkWidget *widget = menu_bars->data;
 684       gboolean viewable = TRUE;
 685
 686       while (widget)
 687         {
 688           if (!gtk_widget_get_mapped (widget))
 689             viewable = FALSE;
 690
 691           widget = gtk_widget_get_parent (widget);
 692         }
 693
 694       if (viewable)
 695         viewable_menu_bars = g_list_prepend (viewable_menu_bars, menu_bars->data);
 696     }
 697
 698   return g_list_reverse (viewable_menu_bars);
 699 }
 700
 701 static void
 702 set_menu_bars (GtkWindow *window,
 703                GList     *menubars)
 704 {
 705   g_object_set_data (G_OBJECT (window), I_("gtk-menu-bar-list"), menubars);
 706 }
 707
 708 static gboolean
 709 window_key_press_handler (GtkWidget   *widget,
 710                           GdkEventKey *event,
 711                           gpointer     data)
 712 {
 713   gchar *accel = NULL;
 714   gboolean retval = FALSE;
 715
 716   g_object_get (gtk_widget_get_settings (widget),
 717                 "gtk-menu-bar-accel", &accel,
 718                 NULL);
 719
 720   if (accel && *accel)
 721     {
 722       guint keyval = 0;
 723       GdkModifierType mods = 0;
 724
 725       gtk_accelerator_parse (accel, &keyval, &mods);
 726
 727       if (keyval == 0)
 728         g_warning ("Failed to parse menu bar accelerator '%s'\n", accel);
 729
 730       /* FIXME this is wrong, needs to be in the global accel resolution
 731        * thing, to properly consider i18n etc., but that probably requires
 732        * AccelGroup changes etc.
 733        */
 734       if (event->keyval == keyval &&
 735           ((event->state & gtk_accelerator_get_default_mod_mask ()) ==
 736            (mods & gtk_accelerator_get_default_mod_mask ())))
 737         {
 738           GList *tmp_menubars = get_viewable_menu_bars (GTK_WINDOW (widget));
 739           GList *menubars;
 740
 741           menubars = _gtk_container_focus_sort (GTK_CONTAINER (widget), tmp_menubars,
 742                                                 GTK_DIR_TAB_FORWARD, NULL);
 743           g_list_free (tmp_menubars);
 744
 745           if (menubars)
 746             {
 747               GtkMenuShell *menu_shell = GTK_MENU_SHELL (menubars->data);
 748
 749               _gtk_menu_shell_set_keyboard_mode (menu_shell, TRUE);
 750               gtk_menu_shell_select_first (menu_shell, FALSE);
 751
 752               g_list_free (menubars);
 753
 754               retval = TRUE;
 755             }
 756         }
 757     }
 758
 759   g_free (accel);
 760
 761   return retval;
 762 }
 763
 764 static void
 765 add_to_window (GtkWindow  *window,
 766                GtkMenuBar *menubar)
 767 {
 768   GList *menubars = get_menu_bars (window);
 769
 770   if (!menubars)
 771     {
 772       g_signal_connect (window,
 773                         "key-press-event",
 774                         G_CALLBACK (window_key_press_handler),
 775                         NULL);
 776     }
 777
 778   set_menu_bars (window, g_list_prepend (menubars, menubar));
 779 }
 780
 781 static void
 782 remove_from_window (GtkWindow  *window,
 783                     GtkMenuBar *menubar)
 784 {
 785   GList *menubars = get_menu_bars (window);
 786
 787   menubars = g_list_remove (menubars, menubar);
 788
 789   if (!menubars)
 790     {
 791       g_signal_handlers_disconnect_by_func (window,
 792                                             window_key_press_handler,
 793                                             NULL);
 794     }
 795
 796   set_menu_bars (window, menubars);
 797 }
 798
 799 static void
 800 gtk_menu_bar_hierarchy_changed (GtkWidget *widget,
 801                                 GtkWidget *old_toplevel)
 802 {
 803   GtkWidget *toplevel;
 804   GtkMenuBar *menubar;
 805
 806   menubar = GTK_MENU_BAR (widget);
 807
 808   toplevel = gtk_widget_get_toplevel (widget);
 809
 810   if (old_toplevel)
 811     remove_from_window (GTK_WINDOW (old_toplevel), menubar);
 812
 813   if (gtk_widget_is_toplevel (toplevel))
 814     add_to_window (GTK_WINDOW (toplevel), menubar);
 815 }
 816
 817 /**
 818  * _gtk_menu_bar_cycle_focus:
 819  * @menubar: a #GtkMenuBar
 820  * @dir: direction in which to cycle the focus
 821  *
 822  * Move the focus between menubars in the toplevel.
 823  **/
 824 void
 825 _gtk_menu_bar_cycle_focus (GtkMenuBar       *menubar,
 826                            GtkDirectionType  dir)
 827 {
 828   GtkWidget *toplevel = gtk_widget_get_toplevel (GTK_WIDGET (menubar));
 829   GtkMenuItem *to_activate = NULL;
 830
 831   if (gtk_widget_is_toplevel (toplevel))
 832     {
 833       GList *tmp_menubars = get_viewable_menu_bars (GTK_WINDOW (toplevel));
 834       GList *menubars;
 835       GList *current;
 836
 837       menubars = _gtk_container_focus_sort (GTK_CONTAINER (toplevel), tmp_menubars,
 838                                             dir, GTK_WIDGET (menubar));
 839       g_list_free (tmp_menubars);
 840
 841       if (menubars)
 842         {
 843           current = g_list_find (menubars, menubar);
 844
 845           if (current && current->next)
 846             {
 847               GtkMenuShell *new_menushell = GTK_MENU_SHELL (current->next->data);
 848               if (new_menushell->priv->children)
 849                 to_activate = new_menushell->priv->children->data;
 850             }
 851         }
 852
 853       g_list_free (menubars);
 854     }
 855
 856   gtk_menu_shell_cancel (GTK_MENU_SHELL (menubar));
 857
 858   if (to_activate)
 859     g_signal_emit_by_name (to_activate, "activate_item");
 860 }
 861
 862 static GtkShadowType
 863 get_shadow_type (GtkMenuBar *menubar)
 864 {
 865   GtkShadowType shadow_type = GTK_SHADOW_OUT;
 866
 867   gtk_widget_style_get (GTK_WIDGET (menubar),
 868                         "shadow-type", &shadow_type,
 869                         NULL);
 870
 871   return shadow_type;
 872 }
 873
 874 static gint
 875 gtk_menu_bar_get_popup_delay (GtkMenuShell *menu_shell)
 876 {
 877   gint popup_delay;
 878
 879   g_object_get (gtk_widget_get_settings (GTK_WIDGET (menu_shell)),
 880                 "gtk-menu-bar-popup-delay", &popup_delay,
 881                 NULL);
 882
 883   return popup_delay;
 884 }
 885
 886 static void
 887 gtk_menu_bar_move_current (GtkMenuShell         *menu_shell,
 888                            GtkMenuDirectionType  direction)
 889 {
 890   GtkMenuBar *menubar = GTK_MENU_BAR (menu_shell);
 891   GtkTextDirection text_dir;
 892   GtkPackDirection pack_dir;
 893
 894   text_dir = gtk_widget_get_direction (GTK_WIDGET (menubar));
 895   pack_dir = gtk_menu_bar_get_pack_direction (menubar);
 896
 897   if (pack_dir == GTK_PACK_DIRECTION_LTR || pack_dir == GTK_PACK_DIRECTION_RTL)
 898      {
 899       if ((text_dir == GTK_TEXT_DIR_RTL) == (pack_dir == GTK_PACK_DIRECTION_LTR))
 900         {
 901           switch (direction)
 902             {
 903             case GTK_MENU_DIR_PREV:
 904               direction = GTK_MENU_DIR_NEXT;
 905               break;
 906             case GTK_MENU_DIR_NEXT:
 907               direction = GTK_MENU_DIR_PREV;
 908               break;
 909             default: ;
 910             }
 911         }
 912     }
 913   else
 914     {
 915       switch (direction)
 916         {
 917         case GTK_MENU_DIR_PARENT:
 918           if ((text_dir == GTK_TEXT_DIR_LTR) == (pack_dir == GTK_PACK_DIRECTION_TTB))
 919             direction = GTK_MENU_DIR_PREV;
 920           else
 921             direction = GTK_MENU_DIR_NEXT;
 922           break;
 923         case GTK_MENU_DIR_CHILD:
 924           if ((text_dir == GTK_TEXT_DIR_LTR) == (pack_dir == GTK_PACK_DIRECTION_TTB))
 925             direction = GTK_MENU_DIR_NEXT;
 926           else
 927             direction = GTK_MENU_DIR_PREV;
 928           break;
 929         case GTK_MENU_DIR_PREV:
 930           if (text_dir == GTK_TEXT_DIR_RTL)
 931             direction = GTK_MENU_DIR_CHILD;
 932           else
 933             direction = GTK_MENU_DIR_PARENT;
 934           break;
 935         case GTK_MENU_DIR_NEXT:
 936           if (text_dir == GTK_TEXT_DIR_RTL)
 937             direction = GTK_MENU_DIR_PARENT;
 938           else
 939             direction = GTK_MENU_DIR_CHILD;
 940           break;
 941         default: ;
 942         }
 943     }
 944
 945   GTK_MENU_SHELL_CLASS (gtk_menu_bar_parent_class)->move_current (menu_shell, direction);
 946 }
 947
 948 /**
 949  * gtk_menu_bar_get_pack_direction:
 950  * @menubar: a #GtkMenuBar
 951  *
 952  * Retrieves the current pack direction of the menubar.
 953  * See gtk_menu_bar_set_pack_direction().
 954  *
 955  * Return value: the pack direction
 956  *
 957  * Since: 2.8
 958  */
 959 GtkPackDirection
 960 gtk_menu_bar_get_pack_direction (GtkMenuBar *menubar)
 961 {
 962   g_return_val_if_fail (GTK_IS_MENU_BAR (menubar),
 963                         GTK_PACK_DIRECTION_LTR);
 964
 965   return menubar->priv->pack_direction;
 966 }
 967
 968 /**
 969  * gtk_menu_bar_set_pack_direction:
 970  * @menubar: a #GtkMenuBar
 971  * @pack_dir: a new #GtkPackDirection
 972  *
 973  * Sets how items should be packed inside a menubar.
 974  *
 975  * Since: 2.8
 976  */
 977 void
 978 gtk_menu_bar_set_pack_direction (GtkMenuBar       *menubar,
 979                                  GtkPackDirection  pack_dir)
 980 {
 981   GtkMenuBarPrivate *priv;
 982   GList *l;
 983
 984   g_return_if_fail (GTK_IS_MENU_BAR (menubar));
 985
 986   priv = menubar->priv;
 987
 988   if (priv->pack_direction != pack_dir)
 989     {
 990       priv->pack_direction = pack_dir;
 991
 992       gtk_widget_queue_resize (GTK_WIDGET (menubar));
 993
 994       for (l = GTK_MENU_SHELL (menubar)->priv->children; l; l = l->next)
 995         gtk_widget_queue_resize (GTK_WIDGET (l->data));
 996
 997       g_object_notify (G_OBJECT (menubar), "pack-direction");
 998     }
 999 }
1000
1001 /**
1002  * gtk_menu_bar_get_child_pack_direction:
1003  * @menubar: a #GtkMenuBar
1004  *
1005  * Retrieves the current child pack direction of the menubar.
1006  * See gtk_menu_bar_set_child_pack_direction().
1007  *
1008  * Return value: the child pack direction
1009  *
1010  * Since: 2.8
1011  */
1012 GtkPackDirection
1013 gtk_menu_bar_get_child_pack_direction (GtkMenuBar *menubar)
1014 {
1015   g_return_val_if_fail (GTK_IS_MENU_BAR (menubar),
1016                         GTK_PACK_DIRECTION_LTR);
1017
1018   return menubar->priv->child_pack_direction;
1019 }
1020
1021 /**
1022  * gtk_menu_bar_set_child_pack_direction:
1023  * @menubar: a #GtkMenuBar
1024  * @child_pack_dir: a new #GtkPackDirection
1025  *
1026  * Sets how widgets should be packed inside the children of a menubar.
1027  *
1028  * Since: 2.8
1029  */
1030 void
1031 gtk_menu_bar_set_child_pack_direction (GtkMenuBar       *menubar,
1032                                        GtkPackDirection  child_pack_dir)
1033 {
1034   GtkMenuBarPrivate *priv;
1035   GList *l;
1036
1037   g_return_if_fail (GTK_IS_MENU_BAR (menubar));
1038
1039   priv = menubar->priv;
1040
1041   if (priv->child_pack_direction != child_pack_dir)
1042     {
1043       priv->child_pack_direction = child_pack_dir;
1044
1045       gtk_widget_queue_resize (GTK_WIDGET (menubar));
1046
1047       for (l = GTK_MENU_SHELL (menubar)->priv->children; l; l = l->next)
1048         gtk_widget_queue_resize (GTK_WIDGET (l->data));
1049
1050       g_object_notify (G_OBJECT (menubar), "child-pack-direction");
1051     }
1052 }