src/ui/controls/FUiCtrl_GroupedListViewItemProviderAdaptor.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_GroupedListViewItemProviderAdaptor.cpp
  20  * @brief       This is the implementation file for _GroupedListViewItemProviderAdaptor class.
  21  *
  22  * This file contains the implementation of _GroupedListViewItemProviderAdaptor class.
  23  */
  24
  25 #include <FUiCtrlGroupItem.h>
  26 #include <FUiCtrlListItemBase.h>
  27 #include "FUi_ResourceManager.h"
  28 #include "FUiCtrl_GroupedListViewItemProviderAdaptor.h"
  29 #include "FUiCtrl_GroupItemImpl.h"
  30 #include "FUiCtrl_IListItemCommon.h"
  31 #include "FUiCtrl_ListItemBaseImpl.h"
  32 #include "FUiCtrl_ListViewItem.h"
  33
  34 #ifdef MEMORY_LEAK_CHECK
  35 #include "mem_leak_check.h"
  36 #endif
  37
  38 using namespace Tizen::Base;
  39
  40 namespace Tizen { namespace Ui { namespace Controls
  41 {
  42
  43 _GroupedListViewItemProviderAdaptor::_GroupedListViewItemProviderAdaptor(const IGroupedListViewItemProvider& provider)
  44         : __pGroupedListViewProvider(const_cast<IGroupedListViewItemProvider*>(&provider))
  45         , __pEventListener(null)
  46         , __fontName(L"")
  47         , __groupItemAverageHeight(0)
  48         , __itemAverageHeight(0)
  49         , __groupItemLoadedCount(0)
  50         , __itemLoadedCount(0)
  51         , __countOfAllGroups(0)
  52         , __countOfAllItems(0)
  53         , __pItemNeedsLazyDeletion(null)
  54 {
  55 }
  56
  57 _GroupedListViewItemProviderAdaptor::~_GroupedListViewItemProviderAdaptor()
  58 {
  59         __descriptionTextShowItem.clear();
  60
  61         SetItemNeedsLazyDeletion(null);
  62 }
  63
  64 void
  65 _GroupedListViewItemProviderAdaptor::SetItemProvider(const IGroupedListViewItemProvider& provider)
  66 {
  67         __pGroupedListViewProvider = const_cast<IGroupedListViewItemProvider*>(&provider);
  68 }
  69
  70 _IListItemCommon*
  71 _GroupedListViewItemProviderAdaptor::LoadItem(int groupIndex, int itemIndex)
  72 {
  73         ListItemBase* pItemBase = null;
  74         GroupItem* pGroupItem = null;
  75         _TableViewItem* pTableViewItem = null;
  76
  77         if (itemIndex == -1)
  78         {
  79                 pGroupItem = __pGroupedListViewProvider->CreateGroupItem(groupIndex, GetListWidth());
  80                 if (pGroupItem == null)
  81                 {
  82                         pTableViewItem = GetDefaultItem();
  83                         pTableViewItem->SetAppInfo(null);
  84
  85                         return pTableViewItem;
  86                 }
  87         }
  88         else
  89         {
  90                 pItemBase = __pGroupedListViewProvider->CreateItem(groupIndex, itemIndex, GetListWidth());
  91                 if (pItemBase == null)
  92                 {
  93                         pTableViewItem = GetDefaultItem();
  94                         pTableViewItem->SetAppInfo(null);
  95
  96                         return pTableViewItem;
  97                 }
  98         }
  99
 100         _ListItemBaseImpl* pItemBaseImpl = null;
 101         if (itemIndex == -1)
 102         {
 103                 pItemBaseImpl = static_cast<_ListItemBaseImpl*>(_GroupItemImpl::GetInstance(*pGroupItem));
 104         }
 105         else
 106         {
 107                 pItemBaseImpl = _ListItemBaseImpl::GetInstance(*pItemBase);
 108         }
 109         SysAssert(pItemBaseImpl != null);
 110
 111         // add ListViewItem event listener
 112         pItemBaseImpl->AddListViewItemEventListener(*__pEventListener);
 113
 114         _ListViewItem* pListViewItem = pItemBaseImpl->GetListViewItem();
 115         SysAssert(pListViewItem != null);
 116
 117         pListViewItem->SetFont(__fontName);
 118         pListViewItem->AddRef();
 119         pListViewItem->SetItemStyle(static_cast<TableViewAnnexStyle>(pItemBaseImpl->GetListItemAnnexStyle()));
 120         pListViewItem->SetItemWidth(GetListWidth());
 121
 122         if (itemIndex == -1)
 123         {
 124                 pListViewItem->SetAppInfo(pGroupItem);
 125
 126                 if (__groupItemLoadedCount < __countOfAllGroups)
 127                 {
 128                         __groupItemAverageHeight = (__groupItemAverageHeight * __groupItemLoadedCount + pListViewItem->GetItemHeight()) / (__groupItemLoadedCount + 1);
 129                         __groupItemLoadedCount++;
 130                 }
 131         }
 132         else
 133         {
 134                 pListViewItem->SetAppInfo(pItemBase);
 135
 136                 if (__itemLoadedCount < __countOfAllItems)
 137                 {
 138                         __itemAverageHeight = (__itemAverageHeight * __itemLoadedCount + pListViewItem->GetItemHeight()) / (__itemLoadedCount + 1);
 139                         __itemLoadedCount++;
 140                 }
 141         }
 142
 143         if (IsDescriptionTextShown(groupIndex, itemIndex) == true)
 144         {
 145                 pListViewItem->SetDescriptionTextShowState(true);
 146         }
 147
 148         return pListViewItem;
 149 }
 150
 151 result
 152 _GroupedListViewItemProviderAdaptor::UnloadItem(_IListItemCommon* pListItem, int groupIndex, int itemIndex)
 153 {
 154         SysTryReturn(NID_UI_CTRL, pListItem != null, E_INVALID_ARG, E_INVALID_ARG,
 155                                 "[E_INVALID_ARG] pListItem is invalid argument.");
 156
 157         _ListViewItem* pListViewItem = static_cast<_ListViewItem*>(pListItem);
 158         if (pListViewItem->GetParent() != null)
 159         {
 160                 pListViewItem->GetParent()->DetachChild(*pListViewItem);
 161         }
 162
 163         // default item case
 164         if (pListViewItem == GetDefaultItem())
 165         {
 166                 return E_SUCCESS;
 167         }
 168
 169         if (pListViewItem == __pItemNeedsLazyDeletion)
 170         {
 171                 pListViewItem->AddRef();
 172         }
 173
 174         if (pListViewItem->Release() != 0)
 175         {
 176                 if (itemIndex == -1)
 177                 {
 178                         GroupItem* pGroupItem = static_cast<GroupItem*>(pListViewItem->GetAppInfo());
 179                         if (__pGroupedListViewProvider->DeleteGroupItem(groupIndex, pGroupItem, GetListWidth()) == false)
 180                         {
 181                                 delete pGroupItem;
 182                         }
 183                 }
 184                 else
 185                 {
 186                         ListItemBase* pItemBase = static_cast<ListItemBase*>(pListViewItem->GetAppInfo());
 187                         if (__pGroupedListViewProvider->DeleteItem(groupIndex, itemIndex, pItemBase, GetListWidth()) == false)
 188                         {
 189                                 delete pItemBase;
 190                         }
 191                 }
 192         }
 193
 194         return E_SUCCESS;
 195 }
 196
 197 result
 198 _GroupedListViewItemProviderAdaptor::DeleteItem(_IListItemCommon* pListItem, int groupIndex, int itemIndex)
 199 {
 200         SysTryReturn(NID_UI_CTRL, pListItem != null, E_INVALID_ARG, E_INVALID_ARG,
 201                                 "[E_INVALID_ARG] pListItem is invalid argument.");
 202
 203         _ListViewItem* pListViewItem = static_cast<_ListViewItem*>(pListItem);
 204         if (pListViewItem->GetParent() != null)
 205         {
 206                 pListViewItem->GetParent()->DetachChild(*pListViewItem);
 207         }
 208
 209         // default item case
 210         if (pListViewItem == GetDefaultItem())
 211         {
 212                 return E_SUCCESS;
 213         }
 214
 215         if (pListViewItem == __pItemNeedsLazyDeletion)
 216         {
 217                 pListViewItem->AddRef();
 218         }
 219
 220         if (pListViewItem->Release() != 0)
 221         {
 222                 if (itemIndex == -1)
 223                 {
 224                         GroupItem* pGroupItem = static_cast<GroupItem*>(pListViewItem->GetAppInfo());
 225                         delete pGroupItem;
 226                 }
 227                 else
 228                 {
 229                         ListItemBase* pItemBase = static_cast<ListItemBase*>(pListViewItem->GetAppInfo());
 230                         delete pItemBase;
 231                 }
 232         }
 233
 234         return E_SUCCESS;
 235 }
 236
 237 bool
 238 _GroupedListViewItemProviderAdaptor::UpdateItem(_IListItemCommon* pItem, int groupIndex, int itemIndex)
 239 {
 240         _ListViewItem* pListViewItem = static_cast<_ListViewItem*>(pItem);
 241
 242         if (pListViewItem != null)
 243         {
 244                 pListViewItem->SetDescriptionTextShowState(IsDescriptionTextShown(groupIndex, itemIndex));
 245         }
 246
 247         return true;
 248 }
 249
 250 int
 251 _GroupedListViewItemProviderAdaptor::GetItemCount(int groupIndex) const
 252 {
 253         _GroupedListViewItemProviderAdaptor* pItemProviderAdaptor = const_cast<_GroupedListViewItemProviderAdaptor*>(this);
 254         int itemCount = __pGroupedListViewProvider->GetItemCount(groupIndex);
 255
 256         if (__groupItemLoadedCount <= groupIndex)
 257         {
 258                 pItemProviderAdaptor->__countOfAllItems += itemCount;
 259         }
 260
 261         return itemCount;
 262 }
 263
 264 int
 265 _GroupedListViewItemProviderAdaptor::GetGroupCount(void) const
 266 {
 267         _GroupedListViewItemProviderAdaptor* pItemProviderAdaptor = const_cast<_GroupedListViewItemProviderAdaptor*>(this);
 268         pItemProviderAdaptor->__countOfAllGroups = __pGroupedListViewProvider->GetGroupCount();
 269
 270         return __countOfAllGroups;
 271 }
 272
 273 int
 274 _GroupedListViewItemProviderAdaptor::GetDefaultItemHeight(void)
 275 {
 276         return __itemAverageHeight;
 277 }
 278
 279 int
 280 _GroupedListViewItemProviderAdaptor::GetDefaultGroupItemHeight(void)
 281 {
 282         return __groupItemAverageHeight;
 283 }
 284
 285 bool
 286 _GroupedListViewItemProviderAdaptor::IsReorderable(int groupIndexFrom, int groupIndexTo)
 287 {
 288         return __pGroupedListViewProvider->IsReorderable(groupIndexFrom, groupIndexTo);
 289 }
 290
 291 bool
 292 _GroupedListViewItemProviderAdaptor::HasSectionHeader(int groupIndex) const
 293 {
 294         return true;
 295 }
 296
 297 bool
 298 _GroupedListViewItemProviderAdaptor::HasSectionFooter(int groupIndex) const
 299 {
 300         return false;
 301 }
 302
 303 bool
 304 _GroupedListViewItemProviderAdaptor::SetDescriptionTextShowState(int groupIndex, int itemIndex, bool show)
 305 {
 306         _ListItemPos descriptionTextPos = {groupIndex, itemIndex};
 307         int idxDescriptionTextGroup = -1;
 308         int idxDescriptionTextItem = -1;
 309
 310         _LinkedList <_ListItemPos>::_Iterator theIter = __descriptionTextShowItem.begin();
 311         while (theIter != __descriptionTextShowItem.end())
 312         {
 313                 idxDescriptionTextGroup = theIter->groupIndex;
 314                 idxDescriptionTextItem = theIter->itemIndex;
 315
 316                 if (idxDescriptionTextGroup == groupIndex)
 317                 {
 318                         if (idxDescriptionTextItem == itemIndex)
 319                         {
 320                                 if (show == false)
 321                                 {
 322                                         __descriptionTextShowItem.erase(theIter);
 323                                 }
 324                                 return true;
 325                         }
 326                         else if (idxDescriptionTextItem > itemIndex)
 327                         {
 328                                 if (show == true)
 329                                 {
 330                                         __descriptionTextShowItem.insert(theIter, descriptionTextPos);
 331                                 }
 332                                 return true;
 333                         }
 334                 }
 335
 336                 if (idxDescriptionTextGroup > groupIndex)
 337                 {
 338                         if (show == true)
 339                         {
 340                                 __descriptionTextShowItem.insert(theIter, descriptionTextPos);
 341                         }
 342                         return true;
 343                 }
 344
 345                 theIter++;
 346         }
 347
 348         if (show == true)
 349         {
 350                 __descriptionTextShowItem.push_back(descriptionTextPos);
 351         }
 352
 353         return true;
 354 }
 355
 356 bool
 357 _GroupedListViewItemProviderAdaptor::IsDescriptionTextShown(int groupIndex, int itemIndex) const
 358 {
 359         int idxDescriptionTextGroup = -1;
 360         int idxDescriptionTextItem = -1;
 361
 362         _LinkedList <_ListItemPos>::_Iterator theIter = __descriptionTextShowItem.begin();
 363         while (theIter != __descriptionTextShowItem.end())
 364         {
 365                 idxDescriptionTextGroup = theIter->groupIndex;
 366                 idxDescriptionTextItem = theIter->itemIndex;
 367
 368                 if (idxDescriptionTextGroup == groupIndex)
 369                 {
 370                         if (idxDescriptionTextItem == itemIndex)
 371                         {
 372                                 return true;
 373                         }
 374                         else if (idxDescriptionTextItem > itemIndex)
 375                         {
 376                                 return false;
 377                         }
 378                 }
 379                 else if (idxDescriptionTextGroup > groupIndex)
 380                 {
 381                         return false;
 382                 }
 383
 384                 theIter++;
 385         }
 386
 387         return false;
 388 }
 389
 390 void
 391 _GroupedListViewItemProviderAdaptor::SetListViewItemEventListener(_IUiListViewItemEventListener& listener)
 392 {
 393         __pEventListener = &listener;
 394 }
 395
 396 void
 397 _GroupedListViewItemProviderAdaptor::SetItemFont(const String& fontName)
 398 {
 399         __fontName = fontName;
 400 }
 401
 402 void
 403 _GroupedListViewItemProviderAdaptor::SetItemNeedsLazyDeletion(_ListViewItem* pItem)
 404 {
 405         if (__pItemNeedsLazyDeletion != pItem)
 406         {
 407                 if (__pItemNeedsLazyDeletion != null)
 408                 {
 409                         __pItemNeedsLazyDeletion->Release();
 410                 }
 411
 412                 __pItemNeedsLazyDeletion = pItem;
 413         }
 414 }
 415 }}} // Tizen::Ui::Controls