Resize support for detached GTK Panels.

chrome/browser/ui/panels/panel_browser_window_gtk.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_browser_window_gtk.h"
 
 #include "base/bind.h"
 #include "chrome/browser/ui/browser_list.h"
 #include "chrome/browser/ui/gtk/browser_titlebar.h"
 #include "chrome/browser/ui/panels/panel.h"
 #include "chrome/browser/ui/panels/panel_bounds_animation.h"
+#include "chrome/browser/ui/panels/panel_drag_gtk.h"
 #include "chrome/browser/ui/panels/panel_manager.h"
 #include "chrome/browser/ui/panels/panel_strip.h"
 #include "chrome/browser/ui/panels/panel_settings_menu_model.h"
 #include "chrome/common/chrome_notification_types.h"
 #include "content/public/browser/notification_service.h"
 #include "ui/base/dragdrop/gtk_dnd_util.h"
 
 using content::WebContents;
 
 namespace {
@@ skipping 12 matching lines @@
 
 // Markup for title text in draw attention state. Set to color white.
 const char* const kDrawAttentionTitleMarkupPrefix =
     "<span fgcolor='#ffffff'>";
 const char* const kDrawAttentionTitleMarkupSuffix = "</span>";
 
 // Set minimium width for window really small so it can be reduced to icon only
 // size in overflow expansion state.
 const int kMinWindowWidth = 2;
 
-}
+}  // namespace
 
 NativePanel* Panel::CreateNativePanel(Browser* browser, Panel* panel,
                                       const gfx::Rect& bounds) {
   PanelBrowserWindowGtk* panel_browser_window_gtk =
       new PanelBrowserWindowGtk(browser, panel, bounds);
   panel_browser_window_gtk->Init();
   return panel_browser_window_gtk;
 }
 
 PanelBrowserWindowGtk::PanelBrowserWindowGtk(Browser* browser,
@@ skipping 42 matching lines @@
       this,
       chrome::NOTIFICATION_PANEL_CHANGED_LAYOUT_MODE,
       content::Source<Panel>(panel_.get()));
   registrar_.Add(
       this,
       chrome::NOTIFICATION_WINDOW_CLOSED,
       content::Source<GtkWindow>(window()));
 }
 
 bool PanelBrowserWindowGtk::GetWindowEdge(int x, int y, GdkWindowEdge* edge) {
-  // Since panels are not resizable or movable by the user, we should not
-  // detect the window edge for behavioral purposes.  The edge, if any,
-  // is present only for visual aspects.
-  return FALSE;
+  // Only detect the window edge when panels can be resized by the user.
+  // This method is used by the base class to detect when the cursor has
+  // hit the window edge in order to change the cursor to a resize cursor
+  // and to detect when to initiate a resize drag.
+  return panel_->CanResizeByMouse() ?
+    BrowserWindowGtk::GetWindowEdge(x, y, edge) : FALSE;
+}
+
+void PanelBrowserWindowGtk::EnsureDragHelperCreated() {
+  if (drag_helper_.get())
+    return;
+
+  drag_helper_.reset(new PanelDragGtk(panel_.get()));
+  gtk_box_pack_end(GTK_BOX(window_vbox_), drag_helper_->widget(),
+                   FALSE, FALSE, 0);
 }
 
 bool PanelBrowserWindowGtk::HandleTitleBarLeftMousePress(
     GdkEventButton* event,
     guint32 last_click_time,
     gfx::Point last_click_position) {
   // In theory we should never enter this function as we have a handler for
   // button press on titlebar where we handle this.  Not putting NOTREACHED()
   // here because we don't want to crash if hit-testing for titlebar in window
   // button press handler in BrowserWindowGtk is off by a pixel or two.
   DLOG(WARNING) << "Hit-testing for titlebar off by a pixel or two?";
   return TRUE;
 }
 
+bool PanelBrowserWindowGtk::HandleWindowEdgeLeftMousePress(
+    GtkWindow* window,
+    GdkWindowEdge edge,
+    GdkEventButton* event) {
+  DCHECK_EQ(1U, event->button);
+  DCHECK_EQ(GDK_BUTTON_PRESS, event->type);
+
+  EnsureDragHelperCreated();
+  // Resize cursor was set by BrowserWindowGtk when mouse moved over
+  // window edge.
+  GdkCursor* cursor =
+    gdk_window_get_cursor(gtk_widget_get_window(GTK_WIDGET(window_)));

[Evan Stade, 2012/04/12 03:25:29]

2 more indent

[jennb, 2012/04/12 18:00:24]

Done.

+  drag_helper_->InitialWindowEdgeMousePress(event, cursor, edge);
+  return TRUE;
+}
+
 void PanelBrowserWindowGtk::SaveWindowPosition() {
   // We don't save window position for panels as it's controlled by
   // PanelManager.
   return;
 }
 
 void PanelBrowserWindowGtk::SetGeometryHints() {
   // Set minimum height the window can be set to.
   GdkGeometry hints;
   hints.min_height = Panel::kMinimizedPanelHeight;
@@ skipping 144 matching lines @@
         bounds_animator_.reset();
 
       CleanupDragDrop();
       if (drag_widget_) {
         // Terminate the grab if we have it. We could do this using any widget,
         // |drag_widget_| is just convenient.
         gtk_grab_add(drag_widget_);
         gtk_grab_remove(drag_widget_);
         DestroyDragWidget();
       }
+
+      if (drag_helper_.get())
+        drag_helper_.reset();
+
       panel_->OnNativePanelClosed();
       break;
   }
 
   BrowserWindowGtk::Observe(type, source, details);
 }
 
 void PanelBrowserWindowGtk::ShowPanel() {
   Show();
 }
@@ skipping 253 matching lines @@
     CreateDragWidget();
     if (!system_drag_disabled_for_testing_) {
       GtkTargetList* list = ui::GetTargetListFromCodeMask(ui::CHROME_TAB);
       gtk_drag_begin(drag_widget_, list, GDK_ACTION_MOVE, 1, last_mouse_down_);
       // gtk_drag_begin increments reference count for GtkTargetList.  So unref
       // it here to reduce the reference count.
       gtk_target_list_unref(list);
     }
     panel_->manager()->StartDragging(panel_.get(), gfx::Point(old_x, old_y));
   }
-
   if (drag_widget_) {
     panel_->manager()->Drag(gfx::Point(new_x, new_y));
     gdk_event_free(last_mouse_down_);
     last_mouse_down_ = gdk_event_copy(event);
   }
 }
 
 void PanelBrowserWindowGtk::AnimationEnded(const ui::Animation* animation) {
   titlebar()->SendEnterNotifyToCloseButtonIfUnderMouse();
 
@@ skipping 328 matching lines @@
     MessageLoopForUI::current()->RunAllPending();
 }
 
 bool NativePanelTestingGtk::IsWindowSizeKnown() const {
   return !panel_browser_window_gtk_->frame_size_.IsEmpty();
 }
 
 bool NativePanelTestingGtk::IsAnimatingBounds() const {
   return panel_browser_window_gtk_->IsAnimatingBounds();
 }