Makes tab dragging on views restrict the drag to the main window....

chrome/browser/views/tabs/dragged_tab_view.cc

 // Copyright (c) 2006-2008 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/dragged_tab_view.h"
 
 #include "app/gfx/canvas.h"
 #include "chrome/browser/tab_contents/tab_contents.h"
 #include "chrome/browser/tabs/tab_strip_model.h"
 #include "chrome/browser/views/tabs/native_view_photobooth.h"
@@ skipping 43 matching lines @@
   container_->Init(NULL, gfx::Rect(0, 0, 0, 0));
   container_->SetContentsView(this);
 
   BOOL drag;
   if ((::SystemParametersInfo(SPI_GETDRAGFULLWINDOWS, 0, &drag, 0) != 0) &&
       (drag == FALSE)) {
     show_contents_on_drag_ = false;
   }
 #else
   container_.reset(new views::WidgetGtk(views::WidgetGtk::TYPE_POPUP));
+  container_->MakeTransparent();
   container_->set_delete_on_destroy(false);
   container_->Init(NULL, gfx::Rect(0, 0, 0, 0));
   container_->SetContentsView(this);
 #endif
 }
 
 DraggedTabView::~DraggedTabView() {
   if (close_animation_.IsAnimating())
     close_animation_.Stop();
   GetParent()->RemoveChildView(this);
-#if defined(OS_WIN)
   container_->CloseNow();
-#else
-  NOTIMPLEMENTED();
-#endif
 }
 
 void DraggedTabView::MoveTo(const gfx::Point& screen_point) {
-#if defined(OS_WIN)
-  int show_flags = container_->IsVisible() ? SWP_NOZORDER : SWP_SHOWWINDOW;
-
   int x;
   if (UILayoutIsRightToLeft() && !attached_) {
     // On RTL locales, a dragged tab (when it is not attached to a tab strip)
     // is rendered using a right-to-left orientation so we should calculate the
     // window position differently.
     gfx::Size ps = GetPreferredSize();
     x = screen_point.x() - ScaleValue(ps.width()) + mouse_tab_offset_.x() +
         ScaleValue(
             renderer_->MirroredXCoordinateInsideView(mouse_tab_offset_.x()));
   } else {
     x = screen_point.x() + mouse_tab_offset_.x() -
         ScaleValue(mouse_tab_offset_.x());
   }
   int y = screen_point.y() + mouse_tab_offset_.y() -
       ScaleValue(mouse_tab_offset_.y());
 
+#if defined(OS_WIN)
+  int show_flags = container_->IsVisible() ? SWP_NOZORDER : SWP_SHOWWINDOW;
+
   container_->SetWindowPos(HWND_TOP, x, y, 0, 0,
                            SWP_NOSIZE | SWP_NOACTIVATE | show_flags);
 #else
-  NOTIMPLEMENTED();
+  gfx::Rect bounds;
+  container_->GetBounds(&bounds, true);
+  container_->SetBounds(gfx::Rect(x, y, bounds.width(), bounds.height()));
+  if (!container_->IsVisible())
+    container_->Show();
 #endif
 }
 
 void DraggedTabView::Attach(int selected_width) {
   attached_ = true;
   photobooth_ = NULL;
 #if defined(OS_WIN)
   container_->SetOpacity(kOpaqueAlpha);
-#else
-  NOTIMPLEMENTED();
 #endif
   Resize(selected_width);
 }
 
 void DraggedTabView::Resize(int width) {
   attached_tab_size_.set_width(width);
   ResizeContainer();
   Update();
 }
 
@@ skipping 11 matching lines @@
 
   if (attached_tab_size_.width() != tab_width_) {
     // The attached tab size differs from current tab size. Resize accordingly.
     Resize(tab_width_);
   }
 
   attached_ = false;
   photobooth_ = photobooth;
 #if defined(OS_WIN)
   container_->SetOpacity(kTransparentAlpha);
-#else
-  NOTIMPLEMENTED();
 #endif
   ResizeContainer();
   Update();
 }
 
 void DraggedTabView::Update() {
 #if defined(OS_WIN)
   container_->set_can_update_layered_window(true);
   SchedulePaint();
   container_->PaintNow(gfx::Rect());
   container_->set_can_update_layered_window(false);
 #else
-  NOTIMPLEMENTED();
+  SchedulePaint();
 #endif
 }
 
 void DraggedTabView::AnimateToBounds(const gfx::Rect& bounds,
                                      Callback0::Type* callback) {
   animation_callback_.reset(callback);
 
   gfx::Rect initial_bounds;
   GetWidget()->GetBounds(&initial_bounds, true);
   animation_start_bounds_ = initial_bounds;
   animation_end_bounds_ = bounds;
 
   close_animation_.SetSlideDuration(kAnimateToBoundsDurationMs);
   close_animation_.SetTweenType(SlideAnimation::EASE_OUT);
   if (!close_animation_.IsShowing()) {
     close_animation_.Reset();
     close_animation_.Show();
   }
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 // DraggedTabView, AnimationDelegate implementation:
 
 void DraggedTabView::AnimationProgressed(const Animation* animation) {
-#if defined(OS_WIN)
   int delta_x = (animation_end_bounds_.x() - animation_start_bounds_.x());
   int x = animation_start_bounds_.x() +
       static_cast<int>(delta_x * animation->GetCurrentValue());
   int y = animation_end_bounds_.y();
+#if defined(OS_WIN)
   container_->SetWindowPos(NULL, x, y, 0, 0, SWP_NOSIZE | SWP_NOACTIVATE);
 #else
+  gfx::Rect bounds;
+  container_->GetBounds(&bounds, true);
+  container_->SetBounds(gfx::Rect(x, y, bounds.width(), bounds.height()));
 #endif
 }
 
 void DraggedTabView::AnimationEnded(const Animation* animation) {
   animation_callback_->Run();
 }
 
 void DraggedTabView::AnimationCanceled(const Animation* animation) {
   AnimationEnded(animation);
 }
@@ skipping 96 matching lines @@
 
 void DraggedTabView::PaintFocusRect(gfx::Canvas* canvas) {
   gfx::Size ps = GetPreferredSize();
   canvas->DrawFocusRect(0, 0,
                         static_cast<int>(ps.width() * kScalingFactor),
                         static_cast<int>(ps.height() * kScalingFactor));
 }
 
 void DraggedTabView::ResizeContainer() {
   gfx::Size ps = GetPreferredSize();
+  int w = ScaleValue(ps.width());
+  int h = ScaleValue(ps.height());
 #if defined(OS_WIN)
-  SetWindowPos(container_->GetNativeView(), HWND_TOPMOST, 0, 0,
-               ScaleValue(ps.width()), ScaleValue(ps.height()),
+  SetWindowPos(container_->GetNativeView(), HWND_TOPMOST, 0, 0, w, h,
                SWP_NOMOVE | SWP_NOZORDER | SWP_NOACTIVATE);
 #else
-  NOTIMPLEMENTED();
+  gfx::Rect bounds;
+  container_->GetBounds(&bounds, true);
+  container_->SetBounds(gfx::Rect(bounds.x(), bounds.y(), w, h));
 #endif
 }
 
 int DraggedTabView::ScaleValue(int value) {
   return attached_ ? value : static_cast<int>(value * kScalingFactor);
 }