Support mozc suggest window on ChromeOS.

chrome/browser/chromeos/input_method/candidate_window.cc

 // Copyright (c) 2011 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 815 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_width_(0),
       previous_candidate_column_width_(0),
-      previous_annotation_column_width_(0) {
+      previous_annotation_column_width_(0),
+      is_suggestion_window_location_avaiable_(false) {
 }
 
 CandidateWindowView::~CandidateWindowView() {
 }
 
 void CandidateWindowView::Init() {
   // Set the background and the border of the view.
   set_background(
       views::Background::CreateSolidBackground(kDefaultBackgroundColor));
   set_border(views::Border::CreateSolidBorder(1, kFrameColor));
@@ skipping 81 matching lines @@
 
 void CandidateWindowView::ShowLookupTable() {
   candidate_area_->Show();
   ResizeAndMoveParentFrame();
   parent_frame_->Show();
 }
 
 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()) {
+      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_avaiable_ = true;
+    } else {
+      is_suggestion_window_location_avaiable_ = false;
+    }
+
     // Compute the index of the current page.
     const int current_page_index = ComputePageIndex(new_lookup_table);
     if (current_page_index < 0) {
       LOG(ERROR) << "Invalid lookup_table: " << new_lookup_table.ToString();
       return;
     }
 
     // Update the candidates in the current page.
     const size_t start_from = current_page_index * new_lookup_table.page_size;
 
@@ skipping 204 matching lines @@
   // For now, we don't distinguish left and right clicks.
   const int button = 1;  // Left button.
   const int key_modifilers = 0;
   FOR_EACH_OBSERVER(Observer, observers_,
                     OnCandidateCommitted(selected_candidate_index_in_page_,
                                          button,
                                          key_modifilers));
 }
 
 void CandidateWindowView::ResizeAndMoveParentFrame() {
-  const int x = cursor_location_.x();
-  const int y = cursor_location_.y();
+  // 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_avaiable_ ?
+      suggestion_window_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_avaiable_ ?
+      std::max(suggestion_window_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::GetMonitorWorkAreaNearestWindow(
       parent_frame_->GetNativeView());
   // The size.
   gfx::Rect frame_bounds = old_bounds;
   frame_bounds.set_size(GetPreferredSize());
 
@@ skipping 480 matching lines @@
 CandidateWindowController::~CandidateWindowController() {
   delete impl_;
 }
 
 bool CandidateWindowController::Init() {
   return impl_->Init();
 }
 
 }  // namespace input_method
 }  // namespace chromeos