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