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