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 Flora License, Version 1.0 (the License);
   6 // you may not use this file except in compliance with the License.
   7 // You may obtain a copy of the License at
   8 //
   9 //     http://floralicense.org/license/
  10 //
  11 // Unless required by applicable law or agreed to in writing, software
  12 // distributed under the License is distributed on an AS IS BASIS,
  13 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  14 // See the License for the specific language governing permissions and
  15 // limitations under the License.
  16 //
  17 /**
  18  * @file                FUiCtrl_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_ResourceManager.h"
  30 #include "FUi_UiTouchEvent.h"
  31 #include "FUiAnim_VisualElement.h"
  32 #include "FUiCtrl_CheckButtonPresenter.h"
  33 #include "FUiCtrl_CheckButtonModel.h"
  34 #include "FUiCtrl_CheckButton.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(Rectangle())
  54         , __textBounds(Rectangle())
  55         , __defaultButtonBounds(Rectangle())
  56         , __onOffSlidingButtonBounds(Rectangle())
  57         , __detailedButtonBounds(Rectangle())
  58         , __fontStyle(0)
  59         , __fontSize(0)
  60         , __pCheckAnimationTimer(null)
  61         , __ratio(10)
  62 {
  63
  64 }
  65
  66 _CheckButtonPresenter::~_CheckButtonPresenter(void)
  67 {
  68         if (__pCheckButtonModel)
  69         {
  70                 delete __pCheckButtonModel;
  71                 __pCheckButtonModel = null;
  72         }
  73
  74         if (__pTextObject)
  75         {
  76                 delete __pTextObject;
  77                 __pTextObject = null;
  78         }
  79
  80         if (__pTitleTextObject)
  81         {
  82                 delete __pTitleTextObject;
  83                 __pTitleTextObject = null;
  84         }
  85
  86         if (__pCheckAnimationTimer)
  87         {
  88                 delete __pCheckAnimationTimer;
  89                 __pCheckAnimationTimer = null;
  90         }
  91 }
  92
  93 result
  94 _CheckButtonPresenter::Construct(const _CheckButton& checkButton)
  95 {
  96         result r = E_SUCCESS;
  97
  98         __pCheckButton = const_cast <_CheckButton*>(&checkButton);
  99
 100         __fontStyle = FONT_STYLE_PLAIN;
 101
 102         __pTextObject = new (std::nothrow) TextObject();
 103         SysTryCatch(NID_UI_CTRL, __pTextObject != null, r = E_OUT_OF_MEMORY, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] Memory is insufficient.");
 104
 105         __pTitleTextObject = new (std::nothrow) TextObject();
 106         SysTryCatch(NID_UI_CTRL, __pTitleTextObject != null, r = E_OUT_OF_MEMORY, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] Memory is insufficient.");
 107
 108         __pTextObject->Construct();
 109         __pTextObject->SetWrap(TEXT_OBJECT_WRAP_TYPE_WORD);
 110         __pTextObject->SetAction(TEXT_OBJECT_ACTION_TYPE_ABBREV);
 111
 112         __pTitleTextObject->Construct();
 113         __pTitleTextObject->SetWrap(TEXT_OBJECT_WRAP_TYPE_WORD);
 114         __pTitleTextObject->SetAction(TEXT_OBJECT_ACTION_TYPE_ABBREV);
 115
 116         CalculateTextBounds();
 117         CalculateTitleTextBounds();
 118         CalculateButtonBounds();
 119
 120         return E_SUCCESS;
 121
 122 CATCH:
 123
 124         delete __pTextObject;
 125         __pTextObject = null;
 126
 127         delete __pTitleTextObject;
 128         __pTitleTextObject = null;
 129
 130         return r;
 131 }
 132
 133 result
 134 _CheckButtonPresenter::Install(void)
 135 {
 136         result r = E_SUCCESS;
 137
 138         _CheckButtonModel* pModel = new (std::nothrow) _CheckButtonModel();
 139         SysTryReturn(NID_UI_CTRL, pModel, E_OUT_OF_MEMORY, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] Memory is insufficient.");
 140
 141         r = SetModel(*pModel);
 142         SysTryCatch(NID_UI_CTRL, r == E_SUCCESS, r = E_SYSTEM, E_SYSTEM, "[E_SYSTEM] A system error occurred.");
 143
 144         r = pModel->Construct();
 145         SysTryCatch(NID_UI_CTRL, r == E_SUCCESS, r = E_SYSTEM, E_SYSTEM, "[E_SYSTEM] A system error occurred.");
 146
 147         return E_SUCCESS;
 148
 149 CATCH:
 150         delete pModel;
 151         return r;
 152 }
 153
 154 result
 155 _CheckButtonPresenter::SetModel(const _CheckButtonModel& checkButtonModel)
 156 {
 157         __pCheckButtonModel = const_cast <_CheckButtonModel*>(&checkButtonModel);
 158
 159         return E_SUCCESS;
 160 }
 161
 162 void
 163 _CheckButtonPresenter::OnFontChanged(Font* pFont)
 164 {
 165         __pTextFont = pFont;
 166         __pTitleTextFont = pFont;
 167
 168         return;
 169 }
 170
 171 void
 172 _CheckButtonPresenter::OnFontInfoRequested(unsigned long& style, int& size)
 173 {
 174         style = __fontStyle;
 175         size =  __fontSize;
 176
 177         return;
 178 }
 179
 180 void
 181 _CheckButtonPresenter::SetFontInfo(unsigned long style, int size)
 182 {
 183         __fontStyle = style;
 184         __fontSize = size;
 185
 186         return;
 187 }
 188
 189 void
 190 _CheckButtonPresenter::Draw(void)
 191 {
 192         DrawBackground();
 193         DrawCheckBitmap();
 194         DrawText();
 195
 196         return;
 197 }
 198
 199 void
 200 _CheckButtonPresenter::DrawBackground(void)
 201 {
 202         Canvas* pCanvas = __pCheckButton->GetCanvasN();
 203         if (pCanvas == null)
 204         {
 205                 SysLog(NID_UI_CTRL, "Cannot get a canvas.");
 206
 207                 return;
 208         }
 209
 210         Bitmap* pReplacementColorBackgroundBitmap = null;
 211         Bitmap* pBackgroundBitmap = __pCheckButton->GetBackgroundBitmap(__pCheckButton->GetGroupStyle());
 212         Bitmap* pBackgroundNormalEffectBitmap = __pCheckButton->GetBackgroundNormalEffectBitmap(__pCheckButton->GetGroupStyle());
 213         Bitmap* pBackgroundPressedEffectBitmap = __pCheckButton->GetBackgroundPressedEffectBitmap(__pCheckButton->GetGroupStyle());
 214
 215         pCanvas->SetBackgroundColor(Color(0, 0, 0, 0));
 216         pCanvas->Clear();
 217
 218         Rectangle bounds(0, 0, __pCheckButton->GetBounds().width, __pCheckButton->GetBounds().height);
 219         CheckButtonStatus checkStatus = __pCheckButton->GetCheckButtonStatus();
 220         BackgroundStyle backgroundStyle = __pCheckButton->GetBackgroundStyle();
 221
 222         if (checkStatus == CHECK_BUTTON_STATUS_NORMAL)
 223         {
 224                 if (backgroundStyle == BACKGROUND_STYLE_NONE)
 225                 {
 226                         pCanvas->SetBackgroundColor(Color(0, 0, 0, 0));
 227                         pCanvas->Clear();
 228                 }
 229                 else
 230                 {
 231                         if (pBackgroundBitmap && pBackgroundBitmap->IsNinePatchedBitmap())
 232                         {
 233                                 pReplacementColorBackgroundBitmap = _BitmapImpl::GetColorReplacedBitmapN(*pBackgroundBitmap, Color::GetColor(COLOR_ID_MAGENTA),
 234                                                 __pCheckButton->GetColor(CHECK_BUTTON_STATUS_NORMAL));
 235                                 if (pReplacementColorBackgroundBitmap)
 236                                 {
 237                                         pCanvas->DrawNinePatchedBitmap(bounds, *pReplacementColorBackgroundBitmap);
 238                                 }
 239                                 if (pBackgroundNormalEffectBitmap)
 240                                 {
 241                                         pCanvas->DrawNinePatchedBitmap(bounds, *pBackgroundNormalEffectBitmap);
 242                                 }
 243                         }
 244                         else
 245                         {
 246                                 if (pBackgroundBitmap)
 247                                 {
 248                                         pCanvas->DrawBitmap(Rectangle(0, 0, bounds.width, bounds.height), *pBackgroundBitmap);
 249                                 }
 250                         }
 251                 }
 252         }
 253         else if (checkStatus == CHECK_BUTTON_STATUS_DISABLED)
 254         {
 255                 if (backgroundStyle == BACKGROUND_STYLE_NONE)
 256                 {
 257                         pCanvas->SetBackgroundColor(Color(0, 0, 0, 0));
 258                         pCanvas->Clear();
 259                 }
 260                 else
 261                 {
 262                         if (pBackgroundBitmap && pBackgroundBitmap->IsNinePatchedBitmap())
 263                         {
 264                                 pReplacementColorBackgroundBitmap = _BitmapImpl::GetColorReplacedBitmapN(*pBackgroundBitmap, Color::GetColor(COLOR_ID_MAGENTA),
 265                                                 __pCheckButton->GetColor(CHECK_BUTTON_STATUS_DISABLED));
 266                                 if (pReplacementColorBackgroundBitmap)
 267                                 {
 268                                         pCanvas->DrawNinePatchedBitmap(bounds, *pReplacementColorBackgroundBitmap);
 269                                 }
 270                                 if (pBackgroundNormalEffectBitmap)
 271                                 {
 272                                         pCanvas->DrawNinePatchedBitmap(bounds, *pBackgroundNormalEffectBitmap);
 273                                 }
 274                         }
 275                         else
 276                         {
 277                                 if (pBackgroundBitmap)
 278                                 {
 279                                         pCanvas->DrawBitmap(Rectangle(0, 0, bounds.width, bounds.height), *pBackgroundBitmap);
 280                                 }
 281                         }
 282                 }
 283         }
 284         else if (checkStatus == CHECK_BUTTON_STATUS_PRESSED)
 285         {
 286                 if (backgroundStyle == BACKGROUND_STYLE_NONE)
 287                 {
 288                         pCanvas->SetBackgroundColor(__pCheckButton->GetColor(CHECK_BUTTON_STATUS_PRESSED));
 289                         pCanvas->Clear();
 290                 }
 291                 else
 292                 {
 293                         if (pBackgroundBitmap && pBackgroundBitmap->IsNinePatchedBitmap())
 294                         {
 295                                 pReplacementColorBackgroundBitmap = _BitmapImpl::GetColorReplacedBitmapN(*pBackgroundBitmap, Color::GetColor(COLOR_ID_MAGENTA),
 296                                                 __pCheckButton->GetColor(CHECK_BUTTON_STATUS_PRESSED));
 297                                 if (pReplacementColorBackgroundBitmap)
 298                                 {
 299                                         pCanvas->DrawNinePatchedBitmap(bounds, *pReplacementColorBackgroundBitmap);
 300                                 }
 301                                 if (pBackgroundPressedEffectBitmap)
 302                                 {
 303                                         pCanvas->DrawNinePatchedBitmap(bounds, *pBackgroundPressedEffectBitmap);
 304                                 }
 305                         }
 306                         else
 307                         {
 308                                 if (pBackgroundBitmap)
 309                                 {
 310                                         pCanvas->DrawBitmap(Rectangle(0, 0, bounds.width, bounds.height), *pBackgroundBitmap);
 311                                 }
 312                         }
 313                 }
 314         }
 315         else
 316         {
 317                 if (backgroundStyle == BACKGROUND_STYLE_NONE)
 318                 {
 319                         pCanvas->SetBackgroundColor(Color(0, 0, 0, 0));
 320                         pCanvas->Clear();
 321                 }
 322                 else
 323                 {
 324                         if (pBackgroundBitmap && pBackgroundBitmap->IsNinePatchedBitmap())
 325                         {
 326                                 pReplacementColorBackgroundBitmap = _BitmapImpl::GetColorReplacedBitmapN(*pBackgroundBitmap, Color::GetColor(COLOR_ID_MAGENTA),
 327                                                 __pCheckButton->GetColor(CHECK_BUTTON_STATUS_HIGHLIGHTED));
 328                                 if (pReplacementColorBackgroundBitmap)
 329                                 {
 330                                         pCanvas->DrawNinePatchedBitmap(bounds, *pReplacementColorBackgroundBitmap);
 331                                 }
 332                                 if (pBackgroundNormalEffectBitmap)
 333                                 {
 334                                         pCanvas->DrawNinePatchedBitmap(bounds, *pBackgroundNormalEffectBitmap);
 335                                 }
 336                         }
 337                         else
 338                         {
 339                                 if (pBackgroundBitmap)
 340                                 {
 341                                         pCanvas->DrawBitmap(Rectangle(0, 0, bounds.width, bounds.height), *pBackgroundBitmap);
 342                                 }
 343                         }
 344                 }
 345         }
 346
 347         delete pCanvas;
 348         delete pReplacementColorBackgroundBitmap;
 349
 350         return;
 351 }
 352
 353 void
 354 _CheckButtonPresenter::DrawCheckBitmap(void)
 355 {
 356         Canvas* pCanvas = __pCheckButton->GetCanvasN();
 357         if (pCanvas == null)
 358         {
 359                 SysLog(NID_UI_CTRL, "Cannot get a canvas.");
 360
 361                 return;
 362         }
 363
 364         Color detailedNormalBackgroundColor;
 365         Color detailedPressedBackgroundColor;
 366         Color detailedNormalTextColor;
 367         Color detailedPressedTextColor;
 368
 369         GET_COLOR_CONFIG(CHECKBUTTON::DETAILED_ICON_BG_NORMAL, detailedNormalBackgroundColor);
 370         GET_COLOR_CONFIG(CHECKBUTTON::DETAILED_ICON_BG_PRESSED, detailedPressedBackgroundColor);
 371         GET_COLOR_CONFIG(CHECKBUTTON::DETAILED_ICON_TEXT_NORMAL, detailedNormalTextColor);
 372         GET_COLOR_CONFIG(CHECKBUTTON::DETAILED_ICON_TEXT_PRESSED, detailedPressedTextColor);
 373
 374         Bitmap* pReplacementColorBackgroundBitmap = null;
 375         Bitmap* pReplacementColorTextBitmap = null;
 376         Bitmap* pOnOffBitmap = __pCheckButton->GetOnOffBitmap();
 377         Bitmap* pCircleBitmap = __pCheckButton->GetCircleBitmap();
 378         Bitmap* pDetailedBitmap = __pCheckButton->GetDetailedBitmap();
 379         Bitmap* pCircleNormalEffectBitmap = __pCheckButton->GetCircleNormalEffectBitmap();
 380         Bitmap* pCirclePressedEffectBitmap = __pCheckButton->GetCirclePressedEffectBitmap();
 381
 382         CheckButtonStatus checkStatus = __pCheckButton->GetCheckButtonStatus();
 383         CheckButtonStyle checkStyle = __pCheckButton->GetCheckButtonStyle();
 384
 385         CalculateButtonBounds();
 386
 387         if (checkStyle == CHECK_BUTTON_STYLE_MARK || checkStyle == CHECK_BUTTON_STYLE_MARK_WITH_DIVIDER || checkStyle == CHECK_BUTTON_STYLE_MARK_WITH_DETAILED_BUTTON)
 388         {
 389                 if (checkStatus == CHECK_BUTTON_STATUS_NORMAL || checkStatus == CHECK_BUTTON_STATUS_DISABLED)
 390                 {
 391                         Bitmap* pMarkBgNormalBitmap = __pCheckButton->GetMarkBgNormalBitmap();
 392
 393                         if (pMarkBgNormalBitmap)
 394                         {
 395                                 pCanvas->DrawBitmap(Point(__defaultButtonBounds.x, __defaultButtonBounds.y), *pMarkBgNormalBitmap);
 396                         }
 397
 398                         if (checkStyle == CHECK_BUTTON_STYLE_MARK_WITH_DETAILED_BUTTON)
 399                         {
 400                                 pReplacementColorBackgroundBitmap = _BitmapImpl::GetColorReplacedBitmapN(*pCircleBitmap, Color::GetColor(COLOR_ID_MAGENTA), detailedNormalBackgroundColor);
 401                                 pReplacementColorTextBitmap = _BitmapImpl::GetColorReplacedBitmapN(*pDetailedBitmap, Color::GetColor(COLOR_ID_MAGENTA), detailedNormalTextColor);
 402
 403                                 if (pReplacementColorBackgroundBitmap)
 404                                 {
 405                                         pCanvas->DrawBitmap(Point(__detailedButtonBounds.x, __detailedButtonBounds.y), *pReplacementColorBackgroundBitmap);
 406                                 }
 407                                 if (pCircleNormalEffectBitmap)
 408                                 {
 409                                         pCanvas->DrawBitmap(Point(__detailedButtonBounds.x, __detailedButtonBounds.y), *pCircleNormalEffectBitmap);
 410                                 }
 411                                 if (pReplacementColorTextBitmap)
 412                                 {
 413                                         pCanvas->DrawBitmap(Point(__detailedButtonBounds.x, __detailedButtonBounds.y), *pReplacementColorTextBitmap);
 414                                 }
 415                         }
 416                 }
 417                 else if (checkStatus == CHECK_BUTTON_STATUS_PRESSED)
 418                 {
 419                         Bitmap* pMarkBgPressedBitmap = __pCheckButton->GetMarkBgPressedBitmap();
 420
 421                         if (pMarkBgPressedBitmap)
 422                         {
 423                                 pCanvas->DrawBitmap(Point(__defaultButtonBounds.x, __defaultButtonBounds.y), *pMarkBgPressedBitmap);
 424                         }
 425
 426                         if (checkStyle == CHECK_BUTTON_STYLE_MARK_WITH_DETAILED_BUTTON)
 427                         {
 428                                 pReplacementColorBackgroundBitmap = _BitmapImpl::GetColorReplacedBitmapN(*pCircleBitmap, Color::GetColor(COLOR_ID_MAGENTA), detailedPressedBackgroundColor);
 429                                 pReplacementColorTextBitmap = _BitmapImpl::GetColorReplacedBitmapN(*pDetailedBitmap, Color::GetColor(COLOR_ID_MAGENTA), detailedPressedTextColor);
 430
 431                                 if (pReplacementColorBackgroundBitmap)
 432                                 {
 433                                         pCanvas->DrawBitmap(Point(__detailedButtonBounds.x, __detailedButtonBounds.y), *pReplacementColorBackgroundBitmap);
 434                                 }
 435                                 if (pCirclePressedEffectBitmap)
 436                                 {
 437                                         pCanvas->DrawBitmap(Point(__detailedButtonBounds.x, __detailedButtonBounds.y), *pCirclePressedEffectBitmap);
 438                                 }
 439                                 if (pReplacementColorTextBitmap)
 440                                 {
 441                                         pCanvas->DrawBitmap(Point(__detailedButtonBounds.x, __detailedButtonBounds.y), *pReplacementColorTextBitmap);
 442                                 }
 443                         }
 444                 }
 445
 446                 DrawMarkAnimation();
 447         }
 448         else if (checkStyle == CHECK_BUTTON_STYLE_RADIO || checkStyle == CHECK_BUTTON_STYLE_RADIO_WITH_DIVIDER || checkStyle == CHECK_BUTTON_STYLE_RADIO_WITH_DETAILED_BUTTON)
 449         {
 450                 if (checkStatus == CHECK_BUTTON_STATUS_NORMAL || checkStatus == CHECK_BUTTON_STATUS_DISABLED)
 451                 {
 452                         if (checkStyle == CHECK_BUTTON_STYLE_RADIO_WITH_DETAILED_BUTTON)
 453                         {
 454                                 pReplacementColorBackgroundBitmap = _BitmapImpl::GetColorReplacedBitmapN(*pCircleBitmap, Color::GetColor(COLOR_ID_MAGENTA), detailedNormalBackgroundColor);
 455                                 pReplacementColorTextBitmap = _BitmapImpl::GetColorReplacedBitmapN(*pDetailedBitmap, Color::GetColor(COLOR_ID_MAGENTA), detailedNormalTextColor);
 456
 457                                 if (pReplacementColorBackgroundBitmap)
 458                                 {
 459                                         pCanvas->DrawBitmap(Point(__detailedButtonBounds.x, __detailedButtonBounds.y), *pReplacementColorBackgroundBitmap);
 460                                 }
 461                                 if (pCircleNormalEffectBitmap)
 462                                 {
 463                                         pCanvas->DrawBitmap(Point(__detailedButtonBounds.x, __detailedButtonBounds.y), *pCircleNormalEffectBitmap);
 464                                 }
 465                                 if (pReplacementColorTextBitmap)
 466                                 {
 467                                         pCanvas->DrawBitmap(Point(__detailedButtonBounds.x, __detailedButtonBounds.y), *pReplacementColorTextBitmap);
 468                                 }
 469                         }
 470                 }
 471                 else if (checkStatus == CHECK_BUTTON_STATUS_PRESSED)
 472                 {
 473                         if (checkStyle == CHECK_BUTTON_STYLE_RADIO_WITH_DETAILED_BUTTON)
 474                         {
 475                                 pReplacementColorBackgroundBitmap = _BitmapImpl::GetColorReplacedBitmapN(*pCircleBitmap, Color::GetColor(COLOR_ID_MAGENTA), detailedPressedBackgroundColor);
 476                                 pReplacementColorTextBitmap = _BitmapImpl::GetColorReplacedBitmapN(*pDetailedBitmap, Color::GetColor(COLOR_ID_MAGENTA), detailedPressedTextColor);
 477
 478                                 if (pReplacementColorBackgroundBitmap)
 479                                 {
 480                                         pCanvas->DrawBitmap(Point(__detailedButtonBounds.x, __detailedButtonBounds.y), *pReplacementColorBackgroundBitmap);
 481                                 }
 482                                 if (pCirclePressedEffectBitmap)
 483                                 {
 484                                         pCanvas->DrawBitmap(Point(__detailedButtonBounds.x, __detailedButtonBounds.y), *pCirclePressedEffectBitmap);
 485                                 }
 486                                 if (pReplacementColorTextBitmap)
 487                                 {
 488                                         pCanvas->DrawBitmap(Point(__detailedButtonBounds.x, __detailedButtonBounds.y), *pReplacementColorTextBitmap);
 489                                 }
 490                         }
 491                 }
 492
 493                 DrawMarkAnimation();
 494         }
 495         else if (checkStyle == CHECK_BUTTON_STYLE_ONOFF || checkStyle == CHECK_BUTTON_STYLE_ONOFF_WITH_DIVIDER)
 496         {
 497                 if (checkStatus == CHECK_BUTTON_STATUS_NORMAL || checkStatus == CHECK_BUTTON_STATUS_DISABLED)
 498                 {
 499                         Bitmap* pOnOffBgNormalBitmap = __pCheckButton->GetOnOffBgNormalBitmap();
 500
 501                         if (pOnOffBgNormalBitmap)
 502                         {
 503                                 pCanvas->DrawBitmap(Point(__defaultButtonBounds.x, __defaultButtonBounds.y), *pOnOffBgNormalBitmap);
 504                         }
 505                 }
 506                 else if (checkStatus == CHECK_BUTTON_STATUS_PRESSED)
 507                 {
 508                         Bitmap* pOnOffBgPressedBitmap = __pCheckButton->GetOnOffBgPressedBitmap();
 509
 510                         if (pOnOffBgPressedBitmap)
 511                         {
 512                                 pCanvas->DrawBitmap(Point(__defaultButtonBounds.x, __defaultButtonBounds.y), *pOnOffBgPressedBitmap);
 513                         }
 514                 }
 515
 516                 if (__pCheckButton->IsSelected() && pOnOffBitmap)
 517                 {
 518                         pCanvas->DrawBitmap(Point(__defaultButtonBounds.x, __defaultButtonBounds.y), *pOnOffBitmap);
 519                 }
 520         }
 521         else if (checkStyle == CHECK_BUTTON_STYLE_ONOFF_SLIDING)
 522         {
 523                 if (__pCheckButton->IsSelected())
 524                 {
 525                         Bitmap* pOnOffSlidingOnBitmap = __pCheckButton->GetOnOffSlidingOnBitmap();
 526
 527                         if (pOnOffSlidingOnBitmap)
 528                         {
 529                                 pCanvas->DrawBitmap(Point(__onOffSlidingButtonBounds.x, __onOffSlidingButtonBounds.y), *pOnOffSlidingOnBitmap);
 530                         }
 531                 }
 532                 else
 533                 {
 534                         Bitmap* pOnOffSlidingOffBitmap = __pCheckButton->GetOnOffSlidingOffBitmap();
 535
 536                         if (pOnOffSlidingOffBitmap)
 537                         {
 538                                 pCanvas->DrawBitmap(Point(__onOffSlidingButtonBounds.x, __onOffSlidingButtonBounds.y), *pOnOffSlidingOffBitmap);
 539                         }
 540                 }
 541         }
 542
 543         delete pCanvas;
 544         delete pReplacementColorBackgroundBitmap;
 545         delete pReplacementColorTextBitmap;
 546
 547         return;
 548 }
 549
 550 void
 551 _CheckButtonPresenter::DrawText(void)
 552 {
 553         result r = E_SUCCESS;
 554
 555         TextSimple* pSimpleText = null;
 556         TextSimple* pSimpleTitleText = null;
 557         TextObjectAlignment horizontalAlign = TEXT_OBJECT_ALIGNMENT_CENTER;
 558         TextObjectAlignment verticalAlign = TEXT_OBJECT_ALIGNMENT_MIDDLE;
 559
 560         CheckButtonStatus checkStatus = __pCheckButton->GetCheckButtonStatus();
 561         bool showTitle = __pCheckButton->GetShowTitle();
 562
 563         Canvas* pCanvas = __pCheckButton->GetCanvasN();
 564         if (pCanvas == null)
 565         {
 566                 SysLog(NID_UI_CTRL, "Cannot get a canvas.");
 567
 568                 return;
 569         }
 570
 571         __pTextObject->RemoveAll();
 572         pSimpleText = new (std::nothrow) TextSimple(const_cast<wchar_t*>(__pCheckButton->GetText().GetPointer()), __pCheckButton->GetText().GetLength());
 573         __pTextObject->AppendElement(*pSimpleText);
 574
 575         __pTitleTextObject->RemoveAll();
 576         pSimpleTitleText = new (std::nothrow) TextSimple(const_cast<wchar_t*>(__pCheckButton->GetTitleText().GetPointer()), __pCheckButton->GetTitleText().GetLength());
 577         __pTitleTextObject->AppendElement(*pSimpleTitleText);
 578
 579         if (checkStatus == CHECK_BUTTON_STATUS_NORMAL)
 580         {
 581                 __pTextObject->SetForegroundColor(__pCheckButton->GetTextColor(), 0, __pTextObject->GetTextLength());
 582                 __pTitleTextObject->SetForegroundColor(__pCheckButton->GetTitleTextColor(), 0, __pTitleTextObject->GetTextLength());
 583         }
 584         else if (checkStatus == CHECK_BUTTON_STATUS_DISABLED)
 585         {
 586                 __pTextObject->SetForegroundColor(__pCheckButton->GetDisabledTextColor(), 0, __pTextObject->GetTextLength());
 587                 __pTitleTextObject->SetForegroundColor(__pCheckButton->GetDisabledTitleTextColor(), 0, __pTitleTextObject->GetTextLength());
 588         }
 589         else if (checkStatus == CHECK_BUTTON_STATUS_HIGHLIGHTED)
 590         {
 591                 __pTextObject->SetForegroundColor(__pCheckButton->GetHighlightedTextColor(), 0, __pTextObject->GetTextLength());
 592                 __pTitleTextObject->SetForegroundColor(__pCheckButton->GetHighlightedTitleTextColor(), 0, __pTitleTextObject->GetTextLength());
 593         }
 594         else
 595         {
 596                 __pTextObject->SetForegroundColor(__pCheckButton->GetPressedTextColor(), 0, __pTextObject->GetTextLength());
 597                 __pTitleTextObject->SetForegroundColor(__pCheckButton->GetPressedTitleTextColor(), 0, __pTitleTextObject->GetTextLength());
 598         }
 599
 600         CalculateTextBounds();
 601         CalculateTitleTextBounds();
 602
 603         __pTextObject->SetWrap(TEXT_OBJECT_WRAP_TYPE_NONE);
 604         __pTextObject->SetAction(TEXT_OBJECT_ACTION_TYPE_ABBREV);
 605         __pTextObject->SetBounds(GetTextBounds());
 606         __pTextObject->Compose();
 607
 608         __pTitleTextObject->SetWrap(TEXT_OBJECT_WRAP_TYPE_NONE);
 609         __pTitleTextObject->SetAction(TEXT_OBJECT_ACTION_TYPE_ABBREV);
 610         __pTitleTextObject->SetBounds(GetTitleTextBounds());
 611         __pTitleTextObject->Compose();
 612
 613         switch (__pCheckButton->GetTextHorizontalAlignment())
 614         {
 615         case ALIGNMENT_LEFT:
 616                 horizontalAlign = TEXT_OBJECT_ALIGNMENT_LEFT;
 617                 break;
 618         case ALIGNMENT_CENTER:
 619                 horizontalAlign = TEXT_OBJECT_ALIGNMENT_CENTER;
 620                 break;
 621         default:
 622                 horizontalAlign = TEXT_OBJECT_ALIGNMENT_RIGHT;
 623         }
 624
 625         switch (__pCheckButton->GetTextVerticalAlignment())
 626         {
 627         case ALIGNMENT_TOP:
 628                 verticalAlign = TEXT_OBJECT_ALIGNMENT_TOP;
 629                 break;
 630         case ALIGNMENT_MIDDLE:
 631                 verticalAlign = TEXT_OBJECT_ALIGNMENT_MIDDLE;
 632                 break;
 633         default:
 634                 verticalAlign = TEXT_OBJECT_ALIGNMENT_BOTTOM;
 635         }
 636
 637         __fontSize =  __pCheckButton->GetTextSize();
 638         __pTextFont = __pCheckButton->GetFallbackFont();
 639         r = GetLastResult();
 640         SysTryReturnVoidResult(NID_UI_CTRL, __pTextFont, r, "[%s] Propagating.", GetErrorMessage(r));
 641
 642         __pTextObject->SetAlignment(horizontalAlign | verticalAlign);
 643         __pTextObject->SetFont(__pTextFont, 0, __pTextObject->GetTextLength());
 644         __pTextObject->Draw(*_CanvasImpl::GetInstance(*pCanvas));
 645
 646         __fontSize = __pCheckButton->GetTitleTextSize();
 647         __pTitleTextFont = __pCheckButton->GetFallbackFont();
 648         r = GetLastResult();
 649         SysTryReturnVoidResult(NID_UI_CTRL, __pTitleTextFont, r, "[%s] Propagating.", GetErrorMessage(r));
 650
 651         __pTitleTextObject->SetAlignment(TEXT_OBJECT_ALIGNMENT_LEFT | TEXT_OBJECT_ALIGNMENT_MIDDLE);
 652         __pTitleTextObject->SetFont(__pTitleTextFont, 0, __pTitleTextObject->GetTextLength());
 653
 654         if (showTitle)
 655         {
 656                 __pTitleTextObject->Draw(*_CanvasImpl::GetInstance(*pCanvas));
 657         }
 658
 659         delete pCanvas;
 660
 661         return;
 662 }
 663
 664 bool
 665 _CheckButtonPresenter::OnTouchPressed(const _Control& source, const _TouchInfo& touchinfo)
 666 {
 667         if (&source != __pCheckButton)
 668         {
 669                 return false;
 670         }
 671
 672         if (!__pCheckButton->IsEnabled())
 673         {
 674                 return true;
 675         }
 676
 677         __touchMoveHandled = false;
 678
 679         __pCheckButton->SetCheckButtonStatus(CHECK_BUTTON_STATUS_PRESSED);
 680
 681         __pCheckButton->Invalidate();
 682
 683         return true;
 684 }
 685
 686 bool
 687 _CheckButtonPresenter::OnTouchReleased(const _Control& source, const _TouchInfo& touchinfo)
 688 {
 689         int checkButtonLeftMargin = 0;
 690         int checkButtonDetailedBitmapWidth = 0;
 691
 692         GET_SHAPE_CONFIG(CHECKBUTTON::LEFT_MARGIN, _CONTROL_ORIENTATION_PORTRAIT, checkButtonLeftMargin);
 693         GET_SHAPE_CONFIG(CHECKBUTTON::DETAILED_BITMAP_WIDTH, _CONTROL_ORIENTATION_PORTRAIT, checkButtonDetailedBitmapWidth);
 694
 695         if (&source != __pCheckButton)
 696         {
 697                 return false;
 698         }
 699
 700         if (!__pCheckButton->IsEnabled())
 701         {
 702                 return true;
 703         }
 704
 705         CheckButtonStatus status = __pCheckButton->GetCheckButtonStatus();
 706         CheckButtonStyle checkStyle = __pCheckButton->GetCheckButtonStyle();
 707
 708         if (status == CHECK_BUTTON_STATUS_NORMAL)
 709         {
 710                 return true;
 711         }
 712
 713         if (checkStyle == CHECK_BUTTON_STYLE_MARK || checkStyle == CHECK_BUTTON_STYLE_MARK_WITH_DIVIDER || checkStyle == CHECK_BUTTON_STYLE_MARK_WITH_DETAILED_BUTTON
 714                         || checkStyle == CHECK_BUTTON_STYLE_RADIO || checkStyle == CHECK_BUTTON_STYLE_RADIO_WITH_DIVIDER || checkStyle == CHECK_BUTTON_STYLE_RADIO_WITH_DETAILED_BUTTON)
 715         {
 716                 StartCheckAnimationTimer();
 717                  __ratio = 0;
 718          }
 719
 720         Point touchPoint = touchinfo.GetCurrentPosition();
 721
 722         touchPoint.x += source.GetClientBounds().x;
 723         touchPoint.y += source.GetClientBounds().y;
 724
 725         Rectangle bounds = __pCheckButton->GetClientBounds();
 726         Rectangle detailedBounds = __pCheckButton->GetClientBounds();
 727         detailedBounds.width = detailedBounds.width - checkButtonLeftMargin - checkButtonDetailedBitmapWidth;
 728
 729         __pCheckButton->SetCheckButtonStatus(CHECK_BUTTON_STATUS_NORMAL);
 730         __pCheckButton->Invalidate();
 731
 732         if (checkStyle == CHECK_BUTTON_STYLE_MARK_WITH_DETAILED_BUTTON || checkStyle == CHECK_BUTTON_STYLE_RADIO_WITH_DETAILED_BUTTON)
 733         {
 734                 if (detailedBounds.Contains(touchPoint))
 735                 {
 736                         __pCheckButton->FireActionEvent();
 737
 738                         if (__pCheckButton->GetRadioGroup() != null)
 739                         {
 740                                 __pCheckButton->SendTouchReleasedEvent(*__pCheckButton);
 741                         }
 742                 }
 743         }
 744         else
 745         {
 746                 if (bounds.Contains(touchPoint))
 747                 {
 748                         __pCheckButton->FireActionEvent();
 749
 750                         if (__pCheckButton->GetRadioGroup() != null)
 751                         {
 752                                 __pCheckButton->SendTouchReleasedEvent(*__pCheckButton);
 753                         }
 754                 }
 755         }
 756
 757         return true;
 758 }
 759
 760 bool
 761 _CheckButtonPresenter::OnTouchMoved(const _Control& source, const _TouchInfo& touchinfo)
 762 {
 763         if (&source != __pCheckButton)
 764         {
 765                 return false;
 766         }
 767
 768         if (!__pCheckButton->IsEnabled())
 769         {
 770                 return true;
 771         }
 772
 773         Point touchPoint = touchinfo.GetCurrentPosition();
 774
 775         touchPoint.x += source.GetClientBounds().x;
 776         touchPoint.y += source.GetClientBounds().y;
 777
 778         Rectangle bounds = __pCheckButton->GetClientBounds();
 779         bool isInCheckButtonArea = bounds.Contains(touchPoint);
 780
 781         if (isInCheckButtonArea && (__touchMoveHandled != true))
 782         {
 783                 __pCheckButton->SetCheckButtonStatus(CHECK_BUTTON_STATUS_PRESSED);
 784         }
 785         else
 786         {
 787                 __pCheckButton->SetCheckButtonStatus(CHECK_BUTTON_STATUS_NORMAL);
 788         }
 789
 790         __pCheckButton->Invalidate();
 791
 792         return false;
 793 }
 794
 795 bool
 796 _CheckButtonPresenter::OnTouchCanceled(const _Control& source, const _TouchInfo& touchinfo)
 797 {
 798         if (&source != __pCheckButton)
 799         {
 800                 return false;
 801         }
 802
 803         if (!__pCheckButton->IsEnabled())
 804         {
 805                 return true;
 806         }
 807
 808         __pCheckButton->SetCheckButtonStatus(CHECK_BUTTON_STATUS_NORMAL);
 809         __pCheckButton->Invalidate();
 810
 811         return true;
 812 }
 813
 814 void
 815 _CheckButtonPresenter::OnTouchMoveHandled(const _Control& control)
 816 {
 817         __touchMoveHandled = true;
 818         __pCheckButton->SetCheckButtonStatus(CHECK_BUTTON_STATUS_NORMAL);
 819         __pCheckButton->Invalidate();
 820
 821         return;
 822 }
 823
 824 bool
 825 _CheckButtonPresenter::IsEnabledStateChanged(void)
 826 {
 827         bool __currentEnabledState = __pCheckButton->GetEnableState();
 828
 829         if (__currentEnabledState != __previousEnabledState)
 830         {
 831                 __previousEnabledState = __currentEnabledState;
 832                 return true;
 833         }
 834         else
 835         {
 836                 return false;
 837         }
 838 }
 839
 840 result
 841 _CheckButtonPresenter::CalculateTitleTextBounds(void)
 842 {
 843         int checkButtonLeftMargin = 0;
 844         int checkButtonTopMargin = 0;
 845         int checkButtonBitmapWidth = 0;
 846         int checkButtonOnOffSlidingBitmappWidth = 0;
 847         int checkButtonDetailedBitmapWidth = 0;
 848         int checkButtonTitleTextHeight = 0;
 849         int checkButtonTextHeight = 0;
 850
 851         GET_SHAPE_CONFIG(CHECKBUTTON::LEFT_MARGIN, _CONTROL_ORIENTATION_PORTRAIT, checkButtonLeftMargin);
 852         GET_SHAPE_CONFIG(CHECKBUTTON::TOP_MARGIN, _CONTROL_ORIENTATION_PORTRAIT, checkButtonTopMargin);
 853         GET_SHAPE_CONFIG(CHECKBUTTON::MARK_BITMAP_WIDTH, _CONTROL_ORIENTATION_PORTRAIT, checkButtonBitmapWidth);
 854         GET_SHAPE_CONFIG(CHECKBUTTON::ONOFF_SLIDING_BITMAP_WIDTH, _CONTROL_ORIENTATION_PORTRAIT, checkButtonOnOffSlidingBitmappWidth);
 855         GET_SHAPE_CONFIG(CHECKBUTTON::DETAILED_BITMAP_WIDTH, _CONTROL_ORIENTATION_PORTRAIT, checkButtonDetailedBitmapWidth);
 856         GET_SHAPE_CONFIG(CHECKBUTTON::TITLE_TEXT_HEIGHT, _CONTROL_ORIENTATION_PORTRAIT, checkButtonTitleTextHeight);
 857         GET_SHAPE_CONFIG(CHECKBUTTON::TEXT_HEIGHT, _CONTROL_ORIENTATION_PORTRAIT, checkButtonTextHeight);
 858
 859         CheckButtonStyle checkStyle = __pCheckButton->GetCheckButtonStyle();
 860
 861         if (checkStyle == CHECK_BUTTON_STYLE_ONOFF_SLIDING)
 862         {
 863                 __titleTextBounds.x = checkButtonLeftMargin;
 864                 __titleTextBounds.y = checkButtonTopMargin;
 865                 __titleTextBounds.width = __pCheckButton->GetBounds().width - checkButtonLeftMargin * 3 - checkButtonOnOffSlidingBitmappWidth;
 866                 __titleTextBounds.height = __pCheckButton->GetBounds().height - checkButtonTopMargin * 2 - __textBounds.height;
 867         }
 868         else
 869         {
 870                 if (checkStyle == CHECK_BUTTON_STYLE_MARK_WITH_DETAILED_BUTTON || checkStyle == CHECK_BUTTON_STYLE_RADIO_WITH_DETAILED_BUTTON)
 871                 {
 872                         __titleTextBounds.x = checkButtonLeftMargin * 2 + checkButtonBitmapWidth;
 873                         __titleTextBounds.y = checkButtonTopMargin;
 874                         __titleTextBounds.width = __pCheckButton->GetBounds().width - checkButtonLeftMargin * 4 - checkButtonBitmapWidth - checkButtonDetailedBitmapWidth;
 875                         __titleTextBounds.height = __pCheckButton->GetBounds().height - checkButtonTopMargin * 2 - __textBounds.height;
 876                 }
 877                 else
 878                 {
 879                         __titleTextBounds.x = checkButtonLeftMargin * 2 + checkButtonBitmapWidth;
 880                         __titleTextBounds.y = checkButtonTopMargin;
 881                         __titleTextBounds.width = __pCheckButton->GetBounds().width - checkButtonLeftMargin * 3 - checkButtonBitmapWidth;
 882                         __titleTextBounds.height = __pCheckButton->GetBounds().height - checkButtonTopMargin * 2 - __textBounds.height;
 883                 }
 884         }
 885
 886         return E_SUCCESS;
 887 }
 888
 889 result
 890 _CheckButtonPresenter::CalculateTextBounds(void)
 891 {
 892         int checkButtonLeftMargin = 0;
 893         int checkButtonTopMargin = 0;
 894         int checkButtonBitmapWidth = 0;
 895         int checkButtonOnOffSlidingBitmapWidth = 0;
 896         int checkButtonDetailedBitmapWidth = 0;
 897         int checkButtonTitleTextHeight = 0;
 898         int checkButtonTextHeight = 0;
 899
 900         GET_SHAPE_CONFIG(CHECKBUTTON::LEFT_MARGIN, _CONTROL_ORIENTATION_PORTRAIT, checkButtonLeftMargin);
 901         GET_SHAPE_CONFIG(CHECKBUTTON::TOP_MARGIN, _CONTROL_ORIENTATION_PORTRAIT, checkButtonTopMargin);
 902         GET_SHAPE_CONFIG(CHECKBUTTON::MARK_BITMAP_WIDTH, _CONTROL_ORIENTATION_PORTRAIT, checkButtonBitmapWidth);
 903         GET_SHAPE_CONFIG(CHECKBUTTON::ONOFF_SLIDING_BITMAP_WIDTH, _CONTROL_ORIENTATION_PORTRAIT, checkButtonOnOffSlidingBitmapWidth);
 904         GET_SHAPE_CONFIG(CHECKBUTTON::DETAILED_BITMAP_WIDTH, _CONTROL_ORIENTATION_PORTRAIT, checkButtonDetailedBitmapWidth);
 905         GET_SHAPE_CONFIG(CHECKBUTTON::TITLE_TEXT_HEIGHT, _CONTROL_ORIENTATION_PORTRAIT, checkButtonTitleTextHeight);
 906         GET_SHAPE_CONFIG(CHECKBUTTON::TEXT_HEIGHT, _CONTROL_ORIENTATION_PORTRAIT, checkButtonTextHeight);
 907
 908         CheckButtonStyle checkStyle = __pCheckButton->GetCheckButtonStyle();
 909         bool showTitle = __pCheckButton->GetShowTitle();
 910
 911         if (checkStyle == CHECK_BUTTON_STYLE_ONOFF_SLIDING)
 912         {
 913                 if (showTitle)
 914                 {
 915                         __textBounds.x = checkButtonLeftMargin;
 916                         __textBounds.y = checkButtonTopMargin + checkButtonTitleTextHeight;
 917                         __textBounds.width = __pCheckButton->GetBounds().width - checkButtonLeftMargin * 3 - checkButtonOnOffSlidingBitmapWidth;
 918                         __textBounds.height = __pCheckButton->GetBounds().height - checkButtonTopMargin * 2 - checkButtonTitleTextHeight;
 919                 }
 920                 else
 921                 {
 922                         __textBounds.x = checkButtonLeftMargin;
 923                         __textBounds.y = checkButtonTopMargin;
 924                         __textBounds.width = __pCheckButton->GetBounds().width - checkButtonLeftMargin * 3 - checkButtonOnOffSlidingBitmapWidth;
 925                         __textBounds.height = __pCheckButton->GetBounds().height - checkButtonTopMargin * 2;
 926                 }
 927         }
 928         else
 929         {
 930                 if (checkStyle == CHECK_BUTTON_STYLE_MARK_WITH_DETAILED_BUTTON || checkStyle == CHECK_BUTTON_STYLE_RADIO_WITH_DETAILED_BUTTON)
 931                 {
 932                         if (showTitle)
 933                         {
 934                                 __textBounds.x = checkButtonLeftMargin * 2 + checkButtonBitmapWidth;
 935                                 __textBounds.y = checkButtonTopMargin + checkButtonTitleTextHeight;
 936                                 __textBounds.width = __pCheckButton->GetBounds().width - checkButtonLeftMargin * 4 - checkButtonBitmapWidth - checkButtonDetailedBitmapWidth;
 937                                 __textBounds.height = __pCheckButton->GetBounds().height - checkButtonTopMargin * 2 - checkButtonTitleTextHeight;
 938                         }
 939                         else
 940                         {
 941                                 __textBounds.x = checkButtonLeftMargin * 2 + checkButtonBitmapWidth;
 942                                 __textBounds.y = checkButtonTopMargin;
 943                                 __textBounds.width = __pCheckButton->GetBounds().width - checkButtonLeftMargin * 4 - checkButtonBitmapWidth - checkButtonDetailedBitmapWidth;
 944                                 __textBounds.height = __pCheckButton->GetBounds().height - checkButtonTopMargin * 2;
 945                         }
 946                 }
 947                 else
 948                 {
 949                         if (showTitle)
 950                         {
 951                                 __textBounds.x = checkButtonLeftMargin * 2 + checkButtonBitmapWidth;
 952                                 __textBounds.y = checkButtonTopMargin + checkButtonTitleTextHeight;
 953                                 __textBounds.width = __pCheckButton->GetBounds().width - checkButtonLeftMargin * 3 - checkButtonBitmapWidth;
 954                                 __textBounds.height = __pCheckButton->GetBounds().height - checkButtonTopMargin * 2 - checkButtonTitleTextHeight;
 955                         }
 956                         else
 957                         {
 958                                 __textBounds.x = checkButtonLeftMargin * 2 + checkButtonBitmapWidth;
 959                                 __textBounds.y = checkButtonTopMargin;
 960                                 __textBounds.width = __pCheckButton->GetBounds().width - checkButtonLeftMargin * 3 - checkButtonBitmapWidth;
 961                                 __textBounds.height = __pCheckButton->GetBounds().height - checkButtonTopMargin * 2;
 962                         }
 963                 }
 964         }
 965
 966         return E_SUCCESS;
 967 }
 968
 969 result
 970 _CheckButtonPresenter::CalculateButtonBounds(void)
 971 {
 972         int checkButtonLeftMargin = 0;
 973         int checkButtonBitmapWidth = 0;
 974         int checkButtonBitmapHeight = 0;
 975         int checkButtonOnOffSlidingBitmapWidth = 0;
 976         int checkButtonOnOffSlidingBitmapHeight = 0;
 977         int checkButtonDetaieldBitmapWidth = 0;
 978         int checkButtonDetaieldBitmapHeight = 0;
 979
 980         GET_SHAPE_CONFIG(CHECKBUTTON::LEFT_MARGIN, _CONTROL_ORIENTATION_PORTRAIT, checkButtonLeftMargin);
 981         GET_SHAPE_CONFIG(CHECKBUTTON::MARK_BITMAP_WIDTH, _CONTROL_ORIENTATION_PORTRAIT, checkButtonBitmapWidth);
 982         GET_SHAPE_CONFIG(CHECKBUTTON::MARK_BITMAP_HEIGHT, _CONTROL_ORIENTATION_PORTRAIT, checkButtonBitmapHeight);
 983         GET_SHAPE_CONFIG(CHECKBUTTON::ONOFF_SLIDING_BITMAP_WIDTH, _CONTROL_ORIENTATION_PORTRAIT, checkButtonOnOffSlidingBitmapWidth);
 984         GET_SHAPE_CONFIG(CHECKBUTTON::ONOFF_SLIDING_BITMAP_HEIGHT, _CONTROL_ORIENTATION_PORTRAIT, checkButtonOnOffSlidingBitmapHeight);
 985         GET_SHAPE_CONFIG(CHECKBUTTON::DETAILED_BITMAP_WIDTH, _CONTROL_ORIENTATION_PORTRAIT, checkButtonDetaieldBitmapWidth);
 986         GET_SHAPE_CONFIG(CHECKBUTTON::DETAILED_BITMAP_HEIGHT, _CONTROL_ORIENTATION_PORTRAIT, checkButtonDetaieldBitmapHeight);
 987
 988         __defaultButtonBounds.x = checkButtonLeftMargin;
 989         __defaultButtonBounds.y = (__pCheckButton->GetBounds().height - checkButtonBitmapHeight) / 2;
 990         __defaultButtonBounds.width = checkButtonBitmapWidth;
 991         __defaultButtonBounds.height = checkButtonBitmapHeight;
 992
 993         __onOffSlidingButtonBounds.x = __pCheckButton->GetBounds().width - checkButtonLeftMargin - checkButtonOnOffSlidingBitmapWidth;
 994         __onOffSlidingButtonBounds.y = (__pCheckButton->GetBounds().height - checkButtonOnOffSlidingBitmapHeight) / 2;
 995         __onOffSlidingButtonBounds.width = checkButtonOnOffSlidingBitmapWidth;
 996         __onOffSlidingButtonBounds.height = checkButtonOnOffSlidingBitmapHeight;
 997
 998         __detailedButtonBounds.x = __pCheckButton->GetBounds().width - checkButtonLeftMargin - checkButtonDetaieldBitmapWidth;
 999         __detailedButtonBounds.y = (__pCheckButton->GetBounds().height - checkButtonDetaieldBitmapHeight) / 2;
1000         __detailedButtonBounds.width = checkButtonDetaieldBitmapWidth;
1001         __detailedButtonBounds.height = checkButtonDetaieldBitmapHeight;
1002
1003         return E_SUCCESS;
1004 }
1005
1006 Rectangle
1007 _CheckButtonPresenter::GetTitleTextBounds(void) const
1008 {
1009         return __titleTextBounds;
1010 }
1011
1012 Rectangle
1013 _CheckButtonPresenter::GetTextBounds(void) const
1014 {
1015         return __textBounds;
1016 }
1017
1018 Rectangle
1019 _CheckButtonPresenter::GetDefaultButtonBounds(void) const
1020 {
1021         return __defaultButtonBounds;
1022 }
1023 Rectangle
1024 _CheckButtonPresenter::GetOnOffSlidingButtonBounds(void) const
1025 {
1026         return __onOffSlidingButtonBounds;
1027 }
1028 Rectangle
1029 _CheckButtonPresenter::GetDetailedButtonBounds(void) const
1030 {
1031         return __detailedButtonBounds;
1032 }
1033
1034 result
1035 _CheckButtonPresenter::StartCheckAnimationTimer(void)
1036 {
1037         result r = E_SUCCESS;
1038         if (__pCheckAnimationTimer == null)
1039         {
1040                 __pCheckAnimationTimer = new (std::nothrow) Timer;
1041                 SysTryReturn(NID_UI_CTRL, (__pCheckAnimationTimer != null), E_OUT_OF_MEMORY, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] Memroy allocation failed.");
1042
1043                 r = __pCheckAnimationTimer->Construct(*this);
1044                 SysTryCatch(NID_UI, r == E_SUCCESS, , r, "[%s] Propagating.", GetErrorMessage(r));
1045         }
1046         else
1047         {
1048                 __pCheckAnimationTimer->Cancel();
1049         }
1050
1051         __pCheckAnimationTimer->Start(CHECK_ACTION_TIMER_PERIOD);
1052         SysTryCatch(NID_UI, r == E_SUCCESS, , r, "[%s] Propagating.", GetErrorMessage(r));
1053
1054         return r;
1055 CATCH:
1056         ResetCheckAnimationTimer();
1057         return r;
1058 }
1059
1060 result
1061 _CheckButtonPresenter::ResetCheckAnimationTimer(void)
1062 {
1063         delete __pCheckAnimationTimer;
1064         __pCheckAnimationTimer = null;
1065
1066         return E_SUCCESS;
1067 }
1068
1069 void
1070 _CheckButtonPresenter::OnTimerExpired(Timer& timer)
1071 {
1072         __ratio++;
1073
1074         if (__ratio <= RATIO_MAX)
1075         {
1076                 StartCheckAnimationTimer();
1077                 DrawMarkAnimation();
1078         }
1079         else
1080         {
1081                 ResetCheckAnimationTimer();
1082                 __ratio = 10;
1083         }
1084
1085         return;
1086 }
1087
1088 void
1089 _CheckButtonPresenter::DrawMarkAnimation(void)
1090 {
1091         Canvas* pCanvas = __pCheckButton->GetCanvasN();
1092         if (pCanvas == null)
1093         {
1094                 SysLog(NID_UI_CTRL, "Cannot get a canvas.");
1095
1096                 return;
1097         }
1098
1099         Bitmap* pMarkBitmap = __pCheckButton->GetMarkBitmap();
1100          //CheckButtonStyle checkStyle = __pCheckButton->GetCheckButtonStyle();
1101
1102          //if (checkStyle == CHECK_BUTTON_STYLE_MARK || checkStyle == CHECK_BUTTON_STYLE_MARK_WITH_DIVIDER || checkStyle == CHECK_BUTTON_STYLE_MARK_WITH_DETAILED_BUTTON
1103         //              || checkStyle == CHECK_BUTTON_STYLE_RADIO || checkStyle == CHECK_BUTTON_STYLE_RADIO_WITH_DIVIDER || checkStyle == CHECK_BUTTON_STYLE_RADIO_WITH_DETAILED_BUTTON)
1104         {
1105                 if (__pCheckButton->IsSelected() && pMarkBitmap)
1106                 {
1107                         Rectangle sourceRect(0, 0, pMarkBitmap->GetWidth() * __ratio * 0.1, pMarkBitmap->GetHeight());
1108                         Rectangle destRect(__defaultButtonBounds.x, __defaultButtonBounds.y, pMarkBitmap->GetWidth() * __ratio * 0.1, pMarkBitmap->GetHeight());
1109
1110                          pCanvas->DrawBitmap(destRect, *pMarkBitmap, sourceRect);
1111                 }
1112         }
1113
1114         delete pCanvas;
1115
1116         return;
1117         }
1118
1119 }}} // Tizen::Ui::Controls