Use white header for app windows part #2

ash/wm/caption_buttons/frame_caption_button_container_view.cc

 // Copyright 2013 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/caption_buttons/frame_caption_button_container_view.h"
 
 #include "ash/ash_switches.h"
 #include "ash/metrics/user_metrics_recorder.h"
 #include "ash/shell.h"
 #include "ash/wm/caption_buttons/alternate_frame_size_button.h"
 #include "ash/wm/caption_buttons/frame_caption_button.h"
 #include "ash/wm/caption_buttons/frame_maximize_button.h"
-#include "grit/ash_resources.h"
 #include "grit/ui_strings.h"  // Accessibility names
 #include "ui/base/hit_test.h"
 #include "ui/base/l10n/l10n_util.h"
-#include "ui/base/resource/resource_bundle.h"
 #include "ui/compositor/scoped_animation_duration_scale_mode.h"
 #include "ui/gfx/canvas.h"
 #include "ui/gfx/insets.h"
 #include "ui/gfx/point.h"
 #include "ui/views/widget/widget.h"
 #include "ui/views/widget/widget_delegate.h"
 
 namespace ash {
 
 namespace {
 
-// The distance between buttons.
-const int kDistanceBetweenButtons = -1;

[James Cook, 2014/02/03 18:46:35]

Hooray, no more crazy overlap constant!

-
 // Converts |point| from |src| to |dst| and hittests against |dst|.
 bool ConvertPointToViewAndHitTest(const views::View* src,
                                   const views::View* dst,
                                   const gfx::Point& point) {
   gfx::Point converted(point);
   views::View::ConvertPointToTarget(src, dst, &converted);
   return dst->HitTestPoint(converted);
 }
 
 }  // namespace
@@ skipping 28 matching lines @@
     size_button_ = new FrameMaximizeButton(this, frame);
   size_button_->SetAccessibleName(
       l10n_util::GetStringUTF16(IDS_APP_ACCNAME_MAXIMIZE));
   size_button_->SetVisible(frame_->widget_delegate()->CanMaximize());
   AddChildView(size_button_);
 
   close_button_ = new FrameCaptionButton(this, CAPTION_BUTTON_ICON_CLOSE);
   close_button_->SetAccessibleName(
       l10n_util::GetStringUTF16(IDS_APP_ACCNAME_CLOSE));
   AddChildView(close_button_);
-
-  button_separator_ = ui::ResourceBundle::GetSharedInstance().GetImageNamed(
-      IDR_AURA_WINDOW_BUTTON_SEPARATOR).AsImageSkia();
 }
 
 FrameCaptionButtonContainerView::~FrameCaptionButtonContainerView() {
 }
 
 FrameMaximizeButton*
 FrameCaptionButtonContainerView::GetOldStyleSizeButton() {
   return switches::UseAlternateFrameCaptionButtonStyle() ?
       NULL : static_cast<FrameMaximizeButton*>(size_button_);
 }
 
-void FrameCaptionButtonContainerView::SetButtonImages(CaptionButtonIcon icon,
-                                                      int normal_image_id,
-                                                      int hovered_image_id,
-                                                      int pressed_image_id) {
-  button_icon_id_map_[icon] = ButtonIconIds(normal_image_id,
-                                            hovered_image_id,
-                                            pressed_image_id);
+void FrameCaptionButtonContainerView::SetButtonImages(
+    CaptionButtonIcon icon,
+    int icon_image_id,
+    int inactive_icon_image_id,
+    int hovered_background_image_id,
+    int pressed_background_image_id) {
+  button_icon_id_map_[icon] = ButtonIconIds(icon_image_id,
+                                            inactive_icon_image_id,
+                                            hovered_background_image_id,
+                                            pressed_background_image_id);
   FrameCaptionButton* buttons[] = {
     minimize_button_, size_button_, close_button_
   };
   for (size_t i = 0; i < arraysize(buttons); ++i) {
     if (buttons[i]->icon() == icon) {
       buttons[i]->SetImages(icon,
                             FrameCaptionButton::ANIMATE_NO,
-                            normal_image_id,
-                            hovered_image_id,
-                            pressed_image_id);
+                            icon_image_id,
+                            inactive_icon_image_id,
+                            hovered_background_image_id,
+                            pressed_background_image_id);
     }
   }
 }
 
+void FrameCaptionButtonContainerView::SetPaintAsActive(bool paint_as_active) {
+  minimize_button_->set_paint_as_active(paint_as_active);
+  size_button_->set_paint_as_active(paint_as_active);
+  close_button_->set_paint_as_active(paint_as_active);
+}
+
 void FrameCaptionButtonContainerView::ResetWindowControls() {
   SetButtonsToNormal(ANIMATE_NO);
 }
 
 int FrameCaptionButtonContainerView::NonClientHitTest(
     const gfx::Point& point) const {
   if (close_button_->visible() &&
       ConvertPointToViewAndHitTest(this, close_button_, point)) {
     return HTCLOSE;
   } else if (size_button_->visible() &&
              ConvertPointToViewAndHitTest(this, size_button_, point)) {
     return HTMAXBUTTON;
   } else if (minimize_button_->visible() &&
              ConvertPointToViewAndHitTest(this, minimize_button_, point)) {
     return HTMINBUTTON;
   }
   return HTNOWHERE;
 }
 
 gfx::Size FrameCaptionButtonContainerView::GetPreferredSize() {
   int width = 0;
-  bool first_visible = true;
   for (int i = 0; i < child_count(); ++i) {
     views::View* child = child_at(i);
-    if (!child->visible())
-      continue;
-
-    width += child_at(i)->GetPreferredSize().width();
-    if (!first_visible)
-      width += kDistanceBetweenButtons;
-    first_visible = false;
+    if (child->visible())
+      width += child_at(i)->GetPreferredSize().width();
   }
   return gfx::Size(width, close_button_->GetPreferredSize().height());
 }
 
 void FrameCaptionButtonContainerView::Layout() {
   int x = 0;
   for (int i = 0; i < child_count(); ++i) {
     views::View* child = child_at(i);
     if (!child->visible())
       continue;
 
     gfx::Size size = child->GetPreferredSize();
     child->SetBounds(x, 0, size.width(), size.height());
-    x += size.width() + kDistanceBetweenButtons;
+    x += size.width();
   }
 }
 
 const char* FrameCaptionButtonContainerView::GetClassName() const {
   return kViewClassName;
 }
 
-void FrameCaptionButtonContainerView::OnPaint(gfx::Canvas* canvas) {
-  views::View::OnPaint(canvas);
-
-  // The alternate button style does not paint the button separator.
-  if (!switches::UseAlternateFrameCaptionButtonStyle()) {
-    // We should have at most two visible buttons. The button separator is
-    // always painted underneath the close button regardless of whether a
-    // button other than the close button is visible.
-    gfx::Rect divider(close_button_->bounds().origin(),
-                      button_separator_.size());
-    canvas->DrawImageInt(button_separator_,
-                         GetMirroredXForRect(divider),
-                         divider.y());
-  }
-}
-
 void FrameCaptionButtonContainerView::SetButtonIcon(FrameCaptionButton* button,
                                                     CaptionButtonIcon icon,
                                                     Animate animate) {
   if (button->icon() == icon &&
       (animate == ANIMATE_YES || !button->is_animating_image_swap())) {
     return;
   }
 
   FrameCaptionButton::Animate fcb_animate = (animate == ANIMATE_YES) ?
       FrameCaptionButton::ANIMATE_YES : FrameCaptionButton::ANIMATE_NO;
   std::map<CaptionButtonIcon, ButtonIconIds>::const_iterator it =
       button_icon_id_map_.find(icon);
   if (it != button_icon_id_map_.end()) {
     button->SetImages(icon,
                       fcb_animate,
-                      it->second.normal_image_id,
-                      it->second.hovered_image_id,
-                      it->second.pressed_image_id);
+                      it->second.icon_image_id,
+                      it->second.inactive_icon_image_id,
+                      it->second.hovered_background_image_id,
+                      it->second.pressed_background_image_id);
   }
 }
 
 void FrameCaptionButtonContainerView::ButtonPressed(views::Button* sender,
                                                     const ui::Event& event) {
   // When shift-clicking, slow down animations for visual debugging.
   // We used to do this via an event filter that looked for the shift key being
   // pressed but this interfered with several normal keyboard shortcuts.
   scoped_ptr<ui::ScopedAnimationDurationScaleMode> slow_duration_mode;
   if (event.IsShiftDown()) {
@@ skipping 65 matching lines @@
     if (!button->visible())
       continue;
 
     if (button->state() == views::Button::STATE_PRESSED) {
       gfx::Rect expanded_bounds = button->bounds();
       expanded_bounds.Inset(pressed_hittest_outer_insets);
       if (expanded_bounds.Contains(position)) {
         pressed_button = button;
         // Do not break in order to give preference to buttons which are
         // closer to |position_in_screen| than the currently pressed button.
-        // TODO(pkotwicz): Make the caption buttons not overlap.
       }
     } else if (ConvertPointToViewAndHitTest(this, button, position)) {
       pressed_button = button;
       break;
     }
   }
 
   for (size_t i = 0; i < arraysize(buttons); ++i) {
     buttons[i]->SetState(buttons[i] == pressed_button ?
         views::Button::STATE_PRESSED : views::Button::STATE_NORMAL);
   }
   return pressed_button;
 }
 
 FrameCaptionButtonContainerView::ButtonIconIds::ButtonIconIds()
-    : normal_image_id(-1),
-      hovered_image_id(-1),
-      pressed_image_id(-1) {
+    : icon_image_id(-1),
+      inactive_icon_image_id(-1),
+      hovered_background_image_id(-1),
+      pressed_background_image_id(-1) {
 }
 
-FrameCaptionButtonContainerView::ButtonIconIds::ButtonIconIds(int normal_id,
-                                                              int hovered_id,
-                                                              int pressed_id)
-    : normal_image_id(normal_id),
-      hovered_image_id(hovered_id),
-      pressed_image_id(pressed_id) {
+FrameCaptionButtonContainerView::ButtonIconIds::ButtonIconIds(
+    int icon_id,
+    int inactive_icon_id,
+    int hovered_background_id,
+    int pressed_background_id)
+    : icon_image_id(icon_id),
+      inactive_icon_image_id(inactive_icon_id),
+      hovered_background_image_id(hovered_background_id),
+      pressed_background_image_id(pressed_background_id) {
 }
 
 FrameCaptionButtonContainerView::ButtonIconIds::~ButtonIconIds() {
 }
 
 }  // namespace ash