Fix the problem that notifications and panels overlap.

chrome/browser/notifications/balloon_collection_impl.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/notifications/balloon_collection_impl.h"
 
 #include "base/bind.h"
 #include "base/logging.h"
 #include "base/stl_util.h"
 #include "chrome/browser/notifications/balloon.h"
 #include "chrome/browser/notifications/balloon_host.h"
 #include "chrome/browser/notifications/notification.h"
+#include "chrome/browser/ui/browser.h"
+#include "chrome/browser/ui/panels/panel_manager.h"
+#include "chrome/browser/ui/panels/panel.h"
 #include "chrome/browser/ui/window_sizer.h"
+#include "chrome/common/chrome_notification_types.h"
+#include "content/public/browser/notification_registrar.h"
+#include "content/public/browser/notification_service.h"
 #include "ui/gfx/rect.h"
 #include "ui/gfx/size.h"
 
 namespace {
 
 // Portion of the screen allotted for notifications. When notification balloons
 // extend over this, no new notifications are shown until some are closed.
 const double kPercentBalloonFillFactor = 0.7;
 
 // Allow at least this number of balloons on the screen.
 const int kMinAllowedBalloonCount = 2;
 
 // Delay from the mouse leaving the balloon collection before
 // there is a relayout, in milliseconds.
 const int kRepositionDelay = 300;
 
+// The spacing between the balloon and the panel.
+const int kVerticalSpacingBetweenBalloonAndPanel = 5;
+
 }  // namespace
 
 BalloonCollectionImpl::BalloonCollectionImpl()
 #if USE_OFFSETS
     : ALLOW_THIS_IN_INITIALIZER_LIST(reposition_factory_(this)),
       added_as_message_loop_observer_(false)
 #endif
 {
+  registrar_.Add(this, chrome::NOTIFICATION_PANEL_ADDED,
+                 content::NotificationService::AllSources());
+  registrar_.Add(this, chrome::NOTIFICATION_PANEL_REMOVED,
+                 content::NotificationService::AllSources());
+  registrar_.Add(this, chrome::NOTIFICATION_PANEL_CHANGED_BOUNDS,
+                 content::NotificationService::AllSources());
 
   SetPositionPreference(BalloonCollection::DEFAULT_POSITION);
 }
 
 BalloonCollectionImpl::~BalloonCollectionImpl() {
 }
 
 void BalloonCollectionImpl::Add(const Notification& notification,
                                 Profile* profile) {
   Balloon* new_balloon = MakeBalloon(notification, profile);
@@ skipping 98 matching lines @@
 
   // This is used only for testing.
   if (!on_collection_changed_callback_.is_null())
     on_collection_changed_callback_.Run();
 }
 
 const BalloonCollection::Balloons& BalloonCollectionImpl::GetActiveBalloons() {
   return base_.balloons();
 }
 
+void BalloonCollectionImpl::Observe(
+    int type,
+    const content::NotificationSource& source,
+    const content::NotificationDetails& details) {
+  gfx::Rect bounds;
+  switch (type) {
+    case chrome::NOTIFICATION_PANEL_CHANGED_BOUNDS:
+      bounds = content::Source<Panel>(source).ptr()->GetBounds();
+      // Fall through.
+    case chrome::NOTIFICATION_PANEL_ADDED:
+    case chrome::NOTIFICATION_PANEL_REMOVED:
+      if (layout_.ComputeOffsetToMoveAbovePanels(bounds))
+        PositionBalloons(true);
+      break;
+    default:
+      NOTREACHED();
+      break;
+  }
+}
+
 void BalloonCollectionImpl::PositionBalloonsInternal(bool reposition) {
   const Balloons& balloons = base_.balloons();
 
   layout_.RefreshSystemMetrics();
   gfx::Point origin = layout_.GetLayoutOrigin();
   for (Balloons::const_iterator it = balloons.begin();
        it != balloons.end();
        ++it) {
     gfx::Point upper_left = layout_.NextPosition((*it)->GetViewSize(), &origin);
     (*it)->SetPosition(upper_left, reposition);
@@ skipping 58 matching lines @@
                      reposition_factory_.GetWeakPtr()),
           kRepositionDelay);
     }
   } else {
     // Mouse moved back into the region.  Cancel the reposition.
     reposition_factory_.InvalidateWeakPtrs();
   }
 }
 #endif
 
-BalloonCollectionImpl::Layout::Layout() : placement_(INVALID) {
+BalloonCollectionImpl::Layout::Layout()
+    : placement_(INVALID),
+      offset_to_move_above_panels_(0) {
   RefreshSystemMetrics();
 }
 
 void BalloonCollectionImpl::Layout::GetMaxLinearSize(int* max_balloon_size,
                                                      int* total_size) const {
   DCHECK(max_balloon_size && total_size);
 
   // All placement schemes are vertical, so we only care about height.
   *total_size = work_area_.height();
   *max_balloon_size = max_balloon_height();
 }
 
 gfx::Point BalloonCollectionImpl::Layout::GetLayoutOrigin() const {
+  // For lower-left and lower-right positioning, we need to add an offset
+  // to ensure balloons to stay on top of panels to avoid overlapping.
   int x = 0;
   int y = 0;
   switch (placement_) {
-    case VERTICALLY_FROM_TOP_LEFT:
+    case VERTICALLY_FROM_TOP_LEFT: {
       x = work_area_.x() + HorizontalEdgeMargin();
-      y = work_area_.y() + VerticalEdgeMargin();
+      y = work_area_.y() + VerticalEdgeMargin() + offset_to_move_above_panels_;
       break;
-    case VERTICALLY_FROM_TOP_RIGHT:
+    }
+    case VERTICALLY_FROM_TOP_RIGHT: {
       x = work_area_.right() - HorizontalEdgeMargin();
-      y = work_area_.y() + VerticalEdgeMargin();
+      y = work_area_.y() + VerticalEdgeMargin() + offset_to_move_above_panels_;
       break;
+    }
     case VERTICALLY_FROM_BOTTOM_LEFT:
       x = work_area_.x() + HorizontalEdgeMargin();
-      y = work_area_.bottom() - VerticalEdgeMargin();
+      y = work_area_.bottom() - VerticalEdgeMargin() -
+          offset_to_move_above_panels_;
       break;
     case VERTICALLY_FROM_BOTTOM_RIGHT:
       x = work_area_.right() - HorizontalEdgeMargin();
-      y = work_area_.bottom() - VerticalEdgeMargin();
+      y = work_area_.bottom() - VerticalEdgeMargin() -
+          offset_to_move_above_panels_;
       break;
     default:
       NOTREACHED();
       break;
   }
   return gfx::Point(x, y);
 }
 
 gfx::Point BalloonCollectionImpl::Layout::NextPosition(
     const gfx::Size& balloon_size,
@@ skipping 28 matching lines @@
       y = position_iterator->y();
       break;
     default:
       NOTREACHED();
       break;
   }
   return gfx::Point(x, y);
 }
 
 gfx::Point BalloonCollectionImpl::Layout::OffScreenLocation() const {
-  int x = 0;
-  int y = 0;
+  gfx::Point location = GetLayoutOrigin();
   switch (placement_) {
     case VERTICALLY_FROM_TOP_LEFT:
-      x = work_area_.x() + HorizontalEdgeMargin();
-      y = work_area_.y() + kBalloonMaxHeight + VerticalEdgeMargin();
+    case VERTICALLY_FROM_BOTTOM_LEFT:
+      location.Offset(0, kBalloonMaxHeight);
       break;
     case VERTICALLY_FROM_TOP_RIGHT:
-      x = work_area_.right() - kBalloonMaxWidth - HorizontalEdgeMargin();
-      y = work_area_.y() + kBalloonMaxHeight + VerticalEdgeMargin();
-      break;
-    case VERTICALLY_FROM_BOTTOM_LEFT:
-      x = work_area_.x() + HorizontalEdgeMargin();
-      y = work_area_.bottom() + kBalloonMaxHeight + VerticalEdgeMargin();
-      break;
     case VERTICALLY_FROM_BOTTOM_RIGHT:
-      x = work_area_.right() - kBalloonMaxWidth - HorizontalEdgeMargin();
-      y = work_area_.bottom() + kBalloonMaxHeight + VerticalEdgeMargin();
+      location.Offset(-kBalloonMaxWidth, kBalloonMaxHeight);
       break;
     default:
       NOTREACHED();
       break;
   }
-  return gfx::Point(x, y);
+  return location;
 }
 
 bool BalloonCollectionImpl::Layout::RequiresOffsets() const {
   // Layout schemes that grow up from the bottom require offsets;
   // schemes that grow down do not require offsets.
   bool offsets = (placement_ == VERTICALLY_FROM_BOTTOM_LEFT ||
                   placement_ == VERTICALLY_FROM_BOTTOM_RIGHT);
 
 #if defined(OS_MACOSX)
   // These schemes are in screen-coordinates, and top and bottom
   // are inverted on Mac.
   offsets = !offsets;
 #endif
 
   return offsets;
 }
 
 // static
 gfx::Size BalloonCollectionImpl::Layout::ConstrainToSizeLimits(
     const gfx::Size& size) {
   // restrict to the min & max sizes
   return gfx::Size(
       std::max(min_balloon_width(),
                std::min(max_balloon_width(), size.width())),
       std::max(min_balloon_height(),
                std::min(max_balloon_height(), size.height())));
 }
 
+bool BalloonCollectionImpl::Layout::ComputeOffsetToMoveAbovePanels(
+    const gfx::Rect& panel_bounds) {
+  const PanelManager::Panels& panels = PanelManager::GetInstance()->panels();
+  int offset_to_move_above_panels = 0;
+
+  // The offset is the maximum height of panels that could overlap with the
+  // balloons.
+  if (NeedToMoveAboveLeftSidePanels()) {
+    // If the affecting panel does not lie in the balloon area, no need to
+    // update the offset.
+    if (!panel_bounds.IsEmpty() &&
+        (panel_bounds.right() <= work_area_.x() ||
+         panel_bounds.x() >= work_area_.x() + max_balloon_width())) {
+      return false;
+    }
+
+    for (PanelManager::Panels::const_reverse_iterator iter = panels.rbegin();
+         iter != panels.rend(); ++iter) {
+      // No need to check panels beyond the area occupied by the balloons.
+      if ((*iter)->GetBounds().x() >= work_area_.x() + max_balloon_width())

[jennb, 2011/11/11 23:02:43]

FYI, until your overflow changes are in, this will cause balloons to be affected
by tall overflow panels appearing offscreen.

No need to fix now as you're almost done with overflow changes.

+        break;
+
+      int current_height = (*iter)->GetBounds().height();
+      if (current_height > offset_to_move_above_panels)
+        offset_to_move_above_panels = current_height;
+    }
+  } else if (NeedToMoveAboveRightSidePanels()) {
+    // If the affecting panel does not lie in the balloon area, no need to
+    // update the offset.
+    if (!panel_bounds.IsEmpty() &&
+        (panel_bounds.right() <= work_area_.right() - max_balloon_width() ||
+         panel_bounds.x() >= work_area_.right())) {
+      return false;
+    }
+
+    for (PanelManager::Panels::const_iterator iter = panels.begin();
+         iter != panels.end(); ++iter) {
+      // No need to check panels beyond the area occupied by the balloons.
+      if ((*iter)->GetBounds().right() <=
+          work_area_.right() - max_balloon_width())
+        break;
+
+      int current_height = (*iter)->GetBounds().height();
+      if (current_height > offset_to_move_above_panels)
+        offset_to_move_above_panels = current_height;
+    }
+  }
+
+  // Ensure that we have some sort of margin between the 1st balloon and the
+  // panel beneath it even the vertical edge margin is 0 as on Mac.
+  if (offset_to_move_above_panels && !VerticalEdgeMargin())
+    offset_to_move_above_panels += kVerticalSpacingBetweenBalloonAndPanel;
+
+  // If no change is detected, return false to indicate that we do not need to
+  // reposition balloons.
+  if (offset_to_move_above_panels_ == offset_to_move_above_panels)
+    return false;
+
+  offset_to_move_above_panels_ = offset_to_move_above_panels;
+  return true;
+}
+
 bool BalloonCollectionImpl::Layout::RefreshSystemMetrics() {
   bool changed = false;
 
 #if defined(OS_MACOSX)
   gfx::Rect new_work_area = GetMacWorkArea();
 #else
   scoped_ptr<WindowSizer::MonitorInfoProvider> info_provider(
       WindowSizer::CreateDefaultMonitorInfoProvider());
   gfx::Rect new_work_area = info_provider->GetPrimaryMonitorWorkArea();
 #endif
   if (!work_area_.Equals(new_work_area)) {
     work_area_.SetRect(new_work_area.x(), new_work_area.y(),
                        new_work_area.width(), new_work_area.height());
     changed = true;
   }
 
   return changed;
 }