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