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 559 matching lines @@
   // showing candidate number information like 2/19.
   InformationTextArea* footer_area_;
 
   // Current columns width in |candidate_area_|.
   int previous_shortcut_column_width_;
   int previous_candidate_column_width_;
   int previous_annotation_column_width_;
 
   // The last cursor location.
   gfx::Rect cursor_location_;
+
+  // This location is used by mozc window rendereing, The mozc-engine have two
+  // types of lookup-table, suggestion window and candidate window(this is
+  // ordinal look-up table). The location of these two windows is different
+  // and which is managed by mozc-engine now.
+  gfx::Rect window_location_for_mozc_engine_;
+
+  // If rendering operation comes from mozc-engine, this value becomes true.
+  // Otherwise this value becomes false.
+  bool is_mozc_window_;
 };
 
 // CandidateRow renderes a row of a candidate.
 class CandidateView : public views::View {
  public:
   CandidateView(CandidateWindowView* parent_candidate_window,
                 int index_in_page,
                 InputMethodLookupTable::Orientation orientation);
   virtual ~CandidateView() {}
   // Initializes the candidate view with the given column widths.
@@ skipping 383 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_mozc_window_(false) {
 }
 
 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));
 
   // Create areas.
   preedit_area_ = new InformationTextArea(views::Label::ALIGN_LEFT,
@@ skipping 78 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()) {
+    std::string old_serialized_msg;
+    std::string new_serialized_msg;
+    if (old_table.mozc_candidates.SerializeToString(&old_serialized_msg)) {
+      return true;
+    }
+    if (new_table.mozc_candidates.SerializeToString(&new_serialized_msg)) {
+      // It might be safe to avoid update if the protocol buffer sent from
+      // mozc-engine is broken.
+      return false;
+    }
+    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);
 
+    // Stores mozc specific window location.
+    if (new_lookup_table.mozc_candidates.has_window_location()) {
+      if (new_lookup_table.mozc_candidates.window_location() ==
+          mozc::commands::Candidates::CARET) {
+        DCHECK(new_lookup_table.mozc_candidates.has_caret_rectangle());
+        window_location_for_mozc_engine_.set_x(
+            new_lookup_table.mozc_candidates.caret_rectangle().x());
+        window_location_for_mozc_engine_.set_y(
+            new_lookup_table.mozc_candidates.caret_rectangle().y());
+        window_location_for_mozc_engine_.set_width(
+            new_lookup_table.mozc_candidates.caret_rectangle().width());
+        window_location_for_mozc_engine_.set_height(
+            new_lookup_table.mozc_candidates.caret_rectangle().height());
+      } else {
+        DCHECK(new_lookup_table.mozc_candidates.has_composition_rectangle());
+        window_location_for_mozc_engine_.set_x(
+            new_lookup_table.mozc_candidates.composition_rectangle().x());
+        window_location_for_mozc_engine_.set_y(
+            new_lookup_table.mozc_candidates.composition_rectangle().y());
+        window_location_for_mozc_engine_.set_width(
+            new_lookup_table.mozc_candidates.composition_rectangle().width());
+        window_location_for_mozc_engine_.set_height(
+            new_lookup_table.mozc_candidates.composition_rectangle().height());
+      }
+      is_mozc_window_ = true;
+    } else {
+      is_mozc_window_ = 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_mozc_window_ ?
+      window_location_for_mozc_engine_.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 concern about
+  // multi-line composition,
+  const int y = is_mozc_window_ ?
+      std::max(window_location_for_mozc_engine_.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 479 matching lines @@
 CandidateWindowController::~CandidateWindowController() {
   delete impl_;
 }
 
 bool CandidateWindowController::Init() {
   return impl_->Init();
 }
 
 }  // namespace input_method
 }  // namespace chromeos