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