src/ui/controls/FUiCtrl_TextBoxImpl.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_TextBoxImpl.cpp
  20 * @brief        This is the implementation file for _TextBoxImpl class.
  21 */
  22
  23 #include <new>
  24 #include <FBaseSysLog.h>
  25 #include <FBase_LocalizedNumParser.h>
  26 #include <FUiAccessibilityContainer.h>
  27 #include <FUiAccessibilityElement.h>
  28 #include "FUi_CoordinateSystemUtils.h"
  29 #include "FUi_UiBuilder.h"
  30 #include "FUiCtrl_TextBoxImpl.h"
  31 #include "FUiCtrl_PublicTextBlockEvent.h"
  32 #include "FUiCtrl_PublicLinkEvent.h"
  33 #include "FUi_CoordinateSystemUtils.h"
  34
  35 using namespace Tizen::Base;
  36 using namespace Tizen::Base::Runtime;
  37 using namespace Tizen::Base::Utility;
  38 using namespace Tizen::Graphics;
  39 using namespace Tizen::Ui;
  40
  41 namespace Tizen { namespace Ui { namespace Controls
  42 {
  43
  44 const int TEXTBOX_LENGTH_MAX = 2048;
  45
  46 _TextBoxImpl::_TextBoxImpl(TextBox* pPublic, _Edit* pCore)
  47         : _ControlImpl(pPublic, pCore)
  48         , __pEdit(pCore)
  49         , __pPublicTextBlockEvent(null)
  50         , __pPublicLinkEvent(null)
  51         , __autoLinkMask(LINK_TYPE_NONE)
  52 {
  53 }
  54
  55 _TextBoxImpl::~_TextBoxImpl(void)
  56 {
  57         if (__pPublicTextBlockEvent)
  58         {
  59                 delete __pPublicTextBlockEvent;
  60                 __pPublicTextBlockEvent = null;
  61         }
  62
  63         if (__pPublicLinkEvent)
  64         {
  65                 delete __pPublicLinkEvent;
  66                 __pPublicLinkEvent = null;
  67         }
  68 }
  69
  70 _TextBoxImpl*
  71 _TextBoxImpl::CreateTextBoxImplN(TextBox* pPublic)
  72 {
  73         ClearLastResult();
  74         result r = E_SUCCESS;
  75
  76         _Edit* pCore = _Edit::CreateEditN();
  77         SysTryReturn(NID_UI_CTRL, pCore, null, GetLastResult(), "[%s] Propagating.", GetErrorMessage(r));
  78
  79         _TextBoxImpl* pImpl = new (std::nothrow) _TextBoxImpl(pPublic, pCore);
  80
  81         r = _ControlImpl::CheckConstruction(pCore, pImpl);
  82     SysTryReturn(NID_UI_CTRL, r == E_SUCCESS, null, r, "[%s] Propagating.", GetErrorMessage(r));
  83
  84         r = GetLastResult();
  85         SysTryCatch(NID_UI_CTRL, r == E_SUCCESS, , r, "[%s] Propagating.", GetErrorMessage(r));
  86
  87         return pImpl;
  88
  89 CATCH:
  90         delete pCore;
  91         delete pImpl;
  92         return null;
  93 }
  94
  95 const char*
  96 _TextBoxImpl::GetPublicClassName(void) const
  97 {
  98         return "Tizen::Ui::Controls::TextBox";
  99 }
 100
 101 const TextBox&
 102 _TextBoxImpl::GetPublic(void) const
 103 {
 104         return static_cast <const TextBox&>(_ControlImpl::GetPublic());
 105 }
 106
 107 TextBox&
 108 _TextBoxImpl::GetPublic(void)
 109 {
 110         return static_cast <TextBox&>(_ControlImpl::GetPublic());
 111 }
 112
 113 const _Edit&
 114 _TextBoxImpl::GetCore(void) const
 115 {
 116         return static_cast <const _Edit&>(_ControlImpl::GetCore());
 117 }
 118
 119 _Edit&
 120 _TextBoxImpl::GetCore(void)
 121 {
 122         return static_cast <_Edit&>(_ControlImpl::GetCore());
 123 }
 124
 125 result
 126 _TextBoxImpl::Initialize(TextBoxBorder border)
 127 {
 128         result r = E_SUCCESS;
 129
 130         r = __pEdit->Initialize(EDIT_STYLE_VIEWER, INPUT_STYLE_OVERLAY, TEXTBOX_LENGTH_MAX);
 131
 132         if (border == TEXT_BOX_BORDER_ROUNDED)
 133         {
 134                 __pEdit->SetBorderRoundStyleEnabled(true);
 135         }
 136         else
 137         {
 138                 __pEdit->SetBorderRoundStyleEnabled(false);
 139         }
 140
 141         if (r != E_SUCCESS)
 142         {
 143                 goto CATCH;
 144         }
 145
 146         __pEdit->SetAutoLinkMask(LINK_TYPE_URL | LINK_TYPE_EMAIL | LINK_TYPE_TEL_NUM);
 147
 148         return r;
 149
 150 CATCH:
 151         Dispose();
 152         return r;
 153 }
 154
 155 result
 156 _TextBoxImpl::Dispose(void)
 157 {
 158         result r = E_SUCCESS;
 159
 160         if (__pEdit)
 161         {
 162                 delete __pEdit;
 163                 __pEdit = null;
 164         }
 165
 166         return r;
 167 }
 168
 169 result
 170 _TextBoxImpl::SetAutoLinkMask(unsigned long autoLinks)
 171 {
 172         __autoLinkMask = autoLinks;
 173
 174         return __pEdit->SetAutoLinkMask(autoLinks);
 175 }
 176
 177 unsigned long
 178 _TextBoxImpl::GetAutoLinkMask(void) const
 179 {
 180         return __autoLinkMask;
 181 }
 182
 183 result
 184 _TextBoxImpl::AddUiLinkEventListener(IUiLinkEventListener& listener)
 185 {
 186         if (__pPublicLinkEvent == null)
 187         {
 188                 __pPublicLinkEvent = _PublicLinkEvent::CreateInstanceN(GetPublic());
 189
 190                 if (IsFailed(GetLastResult()))
 191                 {
 192                         SysLogException(NID_UI_CTRL, E_SYSTEM, "[E_SYSTEM] System error occurred.");
 193                         delete __pPublicLinkEvent;
 194                         return E_SYSTEM;
 195                 }
 196         }
 197
 198         __pPublicLinkEvent->AddListener(listener);
 199         __pEdit->AddUiLinkEventListener(*this);
 200
 201         return E_SUCCESS;
 202 }
 203
 204 result
 205 _TextBoxImpl::RemoveUiLinkEventListener(IUiLinkEventListener& listener)
 206 {
 207         SysTryReturn(NID_UI_CTRL, __pPublicLinkEvent, E_SYSTEM, E_SYSTEM,
 208                                 "[E_SYSTEM] This instance isn't constructed.")
 209
 210         __pPublicLinkEvent->RemoveListener(listener);
 211         __pEdit->RemoveUiLinkEventListener(*this);
 212
 213         return E_SUCCESS;
 214 }
 215
 216 result
 217 _TextBoxImpl::AppendCharacter(const Character& character)
 218 {
 219         return __pEdit->AppendCharacter(character);
 220 }
 221
 222 result
 223 _TextBoxImpl::AppendText(const String& text)
 224 {
 225         return __pEdit->AppendText(text);
 226 }
 227
 228 result
 229 _TextBoxImpl::Clear(void)
 230 {
 231         return __pEdit->ClearText();
 232 }
 233
 234 int
 235 _TextBoxImpl::GetLineCount(void) const
 236 {
 237         return __pEdit->GetTextLineCount();
 238 }
 239
 240 String
 241 _TextBoxImpl::GetText(void) const
 242 {
 243         return __pEdit->GetText();
 244 }
 245
 246 String
 247 _TextBoxImpl::GetText(int start, int end) const
 248 {
 249         return __pEdit->GetText(start, end);
 250 }
 251
 252 int
 253 _TextBoxImpl::GetTextLength(void) const
 254 {
 255         return __pEdit->GetTextLength();
 256 }
 257
 258 result
 259 _TextBoxImpl::InsertCharacterAt(int index, const Character& character)
 260 {
 261         result r = __pEdit->InsertCharacterAt(index, character);
 262
 263         if (r == E_INVALID_ARG)
 264         {
 265                 r = E_OUT_OF_RANGE;
 266         }
 267
 268         return r;
 269 }
 270
 271 result
 272 _TextBoxImpl::InsertTextAt(int index, const String& text)
 273 {
 274         result r = __pEdit->InsertTextAt(index, text);
 275
 276         if (r == E_INVALID_ARG)
 277         {
 278                 r = E_OUT_OF_RANGE;
 279         }
 280
 281         return r;
 282 }
 283
 284 result
 285 _TextBoxImpl::SetText(const String& text)
 286 {
 287         return __pEdit->SetText(text);
 288 }
 289
 290 int
 291 _TextBoxImpl::GetLineSpacing(void) const
 292 {
 293         return _CoordinateSystemUtils::ConvertToInteger(GetLineSpacingF());
 294 }
 295
 296 float
 297 _TextBoxImpl::GetLineSpacingF(void) const
 298 {
 299         return __pEdit->GetLineSpacingF();
 300 }
 301
 302 result
 303 _TextBoxImpl::SetLineSpacing(int multiplier, int extra)
 304 {
 305         return SetLineSpacing(multiplier, _CoordinateSystemUtils::ConvertToFloat(extra));
 306 }
 307
 308 result
 309 _TextBoxImpl::SetLineSpacing(int multiplier, float extra)
 310 {
 311         SysTryReturn(NID_UI_CTRL, multiplier >= 0, E_INVALID_ARG, E_INVALID_ARG, "[E_INVALID_ARG] The invalid argument is given.");
 312         SysTryReturn(NID_UI_CTRL, extra >= 0.0f, E_INVALID_ARG, E_INVALID_ARG, "[E_INVALID_ARG] The invalid argument is given.");
 313
 314         return __pEdit->SetLineSpacing(DEFAULT_LINE_SPACE * multiplier + extra);
 315 }
 316
 317 HorizontalAlignment
 318 _TextBoxImpl::GetTextAlignment(void) const
 319 {
 320         return __pEdit->GetTextAlignment();
 321 }
 322
 323 result
 324 _TextBoxImpl::SetTextAlignment(HorizontalAlignment alignment)
 325 {
 326         return __pEdit->SetTextAlignment(alignment);
 327 }
 328
 329 int
 330 _TextBoxImpl::GetTextSize(void) const
 331 {
 332         return _CoordinateSystemUtils::ConvertToInteger(GetTextSizeF());
 333 }
 334
 335 float
 336 _TextBoxImpl::GetTextSizeF(void) const
 337 {
 338         return __pEdit->GetTextSizeF();
 339 }
 340
 341 result
 342 _TextBoxImpl::SetTextSize(int size)
 343 {
 344         return __pEdit->SetTextSize(_CoordinateSystemUtils::ConvertToFloat(size));
 345 }
 346
 347 result
 348 _TextBoxImpl::SetTextSize(float size)
 349 {
 350         return __pEdit->SetTextSize(size);
 351 }
 352
 353 int
 354 _TextBoxImpl::GetTextTotalHeight(void) const
 355 {
 356         return _CoordinateSystemUtils::ConvertToInteger(GetTextTotalHeightF());
 357 }
 358
 359 float
 360 _TextBoxImpl::GetTextTotalHeightF(void) const
 361 {
 362         return __pEdit->GetTextTotalHeightF();
 363 }
 364
 365 result
 366 _TextBoxImpl::GetFontType(String& typefaceName, unsigned long& styleMask) const
 367 {
 368         __pEdit->GetFontType(typefaceName, styleMask);
 369
 370         return E_SUCCESS;
 371 }
 372
 373 unsigned long
 374 _TextBoxImpl::GetTextStyle(void) const
 375 {
 376         return __pEdit->GetTextStyle();
 377 }
 378
 379 result
 380 _TextBoxImpl::SetFontType(const String& typefaceName, unsigned long styleMask)
 381 {
 382         return __pEdit->SetFontType(typefaceName, styleMask);
 383 }
 384
 385 result
 386 _TextBoxImpl::SetTextStyle(unsigned long style)
 387 {
 388         return __pEdit->SetTextStyle(style);
 389 }
 390
 391 result
 392 _TextBoxImpl::SetFont(const Font& font)
 393 {
 394         return __pEdit->SetFont(font);
 395 }
 396
 397 result
 398 _TextBoxImpl::ReleaseBlock(void)
 399 {
 400         return __pEdit->ReleaseTextBlock();
 401 }
 402
 403 result
 404 _TextBoxImpl::GetBlockRange(int& start, int& end) const
 405 {
 406         __pEdit->GetBlockRange(start, end);
 407
 408         return E_SUCCESS;
 409 }
 410
 411 result
 412 _TextBoxImpl::SetBlockRange(int start, int end)
 413 {
 414         SysTryReturnResult(NID_UI_CTRL, (start > -1 && end > -1), E_INVALID_ARG, "[E_INVALID_ARG] The invalid argument is given.\n");
 415         SysTryReturnResult(NID_UI_CTRL, (end > start), E_INVALID_ARG, "[E_INVALID_ARG] The invalid argument is given.\n");
 416
 417         int tempTextLength = 0;
 418         tempTextLength = __pEdit->GetTextLength();
 419         SysTryReturnResult(NID_UI_CTRL, (tempTextLength > start && tempTextLength > end), E_INVALID_ARG,
 420                                           "[E_INVALID_ARG] The invalid argument is given.\n");
 421
 422         return __pEdit->SetBlockRange(start, end);
 423 }
 424
 425 result
 426 _TextBoxImpl::AddTextBlockEventListener(ITextBlockEventListener& listener)
 427 {
 428         if (__pPublicTextBlockEvent == null)
 429         {
 430                 __pPublicTextBlockEvent = _PublicTextBlockEvent::CreateInstanceN(GetPublic());
 431
 432                 if (IsFailed(GetLastResult()))
 433                 {
 434                         SysLogException(NID_UI_CTRL, E_SYSTEM, "[E_SYSTEM] System error occurred.");
 435                         delete __pPublicTextBlockEvent;
 436                         return E_SYSTEM;
 437                 }
 438         }
 439
 440         __pPublicTextBlockEvent->AddListener(listener);
 441         __pEdit->AddTextBlockEventListener(*this);
 442
 443         return E_SUCCESS;
 444 }
 445
 446 result
 447 _TextBoxImpl::RemoveTextBlockEventListener(ITextBlockEventListener& listener)
 448 {
 449         SysTryReturn(NID_UI_CTRL, __pPublicTextBlockEvent, E_SYSTEM, E_SYSTEM,
 450                                 "[E_SYSTEM] This instance isn't constructed.")
 451
 452         __pPublicTextBlockEvent->RemoveListener(listener);
 453         __pEdit->RemoveTextBlockEventListener(*this);
 454
 455         return E_SUCCESS;
 456 }
 457
 458 Color
 459 _TextBoxImpl::GetColor(TextBoxStatus status) const
 460 {
 461         return __pEdit->GetColor(ConvertStatus(status));
 462 }
 463
 464 Color
 465 _TextBoxImpl::GetTextColor(TextBoxTextColor type) const
 466 {
 467         if (type == TEXT_BOX_TEXT_COLOR_BLOCKED)
 468         {
 469                 return __pEdit->GetBlockTextColor();
 470         }
 471         else
 472         {
 473                 return __pEdit->GetTextColor(ConvertTextColorType(type));
 474         }
 475 }
 476
 477 result
 478 _TextBoxImpl::SetColor(TextBoxStatus status, const Color& color)
 479 {
 480         if (status == TEXT_BOX_STATUS_HIGHLIGHTED)
 481         {
 482                 __pEdit->SetColor(EDIT_STATUS_PRESSED, color);
 483         }
 484
 485         return __pEdit->SetColor(ConvertStatus(status), color);
 486 }
 487
 488 result
 489 _TextBoxImpl::SetTextColor(TextBoxTextColor type, const Color& color)
 490 {
 491         if (type == TEXT_BOX_TEXT_COLOR_BLOCKED)
 492         {
 493                 return __pEdit->SetBlockTextColor(color);
 494         }
 495         else
 496         {
 497                 return __pEdit->SetTextColor(ConvertTextColorType(type), color);
 498         }
 499 }
 500
 501 result
 502 _TextBoxImpl::SetBackgroundBitmap(TextBoxStatus status, const Bitmap& bitmap)
 503 {
 504         if (status == TEXT_BOX_STATUS_HIGHLIGHTED)
 505         {
 506                 __pEdit->SetBackgroundBitmap(EDIT_STATUS_PRESSED, bitmap);
 507         }
 508
 509         return __pEdit->SetBackgroundBitmap(ConvertStatus(status), bitmap);
 510 }
 511
 512 EditTextColor
 513 _TextBoxImpl::ConvertTextColorType(TextBoxTextColor type) const
 514 {
 515         EditTextColor editTextColorType = EDIT_TEXT_COLOR_NORMAL;
 516
 517         switch (type)
 518         {
 519         case TEXT_BOX_TEXT_COLOR_NORMAL:
 520                 editTextColorType = EDIT_TEXT_COLOR_NORMAL;
 521                 break;
 522
 523         case TEXT_BOX_TEXT_COLOR_HIGHLIGHTED:
 524                 editTextColorType = EDIT_TEXT_COLOR_HIGHLIGHTED;
 525                 break;
 526
 527         case TEXT_BOX_TEXT_COLOR_DISABLED:
 528                 editTextColorType = EDIT_TEXT_COLOR_DISABLED;
 529                 break;
 530
 531         case TEXT_BOX_TEXT_COLOR_LINK:
 532                 editTextColorType = EDIT_TEXT_COLOR_LINK;
 533                 break;
 534
 535         case TEXT_BOX_TEXT_COLOR_BLOCKED:
 536         default:
 537                 editTextColorType = EDIT_TEXT_COLOR_NORMAL;
 538                 break;
 539         }
 540
 541         return editTextColorType;
 542 }
 543
 544 EditStatus
 545 _TextBoxImpl::ConvertStatus(TextBoxStatus status) const
 546 {
 547         EditStatus editStatus = EDIT_STATUS_NORMAL;
 548
 549         switch (status)
 550         {
 551         case TEXT_BOX_STATUS_NORMAL:
 552                 editStatus = EDIT_STATUS_NORMAL;
 553                 break;
 554
 555         case TEXT_BOX_STATUS_HIGHLIGHTED:
 556                 editStatus = EDIT_STATUS_HIGHLIGHTED;
 557                 break;
 558
 559         case TEXT_BOX_STATUS_DISABLED:
 560                 editStatus = EDIT_STATUS_DISABLED;
 561                 break;
 562
 563         default:
 564                 editStatus = EDIT_STATUS_NORMAL;
 565                 break;
 566         }
 567
 568         return editStatus;
 569 }
 570
 571 result
 572 _TextBoxImpl::OnBoundsChanged(const Rectangle& oldRect, const Rectangle& newRect)
 573 {
 574         return E_SUCCESS;
 575 }
 576
 577 result
 578 _TextBoxImpl::OnBoundsChanged(const FloatRectangle& oldRect, const FloatRectangle& newRect)
 579 {
 580         return E_SUCCESS;
 581 }
 582
 583 void
 584 _TextBoxImpl::OnLinkClicked(_Control& source, const String& text, LinkType linkType,
 585                                                         const String& link)
 586 {
 587         if (__pPublicLinkEvent != null)
 588         {
 589                 IEventArg* pLinkEventArg = _PublicLinkEvent::CreateLinkEventArgN(text, linkType, link);
 590                 SysTryReturnVoidResult(NID_UI_CTRL, pLinkEventArg, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] Unable to create _LinkEventArg.");
 591
 592                 __pPublicLinkEvent->Fire(*pLinkEventArg);
 593         }
 594 }
 595
 596 void
 597 _TextBoxImpl::OnTextBlockSelected(_Control& source, int start, int end)
 598 {
 599         if (__pPublicTextBlockEvent != null)
 600         {
 601                 IEventArg* pTextBlockEventArg = _PublicTextBlockEvent::CreateTextBlockEventArgN(start, end);
 602                 SysTryReturnVoidResult(NID_UI_CTRL, pTextBlockEventArg, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] Unable to create _TextBlockEventArg.");
 603
 604                 __pPublicTextBlockEvent->Fire(*pTextBlockEventArg);
 605         }
 606 }
 607
 608 FloatDimension
 609 _TextBoxImpl::GetContentSizeF(bool horizontalMode, bool verticalMode) const
 610 {
 611         return __pEdit->GetContentSizeInternalF(horizontalMode, verticalMode);
 612 }
 613
 614 _TextBoxImpl*
 615 _TextBoxImpl::GetInstance(TextBox& textBox)
 616 {
 617         return static_cast<_TextBoxImpl*> (textBox._pControlImpl);
 618 }
 619
 620 const _TextBoxImpl*
 621 _TextBoxImpl::GetInstance(const TextBox& textBox)
 622 {
 623         return static_cast<const _TextBoxImpl*> (textBox._pControlImpl);
 624 }
 625
 626 class _TextBoxMaker
 627         : public _UiBuilderControlMaker
 628 {
 629 public:
 630         _TextBoxMaker(_UiBuilder* uibuilder)
 631                 : _UiBuilderControlMaker(uibuilder){};
 632         virtual ~_TextBoxMaker(){};
 633         static _UiBuilderControlMaker* GetInstance(_UiBuilder* uibuilder)
 634         {
 635                 _TextBoxMaker* pTextBoxMaker = new (std::nothrow) _TextBoxMaker(uibuilder);
 636                 return pTextBoxMaker;
 637         };
 638
 639 protected:
 640         virtual Control* Make(_UiBuilderControl* pControl)
 641         {
 642                 result r = E_SUCCESS;
 643
 644                 FloatRectangle rect;
 645
 646                 TextBox* pTextBox = null;
 647                 _UiBuilderControlLayout* pControlProperty = null;
 648                 HorizontalAlignment textAlignment = ALIGNMENT_LEFT;
 649                 TextBoxBorder textboxBorder = TEXT_BOX_BORDER_ROUNDED;
 650                 String text;
 651                 Color color;
 652                 int opacity = 100;
 653                 float textSize = 0.0f;
 654                 float lineSpacingExtra = 0.0f;
 655                 int lineSpacingMultiplier = 1;
 656                 String elementString;
 657
 658                 GetProperty(pControl, &pControlProperty);
 659                 if (pControlProperty == null)
 660                 {
 661                         return null;
 662                 }
 663
 664                 pTextBox = new (std::nothrow) TextBox();
 665                 if (pTextBox == null)
 666                 {
 667                         return null;
 668                 }
 669
 670                 rect = pControlProperty->GetRectF();
 671                 if (pControl->GetElement("textboxBorder", elementString))
 672                 {
 673                         if (elementString.Equals(L"TEXT_BOX_BORDER_NONE", false))
 674                         {
 675                                 textboxBorder = TEXT_BOX_BORDER_NONE;
 676                         }
 677                         else if (elementString.Equals(L"TEXT_BOX_BORDER_ROUNDED", false))
 678                         {
 679                                 textboxBorder = TEXT_BOX_BORDER_ROUNDED;
 680                         }
 681                         else if (elementString.Equals(L"TEXT_BOX_BORDER_LINE", false))
 682                         {
 683                                 textboxBorder = TEXT_BOX_BORDER_ROUNDED;
 684                         }
 685                 }
 686
 687                 r = pTextBox->Construct(rect, textboxBorder);
 688                 if (r != E_SUCCESS)
 689                 {
 690                         return null;
 691                 }
 692
 693                 if (pControl->GetElement("textAlignment", elementString))
 694                 {
 695                         if (elementString.Equals(L"ALIGNMENT_LEFT", false))
 696                         {
 697                                 textAlignment = ALIGNMENT_LEFT;
 698                         }
 699                         else if (elementString.Equals(L"ALIGNMENT_RIGHT", false))
 700                         {
 701                                 textAlignment = ALIGNMENT_RIGHT;
 702                         }
 703                         else if (elementString.Equals(L"ALIGNMENT_CENTER", false))
 704                         {
 705                                 textAlignment = ALIGNMENT_CENTER;
 706                         }
 707
 708                         r = pTextBox->SetTextAlignment(textAlignment);
 709                 }
 710
 711                 if (pControl->GetElement("textSize", elementString))
 712                 {
 713                         textSize = _LocalizedNumParser::ToDouble(elementString, "C");
 714                         _ICoordinateSystemTransformer* pTransform = GetTransformer();
 715                         if (pTransform)
 716                         {
 717                                 textSize = pTransform->Transform(textSize);
 718                         }
 719                         r = pTextBox->SetTextSize(textSize);
 720                 }
 721
 722                 if (pControl->GetElement("lineSpacingExtra", elementString))
 723                 {
 724                         lineSpacingExtra =_LocalizedNumParser::ToDouble(elementString, "C");
 725                         if (pControl->GetElement("lineSpacingMultiplier", elementString))
 726                         {
 727                                 Base::Integer::Parse(elementString, lineSpacingMultiplier);
 728                                 r = pTextBox->SetLineSpacing(lineSpacingMultiplier, lineSpacingExtra);
 729                         }
 730                 }
 731
 732                 if (pControl->GetElement("text", elementString))
 733                 {
 734                         r = pTextBox->SetText(elementString);
 735                 }
 736
 737                 if (pControl->GetElement("disabledBackgroundBitmapPath", elementString))
 738                 {
 739                         Bitmap* pBackGroundBitmap = null;
 740                         pBackGroundBitmap = LoadBitmapN(elementString);
 741                         if (pBackGroundBitmap != null)
 742                         {
 743                                 pTextBox->SetBackgroundBitmap(TEXT_BOX_STATUS_DISABLED, *pBackGroundBitmap);
 744                                 delete pBackGroundBitmap;
 745                         }
 746                 }
 747
 748                 if (pControl->GetElement("highlightedBackgroundBitmapPath", elementString))
 749                 {
 750                         Bitmap* pBackGroundBitmap = null;
 751                         pBackGroundBitmap = LoadBitmapN(elementString);
 752                         if (pBackGroundBitmap != null)
 753                         {
 754                                 pTextBox->SetBackgroundBitmap(TEXT_BOX_STATUS_HIGHLIGHTED, *pBackGroundBitmap);
 755                                 delete pBackGroundBitmap;
 756                         }
 757                 }
 758
 759                 if (pControl->GetElement("normalBackgroundBitmapPath", elementString))
 760                 {
 761                         Bitmap* pBackGroundBitmap = null;
 762                         pBackGroundBitmap = LoadBitmapN(elementString);
 763                         if (pBackGroundBitmap != null)
 764                         {
 765                                 pTextBox->SetBackgroundBitmap(TEXT_BOX_STATUS_NORMAL, *pBackGroundBitmap);
 766                                 delete pBackGroundBitmap;
 767                         }
 768                 }
 769
 770                 if (pControl->GetElement("disabledTextColor", elementString))
 771                 {
 772                         ConvertStringToColor32(elementString, opacity, color);
 773                         pTextBox->SetTextColor(TEXT_BOX_TEXT_COLOR_DISABLED, color);
 774                 }
 775
 776                 if (pControl->GetElement("highlightedTextColor", elementString))
 777                 {
 778                         ConvertStringToColor32(elementString, opacity, color);
 779                         pTextBox->SetTextColor(TEXT_BOX_TEXT_COLOR_HIGHLIGHTED, color);
 780                 }
 781
 782                 if (pControl->GetElement("normalTextColor", elementString))
 783                 {
 784                         ConvertStringToColor32(elementString, opacity, color);
 785                         pTextBox->SetTextColor(TEXT_BOX_TEXT_COLOR_NORMAL, color);
 786                 }
 787
 788                 if (pControl->GetElement("disabledColorOpacity", elementString))
 789                 {
 790                         Base::Integer::Parse(elementString, opacity);
 791                 }
 792                 if (pControl->GetElement("disabledColor", elementString))
 793                 {
 794                         ConvertStringToColor32(elementString, opacity, color);
 795                         pTextBox->SetColor(TEXT_BOX_STATUS_DISABLED, color);
 796                 }
 797
 798                 if (pControl->GetElement("highlightedColorOpacity", elementString))
 799                 {
 800                         Base::Integer::Parse(elementString, opacity);
 801                 }
 802                 if (pControl->GetElement("highlightedColor", elementString))
 803                 {
 804                         ConvertStringToColor32(elementString, opacity, color);
 805                         pTextBox->SetColor(TEXT_BOX_STATUS_HIGHLIGHTED, color);
 806                 }
 807
 808                 if (pControl->GetElement("normalColorOpacity", elementString))
 809                 {
 810                         Base::Integer::Parse(elementString, opacity);
 811                 }
 812                 if (pControl->GetElement("normalColor", elementString))
 813                 {
 814                         ConvertStringToColor32(elementString, opacity, color);
 815                         pTextBox->SetColor(TEXT_BOX_STATUS_NORMAL, color);
 816                 }
 817
 818                 if (pControl->GetElement(L"accessibilityHint", elementString))
 819                 {
 820                         AccessibilityContainer* pContainer = pTextBox->GetAccessibilityContainer();
 821                         if (pContainer)
 822                         {
 823                                 AccessibilityElement* pElement = pContainer->GetElement(L"EditText");
 824                                 if (pElement)
 825                                 {
 826                                         pElement->SetHint(elementString);
 827                                 }
 828                         }
 829                 }
 830
 831                 return pTextBox;
 832         }
 833 };
 834
 835 _TextBoxRegister::_TextBoxRegister()
 836 {
 837           _UiBuilderControlTableManager* pUiBuilderControlTableManager = _UiBuilderControlTableManager::GetInstance();
 838           pUiBuilderControlTableManager->RegisterControl(L"TextBox", _TextBoxMaker::GetInstance);
 839 }
 840 _TextBoxRegister::~_TextBoxRegister()
 841 {
 842           _UiBuilderControlTableManager* pUiBuilderControlTableManager = _UiBuilderControlTableManager::GetInstance();
 843           pUiBuilderControlTableManager->UnregisterControl(L"TextBox");
 844 }
 845 static _TextBoxRegister TextBoxRegisterToUiBuilder;
 846 }}} // Tizen::Ui::Controls