Auto-size the views version of the options dialog.

views/controls/tabbed_pane/native_tabbed_pane_win.cc

 // Copyright (c) 2010 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "views/controls/tabbed_pane/native_tabbed_pane_win.h"
 
 #include <vssym32.h>
 
 #include "app/l10n_util_win.h"
 #include "app/resource_bundle.h"
@@ skipping 28 matching lines @@
     HDC dc = canvas->BeginPlatformPaint();
     RECT r = {0, 0, view->width(), view->height()};
     gfx::NativeTheme::instance()->PaintTabPanelBackground(dc, &r);
     canvas->EndPlatformPaint();
   }
 
  private:
   DISALLOW_COPY_AND_ASSIGN(TabBackground);
 };
 
+// Custom layout manager that takes care of sizing and displaying the tab pages.
+class TabLayout : public LayoutManager {
+ public:
+  TabLayout() {}
+
+  // Switches to the tab page identified by the given index.
+  void SwitchToPage(View* host, View* page) {
+    for (int i = 0; i < host->GetChildViewCount(); ++i) {
+      View* child = host->GetChildViewAt(i);
+      // The child might not have been laid out yet.
+      if (child == page)
+        child->SetBounds(gfx::Rect(host->size()));
+      child->SetVisible(child == page);
+    }
+  }
+
+ private:
+  // LayoutManager overrides:
+  virtual void Layout(View* host) {
+    gfx::Rect bounds(host->size());
+    for (int i = 0; i < host->GetChildViewCount(); ++i) {
+      View* child = host->GetChildViewAt(i);
+      // We only layout visible children, since it may be expensive.
+      if (child->IsVisible() && child->bounds() != bounds)
+        child->SetBounds(bounds);
+    }
+  }
+
+  virtual gfx::Size GetPreferredSize(View* host) {
+    // First, query the preferred sizes to determine a good width.
+    int width = 0;
+    for (int i = 0; i < host->GetChildViewCount(); ++i) {
+      View* page = host->GetChildViewAt(i);
+      width = std::max(width, page->GetPreferredSize().width());
+    }
+    // After we know the width, decide on the height.
+    return gfx::Size(width, GetPreferredHeightForWidth(host, width));
+  }
+
+  virtual int GetPreferredHeightForWidth(View* host, int width) {
+    int height = 0;
+    for (int i = 0; i < host->GetChildViewCount(); ++i) {
+      View* page = host->GetChildViewAt(i);
+      height = std::max(height, page->GetHeightForWidth(width));
+    }
+    return height;
+  }
+
+  DISALLOW_COPY_AND_ASSIGN(TabLayout);
+};
+
 ////////////////////////////////////////////////////////////////////////////////
 // NativeTabbedPaneWin, public:
 
 NativeTabbedPaneWin::NativeTabbedPaneWin(TabbedPane* tabbed_pane)
     : NativeControlWin(),
       tabbed_pane_(tabbed_pane),
+      tab_layout_manager_(NULL),
       content_window_(NULL),
       selected_index_(-1) {
   // Associates the actual HWND with the tabbed-pane so the tabbed-pane is
   // the one considered as having the focus (not the wrapper) when the HWND is
   // focused directly (with a click for example).
   set_focus_view(tabbed_pane);
 }
 
 NativeTabbedPaneWin::~NativeTabbedPaneWin() {
   // We own the tab views, let's delete them.
   STLDeleteContainerPointers(tab_views_.begin(), tab_views_.end());
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // NativeTabbedPaneWin, NativeTabbedPaneWrapper implementation:
 
 void NativeTabbedPaneWin::AddTab(const std::wstring& title, View* contents) {
   AddTabAtIndex(static_cast<int>(tab_views_.size()), title, contents, true);
 }
 
 void NativeTabbedPaneWin::AddTabAtIndex(int index, const std::wstring& title,
                                         View* contents,
                                         bool select_if_first_tab) {
   DCHECK(index <= static_cast<int>(tab_views_.size()));
   contents->set_parent_owned(false);
+  contents->SetVisible(false);
   tab_views_.insert(tab_views_.begin() + index, contents);
   tab_titles_.insert(tab_titles_.begin() + index, title);
 
   if (!contents->background())
     contents->set_background(new TabBackground);
 
-  if (tab_views_.size() == 1 && select_if_first_tab) {
-    // If this is the only tab displayed, make sure the contents is set.
+  if (tab_views_.size() == 1 && select_if_first_tab)
     selected_index_ = 0;
-    if (content_window_)
-      content_window_->GetRootView()->AddChildView(contents);
-  }
 
   // Add native tab only if the native control is alreay created.
   if (content_window_) {
-    AddNativeTab(index, title, contents);
-
+    AddNativeTab(index, title);
     // The newly added tab may have made the contents window smaller.
     ResizeContents();
+
+    RootView* content_root = content_window_->GetRootView();
+    content_root->AddChildView(contents);
+    // Switch to the newly added tab if requested;
+    if (tab_views_.size() == 1 && select_if_first_tab)
+      tab_layout_manager_->SwitchToPage(content_root, contents);
   }
 }
 
 void NativeTabbedPaneWin::AddNativeTab(int index,
-                                       const std::wstring &title,
-                                       views::View* contents) {
+                                       const std::wstring &title) {
   TCITEM tcitem;
   tcitem.mask = TCIF_TEXT;
 
   // If the locale is RTL, we set the TCIF_RTLREADING so that BiDi text is
   // rendered properly on the tabs.
   if (base::i18n::IsRTL()) {
     tcitem.mask |= TCIF_RTLREADING;
   }
 
   tcitem.pszText = const_cast<wchar_t*>(title.c_str());
@@ skipping 18 matching lines @@
     }
   }
   TabCtrl_DeleteItem(native_view(), index);
 
   // The removed tab may have made the contents window bigger.
   if (content_window_)
     ResizeContents();
 
   std::vector<View*>::iterator iter = tab_views_.begin() + index;
   View* removed_tab = *iter;
+  if (content_window_)
+    content_window_->GetRootView()->RemoveChildView(removed_tab);
   tab_views_.erase(iter);
   tab_titles_.erase(tab_titles_.begin() + index);
 
   return removed_tab;
 }
 
 void NativeTabbedPaneWin::SelectTabAt(int index) {
   DCHECK((index >= 0) && (index < static_cast<int>(tab_views_.size())));
   if (native_view())
     TabCtrl_SetCurSel(native_view(), index);
@@ skipping 16 matching lines @@
 
 View* NativeTabbedPaneWin::GetView() {
   return this;
 }
 
 void NativeTabbedPaneWin::SetFocus() {
   // Focus the associated HWND.
   Focus();
 }
 
+gfx::Size NativeTabbedPaneWin::GetPreferredSize() {
+  if (!native_view())
+    return gfx::Size();
+
+  gfx::Rect contentSize(content_window_->GetRootView()->GetPreferredSize());
+  RECT paneSize = { 0, 0, contentSize.width(), contentSize.height() };
+  TabCtrl_AdjustRect(native_view(), TRUE, &paneSize);
+  return gfx::Size(paneSize.right - paneSize.left,
+                   paneSize.bottom - paneSize.top);
+}
+
 gfx::NativeView NativeTabbedPaneWin::GetTestingHandle() const {
   return native_view();
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // NativeTabbedPaneWin, NativeControlWin override:
 
 void NativeTabbedPaneWin::CreateNativeControl() {
   // Create the tab control.
   //
@@ skipping 29 matching lines @@
   content_window_ = new WidgetWin();
   content_window_->Init(tab_control, gfx::Rect());
 
   // Explicitly setting the WS_EX_LAYOUTRTL property for the HWND (see above
   // for why we waited until |content_window_| is created before we set this
   // property for the tabbed pane's HWND).
   if (base::i18n::IsRTL())
     l10n_util::HWNDSetRTLLayout(tab_control);
 
   RootView* root_view = content_window_->GetRootView();
-  root_view->SetLayoutManager(new FillLayout());
+  tab_layout_manager_ = new TabLayout();
+  root_view->SetLayoutManager(tab_layout_manager_);
   DWORD sys_color = ::GetSysColor(COLOR_3DHILIGHT);
   SkColor color = SkColorSetRGB(GetRValue(sys_color), GetGValue(sys_color),
                                 GetBValue(sys_color));
   root_view->set_background(Background::CreateSolidBackground(color));
 
   content_window_->SetFocusTraversableParentView(this);
 
   NativeControlCreated(tab_control);
 
   // Add tabs that are already added if any.
@@ skipping 41 matching lines @@
     // We have been added to a view hierarchy, update the FocusTraversable
     // parent.
     content_window_->SetFocusTraversableParent(GetRootView());
   }
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // NativeTabbedPaneWin, private:
 
 void NativeTabbedPaneWin::InitializeTabs() {
-  for (size_t i = 0; i < tab_views_.size(); ++i) {
-    AddNativeTab(i, tab_titles_[i], tab_views_[i]);
-  }
+  for (size_t i = 0; i < tab_titles_.size(); ++i)
+    AddNativeTab(i, tab_titles_[i]);
+
+  RootView* content_root = content_window_->GetRootView();
+  for (std::vector<View*>::iterator tab(tab_views_.begin());
+       tab != tab_views_.end(); ++tab)
+    content_root->AddChildView(*tab);
 }
 
 void NativeTabbedPaneWin::DoSelectTabAt(int index, boolean invoke_listener) {
   selected_index_ = index;
   if (content_window_) {
     RootView* content_root = content_window_->GetRootView();
 
     // Clear the focus if the focused view was on the tab.
     FocusManager* focus_manager = GetFocusManager();
     DCHECK(focus_manager);
     View* focused_view = focus_manager->GetFocusedView();
     if (focused_view && content_root->IsParentOf(focused_view))
       focus_manager->ClearFocus();
-
-    content_root->RemoveAllChildViews(false);
-    content_root->AddChildView(tab_views_[index]);
-    content_root->Layout();
+    tab_layout_manager_->SwitchToPage(content_root, tab_views_.at(index));
   }
   if (invoke_listener && tabbed_pane_->listener())
     tabbed_pane_->listener()->TabSelectedAt(index);
 }
 
 void NativeTabbedPaneWin::ResizeContents() {
   CRect content_bounds;
   if (!GetClientRect(native_view(), &content_bounds))
     return;
   TabCtrl_AdjustRect(native_view(), FALSE, &content_bounds);
   content_window_->MoveWindow(content_bounds.left, content_bounds.top,
                               content_bounds.Width(), content_bounds.Height(),
                               TRUE);
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // NativeTabbedPaneWrapper, public:
 
 // static
 NativeTabbedPaneWrapper* NativeTabbedPaneWrapper::CreateNativeWrapper(
     TabbedPane* tabbed_pane) {
   return new NativeTabbedPaneWin(tabbed_pane);
 }
 
 }  // namespace views