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