PPAPI: Move IMEInputEvent and TextInput to stable.

ppapi/examples/ime/ime.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 <string>
 #include <utility>
 #include <vector>
 
 #include "ppapi/c/dev/ppb_cursor_control_dev.h"
 #include "ppapi/c/ppb_console.h"
 #include "ppapi/cpp/completion_callback.h"
 #include "ppapi/cpp/dev/font_dev.h"
-#include "ppapi/cpp/dev/ime_input_event_dev.h"
-#include "ppapi/cpp/dev/text_input_dev.h"
 #include "ppapi/cpp/graphics_2d.h"
 #include "ppapi/cpp/image_data.h"
 #include "ppapi/cpp/input_event.h"
 #include "ppapi/cpp/instance.h"
 #include "ppapi/cpp/module.h"
 #include "ppapi/cpp/rect.h"
 #include "ppapi/cpp/size.h"
+#include "ppapi/cpp/text_input_controller.h"
 
 namespace {
 
 // Extracted from: ui/base/keycodes/keyboard_codes.h
 enum {
   VKEY_BACK = 0x08,
   VKEY_SHIFT = 0x10,
   VKEY_DELETE = 0x2E,
   VKEY_LEFT = 0x25,
   VKEY_UP = 0x26,
@@ skipping 51 matching lines @@
   for (size_t step = 0; step < n; ++step)
     i = GetNextCharOffsetUtf8(str, i);
   return i;
 }
 
 }  // namespace
 
 class TextFieldStatusHandler {
  public:
   virtual ~TextFieldStatusHandler() {}
-  virtual void FocusIn(const pp::Rect& caret, const pp::Rect& bounding_box) {}
+  virtual void FocusIn(const pp::Rect& caret) {}
   virtual void FocusOut() {}
   virtual void UpdateSelection(const std::string& text) {}
 };
 
 class TextFieldStatusNotifyingHandler : public TextFieldStatusHandler {
  public:
   explicit TextFieldStatusNotifyingHandler(pp::Instance* instance)
       : textinput_control_(instance) {
   }
 
  protected:
   // Implement TextFieldStatusHandler.
-  virtual void FocusIn(const pp::Rect& caret, const pp::Rect& bounding_box) {
+  virtual void FocusIn(const pp::Rect& caret) {
     textinput_control_.SetTextInputType(PP_TEXTINPUT_TYPE_TEXT);
-    textinput_control_.UpdateCaretPosition(caret, bounding_box);
+    textinput_control_.UpdateCaretPosition(caret);
   }
   virtual void FocusOut() {
     textinput_control_.CancelCompositionText();
     textinput_control_.SetTextInputType(PP_TEXTINPUT_TYPE_NONE);
   }
   virtual void UpdateSelection(const std::string& text) {
-    textinput_control_.SetSelectionText(text);
-    textinput_control_.SelectionChanged();
+    textinput_control_.UpdateSurroundingText(text, 0, text.size());
   }
 
  private:
-  class MyTextInput : public pp::TextInput_Dev {
-   public:
-    MyTextInput(pp::Instance* instance) : pp::TextInput_Dev(instance) {}
-    virtual void RequestSurroundingText(uint32_t characters) {
-      UpdateSurroundingText(selection_text_, 0, selection_text_.size());
-    }
-    void SetSelectionText(const std::string& text) { selection_text_ = text; }
-    std::string selection_text_;
-  };
-  MyTextInput textinput_control_;
+  pp::TextInputController textinput_control_;
 };
 
 // Hand-made text field for demonstrating text input API.
 class MyTextField {
  public:
   MyTextField(pp::Instance* instance, TextFieldStatusHandler* handler,
               int x, int y, int width, int height)
       : instance_(instance),
         status_handler_(handler),
         area_(x, y, width, height),
@@ skipping 227 matching lines @@
 
  private:
   // Notify the plugin instance that the caret position has changed.
   void CaretPosChanged() {
     if (Focused()) {
       std::string str = utf8_text_.substr(0, caret_pos_);
       if (!composition_.empty())
         str += composition_.substr(0, composition_selection_.first);
       int px = font_.MeasureSimpleText(str);
       pp::Rect caret(area_.x() + px, area_.y(), 0, area_.height() + 2);
-      status_handler_->FocusIn(caret, area_);
+      status_handler_->FocusIn(caret);
       status_handler_->UpdateSelection(
           utf8_text_.substr(SelectionLeft(),
                             SelectionRight() - SelectionLeft()));
     }
   }
   size_t SelectionLeft() const {
     return std::min(caret_pos_, anchor_pos_);
   }
   size_t SelectionRight() const {
     return std::max(caret_pos_, anchor_pos_);
@@ skipping 33 matching lines @@
     RequestInputEvents(PP_INPUTEVENT_CLASS_MOUSE);
     RequestFilteringInputEvents(PP_INPUTEVENT_CLASS_KEYBOARD);
 
     for (uint32_t i = 0; i < argc; ++i) {
       if (argn[i] == std::string("ime")) {
         if (argv[i] == std::string("no")) {
           // Example of NO-IME plugins (e.g., games).
           //
           // When a plugin never wants to accept text input, at initialization
           // explicitly turn off the text input feature by calling:
-          pp::TextInput_Dev(this).SetTextInputType(PP_TEXTINPUT_TYPE_NONE);
+          pp::TextInputController(this).SetTextInputType(
+              PP_TEXTINPUT_TYPE_NONE);
         } else if (argv[i] == std::string("unaware")) {
           // Demonstrating the behavior of IME-unaware plugins.
           // Never call any text input related APIs.
           //
           // In such a case, the plugin is assumed to always accept text input.
           // For example, when the plugin is focused in touch devices a virtual
           // keyboard may pop up, or in environment IME is used, users can type
           // text via IME on the plugin. The characters are delivered to the
           // plugin via PP_INPUTEVENT_TYPE_CHAR events.
         } else if (argv[i] == std::string("caretmove")) {
@@ skipping 53 matching lines @@
         ret = OnKeyDown(keyEvent);
         break;
       }
       case PP_INPUTEVENT_TYPE_CHAR: {
         const pp::KeyboardInputEvent keyEvent(event);
         Log("Char [" + keyEvent.GetCharacterText().AsString() + "]");
         ret = OnChar(keyEvent);
         break;
       }
       case PP_INPUTEVENT_TYPE_IME_COMPOSITION_START: {
-        const pp::IMEInputEvent_Dev imeEvent(event);
+        const pp::IMEInputEvent imeEvent(event);
         Log("CompositionStart [" + imeEvent.GetText().AsString() + "]");
         ret = true;
         break;
       }
       case PP_INPUTEVENT_TYPE_IME_COMPOSITION_UPDATE: {
-        const pp::IMEInputEvent_Dev imeEvent(event);
+        const pp::IMEInputEvent imeEvent(event);
         Log("CompositionUpdate [" + imeEvent.GetText().AsString() + "]");
         ret = OnCompositionUpdate(imeEvent);
         break;
       }
       case PP_INPUTEVENT_TYPE_IME_COMPOSITION_END: {
-        const pp::IMEInputEvent_Dev imeEvent(event);
+        const pp::IMEInputEvent imeEvent(event);
         Log("CompositionEnd [" + imeEvent.GetText().AsString() + "]");
         ret = OnCompositionEnd(imeEvent);
         break;
       }
       case PP_INPUTEVENT_TYPE_IME_TEXT: {
-        const pp::IMEInputEvent_Dev imeEvent(event);
+        const pp::IMEInputEvent imeEvent(event);
         Log("ImeText [" + imeEvent.GetText().AsString() + "]");
         ret = OnImeText(imeEvent);
         break;
       }
       default:
         break;
     }
     if (ret && (dragging_ || event.GetType() != PP_INPUTEVENT_TYPE_MOUSEMOVE))
       Paint();
     return ret;
   }
 
   virtual void DidChangeView(const pp::Rect& position, const pp::Rect& clip) {
     if (position.size() == last_size_)
       return;
     last_size_ = position.size();
     Paint();
   }
 
  private:
-  bool OnCompositionUpdate(const pp::IMEInputEvent_Dev& ev) {
+  bool OnCompositionUpdate(const pp::IMEInputEvent& ev) {
     for (std::vector<MyTextField>::iterator it = textfield_.begin();
          it != textfield_.end();
          ++it) {
       if (it->Focused()) {
         std::vector< std::pair<uint32_t, uint32_t> > segs;
         for (uint32_t i = 0; i < ev.GetSegmentNumber(); ++i)
           segs.push_back(std::make_pair(ev.GetSegmentOffset(i),
                                         ev.GetSegmentOffset(i + 1)));
+        uint32_t selection_start;
+        uint32_t selection_end;
+        ev.GetSelection(&selection_start, &selection_end);
         it->SetComposition(ev.GetText().AsString(),
                            segs,
                            ev.GetTargetSegment(),
-                           ev.GetSelection());
+                           std::make_pair(selection_start, selection_end));
         return true;
       }
     }
     return false;
   }
 
-  bool OnCompositionEnd(const pp::IMEInputEvent_Dev& ev) {
+  bool OnCompositionEnd(const pp::IMEInputEvent& ev) {
     for (std::vector<MyTextField>::iterator it = textfield_.begin();
          it != textfield_.end();
          ++it) {
       if (it->Focused()) {
         it->SetComposition(std::string(),
                            std::vector<std::pair<uint32_t, uint32_t> >(),
                            0,
                            std::make_pair(0, 0));
         return true;
       }
@@ skipping 86 matching lines @@
       if (it->Focused()) {
         std::string str = ev.GetCharacterText().AsString();
         if (str != "\r" && str != "\n")
           it->InsertText(str);
         return true;
       }
     }
     return false;
   }
 
-  bool OnImeText(const pp::IMEInputEvent_Dev ev) {
+  bool OnImeText(const pp::IMEInputEvent ev) {
     for (std::vector<MyTextField>::iterator it = textfield_.begin();
          it != textfield_.end();
          ++it) {
       if (it->Focused()) {
         it->InsertText(ev.GetText().AsString());
         return true;
       }
     }
     return false;
   }
@@ skipping 48 matching lines @@
   }
 };
 
 namespace pp {
 
 Module* CreateModule() {
   return new MyModule();
 }
 
 }  // namespace pp