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
17using ui::OSExchangeData;
18
19namespace gfx {
20class Font;
21}
22
23namespace ui {
24class Accelerator;
25}
26
27namespace views {
28
29class 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.
36class 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;
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.
191  virtual void DropMenuClosed(MenuItemView* menu) {
192  }
193
194  // Notification that the user has highlighted the specified item.
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