Fix various problems with constrained windows and/or custom frame windows:...

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/app/theme/theme_resources.h"
 #include "chrome/browser/browser_process.h"
 #include "chrome/browser/profile.h"
 #include "chrome/browser/tab_contents/tab_contents.h"
 #include "chrome/browser/tab_contents/web_contents.h"
 #include "chrome/browser/tab_contents/web_contents_view.h"
 #include "chrome/browser/toolbar_model.h"
+#include "chrome/browser/views/frame/browser_view.h"
 #include "chrome/browser/web_app.h"
 #include "chrome/browser/window_sizer.h"
 #include "chrome/common/chrome_constants.h"
 #include "chrome/common/gfx/chrome_canvas.h"
 #include "chrome/common/gfx/chrome_font.h"
 #include "chrome/common/gfx/path.h"
 #include "chrome/common/gfx/text_elider.h"
 #include "chrome/common/l10n_util.h"
 #include "chrome/common/pref_names.h"
 #include "chrome/common/pref_service.h"
@@ skipping 183 matching lines @@
   // Overridden from views::View:
   virtual void Paint(ChromeCanvas* canvas);
   virtual void Layout();
   virtual gfx::Size GetPreferredSize();
   virtual void ViewHierarchyChanged(bool is_add, View *parent, View *child);
 
   // 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
+  // borders, including both the window frame and any client edge.
+  int NonClientBorderThickness() const;
+
   // Returns the height of the entire nonclient top border, including the window
   // frame, any title area, and any connected client edge.
   int NonClientTopBorderHeight() const;
 
+  // Calculates multiple values related to title layout.  Returns the height of
+  // the entire titlebar including any connected client edge.
+  int TitleCoordinates(int* title_top_spacing,
+                       int* title_thickness) const;
+
   // 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();
 
@@ skipping 12 matching lines @@
 
   static void InitClass();
 
   // The font to be used to render the titlebar text.
   static ChromeFont title_font_;
 
   DISALLOW_EVIL_CONSTRUCTORS(ConstrainedWindowNonClientView);
 };
 
 ChromeFont ConstrainedWindowNonClientView::title_font_;
-static const int kWindowLeftSpacing = 5;
-static const int kWindowControlsTopOffset = 1;
-static const int kWindowControlsRightOffset = 4;
-static const int kTitleTopOffset = 6;
-static const int kTitleBottomSpacing = 5;
-static const int kNoTitleTopSpacing = 8;
-static const int kResizeAreaSize = 5;
-static const int kResizeAreaNorthSize = 3;
-static const int kResizeAreaCornerSize = 16;
-static const int kWindowHorizontalBorderSize = 5;
-static const int kWindowVerticalBorderSize = 5;
-static const int kWindowIconSize = 16;
 
 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.
+const int kResizeAreaCornerSize = 16;
+// The titlebar never shrinks to less than 20 px tall, including the height of
+// the frame border and client edge.
+const int kTitlebarMinimumHeight = 20;
+// The icon is inset 2 px from the left frame border.
+const int kIconLeftSpacing = 2;
+// The title text starts 2 px below the bottom of the top frame border.
+const int kTitleTopSpacing = 2;
+// There is a 5 px gap between the title text and the caption buttons.
+const int kTitleCaptionSpacing = 5;
+// 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:
 
 ConstrainedWindowNonClientView::ConstrainedWindowNonClientView(
     ConstrainedWindowImpl* container, TabContents* owner)
         : NonClientView(),
@@ skipping 29 matching lines @@
   SchedulePaint(title_bounds_, false);
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // ConstrainedWindowNonClientView, views::NonClientView implementation:
 
 gfx::Rect ConstrainedWindowNonClientView::CalculateClientAreaBounds(
     int width,
     int height) const {
   int top_height = NonClientTopBorderHeight();
-  return gfx::Rect(kWindowHorizontalBorderSize, top_height,
-      std::max(0, width - (2 * kWindowHorizontalBorderSize)),
-      std::max(0, height - top_height - kWindowVerticalBorderSize));
+  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));
 }
 
 gfx::Size ConstrainedWindowNonClientView::CalculateWindowSizeForClientSize(
     int width,
     int height) const {
-  return gfx::Size(width + (2 * kWindowHorizontalBorderSize),
-      height + NonClientTopBorderHeight() + kWindowVerticalBorderSize);
+  int border_thickness = NonClientBorderThickness();
+  return gfx::Size(width + (2 * border_thickness),
+                   height + NonClientTopBorderHeight() + border_thickness);
 }
 
 CPoint ConstrainedWindowNonClientView::GetSystemMenuPoint() const {
   // Doesn't matter what we return, since this is only used when the user clicks
   // a window icon, and we never have an icon.
   return CPoint();
 }
 
 int ConstrainedWindowNonClientView::NonClientHitTest(const gfx::Point& point) {
   // First see if it's within the grow box area, since that overlaps the client
   // bounds.
   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, kResizeAreaNorthSize,
-      kResizeAreaSize, kResizeAreaCornerSize,
+  int window_component = GetHTComponentForFrame(point, FrameBorderThickness(),
+      NonClientBorderThickness(), kResizeAreaCornerSize,
       container_->window_delegate()->CanResize());
   // Fall back to the caption if no other component matches.
   return ((window_component == HTNOWHERE) && bounds().Contains(point)) ?
       HTCAPTION : window_component;
 }
 
 void ConstrainedWindowNonClientView::GetWindowMask(const gfx::Size& size,
                                                    gfx::Path* window_mask) {
   DCHECK(window_mask);
 
@@ skipping 30 matching lines @@
 }
 
 void ConstrainedWindowNonClientView::Layout() {
   LayoutWindowControls();
   LayoutTitleBar();
   LayoutClientView();
 }
 
 gfx::Size ConstrainedWindowNonClientView::GetPreferredSize() {
   gfx::Size prefsize(container_->client_view()->GetPreferredSize());
-  prefsize.Enlarge(2 * kWindowHorizontalBorderSize,
-                   NonClientTopBorderHeight() + kWindowVerticalBorderSize);
+  int border_thickness = NonClientBorderThickness();
+  prefsize.Enlarge(2 * border_thickness,
+                   NonClientTopBorderHeight() + border_thickness);
   return prefsize;
 }
 
 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());
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // ConstrainedWindowNonClientView, views::BaseButton::Button
 //     implementation:
 
 void ConstrainedWindowNonClientView::ButtonPressed(views::BaseButton* sender) {
   if (sender == close_button_)
     container_->ExecuteSystemMenuCommand(SC_CLOSE);
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // ConstrainedWindowNonClientView, private:
 
+int ConstrainedWindowNonClientView::FrameBorderThickness() const {
+  return kFrameBorderThickness;
+}
+
+int ConstrainedWindowNonClientView::NonClientBorderThickness() const {
+  return FrameBorderThickness() + kClientEdgeThickness;
+}
+
 int ConstrainedWindowNonClientView::NonClientTopBorderHeight() const {
-  return kTitleTopOffset + title_font_.height() + kTitleBottomSpacing;
+  int title_top_spacing, title_thickness;
+  return TitleCoordinates(&title_top_spacing, &title_thickness);
+}
+
+int ConstrainedWindowNonClientView::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) {
   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 =
@@ skipping 36 matching lines @@
 void ConstrainedWindowNonClientView::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) {
   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(-1, -1);
+  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() {
   gfx::Size close_button_size = close_button_->GetPreferredSize();
   close_button_->SetBounds(
-      width() - close_button_size.width() - kWindowControlsRightOffset,
-      kWindowControlsTopOffset, close_button_size.width(),
+      width() - close_button_size.width() - FrameBorderThickness(),
+      kCaptionTopSpacing, close_button_size.width(),
       close_button_size.height());
 }
 
 void ConstrainedWindowNonClientView::LayoutTitleBar() {
   // Size the title.
-  int title_x = kWindowLeftSpacing;
-  int title_top_spacing = NonClientTopBorderHeight();
-  title_bounds_.SetRect(title_x, kTitleTopOffset,
-                        close_button_->x() - kWindowLeftSpacing - title_x,
-                        title_font_.height());
+  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()));
 }
 
 // static
 void ConstrainedWindowNonClientView::InitClass() {
   static bool initialized = false;
@@ skipping 174 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;
 }