src/ui/controls/FUiCtrl_ExpandableEditAreaImpl.cpp

   1 //
   2 // Open Service Platform
   3 // Copyright (c) 2012-2013 Samsung Electronics Co., Ltd.
   4 //
   5 // Licensed under the Flora License, Version 1.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://floralicense.org/license/
  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_ExpandableEditAreaImpl.cpp
  19 * @brief        This is the implementation for the _ExpandableEditAreaImpl class.
  20 * @version      3.0
  21 */
  22
  23 #include <FBaseSysLog.h>
  24 #include <FBaseInternalTypes.h>
  25 #include <FUiCtrlInputTypes.h>
  26 #include "FUi_UiBuilder.h"
  27 #include "FUi_ResourceSizeInfo.h"
  28 #include "FUiCtrl_Edit.h"
  29 #include "FUiCtrl_ExpandableEditAreaImpl.h"
  30 #include "FUiCtrl_TokenEdit.h"
  31
  32 static const int _EXPANDABLE_EDIT_AREA_DEFAULT_MAX_LINE_COUNT = 10;
  33
  34 using namespace Tizen::Base;
  35 using namespace Tizen::Graphics;
  36 using namespace Tizen::Locales;
  37 using namespace Tizen::Base::Runtime;
  38
  39 namespace Tizen { namespace Ui { namespace Controls
  40 {
  41 _ExpandableEditAreaImpl*
  42 _ExpandableEditAreaImpl::GetInstance(ExpandableEditArea& expandableEditArea)
  43 {
  44         return (static_cast<_ExpandableEditAreaImpl*> (expandableEditArea._pControlImpl));
  45 }
  46
  47 const _ExpandableEditAreaImpl*
  48 _ExpandableEditAreaImpl::GetInstance(const ExpandableEditArea& expandableEditArea)
  49 {
  50         return (static_cast<const _ExpandableEditAreaImpl*> (expandableEditArea._pControlImpl));
  51 }
  52
  53 _ExpandableEditAreaImpl::_ExpandableEditAreaImpl(ExpandableEditArea* pPublic, _Edit* pCore)
  54         : _ControlImpl(pPublic, pCore)
  55         , __pExpandableEditArea(pCore)
  56         , __expandableEditAreaStyle(EXPANDABLE_EDIT_AREA_STYLE_NORMAL)
  57         , __expandableEditAreaTitleStyle(EXPANDABLE_EDIT_AREA_TITLE_STYLE_NONE)
  58         , __maxLineCount(_EXPANDABLE_EDIT_AREA_DEFAULT_MAX_LINE_COUNT)
  59         , __pPublicTextEvent(null)
  60         , __pPublicExpandableEditAreaEvent(null)
  61         , __pPublicTextBlockEvent(null)
  62         , __pPublicKeypadEvent(null)
  63         , __pPublicLanguageEvent(null)
  64         , __pTokenFilter(null)
  65 {
  66 }
  67
  68 _ExpandableEditAreaImpl::~_ExpandableEditAreaImpl(void)
  69 {
  70         if (__pExpandableEditArea)
  71         {
  72                 __pExpandableEditArea->RemoveTextEventListener(*this);
  73                 __pExpandableEditArea->RemoveExpandableEditAreaEventListener(*this);
  74                 __pExpandableEditArea->RemoveTextBlockEventListener(*this);
  75                 __pExpandableEditArea->RemoveKeypadEventListener(*this);
  76         }
  77
  78         delete __pPublicTextEvent;
  79         __pPublicTextEvent = null;
  80
  81         delete __pPublicExpandableEditAreaEvent;
  82         __pPublicExpandableEditAreaEvent = null;
  83
  84         delete __pPublicTextBlockEvent;
  85         __pPublicTextBlockEvent = null;
  86
  87         delete __pPublicKeypadEvent;
  88         __pPublicKeypadEvent = null;
  89
  90 }
  91
  92 _ExpandableEditAreaImpl*
  93 _ExpandableEditAreaImpl::CreateExpandableEditAreaImplN(ExpandableEditArea* pControl, const Rectangle& rect,
  94                                                                                                            ExpandableEditAreaStyle style, ExpandableEditAreaTitleStyle titleStyle)
  95 {
  96         ClearLastResult();
  97
  98         result r = E_SUCCESS;
  99
 100         r = FUNC_SIZE_INFO(ExpandableEditArea)().CheckInitialSizeValid(Dimension(rect.width, rect.height), _CONTROL_ORIENTATION_PORTRAIT);
 101         SysTryReturn(NID_UI_CTRL, r == E_SUCCESS, null, E_INVALID_ARG, "[E_INVALID_ARG] Invalid argument is used. The given rect size is not valid.");
 102
 103         _Edit* pCore = null;
 104         if (style == EXPANDABLE_EDIT_AREA_STYLE_NORMAL)
 105         {
 106                 pCore = _Edit::CreateEditN();
 107         }
 108         else
 109         {
 110                 pCore = _TokenEdit::CreateTokenEditN();
 111         }
 112         SysTryReturn(NID_UI_CTRL, pCore != null, null, GetLastResult(), "[%s] Propagating.", GetErrorMessage(GetLastResult()));
 113
 114         _ExpandableEditAreaImpl* pImpl = new (std::nothrow) _ExpandableEditAreaImpl(pControl, pCore);
 115         r = CheckConstruction(pCore, pImpl);
 116         SysTryReturn(NID_UI_CTRL, r == E_SUCCESS, null, r, "[%s] Propagating.", GetErrorMessage(r));
 117
 118         r = pImpl->InitializeBoundsProperties(FUNC_SIZE_INFO(ExpandableEditArea)(), _CONTROL_ORIENTATION_PORTRAIT);
 119         SysTryCatch(NID_UI_CTRL, r == E_SUCCESS, , r, "[%s] Propagating.", GetErrorMessage(r));
 120
 121         r = pCore->AddExpandableEditAreaEventListener(*pImpl);
 122         SysTryCatch(NID_UI_CTRL, r == E_SUCCESS, , r, "[%s] Propagating.", GetErrorMessage(r));
 123
 124         r = pCore->AddKeypadEventListener(*pImpl);
 125         SysTryCatch(NID_UI_CTRL, r == E_SUCCESS, , r, "[%s] Propagating.", GetErrorMessage(r));
 126
 127         r = pCore->AddTextBlockEventListener(*pImpl);
 128         SysTryCatch(NID_UI_CTRL, r == E_SUCCESS, , r, "[%s] Propagating.", GetErrorMessage(r));
 129
 130         r = pCore->AddTextEventListener(*pImpl);
 131         SysTryCatch(NID_UI_CTRL, r == E_SUCCESS, , r, "[%s] Propagating.", GetErrorMessage(r));
 132
 133         r = pCore->AddLanguageEventListener(*pImpl);
 134         SysTryCatch(NID_UI_CTRL, r == E_SUCCESS, , r, "[%s] Propagating.", GetErrorMessage(r));
 135
 136         return pImpl;
 137
 138 CATCH:
 139         delete pImpl;
 140         return null;
 141 }
 142
 143 const char*
 144 _ExpandableEditAreaImpl::GetPublicClassName(void) const
 145 {
 146         return "Tizen::Ui::Controls::ExpandableEditArea";
 147 }
 148
 149 const ExpandableEditArea&
 150 _ExpandableEditAreaImpl::GetPublic(void) const
 151 {
 152         return static_cast <const ExpandableEditArea&>(_ControlImpl::GetPublic());
 153 }
 154
 155 ExpandableEditArea&
 156 _ExpandableEditAreaImpl::GetPublic(void)
 157 {
 158         return static_cast <ExpandableEditArea&>(_ControlImpl::GetPublic());
 159 }
 160
 161 const _Edit&
 162 _ExpandableEditAreaImpl::GetCore(void) const
 163 {
 164         return static_cast <const _Edit&>(_ControlImpl::GetCore());
 165 }
 166
 167 _Edit&
 168 _ExpandableEditAreaImpl::GetCore(void)
 169 {
 170         return static_cast <_Edit&>(_ControlImpl::GetCore());
 171 }
 172
 173 result
 174 _ExpandableEditAreaImpl::Construct(const Rectangle& rect, ExpandableEditAreaStyle style,
 175                                                                    ExpandableEditAreaTitleStyle titleStyle, int maxExpandableLines)
 176 {
 177         ClearLastResult();
 178
 179         result r = E_SUCCESS;
 180
 181         r = CreateExpandableEditArea(rect, style, titleStyle, maxExpandableLines);
 182         SysTryReturnResult(NID_UI_CTRL, r == E_SUCCESS, r, "Propagating.");
 183
 184         return r;
 185 }
 186
 187 result
 188 _ExpandableEditAreaImpl::Dispose(void)
 189 {
 190         ClearLastResult();
 191
 192         result r = E_SUCCESS;
 193
 194         if (__pExpandableEditArea)
 195         {
 196                 delete __pExpandableEditArea;
 197                 __pExpandableEditArea = null;
 198         }
 199
 200         return r;
 201 }
 202
 203 result
 204 _ExpandableEditAreaImpl::CreateExpandableEditArea(const Rectangle& rect, ExpandableEditAreaStyle style,
 205                                                                                                   ExpandableEditAreaTitleStyle titleStyle, int maxExpandableLines)
 206 {
 207         ClearLastResult();
 208
 209         result r = E_SUCCESS;
 210
 211         int editStyle = EDIT_STYLE_NORMAL | EDIT_STYLE_FLEXIBLE;
 212         if (style & EXPANDABLE_EDIT_AREA_STYLE_TOKEN)
 213         {
 214                 editStyle |= EDIT_STYLE_TOKEN;
 215         }
 216
 217         if (titleStyle == EXPANDABLE_EDIT_AREA_TITLE_STYLE_INNER)
 218         {
 219                 editStyle |= EDIT_STYLE_TITLE_LEFT;
 220         }
 221         else if (titleStyle == EXPANDABLE_EDIT_AREA_TITLE_STYLE_TOP)
 222         {
 223                 editStyle |= EDIT_STYLE_TITLE_TOP;
 224         }
 225
 226         r = __pExpandableEditArea->Initialize(editStyle, INPUT_STYLE_OVERLAY, 1000);
 227         SysTryReturnResult(NID_UI_CTRL, r == E_SUCCESS, r, "Propagating.");
 228
 229         __pExpandableEditArea->SetMaxLineCount(maxExpandableLines);
 230
 231         return r;
 232 }
 233
 234 int
 235 _ExpandableEditAreaImpl::GetMargin(EditMarginType marginType) const
 236 {
 237         ClearLastResult();
 238
 239         if (marginType == EDIT_MARGIN_TYPE_VERTICAL)
 240         {
 241                 return __pExpandableEditArea->GetVerticalMargin(EDIT_TEXT_TOP_MARGIN);
 242         }
 243         else
 244         {
 245                 return __pExpandableEditArea->GetHorizontalMargin(EDIT_TEXT_LEFT_MARGIN);
 246         }
 247 }
 248
 249 result
 250 _ExpandableEditAreaImpl::SetMargin(EditMarginType marginType, int margin)
 251 {
 252         ClearLastResult();
 253
 254         result r = E_SUCCESS;
 255         Variant varMargin(margin);
 256
 257         if (marginType == EDIT_MARGIN_TYPE_HORIZONTAL)
 258         {
 259                 r = __pExpandableEditArea->SetHorizontalMargin(margin, EDIT_TEXT_LEFT_MARGIN);
 260                 SysTryReturn(NID_UI_CTRL, r == E_SUCCESS, r, r, "[%s] Propagating.", GetErrorMessage(r));
 261                 r = __pExpandableEditArea->SetHorizontalMargin(margin, EDIT_TEXT_RIGHT_MARGIN);
 262                 SysTryReturn(NID_UI_CTRL, r == E_SUCCESS, r, r, "[%s] Propagating.", GetErrorMessage(r));
 263         }
 264         else
 265         {
 266                 r = __pExpandableEditArea->SetVerticalMargin(margin, EDIT_TEXT_TOP_MARGIN);
 267                 SysTryReturn(NID_UI_CTRL, r == E_SUCCESS, r, r, "[%s] Propagating.", GetErrorMessage(r));
 268                 r = __pExpandableEditArea->SetVerticalMargin(margin, EDIT_TEXT_BOTTOM_MARGIN);
 269                 SysTryReturn(NID_UI_CTRL, r == E_SUCCESS, r, r, "[%s] Propagating.", GetErrorMessage(r));
 270         }
 271
 272         return r;
 273 }
 274
 275 KeypadAction
 276 _ExpandableEditAreaImpl::GetKeypadAction(void) const
 277 {
 278         ClearLastResult();
 279
 280         CoreKeypadAction coreKeypadAction = __pExpandableEditArea->GetKeypadAction();
 281         KeypadAction publicKeypadAction = KEYPAD_ACTION_ENTER;
 282
 283         switch (coreKeypadAction)
 284         {
 285         case CORE_KEYPAD_ACTION_ENTER:
 286                 publicKeypadAction = KEYPAD_ACTION_ENTER;
 287                 break;
 288
 289         case CORE_KEYPAD_ACTION_GO:
 290                 publicKeypadAction = KEYPAD_ACTION_GO;
 291                 break;
 292
 293         case CORE_KEYPAD_ACTION_NEXT:
 294                 publicKeypadAction = KEYPAD_ACTION_NEXT;
 295                 break;
 296
 297         case CORE_KEYPAD_ACTION_SEND:
 298                 publicKeypadAction = KEYPAD_ACTION_SEND;
 299                 break;
 300
 301         case CORE_KEYPAD_ACTION_SEARCH:
 302                 publicKeypadAction = KEYPAD_ACTION_SEARCH;
 303                 break;
 304
 305         case CORE_KEYPAD_ACTION_LOGIN:
 306                 publicKeypadAction = KEYPAD_ACTION_LOGIN;
 307                 break;
 308
 309         case CORE_KEYPAD_ACTION_SIGN_IN:
 310                 publicKeypadAction = KEYPAD_ACTION_SIGN_IN;
 311                 break;
 312
 313         case CORE_KEYPAD_ACTION_JOIN:
 314                 publicKeypadAction = KEYPAD_ACTION_JOIN;
 315                 break;
 316
 317         case CORE_KEYPAD_ACTION_DONE:
 318                 publicKeypadAction = KEYPAD_ACTION_DONE;
 319                 break;
 320
 321         default:
 322                 break;
 323         }
 324
 325         return publicKeypadAction;
 326 }
 327
 328 result
 329 _ExpandableEditAreaImpl::SetKeypadAction(KeypadAction keypadAction)
 330 {
 331         ClearLastResult();
 332
 333         CoreKeypadAction coreKeypadAction = CORE_KEYPAD_ACTION_ENTER;
 334
 335         switch (keypadAction)
 336         {
 337         case KEYPAD_ACTION_ENTER:
 338                 coreKeypadAction = CORE_KEYPAD_ACTION_ENTER;
 339                 break;
 340
 341         case KEYPAD_ACTION_GO:
 342                 coreKeypadAction = CORE_KEYPAD_ACTION_GO;
 343                 break;
 344
 345         case KEYPAD_ACTION_NEXT:
 346                 coreKeypadAction = CORE_KEYPAD_ACTION_NEXT;
 347                 break;
 348
 349         case KEYPAD_ACTION_SEND:
 350                 coreKeypadAction = CORE_KEYPAD_ACTION_SEND;
 351                 break;
 352
 353         case KEYPAD_ACTION_SEARCH:
 354                 coreKeypadAction = CORE_KEYPAD_ACTION_SEARCH;
 355                 break;
 356
 357         case KEYPAD_ACTION_LOGIN:
 358                 coreKeypadAction = CORE_KEYPAD_ACTION_LOGIN;
 359                 break;
 360
 361         case KEYPAD_ACTION_SIGN_IN:
 362                 coreKeypadAction = CORE_KEYPAD_ACTION_SIGN_IN;
 363                 break;
 364
 365         case KEYPAD_ACTION_JOIN:
 366                 coreKeypadAction = CORE_KEYPAD_ACTION_JOIN;
 367                 break;
 368
 369         case KEYPAD_ACTION_DONE:
 370                 coreKeypadAction = CORE_KEYPAD_ACTION_DONE;
 371                 break;
 372
 373         default:
 374                 break;
 375         }
 376
 377         return __pExpandableEditArea->SetKeypadAction(coreKeypadAction);
 378 }
 379
 380 KeypadStyle
 381 _ExpandableEditAreaImpl::GetKeypadStyle(void) const
 382 {
 383         ClearLastResult();
 384
 385         return __pExpandableEditArea->GetKeypadStyle();
 386 }
 387
 388 result
 389 _ExpandableEditAreaImpl::SetKeypadStyle(KeypadStyle keypadStyle)
 390 {
 391         ClearLastResult();
 392
 393         return __pExpandableEditArea->SetKeypadStyle(keypadStyle);
 394 }
 395
 396 bool
 397 _ExpandableEditAreaImpl::IsTextPredictionEnabled(void) const
 398 {
 399         return __pExpandableEditArea->IsTextPredictionEnabled();
 400 }
 401
 402 result
 403 _ExpandableEditAreaImpl::SetTextPredictionEnabled(bool enable)
 404 {
 405         return __pExpandableEditArea->SetTextPredictionEnabled(enable);
 406 }
 407
 408 result
 409 _ExpandableEditAreaImpl::HideKeypad(void)
 410 {
 411         ClearLastResult();
 412
 413         return __pExpandableEditArea->HideKeypad();
 414 }
 415
 416 int
 417 _ExpandableEditAreaImpl::GetTextSize(void) const
 418 {
 419         ClearLastResult();
 420
 421         return __pExpandableEditArea->GetTextSize();
 422 }
 423
 424 result
 425 _ExpandableEditAreaImpl::SetTextSize(int size)
 426 {
 427         ClearLastResult();
 428
 429         return __pExpandableEditArea->SetTextSize(size);
 430 }
 431
 432 Color
 433 _ExpandableEditAreaImpl::GetColor(EditStatus status) const
 434 {
 435         ClearLastResult();
 436
 437         return __pExpandableEditArea->GetColor(status);
 438 }
 439
 440 Color
 441 _ExpandableEditAreaImpl::GetTextColor(EditTextColor type) const
 442 {
 443         ClearLastResult();
 444         SysTryReturn(NID_UI_CTRL, type !=  EDIT_TEXT_COLOR_LINK, Color(), E_INVALID_ARG, "[E_INVALID_ARG] Invalid argument is used. The EditTextColor type is EDIT_TEXT_COLOR_LINK.");
 445
 446         return __pExpandableEditArea->GetTextColor(type);
 447 }
 448
 449 result
 450 _ExpandableEditAreaImpl::SetBackgroundBitmap(EditStatus status, const Bitmap& bitmap)
 451 {
 452         ClearLastResult();
 453
 454         return __pExpandableEditArea->SetBackgroundBitmap(status, bitmap);
 455 }
 456
 457 result
 458 _ExpandableEditAreaImpl::SetColor(EditStatus status, const Color& color)
 459 {
 460         ClearLastResult();
 461
 462         return __pExpandableEditArea->SetColor(status, color);
 463 }
 464
 465 result
 466 _ExpandableEditAreaImpl::SetTextColor(EditTextColor type, const Color& color)
 467 {
 468         ClearLastResult();
 469
 470         return __pExpandableEditArea->SetTextColor(type, color);
 471 }
 472
 473 String
 474 _ExpandableEditAreaImpl::GetText(int start, int end) const
 475 {
 476         ClearLastResult();
 477
 478         return __pExpandableEditArea->GetText(start, end);
 479 }
 480
 481 result
 482 _ExpandableEditAreaImpl::AddExpandableEditAreaEventListener(IExpandableEditAreaEventListener& listener)
 483 {
 484         result r = E_SUCCESS;
 485         ClearLastResult();
 486
 487         if (__pPublicExpandableEditAreaEvent == null)
 488         {
 489                 __pPublicExpandableEditAreaEvent = _PublicExpandableEditAreaEvent::CreateInstanceN(GetPublic());
 490                 r = GetLastResult();
 491                 SysTryReturnResult(NID_UI_CTRL, __pPublicExpandableEditAreaEvent != null, r, "Propagating.");
 492         }
 493
 494         r = __pPublicExpandableEditAreaEvent->AddListener(listener);
 495         SysTryReturnResult(NID_UI_CTRL, r != E_OBJ_ALREADY_EXIST, E_SYSTEM, "A system error has occurred. The IExpandableEditAreaEventListener instance already exists in the event listener list.");
 496
 497         return r;
 498 }
 499
 500 result
 501 _ExpandableEditAreaImpl::RemoveExpandableEditAreaEventListener(IExpandableEditAreaEventListener& listener)
 502 {
 503         ClearLastResult();
 504
 505         SysTryReturnResult(NID_UI_CTRL, __pPublicExpandableEditAreaEvent != null, E_SYSTEM, "A system error has occurred. The _PublicExpandableEditAreaEvent instance is null");
 506
 507         result r = __pPublicExpandableEditAreaEvent->RemoveListener(listener);
 508         SysTryReturnResult(NID_UI_CTRL, r != E_OBJ_NOT_FOUND, E_SYSTEM, "A system error has occurred. The IExpandableEditAreaEventListener instance does not exist in the event listener list.");
 509
 510         return r;
 511
 512 }
 513
 514 result
 515 _ExpandableEditAreaImpl::AddKeypadEventListener(IKeypadEventListener& listener)
 516 {
 517         result r = E_SUCCESS;
 518         ClearLastResult();
 519
 520         if (__pPublicKeypadEvent == null)
 521         {
 522                 __pPublicKeypadEvent = _PublicKeypadEvent::CreateInstanceN(GetPublic());
 523                 r = GetLastResult();
 524                 SysTryReturnResult(NID_UI_CTRL, __pPublicKeypadEvent != null, r, "Propagating.");
 525         }
 526
 527         r = __pPublicKeypadEvent->AddListener(listener);
 528         SysTryReturnResult(NID_UI_CTRL, r != E_OBJ_ALREADY_EXIST, E_SYSTEM, "A system error has occurred. The IKeypadEventListener instance already exists in the event listener list.");
 529
 530         return r;
 531 }
 532
 533 result
 534 _ExpandableEditAreaImpl::RemoveKeypadEventListener(IKeypadEventListener& listener)
 535 {
 536         ClearLastResult();
 537
 538         SysTryReturnResult(NID_UI_CTRL, __pPublicKeypadEvent != null, E_SYSTEM, "A system error has occurred. The _PublicKeypadEvent instance is null.");
 539
 540         result r = __pPublicKeypadEvent->RemoveListener(listener);
 541         SysTryReturnResult(NID_UI_CTRL, r != E_OBJ_NOT_FOUND, E_SYSTEM, "A system error has occurred. The IKeypadEventListener instance does not exist in the event listener list.");
 542
 543         return r;
 544
 545 }
 546
 547 result
 548 _ExpandableEditAreaImpl::AddTextBlockEventListener(ITextBlockEventListener& listener)
 549 {
 550         result r = E_SUCCESS;
 551         ClearLastResult();
 552
 553         if (__pPublicTextBlockEvent == null)
 554         {
 555                 __pPublicTextBlockEvent = _PublicTextBlockEvent::CreateInstanceN(GetPublic());
 556                 r = GetLastResult();
 557                 SysTryReturnResult(NID_UI_CTRL, __pPublicTextBlockEvent != null, r, "Propagating.");
 558         }
 559
 560         r = __pPublicTextBlockEvent->AddListener(listener);
 561         SysTryReturnResult(NID_UI_CTRL, r != E_OBJ_ALREADY_EXIST, E_SYSTEM, "A system error has occurred. The ITextBlockEventListener instance already exists in the event listener list.");
 562
 563         return r;
 564 }
 565
 566 result
 567 _ExpandableEditAreaImpl::RemoveTextBlockEventListener(ITextBlockEventListener& listener)
 568 {
 569         ClearLastResult();
 570
 571         SysTryReturnResult(NID_UI_CTRL, __pPublicTextBlockEvent, E_SYSTEM, "A system error has occurred. The _PublicTextBlockEvent instance is null.");
 572
 573         result r = __pPublicTextBlockEvent->RemoveListener(listener);
 574         SysTryReturnResult(NID_UI_CTRL, r != E_OBJ_NOT_FOUND, E_SYSTEM, "A system error has occurred. The ITextBlockEventListener instance does not exist in the event listener list.");
 575
 576         return r;
 577 }
 578
 579 result
 580 _ExpandableEditAreaImpl::AddTextEventListener(ITextEventListener& listener)
 581 {
 582         result r = E_SUCCESS;
 583         ClearLastResult();
 584
 585         if (__pPublicTextEvent == null)
 586         {
 587                 __pPublicTextEvent = _PublicTextEvent::CreateInstanceN(GetPublic());
 588                 r = GetLastResult();
 589                 SysTryReturnResult(NID_UI_CTRL, r == E_SUCCESS, r, "Propagating.");
 590         }
 591
 592         r = __pPublicTextEvent->AddListener(listener);
 593         SysTryReturnResult(NID_UI_CTRL, r != E_OBJ_ALREADY_EXIST, E_SYSTEM, "A system error has occurred. The ITextEventListener instance already exists in the event listener list.");
 594
 595         return r;
 596 }
 597
 598 result
 599 _ExpandableEditAreaImpl::RemoveTextEventListener(ITextEventListener& listener)
 600 {
 601         ClearLastResult();
 602
 603         SysTryReturnResult(NID_UI_CTRL, __pPublicTextEvent, E_SYSTEM, "A system error has occurred. The _PublicTextEvent instance is null.");
 604
 605         result r = __pPublicTextEvent->RemoveListener(listener);
 606         SysTryReturnResult(NID_UI_CTRL, r != E_OBJ_NOT_FOUND, E_SYSTEM, "A system error has occurred. The ITextEventListener instance does not exist in the event listener list.");
 607
 608         return r;
 609 }
 610
 611 result
 612 _ExpandableEditAreaImpl::AddLanguageEventListener(ILanguageEventListener& listener)
 613 {
 614         result r = E_SUCCESS;
 615         ClearLastResult();
 616
 617         if (__pPublicLanguageEvent == null)
 618         {
 619                 __pPublicLanguageEvent = _PublicLanguageEvent::CreateInstanceN(GetPublic());
 620                 r = GetLastResult();
 621                 SysTryReturnResult(NID_UI_CTRL, r == E_SUCCESS, r, "Propagating.");
 622         }
 623
 624         SysAssertf(__pPublicLanguageEvent != null, "Not yet constructed. Construct() should be called before use.");
 625
 626         r =  __pPublicLanguageEvent->AddListener(listener);
 627
 628         return r;
 629 }
 630
 631 result
 632 _ExpandableEditAreaImpl::RemoveLanguageEventListener(ILanguageEventListener& listener)
 633 {
 634         ClearLastResult();
 635
 636         SysAssertf(__pPublicLanguageEvent != null, "Not yet constructed. Construct() should be called before use.");
 637
 638         return __pPublicLanguageEvent->RemoveListener(listener);
 639 }
 640
 641 result
 642 _ExpandableEditAreaImpl::SetLowerCaseModeEnabled(bool enable)
 643 {
 644         ClearLastResult();
 645
 646         __pExpandableEditArea->SetLowerCaseModeEnabled(enable);
 647
 648         return E_SUCCESS;
 649 }
 650
 651 bool
 652 _ExpandableEditAreaImpl::IsLowerCaseModeEnabled(void) const
 653 {
 654         ClearLastResult();
 655
 656         return __pExpandableEditArea->IsLowerCaseModeEnabled();
 657 }
 658
 659 result
 660 _ExpandableEditAreaImpl::SetCursorPosition(int position)
 661 {
 662         ClearLastResult();
 663
 664         return __pExpandableEditArea->SetCursorPosition(position);
 665 }
 666
 667 int
 668 _ExpandableEditAreaImpl::GetCursorPosition(void) const
 669 {
 670         ClearLastResult();
 671
 672         return __pExpandableEditArea->GetCursorPosition();
 673 }
 674
 675 String
 676 _ExpandableEditAreaImpl::GetText(void) const
 677 {
 678         ClearLastResult();
 679
 680         return __pExpandableEditArea->GetText();
 681 }
 682
 683 int
 684 _ExpandableEditAreaImpl::GetTextLength(void) const
 685 {
 686         ClearLastResult();
 687
 688         return __pExpandableEditArea->GetTextLength();
 689 }
 690
 691 result
 692 _ExpandableEditAreaImpl::SetText(const String& text)
 693 {
 694         ClearLastResult();
 695
 696         return __pExpandableEditArea->SetText(text);
 697 }
 698
 699 result
 700 _ExpandableEditAreaImpl::InsertTextAt(int index, const String& text)
 701 {
 702         ClearLastResult();
 703
 704         return __pExpandableEditArea->InsertTextAt(index, text);
 705 }
 706
 707 result
 708 _ExpandableEditAreaImpl::AppendText(const String& text)
 709 {
 710         ClearLastResult();
 711
 712         return __pExpandableEditArea->AppendText(text);
 713 }
 714
 715 result
 716 _ExpandableEditAreaImpl::AppendCharacter(const Character& character)
 717 {
 718         ClearLastResult();
 719
 720         return __pExpandableEditArea->AppendCharacter(character);
 721 }
 722
 723 result
 724 _ExpandableEditAreaImpl::InsertTextAt(int position, const String& text, const Bitmap& textImage)
 725 {
 726         ClearLastResult();
 727
 728         _TokenEdit* pTokenEdit = dynamic_cast <_TokenEdit*>(__pExpandableEditArea);
 729         SysTryReturnResult(NID_UI_CTRL, pTokenEdit == null, E_UNSUPPORTED_OPERATION,
 730                                         "ExpandableEditArea of style EXPANDABLE_EDIT_AREA_STYLE_TOKEN does not support this operation.");
 731
 732         return __pExpandableEditArea->InsertTextAt(position, text, textImage);
 733 }
 734
 735 result
 736 _ExpandableEditAreaImpl::AppendText(const String& text, const Bitmap& textImage)
 737 {
 738         ClearLastResult();
 739
 740         _TokenEdit* pTokenEdit = dynamic_cast <_TokenEdit*>(__pExpandableEditArea);
 741         SysTryReturnResult(NID_UI_CTRL, pTokenEdit == null, E_UNSUPPORTED_OPERATION,
 742                                  "ExpandableEditArea of style EXPANDABLE_EDIT_AREA_STYLE_TOKEN does not support this operation.");
 743
 744         return __pExpandableEditArea->AppendText(text, textImage);
 745 }
 746
 747 result
 748 _ExpandableEditAreaImpl::Clear(void)
 749 {
 750         ClearLastResult();
 751
 752         return __pExpandableEditArea->ClearText();
 753 }
 754
 755 result
 756 _ExpandableEditAreaImpl::DeleteCharacterAt(int index)
 757 {
 758         ClearLastResult();
 759
 760         return __pExpandableEditArea->DeleteCharacterAt(index);
 761 }
 762
 763 result
 764 _ExpandableEditAreaImpl::InsertCharacterAt(int index, const Character& character)
 765 {
 766         ClearLastResult();
 767
 768         return __pExpandableEditArea->InsertCharacterAt(index, character);
 769 }
 770
 771 result
 772 _ExpandableEditAreaImpl::SetGuideText(const String& guideText)
 773 {
 774         ClearLastResult();
 775
 776         __pExpandableEditArea->SetGuideText(guideText);
 777
 778         return E_SUCCESS;
 779 }
 780
 781 String
 782 _ExpandableEditAreaImpl::GetGuideText(void) const
 783 {
 784         ClearLastResult();
 785
 786         return __pExpandableEditArea->GetGuideText();
 787 }
 788
 789 Color
 790 _ExpandableEditAreaImpl::GetGuideTextColor(void) const
 791 {
 792         ClearLastResult();
 793
 794         return __pExpandableEditArea->GetGuideTextColor();
 795 }
 796
 797 result
 798 _ExpandableEditAreaImpl::SetGuideTextColor(const Color& color)
 799 {
 800         ClearLastResult();
 801
 802         return __pExpandableEditArea->SetGuideTextColor(color);
 803 }
 804
 805 int
 806 _ExpandableEditAreaImpl::GetLineSpacing (void) const
 807 {
 808         return __pExpandableEditArea->GetLineSpacing();
 809 }
 810
 811 result
 812 _ExpandableEditAreaImpl::SetLineSpacing (int multiplier, int extra)
 813 {
 814         SysTryReturn(NID_UI_CTRL, multiplier >= 0, E_INVALID_ARG, E_INVALID_ARG, "[E_INVALID_ARG] Invalid argument is used. multiplier = %d ", multiplier);
 815         SysTryReturn(NID_UI_CTRL, extra >= 0, E_INVALID_ARG, E_INVALID_ARG, "[E_INVALID_ARG] Invalid argument is used. extra = %d ", extra);
 816
 817         return __pExpandableEditArea->SetLineSpacing(DEFAULT_LINE_SPACE * multiplier + extra);
 818 }
 819
 820 Color
 821 _ExpandableEditAreaImpl::GetTitleTextColor(EditStatus status) const
 822 {
 823         ClearLastResult();
 824
 825         return __pExpandableEditArea->GetTitleTextColor(status);
 826 }
 827
 828 result
 829 _ExpandableEditAreaImpl::SetTitleTextColor(EditStatus status, const Color& color)
 830 {
 831         ClearLastResult();
 832
 833         return __pExpandableEditArea->SetTitleTextColor(status, color);
 834 }
 835
 836 Color
 837 _ExpandableEditAreaImpl::GetTokenColor(ExpandableEditAreaTokenStatus status) const
 838 {
 839         ClearLastResult();
 840
 841         _TokenEdit* pTokenEdit = dynamic_cast <_TokenEdit*>(__pExpandableEditArea);
 842         SysTryReturn(NID_UI_CTRL, pTokenEdit != null, Color(), E_UNSUPPORTED_OPERATION,
 843                                 "[E_UNSUPPORTED_OPERATION] ExpandableEditArea of style EXPANDABLE_EDIT_AREA_NORMAL does not support this operation.");
 844
 845         Variant var;
 846         switch (status)
 847         {
 848         case EXPANDABLE_EDIT_AREA_TOKEN_STATUS_NORMAL :
 849                 var = pTokenEdit->GetPropertyNormalTokenColor();
 850                 break;
 851
 852         case EXPANDABLE_EDIT_AREA_TOKEN_STATUS_SELECTED :
 853                 var = pTokenEdit->GetPropertySelectedTokenColor();
 854                 break;
 855
 856         default :
 857                 break;
 858         }
 859
 860         return var.ToColor();
 861 }
 862
 863 result
 864 _ExpandableEditAreaImpl::SetTokenColor(ExpandableEditAreaTokenStatus status, const Color& color)
 865 {
 866         ClearLastResult();
 867
 868         _TokenEdit* pTokenEdit = dynamic_cast <_TokenEdit*>(__pExpandableEditArea);
 869         SysTryReturnResult(NID_UI_CTRL, pTokenEdit != null, E_UNSUPPORTED_OPERATION,
 870                                             "ExpandableEditArea of style EXPANDABLE_EDIT_AREA_NORMAL does not support this operation.");
 871
 872         Variant var(color);
 873
 874         switch (status)
 875         {
 876         case EXPANDABLE_EDIT_AREA_TOKEN_STATUS_NORMAL :
 877                 pTokenEdit->SetPropertyNormalTokenColor(var);
 878                 break;
 879
 880         case EXPANDABLE_EDIT_AREA_TOKEN_STATUS_SELECTED :
 881                 pTokenEdit->SetPropertySelectedTokenColor(var);
 882                 break;
 883
 884         default :
 885                 break;
 886         }
 887
 888         return E_SUCCESS;
 889 }
 890
 891 Color
 892 _ExpandableEditAreaImpl::GetTokenTextColor(void) const
 893 {
 894         ClearLastResult();
 895
 896         _TokenEdit* pTokenEdit = dynamic_cast <_TokenEdit*>(__pExpandableEditArea);
 897         SysTryReturn(NID_UI_CTRL, pTokenEdit != null, Color(), E_UNSUPPORTED_OPERATION,
 898                                 "[E_UNSUPPORTED_OPERATION] ExpandableEditArea of style EXPANDABLE_EDIT_AREA_NORMAL does not support this operation.");
 899
 900         Variant var = pTokenEdit->GetPropertyTokenTextColor();
 901
 902         return var.ToColor();
 903 }
 904
 905 Color
 906 _ExpandableEditAreaImpl::GetSelectedTokenTextColor(void) const
 907 {
 908         ClearLastResult();
 909
 910         _TokenEdit* pTokenEdit = dynamic_cast <_TokenEdit*>(__pExpandableEditArea);
 911         SysTryReturn(NID_UI_CTRL, pTokenEdit != null, Color(), E_UNSUPPORTED_OPERATION,
 912                                 "[E_UNSUPPORTED_OPERATION] ExpandableEditArea of style EXPANDABLE_EDIT_AREA_NORMAL does not support this operation.");
 913
 914         return pTokenEdit->GetSelectedTokenTextColor();
 915 }
 916
 917 result
 918 _ExpandableEditAreaImpl::SetTokenTextColor(const Color& color)
 919 {
 920         ClearLastResult();
 921
 922         _TokenEdit* pTokenEdit = dynamic_cast <_TokenEdit*>(__pExpandableEditArea);
 923         SysTryReturnResult(NID_UI_CTRL, pTokenEdit != null, E_UNSUPPORTED_OPERATION,
 924                                             "ExpandableEditArea of style EXPANDABLE_EDIT_AREA_NORMAL does not support this operation.");
 925
 926         Variant var(color);
 927
 928         return pTokenEdit->SetPropertyTokenTextColor(var);
 929 }
 930
 931 result
 932 _ExpandableEditAreaImpl::SetSelectedTokenTextColor(const Color& color)
 933 {
 934         ClearLastResult();
 935
 936         _TokenEdit* pTokenEdit = dynamic_cast <_TokenEdit*>(__pExpandableEditArea);
 937         SysTryReturnResult(NID_UI_CTRL, pTokenEdit != null, E_UNSUPPORTED_OPERATION,
 938                                             "ExpandableEditArea of style EXPANDABLE_EDIT_AREA_NORMAL does not support this operation.");
 939
 940         return pTokenEdit->SetSelectedTokenTextColor(color);
 941 }
 942
 943 result
 944 _ExpandableEditAreaImpl::SetCurrentLanguage(LanguageCode languageCode)
 945 {
 946         ClearLastResult();
 947
 948         return __pExpandableEditArea->SetCurrentLanguage(languageCode);
 949 }
 950
 951 result
 952 _ExpandableEditAreaImpl::GetCurrentLanguage(LanguageCode& language) const
 953 {
 954         ClearLastResult();
 955
 956         return __pExpandableEditArea->GetCurrentLanguage(language);
 957 }
 958
 959 void
 960 _ExpandableEditAreaImpl::SetKeypadEnabled(bool enable)
 961 {
 962         ClearLastResult();
 963
 964         __pExpandableEditArea->SetKeypadEnabled(enable);
 965 }
 966
 967 bool
 968 _ExpandableEditAreaImpl::IsKeypadEnabled(void) const
 969 {
 970         ClearLastResult();
 971
 972         return __pExpandableEditArea->IsKeypadEnabled();
 973 }
 974
 975 result
 976 _ExpandableEditAreaImpl::ShowKeypad(void)
 977 {
 978         ClearLastResult();
 979
 980         return __pExpandableEditArea->ShowKeypad();
 981 }
 982
 983 int
 984 _ExpandableEditAreaImpl::GetTextLineCount(void) const
 985 {
 986         ClearLastResult();
 987
 988         return __pExpandableEditArea->GetTextLineCount();
 989 }
 990
 991 result
 992 _ExpandableEditAreaImpl::GetBlockRange(int& start, int& end) const
 993 {
 994         ClearLastResult();
 995
 996         __pExpandableEditArea->GetBlockRange(start, end);
 997
 998         if (!((start == 0) && (end == 0)))
 999         {
1000                 end -= 1;
1001         }
1002
1003         return E_SUCCESS;
1004 }
1005
1006 result
1007 _ExpandableEditAreaImpl::ReleaseBlock(void)
1008 {
1009         ClearLastResult();
1010
1011         return __pExpandableEditArea->ReleaseTextBlock();
1012 }
1013
1014 result
1015 _ExpandableEditAreaImpl::RemoveTextBlock(void)
1016 {
1017         ClearLastResult();
1018
1019         return __pExpandableEditArea->RemoveTextBlock();
1020 }
1021
1022 result
1023 _ExpandableEditAreaImpl::SetBlockRange(int start, int end)
1024 {
1025         ClearLastResult();
1026
1027         int tempTextLength = __pExpandableEditArea->GetTextLength();
1028         SysTryReturnResult(NID_UI_CTRL, ((start > -1) && (end > -1) && (end >= start) && (end < tempTextLength)), E_OUT_OF_RANGE,
1029                                             "start (%d) and end (%d) is out of range.", start, end);
1030
1031         return __pExpandableEditArea->SetBlockRange(start, end + 1);
1032 }
1033
1034 result
1035 _ExpandableEditAreaImpl::OnBoundsChanged(const Rectangle& oldRect, const Rectangle& newRect)
1036 {
1037         ClearLastResult();
1038
1039         return E_SUCCESS;
1040 }
1041
1042 void
1043 _ExpandableEditAreaImpl::SetMaxLineCount(int maxLineCount)
1044 {
1045         ClearLastResult();
1046
1047         __pExpandableEditArea->SetMaxLineCount(maxLineCount);
1048 }
1049
1050 int
1051 _ExpandableEditAreaImpl::GetMaxLineCount(void) const
1052 {
1053         ClearLastResult();
1054
1055         return __pExpandableEditArea->GetMaxLineCount();
1056 }
1057
1058 String
1059 _ExpandableEditAreaImpl::GetTitleText(void) const
1060 {
1061         ClearLastResult();
1062
1063         return __pExpandableEditArea->GetTitleText();
1064 }
1065
1066 result
1067 _ExpandableEditAreaImpl::SetTitleText(const String& title)
1068 {
1069         ClearLastResult();
1070
1071         SysTryReturnResult(NID_UI_CTRL, (__pExpandableEditArea->GetEditStyle() & (EDIT_STYLE_TITLE_LEFT | EDIT_STYLE_TITLE_TOP)),
1072                                             E_UNSUPPORTED_OPERATION, "The current title style cannot support this function.\n");
1073
1074         return __pExpandableEditArea->SetTitleText(title);
1075 }
1076
1077 int
1078 _ExpandableEditAreaImpl::GetLimitLength(void) const
1079 {
1080         ClearLastResult();
1081
1082         return __pExpandableEditArea->GetTextLimitLength();
1083 }
1084
1085 result
1086 _ExpandableEditAreaImpl::SetLimitLength(int limitLength)
1087 {
1088         ClearLastResult();
1089
1090         return __pExpandableEditArea->SetLimitLength(limitLength);
1091 }
1092
1093 result
1094 _ExpandableEditAreaImpl::SetAutoResizingEnabled(bool enable)
1095 {
1096         ClearLastResult();
1097
1098         Variant var(enable);
1099
1100         return __pExpandableEditArea->SetPropertyAutoResizingEnabled(var);
1101 }
1102
1103 bool
1104 _ExpandableEditAreaImpl::IsAutoResizingEnabled(void) const
1105 {
1106         ClearLastResult();
1107
1108         Variant var = __pExpandableEditArea->GetPropertyAutoResizingEnabled();
1109
1110         return var.ToBool();
1111 }
1112
1113 void
1114 _ExpandableEditAreaImpl::SetAutoShrinkModeEnabled(bool enable)
1115 {
1116         ClearLastResult();
1117
1118         __pExpandableEditArea->SetAutoShrinkModeEnabled(enable);
1119 }
1120
1121 bool
1122 _ExpandableEditAreaImpl::IsAutoShrinkModeEnabled(void) const
1123 {
1124         ClearLastResult();
1125
1126         return __pExpandableEditArea->IsAutoShrinkModeEnabled();
1127 }
1128
1129 ITokenFilter*
1130 _ExpandableEditAreaImpl::GetTokenFilter(void) const
1131 {
1132         ClearLastResult();
1133
1134         _TokenEdit* pTokenEdit = dynamic_cast <_TokenEdit*>(__pExpandableEditArea);
1135         SysTryReturn(NID_UI_CTRL, pTokenEdit != null, null, E_UNSUPPORTED_OPERATION,
1136                                 "[E_UNSUPPORTED_OPERATION] ExpandableEditArea of style EXPANDABLE_EDIT_AREA_NORMAL does not support this operation.");
1137
1138         return __pTokenFilter;
1139 }
1140
1141 result
1142 _ExpandableEditAreaImpl::SetTokenFilter(const ITokenFilter* pFilter)
1143 {
1144         ClearLastResult();
1145
1146         _TokenEdit* pTokenEdit = dynamic_cast <_TokenEdit*>(__pExpandableEditArea);
1147         SysTryReturnResult(NID_UI_CTRL, pTokenEdit != null, E_UNSUPPORTED_OPERATION,
1148                                             "ExpandableEditArea of style EXPANDABLE_EDIT_AREA_NORMAL does not support this operation.");
1149
1150         __pTokenFilter = const_cast <ITokenFilter*>(pFilter);
1151
1152         return pTokenEdit->SetTokenFilter(this);
1153 }
1154
1155 result
1156 _ExpandableEditAreaImpl::AppendToken(const String& token)
1157 {
1158         ClearLastResult();
1159
1160         _TokenEdit* pTokenEdit = dynamic_cast <_TokenEdit*>(__pExpandableEditArea);
1161         SysTryReturnResult(NID_UI_CTRL, pTokenEdit != null, E_UNSUPPORTED_OPERATION,
1162                                            "ExpandableEditArea of style EXPANDABLE_EDIT_AREA_NORMAL does not support this operation.");
1163
1164         return pTokenEdit->AppendToken(token);
1165 }
1166
1167 result
1168 _ExpandableEditAreaImpl::InsertTokenAt(int index, const String& token)
1169 {
1170         ClearLastResult();
1171
1172         _TokenEdit* pTokenEdit = dynamic_cast <_TokenEdit*>(__pExpandableEditArea);
1173         SysTryReturnResult(NID_UI_CTRL, pTokenEdit != null, E_UNSUPPORTED_OPERATION,
1174                                             "ExpandableEditArea of style EXPANDABLE_EDIT_AREA_NORMAL does not support this operation.");
1175
1176         return pTokenEdit->InsertTokenAt(index, token);
1177 }
1178
1179 String
1180 _ExpandableEditAreaImpl::GetTokenAt(int index) const
1181 {
1182         ClearLastResult();
1183
1184         _TokenEdit* pTokenEdit = dynamic_cast <_TokenEdit*>(__pExpandableEditArea);
1185         SysTryReturn(NID_UI_CTRL, pTokenEdit != null, String(), E_UNSUPPORTED_OPERATION,
1186                                   "[E_UNSUPPORTED_OPERATION] ExpandableEditArea of style EXPANDABLE_EDIT_AREA_NORMAL does not support this operation.");
1187
1188         return pTokenEdit->GetTokenAt(index);
1189 }
1190
1191 int
1192 _ExpandableEditAreaImpl::GetTokenCount(void) const
1193 {
1194         ClearLastResult();
1195
1196         _TokenEdit* pTokenEdit = dynamic_cast <_TokenEdit*>(__pExpandableEditArea);
1197         SysTryReturn(NID_UI_CTRL, pTokenEdit != null, -1, E_UNSUPPORTED_OPERATION,
1198                                  "[E_UNSUPPORTED_OPERATION] ExpandableEditArea of style EXPANDABLE_EDIT_AREA_NORMAL does not support this operation.");
1199
1200         return pTokenEdit->GetTokenCount();
1201 }
1202
1203 int
1204 _ExpandableEditAreaImpl::GetSelectedTokenIndex(void) const
1205 {
1206         ClearLastResult();
1207
1208         _TokenEdit* pTokenEdit = dynamic_cast <_TokenEdit*>(__pExpandableEditArea);
1209         SysTryReturn(NID_UI_CTRL, pTokenEdit != null, -1, E_UNSUPPORTED_OPERATION,
1210                                  "[E_UNSUPPORTED_OPERATION] ExpandableEditArea of style EXPANDABLE_EDIT_AREA_NORMAL does not support this operation.");
1211
1212         return pTokenEdit->GetSelectedTokenIndex();
1213 }
1214
1215 bool
1216 _ExpandableEditAreaImpl::IsTokenEditModeEnabled(void) const
1217 {
1218         ClearLastResult();
1219
1220         _TokenEdit* pTokenEdit = dynamic_cast <_TokenEdit*>(__pExpandableEditArea);
1221         SysTryReturn(NID_UI_CTRL, pTokenEdit != null, false, E_UNSUPPORTED_OPERATION,
1222                                  "[E_UNSUPPORTED_OPERATION] ExpandableEditArea of style EXPANDABLE_EDIT_AREA_NORMAL does not support this operation.");
1223
1224         Variant var = pTokenEdit->GetPropertyTokenEditModeEnabled();
1225
1226         return var.ToBool();
1227 }
1228
1229 result
1230 _ExpandableEditAreaImpl::RemoveTokenAt(int index)
1231 {
1232         ClearLastResult();
1233
1234         _TokenEdit* pTokenEdit = dynamic_cast <_TokenEdit*>(__pExpandableEditArea);
1235         SysTryReturnResult(NID_UI_CTRL, pTokenEdit != null, E_UNSUPPORTED_OPERATION,
1236                                             "ExpandableEditArea of style EXPANDABLE_EDIT_AREA_NORMAL does not support this operation.");
1237
1238         return pTokenEdit->RemoveTokenAt(index);
1239 }
1240
1241 result
1242 _ExpandableEditAreaImpl::SetTokenSelected(int index, bool selected)
1243 {
1244         ClearLastResult();
1245
1246         _TokenEdit* pTokenEdit = dynamic_cast <_TokenEdit*>(__pExpandableEditArea);
1247         SysTryReturnResult(NID_UI_CTRL, pTokenEdit != null, E_UNSUPPORTED_OPERATION,
1248                                             "ExpandableEditArea of style EXPANDABLE_EDIT_AREA_NORMAL does not support this operation.");
1249
1250         return pTokenEdit->SetTokenSelected(index, selected);
1251 }
1252
1253 result
1254 _ExpandableEditAreaImpl::SetTokenEditModeEnabled(bool enable)
1255 {
1256         ClearLastResult();
1257
1258         _TokenEdit* pTokenEdit = dynamic_cast <_TokenEdit*>(__pExpandableEditArea);
1259         SysTryReturnResult(NID_UI_CTRL, pTokenEdit != null, E_UNSUPPORTED_OPERATION,
1260                                             "ExpandableEditArea of style EXPANDABLE_EDIT_AREA_NORMAL does not support this operation.");
1261
1262         Variant var(enable);
1263         return pTokenEdit->SetPropertyTokenEditModeEnabled(var);
1264 }
1265
1266 void
1267 _ExpandableEditAreaImpl::OnTextValueChanged(const _Control& source)
1268 {
1269         if (__pPublicTextEvent != null)
1270         {
1271                 IEventArg* pEventArg = _PublicTextEvent::CreateTextEventArgN(TEXT_EVENT_CHANGED);
1272                 result r = GetLastResult();
1273                 SysTryReturnVoidResult(NID_UI_CTRL, pEventArg != null, r, "[%s] Propagating.", GetErrorMessage(r));
1274
1275                 __pPublicTextEvent->Fire(*pEventArg);
1276         }
1277 }
1278
1279 void
1280 _ExpandableEditAreaImpl::OnTextValueChangeCanceled(const _Control& source)
1281 {
1282         if (__pPublicTextEvent != null)
1283         {
1284                 IEventArg* pEventArg = _PublicTextEvent::CreateTextEventArgN(TEXT_EVENT_CANCELED);
1285                 result r = GetLastResult();
1286                 SysTryReturnVoidResult(NID_UI_CTRL, pEventArg != null, r, "[%s] Propagating.", GetErrorMessage(r));
1287
1288                 __pPublicTextEvent->Fire(*pEventArg);
1289         }
1290 }
1291
1292 void
1293 _ExpandableEditAreaImpl::OnExpandableEditAreaLineAdded(const _Control& source, int newLineCount)
1294 {
1295         if (__pPublicExpandableEditAreaEvent)
1296         {
1297                 IEventArg* pEventArg = _PublicExpandableEditAreaEvent::CreateExpandableEditAreaEventArgN(
1298                         EXPANDABLE_EDITAREA_EVENT_ADDED);
1299                 result r = GetLastResult();
1300                 SysTryReturnVoidResult(NID_UI_CTRL, pEventArg != null, r, "[%s] Propagating.", GetErrorMessage(r));
1301
1302                 __pPublicExpandableEditAreaEvent->Fire(*pEventArg);
1303         }
1304 }
1305
1306 void
1307 _ExpandableEditAreaImpl::OnExpandableEditAreaLineRemoved(const _Control& source, int newLineCount)
1308 {
1309         if (__pPublicExpandableEditAreaEvent)
1310         {
1311                 IEventArg* pEventArg = _PublicExpandableEditAreaEvent::CreateExpandableEditAreaEventArgN(
1312                         EXPANDABLE_EDITAREA_EVENT_REMOVED);
1313                 result r = GetLastResult();
1314                 SysTryReturnVoidResult(NID_UI_CTRL, pEventArg != null, r, "[%s] Propagating.", GetErrorMessage(r));
1315
1316                 __pPublicExpandableEditAreaEvent->Fire(*pEventArg);
1317         }
1318 }
1319
1320 void
1321 _ExpandableEditAreaImpl::OnTextBlockSelected(_Control& source, int start, int end)
1322 {
1323         if (__pPublicTextBlockEvent != null)
1324         {
1325                 IEventArg* pTextBlockEventArg = _PublicTextBlockEvent::CreateTextBlockEventArgN(start, end);
1326                 result r = GetLastResult();
1327                 SysTryReturnVoidResult(NID_UI_CTRL, pTextBlockEventArg != null, r, "[%s] Propagating.", GetErrorMessage(r));
1328
1329                 __pPublicTextBlockEvent->Fire(*pTextBlockEventArg);
1330         }
1331 }
1332
1333 void
1334 _ExpandableEditAreaImpl::OnKeypadWillOpen(void)
1335 {
1336         if (__pPublicKeypadEvent)
1337         {
1338                 IEventArg* pKeypadEventArg = _PublicKeypadEvent::CreateKeypadEventArgN(
1339                         GetPublic(), KEYPAD_ACTION_ENTER, KEYPAD_EVENT_STATUS_CREATED);
1340                 result r = GetLastResult();
1341                 SysTryReturnVoidResult(NID_UI_CTRL, pKeypadEventArg != null, r, "[%s] Propagating.", GetErrorMessage(r));
1342
1343                 __pPublicKeypadEvent->Fire(*pKeypadEventArg);
1344         }
1345 }
1346
1347 void
1348 _ExpandableEditAreaImpl::OnKeypadOpened(void)
1349 {
1350         if (__pPublicKeypadEvent)
1351         {
1352                 IEventArg* pKeypadEventArg = _PublicKeypadEvent::CreateKeypadEventArgN(
1353                         GetPublic(), KEYPAD_ACTION_ENTER, KEYPAD_EVENT_STATUS_OPEN);
1354                 result r = GetLastResult();
1355                 SysTryReturnVoidResult(NID_UI_CTRL, pKeypadEventArg != null, r, "[%s] Propagating.", GetErrorMessage(r));
1356
1357                 __pPublicKeypadEvent->Fire(*pKeypadEventArg);
1358         }
1359 }
1360
1361 void
1362 _ExpandableEditAreaImpl::OnKeypadClosed(void)
1363 {
1364         if (__pPublicKeypadEvent)
1365         {
1366                 IEventArg* pKeypadEventArg = _PublicKeypadEvent::CreateKeypadEventArgN(
1367                         GetPublic(), KEYPAD_ACTION_ENTER, KEYPAD_EVENT_STATUS_CLOSE);
1368                 result r = GetLastResult();
1369                 SysTryReturnVoidResult(NID_UI_CTRL, pKeypadEventArg != null, r, "[%s] Propagating.", GetErrorMessage(r));
1370
1371                 __pPublicKeypadEvent->Fire(*pKeypadEventArg);
1372         }
1373 }
1374
1375 void
1376 _ExpandableEditAreaImpl::OnKeypadBoundsChanged(void)
1377 {
1378         if (__pPublicKeypadEvent)
1379         {
1380                 IEventArg* pKeypadEventArg = _PublicKeypadEvent::CreateKeypadEventArgN(
1381                         GetPublic(), KEYPAD_ACTION_ENTER, KEYPAD_EVENT_STATUS_BOUNDS_CHANGED);
1382                 result r = GetLastResult();
1383                 SysTryReturnVoidResult(NID_UI_CTRL, pKeypadEventArg != null, r, "[%s] Propagating.", GetErrorMessage(r));
1384
1385                 __pPublicKeypadEvent->Fire(*pKeypadEventArg);
1386         }
1387 }
1388
1389 void
1390 _ExpandableEditAreaImpl::OnLanguageChanged(LanguageCode oldLanguage, LanguageCode newLanguage)
1391 {
1392         if (__pPublicLanguageEvent)
1393         {
1394                 IEventArg* pKLanguageEventArg = _PublicLanguageEvent::CreateLanguageEventArgN(GetPublic(), oldLanguage, newLanguage);
1395                 result r = GetLastResult();
1396                 SysTryReturnVoidResult(NID_UI_CTRL, pKLanguageEventArg, r, "[%s] Propagating.", GetErrorMessage(r));
1397
1398                 __pPublicLanguageEvent->Fire(*pKLanguageEventArg);
1399         }
1400         else
1401         {
1402                 SysLog(NID_UI_CTRL, "Event is not created.");
1403         }
1404 }
1405
1406 void
1407 _ExpandableEditAreaImpl::OnKeypadActionPerformed(CoreKeypadAction keypadAction)
1408 {
1409         if (__pPublicKeypadEvent)
1410         {
1411                 KeypadAction onKeypadAction = KEYPAD_ACTION_ENTER;
1412                 switch (keypadAction)
1413                 {
1414                 case CORE_KEYPAD_ACTION_ENTER:
1415                         onKeypadAction = KEYPAD_ACTION_ENTER;
1416                         break;
1417
1418                 case CORE_KEYPAD_ACTION_GO:
1419                         onKeypadAction = KEYPAD_ACTION_GO;
1420                         break;
1421
1422                 case CORE_KEYPAD_ACTION_NEXT:
1423                         onKeypadAction = KEYPAD_ACTION_NEXT;
1424                         break;
1425
1426                 case CORE_KEYPAD_ACTION_SEND:
1427                         onKeypadAction = KEYPAD_ACTION_SEND;
1428                         break;
1429
1430                 case CORE_KEYPAD_ACTION_SEARCH:
1431                         onKeypadAction = KEYPAD_ACTION_SEARCH;
1432                         break;
1433
1434                 case CORE_KEYPAD_ACTION_LOGIN:
1435                         onKeypadAction = KEYPAD_ACTION_LOGIN;
1436                         break;
1437
1438                 case CORE_KEYPAD_ACTION_SIGN_IN:
1439                         onKeypadAction = KEYPAD_ACTION_SIGN_IN;
1440                         break;
1441
1442                 case CORE_KEYPAD_ACTION_JOIN:
1443                         onKeypadAction = KEYPAD_ACTION_JOIN;
1444                         break;
1445
1446                 case CORE_KEYPAD_ACTION_DONE:
1447                         onKeypadAction = KEYPAD_ACTION_DONE;
1448                         break;
1449
1450                 default:
1451                         break;
1452                 }
1453
1454                 IEventArg* pKeypadEventArg = _PublicKeypadEvent::CreateKeypadEventArgN(
1455                         GetPublic(), onKeypadAction, KEYPAD_EVENT_STATUS_ENTERACTION);
1456                 result r = GetLastResult();
1457                 SysTryReturnVoidResult(NID_UI_CTRL, pKeypadEventArg != null, r, "[%s] Propagating.", GetErrorMessage(r));
1458
1459                 __pPublicKeypadEvent->Fire(*pKeypadEventArg);
1460         }
1461 }
1462
1463 bool
1464 _ExpandableEditAreaImpl::ReplaceToken(const String& token, String& replacement)
1465 {
1466         bool enable = false;
1467         if (__pTokenFilter)
1468         {
1469                 enable = __pTokenFilter->ReplaceToken(token, replacement);
1470         }
1471
1472         return enable;
1473 }
1474
1475
1476 class _ExpandableEditAreaMaker
1477         : public _UiBuilderControlMaker
1478 {
1479 public:
1480         _ExpandableEditAreaMaker(_UiBuilder* uibuilder)
1481                 : _UiBuilderControlMaker(uibuilder){};
1482         virtual ~_ExpandableEditAreaMaker(){};
1483         static _UiBuilderControlMaker* GetInstance(_UiBuilder* uibuilder)
1484         {
1485                 _ExpandableEditAreaMaker* pExpandableEditAreaMaker = new (std::nothrow) _ExpandableEditAreaMaker(uibuilder);
1486                 return pExpandableEditAreaMaker;
1487         };
1488
1489 protected:
1490         virtual Control* Make(_UiBuilderControl* pControl)
1491         {
1492                 result r = E_SUCCESS;
1493
1494                 Rectangle rect;
1495                 ExpandableEditArea* pExpandableEditArea = null;
1496                 _UiBuilderControlLayout* pControlProperty = null;
1497                 ExpandableEditAreaStyle style = EXPANDABLE_EDIT_AREA_STYLE_NORMAL;
1498                 ExpandableEditAreaTitleStyle titleStyle = EXPANDABLE_EDIT_AREA_TITLE_STYLE_NONE;
1499                 bool lowerCaseMode = false;
1500                 KeypadAction keypadAction = KEYPAD_ACTION_ENTER;
1501                 KeypadStyle keypadStyle = KEYPAD_STYLE_NORMAL;
1502                 int maxLines = 10;
1503                 String guideText;
1504                 int verticalMarin = 0;
1505                 int horizontalMargin = 0;
1506                 String text;
1507                 int textSize = 6;
1508                 String titleText;
1509                 int limitLength = 0;
1510                 int opacity = 100;
1511                 Color color;
1512                 bool autoResizing = false;
1513                 bool autoShrink = false;
1514                 String elementString;
1515
1516                 GetProperty(pControl, &pControlProperty);
1517                 if (pControlProperty == null)
1518                 {
1519                         return null;
1520                 }
1521
1522                 pExpandableEditArea = new (std::nothrow) ExpandableEditArea();
1523                 if (pExpandableEditArea == null)
1524                 {
1525                         return null;
1526                 }
1527
1528                 rect = pControlProperty->GetRect();
1529
1530                 if (pControl->GetElement(L"style", elementString))
1531                 {
1532                         if (elementString.Equals(L"EXPANDABLE_EDIT_AREA_STYLE_NORMAL", false))
1533                         {
1534                                 style = EXPANDABLE_EDIT_AREA_STYLE_NORMAL;
1535                         }
1536                         else
1537                         {
1538                                 style = EXPANDABLE_EDIT_AREA_STYLE_TOKEN;
1539                         }
1540                 }
1541
1542                 if (pControl->GetElement(L"titleStyle", elementString))
1543                 {
1544                         if (elementString.Equals(L"EXPANDABLE_EDIT_AREA_TITLE_STYLE_NONE", false))
1545                         {
1546                                 titleStyle = EXPANDABLE_EDIT_AREA_TITLE_STYLE_NONE;
1547                         }
1548                         else if (elementString.Equals(L"EXPANDABLE_EDIT_AREA_TITLE_STYLE_TOP", false))
1549                         {
1550                                 titleStyle = EXPANDABLE_EDIT_AREA_TITLE_STYLE_TOP;
1551                         }
1552                         else
1553                         {
1554                                 titleStyle = EXPANDABLE_EDIT_AREA_TITLE_STYLE_INNER;
1555                         }
1556                 }
1557
1558                 if (pControl->GetElement(L"maxLines", elementString))
1559                 {
1560                         Base::Integer::Parse(elementString, maxLines);
1561                 }
1562
1563                 r = pExpandableEditArea->Construct(rect, style, titleStyle, maxLines);
1564                 if (r != E_SUCCESS)
1565                 {
1566                         return null;
1567                 }
1568
1569                 if (pControl->GetElement(L"text", elementString))
1570                 {
1571                         r = pExpandableEditArea->SetText(elementString);
1572                 }
1573
1574                 if (pControl->GetElement(L"guideText", elementString))
1575                 {
1576                         r = pExpandableEditArea->SetGuideText(elementString);
1577                 }
1578
1579                 if (pControl->GetElement(L"keypadStyle", elementString))
1580                 {
1581                         if (elementString.Equals(L"KEYPAD_STYLE_NORMAL", false))
1582                         {
1583                                 keypadStyle = KEYPAD_STYLE_NORMAL;
1584                         }
1585                         else if (elementString.Equals(L"KEYPAD_STYLE_PASSWORD", false))
1586                         {
1587                                 keypadStyle = KEYPAD_STYLE_PASSWORD;
1588                         }
1589                         else if (elementString.Equals(L"KEYPAD_STYLE_EMAIL", false))
1590                         {
1591                                 keypadStyle = KEYPAD_STYLE_EMAIL;
1592                         }
1593                         else if (elementString.Equals(L"KEYPAD_STYLE_URL", false))
1594                         {
1595                                 keypadStyle = KEYPAD_STYLE_URL;
1596                         }
1597                         else if (elementString.Equals(L"KEYPAD_STYLE_NUMBER", false))
1598                         {
1599                                 keypadStyle = KEYPAD_STYLE_NUMBER;
1600                         }
1601                         else if (elementString.Equals(L"KEYPAD_STYLE_PHONE_NUMBER", false))
1602                         {
1603                                 keypadStyle = KEYPAD_STYLE_PHONE_NUMBER;
1604                         }
1605                         else if (elementString.Equals(L"KEYPAD_STYLE_IP_V4", false))
1606                         {
1607                                 keypadStyle = KEYPAD_STYLE_IP_V4;
1608                         }
1609
1610                         r = pExpandableEditArea->SetKeypadStyle(keypadStyle);
1611                 }
1612
1613                 if (pControl->GetElement(L"keypadAction", elementString))
1614                 {
1615                         if (elementString.Equals(L"KEYPAD_ACTION_ENTER", false))
1616                         {
1617                                 keypadAction = KEYPAD_ACTION_ENTER;
1618                         }
1619                         else if (elementString.Equals(L"KEYPAD_ACTION_GO", false))
1620                         {
1621                                 keypadAction = KEYPAD_ACTION_GO;
1622                         }
1623                         else if (elementString.Equals(L"KEYPAD_ACTION_NEXT", false))
1624                         {
1625                                 keypadAction = KEYPAD_ACTION_NEXT;
1626                         }
1627                         else if (elementString.Equals(L"KEYPAD_ACTION_SEND", false))
1628                         {
1629                                 keypadAction = KEYPAD_ACTION_SEND;
1630                         }
1631                         else if (elementString.Equals(L"KEYPAD_ACTION_SEARCH", false))
1632                         {
1633                                 keypadAction = KEYPAD_ACTION_SEARCH;
1634                         }
1635                         else if (elementString.Equals(L"KEYPAD_ACTION_LOGIN", false))
1636                         {
1637                                 keypadAction = KEYPAD_ACTION_LOGIN;
1638                         }
1639                         else if (elementString.Equals(L"KEYPAD_ACTION_SIGN_IN", false))
1640                         {
1641                                 keypadAction = KEYPAD_ACTION_SIGN_IN;
1642                         }
1643                         else if (elementString.Equals(L"KEYPAD_ACTION_JOIN", false))
1644                         {
1645                                 keypadAction = KEYPAD_ACTION_JOIN;
1646                         }
1647                         else if (elementString.Equals(L"KEYPAD_ACTION_DONE", false))
1648                         {
1649                                 keypadAction = KEYPAD_ACTION_DONE;
1650                         }
1651
1652                         r = pExpandableEditArea->SetKeypadAction(keypadAction);
1653                 }
1654
1655                 if (pControl->GetElement(L"lowerCaseMode", elementString))
1656                 {
1657                         if (elementString.Equals(L"true", false))
1658                         {
1659                                 lowerCaseMode = true;
1660                         }
1661                         else
1662                         {
1663                                 lowerCaseMode = false;
1664                         }
1665
1666                         r = pExpandableEditArea->SetLowerCaseModeEnabled(lowerCaseMode);
1667                 }
1668
1669                 if (pControl->GetElement(L"textSize", elementString))
1670                 {
1671                         Base::Integer::Parse(elementString, textSize);
1672                         _ICoordinateSystemTransformer* pTransform = GetTransformer();
1673                         if (pTransform)
1674                         {
1675                                 textSize = pTransform->Transform(textSize);
1676                         }
1677                         r = pExpandableEditArea->SetTextSize(textSize);
1678                 }
1679
1680                 if (pControl->GetElement(L"verticalMargin", elementString))
1681                 {
1682                         Base::Integer::Parse(elementString, verticalMarin);
1683                         r = pExpandableEditArea->SetMargin(EDIT_MARGIN_TYPE_VERTICAL, verticalMarin);
1684                 }
1685
1686                 if (pControl->GetElement(L"horizontalMargin", elementString))
1687                 {
1688                         Base::Integer::Parse(elementString, horizontalMargin);
1689                         r = pExpandableEditArea->SetMargin(EDIT_MARGIN_TYPE_HORIZONTAL, horizontalMargin);
1690                 }
1691
1692                 if (pControl->GetElement(L"limitLength", elementString))
1693                 {
1694                         Base::Integer::Parse(elementString, limitLength);
1695                         r = pExpandableEditArea->SetLimitLength(limitLength);
1696                 }
1697
1698                 if (pControl->GetElement(L"titleText", elementString))
1699                 {
1700                         r = pExpandableEditArea->SetTitleText(elementString);
1701                 }
1702
1703                 if (pControl->GetElement(L"normalBGBitmapPath", elementString))
1704                 {
1705                         Bitmap* pNormalBGBitmap = null;
1706                         pNormalBGBitmap = LoadBitmapN(elementString);
1707                         if (pNormalBGBitmap != null)
1708                         {
1709                                 r = pExpandableEditArea->SetBackgroundBitmap(EDIT_STATUS_NORMAL, *pNormalBGBitmap);
1710                                 delete pNormalBGBitmap;
1711                         }
1712                 }
1713
1714                 if (pControl->GetElement(L"disabledBGBitmapPath", elementString))
1715                 {
1716                         Bitmap* pNormalBGBitmap = null;
1717                         pNormalBGBitmap = LoadBitmapN(elementString);
1718                         if (pNormalBGBitmap != null)
1719                         {
1720                                 r = pExpandableEditArea->SetBackgroundBitmap(EDIT_STATUS_DISABLED, *pNormalBGBitmap);
1721                                 delete pNormalBGBitmap;
1722                         }
1723                 }
1724
1725                 if (pControl->GetElement(L"highlightedBGBitmapPath", elementString))
1726                 {
1727                         Bitmap* pNormalBGBitmap = null;
1728                         pNormalBGBitmap = LoadBitmapN(elementString);
1729                         if (pNormalBGBitmap != null)
1730                         {
1731                                 r = pExpandableEditArea->SetBackgroundBitmap(EDIT_STATUS_HIGHLIGHTED, *pNormalBGBitmap);
1732                                 delete pNormalBGBitmap;
1733                         }
1734                 }
1735
1736                 if (pControl->GetElement(L"pressedBGBitmapPath", elementString))
1737                 {
1738                         Bitmap* pNormalBGBitmap = null;
1739                         pNormalBGBitmap = LoadBitmapN(elementString);
1740                         if (pNormalBGBitmap != null)
1741                         {
1742                                 r = pExpandableEditArea->SetBackgroundBitmap(EDIT_STATUS_PRESSED, *pNormalBGBitmap);
1743                                 delete pNormalBGBitmap;
1744                         }
1745                 }
1746
1747                 if (pControl->GetElement(L"normalColorOpacity", elementString))
1748                 {
1749                         Base::Integer::Parse(elementString, opacity);
1750                 }
1751                 if (pControl->GetElement(L"normalColor", elementString))
1752                 {
1753                         ConvertStringToColor32(elementString, opacity, color);
1754                         r = pExpandableEditArea->SetColor(EDIT_STATUS_NORMAL, color);
1755                 }
1756
1757                 if (pControl->GetElement(L"disabledColorOpacity", elementString))
1758                 {
1759                         Base::Integer::Parse(elementString, opacity);
1760                 }
1761                 if (pControl->GetElement(L"disabledColor", elementString))
1762                 {
1763                         ConvertStringToColor32(elementString, opacity, color);
1764                         r = pExpandableEditArea->SetColor(EDIT_STATUS_DISABLED, color);
1765                 }
1766
1767                 if (pControl->GetElement(L"highlightedColorOpacity", elementString))
1768                 {
1769                         Base::Integer::Parse(elementString, opacity);
1770                 }
1771                 if (pControl->GetElement(L"highlightedColor", elementString))
1772                 {
1773                         ConvertStringToColor32(elementString, opacity, color);
1774                         r = pExpandableEditArea->SetColor(EDIT_STATUS_HIGHLIGHTED, color);
1775                 }
1776
1777                 if (pControl->GetElement(L"pressedColorOpacity", elementString))
1778                 {
1779                         Base::Integer::Parse(elementString, opacity);
1780                 }
1781                 if (pControl->GetElement(L"pressedColor", elementString))
1782                 {
1783                         ConvertStringToColor32(elementString, opacity, color);
1784                         r = pExpandableEditArea->SetColor(EDIT_STATUS_PRESSED, color);
1785                 }
1786
1787                 if (pControl->GetElement(L"guideTextColor", elementString))
1788                 {
1789                         opacity = 100;
1790                         ConvertStringToColor32(elementString, opacity, color);
1791                         r = pExpandableEditArea->SetGuideTextColor(color);
1792                 }
1793
1794                 if (pControl->GetElement(L"normalTitleTextColor", elementString))
1795                 {
1796                         opacity = 100;
1797                         ConvertStringToColor32(elementString, opacity, color);
1798                         r = pExpandableEditArea->SetTitleTextColor(EDIT_STATUS_NORMAL, color);
1799                 }
1800
1801                 if (pControl->GetElement(L"disabledTitleTextColor", elementString))
1802                 {
1803                         opacity = 100;
1804                         ConvertStringToColor32(elementString, opacity, color);
1805                         r = pExpandableEditArea->SetTitleTextColor(EDIT_STATUS_DISABLED, color);
1806                 }
1807
1808                 if (pControl->GetElement(L"highlightedTitleTextColor", elementString))
1809                 {
1810                         opacity = 100;
1811                         ConvertStringToColor32(elementString, opacity, color);
1812                         r = pExpandableEditArea->SetTitleTextColor(EDIT_STATUS_HIGHLIGHTED, color);
1813                 }
1814
1815                 if (pControl->GetElement(L"pressedTitleTextColor", elementString))
1816                 {
1817                         opacity = 100;
1818                         ConvertStringToColor32(elementString, opacity, color);
1819                         r = pExpandableEditArea->SetTitleTextColor(EDIT_STATUS_PRESSED, color);
1820                 }
1821
1822                 if (pControl->GetElement(L"normalTextColor", elementString))
1823                 {
1824                         opacity = 100;
1825                         ConvertStringToColor32(elementString, opacity, color);
1826                         r = pExpandableEditArea->SetTextColor(EDIT_TEXT_COLOR_NORMAL, color);
1827                 }
1828
1829                 if (pControl->GetElement(L"disabledTextColor", elementString))
1830                 {
1831                         opacity = 100;
1832                         ConvertStringToColor32(elementString, opacity, color);
1833                         r = pExpandableEditArea->SetTextColor(EDIT_TEXT_COLOR_DISABLED, color);
1834                 }
1835
1836                 if (pControl->GetElement(L"highlightedTextColor", elementString))
1837                 {
1838                         opacity = 100;
1839                         ConvertStringToColor32(elementString, opacity, color);
1840                         r = pExpandableEditArea->SetTextColor(EDIT_TEXT_COLOR_HIGHLIGHTED, color);
1841                 }
1842
1843                 if (pControl->GetElement(L"normalTokenColor", elementString))
1844                 {
1845                         opacity = 100;
1846                         ConvertStringToColor32(elementString, opacity, color);
1847                         r = pExpandableEditArea->SetTokenColor(EXPANDABLE_EDIT_AREA_TOKEN_STATUS_NORMAL, color);
1848                 }
1849
1850                 if (pControl->GetElement(L"selectedTokenColor", elementString))
1851                 {
1852                         opacity = 100;
1853                         ConvertStringToColor32(elementString, opacity, color);
1854                         r = pExpandableEditArea->SetTokenColor(EXPANDABLE_EDIT_AREA_TOKEN_STATUS_SELECTED, color);
1855                 }
1856
1857                 if (pControl->GetElement(L"tokenTextColor", elementString))
1858                 {
1859                         opacity = 100;
1860                         ConvertStringToColor32(elementString, opacity, color);
1861                         r = pExpandableEditArea->SetTokenTextColor(color);
1862                 }
1863
1864                 if (pControl->GetElement(L"autoResizing", elementString))
1865                 {
1866                         if (elementString.Equals(L"true", false))
1867                         {
1868                                 autoResizing = true;
1869                         }
1870                         else
1871                         {
1872                                 autoResizing = false;
1873                         }
1874
1875                         r = pExpandableEditArea->SetAutoResizingEnabled(autoResizing);
1876                 }
1877
1878                 if (pControl->GetElement(L"autoShrinkModeEnabled", elementString))
1879                 {
1880                         if (elementString.Equals(L"true", false))
1881                         {
1882                                 autoShrink = true;
1883                         }
1884                         else
1885                         {
1886                                 autoShrink = false;
1887                         }
1888
1889                         pExpandableEditArea->SetAutoShrinkModeEnabled(autoShrink);
1890                 }
1891
1892                 return pExpandableEditArea;
1893         }
1894 };
1895
1896 _ExpandableEditAreaRegister::_ExpandableEditAreaRegister(void)
1897 {
1898         _UiBuilderControlTableManager* pUiBuilderControlTableManager = _UiBuilderControlTableManager::GetInstance();
1899         pUiBuilderControlTableManager->RegisterControl(L"ExpandableEditArea", _ExpandableEditAreaMaker::GetInstance);
1900 }
1901 _ExpandableEditAreaRegister::~_ExpandableEditAreaRegister(void)
1902 {
1903         _UiBuilderControlTableManager* pUiBuilderControlTableManager = _UiBuilderControlTableManager::GetInstance();
1904         pUiBuilderControlTableManager->UnregisterControl(L"ExpandableEditArea");
1905 }
1906 static _ExpandableEditAreaRegister ExpandableEditAreaRegisterToUIbuilder;
1907 }}}     // Tizen::Ui::Controls