| // 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 <msctf.h> |
| #include "base/logging.h" |
| #include "base/memory/ref_counted.h" |
| #include "base/memory/scoped_ptr.h" |
| #include "base/memory/singleton.h" |
| #include "base/message_loop.h" |
| #include "base/threading/thread_local_storage.h" |
| #include "base/win/scoped_comptr.h" |
| #include "base/win/scoped_variant.h" |
| #include "ui/base/ime/text_input_client.h" |
| #include "ui/base/win/tsf_bridge.h" |
| #include "ui/base/win/tsf_text_store.h" |
| |
| namespace ui { |
| |
| namespace { |
| |
| // A TLS implementation of TsfBridge. |
| class TsfBridgeDelegate : public TsfBridge { |
| public: |
| TsfBridgeDelegate() |
| : source_cookie_(TF_INVALID_COOKIE), |
| client_id_(TF_CLIENTID_NULL), |
| client_(NULL) { |
| } |
| |
| virtual ~TsfBridgeDelegate() { |
| } |
| |
| // TsfBridge override. |
| bool Initialize() { |
| DCHECK_EQ(MessageLoop::TYPE_UI, MessageLoop::current()->type()); |
| if (client_id_ != TF_CLIENTID_NULL) { |
| VLOG(1) << "Already initialized."; |
| return false; |
| } |
| |
| if (FAILED(thread_manager_.CreateInstance(CLSID_TF_ThreadMgr))) { |
| VLOG(1) << "Failed to create ThreadManager instance."; |
| return false; |
| } |
| |
| if (FAILED(thread_manager_->Activate(&client_id_))) { |
| VLOG(1) << "Failed to activate Thread Manager."; |
| return false; |
| } |
| |
| if (!InitializeForEnabledDocumentManager()) |
| return false; |
| |
| if (!InitializeForPasswordDocumentManager()) |
| return false; |
| |
| if (!InitializeForDisabledDocumentManager()) |
| return false; |
| |
| // Japanese IME expectes the default value of this compartment is |
| // TF_SENTENCEMODE_PHRASEPREDICT like IMM32 implementation. This value is |
| // managed per thread, so that it is enough to set this value at once. This |
| // value does not affect other language's IME behaviors. |
| base::win::ScopedComPtr<ITfCompartmentMgr> thread_compartment_manager; |
| if (FAILED(thread_compartment_manager.QueryFrom(thread_manager_))) { |
| VLOG(1) << "Failed to get ITfCompartmentMgr."; |
| return false; |
| } |
| |
| base::win::ScopedComPtr<ITfCompartment> sentence_compartment; |
| if (FAILED(thread_compartment_manager->GetCompartment( |
| GUID_COMPARTMENT_KEYBOARD_INPUTMODE_SENTENCE, |
| sentence_compartment.Receive()))) { |
| VLOG(1) << "Failed to get sentence compartment."; |
| return false; |
| } |
| |
| base::win::ScopedVariant sentence_variant; |
| sentence_variant.Set(TF_SENTENCEMODE_PHRASEPREDICT); |
| if (FAILED(sentence_compartment->SetValue(client_id_, &sentence_variant))) { |
| VLOG(1) << "Failed to change the sentence mode."; |
| return false; |
| } |
| |
| return true; |
| } |
| |
| // TsfBridge override. |
| virtual void Shutdown() OVERRIDE { |
| DCHECK_EQ(MessageLoop::TYPE_UI, MessageLoop::current()->type()); |
| if (!IsInitialized()) |
| return; |
| base::win::ScopedComPtr<ITfContext> context; |
| if (FAILED(document_manager_for_editable_->GetTop(context.Receive()))) |
| return; |
| base::win::ScopedComPtr<ITfSource> source; |
| if (FAILED(source.QueryFrom(context))) |
| return; |
| if (source_cookie_ == TF_INVALID_COOKIE) |
| return; |
| if (FAILED(source->UnadviseSink(source_cookie_))) |
| return; |
| |
| DCHECK(text_store_.get()); |
| text_store_.reset(); |
| client_id_ = TF_CLIENTID_NULL; |
| } |
| |
| // TsfBridge override. |
| virtual void OnTextInputTypeChanged(TextInputClient* client) OVERRIDE { |
| DCHECK_EQ(MessageLoop::TYPE_UI, MessageLoop::current()->type()); |
| DCHECK(IsInitialized()); |
| |
| if (client != client_) { |
| // Called from not focusing client. Do nothing. |
| return; |
| } |
| |
| DCHECK(client_); |
| const TextInputType type = client_->GetTextInputType(); |
| switch (type) { |
| case TEXT_INPUT_TYPE_NONE: |
| thread_manager_->SetFocus(document_manager_for_non_editable_); |
| break; |
| case TEXT_INPUT_TYPE_PASSWORD: |
| thread_manager_->SetFocus(document_manager_for_password_); |
| break; |
| default: |
| thread_manager_->SetFocus(document_manager_for_editable_); |
| break; |
| } |
| } |
| |
| // TsfBridge override. |
| virtual bool CancelComposition() OVERRIDE { |
| DCHECK_EQ(MessageLoop::TYPE_UI, MessageLoop::current()->type()); |
| DCHECK(IsInitialized()); |
| // If the current focused document manager is not |
| // |document_manager_for_editable_|, do nothing here. |
| if (!IsFocused(document_manager_for_editable_)) |
| return false; |
| |
| base::win::ScopedComPtr<ITfContext> context; |
| if (FAILED(document_manager_for_editable_->GetTop(context.Receive()))) { |
| VLOG(1) << "Failed to get top context."; |
| return false; |
| } |
| |
| base::win::ScopedComPtr<ITfContextOwnerCompositionServices> owner; |
| if (FAILED(owner.QueryFrom(context))) { |
| VLOG(1) << "Failed to get ITfContextOwnerCompositionService."; |
| return false; |
| } |
| // Cancel all composition. |
| owner->TerminateComposition(NULL); |
| return true; |
| } |
| |
| // TsfBridge override. |
| virtual void SetFocusedClient(HWND focused_window, |
| TextInputClient* client) OVERRIDE { |
| DCHECK_EQ(MessageLoop::TYPE_UI, MessageLoop::current()->type()); |
| DCHECK(client); |
| DCHECK(IsInitialized()); |
| client_ = client; |
| text_store_->get()->SetFocusedTextInputClient(focused_window, client); |
| password_text_store_->get()->SetFocusedTextInputClient(focused_window, |
| client); |
| |
| // Synchronize text input type state. |
| OnTextInputTypeChanged(client); |
| } |
| |
| // TsfBridge override. |
| virtual void RemoveFocusedClient(TextInputClient* client) OVERRIDE { |
| DCHECK_EQ(MessageLoop::TYPE_UI, MessageLoop::current()->type()); |
| DCHECK(IsInitialized()); |
| if (client_ == client) { |
| client_ = NULL; |
| text_store_->get()->SetFocusedTextInputClient(NULL, NULL); |
| password_text_store_->get()->SetFocusedTextInputClient(NULL, NULL); |
| } |
| } |
| |
| private: |
| friend struct DefaultSingletonTraits<TsfBridgeDelegate>; |
| |
| // Initializes |document_manager_for_editable_|. |
| bool InitializeForEnabledDocumentManager() { |
| if (FAILED(thread_manager_->CreateDocumentMgr( |
| document_manager_for_editable_.Receive()))) { |
| VLOG(1) << "Failed to create Document Manager."; |
| return false; |
| } |
| |
| TfEditCookie unused_edit_cookie = TF_INVALID_EDIT_COOKIE; |
| text_store_.reset(new scoped_refptr<TsfTextStore>(new TsfTextStore())); |
| |
| base::win::ScopedComPtr<ITfContext> context; |
| if (FAILED(document_manager_for_editable_->CreateContext(client_id_, |
| 0, |
| static_cast<ITextStoreACP*>( |
| text_store_->get()), |
| context.Receive(), |
| &unused_edit_cookie))) { |
| VLOG(1) << "Failed to create Context."; |
| return false; |
| } |
| |
| if (FAILED(document_manager_for_editable_->Push(context))) { |
| VLOG(1) << "Failed to push context."; |
| return false; |
| } |
| |
| base::win::ScopedComPtr<ITfSource> source; |
| if (FAILED(source.QueryFrom(context))) { |
| VLOG(1) << "Failed to get source."; |
| return false; |
| } |
| |
| if (FAILED(source->AdviseSink(IID_ITfTextEditSink, |
| static_cast<ITfTextEditSink*>( |
| text_store_->get()), |
| &source_cookie_))) { |
| VLOG(1) << "AdviseSink failed."; |
| return false; |
| } |
| |
| if (source_cookie_ == TF_INVALID_COOKIE) { |
| VLOG(1) << "The result of cookie is invalid."; |
| return false; |
| } |
| |
| return true; |
| } |
| |
| // Initializes |document_manager_for_password_|. |
| bool InitializeForPasswordDocumentManager() { |
| if (FAILED(thread_manager_->CreateDocumentMgr( |
| document_manager_for_password_.Receive()))) { |
| VLOG(1) << "Failed to create Document Manager."; |
| return false; |
| } |
| |
| TfEditCookie unused_edit_cookie = TF_INVALID_EDIT_COOKIE; |
| password_text_store_.reset( |
| new scoped_refptr<TsfTextStore>(new TsfTextStore())); |
| |
| base::win::ScopedComPtr<ITfContext> context; |
| if (FAILED(document_manager_for_password_->CreateContext( |
| client_id_, |
| 0, |
| static_cast<ITextStoreACP*>(password_text_store_->get()), |
| context.Receive(), |
| &unused_edit_cookie))) { |
| VLOG(1) << "Failed to create Context."; |
| return false; |
| } |
| |
| base::win::ScopedComPtr<ITfCompartmentMgr> compartment_mgr; |
| if (FAILED(compartment_mgr.QueryFrom(context))) { |
| VLOG(1) << "Failed to get CompartmentMgr."; |
| return false; |
| } |
| |
| base::win::ScopedComPtr<ITfCompartment> disabled_compartment; |
| if (FAILED(compartment_mgr->GetCompartment( |
| GUID_COMPARTMENT_KEYBOARD_DISABLED, |
| disabled_compartment.Receive()))) { |
| VLOG(1) << "Failed to get keyboard disabled compartment."; |
| return false; |
| } |
| |
| base::win::ScopedVariant variant; |
| variant.Set(static_cast<int32>(1)); |
| if (FAILED(disabled_compartment->SetValue(client_id_, &variant))) { |
| VLOG(1) << "Failed to disable the DocumentMgr."; |
| return false; |
| } |
| |
| base::win::ScopedComPtr<ITfCompartment> empty_context; |
| if (FAILED(compartment_mgr->GetCompartment(GUID_COMPARTMENT_EMPTYCONTEXT, |
| empty_context.Receive()))) { |
| VLOG(1) << "Failed to get empty context compartment."; |
| return false; |
| } |
| base::win::ScopedVariant empty_context_variant; |
| empty_context_variant.Set(static_cast<int32>(1)); |
| if (FAILED(empty_context->SetValue(client_id_, &empty_context_variant))) { |
| VLOG(1) << "Failed to set empty context."; |
| return false; |
| } |
| |
| if (FAILED(document_manager_for_password_->Push(context))) { |
| VLOG(1) << "Failed to push context."; |
| return false; |
| } |
| |
| base::win::ScopedComPtr<ITfSource> source; |
| if (FAILED(source.QueryFrom(context))) { |
| VLOG(1) << "Failed to get source."; |
| return false; |
| } |
| |
| if (FAILED(source->AdviseSink(IID_ITfTextEditSink, |
| static_cast<ITfTextEditSink*>( |
| password_text_store_->get()), |
| &source_cookie_))) { |
| VLOG(1) << "AdviseSink failed."; |
| return false; |
| } |
| |
| if (source_cookie_ == TF_INVALID_COOKIE) { |
| VLOG(1) << "The result of cookie is invalid."; |
| return false; |
| } |
| |
| return true; |
| } |
| |
| // Initializes |document_manager_for_non_editable_|. |
| bool InitializeForDisabledDocumentManager() { |
| if (FAILED(thread_manager_->CreateDocumentMgr( |
| document_manager_for_non_editable_.Receive()))) { |
| VLOG(1) << "Failed to create Document Manager."; |
| return false; |
| } |
| |
| base::win::ScopedComPtr<ITfContext> disabled_context; |
| DWORD disabled_edit_cookie; |
| // Passing NULL as ITextStoreACP to disable IMEs completely. |
| if (document_manager_for_non_editable_->CreateContext( |
| client_id_, |
| 0, |
| NULL, |
| disabled_context.Receive(), |
| &disabled_edit_cookie)) { |
| VLOG(1) << "Failed to create disabled Context"; |
| return false; |
| } |
| |
| base::win::ScopedComPtr<ITfCompartmentMgr> compartment_mgr; |
| if (FAILED(compartment_mgr.QueryFrom(disabled_context))) { |
| VLOG(1) << "Failed to get CompartmentMgr."; |
| return false; |
| } |
| |
| base::win::ScopedComPtr<ITfCompartment> disabled_compartment; |
| if (FAILED(compartment_mgr->GetCompartment( |
| GUID_COMPARTMENT_KEYBOARD_DISABLED, |
| disabled_compartment.Receive()))) { |
| VLOG(1) << "Failed to get keyboard disabled compartment."; |
| return false; |
| } |
| |
| base::win::ScopedVariant variant; |
| variant.Set(static_cast<int32>(1)); |
| if (FAILED(disabled_compartment->SetValue(client_id_, &variant))) { |
| VLOG(1) << "Failed to disable the DocumentMgr."; |
| return false; |
| } |
| |
| base::win::ScopedComPtr<ITfCompartment> empty_context; |
| if (FAILED(compartment_mgr->GetCompartment(GUID_COMPARTMENT_EMPTYCONTEXT, |
| empty_context.Receive()))) { |
| VLOG(1) << "Failed to get empty context compartment."; |
| return false; |
| } |
| base::win::ScopedVariant empty_context_variant; |
| empty_context_variant.Set(static_cast<int32>(1)); |
| if (FAILED(empty_context->SetValue(client_id_, &empty_context_variant))) { |
| VLOG(1) << "Failed to set empty context."; |
| return false; |
| } |
| |
| if (FAILED(document_manager_for_non_editable_->Push(disabled_context))) { |
| VLOG(1) << "Failed to push disabled context."; |
| return false; |
| } |
| |
| return true; |
| } |
| |
| // Returns true if |document_manager| is the focused document manager. |
| bool IsFocused(base::win::ScopedComPtr<ITfDocumentMgr> document_manager) { |
| base::win::ScopedComPtr<ITfDocumentMgr> focused_document_mangaer; |
| if (FAILED(thread_manager_->GetFocus(focused_document_mangaer.Receive()))) |
| return false; |
| return focused_document_mangaer.IsSameObject(document_manager); |
| } |
| |
| // Returns true if already initialized. |
| bool IsInitialized() { |
| return client_id_ != TF_CLIENTID_NULL; |
| } |
| |
| // An ITfContext object to be used in normal text field. This document manager |
| // contains a TsfTextStore instance and an activated context. |
| base::win::ScopedComPtr<ITfDocumentMgr> document_manager_for_editable_; |
| |
| // Altough TSF support IME enable/disable switching without context changing, |
| // some IMEs don't change their state. So we should switch a focus to a |
| // |document_manager_for_non_editable_| which contains deactivated context to |
| // disable IMEs. |
| base::win::ScopedComPtr<ITfDocumentMgr> document_manager_for_non_editable_; |
| |
| // In the case of password field, we can't use |
| // |document_manager_for_non_editable_| because password field should accept |
| // key input but IMEs must not be enbaled. In addition to this, a user expects |
| // on-screen keyboard layout should be changed to a sutable one on the |
| // password field. To achieve these requirements, we use a different document |
| // manager where 1) the context has special TSF compartments to specify IME |
| // status, and 2) TSF TextStore has a special input scope to specify password |
| // type keyboard layout. |
| base::win::ScopedComPtr<ITfDocumentMgr> document_manager_for_password_; |
| |
| // An ITfThreadMgr object to be used in focus and document management. |
| base::win::ScopedComPtr<ITfThreadMgr> thread_manager_; |
| |
| // A TextStore object to be used in communicating with IME for normal field. |
| scoped_ptr<scoped_refptr<TsfTextStore> > text_store_; |
| |
| // A TextStore object to be used in communicating with IME for password field. |
| scoped_ptr<scoped_refptr<TsfTextStore> > password_text_store_; |
| |
| DWORD source_cookie_; |
| TfClientId client_id_; |
| |
| // Current focused text input client. Do not free |client_|. |
| TextInputClient* client_; |
| |
| DISALLOW_COPY_AND_ASSIGN(TsfBridgeDelegate); |
| }; |
| |
| // We use thread local storage for TsfBridge lifespan management. |
| base::ThreadLocalStorage::StaticSlot tls_tsf_bridge = TLS_INITIALIZER; |
| |
| // Used for releasing TLS object. |
| void FreeTlsTsfBridgeDelegate(void* data) { |
| TsfBridgeDelegate* delegate = static_cast<TsfBridgeDelegate*>(data); |
| delete delegate; |
| } |
| |
| } // namespace |
| |
| TsfBridge::TsfBridge() { |
| } |
| |
| TsfBridge::~TsfBridge() { |
| } |
| |
| // static |
| bool TsfBridge::Initialize() { |
| if (MessageLoop::current()->type() != MessageLoop::TYPE_UI) { |
| VLOG(1) << "Do not use TsfBridge without UI thread."; |
| return false; |
| } |
| tls_tsf_bridge.Initialize(FreeTlsTsfBridgeDelegate); |
| TsfBridgeDelegate* delegate = new TsfBridgeDelegate(); |
| tls_tsf_bridge.Set(delegate); |
| return delegate->Initialize(); |
| } |
| |
| // static |
| TsfBridge* TsfBridge::ReplaceForTesting(TsfBridge* bridge) { |
| if (MessageLoop::current()->type() != MessageLoop::TYPE_UI) { |
| VLOG(1) << "Do not use TsfBridge without UI thread."; |
| return NULL; |
| } |
| TsfBridge* old_bridge = TsfBridge::GetInstance(); |
| tls_tsf_bridge.Set(bridge); |
| return old_bridge; |
| } |
| |
| // static |
| TsfBridge* TsfBridge::GetInstance() { |
| if (MessageLoop::current()->type() != MessageLoop::TYPE_UI) { |
| VLOG(1) << "Do not use TsfBridge without UI thread."; |
| return NULL; |
| } |
| TsfBridgeDelegate* delegate = |
| static_cast<TsfBridgeDelegate*>(tls_tsf_bridge.Get()); |
| DCHECK(delegate) << "Do no call GetInstance before TsfBridge::Initialize."; |
| return delegate; |
| } |
| |
| } // namespace ui |
