Support DWM switching....

chrome/browser/views/constrained_window_impl.cc

 // Copyright (c) 2006-2008 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 "chrome/browser/views/constrained_window_impl.h"
 
 #include "base/gfx/rect.h"
 #include "chrome/app/chrome_dll_resource.h"
 #include "chrome/browser/browser_process.h"
 #include "chrome/browser/profile.h"
@@ skipping 166 matching lines @@
   static SkBitmap* bitmaps_[FRAME_PART_BITMAP_COUNT];
 
   DISALLOW_EVIL_CONSTRUCTORS(OTRWindowResources);
 };
 
 SkBitmap* XPWindowResources::bitmaps_[];
 SkBitmap* VistaWindowResources::bitmaps_[];
 SkBitmap* OTRWindowResources::bitmaps_[];
 
 ////////////////////////////////////////////////////////////////////////////////
-// ConstrainedWindowNonClientView
+// ConstrainedWindowFrameView
 
-class ConstrainedWindowNonClientView
-    : public views::NonClientView,
+class ConstrainedWindowFrameView
+    : public views::NonClientFrameView,
       public views::BaseButton::ButtonListener {
  public:
-  ConstrainedWindowNonClientView(ConstrainedWindowImpl* container,
-                                 TabContents* owner);
-  virtual ~ConstrainedWindowNonClientView();
+  explicit ConstrainedWindowFrameView(ConstrainedWindowImpl* container);
+  virtual ~ConstrainedWindowFrameView();
 
   void UpdateWindowTitle();
 
-  // Overridden from views::NonClientView:
-  virtual gfx::Rect CalculateClientAreaBounds(int width, int height) const;
-  virtual gfx::Size CalculateWindowSizeForClientSize(int width,
-                                                     int height) const;
+  // Overridden from views::NonClientFrameView:
+  virtual gfx::Rect GetBoundsForClientView() const;
+  virtual bool AlwaysUseCustomFrame() const;
+  virtual gfx::Rect GetWindowBoundsForClientBounds(
+      const gfx::Rect& client_bounds) const;
   virtual gfx::Point GetSystemMenuPoint() const;
   virtual int NonClientHitTest(const gfx::Point& point);
   virtual void GetWindowMask(const gfx::Size& size, gfx::Path* window_mask);
   virtual void EnableClose(bool enable);
   virtual void ResetWindowControls() { }
 
   // Overridden from views::View:
   virtual void Paint(ChromeCanvas* canvas);
   virtual void Layout();
-  virtual void ViewHierarchyChanged(bool is_add, View *parent, View *child);
+  virtual void ThemeChanged();
 
   // Overridden from views::BaseButton::ButtonListener:
   virtual void ButtonPressed(views::BaseButton* sender);
 
  private:
   // Returns the thickness of the border that makes up the window frame edges.
   // This does not include any client edge.
   int FrameBorderThickness() const;
 
   // Returns the thickness of the entire nonclient left, right, and bottom
@@ skipping 12 matching lines @@
   // Paints different parts of the window to the incoming canvas.
   void PaintFrameBorder(ChromeCanvas* canvas);
   void PaintTitleBar(ChromeCanvas* canvas);
   void PaintClientEdge(ChromeCanvas* canvas);
 
   // Layout various sub-components of this view.
   void LayoutWindowControls();
   void LayoutTitleBar();
   void LayoutClientView();
 
+  // Returns the bounds of the client area for the specified view size.
+  gfx::Rect CalculateClientAreaBounds(int width, int height) const;
+
   SkColor GetTitleColor() const {
     return (container_->owner()->profile()->IsOffTheRecord() ||
         !win_util::ShouldUseVistaFrame()) ? SK_ColorWHITE : SK_ColorBLACK;
   }
 
+  // Loads the appropriate set of WindowResources for the frame view.
+  void InitWindowResources();
+
   ConstrainedWindowImpl* container_;
 
   scoped_ptr<views::WindowResources> resources_;
 
   gfx::Rect title_bounds_;
 
   views::Button* close_button_;
 
+  // The bounds of the ClientView.
+  gfx::Rect client_view_bounds_;
+
   static void InitClass();
 
   // The font to be used to render the titlebar text.
   static ChromeFont title_font_;
 
-  DISALLOW_EVIL_CONSTRUCTORS(ConstrainedWindowNonClientView);
+  DISALLOW_EVIL_CONSTRUCTORS(ConstrainedWindowFrameView);
 };
 
-ChromeFont ConstrainedWindowNonClientView::title_font_;
+ChromeFont ConstrainedWindowFrameView::title_font_;
 
 namespace {
 // The frame border is only visible in restored mode and is hardcoded to 4 px on
 // each side regardless of the system window border size.
 const int kFrameBorderThickness = 4;
 // Various edges of the frame border have a 1 px shadow along their edges; in a
 // few cases we shift elements based on this amount for visual appeal.
 const int kFrameShadowThickness = 1;
 // In the window corners, the resize areas don't actually expand bigger, but the
 // 16 px at the end of each edge triggers diagonal resizing.
@@ skipping 10 matching lines @@
 // The caption buttons are always drawn 1 px down from the visible top of the
 // window (the true top in restored mode, or the top of the screen in maximized
 // mode).
 const int kCaptionTopSpacing = 1;
 
 const SkColor kContentsBorderShadow = SkColorSetARGB(51, 0, 0, 0);
 const SkColor kContentsBorderColor = SkColorSetRGB(219, 235, 255);
 }
 
 ////////////////////////////////////////////////////////////////////////////////
-// ConstrainedWindowNonClientView, public:
+// ConstrainedWindowFrameView, public:
 
-ConstrainedWindowNonClientView::ConstrainedWindowNonClientView(
-    ConstrainedWindowImpl* container, TabContents* owner)
-        : NonClientView(),
+ConstrainedWindowFrameView::ConstrainedWindowFrameView(
+    ConstrainedWindowImpl* container)
+        : NonClientFrameView(),
           container_(container),
           close_button_(new views::Button) {
   InitClass();
-  if (owner->profile()->IsOffTheRecord()) {
-    resources_.reset(new OTRWindowResources);
-  } else {
-    if (win_util::ShouldUseVistaFrame()) {
-      resources_.reset(new VistaWindowResources);
-    } else {
-      resources_.reset(new XPWindowResources);
-    }
-  }
+  InitWindowResources();
 
   close_button_->SetImage(views::Button::BS_NORMAL,
       resources_->GetPartBitmap(FRAME_CLOSE_BUTTON_ICON));
   close_button_->SetImage(views::Button::BS_HOT,
       resources_->GetPartBitmap(FRAME_CLOSE_BUTTON_ICON_H));
   close_button_->SetImage(views::Button::BS_PUSHED,
       resources_->GetPartBitmap(FRAME_CLOSE_BUTTON_ICON_P));
   close_button_->SetImageAlignment(views::Button::ALIGN_CENTER,
                                    views::Button::ALIGN_MIDDLE);
   close_button_->SetListener(this, 0);
   AddChildView(close_button_);
 }
 
-ConstrainedWindowNonClientView::~ConstrainedWindowNonClientView() {
+ConstrainedWindowFrameView::~ConstrainedWindowFrameView() {
 }
 
-void ConstrainedWindowNonClientView::UpdateWindowTitle() {
+void ConstrainedWindowFrameView::UpdateWindowTitle() {
   SchedulePaint(title_bounds_, false);
 }
 
 ////////////////////////////////////////////////////////////////////////////////
-// ConstrainedWindowNonClientView, views::NonClientView implementation:
+// ConstrainedWindowFrameView, views::NonClientFrameView implementation:
 
-gfx::Rect ConstrainedWindowNonClientView::CalculateClientAreaBounds(
-    int width,
-    int height) const {
+gfx::Rect ConstrainedWindowFrameView::GetBoundsForClientView() const {
+  return client_view_bounds_;
+}
+
+bool ConstrainedWindowFrameView::AlwaysUseCustomFrame() const {
+  // Constrained windows always use the custom frame - they just have a
+  // different set of bitmaps.
+  return true;
+}
+
+gfx::Rect ConstrainedWindowFrameView::GetWindowBoundsForClientBounds(
+    const gfx::Rect& client_bounds) const {
   int top_height = NonClientTopBorderHeight();
   int border_thickness = NonClientBorderThickness();
-  return gfx::Rect(border_thickness, top_height,
-                   std::max(0, width - (2 * border_thickness)),
-                   std::max(0, height - top_height - border_thickness));
+  return gfx::Rect(std::max(0, client_bounds.x() - border_thickness),
+                   std::max(0, client_bounds.y() - top_height),
+                   client_bounds.width() + (2 * border_thickness),
+                   client_bounds.height() + top_height + border_thickness);
 }
 
-gfx::Size ConstrainedWindowNonClientView::CalculateWindowSizeForClientSize(
-    int width,
-    int height) const {
-  int border_thickness = NonClientBorderThickness();
-  return gfx::Size(width + (2 * border_thickness),
-                   height + NonClientTopBorderHeight() + border_thickness);
-}
-
-gfx::Point ConstrainedWindowNonClientView::GetSystemMenuPoint() const {
+gfx::Point ConstrainedWindowFrameView::GetSystemMenuPoint() const {
   // Doesn't really matter, since we never show system menus on constrained
   // windows...
   gfx::Point system_menu_point(FrameBorderThickness(),
                                NonClientTopBorderHeight());
   ConvertPointToScreen(this, &system_menu_point);
   return system_menu_point;
 }
 
-int ConstrainedWindowNonClientView::NonClientHitTest(const gfx::Point& point) {
+int ConstrainedWindowFrameView::NonClientHitTest(const gfx::Point& point) {
   if (!bounds().Contains(point))
     return HTNOWHERE;
 
   int frame_component = container_->client_view()->NonClientHitTest(point);
   if (frame_component != HTNOWHERE)
     return frame_component;
 
   // Then see if the point is within any of the window controls.
   if (close_button_->GetBounds(APPLY_MIRRORING_TRANSFORMATION).Contains(point))
     return HTCLOSE;
 
   int window_component = GetHTComponentForFrame(point, FrameBorderThickness(),
       NonClientBorderThickness(), kResizeAreaCornerSize, kResizeAreaCornerSize,
       container_->window_delegate()->CanResize());
   // Fall back to the caption if no other component matches.
   return (window_component == HTNOWHERE) ? HTCAPTION : window_component;
 }
 
-void ConstrainedWindowNonClientView::GetWindowMask(const gfx::Size& size,
-                                                   gfx::Path* window_mask) {
+void ConstrainedWindowFrameView::GetWindowMask(const gfx::Size& size,
+                                               gfx::Path* window_mask) {
   DCHECK(window_mask);
 
   // Redefine the window visible region for the new size.
   window_mask->moveTo(0, 3);
   window_mask->lineTo(1, 2);
   window_mask->lineTo(1, 1);
   window_mask->lineTo(2, 1);
   window_mask->lineTo(3, 0);
 
   window_mask->lineTo(SkIntToScalar(size.width() - 3), 0);
   window_mask->lineTo(SkIntToScalar(size.width() - 2), 1);
   window_mask->lineTo(SkIntToScalar(size.width() - 1), 1);
   window_mask->lineTo(SkIntToScalar(size.width() - 1), 2);
   window_mask->lineTo(SkIntToScalar(size.width()), 3);
 
   window_mask->lineTo(SkIntToScalar(size.width()),
                       SkIntToScalar(size.height()));
   window_mask->lineTo(0, SkIntToScalar(size.height()));
   window_mask->close();
 }
 
-void ConstrainedWindowNonClientView::EnableClose(bool enable) {
+void ConstrainedWindowFrameView::EnableClose(bool enable) {
   close_button_->SetEnabled(enable);
 }
 
 ////////////////////////////////////////////////////////////////////////////////
-// ConstrainedWindowNonClientView, views::View implementation:
+// ConstrainedWindowFrameView, views::View implementation:
 
-void ConstrainedWindowNonClientView::Paint(ChromeCanvas* canvas) {
+void ConstrainedWindowFrameView::Paint(ChromeCanvas* canvas) {
   PaintFrameBorder(canvas);
   PaintTitleBar(canvas);
   PaintClientEdge(canvas);
 }
 
-void ConstrainedWindowNonClientView::Layout() {
+void ConstrainedWindowFrameView::Layout() {
   LayoutWindowControls();
   LayoutTitleBar();
   LayoutClientView();
 }
 
-void ConstrainedWindowNonClientView::ViewHierarchyChanged(bool is_add,
-                                                          View *parent,
-                                                          View *child) {
-  // Add our Client View as we are added to the Container so that if we are
-  // subsequently resized all the parent-child relationships are established.
-  if (is_add && GetWidget() && child == this)
-    AddChildView(container_->client_view());
+void ConstrainedWindowFrameView::ThemeChanged() {
+  InitWindowResources();
 }
 
 ////////////////////////////////////////////////////////////////////////////////
-// ConstrainedWindowNonClientView, views::BaseButton::Button
+// ConstrainedWindowFrameView, views::BaseButton::Button
 //     implementation:
 
-void ConstrainedWindowNonClientView::ButtonPressed(views::BaseButton* sender) {
+void ConstrainedWindowFrameView::ButtonPressed(views::BaseButton* sender) {
   if (sender == close_button_)
     container_->ExecuteSystemMenuCommand(SC_CLOSE);
 }
 
 ////////////////////////////////////////////////////////////////////////////////
-// ConstrainedWindowNonClientView, private:
+// ConstrainedWindowFrameView, private:
 
-int ConstrainedWindowNonClientView::FrameBorderThickness() const {
+int ConstrainedWindowFrameView::FrameBorderThickness() const {
   return kFrameBorderThickness;
 }
 
-int ConstrainedWindowNonClientView::NonClientBorderThickness() const {
+int ConstrainedWindowFrameView::NonClientBorderThickness() const {
   return FrameBorderThickness() + kClientEdgeThickness;
 }
 
-int ConstrainedWindowNonClientView::NonClientTopBorderHeight() const {
+int ConstrainedWindowFrameView::NonClientTopBorderHeight() const {
   int title_top_spacing, title_thickness;
   return TitleCoordinates(&title_top_spacing, &title_thickness);
 }
 
-int ConstrainedWindowNonClientView::TitleCoordinates(
+int ConstrainedWindowFrameView::TitleCoordinates(
     int* title_top_spacing,
     int* title_thickness) const {
   int frame_thickness = FrameBorderThickness();
   int min_titlebar_height = kTitlebarMinimumHeight + frame_thickness;
   *title_top_spacing = frame_thickness + kTitleTopSpacing;
   // The bottom spacing should be the same apparent height as the top spacing,
   // plus have the client edge tacked on.
   int title_bottom_spacing = *title_top_spacing + kClientEdgeThickness;
   *title_thickness = std::max(title_font_.height(),
       min_titlebar_height - *title_top_spacing - title_bottom_spacing);
   return *title_top_spacing + *title_thickness + title_bottom_spacing;
 }
 
-void ConstrainedWindowNonClientView::PaintFrameBorder(ChromeCanvas* canvas) {
+void ConstrainedWindowFrameView::PaintFrameBorder(ChromeCanvas* canvas) {
   SkBitmap* top_left_corner = resources_->GetPartBitmap(FRAME_TOP_LEFT_CORNER);
   SkBitmap* top_right_corner =
       resources_->GetPartBitmap(FRAME_TOP_RIGHT_CORNER);
   SkBitmap* top_edge = resources_->GetPartBitmap(FRAME_TOP_EDGE);
   SkBitmap* right_edge = resources_->GetPartBitmap(FRAME_RIGHT_EDGE);
   SkBitmap* left_edge = resources_->GetPartBitmap(FRAME_LEFT_EDGE);
   SkBitmap* bottom_left_corner =
       resources_->GetPartBitmap(FRAME_BOTTOM_LEFT_CORNER);
   SkBitmap* bottom_right_corner =
       resources_->GetPartBitmap(FRAME_BOTTOM_RIGHT_CORNER);
@@ skipping 23 matching lines @@
                        bottom_edge->height());
   canvas->DrawBitmapInt(*bottom_left_corner, 0,
                         height() - bottom_left_corner->height());
 
   // Left.
   canvas->TileImageInt(*left_edge, 0, top_left_corner->height(),
       left_edge->width(),
       height() - top_left_corner->height() - bottom_left_corner->height());
 }
 
-void ConstrainedWindowNonClientView::PaintTitleBar(ChromeCanvas* canvas) {
+void ConstrainedWindowFrameView::PaintTitleBar(ChromeCanvas* canvas) {
   canvas->DrawStringInt(container_->GetWindowTitle(), title_font_,
       GetTitleColor(), MirroredLeftPointForRect(title_bounds_),
       title_bounds_.y(), title_bounds_.width(), title_bounds_.height());
 }
 
-void ConstrainedWindowNonClientView::PaintClientEdge(ChromeCanvas* canvas) {
+void ConstrainedWindowFrameView::PaintClientEdge(ChromeCanvas* canvas) {
   gfx::Rect client_edge_bounds(CalculateClientAreaBounds(width(), height()));
   client_edge_bounds.Inset(-kClientEdgeThickness, -kClientEdgeThickness);
   gfx::Rect frame_shadow_bounds(client_edge_bounds);
   frame_shadow_bounds.Inset(-kFrameShadowThickness, -kFrameShadowThickness);
 
   canvas->FillRectInt(kContentsBorderShadow, frame_shadow_bounds.x(),
                       frame_shadow_bounds.y(), frame_shadow_bounds.width(),
                       frame_shadow_bounds.height());
 
   canvas->FillRectInt(kContentsBorderColor, client_edge_bounds.x(),
                       client_edge_bounds.y(), client_edge_bounds.width(),
                       client_edge_bounds.height());
 }
 
-void ConstrainedWindowNonClientView::LayoutWindowControls() {
+void ConstrainedWindowFrameView::LayoutWindowControls() {
   gfx::Size close_button_size = close_button_->GetPreferredSize();
   close_button_->SetBounds(
       width() - close_button_size.width() - FrameBorderThickness(),
       kCaptionTopSpacing, close_button_size.width(),
       close_button_size.height());
 }
 
-void ConstrainedWindowNonClientView::LayoutTitleBar() {
+void ConstrainedWindowFrameView::LayoutTitleBar() {
   // Size the title.
   int title_x = FrameBorderThickness() + kIconLeftSpacing;
   int title_top_spacing, title_thickness;
   TitleCoordinates(&title_top_spacing, &title_thickness);
   title_bounds_.SetRect(title_x,
       title_top_spacing + ((title_thickness - title_font_.height()) / 2),
       std::max(0, close_button_->x() - kTitleCaptionSpacing - title_x),
       title_font_.height());
 }
 
-void ConstrainedWindowNonClientView::LayoutClientView() {
-  container_->client_view()->SetBounds(CalculateClientAreaBounds(width(),
-                                                                 height()));
+void ConstrainedWindowFrameView::LayoutClientView() {
+  client_view_bounds_ = CalculateClientAreaBounds(width(), height());
+}
+
+gfx::Rect ConstrainedWindowFrameView::CalculateClientAreaBounds(
+    int width,
+    int height) const {
+  int top_height = NonClientTopBorderHeight();
+  int border_thickness = NonClientBorderThickness();
+  return gfx::Rect(border_thickness, top_height,
+                   std::max(0, width - (2 * border_thickness)),
+                   std::max(0, height - top_height - border_thickness));
+}
+
+void ConstrainedWindowFrameView::InitWindowResources() {
+  if (container_->owner()->profile()->IsOffTheRecord()) {
+    resources_.reset(new OTRWindowResources);
+  } else {
+    if (win_util::ShouldUseVistaFrame()) {
+      resources_.reset(new VistaWindowResources);
+    } else {
+      resources_.reset(new XPWindowResources);
+    }
+  }
 }
 
 // static
-void ConstrainedWindowNonClientView::InitClass() {
+void ConstrainedWindowFrameView::InitClass() {
   static bool initialized = false;
   if (!initialized) {
     title_font_ = win_util::GetWindowTitleFont();
 
     initialized = true;
   }
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // ConstrainedWindowImpl, public:
 
 // The space (in pixels) between minimized pop-ups stacked horizontally and
 // vertically.
 static const int kPopupRepositionOffset = 5;
 static const int kConstrainedWindowEdgePadding = 10;
 
 ConstrainedWindowImpl::~ConstrainedWindowImpl() {
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // ConstrainedWindowImpl, ConstrainedWindow implementation:
 
-ConstrainedWindowNonClientView* ConstrainedWindowImpl::non_client_view() {
-  return static_cast<ConstrainedWindowNonClientView*>(non_client_view_);
+views::NonClientFrameView* ConstrainedWindowImpl::CreateFrameViewForWindow() {
+  return new ConstrainedWindowFrameView(this);
 }
 
 void ConstrainedWindowImpl::UpdateWindowTitle() {
   UpdateUI(TabContents::INVALIDATE_TITLE);
 }
 
 void ConstrainedWindowImpl::ActivateConstrainedWindow() {
   // Other pop-ups are simply moved to the front of the z-order.
   SetWindowPos(HWND_TOP, 0, 0, 0, 0, SWP_NOMOVE | SWP_NOSIZE | SWP_SHOWWINDOW);
 
@@ skipping 47 matching lines @@
 const gfx::Rect& ConstrainedWindowImpl::GetCurrentBounds() const {
   return current_bounds_;
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // ConstrainedWindowImpl, private:
 
 ConstrainedWindowImpl::ConstrainedWindowImpl(
     TabContents* owner,
     views::WindowDelegate* window_delegate)
-    : CustomFrameWindow(window_delegate,
-                        new ConstrainedWindowNonClientView(this, owner)) {
-  Init(owner);
+    : Window(window_delegate),
+      owner_(owner) {
+  non_client_view_->SetFrameView(CreateFrameViewForWindow());
+  Init();
 }
 
-void ConstrainedWindowImpl::Init(TabContents* owner) {
-  owner_ = owner;
+void ConstrainedWindowImpl::Init() {
   focus_restoration_disabled_ = false;
   set_window_style(WS_CHILD | WS_CLIPSIBLINGS | WS_CLIPCHILDREN | WS_CAPTION |
                    WS_THICKFRAME | WS_SYSMENU);
   set_focus_on_creation(false);
 }
 
 void ConstrainedWindowImpl::InitAsDialog(const gfx::Rect& initial_bounds) {
-  CustomFrameWindow::Init(owner_->GetNativeView(), initial_bounds);
+  Window::Init(owner_->GetNativeView(), initial_bounds);
   ActivateConstrainedWindow();
 }
 
 void ConstrainedWindowImpl::UpdateUI(unsigned int changed_flags) {
   if (changed_flags & TabContents::INVALIDATE_TITLE)
-    non_client_view()->UpdateWindowTitle();
+    UpdateWindowTitle();
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // ConstrainedWindowImpl, views::WidgetWin overrides:
 
 void ConstrainedWindowImpl::OnDestroy() {
   // We do this here, rather than |Close|, since the window may be destroyed in
   // a way other than by some other component calling Close, e.g. by the native
   // window hierarchy closing. We are guaranteed to receive a WM_DESTROY
   // message regardless of how the window is closed.
@@ skipping 53 matching lines @@
 ConstrainedWindow* ConstrainedWindow::CreateConstrainedDialog(
     TabContents* parent,
     const gfx::Rect& initial_bounds,
     views::View* contents_view,
     views::WindowDelegate* window_delegate) {
   ConstrainedWindowImpl* window = new ConstrainedWindowImpl(parent,
                                                             window_delegate);
   window->InitAsDialog(initial_bounds);
   return window;
 }