Render maximized mode better when using nonstandard border widths....

chrome/browser/views/frame/opaque_non_client_view.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/frame/opaque_non_client_view.h"
 
 #include "chrome/app/theme/theme_resources.h"
 #include "chrome/browser/tab_contents.h"
 #include "chrome/browser/views/frame/browser_view.h"
 #include "chrome/browser/views/tabs/tab_strip.h"
@@ skipping 273 matching lines @@
 SkBitmap OpaqueNonClientView::app_top_center_;
 SkBitmap OpaqueNonClientView::app_top_right_;
 ChromeFont OpaqueNonClientView::title_font_;
 
 // The distance between the top of the window and the top of the window
 // controls when the window is restored.
 static const int kWindowControlsTopOffset = 1;
 // The distance between the right edge of the window and the right edge of the
 // right-most window control when the window is restored.
 static const int kWindowControlsRightOffset = 4;
-// The distance between the top of the window and the top of the window
-// controls' images when the window is maximized.  We extend the clickable area
-// all the way to the top of the window to obey Fitts' Law.
-static const int kWindowControlsZoomedTopExtraHeight = 5;
-// The distance between the right edge of the window and the right edge of the
-// right-most window control when the window is maximized.
-static const int kWindowControlsZoomedRightOffset = 7;
+// The distance between the bottom of the window's top border and the top of the
+// window controls' images when the window is maximized.  We extend the
+// clickable area all the way to the top of the window to obey Fitts' Law.
+static const int kWindowControlsZoomedTopExtraHeight = 1;
+// The distance between right edge of the right-most window control and the left
+// edge of the window's right border when the window is maximized.
+static const int kWindowControlsZoomedRightOffset = 3;
 // The distance between the left edge of the window and the left edge of the
 // window icon when a title-bar is showing and the window is restored.
 static const int kWindowIconLeftOffset = 5;
-// The distance between the left edge of the window and the left edge of the
-// window icon when a title-bar is showing and the window is maximized.
-static const int kWindowIconZoomedLeftOffset = 6;
+// The distance between the right edge of the window's left border and the left
+// edge of the window icon when a title-bar is showing and the window is
+// maximized.
+static const int kWindowIconZoomedLeftOffset = 2;
 // The distance between the top edge of the window and the top edge of the
-// window icon when a title-bar is showing and the window is restored.
-static const int kWindowIconTopOffset = 6;
-// The distance between the top edge of the window and the top edge of the
-// window icon when a title-bar is showing and the window is maximized.
-static const int kWindowIconZoomedTopOffset = 8;
+// window icon and title when a title-bar is showing and the window is restored.
+static const int kWindowIconAndTitleTopOffset = 6;
+// The distance between the bottom edge of the window's top border and the top
+// edge of the window icon and title when a title-bar is showing and the window
+// is maximized.
+static const int kWindowIconAndTitleZoomedTopOffset = 4;
 // The distance between the window icon and the window title when a title-bar
 // is showing.
 static const int kWindowIconTitleSpacing = 4;
-// The distance between the top of the window and the title text when a
-// title-bar is showing and the window is restored.
-static const int kTitleTopOffset = 6;
-// The distance between the top of the window and the title text when a
-// title-bar is showing and the window is maximized.
-static const int kTitleZoomedTopOffset = 8;
 // The distance between the right edge of the title text bounding box and the
 // left edge of the distributor logo.
 static const int kTitleLogoSpacing = 5;
 // The distance between the bottom of the title text and the TabStrip when a
 // title-bar is showing.
 static const int kTitleBottomSpacing = 6;
 // The distance between the top edge of the window and the TabStrip when there
 // is no title-bar showing, and the window is restored.
 static const int kNoTitleTopSpacing = 15;
-// The distance between the top edge of the window and the TabStrip when there
-// is no title-bar showing, and the window is maximized.
-static const int kNoTitleZoomedTopSpacing = 4;
-// The number of pixels to shave off the bottom of the images making up the top
+// The number of pixels to crop off the bottom of the images making up the top
 // client edge when the window is maximized, so we only draw a shadowed titlebar
 // and not a grey client area border below it.
-static const int kClientEdgeZoomedOffset = 1;
+static const int kClientEdgeZoomedBottomCrop = 1;
 // The amount of horizontal and vertical distance from a corner of the window
 // within which a mouse-drive resize operation will resize the window in two
 // dimensions.
 static const int kResizeAreaCornerSize = 16;
 // The width of the sizing border on the left and right edge of the window.
 static const int kWindowHorizontalBorderSize = 5;
-// The width of the sizing border on the left and right edge of the window when
-// the window is maximized.
-static const int kWindowHorizontalBorderZoomedSize = 4;
 // The height of the sizing border at the top edge of the window
 static const int kWindowVerticalBorderTopSize = 3;
-// The height of the sizing border on the bottom edge of the window.
+// The height of the sizing border on the bottom edge of the window when the
+// window is restored.
 static const int kWindowVerticalBorderBottomSize = 5;
-// The distance between the bottom edge of the window image and the true bottom
-// edge of the window when the window is maximized.
-static const int kWindowBottomZoomedSpacing = 4;
+// The additional height beyond the system-provided thickness of the broder on

[sky, 2009/01/15 01:06:34]

nit: broder -> border

+// the bottom edge of the window when the window is maximized.
+static const int kWindowVerticalBorderZoomedBottomSize = 1;
 // The width and height of the window icon that appears at the top left of
 // pop-up and app windows.
 static const int kWindowIconSize = 16;
 // The horizontal distance of the right edge of the distributor logo from the
 // left edge of the left-most window control.
 static const int kDistributorLogoHorizontalOffset = 7;
 // The vertical distance of the top of the distributor logo from the top edge
 // of the window.
 static const int kDistributorLogoVerticalOffset = 3;
 // The distance between the left edge of the window and the OTR avatar icon when
 // the window is restored.
 static const int kOTRLeftOffset = 7;
-// The distance between the left edge of the window and the OTR avatar icon when
-// the window is maximized.
-static const int kOTRZoomedLeftOffset = 6;
+// The distance between the right edge of the window's left border and the OTR
+// avatar icon when the window is maximized.
+static const int kOTRZoomedLeftOffset = 2;
 // The distance between the top edge of the client area and the OTR avatar icon
 // when the window is maximized.
 static const int kOTRZoomedTopSpacing = 2;
 // The distance between the bottom of the OTR avatar icon and the bottom of the
 // tabstrip.
 static const int kOTRBottomSpacing = 2;
 // The number of pixels to crop off the top of the OTR image when the window is
 // maximized.
 static const int kOTRZoomedTopCrop = 4;
 // Horizontal distance between the right edge of the OTR avatar icon and the
@@ skipping 106 matching lines @@
 }
 
 gfx::Rect OpaqueNonClientView::GetWindowBoundsForClientBounds(
     const gfx::Rect& client_bounds) {
   int top_height = CalculateNonClientTopHeight();
   int horizontal_border = HorizontalBorderSize();
   int window_x = std::max(0, client_bounds.x() - horizontal_border);
   int window_y = std::max(0, client_bounds.y() - top_height);
   int window_w = client_bounds.width() + (2 * horizontal_border);
   int window_h =
-      client_bounds.height() + top_height + kWindowVerticalBorderBottomSize;
+      client_bounds.height() + top_height + VerticalBorderBottomSize();
   return gfx::Rect(window_x, window_y, window_w, window_h);
 }
 
 gfx::Rect OpaqueNonClientView::GetBoundsForTabStrip(TabStrip* tabstrip) {
   int tabstrip_x = browser_view_->ShouldShowOffTheRecordAvatar() ?
       (otr_avatar_bounds_.right() + kOTRTabStripSpacing) :
       HorizontalBorderSize();
   int tabstrip_width = minimize_button_->x() - tabstrip_x -
       (frame_->IsMaximized() ?
       kNewTabIconMinimizeZoomedSpacing : kNewTabIconMinimizeSpacing);
@@ skipping 38 matching lines @@
 
 ///////////////////////////////////////////////////////////////////////////////
 // OpaqueNonClientView, views::NonClientView implementation:
 
 gfx::Rect OpaqueNonClientView::CalculateClientAreaBounds(int width,
                                                          int height) const {
   int top_margin = CalculateNonClientTopHeight();
   int horizontal_border = HorizontalBorderSize();
   return gfx::Rect(horizontal_border, top_margin,
       std::max(0, width - (2 * horizontal_border)),
-      std::max(0, height - top_margin - kWindowVerticalBorderBottomSize));
+      std::max(0, height - top_margin - VerticalBorderBottomSize()));
 }
 
 gfx::Size OpaqueNonClientView::CalculateWindowSizeForClientSize(
     int width,
     int height) const {
   return gfx::Size(width + (2 * HorizontalBorderSize()),
-      height + CalculateNonClientTopHeight() + kWindowVerticalBorderBottomSize);
+      height + CalculateNonClientTopHeight() + VerticalBorderBottomSize());
 }
 
 CPoint OpaqueNonClientView::GetSystemMenuPoint() const {
   CPoint system_menu_point(icon_bounds_.x(), icon_bounds_.bottom());
   MapWindowPoints(frame_->GetHWND(), HWND_DESKTOP, &system_menu_point, 1);
   return system_menu_point;
 }
 
 int OpaqueNonClientView::NonClientHitTest(const gfx::Point& point) {
   // First see if it's within the grow box area, since that overlaps the client
@@ skipping 55 matching lines @@
   restore_button_->SetState(views::Button::BS_NORMAL);
   minimize_button_->SetState(views::Button::BS_NORMAL);
   maximize_button_->SetState(views::Button::BS_NORMAL);
   // The close button isn't affected by this constraint.
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 // OpaqueNonClientView, views::View overrides:
 
 void OpaqueNonClientView::Paint(ChromeCanvas* canvas) {
-  // Clip the content area out of the rendering.
-  gfx::Rect contents_bounds = browser_view_->GetClientAreaBounds();
-  SkRect clip;
-  clip.set(SkIntToScalar(contents_bounds.x()),
-           SkIntToScalar(contents_bounds.y()),
-           SkIntToScalar(contents_bounds.right()),
-           SkIntToScalar(contents_bounds.bottom()));
-  canvas->clipRect(clip, SkRegion::kDifference_Op);
-
-  // Render the remaining portions of the non-client area.
   if (frame_->IsMaximized())
     PaintMaximizedFrameBorder(canvas);
   else
     PaintFrameBorder(canvas);
   PaintDistributorLogo(canvas);
   PaintTitleBar(canvas);
   PaintToolbarBackground(canvas);
   PaintOTRAvatar(canvas);
   if (frame_->IsMaximized())
     PaintMaximizedClientEdge(canvas);
   else
     PaintClientEdge(canvas);
 }
 
 void OpaqueNonClientView::Layout() {
   LayoutWindowControls();
   LayoutDistributorLogo();
   LayoutTitleBar();
   LayoutOTRAvatar();
   LayoutClientView();
 }
 
 gfx::Size OpaqueNonClientView::GetPreferredSize() {
   gfx::Size prefsize(frame_->client_view()->GetPreferredSize());
   prefsize.Enlarge(2 * HorizontalBorderSize(),
-      CalculateNonClientTopHeight() + kWindowVerticalBorderBottomSize);
+      CalculateNonClientTopHeight() + VerticalBorderBottomSize());
   return prefsize;
 }
 
 views::View* OpaqueNonClientView::GetViewForPoint(const gfx::Point& point,
                                                   bool can_create_floating) {
   // We override this function because the ClientView can overlap the non -
   // client view, making it impossible to click on the window controls. We need
   // to ensure the window controls are checked _first_.
   views::View* views[] = { close_button_, restore_button_, maximize_button_,
                            minimize_button_ };
@@ skipping 40 matching lines @@
 }
 
 void OpaqueNonClientView::SetAccessibleName(const std::wstring& name) {
   accessible_name_ = name;
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 // OpaqueNonClientView, private:
 
 int OpaqueNonClientView::CalculateNonClientTopHeight() const {
-  if (frame_->window_delegate()->ShouldShowWindowTitle())
-    return kTitleTopOffset + title_font_.height() + kTitleBottomSpacing;
-  return frame_->IsMaximized() ? kNoTitleZoomedTopSpacing : kNoTitleTopSpacing;
+  if (frame_->window_delegate()->ShouldShowWindowTitle()) {
+    int top_offset = frame_->IsMaximized() ? (GetSystemMetrics(SM_CYSIZEFRAME) +
+        kWindowIconAndTitleZoomedTopOffset) : kWindowIconAndTitleTopOffset;
+    return top_offset + title_font_.height() + kTitleBottomSpacing;
+  }
+  return frame_->IsMaximized() ?
+      GetSystemMetrics(SM_CYSIZEFRAME) : kNoTitleTopSpacing;
 }
 
 int OpaqueNonClientView::HorizontalBorderSize() const {
   return frame_->IsMaximized() ?
-      kWindowHorizontalBorderZoomedSize : kWindowHorizontalBorderSize;
+      GetSystemMetrics(SM_CXSIZEFRAME) : kWindowHorizontalBorderSize;
+}
+
+int OpaqueNonClientView::VerticalBorderBottomSize() const {
+  return frame_->IsMaximized() ? (GetSystemMetrics(SM_CYSIZEFRAME) +
+      kWindowVerticalBorderZoomedBottomSize) : kWindowVerticalBorderBottomSize;
 }
 
 void OpaqueNonClientView::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);
@@ skipping 29 matching lines @@
                         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 OpaqueNonClientView::PaintMaximizedFrameBorder(ChromeCanvas* canvas) {
   SkBitmap* top_edge = resources()->GetPartBitmap(FRAME_MAXIMIZED_TOP_EDGE);
-  canvas->TileImageInt(*top_edge, 0, kNoTitleZoomedTopSpacing, width(),
+  int frame_thickness = GetSystemMetrics(SM_CYSIZEFRAME);
+  canvas->TileImageInt(*top_edge, 0, frame_thickness, width(),
                        top_edge->height());
 
   SkBitmap* bottom_edge =
       resources()->GetPartBitmap(FRAME_MAXIMIZED_BOTTOM_EDGE);
   canvas->TileImageInt(*bottom_edge, 0,
-      height() - bottom_edge->height() - kWindowBottomZoomedSpacing, width(),
+      height() - bottom_edge->height() - frame_thickness, width(),
       bottom_edge->height());
 }
 
 void OpaqueNonClientView::PaintDistributorLogo(ChromeCanvas* canvas) {
   // The distributor logo is only painted when the frame is not maximized and
   // when we actually have a logo.
   if (!frame_->IsMaximized() && !distributor_logo_.empty()) {
     int logo_x = MirroredLeftPointForRect(logo_bounds_);
     canvas->DrawBitmapInt(distributor_logo_, logo_x, logo_bounds_.y());
   }
@@ skipping 59 matching lines @@
   //
   // Note: We can get away with this hackery because we only draw a top edge
   // when there is no toolbar.  If we tried to draw a top edge over the
   // toolbar's top edge, we'd need a different solution.
   gfx::Rect toolbar_bounds = browser_view_->GetToolbarBounds();
   if (browser_view_->IsToolbarVisible())
     toolbar_bounds.set_height(std::max(0, toolbar_bounds.height() - 1));
   int client_area_top = frame_->client_view()->y() + toolbar_bounds.bottom();
 
   // When we don't have a toolbar to draw a top edge for us, draw a top edge.
-  gfx::Rect client_area_bounds = browser_view_->GetClientAreaBounds();
+  gfx::Rect client_area_bounds = CalculateClientAreaBounds(width(), height());
   if (!browser_view_->IsToolbarVisible()) {
     // This is necessary because the top center bitmap is shorter than the top
     // left and right bitmaps.  We need their top edges to line up, and we
     // need the left and right edges to start below the corners' bottoms.
     int top_edge_y = client_area_top - app_top_center_.height();
     client_area_top = top_edge_y + app_top_left_.height();
     canvas->DrawBitmapInt(app_top_left_,
                           client_area_bounds.x() - app_top_left_.width(),
                           top_edge_y);
     canvas->TileImageInt(app_top_center_, client_area_bounds.x(), top_edge_y,
                          client_area_bounds.width(), app_top_center_.height());
     canvas->DrawBitmapInt(app_top_right_, client_area_bounds.right(),
                           top_edge_y);
   }
 
   int client_area_bottom =
-      std::max(client_area_top, height() - kWindowVerticalBorderBottomSize);
+      std::max(client_area_top, height() - VerticalBorderBottomSize());
   int client_area_height = client_area_bottom - client_area_top;
   SkBitmap* right = resources()->GetPartBitmap(FRAME_CLIENT_EDGE_RIGHT);
   canvas->TileImageInt(*right, client_area_bounds.right(), client_area_top,
                        right->width(), client_area_height);
 
   canvas->DrawBitmapInt(
       *resources()->GetPartBitmap(FRAME_CLIENT_EDGE_BOTTOM_RIGHT),
       client_area_bounds.right(), client_area_bottom);
 
   SkBitmap* bottom = resources()->GetPartBitmap(FRAME_CLIENT_EDGE_BOTTOM);
   canvas->TileImageInt(*bottom, client_area_bounds.x(),
       client_area_bottom, client_area_bounds.width(),
       bottom->height());
 
   SkBitmap* bottom_left =
       resources()->GetPartBitmap(FRAME_CLIENT_EDGE_BOTTOM_LEFT);
   canvas->DrawBitmapInt(*bottom_left,
       client_area_bounds.x() - bottom_left->width(), client_area_bottom);
 
   SkBitmap* left = resources()->GetPartBitmap(FRAME_CLIENT_EDGE_LEFT);
   canvas->TileImageInt(*left, client_area_bounds.x() - left->width(),
       client_area_top, left->width(), client_area_height);
 }
 
 void OpaqueNonClientView::PaintMaximizedClientEdge(ChromeCanvas* canvas) {
   if (browser_view_->IsToolbarVisible())
     return;  // The toolbar draws its own client edge, which is sufficient.
 
-  int edge_height = app_top_center_.height() - kClientEdgeZoomedOffset;
+  int edge_height = app_top_center_.height() - kClientEdgeZoomedBottomCrop;
   canvas->TileImageInt(app_top_center_, 0,
       frame_->client_view()->y() - edge_height, width(), edge_height);
 }
 
 void OpaqueNonClientView::LayoutWindowControls() {
   // TODO(pkasting): This function is almost identical to
   // DefaultNonClientView::LayoutWindowControls(), they should be combined.
   close_button_->SetImageAlignment(views::Button::ALIGN_LEFT,
                                    views::Button::ALIGN_BOTTOM);
   // Maximized buttons start at window top so that even if their images aren't
   // drawn flush with the screen edge, they still obey Fitts' Law.
   bool is_maximized = frame_->IsMaximized();
   int top_offset = is_maximized ? 0 : kWindowControlsTopOffset;
-  int top_extra_height = is_maximized ? kWindowControlsZoomedTopExtraHeight : 0;
+  int top_extra_height = is_maximized ?
+      (GetSystemMetrics(SM_CYSIZEFRAME) + kWindowControlsZoomedTopExtraHeight) :
+      0;
+  int right_offset = is_maximized ?
+      (GetSystemMetrics(SM_CXSIZEFRAME) + kWindowControlsZoomedRightOffset) :
+      kWindowControlsRightOffset;
   gfx::Size close_button_size = close_button_->GetPreferredSize();
   close_button_->SetBounds(
-      (width() - close_button_size.width() - (is_maximized ?
-          kWindowControlsZoomedRightOffset : kWindowControlsRightOffset)),
+      (width() - close_button_size.width() - right_offset),
       top_offset,
       (is_maximized ?
           // We extend the maximized close button to the screen corner to obey
           // Fitts' Law.
           (close_button_size.width() + kWindowControlsZoomedRightOffset) :
           close_button_size.width()),
       (close_button_size.height() + top_extra_height));
 
   // When the window is restored, we show a maximized button; otherwise, we show
   // a restore button.
@@ skipping 27 matching lines @@
 void OpaqueNonClientView::LayoutDistributorLogo() {
   logo_bounds_.SetRect(minimize_button_->x() - distributor_logo_.width() -
       kDistributorLogoHorizontalOffset, kDistributorLogoVerticalOffset,
       distributor_logo_.width(), distributor_logo_.height());
 }
 
 void OpaqueNonClientView::LayoutTitleBar() {
   // Size the window icon, even if it is hidden so we can size the title based
   // on its position.
   int left_offset = frame_->IsMaximized() ?
-      kWindowIconZoomedLeftOffset : kWindowIconLeftOffset;
+      (GetSystemMetrics(SM_CXSIZEFRAME) + kWindowIconZoomedLeftOffset) :
+      kWindowIconLeftOffset;
   int top_offset = frame_->IsMaximized() ?
-      kWindowIconZoomedTopOffset : kWindowIconTopOffset;
+      (GetSystemMetrics(SM_CYSIZEFRAME) + kWindowIconAndTitleZoomedTopOffset) :
+      kWindowIconAndTitleTopOffset;
   views::WindowDelegate* d = frame_->window_delegate();
   int icon_size = d->ShouldShowWindowIcon() ? kWindowIconSize : 0;
   icon_bounds_.SetRect(left_offset, top_offset, icon_size, icon_size);
   if (window_icon_)
     window_icon_->SetBounds(icon_bounds_);
 
   // Size the title, if visible.
   if (d->ShouldShowWindowTitle()) {
     int title_right = logo_bounds_.x() - kTitleLogoSpacing;
     int icon_right = icon_bounds_.right();
     int title_left =
         icon_right + (d->ShouldShowWindowIcon() ? kWindowIconTitleSpacing : 0);
-    int top_offset = frame_->IsMaximized() ?
-        kTitleZoomedTopOffset : kTitleTopOffset;
     title_bounds_.SetRect(title_left, top_offset,
         std::max(0, title_right - icon_right), title_font_.height());
   }
 }
 
 void OpaqueNonClientView::LayoutOTRAvatar() {
   SkBitmap otr_avatar_icon = browser_view_->GetOTRAvatarIcon();
   int non_client_height = CalculateNonClientTopHeight();
   int otr_bottom = non_client_height + browser_view_->GetTabStripHeight() -
       kOTRBottomSpacing;
   int otr_x, otr_y, otr_height;
   if (frame_->IsMaximized()) {
-    otr_x = kOTRZoomedLeftOffset;
+    otr_x = GetSystemMetrics(SM_CXSIZEFRAME) + kOTRZoomedLeftOffset;
     otr_y = non_client_height + kOTRZoomedTopSpacing;
     otr_height = otr_bottom - otr_y;
   } else {
     otr_x = kOTRLeftOffset; 
     otr_height = otr_avatar_icon.height();
     otr_y = otr_bottom - otr_height;
   }
   otr_avatar_bounds_.SetRect(otr_x, otr_y, otr_avatar_icon.width(), otr_height);
 }
 
@@ skipping 23 matching lines @@
 }
 
 // static
 void OpaqueNonClientView::InitAppWindowResources() {
   static bool initialized = false;
   if (!initialized) {
     title_font_ = win_util::GetWindowTitleFont();
     initialized = true;
   }
 }