Support auto-hide taskbar for panels on Windows.

chrome/browser/ui/panels/panel_manager.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_manager.h"
 
 #include <algorithm>
 
 #include "base/logging.h"
 #include "base/memory/scoped_ptr.h"
 #include "chrome/browser/ui/browser.h"
+#include "chrome/browser/ui/panels/bottom_bar.h"
 #include "chrome/browser/ui/window_sizer.h"
 
 namespace {
 // Invalid panel index.
 const size_t kInvalidPanelIndex = static_cast<size_t>(-1);
 
 // Minimum width and height of a panel.
 const int kPanelMinWidthPixels = 64;
 const int kPanelMinHeightPixels = 24;
 
 // Default width and height of a panel.
 const int kPanelDefaultWidthPixels = 240;
 const int kPanelDefaultHeightPixels = 290;
 
 // Maxmium width and height of a panel based on the factor of the working
 // area.
 const double kPanelMaxWidthFactor = 1.0;
 const double kPanelMaxHeightFactor = 0.5;
 
 // Horizontal spacing between two panels.
 const int kPanelsHorizontalSpacing = 4;
 
+// The polling interval to check if auto-hide bottom bar becomes visible or
+// hidden so that we can bring up/down panels' titlebar.
+const int kBottomBarCheckPollingIntervalMs = 50;
+
 // Single instance of PanelManager.
 scoped_ptr<PanelManager> panel_instance;
 }  // namespace
 
 // static
 PanelManager* PanelManager::GetInstance() {
   if (!panel_instance.get()) {
     panel_instance.reset(new PanelManager());
   }
   return panel_instance.get();
 }
 
 PanelManager::PanelManager()
-    : max_width_(0),
+    : auto_hide_bottom_bar_height_(0),
+      max_width_(0),
       max_height_(0),
-      min_x_(0),
       current_x_(0),
-      bottom_edge_y_(0),
       dragging_panel_index_(kInvalidPanelIndex),
-      dragging_panel_original_x_(0) {
+      dragging_panel_original_x_(0),
+      should_check_auto_hide_bottom_bar_on_titlebar_change_(true) {
   OnDisplayChanged();
 }
 
 PanelManager::~PanelManager() {
   DCHECK(panels_.empty());
   DCHECK(panels_pending_to_remove_.empty());
 }
 
 void PanelManager::OnDisplayChanged() {
   scoped_ptr<WindowSizer::MonitorInfoProvider> info_provider(
       WindowSizer::CreateDefaultMonitorInfoProvider());
-  SetWorkArea(info_provider->GetPrimaryMonitorWorkArea());
+  gfx::Rect work_area = info_provider->GetPrimaryMonitorWorkArea();
+
+  int auto_hide_bottom_bar_height =
+      IsBottomBarInAutoHideMode() ? GetBottomBarHeight() : 0;
+
+  SetWorkArea(work_area, auto_hide_bottom_bar_height);
 }
 
-void PanelManager::SetWorkArea(const gfx::Rect& work_area) {
-  if (work_area == work_area_)
+void PanelManager::SetWorkArea(const gfx::Rect& work_area,
+                               int auto_hide_bottom_bar_height) {
+  if (work_area == work_area_ &&
+      auto_hide_bottom_bar_height == auto_hide_bottom_bar_height_)
     return;
   work_area_ = work_area;
+  auto_hide_bottom_bar_height_ = auto_hide_bottom_bar_height;
 
-  min_x_ = work_area.x();
   current_x_ = work_area.right();
-  bottom_edge_y_ = work_area.bottom();
   max_width_ = static_cast<int>(work_area.width() * kPanelMaxWidthFactor);
   max_height_ = static_cast<int>(work_area.height() * kPanelMaxHeightFactor);
 
   Rearrange(panels_.begin());
 }
 
 void PanelManager::FindAndClosePanelOnOverflow(const Extension* extension) {
   Panel* panel_to_close = NULL;
 
   // Try to find the left-most panel invoked from the same extension and close
@@ skipping 180 matching lines @@
         dragging_panel_bounds_);
   }
 
   dragging_panel_index_ = kInvalidPanelIndex;
 
   DelayedRemove();
 }
 
 bool PanelManager::ShouldBringUpTitleBarForAllMinimizedPanels(
     int mouse_x, int mouse_y) const {
+  // We should always bring up the title-bar if the mouse is over the auto-hide
+  // task-bar that becomes visible.
+  if (auto_hide_bottom_bar_height_ &&
+      mouse_y >= work_area_.bottom() - auto_hide_bottom_bar_height_ &&
+      IsBottomBarFullyVisible())
+    return true;
+
   for (Panels::const_iterator iter = panels_.begin();
        iter != panels_.end(); ++iter) {
     if ((*iter)->ShouldBringUpTitleBar(mouse_x, mouse_y))
       return true;
   }
   return false;
 }
 
-void PanelManager::BringUpOrDownTitleBarForAllMinimizedPanels(bool bring_up) {
+void PanelManager::BringUpTitleBar() {
+  // If the bottom-bar is in auto-hide mode, delay the bring-up action until
+  // it is fully visible. We do not want both bottom bar and panel titlebar
+  // to pop up at the same time but with different speed.
+  if (!auto_hide_bottom_bar_height_ ||
+      !should_check_auto_hide_bottom_bar_on_titlebar_change_ ||
+      IsBottomBarFullyVisible()) {
+    bring_up_or_down_titlebar_timer_.Stop();

[Dmitry Titov, 2011/08/17 22:56:38]

It seems that this code actually wants to receive an event or a notification
about bottom bar changing state. The timer is an implementation detail. Perhaps
we can make BottomBar class to source these events/notificaitons. Perhaps they
can be sourced differently on different platforms.

[jianli, 2011/08/22 20:44:42]

Done.

+    DoBringUpOrDownTitleBar(true);
+    return;
+  }
+
+  // Start the timer if not yet.
+  if (!bring_up_or_down_titlebar_timer_.IsRunning()) {
+    bring_up_or_down_titlebar_timer_.Start(
+        base::TimeDelta::FromMilliseconds(kBottomBarCheckPollingIntervalMs),
+        this,
+        &PanelManager::BringUpTitleBar);
+  }
+}
+
+void PanelManager::BringDownTitleBar() {
+  // If the bottom-bar is in auto-hide mode, delay the bring-down action until
+  // it is completely hidden. We do not want both bottom bar and panel titlebar
+  // to pop up at the same time but with different speed.
+  if (!auto_hide_bottom_bar_height_ ||
+      !should_check_auto_hide_bottom_bar_on_titlebar_change_ ||
+      IsBottomBarHidden()) {
+    bring_up_or_down_titlebar_timer_.Stop();
+    DoBringUpOrDownTitleBar(false);
+    return;
+  }
+
+  // Start the timer if not yet.
+  if (!bring_up_or_down_titlebar_timer_.IsRunning()) {
+    bring_up_or_down_titlebar_timer_.Start(
+        base::TimeDelta::FromMilliseconds(kBottomBarCheckPollingIntervalMs),
+        this,
+        &PanelManager::BringDownTitleBar);
+  }
+}
+
+void PanelManager::DoBringUpOrDownTitleBar(bool bring_up) {
   for (Panels::const_iterator iter = panels_.begin();
        iter != panels_.end(); ++iter) {
     Panel* panel = *iter;
 
     // Skip any panel that is drawing the attention.
     if (panel->IsDrawingAttention())
       continue;
 
     if (bring_up) {
       if (panel->expansion_state() == Panel::MINIMIZED)
         panel->SetExpansionState(Panel::TITLE_ONLY);
     } else {
       if (panel->expansion_state() == Panel::TITLE_ONLY)
         panel->SetExpansionState(Panel::MINIMIZED);
     }
   }
 }
 
+int PanelManager::GetBottomPositionPerExpansionState(
+    Panel::ExpansionState expansion_state) const {
+  int bottom = work_area_.bottom();
+  if (expansion_state != Panel::MINIMIZED)
+    bottom -= auto_hide_bottom_bar_height_;
+  return bottom;
+}
+
 void PanelManager::Rearrange(Panels::iterator iter_to_start) {
   if (iter_to_start == panels_.end())
     return;
 
   for (Panels::iterator iter = iter_to_start; iter != panels_.end(); ++iter) {
     gfx::Rect new_bounds((*iter)->GetBounds());
     ComputeBoundsForNextPanel(&new_bounds, false);
     if (new_bounds != (*iter)->GetBounds())
       (*iter)->SetPanelBounds(new_bounds);
   }
@@ skipping 16 matching lines @@
     else if (width > max_width_)
       width = max_width_;
 
     if (height < kPanelMinHeightPixels)
       height = kPanelMinHeightPixels;
     else if (height > max_height_)
       height = max_height_;
   }
 
   int x = current_x_ - width;
-  int y = bottom_edge_y_ - height;
+  int y = work_area_.bottom() - auto_hide_bottom_bar_height_ - height;
 
-  if (x < min_x_)
+  if (x < work_area_.x())
     return false;
 
   current_x_ -= width + kPanelsHorizontalSpacing;
 
   bounds->SetRect(x, y, width, height);
   return true;
 }
 
 void PanelManager::RemoveAll() {
   // This should not be called when we're in the process of dragging.
   DCHECK(dragging_panel_index_ == kInvalidPanelIndex);
 
   // Start from the bottom to avoid reshuffling.
   for (Panels::reverse_iterator iter = panels_.rbegin();
        iter != panels_.rend(); ++iter)
     (*iter)->Close();
 }