aboutsummaryrefslogtreecommitdiffstats
path: root/packages/gtk+/gtk+-2.6.4-1.osso7/gtkmenu.c.diff
diff options
context:
space:
mode:
authorKoen Kooi <koen@openembedded.org>2005-06-30 08:19:37 +0000
committerOpenEmbedded Project <openembedded-devel@lists.openembedded.org>2005-06-30 08:19:37 +0000
commitc8e5702127e507e82e6f68a4b8c546803accea9d (patch)
tree00583491f40ecc640f2b28452af995e3a63a09d7 /packages/gtk+/gtk+-2.6.4-1.osso7/gtkmenu.c.diff
parent87ec8ca4d2e2eb4d1c1e1e1a6b46a395d56805b9 (diff)
downloadopenembedded-c8e5702127e507e82e6f68a4b8c546803accea9d.tar.gz
openembedded-c8e5702127e507e82e6f68a4b8c546803accea9d.tar.bz2
openembedded-c8e5702127e507e82e6f68a4b8c546803accea9d.zip
import clean BK tree at cset 1.3670
Diffstat (limited to 'packages/gtk+/gtk+-2.6.4-1.osso7/gtkmenu.c.diff')
-rw-r--r--packages/gtk+/gtk+-2.6.4-1.osso7/gtkmenu.c.diff1223
1 files changed, 1223 insertions, 0 deletions
diff --git a/packages/gtk+/gtk+-2.6.4-1.osso7/gtkmenu.c.diff b/packages/gtk+/gtk+-2.6.4-1.osso7/gtkmenu.c.diff
index e69de29bb2..16fac1b155 100644
--- a/packages/gtk+/gtk+-2.6.4-1.osso7/gtkmenu.c.diff
+++ b/packages/gtk+/gtk+-2.6.4-1.osso7/gtkmenu.c.diff
@@ -0,0 +1,1223 @@
+--- gtk+-2.6.4/gtk/gtkmenu.c 2005-03-01 08:28:56.000000000 +0200
++++ gtk+-2.6.4/gtk/gtkmenu.c 2005-04-06 16:19:36.921925376 +0300
+@@ -24,10 +24,16 @@
+ * GTK+ at ftp://ftp.gtk.org/pub/gtk/.
+ */
+
++/* Modified for Nokia Oyj during 2002-2005. See CHANGES file for list
++ * of changes.
++ */
++
+ #define GTK_MENU_INTERNALS
+
+ #include <config.h>
+ #include <string.h> /* memset */
++#include <math.h>
++#include <stdlib.h>
+ #include "gdk/gdkkeysyms.h"
+ #include "gtkalias.h"
+ #include "gtkaccellabel.h"
+@@ -44,7 +50,11 @@
+ #include "gtkvscrollbar.h"
+ #include "gtksettings.h"
+ #include "gtkintl.h"
++#include "gtkcombobox.h"
+
++/* Hildon : We need this to figure out if menu should have
++ * corners etc. */
++#include "gtkmenubar.h"
+
+ #define MENU_ITEM_CLASS(w) GTK_MENU_ITEM_GET_CLASS (w)
+
+@@ -55,16 +65,43 @@
+ * extends below the submenu
+ */
+
++/* HILDON:
++ * Urgh, nasty thing to hard-code things like these :p
++ * One should really do some rewriting here...
++ */
++
+ #define MENU_SCROLL_STEP1 8
+ #define MENU_SCROLL_STEP2 15
+-#define MENU_SCROLL_ARROW_HEIGHT 16
+-#define MENU_SCROLL_FAST_ZONE 8
++#define MENU_SCROLL_ARROW_HEIGHT 20 /* This used to be: 23; This hard-coding should be
++ * changed. Add arrow_height style property into
++ * commongtkrc and read it from there everywhere
++ * where a reference to MENU_SCROLL_ARROW_HEIGHT
++ * is made.
++ * If these changes are made, please modify also
++ * gtkcombobox.c.
++ */
++#define MENU_SCROLL_FAST_ZONE MENU_SCROLL_ARROW_HEIGHT /* Was originally 8 */
+ #define MENU_SCROLL_TIMEOUT1 50
+ #define MENU_SCROLL_TIMEOUT2 20
+
+ #define ATTACH_INFO_KEY "gtk-menu-child-attach-info-key"
+ #define ATTACHED_MENUS "gtk-attached-menus"
+
++/* HILDON: */
++#define HILDON_MENU_NAME_SHARP "menu_with_corners"
++
++/* needed to allow different themeing for first level menus */
++#define HILDON_MENU_NAME_ROUND_FIRST_LEVEL "menu_without_corners_first_level"
++#define HILDON_MENU_NAME_ROUND "menu_without_corners"
++#define HILDON_MENU_NAME_FORCE_SHARP "menu_force_with_corners"
++#define HILDON_MENU_NAME_FORCE_ROUND "menu_force_without_corners"
++
++/* maximum sizes for menus when attached to comboboxes */
++#define HILDON_MENU_COMBO_MAX_WIDTH 406
++#define HILDON_MENU_COMBO_MIN_WIDTH 66
++#define HILDON_MENU_COMBO_MAX_HEIGHT 305
++#define HILDON_MENU_COMBO_MIN_HEIGHT 70
++
+ typedef struct _GtkMenuAttachData GtkMenuAttachData;
+ typedef struct _GtkMenuPrivate GtkMenuPrivate;
+
+@@ -92,6 +129,15 @@
+ gboolean have_layout;
+ gint n_rows;
+ gint n_columns;
++
++ /* Arrow states */
++ GtkStateType lower_arrow_state;
++ GtkStateType upper_arrow_state;
++
++ /* For context menu behavior */
++ gboolean context_menu;
++ int popup_pointer_x;
++ int popup_pointer_y;
+ };
+
+ typedef struct
+@@ -108,6 +154,7 @@
+
+ enum {
+ MOVE_SCROLL,
++ CLOSE_CURRENT,
+ LAST_SIGNAL
+ };
+
+@@ -191,7 +238,8 @@
+ static void gtk_menu_handle_scrolling (GtkMenu *menu,
+ gint event_x,
+ gint event_y,
+- gboolean enter);
++ gboolean enter,
++ gboolean motion);
+ static void gtk_menu_set_tearoff_hints (GtkMenu *menu,
+ gint width);
+ static void gtk_menu_style_set (GtkWidget *widget,
+@@ -232,6 +280,9 @@
+ guint signal_id);
+ static void _gtk_menu_refresh_accel_paths (GtkMenu *menu,
+ gboolean group_changed);
++static gboolean gtk_menu_check_name (GtkWidget *widget);
++
++static void _gtk_menu_close_current (GtkMenu *menu);
+
+ static GtkMenuShellClass *parent_class = NULL;
+ static const gchar attach_data_key[] = "gtk-menu-attach-data";
+@@ -496,7 +547,6 @@
+ widget_class->hide_all = gtk_menu_hide_all;
+ widget_class->enter_notify_event = gtk_menu_enter_notify;
+ widget_class->leave_notify_event = gtk_menu_leave_notify;
+- widget_class->motion_notify_event = gtk_menu_motion_notify;
+ widget_class->style_set = gtk_menu_style_set;
+ widget_class->focus = gtk_menu_focus;
+ widget_class->can_activate_accel = gtk_menu_real_can_activate_accel;
+@@ -521,6 +571,15 @@
+ _gtk_marshal_VOID__ENUM,
+ G_TYPE_NONE, 1,
+ GTK_TYPE_SCROLL_TYPE);
++
++ menu_signals[CLOSE_CURRENT] =
++ _gtk_binding_signal_new ("close_current",
++ G_OBJECT_CLASS_TYPE (object_class),
++ G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION,
++ G_CALLBACK (_gtk_menu_close_current),
++ NULL, NULL,
++ _gtk_marshal_VOID__VOID,
++ G_TYPE_NONE, 0);
+
+ g_object_class_install_property (gobject_class,
+ PROP_TEAROFF_TITLE,
+@@ -606,6 +665,11 @@
+ G_PARAM_READWRITE));
+
+ binding_set = gtk_binding_set_by_class (class);
++ /* Hildon : We moved handling of escape-key here because we need it to
++ * work like closing a submenu, not closing all the menus. */
++ gtk_binding_entry_add_signal (binding_set,
++ GDK_Escape, 0,
++ "close_current", 0);
+ gtk_binding_entry_add_signal (binding_set,
+ GDK_Up, 0,
+ "move_current", 1,
+@@ -709,6 +773,25 @@
+ DEFAULT_POPDOWN_DELAY,
+ G_PARAM_READWRITE));
+
++ /* Hildon addition : border width was
++ replaced with horizontal-padding and
++ vertical-padding (which already is an style
++ property for GtkMenu). */
++ gtk_widget_class_install_style_property (widget_class,
++ g_param_spec_int ("horizontal-padding",
++ P_("Horizontal Padding"),
++ P_("Extra space at the left and right edges of the menu"),
++ 0,
++ G_MAXINT,
++ 0, /* 1, */
++ G_PARAM_READABLE));
++
++ gtk_widget_class_install_style_property (widget_class,
++ g_param_spec_boolean ("double_arrows",
++ P_("Double Arrows"),
++ P_("When scrolling, always show both arrows."),
++ FALSE,
++ G_PARAM_READABLE));
+ }
+
+
+@@ -884,13 +967,14 @@
+ menu->toggle_size = 0;
+
+ menu->toplevel = g_object_connect (g_object_new (GTK_TYPE_WINDOW,
+- "type", GTK_WINDOW_POPUP,
+- "child", menu,
+- NULL),
++ "type", GTK_WINDOW_POPUP,
++ "child", menu,
++ NULL),
+ "signal::event", gtk_menu_window_event, menu,
+ "signal::size_request", gtk_menu_window_size_request, menu,
+ "signal::destroy", gtk_widget_destroyed, &menu->toplevel,
+ NULL);
++
+ gtk_window_set_resizable (GTK_WINDOW (menu->toplevel), FALSE);
+ gtk_window_set_mnemonic_modifier (GTK_WINDOW (menu->toplevel), 0);
+
+@@ -919,6 +1003,15 @@
+ menu->lower_arrow_visible = FALSE;
+ menu->upper_arrow_prelight = FALSE;
+ menu->lower_arrow_prelight = FALSE;
++
++ /* <Hildon> */
++ priv->upper_arrow_state = GTK_STATE_NORMAL;
++ priv->lower_arrow_state = GTK_STATE_NORMAL;
++
++ priv->context_menu = FALSE;
++ priv->popup_pointer_x = -1;
++ priv->popup_pointer_y = -1;
++ /* </hildon */
+
+ priv->have_layout = FALSE;
+ }
+@@ -1220,7 +1313,8 @@
+
+ static gboolean
+ popup_grab_on_window (GdkWindow *window,
+- guint32 activate_time)
++ guint32 activate_time,
++ gboolean grab_keyboard)
+ {
+ if ((gdk_pointer_grab (window, TRUE,
+ GDK_BUTTON_PRESS_MASK | GDK_BUTTON_RELEASE_MASK |
+@@ -1228,7 +1322,8 @@
+ GDK_POINTER_MOTION_MASK,
+ NULL, NULL, activate_time) == 0))
+ {
+- if (gdk_keyboard_grab (window, TRUE,
++ if (!grab_keyboard ||
++ gdk_keyboard_grab (window, TRUE,
+ activate_time) == 0)
+ return TRUE;
+ else
+@@ -1282,6 +1377,7 @@
+ GtkWidget *parent;
+ GdkEvent *current_event;
+ GtkMenuShell *menu_shell;
++ gboolean grab_keyboard;
+ GtkMenuPrivate *priv = gtk_menu_get_private (menu);
+
+ g_return_if_fail (GTK_IS_MENU (menu));
+@@ -1333,10 +1429,28 @@
+ * probably could just leave the grab on the other window, with a
+ * little reorganization of the code in gtkmenu*).
+ */
++
++ grab_keyboard = gtk_menu_shell_get_take_focus (menu_shell);
++ gtk_window_set_accept_focus (GTK_WINDOW (menu->toplevel), grab_keyboard);
++
+ if (xgrab_shell && xgrab_shell != widget)
+ {
+- if (popup_grab_on_window (xgrab_shell->window, activate_time))
++ if (popup_grab_on_window (xgrab_shell->window, activate_time, grab_keyboard))
+ GTK_MENU_SHELL (xgrab_shell)->have_xgrab = TRUE;
++
++ /* HILDON:
++ * Check wheter parent is GtkMenuBar. If so,
++ * then we need sharp upper corners for this menu.
++ */
++ if (gtk_menu_check_name (widget))
++ {
++ if (GTK_IS_MENU_BAR (parent_menu_shell))
++ gtk_widget_set_name (widget, HILDON_MENU_NAME_SHARP);
++ else if (GTK_IS_MENU (parent_menu_shell))
++ gtk_widget_set_name( widget, HILDON_MENU_NAME_ROUND);
++ else
++ gtk_widget_set_name (widget, HILDON_MENU_NAME_ROUND_FIRST_LEVEL);
++ }
+ }
+ else
+ {
+@@ -1344,8 +1458,14 @@
+
+ xgrab_shell = widget;
+ transfer_window = menu_grab_transfer_window_get (menu);
+- if (popup_grab_on_window (transfer_window, activate_time))
++ if (popup_grab_on_window (transfer_window, activate_time, grab_keyboard))
+ GTK_MENU_SHELL (xgrab_shell)->have_xgrab = TRUE;
++
++ /* HILDON:
++ * We want this menu to have round corners (Used by default)
++ */
++ if (gtk_menu_check_name (widget))
++ gtk_widget_set_name (widget, HILDON_MENU_NAME_ROUND_FIRST_LEVEL);
+ }
+
+ if (!GTK_MENU_SHELL (xgrab_shell)->have_xgrab)
+@@ -1409,6 +1529,23 @@
+
+ /* Position the menu, possibly changing the size request
+ */
++ if (GTK_IS_COMBO_BOX (gtk_menu_get_attach_widget (menu)))
++ {
++ /* Hildon - limit the size if the menu is attached to a ComboBox */
++ GtkRequisition req;
++ gint width, height;
++
++ gtk_widget_set_size_request (widget, -1, -1);
++ gtk_widget_size_request (widget, &req);
++
++ width = MAX (MIN (req.width, HILDON_MENU_COMBO_MAX_WIDTH),
++ HILDON_MENU_COMBO_MIN_WIDTH);
++ height = MAX (MIN (req.height, HILDON_MENU_COMBO_MAX_HEIGHT),
++ HILDON_MENU_COMBO_MIN_HEIGHT);
++
++ gtk_widget_set_size_request (widget, width, height);
++ }
++
+ gtk_menu_position (menu);
+
+ /* Compute the size of the toplevel and realize it so we
+@@ -1430,13 +1567,29 @@
+
+ gtk_menu_scroll_to (menu, menu->scroll_offset);
+
++ if (priv->context_menu)
++ {
++ /* Save position of the pointer during popup */
++ /* currently not-multihead safe */
++ GdkScreen *screen;
++ GdkDisplay *display;
++
++ screen = gtk_widget_get_screen (widget);
++ display = gdk_screen_get_display (screen);
++
++ gdk_display_get_pointer (display, NULL,
++ &priv->popup_pointer_x,
++ &priv->popup_pointer_y,
++ NULL);
++ }
++
+ /* Once everything is set up correctly, map the toplevel window on
+ the screen.
+ */
+ gtk_widget_show (menu->toplevel);
+
+ if (xgrab_shell == widget)
+- popup_grab_on_window (widget->window, activate_time); /* Should always succeed */
++ popup_grab_on_window (widget->window, activate_time, grab_keyboard); /* Should always succeed */
+ gtk_grab_add (GTK_WIDGET (menu));
+ }
+
+@@ -1996,6 +2149,7 @@
+ GtkWidget *child;
+ GList *children;
+ guint vertical_padding;
++ guint horizontal_padding;
+
+ g_return_if_fail (GTK_IS_MENU (widget));
+
+@@ -2025,9 +2179,10 @@
+
+ gtk_widget_style_get (GTK_WIDGET (menu),
+ "vertical-padding", &vertical_padding,
++ "horizontal-padding", &horizontal_padding,
+ NULL);
+
+- attributes.x = border_width + widget->style->xthickness;
++ attributes.x = border_width + widget->style->xthickness + horizontal_padding;
+ attributes.y = border_width + widget->style->ythickness + vertical_padding;
+ attributes.width = MAX (1, widget->allocation.width - attributes.x * 2);
+ attributes.height = MAX (1, widget->allocation.height - attributes.y * 2);
+@@ -2040,11 +2195,14 @@
+ if (menu->lower_arrow_visible)
+ attributes.height -= MENU_SCROLL_ARROW_HEIGHT;
+
++ attributes.window_type = GDK_WINDOW_CHILD;
++
+ menu->view_window = gdk_window_new (widget->window, &attributes, attributes_mask);
+ gdk_window_set_user_data (menu->view_window, menu);
+
+ attributes.x = 0;
+ attributes.y = 0;
++ attributes.width = MAX (1, widget->requisition.width - (border_width + widget->style->xthickness + horizontal_padding) * 2);
+ attributes.height = MAX (1, widget->requisition.height - (border_width + widget->style->ythickness + vertical_padding) * 2);
+
+ menu->bin_window = gdk_window_new (menu->view_window, &attributes, attributes_mask);
+@@ -2164,6 +2322,10 @@
+ guint vertical_padding;
+ GtkRequisition child_requisition;
+ GtkMenuPrivate *priv;
++ guint horizontal_padding;
++ GdkScreen *screen;
++ GdkRectangle monitor;
++ gint monitor_num;
+
+ g_return_if_fail (GTK_IS_MENU (widget));
+ g_return_if_fail (requisition != NULL);
+@@ -2182,6 +2344,16 @@
+ priv->heights = g_new0 (guint, gtk_menu_get_n_rows (menu));
+ priv->heights_length = gtk_menu_get_n_rows (menu);
+
++/* Hildon addition to find out the monitor width */
++ screen = gtk_widget_get_screen (widget);
++ if (widget->window != NULL)
++ monitor_num = gdk_screen_get_monitor_at_window (screen, widget->window);
++ else
++ monitor_num = 0;
++ if (monitor_num < 0)
++ monitor_num = 0;
++ gdk_screen_get_monitor_geometry (screen, monitor_num, &monitor);
++
+ children = menu_shell->children;
+ while (children)
+ {
+@@ -2223,15 +2395,18 @@
+
+ requisition->width += max_toggle_size + max_accel_width;
+ requisition->width *= gtk_menu_get_n_columns (menu);
+- requisition->width += (GTK_CONTAINER (menu)->border_width +
+- widget->style->xthickness) * 2;
+
+ gtk_widget_style_get (GTK_WIDGET (menu),
++ "horizontal-padding", &horizontal_padding,
+ "vertical-padding", &vertical_padding,
+ NULL);
++ requisition->width += (GTK_CONTAINER (menu)->border_width + horizontal_padding +
++ widget->style->xthickness) * 2;
+ requisition->height += (GTK_CONTAINER (menu)->border_width + vertical_padding +
+ widget->style->ythickness) * 2;
+
++/* Hildon addition to not make the menu too wide for the screen. */
++ requisition->width = MIN (requisition->width, monitor.width);
+ menu->toggle_size = max_toggle_size;
+
+ /* Don't resize the tearoff if it is not active, because it won't redraw (it is only a background pixmap).
+@@ -2253,6 +2428,7 @@
+ GList *children;
+ gint x, y;
+ gint width, height;
++ guint horizontal_padding;
+ guint vertical_padding;
+
+ g_return_if_fail (GTK_IS_MENU (widget));
+@@ -2266,10 +2442,11 @@
+ gtk_widget_get_child_requisition (GTK_WIDGET (menu), &child_requisition);
+
+ gtk_widget_style_get (GTK_WIDGET (menu),
++ "horizontal-padding", &horizontal_padding,
+ "vertical-padding", &vertical_padding,
+ NULL);
+
+- x = GTK_CONTAINER (menu)->border_width + widget->style->xthickness;
++ x = GTK_CONTAINER (menu)->border_width + widget->style->xthickness + horizontal_padding;
+ y = GTK_CONTAINER (menu)->border_width + widget->style->ythickness + vertical_padding;
+
+ width = MAX (1, allocation->width - x * 2);
+@@ -2407,27 +2584,32 @@
+ GdkEventExpose *event)
+ {
+ GtkMenu *menu;
+- gint width, height;
+- gint border_x, border_y;
+- guint vertical_padding;
+
+ g_return_if_fail (GTK_IS_MENU (widget));
+
+ menu = GTK_MENU (widget);
+
+- gtk_widget_style_get (GTK_WIDGET (menu),
+- "vertical-padding", &vertical_padding,
+- NULL);
+-
+- border_x = GTK_CONTAINER (widget)->border_width + widget->style->xthickness;
+- border_y = GTK_CONTAINER (widget)->border_width + widget->style->ythickness + vertical_padding;
+- gdk_drawable_get_size (widget->window, &width, &height);
+-
+ if (event->window == widget->window)
+ {
++ gint width, height;
++ gint border_x, border_y;
++ guint vertical_padding;
++ guint horizontal_padding;
++ GtkMenuPrivate *priv;
+ gint arrow_space = MENU_SCROLL_ARROW_HEIGHT - 2 * widget->style->ythickness;
+ gint arrow_size = 0.7 * arrow_space;
+
++ priv = gtk_menu_get_private (menu);
++
++ gtk_widget_style_get (GTK_WIDGET (menu),
++ "vertical-padding", &vertical_padding,
++ "horizontal-padding", &horizontal_padding,
++ NULL);
++
++ border_x = GTK_CONTAINER (widget)->border_width + widget->style->xthickness + horizontal_padding;
++ border_y = GTK_CONTAINER (widget)->border_width + widget->style->ythickness + vertical_padding;
++ gdk_drawable_get_size (widget->window, &width, &height);
++
+ gtk_paint_box (widget->style,
+ widget->window,
+ GTK_STATE_NORMAL,
+@@ -2436,21 +2618,9 @@
+ 0, 0, -1, -1);
+ if (menu->upper_arrow_visible && !menu->tearoff_active)
+ {
+- gtk_paint_box (widget->style,
+- widget->window,
+- menu->upper_arrow_prelight ?
+- GTK_STATE_PRELIGHT : GTK_STATE_NORMAL,
+- GTK_SHADOW_OUT,
+- NULL, widget, "menu",
+- border_x,
+- border_y,
+- width - 2 * border_x,
+- MENU_SCROLL_ARROW_HEIGHT);
+-
+ gtk_paint_arrow (widget->style,
+ widget->window,
+- menu->upper_arrow_prelight ?
+- GTK_STATE_PRELIGHT : GTK_STATE_NORMAL,
++ priv->upper_arrow_state,
+ GTK_SHADOW_OUT,
+ NULL, widget, "menu_scroll_arrow_up",
+ GTK_ARROW_UP,
+@@ -2462,21 +2632,9 @@
+
+ if (menu->lower_arrow_visible && !menu->tearoff_active)
+ {
+- gtk_paint_box (widget->style,
+- widget->window,
+- menu->lower_arrow_prelight ?
+- GTK_STATE_PRELIGHT : GTK_STATE_NORMAL,
+- GTK_SHADOW_OUT,
+- NULL, widget, "menu",
+- border_x,
+- height - border_y - MENU_SCROLL_ARROW_HEIGHT,
+- width - 2*border_x,
+- MENU_SCROLL_ARROW_HEIGHT);
+-
+ gtk_paint_arrow (widget->style,
+ widget->window,
+- menu->lower_arrow_prelight ?
+- GTK_STATE_PRELIGHT : GTK_STATE_NORMAL,
++ priv->lower_arrow_state,
+ GTK_SHADOW_OUT,
+ NULL, widget, "menu_scroll_arrow_down",
+ GTK_ARROW_DOWN,
+@@ -2516,18 +2674,82 @@
+ GTK_WIDGET_CLASS (parent_class)->show (widget);
+ }
+
++static GtkWidget *
++find_active_menu_item (GdkEventButton *event)
++{
++ GtkWidget *menu_item;
++
++ menu_item = gtk_get_event_widget ((GdkEvent*) event);
++ while (menu_item && !GTK_IS_MENU_ITEM (menu_item))
++ menu_item = menu_item->parent;
++
++ return menu_item;
++}
++
++static gboolean
++pointer_in_menu_tree (GtkWidget *widget)
++{
++ GtkMenuShell *mshell;
++ int width, height, x, y;
++
++ mshell = GTK_MENU_SHELL (widget);
++
++ gdk_window_get_pointer (widget->window, &x, &y, NULL);
++ gdk_drawable_get_size (widget->window, &width, &height);
++
++ if ((x <= width) && (x >= 0) && (y <= height) && (y >= 0))
++ return TRUE;
++
++ if ((mshell->parent_menu_shell != NULL) &&
++ GTK_IS_MENU (mshell->parent_menu_shell))
++ return pointer_in_menu_tree (mshell->parent_menu_shell);
++
++ return FALSE;
++}
++
++static int
++distance_traveled (GtkWidget *widget)
++{
++ GtkMenuPrivate *priv;
++ GdkScreen *screen;
++ GdkDisplay *display;
++ int x, y, dx, dy;
++
++ priv = gtk_menu_get_private (GTK_MENU (widget));
++
++ screen = gtk_widget_get_screen (widget);
++ display = gdk_screen_get_display (screen);
++
++ gdk_display_get_pointer (display, NULL, &x, &y, NULL);
++
++ dx = (priv->popup_pointer_x - x);
++ dy = (priv->popup_pointer_y - y);
++
++ return abs ((int) sqrt ((double) (dx * dx + dy * dy)));
++}
++
+ static gboolean
+ gtk_menu_button_press (GtkWidget *widget,
+- GdkEventButton *event)
++ GdkEventButton *event)
+ {
+- /* Don't pop down the menu for releases over scroll arrows
+- */
+- if (GTK_IS_MENU (widget))
++ GtkWidget *menu_item;
++
++ menu_item = find_active_menu_item (event);
++ if (menu_item == NULL)
+ {
+ GtkMenu *menu = GTK_MENU (widget);
+
+- if (menu->upper_arrow_prelight || menu->lower_arrow_prelight)
+- return TRUE;
++ if (menu->upper_arrow_prelight || menu->lower_arrow_prelight)
++ {
++ gtk_menu_handle_scrolling (GTK_MENU (widget), event->x_root, event->y_root, TRUE, FALSE);
++
++ return TRUE;
++ }
++
++ /* Don't pass down to menu shell if a non-menuitem part
++ * of the menu was clicked. */
++ if (pointer_in_menu_tree (widget))
++ return TRUE;
+ }
+
+ return GTK_WIDGET_CLASS (parent_class)->button_press_event (widget, event);
+@@ -2537,14 +2759,44 @@
+ gtk_menu_button_release (GtkWidget *widget,
+ GdkEventButton *event)
+ {
+- /* Don't pop down the menu for releases over scroll arrows
+- */
+- if (GTK_IS_MENU (widget))
++ GtkMenuPrivate *priv;
++ GtkWidget *menu_item;
++
++ priv = gtk_menu_get_private (GTK_MENU (widget));
++
++ menu_item = find_active_menu_item (event);
++ if (menu_item == NULL)
+ {
+ GtkMenu *menu = GTK_MENU (widget);
+
+- if (menu->upper_arrow_prelight || menu->lower_arrow_prelight)
+- return TRUE;
++ if (menu->upper_arrow_prelight || menu->lower_arrow_prelight)
++ {
++ gtk_menu_handle_scrolling (GTK_MENU (widget), event->x_root, event->y_root, FALSE, FALSE);
++
++ return TRUE;
++ }
++
++ if (priv->context_menu &&
++ (priv->popup_pointer_x >= 0) &&
++ (priv->popup_pointer_y >= 0))
++ {
++ int distance;
++
++ distance = distance_traveled (widget);
++
++ priv->popup_pointer_x = -1;
++ priv->popup_pointer_y = -1;
++
++ /* Don't popdown if we traveled less than 20px since popup point,
++ * as per the specs. */
++ if (distance < 20)
++ return TRUE;
++ }
++
++ /* Don't pass down to menu shell if a non-menuitem part
++ * of the menu was clicked. */
++ if (pointer_in_menu_tree (widget))
++ return TRUE;
+ }
+
+ return GTK_WIDGET_CLASS (parent_class)->button_release_event (widget, event);
+@@ -2765,7 +3017,7 @@
+ gboolean need_enter;
+
+ if (GTK_IS_MENU (widget))
+- gtk_menu_handle_scrolling (GTK_MENU (widget), event->x_root, event->y_root, TRUE);
++ gtk_menu_handle_scrolling (GTK_MENU (widget), event->x_root, event->y_root, TRUE, TRUE);
+
+ /* We received the event for one of two reasons:
+ *
+@@ -2779,7 +3031,27 @@
+ menu_item = gtk_get_event_widget ((GdkEvent*) event);
+ if (!menu_item || !GTK_IS_MENU_ITEM (menu_item) ||
+ !GTK_IS_MENU (menu_item->parent))
+- return FALSE;
++ {
++ GtkMenuPrivate *priv;
++
++ priv = gtk_menu_get_private (GTK_MENU (widget));
++
++ if (priv->context_menu)
++ {
++ /* Context menu mode. If we dragged out of the menu,
++ * close the menu, as by the specs. */
++ if (!pointer_in_menu_tree (widget) &&
++ (distance_traveled (widget) >= 20) &&
++ (event->state & GDK_BUTTON1_MASK))
++ {
++ gtk_menu_deactivate (GTK_MENU_SHELL (widget));
++
++ return TRUE;
++ }
++ }
++
++ return FALSE;
++ }
+
+ menu_shell = GTK_MENU_SHELL (menu_item->parent);
+ menu = GTK_MENU (menu_shell);
+@@ -2795,6 +3067,11 @@
+ */
+ if (gtk_menu_navigating_submenu (menu, event->x_root, event->y_root))
+ return TRUE;
++/* HILDON MOD.
++ * Close the submenus that are two levels down from the currently selected.
++ * This ensures that the focus is correct all the time.*/
++ if (GTK_MENU_ITEM(menu_item)->submenu != NULL)
++ gtk_menu_shell_deselect (GTK_MENU_SHELL(&(GTK_MENU(GTK_MENU_ITEM(menu_item)->submenu)->menu_shell)));
+
+ /* Make sure we pop down if we enter a non-selectable menu item, so we
+ * don't show a submenu when the cursor is outside the stay-up triangle.
+@@ -2828,6 +3105,7 @@
+ send_event->crossing.y_root = event->y_root;
+ send_event->crossing.x = event->x;
+ send_event->crossing.y = event->y;
++ send_event->crossing.state = event->state;
+
+ /* We send the event to 'widget', the currently active menu,
+ * instead of 'menu', the menu that the pointer is in. This
+@@ -2852,17 +3130,24 @@
+ GtkWidget *widget;
+ gint offset;
+ gint view_width, view_height;
++ gboolean double_arrows;
+
+ widget = GTK_WIDGET (menu);
+ offset = menu->scroll_offset + step;
+
++ /* get double_arrows style property */
++ gtk_widget_style_get (widget,
++ "double_arrows", &double_arrows,
++ NULL);
++
+ /* If we scroll upward and the non-visible top part
+ * is smaller than the scroll arrow it would be
+ * pretty stupid to show the arrow and taking more
+ * screen space than just scrolling to the top.
+ */
+- if ((step < 0) && (offset < MENU_SCROLL_ARROW_HEIGHT))
+- offset = 0;
++ if (!double_arrows)
++ if ((step < 0) && (offset < MENU_SCROLL_ARROW_HEIGHT))
++ offset = 0;
+
+ /* Don't scroll over the top if we weren't before: */
+ if ((menu->scroll_offset >= 0) && (offset < 0))
+@@ -2874,6 +3159,12 @@
+ if (menu->scroll_offset > 0)
+ view_height -= MENU_SCROLL_ARROW_HEIGHT;
+
++ /* When both arrows are always shown, reduce
++ * view height even more.
++ */
++ if (double_arrows)
++ view_height -= MENU_SCROLL_ARROW_HEIGHT;
++
+ if ((menu->scroll_offset + view_height <= widget->requisition.height) &&
+ (offset + view_height > widget->requisition.height))
+ offset = widget->requisition.height - view_height;
+@@ -2922,18 +3213,21 @@
+ gtk_menu_handle_scrolling (GtkMenu *menu,
+ gint x,
+ gint y,
+- gboolean enter)
++ gboolean enter,
++ gboolean motion)
+ {
+ GtkMenuShell *menu_shell;
++ GtkMenuPrivate *priv;
+ gint width, height;
+ gint border;
+ GdkRectangle rect;
+- gboolean in_arrow;
+ gboolean scroll_fast = FALSE;
+ guint vertical_padding;
+ gint top_x, top_y;
+ gint win_x, win_y;
+
++ priv = gtk_menu_get_private (menu);
++
+ menu_shell = GTK_MENU_SHELL (menu);
+
+ gdk_drawable_get_size (GTK_WIDGET (menu)->window, &width, &height);
+@@ -2946,10 +3240,11 @@
+ GTK_WIDGET (menu)->style->ythickness + vertical_padding;
+
+ gdk_window_get_position (menu->toplevel->window, &top_x, &top_y);
++ x -= top_x;
++ y -= top_y;
++
+ gdk_window_get_position (GTK_WIDGET (menu)->window, &win_x, &win_y);
+- win_x += top_x;
+- win_y += top_y;
+-
++
+ if (menu->upper_arrow_visible && !menu->tearoff_active)
+ {
+ rect.x = win_x;
+@@ -2957,35 +3252,49 @@
+ rect.width = width;
+ rect.height = MENU_SCROLL_ARROW_HEIGHT + border;
+
+- in_arrow = FALSE;
++ menu->upper_arrow_prelight = FALSE;
+ if ((x >= rect.x) && (x < rect.x + rect.width) &&
+ (y >= rect.y) && (y < rect.y + rect.height))
+- {
+- in_arrow = TRUE;
+- scroll_fast = (y < rect.y + MENU_SCROLL_FAST_ZONE);
+- }
+-
+- if (enter && in_arrow &&
+- (!menu->upper_arrow_prelight || menu->scroll_fast != scroll_fast))
+- {
+- menu->upper_arrow_prelight = TRUE;
+- menu->scroll_fast = scroll_fast;
+- gdk_window_invalidate_rect (GTK_WIDGET (menu)->window, &rect, FALSE);
+-
+- /* Deselect the active item so that any submenus are poped down */
+- gtk_menu_shell_deselect (menu_shell);
++ menu->upper_arrow_prelight = TRUE;
+
+- gtk_menu_remove_scroll_timeout (menu);
+- menu->scroll_step = (scroll_fast) ? -MENU_SCROLL_STEP2 : -MENU_SCROLL_STEP1;
+- menu->timeout_id = g_timeout_add ((scroll_fast) ? MENU_SCROLL_TIMEOUT2 : MENU_SCROLL_TIMEOUT1,
+- gtk_menu_scroll_timeout,
+- menu);
+- }
+- else if (!enter && !in_arrow && menu->upper_arrow_prelight)
++ if (priv->upper_arrow_state != GTK_STATE_INSENSITIVE)
+ {
+- gdk_window_invalidate_rect (GTK_WIDGET (menu)->window, &rect, FALSE);
+-
+- gtk_menu_stop_scrolling (menu);
++ if (enter && menu->upper_arrow_prelight &&
++ (menu->timeout_id == 0 || menu->scroll_fast != scroll_fast))
++ {
++ menu->scroll_fast = scroll_fast;
++
++ /* Deselect the active item so that any submenus are poped down */
++ gtk_menu_shell_deselect (menu_shell);
++
++ gtk_menu_remove_scroll_timeout (menu);
++ menu->scroll_step = (scroll_fast) ? -MENU_SCROLL_STEP2 : -MENU_SCROLL_STEP1;
++
++ if (!motion)
++ {
++ /* Only do stuff on click. */
++ GtkSettings *settings;
++ guint timeout;
++
++ settings = gtk_settings_get_default ();
++ g_object_get (settings, "gtk-update-timeout", &timeout, NULL);
++
++ menu->timeout_id = g_timeout_add (timeout / 2, gtk_menu_scroll_timeout, menu);
++
++ priv->upper_arrow_state = GTK_STATE_ACTIVE;
++ }
++
++ gdk_window_invalidate_rect (GTK_WIDGET (menu)->window, &rect, FALSE);
++ }
++ else if (!enter)
++ {
++ gtk_menu_stop_scrolling (menu);
++
++ priv->upper_arrow_state = menu->upper_arrow_prelight ?
++ GTK_STATE_PRELIGHT : GTK_STATE_NORMAL;
++
++ gdk_window_invalidate_rect (GTK_WIDGET (menu)->window, &rect, FALSE);
++ }
+ }
+ }
+
+@@ -2996,36 +3305,50 @@
+ rect.width = width;
+ rect.height = MENU_SCROLL_ARROW_HEIGHT + border;
+
+- in_arrow = FALSE;
++ menu->lower_arrow_prelight = FALSE;
+ if ((x >= rect.x) && (x < rect.x + rect.width) &&
+ (y >= rect.y) && (y < rect.y + rect.height))
+- {
+- in_arrow = TRUE;
+- scroll_fast = (y > rect.y + rect.height - MENU_SCROLL_FAST_ZONE);
+- }
++ menu->lower_arrow_prelight = TRUE;
+
+- if (enter && in_arrow &&
+- (!menu->lower_arrow_prelight || menu->scroll_fast != scroll_fast))
++ if (priv->lower_arrow_state != GTK_STATE_INSENSITIVE)
+ {
+- menu->lower_arrow_prelight = TRUE;
+- menu->scroll_fast = scroll_fast;
+- gdk_window_invalidate_rect (GTK_WIDGET (menu)->window, &rect, FALSE);
++ if (enter && menu->lower_arrow_prelight &&
++ (menu->timeout_id == 0 || menu->scroll_fast != scroll_fast))
++ {
++ menu->scroll_fast = scroll_fast;
+
+- /* Deselect the active item so that any submenus are poped down */
+- gtk_menu_shell_deselect (menu_shell);
++ /* Deselect the active item so that any submenus are poped down */
++ gtk_menu_shell_deselect (menu_shell);
+
+- gtk_menu_remove_scroll_timeout (menu);
+- menu->scroll_step = (scroll_fast) ? MENU_SCROLL_STEP2 : MENU_SCROLL_STEP1;
+- menu->timeout_id = g_timeout_add ((scroll_fast) ? MENU_SCROLL_TIMEOUT2 : MENU_SCROLL_TIMEOUT1,
+- gtk_menu_scroll_timeout,
+- menu);
+- }
+- else if (!enter && !in_arrow && menu->lower_arrow_prelight)
+- {
+- gdk_window_invalidate_rect (GTK_WIDGET (menu)->window, &rect, FALSE);
+-
+- gtk_menu_stop_scrolling (menu);
+- }
++ gtk_menu_remove_scroll_timeout (menu);
++ menu->scroll_step = (scroll_fast) ? MENU_SCROLL_STEP2 : MENU_SCROLL_STEP1;
++
++ if (!motion)
++ {
++ /* Only do stuff on click. */
++ GtkSettings *settings;
++ guint timeout;
++
++ settings = gtk_settings_get_default ();
++ g_object_get (settings, "gtk-update-timeout", &timeout, NULL);
++
++ menu->timeout_id = g_timeout_add (timeout / 2, gtk_menu_scroll_timeout, menu);
++
++ priv->lower_arrow_state = GTK_STATE_ACTIVE;
++ }
++
++ gdk_window_invalidate_rect (GTK_WIDGET (menu)->window, &rect, FALSE);
++ }
++ else if (!enter)
++ {
++ gtk_menu_stop_scrolling (menu);
++
++ priv->lower_arrow_state = menu->lower_arrow_prelight ?
++ GTK_STATE_PRELIGHT : GTK_STATE_NORMAL;
++
++ gdk_window_invalidate_rect (GTK_WIDGET (menu)->window, &rect, FALSE);
++ }
++ }
+ }
+ }
+
+@@ -3041,7 +3364,7 @@
+ GtkMenuShell *menu_shell = GTK_MENU_SHELL (widget);
+
+ if (!menu_shell->ignore_enter)
+- gtk_menu_handle_scrolling (GTK_MENU (widget), event->x_root, event->y_root, TRUE);
++ gtk_menu_handle_scrolling (GTK_MENU (widget), event->x_root, event->y_root, TRUE, TRUE);
+ }
+
+ if (menu_item && GTK_IS_MENU_ITEM (menu_item))
+@@ -3106,7 +3429,7 @@
+ if (gtk_menu_navigating_submenu (menu, event->x_root, event->y_root))
+ return TRUE;
+
+- gtk_menu_handle_scrolling (menu, event->x_root, event->y_root, FALSE);
++ gtk_menu_handle_scrolling (menu, event->x_root, event->y_root, FALSE, TRUE);
+
+ event_widget = gtk_get_event_widget ((GdkEvent*) event);
+
+@@ -3611,7 +3934,13 @@
+ requisition.width, requisition.height);
+ }
+
+- menu->scroll_offset = scroll_offset;
++ /* Hildon hack for menu in comboboxes:
++ * in case the menu in attached to a ComboBox, the scroll_offset is
++ * calculated in the positioning function so we dont't overwrite it
++ * with the value calculated above (in this function) */
++ if ( !GTK_IS_COMBO_BOX(gtk_menu_get_attach_widget(menu)) )
++ menu->scroll_offset = scroll_offset;
++
+ }
+
+ static void
+@@ -3628,9 +3957,6 @@
+ gtk_menu_stop_scrolling (GtkMenu *menu)
+ {
+ gtk_menu_remove_scroll_timeout (menu);
+-
+- menu->upper_arrow_prelight = FALSE;
+- menu->lower_arrow_prelight = FALSE;
+ }
+
+ static void
+@@ -3644,6 +3970,8 @@
+ gboolean last_visible;
+ gint menu_height;
+ guint vertical_padding;
++ guint horizontal_padding;
++ gboolean double_arrows;
+
+ widget = GTK_WIDGET (menu);
+
+@@ -3663,19 +3991,93 @@
+
+ gtk_widget_style_get (GTK_WIDGET (menu),
+ "vertical-padding", &vertical_padding,
++ "horizontal-padding", &horizontal_padding,
++ "double_arrows", &double_arrows,
+ NULL);
+
+ border_width = GTK_CONTAINER (menu)->border_width;
+- view_width -= (border_width + widget->style->xthickness) * 2;
++ view_width -= (border_width + widget->style->xthickness + horizontal_padding) * 2;
+ view_height -= (border_width + widget->style->ythickness + vertical_padding) * 2;
+ menu_height = widget->requisition.height -
+ (border_width + widget->style->ythickness + vertical_padding) * 2;
+
+- x = border_width + widget->style->xthickness;
++ x = border_width + widget->style->xthickness + horizontal_padding;
+ y = border_width + widget->style->ythickness + vertical_padding;
+
++ if (double_arrows && !menu->tearoff_active && (view_height < menu_height))
++ {
++ GtkMenuPrivate *priv;
++ GtkStateType upper_arrow_previous_state, lower_arrow_previous_state;
++
++ priv = gtk_menu_get_private (menu);
++
++ upper_arrow_previous_state = priv->upper_arrow_state;
++ lower_arrow_previous_state = priv->lower_arrow_state;
++
++ if (!menu->upper_arrow_visible || !menu->lower_arrow_visible)
++ gtk_widget_queue_draw (GTK_WIDGET (menu));
++
++ view_height -= 2*MENU_SCROLL_ARROW_HEIGHT;
++ y += MENU_SCROLL_ARROW_HEIGHT;
++
++ menu->upper_arrow_visible = menu->lower_arrow_visible = TRUE;
++ if (priv->upper_arrow_state == GTK_STATE_INSENSITIVE)
++ {
++ priv->upper_arrow_state = menu->upper_arrow_prelight ?
++ GTK_STATE_PRELIGHT : GTK_STATE_NORMAL;
++ }
++ if (priv->lower_arrow_state == GTK_STATE_INSENSITIVE)
++ {
++ priv->lower_arrow_state = menu->lower_arrow_prelight ?
++ GTK_STATE_PRELIGHT : GTK_STATE_NORMAL;
++ }
++
++ if (offset <= 0)
++ {
++ offset = 0;
++ priv->upper_arrow_state = GTK_STATE_INSENSITIVE;
++ }
++ if (offset >= menu_height - view_height)
++ {
++ offset = menu_height - view_height;
++ priv->lower_arrow_state = GTK_STATE_INSENSITIVE;
++ }
++
++ if ((priv->upper_arrow_state != upper_arrow_previous_state) ||
++ (priv->lower_arrow_state != lower_arrow_previous_state))
++ gtk_widget_queue_draw (GTK_WIDGET (menu));
++
++ if (upper_arrow_previous_state != GTK_STATE_INSENSITIVE &&
++ priv->upper_arrow_state == GTK_STATE_INSENSITIVE)
++ {
++ /* If we hid the upper arrow, possibly remove timeout */
++ if (menu->scroll_step < 0)
++ {
++ gtk_menu_stop_scrolling (menu);
++ gtk_widget_queue_draw (GTK_WIDGET (menu));
++ }
++ }
++
++ if (lower_arrow_previous_state != GTK_STATE_INSENSITIVE &&
++ priv->lower_arrow_state == GTK_STATE_INSENSITIVE)
++ {
++ /* If we hid the lower arrow, possibly remove timeout */
++ if (menu->scroll_step > 0)
++ {
++ gtk_menu_stop_scrolling (menu);
++ gtk_widget_queue_draw (GTK_WIDGET (menu));
++ }
++ }
++ }
++ else
+ if (!menu->tearoff_active)
+ {
++ if (offset <= 0)
++ offset = 0;
++
++ if (offset >= menu_height - view_height)
++ offset = menu_height - view_height;
++
+ last_visible = menu->upper_arrow_visible;
+ menu->upper_arrow_visible = offset > 0;
+
+@@ -3685,8 +4087,6 @@
+ if ( (last_visible != menu->upper_arrow_visible) &&
+ !menu->upper_arrow_visible)
+ {
+- menu->upper_arrow_prelight = FALSE;
+-
+ /* If we hid the upper arrow, possibly remove timeout */
+ if (menu->scroll_step < 0)
+ {
+@@ -3704,8 +4104,6 @@
+ if ( (last_visible != menu->lower_arrow_visible) &&
+ !menu->lower_arrow_visible)
+ {
+- menu->lower_arrow_prelight = FALSE;
+-
+ /* If we hid the lower arrow, possibly remove timeout */
+ if (menu->scroll_step > 0)
+ {
+@@ -3792,12 +4190,14 @@
+ &child_offset, &child_height, &last_child))
+ {
+ guint vertical_padding;
++ gboolean double_arrows;
+
+ y = menu->scroll_offset;
+ gdk_drawable_get_size (GTK_WIDGET (menu)->window, &width, &height);
+
+ gtk_widget_style_get (GTK_WIDGET (menu),
+ "vertical-padding", &vertical_padding,
++ "double_arrows", &double_arrows,
+ NULL);
+
+ height -= 2*GTK_CONTAINER (menu)->border_width + 2*GTK_WIDGET (menu)->style->ythickness + 2*vertical_padding;
+@@ -3820,11 +4220,11 @@
+ if (child_offset + child_height > y + height - arrow_height)
+ {
+ arrow_height = 0;
+- if (!last_child && !menu->tearoff_active)
++ if ((!last_child && !menu->tearoff_active) || (double_arrows))
+ arrow_height += MENU_SCROLL_ARROW_HEIGHT;
+
+ y = child_offset + child_height - height + arrow_height;
+- if ((y > 0) && !menu->tearoff_active)
++ if (((y > 0) && !menu->tearoff_active) || (double_arrows))
+ {
+ /* Need upper arrow */
+ arrow_height += MENU_SCROLL_ARROW_HEIGHT;
+@@ -4374,3 +4774,60 @@
+ return list;
+ }
+
++/* Little help function for making some sanity tests on this menu.
++ * Checks that given widget really is a menu and that it has no name
++ * assigned to it yet.
++ * Names used to do hildon theming:
++ * HILDON_MENU_NAME_SHARP for menu with sharp upper corners
++ * HILDON_MENU_NAME_ROUND for menu with round corners
++ */
++static gboolean
++gtk_menu_check_name (GtkWidget *widget)
++{
++ gboolean legal_name = FALSE;
++ gchar **tmp = NULL;
++ const gchar *name = NULL;
++ static gchar *menu_names[] = { "GtkMenu",
++ HILDON_MENU_NAME_SHARP,
++ HILDON_MENU_NAME_ROUND,
++ HILDON_MENU_NAME_ROUND_FIRST_LEVEL,
++ NULL };
++ if (GTK_IS_MENU (widget) &&
++ (name = gtk_widget_get_name (widget)))
++ {
++ if (!g_ascii_strcasecmp (name, HILDON_MENU_NAME_FORCE_SHARP) || !g_ascii_strcasecmp (name, HILDON_MENU_NAME_FORCE_ROUND))
++ return FALSE;
++ for (tmp = menu_names; *tmp; tmp++)
++ if (!g_ascii_strcasecmp (name, *tmp ))
++ {
++ legal_name = TRUE;
++ break;
++ }
++ }
++
++ return legal_name;
++}
++
++/* A function called when esc-key is pressed. */
++static void
++_gtk_menu_close_current (GtkMenu * menu)
++{
++ GtkMenuShell * shell = GTK_MENU_SHELL (menu);
++
++ /* Check is a submenu of current menu item is visible.
++ * If it is, close that first. */
++ if (shell->active_menu_item && (GTK_MENU_ITEM (shell->active_menu_item)->submenu) && GTK_WIDGET_VISIBLE (GTK_MENU_ITEM (shell->active_menu_item)->submenu))
++ gtk_menu_popdown (GTK_MENU (GTK_MENU_ITEM (shell->active_menu_item)->submenu));
++ else
++ gtk_menu_popdown (menu);
++
++}
++
++/* Hildon function to make context menus behave according to spec */
++void
++_gtk_menu_enable_context_menu_behavior (GtkMenu *menu)
++{
++ GtkMenuPrivate *priv = gtk_menu_get_private (menu);
++
++ priv->context_menu = TRUE;
++}