Home | History | Annotate | Download | only in button 
      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
    360