Add the ability to resize the window when over the custom frame.

chrome/browser/gtk/browser_window_gtk.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/gtk/browser_window_gtk.h"
 
 #include <gdk/gdkkeysyms.h>
 
 #include "app/resource_bundle.h"
 #include "app/theme_provider.h"
@@ skipping 41 matching lines @@
 #include "chrome/browser/views/tabs/tab_overview_types.h"
 #endif
 
 namespace {
 
 // The number of milliseconds between loading animation frames.
 const int kLoadingAnimationFrameTimeMs = 30;
 
 const char* kBrowserWindowKey = "__BROWSER_WINDOW_GTK__";
 
-// The width of the custom frame.
-const int kCustomFrameWidth = 3;
+// The frame border is only visible in restored mode and is hardcoded to 4 px
+// on each side regardless of the system window border size.
+const int kFrameBorderThickness = 4;
+// While resize areas on Windows are normally the same size as the window
+// borders, our top area is shrunk by 1 px to make it easier to move the window
+// around with our thinner top grabbable strip.  (Incidentally, our side and
+// bottom resize areas don't match the frame border thickness either -- they
+// span the whole nonclient area, so there's no "dead zone" for the mouse.)
+const int kTopResizeAdjust = 1;
+// In the window corners, the resize areas don't actually expand bigger, but
+// the 16 px at the end of each edge triggers diagonal resizing.
+const int kResizeAreaCornerSize = 16;
 
 gboolean MainWindowConfigured(GtkWindow* window, GdkEventConfigure* event,
                               BrowserWindowGtk* browser_win) {
   gfx::Rect bounds = gfx::Rect(event->x, event->y, event->width, event->height);
   browser_win->OnBoundsChanged(bounds);
   return FALSE;
 }
 
 gboolean MainWindowStateChanged(GtkWindow* window, GdkEventWindowState* event,
                                 BrowserWindowGtk* browser_win) {
@@ skipping 186 matching lines @@
     }
 
     return gtk_window_propagate_key_event(window, event);
   } else {
     bool rv = gtk_window_propagate_key_event(window, event);
     DCHECK(rv);
     return TRUE;
   }
 }
 
-gboolean OnButtonPressEvent(GtkWidget* widget, GdkEventButton* event,
-                            Browser* browser) {
-  // TODO(jhawkins): Investigate the possibility of the button numbers being
-  // different for other mice.
-  if (event->button == 8) {
-    browser->GoBack(CURRENT_TAB);
-    return TRUE;
-  } else if (event->button == 9) {
-    browser->GoForward(CURRENT_TAB);
-    return TRUE;
-  }
-  return FALSE;
-}
-
 gboolean OnFocusIn(GtkWidget* widget, GdkEventFocus* event, Browser* browser) {
   BrowserList::SetLastActive(browser);
   return FALSE;
 }
 
+GdkCursorType GdkWindowEdgeToGdkCursorType(GdkWindowEdge edge) {
+  switch (edge) {
+    case GDK_WINDOW_EDGE_NORTH_WEST:
+      return GDK_TOP_LEFT_CORNER;
+    case GDK_WINDOW_EDGE_NORTH:
+      return GDK_TOP_SIDE;
+    case GDK_WINDOW_EDGE_NORTH_EAST:
+      return GDK_TOP_RIGHT_CORNER;
+    case GDK_WINDOW_EDGE_WEST:
+      return GDK_LEFT_SIDE;
+    case GDK_WINDOW_EDGE_EAST:
+      return GDK_RIGHT_SIDE;
+    case GDK_WINDOW_EDGE_SOUTH_WEST:
+      return GDK_BOTTOM_LEFT_CORNER;
+    case GDK_WINDOW_EDGE_SOUTH:
+      return GDK_BOTTOM_SIDE;
+    case GDK_WINDOW_EDGE_SOUTH_EAST:
+      return GDK_BOTTOM_RIGHT_CORNER;
+    default:
+      NOTREACHED();
+  }
+  return GDK_LAST_CURSOR;
+}
+
 }  // namespace
 
 std::map<XID, GtkWindow*> BrowserWindowGtk::xid_map_;
 
 BrowserWindowGtk::BrowserWindowGtk(Browser* browser)
     :  browser_(browser),
        full_screen_(false),
-       drag_active_(false) {
+       drag_active_(false),
+       frame_cursor_(NULL) {
   use_custom_frame_.Init(prefs::kUseCustomChromeFrame,
       browser_->profile()->GetPrefs(), this);
   window_ = GTK_WINDOW(gtk_window_new(GTK_WINDOW_TOPLEVEL));
   g_object_set_data(G_OBJECT(window_), kBrowserWindowKey, this);
+  gtk_widget_add_events(GTK_WIDGET(window_), GDK_BUTTON_PRESS_MASK |
+                                             GDK_POINTER_MOTION_MASK);
 
   SetWindowIcon();
   SetBackgroundColor();
   SetGeometryHints();
   ConnectHandlersToSignals();
   ConnectAccelerators();
   bounds_ = GetInitialWindowBounds(window_);
 
   InitWidgets();
   HideUnsupportedWindowFeatures();
 
   registrar_.Add(this, NotificationType::BOOKMARK_BAR_VISIBILITY_PREF_CHANGED,
                  NotificationService::AllSources());
 }
 
 BrowserWindowGtk::~BrowserWindowGtk() {
   browser_->tabstrip_model()->RemoveObserver(this);
+
+  if (frame_cursor_) {
+    gdk_cursor_unref(frame_cursor_);
+    frame_cursor_ = NULL;
+  }
 }
 
 void BrowserWindowGtk::HandleAccelerator(guint keyval,
                                          GdkModifierType modifier) {
   if (!HandleCustomAccelerator(keyval, modifier, browser_.get())) {
     // Pass the accelerator on to GTK.
     gtk_accel_groups_activate(G_OBJECT(window_), keyval, modifier);
   }
 }
 
@@ skipping 439 matching lines @@
 bool BrowserWindowGtk::ShouldShowWindowIcon() const {
   return browser_->SupportsWindowFeature(Browser::FEATURE_TITLEBAR);
 }
 
 void BrowserWindowGtk::AddFindBar(FindBarGtk* findbar) {
   gtk_box_pack_start(GTK_BOX(render_area_vbox_), findbar->widget(),
                      FALSE, FALSE, 0);
   gtk_box_reorder_child(GTK_BOX(render_area_vbox_), findbar->widget(), 0);
 }
 
+void BrowserWindowGtk::ResetCustomFrameCursor() {
+  if (!frame_cursor_)
+    return;
+
+  gdk_cursor_unref(frame_cursor_);
+  frame_cursor_ = NULL;
+  gdk_window_set_cursor(GTK_WIDGET(window_)->window, NULL);
+}
+
 // static
 BrowserWindowGtk* BrowserWindowGtk::GetBrowserWindowForNativeWindow(
     gfx::NativeWindow window) {
   if (window) {
     return static_cast<BrowserWindowGtk*>(
         g_object_get_data(G_OBJECT(window), kBrowserWindowKey));
   }
 
   return NULL;
 }
@@ skipping 39 matching lines @@
   g_signal_connect(window_, "configure-event",
                    G_CALLBACK(MainWindowConfigured), this);
   g_signal_connect(window_, "window-state-event",
                    G_CALLBACK(MainWindowStateChanged), this);
   g_signal_connect(window_, "map",
                    G_CALLBACK(MainWindowMapped), this);
   g_signal_connect(window_, "unmap",
                      G_CALLBACK(MainWindowUnMapped), this);
   g_signal_connect(window_, "key-press-event",
                    G_CALLBACK(OnKeyPress), browser_.get());
+  g_signal_connect(window_, "motion-notify-event",
+                   G_CALLBACK(OnMouseMoveEvent), this);
   g_signal_connect(window_, "button-press-event",
-                   G_CALLBACK(OnButtonPressEvent), browser_.get());
+                   G_CALLBACK(OnButtonPressEvent), this);
   g_signal_connect(window_, "focus-in-event",
                    G_CALLBACK(OnFocusIn), browser_.get());
 }
 
 void BrowserWindowGtk::InitWidgets() {
   // This vbox encompasses all of the widgets within the browser, including the
   // tabstrip and the content vbox.  The vbox is put in a floating container
   // (see gtk_floating_container.h) so we can position the
   // minimize/maximize/close buttons.  The floating container is then put in an
   // alignment so we can do custom frame drawing if the user turns of window
@@ skipping 122 matching lines @@
   }
 }
 
 void BrowserWindowGtk::UpdateCustomFrame() {
   bool enable = use_custom_frame_.GetValue() && !full_screen_;
   gtk_window_set_decorated(window_, !enable);
   titlebar_->UpdateCustomFrame(enable);
   UpdateWindowShape(bounds_.width(), bounds_.height());
   if (enable) {
     gtk_alignment_set_padding(GTK_ALIGNMENT(window_container_), 1,
-        kCustomFrameWidth, kCustomFrameWidth, kCustomFrameWidth);
+        kFrameBorderThickness, kFrameBorderThickness, kFrameBorderThickness);
   } else {
     gtk_alignment_set_padding(GTK_ALIGNMENT(window_container_), 0, 0, 0, 0);
   }
 }
 
 void BrowserWindowGtk::SaveWindowPosition() {
   // Browser::SaveWindowPlacement is used for session restore.
   if (browser_->ShouldSaveWindowPlacement())
     browser_->SaveWindowPlacement(bounds_, IsMaximized());
 
@@ skipping 23 matching lines @@
                                             guint keyval,
                                             GdkModifierType modifier,
                                             BrowserWindowGtk* browser_window) {
   int command_id = GetCommandId(keyval, modifier);
   browser_window->ExecuteBrowserCommand(command_id);
 
   return TRUE;
 }
 
 // static
+gboolean BrowserWindowGtk::OnMouseMoveEvent(GtkWidget* widget,
+    GdkEventMotion* event, BrowserWindowGtk* browser) {
+  // Update the cursor if we're on the custom frame border.
+  GdkWindowEdge edge;
+  bool has_hit_edge = browser->GetWindowEdge(static_cast<int>(event->x),
+      static_cast<int>(event->y), &edge);
+  GdkCursorType new_cursor = GDK_LAST_CURSOR;
+  if (has_hit_edge)
+    new_cursor = GdkWindowEdgeToGdkCursorType(edge);
+
+  GdkCursorType last_cursor = GDK_LAST_CURSOR;
+  if (browser->frame_cursor_)
+    last_cursor = browser->frame_cursor_->type;
+
+  if (last_cursor != new_cursor) {
+    if (browser->frame_cursor_) {
+      gdk_cursor_unref(browser->frame_cursor_);
+      browser->frame_cursor_ = NULL;
+    }
+    if (has_hit_edge) {
+      browser->frame_cursor_ = gdk_cursor_new(new_cursor);
+      gdk_window_set_cursor(GTK_WIDGET(browser->window_)->window,
+                            browser->frame_cursor_);
+    } else {
+      gdk_window_set_cursor(GTK_WIDGET(browser->window_)->window, NULL);
+    }
+  }
+  return FALSE;
+}
+
+// static
+gboolean BrowserWindowGtk::OnButtonPressEvent(GtkWidget* widget,
+    GdkEventButton* event, BrowserWindowGtk* browser) {
+  // Handle back/forward.
+  // TODO(jhawkins): Investigate the possibility of the button numbers being
+  // different for other mice.
+  if (event->button == 8) {
+    browser->browser_->GoBack(CURRENT_TAB);
+    return TRUE;
+  } else if (event->button == 9) {
+    browser->browser_->GoForward(CURRENT_TAB);
+    return TRUE;
+  }
+
+  // Handle left and right clicks.  In particular, we care about clicks in the
+  // custom frame border and clicks in the titlebar.
+  GdkWindowEdge edge;
+  bool has_hit_edge = browser->GetWindowEdge(static_cast<int>(event->x),
+      static_cast<int>(event->y), &edge);
+  // Ignore clicks that are in/below the tab strip.
+  gint tabstrip_y;
+  gtk_widget_get_pointer(browser->toolbar_->widget(), NULL, &tabstrip_y);
+  bool has_hit_titlebar = !browser->IsFullscreen() && (tabstrip_y < 0)
+      && !has_hit_edge;
+  if (event->button == 1) {
+    if (GDK_BUTTON_PRESS == event->type) {
+      if (has_hit_titlebar) {
+        gtk_window_begin_move_drag(browser->window_, event->button,
+                                   event->x_root, event->y_root, event->time);
+        return TRUE;
+      } else if (has_hit_edge) {
+        gtk_window_begin_resize_drag(browser->window_, edge, event->button,
+                                     event->x_root, event->y_root, event->time);
+        return TRUE;
+      }
+    } else if (GDK_2BUTTON_PRESS == event->type) {
+      if (has_hit_titlebar) {
+        // Maximize/restore on double click.
+        if (browser->IsMaximized()) {
+          gtk_window_unmaximize(browser->window_);
+        } else {
+          gtk_window_maximize(browser->window_);
+        }
+        return TRUE;
+      }
+    }
+  } else if (event->button == 3) {
+    if (has_hit_titlebar) {
+      browser->titlebar_->ShowContextMenu();
+      return TRUE;
+    }
+  }
+
+  return FALSE;  // Continue to propagate the event.
+}
+
+// static
 void BrowserWindowGtk::MainWindowMapped(GtkWidget* widget,
                                         BrowserWindowGtk* window) {
   // Map the X Window ID of the window to our window.
   XID xid = x11_util::GetX11WindowFromGtkWidget(widget);
   BrowserWindowGtk::xid_map_.insert(
       std::pair<XID, GtkWindow*>(xid, GTK_WINDOW(widget)));
 }
 
 // static
 void BrowserWindowGtk::MainWindowUnMapped(GtkWidget* widget,
@@ skipping 35 matching lines @@
 }
 
 bool BrowserWindowGtk::IsToolbarSupported() {
   return browser_->SupportsWindowFeature(Browser::FEATURE_TOOLBAR) ||
          browser_->SupportsWindowFeature(Browser::FEATURE_LOCATIONBAR);
 }
 
 bool BrowserWindowGtk::IsBookmarkBarSupported() {
   return browser_->SupportsWindowFeature(Browser::FEATURE_BOOKMARKBAR);
 }
+
+bool BrowserWindowGtk::GetWindowEdge(int x, int y, GdkWindowEdge* edge) {
+  if (!use_custom_frame_.GetValue())
+    return false;
+
+  if (IsMaximized() || IsFullscreen())
+    return false;
+
+  if (x < kFrameBorderThickness) {
+    // Left edge.
+    if (y < kResizeAreaCornerSize - kTopResizeAdjust) {
+      *edge = GDK_WINDOW_EDGE_NORTH_WEST;
+    } else if (y < bounds_.height() - kResizeAreaCornerSize) {
+      *edge = GDK_WINDOW_EDGE_WEST;
+    } else {
+      *edge = GDK_WINDOW_EDGE_SOUTH_WEST;
+    }
+    return true;
+  } else if (x < bounds_.width() - kFrameBorderThickness) {
+    if (y < kFrameBorderThickness - kTopResizeAdjust) {
+      // Top edge.
+      if (x < kResizeAreaCornerSize) {
+        *edge = GDK_WINDOW_EDGE_NORTH_WEST;
+      } else if (x < x < bounds_.width() - kResizeAreaCornerSize) {
+        *edge = GDK_WINDOW_EDGE_NORTH;
+      } else {
+        *edge = GDK_WINDOW_EDGE_NORTH_EAST;
+      }
+    } else if (y < bounds_.height() - kFrameBorderThickness) {
+      // Ignore the middle content area.
+      return false;
+    } else {
+      // Bottom edge.
+      if (x < kResizeAreaCornerSize) {
+        *edge = GDK_WINDOW_EDGE_SOUTH_WEST;
+      } else if (x < bounds_.width() - kResizeAreaCornerSize) {
+        *edge = GDK_WINDOW_EDGE_SOUTH;
+      } else {
+        *edge = GDK_WINDOW_EDGE_SOUTH_EAST;
+      }
+    }
+    return true;
+  } else {
+    // Right edge.
+    if (y < kResizeAreaCornerSize - kTopResizeAdjust) {
+      *edge = GDK_WINDOW_EDGE_NORTH_EAST;
+    } else if (y < bounds_.height() - kResizeAreaCornerSize) {
+      *edge = GDK_WINDOW_EDGE_EAST;
+    } else {
+      *edge = GDK_WINDOW_EDGE_SOUTH_EAST;
+    }
+    return true;
+  }
+  NOTREACHED();
+}