Support minimizing the panel into 3-pixel line on Windows. Also support bringing up/down the titl...

chrome/browser/ui/panels/panel_browser_view.cc

 // Copyright (c) 2011 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/ui/panels/panel_browser_view.h"
 
 #include "base/logging.h"
 #include "chrome/browser/ui/panels/panel.h"
 #include "chrome/browser/ui/panels/panel_browser_frame_view.h"
 #include "chrome/browser/ui/panels/panel_manager.h"
+#include "chrome/browser/ui/panels/panel_mouse_watcher_win.h"
 #include "chrome/browser/ui/views/frame/browser_frame.h"
 #include "grit/chromium_strings.h"
 #include "ui/base/animation/slide_animation.h"
 #include "ui/base/l10n/l10n_util.h"
 #include "views/widget/widget.h"
 
 namespace {
 // This value is experimental and subjective.
 const int kSetBoundsAnimationMs = 200;
+
+// The panel can be fully minimized to 3-pixel lines.
+const int kFullyMinimizedHeight = 3;
 }
 
 NativePanel* Panel::CreateNativePanel(Browser* browser, Panel* panel,
                                       const gfx::Rect& bounds) {
   PanelBrowserView* view = new PanelBrowserView(browser, panel, bounds);
   (new BrowserFrame(view))->InitBrowserFrame();
   return view;
 }
 
 PanelBrowserView::PanelBrowserView(Browser* browser, Panel* panel,
                                    const gfx::Rect& bounds)
   : BrowserView(browser),
     panel_(panel),
     bounds_(bounds),
     original_height_(bounds.height()),
-    minimized_(false),
     closed_(false),
     focused_(false),
     mouse_pressed_(false),
     mouse_dragging_(false) {
 }
 
 PanelBrowserView::~PanelBrowserView() {
 }
 
 void PanelBrowserView::Init() {
   BrowserView::Init();
 
   GetWidget()->SetAlwaysOnTop(true);
   GetWidget()->non_client_view()->SetAccessibleName(
       l10n_util::GetStringUTF16(IDS_PRODUCT_NAME));
 }
 
 void PanelBrowserView::Close() {
   closed_ = true;
 
   // Cancel any currently running animation since we're closing down.
   if (bounds_animator_.get())
     bounds_animator_.reset();
 
   ::BrowserView::Close();
+
+  // Stop the global mouse watcher only if we do not have any panels up.
+  if (panel_->manager()->active_count() == 1)
+    StopMouseWatcher();
 }
 
 void PanelBrowserView::SetBounds(const gfx::Rect& bounds) {
   bounds_ = bounds;
 
   // No animation if the panel is being dragged.
   if (mouse_dragging_) {
     ::BrowserView::SetBounds(bounds);
     return;
   }
@@ skipping 78 matching lines @@
 }
 
 gfx::Rect PanelBrowserView::GetPanelBounds() const {
   return bounds_;
 }
 
 void PanelBrowserView::SetPanelBounds(const gfx::Rect& bounds) {
   SetBounds(bounds);
 }
 
-void PanelBrowserView::MinimizePanel() {
-  if (minimized_)
-    return;
+void PanelBrowserView::OnPanelExpansionStateChanged(
+    Panel::ExpansionState expansion_state) {
+  int height;
+  switch (expansion_state) {
+    case Panel::EXPANDED:
+      height = original_height_;
+      break;
+    case Panel::TITLE_ONLY:
+      height = GetFrameView()->NonClientTopBorderHeight();
+      break;
+    case Panel::MINIMIZED:
+      height = kFullyMinimizedHeight;
+      EnsureMouseWatcherStarted();
+      break;
+    default:
+      NOTREACHED();
+      height = original_height_;
+      break;
+  }
 
-  minimized_ = true;
-  gfx::Rect bounds = GetPanelBounds();
-  original_height_ = bounds.height();
-  bounds.set_height(GetFrameView()->NonClientTopBorderHeight());
-  bounds.set_y(bounds.y() + original_height_ - bounds.height());
-  SetPanelBounds(bounds);
+  gfx::Rect bounds = bounds_;
+  bounds.set_y(bounds.y() + bounds.height() - height);
+  bounds.set_height(height);
+  SetBounds(bounds);
 }
 
-void PanelBrowserView::RestorePanel() {
-  if (!minimized_)
-    return;
-
-  minimized_ = false;
-  gfx::Rect bounds = GetPanelBounds();
-  bounds.set_y(bounds.y() - original_height_ + bounds.height());
-  bounds.set_height(original_height_);
-  SetPanelBounds(bounds);
+bool PanelBrowserView::ShouldBringUpPanelTitleBar(int mouse_x,
+                                                  int mouse_y) const {
+  return bounds_.x() <= mouse_x && mouse_x <= bounds_.right() &&
+         mouse_y >= bounds_.y();
 }
 
 void PanelBrowserView::ClosePanel() {
   Close();
 }
 
 void PanelBrowserView::ActivatePanel() {
   Activate();
 }
 
@@ skipping 54 matching lines @@
   }
   if (mouse_dragging_)
     panel_->manager()->Drag(delta_x);
   return true;
 }
 
 bool PanelBrowserView::OnTitleBarMouseReleased(const views::MouseEvent& event) {
   if (mouse_dragging_)
     return EndDragging(false);
 
-  MinimizeOrRestore();
+  Panel::ExpansionState new_expansion_state =
+    (panel_->expansion_state() != Panel::EXPANDED) ? Panel::EXPANDED
+                                                   : Panel::MINIMIZED;
+  panel_->SetExpansionState(new_expansion_state);
   return true;
 }
 
 bool PanelBrowserView::OnTitleBarMouseCaptureLost() {
   return EndDragging(true);
 }
 
 bool PanelBrowserView::EndDragging(bool cancelled) {
   // Only handle clicks that started in our window.
   if (!mouse_pressed_)
     return false;
   mouse_pressed_ = false;
 
   if (!mouse_dragging_)
     cancelled = true;
   mouse_dragging_ = false;
   panel_->manager()->EndDragging(cancelled);
   return true;
 }
-
-void PanelBrowserView::MinimizeOrRestore() {
-  if (minimized_)
-    panel_->Restore();
-  else
-    panel_->Minimize();
-}