| 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/button/custom_button.h" | |
| 6 | |
| 7 #include "ui/accessibility/ax_view_state.h" | |
| 8 #include "ui/events/event.h" | |
| 9 #include "ui/events/keycodes/keyboard_codes.h" | |
| 10 #include "ui/gfx/animation/throb_animation.h" | |
| 11 #include "ui/gfx/screen.h" | |
| 12 #include "ui/views/controls/button/blue_button.h" | |
| 13 #include "ui/views/controls/button/checkbox.h" | |
| 14 #include "ui/views/controls/button/image_button.h" | |
| 15 #include "ui/views/controls/button/label_button.h" | |
| 16 #include "ui/views/controls/button/menu_button.h" | |
| 17 #include "ui/views/controls/button/radio_button.h" | |
| 18 #include "ui/views/widget/widget.h" | |
| 19 | |
| 20 namespace views { | |
| 21 | |
| 22 // How long the hover animation takes if uninterrupted. | |
| 23 static const int kHoverFadeDurationMs = 150; | |
| 24 | |
| 25 // static | |
| 26 const char CustomButton::kViewClassName[] = "CustomButton"; | |
| 27 | |
| 28 //////////////////////////////////////////////////////////////////////////////// | |
| 29 // CustomButton, public: | |
| 30 | |
| 31 // static | |
| 32 const CustomButton* CustomButton::AsCustomButton(const views::View* view) { | |
| 33 return AsCustomButton(const_cast<views::View*>(view)); | |
| 34 } | |
| 35 | |
| 36 CustomButton* CustomButton::AsCustomButton(views::View* view) { | |
| 37 if (view) { | |
| 38 const char* classname = view->GetClassName(); | |
| 39 if (!strcmp(classname, Checkbox::kViewClassName) || | |
| 40 !strcmp(classname, CustomButton::kViewClassName) || | |
| 41 !strcmp(classname, ImageButton::kViewClassName) || | |
| 42 !strcmp(classname, LabelButton::kViewClassName) || | |
| 43 !strcmp(classname, RadioButton::kViewClassName) || | |
| 44 !strcmp(classname, MenuButton::kViewClassName)) { | |
| 45 return static_cast<CustomButton*>(view); | |
| 46 } | |
| 47 } | |
| 48 return NULL; | |
| 49 } | |
| 50 | |
| 51 CustomButton::~CustomButton() { | |
| 52 } | |
| 53 | |
| 54 void CustomButton::SetState(ButtonState state) { | |
| 55 if (state == state_) | |
| 56 return; | |
| 57 | |
| 58 if (animate_on_state_change_ && | |
| 59 (!is_throbbing_ || !hover_animation_->is_animating())) { | |
| 60 is_throbbing_ = false; | |
| 61 if (state_ == STATE_NORMAL && state == STATE_HOVERED) { | |
| 62 // Button is hovered from a normal state, start hover animation. | |
| 63 hover_animation_->Show(); | |
| 64 } else if ((state_ == STATE_HOVERED || state_ == STATE_PRESSED) | |
| 65 && state == STATE_NORMAL) { | |
| 66 // Button is returning to a normal state from hover, start hover | |
| 67 // fade animation. | |
| 68 hover_animation_->Hide(); | |
| 69 } else { | |
| 70 hover_animation_->Stop(); | |
| 71 } | |
| 72 } | |
| 73 | |
| 74 state_ = state; | |
| 75 StateChanged(); | |
| 76 if (state_changed_delegate_.get()) | |
| 77 state_changed_delegate_->StateChanged(state_); | |
| 78 SchedulePaint(); | |
| 79 } | |
| 80 | |
| 81 void CustomButton::StartThrobbing(int cycles_til_stop) { | |
| 82 is_throbbing_ = true; | |
| 83 hover_animation_->StartThrobbing(cycles_til_stop); | |
| 84 } | |
| 85 | |
| 86 void CustomButton::StopThrobbing() { | |
| 87 if (hover_animation_->is_animating()) { | |
| 88 hover_animation_->Stop(); | |
| 89 SchedulePaint(); | |
| 90 } | |
| 91 } | |
| 92 | |
| 93 void CustomButton::SetAnimationDuration(int duration) { | |
| 94 hover_animation_->SetSlideDuration(duration); | |
| 95 } | |
| 96 | |
| 97 void CustomButton::SetHotTracked(bool is_hot_tracked) { | |
| 98 if (state_ != STATE_DISABLED) | |
| 99 SetState(is_hot_tracked ? STATE_HOVERED : STATE_NORMAL); | |
| 100 | |
| 101 if (is_hot_tracked) | |
| 102 NotifyAccessibilityEvent(ui::AX_EVENT_FOCUS, true); | |
| 103 } | |
| 104 | |
| 105 bool CustomButton::IsHotTracked() const { | |
| 106 return state_ == STATE_HOVERED; | |
| 107 } | |
| 108 | |
| 109 //////////////////////////////////////////////////////////////////////////////// | |
| 110 // CustomButton, View overrides: | |
| 111 | |
| 112 void CustomButton::OnEnabledChanged() { | |
| 113 if (enabled() ? (state_ != STATE_DISABLED) : (state_ == STATE_DISABLED)) | |
| 114 return; | |
| 115 | |
| 116 if (enabled()) | |
| 117 SetState(IsMouseHovered() ? STATE_HOVERED : STATE_NORMAL); | |
| 118 else | |
| 119 SetState(STATE_DISABLED); | |
| 120 } | |
| 121 | |
| 122 const char* CustomButton::GetClassName() const { | |
| 123 return kViewClassName; | |
| 124 } | |
| 125 | |
| 126 bool CustomButton::OnMousePressed(const ui::MouseEvent& event) { | |
| 127 if (state_ != STATE_DISABLED) { | |
| 128 if (ShouldEnterPushedState(event) && HitTestPoint(event.location())) | |
| 129 SetState(STATE_PRESSED); | |
| 130 if (request_focus_on_press_) | |
| 131 RequestFocus(); | |
| 132 } | |
| 133 return true; | |
| 134 } | |
| 135 | |
| 136 bool CustomButton::OnMouseDragged(const ui::MouseEvent& event) { | |
| 137 if (state_ != STATE_DISABLED) { | |
| 138 if (HitTestPoint(event.location())) | |
| 139 SetState(ShouldEnterPushedState(event) ? STATE_PRESSED : STATE_HOVERED); | |
| 140 else | |
| 141 SetState(STATE_NORMAL); | |
| 142 } | |
| 143 return true; | |
| 144 } | |
| 145 | |
| 146 void CustomButton::OnMouseReleased(const ui::MouseEvent& event) { | |
| 147 if (state_ == STATE_DISABLED) | |
| 148 return; | |
| 149 | |
| 150 if (!HitTestPoint(event.location())) { | |
| 151 SetState(STATE_NORMAL); | |
| 152 return; | |
| 153 } | |
| 154 | |
| 155 SetState(STATE_HOVERED); | |
| 156 if (IsTriggerableEvent(event)) { | |
| 157 NotifyClick(event); | |
| 158 // NOTE: We may be deleted at this point (by the listener's notification | |
| 159 // handler). | |
| 160 } | |
| 161 } | |
| 162 | |
| 163 void CustomButton::OnMouseCaptureLost() { | |
| 164 // Starting a drag results in a MouseCaptureLost, we need to ignore it. | |
| 165 if (state_ != STATE_DISABLED && !InDrag()) | |
| 166 SetState(STATE_NORMAL); | |
| 167 } | |
| 168 | |
| 169 void CustomButton::OnMouseEntered(const ui::MouseEvent& event) { | |
| 170 if (state_ != STATE_DISABLED) | |
| 171 SetState(STATE_HOVERED); | |
| 172 } | |
| 173 | |
| 174 void CustomButton::OnMouseExited(const ui::MouseEvent& event) { | |
| 175 // Starting a drag results in a MouseExited, we need to ignore it. | |
| 176 if (state_ != STATE_DISABLED && !InDrag()) | |
| 177 SetState(STATE_NORMAL); | |
| 178 } | |
| 179 | |
| 180 void CustomButton::OnMouseMoved(const ui::MouseEvent& event) { | |
| 181 if (state_ != STATE_DISABLED) | |
| 182 SetState(HitTestPoint(event.location()) ? STATE_HOVERED : STATE_NORMAL); | |
| 183 } | |
| 184 | |
| 185 bool CustomButton::OnKeyPressed(const ui::KeyEvent& event) { | |
| 186 if (state_ == STATE_DISABLED) | |
| 187 return false; | |
| 188 | |
| 189 // Space sets button state to pushed. Enter clicks the button. This matches | |
| 190 // the Windows native behavior of buttons, where Space clicks the button on | |
| 191 // KeyRelease and Enter clicks the button on KeyPressed. | |
| 192 if (event.key_code() == ui::VKEY_SPACE) { | |
| 193 SetState(STATE_PRESSED); | |
| 194 } else if (event.key_code() == ui::VKEY_RETURN) { | |
| 195 SetState(STATE_NORMAL); | |
| 196 // TODO(beng): remove once NotifyClick takes ui::Event. | |
| 197 ui::MouseEvent synthetic_event(ui::ET_MOUSE_RELEASED, | |
| 198 gfx::Point(), | |
| 199 gfx::Point(), | |
| 200 ui::EF_LEFT_MOUSE_BUTTON, | |
| 201 ui::EF_LEFT_MOUSE_BUTTON); | |
| 202 NotifyClick(synthetic_event); | |
| 203 } else { | |
| 204 return false; | |
| 205 } | |
| 206 return true; | |
| 207 } | |
| 208 | |
| 209 bool CustomButton::OnKeyReleased(const ui::KeyEvent& event) { | |
| 210 if ((state_ == STATE_DISABLED) || (event.key_code() != ui::VKEY_SPACE)) | |
| 211 return false; | |
| 212 | |
| 213 SetState(STATE_NORMAL); | |
| 214 // TODO(beng): remove once NotifyClick takes ui::Event. | |
| 215 ui::MouseEvent synthetic_event(ui::ET_MOUSE_RELEASED, | |
| 216 gfx::Point(), | |
| 217 gfx::Point(), | |
| 218 ui::EF_LEFT_MOUSE_BUTTON, | |
| 219 ui::EF_LEFT_MOUSE_BUTTON); | |
| 220 NotifyClick(synthetic_event); | |
| 221 return true; | |
| 222 } | |
| 223 | |
| 224 void CustomButton::OnGestureEvent(ui::GestureEvent* event) { | |
| 225 if (state_ == STATE_DISABLED) { | |
| 226 Button::OnGestureEvent(event); | |
| 227 return; | |
| 228 } | |
| 229 | |
| 230 if (event->type() == ui::ET_GESTURE_TAP && IsTriggerableEvent(*event)) { | |
| 231 // Set the button state to hot and start the animation fully faded in. The | |
| 232 // GESTURE_END event issued immediately after will set the state to | |
| 233 // STATE_NORMAL beginning the fade out animation. See | |
| 234 // http://crbug.com/131184. | |
| 235 SetState(STATE_HOVERED); | |
| 236 hover_animation_->Reset(1.0); | |
| 237 NotifyClick(*event); | |
| 238 event->StopPropagation(); | |
| 239 } else if (event->type() == ui::ET_GESTURE_TAP_DOWN && | |
| 240 ShouldEnterPushedState(*event)) { | |
| 241 SetState(STATE_PRESSED); | |
| 242 if (request_focus_on_press_) | |
| 243 RequestFocus(); | |
| 244 event->StopPropagation(); | |
| 245 } else if (event->type() == ui::ET_GESTURE_TAP_CANCEL || | |
| 246 event->type() == ui::ET_GESTURE_END) { | |
| 247 SetState(STATE_NORMAL); | |
| 248 } | |
| 249 if (!event->handled()) | |
| 250 Button::OnGestureEvent(event); | |
| 251 } | |
| 252 | |
| 253 bool CustomButton::AcceleratorPressed(const ui::Accelerator& accelerator) { | |
| 254 SetState(STATE_NORMAL); | |
| 255 /* | |
| 256 ui::KeyEvent key_event(ui::ET_KEY_RELEASED, accelerator.key_code(), | |
| 257 accelerator.modifiers()); | |
| 258 */ | |
| 259 // TODO(beng): remove once NotifyClick takes ui::Event. | |
| 260 ui::MouseEvent synthetic_event(ui::ET_MOUSE_RELEASED, | |
| 261 gfx::Point(), | |
| 262 gfx::Point(), | |
| 263 ui::EF_LEFT_MOUSE_BUTTON, | |
| 264 ui::EF_LEFT_MOUSE_BUTTON); | |
| 265 NotifyClick(synthetic_event); | |
| 266 return true; | |
| 267 } | |
| 268 | |
| 269 void CustomButton::ShowContextMenu(const gfx::Point& p, | |
| 270 ui::MenuSourceType source_type) { | |
| 271 if (!context_menu_controller()) | |
| 272 return; | |
| 273 | |
| 274 // We're about to show the context menu. Showing the context menu likely means | |
| 275 // we won't get a mouse exited and reset state. Reset it now to be sure. | |
| 276 if (state_ != STATE_DISABLED) | |
| 277 SetState(STATE_NORMAL); | |
| 278 View::ShowContextMenu(p, source_type); | |
| 279 } | |
| 280 | |
| 281 void CustomButton::OnDragDone() { | |
| 282 SetState(STATE_NORMAL); | |
| 283 } | |
| 284 | |
| 285 void CustomButton::GetAccessibleState(ui::AXViewState* state) { | |
| 286 Button::GetAccessibleState(state); | |
| 287 switch (state_) { | |
| 288 case STATE_HOVERED: | |
| 289 state->AddStateFlag(ui::AX_STATE_HOVERED); | |
| 290 break; | |
| 291 case STATE_PRESSED: | |
| 292 state->AddStateFlag(ui::AX_STATE_PRESSED); | |
| 293 break; | |
| 294 case STATE_DISABLED: | |
| 295 state->AddStateFlag(ui::AX_STATE_DISABLED); | |
| 296 break; | |
| 297 case STATE_NORMAL: | |
| 298 case STATE_COUNT: | |
| 299 // No additional accessibility state set for this button state. | |
| 300 break; | |
| 301 } | |
| 302 } | |
| 303 | |
| 304 void CustomButton::VisibilityChanged(View* starting_from, bool visible) { | |
| 305 if (state_ == STATE_DISABLED) | |
| 306 return; | |
| 307 SetState(visible && IsMouseHovered() ? STATE_HOVERED : STATE_NORMAL); | |
| 308 } | |
| 309 | |
| 310 //////////////////////////////////////////////////////////////////////////////// | |
| 311 // CustomButton, gfx::AnimationDelegate implementation: | |
| 312 | |
| 313 void CustomButton::AnimationProgressed(const gfx::Animation* animation) { | |
| 314 SchedulePaint(); | |
| 315 } | |
| 316 | |
| 317 //////////////////////////////////////////////////////////////////////////////// | |
| 318 // CustomButton, protected: | |
| 319 | |
| 320 CustomButton::CustomButton(ButtonListener* listener) | |
| 321 : Button(listener), | |
| 322 state_(STATE_NORMAL), | |
| 323 animate_on_state_change_(true), | |
| 324 is_throbbing_(false), | |
| 325 triggerable_event_flags_(ui::EF_LEFT_MOUSE_BUTTON), | |
| 326 request_focus_on_press_(true) { | |
| 327 hover_animation_.reset(new gfx::ThrobAnimation(this)); | |
| 328 hover_animation_->SetSlideDuration(kHoverFadeDurationMs); | |
| 329 } | |
| 330 | |
| 331 void CustomButton::StateChanged() { | |
| 332 } | |
| 333 | |
| 334 bool CustomButton::IsTriggerableEvent(const ui::Event& event) { | |
| 335 return event.type() == ui::ET_GESTURE_TAP_DOWN || | |
| 336 event.type() == ui::ET_GESTURE_TAP || | |
| 337 (event.IsMouseEvent() && | |
| 338 (triggerable_event_flags_ & event.flags()) != 0); | |
| 339 } | |
| 340 | |
| 341 bool CustomButton::ShouldEnterPushedState(const ui::Event& event) { | |
| 342 return IsTriggerableEvent(event); | |
| 343 } | |
| 344 | |
| 345 //////////////////////////////////////////////////////////////////////////////// | |
| 346 // CustomButton, View overrides (protected): | |
| 347 | |
| 348 void CustomButton::ViewHierarchyChanged( | |
| 349 const ViewHierarchyChangedDetails& details) { | |
| 350 if (!details.is_add && state_ != STATE_DISABLED) | |
| 351 SetState(STATE_NORMAL); | |
| 352 } | |
| 353 | |
| 354 void CustomButton::OnBlur() { | |
| 355 if (IsHotTracked()) | |
| 356 SetState(STATE_NORMAL); | |
| 357 } | |
| 358 | |
| 359 } // namespace views | |
| OLD | NEW |
|---|
Chromium Code Reviews
