Implements unimplemented methods of AutocompleteEditViewGtk....

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 <algorithm>
@@ skipping 82 matching lines @@
                                                          popup_positioner)),
       controller_(controller),
       toolbar_model_(toolbar_model),
       command_updater_(command_updater),
       popup_window_mode_(popup_window_mode),
       scheme_security_level_(ToolbarModel::NORMAL),
       selection_saved_(false),
       mark_set_handler_id_(0),
       button_1_pressed_(false),
       text_selected_during_click_(false),
-      text_view_focused_before_button_press_(false)
+      text_view_focused_before_button_press_(false),
 #if !defined(TOOLKIT_VIEWS)
-      ,
-      theme_provider_(GtkThemeProvider::GetFrom(profile))
+      theme_provider_(GtkThemeProvider::GetFrom(profile)),
 #endif
-      {
+      tab_was_pressed_(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 27 matching lines @@
 
   // Until we switch to vector graphics, force the font size.
   gtk_util::ForceFontSizePixels(text_view_,
       popup_window_mode_ ?
       browser_defaults::kAutocompleteEditFontPixelSizeInPopup :
       browser_defaults::kAutocompleteEditFontPixelSize);
 
   // The text view was floating.  It will now be owned by the alignment.
   gtk_container_add(GTK_CONTAINER(alignment_.get()), text_view_);
 
-  // Allows inserting tab characters when pressing tab key, to prevent
-  // |text_view_| from moving focus.
-  // Tab characters will be filtered out by our "insert-text" signal handler
-  // attached to |text_buffer_| object.
-  // Tab key events will be handled by our "key-press-event" signal handler for
-  // tab to search feature.
-  gtk_text_view_set_accepts_tab(GTK_TEXT_VIEW(text_view_), TRUE);
+  // Do not allow inserting tab characters when pressing Tab key, so that when
+  // Tab key is pressed, |text_view_| will emit "move-focus" signal, which will
+  // be intercepted by our own handler to trigger Tab to search feature when
+  // necessary.
+  gtk_text_view_set_accepts_tab(GTK_TEXT_VIEW(text_view_), FALSE);
 
   faded_text_tag_ = gtk_text_buffer_create_tag(text_buffer_,
       NULL, "foreground", kTextBaseColor, NULL);
   secure_scheme_tag_ = gtk_text_buffer_create_tag(text_buffer_,
       NULL, "foreground", kSecureSchemeColor, NULL);
   insecure_scheme_tag_ = gtk_text_buffer_create_tag(text_buffer_,
       NULL, "foreground", kInsecureSchemeColor, NULL);
   normal_text_tag_ = gtk_text_buffer_create_tag(text_buffer_,
       NULL, "foreground", "#000000", NULL);
 
@@ skipping 17 matching lines @@
   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);
+  g_signal_connect(text_view_, "move-focus",
+                   G_CALLBACK(&HandleViewMoveFocusThunk), 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
   // so we don't force a minimum width based on the text length.
   g_signal_connect(text_view_, "size-request",
                    G_CALLBACK(&HandleViewSizeRequestThunk), this);
   g_signal_connect(text_view_, "populate-popup",
                    G_CALLBACK(&HandlePopulatePopupThunk), this);
   mark_set_handler_id_ = g_signal_connect(
       text_buffer_, "mark-set", G_CALLBACK(&HandleMarkSetThunk), this);
   g_signal_connect(text_view_, "drag-data-received",
@@ skipping 114 matching lines @@
   model_->SetUserText(text);
   // TODO(deanm): something about selection / focus change here.
   SetWindowTextAndCaretPos(display_text, display_text.length());
   if (update_popup)
     UpdatePopup();
   TextChanged();
 }
 
 void AutocompleteEditViewGtk::SetWindowTextAndCaretPos(const std::wstring& text,
                                                        size_t caret_pos) {
+  CharRange range(static_cast<int>(caret_pos), static_cast<int>(caret_pos));
+  SetTextAndSelectedRange(text, range);
+}
+
+void AutocompleteEditViewGtk::SetTextAndSelectedRange(const std::wstring& text,
+                                                      const CharRange& range) {
   std::string utf8 = WideToUTF8(text);
   gtk_text_buffer_set_text(text_buffer_, utf8.data(), utf8.length());
-  EmphasizeURLComponents();
 
-  GtkTextIter cur_pos;
-  gtk_text_buffer_get_iter_at_offset(text_buffer_, &cur_pos, caret_pos);
-  gtk_text_buffer_place_cursor(text_buffer_, &cur_pos);
+  GtkTextIter insert, bound;
+  ItersFromCharRange(range, &insert, &bound);
+  gtk_text_buffer_select_range(text_buffer_, &insert, &bound);
 }
 
 void AutocompleteEditViewGtk::SetForcedQuery() {
   const std::wstring current_text(GetText());
   if (current_text.empty() || (current_text[0] != '?')) {
     SetUserText(L"?");
   } else {
     GtkTextIter start, end;
     gtk_text_buffer_get_bounds(text_buffer_, &start, &end);
     gtk_text_buffer_get_iter_at_offset(text_buffer_, &start, 1);
     StartUpdatingHighlightedText();
     gtk_text_buffer_select_range(text_buffer_, &start, &end);
     FinishUpdatingHighlightedText();
   }
 }
 
 bool AutocompleteEditViewGtk::IsSelectAll() {
-  NOTIMPLEMENTED();
-  return false;
+  GtkTextIter sel_start, sel_end;
+  if (!gtk_text_buffer_get_selection_bounds(text_buffer_, &sel_start, &sel_end))
+    return false;
+
+  GtkTextIter start, end;
+  gtk_text_buffer_get_bounds(text_buffer_, &start, &end);
+
+  return gtk_text_iter_equal(&start, &sel_start) &&
+      gtk_text_iter_equal(&end, &sel_end);
 }
 
 void AutocompleteEditViewGtk::SelectAll(bool reversed) {
   // SelectAll() is invoked as a side effect of other actions (e.g.  switching
   // tabs or hitting Escape) in autocomplete_edit.cc, so we don't update the
   // PRIMARY selection here.
   // TODO(derat): But this is also called by LocationBarView::FocusLocation() --
   // should the X selection be updated when the user hits Ctrl-L?
   SelectAllInternal(reversed, false);
 }
@@ skipping 15 matching lines @@
   model_->StartAutocomplete(sel.cp_max < GetTextLength());
 }
 
 void AutocompleteEditViewGtk::ClosePopup() {
   popup_view_->GetModel()->StopAutocomplete();
 }
 
 void AutocompleteEditViewGtk::OnTemporaryTextMaybeChanged(
     const std::wstring& display_text,
     bool save_original_selection) {
-  // TODO(deanm): Ignoring save_original_selection here, etc.
+  if (save_original_selection) {
+    saved_temporary_selection_ = GetSelection();
+    saved_temporary_text_ = GetText();
+  }
+
+  StartUpdatingHighlightedText();
   SetWindowTextAndCaretPos(display_text, display_text.length());
+  FinishUpdatingHighlightedText();
   TextChanged();
 }
 
 bool AutocompleteEditViewGtk::OnInlineAutocompleteTextMaybeChanged(
     const std::wstring& display_text,
     size_t user_text_length) {
   if (display_text == GetText())
     return false;
 
   StartUpdatingHighlightedText();
   SetWindowTextAndCaretPos(display_text, 0);
 
   // Select the part of the text that was inline autocompleted.
   GtkTextIter bound, insert;
   gtk_text_buffer_get_bounds(text_buffer_, &insert, &bound);
   gtk_text_buffer_get_iter_at_offset(text_buffer_, &insert, user_text_length);
   gtk_text_buffer_select_range(text_buffer_, &insert, &bound);
 
   FinishUpdatingHighlightedText();
   TextChanged();
   return true;
 }
 
 void AutocompleteEditViewGtk::OnRevertTemporaryText() {
-  NOTIMPLEMENTED();
+  StartUpdatingHighlightedText();
+  SetTextAndSelectedRange(saved_temporary_text_, saved_temporary_selection_);
+  FinishUpdatingHighlightedText();
+  saved_temporary_text_.clear();
+  TextChanged();
 }
 
 void AutocompleteEditViewGtk::OnBeforePossibleChange() {
   // Record our state.
   text_before_change_ = GetText();
   sel_before_change_ = GetSelection();
 }
 
 // TODO(deanm): This is mostly stolen from Windows, and will need some work.
 bool AutocompleteEditViewGtk::OnAfterPossibleChange() {
@@ skipping 81 matching lines @@
   OnBeforePossibleChange();
 }
 
 void AutocompleteEditViewGtk::HandleEndUserAction() {
   OnAfterPossibleChange();
 }
 
 gboolean AutocompleteEditViewGtk::HandleKeyPress(GtkWidget* widget,
                                                  GdkEventKey* event) {
   // Background of this piece of complicated code:
-  // The omnibox supports several special behavior which may be triggered by
+  // The omnibox supports several special behaviors which may be triggered by
   // certain key events:
   // Tab to search - triggered by Tab key
   // Accept input - triggered by Enter key
   // Revert input - triggered by Escape key
   //
   // Because we use a GtkTextView object |text_view_| for text input, we need
   // send all key events to |text_view_| before handling them, to make sure
   // IME works without any problem. So here, we intercept "key-press-event"
   // signal of |text_view_| object and call its default handler to handle the
   // key event first.
   //
-  // Then if the key event is one of Tab, Enter and Escape, we need trigger
-  // corresponding special behavior if IME did not handle it.
-  // For Escape key if the default signal handler returns FALSE, then we know
+  // Then if the key event is one of Tab, Enter and Escape, we need to trigger
+  // the corresponding special behavior if IME did not handle it.
+  // For Escape key, if the default signal handler returns FALSE, then we know
   // it's not handled by IME.
   //
-  // But for Tab and Enter key, the default signal handler always returns TRUE,
-  // and following operation will be performed by GtkTextView if IME did not
-  // handle it:
-  // Tab key - delete current selection range and insert '\t'
-  // Enter key - delete current selection range and insert '\n'
+  // For Tab key, as "accepts-tab" property of |text_view_| is set to FALSE,
+  // if IME did not handle it then "move-focus" signal will be emitted by the
+  // default signal handler of |text_view_|. So we can intercept "move-focus"
+  // signal of |text_view_| to know if a Tab key press event was handled by IME,
+  // and trigger Tab to search behavior when necessary in the signal handler.
   //
-  // We need dinstinguish if IME handled the key event or not, and avoid above
-  // built-in operation if IME did not handle the key event. Because we don't
-  // want the content of omnibox to be changed before triggering our special
-  // behavior. Otherwise our special behavior would not be performed correctly.
+  // But for Enter key, if IME did not handle the key event, the default signal
+  // handler will delete current selection range and insert '\n' and always
+  // return TRUE. We need to prevent |text_view_| from performing this default
+  // action if IME did not handle the key event, because we don't want the
+  // content of omnibox to be changed before triggering our special behavior.
+  // Otherwise our special behavior would not be performed correctly.
   //
   // But there is no way for us to prevent GtkTextView from handling the key
-  // event and performing above built-in operation. So in order to achieve our
-  // goal, "insert-text" signal of |text_buffer_| object is intercepted, and
+  // event and performing built-in operation. So in order to achieve our goal,
+  // "insert-text" signal of |text_buffer_| object is intercepted, and
   // following actions are done in the signal handler:
   // - If there is only one character in inserted text, save it in
   //   char_inserted_.
   // - Filter out all new line and tab characters.
   //
-  // So if char_inserted_ equals to '\t' after calling |text_view_|'s
-  // default signal handler against a Tab key press event, then we can sure this
-  // Tab key press event is handled by GtkTextView instead of IME. Then we can
-  // perform the special behavior of Tab key safely.
-  //
-  // Enter key press event can be treated in the same way.
+  // So if |char_inserted_| equals '\n' after calling |text_view_|'s
+  // default signal handler against an Enter key press event, then we know that
+  // the Enter key press event was handled by GtkTextView rather than IME, and
+  // can perform the special behavior for Enter key safely.
   //
   // Now the last thing is to prevent the content of omnibox from being changed
   // by GtkTextView when Tab or Enter key is pressed. Because we can't prevent
-  // it, we use backup and restore trick: If Tab or Enter is pressed, backup the
-  // content of omnibox before sending the key event to |text_view_|, and then
-  // restore it afterwards if IME did not handle the event.
+  // it, we use a backup and restore trick: If Enter is pressed, backup the
+  // content of omnibox before sending the key event to |text_view_|, and
+  // then restore it afterwards if IME did not handle the event.
 
   GtkWidgetClass* klass = GTK_WIDGET_GET_CLASS(widget);
-  bool tab_pressed = ((event->keyval == GDK_Tab ||
-                       event->keyval == GDK_ISO_Left_Tab ||
-                       event->keyval == GDK_KP_Tab) &&
-                      !(event->state & GDK_CONTROL_MASK));
 
   bool enter_pressed = (event->keyval == GDK_Return ||
                         event->keyval == GDK_ISO_Enter ||
                         event->keyval == GDK_KP_Enter);
 
-  gchar* original_text = NULL;
+  std::wstring original_text;
 
-  // Tab and Enter key will have special behavior if it's not handled by IME.
+  // Enter key will have special behavior if it's not handled by IME.
   // We need save the original content of |text_buffer_| and restore it when
   // necessary, because GtkTextView might alter the content.
-  if (tab_pressed || enter_pressed) {
-    GtkTextIter start, end;
-    gtk_text_buffer_get_bounds(text_buffer_, &start, &end);
-    original_text = gtk_text_buffer_get_text(text_buffer_, &start, &end, FALSE);
-
-    // Reset these variable, which may be set in "insert-text" signal handler.
-    // So that we can know if Tab or Enter key event is handled by IME or not.
+  if (enter_pressed) {
+    original_text = GetText();
+    // Reset |char_inserted_|, which may be set in the "insert-text" signal
+    // handler, so that we'll know if an Enter key event was handled by IME.
     char_inserted_ = 0;
   }
 
+  // Set |tab_was_pressed_| to true if it's a Tab key press event, so that our
+  // handler of "move-focus" signal can trigger Tab to search behavior when
+  // necessary.
+  tab_was_pressed_ = ((event->keyval == GDK_Tab ||
+                       event->keyval == GDK_ISO_Left_Tab ||
+                       event->keyval == GDK_KP_Tab) &&
+                      !(event->state & GDK_CONTROL_MASK));
+
   // Call the default handler, so that IME can work as normal.
-  // New line and tab characters will be filtered out by our "insert-text"
+  // New line characters will be filtered out by our "insert-text"
   // signal handler attached to |text_buffer_| object.
   gboolean result = klass->key_press_event(widget, event);
 
-  bool tab_inserted = (char_inserted_ == '\t');
-  bool new_line_inserted = (char_inserted_ == '\n' || char_inserted_ == '\r');
-  if ((tab_pressed && tab_inserted) || (enter_pressed && new_line_inserted)) {
-    // Tab or Enter key is handled by GtkTextView, so we are sure that it is not
-    // handled by IME.
-    // Revert the original content in case it has been altered.
-    // Call gtk_text_buffer_{begin|end}_user_action() to make sure |model_| will
-    // be updated correctly.
-    gtk_text_buffer_begin_user_action(text_buffer_);
-    gtk_text_buffer_set_text(text_buffer_, original_text, -1);
-    gtk_text_buffer_end_user_action(text_buffer_);
-  }
+  // Set |tab_was_pressed_| to false, to make sure Tab to search behavior can
+  // only be triggered by pressing Tab key.
+  tab_was_pressed_ = false;
 
-  if (original_text)
-    g_free(original_text);
-
-  if (tab_pressed && tab_inserted) {
-    if (model_->is_keyword_hint() && !model_->keyword().empty()) {
-      model_->AcceptKeyword();
-    } else {
-      // Handle move focus by ourselves.
-      static guint signal_id = g_signal_lookup("move-focus", GTK_TYPE_WIDGET);
-      g_signal_emit(widget, signal_id, 0, (event->state & GDK_SHIFT_MASK) ?
-                    GTK_DIR_TAB_BACKWARD : GTK_DIR_TAB_FORWARD);
-    }
-    result = TRUE;
-  } else if (enter_pressed && new_line_inserted) {
+  if (enter_pressed && (char_inserted_ == '\n' || char_inserted_ == '\r')) {
     bool alt_held = (event->state & GDK_MOD1_MASK);
+    // Revert the original text in case the text has been changed.
+    SetUserText(original_text);
     model_->AcceptInput(alt_held ? NEW_FOREGROUND_TAB : CURRENT_TAB, false);
     result = TRUE;
   } else if (!result && event->keyval == GDK_Escape &&
              (event->state & gtk_accelerator_get_default_mod_mask()) == 0) {
-    // We can handle Escape key if |text_view_| did not handle it.
-    // If it's not handled by us, then we need propagate it upto parent
+    // We can handle the Escape key if |text_view_| did not handle it.
+    // If it's not handled by us, then we need to propagate it up to the parent
     // widgets, so that Escape accelerator can still work.
     result = model_->OnEscapeKeyPressed();
+  } else if (event->keyval == GDK_Control_L || event->keyval == GDK_Control_R) {
+    // Omnibox2 can switch its contents while pressing a control key. To switch
+    // the contents of omnibox2, we notify the AutocompleteEditModel class when
+    // the control-key state is changed.
+    model_->OnControlKeyChanged(true);
   }
 
-  // If the key event is not handled by |text_view_| and us, then we need
+  // If the key event is not handled by |text_view_| or us, then we need to
   // propagate the key event up to parent widgets by returning FALSE.
-  // In this case we need stop the signal emission explicitly to prevent the
+  // In this case we need to stop the signal emission explicitly to prevent the
   // default "key-press-event" handler of |text_view_| from being called again.
   if (!result) {
     static guint signal_id =
         g_signal_lookup("key-press-event", GTK_TYPE_WIDGET);
     g_signal_stop_emission(widget, signal_id, 0);
   }
 
   return result;
 }
 
 gboolean AutocompleteEditViewGtk::HandleKeyRelease(GtkWidget* widget,
                                                    GdkEventKey* event) {
+  if (event->keyval == GDK_Control_L || event->keyval == GDK_Control_R) {
+    // Omnibox2 can switch its contents while pressing a control key. To switch
+    // the contents of omnibox2, we notify the AutocompleteEditModel class when
+    // the control-key state is changed.
+    model_->OnControlKeyChanged(false);

[Dean McNamee, 2009/08/21 18:21:35]

I am still not happy with this code, but I will let you fix it in a follow up.

+  }
+
   // 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) {
   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
@@ skipping 200 matching lines @@
     GtkTextBuffer* buffer, GtkTextIter* location, const gchar* text, gint len) {
   std::string filtered_text;
   filtered_text.reserve(len);
 
   // Filter out new line and tab characters.
   // |text| is guaranteed to be a valid UTF-8 string, so it's safe here to
   // filter byte by byte.
   //
   // If there was only a single character, then it might be generated by a key
   // event. In this case, we save the single character to help our
-  // "key-press-event" signal handler distinguish if a Tab or Enter key event
-  // is handled by IME or not.
+  // "key-press-event" signal handler distinguish if an Enter key event is
+  // handled by IME or not.
   if (len == 1)
     char_inserted_ = text[0];
 
   for (gint i = 0; i < len; ++i) {
     gchar c = text[i];
     if (c == '\n' || c == '\r' || c == '\t')
       continue;
 
     filtered_text.push_back(c);
   }
@@ skipping 29 matching lines @@
 
   // We're showing a keyword and the user pressed backspace at the beginning
   // of the text. Delete the selected keyword.
   model_->ClearKeyword(GetText());
 
   // Stop propagating the signal emission into GtkTextView.
   static guint signal_id = g_signal_lookup("backspace", GTK_TYPE_TEXT_VIEW);
   g_signal_stop_emission(text_view_, signal_id, 0);
 }
 
+void AutocompleteEditViewGtk::HandleViewMoveFocus(GtkWidget* widget) {
+  // Trigger Tab to search behavior only when Tab key is pressed.
+  if (tab_was_pressed_ && model_->is_keyword_hint() &&
+      !model_->keyword().empty()) {
+    model_->AcceptKeyword();
+
+    // If Tab to search behavior is triggered, then stop the signal emission to
+    // prevent the focus from being moved.
+    static guint signal_id = g_signal_lookup("move-focus", GTK_TYPE_WIDGET);
+    g_signal_stop_emission(widget, signal_id, 0);
+  }
+
+  // Propagate the signal so that focus can be moved as normal.
+}
+
 void AutocompleteEditViewGtk::HandleCopyClipboard() {
   // On copy, we manually update the PRIMARY selection to contain the
   // highlighted text.  This matches Firefox -- we highlight the URL but don't
   // update PRIMARY on Ctrl-L, so Ctrl-L, Ctrl-C and then middle-click is a
   // convenient way to paste the current URL somewhere.
   if (!gtk_text_buffer_get_has_selection(text_buffer_))
     return;
 
   GtkClipboard* clipboard = gtk_clipboard_get(GDK_SELECTION_PRIMARY);
   DCHECK(clipboard);
@@ skipping 140 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());
 }