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