Improves tab overview.

chrome/browser/views/tabs/tab_overview_drag_controller.cc

 // Copyright (c) 2009 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/views/tabs/tab_overview_drag_controller.h"
 
 #include "chrome/browser/browser.h"
 #include "chrome/browser/browser_window.h"
 #include "chrome/browser/dock_info.h"
+#include "chrome/browser/gtk/browser_window_gtk.h"
 #include "chrome/browser/tab_contents/tab_contents.h"
 #include "chrome/browser/tabs/tab_strip_model.h"
 #include "chrome/browser/tab_contents/tab_contents.h"
 #include "chrome/browser/views/tabs/tab_overview_cell.h"
 #include "chrome/browser/views/tabs/tab_overview_controller.h"
 #include "chrome/browser/views/tabs/tab_overview_grid.h"
 #include "chrome/browser/views/tabs/tab_overview_types.h"
 #include "chrome/common/notification_service.h"
 #include "views/fill_layout.h"
 #include "views/view.h"
 #include "views/widget/root_view.h"
 #include "views/widget/widget_gtk.h"
 
 TabOverviewDragController::TabOverviewDragController(
     TabOverviewController* controller)
     : controller_(controller),
       original_model_(controller->model()),
       current_index_(-1),
       original_index_(-1),
       detached_tab_(NULL),
       original_delegate_(NULL),
       x_offset_(0),
       y_offset_(0),
       dragging_(false),
       modifying_model_(false),
-      detached_window_(NULL) {
+      detached_window_(NULL),
+      hidden_browser_(NULL),
+      mouse_over_mini_window_(false) {
 }
 
 TabOverviewDragController::~TabOverviewDragController() {
   if (dragging_)
     controller_->DragEnded();
   if (original_index_ != -1)
-    RevertDrag();
+    RevertDrag(false);
 }
 
 bool TabOverviewDragController::Configure(const gfx::Point& location) {
   // Find the cell the user clicked on.
   TabOverviewCell* cell = NULL;
   int index = -1;
   for (int i = 0; i < grid()->GetChildViewCount(); ++i) {
     views::View* child = grid()->GetChildViewAt(i);
     if (child->bounds().Contains(location)) {
       index = i;
@@ skipping 10 matching lines @@
   if (!cell->IsPointInThumbnail(cell_point))
     return false;
 
   current_index_ = original_index_ = index;
   origin_ = location;
   x_offset_ = location.x() - cell->bounds().x();
   y_offset_ = location.y() - cell->bounds().y();
 
   // Ask the controller to select the cell.
   controller_->SelectTab(index);
+
+  if (controller_->browser()) {
+    browser_window_size_ =
+        controller_->browser()->window()->GetNormalBounds().size();
+  }
+
   return true;
 }
 
 void TabOverviewDragController::Drag(const gfx::Point& location) {
   if (original_index_ == -1)
     return;
 
   if (!dragging_ &&
       views::View::ExceededDragThreshold(location.x() - origin_.x(),
                                          location.y() - origin_.y())) {
     // Start dragging.
     dragging_ = true;
     controller_->DragStarted();
     grid()->set_floating_index(current_index_);
   }
   if (dragging_)
     DragCell(location);
 }
 
 void TabOverviewDragController::CommitDrag(const gfx::Point& location) {
   if (original_index_ == -1)
     return;
 
   Drag(location);
   if (detached_tab_) {
-    DropTab(location);
+    if (mouse_over_mini_window_) {
+      // Dragged over a mini window, add as the last tab to the browser.
+      Attach(model()->count());
+    } else {
+      DropTab(location);
+    }
   } else if (!dragging_ ) {
     // We haven't started dragging. Tell the controller to focus the browser.
     controller_->FocusBrowser();
   } else {
     // The tab is already in position, nothing to do but animate the change.
     grid()->set_floating_index(-1);
     grid()->AnimateToTargetBounds();
   }
 
   // Set the index to -1 so we know not to do any cleanup.
   original_index_ = -1;
 }
 
-void TabOverviewDragController::RevertDrag() {
+void TabOverviewDragController::RevertDrag(bool tab_destroyed) {
   if (original_index_ == -1)
     return;
 
   modifying_model_ = true;
   if (detached_tab_) {
     // Tab is currently detached, add it back to the original tab strip.
-    original_model_->InsertTabContentsAt(original_index_,
-                                         detached_tab_, true, false);
+    if (!tab_destroyed) {
+      original_model_->InsertTabContentsAt(original_index_,
+                                           detached_tab_, true, false);
+    }
     SetDetachedContents(NULL);
     detached_window_->Close();
     detached_window_ = NULL;
-  } else if (original_model_ != model()) {
+
+    if (hidden_browser_) {
+      gtk_widget_show(GTK_WIDGET(static_cast<BrowserWindowGtk*>(
+          hidden_browser_->window())->GetNativeHandle()));
+    }
+  } else if (original_model_ != model() && !tab_destroyed) {
     // The tab was added to a different tab strip. Move it back to the
     // original.
     TabContents* contents = model()->DetachTabContentsAt(current_index_);
     original_model_->InsertTabContentsAt(original_index_, contents, true,
                                          false);
-  } else if (current_index_ != original_index_) {
+  } else if (current_index_ != original_index_ && !tab_destroyed) {
     original_model_->MoveTabContentsAt(current_index_, original_index_, true);
   }
   modifying_model_ = false;
 
   // Set the index to -1 so we know not to do any cleanup.
   original_index_ = -1;
 }
 
 TabOverviewGrid* TabOverviewDragController::grid() const {
   return controller_->grid();
 }
 
 TabStripModel* TabOverviewDragController::model() const {
   return controller_->model();
 }
 
 void TabOverviewDragController::Observe(NotificationType type,
                                         const NotificationSource& source,
                                         const NotificationDetails& details) {
   DCHECK(type == NotificationType::TAB_CONTENTS_DESTROYED);
   DCHECK(Source<TabContents>(source).ptr() == detached_tab_);
-  RevertDrag();
+  RevertDrag(true);
 }
 
 void TabOverviewDragController::OpenURLFromTab(
     TabContents* source,
     const GURL& url,
     const GURL& referrer,
     WindowOpenDisposition disposition,
     PageTransition::Type transition) {
   if (original_delegate_) {
     if (disposition == CURRENT_TAB)
@@ skipping 156 matching lines @@
 
   grid()->set_floating_index(-1);
   SetDetachedContents(model()->GetTabContentsAt(current_index_));
   if (model()->count() == 1) {
     // The model is going to be empty. Tell the host to move us offscreen.
     // NOTE: it would be nice to hide and destroy the window here but this
     // causes two problems: we'll stop getting events, and we don't want
     // to empty out the tabstrip as otherwise they may trigger Chrome to
     // exit.
     controller_->MoveOffscreen();
+    hidden_browser_ = controller_->browser();
+    gtk_widget_hide(GTK_WIDGET(static_cast<BrowserWindowGtk*>(
+        hidden_browser_->window())->GetNativeHandle()));
   }
   modifying_model_ = true;
   model()->DetachTabContentsAt(current_index_);
   modifying_model_ = false;
 }
 
 void TabOverviewDragController::DropTab(const gfx::Point& location) {
   TabContents* contents = detached_tab_;
   SetDetachedContents(NULL);
 
-  gfx::Rect browser_rect = controller_->browser()->window()->GetNormalBounds();
   gfx::Point screen_loc(location);
   grid()->ConvertPointToScreen(grid(), &screen_loc);
-  gfx::Rect window_bounds(
-      screen_loc, gfx::Size(browser_rect.width(), browser_rect.height()));
-  Browser* new_browser = model()->delegate()->CreateNewStripWithContents(
-      contents, window_bounds, DockInfo());
+  gfx::Rect window_bounds(screen_loc, browser_window_size_);
+  Browser* new_browser =
+      original_model_->delegate()->CreateNewStripWithContents(
+          contents, window_bounds, DockInfo());
   new_browser->window()->Show();
 
   detached_window_->Close();
   detached_window_ = NULL;
 }
 
 void TabOverviewDragController::MoveDetachedWindow(
     const gfx::Point& location) {
   gfx::Point screen_loc = location;
   screen_loc.Offset(-x_offset_, -y_offset_);
   grid()->ConvertPointToScreen(grid(), &screen_loc);
   detached_window_->SetBounds(
       gfx::Rect(screen_loc,
                 detached_window_->GetRootView()->GetPreferredSize()));
+
+  // Notify the wm of the move.
+  TabOverviewTypes::Message message;
+  message.set_type(TabOverviewTypes::Message::WM_MOVE_FLOATING_TAB);
+  message.set_param(0, x11_util::GetX11WindowFromGtkWidget(
+                        detached_window_->GetNativeView()));
+  message.set_param(1, screen_loc.x() + x_offset_);
+  message.set_param(2, screen_loc.y() + y_offset_);
+  TabOverviewTypes::instance()->SendMessage(message);
 }
 
 views::Widget* TabOverviewDragController::CreateDetachedWindow(
     const gfx::Point& location,
     TabContents* tab_contents) {
   // TODO: wrap the cell in another view that provides a background.
   views::WidgetGtk* widget =
-      new views::WidgetGtk(views::WidgetGtk::TYPE_POPUP);
+      new views::WidgetGtk(views::WidgetGtk::TYPE_WINDOW);
   widget->MakeTransparent();
   gfx::Point screen_loc = location;
   screen_loc.Offset(-x_offset_, -y_offset_);
   grid()->ConvertPointToScreen(grid(), &screen_loc);
   TabOverviewCell* cell = new TabOverviewCell();
   cell->set_preferred_size(
       gfx::Size(grid()->cell_width(), grid()->cell_height()));
   controller_->ConfigureCell(cell, tab_contents);
   widget->Init(NULL, gfx::Rect(screen_loc, cell->GetPreferredSize()), true);
   widget->GetRootView()->SetLayoutManager(new views::FillLayout());
@@ skipping 30 matching lines @@
                    Source<TabContents>(tab));
 
     // We need to be the delegate so we receive messages about stuff,
     // otherwise our dragged contents may be replaced and subsequently
     // collected/destroyed while the drag is in process, leading to
     // nasty crashes.
     original_delegate_ = tab->delegate();
     tab->set_delegate(this);
   }
 }