Linux: middle-click to navigate

chrome/browser/tab_contents/tab_contents_view_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/tab_contents/tab_contents_view_gtk.h"
 
 #include <gdk/gdk.h>
 #include <gtk/gtk.h>
 
 #include "base/string_util.h"
@@ skipping 10 matching lines @@
 #include "chrome/browser/renderer_host/render_view_host.h"
 #include "chrome/browser/renderer_host/render_view_host_factory.h"
 #include "chrome/browser/renderer_host/render_widget_host_view_gtk.h"
 #include "chrome/browser/tab_contents/interstitial_page.h"
 #include "chrome/browser/tab_contents/render_view_context_menu_gtk.h"
 #include "chrome/browser/tab_contents/tab_contents.h"
 #include "chrome/browser/tab_contents/tab_contents_delegate.h"
 #include "chrome/common/gtk_util.h"
 #include "chrome/common/notification_source.h"
 #include "chrome/common/notification_type.h"
+#include "webkit/api/public/WebInputEvent.h"
+
+using WebKit::WebInputEvent;
+using WebKit::WebMouseEvent;
 
 namespace {
 
 // TODO(erg): I have no idea how to progromatically figure out how wide the
 // vertical scrollbar is. Hack it with a hardcoded value for now.
 const int kScrollbarWidthHack = 25;
 
 // Called when the content view gtk widget is tabbed to, or after the call to
 // gtk_widget_child_focus() in TakeFocus(). We return true
 // and grab focus if we don't have it. The call to
@@ skipping 60 matching lines @@
 
 // static
 TabContentsView* TabContentsView::Create(TabContents* tab_contents) {
   return new TabContentsViewGtk(tab_contents);
 }
 
 TabContentsViewGtk::TabContentsViewGtk(TabContents* tab_contents)
     : TabContentsView(tab_contents),
       floating_(gtk_floating_container_new()),
       fixed_(gtk_fixed_new()),
-      popup_view_(NULL) {
+      popup_view_(NULL),
+      outstanding_clipboard_contents_request_(NULL) {
   g_signal_connect(fixed_, "size-allocate",
                    G_CALLBACK(OnSizeAllocate), this);
   g_signal_connect(floating_.get(), "set-floating-position",
                    G_CALLBACK(OnSetFloatingPosition), this);
 
   gtk_container_add(GTK_CONTAINER(floating_.get()), fixed_);
   gtk_widget_show(fixed_);
   gtk_widget_show(floating_.get());
   registrar_.Add(this, NotificationType::TAB_CONTENTS_CONNECTED,
                  Source<TabContents>(tab_contents));
 }
 
 TabContentsViewGtk::~TabContentsViewGtk() {
   floating_.Destroy();
+  if (outstanding_clipboard_contents_request_)
+    outstanding_clipboard_contents_request_->Cancel();
 }
 
 void TabContentsViewGtk::AttachBlockedPopupView(
     BlockedPopupContainerViewGtk* popup_view) {
   DCHECK(popup_view_ == NULL);
   popup_view_ = popup_view;
   gtk_floating_container_add_floating(GTK_FLOATING_CONTAINER(floating_.get()),
                                       popup_view->widget());
 }
 
@@ skipping 180 matching lines @@
   if (event.type == WebKit::WebInputEvent::Char)
     return;
 
   BrowserWindowGtk* browser_window =
       BrowserWindowGtk::GetBrowserWindowForNativeWindow(window);
   DCHECK(browser_window);
   browser_window->HandleAccelerator(event.os_event->keyval,
       static_cast<GdkModifierType>(event.os_event->state));
 }
 
+TabContentsViewGtk::ClipboardRequestCallback::ClipboardRequestCallback(
+    TabContentsViewGtk* tab_contents_view)
+    : tab_contents_view_(tab_contents_view) {
+}
+
+void TabContentsViewGtk::ClipboardRequestCallback::Cancel() {
+  tab_contents_view_ = NULL;
+}
+
+void TabContentsViewGtk::ClipboardRequestCallback::Callback(
+    const gchar* utf8_string) {
+  if (tab_contents_view_)
+    tab_contents_view_->ClipboardContentsReceived(utf8_string);
+
+  delete this;
+}
+
+static void ClipboardCallback(GtkClipboard *clipboard,
+                              const gchar *utf8_string,
+                              gpointer arg) {
+  TabContentsViewGtk::ClipboardRequestCallback* callback =
+    reinterpret_cast<TabContentsViewGtk::ClipboardRequestCallback*>(arg);
+  callback->Callback(utf8_string);
+}
+
+void TabContentsViewGtk::HandleMouseButtonEvent(const WebMouseEvent* event) {
+  // We only trigger on middle-button up with Control held down.
+  if (event->type != WebInputEvent::MouseUp ||
+      event->button != WebMouseEvent::ButtonMiddle ||
+      (event->modifiers & WebInputEvent::ControlKey) == 0 ||
+      event->modifiers & WebInputEvent::ShiftKey ||
+      event->modifiers & WebInputEvent::AltKey ||
+      event->modifiers & WebInputEvent::MetaKey ||
+      outstanding_clipboard_contents_request_) {
+    return;
+  }
+
+  outstanding_clipboard_contents_request_ = new ClipboardRequestCallback(this);
+  GtkClipboard* x_clipboard = gtk_clipboard_get(GDK_SELECTION_PRIMARY);
+  gtk_clipboard_request_text(x_clipboard, ClipboardCallback,
+                             outstanding_clipboard_contents_request_);
+}
+
+void TabContentsViewGtk::ClipboardContentsReceived(const gchar* utf8_contents) {
+  outstanding_clipboard_contents_request_ = NULL;
+  if (!utf8_contents)
+    return;
+
+  GURL target(utf8_contents);
+  if (!target.is_valid())
+    target = GURL(std::string("http://") + utf8_contents);
+  if (!target.is_valid())
+    return;
+
+  tab_contents()->RequestOpenURL(target, GURL() /* referrer */,
+                                 NEW_FOREGROUND_TAB);
+}
+
 void TabContentsViewGtk::Observe(NotificationType type,
                                  const NotificationSource& source,
                                  const NotificationDetails& details) {
   switch (type.value) {
     case NotificationType::TAB_CONTENTS_CONNECTED: {
       // No need to remove the SadTabGtk's widget from the container since
       // the new RenderWidgetHostViewGtk instance already removed all the
       // vbox's children.
       sad_tab_.reset();
       break;
@@ skipping 98 matching lines @@
     gtk_container_child_set_property(GTK_CONTAINER(floating_container),
                                      widget, "x", &value);
 
     int child_y = std::max(half_view_height - (requisition.height / 2), 0);
     g_value_set_int(&value, child_y);
     gtk_container_child_set_property(GTK_CONTAINER(floating_container),
                                      widget, "y", &value);
     g_value_unset(&value);
   }
 }