Draggable region support for frameless app window on GTK.

chrome/browser/ui/gtk/extensions/shell_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/gtk/extensions/shell_window_gtk.h"
 
 #include "chrome/browser/profiles/profile.h"
+#include "chrome/browser/ui/gtk/gtk_window_util.h"
+#include "chrome/common/extensions/draggable_region.h"
 #include "chrome/common/extensions/extension.h"
 #include "content/public/browser/render_view_host.h"
 #include "content/public/browser/render_widget_host_view.h"
 #include "content/public/browser/web_contents.h"
 #include "content/public/browser/web_contents_view.h"
 #include "ui/base/x/active_window_watcher_x.h"
 #include "ui/gfx/rect.h"
 
 ShellWindowGtk::ShellWindowGtk(Profile* profile,
                                const extensions::Extension* extension,
                                const GURL& url,
                                const ShellWindow::CreateParams& params)
     : ShellWindow(profile, extension, url),
       state_(GDK_WINDOW_STATE_WITHDRAWN),
       is_active_(!ui::ActiveWindowWatcherX::WMSupportsActivation()),
-      content_thinks_its_fullscreen_(false) {
+      content_thinks_its_fullscreen_(false),
+      frameless_(params.frame == ShellWindow::CreateParams::FRAME_NONE) {
   window_ = GTK_WINDOW(gtk_window_new(GTK_WINDOW_TOPLEVEL));
 
   gfx::NativeView native_view =
       web_contents()->GetView()->GetNativeView();
   gtk_container_add(GTK_CONTAINER(window_), native_view);
 
   gtk_window_set_default_size(
       window_, params.bounds.width(), params.bounds.height());
 
   // Hide titlebar when {frame: 'none'} specified on ShellWindow.
-  if (params.frame == ShellWindow::CreateParams::FRAME_NONE)
+  if (frameless_)
     gtk_window_set_decorated(window_, false);
 
   int min_width = params.minimum_size.width();
   int min_height = params.minimum_size.height();
   int max_width = params.maximum_size.width();
   int max_height = params.maximum_size.height();
   GdkGeometry hints;
   int hints_mask = 0;
   if (min_width || min_height) {
     hints.min_height = min_height;
     hints.min_width = min_width;
     hints_mask |= GDK_HINT_MIN_SIZE;
   }
   if (max_width || max_height) {
     hints.max_height = max_height ? max_height : G_MAXINT;
     hints.max_width = max_width ? max_width : G_MAXINT;
     hints_mask |= GDK_HINT_MAX_SIZE;
   }
   if (hints_mask) {
     gtk_window_set_geometry_hints(
         window_,
         GTK_WIDGET(window_),
         &hints,
         static_cast<GdkWindowHints>(hints_mask));
   }
 
+  // In some (older) versions of compiz, raising top-level windows when they
+  // are partially off-screen causes them to get snapped back on screen, not
+  // always even on the current virtual desktop.  If we are running under
+  // compiz, suppress such raises, as they are not necessary in compiz anyway.
+  if (ui::GuessWindowManager() == ui::WM_COMPIZ)
+    suppress_window_raise_ = true;
+
   // TODO(mihaip): Mirror contents of <title> tag in window title
   gtk_window_set_title(window_, extension->name().c_str());
 
   g_signal_connect(window_, "delete-event",
                    G_CALLBACK(OnMainWindowDeleteEventThunk), this);
   g_signal_connect(window_, "configure-event",
                    G_CALLBACK(OnConfigureThunk), this);
   g_signal_connect(window_, "window-state-event",
                    G_CALLBACK(OnWindowStateThunk), this);
+  if (frameless_) {
+    g_signal_connect(window_, "button-press-event",
+                     G_CALLBACK(OnButtonPressThunk), this);
+  }
 
   ui::ActiveWindowWatcherX::AddObserver(this);
 }
 
 ShellWindowGtk::~ShellWindowGtk() {
   ui::ActiveWindowWatcherX::RemoveObserver(this);
 }
 
 bool ShellWindowGtk::IsActive() const {
   return is_active_;
@@ skipping 121 matching lines @@
       !(state_ & GDK_WINDOW_STATE_FULLSCREEN)) {
     content_thinks_its_fullscreen_ = false;
     content::RenderViewHost* rvh = web_contents()->GetRenderViewHost();
     if (rvh)
       rvh->ExitFullscreen();
   }
 
   return FALSE;
 }
 
+gboolean ShellWindowGtk::OnButtonPress(GtkWidget* widget,
+                                       GdkEventButton* event) {
+  if (!draggable_region_.isEmpty() &&
+      draggable_region_.contains(event->x, event->y)) {
+    if (event->button == 1) {
+      if (GDK_BUTTON_PRESS == event->type) {
+        guint32 last_click_time = last_click_time_;
+        gfx::Point last_click_position = last_click_position_;
+        last_click_time_ = event->time;
+        last_click_position_ = gfx::Point(static_cast<int>(event->x),

[Evan Stade, 2012/08/15 21:20:40]

you could share more code if you passed &last_click_time_ and
&last_click_position_ into the function, and let the function do the updating.

+                                          static_cast<int>(event->y));
+
+        if (!suppress_window_raise_)
+          gdk_window_raise(GTK_WIDGET(widget)->window);
+
+        return gtk_window_util::HandleTitleBarLeftMousePress(GTK_WINDOW(widget),
+            bounds_, event, last_click_time, last_click_position);
+      } else if (event->type == GDK_2BUTTON_PRESS) {

[Evan Stade, 2012/08/15 21:20:40]

nit: it's weird that the if and the else if cases have the order of the operands
switched around.

+        bool is_maximized_ = gdk_window_get_state(GTK_WIDGET(widget)->window) &

[Evan Stade, 2012/08/15 21:20:40]

first, local variables should not have final underscores

second, this doesn't really seem like a great use of the ternary operator
because the code inside the two conditions does not overlap at all.

+                             GDK_WINDOW_STATE_MAXIMIZED;
+        is_maximized_ ? gtk_window_unmaximize(GTK_WINDOW(widget)) :
+                        gtk_window_maximize(GTK_WINDOW(widget));
+        return TRUE;
+      }
+    } else if (event->button == 2) {
+      gdk_window_lower(GTK_WIDGET(widget)->window);
+      return TRUE;
+    }
+  }
+
+  return FALSE;
+}
+
 void ShellWindowGtk::SetFullscreen(bool fullscreen) {
   content_thinks_its_fullscreen_ = fullscreen;
   if (fullscreen)
     gtk_window_fullscreen(window_);
   else
     gtk_window_unfullscreen(window_);
 }
 
 bool ShellWindowGtk::IsFullscreenOrPending() const {
   return content_thinks_its_fullscreen_;
 }
 
+void ShellWindowGtk::UpdateDraggableRegions(
+    const std::vector<extensions::DraggableRegion>& regions) {
+  // Draggable region is not supported for non-frameless window.
+  if (!frameless_)
+    return;
+
+  SkRegion draggable_region;
+
+  // By default, the whole window is draggable.
+  gfx::Rect bounds = GetBounds();
+  draggable_region.op(0, 0, bounds.right(), bounds.bottom(),
+                      SkRegion::kUnion_Op);
+
+  // Exclude those designated as non-draggable.
+  for (std::vector<extensions::DraggableRegion>::const_iterator iter =
+           regions.begin();
+       iter != regions.end(); ++iter) {
+    const extensions::DraggableRegion& region = *iter;
+    draggable_region.op(region.bounds.x(),
+                        region.bounds.y(),
+                        region.bounds.right(),
+                        region.bounds.bottom(),
+                        SkRegion::kDifference_Op);
+  }
+
+  draggable_region_ = draggable_region;
+}
+
 // static
 ShellWindow* ShellWindow::CreateImpl(Profile* profile,
                                      const extensions::Extension* extension,
                                      const GURL& url,
                                      const ShellWindow::CreateParams& params) {
   return new ShellWindowGtk(profile, extension, url, params);
 }