Reland Linux Window Control Alignment

ui/views/window/custom_frame_view.cc

 // Copyright (c) 2012 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 "ui/views/window/custom_frame_view.h"
 
 #include <algorithm>
+#include <vector>
 
 #include "base/strings/utf_string_conversions.h"
 #include "grit/ui_resources.h"
 #include "grit/ui_strings.h"
 #include "ui/base/hit_test.h"
 #include "ui/base/l10n/l10n_util.h"
 #include "ui/base/resource/resource_bundle.h"
 #include "ui/gfx/canvas.h"
 #include "ui/gfx/font.h"
 #include "ui/gfx/image/image.h"
 #include "ui/gfx/path.h"
+#include "ui/gfx/rect.h"
 #include "ui/views/color_constants.h"
 #include "ui/views/controls/button/image_button.h"
 #include "ui/views/views_delegate.h"
 #include "ui/views/widget/native_widget_private.h"
 #include "ui/views/widget/widget.h"
 #include "ui/views/widget/widget_delegate.h"
 #include "ui/views/window/client_view.h"
 #include "ui/views/window/frame_background.h"
+#include "ui/views/window/window_button_order_provider.h"
 #include "ui/views/window/window_resources.h"
 #include "ui/views/window/window_shape.h"
 
 namespace views {
 
 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;
@@ skipping 23 matching lines @@
 const SkColor kDefaultColorFrame = SkColorSetRGB(66, 116, 201);
 const SkColor kDefaultColorFrameInactive = SkColorSetRGB(161, 182, 228);
 #endif
 
 const gfx::FontList& GetTitleFontList() {
   static const gfx::FontList title_font_list =
       internal::NativeWidgetPrivate::GetWindowTitleFontList();
   return title_font_list;
 }
 
+void LayoutButton(ImageButton* button, const gfx::Rect& bounds) {
+  button->SetVisible(true);
+  button->SetImageAlignment(ImageButton::ALIGN_LEFT,
+                            ImageButton::ALIGN_BOTTOM);
+  button->SetBoundsRect(bounds);
+}
+
 }  // namespace
 
 ///////////////////////////////////////////////////////////////////////////////
 // CustomFrameView, public:
 
 CustomFrameView::CustomFrameView()
     : frame_(NULL),
       window_icon_(NULL),
       minimize_button_(NULL),
       maximize_button_(NULL),
       restore_button_(NULL),
       close_button_(NULL),
       should_show_maximize_button_(false),
-      frame_background_(new FrameBackground()) {
+      frame_background_(new FrameBackground()),
+      minimum_title_bar_x_(0),
+      maximum_title_bar_x_(-1) {
 }
 
 CustomFrameView::~CustomFrameView() {
 }
 
 void CustomFrameView::Init(Widget* frame) {
   frame_ = frame;
 
-  close_button_ = new ImageButton(this);
-  close_button_->SetAccessibleName(
-      l10n_util::GetStringUTF16(IDS_APP_ACCNAME_CLOSE));
-
-  // Close button images will be set in LayoutWindowControls().
-  AddChildView(close_button_);
-
+  close_button_ = InitWindowCaptionButton(IDS_APP_ACCNAME_CLOSE,
+      IDR_CLOSE, IDR_CLOSE_H, IDR_CLOSE_P);
   minimize_button_ = InitWindowCaptionButton(IDS_APP_ACCNAME_MINIMIZE,
       IDR_MINIMIZE, IDR_MINIMIZE_H, IDR_MINIMIZE_P);
-
   maximize_button_ = InitWindowCaptionButton(IDS_APP_ACCNAME_MAXIMIZE,
       IDR_MAXIMIZE, IDR_MAXIMIZE_H, IDR_MAXIMIZE_P);
-
   restore_button_ = InitWindowCaptionButton(IDS_APP_ACCNAME_RESTORE,
       IDR_RESTORE, IDR_RESTORE_H, IDR_RESTORE_P);
 
   should_show_maximize_button_ = frame_->widget_delegate()->CanMaximize();
 
   if (frame_->widget_delegate()->ShouldShowWindowIcon()) {
     window_icon_ = new ImageButton(this);
     AddChildView(window_icon_);
   }
 }
@@ skipping 154 matching lines @@
 
 int CustomFrameView::NonClientTopBorderHeight() const {
   return std::max(FrameBorderThickness() + IconSize(),
                   CaptionButtonY() + kCaptionButtonHeightWithPadding) +
       TitlebarBottomThickness();
 }
 
 int CustomFrameView::CaptionButtonY() const {
   // 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.
-  return frame_->IsMaximized() ? FrameBorderThickness() : kFrameShadowThickness;
+  return frame_->IsMaximized() ? FrameBorderThickness() : kFrameBorderThickness;
 }
 
 int CustomFrameView::TitlebarBottomThickness() const {
   return kTitlebarTopAndBottomEdgeThickness +
       (ShouldShowClientEdge() ? kClientEdgeThickness : 0);
 }
 
 int CustomFrameView::IconSize() const {
 #if defined(OS_WIN)
   // This metric scales up if either the titlebar height or the titlebar font
@@ skipping 17 matching lines @@
   // from below the 3D edge.
   int unavailable_px_at_top = frame_->IsMaximized() ?
       frame_thickness : kTitlebarTopAndBottomEdgeThickness;
   // When the icon is shorter than the minimum space we reserve for the caption
   // button, we vertically center it.  We want to bias rounding to put extra
   // space above the icon, since the 3D edge (+ client edge, for restored
   // windows) below looks (to the eye) more like additional space than does the
   // 3D edge (or nothing at all, for maximized windows) above; hence the +1.
   int y = unavailable_px_at_top + (NonClientTopBorderHeight() -
       unavailable_px_at_top - size - TitlebarBottomThickness() + 1) / 2;
-  return gfx::Rect(frame_thickness + kIconLeftSpacing, y, size, size);
+  return gfx::Rect(frame_thickness + kIconLeftSpacing + minimum_title_bar_x_,
+                   y, size, size);
 }
 
 bool CustomFrameView::ShouldShowTitleBarAndBorder() const {
   if (frame_->IsFullscreen())
     return false;
 
   if (ViewsDelegate::views_delegate) {
     return !ViewsDelegate::views_delegate->WindowManagerProvidesTitleBar(
                 frame_->IsMaximized());
   }
@@ skipping 133 matching lines @@
 SkColor CustomFrameView::GetFrameColor() const {
   return frame_->IsActive() ? kDefaultColorFrame : kDefaultColorFrameInactive;
 }
 
 const gfx::ImageSkia* CustomFrameView::GetFrameImage() const {
   return ui::ResourceBundle::GetSharedInstance().GetImageNamed(
       frame_->IsActive() ? IDR_FRAME : IDR_FRAME_INACTIVE).ToImageSkia();
 }
 
 void CustomFrameView::LayoutWindowControls() {
-  close_button_->SetImageAlignment(ImageButton::ALIGN_LEFT,
-                                   ImageButton::ALIGN_BOTTOM);
+  minimum_title_bar_x_ = 0;
+  maximum_title_bar_x_ = width();
+
+  if (bounds().IsEmpty())
+    return;
+
   int caption_y = CaptionButtonY();
   bool is_maximized = frame_->IsMaximized();
   // There should always be the same number of non-shadow pixels visible to the
-  // side of the caption buttons.  In maximized mode we extend the rightmost
-  // button to the screen corner to obey Fitts' Law.
-  int right_extra_width = is_maximized ?
+  // side of the caption buttons.  In maximized mode we extend the edge button
+  // to the screen corner to obey Fitts' Law.
+  int extra_width = is_maximized ?
       (kFrameBorderThickness - kFrameShadowThickness) : 0;
-  gfx::Size close_button_size = close_button_->GetPreferredSize();
-  close_button_->SetBounds(width() - FrameBorderThickness() -
-      right_extra_width - close_button_size.width(), caption_y,
-      close_button_size.width() + right_extra_width,
-      close_button_size.height());
+  int next_button_x = FrameBorderThickness();
 
-  // When the window is restored, we show a maximized button; otherwise, we show
-  // a restore button.
   bool is_restored = !is_maximized && !frame_->IsMinimized();
   ImageButton* invisible_button = is_restored ? restore_button_
                                               : maximize_button_;
   invisible_button->SetVisible(false);
 
-  ImageButton* visible_button = is_restored ? maximize_button_
-                                            : restore_button_;
-  FramePartImage normal_part, hot_part, pushed_part;
-  int next_button_x;
-  if (should_show_maximize_button_) {
-    visible_button->SetVisible(true);
-    visible_button->SetImageAlignment(ImageButton::ALIGN_LEFT,
-                                      ImageButton::ALIGN_BOTTOM);
-    gfx::Size visible_button_size = visible_button->GetPreferredSize();
-    visible_button->SetBounds(close_button_->x() - visible_button_size.width(),
-                              caption_y, visible_button_size.width(),
-                              visible_button_size.height());
-    next_button_x = visible_button->x();
-  } else {
-    visible_button->SetVisible(false);
-    next_button_x = close_button_->x();
+  WindowButtonOrderProvider* button_order =
+      WindowButtonOrderProvider::GetInstance();
+  const std::vector<views::FrameButton>& leading_buttons =
+      button_order->leading_buttons();
+  const std::vector<views::FrameButton>& trailing_buttons =
+      button_order->trailing_buttons();
+
+  ImageButton* button = NULL;
+  for (std::vector<views::FrameButton>::const_iterator it =
+           leading_buttons.begin(); it != leading_buttons.end(); ++it) {
+    button = GetImageButton(*it);
+    if (!button)
+      continue;
+    gfx::Rect target_bounds(gfx::Point(next_button_x, caption_y),
+                            button->GetPreferredSize());
+    if (it == leading_buttons.begin())
+      target_bounds.set_width(target_bounds.width() + extra_width);
+    LayoutButton(button, target_bounds);
+    next_button_x += button->width();
+    minimum_title_bar_x_ = std::min(width(), next_button_x);
   }
 
-  minimize_button_->SetVisible(true);
-  minimize_button_->SetImageAlignment(ImageButton::ALIGN_LEFT,
-                                      ImageButton::ALIGN_BOTTOM);
-  gfx::Size minimize_button_size = minimize_button_->GetPreferredSize();
-  minimize_button_->SetBounds(
-      next_button_x - minimize_button_size.width(), caption_y,
-      minimize_button_size.width(),
-      minimize_button_size.height());
-
-  normal_part = IDR_CLOSE;
-  hot_part = IDR_CLOSE_H;
-  pushed_part = IDR_CLOSE_P;
-
-  ui::ResourceBundle& rb = ui::ResourceBundle::GetSharedInstance();
-
-  close_button_->SetImage(CustomButton::STATE_NORMAL,
-                          rb.GetImageNamed(normal_part).ToImageSkia());
-  close_button_->SetImage(CustomButton::STATE_HOVERED,
-                          rb.GetImageNamed(hot_part).ToImageSkia());
-  close_button_->SetImage(CustomButton::STATE_PRESSED,
-                          rb.GetImageNamed(pushed_part).ToImageSkia());
+  // Trailing buttions are laid out in a RTL fashion
+  next_button_x = width() - FrameBorderThickness();
+  for (std::vector<views::FrameButton>::const_reverse_iterator it =
+           trailing_buttons.rbegin(); it != trailing_buttons.rend(); ++it) {
+    button = GetImageButton(*it);
+    if (!button)
+      continue;
+    gfx::Rect target_bounds(gfx::Point(next_button_x, caption_y),
+                            button->GetPreferredSize());
+    if (it == trailing_buttons.rbegin())
+      target_bounds.set_width(target_bounds.width() + extra_width);
+    target_bounds.Offset(-target_bounds.width(), 0);
+    LayoutButton(button, target_bounds);
+    next_button_x = button->x();
+    maximum_title_bar_x_ = std::max(minimum_title_bar_x_, next_button_x);
+  }
 }
 
 void CustomFrameView::LayoutTitleBar() {
+  DCHECK_GE(maximum_title_bar_x_, 0);
   // The window title position is calculated based on the icon position, even
   // when there is no icon.
   gfx::Rect icon_bounds(IconBounds());
   bool show_window_icon = window_icon_ != NULL;
   if (show_window_icon)
     window_icon_->SetBoundsRect(icon_bounds);
 
   if (!frame_->widget_delegate()->ShouldShowWindowTitle())
     return;
 
   // The offset between the window left edge and the title text.
   int title_x = show_window_icon ? icon_bounds.right() + kTitleIconOffsetX
                                  : icon_bounds.x();
   int title_height = GetTitleFontList().GetHeight();
   // We bias the title position so that when the difference between the icon and
   // title heights is odd, the extra pixel of the title is above the vertical
   // midline rather than below.  This compensates for how the icon is already
   // biased downwards (see IconBounds()) and helps prevent descenders on the
   // title from overlapping the 3D edge at the bottom of the titlebar.
   title_bounds_.SetRect(title_x,
       icon_bounds.y() + ((icon_bounds.height() - title_height - 1) / 2),
-      std::max(0, minimize_button_->x() - kTitleCaptionSpacing -
+      std::max(0, maximum_title_bar_x_ - kTitleCaptionSpacing -
       title_x), title_height);
 }
 
 void CustomFrameView::LayoutClientView() {
   if (!ShouldShowTitleBarAndBorder()) {
     client_view_bounds_ = bounds();
     return;
   }
 
   int top_height = NonClientTopBorderHeight();
@@ skipping 14 matching lines @@
   button->SetImage(CustomButton::STATE_NORMAL,
                    rb.GetImageNamed(normal_image_id).ToImageSkia());
   button->SetImage(CustomButton::STATE_HOVERED,
                    rb.GetImageNamed(hot_image_id).ToImageSkia());
   button->SetImage(CustomButton::STATE_PRESSED,
                    rb.GetImageNamed(pushed_image_id).ToImageSkia());
   AddChildView(button);
   return button;
 }
 
+ImageButton* CustomFrameView::GetImageButton(views::FrameButton frame_button) {
+  ImageButton* button = NULL;
+  switch (frame_button) {
+    case views::FRAME_BUTTON_MINIMIZE: {
+      button = minimize_button_;
+      break;
+    }
+    case views::FRAME_BUTTON_MAXIMIZE: {
+      bool is_restored = !frame_->IsMaximized() && !frame_->IsMinimized();
+      button = is_restored ? maximize_button_ : restore_button_;
+      if (!should_show_maximize_button_) {
+        // If we should not show the maximize/restore button, then we return
+        // NULL as we don't want this button to become visible and to be laid
+        // out.
+        button->SetVisible(false);
+        return NULL;
+      }
+      break;
+    }
+    case views::FRAME_BUTTON_CLOSE: {
+      button = close_button_;
+      break;
+    }
+  }
+  return button;
+}
+
 }  // namespace views