blob: 3a4083c4c8e1aa3b57eb916f32126c64a7f3a89b [file] [log] [blame]
// 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 <vector>
#include "base/basictypes.h"
#include "base/strings/string16.h"
#include "third_party/npapi/bindings/npapi.h"
#include "ui/gfx/rect.h"
namespace content {
class PluginInstance;
// A class that emulates an IME for windowless plug-ins. A windowless plug-in
// does not have a window. Therefore, we cannot attach an IME to a windowless
// plug-in. To allow such windowless plug-ins to use IMEs without any changes to
// them, this class receives the IME data from a browser and patches IMM32
// functions to return the IME data when a windowless plug-in calls IMM32
// functions. I would not Flash retrieves pointers to IMM32 functions with
// GetProcAddress(), this class also needs a hook to GetProcAddress() to
// dispatch IMM32 function calls from a plug-in to this class as listed in the
// following snippet.
// FARPROC WINAPI GetProcAddressPatch(HMODULE module, LPCSTR name) {
// FARPROC* proc = WebPluginIMEWin::GetProcAddress(name);
// if (proc)
// return proc;
// return ::GetProcAddress(module, name);
// }
// ...
// app::win::IATPatchFunction get_proc_address;
// get_proc_address.Patch(
// GetPluginPath().value().c_str(), "kernel32.dll", "GetProcAddress",
// GetProcAddressPatch);
// After we successfuly dispatch IMM32 calls from a plug-in to this class, we
// need to update its IME data so the class can return it to the plug-in through
// its IMM32 calls. To update the IME data, we call CompositionUpdated() or
// CompositionCompleted() BEFORE sending an IMM32 Window message to the plugin
// with a SendEvents() call as listed in the following snippet. (Plug-ins call
// IMM32 functions when it receives IMM32 window messages. We need to update the
// IME data of this class before sending IMM32 messages so the plug-ins can get
// the latest data.)
// WebPluginIMEWin ime;
// ...
// base::string16 text = "composing";
// std::vector<int> clauses;
// clauses.push_back(0);
// clauses.push_back(text.length());
// std::vector<int> target;
// ime.CompositionUpdated(text, clauses, target, text.length());
// ime.SendEvents(instance());
// base::string16 result = "result";
// ime.CompositionCompleted(result);
// ime.SendEvents(instance());
// This class also provides GetStatus() so we can retrieve the IME status
// changed by a plug-in with IMM32 functions. This function is mainly used for
// retrieving the position of a caret.
class WebPluginIMEWin {
// A simple class that allows a plug-in to access a WebPluginIMEWin instance
// only in a scope.
class ScopedLock {
explicit ScopedLock(WebPluginIMEWin* instance) : instance_(instance) {
if (instance_)
~ScopedLock() {
if (instance_)
WebPluginIMEWin* instance_;
// Sends raw IME events sent from a browser to this IME emulator and updates
// the list of Windows events to be sent to a plug-in. A raw IME event is
// mapped to two or more Windows events and it is not so trivial to send these
// Windows events to a plug-in. This function inserts Windows events in the
// order expected by a plug-in.
void CompositionUpdated(const base::string16& text,
std::vector<int> clauses,
std::vector<int> target,
int cursor_position);
void CompositionCompleted(const base::string16& text);
// Send all the events added in Update() to a plug-in.
bool SendEvents(PluginInstance* instance);
// Retrieves the status of this IME emulator.
bool GetStatus(int* input_type, gfx::Rect* caret_rect);
// Returns the pointers to IMM32-emulation functions implemented by this
// class. This function is used for over-writing the ones returned from
// GetProcAddress() calls of Win32 API.
static FARPROC GetProcAddress(const char* name);
// Allow (or disallow) the patch functions to use this WebPluginIMEWin
// instance through our patch functions. Our patch functions need a static
// member variable |instance_| to access a WebPluginIMEWIn instance. We lock
// this static variable to prevent two or more plug-ins from accessing a
// WebPluginIMEWin instance.
void Lock();
void Unlock();
// Retrieve the instance of this class.
static WebPluginIMEWin* GetInstance(HIMC context);
// IMM32 patch functions implemented by this class.
static BOOL WINAPI ImmAssociateContextEx(HWND window,
HIMC context,
DWORD flags);
static LONG WINAPI ImmGetCompositionStringW(HIMC context,
DWORD index,
LPVOID dst_data,
DWORD dst_size);
static HIMC WINAPI ImmGetContext(HWND window);
static BOOL WINAPI ImmReleaseContext(HWND window, HIMC context);
static BOOL WINAPI ImmSetCandidateWindow(HIMC context,
CANDIDATEFORM* candidate);
static BOOL WINAPI ImmSetOpenStatus(HIMC context, BOOL open);
// a list of NPEvents to be sent to a plug-in.
std::vector<NPEvent> events_;
// The return value for GCS_COMPSTR.
base::string16 composition_text_;
// The return value for GCS_RESULTSTR.
base::string16 result_text_;
// The return value for GCS_COMPATTR.
std::string composition_attributes_;
// The return value for GCS_COMPCLAUSE.
std::vector<uint32> composition_clauses_;
// The return value for GCS_RESULTCLAUSE.
uint32 result_clauses_[2];
// The return value for GCS_CURSORPOS.
int cursor_position_;
// The return value for GCS_DELTASTART.
int delta_start_;
// Whether we are composing text. This variable is used for sending a
// WM_IME_STARTCOMPOSITION message when we start composing IME text.
bool composing_text_;
// Whether a plug-in supports IME messages. When a plug-in cannot handle
// IME messages, we need to send the IME text with WM_CHAR messages as Windows
// does.
bool support_ime_messages_;
// The IME status received from a plug-in.
bool status_updated_;
int input_type_;
gfx::Rect caret_rect_;
// The pointer to the WebPluginIMEWin instance used by patch functions.
static WebPluginIMEWin* instance_;
} // namespace content