src/ui/controls/FUiCtrl_CustomListElements.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 /**
  19 * @file         FUiCtrl_CustomListElements.cpp
  20 * @brief        This is the header file for the classes related to implementing elements in CustomListItem.
  21 */
  22
  23 #include <FBaseSysLog.h>
  24 #include <FGrp_BitmapImpl.h>
  25 #include <FGrp_TextTextObject.h>
  26 #include <FGrp_TextTextSimple.h>
  27 #include "FUiCtrl_CustomListItemImpl.h"
  28 #include "FUiCtrl_CustomListItemFormatImpl.h"
  29 #include "FUiCtrl_PanelImpl.h"
  30 #include "FUi_ResourceManager.h"
  31 #include "FUi_CoordinateSystemUtils.h"
  32
  33 using namespace Tizen::Base;
  34 using namespace Tizen::Base::Collection;
  35 using namespace Tizen::Graphics;
  36 using namespace Tizen::Graphics::_Text;
  37
  38 namespace Tizen { namespace Ui { namespace Controls
  39 {
  40
  41 _ElementBaseModel::_ElementBaseModel(void)
  42         : _elementId(-1)
  43         , _itemStatus(CUSTOM_LIST_ITEM_STATUS_NORMAL)
  44 {
  45 }
  46
  47 _ElementBaseModel::~_ElementBaseModel(void)
  48 {
  49 }
  50
  51 int
  52 _ElementBaseModel::GetElementId(void)
  53 {
  54         return _elementId;
  55 }
  56
  57 CustomListItemStatus
  58 _ElementBaseModel::GetItemStatus(void)
  59 {
  60         return _itemStatus;
  61 }
  62
  63 void
  64 _ElementBaseModel::HandleElementEvent(CustomListItemStatus itemStatus)
  65 {
  66         _itemStatus = itemStatus;
  67 }
  68
  69 _TextElementModel::_TextElementModel(const String& text)
  70         : __text(text)
  71         , __textSize(0)
  72         , __slidingEnabled(false)
  73 {
  74 }
  75
  76 _TextElementModel::~_TextElementModel(void)
  77 {
  78 }
  79
  80 void
  81 _TextElementModel::SetTextSliding(bool enable)
  82 {
  83         __slidingEnabled = enable;
  84 }
  85
  86 bool
  87 _TextElementModel::GetTextSliding(void)
  88 {
  89         return __slidingEnabled;
  90 }
  91
  92 void
  93 _TextElementModel::GetData(String& text, Color& textColor, int& textSize) const
  94 {
  95         text = __text;
  96         textColor = __textColor[_itemStatus];
  97         textSize = __textSize;
  98
  99         return;
 100 }
 101
 102 int
 103 _TextElementModel::GetTextSize(void) const
 104 {
 105         return __textSize;
 106 }
 107
 108 result
 109 _TextElementModel::CreateElementView(_ElementViewParams& elementParams)
 110 {
 111         _TextElementModel* pTextElementModel = dynamic_cast<_TextElementModel*>(elementParams.pElementModel);
 112         SysTryReturn(NID_UI_CTRL, (pTextElementModel != null), E_SYSTEM, E_SYSTEM, "[E_SYSTEM] A system error has occurred. Failed to get element model");
 113
 114         SysTryReturn(NID_UI_CTRL, (elementParams.pElementFormatData != null), E_SYSTEM, E_SYSTEM, "[E_INVALID_ARG] Invalid argument is used. pElementFormatData must not be null");
 115         SysTryReturn(NID_UI_CTRL, (elementParams.pTableViewItemBase != null), E_SYSTEM, E_SYSTEM, "[E_INVALID_ARG] Invalid argument is used. pTableViewItemBase must not be null");
 116         SysTryReturn(NID_UI_CTRL, (elementParams.pCustomListItemImpl != null), E_SYSTEM, E_SYSTEM, "[E_INVALID_ARG] Invalid argument is used. pCustomListItemImpl must not be null");
 117
 118         pTextElementModel->__textSize = elementParams.pElementFormatData->textSize;
 119         pTextElementModel->__textColor[CUSTOM_LIST_ITEM_STATUS_NORMAL] = elementParams.pElementFormatData->normalTextColor;
 120         pTextElementModel->__textColor[CUSTOM_LIST_ITEM_STATUS_FOCUSED] = elementParams.pElementFormatData->focusedTextColor;
 121         pTextElementModel->__textColor[CUSTOM_LIST_ITEM_STATUS_SELECTED] = elementParams.pElementFormatData->highlightedTextColor;
 122
 123         TextObject* pText = new (std::nothrow) TextObject();
 124         SysTryReturn(NID_UI_CTRL, pText, E_OUT_OF_MEMORY, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] Memory allocation failed.");
 125
 126         pText->Construct();
 127
 128         TextSimple* pSimpleText = new (std::nothrow) TextSimple(const_cast <wchar_t*>(pTextElementModel->__text.GetPointer()), pTextElementModel->__text.GetLength());
 129         SysTryReturn(NID_UI_CTRL, pSimpleText, E_OUT_OF_MEMORY, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] Memory allocation failed.");
 130
 131         pText->AppendElement(*pSimpleText);
 132
 133         pText->SetAction(TEXT_OBJECT_ACTION_TYPE_NONE);
 134         pText->SetAlignment(TEXT_OBJECT_ALIGNMENT_LEFT | TEXT_OBJECT_ALIGNMENT_MIDDLE);
 135         pText->SetWrap(TEXT_OBJECT_WRAP_TYPE_NONE);
 136         pText->Compose();
 137
 138         _TextElementView* pTextElementView = new (std::nothrow) _TextElementView(pText);
 139         SysTryReturn(NID_UI_CTRL, (pTextElementView != null), E_OUT_OF_MEMORY, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] Memory allocation failed.");
 140
 141         pTextElementView->Construct(_CoordinateSystemUtils::ConvertToFloat(elementParams.pElementFormatData->rect));
 142         pTextElementView->AddTouchEventListener(*elementParams.pCustomListItemImpl);
 143         elementParams.pTableViewItemBase->AddControl(*pTextElementView);
 144         pTextElementView->SetModel(pTextElementModel);
 145         elementParams.pTableViewItemBase->SetIndividualSelectionEnabled(pTextElementView, true);
 146
 147         return E_SUCCESS;
 148 }
 149
 150 _BitmapElementModel::_BitmapElementModel(void)
 151 {
 152         for (int i = 0; i <= CUSTOM_LIST_ITEM_STATUS_FOCUSED; i++)
 153         {
 154                 __pBitmap[i] = null;
 155         }
 156 }
 157
 158 _BitmapElementModel::~_BitmapElementModel(void)
 159 {
 160         for (int i = 0; i <= CUSTOM_LIST_ITEM_STATUS_FOCUSED; i++)
 161         {
 162                 delete __pBitmap[i];
 163         }
 164 }
 165
 166 Bitmap*
 167 _BitmapElementModel::GetData(void) const
 168 {
 169         return __pBitmap[_itemStatus];
 170 }
 171
 172 result
 173 _BitmapElementModel::CreateElementView(_ElementViewParams& elementParams)
 174 {
 175         _BitmapElementModel* pBitmapElementModel = dynamic_cast<_BitmapElementModel*>(elementParams.pElementModel);
 176         SysTryReturn(NID_UI_CTRL, (pBitmapElementModel != null), E_SYSTEM, E_SYSTEM, "[E_SYSTEM] A system error has occurred. Failed to get element model");
 177
 178         SysTryReturn(NID_UI_CTRL, (elementParams.pElementFormatData != null), E_SYSTEM, E_SYSTEM, "[E_INVALID_ARG] Invalid argument is used. pElementFormatData must not be null");
 179         SysTryReturn(NID_UI_CTRL, (elementParams.pCustomListItemImpl != null), E_SYSTEM, E_SYSTEM, "[E_INVALID_ARG] Invalid argument is used. pCustomListItemImpl must not be null");
 180         SysTryReturn(NID_UI_CTRL, (elementParams.pTableViewItemBase != null), E_SYSTEM, E_SYSTEM, "[E_INVALID_ARG] Invalid argument is used. pTableViewItemBase must not be null");
 181
 182         _BitmapElementView* pBitmapElementView = new (std::nothrow) _BitmapElementView();
 183         SysTryReturn(NID_UI_CTRL, (pBitmapElementView != null), E_OUT_OF_MEMORY, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] Memory allocation failed.");
 184
 185         pBitmapElementView->Construct(_CoordinateSystemUtils::ConvertToFloat(elementParams.pElementFormatData->rect));
 186         pBitmapElementView->AddTouchEventListener(*elementParams.pCustomListItemImpl);
 187         elementParams.pTableViewItemBase->AddControl(*pBitmapElementView);
 188         pBitmapElementView->SetModel(pBitmapElementModel);
 189         elementParams.pTableViewItemBase->SetIndividualSelectionEnabled(pBitmapElementView, true);
 190
 191         return E_SUCCESS;
 192 }
 193
 194 _CustomElementModel::_CustomElementModel(void)
 195         : __pListElement(null)
 196 {
 197 }
 198
 199 _CustomElementModel::~_CustomElementModel(void)
 200 {
 201 }
 202
 203 ICustomListElement*
 204 _CustomElementModel::GetData(void) const
 205 {
 206         return __pListElement;
 207 }
 208
 209 result
 210 _CustomElementModel::CreateElementView(_ElementViewParams& elementParams)
 211 {
 212         _CustomElementModel* pCustomElementModel = dynamic_cast<_CustomElementModel*>(elementParams.pElementModel);
 213         SysTryReturn(NID_UI_CTRL, (pCustomElementModel != null), E_SYSTEM, E_SYSTEM, "[E_SYSTEM] A system error has occurred. Failed to get element model");
 214
 215         SysTryReturn(NID_UI_CTRL, (elementParams.pElementFormatData != null), E_SYSTEM, E_SYSTEM, "[E_INVALID_ARG] Invalid argument is used. pElementFormatData must not be null");
 216         SysTryReturn(NID_UI_CTRL, (elementParams.pCustomListItemImpl != null), E_SYSTEM, E_SYSTEM, "[E_INVALID_ARG] Invalid argument is used. pCustomListItemImpl must not be null");
 217         SysTryReturn(NID_UI_CTRL, (elementParams.pTableViewItemBase != null), E_SYSTEM, E_SYSTEM, "[E_INVALID_ARG] Invalid argument is used. pTableViewItemBase must not be null");
 218
 219         _CustomElementView* pCustomElementView = new (std::nothrow) _CustomElementView();
 220         SysTryReturn(NID_UI_CTRL, (pCustomElementView != null), E_OUT_OF_MEMORY, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] Memory allocation failed.");
 221
 222         pCustomElementView->Construct(_CoordinateSystemUtils::ConvertToFloat(elementParams.pElementFormatData->rect));
 223         pCustomElementView->AddTouchEventListener(*elementParams.pCustomListItemImpl);
 224         elementParams.pTableViewItemBase->AddControl(*pCustomElementView);
 225         pCustomElementView->SetModel(pCustomElementModel);
 226         elementParams.pTableViewItemBase->SetIndividualSelectionEnabled(pCustomElementView, true);
 227
 228         return E_SUCCESS;
 229 }
 230
 231 _CheckElementModel::_CheckElementModel(void)
 232         : __checkBoxStatus(CHECK_BOX_UNCHECKED)
 233         , __pCheckBitmaps(null)
 234         , __isDividerEnabled(false)
 235         , __rightDivider(false)
 236         , __leftDivider(false)
 237 {
 238 }
 239
 240 _CheckElementModel::~_CheckElementModel(void)
 241 {
 242 }
 243
 244 void
 245 _CheckElementModel::SetCheckBoxStatus(_CheckBoxBitmapType checkBoxStatus)
 246 {
 247         __checkBoxStatus = checkBoxStatus;
 248 }
 249
 250 _CheckBoxBitmapType
 251 _CheckElementModel::GetCheckBoxStatus(void)
 252 {
 253         return __checkBoxStatus;
 254 }
 255
 256 const _CheckBoxBitmapType
 257 _CheckElementModel::GetCheckBoxStatus(void) const
 258 {
 259         return __checkBoxStatus;
 260 }
 261
 262 void
 263 _CheckElementModel::GetData(Rectangle& bitmapBounds, bool& isDividerEnabled, bool& leftDivider, bool& rightDivider) const
 264 {
 265         bitmapBounds = __bitmapBounds;
 266         isDividerEnabled = __isDividerEnabled;
 267         leftDivider = __leftDivider;
 268         rightDivider = __rightDivider;
 269
 270         return;
 271 }
 272
 273 Bitmap*
 274 _CheckElementModel::GetCheckBitmap(_BitmapType checkBoxStatus) const
 275 {
 276         return __pCheckBitmaps[checkBoxStatus];
 277 }
 278
 279 result
 280 _CheckElementModel::CreateElementView(_ElementViewParams& elementParams)
 281 {
 282         SysTryReturn(NID_UI_CTRL, (elementParams.pElementFormatData != null), E_SYSTEM, E_SYSTEM, "[E_INVALID_ARG] Invalid argument is used. pElementFormatData must not be null");
 283         SysTryReturn(NID_UI_CTRL, (elementParams.pCustomListItemImpl != null), E_SYSTEM, E_SYSTEM, "[E_INVALID_ARG] Invalid argument is used. pCustomListItemImpl must not be null");
 284         SysTryReturn(NID_UI_CTRL, (elementParams.pTableViewItemBase != null), E_SYSTEM, E_SYSTEM, "[E_INVALID_ARG] Invalid argument is used. pTableViewItemBase must not be null");
 285
 286         if (elementParams.annexStyle != TABLE_VIEW_ANNEX_STYLE_NORMAL)
 287         {
 288                 Rectangle checkBoxBounds(elementParams.pElementFormatData->rect);
 289                 int dividerMargin = 0;
 290
 291                 GET_SHAPE_CONFIG(LIST::CHECK_ELEMENT_DIVIDER_MARGIN, _CONTROL_ORIENTATION_PORTRAIT, dividerMargin);
 292
 293                 if (elementParams.isDividerEnabled)
 294                 {
 295                         checkBoxBounds.width += 2 * dividerMargin;
 296                         checkBoxBounds.y = 0;
 297                         checkBoxBounds.height = elementParams.pCustomListItemImpl->height;
 298                 }
 299
 300                 _CheckElementModel* pCheckElementModel = dynamic_cast<_CheckElementModel*>(elementParams.pElementModel);
 301                 SysTryReturn(NID_UI_CTRL, (pCheckElementModel != null), E_SYSTEM, E_SYSTEM, "[E_SYSTEM] A system error has occurred. Failed to get element model");
 302
 303                 pCheckElementModel->__pCheckBitmaps = elementParams.pCheckBitmaps;
 304                 pCheckElementModel->__isDividerEnabled = elementParams.isDividerEnabled;
 305
 306                 pCheckElementModel->__bitmapBounds.width = elementParams.pElementFormatData->rect.width;
 307                 pCheckElementModel->__bitmapBounds.height = elementParams.pElementFormatData->rect.height;
 308
 309                 if (elementParams.isDividerEnabled)
 310                 {
 311                         pCheckElementModel->__bitmapBounds.x = ((checkBoxBounds.x + dividerMargin) > elementParams.pElementFormatData->rect.x) ? (dividerMargin) : (0);
 312                         pCheckElementModel->__bitmapBounds.y = elementParams.pElementFormatData->rect.y;
 313
 314                         _CustomListItemImpl::SetDividerRequired(*elementParams.pElementFormat, elementParams.pElementFormatData->rect, pCheckElementModel->__leftDivider, pCheckElementModel->__rightDivider);
 315                 }
 316                 else
 317                 {
 318                         pCheckElementModel->__bitmapBounds.x = 0;
 319                         pCheckElementModel->__bitmapBounds.y = 0;
 320                 }
 321
 322                 _CheckElementView* pCheckElementView = new (std::nothrow) _CheckElementView();
 323                 SysTryReturn(NID_UI_CTRL, (pCheckElementView != null), E_OUT_OF_MEMORY, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] Memory allocation failed.");
 324
 325                 pCheckElementView->Construct(_CoordinateSystemUtils::ConvertToFloat(elementParams.pElementFormatData->rect));
 326                 pCheckElementView->AddTouchEventListener(*elementParams.pCustomListItemImpl);
 327                 elementParams.pTableViewItemBase->AddControl(*pCheckElementView);
 328                 pCheckElementView->SetModel(pCheckElementModel);
 329                 elementParams.pTableViewItemBase->SetIndividualSelectionEnabled(pCheckElementView, true);
 330         }
 331
 332         return E_SUCCESS;
 333 }
 334
 335 _ElementBaseView::_ElementBaseView(void)
 336         : __pElementBaseModel(null)
 337 {
 338 }
 339
 340 _ElementBaseView::~_ElementBaseView(void)
 341 {
 342 }
 343
 344 int
 345 _ElementBaseView::GetElementId(void) const
 346 {
 347         SysTryReturn(NID_UI_CTRL, (__pElementBaseModel != null), -1, E_SYSTEM, "Element model not set");
 348
 349         return __pElementBaseModel->GetElementId();
 350 }
 351
 352 _TextElementView::_TextElementView(TextObject* pText)
 353         : __pText(pText)
 354 {
 355 }
 356
 357 _TextElementView::~_TextElementView(void)
 358 {
 359         __pText->RemoveAll();
 360
 361         delete __pText;
 362         __pText = null;
 363
 364 }
 365
 366 result
 367 _TextElementView::OnDraw(void)
 368 {
 369         result r = E_SUCCESS;
 370
 371         _TextElementModel* __pTextElementModel = dynamic_cast<_TextElementModel*>(__pElementBaseModel);
 372         SysTryReturn(NID_UI_CTRL, (__pTextElementModel), E_SYSTEM, E_SYSTEM, "[E_SYSTEM] A system error occured. Failed to get _TextElementModel.");
 373
 374         Canvas* pCanvas = GetCanvasN();
 375         r  = GetLastResult();
 376         SysTryReturn(NID_UI_CTRL, (pCanvas), r, r, "[%s] Propagating.", GetErrorMessage(r));
 377
 378         String text;
 379         Color textColor;
 380         int textSize = 0;
 381
 382         __pTextElementModel->GetData(text, textColor, textSize);
 383
 384         if (IsEnabled() == false)
 385         {
 386                 GET_COLOR_CONFIG(LIST::ELEMENT_TEXT_DISABLED, textColor);
 387         }
 388
 389         pCanvas->SetBackgroundColor(Color(0, 0, 0, 0));
 390         pCanvas->Clear();
 391
 392         if (__pText)
 393         {
 394                 FloatRectangle bounds = GetBoundsF();
 395                 bounds.x = 0.0f;
 396                 bounds.y = 0.0f;
 397
 398                 _ListBaseImpl* pListBaseImpl = _CustomListItemImpl::GetListBaseImplFromElement(*this);
 399                 SysTryCatch(NID_UI_CTRL, (pListBaseImpl != null), , E_SYSTEM, "[E_SYSTEM] A system error has occurred. Failed to get _ListBaseImpl instance.");
 400
 401                 Font font;
 402                 r = font.Construct(pListBaseImpl->GetCore().GetFont(), FONT_STYLE_PLAIN, textSize);
 403                 if (r != E_SUCCESS)
 404                 {
 405                         font.Construct(FONT_STYLE_PLAIN, textSize);
 406                 }
 407
 408                 __pText->SetFont(&font, 0, __pText->GetTextLength());
 409                 __pText->SetForegroundColor(textColor, 0, __pText->GetTextLength());
 410                 __pText->SetBounds(bounds);
 411                 __pText->Draw(*_CanvasImpl::GetInstance(*pCanvas));
 412         }
 413
 414         delete pCanvas;
 415         return E_SUCCESS;
 416
 417 CATCH:
 418         delete pCanvas;
 419         return E_SYSTEM;
 420 }
 421
 422 void
 423 _TextElementView::SetModel(_TextElementModel* pTextElementModel)
 424 {
 425         __pElementBaseModel = pTextElementModel;
 426 }
 427
 428 void
 429 _TextElementView::StartTextSlide(void)
 430 {
 431         if (IsEnabled() == false)
 432         {
 433                 return;
 434         }
 435
 436         Canvas* pCanvas = GetCanvasN();
 437         SysTryReturnVoidResult(NID_UI_CTRL, (pCanvas != null), GetLastResult(), "[%s] Propagating.", GetErrorMessage(GetLastResult()));
 438
 439         pCanvas->SetBackgroundColor(Color(0, 0, 0, 0));
 440         pCanvas->Clear();
 441
 442         if (__pText->GetTextLengthAt(0) < __pText->GetTextLength())
 443         {
 444                 __pText->SetAction(TEXT_OBJECT_ACTION_TYPE_SLIDE_LEFT);
 445                 __pText->Compose();
 446                 __pText->DrawWithOffset(*_CanvasImpl::GetInstance(*pCanvas));
 447         }
 448         else
 449         {
 450                 __pText->Draw(*_CanvasImpl::GetInstance(*pCanvas));
 451         }
 452
 453         delete pCanvas;
 454 }
 455
 456 void
 457 _TextElementView::StopTextSlide(void)
 458 {
 459         if (IsEnabled() == false)
 460         {
 461                 return;
 462         }
 463
 464         Canvas* pCanvas = GetCanvasN();
 465         SysTryReturnVoidResult(NID_UI_CTRL, (pCanvas != null), GetLastResult(), "[%s] Propagating.", GetErrorMessage(GetLastResult()));
 466
 467         pCanvas->SetBackgroundColor(Color(0, 0, 0, 0));
 468         pCanvas->Clear();
 469
 470         __pText->SetAction(TEXT_OBJECT_ACTION_TYPE_NONE);
 471         __pText->SetAlignment(TEXT_OBJECT_ALIGNMENT_LEFT | TEXT_OBJECT_ALIGNMENT_MIDDLE);
 472         __pText->SetWrap(TEXT_OBJECT_WRAP_TYPE_NONE);
 473         __pText->Compose();
 474         __pText->DrawWithOffset(*_CanvasImpl::GetInstance(*pCanvas));
 475
 476         delete pCanvas;
 477 }
 478
 479 _BitmapElementView::_BitmapElementView(void)
 480 {
 481 }
 482
 483 _BitmapElementView::~_BitmapElementView(void)
 484 {
 485 }
 486
 487 result
 488 _BitmapElementView::OnDraw(void)
 489 {
 490         result r = E_SUCCESS;
 491         Canvas* pCanvas = GetCanvasN();
 492
 493         r  = GetLastResult();
 494         SysTryReturn(NID_UI_CTRL, (pCanvas), r, r, "[%s] Propagating.", GetErrorMessage(r));
 495
 496         _BitmapElementModel* __pBitmapElementModel = dynamic_cast<_BitmapElementModel*>(__pElementBaseModel);
 497         SysTryReturn(NID_UI_CTRL, (__pBitmapElementModel), E_SYSTEM, E_SYSTEM, "[E_SYSTEM] A system error has occured. Failed to get _BitmapElementModel.");
 498
 499         Bitmap *pBitmap = __pBitmapElementModel->GetData();
 500
 501         if (pBitmap)
 502         {
 503                 pCanvas->SetBackgroundColor(Color(0, 0, 0, 0));
 504                 pCanvas->Clear();
 505
 506                 if (_BitmapImpl::CheckNinePatchedBitmapStrictly(*pBitmap))
 507                 {
 508                         pCanvas->DrawNinePatchedBitmap(FloatRectangle(0.0f, 0.0f, GetWidthF(), GetHeightF()), *pBitmap);
 509                 }
 510                 else
 511                 {
 512                         pCanvas->DrawBitmap(FloatRectangle(0.0f, 0.0f, GetWidthF(), GetHeightF()), *pBitmap);
 513                 }
 514         }
 515
 516         delete pCanvas;
 517
 518         return E_SUCCESS;
 519 }
 520
 521 void
 522 _BitmapElementView::SetModel(_BitmapElementModel* pBitmapElementModel)
 523 {
 524         __pElementBaseModel = static_cast<_ElementBaseModel*>(pBitmapElementModel);
 525 }
 526
 527 _CustomElementView::_CustomElementView(void)
 528 {
 529 }
 530
 531 _CustomElementView::~_CustomElementView(void)
 532 {
 533 }
 534
 535 result
 536 _CustomElementView::OnDraw(void)
 537 {
 538         result r = E_SUCCESS;
 539         Canvas* pCanvas = GetCanvasN();
 540
 541         CustomListItemStatus itemStatus;
 542         ICustomListElement* pListElement;
 543
 544         r  = GetLastResult();
 545         SysTryReturn(NID_UI_CTRL, (pCanvas), r, r, "[%s] Propagating.", GetErrorMessage(r));
 546
 547         _CustomElementModel* __pCustomElementModel = dynamic_cast<_CustomElementModel*>(__pElementBaseModel);
 548         SysTryCatch(NID_UI_CTRL, (__pCustomElementModel), , E_SYSTEM, "[E_SYSTEM] A system error has occured. Failed to get _CustomElementModel.");
 549
 550         itemStatus = __pCustomElementModel->GetItemStatus();
 551         pListElement = __pCustomElementModel->GetData();
 552
 553         if (pListElement)
 554         {
 555                 TableViewItemBase* pParentItem = dynamic_cast<TableViewItemBase*>(GetParent());
 556                 SysTryCatch(NID_UI_CTRL, pParentItem, , E_SYSTEM, "[E_SYSTEM] Failed to get parent item");
 557
 558                 Color bgColor = pParentItem->GetBackgroundColor(TABLE_VIEW_ITEM_DRAWING_STATUS_NORMAL);
 559
 560                 pCanvas->SetBackgroundColor(bgColor);
 561                 pCanvas->Clear();
 562                 pListElement->DrawElement(*pCanvas, Rectangle(0, 0, GetWidth(), GetHeight()), itemStatus);
 563         }
 564
 565         delete pCanvas;
 566         return E_SUCCESS;
 567
 568 CATCH:
 569         delete pCanvas;
 570         return E_SYSTEM;
 571
 572 }
 573
 574 void
 575 _CustomElementView::SetModel(_CustomElementModel* pCustomElementModel)
 576 {
 577         __pElementBaseModel = static_cast<_ElementBaseModel*>(pCustomElementModel);
 578 }
 579
 580 _CheckElementView::_CheckElementView(void)
 581         : __pressedState(false)
 582 {
 583         GET_COLOR_CONFIG(LIST::LISTITEM_DIVIDER_LEFT_HALF_COLOR, __leftHalfDividerColor);
 584         GET_COLOR_CONFIG(LIST::LISTITEM_DIVIDER_RIGHT_HALF_COLOR, __rightHalfDividerColor);
 585 }
 586
 587 _CheckElementView::~_CheckElementView(void)
 588 {
 589 }
 590
 591 result
 592 _CheckElementView::OnDraw(void)
 593 {
 594         result r = E_SUCCESS;
 595         Canvas* pCanvas = GetCanvasN();
 596
 597         r  = GetLastResult();
 598         SysTryReturn(NID_UI_CTRL, (pCanvas), r, r, "[%s] Propagating.", GetErrorMessage(r));
 599
 600         Rectangle bitmapBounds;
 601         bool isDividerEnabled = false;
 602         bool leftDivider = false;
 603         bool rightDivider = false;
 604         Bitmap* pCheckBitmap = null;
 605         _CheckElementModel* pCheckElementModel = null;
 606
 607         _ListBaseImpl* pListBaseImpl = _CustomListItemImpl::GetListBaseImplFromElement(*this);
 608         SysTryCatch(NID_UI_CTRL, (pListBaseImpl), , E_SYSTEM, "[E_SYSTEM] A system error has occured. Failed to get _ListBaseImpl.");
 609
 610         pCheckElementModel = dynamic_cast<_CheckElementModel*>(__pElementBaseModel);
 611         SysTryCatch(NID_UI_CTRL, (pCheckElementModel), , E_SYSTEM, "[E_SYSTEM] A system error has occured. Failed to get _CheckElementModel.");
 612
 613         pCheckElementModel->GetData(bitmapBounds, isDividerEnabled, leftDivider, rightDivider);
 614
 615         if (isDividerEnabled)
 616         {
 617                 Color bgColor(0, 0, 0, 0);
 618
 619                 if (__pressedState == true)
 620                 {
 621                         GET_COLOR_CONFIG(TABLEVIEW::ITEM_BG_PRESSED, bgColor);
 622                 }
 623                 else
 624                 {
 625                         bgColor = pListBaseImpl->GetBackgroundColor();
 626                 }
 627
 628                 pCanvas->SetBackgroundColor(bgColor);
 629         }
 630         else
 631         {
 632                 pCanvas->SetBackgroundColor(Color(0, 0, 0, 0));
 633         }
 634
 635         if (__pressedState == true && pListBaseImpl->GetAnnexStyle() != TABLE_VIEW_ANNEX_STYLE_ONOFF_SLIDING
 636                         && pListBaseImpl->GetAnnexStyle() != TABLE_VIEW_ANNEX_STYLE_ONOFF_SLIDING_WITH_DIVIDER)
 637         {
 638                 if (pCheckElementModel->GetCheckBoxStatus() == CHECK_BOX_UNCHECKED)
 639                 {
 640                         pCheckBitmap = pCheckElementModel->GetCheckBitmap(BITMAP_UNCHECKED_PRESSED);
 641                 }
 642                 else
 643                 {
 644                         pCheckBitmap = pCheckElementModel->GetCheckBitmap(BITMAP_CHECKED_PRESSED);
 645                 }
 646         }
 647         else
 648         {
 649                 if (pListBaseImpl->GetAnnexStyle() == TABLE_VIEW_ANNEX_STYLE_ONOFF_SLIDING ||
 650                                 pListBaseImpl->GetAnnexStyle() == TABLE_VIEW_ANNEX_STYLE_ONOFF_SLIDING_WITH_DIVIDER)
 651                 {
 652                         if (IsEnabled() == true)
 653                         {
 654                                 if (pCheckElementModel->GetCheckBoxStatus() == CHECK_BOX_CHECKED)
 655                                 {
 656                                         pCheckBitmap = pCheckElementModel->GetCheckBitmap(BITMAP_CHECKED);
 657                                 }
 658                                 else
 659                                 {
 660                                         pCheckBitmap = pCheckElementModel->GetCheckBitmap(BITMAP_UNCHECKED);
 661                                 }
 662                         }
 663                         else
 664                         {
 665                                 if (pCheckElementModel->GetCheckBoxStatus() == CHECK_BOX_CHECKED)
 666                                 {
 667                                         pCheckBitmap = pCheckElementModel->GetCheckBitmap(BITMAP_CHECKED_DISABLED);
 668                                 }
 669                                 else
 670                                 {
 671                                         pCheckBitmap = pCheckElementModel->GetCheckBitmap(BITMAP_UNCHECKED_DISABLED);
 672                                 }
 673                         }
 674                 }
 675                 else
 676                 {
 677                         if (IsEnabled() == true)
 678                         {
 679                                 if (pCheckElementModel->GetCheckBoxStatus() == CHECK_BOX_CHECKED)
 680                                 {
 681                                         pCheckBitmap = pCheckElementModel->GetCheckBitmap(BITMAP_CHECKED);
 682                                 }
 683                                 else
 684                                 {
 685                                         pCheckBitmap = pCheckElementModel->GetCheckBitmap(BITMAP_UNCHECKED);
 686                                 }
 687                         }
 688                         else
 689                         {
 690                                 if (pCheckElementModel->GetCheckBoxStatus() != CHECK_BOX_UNCHECKED)
 691                                 {
 692                                         pCheckBitmap =  pCheckElementModel->GetCheckBitmap(BITMAP_CHECKED_DISABLED);
 693                                 }
 694                                 else
 695                                 {
 696                                         pCheckBitmap = pCheckElementModel->GetCheckBitmap(BITMAP_UNCHECKED);
 697                                 }
 698                         }
 699                 }
 700         }
 701
 702         pCanvas->Clear();
 703
 704         if (bitmapBounds.width > pCheckBitmap->GetWidth())
 705         {
 706                 bitmapBounds.width = pCheckBitmap->GetWidth();
 707         }
 708
 709         if (bitmapBounds.height > pCheckBitmap->GetHeight())
 710         {
 711                 bitmapBounds.height = pCheckBitmap->GetHeight();
 712         }
 713
 714         pCanvas->DrawBitmap(bitmapBounds, *pCheckBitmap);
 715
 716         if (isDividerEnabled)
 717         {
 718                 float lineWidth = 0.0f;
 719
 720                 GET_SHAPE_CONFIG(LIST::CHECK_ELEMENT_DIVIDER_WIDTH, _CONTROL_ORIENTATION_PORTRAIT, lineWidth);
 721
 722                 FloatRectangle bounds = GetBoundsF();
 723                 float dividerHeight = 0.0f;
 724
 725                 dividerHeight = bounds.height / 2.0f;
 726                 bounds.y = bounds.y + ((bounds.height - dividerHeight) / 2.0f);
 727
 728                 if (leftDivider)
 729                 {
 730                         pCanvas->SetLineWidth(lineWidth / 2.0f);
 731                         pCanvas->SetForegroundColor(__leftHalfDividerColor);
 732                         pCanvas->DrawLine(FloatPoint(0.0f, bounds.y), FloatPoint(0.0f, dividerHeight + bounds.y));
 733
 734                         pCanvas->SetLineWidth(lineWidth / 2.0f);
 735                         pCanvas->SetForegroundColor(__rightHalfDividerColor);
 736                         pCanvas->DrawLine(FloatPoint(1.0f, bounds.y), FloatPoint(1.0f, dividerHeight + bounds.y));
 737                 }
 738
 739                 if (rightDivider)
 740                 {
 741                         pCanvas->SetLineWidth(lineWidth / 2.0f);
 742                         pCanvas->SetForegroundColor(__leftHalfDividerColor);
 743                         pCanvas->DrawLine(FloatPoint(bounds.width - lineWidth, bounds.y), FloatPoint(bounds.width - lineWidth, dividerHeight + bounds.y));
 744
 745                         pCanvas->SetLineWidth(lineWidth / 2.0f);
 746                         pCanvas->SetForegroundColor(__rightHalfDividerColor);
 747                         pCanvas->DrawLine(FloatPoint(bounds.width - lineWidth + 1.0f, bounds.y), FloatPoint(bounds.width - lineWidth + 1.0f, dividerHeight + bounds.y));
 748                 }
 749         }
 750
 751         delete pCanvas;
 752         return E_SUCCESS;
 753
 754 CATCH:
 755         delete pCanvas;
 756         return E_SYSTEM;
 757 }
 758
 759 void
 760 _CheckElementView::SetModel(_CheckElementModel* pCheckElementModel)
 761 {
 762         __pElementBaseModel = static_cast<_ElementBaseModel*>(pCheckElementModel);
 763 }
 764
 765 void
 766 _CheckElementView::SetPressed(bool pressedState)
 767 {
 768         __pressedState = pressedState;
 769 }
 770
 771 }}} //Tizen::Ui::Controls