chrome/browser/ui/gtk/gtk_window_util.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/gtk_window_util.h"

#include <dlfcn.h>
#include "content/public/browser/render_view_host.h"
#include "content/public/browser/web_contents.h"

using content::RenderWidgetHost;
using content::WebContents;

namespace gtk_window_util {

// Keep track of the last click time and the last click position so we can
// filter out extra GDK_BUTTON_PRESS events when a double click happens.
static guint32 last_click_time;
static int last_click_x;
static int last_click_y;

// Performs Cut/Copy/Paste operation on the |window|.
// If the current render view is focused, then just call the specified |method|
// against the current render view host, otherwise emit the specified |signal|
// against the focused widget.
// TODO(suzhe): This approach does not work for plugins.
void DoCutCopyPaste(GtkWindow* window,
                    WebContents* web_contents,
                    void (RenderWidgetHost::*method)(),
                    const char* signal) {
  GtkWidget* widget = gtk_window_get_focus(window);
  if (widget == NULL)
    return;  // Do nothing if no focused widget.

  if (web_contents && widget == web_contents->GetContentNativeView()) {
    (web_contents->GetRenderViewHost()->*method)();
  } else {
    guint id;
    if ((id = g_signal_lookup(signal, G_OBJECT_TYPE(widget))) != 0)
      g_signal_emit(widget, id, 0);
  }
}

void DoCut(GtkWindow* window, WebContents* web_contents) {
  DoCutCopyPaste(window, web_contents,
                 &RenderWidgetHost::Cut, "cut-clipboard");
}

void DoCopy(GtkWindow* window, WebContents* web_contents) {
  DoCutCopyPaste(window, web_contents,
                 &RenderWidgetHost::Copy, "copy-clipboard");
}

void DoPaste(GtkWindow* window, WebContents* web_contents) {
  DoCutCopyPaste(window, web_contents,
                 &RenderWidgetHost::Paste, "paste-clipboard");
}

// Ubuntu patches their version of GTK+ so that there is always a
// gripper in the bottom right corner of the window. We dynamically
// look up this symbol because it's a non-standard Ubuntu extension to
// GTK+. We always need to disable this feature since we can't
// communicate this to WebKit easily.
typedef void (*gtk_window_set_has_resize_grip_func)(GtkWindow*, gboolean);
gtk_window_set_has_resize_grip_func gtk_window_set_has_resize_grip_sym;

void DisableResizeGrip(GtkWindow* window) {
  static bool resize_grip_looked_up = false;
  if (!resize_grip_looked_up) {
    resize_grip_looked_up = true;
    gtk_window_set_has_resize_grip_sym =
        reinterpret_cast<gtk_window_set_has_resize_grip_func>(
            dlsym(NULL, "gtk_window_set_has_resize_grip"));
  }
  if (gtk_window_set_has_resize_grip_sym)
    gtk_window_set_has_resize_grip_sym(window, 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;
}

bool BoundsMatchMonitorSize(GtkWindow* window, gfx::Rect bounds) {
  // 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);
}

bool HandleTitleBarLeftMousePress(
    GtkWindow* window,
    const gfx::Rect& bounds,
    GdkEventButton* event) {
  // 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.
  DCHECK(event->type == GDK_BUTTON_PRESS);
  DCHECK(event->button == 1);

  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_x);
  int click_move_y = abs(event->y - last_click_y);

  last_click_time = event->time;
  last_click_x = static_cast<int>(event->x);
  last_click_y = static_cast<int>(event->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(window, bounds)) {
      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;
}

void UnMaximize(GtkWindow* window,
                const gfx::Rect& bounds,
                const gfx::Rect& restored_bounds) {
  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);
}

}  // namespace gtk_window_util