1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
|
// Copyright (c) 2012 The Chromium Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#ifndef UI_BASE_MODELS_SIMPLE_MENU_MODEL_H_
#define UI_BASE_MODELS_SIMPLE_MENU_MODEL_H_
#include <vector>
#include "base/memory/weak_ptr.h"
#include "base/string16.h"
#include "ui/base/models/menu_model.h"
namespace gfx {
class Image;
}
namespace ui {
class ButtonMenuItemModel;
// A simple MenuModel implementation with an imperative API for adding menu
// items. This makes it easy to construct fixed menus. Menus populated by
// dynamic data sources may be better off implementing MenuModel directly.
// The breadth of MenuModel is not exposed through this API.
class UI_EXPORT SimpleMenuModel : public MenuModel {
public:
class UI_EXPORT Delegate {
public:
// Methods for determining the state of specific command ids.
virtual bool IsCommandIdChecked(int command_id) const = 0;
virtual bool IsCommandIdEnabled(int command_id) const = 0;
virtual bool IsCommandIdVisible(int command_id) const;
// Gets the accelerator for the specified command id. Returns true if the
// command id has a valid accelerator, false otherwise.
virtual bool GetAcceleratorForCommandId(
int command_id,
ui::Accelerator* accelerator) = 0;
// Some command ids have labels and icons that change over time.
virtual bool IsItemForCommandIdDynamic(int command_id) const;
virtual string16 GetLabelForCommandId(int command_id) const;
// Gets the icon for the item with the specified id, returning true if there
// is an icon, false otherwise.
virtual bool GetIconForCommandId(int command_id,
gfx::Image* icon) const;
// Notifies the delegate that the item with the specified command id was
// visually highlighted within the menu.
virtual void CommandIdHighlighted(int command_id);
// Performs the action associates with the specified command id.
// The passed |event_flags| are the flags from the event which issued this
// command and they can be examined to find modifier keys.
virtual void ExecuteCommand(int command_id, int event_flags) = 0;
// Notifies the delegate that the menu is about to show.
virtual void MenuWillShow(SimpleMenuModel* source);
// Notifies the delegate that the menu has closed.
virtual void MenuClosed(SimpleMenuModel* source);
protected:
virtual ~Delegate() {}
};
// The Delegate can be NULL, though if it is items can't be checked or
// disabled.
explicit SimpleMenuModel(Delegate* delegate);
virtual ~SimpleMenuModel();
// Methods for adding items to the model.
void AddItem(int command_id, const string16& label);
void AddItemWithStringId(int command_id, int string_id);
void AddCheckItem(int command_id, const string16& label);
void AddCheckItemWithStringId(int command_id, int string_id);
void AddRadioItem(int command_id, const string16& label, int group_id);
void AddRadioItemWithStringId(int command_id, int string_id, int group_id);
// Adds a separator of the specified type to the model.
// - Adding a separator after another separator is always invalid if they
// differ in type, but silently ignored if they are both NORMAL.
// - Adding a separator to an empty model is invalid, unless they are NORMAL
// or SPACING. NORMAL separators are silently ignored if the model is empty.
void AddSeparator(MenuSeparatorType separator_type);
// Removes separators until the model's last entry is not a separator, or the
// model is empty.
void RemoveTrailingSeparators();
// These three methods take pointers to various sub-models. These models
// should be owned by the same owner of this SimpleMenuModel.
void AddButtonItem(int command_id, ButtonMenuItemModel* model);
void AddSubMenu(int command_id, const string16& label, MenuModel* model);
void AddSubMenuWithStringId(int command_id, int string_id, MenuModel* model);
// Methods for inserting items into the model.
void InsertItemAt(int index, int command_id, const string16& label);
void InsertItemWithStringIdAt(int index, int command_id, int string_id);
void InsertSeparatorAt(int index, MenuSeparatorType separator_type);
void InsertCheckItemAt(int index, int command_id, const string16& label);
void InsertCheckItemWithStringIdAt(int index, int command_id, int string_id);
void InsertRadioItemAt(
int index, int command_id, const string16& label, int group_id);
void InsertRadioItemWithStringIdAt(
int index, int command_id, int string_id, int group_id);
void InsertSubMenuAt(
int index, int command_id, const string16& label, MenuModel* model);
void InsertSubMenuWithStringIdAt(
int index, int command_id, int string_id, MenuModel* model);
// Sets the icon for the item at |index|.
void SetIcon(int index, const gfx::Image& icon);
// Clears all items. Note that it does not free MenuModel of submenu.
void Clear();
// Returns the index of the item that has the given |command_id|. Returns
// -1 if not found.
int GetIndexOfCommandId(int command_id);
// Overridden from MenuModel:
virtual bool HasIcons() const OVERRIDE;
virtual int GetItemCount() const OVERRIDE;
virtual ItemType GetTypeAt(int index) const OVERRIDE;
virtual ui::MenuSeparatorType GetSeparatorTypeAt(int index) const OVERRIDE;
virtual int GetCommandIdAt(int index) const OVERRIDE;
virtual string16 GetLabelAt(int index) const OVERRIDE;
virtual bool IsItemDynamicAt(int index) const OVERRIDE;
virtual bool GetAcceleratorAt(int index,
ui::Accelerator* accelerator) const OVERRIDE;
virtual bool IsItemCheckedAt(int index) const OVERRIDE;
virtual int GetGroupIdAt(int index) const OVERRIDE;
virtual bool GetIconAt(int index, gfx::Image* icon) OVERRIDE;
virtual ui::ButtonMenuItemModel* GetButtonMenuItemAt(
int index) const OVERRIDE;
virtual bool IsEnabledAt(int index) const OVERRIDE;
virtual bool IsVisibleAt(int index) const OVERRIDE;
virtual void HighlightChangedTo(int index) OVERRIDE;
virtual void ActivatedAt(int index) OVERRIDE;
virtual void ActivatedAt(int index, int event_flags) OVERRIDE;
virtual MenuModel* GetSubmenuModelAt(int index) const OVERRIDE;
virtual void MenuWillShow() OVERRIDE;
virtual void MenuClosed() OVERRIDE;
virtual void SetMenuModelDelegate(
ui::MenuModelDelegate* menu_model_delegate) OVERRIDE;
virtual MenuModelDelegate* GetMenuModelDelegate() const OVERRIDE;
protected:
void set_delegate(Delegate* delegate) { delegate_ = delegate; }
Delegate* delegate() { return delegate_; }
private:
struct Item;
typedef std::vector<Item> ItemVector;
// Returns |index|.
int ValidateItemIndex(int index) const;
// Functions for inserting items into |items_|.
void AppendItem(const Item& item);
void InsertItemAtIndex(const Item& item, int index);
void ValidateItem(const Item& item);
// Notify the delegate that the menu is closed.
void OnMenuClosed();
ItemVector items_;
Delegate* delegate_;
MenuModelDelegate* menu_model_delegate_;
base::WeakPtrFactory<SimpleMenuModel> method_factory_;
DISALLOW_COPY_AND_ASSIGN(SimpleMenuModel);
};
} // namespace ui
#endif // UI_BASE_MODELS_SIMPLE_MENU_MODEL_H_
|
