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