Linux: make frameless window resizable

rogerwang · rogerwang · commit 1ec4bec2eb87 · 2013-10-23T20:47:18.000+08:00
Merge upstream patch from #169010; Fix nwjs#142
diff --git a/src/browser/native_window_gtk.cc b/src/browser/native_window_gtk.cc
@@ -51,7 +51,10 @@ const double kGtkCursorBlinkCycleFactor = 2000.0;
 NativeWindowGtk::NativeWindowGtk(const base::WeakPtr<content::Shell>& shell,
                                  base::DictionaryValue* manifest)
     : NativeWindow(shell, manifest),
-      content_thinks_its_fullscreen_(false) {
+      state_(GDK_WINDOW_STATE_WITHDRAWN),
+      content_thinks_its_fullscreen_(false),
+      frame_cursor_(NULL),
+      resizable_(true) {
   window_ = GTK_WINDOW(gtk_window_new(GTK_WINDOW_TOPLEVEL));
 
   vbox_ = gtk_vbox_new(FALSE, 0);
@@ -124,6 +127,9 @@ NativeWindowGtk::NativeWindowGtk(const base::WeakPtr<content::Shell>& shell,
   if (!has_frame_) {
     g_signal_connect(window_, "button-press-event",
                      G_CALLBACK(OnButtonPressThunk), this);
+
+    g_signal_connect(window_, "motion-notify-event",
+                     G_CALLBACK(OnMouseMoveEventThunk), this);
   }
 
   SetWebKitColorStyle();
@@ -193,6 +199,14 @@ bool NativeWindowGtk::IsFullscreen() {
   return content_thinks_its_fullscreen_;
 }
 
+bool NativeWindowGtk::IsMaximized() const {
+  return (state_ & GDK_WINDOW_STATE_MAXIMIZED);
+}
+
+bool NativeWindowGtk::IsMinimized() const {
+  return (state_ & GDK_WINDOW_STATE_ICONIFIED);
+}
+
 void NativeWindowGtk::SetSize(const gfx::Size& size) {
   gtk_window_util::SetWindowSize(window_, size);
 }
@@ -225,6 +239,7 @@ void NativeWindowGtk::SetMaximumSize(int width, int height) {
 }
 
 void NativeWindowGtk::SetResizable(bool resizable) {
+  resizable_ = resizable;
   // Should request widget size after setting unresizable, otherwise the 
   // window will shrink to a very small size.
   if (resizable == false) {
@@ -514,6 +529,8 @@ gboolean NativeWindowGtk::OnFocusOut(GtkWidget* window, GdkEventFocus*) {
 // Window state has changed.
 gboolean NativeWindowGtk::OnWindowState(GtkWidget* window,
                                         GdkEventWindowState* event) {
+  state_ = event->new_window_state;
+
   switch (event->changed_mask) {
     case GDK_WINDOW_STATE_ICONIFIED:
       if (shell()) {
@@ -562,23 +579,107 @@ gboolean NativeWindowGtk::OnWindowDeleteEvent(GtkWidget* widget,
   return FALSE;
 }
 
+bool NativeWindowGtk::GetWindowEdge(int x, int y, GdkWindowEdge* edge) {
+  if (has_frame_)
+    return false;
+
+  if (IsMaximized() || IsFullscreen())
+    return false;
+
+  return gtk_window_util::GetWindowEdge(GetBounds().size(), 0, x, y, edge);
+}
+
+gboolean NativeWindowGtk::OnMouseMoveEvent(GtkWidget* widget,
+                                           GdkEventMotion* event) {
+  if (has_frame_) {
+    // Reset the cursor.
+    if (frame_cursor_) {
+      frame_cursor_ = NULL;
+      gdk_window_set_cursor(gtk_widget_get_window(GTK_WIDGET(window_)), NULL);
+    }
+    return FALSE;
+  }
+
+  if (!resizable_)
+    return FALSE;
+
+  int win_x, win_y;
+  GdkWindow* gdk_window = gtk_widget_get_window(GTK_WIDGET(window_));
+  gdk_window_get_origin(gdk_window, &win_x, &win_y);
+  gfx::Point point(static_cast<int>(event->x_root - win_x),
+                   static_cast<int>(event->y_root - win_y));
+
+  // Update the cursor if we're on the custom frame border.
+  GdkWindowEdge edge;
+  bool has_hit_edge = GetWindowEdge(point.x(), point.y(), &edge);
+  GdkCursorType new_cursor = GDK_LAST_CURSOR;
+  if (has_hit_edge)
+    new_cursor = gtk_window_util::GdkWindowEdgeToGdkCursorType(edge);
+
+  GdkCursorType last_cursor = GDK_LAST_CURSOR;
+  if (frame_cursor_)
+    last_cursor = frame_cursor_->type;
+
+  if (last_cursor != new_cursor) {
+    frame_cursor_ = has_hit_edge ? gfx::GetCursor(new_cursor) : NULL;
+    gdk_window_set_cursor(gtk_widget_get_window(GTK_WIDGET(window_)),
+                          frame_cursor_);
+  }
+  return FALSE;
+}
+
 // Capture mouse click on window.
 gboolean NativeWindowGtk::OnButtonPress(GtkWidget* widget,
                                         GdkEventButton* event) {
-  if (!draggable_region_.isEmpty() &&
-      draggable_region_.contains(event->x, event->y)) {
-    if (event->button == 1 && GDK_BUTTON_PRESS == event->type) {
-      if (!suppress_window_raise_)
+  DCHECK(!has_frame_);
+  // Make the button press coordinate relative to the browser window.
+  int win_x, win_y;
+  GdkWindow* gdk_window = gtk_widget_get_window(GTK_WIDGET(window_));
+  gdk_window_get_origin(gdk_window, &win_x, &win_y);
+
+  GdkWindowEdge edge;
+  gfx::Point point(static_cast<int>(event->x_root - win_x),
+                   static_cast<int>(event->y_root - win_y));
+  bool has_hit_edge = resizable_ && GetWindowEdge(point.x(), point.y(), &edge);
+  bool has_hit_titlebar =
+      !draggable_region_.isEmpty() && draggable_region_.contains(event->x, event->y);
+
+  if (event->button == 1) {
+    if (GDK_BUTTON_PRESS == event->type) {
+      // Raise the window after a click on either the titlebar or the border to
+      // match the behavior of most window managers, unless that behavior has
+      // been suppressed.
+      if ((has_hit_titlebar || has_hit_edge) && !suppress_window_raise_)
         gdk_window_raise(GTK_WIDGET(widget)->window);
 
-      return gtk_window_util::HandleTitleBarLeftMousePress(
-          GTK_WINDOW(widget), GetBounds(), event);
-    } else if (event->button == 2) {
-      gdk_window_lower(GTK_WIDGET(widget)->window);
-      return TRUE;
+      if (has_hit_edge) {
+        gtk_window_begin_resize_drag(window_, edge, event->button,
+                                     static_cast<gint>(event->x_root),
+                                     static_cast<gint>(event->y_root),
+                                     event->time);
+        return TRUE;
+      } else if (has_hit_titlebar) {
+        return gtk_window_util::HandleTitleBarLeftMousePress(
+            window_, GetBounds(), event);
+      }
+    } else if (GDK_2BUTTON_PRESS == event->type) {
+      if (has_hit_titlebar && resizable_) {
+        // Maximize/restore on double click.
+        if (IsMaximized()) {
+          gtk_window_unmaximize(window_);
+          //gtk_window_util::UnMaximize(GTK_WINDOW(widget),
+          //    GetBounds(), restored_bounds_);
+        } else {
+          gtk_window_maximize(window_);
+        }
+        return TRUE;
+      }
     }
+  } else if (event->button == 2) {
+    if (has_hit_titlebar || has_hit_edge)
+      gdk_window_lower(gdk_window);
+    return TRUE;
   }
-
   return FALSE;
 }
 
diff --git a/src/browser/native_window_gtk.h b/src/browser/native_window_gtk.h
@@ -22,6 +22,7 @@
 #define CONTENT_NW_SRC_BROWSER_NATIVE_WINDOW_GTK_H_
 
 #include <gtk/gtk.h>
+#include <gdk/gdk.h>
 
 #include "content/nw/src/browser/native_window.h"
 #include "third_party/skia/include/core/SkRegion.h"
@@ -70,6 +71,8 @@ class NativeWindowGtk : public NativeWindow {
 
   GtkWindow* window() const { return window_; }
 
+  bool IsMinimized() const;
+  bool IsMaximized() const;
  protected:
   // NativeWindow implementation.
   virtual void AddToolbar() OVERRIDE;
@@ -90,6 +93,11 @@ class NativeWindowGtk : public NativeWindow {
   // Get the position and size of the current window.
   gfx::Rect GetBounds();
 
+  // If the point (|x|, |y|) is within the resize border area of the window,
+  // returns true and sets |edge| to the appropriate GdkWindowEdge value.
+  // Otherwise, returns false.
+  bool GetWindowEdge(int x, int y, GdkWindowEdge* edge);
+
   CHROMEGTK_CALLBACK_0(NativeWindowGtk, void, OnBackButtonClicked);
   CHROMEGTK_CALLBACK_0(NativeWindowGtk, void, OnForwardButtonClicked);
   CHROMEGTK_CALLBACK_0(NativeWindowGtk, void, OnRefreshStopButtonClicked);
@@ -106,6 +114,8 @@ class NativeWindowGtk : public NativeWindow {
                        GdkEvent*);
   CHROMEGTK_CALLBACK_1(NativeWindowGtk, gboolean, OnButtonPress,
                        GdkEventButton*);
+  CHROMEGTK_CALLBACK_1(NativeWindowGtk, gboolean, OnMouseMoveEvent,
+                       GdkEventMotion*);
 
   GtkWindow* window_;
   GtkWidget* toolbar_;
@@ -116,6 +126,7 @@ class NativeWindowGtk : public NativeWindow {
   GtkToolItem* refresh_stop_button_;
   GtkToolItem* devtools_button_;
   GtkToolItem* dev_reload_button_;
+  GdkWindowState state_;
 
   // True if the RVH is in fullscreen mode. The window may not actually be in
   // fullscreen, however: some WMs don't support fullscreen.
@@ -129,6 +140,13 @@ class NativeWindowGtk : public NativeWindow {
   // bar or window border.  This is to work around a compiz bug.
   bool suppress_window_raise_;
 
+  // The current window cursor.  We set it to a resize cursor when over the
+  // custom frame border.  We set it to NULL if we want the default cursor.
+  GdkCursor* frame_cursor_;
+
+  // True if the window should be resizable by the user.
+  bool resizable_;
+
   DISALLOW_COPY_AND_ASSIGN(NativeWindowGtk);
 };
 
