src/ui/controls/FUiCtrl_CheckButton.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_CheckButton.cpp
  19  * @brief               This is the implementation file for the _CheckButton class.
  20  */
  21
  22 #include <FBaseErrorDefine.h>
  23 #include <FBaseSysLog.h>
  24 #include "FUi_AccessibilityContainer.h"
  25 #include "FUi_AccessibilityElement.h"
  26 #include "FUi_AccessibilityManager.h"
  27 #include "FUi_CoordinateSystemUtils.h"
  28 #include "FUi_ResourceManager.h"
  29 #include "FUi_UiNotificationEvent.h"
  30 #include "FUi_UiEventManager.h"
  31 #include "FUiCtrl_ScrollPanel.h"
  32 #include "FUiCtrl_CheckButton.h"
  33 #include "FUiCtrl_CheckButtonPresenter.h"
  34
  35 using namespace Tizen::Base;
  36 using namespace Tizen::Base::Runtime;
  37 using namespace Tizen::Base::Collection;
  38 using namespace Tizen::Graphics;
  39 using namespace Tizen::Ui;
  40
  41 namespace Tizen { namespace Ui { namespace Controls
  42 {
  43
  44 class CheckButtonAccessibilityListener
  45         : public _IAccessibilityListener
  46 {
  47 public:
  48         CheckButtonAccessibilityListener(_CheckButton* pCheckButton)
  49                 : __pCheckButton(pCheckButton)
  50         {
  51         }
  52         virtual bool OnAccessibilityFocusMovedNext(const _AccessibilityContainer& control, const _AccessibilityElement& element){return false;}
  53         virtual bool OnAccessibilityFocusMovedPrevious(const _AccessibilityContainer& control, const _AccessibilityElement& element){return false;}
  54         virtual bool OnAccessibilityReadingElement(const _AccessibilityContainer& control, const _AccessibilityElement& element){return false;}
  55         virtual bool OnAccessibilityReadElement(const _AccessibilityContainer& control, const _AccessibilityElement& element){return false;}
  56         virtual bool OnAccessibilityFocusIn(const _AccessibilityContainer& control, const _AccessibilityElement& element){return false;}
  57         virtual bool OnAccessibilityFocusOut(const _AccessibilityContainer& control, const _AccessibilityElement& element){return false;}
  58         virtual bool OnAccessibilityValueIncreased(const _AccessibilityContainer& control, const _AccessibilityElement& element){return false;}
  59         virtual bool OnAccessibilityValueDecreased(const _AccessibilityContainer& control, const _AccessibilityElement& element){return false;}
  60         virtual bool OnAccessibilityActionPerformed(const _AccessibilityContainer& control, const _AccessibilityElement& element)
  61         {
  62                 if (element.GetName() == L"MoreButtonText")
  63                 {
  64                         return true;
  65                 }
  66                 CheckButtonStyle style = __pCheckButton->GetCheckButtonStyle();
  67                 if (style == CHECK_BUTTON_STYLE_MARK || style == CHECK_BUTTON_STYLE_MARK_WITH_DIVIDER || style == CHECK_BUTTON_STYLE_MARK_WITH_DETAILED_BUTTON)
  68                 {
  69                         if(__pCheckButton->IsSelected())
  70                         {
  71                                 _AccessibilityManager::GetInstance()->ReadContent(L"ticked");
  72                         }
  73                         else
  74                         {
  75                                 _AccessibilityManager::GetInstance()->ReadContent(L"unticked");
  76                         }
  77                 }
  78                 else if (style == CHECK_BUTTON_STYLE_RADIO || style == CHECK_BUTTON_STYLE_RADIO_WITH_DIVIDER || style == CHECK_BUTTON_STYLE_RADIO_WITH_DETAILED_BUTTON)
  79                 {
  80                         if(__pCheckButton->IsSelected())
  81                         {
  82                                 _AccessibilityManager::GetInstance()->ReadContent(L"selected");
  83                         }
  84                         else
  85                         {
  86                                 _AccessibilityManager::GetInstance()->ReadContent(L"unselected");
  87                         }
  88                 }
  89                 else if (style == CHECK_BUTTON_STYLE_ONOFF || style == CHECK_BUTTON_STYLE_ONOFF_WITH_DIVIDER
  90                                 || style == CHECK_BUTTON_STYLE_ONOFF_SLIDING || style == CHECK_BUTTON_STYLE_ONOFF_SLIDING_WITH_DIVIDER)
  91                 {
  92                         if(__pCheckButton->IsSelected())
  93                         {
  94                                 _AccessibilityManager::GetInstance()->ReadContent(L"on");
  95                         }
  96                         else
  97                         {
  98                                 _AccessibilityManager::GetInstance()->ReadContent(L"off");
  99                         }
 100                 }
 101                 return true;
 102         }
 103
 104         _CheckButton* __pCheckButton;
 105 };
 106
 107 IMPLEMENT_PROPERTY(_CheckButton);
 108
 109 _CheckButton::_CheckButton(void)
 110         : __checkButtonStyle(CHECK_BUTTON_STYLE_MARK)
 111         , __backgroundStyle(BACKGROUND_STYLE_DEFAULT)
 112         , __showTitle(false)
 113         , __groupStyle(GROUP_STYLE_NONE)
 114         , __checkButtonStatus(_CHECK_BUTTON_STATUS_NORMAL)
 115         , __pCheckButtonPresenter(null)
 116         , __pActionEvent(null)
 117         , __selected(false)
 118         , __checkedActionId(0)
 119         , __uncheckedActionId(0)
 120         , __selectedActionId(-1)
 121         , __text(L"")
 122         , __titleText(L"")
 123         , __pCircleNormalEffectBitmap(null)
 124         , __pCirclePressedEffectBitmap(null)
 125         , __pBackgroundNormalEffectBitmap(null)
 126         , __pBackgroundPressedEffectBitmap(null)
 127         , __pBackgroundTopNormalEffectBitmap(null)
 128         , __pBackgroundTopPressedEffectBitmap(null)
 129         , __pBackgroundMiddleNormalEffectBitmap(null)
 130         , __pBackgroundMiddlePressedEffectBitmap(null)
 131         , __pBackgroundBottomNormalEffectBitmap(null)
 132         , __pBackgroundBottomPressedEffectBitmap(null)
 133         , __horizontalAlignment(ALIGNMENT_LEFT)
 134         , __verticalAlignment(ALIGNMENT_MIDDLE)
 135         , __textSize(0.0f)
 136         , __titleTextSize(0.0f)
 137         , __previousTouchArea(false)
 138         , __pRadioGroup(null)
 139         , __pButtonElement(null)
 140         , __pDetailButtonElement(null)
 141         , __pAccessibilityListener(null)
 142 {
 143         result r = E_SUCCESS;
 144
 145         _AccessibilityContainer* pContainer = null;
 146
 147         GET_SHAPE_CONFIG(CHECKBUTTON::TEXT_FONT_SIZE, _CONTROL_ORIENTATION_PORTRAIT, __textSize);
 148         GET_SHAPE_CONFIG(CHECKBUTTON::TITLE_TEXT_FONT_SIZE, _CONTROL_ORIENTATION_PORTRAIT, __titleTextSize);
 149
 150         _CheckButtonPresenter* pPresenter = new (std::nothrow) _CheckButtonPresenter();
 151         SysTryReturnVoidResult(NID_UI_CTRL, pPresenter, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] Memory is insufficient.");
 152
 153         r = SetPresenter(*pPresenter);
 154         SysTryCatch(NID_UI_CTRL, r == E_SUCCESS, , E_SYSTEM, "[E_SYSTEM] A system error occurred.");
 155
 156         r = pPresenter->Construct(*this);
 157         SysTryCatch(NID_UI_CTRL, r == E_SUCCESS, , E_SYSTEM, "[E_SYSTEM] A system error occurred.");
 158
 159         r = pPresenter->Install();
 160         SysTryCatch(NID_UI_CTRL, r == E_SUCCESS, , E_SYSTEM, "[E_SYSTEM] A system error occurred.");
 161
 162         for (int i = 0; i < NUMBER_OF_CHECK_BUTTON_STATUS; i++)
 163         {
 164                 __pMarkBgNormalBitmap[i] = null;
 165                 __pMarkBitmap[i] = null;
 166                 __pOnOffBgNormalBitmap[i] = null;
 167                 __pOnOffBitmap[i] = null;
 168                 __pOnOffSlidingBgBitmap[i] = null;
 169                 __pOnOffSlidingOnHandlerBitmap[i] = null;
 170                 __pOnOffSlidingOffHandlerBitmap[i] = null;
 171                 __pCircleBitmap[i] = null;
 172                 __pDetailedRightBitmap[i] = null;
 173
 174                 __pBackgroundBitmap[i] = null;
 175                 __pBackgroundTopBitmap[i] = null;
 176                 __pBackgroundMiddleBitmap[i] = null;
 177                 __pBackgroundBottomBitmap[i] = null;
 178         }
 179
 180         GET_COLOR_CONFIG(CHECKBUTTON::TEXT_NORMAL, __normalTextColor);
 181         GET_COLOR_CONFIG(CHECKBUTTON::TEXT_DISABLED, __disabledTextColor);
 182         GET_COLOR_CONFIG(CHECKBUTTON::TEXT_PRESSED, __pressedTextColor);
 183         GET_COLOR_CONFIG(CHECKBUTTON::TEXT_HIGHLIGHTED, __highlightedTextColor);
 184         GET_COLOR_CONFIG(CHECKBUTTON::TEXT_SELECTED, __selectedTextColor);
 185
 186         GET_COLOR_CONFIG(CHECKBUTTON::TITLE_TEXT_NORMAL, __normalTitleTextColor);
 187         GET_COLOR_CONFIG(CHECKBUTTON::TITLE_TEXT_DISABLED, __disabledTitleTextColor);
 188         GET_COLOR_CONFIG(CHECKBUTTON::TITLE_TEXT_PRESSED, __pressedTitleTextColor);
 189         GET_COLOR_CONFIG(CHECKBUTTON::TITLE_TEXT_HIGHLIGHTED, __highlightedTitleTextColor);
 190         GET_COLOR_CONFIG(CHECKBUTTON::TITLE_TEXT_SELECTED, __selectedTitleTextColor);
 191
 192         GET_COLOR_CONFIG(CHECKBUTTON::BG_NORMAL, __normalColor);
 193         GET_COLOR_CONFIG(CHECKBUTTON::BG_DISABLED, __disabledColor);
 194         GET_COLOR_CONFIG(CHECKBUTTON::BG_PRESSED, __pressedColor);
 195         GET_COLOR_CONFIG(CHECKBUTTON::BG_HIGHLIGHTED, __highlightedColor);
 196         GET_COLOR_CONFIG(CHECKBUTTON::BG_SELECTED, __selectedColor);
 197
 198         pContainer = GetAccessibilityContainer();
 199
 200         if(pContainer)
 201         {
 202                 pContainer->Activate(true);
 203                 __pAccessibilityListener = new (std::nothrow) CheckButtonAccessibilityListener(this);
 204                 pContainer->AddListener(*__pAccessibilityListener);
 205                 UpdateAccessibilityElement();
 206         }
 207
 208         ClearLastResult();
 209
 210         return;
 211
 212 CATCH:
 213         delete pPresenter;
 214 }
 215
 216 _CheckButton*
 217 _CheckButton::CreateCheckButtonN(void)
 218 {
 219         _CheckButton* pCheckButton = new (std::nothrow) _CheckButton();
 220         SysTryReturn(NID_UI_CTRL, pCheckButton, null, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] Memory is insufficient.");
 221         SysTryCatch(NID_UI_CTRL, GetLastResult() == E_SUCCESS, , E_SYSTEM, "[E_SYSTEM] A system error occurred.");
 222
 223         pCheckButton->AcquireHandle();
 224
 225         pCheckButton->LoadDefaultBackgroundBitmap();
 226
 227         pCheckButton->SetTouchPressThreshold(SENSITIVE);
 228
 229         return pCheckButton;
 230
 231 CATCH:
 232         delete pCheckButton;
 233         return null;
 234 }
 235
 236 _CheckButton::~_CheckButton(void)
 237 {
 238         if (__pCheckButtonPresenter)
 239         {
 240                 delete __pCheckButtonPresenter;
 241                 __pCheckButtonPresenter = null;
 242         }
 243
 244         if (__pActionEvent)
 245         {
 246                 delete __pActionEvent;
 247                 __pActionEvent = null;
 248         }
 249
 250         for (int i = 0; i < NUMBER_OF_CHECK_BUTTON_STATUS; i++)
 251         {
 252                 if (__pMarkBgNormalBitmap[i])
 253                 {
 254                         delete __pMarkBgNormalBitmap[i];
 255                         __pMarkBgNormalBitmap[i] = null;
 256                 }
 257
 258                 if (__pMarkBitmap[i])
 259                 {
 260                         delete __pMarkBitmap[i];
 261                         __pMarkBitmap[i] = null;
 262                 }
 263
 264                 if (__pOnOffBgNormalBitmap[i])
 265                 {
 266                         delete __pOnOffBgNormalBitmap[i];
 267                         __pOnOffBgNormalBitmap[i] = null;
 268                 }
 269
 270                 if (__pOnOffBitmap[i])
 271                 {
 272                         delete __pOnOffBitmap[i];
 273                         __pOnOffBitmap[i] = null;
 274                 }
 275
 276                 if (__pOnOffSlidingBgBitmap[i])
 277                 {
 278                         delete __pOnOffSlidingBgBitmap[i];
 279                         __pOnOffSlidingBgBitmap[i] = null;
 280                 }
 281
 282                 if (__pOnOffSlidingOnHandlerBitmap[i])
 283                 {
 284                         delete __pOnOffSlidingOnHandlerBitmap[i];
 285                         __pOnOffSlidingOnHandlerBitmap[i] = null;
 286                 }
 287
 288                 if (__pOnOffSlidingOffHandlerBitmap[i])
 289                 {
 290                         delete __pOnOffSlidingOffHandlerBitmap[i];
 291                         __pOnOffSlidingOffHandlerBitmap[i] = null;
 292                 }
 293
 294                 if (__pCircleBitmap[i])
 295                 {
 296                         delete __pCircleBitmap[i];
 297                         __pCircleBitmap[i] = null;
 298                 }
 299
 300                 if (__pDetailedRightBitmap[i])
 301                 {
 302                         delete __pDetailedRightBitmap[i];
 303                         __pDetailedRightBitmap[i] = null;
 304                 }
 305
 306                 if (__pBackgroundBitmap[i])
 307                 {
 308                         delete __pBackgroundBitmap[i];
 309                         __pBackgroundBitmap[i] = null;
 310                 }
 311
 312                 if (__pBackgroundTopBitmap[i])
 313                 {
 314                         delete __pBackgroundTopBitmap[i];
 315                         __pBackgroundTopBitmap[i] = null;
 316                 }
 317
 318                 if (__pBackgroundMiddleBitmap[i])
 319                 {
 320                         delete __pBackgroundMiddleBitmap[i];
 321                         __pBackgroundMiddleBitmap[i] = null;
 322                 }
 323
 324                 if (__pBackgroundBottomBitmap[i])
 325                 {
 326                         delete __pBackgroundBottomBitmap[i];
 327                         __pBackgroundBottomBitmap[i] = null;
 328                 }
 329         }
 330
 331         if (__pCircleNormalEffectBitmap)
 332         {
 333                 delete __pCircleNormalEffectBitmap;
 334                 __pCircleNormalEffectBitmap = null;
 335         }
 336
 337         if (__pCirclePressedEffectBitmap)
 338         {
 339                 delete __pCirclePressedEffectBitmap;
 340                 __pCirclePressedEffectBitmap = null;
 341         }
 342
 343         if (__pBackgroundNormalEffectBitmap)
 344         {
 345                 delete __pBackgroundNormalEffectBitmap;
 346                 __pBackgroundNormalEffectBitmap = null;
 347         }
 348
 349         if (__pBackgroundPressedEffectBitmap)
 350         {
 351                 delete __pBackgroundPressedEffectBitmap;
 352                 __pBackgroundPressedEffectBitmap = null;
 353         }
 354
 355         if (__pBackgroundTopNormalEffectBitmap)
 356         {
 357                 delete __pBackgroundTopNormalEffectBitmap;
 358                 __pBackgroundTopNormalEffectBitmap = null;
 359         }
 360
 361         if (__pBackgroundTopPressedEffectBitmap)
 362         {
 363                 delete __pBackgroundTopPressedEffectBitmap;
 364                 __pBackgroundTopPressedEffectBitmap = null;
 365         }
 366
 367         if (__pBackgroundMiddleNormalEffectBitmap)
 368         {
 369                 delete __pBackgroundMiddleNormalEffectBitmap;
 370                 __pBackgroundMiddleNormalEffectBitmap = null;
 371         }
 372
 373         if (__pBackgroundMiddlePressedEffectBitmap)
 374         {
 375                 delete __pBackgroundMiddlePressedEffectBitmap;
 376                 __pBackgroundMiddlePressedEffectBitmap = null;
 377         }
 378
 379         if (__pBackgroundBottomNormalEffectBitmap)
 380         {
 381                 delete __pBackgroundBottomNormalEffectBitmap;
 382                 __pBackgroundBottomNormalEffectBitmap = null;
 383         }
 384
 385         if (__pBackgroundBottomPressedEffectBitmap)
 386         {
 387                 delete __pBackgroundBottomPressedEffectBitmap;
 388                 __pBackgroundBottomPressedEffectBitmap = null;
 389         }
 390
 391         if (__pButtonElement)
 392         {
 393                 __pButtonElement->Activate(false);
 394                 __pButtonElement = null;
 395         }
 396         if (__pDetailButtonElement)
 397         {
 398                 __pDetailButtonElement->Activate(false);
 399                 __pDetailButtonElement = null;
 400         }
 401
 402         _AccessibilityContainer* pContainer = GetAccessibilityContainer();
 403
 404         if(pContainer)
 405         {
 406                 pContainer->RemoveListener(*__pAccessibilityListener);
 407         }
 408         delete __pAccessibilityListener;
 409         __pAccessibilityListener = null;
 410
 411         ClearLastResult();
 412 }
 413
 414 result
 415 _CheckButton::SetPresenter(const _CheckButtonPresenter& checkButtonPresenter)
 416 {
 417         __pCheckButtonPresenter = const_cast <_CheckButtonPresenter*>(&checkButtonPresenter);
 418
 419         return E_SUCCESS;
 420 }
 421
 422 void
 423 _CheckButton::OnDraw(void)
 424 {
 425         __pCheckButtonPresenter->Draw();
 426         UpdateAccessibilityElement();
 427
 428         return;
 429 }
 430
 431 result
 432 _CheckButton::OnAttachedToMainTree(void)
 433 {
 434         if(__pButtonElement)
 435         {
 436                 __pButtonElement->SetBounds(FloatRectangle(0.0f, 0.0f, GetBoundsF().width, GetBoundsF().height));
 437         }
 438
 439         if(__pDetailButtonElement)
 440         {
 441                 __pDetailButtonElement->SetBounds(FloatRectangle(__pCheckButtonPresenter->GetDetailedButtonBoundsF()));
 442         }
 443         return E_SUCCESS;
 444 }
 445
 446 void
 447 _CheckButton::UpdateAccessibilityElement(void)
 448 {
 449         _AccessibilityContainer* pContainer = GetAccessibilityContainer();
 450
 451         if(pContainer)
 452         {
 453                 String label = L"";
 454                 if(GetShowTitle())
 455                 {
 456                         label = GetTitleText();
 457                         label.Append(L", ");
 458                 }
 459
 460                 if (__checkButtonStyle == CHECK_BUTTON_STYLE_MARK || __checkButtonStyle == CHECK_BUTTON_STYLE_MARK_WITH_DIVIDER
 461                                 || __checkButtonStyle == CHECK_BUTTON_STYLE_MARK_WITH_DETAILED_BUTTON)
 462                 {
 463                         if (__pButtonElement == null)
 464                         {
 465                                 __pButtonElement = new (std::nothrow) _AccessibilityElement(true);
 466                                 SysTryReturnVoidResult(NID_UI_CTRL, __pButtonElement, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] Memory shortage.");
 467                                 pContainer->AddElement(*__pButtonElement);
 468                         }
 469                         __pButtonElement->SetBounds(FloatRectangle(0.0f, 0.0f, GetBoundsF().width, GetBoundsF().height));
 470                         __pButtonElement->SetLabel(label + GetText());
 471                         __pButtonElement->SetTraitWithStringId("IDS_TPLATFORM_BODY_TICKBOX_T_TTS");
 472                         __pButtonElement->SetName(L"CheckButtonText");
 473
 474                         if (__checkButtonStyle == CHECK_BUTTON_STYLE_MARK_WITH_DETAILED_BUTTON)
 475                         {
 476                                 if (__pDetailButtonElement == null)
 477                                 {
 478                                         __pDetailButtonElement = new (std::nothrow) _AccessibilityElement(true);
 479                                         SysTryReturnVoidResult(NID_UI_CTRL, __pDetailButtonElement, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] Memory shortage.");
 480                                         pContainer->AddElement(*__pDetailButtonElement);
 481                                 }
 482                                 __pDetailButtonElement->SetBounds(FloatRectangle(__pCheckButtonPresenter->GetDetailedButtonBoundsF()));
 483                                 __pDetailButtonElement->SetLabel(L"More");
 484                                 __pDetailButtonElement->SetTraitWithStringId("IDS_TPLATFORM_BODY_BUTTON_T_TTS");
 485                                 __pDetailButtonElement->SetName(L"MoreButtonText");
 486                         }
 487                 }
 488                 else if (__checkButtonStyle == CHECK_BUTTON_STYLE_RADIO || __checkButtonStyle == CHECK_BUTTON_STYLE_RADIO_WITH_DIVIDER
 489                                 || __checkButtonStyle == CHECK_BUTTON_STYLE_RADIO_WITH_DETAILED_BUTTON)
 490                 {
 491                         if (__pButtonElement == null)
 492                         {
 493                                 __pButtonElement = new (std::nothrow) _AccessibilityElement(true);
 494                                 SysTryReturnVoidResult(NID_UI_CTRL, __pButtonElement, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] Memory shortage.");
 495                                 pContainer->AddElement(*__pButtonElement);
 496                         }
 497                         __pButtonElement->SetBounds(FloatRectangle(0.0f, 0.0f, GetBoundsF().width, GetBoundsF().height));
 498                         __pButtonElement->SetLabel(label + GetText());
 499                         __pButtonElement->SetTraitWithStringId("IDS_TPLATFORM_BODY_RADIO_BUTTON_T_TTS");
 500                         __pButtonElement->SetName(L"CheckButtonText");
 501
 502                         if (__checkButtonStyle == CHECK_BUTTON_STYLE_RADIO_WITH_DETAILED_BUTTON)
 503                         {
 504                                 if (__pDetailButtonElement == null)
 505                                 {
 506                                         __pDetailButtonElement = new (std::nothrow) _AccessibilityElement(true);
 507                                         SysTryReturnVoidResult(NID_UI_CTRL, __pDetailButtonElement, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] Memory shortage.");
 508                                         pContainer->AddElement(*__pDetailButtonElement);
 509                                 }
 510                                 __pDetailButtonElement->SetBounds(FloatRectangle(__pCheckButtonPresenter->GetDetailedButtonBoundsF()));
 511                                 __pDetailButtonElement->SetLabel(L"More");
 512                                 __pDetailButtonElement->SetTraitWithStringId("IDS_TPLATFORM_BODY_BUTTON_T_TTS");
 513                                 __pDetailButtonElement->SetName(L"MoreButtonText");
 514                         }
 515                 }
 516                 else if (__checkButtonStyle == CHECK_BUTTON_STYLE_ONOFF || __checkButtonStyle == CHECK_BUTTON_STYLE_ONOFF_WITH_DIVIDER
 517                                 || __checkButtonStyle == CHECK_BUTTON_STYLE_ONOFF_SLIDING || __checkButtonStyle == CHECK_BUTTON_STYLE_ONOFF_SLIDING_WITH_DIVIDER)
 518                 {
 519                         if (__pButtonElement == null)
 520                         {
 521                                 __pButtonElement = new (std::nothrow) _AccessibilityElement(true);
 522                                 SysTryReturnVoidResult(NID_UI_CTRL, __pButtonElement, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] Memory shortage.");
 523                                 pContainer->AddElement(*__pButtonElement);
 524                         }
 525                         __pButtonElement->SetBounds(FloatRectangle(0.0f, 0.0f, GetBoundsF().width, GetBoundsF().height));
 526                         __pButtonElement->SetLabel(label + GetText());
 527                         __pButtonElement->SetTraitWithStringId("IDS_TPLATFORM_BODY_ON_OFF_BUTTON_T_TTS");
 528                         __pButtonElement->SetName(L"CheckButtonText");
 529                 }
 530                 UpdateAccessibilityCheckStatus();
 531         }
 532
 533         return;
 534 }
 535
 536 bool
 537 _CheckButton::OnTouchPressed(const _Control& source, const _TouchInfo& touchinfo)
 538 {
 539         return __pCheckButtonPresenter->OnTouchPressed(source, touchinfo);
 540 }
 541
 542 bool
 543 _CheckButton::OnTouchReleased(const _Control& source, const _TouchInfo& touchinfo)
 544 {
 545         return __pCheckButtonPresenter->OnTouchReleased(source, touchinfo);
 546 }
 547
 548 bool
 549 _CheckButton::OnTouchMoved(const _Control& source, const _TouchInfo& touchinfo)
 550 {
 551         return __pCheckButtonPresenter->OnTouchMoved(source, touchinfo);
 552 }
 553
 554 bool
 555 _CheckButton::OnTouchCanceled(const _Control & source, const _TouchInfo & touchinfo)
 556 {
 557         return __pCheckButtonPresenter->OnTouchCanceled(source, touchinfo);
 558 }
 559
 560 void
 561 _CheckButton::OnTouchMoveHandled(const _Control& control)
 562 {
 563         __pCheckButtonPresenter->OnTouchMoveHandled(control);
 564
 565         return;
 566 }
 567
 568 bool
 569 _CheckButton::OnKeyPressed(const _Control& source, const _KeyInfo& keyInfo)
 570 {
 571         return __pCheckButtonPresenter->OnKeyPressed(source, keyInfo);
 572 }
 573
 574 bool
 575 _CheckButton::OnKeyReleased(const _Control& source, const _KeyInfo& keyInfo)
 576 {
 577         return __pCheckButtonPresenter->OnKeyReleased(source, keyInfo);
 578 }
 579
 580 void
 581 _CheckButton::OnBoundsChanged(void)
 582 {
 583         if(__pButtonElement)
 584         {
 585                 __pButtonElement->SetBounds(FloatRectangle(0.0f, 0.0f, GetBoundsF().width, GetBoundsF().height));
 586         }
 587
 588         if(__pDetailButtonElement)
 589         {
 590                 __pDetailButtonElement->SetBounds(FloatRectangle(__pCheckButtonPresenter->GetDetailedButtonBoundsF()));
 591         }
 592
 593         if (__checkButtonStyle == CHECK_BUTTON_STYLE_ONOFF_SLIDING || __checkButtonStyle == CHECK_BUTTON_STYLE_ONOFF_SLIDING_WITH_DIVIDER)
 594         {
 595                 __pCheckButtonPresenter->CalculateButtonBounds();
 596                 __pCheckButtonPresenter->AdjustHandlerPosition();
 597         }
 598
 599         return;
 600 }
 601
 602 void
 603 _CheckButton::OnFontChanged(Font* pFont)
 604 {
 605         __pCheckButtonPresenter->OnFontChanged(pFont);
 606
 607         return;
 608 }
 609
 610 void
 611 _CheckButton::OnFontInfoRequested(unsigned long& style, int& size)
 612 {
 613         __pCheckButtonPresenter->OnFontInfoRequested(style, size);
 614
 615         return;
 616 }
 617
 618 void
 619 _CheckButton::OnDrawFocus(void)
 620 {
 621         __pCheckButtonPresenter->OnDrawFocus();
 622
 623         return;
 624 }
 625
 626 void
 627 _CheckButton::OnChildControlFocusMoved(const _Control& control)
 628 {
 629         __pCheckButtonPresenter->OnChildControlFocusMoved(control);
 630
 631         return;
 632 }
 633
 634 bool
 635 _CheckButton::IsChildControlFocusManage(void) const
 636 {
 637         __pCheckButtonPresenter->IsChildControlFocusManage();
 638
 639         return true;
 640 }
 641
 642 void
 643 _CheckButton::OnFocusableStateChanged(bool focusalbeState)
 644 {
 645         __pCheckButtonPresenter->OnFocusableStateChanged(focusalbeState);
 646
 647         return;
 648 }
 649
 650 void
 651 _CheckButton::OnFocusModeStateChanged(void)
 652 {
 653         __pCheckButtonPresenter->OnFocusModeStateChanged();
 654
 655         return;
 656 }
 657
 658 bool
 659 _CheckButton::OnFocusGained(const _Control& source)
 660 {
 661         __pCheckButtonPresenter->OnFocusGained(source);
 662
 663         return true;
 664 }
 665
 666 bool
 667 _CheckButton::OnFocusLost(const _Control& source)
 668 {
 669         __pCheckButtonPresenter->OnFocusLost(source);
 670
 671         return true;
 672 }
 673
 674 void
 675 _CheckButton::SendTouchReleasedEvent(const _Control& control)
 676 {
 677         const _Control* pDestination = dynamic_cast <const _Control*>(&control);
 678         SysTryReturnVoidResult(NID_UI_CTRL, pDestination != null, E_SYSTEM, "[E_SYSTEM] pDestination is null.");
 679
 680         ArrayList* pArgs = new (std::nothrow) ArrayList();
 681         SysTryReturnVoidResult(NID_UI_CTRL, pArgs != null, E_SYSTEM, "[E_SYSTEM] pArgs is null.");
 682
 683         result r = E_SYSTEM;
 684         r = pArgs->Construct();
 685         SysTryReturnVoidResult(NID_UI_CTRL, r == E_SUCCESS, E_SYSTEM, "[E_SYSTEM] Unable to construct pArgs");
 686
 687         // Index 0 : Type
 688         String type(L"CheckButtonReleasedEvent");
 689         r = pArgs->Add(type);
 690         SysTryReturnVoidResult(NID_UI_CTRL, r == E_SUCCESS, E_SYSTEM, "[E_SYSTEM] Unable to add type to pArgs");
 691
 692         r = pArgs->Add(*this);
 693         SysTryReturnVoidResult(NID_UI_CTRL, r == E_SUCCESS, E_SYSTEM, "[E_SYSTEM] Unable to add data to pArgs");
 694
 695
 696         _UiNotificationEvent event(__pRadioGroup->GetHandle(), pArgs);
 697
 698         r = _UiEventManager::GetInstance()->SendEvent(event);
 699
 700         return;
 701 }
 702
 703 result
 704 _CheckButton::SetSelected(bool select)
 705 {
 706         return SetProperty(L"selected", Variant(select));
 707 }
 708
 709 result
 710 _CheckButton::SetPropertySelected(const Variant& selected)
 711 {
 712         __selected = selected.ToBool();
 713
 714         //if (__selected == true)
 715         //{
 716         //      SetCheckButtonStatus(_CHECK_BUTTON_STATUS_SELECTED);
 717         //}
 718         //else
 719         //{
 720         //      SetCheckButtonStatus(_CHECK_BUTTON_STATUS_NORMAL);
 721         //}
 722
 723         if (__checkButtonStyle == CHECK_BUTTON_STYLE_ONOFF_SLIDING || __checkButtonStyle == CHECK_BUTTON_STYLE_ONOFF_SLIDING_WITH_DIVIDER)
 724         {
 725                 __pCheckButtonPresenter->CalculateButtonBounds();
 726                 __pCheckButtonPresenter->InitOnOffHandlerMoved();
 727                 __pCheckButtonPresenter->AdjustHandlerPosition();
 728         }
 729
 730         __pCheckButtonPresenter->Draw();
 731
 732         return E_SUCCESS;
 733 }
 734
 735 bool
 736 _CheckButton::IsSelected(void) const
 737 {
 738         Variant selected = GetProperty(L"selected");
 739
 740         return selected.ToBool();
 741 }
 742
 743 Variant
 744 _CheckButton::GetPropertySelected(void) const
 745 {
 746         return Variant(__selected);
 747 }
 748
 749 result
 750 _CheckButton::AddActionEventListener(const Controls::_IActionEventListener& listener)
 751 {
 752         if (__pActionEvent == null)
 753         {
 754                 __pActionEvent = _ActionEvent::CreateInstanceN(*this);
 755                 SysTryReturn(NID_UI_CTRL, __pActionEvent, E_SYSTEM, E_SYSTEM, "[E_SYSTEM] A system error occurred.\n");
 756         }
 757
 758         result r = __pActionEvent->AddListener(listener);
 759         SysTryReturn(NID_UI_CTRL, r == E_SUCCESS, r, r, "[%s] Propagating.", GetErrorMessage(r));
 760
 761         return E_SUCCESS;
 762 }
 763
 764 result
 765 _CheckButton::RemoveActionEventListener(const Controls::_IActionEventListener& listener)
 766 {
 767         result r = E_OBJ_NOT_FOUND;
 768
 769         if (__pActionEvent)
 770         {
 771                 r = __pActionEvent->RemoveListener(listener);
 772         }
 773
 774         SysTryReturn(NID_UI_CTRL, r == E_SUCCESS, r, r, "[%s] Propagating.", GetErrorMessage(r));
 775
 776         return E_SUCCESS;
 777 }
 778
 779 result
 780 _CheckButton::AddRadioGroup(const _Control& radioGroup)
 781 {
 782         SysTryReturn(NID_UI_CTRL, __pRadioGroup == null, E_INVALID_ARG, E_INVALID_ARG,
 783                                 "[E_INVALID_ARG] The CheckButton is already belonged to a RadioGroup.\n");
 784
 785         __pRadioGroup = const_cast <_Control*>(&radioGroup);
 786
 787         return E_SUCCESS;
 788 }
 789
 790 result
 791 _CheckButton::RemoveRadioGroup(void)
 792 {
 793         SysTryReturn(NID_UI_CTRL, __pRadioGroup, E_OBJ_NOT_FOUND, E_OBJ_NOT_FOUND,
 794                                 "[E_OBJ_NOT_FOUND] Unable to find the CheckButton.\n");
 795
 796         __pRadioGroup = null;
 797
 798         return E_SUCCESS;
 799 }
 800
 801 result
 802 _CheckButton::SetActionId(int checkedActionId, int uncheckedActionId, int selectedActionId)
 803 {
 804         result r = E_SUCCESS;
 805
 806         r = SetProperty(L"checkedActionId", Variant(checkedActionId));
 807         r = SetProperty(L"uncheckedActionId", Variant(uncheckedActionId));
 808         r = SetProperty(L"selectedActionId", Variant(selectedActionId));
 809
 810         return r;
 811 }
 812
 813 result
 814 _CheckButton::SetPropertyCheckedActionId(const Variant& checkedActionId)
 815 {
 816         __checkedActionId = checkedActionId.ToInt();
 817
 818         return E_SUCCESS;
 819 }
 820
 821 int
 822 _CheckButton::GetCheckedActionId(void) const
 823 {
 824         Variant checkedActionId = GetProperty(L"checkedActionId");
 825
 826         return checkedActionId.ToInt();
 827 }
 828
 829 Variant
 830 _CheckButton::GetPropertyCheckedActionId(void) const
 831 {
 832         return Variant(__checkedActionId);
 833 }
 834
 835 result
 836 _CheckButton::SetPropertyUncheckedActionId(const Variant& uncheckedActionId)
 837 {
 838         __uncheckedActionId = uncheckedActionId.ToInt();
 839
 840         return E_SUCCESS;
 841 }
 842
 843 int
 844 _CheckButton::GetUncheckedActionId(void) const
 845 {
 846         Variant uncheckedActionId = GetProperty(L"uncheckedActionId");
 847
 848         return uncheckedActionId.ToInt();
 849 }
 850
 851 Variant
 852 _CheckButton::GetPropertyUncheckedActionId(void) const
 853 {
 854         return Variant(__uncheckedActionId);
 855 }
 856
 857 result
 858 _CheckButton::SetPropertySelectedActionId(const Variant& selectedActionId)
 859 {
 860         __selectedActionId = selectedActionId.ToInt();
 861
 862         return E_SUCCESS;
 863 }
 864
 865 int
 866 _CheckButton::GetSelectedActionId(void) const
 867 {
 868         Variant selectedActionId = GetProperty(L"selectedActionId");
 869
 870         return selectedActionId.ToInt();
 871 }
 872
 873 Variant
 874 _CheckButton::GetPropertySelectedActionId(void) const
 875 {
 876         return Variant(__selectedActionId);
 877 }
 878
 879 result
 880 _CheckButton::LoadDefaultBackgroundBitmap(void)
 881 {
 882         result r = E_SUCCESS;
 883
 884         r = GET_BITMAP_CONFIG_N(CHECKBUTTON::GROUPED_SINGLE_BG_NORMAL, BITMAP_PIXEL_FORMAT_ARGB8888, __pBackgroundBitmap[_CHECK_BUTTON_STATUS_NORMAL]);
 885         r = GET_BITMAP_CONFIG_N(CHECKBUTTON::GROUPED_SINGLE_BG_DISABLED, BITMAP_PIXEL_FORMAT_ARGB8888, __pBackgroundBitmap[_CHECK_BUTTON_STATUS_DISABLED]);
 886         r = GET_BITMAP_CONFIG_N(CHECKBUTTON::GROUPED_SINGLE_BG_PRESSED, BITMAP_PIXEL_FORMAT_ARGB8888, __pBackgroundBitmap[_CHECK_BUTTON_STATUS_PRESSED]);
 887         r = GET_BITMAP_CONFIG_N(CHECKBUTTON::GROUPED_SINGLE_BG_HIGHLIGHTED, BITMAP_PIXEL_FORMAT_ARGB8888, __pBackgroundBitmap[_CHECK_BUTTON_STATUS_HIGHLIGHTED]);
 888         r = GET_BITMAP_CONFIG_N(CHECKBUTTON::GROUPED_SINGLE_BG_SELECTED, BITMAP_PIXEL_FORMAT_ARGB8888, __pBackgroundBitmap[_CHECK_BUTTON_STATUS_SELECTED]);
 889
 890         r = GET_BITMAP_CONFIG_N(CHECKBUTTON::GROUPED_SINGLE_BG_EFFECT_NORMAL, BITMAP_PIXEL_FORMAT_ARGB8888, __pBackgroundNormalEffectBitmap);
 891         r = GET_BITMAP_CONFIG_N(CHECKBUTTON::GROUPED_SINGLE_BG_EFFECT_PRESSED, BITMAP_PIXEL_FORMAT_ARGB8888, __pBackgroundPressedEffectBitmap);
 892
 893         r = GET_BITMAP_CONFIG_N(CHECKBUTTON::GROUPED_TOP_BG_NORMAL, BITMAP_PIXEL_FORMAT_ARGB8888, __pBackgroundTopBitmap[_CHECK_BUTTON_STATUS_NORMAL]);
 894         r = GET_BITMAP_CONFIG_N(CHECKBUTTON::GROUPED_TOP_BG_DISABLED, BITMAP_PIXEL_FORMAT_ARGB8888, __pBackgroundTopBitmap[_CHECK_BUTTON_STATUS_DISABLED]);
 895         r = GET_BITMAP_CONFIG_N(CHECKBUTTON::GROUPED_TOP_BG_PRESSED, BITMAP_PIXEL_FORMAT_ARGB8888, __pBackgroundTopBitmap[_CHECK_BUTTON_STATUS_PRESSED]);
 896         r = GET_BITMAP_CONFIG_N(CHECKBUTTON::GROUPED_TOP_BG_HIGHLIGHTED, BITMAP_PIXEL_FORMAT_ARGB8888, __pBackgroundTopBitmap[_CHECK_BUTTON_STATUS_HIGHLIGHTED]);
 897         r = GET_BITMAP_CONFIG_N(CHECKBUTTON::GROUPED_TOP_BG_SELECTED, BITMAP_PIXEL_FORMAT_ARGB8888, __pBackgroundTopBitmap[_CHECK_BUTTON_STATUS_SELECTED]);
 898
 899         r = GET_BITMAP_CONFIG_N(CHECKBUTTON::GROUPED_TOP_BG_EFFECT_NORMAL, BITMAP_PIXEL_FORMAT_ARGB8888, __pBackgroundTopNormalEffectBitmap);
 900         r = GET_BITMAP_CONFIG_N(CHECKBUTTON::GROUPED_TOP_BG_EFFECT_PRESSED, BITMAP_PIXEL_FORMAT_ARGB8888, __pBackgroundTopPressedEffectBitmap);
 901
 902         r = GET_BITMAP_CONFIG_N(CHECKBUTTON::GROUPED_MIDDLE_BG_NORMAL, BITMAP_PIXEL_FORMAT_ARGB8888, __pBackgroundMiddleBitmap[_CHECK_BUTTON_STATUS_NORMAL]);
 903         r = GET_BITMAP_CONFIG_N(CHECKBUTTON::GROUPED_MIDDLE_BG_DISABLED, BITMAP_PIXEL_FORMAT_ARGB8888, __pBackgroundMiddleBitmap[_CHECK_BUTTON_STATUS_DISABLED]);
 904         r = GET_BITMAP_CONFIG_N(CHECKBUTTON::GROUPED_MIDDLE_BG_PRESSED, BITMAP_PIXEL_FORMAT_ARGB8888, __pBackgroundMiddleBitmap[_CHECK_BUTTON_STATUS_PRESSED]);
 905         r = GET_BITMAP_CONFIG_N(CHECKBUTTON::GROUPED_MIDDLE_BG_HIGHLIGHTED, BITMAP_PIXEL_FORMAT_ARGB8888, __pBackgroundMiddleBitmap[_CHECK_BUTTON_STATUS_HIGHLIGHTED]);
 906         r = GET_BITMAP_CONFIG_N(CHECKBUTTON::GROUPED_MIDDLE_BG_SELECTED, BITMAP_PIXEL_FORMAT_ARGB8888, __pBackgroundMiddleBitmap[_CHECK_BUTTON_STATUS_SELECTED]);
 907
 908         r = GET_BITMAP_CONFIG_N(CHECKBUTTON::GROUPED_MIDDLE_BG_EFFECT_NORMAL, BITMAP_PIXEL_FORMAT_ARGB8888, __pBackgroundMiddleNormalEffectBitmap);
 909         r = GET_BITMAP_CONFIG_N(CHECKBUTTON::GROUPED_MIDDLE_BG_EFFECT_PRESSED, BITMAP_PIXEL_FORMAT_ARGB8888, __pBackgroundMiddlePressedEffectBitmap);
 910
 911         r = GET_BITMAP_CONFIG_N(CHECKBUTTON::GROUPED_BOTTOM_BG_NORMAL, BITMAP_PIXEL_FORMAT_ARGB8888, __pBackgroundBottomBitmap[_CHECK_BUTTON_STATUS_NORMAL]);
 912         r = GET_BITMAP_CONFIG_N(CHECKBUTTON::GROUPED_BOTTOM_BG_DISABLED, BITMAP_PIXEL_FORMAT_ARGB8888, __pBackgroundBottomBitmap[_CHECK_BUTTON_STATUS_DISABLED]);
 913         r = GET_BITMAP_CONFIG_N(CHECKBUTTON::GROUPED_BOTTOM_BG_PRESSED, BITMAP_PIXEL_FORMAT_ARGB8888, __pBackgroundBottomBitmap[_CHECK_BUTTON_STATUS_PRESSED]);
 914         r = GET_BITMAP_CONFIG_N(CHECKBUTTON::GROUPED_BOTTOM_BG_HIGHLIGHTED, BITMAP_PIXEL_FORMAT_ARGB8888, __pBackgroundBottomBitmap[_CHECK_BUTTON_STATUS_HIGHLIGHTED]);
 915         r = GET_BITMAP_CONFIG_N(CHECKBUTTON::GROUPED_BOTTOM_BG_SELECTED, BITMAP_PIXEL_FORMAT_ARGB8888, __pBackgroundBottomBitmap[_CHECK_BUTTON_STATUS_SELECTED]);
 916
 917         r = GET_BITMAP_CONFIG_N(CHECKBUTTON::GROUPED_BOTTOM_BG_EFFECT_NORMAL, BITMAP_PIXEL_FORMAT_ARGB8888, __pBackgroundBottomNormalEffectBitmap);
 918         r = GET_BITMAP_CONFIG_N(CHECKBUTTON::GROUPED_BOTTOM_BG_EFFECT_PRESSED, BITMAP_PIXEL_FORMAT_ARGB8888, __pBackgroundBottomPressedEffectBitmap);
 919
 920         r = GET_BITMAP_CONFIG_N(CHECKBUTTON::MARK_ICON_BG_NORMAL, BITMAP_PIXEL_FORMAT_ARGB8888, __pMarkBgNormalBitmap[_CHECK_BUTTON_STATUS_NORMAL]);
 921         r = GET_BITMAP_CONFIG_N(CHECKBUTTON::MARK_ICON_BG_DISABLED, BITMAP_PIXEL_FORMAT_ARGB8888, __pMarkBgNormalBitmap[_CHECK_BUTTON_STATUS_DISABLED]);
 922         r = GET_BITMAP_CONFIG_N(CHECKBUTTON::MARK_ICON_BG_PRESSED, BITMAP_PIXEL_FORMAT_ARGB8888, __pMarkBgNormalBitmap[_CHECK_BUTTON_STATUS_PRESSED]);
 923         r = GET_BITMAP_CONFIG_N(CHECKBUTTON::MARK_ICON_BG_HIGHLIGHTED, BITMAP_PIXEL_FORMAT_ARGB8888, __pMarkBgNormalBitmap[_CHECK_BUTTON_STATUS_HIGHLIGHTED]);
 924         r = GET_BITMAP_CONFIG_N(CHECKBUTTON::MARK_ICON_BG_SELECTED, BITMAP_PIXEL_FORMAT_ARGB8888, __pMarkBgNormalBitmap[_CHECK_BUTTON_STATUS_SELECTED]);
 925
 926         r = GET_BITMAP_CONFIG_N(CHECKBUTTON::MARK_ICON_NORMAL, BITMAP_PIXEL_FORMAT_ARGB8888, __pMarkBitmap[_CHECK_BUTTON_STATUS_NORMAL]);
 927         r = GET_BITMAP_CONFIG_N(CHECKBUTTON::MARK_ICON_DISABLED, BITMAP_PIXEL_FORMAT_ARGB8888, __pMarkBitmap[_CHECK_BUTTON_STATUS_DISABLED]);
 928         r = GET_BITMAP_CONFIG_N(CHECKBUTTON::MARK_ICON_PRESSED, BITMAP_PIXEL_FORMAT_ARGB8888, __pMarkBitmap[_CHECK_BUTTON_STATUS_PRESSED]);
 929         r = GET_BITMAP_CONFIG_N(CHECKBUTTON::MARK_ICON_HIGHLIGHTED, BITMAP_PIXEL_FORMAT_ARGB8888, __pMarkBitmap[_CHECK_BUTTON_STATUS_HIGHLIGHTED]);
 930         r = GET_BITMAP_CONFIG_N(CHECKBUTTON::MARK_ICON_SELECTED, BITMAP_PIXEL_FORMAT_ARGB8888, __pMarkBitmap[_CHECK_BUTTON_STATUS_SELECTED]);
 931
 932         r = GET_BITMAP_CONFIG_N(CHECKBUTTON::ONOFF_ICON_BG_NORMAL, BITMAP_PIXEL_FORMAT_ARGB8888, __pOnOffBgNormalBitmap[_CHECK_BUTTON_STATUS_NORMAL]);
 933         r = GET_BITMAP_CONFIG_N(CHECKBUTTON::ONOFF_ICON_BG_DISABLED, BITMAP_PIXEL_FORMAT_ARGB8888, __pOnOffBgNormalBitmap[_CHECK_BUTTON_STATUS_DISABLED]);
 934         r = GET_BITMAP_CONFIG_N(CHECKBUTTON::ONOFF_ICON_BG_PRESSED, BITMAP_PIXEL_FORMAT_ARGB8888, __pOnOffBgNormalBitmap[_CHECK_BUTTON_STATUS_PRESSED]);
 935         r = GET_BITMAP_CONFIG_N(CHECKBUTTON::ONOFF_ICON_BG_HIGHLIGHTED, BITMAP_PIXEL_FORMAT_ARGB8888, __pOnOffBgNormalBitmap[_CHECK_BUTTON_STATUS_HIGHLIGHTED]);
 936         r = GET_BITMAP_CONFIG_N(CHECKBUTTON::ONOFF_ICON_BG_SELECTED, BITMAP_PIXEL_FORMAT_ARGB8888, __pOnOffBgNormalBitmap[_CHECK_BUTTON_STATUS_SELECTED]);
 937
 938         r = GET_BITMAP_CONFIG_N(CHECKBUTTON::ONOFF_ICON_NORMAL, BITMAP_PIXEL_FORMAT_ARGB8888, __pOnOffBitmap[_CHECK_BUTTON_STATUS_NORMAL]);
 939         r = GET_BITMAP_CONFIG_N(CHECKBUTTON::ONOFF_ICON_DISABLED, BITMAP_PIXEL_FORMAT_ARGB8888, __pOnOffBitmap[_CHECK_BUTTON_STATUS_DISABLED]);
 940         r = GET_BITMAP_CONFIG_N(CHECKBUTTON::ONOFF_ICON_PRESSED, BITMAP_PIXEL_FORMAT_ARGB8888, __pOnOffBitmap[_CHECK_BUTTON_STATUS_PRESSED]);
 941         r = GET_BITMAP_CONFIG_N(CHECKBUTTON::ONOFF_ICON_HIGHLIGHTED, BITMAP_PIXEL_FORMAT_ARGB8888, __pOnOffBitmap[_CHECK_BUTTON_STATUS_HIGHLIGHTED]);
 942         r = GET_BITMAP_CONFIG_N(CHECKBUTTON::ONOFF_ICON_SELECTED, BITMAP_PIXEL_FORMAT_ARGB8888, __pOnOffBitmap[_CHECK_BUTTON_STATUS_SELECTED]);
 943
 944         r = GET_BITMAP_CONFIG_N(CHECKBUTTON::ONOFF_SLIDING_BG_NORMAL, BITMAP_PIXEL_FORMAT_ARGB8888, __pOnOffSlidingBgBitmap[_CHECK_BUTTON_STATUS_NORMAL]);
 945         r = GET_BITMAP_CONFIG_N(CHECKBUTTON::ONOFF_SLIDING_BG_DISABLED, BITMAP_PIXEL_FORMAT_ARGB8888, __pOnOffSlidingBgBitmap[_CHECK_BUTTON_STATUS_DISABLED]);
 946         r = GET_BITMAP_CONFIG_N(CHECKBUTTON::ONOFF_SLIDING_BG_PRESSED, BITMAP_PIXEL_FORMAT_ARGB8888, __pOnOffSlidingBgBitmap[_CHECK_BUTTON_STATUS_PRESSED]);
 947         r = GET_BITMAP_CONFIG_N(CHECKBUTTON::ONOFF_SLIDING_BG_HIGHLIGHTED, BITMAP_PIXEL_FORMAT_ARGB8888, __pOnOffSlidingBgBitmap[_CHECK_BUTTON_STATUS_HIGHLIGHTED]);
 948         r = GET_BITMAP_CONFIG_N(CHECKBUTTON::ONOFF_SLIDING_BG_SELECTED, BITMAP_PIXEL_FORMAT_ARGB8888, __pOnOffSlidingBgBitmap[_CHECK_BUTTON_STATUS_SELECTED]);
 949
 950         r = GET_BITMAP_CONFIG_N(CHECKBUTTON::ONOFF_SLIDING_ON_HANDLER_NORMAL, BITMAP_PIXEL_FORMAT_ARGB8888, __pOnOffSlidingOnHandlerBitmap[_CHECK_BUTTON_STATUS_NORMAL]);
 951         r = GET_BITMAP_CONFIG_N(CHECKBUTTON::ONOFF_SLIDING_ON_HANDLER_DISABLED, BITMAP_PIXEL_FORMAT_ARGB8888, __pOnOffSlidingOnHandlerBitmap[_CHECK_BUTTON_STATUS_DISABLED]);
 952         r = GET_BITMAP_CONFIG_N(CHECKBUTTON::ONOFF_SLIDING_ON_HANDLER_PRESSED, BITMAP_PIXEL_FORMAT_ARGB8888, __pOnOffSlidingOnHandlerBitmap[_CHECK_BUTTON_STATUS_PRESSED]);
 953         r = GET_BITMAP_CONFIG_N(CHECKBUTTON::ONOFF_SLIDING_ON_HANDLER_HIGHLIGHTED, BITMAP_PIXEL_FORMAT_ARGB8888, __pOnOffSlidingOnHandlerBitmap[_CHECK_BUTTON_STATUS_HIGHLIGHTED]);
 954         r = GET_BITMAP_CONFIG_N(CHECKBUTTON::ONOFF_SLIDING_ON_HANDLER_SELECTED, BITMAP_PIXEL_FORMAT_ARGB8888, __pOnOffSlidingOnHandlerBitmap[_CHECK_BUTTON_STATUS_SELECTED]);
 955
 956         r = GET_BITMAP_CONFIG_N(CHECKBUTTON::ONOFF_SLIDING_OFF_HANDLER_NORMAL, BITMAP_PIXEL_FORMAT_ARGB8888, __pOnOffSlidingOffHandlerBitmap[_CHECK_BUTTON_STATUS_NORMAL]);
 957         r = GET_BITMAP_CONFIG_N(CHECKBUTTON::ONOFF_SLIDING_OFF_HANDLER_DISABLED, BITMAP_PIXEL_FORMAT_ARGB8888, __pOnOffSlidingOffHandlerBitmap[_CHECK_BUTTON_STATUS_DISABLED]);
 958         r = GET_BITMAP_CONFIG_N(CHECKBUTTON::ONOFF_SLIDING_OFF_HANDLER_PRESSED, BITMAP_PIXEL_FORMAT_ARGB8888, __pOnOffSlidingOffHandlerBitmap[_CHECK_BUTTON_STATUS_PRESSED]);
 959         r = GET_BITMAP_CONFIG_N(CHECKBUTTON::ONOFF_SLIDING_OFF_HANDLER_HIGHLIGHTED, BITMAP_PIXEL_FORMAT_ARGB8888, __pOnOffSlidingOffHandlerBitmap[_CHECK_BUTTON_STATUS_HIGHLIGHTED]);
 960         r = GET_BITMAP_CONFIG_N(CHECKBUTTON::ONOFF_SLIDING_OFF_HANDLER_SELECTED, BITMAP_PIXEL_FORMAT_ARGB8888, __pOnOffSlidingOffHandlerBitmap[_CHECK_BUTTON_STATUS_SELECTED]);
 961
 962         r = GET_BITMAP_CONFIG_N(CHECKBUTTON::DETAILED_BG_NORMAL, BITMAP_PIXEL_FORMAT_ARGB8888, __pCircleBitmap[_CHECK_BUTTON_STATUS_NORMAL]);
 963         r = GET_BITMAP_CONFIG_N(CHECKBUTTON::DETAILED_BG_DISABLED, BITMAP_PIXEL_FORMAT_ARGB8888, __pCircleBitmap[_CHECK_BUTTON_STATUS_DISABLED]);
 964         r = GET_BITMAP_CONFIG_N(CHECKBUTTON::DETAILED_BG_PRESSED, BITMAP_PIXEL_FORMAT_ARGB8888, __pCircleBitmap[_CHECK_BUTTON_STATUS_PRESSED]);
 965         r = GET_BITMAP_CONFIG_N(CHECKBUTTON::DETAILED_BG_HIGHLIGHTED, BITMAP_PIXEL_FORMAT_ARGB8888, __pCircleBitmap[_CHECK_BUTTON_STATUS_HIGHLIGHTED]);
 966         r = GET_BITMAP_CONFIG_N(CHECKBUTTON::DETAILED_BG_SELECTED, BITMAP_PIXEL_FORMAT_ARGB8888, __pCircleBitmap[_CHECK_BUTTON_STATUS_SELECTED]);
 967
 968         r = GET_BITMAP_CONFIG_N(CHECKBUTTON::DETAILED_BG_EFFECT_NORMAL, BITMAP_PIXEL_FORMAT_ARGB8888, __pCircleNormalEffectBitmap);
 969         r = GET_BITMAP_CONFIG_N(CHECKBUTTON::DETAILED_BG_EFFECT_PRESSED, BITMAP_PIXEL_FORMAT_ARGB8888, __pCirclePressedEffectBitmap);
 970
 971         r = GET_BITMAP_CONFIG_N(CHECKBUTTON::DETAILED_ICON_NORMAL, BITMAP_PIXEL_FORMAT_ARGB8888, __pDetailedRightBitmap[_CHECK_BUTTON_STATUS_NORMAL]);
 972         r = GET_BITMAP_CONFIG_N(CHECKBUTTON::DETAILED_ICON_DISABLED, BITMAP_PIXEL_FORMAT_ARGB8888, __pDetailedRightBitmap[_CHECK_BUTTON_STATUS_DISABLED]);
 973         r = GET_BITMAP_CONFIG_N(CHECKBUTTON::DETAILED_ICON_PRESSED, BITMAP_PIXEL_FORMAT_ARGB8888, __pDetailedRightBitmap[_CHECK_BUTTON_STATUS_PRESSED]);
 974         r = GET_BITMAP_CONFIG_N(CHECKBUTTON::DETAILED_ICON_HIGHLIGHTED, BITMAP_PIXEL_FORMAT_ARGB8888, __pDetailedRightBitmap[_CHECK_BUTTON_STATUS_HIGHLIGHTED]);
 975         r = GET_BITMAP_CONFIG_N(CHECKBUTTON::DETAILED_ICON_SELECTED, BITMAP_PIXEL_FORMAT_ARGB8888, __pDetailedRightBitmap[_CHECK_BUTTON_STATUS_SELECTED]);
 976
 977         return r;
 978 }
 979
 980 result
 981 _CheckButton::SetText(const String& text)
 982 {
 983         return SetProperty(L"text", Variant(text));
 984 }
 985
 986 result
 987 _CheckButton::SetPropertyText(const Variant& text)
 988 {
 989         __text = text.ToString();
 990
 991         if(__pButtonElement)
 992         {
 993                 __pButtonElement->SetLabel(__text);
 994         }
 995
 996         return E_SUCCESS;
 997 }
 998
 999 String
1000 _CheckButton::GetText(void) const
1001 {
1002         Variant text = GetProperty(L"text");
1003
1004         return text.ToString();
1005 }
1006
1007 Variant
1008 _CheckButton::GetPropertyText(void) const
1009 {
1010         return Variant(__text);
1011 }
1012
1013 result
1014 _CheckButton::SetTitleText(const String& title)
1015 {
1016         return SetProperty(L"titleText", Variant(title));
1017 }
1018
1019 result
1020 _CheckButton::SetPropertyTitleText(const Variant& title)
1021 {
1022         __titleText = title.ToString();
1023
1024         if (__pButtonElement)
1025         {
1026                 String label = __titleText;
1027                 label.Append(L", ");
1028
1029                 __pButtonElement->SetLabel(label + GetText());
1030         }
1031         return E_SUCCESS;
1032 }
1033
1034 String
1035 _CheckButton::GetTitleText(void) const
1036 {
1037         Variant title = GetProperty(L"titleText");
1038
1039         return title.ToString();
1040 }
1041
1042 Variant
1043 _CheckButton::GetPropertyTitleText(void) const
1044 {
1045         return Variant(__titleText);
1046 }
1047
1048 result
1049 _CheckButton::SetTextHorizontalAlignment(HorizontalAlignment alignment)
1050 {
1051         __horizontalAlignment = alignment;
1052         return E_SUCCESS;
1053 }
1054
1055 HorizontalAlignment
1056 _CheckButton::GetTextHorizontalAlignment(void) const
1057 {
1058         return __horizontalAlignment;
1059 }
1060
1061 result
1062 _CheckButton::SetTextVerticalAlignment(VerticalAlignment alignment)
1063 {
1064         __verticalAlignment = alignment;
1065         return E_SUCCESS;
1066 }
1067
1068 VerticalAlignment
1069 _CheckButton::GetTextVerticalAlignment(void) const
1070 {
1071         return __verticalAlignment;
1072 }
1073
1074 result
1075 _CheckButton::SetTextColor(const Color& color)
1076 {
1077         return SetProperty(L"normalTextColor", Variant(color));
1078 }
1079
1080 Color
1081 _CheckButton::GetTextColor(void) const
1082 {
1083         Variant color = GetProperty(L"normalTextColor");
1084
1085         return color.ToColor();
1086 }
1087
1088 result
1089 _CheckButton::SetDisabledTextColor(const Color& color)
1090 {
1091         return SetProperty(L"disabledTextColor", Variant(color));
1092 }
1093
1094 Color
1095 _CheckButton::GetDisabledTextColor(void) const
1096 {
1097         Variant color = GetProperty(L"disabledTextColor");
1098
1099         return color.ToColor();
1100 }
1101
1102 result
1103 _CheckButton::SetPressedTextColor(const Color& color)
1104 {
1105         return SetProperty(L"pressedTextColor", Variant(color));
1106 }
1107
1108 Color
1109 _CheckButton::GetPressedTextColor(void) const
1110 {
1111         Variant color = GetProperty(L"pressedTextColor");
1112
1113         return color.ToColor();
1114 }
1115
1116 result
1117 _CheckButton::SetHighlightedTextColor(const Color& color)
1118 {
1119         return SetProperty(L"highlightedTextColor", Variant(color));
1120 }
1121
1122 Color
1123 _CheckButton::GetHighlightedTextColor(void) const
1124 {
1125
1126         Variant color = GetProperty(L"highlightedTextColor");
1127
1128         return color.ToColor();
1129 }
1130
1131 result
1132 _CheckButton::SetSelectedTextColor(const Color& color)
1133 {
1134         return SetProperty(L"selectedTextColor", Variant(color));
1135 }
1136
1137 Color
1138 _CheckButton::GetSelectedTextColor(void) const
1139 {
1140
1141         Variant color = GetProperty(L"selectedTextColor");
1142
1143         return color.ToColor();
1144 }
1145
1146 result
1147 _CheckButton::SetPropertyNormalTextColor(const Variant& color)
1148 {
1149         __normalTextColor = color.ToColor();
1150         return E_SUCCESS;
1151 }
1152
1153 result
1154 _CheckButton::SetPropertyDisabledTextColor(const Variant& color)
1155 {
1156         __disabledTextColor = color.ToColor();
1157         return E_SUCCESS;
1158 }
1159
1160 result
1161 _CheckButton::SetPropertyPressedTextColor(const Variant& color)
1162 {
1163         __pressedTextColor = color.ToColor();
1164         return E_SUCCESS;
1165 }
1166
1167 result
1168 _CheckButton::SetPropertyHighlightedTextColor(const Variant& color)
1169 {
1170         __highlightedTextColor = color.ToColor();
1171         return E_SUCCESS;
1172 }
1173
1174 result
1175 _CheckButton::SetPropertySelectedTextColor(const Variant& color)
1176 {
1177         __selectedTextColor = color.ToColor();
1178         return E_SUCCESS;
1179 }
1180
1181 Variant
1182 _CheckButton::GetPropertyNormalTextColor(void) const
1183 {
1184         return Variant(__normalTextColor);
1185 }
1186
1187 Variant
1188 _CheckButton::GetPropertyDisabledTextColor(void) const
1189 {
1190         return Variant(__disabledTextColor);
1191 }
1192
1193 Variant
1194 _CheckButton::GetPropertyPressedTextColor(void) const
1195 {
1196         return Variant(__pressedTextColor);
1197 }
1198
1199 Variant
1200 _CheckButton::GetPropertyHighlightedTextColor(void) const
1201 {
1202         return Variant(__highlightedTextColor);
1203 }
1204
1205 Variant
1206 _CheckButton::GetPropertySelectedTextColor(void) const
1207 {
1208         return Variant(__selectedTextColor);
1209 }
1210
1211 result
1212 _CheckButton::SetTitleTextColor(const Color& color)
1213 {
1214         return SetProperty(L"normalTitleTextColor", Variant(color));
1215 }
1216
1217 Color
1218 _CheckButton::GetTitleTextColor(void) const
1219 {
1220         Variant color = GetProperty(L"normalTitleTextColor");
1221
1222         return color.ToColor();
1223 }
1224
1225 result
1226 _CheckButton::SetDisabledTitleTextColor(const Color& color)
1227 {
1228         return SetProperty(L"disabledTitleTextColor", Variant(color));
1229 }
1230
1231 Color
1232 _CheckButton::GetDisabledTitleTextColor(void) const
1233 {
1234         Variant color = GetProperty(L"disabledTitleTextColor");
1235
1236         return color.ToColor();
1237 }
1238
1239 result
1240 _CheckButton::SetPressedTitleTextColor(const Color& color)
1241 {
1242         return SetProperty(L"pressedTitleTextColor", Variant(color));
1243 }
1244
1245 Color
1246 _CheckButton::GetPressedTitleTextColor(void) const
1247 {
1248         Variant color = GetProperty(L"pressedTitleTextColor");
1249
1250         return color.ToColor();
1251 }
1252
1253 result
1254 _CheckButton::SetHighlightedTitleTextColor(const Color& color)
1255 {
1256         return SetProperty(L"highlightedTitleTextColor", Variant(color));
1257 }
1258
1259 Color
1260 _CheckButton::GetHighlightedTitleTextColor(void) const
1261 {
1262         Variant color = GetProperty(L"highlightedTitleTextColor");
1263
1264         return color.ToColor();
1265 }
1266
1267 result
1268 _CheckButton::SetSelectedTitleTextColor(const Color& color)
1269 {
1270         return SetProperty(L"selectedTitleTextColor", Variant(color));
1271 }
1272
1273 Color
1274 _CheckButton::GetSelectedTitleTextColor(void) const
1275 {
1276         Variant color = GetProperty(L"selectedTitleTextColor");
1277
1278         return color.ToColor();
1279 }
1280
1281 result
1282 _CheckButton::SetPropertyNormalTitleTextColor(const Variant& color)
1283 {
1284         __normalTitleTextColor = color.ToColor();
1285         return E_SUCCESS;
1286 }
1287
1288 result
1289 _CheckButton::SetPropertyDisabledTitleTextColor(const Variant& color)
1290 {
1291         __disabledTitleTextColor = color.ToColor();
1292         return E_SUCCESS;
1293 }
1294
1295 result
1296 _CheckButton::SetPropertyPressedTitleTextColor(const Variant& color)
1297 {
1298         __pressedTitleTextColor = color.ToColor();
1299         return E_SUCCESS;
1300 }
1301
1302 result
1303 _CheckButton::SetPropertyHighlightedTitleTextColor(const Variant& color)
1304 {
1305         __highlightedTitleTextColor = color.ToColor();
1306         return E_SUCCESS;
1307 }
1308
1309 result
1310 _CheckButton::SetPropertySelectedTitleTextColor(const Variant& color)
1311 {
1312         __selectedTitleTextColor = color.ToColor();
1313         return E_SUCCESS;
1314 }
1315
1316 Variant
1317 _CheckButton::GetPropertyNormalTitleTextColor(void) const
1318 {
1319         return Variant(__normalTitleTextColor);
1320 }
1321
1322 Variant
1323 _CheckButton::GetPropertyDisabledTitleTextColor(void) const
1324 {
1325         return Variant(__disabledTitleTextColor);
1326 }
1327
1328 Variant
1329 _CheckButton::GetPropertyPressedTitleTextColor(void) const
1330 {
1331         return Variant(__pressedTitleTextColor);
1332 }
1333
1334 Variant
1335 _CheckButton::GetPropertyHighlightedTitleTextColor(void) const
1336 {
1337         return Variant(__highlightedTitleTextColor);
1338 }
1339
1340 Variant
1341 _CheckButton::GetPropertySelectedTitleTextColor(void) const
1342 {
1343         return Variant(__selectedTitleTextColor);
1344 }
1345
1346 result
1347 _CheckButton::SetColor(_CheckButtonStatus status, const Color& color)
1348 {
1349         result r = E_SUCCESS;
1350
1351         switch (status)
1352         {
1353         case _CHECK_BUTTON_STATUS_NORMAL:
1354                 r = SetProperty(L"normalColor", Variant(color));
1355                 break;
1356         case _CHECK_BUTTON_STATUS_DISABLED:
1357                 r = SetProperty(L"disabledColor", Variant(color));
1358                 break;
1359         case _CHECK_BUTTON_STATUS_PRESSED:
1360                 r = SetProperty(L"pressedColor", Variant(color));
1361                 break;
1362         case _CHECK_BUTTON_STATUS_HIGHLIGHTED:
1363                 r = SetProperty(L"highlightedColor", Variant(color));
1364                 break;
1365         default:
1366                 r = SetProperty(L"selectedColor", Variant(color));
1367         }
1368
1369         return r;
1370 }
1371
1372 result
1373 _CheckButton::SetPropertyNormalColor(const Variant& color)
1374 {
1375         __normalColor = color.ToColor();
1376         return E_SUCCESS;
1377 }
1378
1379 result
1380 _CheckButton::SetPropertyDisabledColor(const Variant& color)
1381 {
1382         __disabledColor = color.ToColor();
1383         return E_SUCCESS;
1384 }
1385
1386 result
1387 _CheckButton::SetPropertyPressedColor(const Variant& color)
1388 {
1389         __pressedColor = color.ToColor();
1390         return E_SUCCESS;
1391 }
1392
1393 result
1394 _CheckButton::SetPropertyHighlightedColor(const Variant& color)
1395 {
1396         __highlightedColor = color.ToColor();
1397         return E_SUCCESS;
1398 }
1399
1400 result
1401 _CheckButton::SetPropertySelectedColor(const Variant& color)
1402 {
1403         __selectedColor = color.ToColor();
1404         return E_SUCCESS;
1405 }
1406
1407 Color
1408 _CheckButton::GetColor(_CheckButtonStatus status) const
1409 {
1410         Variant color;
1411
1412         switch (status)
1413         {
1414         case _CHECK_BUTTON_STATUS_NORMAL:
1415                 color = GetProperty(L"normalColor");
1416                 break;
1417         case _CHECK_BUTTON_STATUS_DISABLED:
1418                 color = GetProperty(L"disabledColor");
1419                 break;
1420         case _CHECK_BUTTON_STATUS_PRESSED:
1421                 color = GetProperty(L"pressedColor");
1422                 break;
1423         case _CHECK_BUTTON_STATUS_HIGHLIGHTED:
1424                 color = GetProperty(L"highlightedColor");
1425                 break;
1426         default:
1427                 color = GetProperty(L"selectedColor");
1428         }
1429
1430         return color.ToColor();
1431 }
1432
1433 Variant
1434 _CheckButton::GetPropertyNormalColor(void) const
1435 {
1436         return Variant(__normalColor);
1437 }
1438
1439 Variant
1440 _CheckButton::GetPropertyDisabledColor(void) const
1441 {
1442         return Variant(__disabledColor);
1443 }
1444
1445 Variant
1446 _CheckButton::GetPropertyPressedColor(void) const
1447 {
1448         return Variant(__pressedColor);
1449 }
1450
1451 Variant
1452 _CheckButton::GetPropertyHighlightedColor(void) const
1453 {
1454         return Variant(__highlightedColor);
1455 }
1456
1457 Variant
1458 _CheckButton::GetPropertySelectedColor(void) const
1459 {
1460         return Variant(__selectedColor);
1461 }
1462
1463 int
1464 _CheckButton::GetTextSize(void) const
1465 {
1466         return _CoordinateSystemUtils::ConvertToInteger(GetTextSizeF());
1467 }
1468
1469 float
1470 _CheckButton::GetTextSizeF(void) const
1471 {
1472         return __textSize;
1473 }
1474
1475 int
1476 _CheckButton::GetTitleTextSize(void) const
1477 {
1478         return _CoordinateSystemUtils::ConvertToInteger(GetTitleTextSizeF());
1479 }
1480
1481 float
1482 _CheckButton::GetTitleTextSizeF(void) const
1483 {
1484         return __titleTextSize;
1485 }
1486
1487 result
1488 _CheckButton::SetCheckButtonStyle(const CheckButtonStyle& checkButtonStyle)
1489 {
1490         __checkButtonStyle = checkButtonStyle;
1491         return E_SUCCESS;
1492 }
1493
1494 result
1495 _CheckButton::SetBackgroundStyle(const BackgroundStyle& backgroundStyle)
1496 {
1497         __backgroundStyle = backgroundStyle;
1498         return E_SUCCESS;
1499 }
1500
1501 result
1502 _CheckButton::SetShowTitle(bool showTitle)
1503 {
1504         __showTitle = showTitle;
1505         return E_SUCCESS;
1506 }
1507
1508 result
1509 _CheckButton::SetGroupStyle(const GroupStyle& groupStyle)
1510 {
1511         __groupStyle = groupStyle;
1512         return E_SUCCESS;
1513 }
1514
1515 result
1516 _CheckButton::SetCheckButtonStatus(_CheckButtonStatus checkButtonStatus)
1517 {
1518         if (__checkButtonStatus != checkButtonStatus)
1519         {
1520                 __checkButtonStatus = checkButtonStatus;
1521         }
1522
1523         if (_CHECK_BUTTON_STATUS_DISABLED == __checkButtonStatus)
1524         {
1525                 SetEnableState(false);
1526         }
1527         else
1528         {
1529                 SetEnableState(true);
1530         }
1531
1532         return E_SUCCESS;
1533 }
1534
1535 CheckButtonStyle
1536 _CheckButton::GetCheckButtonStyle(void) const
1537 {
1538         return __checkButtonStyle;
1539 }
1540
1541 BackgroundStyle
1542 _CheckButton::GetBackgroundStyle(void) const
1543 {
1544         return __backgroundStyle;
1545 }
1546
1547 bool
1548 _CheckButton::GetShowTitle(void) const
1549 {
1550         return __showTitle;
1551 }
1552
1553 GroupStyle
1554 _CheckButton::GetGroupStyle(void) const
1555 {
1556         return __groupStyle;
1557 }
1558
1559 _CheckButtonStatus
1560 _CheckButton::GetCheckButtonStatus(void) const
1561 {
1562         _CheckButtonStatus status = __checkButtonStatus;
1563
1564         if (!IsEnabled())
1565         {
1566                 status = _CHECK_BUTTON_STATUS_DISABLED;
1567         }
1568
1569         return status;
1570 }
1571
1572 Bitmap*
1573 _CheckButton::GetMarkBgBitmap(_CheckButtonStatus checkButtonStatus) const
1574 {
1575         return __pMarkBgNormalBitmap[checkButtonStatus];
1576 }
1577
1578 Bitmap*
1579 _CheckButton::GetMarkBitmap(_CheckButtonStatus checkButtonStatus) const
1580 {
1581         return __pMarkBitmap[checkButtonStatus];
1582 }
1583
1584 Bitmap*
1585 _CheckButton::GetOnOffBgBitmap(_CheckButtonStatus checkButtonStatus) const
1586 {
1587         return __pOnOffBgNormalBitmap[checkButtonStatus];
1588 }
1589
1590 Bitmap*
1591 _CheckButton::GetOnOffBitmap(_CheckButtonStatus checkButtonStatus) const
1592 {
1593         return __pOnOffBitmap[checkButtonStatus];
1594 }
1595
1596 Bitmap*
1597 _CheckButton::GetOnOffSlidingBgBitmap(_CheckButtonStatus checkButtonStatus) const
1598 {
1599         return __pOnOffSlidingBgBitmap[checkButtonStatus];
1600 }
1601
1602 Bitmap*
1603 _CheckButton::GetOnOffSlidingOnHandlerBitmap(_CheckButtonStatus checkButtonStatus) const
1604 {
1605         return __pOnOffSlidingOnHandlerBitmap[checkButtonStatus];
1606 }
1607
1608 Bitmap*
1609 _CheckButton::GetOnOffSlidingOffHandlerBitmap(_CheckButtonStatus checkButtonStatus) const
1610 {
1611         return __pOnOffSlidingOffHandlerBitmap[checkButtonStatus];
1612 }
1613
1614 Bitmap*
1615 _CheckButton::GetCircleBitmap(_CheckButtonStatus checkButtonStatus) const
1616 {
1617         return __pCircleBitmap[checkButtonStatus];
1618 }
1619
1620 Bitmap*
1621 _CheckButton::GetCircleNormalEffectBitmap(void) const
1622 {
1623         return __pCircleNormalEffectBitmap;
1624 }
1625
1626 Bitmap*
1627 _CheckButton::GetCirclePressedEffectBitmap(void) const
1628 {
1629         return __pCirclePressedEffectBitmap;
1630 }
1631
1632 Bitmap*
1633 _CheckButton::GetDetailedRightBitmap(_CheckButtonStatus checkButtonStatus) const
1634 {
1635         return __pDetailedRightBitmap[checkButtonStatus];
1636 }
1637
1638 Bitmap*
1639 _CheckButton::GetBackgroundBitmap(GroupStyle groupStyle, _CheckButtonStatus checkButtonStatus) const
1640 {
1641         switch(groupStyle)
1642         {
1643         case GROUP_STYLE_TOP:
1644                 return __pBackgroundTopBitmap[checkButtonStatus];
1645                 break;
1646         case GROUP_STYLE_MIDDLE:
1647                 return __pBackgroundMiddleBitmap[checkButtonStatus];
1648                 break;
1649         case GROUP_STYLE_BOTTOM:
1650                 return __pBackgroundBottomBitmap[checkButtonStatus];
1651                 break;
1652         default:
1653                 return __pBackgroundBitmap[checkButtonStatus];
1654         }
1655 }
1656
1657 Bitmap*
1658 _CheckButton::GetBackgroundNormalEffectBitmap(GroupStyle groupStyle) const
1659 {
1660         switch(groupStyle)
1661         {
1662         case GROUP_STYLE_TOP:
1663                 return __pBackgroundTopNormalEffectBitmap;
1664                 break;
1665         case GROUP_STYLE_MIDDLE:
1666                 return __pBackgroundMiddleNormalEffectBitmap;
1667                 break;
1668         case GROUP_STYLE_BOTTOM:
1669                 return __pBackgroundBottomNormalEffectBitmap;
1670                 break;
1671         default:
1672                 return __pBackgroundNormalEffectBitmap;
1673         }
1674 }
1675
1676 Bitmap*
1677 _CheckButton::GetBackgroundPressedEffectBitmap(GroupStyle groupStyle) const
1678 {
1679         switch(groupStyle)
1680         {
1681         case GROUP_STYLE_TOP:
1682                 return __pBackgroundTopPressedEffectBitmap;
1683                 break;
1684         case GROUP_STYLE_MIDDLE:
1685                 return __pBackgroundMiddlePressedEffectBitmap;
1686                 break;
1687         case GROUP_STYLE_BOTTOM:
1688                 return __pBackgroundBottomPressedEffectBitmap;
1689                 break;
1690         default:
1691                 return __pBackgroundPressedEffectBitmap;
1692         }
1693 }
1694
1695 bool
1696 _CheckButton::IsTouchAreaChanged(bool currentButtonArea)
1697 {
1698         if (__previousTouchArea != currentButtonArea)
1699         {
1700                 __previousTouchArea = currentButtonArea;
1701                 return true;
1702         }
1703         else
1704         {
1705                 return false;
1706         }
1707 }
1708
1709 result
1710 _CheckButton::FireActionEvent(void)
1711 {
1712         result r = E_SUCCESS;
1713
1714         if (__selected)
1715         {
1716                 __selected = false;
1717
1718                 //SetCheckButtonStatus(_CHECK_BUTTON_STATUS_NORMAL);
1719
1720                 if (__pActionEvent)
1721                 {
1722                         IEventArg* pEventArg = _ActionEvent::CreateActionEventArgN(__uncheckedActionId);
1723                         SysTryReturn(NID_UI_CTRL, pEventArg, E_INVALID_STATE, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] Memory shortage.");
1724                         __pActionEvent->Fire(*pEventArg);
1725                 }
1726         }
1727         else
1728         {
1729                 __selected = true;
1730
1731                 //SetCheckButtonStatus(_CHECK_BUTTON_STATUS_SELECTED);
1732
1733                 if (__pActionEvent)
1734                 {
1735                         IEventArg* pEventArg = _ActionEvent::CreateActionEventArgN(__checkedActionId);
1736                         SysTryReturn(NID_UI_CTRL, pEventArg, E_INVALID_STATE, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] Memory shortage.");
1737                         __pActionEvent->Fire(*pEventArg);
1738                 }
1739         }
1740         return r;
1741 }
1742
1743 _Control*
1744 _CheckButton::GetRadioGroup(void)
1745 {
1746         return __pRadioGroup;
1747 }
1748
1749 void
1750 _CheckButton::UpdateAccessibilityCheckStatus(void)
1751 {
1752         if(likely(!(_AccessibilityManager::IsActivated())))
1753         {
1754                 return;
1755         }
1756
1757         if (__checkButtonStyle == CHECK_BUTTON_STYLE_MARK || __checkButtonStyle == CHECK_BUTTON_STYLE_MARK_WITH_DIVIDER || __checkButtonStyle == CHECK_BUTTON_STYLE_MARK_WITH_DETAILED_BUTTON)
1758         {
1759                 if (__pButtonElement != null)
1760                 {
1761                         if(__selected)
1762                         {
1763                                 __pButtonElement->SetValueWithStringId("IDS_TPLATFORM_BODY_TICK_T_TTS");
1764                         }
1765                         else
1766                         {
1767                                 __pButtonElement->SetValueWithStringId("IDS_TPLATFORM_BODY_UNTICK_T_TTS");
1768                         }
1769                 }
1770         }
1771         else if (__checkButtonStyle == CHECK_BUTTON_STYLE_RADIO || __checkButtonStyle == CHECK_BUTTON_STYLE_RADIO_WITH_DIVIDER || __checkButtonStyle == CHECK_BUTTON_STYLE_RADIO_WITH_DETAILED_BUTTON)
1772         {
1773                 if (__pButtonElement != null)
1774                 {
1775                         if(__selected)
1776                         {
1777                                 __pButtonElement->SetValueWithStringId("IDS_TPLATFORM_BODY_SELECTED_T_TTS");
1778                         }
1779                         else
1780                         {
1781                                 __pButtonElement->SetValue(L"unselected");
1782                         }
1783                 }
1784         }
1785         else if (__checkButtonStyle == CHECK_BUTTON_STYLE_ONOFF || __checkButtonStyle == CHECK_BUTTON_STYLE_ONOFF_WITH_DIVIDER
1786                 || __checkButtonStyle == CHECK_BUTTON_STYLE_ONOFF_SLIDING || __checkButtonStyle == CHECK_BUTTON_STYLE_ONOFF_SLIDING_WITH_DIVIDER)
1787         {
1788                 if (__pButtonElement != null)
1789                 {
1790                         if(__selected)
1791                         {
1792                                 __pButtonElement->SetValueWithStringId("IDS_TPLATFORM_BODY_ON");
1793                         }
1794                         else
1795                         {
1796                                 __pButtonElement->SetValueWithStringId("IDS_TPLATFORM_BODY_OFF");
1797                         }
1798                 }
1799         }
1800
1801         return;
1802 }
1803
1804 }}} // Tizen::Ui::Controls