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 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_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_CoordinateSystemUtils.h"
  28 #include "FUi_ResourceManager.h"
  29 #include "FUiCtrl_GroupedListViewItemProviderAdaptor.h"
  30 #include "FUiCtrl_GroupItemImpl.h"
  31 #include "FUiCtrl_IListItemCommon.h"
  32 #include "FUiCtrl_ListItemBaseImpl.h"
  33 #include "FUiCtrl_ListViewItem.h"
  34
  35 #ifdef MEMORY_LEAK_CHECK
  36 #include "mem_leak_check.h"
  37 #endif
  38
  39 using namespace Tizen::Base;
  40
  41 namespace Tizen { namespace Ui { namespace Controls
  42 {
  43
  44 _GroupedListViewItemProviderAdaptor::_GroupedListViewItemProviderAdaptor(const IGroupedListViewItemProvider& provider)
  45         : __pGroupedListViewProvider(const_cast<IGroupedListViewItemProvider*>(&provider))
  46         , __pGroupedListViewProviderF(null)
  47         , __pEventListener(null)
  48         , __fontName(L"")
  49         , __groupItemAverageHeight(0.0f)
  50         , __itemAverageHeight(0.0f)
  51         , __groupItemLoadedCount(0)
  52         , __itemLoadedCount(0)
  53         , __countOfAllGroups(0)
  54         , __countOfAllItems(0)
  55         , __pItemNeedsLazyDeletion(null)
  56         , __pLazyDeletionItem(null)
  57         , __usingFloatingPoint(false)
  58 {
  59 }
  60
  61 _GroupedListViewItemProviderAdaptor::_GroupedListViewItemProviderAdaptor(const IGroupedListViewItemProviderF& provider)
  62         : __pGroupedListViewProvider(null)
  63         , __pGroupedListViewProviderF(const_cast<IGroupedListViewItemProviderF*>(&provider))
  64         , __pEventListener(null)
  65         , __fontName(L"")
  66         , __groupItemAverageHeight(0.0f)
  67         , __itemAverageHeight(0.0f)
  68         , __groupItemLoadedCount(0)
  69         , __itemLoadedCount(0)
  70         , __countOfAllGroups(0)
  71         , __countOfAllItems(0)
  72         , __pItemNeedsLazyDeletion(null)
  73         , __pLazyDeletionItem(null)
  74         , __usingFloatingPoint(true)
  75 {
  76 }
  77
  78 _GroupedListViewItemProviderAdaptor::~_GroupedListViewItemProviderAdaptor()
  79 {
  80         __descriptionTextShowItem.clear();
  81
  82         SetItemLazyDeletion(null);
  83 }
  84
  85 void
  86 _GroupedListViewItemProviderAdaptor::SetItemProvider(const IGroupedListViewItemProvider& provider)
  87 {
  88         __pGroupedListViewProvider = const_cast<IGroupedListViewItemProvider*>(&provider);
  89         __pGroupedListViewProviderF = null;
  90
  91         __usingFloatingPoint = false;
  92 }
  93
  94 void
  95 _GroupedListViewItemProviderAdaptor::SetItemProvider(const IGroupedListViewItemProviderF& provider)
  96 {
  97         __pGroupedListViewProvider = null;
  98         __pGroupedListViewProviderF = const_cast<IGroupedListViewItemProviderF*>(&provider);
  99
 100         __usingFloatingPoint = true;
 101 }
 102
 103 IGroupedListViewItemProvider*
 104 _GroupedListViewItemProviderAdaptor::GetItemProvider(void) const
 105 {
 106         return __pGroupedListViewProvider;
 107 }
 108
 109 IGroupedListViewItemProviderF*
 110 _GroupedListViewItemProviderAdaptor::GetItemProviderF(void) const
 111 {
 112         return __pGroupedListViewProviderF;
 113 }
 114
 115 _IListItemCommon*
 116 _GroupedListViewItemProviderAdaptor::LoadItem(int groupIndex, int itemIndex)
 117 {
 118         ListItemBase* pItemBase = null;
 119         GroupItem* pGroupItem = null;
 120         _TableViewItem* pTableViewItem = null;
 121
 122         if (itemIndex == -1)
 123         {
 124                 if (__usingFloatingPoint)
 125                 {
 126                         pGroupItem = __pGroupedListViewProviderF->CreateGroupItem(groupIndex, GetListWidth());
 127                 }
 128                 else
 129                 {
 130                         pGroupItem = __pGroupedListViewProvider->CreateGroupItem(groupIndex, _CoordinateSystemUtils::ConvertToInteger(GetListWidth()));
 131                 }
 132
 133                 if (pGroupItem == null)
 134                 {
 135                         pTableViewItem = GetDefaultItem();
 136                         pTableViewItem->SetAppInfo(null);
 137
 138                         return pTableViewItem;
 139                 }
 140         }
 141         else
 142         {
 143                 if (__usingFloatingPoint)
 144                 {
 145                         pItemBase = __pGroupedListViewProviderF->CreateItem(groupIndex, itemIndex, GetListWidth());
 146                 }
 147                 else
 148                 {
 149                         pItemBase = __pGroupedListViewProvider->CreateItem(groupIndex, itemIndex, _CoordinateSystemUtils::ConvertToInteger(GetListWidth()));
 150                 }
 151
 152                 if (pItemBase == null)
 153                 {
 154                         pTableViewItem = GetDefaultItem();
 155                         pTableViewItem->SetAppInfo(null);
 156
 157                         return pTableViewItem;
 158                 }
 159         }
 160
 161         _ListItemBaseImpl* pItemBaseImpl = null;
 162         if (itemIndex == -1)
 163         {
 164                 pItemBaseImpl = static_cast<_ListItemBaseImpl*>(_GroupItemImpl::GetInstance(*pGroupItem));
 165         }
 166         else
 167         {
 168                 pItemBaseImpl = _ListItemBaseImpl::GetInstance(*pItemBase);
 169         }
 170         SysAssert(pItemBaseImpl != null);
 171
 172         // add ListViewItem event listener
 173         pItemBaseImpl->AddListViewItemEventListener(*__pEventListener);
 174
 175         _ListViewItem* pListViewItem = pItemBaseImpl->GetListViewItem();
 176         SysAssert(pListViewItem != null);
 177
 178         pListViewItem->AddRef();
 179         pListViewItem->SetItemStyle(static_cast<TableViewAnnexStyle>(pItemBaseImpl->GetListItemAnnexStyle()));
 180         pListViewItem->SetItemWidth(GetListWidth());
 181         pListViewItem->SetFont(__fontName);
 182
 183         if (itemIndex == -1)
 184         {
 185                 pListViewItem->SetAppInfo(pGroupItem);
 186
 187                 if (__groupItemLoadedCount < __countOfAllGroups)
 188                 {
 189                         __groupItemAverageHeight = (__groupItemAverageHeight * __groupItemLoadedCount + pListViewItem->GetItemHeight()) / (__groupItemLoadedCount + 1);
 190                         __groupItemLoadedCount++;
 191                 }
 192         }
 193         else
 194         {
 195                 pListViewItem->SetAppInfo(pItemBase);
 196
 197                 if (__itemLoadedCount < __countOfAllItems)
 198                 {
 199                         __itemAverageHeight = (__itemAverageHeight * __itemLoadedCount + pListViewItem->GetItemHeight()) / (__itemLoadedCount + 1);
 200                         __itemLoadedCount++;
 201                 }
 202         }
 203
 204         if (IsDescriptionTextShown(groupIndex, itemIndex))
 205         {
 206                 pListViewItem->SetDescriptionTextShowState(true);
 207         }
 208
 209         return pListViewItem;
 210 }
 211
 212 result
 213 _GroupedListViewItemProviderAdaptor::UnloadItem(_IListItemCommon* pListItem, int groupIndex, int itemIndex)
 214 {
 215         SysTryReturn(NID_UI_CTRL, pListItem != null, E_INVALID_ARG, E_INVALID_ARG,
 216                                 "[E_INVALID_ARG] pListItem is invalid argument.");
 217
 218         _ListViewItem* pListViewItem = static_cast<_ListViewItem*>(pListItem);
 219         if (pListViewItem->GetParent() != null)
 220         {
 221                 pListViewItem->GetParent()->DetachChild(*pListViewItem);
 222         }
 223
 224         // default item case
 225         if (pListViewItem == GetDefaultItem())
 226         {
 227                 return E_SUCCESS;
 228         }
 229
 230         if (pListViewItem == __pItemNeedsLazyDeletion)
 231         {
 232                 SetItemLazyDeletion(pListViewItem);
 233         }
 234
 235         if (pListViewItem->Release() != 0)
 236         {
 237                 if (itemIndex == -1)
 238                 {
 239                         GroupItem* pGroupItem = static_cast<GroupItem*>(pListViewItem->GetAppInfo());
 240
 241                         _GroupItemImpl* pItemBaseImpl = _GroupItemImpl::GetInstance(*pGroupItem);
 242                         SysAssert(pItemBaseImpl != null);
 243
 244                         // remove ListViewItem event listener
 245                         pItemBaseImpl->RemoveListViewItemEventListener(*__pEventListener);
 246
 247                         if (__usingFloatingPoint)
 248                         {
 249                                 if (!__pGroupedListViewProviderF->DeleteGroupItem(groupIndex, pGroupItem, GetListWidth()))
 250                                 {
 251                                         delete pGroupItem;
 252                                 }
 253                         }
 254                         else
 255                         {
 256                                 if (!__pGroupedListViewProvider->DeleteGroupItem(groupIndex, pGroupItem, _CoordinateSystemUtils::ConvertToInteger(GetListWidth())))
 257                                 {
 258                                         delete pGroupItem;
 259                                 }
 260                         }
 261                 }
 262                 else
 263                 {
 264                         ListItemBase* pItemBase = static_cast<ListItemBase*>(pListViewItem->GetAppInfo());
 265
 266                         _ListItemBaseImpl* pItemBaseImpl = _ListItemBaseImpl::GetInstance(*pItemBase);
 267                         SysAssert(pItemBaseImpl != null);
 268
 269                         // remove ListViewItem event listener
 270                         pItemBaseImpl->RemoveListViewItemEventListener(*__pEventListener);
 271
 272                         if (__usingFloatingPoint)
 273                         {
 274                                 if (!__pGroupedListViewProviderF->DeleteItem(groupIndex, itemIndex, pItemBase, GetListWidth()))
 275                                 {
 276                                         delete pItemBase;
 277                                 }
 278                         }
 279                         else
 280                         {
 281                                 if (!__pGroupedListViewProvider->DeleteItem(groupIndex, itemIndex, pItemBase, _CoordinateSystemUtils::ConvertToInteger(GetListWidth())))
 282                                 {
 283                                         delete pItemBase;
 284                                 }
 285                         }
 286                 }
 287         }
 288
 289         return E_SUCCESS;
 290 }
 291
 292 result
 293 _GroupedListViewItemProviderAdaptor::DeleteItem(_IListItemCommon* pListItem, int groupIndex, int itemIndex)
 294 {
 295         SysTryReturn(NID_UI_CTRL, pListItem != null, E_INVALID_ARG, E_INVALID_ARG,
 296                                 "[E_INVALID_ARG] pListItem is invalid argument.");
 297
 298         _ListViewItem* pListViewItem = static_cast<_ListViewItem*>(pListItem);
 299         if (pListViewItem->GetParent() != null)
 300         {
 301                 pListViewItem->GetParent()->DetachChild(*pListViewItem);
 302         }
 303
 304         // default item case
 305         if (pListViewItem == GetDefaultItem())
 306         {
 307                 return E_SUCCESS;
 308         }
 309
 310         if (pListViewItem == __pItemNeedsLazyDeletion)
 311         {
 312                 SetItemLazyDeletion(pListViewItem);
 313         }
 314
 315         if (pListViewItem->Release() != 0)
 316         {
 317                 if (itemIndex == -1)
 318                 {
 319                         GroupItem* pGroupItem = static_cast<GroupItem*>(pListViewItem->GetAppInfo());
 320                         delete pGroupItem;
 321                 }
 322                 else
 323                 {
 324                         ListItemBase* pItemBase = static_cast<ListItemBase*>(pListViewItem->GetAppInfo());
 325                         delete pItemBase;
 326                 }
 327         }
 328
 329         return E_SUCCESS;
 330 }
 331
 332 bool
 333 _GroupedListViewItemProviderAdaptor::UpdateItem(_IListItemCommon* pItem, int groupIndex, int itemIndex)
 334 {
 335         _ListViewItem* pListViewItem = static_cast<_ListViewItem*>(pItem);
 336
 337         if (pListViewItem != null)
 338         {
 339                 pListViewItem->SetDescriptionTextShowState(IsDescriptionTextShown(groupIndex, itemIndex));
 340         }
 341
 342         return true;
 343 }
 344
 345 int
 346 _GroupedListViewItemProviderAdaptor::GetItemCount(int groupIndex) const
 347 {
 348         _GroupedListViewItemProviderAdaptor* pItemProviderAdaptor = const_cast<_GroupedListViewItemProviderAdaptor*>(this);
 349
 350         int itemCount = 0;
 351         if (__usingFloatingPoint)
 352         {
 353                 itemCount = __pGroupedListViewProviderF->GetItemCount(groupIndex);
 354         }
 355         else
 356         {
 357                 itemCount = __pGroupedListViewProvider->GetItemCount(groupIndex);
 358         }
 359
 360         if (__groupItemLoadedCount <= groupIndex)
 361         {
 362                 pItemProviderAdaptor->__countOfAllItems += itemCount;
 363         }
 364
 365         return itemCount;
 366 }
 367
 368 int
 369 _GroupedListViewItemProviderAdaptor::GetGroupCount(void) const
 370 {
 371         _GroupedListViewItemProviderAdaptor* pItemProviderAdaptor = const_cast<_GroupedListViewItemProviderAdaptor*>(this);
 372
 373         if (__usingFloatingPoint)
 374         {
 375                 pItemProviderAdaptor->__countOfAllGroups = __pGroupedListViewProviderF->GetGroupCount();
 376         }
 377         else
 378         {
 379                 pItemProviderAdaptor->__countOfAllGroups = __pGroupedListViewProvider->GetGroupCount();
 380         }
 381
 382         return __countOfAllGroups;
 383 }
 384
 385 float
 386 _GroupedListViewItemProviderAdaptor::GetDefaultItemHeight(void)
 387 {
 388         return __itemAverageHeight;
 389 }
 390
 391 float
 392 _GroupedListViewItemProviderAdaptor::GetDefaultGroupItemHeight(void)
 393 {
 394         return __groupItemAverageHeight;
 395 }
 396
 397 bool
 398 _GroupedListViewItemProviderAdaptor::IsReorderable(int groupIndexFrom, int groupIndexTo)
 399 {
 400         if (__usingFloatingPoint)
 401         {
 402                 return __pGroupedListViewProviderF->IsReorderable(groupIndexFrom, groupIndexTo);
 403         }
 404
 405         return __pGroupedListViewProvider->IsReorderable(groupIndexFrom, groupIndexTo);
 406 }
 407
 408 bool
 409 _GroupedListViewItemProviderAdaptor::HasSectionHeader(int groupIndex) const
 410 {
 411         return true;
 412 }
 413
 414 bool
 415 _GroupedListViewItemProviderAdaptor::HasSectionFooter(int groupIndex) const
 416 {
 417         return false;
 418 }
 419
 420 bool
 421 _GroupedListViewItemProviderAdaptor::SetDescriptionTextShowState(int groupIndex, int itemIndex, bool show)
 422 {
 423         _ListItemPos descriptionTextPos = {groupIndex, itemIndex};
 424         int idxDescriptionTextGroup = -1;
 425         int idxDescriptionTextItem = -1;
 426
 427         _LinkedList <_ListItemPos>::_Iterator theIter = __descriptionTextShowItem.begin();
 428         while (theIter != __descriptionTextShowItem.end())
 429         {
 430                 idxDescriptionTextGroup = theIter->groupIndex;
 431                 idxDescriptionTextItem = theIter->itemIndex;
 432
 433                 if (idxDescriptionTextGroup == groupIndex)
 434                 {
 435                         if (idxDescriptionTextItem == itemIndex)
 436                         {
 437                                 if (show == false)
 438                                 {
 439                                         __descriptionTextShowItem.erase(theIter);
 440                                 }
 441                                 return true;
 442                         }
 443                         else if (idxDescriptionTextItem > itemIndex)
 444                         {
 445                                 if (show == true)
 446                                 {
 447                                         __descriptionTextShowItem.insert(theIter, descriptionTextPos);
 448                                 }
 449                                 return true;
 450                         }
 451                 }
 452
 453                 if (idxDescriptionTextGroup > groupIndex)
 454                 {
 455                         if (show == true)
 456                         {
 457                                 __descriptionTextShowItem.insert(theIter, descriptionTextPos);
 458                         }
 459                         return true;
 460                 }
 461
 462                 theIter++;
 463         }
 464
 465         if (show == true)
 466         {
 467                 __descriptionTextShowItem.push_back(descriptionTextPos);
 468         }
 469
 470         return true;
 471 }
 472
 473 bool
 474 _GroupedListViewItemProviderAdaptor::IsDescriptionTextShown(int groupIndex, int itemIndex) const
 475 {
 476         int idxDescriptionTextGroup = -1;
 477         int idxDescriptionTextItem = -1;
 478
 479         _LinkedList <_ListItemPos>::_Iterator theIter = __descriptionTextShowItem.begin();
 480         while (theIter != __descriptionTextShowItem.end())
 481         {
 482                 idxDescriptionTextGroup = theIter->groupIndex;
 483                 idxDescriptionTextItem = theIter->itemIndex;
 484
 485                 if (idxDescriptionTextGroup == groupIndex)
 486                 {
 487                         if (idxDescriptionTextItem == itemIndex)
 488                         {
 489                                 return true;
 490                         }
 491                         else if (idxDescriptionTextItem > itemIndex)
 492                         {
 493                                 return false;
 494                         }
 495                 }
 496                 else if (idxDescriptionTextGroup > groupIndex)
 497                 {
 498                         return false;
 499                 }
 500
 501                 theIter++;
 502         }
 503
 504         return false;
 505 }
 506
 507 void
 508 _GroupedListViewItemProviderAdaptor::SetListViewItemEventListener(_IUiListViewItemEventListener& listener)
 509 {
 510         __pEventListener = &listener;
 511 }
 512
 513 void
 514 _GroupedListViewItemProviderAdaptor::SetItemFont(const String& fontName)
 515 {
 516         __fontName = fontName;
 517 }
 518
 519 void
 520 _GroupedListViewItemProviderAdaptor::SetItemNeedsLazyDeletion(_ListViewItem* pItem)
 521 {
 522         __pItemNeedsLazyDeletion = pItem;
 523 }
 524
 525 void
 526 _GroupedListViewItemProviderAdaptor::SetItemLazyDeletion(_ListViewItem* pItem)
 527 {
 528         if (__pLazyDeletionItem != pItem)
 529         {
 530                 if (__pLazyDeletionItem != null)
 531                 {
 532                         __pLazyDeletionItem->Release();
 533                 }
 534                 if (pItem != null)
 535                 {
 536                         pItem->AddRef();
 537                 }
 538
 539                 __pLazyDeletionItem = pItem;
 540         }
 541 }
 542
 543 }}} // Tizen::Ui::Controls