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/tabbed_pane/tabbed_pane.h"
6
7#include "base/logging.h"
8#include "ui/accessibility/ax_view_state.h"
9#include "ui/base/resource/resource_bundle.h"
10#include "ui/events/keycodes/keyboard_codes.h"
11#include "ui/gfx/canvas.h"
12#include "ui/gfx/font_list.h"
13#include "ui/views/controls/label.h"
14#include "ui/views/controls/tabbed_pane/tabbed_pane_listener.h"
15#include "ui/views/layout/layout_manager.h"
16#include "ui/views/widget/widget.h"
17
18namespace {
19
20// TODO(markusheintz|msw): Use NativeTheme colors.
21const SkColor kTabTitleColor_Inactive = SkColorSetRGB(0x64, 0x64, 0x64);
22const SkColor kTabTitleColor_Active = SK_ColorBLACK;
23const SkColor kTabTitleColor_Hovered = SK_ColorBLACK;
24const SkColor kTabBorderColor = SkColorSetRGB(0xC8, 0xC8, 0xC8);
25const SkScalar kTabBorderThickness = 1.0f;
26
27}  // namespace
28
29namespace views {
30
31// static
32const char TabbedPane::kViewClassName[] = "TabbedPane";
33
34// The tab view shown in the tab strip.
35class Tab : public View {
36 public:
37  Tab(TabbedPane* tabbed_pane, const base::string16& title, View* contents);
38  virtual ~Tab();
39
40  View* contents() const { return contents_; }
41
42  bool selected() const { return contents_->visible(); }
43  void SetSelected(bool selected);
44
45  // Overridden from View:
46  virtual bool OnMousePressed(const ui::MouseEvent& event) OVERRIDE;
47  virtual void OnMouseEntered(const ui::MouseEvent& event) OVERRIDE;
48  virtual void OnMouseExited(const ui::MouseEvent& event) OVERRIDE;
49  virtual void OnGestureEvent(ui::GestureEvent* event) OVERRIDE;
50  virtual gfx::Size GetPreferredSize() const OVERRIDE;
51  virtual void Layout() OVERRIDE;
52
53 private:
54  enum TabState {
55    TAB_INACTIVE,
56    TAB_ACTIVE,
57    TAB_HOVERED,
58  };
59
60  void SetState(TabState tab_state);
61
62  TabbedPane* tabbed_pane_;
63  Label* title_;
64  gfx::Size preferred_title_size_;
65  TabState tab_state_;
66  // The content view associated with this tab.
67  View* contents_;
68
69  DISALLOW_COPY_AND_ASSIGN(Tab);
70};
71
72// The tab strip shown above the tab contents.
73class TabStrip : public View {
74 public:
75  explicit TabStrip(TabbedPane* tabbed_pane);
76  virtual ~TabStrip();
77
78  // Overridden from View:
79  virtual gfx::Size GetPreferredSize() const OVERRIDE;
80  virtual void Layout() OVERRIDE;
81  virtual void OnPaint(gfx::Canvas* canvas) OVERRIDE;
82
83 private:
84  TabbedPane* tabbed_pane_;
85
86  DISALLOW_COPY_AND_ASSIGN(TabStrip);
87};
88
89Tab::Tab(TabbedPane* tabbed_pane, const base::string16& title, View* contents)
90    : tabbed_pane_(tabbed_pane),
91      title_(new Label(title,
92                       ui::ResourceBundle::GetSharedInstance().GetFontList(
93                           ui::ResourceBundle::BoldFont))),
94      tab_state_(TAB_ACTIVE),
95      contents_(contents) {
96  // Calculate this now while the font list is guaranteed to be bold.
97  preferred_title_size_ = title_->GetPreferredSize();
98
99  SetState(TAB_INACTIVE);
100  AddChildView(title_);
101}
102
103Tab::~Tab() {}
104
105void Tab::SetSelected(bool selected) {
106  contents_->SetVisible(selected);
107  SetState(selected ? TAB_ACTIVE : TAB_INACTIVE);
108}
109
110bool Tab::OnMousePressed(const ui::MouseEvent& event) {
111  if (event.IsOnlyLeftMouseButton() &&
112      GetLocalBounds().Contains(event.location()))
113    tabbed_pane_->SelectTab(this);
114  return true;
115}
116
117void Tab::OnMouseEntered(const ui::MouseEvent& event) {
118  SetState(selected() ? TAB_ACTIVE : TAB_HOVERED);
119}
120
121void Tab::OnMouseExited(const ui::MouseEvent& event) {
122  SetState(selected() ? TAB_ACTIVE : TAB_INACTIVE);
123}
124
125void Tab::OnGestureEvent(ui::GestureEvent* event) {
126  switch (event->type()) {
127    case ui::ET_GESTURE_TAP_DOWN:
128      // Fallthrough.
129    case ui::ET_GESTURE_TAP:
130      // SelectTab also sets the right tab color.
131      tabbed_pane_->SelectTab(this);
132      break;
133    case ui::ET_GESTURE_TAP_CANCEL:
134      SetState(selected() ? TAB_ACTIVE : TAB_INACTIVE);
135      break;
136    default:
137      break;
138  }
139  event->SetHandled();
140}
141
142gfx::Size Tab::GetPreferredSize() const {
143  gfx::Size size(preferred_title_size_);
144  size.Enlarge(21, 9);
145  const int kTabMinWidth = 54;
146  if (size.width() < kTabMinWidth)
147    size.set_width(kTabMinWidth);
148  return size;
149}
150
151void Tab::Layout() {
152  gfx::Rect bounds = GetLocalBounds();
153  bounds.Inset(0, 1, 0, 0);
154  bounds.ClampToCenteredSize(preferred_title_size_);
155  title_->SetBoundsRect(bounds);
156}
157
158void Tab::SetState(TabState tab_state) {
159  if (tab_state == tab_state_)
160    return;
161  tab_state_ = tab_state;
162
163  ui::ResourceBundle& rb = ui::ResourceBundle::GetSharedInstance();
164  switch (tab_state) {
165    case TAB_INACTIVE:
166      title_->SetEnabledColor(kTabTitleColor_Inactive);
167      title_->SetFontList(rb.GetFontList(ui::ResourceBundle::BaseFont));
168      break;
169    case TAB_ACTIVE:
170      title_->SetEnabledColor(kTabTitleColor_Active);
171      title_->SetFontList(rb.GetFontList(ui::ResourceBundle::BoldFont));
172      break;
173    case TAB_HOVERED:
174      title_->SetEnabledColor(kTabTitleColor_Hovered);
175      title_->SetFontList(rb.GetFontList(ui::ResourceBundle::BaseFont));
176      break;
177  }
178  SchedulePaint();
179}
180
181TabStrip::TabStrip(TabbedPane* tabbed_pane) : tabbed_pane_(tabbed_pane) {}
182
183TabStrip::~TabStrip() {}
184
185gfx::Size TabStrip::GetPreferredSize() const {
186  gfx::Size size;
187  for (int i = 0; i < child_count(); ++i) {
188    const gfx::Size child_size = child_at(i)->GetPreferredSize();
189    size.SetSize(size.width() + child_size.width(),
190                 std::max(size.height(), child_size.height()));
191  }
192  return size;
193}
194
195void TabStrip::Layout() {
196  const int kTabOffset = 9;
197  int x = kTabOffset;  // Layout tabs with an offset to the tabstrip border.
198  for (int i = 0; i < child_count(); ++i) {
199    gfx::Size ps = child_at(i)->GetPreferredSize();
200    child_at(i)->SetBounds(x, 0, ps.width(), ps.height());
201    x = child_at(i)->bounds().right();
202  }
203}
204
205void TabStrip::OnPaint(gfx::Canvas* canvas) {
206  OnPaintBackground(canvas);
207
208  // Draw the TabStrip border.
209  SkPaint paint;
210  paint.setColor(kTabBorderColor);
211  paint.setStrokeWidth(kTabBorderThickness);
212  SkScalar line_y = SkIntToScalar(height()) - (kTabBorderThickness / 2);
213  SkScalar line_end = SkIntToScalar(width());
214  int selected_tab_index = tabbed_pane_->selected_tab_index();
215  if (selected_tab_index >= 0) {
216    Tab* selected_tab = tabbed_pane_->GetTabAt(selected_tab_index);
217    SkPath path;
218    SkScalar tab_height =
219        SkIntToScalar(selected_tab->height()) - kTabBorderThickness;
220    SkScalar tab_width =
221        SkIntToScalar(selected_tab->width()) - kTabBorderThickness;
222    SkScalar tab_start = SkIntToScalar(selected_tab->GetMirroredX());
223    path.moveTo(0, line_y);
224    path.rLineTo(tab_start, 0);
225    path.rLineTo(0, -tab_height);
226    path.rLineTo(tab_width, 0);
227    path.rLineTo(0, tab_height);
228    path.lineTo(line_end, line_y);
229
230    SkPaint paint;
231    paint.setStyle(SkPaint::kStroke_Style);
232    paint.setColor(kTabBorderColor);
233    paint.setStrokeWidth(kTabBorderThickness);
234    canvas->DrawPath(path, paint);
235  } else {
236    canvas->sk_canvas()->drawLine(0, line_y, line_end, line_y, paint);
237  }
238}
239
240TabbedPane::TabbedPane()
241  : listener_(NULL),
242    tab_strip_(new TabStrip(this)),
243    contents_(new View()),
244    selected_tab_index_(-1) {
245  SetFocusable(true);
246  AddChildView(tab_strip_);
247  AddChildView(contents_);
248}
249
250TabbedPane::~TabbedPane() {}
251
252int TabbedPane::GetTabCount() {
253  DCHECK_EQ(tab_strip_->child_count(), contents_->child_count());
254  return contents_->child_count();
255}
256
257View* TabbedPane::GetSelectedTab() {
258  return selected_tab_index() < 0 ?
259      NULL : GetTabAt(selected_tab_index())->contents();
260}
261
262void TabbedPane::AddTab(const base::string16& title, View* contents) {
263  AddTabAtIndex(tab_strip_->child_count(), title, contents);
264}
265
266void TabbedPane::AddTabAtIndex(int index,
267                               const base::string16& title,
268                               View* contents) {
269  DCHECK(index >= 0 && index <= GetTabCount());
270  contents->SetVisible(false);
271
272  tab_strip_->AddChildViewAt(new Tab(this, title, contents), index);
273  contents_->AddChildViewAt(contents, index);
274  if (selected_tab_index() < 0)
275    SelectTabAt(index);
276
277  PreferredSizeChanged();
278}
279
280void TabbedPane::SelectTabAt(int index) {
281  DCHECK(index >= 0 && index < GetTabCount());
282  if (index == selected_tab_index())
283    return;
284
285  if (selected_tab_index() >= 0)
286    GetTabAt(selected_tab_index())->SetSelected(false);
287
288  selected_tab_index_ = index;
289  Tab* tab = GetTabAt(index);
290  tab->SetSelected(true);
291  tab_strip_->SchedulePaint();
292
293  FocusManager* focus_manager = tab->contents()->GetFocusManager();
294  if (focus_manager) {
295    const View* focused_view = focus_manager->GetFocusedView();
296    if (focused_view && contents_->Contains(focused_view) &&
297        !tab->contents()->Contains(focused_view))
298      focus_manager->SetFocusedView(tab->contents());
299  }
300
301  if (listener())
302    listener()->TabSelectedAt(index);
303}
304
305void TabbedPane::SelectTab(Tab* tab) {
306  const int index = tab_strip_->GetIndexOf(tab);
307  if (index >= 0)
308    SelectTabAt(index);
309}
310
311gfx::Size TabbedPane::GetPreferredSize() const {
312  gfx::Size size;
313  for (int i = 0; i < contents_->child_count(); ++i)
314    size.SetToMax(contents_->child_at(i)->GetPreferredSize());
315  size.Enlarge(0, tab_strip_->GetPreferredSize().height());
316  return size;
317}
318
319Tab* TabbedPane::GetTabAt(int index) {
320  return static_cast<Tab*>(tab_strip_->child_at(index));
321}
322
323void TabbedPane::Layout() {
324  const gfx::Size size = tab_strip_->GetPreferredSize();
325  tab_strip_->SetBounds(0, 0, width(), size.height());
326  contents_->SetBounds(0, tab_strip_->bounds().bottom(), width(),
327                       std::max(0, height() - size.height()));
328  for (int i = 0; i < contents_->child_count(); ++i)
329    contents_->child_at(i)->SetSize(contents_->size());
330}
331
332void TabbedPane::ViewHierarchyChanged(
333    const ViewHierarchyChangedDetails& details) {
334  if (details.is_add) {
335    // Support navigating tabs by Ctrl+Tab and Ctrl+Shift+Tab.
336    AddAccelerator(ui::Accelerator(ui::VKEY_TAB,
337                                   ui::EF_CONTROL_DOWN | ui::EF_SHIFT_DOWN));
338    AddAccelerator(ui::Accelerator(ui::VKEY_TAB, ui::EF_CONTROL_DOWN));
339  }
340}
341
342bool TabbedPane::AcceleratorPressed(const ui::Accelerator& accelerator) {
343  // Handle Ctrl+Tab and Ctrl+Shift+Tab navigation of pages.
344  DCHECK(accelerator.key_code() == ui::VKEY_TAB && accelerator.IsCtrlDown());
345  const int tab_count = GetTabCount();
346  if (tab_count <= 1)
347    return false;
348  const int increment = accelerator.IsShiftDown() ? -1 : 1;
349  int next_tab_index = (selected_tab_index() + increment) % tab_count;
350  // Wrap around.
351  if (next_tab_index < 0)
352    next_tab_index += tab_count;
353  SelectTabAt(next_tab_index);
354  return true;
355}
356
357const char* TabbedPane::GetClassName() const {
358  return kViewClassName;
359}
360
361void TabbedPane::OnFocus() {
362  View::OnFocus();
363
364  View* selected_tab = GetSelectedTab();
365  if (selected_tab) {
366    selected_tab->NotifyAccessibilityEvent(
367        ui::AX_EVENT_FOCUS, true);
368  }
369}
370
371void TabbedPane::GetAccessibleState(ui::AXViewState* state) {
372  state->role = ui::AX_ROLE_TAB_LIST;
373}
374
375}  // namespace views
376