src/ui/controls/FUiCtrl_TableView.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_TableView.cpp
  20  * @brief               This file implements the _TableView class.
  21  * @version             3.0
  22  */
  23
  24 #include <FGrp_BitmapImpl.h>
  25 #include "FUi_ControlManager.h"
  26 #include "FUi_ResourceManager.h"
  27 #include "FUiAnim_VisualElement.h"
  28 #include "FUiCtrl_ListViewModel.h"
  29 #include "FUiCtrl_FastScroll.h"
  30 #include "FUiCtrl_Scroll.h"
  31 #include "FUiCtrl_TableView.h"
  32 #include "FUiCtrl_TableViewPresenter.h"
  33 #include "FUiCtrl_TableViewItem.h"
  34 #include "FUiCtrl_TableViewItemProvider.h"
  35 #include "FUiCtrl_TableViewItemProviderAdaptor.h"
  36 #include "FUiCtrl_UiTableViewItemEvent.h"
  37
  38
  39 using namespace Tizen::Base;
  40 using namespace Tizen::Ui;
  41 using namespace Tizen::Ui::Animations;
  42 using namespace Tizen::Graphics;
  43
  44 namespace Tizen { namespace Ui { namespace Controls
  45 {
  46
  47 IMPLEMENT_PROPERTY(_TableView);
  48
  49 _TableView::_TableView(void)
  50         : __pTableViewPresenter(null)
  51         , __pFastScroll(null)
  52         , __pTableViewItemEvent(null)
  53         , __itemDividerEnabled(false)
  54         , __sweepEnabled(false)
  55         , __reorderEnabled(false)
  56         , __sectionStyle(false)
  57         , __groupedLookEnable(false)
  58         , __tableViewStyle(TABLE_VIEW_STYLE_SIMPLE)
  59         , __scrollStyle(TABLE_VIEW_SCROLL_BAR_STYLE_FADE_OUT)
  60         , __pBitmapOfEmptyTableView(null)
  61         , __pBackgroundBitmap(null)
  62         , __textOfEmptyTableView(L"Empty TableView")
  63 {
  64         Color bgColor;
  65
  66         GET_COLOR_CONFIG(TABLEVIEW::BG_NORMAL, bgColor);
  67         GET_COLOR_CONFIG(TABLEVIEW::SECTIONITEM_BG_NORMAL, __sectionStyleColor);
  68         GET_COLOR_CONFIG(TABLEVIEW::ITEM_DIVIDER_BOTTOM_BG_NORMAL, __itemDividerColor);
  69
  70         SetBackgroundColor(bgColor);
  71 }
  72
  73 _TableView::~_TableView(void)
  74 {
  75         GetVisualElement()->RemoveAllAnimations();
  76
  77         __pTableViewPresenter = null;
  78
  79         if (__pFastScroll != null)
  80         {
  81                 DetachSystemChild(*__pFastScroll);
  82
  83                 delete __pFastScroll;
  84                 __pFastScroll = null;
  85         }
  86
  87         delete __pTableViewItemEvent;
  88         __pTableViewItemEvent = null;
  89 }
  90
  91 _TableView*
  92 _TableView::CreateTableViewN(TableViewStyle style, bool itemDivider, TableViewScrollBarStyle scrollStyle)
  93 {
  94         ClearLastResult();
  95         result r = E_SUCCESS;
  96
  97         _TableView* pTableView = null;
  98
  99         _ControlManager* pControlManager = _ControlManager::GetInstance();
 100         SysTryReturn(NID_UI_CTRL, pControlManager, null, E_SYSTEM, "[E_SYSTEM] System error occurred.");
 101
 102         pTableView = new (std::nothrow) _TableView;
 103         SysTryCatch(NID_UI_CTRL, pTableView != null, , E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] Memory shortage.");
 104
 105         r = GetLastResult();
 106         SysTryCatch(NID_UI_CTRL, r == E_SUCCESS, , E_SYSTEM, "[%s] Propagating", GetErrorMessage(r));
 107
 108         pTableView->AcquireHandle();
 109
 110         r = pTableView->Initialize(style, itemDivider, scrollStyle);
 111         SysTryCatch(NID_UI_CTRL, (r == E_SUCCESS), , r, "[%s] Failed to Initialize", GetErrorMessage(r));
 112
 113         return pTableView;
 114
 115 CATCH:
 116         delete pTableView;
 117         return null;
 118 }
 119
 120 result
 121 _TableView::Initialize(TableViewStyle style, bool itemDivider, TableViewScrollBarStyle scrollStyle)
 122 {
 123         result r = E_SUCCESS;
 124
 125         _TableViewPresenter* pPresenter = new (std::nothrow) _TableViewPresenter();
 126         SysTryReturn(NID_UI_CTRL, pPresenter != null, E_OUT_OF_MEMORY, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] Memory shortage.");
 127
 128         r = pPresenter->Construct(this);
 129         SysTryReturn(NID_UI_CTRL, (r == E_SUCCESS), r, r, "[%s] Propagating.", GetErrorMessage(r));
 130
 131         r = _ScrollPanel::Initialize(*pPresenter);
 132         SetTableViewPresenter(pPresenter);
 133         SetScrollAreaAutoResizingEnabled(false);
 134
 135         Rectangle rect = GetBounds();
 136         SetScrollAreaBounds(rect);
 137
 138         SetTableViewStyle(style);
 139         SetScrollStyle(scrollStyle);
 140         SetItemDividerEnabled(itemDivider);
 141
 142         return r;
 143 }
 144
 145 _TableViewPresenter*
 146 _TableView::GetTableViewPresenter(void) const
 147 {
 148         return __pTableViewPresenter;
 149 }
 150
 151 void
 152 _TableView::SetTableViewPresenter(const _TableViewPresenter* pPresenter)
 153 {
 154         _ScrollPanel::SetScrollPanelPresenter(pPresenter);
 155
 156         __pTableViewPresenter = const_cast<_TableViewPresenter*>(pPresenter);
 157 }
 158
 159 result
 160 _TableView::SetItemProvider(const _TableViewItemProvider* pProvider)
 161 {
 162         return __pTableViewPresenter->SetItemProvider(pProvider);
 163 }
 164
 165 void
 166 _TableView::SetItemProviderAdaptor(_TableViewItemProviderAdaptor* pProviderAdaptor)
 167 {
 168         __pTableViewPresenter->SetTableViewItemProviderAdaptor(pProviderAdaptor);
 169 }
 170
 171 _TableViewItemProviderAdaptor*
 172 _TableView::GetItemProviderAdaptor(void) const
 173 {
 174         return __pTableViewPresenter->GetTableViewItemProviderAdaptor();
 175 }
 176
 177 void
 178 _TableView::SetSweepEnabled(bool enable)
 179 {
 180         __sweepEnabled = enable;
 181 }
 182
 183 bool
 184 _TableView::IsSweepEnabled(void) const
 185 {
 186         return __sweepEnabled;
 187 }
 188
 189 bool
 190 _TableView::IsReorderModeEnabled(void) const
 191 {
 192         return __reorderEnabled;
 193 }
 194
 195 result
 196 _TableView::SetReorderModeEnabled(bool enable)
 197 {
 198         if (__reorderEnabled != enable)
 199         {
 200                 __reorderEnabled = enable;
 201
 202                 __pTableViewPresenter->SetReorderMode(enable);
 203         }
 204
 205         return E_SUCCESS;
 206 }
 207
 208 result
 209 _TableView::SetItemChecked(int groupIndex, int itemIndex, bool check)
 210 {
 211         if (IsOnProcessing())
 212         {
 213                 return E_INVALID_OPERATION;
 214         }
 215         return __pTableViewPresenter->SetItemChecked(groupIndex, itemIndex, check);
 216 }
 217
 218 bool
 219 _TableView::IsItemChecked(int groupIndex, int itemIndex) const
 220 {
 221         return __pTableViewPresenter->IsItemChecked(groupIndex, itemIndex);
 222 }
 223
 224 result
 225 _TableView::SetItemEnabled(int groupIndex, int itemIndex, bool enable)
 226 {
 227         if (IsOnProcessing())
 228         {
 229                 return E_INVALID_OPERATION;
 230         }
 231         return __pTableViewPresenter->SetItemEnabled(groupIndex, itemIndex, enable);
 232 }
 233
 234 void
 235 _TableView::CheckItemHeightAndRefreshLayout(int groupIndex, int itemIndex)
 236 {
 237         TableViewItemTag itemTag = {groupIndex, itemIndex};
 238         __pTableViewPresenter->CheckItemHeightAndRefreshLayout(itemTag, true);
 239 }
 240
 241 _TableViewItem*
 242 _TableView::FindItem(int groupIndex, int itemIndex) const
 243 {
 244         TableViewItemTag itemTag = {groupIndex, itemIndex};
 245
 246         return __pTableViewPresenter->FindItem(itemTag);
 247 }
 248
 249 void
 250 _TableView::UnloadItem(int groupIndex, int itemIndex)
 251 {
 252         if (IsOnProcessing())
 253         {
 254                 return;
 255         }
 256         return __pTableViewPresenter->UnloadItem(groupIndex, itemIndex);
 257 }
 258
 259 _TableViewItem*
 260 _TableView::LoadItem(int groupIndex, int itemIndex)
 261 {
 262         if (IsOnProcessing())
 263         {
 264                 return null;
 265         }
 266         return __pTableViewPresenter->LoadItem(groupIndex, itemIndex);
 267 }
 268
 269 void
 270 _TableView::RefreshItemLayout(int groupIndex, int itemIndex)
 271 {
 272         __pTableViewPresenter->RefreshItemLayout(groupIndex, itemIndex);
 273 }
 274
 275 void
 276 _TableView::GetFirstLoadedItemIndex(int& groupIndex, int& itemIndex) const
 277 {
 278         __pTableViewPresenter->GetFirstLoadedItemIndex(groupIndex, itemIndex);
 279 }
 280
 281 void
 282 _TableView::GetLastLoadedItemIndex(int& groupIndex, int& itemIndex) const
 283 {
 284         __pTableViewPresenter->GetLastLoadedItemIndex(groupIndex, itemIndex);
 285 }
 286
 287 void
 288 _TableView::ResetSweepItem(void)
 289 {
 290         __pTableViewPresenter->ResetSweepItem();
 291 }
 292
 293 int
 294 _TableView::GetPressedItemCount(void)
 295 {
 296         return __pTableViewPresenter->GetPressedItemCount();
 297 }
 298
 299 int
 300 _TableView::GetTopMargin(void) const
 301 {
 302         return __pTableViewPresenter->GetTopMargin();
 303 }
 304
 305 result
 306 _TableView::SetTopMargin(int topMargin)
 307 {
 308         return __pTableViewPresenter->SetTopMargin(topMargin);
 309 }
 310
 311 int
 312 _TableView::GetBottomMargin(void) const
 313 {
 314         return __pTableViewPresenter->GetBottomMargin();
 315 }
 316
 317 result
 318 _TableView::SetBottomMargin(int bottomMargin)
 319 {
 320         return __pTableViewPresenter->SetBottomMargin(bottomMargin);
 321 }
 322
 323 bool
 324 _TableView::IsItemEnabled(int groupIndex, int itemIndex) const
 325 {
 326         return __pTableViewPresenter->IsItemEnabled(groupIndex, itemIndex);
 327 }
 328
 329 result
 330 _TableView::GetTopDrawnItemIndex(int& groupIndex, int& itemIndex) const
 331 {
 332         groupIndex = -1;
 333         itemIndex = -1;
 334
 335         return __pTableViewPresenter->GetTopDrawnItemIndex(groupIndex, itemIndex);
 336 }
 337
 338 result
 339 _TableView::SetTopDrawnItemIndex(int groupIndex, int itemIndex)
 340 {
 341         if (IsOnProcessing())
 342         {
 343                 return E_INVALID_OPERATION;
 344         }
 345         return __pTableViewPresenter->SetTopDrawnItemIndex(groupIndex, itemIndex);
 346 }
 347
 348 result
 349 _TableView::GetBottomDrawnItemIndex(int& groupIndex, int& itemIndex) const
 350 {
 351         groupIndex = -1;
 352         itemIndex = -1;
 353
 354         return __pTableViewPresenter->GetBottomDrawnItemIndex(groupIndex, itemIndex);
 355 }
 356
 357 result
 358 _TableView::SetBottomDrawnItemIndex(int groupIndex, int itemIndex)
 359 {
 360         if (IsOnProcessing())
 361         {
 362                 return E_INVALID_OPERATION;
 363         }
 364         return __pTableViewPresenter->SetBottomDrawnItemIndex(groupIndex, itemIndex);
 365 }
 366
 367 result
 368 _TableView::ScrollByPixel(int scrollDistance)
 369 {
 370         return __pTableViewPresenter->ScrollByPixel(scrollDistance);
 371 }
 372
 373 void
 374 _TableView::SetScrollEnabled(bool enable)
 375 {
 376         __pTableViewPresenter->SetScrollEnabled(enable);
 377 }
 378
 379 bool
 380 _TableView::IsScrollEnabled(void) const
 381 {
 382         return __pTableViewPresenter->IsScrollEnabled();
 383 }
 384
 385 result
 386 _TableView::AddTableViewItemEventListener(const _ITableViewItemEventListener& listener)
 387 {
 388         result r = E_SUCCESS;
 389
 390         if (__pTableViewItemEvent == null)
 391         {
 392                 __pTableViewItemEvent = new (std::nothrow) _UiTableViewItemEvent();
 393                 SysTryReturn(NID_UI_CTRL, __pTableViewItemEvent != null, E_OUT_OF_MEMORY, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] The memory is insufficient.");
 394
 395                 r = __pTableViewItemEvent->Construct(this, TABLE_VIEW_STYLE_SIMPLE);
 396                 SysTryReturn(NID_UI_CTRL, r == E_SUCCESS, E_SYSTEM, E_SYSTEM, "[E_SYSTEM] Unable to construct Item Event.");
 397         }
 398
 399         r = __pTableViewItemEvent->AddListener(listener);
 400         SysTryReturn(NID_UI_CTRL, r == E_SUCCESS, r, r, "[%s] Propagating.", GetErrorMessage(GetLastResult()));
 401
 402         return E_SUCCESS;
 403 }
 404
 405 result
 406 _TableView::RemoveTableViewItemEventListener(const _ITableViewItemEventListener& listener)
 407 {
 408         SysTryReturn(NID_UI_CTRL, __pTableViewItemEvent != null, E_OBJ_NOT_FOUND, E_OBJ_NOT_FOUND, "[E_OBJ_NOT_FOUND] This instance isn't constructed.");
 409
 410         return __pTableViewItemEvent->RemoveListener(listener);
 411 }
 412
 413 result
 414 _TableView::AddGroupedTableViewItemEventListener(const _ITableViewItemEventListener& listener)
 415 {
 416         result r = E_SUCCESS;
 417
 418         if (__pTableViewItemEvent == null)
 419         {
 420                 __pTableViewItemEvent = new (std::nothrow) _UiTableViewItemEvent();
 421                 SysTryReturn(NID_UI_CTRL, __pTableViewItemEvent != null, E_OUT_OF_MEMORY, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] The memory is insufficient.");
 422
 423                 r = __pTableViewItemEvent->Construct(this, TABLE_VIEW_STYLE_GROUPED);
 424                 SysTryReturn(NID_UI_CTRL, r == E_SUCCESS, E_SYSTEM, E_SYSTEM, "[E_SYSTEM] Unable to construct Item Event.");
 425         }
 426
 427         r = __pTableViewItemEvent->AddListener(listener);
 428         SysTryReturn(NID_UI_CTRL, r == E_SUCCESS, r, r, "[%s] Propagating.", GetErrorMessage(GetLastResult()));
 429
 430         return E_SUCCESS;
 431 }
 432
 433 result
 434 _TableView::RemoveGroupedTableViewItemEventListener(const _ITableViewItemEventListener& listener)
 435 {
 436         SysTryReturn(NID_UI_CTRL, __pTableViewItemEvent != null, E_OBJ_NOT_FOUND, E_OBJ_NOT_FOUND, "[E_OBJ_NOT_FOUND] This instance isn't constructed.");
 437
 438         return __pTableViewItemEvent->RemoveListener(listener);
 439 }
 440
 441 result
 442 _TableView::AddSectionTableViewItemEventListener(const _ITableViewItemEventListener& listener)
 443 {
 444         result r = E_SUCCESS;
 445
 446         if (__pTableViewItemEvent == null)
 447         {
 448                 __pTableViewItemEvent = new (std::nothrow) _UiTableViewItemEvent();
 449                 SysTryReturn(NID_UI_CTRL, __pTableViewItemEvent != null, E_OUT_OF_MEMORY, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] The memory is insufficient.");
 450
 451                 r = __pTableViewItemEvent->Construct(this, TABLE_VIEW_STYLE_SECTION);
 452                 SysTryReturn(NID_UI_CTRL, r == E_SUCCESS, E_SYSTEM, E_SYSTEM, "[E_SYSTEM] Unable to construct Item Event.");
 453         }
 454
 455         r = __pTableViewItemEvent->AddListener(listener);
 456         SysTryReturn(NID_UI_CTRL, r == E_SUCCESS, r, r, "[%s] Propagating.", GetErrorMessage(GetLastResult()));
 457
 458         return E_SUCCESS;
 459 }
 460
 461 result
 462 _TableView::RemoveSectionTableViewItemEventListener(const _ITableViewItemEventListener& listener)
 463 {
 464         SysTryReturn(NID_UI_CTRL, __pTableViewItemEvent != null, E_OBJ_NOT_FOUND, E_OBJ_NOT_FOUND, "[E_OBJ_NOT_FOUND] This instance isn't constructed.");
 465
 466         return __pTableViewItemEvent->RemoveListener(listener);
 467 }
 468
 469 result
 470 _TableView::AddFastScrollListener(const _IUiFastScrollListener& listener)
 471 {
 472         SysTryReturn(NID_UI_CTRL, __pFastScroll != null, E_OBJ_NOT_FOUND, E_OBJ_NOT_FOUND, "[E_OBJ_NOT_FOUND] This instance isn't constructed.");
 473         __pFastScroll->AddFastScrollEventListener(listener);
 474
 475         return E_SUCCESS;
 476 }
 477
 478 result
 479 _TableView::RemoveFastScrollListener(const _IUiFastScrollListener& listener)
 480 {
 481         SysTryReturn(NID_UI_CTRL, __pFastScroll != null, E_OBJ_NOT_FOUND, E_OBJ_NOT_FOUND, "[E_OBJ_NOT_FOUND] This instance isn't constructed.");
 482         __pFastScroll->RemoveFastScrollEventListener(listener);
 483
 484         return E_SUCCESS;
 485 }
 486
 487 _FastScroll*
 488 _TableView::GetFastScrollBar(void) const
 489 {
 490         return __pFastScroll;
 491 }
 492
 493 result
 494 _TableView::SetFastScrollIndex(const String& text, bool useSearchIcon)
 495 {
 496         SysTryReturn(NID_UI_CTRL, __scrollStyle == TABLE_VIEW_SCROLL_BAR_STYLE_FAST_SCROLL, E_INVALID_OPERATION, E_INVALID_OPERATION, "[E_INVALID_OPERATION] The style of TableView scroll is not TABLE_VIEW_SCROLL_BAR_STYLE_FAST_SCROLL");
 497         SysTryReturn(NID_UI_CTRL, __pFastScroll != null, E_OBJ_NOT_FOUND, E_OBJ_NOT_FOUND, "[E_OBJ_NOT_FOUND] This instance isn't constructed.");
 498         result r = E_SUCCESS;
 499
 500         const wchar_t* pIndexTextArray = text.GetPointer();
 501         int indexLenth = 1;
 502         int indexCount = text.GetLength();
 503         int childOrder = 0;
 504
 505         // Set the primary index.
 506         _FastScrollIndex* pRootIndex = __pFastScroll->GetIndex();
 507         if (pRootIndex == null)
 508         {
 509                 pRootIndex = _FastScrollIndex::CreateFastScrollIndexN();
 510                 r = GetLastResult();
 511                 SysTryReturn(NID_UI_CTRL, pRootIndex != null, r, r, "[%s] Propagating.", GetErrorMessage(r));
 512
 513                 r = __pFastScroll->SetIndex(pRootIndex);
 514                 SysTryReturn(NID_UI_CTRL, r == E_SUCCESS, r, r, "[%s] Propagating.", GetErrorMessage(r));
 515         }
 516         else
 517         {
 518                 pRootIndex->RemoveChildren(true);
 519         }
 520
 521         if (useSearchIcon == true)
 522         {
 523                 Bitmap* pSearchIcon = null;
 524                 String fastScrollSearchIconIndex(L"[SEARCH_ICON_INDEX]");
 525
 526                 r = GET_BITMAP_CONFIG_N(TABLEVIEW::SEARCH_ICON_NORMAL, BITMAP_PIXEL_FORMAT_ARGB8888, pSearchIcon);
 527                 SysTryReturn(NID_UI_CTRL, r == E_SUCCESS, E_SYSTEM, E_SYSTEM, "[E_SYSTEM] SearchIcon image load failed");
 528
 529                 r = pRootIndex->AddChildIndex(&fastScrollSearchIconIndex, pSearchIcon);
 530                 SysTryReturn(NID_UI_CTRL, r == E_SUCCESS, E_INVALID_STATE, E_INVALID_STATE, "[E_INVALID_STATE] Failed to add text array to the primary index.");
 531
 532                 childOrder++;
 533         }
 534
 535         r = pRootIndex->AddChildTextIndexArray(childOrder, pIndexTextArray, indexLenth, indexCount);
 536         SysTryReturn(NID_UI_CTRL, r == E_SUCCESS, r, r, "[%s] Propagating.", GetErrorMessage(r));
 537
 538         r = __pFastScroll->UpdateIndex();
 539         SysTryReturn(NID_UI_CTRL, r == E_SUCCESS, r, r, "[%s] Propagating.", GetErrorMessage(r));
 540         return E_SUCCESS;
 541 }
 542
 543 result
 544 _TableView::SetScrollStyle(TableViewScrollBarStyle scrollStyle)
 545 {
 546         __scrollStyle = scrollStyle;
 547
 548         return E_SUCCESS;
 549 }
 550
 551 TableViewStyle
 552 _TableView::GetTableViewStyle(void) const
 553 {
 554         return __tableViewStyle;
 555 }
 556
 557 void
 558 _TableView::SetTableViewStyle(TableViewStyle style)
 559 {
 560         __tableViewStyle = style;
 561
 562         if (__tableViewStyle == TABLE_VIEW_STYLE_SECTION)
 563         {
 564                 int topMargin = 0;
 565                 GET_FIXED_VALUE_CONFIG(TABLEVIEW::SECTIONITEM_TOP_MARGIN, _CONTROL_ORIENTATION_PORTRAIT, topMargin);
 566                 SetTopMargin(topMargin);
 567
 568                 int x = 0;
 569                 GET_SHAPE_CONFIG(TABLEVIEW::GROUPITEM_LEFT_MARGIN, _CONTROL_ORIENTATION_PORTRAIT, x);
 570                 __pTableViewPresenter->SetLeftMargin(x);
 571
 572                 __groupedLookEnable = true;
 573         }
 574 }
 575
 576 TableViewScrollBarStyle
 577 _TableView::GetScrollStyle(void) const
 578 {
 579         return __scrollStyle;
 580 }
 581
 582 int
 583 _TableView::GetGroupCount(void) const
 584 {
 585         return __pTableViewPresenter->GetGroupCount();
 586 }
 587
 588 int
 589 _TableView::GetItemCountAt(int groupIndex) const
 590 {
 591         SysTryReturn(NID_UI_CTRL, groupIndex >= 0 && groupIndex < GetGroupCount(), -1, E_INVALID_ARG, "[E_INVALID_ARG] Invalid group index.");
 592
 593         int itemCount = __pTableViewPresenter->GetItemCountAt(groupIndex);
 594
 595         if (GetTableViewStyle() == TABLE_VIEW_STYLE_SECTION)
 596         {
 597                 // sub section footer
 598                 if (__pTableViewPresenter->HasSectionFooter(groupIndex) == true)
 599                 {
 600                         itemCount--;
 601                         if (itemCount < 0)
 602                         {
 603                                 itemCount = 0;
 604                         }
 605                 }
 606         }
 607
 608         return itemCount;
 609 }
 610
 611 result
 612 _TableView::RefreshTableView(int groupIndex, int itemIndex, TableViewRefreshType type, bool animation)
 613 {
 614         if (IsOnProcessing())
 615         {
 616                 return E_INVALID_OPERATION;
 617         }
 618         return __pTableViewPresenter->RefreshTableView(groupIndex, itemIndex, type, animation);
 619 }
 620
 621 result
 622 _TableView::UpdateTableView(void)
 623 {
 624         if (IsOnProcessing())
 625         {
 626                 return E_INVALID_OPERATION;
 627         }
 628         return __pTableViewPresenter->UpdateTableView();
 629 }
 630
 631 result
 632 _TableView::GetItemIndexFromPosition(const Point& position, int& groupIndex, int& itemIndex) const
 633 {
 634         return __pTableViewPresenter->GetItemIndexFromPosition(position, groupIndex, itemIndex);
 635 }
 636
 637 result
 638 _TableView::SetPropertySectionColor(const Variant& sectionColor)
 639 {
 640         __sectionStyleColor = sectionColor.ToColor();
 641
 642         return E_SUCCESS;
 643 }
 644
 645 result
 646 _TableView::SetSectionColor(const Color& color)
 647 {
 648         if (GetTableViewStyle() != TABLE_VIEW_STYLE_SECTION)
 649         {
 650                 SysLog(NID_UI_CTRL, "[E_INVALID_OPERATION] The style of TableView is not TABLE_VIEW_STYLE_SECTION.");
 651                 return E_INVALID_OPERATION;
 652         }
 653
 654         if (__sectionStyleColor == color)
 655         {
 656                 return E_SUCCESS;
 657         }
 658
 659         result r = SetProperty("sectionColor", Variant(color));
 660         SysTryReturn(NID_UI_CTRL, r == E_SUCCESS, r, r, "[%s] Propagating.", GetErrorMessage(r));
 661
 662         return __pTableViewPresenter->SetStatusChanged(true);
 663 }
 664
 665 Variant
 666 _TableView::GetPropertySectionColor(void) const
 667 {
 668         return Variant(__sectionStyleColor);
 669 }
 670
 671 Color
 672 _TableView::GetSectionColor(void) const
 673 {
 674         if (GetTableViewStyle() != TABLE_VIEW_STYLE_SECTION)
 675         {
 676                 SetLastResult(E_SUCCESS);
 677                 return Color(0);
 678         }
 679
 680         Variant sectionColor = GetProperty("sectionColor");
 681
 682         return sectionColor.ToColor();
 683 }
 684
 685 Variant
 686 _TableView::GetPropertyItemDividerColor(void) const
 687 {
 688         return Variant(__itemDividerColor);
 689 }
 690
 691 Color
 692 _TableView::GetItemDividerColor(void) const
 693 {
 694         Variant itemDividerColor = GetProperty("itemDividerColor");
 695
 696         return itemDividerColor.ToColor();
 697 }
 698
 699 result
 700 _TableView::SetPropertyItemDividerColor(const Variant& itemDividerColor)
 701 {
 702         __itemDividerColor = itemDividerColor.ToColor();
 703
 704         return E_SUCCESS;
 705 }
 706
 707 result
 708 _TableView::SetItemDividerColor(const Color& color)
 709 {
 710         return SetProperty("itemDividerColor", Variant(color));
 711 }
 712
 713 bool
 714 _TableView::IsItemDividerEnabled(void) const
 715 {
 716         return __itemDividerEnabled;
 717 }
 718
 719 void
 720 _TableView::SetItemDividerEnabled(bool enable)
 721 {
 722         __itemDividerEnabled = enable;
 723 }
 724
 725 Bitmap*
 726 _TableView::GetBitmapOfEmptyTableView(void) const
 727 {
 728         return __pBitmapOfEmptyTableView;
 729 }
 730
 731 result
 732 _TableView::SetBitmapOfEmptyTableView(const Bitmap* pBitmap)
 733 {
 734         Bitmap* pCloneBitmap = null;
 735
 736         if (pBitmap == null)
 737         {
 738                 delete __pBitmapOfEmptyTableView;
 739                 __pBitmapOfEmptyTableView = null;
 740
 741                 return E_SUCCESS;
 742         }
 743         else
 744         {
 745                 pCloneBitmap = _BitmapImpl::CloneN(*pBitmap);
 746                 SysTryReturn(NID_UI_CTRL, pCloneBitmap != null, GetLastResult(), GetLastResult(), "[%s] Propagating.", GetErrorMessage(GetLastResult()));
 747
 748                 delete __pBitmapOfEmptyTableView;
 749                 __pBitmapOfEmptyTableView = pCloneBitmap;
 750         }
 751
 752         return __pTableViewPresenter->SetStatusChanged(true);
 753 }
 754
 755 Variant
 756 _TableView::GetPropertyTextColorOfEmptyTableView(void) const
 757 {
 758         return Variant(__textColorOfEmptyTableView);
 759 }
 760
 761 Color
 762 _TableView::GetTextColorOfEmptyTableView(void) const
 763 {
 764         Variant textColorOfEmptyTableView = GetProperty("textColorOfEmptyTableView");
 765
 766         return textColorOfEmptyTableView.ToColor();
 767 }
 768
 769 result
 770 _TableView::SetPropertyTextColorOfEmptyTableView(const Variant& textColorOfEmptyTableView)
 771 {
 772         __textColorOfEmptyTableView = textColorOfEmptyTableView.ToColor();
 773
 774         return E_SUCCESS;
 775 }
 776
 777 result
 778 _TableView::SetTextColorOfEmptyTableView(const Color& color)
 779 {
 780         if (__textColorOfEmptyTableView == color)
 781         {
 782                 return E_SUCCESS;
 783         }
 784
 785         result r = SetProperty("textColorOfEmptyTableView", Variant(color));
 786
 787         SysTryReturn(NID_UI_CTRL, r == E_SUCCESS, r, r, "[%s] Propagating.", GetErrorMessage(r));
 788
 789         return __pTableViewPresenter->SetStatusChanged(true);
 790 }
 791
 792 Variant
 793 _TableView::GetPropertyTextOfEmptyTableView(void) const
 794 {
 795         return Variant(__textOfEmptyTableView);
 796 }
 797
 798 String
 799 _TableView::GetTextOfEmptyTableView(void) const
 800 {
 801         Variant textOfEmptyTableView = GetProperty("textOfEmptyTableView");
 802
 803         return textOfEmptyTableView.ToString();
 804 }
 805
 806 result
 807 _TableView::SetPropertyTextOfEmptyTableView(const Variant& textOfEmptyTableView)
 808 {
 809         __textOfEmptyTableView = textOfEmptyTableView.ToString();
 810
 811         return E_SUCCESS;
 812 }
 813
 814 result
 815 _TableView::SetTextOfEmptyTableView(const String& text)
 816 {
 817         if (__textOfEmptyTableView == text)
 818         {
 819                 return E_SUCCESS;
 820         }
 821
 822         result r = SetProperty("textOfEmptyTableView", Variant(text));
 823
 824         SysTryReturn(NID_UI_CTRL, r == E_SUCCESS, r, r, "[%s] Propagating.", GetErrorMessage(r));
 825
 826         return __pTableViewPresenter->SetStatusChanged(true);
 827 }
 828
 829 void
 830 _TableView::FireTableViewItemEvent(int groupIndex, int itemIndex, TableViewNotifyType type, _TableViewItem* pItem)
 831 {
 832         if (type == TABLEVIEW_NOTIFY_TYPE_ANNEX_CHECK)
 833         {
 834                 __pTableViewPresenter->GetModel()->SetItemChecked(groupIndex, itemIndex, true);
 835         }
 836         else if (type == TABLEVIEW_NOTIFY_TYPE_ANNEX_UNCHECK)
 837         {
 838                 __pTableViewPresenter->GetModel()->SetItemChecked(groupIndex, itemIndex, false);
 839         }
 840
 841         if (__pTableViewItemEvent != null)
 842         {
 843                 _TableViewItemEventArg* pArg = new (std::nothrow) _TableViewItemEventArg(groupIndex, itemIndex, 0, 0, pItem, type);
 844                 SysTryReturnVoidResult(NID_UI_CTRL, pArg, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] The memory is insufficient.");
 845                 __pTableViewItemEvent->Fire(*pArg);
 846         }
 847 }
 848
 849 void
 850 _TableView::FireTableViewItemSweepEvent(int groupIndex, int itemIndex, TableViewSweepDirection directioin)
 851 {
 852         if (__pTableViewItemEvent != null)
 853         {
 854                 _TableViewItemEventArg* pArg = new (std::nothrow) _TableViewItemEventArg(groupIndex, itemIndex, directioin, 0, null, TABLEVIEW_NOTIFY_TYPE_ITEM_SWEPT);
 855                 SysTryReturnVoidResult(NID_UI_CTRL, pArg, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] The memory is insufficient.");
 856                 __pTableViewItemEvent->Fire(*pArg);
 857         }
 858 }
 859
 860 void
 861 _TableView::FireTableViewItemReorderEvent(int fromItemIndex, int toItemIndex)
 862 {
 863         if (__pTableViewItemEvent != null)
 864         {
 865                 _TableViewItemEventArg* pArg = new (std::nothrow) _TableViewItemEventArg(fromItemIndex, toItemIndex, 0, 0, null, TABLEVIEW_NOTIFY_TYPE_REORDERED_ITEM);
 866                 SysTryReturnVoidResult(NID_UI_CTRL, pArg, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] The memory is insufficient.");
 867                 __pTableViewItemEvent->Fire(*pArg);
 868         }
 869 }
 870 void
 871 _TableView::FireTableViewItemReorderEvent(int fromGroupIndex, int fromItemIndex, int toGroupIndex, int toItemIndex)
 872 {
 873         if (__pTableViewItemEvent != null)
 874         {
 875                 _TableViewItemEventArg* pArg = new (std::nothrow) _TableViewItemEventArg(fromGroupIndex, fromItemIndex, toGroupIndex, toItemIndex, null, TABLEVIEW_NOTIFY_TYPE_REORDERED_ITEM);
 876                 SysTryReturnVoidResult(NID_UI_CTRL, pArg, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] The memory is insufficient.");
 877                 __pTableViewItemEvent->Fire(*pArg);
 878         }
 879 }
 880
 881 void
 882 _TableView::FireTableViewContextItemActivationEvent(int groupIndex, int itemIndex, _TableViewItem* pItem, bool activated)
 883 {
 884         if (__pTableViewItemEvent != null)
 885         {
 886                 _TableViewItemEventArg* pArg = new (std::nothrow) _TableViewItemEventArg(groupIndex, itemIndex, 0, 0, pItem, TABLEVIEW_NOTIFY_TYPE_CONTEXT_ITEM_ACTIVATION, activated);
 887                 SysTryReturnVoidResult(NID_UI_CTRL, pArg, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] The memory is insufficient.");
 888                 __pTableViewItemEvent->Fire(*pArg);
 889         }
 890 }
 891
 892 result
 893 _TableView::ExpandGroup(int groupIndex)
 894 {
 895         if (IsOnProcessing())
 896         {
 897                 return E_INVALID_OPERATION;
 898         }
 899         return __pTableViewPresenter->ExpandGroup(groupIndex, true);
 900 }
 901
 902 result
 903 _TableView::CollapseGroup(int groupIndex)
 904 {
 905         if (IsOnProcessing())
 906         {
 907                 return E_INVALID_OPERATION;
 908         }
 909         return __pTableViewPresenter->CollapseGroup(groupIndex, true);
 910 }
 911
 912 bool
 913 _TableView::IsGroupExpanded(int groupIndex) const
 914 {
 915         return __pTableViewPresenter->IsGroupExpanded(groupIndex);
 916 }
 917
 918 result
 919 _TableView::ExpandAllGroup(bool animation)
 920 {
 921         if (IsOnProcessing())
 922         {
 923                 return E_INVALID_OPERATION;
 924         }
 925
 926         int groupCount = GetGroupCount();
 927
 928         for (int i = 0; i < groupCount; i++)
 929         {
 930                  __pTableViewPresenter->ExpandGroup(i, false);
 931         }
 932
 933         return E_SUCCESS;
 934 }
 935
 936 result
 937 _TableView::CollapseAllGroup(bool animation)
 938 {
 939         if (IsOnProcessing())
 940         {
 941                 return E_INVALID_OPERATION;
 942         }
 943
 944         int groupCount = GetGroupCount();
 945
 946         for (int i = 0; i < groupCount; i++)
 947         {
 948                  __pTableViewPresenter->CollapseGroup(i, false);
 949         }
 950
 951         return E_SUCCESS;
 952 }
 953
 954 void
 955 _TableView::SetGroupedLookEnabled(bool enable)
 956 {
 957         __groupedLookEnable = enable;
 958
 959         if (__tableViewStyle == TABLE_VIEW_STYLE_SECTION && !__groupedLookEnable)
 960         {
 961                 __pTableViewPresenter->SetLeftMargin(0);
 962         }
 963 }
 964
 965 bool
 966 _TableView::IsGroupedLookEnabled(void) const
 967 {
 968         return __groupedLookEnable;
 969 }
 970
 971 bool
 972 _TableView::GetFirstDrawnFlag(void) const
 973 {
 974         return __pTableViewPresenter->GetFirstDrawnFlag();
 975 }
 976
 977 int
 978 _TableView::GetMaxItemCachingSize(void) const
 979 {
 980         return __pTableViewPresenter->GetMaxItemCachingSize();
 981 }
 982
 983 void
 984 _TableView::OnDraw(void)
 985 {
 986         __pTableViewPresenter->Draw();
 987 }
 988
 989 void
 990 _TableView::OnChildAttached(const _Control& child)
 991 {
 992         _ScrollPanel::OnChildAttached(child);
 993 }
 994
 995 void
 996 _TableView::OnChildDetached(const _Control& child)
 997 {
 998         _ScrollPanel::OnChildDetached(child);
 999 }
1000
1001 void
1002 _TableView::OnBoundsChanged(void)
1003 {
1004         if (__scrollStyle == TABLE_VIEW_SCROLL_BAR_STYLE_FAST_SCROLL || __scrollStyle == TABLE_VIEW_SCROLL_BAR_STYLE_NONE)
1005         {
1006                 _Scroll* pScroll = _ScrollPanel::GetScrollBar();
1007                 if (pScroll == null)
1008                 {
1009                         Rectangle bounds = GetBounds();
1010
1011                         pScroll = _Scroll::CreateScrollN(*this,
1012                                                                                         SCROLL_DIRECTION_VERTICAL,
1013                                                                                         false,
1014                                                                                         false,
1015                                                                                         false,
1016                                                                                         false,
1017                                                                                         bounds.height,
1018                                                                                         bounds.height,
1019                                                                                         0);
1020                         SysTryReturnVoidResult(NID_UI_CTRL, pScroll != null, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] The memory is insufficient.");
1021
1022                         pScroll->EnableScrollingEffect(false);
1023                         pScroll->SetVisibleState(false);
1024                         _ScrollPanel::SetScrollBar(pScroll);
1025
1026                         pScroll->AddScrollEventListener(*this);
1027                         AttachSystemChild(*pScroll);
1028                 }
1029
1030                 if (__pFastScroll == null && __scrollStyle == TABLE_VIEW_SCROLL_BAR_STYLE_FAST_SCROLL)
1031                 {
1032                         __pFastScroll = _FastScroll::CreateFastScrollN(*this);
1033                         if (__pFastScroll != null)
1034                         {
1035                                 AttachSystemChild(*__pFastScroll);
1036                         }
1037                 }
1038         }
1039         else
1040         {
1041                 _Scroll* pScroll = _ScrollPanel::GetScrollBar();
1042
1043                 if (pScroll == null)
1044                 {
1045                         Rectangle bounds = GetBounds();
1046
1047                         pScroll = _Scroll::CreateScrollN(*this,
1048                                                                                         SCROLL_DIRECTION_VERTICAL,
1049                                                                                         ((__scrollStyle == TABLE_VIEW_SCROLL_BAR_STYLE_FIXED) ? false : true),
1050                                                                                         ((__scrollStyle == TABLE_VIEW_SCROLL_BAR_STYLE_JUMP_TO_TOP) ? true : false),
1051                                                                                         ((__scrollStyle == TABLE_VIEW_SCROLL_BAR_STYLE_THUMB) ? true : false),
1052                                                                                         ((__scrollStyle == TABLE_VIEW_SCROLL_BAR_STYLE_FIXED) ? true : false),
1053                                                                                         bounds.height,
1054                                                                                         bounds.height,
1055                                                                                         0);
1056                         SysTryReturnVoidResult(NID_UI_CTRL, pScroll != null, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] The memory is insufficient.");
1057
1058                         pScroll->EnableScrollingEffect(true);
1059                         _ScrollPanel::SetScrollBar(pScroll);
1060
1061                         pScroll->AddScrollEventListener(*this);
1062                         AttachSystemChild(*pScroll);
1063                 }
1064         }
1065
1066         _ScrollPanel::OnBoundsChanged();
1067 }
1068
1069 _UiTouchEventDelivery
1070 _TableView::OnPreviewTouchPressed(const _Control& source, const _TouchInfo& touchinfo)
1071 {
1072         return __pTableViewPresenter->OnPreviewTouchPressed(source, touchinfo);
1073 }
1074
1075 _UiTouchEventDelivery
1076 _TableView::OnPreviewTouchMoved(const _Control& source, const _TouchInfo& touchinfo)
1077 {
1078         return __pTableViewPresenter->OnPreviewTouchMoved(source, touchinfo);
1079 }
1080
1081 _UiTouchEventDelivery
1082 _TableView::OnPreviewTouchReleased(const _Control& source, const _TouchInfo& touchinfo)
1083 {
1084         return __pTableViewPresenter->OnPreviewTouchReleased(source, touchinfo);
1085 }
1086
1087 _UiTouchEventDelivery
1088 _TableView::OnPreviewTouchCanceled(const _Control& source, const _TouchInfo& touchinfo)
1089 {
1090         return __pTableViewPresenter->OnPreviewTouchCanceled(source, touchinfo);
1091 }
1092
1093 bool
1094 _TableView::OnTouchPressed(const _Control& source, const _TouchInfo& touchinfo)
1095 {
1096         return __pTableViewPresenter->OnTouchPressed(source, touchinfo);
1097 }
1098
1099 bool
1100 _TableView::OnTouchMoved(const _Control& source, const _TouchInfo& touchinfo)
1101 {
1102         return __pTableViewPresenter->OnTouchMoved(source, touchinfo);
1103 }
1104
1105 bool
1106 _TableView::OnTouchReleased(const _Control& source, const _TouchInfo& touchinfo)
1107 {
1108         return __pTableViewPresenter->OnTouchReleased(source, touchinfo);
1109 }
1110
1111 bool
1112 _TableView::OnTouchCanceled(const _Control& source, const _TouchInfo& touchinfo)
1113 {
1114         return __pTableViewPresenter->OnTouchCanceled(source, touchinfo);
1115 }
1116
1117 bool
1118 _TableView::OnFlickGestureDetected(_TouchFlickGestureDetector& gesture)
1119 {
1120         return __pTableViewPresenter->OnFlickGestureDetected(gesture);
1121 }
1122
1123 bool
1124 _TableView::OnFlickGestureCanceled(_TouchFlickGestureDetector& gesture)
1125 {
1126         return __pTableViewPresenter->OnFlickGestureCanceled(gesture);
1127 }
1128
1129 result
1130 _TableView::SetTableViewStatusChanged(bool changed)
1131 {
1132         return __pTableViewPresenter->SetStatusChanged(changed);
1133 }
1134
1135 bool
1136 _TableView::IsOnProcessing(void)
1137 {
1138         _TableViewItemProviderAdaptor* pProviderAdapter = __pTableViewPresenter->GetTableViewItemProviderAdaptor();
1139         if (pProviderAdapter != null)
1140         {
1141                 if (pProviderAdapter->IsOnProcessing())
1142                 {
1143                         return true;
1144                 }
1145         }
1146
1147         return false;
1148 }
1149
1150 }}} // Tizen::Ui::Controls