src/ui/controls/FUiCtrl_SliderImpl.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_SliderImpl.cpp
  20  * @brief       This is the implementation file for the _SliderImpl class.
  21  */
  22
  23 #include <FApp_AppInfo.h>
  24 #include <FBaseInternalTypes.h>
  25 #include <FUiAccessibilityContainer.h>
  26 #include <FUiAccessibilityElement.h>
  27 #include "FUi_ResourceManager.h"
  28 #include "FUi_ResourceSizeInfo.h"
  29 #include "FUi_UiBuilder.h"
  30 #include "FUiCtrl_SliderImpl.h"
  31 #include "FUiCtrl_PublicAdjustmentEvent.h"
  32 #include "FUiCtrl_PublicSliderEvent.h"
  33
  34 using namespace Tizen::Ui;
  35 using namespace Tizen::Graphics;
  36 using namespace Tizen::Base;
  37
  38 namespace Tizen { namespace Ui { namespace Controls
  39 {
  40
  41 _SliderImpl*
  42 _SliderImpl::GetInstance(Slider& slider)
  43 {
  44         return static_cast<_SliderImpl*> (slider._pControlImpl);
  45 }
  46
  47 const _SliderImpl*
  48 _SliderImpl::GetInstance(const Slider& slider)
  49 {
  50         return static_cast<const _SliderImpl*> (slider._pControlImpl);
  51 }
  52
  53 _SliderImpl::_SliderImpl(Slider* pPublic, _Slider* pCore)
  54         : _ControlImpl(pPublic, pCore)
  55         , __pPublicAdjustmentEvent(null)
  56         , __pPublicSliderEvent(null)
  57 {
  58 }
  59
  60 _SliderImpl::~_SliderImpl(void)
  61 {
  62         if (__pPublicAdjustmentEvent != null)
  63         {
  64                 delete __pPublicAdjustmentEvent;
  65                 __pPublicAdjustmentEvent = null;
  66         }
  67
  68         if (__pPublicSliderEvent != null)
  69         {
  70                 delete __pPublicSliderEvent;
  71                 __pPublicSliderEvent = null;
  72         }
  73 }
  74
  75 _SliderImpl*
  76 _SliderImpl::CreateSliderImplN(Slider* pControl, const Rectangle& rect, int sliderStyle)
  77 {
  78         ClearLastResult();
  79
  80         result r = E_SUCCESS;
  81
  82         r = FUNC_SIZE_INFO(Slider)(sliderStyle).CheckInitialSizeValid(Dimension(rect.width, rect.height), _CONTROL_ORIENTATION_PORTRAIT);
  83         SysTryReturn(NID_UI_CTRL, r == E_SUCCESS, null, r, "[%s] Propagating.", GetErrorMessage(r));
  84
  85         _Slider* pCore = _Slider::CreateSliderN();
  86         r = GetLastResult();
  87         SysTryReturn(NID_UI_CTRL, pCore != null, null, r, "[%s] Propagating.", GetErrorMessage(r));
  88
  89         _SliderImpl* pImpl = new (std::nothrow) _SliderImpl(pControl, pCore);
  90         r = CheckConstruction(pCore, pImpl);
  91         SysTryReturn(NID_UI_CTRL, r == E_SUCCESS, null, r, "[%s] Propagating.", GetErrorMessage(r));
  92
  93         r = pImpl->InitializeBoundsProperties(FUNC_SIZE_INFO(Slider)(sliderStyle), rect, pCore->GetOrientation());
  94         SysTryCatch(NID_UI_CTRL, r == E_SUCCESS, , r, "[%s] Propagating.", GetErrorMessage(r));
  95
  96         pImpl->__pPublicAdjustmentEvent = _PublicAdjustmentEvent::CreateInstanceN(*pControl);
  97         SysTryCatch(NID_UI_CTRL, pImpl->__pPublicAdjustmentEvent != null, , E_SYSTEM, "[E_SYSTEM] A system error has occurred. Failed to construct an AdjustmentEvent instance");
  98
  99         pImpl->__pPublicSliderEvent = _PublicSliderEvent::CreateInstanceN(*pControl);
 100         SysTryCatch(NID_UI_CTRL, pImpl->__pPublicSliderEvent != null, , E_SYSTEM, "[E_SYSTEM] A system error has occurred. Failed to construct a SliderEvent instance");
 101
 102         r = pCore->AddAdjustmentEventListener(*pImpl);
 103         SysTryCatch(NID_UI_CTRL, r == E_SUCCESS, , r, "[%s] Propagating.", GetErrorMessage(r));
 104
 105         r = pCore->AddSliderEventListener(*pImpl);
 106         SysTryCatch(NID_UI_CTRL, r == E_SUCCESS, , r, "[%s] Propagating.", GetErrorMessage(r));
 107
 108         return pImpl;
 109
 110 CATCH:
 111         delete pImpl;
 112         pImpl = null;
 113
 114         return null;
 115 }
 116
 117 _SliderImpl*
 118 _SliderImpl::CreateSliderImplFN(Slider* pControl, const FloatRectangle& rect, int sliderStyle)
 119 {
 120         ClearLastResult();
 121
 122         result r = E_SUCCESS;
 123
 124         r = FUNC_SIZE_INFO(Slider)(sliderStyle).CheckInitialSizeValidF(FloatDimension(rect.width, rect.height), _CONTROL_ORIENTATION_PORTRAIT);
 125         SysTryReturn(NID_UI_CTRL, r == E_SUCCESS, null, r, "[%s] Propagating.", GetErrorMessage(r));
 126
 127         _Slider* pCore = _Slider::CreateSliderN();
 128         r = GetLastResult();
 129         SysTryReturn(NID_UI_CTRL, pCore != null, null, r, "[%s] Propagating.", GetErrorMessage(r));
 130
 131         _SliderImpl* pImpl = new (std::nothrow) _SliderImpl(pControl, pCore);
 132         r = CheckConstruction(pCore, pImpl);
 133         SysTryReturn(NID_UI_CTRL, r == E_SUCCESS, null, r, "[%s] Propagating.", GetErrorMessage(r));
 134
 135         r = pImpl->InitializeBoundsPropertiesF(FUNC_SIZE_INFO(Slider)(sliderStyle), rect, pCore->GetOrientation());
 136         SysTryCatch(NID_UI_CTRL, r == E_SUCCESS, , r, "[%s] Propagating.", GetErrorMessage(r));
 137
 138         pImpl->__pPublicAdjustmentEvent = _PublicAdjustmentEvent::CreateInstanceN(*pControl);
 139         SysTryCatch(NID_UI_CTRL, pImpl->__pPublicAdjustmentEvent != null, , E_SYSTEM, "[E_SYSTEM] A system error has occurred. Failed to construct an AdjustmentEvent instance");
 140
 141         pImpl->__pPublicSliderEvent = _PublicSliderEvent::CreateInstanceN(*pControl);
 142         SysTryCatch(NID_UI_CTRL, pImpl->__pPublicSliderEvent != null, , E_SYSTEM, "[E_SYSTEM] A system error has occurred. Failed to construct a SliderEvent instance");
 143
 144         r = pCore->AddAdjustmentEventListener(*pImpl);
 145         SysTryCatch(NID_UI_CTRL, r == E_SUCCESS, , r, "[%s] Propagating.", GetErrorMessage(r));
 146
 147         r = pCore->AddSliderEventListener(*pImpl);
 148         SysTryCatch(NID_UI_CTRL, r == E_SUCCESS, , r, "[%s] Propagating.", GetErrorMessage(r));
 149
 150         return pImpl;
 151
 152 CATCH:
 153         delete pImpl;
 154         pImpl = null;
 155
 156         return null;
 157 }
 158
 159 result
 160 _SliderImpl::Initialize(int minValue, int maxValue, BackgroundStyle bgStyle, int sliderStyle, GroupStyle groupStyle)
 161 {
 162         ClearLastResult();
 163
 164         result r = E_SUCCESS;
 165
 166         int style = _SLIDER_STYLE_NONE;
 167
 168         if (sliderStyle & SLIDER_STYLE_BUBBLE)
 169         {
 170                 style |= _SLIDER_STYLE_OVERLAY;
 171         }
 172
 173         if (bgStyle == BACKGROUND_STYLE_NONE)
 174         {
 175                 SysTryReturn(NID_UI_CTRL, groupStyle == GROUP_STYLE_NONE, E_INVALID_OPERATION, E_INVALID_OPERATION,
 176                                    "[E_INVALID_OPERATION] The current Slider style does not support given group style.");
 177
 178                 style |= _SLIDER_STYLE_NO_BG;
 179         }
 180         if (sliderStyle & SLIDER_STYLE_TITLE)
 181         {
 182                 style |= _SLIDER_STYLE_TITLE_TEXT;
 183         }
 184
 185         r = SetRange(minValue, maxValue);
 186         SysTryReturn(NID_UI_CTRL, r == E_SUCCESS, r, r, "[%s] Propagating.", GetErrorMessage(r));
 187
 188         GetCore().SetStyle(style);
 189         GetCore().SetGroupStyle(groupStyle);
 190
 191         return r;
 192 }
 193
 194 result
 195 _SliderImpl::SetRange(int minValue, int maxValue)
 196 {
 197         ClearLastResult();
 198
 199         return GetCore().SetRange(minValue, maxValue);
 200 }
 201
 202 result
 203 _SliderImpl::GetRange(int& minValue, int& maxValue) const
 204 {
 205         ClearLastResult();
 206
 207         return GetCore().GetRange(minValue, maxValue);
 208 }
 209
 210 result
 211 _SliderImpl::SetValue(int value)
 212 {
 213         ClearLastResult();
 214
 215         Variant varValue(value);
 216
 217         return GetCore().SetPropertyValue(varValue);
 218 }
 219
 220 int
 221 _SliderImpl::GetValue(void) const
 222 {
 223         ClearLastResult();
 224
 225         return GetCore().GetPropertyValue().ToInt();
 226 }
 227
 228 result
 229 _SliderImpl::SetIcon(IconPosition position, const Bitmap& icon)
 230 {
 231         ClearLastResult();
 232
 233         return GetCore().SetIcon(position, icon);
 234 }
 235
 236 result
 237 _SliderImpl::SetTitleText(const String& title)
 238 {
 239         ClearLastResult();
 240
 241         Variant varTitleText(title);
 242
 243         return GetCore().SetPropertyTitleText(varTitleText);
 244 }
 245
 246 String
 247 _SliderImpl::GetTitleText(void) const
 248 {
 249         ClearLastResult();
 250
 251         return GetCore().GetPropertyTitleText().ToString();
 252 }
 253
 254 result
 255 _SliderImpl::SetTitleTextColor(const Color& color)
 256 {
 257         ClearLastResult();
 258
 259         Variant varTitleTextColor(color);
 260
 261         return GetCore().SetPropertyTitleTextColor(varTitleTextColor);
 262 }
 263
 264 Color
 265 _SliderImpl::GetTitleTextColor(void) const
 266 {
 267         ClearLastResult();
 268
 269         return GetCore().GetPropertyTitleTextColor().ToColor();
 270 }
 271
 272 result
 273 _SliderImpl::AddAdjustmentEventListener(IAdjustmentEventListener& listener)
 274 {
 275         ClearLastResult();
 276
 277         result r = __pPublicAdjustmentEvent->AddListener(listener);
 278         SysTryReturnResult(NID_UI_CTRL, r != E_OBJ_ALREADY_EXIST, E_SYSTEM, "A system error has occurred. The IAdjustmentEventListener instance already exists in the event listener list.");
 279
 280         return r;
 281 }
 282
 283 result
 284 _SliderImpl::RemoveAdjustmentEventListener(IAdjustmentEventListener& listener)
 285 {
 286         ClearLastResult();
 287
 288         result r = __pPublicAdjustmentEvent->RemoveListener(listener);
 289         SysTryReturnResult(NID_UI_CTRL, r != E_OBJ_NOT_FOUND, E_SYSTEM, "A system error has occurred. The IAdjustmentEventListener instance does not exist");
 290
 291         return r;
 292 }
 293
 294 result
 295 _SliderImpl::AddSliderEventListener(const ISliderEventListener& listener)
 296 {
 297         ClearLastResult();
 298
 299         result r = __pPublicSliderEvent->AddListener(listener);
 300         SysTryReturnResult(NID_UI_CTRL, r != E_OBJ_ALREADY_EXIST, E_SYSTEM, "A system error has occurred. The ISliderEventListener instance already exists in the event listener list.");
 301
 302         return r;
 303 }
 304
 305 result
 306 _SliderImpl::RemoveSliderEventListener(const ISliderEventListener& listener)
 307 {
 308         ClearLastResult();
 309
 310         result r = __pPublicSliderEvent->RemoveListener(listener);
 311         SysTryReturnResult(NID_UI_CTRL, r != E_OBJ_NOT_FOUND, E_SYSTEM, "A system error has occurred. The ISliderEventListener does not exist in the event listener list.");
 312
 313         return r;
 314 }
 315
 316 result
 317 _SliderImpl::SetBarColor(const Color& color)
 318 {
 319         ClearLastResult();
 320
 321         Variant varBarColor(color);
 322
 323         return GetCore().SetPropertyBarColor(varBarColor);
 324 }
 325
 326 Color
 327 _SliderImpl::GetBarColor(void) const
 328 {
 329         ClearLastResult();
 330
 331         return GetCore().GetPropertyBarColor().ToColor();
 332 }
 333
 334 result
 335 _SliderImpl::SetBarBackgroundColor(const Color& color)
 336 {
 337         ClearLastResult();
 338
 339         Variant varBarBackgroundColor(color);
 340
 341         return GetCore().SetPropertyBarBackgroundColor(varBarBackgroundColor);
 342 }
 343
 344 Color
 345 _SliderImpl::GetBarBackgroundColor(void) const
 346 {
 347         ClearLastResult();
 348
 349         return GetCore().GetPropertyBarBackgroundColor().ToColor();
 350 }
 351
 352 result
 353 _SliderImpl::SetColor(const Color& color)
 354 {
 355         ClearLastResult();
 356
 357         Variant varColor(color);
 358
 359         return GetCore().SetPropertyColor(varColor);
 360 }
 361
 362 Color
 363 _SliderImpl::GetColor(void) const
 364 {
 365         ClearLastResult();
 366
 367         return GetCore().GetPropertyColor().ToColor();
 368 }
 369
 370 result
 371 _SliderImpl::SetThumbBitmap(SliderThumbStatus status, const Bitmap& bitmap)
 372 {
 373         ClearLastResult();
 374
 375         return GetCore().SetThumbBitmap(status, bitmap);
 376 }
 377
 378 void
 379 _SliderImpl::SetThumbTextColor(SliderThumbStatus status, const Color& color)
 380 {
 381         ClearLastResult();
 382
 383         GetCore().SetThumbTextColor(status, color);
 384
 385         return;
 386 }
 387
 388 const char*
 389 _SliderImpl::GetPublicClassName(void) const
 390 {
 391         return "Tizen::Ui::Controls::Slider";
 392 }
 393
 394 const Slider&
 395 _SliderImpl::GetPublic(void) const
 396 {
 397         return static_cast <const Slider&>(_ControlImpl::GetPublic());
 398 }
 399
 400 Slider&
 401 _SliderImpl::GetPublic(void)
 402 {
 403         return static_cast <Slider&>(_ControlImpl::GetPublic());
 404 }
 405
 406 const _Slider&
 407 _SliderImpl::GetCore(void) const
 408 {
 409         return static_cast <const _Slider&>(_ControlImpl::GetCore());
 410 }
 411
 412 _Slider&
 413 _SliderImpl::GetCore(void)
 414 {
 415         return static_cast <_Slider&>(_ControlImpl::GetCore());
 416 }
 417
 418 void
 419 _SliderImpl::OnAdjustmentValueChanged(const _Control& source, int adjustment)
 420 {
 421         ClearLastResult();
 422
 423         Runtime::IEventArg* pEventArg = _PublicAdjustmentEvent::CreateAdjustmentEventArgN(adjustment);
 424         result r = GetLastResult();
 425         SysTryReturnVoidResult(NID_UI_CTRL, pEventArg != null, r, "[%s] Propagating.", GetErrorMessage(r));
 426
 427         __pPublicAdjustmentEvent->Fire(*pEventArg);
 428         return;
 429 }
 430
 431 void
 432 _SliderImpl::OnSliderBarMoved(_Slider& source, int value)
 433 {
 434         ClearLastResult();
 435
 436         Runtime::IEventArg* pEventArg = _PublicSliderEvent::CreateSliderEventArgN(value);
 437         result r = GetLastResult();
 438         SysTryReturnVoidResult(NID_UI_CTRL, pEventArg != null, r, "[%s] Propagating.", GetErrorMessage(r));
 439
 440         __pPublicSliderEvent->Fire(*pEventArg);
 441         return;
 442 }
 443
 444 class _SliderMaker
 445         : public _UiBuilderControlMaker
 446 {
 447 public:
 448         _SliderMaker(_UiBuilder* pUiBuilder)
 449                 : _UiBuilderControlMaker(pUiBuilder){}
 450         virtual ~_SliderMaker(void){}
 451
 452         static _UiBuilderControlMaker*
 453         GetInstance(_UiBuilder* pUiBuilder)
 454         {
 455                 _SliderMaker* pSliderMaker = new (std::nothrow) _SliderMaker(pUiBuilder);
 456                 return pSliderMaker;
 457         }
 458
 459 protected:
 460         virtual Control*
 461         Make(_UiBuilderControl* pControl)
 462         {
 463                 result r = E_SUCCESS;
 464                 _UiBuilderControlLayout* pControlProperty = null;
 465                 Slider* pSlider = null;
 466                 Tizen::Base::String elementString;
 467                 Tizen::Base::String elementString1;
 468                 FloatRectangle rect;
 469                 int tempMin = 0;
 470                 int tempMax = 0;
 471                 int temp = 0;
 472                 int sliderStyle = SLIDER_STYLE_NONE;
 473                 bool isShowTitle = false;
 474                 bool isGroupStyle = false;
 475                 BackgroundStyle backgroundStyleEnum = BACKGROUND_STYLE_DEFAULT;
 476                 GroupStyle groupStyleEmum = GROUP_STYLE_NONE;
 477
 478                 Color color;
 479                 int opacity = 0;
 480
 481
 482                 GetProperty(pControl, &pControlProperty);
 483                 if (pControlProperty == null)
 484                 {
 485                         return null;
 486                 }
 487
 488                 pSlider = new (std::nothrow) Slider;
 489                 if (pSlider == null)
 490                 {
 491                         return null;
 492                 }
 493                 rect = pControlProperty->GetRectF();
 494
 495                 if (pControl->GetElement(L"backgroundStyle", elementString) || pControl->GetElement(L"BackgroundStyle", elementString))
 496                 {
 497                         if (elementString.Equals(L"BACKGROUND_STYLE_NONE", false))
 498                         {
 499                                 backgroundStyleEnum = BACKGROUND_STYLE_NONE;
 500                         }
 501                 }
 502
 503                 if (pControl->GetElement(L"showTitleText", elementString) || pControl->GetElement(L"bShowtitleText", elementString))
 504                 {
 505                         if (elementString.Equals(L"true", false))
 506                         {
 507                                 isShowTitle = true;
 508                         }
 509                 }
 510
 511                 if (pControl->GetElement(L"groupStyle", elementString) || pControl->GetElement(L"GroupStyle", elementString))
 512                 {
 513                         isGroupStyle = true;
 514
 515                         if (elementString.Equals(L"GROUP_STYLE_NONE", false))
 516                         {
 517                                 groupStyleEmum = GROUP_STYLE_NONE;
 518                         }
 519                         if (elementString.Equals(L"GROUP_STYLE_SINGLE", false))
 520                         {
 521                                 groupStyleEmum = GROUP_STYLE_SINGLE;
 522                         }
 523                         if (elementString.Equals(L"GROUP_STYLE_TOP", false))
 524                         {
 525                                 groupStyleEmum = GROUP_STYLE_TOP;
 526                         }
 527                         if (elementString.Equals(L"GROUP_STYLE_MIDDLE", false))
 528                         {
 529                                 groupStyleEmum = GROUP_STYLE_MIDDLE;
 530                         }
 531                         if (elementString.Equals(L"GROUP_STYLE_BOTTOM", false))
 532                         {
 533                                 groupStyleEmum = GROUP_STYLE_BOTTOM;
 534                         }
 535                 }
 536                 if (isGroupStyle == true)
 537                 {
 538                         if (pControl->GetElement(L"min", elementString) && pControl->GetElement(L"max", elementString1))
 539                         {
 540                                 Base::Integer::Parse(elementString, tempMin);
 541                                 Base::Integer::Parse(elementString1, tempMax);
 542
 543                                 if (tempMin > tempMax)
 544                                 {
 545                                         temp = tempMin;
 546                                         tempMin = tempMax;
 547                                         tempMax = tempMin;
 548                                 }
 549
 550                                 r = pSlider->Construct(rect, backgroundStyleEnum, isShowTitle, tempMin, tempMax, groupStyleEmum);
 551                         }
 552                         else
 553                         {
 554                                 r = pSlider->Construct(rect, backgroundStyleEnum, isShowTitle, 0, 10, groupStyleEmum);
 555                         }
 556                 }
 557
 558                 else
 559                 {
 560                         if (pControl->GetElement(L"sliderStyleBubble", elementString))
 561                         {
 562                                 if (elementString.Equals(L"true", false))
 563                                 {
 564                                         sliderStyle |= SLIDER_STYLE_BUBBLE;
 565                                 }
 566                         }
 567
 568                         if (pControl->GetElement(L"sliderStyleTitle", elementString))
 569                         {
 570                                 if (elementString.Equals(L"true", false))
 571                                 {
 572                                         isShowTitle = true;
 573                                         sliderStyle |= SLIDER_STYLE_TITLE;
 574                                 }
 575                         }
 576
 577                         if (pControl->GetElement(L"min", elementString) && pControl->GetElement(L"max", elementString1))
 578                         {
 579                                 Base::Integer::Parse(elementString, tempMin);
 580                                 Base::Integer::Parse(elementString1, tempMax);
 581
 582                                 if (tempMin > tempMax)
 583                                 {
 584                                         temp = tempMin;
 585                                         tempMin = tempMax;
 586                                         tempMax = tempMin;
 587                                 }
 588
 589                                 r = pSlider->Construct(rect, sliderStyle, tempMin, tempMax);
 590                         }
 591                         else
 592                         {
 593                                 r = pSlider->Construct(rect, sliderStyle, 0, 10);
 594                         }
 595                 }
 596
 597                 if (r != E_SUCCESS)
 598                 {
 599                         delete pSlider;
 600                         pSlider = null;
 601
 602                         return null;
 603                 }
 604
 605                 if (pControl->GetElement(L"value", elementString))
 606                 {
 607                         Base::Integer::Parse(elementString, temp);
 608                         if (temp > tempMax || temp < tempMin)
 609                         {
 610                                 temp = (tempMin + tempMax) >> 1;
 611                         }
 612                         pSlider->SetValue(temp);
 613                 }
 614                 else
 615                 {
 616                         pSlider->SetValue((tempMin + tempMax) >> 1);
 617                 }
 618
 619                 if (isShowTitle)
 620                 {
 621                         if (pControl->GetElement(L"titleText", elementString))
 622                         {
 623                                 pSlider->SetTitleText(elementString);
 624                         }
 625                         if (pControl->GetElement(L"colorOfTitleText", elementString))
 626                         {
 627                                 ConvertStringToColor(elementString, color);
 628                                 pSlider->SetTitleTextColor(color);
 629                         }
 630                 }
 631
 632                 if (pControl->GetElement(L"normalThumbBitmap", elementString))
 633                 {
 634                         Bitmap* pBitmap = null;
 635                         pBitmap = LoadBitmapN(elementString);
 636                         if (pBitmap != null)
 637                         {
 638                                 pSlider->SetThumbBitmap(SLIDER_THUMB_STATUS_NORMAL, *pBitmap);
 639                                 delete pBitmap;
 640                                 pBitmap = null;
 641                         }
 642                 }
 643
 644                 if (pControl->GetElement(L"pressedThumbBitmap", elementString))
 645                 {
 646                         Bitmap* pBitmap = null;
 647                         pBitmap = LoadBitmapN(elementString);
 648                         if (pBitmap != null)
 649                         {
 650                                 pSlider->SetThumbBitmap(SLIDER_THUMB_STATUS_PRESSED, *pBitmap);
 651                                 delete pBitmap;
 652                                 pBitmap = null;
 653                         }
 654                 }
 655
 656                 if (pControl->GetElement(L"disabledThumbBitmap", elementString))
 657                 {
 658                         Bitmap* pBitmap = null;
 659                         pBitmap = LoadBitmapN(elementString);
 660                         if (pBitmap != null)
 661                         {
 662                                 pSlider->SetThumbBitmap(SLIDER_THUMB_STATUS_DISABLED, *pBitmap);
 663                                 delete pBitmap;
 664                                 pBitmap = null;
 665                         }
 666                 }
 667
 668                 if (pControl->GetElement(L"highlightedThumbBitmap", elementString))
 669                 {
 670                         Bitmap* pBitmap = null;
 671                         pBitmap = LoadBitmapN(elementString);
 672                         if (pBitmap != null)
 673                         {
 674                                 pSlider->SetThumbBitmap(SLIDER_THUMB_STATUS_HIGHLIGHTED, *pBitmap);
 675                                 delete pBitmap;
 676                                 pBitmap = null;
 677                         }
 678                 }
 679
 680                 if (pControl->GetElement(L"leftIconBitmapPath", elementString))
 681                 {
 682                         Bitmap* pBitmap = null;
 683                         pBitmap = LoadBitmapN(elementString);
 684                         if (pBitmap != null)
 685                         {
 686                                 pSlider->SetIcon(ICON_POSITION_LEFT, *pBitmap);
 687                                 delete pBitmap;
 688                                 pBitmap = null;
 689                         }
 690                 }
 691
 692                 if (pControl->GetElement(L"rightIconBitmapPath", elementString))
 693                 {
 694                         Bitmap* pBitmap = null;
 695                         pBitmap = LoadBitmapN(elementString);
 696                         if (pBitmap != null)
 697                         {
 698                                 pSlider->SetIcon(ICON_POSITION_RIGHT, *pBitmap);
 699                                 delete pBitmap;
 700                                 pBitmap = null;
 701                         }
 702                 }
 703
 704                 if (pControl->GetElement(L"normalThumbTextColor", elementString))
 705                 {
 706                         ConvertStringToColor(elementString, color);
 707                         pSlider->SetThumbTextColor(SLIDER_THUMB_STATUS_NORMAL, color);
 708                 }
 709
 710                 if (pControl->GetElement(L"pressedThumbTextColor", elementString))
 711                 {
 712                         ConvertStringToColor(elementString, color);
 713                         pSlider->SetThumbTextColor(SLIDER_THUMB_STATUS_PRESSED, color);
 714                 }
 715
 716                 if (pControl->GetElement(L"disabledThumbTextColor", elementString))
 717                 {
 718                         ConvertStringToColor(elementString, color);
 719                         pSlider->SetThumbTextColor(SLIDER_THUMB_STATUS_DISABLED, color);
 720                 }
 721
 722                 if (pControl->GetElement(L"highlightedThumbTextColor", elementString))
 723                 {
 724                         ConvertStringToColor(elementString, color);
 725                         pSlider->SetThumbTextColor(SLIDER_THUMB_STATUS_HIGHLIGHTED, color);
 726                 }
 727
 728                 if (pControl->GetElement(L"barColor", elementString))
 729                 {
 730                         ConvertStringToColor(elementString, color);
 731                         pSlider->SetBarColor(color);
 732                 }
 733
 734                 if (pControl->GetElement(L"barBackgroundColor", elementString))
 735                 {
 736                         ConvertStringToColor(elementString, color);
 737                         pSlider->SetBarBackgroundColor(color);
 738                 }
 739
 740                 if (pControl->GetElement(L"colorOpacity", elementString))
 741                 {
 742                         Base::Integer::Parse(elementString, opacity);
 743                 }
 744                 if (pControl->GetElement(L"color", elementString))
 745                 {
 746                         ConvertStringToColor32(elementString, opacity, color);
 747                         pSlider->SetColor(color);
 748                 }
 749
 750                 if (pControl->GetElement(L"accessibilityHint", elementString))
 751                 {
 752                         AccessibilityContainer* pContainer = pSlider->GetAccessibilityContainer();
 753                         if (pContainer)
 754                         {
 755                                 AccessibilityElement* pElement = pContainer->GetElement(L"SliderControl");
 756                                 if (pElement)
 757                                 {
 758                                         pElement->SetHint(elementString);
 759                                 }
 760                         }
 761                 }
 762
 763                 return pSlider;
 764         }
 765
 766 }; // _SliderMaker
 767
 768 _SliderRegister::_SliderRegister(void)
 769 {
 770         _UiBuilderControlTableManager* pUiBuilderControlTableManager = _UiBuilderControlTableManager::GetInstance();
 771         pUiBuilderControlTableManager->RegisterControl(L"Slider", _SliderMaker::GetInstance);
 772 }
 773 _SliderRegister::~_SliderRegister(void)
 774 {
 775         _UiBuilderControlTableManager* pUiBuilderControlTableManager = _UiBuilderControlTableManager::GetInstance();
 776         pUiBuilderControlTableManager->UnregisterControl(L"Slider");
 777 }
 778 static _SliderRegister SliderRegisterToUiBuilder;
 779 }}} // Tizen::Ui::Controls