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