src/ui/controls/FUiCtrl_TokenEdit.cpp

   1 //
   2 // Open Service Platform
   3 // Copyright (c) 2012-2013 Samsung Electronics Co., Ltd.
   4 //
   5 // Licensed under the Apache License, Version 2.0 (the License);
   6 // you may not use this file except in compliance with the License.
   7 // You may obtain a copy of the License at
   8 //
   9 //     http://www.apache.org/licenses/LICENSE-2.0/
  10 //
  11 // Unless required by applicable law or agreed to in writing, software
  12 // distributed under the License is distributed on an "AS IS" BASIS,
  13 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  14 // See the License for the specific language governing permissions and
  15 // limitations under the License.
  16 //
  17 /**
  18  * @file                FUiCtrl_TokenEdit.cpp
  19  * @brief               This is the implementation file for the _TokenEdit class.
  20  */
  21
  22 #include <FBaseSysLog.h>
  23 #include "FUiCtrl_TokenEdit.h"
  24 #include "FUiCtrl_TokenEditPresenter.h"
  25
  26 #include "FUi_AccessibilityContainer.h"
  27 #include "FUi_AccessibilityElement.h"
  28
  29 using namespace Tizen::Base;
  30 using namespace Tizen::Graphics;
  31 using namespace Tizen::Ui;
  32
  33 namespace Tizen { namespace Ui { namespace Controls
  34 {
  35
  36 IMPLEMENT_PROPERTY(_TokenEdit);
  37
  38 _TokenEdit::_TokenEdit(void)
  39         : _Edit()
  40         , __pTokenEditPresenter(null)
  41         , __isSelectedTokenTextColorSet(false)
  42         , __pTokenFilter(null)
  43         , __pTitleTextAccessibilityElement(null)
  44         , __pCursorAccessibilityElement(null)
  45 {
  46         GET_COLOR_CONFIG(TOKENEDIT::BG_NORMAL, __tokenColor[TOKEN_EDIT_STATUS_NORMAL]);
  47         GET_COLOR_CONFIG(TOKENEDIT::BG_SELECTED, __tokenColor[TOKEN_EDIT_STATUS_SELECTED]);
  48         GET_COLOR_CONFIG(TOKENEDIT::BG_HIGHLIGHTED, __tokenColor[TOKEN_EDIT_STATUS_HIGHLIGHTED]);
  49         GET_COLOR_CONFIG(TOKENEDIT::BG_DISABLED, __tokenColor[TOKEN_EDIT_STATUS_DISABLED]);
  50         GET_COLOR_CONFIG(TOKENEDIT::TEXT_NORMAL, __tokenTextColor[EXPANDABLE_EDIT_AREA_TOKEN_STATUS_NORMAL]);
  51         GET_COLOR_CONFIG(TOKENEDIT::TEXT_SELECTED, __tokenTextColor[EXPANDABLE_EDIT_AREA_TOKEN_STATUS_SELECTED]);
  52
  53         _AccessibilityContainer* pContainer = null;
  54         pContainer = GetAccessibilityContainer();
  55         if (pContainer)
  56         {
  57                 pContainer->Activate(true);
  58         }
  59 }
  60
  61 _TokenEdit::~_TokenEdit(void)
  62 {
  63
  64 }
  65
  66 _TokenEdit*
  67 _TokenEdit::CreateTokenEditN(void)
  68 {
  69         _TokenEditPresenter* pPresenter = _TokenEditPresenter::CreateTokenEditPresenterN();
  70         result r = GetLastResult();
  71         SysTryReturn(NID_UI_CTRL, pPresenter != null, null, r, "[%s] Propagating.", GetErrorMessage(r));
  72
  73         _TokenEdit* pTokenEdit = new (std::nothrow) _TokenEdit();
  74         SysTryCatch(NID_UI_CTRL, pTokenEdit != null, , E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] Memory allocation failed.");
  75         SysTryCatch(NID_UI_CTRL, GetLastResult() == E_SUCCESS, , GetLastResult(), "[%s] Propagating.", GetErrorMessage(GetLastResult()));
  76
  77         pTokenEdit->AcquireHandle();
  78
  79         pTokenEdit->SetPresenter(*pPresenter);
  80         pTokenEdit->__pTokenEditPresenter = pPresenter;
  81
  82         return pTokenEdit;
  83
  84 CATCH:
  85         delete pPresenter;
  86         delete pTokenEdit;
  87         return null;
  88 }
  89
  90 void
  91 _TokenEdit::OnDraw(void)
  92 {
  93         result r = E_SUCCESS;
  94
  95         if (__pTokenEditPresenter == null)
  96         {
  97                 return;
  98         }
  99
 100         Canvas* pCanvas = GetCanvasN();
 101         SysTryReturnVoidResult(NID_UI_CTRL, pCanvas, GetLastResult(), "[%s] Propagating.", GetErrorMessage(GetLastResult()));
 102
 103         r = __pTokenEditPresenter->Draw(*pCanvas);
 104         SysTryReturnVoidResult(NID_UI_CTRL, r == E_SUCCESS, r, "[%s] Propagating.", GetErrorMessage(r));
 105
 106         delete pCanvas;
 107 }
 108
 109 result
 110 _TokenEdit::SetTokenFilter(const _ITokenFilter* pFilter)
 111 {
 112         result r = E_SUCCESS;
 113
 114         __pTokenFilter = const_cast< _ITokenFilter* >(pFilter);
 115
 116         return r;
 117 }
 118
 119 _ITokenFilter*
 120 _TokenEdit::GetTokenFilter(void) const
 121 {
 122         return __pTokenFilter;
 123 }
 124
 125 result
 126 _TokenEdit::AppendToken(const String& token)
 127 {
 128         result r = E_SUCCESS;
 129
 130         SysAssertf(__pTokenEditPresenter != null, "_TokenEditPresenter instance is null");
 131
 132         r = __pTokenEditPresenter->AppendToken(token);
 133         SysTryReturnResult(NID_UI_CTRL, r == E_SUCCESS, r, "Propagating.");
 134
 135         return r;
 136 }
 137
 138 result
 139 _TokenEdit::InsertTokenAt(int index, const String& token)
 140 {
 141         result r = E_SUCCESS;
 142
 143         SysAssertf(__pTokenEditPresenter != null, "_TokenEditPresenter instance is null");
 144
 145         r = __pTokenEditPresenter->InsertTokenAt(index, token, true);
 146         SysTryReturnResult(NID_UI_CTRL, r == E_SUCCESS, r, "Propagating.");
 147
 148         return r;
 149 }
 150
 151 String
 152 _TokenEdit::GetTokenAt(int index) const
 153 {
 154         SysAssertf(__pTokenEditPresenter != null, "_TokenEditPresenter instance is null");
 155
 156         return __pTokenEditPresenter->GetTokenAt(index);
 157 }
 158
 159 int
 160 _TokenEdit::GetTokenCount(void) const
 161 {
 162         SysAssertf(__pTokenEditPresenter != null, "_TokenEditPresenter instance is null");
 163
 164         return __pTokenEditPresenter->GetTokenCount(true);
 165 }
 166
 167 int
 168 _TokenEdit::GetSelectedTokenIndex(void) const
 169 {
 170         SysAssertf(__pTokenEditPresenter != null, "_TokenEditPresenter instance is null");
 171
 172         return __pTokenEditPresenter->GetSelectedTokenIndex();
 173 }
 174
 175 bool
 176 _TokenEdit::IsTokenEditModeEnabled(void) const
 177 {
 178         SysAssertf(__pTokenEditPresenter != null, "_TokenEditPresenter instance is null");
 179
 180         Variant var = GetProperty("tokenEditModeEnabled");
 181
 182         return var.ToBool();
 183 }
 184
 185 result
 186 _TokenEdit::RemoveTokenAt(int index)
 187 {
 188         SysAssertf(__pTokenEditPresenter != null, "_TokenEditPresenter instance is null");
 189
 190         return __pTokenEditPresenter->RemoveTokenAt(index, true);
 191 }
 192
 193 result
 194 _TokenEdit::SetTokenSelected(int index, bool selected)
 195 {
 196         SysAssertf(__pTokenEditPresenter != null, "_TokenEditPresenter instance is null");
 197
 198         return __pTokenEditPresenter->SetTokenSelected(index, selected);
 199 }
 200
 201 result
 202 _TokenEdit::SetTokenEditModeEnabled(bool enable)
 203 {
 204         SysAssertf(__pTokenEditPresenter != null, "_TokenEditPresenter instance is null");
 205
 206         Variant var(enable);
 207
 208         return SetProperty("tokenEditModeEnabled", var);
 209 }
 210
 211 Color
 212 _TokenEdit::GetTokenColor(TokenEditStatus status) const
 213 {
 214         Variant var;
 215
 216         switch (status)
 217         {
 218         case TOKEN_EDIT_STATUS_NORMAL:
 219                 var = GetProperty("normalTokenColor");
 220                 break;
 221
 222         case TOKEN_EDIT_STATUS_SELECTED:
 223                 var = GetProperty("selectedTokenColor");
 224                 break;
 225
 226         case TOKEN_EDIT_STATUS_HIGHLIGHTED:
 227                 var = GetProperty("highlightedTokenColor");
 228                 break;
 229
 230         case TOKEN_EDIT_STATUS_DISABLED:
 231                 var = GetProperty("disabledTokenColor");
 232                 break;
 233
 234         default:
 235                 break;
 236         }
 237
 238         return var.ToColor();
 239 }
 240
 241 Color
 242 _TokenEdit::GetTokenTextColor(void) const
 243 {
 244         Variant var = GetProperty("tokenTextColor");
 245
 246         return var.ToColor();
 247 }
 248
 249 result
 250 _TokenEdit::SetTokenColor(TokenEditStatus status, const Color& color)
 251 {
 252         result r = E_SUCCESS;
 253         Variant var(color);
 254
 255         switch (status)
 256         {
 257         case TOKEN_EDIT_STATUS_NORMAL:
 258                 r = SetProperty("normalTokenColor", var);
 259                 break;
 260
 261         case TOKEN_EDIT_STATUS_SELECTED:
 262                 r = SetProperty("selectedTokenColor", var);
 263                 break;
 264
 265         case TOKEN_EDIT_STATUS_HIGHLIGHTED:
 266                 r = SetProperty("highlightedTokenColor", var);
 267                 break;
 268
 269         case TOKEN_EDIT_STATUS_DISABLED:
 270                 r = SetProperty("disabledTokenColor", var);
 271                 break;
 272         default:
 273                 break;
 274         }
 275
 276         return r;
 277 }
 278
 279 result
 280 _TokenEdit::SetTokenTextColor(const Color& color)
 281 {
 282         Variant var(color);
 283         return SetProperty("tokenTextColor", var);
 284 }
 285
 286 Color
 287 _TokenEdit::GetSelectedTokenTextColor(void) const
 288 {
 289         Variant var = GetProperty("selectedTokenTextColor");
 290
 291         return var.ToColor();
 292 }
 293
 294 result
 295 _TokenEdit::SetSelectedTokenTextColor(const Color& color)
 296 {
 297         Variant var(color);
 298
 299         return SetProperty("selectedTokenTextColor", var);
 300 }
 301
 302 result
 303 _TokenEdit::SetTitleText(const String& title)
 304 {
 305         result r = E_SUCCESS;
 306
 307         SysAssertf(__pTokenEditPresenter != null, "_TokenEditPresenter instance is null");
 308
 309         __pTokenEditPresenter->SetDescriptionText(title);
 310
 311         r = __pTokenEditPresenter->CalculateDescriptionTextRect(title);
 312         SysTryReturnResult(NID_UI_CTRL, r == E_SUCCESS, r, "Propagating.");
 313
 314         r = __pTokenEditPresenter->CalculateTokenPositionFromIndex(0);
 315         SysTryReturnResult(NID_UI_CTRL, r == E_SUCCESS, r, "Propagating.");
 316
 317         r = __pTokenEditPresenter->SetInitialBounds();
 318         SysTryReturnResult(NID_UI_CTRL, r == E_SUCCESS, r, "Propagating.");
 319
 320         Invalidate(true);
 321         return r;
 322 }
 323
 324 String
 325 _TokenEdit::GetTitleText(void) const
 326 {
 327         SysAssertf(__pTokenEditPresenter != null, "_TokenEditPresenter instance is null");
 328
 329         return __pTokenEditPresenter->GetDescriptionText();
 330 }
 331
 332 void
 333 _TokenEdit::SetAutoShrinkModeEnabled(bool enable)
 334 {
 335         SysAssertf(__pTokenEditPresenter != null, "_TokenEditPresenter instance is null");
 336
 337         __pTokenEditPresenter->SetAutoShrinkModeEnabled(enable);
 338 }
 339
 340 bool
 341 _TokenEdit::IsAutoShrinkModeEnabled(void) const
 342 {
 343         SysAssertf(__pTokenEditPresenter != null, "_TokenEditPresenter instance is null");
 344
 345         return __pTokenEditPresenter->IsAutoShrinkModeEnabled();
 346 }
 347
 348 result
 349 _TokenEdit::ProcessTokenFiltering(const String& inputString, String& replaceString, bool& enable)
 350 {
 351         if (__pTokenFilter)
 352         {
 353                 enable = __pTokenFilter->ReplaceToken(inputString, replaceString);
 354         }
 355
 356         return E_SUCCESS;
 357 }
 358
 359 bool
 360 _TokenEdit::OnTouchPressed(const _Control& source, const _TouchInfo& touchinfo)
 361 {
 362         if (&source != this)
 363         {
 364                 return false;
 365         }
 366
 367         if (__pTokenEditPresenter == null)
 368         {
 369                 return false;
 370         }
 371         return __pTokenEditPresenter->OnTouchPressed(source, touchinfo);
 372 }
 373
 374 bool
 375 _TokenEdit::OnTouchReleased(const _Control& source, const _TouchInfo& touchinfo)
 376 {
 377         if (&source != this)
 378         {
 379                 return false;
 380         }
 381         if (__pTokenEditPresenter == null)
 382         {
 383                 return false;
 384         }
 385         return __pTokenEditPresenter->OnTouchReleased(source, touchinfo);
 386 }
 387
 388 bool
 389 _TokenEdit::OnTouchMoved(const _Control& source, const _TouchInfo& touchinfo)
 390 {
 391         if (&source != this)
 392         {
 393                 return false;
 394         }
 395         if (__pTokenEditPresenter == null)
 396         {
 397                 return false;
 398         }
 399         return __pTokenEditPresenter->OnTouchMoved(source, touchinfo);
 400 }
 401
 402 result
 403 _TokenEdit::SetPropertyNormalTokenColor(const Variant& color)
 404 {
 405         ClearLastResult();
 406
 407         __tokenColor[TOKEN_EDIT_STATUS_NORMAL] = color.ToColor();
 408
 409         return E_SUCCESS;
 410 }
 411
 412 Variant
 413 _TokenEdit::GetPropertyNormalTokenColor(void) const
 414 {
 415         ClearLastResult();
 416
 417         return Variant(__tokenColor[TOKEN_EDIT_STATUS_NORMAL]);
 418 }
 419
 420 result
 421 _TokenEdit::SetPropertySelectedTokenColor(const Variant& color)
 422 {
 423         ClearLastResult();
 424
 425         __tokenColor[TOKEN_EDIT_STATUS_SELECTED] = color.ToColor();
 426
 427         return E_SUCCESS;
 428 }
 429
 430 Variant
 431 _TokenEdit::GetPropertySelectedTokenColor(void) const
 432 {
 433         ClearLastResult();
 434
 435         return Variant(__tokenColor[TOKEN_EDIT_STATUS_SELECTED]);
 436 }
 437
 438 result
 439 _TokenEdit::SetPropertyHighlightedTokenColor(const Variant& color)
 440 {
 441         ClearLastResult();
 442
 443         __tokenColor[TOKEN_EDIT_STATUS_HIGHLIGHTED] = color.ToColor();
 444
 445         return E_SUCCESS;
 446 }
 447
 448 Variant
 449 _TokenEdit::GetPropertyHighlightedTokenColor(void) const
 450 {
 451         ClearLastResult();
 452
 453         return Variant(__tokenColor[TOKEN_EDIT_STATUS_HIGHLIGHTED]);
 454 }
 455
 456 result
 457 _TokenEdit::SetPropertyDisabledTokenColor(const Variant& color)
 458 {
 459         ClearLastResult();
 460
 461         __tokenColor[TOKEN_EDIT_STATUS_DISABLED] = color.ToColor();
 462
 463         return E_SUCCESS;
 464 }
 465
 466 Variant
 467 _TokenEdit::GetPropertyDisabledTokenColor(void) const
 468 {
 469         ClearLastResult();
 470
 471         return Variant(__tokenColor[TOKEN_EDIT_STATUS_DISABLED]);
 472 }
 473
 474 result
 475 _TokenEdit::SetPropertyTokenTextColor(const Variant& color)
 476 {
 477         ClearLastResult();
 478
 479         __tokenTextColor[EXPANDABLE_EDIT_AREA_TOKEN_STATUS_NORMAL] = color.ToColor();
 480         if (!__isSelectedTokenTextColorSet)
 481         {
 482                 __tokenTextColor[EXPANDABLE_EDIT_AREA_TOKEN_STATUS_SELECTED] = color.ToColor();
 483         }
 484
 485         return E_SUCCESS;
 486 }
 487
 488 Variant
 489 _TokenEdit::GetPropertyTokenTextColor(void) const
 490 {
 491         ClearLastResult();
 492
 493         return Variant(__tokenTextColor[EXPANDABLE_EDIT_AREA_TOKEN_STATUS_NORMAL]);
 494 }
 495
 496 result
 497 _TokenEdit::SetPropertySelectedTokenTextColor(const Variant& color)
 498 {
 499         ClearLastResult();
 500
 501         __isSelectedTokenTextColorSet = true;
 502
 503         __tokenTextColor[EXPANDABLE_EDIT_AREA_TOKEN_STATUS_SELECTED] = color.ToColor();
 504
 505         return E_SUCCESS;
 506 }
 507
 508 Variant
 509 _TokenEdit::GetPropertySelectedTokenTextColor(void) const
 510 {
 511         ClearLastResult();
 512
 513         return Variant(__tokenTextColor[EXPANDABLE_EDIT_AREA_TOKEN_STATUS_SELECTED]);
 514 }
 515
 516 result
 517 _TokenEdit::SetPropertyTokenEditModeEnabled(const Variant& enable)
 518 {
 519         SysAssertf(__pTokenEditPresenter != null, "_TokenEditPresenter instance is null");
 520
 521         ClearLastResult();
 522
 523         return __pTokenEditPresenter->SetTokenEditModeEnabled(enable.ToBool());
 524 }
 525
 526 Variant
 527 _TokenEdit::GetPropertyTokenEditModeEnabled(void) const
 528 {
 529         SysAssertf(__pTokenEditPresenter != null, "_TokenEditPresenter instance is null");
 530
 531         ClearLastResult();
 532
 533         bool enabled = __pTokenEditPresenter->IsTokenEditModeEnabled();
 534
 535         return Variant(enabled);
 536 }
 537
 538 result
 539 _TokenEdit::OnAttachedToMainTree(void)
 540 {
 541         _AccessibilityContainer* pContainer = null;
 542         pContainer = GetAccessibilityContainer();
 543         if (pContainer)
 544         {
 545                 if (__pTitleTextAccessibilityElement)
 546                 {
 547                         return E_SUCCESS;
 548                 }
 549                 pContainer->AddListener(*this);
 550                 UpdateAccessibilityElement(EDIT_ACCESSIBILITY_ELEMENT_TYPE_TEXT);
 551         }
 552
 553         return E_SUCCESS;
 554 }
 555
 556 void
 557 _TokenEdit::OnBoundsChanged(void)
 558 {
 559         SysAssertf(__pTokenEditPresenter != null, "_TokenEditPresenter instance is null");
 560
 561         __pTokenEditPresenter->OnBoundsChanged();
 562
 563         return;
 564 }
 565
 566 bool
 567 _TokenEdit::OnAccessibilityFocusIn(const _AccessibilityContainer& control, const _AccessibilityElement& element)
 568 {
 569         return __pTokenEditPresenter->OnAccessibilityFocusIn(control, element);
 570 }
 571
 572 bool
 573 _TokenEdit::OnAccessibilityFocusOut(const _AccessibilityContainer& control, const _AccessibilityElement& element)
 574 {
 575         return __pTokenEditPresenter->OnAccessibilityFocusOut(control, element);
 576 }
 577
 578 bool
 579 _TokenEdit::OnAccessibilityActionPerformed(const _AccessibilityContainer& control, const _AccessibilityElement& element)
 580 {
 581         return __pTokenEditPresenter->OnAccessibilityActionPerformed(control, element);
 582 }
 583
 584 void
 585 _TokenEdit::UpdateAccessibilityElement(EditAccessibilityElementType type)
 586 {
 587         _AccessibilityElement* pTextAccessibilityElement = _Edit::GetTextAccessibilityElement();
 588         String spaceString(L" ");
 589         switch (type)
 590         {
 591         case EDIT_ACCESSIBILITY_ELEMENT_TYPE_TEXT:
 592                 if (pTextAccessibilityElement)
 593                 {
 594                         pTextAccessibilityElement->SetBounds(FloatRectangle(0.0f, 0.0f, GetBoundsF().width, GetBoundsF().height));
 595                         if (GetTokenCount())
 596                         {
 597                                 pTextAccessibilityElement->SetLabel(GetTitleText() + spaceString + __pTokenEditPresenter->GetTextAccessibilityElementText());
 598                         }
 599                         else
 600                         {
 601                                 pTextAccessibilityElement->SetLabel(GetTitleText() + spaceString + GetGuideText() + GetText());
 602                         }
 603                         pTextAccessibilityElement->SetHintWithStringId("IDS_TPLATFORM_BODY_DOUBLE_TAP_TO_EDIT_T_TTS");
 604                 }
 605                 break;
 606
 607         default:
 608                 break;
 609         }
 610
 611         return;
 612 }
 613
 614 _AccessibilityElement*
 615 _TokenEdit::GetTitleTextAccessibilityElement(void) const
 616 {
 617         return __pTitleTextAccessibilityElement;
 618 }
 619
 620 _AccessibilityElement*
 621 _TokenEdit::GetCursorAccessibilityElement(void) const
 622 {
 623         return __pCursorAccessibilityElement;
 624 }
 625
 626 result
 627 _TokenEdit::AddTitleAccessibilityElement(void)
 628 {
 629         result r = E_SUCCESS;
 630
 631         if (!(GetEditStyle() & EDIT_STYLE_TITLE_LEFT))
 632         {
 633                 return r;
 634         }
 635
 636         if (__pTitleTextAccessibilityElement)
 637         {
 638                 return r;
 639         }
 640
 641         _AccessibilityContainer* pContainer = GetAccessibilityContainer();
 642
 643         if (pContainer)
 644         {
 645                 _AccessibilityElement* pAccessibilityElement = new (std::nothrow) _AccessibilityElement(true);
 646                 SysTryReturnResult(NID_UI_CTRL, pAccessibilityElement != null, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] Memory allocation failed.");
 647
 648                 String labelText = GetTitleText();
 649                 pAccessibilityElement->SetBounds(__pTokenEditPresenter->GetDescriptionTextRect());
 650                 pAccessibilityElement->SetLabel(labelText);
 651                 pContainer->AddElement(*pAccessibilityElement);
 652                 __pTitleTextAccessibilityElement = pAccessibilityElement;
 653         }
 654
 655         return r;
 656 }
 657
 658 result
 659 _TokenEdit::AddCursorAccessibilityElement(void)
 660 {
 661         result r = E_SUCCESS;
 662
 663         if (__pCursorAccessibilityElement)
 664         {
 665                 return r;
 666         }
 667
 668         _AccessibilityContainer* pContainer = GetAccessibilityContainer();
 669
 670         if (pContainer)
 671         {
 672                 _AccessibilityElement* pAccessibilityElement = new (std::nothrow) _AccessibilityElement(true);
 673                 SysTryReturnResult(NID_UI_CTRL, pAccessibilityElement != null, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] Memory allocation failed.");
 674
 675                 if (GetTextLength())
 676                 {
 677                         pAccessibilityElement->SetLabel(GetText());
 678                 }
 679                 else
 680                 {
 681                         pAccessibilityElement->SetTrait(L"Edit field");
 682                 }
 683
 684                 pContainer->AddElement(*pAccessibilityElement);
 685
 686                 __pCursorAccessibilityElement = pAccessibilityElement;
 687
 688                 SetCursorAccessibilityBounds(__pTokenEditPresenter->GetTextBoundsF());
 689         }
 690
 691         return r;
 692 }
 693
 694 result
 695 _TokenEdit::SetCursorAccessibilityBounds(const FloatRectangle& cursorBounds)
 696 {
 697         if (!__pCursorAccessibilityElement)
 698         {
 699                 return E_SUCCESS;
 700         }
 701         __pCursorAccessibilityElement->SetBounds(cursorBounds);
 702
 703         return E_SUCCESS;
 704 }
 705
 706 void
 707 _TokenEdit::RemoveTitleAccessibilityElement(void)
 708 {
 709         _AccessibilityContainer* pContainer = GetAccessibilityContainer();
 710         if (pContainer)
 711         {
 712                 if (__pTitleTextAccessibilityElement)
 713                 {
 714                         pContainer->RemoveElement(*__pTitleTextAccessibilityElement);
 715                         __pTitleTextAccessibilityElement = null;
 716                 }
 717         }
 718 }
 719
 720 void
 721 _TokenEdit::RemoveCursorAccessibilityElement(void)
 722 {
 723         _AccessibilityContainer* pContainer = GetAccessibilityContainer();
 724         if (pContainer)
 725         {
 726                 if (__pCursorAccessibilityElement)
 727                 {
 728                         pContainer->RemoveElement(*__pCursorAccessibilityElement);
 729                         __pCursorAccessibilityElement = null;
 730                 }
 731         }
 732 }
 733
 734 void
 735 _TokenEdit::OnDrawFocus(void)
 736 {
 737         //Exit Token editing/pressed mode
 738         __pTokenEditPresenter->PrepareFocusUiMode();
 739
 740         __pTokenEditPresenter->SetDrawFocusState(true);
 741
 742         return;
 743 }
 744
 745 void
 746 _TokenEdit::OnFocusModeStateChanged(void)
 747 {
 748         //Reset focus index here
 749         __pTokenEditPresenter->SetDrawFocusState(false);
 750
 751         return;
 752 }
 753
 754 }}} //Tizen::Ui::Controls