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