Pepper IME API for surrounding text retrieval.

ppapi/examples/ime/ime.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 <string>
 #include <utility>
 #include <vector>
 
 #include "ppapi/c/dev/ppb_console_dev.h"
 #include "ppapi/c/dev/ppb_cursor_control_dev.h"
@@ skipping 74 matching lines @@
   return i;
 }
 
 }  // namespace
 
 class TextFieldStatusHandler {
  public:
   virtual ~TextFieldStatusHandler() {}
   virtual void FocusIn(const pp::Rect& caret, const pp::Rect& bounding_box) {}
   virtual void FocusOut() {}
+  virtual void UpdateSelection(const std::string& text) {}
 };
 
-class TextFieldStatusNotifyingHanlder : public TextFieldStatusHandler {
+class TextFieldStatusNotifyingHandler : public TextFieldStatusHandler {
  public:
-  explicit TextFieldStatusNotifyingHanlder(pp::Instance* instance)
-      : instance_(instance),
-        textinput_control_(instance) {}
+  explicit TextFieldStatusNotifyingHandler(pp::Instance* instance)
+      : textinput_control_(instance) {
+  }
 
  protected:
+  // Implement TextFieldStatusHandler.
   virtual void FocusIn(const pp::Rect& caret, const pp::Rect& bounding_box) {
     textinput_control_.SetTextInputType(PP_TEXTINPUT_TYPE_TEXT);
     textinput_control_.UpdateCaretPosition(caret, bounding_box);
   }
   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();
+  }
 
  private:
-  pp::Instance* instance_;
-  pp::TextInput_Dev textinput_control_;
+  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_;
 };
 
 // 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 228 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_->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_);
   }
   bool HasSelection() const {
     return caret_pos_ != anchor_pos_;
@@ skipping 49 matching lines @@
           // plugin via PP_INPUTEVENT_TYPE_CHAR events.
         } else if (argv[i] == std::string("caretmove")) {
           // Demonstrating the behavior of plugins with limited IME support.
           //
           // It uses SetTextInputType() and UpdateCaretPosition() API to notify
           // text input status to the browser, but unable to handle inline
           // compositions. By using the notified information. the browser can,
           // say, show virtual keyboards or IMEs only at appropriate timing
           // that the plugin does need to accept text input.
           delete status_handler_;
-          status_handler_ = new TextFieldStatusNotifyingHanlder(this);
+          status_handler_ = new TextFieldStatusNotifyingHandler(this);
         } else if (argv[i] == std::string("full")) {
           // Demonstrating the behavior of plugins fully supporting IME.
           //
           // It notifies updates of caret positions to the browser,
           // and handles all text input events by itself.
           delete status_handler_;
-          status_handler_ = new TextFieldStatusNotifyingHanlder(this);
+          status_handler_ = new TextFieldStatusNotifyingHandler(this);
           RequestInputEvents(PP_INPUTEVENT_CLASS_IME);
         }
         break;
       }
     }
 
     textfield_.push_back(MyTextField(this, status_handler_,
                                      10, 10, 300, 20));
     textfield_.back().SetText("Hello");
     textfield_.push_back(MyTextField(this, status_handler_,
@@ skipping 259 matching lines @@
   }
 };
 
 namespace pp {
 
 Module* CreateModule() {
   return new MyModule();
 }
 
 }  // namespace pp