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_COMBOBOX_COMBOBOX_H_
6#define UI_VIEWS_CONTROLS_COMBOBOX_COMBOBOX_H_
7
8#include <string>
9
10#include "base/memory/weak_ptr.h"
11#include "base/time/time.h"
12#include "ui/base/models/combobox_model_observer.h"
13#include "ui/gfx/animation/animation_delegate.h"
14#include "ui/gfx/native_widget_types.h"
15#include "ui/views/controls/button/button.h"
16#include "ui/views/controls/menu/menu_delegate.h"
17#include "ui/views/controls/prefix_delegate.h"
18
19namespace gfx {
20class FontList;
21class SlideAnimation;
22}
23
24namespace ui {
25class ComboboxModel;
26}
27
28namespace views {
29
30class ComboboxListener;
31class ComboboxMenuRunner;
32class CustomButton;
33class FocusableBorder;
34class MenuRunner;
35class MenuRunnerHandler;
36class Painter;
37class PrefixSelector;
38
39// A non-editable combobox (aka a drop-down list or selector).
40// Combobox has two distinct parts, the drop down arrow and the text. Combobox
41// offers two distinct behaviors:
42// * STYLE_NORMAL: typical combobox, clicking on the text and/or button shows
43// the drop down, arrow keys change selection, selected index can be changed by
44// the user to something other than the first item.
45// * STYLE_ACTION: clicking on the text notifies the listener. The menu can be
46// shown only by clicking on the arrow. The selected index is always reverted to
47// 0 after the listener is notified.
48class VIEWS_EXPORT Combobox : public MenuDelegate,
49                              public PrefixDelegate,
50                              public ui::ComboboxModelObserver,
51                              public ButtonListener {
52 public:
53  // The style of the combobox.
54  enum Style {
55    STYLE_NORMAL,
56    STYLE_ACTION,
57  };
58
59  // The combobox's class name.
60  static const char kViewClassName[];
61
62  // |model| is not owned by the combobox.
63  explicit Combobox(ui::ComboboxModel* model);
64  virtual ~Combobox();
65
66  static const gfx::FontList& GetFontList();
67
68  // Sets the listener which will be called when a selection has been made.
69  void set_listener(ComboboxListener* listener) { listener_ = listener; }
70
71  void SetStyle(Style style);
72
73  // Informs the combobox that its model changed.
74  void ModelChanged();
75
76  // Gets/Sets the selected index.
77  int selected_index() const { return selected_index_; }
78  void SetSelectedIndex(int index);
79
80  // Looks for the first occurrence of |value| in |model()|. If found, selects
81  // the found index and returns true. Otherwise simply noops and returns false.
82  bool SelectValue(const base::string16& value);
83
84  ui::ComboboxModel* model() const { return model_; }
85
86  // Set the accessible name of the combobox.
87  void SetAccessibleName(const base::string16& name);
88
89  // Visually marks the combobox as having an invalid value selected.
90  // When invalid, it paints with white text on a red background.
91  // Callers are responsible for restoring validity with selection changes.
92  void SetInvalid(bool invalid);
93  bool invalid() const { return invalid_; }
94
95  // Overridden from View:
96  virtual gfx::Size GetPreferredSize() const OVERRIDE;
97  virtual const char* GetClassName() const OVERRIDE;
98  virtual bool SkipDefaultKeyEventProcessing(const ui::KeyEvent& e) OVERRIDE;
99  virtual bool OnKeyPressed(const ui::KeyEvent& e) OVERRIDE;
100  virtual bool OnKeyReleased(const ui::KeyEvent& e) OVERRIDE;
101  virtual void OnPaint(gfx::Canvas* canvas) OVERRIDE;
102  virtual void OnFocus() OVERRIDE;
103  virtual void OnBlur() OVERRIDE;
104  virtual void GetAccessibleState(ui::AXViewState* state) OVERRIDE;
105  virtual ui::TextInputClient* GetTextInputClient() OVERRIDE;
106  virtual void Layout() OVERRIDE;
107
108  // Overridden from MenuDelegate:
109  virtual bool IsItemChecked(int id) const OVERRIDE;
110  virtual bool IsCommandEnabled(int id) const OVERRIDE;
111  virtual void ExecuteCommand(int id) OVERRIDE;
112  virtual bool GetAccelerator(int id,
113                              ui::Accelerator* accelerator) const OVERRIDE;
114
115  // Overridden from PrefixDelegate:
116  virtual int GetRowCount() OVERRIDE;
117  virtual int GetSelectedRow() OVERRIDE;
118  virtual void SetSelectedRow(int row) OVERRIDE;
119  virtual base::string16 GetTextForRow(int row) OVERRIDE;
120
121  // Overriden from ComboboxModelObserver:
122  virtual void OnComboboxModelChanged(ui::ComboboxModel* model) OVERRIDE;
123
124  // Overriden from ButtonListener:
125  virtual void ButtonPressed(Button* sender, const ui::Event& event) OVERRIDE;
126
127 private:
128  FRIEND_TEST_ALL_PREFIXES(ComboboxTest, Click);
129  FRIEND_TEST_ALL_PREFIXES(ComboboxTest, ClickButDisabled);
130  FRIEND_TEST_ALL_PREFIXES(ComboboxTest, NotifyOnClickWithMouse);
131  FRIEND_TEST_ALL_PREFIXES(ComboboxTest, ContentWidth);
132
133  // Updates the combobox's content from its model.
134  void UpdateFromModel();
135
136  // Updates the border according to the current state.
137  void UpdateBorder();
138
139  // Given bounds within our View, this helper mirrors the bounds if necessary.
140  void AdjustBoundsForRTLUI(gfx::Rect* rect) const;
141
142  // Draws the selected value of the drop down list
143  void PaintText(gfx::Canvas* canvas);
144
145  // Draws the button images.
146  void PaintButtons(gfx::Canvas* canvas);
147
148  // Show the drop down list
149  void ShowDropDownMenu(ui::MenuSourceType source_type);
150
151  // Called when the selection is changed by the user.
152  void OnPerformAction();
153  void NotifyPerformAction();
154  void AfterPerformAction();
155
156  // Converts a menu command ID to a menu item index.
157  int MenuCommandToIndex(int menu_command_id) const;
158
159  int GetDisclosureArrowLeftPadding() const;
160  int GetDisclosureArrowRightPadding() const;
161
162  // Returns the size of the disclosure arrow.
163  gfx::Size ArrowSize() const;
164
165  // Handles the clicking event.
166  void HandleClickEvent();
167
168  // Our model. Not owned.
169  ui::ComboboxModel* model_;
170
171  // The visual style of this combobox.
172  Style style_;
173
174  // Our listener. Not owned. Notified when the selected index change.
175  ComboboxListener* listener_;
176
177  // The current selected index; -1 and means no selection.
178  int selected_index_;
179
180  // True when the selection is visually denoted as invalid.
181  bool invalid_;
182
183  // The accessible name of this combobox.
184  base::string16 accessible_name_;
185
186  // A helper used to select entries by keyboard input.
187  scoped_ptr<PrefixSelector> selector_;
188
189  // Responsible for showing the context menu.
190  scoped_ptr<MenuRunner> dropdown_list_menu_runner_;
191
192  // Weak. Owned by dropdown_list_menu_runner_.
193  MenuItemView* menu_;
194
195  // Is the drop down list showing
196  bool dropdown_open_;
197
198  // Like MenuButton, we use a time object in order to keep track of when the
199  // combobox was closed. The time is used for simulating menu behavior; that
200  // is, if the menu is shown and the button is pressed, we need to close the
201  // menu. There is no clean way to get the second click event because the
202  // menu is displayed using a modal loop and, unlike regular menus in Windows,
203  // the button is not part of the displayed menu.
204  base::Time closed_time_;
205
206  // The maximum dimensions of the content in the dropdown
207  mutable gfx::Size content_size_;
208
209  // The painters or images that are used when |style_| is STYLE_BUTTONS. The
210  // first index means the state of unfocused or focused.
211  // The images are owned by ResourceBundle.
212  scoped_ptr<Painter> body_button_painters_[2][Button::STATE_COUNT];
213  std::vector<const gfx::ImageSkia*>
214      menu_button_images_[2][Button::STATE_COUNT];
215
216  // The transparent buttons to handle events and render buttons. These are
217  // placed on top of this combobox as child views, accept event and manage the
218  // button states. These are not rendered but when |style_| is
219  // STYLE_NOTIFY_ON_CLICK, a Combobox renders the button images according to
220  // these button states.
221  // The base View takes the ownerships of these as child views.
222  CustomButton* text_button_;
223  CustomButton* arrow_button_;
224
225  // Used for making calbacks.
226  base::WeakPtrFactory<Combobox> weak_ptr_factory_;
227
228  DISALLOW_COPY_AND_ASSIGN(Combobox);
229};
230
231}  // namespace views
232
233#endif  // UI_VIEWS_CONTROLS_COMBOBOX_COMBOBOX_H_
234