src/ui/controls/FUiCtrl_CustomListItemImpl.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_CustomListItemImpl.cpp
  20  * @brief       This file contains implementation of _CustomListItemImpl class
  21  */
  22
  23 #include <FBaseSysLog.h>
  24 #include <FGrp_BitmapImpl.h>
  25 #include <FGrp_TextTextObject.h>
  26 #include "FUiCtrl_CustomListItemImpl.h"
  27 #include "FUiCtrl_CustomListItemFormatImpl.h"
  28 #include "FUiCtrl_PanelImpl.h"
  29
  30
  31 using namespace Tizen::Base;
  32 using namespace Tizen::Graphics;
  33 using namespace Tizen::Base::Collection;
  34 using namespace Tizen::Base::Runtime;
  35 using namespace Tizen::Graphics::_Text;
  36
  37 namespace Tizen { namespace Ui { namespace Controls
  38 {
  39
  40 const int INVALID_INDEX = -1;
  41
  42 _TableViewItemData::_TableViewItemData(void)
  43         : itemIndex(-1)
  44         , groupIndex(-1)
  45 {
  46 }
  47
  48 _TableViewItemData::~_TableViewItemData(void)
  49 {
  50 }
  51
  52 void
  53 _TableViewItemData::GetIndex(int& mainIndex, int& subIndex) const
  54 {
  55         mainIndex = groupIndex;
  56         subIndex = itemIndex;
  57 }
  58
  59 result
  60 _TableViewItemData::SetEnabled(bool enable)
  61 {
  62         Control* pControl = null;
  63
  64         for (int count = 0; count < GetControlCount(); count++)
  65         {
  66                 pControl = GetControl(count);
  67
  68                 if (pControl)
  69                 {
  70                         pControl->SetEnabled(enable);
  71                 }
  72         }
  73
  74         return E_SUCCESS;
  75 }
  76
  77 _TableViewGroupItemData::_TableViewGroupItemData(void)
  78         : groupIndex(-1)
  79 {
  80 }
  81
  82 _TableViewGroupItemData::~_TableViewGroupItemData(void)
  83 {
  84 }
  85
  86 void
  87 _TableViewGroupItemData::GetIndex(int& mainIndex, int& subIndex) const
  88 {
  89         mainIndex = groupIndex;
  90         subIndex = -1;
  91 }
  92
  93 result
  94 _TableViewGroupItemData::SetEnabled(bool enable)
  95 {
  96         Control* pControl = null;
  97
  98         for (int count = 0; count < GetControlCount(); count++)
  99         {
 100                 pControl = GetControl(count);
 101
 102                 if (pControl)
 103                 {
 104                         pControl->SetEnabled(enable);
 105                 }
 106         }
 107
 108         return E_SUCCESS;
 109 }
 110
 111 _CustomListItemImpl::_CustomListItemImpl(int itemHeight)
 112         : height(itemHeight)
 113         , itemId(LIST_ITEM_UNSPECIFIED_ID)
 114         , __pTableViewItemData(null)
 115         , __pTableViewGroupItemData(null)
 116         , __pSubItemsList(null)
 117         , __pTextSlideTimer(null)
 118         , __isMoved(false)
 119 {
 120         for (int i = 0; i <= CUSTOM_LIST_ITEM_STATUS_FOCUSED; i++)
 121         {
 122                 __pBitmaps[i] = null;
 123         }
 124 }
 125
 126 _CustomListItemImpl::~_CustomListItemImpl(void)
 127 {
 128         for (int i = 0; i <= CUSTOM_LIST_ITEM_STATUS_FOCUSED; i++)
 129         {
 130                 delete __pBitmaps[i];
 131         }
 132
 133         elements.RemoveAll(true);
 134 }
 135
 136 _CustomListItemImpl*
 137 _CustomListItemImpl::CreateInstanceN(int itemHeight)
 138 {
 139         _CustomListItemImpl* pImpl = new (std::nothrow) _CustomListItemImpl(itemHeight);
 140         SysTryReturn(NID_UI_CTRL, pImpl, null, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] Memory allocation failed.");
 141
 142         SetLastResult(E_SUCCESS);
 143         return pImpl;
 144 }
 145
 146 void
 147 _CustomListItemImpl::RemoveElement(int elementId)
 148 {
 149         _ElementBaseModel* pBaseModel = GetElementModelById(elementId);
 150         elements.Remove(*pBaseModel, true);
 151 }
 152
 153 result
 154 _CustomListItemImpl::SetCheckBox(int elementId)
 155 {
 156         _CheckElementModel* pCheckElement = null;
 157         _ElementBaseModel* pBaseModel = GetElementModelById(elementId);
 158
 159         if (pBaseModel && pBaseModel->_elementType != LIST_ITEM_ELEMENT_TYPE_CHECKBOX)
 160         {
 161                 return E_SYSTEM;
 162         }
 163
 164         pCheckElement = new (std::nothrow) _CheckElementModel();
 165         SysTryReturn(NID_UI_CTRL, pCheckElement, E_SYSTEM, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] Memory allocation failed.");
 166
 167         pCheckElement->_elementId = elementId;
 168         pCheckElement->_elementType = LIST_ITEM_ELEMENT_TYPE_CHECKBOX;
 169
 170         elements.Add(*pCheckElement);
 171         return E_SUCCESS;
 172 }
 173
 174 result
 175 _CustomListItemImpl::SetElement(int elementId, const Bitmap& normalBitmap, const Bitmap* pFocusedBitmap, const Bitmap* pHighlightedBitmap)
 176 {
 177         _ElementBaseModel* pBaseModel = GetElementModelById(elementId);
 178         if (pBaseModel && pBaseModel->_elementType != LIST_ITEM_ELEMENT_TYPE_BITMAP)
 179         {
 180                 RemoveElement(elementId);
 181         }
 182
 183         result r = E_SUCCESS;
 184         _BitmapElementModel* pBitmapElement = dynamic_cast<_BitmapElementModel*>(pBaseModel);
 185
 186         if (!pBitmapElement)
 187         {
 188                 pBitmapElement = new (std::nothrow) _BitmapElementModel();
 189                 SysTryReturnResult(NID_UI_CTRL, pBitmapElement, E_OUT_OF_MEMORY, "Memory allocation failed.");
 190
 191                 pBitmapElement->_elementId = elementId;
 192                 pBitmapElement->_elementType = LIST_ITEM_ELEMENT_TYPE_BITMAP;
 193                 elements.Add(*pBitmapElement);
 194         }
 195         else
 196         {
 197                 delete pBitmapElement->__pBitmap[CUSTOM_LIST_ITEM_STATUS_NORMAL];
 198                 delete pBitmapElement->__pBitmap[CUSTOM_LIST_ITEM_STATUS_SELECTED];
 199                 delete pBitmapElement->__pBitmap[CUSTOM_LIST_ITEM_STATUS_FOCUSED];
 200         }
 201
 202         pBitmapElement->__pBitmap[CUSTOM_LIST_ITEM_STATUS_NORMAL] = _BitmapImpl::CloneN(normalBitmap);
 203
 204         r = GetLastResult();
 205         SysTryReturn(NID_UI_CTRL, r == E_SUCCESS, E_SYSTEM, r, "[%s] Propagating.", GetErrorMessage(r));
 206
 207         if (pFocusedBitmap)
 208         {
 209                 pBitmapElement->__pBitmap[CUSTOM_LIST_ITEM_STATUS_FOCUSED] = _BitmapImpl::CloneN(*pFocusedBitmap);
 210                 r = GetLastResult();
 211                 SysTryReturn(NID_UI_CTRL, r == E_SUCCESS, E_SYSTEM, r, "[%s] Propagating.", GetErrorMessage(r));
 212         }
 213         else
 214         {
 215                 pBitmapElement->__pBitmap[CUSTOM_LIST_ITEM_STATUS_FOCUSED] = null;
 216         }
 217
 218         if (pHighlightedBitmap)
 219         {
 220                 pBitmapElement->__pBitmap[CUSTOM_LIST_ITEM_STATUS_SELECTED] = _BitmapImpl::CloneN(*pHighlightedBitmap);
 221                 r = GetLastResult();
 222                 SysTryReturn(NID_UI_CTRL, r == E_SUCCESS, E_SYSTEM, r, "[%s] Propagating.", GetErrorMessage(r));
 223         }
 224         else
 225         {
 226                 pBitmapElement->__pBitmap[CUSTOM_LIST_ITEM_STATUS_SELECTED] = null;
 227         }
 228
 229         return E_SUCCESS;
 230 }
 231
 232 result
 233 _CustomListItemImpl::SetElement(int elementId, const String& text)
 234 {
 235         _ElementBaseModel* pBaseModel = GetElementModelById(elementId);
 236         if (pBaseModel && pBaseModel->_elementType != LIST_ITEM_ELEMENT_TYPE_TEXT)
 237         {
 238                 RemoveElement(elementId);
 239         }
 240
 241         _TextElementModel* pTextElement = dynamic_cast<_TextElementModel*>(pBaseModel);
 242
 243         if (!pTextElement)
 244         {
 245                 pTextElement = new (std::nothrow) _TextElementModel(text);
 246                 SysTryReturnResult(NID_UI_CTRL, pTextElement, E_OUT_OF_MEMORY, "Memory allocation failed.");
 247
 248                 pTextElement->_elementType = LIST_ITEM_ELEMENT_TYPE_TEXT;
 249                 pTextElement->_elementId = elementId;
 250
 251                 elements.Add(*pTextElement);
 252         }
 253         else
 254         {
 255                 pTextElement->__text = text;
 256         }
 257
 258         return E_SUCCESS;
 259 }
 260
 261 result
 262 _CustomListItemImpl::SetElement(int elementId, const Bitmap& normalBitmap, const Bitmap* pFocusedBitmap)
 263 {
 264         return SetElement(elementId, normalBitmap, pFocusedBitmap, &normalBitmap);
 265 }
 266
 267 result
 268 _CustomListItemImpl::SetElement(int elementId, const ICustomListElement& element)
 269 {
 270         _ElementBaseModel* pBaseModel = GetElementModelById(elementId);
 271         if (pBaseModel && pBaseModel->_elementType != LIST_ITEM_ELEMENT_TYPE_CUSTOM)
 272         {
 273                 RemoveElement(elementId);
 274         }
 275
 276         _CustomElementModel* pCustomListElement = dynamic_cast<_CustomElementModel*>(pBaseModel);
 277
 278         if (!pCustomListElement)
 279         {
 280                 pCustomListElement = new (std::nothrow) _CustomElementModel();
 281                 SysTryReturnResult(NID_UI_CTRL, pCustomListElement, E_OUT_OF_MEMORY, "Memory allocation failed.");
 282
 283                 pCustomListElement->_elementId = elementId;
 284                 pCustomListElement->_elementType = LIST_ITEM_ELEMENT_TYPE_CUSTOM;
 285                 pCustomListElement->__pListElement = const_cast<ICustomListElement*>(&element);
 286
 287                 elements.Add(*pCustomListElement);
 288         }
 289         else
 290         {
 291                 pCustomListElement->__pListElement = const_cast<ICustomListElement*>(&element);
 292         }
 293
 294         return E_SUCCESS;
 295 }
 296
 297 result
 298 _CustomListItemImpl::SetTextSliding(int elementId, bool enable)
 299 {
 300         _TextElementModel* pTextElementModel = dynamic_cast<_TextElementModel*>(GetElementModelById(elementId));
 301         SysTryReturn(NID_UI_CTRL, pTextElementModel, E_SYSTEM, E_SYSTEM, "[E_SYSTEM] A system error has occurred. Failed to get element data");
 302
 303         pTextElementModel->SetTextSliding(enable);
 304
 305         return E_SUCCESS;
 306 }
 307
 308 void
 309 _CustomListItemImpl::StartSliding(void)
 310 {
 311         _TextElementModel* pTextElementModel = null;
 312
 313         for (int i = 0; i < elements.GetCount(); i++)
 314         {
 315                 pTextElementModel = dynamic_cast<_TextElementModel*>(const_cast<Object*>(elements.GetAt(i)));
 316                 if (pTextElementModel && pTextElementModel->GetTextSliding())
 317                 {
 318                         StartTextSlideTimer();
 319                         break;
 320                 }
 321         }
 322 }
 323
 324 void
 325 _CustomListItemImpl::StopSliding(void)
 326 {
 327         _TextElementModel* pTextElementModel = null;
 328
 329         for (int i = 0; i < elements.GetCount(); i++)
 330         {
 331                 pTextElementModel = dynamic_cast<_TextElementModel*>(const_cast<Object*>(elements.GetAt(i)));
 332                 if (pTextElementModel && pTextElementModel->GetTextSliding())
 333                 {
 334                         _TextElementView* pTextElementView = dynamic_cast<_TextElementView*>(GetElementViewById(pTextElementModel->_elementId));
 335                         SysTryReturnVoidResult(NID_UI_CTRL, (pTextElementView != null), GetLastResult(), "[%s] Propagating.", GetErrorMessage(GetLastResult()));
 336
 337                         pTextElementView->StopTextSlide();
 338                 }
 339         }
 340
 341         StopTextSlideTimer();
 342 }
 343
 344 void
 345 _CustomListItemImpl::StartTextSlideTimer(void)
 346 {
 347         result r = E_SUCCESS;
 348
 349         if (__pTextSlideTimer == null)
 350         {
 351                 __pTextSlideTimer = new (std::nothrow) Timer();
 352                 SysTryReturnVoidResult(NID_UI_CTRL, (__pTextSlideTimer != null), E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] Memory allocation failed.");
 353
 354                 r = __pTextSlideTimer->Construct(*this);
 355                 SysTryCatch(NID_UI_CTRL, (r == E_SUCCESS), ,E_SYSTEM, "[E_SYSTEM] A system error has occured. Failed to construct sliding timer.");
 356         }
 357         else
 358         {
 359                 __pTextSlideTimer->Cancel();
 360         }
 361
 362         r = __pTextSlideTimer->Start(TEXT_SLIDING_TIMER_DURATION);
 363         SysTryCatch(NID_UI_CTRL, (r == E_SUCCESS), , E_SYSTEM, "[E_SYSTEM] A system error has occured. Failed to start sliding timer.");
 364
 365         return;
 366
 367 CATCH:
 368         StopTextSlideTimer();
 369 }
 370
 371 void
 372 _CustomListItemImpl::StopTextSlideTimer(void)
 373 {
 374         delete __pTextSlideTimer;
 375         __pTextSlideTimer = null;
 376 }
 377
 378 void
 379 _CustomListItemImpl::OnTimerExpired(Timer& timer)
 380 {
 381         if (&timer == __pTextSlideTimer)
 382         {
 383                 _TextElementModel* pTextElementModel = null;
 384                 bool timerRequired = false;
 385
 386                 for (int i = 0; i < elements.GetCount(); i++)
 387                 {
 388                         pTextElementModel = dynamic_cast<_TextElementModel*>(const_cast<Object*>(elements.GetAt(i)));
 389                         if (pTextElementModel && pTextElementModel->GetTextSliding())
 390                         {
 391                                 _TextElementView* pTextElementView = dynamic_cast<_TextElementView*>(GetElementViewById(pTextElementModel->_elementId));
 392                                 SysTryReturnVoidResult(NID_UI_CTRL, (pTextElementView != null), GetLastResult(), "[%s] Propagating.", GetErrorMessage(GetLastResult()));
 393
 394                                 pTextElementView->StartTextSlide();
 395                                 timerRequired = true;
 396                         }
 397                 }
 398
 399                 if (timerRequired)
 400                 {
 401                         StartTextSlideTimer();
 402                 }
 403         }
 404 }
 405
 406 _ElementBaseModel*
 407 _CustomListItemImpl::GetElementModelById(int elementId) const
 408 {
 409         _ElementBaseModel* pElementBaseModel = null;
 410
 411         for (int i = 0; i < elements.GetCount(); i++)
 412         {
 413                 pElementBaseModel = dynamic_cast<_ElementBaseModel*>(const_cast<Object*>(elements.GetAt(i)));
 414                 SysTryReturn(NID_UI_CTRL, pElementBaseModel, null, E_SYSTEM, "[E_SYSTEM] A system error has occurred. Failed to get element data");
 415
 416                 if (pElementBaseModel->_elementId == elementId)
 417                 {
 418                         return pElementBaseModel;
 419                 }
 420         }
 421
 422         return null;
 423 }
 424
 425 _ElementBaseView*
 426 _CustomListItemImpl::GetElementViewById(int elementId) const
 427 {
 428         TableViewItemBase* pTableViewItemBase = null;
 429
 430         if (__pTableViewItemData)
 431         {
 432                 pTableViewItemBase = __pTableViewItemData;
 433         }
 434         else if (__pTableViewGroupItemData)
 435         {
 436                 pTableViewItemBase = __pTableViewGroupItemData;
 437         }
 438         else
 439         {
 440                 return null;
 441         }
 442
 443         _ElementBaseView* pElementBaseView = null;
 444         int controlCount = pTableViewItemBase->GetControlCount();
 445
 446         for (int count = 0; count < controlCount; count++)
 447         {
 448                 pElementBaseView = dynamic_cast<_ElementBaseView*>(const_cast<Control*>(pTableViewItemBase->GetControl(count)));
 449                 SysTryReturn(NID_UI_CTRL, pElementBaseView, null, E_SYSTEM, "[E_SYSTEM] A system error has occurred. Failed to get element data");
 450
 451                 if (pElementBaseView->GetElementId() == elementId)
 452                 {
 453                         return pElementBaseView;
 454                 }
 455         }
 456
 457         return null;
 458 }
 459
 460 void
 461 _CustomListItemImpl::SetNormalItemBackgroundBitmap(const Bitmap& bitmap)
 462 {
 463         TableViewItemDrawingStatus status = TABLE_VIEW_ITEM_DRAWING_STATUS_NORMAL;
 464
 465         if (__pBitmaps[status])
 466         {
 467                 delete __pBitmaps[status];
 468         }
 469
 470         __pBitmaps[status] = _BitmapImpl::CloneN(bitmap);
 471
 472         SetBackgroundBitmap(bitmap, status);
 473         return;
 474 }
 475
 476 void
 477 _CustomListItemImpl::SetFocusedItemBackgroundBitmap(const Bitmap& bitmap)
 478 {
 479         TableViewItemDrawingStatus status = TABLE_VIEW_ITEM_DRAWING_STATUS_PRESSED;
 480
 481         if (__pBitmaps[status])
 482         {
 483                 delete __pBitmaps[status];
 484         }
 485
 486         __pBitmaps[status] = _BitmapImpl::CloneN(bitmap);
 487
 488         SetBackgroundBitmap(bitmap, status);
 489         return;
 490 }
 491
 492 void
 493 _CustomListItemImpl::SetHighlightedItemBackgroundBitmap(const Bitmap& bitmap)
 494 {
 495         TableViewItemDrawingStatus status = TABLE_VIEW_ITEM_DRAWING_STATUS_HIGHLIGHTED;
 496
 497         if (__pBitmaps[status])
 498         {
 499                 delete __pBitmaps[status];
 500         }
 501
 502         __pBitmaps[status] = _BitmapImpl::CloneN(bitmap);
 503
 504         SetBackgroundBitmap(bitmap, status);
 505         return;
 506 }
 507
 508 void
 509 _CustomListItemImpl::SetBackgroundBitmap(const Bitmap& bitmap, TableViewItemDrawingStatus status)
 510 {
 511         if (__pTableViewItemData)
 512         {
 513                 bool returnValue = __pTableViewItemData->SetBackgroundBitmap(__pBitmaps[status], status);
 514                 result r = GetLastResult();
 515
 516                 SysTryReturnVoidResult(NID_UI_CTRL, returnValue == true, r, "[%s] Propagating.", GetErrorMessage(r));
 517         }
 518         else if (__pTableViewGroupItemData)
 519         {
 520                 bool returnValue = __pTableViewGroupItemData->SetBackgroundBitmap(__pBitmaps[status], status);
 521                 result r = GetLastResult();
 522
 523                 SysTryReturnVoidResult(NID_UI_CTRL, returnValue == true, r, "[%s] Propagating.", GetErrorMessage(r));
 524         }
 525
 526         SetLastResult(E_SUCCESS);
 527         return;
 528 }
 529
 530 void
 531 _CustomListItemImpl::UpdateBitmaps(void)
 532 {
 533         for (int i = 0; i <= CUSTOM_LIST_ITEM_STATUS_FOCUSED; i++)
 534         {
 535                 if (__pBitmaps[i])
 536                 {
 537                         SetBackgroundBitmap(*__pBitmaps[i], (TableViewItemDrawingStatus)i);
 538                 }
 539         }
 540
 541         return;
 542 }
 543
 544 _CheckElementModel*
 545 _CustomListItemImpl::GetCheckElement(void)
 546 {
 547         _ElementBaseModel* pElementBase = null;
 548         _CheckElementModel* pCheckElement = null;
 549
 550         for (int i = 0; i < elements.GetCount(); i++)
 551         {
 552                 pElementBase = dynamic_cast<_ElementBaseModel*>(elements.GetAt(i));
 553                 SysTryReturn(NID_UI_CTRL, (pElementBase != null), null, E_SYSTEM, "[E_SYSTEM] A system error has occurred. Failed to get element");
 554
 555                 if (pElementBase->_elementType == LIST_ITEM_ELEMENT_TYPE_CHECKBOX)
 556                 {
 557                         pCheckElement = dynamic_cast<_CheckElementModel*>(pElementBase);
 558                         return pCheckElement;
 559                 }
 560         }
 561
 562         return null;
 563 }
 564
 565 result
 566 _CustomListItemImpl::SetDividerRequired(LinkedList& elementFormatList, Rectangle& checkElementBounds, bool& leftDivider, bool& rightDivider)
 567 {
 568         _ElementFormatData* pFormatData = null;
 569
 570         for (int formatDataCount = elementFormatList.GetCount() - 1; formatDataCount >= 0; formatDataCount--)
 571         {
 572                 pFormatData = dynamic_cast<_ElementFormatData*>(elementFormatList.GetAt(formatDataCount));
 573                 SysTryReturnResult(NID_UI_CTRL, (pFormatData != null), E_SYSTEM, "A system error has occurred. Failed to get format data");
 574
 575                 if (pFormatData->rect.x < checkElementBounds.x)
 576                 {
 577                         leftDivider = true;
 578                 }
 579                 else if (pFormatData->rect.x > checkElementBounds.x + checkElementBounds.width)
 580                 {
 581                         rightDivider = true;
 582                 }
 583         }
 584
 585         return E_SUCCESS;
 586 }
 587
 588 result
 589 _CustomListItemImpl::CreateTableViewItem(_TableViewItemParams& tableViewItemParams)
 590 {
 591         TableViewItemBase* pTableViewItemBase = null;
 592
 593         if (tableViewItemParams.itemIndex == -1)
 594         {
 595                 pTableViewItemBase = CreateTableViewGroupItemN(tableViewItemParams);
 596         }
 597         else
 598         {
 599                 pTableViewItemBase = CreateTableViewItemN(tableViewItemParams);
 600         }
 601
 602         SysTryReturnResult(NID_UI_CTRL, (pTableViewItemBase != null), E_SYSTEM, "A system error has occurred. Failed to create tableViewItem");
 603
 604         _CustomListItemImpl* pCustomListItemImpl = GetItemImpl(tableViewItemParams.pItem);
 605         SysTryReturnResult(NID_UI_CTRL, (pCustomListItemImpl != null), E_INVALID_ARG, "Invalid argument is used. CustomListItem is null");
 606
 607         _CustomListItemFormatImpl* pFormatImpl = GetFormatImpl(tableViewItemParams.pItem);
 608         SysTryReturnResult(NID_UI_CTRL, (pFormatImpl != null), E_INVALID_ARG, "Invalid argument is used. CustomListItemFormat is null");
 609
 610         LinkedList* pElementFormat = &pFormatImpl->elementFormatDataList;
 611         LinkedList* pElements = &pCustomListItemImpl->elements;
 612         _ElementBaseModel* pElementBase = null;
 613
 614         for (int elementCount = pElements->GetCount() - 1; elementCount >= 0; elementCount--)
 615         {
 616                 pElementBase = dynamic_cast<_ElementBaseModel*>(pElements->GetAt(elementCount));
 617                 SysTryCatch(NID_UI_CTRL, (pElementBase != null), , E_SYSTEM, "[E_SYSTEM] A system error has occurred. Failed to get element.");
 618
 619                 if (!pCustomListItemImpl->IsElementIdValid(pElementFormat, pElementBase->_elementId))
 620                 {
 621                         pElements->RemoveAt(elementCount, true);
 622                         SysLog(NID_UI_CTRL, "The provided elementId is not present in CustomListItemFormat.");
 623                         continue;
 624                 }
 625
 626                 result r = E_SUCCESS;
 627
 628                 _ElementViewParams elementParams;
 629                 elementParams.pTableViewItemBase = pTableViewItemBase;
 630                 elementParams.pElementModel = pElementBase;
 631                 elementParams.pElementFormatData = pFormatImpl->GetElementFormatById(pElementBase->_elementId);
 632                 elementParams.isDividerEnabled = tableViewItemParams.isDividerEnabled;
 633                 elementParams.annexStyle = tableViewItemParams.annexStyle;
 634                 elementParams.pCustomListItemImpl = pCustomListItemImpl;
 635                 elementParams.pCheckBitmaps = tableViewItemParams.pCheckBitmaps;
 636                 elementParams.pElementFormat = pElementFormat;
 637
 638                 r = pElementBase->CreateElementView(elementParams);
 639                 SysTryCatch(NID_UI_CTRL, r == E_SUCCESS, , E_SYSTEM, "[E_SYSTEM] A system error has occurred. Failed to create element view.");
 640         }
 641
 642         return E_SUCCESS;
 643
 644 CATCH:
 645         if (tableViewItemParams.itemIndex == -1)
 646         {
 647                 _TableViewGroupItemData* pTableViewGroupItemData = dynamic_cast<_TableViewGroupItemData*>(pTableViewItemBase);
 648                 delete pTableViewGroupItemData;
 649         }
 650         else
 651         {
 652                 _TableViewItemData* pTableViewItemData = dynamic_cast<_TableViewItemData*>(pTableViewItemBase);
 653                 delete pTableViewItemData;
 654         }
 655
 656         return E_SYSTEM;
 657 }
 658
 659 TableViewItemBase*
 660 _CustomListItemImpl::CreateTableViewGroupItemN(_TableViewItemParams& tableViewItemParams)
 661 {
 662         result r = E_SUCCESS;
 663
 664         _TableViewGroupItemData* pTableViewGroupItemData = null;
 665
 666         pTableViewGroupItemData = new (std::nothrow) _TableViewGroupItemData();
 667         SysTryReturn(NID_UI_CTRL, pTableViewGroupItemData, null, E_SYSTEM, "[E_OUT_OF_MEMORY] Memory allocation failed.");
 668
 669         r = pTableViewGroupItemData->Construct(FloatDimension(tableViewItemParams.width, tableViewItemParams.pItem->__pCustomListItemImpl->height));
 670         SysTryCatch(NID_UI_CTRL, pTableViewGroupItemData, , E_SYSTEM, "[%s] Failed to create an item.", GetErrorMessage(r));
 671
 672         pTableViewGroupItemData->groupIndex = tableViewItemParams.groupIndex;
 673         tableViewItemParams.pItem->__pCustomListItemImpl->__pTableViewGroupItemData = pTableViewGroupItemData;
 674
 675         tableViewItemParams.pItem->__pCustomListItemImpl->UpdateBitmaps();
 676
 677         return pTableViewGroupItemData;
 678
 679 CATCH:
 680         delete pTableViewGroupItemData;
 681         return null;
 682 }
 683
 684 TableViewItemBase*
 685 _CustomListItemImpl::CreateTableViewItemN(_TableViewItemParams& tableViewItemParams)
 686 {
 687         result r = E_SUCCESS;
 688         _TableViewItemData* pTableViewItemData = null;
 689
 690         pTableViewItemData = new (std::nothrow) _TableViewItemData();
 691         SysTryReturn(NID_UI_CTRL, pTableViewItemData, null, E_SYSTEM, "[E_OUT_OF_MEMORY] Memory allocation failed.");
 692
 693         r = pTableViewItemData->Construct(FloatDimension(tableViewItemParams.width, tableViewItemParams.pItem->__pCustomListItemImpl->height), TABLE_VIEW_ANNEX_STYLE_NORMAL);
 694         SysTryCatch(NID_UI_CTRL, pTableViewItemData, , E_SYSTEM, "[%s] Failed to create an item.", GetErrorMessage(r));
 695
 696         pTableViewItemData->groupIndex = tableViewItemParams.groupIndex;
 697         pTableViewItemData->itemIndex = tableViewItemParams.itemIndex;
 698         tableViewItemParams.pItem->__pCustomListItemImpl->__pTableViewItemData = pTableViewItemData;
 699
 700         tableViewItemParams.pItem->__pCustomListItemImpl->UpdateBitmaps();
 701
 702         return pTableViewItemData;
 703
 704 CATCH:
 705         delete pTableViewItemData;
 706         return null;
 707 }
 708
 709 result
 710 _CustomListItemImpl::SetElementData(_ElementBaseModel* pElement)
 711 {
 712         SysTryReturnResult(NID_UI_CTRL, (pElement != null), E_INVALID_ARG, "Invalid argument used. pElement must not be null.");
 713
 714         _ElementBaseModel* pTempElement = null;
 715         int i = 0;
 716         result r = E_SUCCESS;
 717
 718         for (; i < elements.GetCount(); i++)
 719         {
 720                 pTempElement = dynamic_cast<_ElementBaseModel*>(elements.GetAt(i));
 721                 SysTryReturnResult(NID_UI_CTRL, pTempElement, E_SYSTEM, "A system error has occurred. Failed to get element");
 722
 723                 if (pElement->_elementId == pTempElement->_elementId)
 724                 {
 725                         break;
 726                 }
 727         }
 728
 729         if (i != elements.GetCount())
 730         {
 731                 r = elements.SetAt(*pElement, i, true);
 732         }
 733         else
 734         {
 735                 r = elements.Add(*pElement);
 736         }
 737
 738         return r;
 739 }
 740
 741 bool
 742 _CustomListItemImpl::IsElementIdValid(LinkedList* pElementFormat, int elementId) const
 743 {
 744         for (int elementFormatDataCount = pElementFormat->GetCount() - 1; elementFormatDataCount >= 0; elementFormatDataCount--)
 745         {
 746                 _ElementFormatData* pElementFormatData = dynamic_cast<_ElementFormatData*>(const_cast<Object*>(pElementFormat->GetAt(elementFormatDataCount)));
 747
 748                 if (pElementFormatData != null && pElementFormatData->elementId == elementId)
 749                 {
 750                         return true;
 751                 }
 752         }
 753
 754         return false;
 755 }
 756
 757 _CustomListItemFormatImpl*
 758 _CustomListItemImpl::GetFormatImpl(CustomListItem* pItem)
 759 {
 760         SysTryReturn(NID_UI_CTRL, (pItem != null), null, E_INVALID_ARG, "[E_INVALID_ARG] Invalid argument is used. CustomListItem is null");
 761
 762         CustomListItemFormat* pFormat = pItem->__pCustomListItemFormat;
 763         SysTryReturn(NID_UI_CTRL, (pFormat != null), null, E_INVALID_ARG, "[E_INVALID_ARG] Invalid argument is used. CustomListItemFormat is null");
 764
 765         return pItem->__pCustomListItemFormat->__pCustomListItemFormatImpl;
 766 }
 767
 768 _CustomListItemImpl*
 769 _CustomListItemImpl::GetItemImpl(CustomListItem* pItem)
 770 {
 771         SysTryReturn(NID_UI_CTRL, (pItem != null), null, E_INVALID_ARG, "[E_INVALID_ARG] Invalid argument is used. CustomListItem is null");
 772
 773         return pItem->__pCustomListItemImpl;
 774 }
 775
 776 result
 777 _CustomListItemImpl::UpdateTableViewItem(_TableViewItemUpdateParams& updateParams)
 778 {
 779         _CustomListItemImpl* pCustomListItemImpl = GetItemImpl(updateParams.pItem);
 780         SysTryReturnResult(NID_UI_CTRL, (pCustomListItemImpl != null), E_SYSTEM, "Invalid argument used. __pCustomListItemImpl must not be null");
 781
 782         TableViewItemBase* pTableViewItemBase = null;
 783
 784         if (pCustomListItemImpl->__pTableViewItemData)
 785         {
 786                 pTableViewItemBase = pCustomListItemImpl->__pTableViewItemData;
 787         }
 788         else
 789         {
 790                 pTableViewItemBase = pCustomListItemImpl->__pTableViewGroupItemData;
 791         }
 792
 793         SysTryReturnResult(NID_UI_CTRL, (pTableViewItemBase != null), E_SYSTEM, "A system error has occurred. Failed to create tableViewItem");
 794
 795         _CustomListItemFormatImpl* pFormatImpl = GetFormatImpl(updateParams.pItem);
 796         SysTryReturnResult(NID_UI_CTRL, (pFormatImpl != null), E_SYSTEM, "Invalid argument used. Item format must not be null");
 797
 798         LinkedList* pElementFormat = &pFormatImpl->elementFormatDataList;
 799         _ElementBaseModel* pElementBase = null;
 800         bool isValidElementId = false;
 801
 802         for (int i = 0; i < pTableViewItemBase->GetControlCount(); i++)
 803         {
 804                 Control* pControl = dynamic_cast<Control*>(pTableViewItemBase->GetControl(i));
 805                 pTableViewItemBase->SetIndividualSelectionEnabled(pControl, false);
 806         }
 807
 808         pTableViewItemBase->RemoveAllControls();
 809
 810         for (int elementCount = pCustomListItemImpl->elements.GetCount() -1; elementCount >= 0; elementCount--)
 811         {
 812                 isValidElementId = false;
 813
 814                 pElementBase = dynamic_cast<_ElementBaseModel*>(pCustomListItemImpl->elements.GetAt(elementCount));
 815                 SysTryReturnResult(NID_UI_CTRL, (pElementBase != null), E_SYSTEM, "Invalid element.");
 816
 817                 if (!pCustomListItemImpl->IsElementIdValid(pElementFormat, pElementBase->_elementId))
 818                 {
 819                         pCustomListItemImpl->elements.RemoveAt(elementCount, true);
 820                         SysLog(NID_UI_CTRL, "The provided elementId is not present in CustomListItemFormat.");
 821                         continue;
 822                 }
 823
 824                 result r = E_SUCCESS;
 825
 826                 _ElementViewParams elementParams;
 827                 elementParams.pTableViewItemBase = pTableViewItemBase;
 828                 elementParams.pElementModel = pElementBase;
 829                 elementParams.pElementFormatData = pFormatImpl->GetElementFormatById(pElementBase->_elementId);
 830                 elementParams.isDividerEnabled = updateParams.isDividerEnabled;
 831                 elementParams.annexStyle = updateParams.annexStyle;
 832                 elementParams.pCustomListItemImpl = pCustomListItemImpl;
 833                 elementParams.pCheckBitmaps = updateParams.pCheckBitmaps;
 834                 elementParams.pElementFormat = pElementFormat;
 835
 836                 r = pElementBase->CreateElementView(elementParams);
 837                 SysTryReturnResult(NID_UI_CTRL, r == E_SUCCESS, E_SYSTEM, "A system error has occurred. Failed to create element view.");
 838         }
 839
 840         pCustomListItemImpl->UpdateBitmaps();
 841
 842         return E_SUCCESS;
 843 }
 844
 845 void
 846 _CustomListItemImpl::OnTouchDoublePressed (const Control &source, const Point &currentPosition, const TouchEventInfo &touchInfo)
 847 {
 848         return;
 849 }
 850
 851 void
 852 _CustomListItemImpl::OnTouchFocusIn (const Control &source, const Point &currentPosition, const TouchEventInfo &touchInfo)
 853 {
 854         return;
 855 }
 856
 857 void
 858 _CustomListItemImpl::OnTouchFocusOut (const Control &source, const Point &currentPosition, const TouchEventInfo &touchInfo)
 859 {
 860         if (source.IsEnabled() == false || touchInfo.IsFlicked())
 861         {
 862                 return;
 863         }
 864
 865         _ElementBaseView* pCurrentElement = dynamic_cast<_ElementBaseView*>(const_cast<Control*>(&source));
 866         SysTryReturnVoidResult(NID_UI_CTRL, (pCurrentElement != null), E_SYSTEM, "[E_SYSTEM] A system error has occurred. Failed to get element");
 867
 868         _ListBaseImpl* pListBaseImpl = GetListBaseImplFromElement(source);
 869         SysTryReturnVoidResult(NID_UI_CTRL, (pListBaseImpl != null), E_SYSTEM, "[E_SYSTEM] A system error has occurred. Failed to get item.");
 870
 871         UpdateElements(source, pCurrentElement->GetElementId(), false, pListBaseImpl->_isDividerEnabled);
 872
 873         UpdateItemBackground(source, pListBaseImpl->_isDividerEnabled);
 874
 875         return;
 876 }
 877
 878 void
 879 _CustomListItemImpl::OnTouchLongPressed (const Control &source, const Point &currentPosition, const TouchEventInfo &touchInfo)
 880 {
 881         return;
 882 }
 883
 884 void
 885 _CustomListItemImpl::OnTouchMoved (const Control &source, const Point &currentPosition, const TouchEventInfo &touchInfo)
 886 {
 887         __isMoved = true;
 888         return;
 889 }
 890
 891 void
 892 _CustomListItemImpl::OnTouchPressed (const Control &source, const Point &currentPosition, const TouchEventInfo &touchInfo)
 893 {
 894         if (source.IsEnabled() == false || touchInfo.IsFlicked())
 895         {
 896                 return;
 897         }
 898         _ElementBaseView* pCurrentElement = dynamic_cast<_ElementBaseView*>(const_cast<Control*>(&source));
 899         SysTryReturnVoidResult(NID_UI_CTRL, (pCurrentElement != null), E_SYSTEM, "[E_SYSTEM] A system error has occurred. Failed to get element");
 900
 901         _ListBaseImpl* pListBaseImpl = GetListBaseImplFromElement(source);
 902         SysTryReturnVoidResult(NID_UI_CTRL, (pListBaseImpl != null), E_SYSTEM, "[E_SYSTEM] A system error has occurred. Failed to get item.");
 903
 904         int elementId = pCurrentElement->GetElementId();
 905
 906         UpdateElements(source, elementId, true, pListBaseImpl->_isDividerEnabled);
 907
 908         UpdateItemBackground(source, pListBaseImpl->_isDividerEnabled);
 909 }
 910
 911 void
 912 _CustomListItemImpl::OnTouchReleased (const Control &source, const Point &currentPosition, const TouchEventInfo &touchInfo)
 913 {
 914         if (source.IsEnabled() == false || touchInfo.IsFlicked())
 915         {
 916                 return;
 917         }
 918         _ElementBaseView* pCurrentElement = dynamic_cast<_ElementBaseView*>(const_cast<Control*>(&source));
 919         SysTryReturnVoidResult(NID_UI_CTRL, (pCurrentElement != null), E_SYSTEM, "[E_SYSTEM] A system error has occurred. Failed to get element");
 920
 921         _ListBaseImpl* pListBaseImpl = GetListBaseImplFromElement(source);
 922         SysTryReturnVoidResult(NID_UI_CTRL, (pListBaseImpl != null), E_SYSTEM, "[E_SYSTEM] A system error has occurred. Failed to get item.");
 923
 924         _CheckElementView* pCheckElementView = dynamic_cast<_CheckElementView*>(const_cast<Control*>(&source));
 925
 926         UpdateElements(source, pCurrentElement->GetElementId(), false, pListBaseImpl->_isDividerEnabled);
 927
 928         if (__isMoved == false)
 929         {
 930                 int groupIndex = -1;
 931                 int itemIndex = -1;
 932
 933                 GetIndexFromElement(source, groupIndex, itemIndex);
 934
 935                 if (((pListBaseImpl->_isDividerEnabled) && (pCheckElementView)) || (!pListBaseImpl->_isDividerEnabled))
 936                 {
 937                         pListBaseImpl->SetItemChecked(groupIndex, itemIndex, !pListBaseImpl->IsItemChecked(groupIndex, itemIndex));
 938                 }
 939
 940                 UpdateItemBackground(source, pListBaseImpl->_isDividerEnabled);
 941
 942                 bool elementIdEnabled = IsElementEventEnabled(source);
 943                 if (!elementIdEnabled)
 944                 {
 945                         pListBaseImpl->ProcessItemStateChange(groupIndex, itemIndex, ITEM_SELECTED);
 946                 }
 947                 else
 948                 {
 949                         pListBaseImpl->ProcessItemStateChange(groupIndex, itemIndex, pCurrentElement->GetElementId(), ITEM_SELECTED);
 950                 }
 951         }
 952         else
 953         {
 954                 UpdateItemBackground(source, pListBaseImpl->_isDividerEnabled);
 955         }
 956
 957         __isMoved = false;
 958
 959         return;
 960 }
 961
 962 _ElementBaseView*
 963 _CustomListItemImpl::GetViewById(int elementId) const
 964 {
 965         TableViewItemBase* pTableViewItemBase = null;
 966
 967         if (__pTableViewItemData)
 968         {
 969                 pTableViewItemBase = __pTableViewItemData;
 970         }
 971         else if (__pTableViewGroupItemData)
 972         {
 973                 pTableViewItemBase = __pTableViewGroupItemData;
 974         }
 975         else
 976         {
 977                 return null;
 978         }
 979
 980         _ElementBaseView* pElementBaseView = null;
 981
 982         for (int controlIndex = 0; controlIndex < pTableViewItemBase->GetControlCount(); controlIndex++)
 983         {
 984                 pElementBaseView = dynamic_cast<_ElementBaseView*>(pTableViewItemBase->GetControl(controlIndex));
 985                 SysTryReturn(NID_UI_CTRL, (pElementBaseView != null), null, E_SYSTEM, "[E_SYSTEM] Invalid Element added to item");
 986
 987                 if (pElementBaseView->GetElementId() == elementId)
 988                 {
 989                         SetLastResult(E_SUCCESS);
 990                         return pElementBaseView;
 991                 }
 992         }
 993
 994         SetLastResult(E_SYSTEM);
 995         return null;
 996 }
 997
 998 _ListBaseImpl*
 999 _CustomListItemImpl::GetListBaseImplFromElement(const Control& element)
1000 {
1001         _ElementBaseView* pCurrentElement = dynamic_cast<_ElementBaseView*>(const_cast<Control*>(&element));
1002         SysTryReturn(NID_UI_CTRL, (pCurrentElement != null), null, E_INVALID_ARG, "[E_INVALID_ARG] Invalid argument is used. source is not an element");
1003
1004         TableViewItemBase* pTableViewItemBase = dynamic_cast<TableViewItemBase*>(pCurrentElement->GetParent());
1005         SysTryReturn(NID_UI_CTRL, (pTableViewItemBase != null), null, E_SYSTEM, "[E_INVALID_ARG] Invalid argument is used. source is not an element");
1006
1007         Control* pControl = dynamic_cast<Control*>(pTableViewItemBase->GetParent());
1008         SysTryReturn(NID_UI_CTRL, (pControl != null), null, E_SYSTEM, "[E_INVALID_ARG] Invalid argument is used. source is not an element");
1009
1010         _ListBaseImpl* pListBaseImpl = static_cast<_ListBaseImpl*>(_ControlImpl::GetInstance(*pControl));
1011         SysTryReturn(NID_UI_CTRL, (pListBaseImpl != null), null, E_SYSTEM, "[E_INVALID_ARG] Invalid argument is used. source is not an element");
1012
1013         return pListBaseImpl;
1014 }
1015
1016 CustomListItem*
1017 _CustomListItemImpl::GetItemFromElement(const Control& source) const
1018 {
1019         _ElementBaseView* pCurrentElement = dynamic_cast<_ElementBaseView*>(const_cast<Control*>(&source));
1020         SysTryReturn(NID_UI_CTRL, (pCurrentElement != null), null, E_SYSTEM, "[E_SYSTEM] A system error has occurred. Failed to get element");
1021
1022         _ITableViewBaseItemData* pBaseData = dynamic_cast<_ITableViewBaseItemData*>(pCurrentElement->GetParent());
1023         SysTryReturn(NID_UI_CTRL, (pBaseData != null), null, E_SYSTEM, "[E_SYSTEM] A system error has occurred. Failed to get item.");
1024
1025         _ListBaseImpl* pListBaseImpl = GetListBaseImplFromElement(source);
1026         SysTryReturn(NID_UI_CTRL, (pListBaseImpl != null), null, E_SYSTEM, "[E_SYSTEM] A system error has occurred. Failed to get item.");
1027
1028         int groupIndex = -1;
1029         int itemIndex = -1;
1030
1031         pBaseData->GetIndex(groupIndex, itemIndex);
1032
1033         CustomListItem* pCustomListItem = pListBaseImpl->GetCustomListItemAt(groupIndex, itemIndex - pListBaseImpl->GetTopItemIndex(groupIndex));
1034         SysTryReturn(NID_UI_CTRL, (pCustomListItem != null), null, E_SYSTEM, "[E_SYSTEM] A system error has occurred. Failed to get item.");
1035
1036         return pCustomListItem;
1037 }
1038
1039 void
1040 _CustomListItemImpl::GetIndexFromElement(const Control& source, int& groupIndex, int& itemIndex) const
1041 {
1042         _ElementBaseView* pCurrentElement = dynamic_cast<_ElementBaseView*>(const_cast<Control*>(&source));
1043         SysTryReturnVoidResult(NID_UI_CTRL, (pCurrentElement != null), E_SYSTEM, "[E_SYSTEM] A system error has occurred. Failed to get element");
1044
1045         _ITableViewBaseItemData* pBaseData = dynamic_cast<_ITableViewBaseItemData*>(pCurrentElement->GetParent());
1046         SysTryReturnVoidResult(NID_UI_CTRL, (pBaseData != null), E_SYSTEM, "[E_SYSTEM] A system error has occurred. Failed to get item.");
1047
1048         _ListBaseImpl* pListBaseImpl = GetListBaseImplFromElement(source);
1049         SysTryReturnVoidResult(NID_UI_CTRL, (pListBaseImpl != null), E_SYSTEM, "[E_SYSTEM] A system error has occurred. Failed to get item.");
1050
1051         pBaseData->GetIndex(groupIndex, itemIndex);
1052 }
1053
1054 bool
1055 _CustomListItemImpl::IsElementEventEnabled(const Control& element)
1056 {
1057         CustomListItem* pCustomListItem = GetItemFromElement(element);
1058         SysTryReturn(NID_UI_CTRL, (pCustomListItem != null), false, E_SYSTEM, "[E_SYSTEM] A system error has occurred. Failed to get item.");
1059
1060         CustomListItemFormat* pFormat = pCustomListItem->__pCustomListItemFormat;
1061         SysTryReturn(NID_UI_CTRL, (pFormat != null), false, E_SYSTEM, "[E_SYSTEM] A system error has occurred. Failed to get item.");
1062
1063         _ElementBaseView* pCurrentElement = dynamic_cast<_ElementBaseView*>(const_cast<Control*>(&element));
1064         SysTryReturn(NID_UI_CTRL, (pCurrentElement != null), false, E_SYSTEM, "[E_SYSTEM] A system error has occurred. Failed to get element");
1065
1066         return pFormat->__pCustomListItemFormatImpl->IsElementEventEnabled(pCurrentElement->GetElementId());
1067 }
1068
1069 void
1070 _CustomListItemImpl::UpdateElements(const Control &source, int elementId, bool isPressed, bool isDividerEnabled)
1071 {
1072         bool elementIdEnabled = IsElementEventEnabled(source);
1073         CustomListItemStatus customListItemStatus;
1074
1075         _CheckElementView* pCheckElementView = dynamic_cast<_CheckElementView*>(const_cast<Control*>(&source));
1076
1077         if (isPressed == true)
1078         {
1079                 customListItemStatus = CUSTOM_LIST_ITEM_STATUS_FOCUSED;
1080                 StartSliding();
1081         }
1082         else
1083         {
1084                 customListItemStatus = CUSTOM_LIST_ITEM_STATUS_NORMAL;
1085                 StopSliding();
1086         }
1087
1088         int elementCount = elements.GetCount();
1089
1090         if (elementIdEnabled)
1091         {
1092                 if (pCheckElementView)
1093                 {
1094                         GetCheckElement()->HandleElementEvent(customListItemStatus);
1095                         pCheckElementView->SetPressed(isPressed);
1096                 }
1097                 else
1098                 {
1099                         _ElementBaseModel* pElementBaseModel = GetElementModelById(elementId);
1100                         SysTryReturnVoidResult(NID_UI_CTRL, (pElementBaseModel != null), E_SYSTEM, "[E_SYSTEM] A system error has occurred. Failed to get item.");
1101
1102                         pElementBaseModel->HandleElementEvent(customListItemStatus);
1103                 }
1104         }
1105         else
1106         {
1107                 if (isDividerEnabled)
1108                 {
1109                         if (pCheckElementView)
1110                         {
1111                                 GetCheckElement()->HandleElementEvent(customListItemStatus);
1112                                 pCheckElementView->SetPressed(isPressed);
1113                         }
1114                         else
1115                         {
1116                                 for (int i = 0; i < elementCount; i++)
1117                                 {
1118                                         _ElementBaseModel* pElementBase = dynamic_cast<_ElementBaseModel*>(elements.GetAt(i));
1119                                         SysTryReturnVoidResult(NID_UI_CTRL, (pElementBase != null), E_SYSTEM, "[E_SYSTEM] A system error has occurred. Failed to get element");
1120
1121                                         if (pElementBase->_elementType != LIST_ITEM_ELEMENT_TYPE_CHECKBOX)
1122                                         {
1123                                                 pElementBase->HandleElementEvent(customListItemStatus);
1124                                         }
1125                                 }
1126                         }
1127                 }
1128                 else
1129                 {
1130                         for (int i = 0; i < elementCount; i++)
1131                         {
1132                                 _ElementBaseModel* pElementBase = dynamic_cast<_ElementBaseModel*>(elements.GetAt(i));
1133                                 SysTryReturnVoidResult(NID_UI_CTRL, (pElementBase != null), E_SYSTEM, "[E_SYSTEM] A system error has occurred. Failed to get element");
1134
1135                                 pElementBase->HandleElementEvent(customListItemStatus);
1136                         }
1137                 }
1138         }
1139 }
1140
1141 void
1142 _CustomListItemImpl::UpdateItemBackground(const Control& element, bool isDividerEnabled)
1143 {
1144         TableViewItemBase* pTableViewItemBase = dynamic_cast<TableViewItemBase*>(element.GetParent());
1145         SysTryReturnVoidResult(NID_UI_CTRL, (pTableViewItemBase != null), E_SYSTEM, "[E_SYSTEM] A system error has occurred. Failed to get item.");
1146
1147         _CheckElementView* pCheckElementView = dynamic_cast<_CheckElementView*>(const_cast<Control*>(&element));
1148
1149         bool elementIdEnabled = IsElementEventEnabled(element);
1150         if (!elementIdEnabled)
1151         {
1152                 if (isDividerEnabled)
1153                 {
1154                         if (!pCheckElementView)
1155                         {
1156                                 pTableViewItemBase->SetBackgroundColor(Color(0, 0, 0, 0));
1157                         }
1158                 }
1159                 else
1160                 {
1161                         pTableViewItemBase->SetBackgroundColor(Color(0, 0, 0, 0));
1162                 }
1163         }
1164
1165         pTableViewItemBase->Invalidate(true);
1166 }
1167
1168 void
1169 _CustomListItemImpl::DeleteCustomListItem(Tizen::Base::Object* pObj)
1170 {
1171         CustomListItem* pCustomListItem = dynamic_cast<CustomListItem*>(pObj);
1172         delete pCustomListItem;
1173 }
1174
1175 }}} //Tizen::Ui::Controls