1 // Copyright 2013 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 "win8/metro_driver/ime/text_store.h" 6 7 #include <algorithm> 8 9 #include "base/win/scoped_variant.h" 10 #include "ui/base/win/atl_module.h" 11 #include "win8/metro_driver/ime/input_scope.h" 12 #include "win8/metro_driver/ime/text_store_delegate.h" 13 14 namespace metro_driver { 15 namespace { 16 17 // We support only one view. 18 const TsViewCookie kViewCookie = 1; 19 20 } // namespace 21 22 TextStore::TextStore() 23 : text_store_acp_sink_mask_(0), 24 window_handle_(NULL), 25 delegate_(NULL), 26 committed_size_(0), 27 selection_start_(0), 28 selection_end_(0), 29 edit_flag_(false), 30 current_lock_type_(0), 31 category_manager_(NULL), 32 display_attribute_manager_(NULL), 33 input_scope_(NULL) { 34 } 35 36 TextStore::~TextStore() { 37 } 38 39 // static 40 scoped_refptr<TextStore> TextStore::Create( 41 HWND window_handle, 42 const std::vector<InputScope>& input_scopes, 43 TextStoreDelegate* delegate) { 44 if (!delegate) { 45 LOG(ERROR) << "|delegate| must be non-NULL."; 46 return scoped_refptr<TextStore>(); 47 } 48 base::win::ScopedComPtr<ITfCategoryMgr> category_manager; 49 HRESULT hr = category_manager.CreateInstance(CLSID_TF_CategoryMgr); 50 if (FAILED(hr)) { 51 LOG(ERROR) << "Failed to initialize CategoryMgr. hr = " << hr; 52 return scoped_refptr<TextStore>(); 53 } 54 base::win::ScopedComPtr<ITfDisplayAttributeMgr> display_attribute_manager; 55 hr = display_attribute_manager.CreateInstance(CLSID_TF_DisplayAttributeMgr); 56 if (FAILED(hr)) { 57 LOG(ERROR) << "Failed to initialize DisplayAttributeMgr. hr = " << hr; 58 return scoped_refptr<TextStore>(); 59 } 60 base::win::ScopedComPtr<ITfInputScope> input_scope = 61 CreteInputScope(input_scopes); 62 if (!input_scope) { 63 LOG(ERROR) << "Failed to initialize InputScope."; 64 return scoped_refptr<TextStore>(); 65 } 66 67 ui::win::CreateATLModuleIfNeeded(); 68 CComObject<TextStore>* object = NULL; 69 hr = CComObject<TextStore>::CreateInstance(&object); 70 if (FAILED(hr)) { 71 LOG(ERROR) << "CComObject<TextStore>::CreateInstance failed. hr = " 72 << hr; 73 return scoped_refptr<TextStore>(); 74 } 75 object->Initialize(window_handle, 76 category_manager, 77 display_attribute_manager, 78 input_scope, 79 delegate); 80 return scoped_refptr<TextStore>(object); 81 } 82 83 void TextStore::Initialize(HWND window_handle, 84 ITfCategoryMgr* category_manager, 85 ITfDisplayAttributeMgr* display_attribute_manager, 86 ITfInputScope* input_scope, 87 TextStoreDelegate* delegate) { 88 window_handle_ = window_handle; 89 category_manager_ = category_manager; 90 display_attribute_manager_ = display_attribute_manager; 91 input_scope_ = input_scope; 92 delegate_ = delegate; 93 } 94 95 96 STDMETHODIMP TextStore::AdviseSink(REFIID iid, 97 IUnknown* unknown, 98 DWORD mask) { 99 if (!IsEqualGUID(iid, IID_ITextStoreACPSink)) 100 return E_INVALIDARG; 101 if (text_store_acp_sink_) { 102 if (text_store_acp_sink_.IsSameObject(unknown)) { 103 text_store_acp_sink_mask_ = mask; 104 return S_OK; 105 } else { 106 return CONNECT_E_ADVISELIMIT; 107 } 108 } 109 if (FAILED(text_store_acp_sink_.QueryFrom(unknown))) 110 return E_UNEXPECTED; 111 text_store_acp_sink_mask_ = mask; 112 113 return S_OK; 114 } 115 116 STDMETHODIMP TextStore::FindNextAttrTransition( 117 LONG acp_start, 118 LONG acp_halt, 119 ULONG num_filter_attributes, 120 const TS_ATTRID* filter_attributes, 121 DWORD flags, 122 LONG* acp_next, 123 BOOL* found, 124 LONG* found_offset) { 125 if (!acp_next || !found || !found_offset) 126 return E_INVALIDARG; 127 // We don't support any attributes. 128 // So we always return "not found". 129 *acp_next = 0; 130 *found = FALSE; 131 *found_offset = 0; 132 return S_OK; 133 } 134 135 STDMETHODIMP TextStore::GetACPFromPoint(TsViewCookie view_cookie, 136 const POINT* point, 137 DWORD flags, 138 LONG* acp) { 139 NOTIMPLEMENTED(); 140 if (view_cookie != kViewCookie) 141 return E_INVALIDARG; 142 return E_NOTIMPL; 143 } 144 145 STDMETHODIMP TextStore::GetActiveView(TsViewCookie* view_cookie) { 146 if (!view_cookie) 147 return E_INVALIDARG; 148 // We support only one view. 149 *view_cookie = kViewCookie; 150 return S_OK; 151 } 152 153 STDMETHODIMP TextStore::GetEmbedded(LONG acp_pos, 154 REFGUID service, 155 REFIID iid, 156 IUnknown** unknown) { 157 // We don't support any embedded objects. 158 NOTIMPLEMENTED(); 159 if (!unknown) 160 return E_INVALIDARG; 161 *unknown = NULL; 162 return E_NOTIMPL; 163 } 164 165 STDMETHODIMP TextStore::GetEndACP(LONG* acp) { 166 if (!acp) 167 return E_INVALIDARG; 168 if (!HasReadLock()) 169 return TS_E_NOLOCK; 170 *acp = static_cast<LONG>(string_buffer_.size()); 171 return S_OK; 172 } 173 174 STDMETHODIMP TextStore::GetFormattedText(LONG acp_start, 175 LONG acp_end, 176 IDataObject** data_object) { 177 NOTIMPLEMENTED(); 178 return E_NOTIMPL; 179 } 180 181 STDMETHODIMP TextStore::GetScreenExt(TsViewCookie view_cookie, RECT* rect) { 182 if (view_cookie != kViewCookie) 183 return E_INVALIDARG; 184 if (!rect) 185 return E_INVALIDARG; 186 187 // {0, 0, 0, 0} means that the document rect is not currently displayed. 188 SetRect(rect, 0, 0, 0, 0); 189 190 RECT client_rect = {}; 191 if (!GetClientRect(window_handle_, &client_rect)) 192 return E_FAIL; 193 POINT left_top = {client_rect.left, client_rect.top}; 194 POINT right_bottom = {client_rect.right, client_rect.bottom}; 195 if (!ClientToScreen(window_handle_, &left_top)) 196 return E_FAIL; 197 if (!ClientToScreen(window_handle_, &right_bottom)) 198 return E_FAIL; 199 200 rect->left = left_top.x; 201 rect->top = left_top.y; 202 rect->right = right_bottom.x; 203 rect->bottom = right_bottom.y; 204 return S_OK; 205 } 206 207 STDMETHODIMP TextStore::GetSelection(ULONG selection_index, 208 ULONG selection_buffer_size, 209 TS_SELECTION_ACP* selection_buffer, 210 ULONG* fetched_count) { 211 if (!selection_buffer) 212 return E_INVALIDARG; 213 if (!fetched_count) 214 return E_INVALIDARG; 215 if (!HasReadLock()) 216 return TS_E_NOLOCK; 217 *fetched_count = 0; 218 if ((selection_buffer_size > 0) && 219 ((selection_index == 0) || (selection_index == TS_DEFAULT_SELECTION))) { 220 selection_buffer[0].acpStart = selection_start_; 221 selection_buffer[0].acpEnd = selection_end_; 222 selection_buffer[0].style.ase = TS_AE_END; 223 selection_buffer[0].style.fInterimChar = FALSE; 224 *fetched_count = 1; 225 } 226 return S_OK; 227 } 228 229 STDMETHODIMP TextStore::GetStatus(TS_STATUS* status) { 230 if (!status) 231 return E_INVALIDARG; 232 233 status->dwDynamicFlags = 0; 234 // We use transitory contexts and we don't support hidden text. 235 status->dwStaticFlags = TS_SS_TRANSITORY | TS_SS_NOHIDDENTEXT; 236 237 return S_OK; 238 } 239 240 STDMETHODIMP TextStore::GetText(LONG acp_start, 241 LONG acp_end, 242 wchar_t* text_buffer, 243 ULONG text_buffer_size, 244 ULONG* text_buffer_copied, 245 TS_RUNINFO* run_info_buffer, 246 ULONG run_info_buffer_size, 247 ULONG* run_info_buffer_copied, 248 LONG* next_acp) { 249 if (!text_buffer_copied || !run_info_buffer_copied) 250 return E_INVALIDARG; 251 if (!text_buffer && text_buffer_size != 0) 252 return E_INVALIDARG; 253 if (!run_info_buffer && run_info_buffer_size != 0) 254 return E_INVALIDARG; 255 if (!next_acp) 256 return E_INVALIDARG; 257 if (!HasReadLock()) 258 return TF_E_NOLOCK; 259 const LONG string_buffer_size = static_cast<LONG>(string_buffer_.size()); 260 if (acp_end == -1) 261 acp_end = string_buffer_size; 262 if (!((0 <= acp_start) && 263 (acp_start <= acp_end) && 264 (acp_end <= string_buffer_size))) { 265 return TF_E_INVALIDPOS; 266 } 267 acp_end = std::min(acp_end, acp_start + static_cast<LONG>(text_buffer_size)); 268 *text_buffer_copied = acp_end - acp_start; 269 270 const base::string16& result = 271 string_buffer_.substr(acp_start, *text_buffer_copied); 272 for (size_t i = 0; i < result.size(); ++i) 273 text_buffer[i] = result[i]; 274 275 if (run_info_buffer_size) { 276 run_info_buffer[0].uCount = *text_buffer_copied; 277 run_info_buffer[0].type = TS_RT_PLAIN; 278 *run_info_buffer_copied = 1; 279 } 280 281 *next_acp = acp_end; 282 return S_OK; 283 } 284 285 STDMETHODIMP TextStore::GetTextExt(TsViewCookie view_cookie, 286 LONG acp_start, 287 LONG acp_end, 288 RECT* rect, 289 BOOL* clipped) { 290 if (!rect || !clipped) 291 return E_INVALIDARG; 292 if (view_cookie != kViewCookie) 293 return E_INVALIDARG; 294 if (!HasReadLock()) 295 return TS_E_NOLOCK; 296 if (!((static_cast<LONG>(committed_size_) <= acp_start) && 297 (acp_start <= acp_end) && 298 (acp_end <= static_cast<LONG>(string_buffer_.size())))) { 299 return TS_E_INVALIDPOS; 300 } 301 302 // According to a behavior of notepad.exe and wordpad.exe, top left corner of 303 // rect indicates a first character's one, and bottom right corner of rect 304 // indicates a last character's one. 305 // We use RECT instead of gfx::Rect since left position may be bigger than 306 // right position when composition has multiple lines. 307 RECT result; 308 RECT tmp_rect; 309 const uint32 start_pos = acp_start - committed_size_; 310 const uint32 end_pos = acp_end - committed_size_; 311 312 if (start_pos == end_pos) { 313 // According to MSDN document, if |acp_start| and |acp_end| are equal it is 314 // OK to just return E_INVALIDARG. 315 // http://msdn.microsoft.com/en-us/library/ms538435 316 // But when using Pinin IME of Windows 8, this method is called with the 317 // equal values of |acp_start| and |acp_end|. So we handle this condition. 318 if (start_pos == 0) { 319 if (delegate_->GetCompositionCharacterBounds(0, &tmp_rect)) { 320 tmp_rect.right = tmp_rect.right; 321 result = tmp_rect; 322 } else if (string_buffer_.size() == committed_size_) { 323 result = delegate_->GetCaretBounds(); 324 } else { 325 return TS_E_NOLAYOUT; 326 } 327 } else if (delegate_->GetCompositionCharacterBounds(start_pos - 1, 328 &tmp_rect)) { 329 tmp_rect.left = tmp_rect.right; 330 result = tmp_rect; 331 } else { 332 return TS_E_NOLAYOUT; 333 } 334 } else { 335 if (delegate_->GetCompositionCharacterBounds(start_pos, &tmp_rect)) { 336 result = tmp_rect; 337 if (delegate_->GetCompositionCharacterBounds(end_pos - 1, &tmp_rect)) { 338 result.right = tmp_rect.right; 339 result.bottom = tmp_rect.bottom; 340 } else { 341 // We may not be able to get the last character bounds, so we use the 342 // first character bounds instead of returning TS_E_NOLAYOUT. 343 } 344 } else { 345 // Hack for PPAPI flash. PPAPI flash does not support GetCaretBounds, so 346 // it's better to return previous caret rectangle instead. 347 // TODO(nona, kinaba): Remove this hack. 348 if (start_pos == 0) 349 result = delegate_->GetCaretBounds(); 350 else 351 return TS_E_NOLAYOUT; 352 } 353 } 354 355 *rect = result; 356 *clipped = FALSE; 357 return S_OK; 358 } 359 360 STDMETHODIMP TextStore::GetWnd(TsViewCookie view_cookie, 361 HWND* window_handle) { 362 if (!window_handle) 363 return E_INVALIDARG; 364 if (view_cookie != kViewCookie) 365 return E_INVALIDARG; 366 *window_handle = window_handle_; 367 return S_OK; 368 } 369 370 STDMETHODIMP TextStore::InsertEmbedded(DWORD flags, 371 LONG acp_start, 372 LONG acp_end, 373 IDataObject* data_object, 374 TS_TEXTCHANGE* change) { 375 // We don't support any embedded objects. 376 NOTIMPLEMENTED(); 377 return E_NOTIMPL; 378 } 379 380 STDMETHODIMP TextStore::InsertEmbeddedAtSelection(DWORD flags, 381 IDataObject* data_object, 382 LONG* acp_start, 383 LONG* acp_end, 384 TS_TEXTCHANGE* change) { 385 // We don't support any embedded objects. 386 NOTIMPLEMENTED(); 387 return E_NOTIMPL; 388 } 389 390 STDMETHODIMP TextStore::InsertTextAtSelection(DWORD flags, 391 const wchar_t* text_buffer, 392 ULONG text_buffer_size, 393 LONG* acp_start, 394 LONG* acp_end, 395 TS_TEXTCHANGE* text_change) { 396 const LONG start_pos = selection_start_; 397 const LONG end_pos = selection_end_; 398 const LONG new_end_pos = start_pos + text_buffer_size; 399 400 if (flags & TS_IAS_QUERYONLY) { 401 if (!HasReadLock()) 402 return TS_E_NOLOCK; 403 if (acp_start) 404 *acp_start = start_pos; 405 if (acp_end) 406 *acp_end = end_pos; 407 return S_OK; 408 } 409 410 if (!HasReadWriteLock()) 411 return TS_E_NOLOCK; 412 if (!text_buffer) 413 return E_INVALIDARG; 414 415 DCHECK_LE(start_pos, end_pos); 416 string_buffer_ = string_buffer_.substr(0, start_pos) + 417 base::string16(text_buffer, text_buffer + text_buffer_size) + 418 string_buffer_.substr(end_pos); 419 if (acp_start) 420 *acp_start = start_pos; 421 if (acp_end) 422 *acp_end = new_end_pos; 423 if (text_change) { 424 text_change->acpStart = start_pos; 425 text_change->acpOldEnd = end_pos; 426 text_change->acpNewEnd = new_end_pos; 427 } 428 selection_start_ = start_pos; 429 selection_end_ = new_end_pos; 430 return S_OK; 431 } 432 433 STDMETHODIMP TextStore::QueryInsert( 434 LONG acp_test_start, 435 LONG acp_test_end, 436 ULONG text_size, 437 LONG* acp_result_start, 438 LONG* acp_result_end) { 439 if (!acp_result_start || !acp_result_end || acp_test_start > acp_test_end) 440 return E_INVALIDARG; 441 const LONG committed_size = static_cast<LONG>(committed_size_); 442 const LONG buffer_size = static_cast<LONG>(string_buffer_.size()); 443 *acp_result_start = std::min(std::max(committed_size, acp_test_start), 444 buffer_size); 445 *acp_result_end = std::min(std::max(committed_size, acp_test_end), 446 buffer_size); 447 return S_OK; 448 } 449 450 STDMETHODIMP TextStore::QueryInsertEmbedded(const GUID* service, 451 const FORMATETC* format, 452 BOOL* insertable) { 453 if (!format) 454 return E_INVALIDARG; 455 // We don't support any embedded objects. 456 if (insertable) 457 *insertable = FALSE; 458 return S_OK; 459 } 460 461 STDMETHODIMP TextStore::RequestAttrsAtPosition( 462 LONG acp_pos, 463 ULONG attribute_buffer_size, 464 const TS_ATTRID* attribute_buffer, 465 DWORD flags) { 466 // We don't support any document attributes. 467 // This method just returns S_OK, and the subsequently called 468 // RetrieveRequestedAttrs() returns 0 as the number of supported attributes. 469 return S_OK; 470 } 471 472 STDMETHODIMP TextStore::RequestAttrsTransitioningAtPosition( 473 LONG acp_pos, 474 ULONG attribute_buffer_size, 475 const TS_ATTRID* attribute_buffer, 476 DWORD flags) { 477 // We don't support any document attributes. 478 // This method just returns S_OK, and the subsequently called 479 // RetrieveRequestedAttrs() returns 0 as the number of supported attributes. 480 return S_OK; 481 } 482 483 STDMETHODIMP TextStore::RequestLock(DWORD lock_flags, HRESULT* result) { 484 if (!text_store_acp_sink_.get()) 485 return E_FAIL; 486 if (!result) 487 return E_INVALIDARG; 488 489 if (current_lock_type_ != 0) { 490 if (lock_flags & TS_LF_SYNC) { 491 // Can't lock synchronously. 492 *result = TS_E_SYNCHRONOUS; 493 return S_OK; 494 } 495 // Queue the lock request. 496 lock_queue_.push_back(lock_flags & TS_LF_READWRITE); 497 *result = TS_S_ASYNC; 498 return S_OK; 499 } 500 501 // Lock 502 current_lock_type_ = (lock_flags & TS_LF_READWRITE); 503 504 edit_flag_ = false; 505 const uint32 last_committed_size = committed_size_; 506 507 // Grant the lock. 508 *result = text_store_acp_sink_->OnLockGranted(current_lock_type_); 509 510 // Unlock 511 current_lock_type_ = 0; 512 513 // Handles the pending lock requests. 514 while (!lock_queue_.empty()) { 515 current_lock_type_ = lock_queue_.front(); 516 lock_queue_.pop_front(); 517 text_store_acp_sink_->OnLockGranted(current_lock_type_); 518 current_lock_type_ = 0; 519 } 520 521 if (!edit_flag_) 522 return S_OK; 523 524 // If the text store is edited in OnLockGranted(), we may need to call 525 // TextStoreDelegate::ConfirmComposition() or 526 // TextStoreDelegate::SetComposition(). 527 const uint32 new_committed_size = committed_size_; 528 const base::string16& new_committed_string = 529 string_buffer_.substr(last_committed_size, 530 new_committed_size - last_committed_size); 531 const base::string16& composition_string = 532 string_buffer_.substr(new_committed_size); 533 534 // If there is new committed string, calls 535 // TextStoreDelegate::ConfirmComposition(). 536 if ((!new_committed_string.empty())) 537 delegate_->OnTextCommitted(new_committed_string); 538 539 // Calls TextInputClient::SetCompositionText(). 540 std::vector<metro_viewer::UnderlineInfo> underlines = underlines_; 541 // Adjusts the offset. 542 for (size_t i = 0; i < underlines_.size(); ++i) { 543 underlines[i].start_offset -= new_committed_size; 544 underlines[i].end_offset -= new_committed_size; 545 } 546 int32 selection_start = 0; 547 int32 selection_end = 0; 548 if (selection_start_ >= new_committed_size) 549 selection_start = selection_start_ - new_committed_size; 550 if (selection_end_ >= new_committed_size) 551 selection_end = selection_end_ - new_committed_size; 552 delegate_->OnCompositionChanged( 553 composition_string, selection_start, selection_end, underlines); 554 555 // If there is no composition string, clear the text store status. 556 // And call OnSelectionChange(), OnLayoutChange(), and OnTextChange(). 557 if ((composition_string.empty()) && (new_committed_size != 0)) { 558 string_buffer_.clear(); 559 committed_size_ = 0; 560 selection_start_ = 0; 561 selection_end_ = 0; 562 if (text_store_acp_sink_mask_ & TS_AS_SEL_CHANGE) 563 text_store_acp_sink_->OnSelectionChange(); 564 if (text_store_acp_sink_mask_ & TS_AS_LAYOUT_CHANGE) 565 text_store_acp_sink_->OnLayoutChange(TS_LC_CHANGE, 0); 566 if (text_store_acp_sink_mask_ & TS_AS_TEXT_CHANGE) { 567 TS_TEXTCHANGE textChange; 568 textChange.acpStart = 0; 569 textChange.acpOldEnd = new_committed_size; 570 textChange.acpNewEnd = 0; 571 text_store_acp_sink_->OnTextChange(0, &textChange); 572 } 573 } 574 575 return S_OK; 576 } 577 578 STDMETHODIMP TextStore::RequestSupportedAttrs( 579 DWORD /* flags */, // Seems that we should ignore this. 580 ULONG attribute_buffer_size, 581 const TS_ATTRID* attribute_buffer) { 582 if (!attribute_buffer) 583 return E_INVALIDARG; 584 if (!input_scope_) 585 return E_FAIL; 586 // We support only input scope attribute. 587 for (size_t i = 0; i < attribute_buffer_size; ++i) { 588 if (IsEqualGUID(GUID_PROP_INPUTSCOPE, attribute_buffer[i])) 589 return S_OK; 590 } 591 return E_FAIL; 592 } 593 594 STDMETHODIMP TextStore::RetrieveRequestedAttrs( 595 ULONG attribute_buffer_size, 596 TS_ATTRVAL* attribute_buffer, 597 ULONG* attribute_buffer_copied) { 598 if (!attribute_buffer_copied) 599 return E_INVALIDARG; 600 *attribute_buffer_copied = 0; 601 if (!attribute_buffer) 602 return E_INVALIDARG; 603 if (!input_scope_) 604 return E_UNEXPECTED; 605 // We support only input scope attribute. 606 *attribute_buffer_copied = 0; 607 if (attribute_buffer_size == 0) 608 return S_OK; 609 610 attribute_buffer[0].dwOverlapId = 0; 611 attribute_buffer[0].idAttr = GUID_PROP_INPUTSCOPE; 612 attribute_buffer[0].varValue.vt = VT_UNKNOWN; 613 attribute_buffer[0].varValue.punkVal = input_scope_.get(); 614 attribute_buffer[0].varValue.punkVal->AddRef(); 615 *attribute_buffer_copied = 1; 616 return S_OK; 617 } 618 619 STDMETHODIMP TextStore::SetSelection( 620 ULONG selection_buffer_size, 621 const TS_SELECTION_ACP* selection_buffer) { 622 if (!HasReadWriteLock()) 623 return TF_E_NOLOCK; 624 if (selection_buffer_size > 0) { 625 const LONG start_pos = selection_buffer[0].acpStart; 626 const LONG end_pos = selection_buffer[0].acpEnd; 627 if (!((static_cast<LONG>(committed_size_) <= start_pos) && 628 (start_pos <= end_pos) && 629 (end_pos <= static_cast<LONG>(string_buffer_.size())))) { 630 return TF_E_INVALIDPOS; 631 } 632 selection_start_ = start_pos; 633 selection_end_ = end_pos; 634 } 635 return S_OK; 636 } 637 638 STDMETHODIMP TextStore::SetText(DWORD flags, 639 LONG acp_start, 640 LONG acp_end, 641 const wchar_t* text_buffer, 642 ULONG text_buffer_size, 643 TS_TEXTCHANGE* text_change) { 644 if (!HasReadWriteLock()) 645 return TS_E_NOLOCK; 646 if (!((static_cast<LONG>(committed_size_) <= acp_start) && 647 (acp_start <= acp_end) && 648 (acp_end <= static_cast<LONG>(string_buffer_.size())))) { 649 return TS_E_INVALIDPOS; 650 } 651 652 TS_SELECTION_ACP selection; 653 selection.acpStart = acp_start; 654 selection.acpEnd = acp_end; 655 selection.style.ase = TS_AE_NONE; 656 selection.style.fInterimChar = 0; 657 658 HRESULT ret; 659 ret = SetSelection(1, &selection); 660 if (ret != S_OK) 661 return ret; 662 663 TS_TEXTCHANGE change; 664 ret = InsertTextAtSelection(0, text_buffer, text_buffer_size, 665 &acp_start, &acp_end, &change); 666 if (ret != S_OK) 667 return ret; 668 669 if (text_change) 670 *text_change = change; 671 672 return S_OK; 673 } 674 675 STDMETHODIMP TextStore::UnadviseSink(IUnknown* unknown) { 676 if (!text_store_acp_sink_.IsSameObject(unknown)) 677 return CONNECT_E_NOCONNECTION; 678 text_store_acp_sink_.Release(); 679 text_store_acp_sink_mask_ = 0; 680 return S_OK; 681 } 682 683 STDMETHODIMP TextStore::OnStartComposition( 684 ITfCompositionView* composition_view, 685 BOOL* ok) { 686 if (ok) 687 *ok = TRUE; 688 return S_OK; 689 } 690 691 STDMETHODIMP TextStore::OnUpdateComposition( 692 ITfCompositionView* composition_view, 693 ITfRange* range) { 694 return S_OK; 695 } 696 697 STDMETHODIMP TextStore::OnEndComposition( 698 ITfCompositionView* composition_view) { 699 return S_OK; 700 } 701 702 STDMETHODIMP TextStore::OnEndEdit(ITfContext* context, 703 TfEditCookie read_only_edit_cookie, 704 ITfEditRecord* edit_record) { 705 if (!context || !edit_record) 706 return E_INVALIDARG; 707 if (!GetCompositionStatus(context, read_only_edit_cookie, &committed_size_, 708 &underlines_)) { 709 return S_OK; 710 } 711 edit_flag_ = true; 712 return S_OK; 713 } 714 715 bool TextStore::GetDisplayAttribute(TfGuidAtom guid_atom, 716 TF_DISPLAYATTRIBUTE* attribute) { 717 GUID guid; 718 if (FAILED(category_manager_->GetGUID(guid_atom, &guid))) 719 return false; 720 721 base::win::ScopedComPtr<ITfDisplayAttributeInfo> display_attribute_info; 722 if (FAILED(display_attribute_manager_->GetDisplayAttributeInfo( 723 guid, display_attribute_info.Receive(), NULL))) { 724 return false; 725 } 726 return SUCCEEDED(display_attribute_info->GetAttributeInfo(attribute)); 727 } 728 729 bool TextStore::GetCompositionStatus( 730 ITfContext* context, 731 const TfEditCookie read_only_edit_cookie, 732 uint32* committed_size, 733 std::vector<metro_viewer::UnderlineInfo>* undelines) { 734 DCHECK(context); 735 DCHECK(committed_size); 736 DCHECK(undelines); 737 const GUID* rgGuids[2] = {&GUID_PROP_COMPOSING, &GUID_PROP_ATTRIBUTE}; 738 base::win::ScopedComPtr<ITfReadOnlyProperty> track_property; 739 if (FAILED(context->TrackProperties(rgGuids, 2, NULL, 0, 740 track_property.Receive()))) { 741 return false; 742 } 743 744 *committed_size = 0; 745 undelines->clear(); 746 base::win::ScopedComPtr<ITfRange> start_to_end_range; 747 base::win::ScopedComPtr<ITfRange> end_range; 748 if (FAILED(context->GetStart(read_only_edit_cookie, 749 start_to_end_range.Receive()))) { 750 return false; 751 } 752 if (FAILED(context->GetEnd(read_only_edit_cookie, end_range.Receive()))) 753 return false; 754 if (FAILED(start_to_end_range->ShiftEndToRange(read_only_edit_cookie, 755 end_range, TF_ANCHOR_END))) { 756 return false; 757 } 758 759 base::win::ScopedComPtr<IEnumTfRanges> ranges; 760 if (FAILED(track_property->EnumRanges(read_only_edit_cookie, ranges.Receive(), 761 start_to_end_range))) { 762 return false; 763 } 764 765 while (true) { 766 base::win::ScopedComPtr<ITfRange> range; 767 if (ranges->Next(1, range.Receive(), NULL) != S_OK) 768 break; 769 base::win::ScopedVariant value; 770 base::win::ScopedComPtr<IEnumTfPropertyValue> enum_prop_value; 771 if (FAILED(track_property->GetValue(read_only_edit_cookie, range, 772 value.Receive()))) { 773 return false; 774 } 775 if (FAILED(enum_prop_value.QueryFrom(value.AsInput()->punkVal))) 776 return false; 777 778 TF_PROPERTYVAL property_value; 779 bool is_composition = false; 780 bool has_display_attribute = false; 781 TF_DISPLAYATTRIBUTE display_attribute; 782 while (enum_prop_value->Next(1, &property_value, NULL) == S_OK) { 783 if (IsEqualGUID(property_value.guidId, GUID_PROP_COMPOSING)) { 784 is_composition = (property_value.varValue.lVal == TRUE); 785 } else if (IsEqualGUID(property_value.guidId, GUID_PROP_ATTRIBUTE)) { 786 TfGuidAtom guid_atom = 787 static_cast<TfGuidAtom>(property_value.varValue.lVal); 788 if (GetDisplayAttribute(guid_atom, &display_attribute)) 789 has_display_attribute = true; 790 } 791 VariantClear(&property_value.varValue); 792 } 793 794 base::win::ScopedComPtr<ITfRangeACP> range_acp; 795 range_acp.QueryFrom(range); 796 LONG start_pos, length; 797 range_acp->GetExtent(&start_pos, &length); 798 if (!is_composition) { 799 if (*committed_size < static_cast<size_t>(start_pos + length)) 800 *committed_size = start_pos + length; 801 } else { 802 metro_viewer::UnderlineInfo underline; 803 underline.start_offset = start_pos; 804 underline.end_offset = start_pos + length; 805 underline.thick = !!display_attribute.fBoldLine; 806 undelines->push_back(underline); 807 } 808 } 809 return true; 810 } 811 812 bool TextStore::CancelComposition() { 813 // If there is an on-going document lock, we must not edit the text. 814 if (edit_flag_) 815 return false; 816 817 if (string_buffer_.empty()) 818 return true; 819 820 // Unlike ImmNotifyIME(NI_COMPOSITIONSTR, CPS_CANCEL, 0) in IMM32, TSF does 821 // not have a dedicated method to cancel composition. However, CUAS actually 822 // has a protocol conversion from CPS_CANCEL into TSF operations. According 823 // to the observations on Windows 7, TIPs are expected to cancel composition 824 // when an on-going composition text is replaced with an empty string. So 825 // we use the same operation to cancel composition here to minimize the risk 826 // of potential compatibility issues. 827 828 const uint32 previous_buffer_size = 829 static_cast<uint32>(string_buffer_.size()); 830 string_buffer_.clear(); 831 committed_size_ = 0; 832 selection_start_ = 0; 833 selection_end_ = 0; 834 if (text_store_acp_sink_mask_ & TS_AS_SEL_CHANGE) 835 text_store_acp_sink_->OnSelectionChange(); 836 if (text_store_acp_sink_mask_ & TS_AS_LAYOUT_CHANGE) 837 text_store_acp_sink_->OnLayoutChange(TS_LC_CHANGE, 0); 838 if (text_store_acp_sink_mask_ & TS_AS_TEXT_CHANGE) { 839 TS_TEXTCHANGE textChange = {}; 840 textChange.acpStart = 0; 841 textChange.acpOldEnd = previous_buffer_size; 842 textChange.acpNewEnd = 0; 843 text_store_acp_sink_->OnTextChange(0, &textChange); 844 } 845 return true; 846 } 847 848 bool TextStore::ConfirmComposition() { 849 // If there is an on-going document lock, we must not edit the text. 850 if (edit_flag_) 851 return false; 852 853 if (string_buffer_.empty()) 854 return true; 855 856 // See the comment in TextStore::CancelComposition. 857 // This logic is based on the observation about how to emulate 858 // ImmNotifyIME(NI_COMPOSITIONSTR, CPS_COMPLETE, 0) by CUAS. 859 860 const base::string16& composition_text = 861 string_buffer_.substr(committed_size_); 862 if (!composition_text.empty()) 863 delegate_->OnTextCommitted(composition_text); 864 865 const uint32 previous_buffer_size = 866 static_cast<uint32>(string_buffer_.size()); 867 string_buffer_.clear(); 868 committed_size_ = 0; 869 selection_start_ = 0; 870 selection_end_ = 0; 871 if (text_store_acp_sink_mask_ & TS_AS_SEL_CHANGE) 872 text_store_acp_sink_->OnSelectionChange(); 873 if (text_store_acp_sink_mask_ & TS_AS_LAYOUT_CHANGE) 874 text_store_acp_sink_->OnLayoutChange(TS_LC_CHANGE, 0); 875 if (text_store_acp_sink_mask_ & TS_AS_TEXT_CHANGE) { 876 TS_TEXTCHANGE textChange = {}; 877 textChange.acpStart = 0; 878 textChange.acpOldEnd = previous_buffer_size; 879 textChange.acpNewEnd = 0; 880 text_store_acp_sink_->OnTextChange(0, &textChange); 881 } 882 return true; 883 } 884 885 void TextStore::SendOnLayoutChange() { 886 if (text_store_acp_sink_ && (text_store_acp_sink_mask_ & TS_AS_LAYOUT_CHANGE)) 887 text_store_acp_sink_->OnLayoutChange(TS_LC_CHANGE, 0); 888 } 889 890 bool TextStore::HasReadLock() const { 891 return (current_lock_type_ & TS_LF_READ) == TS_LF_READ; 892 } 893 894 bool TextStore::HasReadWriteLock() const { 895 return (current_lock_type_ & TS_LF_READWRITE) == TS_LF_READWRITE; 896 } 897 898 } // namespace metro_driver 899
