src/ui/controls/FUiCtrl_CheckButtonImpl.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_CheckButtonImpl.cpp
  19  * @brief               This is the implementation file for the _CheckButtonImpl class.
  20  */
  21
  22 #include <FUiCtrlRadioGroup.h>
  23 #include <FBaseInternalTypes.h>
  24 #include <FBaseSysLog.h>
  25 #include <FUiAccessibilityContainer.h>
  26 #include <FUiAccessibilityElement.h>
  27 #include <FApp_AppInfo.h>
  28 #include "FUi_ResourceSizeInfo.h"
  29 #include "FUi_ResourceManager.h"
  30 #include "FUi_UiBuilder.h"
  31 #include "FUiCtrl_CheckButtonImpl.h"
  32 #include "FUiCtrl_CheckButton.h"
  33
  34
  35 using namespace Tizen::Base;
  36 using namespace Tizen::Graphics;
  37 using namespace Tizen::App;
  38
  39 namespace Tizen { namespace Ui { namespace Controls
  40 {
  41
  42 Dimension
  43 _CheckButtonImpl::CheckButtonSizeInfo::GetDefaultMinimumSize(_ControlOrientation orientation) const
  44 {
  45         result r = E_SUCCESS;
  46         Dimension dimension(0, 0);
  47
  48         r = GET_DIMENSION_CONFIG(CHECKBUTTON::MIN_SIZE, orientation, dimension);
  49         SysTryReturn(NID_UI, r == E_SUCCESS, dimension, r, "[%s] A system error occurred.", GetErrorMessage(r));
  50
  51         SetLastResult(r);
  52
  53         return dimension;
  54 }
  55
  56 FloatDimension
  57 _CheckButtonImpl::CheckButtonSizeInfo::GetDefaultMinimumSizeF(_ControlOrientation orientation) const
  58 {
  59         result r = E_SUCCESS;
  60         FloatDimension dimension(0.0f, 0.0f);
  61
  62         r = GET_DIMENSION_CONFIG(CHECKBUTTON::MIN_SIZE, orientation, dimension);
  63         SysTryReturn(NID_UI, r == E_SUCCESS, dimension, r, "[%s] A system error occurred.", GetErrorMessage(r));
  64
  65         SetLastResult(r);
  66
  67         return dimension;
  68 }
  69
  70 _CheckButtonImpl*
  71 _CheckButtonImpl::GetInstance(CheckButton& checkButton)
  72 {
  73         return static_cast<_CheckButtonImpl*> (checkButton._pControlImpl);
  74 }
  75
  76 const _CheckButtonImpl*
  77 _CheckButtonImpl::GetInstance(const CheckButton& checkButton)
  78 {
  79         return static_cast<const _CheckButtonImpl*> (checkButton._pControlImpl);
  80 }
  81
  82 _CheckButtonImpl::_CheckButtonImpl(CheckButton* pPublic, _CheckButton* pCore)
  83         : _ControlImpl(pPublic, pCore)
  84         , __pPublicActionEvent(null)
  85 {
  86         ClearLastResult();
  87 }
  88
  89 _CheckButtonImpl::~_CheckButtonImpl(void)
  90 {
  91         _CheckButtonImpl::GetCore().RemoveActionEventListener(*this);
  92
  93         if (__pPublicActionEvent)
  94         {
  95                 delete __pPublicActionEvent;
  96                 __pPublicActionEvent = null;
  97         }
  98
  99         ClearLastResult();
 100 }
 101
 102 _CheckButtonImpl*
 103 _CheckButtonImpl::CreateCheckButtonImplN(CheckButton* pControl, const Rectangle& bounds)
 104 {
 105         result r = E_SUCCESS;
 106         r = GET_SIZE_INFO(CheckButton).CheckInitialSizeValid(Dimension(bounds.width, bounds.height), _CONTROL_ORIENTATION_PORTRAIT);
 107         SysTryReturn(NID_UI_CTRL, r == E_SUCCESS, null, E_INVALID_ARG, "[E_INVALID_ARG] The given size is not valid.");
 108
 109         _CheckButton* pCore = _CheckButton::CreateCheckButtonN();
 110         SysTryReturn(NID_UI_CTRL, pCore, null, E_SYSTEM, "[%s] Propagating.", GetErrorMessage(GetLastResult()));
 111
 112         _CheckButtonImpl* pImpl = new (std::nothrow) _CheckButtonImpl(pControl, pCore);
 113         r = _ControlImpl::CheckConstruction(pCore, pImpl);
 114         SysTryReturn(NID_UI_CTRL, r == E_SUCCESS, null, r, "[%s] Propagating.", GetErrorMessage(r));
 115
 116         r = pImpl->InitializeBoundsProperties(GET_SIZE_INFO(CheckButton), bounds, pCore->GetOrientation());
 117         SysTryCatch(NID_UI_CTRL, r == E_SUCCESS, , r, "[%s] Propagating.", GetErrorMessage(r));
 118
 119         r = pCore->AddActionEventListener(*pImpl);
 120         SysTryCatch(NID_UI_CTRL, r == E_SUCCESS, , r, "[%s] Propagating.", GetErrorMessage(r));
 121
 122         ClearLastResult();
 123
 124         return pImpl;
 125
 126 CATCH:
 127         delete pImpl;
 128         return null;
 129 }
 130
 131 _CheckButtonImpl*
 132 _CheckButtonImpl::CreateCheckButtonImplN(CheckButton* pControl, const FloatRectangle& bounds)
 133 {
 134         result r = E_SUCCESS;
 135         r = GET_SIZE_INFO(CheckButton).CheckInitialSizeValidF(FloatDimension(bounds.width, bounds.height), _CONTROL_ORIENTATION_PORTRAIT);
 136         SysTryReturn(NID_UI_CTRL, r == E_SUCCESS, null, E_INVALID_ARG, "[E_INVALID_ARG] The given size is not valid.");
 137
 138         _CheckButton* pCore = _CheckButton::CreateCheckButtonN();
 139         SysTryReturn(NID_UI_CTRL, pCore, null, E_SYSTEM, "[%s] Propagating.", GetErrorMessage(GetLastResult()));
 140
 141         _CheckButtonImpl* pImpl = new (std::nothrow) _CheckButtonImpl(pControl, pCore);
 142         r = _ControlImpl::CheckConstruction(pCore, pImpl);
 143         SysTryReturn(NID_UI_CTRL, r == E_SUCCESS, null, r, "[%s] Propagating.", GetErrorMessage(r));
 144
 145         r = pImpl->InitializeBoundsPropertiesF(GET_SIZE_INFO(CheckButton), bounds, pCore->GetOrientation());
 146         SysTryCatch(NID_UI_CTRL, r == E_SUCCESS, , r, "[%s] Propagating.", GetErrorMessage(r));
 147
 148         r = pCore->AddActionEventListener(*pImpl);
 149         SysTryCatch(NID_UI_CTRL, r == E_SUCCESS, , r, "[%s] Propagating.", GetErrorMessage(r));
 150
 151         ClearLastResult();
 152
 153         return pImpl;
 154
 155 CATCH:
 156         delete pImpl;
 157         return null;
 158 }
 159
 160 Color
 161 _CheckButtonImpl::GetColorOnError(void)
 162 {
 163         return Color(0XFFFFFFFF);
 164 }
 165
 166 const char*
 167 _CheckButtonImpl::GetPublicClassName(void) const
 168 {
 169         return "Tizen::Ui::Controls::CheckButton";
 170 }
 171
 172 const CheckButton&
 173 _CheckButtonImpl::GetPublic(void) const
 174 {
 175         return static_cast <const CheckButton&>(_ControlImpl::GetPublic());
 176 }
 177
 178 CheckButton&
 179 _CheckButtonImpl::GetPublic(void)
 180 {
 181         return static_cast <CheckButton&>(_ControlImpl::GetPublic());
 182 }
 183
 184 const _CheckButton&
 185 _CheckButtonImpl::GetCore(void) const
 186 {
 187         return static_cast <const _CheckButton&>(_ControlImpl::GetCore());
 188 }
 189
 190 _CheckButton&
 191 _CheckButtonImpl::GetCore(void)
 192 {
 193         return static_cast <_CheckButton&>(_ControlImpl::GetCore());
 194 }
 195
 196 result
 197 _CheckButtonImpl::SetSelected(bool select)
 198 {
 199         result r = GetCore().SetSelected(select);
 200
 201         SetLastResultReturn(r);
 202 }
 203
 204 bool
 205 _CheckButtonImpl::IsSelected(void) const
 206 {
 207         ClearLastResult();
 208
 209         return GetCore().IsSelected();
 210 }
 211
 212 result
 213 _CheckButtonImpl::AddActionEventListener(IActionEventListener& listener)
 214 {
 215         if (__pPublicActionEvent == null)
 216         {
 217                 __pPublicActionEvent = _PublicActionEvent::CreateInstanceN(GetPublic());
 218                 SysTryReturn(NID_UI_CTRL, __pPublicActionEvent, E_SYSTEM, E_SYSTEM, "[E_SYSTEM] A system error occurred.")
 219         }
 220
 221         result r = __pPublicActionEvent->AddListener(listener);
 222         SysTryReturn(NID_UI_CTRL, r == E_SUCCESS, E_SYSTEM, E_SYSTEM, "[E_SYSTEM] A system error occurred.");
 223
 224         return E_SUCCESS;
 225 }
 226
 227 result
 228 _CheckButtonImpl::RemoveActionEventListener(IActionEventListener& listener)
 229 {
 230         result r = E_OBJ_NOT_FOUND;
 231
 232         if (__pPublicActionEvent)
 233         {
 234                 r = __pPublicActionEvent->RemoveListener(listener);
 235         }
 236
 237         SysTryReturn(NID_UI_CTRL, r == E_SUCCESS, E_SYSTEM, E_SYSTEM, "[E_SYSTEM] A system error occurred.");
 238
 239         return E_SUCCESS;
 240 }
 241
 242 result
 243 _CheckButtonImpl::SetActionId(int checkedActionId, int uncheckedActionId, int selectedActionId)
 244 {
 245         result r = GetCore().SetActionId(checkedActionId, uncheckedActionId, selectedActionId);
 246
 247         SetLastResultReturn(r);
 248 }
 249
 250 int
 251 _CheckButtonImpl::GetCheckedActionId(void) const
 252 {
 253         ClearLastResult();
 254
 255         return GetCore().GetCheckedActionId();
 256 }
 257
 258 int
 259 _CheckButtonImpl::GetUncheckedActionId(void) const
 260 {
 261         ClearLastResult();
 262
 263         return GetCore().GetUncheckedActionId();
 264 }
 265
 266 int
 267 _CheckButtonImpl::GetSelectedActionId(void) const
 268 {
 269         ClearLastResult();
 270
 271         return GetCore().GetSelectedActionId();
 272 }
 273
 274 result
 275 _CheckButtonImpl::SetText(const String& text)
 276 {
 277         int textLength = text.GetLength();
 278         int checkButtonTextMaxLength = 0;
 279         GET_FIXED_VALUE_CONFIG(CHECKBUTTON::TEXT_MAX_LENGTH, _CONTROL_ORIENTATION_PORTRAIT, checkButtonTextMaxLength);
 280         String tempText = String(text);
 281
 282         if (textLength >= checkButtonTextMaxLength)
 283         {
 284                 tempText.Remove(checkButtonTextMaxLength - 1, textLength - checkButtonTextMaxLength + 1);
 285         }
 286
 287         Variant var(tempText);
 288         result r = GetCore().SetPropertyText(var);
 289         SysTryLog(NID_UI_CTRL, r == E_SUCCESS, "[%s] Propagating.", GetErrorMessage(r));
 290
 291         return r;
 292 }
 293
 294 String
 295 _CheckButtonImpl::GetText(void) const
 296 {
 297         ClearLastResult();
 298
 299         return GetCore().GetPropertyText().ToString();
 300 }
 301
 302 result
 303 _CheckButtonImpl::SetTitleText(const String& title)
 304 {
 305         SysTryReturn(NID_UI_CTRL, GetCore().GetShowTitle() == true , E_INVALID_STATE, E_INVALID_STATE,
 306                         "[E_INVALID_STATE] The CheckButton has no title style.\n");
 307
 308         int titleLength = title.GetLength();
 309         int checkButtonTitleMaxLength = 0;
 310         GET_FIXED_VALUE_CONFIG(CHECKBUTTON::TITLE_TEXT_MAX_LENGTH, _CONTROL_ORIENTATION_PORTRAIT, checkButtonTitleMaxLength);
 311         String tempTitle = String(title);
 312
 313         if (titleLength >= checkButtonTitleMaxLength)
 314         {
 315                 tempTitle.Remove(checkButtonTitleMaxLength - 1, titleLength - checkButtonTitleMaxLength + 1);
 316         }
 317
 318         Variant var(tempTitle);
 319         result r = GetCore().SetPropertyTitleText(var);
 320         SysTryLog(NID_UI_CTRL, r == E_SUCCESS, "[%s] Propagating.", GetErrorMessage(r));
 321
 322         return r;
 323 }
 324
 325 String
 326 _CheckButtonImpl::GetTitleText(void) const
 327 {
 328         SysTryReturn(NID_UI_CTRL, GetCore().GetShowTitle() == true, L"", E_INVALID_STATE,
 329                         "[E_INVALID_STATE] The CheckButton has no title style.\n");
 330
 331         ClearLastResult();
 332
 333         return GetCore().GetPropertyTitleText().ToString();
 334 }
 335
 336 result
 337 _CheckButtonImpl::SetTextHorizontalAlignment(HorizontalAlignment alignment)
 338 {
 339         result r = GetCore().SetTextHorizontalAlignment(alignment);
 340         SysTryLog(NID_UI_CTRL, r == E_SUCCESS, "[%s] Propagating.", GetErrorMessage(r));
 341
 342         return r;
 343 }
 344
 345 HorizontalAlignment
 346 _CheckButtonImpl::GetTextHorizontalAlignment(void) const
 347 {
 348         ClearLastResult();
 349
 350         return GetCore().GetTextHorizontalAlignment();
 351 }
 352
 353 result
 354 _CheckButtonImpl::SetTextVerticalAlignment(VerticalAlignment alignment)
 355 {
 356         result r = GetCore().SetTextVerticalAlignment(alignment);
 357         SysTryLog(NID_UI_CTRL, r == E_SUCCESS, "[%s] Propagating.", GetErrorMessage(r));
 358
 359         return r;
 360 }
 361
 362 VerticalAlignment
 363 _CheckButtonImpl::GetTextVerticalAlignment(void) const
 364 {
 365         ClearLastResult();
 366
 367         return GetCore().GetTextVerticalAlignment();
 368 }
 369
 370 result
 371 _CheckButtonImpl::SetTextColor(const Color& color)
 372 {
 373         result r =  GetCore().SetTextColor(color);
 374         SysTryLog(NID_UI_CTRL, r == E_SUCCESS, "[%s] Propagating.", GetErrorMessage(r));
 375
 376         return r;
 377 }
 378
 379 Color
 380 _CheckButtonImpl::GetTextColor(void) const
 381 {
 382         ClearLastResult();
 383
 384         return GetCore().GetTextColor();
 385 }
 386
 387 result
 388 _CheckButtonImpl::SetDisabledTextColor(const Color& color)
 389 {
 390         result r = GetCore().SetDisabledTextColor(color);
 391         SysTryLog(NID_UI_CTRL, r == E_SUCCESS, "[%s] Propagating.", GetErrorMessage(r));
 392
 393         return r;
 394 }
 395
 396 Color
 397 _CheckButtonImpl::GetDisabledTextColor(void) const
 398 {
 399         ClearLastResult();
 400
 401         return GetCore().GetDisabledTextColor();
 402 }
 403
 404 result
 405 _CheckButtonImpl::SetPressedTextColor(const Color& color)
 406 {
 407         result r = GetCore().SetPressedTextColor(color);
 408         SysTryLog(NID_UI_CTRL, r == E_SUCCESS, "[%s] Propagating.", GetErrorMessage(r));
 409
 410         return r;
 411 }
 412
 413 Color
 414 _CheckButtonImpl::GetPressedTextColor(void) const
 415 {
 416         ClearLastResult();
 417
 418         return GetCore().GetPressedTextColor();
 419 }
 420
 421 result
 422 _CheckButtonImpl::SetHighlightedTextColor(const Color& color)
 423 {
 424         result r = GetCore().SetHighlightedTextColor(color);
 425         SysTryLog(NID_UI_CTRL, r == E_SUCCESS, "[%s] Propagating.", GetErrorMessage(r));
 426
 427         return r;
 428 }
 429
 430 Color
 431 _CheckButtonImpl::GetHighlightedTextColor(void) const
 432 {
 433         ClearLastResult();
 434
 435         return GetCore().GetHighlightedTextColor();
 436 }
 437
 438 result
 439 _CheckButtonImpl::SetTitleTextColor(const Color& color)
 440 {
 441         result r = GetCore().SetTitleTextColor(color);
 442         SysTryLog(NID_UI_CTRL, r == E_SUCCESS, "[%s] Propagating.", GetErrorMessage(r));
 443
 444         return r;
 445 }
 446
 447 Color
 448 _CheckButtonImpl::GetTitleTextColor(void) const
 449 {
 450         ClearLastResult();
 451
 452         return GetCore().GetTitleTextColor();
 453 }
 454
 455 result
 456 _CheckButtonImpl::SetDisabledTitleTextColor(const Color& color)
 457 {
 458         result r = GetCore().SetDisabledTitleTextColor(color);
 459         SysTryLog(NID_UI_CTRL, r == E_SUCCESS, "[%s] Propagating.", GetErrorMessage(r));
 460
 461         return r;
 462 }
 463
 464 Color
 465 _CheckButtonImpl::GetDisabledTitleTextColor(void) const
 466 {
 467         ClearLastResult();
 468
 469         return GetCore().GetDisabledTitleTextColor();
 470 }
 471
 472 result
 473 _CheckButtonImpl::SetPressedTitleTextColor(const Color& color)
 474 {
 475         result r = GetCore().SetPressedTitleTextColor(color);
 476         SysTryLog(NID_UI_CTRL, r == E_SUCCESS, "[%s] Propagating.", GetErrorMessage(r));
 477
 478         return r;
 479 }
 480
 481 Color
 482 _CheckButtonImpl::GetPressedTitleTextColor(void) const
 483 {
 484         ClearLastResult();
 485
 486         return GetCore().GetPressedTitleTextColor();
 487 }
 488
 489 result
 490 _CheckButtonImpl::SetHighlightedTitleTextColor(const Color& color)
 491 {
 492         result r = GetCore().SetHighlightedTitleTextColor(color);
 493         SysTryLog(NID_UI_CTRL, r == E_SUCCESS, "[%s] Propagating.", GetErrorMessage(r));
 494
 495         return r;
 496 }
 497
 498 Color
 499 _CheckButtonImpl::GetHighlightedTitleTextColor(void) const
 500 {
 501         ClearLastResult();
 502
 503         return GetCore().GetHighlightedTitleTextColor();
 504 }
 505
 506 result
 507 _CheckButtonImpl::SetColor(CheckButtonStatus status, const Color& color)
 508 {
 509         SysTryReturn(NID_UI_CTRL, GetCore().GetBackgroundStyle() != BACKGROUND_STYLE_NONE, E_INVALID_OPERATION, E_INVALID_OPERATION,
 510                                 "[E_INVALID_OPERATION] Unable to set color.\n");
 511
 512         _CheckButtonStatus coreStatus = ConvertStatus(status);
 513
 514         result r = GetCore().SetColor(coreStatus, color);
 515         SysTryLog(NID_UI_CTRL, r == E_SUCCESS, "[%s] Propagating.", GetErrorMessage(r));
 516
 517         return r;
 518 }
 519
 520 Color
 521 _CheckButtonImpl::GetColor(CheckButtonStatus status) const
 522 {
 523         SysTryReturn(NID_UI_CTRL, GetCore().GetBackgroundStyle() != BACKGROUND_STYLE_NONE,
 524                                 _CheckButtonImpl::GetColorOnError(), E_INVALID_OPERATION, "[E_INVALID_OPERATION] Unable to get color.\n");
 525
 526         _CheckButtonStatus coreStatus = ConvertStatus(status);
 527
 528         ClearLastResult();
 529
 530         return GetCore().GetColor(coreStatus);
 531 }
 532
 533 result
 534 _CheckButtonImpl::SetStyle(const CheckButtonStyle& checkButtonStyle, const BackgroundStyle& backgroundStyle, bool showTitle, const GroupStyle& groupStyle)
 535 {
 536         result r = GetCore().SetCheckButtonStyle(checkButtonStyle);
 537         SysTryLog(NID_UI_CTRL, r == E_SUCCESS, "[%s] Propagating.", GetErrorMessage(r));
 538
 539         r = GetCore().SetBackgroundStyle(backgroundStyle);
 540         SysTryLog(NID_UI_CTRL, r == E_SUCCESS, "[%s] Propagating.", GetErrorMessage(r));
 541
 542         r = GetCore().SetShowTitle(showTitle);
 543         SysTryLog(NID_UI_CTRL, r == E_SUCCESS, "[%s] Propagating.", GetErrorMessage(r));
 544
 545         r = GetCore().SetGroupStyle(groupStyle);
 546         SysTryLog(NID_UI_CTRL, r == E_SUCCESS, "[%s] Propagating.", GetErrorMessage(r));
 547
 548         return r;
 549 }
 550
 551 bool
 552 _CheckButtonImpl::IsLayoutable(void) const
 553 {
 554         return true;
 555 }
 556
 557 void
 558 _CheckButtonImpl::OnActionPerformed(const _Control& source, int actionId)
 559 {
 560         if (__pPublicActionEvent != null)
 561         {
 562                 __pPublicActionEvent->Fire(*_PublicActionEvent::CreateActionEventArgN(actionId));
 563         }
 564
 565         return;
 566 }
 567
 568 _CheckButtonStatus
 569 _CheckButtonImpl::ConvertStatus(CheckButtonStatus status) const
 570 {
 571         _CheckButtonStatus coreStatus = _CHECK_BUTTON_STATUS_HIGHLIGHTED;
 572         switch (status)
 573         {
 574         case CHECK_BUTTON_STATUS_NORMAL:
 575                 coreStatus = _CHECK_BUTTON_STATUS_NORMAL;
 576                 break;
 577         case CHECK_BUTTON_STATUS_DISABLED:
 578                 coreStatus = _CHECK_BUTTON_STATUS_DISABLED;
 579                 break;
 580         case CHECK_BUTTON_STATUS_PRESSED:
 581                 coreStatus = _CHECK_BUTTON_STATUS_PRESSED;
 582                 break;
 583         default:
 584                 coreStatus = _CHECK_BUTTON_STATUS_HIGHLIGHTED;
 585         }
 586
 587         return coreStatus;
 588 }
 589
 590 class _CheckButtonMaker
 591         : public _UiBuilderControlMaker
 592 {
 593 public:
 594         _CheckButtonMaker(_UiBuilder* uibuilder)
 595                 : _UiBuilderControlMaker(uibuilder){};
 596         virtual ~_CheckButtonMaker(){};
 597         static _UiBuilderControlMaker* GetInstance(_UiBuilder* uibuilder)
 598         {
 599                 _CheckButtonMaker* pCheckButtonMaker = new (std::nothrow) _CheckButtonMaker(uibuilder);
 600                 return static_cast<_UiBuilderControlMaker*>(pCheckButtonMaker);
 601         };
 602 protected:
 603         virtual Control* Make(_UiBuilderControl* pControl)
 604         {
 605                 bool isText = false;
 606                 bool isRadioStyle = false;
 607                 result r = E_SYSTEM;
 608                 _UiBuilderControlLayout* pControlProperty = null;
 609                 CheckButton* pCheck = null;
 610                 BackgroundStyle backgroundStyle = BACKGROUND_STYLE_DEFAULT;
 611                 FloatRectangle rect;
 612
 613                 Tizen::Base::String elementString;
 614                 String checkText;
 615                 HorizontalAlignment horizontalAlignment;
 616                 VerticalAlignment verticalAlignment;
 617                 GroupStyle groupStyle = GROUP_STYLE_NONE;
 618                 bool showTitle = false;
 619                 Color color;
 620                 int opacity = 0;
 621
 622                 GetProperty(pControl, &pControlProperty);
 623                 if (pControlProperty == null)
 624                 {
 625                         return null;
 626                 }
 627
 628                 pCheck = new (std::nothrow) CheckButton();
 629                 rect = pControlProperty->GetRectF();
 630
 631                 Tizen::Base::String styleString;
 632                 styleString = pControlProperty->GetStyle();
 633
 634                 //Construct
 635                 if (pControl->GetElement("text", elementString))
 636                 {
 637                         isText = true;
 638                         checkText = elementString;
 639                 }
 640
 641                 if (pControl->GetElement("backgroundStyle", elementString) || pControl->GetElement("BackgroundStyle", elementString))
 642                 {
 643                         if (elementString.Equals(L"BACKGROUND_STYLE_NONE", false))
 644                         {
 645                                 backgroundStyle = BACKGROUND_STYLE_NONE;
 646                         }
 647                 }
 648
 649                 if (pControl->GetElement("showtitleText", elementString)  || pControl->GetElement("bShowtitleText", elementString))
 650                 {
 651                         if (elementString.Equals(L"true", false))
 652                         {
 653                                 showTitle = true;
 654                         }
 655                 }
 656
 657                 if (pControl->GetElement("groupStyle", elementString) || pControl->GetElement("GroupStyle", elementString))
 658                 {
 659                         if (elementString.Equals(L"GROUP_STYLE_NONE", false))
 660                         {
 661                                 groupStyle = GROUP_STYLE_NONE;
 662                         }
 663
 664                         if (elementString.Equals(L"GROUP_STYLE_SINGLE", false))
 665                         {
 666                                 groupStyle = GROUP_STYLE_SINGLE;
 667                         }
 668
 669                         if (elementString.Equals(L"GROUP_STYLE_TOP", false))
 670                         {
 671                                 groupStyle = GROUP_STYLE_TOP;
 672                         }
 673
 674                         if (elementString.Equals(L"GROUP_STYLE_MIDDLE", false))
 675                         {
 676                                 groupStyle = GROUP_STYLE_MIDDLE;
 677                         }
 678
 679                         if (elementString.Equals(L"GROUP_STYLE_BOTTOM", false))
 680                         {
 681                                 groupStyle = GROUP_STYLE_BOTTOM;
 682                         }
 683                 }
 684
 685                 if (styleString.Equals(L"CHECK_BUTTON_STYLE_ONOFF", false))
 686                 {
 687                         r = pCheck->Construct(rect, CHECK_BUTTON_STYLE_ONOFF, backgroundStyle, showTitle, checkText, groupStyle);
 688                 }
 689                 else if (styleString.Equals(L"CHECK_BUTTON_STYLE_ONOFF_WITH_DIVIDER", false))
 690                 {
 691                         r = pCheck->Construct(rect, CHECK_BUTTON_STYLE_ONOFF_WITH_DIVIDER, backgroundStyle, showTitle, checkText, groupStyle);
 692                 }
 693                 else if (styleString.Equals(L"CHECK_BUTTON_STYLE_MARK_WITH_DIVIDER", false))
 694                 {
 695                         r = pCheck->Construct(rect, CHECK_BUTTON_STYLE_MARK_WITH_DIVIDER, backgroundStyle, showTitle, checkText, groupStyle);
 696                 }
 697                 else if (styleString.Equals(L"CHECK_BUTTON_STYLE_RADIO_WITH_DIVIDER", false))
 698                 {
 699                         r = pCheck->Construct(rect, CHECK_BUTTON_STYLE_RADIO_WITH_DIVIDER, backgroundStyle, showTitle, checkText, groupStyle);
 700                         isRadioStyle = true;
 701                 }
 702                 else if (styleString.Equals(L"CHECK_BUTTON_STYLE_RADIO", false))
 703                 {
 704                         r = pCheck->Construct(rect, CHECK_BUTTON_STYLE_RADIO, backgroundStyle, showTitle, checkText, groupStyle);
 705                         isRadioStyle = true;
 706                 }
 707                 else if (styleString.Equals(L"CHECK_BUTTON_STYLE_ONOFF_SLIDING", false))
 708                 {
 709                         r = pCheck->Construct(rect, CHECK_BUTTON_STYLE_ONOFF_SLIDING, backgroundStyle, showTitle, checkText, groupStyle);
 710                 }
 711                 else if (styleString.Equals(L"CHECK_BUTTON_STYLE_MARK_WITH_DETAILED_BUTTON", false))
 712                 {
 713                         r = pCheck->Construct(rect, CHECK_BUTTON_STYLE_MARK_WITH_DETAILED_BUTTON, backgroundStyle, showTitle, checkText, groupStyle);
 714                 }
 715                 else if (styleString.Equals(L"CHECK_BUTTON_STYLE_RADIO_WITH_DETAILED_BUTTON", false))
 716                 {
 717                         r = pCheck->Construct(rect, CHECK_BUTTON_STYLE_RADIO_WITH_DETAILED_BUTTON, backgroundStyle, showTitle, checkText, groupStyle);
 718                         isRadioStyle = true;
 719                 }
 720                 else if (styleString.Equals(L"CHECK_BUTTON_STYLE_ONOFF_SLIDING_WITH_DIVIDER", false))
 721                 {
 722                         r = pCheck->Construct(rect, CHECK_BUTTON_STYLE_ONOFF_SLIDING_WITH_DIVIDER, backgroundStyle, showTitle, checkText, groupStyle);
 723                 }
 724                 else
 725                 {
 726                         r = pCheck->Construct(rect, CHECK_BUTTON_STYLE_MARK, backgroundStyle, showTitle, checkText, groupStyle);
 727                 }
 728
 729                 if (r != E_SUCCESS)
 730                 {
 731                         delete pCheck;
 732                         return null;
 733                 }
 734
 735                 if (showTitle)
 736                 {
 737                         if (pControl->GetElement("titleText", elementString))
 738                         {
 739                                 pCheck->SetTitleText(elementString);
 740                         }
 741
 742                         if (pControl->GetElement("colorOfTitleText", elementString))
 743                         {
 744                                 ConvertStringToColor(elementString, color);
 745                                 pCheck->SetTitleTextColor(color);
 746                         }
 747
 748                         if (pControl->GetElement("pressedTitleTextColor", elementString))
 749                         {
 750                                 ConvertStringToColor(elementString, color);
 751                                 pCheck->SetPressedTitleTextColor(color);
 752                         }
 753
 754                         if (pControl->GetElement("disabledTitleTextColor", elementString))
 755                         {
 756                                 ConvertStringToColor(elementString, color);
 757                                 pCheck->SetDisabledTitleTextColor(color);
 758                         }
 759
 760                         if (pControl->GetElement("highlightedTitleTextColor", elementString))
 761                         {
 762                                 ConvertStringToColor(elementString, color);
 763                                 pCheck->SetHighlightedTitleTextColor(color);
 764                         }
 765                 }
 766
 767                 if (isText)
 768                 {
 769                         if (pControl->GetElement("colorOfText", elementString))
 770                         {
 771                                 ConvertStringToColor(elementString, color);
 772                                 pCheck->SetTextColor(color);
 773                         }
 774
 775                         if (pControl->GetElement("pressedTextColor", elementString))
 776                         {
 777                                 ConvertStringToColor(elementString, color);
 778                                 pCheck->SetPressedTextColor(color);
 779                         }
 780
 781                         if (pControl->GetElement("disabledTextColor", elementString))
 782                         {
 783                                 ConvertStringToColor(elementString, color);
 784                                 pCheck->SetDisabledTextColor(color);
 785                         }
 786
 787                         if (pControl->GetElement("highlightedTextColor", elementString))
 788                         {
 789                                 ConvertStringToColor(elementString, color);
 790                                 pCheck->SetHighlightedTextColor(color);
 791                         }
 792                 }
 793
 794                 if (isRadioStyle && pControl->GetElement("GroupID", elementString))
 795                 {
 796                         RadioGroup* pGroup = (RadioGroup*) ((GetContainer())->GetControl(elementString, true));
 797
 798                         if (pGroup == null)
 799                         {
 800                                 pGroup = new (std::nothrow) RadioGroup();
 801                                 r = pGroup->Construct();
 802
 803                                 if (r != E_SUCCESS)
 804                                 {
 805                                         //      SysLogExceptionxception( "[E_SYSTEM] UiBuilder::__MakeCheck: Failed to create Group(%s)",buffer);
 806                                         delete pCheck;
 807                                         delete pGroup;
 808                                         return null;
 809                                 }
 810                                 pGroup->SetName(elementString);
 811                                 GetContainer()->AddControl(*pGroup);
 812
 813                                 r = pGroup->Add(*pCheck);
 814                         }
 815                         else
 816                         {
 817                                 r = pGroup->Add(*pCheck);
 818                         }
 819                 }
 820
 821                 if (pControl->GetElement("horizontalAlign", elementString) || pControl->GetElement("hAlign", elementString))
 822                 {
 823                         if (ConvertHAlignToHorizontalAlignment(elementString, horizontalAlignment))
 824                         {
 825                                 pCheck->SetTextHorizontalAlignment(horizontalAlignment);
 826                         }
 827                 }
 828
 829                 if (pControl->GetElement("verticalAlign", elementString) || pControl->GetElement("vAlign", elementString))
 830                 {
 831                         if (ConvertVAlignToVerticalAlignment(elementString, verticalAlignment))
 832                         {
 833                                 pCheck->SetTextVerticalAlignment(verticalAlignment);
 834                         }
 835                 }
 836
 837                 if (pControl->GetElement("normalColorOpacity", elementString))
 838                 {
 839                         Base::Integer::Parse(elementString, opacity);
 840                 }
 841
 842                 if (pControl->GetElement("normalColor", elementString))
 843                 {
 844                         ConvertStringToColor32(elementString, opacity, color);
 845                         pCheck->SetColor(CHECK_BUTTON_STATUS_NORMAL, color);
 846                 }
 847
 848                 if (pControl->GetElement("pressedColorOpacity", elementString))
 849                 {
 850                         Base::Integer::Parse(elementString, opacity);
 851                 }
 852
 853                 if (pControl->GetElement("pressedColor", elementString))
 854                 {
 855                         ConvertStringToColor32(elementString, opacity, color);
 856                         pCheck->SetColor(CHECK_BUTTON_STATUS_PRESSED, color);
 857                 }
 858
 859                 if (pControl->GetElement("disabledColorOpacity", elementString))
 860                 {
 861                         Base::Integer::Parse(elementString, opacity);
 862                 }
 863
 864                 if (pControl->GetElement("disabledColor", elementString))
 865                 {
 866                         ConvertStringToColor32(elementString, opacity, color);
 867                         pCheck->SetColor(CHECK_BUTTON_STATUS_DISABLED, color);
 868                 }
 869
 870                 if (pControl->GetElement("highlightedColorOpacity", elementString))
 871                 {
 872                         Base::Integer::Parse(elementString, opacity);
 873                 }
 874
 875                 if (pControl->GetElement("highlightedColor", elementString))
 876                 {
 877                         ConvertStringToColor32(elementString, opacity, color);
 878                         pCheck->SetColor(CHECK_BUTTON_STATUS_HIGHLIGHTED, color);
 879                 }
 880                 if (pControl->GetElement(L"accessibilityHint1", elementString))
 881                 {
 882                         AccessibilityContainer* pContainer = pCheck->GetAccessibilityContainer();
 883                         if (pContainer)
 884                         {
 885                                 AccessibilityElement* pElement = pContainer->GetElement(L"CheckButtonText");
 886                                 if (pElement)
 887                                 {
 888                                         pElement->SetHint(elementString);
 889                                 }
 890                         }
 891                 }
 892                 if (pControl->GetElement(L"accessibilityHint2", elementString))
 893                 {
 894                         AccessibilityContainer* pContainer = pCheck->GetAccessibilityContainer();
 895                         if (pContainer)
 896                         {
 897                                 AccessibilityElement* pElement = pContainer->GetElement(L"MoreButtonText");
 898                                 if (pElement)
 899                                 {
 900                                         pElement->SetHint(elementString);
 901                                 }
 902                         }
 903                 }
 904 #if 0
 905         //-------safety for Minimum size-------------------
 906         tempRect = (pControl->GetAttribute(UIBUILDER_ATTRIBUTE_PORTRAIT))->GetRectF();
 907         if ((pStyleString != null) &&
 908             ((strcmp((const char*)pStyleString,"CHECK_BUTTON_STYLE_ONOFF_WITH_DIVIDER") == 0)
 909             || (strcmp((const char*)pStyleString,"CHECK_BUTTON_STYLE_ONOFF_WITH_DIVIDER") == 0)
 910             || (strcmp((const char*)pStyleString,"CHECK_BUTTON_STYLE_RADIO_WITH_DIVIDER") == 0)))
 911         {
 912             if (tempRect.w < __BaseProperty(PROPERTY_CHECKBUTTON_MIN_WIDTH_WITH_DIVIDER))
 913             {
 914                 tempRect.w = __BaseProperty(PROPERTY_CHECKBUTTON_MIN_WIDTH_WITH_DIVIDER);
 915             }
 916         }
 917         else if ((pStyleString != null)  &&
 918             ((strcmp((const char*)pStyleString,"CHECK_BUTTON_STYLE_MARK_WITH_DETAILED_BUTTON") == 0)
 919             || (strcmp((const char*)pStyleString,"CHECK_BUTTON_STYLE_RADIO_WITH_DETAILED_BUTTON") == 0)))
 920         {
 921             if (tempRect.w < __BaseProperty(PROPERTY_CHECKBUTTON_MIN_WIDTH_WITH_DETAILED))
 922             {
 923                 tempRect.w = __BaseProperty(PROPERTY_CHECKBUTTON_MIN_WIDTH_WITH_DETAILED);
 924             }
 925         }
 926         else if ((pStyleString != null) &&
 927             (strcmp((const char*)pStyleString,"CHECK_BUTTON_STYLE_ONOFF_SLIDING") == 0))
 928         {
 929             if (tempRect.w < __BaseProperty(PROPERTY_CHECKBUTTON_MIN_WIDTH_ONOFF_SLIDING))
 930             {
 931                 tempRect.w = __BaseProperty(PROPERTY_CHECKBUTTON_MIN_WIDTH_ONOFF_SLIDING);
 932             }
 933         }
 934         else
 935         {
 936             if (showTitle)
 937             {
 938                 if (tempRect.w < __BaseProperty(PROPERTY_CHECKBUTTON_MIN_WIDTH_WITH_TITLE))
 939                 {
 940                     tempRect.w = __BaseProperty(PROPERTY_CHECKBUTTON_MIN_WIDTH_WITH_TITLE);
 941                 }
 942             }
 943             else
 944             {
 945                 if (tempRect.w < __BaseProperty(PROPERTY_CHECKBUTTON_MIN_WIDTH))
 946                 {
 947                     tempRect.w = __BaseProperty(PROPERTY_CHECKBUTTON_MIN_WIDTH);
 948                 }
 949             }
 950         }
 951
 952         if (showTitle)
 953         {
 954             if (tempRect.h < __BaseProperty(PROPERTY_CHECKBUTTON_MIN_HEIGHT_WITH_TITLE))
 955             {
 956                 tempRect.h = __BaseProperty(PROPERTY_CHECKBUTTON_MIN_HEIGHT_WITH_TITLE);
 957             }
 958         }
 959         else // no title
 960         {
 961             if (tempRect.h < __BaseProperty(PROPERTY_CHECKBUTTON_MIN_HEIGHT))
 962             {
 963                 tempRect.h = __BaseProperty(PROPERTY_CHECKBUTTON_MIN_HEIGHT);
 964             }
 965         }
 966
 967         (pControl->GetAttribute(UIBUILDER_ATTRIBUTE_PORTRAIT))->SetRect(tempRect.x,tempRect.y,tempRect.w,tempRect.h);
 968
 969         tempRect = (pControl->GetAttribute(UIBUILDER_ATTRIBUTE_LANDSCAPE))->GetRectF();
 970         if ((pStyleString != null) &&
 971                 ((strcmp((const char*)pStyleString,"CHECK_BUTTON_STYLE_ONOFF_WITH_DIVIDER") == 0)
 972                         || (strcmp((const char*)pStyleString,"CHECK_BUTTON_STYLE_ONOFF_WITH_DIVIDER") == 0)
 973                         || (strcmp((const char*)pStyleString,"CHECK_BUTTON_STYLE_RADIO_WITH_DIVIDER") == 0)))
 974         {
 975             if (tempRect.w < __BaseProperty(PROPERTY_CHECKBUTTON_MIN_WIDTH_WITH_DIVIDER))
 976             {
 977                 tempRect.w = __BaseProperty(PROPERTY_CHECKBUTTON_MIN_WIDTH_WITH_DIVIDER);
 978             }
 979         }
 980         else if ((pStyleString != null)  &&
 981                 ((strcmp((const char*)pStyleString,"CHECK_BUTTON_STYLE_MARK_WITH_DETAILED_BUTTON") == 0)
 982                         || (strcmp((const char*)pStyleString,"CHECK_BUTTON_STYLE_RADIO_WITH_DETAILED_BUTTON") == 0)))
 983         {
 984             if (tempRect.w < __BaseProperty(PROPERTY_CHECKBUTTON_MIN_WIDTH_WITH_DETAILED))
 985             {
 986                 tempRect.w = __BaseProperty(PROPERTY_CHECKBUTTON_MIN_WIDTH_WITH_DETAILED);
 987             }
 988         }
 989         else if ((pStyleString != null) &&
 990                 (strcmp((const char*)pStyleString,"CHECK_BUTTON_STYLE_ONOFF_SLIDING") == 0))
 991         {
 992             if (tempRect.w < __BaseProperty(PROPERTY_CHECKBUTTON_MIN_WIDTH_ONOFF_SLIDING))
 993             {
 994                 tempRect.w = __BaseProperty(PROPERTY_CHECKBUTTON_MIN_WIDTH_ONOFF_SLIDING);
 995             }
 996         }
 997         else
 998         {
 999             if (showTitle)
1000             {
1001                 if (tempRect.w < __BaseProperty(PROPERTY_CHECKBUTTON_MIN_WIDTH_WITH_TITLE))
1002                 {
1003                     tempRect.w = __BaseProperty(PROPERTY_CHECKBUTTON_MIN_WIDTH_WITH_TITLE);
1004                 }
1005             }
1006             else
1007             {
1008                 if (tempRect.w < __BaseProperty(PROPERTY_CHECKBUTTON_MIN_WIDTH))
1009                 {
1010                     tempRect.w = __BaseProperty(PROPERTY_CHECKBUTTON_MIN_WIDTH);
1011                 }
1012             }
1013         }
1014
1015         if (showTitle)
1016         {
1017             if (tempRect.h < __BaseProperty(PROPERTY_CHECKBUTTON_MIN_HEIGHT_WITH_TITLE))
1018             {
1019                 tempRect.h = __BaseProperty(PROPERTY_CHECKBUTTON_MIN_HEIGHT_WITH_TITLE);
1020             }
1021         }
1022         else // no title
1023         {
1024             if (tempRect.h < __BaseProperty(PROPERTY_CHECKBUTTON_MIN_HEIGHT))
1025             {
1026                 tempRect.h = __BaseProperty(PROPERTY_CHECKBUTTON_MIN_HEIGHT);
1027             }
1028         }
1029
1030         (pControl->GetAttribute(UIBUILDER_ATTRIBUTE_LANDSCAPE))->SetRect(tempRect.x,tempRect.y,tempRect.w,tempRect.h);
1031
1032         //--------end safety code------------------------
1033
1034 #endif
1035                 return pCheck;
1036         }
1037
1038 private:
1039 }; // _CheckButtonMaker
1040
1041 _CheckButtonRegister::_CheckButtonRegister()
1042 {
1043         _UiBuilderControlTableManager* pUiBuilderControlTableManager = _UiBuilderControlTableManager::GetInstance();
1044         pUiBuilderControlTableManager->RegisterControl(L"CheckButton", _CheckButtonMaker::GetInstance);
1045 }
1046 _CheckButtonRegister::~_CheckButtonRegister()
1047 {
1048         _UiBuilderControlTableManager* pUiBuilderControlTableManager = _UiBuilderControlTableManager::GetInstance();
1049         pUiBuilderControlTableManager->UnregisterControl(L"CheckButton");
1050 }
1051 static _CheckButtonRegister CheckButtonRegisterToUiBuilder;
1052 }}} // Tizen::Ui::Controls