Support dragging panels to stack and snap.

chrome/browser/ui/panels/panel_manager.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 "chrome/browser/ui/panels/panel_manager.h"
 
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/logging.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/message_loop.h"
 #include "chrome/browser/ui/panels/detached_panel_collection.h"
 #include "chrome/browser/ui/panels/docked_panel_collection.h"
 #include "chrome/browser/ui/panels/panel_drag_controller.h"
 #include "chrome/browser/ui/panels/panel_mouse_watcher.h"
 #include "chrome/browser/ui/panels/panel_resize_controller.h"
+#include "chrome/browser/ui/panels/stacked_panel_collection.h"
 #include "chrome/common/chrome_notification_types.h"
 #include "chrome/common/chrome_switches.h"
 #include "chrome/common/chrome_version_info.h"
 #include "content/public/browser/notification_service.h"
 #include "content/public/browser/notification_source.h"
 
 #if defined(TOOLKIT_GTK)
 #include "ui/base/x/x11_util.h"
 #endif
 
@@ skipping 105 matching lines @@
 }
 
 void PanelManager::OnDisplayAreaChanged(const gfx::Rect& display_area) {
   if (display_area == display_area_)
     return;
   gfx::Rect old_display_area = display_area_;
   display_area_ = display_area;
 
   docked_collection_->OnDisplayAreaChanged(old_display_area);
   detached_collection_->OnDisplayAreaChanged(old_display_area);
+  for (Stacks::const_iterator iter = stacks_.begin();
+       iter != stacks_.end(); iter++)
+    (*iter)->OnDisplayAreaChanged(old_display_area);
 }
 
 void PanelManager::OnFullScreenModeChanged(bool is_full_screen) {
   docked_collection_->OnFullScreenModeChanged(is_full_screen);
 }
 
 int PanelManager::GetMaxPanelWidth() const {
   return static_cast<int>(display_area_.width() * kPanelMaxWidthFactor);
 }
 
@@ skipping 83 matching lines @@
   drag_controller_->OnPanelClosed(panel);
   resize_controller_->OnPanelClosed(panel);
   panel->collection()->RemovePanel(panel);
 
   content::NotificationService::current()->Notify(
       chrome::NOTIFICATION_PANEL_CLOSED,
       content::Source<Panel>(panel),
       content::NotificationService::NoDetails());
 }
 
+StackedPanelCollection* PanelManager::CreateStack() {
+  StackedPanelCollection* stack = new StackedPanelCollection(this);
+  stacks_.push_back(stack);
+  return stack;
+}
+
+void PanelManager::RemoveStack(StackedPanelCollection* stack) {
+  DCHECK_EQ(0, stack->num_panels());
+  stacks_.remove(stack);
+  stack->CloseAll();
+}
+
 void PanelManager::StartDragging(Panel* panel,
                                  const gfx::Point& mouse_location) {
   drag_controller_->StartDragging(panel, mouse_location);
 }
 
 void PanelManager::Drag(const gfx::Point& mouse_location) {
   drag_controller_->Drag(mouse_location);
 }
 
 void PanelManager::EndDragging(bool cancelled) {
@@ skipping 53 matching lines @@
 }
 
 void PanelManager::CloseAll() {
   DCHECK(!drag_controller_->is_dragging());
 
   detached_collection_->CloseAll();
   docked_collection_->CloseAll();
 }
 
 int PanelManager::num_panels() const {
-  return detached_collection_->num_panels() + docked_collection_->num_panels();
+  int count = detached_collection_->num_panels() +
+              docked_collection_->num_panels();
+  for (Stacks::const_iterator iter = stacks_.begin();
+       iter != stacks_.end(); iter++)
+    count += (*iter)->num_panels();
+  return count;
 }
 
 std::vector<Panel*> PanelManager::panels() const {
   std::vector<Panel*> panels;
   for (DetachedPanelCollection::Panels::const_iterator iter =
            detached_collection_->panels().begin();
        iter != detached_collection_->panels().end(); ++iter)
     panels.push_back(*iter);
   for (DockedPanelCollection::Panels::const_iterator iter =
            docked_collection_->panels().begin();
        iter != docked_collection_->panels().end(); ++iter)
     panels.push_back(*iter);
+  for (Stacks::const_iterator stack_iter = stacks_.begin();
+       stack_iter != stacks_.end(); stack_iter++) {
+    for (StackedPanelCollection::Panels::const_iterator iter =
+             (*stack_iter)->panels().begin();
+         iter != (*stack_iter)->panels().end(); ++stack_iter) {
+      panels.push_back(*iter);
+    }
+  }
   return panels;
 }
 
+std::vector<Panel*> PanelManager::GetDetachedAndStackedPanels() const {
+  std::vector<Panel*> panels;
+  for (DetachedPanelCollection::Panels::const_iterator iter =
+           detached_collection_->panels().begin();
+       iter != detached_collection_->panels().end(); ++iter)
+    panels.push_back(*iter);
+  for (Stacks::const_iterator stack_iter = stacks_.begin();
+       stack_iter != stacks_.end(); stack_iter++) {
+    for (StackedPanelCollection::Panels::const_iterator iter =
+             (*stack_iter)->panels().begin();
+         iter != (*stack_iter)->panels().end(); ++iter) {
+      panels.push_back(*iter);
+    }
+  }
+  return panels;
+}
+
 void PanelManager::SetMouseWatcher(PanelMouseWatcher* watcher) {
   panel_mouse_watcher_.reset(watcher);
 }
 
 void PanelManager::OnPanelAnimationEnded(Panel* panel) {
   content::NotificationService::current()->Notify(
       chrome::NOTIFICATION_PANEL_BOUNDS_ANIMATIONS_FINISHED,
       content::Source<Panel>(panel),
       content::NotificationService::NoDetails());
 }