src/ui/controls/FUiCtrl_TableViewItemProviderAdaptor.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_TableViewItemProviderAdaptor.cpp
  20  * @brief       This is the implementation file for _TableViewItemProviderAdaptor class.
  21  *
  22  * This file contains the implementation of _TableViewItemProviderAdaptor class.
  23  */
  24
  25 #include <FUi_ResourceManager.h>
  26 #include <FUiCtrlTableViewItem.h>
  27 #include <FUiCtrlTableViewGroupItem.h>
  28 #include "FUiCtrl_TableViewItemProviderAdaptor.h"
  29 #include "FUiCtrl_TableViewItem.h"
  30 #include "FUiCtrl_TableViewItemProvider.h"
  31 #include "FUiCtrl_TableViewPresenter.h"
  32 #include "FUiCtrl_TableViewItemImpl.h"
  33 #include "FUiCtrl_ListViewModel.h"
  34 #include "FUiCtrl_IListItemCommon.h"
  35 #include "FUiCtrl_LabelImpl.h"
  36 #include "FUi_CoordinateSystemUtils.h"
  37
  38 using namespace Tizen::Graphics;
  39
  40 namespace Tizen { namespace Ui { namespace Controls
  41 {
  42
  43 _TableViewItemProviderAdaptor::_TableViewItemProviderAdaptor()
  44         : __pTableViewProvider(null)
  45         , __pDefaultItem(null)
  46         , __pTableViewPresenter(null)
  47         , __listWidth(0.0f)
  48         , __style(0)
  49 {
  50 }
  51
  52 _TableViewItemProviderAdaptor::~_TableViewItemProviderAdaptor()
  53 {
  54         delete __pDefaultItem;
  55         __pDefaultItem = null;
  56
  57         delete __pTableViewProvider;
  58         __pTableViewProvider = null;
  59 }
  60
  61 void
  62 _TableViewItemProviderAdaptor::SetItemProvider(_TableViewItemProvider* pProvider)
  63 {
  64         if (__pTableViewProvider != pProvider)
  65         {
  66                 delete __pTableViewProvider;
  67         }
  68
  69         __pTableViewProvider = pProvider;
  70 }
  71
  72 bool
  73 _TableViewItemProviderAdaptor::IsItemProvider() const
  74 {
  75         if (__pTableViewProvider != null)
  76         {
  77                 return true;
  78         }
  79         else
  80         {
  81                 return false;
  82         }
  83 }
  84
  85 int
  86 _TableViewItemProviderAdaptor::GetItemCount(int groupIndex) const
  87 {
  88         SysTryReturn(NID_UI_CTRL, __pTableViewProvider != null, 0, E_INVALID_OPERATION, "[E_INVALID_OPERATION] This instance has not provider.");
  89
  90         if (__style == TABLE_VIEW_STYLE_SECTION)
  91         {
  92                 if (__pTableViewProvider->HasSectionFooter(groupIndex) == true)
  93                 {
  94                         return __pTableViewProvider->GetItemCount(groupIndex) + 1;
  95                 }
  96         }
  97
  98         return __pTableViewProvider->GetItemCount(groupIndex);
  99 }
 100
 101 int
 102 _TableViewItemProviderAdaptor::GetGroupCount(void) const
 103 {
 104         SysTryReturn(NID_UI_CTRL, __pTableViewProvider != null, 0, E_INVALID_OPERATION, "[E_INVALID_OPERATION] This instance has not provider.");
 105
 106         if (__style == TABLE_VIEW_STYLE_SIMPLE)
 107         {
 108                 return 1;
 109         }
 110
 111         return __pTableViewProvider->GetGroupCount();
 112 }
 113
 114 _IListItemCommon*
 115 _TableViewItemProviderAdaptor::LoadItem(int groupIndex, int itemIndex)
 116 {
 117         SysTryReturn(NID_UI_CTRL, __pTableViewProvider != null, null, E_SYSTEM, "[E_SYSTEM] This instance isn't constructed.");
 118
 119         TableViewItem* pItem = null;
 120         TableViewGroupItem* pGroupItem = null;
 121         TableViewItemTag index = {groupIndex, itemIndex};
 122
 123 //      Label* pLabel = null;
 124
 125         if (itemIndex == -1)
 126         {
 127                 if (__style == TABLE_VIEW_STYLE_SIMPLE)
 128                 {
 129                         GetDefaultItem()->SetItemHeight(0);
 130                         return GetDefaultItem();
 131                 }
 132                 else if (__style == TABLE_VIEW_STYLE_GROUPED)
 133                 {
 134                         pGroupItem = __pTableViewProvider->CreateGroupItem(groupIndex, __listWidth);
 135
 136                         if (pGroupItem == null)
 137                         {
 138                                 GetDefaultItem()->SetAppInfo(null);
 139                                 return __pDefaultItem;
 140                         }
 141                 }
 142                 else // (__style == TABLE_VIEW_STYLE_SECTION)
 143                 {
 144                         if (!HasSectionHeader(groupIndex))
 145                         {
 146                                 _TableViewItem* pHeaderItem = _TableViewItem::CreateTableViewItemN(0);
 147                                 if (pHeaderItem == null)
 148                                 {
 149                                         GetDefaultItem()->SetAppInfo(null);
 150                                         return __pDefaultItem;
 151                                 }
 152
 153                                 return pHeaderItem;
 154                         }
 155
 156                         pGroupItem = new (std::nothrow) TableViewGroupItem();
 157                         if (pGroupItem == null)
 158                         {
 159                                 GetDefaultItem()->SetAppInfo(null);
 160                                 return __pDefaultItem;
 161                         }
 162
 163                         float itemHeight = 0.0f;
 164                         GET_SHAPE_CONFIG(TABLEVIEW::GROUPITEM_DEFAULT_HEIGHT, _CONTROL_ORIENTATION_PORTRAIT, itemHeight);
 165
 166                         pGroupItem->Construct(FloatDimension(__listWidth, itemHeight));
 167
 168                         _TableViewItemImpl* pImpl = _TableViewItemImpl::GetInstance(*pGroupItem);
 169                         if (pImpl != null)
 170                         {
 171                                 _TableViewItem* pItemCore = &pImpl->GetCore();
 172                                 if (pItemCore != null)
 173                                 {
 174                                         Tizen::Base::String contents = __pTableViewProvider->GetSectionHeader(groupIndex);
 175                                         HorizontalAlignment contentsAlignment = __pTableViewPresenter->GetSectionHeaderTextHorizontalAlignment(groupIndex);
 176                                         pItemCore->SetSectionHeaderFooterContents(contents, contentsAlignment, true);
 177                                 }
 178                         }
 179                 }
 180         }
 181         else if ((__style == TABLE_VIEW_STYLE_SECTION) && (itemIndex == __pTableViewPresenter->GetItemCountAt(groupIndex) - 1) && HasSectionFooter(groupIndex))
 182         {
 183                 pItem = new (std::nothrow) TableViewItem();
 184                 if (pItem == null)
 185                 {
 186                         GetDefaultItem()->SetAppInfo(null);
 187                         return __pDefaultItem;
 188                 }
 189
 190                 float itemHeight = 0.0f;
 191                 GET_SHAPE_CONFIG(TABLEVIEW::GROUPITEM_DEFAULT_HEIGHT, _CONTROL_ORIENTATION_PORTRAIT, itemHeight);
 192
 193                 pItem->Construct(FloatDimension(__listWidth, itemHeight));
 194
 195                 _TableViewItemImpl* pImpl = _TableViewItemImpl::GetInstance(*pItem);
 196                 if (pImpl != null)
 197                 {
 198                         _TableViewItem* pItemCore = &pImpl->GetCore();
 199                         if (pItemCore != null)
 200                         {
 201                                 Tizen::Base::String contents = __pTableViewProvider->GetSectionFooter(groupIndex);
 202                                 HorizontalAlignment contentsAlignment = __pTableViewPresenter->GetSectionFooterTextHorizontalAlignment(groupIndex);
 203                                 pItemCore->SetSectionHeaderFooterContents(contents, contentsAlignment, false);
 204                         }
 205                 }
 206         }
 207         else
 208         {
 209                 pItem = __pTableViewProvider->CreateItem(index, __listWidth);
 210
 211                 if (pItem == null)
 212                 {
 213                         GetDefaultItem()->SetAppInfo(null);
 214                         return __pDefaultItem;
 215                 }
 216         }
 217
 218         _TableViewItem* pItemCore = null;
 219         _TableViewItemImpl* pImpl = null;
 220         if (itemIndex == -1)
 221         {
 222                 if ((pImpl = _TableViewItemImpl::GetInstance(*pGroupItem)) == null)
 223                 {
 224                         if (!(__pTableViewProvider->DeleteGroupItem(groupIndex, pGroupItem)))
 225                         {
 226                                 delete pGroupItem;
 227                                 pGroupItem = null;
 228                         }
 229
 230                         GetDefaultItem()->SetAppInfo(null);
 231                         return __pDefaultItem;
 232                 }
 233                 else
 234                 {
 235                         pItemCore = &pImpl->GetCore();
 236                 }
 237         }
 238         else
 239         {
 240                 if ((pImpl = _TableViewItemImpl::GetInstance(*pItem)) == null)
 241                 {
 242                         if (!(__pTableViewProvider->DeleteItem(index, pItem)))
 243                         {
 244                                 delete pItem;
 245                                 pItem = null;
 246                         }
 247
 248                         GetDefaultItem()->SetAppInfo(null);
 249                         return __pDefaultItem;
 250                 }
 251                 else
 252                 {
 253                         pItemCore = &pImpl->GetCore();
 254                 }
 255         }
 256
 257         if (pItemCore == null)
 258         {
 259                 if (itemIndex == -1)
 260                 {
 261                         if ((__pTableViewProvider->DeleteGroupItem(groupIndex, pGroupItem)) == false)
 262                         {
 263                                 delete pGroupItem;
 264                                 pGroupItem = null;
 265                         }
 266                 }
 267                 else
 268                 {
 269                         if ((__pTableViewProvider->DeleteItem(index, pItem)) == false)
 270                         {
 271                                 delete pItem;
 272                                 pItem = null;
 273                         }
 274                 }
 275
 276                 GetDefaultItem()->SetAppInfo(null);
 277                 return __pDefaultItem;
 278         }
 279
 280         if (itemIndex == -1)
 281         {
 282                 pItemCore->SetAppInfo(pGroupItem);
 283         }
 284         else
 285         {
 286                 pItemCore->SetAppInfo(pItem);
 287         }
 288
 289         return pItemCore;
 290 }
 291
 292 result
 293 _TableViewItemProviderAdaptor::UnloadItem(_IListItemCommon* pItemCore, int groupIndex, int itemIndex)
 294 {
 295         SysTryReturn(NID_UI_CTRL, __pTableViewProvider != null, E_INVALID_OPERATION, E_INVALID_OPERATION, "[E_INVALID_OPERATION] This instance has not provider.");
 296         SysTryReturn(NID_UI_CTRL, pItemCore != null, E_INVALID_ARG, E_INVALID_ARG, "[E_INVALID_ARG] pItemCore is invalid argument.");
 297
 298         TableViewItem* pItem = static_cast <TableViewItem*>(pItemCore->GetAppInfo());
 299         TableViewItemTag index = {groupIndex, itemIndex};
 300
 301         _TableViewItem* pCoreItem = static_cast <_TableViewItem*>(pItemCore);
 302         if (pCoreItem->GetParent() != null)
 303         {
 304                 pCoreItem->GetParent()->DetachChild(*pCoreItem);
 305         }
 306
 307         // default item case
 308         if (pItem == null)
 309         {
 310                 return E_SUCCESS;
 311         }
 312
 313 //      if (pItem->GetParent() != null)
 314 //      {
 315 //              pItem->GetParent()->RemoveControl(*pItem);
 316 //      }
 317
 318 //      pItemCore->Release();
 319
 320         pItemCore->SetAppInfo(null);
 321         if (itemIndex == -1)
 322         {
 323                 if (__pTableViewProvider->DeleteGroupItem(groupIndex, (TableViewGroupItem*) pItem) == false)
 324                 {
 325                         delete pItem;
 326                         pItem = null;
 327                 }
 328         }
 329         else
 330         {
 331                 if (__pTableViewProvider->DeleteItem(index, pItem) == false)
 332                 {
 333                         delete pItem;
 334                         pItem = null;
 335                 }
 336         }
 337
 338         return E_SUCCESS;
 339 }
 340
 341 result
 342 _TableViewItemProviderAdaptor::DeleteItem(_IListItemCommon* pItemCore, int groupIndex, int itemIndex)
 343 {
 344         SysTryReturn(NID_UI_CTRL, __pTableViewProvider != null, E_INVALID_OPERATION, E_INVALID_OPERATION, "[E_INVALID_OPERATION] This instance has not provider.");
 345         SysTryReturn(NID_UI_CTRL, pItemCore != null, E_INVALID_ARG, E_INVALID_ARG, "[E_INVALID_ARG] pItemCore is invalid argument.");
 346
 347         TableViewItem* pItem = static_cast <TableViewItem*>(pItemCore->GetAppInfo());
 348
 349         _TableViewItem* pCoreItem = static_cast <_TableViewItem*>(pItemCore);
 350         if (pCoreItem->GetParent() != null)
 351         {
 352                 pCoreItem->GetParent()->DetachChild(*pCoreItem);
 353         }
 354
 355         // default item case
 356         if (pItem == null)
 357         {
 358                 return E_SUCCESS;
 359         }
 360
 361 //      pItemCore->Release();
 362
 363         delete pItem;
 364         pItem = null;
 365
 366         return E_SUCCESS;
 367 }
 368
 369 bool
 370 _TableViewItemProviderAdaptor::UpdateItem(_IListItemCommon* pItemCore, int groupIndex, int itemIndex)
 371 {
 372         SysTryReturn(NID_UI_CTRL, __pTableViewProvider != null, false, E_INVALID_OPERATION, "[E_INVALID_OPERATION] This instance has not provider.");
 373
 374         TableViewItemTag itemTag = {groupIndex, itemIndex};
 375         bool ret = false;
 376
 377         if (itemIndex == -1)
 378         {
 379                 TableViewGroupItem* pItem = static_cast <TableViewGroupItem*>(pItemCore->GetAppInfo());
 380
 381                 if (pItem != null)
 382                 {
 383                         ret = __pTableViewProvider->UpdateGroupItem(itemTag.groupIndex, pItem);
 384                 }
 385         }
 386         else
 387         {
 388                 TableViewItem* pItem = static_cast <TableViewItem*>(pItemCore->GetAppInfo());
 389
 390                 if (pItem != null)
 391                 {
 392                         ret = __pTableViewProvider->UpdateItem(itemTag, pItem);
 393                 }
 394         }
 395
 396         return ret;
 397 }
 398
 399 result
 400 _TableViewItemProviderAdaptor::SetListWidth(float width)
 401 {
 402         __listWidth = width;
 403
 404         return E_SUCCESS;
 405 }
 406
 407 float
 408 _TableViewItemProviderAdaptor::GetListWidth(void)
 409 {
 410         return __listWidth;
 411 }
 412
 413 result
 414 _TableViewItemProviderAdaptor::SetTableViewStyle(int style)
 415 {
 416         __style = style;
 417
 418         return E_SUCCESS;
 419 }
 420
 421 void
 422 _TableViewItemProviderAdaptor::SetTableViewPresenter(_TableViewPresenter* pPresenter)
 423 {
 424         __pTableViewPresenter = pPresenter;
 425 }
 426
 427 bool
 428 _TableViewItemProviderAdaptor::HasSectionHeader(int groupIndex) const
 429 {
 430         SysTryReturn(NID_UI_CTRL, __pTableViewProvider != null, false, E_INVALID_OPERATION, "[E_INVALID_OPERATION] This instance has not provider.");
 431
 432         return __pTableViewProvider->HasSectionHeader(groupIndex);
 433 }
 434
 435 bool
 436 _TableViewItemProviderAdaptor::HasSectionFooter(int groupIndex) const
 437 {
 438         SysTryReturn(NID_UI_CTRL, __pTableViewProvider != null, false, E_INVALID_OPERATION, "[E_INVALID_OPERATION] This instance has not provider.");
 439
 440         return __pTableViewProvider->HasSectionFooter(groupIndex);
 441 }
 442
 443 float
 444 _TableViewItemProviderAdaptor::GetItemHeight(int groupIndex, int itemIndex)
 445 {
 446         SysTryReturn(NID_UI_CTRL, __pTableViewProvider != null, 0, E_INVALID_OPERATION, "[E_INVALID_OPERATION] This instance has not provider.");
 447
 448         float itemHeight = 0.0f;
 449
 450         if (itemIndex == -1)
 451         {
 452                 itemHeight = __pTableViewProvider->GetGroupItemHeight(groupIndex);
 453         }
 454         else
 455         {
 456                 TableViewItemTag itemTag = {groupIndex, itemIndex};
 457                 itemHeight = __pTableViewProvider->GetItemHeight(itemTag);
 458         }
 459
 460         return itemHeight;
 461 }
 462
 463 float
 464 _TableViewItemProviderAdaptor::GetDefaultItemHeight(void)
 465 {
 466         SysTryReturn(NID_UI_CTRL, __pTableViewProvider != null, 0, E_INVALID_OPERATION, "[E_INVALID_OPERATION] This instance has not provider.");
 467
 468         return __pTableViewProvider->GetDefaultItemHeight();
 469 }
 470
 471 float
 472 _TableViewItemProviderAdaptor::GetDefaultGroupItemHeight(void)
 473 {
 474         SysTryReturn(NID_UI_CTRL, __pTableViewProvider != null, 0, E_INVALID_OPERATION, "[E_INVALID_OPERATION] This instance has not provider.");
 475
 476         return __pTableViewProvider->GetDefaultGroupItemHeight();
 477 }
 478
 479 bool
 480 _TableViewItemProviderAdaptor::IsReorderable(int groupIndexFrom, int groupIndexTo)
 481 {
 482         SysTryReturn(NID_UI_CTRL, __pTableViewProvider != null, false, E_INVALID_OPERATION, "[E_INVALID_OPERATION] This instance has not provider.");
 483
 484         return __pTableViewProvider->IsReorderable(groupIndexFrom, groupIndexTo);
 485 }
 486
 487 bool
 488 _TableViewItemProviderAdaptor::IsOnProcessing()
 489 {
 490         if (__pTableViewProvider != null)
 491         {
 492                 return __pTableViewProvider->IsOnProcessing();
 493         }
 494         return false;
 495 }
 496
 497 _TableViewItem*
 498 _TableViewItemProviderAdaptor::GetDefaultItem(void)
 499 {
 500         if (__pDefaultItem == null)
 501         {
 502                 __pDefaultItem = _TableViewItem::CreateTableViewItemN(0.0f);
 503         }
 504
 505         return __pDefaultItem;
 506 }
 507
 508 }}} // Tizen::Ui::Controls