Add two libcros interfaces for handwriting: SendHandwritingStrokes and CancelHandwriting.

chromeos_input_method.cc

-// Copyright (c) 2010 The Chromium OS Authors. All rights reserved.
+// Copyright (c) 2011 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 SendHandwritingStroke(const HandwritingStroke& stroke) {
+    if (stroke.size() < 2) {
+      LOG(WARNING) << "Empty stroke data or a single dot is passed.";
+      return;
+    }
+
+    IBusInputContext* context = GetInputContext(input_context_path_, ibus_);
+    if (!context) {
+      return;
+    }
+
+    const size_t raw_stroke_size = stroke.size() * 2;
+    scoped_array<double> raw_stroke(new double[raw_stroke_size]);
+    for (size_t n = 0; n < stroke.size(); ++n) {
+      raw_stroke[n * 2] = stroke[n].first;  // x
+      raw_stroke[n * 2 + 1] = stroke[n].second;  // y
+    }
+    ibus_input_context_process_hand_writing_event(
+        context, raw_stroke.get(), raw_stroke_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 ChromeOSSendHandwritingStroke(InputMethodStatusConnection* connection,
+                                   const HandwritingStroke& stroke) {
+  g_return_if_fail(connection);
+  connection->SendHandwritingStroke(stroke);
+}
+
+extern "C"
+void ChromeOSCancelHandwriting(InputMethodStatusConnection* connection,
+                               int n_strokes) {
+  g_return_if_fail(connection);
+  connection->CancelHandwriting(n_strokes);
+}
+
 }  // namespace chromeos