src/ui/controls/FUiCtrl_TableViewItemProvider.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_TableViewItemProvider.cpp
  20  * @brief               This file implements the _TableViewItemProvider class.
  21  */
  22
  23 #include <FUiCtrlTableView.h>
  24 #include <FUiCtrlITableViewItemProvider.h>
  25 #include <FUiCtrlIGroupedTableViewItemProvider.h>
  26 #include <FUiCtrlISectionTableViewItemProvider.h>
  27 #include <FUiCtrlITableViewItemProviderF.h>
  28 #include <FUiCtrlIGroupedTableViewItemProviderF.h>
  29 #include <FUiCtrlISectionTableViewItemProviderF.h>
  30 #include <FUiCtrlTableViewItem.h>
  31 #include <FUiCtrlTableViewGroupItem.h>
  32 #include "FUiCtrl_TableViewItemProvider.h"
  33 #include "FUi_ResourceManager.h"
  34 #include "FUi_CoordinateSystemUtils.h"
  35
  36 using namespace Tizen::Base;
  37 using namespace Tizen::Ui;
  38
  39 namespace Tizen { namespace Ui { namespace Controls
  40 {
  41
  42 _TableViewItemProvider::_TableViewItemProvider(TableViewStyle style,  bool useFloatingPoint)
  43         : __pSimpleProvider(null)
  44         , __pGroupedProvider(null)
  45         , __pSectionProvider(null)
  46         , __pSimpleProviderF(null)
  47         , __pGroupedProviderF(null)
  48         , __pSectionProviderF(null)
  49         , __style(style)
  50         , __onProcessing(false)
  51         , __useFloatingPoint(useFloatingPoint)
  52 {
  53
  54 }
  55
  56 _TableViewItemProvider::~_TableViewItemProvider(void)
  57 {
  58         __pSimpleProvider = null;
  59         __pGroupedProvider = null;
  60         __pSectionProvider = null;
  61 }
  62
  63 _TableViewItemProvider*
  64 _TableViewItemProvider::CreateTableViewItemProviderN(TableViewStyle style, bool useFloatingPoint)
  65 {
  66         ClearLastResult();
  67
  68         _TableViewItemProvider* pProvider = new (std::nothrow) _TableViewItemProvider(style, useFloatingPoint);
  69         SysTryReturn(NID_UI_CTRL, pProvider != null, null, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] Memory shortage.");
  70
  71         return pProvider;
  72 }
  73
  74 result
  75 _TableViewItemProvider::SetSimpleStyleItemProvider(ITableViewItemProvider* pProvider)
  76 {
  77         SysTryReturn(NID_UI_CTRL, __style == TABLE_VIEW_STYLE_SIMPLE, E_INVALID_OPERATION, E_INVALID_OPERATION, "[E_INVALID_OPERATION] The style of TableView is not TABLE_VIEW_STYLE_SECTION");
  78
  79         if (__useFloatingPoint)
  80         {
  81                 return E_INVALID_OPERATION;
  82         }
  83
  84         __pSimpleProvider = pProvider;
  85
  86         return E_SUCCESS;
  87 }
  88
  89 result
  90 _TableViewItemProvider::SetGroupedStyleItemProvider(IGroupedTableViewItemProvider* pProvider)
  91 {
  92         SysTryReturn(NID_UI_CTRL, __style == TABLE_VIEW_STYLE_GROUPED, E_INVALID_OPERATION, E_INVALID_OPERATION, "[E_INVALID_OPERATION] The style of TableView is not TABLE_VIEW_STYLE_SECTION");
  93
  94         if (__useFloatingPoint)
  95         {
  96                 return E_INVALID_OPERATION;
  97         }
  98
  99         __pGroupedProvider = pProvider;
 100
 101         return E_SUCCESS;
 102 }
 103
 104 result
 105 _TableViewItemProvider::SetSectionStyleItemProvider(ISectionTableViewItemProvider* pProvider)
 106 {
 107         SysTryReturn(NID_UI_CTRL, __style == TABLE_VIEW_STYLE_SECTION, E_INVALID_OPERATION, E_INVALID_OPERATION, "[E_INVALID_OPERATION] The style of TableView is not TABLE_VIEW_STYLE_SECTION");
 108
 109         if (__useFloatingPoint)
 110         {
 111                 return E_INVALID_OPERATION;
 112         }
 113
 114         __pSectionProvider = pProvider;
 115
 116         return E_SUCCESS;
 117 }
 118
 119 result
 120 _TableViewItemProvider::SetSimpleStyleItemProviderF(ITableViewItemProviderF* pProvider)
 121 {
 122         SysTryReturn(NID_UI_CTRL, __style == TABLE_VIEW_STYLE_SIMPLE, E_INVALID_OPERATION, E_INVALID_OPERATION, "[E_INVALID_OPERATION] The style of TableView is not TABLE_VIEW_STYLE_SECTION");
 123
 124         if (!__useFloatingPoint)
 125         {
 126                 return E_INVALID_OPERATION;
 127         }
 128
 129         __pSimpleProviderF = pProvider;
 130
 131         return E_SUCCESS;
 132 }
 133
 134 result
 135 _TableViewItemProvider::SetGroupedStyleItemProviderF(IGroupedTableViewItemProviderF* pProvider)
 136 {
 137         SysTryReturn(NID_UI_CTRL, __style == TABLE_VIEW_STYLE_GROUPED, E_INVALID_OPERATION, E_INVALID_OPERATION, "[E_INVALID_OPERATION] The style of TableView is not TABLE_VIEW_STYLE_SECTION");
 138
 139         if (!__useFloatingPoint)
 140         {
 141                 return E_INVALID_OPERATION;
 142         }
 143
 144         __pGroupedProviderF = pProvider;
 145
 146         return E_SUCCESS;
 147 }
 148
 149 result
 150 _TableViewItemProvider::SetSectionStyleItemProviderF(ISectionTableViewItemProviderF* pProvider)
 151 {
 152         SysTryReturn(NID_UI_CTRL, __style == TABLE_VIEW_STYLE_SECTION, E_INVALID_OPERATION, E_INVALID_OPERATION, "[E_INVALID_OPERATION] The style of TableView is not TABLE_VIEW_STYLE_SECTION");
 153
 154         if (!__useFloatingPoint)
 155         {
 156                 return E_INVALID_OPERATION;
 157         }
 158
 159         __pSectionProviderF = pProvider;
 160
 161         return E_SUCCESS;
 162 }
 163
 164
 165 int
 166 _TableViewItemProvider::GetGroupCount(void)
 167 {
 168         int count = 0;
 169         __onProcessing = true;
 170
 171         if (__useFloatingPoint)
 172         {
 173                 switch (__style)
 174                 {
 175                 case TABLE_VIEW_STYLE_SIMPLE:
 176                         count = 1;
 177                         break;
 178
 179                 case TABLE_VIEW_STYLE_GROUPED:
 180                         count = __pGroupedProviderF->GetGroupCount();
 181                         break;
 182
 183                 case TABLE_VIEW_STYLE_SECTION:
 184                         count = __pSectionProviderF->GetSectionCount();
 185                         break;
 186                 }
 187         }
 188         else
 189         {
 190                 switch (__style)
 191                 {
 192                 case TABLE_VIEW_STYLE_SIMPLE:
 193                         count = 1;
 194                         break;
 195
 196                 case TABLE_VIEW_STYLE_GROUPED:
 197                         count = __pGroupedProvider->GetGroupCount();
 198                         break;
 199
 200                 case TABLE_VIEW_STYLE_SECTION:
 201                         count = __pSectionProvider->GetSectionCount();
 202                         break;
 203                 }
 204         }
 205
 206         __onProcessing = false;
 207
 208         return count;
 209 }
 210
 211 int
 212 _TableViewItemProvider::GetItemCount(int groupIndex)
 213 {
 214         int count = 0;
 215
 216         __onProcessing = true;
 217
 218         if (__useFloatingPoint)
 219         {
 220                 switch (__style)
 221                 {
 222                 case TABLE_VIEW_STYLE_SIMPLE:
 223                         count = __pSimpleProviderF->GetItemCount();
 224                         break;
 225
 226                 case TABLE_VIEW_STYLE_GROUPED:
 227                         count = __pGroupedProviderF->GetItemCount(groupIndex);
 228                         break;
 229
 230                 case TABLE_VIEW_STYLE_SECTION:
 231                         count = __pSectionProviderF->GetItemCount(groupIndex);
 232                         break;
 233                 }
 234         }
 235         else
 236         {
 237                 switch (__style)
 238                 {
 239                 case TABLE_VIEW_STYLE_SIMPLE:
 240                         count = __pSimpleProvider->GetItemCount();
 241                         break;
 242
 243                 case TABLE_VIEW_STYLE_GROUPED:
 244                         count = __pGroupedProvider->GetItemCount(groupIndex);
 245                         break;
 246
 247                 case TABLE_VIEW_STYLE_SECTION:
 248                         count = __pSectionProvider->GetItemCount(groupIndex);
 249                         break;
 250                 }
 251         }
 252
 253         __onProcessing = false;
 254
 255         return count;
 256 }
 257
 258 float
 259 _TableViewItemProvider::GetGroupItemHeight(int groupIndex)
 260 {
 261         return GetDefaultGroupItemHeight();
 262 }
 263
 264 float
 265 _TableViewItemProvider::GetItemHeight(const TableViewItemTag& itemTag)
 266 {
 267         return GetDefaultItemHeight();
 268 }
 269
 270 float
 271 _TableViewItemProvider::GetDefaultItemHeight(void)
 272 {
 273         float height = 0.0f;
 274
 275         __onProcessing = true;
 276
 277         if (__useFloatingPoint)
 278         {
 279                 switch (__style)
 280                 {
 281                 case TABLE_VIEW_STYLE_SIMPLE:
 282                         height = __pSimpleProviderF->GetDefaultItemHeight();
 283                         break;
 284
 285                 case TABLE_VIEW_STYLE_GROUPED:
 286                         height = __pGroupedProviderF->GetDefaultItemHeight();
 287                         break;
 288
 289                 case TABLE_VIEW_STYLE_SECTION:
 290                         height = __pSectionProviderF->GetDefaultItemHeight();
 291                         break;
 292                 }
 293         }
 294         else
 295         {
 296                 int heightInt = 0;
 297                 switch (__style)
 298                 {
 299                 case TABLE_VIEW_STYLE_SIMPLE:
 300                         heightInt = __pSimpleProvider->GetDefaultItemHeight();
 301                         break;
 302
 303                 case TABLE_VIEW_STYLE_GROUPED:
 304                         heightInt = __pGroupedProvider->GetDefaultItemHeight();
 305                         break;
 306
 307                 case TABLE_VIEW_STYLE_SECTION:
 308                         heightInt = __pSectionProvider->GetDefaultItemHeight();
 309                         break;
 310                 }
 311
 312                 height = _CoordinateSystemUtils::ConvertToFloat(heightInt);
 313         }
 314
 315         __onProcessing = false;
 316
 317         return height;
 318 }
 319
 320 float
 321 _TableViewItemProvider::GetDefaultGroupItemHeight(void)
 322 {
 323         float height = 0.0f;
 324         int heightInt = 0;
 325
 326         __onProcessing = true;
 327
 328         switch (__style)
 329         {
 330         case TABLE_VIEW_STYLE_SIMPLE:
 331                 height = 0.0f;
 332                 break;
 333
 334         case TABLE_VIEW_STYLE_GROUPED:
 335                 if (__useFloatingPoint)
 336                 {
 337                         height = __pGroupedProviderF->GetDefaultGroupItemHeight();
 338                 }
 339                 else
 340                 {
 341                         heightInt = __pGroupedProvider->GetDefaultGroupItemHeight();
 342
 343                         height = _CoordinateSystemUtils::ConvertToFloat(heightInt);
 344                 }
 345                 break;
 346
 347         case TABLE_VIEW_STYLE_SECTION:
 348                 {
 349                         GET_SHAPE_CONFIG(TABLEVIEW::GROUPITEM_DEFAULT_HEIGHT, _CONTROL_ORIENTATION_PORTRAIT, height);
 350                 }
 351                 break;
 352         }
 353
 354         __onProcessing = false;
 355
 356         return height;
 357 }
 358
 359
 360 TableViewGroupItem*
 361 _TableViewItemProvider::CreateGroupItem(int groupIndex, float itemWidth)
 362 {
 363         TableViewGroupItem* pItem = null;
 364
 365         __onProcessing = true;
 366
 367         switch (__style)
 368         {
 369         case TABLE_VIEW_STYLE_SIMPLE:
 370                 pItem = null;
 371                 break;
 372
 373         case TABLE_VIEW_STYLE_GROUPED:
 374                 if (__useFloatingPoint)
 375                 {
 376                         pItem = __pGroupedProviderF->CreateGroupItem(groupIndex, itemWidth);
 377                 }
 378                 else
 379                 {
 380                         int itemWidthInt = _CoordinateSystemUtils::ConvertToInteger(itemWidth);
 381                         pItem = __pGroupedProvider->CreateGroupItem(groupIndex, itemWidthInt);
 382                 }
 383                 break;
 384
 385         case TABLE_VIEW_STYLE_SECTION:
 386                 pItem = null;
 387                 break;
 388         }
 389
 390         __onProcessing = false;
 391
 392         return pItem;
 393 }
 394
 395 bool
 396 _TableViewItemProvider::DeleteGroupItem(int groupIndex, TableViewGroupItem* pItem)
 397 {
 398         bool value = false;
 399
 400         __onProcessing = true;
 401
 402         switch (__style)
 403         {
 404         case TABLE_VIEW_STYLE_SIMPLE:
 405                 delete pItem;
 406                 value = true;
 407                 break;
 408
 409         case TABLE_VIEW_STYLE_GROUPED:
 410                 if (__useFloatingPoint)
 411                 {
 412                         value = __pGroupedProviderF->DeleteGroupItem(groupIndex, pItem);
 413                 }
 414                 else
 415                 {
 416                         value = __pGroupedProvider->DeleteGroupItem(groupIndex, pItem);
 417                 }
 418                 break;
 419         case TABLE_VIEW_STYLE_SECTION:
 420                 delete pItem;
 421                 value = true;
 422                 break;
 423         }
 424         __onProcessing = false;
 425
 426         return value;
 427 }
 428
 429 TableViewItem*
 430 _TableViewItemProvider::CreateItem(const TableViewItemTag& itemTag, float itemWidth)
 431 {
 432         TableViewItem* pItem = null;
 433
 434         __onProcessing = true;
 435
 436         if (__useFloatingPoint)
 437         {
 438                 switch (__style)
 439                 {
 440                 case TABLE_VIEW_STYLE_SIMPLE:
 441                         pItem = __pSimpleProviderF->CreateItem(itemTag.itemIndex, itemWidth);
 442                         break;
 443
 444                 case TABLE_VIEW_STYLE_GROUPED:
 445                         pItem = __pGroupedProviderF->CreateItem(itemTag.groupIndex, itemTag.itemIndex, itemWidth);
 446                         break;
 447
 448                 case TABLE_VIEW_STYLE_SECTION:
 449                         pItem = __pSectionProviderF->CreateItem(itemTag.groupIndex, itemTag.itemIndex, itemWidth);
 450                         break;
 451                 }
 452         }
 453         else
 454         {
 455                 int itemWidthInt = _CoordinateSystemUtils::ConvertToInteger(itemWidth);
 456
 457                 switch (__style)
 458                 {
 459                 case TABLE_VIEW_STYLE_SIMPLE:
 460                         pItem = __pSimpleProvider->CreateItem(itemTag.itemIndex, itemWidthInt);
 461                         break;
 462
 463                 case TABLE_VIEW_STYLE_GROUPED:
 464                         pItem = __pGroupedProvider->CreateItem(itemTag.groupIndex, itemTag.itemIndex, itemWidthInt);
 465                         break;
 466
 467                 case TABLE_VIEW_STYLE_SECTION:
 468                         pItem = __pSectionProvider->CreateItem(itemTag.groupIndex, itemTag.itemIndex, itemWidthInt);
 469                         break;
 470                 }
 471         }
 472
 473         __onProcessing = false;
 474
 475         return pItem;
 476 }
 477
 478 bool
 479 _TableViewItemProvider::DeleteItem(const TableViewItemTag& itemTag, TableViewItem* pItem)
 480 {
 481         bool value = false;
 482
 483         __onProcessing = true;
 484
 485         if (__useFloatingPoint)
 486         {
 487                 switch (__style)
 488                 {
 489                 case TABLE_VIEW_STYLE_SIMPLE:
 490                         value = __pSimpleProviderF->DeleteItem(itemTag.itemIndex, pItem);
 491                         break;
 492
 493                 case TABLE_VIEW_STYLE_GROUPED:
 494                         value = __pGroupedProviderF->DeleteItem(itemTag.groupIndex, itemTag.itemIndex, pItem);
 495                         break;
 496
 497                 case TABLE_VIEW_STYLE_SECTION:
 498                         value = __pSectionProviderF->DeleteItem(itemTag.groupIndex, itemTag.itemIndex, pItem);
 499                         break;
 500                 }
 501         }
 502         else
 503         {
 504                 switch (__style)
 505                 {
 506                 case TABLE_VIEW_STYLE_SIMPLE:
 507                         value = __pSimpleProvider->DeleteItem(itemTag.itemIndex, pItem);
 508                         break;
 509
 510                 case TABLE_VIEW_STYLE_GROUPED:
 511                         value = __pGroupedProvider->DeleteItem(itemTag.groupIndex, itemTag.itemIndex, pItem);
 512                         break;
 513
 514                 case TABLE_VIEW_STYLE_SECTION:
 515                         value = __pSectionProvider->DeleteItem(itemTag.groupIndex, itemTag.itemIndex, pItem);
 516                         break;
 517                 }
 518         }
 519
 520         __onProcessing = false;
 521
 522         return value;
 523 }
 524
 525 bool
 526 _TableViewItemProvider::UpdateItem(const TableViewItemTag& itemTag, TableViewItem *pItem)
 527 {
 528         __onProcessing = true;
 529
 530         if (__useFloatingPoint)
 531         {
 532                 switch (__style)
 533                 {
 534                 case TABLE_VIEW_STYLE_SIMPLE:
 535                         __pSimpleProviderF->UpdateItem(itemTag.itemIndex, pItem);
 536                         break;
 537
 538                 case TABLE_VIEW_STYLE_GROUPED:
 539                         __pGroupedProviderF->UpdateItem(itemTag.groupIndex, itemTag.itemIndex, pItem);
 540                         break;
 541
 542                 case TABLE_VIEW_STYLE_SECTION:
 543                         __pSectionProviderF->UpdateItem(itemTag.groupIndex, itemTag.itemIndex, pItem);
 544                         break;
 545                 }
 546         }
 547         else
 548         {
 549                 switch (__style)
 550                 {
 551                 case TABLE_VIEW_STYLE_SIMPLE:
 552                         __pSimpleProvider->UpdateItem(itemTag.itemIndex, pItem);
 553                         break;
 554
 555                 case TABLE_VIEW_STYLE_GROUPED:
 556                         __pGroupedProvider->UpdateItem(itemTag.groupIndex, itemTag.itemIndex, pItem);
 557                         break;
 558
 559                 case TABLE_VIEW_STYLE_SECTION:
 560                         __pSectionProvider->UpdateItem(itemTag.groupIndex, itemTag.itemIndex, pItem);
 561                         break;
 562                 }
 563         }
 564
 565         __onProcessing = false;
 566
 567         return true;
 568 }
 569
 570 bool
 571 _TableViewItemProvider::UpdateGroupItem(int groupIndex, TableViewGroupItem *pItem)
 572 {
 573         bool value = false;
 574         __onProcessing = true;
 575
 576         switch (__style)
 577         {
 578         case TABLE_VIEW_STYLE_SIMPLE:
 579                 value = false;
 580                 break;
 581
 582         case TABLE_VIEW_STYLE_GROUPED:
 583                 if (__useFloatingPoint)
 584                 {
 585                         __pGroupedProviderF->UpdateGroupItem(groupIndex, pItem);
 586                 }
 587                 else
 588                 {
 589                         __pGroupedProvider->UpdateGroupItem(groupIndex, pItem);
 590                 }
 591                 value = true;
 592                 break;
 593
 594         case TABLE_VIEW_STYLE_SECTION:
 595                 value = false;
 596                 break;
 597         }
 598
 599         __onProcessing = false;
 600
 601         return value;
 602 }
 603
 604 bool
 605 _TableViewItemProvider::IsReorderable(int groupIndexFrom, int groupIndexTo)
 606 {
 607         bool value = false;
 608
 609         switch (__style)
 610         {
 611         case TABLE_VIEW_STYLE_SIMPLE:
 612                 value = false;
 613                 break;
 614
 615         case TABLE_VIEW_STYLE_GROUPED:
 616                 if (__useFloatingPoint)
 617                 {
 618                         value = __pGroupedProviderF->IsReorderable(groupIndexFrom, groupIndexTo);
 619                 }
 620                 else
 621                 {
 622                         value = __pGroupedProvider->IsReorderable(groupIndexFrom, groupIndexTo);
 623                 }
 624                 break;
 625         case TABLE_VIEW_STYLE_SECTION:
 626                 value = false;
 627                 break;
 628         }
 629
 630         return value;
 631 }
 632
 633 bool
 634 _TableViewItemProvider::IsOnProcessing()
 635 {
 636         return __onProcessing;
 637 }
 638
 639 Tizen::Base::String
 640 _TableViewItemProvider::GetSectionHeader(int groupIndex)
 641 {
 642         SysTryReturn(NID_UI_CTRL, __style == TABLE_VIEW_STYLE_SECTION, String(""), E_INVALID_OPERATION, "[E_INVALID_OPERATION] The style of TableView is not TABLE_VIEW_STYLE_SECTION");
 643
 644         String sectionHeader;
 645
 646         if (__useFloatingPoint)
 647         {
 648                 sectionHeader = __pSectionProviderF->GetSectionHeader(groupIndex);
 649         }
 650         else
 651         {
 652                 sectionHeader = __pSectionProvider->GetSectionHeader(groupIndex);
 653         }
 654
 655         return sectionHeader;
 656 }
 657
 658 bool
 659 _TableViewItemProvider::HasSectionHeader(int groupIndex)
 660 {
 661         SysTryReturn(NID_UI_CTRL, __style == TABLE_VIEW_STYLE_SECTION, false, E_INVALID_OPERATION, "[E_INVALID_OPERATION] The style of TableView is not TABLE_VIEW_STYLE_SECTION");
 662
 663         bool hasSectionHeader;
 664
 665         if (__useFloatingPoint)
 666         {
 667                 hasSectionHeader = __pSectionProviderF->HasSectionHeader(groupIndex);
 668         }
 669         else
 670         {
 671                 hasSectionHeader = __pSectionProvider->HasSectionHeader(groupIndex);
 672         }
 673
 674         return hasSectionHeader;
 675 }
 676
 677 Tizen::Base::String
 678 _TableViewItemProvider::GetSectionFooter(int groupIndex)
 679 {
 680         SysTryReturn(NID_UI_CTRL, __style == TABLE_VIEW_STYLE_SECTION, String(""), E_INVALID_OPERATION, "[E_INVALID_OPERATION] The style of TableView is not TABLE_VIEW_STYLE_SECTION");
 681
 682         String sectionFooter;
 683
 684         if (__useFloatingPoint)
 685         {
 686                 sectionFooter = __pSectionProviderF->GetSectionFooter(groupIndex);
 687         }
 688         else
 689         {
 690                 sectionFooter = __pSectionProvider->GetSectionFooter(groupIndex);
 691         }
 692
 693         return sectionFooter;
 694 }
 695
 696 bool
 697 _TableViewItemProvider::HasSectionFooter(int groupIndex)
 698 {
 699         SysTryReturn(NID_UI_CTRL, __style == TABLE_VIEW_STYLE_SECTION, false, E_INVALID_OPERATION, "[E_INVALID_OPERATION] The style of TableView is not TABLE_VIEW_STYLE_SECTION");
 700
 701         bool hasSectionFooter;
 702
 703         if (__useFloatingPoint)
 704         {
 705                 hasSectionFooter = __pSectionProviderF->HasSectionFooter(groupIndex);
 706         }
 707         else
 708         {
 709                 hasSectionFooter = __pSectionProvider->HasSectionFooter(groupIndex);
 710         }
 711
 712         return hasSectionFooter;
 713 }
 714
 715 }}}   // Tizen::Ui::Controls
 716