src/ui/controls/FUiCtrl_Edit.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_Edit.cpp
  20  * @brief               This is the implementation file for the _Edit class.
  21  */
  22
  23 #include <FBaseErrorDefine.h>
  24 #include <FBaseSysLog.h>
  25 #include <FGrpFont.h>
  26 #include <FGrp_BitmapImpl.h>
  27 #include <FGrp_FontImpl.h>
  28 #include "FUi_AccessibilityContainer.h"
  29 #include "FUi_AccessibilityElement.h"
  30 #include "FUi_IAccessibilityListener.h"
  31 #include "FUi_UiEventManager.h"
  32 #include "FUiAnim_VisualElement.h"
  33 #include "FUiCtrl_Edit.h"
  34 #include "FUiCtrl_EditPresenter.h"
  35 #include "FUiCtrl_ScrollPanel.h"
  36
  37 using namespace Tizen::Base;
  38 using namespace Tizen::Base::Runtime;
  39 using namespace Tizen::Base::Utility;
  40 using namespace Tizen::Graphics;
  41 using namespace Tizen::Ui;
  42 using namespace Tizen::Ui::Animations;
  43 using namespace Tizen::Locales;
  44 using namespace Tizen::Graphics::_Text;
  45 using namespace Tizen::Base::Collection;
  46
  47
  48 namespace Tizen { namespace Ui { namespace Controls
  49 {
  50
  51 class _EditInternalTouchEventListener
  52         : public _ITouchEventListener
  53         , virtual public _IUiEventListener
  54         , virtual public Tizen::Base::Runtime::IEventListener
  55 {
  56 // Operation
  57 public:
  58         _EditInternalTouchEventListener(const _Edit& edit);
  59         /**
  60         * This is the destructor for this class.
  61         */
  62         virtual ~_EditInternalTouchEventListener(void) {}
  63
  64         /**
  65          * Notifies when an entity is touch pressed.
  66          *
  67          * @param[in]   source                  The source of the event
  68          * @param[in]   currentPosition The current position
  69          * @param[in]   touchInfo               The touch event information
  70          */
  71         virtual bool OnTouchPressed(const _Control& source, const _TouchInfo& touchinfo);
  72
  73         /**
  74          * Notifies when an entity is touch released.
  75          *
  76          * @param[in]   source                  The source of the event
  77          * @param[in]   currentPosition The current position
  78          * @param[in]   touchInfo               The touch event information
  79          */
  80         virtual bool OnTouchReleased(const _Control& source, const _TouchInfo& touchinfo){return false;};
  81
  82         /**
  83          * Notifies when an entity is touch moved.
  84          *
  85          * @param[in]   source                  The source of the event
  86          * @param[in]   currentPosition The current position
  87          * @param[in]   touchInfo               The touch event information
  88          */
  89         virtual bool OnTouchMoved(const _Control& source, const _TouchInfo& touchinfo){return false;};
  90
  91         /**
  92          * Notifies when an entity is touch cancelled.
  93          *
  94          * @param[in]   source                  The source of the event
  95          * @param[in]   currentPosition The current position
  96          * @param[in]   touchInfo               The touch event information
  97          */
  98         virtual bool OnTouchCanceled(const _Control& source, const _TouchInfo& touchinfo){return false;};
  99
 100 private:
 101         _Edit* __pEdit;
 102 }; // _ITouchEventListener
 103
 104 _EditInternalTouchEventListener::_EditInternalTouchEventListener(const _Edit& edit)
 105 {
 106         __pEdit = const_cast<_Edit*>(&edit);
 107 }
 108
 109 bool
 110 _EditInternalTouchEventListener::OnTouchPressed(const _Control& source, const _TouchInfo& touchinfo)
 111 {
 112         _EditPresenter* pEditPresenter = __pEdit->GetPresenter();
 113         _Toolbar* pCommandButton = pEditPresenter->GetKeypadCommandButton();
 114         if (__pEdit == &source || pCommandButton == source.GetParent())
 115         {
 116                 return false;
 117         }
 118         else //check the state of Text Prediction & CopyPaste Popup
 119         {
 120                 if (pEditPresenter->IsCopyPastePopupVisible())
 121                 {
 122                         if (pEditPresenter->GetTextCompositionState())
 123                         {
 124                                 pEditPresenter->FinishTextComposition();
 125                         }
 126
 127                         if (pEditPresenter->IsCopyPastePopup(source))
 128                         {
 129                                 return false; // CopyPastePopup is touched
 130                         }
 131                         else
 132                         {
 133                                 pEditPresenter->InitializeCopyPasteManager();
 134                         }
 135                 }
 136         }
 137
 138         return false;
 139 }
 140
 141 IMPLEMENT_PROPERTY(_Edit);
 142
 143 _Edit::_Edit(void)
 144         : _pEditPresenter(null)
 145         , __bottomMargin(-1)
 146         , __leftMargin(-1)
 147         , __lineSpacing(-1)
 148         , __rightMargin(-1)
 149         , __textSize(-1)
 150         , __topMargin(-1)
 151         , __editStyle(EDIT_STYLE_NORMAL)
 152         , __borderRoundStyle(false)
 153         , __ellipsisPosition(ELLIPSIS_POSITION_END)
 154         , __inputStyle(INPUT_STYLE_OVERLAY)
 155         , __isConstructed(false)
 156         , __guideTextColor(Color())
 157         , __isSettingGuideTextColor(false)
 158         , __pDefaultBackgroundEffectBitmap(null)
 159         , __pGestureFlick(null)
 160         , __pGestureLongPress(null)
 161         , __pGestureTap(null)
 162         , __pEditInternalTouchEventListener(null)
 163         , __pExpandableEditAreaEvent(null)
 164         , __pKeypadEvent(null)
 165         , __pLanguageEvent(null)
 166         , __pLinkEvent(null)
 167         , __pScrollPanelEvent(null)
 168         , __pTextBlockEvent(null)
 169         , __pTextEvent(null)
 170         , __pTitleTextAccessibilityElement(null)
 171         , __pTextAccessibilityElement(null)
 172         , __pClearButtonTextAccessibilityElement(null)
 173         , __pToolbarAccessibilityElement(null)
 174         , __isAccessibilityCreated(false)
 175         , __isFullScreenKeypadEdit(false)
 176 {
 177         for (int status = 0; status < EDIT_COLOR_MAX; status++)
 178         {
 179                 __pBackgroundBitmap[status] = null;
 180         }
 181
 182         for (int status = 0; status < EDIT_COLOR_MAX; status++)
 183         {
 184                 __pDefaultBackgroundBitmap[status] = null;
 185         }
 186
 187         __blockTextColor.used = false;
 188         __blockTextColor.blockTextColor = Color();
 189 }
 190
 191 _Edit::~_Edit(void)
 192 {
 193         delete _pEditPresenter;
 194         _pEditPresenter = null;
 195
 196         for (int status = 0; status < EDIT_COLOR_MAX; status++)
 197         {
 198                 if (__pBackgroundBitmap[status])
 199                 {
 200                         delete __pBackgroundBitmap[status];
 201                         __pBackgroundBitmap[status] = null;
 202                 }
 203
 204                 if (__pDefaultBackgroundBitmap[status])
 205         {
 206                         delete __pDefaultBackgroundBitmap[status];
 207                         __pDefaultBackgroundBitmap[status] = null;
 208         }
 209         }
 210
 211         if (__pDefaultBackgroundEffectBitmap)
 212         {
 213                 delete __pDefaultBackgroundEffectBitmap;
 214                 __pDefaultBackgroundEffectBitmap = null;
 215         }
 216
 217         if (__pTextBlockEvent)
 218         {
 219                 delete __pTextBlockEvent;
 220                 __pTextBlockEvent = null;
 221         }
 222
 223         if (__pLinkEvent)
 224         {
 225                 delete __pLinkEvent;
 226                 __pLinkEvent = null;
 227         }
 228
 229         if (__pKeypadEvent)
 230         {
 231                 delete __pKeypadEvent;
 232                 __pKeypadEvent = null;
 233         }
 234
 235         if (__pScrollPanelEvent)
 236         {
 237                 delete __pScrollPanelEvent;
 238                 __pScrollPanelEvent = null;
 239         }
 240
 241         if (__pLanguageEvent)
 242         {
 243                 delete __pLanguageEvent;
 244                 __pLanguageEvent = null;
 245         }
 246
 247         if (__pGestureFlick)
 248         {
 249                 _ITouchFlickGestureEventListener* pListener = dynamic_cast<_ITouchFlickGestureEventListener*>(this);
 250                 __pGestureFlick->RemoveGestureListener(*pListener);
 251                 RemoveGestureDetector(*__pGestureFlick);
 252                 delete __pGestureFlick;
 253                 __pGestureFlick = null;
 254         }
 255
 256         if (__pGestureLongPress)
 257         {
 258                 _ITouchLongPressGestureEventListener* pListener = dynamic_cast<_ITouchLongPressGestureEventListener*>(this);
 259                 __pGestureLongPress->RemoveGestureListener(*pListener);
 260                 RemoveGestureDetector(*__pGestureLongPress);
 261                 delete __pGestureLongPress;
 262                 __pGestureLongPress = null;
 263         }
 264
 265         if (__pGestureTap)
 266         {
 267                 _ITouchTapGestureEventListener* pListener = dynamic_cast<_ITouchTapGestureEventListener*>(this);
 268                 __pGestureTap->RemoveGestureListener(*pListener);
 269                 RemoveGestureDetector(*__pGestureTap);
 270                 delete __pGestureTap;
 271                 __pGestureTap = null;
 272         }
 273
 274         if (__pEditInternalTouchEventListener)
 275         {
 276                 _UiEventManager::GetInstance()->RemoveTouchEventListener(*__pEditInternalTouchEventListener);
 277                 delete __pEditInternalTouchEventListener;
 278                 __pEditInternalTouchEventListener = null;
 279         }
 280
 281         if (__pTextEvent)
 282         {
 283                 delete __pTextEvent;
 284                 __pTextEvent = null;
 285         }
 286
 287         if (__pExpandableEditAreaEvent)
 288         {
 289                 delete __pExpandableEditAreaEvent;
 290                 __pExpandableEditAreaEvent = null;
 291         }
 292
 293         if (__pTitleTextAccessibilityElement)
 294         {
 295                 __pTitleTextAccessibilityElement->Activate(false);
 296                 __pTitleTextAccessibilityElement = null;
 297         }
 298         if (__pTextAccessibilityElement)
 299         {
 300                 __pTextAccessibilityElement->Activate(false);
 301                 __pTextAccessibilityElement = null;
 302         }
 303         if (__pClearButtonTextAccessibilityElement)
 304         {
 305                 __pClearButtonTextAccessibilityElement->Activate(false);
 306                 __pClearButtonTextAccessibilityElement = null;
 307         }
 308         if (__pToolbarAccessibilityElement)
 309         {
 310                 __pToolbarAccessibilityElement->Activate(false);
 311                 __pToolbarAccessibilityElement = null;
 312         }
 313 }
 314
 315 _Edit*
 316 _Edit::CreateEditN(void)
 317 {
 318         _EditPresenter* pPresenter = _EditPresenter::CreateInstanceN();
 319         if (pPresenter == null)
 320         {
 321                 SetLastResult(E_OUT_OF_MEMORY);
 322
 323                 return null;
 324         }
 325
 326         result r = E_SUCCESS;
 327         _VisualElement* pBaseVisualElement = null;
 328         _Edit* pEdit = new (std::nothrow) _Edit;
 329         SysTryCatch(NID_UI_CTRL, pEdit, , E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] The memory is insufficient.");
 330
 331         pBaseVisualElement = pEdit->GetVisualElement();
 332         if (pBaseVisualElement)
 333         {
 334                 r = pBaseVisualElement->SetSurfaceOpaque(false);
 335                 SysTryCatch(NID_UI_CTRL, r == E_SUCCESS, , r, "[%s] Propagating.", GetErrorMessage(r));
 336         }
 337
 338         pEdit->AcquireHandle();
 339
 340         r = pEdit->SetPresenter(*pPresenter);
 341         SysTryCatch(NID_UI_CTRL, r == E_SUCCESS, , r, "[%s] Propagating.", GetErrorMessage(r));
 342
 343         return pEdit;
 344
 345 CATCH:
 346         delete pPresenter;
 347         delete pEdit;
 348
 349         return null;
 350 }
 351
 352 result
 353 _Edit::Initialize(int editStyle, InputStyle inputStyle, int limitLength, GroupStyle groupStyle)
 354 {
 355         result r = E_SUCCESS;
 356
 357         SetEditStyle(editStyle);
 358
 359         r = LoadDefaultBackgroundBitmap(groupStyle);
 360         SysTryReturn(NID_UI_CTRL, r == E_SUCCESS, r, r, "[%s] Failed to load Bitmaps", GetErrorMessage(r));
 361
 362         InitializeColorInformation();
 363
 364         r = _pEditPresenter->Initialize(*this);
 365         SysTryReturn(NID_UI_CTRL, r == E_SUCCESS, r, r, "[%s] Failed to construct", GetErrorMessage(r));
 366
 367         r = _pEditPresenter->SetTextLimitLength(limitLength);
 368         SysTryReturn(NID_UI_CTRL, r == E_SUCCESS, r, r, "[%s] Failed to set limit length", GetErrorMessage(r));
 369
 370         __inputStyle = inputStyle;
 371         if (inputStyle == INPUT_STYLE_OVERLAY)
 372         {
 373                 if (!(editStyle & EDIT_STYLE_FLEXIBLE))
 374                 {
 375                         _pEditPresenter->SetKeypadCommandButtonVisible(true);
 376                 }
 377         }
 378
 379         _pEditPresenter->SetEditGroupStyle(groupStyle);
 380
 381         __textSize = _pEditPresenter->GetTextSize();
 382
 383         __pGestureFlick = new (std::nothrow) _TouchFlickGestureDetector;
 384         SysTryReturn(NID_UI_CTRL, __pGestureFlick, E_OUT_OF_MEMORY, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] Failed to create touch flick gesture.");
 385         r = AddGestureDetector(*__pGestureFlick);
 386         SysTryReturn(NID_UI_CTRL, r == E_SUCCESS, r, r, "[%s] Failed to add gesture listener", GetErrorMessage(r));
 387         r = __pGestureFlick->AddGestureListener(*this);
 388         SysTryReturn(NID_UI_CTRL, r == E_SUCCESS, r, r, "[%s] Failed to add gesture listener", GetErrorMessage(r));
 389
 390         __pGestureLongPress = new (std::nothrow) _TouchLongPressGestureDetector;
 391         SysTryReturn(NID_UI_CTRL, __pGestureLongPress, E_OUT_OF_MEMORY, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] Failed to create touch long press gesture.");
 392         r = AddGestureDetector(*__pGestureLongPress);
 393         SysTryReturn(NID_UI_CTRL, r == E_SUCCESS, r, r, "[%s] Failed to add gesture detector", GetErrorMessage(r));
 394         r = __pGestureLongPress->AddGestureListener(*this);
 395         SysTryReturn(NID_UI_CTRL, r == E_SUCCESS, r, r, "[%s] Failed to add gesture listener", GetErrorMessage(r));
 396
 397         __pGestureTap = new (std::nothrow) _TouchTapGestureDetector;
 398         SysTryReturn(NID_UI_CTRL, __pGestureTap, E_OUT_OF_MEMORY, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] Failed to create touch tap gesture.");
 399         r = AddGestureDetector(*__pGestureTap);
 400         SysTryReturn(NID_UI_CTRL, r == E_SUCCESS, r, r, "[%s] Failed to add gesture detector", GetErrorMessage(r));
 401         r = __pGestureTap->AddGestureListener(*this);
 402         SysTryReturn(NID_UI_CTRL, r == E_SUCCESS, r, r, "[%s] Failed to add gesture listener", GetErrorMessage(r));
 403
 404         __pEditInternalTouchEventListener = new (std::nothrow) _EditInternalTouchEventListener(*this);
 405         SysTryReturn(NID_UI_CTRL, __pEditInternalTouchEventListener, E_OUT_OF_MEMORY, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] Failed to create internal touch listener.");
 406         r = _UiEventManager::GetInstance()->AddTouchEventListener(*__pEditInternalTouchEventListener);
 407         SysTryReturn(NID_UI_CTRL, r == E_SUCCESS, r, r, "[%s] Unable to add internal event listener", GetErrorMessage(r));
 408
 409         SetTouchMoveAllowance(TOUCH_MOVE_ALLOWANCE_INSENSITIVE);
 410         __isConstructed = true;
 411
 412         return r;
 413 }
 414
 415 void
 416 _Edit::InitializeColorInformation(void)
 417 {
 418         GET_COLOR_CONFIG(EDIT::BG_NORMAL, __color[EDIT_STATUS_NORMAL].backgroundColor);
 419         GET_COLOR_CONFIG(EDIT::BG_PRESSED, __color[EDIT_STATUS_PRESSED].backgroundColor);
 420         GET_COLOR_CONFIG(EDIT::BG_HIGHLIGHTED, __color[EDIT_STATUS_HIGHLIGHTED].backgroundColor);
 421         GET_COLOR_CONFIG(EDIT::BG_DISABLED, __color[EDIT_STATUS_DISABLED].backgroundColor);
 422
 423         GET_COLOR_CONFIG(EDIT::TITLE_TEXT_NORMAL, __color[EDIT_STATUS_NORMAL].titleTextColor);
 424         GET_COLOR_CONFIG(EDIT::TITLE_TEXT_PRESSED, __color[EDIT_STATUS_PRESSED].titleTextColor);
 425         GET_COLOR_CONFIG(EDIT::TITLE_TEXT_HIGHLIGHTED, __color[EDIT_STATUS_HIGHLIGHTED].titleTextColor);
 426         GET_COLOR_CONFIG(EDIT::TITLE_TEXT_DISABLED, __color[EDIT_STATUS_DISABLED].titleTextColor);
 427
 428         GET_COLOR_CONFIG(EDIT::TEXT_NORMAL, __color[EDIT_STATUS_NORMAL].textColor);
 429         GET_COLOR_CONFIG(EDIT::TEXT_PRESSED, __color[EDIT_STATUS_PRESSED].textColor);
 430         GET_COLOR_CONFIG(EDIT::TEXT_HIGHLIGHTED, __color[EDIT_STATUS_HIGHLIGHTED].textColor);
 431         GET_COLOR_CONFIG(EDIT::TEXT_DISABLED, __color[EDIT_STATUS_DISABLED].textColor);
 432
 433         GET_COLOR_CONFIG(EDIT::GUIDE_TEXT_NORMAL, __guideTextColor);
 434
 435         memset(__cutlinkColor, 0, sizeof(EditCutlinkColor) * EDIT_LINK_TYPE_MAX);
 436         for (int i = 0; i < EDIT_LINK_TYPE_MAX; i++)
 437         {
 438                 EditCutLinkType type = (EditCutLinkType) i;
 439                 //GET_COLOR_CONFIG(EDIT::CUT_LINK_TEXT_NORMAL, __cutlinkColor[type].cutlinkFgColor);
 440                 __cutlinkColor[type].cutlinkFgColor = Color::GetColor(COLOR_ID_BLUE);
 441                 GET_COLOR_CONFIG(EDIT::CUT_LINK_BG_NORMAL, __cutlinkColor[type].cutlinkBgColor);
 442         }
 443 }
 444
 445 result
 446 _Edit::SetPresenter(const _EditPresenter& pPresenter)
 447 {
 448         result r = E_SUCCESS;
 449
 450         _pEditPresenter = const_cast<_EditPresenter*>(&pPresenter);
 451
 452         return r;
 453 }
 454
 455 _EditPresenter*
 456 _Edit::GetPresenter(void) const
 457 {
 458         return _pEditPresenter;
 459 }
 460
 461 Dimension
 462 _Edit::GetContentSizeInternal(void) const
 463 {
 464         Dimension dimension(0,0);
 465         int leftMargin = 0;
 466         int rightMargin = 0;
 467         int textTopMargin = 0;
 468         int textBottomMargin = 0;
 469
 470         _ControlOrientation orientation = GetOrientation();
 471         GET_SHAPE_CONFIG(EDIT::AREA_LEFT_MARGIN, orientation, leftMargin);
 472         GET_SHAPE_CONFIG(EDIT::AREA_RIGHT_MARGIN, orientation, rightMargin);
 473         GET_SHAPE_CONFIG(EDIT::AREA_TEXT_TOP_MARGIN, orientation, textTopMargin);
 474         GET_SHAPE_CONFIG(EDIT::AREA_TEXT_BOTTOM_MARGIN, orientation, textBottomMargin);
 475
 476         TextObject* pTextObject = _pEditPresenter->GetTextObject();
 477
 478         if (!pTextObject)
 479         {
 480                 return dimension;
 481         }
 482
 483         // store
 484         TextObjectActionType previousActionType = pTextObject->GetAction();
 485         TextObjectWrapType previousWrapType = pTextObject->GetWrap();
 486         Rectangle previousRect = pTextObject->GetBounds();
 487         Rectangle newRect = previousRect;
 488
 489         if (orientation == _CONTROL_ORIENTATION_PORTRAIT)
 490         {
 491         newRect.width = _ControlManager::GetInstance()->GetScreenSize().width;
 492         }
 493         else
 494         {
 495                 newRect.width = _ControlManager::GetInstance()->GetScreenSize().height;
 496         }
 497
 498
 499         pTextObject->SetBounds(newRect);
 500         pTextObject->SetAction(TEXT_OBJECT_ACTION_TYPE_NONE);
 501         pTextObject->SetWrap(TEXT_OBJECT_WRAP_TYPE_WORD);
 502         pTextObject->Compose();
 503
 504         dimension = pTextObject->GetTextExtent(0, pTextObject->GetTextLength());
 505         if (dimension.width > newRect.width)
 506         {
 507                 dimension.width = newRect.width;
 508         }
 509
 510         dimension.height = pTextObject->GetTotalHeight();
 511
 512         // restore
 513         pTextObject->SetBounds(previousRect);
 514         pTextObject->SetAction(previousActionType);
 515         pTextObject->SetWrap(previousWrapType);
 516         pTextObject->Compose();
 517
 518         dimension.width += leftMargin + rightMargin;
 519         dimension.height += textTopMargin + textBottomMargin;
 520
 521         return  dimension;
 522 }
 523
 524 HorizontalAlignment
 525 _Edit::GetTextAlignment(void) const
 526 {
 527         return _pEditPresenter->GetTextAlignment();
 528 }
 529
 530 result
 531 _Edit::SetTextAlignment(HorizontalAlignment alignment)
 532 {
 533         return _pEditPresenter->SetTextAlignment(alignment);
 534 }
 535
 536 bool
 537 _Edit::IsViewModeEnabled(void) const
 538 {
 539         Variant var = GetProperty("viewModeEnabled");
 540
 541         return var.ToBool();
 542 }
 543
 544 result
 545 _Edit::SetViewModeEnabled(bool enable)
 546 {
 547         Variant var(enable);
 548
 549         return SetProperty("viewModeEnabled", var);
 550 }
 551
 552 result
 553 _Edit::SetAutoLinkMask(unsigned long autoLinks)
 554 {
 555         SysTryReturn(NID_UI_CTRL, (__inputStyle == INPUT_STYLE_OVERLAY), E_UNSUPPORTED_OPERATION, E_UNSUPPORTED_OPERATION, "[E_UNSUPPORTED_OPERATION] The current state unable to this operation.");
 556         Variant var(autoLinks);
 557
 558         return SetProperty("autoLinkMask", var);
 559 }
 560
 561 unsigned long
 562 _Edit::GetAutoLinkMask(void) const
 563 {
 564         SysTryReturn(NID_UI_CTRL, (__inputStyle == INPUT_STYLE_OVERLAY), LINK_TYPE_NONE, E_UNSUPPORTED_OPERATION, "[E_UNSUPPORTED_OPERATION] The current state unable to this operation.");
 565         Variant var = GetProperty("autoLinkMask");
 566
 567         return var.ToULong();
 568 }
 569
 570 int
 571 _Edit::GetLineSpacing(void) const
 572 {
 573         return _pEditPresenter->GetLineSpacing();
 574 }
 575
 576 result
 577 _Edit::SetLineSpacing(int linePixelGap)
 578 {
 579         return _pEditPresenter->SetLineSpacing(linePixelGap);
 580 }
 581
 582 void
 583 _Edit::SetMaxLineCount(int maxLineCount)
 584 {
 585         _pEditPresenter->SetMaxLineCount(maxLineCount);
 586 }
 587
 588 int
 589 _Edit::GetMaxLineCount(void) const
 590 {
 591         return _pEditPresenter->GetMaxLineCount();
 592 }
 593
 594 int
 595 _Edit::GetHorizontalMargin(EditTextHorizontalMargin marginType) const
 596 {
 597         Variant var;
 598
 599         switch (marginType)
 600         {
 601         case EDIT_TEXT_LEFT_MARGIN:
 602                 var = GetProperty("leftMargin");
 603                 break;
 604
 605         case EDIT_TEXT_RIGHT_MARGIN:
 606                 var = GetProperty("rightMargin");
 607                 break;
 608
 609         case EDIT_TEXT_HORIZONTAL_MARGIN:
 610                 var = GetProperty("leftMargin");
 611                 break;
 612
 613         default:
 614                 break;
 615         }
 616
 617         return var.ToInt();
 618 }
 619
 620 int
 621 _Edit::GetVerticalMargin(EditTextVerticalMargin marginType) const
 622 {
 623         Variant var;
 624
 625         switch (marginType)
 626         {
 627         case EDIT_TEXT_TOP_MARGIN:
 628                 var = GetProperty("topMargin");
 629                 break;
 630
 631         case EDIT_TEXT_BOTTOM_MARGIN:
 632                 var = GetProperty("bottomMargin");
 633                 break;
 634
 635         case EDIT_TEXT_VERTICAL_MARGIN:
 636                 var = GetProperty("topMargin");
 637                 break;
 638
 639         default:
 640                 break;
 641         }
 642
 643         return var.ToInt();
 644 }
 645
 646 result
 647 _Edit::SetHorizontalMargin(int margin, EditTextHorizontalMargin marginType)
 648 {
 649         result r = E_SUCCESS;
 650         Variant var(margin);
 651
 652         SysTryReturn(NID_UI_CTRL, margin > 0, E_INVALID_ARG, E_INVALID_ARG, "[E_INVALID_ARG] The invalid argument is given.");
 653
 654         switch (marginType)
 655         {
 656         case EDIT_TEXT_LEFT_MARGIN:
 657                 r = SetProperty("leftMargin", var);
 658                 break;
 659
 660         case EDIT_TEXT_RIGHT_MARGIN:
 661                 r = SetProperty("rightMargin", var);
 662                 break;
 663
 664         case EDIT_TEXT_HORIZONTAL_MARGIN:
 665                 r = SetProperty("leftMargin", var);
 666                 SysTryReturn(NID_UI_CTRL, r == E_SUCCESS, E_SYSTEM, E_SYSTEM, "[E_SYSTEM] Faild to set margin.");
 667                 r = SetProperty("rightMargin", var);
 668                 break;
 669
 670         default:
 671                 break;
 672         }
 673         SysTryReturn(NID_UI_CTRL, r == E_SUCCESS, E_SYSTEM, E_SYSTEM, "[E_SYSTEM] Faild to set margin.");
 674
 675         _pEditPresenter->SetClientBounds();
 676         r = _pEditPresenter->SetInitialBounds();
 677         SysTryReturn(NID_UI_CTRL, r == E_SUCCESS, E_SYSTEM, E_SYSTEM, "[E_SYSTEM] Faild to set margin.");
 678
 679         return r;
 680
 681 }
 682
 683 result
 684 _Edit::SetVerticalMargin(int margin, EditTextVerticalMargin marginType)
 685 {
 686         result r = E_SUCCESS;
 687         Variant var(margin);
 688
 689         SysTryReturn(NID_UI_CTRL, margin > 0, E_INVALID_ARG, E_INVALID_ARG, "[E_INVALID_ARG] The invalid argument is given.");
 690
 691         switch (marginType)
 692         {
 693         case EDIT_TEXT_TOP_MARGIN:
 694                 r = SetProperty("topMargin", var);
 695                 break;
 696
 697         case EDIT_TEXT_BOTTOM_MARGIN:
 698                 r = SetProperty("bottomMargin", var);
 699                 break;
 700
 701         case EDIT_TEXT_VERTICAL_MARGIN:
 702                 r = SetProperty("topMargin", var);
 703                 SysTryReturn(NID_UI_CTRL, r == E_SUCCESS, E_SYSTEM, E_SYSTEM, "[E_SYSTEM] Faild to set margin.");
 704                 r = SetProperty("bottomMargin", var);
 705                 break;
 706
 707         default:
 708                 break;
 709         }
 710         SysTryReturn(NID_UI_CTRL, r == E_SUCCESS, E_SYSTEM, E_SYSTEM, "[E_SYSTEM] Faild to set margin.");
 711
 712         _pEditPresenter->SetClientBounds();
 713         r = _pEditPresenter->SetInitialBounds();
 714         SysTryReturn(NID_UI_CTRL, r == E_SUCCESS, E_SYSTEM, E_SYSTEM, "[E_SYSTEM] Faild to set margin.");
 715
 716         return r;
 717
 718 }
 719
 720 int
 721 _Edit::GetTextLimitLength(void) const
 722 {
 723         return _pEditPresenter->GetTextLimitLength();
 724 }
 725
 726 result
 727 _Edit::SetLimitLength(int limitLength)
 728 {
 729         return _pEditPresenter->SetTextLimitLength(limitLength);
 730 }
 731
 732 result
 733 _Edit::SetAutoResizingEnabled(bool enable)
 734 {
 735         Variant var(enable);
 736
 737         return SetProperty("autoResizingEnabled", var);
 738 }
 739
 740 bool
 741 _Edit::IsAutoResizingEnabled(void) const
 742 {
 743         Variant var = GetProperty("autoResizingEnabled");
 744
 745         return var.ToBool();
 746 }
 747
 748 CoreKeypadAction
 749 _Edit::GetKeypadAction(void) const
 750 {
 751         Variant var = GetProperty("keypadAction");
 752
 753         return (CoreKeypadAction)var.ToInt();
 754 }
 755
 756 result
 757 _Edit::SetKeypadAction(CoreKeypadAction keypadAction)
 758 {
 759         SysTryReturn(NID_UI_CTRL, (__inputStyle == INPUT_STYLE_OVERLAY), E_UNSUPPORTED_OPERATION, E_UNSUPPORTED_OPERATION, "[E_UNSUPPORTED_OPERATION] The current state unable to this operation.");
 760         Variant var((int)keypadAction);
 761
 762         return SetProperty("keypadAction", var);
 763 }
 764
 765 result
 766 _Edit::SetKeypadActionEnabled(bool enabled)
 767 {
 768         Variant var(enabled);
 769
 770         return SetProperty("keypadActionEnabled", var);
 771 }
 772
 773 bool
 774 _Edit::GetKeypadActionEnabled(void) const
 775 {
 776         Variant var = GetProperty("keypadActionEnabled");
 777
 778         return var.ToBool();
 779 }
 780
 781 KeypadStyle
 782 _Edit::GetKeypadStyle(void) const
 783 {
 784         Variant var = GetProperty("keypadStyle");
 785
 786         return (KeypadStyle)var.ToInt();
 787 }
 788
 789 result
 790 _Edit::SetKeypadStyle(KeypadStyle keypadStyle)
 791 {
 792         SysTryReturn(NID_UI_CTRL, (KEYPAD_STYLE_PASSWORD != keypadStyle), E_INVALID_ARG, E_INVALID_ARG, "[E_INVALID_ARG] The invalid argument is given.");
 793         Variant var((int)keypadStyle);
 794
 795         return SetProperty("keypadStyle", var);
 796 }
 797
 798 result
 799 _Edit::SetKeypadNormalNumberStyle(bool enable)
 800 {
 801         return _pEditPresenter->SetKeypadNormalNumberStyle(enable);
 802 }
 803
 804 bool
 805 _Edit::IsTextPredictionEnabled(void) const
 806 {
 807         return _pEditPresenter->IsTextPredictionEnabled();
 808 }
 809
 810 result
 811 _Edit::SetTextPredictionEnabled(bool enable)
 812 {
 813         return _pEditPresenter->SetTextPredictionEnabled(enable);
 814 }
 815
 816 void
 817 _Edit::UpdateAccessibilityElement(EditAccessibilityElementType type)
 818 {
 819         if (!__isAccessibilityCreated)
 820         {
 821                 return;
 822         }
 823
 824         switch(type)
 825         {
 826                 case EDIT_ACCESSIBILITY_ELEMENT_TYPE_TITLE_TEXT:
 827                         if (__pTitleTextAccessibilityElement)
 828                         {
 829                                 __pTitleTextAccessibilityElement->SetBounds(_pEditPresenter->GetTitleBounds());
 830                                 __pTitleTextAccessibilityElement->SetLabel(GetTitleText());
 831                         }
 832                         break;
 833                 case EDIT_ACCESSIBILITY_ELEMENT_TYPE_TEXT:
 834                         if (__pTextAccessibilityElement)
 835                         {
 836                                 __pTextAccessibilityElement->SetBounds(_pEditPresenter->GetTextAreaBounds());
 837                                 __pTextAccessibilityElement->SetLabel(GetText());
 838                         }
 839                         break;
 840                 case EDIT_ACCESSIBILITY_ELEMENT_TYPE_CLEAR_ICON:
 841                         if (__pClearButtonTextAccessibilityElement)
 842                         {
 843                                 __pClearButtonTextAccessibilityElement->SetBounds(_pEditPresenter->GetClearIconBounds());
 844                         }
 845                         break;
 846                 default:
 847                         break;
 848         }
 849         return;
 850 }
 851
 852 void
 853 _Edit::SetFullScreenKeypadEdit(bool enabled)
 854 {
 855         __isFullScreenKeypadEdit = enabled;
 856 }
 857
 858 bool
 859 _Edit::IsFullScreenKeypadEdit(void)
 860 {
 861         return __isFullScreenKeypadEdit;
 862 }
 863
 864 result
 865 _Edit::HideKeypad(void)
 866 {
 867         return _pEditPresenter->HideKeypad(true);
 868 }
 869
 870 int
 871 _Edit::GetTextSize(void) const
 872 {
 873         Variant size = GetProperty("textSize");
 874
 875         return size.ToInt();
 876 }
 877
 878 result
 879 _Edit::SetTextSize(int size)
 880 {
 881         Variant var(size);
 882
 883         return SetProperty("textSize", Variant(size));
 884 }
 885
 886 Color
 887 _Edit::GetColor(EditStatus status) const
 888 {
 889         Variant color;
 890         switch (status)
 891         {
 892         case EDIT_STATUS_NORMAL:
 893                 color = GetProperty("normalColor");
 894                 break;
 895
 896         case EDIT_STATUS_DISABLED:
 897                 color = GetProperty("disabledColor");
 898                 break;
 899
 900         case EDIT_STATUS_HIGHLIGHTED:
 901                 color = GetProperty("highlightedColor");
 902                 break;
 903
 904         case EDIT_STATUS_PRESSED:
 905                 color = GetProperty("pressedColor");
 906                 break;
 907
 908         default:
 909                 break;
 910         }
 911
 912         return color.ToColor();
 913 }
 914
 915 Color
 916 _Edit::GetTextColor(EditTextColor type) const
 917 {
 918         Variant variantColor;
 919         Color color;
 920         switch (type)
 921         {
 922         case EDIT_TEXT_COLOR_NORMAL:
 923                 variantColor = GetProperty("normalTextColor");
 924                 color =  variantColor.ToColor();
 925                 break;
 926
 927         case EDIT_TEXT_COLOR_DISABLED:
 928                 variantColor = GetProperty("disabledTextColor");
 929                 color =  variantColor.ToColor();
 930                 break;
 931
 932         case EDIT_TEXT_COLOR_HIGHLIGHTED:
 933                 variantColor = GetProperty("highlightedTextColor");
 934                 color =  variantColor.ToColor();
 935                 break;
 936
 937         case EDIT_TEXT_COLOR_LINK:
 938                 color = __cutlinkColor[EDIT_LINK_TYPE_URL].cutlinkFgColor;
 939                 break;
 940
 941         default:
 942                 break;
 943         }
 944
 945         return color;
 946 }
 947
 948 Color
 949 _Edit::GetTextColor(EditStatus status) const
 950 {
 951         Variant variantColor;
 952         Color color;
 953
 954         switch (status)
 955         {
 956         case EDIT_STATUS_NORMAL:
 957                 variantColor = GetProperty("normalTextColor");
 958                 color = variantColor.ToColor();
 959                 break;
 960
 961         case EDIT_STATUS_DISABLED:
 962                 variantColor = GetProperty("disabledTextColor");
 963                 color = variantColor.ToColor();
 964                 break;
 965
 966         case EDIT_STATUS_HIGHLIGHTED:
 967                 variantColor = GetProperty("highlightedTextColor");
 968                 color = variantColor.ToColor();
 969                 break;
 970
 971         case EDIT_STATUS_PRESSED:
 972                 variantColor = GetProperty("pressedTextColor");
 973                 color = variantColor.ToColor();
 974                 break;
 975
 976         default:
 977                 break;
 978         }
 979
 980         return color;
 981 }
 982
 983 result
 984 _Edit::SetBackgroundBitmap(EditStatus status, const Bitmap& bitmap)
 985 {
 986         result r = E_SUCCESS;
 987
 988         Bitmap* pNewBitmap = _BitmapImpl::CloneN(bitmap);
 989         SysTryReturn(NID_UI_CTRL, pNewBitmap, E_OUT_OF_MEMORY, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] Memory shortage.");
 990
 991         delete __pBackgroundBitmap[status];
 992         __pBackgroundBitmap[status] = pNewBitmap;
 993
 994         return r;
 995 }
 996
 997 result
 998 _Edit::SetColor(EditStatus status, const Color& color)
 999 {
1000         result r = E_SUCCESS;
1001
1002         switch (status)
1003         {
1004         case EDIT_STATUS_NORMAL:
1005                 r = SetProperty("normalColor", Variant(color));
1006                 break;
1007
1008         case EDIT_STATUS_DISABLED:
1009                 r = SetProperty("disabledColor", Variant(color));
1010                 break;
1011
1012         case EDIT_STATUS_HIGHLIGHTED:
1013                 r = SetProperty("highlightedColor", Variant(color));
1014                 break;
1015
1016         case EDIT_STATUS_PRESSED:
1017                 r = SetProperty("pressedColor", Variant(color));
1018                 break;
1019
1020         default:
1021                 r = E_INVALID_ARG;
1022                 break;
1023         }
1024         SysTryReturn(NID_UI_CTRL, r == E_SUCCESS, r, r, "[%s] Unable to set color.", GetErrorMessage(r));
1025
1026         return r;
1027 }
1028
1029 result
1030 _Edit::SetTextColor(EditTextColor type, const Color& color)
1031 {
1032         result r = E_SUCCESS;
1033         EditCutlinkColor autoLinkColorInfo;
1034
1035         switch (type)
1036         {
1037         case EDIT_TEXT_COLOR_NORMAL:
1038                 r =     SetProperty("normalTextColor", Variant(color));
1039                 SysTryReturn(NID_UI_CTRL, r == E_SUCCESS, r, r, "[%s] System error occurred.", GetErrorMessage(r));
1040                 break;
1041
1042         case EDIT_TEXT_COLOR_DISABLED:
1043                 r =     SetProperty("disabledTextColor", Variant(color));
1044                 SysTryReturn(NID_UI_CTRL, r == E_SUCCESS, r, r, "[%s] System error occurred.", GetErrorMessage(r));
1045                 break;
1046
1047         case EDIT_TEXT_COLOR_HIGHLIGHTED:
1048                 r =     SetProperty("highlightedTextColor", Variant(color));
1049                 SysTryReturn(NID_UI_CTRL, r == E_SUCCESS, r, r, "[%s] System error occurred.", GetErrorMessage(r));
1050
1051                 r =     SetProperty("pressedTextColor", Variant(color));
1052                 SysTryReturn(NID_UI_CTRL, r == E_SUCCESS, r, r, "[%s] System error occurred.", GetErrorMessage(r));
1053                 break;
1054
1055         case EDIT_TEXT_COLOR_LINK:
1056                 GetCutlinkColorInfo(EDIT_LINK_TYPE_URL, &autoLinkColorInfo);
1057                 autoLinkColorInfo.cutlinkFgColor = color;
1058                 SetCutlinkColorInfo(EDIT_LINK_TYPE_URL, autoLinkColorInfo);
1059                 SetCutlinkColorInfo(EDIT_LINK_TYPE_EMAIL, autoLinkColorInfo);
1060                 SetCutlinkColorInfo(EDIT_LINK_TYPE_PHONE_NUM, autoLinkColorInfo);
1061                 break;
1062
1063         default:
1064                 r = E_INVALID_ARG;
1065                 break;
1066         }
1067
1068         return r;
1069 }
1070
1071 String
1072 _Edit::GetText(int start, int end) const
1073 {
1074         SysTryReturn(NID_UI_CTRL, (start > -1 && end > -1 && end > start), String(), E_INVALID_ARG, "[E_INVALID_ARG] The invalid argument(start = %d, end = %d) is given.");
1075
1076         return _pEditPresenter->GetText(start, end);
1077 }
1078
1079 result
1080 _Edit::AddExpandableEditAreaEventListener(const _IExpandableEditAreaEventListener& listener)
1081 {
1082         if (__pExpandableEditAreaEvent == null)
1083         {
1084                 __pExpandableEditAreaEvent = _ExpandableEditAreaEvent::CreateInstanceN(*this);
1085                 SysTryReturn(NID_UI_CTRL, __pExpandableEditAreaEvent, E_SYSTEM, E_SYSTEM, "[E_SYSTEM] System error occurred.");
1086         }
1087
1088         return __pExpandableEditAreaEvent->AddListener(listener);
1089 }
1090
1091 result
1092 _Edit::RemoveExpandableEditAreaEventListener(const _IExpandableEditAreaEventListener& listener)
1093 {
1094         SysTryReturn(NID_UI_CTRL, __pExpandableEditAreaEvent, E_SYSTEM, E_SYSTEM, "[E_SYSTEM] This instance isn't constructed.");
1095
1096         return __pExpandableEditAreaEvent->RemoveListener(listener);
1097 }
1098
1099 result
1100 _Edit::AddUiLinkEventListener(const _IUiLinkEventListener& listener)
1101 {
1102         if (__pLinkEvent == null)
1103         {
1104                 __pLinkEvent = _LinkEvent::CreateInstanceN(*this);
1105                 SysTryReturn(NID_UI_CTRL, __pLinkEvent, E_SYSTEM, E_SYSTEM, "[E_SYSTEM] System error occurred.");
1106         }
1107
1108         return __pLinkEvent->AddListener(listener);
1109 }
1110
1111 result
1112 _Edit::RemoveUiLinkEventListener(const _IUiLinkEventListener& listener)
1113 {
1114         SysTryReturn(NID_UI_CTRL, __pLinkEvent, E_SYSTEM, E_SYSTEM, "[E_SYSTEM] This instance isn't constructed.");
1115
1116         return __pLinkEvent->RemoveListener(listener);
1117 }
1118
1119 result
1120 _Edit::AddTextBlockEventListener(const _ITextBlockEventListener& listener)
1121 {
1122         if (__pTextBlockEvent == null)
1123         {
1124                 __pTextBlockEvent = _TextBlockEvent::CreateInstanceN(*this);
1125                 SysTryReturn(NID_UI_CTRL, __pTextBlockEvent, E_SYSTEM, E_SYSTEM, "[E_SYSTEM] System error occurred.");
1126         }
1127
1128         return __pTextBlockEvent->AddListener(listener);
1129 }
1130
1131 result
1132 _Edit::RemoveTextBlockEventListener(const _ITextBlockEventListener& listener)
1133 {
1134         SysTryReturn(NID_UI_CTRL, __pTextBlockEvent, E_SYSTEM, E_SYSTEM, "[E_SYSTEM] This instance isn't constructed.");
1135
1136         __pTextBlockEvent->RemoveListener(listener);
1137
1138         return E_SUCCESS;
1139 }
1140
1141 result
1142 _Edit::AddKeypadEventListener(const _IKeypadEventListener& listener)
1143 {
1144         if (__pKeypadEvent == null)
1145         {
1146                 __pKeypadEvent = _KeypadEvent::CreateInstanceN(*this);
1147                 SysTryReturn(NID_UI_CTRL, __pKeypadEvent, E_SYSTEM, E_SYSTEM, "[E_SYSTEM] System error occurred.");
1148         }
1149
1150         return __pKeypadEvent->AddListener(listener);
1151 }
1152
1153 result
1154 _Edit::RemoveKeypadEventListener(const _IKeypadEventListener& listener)
1155 {
1156         SysTryReturn(NID_UI_CTRL, __pKeypadEvent, E_SYSTEM, E_SYSTEM, "[E_SYSTEM] This instance isn't constructed.");
1157
1158         __pKeypadEvent->RemoveListener(listener);
1159
1160         return E_SUCCESS;
1161 }
1162
1163 result
1164 _Edit::AddTextEventListener(const _ITextEventListener& listener)
1165 {
1166         if (__pTextEvent == null)
1167         {
1168                 __pTextEvent = _TextEvent::CreateInstanceN(*this);
1169                 SysTryReturn(NID_UI_CTRL, __pTextEvent, E_SYSTEM, E_SYSTEM, "[E_SYSTEM] System error occurred.");
1170         }
1171
1172         return __pTextEvent->AddListener(listener);
1173 }
1174
1175 result
1176 _Edit::RemoveTextEventListener(const _ITextEventListener& listener)
1177 {
1178         SysTryReturn(NID_UI_CTRL, __pTextEvent, E_SYSTEM, E_SYSTEM, "[E_SYSTEM] This instance isn't constructed.");
1179         __pTextEvent->RemoveListener(listener);
1180
1181         return E_SUCCESS;
1182 }
1183
1184 result
1185 _Edit::AddScrollPanelEventListener(const _IScrollPanelEventListener& listener)
1186 {
1187         if (__pScrollPanelEvent == null)
1188         {
1189                 if (__inputStyle != INPUT_STYLE_OVERLAY)
1190                 {
1191                         SysLogException(NID_UI_CTRL, E_SYSTEM, "[E_SYSTEM] System error occurred.");
1192                         return E_SYSTEM;
1193                 }
1194                 else
1195                 {
1196                         __pScrollPanelEvent = _ScrollPanelEvent::CreateScrollPanelEventN(*this);
1197                         SysTryReturn(NID_UI_CTRL, __pScrollPanelEvent,
1198                                 E_SYSTEM, E_SYSTEM, "[E_SYSTEM] System error occurred.");
1199                 }
1200         }
1201
1202         return __pScrollPanelEvent->AddListener(listener);
1203 }
1204
1205 result
1206 _Edit::RemoveScrollPanelEventListener(const _IScrollPanelEventListener& listener)
1207 {
1208         SysTryReturn(NID_UI_CTRL, __pScrollPanelEvent, E_SYSTEM, E_SYSTEM, "[E_SYSTEM] This instance isn't constructed.");
1209         __pScrollPanelEvent->RemoveListener(listener);
1210
1211         return E_SUCCESS;
1212 }
1213
1214 result
1215 _Edit::AddActionEventListener(const _IActionEventListener& listener)
1216 {
1217         _pEditPresenter->AddActionEventListener(listener);
1218
1219         return E_SUCCESS;
1220 }
1221
1222 result
1223 _Edit::RemoveActionEventListener(const _IActionEventListener& listener)
1224 {
1225         _pEditPresenter->RemoveActionEventListener(listener);
1226
1227         return E_SUCCESS;
1228 }
1229
1230 result
1231 _Edit::AddLanguageEventListener(const _ILanguageEventListener& listener)
1232 {
1233         if (__pLanguageEvent == null)
1234         {
1235                 __pLanguageEvent = _LanguageEvent::CreateInstanceN(*this);
1236
1237                 SysTryReturn(NID_UI_CTRL, __pLanguageEvent, E_SYSTEM, E_SYSTEM, "[E_SYSTEM] This instance isn't constructed.")
1238
1239                 __pLanguageEvent->AddListener(listener);
1240         }
1241
1242         return E_SUCCESS;
1243 }
1244
1245 result
1246 _Edit::RemoveLanguageEventListener(const _ILanguageEventListener& listener)
1247 {
1248         SysTryReturn(NID_UI_CTRL, __pLanguageEvent, E_SYSTEM, E_SYSTEM, "[E_SYSTEM] This instance isn't constructed.");
1249
1250         __pLanguageEvent->RemoveListener(listener);
1251
1252         return E_SUCCESS;
1253 }
1254
1255 int
1256 _Edit::GetRemainingLength(void) const
1257 {
1258         return _pEditPresenter->GetRemainingLength();
1259 }
1260
1261 void
1262 _Edit::SetLowerCaseModeEnabled(bool enable)
1263 {
1264         Variant var(enable);
1265
1266         SetProperty("lowerCaseModeEnabled", var);
1267 }
1268
1269 bool
1270 _Edit::IsLowerCaseModeEnabled(void) const
1271 {
1272         Variant var = GetProperty("lowerCaseModeEnabled");
1273
1274         return var.ToBool();
1275 }
1276
1277 result
1278 _Edit::SetCursorPosition(int position)
1279 {
1280         int textLength = GetTextLength();
1281         SysTryReturn(NID_UI_CTRL, (position >= 0 && position <= textLength), E_OUT_OF_RANGE, E_OUT_OF_RANGE, "[E_OUT_OF_RANGE] This position is out of range.");
1282
1283         Variant var(position);
1284
1285         return SetProperty("cursorPosition", var);
1286 }
1287
1288 int
1289 _Edit::GetCursorPosition(void) const
1290 {
1291         Variant var = GetProperty("cursorPosition");
1292
1293         return var.ToInt();
1294 }
1295
1296 String
1297 _Edit::GetText(void) const
1298 {
1299         Variant var = GetProperty("text");
1300
1301         return var.ToString();
1302 }
1303
1304 int
1305 _Edit::GetTextLength(void) const
1306 {
1307         return _pEditPresenter->GetTextLength();
1308 }
1309
1310 result
1311 _Edit::SetText(const String& text)
1312 {
1313         Variant var(text);
1314
1315         return SetProperty("text", var);
1316 }
1317
1318 result
1319 _Edit::InsertTextAtCursorPosition(const String& text)
1320 {
1321         return _pEditPresenter->InsertTextAtCursorPosition(text);
1322 }
1323
1324 result
1325 _Edit::InsertCharacterAt(int index, const Character& character)
1326 {
1327         return _pEditPresenter->InsertCharacterAt(index, character);
1328 }
1329
1330 result
1331 _Edit::InsertTextAt(int index, const String& text)
1332 {
1333         return _pEditPresenter->InsertTextAt(index, text);
1334 }
1335
1336 result
1337 _Edit::AppendText(const String& text)
1338 {
1339         return _pEditPresenter->AppendText(text);
1340 }
1341
1342 result
1343 _Edit::AppendCharacter(const Character& character)
1344 {
1345         return _pEditPresenter->AppendCharacter(character);
1346 }
1347
1348 result
1349 _Edit::InsertTextAt(int position, const String& text, const Bitmap& textImage)
1350 {
1351         return _pEditPresenter->InsertTextAt(position, text, textImage);
1352 }
1353
1354 result
1355 _Edit::AppendText(const String& text, const Bitmap& textImage)
1356 {
1357         return _pEditPresenter->InsertTextAt(_pEditPresenter->GetTextLength(), text, textImage);
1358 }
1359
1360 result
1361 _Edit::ClearText(void)
1362 {
1363         return _pEditPresenter->ClearText();
1364 }
1365
1366 result
1367 _Edit::DeleteCharacterAt(int index)
1368 {
1369         return _pEditPresenter->DeleteCharacterAt(index);
1370 }
1371
1372 result
1373 _Edit::DeleteCharacterAtCursorPosition(void)
1374 {
1375         return _pEditPresenter->DeleteCharacterAtCursorPosition();
1376 }
1377
1378 void
1379 _Edit::GetCurrentTextRange(int& start, int& end) const
1380 {
1381         return _pEditPresenter->GetCurrentTextRange(start, end);
1382 }
1383
1384 void
1385 _Edit::SetGuideText(const String& guideText)
1386 {
1387         Variant var(guideText);
1388
1389         SetProperty("guideText", var);
1390 }
1391
1392 String
1393 _Edit::GetGuideText(void) const
1394 {
1395         Variant var = GetProperty("guideText");
1396
1397         return var.ToString();
1398 }
1399
1400 Color
1401 _Edit::GetGuideTextColor(void) const
1402 {
1403         Variant color = GetProperty("guideTextColor");
1404
1405         return color.ToColor();
1406 }
1407
1408 result
1409 _Edit::SetGuideTextColor(const Color& color)
1410 {
1411         __isSettingGuideTextColor = true;
1412
1413         return SetProperty("guideTextColor", Variant(color));
1414 }
1415
1416 void
1417 _Edit::SetKeypadEnabled(bool enable)
1418 {
1419         Variant var(enable);
1420
1421         SetProperty("keypadEnabled", var);
1422 }
1423
1424 bool
1425 _Edit::IsKeypadEnabled(void) const
1426 {
1427         Variant var = GetProperty("keypadEnabled");
1428
1429         return var.ToBool();
1430 }
1431
1432 result
1433 _Edit::ShowKeypad(void)
1434 {
1435         SysTryReturn(NID_UI_CTRL, (HasParent() && GetParent()), E_SYSTEM, E_SYSTEM, "[E_SYSTEM] The keypad couldn't be shown.");
1436         SysTryReturn(NID_UI_CTRL, (IsKeypadEnabled() && (__inputStyle == INPUT_STYLE_OVERLAY)), E_INVALID_STATE, E_INVALID_STATE, "[E_INVALID_STATE] The keypad couldn't be shown.");
1437
1438         return _pEditPresenter->ShowKeypad();
1439 }
1440
1441 int
1442 _Edit::GetTextLineCount(void) const
1443 {
1444         return _pEditPresenter->GetTextLineCount();
1445 }
1446
1447 int
1448 _Edit::GetTextTotalHeight(void) const
1449 {
1450         return _pEditPresenter->GetTextTotalHeight();
1451 }
1452
1453 result
1454 _Edit::SetBlockTextColor(const Color& color)
1455 {
1456         Variant var(color);
1457
1458         return SetProperty("blockedTextColor", var);
1459 }
1460
1461 Color
1462 _Edit::GetBlockTextColor(void) const
1463 {
1464         Variant var;
1465
1466         if (__blockTextColor.used)
1467         {
1468                 var = GetProperty("blockedTextColor");
1469         }
1470         else
1471         {
1472                 var = GetProperty("highlightedColor");
1473         }
1474
1475         return var.ToColor();
1476 }
1477
1478 void
1479 _Edit::GetBlockRange(int& start, int& end) const
1480 {
1481         _pEditPresenter->GetBlockRange(start, end);
1482 }
1483
1484 result
1485 _Edit::SetBlockRange(int start, int end)
1486 {
1487         return _pEditPresenter->SetBlockRange(start, end);
1488 }
1489
1490 void
1491 _Edit::GetWordPosition(int cursorPos, int& startPos, int& endPos) const
1492 {
1493         _pEditPresenter->GetWordPosition(cursorPos, startPos, endPos);
1494 }
1495
1496 result
1497 _Edit::GetTextImageRangeAt(int postion, int& startPosition, int& endPosition) const
1498 {
1499         return _pEditPresenter->GetTextImageRangeAt(postion, startPosition, endPosition);
1500 }
1501
1502 result
1503 _Edit::BeginTextBlock(void)
1504 {
1505         return _pEditPresenter->BeginTextBlock();
1506 }
1507
1508 result
1509 _Edit::ReleaseTextBlock(void)
1510 {
1511         return _pEditPresenter->ReleaseTextBlock();
1512 }
1513
1514 bool
1515 _Edit::IsBlocked(void) const
1516 {
1517         return _pEditPresenter->IsBlocked();
1518 }
1519
1520 result
1521 _Edit::CopyText(void)
1522 {
1523         return _pEditPresenter->CopyText();
1524 }
1525
1526 result
1527 _Edit::CutText(void)
1528 {
1529         return _pEditPresenter->CutText();
1530 }
1531
1532 result
1533 _Edit::PasteText(void)
1534 {
1535         return _pEditPresenter->PasteText();
1536 }
1537
1538 result
1539 _Edit::RemoveTextBlock(void)
1540 {
1541         return _pEditPresenter->RemoveTextBlock();
1542 }
1543
1544 bool
1545 _Edit::IsClipped(void) const
1546 {
1547         return _pEditPresenter->IsClipped();
1548 }
1549
1550 result
1551 _Edit::SetCurrentLanguage(LanguageCode languageCode)
1552 {
1553         return _pEditPresenter->SetCurrentLanguage(languageCode);
1554 }
1555
1556 result
1557 _Edit::GetCurrentLanguage(LanguageCode& language) const
1558 {
1559         return _pEditPresenter->GetCurrentLanguage(language);
1560 }
1561
1562 bool
1563 _Edit::CalculateAbsoluteCursorBounds(int index, Rectangle& absCursorRect)
1564 {
1565         return _pEditPresenter->CalculateAbsoluteCursorBounds(index, absCursorRect);
1566 }
1567
1568 void
1569 _Edit::OnDraw(void)
1570 {
1571         Canvas* pCanvas = GetCanvasN();
1572         SysTryReturnVoidResult(NID_UI_CTRL, pCanvas, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] Unable to create instance.");
1573
1574         _pEditPresenter->Draw(*pCanvas);
1575
1576         delete pCanvas;
1577 }
1578
1579 bool
1580 _Edit::OnTouchPressed(const _Control& source, const _TouchInfo& touchinfo)
1581 {
1582         return _pEditPresenter->OnTouchPressed(source, touchinfo);
1583 }
1584
1585 bool
1586 _Edit::OnTouchCanceled(const _Control& source, const _TouchInfo& touchinfo)
1587 {
1588         return _pEditPresenter->OnTouchCanceled(source, touchinfo);
1589 }
1590
1591 bool
1592 _Edit::OnTouchReleased(const _Control& source, const _TouchInfo& touchinfo)
1593 {
1594         return _pEditPresenter->OnTouchReleased(source, touchinfo);
1595 }
1596
1597 bool
1598 _Edit::OnTouchMoved(const _Control& source, const _TouchInfo& touchinfo)
1599 {
1600         return _pEditPresenter->OnTouchMoved(source, touchinfo);
1601 }
1602
1603 bool
1604 _Edit::OnKeyPressed(const _Control& source, const _KeyInfo& keyInfo)
1605 {
1606         return _pEditPresenter->OnKeyPressed(source, keyInfo);
1607 }
1608
1609 bool
1610 _Edit::OnKeyReleased(const _Control& source, const _KeyInfo& keyInfo)
1611 {
1612         return _pEditPresenter->OnKeyReleased(source, keyInfo);
1613 }
1614
1615 bool
1616 _Edit::OnNotifiedN(const _Control& source, IList* pArgs)
1617 {
1618         return _pEditPresenter->OnNotifiedN(pArgs);
1619 }
1620
1621
1622 bool
1623 _Edit::OnFlickGestureDetected(_TouchFlickGestureDetector& gesture)
1624 {
1625         int xDistance = 0;
1626         int yDistance = 0;
1627         gesture.GetDistance(xDistance, yDistance);
1628         Point flickPoint(xDistance, yDistance);
1629
1630         _pEditPresenter->InitializeCopyPasteManager();
1631
1632         _pEditPresenter->StartFlickAnimation(flickPoint, gesture.GetDuration());
1633
1634         return true;
1635 }
1636
1637 bool
1638 _Edit::OnFlickGestureCanceled(_TouchFlickGestureDetector& gesture)
1639 {
1640         return false;
1641 }
1642
1643 bool
1644 _Edit::OnLongPressGestureDetected(_TouchLongPressGestureDetector& gesture)
1645 {
1646         _pEditPresenter->OnLongPressGestureDetected();
1647
1648         return true;
1649 }
1650
1651 bool
1652 _Edit::OnLongPressGestureCanceled(_TouchLongPressGestureDetector& gesture)
1653 {
1654         return false;
1655 }
1656
1657 bool
1658 _Edit::OnTapGestureDetected(_TouchTapGestureDetector& gesture)
1659 {
1660         _pEditPresenter->OnTapGestureDetected();
1661
1662         return true;
1663 }
1664
1665 bool
1666 _Edit::OnTapGestureCanceled(_TouchTapGestureDetector& gesture)
1667 {
1668         return false;
1669 }
1670
1671 void
1672 _Edit::OnClipboardPopupClosed(const ClipboardItem* pClipboardItem)
1673 {
1674         _pEditPresenter->OnClipboardPopupClosed(pClipboardItem);
1675 }
1676
1677 bool
1678 _Edit::OnFocusGained(const _Control& source)
1679 {
1680         return _pEditPresenter->OnFocusGained();
1681 }
1682
1683 bool
1684 _Edit::OnFocusLost(const _Control& source)
1685 {
1686         _pEditPresenter->OnFocusLost();
1687         Invalidate();
1688
1689         return true;
1690 }
1691
1692 result
1693 _Edit::OnAttachedToMainTree(void)
1694 {
1695         if (__isAccessibilityCreated)
1696         {
1697                 return E_SUCCESS;
1698         }
1699
1700         _AccessibilityContainer* pEditAccessibilityContainer = GetAccessibilityContainer();
1701         if(pEditAccessibilityContainer)
1702         {
1703                 pEditAccessibilityContainer->Activate(true);
1704         }
1705         if (pEditAccessibilityContainer)
1706         {
1707                 if ((__editStyle & EDIT_STYLE_TITLE_TOP) || (__editStyle & EDIT_STYLE_TITLE_LEFT))
1708                 {
1709                         __pTitleTextAccessibilityElement = new _AccessibilityElement(true);
1710                         __pTitleTextAccessibilityElement->SetBounds(_pEditPresenter->GetTitleBounds());
1711                         __pTitleTextAccessibilityElement->SetLabel(GetTitleText());
1712                         __pTitleTextAccessibilityElement->SetTrait(ACCESSIBILITY_TRAITS_TEXT_FIELD);
1713                         __pTitleTextAccessibilityElement->SetName(L"EditTitleText");
1714                         pEditAccessibilityContainer->AddElement(*__pTitleTextAccessibilityElement);
1715                 }
1716
1717                 __pTextAccessibilityElement = new _AccessibilityElement(true);
1718                 __pTextAccessibilityElement->SetBounds(_pEditPresenter->GetTextAreaBounds());
1719                 __pTextAccessibilityElement->SetLabel(GetText());
1720                 __pTextAccessibilityElement->SetTrait(ACCESSIBILITY_TRAITS_TEXT_FIELD);
1721                 __pTextAccessibilityElement->SetName(L"EditText");
1722                 pEditAccessibilityContainer->AddElement(*__pTextAccessibilityElement);
1723
1724                 if (__editStyle & EDIT_STYLE_CLEAR)
1725                 {
1726                         __pClearButtonTextAccessibilityElement = new _AccessibilityElement(true);
1727                         __pClearButtonTextAccessibilityElement->SetBounds(_pEditPresenter->GetClearIconBounds());
1728                         __pClearButtonTextAccessibilityElement->SetLabel(L"all clear, button");
1729                         __pClearButtonTextAccessibilityElement->SetTrait(ACCESSIBILITY_TRAITS_TEXT_FIELD);
1730                         __pClearButtonTextAccessibilityElement->SetName(L"EditFieldClearButton");
1731                         pEditAccessibilityContainer->AddElement(*__pClearButtonTextAccessibilityElement);
1732                 }
1733         }
1734
1735         __isAccessibilityCreated = true;
1736
1737         return E_SUCCESS;
1738 }
1739
1740 void
1741 _Edit::OnBoundsChanged(void)
1742 {
1743         if (__isConstructed)
1744         {
1745                 SysAssertf(_pEditPresenter != null, "_pEditPresenter is null");
1746
1747                 _pEditPresenter->Resize();
1748
1749                 if(__isAccessibilityCreated)
1750                 {
1751                         if (__pTitleTextAccessibilityElement)
1752                         {
1753                                 __pTitleTextAccessibilityElement->SetBounds(_pEditPresenter->GetTitleBounds());
1754                         }
1755
1756                         if (__pTextAccessibilityElement)
1757                         {
1758                                 __pTextAccessibilityElement->SetBounds(_pEditPresenter->GetTextAreaBounds());
1759                         }
1760
1761                         if (__pClearButtonTextAccessibilityElement)
1762                         {
1763                                 __pClearButtonTextAccessibilityElement->SetBounds(_pEditPresenter->GetClearIconBounds());
1764                         }
1765                 }
1766         }
1767 }
1768
1769 void
1770 _Edit::OnChangeLayout(_ControlOrientation orientation)
1771 {
1772         result r = _pEditPresenter->ChangeLayout(orientation);
1773         SetLastResult(r);
1774 }
1775
1776 void
1777 _Edit::OnScrollPanelBoundsChanged(void)
1778 {
1779         _pEditPresenter->OnScrollPanelBoundsChanged();
1780 }
1781
1782 void
1783 _Edit::OnFontChanged(Font* pFont)
1784 {
1785         _pEditPresenter->OnFontChanged(pFont);
1786 }
1787
1788 void
1789 _Edit::OnFontInfoRequested(unsigned long& style, int& size)
1790 {
1791         _pEditPresenter->OnFontInfoRequested(style, size);
1792 }
1793
1794 void
1795 _Edit::OnAncestorEnableStateChanged(const _Control& control)
1796 {
1797         bool enableState = false;
1798         enableState = control.GetEnableState();
1799
1800         if (!enableState)
1801         {
1802                 if (_Edit::IsFocused())
1803                 {
1804                         _pEditPresenter->HideKeypad(true);
1805                 }
1806         }
1807
1808         Invalidate();
1809 }
1810
1811 unsigned long
1812 _Edit::GetEditStyle(void) const
1813 {
1814         return __editStyle;
1815 }
1816
1817 void
1818 _Edit::SetEditStyle(unsigned long style)
1819 {
1820         __editStyle = style;
1821 }
1822
1823 void
1824 _Edit::SetBorderRoundStyleEnabled(bool enable)
1825 {
1826         __borderRoundStyle = enable;
1827 }
1828
1829 bool
1830 _Edit::IsBorderRoundStyleEnabled(void) const
1831 {
1832         return __borderRoundStyle;
1833 }
1834
1835 bool
1836 _Edit::IsUsbKeyboardConnected(void) const
1837 {
1838         return _pEditPresenter->IsUsbKeyboardConnected();
1839 }
1840
1841 bool
1842 _Edit::IsKeypadExist(void) const
1843 {
1844         return _pEditPresenter->IsKeypadExist();
1845 }
1846
1847 void
1848 _Edit::SetAutoShrinkModeEnabled(bool enable)
1849 {
1850         _pEditPresenter->SetAutoShrinkModeEnabled(enable);
1851 }
1852
1853 bool
1854 _Edit::IsAutoShrinkModeEnabled(void) const
1855 {
1856         return _pEditPresenter->IsAutoShrinkModeEnabled();
1857 }
1858
1859 EllipsisPosition
1860 _Edit::GetEllipsisPosition(void) const
1861 {
1862         return __ellipsisPosition;
1863 }
1864
1865 void
1866 _Edit::SetEllipsisPosition(EllipsisPosition position)
1867 {
1868         __ellipsisPosition = position;
1869         _pEditPresenter->SetEllipsisPosition(position);
1870 }
1871
1872 void
1873 _Edit::GetCutlinkColorInfo(EditCutLinkType type, EditCutlinkColor* colorInfo) const
1874 {
1875         *colorInfo = __cutlinkColor[type];
1876 }
1877
1878 void
1879 _Edit::SetCutlinkColorInfo(EditCutLinkType type, EditCutlinkColor colorInfo)
1880 {
1881         __cutlinkColor[type] = colorInfo;
1882 }
1883
1884 Bitmap*
1885 _Edit::GetBackgroundBitmap(EditStatus status) const
1886 {
1887         return __pBackgroundBitmap[status];
1888 }
1889
1890 result
1891 _Edit::LoadDefaultBackgroundBitmap(GroupStyle groupStyle)
1892 {
1893         result r = E_SUCCESS;
1894
1895         switch(groupStyle)
1896         {
1897                 case GROUP_STYLE_NONE:
1898                         r = GET_BITMAP_CONFIG_N(EDIT::BG_NORMAL, BITMAP_PIXEL_FORMAT_ARGB8888, __pDefaultBackgroundBitmap[EDIT_STATUS_NORMAL]);
1899                         SysTryCatch(NID_UI_CTRL, r == E_SUCCESS, , r, "Failed to load bitmap");
1900                         r = GET_BITMAP_CONFIG_N(EDIT::BG_DISABLED, BITMAP_PIXEL_FORMAT_ARGB8888, __pDefaultBackgroundBitmap[EDIT_STATUS_DISABLED]);
1901                         SysTryCatch(NID_UI_CTRL, r == E_SUCCESS, , r, "Failed to load bitmap");
1902                         r = GET_BITMAP_CONFIG_N(EDIT::BG_HIGHLIGHTED, BITMAP_PIXEL_FORMAT_ARGB8888, __pDefaultBackgroundBitmap[EDIT_STATUS_HIGHLIGHTED]);
1903                         SysTryCatch(NID_UI_CTRL, r == E_SUCCESS, , r, "Failed to load bitmap");
1904                         r = GET_BITMAP_CONFIG_N(EDIT::BG_PRESSED, BITMAP_PIXEL_FORMAT_ARGB8888, __pDefaultBackgroundBitmap[EDIT_STATUS_PRESSED]);
1905                         SysTryCatch(NID_UI_CTRL, r == E_SUCCESS, , r, "Failed to load bitmap");
1906                         r = GET_BITMAP_CONFIG_N(EDIT::BG_EFFECT, BITMAP_PIXEL_FORMAT_ARGB8888, __pDefaultBackgroundEffectBitmap);
1907                         SysTryCatch(NID_UI_CTRL, r == E_SUCCESS, , r, "Failed to load bitmap");
1908                         break;
1909                 case GROUP_STYLE_SINGLE:
1910                         r = GET_BITMAP_CONFIG_N(EDIT::BG_SINGLE_NORMAL, BITMAP_PIXEL_FORMAT_ARGB8888, __pDefaultBackgroundBitmap[EDIT_STATUS_NORMAL]);
1911                         SysTryCatch(NID_UI_CTRL, r == E_SUCCESS, , r, "Failed to load bitmap");
1912                         r = GET_BITMAP_CONFIG_N(EDIT::BG_SINGLE_EFFECT, BITMAP_PIXEL_FORMAT_ARGB8888, __pDefaultBackgroundEffectBitmap);
1913                         SysTryCatch(NID_UI_CTRL, r == E_SUCCESS, , r, "Failed to load bitmap");
1914                         break;
1915                 case GROUP_STYLE_TOP:
1916                         r = GET_BITMAP_CONFIG_N(EDIT::BG_TOP, BITMAP_PIXEL_FORMAT_ARGB8888, __pDefaultBackgroundBitmap[EDIT_STATUS_NORMAL]);
1917                         SysTryCatch(NID_UI_CTRL, r == E_SUCCESS, , r, "Failed to load bitmap");
1918                         r = GET_BITMAP_CONFIG_N(EDIT::BG_TOP_EFFECT, BITMAP_PIXEL_FORMAT_ARGB8888, __pDefaultBackgroundEffectBitmap);
1919                         SysTryCatch(NID_UI_CTRL, r == E_SUCCESS, , r, "Failed to load bitmap");
1920                         break;
1921                 case GROUP_STYLE_MIDDLE:
1922                         r = GET_BITMAP_CONFIG_N(EDIT::BG_CENTER, BITMAP_PIXEL_FORMAT_ARGB8888, __pDefaultBackgroundBitmap[EDIT_STATUS_NORMAL]);
1923                         SysTryCatch(NID_UI_CTRL, r == E_SUCCESS, , r, "Failed to load bitmap");
1924                         r = GET_BITMAP_CONFIG_N(EDIT::BG_CENTER_EFFECT, BITMAP_PIXEL_FORMAT_ARGB8888, __pDefaultBackgroundEffectBitmap);
1925                         SysTryCatch(NID_UI_CTRL, r == E_SUCCESS, , r, "Failed to load bitmap");
1926                         break;
1927                 case GROUP_STYLE_BOTTOM:
1928                         r = GET_BITMAP_CONFIG_N(EDIT::BG_BOTTOM, BITMAP_PIXEL_FORMAT_ARGB8888, __pDefaultBackgroundBitmap[EDIT_STATUS_NORMAL]);
1929                         SysTryCatch(NID_UI_CTRL, r == E_SUCCESS, , r, "Failed to load bitmap");
1930                         r = GET_BITMAP_CONFIG_N(EDIT::BG_BOTTOM_EFFECT, BITMAP_PIXEL_FORMAT_ARGB8888, __pDefaultBackgroundEffectBitmap);
1931                         SysTryCatch(NID_UI_CTRL, r == E_SUCCESS, , r, "Failed to load bitmap");
1932                         break;
1933                 default:
1934                         r = GET_BITMAP_CONFIG_N(EDIT::BG_NORMAL, BITMAP_PIXEL_FORMAT_ARGB8888, __pDefaultBackgroundBitmap[EDIT_STATUS_NORMAL]);
1935                         SysTryCatch(NID_UI_CTRL, r == E_SUCCESS, , r, "Failed to load bitmap");
1936                         r = GET_BITMAP_CONFIG_N(EDIT::BG_EFFECT, BITMAP_PIXEL_FORMAT_ARGB8888, __pDefaultBackgroundEffectBitmap);
1937                         SysTryCatch(NID_UI_CTRL, r == E_SUCCESS, , r, "Failed to load bitmap");
1938                         break;
1939         }
1940
1941         return r;
1942
1943 CATCH:
1944         for (int status = 0; status < EDIT_COLOR_MAX; status++)
1945         {
1946                 if (__pDefaultBackgroundBitmap[status])
1947                 {
1948                         delete __pDefaultBackgroundBitmap[status];
1949                         __pDefaultBackgroundBitmap[status] = null;
1950                 }
1951         }
1952
1953         delete __pDefaultBackgroundEffectBitmap;
1954         __pDefaultBackgroundEffectBitmap = null;
1955
1956         return r;
1957 }
1958
1959 result
1960 _Edit::ReplaceDefaultBackgroundBitmapForSearchBar(void)
1961 {
1962         result r = E_SUCCESS;
1963
1964         for (int status = 0; status < EDIT_COLOR_MAX; status++)
1965         {
1966                 if (__pDefaultBackgroundBitmap[status])
1967                 {
1968                         delete __pDefaultBackgroundBitmap[status];
1969                         __pDefaultBackgroundBitmap[status] = null;
1970                 }
1971         }
1972
1973         if (__pDefaultBackgroundEffectBitmap)
1974         {
1975                 delete __pDefaultBackgroundEffectBitmap;
1976                 __pDefaultBackgroundEffectBitmap = null;
1977         }
1978
1979         r = GET_BITMAP_CONFIG_N(SEARCHBAR::BG_NORMAL, BITMAP_PIXEL_FORMAT_ARGB8888, __pDefaultBackgroundBitmap[EDIT_STATUS_NORMAL]);
1980         SysTryCatch(NID_UI_CTRL, r == E_SUCCESS, , r, "Failed to load bitmap");
1981         r = GET_BITMAP_CONFIG_N(SEARCHBAR::BG_DISABLED, BITMAP_PIXEL_FORMAT_ARGB8888, __pDefaultBackgroundBitmap[EDIT_STATUS_DISABLED]);
1982         SysTryCatch(NID_UI_CTRL, r == E_SUCCESS, , r, "Failed to load bitmap");
1983         r = GET_BITMAP_CONFIG_N(SEARCHBAR::BG_HIGHLIGHTED, BITMAP_PIXEL_FORMAT_ARGB8888, __pDefaultBackgroundBitmap[EDIT_STATUS_HIGHLIGHTED]);
1984         SysTryCatch(NID_UI_CTRL, r == E_SUCCESS, , r, "Failed to load bitmap");
1985         r = GET_BITMAP_CONFIG_N(SEARCHBAR::BG_PRESSED, BITMAP_PIXEL_FORMAT_ARGB8888, __pDefaultBackgroundBitmap[EDIT_STATUS_PRESSED]);
1986         SysTryCatch(NID_UI_CTRL, r == E_SUCCESS, , r, "Failed to load bitmap");
1987         r = GET_BITMAP_CONFIG_N(SEARCHBAR::BG_EFFECT, BITMAP_PIXEL_FORMAT_ARGB8888, __pDefaultBackgroundEffectBitmap);
1988         SysTryCatch(NID_UI_CTRL, r == E_SUCCESS, , r, "Failed to load bitmap");
1989
1990         _pEditPresenter->SetSearchBarFlag(true);
1991
1992         return r;
1993
1994 CATCH:
1995         for (int status = 0; status < EDIT_COLOR_MAX; status++)
1996         {
1997                 if (__pDefaultBackgroundBitmap[status])
1998                 {
1999                         delete __pDefaultBackgroundBitmap[status];
2000                         __pDefaultBackgroundBitmap[status] = null;
2001                 }
2002         }
2003
2004         delete __pDefaultBackgroundEffectBitmap;
2005         __pDefaultBackgroundEffectBitmap = null;
2006
2007         return r;
2008 }
2009
2010 Bitmap*
2011 _Edit::GetDefaultBackgroundBitmap(EditStatus status) const
2012 {
2013         return __pDefaultBackgroundBitmap[status];
2014 }
2015
2016 bool
2017 _Edit::IsCustomDefaultBackgroundBitmap(EditStatus status) const
2018 {
2019         bool isCustomBitmap = false;
2020
2021         switch (status)
2022         {
2023         case EDIT_STATUS_NORMAL:
2024                 isCustomBitmap = IS_CUSTOM_BITMAP(EDIT::BG_NORMAL)
2025                 break;
2026         case EDIT_STATUS_DISABLED:
2027                 isCustomBitmap = IS_CUSTOM_BITMAP(EDIT::BG_DISABLED)
2028                 break;
2029         case EDIT_STATUS_HIGHLIGHTED:
2030                 isCustomBitmap = IS_CUSTOM_BITMAP(EDIT::BG_HIGHLIGHTED)
2031                 break;
2032         case EDIT_STATUS_PRESSED:
2033                 isCustomBitmap = IS_CUSTOM_BITMAP(EDIT::BG_PRESSED)
2034                 break;
2035         default:
2036                 isCustomBitmap = false;
2037                 break;
2038         }
2039
2040         return isCustomBitmap;
2041 }
2042
2043 Bitmap*
2044 _Edit::GetDefaultBackgroundEffectBitmap(void) const
2045 {
2046         return __pDefaultBackgroundEffectBitmap;
2047
2048 }
2049
2050 bool
2051 _Edit::IsSettingGuideTextColor(void) const
2052 {
2053         return __isSettingGuideTextColor;
2054 }
2055
2056 result
2057 _Edit::SetFont(const Font& font)
2058 {
2059         return _pEditPresenter->SetFont(font);
2060 }
2061
2062 void
2063 _Edit::GetFontType(String& typefaceName, unsigned long& styleMask) const
2064 {
2065         _pEditPresenter->GetFontType(typefaceName, styleMask);
2066 }
2067
2068 result
2069 _Edit::SetFontType(const String& typefaceName, unsigned long styleMask)
2070 {
2071         return _pEditPresenter->SetFontType(typefaceName, styleMask);
2072 }
2073
2074 unsigned long
2075 _Edit::GetTextStyle(void) const
2076 {
2077         return _pEditPresenter->GetTextStyle();
2078 }
2079
2080 result
2081 _Edit::SetTextStyle(unsigned long style)
2082 {
2083         return _pEditPresenter->SetTextStyle(style);
2084 }
2085
2086 String
2087 _Edit::GetTitleText(void) const
2088 {
2089         SysTryReturn(NID_UI_CTRL, (GetEditStyle() & EDIT_STYLE_TITLE_TOP) || (GetEditStyle() & EDIT_STYLE_TITLE_LEFT), String(), E_SYSTEM, "[E_SYSTEM] The EditField has no title style.\n");
2090
2091         Variant var = GetProperty("titleText");
2092
2093         return var.ToString();
2094 }
2095
2096 result
2097 _Edit::SetTitleText(const String& title)
2098 {
2099         SysTryReturn(NID_UI_CTRL, (GetEditStyle() & EDIT_STYLE_TITLE_TOP) || (GetEditStyle() & EDIT_STYLE_TITLE_LEFT), E_SYSTEM, E_SYSTEM, "[E_SYSTEM] The EditField has no title style.\n");
2100         Variant var(title);
2101
2102         return SetProperty("titleText", var);
2103 }
2104
2105 Color
2106 _Edit::GetTitleTextColor(EditStatus status) const
2107 {
2108         Variant var;
2109         switch (status)
2110         {
2111         case EDIT_STATUS_NORMAL:
2112                 var = GetProperty("normalTitleTextColor");
2113                 break;
2114
2115         case EDIT_STATUS_DISABLED:
2116                 var = GetProperty("disabledTitleTextColor");
2117                 break;
2118
2119         case EDIT_STATUS_HIGHLIGHTED:
2120                 var = GetProperty("highlightedTitleTextColor");
2121                 break;
2122
2123         case EDIT_STATUS_PRESSED:
2124                 var = GetProperty("pressedTitleTextColor");
2125                 break;
2126
2127         default:
2128                 break;
2129         }
2130
2131         return var.ToColor();
2132 }
2133
2134 result
2135 _Edit::SetTitleTextColor(EditStatus status, const Color& color)
2136 {
2137         result r = E_SUCCESS;
2138
2139         Variant var(color);
2140
2141         switch (status)
2142         {
2143         case EDIT_STATUS_NORMAL:
2144                 r = SetProperty("normalTitleTextColor", var);
2145                 break;
2146
2147         case EDIT_STATUS_DISABLED:
2148                 r = SetProperty("disabledTitleTextColor", var);
2149                 break;
2150
2151         case EDIT_STATUS_HIGHLIGHTED:
2152                 r = SetProperty("highlightedTitleTextColor", var);
2153                 break;
2154
2155         case EDIT_STATUS_PRESSED:
2156                 r = SetProperty("pressedTitleTextColor", var);
2157                 break;
2158
2159         default:
2160                 r = E_INVALID_ARG;
2161                 break;
2162         }
2163
2164         return r;
2165 }
2166
2167 InputStyle
2168 _Edit::GetInputStyle(void) const
2169 {
2170         return __inputStyle;
2171 }
2172
2173 result
2174 _Edit::SetKeypadCommandButtonVisible(bool visible)
2175 {
2176         Variant var(visible);
2177
2178         return SetProperty("overlayKeypadCommandButtonVisible", var);
2179 }
2180
2181 _Toolbar*
2182 _Edit::GetKeypadCommandButton(void) const
2183 {
2184         return _pEditPresenter->GetKeypadCommandButton();
2185 }
2186
2187
2188 result
2189 _Edit::SetKeypadCommandButton(CommandButtonPosition position, const String& text, int actionId)
2190 {
2191         SysTryReturn(NID_UI_CTRL, (__inputStyle != INPUT_STYLE_FULLSCREEN), E_SYSTEM, E_SYSTEM, "[E_SYSTEM] Unable to show the keypad due to a wrong input style.");
2192
2193         return _pEditPresenter->SetKeypadCommandButton(position, text, actionId);
2194 }
2195
2196 result
2197 _Edit::GetKeypadBounds(Rectangle& rect) const
2198 {
2199         return _pEditPresenter->GetKeypadBounds(rect);
2200 }
2201
2202 result
2203 _Edit::SendExpandableEditAreaEvent(_ExpandableEditAreaEventStatus status, int selectedTokenIndex)
2204 {
2205         if (__pExpandableEditAreaEvent)
2206         {
2207                 IEventArg* pEventArg = _ExpandableEditAreaEvent::CreateExpandableEditAreaEventArgN(status, selectedTokenIndex);
2208                 SysTryReturn(NID_UI_CTRL, pEventArg, E_OUT_OF_MEMORY, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] Memory shortage.");
2209
2210                 __pExpandableEditAreaEvent->Fire(*pEventArg);
2211         }
2212
2213         return E_SUCCESS;
2214 }
2215
2216 result
2217 _Edit::SendScrollPanelEvent(CoreScrollPanelStatus eventstatus)
2218 {
2219         if (__pScrollPanelEvent)
2220         {
2221                 IEventArg* pEventArg = _ScrollPanelEvent::CreateScrollPanelEventArgN(eventstatus);
2222                 SysTryReturn(NID_UI_CTRL, pEventArg, E_OUT_OF_MEMORY, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] Unable to create _CoreScrollPanelEventArg.");
2223
2224                 __pScrollPanelEvent->Fire(*pEventArg);
2225         }
2226
2227         return E_SUCCESS;
2228 }
2229
2230 result
2231 _Edit::SendKeypadEvent(CoreKeypadAction keypadAction, CoreKeypadEventStatus eventstatus)
2232 {
2233         if (__pKeypadEvent)
2234         {
2235                 IEventArg* pEventArg = _KeypadEvent::CreateKeypadEventArgN(keypadAction, eventstatus);
2236                 SysTryReturn(NID_UI_CTRL, pEventArg, E_OUT_OF_MEMORY, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] Unable to create _KeypadEventArg.");
2237
2238                 __pKeypadEvent->Fire(*pEventArg);
2239         }
2240
2241         return E_SUCCESS;
2242 }
2243
2244 result
2245 _Edit::SendTextEvent(CoreTextEventStatus textEventStatus)
2246 {
2247         if (__pTextAccessibilityElement)
2248         {
2249                 __pTextAccessibilityElement->SetLabel(GetText());
2250         }
2251
2252         if (__pTextEvent)
2253         {
2254                 IEventArg* pEventArg = _TextEvent::CreateTextEventArgN(textEventStatus);
2255                 SysTryReturn(NID_UI_CTRL, pEventArg, E_OUT_OF_MEMORY, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] Memory shortage.");
2256
2257                 __pTextEvent->Fire(*pEventArg);
2258         }
2259
2260         return E_SUCCESS;
2261 }
2262
2263 result
2264 _Edit::SendTextBlockEvent(int start, int end)
2265 {
2266         if (__pTextBlockEvent)
2267         {
2268                 IEventArg* pTextBlockEventArg = _TextBlockEvent::CreateTextBlockEventArgN(start, end);
2269                 SysTryReturn(NID_UI_CTRL, pTextBlockEventArg, E_OUT_OF_MEMORY, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] Unable to create _TextBlockEventArg.");
2270
2271                 __pTextBlockEvent->Fire(*pTextBlockEventArg);
2272         }
2273
2274         return E_SUCCESS;
2275 }
2276
2277 result
2278 _Edit::SendLinkEvent(const String& text, LinkType linkType, const String& link)
2279 {
2280         if (__pLinkEvent)
2281         {
2282                 IEventArg* pLinkEventArg = _LinkEvent::CreateLinkEventArgN(text, linkType, link);
2283                 SysTryReturn(NID_UI_CTRL, pLinkEventArg, E_OUT_OF_MEMORY, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] Unable to create _LinkEventArg.");
2284
2285                 __pLinkEvent->Fire(*pLinkEventArg);
2286         }
2287
2288         return E_SUCCESS;
2289 }
2290
2291 result
2292 _Edit::SendLanguageEvent(LanguageCode prevLanguageCode, LanguageCode currentLanguageCode)
2293 {
2294         if (__pLanguageEvent)
2295         {
2296                 IEventArg* pLanguageEventArg = _LanguageEvent::CreateLanguageEventArgN(prevLanguageCode, currentLanguageCode);
2297                 SysTryReturn(NID_UI_CTRL, pLanguageEventArg, E_OUT_OF_MEMORY, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] Memory shortage.");
2298
2299                 __pLanguageEvent->Fire(*pLanguageEventArg);
2300         }
2301
2302         return E_SUCCESS;
2303 }
2304
2305 result
2306 _Edit::AttachScrollPanelEvent(void)
2307 {
2308         _ScrollPanel* pScrollPanelCore = dynamic_cast<_ScrollPanel*>(GetParent());
2309         if (pScrollPanelCore)
2310         {
2311                 if (__pScrollPanelEvent)
2312                 {
2313                         pScrollPanelCore->SetScrollPanelEvent(__pScrollPanelEvent);
2314                 }
2315                 pScrollPanelCore->SetControlKeypadBinding(this);
2316         }
2317
2318         return E_SUCCESS;
2319 }
2320
2321 result
2322 _Edit::DetachScrollPanelEvent(void)
2323 {
2324         _ScrollPanel* pScrollPanelCore = dynamic_cast<_ScrollPanel*>(GetParent());
2325         if (pScrollPanelCore)
2326         {
2327                 if (__pScrollPanelEvent && (pScrollPanelCore->GetScrollPanelEvent() == __pScrollPanelEvent))
2328                 {
2329                         pScrollPanelCore->SetScrollPanelEvent(null);
2330                 }
2331                 pScrollPanelCore->SetControlKeypadBinding(null);
2332         }
2333
2334         return E_SUCCESS;
2335 }
2336
2337 bool
2338 _Edit::IsKeypadCommandButtonVisible(void) const
2339 {
2340         Variant var = GetProperty("overlayKeypadCommandButtonVisible");
2341
2342         return var.ToBool();
2343 }
2344
2345 String
2346 _Edit::GetKeypadCommandButtonText(CommandButtonPosition position) const
2347 {
2348         SysTryReturn(NID_UI_CTRL, (__inputStyle != INPUT_STYLE_FULLSCREEN), String(), E_SYSTEM, "[E_SYSTEM] Unable to show the keypad due to a wrong input style.");
2349
2350         return _pEditPresenter->GetKeypadCommandButtonText(position);
2351 }
2352
2353 int
2354 _Edit::GetKeypadCommandButtonActionId(CommandButtonPosition position) const
2355 {
2356         SysTryReturn(NID_UI_CTRL, (__inputStyle != INPUT_STYLE_FULLSCREEN), -1, E_SYSTEM, "[E_SYSTEM] Unable to show the keypad due to a wrong input style.");
2357
2358         return _pEditPresenter->GetKeypadCommandButtonActionId(position);
2359 }
2360
2361 result
2362 _Edit::GetCursorBounds(bool isAbsRect, Rectangle& cursorBounds) const
2363 {
2364         return _pEditPresenter->GetCursorBounds(isAbsRect, cursorBounds);
2365 }
2366
2367 int
2368 _Edit::GetCursorPositionAt(const Point& touchPoint) const
2369 {
2370         return _pEditPresenter->GetCursorPositionAt(touchPoint);
2371 }
2372
2373 void
2374 _Edit::SetCursorDisabled(bool disabled)
2375 {
2376         return _pEditPresenter->SetCursorDisabled(disabled);
2377 }
2378
2379 result
2380 _Edit::SetPropertyAutoResizingEnabled(const Variant& enable)
2381 {
2382         result r = E_SUCCESS;
2383
2384         r = _pEditPresenter->SetAutoResizingEnabled(enable.ToBool());
2385
2386         return r;
2387 }
2388
2389 Variant
2390 _Edit::GetPropertyAutoResizingEnabled(void) const
2391 {
2392         return Variant(_pEditPresenter->IsAutoResizingEnabled());
2393 }
2394
2395 result
2396 _Edit::SetPropertyCursorPosition(const Variant& position)
2397 {
2398         result r = E_SUCCESS;
2399         int textLength = GetTextLength();
2400         int cursorPos = position.ToInt();
2401
2402         SysTryReturn(NID_UI_CTRL, (cursorPos >= 0 && cursorPos <= textLength), E_OUT_OF_RANGE, E_OUT_OF_RANGE, "[E_OUT_OF_RANGE] This position is out of range.");
2403
2404         r = _pEditPresenter->SetCursorPosition(cursorPos);
2405
2406         return r;
2407 }
2408
2409 Variant
2410 _Edit::GetPropertyCursorPosition(void) const
2411 {
2412         return Variant(_pEditPresenter->GetCursorPosition());
2413 }
2414
2415 result
2416 _Edit::SetPropertyDisabledColor(const Variant& color)
2417 {
2418         __color[EDIT_STATUS_DISABLED].backgroundColor = color.ToColor();
2419
2420         return E_SUCCESS;
2421 }
2422
2423 Variant
2424 _Edit::GetPropertyDisabledColor(void) const
2425 {
2426         return Variant(__color[EDIT_STATUS_DISABLED].backgroundColor);
2427 }
2428
2429 result
2430 _Edit::SetPropertyDisabledTextColor(const Variant& color)
2431 {
2432         __color[EDIT_STATUS_DISABLED].textColor = color.ToColor();
2433
2434         return E_SUCCESS;
2435 }
2436
2437 Variant
2438 _Edit::GetPropertyDisabledTextColor(void) const
2439 {
2440         return Variant(__color[EDIT_STATUS_DISABLED].textColor);
2441 }
2442
2443 result
2444 _Edit::SetPropertyGuideText(const Variant& guideText)
2445 {
2446         if (__pTextAccessibilityElement)
2447         {
2448                 __pTextAccessibilityElement->SetLabel(guideText.ToString());
2449         }
2450
2451         return _pEditPresenter->SetGuideText(guideText.ToString());
2452 }
2453
2454 Variant
2455 _Edit::GetPropertyGuideText(void) const
2456 {
2457         return Variant(_pEditPresenter->GetGuideText());
2458 }
2459
2460 result
2461 _Edit::SetPropertyGuideTextColor(const Variant& color)
2462 {
2463         __guideTextColor = color.ToColor();
2464
2465         return E_SUCCESS;
2466 }
2467
2468 Variant
2469 _Edit::GetPropertyGuideTextColor(void) const
2470 {
2471         return Variant(__guideTextColor);
2472 }
2473
2474 result
2475 _Edit::SetPropertyKeypadActionEnabled(const Variant& enabled)
2476 {
2477         return _pEditPresenter->SetKeypadActionEnabled(enabled.ToBool());
2478 }
2479
2480 Variant
2481 _Edit::GetPropertyKeypadActionEnabled(void) const
2482 {
2483         return Variant(_pEditPresenter->IsKeypadActionEnabled());
2484 }
2485
2486 result
2487 _Edit::SetPropertyKeypadAction(const Variant& action)
2488 {
2489         SysTryReturn(NID_UI_CTRL, (__inputStyle == INPUT_STYLE_OVERLAY), E_UNSUPPORTED_OPERATION, E_UNSUPPORTED_OPERATION, "[E_UNSUPPORTED_OPERATION] The current state unable to this operation.");
2490
2491         result r = E_SUCCESS;
2492
2493         r = _pEditPresenter->SetKeypadAction((CoreKeypadAction)action.ToInt());
2494
2495         return r;
2496 }
2497
2498 Variant
2499 _Edit::GetPropertyKeypadAction(void) const
2500 {
2501         return Variant((int)_pEditPresenter->GetKeypadAction());
2502 }
2503
2504 result
2505 _Edit::SetPropertyLineSpacing(const Variant& lineSpacing)
2506 {
2507         __lineSpacing = lineSpacing.ToInt();
2508
2509         return E_SUCCESS;
2510 }
2511
2512 Variant
2513 _Edit::GetPropertyLineSpacing(void) const
2514 {
2515         return Variant(__lineSpacing);
2516 }
2517
2518 result
2519 _Edit::SetPropertyNormalColor(const Variant& color)
2520 {
2521         __color[EDIT_STATUS_NORMAL].backgroundColor = color.ToColor();
2522
2523         return E_SUCCESS;
2524 }
2525
2526 Variant
2527 _Edit::GetPropertyNormalColor(void) const
2528 {
2529         return Variant(__color[EDIT_STATUS_NORMAL].backgroundColor);
2530 }
2531
2532 result
2533 _Edit::SetPropertyPressedColor(const Variant& color)
2534 {
2535         __color[EDIT_STATUS_PRESSED].backgroundColor = color.ToColor();
2536
2537         return E_SUCCESS;
2538 }
2539
2540 Variant
2541 _Edit::GetPropertyPressedColor(void) const
2542 {
2543         return Variant(__color[EDIT_STATUS_PRESSED].backgroundColor);
2544 }
2545
2546 result
2547 _Edit::SetPropertyHighlightedColor(const Variant& color)
2548 {
2549         __color[EDIT_STATUS_HIGHLIGHTED].backgroundColor = color.ToColor();
2550
2551         return E_SUCCESS;
2552 }
2553
2554 Variant
2555 _Edit::GetPropertyHighlightedColor(void) const
2556 {
2557         return Variant(__color[EDIT_STATUS_HIGHLIGHTED].backgroundColor);
2558 }
2559
2560 result
2561 _Edit::SetPropertyTextSize(const Variant& textSize)
2562 {
2563         int fontMinSize = 0;
2564         int size = textSize.ToInt();
2565         result r = E_SUCCESS;
2566
2567         GET_FIXED_VALUE_CONFIG(EDIT::FONT_MIN_SIZE, _CONTROL_ORIENTATION_PORTRAIT, fontMinSize);
2568         SysTryReturn(NID_UI_CTRL, size >= fontMinSize, E_INVALID_ARG, E_INVALID_ARG, "[E_INVALID_ARG] The invalid size is given.");
2569
2570         r = _pEditPresenter->SetTextSize(size);
2571
2572         __textSize = size;
2573
2574         return r;
2575 }
2576
2577 Variant
2578 _Edit::GetPropertyTextSize(void) const
2579 {
2580         return Variant(__textSize);
2581 }
2582
2583 result
2584 _Edit::SetPropertyNormalTextColor(const Variant& color)
2585 {
2586         __color[EDIT_STATUS_NORMAL].textColor = color.ToColor();
2587
2588         return E_SUCCESS;
2589 }
2590
2591 Variant
2592 _Edit::GetPropertyNormalTextColor(void) const
2593 {
2594         return Variant(__color[EDIT_STATUS_NORMAL].textColor);
2595 }
2596
2597 result
2598 _Edit::SetPropertyHighlightedTextColor(const Variant& color)
2599 {
2600         __color[EDIT_STATUS_HIGHLIGHTED].textColor = color.ToColor();
2601
2602         return E_SUCCESS;
2603 }
2604
2605 Variant
2606 _Edit::GetPropertyHighlightedTextColor(void) const
2607 {
2608         return Variant(__color[EDIT_STATUS_HIGHLIGHTED].textColor);
2609 }
2610
2611 result
2612 _Edit::SetPropertyPressedTextColor(const Variant& color)
2613 {
2614         __color[EDIT_STATUS_PRESSED].textColor = color.ToColor();
2615
2616         return E_SUCCESS;
2617 }
2618
2619 Variant
2620 _Edit::GetPropertyPressedTextColor(void) const
2621 {
2622         return Variant(__color[EDIT_STATUS_PRESSED].textColor);
2623 }
2624
2625 result
2626 _Edit::SetPropertyKeypadEnabled(const Variant& enabled)
2627 {
2628         _pEditPresenter->SetKeypadEnabled(enabled.ToBool());
2629
2630         return E_SUCCESS;
2631 }
2632
2633 Variant
2634 _Edit::GetPropertyKeypadEnabled(void) const
2635 {
2636         return Variant(_pEditPresenter->IsKeypadEnabled());
2637 }
2638
2639 result
2640 _Edit::SetPropertyKeypadStyle(const Variant& style)
2641 {
2642         SysTryReturn(NID_UI_CTRL, (KEYPAD_STYLE_PASSWORD != (KeypadStyle)style.ToInt()), E_INVALID_ARG, E_INVALID_ARG, "[E_INVALID_ARG] The invalid argument is given.");
2643
2644         return _pEditPresenter->SetKeypadStyle((KeypadStyle)style.ToInt());
2645 }
2646
2647 Variant
2648 _Edit::GetPropertyKeypadStyle(void) const
2649 {
2650         return Variant((int)_pEditPresenter->GetKeypadStyle());
2651 }
2652
2653 result
2654 _Edit::SetPropertyLowerCaseModeEnabled(const Variant& enabled)
2655 {
2656         _pEditPresenter->SetLowerCaseModeEnabled(enabled.ToBool());
2657
2658         return E_SUCCESS;
2659 }
2660
2661 Variant
2662 _Edit::GetPropertyLowerCaseModeEnabled(void) const
2663 {
2664         return Variant(_pEditPresenter->IsLowerCaseModeEnabled());
2665 }
2666
2667 result
2668 _Edit::SetPropertyOverlayKeypadCommandButtonVisible(const Variant& visible)
2669 {
2670         return _pEditPresenter->SetKeypadCommandButtonVisible(visible.ToBool());
2671 }
2672
2673 Variant
2674 _Edit::GetPropertyOverlayKeypadCommandButtonVisible(void) const
2675 {
2676         return Variant(_pEditPresenter->IsKeypadCommandButtonVisible());
2677 }
2678
2679 result
2680 _Edit::SetPropertyText(const Variant& text)
2681 {
2682         return _pEditPresenter->SetText(text.ToString());
2683 }
2684
2685 Variant
2686 _Edit::GetPropertyText(void) const
2687 {
2688         return Variant(_pEditPresenter->GetText());
2689 }
2690
2691 result
2692 _Edit::SetPropertyViewModeEnabled(const Variant& enabled)
2693 {
2694         return _pEditPresenter->SetViewModeEnabled(enabled.ToBool());
2695 }
2696
2697 Variant
2698 _Edit::GetPropertyViewModeEnabled(void) const
2699 {
2700         return Variant(_pEditPresenter->IsViewModeEnabled());
2701 }
2702
2703 result
2704 _Edit::SetPropertyAutoLinkMask(const Variant& autoLinks)
2705 {
2706         SysTryReturn(NID_UI_CTRL, (__inputStyle == INPUT_STYLE_OVERLAY), E_UNSUPPORTED_OPERATION, E_UNSUPPORTED_OPERATION, "[E_UNSUPPORTED_OPERATION] The current state unable to this operation.");
2707
2708         return _pEditPresenter->SetAutoLinkMask(autoLinks.ToULong());
2709 }
2710
2711 Variant
2712 _Edit::GetPropertyAutoLinkMask(void) const
2713 {
2714         SysTryReturn(NID_UI_CTRL, (__inputStyle == INPUT_STYLE_OVERLAY), Variant((unsigned long)LINK_TYPE_NONE), E_UNSUPPORTED_OPERATION, "[E_UNSUPPORTED_OPERATION] The current state unable to this operation.");
2715
2716         return Variant(_pEditPresenter->GetAutoLinkMask());
2717 }
2718
2719 result
2720 _Edit::SetPropertyTitleText(const Variant& titleText)
2721 {
2722         return _pEditPresenter->SetTitleText(titleText.ToString());
2723 }
2724
2725 Variant
2726 _Edit::GetPropertyTitleText(void) const
2727 {
2728         return Variant(_pEditPresenter->GetTitleText());
2729 }
2730
2731 result
2732 _Edit::SetPropertyNormalTitleTextColor(const Variant& color)
2733 {
2734         __color[EDIT_STATUS_NORMAL].titleTextColor = color.ToColor();
2735
2736         return E_SUCCESS;
2737 }
2738
2739 Variant
2740 _Edit::GetPropertyNormalTitleTextColor(void) const
2741 {
2742         return Variant(__color[EDIT_STATUS_NORMAL].titleTextColor);
2743 }
2744
2745 result
2746 _Edit::SetPropertyDisabledTitleTextColor(const Variant& color)
2747 {
2748         __color[EDIT_STATUS_DISABLED].titleTextColor = color.ToColor();
2749
2750         return E_SUCCESS;
2751 }
2752
2753 Variant
2754 _Edit::GetPropertyDisabledTitleTextColor(void) const
2755 {
2756         return Variant(__color[EDIT_STATUS_DISABLED].titleTextColor);
2757 }
2758
2759 result
2760 _Edit::SetPropertyHighlightedTitleTextColor(const Variant& color)
2761 {
2762         __color[EDIT_STATUS_HIGHLIGHTED].titleTextColor = color.ToColor();
2763
2764         return E_SUCCESS;
2765 }
2766
2767 Variant
2768 _Edit::GetPropertyHighlightedTitleTextColor(void) const
2769 {
2770         return Variant(__color[EDIT_STATUS_HIGHLIGHTED].titleTextColor);
2771 }
2772
2773 result
2774 _Edit::SetPropertyPressedTitleTextColor(const Variant& color)
2775 {
2776         __color[EDIT_STATUS_PRESSED].titleTextColor = color.ToColor();
2777
2778         return E_SUCCESS;
2779 }
2780
2781 Variant
2782 _Edit::GetPropertyPressedTitleTextColor(void) const
2783 {
2784         return Variant(__color[EDIT_STATUS_PRESSED].titleTextColor);
2785 }
2786
2787 result
2788 _Edit::SetPropertyBlockedTextColor(const Variant& color)
2789 {
2790         __blockTextColor.blockTextColor = color.ToColor();
2791         __blockTextColor.used = true;
2792
2793         return E_SUCCESS;
2794 }
2795
2796 Variant
2797 _Edit::GetPropertyBlockedTextColor(void) const
2798 {
2799         return Variant(__blockTextColor.blockTextColor);
2800 }
2801
2802 result
2803 _Edit::SetPropertyTopMargin(const Variant& margin)
2804 {
2805         SysTryReturn(NID_UI_CTRL, margin.ToInt() > 0, E_INVALID_ARG, E_INVALID_ARG, "[E_INVALID_ARG] The invalid argument is given.");
2806
2807         __topMargin = margin.ToInt();
2808
2809         return E_SUCCESS;
2810 }
2811
2812 Variant
2813 _Edit::GetPropertyTopMargin(void) const
2814 {
2815         return Variant(__topMargin);
2816 }
2817
2818 result
2819 _Edit::SetPropertyBottomMargin(const Variant& margin)
2820 {
2821         SysTryReturn(NID_UI_CTRL, margin.ToInt() > 0, E_INVALID_ARG, E_INVALID_ARG, "[E_INVALID_ARG] The invalid argument is given.");
2822
2823         __bottomMargin = margin.ToInt();
2824
2825         return E_SUCCESS;
2826 }
2827
2828 Variant
2829 _Edit::GetPropertyBottomMargin(void) const
2830 {
2831         return Variant(__bottomMargin);
2832 }
2833
2834 result
2835 _Edit::SetPropertyLeftMargin(const Variant& margin)
2836 {
2837         SysTryReturn(NID_UI_CTRL, margin.ToInt() > 0, E_INVALID_ARG, E_INVALID_ARG, "[E_INVALID_ARG] The invalid argument is given.");
2838
2839         __leftMargin = margin.ToInt();
2840
2841         return E_SUCCESS;
2842 }
2843
2844 Variant
2845 _Edit::GetPropertyLeftMargin(void) const
2846 {
2847         return Variant(__leftMargin);
2848 }
2849
2850 result
2851 _Edit::SetPropertyRightMargin(const Variant& margin)
2852 {
2853         SysTryReturn(NID_UI_CTRL, margin.ToInt() > 0, E_INVALID_ARG, E_INVALID_ARG, "[E_INVALID_ARG] The invalid argument is given.");
2854
2855         __rightMargin = margin.ToInt();
2856
2857         return E_SUCCESS;
2858 }
2859
2860 Variant
2861 _Edit::GetPropertyRightMargin(void) const
2862 {
2863         return Variant(__rightMargin);
2864 }
2865
2866 }}} // Tizen::Ui::Controls