src/ui/controls/FUiCtrl_CheckButtonPresenter.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  * @file                FUiCtrl_CheckButtonPresenter.cpp
  19  * @brief               This is the implementation file for the _CheckButtonPresenter class.
  20  */
  21
  22 #include <FBaseErrorDefine.h>
  23 #include <FBaseSysLog.h>
  24 #include <FGrp_BitmapImpl.h>
  25 #include <FGrp_CanvasImpl.h>
  26 #include <FGrp_FontImpl.h>
  27 #include <FGrp_TextTextObject.h>
  28 #include <FGrp_TextTextSimple.h>
  29 #include "FUi_CoordinateSystemUtils.h"
  30 #include "FUi_ResourceManager.h"
  31 #include "FUi_UiTouchEvent.h"
  32 #include "FUiAnim_VisualElement.h"
  33 #include "FUiCtrl_CheckButtonPresenter.h"
  34 #include "FUiCtrl_CheckButtonModel.h"
  35
  36 using namespace Tizen::Base;
  37 using namespace Tizen::Graphics;
  38 using namespace Tizen::Graphics::_Text;
  39 using namespace Tizen::Base::Runtime;
  40
  41 namespace Tizen { namespace Ui { namespace Controls
  42 {
  43
  44 _CheckButtonPresenter::_CheckButtonPresenter(void)
  45         : __pCheckButton(null)
  46         , __pCheckButtonModel(null)
  47         , __previousEnabledState(false)
  48         , __touchMoveHandled(false)
  49         , __pTextFont(null)
  50         , __pTitleTextFont(null)
  51         , __pTextObject(null)
  52         , __pTitleTextObject(null)
  53         , __titleTextBounds(FloatRectangle())
  54         , __textBounds(FloatRectangle())
  55         , __defaultButtonBounds(FloatRectangle())
  56         , __onOffSlidingButtonBounds(FloatRectangle())
  57         , __detailedButtonBounds(FloatRectangle())
  58         , __fontStyle(0)
  59         , __fontSize(0.0f)
  60         , __pCheckAnimationTimer(null)
  61         , __ratio(10)
  62         , __onOffHandlerPosition(0.0f)
  63         , __onOffHandlerPressed(false)
  64         , __onOffHandlerMoved(false)
  65         , __highlightedIndex(0)
  66         , __detailedPressed(false)
  67 {
  68
  69 }
  70
  71 _CheckButtonPresenter::~_CheckButtonPresenter(void)
  72 {
  73         if (__pCheckButtonModel)
  74         {
  75                 delete __pCheckButtonModel;
  76                 __pCheckButtonModel = null;
  77         }
  78
  79         if (__pTextObject)
  80         {
  81                 delete __pTextObject;
  82                 __pTextObject = null;
  83         }
  84
  85         if (__pTitleTextObject)
  86         {
  87                 delete __pTitleTextObject;
  88                 __pTitleTextObject = null;
  89         }
  90
  91         if (__pCheckAnimationTimer)
  92         {
  93                 delete __pCheckAnimationTimer;
  94                 __pCheckAnimationTimer = null;
  95         }
  96 }
  97
  98 result
  99 _CheckButtonPresenter::Construct(const _CheckButton& checkButton)
 100 {
 101         result r = E_SUCCESS;
 102
 103         __pCheckButton = const_cast <_CheckButton*>(&checkButton);
 104
 105         __fontStyle = FONT_STYLE_PLAIN;
 106
 107         __pTextObject = new (std::nothrow) TextObject();
 108         SysTryCatch(NID_UI_CTRL, __pTextObject != null, r = E_OUT_OF_MEMORY, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] Memory is insufficient.");
 109
 110         __pTitleTextObject = new (std::nothrow) TextObject();
 111         SysTryCatch(NID_UI_CTRL, __pTitleTextObject != null, r = E_OUT_OF_MEMORY, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] Memory is insufficient.");
 112
 113         __pTextObject->Construct();
 114         __pTextObject->SetWrap(TEXT_OBJECT_WRAP_TYPE_WORD);
 115         __pTextObject->SetAction(TEXT_OBJECT_ACTION_TYPE_ABBREV);
 116
 117         __pTitleTextObject->Construct();
 118         __pTitleTextObject->SetWrap(TEXT_OBJECT_WRAP_TYPE_WORD);
 119         __pTitleTextObject->SetAction(TEXT_OBJECT_ACTION_TYPE_ABBREV);
 120
 121         CalculateTextBounds();
 122         CalculateTitleTextBounds();
 123         CalculateButtonBounds();
 124
 125         return E_SUCCESS;
 126
 127 CATCH:
 128
 129         delete __pTextObject;
 130         __pTextObject = null;
 131
 132         delete __pTitleTextObject;
 133         __pTitleTextObject = null;
 134
 135         return r;
 136 }
 137
 138 result
 139 _CheckButtonPresenter::Install(void)
 140 {
 141         result r = E_SUCCESS;
 142
 143         _CheckButtonModel* pModel = new (std::nothrow) _CheckButtonModel();
 144         SysTryReturn(NID_UI_CTRL, pModel, E_OUT_OF_MEMORY, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] Memory is insufficient.");
 145
 146         r = SetModel(*pModel);
 147         SysTryCatch(NID_UI_CTRL, r == E_SUCCESS, r = E_SYSTEM, E_SYSTEM, "[E_SYSTEM] A system error occurred.");
 148
 149         r = pModel->Construct();
 150         SysTryCatch(NID_UI_CTRL, r == E_SUCCESS, r = E_SYSTEM, E_SYSTEM, "[E_SYSTEM] A system error occurred.");
 151
 152         return E_SUCCESS;
 153
 154 CATCH:
 155         delete pModel;
 156         return r;
 157 }
 158
 159 result
 160 _CheckButtonPresenter::SetModel(const _CheckButtonModel& checkButtonModel)
 161 {
 162         __pCheckButtonModel = const_cast <_CheckButtonModel*>(&checkButtonModel);
 163
 164         return E_SUCCESS;
 165 }
 166
 167 void
 168 _CheckButtonPresenter::OnFontChanged(Font* pFont)
 169 {
 170         __pTextFont = pFont;
 171         __pTitleTextFont = pFont;
 172
 173         return;
 174 }
 175
 176 void
 177 _CheckButtonPresenter::OnFontInfoRequested(unsigned long& style, int& size)
 178 {
 179         style = __fontStyle;
 180         size = _CoordinateSystemUtils::ConvertToInteger(__fontSize);
 181
 182         return;
 183 }
 184
 185 void
 186 _CheckButtonPresenter::OnFontInfoRequested(unsigned long& style, float& size)
 187 {
 188         style = __fontStyle;
 189         size =  __fontSize;
 190
 191         return;
 192 }
 193
 194 void
 195 _CheckButtonPresenter::SetFontInfo(unsigned long style, float size)
 196 {
 197         __fontStyle = style;
 198         __fontSize = size;
 199
 200         return;
 201 }
 202
 203 void
 204 _CheckButtonPresenter::Draw(void)
 205 {
 206         DrawBackground();
 207         DrawCheckBitmap();
 208         DrawText();
 209
 210         return;
 211 }
 212
 213 void
 214 _CheckButtonPresenter::DrawBackground(void)
 215 {
 216         Canvas* pCanvas = __pCheckButton->GetCanvasN();
 217         if (pCanvas == null)
 218         {
 219                 SysLog(NID_UI_CTRL, "Cannot get a canvas.");
 220
 221                 return;
 222         }
 223
 224         Bitmap* pBgBitmap = null;
 225         Bitmap* pReColorBgBitmap = null;
 226
 227         Bitmap* pHighlightedBgBitmap = null;
 228         Bitmap* pHighlightedReColorBgBitmap = null;
 229
 230         FloatDimension minDimension(0.0f, 0.0f);
 231         FloatDimension minDimensionWithAnnex(0.0f, 0.0f);
 232
 233         GET_DIMENSION_CONFIG(CHECKBUTTON::MIN_DIMENSION, __pCheckButton->GetOrientation(), minDimension);
 234         GET_DIMENSION_CONFIG(CHECKBUTTON::MIN_DIMENSION_WITH_ANNEX, __pCheckButton->GetOrientation(), minDimensionWithAnnex);
 235
 236         FloatRectangle bounds(0.0f, 0.0f, __pCheckButton->GetBoundsF().width, __pCheckButton->GetBoundsF().height);
 237
 238         _CheckButtonStatus checkStatus = __pCheckButton->GetCheckButtonStatus();
 239         BackgroundStyle backgroundStyle = __pCheckButton->GetBackgroundStyle();
 240         CheckButtonStyle checkStyle = __pCheckButton->GetCheckButtonStyle();
 241
 242         if (checkStyle == CHECK_BUTTON_STYLE_MARK || checkStyle == CHECK_BUTTON_STYLE_MARK_WITH_DIVIDER || checkStyle == CHECK_BUTTON_STYLE_ONOFF
 243                         || checkStyle == CHECK_BUTTON_STYLE_ONOFF_WITH_DIVIDER || checkStyle == CHECK_BUTTON_STYLE_RADIO || checkStyle == CHECK_BUTTON_STYLE_RADIO_WITH_DIVIDER)
 244         {
 245                 if (bounds.width < minDimension.width )
 246                 {
 247                         bounds.width = minDimension.width;
 248                 }
 249
 250                 if (bounds.height < minDimension.height )
 251                 {
 252                         bounds.height = minDimension.height;
 253                 }
 254         }
 255         else
 256         {
 257                 if (bounds.width < minDimensionWithAnnex.width )
 258                 {
 259                         bounds.width = minDimensionWithAnnex.width;
 260                 }
 261
 262                 if (bounds.height < minDimensionWithAnnex.height )
 263                 {
 264                         bounds.height = minDimensionWithAnnex.height;
 265                 }
 266         }
 267
 268         pCanvas->SetBackgroundColor(Color(0, 0, 0, 0));
 269         pCanvas->Clear();
 270
 271         if (checkStatus == _CHECK_BUTTON_STATUS_NORMAL)
 272         {
 273                 if (backgroundStyle == BACKGROUND_STYLE_NONE)
 274                 {
 275                         pCanvas->SetBackgroundColor(Color(0, 0, 0, 0));
 276                         pCanvas->Clear();
 277                 }
 278                 else
 279                 {
 280                         pBgBitmap = __pCheckButton->GetBackgroundBitmap(__pCheckButton->GetGroupStyle(), _CHECK_BUTTON_STATUS_NORMAL);
 281
 282                         if (pBgBitmap && _BitmapImpl::CheckNinePatchedBitmapStrictly(*pBgBitmap))
 283                         {
 284                                 pReColorBgBitmap = _BitmapImpl::GetColorReplacedBitmapN(*pBgBitmap, Color::GetColor(COLOR_ID_MAGENTA),
 285                                                 __pCheckButton->GetColor(_CHECK_BUTTON_STATUS_NORMAL));
 286                                 if (pReColorBgBitmap)
 287                                 {
 288                                         pCanvas->DrawNinePatchedBitmap(bounds, *pReColorBgBitmap);
 289                                 }
 290
 291                                 bool themeBgBitmap = false;
 292
 293                                 if (__pCheckButton->GetGroupStyle() == GROUP_STYLE_SINGLE)
 294                                 {
 295                                         themeBgBitmap = IS_CUSTOM_BITMAP(PANEL::GROUPED_SINGLE_BG_NORMAL);
 296                                 }
 297                                 else if (__pCheckButton->GetGroupStyle() == GROUP_STYLE_TOP)
 298                                 {
 299                                         themeBgBitmap = IS_CUSTOM_BITMAP(PANEL::GROUPED_TOP_BG_NORMAL);
 300                                 }
 301                                 else if (__pCheckButton->GetGroupStyle() == GROUP_STYLE_MIDDLE)
 302                                 {
 303                                         themeBgBitmap = IS_CUSTOM_BITMAP(PANEL::GROUPED_MIDDLE_BG_NORMAL);
 304                                 }
 305                                 else if (__pCheckButton->GetGroupStyle() == GROUP_STYLE_BOTTOM)
 306                                 {
 307                                         themeBgBitmap = IS_CUSTOM_BITMAP(PANEL::GROUPED_BOTTOM_BG_NORMAL);
 308                                 }
 309
 310                                 if (themeBgBitmap == false)
 311                                 {
 312                                         Bitmap* pBgNormalEffectBitmap = __pCheckButton->GetBackgroundNormalEffectBitmap(__pCheckButton->GetGroupStyle());
 313
 314                                         if (pBgNormalEffectBitmap)
 315                                         {
 316                                                 pCanvas->DrawNinePatchedBitmap(bounds, *pBgNormalEffectBitmap);
 317                                         }
 318                                 }
 319                         }
 320                         else
 321                         {
 322                                 if (pBgBitmap)
 323                                 {
 324                                         pCanvas->DrawBitmap(FloatRectangle(0.0f, 0.0f, bounds.width, bounds.height), *pBgBitmap);
 325                                 }
 326                         }
 327                 }
 328         }
 329         else if (checkStatus == _CHECK_BUTTON_STATUS_DISABLED)
 330         {
 331                 if (backgroundStyle == BACKGROUND_STYLE_NONE)
 332                 {
 333                         pCanvas->SetBackgroundColor(Color(0, 0, 0, 0));
 334                         pCanvas->Clear();
 335                 }
 336                 else
 337                 {
 338                         pBgBitmap = __pCheckButton->GetBackgroundBitmap(__pCheckButton->GetGroupStyle(), _CHECK_BUTTON_STATUS_DISABLED);
 339
 340                         if (pBgBitmap && _BitmapImpl::CheckNinePatchedBitmapStrictly(*pBgBitmap))
 341                         {
 342                                 pReColorBgBitmap = _BitmapImpl::GetColorReplacedBitmapN(*pBgBitmap, Color::GetColor(COLOR_ID_MAGENTA),
 343                                                 __pCheckButton->GetColor(_CHECK_BUTTON_STATUS_DISABLED));
 344                                 if (pReColorBgBitmap)
 345                                 {
 346                                         pCanvas->DrawNinePatchedBitmap(bounds, *pReColorBgBitmap);
 347                                 }
 348
 349                                 bool themeBgBitmap = false;
 350
 351                                 if (__pCheckButton->GetGroupStyle() == GROUP_STYLE_SINGLE)
 352                                 {
 353                                         themeBgBitmap = IS_CUSTOM_BITMAP(PANEL::GROUPED_SINGLE_BG_DISABLED);
 354                                 }
 355                                 else if (__pCheckButton->GetGroupStyle() == GROUP_STYLE_TOP)
 356                                 {
 357                                         themeBgBitmap = IS_CUSTOM_BITMAP(PANEL::GROUPED_TOP_BG_DISABLED);
 358                                 }
 359                                 else if (__pCheckButton->GetGroupStyle() == GROUP_STYLE_MIDDLE)
 360                                 {
 361                                         themeBgBitmap = IS_CUSTOM_BITMAP(PANEL::GROUPED_MIDDLE_BG_DISABLED);
 362                                 }
 363                                 else if (__pCheckButton->GetGroupStyle() == GROUP_STYLE_BOTTOM)
 364                                 {
 365                                         themeBgBitmap = IS_CUSTOM_BITMAP(PANEL::GROUPED_BOTTOM_BG_DISABLED);
 366                                 }
 367
 368                                 if (themeBgBitmap == false)
 369                                 {
 370                                         Bitmap* pBgNormalEffectBitmap = __pCheckButton->GetBackgroundNormalEffectBitmap(__pCheckButton->GetGroupStyle());
 371
 372                                         if (pBgNormalEffectBitmap)
 373                                         {
 374                                                 pCanvas->DrawNinePatchedBitmap(bounds, *pBgNormalEffectBitmap);
 375                                         }
 376                                 }
 377                         }
 378                         else
 379                         {
 380                                 if (pBgBitmap)
 381                                 {
 382                                         pCanvas->DrawBitmap(FloatRectangle(0.0f, 0.0f, bounds.width, bounds.height), *pBgBitmap);
 383                                 }
 384                         }
 385                 }
 386         }
 387         else if (checkStatus == _CHECK_BUTTON_STATUS_PRESSED)
 388         {
 389                 if (backgroundStyle == BACKGROUND_STYLE_NONE)
 390                 {
 391                         pCanvas->SetBackgroundColor(__pCheckButton->GetColor(_CHECK_BUTTON_STATUS_PRESSED));
 392                         pCanvas->Clear();
 393                 }
 394                 else
 395                 {
 396                         pBgBitmap = __pCheckButton->GetBackgroundBitmap(__pCheckButton->GetGroupStyle(), _CHECK_BUTTON_STATUS_PRESSED);
 397
 398                         if (pBgBitmap && _BitmapImpl::CheckNinePatchedBitmapStrictly(*pBgBitmap))
 399                         {
 400                                 pReColorBgBitmap = _BitmapImpl::GetColorReplacedBitmapN(*pBgBitmap, Color::GetColor(COLOR_ID_MAGENTA),
 401                                                 __pCheckButton->GetColor(_CHECK_BUTTON_STATUS_PRESSED));
 402                                 if (pReColorBgBitmap)
 403                                 {
 404                                         pCanvas->DrawNinePatchedBitmap(bounds, *pReColorBgBitmap);
 405                                 }
 406
 407                                 bool themeBgBitmap = false;
 408
 409                                 if (__pCheckButton->GetGroupStyle() == GROUP_STYLE_SINGLE)
 410                                 {
 411                                         themeBgBitmap = IS_CUSTOM_BITMAP(PANEL::GROUPED_SINGLE_BG_PRESSED);
 412                                 }
 413                                 else if (__pCheckButton->GetGroupStyle() == GROUP_STYLE_TOP)
 414                                 {
 415                                         themeBgBitmap = IS_CUSTOM_BITMAP(PANEL::GROUPED_TOP_BG_PRESSED);
 416                                 }
 417                                 else if (__pCheckButton->GetGroupStyle() == GROUP_STYLE_MIDDLE)
 418                                 {
 419                                         themeBgBitmap = IS_CUSTOM_BITMAP(PANEL::GROUPED_MIDDLE_BG_PRESSED);
 420                                 }
 421                                 else if (__pCheckButton->GetGroupStyle() == GROUP_STYLE_BOTTOM)
 422                                 {
 423                                         themeBgBitmap = IS_CUSTOM_BITMAP(PANEL::GROUPED_BOTTOM_BG_PRESSED);
 424                                 }
 425
 426                                 if (themeBgBitmap == false)
 427                                 {
 428                                         Bitmap* pBgPressedEffectBitmap = __pCheckButton->GetBackgroundPressedEffectBitmap(__pCheckButton->GetGroupStyle());
 429
 430                                         if (pBgPressedEffectBitmap)
 431                                         {
 432                                                 pCanvas->DrawNinePatchedBitmap(bounds, *pBgPressedEffectBitmap);
 433                                         }
 434                                 }
 435                         }
 436                         else
 437                         {
 438                                 if (pBgBitmap)
 439                                 {
 440                                         pCanvas->DrawBitmap(FloatRectangle(0.0f, 0.0f, bounds.width, bounds.height), *pBgBitmap);
 441                                 }
 442                         }
 443                 }
 444         }
 445         else if (checkStatus == _CHECK_BUTTON_STATUS_HIGHLIGHTED)
 446         {
 447                 if (backgroundStyle == BACKGROUND_STYLE_NONE)
 448                 {
 449                         pCanvas->SetBackgroundColor(Color(0, 0, 0, 0));
 450                         pCanvas->Clear();
 451                 }
 452                 else
 453                 {
 454                         pBgBitmap = __pCheckButton->GetBackgroundBitmap(__pCheckButton->GetGroupStyle(), _CHECK_BUTTON_STATUS_NORMAL);
 455
 456                         if (pBgBitmap && _BitmapImpl::CheckNinePatchedBitmapStrictly(*pBgBitmap))
 457                         {
 458                                 pReColorBgBitmap = _BitmapImpl::GetColorReplacedBitmapN(*pBgBitmap, Color::GetColor(COLOR_ID_MAGENTA),
 459                                                 __pCheckButton->GetColor(_CHECK_BUTTON_STATUS_NORMAL));
 460                                 if (pReColorBgBitmap)
 461                                 {
 462                                         pCanvas->DrawNinePatchedBitmap(bounds, *pReColorBgBitmap);
 463                                 }
 464
 465                                 bool themeBgBitmap = false;
 466
 467                                 if (__pCheckButton->GetGroupStyle() == GROUP_STYLE_SINGLE)
 468                                 {
 469                                         themeBgBitmap = IS_CUSTOM_BITMAP(PANEL::GROUPED_SINGLE_BG_HIGHLIGHTED);
 470                                 }
 471                                 else if (__pCheckButton->GetGroupStyle() == GROUP_STYLE_TOP)
 472                                 {
 473                                         themeBgBitmap = IS_CUSTOM_BITMAP(PANEL::GROUPED_TOP_BG_HIGHLIGHTED);
 474                                 }
 475                                 else if (__pCheckButton->GetGroupStyle() == GROUP_STYLE_MIDDLE)
 476                                 {
 477                                         themeBgBitmap = IS_CUSTOM_BITMAP(PANEL::GROUPED_MIDDLE_BG_HIGHLIGHTED);
 478                                 }
 479                                 else if (__pCheckButton->GetGroupStyle() == GROUP_STYLE_BOTTOM)
 480                                 {
 481                                         themeBgBitmap = IS_CUSTOM_BITMAP(PANEL::GROUPED_BOTTOM_BG_HIGHLIGHTED);
 482                                 }
 483
 484                                 if (themeBgBitmap == false)
 485                                 {
 486                                         Bitmap* pBgPressedEffectBitmap = __pCheckButton->GetBackgroundPressedEffectBitmap(__pCheckButton->GetGroupStyle());
 487
 488                                         if (pBgPressedEffectBitmap)
 489                                         {
 490                                                 pCanvas->DrawNinePatchedBitmap(bounds, *pBgPressedEffectBitmap);
 491                                         }
 492                                 }
 493                         }
 494                         else
 495                         {
 496                                 if (pBgBitmap)
 497                                 {
 498                                         pCanvas->DrawBitmap(FloatRectangle(0.0f, 0.0f, bounds.width, bounds.height), *pBgBitmap);
 499                                 }
 500                         }
 501
 502                         pHighlightedBgBitmap = __pCheckButton->GetBackgroundBitmap(__pCheckButton->GetGroupStyle(), _CHECK_BUTTON_STATUS_HIGHLIGHTED);
 503
 504                         pHighlightedReColorBgBitmap = _BitmapImpl::GetColorReplacedBitmapN(*pHighlightedBgBitmap,
 505                                         Color::GetColor(COLOR_ID_MAGENTA), __pCheckButton->GetColor(_CHECK_BUTTON_STATUS_HIGHLIGHTED));
 506
 507                         if (pHighlightedReColorBgBitmap && __highlightedIndex == 0)
 508                         {
 509                                 if (_BitmapImpl::CheckNinePatchedBitmapStrictly(*pHighlightedReColorBgBitmap))
 510                                 {
 511                                         pCanvas->DrawNinePatchedBitmap(bounds, *pHighlightedReColorBgBitmap);
 512                                 }
 513                                 else
 514                                 {
 515                                         pCanvas->DrawBitmap(bounds, *pHighlightedReColorBgBitmap,
 516                                                         FloatRectangle(0.0f, 0.0f, pHighlightedReColorBgBitmap->GetWidthF(), pHighlightedReColorBgBitmap->GetHeightF()));
 517                                 }
 518                         }
 519                 }
 520         }
 521         else
 522         {
 523                 if (backgroundStyle == BACKGROUND_STYLE_NONE)
 524                 {
 525                         pCanvas->SetBackgroundColor(Color(0, 0, 0, 0));
 526                         pCanvas->Clear();
 527                 }
 528                 else
 529                 {
 530                         pBgBitmap = __pCheckButton->GetBackgroundBitmap(__pCheckButton->GetGroupStyle(), __pCheckButton->GetCheckButtonStatus());
 531
 532                         if (pBgBitmap && _BitmapImpl::CheckNinePatchedBitmapStrictly(*pBgBitmap))
 533                         {
 534                                 pReColorBgBitmap = _BitmapImpl::GetColorReplacedBitmapN(*pBgBitmap, Color::GetColor(COLOR_ID_MAGENTA),
 535                                                 __pCheckButton->GetColor(_CHECK_BUTTON_STATUS_SELECTED));
 536                                 if (pReColorBgBitmap)
 537                                 {
 538                                         pCanvas->DrawNinePatchedBitmap(bounds, *pReColorBgBitmap);
 539                                 }
 540
 541                                 bool themeBgBitmap = false;
 542
 543                                 if (__pCheckButton->GetGroupStyle() == GROUP_STYLE_SINGLE)
 544                                 {
 545                                         themeBgBitmap = IS_CUSTOM_BITMAP(PANEL::GROUPED_SINGLE_BG_SELECTED);
 546                                 }
 547                                 else if (__pCheckButton->GetGroupStyle() == GROUP_STYLE_TOP)
 548                                 {
 549                                         themeBgBitmap = IS_CUSTOM_BITMAP(PANEL::GROUPED_TOP_BG_SELECTED);
 550                                 }
 551                                 else if (__pCheckButton->GetGroupStyle() == GROUP_STYLE_MIDDLE)
 552                                 {
 553                                         themeBgBitmap = IS_CUSTOM_BITMAP(PANEL::GROUPED_MIDDLE_BG_SELECTED);
 554                                 }
 555                                 else if (__pCheckButton->GetGroupStyle() == GROUP_STYLE_BOTTOM)
 556                                 {
 557                                         themeBgBitmap = IS_CUSTOM_BITMAP(PANEL::GROUPED_BOTTOM_BG_SELECTED);
 558                                 }
 559
 560                                 if (themeBgBitmap == false)
 561                                 {
 562                                         Bitmap* pBgNormalEffectBitmap = __pCheckButton->GetBackgroundNormalEffectBitmap(__pCheckButton->GetGroupStyle());
 563
 564                                         if (pBgNormalEffectBitmap)
 565                                         {
 566                                                 pCanvas->DrawNinePatchedBitmap(bounds, *pBgNormalEffectBitmap);
 567                                         }
 568                                 }
 569                         }
 570                         else
 571                         {
 572                                 if (pBgBitmap)
 573                                 {
 574                                         pCanvas->DrawBitmap(FloatRectangle(0.0f, 0.0f, bounds.width, bounds.height), *pBgBitmap);
 575                                 }
 576                         }
 577                 }
 578         }
 579
 580         delete pCanvas;
 581         delete pReColorBgBitmap;
 582         delete pHighlightedReColorBgBitmap;
 583
 584         return;
 585 }
 586
 587 void
 588 _CheckButtonPresenter::DrawCheckBitmap(void)
 589 {
 590         Canvas* pCanvas = __pCheckButton->GetCanvasN();
 591         if (pCanvas == null)
 592         {
 593                 SysLog(NID_UI_CTRL, "Cannot get a canvas.");
 594
 595                 return;
 596         }
 597
 598         Color detailedNormalBgColor;
 599         Color detailedDisabledBgColor;
 600         Color detailedPressedBgColor;
 601         Color detailedHighlightedBgColor;
 602         Color detailedSelectedBgColor;
 603
 604         Color detailedRightNormalColor;
 605         Color detailedRightDisabledColor;
 606         Color detailedRightPressedColor;
 607         Color detailedRightHighlightedColor;
 608         Color detailedRightSelectedColor;
 609
 610         GET_COLOR_CONFIG(CHECKBUTTON::DETAILED_ICON_BG_NORMAL, detailedNormalBgColor);
 611         GET_COLOR_CONFIG(CHECKBUTTON::DETAILED_ICON_BG_DISABLED, detailedDisabledBgColor);
 612         GET_COLOR_CONFIG(CHECKBUTTON::DETAILED_ICON_BG_PRESSED, detailedPressedBgColor);
 613         GET_COLOR_CONFIG(CHECKBUTTON::DETAILED_ICON_BG_HIGHLIGHTED, detailedHighlightedBgColor);
 614         GET_COLOR_CONFIG(CHECKBUTTON::DETAILED_ICON_BG_SELECTED, detailedSelectedBgColor);
 615
 616         GET_COLOR_CONFIG(CHECKBUTTON::DETAILED_ICON_TEXT_NORMAL, detailedRightNormalColor);
 617         GET_COLOR_CONFIG(CHECKBUTTON::DETAILED_ICON_TEXT_DISABLED, detailedRightDisabledColor);
 618         GET_COLOR_CONFIG(CHECKBUTTON::DETAILED_ICON_TEXT_PRESSED, detailedRightPressedColor);
 619         GET_COLOR_CONFIG(CHECKBUTTON::DETAILED_ICON_TEXT_HIGHLIGHTED, detailedRightHighlightedColor);
 620         GET_COLOR_CONFIG(CHECKBUTTON::DETAILED_ICON_TEXT_SELECTED, detailedRightSelectedColor);
 621
 622         Bitmap* pReColorCircleBitmap = null;
 623         Bitmap* pReColorRightBitmap = null;
 624
 625         _CheckButtonStatus checkStatus = __pCheckButton->GetCheckButtonStatus();
 626         CheckButtonStyle checkStyle = __pCheckButton->GetCheckButtonStyle();
 627
 628         CalculateButtonBounds();
 629
 630         if (checkStyle == CHECK_BUTTON_STYLE_MARK || checkStyle == CHECK_BUTTON_STYLE_MARK_WITH_DIVIDER || checkStyle == CHECK_BUTTON_STYLE_MARK_WITH_DETAILED_BUTTON)
 631         {
 632                 if (checkStatus == _CHECK_BUTTON_STATUS_NORMAL)
 633                 {
 634                         Bitmap* pMarkBgNormalBitmap = __pCheckButton->GetMarkBgBitmap(_CHECK_BUTTON_STATUS_NORMAL);
 635
 636                         if (pMarkBgNormalBitmap)
 637                         {
 638                                 pCanvas->DrawBitmap(FloatPoint(__defaultButtonBounds.x, __defaultButtonBounds.y), *pMarkBgNormalBitmap);
 639                         }
 640
 641                         if (checkStyle == CHECK_BUTTON_STYLE_MARK_WITH_DETAILED_BUTTON)
 642                         {
 643                                 Bitmap* pCircleNormalBitmap = __pCheckButton->GetCircleBitmap(_CHECK_BUTTON_STATUS_NORMAL);
 644                                 Bitmap* pDetailedRightNormalBitmap = __pCheckButton->GetDetailedRightBitmap(_CHECK_BUTTON_STATUS_NORMAL);
 645
 646                                 if (__detailedPressed == true)
 647                                 {
 648                                         if (pCircleNormalBitmap)
 649                                         {
 650                                                 pReColorCircleBitmap = _BitmapImpl::GetColorReplacedBitmapN(*pCircleNormalBitmap, Color::GetColor(COLOR_ID_MAGENTA), detailedPressedBgColor);
 651                                         }
 652
 653                                         if (pDetailedRightNormalBitmap)
 654                                         {
 655                                                 pReColorRightBitmap = _BitmapImpl::GetColorReplacedBitmapN(*pDetailedRightNormalBitmap, Color::GetColor(COLOR_ID_MAGENTA), detailedRightPressedColor);
 656                                         }
 657                                 }
 658                                 else
 659                                 {
 660                                         if (pCircleNormalBitmap)
 661                                         {
 662                                                 pReColorCircleBitmap = _BitmapImpl::GetColorReplacedBitmapN(*pCircleNormalBitmap, Color::GetColor(COLOR_ID_MAGENTA), detailedNormalBgColor);
 663                                         }
 664
 665                                         if (pDetailedRightNormalBitmap)
 666                                         {
 667                                                 pReColorRightBitmap = _BitmapImpl::GetColorReplacedBitmapN(*pDetailedRightNormalBitmap, Color::GetColor(COLOR_ID_MAGENTA), detailedRightNormalColor);
 668                                         }
 669                                 }
 670
 671                                 if (pReColorCircleBitmap)
 672                                 {
 673                                         pCanvas->DrawBitmap(FloatPoint(__detailedButtonBounds.x, __detailedButtonBounds.y), *pReColorCircleBitmap);
 674                                 }
 675
 676                                 if (pReColorRightBitmap)
 677                                 {
 678                                         float arrowWidth = pReColorRightBitmap->GetWidthF();
 679                                         float arrowHeight = pReColorRightBitmap->GetHeightF();
 680
 681                                         pCanvas->DrawBitmap(FloatPoint(__detailedButtonBounds.x + (__detailedButtonBounds.width - arrowWidth) / 2.0f
 682                                                         , __detailedButtonBounds.y + (__detailedButtonBounds.height - arrowHeight) / 2.0f), *pReColorRightBitmap);
 683                                 }
 684
 685                                 bool themeBgBitmap = IS_CUSTOM_BITMAP(CHECKBUTTON::DETAILED_BG_NORMAL);
 686
 687                                 if (themeBgBitmap == false)
 688                                 {
 689                                         Bitmap* pCircleNormalEffectBitmap = __pCheckButton->GetCircleNormalEffectBitmap();
 690
 691                                         if (pCircleNormalEffectBitmap)
 692                                         {
 693                                                 pCanvas->DrawBitmap(FloatPoint(__detailedButtonBounds.x, __detailedButtonBounds.y), *pCircleNormalEffectBitmap);
 694                                         }
 695                                 }
 696                         }
 697                 }
 698                 else if (checkStatus == _CHECK_BUTTON_STATUS_DISABLED)
 699                 {
 700                         Bitmap* pMarkBgDisabledBitmap = __pCheckButton->GetMarkBgBitmap(_CHECK_BUTTON_STATUS_DISABLED);
 701
 702                         if (pMarkBgDisabledBitmap)
 703                         {
 704                                 pCanvas->DrawBitmap(FloatPoint(__defaultButtonBounds.x, __defaultButtonBounds.y), *pMarkBgDisabledBitmap);
 705                         }
 706
 707                         if (checkStyle == CHECK_BUTTON_STYLE_MARK_WITH_DETAILED_BUTTON)
 708                         {
 709                                 Bitmap* pCircleDisabledBitmap = __pCheckButton->GetCircleBitmap(_CHECK_BUTTON_STATUS_DISABLED);
 710                                 Bitmap* pDetailedRightDisabledBitmap = __pCheckButton->GetDetailedRightBitmap(_CHECK_BUTTON_STATUS_DISABLED);
 711
 712                                 if (pCircleDisabledBitmap)
 713                                 {
 714                                         pReColorCircleBitmap = _BitmapImpl::GetColorReplacedBitmapN(*pCircleDisabledBitmap, Color::GetColor(COLOR_ID_MAGENTA), detailedDisabledBgColor);
 715                                 }
 716
 717                                 if (pDetailedRightDisabledBitmap)
 718                                 {
 719                                         pReColorRightBitmap = _BitmapImpl::GetColorReplacedBitmapN(*pDetailedRightDisabledBitmap, Color::GetColor(COLOR_ID_MAGENTA), detailedRightDisabledColor);
 720                                 }
 721
 722                                 if (pReColorCircleBitmap)
 723                                 {
 724                                         pCanvas->DrawBitmap(FloatPoint(__detailedButtonBounds.x, __detailedButtonBounds.y), *pReColorCircleBitmap);
 725                                 }
 726
 727                                 if (pReColorRightBitmap)
 728                                 {
 729                                         float arrowWidth = pReColorRightBitmap->GetWidthF();
 730                                         float arrowHeight = pReColorRightBitmap->GetHeightF();
 731
 732                                         pCanvas->DrawBitmap(FloatPoint(__detailedButtonBounds.x + (__detailedButtonBounds.width - arrowWidth) / 2.0f
 733                                                         , __detailedButtonBounds.y + (__detailedButtonBounds.height - arrowHeight) / 2.0f), *pReColorRightBitmap);
 734                                 }
 735
 736                                 bool themeBgBitmap = IS_CUSTOM_BITMAP(CHECKBUTTON::DETAILED_BG_DISABLED);
 737
 738                                 if (themeBgBitmap == false)
 739                                 {
 740                                         Bitmap* pCircleNormalEffectBitmap = __pCheckButton->GetCircleNormalEffectBitmap();
 741
 742                                         if (pCircleNormalEffectBitmap)
 743                                         {
 744                                                 pCanvas->DrawBitmap(FloatPoint(__detailedButtonBounds.x, __detailedButtonBounds.y), *pCircleNormalEffectBitmap);
 745                                         }
 746                                 }
 747                         }
 748                 }
 749                 else if (checkStatus == _CHECK_BUTTON_STATUS_PRESSED)
 750                 {
 751                         Bitmap* pMarkBgPressedBitmap = __pCheckButton->GetMarkBgBitmap(_CHECK_BUTTON_STATUS_PRESSED);
 752
 753                         if (pMarkBgPressedBitmap)
 754                         {
 755                                 pCanvas->DrawBitmap(FloatPoint(__defaultButtonBounds.x, __defaultButtonBounds.y), *pMarkBgPressedBitmap);
 756                         }
 757
 758                         if (checkStyle == CHECK_BUTTON_STYLE_MARK_WITH_DETAILED_BUTTON)
 759                         {
 760                                 Bitmap* pCirclePressedBitmap = __pCheckButton->GetCircleBitmap(_CHECK_BUTTON_STATUS_PRESSED);
 761                                 Bitmap* pDetailedRightPressedBitmap = __pCheckButton->GetDetailedRightBitmap(_CHECK_BUTTON_STATUS_PRESSED);
 762
 763                                 if (__detailedPressed == true)
 764                                 {
 765                                         if (pCirclePressedBitmap)
 766                                         {
 767                                                 pReColorCircleBitmap = _BitmapImpl::GetColorReplacedBitmapN(*pCirclePressedBitmap, Color::GetColor(COLOR_ID_MAGENTA), detailedPressedBgColor);
 768                                         }
 769
 770                                         if (pDetailedRightPressedBitmap)
 771                                         {
 772                                                 pReColorRightBitmap = _BitmapImpl::GetColorReplacedBitmapN(*pDetailedRightPressedBitmap, Color::GetColor(COLOR_ID_MAGENTA), detailedRightPressedColor);
 773                                         }
 774                                 }
 775                                 else
 776                                 {
 777                                         if (pCirclePressedBitmap)
 778                                         {
 779                                                 pReColorCircleBitmap = _BitmapImpl::GetColorReplacedBitmapN(*pCirclePressedBitmap, Color::GetColor(COLOR_ID_MAGENTA), detailedNormalBgColor);
 780                                         }
 781
 782                                         if (pDetailedRightPressedBitmap)
 783                                         {
 784                                                 pReColorRightBitmap = _BitmapImpl::GetColorReplacedBitmapN(*pDetailedRightPressedBitmap, Color::GetColor(COLOR_ID_MAGENTA), detailedRightNormalColor);
 785                                         }
 786                                 }
 787
 788                                 if (pReColorCircleBitmap)
 789                                 {
 790                                         pCanvas->DrawBitmap(FloatPoint(__detailedButtonBounds.x, __detailedButtonBounds.y), *pReColorCircleBitmap);
 791                                 }
 792
 793                                 if (pReColorRightBitmap)
 794                                 {
 795                                         float arrowWidth = pReColorRightBitmap->GetWidthF();
 796                                         float arrowHeight = pReColorRightBitmap->GetHeightF();
 797
 798                                         pCanvas->DrawBitmap(FloatPoint(__detailedButtonBounds.x + (__detailedButtonBounds.width - arrowWidth) / 2.0f
 799                                                         , __detailedButtonBounds.y + (__detailedButtonBounds.height - arrowHeight) / 2.0f), *pReColorRightBitmap);
 800                                 }
 801
 802                                 bool themeBgBitmap = IS_CUSTOM_BITMAP(CHECKBUTTON::DETAILED_BG_PRESSED);
 803
 804                                 if (themeBgBitmap == false)
 805                                 {
 806                                         Bitmap* pCirclePressedEffectBitmap = __pCheckButton->GetCirclePressedEffectBitmap();
 807
 808                                         if (pCirclePressedEffectBitmap)
 809                                         {
 810                                                 pCanvas->DrawBitmap(FloatPoint(__detailedButtonBounds.x, __detailedButtonBounds.y), *pCirclePressedEffectBitmap);
 811                                         }
 812                                 }
 813                         }
 814                 }
 815                 else if (checkStatus == _CHECK_BUTTON_STATUS_HIGHLIGHTED)
 816                 {
 817                         Bitmap* pMarkBgNormalBitmap = __pCheckButton->GetMarkBgBitmap(_CHECK_BUTTON_STATUS_NORMAL);
 818                         Bitmap* pMarkBgHighlightedBitmap = __pCheckButton->GetMarkBgBitmap(_CHECK_BUTTON_STATUS_HIGHLIGHTED);
 819
 820                         if (pMarkBgNormalBitmap)
 821                         {
 822                                 pCanvas->DrawBitmap(FloatPoint(__defaultButtonBounds.x, __defaultButtonBounds.y), *pMarkBgNormalBitmap);
 823                         }
 824
 825                         Bitmap* pReColorMarkBgHighlightedBitmap = null;
 826
 827                         if (pMarkBgHighlightedBitmap)
 828                         {
 829                                 pReColorMarkBgHighlightedBitmap = _BitmapImpl::GetColorReplacedBitmapN(*pMarkBgHighlightedBitmap,
 830                                                 Color::GetColor(COLOR_ID_MAGENTA), detailedHighlightedBgColor);
 831                         }
 832
 833                         if (pReColorMarkBgHighlightedBitmap && __highlightedIndex == 1)
 834                         {
 835                                 pCanvas->DrawBitmap(FloatPoint(__defaultButtonBounds.x, __defaultButtonBounds.y), *pReColorMarkBgHighlightedBitmap);
 836                         }
 837
 838                         delete pReColorMarkBgHighlightedBitmap;
 839
 840                         if (checkStyle == CHECK_BUTTON_STYLE_MARK_WITH_DETAILED_BUTTON)
 841                         {
 842                                 Bitmap* pCircleNormalBitmap = __pCheckButton->GetCircleBitmap(_CHECK_BUTTON_STATUS_NORMAL);
 843                                 Bitmap* pCircleHighlightedBitmap = __pCheckButton->GetCircleBitmap(_CHECK_BUTTON_STATUS_HIGHLIGHTED);
 844                                 Bitmap* pDetailedRightHighlightedBitmap = __pCheckButton->GetDetailedRightBitmap(_CHECK_BUTTON_STATUS_HIGHLIGHTED);
 845
 846                                 if (__detailedPressed == true)
 847                                 {
 848                                         if (pCircleNormalBitmap)
 849                                         {
 850                                                 pReColorCircleBitmap = _BitmapImpl::GetColorReplacedBitmapN(*pCircleNormalBitmap, Color::GetColor(COLOR_ID_MAGENTA), detailedPressedBgColor);
 851                                         }
 852
 853                                         if (pDetailedRightHighlightedBitmap)
 854                                         {
 855                                                 pReColorRightBitmap = _BitmapImpl::GetColorReplacedBitmapN(*pDetailedRightHighlightedBitmap, Color::GetColor(COLOR_ID_MAGENTA), detailedRightPressedColor);
 856                                         }
 857                                 }
 858                                 else
 859                                 {
 860                                         if (pCircleNormalBitmap)
 861                                         {
 862                                                 pReColorCircleBitmap = _BitmapImpl::GetColorReplacedBitmapN(*pCircleNormalBitmap, Color::GetColor(COLOR_ID_MAGENTA), detailedNormalBgColor);
 863                                         }
 864
 865                                         if (pDetailedRightHighlightedBitmap)
 866                                         {
 867                                                 pReColorRightBitmap = _BitmapImpl::GetColorReplacedBitmapN(*pDetailedRightHighlightedBitmap, Color::GetColor(COLOR_ID_MAGENTA), detailedRightHighlightedColor);
 868                                         }
 869                                 }
 870
 871                                 if (pReColorCircleBitmap)
 872                                 {
 873                                         pCanvas->DrawBitmap(FloatPoint(__detailedButtonBounds.x, __detailedButtonBounds.y), *pReColorCircleBitmap);
 874                                 }
 875
 876                                 if (pReColorRightBitmap)
 877                                 {
 878                                         float arrowWidth = pReColorRightBitmap->GetWidthF();
 879                                         float arrowHeight = pReColorRightBitmap->GetHeightF();
 880
 881                                         pCanvas->DrawBitmap(FloatPoint(__detailedButtonBounds.x + (__detailedButtonBounds.width - arrowWidth) / 2.0f
 882                                                         , __detailedButtonBounds.y + (__detailedButtonBounds.height - arrowHeight) / 2.0f), *pReColorRightBitmap);
 883                                 }
 884
 885                                 bool themeBgBitmap = IS_CUSTOM_BITMAP(CHECKBUTTON::DETAILED_BG_HIGHLIGHTED);
 886
 887                                 if (themeBgBitmap == false)
 888                                 {
 889                                         Bitmap* pCirclePressedEffectBitmap = __pCheckButton->GetCirclePressedEffectBitmap();
 890
 891                                         if (pCirclePressedEffectBitmap)
 892                                         {
 893                                                 pCanvas->DrawBitmap(FloatPoint(__detailedButtonBounds.x, __detailedButtonBounds.y), *pCirclePressedEffectBitmap);
 894                                         }
 895                                 }
 896
 897                                 Bitmap* pReColorCircleHighlightedBitmap = null;
 898
 899                                 if (pCircleHighlightedBitmap)
 900                                 {
 901                                         pReColorCircleHighlightedBitmap = _BitmapImpl::GetColorReplacedBitmapN(*pCircleHighlightedBitmap, Color::GetColor(COLOR_ID_MAGENTA), detailedHighlightedBgColor);
 902                                 }
 903
 904                                 if (pReColorCircleHighlightedBitmap && __highlightedIndex == 2)
 905                                 {
 906                                         pCanvas->DrawBitmap(FloatPoint(__detailedButtonBounds.x, __detailedButtonBounds.y), *pReColorCircleHighlightedBitmap);
 907                                 }
 908
 909                                 delete pReColorCircleHighlightedBitmap;
 910                         }
 911                 }
 912                 else if (checkStatus == _CHECK_BUTTON_STATUS_SELECTED)
 913                 {
 914                         Bitmap* pMarkBgSelectedBitmap = __pCheckButton->GetMarkBgBitmap(_CHECK_BUTTON_STATUS_SELECTED);
 915
 916                         if (pMarkBgSelectedBitmap)
 917                         {
 918                                 pCanvas->DrawBitmap(FloatPoint(__defaultButtonBounds.x, __defaultButtonBounds.y), *pMarkBgSelectedBitmap);
 919                         }
 920
 921                         if (checkStyle == CHECK_BUTTON_STYLE_MARK_WITH_DETAILED_BUTTON)
 922                         {
 923                                 Bitmap* pCircleSelectedBitmap = __pCheckButton->GetCircleBitmap(_CHECK_BUTTON_STATUS_SELECTED);
 924                                 Bitmap* pDetailedRightSelectedBitmap = __pCheckButton->GetDetailedRightBitmap(_CHECK_BUTTON_STATUS_SELECTED);
 925
 926                                 if (__detailedPressed == true)
 927                                 {
 928                                         if (pCircleSelectedBitmap)
 929                                         {
 930                                                 pReColorCircleBitmap = _BitmapImpl::GetColorReplacedBitmapN(*pCircleSelectedBitmap, Color::GetColor(COLOR_ID_MAGENTA), detailedPressedBgColor);
 931                                         }
 932
 933                                         if (pDetailedRightSelectedBitmap)
 934                                         {
 935                                                 pReColorRightBitmap = _BitmapImpl::GetColorReplacedBitmapN(*pDetailedRightSelectedBitmap, Color::GetColor(COLOR_ID_MAGENTA), detailedRightPressedColor);
 936                                         }
 937                                 }
 938                                 else
 939                                 {
 940                                         if (pCircleSelectedBitmap)
 941                                         {
 942                                                 pReColorCircleBitmap = _BitmapImpl::GetColorReplacedBitmapN(*pCircleSelectedBitmap, Color::GetColor(COLOR_ID_MAGENTA), detailedSelectedBgColor);
 943                                         }
 944
 945                                         if (pDetailedRightSelectedBitmap)
 946                                         {
 947                                                 pReColorRightBitmap = _BitmapImpl::GetColorReplacedBitmapN(*pDetailedRightSelectedBitmap, Color::GetColor(COLOR_ID_MAGENTA), detailedRightSelectedColor);
 948                                         }
 949                                 }
 950
 951                                 if (pReColorCircleBitmap)
 952                                 {
 953                                         pCanvas->DrawBitmap(FloatPoint(__detailedButtonBounds.x, __detailedButtonBounds.y), *pReColorCircleBitmap);
 954                                 }
 955
 956                                 if (pReColorRightBitmap)
 957                                 {
 958                                         float arrowWidth = pReColorRightBitmap->GetWidthF();
 959                                         float arrowHeight = pReColorRightBitmap->GetHeightF();
 960
 961                                         pCanvas->DrawBitmap(FloatPoint(__detailedButtonBounds.x + (__detailedButtonBounds.width - arrowWidth) / 2.0f
 962                                                         , __detailedButtonBounds.y + (__detailedButtonBounds.height - arrowHeight) / 2.0f), *pReColorRightBitmap);
 963                                 }
 964
 965                                 bool themeBgBitmap = IS_CUSTOM_BITMAP(CHECKBUTTON::DETAILED_BG_SELECTED);
 966
 967                                 if (themeBgBitmap == false)
 968                                 {
 969                                         Bitmap* pCircleNormalEffectBitmap = __pCheckButton->GetCircleNormalEffectBitmap();
 970
 971                                         if (pCircleNormalEffectBitmap)
 972                                         {
 973                                                 pCanvas->DrawBitmap(FloatPoint(__detailedButtonBounds.x, __detailedButtonBounds.y), *pCircleNormalEffectBitmap);
 974                                         }
 975                                 }
 976                         }
 977                 }
 978
 979                 DrawMarkAnimation();
 980         }
 981         else if (checkStyle == CHECK_BUTTON_STYLE_RADIO || checkStyle == CHECK_BUTTON_STYLE_RADIO_WITH_DIVIDER || checkStyle == CHECK_BUTTON_STYLE_RADIO_WITH_DETAILED_BUTTON)
 982         {
 983                 if (checkStatus == _CHECK_BUTTON_STATUS_NORMAL)
 984                 {
 985                         if (checkStyle == CHECK_BUTTON_STYLE_RADIO_WITH_DETAILED_BUTTON)
 986                         {
 987                                 Bitmap* pCircleNormalBitmap = __pCheckButton->GetCircleBitmap(_CHECK_BUTTON_STATUS_NORMAL);
 988                                 Bitmap* pDetailedRightNormalBitmap = __pCheckButton->GetDetailedRightBitmap(_CHECK_BUTTON_STATUS_NORMAL);
 989
 990                                 if (__detailedPressed == true)
 991                                 {
 992                                         if (pCircleNormalBitmap)
 993                                         {
 994                                                 pReColorCircleBitmap = _BitmapImpl::GetColorReplacedBitmapN(*pCircleNormalBitmap, Color::GetColor(COLOR_ID_MAGENTA), detailedPressedBgColor);
 995                                         }
 996
 997                                         if (pDetailedRightNormalBitmap)
 998                                         {
 999                                                 pReColorRightBitmap = _BitmapImpl::GetColorReplacedBitmapN(*pDetailedRightNormalBitmap, Color::GetColor(COLOR_ID_MAGENTA), detailedRightPressedColor);
1000                                         }
1001                                 }
1002                                 else
1003                                 {
1004                                         if (pCircleNormalBitmap)
1005                                         {
1006                                                 pReColorCircleBitmap = _BitmapImpl::GetColorReplacedBitmapN(*pCircleNormalBitmap, Color::GetColor(COLOR_ID_MAGENTA), detailedNormalBgColor);
1007                                         }
1008
1009                                         if (pDetailedRightNormalBitmap)
1010                                         {
1011                                                 pReColorRightBitmap = _BitmapImpl::GetColorReplacedBitmapN(*pDetailedRightNormalBitmap, Color::GetColor(COLOR_ID_MAGENTA), detailedRightNormalColor);
1012                                         }
1013                                 }
1014
1015                                 if (pReColorCircleBitmap)
1016                                 {
1017                                         pCanvas->DrawBitmap(FloatPoint(__detailedButtonBounds.x, __detailedButtonBounds.y), *pReColorCircleBitmap);
1018                                 }
1019
1020                                 if (pReColorRightBitmap)
1021                                 {
1022                                         float arrowWidth = pReColorRightBitmap->GetWidthF();
1023                                         float arrowHeight = pReColorRightBitmap->GetHeightF();
1024
1025                                         pCanvas->DrawBitmap(FloatPoint(__detailedButtonBounds.x + (__detailedButtonBounds.width - arrowWidth) / 2.0f
1026                                                         , __detailedButtonBounds.y + (__detailedButtonBounds.height - arrowHeight) / 2.0f), *pReColorRightBitmap);
1027                                 }
1028
1029                                 bool themeBgBitmap = IS_CUSTOM_BITMAP(CHECKBUTTON::DETAILED_BG_NORMAL);
1030
1031                                 if (themeBgBitmap == false)
1032                                 {
1033                                         Bitmap* pCircleNormalEffectBitmap = __pCheckButton->GetCircleNormalEffectBitmap();
1034
1035                                         if (pCircleNormalEffectBitmap)
1036                                         {
1037                                                 pCanvas->DrawBitmap(FloatPoint(__detailedButtonBounds.x, __detailedButtonBounds.y), *pCircleNormalEffectBitmap);
1038                                         }
1039                                 }
1040                         }
1041                 }
1042                 else if (checkStatus == _CHECK_BUTTON_STATUS_DISABLED)
1043                 {
1044                         if (checkStyle == CHECK_BUTTON_STYLE_RADIO_WITH_DETAILED_BUTTON)
1045                         {
1046                                 Bitmap* pCircleDisabledBitmap = __pCheckButton->GetCircleBitmap(_CHECK_BUTTON_STATUS_DISABLED);
1047                                 Bitmap* pDetailedRightDisabledBitmap = __pCheckButton->GetDetailedRightBitmap(_CHECK_BUTTON_STATUS_DISABLED);
1048
1049                                 if (pCircleDisabledBitmap)
1050                                 {
1051                                         pReColorCircleBitmap = _BitmapImpl::GetColorReplacedBitmapN(*pCircleDisabledBitmap, Color::GetColor(COLOR_ID_MAGENTA), detailedDisabledBgColor);
1052                                 }
1053
1054                                 if (pDetailedRightDisabledBitmap)
1055                                 {
1056                                         pReColorRightBitmap = _BitmapImpl::GetColorReplacedBitmapN(*pDetailedRightDisabledBitmap, Color::GetColor(COLOR_ID_MAGENTA), detailedRightDisabledColor);
1057                                 }
1058
1059                                 if (pReColorCircleBitmap)
1060                                 {
1061                                         pCanvas->DrawBitmap(FloatPoint(__detailedButtonBounds.x, __detailedButtonBounds.y), *pReColorCircleBitmap);
1062                                 }
1063
1064                                 if (pReColorRightBitmap)
1065                                 {
1066                                         float arrowWidth = pReColorRightBitmap->GetWidthF();
1067                                         float arrowHeight = pReColorRightBitmap->GetHeightF();
1068
1069                                         pCanvas->DrawBitmap(FloatPoint(__detailedButtonBounds.x + (__detailedButtonBounds.width - arrowWidth) / 2.0f
1070                                                         , __detailedButtonBounds.y + (__detailedButtonBounds.height - arrowHeight) / 2.0f), *pReColorRightBitmap);
1071                                 }
1072
1073                                 bool themeBgBitmap = IS_CUSTOM_BITMAP(CHECKBUTTON::DETAILED_BG_DISABLED);
1074
1075                                 if (themeBgBitmap == false)
1076                                 {
1077                                         Bitmap* pCircleNormalEffectBitmap = __pCheckButton->GetCircleNormalEffectBitmap();
1078
1079                                         if (pCircleNormalEffectBitmap)
1080                                         {
1081                                                 pCanvas->DrawBitmap(FloatPoint(__detailedButtonBounds.x, __detailedButtonBounds.y), *pCircleNormalEffectBitmap);
1082                                         }
1083                                 }
1084                         }
1085                 }
1086                 else if (checkStatus == _CHECK_BUTTON_STATUS_PRESSED)
1087                 {
1088                         if (checkStyle == CHECK_BUTTON_STYLE_RADIO_WITH_DETAILED_BUTTON)
1089                         {
1090                                 Bitmap* pCirclePressedBitmap = __pCheckButton->GetCircleBitmap(_CHECK_BUTTON_STATUS_PRESSED);
1091                                 Bitmap* pDetailedRightPressedBitmap = __pCheckButton->GetDetailedRightBitmap(_CHECK_BUTTON_STATUS_PRESSED);
1092
1093                                 if (__detailedPressed == true)
1094                                 {
1095                                         if (pCirclePressedBitmap)
1096                                         {
1097                                                 pReColorCircleBitmap = _BitmapImpl::GetColorReplacedBitmapN(*pCirclePressedBitmap, Color::GetColor(COLOR_ID_MAGENTA), detailedPressedBgColor);
1098                                         }
1099
1100                                         if (pDetailedRightPressedBitmap)
1101                                         {
1102                                                 pReColorRightBitmap = _BitmapImpl::GetColorReplacedBitmapN(*pDetailedRightPressedBitmap, Color::GetColor(COLOR_ID_MAGENTA), detailedRightPressedColor);
1103                                         }
1104                                 }
1105                                 else
1106                                 {
1107                                         if (pCirclePressedBitmap)
1108                                         {
1109                                                 pReColorCircleBitmap = _BitmapImpl::GetColorReplacedBitmapN(*pCirclePressedBitmap, Color::GetColor(COLOR_ID_MAGENTA), detailedNormalBgColor);
1110                                         }
1111
1112                                         if (pDetailedRightPressedBitmap)
1113                                         {
1114                                                 pReColorRightBitmap = _BitmapImpl::GetColorReplacedBitmapN(*pDetailedRightPressedBitmap, Color::GetColor(COLOR_ID_MAGENTA), detailedRightNormalColor);
1115                                         }
1116                                 }
1117
1118                                 if (pReColorCircleBitmap)
1119                                 {
1120                                         pCanvas->DrawBitmap(FloatPoint(__detailedButtonBounds.x, __detailedButtonBounds.y), *pReColorCircleBitmap);
1121                                 }
1122
1123                                 if (pReColorRightBitmap)
1124                                 {
1125                                         float arrowWidth = pReColorRightBitmap->GetWidthF();
1126                                         float arrowHeight = pReColorRightBitmap->GetHeightF();
1127
1128                                         pCanvas->DrawBitmap(FloatPoint(__detailedButtonBounds.x + (__detailedButtonBounds.width - arrowWidth) / 2.0f
1129                                                         , __detailedButtonBounds.y + (__detailedButtonBounds.height - arrowHeight) / 2.0f), *pReColorRightBitmap);
1130                                 }
1131
1132                                 bool themeBgBitmap = IS_CUSTOM_BITMAP(CHECKBUTTON::DETAILED_BG_PRESSED);
1133
1134                                 if (themeBgBitmap == false)
1135                                 {
1136                                         Bitmap* pCirclePressedEffectBitmap = __pCheckButton->GetCirclePressedEffectBitmap();
1137
1138                                         if (pCirclePressedEffectBitmap)
1139                                         {
1140                                                 pCanvas->DrawBitmap(FloatPoint(__detailedButtonBounds.x, __detailedButtonBounds.y), *pCirclePressedEffectBitmap);
1141                                         }
1142                                 }
1143                         }
1144                 }
1145                 else if (checkStatus == _CHECK_BUTTON_STATUS_HIGHLIGHTED)
1146                 {
1147                         if (checkStyle == CHECK_BUTTON_STYLE_RADIO_WITH_DETAILED_BUTTON)
1148                         {
1149                                 Bitmap* pCircleNormalBitmap = __pCheckButton->GetCircleBitmap(_CHECK_BUTTON_STATUS_NORMAL);
1150                                 Bitmap* pCircleHighlightedBitmap = __pCheckButton->GetCircleBitmap(_CHECK_BUTTON_STATUS_HIGHLIGHTED);
1151                                 Bitmap* pDetailedRightHighlightedBitmap = __pCheckButton->GetDetailedRightBitmap(_CHECK_BUTTON_STATUS_HIGHLIGHTED);
1152
1153                                 if (__detailedPressed == true)
1154                                 {
1155                                         if (pCircleNormalBitmap)
1156                                         {
1157                                                 pReColorCircleBitmap = _BitmapImpl::GetColorReplacedBitmapN(*pCircleNormalBitmap, Color::GetColor(COLOR_ID_MAGENTA), detailedPressedBgColor);
1158                                         }
1159
1160                                         if (pDetailedRightHighlightedBitmap)
1161                                         {
1162                                                 pReColorRightBitmap = _BitmapImpl::GetColorReplacedBitmapN(*pDetailedRightHighlightedBitmap, Color::GetColor(COLOR_ID_MAGENTA), detailedRightPressedColor);
1163                                         }
1164                                 }
1165                                 else
1166                                 {
1167                                         if (pCircleNormalBitmap)
1168                                         {
1169                                                 pReColorCircleBitmap = _BitmapImpl::GetColorReplacedBitmapN(*pCircleNormalBitmap, Color::GetColor(COLOR_ID_MAGENTA), detailedNormalBgColor);
1170                                         }
1171
1172                                         if (pDetailedRightHighlightedBitmap)
1173                                         {
1174                                                 pReColorRightBitmap = _BitmapImpl::GetColorReplacedBitmapN(*pDetailedRightHighlightedBitmap, Color::GetColor(COLOR_ID_MAGENTA), detailedRightHighlightedColor);
1175                                         }
1176                                 }
1177
1178                                 if (pReColorCircleBitmap)
1179                                 {
1180                                         pCanvas->DrawBitmap(FloatPoint(__detailedButtonBounds.x, __detailedButtonBounds.y), *pReColorCircleBitmap);
1181                                 }
1182
1183                                 if (pReColorRightBitmap)
1184                                 {
1185                                         float arrowWidth = pReColorRightBitmap->GetWidthF();
1186                                         float arrowHeight = pReColorRightBitmap->GetHeightF();
1187
1188                                         pCanvas->DrawBitmap(FloatPoint(__detailedButtonBounds.x + (__detailedButtonBounds.width - arrowWidth) / 2.0f
1189                                                         , __detailedButtonBounds.y + (__detailedButtonBounds.height - arrowHeight) / 2.0f), *pReColorRightBitmap);
1190                                 }
1191
1192                                 bool themeBgBitmap = IS_CUSTOM_BITMAP(CHECKBUTTON::DETAILED_BG_HIGHLIGHTED);
1193
1194                                 if (themeBgBitmap == false)
1195                                 {
1196                                         Bitmap* pCirclePressedEffectBitmap = __pCheckButton->GetCirclePressedEffectBitmap();
1197
1198                                         if (pCirclePressedEffectBitmap)
1199                                         {
1200                                                 pCanvas->DrawBitmap(FloatPoint(__detailedButtonBounds.x, __detailedButtonBounds.y), *pCirclePressedEffectBitmap);
1201                                         }
1202                                 }
1203
1204                                 Bitmap* pReColorCircleHighlightedBitmap = null;
1205
1206                                 if (pCircleHighlightedBitmap)
1207                                 {
1208                                         pReColorCircleHighlightedBitmap = _BitmapImpl::GetColorReplacedBitmapN(*pCircleHighlightedBitmap, Color::GetColor(COLOR_ID_MAGENTA), detailedHighlightedBgColor);
1209                                 }
1210
1211                                 if (pReColorCircleHighlightedBitmap && __highlightedIndex == 1)
1212                                 {
1213                                         pCanvas->DrawBitmap(FloatPoint(__detailedButtonBounds.x, __detailedButtonBounds.y), *pReColorCircleHighlightedBitmap);
1214                                 }
1215
1216                                 delete pReColorCircleHighlightedBitmap;
1217                         }
1218                 }
1219                 else if (checkStatus == _CHECK_BUTTON_STATUS_SELECTED)
1220                 {
1221                         if (checkStyle == CHECK_BUTTON_STYLE_RADIO_WITH_DETAILED_BUTTON)
1222                         {
1223                                 Bitmap* pCircleSelectedBitmap = __pCheckButton->GetCircleBitmap(_CHECK_BUTTON_STATUS_SELECTED);
1224                                 Bitmap* pDetailedRightSelectedBitmap = __pCheckButton->GetDetailedRightBitmap(_CHECK_BUTTON_STATUS_SELECTED);
1225
1226                                 if (__detailedPressed == true)
1227                                 {
1228                                         if (pCircleSelectedBitmap)
1229                                         {
1230                                                 pReColorCircleBitmap = _BitmapImpl::GetColorReplacedBitmapN(*pCircleSelectedBitmap, Color::GetColor(COLOR_ID_MAGENTA), detailedPressedBgColor);
1231                                         }
1232
1233                                         if (pDetailedRightSelectedBitmap)
1234                                         {
1235                                                 pReColorRightBitmap = _BitmapImpl::GetColorReplacedBitmapN(*pDetailedRightSelectedBitmap, Color::GetColor(COLOR_ID_MAGENTA), detailedRightPressedColor);
1236                                         }
1237                                 }
1238                                 else
1239                                 {
1240                                         if (pCircleSelectedBitmap)
1241                                         {
1242                                                 pReColorCircleBitmap = _BitmapImpl::GetColorReplacedBitmapN(*pCircleSelectedBitmap, Color::GetColor(COLOR_ID_MAGENTA), detailedSelectedBgColor);
1243                                         }
1244
1245                                         if (pDetailedRightSelectedBitmap)
1246                                         {
1247                                                 pReColorRightBitmap = _BitmapImpl::GetColorReplacedBitmapN(*pDetailedRightSelectedBitmap, Color::GetColor(COLOR_ID_MAGENTA), detailedRightSelectedColor);
1248                                         }
1249                                 }
1250
1251                                 if (pReColorCircleBitmap)
1252                                 {
1253                                         pCanvas->DrawBitmap(FloatPoint(__detailedButtonBounds.x, __detailedButtonBounds.y), *pReColorCircleBitmap);
1254                                 }
1255
1256                                 if (pReColorRightBitmap)
1257                                 {
1258                                         float arrowWidth = pReColorRightBitmap->GetWidthF();
1259                                         float arrowHeight = pReColorRightBitmap->GetHeightF();
1260
1261                                         pCanvas->DrawBitmap(FloatPoint(__detailedButtonBounds.x + (__detailedButtonBounds.width - arrowWidth) / 2.0f
1262                                                         , __detailedButtonBounds.y + (__detailedButtonBounds.height - arrowHeight) / 2.0f), *pReColorRightBitmap);
1263                                 }
1264
1265                                 bool themeBgBitmap = IS_CUSTOM_BITMAP(CHECKBUTTON::DETAILED_BG_SELECTED);
1266
1267                                 if (themeBgBitmap == false)
1268                                 {
1269                                         Bitmap* pCircleNormalEffectBitmap = __pCheckButton->GetCircleNormalEffectBitmap();
1270
1271                                         if (pCircleNormalEffectBitmap)
1272                                         {
1273                                                 pCanvas->DrawBitmap(FloatPoint(__detailedButtonBounds.x, __detailedButtonBounds.y), *pCircleNormalEffectBitmap);
1274                                         }
1275                                 }
1276                         }
1277                 }
1278
1279                 DrawMarkAnimation();
1280         }
1281         else if (checkStyle == CHECK_BUTTON_STYLE_ONOFF || checkStyle == CHECK_BUTTON_STYLE_ONOFF_WITH_DIVIDER)
1282         {
1283                 if (checkStatus == _CHECK_BUTTON_STATUS_NORMAL)
1284                 {
1285                         Bitmap* pOnOffBgNormalBitmap = __pCheckButton->GetOnOffBgBitmap(_CHECK_BUTTON_STATUS_NORMAL);
1286
1287                         if (pOnOffBgNormalBitmap)
1288                         {
1289                                 pCanvas->DrawBitmap(FloatPoint(__defaultButtonBounds.x, __defaultButtonBounds.y), *pOnOffBgNormalBitmap);
1290                         }
1291
1292                         Bitmap* pOnOffNormalBitmap = __pCheckButton->GetOnOffBitmap(_CHECK_BUTTON_STATUS_NORMAL);
1293
1294                         if (__pCheckButton->IsSelected() && pOnOffNormalBitmap)
1295                         {
1296                                 pCanvas->DrawBitmap(FloatPoint(__defaultButtonBounds.x, __defaultButtonBounds.y), *pOnOffNormalBitmap);
1297                         }
1298                 }
1299                 else if (checkStatus == _CHECK_BUTTON_STATUS_DISABLED)
1300                 {
1301                         Bitmap* pOnOffBgDisabledBitmap = __pCheckButton->GetOnOffBgBitmap(_CHECK_BUTTON_STATUS_DISABLED);
1302
1303                         if (pOnOffBgDisabledBitmap)
1304                         {
1305                                 pCanvas->DrawBitmap(FloatPoint(__defaultButtonBounds.x, __defaultButtonBounds.y), *pOnOffBgDisabledBitmap);
1306                         }
1307
1308                         Bitmap* pOnOffDisabledBitmap = __pCheckButton->GetOnOffBitmap(_CHECK_BUTTON_STATUS_DISABLED);
1309
1310                         if (__pCheckButton->IsSelected() && pOnOffDisabledBitmap)
1311                         {
1312                                 pCanvas->DrawBitmap(FloatPoint(__defaultButtonBounds.x, __defaultButtonBounds.y), *pOnOffDisabledBitmap);
1313                         }
1314                 }
1315                 else if (checkStatus == _CHECK_BUTTON_STATUS_PRESSED)
1316                 {
1317                         Bitmap* pOnOffBgPressedBitmap = __pCheckButton->GetOnOffBgBitmap(_CHECK_BUTTON_STATUS_PRESSED);
1318
1319                         if (pOnOffBgPressedBitmap)
1320                         {
1321                                 pCanvas->DrawBitmap(FloatPoint(__defaultButtonBounds.x, __defaultButtonBounds.y), *pOnOffBgPressedBitmap);
1322                         }
1323
1324                         Bitmap* pOnOffPressedBitmap = __pCheckButton->GetOnOffBitmap(_CHECK_BUTTON_STATUS_PRESSED);
1325
1326                         if (__pCheckButton->IsSelected() && pOnOffPressedBitmap)
1327                         {
1328                                 pCanvas->DrawBitmap(FloatPoint(__defaultButtonBounds.x, __defaultButtonBounds.y), *pOnOffPressedBitmap);
1329                         }
1330                 }
1331                 else if (checkStatus == _CHECK_BUTTON_STATUS_HIGHLIGHTED)
1332                 {
1333                         Bitmap* pOnOffBgNormalBitmap = __pCheckButton->GetOnOffBgBitmap(_CHECK_BUTTON_STATUS_NORMAL);
1334                         Bitmap* pOnOffBgHighlightedBitmap = __pCheckButton->GetOnOffBgBitmap(_CHECK_BUTTON_STATUS_HIGHLIGHTED);
1335
1336                         if (pOnOffBgNormalBitmap)
1337                         {
1338                                 pCanvas->DrawBitmap(FloatPoint(__defaultButtonBounds.x, __defaultButtonBounds.y), *pOnOffBgNormalBitmap);
1339                         }
1340
1341                         Bitmap* pOnOffHighlightedBitmap = __pCheckButton->GetOnOffBitmap(_CHECK_BUTTON_STATUS_HIGHLIGHTED);
1342
1343                         if (__pCheckButton->IsSelected() && pOnOffHighlightedBitmap)
1344                         {
1345                                 pCanvas->DrawBitmap(FloatPoint(__defaultButtonBounds.x, __defaultButtonBounds.y), *pOnOffHighlightedBitmap);
1346                         }
1347
1348                         Bitmap* pReColorOnOffBgHighlightedBitmap = null;
1349
1350                         if (pOnOffBgHighlightedBitmap)
1351                         {
1352                                 pReColorOnOffBgHighlightedBitmap = _BitmapImpl::GetColorReplacedBitmapN(*pOnOffBgHighlightedBitmap, Color::GetColor(COLOR_ID_MAGENTA), detailedHighlightedBgColor);
1353                         }
1354
1355                         if (pReColorOnOffBgHighlightedBitmap && __highlightedIndex == 1)
1356                         {
1357                                 pCanvas->DrawBitmap(FloatPoint(__defaultButtonBounds.x, __defaultButtonBounds.y), *pReColorOnOffBgHighlightedBitmap);
1358                         }
1359
1360                         delete pReColorOnOffBgHighlightedBitmap;
1361                 }
1362                 else if (checkStatus == _CHECK_BUTTON_STATUS_SELECTED)
1363                 {
1364                         Bitmap* pOnOffBgSelectedBitmap = __pCheckButton->GetOnOffBgBitmap(_CHECK_BUTTON_STATUS_SELECTED);
1365
1366                         if (pOnOffBgSelectedBitmap)
1367                         {
1368                                 pCanvas->DrawBitmap(FloatPoint(__defaultButtonBounds.x, __defaultButtonBounds.y), *pOnOffBgSelectedBitmap);
1369                         }
1370
1371                         Bitmap* pOnOffSelectedBitmap = __pCheckButton->GetOnOffBitmap(_CHECK_BUTTON_STATUS_SELECTED);
1372
1373                         if (__pCheckButton->IsSelected() && pOnOffSelectedBitmap)
1374                         {
1375                                 pCanvas->DrawBitmap(FloatPoint(__defaultButtonBounds.x, __defaultButtonBounds.y), *pOnOffSelectedBitmap);
1376                         }
1377                 }
1378         }
1379         else if (checkStyle == CHECK_BUTTON_STYLE_ONOFF_SLIDING || checkStyle == CHECK_BUTTON_STYLE_ONOFF_SLIDING_WITH_DIVIDER)
1380         {
1381                 float handlerWidth = 0.0f;
1382                 GET_SHAPE_CONFIG(CHECKBUTTON::ONOFF_SLIDING_HANDLER_WIDTH, _CONTROL_ORIENTATION_PORTRAIT, handlerWidth);
1383                 DrawOnOffSlidingHandler(__onOffHandlerPosition - (handlerWidth / 2.0f));
1384
1385                 float dividerWidth = 0.0f;
1386                 float dividerTopMargin = 0.0f;
1387                 float dividerRightMargin = 0.0f;
1388
1389                 Color dividerLeftColor;
1390                 //Color dividerRightColor;
1391                 FloatDimension minDimension(0.0f, 0.0f);
1392
1393                 GET_SHAPE_CONFIG(CHECKBUTTON::DIVIDER_WIDTH, _CONTROL_ORIENTATION_PORTRAIT, dividerWidth);
1394                 GET_SHAPE_CONFIG(CHECKBUTTON::DIVIDER_TOP_MARGIN, _CONTROL_ORIENTATION_PORTRAIT, dividerTopMargin);
1395                 GET_SHAPE_CONFIG(CHECKBUTTON::DIVIDER_RIGHT_MARGIN, _CONTROL_ORIENTATION_PORTRAIT, dividerRightMargin);
1396                 GET_COLOR_CONFIG(HEADER::DIVIDER_LINE_LEFT_NORMAL, dividerLeftColor);
1397                 //GET_COLOR_CONFIG(HEADER::DIVIDER_LINE_RIGHT_NORMAL, dividerRightColor);
1398
1399                 GET_DIMENSION_CONFIG(CHECKBUTTON::MIN_DIMENSION, __pCheckButton->GetOrientation(), minDimension);
1400
1401                 FloatRectangle bounds(0.0f, 0.0f, __pCheckButton->GetBoundsF().width, __pCheckButton->GetBoundsF().height);
1402
1403                 if (bounds.height < minDimension.height )
1404                 {
1405                         bounds.height = minDimension.height;
1406                 }
1407
1408                 if (checkStyle == CHECK_BUTTON_STYLE_ONOFF_SLIDING_WITH_DIVIDER)
1409                 {
1410                         pCanvas->SetForegroundColor(dividerLeftColor);
1411                         pCanvas->SetLineWidth(dividerWidth);
1412                         pCanvas->DrawLine(FloatPoint(__onOffSlidingButtonBounds.x - dividerRightMargin + dividerWidth, dividerTopMargin),
1413                                         FloatPoint(__onOffSlidingButtonBounds.x - dividerRightMargin + dividerWidth, dividerTopMargin + bounds.height - dividerTopMargin * 2));
1414
1415                         //pCanvas->SetForegroundColor(dividerRightColor);
1416                         //pCanvas->SetLineWidth(dividerWidth/2);
1417                         //pCanvas->DrawLine(FloatPoint(__onOffSlidingButtonBounds.x - dividerRightMargin + dividerWidth, dividerTopMargin),
1418                         //              FloatPoint(__onOffSlidingButtonBounds.x - dividerRightMargin + dividerWidth, dividerTopMargin + bounds.height - dividerTopMargin * 2));
1419                 }
1420         }
1421
1422         delete pCanvas;
1423         delete pReColorCircleBitmap;
1424         delete pReColorRightBitmap;
1425
1426         return;
1427 }
1428
1429 void
1430 _CheckButtonPresenter::DrawText(void)
1431 {
1432         result r = E_SUCCESS;
1433
1434         TextSimple* pSimpleText = null;
1435         TextSimple* pSimpleTitleText = null;
1436         TextObjectAlignment horizontalAlign = TEXT_OBJECT_ALIGNMENT_CENTER;
1437         TextObjectAlignment verticalAlign = TEXT_OBJECT_ALIGNMENT_MIDDLE;
1438
1439         _CheckButtonStatus checkStatus = __pCheckButton->GetCheckButtonStatus();
1440         bool showTitle = __pCheckButton->GetShowTitle();
1441
1442         Canvas* pCanvas = __pCheckButton->GetCanvasN();
1443         if (pCanvas == null)
1444         {
1445                 SysLog(NID_UI_CTRL, "Cannot get a canvas.");
1446
1447                 return;
1448         }
1449
1450         __pTextObject->RemoveAll(true);
1451         pSimpleText = new (std::nothrow) TextSimple(const_cast<wchar_t*>(__pCheckButton->GetText().GetPointer()), __pCheckButton->GetText().GetLength());
1452         __pTextObject->AppendElement(*pSimpleText);
1453
1454         __pTitleTextObject->RemoveAll(true);
1455         pSimpleTitleText = new (std::nothrow) TextSimple(const_cast<wchar_t*>(__pCheckButton->GetTitleText().GetPointer()), __pCheckButton->GetTitleText().GetLength());
1456         __pTitleTextObject->AppendElement(*pSimpleTitleText);
1457
1458         if (checkStatus == _CHECK_BUTTON_STATUS_NORMAL)
1459         {
1460                 __pTextObject->SetForegroundColor(__pCheckButton->GetTextColor(), 0, __pTextObject->GetTextLength());
1461                 __pTitleTextObject->SetForegroundColor(__pCheckButton->GetTitleTextColor(), 0, __pTitleTextObject->GetTextLength());
1462         }
1463         else if (checkStatus == _CHECK_BUTTON_STATUS_DISABLED)
1464         {
1465                 __pTextObject->SetForegroundColor(__pCheckButton->GetDisabledTextColor(), 0, __pTextObject->GetTextLength());
1466                 __pTitleTextObject->SetForegroundColor(__pCheckButton->GetDisabledTitleTextColor(), 0, __pTitleTextObject->GetTextLength());
1467         }
1468         else if (checkStatus == _CHECK_BUTTON_STATUS_PRESSED)
1469         {
1470                 __pTextObject->SetForegroundColor(__pCheckButton->GetPressedTextColor(), 0, __pTextObject->GetTextLength());
1471                 __pTitleTextObject->SetForegroundColor(__pCheckButton->GetPressedTitleTextColor(), 0, __pTitleTextObject->GetTextLength());
1472         }
1473         else if (checkStatus == _CHECK_BUTTON_STATUS_HIGHLIGHTED)
1474         {
1475                 __pTextObject->SetForegroundColor(__pCheckButton->GetHighlightedTextColor(), 0, __pTextObject->GetTextLength());
1476                 __pTitleTextObject->SetForegroundColor(__pCheckButton->GetHighlightedTitleTextColor(), 0, __pTitleTextObject->GetTextLength());
1477         }
1478         else
1479         {
1480                 __pTextObject->SetForegroundColor(__pCheckButton->GetSelectedTextColor(), 0, __pTextObject->GetTextLength());
1481                 __pTitleTextObject->SetForegroundColor(__pCheckButton->GetSelectedTitleTextColor(), 0, __pTitleTextObject->GetTextLength());
1482         }
1483
1484         CalculateTextBounds();
1485         CalculateTitleTextBounds();
1486
1487         __pTextObject->SetWrap(TEXT_OBJECT_WRAP_TYPE_NONE);
1488         __pTextObject->SetAction(TEXT_OBJECT_ACTION_TYPE_ABBREV);
1489         __pTextObject->SetBounds(GetTextBoundsF());
1490         __pTextObject->Compose();
1491
1492         __pTitleTextObject->SetWrap(TEXT_OBJECT_WRAP_TYPE_NONE);
1493         __pTitleTextObject->SetAction(TEXT_OBJECT_ACTION_TYPE_ABBREV);
1494         __pTitleTextObject->SetBounds(GetTitleTextBoundsF());
1495         __pTitleTextObject->Compose();
1496
1497         switch (__pCheckButton->GetTextHorizontalAlignment())
1498         {
1499         case ALIGNMENT_LEFT:
1500                 horizontalAlign = TEXT_OBJECT_ALIGNMENT_LEFT;
1501                 break;
1502         case ALIGNMENT_CENTER:
1503                 horizontalAlign = TEXT_OBJECT_ALIGNMENT_CENTER;
1504                 break;
1505         default:
1506                 horizontalAlign = TEXT_OBJECT_ALIGNMENT_RIGHT;
1507         }
1508
1509         switch (__pCheckButton->GetTextVerticalAlignment())
1510         {
1511         case ALIGNMENT_TOP:
1512                 verticalAlign = TEXT_OBJECT_ALIGNMENT_TOP;
1513                 break;
1514         case ALIGNMENT_MIDDLE:
1515                 verticalAlign = TEXT_OBJECT_ALIGNMENT_MIDDLE;
1516                 break;
1517         default:
1518                 verticalAlign = TEXT_OBJECT_ALIGNMENT_BOTTOM;
1519         }
1520
1521         __fontSize =  __pCheckButton->GetTextSizeF();
1522         __pTextFont = __pCheckButton->GetFallbackFont();
1523         r = GetLastResult();
1524         SysTryReturnVoidResult(NID_UI_CTRL, __pTextFont, r, "[%s] Propagating.", GetErrorMessage(r));
1525
1526         __pTextObject->SetAlignment(horizontalAlign | verticalAlign);
1527         __pTextObject->SetFont(__pTextFont, 0, __pTextObject->GetTextLength());
1528         __pTextObject->Draw(*_CanvasImpl::GetInstance(*pCanvas));
1529
1530         __fontSize = __pCheckButton->GetTitleTextSizeF();
1531         __pTitleTextFont = __pCheckButton->GetFallbackFont();
1532         r = GetLastResult();
1533         SysTryReturnVoidResult(NID_UI_CTRL, __pTitleTextFont, r, "[%s] Propagating.", GetErrorMessage(r));
1534
1535         __pTitleTextObject->SetAlignment(TEXT_OBJECT_ALIGNMENT_LEFT | TEXT_OBJECT_ALIGNMENT_MIDDLE);
1536         __pTitleTextObject->SetFont(__pTitleTextFont, 0, __pTitleTextObject->GetTextLength());
1537
1538         if (showTitle)
1539         {
1540                 __pTitleTextObject->Draw(*_CanvasImpl::GetInstance(*pCanvas));
1541         }
1542
1543         delete pCanvas;
1544
1545         return;
1546 }
1547
1548 bool
1549 _CheckButtonPresenter::OnTouchPressed(const _Control& source, const _TouchInfo& touchinfo)
1550 {
1551         if (&source != __pCheckButton)
1552         {
1553                 return false;
1554         }
1555
1556         if (!__pCheckButton->IsEnabled())
1557         {
1558                 return true;
1559         }
1560
1561         __touchMoveHandled = false;
1562
1563         FloatPoint touchPoint = touchinfo.GetCurrentPosition();
1564
1565         touchPoint.x += source.GetClientBoundsF().x;
1566         touchPoint.y += source.GetClientBoundsF().y;
1567
1568         CheckButtonStyle checkStyle = __pCheckButton->GetCheckButtonStyle();
1569
1570         if (checkStyle == CHECK_BUTTON_STYLE_ONOFF_SLIDING || checkStyle == CHECK_BUTTON_STYLE_ONOFF_SLIDING_WITH_DIVIDER)
1571         {
1572                 if (__onOffSlidingButtonBounds.Contains(touchPoint))
1573                 {
1574                         __onOffHandlerPressed = true;
1575                 }
1576                 else
1577                 {
1578                         __pCheckButton->SetCheckButtonStatus(_CHECK_BUTTON_STATUS_PRESSED);
1579                 }
1580         }
1581         else if (checkStyle == CHECK_BUTTON_STYLE_MARK_WITH_DETAILED_BUTTON || checkStyle == CHECK_BUTTON_STYLE_RADIO_WITH_DETAILED_BUTTON)
1582         {
1583                 if (__detailedButtonBounds.Contains(touchPoint))
1584                 {
1585                         __detailedPressed = true;
1586                 }
1587                 else
1588                 {
1589                         __pCheckButton->SetCheckButtonStatus(_CHECK_BUTTON_STATUS_PRESSED);
1590                 }
1591         }
1592         else
1593         {
1594                 __pCheckButton->SetCheckButtonStatus(_CHECK_BUTTON_STATUS_PRESSED);
1595         }
1596
1597         __pCheckButton->Invalidate();
1598
1599         return true;
1600 }
1601
1602 bool
1603 _CheckButtonPresenter::OnTouchReleased(const _Control& source, const _TouchInfo& touchinfo)
1604 {
1605         float checkButtonLeftMargin = 0.0f;
1606         float checkButtonDetailedBitmapWidth = 0.0f;
1607         float checkButtonOnOffSlidingBitmapWidth = 0.0f;
1608         float dividerRightMargin = 0.0f;
1609
1610         GET_SHAPE_CONFIG(CHECKBUTTON::LEFT_MARGIN, _CONTROL_ORIENTATION_PORTRAIT, checkButtonLeftMargin);
1611         GET_SHAPE_CONFIG(CHECKBUTTON::DETAILED_BITMAP_WIDTH, _CONTROL_ORIENTATION_PORTRAIT, checkButtonDetailedBitmapWidth);
1612         GET_SHAPE_CONFIG(CHECKBUTTON::ONOFF_SLIDING_BITMAP_WIDTH, _CONTROL_ORIENTATION_PORTRAIT, checkButtonOnOffSlidingBitmapWidth);
1613         GET_SHAPE_CONFIG(CHECKBUTTON::DIVIDER_RIGHT_MARGIN, _CONTROL_ORIENTATION_PORTRAIT, dividerRightMargin);
1614
1615         if (&source != __pCheckButton)
1616         {
1617                 return false;
1618         }
1619
1620         if (!__pCheckButton->IsEnabled())
1621         {
1622                 return true;
1623         }
1624
1625         _CheckButtonStatus status = __pCheckButton->GetCheckButtonStatus();
1626         CheckButtonStyle checkStyle = __pCheckButton->GetCheckButtonStyle();
1627
1628         if (checkStyle == CHECK_BUTTON_STYLE_ONOFF_SLIDING || checkStyle == CHECK_BUTTON_STYLE_ONOFF_SLIDING_WITH_DIVIDER)
1629         {
1630                 if (status == _CHECK_BUTTON_STATUS_NORMAL && __onOffHandlerPressed == false)
1631                 {
1632                         __onOffHandlerMoved = false;
1633
1634                         return true;
1635                 }
1636         }
1637         else if (checkStyle == CHECK_BUTTON_STYLE_MARK_WITH_DETAILED_BUTTON || checkStyle == CHECK_BUTTON_STYLE_RADIO_WITH_DETAILED_BUTTON)
1638         {
1639                 if (status == _CHECK_BUTTON_STATUS_NORMAL && __detailedPressed == true)
1640                 {
1641                         __detailedPressed = false;
1642
1643                         __pCheckButton->Invalidate();
1644
1645                         return true;
1646                 }
1647         }
1648         else
1649         {
1650                 if (status == _CHECK_BUTTON_STATUS_NORMAL)
1651                 {
1652                         return true;
1653                 }
1654         }
1655
1656         if (checkStyle == CHECK_BUTTON_STYLE_MARK || checkStyle == CHECK_BUTTON_STYLE_MARK_WITH_DIVIDER || checkStyle == CHECK_BUTTON_STYLE_MARK_WITH_DETAILED_BUTTON
1657                         || checkStyle == CHECK_BUTTON_STYLE_RADIO || checkStyle == CHECK_BUTTON_STYLE_RADIO_WITH_DIVIDER || checkStyle == CHECK_BUTTON_STYLE_RADIO_WITH_DETAILED_BUTTON)
1658         {
1659                 StartCheckAnimationTimer();
1660                 __ratio = 0;
1661         }
1662
1663         FloatPoint touchPoint = touchinfo.GetCurrentPosition();
1664
1665         touchPoint.x += source.GetClientBoundsF().x;
1666         touchPoint.y += source.GetClientBoundsF().y;
1667
1668         FloatRectangle bounds = __pCheckButton->GetClientBoundsF();
1669         FloatRectangle detailedBounds = __pCheckButton->GetClientBoundsF();
1670
1671         __pCheckButton->SetCheckButtonStatus(_CHECK_BUTTON_STATUS_NORMAL);
1672         __pCheckButton->Invalidate();
1673
1674         if (checkStyle == CHECK_BUTTON_STYLE_MARK_WITH_DETAILED_BUTTON || checkStyle == CHECK_BUTTON_STYLE_RADIO_WITH_DETAILED_BUTTON)
1675         {
1676                 if (!__detailedButtonBounds.Contains(touchPoint))
1677                 {
1678                         PLAY_FEEDBACK(_RESOURCE_FEEDBACK_PATTERN_TAP, __pCheckButton);
1679
1680                         __pCheckButton->FireActionEvent();
1681
1682                         if (__pCheckButton->GetRadioGroup() != null)
1683                         {
1684                                 __pCheckButton->SendTouchReleasedEvent(*__pCheckButton);
1685                         }
1686                 }
1687         }
1688         else if (checkStyle == CHECK_BUTTON_STYLE_ONOFF_SLIDING_WITH_DIVIDER)
1689         {
1690                 detailedBounds.width = detailedBounds.width - checkButtonLeftMargin - checkButtonOnOffSlidingBitmapWidth - dividerRightMargin;
1691
1692                 if (!detailedBounds.Contains(touchPoint))
1693                 {
1694                         if (__onOffHandlerMoved == false)
1695                         {
1696                                 PLAY_FEEDBACK(_RESOURCE_FEEDBACK_PATTERN_TAP, __pCheckButton);
1697
1698                                 __pCheckButton->FireActionEvent();
1699
1700                                 if (__pCheckButton->GetRadioGroup() != null)
1701                                 {
1702                                         __pCheckButton->SendTouchReleasedEvent(*__pCheckButton);
1703                                 }
1704                         }
1705                 }
1706
1707                 AdjustHandlerPosition();
1708
1709                 __onOffHandlerPressed = false;
1710                 __onOffHandlerMoved = false;
1711         }
1712         else if (checkStyle == CHECK_BUTTON_STYLE_ONOFF_SLIDING)
1713         {
1714                 if (bounds.Contains(touchPoint))
1715                 {
1716                         if (__onOffHandlerMoved == false)
1717                         {
1718                                 PLAY_FEEDBACK(_RESOURCE_FEEDBACK_PATTERN_TAP, __pCheckButton);
1719
1720                                 __pCheckButton->FireActionEvent();
1721
1722                                 if (__pCheckButton->GetRadioGroup() != null)
1723                                 {
1724                                         __pCheckButton->SendTouchReleasedEvent(*__pCheckButton);
1725                                 }
1726                         }
1727                 }
1728
1729                 AdjustHandlerPosition();
1730
1731                 __onOffHandlerPressed = false;
1732                 __onOffHandlerMoved = false;
1733         }
1734         else
1735         {
1736                 if (bounds.Contains(touchPoint))
1737                 {
1738                         PLAY_FEEDBACK(_RESOURCE_FEEDBACK_PATTERN_TAP, __pCheckButton);
1739
1740                         __pCheckButton->FireActionEvent();
1741
1742                         if (__pCheckButton->GetRadioGroup() != null)
1743                         {
1744                                 __pCheckButton->SendTouchReleasedEvent(*__pCheckButton);
1745                         }
1746                 }
1747         }
1748
1749         return true;
1750 }
1751
1752 result
1753 _CheckButtonPresenter::InitOnOffHandlerMoved(void)
1754 {
1755         __onOffHandlerMoved = false;
1756
1757         return E_SUCCESS;
1758 }
1759
1760 result
1761 _CheckButtonPresenter::AdjustHandlerPosition(void)
1762 {
1763         float handlerWidth = 0.0f;
1764         GET_SHAPE_CONFIG(CHECKBUTTON::ONOFF_SLIDING_HANDLER_WIDTH, _CONTROL_ORIENTATION_PORTRAIT, handlerWidth);
1765
1766         if (__onOffHandlerMoved == false)
1767         {
1768                 if (!__pCheckButton->IsSelected())
1769                 {
1770                         __onOffHandlerPosition = __onOffSlidingButtonBounds.x;
1771                 }
1772                 else
1773                 {
1774                         __onOffHandlerPosition = __onOffSlidingButtonBounds.x + __onOffSlidingButtonBounds.width - (handlerWidth / 2.0f);
1775                 }
1776         }
1777         else
1778         {
1779                 if (!__pCheckButton->IsSelected())
1780                 {
1781                         if (__onOffHandlerPosition < __onOffSlidingButtonBounds.x + (__onOffSlidingButtonBounds.width / 2.0f))
1782                         {
1783                                 __onOffHandlerPosition = __onOffSlidingButtonBounds.x;
1784                         }
1785                         else
1786                         {
1787                                 __onOffHandlerPosition = __onOffSlidingButtonBounds.x + __onOffSlidingButtonBounds.width - (handlerWidth / 2.0f);
1788
1789                                 PLAY_FEEDBACK(_RESOURCE_FEEDBACK_PATTERN_TAP, __pCheckButton);
1790
1791                                 __pCheckButton->FireActionEvent();
1792
1793                                 if (__pCheckButton->GetRadioGroup() != null)
1794                                 {
1795                                         __pCheckButton->SendTouchReleasedEvent(*__pCheckButton);
1796                                 }
1797                         }
1798                 }
1799                 else
1800                 {
1801                         if (__onOffHandlerPosition < __onOffSlidingButtonBounds.x + (__onOffSlidingButtonBounds.width / 2.0f))
1802                         {
1803                                 __onOffHandlerPosition = __onOffSlidingButtonBounds.x;
1804
1805                                 PLAY_FEEDBACK(_RESOURCE_FEEDBACK_PATTERN_TAP, __pCheckButton);
1806
1807                                 __pCheckButton->FireActionEvent();
1808
1809                                 if (__pCheckButton->GetRadioGroup() != null)
1810                                 {
1811                                         __pCheckButton->SendTouchReleasedEvent(*__pCheckButton);
1812                                 }
1813                         }
1814                         else
1815                         {
1816                                 __onOffHandlerPosition = __onOffSlidingButtonBounds.x + __onOffSlidingButtonBounds.width - (handlerWidth / 2.0f);
1817                         }
1818                 }
1819         }
1820
1821         __pCheckButton->Invalidate();
1822
1823         return E_SUCCESS;
1824 }
1825
1826 bool
1827 _CheckButtonPresenter::OnTouchMoved(const _Control& source, const _TouchInfo& touchinfo)
1828 {
1829         if (&source != __pCheckButton)
1830         {
1831                 return false;
1832         }
1833
1834         if (!__pCheckButton->IsEnabled())
1835         {
1836                 return true;
1837         }
1838
1839         FloatPoint touchPoint = touchinfo.GetCurrentPosition();
1840
1841         touchPoint.x += source.GetClientBoundsF().x;
1842         touchPoint.y += source.GetClientBoundsF().y;
1843
1844         FloatRectangle bounds = __pCheckButton->GetClientBoundsF();
1845         bool isInCheckButtonArea = bounds.Contains(touchPoint);
1846         bool isInOnOffHandlerArea = __onOffSlidingButtonBounds.Contains(touchPoint);
1847         bool isDetailedArea = __detailedButtonBounds.Contains(touchPoint);
1848
1849         CheckButtonStyle checkStyle = __pCheckButton->GetCheckButtonStyle();
1850
1851         if (checkStyle == CHECK_BUTTON_STYLE_ONOFF_SLIDING || checkStyle == CHECK_BUTTON_STYLE_ONOFF_SLIDING_WITH_DIVIDER)
1852         {
1853                 if (__onOffHandlerPressed == true)
1854                 {
1855                         __pCheckButton->SetCheckButtonStatus(_CHECK_BUTTON_STATUS_NORMAL);
1856                 }
1857                 else
1858                 {
1859                         if (isInCheckButtonArea == true && __touchMoveHandled == false && isInOnOffHandlerArea == false )
1860                         {
1861                                 __pCheckButton->SetCheckButtonStatus(_CHECK_BUTTON_STATUS_PRESSED);
1862                         }
1863                         else
1864                         {
1865                                 __pCheckButton->SetCheckButtonStatus(_CHECK_BUTTON_STATUS_NORMAL);
1866                         }
1867                 }
1868         }
1869         else if (checkStyle == CHECK_BUTTON_STYLE_MARK_WITH_DETAILED_BUTTON || checkStyle == CHECK_BUTTON_STYLE_RADIO_WITH_DETAILED_BUTTON)
1870         {
1871                 if (isDetailedArea == true && __touchMoveHandled == false)
1872                 {
1873                         __detailedPressed = true;
1874
1875                         __pCheckButton->SetCheckButtonStatus(_CHECK_BUTTON_STATUS_NORMAL);
1876                 }
1877                 else
1878                 {
1879                         __detailedPressed = false;
1880
1881                         if (isInCheckButtonArea == true && __touchMoveHandled == false && isDetailedArea == false )
1882                         {
1883                                 __pCheckButton->SetCheckButtonStatus(_CHECK_BUTTON_STATUS_PRESSED);
1884                         }
1885                         else
1886                         {
1887                                 __pCheckButton->SetCheckButtonStatus(_CHECK_BUTTON_STATUS_NORMAL);
1888                         }
1889                 }
1890         }
1891         else
1892         {
1893                 if (isInCheckButtonArea == true && __touchMoveHandled == false)
1894                 {
1895                         __pCheckButton->SetCheckButtonStatus(_CHECK_BUTTON_STATUS_PRESSED);
1896                 }
1897                 else
1898                 {
1899                         __pCheckButton->SetCheckButtonStatus(_CHECK_BUTTON_STATUS_NORMAL);
1900                 }
1901         }
1902
1903         if (checkStyle == CHECK_BUTTON_STYLE_ONOFF_SLIDING || checkStyle == CHECK_BUTTON_STYLE_ONOFF_SLIDING_WITH_DIVIDER)
1904         {
1905                 if (isInOnOffHandlerArea == true && __onOffHandlerPressed == true)
1906                 {
1907                         __onOffHandlerPosition = touchPoint.x;
1908
1909                         __onOffHandlerMoved = true;
1910                 }
1911         }
1912
1913         __pCheckButton->Invalidate();
1914
1915         if (__onOffHandlerMoved == true)
1916         {
1917                 return true;
1918         }
1919         else
1920         {
1921                 return false;
1922         }
1923 }
1924
1925 void
1926 _CheckButtonPresenter::DrawOnOffSlidingHandler(float handlerPosition)
1927 {
1928         Canvas* pCanvas = __pCheckButton->GetCanvasN();
1929         if (pCanvas == null)
1930         {
1931                 SysLog(NID_UI_CTRL, "Cannot get a canvas.");
1932
1933                 return;
1934         }
1935
1936         Bitmap* pReColorBgBitmap = null;
1937
1938         Color detailedHighlightedBgColor;
1939         GET_COLOR_CONFIG(CHECKBUTTON::DETAILED_ICON_BG_HIGHLIGHTED, detailedHighlightedBgColor);
1940
1941         float handlerMargin = 0.0f;
1942         float handlerWidth = 0.0f;
1943
1944         _CheckButtonStatus checkStatus = __pCheckButton->GetCheckButtonStatus();
1945
1946         GET_SHAPE_CONFIG(CHECKBUTTON::ONOFF_SLIDING_HANDLER_MARGIN, _CONTROL_ORIENTATION_PORTRAIT, handlerMargin);
1947         GET_SHAPE_CONFIG(CHECKBUTTON::ONOFF_SLIDING_HANDLER_WIDTH, _CONTROL_ORIENTATION_PORTRAIT, handlerWidth);
1948
1949         if (handlerPosition < __onOffSlidingButtonBounds.x)
1950         {
1951                 handlerPosition = __onOffSlidingButtonBounds.x;
1952         }
1953
1954         if (handlerPosition > __onOffSlidingButtonBounds.x + __onOffSlidingButtonBounds.width - handlerWidth)
1955         {
1956                 handlerPosition = __onOffSlidingButtonBounds.x + __onOffSlidingButtonBounds.width - handlerWidth;
1957         }
1958
1959         if (!__pCheckButton->IsSelected())
1960         {
1961                 if (checkStatus == _CHECK_BUTTON_STATUS_NORMAL)
1962                 {
1963                         Bitmap* pOnOffSlidingNormalBgBitmap = __pCheckButton->GetOnOffSlidingBgBitmap(_CHECK_BUTTON_STATUS_NORMAL);
1964
1965                         if (pOnOffSlidingNormalBgBitmap)
1966                         {
1967                                 pCanvas->DrawBitmap(FloatPoint(__onOffSlidingButtonBounds.x, __onOffSlidingButtonBounds.y), *pOnOffSlidingNormalBgBitmap);
1968                         }
1969
1970                         Bitmap* pOnOffSlidingOffHandlerNormalBitmap = __pCheckButton->GetOnOffSlidingOffHandlerBitmap(_CHECK_BUTTON_STATUS_NORMAL);
1971
1972                         if (pOnOffSlidingOffHandlerNormalBitmap)
1973                         {
1974                                 pCanvas->DrawBitmap(FloatPoint(handlerPosition, __onOffSlidingButtonBounds.y - handlerMargin), *pOnOffSlidingOffHandlerNormalBitmap);
1975                         }
1976                 }
1977                 else if (checkStatus == _CHECK_BUTTON_STATUS_DISABLED)
1978                 {
1979                         Bitmap* pOnOffSlidingDisabledBgBitmap = __pCheckButton->GetOnOffSlidingBgBitmap(_CHECK_BUTTON_STATUS_DISABLED);
1980
1981                         if (pOnOffSlidingDisabledBgBitmap)
1982                         {
1983                                 pCanvas->DrawBitmap(FloatPoint(__onOffSlidingButtonBounds.x, __onOffSlidingButtonBounds.y), *pOnOffSlidingDisabledBgBitmap);
1984                         }
1985
1986                         Bitmap* pOnOffSlidingOffHandlerDisabledBitmap = __pCheckButton->GetOnOffSlidingOffHandlerBitmap(_CHECK_BUTTON_STATUS_DISABLED);
1987
1988                         if (pOnOffSlidingOffHandlerDisabledBitmap)
1989                         {
1990                                 pCanvas->DrawBitmap(FloatPoint(handlerPosition, __onOffSlidingButtonBounds.y - handlerMargin), *pOnOffSlidingOffHandlerDisabledBitmap);
1991                         }
1992                 }
1993                 else if (checkStatus == _CHECK_BUTTON_STATUS_PRESSED)
1994                 {
1995                         Bitmap* pOnOffSlidingPressedBgBitmap = __pCheckButton->GetOnOffSlidingBgBitmap(_CHECK_BUTTON_STATUS_PRESSED);
1996
1997                         if (pOnOffSlidingPressedBgBitmap)
1998                         {
1999                                 pCanvas->DrawBitmap(FloatPoint(__onOffSlidingButtonBounds.x, __onOffSlidingButtonBounds.y), *pOnOffSlidingPressedBgBitmap);
2000                         }
2001
2002                         Bitmap* pOnOffSlidingOffHandlerPressedBitmap = __pCheckButton->GetOnOffSlidingOffHandlerBitmap(_CHECK_BUTTON_STATUS_PRESSED);
2003
2004                         if (pOnOffSlidingOffHandlerPressedBitmap)
2005                         {
2006                                 pCanvas->DrawBitmap(FloatPoint(handlerPosition, __onOffSlidingButtonBounds.y - handlerMargin), *pOnOffSlidingOffHandlerPressedBitmap);
2007                         }
2008                 }
2009                 else if (checkStatus == _CHECK_BUTTON_STATUS_HIGHLIGHTED)
2010                 {
2011                         Bitmap* pOnOffSlidingHighlightedBgBitmap = __pCheckButton->GetOnOffSlidingBgBitmap(_CHECK_BUTTON_STATUS_HIGHLIGHTED);
2012
2013                         if (pOnOffSlidingHighlightedBgBitmap)
2014                         {
2015                                 pCanvas->DrawBitmap(FloatPoint(__onOffSlidingButtonBounds.x, __onOffSlidingButtonBounds.y), *pOnOffSlidingHighlightedBgBitmap);
2016                         }
2017
2018                         Bitmap* pOnOffSlidingOffHandlerNormalBitmap = __pCheckButton->GetOnOffSlidingOffHandlerBitmap(_CHECK_BUTTON_STATUS_NORMAL);
2019
2020                         if (pOnOffSlidingOffHandlerNormalBitmap)
2021                         {
2022                                 pCanvas->DrawBitmap(FloatPoint(handlerPosition, __onOffSlidingButtonBounds.y - handlerMargin), *pOnOffSlidingOffHandlerNormalBitmap);
2023                         }
2024
2025                         Bitmap* pOnOffSlidingOffHandlerHighlightedBitmap = __pCheckButton->GetOnOffSlidingOffHandlerBitmap(_CHECK_BUTTON_STATUS_HIGHLIGHTED);
2026
2027                         if (pOnOffSlidingOffHandlerHighlightedBitmap)
2028                         {
2029                                 pReColorBgBitmap = _BitmapImpl::GetColorReplacedBitmapN(*pOnOffSlidingOffHandlerHighlightedBitmap, Color::GetColor(COLOR_ID_MAGENTA),
2030                                                 detailedHighlightedBgColor);
2031                         }
2032
2033                         if (pReColorBgBitmap && __highlightedIndex == 1)
2034                         {
2035                                 pCanvas->DrawBitmap(FloatPoint(handlerPosition, __onOffSlidingButtonBounds.y - handlerMargin), *pReColorBgBitmap);
2036                         }
2037                 }
2038                 else if (checkStatus == _CHECK_BUTTON_STATUS_SELECTED)
2039                 {
2040                         Bitmap* pOnOffSlidingSelectedBgBitmap = __pCheckButton->GetOnOffSlidingBgBitmap(_CHECK_BUTTON_STATUS_SELECTED);
2041
2042                         if (pOnOffSlidingSelectedBgBitmap)
2043                         {
2044                                 pCanvas->DrawBitmap(FloatPoint(__onOffSlidingButtonBounds.x, __onOffSlidingButtonBounds.y), *pOnOffSlidingSelectedBgBitmap);
2045                         }
2046
2047                         Bitmap* pOnOffSlidingOffHandlerSelectedBitmap = __pCheckButton->GetOnOffSlidingOffHandlerBitmap(_CHECK_BUTTON_STATUS_SELECTED);
2048
2049                         if (pOnOffSlidingOffHandlerSelectedBitmap)
2050                         {
2051                                 pCanvas->DrawBitmap(FloatPoint(handlerPosition, __onOffSlidingButtonBounds.y - handlerMargin), *pOnOffSlidingOffHandlerSelectedBitmap);
2052                         }
2053                 }
2054         }
2055         else
2056         {
2057                 if (checkStatus == _CHECK_BUTTON_STATUS_NORMAL)
2058                 {
2059                         Bitmap* pOnOffSlidingNormalBgBitmap = __pCheckButton->GetOnOffSlidingBgBitmap(_CHECK_BUTTON_STATUS_NORMAL);
2060
2061                         if (pOnOffSlidingNormalBgBitmap)
2062                         {
2063                                 pCanvas->DrawBitmap(FloatPoint(__onOffSlidingButtonBounds.x, __onOffSlidingButtonBounds.y), *pOnOffSlidingNormalBgBitmap);
2064                         }
2065
2066                         Bitmap* pOnOffSlidingOnHandlerNormalBitmap = __pCheckButton->GetOnOffSlidingOnHandlerBitmap(_CHECK_BUTTON_STATUS_NORMAL);
2067
2068                         if (pOnOffSlidingOnHandlerNormalBitmap)
2069                         {
2070                                 pCanvas->DrawBitmap(FloatPoint(handlerPosition, __onOffSlidingButtonBounds.y - handlerMargin), *pOnOffSlidingOnHandlerNormalBitmap);
2071                         }
2072                 }
2073                 else if (checkStatus == _CHECK_BUTTON_STATUS_DISABLED)
2074                 {
2075                         Bitmap* pOnOffSlidingDisabledBgBitmap = __pCheckButton->GetOnOffSlidingBgBitmap(_CHECK_BUTTON_STATUS_DISABLED);
2076
2077                         if (pOnOffSlidingDisabledBgBitmap)
2078                         {
2079                                 pCanvas->DrawBitmap(FloatPoint(__onOffSlidingButtonBounds.x, __onOffSlidingButtonBounds.y), *pOnOffSlidingDisabledBgBitmap);
2080                         }
2081
2082                         Bitmap* pOnOffSlidingOnHandlerDisabledBitmap = __pCheckButton->GetOnOffSlidingOnHandlerBitmap(_CHECK_BUTTON_STATUS_DISABLED);
2083
2084                         if (pOnOffSlidingOnHandlerDisabledBitmap)
2085                         {
2086                                 pCanvas->DrawBitmap(FloatPoint(handlerPosition, __onOffSlidingButtonBounds.y - handlerMargin), *pOnOffSlidingOnHandlerDisabledBitmap);
2087                         }
2088                 }
2089                 else if (checkStatus == _CHECK_BUTTON_STATUS_PRESSED)
2090                 {
2091                         Bitmap* pOnOffSlidingPressedBgBitmap = __pCheckButton->GetOnOffSlidingBgBitmap(_CHECK_BUTTON_STATUS_PRESSED);
2092
2093                         if (pOnOffSlidingPressedBgBitmap)
2094                         {
2095                                 pCanvas->DrawBitmap(FloatPoint(__onOffSlidingButtonBounds.x, __onOffSlidingButtonBounds.y), *pOnOffSlidingPressedBgBitmap);
2096                         }
2097
2098                         Bitmap* pOnOffSlidingOnHandlerPressedBitmap = __pCheckButton->GetOnOffSlidingOnHandlerBitmap(_CHECK_BUTTON_STATUS_PRESSED);
2099
2100                         if (pOnOffSlidingOnHandlerPressedBitmap)
2101                         {
2102                                 pCanvas->DrawBitmap(FloatPoint(handlerPosition, __onOffSlidingButtonBounds.y - handlerMargin), *pOnOffSlidingOnHandlerPressedBitmap);
2103                         }
2104                 }
2105                 else if (checkStatus == _CHECK_BUTTON_STATUS_HIGHLIGHTED)
2106                 {
2107                         Bitmap* pOnOffSlidingHighlightedBgBitmap = __pCheckButton->GetOnOffSlidingBgBitmap(_CHECK_BUTTON_STATUS_HIGHLIGHTED);
2108
2109                         if (pOnOffSlidingHighlightedBgBitmap)
2110                         {
2111                                 pCanvas->DrawBitmap(FloatPoint(__onOffSlidingButtonBounds.x, __onOffSlidingButtonBounds.y), *pOnOffSlidingHighlightedBgBitmap);
2112                         }
2113
2114                         Bitmap* pOnOffSlidingOnHandlerNormalBitmap = __pCheckButton->GetOnOffSlidingOnHandlerBitmap(_CHECK_BUTTON_STATUS_NORMAL);
2115
2116                         if (pOnOffSlidingOnHandlerNormalBitmap)
2117                         {
2118                                 pCanvas->DrawBitmap(FloatPoint(handlerPosition, __onOffSlidingButtonBounds.y - handlerMargin), *pOnOffSlidingOnHandlerNormalBitmap);
2119                         }
2120
2121                         Bitmap* pOnOffSlidingOnHandlerHighlightedBitmap = __pCheckButton->GetOnOffSlidingOnHandlerBitmap(_CHECK_BUTTON_STATUS_HIGHLIGHTED);
2122
2123                         if (pOnOffSlidingOnHandlerHighlightedBitmap)
2124                         {
2125                                 pReColorBgBitmap = _BitmapImpl::GetColorReplacedBitmapN(*pOnOffSlidingOnHandlerHighlightedBitmap, Color::GetColor(COLOR_ID_MAGENTA),
2126                                                 detailedHighlightedBgColor);
2127                         }
2128
2129                         if (pReColorBgBitmap && __highlightedIndex == 1)
2130                         {
2131                                 pCanvas->DrawBitmap(FloatPoint(handlerPosition, __onOffSlidingButtonBounds.y - handlerMargin), *pReColorBgBitmap);
2132                         }
2133                 }
2134                 else if (checkStatus == _CHECK_BUTTON_STATUS_SELECTED)
2135                 {
2136                         Bitmap* pOnOffSlidingSelectedBgBitmap = __pCheckButton->GetOnOffSlidingBgBitmap(_CHECK_BUTTON_STATUS_SELECTED);
2137
2138                         if (pOnOffSlidingSelectedBgBitmap)
2139                         {
2140                                 pCanvas->DrawBitmap(FloatPoint(__onOffSlidingButtonBounds.x, __onOffSlidingButtonBounds.y), *pOnOffSlidingSelectedBgBitmap);
2141                         }
2142
2143                         Bitmap* pOnOffSlidingOnHandlerSelectedBitmap = __pCheckButton->GetOnOffSlidingOnHandlerBitmap(_CHECK_BUTTON_STATUS_SELECTED);
2144
2145                         if (pOnOffSlidingOnHandlerSelectedBitmap)
2146                         {
2147                                 pCanvas->DrawBitmap(FloatPoint(handlerPosition, __onOffSlidingButtonBounds.y - handlerMargin), *pOnOffSlidingOnHandlerSelectedBitmap);
2148                         }
2149                 }
2150         }
2151
2152         delete pCanvas;
2153         delete pReColorBgBitmap;
2154
2155         return;
2156 }
2157
2158 bool
2159 _CheckButtonPresenter::OnTouchCanceled(const _Control& source, const _TouchInfo& touchinfo)
2160 {
2161         if (&source != __pCheckButton)
2162         {
2163                 return false;
2164         }
2165
2166         if (!__pCheckButton->IsEnabled())
2167         {
2168                 return true;
2169         }
2170
2171         __pCheckButton->SetCheckButtonStatus(_CHECK_BUTTON_STATUS_NORMAL);
2172         __pCheckButton->Invalidate();
2173
2174         return true;
2175 }
2176
2177 void
2178 _CheckButtonPresenter::OnTouchMoveHandled(const _Control& control)
2179 {
2180         __touchMoveHandled = true;
2181         __pCheckButton->SetCheckButtonStatus(_CHECK_BUTTON_STATUS_NORMAL);
2182         __pCheckButton->Invalidate();
2183
2184         return;
2185 }
2186
2187 bool
2188 _CheckButtonPresenter::OnKeyPressed(const _Control& source, const _KeyInfo& keyInfo)
2189 {
2190         _KeyCode keyCode = keyInfo.GetKeyCode();
2191
2192         CheckButtonStyle checkStyle = __pCheckButton->GetCheckButtonStyle();
2193
2194         if (__pCheckButton->IsFocusModeStateEnabled() == true && keyCode == _KEY_ENTER)
2195         {
2196                 if (__pCheckButton->GetCheckButtonStatus() != _CHECK_BUTTON_STATUS_DISABLED)
2197                 {
2198                         if (checkStyle == CHECK_BUTTON_STYLE_ONOFF_SLIDING || checkStyle == CHECK_BUTTON_STYLE_ONOFF_SLIDING_WITH_DIVIDER)
2199                         {
2200                                 if (__highlightedIndex == 1)
2201                                 {
2202                                         __onOffHandlerPressed = true;
2203                                 }
2204                                 else
2205                                 {
2206                                         __pCheckButton->SetCheckButtonStatus(_CHECK_BUTTON_STATUS_PRESSED);
2207                                 }
2208                         }
2209                         else if (checkStyle == CHECK_BUTTON_STYLE_MARK_WITH_DETAILED_BUTTON)
2210                         {
2211                                 if (__highlightedIndex == 2)
2212                                 {
2213                                         __detailedPressed = true;
2214                                 }
2215                                 else
2216                                 {
2217                                         __pCheckButton->SetCheckButtonStatus(_CHECK_BUTTON_STATUS_PRESSED);
2218                                 }
2219                         }
2220                         else if (checkStyle == CHECK_BUTTON_STYLE_RADIO_WITH_DETAILED_BUTTON)
2221                         {
2222                                 if (__highlightedIndex == 1)
2223                                 {
2224                                         __detailedPressed = true;
2225                                 }
2226                                 else
2227                                 {
2228                                         __pCheckButton->SetCheckButtonStatus(_CHECK_BUTTON_STATUS_PRESSED);
2229                                 }
2230                         }
2231                         else
2232                         {
2233                                 __pCheckButton->SetCheckButtonStatus(_CHECK_BUTTON_STATUS_PRESSED);
2234                         }
2235                 }
2236         }
2237
2238         __pCheckButton->Invalidate();
2239
2240         return false;
2241 }
2242
2243 bool
2244 _CheckButtonPresenter::OnKeyReleased(const _Control& source, const _KeyInfo& keyInfo)
2245 {
2246         _KeyCode keyCode = keyInfo.GetKeyCode();
2247
2248         CheckButtonStyle checkStyle = __pCheckButton->GetCheckButtonStyle();
2249
2250         if (__pCheckButton->IsFocusModeStateEnabled() == true && keyCode == _KEY_LEFT)
2251         {
2252                 if (checkStyle == CHECK_BUTTON_STYLE_RADIO || checkStyle == CHECK_BUTTON_STYLE_RADIO_WITH_DIVIDER)
2253                 {
2254                         __highlightedIndex = 0;
2255                 }
2256                 else if (checkStyle == CHECK_BUTTON_STYLE_MARK_WITH_DETAILED_BUTTON)
2257                 {
2258                         if (__highlightedIndex == 0)
2259                         {
2260                                 __highlightedIndex = 1;
2261                         }
2262                         else if (__highlightedIndex == 1)
2263                         {
2264                                 __highlightedIndex = 2;
2265                         }
2266                         else if (__highlightedIndex == 2)
2267                         {
2268                                 __highlightedIndex = 0;
2269                         }
2270                 }
2271                 else
2272                 {
2273                         if (__highlightedIndex == 0)
2274                         {
2275                                 __highlightedIndex = 1;
2276                         }
2277                         else if (__highlightedIndex == 1)
2278                         {
2279                                 __highlightedIndex = 0;
2280                         }
2281                 }
2282
2283                 __pCheckButton->Invalidate();
2284         }
2285         else if (__pCheckButton->IsFocusModeStateEnabled() == true && keyCode == _KEY_RIGHT)
2286         {
2287                 if (checkStyle == CHECK_BUTTON_STYLE_RADIO || checkStyle == CHECK_BUTTON_STYLE_RADIO_WITH_DIVIDER)
2288                 {
2289                         __highlightedIndex = 0;
2290                 }
2291                 else if (checkStyle == CHECK_BUTTON_STYLE_MARK_WITH_DETAILED_BUTTON)
2292                 {
2293                         if (__highlightedIndex == 0)
2294                         {
2295                                 __highlightedIndex = 2;
2296                         }
2297                         else if (__highlightedIndex == 1)
2298                         {
2299                                 __highlightedIndex = 0;
2300                         }
2301                         else if (__highlightedIndex == 2)
2302                         {
2303                                 __highlightedIndex = 1;
2304                         }
2305                 }
2306                 else
2307                 {
2308                         if (__highlightedIndex == 0)
2309                         {
2310                                 __highlightedIndex = 1;
2311                         }
2312                         else if (__highlightedIndex == 1)
2313                         {
2314                                 __highlightedIndex = 0;
2315                         }
2316                 }
2317
2318                 __pCheckButton->Invalidate();
2319         }
2320         else if (__pCheckButton->IsFocusModeStateEnabled() == true && keyCode == _KEY_ENTER)
2321         {
2322                 if (checkStyle == CHECK_BUTTON_STYLE_MARK || checkStyle == CHECK_BUTTON_STYLE_MARK_WITH_DIVIDER || checkStyle == CHECK_BUTTON_STYLE_MARK_WITH_DETAILED_BUTTON
2323                                 || checkStyle == CHECK_BUTTON_STYLE_RADIO || checkStyle == CHECK_BUTTON_STYLE_RADIO_WITH_DIVIDER || checkStyle == CHECK_BUTTON_STYLE_RADIO_WITH_DETAILED_BUTTON)
2324                 {
2325                         StartCheckAnimationTimer();
2326                         __ratio = 0;
2327                 }
2328
2329                 __pCheckButton->SetCheckButtonStatus(_CHECK_BUTTON_STATUS_NORMAL);
2330                 __pCheckButton->Invalidate();
2331
2332                 __pCheckButton->SetCheckButtonStatus(_CHECK_BUTTON_STATUS_HIGHLIGHTED);
2333
2334                 if (checkStyle == CHECK_BUTTON_STYLE_MARK_WITH_DETAILED_BUTTON)
2335                 {
2336                         if (__highlightedIndex != 2)
2337                         {
2338                                 PLAY_FEEDBACK(_RESOURCE_FEEDBACK_PATTERN_TAP, __pCheckButton);
2339
2340                                 __pCheckButton->FireActionEvent();
2341
2342                                 if (__pCheckButton->GetRadioGroup() != null)
2343                                 {
2344                                         __pCheckButton->SendTouchReleasedEvent(*__pCheckButton);
2345                                 }
2346                         }
2347                         else
2348                         {
2349                                 __detailedPressed = false;
2350                         }
2351                 }
2352                 else if (checkStyle == CHECK_BUTTON_STYLE_RADIO_WITH_DETAILED_BUTTON)
2353                 {
2354                         if (__highlightedIndex != 1)
2355                         {
2356                                 PLAY_FEEDBACK(_RESOURCE_FEEDBACK_PATTERN_TAP, __pCheckButton);
2357
2358                                 __pCheckButton->FireActionEvent();
2359
2360                                 if (__pCheckButton->GetRadioGroup() != null)
2361                                 {
2362                                         __pCheckButton->SendTouchReleasedEvent(*__pCheckButton);
2363                                 }
2364                         }
2365                         else
2366                         {
2367                                 __detailedPressed = false;
2368                         }
2369                 }
2370                 else if (checkStyle == CHECK_BUTTON_STYLE_ONOFF_SLIDING_WITH_DIVIDER || checkStyle == CHECK_BUTTON_STYLE_ONOFF_SLIDING)
2371                 {
2372                         PLAY_FEEDBACK(_RESOURCE_FEEDBACK_PATTERN_TAP, __pCheckButton);
2373
2374                         __pCheckButton->FireActionEvent();
2375
2376                         if (__pCheckButton->GetRadioGroup() != null)
2377                         {
2378                                 __pCheckButton->SendTouchReleasedEvent(*__pCheckButton);
2379                         }
2380
2381                         AdjustHandlerPosition();
2382
2383                         __onOffHandlerPressed = false;
2384                         __onOffHandlerMoved = false;
2385                 }
2386                 else
2387                 {
2388                         PLAY_FEEDBACK(_RESOURCE_FEEDBACK_PATTERN_TAP, __pCheckButton);
2389
2390                         __pCheckButton->FireActionEvent();
2391
2392                         if (__pCheckButton->GetRadioGroup() != null)
2393                         {
2394                                 __pCheckButton->SendTouchReleasedEvent(*__pCheckButton);
2395                         }
2396                 }
2397         }
2398
2399         return false;
2400 }
2401
2402 bool
2403 _CheckButtonPresenter::IsEnabledStateChanged(void)
2404 {
2405         bool __currentEnabledState = __pCheckButton->GetEnableState();
2406
2407         if (__currentEnabledState != __previousEnabledState)
2408         {
2409                 __previousEnabledState = __currentEnabledState;
2410                 return true;
2411         }
2412         else
2413         {
2414                 return false;
2415         }
2416 }
2417
2418 result
2419 _CheckButtonPresenter::CalculateTitleTextBounds(void)
2420 {
2421         float checkButtonLeftMargin = 0.0f;
2422         float checkButtonTopMargin = 0.0f;
2423         float checkButtonBitmapWidth = 0.0f;
2424         float checkButtonOnOffSlidingBitmapWidth = 0.0f;
2425         float checkButtonDetailedBitmapWidth = 0.0f;
2426         float checkButtonTitleTextHeight = 0.0f;
2427         float checkButtonTextHeight = 0.0f;
2428
2429         FloatDimension minDimension(0.0f, 0.0f);
2430         FloatDimension minDimensionWithAnnex(0.0f, 0.0f);
2431
2432         GET_SHAPE_CONFIG(CHECKBUTTON::LEFT_MARGIN, _CONTROL_ORIENTATION_PORTRAIT, checkButtonLeftMargin);
2433         GET_SHAPE_CONFIG(CHECKBUTTON::TOP_MARGIN, _CONTROL_ORIENTATION_PORTRAIT, checkButtonTopMargin);
2434         GET_SHAPE_CONFIG(CHECKBUTTON::MARK_BITMAP_WIDTH, _CONTROL_ORIENTATION_PORTRAIT, checkButtonBitmapWidth);
2435         GET_SHAPE_CONFIG(CHECKBUTTON::ONOFF_SLIDING_BITMAP_WIDTH, _CONTROL_ORIENTATION_PORTRAIT, checkButtonOnOffSlidingBitmapWidth);
2436         GET_SHAPE_CONFIG(CHECKBUTTON::DETAILED_BITMAP_WIDTH, _CONTROL_ORIENTATION_PORTRAIT, checkButtonDetailedBitmapWidth);
2437         GET_SHAPE_CONFIG(CHECKBUTTON::TITLE_TEXT_HEIGHT, _CONTROL_ORIENTATION_PORTRAIT, checkButtonTitleTextHeight);
2438         GET_SHAPE_CONFIG(CHECKBUTTON::TEXT_HEIGHT, _CONTROL_ORIENTATION_PORTRAIT, checkButtonTextHeight);
2439
2440         GET_DIMENSION_CONFIG(CHECKBUTTON::MIN_DIMENSION, __pCheckButton->GetOrientation(), minDimension);
2441         GET_DIMENSION_CONFIG(CHECKBUTTON::MIN_DIMENSION_WITH_ANNEX, __pCheckButton->GetOrientation(), minDimensionWithAnnex);
2442
2443         FloatRectangle bounds(0.0f, 0.0f, __pCheckButton->GetBoundsF().width, __pCheckButton->GetBoundsF().height);
2444
2445         CheckButtonStyle checkStyle = __pCheckButton->GetCheckButtonStyle();
2446
2447         if (checkStyle == CHECK_BUTTON_STYLE_MARK || checkStyle == CHECK_BUTTON_STYLE_MARK_WITH_DIVIDER || checkStyle == CHECK_BUTTON_STYLE_ONOFF
2448                         || checkStyle == CHECK_BUTTON_STYLE_ONOFF_WITH_DIVIDER || checkStyle == CHECK_BUTTON_STYLE_RADIO || checkStyle == CHECK_BUTTON_STYLE_RADIO_WITH_DIVIDER)
2449         {
2450                 if (bounds.width < minDimension.width )
2451                 {
2452                         bounds.width = minDimension.width;
2453                 }
2454
2455                 if (bounds.height < minDimension.height )
2456                 {
2457                         bounds.height = minDimension.height;
2458                 }
2459         }
2460         else
2461         {
2462                 if (bounds.width < minDimensionWithAnnex.width )
2463                 {
2464                         bounds.width = minDimensionWithAnnex.width;
2465                 }
2466
2467                 if (bounds.height < minDimensionWithAnnex.height )
2468                 {
2469                         bounds.height = minDimensionWithAnnex.height;
2470                 }
2471         }
2472
2473         if (checkStyle == CHECK_BUTTON_STYLE_ONOFF_SLIDING || checkStyle == CHECK_BUTTON_STYLE_ONOFF_SLIDING_WITH_DIVIDER)
2474         {
2475                 __titleTextBounds.x = checkButtonLeftMargin;
2476                 __titleTextBounds.y = checkButtonTopMargin;
2477                 __titleTextBounds.width = bounds.width - checkButtonLeftMargin * 3 - checkButtonOnOffSlidingBitmapWidth;
2478                 __titleTextBounds.height = bounds.height - checkButtonTopMargin * 2 - __textBounds.height;
2479         }
2480         else
2481         {
2482                 if (checkStyle == CHECK_BUTTON_STYLE_MARK_WITH_DETAILED_BUTTON || checkStyle == CHECK_BUTTON_STYLE_RADIO_WITH_DETAILED_BUTTON)
2483                 {
2484                         __titleTextBounds.x = checkButtonLeftMargin * 2 + checkButtonBitmapWidth;
2485                         __titleTextBounds.y = checkButtonTopMargin;
2486                         __titleTextBounds.width = bounds.width - checkButtonLeftMargin * 4 - checkButtonBitmapWidth - checkButtonDetailedBitmapWidth;
2487                         __titleTextBounds.height = bounds.height - checkButtonTopMargin * 2 - __textBounds.height;
2488                 }
2489                 else
2490                 {
2491                         __titleTextBounds.x = checkButtonLeftMargin * 2 + checkButtonBitmapWidth;
2492                         __titleTextBounds.y = checkButtonTopMargin;
2493                         __titleTextBounds.width = bounds.width - checkButtonLeftMargin * 3 - checkButtonBitmapWidth;
2494                         __titleTextBounds.height = bounds.height - checkButtonTopMargin * 2 - __textBounds.height;
2495                 }
2496         }
2497
2498         return E_SUCCESS;
2499 }
2500
2501 result
2502 _CheckButtonPresenter::CalculateTextBounds(void)
2503 {
2504         float checkButtonLeftMargin = 0.0f;
2505         float checkButtonTopMargin = 0.0f;
2506         float checkButtonBitmapWidth = 0.0f;
2507         float checkButtonOnOffSlidingBitmapWidth = 0.0f;
2508         float checkButtonDetailedBitmapWidth = 0.0f;
2509         float checkButtonTitleTextHeight = 0.0f;
2510         float checkButtonTextHeight = 0.0f;
2511
2512         FloatDimension minDimension(0.0f, 0.0f);
2513         FloatDimension minDimensionWithAnnex(0.0f, 0.0f);
2514
2515         GET_SHAPE_CONFIG(CHECKBUTTON::LEFT_MARGIN, _CONTROL_ORIENTATION_PORTRAIT, checkButtonLeftMargin);
2516         GET_SHAPE_CONFIG(CHECKBUTTON::TOP_MARGIN, _CONTROL_ORIENTATION_PORTRAIT, checkButtonTopMargin);
2517         GET_SHAPE_CONFIG(CHECKBUTTON::MARK_BITMAP_WIDTH, _CONTROL_ORIENTATION_PORTRAIT, checkButtonBitmapWidth);
2518         GET_SHAPE_CONFIG(CHECKBUTTON::ONOFF_SLIDING_BITMAP_WIDTH, _CONTROL_ORIENTATION_PORTRAIT, checkButtonOnOffSlidingBitmapWidth);
2519         GET_SHAPE_CONFIG(CHECKBUTTON::DETAILED_BITMAP_WIDTH, _CONTROL_ORIENTATION_PORTRAIT, checkButtonDetailedBitmapWidth);
2520         GET_SHAPE_CONFIG(CHECKBUTTON::TITLE_TEXT_HEIGHT, _CONTROL_ORIENTATION_PORTRAIT, checkButtonTitleTextHeight);
2521         GET_SHAPE_CONFIG(CHECKBUTTON::TEXT_HEIGHT, _CONTROL_ORIENTATION_PORTRAIT, checkButtonTextHeight);
2522
2523         GET_DIMENSION_CONFIG(CHECKBUTTON::MIN_DIMENSION, __pCheckButton->GetOrientation(), minDimension);
2524         GET_DIMENSION_CONFIG(CHECKBUTTON::MIN_DIMENSION_WITH_ANNEX, __pCheckButton->GetOrientation(), minDimensionWithAnnex);
2525
2526         FloatRectangle bounds(0.0f, 0.0f, __pCheckButton->GetBoundsF().width, __pCheckButton->GetBoundsF().height);
2527
2528         CheckButtonStyle checkStyle = __pCheckButton->GetCheckButtonStyle();
2529         bool showTitle = __pCheckButton->GetShowTitle();
2530
2531         if (checkStyle == CHECK_BUTTON_STYLE_MARK || checkStyle == CHECK_BUTTON_STYLE_MARK_WITH_DIVIDER || checkStyle == CHECK_BUTTON_STYLE_ONOFF
2532                         || checkStyle == CHECK_BUTTON_STYLE_ONOFF_WITH_DIVIDER || checkStyle == CHECK_BUTTON_STYLE_RADIO || checkStyle == CHECK_BUTTON_STYLE_RADIO_WITH_DIVIDER)
2533         {
2534                 if (bounds.width < minDimension.width )
2535                 {
2536                         bounds.width = minDimension.width;
2537                 }
2538
2539                 if (bounds.height < minDimension.height )
2540                 {
2541                         bounds.height = minDimension.height;
2542                 }
2543         }
2544         else
2545         {
2546                 if (bounds.width < minDimensionWithAnnex.width )
2547                 {
2548                         bounds.width = minDimensionWithAnnex.width;
2549                 }
2550
2551                 if (bounds.height < minDimensionWithAnnex.height )
2552                 {
2553                         bounds.height = minDimensionWithAnnex.height;
2554                 }
2555         }
2556
2557         if (checkStyle == CHECK_BUTTON_STYLE_ONOFF_SLIDING || checkStyle == CHECK_BUTTON_STYLE_ONOFF_SLIDING_WITH_DIVIDER)
2558         {
2559                 if (showTitle)
2560                 {
2561                         __textBounds.x = checkButtonLeftMargin;
2562                         __textBounds.y = checkButtonTopMargin + checkButtonTitleTextHeight;
2563                         __textBounds.width = bounds.width - checkButtonLeftMargin * 3 - checkButtonOnOffSlidingBitmapWidth;
2564                         __textBounds.height = bounds.height - checkButtonTopMargin * 2 - checkButtonTitleTextHeight;
2565                 }
2566                 else
2567                 {
2568                         __textBounds.x = checkButtonLeftMargin;
2569                         __textBounds.y = checkButtonTopMargin;
2570                         __textBounds.width = bounds.width - checkButtonLeftMargin * 3 - checkButtonOnOffSlidingBitmapWidth;
2571                         __textBounds.height = bounds.height - checkButtonTopMargin * 2;
2572                 }
2573         }
2574         else
2575         {
2576                 if (checkStyle == CHECK_BUTTON_STYLE_MARK_WITH_DETAILED_BUTTON || checkStyle == CHECK_BUTTON_STYLE_RADIO_WITH_DETAILED_BUTTON)
2577                 {
2578                         if (showTitle)
2579                         {
2580                                 __textBounds.x = checkButtonLeftMargin * 2 + checkButtonBitmapWidth;
2581                                 __textBounds.y = checkButtonTopMargin + checkButtonTitleTextHeight;
2582                                 __textBounds.width = bounds.width - checkButtonLeftMargin * 4 - checkButtonBitmapWidth - checkButtonDetailedBitmapWidth;
2583                                 __textBounds.height = bounds.height - checkButtonTopMargin * 2 - checkButtonTitleTextHeight;
2584                         }
2585                         else
2586                         {
2587                                 __textBounds.x = checkButtonLeftMargin * 2 + checkButtonBitmapWidth;
2588                                 __textBounds.y = checkButtonTopMargin;
2589                                 __textBounds.width = bounds.width - checkButtonLeftMargin * 4 - checkButtonBitmapWidth - checkButtonDetailedBitmapWidth;
2590                                 __textBounds.height = bounds.height - checkButtonTopMargin * 2;
2591                         }
2592                 }
2593                 else
2594                 {
2595                         if (showTitle)
2596                         {
2597                                 __textBounds.x = checkButtonLeftMargin * 2 + checkButtonBitmapWidth;
2598                                 __textBounds.y = checkButtonTopMargin + checkButtonTitleTextHeight;
2599                                 __textBounds.width = bounds.width - checkButtonLeftMargin * 3 - checkButtonBitmapWidth;
2600                                 __textBounds.height = bounds.height - checkButtonTopMargin * 2 - checkButtonTitleTextHeight;
2601                         }
2602                         else
2603                         {
2604                                 __textBounds.x = checkButtonLeftMargin * 2 + checkButtonBitmapWidth;
2605                                 __textBounds.y = checkButtonTopMargin;
2606                                 __textBounds.width = bounds.width - checkButtonLeftMargin * 3 - checkButtonBitmapWidth;
2607                                 __textBounds.height = bounds.height - checkButtonTopMargin * 2;
2608                         }
2609                 }
2610         }
2611
2612         return E_SUCCESS;
2613 }
2614
2615 result
2616 _CheckButtonPresenter::CalculateButtonBounds(void)
2617 {
2618         float checkButtonLeftMargin = 0.0f;
2619         float checkButtonBitmapWidth = 0.0f;
2620         float checkButtonBitmapHeight = 0.0f;
2621         float checkButtonOnOffSlidingBitmapWidth = 0.0f;
2622         float checkButtonOnOffSlidingBitmapHeight = 0.0f;
2623         float checkButtonDetaieldBitmapWidth = 0.0f;
2624         float checkButtonDetaieldBitmapHeight = 0.0f;
2625
2626         FloatDimension minDimension(0.0f, 0.0f);
2627         FloatDimension minDimensionWithAnnex(0.0f, 0.0f);
2628
2629         GET_SHAPE_CONFIG(CHECKBUTTON::LEFT_MARGIN, _CONTROL_ORIENTATION_PORTRAIT, checkButtonLeftMargin);
2630         GET_SHAPE_CONFIG(CHECKBUTTON::MARK_BITMAP_WIDTH, _CONTROL_ORIENTATION_PORTRAIT, checkButtonBitmapWidth);
2631         GET_SHAPE_CONFIG(CHECKBUTTON::MARK_BITMAP_HEIGHT, _CONTROL_ORIENTATION_PORTRAIT, checkButtonBitmapHeight);
2632         GET_SHAPE_CONFIG(CHECKBUTTON::ONOFF_SLIDING_BITMAP_WIDTH, _CONTROL_ORIENTATION_PORTRAIT, checkButtonOnOffSlidingBitmapWidth);
2633         GET_SHAPE_CONFIG(CHECKBUTTON::ONOFF_SLIDING_BITMAP_HEIGHT, _CONTROL_ORIENTATION_PORTRAIT, checkButtonOnOffSlidingBitmapHeight);
2634         GET_SHAPE_CONFIG(CHECKBUTTON::DETAILED_BITMAP_WIDTH, _CONTROL_ORIENTATION_PORTRAIT, checkButtonDetaieldBitmapWidth);
2635         GET_SHAPE_CONFIG(CHECKBUTTON::DETAILED_BITMAP_HEIGHT, _CONTROL_ORIENTATION_PORTRAIT, checkButtonDetaieldBitmapHeight);
2636
2637         GET_DIMENSION_CONFIG(CHECKBUTTON::MIN_DIMENSION, __pCheckButton->GetOrientation(), minDimension);
2638         GET_DIMENSION_CONFIG(CHECKBUTTON::MIN_DIMENSION_WITH_ANNEX, __pCheckButton->GetOrientation(), minDimensionWithAnnex);
2639
2640         FloatRectangle bounds(0.0f, 0.0f, __pCheckButton->GetBoundsF().width, __pCheckButton->GetBoundsF().height);
2641
2642         CheckButtonStyle checkStyle = __pCheckButton->GetCheckButtonStyle();
2643
2644         if (checkStyle == CHECK_BUTTON_STYLE_MARK || checkStyle == CHECK_BUTTON_STYLE_MARK_WITH_DIVIDER || checkStyle == CHECK_BUTTON_STYLE_ONOFF
2645                         || checkStyle == CHECK_BUTTON_STYLE_ONOFF_WITH_DIVIDER || checkStyle == CHECK_BUTTON_STYLE_RADIO || checkStyle == CHECK_BUTTON_STYLE_RADIO_WITH_DIVIDER)
2646         {
2647                 if (bounds.width < minDimension.width )
2648                 {
2649                         bounds.width = minDimension.width;
2650                 }
2651
2652                 if (bounds.height < minDimension.height )
2653                 {
2654                         bounds.height = minDimension.height;
2655                 }
2656         }
2657         else
2658         {
2659                 if (bounds.width < minDimensionWithAnnex.width )
2660                 {
2661                         bounds.width = minDimensionWithAnnex.width;
2662                 }
2663
2664                 if (bounds.height < minDimensionWithAnnex.height )
2665                 {
2666                         bounds.height = minDimensionWithAnnex.height;
2667                 }
2668         }
2669
2670         __defaultButtonBounds.x = checkButtonLeftMargin;
2671         __defaultButtonBounds.y = (bounds.height - checkButtonBitmapHeight) / 2;
2672         __defaultButtonBounds.width = checkButtonBitmapWidth;
2673         __defaultButtonBounds.height = checkButtonBitmapHeight;
2674
2675         __onOffSlidingButtonBounds.x = bounds.width - checkButtonLeftMargin - checkButtonOnOffSlidingBitmapWidth;
2676         __onOffSlidingButtonBounds.y = (bounds.height - checkButtonOnOffSlidingBitmapHeight) / 2;
2677         __onOffSlidingButtonBounds.width = checkButtonOnOffSlidingBitmapWidth;
2678         __onOffSlidingButtonBounds.height = checkButtonOnOffSlidingBitmapHeight;
2679
2680         __detailedButtonBounds.x = bounds.width - checkButtonLeftMargin - checkButtonDetaieldBitmapWidth;
2681         __detailedButtonBounds.y = (bounds.height - checkButtonDetaieldBitmapHeight) / 2;
2682         __detailedButtonBounds.width = checkButtonDetaieldBitmapWidth;
2683         __detailedButtonBounds.height = checkButtonDetaieldBitmapHeight;
2684
2685         return E_SUCCESS;
2686 }
2687
2688 FloatRectangle
2689 _CheckButtonPresenter::GetTitleTextBoundsF(void) const
2690 {
2691         return __titleTextBounds;
2692 }
2693
2694 FloatRectangle
2695 _CheckButtonPresenter::GetTextBoundsF(void) const
2696 {
2697         return __textBounds;
2698 }
2699
2700 FloatRectangle
2701 _CheckButtonPresenter::GetDefaultButtonBoundsF(void) const
2702 {
2703         return __defaultButtonBounds;
2704 }
2705
2706 FloatRectangle
2707 _CheckButtonPresenter::GetOnOffSlidingButtonBoundsF(void) const
2708 {
2709         return __onOffSlidingButtonBounds;
2710 }
2711
2712 FloatRectangle
2713 _CheckButtonPresenter::GetDetailedButtonBoundsF(void) const
2714 {
2715         return __detailedButtonBounds;
2716 }
2717
2718 result
2719 _CheckButtonPresenter::StartCheckAnimationTimer(void)
2720 {
2721         result r = E_SUCCESS;
2722         if (__pCheckAnimationTimer == null)
2723         {
2724                 __pCheckAnimationTimer = new (std::nothrow) Timer;
2725                 SysTryReturn(NID_UI_CTRL, (__pCheckAnimationTimer != null), E_OUT_OF_MEMORY, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] Memroy allocation failed.");
2726
2727                 r = __pCheckAnimationTimer->Construct(*this);
2728                 SysTryCatch(NID_UI, r == E_SUCCESS, , r, "[%s] Propagating.", GetErrorMessage(r));
2729         }
2730         else
2731         {
2732                 __pCheckAnimationTimer->Cancel();
2733         }
2734
2735         __pCheckAnimationTimer->Start(CHECK_ACTION_TIMER_PERIOD);
2736         SysTryCatch(NID_UI, r == E_SUCCESS, , r, "[%s] Propagating.", GetErrorMessage(r));
2737
2738         return r;
2739 CATCH:
2740         ResetCheckAnimationTimer();
2741         return r;
2742 }
2743
2744 result
2745 _CheckButtonPresenter::ResetCheckAnimationTimer(void)
2746 {
2747         delete __pCheckAnimationTimer;
2748         __pCheckAnimationTimer = null;
2749
2750         return E_SUCCESS;
2751 }
2752
2753 void
2754 _CheckButtonPresenter::OnTimerExpired(Timer& timer)
2755 {
2756         __ratio++;
2757
2758         if (__ratio <= RATIO_MAX)
2759         {
2760                 StartCheckAnimationTimer();
2761                 DrawMarkAnimation();
2762         }
2763         else
2764         {
2765                 ResetCheckAnimationTimer();
2766                 __ratio = 10;
2767         }
2768
2769         return;
2770 }
2771
2772 void
2773 _CheckButtonPresenter::OnDrawFocus(void)
2774 {
2775         if (__pCheckButton->GetCheckButtonStatus() != _CHECK_BUTTON_STATUS_DISABLED)
2776         {
2777                 __pCheckButton->SetCheckButtonStatus(_CHECK_BUTTON_STATUS_HIGHLIGHTED);
2778                 __pCheckButton->Invalidate();
2779         }
2780
2781         return;
2782 }
2783
2784 void
2785 _CheckButtonPresenter::OnChildControlFocusMoved(const _Control& control)
2786 {
2787         return;
2788 }
2789
2790 bool
2791 _CheckButtonPresenter::IsChildControlFocusManage(void) const
2792 {
2793         return true;
2794 }
2795
2796 void
2797 _CheckButtonPresenter::OnFocusableStateChanged(bool focusalbeState)
2798 {
2799         return;
2800 }
2801
2802 void
2803 _CheckButtonPresenter::OnFocusModeStateChanged(void)
2804 {
2805         if (__pCheckButton->GetCheckButtonStatus() != _CHECK_BUTTON_STATUS_DISABLED)
2806         {
2807                 __pCheckButton->SetCheckButtonStatus(_CHECK_BUTTON_STATUS_NORMAL);
2808                 __pCheckButton->Invalidate();
2809         }
2810
2811         return;
2812 }
2813
2814 bool
2815 _CheckButtonPresenter::OnFocusGained(const _Control& source)
2816 {
2817         __highlightedIndex = 0;
2818
2819         if (__pCheckButton->IsFocusModeStateEnabled() == true)
2820         {
2821                 if (__pCheckButton->GetCheckButtonStatus() != _CHECK_BUTTON_STATUS_DISABLED)
2822                 {
2823                         __pCheckButton->SetCheckButtonStatus(_CHECK_BUTTON_STATUS_HIGHLIGHTED);
2824                         __pCheckButton->Invalidate();
2825                 }
2826         }
2827
2828         return true;
2829 }
2830
2831 bool
2832 _CheckButtonPresenter::OnFocusLost(const _Control& source)
2833 {
2834         if (__pCheckButton->GetCheckButtonStatus() != _CHECK_BUTTON_STATUS_DISABLED)
2835         {
2836                 __pCheckButton->SetCheckButtonStatus(_CHECK_BUTTON_STATUS_NORMAL);
2837                 __pCheckButton->Invalidate();
2838         }
2839
2840         return true;
2841 }
2842 void
2843 _CheckButtonPresenter::DrawMarkAnimation(void)
2844 {
2845         Canvas* pCanvas = __pCheckButton->GetCanvasN();
2846         if (pCanvas == null)
2847         {
2848                 SysLog(NID_UI_CTRL, "Cannot get a canvas.");
2849
2850                 return;
2851         }
2852
2853         _CheckButtonStatus checkStatus = __pCheckButton->GetCheckButtonStatus();
2854
2855         if (checkStatus == _CHECK_BUTTON_STATUS_NORMAL)
2856         {
2857                 Bitmap* pMarkNormalBitmap = __pCheckButton->GetMarkBitmap(_CHECK_BUTTON_STATUS_NORMAL);
2858
2859                 if (__pCheckButton->IsSelected() && pMarkNormalBitmap)
2860                 {
2861                         FloatRectangle sourceRect(0.0f, 0.0f, pMarkNormalBitmap->GetWidthF() * __ratio * 0.1, pMarkNormalBitmap->GetHeightF());
2862                         FloatRectangle destRect(__defaultButtonBounds.x, __defaultButtonBounds.y, pMarkNormalBitmap->GetWidthF() * __ratio * 0.1, pMarkNormalBitmap->GetHeightF());
2863
2864                         pCanvas->DrawBitmap(destRect, *pMarkNormalBitmap, sourceRect);
2865                 }
2866         }
2867         else if (checkStatus == _CHECK_BUTTON_STATUS_DISABLED)
2868         {
2869                 Bitmap* pMarkDisabledBitmap = __pCheckButton->GetMarkBitmap(_CHECK_BUTTON_STATUS_DISABLED);
2870
2871                 if (__pCheckButton->IsSelected() && pMarkDisabledBitmap)
2872                 {
2873                         FloatRectangle sourceRect(0.0f, 0.0f, pMarkDisabledBitmap->GetWidthF() * __ratio * 0.1, pMarkDisabledBitmap->GetHeightF());
2874                         FloatRectangle destRect(__defaultButtonBounds.x, __defaultButtonBounds.y, pMarkDisabledBitmap->GetWidthF() * __ratio * 0.1, pMarkDisabledBitmap->GetHeightF());
2875
2876                         pCanvas->DrawBitmap(destRect, *pMarkDisabledBitmap, sourceRect);
2877                 }
2878         }
2879         else if (checkStatus == _CHECK_BUTTON_STATUS_PRESSED)
2880         {
2881                 Bitmap* pMarkPressedBitmap = __pCheckButton->GetMarkBitmap(_CHECK_BUTTON_STATUS_PRESSED);
2882
2883                 if (__pCheckButton->IsSelected() && pMarkPressedBitmap)
2884                 {
2885                         FloatRectangle sourceRect(0.0f, 0.0f, pMarkPressedBitmap->GetWidthF() * __ratio * 0.1, pMarkPressedBitmap->GetHeightF());
2886                         FloatRectangle destRect(__defaultButtonBounds.x, __defaultButtonBounds.y, pMarkPressedBitmap->GetWidthF() * __ratio * 0.1, pMarkPressedBitmap->GetHeightF());
2887
2888                         pCanvas->DrawBitmap(destRect, *pMarkPressedBitmap, sourceRect);
2889                 }
2890         }
2891         else if (checkStatus == _CHECK_BUTTON_STATUS_HIGHLIGHTED)
2892         {
2893                 Bitmap* pMarkHighlightedBitmap = __pCheckButton->GetMarkBitmap(_CHECK_BUTTON_STATUS_HIGHLIGHTED);
2894
2895                 if (__pCheckButton->IsSelected() && pMarkHighlightedBitmap)
2896                 {
2897                         FloatRectangle sourceRect(0.0f, 0.0f, pMarkHighlightedBitmap->GetWidthF() * __ratio * 0.1, pMarkHighlightedBitmap->GetHeightF());
2898                         FloatRectangle destRect(__defaultButtonBounds.x, __defaultButtonBounds.y, pMarkHighlightedBitmap->GetWidthF() * __ratio * 0.1, pMarkHighlightedBitmap->GetHeightF());
2899
2900                         pCanvas->DrawBitmap(destRect, *pMarkHighlightedBitmap, sourceRect);
2901                 }
2902         }
2903         else if (checkStatus == _CHECK_BUTTON_STATUS_SELECTED)
2904         {
2905                 Bitmap* pMarkSelectedBitmap = __pCheckButton->GetMarkBitmap(_CHECK_BUTTON_STATUS_SELECTED);
2906
2907                 if (__pCheckButton->IsSelected() && pMarkSelectedBitmap)
2908                 {
2909                         FloatRectangle sourceRect(0.0f, 0.0f, pMarkSelectedBitmap->GetWidthF() * __ratio * 0.1, pMarkSelectedBitmap->GetHeightF());
2910                         FloatRectangle destRect(__defaultButtonBounds.x, __defaultButtonBounds.y, pMarkSelectedBitmap->GetWidthF() * __ratio * 0.1, pMarkSelectedBitmap->GetHeightF());
2911
2912                         pCanvas->DrawBitmap(destRect, *pMarkSelectedBitmap, sourceRect);
2913                 }
2914         }
2915
2916         delete pCanvas;
2917
2918         return;
2919 }
2920
2921 }}} // Tizen::Ui::Controls