Fix candidate window position issue.

chrome/browser/chromeos/input_method/candidate_window.cc

 // Copyright (c) 2012 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/chromeos/input_method/candidate_window.h"
 
 #include <algorithm>
 #include <string>
 #include <vector>
 
@@ skipping 516 matching lines @@
   virtual void OnCandidateWindowOpened();
   virtual void OnCandidateWindowClosed();
 
   // Creates the candidate window view.
   void CreateView();
 
   // IBusUiController::Observer overrides.
   virtual void OnHideAuxiliaryText();
   virtual void OnHideLookupTable();
   virtual void OnHidePreeditText();
-  virtual void OnSetCursorLocation(int x, int y, int width, int height);
+  virtual void OnSetCursorLocation(int x, int y, int width, int height,

[Yusuke Sato, 2012/06/13 14:31:26]

any reason not to use gfx::Rect instead of the first four arguments?  

[Seigo Nonaka, 2012/06/13 15:07:18]

Okay remove now.
On 2012/06/13 14:31:26, Yusuke Sato wrote:

+                                   const gfx::Rect& composition_head);
   virtual void OnUpdateAuxiliaryText(const std::string& utf8_text,
                                      bool visible);
   virtual void OnUpdateLookupTable(const InputMethodLookupTable& lookup_table);
   virtual void OnUpdatePreeditText(const std::string& utf8_text,
                                    unsigned int cursor, bool visible);
   virtual void OnConnectionChange(bool connected);
 
   // The controller is used for communicating with the IBus daemon.
   scoped_ptr<IBusUiController> ibus_ui_controller_;
 
@@ skipping 227 matching lines @@
 CandidateWindowView::CandidateWindowView(views::Widget* parent_frame)
     : selected_candidate_index_in_page_(0),
       parent_frame_(parent_frame),
       preedit_area_(NULL),
       header_area_(NULL),
       candidate_area_(NULL),
       footer_area_(NULL),
       previous_shortcut_column_size_(0, 0),
       previous_candidate_column_size_(0, 0),
       previous_annotation_column_size_(0, 0),
-      is_suggestion_window_location_available_(false),
+      should_show_at_composition_head_(false),
       should_show_upper_side_(false),
       was_candidate_window_open_(false) {
 }
 
 CandidateWindowView::~CandidateWindowView() {
 }
 
 void CandidateWindowView::Init() {
   // Set the background and the border of the view.
   set_background(
@@ skipping 114 matching lines @@
   } else if (was_candidate_window_open_ && !is_open) {
     FOR_EACH_OBSERVER(Observer, observers_, OnCandidateWindowClosed());
   }
   was_candidate_window_open_ = is_open;
 }
 
 bool CandidateWindowView::ShouldUpdateCandidateViews(
     const InputMethodLookupTable& old_table,
     const InputMethodLookupTable& new_table) {
 
-  // Check if mozc lookup table location is changed.
-  if (old_table.mozc_candidates.has_window_location() ||
-      new_table.mozc_candidates.has_window_location()) {
-
-    if (!old_table.mozc_candidates.IsInitialized() ||
-        !new_table.mozc_candidates.IsInitialized()) {
+  // Check only candidate category because other fields are not used in
+  // CandidateWindowView.
+  // TODO(nona): Remove mozc_candidates(crbug.com/129403).
+  if (old_table.mozc_candidates.has_category() ||
+      new_table.mozc_candidates.has_category()) {
+    if (old_table.mozc_candidates.category() !=
+        new_table.mozc_candidates.category())
       return true;
-    }
-
-    std::string old_serialized_msg;
-    std::string new_serialized_msg;
-
-    old_table.mozc_candidates.SerializeToString(&old_serialized_msg);
-    new_table.mozc_candidates.SerializeToString(&new_serialized_msg);
-    return old_serialized_msg != new_serialized_msg;
   }
 
   // Check if most table contents are identical.
   if (old_table.page_size == new_table.page_size &&
       old_table.orientation == new_table.orientation &&
       old_table.candidates == new_table.candidates &&
       old_table.labels == new_table.labels &&
       old_table.annotations == new_table.annotations &&
       // Check if the page indexes are identical.
       ComputePageIndex(old_table) == ComputePageIndex(new_table)) {
     // If all of the conditions are met, we don't have to update candidate
     // views.
     return false;
   }
   return true;
 }
 
 void CandidateWindowView::UpdateCandidates(
     const InputMethodLookupTable& new_lookup_table) {
   const bool should_update = ShouldUpdateCandidateViews(lookup_table_,
                                                         new_lookup_table);
   // Updating the candidate views is expensive. We'll skip this if possible.
   if (should_update) {
     // Initialize candidate views if necessary.
     MaybeInitializeCandidateViews(new_lookup_table);
 
-    // Store mozc specific window location.
-    if (new_lookup_table.mozc_candidates.has_window_location() &&
-        new_lookup_table.mozc_candidates.window_location() ==
-            mozc::commands::Candidates::COMPOSITION) {
-      DCHECK(new_lookup_table.mozc_candidates.has_composition_rectangle());
-      suggestion_window_location_.set_x(
-          new_lookup_table.mozc_candidates.composition_rectangle().x());
-      suggestion_window_location_.set_y(
-          new_lookup_table.mozc_candidates.composition_rectangle().y());
-      suggestion_window_location_.set_width(
-          new_lookup_table.mozc_candidates.composition_rectangle().width());
-      suggestion_window_location_.set_height(
-          new_lookup_table.mozc_candidates.composition_rectangle().height());
-      is_suggestion_window_location_available_ = true;
+    if (new_lookup_table.mozc_candidates.has_category() &&
+        new_lookup_table.mozc_candidates.category() ==
+            mozc::commands::SUGGESTION) {
+      should_show_at_composition_head_ = true;
     } else {
-      is_suggestion_window_location_available_ = false;
+      should_show_at_composition_head_ = false;
     }
 
     // Compute the index of the current page.
     const int current_page_index = ComputePageIndex(new_lookup_table);
     if (current_page_index < 0) {
       DVLOG(1) << "Invalid lookup_table: " << new_lookup_table.ToString();
       return;
     }
 
     // Update the candidates in the current page.
@@ skipping 167 matching lines @@
   // Compute views size in |layout|.
   // If we don't call this function, GetHorizontalOffset() often
   // returns invalid value (returns 0), then candidate window
   // moves right from the correct position in ResizeAndMoveParentFrame().
   // TODO(nhiroki): Figure out why it returns invalid value.
   // It seems that the x-position of the candidate labels is not set.
   layout->Layout(candidate_area_contents);
 }
 
 bool CandidateWindowView::IsCandidateWindowOpen() const {
-  return !is_suggestion_window_location_available_ &&
+  return !should_show_at_composition_head_ &&
       candidate_area_->visible() && candidate_area_->IsShown();
 }
 
 void CandidateWindowView::SelectCandidateAt(int index_in_page) {
   const int current_page_index = ComputePageIndex(lookup_table_);
   if (current_page_index < 0) {
     DVLOG(1) << "Invalid lookup_table: " << lookup_table_.ToString();
     return;
   }
 
@@ skipping 37 matching lines @@
   const int key_modifilers = 0;
   FOR_EACH_OBSERVER(Observer, observers_,
                     OnCandidateCommitted(selected_candidate_index_in_page_,
                                          button,
                                          key_modifilers));
 }
 
 void CandidateWindowView::ResizeAndMoveParentFrame() {
   // If rendering operation comes from mozc-engine, uses mozc specific location,
   // otherwise lookup table is shown under the cursor.
-  const int x = is_suggestion_window_location_available_ ?
-      suggestion_window_location_.x() : cursor_location_.x();
+  const int x = should_show_at_composition_head_?
+      composition_head_location_.x() : cursor_location_.x();
   // To avoid lookup-table overlapping, uses maximum y-position of mozc specific
   // location and cursor location, because mozc-engine does not consider about
   // multi-line composition.
-  const int y = is_suggestion_window_location_available_ ?
-      std::max(suggestion_window_location_.y(), cursor_location_.y()) :
+  const int y = should_show_at_composition_head_?
+      std::max(composition_head_location_.y(), cursor_location_.y()) :
       cursor_location_.y();
   const int height = cursor_location_.height();
   const int horizontal_offset = GetHorizontalOffset();
 
   gfx::Rect old_bounds = parent_frame_->GetClientAreaScreenBounds();
   gfx::Rect screen_bounds = gfx::Screen::GetMonitorNearestWindow(
       parent_frame_->GetNativeView()).work_area();
   // The size.
   gfx::Rect frame_bounds = old_bounds;
   frame_bounds.set_size(GetPreferredSize());
@@ skipping 421 matching lines @@
 }
 
 void CandidateWindowControllerImpl::OnHidePreeditText() {
   candidate_window_->HidePreeditText();
 }
 
 void CandidateWindowControllerImpl::OnSetCursorLocation(
     int x,
     int y,
     int width,
-    int height) {
+    int height,
+    const gfx::Rect& composition_head) {
   // A workaround for http://crosbug.com/6460. We should ignore very short Y
   // move to prevent the window from shaking up and down.
   const int kKeepPositionThreshold = 2;  // px
   const gfx::Rect& last_location =
       candidate_window_->cursor_location();
   const int delta_y = abs(last_location.y() - y);
   if ((last_location.x() == x) && (delta_y <= kKeepPositionThreshold)) {
     DVLOG(1) << "Ignored set_cursor_location signal to prevent window shake";
     return;
   }
 
   // Remember the cursor location.
   candidate_window_->set_cursor_location(
       gfx::Rect(x, y, width, height));
+  candidate_window_->set_composition_head_location(composition_head);
   // Move the window per the cursor location.
   candidate_window_->ResizeAndMoveParentFrame();
   infolist_window_->ResizeAndMoveParentFrame();
 }
 
 void CandidateWindowControllerImpl::OnUpdateAuxiliaryText(
     const std::string& utf8_text,
     bool visible) {
   // If it's not visible, hide the auxiliary text and return.
   if (!visible) {
@@ skipping 84 matching lines @@
 }
 
 // static
 CandidateWindowController*
 CandidateWindowController::CreateCandidateWindowController() {
   return new CandidateWindowControllerImpl;
 }
 
 }  // namespace input_method
 }  // namespace chromeos