From b2f192faabe412adce79534e22efe9fb69ee40e2 Mon Sep 17 00:00:00 2001 From: Richard Purdie Date: Fri, 21 Jul 2006 10:10:31 +0000 Subject: Rename /openembedded/ -> /meta/ git-svn-id: https://svn.o-hand.com/repos/poky/trunk@530 311d38ba-8fff-0310-9ca6-ca027cbcb966 --- .../gtk+/gtk+-2.6.4-1.osso7/gtkmenushell.c.diff | 490 +++++++++++++++++++++ 1 file changed, 490 insertions(+) create mode 100644 meta/packages/gtk+/gtk+-2.6.4-1.osso7/gtkmenushell.c.diff (limited to 'meta/packages/gtk+/gtk+-2.6.4-1.osso7/gtkmenushell.c.diff') diff --git a/meta/packages/gtk+/gtk+-2.6.4-1.osso7/gtkmenushell.c.diff b/meta/packages/gtk+/gtk+-2.6.4-1.osso7/gtkmenushell.c.diff new file mode 100644 index 0000000000..3534b7716d --- /dev/null +++ b/meta/packages/gtk+/gtk+-2.6.4-1.osso7/gtkmenushell.c.diff @@ -0,0 +1,490 @@ +--- gtk+-2.6.4/gtk/gtkmenushell.c 2005-02-09 18:46:54.000000000 +0200 ++++ gtk+-2.6.4/gtk/gtkmenushell.c 2005-04-06 16:19:36.999913520 +0300 +@@ -39,6 +39,8 @@ + #include "gtkmnemonichash.h" + #include "gtktearoffmenuitem.h" + #include "gtkwindow.h" ++#include "gtkprivate.h" ++#include "gtkintl.h" + + #define MENU_SHELL_TIMEOUT 500 + +@@ -52,6 +54,11 @@ + LAST_SIGNAL + }; + ++enum { ++ PROP_0, ++ PROP_TAKE_FOCUS ++}; ++ + typedef void (*GtkMenuShellSignal1) (GtkObject *object, + GtkMenuDirectionType arg1, + gpointer data); +@@ -122,10 +129,20 @@ + { + GtkMnemonicHash *mnemonic_hash; + GtkKeyHash *key_hash; ++ gboolean activated_submenu; ++ gboolean take_focus; + }; + + static void gtk_menu_shell_class_init (GtkMenuShellClass *klass); + static void gtk_menu_shell_init (GtkMenuShell *menu_shell); ++static void gtk_menu_shell_set_property (GObject *object, ++ guint prop_id, ++ const GValue *value, ++ GParamSpec *pspec); ++static void gtk_menu_shell_get_property (GObject *object, ++ guint prop_id, ++ GValue *value, ++ GParamSpec *pspec); + static void gtk_menu_shell_realize (GtkWidget *widget); + static void gtk_menu_shell_finalize (GObject *object); + static gint gtk_menu_shell_button_press (GtkWidget *widget, +@@ -176,7 +193,6 @@ + static GtkContainerClass *parent_class = NULL; + static guint menu_shell_signals[LAST_SIGNAL] = { 0 }; + +- + GType + gtk_menu_shell_get_type (void) + { +@@ -220,6 +236,8 @@ + container_class = (GtkContainerClass*) klass; + + parent_class = g_type_class_peek_parent (klass); ++ object_class->set_property = gtk_menu_shell_set_property; ++ object_class->get_property = gtk_menu_shell_get_property; + + object_class->finalize = gtk_menu_shell_finalize; + +@@ -299,9 +317,15 @@ + + + binding_set = gtk_binding_set_by_class (klass); ++/* Hildon : The following binding is commented out ++ * because we want the Escape key to only exit the ++ * currently opened submenu. Therefore, the handling ++ * of esc-key will be moved to gtkmenuitem.c */ ++/* + gtk_binding_entry_add_signal (binding_set, + GDK_Escape, 0, + "cancel", 0); ++*/ + gtk_binding_entry_add_signal (binding_set, + GDK_Return, 0, + "activate_current", 1, +@@ -330,7 +354,23 @@ + GDK_F10, GDK_SHIFT_MASK, + "cycle_focus", 1, + GTK_TYPE_DIRECTION_TYPE, GTK_DIR_TAB_BACKWARD); +- ++ /** ++ * GtkMenuShell:take-focus: ++ * ++ * A boolean that determines whether the menu and its submenus grab the ++ * keyboard focus. See gtk_menu_shell_set_take_focus() and ++ * gtk_menu_shell_get_take_focus(). ++ * ++ * Since: 2.8 ++ **/ ++ g_object_class_install_property (object_class, ++ PROP_TAKE_FOCUS, ++ g_param_spec_boolean ("take-focus", ++ P_("Take Focus"), ++ P_("A boolean that determines whether the menu grabs the keyboard focus"), ++ TRUE, ++ G_PARAM_READWRITE)); ++ + g_type_class_add_private (object_class, sizeof (GtkMenuShellPrivate)); + } + +@@ -356,6 +396,46 @@ + + priv->mnemonic_hash = NULL; + priv->key_hash = NULL; ++ priv->take_focus = TRUE; ++ priv->activated_submenu = FALSE; ++} ++ ++static void ++gtk_menu_shell_set_property (GObject *object, ++ guint prop_id, ++ const GValue *value, ++ GParamSpec *pspec) ++{ ++ GtkMenuShell *menu_shell = GTK_MENU_SHELL (object); ++ ++ switch (prop_id) ++ { ++ case PROP_TAKE_FOCUS: ++ gtk_menu_shell_set_take_focus (menu_shell, g_value_get_boolean (value)); ++ break; ++ default: ++ G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec); ++ break; ++ } ++} ++ ++static void ++gtk_menu_shell_get_property (GObject *object, ++ guint prop_id, ++ GValue *value, ++ GParamSpec *pspec) ++{ ++ GtkMenuShell *menu_shell = GTK_MENU_SHELL (object); ++ ++ switch (prop_id) ++ { ++ case PROP_TAKE_FOCUS: ++ g_value_set_boolean (value, gtk_menu_shell_get_take_focus (menu_shell)); ++ break; ++ default: ++ G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec); ++ break; ++ } + } + + static void +@@ -470,6 +550,7 @@ + gtk_menu_shell_button_press (GtkWidget *widget, + GdkEventButton *event) + { ++ GtkMenuShellPrivate *priv; + GtkMenuShell *menu_shell; + GtkWidget *menu_item; + +@@ -479,7 +560,22 @@ + if (event->type != GDK_BUTTON_PRESS) + return FALSE; + ++ priv = GTK_MENU_SHELL_GET_PRIVATE (widget); ++ + menu_shell = GTK_MENU_SHELL (widget); ++ menu_item = gtk_menu_shell_get_item (menu_shell, (GdkEvent*) event); ++ ++ if (menu_shell->active && menu_item && ++ (menu_shell->active_menu_item == menu_item) && ++ _gtk_menu_item_is_selectable (menu_item) && ++ GTK_MENU_ITEM (menu_item)->submenu != NULL && ++ !GTK_WIDGET_VISIBLE (GTK_MENU_ITEM (menu_item)->submenu)) ++ { ++ /* Hildon : We want to be able to activate submenu items. */ ++ gtk_menu_shell_activate_item (menu_shell, menu_item, FALSE); ++ ++ priv->activated_submenu = TRUE; ++ } + + if (menu_shell->parent_menu_shell) + { +@@ -491,30 +587,29 @@ + + menu_shell->button = event->button; + +- menu_item = gtk_menu_shell_get_item (menu_shell, (GdkEvent *)event); +- + if (menu_item && _gtk_menu_item_is_selectable (menu_item)) +- { +- if ((menu_item->parent == widget) && +- (menu_item != menu_shell->active_menu_item)) +- { +- if (GTK_MENU_SHELL_GET_CLASS (menu_shell)->submenu_placement == GTK_TOP_BOTTOM) +- { +- menu_shell->activate_time = event->time; +- } ++ { ++ ++ if ((menu_item->parent == widget) && ++ (menu_item != menu_shell->active_menu_item)) ++ { ++ if (GTK_MENU_SHELL_GET_CLASS (menu_shell)->submenu_placement == GTK_TOP_BOTTOM) ++ { ++ menu_shell->activate_time = event->time; ++ } + +- gtk_menu_shell_select_item (menu_shell, menu_item); +- } +- } ++ gtk_menu_shell_select_item (menu_shell, menu_item); ++ } ++ } + } + else + { + widget = gtk_get_event_widget ((GdkEvent*) event); + if (widget == GTK_WIDGET (menu_shell)) +- { +- gtk_menu_shell_deactivate (menu_shell); +- g_signal_emit (menu_shell, menu_shell_signals[SELECTION_DONE], 0); +- } ++ { ++ gtk_menu_shell_deactivate (menu_shell); ++ g_signal_emit (menu_shell, menu_shell_signals[SELECTION_DONE], 0); ++ } + } + + return TRUE; +@@ -524,13 +619,20 @@ + gtk_menu_shell_button_release (GtkWidget *widget, + GdkEventButton *event) + { ++ GtkMenuShellPrivate *priv; + GtkMenuShell *menu_shell; + GtkWidget *menu_item; + gint deactivate; ++ gboolean activated_submenu; + + g_return_val_if_fail (GTK_IS_MENU_SHELL (widget), FALSE); + g_return_val_if_fail (event != NULL, FALSE); + ++ priv = GTK_MENU_SHELL_GET_PRIVATE (widget); ++ ++ activated_submenu = priv->activated_submenu; ++ priv->activated_submenu = FALSE; ++ + menu_shell = GTK_MENU_SHELL (widget); + if (menu_shell->active) + { +@@ -556,11 +658,11 @@ + gtk_menu_shell_activate_item (menu_shell, menu_item, TRUE); + return TRUE; + } +- else if (GTK_MENU_SHELL_GET_CLASS (menu_shell)->submenu_placement != GTK_TOP_BOTTOM) +- { +- gtk_menu_item_select (GTK_MENU_ITEM (menu_item)); +- return TRUE; +- } ++ else if (!activated_submenu) ++ { ++ /* popdown the submenu if we didn't pop it up in this click */ ++ _gtk_menu_item_popdown_submenu (menu_item); ++ } + } + else if (menu_item && + !_gtk_menu_item_is_selectable (menu_item) && +@@ -630,12 +732,14 @@ + gtk_menu_shell_enter_notify (GtkWidget *widget, + GdkEventCrossing *event) + { ++ GtkMenuShellPrivate *priv; + GtkMenuShell *menu_shell; + GtkWidget *menu_item; + + g_return_val_if_fail (GTK_IS_MENU_SHELL (widget), FALSE); + g_return_val_if_fail (event != NULL, FALSE); + ++ priv = GTK_MENU_SHELL_GET_PRIVATE (widget); + menu_shell = GTK_MENU_SHELL (widget); + + if (menu_shell->active) +@@ -658,6 +762,17 @@ + (GTK_WIDGET_STATE (menu_item) != GTK_STATE_PRELIGHT)) + { + gtk_menu_shell_select_item (menu_shell, menu_item); ++ ++ /* If the pen is down, and there is a submenu that is not ++ * yet visible, activate it */ ++ if ((event->state & GDK_BUTTON1_MASK) && ++ GTK_MENU_ITEM (menu_item)->submenu != NULL && ++ !GTK_WIDGET_VISIBLE (GTK_MENU_ITEM (menu_item)->submenu)) ++ { ++ gtk_menu_shell_activate_item (menu_shell, menu_item, FALSE); ++ ++ priv->activated_submenu = TRUE; ++ } + } + } + else if (menu_shell->parent_menu_shell) +@@ -887,8 +1002,14 @@ + /* This allows the bizarre radio buttons-with-submenus-display-history + * behavior + */ ++ /* Hildon modification. We probably won't have those ++ * bizarre radio buttons-with-submenus so we don't ++ * need this. Also, this functionality interferes with ++ * other functionality. */ ++/* + if (GTK_MENU_ITEM (menu_shell->active_menu_item)->submenu) + gtk_widget_activate (menu_shell->active_menu_item); ++*/ + } + + void +@@ -919,7 +1040,9 @@ + + g_object_ref (menu_shell); + +- if (deactivate) ++ /* We don't want to deactivate if we're activating ++ * a submenu item. */ ++ if ((deactivate) && (GTK_MENU_ITEM (menu_item)->submenu == NULL)) + { + GtkMenuShell *parent_menu_shell = menu_shell; + +@@ -965,29 +1088,30 @@ + + if (distance > 0) + { ++ /*Hildon: selection no longer wraps around at the ++ *bottom of the menu*/ ++ + node = node->next; +- while (node != start_node && +- (!node || !_gtk_menu_item_is_selectable (node->data))) ++ while (node && node != start_node && ++ !_gtk_menu_item_is_selectable (node->data)) + { +- if (!node) +- node = menu_shell->children; +- else + node = node->next; + } + } + else + { ++ /*Hildon: selection no longer wraps around at the top ++ *of the menu*/ ++ + node = node->prev; +- while (node != start_node && +- (!node || !_gtk_menu_item_is_selectable (node->data))) ++ while (node && node != start_node && ++ !_gtk_menu_item_is_selectable (node->data)) + { +- if (!node) +- node = g_list_last (menu_shell->children); +- else + node = node->prev; + } + } + ++ /*note: gtk_menu_shell_select_item won't select non-selectable items*/ + if (node) + gtk_menu_shell_select_item (menu_shell, node->data); + } +@@ -1119,6 +1243,16 @@ + switch (direction) + { + case GTK_MENU_DIR_PARENT: ++ ++ if(!parent_menu_shell || GTK_IS_MENU_BAR(parent_menu_shell)) ++ break; ++ ++ /* hildon-modification - menu should be closed when returning from submenu. ++ * WARNING: This function is from GtkMenu, which normally ++ * shouldn't be called from GtkMenuShell, but currently ++ * there are no better alternatives. */ ++ gtk_menu_popdown (GTK_MENU (menu_shell)); ++ + if (parent_menu_shell) + { + if (GTK_MENU_SHELL_GET_CLASS (parent_menu_shell)->submenu_placement == +@@ -1151,10 +1285,14 @@ + _gtk_menu_item_is_selectable (menu_shell->active_menu_item) && + GTK_MENU_ITEM (menu_shell->active_menu_item)->submenu) + { ++ /* Hildon-modification -- submenu is not opened automatically but needs to be explicitly opened*/ ++ g_signal_emit (G_OBJECT (menu_shell), menu_shell_signals[ACTIVATE_CURRENT], 0, (gint) FALSE); ++ + if (gtk_menu_shell_select_submenu_first (menu_shell)) + break; + } + ++#if 0 + /* Try to find a menu running the opposite direction */ + while (parent_menu_shell && + (GTK_MENU_SHELL_GET_CLASS (parent_menu_shell)->submenu_placement == +@@ -1173,6 +1311,7 @@ + gtk_menu_shell_move_selected (parent_menu_shell, 1); + gtk_menu_shell_select_submenu_first (parent_menu_shell); + } ++#endif + break; + + case GTK_MENU_DIR_PREV: +@@ -1197,8 +1336,8 @@ + gtk_real_menu_shell_activate_current (GtkMenuShell *menu_shell, + gboolean force_hide) + { +- if (menu_shell->active_menu_item && +- _gtk_menu_item_is_selectable (menu_shell->active_menu_item)) ++ if (menu_shell->active_menu_item)/* && ++ _gtk_menu_item_is_selectable (menu_shell->active_menu_item)) */ + { + + if (GTK_MENU_ITEM (menu_shell->active_menu_item)->submenu == NULL) +@@ -1390,4 +1529,73 @@ + keyval, target); + gtk_menu_shell_reset_key_hash (menu_shell); + } ++/** ++ * gtk_menu_shell_get_take_focus: ++ * @menu: a #GtkMenuShell ++ * ++ * @returns: %TRUE if the menu_shell will take the keyboard focus on popup. ++ * ++ * Since: 2.8 ++ **/ ++gboolean ++gtk_menu_shell_get_take_focus (GtkMenuShell *menu_shell) ++{ ++ GtkMenuShellPrivate *priv; ++ ++ g_return_val_if_fail (GTK_IS_MENU_SHELL (menu_shell), FALSE); ++ ++ priv = GTK_MENU_SHELL_GET_PRIVATE (menu_shell); ++ ++ return priv->take_focus; ++} ++ ++/** ++ * gtk_menu_shell_set_take_focus: ++ * @menu: a #GtkMenuShell ++ * @take_focus: %TRUE if the menu_shell should take the keyboard focus on popup. ++ * ++ * If @take_focus is %TRUE (the default) the menu will take the keyboard focus ++ * so that it will receive all keyboard events which is needed to enable ++ * keyboard navigation in menus. ++ * ++ * Setting @take_focus to %FALSE is useful only for special applications ++ * like virtual keyboard implementations which should not take keyboard ++ * focus. ++ * ++ * The @take_focus state of a menu or menu bar is automatically propagated ++ * to submenus whenever a submenu is popped up, so you don't have to worry ++ * about recursively setting it for your entire menu hierarchy. Only when ++ * programmatically picking a submenu and popping it up manually, the ++ * @take_focus property of the submenu needs to be set explicitely. ++ * ++ * Note that setting it to %FALSE has side-effects: ++ * ++ * If the focus is in some other app, it keeps the focus and keynav in ++ * the menu doesn't work. Consequently, keynav on the menu will only ++ * work if the focus is on some toplevel owned by the onscreen keyboard. ++ * ++ * To avoid confusing the user, menus with @take_focus set to %FALSE ++ * should not display mnemonics or accelerators, since it cannot be ++ * guaranteed that they will work. ++ * ++ * See also gdk_keyboard_grab() ++ * ++ * Since: 2.8 ++ **/ ++void ++gtk_menu_shell_set_take_focus (GtkMenuShell *menu_shell, ++ gboolean take_focus) ++{ ++ GtkMenuShellPrivate *priv; ++ ++ g_return_if_fail (GTK_IS_MENU_SHELL (menu_shell)); ++ ++ priv = GTK_MENU_SHELL_GET_PRIVATE (menu_shell); ++ ++ if (priv->take_focus != take_focus) ++ { ++ priv->take_focus = take_focus; ++ g_object_notify (G_OBJECT (menu_shell), "take-focus"); ++ } ++} + -- cgit v1.2.3-54-g00ecf