/* GTK - The GIMP Toolkit

 * Copyright (C) 1995-1997 Peter Mattis, Spencer Kimball and Josh MacDonald

 *

 * This library is free software; you can redistribute it and/or

 * modify it under the terms of the GNU Lesser General Public

 * License as published by the Free Software Foundation; either

 * version 2 of the License, or (at your option) any later version.

 *

 * This library is distributed in the hope that it will be useful,

 * but WITHOUT ANY WARRANTY; without even the implied warranty of

 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU

 * Lesser General Public License for more details.

 *

 * You should have received a copy of the GNU Lesser General Public

 * License along with this library; if not, write to the

 * Free Software Foundation, Inc., 59 Temple Place - Suite 330,

 * Boston, MA 02111-1307, USA.

 */

/*

 * Modified by the GTK+ Team and others 1997-2000.  See the AUTHORS

 * file for a list of people on the GTK+ Team.  See the ChangeLog

 * files for a list of changes.  These files are distributed with

 * GTK+ at ftp://ftp.gtk.org/pub/gtk/. 

 */

#define GTK_MENU_INTERNALS

#include "config.h"

#include "gdk/gdkkeysyms.h"

#include "gtkbindings.h"

#include "gtkmain.h"

#include "gtkmarshalers.h"

#include "gtkmenubar.h"

#include "gtkmenuitem.h"

#include "gtksettings.h"

#include "gtkintl.h"

#include "gtkwindow.h"

#include "gtkprivate.h"

#include "gtkalias.h"

#define BORDER_SPACING  0

#define DEFAULT_IPADDING 1

/* Properties */

enum {

  PROP_0,

  PROP_PACK_DIRECTION,

  PROP_CHILD_PACK_DIRECTION

};

typedef struct _GtkMenuBarPrivate GtkMenuBarPrivate;

struct _GtkMenuBarPrivate

{

  GtkPackDirection pack_direction;

  GtkPackDirection child_pack_direction;

};

#define GTK_MENU_BAR_GET_PRIVATE(o)  \

  (G_TYPE_INSTANCE_GET_PRIVATE ((o), GTK_TYPE_MENU_BAR, GtkMenuBarPrivate))

static void gtk_menu_bar_set_property      (GObject             *object,

					    guint                prop_id,

					    const GValue        *value,

					    GParamSpec          *pspec);

static void gtk_menu_bar_get_property      (GObject             *object,

					    guint                prop_id,

					    GValue              *value,

					    GParamSpec          *pspec);

static void gtk_menu_bar_size_request      (GtkWidget       *widget,

					    GtkRequisition  *requisition);

static void gtk_menu_bar_size_allocate     (GtkWidget       *widget,

					    GtkAllocation   *allocation);

static void gtk_menu_bar_paint             (GtkWidget       *widget,

					    GdkRectangle    *area);

static gint gtk_menu_bar_expose            (GtkWidget       *widget,

					    GdkEventExpose  *event);

static void gtk_menu_bar_hierarchy_changed (GtkWidget       *widget,

					    GtkWidget       *old_toplevel);

static gint gtk_menu_bar_get_popup_delay   (GtkMenuShell    *menu_shell);

static void gtk_menu_bar_move_current      (GtkMenuShell     *menu_shell,

                                            GtkMenuDirectionType direction);

static GtkShadowType get_shadow_type   (GtkMenuBar      *menubar);

G_DEFINE_TYPE (GtkMenuBar, gtk_menu_bar, GTK_TYPE_MENU_SHELL)

static void

gtk_menu_bar_class_init (GtkMenuBarClass *class)

{

  GObjectClass *gobject_class;

  GtkWidgetClass *widget_class;

  GtkMenuShellClass *menu_shell_class;

  GtkBindingSet *binding_set;

  gobject_class = (GObjectClass*) class;

  widget_class = (GtkWidgetClass*) class;

  menu_shell_class = (GtkMenuShellClass*) class;

  gobject_class->get_property = gtk_menu_bar_get_property;

  gobject_class->set_property = gtk_menu_bar_set_property;

  widget_class->size_request = gtk_menu_bar_size_request;

  widget_class->size_allocate = gtk_menu_bar_size_allocate;

  widget_class->expose_event = gtk_menu_bar_expose;

  widget_class->hierarchy_changed = gtk_menu_bar_hierarchy_changed;

  menu_shell_class->submenu_placement = GTK_TOP_BOTTOM;

  menu_shell_class->get_popup_delay = gtk_menu_bar_get_popup_delay;

  menu_shell_class->move_current = gtk_menu_bar_move_current;

  binding_set = gtk_binding_set_by_class (class);

  gtk_binding_entry_add_signal (binding_set,

				GDK_Left, 0,

				"move-current", 1,

				GTK_TYPE_MENU_DIRECTION_TYPE,

				GTK_MENU_DIR_PREV);

  gtk_binding_entry_add_signal (binding_set,

				GDK_KP_Left, 0,

				"move-current", 1,

				GTK_TYPE_MENU_DIRECTION_TYPE,

				GTK_MENU_DIR_PREV);

  gtk_binding_entry_add_signal (binding_set,

				GDK_Right, 0,

				"move-current", 1,

				GTK_TYPE_MENU_DIRECTION_TYPE,

				GTK_MENU_DIR_NEXT);

  gtk_binding_entry_add_signal (binding_set,

				GDK_KP_Right, 0,

				"move-current", 1,

				GTK_TYPE_MENU_DIRECTION_TYPE,

				GTK_MENU_DIR_NEXT);

  gtk_binding_entry_add_signal (binding_set,

				GDK_Up, 0,

				"move-current", 1,

				GTK_TYPE_MENU_DIRECTION_TYPE,

				GTK_MENU_DIR_PARENT);

  gtk_binding_entry_add_signal (binding_set,

				GDK_KP_Up, 0,

				"move-current", 1,

				GTK_TYPE_MENU_DIRECTION_TYPE,

				GTK_MENU_DIR_PARENT);

  gtk_binding_entry_add_signal (binding_set,

				GDK_Down, 0,

				"move-current", 1,

				GTK_TYPE_MENU_DIRECTION_TYPE,

				GTK_MENU_DIR_CHILD);

  gtk_binding_entry_add_signal (binding_set,

				GDK_KP_Down, 0,

				"move-current", 1,

				GTK_TYPE_MENU_DIRECTION_TYPE,

				GTK_MENU_DIR_CHILD);

  /**

   * GtkMenuBar:pack-direction:

   *

   * The pack direction of the menubar. It determines how

   * menuitems are arranged in the menubar.

   *

   * Since: 2.8

   */

  g_object_class_install_property (gobject_class,

				   PROP_PACK_DIRECTION,

				   g_param_spec_enum ("pack-direction",

 						      P_("Pack direction"),

 						      P_("The pack direction of the menubar"),

 						      GTK_TYPE_PACK_DIRECTION,

 						      GTK_PACK_DIRECTION_LTR,

 						      GTK_PARAM_READWRITE));

  /**

   * GtkMenuBar:child-pack-direction:

   *

   * The child pack direction of the menubar. It determines how

   * the widgets contained in child menuitems are arranged.

   *

   * Since: 2.8

   */

  g_object_class_install_property (gobject_class,

				   PROP_CHILD_PACK_DIRECTION,

				   g_param_spec_enum ("child-pack-direction",

 						      P_("Child Pack direction"),

 						      P_("The child pack direction of the menubar"),

 						      GTK_TYPE_PACK_DIRECTION,

 						      GTK_PACK_DIRECTION_LTR,

 						      GTK_PARAM_READWRITE));

  gtk_widget_class_install_style_property (widget_class,

					   g_param_spec_enum ("shadow-type",

                                                              P_("Shadow type"),

                                                              P_("Style of bevel around the menubar"),

                                                              GTK_TYPE_SHADOW_TYPE,

                                                              GTK_SHADOW_OUT,

                                                              GTK_PARAM_READABLE));

  gtk_widget_class_install_style_property (widget_class,

					   g_param_spec_int ("internal-padding",

							     P_("Internal padding"),

							     P_("Amount of border space between the menubar shadow and the menu items"),

							     0,

							     G_MAXINT,

                                                             DEFAULT_IPADDING,

                                                             GTK_PARAM_READABLE));

  g_type_class_add_private (gobject_class, sizeof (GtkMenuBarPrivate));

}

static void

gtk_menu_bar_init (GtkMenuBar *object)

{

}

GtkWidget*

gtk_menu_bar_new (void)

{

  return g_object_new (GTK_TYPE_MENU_BAR, NULL);

}

static void

gtk_menu_bar_set_property (GObject      *object,

			   guint         prop_id,

			   const GValue *value,

			   GParamSpec   *pspec)

{

  GtkMenuBar *menubar = GTK_MENU_BAR (object);

  switch (prop_id)

    {

    case PROP_PACK_DIRECTION:

      gtk_menu_bar_set_pack_direction (menubar, g_value_get_enum (value));

      break;

    case PROP_CHILD_PACK_DIRECTION:

      gtk_menu_bar_set_child_pack_direction (menubar, g_value_get_enum (value));

      break;

    default:

      G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);

      break;

    }

}

static void

gtk_menu_bar_get_property (GObject    *object,

			   guint       prop_id,

			   GValue     *value,

			   GParamSpec *pspec)

{

  GtkMenuBar *menubar = GTK_MENU_BAR (object);

  switch (prop_id)

    {

    case PROP_PACK_DIRECTION:

      g_value_set_enum (value, gtk_menu_bar_get_pack_direction (menubar));

      break;

    case PROP_CHILD_PACK_DIRECTION:

      g_value_set_enum (value, gtk_menu_bar_get_child_pack_direction (menubar));

      break;

    default:

      G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);

      break;

    }

}

static void

gtk_menu_bar_size_request (GtkWidget      *widget,

			   GtkRequisition *requisition)

{

  GtkMenuBar *menu_bar;

  GtkMenuBarPrivate *priv;

  GtkMenuShell *menu_shell;

  GtkWidget *child;

  GList *children;

  gint nchildren;

  GtkRequisition child_requisition;

  gint ipadding;

  g_return_if_fail (GTK_IS_MENU_BAR (widget));

  g_return_if_fail (requisition != NULL);

  requisition->width = 0;

  requisition->height = 0;

  if (gtk_widget_get_visible (widget))

    {

      menu_bar = GTK_MENU_BAR (widget);

      menu_shell = GTK_MENU_SHELL (widget);

      priv = GTK_MENU_BAR_GET_PRIVATE (menu_bar);

      nchildren = 0;

      children = menu_shell->children;

      while (children)

	{

	  child = children->data;

	  children = children->next;

	  if (gtk_widget_get_visible (child))

	    {

              gint toggle_size;

	      GTK_MENU_ITEM (child)->show_submenu_indicator = FALSE;

	      gtk_widget_size_request (child, &child_requisition);

              gtk_menu_item_toggle_size_request (GTK_MENU_ITEM (child),

                                                 &toggle_size);

	      if (priv->child_pack_direction == GTK_PACK_DIRECTION_LTR ||

		  priv->child_pack_direction == GTK_PACK_DIRECTION_RTL)

		child_requisition.width += toggle_size;

	      else

		child_requisition.height += toggle_size;

              if (priv->pack_direction == GTK_PACK_DIRECTION_LTR ||

		  priv->pack_direction == GTK_PACK_DIRECTION_RTL)

		{

		  requisition->width += child_requisition.width;

		  requisition->height = MAX (requisition->height, child_requisition.height);

		}

	      else

		{

		  requisition->width = MAX (requisition->width, child_requisition.width);

		  requisition->height += child_requisition.height;

		}

	      nchildren += 1;

	    }

	}

      gtk_widget_style_get (widget, "internal-padding", &ipadding, NULL);

      requisition->width += (GTK_CONTAINER (menu_bar)->border_width +

                             ipadding + 

			     BORDER_SPACING) * 2;

      requisition->height += (GTK_CONTAINER (menu_bar)->border_width +

                              ipadding +

			      BORDER_SPACING) * 2;

      if (get_shadow_type (menu_bar) != GTK_SHADOW_NONE)

	{

	  requisition->width += widget->style->xthickness * 2;

	  requisition->height += widget->style->ythickness * 2;

	}

    }

}

static void

gtk_menu_bar_size_allocate (GtkWidget     *widget,

			    GtkAllocation *allocation)

{

  GtkMenuBar *menu_bar;

  GtkMenuShell *menu_shell;

  GtkMenuBarPrivate *priv;

  GtkWidget *child;

  GList *children;

  GtkAllocation child_allocation;

  GtkRequisition child_requisition;

  guint offset;

  GtkTextDirection direction;

  gint ltr_x, ltr_y;

  gint ipadding;

  g_return_if_fail (GTK_IS_MENU_BAR (widget));

  g_return_if_fail (allocation != NULL);

  menu_bar = GTK_MENU_BAR (widget);

  menu_shell = GTK_MENU_SHELL (widget);

  priv = GTK_MENU_BAR_GET_PRIVATE (menu_bar);

  direction = gtk_widget_get_direction (widget);

  widget->allocation = *allocation;

  if (gtk_widget_get_realized (widget))

    gdk_window_move_resize (widget->window,

			    allocation->x, allocation->y,

			    allocation->width, allocation->height);

  gtk_widget_style_get (widget, "internal-padding", &ipadding, NULL);

  if (menu_shell->children)

    {

      child_allocation.x = (GTK_CONTAINER (menu_bar)->border_width +

			    ipadding + 

			    BORDER_SPACING);

      child_allocation.y = (GTK_CONTAINER (menu_bar)->border_width +

			    BORDER_SPACING);

      if (get_shadow_type (menu_bar) != GTK_SHADOW_NONE)

	{

	  child_allocation.x += widget->style->xthickness;

	  child_allocation.y += widget->style->ythickness;

	}

      if (priv->pack_direction == GTK_PACK_DIRECTION_LTR ||

	  priv->pack_direction == GTK_PACK_DIRECTION_RTL)

	{

	  child_allocation.height = MAX (1, (gint)allocation->height - child_allocation.y * 2);

	  offset = child_allocation.x; 	/* Window edge to menubar start */

	  ltr_x = child_allocation.x;

	  children = menu_shell->children;

	  while (children)

	    {

	      gint toggle_size;          

	      child = children->data;

	      children = children->next;

	      gtk_menu_item_toggle_size_request (GTK_MENU_ITEM (child),

						 &toggle_size);

	      gtk_widget_get_child_requisition (child, &child_requisition);

	      if (priv->child_pack_direction == GTK_PACK_DIRECTION_LTR ||

		  priv->child_pack_direction == GTK_PACK_DIRECTION_RTL)

		child_requisition.width += toggle_size;

	      else

		child_requisition.height += toggle_size;

	      /* Support for the right justified help menu */

	      if ((children == NULL) && (GTK_IS_MENU_ITEM(child))

		  && (GTK_MENU_ITEM(child)->right_justify)) 

		{

		  ltr_x = allocation->width -

		    child_requisition.width - offset;

		}

	      if (gtk_widget_get_visible (child))

		{

		  if ((direction == GTK_TEXT_DIR_LTR) == (priv->pack_direction == GTK_PACK_DIRECTION_LTR))

		    child_allocation.x = ltr_x;

		  else

		    child_allocation.x = allocation->width -

		      child_requisition.width - ltr_x; 

		  child_allocation.width = child_requisition.width;

		  gtk_menu_item_toggle_size_allocate (GTK_MENU_ITEM (child),

						      toggle_size);

		  gtk_widget_size_allocate (child, &child_allocation);

		  ltr_x += child_allocation.width;

		}

	    }

	}

      else

	{

	  child_allocation.width = MAX (1, (gint)allocation->width - child_allocation.x * 2);

	  offset = child_allocation.y; 	/* Window edge to menubar start */

	  ltr_y = child_allocation.y;

	  children = menu_shell->children;

	  while (children)

	    {

	      gint toggle_size;          

	      child = children->data;

	      children = children->next;

	      gtk_menu_item_toggle_size_request (GTK_MENU_ITEM (child),

						 &toggle_size);

	      gtk_widget_get_child_requisition (child, &child_requisition);

	      if (priv->child_pack_direction == GTK_PACK_DIRECTION_LTR ||

		  priv->child_pack_direction == GTK_PACK_DIRECTION_RTL)

		child_requisition.width += toggle_size;

	      else

		child_requisition.height += toggle_size;

	      /* Support for the right justified help menu */

	      if ((children == NULL) && (GTK_IS_MENU_ITEM(child))

		  && (GTK_MENU_ITEM(child)->right_justify)) 

		{

		  ltr_y = allocation->height -

		    child_requisition.height - offset;

		}

	      if (gtk_widget_get_visible (child))

		{

		  if ((direction == GTK_TEXT_DIR_LTR) ==

		      (priv->pack_direction == GTK_PACK_DIRECTION_TTB))

		    child_allocation.y = ltr_y;

		  else

		    child_allocation.y = allocation->height -

		      child_requisition.height - ltr_y; 

		  child_allocation.height = child_requisition.height;

		  gtk_menu_item_toggle_size_allocate (GTK_MENU_ITEM (child),

						      toggle_size);

		  gtk_widget_size_allocate (child, &child_allocation);

		  ltr_y += child_allocation.height;

		}

	    }

	}

    }

}

static void

gtk_menu_bar_paint (GtkWidget    *widget,

                    GdkRectangle *area)

{

  g_return_if_fail (GTK_IS_MENU_BAR (widget));

  if (gtk_widget_is_drawable (widget))

    {

      gint border;

      border = GTK_CONTAINER (widget)->border_width;

      gtk_paint_box (widget->style,

		     widget->window,

                     gtk_widget_get_state (widget),

                     get_shadow_type (GTK_MENU_BAR (widget)),

		     area, widget, "menubar",

		     border, border,

		     widget->allocation.width - border * 2,

                     widget->allocation.height - border * 2);

    }

}

static gint

gtk_menu_bar_expose (GtkWidget      *widget,

		     GdkEventExpose *event)

{

  g_return_val_if_fail (GTK_IS_MENU_BAR (widget), FALSE);

  g_return_val_if_fail (event != NULL, FALSE);

  if (gtk_widget_is_drawable (widget))

    {

      gtk_menu_bar_paint (widget, &event->area);

      GTK_WIDGET_CLASS (gtk_menu_bar_parent_class)->expose_event (widget, event);

    }

  return FALSE;

}

static GList *

get_menu_bars (GtkWindow *window)

{

  return g_object_get_data (G_OBJECT (window), "gtk-menu-bar-list");

}

static GList *

get_viewable_menu_bars (GtkWindow *window)

{

  GList *menu_bars;

  GList *viewable_menu_bars = NULL;

  for (menu_bars = get_menu_bars (window);

       menu_bars;

       menu_bars = menu_bars->next)

    {

      GtkWidget *widget = menu_bars->data;

      gboolean viewable = TRUE;

      while (widget)

	{

	  if (!gtk_widget_get_mapped (widget))

	    viewable = FALSE;

	  widget = widget->parent;

	}

      if (viewable)

	viewable_menu_bars = g_list_prepend (viewable_menu_bars, menu_bars->data);

    }

  return g_list_reverse (viewable_menu_bars);

}

static void

set_menu_bars (GtkWindow *window,

	       GList     *menubars)

{

  g_object_set_data (G_OBJECT (window), I_("gtk-menu-bar-list"), menubars);

}

static gboolean

window_key_press_handler (GtkWidget   *widget,

                          GdkEventKey *event,

                          gpointer     data)

{

  gchar *accel = NULL;

  gboolean retval = FALSE;

  g_object_get (gtk_widget_get_settings (widget),

                "gtk-menu-bar-accel", &accel,

                NULL);

  if (accel && *accel)

    {

      guint keyval = 0;

      GdkModifierType mods = 0;

      gtk_accelerator_parse (accel, &keyval, &mods;;

      if (keyval == 0)

        g_warning ("Failed to parse menu bar accelerator '%s'\n", accel);

      /* FIXME this is wrong, needs to be in the global accel resolution

       * thing, to properly consider i18n etc., but that probably requires

       * AccelGroup changes etc.

       */

      if (event->keyval == keyval &&

          ((event->state & gtk_accelerator_get_default_mod_mask ()) ==

	   (mods & gtk_accelerator_get_default_mod_mask ())))

        {

	  GList *tmp_menubars = get_viewable_menu_bars (GTK_WINDOW (widget));

	  GList *menubars;

	  menubars = _gtk_container_focus_sort (GTK_CONTAINER (widget), tmp_menubars,

						GTK_DIR_TAB_FORWARD, NULL);

	  g_list_free (tmp_menubars);

	  if (menubars)

	    {

	      GtkMenuShell *menu_shell = GTK_MENU_SHELL (menubars->data);

              _gtk_menu_shell_set_keyboard_mode (menu_shell, TRUE);

	      gtk_menu_shell_select_first (menu_shell, FALSE);

	      g_list_free (menubars);

	      retval = TRUE;	      

	    }

        }

    }

  g_free (accel);

  return retval;

}

static void

add_to_window (GtkWindow  *window,

               GtkMenuBar *menubar)

{

  GList *menubars = get_menu_bars (window);

  if (!menubars)

    {

      g_signal_connect (window,

			"key-press-event",

			G_CALLBACK (window_key_press_handler),

			NULL);

    }

  set_menu_bars (window, g_list_prepend (menubars, menubar));

}

static void

remove_from_window (GtkWindow  *window,

                    GtkMenuBar *menubar)

{

  GList *menubars = get_menu_bars (window);

  menubars = g_list_remove (menubars, menubar);

  if (!menubars)

    {

      g_signal_handlers_disconnect_by_func (window,

					    window_key_press_handler,

					    NULL);

    }

  set_menu_bars (window, menubars);

}

static void

gtk_menu_bar_hierarchy_changed (GtkWidget *widget,

				GtkWidget *old_toplevel)

{

  GtkWidget *toplevel;  

  GtkMenuBar *menubar;

  menubar = GTK_MENU_BAR (widget);

  toplevel = gtk_widget_get_toplevel (widget);

  if (old_toplevel)

    remove_from_window (GTK_WINDOW (old_toplevel), menubar);

  if (gtk_widget_is_toplevel (toplevel))

    add_to_window (GTK_WINDOW (toplevel), menubar);

}

/**

 * _gtk_menu_bar_cycle_focus:

 * @menubar: a #GtkMenuBar

 * @dir: direction in which to cycle the focus

 * 

 * Move the focus between menubars in the toplevel.

 **/

void

_gtk_menu_bar_cycle_focus (GtkMenuBar       *menubar,

			   GtkDirectionType  dir)

{

  GtkWidget *toplevel = gtk_widget_get_toplevel (GTK_WIDGET (menubar));

  GtkMenuItem *to_activate = NULL;

  if (gtk_widget_is_toplevel (toplevel))

    {

      GList *tmp_menubars = get_viewable_menu_bars (GTK_WINDOW (toplevel));

      GList *menubars;

      GList *current;

      menubars = _gtk_container_focus_sort (GTK_CONTAINER (toplevel), tmp_menubars,

					    dir, GTK_WIDGET (menubar));

      g_list_free (tmp_menubars);

      if (menubars)

	{

	  current = g_list_find (menubars, menubar);

	  if (current && current->next)

	    {

	      GtkMenuShell *new_menushell = GTK_MENU_SHELL (current->next->data);

	      if (new_menushell->children)

		to_activate = new_menushell->children->data;

	    }

	}

      g_list_free (menubars);

    }

  gtk_menu_shell_cancel (GTK_MENU_SHELL (menubar));

  if (to_activate)

    g_signal_emit_by_name (to_activate, "activate_item");

}

static GtkShadowType

get_shadow_type (GtkMenuBar *menubar)

{

  GtkShadowType shadow_type = GTK_SHADOW_OUT;

  gtk_widget_style_get (GTK_WIDGET (menubar),

			"shadow-type", &shadow_type,

			NULL);

  return shadow_type;

}

static gint

gtk_menu_bar_get_popup_delay (GtkMenuShell *menu_shell)

{

  gint popup_delay;

  g_object_get (gtk_widget_get_settings (GTK_WIDGET (menu_shell)),

		"gtk-menu-bar-popup-delay", &popup_delay,

		NULL);

  return popup_delay;

}

static void

gtk_menu_bar_move_current (GtkMenuShell         *menu_shell,

			   GtkMenuDirectionType  direction)

{

  GtkMenuBar *menubar = GTK_MENU_BAR (menu_shell);

  GtkTextDirection text_dir;

  GtkPackDirection pack_dir;

  text_dir = gtk_widget_get_direction (GTK_WIDGET (menubar));

  pack_dir = gtk_menu_bar_get_pack_direction (menubar);

  if (pack_dir == GTK_PACK_DIRECTION_LTR || pack_dir == GTK_PACK_DIRECTION_RTL)

     {

      if ((text_dir == GTK_TEXT_DIR_RTL) == (pack_dir == GTK_PACK_DIRECTION_LTR))

	{

	  switch (direction) 

	    {      

	    case GTK_MENU_DIR_PREV:

	      direction = GTK_MENU_DIR_NEXT;

	      break;

	    case GTK_MENU_DIR_NEXT:

	      direction = GTK_MENU_DIR_PREV;

	      break;

	    default: ;

	    }

	}

    }

  else

    {

      switch (direction) 

	{

	case GTK_MENU_DIR_PARENT:

	  if ((text_dir == GTK_TEXT_DIR_LTR) == (pack_dir == GTK_PACK_DIRECTION_TTB))

	    direction = GTK_MENU_DIR_PREV;

	  else

	    direction = GTK_MENU_DIR_NEXT;

	  break;

	case GTK_MENU_DIR_CHILD:

	  if ((text_dir == GTK_TEXT_DIR_LTR) == (pack_dir == GTK_PACK_DIRECTION_TTB))

	    direction = GTK_MENU_DIR_NEXT;

	  else

	    direction = GTK_MENU_DIR_PREV;

	  break;

	case GTK_MENU_DIR_PREV:

	  if (text_dir == GTK_TEXT_DIR_RTL)	  

	    direction = GTK_MENU_DIR_CHILD;

	  else

	    direction = GTK_MENU_DIR_PARENT;

	  break;

	case GTK_MENU_DIR_NEXT:

	  if (text_dir == GTK_TEXT_DIR_RTL)	  

	    direction = GTK_MENU_DIR_PARENT;

	  else

	    direction = GTK_MENU_DIR_CHILD;

	  break;

	default: ;

	}

    }

  GTK_MENU_SHELL_CLASS (gtk_menu_bar_parent_class)->move_current (menu_shell, direction);

}

/**

 * gtk_menu_bar_get_pack_direction:

 * @menubar: a #GtkMenuBar

 * 

 * Retrieves the current pack direction of the menubar. 

 * See gtk_menu_bar_set_pack_direction().

 *

 * Return value: the pack direction

 *

 * Since: 2.8

 */

GtkPackDirection

gtk_menu_bar_get_pack_direction (GtkMenuBar *menubar)

{

  GtkMenuBarPrivate *priv;

  g_return_val_if_fail (GTK_IS_MENU_BAR (menubar), 

			GTK_PACK_DIRECTION_LTR);

  priv = GTK_MENU_BAR_GET_PRIVATE (menubar);

  return priv->pack_direction;

}

/**

 * gtk_menu_bar_set_pack_direction:

 * @menubar: a #GtkMenuBar

 * @pack_dir: a new #GtkPackDirection

 * 

 * Sets how items should be packed inside a menubar.

 * 

 * Since: 2.8

 */

void

gtk_menu_bar_set_pack_direction (GtkMenuBar       *menubar,

                                 GtkPackDirection  pack_dir)

{

  GtkMenuBarPrivate *priv;

  GList *l;

  g_return_if_fail (GTK_IS_MENU_BAR (menubar));

  priv = GTK_MENU_BAR_GET_PRIVATE (menubar);

  if (priv->pack_direction != pack_dir)

    {

      priv->pack_direction = pack_dir;

      gtk_widget_queue_resize (GTK_WIDGET (menubar));

      for (l = GTK_MENU_SHELL (menubar)->children; l; l = l->next)

	gtk_widget_queue_resize (GTK_WIDGET (l->data));

      g_object_notify (G_OBJECT (menubar), "pack-direction");

    }

}

/**

 * gtk_menu_bar_get_child_pack_direction:

 * @menubar: a #GtkMenuBar

 * 

 * Retrieves the current child pack direction of the menubar.