src/ui/controls/FUiCtrl_ColorPickerPresenter.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_ColorPickerPresenter.cpp
  20  * @brief               This is the implementation file for the FUiCtrl_ColorPickerPresenter class.
  21  */
  22
  23 #include <new>
  24 #include <FBaseSysLog.h>
  25 #include <FBaseErrorDefine.h>
  26 #include <FGrp_BitmapImpl.h>
  27 #include "FUiAnim_VisualElement.h"
  28 #include "FUiCtrl_ColorPickerPresenter.h"
  29 #include "FUiCtrl_ColorPickerModel.h"
  30 #include "FUiCtrl_ColorPicker.h"
  31 #include "FUi_AccessibilityElement.h"
  32 #include "FUi_UiTouchEvent.h"
  33 #include "FUi_ResourceManager.h"
  34 #include "FUi_CoordinateSystemUtils.h"
  35
  36 using namespace Tizen::Base;
  37 using namespace Tizen::Base::Runtime;
  38 using namespace Tizen::Graphics;
  39 using namespace Tizen::Ui;
  40 using namespace Tizen::Ui::Animations;
  41 using namespace Tizen::Base::Utility;
  42
  43 const int ARROW_MOVE_STEP = 5;
  44 const int SLIDE_ACTIVATION_TIME = 500;
  45 const int SLIDE_MOVE_TIME = 60;
  46 const double MAX_VALUE_DEGREE = 100.0;
  47 const double MIN_VALUE = 0.0;
  48 const double MAX_VALUE = 1.0;
  49
  50 namespace Tizen { namespace Ui { namespace Controls
  51 {
  52
  53 union _Color32
  54 {
  55         unsigned int color32;
  56         struct
  57         {
  58                 byte b;
  59                 byte g;
  60                 byte r;
  61                 byte a;
  62         } colorArgb;
  63 };
  64
  65 _ColorPickerPresenter::_ColorPickerPresenter(_ColorPicker& colorPicker)
  66         : __pColorPicker(&colorPicker)
  67         , __pColorPickerModel(null)
  68         , __eventType(HSL_NOT)
  69         , __topMargin(0.0f)
  70         , __blockMargin(0.0f)
  71         , __blockHeight(0.0f)
  72         , __dividerMargin(0.0f)
  73         , __dividerWidth(0.0f)
  74         , __hueColor(0)
  75         , __saturationColor(0)
  76         , __pSlideTimer(null)
  77         , __pHueSliderBgBitmap(null)
  78         , __pCustomBitmap(null)
  79         , __pLuminanceSliderBgBitmap(null)
  80         , __pSaturationSliderBgBitmap(null)
  81         , __pColorNormalReplacementBgBitmap(null)
  82         , __pColorPressedReplacementBgBitmap(null)
  83         , __pColorDisabledReplacementBgBitmap(null)
  84         , __pNormalEffectBgBitmap(null)
  85         , __pPressedEffectBgBitmap(null)
  86         , __pDisabledEffectBgBitmap(null)
  87         , __pLeftArrowNormalBitmap(null)
  88         , __pLeftArrowPressedBitmap(null)
  89         , __pLeftArrowDisabledBitmap(null)
  90         , __pRightArrowNormalBitmap(null)
  91         , __pRightArrowPressedBitmap(null)
  92         , __pRightArrowDisabledBitmap(null)
  93         , __pHandlerBitmap(null)
  94         , __pLandscapeHueSliderBgBitmap(null)
  95         , __pLandscapeCustomBitmap(null)
  96         , __pLandscapeLuminanceSliderBgBitmap(null)
  97         , __pLandscapeSaturationSliderBgBitmap(null)
  98         , __pFocusBitmap(null)
  99 {
 100 }
 101
 102 _ColorPickerPresenter::~_ColorPickerPresenter(void)
 103 {
 104         __pColorPicker = null;
 105
 106         delete __pColorPickerModel;
 107         __pColorPickerModel = null;
 108
 109         if (__pSlideTimer != null)
 110         {
 111                 __pSlideTimer->Cancel();
 112                 delete __pSlideTimer;
 113                 __pSlideTimer = null;
 114         }
 115
 116         delete __pHueSliderBgBitmap;
 117         __pHueSliderBgBitmap = null;
 118
 119         delete __pCustomBitmap;
 120         __pCustomBitmap = null;
 121
 122         delete __pLuminanceSliderBgBitmap;
 123         __pLuminanceSliderBgBitmap = null;
 124
 125         delete __pSaturationSliderBgBitmap;
 126         __pSaturationSliderBgBitmap = null;
 127
 128         delete __pColorNormalReplacementBgBitmap;
 129         __pColorNormalReplacementBgBitmap = null;
 130
 131         delete __pColorPressedReplacementBgBitmap;
 132         __pColorPressedReplacementBgBitmap = null;
 133
 134         delete __pColorDisabledReplacementBgBitmap;
 135         __pColorDisabledReplacementBgBitmap = null;
 136
 137         delete __pNormalEffectBgBitmap;
 138         __pNormalEffectBgBitmap = null;
 139
 140         delete __pPressedEffectBgBitmap;
 141         __pPressedEffectBgBitmap = null;
 142
 143         delete __pDisabledEffectBgBitmap;
 144         __pDisabledEffectBgBitmap = null;
 145
 146         delete __pLeftArrowNormalBitmap;
 147         __pLeftArrowNormalBitmap = null;
 148
 149         delete __pLeftArrowPressedBitmap;
 150         __pLeftArrowPressedBitmap = null;
 151
 152         delete __pLeftArrowDisabledBitmap;
 153         __pLeftArrowDisabledBitmap = null;
 154
 155         delete __pRightArrowNormalBitmap;
 156         __pRightArrowNormalBitmap = null;
 157
 158         delete __pRightArrowPressedBitmap;
 159         __pRightArrowPressedBitmap = null;
 160
 161         delete __pRightArrowDisabledBitmap;
 162         __pRightArrowDisabledBitmap = null;
 163
 164         delete __pHandlerBitmap;
 165         __pHandlerBitmap = null;
 166
 167         delete __pLandscapeHueSliderBgBitmap;
 168         __pLandscapeHueSliderBgBitmap = null;
 169
 170         delete __pLandscapeCustomBitmap;
 171         __pLandscapeCustomBitmap = null;
 172
 173         delete __pLandscapeLuminanceSliderBgBitmap;
 174         __pLandscapeLuminanceSliderBgBitmap = null;
 175
 176         delete __pLandscapeSaturationSliderBgBitmap;
 177         __pLandscapeSaturationSliderBgBitmap = null;
 178
 179         delete __pFocusBitmap;
 180         __pFocusBitmap = null;
 181 }
 182
 183 _ColorPickerPresenter*
 184 _ColorPickerPresenter::CreateInstanceN(_ColorPicker& colorPicker)
 185 {
 186         _ColorPickerPresenter* pColorPickerPresenter = new (std::nothrow) _ColorPickerPresenter(colorPicker);
 187         SysTryReturn(NID_UI_CTRL, (pColorPickerPresenter != null), null, E_OUT_OF_MEMORY,
 188                         "[E_OUT_OF_MEMORY] Memory allocation failed.");
 189
 190         result r = GetLastResult();
 191         SysTryCatch(NID_UI_CTRL, (r == E_SUCCESS), , r, "[%s] Propagating.", GetErrorMessage(r));
 192
 193         pColorPickerPresenter->__pColorPickerModel = _ColorPickerModel::CreateInstanceN();
 194         r = GetLastResult();
 195         SysTryCatch(NID_UI_CTRL, (pColorPickerPresenter->__pColorPickerModel != null), , r,
 196                         "[%s] Propagating.", GetErrorMessage(r));
 197
 198         // Set initial value.
 199         pColorPickerPresenter->__pColorPickerModel->SetHue(MIN_VALUE);
 200         pColorPickerPresenter->__pColorPickerModel->SetSaturation(MAX_VALUE);
 201         pColorPickerPresenter->__pColorPickerModel->SetLuminance(MIN_VALUE);
 202
 203         r = pColorPickerPresenter->LoadResource();
 204         SysTryCatch(NID_UI_CTRL, r == E_SUCCESS, , E_SYSTEM, "[E_SYSTEM] A system error has occurred. Failed to load the ColorPicker resources.");
 205
 206         return pColorPickerPresenter;
 207 CATCH:
 208         delete pColorPickerPresenter;
 209         return null;
 210 }
 211
 212 _VisualElement*
 213 _ColorPickerPresenter::CreateHandlerN(_VisualElement& rootElement, _ColorPickerComponentType handlerType)
 214 {
 215         Canvas* pCanvas = null;
 216         float handlerWidth = 0.0f;
 217         float handlerHeight = 0.0f;
 218         result r = E_SUCCESS;
 219         FloatRectangle handlerBounds = __componentBounds[handlerType];
 220         FloatRectangle bounds = __pColorPicker->GetClientBoundsF();
 221
 222         _VisualElement* pHandler = new (std::nothrow) _VisualElement;
 223         SysTryReturn(NID_UI_CTRL, (pHandler != null), null, E_OUT_OF_MEMORY,
 224                         "[E_OUT_OF_MEMORY] Memory allocation failed.");
 225
 226         r = pHandler->Construct();
 227         SysTryCatch(NID_UI_CTRL, (r == E_SUCCESS), , r, "[%s] Propagating.", GetErrorMessage(r));
 228
 229         GET_SHAPE_CONFIG(COLORPICKER::HANDLER_WIDTH, _CONTROL_ORIENTATION_PORTRAIT, handlerWidth);
 230         GET_SHAPE_CONFIG(COLORPICKER::HANDLER_HEIGHT, _CONTROL_ORIENTATION_PORTRAIT, handlerHeight);
 231
 232         pHandler->SetImplicitAnimationEnabled(false);
 233
 234         pHandler->SetBounds(CoordinateSystem::AlignToDevice(FloatRectangle(bounds.x + handlerBounds.x, bounds.y + handlerBounds.y, handlerWidth, handlerHeight)));
 235         pHandler->SetShowState(true);
 236         pHandler->SetBackBufferEnabled(true);
 237
 238         pHandler->SetRedrawOnResizeEnabled(true);
 239         pHandler->SetSurfaceOpaque(false);
 240
 241         r = rootElement.AttachChild(*pHandler);
 242         SysTryCatch(NID_UI_CTRL, (r == E_SUCCESS), , r, "[%s] Propagating.", GetErrorMessage(r));
 243
 244         pCanvas = pHandler->GetCanvasN();
 245         r = GetLastResult();
 246         SysTryCatch(NID_UI_CTRL, (pCanvas != null), , r, "[%s] Propagating.", GetErrorMessage(r));
 247
 248         pCanvas->SetBackgroundColor(Color());
 249         pCanvas->Clear();
 250         DrawResourceBitmap(*pCanvas, FloatRectangle(0, 0, handlerWidth, handlerHeight), __pHandlerBitmap);
 251
 252         delete pCanvas;
 253
 254         return pHandler;
 255 CATCH:
 256         pHandler->Destroy();
 257         return null;
 258 }
 259
 260 result
 261 _ColorPickerPresenter::Draw(void)
 262 {
 263         Canvas* pCanvas = __pColorPicker->GetCanvasN();
 264         if (pCanvas == null)
 265         {
 266                 SetLastResult(E_SYSTEM);
 267                 return E_SYSTEM;
 268         }
 269
 270         pCanvas->SetBackgroundColor(Color(0, 0, 0, 0));
 271         pCanvas->Clear();
 272
 273         DrawLine(*pCanvas);
 274         DrawArrowButtons(*pCanvas);
 275
 276         DrawHueSlider(*pCanvas);
 277         MoveHandler(HUE_HANDLER);
 278
 279         DrawSaturationSlider(*pCanvas);
 280         MoveHandler(SAT_HANDLER);
 281
 282         DrawLuminanceSlider(*pCanvas);
 283         MoveHandler(LUM_HANDLER);
 284
 285         delete pCanvas;
 286         pCanvas = null;
 287
 288         return E_SUCCESS;
 289 }
 290
 291 Color
 292 _ColorPickerPresenter::GetColor(void) const
 293 {
 294         return __pColorPickerModel->GetColor();
 295 }
 296
 297 int
 298 _ColorPickerPresenter::GetHue(void) const
 299 {
 300         int hueValue = Math::Round((double) __pColorPickerModel->GetHue() * MAX_VALUE_DEGREE);
 301         return hueValue;
 302 }
 303
 304 int
 305 _ColorPickerPresenter::GetSaturation(void) const
 306 {
 307         int saturationValue = Math::Round((double) __pColorPickerModel->GetSaturation() * MAX_VALUE_DEGREE);
 308         return saturationValue;
 309 }
 310
 311 int
 312 _ColorPickerPresenter::GetLuminance(void) const
 313 {
 314         int luminanceValue = Math::Round((double) __pColorPickerModel->GetLuminance() * MAX_VALUE_DEGREE);
 315         return luminanceValue;
 316 }
 317
 318 void
 319 _ColorPickerPresenter::SetColor(const Color& color)
 320 {
 321         __pColorPickerModel->SetColor(color);
 322         SetHandlerPositionByRatio(HUE_HANDLER, __pColorPickerModel->GetHue());
 323         SetHandlerPositionByRatio(SAT_HANDLER, __pColorPickerModel->GetSaturation());
 324         SetHandlerPositionByRatio(LUM_HANDLER, __pColorPickerModel->GetLuminance());
 325
 326         return;
 327 }
 328
 329 result
 330 _ColorPickerPresenter::SetHue(int hue)
 331 {
 332         SysTryReturn(NID_UI_CTRL, (hue <= MAX_VALUE_DEGREE && hue >= 0), E_INVALID_ARG, E_INVALID_ARG,
 333                                  "[E_INVALID_ARG] Invalid argument(s) is used. Hue value is invalid.");
 334
 335         __pColorPickerModel->SetHue((double)hue / MAX_VALUE_DEGREE);
 336         SetHandlerPositionByRatio(HUE_HANDLER, __pColorPickerModel->GetHue());
 337
 338         return E_SUCCESS;
 339 }
 340
 341 result
 342 _ColorPickerPresenter::SetSaturation(int saturation)
 343 {
 344         SysTryReturn(NID_UI_CTRL, (saturation <= MAX_VALUE_DEGREE && saturation >= 0), E_INVALID_ARG, E_INVALID_ARG,
 345                         "[E_INVALID_ARG] Invalid argument(s) is used. Saturation value is invalid.");
 346
 347         __pColorPickerModel->SetSaturation((double)saturation / MAX_VALUE_DEGREE);
 348         SetHandlerPositionByRatio(SAT_HANDLER, __pColorPickerModel->GetSaturation());
 349
 350         return E_SUCCESS;
 351 }
 352
 353 result
 354 _ColorPickerPresenter::SetLuminance(int luminance)
 355 {
 356         SysTryReturn(NID_UI_CTRL, (luminance <= MAX_VALUE_DEGREE && luminance >= 0), E_INVALID_ARG, E_INVALID_ARG,
 357                         "[E_INVALID_ARG] Invalid argument(s) is used. Luminance value is invalid.");
 358
 359         __pColorPickerModel->SetLuminance((double)luminance / MAX_VALUE_DEGREE);
 360         SetHandlerPositionByRatio(LUM_HANDLER, __pColorPickerModel->GetLuminance());
 361
 362         return E_SUCCESS;
 363 }
 364
 365 void
 366 _ColorPickerPresenter::LoadDrawingProperties(const FloatRectangle& controlBounds)
 367 {
 368         const int _BLOCK_COUNT = 3;
 369         float arrowButtonLeftMargin = 0.0f;
 370         float arrowButtonTopMargin = 0.0f;
 371         float barTopMargin = 0.0f;
 372         float barLeftRightMargin = 0.0f;
 373         float sliderHeight = 0.0f;
 374         float sliderWidth = 0.0f;
 375
 376         _ControlOrientation orientation = _ControlManager::GetInstance()->GetOrientation();
 377
 378         GET_SHAPE_CONFIG(COLORPICKER::ARROW_BUTTON_LEFT_MARGIN, orientation, arrowButtonLeftMargin);
 379         GET_SHAPE_CONFIG(COLORPICKER::ARROW_BUTON_TOP_MARGIN, orientation, arrowButtonTopMargin);
 380         GET_SHAPE_CONFIG(COLORPICKER::BAR_TOP_MARGIN, orientation, barTopMargin);
 381         GET_SHAPE_CONFIG(COLORPICKER::BAR_LEFT_RIGHT_MARGIN, orientation, barLeftRightMargin);
 382         GET_SHAPE_CONFIG(COLORPICKER::SLIDER_HEIGHT, orientation, sliderHeight);
 383         GET_FIXED_VALUE_CONFIG(COLORPICKER::BLOCK_MARGIN, orientation, __blockMargin);
 384         GET_SHAPE_CONFIG(COLORPICKER::BLOCK_HEIGHT, orientation, __blockHeight);
 385         GET_SHAPE_CONFIG(COLORPICKER::DIVIDER_MARGIN, orientation, __dividerMargin);
 386         GET_SHAPE_CONFIG(COLORPICKER::DIVIDER_WIDTH, orientation, __dividerWidth);
 387
 388         __blockMargin = Tizen::Graphics::CoordinateSystem::ConvertToLogicalY(__blockMargin);
 389         __dividerMargin = Tizen::Graphics::CoordinateSystem::ConvertToLogicalY(__dividerMargin);
 390
 391         __topMargin = (controlBounds.height - __blockHeight * _BLOCK_COUNT) / 2.0f;
 392
 393         if (__topMargin < 0)
 394         {
 395                 __topMargin = 0;
 396         }
 397
 398         float arrowButtonWidth = 0.0f;
 399         float arrowButtonHeight = 0.0f;
 400
 401         GET_SHAPE_CONFIG(COLORPICKER::ARROW_BUTTON_WIDTH, orientation, arrowButtonWidth);
 402         GET_SHAPE_CONFIG(COLORPICKER::ARROW_BUTTON_HEIGHT, orientation, arrowButtonHeight);
 403
 404         float handlerWidth = 0.0f;
 405         float handlerHeight = 0.0f;
 406
 407         GET_SHAPE_CONFIG(COLORPICKER::HANDLER_WIDTH, orientation, handlerWidth);
 408         GET_SHAPE_CONFIG(COLORPICKER::HANDLER_HEIGHT, orientation, handlerHeight);
 409
 410         float btnStartY = arrowButtonTopMargin + __topMargin;
 411         float barStartY = barTopMargin + __topMargin;
 412
 413         GET_SHAPE_CONFIG(COLORPICKER::BAR_WIDTH, orientation, sliderWidth);
 414
 415         //Set contents position
 416         __componentBounds[HUE_ARROWLEFT].SetBounds(arrowButtonLeftMargin, btnStartY, arrowButtonWidth, arrowButtonHeight);
 417
 418         __componentBounds[HUE_BAR].SetBounds(arrowButtonLeftMargin + arrowButtonWidth + barLeftRightMargin, barStartY, sliderWidth, sliderHeight);
 419
 420         __componentBounds[HUE_ARROWRIGHT].SetBounds(__componentBounds[HUE_BAR].x + sliderWidth + barLeftRightMargin, btnStartY,
 421                         arrowButtonWidth, arrowButtonHeight);
 422
 423         btnStartY += __blockHeight;
 424         __componentBounds[SAT_ARROWLEFT].SetBounds(arrowButtonLeftMargin, btnStartY, arrowButtonWidth, arrowButtonHeight);
 425
 426         __componentBounds[SAT_BAR].SetBounds(arrowButtonLeftMargin + arrowButtonWidth + barLeftRightMargin, barStartY + __blockHeight,
 427                         sliderWidth, sliderHeight);
 428
 429         __componentBounds[SAT_ARROWRIGHT].SetBounds(__componentBounds[SAT_BAR].x + sliderWidth + barLeftRightMargin, btnStartY,
 430                         arrowButtonWidth, arrowButtonHeight);
 431
 432         btnStartY += __blockHeight;
 433         __componentBounds[LUM_ARROWLEFT].SetBounds(arrowButtonLeftMargin, btnStartY, arrowButtonWidth, arrowButtonHeight);
 434
 435         __componentBounds[LUM_BAR].SetBounds(arrowButtonLeftMargin + arrowButtonWidth + barLeftRightMargin, barStartY + __blockHeight * 2,
 436                         sliderWidth, sliderHeight);
 437
 438         __componentBounds[LUM_ARROWRIGHT].SetBounds(__componentBounds[LUM_BAR].x + sliderWidth + barLeftRightMargin, btnStartY,
 439                         arrowButtonWidth, arrowButtonHeight);
 440
 441         float differentialY = (handlerHeight - sliderHeight) / 2.0f;
 442
 443         __componentBounds[HUE_HANDLER].SetBounds(
 444                         __componentBounds[HUE_BAR].x + (__componentBounds[HUE_BAR].width - handlerWidth) * __pColorPickerModel->GetHue(),
 445                         __componentBounds[HUE_BAR].y - differentialY,
 446                         handlerWidth,
 447                         handlerHeight);
 448
 449         __componentBounds[SAT_HANDLER].SetBounds(
 450                         __componentBounds[SAT_BAR].x + (__componentBounds[SAT_BAR].width - handlerWidth) * (MAX_VALUE - __pColorPickerModel->GetSaturation()),
 451                         __componentBounds[SAT_BAR].y - differentialY,
 452                         handlerWidth,
 453                         handlerHeight);
 454
 455         __componentBounds[LUM_HANDLER].SetBounds(
 456                         __componentBounds[LUM_BAR].x + (__componentBounds[LUM_BAR].width - handlerWidth) * __pColorPickerModel->GetLuminance(),
 457                         __componentBounds[LUM_BAR].y - differentialY,
 458                         handlerWidth,
 459                         handlerHeight);
 460
 461         return;
 462 }
 463
 464 void
 465 _ColorPickerPresenter::OnChangeLayout(_ControlOrientation orientation)
 466 {
 467         FloatDimension colorPickerSize;
 468         result r = GET_DIMENSION_CONFIG(COLORPICKER::DEFAULT_SIZE, orientation, colorPickerSize);
 469
 470         if (r == E_SUCCESS && colorPickerSize != __pColorPicker->GetSizeF())
 471         {
 472                 __pColorPicker->SetResizable(true);
 473                 __pColorPicker->SetSize(colorPickerSize);
 474                 __pColorPicker->SetResizable(false);
 475         }
 476         return;
 477 }
 478
 479 bool
 480 _ColorPickerPresenter::OnTouchPressed(const _Control& source, const _TouchInfo& touchinfo)
 481 {
 482         FloatPoint point = touchinfo.GetCurrentPosition();
 483         __eventType = GetTouchActionType(point);
 484
 485         if (__eventType >= HUE_ARROWLEFT && __eventType <= LUM_ARROWRIGHT)
 486         {
 487                 FloatRectangle buttonBounds = __componentBounds[__eventType];
 488                 Canvas* pCanvas = __pColorPicker->GetCanvasN(buttonBounds);
 489                 if (pCanvas != null)
 490                 {
 491                         buttonBounds.x = 0;
 492                         buttonBounds.y = 0;
 493                         DrawArrowButton(*pCanvas, buttonBounds, true, IsLeftButton(__eventType));
 494                         delete pCanvas;
 495                         __pColorPicker->UpdateView();
 496                 }
 497                 TouchButton();
 498
 499                 if (__pSlideTimer == null)
 500                 {
 501                         __pSlideTimer = new (std::nothrow) Timer;
 502                         if (__pSlideTimer == null)
 503                         {
 504                                 return false;
 505                         }
 506
 507                         result r = __pSlideTimer->Construct(*this);
 508                         if (r != E_SUCCESS)
 509                         {
 510                                 delete __pSlideTimer;
 511                                 __pSlideTimer = null;
 512
 513                                 return false;
 514                         }
 515                 }
 516                 __pSlideTimer->Start(SLIDE_ACTIVATION_TIME);
 517         }
 518         else if (__eventType >= HUE_HANDLER && __eventType <= LUM_HANDLER)
 519         {
 520                 TouchHandler(point.x);
 521         }
 522
 523         return false;
 524 }
 525
 526 bool
 527 _ColorPickerPresenter::OnTouchMoved(const _Control& source, const _TouchInfo& touchinfo)
 528 {
 529         if (__eventType >= HUE_HANDLER && __eventType <= LUM_HANDLER)
 530         {
 531                 TouchHandler(touchinfo.GetCurrentPosition().x);
 532         }
 533
 534         return false;
 535 }
 536
 537 bool
 538 _ColorPickerPresenter::OnTouchReleased(const _Control& source, const _TouchInfo& touchinfo)
 539 {
 540         if (__pSlideTimer != null)
 541         {
 542                 __pSlideTimer->Cancel();
 543         }
 544         if(__eventType >= HUE_ARROWLEFT && __eventType <= LUM_ARROWRIGHT)
 545         {
 546                 PLAY_FEEDBACK(_RESOURCE_FEEDBACK_PATTERN_TAP, __pColorPicker);
 547         }
 548
 549         if (__eventType >= HUE_HANDLER && __eventType <= LUM_HANDLER)
 550         {
 551                 PLAY_FEEDBACK(_RESOURCE_FEEDBACK_PATTERN_TAP, __pColorPicker);
 552                 TouchHandler(touchinfo.GetCurrentPosition().x);
 553                 __eventType = HSL_NOT;
 554         }
 555         else
 556         {
 557                 __eventType = HSL_NOT;
 558                 __pColorPicker->Draw();
 559         }
 560
 561         return false;
 562 }
 563
 564 bool
 565 _ColorPickerPresenter::OnTouchCanceled(const _Control& source, const _TouchInfo& touchinfo)
 566 {
 567         return OnTouchReleased(source, touchinfo);
 568 }
 569
 570 void
 571 _ColorPickerPresenter::OnTimerExpired(Timer& timer)
 572 {
 573         if (__eventType >= HUE_ARROWLEFT && __eventType <= LUM_ARROWRIGHT)
 574         {
 575                 TouchButton();
 576         }
 577
 578         timer.Start(SLIDE_MOVE_TIME);
 579 }
 580
 581 result
 582 _ColorPickerPresenter::LoadResource(void)
 583 {
 584         result r = E_SUCCESS;
 585         Color buttonNormalColor;
 586         Color buttonPressedColor;
 587         Color buttonDisabledColor;
 588         Color buttonBgNormalColor;
 589         Color buttonBgPressedColor;
 590         Color buttonBgDisabledColor;
 591         Color handlerHighlightedColor;
 592         Bitmap* pBgNormalBitmap = null;
 593         Bitmap* pBgPressedBitmap = null;
 594         Bitmap* pBgDisabledBitmap = null;
 595         Bitmap* pLeftArrowNormalBitmap = null;
 596         Bitmap* pLeftArrowPressedBitmap = null;
 597         Bitmap* pLeftArrowDisabledBitmap = null;
 598         Bitmap* pRightArrowNormalBitmap = null;
 599         Bitmap* pRightArrowPressedBitmap = null;
 600         Bitmap* pRightArrowDisabledBitmap = null;
 601         Bitmap* pHandlerHighlightedBitmap = null;
 602
 603         r = GET_COLOR_CONFIG(COLORPICKER::ARROW_BUTTON_BG_NORMAL, buttonBgNormalColor);
 604         SysTryReturnResult(NID_UI_CTRL, r == E_SUCCESS, r, "[%s] Propagating.", GetErrorMessage(r));
 605
 606         r = GET_COLOR_CONFIG(COLORPICKER::ARROW_BUTTON_BG_PRESSED, buttonBgPressedColor);
 607         SysTryReturnResult(NID_UI_CTRL, r == E_SUCCESS, r, "[%s] Propagating.", GetErrorMessage(r));
 608
 609         r = GET_COLOR_CONFIG(COLORPICKER::ARROW_BUTTON_BG_DISABLED, buttonBgDisabledColor);
 610         SysTryReturnResult(NID_UI_CTRL, r == E_SUCCESS, r, "[%s] Propagating.", GetErrorMessage(r));
 611
 612         r = GET_COLOR_CONFIG(COLORPICKER::ARROW_BUTTON_NORMAL, buttonNormalColor);
 613         SysTryReturnResult(NID_UI_CTRL, r == E_SUCCESS, r, "[%s] Propagating.", GetErrorMessage(r));
 614
 615         r = GET_COLOR_CONFIG(COLORPICKER::ARROW_BUTTON_PRESSED, buttonPressedColor);
 616         SysTryReturnResult(NID_UI_CTRL, r == E_SUCCESS, r, "[%s] Propagating.", GetErrorMessage(r));
 617
 618         r = GET_COLOR_CONFIG(COLORPICKER::ARROW_BUTTON_DISABLED, buttonDisabledColor);
 619         SysTryReturnResult(NID_UI_CTRL, r == E_SUCCESS, r, "[%s] Propagating.", GetErrorMessage(r));
 620
 621         r = GET_COLOR_CONFIG(COLORPICKER::HANDLER_HIGHLIGHTED, handlerHighlightedColor);
 622         SysTryReturnResult(NID_UI_CTRL, r == E_SUCCESS, r, "[%s] Propagating.", GetErrorMessage(r));
 623
 624         r = GET_BITMAP_CONFIG_N(COLORPICKER::HUE_BAR_PORTRAIT_NORMAL, BITMAP_PIXEL_FORMAT_ARGB8888, __pHueSliderBgBitmap);
 625         SysTryCatch(NID_UI_CTRL, (r == E_SUCCESS), , r, "[%s] Propagating.", GetErrorMessage(r));
 626
 627         r = GET_BITMAP_CONFIG_N(COLORPICKER::BAR_BG_PORTRAIT_NORMAL, BITMAP_PIXEL_FORMAT_ARGB8888, __pCustomBitmap);
 628         SysTryCatch(NID_UI_CTRL, (r == E_SUCCESS), , r, "[%s] Propagating.", GetErrorMessage(r));
 629
 630         r = GET_BITMAP_CONFIG_N(COLORPICKER::LUMINANCE_BAR_PORTRAIT_NORMAL, BITMAP_PIXEL_FORMAT_ARGB8888, __pLuminanceSliderBgBitmap);
 631         SysTryCatch(NID_UI_CTRL, (r == E_SUCCESS), , r, "[%s] Propagating.", GetErrorMessage(r));
 632
 633         r = GET_BITMAP_CONFIG_N(COLORPICKER::SATURATION_BAR_PORTRAIT_NORMAL, BITMAP_PIXEL_FORMAT_ARGB8888, __pSaturationSliderBgBitmap);
 634         SysTryCatch(NID_UI_CTRL, (r == E_SUCCESS), , r, "[%s] Propagating.", GetErrorMessage(r));
 635
 636         r = GET_BITMAP_CONFIG_N(COLORPICKER::HUE_BAR_LANDSCAPE_NORMAL, BITMAP_PIXEL_FORMAT_ARGB8888, __pLandscapeHueSliderBgBitmap);
 637         SysTryCatch(NID_UI_CTRL, (r == E_SUCCESS), , r, "[%s] Propagating.", GetErrorMessage(r));
 638
 639         r = GET_BITMAP_CONFIG_N(COLORPICKER::BAR_BG_LANDSCAPE_NORMAL, BITMAP_PIXEL_FORMAT_ARGB8888, __pLandscapeCustomBitmap);
 640         SysTryCatch(NID_UI_CTRL, (r == E_SUCCESS), , r, "[%s] Propagating.", GetErrorMessage(r));
 641
 642         r = GET_BITMAP_CONFIG_N(COLORPICKER::LUMINANCE_BAR_LANDSCAPE_NORMAL, BITMAP_PIXEL_FORMAT_ARGB8888, __pLandscapeLuminanceSliderBgBitmap);
 643         SysTryCatch(NID_UI_CTRL, (r == E_SUCCESS), , r, "[%s] Propagating.", GetErrorMessage(r));
 644
 645         r = GET_BITMAP_CONFIG_N(COLORPICKER::SATURATION_BAR__LANDSCAPE_NORMAL, BITMAP_PIXEL_FORMAT_ARGB8888, __pLandscapeSaturationSliderBgBitmap);
 646         SysTryCatch(NID_UI_CTRL, (r == E_SUCCESS), , r, "[%s] Propagating.", GetErrorMessage(r));
 647
 648         r = GET_BITMAP_CONFIG_N(COLORPICKER::ARROW_BUTTON_BG_NORMAL, BITMAP_PIXEL_FORMAT_ARGB8888, pBgNormalBitmap);
 649         SysTryCatch(NID_UI_CTRL, (r == E_SUCCESS), , r, "[%s] Propagating.", GetErrorMessage(r));
 650
 651         r = GET_BITMAP_CONFIG_N(COLORPICKER::ARROW_BUTTON_BG_PRESSED, BITMAP_PIXEL_FORMAT_ARGB8888, pBgPressedBitmap);
 652         SysTryCatch(NID_UI_CTRL, (r == E_SUCCESS), , r, "[%s] Propagating.", GetErrorMessage(r));
 653
 654         r = GET_BITMAP_CONFIG_N(COLORPICKER::ARROW_BUTTON_BG_DISABLED, BITMAP_PIXEL_FORMAT_ARGB8888, pBgDisabledBitmap);
 655         SysTryCatch(NID_UI_CTRL, (r == E_SUCCESS), , r, "[%s] Propagating.", GetErrorMessage(r));
 656
 657         r = GET_BITMAP_CONFIG_N(COLORPICKER::ARROW_BUTTON_BG_EFFECT_NORMAL, BITMAP_PIXEL_FORMAT_ARGB8888, __pNormalEffectBgBitmap);
 658         SysTryCatch(NID_UI_CTRL, (r == E_SUCCESS), , r, "[%s] Propagating.", GetErrorMessage(r));
 659
 660         r = GET_BITMAP_CONFIG_N(COLORPICKER::ARROW_BUTTON_BG_EFFECT_PRESSED, BITMAP_PIXEL_FORMAT_ARGB8888, __pPressedEffectBgBitmap);
 661         SysTryCatch(NID_UI_CTRL, (r == E_SUCCESS), , r, "[%s] Propagating.", GetErrorMessage(r));
 662
 663         r = GET_BITMAP_CONFIG_N(COLORPICKER::ARROW_BUTTON_BG_EFFECT_DISABLED, BITMAP_PIXEL_FORMAT_ARGB8888, __pDisabledEffectBgBitmap);
 664         SysTryCatch(NID_UI_CTRL, (r == E_SUCCESS), , r, "[%s] Propagating.", GetErrorMessage(r));
 665
 666         r = GET_BITMAP_CONFIG_N(COLORPICKER::LEFT_ARROW_BUTTON_NORMAL, BITMAP_PIXEL_FORMAT_ARGB8888, pLeftArrowNormalBitmap);
 667         SysTryCatch(NID_UI_CTRL, (r == E_SUCCESS), , r, "[%s] Propagating.", GetErrorMessage(r));
 668
 669         r = GET_BITMAP_CONFIG_N(COLORPICKER::LEFT_ARROW_BUTTON_PRESSED, BITMAP_PIXEL_FORMAT_ARGB8888, pLeftArrowPressedBitmap);
 670         SysTryCatch(NID_UI_CTRL, (r == E_SUCCESS), , r, "[%s] Propagating.", GetErrorMessage(r));
 671
 672         r = GET_BITMAP_CONFIG_N(COLORPICKER::LEFT_ARROW_BUTTON_DISABLED, BITMAP_PIXEL_FORMAT_ARGB8888, pLeftArrowDisabledBitmap);
 673         SysTryCatch(NID_UI_CTRL, (r == E_SUCCESS), , r, "[%s] Propagating.", GetErrorMessage(r));
 674
 675         r = GET_BITMAP_CONFIG_N(COLORPICKER::RIGHT_ARROW_BUTTON_NORMAL, BITMAP_PIXEL_FORMAT_ARGB8888, pRightArrowNormalBitmap);
 676         SysTryCatch(NID_UI_CTRL, (r == E_SUCCESS), , r, "[%s] Propagating.", GetErrorMessage(r));
 677
 678         r = GET_BITMAP_CONFIG_N(COLORPICKER::RIGHT_ARROW_BUTTON_PRESSED, BITMAP_PIXEL_FORMAT_ARGB8888, pRightArrowPressedBitmap);
 679         SysTryCatch(NID_UI_CTRL, (r == E_SUCCESS), , r, "[%s] Propagating.", GetErrorMessage(r));
 680
 681         r = GET_BITMAP_CONFIG_N(COLORPICKER::RIGHT_ARROW_BUTTON_DISABLED, BITMAP_PIXEL_FORMAT_ARGB8888, pRightArrowDisabledBitmap);
 682         SysTryCatch(NID_UI_CTRL, (r == E_SUCCESS), , r, "[%s] Propagating.", GetErrorMessage(r));
 683
 684         r = GET_BITMAP_CONFIG_N(COLORPICKER::HANDLER_HIGHLIGHTED, BITMAP_PIXEL_FORMAT_ARGB8888, pHandlerHighlightedBitmap);
 685         SysTryCatch(NID_UI_CTRL, (r == E_SUCCESS), , r, "[%s] Propagating.", GetErrorMessage(r));
 686
 687         __pColorNormalReplacementBgBitmap = _BitmapImpl::GetColorReplacedBitmapN(*pBgNormalBitmap, Color::GetColor(COLOR_ID_MAGENTA), buttonBgNormalColor);
 688         r = GetLastResult();
 689         SysTryCatch(NID_UI_CTRL, (__pColorNormalReplacementBgBitmap != null), , r, "[%s] Propagating.", GetErrorMessage(r));
 690
 691         __pColorPressedReplacementBgBitmap = _BitmapImpl::GetColorReplacedBitmapN(*pBgPressedBitmap, Color::GetColor(COLOR_ID_MAGENTA), buttonBgPressedColor);
 692         r = GetLastResult();
 693         SysTryCatch(NID_UI_CTRL, (__pColorPressedReplacementBgBitmap != null), , r, "[%s] Propagating.", GetErrorMessage(r));
 694
 695         __pColorDisabledReplacementBgBitmap = _BitmapImpl::GetColorReplacedBitmapN(*pBgDisabledBitmap, Color::GetColor(COLOR_ID_MAGENTA), buttonBgDisabledColor);
 696         r = GetLastResult();
 697         SysTryCatch(NID_UI_CTRL, (__pColorDisabledReplacementBgBitmap != null), , r, "[%s] Propagating.", GetErrorMessage(r));
 698
 699         __pLeftArrowNormalBitmap = _BitmapImpl::GetColorReplacedBitmapN(*pLeftArrowNormalBitmap, Color::GetColor(COLOR_ID_MAGENTA), buttonNormalColor);
 700         r = GetLastResult();
 701         SysTryCatch(NID_UI_CTRL, (__pLeftArrowNormalBitmap != null), , r, "[%s] Propagating.", GetErrorMessage(r));
 702
 703         __pLeftArrowPressedBitmap = _BitmapImpl::GetColorReplacedBitmapN(*pLeftArrowPressedBitmap, Color::GetColor(COLOR_ID_MAGENTA), buttonPressedColor);
 704         r = GetLastResult();
 705         SysTryCatch(NID_UI_CTRL, (__pLeftArrowPressedBitmap != null), , r, "[%s] Propagating.", GetErrorMessage(r));
 706
 707         __pLeftArrowDisabledBitmap = _BitmapImpl::GetColorReplacedBitmapN(*pLeftArrowDisabledBitmap, Color::GetColor(COLOR_ID_MAGENTA), buttonDisabledColor);
 708         r = GetLastResult();
 709         SysTryCatch(NID_UI_CTRL, (__pLeftArrowDisabledBitmap != null), , r, "[%s] Propagating.", GetErrorMessage(r));
 710
 711         __pRightArrowNormalBitmap = _BitmapImpl::GetColorReplacedBitmapN(*pRightArrowNormalBitmap, Color::GetColor(COLOR_ID_MAGENTA), buttonNormalColor);
 712         r = GetLastResult();
 713         SysTryCatch(NID_UI_CTRL, (__pRightArrowNormalBitmap != null), , r, "[%s] Propagating.", GetErrorMessage(r));
 714
 715         __pRightArrowPressedBitmap = _BitmapImpl::GetColorReplacedBitmapN(*pRightArrowPressedBitmap, Color::GetColor(COLOR_ID_MAGENTA), buttonPressedColor);
 716         r = GetLastResult();
 717         SysTryCatch(NID_UI_CTRL, (__pRightArrowPressedBitmap != null), , r, "[%s] Propagating.", GetErrorMessage(r));
 718
 719         __pRightArrowDisabledBitmap = _BitmapImpl::GetColorReplacedBitmapN(*pRightArrowDisabledBitmap, Color::GetColor(COLOR_ID_MAGENTA), buttonDisabledColor);
 720         r = GetLastResult();
 721         SysTryCatch(NID_UI_CTRL, (__pRightArrowDisabledBitmap != null), , r, "[%s] Propagating.", GetErrorMessage(r));
 722
 723         __pFocusBitmap = _BitmapImpl::GetColorReplacedBitmapN(*pHandlerHighlightedBitmap, Color::GetColor(COLOR_ID_MAGENTA), handlerHighlightedColor);
 724         r = GetLastResult();
 725         SysTryCatch(NID_UI_CTRL, (__pFocusBitmap != null), , r, "[%s] Propagating.", GetErrorMessage(r));
 726
 727         r = GET_BITMAP_CONFIG_N(COLORPICKER::HANDLER_NORMAL, BITMAP_PIXEL_FORMAT_ARGB8888, __pHandlerBitmap);
 728         SysTryCatch(NID_UI_CTRL, (r == E_SUCCESS), , r, "[%s] Propagating.", GetErrorMessage(r));
 729
 730         delete pBgNormalBitmap;
 731         pBgNormalBitmap = null;
 732
 733         delete pBgPressedBitmap;
 734         pBgPressedBitmap = null;
 735
 736         delete pBgDisabledBitmap;
 737         pBgDisabledBitmap = null;
 738
 739         delete pLeftArrowNormalBitmap;
 740         pLeftArrowNormalBitmap = null;
 741
 742         delete pLeftArrowPressedBitmap;
 743         pLeftArrowPressedBitmap = null;
 744
 745         delete pLeftArrowDisabledBitmap;
 746         pLeftArrowDisabledBitmap = null;
 747
 748         delete pRightArrowNormalBitmap;
 749         pRightArrowNormalBitmap = null;
 750
 751         delete pRightArrowPressedBitmap;
 752         pRightArrowPressedBitmap = null;
 753
 754         delete pRightArrowDisabledBitmap;
 755         pRightArrowDisabledBitmap = null;
 756
 757         delete pHandlerHighlightedBitmap;
 758         pHandlerHighlightedBitmap = null;
 759
 760         return r;
 761
 762 CATCH:
 763         delete __pHueSliderBgBitmap;
 764         __pHueSliderBgBitmap = null;
 765
 766         delete __pCustomBitmap;
 767         __pCustomBitmap = null;
 768
 769         delete __pLuminanceSliderBgBitmap;
 770         __pLuminanceSliderBgBitmap = null;
 771
 772         delete __pSaturationSliderBgBitmap;
 773         __pSaturationSliderBgBitmap = null;
 774
 775         delete pBgNormalBitmap;
 776         pBgNormalBitmap = null;
 777
 778         delete pBgPressedBitmap;
 779         pBgPressedBitmap = null;
 780
 781         delete pBgDisabledBitmap;
 782         pBgDisabledBitmap = null;
 783
 784         delete pLeftArrowNormalBitmap;
 785         pLeftArrowNormalBitmap = null;
 786
 787         delete pLeftArrowPressedBitmap;
 788         pLeftArrowPressedBitmap = null;
 789
 790         delete pLeftArrowDisabledBitmap;
 791         pLeftArrowDisabledBitmap = null;
 792
 793         delete pRightArrowNormalBitmap;
 794         pRightArrowNormalBitmap = null;
 795
 796         delete pRightArrowPressedBitmap;
 797         pRightArrowPressedBitmap = null;
 798
 799         delete pRightArrowDisabledBitmap;
 800         pRightArrowDisabledBitmap = null;
 801
 802         delete __pColorNormalReplacementBgBitmap;
 803         __pColorNormalReplacementBgBitmap = null;
 804
 805         delete __pColorPressedReplacementBgBitmap;
 806         __pColorPressedReplacementBgBitmap = null;
 807
 808         delete __pColorDisabledReplacementBgBitmap;
 809         __pColorDisabledReplacementBgBitmap = null;
 810
 811         delete __pNormalEffectBgBitmap;
 812         __pNormalEffectBgBitmap = null;
 813
 814         delete __pPressedEffectBgBitmap;
 815         __pPressedEffectBgBitmap = null;
 816
 817         delete __pDisabledEffectBgBitmap;
 818         __pDisabledEffectBgBitmap = null;
 819
 820         delete __pLeftArrowNormalBitmap;
 821         __pLeftArrowNormalBitmap = null;
 822
 823         delete __pLeftArrowPressedBitmap;
 824         __pLeftArrowPressedBitmap = null;
 825
 826         delete __pLeftArrowDisabledBitmap;
 827         __pLeftArrowDisabledBitmap = null;
 828
 829         delete __pRightArrowNormalBitmap;
 830         __pRightArrowNormalBitmap = null;
 831
 832         delete __pRightArrowPressedBitmap;
 833         __pRightArrowPressedBitmap = null;
 834
 835         delete __pRightArrowDisabledBitmap;
 836         __pRightArrowDisabledBitmap = null;
 837
 838         delete __pFocusBitmap;
 839         __pFocusBitmap = null;
 840
 841         delete pHandlerHighlightedBitmap;
 842         pHandlerHighlightedBitmap = null;
 843
 844         return r;
 845 }
 846
 847 void
 848 _ColorPickerPresenter::StepHandler(_ColorPickerComponentType index, bool increase)
 849 {
 850         if (increase)
 851         {
 852                 SetHandlerPosition(index, __componentBounds[index].x + ARROW_MOVE_STEP);
 853         }
 854         else
 855         {
 856                 SetHandlerPosition(index, __componentBounds[index].x - ARROW_MOVE_STEP);
 857         }
 858
 859         MoveHandler(index);
 860         ChangeColorFromCurrentHandlerPosition(index);
 861 }
 862
 863 result
 864 _ColorPickerPresenter::DrawFocus(_ColorPickerComponentType currentFocusedIndex, _ColorPickerComponentType prevFocusIndex)
 865 {
 866         result r = E_SUCCESS;
 867
 868         if (prevFocusIndex != HSL_NOT)
 869         {
 870                 ClearFocus(prevFocusIndex);
 871         }
 872
 873         switch (currentFocusedIndex)
 874         {
 875                 case HUE_HANDLER:
 876                 {
 877                         Canvas *pCanvas = __pColorPicker->GetHueHandler()->GetCanvasN();
 878                         r = GetLastResult();
 879                         SysTryReturnResult(NID_UI_CTRL, pCanvas != null, r, "[%s] Propagating.", GetErrorMessage(r));
 880                         r = DrawResourceBitmap(*pCanvas, FloatRectangle(0, 0, __componentBounds[HUE_HANDLER].width, __componentBounds[HUE_HANDLER].height), __pFocusBitmap);
 881                         delete pCanvas;
 882                 }
 883                 break;
 884                 case SAT_HANDLER:
 885                 {
 886                         Canvas *pCanvas = __pColorPicker->GetSaturationHandler()->GetCanvasN();
 887                         r = GetLastResult();
 888                         SysTryReturnResult(NID_UI_CTRL, pCanvas != null, r, "[%s] Propagating.", GetErrorMessage(r));
 889                         r = DrawResourceBitmap(*pCanvas, FloatRectangle(0, 0, __componentBounds[SAT_HANDLER].width, __componentBounds[SAT_HANDLER].height), __pFocusBitmap);
 890                         delete pCanvas;
 891                 }
 892                 break;
 893                 case LUM_HANDLER:
 894                 {
 895                         Canvas *pCanvas = __pColorPicker->GetLuminanceHandler()->GetCanvasN();
 896                         r = GetLastResult();
 897                         SysTryReturnResult(NID_UI_CTRL, pCanvas != null, r, "[%s] Propagating.", GetErrorMessage(r));
 898                         r = DrawResourceBitmap(*pCanvas, FloatRectangle(0, 0, __componentBounds[LUM_HANDLER].width, __componentBounds[LUM_HANDLER].height), __pFocusBitmap);
 899                         delete pCanvas;
 900                 }
 901                 break;
 902                 default:
 903                         break;
 904         }
 905
 906         return r;
 907 }
 908
 909 result
 910 _ColorPickerPresenter::ClearFocus(_ColorPickerComponentType index)
 911 {
 912         result r = E_SUCCESS;
 913
 914         switch (index)
 915         {
 916                 case HUE_HANDLER:
 917                 {
 918                         Canvas *pCanvas = __pColorPicker->GetHueHandler()->GetCanvasN();
 919                          r = GetLastResult();
 920                         SysTryReturnResult(NID_UI_CTRL, pCanvas != null, r, "[%s] Propagating.", GetErrorMessage(r));
 921                         pCanvas->SetBackgroundColor(Color());
 922                         pCanvas->Clear();
 923                         r = DrawResourceBitmap(*pCanvas, FloatRectangle(0, 0, __componentBounds[HUE_HANDLER].width, __componentBounds[HUE_HANDLER].height), __pHandlerBitmap);
 924                         delete pCanvas;
 925                 }
 926                 break;
 927                 case SAT_HANDLER:
 928                 {
 929                         Canvas *pCanvas = __pColorPicker->GetSaturationHandler()->GetCanvasN();
 930                          r = GetLastResult();
 931                         SysTryReturnResult(NID_UI_CTRL, pCanvas != null, r, "[%s] Propagating.", GetErrorMessage(r));
 932                         pCanvas->SetBackgroundColor(Color());
 933                         pCanvas->Clear();
 934                         r = DrawResourceBitmap(*pCanvas, FloatRectangle(0, 0, __componentBounds[SAT_HANDLER].width, __componentBounds[SAT_HANDLER].height), __pHandlerBitmap);
 935                         delete pCanvas;
 936                 }
 937                 break;
 938                 case LUM_HANDLER:
 939                 {
 940                         Canvas *pCanvas = __pColorPicker->GetLuminanceHandler()->GetCanvasN();
 941                          r = GetLastResult();
 942                         SysTryReturnResult(NID_UI_CTRL, pCanvas != null, r, "[%s] Propagating.", GetErrorMessage(r));
 943                         pCanvas->SetBackgroundColor(Color());
 944                         pCanvas->Clear();
 945                         r = DrawResourceBitmap(*pCanvas, FloatRectangle(0, 0, __componentBounds[LUM_HANDLER].width, __componentBounds[LUM_HANDLER].height), __pHandlerBitmap);
 946                         delete pCanvas;
 947                 }
 948                 break;
 949                 default:
 950                         break;
 951         }
 952
 953         return r;
 954 }
 955
 956 result
 957 _ColorPickerPresenter::DrawHueSlider(Canvas& canvas)
 958 {
 959         result r = E_SUCCESS;
 960
 961         _ControlOrientation orientation = _ControlManager::GetInstance()->GetOrientation();
 962
 963         if (__pHueSliderBgBitmap != null && orientation == _CONTROL_ORIENTATION_PORTRAIT)
 964         {
 965                 r = DrawResourceBitmap(canvas, __componentBounds[HUE_BAR], __pHueSliderBgBitmap);
 966                 SysTryReturn(NID_UI_CTRL, (r == E_SUCCESS), r, r, "[%s] Propagating.", GetErrorMessage(r));
 967         }
 968         else if (__pLandscapeHueSliderBgBitmap != null && orientation == _CONTROL_ORIENTATION_LANDSCAPE)
 969         {
 970                 r = DrawResourceBitmap(canvas, __componentBounds[HUE_BAR], __pLandscapeHueSliderBgBitmap);
 971                 SysTryReturn(NID_UI_CTRL, (r == E_SUCCESS), r, r, "[%s] Propagating.", GetErrorMessage(r));
 972         }
 973
 974         return r;
 975 }
 976
 977 result
 978 _ColorPickerPresenter::DrawLuminanceSlider(Canvas& canvas)
 979 {
 980         result r = E_SUCCESS;
 981         Bitmap* pColorReplacementBitmap = null;
 982         _ControlOrientation orientation = _ControlManager::GetInstance()->GetOrientation();
 983
 984         canvas.SetBackgroundColor(Color(0, 0, 0, 0));
 985         canvas.Clear(__componentBounds[LUM_BAR]);
 986
 987         if (__pCustomBitmap != null && __pLuminanceSliderBgBitmap != null && orientation == _CONTROL_ORIENTATION_PORTRAIT)
 988         {
 989                 pColorReplacementBitmap = _BitmapImpl::GetColorReplacedBitmapN(*__pCustomBitmap, Color::GetColor(COLOR_ID_MAGENTA), __pColorPickerModel->GetSaturationColor());
 990                 r = GetLastResult();
 991                 SysTryReturn(NID_UI_CTRL, pColorReplacementBitmap, E_SYSTEM, r, "[%s] Propagating.", GetErrorMessage(r));
 992
 993                 r = DrawResourceBitmap(canvas, __componentBounds[LUM_BAR], pColorReplacementBitmap);
 994                 SysTryCatch(NID_UI_CTRL, (r == E_SUCCESS), , r, "[%s] Propagating.", GetErrorMessage(r));
 995
 996                 r = DrawResourceBitmap(canvas, __componentBounds[LUM_BAR], __pLuminanceSliderBgBitmap);
 997                 SysTryCatch(NID_UI_CTRL, (r == E_SUCCESS), , r, "[%s] Propagating.", GetErrorMessage(r));
 998         }
 999         else if (__pLandscapeCustomBitmap != null && __pLandscapeLuminanceSliderBgBitmap != null && orientation == _CONTROL_ORIENTATION_LANDSCAPE)
1000         {
1001                 pColorReplacementBitmap = _BitmapImpl::GetColorReplacedBitmapN(*__pLandscapeCustomBitmap, Color::GetColor(COLOR_ID_MAGENTA), __pColorPickerModel->GetSaturationColor());
1002                 r = GetLastResult();
1003                 SysTryReturn(NID_UI_CTRL, pColorReplacementBitmap, r, r, "[%s] Propagating.", GetErrorMessage(r));
1004
1005                 r = DrawResourceBitmap(canvas, __componentBounds[LUM_BAR], pColorReplacementBitmap);
1006                 SysTryCatch(NID_UI_CTRL, (r == E_SUCCESS), , r, "[%s] Propagating.", GetErrorMessage(r));
1007
1008                 r = DrawResourceBitmap(canvas, __componentBounds[LUM_BAR], __pLandscapeLuminanceSliderBgBitmap);
1009                 SysTryCatch(NID_UI_CTRL, (r == E_SUCCESS), , r, "[%s] Propagating.", GetErrorMessage(r));
1010         }
1011
1012         __saturationColor = __pColorPickerModel->GetSaturationColor();
1013
1014         delete pColorReplacementBitmap;
1015         pColorReplacementBitmap = null;
1016
1017         return r;
1018
1019 CATCH:
1020
1021         delete pColorReplacementBitmap;
1022         pColorReplacementBitmap = null;
1023
1024         return r;
1025 }
1026
1027 result
1028 _ColorPickerPresenter::DrawSaturationSlider(Canvas& canvas)
1029 {
1030         result r = E_SUCCESS;
1031         Bitmap* pColorReplacementBitmap = null;
1032         _ControlOrientation orientation = _ControlManager::GetInstance()->GetOrientation();
1033
1034         canvas.SetBackgroundColor(Color(0, 0, 0, 0));
1035         canvas.Clear(__componentBounds[SAT_BAR]);
1036
1037         if (__pCustomBitmap != null && __pSaturationSliderBgBitmap != null && orientation == _CONTROL_ORIENTATION_PORTRAIT)
1038         {
1039                 pColorReplacementBitmap = _BitmapImpl::GetColorReplacedBitmapN(*__pCustomBitmap, Color::GetColor(COLOR_ID_MAGENTA), __pColorPickerModel->GetHueColor());
1040                 r = GetLastResult();
1041                 SysTryReturn(NID_UI_CTRL, pColorReplacementBitmap, r, r, "[%s] Propagating.", GetErrorMessage(r));
1042
1043                 r = DrawResourceBitmap(canvas, __componentBounds[SAT_BAR], pColorReplacementBitmap);
1044                 SysTryCatch(NID_UI_CTRL, (r == E_SUCCESS), , r, "[%s] Propagating.", GetErrorMessage(r));
1045
1046                 r = DrawResourceBitmap(canvas, __componentBounds[SAT_BAR], __pSaturationSliderBgBitmap);
1047                 SysTryCatch(NID_UI_CTRL, (r == E_SUCCESS), , r, "[%s] Propagating.", GetErrorMessage(r));
1048         }
1049         else if (__pLandscapeCustomBitmap != null && __pLandscapeSaturationSliderBgBitmap != null && orientation == _CONTROL_ORIENTATION_LANDSCAPE)
1050         {
1051                 pColorReplacementBitmap = _BitmapImpl::GetColorReplacedBitmapN(*__pLandscapeCustomBitmap, Color::GetColor(COLOR_ID_MAGENTA), __pColorPickerModel->GetHueColor());
1052                 r = GetLastResult();
1053                 SysTryReturn(NID_UI_CTRL, pColorReplacementBitmap, r, r, "[%s] Propagating.", GetErrorMessage(r));
1054
1055                 r = DrawResourceBitmap(canvas, __componentBounds[SAT_BAR], pColorReplacementBitmap);
1056                 SysTryCatch(NID_UI_CTRL, (r == E_SUCCESS), , r, "[%s] Propagating.", GetErrorMessage(r));
1057
1058                 r = DrawResourceBitmap(canvas, __componentBounds[SAT_BAR], __pLandscapeSaturationSliderBgBitmap);
1059                 SysTryCatch(NID_UI_CTRL, (r == E_SUCCESS), , r, "[%s] Propagating.", GetErrorMessage(r));
1060         }
1061
1062         __hueColor = __pColorPickerModel->GetHueColor();
1063
1064         delete pColorReplacementBitmap;
1065         pColorReplacementBitmap = null;
1066
1067         return r;
1068
1069 CATCH:
1070
1071         delete pColorReplacementBitmap;
1072         pColorReplacementBitmap = null;
1073
1074         return r;
1075 }
1076
1077 result
1078 _ColorPickerPresenter::DrawLine(Canvas& canvas)
1079 {
1080         if (__blockMargin <= 0)
1081         {
1082                 return E_SUCCESS;
1083         }
1084
1085         result r = E_SUCCESS;
1086         Color foregroundColor = canvas.GetForegroundColor();
1087         Color dividerTopHalfColor;
1088         Color dividerBottomHalfColor;
1089
1090         r = GET_COLOR_CONFIG(COLORPICKER::DIVIDER_TOP_HALF, dividerTopHalfColor);
1091         SysTryReturn(NID_UI_CTRL, (r == E_SUCCESS), r, r, "[%s] Propagating.", GetErrorMessage(r));
1092
1093         r = GET_COLOR_CONFIG(COLORPICKER::DIVIDER_BOTTOM_HALF, dividerBottomHalfColor);
1094         SysTryReturn(NID_UI_CTRL, (r == E_SUCCESS), r, r, "[%s] Propagating.", GetErrorMessage(r));
1095
1096         canvas.SetForegroundColor(dividerTopHalfColor);
1097         canvas.SetLineStyle(LINE_STYLE_SOLID);
1098
1099         FloatPoint startPoint = Tizen::Graphics::CoordinateSystem::AlignToDevice(FloatPoint(__dividerMargin, __topMargin + __blockHeight - __blockMargin));
1100         FloatPoint endPoint = Tizen::Graphics::CoordinateSystem::AlignToDevice(FloatPoint(__dividerMargin + __dividerWidth, __topMargin + __blockHeight - __blockMargin));
1101
1102         r = canvas.DrawLine(startPoint, endPoint);
1103         SysTryReturn(NID_UI_CTRL, (r == E_SUCCESS), r, r, "[%s] Propagating.", GetErrorMessage(r));
1104
1105         startPoint = Tizen::Graphics::CoordinateSystem::AlignToDevice(FloatPoint(__dividerMargin, __topMargin + (__blockHeight * 2.0f) - __blockMargin));
1106         endPoint = Tizen::Graphics::CoordinateSystem::AlignToDevice(FloatPoint(__dividerMargin + __dividerWidth, __topMargin + (__blockHeight * 2.0f) - __blockMargin));
1107
1108         r = canvas.DrawLine(startPoint, endPoint);
1109         SysTryReturn(NID_UI_CTRL, (r == E_SUCCESS), r, r, "[%s] Propagating.", GetErrorMessage(r));
1110
1111         canvas.SetForegroundColor(dividerBottomHalfColor);
1112
1113         startPoint = Tizen::Graphics::CoordinateSystem::AlignToDevice(FloatPoint(__dividerMargin, __topMargin + __blockHeight));
1114         endPoint = Tizen::Graphics::CoordinateSystem::AlignToDevice(FloatPoint(__dividerMargin + __dividerWidth, __topMargin + __blockHeight));
1115
1116         r = canvas.DrawLine(startPoint, endPoint);
1117         SysTryReturn(NID_UI_CTRL, (r == E_SUCCESS), r, r, "[%s] Propagating.", GetErrorMessage(r));
1118
1119         startPoint = Tizen::Graphics::CoordinateSystem::AlignToDevice(FloatPoint(__dividerMargin, __topMargin + (__blockHeight * 2.0f)));
1120         endPoint = Tizen::Graphics::CoordinateSystem::AlignToDevice(FloatPoint(__dividerMargin + __dividerWidth, __topMargin + (__blockHeight * 2.0f)));
1121
1122         r = canvas.DrawLine(startPoint, endPoint);
1123         SysTryReturn(NID_UI_CTRL, (r == E_SUCCESS), r, r, "[%s] Propagating.", GetErrorMessage(r));
1124
1125         canvas.SetForegroundColor(foregroundColor);
1126
1127         return r;
1128 }
1129
1130 result
1131 _ColorPickerPresenter::DrawArrowButton(Canvas& canvas, const FloatRectangle& rcButton, bool isSelected, bool drawLeftButton)
1132 {
1133         result r = E_SUCCESS;
1134         bool isCustomBitmap = false;
1135         _ControlOrientation orientation = _ControlManager::GetInstance()->GetOrientation();
1136
1137         FloatDimension rightLeftArrowIconSize;
1138         GET_DIMENSION_CONFIG(COLORPICKER::ARROW_BUTTON_ARROW_ICON_SIZE, orientation, rightLeftArrowIconSize);
1139
1140         FloatRectangle rightLeftArrowIconBounds;
1141         rightLeftArrowIconBounds.x = rcButton.x + (rcButton.width - rightLeftArrowIconSize.width) / 2.0f;
1142         rightLeftArrowIconBounds.y = rcButton.y + (rcButton.height - rightLeftArrowIconSize.height) / 2.0f;
1143         rightLeftArrowIconBounds.width = rightLeftArrowIconSize.width;
1144         rightLeftArrowIconBounds.height = rightLeftArrowIconSize.height;
1145
1146
1147         if (__pColorPicker->IsEnabled() == false)
1148         {
1149                 isCustomBitmap = IS_CUSTOM_BITMAP(COLORPICKER::ARROW_BUTTON_BG_DISABLED);
1150
1151                 r = DrawResourceBitmap(canvas, rcButton, __pColorDisabledReplacementBgBitmap);
1152                 SysTryReturn(NID_UI_CTRL, r == E_SUCCESS, r, r, "[%s] Propagating.", GetErrorMessage(r));
1153
1154                 if (isCustomBitmap == false)
1155                 {
1156                         r = DrawResourceBitmap(canvas, rcButton, __pDisabledEffectBgBitmap);
1157                         SysTryReturn(NID_UI_CTRL, r == E_SUCCESS, r, r, "[%s] Propagating.", GetErrorMessage(r));
1158                 }
1159
1160                 if (drawLeftButton)
1161                 {
1162                         r = DrawResourceBitmap(canvas, rightLeftArrowIconBounds, __pLeftArrowDisabledBitmap);
1163                         SysTryReturn(NID_UI_CTRL, r == E_SUCCESS, r, r, "[%s] Propagating.", GetErrorMessage(r));
1164                 }
1165                 else
1166                 {
1167                         r = DrawResourceBitmap(canvas, rightLeftArrowIconBounds, __pRightArrowDisabledBitmap);
1168                         SysTryReturn(NID_UI_CTRL, r == E_SUCCESS, r, r, "[%s] Propagating.", GetErrorMessage(r));
1169                 }
1170         }
1171         else if (isSelected)
1172         {
1173                 isCustomBitmap = IS_CUSTOM_BITMAP(COLORPICKER::ARROW_BUTTON_BG_PRESSED);
1174
1175                 r = DrawResourceBitmap(canvas, rcButton, __pColorPressedReplacementBgBitmap);
1176                 SysTryReturn(NID_UI_CTRL, r == E_SUCCESS, r, r, "[%s] Propagating.", GetErrorMessage(r));
1177
1178                 if (isCustomBitmap == false)
1179                 {
1180                         r = DrawResourceBitmap(canvas, rcButton, __pPressedEffectBgBitmap);
1181                         SysTryReturn(NID_UI_CTRL, r == E_SUCCESS, r, r, "[%s] Propagating.", GetErrorMessage(r));
1182                 }
1183
1184                 if (drawLeftButton)
1185                 {
1186                         r = DrawResourceBitmap(canvas, rightLeftArrowIconBounds, __pLeftArrowPressedBitmap);
1187                         SysTryReturn(NID_UI_CTRL, r == E_SUCCESS, r, r, "[%s] Propagating.", GetErrorMessage(r));
1188                 }
1189                 else
1190                 {
1191                         r = DrawResourceBitmap(canvas, rightLeftArrowIconBounds, __pRightArrowPressedBitmap);
1192                         SysTryReturn(NID_UI_CTRL, r == E_SUCCESS, r, r, "[%s] Propagating.", GetErrorMessage(r));
1193                 }
1194         }
1195         else
1196         {
1197                 isCustomBitmap = IS_CUSTOM_BITMAP(COLORPICKER::ARROW_BUTTON_BG_NORMAL);
1198
1199                 r = DrawResourceBitmap(canvas, rcButton, __pColorNormalReplacementBgBitmap);
1200                 SysTryReturn(NID_UI_CTRL, r == E_SUCCESS, r, r, "[%s] Propagating.", GetErrorMessage(r));
1201
1202                 if (isCustomBitmap == false)
1203                 {
1204                         r = DrawResourceBitmap(canvas, rcButton, __pNormalEffectBgBitmap);
1205                         SysTryReturn(NID_UI_CTRL, r == E_SUCCESS, r, r, "[%s] Propagating.", GetErrorMessage(r));
1206                 }
1207
1208                 if (drawLeftButton)
1209                 {
1210                         r = DrawResourceBitmap(canvas, rightLeftArrowIconBounds, __pLeftArrowNormalBitmap);
1211                         SysTryReturn(NID_UI_CTRL, r == E_SUCCESS, r, r, "[%s] Propagating.", GetErrorMessage(r));
1212                 }
1213                 else
1214                 {
1215                         r = DrawResourceBitmap(canvas, rightLeftArrowIconBounds, __pRightArrowNormalBitmap);
1216                         SysTryReturn(NID_UI_CTRL, r == E_SUCCESS, r, r, "[%s] Propagating.", GetErrorMessage(r));
1217                 }
1218         }
1219
1220         return r;
1221 }
1222
1223 result
1224 _ColorPickerPresenter::DrawArrowButtons(Canvas& canvas)
1225 {
1226         DrawArrowButton(canvas, __componentBounds[HUE_ARROWLEFT], __eventType == HUE_ARROWLEFT, true);
1227         DrawArrowButton(canvas, __componentBounds[HUE_ARROWRIGHT], __eventType == HUE_ARROWRIGHT, false);
1228         DrawArrowButton(canvas, __componentBounds[SAT_ARROWLEFT], __eventType == SAT_ARROWLEFT, true);
1229         DrawArrowButton(canvas, __componentBounds[SAT_ARROWRIGHT], __eventType == SAT_ARROWRIGHT, false);
1230         DrawArrowButton(canvas, __componentBounds[LUM_ARROWLEFT], __eventType == LUM_ARROWLEFT, true);
1231         DrawArrowButton(canvas, __componentBounds[LUM_ARROWRIGHT], __eventType == LUM_ARROWRIGHT, false);
1232
1233         return E_SUCCESS;
1234 }
1235
1236 result
1237 _ColorPickerPresenter::MoveHandler(_ColorPickerComponentType handlerType)
1238 {
1239         _VisualElement* pHandler = null;
1240         result r = E_SUCCESS;
1241
1242         switch (handlerType)
1243         {
1244         case HUE_HANDLER:
1245                 pHandler = __pColorPicker->GetHueHandler();
1246                 break;
1247         case SAT_HANDLER:
1248                 pHandler = __pColorPicker->GetSaturationHandler();
1249                 break;
1250         case LUM_HANDLER:
1251                 pHandler = __pColorPicker->GetLuminanceHandler();
1252                 break;
1253         default:
1254                 r = E_INVALID_ARG;
1255                 break;
1256         }
1257
1258         SysTryReturnResult(NID_UI_CTRL, r == E_SUCCESS, r, "Handler event type is invalid.");
1259
1260         SysTryReturnResult(NID_UI_CTRL, pHandler != null, E_SYSTEM, "A system error has occurred. Failed to get the handler.");
1261
1262         FloatRectangle bounds = __pColorPicker->GetClientBoundsF();
1263         FloatRectangle& handlerBounds = __componentBounds[handlerType];
1264         pHandler->SetBounds(FloatRectangle(bounds.x + handlerBounds.x, bounds.y + handlerBounds.y, handlerBounds.width, handlerBounds.height));
1265
1266         return r;
1267 }
1268
1269 result
1270 _ColorPickerPresenter::TouchButton(void)
1271 {
1272         result r = E_SUCCESS;
1273
1274         switch (__eventType)
1275         {
1276         case HUE_ARROWLEFT:
1277                 SetHandlerPosition(HUE_HANDLER, __componentBounds[HUE_HANDLER].x - ARROW_MOVE_STEP);
1278                 MoveHandler(HUE_HANDLER);
1279                 ChangeColorFromCurrentHandlerPosition(HUE_HANDLER);
1280                 break;
1281         case HUE_ARROWRIGHT:
1282                 SetHandlerPosition(HUE_HANDLER, __componentBounds[HUE_HANDLER].x + ARROW_MOVE_STEP);
1283                 MoveHandler(HUE_HANDLER);
1284                 ChangeColorFromCurrentHandlerPosition(HUE_HANDLER);
1285                 break;
1286         case SAT_ARROWLEFT:
1287                 SetHandlerPosition(SAT_HANDLER, __componentBounds[SAT_HANDLER].x - ARROW_MOVE_STEP);
1288                 MoveHandler(SAT_HANDLER);
1289                 ChangeColorFromCurrentHandlerPosition(SAT_HANDLER);
1290                 break;
1291         case SAT_ARROWRIGHT:
1292                 SetHandlerPosition(SAT_HANDLER, __componentBounds[SAT_HANDLER].x + ARROW_MOVE_STEP);
1293                 MoveHandler(SAT_HANDLER);
1294                 ChangeColorFromCurrentHandlerPosition(SAT_HANDLER);
1295                 break;
1296         case LUM_ARROWLEFT:
1297                 SetHandlerPosition(LUM_HANDLER, __componentBounds[LUM_HANDLER].x - ARROW_MOVE_STEP);
1298                 MoveHandler(LUM_HANDLER);
1299                 ChangeColorFromCurrentHandlerPosition(LUM_HANDLER);
1300                 break;
1301         case LUM_ARROWRIGHT:
1302                 SetHandlerPosition(LUM_HANDLER, __componentBounds[LUM_HANDLER].x + ARROW_MOVE_STEP);
1303                 MoveHandler(LUM_HANDLER);
1304                 ChangeColorFromCurrentHandlerPosition(LUM_HANDLER);
1305                 break;
1306         default:
1307                 SysLogException(NID_UI_CTRL, E_INVALID_ARG, "[E_INVALID_ARG] Invalid argument(s) is used. Arrow button type is invalid.");
1308                 r = E_INVALID_ARG;
1309                 break;
1310         }
1311
1312         return r;
1313 }
1314
1315 result
1316 _ColorPickerPresenter::TouchHandler(float position)
1317 {
1318         result r = E_SUCCESS;
1319
1320         switch (__eventType)
1321         {
1322         case HUE_HANDLER:
1323                 // fall through
1324         case SAT_HANDLER:
1325                 // fall through
1326         case LUM_HANDLER:
1327                 SetHandlerPosition(__eventType, position - __componentBounds[__eventType].width / 2);
1328                 MoveHandler(__eventType);
1329                 ChangeColorFromCurrentHandlerPosition(__eventType);
1330                 break;
1331         default:
1332                 SysLogException(NID_UI_CTRL, E_INVALID_ARG, "[E_INVALID_ARG] Invalid argument(s) is used. Handler event type is invalid.");
1333                 r = E_INVALID_ARG;
1334                 break;
1335         }
1336
1337         return r;
1338 }
1339
1340 result
1341 _ColorPickerPresenter::SetHandlerPosition(_ColorPickerComponentType handlerType, float position)
1342 {
1343         result r = E_SUCCESS;
1344
1345         switch (handlerType)
1346         {
1347         case HUE_HANDLER:
1348                 // fall through
1349         case SAT_HANDLER:
1350                 // fall through
1351         case LUM_HANDLER:
1352         {
1353                 FloatRectangle& barBounds = GetBarBoundsFromHandler(handlerType);
1354                 if (position < barBounds.x)
1355                 {
1356                         position = barBounds.x;
1357                 }
1358                 else if (position > (barBounds.x + barBounds.width - __componentBounds[handlerType].width))
1359                 {
1360                         position = barBounds.x + barBounds.width - __componentBounds[handlerType].width;
1361                 }
1362
1363                 __componentBounds[handlerType].x = position;
1364         }
1365         break;
1366         default:
1367                 SysLogException(NID_UI_CTRL, E_INVALID_ARG, "[E_INVALID_ARG] Invalid argument(s) is used. Handler event type is invalid.");
1368                 r = E_SYSTEM;
1369                 break;
1370         }
1371
1372         return r;
1373 }
1374
1375 result
1376 _ColorPickerPresenter::SetHandlerPositionByRatio(_ColorPickerComponentType handlerType, double ratio)
1377 {
1378         result r = E_SUCCESS;
1379         FloatRectangle& barBounds = GetBarBoundsFromHandler(handlerType);
1380         switch (handlerType)
1381         {
1382         case HUE_HANDLER:
1383                 __componentBounds[handlerType].x = barBounds.x + (barBounds.width - __componentBounds[handlerType].width) * ratio;
1384                 break;
1385
1386         case SAT_HANDLER:
1387                 __componentBounds[handlerType].x = barBounds.x + (barBounds.width - __componentBounds[handlerType].width) * (MAX_VALUE - ratio);
1388                 break;
1389
1390         case LUM_HANDLER:
1391                 __componentBounds[handlerType].x = barBounds.x + (barBounds.width - __componentBounds[handlerType].width) * ratio;
1392                 break;
1393
1394         default:
1395                 SysLogException(NID_UI_CTRL, E_INVALID_ARG, "[E_INVALID_ARG] Invalid argument(s) is used. Handler event type is invalid.");
1396                 r = E_SYSTEM;
1397                 break;
1398         }
1399
1400         return r;
1401 }
1402
1403 result
1404 _ColorPickerPresenter::ChangeColorFromCurrentHandlerPosition(_ColorPickerComponentType handlerType)
1405 {
1406         result r = E_SUCCESS;
1407         _AccessibilityElement* pElement = null;
1408         String value;
1409
1410         switch (handlerType)
1411         {
1412         case HUE_HANDLER:
1413                 __pColorPickerModel->SetHue((double)(__componentBounds[HUE_HANDLER].x - __componentBounds[HUE_BAR].x)
1414                                                                         / (double)(__componentBounds[HUE_BAR].width - __componentBounds[HUE_HANDLER].width));
1415
1416                 pElement = __pColorPicker->GetAccessibilityElement(HUE_BAR);
1417                 value.Append(GetHue());
1418                 break;
1419         case SAT_HANDLER:
1420                 __pColorPickerModel->SetSaturation(MAX_VALUE - ((double)(__componentBounds[SAT_HANDLER].x - __componentBounds[SAT_BAR].x)
1421                                                                                    / (double)(__componentBounds[SAT_BAR].width - __componentBounds[SAT_HANDLER].width)));
1422
1423                 pElement = __pColorPicker->GetAccessibilityElement(SAT_BAR);
1424                 value.Append(GetSaturation());
1425                 break;
1426         case LUM_HANDLER:
1427                 __pColorPickerModel->SetLuminance((double)(__componentBounds[LUM_HANDLER].x - __componentBounds[LUM_BAR].x)
1428                                                                                   / (double)(__componentBounds[LUM_BAR].width - __componentBounds[LUM_HANDLER].width));
1429
1430                 pElement = __pColorPicker->GetAccessibilityElement(LUM_BAR);
1431                 value.Append(GetLuminance());
1432                 break;
1433         default:
1434                 r = E_SYSTEM;
1435                 break;
1436         }
1437
1438         if (pElement != null)
1439         {
1440                 pElement->SetValue(value);
1441         }
1442
1443         SysTryReturnResult(NID_UI_CTRL, r == E_SUCCESS, r, "Handler event type is invalid.");
1444
1445         bool isHueChanged = __hueColor != __pColorPickerModel->GetHueColor();
1446         bool isSaturationChanged = __saturationColor != __pColorPickerModel->GetSaturationColor();
1447         if (isHueChanged == true || isSaturationChanged == true)
1448         {
1449                 Canvas* pCanvas = __pColorPicker->GetCanvasN();
1450                 if (pCanvas != null)
1451                 {
1452                         if (isHueChanged == true)
1453                         {
1454                                 DrawSaturationSlider(*pCanvas);
1455                         }
1456                         if (isSaturationChanged == true)
1457                         {
1458                                 DrawLuminanceSlider(*pCanvas);
1459                         }
1460                         delete pCanvas;
1461
1462                         __pColorPicker->UpdateView();
1463                 }
1464         }
1465
1466         return __pColorPicker->FireColorChangeEvent(__pColorPickerModel->GetColor());
1467 }
1468
1469 bool
1470 _ColorPickerPresenter::IsLeftButton(_ColorPickerComponentType buttonType)
1471 {
1472         return (buttonType == HUE_ARROWLEFT || buttonType == SAT_ARROWLEFT || buttonType == LUM_ARROWLEFT);
1473 }
1474
1475 FloatRectangle&
1476 _ColorPickerPresenter::GetBarBoundsFromHandler(_ColorPickerComponentType handlerType)
1477 {
1478         if (handlerType == HUE_HANDLER)
1479         {
1480                 return __componentBounds[HUE_BAR];
1481         }
1482         else if (handlerType == SAT_HANDLER)
1483         {
1484                 return __componentBounds[SAT_BAR];
1485         }
1486         else if (handlerType == LUM_HANDLER)
1487         {
1488                 return __componentBounds[LUM_BAR];
1489         }
1490
1491         return __componentBounds[HSL_NOT];
1492 }
1493
1494 _ColorPickerComponentType
1495 _ColorPickerPresenter::GetTouchActionType(const FloatPoint& position) const
1496 {
1497         if (__componentBounds[HUE_BAR].Contains(position) == true)
1498         {
1499                 return HUE_HANDLER;
1500         }
1501         else if (__componentBounds[SAT_BAR].Contains(position) == true)
1502         {
1503                 return SAT_HANDLER;
1504         }
1505         else if (__componentBounds[LUM_BAR].Contains(position) == true)
1506         {
1507                 return LUM_HANDLER;
1508         }
1509
1510         for (int type = HUE_ARROWLEFT; type < COMPONENT_TYPE_MAX; type++)
1511         {
1512                 if (__componentBounds[type].Contains(position) == true)
1513                 {
1514                         return (_ColorPickerComponentType)type;
1515                 }
1516         }
1517
1518         return HSL_NOT;
1519 }
1520
1521 result
1522 _ColorPickerPresenter::DrawResourceBitmap(Canvas& canvas, const FloatRectangle& bounds, Bitmap* pBitmap)
1523 {
1524         result r = E_SUCCESS;
1525
1526         SysTryReturn(NID_UI_CTRL, pBitmap != null, E_INVALID_ARG, E_INVALID_ARG,
1527                         "[E_INVALID_ARG] Invalid argument is used. Provided bitmap is null.");
1528
1529         if (_BitmapImpl::CheckNinePatchedBitmapStrictly(*pBitmap))
1530         {
1531                 r = canvas.DrawNinePatchedBitmap(CoordinateSystem::AlignToDevice(bounds), *pBitmap);
1532                 SysTryReturn(NID_UI_CTRL, (r == E_SUCCESS), r, r, "[%s] Propagating.", GetErrorMessage(r));
1533         }
1534         else
1535         {
1536                 r = canvas.DrawBitmap(CoordinateSystem::AlignToDevice(bounds), *pBitmap);
1537                 SysTryReturn(NID_UI_CTRL, (r == E_SUCCESS), r, r, "[%s] Propagating.", GetErrorMessage(r));
1538         }
1539         return r;
1540 }
1541 }}} // Tizen::Ui::Controls