Draggable region support for frameless app window on GTK.

chrome/browser/ui/gtk/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/gtk/browser_window_gtk.h"
 
 #include <gdk/gdkkeysyms.h>
 
 #include <algorithm>
 #include <string>
@@ skipping 280 matching lines @@
        render_area_floating_container_(NULL),
        render_area_event_box_(NULL),
        toolbar_border_(NULL),
        browser_(browser),
        state_(GDK_WINDOW_STATE_WITHDRAWN),
        devtools_dock_side_(DEVTOOLS_DOCK_SIDE_BOTTOM),
        contents_hsplit_(NULL),
        contents_vsplit_(NULL),
        frame_cursor_(NULL),
        is_active_(!ui::ActiveWindowWatcherX::WMSupportsActivation()),
-       last_click_time_(0),
        show_state_after_show_(ui::SHOW_STATE_DEFAULT),
        suppress_window_raise_(false),
        accel_group_(NULL),
        fullscreen_exit_bubble_type_(
            FEB_TYPE_BROWSER_FULLSCREEN_EXIT_INSTRUCTION) {
 }
 
 BrowserWindowGtk::~BrowserWindowGtk() {
   ui::ActiveWindowWatcherX::RemoveObserver(this);
 
@@ skipping 1286 matching lines @@
   // set window_ to NULL, otherwise we will try to close the window again when
   // we call Close() in the destructor.
   //
   // We don't want to use DeleteSoon() here since it won't work on a nested pump
   // (like in UI tests).
   MessageLoop::current()->PostTask(
       FROM_HERE, base::Bind(&base::DeletePointer<BrowserWindowGtk>, this));
 }
 
 void BrowserWindowGtk::UnMaximize() {
-  gtk_window_unmaximize(window_);
-
-  // It can happen that you end up with a window whose restore size is the same
-  // as the size of the screen, so unmaximizing it merely remaximizes it due to
-  // the same WM feature that SetWindowSize() works around.  We try to detect
-  // this and resize the window to work around the issue.
-  if (bounds_.size() == restored_bounds_.size())
-    gtk_window_resize(window_, bounds_.width(), bounds_.height() - 1);
+  gtk_window_util::UnMaximize(window_, bounds_, restored_bounds_);
 }
 
 bool BrowserWindowGtk::CanClose() const {
   // You cannot close a frame for which there is an active originating drag
   // session.
   if (tabstrip_->IsDragSessionActive())
     return false;
 
   // Give beforeunload handlers the chance to cancel the close before we hide
   // the window below.
@@ skipping 641 matching lines @@
     // If the toolbar is not showing, use the location of web contents as the
     // boundary of where to ignore clicks.
     toolbar = render_area_vbox_;
   }
   gint toolbar_y;
   gtk_widget_get_pointer(toolbar, NULL, &toolbar_y);
   bool has_hit_titlebar = !IsFullscreen() && (toolbar_y < 0)
                           && !has_hit_edge;
   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),
-                                        static_cast<int>(event->y));
-
       // 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(gdk_window);
 
       if (has_hit_titlebar) {
-        return HandleTitleBarLeftMousePress(
-            event, last_click_time, last_click_position);
+        return HandleTitleBarLeftMousePress(event);
       } else if (has_hit_edge) {
         return HandleWindowEdgeLeftMousePress(window_, edge, event);
       }
     } else if (GDK_2BUTTON_PRESS == event->type) {
       if (has_hit_titlebar) {
         // Maximize/restore on double click.
         if (IsMaximized()) {
           UnMaximize();
         } else {
           gtk_window_maximize(window_);
@@ skipping 10 matching lines @@
     if (has_hit_titlebar) {
       titlebar_->ShowContextMenu(event);
       return TRUE;
     }
   }
 
   return FALSE;  // Continue to propagate the event.
 }
 
 bool BrowserWindowGtk::HandleTitleBarLeftMousePress(
-    GdkEventButton* event,
-    guint32 last_click_time,
-    gfx::Point last_click_position) {
-  // We want to start a move when the user single clicks, but not start a
-  // move when the user double clicks.  However, a double click sends the
-  // following GDK events: GDK_BUTTON_PRESS, GDK_BUTTON_RELEASE,
-  // GDK_BUTTON_PRESS, GDK_2BUTTON_PRESS, GDK_BUTTON_RELEASE.  If we
-  // start a gtk_window_begin_move_drag on the second GDK_BUTTON_PRESS,
-  // the call to gtk_window_maximize fails.  To work around this, we
-  // keep track of the last click and if it's going to be a double click,
-  // we don't call gtk_window_begin_move_drag.
-  static GtkSettings* settings = gtk_settings_get_default();
-  gint double_click_time = 250;
-  gint double_click_distance = 5;
-  g_object_get(G_OBJECT(settings),
-               "gtk-double-click-time", &double_click_time,
-               "gtk-double-click-distance", &double_click_distance,
-               NULL);
-
-  guint32 click_time = event->time - last_click_time;
-  int click_move_x = abs(event->x - last_click_position.x());
-  int click_move_y = abs(event->y - last_click_position.y());
-
-  if (click_time > static_cast<guint32>(double_click_time) ||
-      click_move_x > double_click_distance ||
-      click_move_y > double_click_distance) {
-    // Ignore drag requests if the window is the size of the screen.
-    // We do this to avoid triggering fullscreen mode in metacity
-    // (without the --no-force-fullscreen flag) and in compiz (with
-    // Legacy Fullscreen Mode enabled).
-    if (!BoundsMatchMonitorSize()) {
-      gtk_window_begin_move_drag(window_, event->button,
-                                 static_cast<gint>(event->x_root),
-                                 static_cast<gint>(event->y_root),
-                                 event->time);
-    }
-    return TRUE;
-  }
-  return FALSE;
+    GdkEventButton* event) {
+  return gtk_window_util::HandleTitleBarLeftMousePress(window_, bounds_, event);
 }
 
 bool BrowserWindowGtk::HandleWindowEdgeLeftMousePress(
     GtkWindow* window,
     GdkWindowEdge edge,
     GdkEventButton* event) {
   gtk_window_begin_resize_drag(window, edge, event->button,
                                static_cast<gint>(event->x_root),
                                static_cast<gint>(event->y_root),
                                event->time);
@@ skipping 118 matching lines @@
 
   NOTREACHED();
   return false;
 }
 
 bool BrowserWindowGtk::UseCustomFrame() const {
   // We don't use the custom frame for app mode windows or app window popups.
   return use_custom_frame_pref_.GetValue() && !browser_->is_app();
 }
 
-bool BrowserWindowGtk::BoundsMatchMonitorSize() {
-  // A screen can be composed of multiple monitors.
-  GdkScreen* screen = gtk_window_get_screen(window_);
-  gint monitor_num = gdk_screen_get_monitor_at_window(screen,
-      gtk_widget_get_window(GTK_WIDGET(window_)));
-
-  GdkRectangle monitor_size;
-  gdk_screen_get_monitor_geometry(screen, monitor_num, &monitor_size);
-  return bounds_.size() == gfx::Size(monitor_size.width, monitor_size.height);
-}
-
 void BrowserWindowGtk::PlaceBookmarkBar(bool is_floating) {
   TRACE_EVENT0("ui::gtk", "BrowserWindowGtk::PlaceBookmarkBar");
 
   GtkWidget* target_parent = NULL;
   if (!is_floating) {
     // Place the bookmark bar at the end of |window_vbox_|; this happens after
     // we have placed the render area at the end of |window_vbox_| so we will
     // be above the render area.
     target_parent = window_vbox_;
   } else {
@@ skipping 32 matching lines @@
           wm_type == ui::WM_OPENBOX ||
           wm_type == ui::WM_XFWM4);
 }
 
 // static
 BrowserWindow* BrowserWindow::CreateBrowserWindow(Browser* browser) {
   BrowserWindowGtk* browser_window_gtk = new BrowserWindowGtk(browser);
   browser_window_gtk->Init();
   return browser_window_gtk;
 }