Fix Instant suggest issues in Linux Views port.

chrome/browser/autocomplete/autocomplete_edit_view_gtk.cc

 // Copyright (c) 2010 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 415 matching lines @@
   GdkRectangle first_char_bounds, last_char_bounds;
   gtk_text_buffer_get_start_iter(text_buffer_, &start);
 
   // Use the real end iterator here to take the width of instant suggestion
   // text into account, so that location bar can layout its children correctly.
   gtk_text_buffer_get_end_iter(text_buffer_, &end);
   gtk_text_view_get_iter_location(GTK_TEXT_VIEW(text_view_),
                                   &start, &first_char_bounds);
   gtk_text_view_get_iter_location(GTK_TEXT_VIEW(text_view_),
                                   &end, &last_char_bounds);
-  return ((last_char_bounds.x > first_char_bounds.x) ?
-          (last_char_bounds.x + last_char_bounds.width - first_char_bounds.x) :
-          (first_char_bounds.x - last_char_bounds.x + last_char_bounds.width)) +
-      horizontal_border_size;
+
+  gint first_char_start = first_char_bounds.x;
+  gint first_char_end = first_char_start + first_char_bounds.width;
+  gint last_char_start = last_char_bounds.x;
+  gint last_char_end = last_char_start + last_char_bounds.width;
+
+  // bounds width could be negative for RTL text.
+  if (first_char_start > first_char_end)
+    std::swap(first_char_start, first_char_end);
+  if (last_char_start > last_char_end)
+    std::swap(last_char_start, last_char_end);
+
+  gint text_width = first_char_start < last_char_start ?
+      last_char_end - first_char_start : first_char_end - last_char_start;
+
+  return text_width + horizontal_border_size;
 }
 
 int AutocompleteEditViewGtk::WidthOfTextAfterCursor() {
   // Not used.
   return -1;
 }
 
 gfx::Font AutocompleteEditViewGtk::GetFont() {
   GtkRcStyle* rc_style = gtk_widget_get_modifier_style(text_view_);
   return gfx::Font((rc_style && rc_style->font_desc) ?
@@ skipping 391 matching lines @@
 
     g_object_set(faded_text_tag_, "foreground", kTextBaseColor, NULL);
     g_object_set(normal_text_tag_, "foreground", "#000000", NULL);
   }
 
   AdjustVerticalAlignmentOfInstantView();
   UpdateInstantViewColors();
 }
 
 void AutocompleteEditViewGtk::UpdateInstantViewColors() {
-#if !defined(TOOLKIT_VIEWS)
   SkColor selection_text, selection_bg;
   GdkColor faded_text, normal_bg;
 
-  if (theme_provider_->UseGtkTheme()) {
-    GtkStyle* style = gtk_rc_get_style(text_view_);
+#if defined(TOOLKIT_VIEWS)
+  bool use_gtk = false;
+#else
+  bool use_gtk = theme_provider_->UseGtkTheme();
+#endif
+
+  if (use_gtk) {
+    GtkStyle* style = gtk_rc_get_style(instant_view_);
 
     faded_text = gtk_util::AverageColors(
         style->text[GTK_STATE_NORMAL], style->base[GTK_STATE_NORMAL]);
     normal_bg = style->base[GTK_STATE_NORMAL];
 
     selection_text = gfx::GdkColorToSkColor(style->text[GTK_STATE_SELECTED]);
     selection_bg = gfx::GdkColorToSkColor(style->base[GTK_STATE_SELECTED]);
   } else {
     gdk_color_parse(kTextBaseColor, &faded_text);
+
+#if defined(TOOLKIT_VIEWS)
+    normal_bg = gfx::SkColorToGdkColor(
+        LocationBarView::GetColor(ToolbarModel::NONE,
+                                  LocationBarView::BACKGROUND));
+    selection_text = LocationBarView::GetColor(
+        ToolbarModel::NONE, LocationBarView::SELECTED_TEXT);
+
+    GtkStyle* style = gtk_rc_get_style(instant_view_);
+    selection_bg = gfx::GdkColorToSkColor(style->base[GTK_STATE_SELECTED]);
+#else
     normal_bg = LocationBarViewGtk::kBackgroundColor;
-
     selection_text =
         theme_provider_->get_active_selection_fg_color();
     selection_bg =
         theme_provider_->get_active_selection_bg_color();
+#endif
   }
 
   double alpha = instant_animation_->is_animating() ?
       instant_animation_->GetCurrentValue() : 0.0;
   GdkColor text = gfx::SkColorToGdkColor(color_utils::AlphaBlend(
       selection_text,
       gfx::GdkColorToSkColor(faded_text),
       alpha * 0xff));
   GdkColor bg = gfx::SkColorToGdkColor(color_utils::AlphaBlend(
       selection_bg,
       gfx::GdkColorToSkColor(normal_bg),
       alpha * 0xff));
 
   if (alpha > 0.0) {
     gtk_label_select_region(GTK_LABEL(instant_view_), 0, -1);
     // ACTIVE is the state for text that is selected, but not focused.
     gtk_widget_modify_text(instant_view_, GTK_STATE_ACTIVE, &text);
     gtk_widget_modify_base(instant_view_, GTK_STATE_ACTIVE, &bg);
   } else {
     // When the text is unselected, fg is used for text color, the state
     // is NORMAL, and the background is transparent.
     gtk_widget_modify_fg(instant_view_, GTK_STATE_NORMAL, &text);
   }
-#else  // defined(TOOLKIT_VIEWS)
-  // We don't worry about views because it doesn't use the instant view.
-#endif
 }
 
 void AutocompleteEditViewGtk::HandleBeginUserAction(GtkTextBuffer* sender) {
   OnBeforePossibleChange();
 }
 
 void AutocompleteEditViewGtk::HandleEndUserAction(GtkTextBuffer* sender) {
   OnAfterPossibleChange();
 }
 
@@ skipping 257 matching lines @@
 }
 
 void AutocompleteEditViewGtk::HandleViewMoveCursor(
     GtkWidget* sender,
     GtkMovementStep step,
     gint count,
     gboolean extend_selection) {
   GtkTextIter sel_start, sel_end;
   gboolean has_selection =
       gtk_text_buffer_get_selection_bounds(text_buffer_, &sel_start, &sel_end);
+  bool handled = false;
 
-  bool handled = true;
+  if (step == GTK_MOVEMENT_VISUAL_POSITIONS && !extend_selection &&
+      (count == 1 || count == -1)) {
+    gint cursor_pos;
+    g_object_get(G_OBJECT(text_buffer_), "cursor-position", &cursor_pos, NULL);
 
-  // We want the GtkEntry behavior when you move the cursor while you have a
-  // selection.  GtkTextView just drops the selection and moves the cursor, but
-  // instead we want to move the cursor to the appropiate end of the selection.
-  if (step == GTK_MOVEMENT_VISUAL_POSITIONS && !extend_selection) {
-    if ((count == 1 || count == -1) && has_selection) {
+    // We need to take the content direction into account when handling cursor
+    // movement, because the behavior of Left and Right key will be inverted if
+    // the direction is RTL. Although we should check the direction around the
+    // input caret, it's much simpler and good enough to check whole content's
+    // direction.
+    PangoDirection content_dir = GetContentDirection();
+    gint count_towards_end = content_dir == PANGO_DIRECTION_RTL ? -1 : 1;
+
+    // We want the GtkEntry behavior when you move the cursor while you have a
+    // selection.  GtkTextView just drops the selection and moves the cursor,
+    // but instead we want to move the cursor to the appropiate end of the
+    // selection.
+    if (has_selection) {
       // We have a selection and start / end are in ascending order.
-      // Cursor placement will remove the selection, so we need inform |model_|
-      // about this change by calling On{Before|After}PossibleChange() methods.
+      // Cursor placement will remove the selection, so we need inform
+      // |model_| about this change by
+      // calling On{Before|After}PossibleChange() methods.
       OnBeforePossibleChange();
-      gtk_text_buffer_place_cursor(text_buffer_,
-                                   count == 1 ? &sel_end : &sel_start);
+      gtk_text_buffer_place_cursor(
+          text_buffer_, count == count_towards_end ? &sel_end : &sel_start);
       OnAfterPossibleChange();
-    } else if (count == 1 && !has_selection) {
-      gint cursor_pos;
-      g_object_get(G_OBJECT(text_buffer_), "cursor-position", &cursor_pos,
-                   NULL);
-      if (cursor_pos == GetTextLength())
-        controller_->OnCommitSuggestedText(GetText());
-      else
-        handled = false;
-    } else {
-      handled = false;
+      handled = true;
+    } else if (count == count_towards_end && cursor_pos == GetTextLength()) {
+      handled = controller_->OnCommitSuggestedText(GetText());
     }
   } else if (step == GTK_MOVEMENT_PAGES) {  // Page up and down.
     // Multiply by count for the direction (if we move too much that's ok).
     model_->OnUpOrDownKeyPressed(model_->result().size() * count);
+    handled = true;
   } else if (step == GTK_MOVEMENT_DISPLAY_LINES) {  // Arrow up and down.
     model_->OnUpOrDownKeyPressed(count);
-  } else {
-    handled = false;
+    handled = true;
   }
 
   if (!handled) {
     // Cursor movement may change the selection, we need to record the change
     // and report it to |model_|.
     if (has_selection || extend_selection)
       OnBeforePossibleChange();
 
     // Propagate into GtkTextView
     GtkTextViewClass* klass = GTK_TEXT_VIEW_GET_CLASS(text_view_);
@@ skipping 245 matching lines @@
   // prevent the focus from being moved.
   bool handled = false;
 
   // Trigger Tab to search behavior only when Tab key is pressed.
   if (model_->is_keyword_hint() && !model_->keyword().empty()) {
     if (enable_tab_to_search_) {
       model_->AcceptKeyword();
       handled = true;
     }
   } else {
-    // TODO(estade): this only works for linux/gtk; linux/views doesn't use
-    // |instant_view_| so its visibility is not an indicator of whether we
-    // have a suggestion.
     if (GTK_WIDGET_VISIBLE(instant_view_)) {
       controller_->OnCommitSuggestedText(GetText());
       handled = true;
     } else {
       handled = controller_->AcceptCurrentInstantPreview();
     }
   }
 
   if (handled) {
     static guint signal_id = g_signal_lookup("move-focus", GTK_TYPE_WIDGET);
@@ skipping 578 matching lines @@
   // baseline, so we need to move the |instant_view_| down to make sure it
   // has the same baseline as the |text_view_|.
   PangoLayout* layout = gtk_label_get_layout(GTK_LABEL(instant_view_));
   int height;
   pango_layout_get_size(layout, NULL, &height);
   PangoLayoutIter* iter = pango_layout_get_iter(layout);
   int baseline = pango_layout_iter_get_baseline(iter);
   pango_layout_iter_free(iter);
   g_object_set(instant_anchor_tag_, "rise", baseline - height, NULL);
 }