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