Support TSF related event handling on NativeTextField

ui/base/ime/win/tsf_event_router.cc

 // 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 "ui/base/ime/win/tsf_event_router.h"
 
 #include <msctf.h>
 #include <set>
 #include <utility>
 
 #include "base/bind.h"
 #include "base/win/scoped_comptr.h"
 #include "base/win/metro.h"
+#include "ui/base/range/range.h"
 #include "ui/base/win/atl_module.h"
 
 namespace ui {
 
 
 // TsfEventRouter::TsfEventRouterDelegate  ------------------------------------
 
 // The implementation class of ITfUIElementSink, whose member functions will be
 // called back by TSF when the UI element status is changed, for example when
 // the candidate window is opened or closed. This class also implements
@@ skipping 25 matching lines @@
   // Sets |thread_manager| to be monitored. |thread_manager| can be NULL.
   void SetManager(ITfThreadMgr* thread_manager);
 
   // Returns true if the IME is composing text.
   bool IsImeComposing();
 
   // Sets |router| to be forwarded TSF-related events.
   void SetRouter(TsfEventRouter* router);
 
  private:
-  // Returns true if the given |context| is composing.
-  static bool IsImeComposingInternal(ITfContext* context);
+  // Returns current composition range. Returns ui::Range::InvalidRange if there
+  // is no composition.
+  static ui::Range GetCompositionRange(ITfContext* context);
 
   // Returns true if the given |element_id| represents the candidate window.
   bool IsCandidateWindowInternal(DWORD element_id);
 
   // A context associated with this class.
   base::win::ScopedComPtr<ITfContext> context_;
 
   // The ITfSource associated with |context_|.
   base::win::ScopedComPtr<ITfSource> context_source_;
 
   // The cookie for |context_source_|.
   DWORD context_source_cookie_;
 
   // A UIElementMgr associated with this class.
   base::win::ScopedComPtr<ITfUIElementMgr> ui_element_manager_;
 
   // The ITfSouce associated with |ui_element_manager_|.
   base::win::ScopedComPtr<ITfSource> ui_source_;
 
   // The set of currently opened candidate window ids.
   std::set<DWORD> open_candidate_window_ids_;
 
   // The cookie for |ui_source_|.
   DWORD ui_source_cookie_;
 
   TsfEventRouter* router_;
+  ui::Range previous_composition_range_;
 
   DISALLOW_COPY_AND_ASSIGN(TsfEventRouterDelegate);
 };
 
 TsfEventRouter::TsfEventRouterDelegate::TsfEventRouterDelegate()
     : context_source_cookie_(TF_INVALID_COOKIE),
       ui_source_cookie_(TF_INVALID_COOKIE),
-      router_(NULL) {
+      router_(NULL),
+      previous_composition_range_(ui::Range::InvalidRange()) {
 }
 
 TsfEventRouter::TsfEventRouterDelegate::~TsfEventRouterDelegate() {}
 
 void TsfEventRouter::TsfEventRouterDelegate::SetRouter(TsfEventRouter* router) {
   router_ = router;
 }
 
 STDMETHODIMP TsfEventRouter::TsfEventRouterDelegate::OnEndEdit(
     ITfContext* context,
@@ skipping 11 matching lines @@
   base::win::ScopedComPtr<IEnumTfRanges> ranges;
   if (FAILED(edit_record->GetTextAndPropertyUpdates(TF_GTP_INCL_TEXT, NULL, 0,
                                                     ranges.Receive())))
      return S_OK;  // Don't care about failures.
 
   ULONG fetched_count = 0;
   base::win::ScopedComPtr<ITfRange> range;
   if (FAILED(ranges->Next(1, range.Receive(), &fetched_count)))
     return S_OK;  // Don't care about failures.
 
+  const ui::Range composition_range = GetCompositionRange(context);
+
+  if (!previous_composition_range_.IsValid() && composition_range.IsValid())
+    router_->OnTsfStartComposition();
+
   // |fetched_count| != 0 means there is at least one range that contains
   // updated text.
   if (fetched_count != 0)
-    router_->OnTextUpdated();
+    router_->OnTextUpdated(composition_range);
+
+  if (previous_composition_range_.IsValid() && !composition_range.IsValid())
+    router_->OnTsfEndComposition();
+
+  previous_composition_range_ = composition_range;
   return S_OK;
 }
 
 STDMETHODIMP TsfEventRouter::TsfEventRouterDelegate::BeginUIElement(
     DWORD element_id,
     BOOL* is_show) {
   if (is_show)
     *is_show = TRUE;  // Without this the UI element will not be shown.
 
   if (!IsCandidateWindowInternal(element_id))
@@ skipping 51 matching lines @@
 
   if (FAILED(ui_element_manager_.QueryFrom(thread_manager)) ||
       FAILED(ui_source_.QueryFrom(ui_element_manager_)))
     return;
   ui_source_->AdviseSink(IID_ITfUIElementSink,
                          static_cast<ITfUIElementSink*>(this),
                          &ui_source_cookie_);
 }
 
 bool TsfEventRouter::TsfEventRouterDelegate::IsImeComposing() {
-  return context_ && IsImeComposingInternal(context_);
+  return context_ && GetCompositionRange(context_).IsValid();
 }
 
 // static
-bool TsfEventRouter::TsfEventRouterDelegate::IsImeComposingInternal(
+ui::Range TsfEventRouter::TsfEventRouterDelegate::GetCompositionRange(
     ITfContext* context) {
   DCHECK(context);
   base::win::ScopedComPtr<ITfContextComposition> context_composition;
   if (FAILED(context_composition.QueryFrom(context)))
-    return false;
+    return ui::Range::InvalidRange();
   base::win::ScopedComPtr<IEnumITfCompositionView> enum_composition_view;
   if (FAILED(context_composition->EnumCompositions(
       enum_composition_view.Receive())))
-    return false;
+    return ui::Range::InvalidRange();
   base::win::ScopedComPtr<ITfCompositionView> composition_view;
-  return enum_composition_view->Next(1, composition_view.Receive(),
-                                     NULL) == S_OK;
+  if (enum_composition_view->Next(1, composition_view.Receive(),
+                                  NULL) != S_OK)
+    return ui::Range::InvalidRange();
+
+  base::win::ScopedComPtr<ITfRange> range;
+  if (FAILED(composition_view->GetRange(range.Receive())))
+    return ui::Range::InvalidRange();
+
+  base::win::ScopedComPtr<ITfRangeACP> range_acp;
+  if (FAILED(range_acp.QueryFrom(range)))
+    return ui::Range::InvalidRange();
+
+  LONG start = 0;
+  LONG length = 0;
+  if (FAILED(range_acp->GetExtent(&start, &length)))
+    return ui::Range::InvalidRange();
+
+  return ui::Range(start, start + length);
 }
 
 bool TsfEventRouter::TsfEventRouterDelegate::IsCandidateWindowInternal(
     DWORD element_id) {
   DCHECK(ui_element_manager_.get());
   base::win::ScopedComPtr<ITfUIElement> ui_element;
   if (FAILED(ui_element_manager_->GetUIElement(element_id,
                                                ui_element.Receive())))
     return false;
   base::win::ScopedComPtr<ITfCandidateListUIElement> candidate_list_ui_element;
@@ skipping 19 matching lines @@
   }
 }
 
 TsfEventRouter::~TsfEventRouter() {
   if (delegate_) {
     delegate_->SetManager(NULL);
     delegate_->SetRouter(NULL);
   }
 }
 
+bool TsfEventRouter::IsImeComposing() {
+  return delegate_->IsImeComposing();
+}
+
+void TsfEventRouter::OnCandidateWindowCountChanged(size_t window_count) {
+  observer_->OnCandidateWindowCountChanged(window_count);
+}
+
+void TsfEventRouter::OnTsfStartComposition() {
+  observer_->OnTsfStartComposition();
+}
+
+void TsfEventRouter::OnTextUpdated(const ui::Range& composition_range) {
+  observer_->OnTextUpdated(composition_range);
+}
+
+void TsfEventRouter::OnTsfEndComposition() {
+  observer_->OnTsfEndComposition();
+}
+
 void TsfEventRouter::SetManager(ITfThreadMgr* thread_manager) {
   delegate_->SetManager(thread_manager);
 }
 
-bool TsfEventRouter::IsImeComposing() {
-  return delegate_->IsImeComposing();
-}
-
-void TsfEventRouter::OnTextUpdated() {
-  observer_->OnTextUpdated();
-}
-
-void TsfEventRouter::OnCandidateWindowCountChanged(size_t window_count) {
-  observer_->OnCandidateWindowCountChanged(window_count);
-}
-
 }  // namespace ui