Home | History | Annotate | Download | only in tabbed_pane 
      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 
     18 namespace {
     19 
     20 // TODO(markusheintz|msw): Use NativeTheme colors.
     21 const SkColor kTabTitleColor_Inactive = SkColorSetRGB(0x64, 0x64, 0x64);
     22 const SkColor kTabTitleColor_Active = SK_ColorBLACK;
     23 const SkColor kTabTitleColor_Hovered = SK_ColorBLACK;
     24 const SkColor kTabBorderColor = SkColorSetRGB(0xC8, 0xC8, 0xC8);
     25 const SkScalar kTabBorderThickness = 1.0f;
     26 
     27 }  // namespace
     28 
     29 namespace views {
     30 
     31 // static
     32 const char TabbedPane::kViewClassName[] = "TabbedPane";
     33 
     34 // The tab view shown in the tab strip.
     35 class 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.
     73 class 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 
     89 Tab::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 
    103 Tab::~Tab() {}
    104 
    105 void Tab::SetSelected(bool selected) {
    106   contents_->SetVisible(selected);
    107   SetState(selected ? TAB_ACTIVE : TAB_INACTIVE);
    108 }
    109 
    110 bool 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 
    117 void Tab::OnMouseEntered(const ui::MouseEvent& event) {
    118   SetState(selected() ? TAB_ACTIVE : TAB_HOVERED);
    119 }
    120 
    121 void Tab::OnMouseExited(const ui::MouseEvent& event) {
    122   SetState(selected() ? TAB_ACTIVE : TAB_INACTIVE);
    123 }
    124 
    125 void 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 
    142 gfx::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 
    151 void 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 
    158 void 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 
    181 TabStrip::TabStrip(TabbedPane* tabbed_pane) : tabbed_pane_(tabbed_pane) {}
    182 
    183 TabStrip::~TabStrip() {}
    184 
    185 gfx::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 
    195 void 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 
    205 void 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 
    240 TabbedPane::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 
    250 TabbedPane::~TabbedPane() {}
    251 
    252 int TabbedPane::GetTabCount() {
    253   DCHECK_EQ(tab_strip_->child_count(), contents_->child_count());
    254   return contents_->child_count();
    255 }
    256 
    257 View* TabbedPane::GetSelectedTab() {
    258   return selected_tab_index() < 0 ?
    259       NULL : GetTabAt(selected_tab_index())->contents();
    260 }
    261 
    262 void TabbedPane::AddTab(const base::string16& title, View* contents) {
    263   AddTabAtIndex(tab_strip_->child_count(), title, contents);
    264 }
    265 
    266 void 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 
    280 void 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 
    305 void TabbedPane::SelectTab(Tab* tab) {
    306   const int index = tab_strip_->GetIndexOf(tab);
    307   if (index >= 0)
    308     SelectTabAt(index);
    309 }
    310 
    311 gfx::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 
    319 Tab* TabbedPane::GetTabAt(int index) {
    320   return static_cast<Tab*>(tab_strip_->child_at(index));
    321 }
    322 
    323 void 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 
    332 void 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 
    342 bool 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 
    357 const char* TabbedPane::GetClassName() const {
    358   return kViewClassName;
    359 }
    360 
    361 void 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 
    371 void TabbedPane::GetAccessibleState(ui::AXViewState* state) {
    372   state->role = ui::AX_ROLE_TAB_LIST;
    373 }
    374 
    375 }  // namespace views
    376