chrome/browser/ui/gtk/gtk_custom_menu_item.h

   1 // Copyright (c) 2011 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #ifndef CHROME_BROWSER_UI_GTK_GTK_CUSTOM_MENU_ITEM_H_
   6 #define CHROME_BROWSER_UI_GTK_GTK_CUSTOM_MENU_ITEM_H_
   7
   8 // GtkCustomMenuItem is a GtkMenuItem subclass that has buttons in it and acts
   9 // to support this. GtkCustomMenuItems only render properly when put in a
  10 // GtkCustomMenu; there's a lot of collaboration between these two classes
  11 // necessary to work around how gtk normally does menus.
  12 //
  13 // We can't rely on the normal event infrastructure. While a menu is up, the
  14 // GtkMenu has a grab on all events. Instead of trying to pump events through
  15 // the normal channels, we have the GtkCustomMenu selectively forward mouse
  16 // motion through a back channel. The GtkCustomMenu only listens for button
  17 // press information so it can block the effects of the click if the cursor
  18 // isn't in a button in the menu item.
  19 //
  20 // A GtkCustomMenuItem doesn't try to take these signals and forward them to
  21 // the buttons it owns. The GtkCustomMenu class keeps track of which button is
  22 // selected (due to key events and mouse movement) and otherwise acts like a
  23 // normal GtkItem. The buttons are only for sizing and rendering; they don't
  24 // respond to events. Instead, when the GtkCustomMenuItem is activated by the
  25 // GtkMenu, it uses which button was selected as a signal of what to do.
  26 //
  27 // Users should connect to the "button-pushed" signal to be notified when a
  28 // button was pushed. We don't go through the normal "activate" signal because
  29 // we need to communicate additional information, namely which button was
  30 // activated.
  31
  32 #include <gtk/gtk.h>
  33
  34 G_BEGIN_DECLS
  35
  36 #define GTK_TYPE_CUSTOM_MENU_ITEM                                       \
  37   (gtk_custom_menu_item_get_type())
  38 #define GTK_CUSTOM_MENU_ITEM(obj)                                       \
  39   (G_TYPE_CHECK_INSTANCE_CAST((obj), GTK_TYPE_CUSTOM_MENU_ITEM,         \
  40                               GtkCustomMenuItem))
  41 #define GTK_CUSTOM_MENU_ITEM_CLASS(klass)                               \
  42   (G_TYPE_CHECK_CLASS_CAST((klass), GTK_TYPE_CUSTOM_MENU_ITEM,          \
  43                            GtkCustomMenuItemClass))
  44 #define GTK_IS_CUSTOM_MENU_ITEM(obj)                                    \
  45   (G_TYPE_CHECK_INSTANCE_TYPE((obj), GTK_TYPE_CUSTOM_MENU_ITEM))
  46 #define GTK_IS_CUSTOM_MENU_ITEM_CLASS(klass)                            \
  47   (G_TYPE_CHECK_CLASS_TYPE((klass), GTK_TYPE_CUSTOM_MENU_ITEM))
  48 #define GTK_CUSTOM_MENU_ITEM_GET_CLASS(obj)                             \
  49   (G_TYPE_INSTANCE_GET_CLASS((obj), GTK_TYPE_CUSTOM_MENU_ITEM,          \
  50                              GtkCustomMenuItemClass))
  51
  52 typedef struct _GtkCustomMenuItem GtkCustomMenuItem;
  53 typedef struct _GtkCustomMenuItemClass GtkCustomMenuItemClass;
  54
  55 struct _GtkCustomMenuItem {
  56   GtkMenuItem menu_item;
  57
  58   // Container for button widgets.
  59   GtkWidget* hbox;
  60
  61   // Label on left side of menu item.
  62   GtkWidget* label;
  63
  64   // List of all widgets we added. Used to find the leftmost and rightmost
  65   // continuous buttons.
  66   GList* all_widgets;
  67
  68   // Possible button widgets. Used for keyboard navigation.
  69   GList* button_widgets;
  70
  71   // The widget that currently has highlight.
  72   GtkWidget* currently_selected_button;
  73
  74   // The widget that was selected *before* |currently_selected_button|. Why do
  75   // we hang on to this? Because the menu system sends us a deselect signal
  76   // right before activating us. We need to listen to deselect since that's
  77   // what we receive when the mouse cursor leaves us entirely.
  78   GtkWidget* previously_selected_button;
  79 };
  80
  81 struct _GtkCustomMenuItemClass {
  82   GtkMenuItemClass parent_class;
  83 };
  84
  85 GType gtk_custom_menu_item_get_type(void) G_GNUC_CONST;
  86 GtkWidget* gtk_custom_menu_item_new(const char* title);
  87
  88 // Adds a button to our list of items in the |hbox|.
  89 GtkWidget* gtk_custom_menu_item_add_button(GtkCustomMenuItem* menu_item,
  90                                            int command_id);
  91
  92 // Adds a button to our list of items in the |hbox|, but that isn't part of
  93 // |button_widgets| to prevent it from being activatable.
  94 GtkWidget* gtk_custom_menu_item_add_button_label(GtkCustomMenuItem* menu_item,
  95                                                  int command_id);
  96
  97 // Adds a vertical space in the |hbox|.
  98 void gtk_custom_menu_item_add_space(GtkCustomMenuItem* menu_item);
  99
 100 // Receives a motion event from the GtkCustomMenu that contains us. We can't
 101 // just subscribe to motion-event or the individual widget enter/leave events
 102 // because the top level GtkMenu has an event grab.
 103 void gtk_custom_menu_item_receive_motion_event(GtkCustomMenuItem* menu_item,
 104                                                gdouble x, gdouble y);
 105
 106 // Notification that the menu got a cursor key event. Used to move up/down
 107 // within the menu buttons. Returns TRUE to stop the default signal handler
 108 // from running.
 109 gboolean gtk_custom_menu_item_handle_move(GtkCustomMenuItem* menu_item,
 110                                           GtkMenuDirectionType direction);
 111
 112 // Because we only get a generic "selected" signal when we've changed, we need
 113 // to have a way for the GtkCustomMenu to tell us that we were just
 114 // selected.
 115 void gtk_custom_menu_item_select_item_by_direction(
 116     GtkCustomMenuItem* menu_item, GtkMenuDirectionType direction);
 117
 118 // Whether we are currently hovering over a clickable region on the menu
 119 // item. Used by GtkCustomMenu to determine whether it should discard click
 120 // events.
 121 gboolean gtk_custom_menu_item_is_in_clickable_region(
 122     GtkCustomMenuItem* menu_item);
 123
 124 // If the button is released while the |currently_selected_button| isn't
 125 // supposed to dismiss the menu, this signals to our listeners that we want to
 126 // run this command if it doesn't dismiss the menu.  Returns TRUE if we acted
 127 // on this button click (and should prevent the normal GtkMenu machinery from
 128 // firing an "activate" signal).
 129 gboolean gtk_custom_menu_item_try_no_dismiss_command(
 130     GtkCustomMenuItem* menu_item);
 131
 132 // Calls |callback| with every button and button-label in the container.
 133 void gtk_custom_menu_item_foreach_button(GtkCustomMenuItem* menu_item,
 134                                          GtkCallback callback,
 135                                          gpointer callback_data);
 136
 137 G_END_DECLS
 138
 139 #endif  // CHROME_BROWSER_UI_GTK_GTK_CUSTOM_MENU_ITEM_H_