Linux: middle-click to navigate

webkit/glue/webview_impl.cc

 /*
 * Copyright 2007 Google Inc. All Rights Reserved.
 *
 * Portions Copyright (C) 2006 Apple Computer, Inc.  All rights reserved.
 *
 * ***** BEGIN LICENSE BLOCK *****
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
@@ skipping 412 matching lines @@
   // ignore it.
   if (!main_frame() || !main_frame()->frameview())
     return;
 
   delegate_->UpdateTargetURL(this, GURL());
 
   main_frame()->frame()->eventHandler()->handleMouseMoveEvent(
       MakePlatformMouseEvent(main_frame()->frameview(), event));
 }
 
-void WebViewImpl::MouseDown(const WebMouseEvent& event) {
+bool WebViewImpl::MouseDown(const WebMouseEvent& event) {
   if (!main_frame() || !main_frame()->frameview())
-    return;
+    return false;
 
   last_mouse_down_point_ = gfx::Point(event.x, event.y);
 
   // If a text field that has focus is clicked again, we should display the
   // autocomplete popup.
   RefPtr<Node> clicked_node;
   if (event.button == WebMouseEvent::ButtonLeft) {
     RefPtr<Node> focused_node = GetFocusedNode();
     if (focused_node.get() &&
         webkit_glue::NodeToHTMLInputElement(focused_node.get())) {
       IntPoint point(event.x, event.y);
       HitTestResult result(point);
       result = page_->mainFrame()->eventHandler()->hitTestResultAtPoint(point,
                                                                         false);
       if (result.innerNonSharedNode() == focused_node) {
         // Already focused text field was clicked, let's remember this.  If
         // focus has not changed after the mouse event is processed, we'll
         // trigger the autocomplete.
         clicked_node = focused_node;
       }
     }
   }
 
-  main_frame()->frame()->eventHandler()->handleMousePressEvent(
+  bool processed = main_frame()->frame()->eventHandler()->handleMousePressEvent(
       MakePlatformMouseEvent(main_frame()->frameview(), event));
 
   if (clicked_node.get() && clicked_node == GetFocusedNode()) {
     // Focus has not changed, show the autocomplete popup.
     static_cast<EditorClientImpl*>(page_->editorClient())->
         ShowFormAutofillForNode(clicked_node.get());
   }
 
   // Dispatch the contextmenu event regardless of if the click was swallowed.
   // On Windows, we handle it on mouse up, not down.
 #if defined(OS_MACOSX)
   if (event.button == WebMouseEvent::ButtonRight ||
       (event.button == WebMouseEvent::ButtonLeft &&
        event.modifiers & WebMouseEvent::ControlKey)) {
     MouseContextMenu(event);
+    return true;
   }
 #elif defined(OS_LINUX)
-  if (event.button == WebMouseEvent::ButtonRight)
+  if (event.button == WebMouseEvent::ButtonRight) {
     MouseContextMenu(event);
+    return true;
+  }
 #endif
+
+  return processed;
 }
 
 void WebViewImpl::MouseContextMenu(const WebMouseEvent& event) {
   if (!main_frame() || !main_frame()->frameview())
     return;
 
   page_->contextMenuController()->clearContextMenu();
 
   MakePlatformMouseEvent pme(main_frame()->frameview(), event);
 
   // Find the right target frame. See issue 1186900.
   HitTestResult result = HitTestResultForWindowPos(pme.pos());
   Frame* target_frame;
   if (result.innerNonSharedNode())
     target_frame = result.innerNonSharedNode()->document()->frame();
   else
     target_frame = page_->focusController()->focusedOrMainFrame();
 
 #if defined(OS_WIN)
   target_frame->view()->setCursor(pointerCursor());
 #endif
 
   context_menu_allowed_ = true;
   target_frame->eventHandler()->sendContextMenuEvent(pme);
   context_menu_allowed_ = false;
   // Actually showing the context menu is handled by the ContextMenuClient
   // implementation...
 }
 
-void WebViewImpl::MouseUp(const WebMouseEvent& event) {
+bool WebViewImpl::MouseUp(const WebMouseEvent& event) {
   if (!main_frame() || !main_frame()->frameview())
-    return;
+    return false;
 
   MouseCaptureLost();
-  main_frame()->frame()->eventHandler()->handleMouseReleaseEvent(
-      MakePlatformMouseEvent(main_frame()->frameview(), event));
+  bool processed =
+      main_frame()->frame()->eventHandler()->handleMouseReleaseEvent(
+          MakePlatformMouseEvent(main_frame()->frameview(), event));
 
 #if defined(OS_WIN)
   // Dispatch the contextmenu event regardless of if the click was swallowed.
   // On Mac/Linux, we handle it on mouse down, not up.
-  if (event.button == WebMouseEvent::ButtonRight)
+  if (event.button == WebMouseEvent::ButtonRight) {
     MouseContextMenu(event);
+    return true;
+  }
 #endif
 
 #if defined(OS_LINUX)
   // If the event was a middle click, attempt to copy text into the focused
   // frame.
   //
   // This code is in the mouse up handler. There is some debate about putting
   // this here, as opposed to the mouse down handler.
   //   xterm: pastes on up.
   //   GTK: pastes on down.
   //   Firefox: pastes on up.
   //   Midori: couldn't paste at all with 0.1.2
   //
   // There is something of a webcompat angle to this well, as highlighted by
   // crbug.com/14608. Pages can clear text boxes 'onclick' and, if we paste on
   // down then the text is pasted just before the onclick handler runs and
   // clears the text box. So it's important this happens after the
   // handleMouseReleaseEvent() earlier in this function
   if (event.button == WebMouseEvent::ButtonMiddle) {
     Frame* focused = GetFocusedWebCoreFrame();
     if (!focused)
-      return;
+      return processed;
     Editor* editor = focused->editor();
     if (!editor || !editor->canEdit())
-      return;
+      return processed;
 
     delegate_->PasteFromSelectionClipboard();
+    return true;
   }
 #endif
+
+  return processed;
 }
 
 void WebViewImpl::MouseWheel(const WebMouseWheelEvent& event) {
   MakePlatformWheelEvent platform_event(main_frame()->frameview(), event);
   main_frame()->frame()->eventHandler()->handleWheelEvent(platform_event);
 }
 
 bool WebViewImpl::KeyEvent(const WebKeyboardEvent& event) {
   DCHECK((event.type == WebInputEvent::RawKeyDown) ||
          (event.type == WebInputEvent::KeyDown) ||
@@ skipping 491 matching lines @@
 
     case WebInputEvent::MouseLeave:
       MouseLeave(*static_cast<const WebMouseEvent*>(input_event));
       break;
 
     case WebInputEvent::MouseWheel:
       MouseWheel(*static_cast<const WebMouseWheelEvent*>(input_event));
       break;
 
     case WebInputEvent::MouseDown:
-      MouseDown(*static_cast<const WebMouseEvent*>(input_event));
-      break;
+      return MouseDown(*static_cast<const WebMouseEvent*>(input_event));
 
     case WebInputEvent::MouseUp:
-      MouseUp(*static_cast<const WebMouseEvent*>(input_event));
-      break;
+      return MouseUp(*static_cast<const WebMouseEvent*>(input_event));
 
     case WebInputEvent::RawKeyDown:
     case WebInputEvent::KeyDown:
     case WebInputEvent::KeyUp:
       handled = KeyEvent(*static_cast<const WebKeyboardEvent*>(input_event));
       break;
 
     case WebInputEvent::Char:
       handled = CharEvent(*static_cast<const WebKeyboardEvent*>(input_event));
       break;
@@ skipping 863 matching lines @@
 
   return document->focusedNode();
 }
 
 HitTestResult WebViewImpl::HitTestResultForWindowPos(const IntPoint& pos) {
   IntPoint doc_point(
       page_->mainFrame()->view()->windowToContents(pos));
   return page_->mainFrame()->eventHandler()->
       hitTestResultAtPoint(doc_point, false);
 }