text: // Copyright 2013 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.
  
  #ifndef UI_BASE_IME_CHROMEOS_CHARACTER_COMPOSER_H_
  #define UI_BASE_IME_CHROMEOS_CHARACTER_COMPOSER_H_
  
  #include <stddef.h>
  #include <stdint.h>
  
  #include <vector>
  
  #include "base/macros.h"
  #include "base/strings/string_util.h"
  #include "ui/base/ime/ui_base_ime_export.h"
  #include "ui/events/keycodes/dom/dom_key.h"
  
  namespace ui {
  class KeyEvent;
  
  // A class to recognize compose and dead key sequence.
  // Outputs composed character.
  class UI_BASE_IME_EXPORT CharacterComposer {
   public:
    using ComposeBuffer = std::vector<DomKey>;
  
    CharacterComposer();
    ~CharacterComposer();
  
    void Reset();
  
    // Filters keypress.
    // Returns true if the keypress is recognized as a part of composition
    // sequence.
    // Fabricated events which don't have the native event, are not supported.
    bool FilterKeyPress(const ui::KeyEvent& event);
  
    // Returns a string consisting of composed character.
    // Empty string is returned when there is no composition result.
    const base::string16& composed_character() const {
      return composed_character_;
    }
  
    // Returns the preedit string.
    const base::string16& preedit_string() const { return preedit_string_; }
  
   private:
    // An enum to describe composition mode.
    enum CompositionMode {
      // This is the initial state.
      // Composite a character with dead-keys and compose-key.
      KEY_SEQUENCE_MODE,
      // Composite a character with a hexadecimal unicode sequence.
      HEX_MODE,
    };
  
    // Filters keypress in key sequence mode.
    bool FilterKeyPressSequenceMode(const ui::KeyEvent& event);
  
    // Filters keypress in hexadecimal mode.
    bool FilterKeyPressHexMode(const ui::KeyEvent& event);
  
    // Commit a character composed from hexadecimal uncode sequence
    void CommitHex();
  
    // Updates preedit string in hexadecimal mode.
    void UpdatePreeditStringHexMode();
  
    // Remembers keypresses previously filtered.
    std::vector<DomKey> compose_buffer_;
  
    // Records hexadecimal digits previously filtered.
    std::vector<unsigned int> hex_buffer_;
  
    // A string representing the composed character.
    base::string16 composed_character_;
  
    // Preedit string.
    base::string16 preedit_string_;
  
    // Composition mode which this instance is in.
    CompositionMode composition_mode_;
  
    DISALLOW_COPY_AND_ASSIGN(CharacterComposer);
  };
  
  // Abstract class for determining whether a ComposeBuffer forms a valid
  // character composition sequence.
  class ComposeChecker {
   public:
    enum class CheckSequenceResult {
      // The sequence is not a composition sequence or the prefix of any
      // composition sequence.
      NO_MATCH,
      // The sequence is a prefix of one or more composition sequences.
      PREFIX_MATCH,
      // The sequence matches a composition sequence.
      FULL_MATCH
    };
    ComposeChecker() {}
    virtual ~ComposeChecker() {}
    virtual CheckSequenceResult CheckSequence(
        const ui::CharacterComposer::ComposeBuffer& sequence,
        uint32_t* composed_character) const = 0;
   private:
    DISALLOW_COPY_AND_ASSIGN(ComposeChecker);
  };
  
  // Implementation of |ComposeChecker| using a compact generated tree.
  class TreeComposeChecker : public ComposeChecker {
   public:
    struct CompositionData {
      size_t maximum_sequence_length;
      int tree_entries;
      const uint16_t* tree;
    };
  
    TreeComposeChecker(const CompositionData& data) : data_(data) {}
    CheckSequenceResult CheckSequence(
        const ui::CharacterComposer::ComposeBuffer& sequence,
        uint32_t* composed_character) const override;
  
   private:
    bool Find(uint16_t index, uint16_t size, uint16_t key, uint16_t* value) const;
    const CompositionData& data_;
  };
  
  }  // namespace ui
  
  #endif  // UI_BASE_IME_CHROMEOS_CHARACTER_COMPOSER_H_
  