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