Add two libcros interfaces for handwriting: SendHandwritingStrokes and CancelHandwriting.

chromeos_input_method.cc

 // Copyright (c) 2010 The Chromium OS 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 "chromeos_input_method.h"
 
 #include "chromeos_input_method_ui.h"
 #include "chromeos_input_method_whitelist.h"
 #include "chromeos_keyboard_overlay_map.h"
 
 #include <ibus.h>
 
 #include <algorithm>  // for std::reverse.
 #include <cstdio>
 #include <cstring>  // for std::strcmp.
 #include <set>
 #include <sstream>
 #include <stack>
 #include <utility>
 
+#include "base/scoped_ptr.h"
 #include "base/singleton.h"
 #include "chromeos/string.h"  // for chromeos::SplitStringUsing.
 #include "ibus_input_methods.h"
 
 namespace chromeos {
 
 // Returns true if |input_method_id| is whitelisted.
 bool InputMethodIdIsWhitelisted(const std::string& input_method_id) {
   static std::set<std::string>* g_supported_input_methods = NULL;
   if (!g_supported_input_methods) {
@@ skipping 613 matching lines @@
     // Since |variant| is floating, ibus_config_set_value_async consumes
     // (takes ownership of) the variable.
 
     if (is_preload_engines) {
       DLOG(INFO) << "SetImeConfig: " << section << "/" << config_name
                  << ": " << value.ToString();
     }
     return true;
   }
 
+  void SendHandwritingStrokes(const HandwritingStrokes& strokes) {
+    if (strokes.size() < 2) {
+      LOG(WARNING) << "Empty stroke data or a single dot is passed.";

[Zachary Kuznia, 2011/04/27 09:45:46]

I think VLOG is preferred now.

[Yusuke Sato, 2011/04/27 10:10:33]

It seems that VLOG is not supported in the logging library for ChromeOS. So let
me keep the line as-is.

+      return;
+    }
+
+    IBusInputContext* context = GetInputContext(input_context_path_, ibus_);
+    if (!context) {
+      return;
+    }
+
+    const size_t raw_strokes_size = strokes.size() * 2;
+    scoped_array<double> raw_strokes(new double[raw_strokes_size]);
+    for (size_t n = 0; n < strokes.size(); ++n) {
+      raw_strokes[n * 2] = strokes[n].first;  // x
+      raw_strokes[n * 2 + 1] = strokes[n].second;  // y
+    }
+    ibus_input_context_process_hand_writing_event(
+        context, raw_strokes.get(), raw_strokes_size);
+    g_object_unref(context);
+  }
+
+  void CancelHandwriting(int n_strokes) {
+    IBusInputContext* context = GetInputContext(input_context_path_, ibus_);
+    if (!context) {
+      return;
+    }
+    ibus_input_context_cancel_hand_writing(context, n_strokes);
+    g_object_unref(context);
+  }
+
  private:
   friend struct DefaultSingletonTraits<InputMethodStatusConnection>;
   InputMethodStatusConnection()
       : current_input_method_changed_(NULL),
         register_ime_properties_(NULL),
         update_ime_property_(NULL),
         connection_change_handler_(NULL),
         language_library_(NULL),
         ibus_(NULL),
         ibus_config_(NULL) {
@@ skipping 510 matching lines @@
 extern "C"
 std::string ChromeOSGetKeyboardOverlayId(const std::string& input_method_id) {
   for (size_t i = 0; i < arraysize(kKeyboardOverlayMap); ++i) {
     if (kKeyboardOverlayMap[i].input_method_id == input_method_id) {
       return kKeyboardOverlayMap[i].keyboard_overlay_id;
     }
   }
   return "";
 }
 
+extern "C"
+void ChromeOSSendHandwritingStrokes(InputMethodStatusConnection* connection,
+                                    const HandwritingStrokes& strokes) {
+  g_return_if_fail(connection);
+  connection->SendHandwritingStrokes(strokes);
+}
+
+extern "C"
+void ChromeOSCancelHandwriting(InputMethodStatusConnection* connection,
+                               int n_strokes) {
+  g_return_if_fail(connection);
+  connection->CancelHandwriting(n_strokes);
+}
+
 }  // namespace chromeos