| 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 UI_VIEWS_CONTROLS_MENU_MENU_DELEGATE_H_ | |
| 6 #define UI_VIEWS_CONTROLS_MENU_MENU_DELEGATE_H_ | |
| 7 | |
| 8 #include <set> | |
| 9 #include <string> | |
| 10 | |
| 11 #include "base/logging.h" | |
| 12 #include "base/strings/string16.h" | |
| 13 #include "third_party/skia/include/core/SkColor.h" | |
| 14 #include "ui/base/dragdrop/drag_drop_types.h" | |
| 15 #include "ui/base/dragdrop/os_exchange_data.h" | |
| 16 #include "ui/base/ui_base_types.h" | |
| 17 #include "ui/views/controls/menu/menu_types.h" | |
| 18 #include "ui/views/views_export.h" | |
| 19 | |
| 20 using ui::OSExchangeData; | |
| 21 | |
| 22 namespace gfx { | |
| 23 class FontList; | |
| 24 class Point; | |
| 25 } | |
| 26 | |
| 27 namespace ui { | |
| 28 class Accelerator; | |
| 29 class DropTargetEvent; | |
| 30 } | |
| 31 | |
| 32 namespace views { | |
| 33 | |
| 34 class MenuButton; | |
| 35 class MenuItemView; | |
| 36 | |
| 37 // MenuDelegate -------------------------------------------------------------- | |
| 38 | |
| 39 // Delegate for a menu. This class is used as part of MenuItemView, see it | |
| 40 // for details. | |
| 41 // TODO(sky): merge this with ui::MenuModel. | |
| 42 class VIEWS_EXPORT MenuDelegate { | |
| 43 public: | |
| 44 // Used during drag and drop to indicate where the drop indicator should | |
| 45 // be rendered. | |
| 46 enum DropPosition { | |
| 47 DROP_UNKNOWN = -1, | |
| 48 | |
| 49 // Indicates a drop is not allowed here. | |
| 50 DROP_NONE, | |
| 51 | |
| 52 // Indicates the drop should occur before the item. | |
| 53 DROP_BEFORE, | |
| 54 | |
| 55 // Indicates the drop should occur after the item. | |
| 56 DROP_AFTER, | |
| 57 | |
| 58 // Indicates the drop should occur on the item. | |
| 59 DROP_ON | |
| 60 }; | |
| 61 | |
| 62 virtual ~MenuDelegate(); | |
| 63 | |
| 64 // Whether or not an item should be shown as checked. This is invoked for | |
| 65 // radio buttons and check buttons. | |
| 66 virtual bool IsItemChecked(int id) const; | |
| 67 | |
| 68 // The string shown for the menu item. This is only invoked when an item is | |
| 69 // added with an empty label. | |
| 70 virtual base::string16 GetLabel(int id) const; | |
| 71 | |
| 72 // The font for the menu item label. | |
| 73 virtual const gfx::FontList* GetLabelFontList(int id) const; | |
| 74 | |
| 75 // Whether this item should be displayed with a bolder color when disabled. | |
| 76 virtual bool GetShouldUseDisabledEmphasizedForegroundColor( | |
| 77 int command_id) const; | |
| 78 | |
| 79 // Override the text color of a given menu item dependent on the | |
| 80 // |command_id| and its |is_hovered| state. Returns true if it chooses to | |
| 81 // override the color. | |
| 82 // | |
| 83 // TODO(erg): Remove this interface. Injecting raw colors into the menu | |
| 84 // circumvents the NativeTheme. | |
| 85 virtual bool GetForegroundColor(int command_id, | |
| 86 bool is_hovered, | |
| 87 SkColor* override_color) const; | |
| 88 | |
| 89 // Override the background color of a given menu item dependent on the | |
| 90 // |command_id| and its |is_hovered| state. Returns true if it chooses to | |
| 91 // override the color. | |
| 92 // | |
| 93 // TODO(erg): Remove this interface. Injecting raw colors into the menu | |
| 94 // circumvents the NativeTheme. | |
| 95 virtual bool GetBackgroundColor(int command_id, | |
| 96 bool is_hovered, | |
| 97 SkColor* override_color) const; | |
| 98 | |
| 99 // The tooltip shown for the menu item. This is invoked when the user | |
| 100 // hovers over the item, and no tooltip text has been set for that item. | |
| 101 virtual base::string16 GetTooltipText(int id, | |
| 102 const gfx::Point& screen_loc) const; | |
| 103 | |
| 104 // If there is an accelerator for the menu item with id |id| it is set in | |
| 105 // |accelerator| and true is returned. | |
| 106 virtual bool GetAccelerator(int id, ui::Accelerator* accelerator) const; | |
| 107 | |
| 108 // Shows the context menu with the specified id. This is invoked when the | |
| 109 // user does the appropriate gesture to show a context menu. The id | |
| 110 // identifies the id of the menu to show the context menu for. | |
| 111 // is_mouse_gesture is true if this is the result of a mouse gesture. | |
| 112 // If this is not the result of a mouse gesture |p| is the recommended | |
| 113 // location to display the content menu at. In either case, |p| is in | |
| 114 // screen coordinates. | |
| 115 // Returns true if a context menu was displayed, otherwise false | |
| 116 virtual bool ShowContextMenu(MenuItemView* source, | |
| 117 int id, | |
| 118 const gfx::Point& p, | |
| 119 ui::MenuSourceType source_type); | |
| 120 | |
| 121 // Controller | |
| 122 virtual bool SupportsCommand(int id) const; | |
| 123 virtual bool IsCommandEnabled(int id) const; | |
| 124 virtual bool IsCommandVisible(int id) const; | |
| 125 virtual bool GetContextualLabel(int id, base::string16* out) const; | |
| 126 virtual void ExecuteCommand(int id) { | |
| 127 } | |
| 128 | |
| 129 // If nested menus are showing (nested menus occur when a menu shows a context | |
| 130 // menu) this is invoked to determine if all the menus should be closed when | |
| 131 // the user selects the menu with the command |id|. This returns true to | |
| 132 // indicate that all menus should be closed. Return false if only the | |
| 133 // context menu should be closed. | |
| 134 virtual bool ShouldCloseAllMenusOnExecute(int id); | |
| 135 | |
| 136 // Executes the specified command. mouse_event_flags give the flags of the | |
| 137 // mouse event that triggered this to be invoked (ui::MouseEvent | |
| 138 // flags). mouse_event_flags is 0 if this is triggered by a user gesture | |
| 139 // other than a mouse event. | |
| 140 virtual void ExecuteCommand(int id, int mouse_event_flags); | |
| 141 | |
| 142 // Returns true if ExecuteCommand() should be invoked while leaving the | |
| 143 // menu open. Default implementation returns true. | |
| 144 virtual bool ShouldExecuteCommandWithoutClosingMenu(int id, | |
| 145 const ui::Event& e); | |
| 146 | |
| 147 // Returns true if the specified event is one the user can use to trigger, or | |
| 148 // accept, the item. Defaults to left or right mouse buttons or tap. | |
| 149 virtual bool IsTriggerableEvent(MenuItemView* view, const ui::Event& e); | |
| 150 | |
| 151 // Invoked to determine if drops can be accepted for a submenu. This is | |
| 152 // ONLY invoked for menus that have submenus and indicates whether or not | |
| 153 // a drop can occur on any of the child items of the item. For example, | |
| 154 // consider the following menu structure: | |
| 155 // | |
| 156 // A | |
| 157 // B | |
| 158 // C | |
| 159 // | |
| 160 // Where A has a submenu with children B and C. This is ONLY invoked for | |
| 161 // A, not B and C. | |
| 162 // | |
| 163 | |
| 164 // To restrict which children can be dropped on override GetDropOperation. | |
| 165 virtual bool CanDrop(MenuItemView* menu, const OSExchangeData& data); | |
| 166 | |
| 167 // See view for a description of this method. | |
| 168 virtual bool GetDropFormats( | |
| 169 MenuItemView* menu, | |
| 170 int* formats, | |
| 171 std::set<OSExchangeData::CustomFormat>* custom_formats); | |
| 172 | |
| 173 // See view for a description of this method. | |
| 174 virtual bool AreDropTypesRequired(MenuItemView* menu); | |
| 175 | |
| 176 // Returns the drop operation for the specified target menu item. This is | |
| 177 // only invoked if CanDrop returned true for the parent menu. position | |
| 178 // is set based on the location of the mouse, reset to specify a different | |
| 179 // position. | |
| 180 // | |
| 181 // If a drop should not be allowed, returned ui::DragDropTypes::DRAG_NONE. | |
| 182 virtual int GetDropOperation(MenuItemView* item, | |
| 183 const ui::DropTargetEvent& event, | |
| 184 DropPosition* position); | |
| 185 | |
| 186 // Invoked to perform the drop operation. This is ONLY invoked if CanDrop() | |
| 187 // returned true for the parent menu item, and GetDropOperation() returned an | |
| 188 // operation other than ui::DragDropTypes::DRAG_NONE. | |
| 189 // | |
| 190 // |menu| is the menu the drop occurred on. | |
| 191 virtual int OnPerformDrop(MenuItemView* menu, | |
| 192 DropPosition position, | |
| 193 const ui::DropTargetEvent& event); | |
| 194 | |
| 195 // Invoked to determine if it is possible for the user to drag the specified | |
| 196 // menu item. | |
| 197 virtual bool CanDrag(MenuItemView* menu); | |
| 198 | |
| 199 // Invoked to write the data for a drag operation to data. sender is the | |
| 200 // MenuItemView being dragged. | |
| 201 virtual void WriteDragData(MenuItemView* sender, OSExchangeData* data); | |
| 202 | |
| 203 // Invoked to determine the drag operations for a drag session of sender. | |
| 204 // See DragDropTypes for possible values. | |
| 205 virtual int GetDragOperations(MenuItemView* sender); | |
| 206 | |
| 207 // Notification the menu has closed. This is only sent when running the | |
| 208 // menu for a drop. | |
| 209 virtual void DropMenuClosed(MenuItemView* menu) { | |
| 210 } | |
| 211 | |
| 212 // Returns true if the menu should close upon a drag completing. Defaults to | |
| 213 // true. This is only invoked for drag and drop operations performed on child | |
| 214 // Views that are not MenuItemViews. | |
| 215 virtual bool ShouldCloseOnDragComplete(); | |
| 216 | |
| 217 // Notification that the user has highlighted the specified item. | |
| 218 virtual void SelectionChanged(MenuItemView* menu) { | |
| 219 } | |
| 220 | |
| 221 // If the user drags the mouse outside the bounds of the menu the delegate | |
| 222 // is queried for a sibling menu to show. If this returns non-null the | |
| 223 // current menu is hidden, and the menu returned from this method is shown. | |
| 224 // | |
| 225 // The delegate owns the returned menu, not the controller. | |
| 226 virtual MenuItemView* GetSiblingMenu(MenuItemView* menu, | |
| 227 const gfx::Point& screen_point, | |
| 228 MenuAnchorPosition* anchor, | |
| 229 bool* has_mnemonics, | |
| 230 MenuButton** button); | |
| 231 | |
| 232 // Returns the max width menus can grow to be. | |
| 233 virtual int GetMaxWidthForMenu(MenuItemView* menu); | |
| 234 | |
| 235 // Invoked prior to a menu being shown. | |
| 236 virtual void WillShowMenu(MenuItemView* menu); | |
| 237 | |
| 238 // Invoked prior to a menu being hidden. | |
| 239 virtual void WillHideMenu(MenuItemView* menu); | |
| 240 | |
| 241 // Returns additional horizontal spacing for the icon of the given item. | |
| 242 // The |command_id| specifies the item of interest, the |icon_size| tells the | |
| 243 // function the size of the icon and it will then return |left_margin| | |
| 244 // and |right_margin| accordingly. Note: Negative values can be returned. | |
| 245 virtual void GetHorizontalIconMargins(int command_id, | |
| 246 int icon_size, | |
| 247 int* left_margin, | |
| 248 int* right_margin) const; | |
| 249 // Returns true if the labels should reserve additional spacing for e.g. | |
| 250 // submenu indicators at the end of the line. | |
| 251 virtual bool ShouldReserveSpaceForSubmenuIndicator() const; | |
| 252 }; | |
| 253 | |
| 254 } // namespace views | |
| 255 | |
| 256 #endif // UI_VIEWS_CONTROLS_MENU_MENU_DELEGATE_H_ | |
| OLD | NEW |
|---|
Chromium Code Reviews
