Refactor intra-strip panel drags by introducing PanelDragController.

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/command_line.h"
 #include "base/logging.h"
 #include "base/memory/scoped_ptr.h"
 #include "chrome/browser/fullscreen.h"
 #include "chrome/browser/ui/browser.h"
 #include "chrome/browser/ui/browser_list.h"
+#include "chrome/browser/ui/panels/detached_panel_strip.h"
 #include "chrome/browser/ui/panels/docked_panel_strip.h"
 #include "chrome/browser/ui/panels/overflow_panel_strip.h"
+#include "chrome/browser/ui/panels/panel_drag_controller.h"
 #include "chrome/browser/ui/panels/panel_mouse_watcher.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"
 #include "ui/gfx/screen.h"
 
 namespace {
 const int kOverflowStripThickness = 26;
@@ skipping 31 matching lines @@
         extension_id == std::string("eggnbpckecmjlblplehfpjjdhhidfdoj");
   }
 
   return true;
 }
 
 PanelManager::PanelManager()
     : panel_mouse_watcher_(PanelMouseWatcher::Create()),
       auto_sizing_enabled_(true),
       is_full_screen_(false) {
+  detached_strip_.reset(new DetachedPanelStrip(this));
   docked_strip_.reset(new DockedPanelStrip(this));
   overflow_strip_.reset(new OverflowPanelStrip(this));
+  drag_controller_.reset(new PanelDragController());
   auto_hiding_desktop_bar_ = AutoHidingDesktopBar::Create(this);
   OnDisplayChanged();
 }
 
 PanelManager::~PanelManager() {
 }
 
 void PanelManager::OnDisplayChanged() {
 #if defined(OS_MACOSX)
   // On OSX, panels should be dropped all the way to the bottom edge of the
@@ skipping 21 matching lines @@
   gfx::Rect docked_strip_bounds;
   docked_strip_bounds.set_x(adjusted_work_area_.x() + kPanelStripLeftMargin);
   docked_strip_bounds.set_y(adjusted_work_area_.bottom() - height);
   docked_strip_bounds.set_width(adjusted_work_area_.width() -
                                 kPanelStripLeftMargin - kPanelStripRightMargin);
   docked_strip_bounds.set_height(height);
   docked_strip_->SetDisplayArea(docked_strip_bounds);
 
   gfx::Rect overflow_area(adjusted_work_area_);
   overflow_area.set_width(kOverflowStripThickness);
   overflow_strip_->SetDisplayArea(overflow_area);

[Andrei, 2012/02/18 19:41:31]

Should not we take care of the detached strip here as well? (I am not 100% sure
where you patch stops, and what is planned for the future, but) since you have
introduced the detached strip member, and use it in some functions, you need to
keep it in a consistent state.

 }
 
 Panel* PanelManager::CreatePanel(Browser* browser) {
   int width = browser->override_bounds().width();
   int height = browser->override_bounds().height();
   Panel* panel = new Panel(browser, gfx::Size(width, height));
   panel->MoveToStrip(docked_strip_.get());
 
   content::NotificationService::current()->Notify(
       chrome::NOTIFICATION_PANEL_ADDED,
@@ skipping 17 matching lines @@
 int PanelManager::StartingRightPosition() const {
   return docked_strip_->StartingRightPosition();
 }
 
 void PanelManager::CheckFullScreenMode() {
   bool is_full_screen_new = IsFullScreenMode();
   if (is_full_screen_ == is_full_screen_new)
     return;
   is_full_screen_ = is_full_screen_new;
   docked_strip_->OnFullScreenModeChanged(is_full_screen_);
   overflow_strip_->OnFullScreenModeChanged(is_full_screen_);

[Andrei, 2012/02/18 21:31:12]

Notify the detached strip here as well

 }
 
 void PanelManager::OnPanelRemoved(Panel* panel) {
 #if defined(OS_WIN) || defined(OS_MACOSX)
   if (num_panels() == 0)
     full_screen_mode_timer_.Stop();
 #endif
 
   content::NotificationService::current()->Notify(
       chrome::NOTIFICATION_PANEL_REMOVED,
       content::Source<Panel>(panel),
       content::NotificationService::NoDetails());
 }
 
 void PanelManager::StartDragging(Panel* panel) {
-  docked_strip_->StartDragging(panel);
+  drag_controller_->StartDragging(panel);
 }
 
-void PanelManager::Drag(int delta_x) {
-  docked_strip_->Drag(delta_x);
+void PanelManager::Drag(int delta_x, int delta_y) {
+  drag_controller_->Drag(delta_x, delta_y);
 }
 
 void PanelManager::EndDragging(bool cancelled) {
-  docked_strip_->EndDragging(cancelled);
+  drag_controller_->EndDragging(cancelled);
 }
 
 void PanelManager::OnPanelExpansionStateChanged(Panel* panel) {
   docked_strip_->OnPanelExpansionStateChanged(panel);

[Andrei, 2012/02/18 19:41:31]

Should it be panel->panel_strip()->OnPanelExpansionStateChanged(panel) ?

[jianli, 2012/02/21 19:14:32]

Yes, we need to fix this. I rather fix it later when we can really create a
detached panel for testing.

 }
 
 void PanelManager::OnPreferredWindowSizeChanged(
     Panel* panel, const gfx::Size& preferred_window_size) {
   if (!auto_sizing_enabled_) {
     LOG(INFO) << "Resizing auto-resizable Panels is not supported yet.";
     return;
   }
   docked_strip_->ResizePanelWindow(panel, preferred_window_size);

[Andrei, 2012/02/18 19:41:31]

Same as above for this and the next 3 functions

[jianli, 2012/02/21 19:14:32]

Yes. But I rather delay the fix as mentioned above.

 }
 
 void PanelManager::ResizePanel(Panel* panel, const gfx::Size& new_size) {
   // Explicit resizing is not allowed for auto-resizable panels for now.
   // http://crbug.com/109343
   if (panel->auto_resizable())
     return;
 
   docked_strip_->ResizePanelWindow(panel, new_size);
 }
@@ skipping 38 matching lines @@
 }
 
 void PanelManager::OnAutoHidingDesktopBarThicknessChanged() {
   AdjustWorkAreaForAutoHidingDesktopBars();
   Layout();
 }
 
 void PanelManager::OnAutoHidingDesktopBarVisibilityChanged(
     AutoHidingDesktopBar::Alignment alignment,
     AutoHidingDesktopBar::Visibility visibility) {
   docked_strip_->OnAutoHidingDesktopBarVisibilityChanged(alignment, visibility);

[Andrei, 2012/02/18 21:31:12]

May other strips, detached and overflow, need to know as well?

 }
 
 void PanelManager::CloseAll() {
+  DCHECK(!drag_controller_->dragging_panel());
+
+  detached_strip_->CloseAll();
   docked_strip_->CloseAll();
   overflow_strip_->CloseAll();
 }
 
 int PanelManager::num_panels() const {
-  return docked_strip_->num_panels() + overflow_strip_->num_panels();
+  return detached_strip_->num_panels() +
+         docked_strip_->num_panels() +
+         overflow_strip_->num_panels();
 }
 
 std::vector<Panel*> PanelManager::panels() const {
   std::vector<Panel*> panels;
+  for (DetachedPanelStrip::Panels::const_iterator iter =
+           detached_strip_->panels().begin();
+       iter != detached_strip_->panels().end(); ++iter)
+    panels.push_back(*iter);
   for (DockedPanelStrip::Panels::const_iterator iter =
            docked_strip_->panels().begin();
        iter != docked_strip_->panels().end(); ++iter)
     panels.push_back(*iter);
   for (OverflowPanelStrip::Panels::const_iterator iter =
            overflow_strip_->panels().begin();
        iter != overflow_strip_->panels().end(); ++iter)
     panels.push_back(*iter);
   return panels;
 }
 
 void PanelManager::SetMouseWatcher(PanelMouseWatcher* watcher) {
   panel_mouse_watcher_.reset(watcher);
 }