Merge 130064 - Changes the maximize button to only minimize for panels. This resulted

ash/wm/frame_painter.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 "ash/wm/frame_painter.h"
 
 #include "ash/shell.h"
 #include "ash/shell_window_ids.h"
 #include "ash/wm/window_util.h"
 #include "base/logging.h"  // DCHECK
@@ skipping 115 matching lines @@
 int FramePainter::kInactiveWindowOpacity = 166;
 int FramePainter::kSoloWindowOpacity = 230;
 std::set<FramePainter*>* FramePainter::instances_ = NULL;
 
 ///////////////////////////////////////////////////////////////////////////////
 // FramePainter, public:
 
 FramePainter::FramePainter()
     : frame_(NULL),
       window_icon_(NULL),
-      maximize_button_(NULL),
+      size_button_(NULL),
       close_button_(NULL),
       window_(NULL),
       button_separator_(NULL),
       top_left_corner_(NULL),
       top_edge_(NULL),
       top_right_corner_(NULL),
       header_left_edge_(NULL),
       header_right_edge_(NULL),
       previous_theme_frame_(NULL),
       previous_opacity_(0),
       crossfade_theme_frame_(NULL),
       crossfade_opacity_(0),
-      crossfade_animation_(NULL) {
+      crossfade_animation_(NULL),
+      size_button_behavior_(SIZE_BUTTON_MAXIMIZES) {
   if (!instances_)
     instances_ = new std::set<FramePainter*>();
   instances_->insert(this);
 }
 
 FramePainter::~FramePainter() {
   // Sometimes we are destroyed before the window closes, so ensure we clean up.
   if (window_)
     window_->RemoveObserver(this);
   instances_->erase(this);
 }
 
 void FramePainter::Init(views::Widget* frame,
                         views::View* window_icon,
                         views::ImageButton* maximize_button,
-                        views::ImageButton* close_button) {
+                        views::ImageButton* close_button,
+                        SizeButtonBehavior behavior) {
   DCHECK(frame);
   // window_icon may be NULL.
   DCHECK(maximize_button);
   DCHECK(close_button);
   frame_ = frame;
   window_icon_ = window_icon;
-  maximize_button_ = maximize_button;
+  size_button_ = maximize_button;
   close_button_ = close_button;
+  size_button_behavior_ = behavior;
 
   // Window frame image parts.
   ui::ResourceBundle& rb = ui::ResourceBundle::GetSharedInstance();
   button_separator_ =
       rb.GetImageNamed(IDR_AURA_WINDOW_BUTTON_SEPARATOR).ToSkBitmap();
   top_left_corner_ =
       rb.GetImageNamed(IDR_AURA_WINDOW_HEADER_SHADE_TOP_LEFT).ToSkBitmap();
   top_edge_ =
       rb.GetImageNamed(IDR_AURA_WINDOW_HEADER_SHADE_TOP).ToSkBitmap();
   top_right_corner_ =
@@ skipping 67 matching lines @@
     return frame_component;
 
   int client_component = frame_->client_view()->NonClientHitTest(point);
   if (client_component != HTNOWHERE)
     return client_component;
 
   // Then see if the point is within any of the window controls.
   if (close_button_->visible() &&
       close_button_->GetMirroredBounds().Contains(point))
     return HTCLOSE;
-  if (maximize_button_->visible() &&
-      maximize_button_->GetMirroredBounds().Contains(point))
+  if (size_button_->visible() &&
+      size_button_->GetMirroredBounds().Contains(point))
     return HTMAXBUTTON;
 
   // Caption is a safe default.
   return HTCAPTION;
 }
 
 gfx::Size FramePainter::GetMinimumSize(views::NonClientFrameView* view) {
   gfx::Size min_size = frame_->client_view()->GetMinimumSize();
   // Ensure we can display the top of the caption area.
   gfx::Rect client_bounds = view->GetBoundsForClientView();
   min_size.Enlarge(0, client_bounds.y());
   // Ensure we have enough space for the window icon and buttons.  We allow
   // the title string to collapse to zero width.
   int title_width = GetTitleOffsetX() +
-      maximize_button_->width() +
+      size_button_->width() +
       button_separator_->width() +
       close_button_->width();
   if (title_width > min_size.width())
     min_size.set_width(title_width);
   return min_size;
 }
 
 void FramePainter::PaintHeader(views::NonClientFrameView* view,
                                gfx::Canvas* canvas,
                                HeaderMode header_mode,
@@ skipping 115 matching lines @@
 void FramePainter::PaintTitleBar(views::NonClientFrameView* view,
                                  gfx::Canvas* canvas,
                                  const gfx::Font& title_font) {
   // The window icon is painted by its own views::View.
   views::WidgetDelegate* delegate = frame_->widget_delegate();
   if (delegate && delegate->ShouldShowWindowTitle()) {
     int title_x = GetTitleOffsetX();
     gfx::Rect title_bounds(
         title_x,
         kTitleOffsetY,
-        std::max(0, maximize_button_->x() - kTitleLogoSpacing - title_x),
+        std::max(0, size_button_->x() - kTitleLogoSpacing - title_x),
         title_font.GetHeight());
     canvas->DrawStringInt(delegate->GetWindowTitle(),
                           title_font,
                           kTitleTextColor,
                           view->GetMirroredXForRect(title_bounds),
                           title_bounds.y(),
                           title_bounds.width(),
                           title_bounds.height(),
                           gfx::Canvas::NO_SUBPIXEL_RENDERING);
   }
 }
 
 void FramePainter::LayoutHeader(views::NonClientFrameView* view,
                                 bool maximized_layout) {
   // The maximized layout uses shorter buttons.
   if (maximized_layout) {
     SetButtonImages(close_button_,
                     IDR_AURA_WINDOW_MAXIMIZED_CLOSE,
                     IDR_AURA_WINDOW_MAXIMIZED_CLOSE_H,
                     IDR_AURA_WINDOW_MAXIMIZED_CLOSE_P);
-    SetButtonImages(maximize_button_,
+    // TODO: need images for SIZE_BUTTON_MINIMIZES.
+    SetButtonImages(size_button_,
                     IDR_AURA_WINDOW_MAXIMIZED_RESTORE,
                     IDR_AURA_WINDOW_MAXIMIZED_RESTORE_H,
                     IDR_AURA_WINDOW_MAXIMIZED_RESTORE_P);
   } else {
     SetButtonImages(close_button_,
                     IDR_AURA_WINDOW_CLOSE,
                     IDR_AURA_WINDOW_CLOSE_H,
                     IDR_AURA_WINDOW_CLOSE_P);
-    SetButtonImages(maximize_button_,
+    // TODO: need images for SIZE_BUTTON_MINIMIZES.
+    SetButtonImages(size_button_,
                     IDR_AURA_WINDOW_MAXIMIZE,
                     IDR_AURA_WINDOW_MAXIMIZE_H,
                     IDR_AURA_WINDOW_MAXIMIZE_P);
   }
 
   gfx::Size close_size = close_button_->GetPreferredSize();
   close_button_->SetBounds(
       view->width() - close_size.width() - kCloseButtonOffsetX,
       kCloseButtonOffsetY,
       close_size.width(),
       close_size.height());
 
-  gfx::Size maximize_size = maximize_button_->GetPreferredSize();
-  maximize_button_->SetBounds(
-      close_button_->x() - button_separator_->width() - maximize_size.width(),
+  gfx::Size size_button_size = size_button_->GetPreferredSize();
+  size_button_->SetBounds(
+      close_button_->x() - button_separator_->width() -
+          size_button_size.width(),
       close_button_->y(),
-      maximize_size.width(),
-      maximize_size.height());
+      size_button_size.width(),
+      size_button_size.height());
 
   if (window_icon_)
     window_icon_->SetBoundsRect(
         gfx::Rect(kIconOffsetX, kIconOffsetY, kIconSize, kIconSize));
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 // aura::WindowObserver overrides:
 
 void FramePainter::OnWindowPropertyChanged(aura::Window* window,
@@ skipping 84 matching lines @@
     if (*it != ignore && IsVisibleNormalWindow(*it)) {
       normal_window_count++;
       if (normal_window_count > 1)
         return false;
     }
   }
   return normal_window_count == 1;
 }
 
 }  // namespace ash