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
 582         return;
 583 }
 584
 585 void
 586 _CheckButtonPresenter::DrawCheckBitmap(void)
 587 {
 588         Canvas* pCanvas = __pCheckButton->GetCanvasN();
 589         if (pCanvas == null)
 590         {
 591                 SysLog(NID_UI_CTRL, "Cannot get a canvas.");
 592
 593                 return;
 594         }
 595
 596         Color detailedNormalBackgroundColor;
 597         Color detailedDisabledBackgroundColor;
 598         Color detailedPressedBackgroundColor;
 599         Color detailedHighlightedBackgroundColor;
 600         Color detailedSelectedBackgroundColor;
 601
 602         Color detailedRightNormalColor;
 603         Color detailedRightDisabledColor;
 604         Color detailedRightPressedColor;
 605         Color detailedRightHighlightedColor;
 606         Color detailedRightSelectedColor;
 607
 608         GET_COLOR_CONFIG(CHECKBUTTON::DETAILED_ICON_BG_NORMAL, detailedNormalBackgroundColor);
 609         GET_COLOR_CONFIG(CHECKBUTTON::DETAILED_ICON_BG_DISABLED, detailedDisabledBackgroundColor);
 610         GET_COLOR_CONFIG(CHECKBUTTON::DETAILED_ICON_BG_PRESSED, detailedPressedBackgroundColor);
 611         GET_COLOR_CONFIG(CHECKBUTTON::DETAILED_ICON_BG_HIGHLIGHTED, detailedHighlightedBackgroundColor);
 612         GET_COLOR_CONFIG(CHECKBUTTON::DETAILED_ICON_BG_SELECTED, detailedSelectedBackgroundColor);
 613
 614         GET_COLOR_CONFIG(CHECKBUTTON::DETAILED_ICON_TEXT_NORMAL, detailedRightNormalColor);
 615         GET_COLOR_CONFIG(CHECKBUTTON::DETAILED_ICON_TEXT_DISABLED, detailedRightDisabledColor);
 616         GET_COLOR_CONFIG(CHECKBUTTON::DETAILED_ICON_TEXT_PRESSED, detailedRightPressedColor);
 617         GET_COLOR_CONFIG(CHECKBUTTON::DETAILED_ICON_TEXT_HIGHLIGHTED, detailedRightHighlightedColor);
 618         GET_COLOR_CONFIG(CHECKBUTTON::DETAILED_ICON_TEXT_SELECTED, detailedRightSelectedColor);
 619
 620         Bitmap* pReplacementColorBackgroundBitmap = null;
 621         Bitmap* pReplacementColorRightBitmap = null;
 622
 623         _CheckButtonStatus checkStatus = __pCheckButton->GetCheckButtonStatus();
 624         CheckButtonStyle checkStyle = __pCheckButton->GetCheckButtonStyle();
 625
 626         CalculateButtonBounds();
 627
 628         if (checkStyle == CHECK_BUTTON_STYLE_MARK || checkStyle == CHECK_BUTTON_STYLE_MARK_WITH_DIVIDER || checkStyle == CHECK_BUTTON_STYLE_MARK_WITH_DETAILED_BUTTON)
 629         {
 630                 if (checkStatus == _CHECK_BUTTON_STATUS_NORMAL)
 631                 {
 632                         Bitmap* pMarkBgNormalBitmap = __pCheckButton->GetMarkBgBitmap(_CHECK_BUTTON_STATUS_NORMAL);
 633
 634                         if (pMarkBgNormalBitmap)
 635                         {
 636                                 pCanvas->DrawBitmap(FloatPoint(__defaultButtonBounds.x, __defaultButtonBounds.y), *pMarkBgNormalBitmap);
 637                         }
 638
 639                         if (checkStyle == CHECK_BUTTON_STYLE_MARK_WITH_DETAILED_BUTTON)
 640                         {
 641                                 Bitmap* pCircleNormalBitmap = __pCheckButton->GetCircleBitmap(_CHECK_BUTTON_STATUS_NORMAL);
 642                                 Bitmap* pDetailedRightNormalBitmap = __pCheckButton->GetDetailedRightBitmap(_CHECK_BUTTON_STATUS_NORMAL);
 643
 644                                 if (pCircleNormalBitmap)
 645                                 {
 646                                         pReplacementColorBackgroundBitmap = _BitmapImpl::GetColorReplacedBitmapN(*pCircleNormalBitmap, Color::GetColor(COLOR_ID_MAGENTA), detailedNormalBackgroundColor);
 647                                 }
 648
 649                                 if (pDetailedRightNormalBitmap)
 650                                 {
 651                                         pReplacementColorRightBitmap = _BitmapImpl::GetColorReplacedBitmapN(*pDetailedRightNormalBitmap, Color::GetColor(COLOR_ID_MAGENTA), detailedRightNormalColor);
 652                                 }
 653
 654                                 if (pReplacementColorBackgroundBitmap)
 655                                 {
 656                                         pCanvas->DrawBitmap(FloatPoint(__detailedButtonBounds.x, __detailedButtonBounds.y), *pReplacementColorBackgroundBitmap);
 657                                 }
 658
 659                                 if (pReplacementColorRightBitmap)
 660                                 {
 661                                         float arrowWidth = pReplacementColorRightBitmap->GetWidthF();
 662                                         float arrowHeight = pReplacementColorRightBitmap->GetHeightF();
 663
 664                                         pCanvas->DrawBitmap(FloatPoint(__detailedButtonBounds.x + (__detailedButtonBounds.width - arrowWidth) / 2.0f
 665                                                         , __detailedButtonBounds.y + (__detailedButtonBounds.height - arrowHeight) / 2.0f), *pReplacementColorRightBitmap);
 666                                 }
 667
 668                                 bool themeBackgroundBitmap = IS_CUSTOM_BITMAP(CHECKBUTTON::DETAILED_BG_NORMAL);
 669
 670                                 if (themeBackgroundBitmap == false)
 671                                 {
 672                                         Bitmap* pCircleNormalEffectBitmap = __pCheckButton->GetCircleNormalEffectBitmap();
 673
 674                                         if (pCircleNormalEffectBitmap)
 675                                         {
 676                                                 pCanvas->DrawBitmap(FloatPoint(__detailedButtonBounds.x, __detailedButtonBounds.y), *pCircleNormalEffectBitmap);
 677                                         }
 678                                 }
 679                         }
 680                 }
 681                 else if (checkStatus == _CHECK_BUTTON_STATUS_DISABLED)
 682                 {
 683                         Bitmap* pMarkBgDisabledBitmap = __pCheckButton->GetMarkBgBitmap(_CHECK_BUTTON_STATUS_DISABLED);
 684
 685                         if (pMarkBgDisabledBitmap)
 686                         {
 687                                 pCanvas->DrawBitmap(FloatPoint(__defaultButtonBounds.x, __defaultButtonBounds.y), *pMarkBgDisabledBitmap);
 688                         }
 689
 690                         if (checkStyle == CHECK_BUTTON_STYLE_MARK_WITH_DETAILED_BUTTON)
 691                         {
 692                                 Bitmap* pCircleDisabledBitmap = __pCheckButton->GetCircleBitmap(_CHECK_BUTTON_STATUS_DISABLED);
 693                                 Bitmap* pDetailedRightDisabledBitmap = __pCheckButton->GetDetailedRightBitmap(_CHECK_BUTTON_STATUS_DISABLED);
 694
 695                                 if (pCircleDisabledBitmap)
 696                                 {
 697                                         pReplacementColorBackgroundBitmap = _BitmapImpl::GetColorReplacedBitmapN(*pCircleDisabledBitmap, Color::GetColor(COLOR_ID_MAGENTA), detailedDisabledBackgroundColor);
 698                                 }
 699
 700                                 if (pDetailedRightDisabledBitmap)
 701                                 {
 702                                         pReplacementColorRightBitmap = _BitmapImpl::GetColorReplacedBitmapN(*pDetailedRightDisabledBitmap, Color::GetColor(COLOR_ID_MAGENTA), detailedRightDisabledColor);
 703                                 }
 704
 705                                 if (pReplacementColorBackgroundBitmap)
 706                                 {
 707                                         pCanvas->DrawBitmap(FloatPoint(__detailedButtonBounds.x, __detailedButtonBounds.y), *pReplacementColorBackgroundBitmap);
 708                                 }
 709
 710                                 if (pReplacementColorRightBitmap)
 711                                 {
 712                                         float arrowWidth = pReplacementColorRightBitmap->GetWidthF();
 713                                         float arrowHeight = pReplacementColorRightBitmap->GetHeightF();
 714
 715                                         pCanvas->DrawBitmap(FloatPoint(__detailedButtonBounds.x + (__detailedButtonBounds.width - arrowWidth) / 2.0f
 716                                                         , __detailedButtonBounds.y + (__detailedButtonBounds.height - arrowHeight) / 2.0f), *pReplacementColorRightBitmap);
 717                                 }
 718
 719                                 bool themeBackgroundBitmap = IS_CUSTOM_BITMAP(CHECKBUTTON::DETAILED_BG_DISABLED);
 720
 721                                 if (themeBackgroundBitmap == false)
 722                                 {
 723                                         Bitmap* pCircleNormalEffectBitmap = __pCheckButton->GetCircleNormalEffectBitmap();
 724
 725                                         if (pCircleNormalEffectBitmap)
 726                                         {
 727                                                 pCanvas->DrawBitmap(FloatPoint(__detailedButtonBounds.x, __detailedButtonBounds.y), *pCircleNormalEffectBitmap);
 728                                         }
 729                                 }
 730                         }
 731                 }
 732                 else if (checkStatus == _CHECK_BUTTON_STATUS_PRESSED)
 733                 {
 734                         Bitmap* pMarkBgPressedBitmap = __pCheckButton->GetMarkBgBitmap(_CHECK_BUTTON_STATUS_PRESSED);
 735
 736                         if (pMarkBgPressedBitmap)
 737                         {
 738                                 pCanvas->DrawBitmap(FloatPoint(__defaultButtonBounds.x, __defaultButtonBounds.y), *pMarkBgPressedBitmap);
 739                         }
 740
 741                         if (checkStyle == CHECK_BUTTON_STYLE_MARK_WITH_DETAILED_BUTTON)
 742                         {
 743                                 Bitmap* pCirclePressedBitmap = __pCheckButton->GetCircleBitmap(_CHECK_BUTTON_STATUS_PRESSED);
 744                                 Bitmap* pDetailedRightPressedBitmap = __pCheckButton->GetDetailedRightBitmap(_CHECK_BUTTON_STATUS_PRESSED);
 745
 746                                 if (pCirclePressedBitmap)
 747                                 {
 748                                         pReplacementColorBackgroundBitmap = _BitmapImpl::GetColorReplacedBitmapN(*pCirclePressedBitmap, Color::GetColor(COLOR_ID_MAGENTA), detailedPressedBackgroundColor);
 749                                 }
 750
 751                                 if (pDetailedRightPressedBitmap)
 752                                 {
 753                                         pReplacementColorRightBitmap = _BitmapImpl::GetColorReplacedBitmapN(*pDetailedRightPressedBitmap, Color::GetColor(COLOR_ID_MAGENTA), detailedRightPressedColor);
 754                                 }
 755
 756                                 if (pReplacementColorBackgroundBitmap)
 757                                 {
 758                                         pCanvas->DrawBitmap(FloatPoint(__detailedButtonBounds.x, __detailedButtonBounds.y), *pReplacementColorBackgroundBitmap);
 759                                 }
 760
 761                                 if (pReplacementColorRightBitmap)
 762                                 {
 763                                         float arrowWidth = pReplacementColorRightBitmap->GetWidthF();
 764                                         float arrowHeight = pReplacementColorRightBitmap->GetHeightF();
 765
 766                                         pCanvas->DrawBitmap(FloatPoint(__detailedButtonBounds.x + (__detailedButtonBounds.width - arrowWidth) / 2.0f
 767                                                         , __detailedButtonBounds.y + (__detailedButtonBounds.height - arrowHeight) / 2.0f), *pReplacementColorRightBitmap);
 768                                 }
 769
 770                                 bool themeBackgroundBitmap = IS_CUSTOM_BITMAP(CHECKBUTTON::DETAILED_BG_PRESSED);
 771
 772                                 if (themeBackgroundBitmap == false)
 773                                 {
 774                                         Bitmap* pCirclePressedEffectBitmap = __pCheckButton->GetCirclePressedEffectBitmap();
 775
 776                                         if (pCirclePressedEffectBitmap)
 777                                         {
 778                                                 pCanvas->DrawBitmap(FloatPoint(__detailedButtonBounds.x, __detailedButtonBounds.y), *pCirclePressedEffectBitmap);
 779                                         }
 780                                 }
 781                         }
 782                 }
 783                 else if (checkStatus == _CHECK_BUTTON_STATUS_HIGHLIGHTED)
 784                 {
 785                         Bitmap* pMarkBgNormalBitmap = __pCheckButton->GetMarkBgBitmap(_CHECK_BUTTON_STATUS_NORMAL);
 786                         Bitmap* pMarkBgHighlightedBitmap = __pCheckButton->GetMarkBgBitmap(_CHECK_BUTTON_STATUS_HIGHLIGHTED);
 787
 788                         if (pMarkBgNormalBitmap)
 789                         {
 790                                 pCanvas->DrawBitmap(FloatPoint(__defaultButtonBounds.x, __defaultButtonBounds.y), *pMarkBgNormalBitmap);
 791                         }
 792
 793                         if (pMarkBgHighlightedBitmap)
 794                         {
 795                                 pReplacementColorBackgroundBitmap = _BitmapImpl::GetColorReplacedBitmapN(*pMarkBgHighlightedBitmap, Color::GetColor(COLOR_ID_MAGENTA), detailedHighlightedBackgroundColor);
 796                         }
 797
 798                         if (pReplacementColorBackgroundBitmap)
 799                         {
 800                                 pCanvas->DrawBitmap(FloatPoint(__defaultButtonBounds.x, __defaultButtonBounds.y), *pReplacementColorBackgroundBitmap);
 801                         }
 802
 803                         if (checkStyle == CHECK_BUTTON_STYLE_MARK_WITH_DETAILED_BUTTON)
 804                         {
 805                                 Bitmap* pCircleNormalBitmap = __pCheckButton->GetCircleBitmap(_CHECK_BUTTON_STATUS_NORMAL);
 806                                 Bitmap* pCircleHighlightedBitmap = __pCheckButton->GetCircleBitmap(_CHECK_BUTTON_STATUS_HIGHLIGHTED);
 807                                 Bitmap* pDetailedRightHighlightedBitmap = __pCheckButton->GetDetailedRightBitmap(_CHECK_BUTTON_STATUS_HIGHLIGHTED);
 808
 809                                 if (pCircleNormalBitmap)
 810                                 {
 811                                         pReplacementColorBackgroundBitmap = _BitmapImpl::GetColorReplacedBitmapN(*pCircleNormalBitmap, Color::GetColor(COLOR_ID_MAGENTA), detailedNormalBackgroundColor);
 812                                 }
 813
 814                                 if (pDetailedRightHighlightedBitmap)
 815                                 {
 816                                         pReplacementColorRightBitmap = _BitmapImpl::GetColorReplacedBitmapN(*pDetailedRightHighlightedBitmap, Color::GetColor(COLOR_ID_MAGENTA), detailedRightHighlightedColor);
 817                                 }
 818
 819                                 if (pReplacementColorBackgroundBitmap)
 820                                 {
 821                                         pCanvas->DrawBitmap(FloatPoint(__detailedButtonBounds.x, __detailedButtonBounds.y), *pReplacementColorBackgroundBitmap);
 822                                 }
 823
 824                                 if (pReplacementColorRightBitmap)
 825                                 {
 826                                         float arrowWidth = pReplacementColorRightBitmap->GetWidthF();
 827                                         float arrowHeight = pReplacementColorRightBitmap->GetHeightF();
 828
 829                                         pCanvas->DrawBitmap(FloatPoint(__detailedButtonBounds.x + (__detailedButtonBounds.width - arrowWidth) / 2.0f
 830                                                         , __detailedButtonBounds.y + (__detailedButtonBounds.height - arrowHeight) / 2.0f), *pReplacementColorRightBitmap);
 831                                 }
 832
 833                                 bool themeBackgroundBitmap = IS_CUSTOM_BITMAP(CHECKBUTTON::DETAILED_BG_HIGHLIGHTED);
 834
 835                                 if (themeBackgroundBitmap == false)
 836                                 {
 837                                         Bitmap* pCirclePressedEffectBitmap = __pCheckButton->GetCirclePressedEffectBitmap();
 838
 839                                         if (pCirclePressedEffectBitmap)
 840                                         {
 841                                                 pCanvas->DrawBitmap(FloatPoint(__detailedButtonBounds.x, __detailedButtonBounds.y), *pCirclePressedEffectBitmap);
 842                                         }
 843                                 }
 844
 845                                 if (pCircleHighlightedBitmap)
 846                                 {
 847                                         pReplacementColorBackgroundBitmap = _BitmapImpl::GetColorReplacedBitmapN(*pCircleHighlightedBitmap, Color::GetColor(COLOR_ID_MAGENTA), detailedHighlightedBackgroundColor);
 848                                 }
 849
 850                                 if (pReplacementColorBackgroundBitmap)
 851                                 {
 852                                         pCanvas->DrawBitmap(FloatPoint(__detailedButtonBounds.x, __detailedButtonBounds.y), *pReplacementColorBackgroundBitmap);
 853                                 }
 854                         }
 855                 }
 856                 else if (checkStatus == _CHECK_BUTTON_STATUS_SELECTED)
 857                 {
 858                         Bitmap* pMarkBgSelectedBitmap = __pCheckButton->GetMarkBgBitmap(_CHECK_BUTTON_STATUS_SELECTED);
 859
 860                         if (pMarkBgSelectedBitmap)
 861                         {
 862                                 pCanvas->DrawBitmap(FloatPoint(__defaultButtonBounds.x, __defaultButtonBounds.y), *pMarkBgSelectedBitmap);
 863                         }
 864
 865                         if (checkStyle == CHECK_BUTTON_STYLE_MARK_WITH_DETAILED_BUTTON)
 866                         {
 867                                 Bitmap* pCircleSelectedBitmap = __pCheckButton->GetCircleBitmap(_CHECK_BUTTON_STATUS_SELECTED);
 868                                 Bitmap* pDetailedRightSelectedBitmap = __pCheckButton->GetDetailedRightBitmap(_CHECK_BUTTON_STATUS_SELECTED);
 869
 870                                 if (pCircleSelectedBitmap)
 871                                 {
 872                                         pReplacementColorBackgroundBitmap = _BitmapImpl::GetColorReplacedBitmapN(*pCircleSelectedBitmap, Color::GetColor(COLOR_ID_MAGENTA), detailedSelectedBackgroundColor);
 873                                 }
 874
 875                                 if (pDetailedRightSelectedBitmap)
 876                                 {
 877                                         pReplacementColorRightBitmap = _BitmapImpl::GetColorReplacedBitmapN(*pDetailedRightSelectedBitmap, Color::GetColor(COLOR_ID_MAGENTA), detailedRightSelectedColor);
 878                                 }
 879
 880                                 if (pReplacementColorBackgroundBitmap)
 881                                 {
 882                                         pCanvas->DrawBitmap(FloatPoint(__detailedButtonBounds.x, __detailedButtonBounds.y), *pReplacementColorBackgroundBitmap);
 883                                 }
 884
 885                                 if (pReplacementColorRightBitmap)
 886                                 {
 887                                         float arrowWidth = pReplacementColorRightBitmap->GetWidthF();
 888                                         float arrowHeight = pReplacementColorRightBitmap->GetHeightF();
 889
 890                                         pCanvas->DrawBitmap(FloatPoint(__detailedButtonBounds.x + (__detailedButtonBounds.width - arrowWidth) / 2.0f
 891                                                         , __detailedButtonBounds.y + (__detailedButtonBounds.height - arrowHeight) / 2.0f), *pReplacementColorRightBitmap);
 892                                 }
 893
 894                                 bool themeBackgroundBitmap = IS_CUSTOM_BITMAP(CHECKBUTTON::DETAILED_BG_SELECTED);
 895
 896                                 if (themeBackgroundBitmap == false)
 897                                 {
 898                                         Bitmap* pCircleNormalEffectBitmap = __pCheckButton->GetCircleNormalEffectBitmap();
 899
 900                                         if (pCircleNormalEffectBitmap)
 901                                         {
 902                                                 pCanvas->DrawBitmap(FloatPoint(__detailedButtonBounds.x, __detailedButtonBounds.y), *pCircleNormalEffectBitmap);
 903                                         }
 904                                 }
 905                         }
 906                 }
 907
 908                 DrawMarkAnimation();
 909         }
 910         else if (checkStyle == CHECK_BUTTON_STYLE_RADIO || checkStyle == CHECK_BUTTON_STYLE_RADIO_WITH_DIVIDER || checkStyle == CHECK_BUTTON_STYLE_RADIO_WITH_DETAILED_BUTTON)
 911         {
 912                 if (checkStatus == _CHECK_BUTTON_STATUS_NORMAL)
 913                 {
 914                         if (checkStyle == CHECK_BUTTON_STYLE_RADIO_WITH_DETAILED_BUTTON)
 915                         {
 916                                 Bitmap* pCircleNormalBitmap = __pCheckButton->GetCircleBitmap(_CHECK_BUTTON_STATUS_NORMAL);
 917                                 Bitmap* pDetailedRightNormalBitmap = __pCheckButton->GetDetailedRightBitmap(_CHECK_BUTTON_STATUS_NORMAL);
 918
 919                                 if (pCircleNormalBitmap)
 920                                 {
 921                                         pReplacementColorBackgroundBitmap = _BitmapImpl::GetColorReplacedBitmapN(*pCircleNormalBitmap, Color::GetColor(COLOR_ID_MAGENTA), detailedNormalBackgroundColor);
 922                                 }
 923
 924                                 if (pDetailedRightNormalBitmap)
 925                                 {
 926                                         pReplacementColorRightBitmap = _BitmapImpl::GetColorReplacedBitmapN(*pDetailedRightNormalBitmap, Color::GetColor(COLOR_ID_MAGENTA), detailedRightNormalColor);
 927                                 }
 928
 929                                 if (pReplacementColorBackgroundBitmap)
 930                                 {
 931                                         pCanvas->DrawBitmap(FloatPoint(__detailedButtonBounds.x, __detailedButtonBounds.y), *pReplacementColorBackgroundBitmap);
 932                                 }
 933
 934                                 if (pReplacementColorRightBitmap)
 935                                 {
 936                                         float arrowWidth = pReplacementColorRightBitmap->GetWidthF();
 937                                         float arrowHeight = pReplacementColorRightBitmap->GetHeightF();
 938
 939                                         pCanvas->DrawBitmap(FloatPoint(__detailedButtonBounds.x + (__detailedButtonBounds.width - arrowWidth) / 2.0f
 940                                                         , __detailedButtonBounds.y + (__detailedButtonBounds.height - arrowHeight) / 2.0f), *pReplacementColorRightBitmap);
 941                                 }
 942
 943                                 bool themeBackgroundBitmap = IS_CUSTOM_BITMAP(CHECKBUTTON::DETAILED_BG_NORMAL);
 944
 945                                 if (themeBackgroundBitmap == false)
 946                                 {
 947                                         Bitmap* pCircleNormalEffectBitmap = __pCheckButton->GetCircleNormalEffectBitmap();
 948
 949                                         if (pCircleNormalEffectBitmap)
 950                                         {
 951                                                 pCanvas->DrawBitmap(FloatPoint(__detailedButtonBounds.x, __detailedButtonBounds.y), *pCircleNormalEffectBitmap);
 952                                         }
 953                                 }
 954                         }
 955                 }
 956                 else if (checkStatus == _CHECK_BUTTON_STATUS_DISABLED)
 957                 {
 958                         if (checkStyle == CHECK_BUTTON_STYLE_RADIO_WITH_DETAILED_BUTTON)
 959                         {
 960                                 Bitmap* pCircleDisabledBitmap = __pCheckButton->GetCircleBitmap(_CHECK_BUTTON_STATUS_DISABLED);
 961                                 Bitmap* pDetailedRightDisabledBitmap = __pCheckButton->GetDetailedRightBitmap(_CHECK_BUTTON_STATUS_DISABLED);
 962
 963                                 if (pCircleDisabledBitmap)
 964                                 {
 965                                         pReplacementColorBackgroundBitmap = _BitmapImpl::GetColorReplacedBitmapN(*pCircleDisabledBitmap, Color::GetColor(COLOR_ID_MAGENTA), detailedDisabledBackgroundColor);
 966                                 }
 967
 968                                 if (pDetailedRightDisabledBitmap)
 969                                 {
 970                                         pReplacementColorRightBitmap = _BitmapImpl::GetColorReplacedBitmapN(*pDetailedRightDisabledBitmap, Color::GetColor(COLOR_ID_MAGENTA), detailedRightDisabledColor);
 971                                 }
 972
 973                                 if (pReplacementColorBackgroundBitmap)
 974                                 {
 975                                         pCanvas->DrawBitmap(FloatPoint(__detailedButtonBounds.x, __detailedButtonBounds.y), *pReplacementColorBackgroundBitmap);
 976                                 }
 977
 978                                 if (pReplacementColorRightBitmap)
 979                                 {
 980                                         float arrowWidth = pReplacementColorRightBitmap->GetWidthF();
 981                                         float arrowHeight = pReplacementColorRightBitmap->GetHeightF();
 982
 983                                         pCanvas->DrawBitmap(FloatPoint(__detailedButtonBounds.x + (__detailedButtonBounds.width - arrowWidth) / 2.0f
 984                                                         , __detailedButtonBounds.y + (__detailedButtonBounds.height - arrowHeight) / 2.0f), *pReplacementColorRightBitmap);
 985                                 }
 986
 987                                 bool themeBackgroundBitmap = IS_CUSTOM_BITMAP(CHECKBUTTON::DETAILED_BG_DISABLED);
 988
 989                                 if (themeBackgroundBitmap == false)
 990                                 {
 991                                         Bitmap* pCircleNormalEffectBitmap = __pCheckButton->GetCircleNormalEffectBitmap();
 992
 993                                         if (pCircleNormalEffectBitmap)
 994                                         {
 995                                                 pCanvas->DrawBitmap(FloatPoint(__detailedButtonBounds.x, __detailedButtonBounds.y), *pCircleNormalEffectBitmap);
 996                                         }
 997                                 }
 998                         }
 999                 }
1000                 else if (checkStatus == _CHECK_BUTTON_STATUS_PRESSED)
1001                 {
1002                         if (checkStyle == CHECK_BUTTON_STYLE_RADIO_WITH_DETAILED_BUTTON)
1003                         {
1004                                 Bitmap* pCirclePressedBitmap = __pCheckButton->GetCircleBitmap(_CHECK_BUTTON_STATUS_PRESSED);
1005                                 Bitmap* pDetailedRightPressedBitmap = __pCheckButton->GetDetailedRightBitmap(_CHECK_BUTTON_STATUS_PRESSED);
1006
1007                                 if (pCirclePressedBitmap)
1008                                 {
1009                                         pReplacementColorBackgroundBitmap = _BitmapImpl::GetColorReplacedBitmapN(*pCirclePressedBitmap, Color::GetColor(COLOR_ID_MAGENTA), detailedPressedBackgroundColor);
1010                                 }
1011
1012                                 if (pDetailedRightPressedBitmap)
1013                                 {
1014                                         pReplacementColorRightBitmap = _BitmapImpl::GetColorReplacedBitmapN(*pDetailedRightPressedBitmap, Color::GetColor(COLOR_ID_MAGENTA), detailedRightPressedColor);
1015                                 }
1016
1017                                 if (pReplacementColorBackgroundBitmap)
1018                                 {
1019                                         pCanvas->DrawBitmap(FloatPoint(__detailedButtonBounds.x, __detailedButtonBounds.y), *pReplacementColorBackgroundBitmap);
1020                                 }
1021
1022                                 if (pReplacementColorRightBitmap)
1023                                 {
1024                                         float arrowWidth = pReplacementColorRightBitmap->GetWidthF();
1025                                         float arrowHeight = pReplacementColorRightBitmap->GetHeightF();
1026
1027                                         pCanvas->DrawBitmap(FloatPoint(__detailedButtonBounds.x + (__detailedButtonBounds.width - arrowWidth) / 2.0f
1028                                                         , __detailedButtonBounds.y + (__detailedButtonBounds.height - arrowHeight) / 2.0f), *pReplacementColorRightBitmap);
1029                                 }
1030
1031                                 bool themeBackgroundBitmap = IS_CUSTOM_BITMAP(CHECKBUTTON::DETAILED_BG_PRESSED);
1032
1033                                 if (themeBackgroundBitmap == false)
1034                                 {
1035                                         Bitmap* pCirclePressedEffectBitmap = __pCheckButton->GetCirclePressedEffectBitmap();
1036
1037                                         if (pCirclePressedEffectBitmap)
1038                                         {
1039                                                 pCanvas->DrawBitmap(FloatPoint(__detailedButtonBounds.x, __detailedButtonBounds.y), *pCirclePressedEffectBitmap);
1040                                         }
1041                                 }
1042                         }
1043                 }
1044                 else if (checkStatus == _CHECK_BUTTON_STATUS_HIGHLIGHTED)
1045                 {
1046                         if (checkStyle == CHECK_BUTTON_STYLE_RADIO_WITH_DETAILED_BUTTON)
1047                         {
1048                                 Bitmap* pCircleNormalBitmap = __pCheckButton->GetCircleBitmap(_CHECK_BUTTON_STATUS_NORMAL);
1049                                 Bitmap* pCircleHighlightedBitmap = __pCheckButton->GetCircleBitmap(_CHECK_BUTTON_STATUS_HIGHLIGHTED);
1050                                 Bitmap* pDetailedRightHighlightedBitmap = __pCheckButton->GetDetailedRightBitmap(_CHECK_BUTTON_STATUS_HIGHLIGHTED);
1051
1052                                 if (pCircleNormalBitmap)
1053                                 {
1054                                         pReplacementColorBackgroundBitmap = _BitmapImpl::GetColorReplacedBitmapN(*pCircleNormalBitmap, Color::GetColor(COLOR_ID_MAGENTA), detailedNormalBackgroundColor);
1055                                 }
1056
1057                                 if (pDetailedRightHighlightedBitmap)
1058                                 {
1059                                         pReplacementColorRightBitmap = _BitmapImpl::GetColorReplacedBitmapN(*pDetailedRightHighlightedBitmap, Color::GetColor(COLOR_ID_MAGENTA), detailedRightHighlightedColor);
1060                                 }
1061
1062                                 if (pReplacementColorBackgroundBitmap)
1063                                 {
1064                                         pCanvas->DrawBitmap(FloatPoint(__detailedButtonBounds.x, __detailedButtonBounds.y), *pReplacementColorBackgroundBitmap);
1065                                 }
1066
1067                                 if (pReplacementColorRightBitmap)
1068                                 {
1069                                         float arrowWidth = pReplacementColorRightBitmap->GetWidthF();
1070                                         float arrowHeight = pReplacementColorRightBitmap->GetHeightF();
1071
1072                                         pCanvas->DrawBitmap(FloatPoint(__detailedButtonBounds.x + (__detailedButtonBounds.width - arrowWidth) / 2.0f
1073                                                         , __detailedButtonBounds.y + (__detailedButtonBounds.height - arrowHeight) / 2.0f), *pReplacementColorRightBitmap);
1074                                 }
1075
1076                                 bool themeBackgroundBitmap = IS_CUSTOM_BITMAP(CHECKBUTTON::DETAILED_BG_HIGHLIGHTED);
1077
1078                                 if (themeBackgroundBitmap == false)
1079                                 {
1080                                         Bitmap* pCirclePressedEffectBitmap = __pCheckButton->GetCirclePressedEffectBitmap();
1081
1082                                         if (pCirclePressedEffectBitmap)
1083                                         {
1084                                                 pCanvas->DrawBitmap(FloatPoint(__detailedButtonBounds.x, __detailedButtonBounds.y), *pCirclePressedEffectBitmap);
1085                                         }
1086                                 }
1087
1088                                 if (pCircleHighlightedBitmap)
1089                                 {
1090                                         pReplacementColorBackgroundBitmap = _BitmapImpl::GetColorReplacedBitmapN(*pCircleHighlightedBitmap, Color::GetColor(COLOR_ID_MAGENTA), detailedHighlightedBackgroundColor);
1091                                 }
1092
1093                                 if (pReplacementColorBackgroundBitmap)
1094                                 {
1095                                         pCanvas->DrawBitmap(FloatPoint(__detailedButtonBounds.x, __detailedButtonBounds.y), *pReplacementColorBackgroundBitmap);
1096                                 }
1097                         }
1098                 }
1099                 else if (checkStatus == _CHECK_BUTTON_STATUS_SELECTED)
1100                 {
1101                         if (checkStyle == CHECK_BUTTON_STYLE_RADIO_WITH_DETAILED_BUTTON)
1102                         {
1103                                 Bitmap* pCircleSelectedBitmap = __pCheckButton->GetCircleBitmap(_CHECK_BUTTON_STATUS_SELECTED);
1104                                 Bitmap* pDetailedRightSelectedBitmap = __pCheckButton->GetDetailedRightBitmap(_CHECK_BUTTON_STATUS_SELECTED);
1105
1106                                 if (pCircleSelectedBitmap)
1107                                 {
1108                                         pReplacementColorBackgroundBitmap = _BitmapImpl::GetColorReplacedBitmapN(*pCircleSelectedBitmap, Color::GetColor(COLOR_ID_MAGENTA), detailedSelectedBackgroundColor);
1109                                 }
1110
1111                                 if (pDetailedRightSelectedBitmap)
1112                                 {
1113                                         pReplacementColorRightBitmap = _BitmapImpl::GetColorReplacedBitmapN(*pDetailedRightSelectedBitmap, Color::GetColor(COLOR_ID_MAGENTA), detailedRightSelectedColor);
1114                                 }
1115
1116                                 if (pReplacementColorBackgroundBitmap)
1117                                 {
1118                                         pCanvas->DrawBitmap(FloatPoint(__detailedButtonBounds.x, __detailedButtonBounds.y), *pReplacementColorBackgroundBitmap);
1119                                 }
1120
1121                                 if (pReplacementColorRightBitmap)
1122                                 {
1123                                         float arrowWidth = pReplacementColorRightBitmap->GetWidthF();
1124                                         float arrowHeight = pReplacementColorRightBitmap->GetHeightF();
1125
1126                                         pCanvas->DrawBitmap(FloatPoint(__detailedButtonBounds.x + (__detailedButtonBounds.width - arrowWidth) / 2.0f
1127                                                         , __detailedButtonBounds.y + (__detailedButtonBounds.height - arrowHeight) / 2.0f), *pReplacementColorRightBitmap);
1128                                 }
1129
1130                                 bool themeBackgroundBitmap = IS_CUSTOM_BITMAP(CHECKBUTTON::DETAILED_BG_SELECTED);
1131
1132                                 if (themeBackgroundBitmap == false)
1133                                 {
1134                                         Bitmap* pCircleNormalEffectBitmap = __pCheckButton->GetCircleNormalEffectBitmap();
1135
1136                                         if (pCircleNormalEffectBitmap)
1137                                         {
1138                                                 pCanvas->DrawBitmap(FloatPoint(__detailedButtonBounds.x, __detailedButtonBounds.y), *pCircleNormalEffectBitmap);
1139                                         }
1140                                 }
1141                         }
1142                 }
1143
1144                 DrawMarkAnimation();
1145         }
1146         else if (checkStyle == CHECK_BUTTON_STYLE_ONOFF || checkStyle == CHECK_BUTTON_STYLE_ONOFF_WITH_DIVIDER)
1147         {
1148                 if (checkStatus == _CHECK_BUTTON_STATUS_NORMAL)
1149                 {
1150                         Bitmap* pOnOffBgNormalBitmap = __pCheckButton->GetOnOffBgBitmap(_CHECK_BUTTON_STATUS_NORMAL);
1151
1152                         if (pOnOffBgNormalBitmap)
1153                         {
1154                                 pCanvas->DrawBitmap(FloatPoint(__defaultButtonBounds.x, __defaultButtonBounds.y), *pOnOffBgNormalBitmap);
1155                         }
1156
1157                         Bitmap* pOnOffNormalBitmap = __pCheckButton->GetOnOffBitmap(_CHECK_BUTTON_STATUS_NORMAL);
1158
1159                         if (__pCheckButton->IsSelected() && pOnOffNormalBitmap)
1160                         {
1161                                 pCanvas->DrawBitmap(FloatPoint(__defaultButtonBounds.x, __defaultButtonBounds.y), *pOnOffNormalBitmap);
1162                         }
1163                 }
1164                 else if (checkStatus == _CHECK_BUTTON_STATUS_DISABLED)
1165                 {
1166                         Bitmap* pOnOffBgDisabledBitmap = __pCheckButton->GetOnOffBgBitmap(_CHECK_BUTTON_STATUS_DISABLED);
1167
1168                         if (pOnOffBgDisabledBitmap)
1169                         {
1170                                 pCanvas->DrawBitmap(FloatPoint(__defaultButtonBounds.x, __defaultButtonBounds.y), *pOnOffBgDisabledBitmap);
1171                         }
1172
1173                         Bitmap* pOnOffDisabledBitmap = __pCheckButton->GetOnOffBitmap(_CHECK_BUTTON_STATUS_DISABLED);
1174
1175                         if (__pCheckButton->IsSelected() && pOnOffDisabledBitmap)
1176                         {
1177                                 pCanvas->DrawBitmap(FloatPoint(__defaultButtonBounds.x, __defaultButtonBounds.y), *pOnOffDisabledBitmap);
1178                         }
1179                 }
1180                 else if (checkStatus == _CHECK_BUTTON_STATUS_PRESSED)
1181                 {
1182                         Bitmap* pOnOffBgPressedBitmap = __pCheckButton->GetOnOffBgBitmap(_CHECK_BUTTON_STATUS_PRESSED);
1183
1184                         if (pOnOffBgPressedBitmap)
1185                         {
1186                                 pCanvas->DrawBitmap(FloatPoint(__defaultButtonBounds.x, __defaultButtonBounds.y), *pOnOffBgPressedBitmap);
1187                         }
1188
1189                         Bitmap* pOnOffPressedBitmap = __pCheckButton->GetOnOffBitmap(_CHECK_BUTTON_STATUS_PRESSED);
1190
1191                         if (__pCheckButton->IsSelected() && pOnOffPressedBitmap)
1192                         {
1193                                 pCanvas->DrawBitmap(FloatPoint(__defaultButtonBounds.x, __defaultButtonBounds.y), *pOnOffPressedBitmap);
1194                         }
1195                 }
1196                 else if (checkStatus == _CHECK_BUTTON_STATUS_HIGHLIGHTED)
1197                 {
1198                         Bitmap* pOnOffBgNormalBitmap = __pCheckButton->GetOnOffBgBitmap(_CHECK_BUTTON_STATUS_NORMAL);
1199                         Bitmap* pOnOffBgHighlightedBitmap = __pCheckButton->GetOnOffBgBitmap(_CHECK_BUTTON_STATUS_HIGHLIGHTED);
1200
1201                         if (pOnOffBgNormalBitmap)
1202                         {
1203                                 pCanvas->DrawBitmap(FloatPoint(__defaultButtonBounds.x, __defaultButtonBounds.y), *pOnOffBgNormalBitmap);
1204                         }
1205
1206                         Bitmap* pOnOffHighlightedBitmap = __pCheckButton->GetOnOffBitmap(_CHECK_BUTTON_STATUS_HIGHLIGHTED);
1207
1208                         if (__pCheckButton->IsSelected() && pOnOffHighlightedBitmap)
1209                         {
1210                                 pCanvas->DrawBitmap(FloatPoint(__defaultButtonBounds.x, __defaultButtonBounds.y), *pOnOffHighlightedBitmap);
1211                         }
1212
1213                         if (pOnOffBgHighlightedBitmap)
1214                         {
1215                                 pReplacementColorBackgroundBitmap = _BitmapImpl::GetColorReplacedBitmapN(*pOnOffBgHighlightedBitmap, Color::GetColor(COLOR_ID_MAGENTA), detailedHighlightedBackgroundColor);
1216                         }
1217
1218                         if (pReplacementColorBackgroundBitmap)
1219                         {
1220                                 pCanvas->DrawBitmap(FloatPoint(__defaultButtonBounds.x, __defaultButtonBounds.y), *pReplacementColorBackgroundBitmap);
1221                         }
1222                 }
1223                 else if (checkStatus == _CHECK_BUTTON_STATUS_SELECTED)
1224                 {
1225                         Bitmap* pOnOffBgSelectedBitmap = __pCheckButton->GetOnOffBgBitmap(_CHECK_BUTTON_STATUS_SELECTED);
1226
1227                         if (pOnOffBgSelectedBitmap)
1228                         {
1229                                 pCanvas->DrawBitmap(FloatPoint(__defaultButtonBounds.x, __defaultButtonBounds.y), *pOnOffBgSelectedBitmap);
1230                         }
1231
1232                         Bitmap* pOnOffSelectedBitmap = __pCheckButton->GetOnOffBitmap(_CHECK_BUTTON_STATUS_SELECTED);
1233
1234                         if (__pCheckButton->IsSelected() && pOnOffSelectedBitmap)
1235                         {
1236                                 pCanvas->DrawBitmap(FloatPoint(__defaultButtonBounds.x, __defaultButtonBounds.y), *pOnOffSelectedBitmap);
1237                         }
1238                 }
1239         }
1240         else if (checkStyle == CHECK_BUTTON_STYLE_ONOFF_SLIDING || checkStyle == CHECK_BUTTON_STYLE_ONOFF_SLIDING_WITH_DIVIDER)
1241         {
1242                 float handlerWidth = 0.0f;
1243                 GET_SHAPE_CONFIG(CHECKBUTTON::ONOFF_SLIDING_HANDLER_WIDTH, _CONTROL_ORIENTATION_PORTRAIT, handlerWidth);
1244                 DrawOnOffSlidingHandler(__onOffHandlerPosition - (handlerWidth / 2.0f));
1245
1246                 float dividerWidth = 0.0f;
1247                 float dividerTopMargin = 0.0f;
1248                 float dividerRightMargin = 0.0f;
1249
1250                 Color dividerLeftColor;
1251                 Color dividerRightColor;
1252                 FloatDimension minDimension(0.0f, 0.0f);
1253
1254                 GET_SHAPE_CONFIG(CHECKBUTTON::DIVIDER_WIDTH, _CONTROL_ORIENTATION_PORTRAIT, dividerWidth);
1255                 GET_SHAPE_CONFIG(CHECKBUTTON::DIVIDER_TOP_MARGIN, _CONTROL_ORIENTATION_PORTRAIT, dividerTopMargin);
1256                 GET_SHAPE_CONFIG(CHECKBUTTON::DIVIDER_RIGHT_MARGIN, _CONTROL_ORIENTATION_PORTRAIT, dividerRightMargin);
1257                 GET_COLOR_CONFIG(HEADER::DIVIDER_LINE_LEFT_NORMAL, dividerLeftColor);
1258                 GET_COLOR_CONFIG(HEADER::DIVIDER_LINE_RIGHT_NORMAL, dividerRightColor);
1259
1260                 GET_DIMENSION_CONFIG(CHECKBUTTON::MIN_DIMENSION, __pCheckButton->GetOrientation(), minDimension);
1261
1262                 FloatRectangle bounds(0.0f, 0.0f, __pCheckButton->GetBoundsF().width, __pCheckButton->GetBoundsF().height);
1263
1264                 if (bounds.height < minDimension.height )
1265                 {
1266                         bounds.height = minDimension.height;
1267                 }
1268
1269                 if (checkStyle == CHECK_BUTTON_STYLE_ONOFF_SLIDING_WITH_DIVIDER)
1270                 {
1271                         pCanvas->SetForegroundColor(dividerLeftColor);
1272                         pCanvas->SetLineWidth(dividerWidth/2);
1273                         pCanvas->DrawLine(FloatPoint(__onOffSlidingButtonBounds.x - dividerRightMargin + dividerWidth/2, dividerTopMargin),
1274                                         FloatPoint(__onOffSlidingButtonBounds.x - dividerRightMargin + dividerWidth/2, dividerTopMargin + bounds.height - dividerTopMargin * 2));
1275
1276                         pCanvas->SetForegroundColor(dividerRightColor);
1277                         pCanvas->SetLineWidth(dividerWidth/2);
1278                         pCanvas->DrawLine(FloatPoint(__onOffSlidingButtonBounds.x - dividerRightMargin + dividerWidth, dividerTopMargin),
1279                                         FloatPoint(__onOffSlidingButtonBounds.x - dividerRightMargin + dividerWidth, dividerTopMargin + bounds.height - dividerTopMargin * 2));
1280                 }
1281         }
1282
1283         delete pCanvas;
1284         delete pReplacementColorBackgroundBitmap;
1285         delete pReplacementColorRightBitmap;
1286
1287         return;
1288 }
1289
1290 void
1291 _CheckButtonPresenter::DrawText(void)
1292 {
1293         result r = E_SUCCESS;
1294
1295         TextSimple* pSimpleText = null;
1296         TextSimple* pSimpleTitleText = null;
1297         TextObjectAlignment horizontalAlign = TEXT_OBJECT_ALIGNMENT_CENTER;
1298         TextObjectAlignment verticalAlign = TEXT_OBJECT_ALIGNMENT_MIDDLE;
1299
1300         _CheckButtonStatus checkStatus = __pCheckButton->GetCheckButtonStatus();
1301         bool showTitle = __pCheckButton->GetShowTitle();
1302
1303         Canvas* pCanvas = __pCheckButton->GetCanvasN();
1304         if (pCanvas == null)
1305         {
1306                 SysLog(NID_UI_CTRL, "Cannot get a canvas.");
1307
1308                 return;
1309         }
1310
1311         __pTextObject->RemoveAll(true);
1312         pSimpleText = new (std::nothrow) TextSimple(const_cast<wchar_t*>(__pCheckButton->GetText().GetPointer()), __pCheckButton->GetText().GetLength());
1313         __pTextObject->AppendElement(*pSimpleText);
1314
1315         __pTitleTextObject->RemoveAll(true);
1316         pSimpleTitleText = new (std::nothrow) TextSimple(const_cast<wchar_t*>(__pCheckButton->GetTitleText().GetPointer()), __pCheckButton->GetTitleText().GetLength());
1317         __pTitleTextObject->AppendElement(*pSimpleTitleText);
1318
1319         if (checkStatus == _CHECK_BUTTON_STATUS_NORMAL)
1320         {
1321                 __pTextObject->SetForegroundColor(__pCheckButton->GetTextColor(), 0, __pTextObject->GetTextLength());
1322                 __pTitleTextObject->SetForegroundColor(__pCheckButton->GetTitleTextColor(), 0, __pTitleTextObject->GetTextLength());
1323         }
1324         else if (checkStatus == _CHECK_BUTTON_STATUS_DISABLED)
1325         {
1326                 __pTextObject->SetForegroundColor(__pCheckButton->GetDisabledTextColor(), 0, __pTextObject->GetTextLength());
1327                 __pTitleTextObject->SetForegroundColor(__pCheckButton->GetDisabledTitleTextColor(), 0, __pTitleTextObject->GetTextLength());
1328         }
1329         else if (checkStatus == _CHECK_BUTTON_STATUS_PRESSED)
1330         {
1331                 __pTextObject->SetForegroundColor(__pCheckButton->GetPressedTextColor(), 0, __pTextObject->GetTextLength());
1332                 __pTitleTextObject->SetForegroundColor(__pCheckButton->GetPressedTitleTextColor(), 0, __pTitleTextObject->GetTextLength());
1333         }
1334         else if (checkStatus == _CHECK_BUTTON_STATUS_HIGHLIGHTED)
1335         {
1336                 __pTextObject->SetForegroundColor(__pCheckButton->GetHighlightedTextColor(), 0, __pTextObject->GetTextLength());
1337                 __pTitleTextObject->SetForegroundColor(__pCheckButton->GetHighlightedTitleTextColor(), 0, __pTitleTextObject->GetTextLength());
1338         }
1339         else
1340         {
1341                 __pTextObject->SetForegroundColor(__pCheckButton->GetSelectedTextColor(), 0, __pTextObject->GetTextLength());
1342                 __pTitleTextObject->SetForegroundColor(__pCheckButton->GetSelectedTitleTextColor(), 0, __pTitleTextObject->GetTextLength());
1343         }
1344
1345         CalculateTextBounds();
1346         CalculateTitleTextBounds();
1347
1348         __pTextObject->SetWrap(TEXT_OBJECT_WRAP_TYPE_NONE);
1349         __pTextObject->SetAction(TEXT_OBJECT_ACTION_TYPE_ABBREV);
1350         __pTextObject->SetBounds(GetTextBoundsF());
1351         __pTextObject->Compose();
1352
1353         __pTitleTextObject->SetWrap(TEXT_OBJECT_WRAP_TYPE_NONE);
1354         __pTitleTextObject->SetAction(TEXT_OBJECT_ACTION_TYPE_ABBREV);
1355         __pTitleTextObject->SetBounds(GetTitleTextBoundsF());
1356         __pTitleTextObject->Compose();
1357
1358         switch (__pCheckButton->GetTextHorizontalAlignment())
1359         {
1360         case ALIGNMENT_LEFT:
1361                 horizontalAlign = TEXT_OBJECT_ALIGNMENT_LEFT;
1362                 break;
1363         case ALIGNMENT_CENTER:
1364                 horizontalAlign = TEXT_OBJECT_ALIGNMENT_CENTER;
1365                 break;
1366         default:
1367                 horizontalAlign = TEXT_OBJECT_ALIGNMENT_RIGHT;
1368         }
1369
1370         switch (__pCheckButton->GetTextVerticalAlignment())
1371         {
1372         case ALIGNMENT_TOP:
1373                 verticalAlign = TEXT_OBJECT_ALIGNMENT_TOP;
1374                 break;
1375         case ALIGNMENT_MIDDLE:
1376                 verticalAlign = TEXT_OBJECT_ALIGNMENT_MIDDLE;
1377                 break;
1378         default:
1379                 verticalAlign = TEXT_OBJECT_ALIGNMENT_BOTTOM;
1380         }
1381
1382         __fontSize =  __pCheckButton->GetTextSizeF();
1383         __pTextFont = __pCheckButton->GetFallbackFont();
1384         r = GetLastResult();
1385         SysTryReturnVoidResult(NID_UI_CTRL, __pTextFont, r, "[%s] Propagating.", GetErrorMessage(r));
1386
1387         __pTextObject->SetAlignment(horizontalAlign | verticalAlign);
1388         __pTextObject->SetFont(__pTextFont, 0, __pTextObject->GetTextLength());
1389         __pTextObject->Draw(*_CanvasImpl::GetInstance(*pCanvas));
1390
1391         __fontSize = __pCheckButton->GetTitleTextSizeF();
1392         __pTitleTextFont = __pCheckButton->GetFallbackFont();
1393         r = GetLastResult();
1394         SysTryReturnVoidResult(NID_UI_CTRL, __pTitleTextFont, r, "[%s] Propagating.", GetErrorMessage(r));
1395
1396         __pTitleTextObject->SetAlignment(TEXT_OBJECT_ALIGNMENT_LEFT | TEXT_OBJECT_ALIGNMENT_MIDDLE);
1397         __pTitleTextObject->SetFont(__pTitleTextFont, 0, __pTitleTextObject->GetTextLength());
1398
1399         if (showTitle)
1400         {
1401                 __pTitleTextObject->Draw(*_CanvasImpl::GetInstance(*pCanvas));
1402         }
1403
1404         delete pCanvas;
1405
1406         return;
1407 }
1408
1409 bool
1410 _CheckButtonPresenter::OnTouchPressed(const _Control& source, const _TouchInfo& touchinfo)
1411 {
1412         if (&source != __pCheckButton)
1413         {
1414                 return false;
1415         }
1416
1417         if (!__pCheckButton->IsEnabled())
1418         {
1419                 return true;
1420         }
1421
1422         __touchMoveHandled = false;
1423
1424         FloatPoint touchPoint = touchinfo.GetCurrentPosition();
1425
1426         touchPoint.x += source.GetClientBoundsF().x;
1427         touchPoint.y += source.GetClientBoundsF().y;
1428
1429         CheckButtonStyle checkStyle = __pCheckButton->GetCheckButtonStyle();
1430
1431         if (checkStyle == CHECK_BUTTON_STYLE_ONOFF_SLIDING || checkStyle == CHECK_BUTTON_STYLE_ONOFF_SLIDING_WITH_DIVIDER)
1432         {
1433                 if (__onOffSlidingButtonBounds.Contains(touchPoint))
1434                 {
1435                         __onOffHandlerPressed = true;
1436                 }
1437                 else
1438                 {
1439                         __pCheckButton->SetCheckButtonStatus(_CHECK_BUTTON_STATUS_PRESSED);
1440                 }
1441         }
1442         else
1443         {
1444                 __pCheckButton->SetCheckButtonStatus(_CHECK_BUTTON_STATUS_PRESSED);
1445         }
1446
1447         __pCheckButton->Invalidate();
1448
1449         return true;
1450 }
1451
1452 bool
1453 _CheckButtonPresenter::OnTouchReleased(const _Control& source, const _TouchInfo& touchinfo)
1454 {
1455         float checkButtonLeftMargin = 0.0f;
1456         float checkButtonDetailedBitmapWidth = 0.0f;
1457         float checkButtonOnOffSlidingBitmapWidth = 0.0f;
1458         float dividerRightMargin = 0.0f;
1459
1460         GET_SHAPE_CONFIG(CHECKBUTTON::LEFT_MARGIN, _CONTROL_ORIENTATION_PORTRAIT, checkButtonLeftMargin);
1461         GET_SHAPE_CONFIG(CHECKBUTTON::DETAILED_BITMAP_WIDTH, _CONTROL_ORIENTATION_PORTRAIT, checkButtonDetailedBitmapWidth);
1462         GET_SHAPE_CONFIG(CHECKBUTTON::ONOFF_SLIDING_BITMAP_WIDTH, _CONTROL_ORIENTATION_PORTRAIT, checkButtonOnOffSlidingBitmapWidth);
1463         GET_SHAPE_CONFIG(CHECKBUTTON::DIVIDER_RIGHT_MARGIN, _CONTROL_ORIENTATION_PORTRAIT, dividerRightMargin);
1464
1465         if (&source != __pCheckButton)
1466         {
1467                 return false;
1468         }
1469
1470         if (!__pCheckButton->IsEnabled())
1471         {
1472                 return true;
1473         }
1474
1475         _CheckButtonStatus status = __pCheckButton->GetCheckButtonStatus();
1476         CheckButtonStyle checkStyle = __pCheckButton->GetCheckButtonStyle();
1477
1478         if (status == _CHECK_BUTTON_STATUS_NORMAL && __onOffHandlerPressed == false)
1479         {
1480                 if (checkStyle == CHECK_BUTTON_STYLE_ONOFF_SLIDING || checkStyle == CHECK_BUTTON_STYLE_ONOFF_SLIDING_WITH_DIVIDER)
1481                 {
1482                         AdjustHandlerPosition();
1483
1484                         __onOffHandlerPressed = false;
1485                         __onOffHandlerMoved = false;
1486                 }
1487
1488                 return true;
1489         }
1490
1491         if (checkStyle == CHECK_BUTTON_STYLE_MARK || checkStyle == CHECK_BUTTON_STYLE_MARK_WITH_DIVIDER || checkStyle == CHECK_BUTTON_STYLE_MARK_WITH_DETAILED_BUTTON
1492                         || checkStyle == CHECK_BUTTON_STYLE_RADIO || checkStyle == CHECK_BUTTON_STYLE_RADIO_WITH_DIVIDER || checkStyle == CHECK_BUTTON_STYLE_RADIO_WITH_DETAILED_BUTTON)
1493         {
1494                 StartCheckAnimationTimer();
1495                 __ratio = 0;
1496         }
1497
1498         FloatPoint touchPoint = touchinfo.GetCurrentPosition();
1499
1500         touchPoint.x += source.GetClientBoundsF().x;
1501         touchPoint.y += source.GetClientBoundsF().y;
1502
1503         FloatRectangle bounds = __pCheckButton->GetClientBoundsF();
1504         FloatRectangle detailedBounds = __pCheckButton->GetClientBoundsF();
1505
1506         __pCheckButton->SetCheckButtonStatus(_CHECK_BUTTON_STATUS_NORMAL);
1507         __pCheckButton->Invalidate();
1508
1509         if (checkStyle == CHECK_BUTTON_STYLE_MARK_WITH_DETAILED_BUTTON || checkStyle == CHECK_BUTTON_STYLE_RADIO_WITH_DETAILED_BUTTON)
1510         {
1511                 detailedBounds.width = detailedBounds.width - checkButtonLeftMargin - checkButtonDetailedBitmapWidth;
1512
1513                 if (detailedBounds.Contains(touchPoint))
1514                 {
1515                         PLAY_FEEDBACK(_RESOURCE_FEEDBACK_PATTERN_TAP, __pCheckButton);
1516
1517                         __pCheckButton->FireActionEvent();
1518
1519                         if (__pCheckButton->GetRadioGroup() != null)
1520                         {
1521                                 __pCheckButton->SendTouchReleasedEvent(*__pCheckButton);
1522                         }
1523                 }
1524         }
1525         else if (checkStyle == CHECK_BUTTON_STYLE_ONOFF_SLIDING_WITH_DIVIDER)
1526         {
1527                 detailedBounds.width = detailedBounds.width - checkButtonLeftMargin - checkButtonOnOffSlidingBitmapWidth - dividerRightMargin;
1528
1529                 if (!detailedBounds.Contains(touchPoint))
1530                 {
1531                         if (__onOffHandlerMoved == false)
1532                         {
1533                                 PLAY_FEEDBACK(_RESOURCE_FEEDBACK_PATTERN_TAP, __pCheckButton);
1534
1535                                 __pCheckButton->FireActionEvent();
1536
1537                                 if (__pCheckButton->GetRadioGroup() != null)
1538                                 {
1539                                         __pCheckButton->SendTouchReleasedEvent(*__pCheckButton);
1540                                 }
1541                         }
1542                 }
1543
1544                 AdjustHandlerPosition();
1545
1546                 __onOffHandlerPressed = false;
1547                 __onOffHandlerMoved = false;
1548         }
1549         else if (checkStyle == CHECK_BUTTON_STYLE_ONOFF_SLIDING)
1550         {
1551                 if (bounds.Contains(touchPoint))
1552                 {
1553                         if (__onOffHandlerMoved == false)
1554                         {
1555                                 PLAY_FEEDBACK(_RESOURCE_FEEDBACK_PATTERN_TAP, __pCheckButton);
1556
1557                                 __pCheckButton->FireActionEvent();
1558
1559                                 if (__pCheckButton->GetRadioGroup() != null)
1560                                 {
1561                                         __pCheckButton->SendTouchReleasedEvent(*__pCheckButton);
1562                                 }
1563                         }
1564                 }
1565
1566                 AdjustHandlerPosition();
1567
1568                 __onOffHandlerPressed = false;
1569                 __onOffHandlerMoved = false;
1570         }
1571         else
1572         {
1573                 if (bounds.Contains(touchPoint))
1574                 {
1575                         PLAY_FEEDBACK(_RESOURCE_FEEDBACK_PATTERN_TAP, __pCheckButton);
1576
1577                         __pCheckButton->FireActionEvent();
1578
1579                         if (__pCheckButton->GetRadioGroup() != null)
1580                         {
1581                                 __pCheckButton->SendTouchReleasedEvent(*__pCheckButton);
1582                         }
1583                 }
1584         }
1585
1586         return true;
1587 }
1588
1589 result
1590 _CheckButtonPresenter::InitOnOffHandlerMoved(void)
1591 {
1592         __onOffHandlerMoved = false;
1593
1594         return E_SUCCESS;
1595 }
1596
1597 result
1598 _CheckButtonPresenter::AdjustHandlerPosition(void)
1599 {
1600         float handlerWidth = 0.0f;
1601         GET_SHAPE_CONFIG(CHECKBUTTON::ONOFF_SLIDING_HANDLER_WIDTH, _CONTROL_ORIENTATION_PORTRAIT, handlerWidth);
1602
1603         if (__onOffHandlerMoved == false)
1604         {
1605                 if (!__pCheckButton->IsSelected())
1606                 {
1607                         __onOffHandlerPosition = __onOffSlidingButtonBounds.x;
1608                 }
1609                 else
1610                 {
1611                         __onOffHandlerPosition = __onOffSlidingButtonBounds.x + __onOffSlidingButtonBounds.width - (handlerWidth / 2.0f);
1612                 }
1613         }
1614         else
1615         {
1616                 if (!__pCheckButton->IsSelected())
1617                 {
1618                         if (__onOffHandlerPosition < __onOffSlidingButtonBounds.x + (__onOffSlidingButtonBounds.width / 2.0f))
1619                         {
1620                                 __onOffHandlerPosition = __onOffSlidingButtonBounds.x;
1621                         }
1622                         else
1623                         {
1624                                 __onOffHandlerPosition = __onOffSlidingButtonBounds.x + __onOffSlidingButtonBounds.width - (handlerWidth / 2.0f);
1625
1626                                 PLAY_FEEDBACK(_RESOURCE_FEEDBACK_PATTERN_TAP, __pCheckButton);
1627
1628                                 __pCheckButton->FireActionEvent();
1629
1630                                 if (__pCheckButton->GetRadioGroup() != null)
1631                                 {
1632                                         __pCheckButton->SendTouchReleasedEvent(*__pCheckButton);
1633                                 }
1634                         }
1635                 }
1636                 else
1637                 {
1638                         if (__onOffHandlerPosition < __onOffSlidingButtonBounds.x + (__onOffSlidingButtonBounds.width / 2.0f))
1639                         {
1640                                 __onOffHandlerPosition = __onOffSlidingButtonBounds.x;
1641
1642                                 PLAY_FEEDBACK(_RESOURCE_FEEDBACK_PATTERN_TAP, __pCheckButton);
1643
1644                                 __pCheckButton->FireActionEvent();
1645
1646                                 if (__pCheckButton->GetRadioGroup() != null)
1647                                 {
1648                                         __pCheckButton->SendTouchReleasedEvent(*__pCheckButton);
1649                                 }
1650                         }
1651                         else
1652                         {
1653                                 __onOffHandlerPosition = __onOffSlidingButtonBounds.x + __onOffSlidingButtonBounds.width - (handlerWidth / 2.0f);
1654                         }
1655                 }
1656         }
1657
1658         __pCheckButton->Invalidate();
1659
1660         return E_SUCCESS;
1661 }
1662
1663 bool
1664 _CheckButtonPresenter::OnTouchMoved(const _Control& source, const _TouchInfo& touchinfo)
1665 {
1666         if (&source != __pCheckButton)
1667         {
1668                 return false;
1669         }
1670
1671         if (!__pCheckButton->IsEnabled())
1672         {
1673                 return true;
1674         }
1675
1676         FloatPoint touchPoint = touchinfo.GetCurrentPosition();
1677
1678         touchPoint.x += source.GetClientBoundsF().x;
1679         touchPoint.y += source.GetClientBoundsF().y;
1680
1681         FloatRectangle bounds = __pCheckButton->GetClientBoundsF();
1682         bool isInCheckButtonArea = bounds.Contains(touchPoint);
1683         bool isInOnOffHandlerArea = __onOffSlidingButtonBounds.Contains(touchPoint);
1684
1685         if (__onOffHandlerPressed == true)
1686         {
1687                 __pCheckButton->SetCheckButtonStatus(_CHECK_BUTTON_STATUS_NORMAL);
1688         }
1689         else
1690         {
1691                 if (isInCheckButtonArea == true && __touchMoveHandled == false && isInOnOffHandlerArea == false )
1692                 {
1693                         __pCheckButton->SetCheckButtonStatus(_CHECK_BUTTON_STATUS_PRESSED);
1694                 }
1695                 else
1696                 {
1697                         __pCheckButton->SetCheckButtonStatus(_CHECK_BUTTON_STATUS_NORMAL);
1698                 }
1699         }
1700
1701         CheckButtonStyle checkStyle = __pCheckButton->GetCheckButtonStyle();
1702
1703         if (checkStyle == CHECK_BUTTON_STYLE_ONOFF_SLIDING || checkStyle == CHECK_BUTTON_STYLE_ONOFF_SLIDING_WITH_DIVIDER)
1704         {
1705                 if (isInOnOffHandlerArea == true && __onOffHandlerPressed == true)
1706                 {
1707                         __onOffHandlerPosition = touchPoint.x;
1708
1709                         __onOffHandlerMoved = true;
1710                 }
1711         }
1712
1713         __pCheckButton->Invalidate();
1714
1715         if (__onOffHandlerMoved == true)
1716         {
1717                 return true;
1718         }
1719         else
1720         {
1721                 return false;
1722         }
1723 }
1724
1725 void
1726 _CheckButtonPresenter::DrawOnOffSlidingHandler(float handlerPosition)
1727 {
1728         Canvas* pCanvas = __pCheckButton->GetCanvasN();
1729         if (pCanvas == null)
1730         {
1731                 SysLog(NID_UI_CTRL, "Cannot get a canvas.");
1732
1733                 return;
1734         }
1735
1736         Bitmap* pReplacementColorBackgroundBitmap = null;
1737
1738         Color detailedHighlightedBackgroundColor;
1739         GET_COLOR_CONFIG(CHECKBUTTON::DETAILED_ICON_BG_HIGHLIGHTED, detailedHighlightedBackgroundColor);
1740
1741         float handlerMargin = 0.0f;
1742         float handlerWidth = 0.0f;
1743
1744         _CheckButtonStatus checkStatus = __pCheckButton->GetCheckButtonStatus();
1745
1746         GET_SHAPE_CONFIG(CHECKBUTTON::ONOFF_SLIDING_HANDLER_MARGIN, _CONTROL_ORIENTATION_PORTRAIT, handlerMargin);
1747         GET_SHAPE_CONFIG(CHECKBUTTON::ONOFF_SLIDING_HANDLER_WIDTH, _CONTROL_ORIENTATION_PORTRAIT, handlerWidth);
1748
1749         if (handlerPosition < __onOffSlidingButtonBounds.x)
1750         {
1751                 handlerPosition = __onOffSlidingButtonBounds.x;
1752         }
1753
1754         if (handlerPosition > __onOffSlidingButtonBounds.x + __onOffSlidingButtonBounds.width - handlerWidth)
1755         {
1756                 handlerPosition = __onOffSlidingButtonBounds.x + __onOffSlidingButtonBounds.width - handlerWidth;
1757         }
1758
1759         if (!__pCheckButton->IsSelected())
1760         {
1761                 if (checkStatus == _CHECK_BUTTON_STATUS_NORMAL)
1762                 {
1763                         Bitmap* pOnOffSlidingNormalBgBitmap = __pCheckButton->GetOnOffSlidingBgBitmap(_CHECK_BUTTON_STATUS_NORMAL);
1764
1765                         if (pOnOffSlidingNormalBgBitmap)
1766                         {
1767                                 pCanvas->DrawBitmap(FloatPoint(__onOffSlidingButtonBounds.x, __onOffSlidingButtonBounds.y), *pOnOffSlidingNormalBgBitmap);
1768                         }
1769
1770                         Bitmap* pOnOffSlidingOffHandlerNormalBitmap = __pCheckButton->GetOnOffSlidingOffHandlerBitmap(_CHECK_BUTTON_STATUS_NORMAL);
1771
1772                         if (pOnOffSlidingOffHandlerNormalBitmap)
1773                         {
1774                                 pCanvas->DrawBitmap(FloatPoint(handlerPosition, __onOffSlidingButtonBounds.y - handlerMargin), *pOnOffSlidingOffHandlerNormalBitmap);
1775                         }
1776                 }
1777                 else if (checkStatus == _CHECK_BUTTON_STATUS_DISABLED)
1778                 {
1779                         Bitmap* pOnOffSlidingDisabledBgBitmap = __pCheckButton->GetOnOffSlidingBgBitmap(_CHECK_BUTTON_STATUS_DISABLED);
1780
1781                         if (pOnOffSlidingDisabledBgBitmap)
1782                         {
1783                                 pCanvas->DrawBitmap(FloatPoint(__onOffSlidingButtonBounds.x, __onOffSlidingButtonBounds.y), *pOnOffSlidingDisabledBgBitmap);
1784                         }
1785
1786                         Bitmap* pOnOffSlidingOffHandlerDisabledBitmap = __pCheckButton->GetOnOffSlidingOffHandlerBitmap(_CHECK_BUTTON_STATUS_DISABLED);
1787
1788                         if (pOnOffSlidingOffHandlerDisabledBitmap)
1789                         {
1790                                 pCanvas->DrawBitmap(FloatPoint(handlerPosition, __onOffSlidingButtonBounds.y - handlerMargin), *pOnOffSlidingOffHandlerDisabledBitmap);
1791                         }
1792                 }
1793                 else if (checkStatus == _CHECK_BUTTON_STATUS_PRESSED)
1794                 {
1795                         Bitmap* pOnOffSlidingPressedBgBitmap = __pCheckButton->GetOnOffSlidingBgBitmap(_CHECK_BUTTON_STATUS_PRESSED);
1796
1797                         if (pOnOffSlidingPressedBgBitmap)
1798                         {
1799                                 pCanvas->DrawBitmap(FloatPoint(__onOffSlidingButtonBounds.x, __onOffSlidingButtonBounds.y), *pOnOffSlidingPressedBgBitmap);
1800                         }
1801
1802                         Bitmap* pOnOffSlidingOffHandlerPressedBitmap = __pCheckButton->GetOnOffSlidingOffHandlerBitmap(_CHECK_BUTTON_STATUS_PRESSED);
1803
1804                         if (pOnOffSlidingOffHandlerPressedBitmap)
1805                         {
1806                                 pCanvas->DrawBitmap(FloatPoint(handlerPosition, __onOffSlidingButtonBounds.y - handlerMargin), *pOnOffSlidingOffHandlerPressedBitmap);
1807                         }
1808                 }
1809                 else if (checkStatus == _CHECK_BUTTON_STATUS_HIGHLIGHTED)
1810                 {
1811                         Bitmap* pOnOffSlidingHighlightedBgBitmap = __pCheckButton->GetOnOffSlidingBgBitmap(_CHECK_BUTTON_STATUS_HIGHLIGHTED);
1812
1813                         if (pOnOffSlidingHighlightedBgBitmap)
1814                         {
1815                                 pCanvas->DrawBitmap(FloatPoint(__onOffSlidingButtonBounds.x, __onOffSlidingButtonBounds.y), *pOnOffSlidingHighlightedBgBitmap);
1816                         }
1817
1818                         Bitmap* pOnOffSlidingOffHandlerNormalBitmap = __pCheckButton->GetOnOffSlidingOffHandlerBitmap(_CHECK_BUTTON_STATUS_NORMAL);
1819
1820                         if (pOnOffSlidingOffHandlerNormalBitmap)
1821                         {
1822                                 pCanvas->DrawBitmap(FloatPoint(handlerPosition, __onOffSlidingButtonBounds.y - handlerMargin), *pOnOffSlidingOffHandlerNormalBitmap);
1823                         }
1824
1825                         Bitmap* pOnOffSlidingOffHandlerHighlightedBitmap = __pCheckButton->GetOnOffSlidingOffHandlerBitmap(_CHECK_BUTTON_STATUS_HIGHLIGHTED);
1826
1827                         if (pOnOffSlidingOffHandlerHighlightedBitmap)
1828                         {
1829                                 pReplacementColorBackgroundBitmap = _BitmapImpl::GetColorReplacedBitmapN(*pOnOffSlidingOffHandlerHighlightedBitmap, Color::GetColor(COLOR_ID_MAGENTA),
1830                                                 detailedHighlightedBackgroundColor);
1831                         }
1832
1833                         if (pReplacementColorBackgroundBitmap)
1834                         {
1835                                 pCanvas->DrawBitmap(FloatPoint(handlerPosition, __onOffSlidingButtonBounds.y - handlerMargin), *pReplacementColorBackgroundBitmap);
1836                         }
1837                 }
1838                 else if (checkStatus == _CHECK_BUTTON_STATUS_SELECTED)
1839                 {
1840                         Bitmap* pOnOffSlidingSelectedBgBitmap = __pCheckButton->GetOnOffSlidingBgBitmap(_CHECK_BUTTON_STATUS_SELECTED);
1841
1842                         if (pOnOffSlidingSelectedBgBitmap)
1843                         {
1844                                 pCanvas->DrawBitmap(FloatPoint(__onOffSlidingButtonBounds.x, __onOffSlidingButtonBounds.y), *pOnOffSlidingSelectedBgBitmap);
1845                         }
1846
1847                         Bitmap* pOnOffSlidingOffHandlerSelectedBitmap = __pCheckButton->GetOnOffSlidingOffHandlerBitmap(_CHECK_BUTTON_STATUS_SELECTED);
1848
1849                         if (pOnOffSlidingOffHandlerSelectedBitmap)
1850                         {
1851                                 pCanvas->DrawBitmap(FloatPoint(handlerPosition, __onOffSlidingButtonBounds.y - handlerMargin), *pOnOffSlidingOffHandlerSelectedBitmap);
1852                         }
1853                 }
1854         }
1855         else
1856         {
1857                 if (checkStatus == _CHECK_BUTTON_STATUS_NORMAL)
1858                 {
1859                         Bitmap* pOnOffSlidingNormalBgBitmap = __pCheckButton->GetOnOffSlidingBgBitmap(_CHECK_BUTTON_STATUS_NORMAL);
1860
1861                         if (pOnOffSlidingNormalBgBitmap)
1862                         {
1863                                 pCanvas->DrawBitmap(FloatPoint(__onOffSlidingButtonBounds.x, __onOffSlidingButtonBounds.y), *pOnOffSlidingNormalBgBitmap);
1864                         }
1865
1866                         Bitmap* pOnOffSlidingOnHandlerNormalBitmap = __pCheckButton->GetOnOffSlidingOnHandlerBitmap(_CHECK_BUTTON_STATUS_NORMAL);
1867
1868                         if (pOnOffSlidingOnHandlerNormalBitmap)
1869                         {
1870                                 pCanvas->DrawBitmap(FloatPoint(handlerPosition, __onOffSlidingButtonBounds.y - handlerMargin), *pOnOffSlidingOnHandlerNormalBitmap);
1871                         }
1872                 }
1873                 else if (checkStatus == _CHECK_BUTTON_STATUS_DISABLED)
1874                 {
1875                         Bitmap* pOnOffSlidingDisabledBgBitmap = __pCheckButton->GetOnOffSlidingBgBitmap(_CHECK_BUTTON_STATUS_DISABLED);
1876
1877                         if (pOnOffSlidingDisabledBgBitmap)
1878                         {
1879                                 pCanvas->DrawBitmap(FloatPoint(__onOffSlidingButtonBounds.x, __onOffSlidingButtonBounds.y), *pOnOffSlidingDisabledBgBitmap);
1880                         }
1881
1882                         Bitmap* pOnOffSlidingOnHandlerDisabledBitmap = __pCheckButton->GetOnOffSlidingOnHandlerBitmap(_CHECK_BUTTON_STATUS_DISABLED);
1883
1884                         if (pOnOffSlidingOnHandlerDisabledBitmap)
1885                         {
1886                                 pCanvas->DrawBitmap(FloatPoint(handlerPosition, __onOffSlidingButtonBounds.y - handlerMargin), *pOnOffSlidingOnHandlerDisabledBitmap);
1887                         }
1888                 }
1889                 else if (checkStatus == _CHECK_BUTTON_STATUS_PRESSED)
1890                 {
1891                         Bitmap* pOnOffSlidingPressedBgBitmap = __pCheckButton->GetOnOffSlidingBgBitmap(_CHECK_BUTTON_STATUS_PRESSED);
1892
1893                         if (pOnOffSlidingPressedBgBitmap)
1894                         {
1895                                 pCanvas->DrawBitmap(FloatPoint(__onOffSlidingButtonBounds.x, __onOffSlidingButtonBounds.y), *pOnOffSlidingPressedBgBitmap);
1896                         }
1897
1898                         Bitmap* pOnOffSlidingOnHandlerPressedBitmap = __pCheckButton->GetOnOffSlidingOnHandlerBitmap(_CHECK_BUTTON_STATUS_PRESSED);
1899
1900                         if (pOnOffSlidingOnHandlerPressedBitmap)
1901                         {
1902                                 pCanvas->DrawBitmap(FloatPoint(handlerPosition, __onOffSlidingButtonBounds.y - handlerMargin), *pOnOffSlidingOnHandlerPressedBitmap);
1903                         }
1904                 }
1905                 else if (checkStatus == _CHECK_BUTTON_STATUS_HIGHLIGHTED)
1906                 {
1907                         Bitmap* pOnOffSlidingHighlightedBgBitmap = __pCheckButton->GetOnOffSlidingBgBitmap(_CHECK_BUTTON_STATUS_HIGHLIGHTED);
1908
1909                         if (pOnOffSlidingHighlightedBgBitmap)
1910                         {
1911                                 pCanvas->DrawBitmap(FloatPoint(__onOffSlidingButtonBounds.x, __onOffSlidingButtonBounds.y), *pOnOffSlidingHighlightedBgBitmap);
1912                         }
1913
1914                         Bitmap* pOnOffSlidingOnHandlerNormalBitmap = __pCheckButton->GetOnOffSlidingOnHandlerBitmap(_CHECK_BUTTON_STATUS_NORMAL);
1915
1916                         if (pOnOffSlidingOnHandlerNormalBitmap)
1917                         {
1918                                 pCanvas->DrawBitmap(FloatPoint(handlerPosition, __onOffSlidingButtonBounds.y - handlerMargin), *pOnOffSlidingOnHandlerNormalBitmap);
1919                         }
1920
1921                         Bitmap* pOnOffSlidingOnHandlerHighlightedBitmap = __pCheckButton->GetOnOffSlidingOnHandlerBitmap(_CHECK_BUTTON_STATUS_HIGHLIGHTED);
1922
1923                         if (pOnOffSlidingOnHandlerHighlightedBitmap)
1924                         {
1925                                 pReplacementColorBackgroundBitmap = _BitmapImpl::GetColorReplacedBitmapN(*pOnOffSlidingOnHandlerHighlightedBitmap, Color::GetColor(COLOR_ID_MAGENTA),
1926                                                 detailedHighlightedBackgroundColor);
1927                         }
1928
1929                         if (pReplacementColorBackgroundBitmap)
1930                         {
1931                                 pCanvas->DrawBitmap(FloatPoint(handlerPosition, __onOffSlidingButtonBounds.y - handlerMargin), *pReplacementColorBackgroundBitmap);
1932                         }
1933                 }
1934                 else if (checkStatus == _CHECK_BUTTON_STATUS_SELECTED)
1935                 {
1936                         Bitmap* pOnOffSlidingSelectedBgBitmap = __pCheckButton->GetOnOffSlidingBgBitmap(_CHECK_BUTTON_STATUS_SELECTED);
1937
1938                         if (pOnOffSlidingSelectedBgBitmap)
1939                         {
1940                                 pCanvas->DrawBitmap(FloatPoint(__onOffSlidingButtonBounds.x, __onOffSlidingButtonBounds.y), *pOnOffSlidingSelectedBgBitmap);
1941                         }
1942
1943                         Bitmap* pOnOffSlidingOnHandlerSelectedBitmap = __pCheckButton->GetOnOffSlidingOnHandlerBitmap(_CHECK_BUTTON_STATUS_SELECTED);
1944
1945                         if (pOnOffSlidingOnHandlerSelectedBitmap)
1946                         {
1947                                 pCanvas->DrawBitmap(FloatPoint(handlerPosition, __onOffSlidingButtonBounds.y - handlerMargin), *pOnOffSlidingOnHandlerSelectedBitmap);
1948                         }
1949                 }
1950         }
1951
1952         delete pCanvas;
1953         delete pReplacementColorBackgroundBitmap;
1954
1955         return;
1956 }
1957
1958 bool
1959 _CheckButtonPresenter::OnTouchCanceled(const _Control& source, const _TouchInfo& touchinfo)
1960 {
1961         if (&source != __pCheckButton)
1962         {
1963                 return false;
1964         }
1965
1966         if (!__pCheckButton->IsEnabled())
1967         {
1968                 return true;
1969         }
1970
1971         __pCheckButton->SetCheckButtonStatus(_CHECK_BUTTON_STATUS_NORMAL);
1972         __pCheckButton->Invalidate();
1973
1974         return true;
1975 }
1976
1977 void
1978 _CheckButtonPresenter::OnTouchMoveHandled(const _Control& control)
1979 {
1980         __touchMoveHandled = true;
1981         __pCheckButton->SetCheckButtonStatus(_CHECK_BUTTON_STATUS_NORMAL);
1982         __pCheckButton->Invalidate();
1983
1984         return;
1985 }
1986
1987 bool
1988 _CheckButtonPresenter::OnKeyPressed(const _Control& source, const _KeyInfo& keyInfo)
1989 {
1990         return false;
1991 }
1992
1993 bool
1994 _CheckButtonPresenter::OnKeyReleased(const _Control& source, const _KeyInfo& keyInfo)
1995 {
1996         _KeyCode keyCode = keyInfo.GetKeyCode();
1997
1998         if (__pCheckButton->IsFocusModeStateEnabled() == true && keyCode == _KEY_ENTER)
1999         {
2000                 CheckButtonStyle checkStyle = __pCheckButton->GetCheckButtonStyle();
2001
2002                 if (checkStyle == CHECK_BUTTON_STYLE_MARK || checkStyle == CHECK_BUTTON_STYLE_MARK_WITH_DIVIDER || checkStyle == CHECK_BUTTON_STYLE_MARK_WITH_DETAILED_BUTTON
2003                                 || checkStyle == CHECK_BUTTON_STYLE_RADIO || checkStyle == CHECK_BUTTON_STYLE_RADIO_WITH_DIVIDER || checkStyle == CHECK_BUTTON_STYLE_RADIO_WITH_DETAILED_BUTTON)
2004                 {
2005                         StartCheckAnimationTimer();
2006                         __ratio = 0;
2007                 }
2008
2009                 __pCheckButton->SetCheckButtonStatus(_CHECK_BUTTON_STATUS_HIGHLIGHTED);
2010                 __pCheckButton->Invalidate();
2011
2012                 PLAY_FEEDBACK(_RESOURCE_FEEDBACK_PATTERN_TAP, __pCheckButton);
2013
2014                 __pCheckButton->FireActionEvent();
2015
2016                 if (__pCheckButton->GetRadioGroup() != null)
2017                 {
2018                         __pCheckButton->SendTouchReleasedEvent(*__pCheckButton);
2019                 }
2020
2021                 if (checkStyle == CHECK_BUTTON_STYLE_ONOFF_SLIDING_WITH_DIVIDER || checkStyle == CHECK_BUTTON_STYLE_ONOFF_SLIDING)
2022                 {
2023                         AdjustHandlerPosition();
2024
2025                         __onOffHandlerPressed = false;
2026                         __onOffHandlerMoved = false;
2027                 }
2028         }
2029
2030         return false;
2031 }
2032
2033 bool
2034 _CheckButtonPresenter::IsEnabledStateChanged(void)
2035 {
2036         bool __currentEnabledState = __pCheckButton->GetEnableState();
2037
2038         if (__currentEnabledState != __previousEnabledState)
2039         {
2040                 __previousEnabledState = __currentEnabledState;
2041                 return true;
2042         }
2043         else
2044         {
2045                 return false;
2046         }
2047 }
2048
2049 result
2050 _CheckButtonPresenter::CalculateTitleTextBounds(void)
2051 {
2052         float checkButtonLeftMargin = 0.0f;
2053         float checkButtonTopMargin = 0.0f;
2054         float checkButtonBitmapWidth = 0.0f;
2055         float checkButtonOnOffSlidingBitmapWidth = 0.0f;
2056         float checkButtonDetailedBitmapWidth = 0.0f;
2057         float checkButtonTitleTextHeight = 0.0f;
2058         float checkButtonTextHeight = 0.0f;
2059
2060         FloatDimension minDimension(0.0f, 0.0f);
2061         FloatDimension minDimensionWithAnnex(0.0f, 0.0f);
2062
2063         GET_SHAPE_CONFIG(CHECKBUTTON::LEFT_MARGIN, _CONTROL_ORIENTATION_PORTRAIT, checkButtonLeftMargin);
2064         GET_SHAPE_CONFIG(CHECKBUTTON::TOP_MARGIN, _CONTROL_ORIENTATION_PORTRAIT, checkButtonTopMargin);
2065         GET_SHAPE_CONFIG(CHECKBUTTON::MARK_BITMAP_WIDTH, _CONTROL_ORIENTATION_PORTRAIT, checkButtonBitmapWidth);
2066         GET_SHAPE_CONFIG(CHECKBUTTON::ONOFF_SLIDING_BITMAP_WIDTH, _CONTROL_ORIENTATION_PORTRAIT, checkButtonOnOffSlidingBitmapWidth);
2067         GET_SHAPE_CONFIG(CHECKBUTTON::DETAILED_BITMAP_WIDTH, _CONTROL_ORIENTATION_PORTRAIT, checkButtonDetailedBitmapWidth);
2068         GET_SHAPE_CONFIG(CHECKBUTTON::TITLE_TEXT_HEIGHT, _CONTROL_ORIENTATION_PORTRAIT, checkButtonTitleTextHeight);
2069         GET_SHAPE_CONFIG(CHECKBUTTON::TEXT_HEIGHT, _CONTROL_ORIENTATION_PORTRAIT, checkButtonTextHeight);
2070
2071         GET_DIMENSION_CONFIG(CHECKBUTTON::MIN_DIMENSION, __pCheckButton->GetOrientation(), minDimension);
2072         GET_DIMENSION_CONFIG(CHECKBUTTON::MIN_DIMENSION_WITH_ANNEX, __pCheckButton->GetOrientation(), minDimensionWithAnnex);
2073
2074         FloatRectangle bounds(0.0f, 0.0f, __pCheckButton->GetBoundsF().width, __pCheckButton->GetBoundsF().height);
2075
2076         CheckButtonStyle checkStyle = __pCheckButton->GetCheckButtonStyle();
2077
2078         if (checkStyle == CHECK_BUTTON_STYLE_MARK || checkStyle == CHECK_BUTTON_STYLE_MARK_WITH_DIVIDER || checkStyle == CHECK_BUTTON_STYLE_ONOFF
2079                         || checkStyle == CHECK_BUTTON_STYLE_ONOFF_WITH_DIVIDER || checkStyle == CHECK_BUTTON_STYLE_RADIO || checkStyle == CHECK_BUTTON_STYLE_RADIO_WITH_DIVIDER)
2080         {
2081                 if (bounds.width < minDimension.width )
2082                 {
2083                         bounds.width = minDimension.width;
2084                 }
2085
2086                 if (bounds.height < minDimension.height )
2087                 {
2088                         bounds.height = minDimension.height;
2089                 }
2090         }
2091         else
2092         {
2093                 if (bounds.width < minDimensionWithAnnex.width )
2094                 {
2095                         bounds.width = minDimensionWithAnnex.width;
2096                 }
2097
2098                 if (bounds.height < minDimensionWithAnnex.height )
2099                 {
2100                         bounds.height = minDimensionWithAnnex.height;
2101                 }
2102         }
2103
2104         if (checkStyle == CHECK_BUTTON_STYLE_ONOFF_SLIDING || checkStyle == CHECK_BUTTON_STYLE_ONOFF_SLIDING_WITH_DIVIDER)
2105         {
2106                 __titleTextBounds.x = checkButtonLeftMargin;
2107                 __titleTextBounds.y = checkButtonTopMargin;
2108                 __titleTextBounds.width = bounds.width - checkButtonLeftMargin * 3 - checkButtonOnOffSlidingBitmapWidth;
2109                 __titleTextBounds.height = bounds.height - checkButtonTopMargin * 2 - __textBounds.height;
2110         }
2111         else
2112         {
2113                 if (checkStyle == CHECK_BUTTON_STYLE_MARK_WITH_DETAILED_BUTTON || checkStyle == CHECK_BUTTON_STYLE_RADIO_WITH_DETAILED_BUTTON)
2114                 {
2115                         __titleTextBounds.x = checkButtonLeftMargin * 2 + checkButtonBitmapWidth;
2116                         __titleTextBounds.y = checkButtonTopMargin;
2117                         __titleTextBounds.width = bounds.width - checkButtonLeftMargin * 4 - checkButtonBitmapWidth - checkButtonDetailedBitmapWidth;
2118                         __titleTextBounds.height = bounds.height - checkButtonTopMargin * 2 - __textBounds.height;
2119                 }
2120                 else
2121                 {
2122                         __titleTextBounds.x = checkButtonLeftMargin * 2 + checkButtonBitmapWidth;
2123                         __titleTextBounds.y = checkButtonTopMargin;
2124                         __titleTextBounds.width = bounds.width - checkButtonLeftMargin * 3 - checkButtonBitmapWidth;
2125                         __titleTextBounds.height = bounds.height - checkButtonTopMargin * 2 - __textBounds.height;
2126                 }
2127         }
2128
2129         return E_SUCCESS;
2130 }
2131
2132 result
2133 _CheckButtonPresenter::CalculateTextBounds(void)
2134 {
2135         float checkButtonLeftMargin = 0.0f;
2136         float checkButtonTopMargin = 0.0f;
2137         float checkButtonBitmapWidth = 0.0f;
2138         float checkButtonOnOffSlidingBitmapWidth = 0.0f;
2139         float checkButtonDetailedBitmapWidth = 0.0f;
2140         float checkButtonTitleTextHeight = 0.0f;
2141         float checkButtonTextHeight = 0.0f;
2142
2143         FloatDimension minDimension(0.0f, 0.0f);
2144         FloatDimension minDimensionWithAnnex(0.0f, 0.0f);
2145
2146         GET_SHAPE_CONFIG(CHECKBUTTON::LEFT_MARGIN, _CONTROL_ORIENTATION_PORTRAIT, checkButtonLeftMargin);
2147         GET_SHAPE_CONFIG(CHECKBUTTON::TOP_MARGIN, _CONTROL_ORIENTATION_PORTRAIT, checkButtonTopMargin);
2148         GET_SHAPE_CONFIG(CHECKBUTTON::MARK_BITMAP_WIDTH, _CONTROL_ORIENTATION_PORTRAIT, checkButtonBitmapWidth);
2149         GET_SHAPE_CONFIG(CHECKBUTTON::ONOFF_SLIDING_BITMAP_WIDTH, _CONTROL_ORIENTATION_PORTRAIT, checkButtonOnOffSlidingBitmapWidth);
2150         GET_SHAPE_CONFIG(CHECKBUTTON::DETAILED_BITMAP_WIDTH, _CONTROL_ORIENTATION_PORTRAIT, checkButtonDetailedBitmapWidth);
2151         GET_SHAPE_CONFIG(CHECKBUTTON::TITLE_TEXT_HEIGHT, _CONTROL_ORIENTATION_PORTRAIT, checkButtonTitleTextHeight);
2152         GET_SHAPE_CONFIG(CHECKBUTTON::TEXT_HEIGHT, _CONTROL_ORIENTATION_PORTRAIT, checkButtonTextHeight);
2153
2154         GET_DIMENSION_CONFIG(CHECKBUTTON::MIN_DIMENSION, __pCheckButton->GetOrientation(), minDimension);
2155         GET_DIMENSION_CONFIG(CHECKBUTTON::MIN_DIMENSION_WITH_ANNEX, __pCheckButton->GetOrientation(), minDimensionWithAnnex);
2156
2157         FloatRectangle bounds(0.0f, 0.0f, __pCheckButton->GetBoundsF().width, __pCheckButton->GetBoundsF().height);
2158
2159         CheckButtonStyle checkStyle = __pCheckButton->GetCheckButtonStyle();
2160         bool showTitle = __pCheckButton->GetShowTitle();
2161
2162         if (checkStyle == CHECK_BUTTON_STYLE_MARK || checkStyle == CHECK_BUTTON_STYLE_MARK_WITH_DIVIDER || checkStyle == CHECK_BUTTON_STYLE_ONOFF
2163                         || checkStyle == CHECK_BUTTON_STYLE_ONOFF_WITH_DIVIDER || checkStyle == CHECK_BUTTON_STYLE_RADIO || checkStyle == CHECK_BUTTON_STYLE_RADIO_WITH_DIVIDER)
2164         {
2165                 if (bounds.width < minDimension.width )
2166                 {
2167                         bounds.width = minDimension.width;
2168                 }
2169
2170                 if (bounds.height < minDimension.height )
2171                 {
2172                         bounds.height = minDimension.height;
2173                 }
2174         }
2175         else
2176         {
2177                 if (bounds.width < minDimensionWithAnnex.width )
2178                 {
2179                         bounds.width = minDimensionWithAnnex.width;
2180                 }
2181
2182                 if (bounds.height < minDimensionWithAnnex.height )
2183                 {
2184                         bounds.height = minDimensionWithAnnex.height;
2185                 }
2186         }
2187
2188         if (checkStyle == CHECK_BUTTON_STYLE_ONOFF_SLIDING || checkStyle == CHECK_BUTTON_STYLE_ONOFF_SLIDING_WITH_DIVIDER)
2189         {
2190                 if (showTitle)
2191                 {
2192                         __textBounds.x = checkButtonLeftMargin;
2193                         __textBounds.y = checkButtonTopMargin + checkButtonTitleTextHeight;
2194                         __textBounds.width = bounds.width - checkButtonLeftMargin * 3 - checkButtonOnOffSlidingBitmapWidth;
2195                         __textBounds.height = bounds.height - checkButtonTopMargin * 2 - checkButtonTitleTextHeight;
2196                 }
2197                 else
2198                 {
2199                         __textBounds.x = checkButtonLeftMargin;
2200                         __textBounds.y = checkButtonTopMargin;
2201                         __textBounds.width = bounds.width - checkButtonLeftMargin * 3 - checkButtonOnOffSlidingBitmapWidth;
2202                         __textBounds.height = bounds.height - checkButtonTopMargin * 2;
2203                 }
2204         }
2205         else
2206         {
2207                 if (checkStyle == CHECK_BUTTON_STYLE_MARK_WITH_DETAILED_BUTTON || checkStyle == CHECK_BUTTON_STYLE_RADIO_WITH_DETAILED_BUTTON)
2208                 {
2209                         if (showTitle)
2210                         {
2211                                 __textBounds.x = checkButtonLeftMargin * 2 + checkButtonBitmapWidth;
2212                                 __textBounds.y = checkButtonTopMargin + checkButtonTitleTextHeight;
2213                                 __textBounds.width = bounds.width - checkButtonLeftMargin * 4 - checkButtonBitmapWidth - checkButtonDetailedBitmapWidth;
2214                                 __textBounds.height = bounds.height - checkButtonTopMargin * 2 - checkButtonTitleTextHeight;
2215                         }
2216                         else
2217                         {
2218                                 __textBounds.x = checkButtonLeftMargin * 2 + checkButtonBitmapWidth;
2219                                 __textBounds.y = checkButtonTopMargin;
2220                                 __textBounds.width = bounds.width - checkButtonLeftMargin * 4 - checkButtonBitmapWidth - checkButtonDetailedBitmapWidth;
2221                                 __textBounds.height = bounds.height - checkButtonTopMargin * 2;
2222                         }
2223                 }
2224                 else
2225                 {
2226                         if (showTitle)
2227                         {
2228                                 __textBounds.x = checkButtonLeftMargin * 2 + checkButtonBitmapWidth;
2229                                 __textBounds.y = checkButtonTopMargin + checkButtonTitleTextHeight;
2230                                 __textBounds.width = bounds.width - checkButtonLeftMargin * 3 - checkButtonBitmapWidth;
2231                                 __textBounds.height = bounds.height - checkButtonTopMargin * 2 - checkButtonTitleTextHeight;
2232                         }
2233                         else
2234                         {
2235                                 __textBounds.x = checkButtonLeftMargin * 2 + checkButtonBitmapWidth;
2236                                 __textBounds.y = checkButtonTopMargin;
2237                                 __textBounds.width = bounds.width - checkButtonLeftMargin * 3 - checkButtonBitmapWidth;
2238                                 __textBounds.height = bounds.height - checkButtonTopMargin * 2;
2239                         }
2240                 }
2241         }
2242
2243         return E_SUCCESS;
2244 }
2245
2246 result
2247 _CheckButtonPresenter::CalculateButtonBounds(void)
2248 {
2249         float checkButtonLeftMargin = 0.0f;
2250         float checkButtonBitmapWidth = 0.0f;
2251         float checkButtonBitmapHeight = 0.0f;
2252         float checkButtonOnOffSlidingBitmapWidth = 0.0f;
2253         float checkButtonOnOffSlidingBitmapHeight = 0.0f;
2254         float checkButtonDetaieldBitmapWidth = 0.0f;
2255         float checkButtonDetaieldBitmapHeight = 0.0f;
2256
2257         FloatDimension minDimension(0.0f, 0.0f);
2258         FloatDimension minDimensionWithAnnex(0.0f, 0.0f);
2259
2260         GET_SHAPE_CONFIG(CHECKBUTTON::LEFT_MARGIN, _CONTROL_ORIENTATION_PORTRAIT, checkButtonLeftMargin);
2261         GET_SHAPE_CONFIG(CHECKBUTTON::MARK_BITMAP_WIDTH, _CONTROL_ORIENTATION_PORTRAIT, checkButtonBitmapWidth);
2262         GET_SHAPE_CONFIG(CHECKBUTTON::MARK_BITMAP_HEIGHT, _CONTROL_ORIENTATION_PORTRAIT, checkButtonBitmapHeight);
2263         GET_SHAPE_CONFIG(CHECKBUTTON::ONOFF_SLIDING_BITMAP_WIDTH, _CONTROL_ORIENTATION_PORTRAIT, checkButtonOnOffSlidingBitmapWidth);
2264         GET_SHAPE_CONFIG(CHECKBUTTON::ONOFF_SLIDING_BITMAP_HEIGHT, _CONTROL_ORIENTATION_PORTRAIT, checkButtonOnOffSlidingBitmapHeight);
2265         GET_SHAPE_CONFIG(CHECKBUTTON::DETAILED_BITMAP_WIDTH, _CONTROL_ORIENTATION_PORTRAIT, checkButtonDetaieldBitmapWidth);
2266         GET_SHAPE_CONFIG(CHECKBUTTON::DETAILED_BITMAP_HEIGHT, _CONTROL_ORIENTATION_PORTRAIT, checkButtonDetaieldBitmapHeight);
2267
2268         GET_DIMENSION_CONFIG(CHECKBUTTON::MIN_DIMENSION, __pCheckButton->GetOrientation(), minDimension);
2269         GET_DIMENSION_CONFIG(CHECKBUTTON::MIN_DIMENSION_WITH_ANNEX, __pCheckButton->GetOrientation(), minDimensionWithAnnex);
2270
2271         FloatRectangle bounds(0.0f, 0.0f, __pCheckButton->GetBoundsF().width, __pCheckButton->GetBoundsF().height);
2272
2273         CheckButtonStyle checkStyle = __pCheckButton->GetCheckButtonStyle();
2274
2275         if (checkStyle == CHECK_BUTTON_STYLE_MARK || checkStyle == CHECK_BUTTON_STYLE_MARK_WITH_DIVIDER || checkStyle == CHECK_BUTTON_STYLE_ONOFF
2276                         || checkStyle == CHECK_BUTTON_STYLE_ONOFF_WITH_DIVIDER || checkStyle == CHECK_BUTTON_STYLE_RADIO || checkStyle == CHECK_BUTTON_STYLE_RADIO_WITH_DIVIDER)
2277         {
2278                 if (bounds.width < minDimension.width )
2279                 {
2280                         bounds.width = minDimension.width;
2281                 }
2282
2283                 if (bounds.height < minDimension.height )
2284                 {
2285                         bounds.height = minDimension.height;
2286                 }
2287         }
2288         else
2289         {
2290                 if (bounds.width < minDimensionWithAnnex.width )
2291                 {
2292                         bounds.width = minDimensionWithAnnex.width;
2293                 }
2294
2295                 if (bounds.height < minDimensionWithAnnex.height )
2296                 {
2297                         bounds.height = minDimensionWithAnnex.height;
2298                 }
2299         }
2300
2301         __defaultButtonBounds.x = checkButtonLeftMargin;
2302         __defaultButtonBounds.y = (bounds.height - checkButtonBitmapHeight) / 2;
2303         __defaultButtonBounds.width = checkButtonBitmapWidth;
2304         __defaultButtonBounds.height = checkButtonBitmapHeight;
2305
2306         __onOffSlidingButtonBounds.x = bounds.width - checkButtonLeftMargin - checkButtonOnOffSlidingBitmapWidth;
2307         __onOffSlidingButtonBounds.y = (bounds.height - checkButtonOnOffSlidingBitmapHeight) / 2;
2308         __onOffSlidingButtonBounds.width = checkButtonOnOffSlidingBitmapWidth;
2309         __onOffSlidingButtonBounds.height = checkButtonOnOffSlidingBitmapHeight;
2310
2311         __detailedButtonBounds.x = bounds.width - checkButtonLeftMargin - checkButtonDetaieldBitmapWidth;
2312         __detailedButtonBounds.y = (bounds.height - checkButtonDetaieldBitmapHeight) / 2;
2313         __detailedButtonBounds.width = checkButtonDetaieldBitmapWidth;
2314         __detailedButtonBounds.height = checkButtonDetaieldBitmapHeight;
2315
2316         return E_SUCCESS;
2317 }
2318
2319 FloatRectangle
2320 _CheckButtonPresenter::GetTitleTextBoundsF(void) const
2321 {
2322         return __titleTextBounds;
2323 }
2324
2325 FloatRectangle
2326 _CheckButtonPresenter::GetTextBoundsF(void) const
2327 {
2328         return __textBounds;
2329 }
2330
2331 FloatRectangle
2332 _CheckButtonPresenter::GetDefaultButtonBoundsF(void) const
2333 {
2334         return __defaultButtonBounds;
2335 }
2336
2337 FloatRectangle
2338 _CheckButtonPresenter::GetOnOffSlidingButtonBoundsF(void) const
2339 {
2340         return __onOffSlidingButtonBounds;
2341 }
2342
2343 FloatRectangle
2344 _CheckButtonPresenter::GetDetailedButtonBoundsF(void) const
2345 {
2346         return __detailedButtonBounds;
2347 }
2348
2349 result
2350 _CheckButtonPresenter::StartCheckAnimationTimer(void)
2351 {
2352         result r = E_SUCCESS;
2353         if (__pCheckAnimationTimer == null)
2354         {
2355                 __pCheckAnimationTimer = new (std::nothrow) Timer;
2356                 SysTryReturn(NID_UI_CTRL, (__pCheckAnimationTimer != null), E_OUT_OF_MEMORY, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] Memroy allocation failed.");
2357
2358                 r = __pCheckAnimationTimer->Construct(*this);
2359                 SysTryCatch(NID_UI, r == E_SUCCESS, , r, "[%s] Propagating.", GetErrorMessage(r));
2360         }
2361         else
2362         {
2363                 __pCheckAnimationTimer->Cancel();
2364         }
2365
2366         __pCheckAnimationTimer->Start(CHECK_ACTION_TIMER_PERIOD);
2367         SysTryCatch(NID_UI, r == E_SUCCESS, , r, "[%s] Propagating.", GetErrorMessage(r));
2368
2369         return r;
2370 CATCH:
2371         ResetCheckAnimationTimer();
2372         return r;
2373 }
2374
2375 result
2376 _CheckButtonPresenter::ResetCheckAnimationTimer(void)
2377 {
2378         delete __pCheckAnimationTimer;
2379         __pCheckAnimationTimer = null;
2380
2381         return E_SUCCESS;
2382 }
2383
2384 void
2385 _CheckButtonPresenter::OnTimerExpired(Timer& timer)
2386 {
2387         __ratio++;
2388
2389         if (__ratio <= RATIO_MAX)
2390         {
2391                 StartCheckAnimationTimer();
2392                 DrawMarkAnimation();
2393         }
2394         else
2395         {
2396                 ResetCheckAnimationTimer();
2397                 __ratio = 10;
2398         }
2399
2400         return;
2401 }
2402
2403 void
2404 _CheckButtonPresenter::OnDrawFocus(void)
2405 {
2406         if (__pCheckButton->IsFocusModeStateEnabled() == false)
2407         {
2408                 __focusPrevStatus = __pCheckButton->GetCheckButtonStatus();
2409                 __pCheckButton->SetCheckButtonStatus(_CHECK_BUTTON_STATUS_HIGHLIGHTED);
2410                 __pCheckButton->Invalidate();
2411         }
2412
2413         return;
2414 }
2415
2416 void
2417 _CheckButtonPresenter::OnChildControlFocusMoved(const _Control& control)
2418 {
2419         return;
2420 }
2421
2422 bool
2423 _CheckButtonPresenter::IsChildControlFocusManage(void) const
2424 {
2425         return true;
2426 }
2427
2428 void
2429 _CheckButtonPresenter::OnFocusableStateChanged(bool focusalbeState)
2430 {
2431         return;
2432 }
2433
2434 void
2435 _CheckButtonPresenter::OnFocusModeStateChanged(void)
2436 {
2437         __pCheckButton->SetCheckButtonStatus(__focusPrevStatus);
2438         __pCheckButton->Invalidate();
2439
2440         return;
2441 }
2442
2443 bool
2444 _CheckButtonPresenter::OnFocusGained(const _Control& source)
2445 {
2446         if (__pCheckButton->IsFocusModeStateEnabled() == true)
2447         {
2448                 __focusPrevStatus = __pCheckButton->GetCheckButtonStatus();
2449                 __pCheckButton->SetCheckButtonStatus(_CHECK_BUTTON_STATUS_HIGHLIGHTED);
2450                 __pCheckButton->Invalidate();
2451         }
2452
2453         return true;
2454 }
2455
2456 bool
2457 _CheckButtonPresenter::OnFocusLost(const _Control& source)
2458 {
2459         __pCheckButton->SetCheckButtonStatus(__focusPrevStatus);
2460         __pCheckButton->Invalidate();
2461
2462         return true;
2463 }
2464 void
2465 _CheckButtonPresenter::DrawMarkAnimation(void)
2466 {
2467         Canvas* pCanvas = __pCheckButton->GetCanvasN();
2468         if (pCanvas == null)
2469         {
2470                 SysLog(NID_UI_CTRL, "Cannot get a canvas.");
2471
2472                 return;
2473         }
2474
2475         _CheckButtonStatus checkStatus = __pCheckButton->GetCheckButtonStatus();
2476
2477         if (checkStatus == _CHECK_BUTTON_STATUS_NORMAL)
2478         {
2479                 Bitmap* pMarkNormalBitmap = __pCheckButton->GetMarkBitmap(_CHECK_BUTTON_STATUS_NORMAL);
2480
2481                 if (__pCheckButton->IsSelected() && pMarkNormalBitmap)
2482                 {
2483                         FloatRectangle sourceRect(0.0f, 0.0f, pMarkNormalBitmap->GetWidthF() * __ratio * 0.1, pMarkNormalBitmap->GetHeightF());
2484                         FloatRectangle destRect(__defaultButtonBounds.x, __defaultButtonBounds.y, pMarkNormalBitmap->GetWidthF() * __ratio * 0.1, pMarkNormalBitmap->GetHeightF());
2485
2486                         pCanvas->DrawBitmap(destRect, *pMarkNormalBitmap, sourceRect);
2487                 }
2488         }
2489         else if (checkStatus == _CHECK_BUTTON_STATUS_DISABLED)
2490         {
2491                 Bitmap* pMarkDisabledBitmap = __pCheckButton->GetMarkBitmap(_CHECK_BUTTON_STATUS_DISABLED);
2492
2493                 if (__pCheckButton->IsSelected() && pMarkDisabledBitmap)
2494                 {
2495                         FloatRectangle sourceRect(0.0f, 0.0f, pMarkDisabledBitmap->GetWidthF() * __ratio * 0.1, pMarkDisabledBitmap->GetHeightF());
2496                         FloatRectangle destRect(__defaultButtonBounds.x, __defaultButtonBounds.y, pMarkDisabledBitmap->GetWidthF() * __ratio * 0.1, pMarkDisabledBitmap->GetHeightF());
2497
2498                         pCanvas->DrawBitmap(destRect, *pMarkDisabledBitmap, sourceRect);
2499                 }
2500         }
2501         else if (checkStatus == _CHECK_BUTTON_STATUS_PRESSED)
2502         {
2503                 Bitmap* pMarkPressedBitmap = __pCheckButton->GetMarkBitmap(_CHECK_BUTTON_STATUS_PRESSED);
2504
2505                 if (__pCheckButton->IsSelected() && pMarkPressedBitmap)
2506                 {
2507                         FloatRectangle sourceRect(0.0f, 0.0f, pMarkPressedBitmap->GetWidthF() * __ratio * 0.1, pMarkPressedBitmap->GetHeightF());
2508                         FloatRectangle destRect(__defaultButtonBounds.x, __defaultButtonBounds.y, pMarkPressedBitmap->GetWidthF() * __ratio * 0.1, pMarkPressedBitmap->GetHeightF());
2509
2510                         pCanvas->DrawBitmap(destRect, *pMarkPressedBitmap, sourceRect);
2511                 }
2512         }
2513         else if (checkStatus == _CHECK_BUTTON_STATUS_HIGHLIGHTED)
2514         {
2515                 Bitmap* pMarkHighlightedBitmap = __pCheckButton->GetMarkBitmap(_CHECK_BUTTON_STATUS_HIGHLIGHTED);
2516
2517                 if (__pCheckButton->IsSelected() && pMarkHighlightedBitmap)
2518                 {
2519                         FloatRectangle sourceRect(0.0f, 0.0f, pMarkHighlightedBitmap->GetWidthF() * __ratio * 0.1, pMarkHighlightedBitmap->GetHeightF());
2520                         FloatRectangle destRect(__defaultButtonBounds.x, __defaultButtonBounds.y, pMarkHighlightedBitmap->GetWidthF() * __ratio * 0.1, pMarkHighlightedBitmap->GetHeightF());
2521
2522                         pCanvas->DrawBitmap(destRect, *pMarkHighlightedBitmap, sourceRect);
2523                 }
2524         }
2525         else if (checkStatus == _CHECK_BUTTON_STATUS_SELECTED)
2526         {
2527                 Bitmap* pMarkSelectedBitmap = __pCheckButton->GetMarkBitmap(_CHECK_BUTTON_STATUS_SELECTED);
2528
2529                 if (__pCheckButton->IsSelected() && pMarkSelectedBitmap)
2530                 {
2531                         FloatRectangle sourceRect(0.0f, 0.0f, pMarkSelectedBitmap->GetWidthF() * __ratio * 0.1, pMarkSelectedBitmap->GetHeightF());
2532                         FloatRectangle destRect(__defaultButtonBounds.x, __defaultButtonBounds.y, pMarkSelectedBitmap->GetWidthF() * __ratio * 0.1, pMarkSelectedBitmap->GetHeightF());
2533
2534                         pCanvas->DrawBitmap(destRect, *pMarkSelectedBitmap, sourceRect);
2535                 }
2536         }
2537
2538         delete pCanvas;
2539
2540         return;
2541 }
2542
2543 }}} // Tizen::Ui::Controls