| OLD | NEW |
|---|
| (Empty) |
| 1 // Copyright (c) 2012 The Chromium Authors. All rights reserved. | |
| 2 // Use of this source code is governed by a BSD-style license that can be | |
| 3 // found in the LICENSE file. | |
| 4 | |
| 5 #include "ui/base/ime/win/tsf_event_router.h" | |
| 6 | |
| 7 #include <msctf.h> | |
| 8 #include <set> | |
| 9 #include <utility> | |
| 10 | |
| 11 #include "base/bind.h" | |
| 12 #include "base/win/scoped_comptr.h" | |
| 13 #include "base/win/metro.h" | |
| 14 #include "ui/base/win/atl_module.h" | |
| 15 #include "ui/gfx/range/range.h" | |
| 16 | |
| 17 namespace ui { | |
| 18 | |
| 19 | |
| 20 // TSFEventRouter::Delegate ------------------------------------ | |
| 21 | |
| 22 // The implementation class of ITfUIElementSink, whose member functions will be | |
| 23 // called back by TSF when the UI element status is changed, for example when | |
| 24 // the candidate window is opened or closed. This class also implements | |
| 25 // ITfTextEditSink, whose member function is called back by TSF when the text | |
| 26 // editting session is finished. | |
| 27 class ATL_NO_VTABLE TSFEventRouter::Delegate | |
| 28 : public ATL::CComObjectRootEx<CComSingleThreadModel>, | |
| 29 public ITfUIElementSink, | |
| 30 public ITfTextEditSink { | |
| 31 public: | |
| 32 BEGIN_COM_MAP(Delegate) | |
| 33 COM_INTERFACE_ENTRY(ITfUIElementSink) | |
| 34 COM_INTERFACE_ENTRY(ITfTextEditSink) | |
| 35 END_COM_MAP() | |
| 36 | |
| 37 Delegate(); | |
| 38 ~Delegate(); | |
| 39 | |
| 40 // ITfTextEditSink: | |
| 41 STDMETHOD(OnEndEdit)(ITfContext* context, TfEditCookie read_only_cookie, | |
| 42 ITfEditRecord* edit_record) OVERRIDE; | |
| 43 | |
| 44 // ITfUiElementSink: | |
| 45 STDMETHOD(BeginUIElement)(DWORD element_id, BOOL* is_show) OVERRIDE; | |
| 46 STDMETHOD(UpdateUIElement)(DWORD element_id) OVERRIDE; | |
| 47 STDMETHOD(EndUIElement)(DWORD element_id) OVERRIDE; | |
| 48 | |
| 49 // Sets |thread_manager| to be monitored. |thread_manager| can be NULL. | |
| 50 void SetManager(ITfThreadMgr* thread_manager); | |
| 51 | |
| 52 // Returns true if the IME is composing text. | |
| 53 bool IsImeComposing(); | |
| 54 | |
| 55 // Sets |router| to be forwarded TSF-related events. | |
| 56 void SetRouter(TSFEventRouter* router); | |
| 57 | |
| 58 private: | |
| 59 // Returns current composition range. Returns gfx::Range::InvalidRange if | |
| 60 // there is no composition. | |
| 61 static gfx::Range GetCompositionRange(ITfContext* context); | |
| 62 | |
| 63 // Returns true if the given |element_id| represents the candidate window. | |
| 64 bool IsCandidateWindowInternal(DWORD element_id); | |
| 65 | |
| 66 // A context associated with this class. | |
| 67 base::win::ScopedComPtr<ITfContext> context_; | |
| 68 | |
| 69 // The ITfSource associated with |context_|. | |
| 70 base::win::ScopedComPtr<ITfSource> context_source_; | |
| 71 | |
| 72 // The cookie for |context_source_|. | |
| 73 DWORD context_source_cookie_; | |
| 74 | |
| 75 // A UIElementMgr associated with this class. | |
| 76 base::win::ScopedComPtr<ITfUIElementMgr> ui_element_manager_; | |
| 77 | |
| 78 // The ITfSouce associated with |ui_element_manager_|. | |
| 79 base::win::ScopedComPtr<ITfSource> ui_source_; | |
| 80 | |
| 81 // The set of currently opened candidate window ids. | |
| 82 std::set<DWORD> open_candidate_window_ids_; | |
| 83 | |
| 84 // The cookie for |ui_source_|. | |
| 85 DWORD ui_source_cookie_; | |
| 86 | |
| 87 TSFEventRouter* router_; | |
| 88 gfx::Range previous_composition_range_; | |
| 89 | |
| 90 DISALLOW_COPY_AND_ASSIGN(Delegate); | |
| 91 }; | |
| 92 | |
| 93 TSFEventRouter::Delegate::Delegate() | |
| 94 : context_source_cookie_(TF_INVALID_COOKIE), | |
| 95 ui_source_cookie_(TF_INVALID_COOKIE), | |
| 96 router_(NULL), | |
| 97 previous_composition_range_(gfx::Range::InvalidRange()) { | |
| 98 } | |
| 99 | |
| 100 TSFEventRouter::Delegate::~Delegate() {} | |
| 101 | |
| 102 void TSFEventRouter::Delegate::SetRouter(TSFEventRouter* router) { | |
| 103 router_ = router; | |
| 104 } | |
| 105 | |
| 106 STDMETHODIMP TSFEventRouter::Delegate::OnEndEdit(ITfContext* context, | |
| 107 TfEditCookie read_only_cookie, | |
| 108 ITfEditRecord* edit_record) { | |
| 109 if (!edit_record || !context) | |
| 110 return E_INVALIDARG; | |
| 111 if (!router_) | |
| 112 return S_OK; | |
| 113 | |
| 114 // |edit_record| can be used to obtain updated ranges in terms of text | |
| 115 // contents and/or text attributes. Here we are interested only in text update | |
| 116 // so we use TF_GTP_INCL_TEXT and check if there is any range which contains | |
| 117 // updated text. | |
| 118 base::win::ScopedComPtr<IEnumTfRanges> ranges; | |
| 119 if (FAILED(edit_record->GetTextAndPropertyUpdates(TF_GTP_INCL_TEXT, NULL, 0, | |
| 120 ranges.Receive()))) | |
| 121 return S_OK; // Don't care about failures. | |
| 122 | |
| 123 ULONG fetched_count = 0; | |
| 124 base::win::ScopedComPtr<ITfRange> range; | |
| 125 if (FAILED(ranges->Next(1, range.Receive(), &fetched_count))) | |
| 126 return S_OK; // Don't care about failures. | |
| 127 | |
| 128 const gfx::Range composition_range = GetCompositionRange(context); | |
| 129 | |
| 130 if (!previous_composition_range_.IsValid() && composition_range.IsValid()) | |
| 131 router_->OnTSFStartComposition(); | |
| 132 | |
| 133 // |fetched_count| != 0 means there is at least one range that contains | |
| 134 // updated text. | |
| 135 if (fetched_count != 0) | |
| 136 router_->OnTextUpdated(composition_range); | |
| 137 | |
| 138 if (previous_composition_range_.IsValid() && !composition_range.IsValid()) | |
| 139 router_->OnTSFEndComposition(); | |
| 140 | |
| 141 previous_composition_range_ = composition_range; | |
| 142 return S_OK; | |
| 143 } | |
| 144 | |
| 145 STDMETHODIMP TSFEventRouter::Delegate::BeginUIElement(DWORD element_id, | |
| 146 BOOL* is_show) { | |
| 147 if (is_show) | |
| 148 *is_show = TRUE; // Without this the UI element will not be shown. | |
| 149 | |
| 150 if (!IsCandidateWindowInternal(element_id)) | |
| 151 return S_OK; | |
| 152 | |
| 153 std::pair<std::set<DWORD>::iterator, bool> insert_result = | |
| 154 open_candidate_window_ids_.insert(element_id); | |
| 155 // Don't call if |router_| is null or |element_id| is already handled. | |
| 156 if (router_ && insert_result.second) | |
| 157 router_->OnCandidateWindowCountChanged(open_candidate_window_ids_.size()); | |
| 158 | |
| 159 return S_OK; | |
| 160 } | |
| 161 | |
| 162 STDMETHODIMP TSFEventRouter::Delegate::UpdateUIElement( | |
| 163 DWORD element_id) { | |
| 164 return S_OK; | |
| 165 } | |
| 166 | |
| 167 STDMETHODIMP TSFEventRouter::Delegate::EndUIElement( | |
| 168 DWORD element_id) { | |
| 169 if ((open_candidate_window_ids_.erase(element_id) != 0) && router_) | |
| 170 router_->OnCandidateWindowCountChanged(open_candidate_window_ids_.size()); | |
| 171 return S_OK; | |
| 172 } | |
| 173 | |
| 174 void TSFEventRouter::Delegate::SetManager( | |
| 175 ITfThreadMgr* thread_manager) { | |
| 176 context_.Release(); | |
| 177 | |
| 178 if (context_source_) { | |
| 179 context_source_->UnadviseSink(context_source_cookie_); | |
| 180 context_source_.Release(); | |
| 181 } | |
| 182 context_source_cookie_ = TF_INVALID_COOKIE; | |
| 183 | |
| 184 ui_element_manager_.Release(); | |
| 185 if (ui_source_) { | |
| 186 ui_source_->UnadviseSink(ui_source_cookie_); | |
| 187 ui_source_.Release(); | |
| 188 } | |
| 189 ui_source_cookie_ = TF_INVALID_COOKIE; | |
| 190 | |
| 191 if (!thread_manager) | |
| 192 return; | |
| 193 | |
| 194 base::win::ScopedComPtr<ITfDocumentMgr> document_manager; | |
| 195 if (FAILED(thread_manager->GetFocus(document_manager.Receive())) || | |
| 196 !document_manager.get() || | |
| 197 FAILED(document_manager->GetBase(context_.Receive())) || | |
| 198 FAILED(context_source_.QueryFrom(context_))) | |
| 199 return; | |
| 200 context_source_->AdviseSink(IID_ITfTextEditSink, | |
| 201 static_cast<ITfTextEditSink*>(this), | |
| 202 &context_source_cookie_); | |
| 203 | |
| 204 if (FAILED(ui_element_manager_.QueryFrom(thread_manager)) || | |
| 205 FAILED(ui_source_.QueryFrom(ui_element_manager_))) | |
| 206 return; | |
| 207 ui_source_->AdviseSink(IID_ITfUIElementSink, | |
| 208 static_cast<ITfUIElementSink*>(this), | |
| 209 &ui_source_cookie_); | |
| 210 } | |
| 211 | |
| 212 bool TSFEventRouter::Delegate::IsImeComposing() { | |
| 213 return context_ && GetCompositionRange(context_).IsValid(); | |
| 214 } | |
| 215 | |
| 216 // static | |
| 217 gfx::Range TSFEventRouter::Delegate::GetCompositionRange( | |
| 218 ITfContext* context) { | |
| 219 DCHECK(context); | |
| 220 base::win::ScopedComPtr<ITfContextComposition> context_composition; | |
| 221 if (FAILED(context_composition.QueryFrom(context))) | |
| 222 return gfx::Range::InvalidRange(); | |
| 223 base::win::ScopedComPtr<IEnumITfCompositionView> enum_composition_view; | |
| 224 if (FAILED(context_composition->EnumCompositions( | |
| 225 enum_composition_view.Receive()))) | |
| 226 return gfx::Range::InvalidRange(); | |
| 227 base::win::ScopedComPtr<ITfCompositionView> composition_view; | |
| 228 if (enum_composition_view->Next(1, composition_view.Receive(), | |
| 229 NULL) != S_OK) | |
| 230 return gfx::Range::InvalidRange(); | |
| 231 | |
| 232 base::win::ScopedComPtr<ITfRange> range; | |
| 233 if (FAILED(composition_view->GetRange(range.Receive()))) | |
| 234 return gfx::Range::InvalidRange(); | |
| 235 | |
| 236 base::win::ScopedComPtr<ITfRangeACP> range_acp; | |
| 237 if (FAILED(range_acp.QueryFrom(range))) | |
| 238 return gfx::Range::InvalidRange(); | |
| 239 | |
| 240 LONG start = 0; | |
| 241 LONG length = 0; | |
| 242 if (FAILED(range_acp->GetExtent(&start, &length))) | |
| 243 return gfx::Range::InvalidRange(); | |
| 244 | |
| 245 return gfx::Range(start, start + length); | |
| 246 } | |
| 247 | |
| 248 bool TSFEventRouter::Delegate::IsCandidateWindowInternal(DWORD element_id) { | |
| 249 DCHECK(ui_element_manager_.get()); | |
| 250 base::win::ScopedComPtr<ITfUIElement> ui_element; | |
| 251 if (FAILED(ui_element_manager_->GetUIElement(element_id, | |
| 252 ui_element.Receive()))) | |
| 253 return false; | |
| 254 base::win::ScopedComPtr<ITfCandidateListUIElement> candidate_list_ui_element; | |
| 255 return SUCCEEDED(candidate_list_ui_element.QueryFrom(ui_element)); | |
| 256 } | |
| 257 | |
| 258 | |
| 259 // TSFEventRouter ------------------------------------------------------------ | |
| 260 | |
| 261 TSFEventRouter::TSFEventRouter(TSFEventRouterObserver* observer) | |
| 262 : observer_(observer), | |
| 263 delegate_(NULL) { | |
| 264 DCHECK(base::win::IsTSFAwareRequired()) | |
| 265 << "Do not use TSFEventRouter without TSF environment."; | |
| 266 DCHECK(observer_); | |
| 267 CComObject<Delegate>* delegate; | |
| 268 ui::win::CreateATLModuleIfNeeded(); | |
| 269 if (SUCCEEDED(CComObject<Delegate>::CreateInstance(&delegate))) { | |
| 270 delegate->AddRef(); | |
| 271 delegate_.Attach(delegate); | |
| 272 delegate_->SetRouter(this); | |
| 273 } | |
| 274 } | |
| 275 | |
| 276 TSFEventRouter::~TSFEventRouter() { | |
| 277 if (delegate_) { | |
| 278 delegate_->SetManager(NULL); | |
| 279 delegate_->SetRouter(NULL); | |
| 280 } | |
| 281 } | |
| 282 | |
| 283 bool TSFEventRouter::IsImeComposing() { | |
| 284 return delegate_->IsImeComposing(); | |
| 285 } | |
| 286 | |
| 287 void TSFEventRouter::OnCandidateWindowCountChanged(size_t window_count) { | |
| 288 observer_->OnCandidateWindowCountChanged(window_count); | |
| 289 } | |
| 290 | |
| 291 void TSFEventRouter::OnTSFStartComposition() { | |
| 292 observer_->OnTSFStartComposition(); | |
| 293 } | |
| 294 | |
| 295 void TSFEventRouter::OnTextUpdated(const gfx::Range& composition_range) { | |
| 296 observer_->OnTextUpdated(composition_range); | |
| 297 } | |
| 298 | |
| 299 void TSFEventRouter::OnTSFEndComposition() { | |
| 300 observer_->OnTSFEndComposition(); | |
| 301 } | |
| 302 | |
| 303 void TSFEventRouter::SetManager(ITfThreadMgr* thread_manager) { | |
| 304 delegate_->SetManager(thread_manager); | |
| 305 } | |
| 306 | |
| 307 } // namespace ui | |
| OLD | NEW |
|---|
Chromium Code Reviews
Issue 149073009:
Remove InputMethodTSF, TSFEventRouter, TSFTextStore, TSFBridge (Closed)
Base URL: svn://svn.chromium.org/chrome/trunk/src