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 19 namespace gfx { 20 class FontList; 21 class SlideAnimation; 22 } 23 24 namespace ui { 25 class ComboboxModel; 26 } 27 28 namespace views { 29 30 class ComboboxListener; 31 class ComboboxMenuRunner; 32 class CustomButton; 33 class FocusableBorder; 34 class MenuRunner; 35 class MenuRunnerHandler; 36 class Painter; 37 class 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. 48 class 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 // Is the drop down list showing 193 bool dropdown_open_; 194 195 // Like MenuButton, we use a time object in order to keep track of when the 196 // combobox was closed. The time is used for simulating menu behavior; that 197 // is, if the menu is shown and the button is pressed, we need to close the 198 // menu. There is no clean way to get the second click event because the 199 // menu is displayed using a modal loop and, unlike regular menus in Windows, 200 // the button is not part of the displayed menu. 201 base::Time closed_time_; 202 203 // The maximum dimensions of the content in the dropdown 204 mutable gfx::Size content_size_; 205 206 // The painters or images that are used when |style_| is STYLE_BUTTONS. The 207 // first index means the state of unfocused or focused. 208 // The images are owned by ResourceBundle. 209 scoped_ptr<Painter> body_button_painters_[2][Button::STATE_COUNT]; 210 std::vector<const gfx::ImageSkia*> 211 menu_button_images_[2][Button::STATE_COUNT]; 212 213 // The transparent buttons to handle events and render buttons. These are 214 // placed on top of this combobox as child views, accept event and manage the 215 // button states. These are not rendered but when |style_| is 216 // STYLE_NOTIFY_ON_CLICK, a Combobox renders the button images according to 217 // these button states. 218 // The base View takes the ownerships of these as child views. 219 CustomButton* text_button_; 220 CustomButton* arrow_button_; 221 222 // Used for making calbacks. 223 base::WeakPtrFactory<Combobox> weak_ptr_factory_; 224 225 DISALLOW_COPY_AND_ASSIGN(Combobox); 226 }; 227 228 } // namespace views 229 230 #endif // UI_VIEWS_CONTROLS_COMBOBOX_COMBOBOX_H_ 231