| 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 #include "ui/views/controls/menu/menu_model_adapter.h" | |
| 6 | |
| 7 #include "base/strings/utf_string_conversions.h" | |
| 8 #include "ui/base/models/menu_model.h" | |
| 9 #include "ui/base/models/menu_model_delegate.h" | |
| 10 #include "ui/views/controls/menu/menu_item_view.h" | |
| 11 #include "ui/views/controls/menu/menu_runner.h" | |
| 12 #include "ui/views/controls/menu/submenu_view.h" | |
| 13 #include "ui/views/test/views_test_base.h" | |
| 14 | |
| 15 namespace { | |
| 16 | |
| 17 // Base command id for test menu and its submenu. | |
| 18 const int kRootIdBase = 100; | |
| 19 const int kSubmenuIdBase = 200; | |
| 20 | |
| 21 class MenuModelBase : public ui::MenuModel { | |
| 22 public: | |
| 23 explicit MenuModelBase(int command_id_base) | |
| 24 : command_id_base_(command_id_base), | |
| 25 last_activation_(-1) { | |
| 26 } | |
| 27 | |
| 28 virtual ~MenuModelBase() { | |
| 29 } | |
| 30 | |
| 31 // ui::MenuModel implementation: | |
| 32 | |
| 33 virtual bool HasIcons() const override { | |
| 34 return false; | |
| 35 } | |
| 36 | |
| 37 virtual int GetItemCount() const override { | |
| 38 return static_cast<int>(items_.size()); | |
| 39 } | |
| 40 | |
| 41 virtual ItemType GetTypeAt(int index) const override { | |
| 42 return items_[index].type; | |
| 43 } | |
| 44 | |
| 45 virtual ui::MenuSeparatorType GetSeparatorTypeAt( | |
| 46 int index) const override { | |
| 47 return ui::NORMAL_SEPARATOR; | |
| 48 } | |
| 49 | |
| 50 virtual int GetCommandIdAt(int index) const override { | |
| 51 return index + command_id_base_; | |
| 52 } | |
| 53 | |
| 54 virtual base::string16 GetLabelAt(int index) const override { | |
| 55 return items_[index].label; | |
| 56 } | |
| 57 | |
| 58 virtual bool IsItemDynamicAt(int index) const override { | |
| 59 return false; | |
| 60 } | |
| 61 | |
| 62 virtual const gfx::FontList* GetLabelFontListAt(int index) const override { | |
| 63 return NULL; | |
| 64 } | |
| 65 | |
| 66 virtual bool GetAcceleratorAt(int index, | |
| 67 ui::Accelerator* accelerator) const override { | |
| 68 return false; | |
| 69 } | |
| 70 | |
| 71 virtual bool IsItemCheckedAt(int index) const override { | |
| 72 return false; | |
| 73 } | |
| 74 | |
| 75 virtual int GetGroupIdAt(int index) const override { | |
| 76 return 0; | |
| 77 } | |
| 78 | |
| 79 virtual bool GetIconAt(int index, gfx::Image* icon) override { | |
| 80 return false; | |
| 81 } | |
| 82 | |
| 83 virtual ui::ButtonMenuItemModel* GetButtonMenuItemAt( | |
| 84 int index) const override { | |
| 85 return NULL; | |
| 86 } | |
| 87 | |
| 88 virtual bool IsEnabledAt(int index) const override { | |
| 89 return true; | |
| 90 } | |
| 91 | |
| 92 virtual bool IsVisibleAt(int index) const override { | |
| 93 return true; | |
| 94 } | |
| 95 | |
| 96 virtual MenuModel* GetSubmenuModelAt(int index) const override { | |
| 97 return items_[index].submenu; | |
| 98 } | |
| 99 | |
| 100 virtual void HighlightChangedTo(int index) override { | |
| 101 } | |
| 102 | |
| 103 virtual void ActivatedAt(int index) override { | |
| 104 set_last_activation(index); | |
| 105 } | |
| 106 | |
| 107 virtual void ActivatedAt(int index, int event_flags) override { | |
| 108 ActivatedAt(index); | |
| 109 } | |
| 110 | |
| 111 virtual void MenuWillShow() override { | |
| 112 } | |
| 113 | |
| 114 virtual void MenuClosed() override { | |
| 115 } | |
| 116 | |
| 117 virtual void SetMenuModelDelegate( | |
| 118 ui::MenuModelDelegate* delegate) override { | |
| 119 } | |
| 120 | |
| 121 virtual ui::MenuModelDelegate* GetMenuModelDelegate() const override { | |
| 122 return NULL; | |
| 123 } | |
| 124 | |
| 125 // Item definition. | |
| 126 struct Item { | |
| 127 Item(ItemType item_type, | |
| 128 const std::string& item_label, | |
| 129 ui::MenuModel* item_submenu) | |
| 130 : type(item_type), | |
| 131 label(base::ASCIIToUTF16(item_label)), | |
| 132 submenu(item_submenu) { | |
| 133 } | |
| 134 | |
| 135 ItemType type; | |
| 136 base::string16 label; | |
| 137 ui::MenuModel* submenu; | |
| 138 }; | |
| 139 | |
| 140 const Item& GetItemDefinition(int index) { | |
| 141 return items_[index]; | |
| 142 } | |
| 143 | |
| 144 // Access index argument to ActivatedAt(). | |
| 145 int last_activation() const { return last_activation_; } | |
| 146 void set_last_activation(int last_activation) { | |
| 147 last_activation_ = last_activation; | |
| 148 } | |
| 149 | |
| 150 protected: | |
| 151 std::vector<Item> items_; | |
| 152 | |
| 153 private: | |
| 154 int command_id_base_; | |
| 155 int last_activation_; | |
| 156 | |
| 157 DISALLOW_COPY_AND_ASSIGN(MenuModelBase); | |
| 158 }; | |
| 159 | |
| 160 class SubmenuModel : public MenuModelBase { | |
| 161 public: | |
| 162 SubmenuModel() : MenuModelBase(kSubmenuIdBase) { | |
| 163 items_.push_back(Item(TYPE_COMMAND, "submenu item 0", NULL)); | |
| 164 items_.push_back(Item(TYPE_COMMAND, "submenu item 1", NULL)); | |
| 165 } | |
| 166 | |
| 167 virtual ~SubmenuModel() { | |
| 168 } | |
| 169 | |
| 170 private: | |
| 171 DISALLOW_COPY_AND_ASSIGN(SubmenuModel); | |
| 172 }; | |
| 173 | |
| 174 class RootModel : public MenuModelBase { | |
| 175 public: | |
| 176 RootModel() : MenuModelBase(kRootIdBase) { | |
| 177 submenu_model_.reset(new SubmenuModel); | |
| 178 | |
| 179 items_.push_back(Item(TYPE_COMMAND, "command 0", NULL)); | |
| 180 items_.push_back(Item(TYPE_CHECK, "check 1", NULL)); | |
| 181 items_.push_back(Item(TYPE_SEPARATOR, "", NULL)); | |
| 182 items_.push_back(Item(TYPE_SUBMENU, "submenu 3", submenu_model_.get())); | |
| 183 items_.push_back(Item(TYPE_RADIO, "radio 4", NULL)); | |
| 184 } | |
| 185 | |
| 186 virtual ~RootModel() { | |
| 187 } | |
| 188 | |
| 189 private: | |
| 190 scoped_ptr<MenuModel> submenu_model_; | |
| 191 | |
| 192 DISALLOW_COPY_AND_ASSIGN(RootModel); | |
| 193 }; | |
| 194 | |
| 195 } // namespace | |
| 196 | |
| 197 namespace views { | |
| 198 | |
| 199 typedef ViewsTestBase MenuModelAdapterTest; | |
| 200 | |
| 201 TEST_F(MenuModelAdapterTest, BasicTest) { | |
| 202 // Build model and adapter. | |
| 203 RootModel model; | |
| 204 views::MenuModelAdapter delegate(&model); | |
| 205 | |
| 206 // Create menu. Build menu twice to check that rebuilding works properly. | |
| 207 MenuItemView* menu = new views::MenuItemView(&delegate); | |
| 208 // MenuRunner takes ownership of menu. | |
| 209 scoped_ptr<MenuRunner> menu_runner(new MenuRunner(menu, 0)); | |
| 210 delegate.BuildMenu(menu); | |
| 211 delegate.BuildMenu(menu); | |
| 212 EXPECT_TRUE(menu->HasSubmenu()); | |
| 213 | |
| 214 // Check top level menu items. | |
| 215 views::SubmenuView* item_container = menu->GetSubmenu(); | |
| 216 EXPECT_EQ(5, item_container->child_count()); | |
| 217 | |
| 218 for (int i = 0; i < item_container->child_count(); ++i) { | |
| 219 const MenuModelBase::Item& model_item = model.GetItemDefinition(i); | |
| 220 | |
| 221 const int id = i + kRootIdBase; | |
| 222 MenuItemView* item = menu->GetMenuItemByID(id); | |
| 223 if (!item) { | |
| 224 EXPECT_EQ(ui::MenuModel::TYPE_SEPARATOR, model_item.type); | |
| 225 continue; | |
| 226 } | |
| 227 | |
| 228 // Check placement. | |
| 229 EXPECT_EQ(i, menu->GetSubmenu()->GetIndexOf(item)); | |
| 230 | |
| 231 // Check type. | |
| 232 switch (model_item.type) { | |
| 233 case ui::MenuModel::TYPE_COMMAND: | |
| 234 EXPECT_EQ(views::MenuItemView::NORMAL, item->GetType()); | |
| 235 break; | |
| 236 case ui::MenuModel::TYPE_CHECK: | |
| 237 EXPECT_EQ(views::MenuItemView::CHECKBOX, item->GetType()); | |
| 238 break; | |
| 239 case ui::MenuModel::TYPE_RADIO: | |
| 240 EXPECT_EQ(views::MenuItemView::RADIO, item->GetType()); | |
| 241 break; | |
| 242 case ui::MenuModel::TYPE_SEPARATOR: | |
| 243 case ui::MenuModel::TYPE_BUTTON_ITEM: | |
| 244 break; | |
| 245 case ui::MenuModel::TYPE_SUBMENU: | |
| 246 EXPECT_EQ(views::MenuItemView::SUBMENU, item->GetType()); | |
| 247 break; | |
| 248 } | |
| 249 | |
| 250 // Check activation. | |
| 251 static_cast<views::MenuDelegate*>(&delegate)->ExecuteCommand(id); | |
| 252 EXPECT_EQ(i, model.last_activation()); | |
| 253 model.set_last_activation(-1); | |
| 254 } | |
| 255 | |
| 256 // Check submenu items. | |
| 257 views::MenuItemView* submenu = menu->GetMenuItemByID(103); | |
| 258 views::SubmenuView* subitem_container = submenu->GetSubmenu(); | |
| 259 EXPECT_EQ(2, subitem_container->child_count()); | |
| 260 | |
| 261 for (int i = 0; i < subitem_container->child_count(); ++i) { | |
| 262 MenuModelBase* submodel = static_cast<MenuModelBase*>( | |
| 263 model.GetSubmenuModelAt(3)); | |
| 264 EXPECT_TRUE(submodel); | |
| 265 | |
| 266 const MenuModelBase::Item& model_item = submodel->GetItemDefinition(i); | |
| 267 | |
| 268 const int id = i + kSubmenuIdBase; | |
| 269 MenuItemView* item = menu->GetMenuItemByID(id); | |
| 270 if (!item) { | |
| 271 EXPECT_EQ(ui::MenuModel::TYPE_SEPARATOR, model_item.type); | |
| 272 continue; | |
| 273 } | |
| 274 | |
| 275 // Check placement. | |
| 276 EXPECT_EQ(i, submenu->GetSubmenu()->GetIndexOf(item)); | |
| 277 | |
| 278 // Check type. | |
| 279 switch (model_item.type) { | |
| 280 case ui::MenuModel::TYPE_COMMAND: | |
| 281 EXPECT_EQ(views::MenuItemView::NORMAL, item->GetType()); | |
| 282 break; | |
| 283 case ui::MenuModel::TYPE_CHECK: | |
| 284 EXPECT_EQ(views::MenuItemView::CHECKBOX, item->GetType()); | |
| 285 break; | |
| 286 case ui::MenuModel::TYPE_RADIO: | |
| 287 EXPECT_EQ(views::MenuItemView::RADIO, item->GetType()); | |
| 288 break; | |
| 289 case ui::MenuModel::TYPE_SEPARATOR: | |
| 290 case ui::MenuModel::TYPE_BUTTON_ITEM: | |
| 291 break; | |
| 292 case ui::MenuModel::TYPE_SUBMENU: | |
| 293 EXPECT_EQ(views::MenuItemView::SUBMENU, item->GetType()); | |
| 294 break; | |
| 295 } | |
| 296 | |
| 297 // Check activation. | |
| 298 static_cast<views::MenuDelegate*>(&delegate)->ExecuteCommand(id); | |
| 299 EXPECT_EQ(i, submodel->last_activation()); | |
| 300 submodel->set_last_activation(-1); | |
| 301 } | |
| 302 | |
| 303 // Check that selecting the root item is safe. The MenuModel does | |
| 304 // not care about the root so MenuModelAdapter should do nothing | |
| 305 // (not hit the NOTREACHED check) when the root is selected. | |
| 306 static_cast<views::MenuDelegate*>(&delegate)->SelectionChanged(menu); | |
| 307 } | |
| 308 | |
| 309 } // namespace views | |
| OLD | NEW |
|---|
Chromium Code Reviews
