| OLD | NEW |
|---|
| (Empty) |
| 1 // Copyright (c) 2012 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_MENU_GTK_H_ | |
| 6 #define CHROME_BROWSER_UI_GTK_MENU_GTK_H_ | |
| 7 | |
| 8 #include <gtk/gtk.h> | |
| 9 | |
| 10 #include <string> | |
| 11 #include <vector> | |
| 12 | |
| 13 #include "base/memory/weak_ptr.h" | |
| 14 #include "ui/base/gtk/gtk_signal.h" | |
| 15 #include "ui/base/gtk/gtk_signal_registrar.h" | |
| 16 #include "ui/gfx/point.h" | |
| 17 | |
| 18 namespace gfx { | |
| 19 class Image; | |
| 20 } | |
| 21 | |
| 22 namespace ui { | |
| 23 class ButtonMenuItemModel; | |
| 24 class MenuModel; | |
| 25 } | |
| 26 | |
| 27 class MenuGtk { | |
| 28 public: | |
| 29 // Delegate class that lets another class control the status of the menu. | |
| 30 class Delegate { | |
| 31 public: | |
| 32 virtual ~Delegate() {} | |
| 33 | |
| 34 // Called before a command is executed. This exists for the case where a | |
| 35 // model is handling the actual execution of commands, but the delegate | |
| 36 // still needs to know that some command got executed. This is called before | |
| 37 // and not after the command is executed because its execution may delete | |
| 38 // the menu and/or the delegate. | |
| 39 virtual void CommandWillBeExecuted() {} | |
| 40 | |
| 41 // Called when the menu stops showing. This will be called before | |
| 42 // ExecuteCommand if the user clicks an item, but will also be called when | |
| 43 // the user clicks away from the menu. | |
| 44 virtual void StoppedShowing() {} | |
| 45 | |
| 46 // Return true if we should override the "gtk-menu-images" system setting | |
| 47 // when showing image menu items for this menu. | |
| 48 virtual bool AlwaysShowIconForCmd(int command_id) const; | |
| 49 | |
| 50 // Returns a tinted image used in button in a menu. | |
| 51 virtual GtkIconSet* GetIconSetForId(int idr); | |
| 52 | |
| 53 // Returns an icon for the menu item, if available. | |
| 54 virtual GtkWidget* GetImageForCommandId(int command_id) const; | |
| 55 | |
| 56 static GtkWidget* GetDefaultImageForCommandId(int command_id); | |
| 57 }; | |
| 58 | |
| 59 MenuGtk(MenuGtk::Delegate* delegate, ui::MenuModel* model); | |
| 60 virtual ~MenuGtk(); | |
| 61 | |
| 62 // Initialize GTK signal handlers. | |
| 63 void ConnectSignalHandlers(); | |
| 64 | |
| 65 // These methods are used to build the menu dynamically. The return value | |
| 66 // is the new menu item. | |
| 67 GtkWidget* AppendMenuItemWithLabel(int command_id, const std::string& label); | |
| 68 GtkWidget* AppendMenuItemWithIcon(int command_id, const std::string& label, | |
| 69 const gfx::Image& icon); | |
| 70 GtkWidget* AppendCheckMenuItemWithLabel(int command_id, | |
| 71 const std::string& label); | |
| 72 GtkWidget* AppendSeparator(); | |
| 73 GtkWidget* InsertSeparator(int position); | |
| 74 GtkWidget* AppendMenuItem(int command_id, GtkWidget* menu_item); | |
| 75 GtkWidget* InsertMenuItem(int command_id, GtkWidget* menu_item, int position); | |
| 76 GtkWidget* AppendMenuItemToMenu(int index, | |
| 77 ui::MenuModel* model, | |
| 78 GtkWidget* menu_item, | |
| 79 GtkWidget* menu, | |
| 80 bool connect_to_activate); | |
| 81 GtkWidget* InsertMenuItemToMenu(int index, | |
| 82 ui::MenuModel* model, | |
| 83 GtkWidget* menu_item, | |
| 84 GtkWidget* menu, | |
| 85 int position, | |
| 86 bool connect_to_activate); | |
| 87 | |
| 88 // Displays the menu near a widget, as if the widget were a menu bar. | |
| 89 // Example: the wrench menu button. | |
| 90 // |button| is the mouse button that brought up the menu. | |
| 91 // |event_time| is the time from the GdkEvent. | |
| 92 void PopupForWidget(GtkWidget* widget, int button, guint32 event_time); | |
| 93 | |
| 94 // Displays the menu as a context menu, i.e. at the cursor location. | |
| 95 // It is implicit that it was brought up using the right mouse button. | |
| 96 // |point| is the point where to put the menu. | |
| 97 // |event_time| is the time of the event that triggered the menu's display. | |
| 98 void PopupAsContext(const gfx::Point& point, guint32 event_time); | |
| 99 | |
| 100 // Displays the menu as a context menu for the passed status icon. | |
| 101 void PopupAsContextForStatusIcon(guint32 event_time, guint32 button, | |
| 102 GtkStatusIcon* icon); | |
| 103 | |
| 104 // Displays the menu following a keyboard event (such as selecting |widget| | |
| 105 // and pressing "enter"). | |
| 106 void PopupAsFromKeyEvent(GtkWidget* widget); | |
| 107 | |
| 108 // Closes the menu. | |
| 109 void Cancel(); | |
| 110 | |
| 111 // Repositions the menu to be right under the button. Alignment is set as | |
| 112 // object data on |void_widget| with the tag "left_align". If "left_align" | |
| 113 // is true, it aligns the left side of the menu with the left side of the | |
| 114 // button. Otherwise it aligns the right side of the menu with the right side | |
| 115 // of the button. Public since some menus have odd requirements that don't | |
| 116 // belong in a public class. | |
| 117 static void WidgetMenuPositionFunc(GtkMenu* menu, | |
| 118 int* x, | |
| 119 int* y, | |
| 120 gboolean* push_in, | |
| 121 void* void_widget); | |
| 122 | |
| 123 // Positions the menu to appear at the gfx::Point represented by |userdata|. | |
| 124 static void PointMenuPositionFunc(GtkMenu* menu, | |
| 125 int* x, | |
| 126 int* y, | |
| 127 gboolean* push_in, | |
| 128 gpointer userdata); | |
| 129 | |
| 130 GtkWidget* widget() const { return menu_; } | |
| 131 | |
| 132 // Updates all the enabled/checked states and the dynamic labels. | |
| 133 void UpdateMenu(); | |
| 134 | |
| 135 private: | |
| 136 // Builds a GtkImageMenuItem. | |
| 137 GtkWidget* BuildMenuItemWithImage(const std::string& label, | |
| 138 const gfx::Image& icon); | |
| 139 | |
| 140 GtkWidget* BuildMenuItemWithImage(const std::string& label, | |
| 141 GtkWidget* image); | |
| 142 | |
| 143 GtkWidget* BuildMenuItemWithLabel(const std::string& label, | |
| 144 int command_id); | |
| 145 | |
| 146 // A function that creates a GtkMenu from |model_|. | |
| 147 void BuildMenuFromModel(); | |
| 148 // Implementation of the above; called recursively. | |
| 149 void BuildSubmenuFromModel(ui::MenuModel* model, GtkWidget* menu); | |
| 150 // Builds a menu item with buttons in it from the data in the model. | |
| 151 GtkWidget* BuildButtonMenuItem(ui::ButtonMenuItemModel* model, | |
| 152 GtkWidget* menu); | |
| 153 | |
| 154 void ExecuteCommand(ui::MenuModel* model, int id); | |
| 155 | |
| 156 // Callback for when a menu item is clicked. | |
| 157 CHROMEGTK_CALLBACK_0(MenuGtk, void, OnMenuItemActivated); | |
| 158 | |
| 159 // Called when one of the buttons is pressed. | |
| 160 CHROMEGTK_CALLBACK_1(MenuGtk, void, OnMenuButtonPressed, int); | |
| 161 | |
| 162 // Called to maybe activate a button if that button isn't supposed to dismiss | |
| 163 // the menu. | |
| 164 CHROMEGTK_CALLBACK_1(MenuGtk, gboolean, OnMenuTryButtonPressed, int); | |
| 165 | |
| 166 // Updates all the menu items' state. | |
| 167 CHROMEGTK_CALLBACK_0(MenuGtk, void, OnMenuShow); | |
| 168 | |
| 169 // Sets the activating widget back to a normal appearance. | |
| 170 CHROMEGTK_CALLBACK_0(MenuGtk, void, OnMenuHidden); | |
| 171 | |
| 172 // Focus out event handler for the menu. | |
| 173 CHROMEGTK_CALLBACK_1(MenuGtk, gboolean, OnMenuFocusOut, GdkEventFocus*); | |
| 174 | |
| 175 // Handles building dynamic submenus on demand when they are shown. | |
| 176 CHROMEGTK_CALLBACK_0(MenuGtk, void, OnSubMenuShow); | |
| 177 | |
| 178 // Handles trearing down dynamic submenus when they have been closed. | |
| 179 CHROMEGTK_CALLBACK_0(MenuGtk, void, OnSubMenuHidden); | |
| 180 | |
| 181 // Scheduled by OnSubMenuHidden() to avoid deleting submenus when hidden | |
| 182 // before pending activations within them are delivered. | |
| 183 static void OnSubMenuHiddenCallback(GtkWidget* submenu); | |
| 184 | |
| 185 // Sets the enable/disabled state and dynamic labels on our menu items. | |
| 186 static void SetButtonItemInfo(GtkWidget* button, gpointer userdata); | |
| 187 | |
| 188 // Sets the check mark, enabled/disabled state and dynamic labels on our menu | |
| 189 // items. | |
| 190 static void SetMenuItemInfo(GtkWidget* widget, void* raw_menu); | |
| 191 | |
| 192 // Queries this object about the menu state. | |
| 193 MenuGtk::Delegate* delegate_; | |
| 194 | |
| 195 // If non-NULL, the MenuModel that we use to populate and control the GTK | |
| 196 // menu (overriding the delegate as a controller). | |
| 197 ui::MenuModel* model_; | |
| 198 | |
| 199 // For some menu items, we want to show the accelerator, but not actually | |
| 200 // explicitly handle it. To this end we connect those menu items' accelerators | |
| 201 // to this group, but don't attach this group to any top level window. | |
| 202 GtkAccelGroup* dummy_accel_group_; | |
| 203 | |
| 204 // gtk_menu_popup() does not appear to take ownership of popup menus, so | |
| 205 // MenuGtk explicitly manages the lifetime of the menu. | |
| 206 GtkWidget* menu_; | |
| 207 | |
| 208 // True when we should ignore "activate" signals. Used to prevent | |
| 209 // menu items from getting activated when we are setting up the | |
| 210 // menu. | |
| 211 static bool block_activation_; | |
| 212 | |
| 213 ui::GtkSignalRegistrar signal_; | |
| 214 | |
| 215 base::WeakPtrFactory<MenuGtk> weak_factory_; | |
| 216 }; | |
| 217 | |
| 218 #endif // CHROME_BROWSER_UI_GTK_MENU_GTK_H_ | |
| OLD | NEW |
|---|
Chromium Code Reviews
Issue 231733005:
Delete the GTK+ port of Chrome. (Closed)
Base URL: svn://svn.chromium.org/chrome/trunk/src