src/ui/controls/FUiCtrl_EditFieldImpl.cpp

   1 //
   2 // Open Service Platform
   3 // Copyright (c) 2012-2013 Samsung Electronics Co., Ltd.
   4 //
   5 // Licensed under the Apache License, Version 2.0 (the License);
   6 // you may not use this file except in compliance with the License.
   7 // You may obtain a copy of the License at
   8 //
   9 //     http://www.apache.org/licenses/LICENSE-2.0/
  10 //
  11 // Unless required by applicable law or agreed to in writing, software
  12 // distributed under the License is distributed on an "AS IS" BASIS,
  13 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  14 // See the License for the specific language governing permissions and
  15 // limitations under the License.
  16 //
  17
  18 /**
  19  * @file        FUiCtrl_EditFieldImpl.cpp
  20  * @brief       This file contains implementation of _EditFieldImpl class
  21  */
  22
  23 #include <FApp_AppInfo.h>
  24 #include <FBaseSysLog.h>
  25 #include <FBaseInternalTypes.h>
  26 #include <FBase_LocalizedNumParser.h>
  27 #include <FUiAccessibilityContainer.h>
  28 #include <FUiAccessibilityElement.h>
  29 #include <FUiCtrlEditField.h>
  30 #include <FUiCtrlInputTypes.h>
  31 #include <FUiITouchEventListener.h>
  32 #include "FUi_ControlImpl.h"
  33 #include "FUi_CoordinateSystemUtils.h"
  34 #include "FUi_IFocusEventListener.h"
  35 #include "FUi_ResourceSizeInfo.h"
  36 #include "FUi_UiBuilder.h"
  37 #include "FUiCtrl_Edit.h"
  38 #include "FUiCtrl_EditFieldImpl.h"
  39 #include "FUiCtrl_PublicActionEvent.h"
  40 #include "FUiCtrl_PublicKeypadEvent.h"
  41 #include "FUiCtrl_PublicLanguageEvent.h"
  42 #include "FUiCtrl_PublicLinkEvent.h"
  43 #include "FUiCtrl_PublicScrollPanelEvent.h"
  44 #include "FUiCtrl_PublicTextBlockEvent.h"
  45 #include "FUiCtrl_PublicTextEvent.h"
  46 #include "FUi_CoordinateSystemUtils.h"
  47
  48 using namespace Tizen::App;
  49 using namespace Tizen::Base;
  50 using namespace Tizen::Base::Runtime;
  51 using namespace Tizen::Base::Utility;
  52 using namespace Tizen::Graphics;
  53 using namespace Tizen::Locales;
  54 using namespace Tizen::Ui;
  55
  56 namespace Tizen { namespace Ui { namespace Controls
  57 {
  58
  59 _EditFieldImpl::EditFieldSizeInfo::EditFieldSizeInfo(void)
  60         :__titleStyle(EDIT_FIELD_TITLE_STYLE_NONE)
  61         , __smallStyle(false)
  62 {
  63 }
  64
  65 Dimension
  66 _EditFieldImpl::EditFieldSizeInfo::GetDefaultMinimumSize(_ControlOrientation orientation) const
  67 {
  68         result r = E_SUCCESS;
  69         Dimension editFieldMinimumSize(0, 0);
  70
  71         if (__smallStyle)
  72         {
  73                 r = GET_DIMENSION_CONFIG(EDIT::SMALL_STYLE_MIN_SIZE, orientation, editFieldMinimumSize);
  74                 SysTryReturn(NID_UI, r == E_SUCCESS, editFieldMinimumSize, r, "System Error occurred.");
  75         }
  76         else if (__titleStyle == EDIT_FIELD_TITLE_STYLE_TOP)
  77         {
  78                 r = GET_DIMENSION_CONFIG(EDIT::TITLE_STYLE_MIN_SIZE, orientation, editFieldMinimumSize);
  79                 SysTryReturn(NID_UI, r == E_SUCCESS, editFieldMinimumSize, r, "System Error occurred.");
  80         }
  81         else
  82         {
  83                 r = GET_DIMENSION_CONFIG(EDIT::MIN_SIZE, orientation, editFieldMinimumSize);
  84                 SysTryReturn(NID_UI, r == E_SUCCESS, editFieldMinimumSize, r, "System Error occurred.");
  85         }
  86
  87         return editFieldMinimumSize;
  88 }
  89
  90 FloatDimension
  91 _EditFieldImpl::EditFieldSizeInfo::GetDefaultMinimumSizeF(_ControlOrientation orientation) const
  92 {
  93         result r = E_SUCCESS;
  94         FloatDimension editFieldMinimumSize(0.0f, 0.0f);
  95
  96         if (__smallStyle)
  97         {
  98                 r = GET_DIMENSION_CONFIG(EDIT::SMALL_STYLE_MIN_SIZE, orientation, editFieldMinimumSize);
  99                 SysTryReturn(NID_UI, r == E_SUCCESS, editFieldMinimumSize, r, "System Error occurred.");
 100         }
 101         else if (__titleStyle == EDIT_FIELD_TITLE_STYLE_TOP)
 102         {
 103                 r = GET_DIMENSION_CONFIG(EDIT::TITLE_STYLE_MIN_SIZE, orientation, editFieldMinimumSize);
 104                 SysTryReturn(NID_UI, r == E_SUCCESS, editFieldMinimumSize, r, "System Error occurred.");
 105         }
 106         else
 107         {
 108                 r = GET_DIMENSION_CONFIG(EDIT::MIN_SIZE, orientation, editFieldMinimumSize);
 109                 SysTryReturn(NID_UI, r == E_SUCCESS, editFieldMinimumSize, r, "System Error occurred.");
 110         }
 111
 112         return editFieldMinimumSize;
 113 }
 114
 115 void
 116 _EditFieldImpl::EditFieldSizeInfo::SetTitleStyle(EditFieldTitleStyle titleStyle)
 117 {
 118         __titleStyle = titleStyle;
 119 }
 120
 121 void
 122 _EditFieldImpl::EditFieldSizeInfo::SetSmallStyle(bool isSmallStyle)
 123 {
 124         __smallStyle = isSmallStyle;
 125 }
 126
 127
 128 _EditFieldImpl*
 129 _EditFieldImpl::GetInstance(EditField& editField)
 130 {
 131         return (static_cast<_EditFieldImpl*> (editField._pControlImpl));
 132 }
 133
 134 const _EditFieldImpl*
 135 _EditFieldImpl::GetInstance(const EditField& editField)
 136 {
 137         return (static_cast<const _EditFieldImpl*> (editField._pControlImpl));
 138 }
 139
 140 _EditFieldImpl::_EditFieldImpl(EditField* pPublic, _Edit* pCore)
 141         : _ControlImpl(pPublic, pCore)
 142         , __pEdit(pCore)
 143         , __editFieldStyle(EDIT_FIELD_STYLE_NORMAL)
 144         , __inputStyle(INPUT_STYLE_OVERLAY)
 145         , __inputModeCategory(EDIT_INPUTMODE_ALPHA | EDIT_INPUTMODE_PREDICTIVE | EDIT_INPUTMODE_NUMERIC | EDIT_INPUTMODE_SYMBOL)
 146         , __currentInputMode(EDIT_INPUTMODE_ALPHA)
 147         , __pPublicActionEvent(null)
 148         , __pPublicKeypadEvent(null)
 149         , __pPublicLanguageEvent(null)
 150         , __pPublicLinkEvent(null)
 151         , __pPublicScrollPanelEvent(null)
 152         , __pPublicTextBlockEvent(null)
 153         , __pPublicTextEvent(null)
 154         , __autoLinkMask(LINK_TYPE_NONE)
 155 {
 156 }
 157
 158 _EditFieldImpl::~_EditFieldImpl(void)
 159 {
 160         if (__pEdit)
 161         {
 162                 __pEdit->RemoveTextEventListener(*this);
 163                 __pEdit->RemoveActionEventListener(*this);
 164                 __pEdit->RemoveTextBlockEventListener(*this);
 165                 __pEdit->RemoveUiLinkEventListener(*this);
 166                 __pEdit->RemoveKeypadEventListener(*this);
 167                 __pEdit->RemoveActionEventListener(*this);
 168                 if (__pEdit->GetInputStyle() == INPUT_STYLE_OVERLAY)
 169                 {
 170                         __pEdit->RemoveScrollPanelEventListener(*this);
 171                 }
 172         }
 173
 174         if (__pPublicTextEvent)
 175         {
 176                 delete __pPublicTextEvent;
 177                 __pPublicTextEvent = null;
 178         }
 179
 180         if (__pPublicActionEvent)
 181         {
 182                 delete __pPublicActionEvent;
 183                 __pPublicActionEvent = null;
 184         }
 185
 186         if (__pPublicTextBlockEvent)
 187         {
 188                 delete __pPublicTextBlockEvent;
 189                 __pPublicTextBlockEvent = null;
 190         }
 191
 192         if (__pPublicLinkEvent)
 193         {
 194                 delete __pPublicLinkEvent;
 195                 __pPublicLinkEvent = null;
 196         }
 197
 198         if (__pPublicKeypadEvent)
 199         {
 200                 delete __pPublicKeypadEvent;
 201                 __pPublicKeypadEvent = null;
 202         }
 203
 204         if (__pPublicLanguageEvent)
 205         {
 206                 delete __pPublicLanguageEvent;
 207                 __pPublicLanguageEvent = null;
 208         }
 209
 210         if (__pPublicScrollPanelEvent)
 211         {
 212                 delete __pPublicScrollPanelEvent;
 213                 __pPublicScrollPanelEvent = null;
 214         }
 215 }
 216
 217 _EditFieldImpl*
 218 _EditFieldImpl::CreateEditFieldImplN(EditField* pControl, const Rectangle& rect, EditFieldStyle style, EditFieldTitleStyle titleStyle)
 219 {
 220         ClearLastResult();
 221
 222         result r = E_SUCCESS;
 223
 224         bool isSmallStyle = false;
 225
 226         if (style == EDIT_FIELD_STYLE_NORMAL_SMALL || style == EDIT_FIELD_STYLE_PASSWORD_SMALL
 227                         || style == EDIT_FIELD_STYLE_EMAIL_SMALL || style == EDIT_FIELD_STYLE_URL_SMALL
 228                         || style == EDIT_FIELD_STYLE_IP_V4_SMALL || style == EDIT_FIELD_STYLE_PHONE_NUMBER_SMALL
 229                         || style == EDIT_FIELD_STYLE_NUMBER_SMALL || style == EDIT_FIELD_STYLE_PASSWORD_NUMBER_SMALL)
 230         {
 231                 isSmallStyle = true;
 232         }
 233
 234         _Edit* pCore = _Edit::CreateEditN();
 235         SysTryReturn(NID_UI_CTRL, pCore, null, GetLastResult(), "[%s] Propagating.", GetErrorMessage(GetLastResult()));
 236
 237         _EditFieldImpl* pImpl = new (std::nothrow) _EditFieldImpl(pControl, pCore);
 238         r = _ControlImpl::CheckConstruction(pCore, pImpl);
 239         SysTryReturn(NID_UI_CTRL, r == E_SUCCESS, null, r, "[%s] Propagating.", GetErrorMessage(r));
 240
 241         return pImpl;
 242 }
 243
 244 _EditFieldImpl*
 245 _EditFieldImpl::CreateEditFieldImplN(EditField* pControl, const FloatRectangle& rect, EditFieldStyle style, EditFieldTitleStyle titleStyle)
 246 {
 247         ClearLastResult();
 248
 249         result r = E_SUCCESS;
 250
 251         bool isSmallStyle = false;
 252
 253         if (style == EDIT_FIELD_STYLE_NORMAL_SMALL || style == EDIT_FIELD_STYLE_PASSWORD_SMALL
 254                         || style == EDIT_FIELD_STYLE_EMAIL_SMALL || style == EDIT_FIELD_STYLE_URL_SMALL
 255                         || style == EDIT_FIELD_STYLE_IP_V4_SMALL || style == EDIT_FIELD_STYLE_PHONE_NUMBER_SMALL
 256                         || style == EDIT_FIELD_STYLE_NUMBER_SMALL || style == EDIT_FIELD_STYLE_PASSWORD_NUMBER_SMALL)
 257         {
 258                 isSmallStyle = true;
 259         }
 260
 261         _Edit* pCore = _Edit::CreateEditN();
 262         SysTryReturn(NID_UI_CTRL, pCore, null, GetLastResult(), "[%s] Propagating.", GetErrorMessage(GetLastResult()));
 263
 264         _EditFieldImpl* pImpl = new (std::nothrow) _EditFieldImpl(pControl, pCore);
 265         r = _ControlImpl::CheckConstruction(pCore, pImpl);
 266         SysTryReturn(NID_UI_CTRL, r == E_SUCCESS, null, r, "[%s] Propagating.", GetErrorMessage(r));
 267
 268         return pImpl;
 269 }
 270
 271 const char*
 272 _EditFieldImpl::GetPublicClassName(void) const
 273 {
 274         return "Tizen::Ui::Controls::EditField";
 275 }
 276
 277 const EditField&
 278 _EditFieldImpl::GetPublic(void) const
 279 {
 280         return static_cast <const EditField&>(_ControlImpl::GetPublic());
 281 }
 282
 283 EditField&
 284 _EditFieldImpl::GetPublic(void)
 285 {
 286         return static_cast <EditField&>(_ControlImpl::GetPublic());
 287 }
 288
 289 const _Edit&
 290 _EditFieldImpl::GetCore(void) const
 291 {
 292         return static_cast <const _Edit&>(_ControlImpl::GetCore());
 293 }
 294
 295 _Edit&
 296 _EditFieldImpl::GetCore(void)
 297 {
 298         return static_cast <_Edit&>(_ControlImpl::GetCore());
 299 }
 300
 301 result
 302 _EditFieldImpl::Initialize(EditFieldStyle style, InputStyle inputStyle,
 303                                                   EditFieldTitleStyle titleStlye, bool enableClear, int limitLength,
 304                                                   GroupStyle groupStyle)
 305 {
 306         result r = E_SUCCESS;
 307
 308         int editfieldStyle = EDIT_STYLE_NORMAL | EDIT_STYLE_SINGLE_LINE | EDIT_STYLE_NOSCROLL;
 309         bool isSmallStyle = false;
 310         EditFieldStyle tempStyle = style;
 311         KeypadStyle keypadStyle = KEYPAD_STYLE_NORMAL;
 312         Variant variantKeypadStyle = (int)KEYPAD_STYLE_NORMAL;
 313
 314         if (style == EDIT_FIELD_STYLE_NORMAL_SMALL || style == EDIT_FIELD_STYLE_PASSWORD_SMALL
 315                 || style == EDIT_FIELD_STYLE_EMAIL_SMALL || style == EDIT_FIELD_STYLE_URL_SMALL
 316                 || style == EDIT_FIELD_STYLE_IP_V4_SMALL || style == EDIT_FIELD_STYLE_PHONE_NUMBER_SMALL
 317                 || style == EDIT_FIELD_STYLE_NUMBER_SMALL || style == EDIT_FIELD_STYLE_PASSWORD_NUMBER_SMALL)
 318         {
 319                 isSmallStyle = true;
 320                 switch (style)
 321                 {
 322                 case EDIT_FIELD_STYLE_EMAIL_SMALL:
 323                         tempStyle = EDIT_FIELD_STYLE_EMAIL;
 324                         break;
 325
 326                 case EDIT_FIELD_STYLE_PASSWORD_SMALL:
 327                         tempStyle = EDIT_FIELD_STYLE_PASSWORD;
 328                         break;
 329
 330                 case EDIT_FIELD_STYLE_URL_SMALL:
 331                         tempStyle = EDIT_FIELD_STYLE_URL;
 332                         break;
 333
 334                 case EDIT_FIELD_STYLE_NUMBER_SMALL:
 335                         tempStyle = EDIT_FIELD_STYLE_NUMBER;
 336                         break;
 337
 338                 case EDIT_FIELD_STYLE_PHONE_NUMBER_SMALL:
 339                         tempStyle = EDIT_FIELD_STYLE_PHONE_NUMBER;
 340                         break;
 341
 342                 case EDIT_FIELD_STYLE_PASSWORD_NUMBER_SMALL:
 343                         tempStyle = EDIT_FIELD_STYLE_PASSWORD_NUMBER;
 344                         break;
 345
 346                 case EDIT_FIELD_STYLE_IP_V4_SMALL:
 347                         tempStyle = EDIT_FIELD_STYLE_IP_V4;
 348                         break;
 349
 350                 default:
 351                         break;
 352                 }
 353         }
 354
 355
 356
 357         if (tempStyle == EDIT_FIELD_STYLE_PASSWORD || tempStyle == EDIT_FIELD_STYLE_PASSWORD_NUMBER)
 358         {
 359                 editfieldStyle |= EDIT_STYLE_PASSWORD;
 360         }
 361
 362         if (isSmallStyle && (titleStlye != EDIT_FIELD_TITLE_STYLE_NONE))
 363         {
 364                 r = E_UNSUPPORTED_OPTION;
 365                 SysLogException(NID_UI_CTRL, E_UNSUPPORTED_OPTION, "[E_UNSUPPORTED_OPTION] Unsupported operation.");
 366                 return r;
 367         }
 368
 369         if (titleStlye == EDIT_FIELD_TITLE_STYLE_INNER)
 370         {
 371                 editfieldStyle |= EDIT_STYLE_TITLE_LEFT;
 372         }
 373         else if (titleStlye == EDIT_FIELD_TITLE_STYLE_TOP)
 374         {
 375                 editfieldStyle |= EDIT_STYLE_TITLE_TOP;
 376         }
 377
 378         if (enableClear)
 379         {
 380                 editfieldStyle |= EDIT_STYLE_CLEAR;
 381         }
 382
 383         __inputStyle = inputStyle;
 384         __editFieldStyle = tempStyle;
 385
 386         r = __pEdit->Initialize(editfieldStyle, inputStyle, limitLength, groupStyle);
 387         if (r != E_SUCCESS)
 388         {
 389                 return r;
 390         }
 391
 392         if (!_AppInfo::IsOspCompat())
 393         {
 394                 __pEdit->SetKeypadCommandButtonVisible(false);
 395         }
 396
 397         switch (tempStyle)
 398         {
 399         case EDIT_FIELD_STYLE_EMAIL :
 400                 keypadStyle = KEYPAD_STYLE_EMAIL;
 401                 break;
 402
 403         case EDIT_FIELD_STYLE_URL :
 404                 keypadStyle = KEYPAD_STYLE_URL;
 405                 break;
 406
 407         case EDIT_FIELD_STYLE_NUMBER :
 408                 keypadStyle = KEYPAD_STYLE_NUMBER;
 409                 break;
 410
 411         case EDIT_FIELD_STYLE_PHONE_NUMBER :
 412                 keypadStyle = KEYPAD_STYLE_PHONE_NUMBER;
 413                 break;
 414
 415         case EDIT_FIELD_STYLE_PASSWORD_NUMBER :
 416                 keypadStyle = KEYPAD_STYLE_NUMBER;
 417                 break;
 418
 419         case EDIT_FIELD_STYLE_IP_V4 :
 420                 keypadStyle = KEYPAD_STYLE_IP_V4;
 421                 break;
 422
 423         case EDIT_FIELD_STYLE_PASSWORD :
 424                 keypadStyle = KEYPAD_STYLE_PASSWORD;
 425                 break;
 426
 427         default:
 428                 break;
 429         }
 430
 431         variantKeypadStyle = (int) keypadStyle;
 432         __pEdit->SetPropertyKeypadStyle(variantKeypadStyle);
 433
 434         __pPublicActionEvent = _PublicActionEvent::CreateInstanceN(GetPublic());
 435         SysTryReturn(NID_UI_CTRL, __pPublicActionEvent, E_OUT_OF_MEMORY, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] Memory allocation failed.");
 436
 437         r = __pEdit->AddActionEventListener(*this);
 438         SysTryReturn(NID_UI_CTRL, r == E_SUCCESS, r, r, "[%s] Propagating.", GetErrorMessage(r));
 439
 440         __pPublicLinkEvent = _PublicLinkEvent::CreateInstanceN(GetPublic());
 441         SysTryReturn(NID_UI_CTRL, __pPublicLinkEvent, E_OUT_OF_MEMORY, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] Memory allocation failed.");
 442
 443         r = __pEdit->AddUiLinkEventListener(*this);
 444         SysTryReturn(NID_UI_CTRL, r == E_SUCCESS, r, r, "[%s] Propagating.", GetErrorMessage(r));
 445
 446         __pPublicTextBlockEvent = _PublicTextBlockEvent::CreateInstanceN(GetPublic());
 447         SysTryReturn(NID_UI_CTRL, __pPublicTextBlockEvent, E_OUT_OF_MEMORY, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] Memory allocation failed.");
 448
 449         r = __pEdit->AddTextBlockEventListener(*this);
 450         SysTryReturn(NID_UI_CTRL, r == E_SUCCESS, r, r, "[%s] Propagating.", GetErrorMessage(r));
 451
 452         __pPublicKeypadEvent = _PublicKeypadEvent::CreateInstanceN(GetPublic());
 453         SysTryReturn(NID_UI_CTRL, __pPublicKeypadEvent, E_OUT_OF_MEMORY, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] Memory allocation failed.");
 454
 455         r = __pEdit->AddKeypadEventListener(*this);
 456         SysTryReturn(NID_UI_CTRL, r == E_SUCCESS, r, r, "[%s] Propagating.", GetErrorMessage(r));
 457
 458         __pPublicTextEvent = _PublicTextEvent::CreateInstanceN(GetPublic());
 459         SysTryReturn(NID_UI_CTRL, __pPublicTextEvent, E_OUT_OF_MEMORY, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] Memory allocation failed.");
 460
 461         r = __pEdit->AddTextEventListener(*this);
 462         SysTryReturn(NID_UI_CTRL, r == E_SUCCESS, r, r, "[%s] Propagating.", GetErrorMessage(r));
 463
 464         __pPublicScrollPanelEvent = _PublicScrollPanelEvent::CreateInstanceN(GetPublic());
 465         SysTryReturn(NID_UI_CTRL, __pPublicScrollPanelEvent, E_OUT_OF_MEMORY, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] Memory allocation failed.");
 466
 467         if (inputStyle == INPUT_STYLE_OVERLAY)
 468         {
 469                 r = __pEdit->AddScrollPanelEventListener(*this);
 470                 SysTryReturn(NID_UI_CTRL, r == E_SUCCESS, r, r, "[%s] Propagating.", GetErrorMessage(r));
 471         }
 472
 473         __pPublicLanguageEvent = _PublicLanguageEvent::CreateInstanceN(GetPublic());
 474         SysTryReturn(NID_UI_CTRL, __pPublicLanguageEvent, E_OUT_OF_MEMORY, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] Memory allocation failed.");
 475
 476         r = __pEdit->AddLanguageEventListener(*this);
 477         SysTryReturn(NID_UI_CTRL, r == E_SUCCESS, r, r, "[%s] Propagating.", GetErrorMessage(r));
 478
 479         if (inputStyle == INPUT_STYLE_OVERLAY)
 480         {
 481                 __pEdit->SetAutoLinkMask(LINK_TYPE_URL | LINK_TYPE_EMAIL | LINK_TYPE_TEL_NUM);
 482         }
 483
 484         return r;
 485 }
 486
 487 result
 488 _EditFieldImpl::Dispose(void)
 489 {
 490         result r = E_SUCCESS;
 491
 492         if (__pEdit)
 493         {
 494                 delete __pEdit;
 495                 __pEdit = null;
 496         }
 497
 498         return r;
 499 }
 500
 501 HorizontalAlignment
 502 _EditFieldImpl::GetTextAlignment(void) const
 503 {
 504         return __pEdit->GetTextAlignment();
 505 }
 506
 507 result
 508 _EditFieldImpl::SetTextAlignment(HorizontalAlignment alignment)
 509 {
 510         return __pEdit->SetTextAlignment(alignment);
 511 }
 512
 513 bool
 514 _EditFieldImpl::IsViewModeEnabled(void) const
 515 {
 516         return __pEdit->GetPropertyViewModeEnabled().ToBool();
 517 }
 518
 519 result
 520 _EditFieldImpl::SetViewModeEnabled(bool enable)
 521 {
 522         Variant variantEnable(enable);
 523
 524         return __pEdit->SetPropertyViewModeEnabled(variantEnable);
 525 }
 526
 527 result
 528 _EditFieldImpl::SetAutoLinkMask(unsigned long autoLinks)
 529 {
 530         result r = E_SUCCESS;
 531         Variant variantAutoLinks(autoLinks);
 532
 533         r =  __pEdit->SetPropertyAutoLinkMask(variantAutoLinks);
 534
 535         if (r == E_SUCCESS)
 536         {
 537                 __autoLinkMask = autoLinks;
 538         }
 539
 540         return r;
 541 }
 542
 543 unsigned long
 544 _EditFieldImpl::GetAutoLinkMask(void) const
 545 {
 546         SysTryReturn(NID_UI_CTRL, (__inputStyle == INPUT_STYLE_OVERLAY), LINK_TYPE_NONE, E_UNSUPPORTED_OPERATION, "[E_UNSUPPORTED_OPERATION] The current state unable to this operation.");
 547         return __autoLinkMask;
 548 }
 549
 550 int
 551 _EditFieldImpl::GetMargin(EditMarginType marginType) const
 552 {
 553         return _CoordinateSystemUtils::ConvertToInteger(GetMarginF(marginType));
 554 }
 555
 556 float
 557 _EditFieldImpl::GetMarginF(EditMarginType marginType) const
 558 {
 559         if (marginType == EDIT_MARGIN_TYPE_VERTICAL)
 560         {
 561                 return __pEdit->GetVerticalMarginF(EDIT_TEXT_TOP_MARGIN);
 562         }
 563         else
 564         {
 565                 return __pEdit->GetHorizontalMarginF(EDIT_TEXT_LEFT_MARGIN);
 566         }
 567 }
 568
 569 result
 570 _EditFieldImpl::SetMargin(EditMarginType marginType, int margin)
 571 {
 572         return SetMargin(marginType, _CoordinateSystemUtils::ConvertToFloat(margin));
 573 }
 574
 575 result
 576 _EditFieldImpl::SetMargin(EditMarginType marginType, float margin)
 577 {
 578         result r = E_SUCCESS;
 579         Variant varMargin(margin);
 580
 581         if (marginType == EDIT_MARGIN_TYPE_HORIZONTAL)
 582         {
 583                 r = __pEdit->SetHorizontalMargin(margin, EDIT_TEXT_LEFT_MARGIN);
 584                 SysTryReturn(NID_UI_CTRL, r == E_SUCCESS, r, r, "[%s] Propagating.", GetErrorMessage(r));
 585                 r = __pEdit->SetHorizontalMargin(margin, EDIT_TEXT_RIGHT_MARGIN);
 586                 SysTryReturn(NID_UI_CTRL, r == E_SUCCESS, r, r, "[%s] Propagating.", GetErrorMessage(r));
 587         }
 588         else
 589         {
 590                 r = __pEdit->SetVerticalMargin(margin, EDIT_TEXT_TOP_MARGIN);
 591                 SysTryReturn(NID_UI_CTRL, r == E_SUCCESS, r, r, "[%s] Propagating.", GetErrorMessage(r));
 592                 r = __pEdit->SetVerticalMargin(margin, EDIT_TEXT_BOTTOM_MARGIN);
 593                 SysTryReturn(NID_UI_CTRL, r == E_SUCCESS, r, r, "[%s] Propagating.", GetErrorMessage(r));
 594         }
 595
 596         return r;
 597 }
 598
 599 result
 600 _EditFieldImpl::SetKeypadActionEnabled(bool enable)
 601 {
 602         Variant variantEnable(enable);
 603
 604         return __pEdit->SetPropertyKeypadActionEnabled(variantEnable);
 605 }
 606
 607 bool
 608 _EditFieldImpl::IsKeypadActionEnabled(void) const
 609 {
 610         return __pEdit->GetPropertyKeypadActionEnabled().ToBool();
 611 }
 612
 613 KeypadAction
 614 _EditFieldImpl::GetKeypadAction(void) const
 615 {
 616         CoreKeypadAction coreKeypadAction = (CoreKeypadAction)__pEdit->GetPropertyKeypadAction().ToInt();
 617         KeypadAction publicKeypadAction = KEYPAD_ACTION_ENTER;
 618
 619         switch (coreKeypadAction)
 620         {
 621         case CORE_KEYPAD_ACTION_ENTER:
 622                 publicKeypadAction = KEYPAD_ACTION_ENTER;
 623                 break;
 624
 625         case CORE_KEYPAD_ACTION_GO:
 626                 publicKeypadAction = KEYPAD_ACTION_GO;
 627                 break;
 628
 629         case CORE_KEYPAD_ACTION_NEXT:
 630                 publicKeypadAction = KEYPAD_ACTION_NEXT;
 631                 break;
 632
 633         case CORE_KEYPAD_ACTION_SEND:
 634                 publicKeypadAction = KEYPAD_ACTION_SEND;
 635                 break;
 636
 637         case CORE_KEYPAD_ACTION_SEARCH:
 638                 publicKeypadAction = KEYPAD_ACTION_SEARCH;
 639                 break;
 640
 641         case CORE_KEYPAD_ACTION_LOGIN:
 642                 publicKeypadAction = KEYPAD_ACTION_LOGIN;
 643                 break;
 644
 645         case CORE_KEYPAD_ACTION_SIGN_IN:
 646                 publicKeypadAction = KEYPAD_ACTION_SIGN_IN;
 647                 break;
 648
 649         case CORE_KEYPAD_ACTION_JOIN:
 650                 publicKeypadAction = KEYPAD_ACTION_JOIN;
 651                 break;
 652
 653         case CORE_KEYPAD_ACTION_DONE:
 654                 publicKeypadAction = KEYPAD_ACTION_DONE;
 655                 break;
 656
 657         default:
 658                 break;
 659         }
 660
 661         return publicKeypadAction;
 662 }
 663
 664 result
 665 _EditFieldImpl::SetKeypadAction(KeypadAction keypadAction)
 666 {
 667         CoreKeypadAction coreKeypadAction = CORE_KEYPAD_ACTION_ENTER;
 668
 669         switch (keypadAction)
 670         {
 671         case KEYPAD_ACTION_ENTER:
 672                 coreKeypadAction = CORE_KEYPAD_ACTION_ENTER;
 673                 break;
 674
 675         case KEYPAD_ACTION_GO:
 676                 coreKeypadAction = CORE_KEYPAD_ACTION_GO;
 677                 break;
 678
 679         case KEYPAD_ACTION_NEXT:
 680                 coreKeypadAction = CORE_KEYPAD_ACTION_NEXT;
 681                 break;
 682
 683         case KEYPAD_ACTION_SEND:
 684                 coreKeypadAction = CORE_KEYPAD_ACTION_SEND;
 685                 break;
 686
 687         case KEYPAD_ACTION_SEARCH:
 688                 coreKeypadAction = CORE_KEYPAD_ACTION_SEARCH;
 689                 break;
 690
 691         case KEYPAD_ACTION_LOGIN:
 692                 coreKeypadAction = CORE_KEYPAD_ACTION_LOGIN;
 693                 break;
 694
 695         case KEYPAD_ACTION_SIGN_IN:
 696                 coreKeypadAction = CORE_KEYPAD_ACTION_SIGN_IN;
 697                 break;
 698
 699         case KEYPAD_ACTION_JOIN:
 700                 coreKeypadAction = CORE_KEYPAD_ACTION_JOIN;
 701                 break;
 702
 703         case KEYPAD_ACTION_DONE:
 704                 coreKeypadAction = CORE_KEYPAD_ACTION_DONE;
 705                 break;
 706
 707         default:
 708                 break;
 709         }
 710
 711         Variant variantKeypadAction((int)coreKeypadAction);
 712
 713         return __pEdit->SetPropertyKeypadAction(variantKeypadAction);
 714 }
 715
 716 KeypadStyle
 717 _EditFieldImpl::GetKeypadStyle(void) const
 718 {
 719         return (KeypadStyle)__pEdit->GetPropertyKeypadStyle().ToInt();
 720 }
 721
 722 result
 723 _EditFieldImpl::SetOverlayKeypadCommandButtonVisible(bool visible)
 724 {
 725         Variant variantVisible(visible);
 726
 727         return __pEdit->SetPropertyOverlayKeypadCommandButtonVisible(variantVisible);
 728 }
 729
 730 bool
 731 _EditFieldImpl::IsOverlayCommandButtonVisible(void) const
 732 {
 733         return __pEdit->GetPropertyOverlayKeypadCommandButtonVisible().ToBool();
 734 }
 735
 736 result
 737 _EditFieldImpl::HideKeypad(void)
 738 {
 739         return __pEdit->HideKeypad();
 740 }
 741
 742 EllipsisPosition
 743 _EditFieldImpl::GetEllipsisPosition(void) const
 744 {
 745         return __pEdit->GetEllipsisPosition();
 746 }
 747
 748 result
 749 _EditFieldImpl::SetEllipsisPosition(EllipsisPosition position)
 750 {
 751         __pEdit->SetEllipsisPosition(position);
 752
 753         return E_SUCCESS;
 754 }
 755
 756 int
 757 _EditFieldImpl::GetTextSize(void) const
 758 {
 759         return _CoordinateSystemUtils::ConvertToInteger(GetTextSizeF());
 760 }
 761
 762 float
 763 _EditFieldImpl::GetTextSizeF(void) const
 764 {
 765         return __pEdit->GetPropertyTextSize().ToFloat();
 766 }
 767
 768 result
 769 _EditFieldImpl::SetTextSize(int size)
 770 {
 771         return SetTextSize(_CoordinateSystemUtils::ConvertToFloat(size));
 772 }
 773
 774 result
 775 _EditFieldImpl::SetTextSize(float size)
 776 {
 777         Variant variantSize(size);
 778
 779         return __pEdit->SetPropertyTextSize(variantSize);
 780 }
 781
 782 Color
 783 _EditFieldImpl::GetColor(EditStatus status) const
 784 {
 785         Color color;
 786
 787         switch (status)
 788         {
 789         case EDIT_STATUS_NORMAL:
 790                 color = __pEdit->GetPropertyNormalColor().ToColor();
 791                 break;
 792
 793         case EDIT_STATUS_DISABLED:
 794                 color = __pEdit->GetPropertyDisabledColor().ToColor();
 795                 break;
 796
 797         case EDIT_STATUS_HIGHLIGHTED:
 798                 color = __pEdit->GetPropertyHighlightedColor().ToColor();
 799                 break;
 800
 801         case EDIT_STATUS_PRESSED:
 802                 color = __pEdit->GetPropertyPressedColor().ToColor();
 803                 break;
 804
 805         default:
 806                 break;
 807         }
 808
 809         return color;
 810 }
 811
 812 Color
 813 _EditFieldImpl::GetTextColor(EditTextColor type) const
 814 {
 815         return __pEdit->GetTextColor(type);
 816 }
 817
 818 result
 819 _EditFieldImpl::SetBackgroundBitmap(EditStatus status, const Bitmap& bitmap)
 820 {
 821         return __pEdit->SetBackgroundBitmap(status, bitmap);
 822 }
 823
 824 result
 825 _EditFieldImpl::SetColor(EditStatus status, const Color& color)
 826 {
 827         result r = E_SUCCESS;
 828         Variant variantColor(color);
 829
 830         switch (status)
 831         {
 832         case EDIT_STATUS_NORMAL:
 833                 r =  __pEdit->SetPropertyNormalColor(variantColor);
 834                 break;
 835
 836         case EDIT_STATUS_DISABLED:
 837                 r =  __pEdit->SetPropertyDisabledColor(variantColor);
 838                 break;
 839
 840         case EDIT_STATUS_HIGHLIGHTED:
 841                 r =  __pEdit->SetPropertyHighlightedColor(variantColor);
 842                 break;
 843
 844         case EDIT_STATUS_PRESSED:
 845                 r =  __pEdit->SetPropertyPressedColor(variantColor);
 846                 break;
 847
 848         default:
 849                 r = E_INVALID_ARG;
 850                 break;
 851         }
 852         SysTryReturn(NID_UI_CTRL, r == E_SUCCESS, r, r, "[%s] Unable to set color.", GetErrorMessage(r));
 853
 854         return r;
 855 }
 856
 857 result
 858 _EditFieldImpl::SetTextColor(EditTextColor type, const Color& color)
 859 {
 860         result r = E_SUCCESS;
 861
 862         r = __pEdit->SetTextColor(type, color);
 863
 864         return r;
 865 }
 866
 867 String
 868 _EditFieldImpl::GetText(int start, int end) const
 869 {
 870         return __pEdit->GetText(start, end);
 871 }
 872
 873 result
 874 _EditFieldImpl::AddUiLinkEventListener(IUiLinkEventListener& listener)
 875 {
 876         ClearLastResult();
 877         SysTryReturn(NID_UI_CTRL, __pPublicLinkEvent, E_SYSTEM, E_SYSTEM, "[E_SYSTEM] This instance isn't constructed.")
 878
 879         return __pPublicLinkEvent->AddListener(listener);
 880 }
 881
 882 result
 883 _EditFieldImpl::RemoveUiLinkEventListener(IUiLinkEventListener& listener)
 884 {
 885         ClearLastResult();
 886         SysTryReturn(NID_UI_CTRL, __pPublicLinkEvent, E_SYSTEM, E_SYSTEM, "[E_SYSTEM] This instance isn't constructed.")
 887
 888         return __pPublicLinkEvent->RemoveListener(listener);
 889 }
 890
 891 result
 892 _EditFieldImpl::AddTextBlockEventListener(ITextBlockEventListener& listener)
 893 {
 894         ClearLastResult();
 895         SysTryReturn(NID_UI_CTRL, __pPublicTextBlockEvent, E_SYSTEM, E_SYSTEM, "[E_SYSTEM] This instance isn't constructed.");
 896
 897         return __pPublicTextBlockEvent->AddListener(listener);
 898 }
 899
 900 result
 901 _EditFieldImpl::RemoveTextBlockEventListener(ITextBlockEventListener& listener)
 902 {
 903         ClearLastResult();
 904         SysTryReturn(NID_UI_CTRL, __pPublicTextBlockEvent, E_SYSTEM, E_SYSTEM, "[E_SYSTEM] This instance isn't constructed.");
 905
 906         return __pPublicTextBlockEvent->RemoveListener(listener);
 907 }
 908
 909 result
 910 _EditFieldImpl::AddKeypadEventListener(IKeypadEventListener& listener)
 911 {
 912         ClearLastResult();
 913         SysTryReturn(NID_UI_CTRL, __pPublicKeypadEvent, E_SYSTEM, E_SYSTEM, "[E_SYSTEM] This instance isn't constructed.");
 914
 915         return __pPublicKeypadEvent->AddListener(listener);
 916 }
 917
 918 result
 919 _EditFieldImpl::RemoveKeypadEventListener(IKeypadEventListener& listener)
 920 {
 921         ClearLastResult();
 922         SysTryReturn(NID_UI_CTRL, __pPublicKeypadEvent, E_SYSTEM, E_SYSTEM, "[E_SYSTEM] This instance isn't constructed.");
 923
 924         return __pPublicKeypadEvent->RemoveListener(listener);
 925 }
 926
 927 result
 928 _EditFieldImpl::AddTextEventListener(ITextEventListener& listener)
 929 {
 930         ClearLastResult();
 931         SysTryReturn(NID_UI_CTRL, __pPublicTextEvent, E_SYSTEM, E_SYSTEM, "[E_SYSTEM] This instance isn't constructed.")
 932
 933         return __pPublicTextEvent->AddListener(listener);
 934 }
 935
 936 result
 937 _EditFieldImpl::RemoveTextEventListener(ITextEventListener& listener)
 938 {
 939         ClearLastResult();
 940         SysTryReturn(NID_UI_CTRL, __pPublicTextEvent, E_SYSTEM, E_SYSTEM, "[E_SYSTEM] This instance isn't constructed.");
 941
 942         return __pPublicTextEvent->RemoveListener(listener);
 943 }
 944
 945 result
 946 _EditFieldImpl::AddScrollPanelEventListener(IScrollPanelEventListener& listener)
 947 {
 948         ClearLastResult();
 949         SysTryReturn(NID_UI_CTRL, (__pEdit->GetInputStyle() == INPUT_STYLE_OVERLAY), E_SYSTEM, E_SYSTEM, "[E_SYSTEM] System error occurred.")
 950         SysTryReturn(NID_UI_CTRL, __pPublicScrollPanelEvent, E_SYSTEM, E_SYSTEM, "[E_SYSTEM] This instance isn't constructed.");
 951
 952         return __pPublicScrollPanelEvent->AddListener(listener);
 953 }
 954
 955 result
 956 _EditFieldImpl::RemoveScrollPanelEventListener(IScrollPanelEventListener& listener)
 957 {
 958         ClearLastResult();
 959         SysTryReturn(NID_UI_CTRL, __pPublicScrollPanelEvent, E_SYSTEM, E_SYSTEM, "[E_SYSTEM] This instance isn't constructed.");
 960
 961         return __pPublicScrollPanelEvent->RemoveListener(listener);
 962 }
 963
 964 result
 965 _EditFieldImpl::AddActionEventListener(IActionEventListener& listener)
 966 {
 967         ClearLastResult();
 968         SysTryReturn(NID_UI_CTRL, __pPublicActionEvent, E_SYSTEM, E_SYSTEM, "[E_SYSTEM] This instance isn't constructed.");
 969
 970         return __pPublicActionEvent->AddListener(listener);
 971 }
 972
 973 result
 974 _EditFieldImpl::RemoveActionEventListener(IActionEventListener& listener)
 975 {
 976         ClearLastResult();
 977         SysTryReturn(NID_UI_CTRL, __pPublicActionEvent, E_SYSTEM, E_SYSTEM, "[E_SYSTEM] This instance isn't constructed.")
 978
 979         return __pPublicActionEvent->RemoveListener(listener);
 980 }
 981
 982 result
 983 _EditFieldImpl::AddLanguageEventListener(ILanguageEventListener& listener)
 984 {
 985         ClearLastResult();
 986         SysTryReturn(NID_UI_CTRL, __pPublicLanguageEvent, E_SYSTEM, E_SYSTEM, "[E_SYSTEM] This instance isn't constructed.");
 987
 988         return __pPublicLanguageEvent->AddListener(listener);
 989 }
 990
 991 result
 992 _EditFieldImpl::RemoveLanguageEventListener(ILanguageEventListener& listener)
 993 {
 994         ClearLastResult();
 995         SysTryReturn(NID_UI_CTRL, __pPublicLanguageEvent, E_SYSTEM, E_SYSTEM, "[E_SYSTEM] This instance isn't constructed.")
 996
 997         return __pPublicLanguageEvent->RemoveListener(listener);
 998 }
 999
1000 int
1001 _EditFieldImpl::GetRemainingLength(void) const
1002 {
1003         return __pEdit->GetRemainingLength();
1004 }
1005
1006 void
1007 _EditFieldImpl::SetLowerCaseModeEnabled(bool enable)
1008 {
1009         Variant variantEnable(enable);
1010
1011         __pEdit->SetPropertyLowerCaseModeEnabled(variantEnable);
1012 }
1013
1014 bool
1015 _EditFieldImpl::IsLowerCaseModeEnabled(void) const
1016 {
1017         return __pEdit->GetPropertyLowerCaseModeEnabled().ToBool();
1018 }
1019
1020 result
1021 _EditFieldImpl::SetInputModeCategory(unsigned long categories, bool enable)
1022 {
1023         result r = E_SUCCESS;
1024         const unsigned long INPUT_MODE_ALL_MASK = EDIT_INPUTMODE_ALPHA | EDIT_INPUTMODE_PREDICTIVE | EDIT_INPUTMODE_NUMERIC| EDIT_INPUTMODE_SYMBOL;
1025         KeypadStyle keypadStyle = GetKeypadStyle();
1026
1027         switch (keypadStyle)
1028         {
1029         case KEYPAD_STYLE_NUMBER:
1030         // fall through
1031         case KEYPAD_STYLE_IP_V4:
1032                 if (enable)
1033                 {
1034                         if (categories & (EDIT_INPUTMODE_ALPHA | EDIT_INPUTMODE_PREDICTIVE | EDIT_INPUTMODE_SYMBOL))
1035                         {
1036                                 SysLogException(NID_UI_CTRL, E_INVALID_OPERATION, "[E_INVALID_OPERATION] The current keypad style can not support given categories.");
1037
1038                                 return E_INVALID_OPERATION;
1039                         }
1040                 }
1041                 else
1042                 {
1043                         if (categories & EDIT_INPUTMODE_NUMERIC)
1044                         {
1045                                 SysLogException(NID_UI_CTRL, E_INVALID_OPERATION, "[E_INVALID_OPERATION] The current keypad style can not support given categories.");
1046
1047                                 return E_INVALID_OPERATION;
1048                         }
1049                 }
1050                 break;
1051
1052         case KEYPAD_STYLE_PHONE_NUMBER:
1053                 if (enable)
1054                 {
1055                         if (categories & (EDIT_INPUTMODE_ALPHA | EDIT_INPUTMODE_PREDICTIVE))
1056                         {
1057                                 SysLogException(NID_UI_CTRL, E_INVALID_OPERATION, "[E_INVALID_OPERATION] The current keypad style can not support given categories.");
1058
1059                                 return E_INVALID_OPERATION;
1060                         }
1061
1062                         if (!((categories & EDIT_INPUTMODE_NUMERIC) && (categories & EDIT_INPUTMODE_SYMBOL)))
1063                         {
1064                                 SysLogException(NID_UI_CTRL, E_INVALID_OPERATION, "[E_INVALID_OPERATION] The current keypad style can not support given categories.");
1065
1066                                 return E_INVALID_OPERATION;
1067                         }
1068                         else
1069                         {
1070                                 if (categories & (EDIT_INPUTMODE_NUMERIC | EDIT_INPUTMODE_SYMBOL))
1071                                 {
1072                                         SysLogException(NID_UI_CTRL, E_INVALID_OPERATION, "[E_INVALID_OPERATION] The current keypad style cna not support given categories.");
1073
1074                                         return E_INVALID_OPERATION;
1075                                 }
1076                         }
1077                 }
1078                 break;
1079
1080         default:
1081                 break;
1082         }
1083
1084         if (((enable == true) && (categories == 0)) || ((enable == false) && (categories == INPUT_MODE_ALL_MASK)))
1085         {
1086                 SysLogException(NID_UI_CTRL, E_INVALID_ARG, "[E_INVALID_ARG] All input modes cannot be disabled.");
1087
1088                 return E_INVALID_ARG;
1089         }
1090
1091         if ((enable == false) && (categories & __currentInputMode))
1092         {
1093                 SysLogException(NID_UI_CTRL, E_INVALID_ARG, "[E_INVALID_ARG] The current input modes cannot be disabled.");
1094
1095                 return E_INVALID_ARG;
1096         }
1097
1098         if (enable)
1099         {
1100                 __inputModeCategory = categories;
1101                 if ((~categories) & EDIT_INPUTMODE_PREDICTIVE)
1102                 {
1103                         __pEdit->SetTextPredictionEnabled(false);
1104                 }
1105         }
1106         else
1107         {
1108                 __inputModeCategory = (~categories & INPUT_MODE_ALL_MASK);
1109                 if (categories == EDIT_INPUTMODE_PREDICTIVE)
1110                 {
1111                         __pEdit->SetTextPredictionEnabled(false);
1112                 }
1113         }
1114
1115         // if currentInputModeCategory doesn't exist in categories, then set tempInputMode
1116         if (!(categories & __currentInputMode))
1117         {
1118                 const int INPUT_MODE_CATEGORY_MAX = 4;
1119                 EditInputModeCategory newInputMode = __currentInputMode;
1120                 EditInputModeCategory tempInputMode = EDIT_INPUTMODE_ALPHA;
1121                 for (int i = 0; i  < INPUT_MODE_CATEGORY_MAX; i++)
1122                 {
1123                         if ( (categories & tempInputMode) && (tempInputMode != EDIT_INPUTMODE_PREDICTIVE))
1124                         {
1125                                 newInputMode = tempInputMode;
1126                                 break;
1127                         }
1128
1129                         switch (tempInputMode)
1130                         {
1131                                 case EDIT_INPUTMODE_ALPHA:
1132                                         tempInputMode = EDIT_INPUTMODE_PREDICTIVE;
1133                                         break;
1134
1135                                 case EDIT_INPUTMODE_PREDICTIVE:
1136                                         tempInputMode = EDIT_INPUTMODE_NUMERIC;
1137                                         break;
1138
1139                                 case EDIT_INPUTMODE_NUMERIC:
1140                                         tempInputMode = EDIT_INPUTMODE_SYMBOL;
1141                                         break;
1142
1143                                 default:
1144                                         break;
1145                         }
1146                 }
1147
1148                 if (__currentInputMode != newInputMode)
1149                 {
1150                         r = SetCurrentInputModeCategory(newInputMode);
1151                 }
1152         }
1153
1154         return r;
1155 }
1156
1157 result
1158 _EditFieldImpl::SetCurrentInputModeCategory(EditInputModeCategory inputModeCategory)
1159 {
1160         KeypadStyle currentKeypadStyle = GetKeypadStyle();
1161         KeypadStyle keypadStyle = KEYPAD_STYLE_NORMAL;
1162
1163         if (inputModeCategory == EDIT_INPUTMODE_NUMERIC)
1164         {
1165                 if (currentKeypadStyle == KEYPAD_STYLE_NORMAL)
1166                 {
1167                         __pEdit->SetKeypadNormalNumberStyle(true);
1168                 }
1169                 else
1170                 {
1171                         keypadStyle = KEYPAD_STYLE_NUMBER;
1172                         Variant variantKeypadStyle((int)keypadStyle);
1173
1174                         __pEdit->SetPropertyKeypadStyle(variantKeypadStyle);
1175                 }
1176         }
1177         else if (inputModeCategory == EDIT_INPUTMODE_SYMBOL)
1178         {
1179                 if (currentKeypadStyle == KEYPAD_STYLE_NORMAL)
1180                 {
1181                         __pEdit->SetKeypadNormalNumberStyle(true);
1182                 }
1183         }
1184         else if (inputModeCategory == EDIT_INPUTMODE_PREDICTIVE)
1185         {
1186                 __pEdit->SetTextPredictionEnabled(true);
1187         }
1188
1189         __currentInputMode = inputModeCategory;
1190         return E_SUCCESS;
1191 }
1192
1193 unsigned long
1194 _EditFieldImpl::GetInputModeCategory(void) const
1195 {
1196         return __inputModeCategory;
1197 }
1198
1199 EditInputModeCategory
1200 _EditFieldImpl::GetCurrentInputModeCategory(void) const
1201 {
1202         return __currentInputMode;
1203 }
1204
1205 bool
1206 _EditFieldImpl::IsTextPredictionEnabled(void) const
1207 {
1208         return __pEdit->IsTextPredictionEnabled();
1209 }
1210
1211 result
1212 _EditFieldImpl::SetTextPredictionEnabled(bool enable)
1213 {
1214         return __pEdit->SetTextPredictionEnabled(enable);
1215 }
1216
1217 result
1218 _EditFieldImpl::SetCursorPosition(int position)
1219 {
1220         Variant variantPosition(position);
1221
1222         return __pEdit->SetPropertyCursorPosition(variantPosition);
1223 }
1224
1225 int
1226 _EditFieldImpl::GetCursorPosition(void) const
1227 {
1228         return __pEdit->GetPropertyCursorPosition().ToInt();
1229 }
1230
1231 String
1232 _EditFieldImpl::GetText(void) const
1233 {
1234         return __pEdit->GetPropertyText().ToString();
1235 }
1236
1237 int
1238 _EditFieldImpl::GetTextLength(void) const
1239 {
1240         return __pEdit->GetTextLength();
1241 }
1242
1243 result
1244 _EditFieldImpl::SetText(const String& text)
1245 {
1246         Variant variantText(text);
1247
1248         return __pEdit->SetPropertyText(variantText);
1249 }
1250
1251 result
1252 _EditFieldImpl::InsertTextAtCursorPosition(const String& text)
1253 {
1254         return __pEdit->InsertTextAtCursorPosition(text);
1255 }
1256
1257 result
1258 _EditFieldImpl::AppendText(const String& text)
1259 {
1260         return __pEdit->AppendText(text);
1261 }
1262
1263 result
1264 _EditFieldImpl::AppendCharacter(const Character& character)
1265 {
1266         return __pEdit->AppendCharacter(character);
1267 }
1268
1269 result
1270 _EditFieldImpl::Clear(void)
1271 {
1272         return __pEdit->ClearText();
1273 }
1274
1275 result
1276 _EditFieldImpl::DeleteCharacterAtCursorPosition(void)
1277 {
1278         return __pEdit->DeleteCharacterAtCursorPosition();
1279 }
1280
1281 void
1282 _EditFieldImpl::GetCurrentTextRange(int& start, int& end) const
1283 {
1284         return __pEdit->GetCurrentTextRange(start, end);
1285 }
1286
1287 void
1288 _EditFieldImpl::SetGuideText(const String& guideText)
1289 {
1290         Variant variantGuideText(guideText);
1291
1292         __pEdit->SetPropertyGuideText(variantGuideText);
1293 }
1294
1295 String
1296 _EditFieldImpl::GetGuideText(void) const
1297 {
1298         return __pEdit->GetPropertyGuideText().ToString();
1299 }
1300
1301 Color
1302 _EditFieldImpl::GetGuideTextColor(void) const
1303 {
1304         return __pEdit->GetPropertyGuideTextColor().ToColor();
1305 }
1306
1307 result
1308 _EditFieldImpl::SetGuideTextColor(const Color& color)
1309 {
1310         Variant variantColor(color);
1311
1312         return __pEdit->SetPropertyGuideTextColor(variantColor);
1313 }
1314
1315 void
1316 _EditFieldImpl::SetKeypadEnabled(bool enable)
1317 {
1318         Variant variantEnable(enable);
1319
1320         __pEdit->SetPropertyKeypadEnabled(variantEnable);
1321
1322         return;
1323 }
1324
1325 bool
1326 _EditFieldImpl::IsKeypadEnabled(void) const
1327 {
1328         return __pEdit->GetPropertyKeypadEnabled().ToBool();
1329 }
1330
1331 result
1332 _EditFieldImpl::ShowKeypad(void)
1333 {
1334         return __pEdit->ShowKeypad();
1335 }
1336
1337 void
1338 _EditFieldImpl::GetBlockRange(int& start, int& end) const
1339 {
1340         __pEdit->GetBlockRange(start, end);
1341 }
1342
1343 result
1344 _EditFieldImpl::BeginBlock(void)
1345 {
1346         return __pEdit->BeginTextBlock();
1347 }
1348
1349 result
1350 _EditFieldImpl::ReleaseBlock(void)
1351 {
1352         return __pEdit->ReleaseTextBlock();
1353 }
1354
1355 bool
1356 _EditFieldImpl::IsBlocked(void) const
1357 {
1358         return __pEdit->IsBlocked();
1359 }
1360
1361 result
1362 _EditFieldImpl::Copy(void)
1363 {
1364         return __pEdit->CopyText();
1365 }
1366
1367 result
1368 _EditFieldImpl::Cut(void)
1369 {
1370         return __pEdit->CutText();
1371 }
1372
1373 result
1374 _EditFieldImpl::Paste(void)
1375 {
1376         return __pEdit->PasteText();
1377 }
1378
1379 result
1380 _EditFieldImpl::Remove(void)
1381 {
1382         SysTryReturnResult(NID_UI_CTRL, (__pEdit->RemoveTextBlock() == E_SUCCESS), E_SYSTEM, "A system error has occurred");
1383
1384         return E_SUCCESS;
1385 }
1386
1387 bool
1388 _EditFieldImpl::IsClipped(void) const
1389 {
1390         return __pEdit->IsClipped();
1391 }
1392
1393 result
1394 _EditFieldImpl::SetTitleText(const String& title)
1395 {
1396         SysTryReturnResult(NID_UI_CTRL, (__pEdit->GetEditStyle() & EDIT_STYLE_TITLE_TOP) ||
1397                                           (__pEdit->GetEditStyle() & EDIT_STYLE_TITLE_LEFT), E_SYSTEM,
1398                                           "The EditField has no title style.");
1399
1400         Variant variantTitle(title);
1401
1402         return __pEdit->SetPropertyTitleText(variantTitle);
1403 }
1404
1405 String
1406 _EditFieldImpl::GetTitleText(void) const
1407 {
1408         return __pEdit->GetPropertyTitleText().ToString();
1409 }
1410
1411 result
1412 _EditFieldImpl::SetTitleTextColor(EditStatus status, const Color& color)
1413 {
1414         result r = E_SUCCESS;
1415         Variant variantColor(color);
1416
1417         switch (status)
1418         {
1419         case EDIT_STATUS_NORMAL:
1420                 r = __pEdit->SetPropertyNormalTitleTextColor(variantColor);
1421                 break;
1422
1423         case EDIT_STATUS_DISABLED:
1424                 r = __pEdit->SetPropertyDisabledTitleTextColor(variantColor);
1425                 break;
1426
1427         case EDIT_STATUS_HIGHLIGHTED:
1428                 r = __pEdit->SetPropertyHighlightedTitleTextColor(variantColor);
1429                 break;
1430
1431         case EDIT_STATUS_PRESSED:
1432                 r = __pEdit->SetPropertyPressedTitleTextColor(variantColor);
1433                 break;
1434
1435         default:
1436                 r = E_INVALID_ARG;
1437                 break;
1438         }
1439
1440         return r;
1441 }
1442
1443 Color
1444 _EditFieldImpl::GetTitleTextColor(EditStatus status) const
1445 {
1446         Color color;
1447
1448         switch (status)
1449         {
1450         case EDIT_STATUS_NORMAL:
1451                 color = __pEdit->GetPropertyNormalTitleTextColor().ToColor();
1452                 break;
1453
1454         case EDIT_STATUS_DISABLED:
1455                 color = __pEdit->GetPropertyDisabledTitleTextColor().ToColor();
1456                 break;
1457
1458         case EDIT_STATUS_HIGHLIGHTED:
1459                 color = __pEdit->GetPropertyHighlightedTitleTextColor().ToColor();
1460                 break;
1461
1462         case EDIT_STATUS_PRESSED:
1463                 color = __pEdit->GetPropertyPressedTitleTextColor().ToColor();
1464                 break;
1465
1466         default:
1467                 break;
1468         }
1469
1470         return color;
1471 }
1472
1473 result
1474 _EditFieldImpl::SetOverlayKeypadCommandButton(CommandButtonPosition position, const String& text, int actionId)
1475 {
1476         return __pEdit->SetKeypadCommandButton(position, text, actionId);
1477 }
1478
1479 String
1480 _EditFieldImpl::GetOverlayKeypadCommandButtonText(CommandButtonPosition position) const
1481 {
1482         return __pEdit->GetKeypadCommandButtonText(position);
1483 }
1484
1485 int
1486 _EditFieldImpl::GetOverlayKeypadCommandButtonActionId(CommandButtonPosition position) const
1487 {
1488         return __pEdit->GetKeypadCommandButtonActionId(position);
1489 }
1490
1491 result
1492 _EditFieldImpl::SetCurrentLanguage(LanguageCode languageCode)
1493 {
1494         return __pEdit->SetCurrentLanguage(languageCode);
1495 }
1496
1497 result
1498 _EditFieldImpl::GetCurrentLanguage(LanguageCode& language) const
1499 {
1500         return __pEdit->GetCurrentLanguage(language);
1501 }
1502
1503 result
1504 _EditFieldImpl::SetPasswordVisible(bool visible)
1505 {
1506         SysTryReturnResult(NID_UI_CTRL, (__pEdit->GetEditStyle() & EDIT_STYLE_PASSWORD), E_INVALID_OPERATION,
1507                                           "Edit Style is not EDIT_STYLE_PASSWORD.");
1508
1509         return __pEdit->SetPasswordVisible(visible);
1510 }
1511
1512 bool
1513 _EditFieldImpl::IsPasswordVisible(void) const
1514 {
1515         ClearLastResult();
1516
1517         SysTryReturn(NID_UI_CTRL, (__pEdit->GetEditStyle() & EDIT_STYLE_PASSWORD), false, E_INVALID_OPERATION, "Edit Style is not EDIT_STYLE_PASSWORD.\n");
1518
1519         return __pEdit->IsPasswordVisible();
1520 }
1521
1522 result
1523 _EditFieldImpl::OnBoundsChanged(const Rectangle& oldRect, const Rectangle& newRect)
1524 {
1525         return E_SUCCESS;
1526 }
1527
1528 void
1529 _EditFieldImpl::OnTextValueChanged(const _Control& source)
1530 {
1531         if (__pPublicTextEvent != null)
1532         {
1533                 IEventArg* pEventArg = _PublicTextEvent::CreateTextEventArgN(TEXT_EVENT_CHANGED);
1534                 SysTryReturnVoidResult(NID_UI_CTRL, pEventArg, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] Memory allocation failed.");
1535
1536                 __pPublicTextEvent->Fire(*pEventArg);
1537         }
1538         else
1539         {
1540                 SysLog(NID_UI_CTRL, "Event is not created.");
1541         }
1542 }
1543
1544 void
1545 _EditFieldImpl::OnTextValueChangeCanceled(const _Control& source)
1546 {
1547         if (__pPublicTextEvent != null)
1548         {
1549                 IEventArg* pEventArg = _PublicTextEvent::CreateTextEventArgN(TEXT_EVENT_CANCELED);
1550                 SysTryReturnVoidResult(NID_UI_CTRL, pEventArg, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] Memory allocation failed.");
1551
1552                 __pPublicTextEvent->Fire(*pEventArg);
1553         }
1554         else
1555         {
1556                 SysLog(NID_UI_CTRL, "Event is not created.");
1557         }
1558 }
1559
1560 void
1561 _EditFieldImpl::OnActionPerformed(const _Control& source, int actionId)
1562 {
1563         if (__pPublicActionEvent != null)
1564         {
1565                 IEventArg* pActionEventArg = _PublicActionEvent::CreateActionEventArgN(actionId);
1566                 SysTryReturnVoidResult(NID_UI_CTRL, pActionEventArg, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] Memory allocation failed.");
1567
1568                 __pPublicActionEvent->Fire(*pActionEventArg);
1569         }
1570         else
1571         {
1572                 SysLog(NID_UI_CTRL, "Event is not created.");
1573         }
1574 }
1575
1576 void
1577 _EditFieldImpl::OnLinkClicked(_Control& source, const String& text, Utility::LinkType linkType,
1578                                                           const String& link)
1579 {
1580         if (__pPublicLinkEvent != null)
1581         {
1582                 IEventArg* pLinkEventArg = _PublicLinkEvent::CreateLinkEventArgN(text, linkType, link);
1583                 SysTryReturnVoidResult(NID_UI_CTRL, pLinkEventArg, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] Memory allocation failed.");
1584
1585                 __pPublicLinkEvent->Fire(*pLinkEventArg);
1586         }
1587         else
1588         {
1589                 SysLog(NID_UI_CTRL, "Event is not created.");
1590         }
1591 }
1592
1593 void
1594 _EditFieldImpl::OnTextBlockSelected(_Control& source, int start, int end)
1595 {
1596         if (__pPublicTextBlockEvent != null)
1597         {
1598                 IEventArg* pTextBlockEventArg = _PublicTextBlockEvent::CreateTextBlockEventArgN(start, end);
1599                 SysTryReturnVoidResult(NID_UI_CTRL, pTextBlockEventArg, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] Memory allocation failed.");
1600
1601                 __pPublicTextBlockEvent->Fire(*pTextBlockEventArg);
1602         }
1603         else
1604         {
1605                 SysLog(NID_UI_CTRL, "Event is not created.");
1606         }
1607 }
1608
1609 void
1610 _EditFieldImpl::OnKeypadWillOpen(void)
1611 {
1612         if (__pPublicKeypadEvent)
1613         {
1614                 IEventArg* pKeypadEventArg = _PublicKeypadEvent::CreateKeypadEventArgN(
1615                         GetPublic(), KEYPAD_ACTION_ENTER, KEYPAD_EVENT_STATUS_CREATED);
1616                 SysTryReturnVoidResult(NID_UI_CTRL, pKeypadEventArg, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] Memory allocation failed.");
1617
1618                 __pPublicKeypadEvent->Fire(*pKeypadEventArg);
1619         }
1620         else
1621         {
1622                 SysLog(NID_UI_CTRL, "Event is not created.");
1623         }
1624 }
1625
1626 void
1627 _EditFieldImpl::OnKeypadOpened(void)
1628 {
1629         if (__pPublicKeypadEvent)
1630         {
1631                 IEventArg* pKeypadEventArg = _PublicKeypadEvent::CreateKeypadEventArgN(
1632                         GetPublic(), KEYPAD_ACTION_ENTER, KEYPAD_EVENT_STATUS_OPEN);
1633                 SysTryReturnVoidResult(NID_UI_CTRL, pKeypadEventArg, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] Memory allocation failed.");
1634
1635                 __pPublicKeypadEvent->Fire(*pKeypadEventArg);
1636         }
1637         else
1638         {
1639                 SysLog(NID_UI_CTRL, "Event is not created.");
1640         }
1641 }
1642
1643 void
1644 _EditFieldImpl::OnKeypadClosed(void)
1645 {
1646         if (__pPublicKeypadEvent)
1647         {
1648                 IEventArg* pKeypadEventArg = _PublicKeypadEvent::CreateKeypadEventArgN(
1649                         GetPublic(), KEYPAD_ACTION_ENTER, KEYPAD_EVENT_STATUS_CLOSE);
1650                 SysTryReturnVoidResult(NID_UI_CTRL, pKeypadEventArg, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] Memory allocation failed.");
1651
1652                 __pPublicKeypadEvent->Fire(*pKeypadEventArg);
1653         }
1654         else
1655         {
1656                 SysLog(NID_UI_CTRL, "Event is not created.");
1657         }
1658 }
1659
1660 void
1661 _EditFieldImpl::OnKeypadBoundsChanged(void)
1662 {
1663         if (__pPublicKeypadEvent)
1664         {
1665                 IEventArg* pKeypadEventArg = _PublicKeypadEvent::CreateKeypadEventArgN(
1666                         GetPublic(), KEYPAD_ACTION_ENTER, KEYPAD_EVENT_STATUS_BOUNDS_CHANGED);
1667                 SysTryReturnVoidResult(NID_UI_CTRL, pKeypadEventArg, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] Memory allocation failed.");
1668
1669                 __pPublicKeypadEvent->Fire(*pKeypadEventArg);
1670         }
1671         else
1672         {
1673                 SysLog(NID_UI_CTRL, "Event is not created.");
1674         }
1675 }
1676
1677 void
1678 _EditFieldImpl::OnKeypadActionPerformed(CoreKeypadAction keypadAction)
1679 {
1680         if (__pPublicKeypadEvent)
1681         {
1682                 KeypadAction onKeypadAction = KEYPAD_ACTION_ENTER;
1683                 switch (keypadAction)
1684                 {
1685                 case CORE_KEYPAD_ACTION_ENTER:
1686                         onKeypadAction = KEYPAD_ACTION_ENTER;
1687                         break;
1688
1689                 case CORE_KEYPAD_ACTION_GO:
1690                         onKeypadAction = KEYPAD_ACTION_GO;
1691                         break;
1692
1693                 case CORE_KEYPAD_ACTION_NEXT:
1694                         onKeypadAction = KEYPAD_ACTION_NEXT;
1695                         break;
1696
1697                 case CORE_KEYPAD_ACTION_SEND:
1698                         onKeypadAction = KEYPAD_ACTION_SEND;
1699                         break;
1700
1701                 case CORE_KEYPAD_ACTION_SEARCH:
1702                         onKeypadAction = KEYPAD_ACTION_SEARCH;
1703                         break;
1704
1705                 case CORE_KEYPAD_ACTION_LOGIN:
1706                         onKeypadAction = KEYPAD_ACTION_LOGIN;
1707                         break;
1708
1709                 case CORE_KEYPAD_ACTION_SIGN_IN:
1710                         onKeypadAction = KEYPAD_ACTION_SIGN_IN;
1711                         break;
1712
1713                 case CORE_KEYPAD_ACTION_JOIN:
1714                         onKeypadAction = KEYPAD_ACTION_JOIN;
1715                         break;
1716
1717                 case CORE_KEYPAD_ACTION_DONE:
1718                         onKeypadAction = KEYPAD_ACTION_DONE;
1719                         break;
1720
1721                 default:
1722                         break;
1723                 }
1724
1725                 IEventArg* pKeypadEventArg = _PublicKeypadEvent::CreateKeypadEventArgN(
1726                         GetPublic(), onKeypadAction, KEYPAD_EVENT_STATUS_ENTERACTION);
1727                 SysTryReturnVoidResult(NID_UI_CTRL, pKeypadEventArg, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] Memory allocation failed.");
1728
1729                 __pPublicKeypadEvent->Fire(*pKeypadEventArg);
1730         }
1731         else
1732         {
1733                 SysLog(NID_UI_CTRL, "Event is not created.");
1734         }
1735 }
1736
1737 void
1738 _EditFieldImpl::OnLanguageChanged(LanguageCode oldLanguage, LanguageCode newLanguage)
1739 {
1740         if (__pPublicLanguageEvent)
1741         {
1742                 IEventArg* pKLanguageEventArg = _PublicLanguageEvent::CreateLanguageEventArgN(GetPublic(), oldLanguage, newLanguage);
1743                 SysTryReturnVoidResult(NID_UI_CTRL, pKLanguageEventArg, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] Memory allocation failed.");
1744
1745                 __pPublicLanguageEvent->Fire(*pKLanguageEventArg);
1746         }
1747         else
1748         {
1749                 SysLog(NID_UI_CTRL, "Event is not created.");
1750         }
1751 }
1752
1753 void
1754 _EditFieldImpl::OnOverlayControlCreated(const _Control& source)
1755 {
1756         if (__pPublicScrollPanelEvent != null)
1757         {
1758                 IEventArg* pEventArg = _PublicScrollPanelEvent::CreateScrollPanelEventArgN(OVERLAY_CONTROL_CREATED);
1759                 SysTryReturnVoidResult(NID_UI_CTRL, pEventArg, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] Memory allocation failed.");
1760
1761                 __pPublicScrollPanelEvent->Fire(*pEventArg);
1762         }
1763         else
1764         {
1765                 SysLog(NID_UI_CTRL, "Event is not created.");
1766         }
1767 }
1768
1769 void
1770 _EditFieldImpl::OnOverlayControlOpened(const _Control& source)
1771 {
1772         if (__pPublicScrollPanelEvent != null)
1773         {
1774                 IEventArg* pEventArg = _PublicScrollPanelEvent::CreateScrollPanelEventArgN(OVERLAY_CONTROL_OPENED);
1775                 SysTryReturnVoidResult(NID_UI_CTRL, pEventArg, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] Memory allocation failed.");
1776
1777                 __pPublicScrollPanelEvent->Fire(*pEventArg);
1778         }
1779         else
1780         {
1781                 SysLog(NID_UI_CTRL, "Event is not created.");
1782         }
1783 }
1784
1785 void
1786 _EditFieldImpl::OnOverlayControlClosed(const _Control& source)
1787 {
1788         if (__pPublicScrollPanelEvent != null)
1789         {
1790                 IEventArg* pEventArg = _PublicScrollPanelEvent::CreateScrollPanelEventArgN(OVERLAY_CONTROL_CLOSED);
1791                 SysTryReturnVoidResult(NID_UI_CTRL, pEventArg, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] Memory allocation failed.");
1792
1793                 __pPublicScrollPanelEvent->Fire(*pEventArg);
1794         }
1795         else
1796         {
1797                 SysLog(NID_UI_CTRL, "Event is not created.");
1798         }
1799 }
1800
1801 void
1802 _EditFieldImpl::OnOtherControlSelected(const _Control& source)
1803 {
1804         if (__pPublicScrollPanelEvent != null)
1805         {
1806                 IEventArg* pEventArg = _PublicScrollPanelEvent::CreateScrollPanelEventArgN(OTHER_CONTROL_SELECTED);
1807                 SysTryReturnVoidResult(NID_UI_CTRL, pEventArg, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] Memory allocation failed.");
1808
1809                 __pPublicScrollPanelEvent->Fire(*pEventArg);
1810         }
1811         else
1812         {
1813                 SysLog(NID_UI_CTRL, "Event is not created.");
1814         }
1815 }
1816
1817 void
1818 _EditFieldImpl::SetEditTextFilter(IEditTextFilter* pFilter)
1819 {
1820         __pEdit->SetEditTextFilter(pFilter);
1821
1822         return;
1823 }
1824
1825 void
1826 _EditFieldImpl::SendOpaqueCommand(const String& command)
1827 {
1828         __pEdit->SendOpaqueCommand(command);
1829
1830         return;
1831 }
1832
1833 class _EditFieldMaker
1834         : public _UiBuilderControlMaker
1835 {
1836 public:
1837         _EditFieldMaker(_UiBuilder* pUiBuilder)
1838                 : _UiBuilderControlMaker(pUiBuilder){};
1839         virtual ~_EditFieldMaker(){};
1840         static _UiBuilderControlMaker* GetInstance(_UiBuilder* pUiBuilder)
1841         {
1842                 _EditFieldMaker* pEditFieldMaker = new (std::nothrow) _EditFieldMaker(pUiBuilder);
1843                 return pEditFieldMaker;
1844         };
1845 protected:
1846         virtual Control* Make(_UiBuilderControl* pControl)
1847         {
1848                 result r = E_SYSTEM;
1849                 _UiBuilderControlLayout* pControlProperty = null;
1850                 EditField* pEditField = null;
1851                 FloatRectangle rect;
1852
1853                 String elementString;
1854                 bool showTitle = false;
1855                 GroupStyle groupStyle = GROUP_STYLE_NONE;
1856                 InputStyle inputStyle = INPUT_STYLE_FULLSCREEN;
1857                 int limitLength = EDIT_FIELD_DEFAULT_LIMIT_LENGTH;
1858                 KeypadAction keypadAction = KEYPAD_ACTION_ENTER;
1859                 bool lowerCaseMode = false;
1860                 HorizontalAlignment horizontalAlignment = ALIGNMENT_LEFT;
1861                 bool viewModeEnable = false;
1862                 float fontSize = 0.0f;
1863                 Color color;
1864                 int opacity = EDIT_COLOR_OPACITY;
1865                 EditFieldStyle editFieldStyle = EDIT_FIELD_STYLE_NORMAL;
1866                 EditFieldTitleStyle editFieldTitleStyle = EDIT_FIELD_TITLE_STYLE_NONE;
1867                 bool clearButtonEnable = false;
1868                 bool newConstructEnable = false;
1869                 float horizontalMargin = 0.0f;
1870                 float verticalMargin = 0.0f;
1871                 EllipsisPosition ellipsisPosition = ELLIPSIS_POSITION_END;
1872
1873                 GetProperty(pControl, &pControlProperty);
1874                 if (pControlProperty == null)
1875                 {
1876                         return null;
1877                 }
1878
1879                 pEditField = new (std::nothrow) EditField();
1880                 if (pEditField == null)
1881                 {
1882                         return null;
1883                 }
1884
1885                 rect = pControlProperty->GetRectF();
1886                 String styleString;
1887                 styleString = pControlProperty->GetStyle();
1888
1889                 if (pControl->GetElement(L"inputStyle", elementString))
1890                 {
1891                         if (elementString.Equals(L"INPUT_STYLE_OVERLAY", false))
1892                         {
1893                                 inputStyle = INPUT_STYLE_OVERLAY;
1894                         }
1895                         else
1896                         {
1897                                 inputStyle = INPUT_STYLE_FULLSCREEN;
1898                         }
1899                 }
1900
1901                 if (pControl->GetElement(L"limitLength", elementString))
1902                 {
1903                         Base::Integer::Parse(elementString, limitLength);
1904                 }
1905                 if (pControl->GetElement(L"GroupStyle", elementString))
1906                 {
1907                         if (elementString.Equals(L"GROUP_STYLE_NONE", false))
1908                         {
1909                                 groupStyle = GROUP_STYLE_NONE;
1910                         }
1911                         if (elementString.Equals(L"GROUP_STYLE_SINGLE", false))
1912                         {
1913                                 groupStyle = GROUP_STYLE_SINGLE;
1914                         }
1915                         if (elementString.Equals(L"GROUP_STYLE_TOP", false))
1916                         {
1917                                 groupStyle = GROUP_STYLE_TOP;
1918                         }
1919                         if (elementString.Equals(L"GROUP_STYLE_MIDDLE", false))
1920                         {
1921                                 groupStyle = GROUP_STYLE_MIDDLE;
1922                         }
1923                         if (elementString.Equals(L"GROUP_STYLE_BOTTOM", false))
1924                         {
1925                                 groupStyle = GROUP_STYLE_BOTTOM;
1926                         }
1927                 }
1928
1929                 if (pControl->GetElement(L"titleStyle", elementString))
1930                 {
1931                         newConstructEnable = true;
1932
1933                         if (elementString.Equals(L"EDIT_FIELD_TITLE_STYLE_NONE", false))
1934                         {
1935                                 editFieldTitleStyle = EDIT_FIELD_TITLE_STYLE_NONE;
1936                         }
1937                         else if (elementString.Equals(L"EDIT_FIELD_TITLE_STYLE_INNER", false))
1938                         {
1939                                 editFieldTitleStyle = EDIT_FIELD_TITLE_STYLE_INNER;
1940                         }
1941                         else if (elementString.Equals(L"EDIT_FIELD_TITLE_STYLE_TOP", false))
1942                         {
1943                                 editFieldTitleStyle = EDIT_FIELD_TITLE_STYLE_TOP;
1944                         }
1945                 }
1946
1947                 if (pControl->GetElement(L"enableClear", elementString))
1948                 {
1949                         if (elementString.Equals(L"true", false))
1950                         {
1951                                 clearButtonEnable = true;
1952                         }
1953                 }
1954
1955                 if (styleString.Equals(L"EDIT_FIELD_STYLE_PASSWORD", false))
1956                 {
1957                         editFieldStyle = EDIT_FIELD_STYLE_PASSWORD;
1958                 }
1959                 else if (styleString.Equals(L"EDIT_FIELD_STYLE_NORMAL_SMALL", false))
1960                 {
1961                         editFieldStyle = EDIT_FIELD_STYLE_NORMAL_SMALL;
1962                 }
1963                 else if (styleString.Equals(L"EDIT_FIELD_STYLE_PASSWORD_SMALL", false))
1964                 {
1965                         editFieldStyle = EDIT_FIELD_STYLE_PASSWORD_SMALL;
1966                 }
1967                 else if (styleString.Equals(L"EDIT_FIELD_STYLE_EMAIL", false))
1968                 {
1969                         editFieldStyle = EDIT_FIELD_STYLE_EMAIL;
1970                 }
1971                 else if (styleString.Equals(L"EDIT_FIELD_STYLE_URL", false))
1972                 {
1973                         editFieldStyle = EDIT_FIELD_STYLE_URL;
1974                 }
1975                 else if (styleString.Equals(L"EDIT_FIELD_STYLE_EMAIL_SMALL", false))
1976                 {
1977                         editFieldStyle = EDIT_FIELD_STYLE_EMAIL_SMALL;
1978                 }
1979                 else if (styleString.Equals(L"EDIT_FIELD_STYLE_URL_SMALL", false))
1980                 {
1981                         editFieldStyle = EDIT_FIELD_STYLE_URL_SMALL;
1982                 }
1983                 else
1984                 {
1985                         editFieldStyle = EDIT_FIELD_STYLE_NORMAL;
1986                 }
1987
1988                 if (styleString.Equals(L"EDIT_FIELD_STYLE_NUMBER", false))
1989                 {
1990                         editFieldStyle = EDIT_FIELD_STYLE_NUMBER;
1991                 }
1992                 else if (styleString.Equals(L"EDIT_FIELD_STYLE_NUMBER_SMALL", false))
1993                 {
1994                         editFieldStyle = EDIT_FIELD_STYLE_NUMBER_SMALL;
1995                 }
1996                 else if (styleString.Equals(L"EDIT_FIELD_STYLE_PHONE_NUMBER", false))
1997                 {
1998                         editFieldStyle = EDIT_FIELD_STYLE_PHONE_NUMBER;
1999                 }
2000                 else if (styleString.Equals(L"EDIT_FIELD_STYLE_PHONE_NUMBER_SMALL", false))
2001                 {
2002                         editFieldStyle = EDIT_FIELD_STYLE_PHONE_NUMBER_SMALL;
2003                 }
2004                 else if (styleString.Equals(L"EDIT_FIELD_STYLE_PASSWORD_NUMBER", false))
2005                 {
2006                         editFieldStyle = EDIT_FIELD_STYLE_PASSWORD_NUMBER;
2007                 }
2008                 else if (styleString.Equals(L"EDIT_FIELD_STYLE_PASSWORD_NUMBER_SMALL", false))
2009                 {
2010                         editFieldStyle = EDIT_FIELD_STYLE_PASSWORD_NUMBER_SMALL;
2011                 }
2012                 else if (styleString.Equals(L"EDIT_FIELD_STYLE_IP_V4", false))
2013                 {
2014                         editFieldStyle = EDIT_FIELD_STYLE_IP_V4;
2015                 }
2016                 else if (styleString.Equals(L"EDIT_FIELD_STYLE_IP_V4_SMALL", false))
2017                 {
2018                         editFieldStyle = EDIT_FIELD_STYLE_IP_V4_SMALL;
2019                 }
2020
2021                 if (newConstructEnable)
2022                 {
2023                         r = pEditField->Construct(rect, editFieldStyle, inputStyle, editFieldTitleStyle, clearButtonEnable, limitLength, groupStyle);
2024                 }
2025                 else
2026                 {
2027                         r = pEditField->Construct(rect, editFieldStyle, inputStyle, showTitle, limitLength, groupStyle);
2028                 }
2029
2030                 if (r != E_SUCCESS)
2031                 {
2032                         delete pEditField;
2033                         pEditField = null;
2034
2035                         return null;
2036                 }
2037
2038                 if (pControl->GetElement(L"commandButtonVisible", elementString))
2039                 {
2040                         if (elementString.Equals(L"true", false))
2041                         {
2042                                 pEditField->SetOverlayKeypadCommandButtonVisible(true);
2043                         }
2044                         else
2045                         {
2046                                 pEditField->SetOverlayKeypadCommandButtonVisible(false);
2047                         }
2048                 }
2049
2050                 if (pControl->GetElement(L"text", elementString))
2051                 {
2052                         r = pEditField->SetText(elementString);
2053                 }
2054                 if (pControl->GetElement(L"guideText", elementString))
2055                 {
2056                         pEditField->SetGuideText(elementString);
2057                 }
2058                 if (pControl->GetElement(L"titleText", elementString))
2059                 {
2060                         r = pEditField->SetTitleText(elementString);
2061                 }
2062                 if (pControl->GetElement(L"keypadEnabled", elementString) || pControl->GetElement(L"KeypadEnabled", elementString))
2063                 {
2064                         if (elementString.Equals(L"true", false))
2065                         {
2066                                 pEditField->SetKeypadEnabled(true);
2067                         }
2068                         else
2069                         {
2070                                 pEditField->SetKeypadEnabled(false);
2071                         }
2072                 }
2073                 else
2074                         pEditField->SetKeypadEnabled(true);
2075
2076                 if (pControl->GetElement(L"keypadAction", elementString))
2077                 {
2078                         if (elementString.Equals(L"KEYPAD_ACTION_ENTER", false))
2079                         {
2080                                 keypadAction = KEYPAD_ACTION_ENTER;
2081                         }
2082                         else if (elementString.Equals(L"KEYPAD_ACTION_GO", false))
2083                         {
2084                                 keypadAction = KEYPAD_ACTION_GO;
2085                         }
2086                         else if (elementString.Equals(L"KEYPAD_ACTION_NEXT", false))
2087                         {
2088                                 keypadAction = KEYPAD_ACTION_NEXT;
2089                         }
2090                         else if (elementString.Equals(L"KEYPAD_ACTION_SEND", false))
2091                         {
2092                                 keypadAction = KEYPAD_ACTION_SEND;
2093                         }
2094                         else if (elementString.Equals(L"KEYPAD_ACTION_SEARCH", false))
2095                         {
2096                                 keypadAction = KEYPAD_ACTION_SEARCH;
2097                         }
2098                         else if (elementString.Equals(L"KEYPAD_ACTION_LOGIN", false))
2099                         {
2100                                 keypadAction = KEYPAD_ACTION_LOGIN;
2101                         }
2102                         else if (elementString.Equals(L"KEYPAD_ACTION_SIGN_IN", false))
2103                         {
2104                                 keypadAction = KEYPAD_ACTION_SIGN_IN;
2105                         }
2106                         else if (elementString.Equals(L"KEYPAD_ACTION_JOIN", false))
2107                         {
2108                                 keypadAction = KEYPAD_ACTION_JOIN;
2109                         }
2110                         else if (elementString.Equals(L"KEYPAD_ACTION_DONE", false))
2111                         {
2112                                 keypadAction = KEYPAD_ACTION_DONE;
2113                         }
2114
2115                         r = pEditField->SetKeypadAction(keypadAction);
2116                 }
2117
2118                 if (pControl->GetElement(L"textHorizontalAlignment", elementString))
2119                 {
2120                         if (elementString.Equals(L"ALIGNMENT_LEFT", false))
2121                         {
2122                                 horizontalAlignment = ALIGNMENT_LEFT;
2123                         }
2124                         else if (elementString.Equals(L"ALIGNMENT_CENTER", false))
2125                         {
2126                                 horizontalAlignment = ALIGNMENT_CENTER;
2127                         }
2128                         else if (elementString.Equals(L"ALIGNMENT_RIGHT", false))
2129                         {
2130                                 horizontalAlignment = ALIGNMENT_RIGHT;
2131                         }
2132
2133                         r = pEditField->SetTextAlignment(horizontalAlignment);
2134                 }
2135
2136                 if (pControl->GetElement(L"lowerCaseMode", elementString))
2137                 {
2138                         if (elementString.Equals(L"true", false))
2139                         {
2140                                 lowerCaseMode = true;
2141                         }
2142                         else
2143                         {
2144                                 lowerCaseMode = false;
2145                         }
2146
2147                         pEditField->SetLowerCaseModeEnabled(lowerCaseMode);
2148                 }
2149
2150                 if (pControl->GetElement(L"textSize", elementString))
2151                 {
2152                         fontSize = _LocalizedNumParser::ToDouble(elementString, "C");
2153                         _ICoordinateSystemTransformer* pTransform = GetTransformer();
2154                         if (pTransform)
2155                         {
2156                                 fontSize = pTransform->Transform(fontSize);
2157                         }
2158                         r = pEditField->SetTextSize(fontSize);
2159                 }
2160
2161                 if (pControl->GetElement(L"viewMode", elementString))
2162                 {
2163                         if (elementString.Equals(L"true", false))
2164                         {
2165                                 viewModeEnable = true;
2166                                 r = pEditField->SetViewModeEnabled(viewModeEnable);
2167                         }
2168                 }
2169
2170                 if (pControl->GetElement(L"normalBGBitmapPath", elementString))
2171                 {
2172                         Bitmap* pressedBGBitmap = null;
2173                         pressedBGBitmap = LoadBitmapN(elementString);
2174                         if (pressedBGBitmap != null)
2175                         {
2176                                 r = pEditField->SetBackgroundBitmap(EDIT_STATUS_NORMAL, *pressedBGBitmap);
2177                                 delete pressedBGBitmap;
2178                                 pressedBGBitmap = null;
2179                         }
2180                 }
2181
2182                 if (pControl->GetElement(L"disabledBGBitmapPath", elementString))
2183                 {
2184                         Bitmap* disalbedBGBitmap = null;
2185                         disalbedBGBitmap = LoadBitmapN(elementString);
2186                         if (disalbedBGBitmap != null)
2187                         {
2188                                 r = pEditField->SetBackgroundBitmap(EDIT_STATUS_DISABLED, *disalbedBGBitmap);
2189                                 delete disalbedBGBitmap;
2190                                 disalbedBGBitmap = null;
2191                         }
2192                 }
2193
2194                 if (pControl->GetElement(L"highlightedBGBitmapPath", elementString))
2195                 {
2196                         Bitmap* highlightedBGBitmap = null;
2197                         highlightedBGBitmap = LoadBitmapN(elementString);
2198                         if (highlightedBGBitmap != null)
2199                         {
2200                                 r = pEditField->SetBackgroundBitmap(EDIT_STATUS_HIGHLIGHTED, *highlightedBGBitmap);
2201                                 delete highlightedBGBitmap;
2202                                 highlightedBGBitmap = null;
2203                         }
2204                 }
2205
2206                 if (pControl->GetElement(L"pressedBGBitmapPath", elementString))
2207                 {
2208                         Bitmap* pressedBGBitmap = null;
2209                         pressedBGBitmap = LoadBitmapN(elementString);
2210                         if (pressedBGBitmap != null)
2211                         {
2212                                 r = pEditField->SetBackgroundBitmap(EDIT_STATUS_PRESSED, *pressedBGBitmap);
2213                                 delete pressedBGBitmap;
2214                                 pressedBGBitmap = null;
2215                         }
2216                 }
2217
2218                 if (pControl->GetElement(L"normalColorOpacity", elementString))
2219                 {
2220                         Base::Integer::Parse(elementString, opacity);
2221                 }
2222                 if (pControl->GetElement(L"normalColor", elementString))
2223                 {
2224                         ConvertStringToColor32(elementString, opacity, color);
2225                         r = pEditField->SetColor(EDIT_STATUS_NORMAL, color);
2226                 }
2227
2228                 if (pControl->GetElement(L"pressedColorOpacity", elementString))
2229                 {
2230                         Base::Integer::Parse(elementString, opacity);
2231                 }
2232                 if (pControl->GetElement(L"pressedColor", elementString))
2233                 {
2234                         ConvertStringToColor32(elementString, opacity, color);
2235                         r = pEditField->SetColor(EDIT_STATUS_PRESSED, color);
2236                 }
2237
2238                 if (pControl->GetElement(L"highlightedColorOpacity", elementString))
2239                 {
2240                         Base::Integer::Parse(elementString, opacity);
2241                 }
2242                 if (pControl->GetElement(L"highlightedColor", elementString))
2243                 {
2244                         ConvertStringToColor32(elementString, opacity, color);
2245                         r = pEditField->SetColor(EDIT_STATUS_HIGHLIGHTED, color);
2246                 }
2247
2248                 if (pControl->GetElement(L"disabledColorOpacity", elementString))
2249                 {
2250                         Base::Integer::Parse(elementString, opacity);
2251                 }
2252                 if (pControl->GetElement(L"disabledColor", elementString))
2253                 {
2254                         ConvertStringToColor32(elementString, opacity, color);
2255                         r = pEditField->SetColor(EDIT_STATUS_DISABLED, color);
2256                 }
2257
2258                 opacity = 100;
2259                 if (pControl->GetElement(L"guideTextColor", elementString))
2260                 {
2261                         ConvertStringToColor32(elementString, opacity, color);
2262                         r = pEditField->SetGuideTextColor(color);
2263                 }
2264
2265                 if (pControl->GetElement(L"normalTextColor", elementString))
2266                 {
2267                         ConvertStringToColor32(elementString, opacity, color);
2268                         r = pEditField->SetTextColor(EDIT_TEXT_COLOR_NORMAL, color);
2269                 }
2270
2271                 if (pControl->GetElement(L"disabledTextColor", elementString))
2272                 {
2273                         ConvertStringToColor32(elementString, opacity, color);
2274                         r = pEditField->SetTextColor(EDIT_TEXT_COLOR_DISABLED, color);
2275                 }
2276
2277                 if (pControl->GetElement(L"highlightedTextColor", elementString))
2278                 {
2279                         ConvertStringToColor32(elementString, opacity, color);
2280                         r = pEditField->SetTextColor(EDIT_TEXT_COLOR_HIGHLIGHTED, color);
2281                 }
2282
2283                 if (pControl->GetElement(L"linkTextColor", elementString))
2284                 {
2285                         ConvertStringToColor32(elementString, opacity, color);
2286                         r = pEditField->SetTextColor(EDIT_TEXT_COLOR_LINK, color);
2287                 }
2288
2289                 if (pControl->GetElement(L"horizontalMargin", elementString))
2290                 {
2291                         horizontalMargin = _LocalizedNumParser::ToDouble(elementString, "C");
2292                         r = pEditField->SetMargin(EDIT_MARGIN_TYPE_HORIZONTAL, horizontalMargin);
2293                 }
2294
2295                 if (pControl->GetElement(L"verticalMargin", elementString))
2296                 {
2297                         verticalMargin = _LocalizedNumParser::ToDouble(elementString, "C");
2298                         r = pEditField->SetMargin(EDIT_MARGIN_TYPE_VERTICAL, verticalMargin);
2299                 }
2300
2301                 if (pControl->GetElement(L"titleTextColor", elementString))
2302                 {
2303                         ConvertStringToColor32(elementString, opacity, color);
2304                         r = pEditField->SetTitleTextColor(EDIT_STATUS_NORMAL, color);
2305                 }
2306
2307                 if (pControl->GetElement(L"ellipsisPosition", elementString))
2308                 {
2309                         if (elementString.Equals(L"ELLIPSIS_POSITION_START", false))
2310                         {
2311                                 ellipsisPosition = ELLIPSIS_POSITION_START;
2312                         }
2313                         else if (elementString.Equals(L"ELLIPSIS_POSITION_MIDDLE", false))
2314                         {
2315                                 ellipsisPosition = ELLIPSIS_POSITION_MIDDLE;
2316                         }
2317                         else
2318                         {
2319                                 ellipsisPosition = ELLIPSIS_POSITION_END;
2320                         }
2321
2322                         r = pEditField->SetEllipsisPosition(ellipsisPosition);
2323                 }
2324
2325                 if (pControl->GetElement(L"accessibilityHint", elementString))
2326                 {
2327                         AccessibilityContainer* pContainer = pEditField->GetAccessibilityContainer();
2328                         if (pContainer)
2329                         {
2330                                 AccessibilityElement* pElement = pContainer->GetElement(L"EditText");
2331                                 if (pElement)
2332                                 {
2333                                         pElement->SetHint(elementString);
2334                                 }
2335                         }
2336                 }
2337
2338                 return pEditField;
2339         }
2340 }; // _EditFieldMaker
2341
2342 _EditFieldRegister::_EditFieldRegister(void)
2343 {
2344           _UiBuilderControlTableManager* pUiBuilderControlTableManager = _UiBuilderControlTableManager::GetInstance();
2345           pUiBuilderControlTableManager->RegisterControl(L"EditField", _EditFieldMaker::GetInstance);
2346 }
2347
2348 _EditFieldRegister::~_EditFieldRegister(void)
2349 {
2350           _UiBuilderControlTableManager* pUiBuilderControlTableManager = _UiBuilderControlTableManager::GetInstance();
2351           pUiBuilderControlTableManager->UnregisterControl(L"EditField");
2352 }
2353 static _EditFieldRegister EditFieldRegisterToUiBuilder;
2354 }}} // Tizen::Ui::Controls