Linux: Select omnibox text on button release instead of press.

chrome/browser/autocomplete/autocomplete_edit_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/autocomplete/autocomplete_edit_view_gtk.h"
 
 #include <gtk/gtk.h>
 #include <gdk/gdkkeysyms.h>
 
 #include "app/l10n_util.h"
@@ skipping 68 matching lines @@
       insecure_scheme_tag_(NULL),
       model_(new AutocompleteEditModel(this, controller, profile)),
       popup_view_(new AutocompletePopupViewGtk(this, model_.get(), profile,
                                                popup_positioner)),
       controller_(controller),
       toolbar_model_(toolbar_model),
       command_updater_(command_updater),
       popup_window_mode_(false),  // TODO(deanm)
       scheme_security_level_(ToolbarModel::NORMAL),
       selection_saved_(false),
-      mark_set_handler_id_(0) {
+      mark_set_handler_id_(0),
+      button_1_pressed_(false),
+      text_selected_during_click_(false),
+      text_view_focused_before_button_press_(false) {
   model_->set_popup_model(popup_view_->GetModel());
 }
 
 AutocompleteEditViewGtk::~AutocompleteEditViewGtk() {
   NotificationService::current()->Notify(
       NotificationType::AUTOCOMPLETE_EDIT_DESTROYED,
       Source<AutocompleteEditViewGtk>(this),
       NotificationService::NoDetails());
 
   // Explicitly teardown members which have a reference to us.  Just to be safe
@@ skipping 56 matching lines @@
                    G_CALLBACK(&HandleBeginUserActionThunk), this);
   g_signal_connect(text_buffer_, "end-user-action",
                    G_CALLBACK(&HandleEndUserActionThunk), this);
   // We connect to key press and release for special handling of a few keys.
   g_signal_connect(text_view_, "key-press-event",
                    G_CALLBACK(&HandleKeyPressThunk), this);
   g_signal_connect(text_view_, "key-release-event",
                    G_CALLBACK(&HandleKeyReleaseThunk), this);
   g_signal_connect(text_view_, "button-press-event",
                    G_CALLBACK(&HandleViewButtonPressThunk), this);
+  g_signal_connect(text_view_, "button-release-event",
+                   G_CALLBACK(&HandleViewButtonReleaseThunk), this);
   g_signal_connect(text_view_, "focus-in-event",
                    G_CALLBACK(&HandleViewFocusInThunk), this);
   g_signal_connect(text_view_, "focus-out-event",
                    G_CALLBACK(&HandleViewFocusOutThunk), this);
   // NOTE: The GtkTextView documentation asks you not to connect to this
   // signal, but it is very convenient and clean for catching up/down.
   g_signal_connect(text_view_, "move-cursor",
                    G_CALLBACK(&HandleViewMoveCursorThunk), this);
   // Override the size request.  We want to keep the original height request
   // from the widget, since that's font dependent.  We want to ignore the width
@@ skipping 313 matching lines @@
 
 gboolean AutocompleteEditViewGtk::HandleKeyRelease(GtkWidget* widget,
                                                    GdkEventKey* event) {
   // Even though we handled the press ourselves, let GtkTextView handle the
   // release.  It shouldn't do anything particularly interesting, but it will
   // handle the IME work for us.
   return FALSE;  // Propagate into GtkTextView.
 }
 
 gboolean AutocompleteEditViewGtk::HandleViewButtonPress(GdkEventButton* event) {
-  // When the GtkTextView is clicked, it will call gtk_widget_grab_focus.
-  // I believe this causes the focus-in event to be fired before the main
-  // clicked handling code.  If we were to try to set the selection from
-  // the focus-in event, it's just going to be undone by the click handler.
-  // This is a bit ugly.  We shim in to get the click before the GtkTextView,
-  // then if we don't have focus, we (hopefully safely) assume that the click
-  // will cause us to become focused.  We call GtkTextView's default handler
-  // and then stop propagation.  This allows us to run our code after the
-  // default handler, even if that handler stopped propagation.
-  if (GTK_WIDGET_HAS_FOCUS(text_view_))
-    return FALSE;  // Continue to propagate into the GtkTextView handler.
+  if (event->button == 1) {
+    // When the first button is pressed, track some stuff that will help us
+    // determine whether we should select all of the text when the button is
+    // released.
+    button_1_pressed_ = true;
+    text_view_focused_before_button_press_ = GTK_WIDGET_HAS_FOCUS(text_view_);
+    text_selected_during_click_ = false;
+  }
+  return FALSE;
+}
 
-  // We only want to select everything on left-click; otherwise we'll end up
-  // stealing the PRIMARY selection when the user middle-clicks to paste it
-  // here.
+gboolean AutocompleteEditViewGtk::HandleViewButtonRelease(
+    GdkEventButton* event) {
   if (event->button != 1)
     return FALSE;
 
+  button_1_pressed_ = false;
+
   // Call the GtkTextView default handler, ignoring the fact that it will
   // likely have told us to stop propagating.  We want to handle selection.
   GtkWidgetClass* klass = GTK_WIDGET_GET_CLASS(text_view_);
-  klass->button_press_event(text_view_, event);
+  klass->button_release_event(text_view_, event);
 
-  // Select the full input and update the PRIMARY selection when we get focus.
-  SelectAllInternal(false, true);
+  if (!text_view_focused_before_button_press_ && !text_selected_during_click_) {
+    // If this was a focusing click and the user didn't drag to highlight any
+    // text, select the full input and update the PRIMARY selection.
+    SelectAllInternal(false, true);
 
-  // So we told the buffer where the cursor should be, but make sure to tell
-  // the view so it can scroll it to be visible if needed.
-  // NOTE: This function doesn't seem to like a count of 0, looking at the
-  // code it will skip an important loop.  Use -1 to achieve the same.
-  GtkTextIter start, end;
-  gtk_text_buffer_get_bounds(text_buffer_, &start, &end);
-  gtk_text_view_move_visually(GTK_TEXT_VIEW(text_view_), &start, -1);
+    // So we told the buffer where the cursor should be, but make sure to tell
+    // the view so it can scroll it to be visible if needed.
+    // NOTE: This function doesn't seem to like a count of 0, looking at the
+    // code it will skip an important loop.  Use -1 to achieve the same.
+    GtkTextIter start, end;
+    gtk_text_buffer_get_bounds(text_buffer_, &start, &end);
+    gtk_text_view_move_visually(GTK_TEXT_VIEW(text_view_), &start, -1);
+  }
 
   return TRUE;  // Don't continue, we called the default handler already.
 }
 
 gboolean AutocompleteEditViewGtk::HandleViewFocusIn() {
   model_->OnSetFocus(false);
   // TODO(deanm): Some keyword hit business, etc here.
 
   return FALSE;  // Continue propagation.
 }
@@ skipping 92 matching lines @@
     size_t text_len = strlen(text);
     if (!text_len) {
       no_text_selected = true;
     } else {
       selected_text_ = std::string(text, text_len);
       selection_saved_ = false;
     }
     g_free(text);
   }
 
+  // If the user just selected some text with the mouse (or at least while the
+  // mouse button was down), make sure that we won't blow their selection away
+  // later by selecting all of the text when the button is released.
+  if (button_1_pressed_ && !no_text_selected) {
+    text_selected_during_click_ = true;
+  }
+
   // If we have some previously-selected text but it's no longer highlighted
   // and we haven't saved it as the selection yet, we save it now.
   if (!selected_text_.empty() && no_text_selected && !selection_saved_) {
     SavePrimarySelection(selected_text_);
     selection_saved_ = true;
   }
 }
 
 void AutocompleteEditViewGtk::SelectAllInternal(bool reversed,
                                                 bool update_primary_selection) {
@@ skipping 127 matching lines @@
     const std::string& selected_text) {
   GtkClipboard* clipboard =
       gtk_widget_get_clipboard(text_view_, GDK_SELECTION_PRIMARY);
   DCHECK(clipboard);
   if (!clipboard)
     return;
 
   gtk_clipboard_set_text(
       clipboard, selected_text.data(), selected_text.size());
 }