ui/app_list/views/page_switcher.cc

   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/app_list/views/page_switcher.h"
   6
   7 #include <algorithm>
   8
   9 #include "third_party/skia/include/core/SkPath.h"
  10 #include "ui/app_list/app_list_constants.h"
  11 #include "ui/app_list/pagination_model.h"
  12 #include "ui/base/ui_base_switches_util.h"
  13 #include "ui/gfx/animation/throb_animation.h"
  14 #include "ui/gfx/canvas.h"
  15 #include "ui/gfx/skia_util.h"
  16 #include "ui/views/controls/button/custom_button.h"
  17 #include "ui/views/layout/box_layout.h"
  18
  19 namespace app_list {
  20
  21 namespace {
  22
  23 const int kPreferredHeight = 58;
  24
  25 const int kMaxButtonSpacing = 18;
  26 const int kMinButtonSpacing = 4;
  27 const int kMaxButtonWidth = 68;
  28 const int kMinButtonWidth = 28;
  29 const int kButtonHeight = 6;
  30 const int kButtonCornerRadius = 2;
  31 const int kButtonStripPadding = 20;
  32
  33 class PageSwitcherButton : public views::CustomButton {
  34  public:
  35   explicit PageSwitcherButton(views::ButtonListener* listener)
  36       : views::CustomButton(listener),
  37         button_width_(kMaxButtonWidth),
  38         selected_range_(0) {
  39   }
  40   ~PageSwitcherButton() override {}
  41
  42   void SetSelectedRange(double selected_range) {
  43     if (selected_range_ == selected_range)
  44       return;
  45
  46     selected_range_ = selected_range;
  47     SchedulePaint();
  48   }
  49
  50   void set_button_width(int button_width) { button_width_ = button_width; }
  51
  52   // Overridden from views::View:
  53   gfx::Size GetPreferredSize() const override {
  54     return gfx::Size(button_width_, kButtonHeight);
  55   }
  56
  57   void OnPaint(gfx::Canvas* canvas) override {
  58     if (state() == STATE_HOVERED)
  59       PaintButton(canvas, kPagerHoverColor);
  60     else
  61       PaintButton(canvas, kPagerNormalColor);
  62   }
  63
  64  private:
  65   void OnGestureEvent(ui::GestureEvent* event) override {
  66     CustomButton::OnGestureEvent(event);
  67
  68     if (!switches::IsTouchFeedbackEnabled())
  69       return;
  70
  71     if (event->type() == ui::ET_GESTURE_TAP_DOWN)
  72       SetState(views::CustomButton::STATE_HOVERED);
  73     else if (event->type() == ui::ET_GESTURE_TAP_CANCEL ||
  74              event->type() == ui::ET_GESTURE_TAP)
  75       SetState(views::CustomButton::STATE_NORMAL);
  76     SchedulePaint();
  77   }
  78
  79   // Paints a button that has two rounded corner at bottom.
  80   void PaintButton(gfx::Canvas* canvas, SkColor base_color) {
  81     gfx::Rect rect(GetContentsBounds());
  82     rect.ClampToCenteredSize(gfx::Size(button_width_, kButtonHeight));
  83
  84     SkPath path;
  85     path.addRoundRect(gfx::RectToSkRect(rect),
  86                       SkIntToScalar(kButtonCornerRadius),
  87                       SkIntToScalar(kButtonCornerRadius));
  88
  89     SkPaint paint;
  90     paint.setAntiAlias(true);
  91     paint.setStyle(SkPaint::kFill_Style);
  92     paint.setColor(base_color);
  93     canvas->DrawPath(path, paint);
  94
  95     int selected_start_x = 0;
  96     int selected_width = 0;
  97     if (selected_range_ > 0) {
  98       selected_width = selected_range_ * rect.width();
  99     } else if (selected_range_ < 0) {
 100       selected_width =  -selected_range_ * rect.width();
 101       selected_start_x = rect.right() - selected_width;
 102     }
 103
 104     if (selected_width) {
 105       gfx::Rect selected_rect(rect);
 106       selected_rect.set_x(selected_start_x);
 107       selected_rect.set_width(selected_width);
 108
 109       SkPath selected_path;
 110       selected_path.addRoundRect(gfx::RectToSkRect(selected_rect),
 111                                  SkIntToScalar(kButtonCornerRadius),
 112                                  SkIntToScalar(kButtonCornerRadius));
 113       paint.setColor(kPagerSelectedColor);
 114       canvas->DrawPath(selected_path, paint);
 115     }
 116   }
 117
 118   int button_width_;
 119
 120   // [-1, 1] range that represents the portion of the button that should be
 121   // painted with kSelectedColor. Positive range starts from left side and
 122   // negative range starts from the right side.
 123   double selected_range_;
 124
 125   DISALLOW_COPY_AND_ASSIGN(PageSwitcherButton);
 126 };
 127
 128 // Gets PageSwitcherButton at |index| in |buttons|.
 129 PageSwitcherButton* GetButtonByIndex(views::View* buttons, int index) {
 130   return static_cast<PageSwitcherButton*>(buttons->child_at(index));
 131 }
 132
 133 }  // namespace
 134
 135 PageSwitcher::PageSwitcher(PaginationModel* model)
 136     : model_(model),
 137       buttons_(new views::View) {
 138   AddChildView(buttons_);
 139
 140   TotalPagesChanged();
 141   SelectedPageChanged(-1, model->selected_page());
 142   model_->AddObserver(this);
 143 }
 144
 145 PageSwitcher::~PageSwitcher() {
 146   model_->RemoveObserver(this);
 147 }
 148
 149 int PageSwitcher::GetPageForPoint(const gfx::Point& point) const {
 150   if (!buttons_->bounds().Contains(point))
 151     return -1;
 152
 153   gfx::Point buttons_point(point);
 154   views::View::ConvertPointToTarget(this, buttons_, &buttons_point);
 155
 156   for (int i = 0; i < buttons_->child_count(); ++i) {
 157     const views::View* button = buttons_->child_at(i);
 158     if (button->bounds().Contains(buttons_point))
 159       return i;
 160   }
 161
 162   return -1;
 163 }
 164
 165 void PageSwitcher::UpdateUIForDragPoint(const gfx::Point& point) {
 166   int page = GetPageForPoint(point);
 167
 168   const int button_count = buttons_->child_count();
 169   if (page >= 0 && page < button_count) {
 170     PageSwitcherButton* button =
 171         static_cast<PageSwitcherButton*>(buttons_->child_at(page));
 172     button->SetState(views::CustomButton::STATE_HOVERED);
 173     return;
 174   }
 175
 176   for (int i = 0; i < button_count; ++i) {
 177     PageSwitcherButton* button =
 178         static_cast<PageSwitcherButton*>(buttons_->child_at(i));
 179     button->SetState(views::CustomButton::STATE_NORMAL);
 180   }
 181 }
 182
 183 gfx::Size PageSwitcher::GetPreferredSize() const {
 184   // Always return a size with correct height so that container resize is not
 185   // needed when more pages are added.
 186   return gfx::Size(buttons_->GetPreferredSize().width(),
 187                    kPreferredHeight);
 188 }
 189
 190 void PageSwitcher::Layout() {
 191   gfx::Rect rect(GetContentsBounds());
 192
 193   CalculateButtonWidthAndSpacing(rect.width());
 194
 195   // Makes |buttons_| horizontally center and vertically fill.
 196   gfx::Size buttons_size(buttons_->GetPreferredSize());
 197   gfx::Rect buttons_bounds(rect.CenterPoint().x() - buttons_size.width() / 2,
 198                            rect.y(),
 199                            buttons_size.width(),
 200                            rect.height());
 201   buttons_->SetBoundsRect(gfx::IntersectRects(rect, buttons_bounds));
 202 }
 203
 204 void PageSwitcher::CalculateButtonWidthAndSpacing(int contents_width) {
 205   const int button_count = buttons_->child_count();
 206   if (!button_count)
 207     return;
 208
 209   contents_width -= 2 * kButtonStripPadding;
 210
 211   int button_width = kMinButtonWidth;
 212   int button_spacing = kMinButtonSpacing;
 213   if (button_count > 1) {
 214     button_spacing = (contents_width - button_width * button_count) /
 215         (button_count - 1);
 216     button_spacing = std::min(kMaxButtonSpacing,
 217                               std::max(kMinButtonSpacing, button_spacing));
 218   }
 219
 220   button_width = (contents_width - (button_count - 1) * button_spacing) /
 221       button_count;
 222   button_width = std::min(kMaxButtonWidth,
 223                           std::max(kMinButtonWidth, button_width));
 224
 225   buttons_->SetLayoutManager(new views::BoxLayout(
 226       views::BoxLayout::kHorizontal, kButtonStripPadding, 0, button_spacing));
 227   for (int i = 0; i < button_count; ++i) {
 228     PageSwitcherButton* button =
 229         static_cast<PageSwitcherButton*>(buttons_->child_at(i));
 230     button->set_button_width(button_width);
 231   }
 232 }
 233
 234 void PageSwitcher::ButtonPressed(views::Button* sender,
 235                                  const ui::Event& event) {
 236   for (int i = 0; i < buttons_->child_count(); ++i) {
 237     if (sender == static_cast<views::Button*>(buttons_->child_at(i))) {
 238       model_->SelectPage(i, true /* animate */);
 239       break;
 240     }
 241   }
 242 }
 243
 244 void PageSwitcher::TotalPagesChanged() {
 245   buttons_->RemoveAllChildViews(true);
 246   for (int i = 0; i < model_->total_pages(); ++i) {
 247     PageSwitcherButton* button = new PageSwitcherButton(this);
 248     button->SetSelectedRange(i == model_->selected_page() ? 1 : 0);
 249     buttons_->AddChildView(button);
 250   }
 251   buttons_->SetVisible(model_->total_pages() > 1);
 252   Layout();
 253 }
 254
 255 void PageSwitcher::SelectedPageChanged(int old_selected, int new_selected) {
 256   if (old_selected >= 0 && old_selected < buttons_->child_count())
 257     GetButtonByIndex(buttons_, old_selected)->SetSelectedRange(0);
 258   if (new_selected >= 0 && new_selected < buttons_->child_count())
 259     GetButtonByIndex(buttons_, new_selected)->SetSelectedRange(1);
 260 }
 261
 262 void PageSwitcher::TransitionStarted() {
 263 }
 264
 265 void PageSwitcher::TransitionChanged() {
 266   const int current_page = model_->selected_page();
 267   const int target_page = model_->transition().target_page;
 268
 269   double progress = model_->transition().progress;
 270   double remaining = progress - 1;
 271
 272   if (current_page > target_page) {
 273     remaining = -remaining;
 274     progress = -progress;
 275   }
 276
 277   GetButtonByIndex(buttons_, current_page)->SetSelectedRange(remaining);
 278   if (model_->is_valid_page(target_page))
 279     GetButtonByIndex(buttons_, target_page)->SetSelectedRange(progress);
 280 }
 281
 282 }  // namespace app_list