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 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_TableView.cpp
  20  * @brief               This file implements the _TableView class.
  21  */
  22
  23 #include <FGrp_BitmapImpl.h>
  24 #include "FUi_ControlManager.h"
  25 #include "FUi_ResourceManager.h"
  26 #include "FUiAnim_VisualElement.h"
  27 #include "FUiCtrl_ListViewModel.h"
  28 #include "FUiCtrl_FastScroll.h"
  29 #include "FUiCtrl_Scroll.h"
  30 #include "FUiCtrl_TableView.h"
  31 #include "FUiCtrl_TableViewPresenter.h"
  32 #include "FUiCtrl_TableViewItem.h"
  33 #include "FUiCtrl_TableViewItemProvider.h"
  34 #include "FUiCtrl_TableViewItemProviderAdaptor.h"
  35 #include "FUiCtrl_UiTableViewItemEvent.h"
  36 #include "FUi_CoordinateSystemUtils.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         , __pExpandGroupAnimation(null)
  64         , __pCollapseGroupAnimation(null)
  65         , __pSweptAnimation(null)
  66         , __pRemoveItemtAnimation(null)
  67 {
  68         GET_COLOR_CONFIG(TABLEVIEW::SECTIONITEM_BG_NORMAL, __sectionStyleColor);
  69         GET_COLOR_CONFIG(TABLEVIEW::ITEM_DIVIDER_BOTTOM_BG_NORMAL, __itemDividerColor);
  70 }
  71
  72 _TableView::~_TableView(void)
  73 {
  74         if (__pTableViewPresenter)
  75         {
  76                 __pTableViewPresenter->BlockAnimationCallback(true);
  77         }
  78
  79         if (GetVisualElement() != null)
  80         {
  81                 __pExpandGroupAnimation->SetVisualElementAnimationTickEventListener(null);
  82                 __pExpandGroupAnimation->SetVisualElementAnimationStatusEventListener(null);
  83
  84                 __pCollapseGroupAnimation->SetVisualElementAnimationTickEventListener(null);
  85                 __pCollapseGroupAnimation->SetVisualElementAnimationStatusEventListener(null);
  86
  87                 __pSweptAnimation->SetVisualElementAnimationTickEventListener(null);
  88                 __pSweptAnimation->SetVisualElementAnimationStatusEventListener(null);
  89
  90                 __pRemoveItemtAnimation->SetVisualElementAnimationTickEventListener(null);
  91                 __pRemoveItemtAnimation->SetVisualElementAnimationStatusEventListener(null);
  92
  93                 GetVisualElement()->RemoveAllAnimations();
  94         }
  95
  96         //SuperClass will delete.
  97         __pTableViewPresenter = null;
  98
  99         if (__pFastScroll != null)
 100         {
 101                 DetachSystemChild(*__pFastScroll);
 102
 103                 delete __pFastScroll;
 104                 __pFastScroll = null;
 105         }
 106
 107         delete __pTableViewItemEvent;
 108         __pTableViewItemEvent = null;
 109
 110         delete __pExpandGroupAnimation;
 111         __pExpandGroupAnimation = null;
 112
 113         delete __pCollapseGroupAnimation;
 114         __pCollapseGroupAnimation = null;
 115
 116         delete __pSweptAnimation;
 117         __pSweptAnimation = null;
 118
 119         delete __pRemoveItemtAnimation;
 120         __pRemoveItemtAnimation = null;
 121 }
 122
 123 _TableView*
 124 _TableView::CreateTableViewN(TableViewStyle style, bool itemDivider, TableViewScrollBarStyle scrollStyle)
 125 {
 126         ClearLastResult();
 127         result r = E_SUCCESS;
 128
 129         _TableView* pTableView = null;
 130
 131         _ControlManager* pControlManager = _ControlManager::GetInstance();
 132         SysTryReturn(NID_UI_CTRL, pControlManager, null, E_SYSTEM, "[%s] A system error has been occurred.", GetErrorMessage(E_SYSTEM));
 133         pTableView = new (std::nothrow) _TableView;
 134         SysTryCatch(NID_UI_CTRL, pTableView != null, , E_OUT_OF_MEMORY, "[%s] Memory allocation failed.", GetErrorMessage(E_OUT_OF_MEMORY));
 135
 136         r = GetLastResult();
 137         SysTryCatch(NID_UI_CTRL, r == E_SUCCESS, , E_SYSTEM, "[%s] Propagating", GetErrorMessage(r));
 138
 139         pTableView->AcquireHandle();
 140
 141         r = pTableView->Initialize(style, itemDivider, scrollStyle);
 142         SysTryCatch(NID_UI_CTRL, (r == E_SUCCESS), , r, "[%s] Failed to Initialize", GetErrorMessage(r));
 143
 144         return pTableView;
 145
 146 CATCH:
 147         delete pTableView;
 148         return null;
 149 }
 150
 151 result
 152 _TableView::Initialize(TableViewStyle style, bool itemDivider, TableViewScrollBarStyle scrollStyle)
 153 {
 154         result r = E_SUCCESS;
 155
 156         _TableViewPresenter* pPresenter = new (std::nothrow) _TableViewPresenter();
 157         SysTryReturn(NID_UI_CTRL, pPresenter != null, E_OUT_OF_MEMORY, E_OUT_OF_MEMORY, "[%s] Memory allocation failed.", GetErrorMessage(E_OUT_OF_MEMORY));
 158
 159         r = pPresenter->Construct(this);
 160         SysTryReturn(NID_UI_CTRL, (r == E_SUCCESS), r, r, "[%s] Propagating.", GetErrorMessage(r));
 161
 162         r = _ScrollPanel::Initialize(*pPresenter, false);
 163         SetTableViewPresenter(pPresenter);
 164         SetScrollAreaAutoResizingEnabled(false);
 165
 166         FloatRectangle rect = GetBoundsF();
 167         SetScrollAreaBounds(rect);
 168
 169         SetTableViewStyle(style);
 170         SetScrollStyle(scrollStyle);
 171         SetItemDividerEnabled(itemDivider);
 172
 173         Color bgColor;
 174         GET_COLOR_CONFIG(TABLEVIEW::BG_NORMAL, bgColor);
 175         SetBackgroundColor(bgColor);
 176
 177         __pExpandGroupAnimation = new (std::nothrow) VisualElementValueAnimation;
 178         SysTryReturn(NID_UI_CTRL, __pExpandGroupAnimation != null, false, E_OUT_OF_MEMORY, "[%s] Memory allocation failed.", GetErrorMessage(E_OUT_OF_MEMORY));
 179
 180         __pExpandGroupAnimation->SetTimingFunction(VisualElementAnimation::GetTimingFunctionByName("EaseInOut"));
 181         r = GetLastResult();
 182         SysTryCatch(NID_UI_CTRL, r == E_SUCCESS, , r, "[%s] Propagating.", GetErrorMessage(r));
 183
 184         __pExpandGroupAnimation->SetVisualElementAnimationTickEventListener(__pTableViewPresenter);
 185         r = GetLastResult();
 186         SysTryCatch(NID_UI_CTRL, r == E_SUCCESS, , r, "[%s] Propagating.", GetErrorMessage(r));
 187
 188         __pExpandGroupAnimation->SetVisualElementAnimationStatusEventListener(__pTableViewPresenter);
 189         r = GetLastResult();
 190         SysTryCatch(NID_UI_CTRL, r == E_SUCCESS, , r, "[%s] Propagating.", GetErrorMessage(r));
 191
 192         __pCollapseGroupAnimation = new (std::nothrow) VisualElementValueAnimation;
 193         SysTryReturn(NID_UI_CTRL, __pCollapseGroupAnimation != null, false, E_OUT_OF_MEMORY, "[%s] Memory allocation failed.", GetErrorMessage(E_OUT_OF_MEMORY));
 194
 195         __pCollapseGroupAnimation->SetTimingFunction(VisualElementAnimation::GetTimingFunctionByName("EaseInOut"));
 196         r = GetLastResult();
 197         SysTryCatch(NID_UI_CTRL, r == E_SUCCESS, , r, "[%s] Propagating.", GetErrorMessage(r));
 198
 199         __pCollapseGroupAnimation->SetVisualElementAnimationTickEventListener(__pTableViewPresenter);
 200         r = GetLastResult();
 201         SysTryCatch(NID_UI_CTRL, r == E_SUCCESS, , r, "[%s] Propagating.", GetErrorMessage(r));
 202
 203         __pCollapseGroupAnimation->SetVisualElementAnimationStatusEventListener(__pTableViewPresenter);
 204         r = GetLastResult();
 205         SysTryCatch(NID_UI_CTRL, r == E_SUCCESS, , r, "[%s] Propagating.", GetErrorMessage(r));
 206
 207         __pSweptAnimation = new (std::nothrow) VisualElementValueAnimation;
 208         SysTryReturn(NID_UI_CTRL, __pSweptAnimation != null, false, E_OUT_OF_MEMORY, "[%s] Memory allocation failed.", GetErrorMessage(E_OUT_OF_MEMORY));
 209
 210         __pSweptAnimation->SetTimingFunction(VisualElementAnimation::GetTimingFunctionByName("EaseInOut"));
 211         r = GetLastResult();
 212         SysTryCatch(NID_UI_CTRL, r == E_SUCCESS, , r, "[%s] Propagating.", GetErrorMessage(r));
 213
 214         __pSweptAnimation->SetVisualElementAnimationTickEventListener(__pTableViewPresenter);
 215         r = GetLastResult();
 216         SysTryCatch(NID_UI_CTRL, r == E_SUCCESS, , r, "[%s] Propagating.", GetErrorMessage(r));
 217
 218         __pSweptAnimation->SetVisualElementAnimationStatusEventListener(__pTableViewPresenter);
 219         r = GetLastResult();
 220         SysTryCatch(NID_UI_CTRL, r == E_SUCCESS, , r, "[%s] Propagating.", GetErrorMessage(r));
 221
 222         __pRemoveItemtAnimation = new (std::nothrow) VisualElementValueAnimation;
 223         SysTryReturn(NID_UI_CTRL, __pRemoveItemtAnimation != null, false, E_OUT_OF_MEMORY,"[%s] Memory allocation failed.", GetErrorMessage(E_OUT_OF_MEMORY));
 224
 225         __pRemoveItemtAnimation->SetTimingFunction(VisualElementAnimation::GetTimingFunctionByName("EaseIn"));
 226         r = GetLastResult();
 227         SysTryCatch(NID_UI_CTRL, r == E_SUCCESS, , r, "[%s] Propagating.", GetErrorMessage(r));
 228
 229         __pRemoveItemtAnimation->SetVisualElementAnimationTickEventListener(this);
 230         r = GetLastResult();
 231         SysTryCatch(NID_UI_CTRL, r == E_SUCCESS, , r, "[%s] Propagating.", GetErrorMessage(r));
 232
 233         __pRemoveItemtAnimation->SetVisualElementAnimationStatusEventListener(this);
 234         r = GetLastResult();
 235         SysTryCatch(NID_UI_CTRL, r == E_SUCCESS, , r, "[%s] Propagating.", GetErrorMessage(r));
 236
 237         return r;
 238
 239 CATCH:
 240         delete __pExpandGroupAnimation;
 241         __pExpandGroupAnimation = null;
 242
 243         delete __pCollapseGroupAnimation;
 244         __pCollapseGroupAnimation = null;
 245
 246         delete __pSweptAnimation;
 247         __pSweptAnimation = null;
 248
 249         delete __pRemoveItemtAnimation;
 250         __pRemoveItemtAnimation = null;
 251
 252         return r;
 253 }
 254
 255 _TableViewPresenter*
 256 _TableView::GetTableViewPresenter(void) const
 257 {
 258         return __pTableViewPresenter;
 259 }
 260
 261 void
 262 _TableView::SetTableViewPresenter(const _TableViewPresenter* pPresenter)
 263 {
 264         __pTableViewPresenter = const_cast<_TableViewPresenter*>(pPresenter);
 265 }
 266
 267 result
 268 _TableView::SetItemProvider(const _TableViewItemProvider* pProvider)
 269 {
 270         return __pTableViewPresenter->SetItemProvider(pProvider);
 271 }
 272
 273 void
 274 _TableView::SetItemProviderAdaptor(_TableViewItemProviderAdaptor* pProviderAdaptor)
 275 {
 276         __pTableViewPresenter->SetTableViewItemProviderAdaptor(pProviderAdaptor);
 277 }
 278
 279 _TableViewItemProviderAdaptor*
 280 _TableView::GetItemProviderAdaptor(void) const
 281 {
 282         return __pTableViewPresenter->GetTableViewItemProviderAdaptor();
 283 }
 284
 285 void
 286 _TableView::SetSweepEnabled(bool enable)
 287 {
 288         __sweepEnabled = enable;
 289 }
 290
 291 bool
 292 _TableView::IsSweepEnabled(void) const
 293 {
 294         return __sweepEnabled;
 295 }
 296
 297 bool
 298 _TableView::IsReorderModeEnabled(void) const
 299 {
 300         return __reorderEnabled;
 301 }
 302
 303 result
 304 _TableView::SetReorderModeEnabled(bool enable)
 305 {
 306         if (__reorderEnabled != enable)
 307         {
 308                 __reorderEnabled = enable;
 309
 310                 __pTableViewPresenter->SetReorderMode(enable);
 311         }
 312
 313         return E_SUCCESS;
 314 }
 315
 316 void
 317 _TableView::SetAnnexFocused(bool isAnnexFocused)
 318 {
 319         return __pTableViewPresenter->SetAnnexFocused(isAnnexFocused);
 320 }
 321
 322 void
 323 _TableView::SetTableViewFocused(bool focusStatus)
 324 {
 325         return __pTableViewPresenter->SetTableViewFocused(focusStatus);
 326 }
 327
 328 bool
 329 _TableView::IsTableViewFocused(void)
 330 {
 331         return __pTableViewPresenter->IsTableViewFocused();
 332 }
 333
 334 result
 335 _TableView::SetItemChecked(int groupIndex, int itemIndex, bool check)
 336 {
 337         if (IsOnProcessing())
 338         {
 339                 return E_INVALID_OPERATION;
 340         }
 341         return __pTableViewPresenter->SetItemChecked(groupIndex, itemIndex, check);
 342 }
 343
 344 bool
 345 _TableView::IsItemChecked(int groupIndex, int itemIndex) const
 346 {
 347         return __pTableViewPresenter->IsItemChecked(groupIndex, itemIndex);
 348 }
 349
 350 result
 351 _TableView::SetItemEnabled(int groupIndex, int itemIndex, bool enable)
 352 {
 353         if (IsOnProcessing())
 354         {
 355                 return E_INVALID_OPERATION;
 356         }
 357         return __pTableViewPresenter->SetItemEnabled(groupIndex, itemIndex, enable);
 358 }
 359
 360 void
 361 _TableView::CheckItemHeightAndRefreshLayout(int groupIndex, int itemIndex)
 362 {
 363         TableViewItemTag itemTag = {groupIndex, itemIndex};
 364         __pTableViewPresenter->CheckItemHeightAndRefreshLayout(itemTag, true);
 365 }
 366
 367 _TableViewItem*
 368 _TableView::FindItem(int groupIndex, int itemIndex) const
 369 {
 370         TableViewItemTag itemTag = {groupIndex, itemIndex};
 371
 372         return __pTableViewPresenter->FindItem(itemTag);
 373 }
 374
 375 void
 376 _TableView::UnloadItem(int groupIndex, int itemIndex)
 377 {
 378         if (IsOnProcessing())
 379         {
 380                 return;
 381         }
 382         return __pTableViewPresenter->UnloadItem(groupIndex, itemIndex);
 383 }
 384
 385 _TableViewItem*
 386 _TableView::LoadItem(int groupIndex, int itemIndex)
 387 {
 388         if (IsOnProcessing())
 389         {
 390                 return null;
 391         }
 392         return __pTableViewPresenter->LoadItem(groupIndex, itemIndex);
 393 }
 394
 395 void
 396 _TableView::RefreshItemLayout(int groupIndex, int itemIndex)
 397 {
 398         __pTableViewPresenter->RefreshItemLayout(groupIndex, itemIndex);
 399 }
 400
 401 void
 402 _TableView::GetFirstLoadedItemIndex(int& groupIndex, int& itemIndex) const
 403 {
 404         __pTableViewPresenter->GetFirstLoadedItemIndex(groupIndex, itemIndex);
 405 }
 406
 407 void
 408 _TableView::GetLastLoadedItemIndex(int& groupIndex, int& itemIndex) const
 409 {
 410         __pTableViewPresenter->GetLastLoadedItemIndex(groupIndex, itemIndex);
 411 }
 412
 413 void
 414 _TableView::ResetSweepItem(void)
 415 {
 416         __pTableViewPresenter->ResetSweepItem();
 417 }
 418
 419 void
 420 _TableView::GetSweepItemIndex(int& groupIndex, int& itemIndex) const
 421 {
 422         __pTableViewPresenter->GetSweepItemIndex(groupIndex, itemIndex);
 423 }
 424
 425 int
 426 _TableView::GetPressedItemCount(void)
 427 {
 428         return __pTableViewPresenter->GetPressedItemCount();
 429 }
 430
 431 float
 432 _TableView::GetTopMargin(void) const
 433 {
 434         return __pTableViewPresenter->GetTopMargin();
 435 }
 436
 437 result
 438 _TableView::SetTopMargin(float topMargin)
 439 {
 440         return __pTableViewPresenter->SetTopMargin(topMargin);
 441 }
 442
 443 float
 444 _TableView::GetBottomMargin(void) const
 445 {
 446         return __pTableViewPresenter->GetBottomMargin();
 447 }
 448
 449 result
 450 _TableView::SetBottomMargin(float bottomMargin)
 451 {
 452         return __pTableViewPresenter->SetBottomMargin(bottomMargin);
 453 }
 454
 455 bool
 456 _TableView::IsItemEnabled(int groupIndex, int itemIndex) const
 457 {
 458         return __pTableViewPresenter->IsItemEnabled(groupIndex, itemIndex);
 459 }
 460
 461 result
 462 _TableView::GetTopDrawnItemIndex(int& groupIndex, int& itemIndex) const
 463 {
 464         groupIndex = -1;
 465         itemIndex = -1;
 466
 467         return __pTableViewPresenter->GetTopDrawnItemIndex(groupIndex, itemIndex);
 468 }
 469
 470 result
 471 _TableView::SetTopDrawnItemIndex(int groupIndex, int itemIndex)
 472 {
 473         if (IsOnProcessing())
 474         {
 475                 return E_INVALID_OPERATION;
 476         }
 477         return __pTableViewPresenter->SetTopDrawnItemIndex(groupIndex, itemIndex);
 478 }
 479
 480 result
 481 _TableView::GetBottomDrawnItemIndex(int& groupIndex, int& itemIndex) const
 482 {
 483         groupIndex = -1;
 484         itemIndex = -1;
 485
 486         return __pTableViewPresenter->GetBottomDrawnItemIndex(groupIndex, itemIndex);
 487 }
 488
 489 result
 490 _TableView::SetBottomDrawnItemIndex(int groupIndex, int itemIndex)
 491 {
 492         if (IsOnProcessing())
 493         {
 494                 return E_INVALID_OPERATION;
 495         }
 496         return __pTableViewPresenter->SetBottomDrawnItemIndex(groupIndex, itemIndex);
 497 }
 498
 499 result
 500 _TableView::ScrollByPixel(float scrollDistance)
 501 {
 502         return __pTableViewPresenter->ScrollByPixel(scrollDistance);
 503 }
 504
 505 void
 506 _TableView::SetScrollEnabled(bool enable)
 507 {
 508         __pTableViewPresenter->SetScrollEnabled(enable);
 509 }
 510
 511 bool
 512 _TableView::IsScrollEnabled(void) const
 513 {
 514         return __pTableViewPresenter->IsScrollEnabled();
 515 }
 516
 517 result
 518 _TableView::AddTableViewItemEventListener(const _ITableViewItemEventListener& listener)
 519 {
 520         result r = E_SUCCESS;
 521
 522         if (__pTableViewItemEvent == null)
 523         {
 524                 __pTableViewItemEvent = new (std::nothrow) _UiTableViewItemEvent();
 525                 SysTryReturn(NID_UI_CTRL, __pTableViewItemEvent != null, E_OUT_OF_MEMORY, E_OUT_OF_MEMORY, "[%s] Memory allocation failed.", GetErrorMessage(E_OUT_OF_MEMORY));
 526
 527                 r = __pTableViewItemEvent->Construct(this, TABLE_VIEW_STYLE_SIMPLE);
 528                 SysTryReturn(NID_UI_CTRL, r == E_SUCCESS, E_SYSTEM, E_SYSTEM, "[%s] A system error has been occurred. Unable to construct Item Event.", GetErrorMessage(E_SYSTEM));
 529         }
 530
 531         r = __pTableViewItemEvent->AddListener(listener);
 532         SysTryReturn(NID_UI_CTRL, r == E_SUCCESS, r, r, "[%s] Propagating.", GetErrorMessage(GetLastResult()));
 533
 534         return E_SUCCESS;
 535 }
 536
 537 result
 538 _TableView::RemoveTableViewItemEventListener(const _ITableViewItemEventListener& listener)
 539 {
 540         SysTryReturn(NID_UI_CTRL, __pTableViewItemEvent != null, E_OBJ_NOT_FOUND, E_OBJ_NOT_FOUND, "[%s] This instance is not available.", GetErrorMessage(E_OBJ_NOT_FOUND));
 541
 542         return __pTableViewItemEvent->RemoveListener(listener);
 543 }
 544
 545 result
 546 _TableView::AddGroupedTableViewItemEventListener(const _ITableViewItemEventListener& listener)
 547 {
 548         result r = E_SUCCESS;
 549
 550         if (__pTableViewItemEvent == null)
 551         {
 552                 __pTableViewItemEvent = new (std::nothrow) _UiTableViewItemEvent();
 553                 SysTryReturn(NID_UI_CTRL, __pTableViewItemEvent != null, E_OUT_OF_MEMORY, E_OUT_OF_MEMORY, "[%s] Memory allocation failed.", GetErrorMessage(E_OUT_OF_MEMORY));
 554
 555                 r = __pTableViewItemEvent->Construct(this, TABLE_VIEW_STYLE_GROUPED);
 556                 SysTryReturn(NID_UI_CTRL, r == E_SUCCESS, E_SYSTEM, E_SYSTEM, "[%s] A system error has been occurred. Unable to construct Item Event.", GetErrorMessage(E_SYSTEM));
 557         }
 558
 559         r = __pTableViewItemEvent->AddListener(listener);
 560         SysTryReturn(NID_UI_CTRL, r == E_SUCCESS, r, r, "[%s] Propagating.", GetErrorMessage(GetLastResult()));
 561
 562         return E_SUCCESS;
 563 }
 564
 565 result
 566 _TableView::RemoveGroupedTableViewItemEventListener(const _ITableViewItemEventListener& listener)
 567 {
 568         SysTryReturn(NID_UI_CTRL, __pTableViewItemEvent != null, E_OBJ_NOT_FOUND, E_OBJ_NOT_FOUND, "[%s] This instance is not available.", GetErrorMessage(E_OBJ_NOT_FOUND));
 569
 570         return __pTableViewItemEvent->RemoveListener(listener);
 571 }
 572
 573 result
 574 _TableView::AddSectionTableViewItemEventListener(const _ITableViewItemEventListener& listener)
 575 {
 576         result r = E_SUCCESS;
 577
 578         if (__pTableViewItemEvent == null)
 579         {
 580                 __pTableViewItemEvent = new (std::nothrow) _UiTableViewItemEvent();
 581                 SysTryReturn(NID_UI_CTRL, __pTableViewItemEvent != null, E_OUT_OF_MEMORY, E_OUT_OF_MEMORY, "[%s] Memory allocation failed.", GetErrorMessage(E_OUT_OF_MEMORY));
 582
 583                 r = __pTableViewItemEvent->Construct(this, TABLE_VIEW_STYLE_SECTION);
 584                 SysTryReturn(NID_UI_CTRL, r == E_SUCCESS, E_SYSTEM, E_SYSTEM,  "[%s] A system error has been occurred. Unable to construct Item Event.", GetErrorMessage(E_SYSTEM));
 585         }
 586
 587         r = __pTableViewItemEvent->AddListener(listener);
 588         SysTryReturn(NID_UI_CTRL, r == E_SUCCESS, r, r, "[%s] Propagating.", GetErrorMessage(GetLastResult()));
 589
 590         return E_SUCCESS;
 591 }
 592
 593 result
 594 _TableView::RemoveSectionTableViewItemEventListener(const _ITableViewItemEventListener& listener)
 595 {
 596         SysTryReturn(NID_UI_CTRL, __pTableViewItemEvent != null, E_OBJ_NOT_FOUND, E_OBJ_NOT_FOUND, "[%s] This instance is not available.", GetErrorMessage(E_OBJ_NOT_FOUND));
 597
 598         return __pTableViewItemEvent->RemoveListener(listener);
 599 }
 600
 601 result
 602 _TableView::AddFastScrollListener(const _IUiFastScrollListener& listener)
 603 {
 604         SysTryReturn(NID_UI_CTRL, __pFastScroll != null, E_OBJ_NOT_FOUND, E_OBJ_NOT_FOUND, "[%s] This instance is not available.", GetErrorMessage(E_OBJ_NOT_FOUND));
 605         __pFastScroll->AddFastScrollEventListener(listener);
 606
 607         return E_SUCCESS;
 608 }
 609
 610 result
 611 _TableView::RemoveFastScrollListener(const _IUiFastScrollListener& listener)
 612 {
 613         SysTryReturn(NID_UI_CTRL, __pFastScroll != null, E_OBJ_NOT_FOUND, E_OBJ_NOT_FOUND, "[%s] This instance is not available.", GetErrorMessage(E_OBJ_NOT_FOUND));
 614         __pFastScroll->RemoveFastScrollEventListener(listener);
 615
 616         return E_SUCCESS;
 617 }
 618
 619 _FastScroll*
 620 _TableView::GetFastScrollBar(void) const
 621 {
 622         return __pFastScroll;
 623 }
 624
 625 result
 626 _TableView::SetFastScrollIndex(const String& text, bool useSearchIcon)
 627 {
 628         SysTryReturn(NID_UI_CTRL,
 629                                 (__scrollStyle == TABLE_VIEW_SCROLL_BAR_STYLE_FAST_SCROLL || __scrollStyle == TABLE_VIEW_SCROLL_BAR_STYLE_FAST_SCROLL_FIXED),
 630                 E_INVALID_OPERATION, E_INVALID_OPERATION, "[%s]The style of TableView scroll is not TABLE_VIEW_SCROLL_BAR_STYLE_FAST_SCROLL", GetErrorMessage(E_INVALID_OPERATION));
 631         SysTryReturn(NID_UI_CTRL, __pFastScroll != null, E_OBJ_NOT_FOUND, E_OBJ_NOT_FOUND, "[%s] This instance is not available.", GetErrorMessage(E_OBJ_NOT_FOUND));
 632         SysTryReturn(NID_UI_CTRL, (useSearchIcon || (!useSearchIcon && text.GetLength() > 0)), E_INVALID_ARG, E_INVALID_ARG,"[%s] Invalid input argument.",GetErrorMessage(E_INVALID_ARG));
 633
 634         result r = E_SUCCESS;
 635
 636         const wchar_t* pIndexTextArray = text.GetPointer();
 637         int indexLenth = 1;
 638         int indexCount = text.GetLength();
 639         int childOrder = 0;
 640
 641         // Set the primary index.
 642         _FastScrollIndex* pRootIndex = __pFastScroll->GetIndex();
 643         if (pRootIndex == null)
 644         {
 645                 pRootIndex = _FastScrollIndex::CreateFastScrollIndexN();
 646                 r = GetLastResult();
 647                 SysTryReturn(NID_UI_CTRL, pRootIndex != null, r, r, "[%s] Propagating.", GetErrorMessage(r));
 648
 649                 r = __pFastScroll->SetIndex(pRootIndex);
 650                 SysTryReturn(NID_UI_CTRL, r == E_SUCCESS, r, r, "[%s] Propagating.", GetErrorMessage(r));
 651         }
 652         else
 653         {
 654                 pRootIndex->RemoveChildren(true);
 655         }
 656
 657         if (useSearchIcon == true)
 658         {
 659                 Bitmap* pSearchIcon = null;
 660                 String fastScrollSearchIconIndex(L"[SEARCH_ICON_INDEX]");
 661
 662                 r = GET_BITMAP_CONFIG_N(TABLEVIEW::SEARCH_ICON_NORMAL, BITMAP_PIXEL_FORMAT_ARGB8888, pSearchIcon);
 663                 SysTryReturn(NID_UI_CTRL, r == E_SUCCESS, E_SYSTEM, E_SYSTEM, "[%s] A system error has been occurred. SearchIcon image load failed.", GetErrorMessage(E_SYSTEM));
 664
 665                 _FastScrollIndex* pIndex = pRootIndex->AddChildIndex(&fastScrollSearchIconIndex, pSearchIcon);
 666                 SysTryReturn(NID_UI_CTRL, pIndex, E_INVALID_STATE, E_INVALID_STATE, "[%s] Primary Index is in an invalid state.", GetErrorMessage(E_INVALID_STATE));
 667
 668                 childOrder++;
 669         }
 670
 671         r = pRootIndex->AddChildTextIndexArray(childOrder, pIndexTextArray, indexLenth, indexCount);
 672         SysTryReturn(NID_UI_CTRL, r == E_SUCCESS, r, r, "[%s] Propagating.", GetErrorMessage(r));
 673
 674         r = __pFastScroll->UpdateIndex();
 675         SysTryReturn(NID_UI_CTRL, r == E_SUCCESS, r, r, "[%s] Propagating.", GetErrorMessage(r));
 676         return E_SUCCESS;
 677 }
 678
 679 result
 680 _TableView::SetScrollStyle(TableViewScrollBarStyle scrollStyle)
 681 {
 682         __scrollStyle = scrollStyle;
 683
 684         return E_SUCCESS;
 685 }
 686
 687 TableViewStyle
 688 _TableView::GetTableViewStyle(void) const
 689 {
 690         return __tableViewStyle;
 691 }
 692
 693 void
 694 _TableView::SetTableViewStyle(TableViewStyle style)
 695 {
 696         if(__tableViewStyle == style)
 697         {
 698                 return;
 699         }
 700
 701         __tableViewStyle = style;
 702
 703         if (__tableViewStyle == TABLE_VIEW_STYLE_SECTION)
 704         {
 705                 int topMargin = 0;
 706                 GET_FIXED_VALUE_CONFIG(TABLEVIEW::SECTIONITEM_TOP_MARGIN, _CONTROL_ORIENTATION_PORTRAIT, topMargin);
 707                 SetTopMargin(topMargin);
 708
 709                 int x = 0;
 710                 GET_SHAPE_CONFIG(TABLEVIEW::GROUPITEM_LEFT_MARGIN, _CONTROL_ORIENTATION_PORTRAIT, x);
 711                 __pTableViewPresenter->SetLeftMargin(x);
 712
 713                 __groupedLookEnable = true;
 714         }
 715 }
 716
 717 TableViewScrollBarStyle
 718 _TableView::GetScrollStyle(void) const
 719 {
 720         return __scrollStyle;
 721 }
 722
 723 int
 724 _TableView::GetGroupCount(void) const
 725 {
 726         return __pTableViewPresenter->GetGroupCount();
 727 }
 728
 729 int
 730 _TableView::GetItemCountAt(int groupIndex) const
 731 {
 732         SysTryReturn(NID_UI_CTRL, groupIndex >= 0 && groupIndex < GetGroupCount(), -1, E_INVALID_ARG, "[%s] Invalid argument is used. Group Index={%d} ",  GetErrorMessage(E_INVALID_ARG), groupIndex);
 733
 734         int itemCount = __pTableViewPresenter->GetItemCountAt(groupIndex);
 735
 736         if (GetTableViewStyle() == TABLE_VIEW_STYLE_SECTION)
 737         {
 738                 // sub section footer
 739                 if (__pTableViewPresenter->HasSectionFooter(groupIndex) == true)
 740                 {
 741                         itemCount--;
 742                         if (itemCount < 0)
 743                         {
 744                                 itemCount = 0;
 745                         }
 746                 }
 747         }
 748
 749         return itemCount;
 750 }
 751
 752 result
 753 _TableView::RefreshTableView(int groupIndex, int itemIndex, TableViewRefreshType type, bool animation)
 754 {
 755         if (IsOnProcessing())
 756         {
 757                 return E_INVALID_OPERATION;
 758         }
 759
 760         return __pTableViewPresenter->RefreshTableView(groupIndex, itemIndex, type, animation);
 761 }
 762
 763 result
 764 _TableView::RefreshAllItems(void)
 765 {
 766         if (IsOnProcessing())
 767         {
 768                 return E_INVALID_OPERATION;
 769         }
 770
 771         return __pTableViewPresenter->RefreshAllItems();
 772 }
 773
 774
 775 result
 776 _TableView::UpdateTableView(bool isRestoreAnnexFocusValue)
 777 {
 778         if (IsOnProcessing())
 779         {
 780                 return E_INVALID_OPERATION;
 781         }
 782         return __pTableViewPresenter->UpdateTableView(isRestoreAnnexFocusValue);
 783 }
 784
 785 result
 786 _TableView::GetItemIndexFromPosition(const Point& position, int& groupIndex, int& itemIndex) const
 787 {
 788         return __pTableViewPresenter->GetItemIndexFromPosition(_CoordinateSystemUtils::ConvertToFloat(position), groupIndex, itemIndex);
 789 }
 790
 791 result
 792 _TableView::GetItemIndexFromPosition(const Tizen::Graphics::FloatPoint& position, int& groupIndex, int& itemIndex) const
 793 {
 794         return __pTableViewPresenter->GetItemIndexFromPosition(position, groupIndex, itemIndex);
 795 }
 796
 797
 798 result
 799 _TableView::SetPropertySectionColor(const Variant& sectionColor)
 800 {
 801         __sectionStyleColor = sectionColor.ToColor();
 802
 803         return E_SUCCESS;
 804 }
 805
 806 result
 807 _TableView::SetSectionColor(const Color& color)
 808 {
 809         if (GetTableViewStyle() != TABLE_VIEW_STYLE_SECTION)
 810         {
 811                 SysLog(NID_UI_CTRL, "[%s] The style of TableView is not TABLE_VIEW_STYLE_SECTION.", GetErrorMessage(E_INVALID_OPERATION));
 812                 return E_INVALID_OPERATION;
 813         }
 814
 815         if (__sectionStyleColor == color)
 816         {
 817                 return E_SUCCESS;
 818         }
 819
 820         result r = SetProperty("sectionColor", Variant(color));
 821         SysTryReturn(NID_UI_CTRL, r == E_SUCCESS, r, r, "[%s] Propagating.", GetErrorMessage(r));
 822
 823         return __pTableViewPresenter->SetStatusChanged(true);
 824 }
 825
 826 Variant
 827 _TableView::GetPropertySectionColor(void) const
 828 {
 829         return Variant(__sectionStyleColor);
 830 }
 831
 832 Color
 833 _TableView::GetSectionColor(void) const
 834 {
 835         if (GetTableViewStyle() != TABLE_VIEW_STYLE_SECTION)
 836         {
 837                 SetLastResult(E_SUCCESS);
 838                 return Color(0);
 839         }
 840
 841         Variant sectionColor = GetProperty("sectionColor");
 842
 843         return sectionColor.ToColor();
 844 }
 845
 846 Variant
 847 _TableView::GetPropertyItemDividerColor(void) const
 848 {
 849         return Variant(__itemDividerColor);
 850 }
 851
 852 Color
 853 _TableView::GetItemDividerColor(void) const
 854 {
 855         Variant itemDividerColor = GetProperty("itemDividerColor");
 856
 857         return itemDividerColor.ToColor();
 858 }
 859
 860 result
 861 _TableView::SetPropertyItemDividerColor(const Variant& itemDividerColor)
 862 {
 863         if(__itemDividerColor == itemDividerColor.ToColor())
 864         {
 865                 return E_SUCCESS;
 866         }
 867
 868         __itemDividerColor = itemDividerColor.ToColor();
 869
 870         return __pTableViewPresenter->SetStatusChanged(true);
 871 }
 872
 873 result
 874 _TableView::SetItemDividerColor(const Color& color)
 875 {
 876         return SetProperty("itemDividerColor", Variant(color));
 877 }
 878
 879 bool
 880 _TableView::IsItemDividerEnabled(void) const
 881 {
 882         return __itemDividerEnabled;
 883 }
 884
 885 void
 886 _TableView::SetItemDividerEnabled(bool enable)
 887 {
 888         __itemDividerEnabled = enable;
 889 }
 890
 891 Bitmap*
 892 _TableView::GetBitmapOfEmptyTableView(void) const
 893 {
 894         return __pBitmapOfEmptyTableView;
 895 }
 896
 897 result
 898 _TableView::SetBitmapOfEmptyTableView(const Bitmap* pBitmap)
 899 {
 900         Bitmap* pCloneBitmap = null;
 901
 902         if (pBitmap == null)
 903         {
 904                 delete __pBitmapOfEmptyTableView;
 905                 __pBitmapOfEmptyTableView = null;
 906
 907                 return E_SUCCESS;
 908         }
 909         else
 910         {
 911                 pCloneBitmap = _BitmapImpl::CloneN(*pBitmap);
 912                 SysTryReturn(NID_UI_CTRL, pCloneBitmap != null, GetLastResult(), GetLastResult(), "[%s] Propagating.", GetErrorMessage(GetLastResult()));
 913
 914                 delete __pBitmapOfEmptyTableView;
 915                 __pBitmapOfEmptyTableView = pCloneBitmap;
 916         }
 917
 918         return __pTableViewPresenter->SetStatusChanged(true);
 919 }
 920
 921 Variant
 922 _TableView::GetPropertyTextColorOfEmptyTableView(void) const
 923 {
 924         return Variant(__textColorOfEmptyTableView);
 925 }
 926
 927 Color
 928 _TableView::GetTextColorOfEmptyTableView(void) const
 929 {
 930         Variant textColorOfEmptyTableView = GetProperty("textColorOfEmptyTableView");
 931
 932         return textColorOfEmptyTableView.ToColor();
 933 }
 934
 935 result
 936 _TableView::SetPropertyTextColorOfEmptyTableView(const Variant& textColorOfEmptyTableView)
 937 {
 938         __textColorOfEmptyTableView = textColorOfEmptyTableView.ToColor();
 939
 940         return E_SUCCESS;
 941 }
 942
 943 result
 944 _TableView::SetTextColorOfEmptyTableView(const Color& color)
 945 {
 946         if (__textColorOfEmptyTableView == color)
 947         {
 948                 return E_SUCCESS;
 949         }
 950
 951         result r = SetProperty("textColorOfEmptyTableView", Variant(color));
 952
 953         SysTryReturn(NID_UI_CTRL, r == E_SUCCESS, r, r, "[%s] Propagating.", GetErrorMessage(r));
 954
 955         return __pTableViewPresenter->SetStatusChanged(true);
 956 }
 957
 958 Variant
 959 _TableView::GetPropertyTextOfEmptyTableView(void) const
 960 {
 961         return Variant(__textOfEmptyTableView);
 962 }
 963
 964 String
 965 _TableView::GetTextOfEmptyTableView(void) const
 966 {
 967         Variant textOfEmptyTableView = GetProperty("textOfEmptyTableView");
 968
 969         return textOfEmptyTableView.ToString();
 970 }
 971
 972 result
 973 _TableView::SetPropertyTextOfEmptyTableView(const Variant& textOfEmptyTableView)
 974 {
 975         __textOfEmptyTableView = textOfEmptyTableView.ToString();
 976
 977         return E_SUCCESS;
 978 }
 979
 980 result
 981 _TableView::SetTextOfEmptyTableView(const String& text)
 982 {
 983         if (__textOfEmptyTableView == text)
 984         {
 985                 return E_SUCCESS;
 986         }
 987
 988         result r = SetProperty("textOfEmptyTableView", Variant(text));
 989
 990         SysTryReturn(NID_UI_CTRL, r == E_SUCCESS, r, r, "[%s] Propagating.", GetErrorMessage(r));
 991
 992         return __pTableViewPresenter->SetStatusChanged(true);
 993 }
 994
 995 void
 996 _TableView::FireTableViewItemEvent(int groupIndex, int itemIndex, TableViewNotifyType type, _TableViewItem* pItem)
 997 {
 998         if (type == TABLEVIEW_NOTIFY_TYPE_ANNEX_CHECK)
 999         {
1000                 __pTableViewPresenter->GetModel()->SetItemChecked(groupIndex, itemIndex, true);
1001         }
1002         else if (type == TABLEVIEW_NOTIFY_TYPE_ANNEX_UNCHECK)
1003         {
1004                 __pTableViewPresenter->GetModel()->SetItemChecked(groupIndex, itemIndex, false);
1005         }
1006
1007         if (__pTableViewItemEvent != null)
1008         {
1009                 _TableViewItemEventArg* pArg = new (std::nothrow) _TableViewItemEventArg(groupIndex, itemIndex, 0, 0, pItem, type);
1010                 SysTryReturnVoidResult(NID_UI_CTRL, pArg, E_OUT_OF_MEMORY, "[%s] Memory allocation failed.", GetErrorMessage(E_OUT_OF_MEMORY));
1011                 __pTableViewItemEvent->Fire(*pArg);
1012         }
1013 }
1014
1015 void
1016 _TableView::FireTableViewItemSweepEvent(int groupIndex, int itemIndex, TableViewSweepDirection directioin)
1017 {
1018         if (__pTableViewItemEvent != null)
1019         {
1020                 _TableViewItemEventArg* pArg = new (std::nothrow) _TableViewItemEventArg(groupIndex, itemIndex, directioin, 0, null, TABLEVIEW_NOTIFY_TYPE_ITEM_SWEPT);
1021                 SysTryReturnVoidResult(NID_UI_CTRL, pArg, E_OUT_OF_MEMORY,"[%s] Memory allocation failed.", GetErrorMessage(E_OUT_OF_MEMORY));
1022                 __pTableViewItemEvent->Fire(*pArg);
1023         }
1024 }
1025
1026 void
1027 _TableView::FireTableViewItemReorderEvent(int fromItemIndex, int toItemIndex)
1028 {
1029         if (__pTableViewItemEvent != null)
1030         {
1031                 _TableViewItemEventArg* pArg = new (std::nothrow) _TableViewItemEventArg(fromItemIndex, toItemIndex, 0, 0, null, TABLEVIEW_NOTIFY_TYPE_REORDERED_ITEM);
1032                 SysTryReturnVoidResult(NID_UI_CTRL, pArg, E_OUT_OF_MEMORY, "[%s] Memory allocation failed.", GetErrorMessage(E_OUT_OF_MEMORY));
1033                 __pTableViewItemEvent->Fire(*pArg);
1034         }
1035 }
1036 void
1037 _TableView::FireTableViewItemReorderEvent(int fromGroupIndex, int fromItemIndex, int toGroupIndex, int toItemIndex)
1038 {
1039         if (__pTableViewItemEvent != null)
1040         {
1041                 _TableViewItemEventArg* pArg = new (std::nothrow) _TableViewItemEventArg(fromGroupIndex, fromItemIndex, toGroupIndex, toItemIndex, null, TABLEVIEW_NOTIFY_TYPE_REORDERED_ITEM);
1042                 SysTryReturnVoidResult(NID_UI_CTRL, pArg, E_OUT_OF_MEMORY, "[%s] Memory allocation failed.", GetErrorMessage(E_OUT_OF_MEMORY));
1043                 __pTableViewItemEvent->Fire(*pArg);
1044         }
1045 }
1046
1047 void
1048 _TableView::FireTableViewContextItemActivationEvent(int groupIndex, int itemIndex, _TableViewItem* pItem, bool activated)
1049 {
1050         if (__pTableViewItemEvent != null)
1051         {
1052                 _TableViewItemEventArg* pArg = new (std::nothrow) _TableViewItemEventArg(groupIndex, itemIndex, 0, 0, pItem, TABLEVIEW_NOTIFY_TYPE_CONTEXT_ITEM_ACTIVATION, activated);
1053                 SysTryReturnVoidResult(NID_UI_CTRL, pArg, E_OUT_OF_MEMORY, "[%s] Memory allocation failed.", GetErrorMessage(E_OUT_OF_MEMORY));
1054                 __pTableViewItemEvent->Fire(*pArg);
1055         }
1056 }
1057
1058 result
1059 _TableView::ExpandGroup(int groupIndex)
1060 {
1061         if (IsOnProcessing())
1062         {
1063                 return E_INVALID_OPERATION;
1064         }
1065         return __pTableViewPresenter->ExpandGroup(groupIndex, true);
1066 }
1067
1068 result
1069 _TableView::CollapseGroup(int groupIndex)
1070 {
1071         if (IsOnProcessing())
1072         {
1073                 return E_INVALID_OPERATION;
1074         }
1075         return __pTableViewPresenter->CollapseGroup(groupIndex, true);
1076 }
1077
1078 bool
1079 _TableView::IsGroupExpanded(int groupIndex) const
1080 {
1081         return __pTableViewPresenter->IsGroupExpanded(groupIndex);
1082 }
1083
1084 result
1085 _TableView::ExpandAllGroup(bool animation)
1086 {
1087         if (IsOnProcessing())
1088         {
1089                 return E_INVALID_OPERATION;
1090         }
1091
1092         int groupCount = GetGroupCount();
1093
1094         for (int i = 0; i < groupCount; i++)
1095         {
1096                  __pTableViewPresenter->ExpandGroup(i, false);
1097         }
1098
1099         return E_SUCCESS;
1100 }
1101
1102 result
1103 _TableView::CollapseAllGroup(bool animation)
1104 {
1105         if (IsOnProcessing())
1106         {
1107                 return E_INVALID_OPERATION;
1108         }
1109
1110         int groupCount = GetGroupCount();
1111
1112         for (int i = 0; i < groupCount; i++)
1113         {
1114                  __pTableViewPresenter->CollapseGroup(i, false);
1115         }
1116
1117         return E_SUCCESS;
1118 }
1119
1120 void
1121 _TableView::StopExpandCollapseAnimation(void)
1122 {
1123         __pTableViewPresenter->StopExpandCollapseAnimation();
1124 }
1125
1126 void
1127 _TableView::SetGroupedLookEnabled(bool enable)
1128 {
1129         __groupedLookEnable = enable;
1130
1131         if (__tableViewStyle == TABLE_VIEW_STYLE_SECTION && !__groupedLookEnable)
1132         {
1133                 __pTableViewPresenter->SetLeftMargin(0);
1134         }
1135 }
1136
1137 bool
1138 _TableView::IsGroupedLookEnabled(void) const
1139 {
1140         return __groupedLookEnable;
1141 }
1142
1143 bool
1144 _TableView::GetFirstDrawnFlag(void) const
1145 {
1146         return __pTableViewPresenter->GetFirstDrawnFlag();
1147 }
1148
1149 int
1150 _TableView::GetMaxItemCachingSize(void) const
1151 {
1152         return __pTableViewPresenter->GetMaxItemCachingSize();
1153 }
1154
1155 result
1156 _TableView::OpenContextItem(int groupIndex, int itemIndex)
1157 {
1158         return __pTableViewPresenter->OpenContextItem(groupIndex, itemIndex);
1159 }
1160 result
1161 _TableView::CloseContextItem(int groupIndex, int itemIndex)
1162 {
1163         return __pTableViewPresenter->CloseContextItem(groupIndex, itemIndex);
1164 }
1165 bool
1166 _TableView::IsContextItemOpened(int groupIndex, int itemIndex) const
1167 {
1168         return __pTableViewPresenter->IsContextItemOpened(groupIndex, itemIndex);
1169 }
1170
1171 result
1172 _TableView::SetSectionHeaderTextHorizontalAlignment(int sectionIndex, HorizontalAlignment alignment)
1173 {
1174         return __pTableViewPresenter->SetSectionHeaderTextHorizontalAlignment(sectionIndex, alignment);
1175 }
1176
1177 HorizontalAlignment
1178 _TableView::GetSectionHeaderTextHorizontalAlignment(int sectionIndex) const
1179 {
1180         return __pTableViewPresenter->GetSectionHeaderTextHorizontalAlignment(sectionIndex);
1181 }
1182
1183 result
1184 _TableView::SetSectionFooterTextHorizontalAlignment(int sectionIndex, HorizontalAlignment alignment)
1185 {
1186         return __pTableViewPresenter->SetSectionFooterTextHorizontalAlignment(sectionIndex, alignment);
1187 }
1188
1189 HorizontalAlignment
1190 _TableView::GetSectionFooterTextHorizontalAlignment(int sectionIndex) const
1191 {
1192         return __pTableViewPresenter->GetSectionFooterTextHorizontalAlignment(sectionIndex);
1193 }
1194
1195 void
1196 _TableView::FireItemTouchReleasedEventDuringPressing(int groupIndex, int itemIndex)
1197 {
1198         __pTableViewPresenter->FireItemTouchReleasedEventDuringPressing(groupIndex, itemIndex);
1199 }
1200
1201 void
1202 _TableView::OnDraw(void)
1203 {
1204         __pTableViewPresenter->Draw();
1205 }
1206
1207 void
1208 _TableView::OnChildAttached(const _Control& child)
1209 {
1210         _ScrollPanel::OnChildAttached(child);
1211 }
1212
1213 void
1214 _TableView::OnChildDetached(const _Control& child)
1215 {
1216         _ScrollPanel::OnChildDetached(child);
1217 }
1218
1219 void
1220 _TableView::OnBoundsChanged(void)
1221 {
1222         if (__scrollStyle == TABLE_VIEW_SCROLL_BAR_STYLE_FAST_SCROLL || __scrollStyle == TABLE_VIEW_SCROLL_BAR_STYLE_FAST_SCROLL_FIXED || __scrollStyle == TABLE_VIEW_SCROLL_BAR_STYLE_NONE)
1223         {
1224                 _Scroll* pScroll = _ScrollPanel::GetScrollBar();
1225                 if (pScroll == null)
1226                 {
1227                         FloatRectangle bounds = GetBoundsF();
1228
1229                         pScroll = _Scroll::CreateScrollN(*this,
1230                                                                                         SCROLL_DIRECTION_VERTICAL,
1231                                                                                         false,
1232                                                                                         false,
1233                                                                                         false,
1234                                                                                         false,
1235                                                                                         bounds.height,
1236                                                                                         bounds.height,
1237                                                                                         0);
1238                         SysTryReturnVoidResult(NID_UI_CTRL, pScroll != null, GetLastResult(), "[%s] Propagating", GetErrorMessage(GetLastResult()));
1239
1240                         pScroll->EnableScrollingEffect(false);
1241                         pScroll->SetVisibleState(false);
1242                         _ScrollPanel::SetScrollBar(pScroll);
1243
1244                         pScroll->AddScrollEventListener(*this);
1245                         AttachSystemChild(*pScroll);
1246                 }
1247
1248                 if (__scrollStyle == TABLE_VIEW_SCROLL_BAR_STYLE_FAST_SCROLL || __scrollStyle == TABLE_VIEW_SCROLL_BAR_STYLE_FAST_SCROLL_FIXED)
1249                 {
1250                         if (__pFastScroll == null)
1251                         {
1252                                 if (__scrollStyle == TABLE_VIEW_SCROLL_BAR_STYLE_FAST_SCROLL_FIXED)
1253                                 {
1254                                         __pFastScroll = _FastScroll::CreateFastScrollN(*this, false);
1255                                 }
1256                                 else
1257                                 {
1258                                         __pFastScroll = _FastScroll::CreateFastScrollN(*this);
1259                                 }
1260
1261                                 if (__pFastScroll != null)
1262                                 {
1263                                         AttachSystemChild(*__pFastScroll);
1264                                 }
1265                         }
1266                         else
1267                         {
1268                                 __pFastScroll->OnParentBoundsChanged();
1269                         }
1270                 }
1271         }
1272         else
1273         {
1274                 _Scroll* pScroll = _ScrollPanel::GetScrollBar();
1275
1276                 if (pScroll == null)
1277                 {
1278                         FloatRectangle bounds = GetBoundsF();
1279
1280                         pScroll = _Scroll::CreateScrollN(*this,
1281                                                                                         SCROLL_DIRECTION_VERTICAL,
1282                                                                                         ((__scrollStyle == TABLE_VIEW_SCROLL_BAR_STYLE_FIXED) ? false : true),
1283                                                                                         ((__scrollStyle == TABLE_VIEW_SCROLL_BAR_STYLE_JUMP_TO_TOP) ? true : false),
1284                                                                                         ((__scrollStyle == TABLE_VIEW_SCROLL_BAR_STYLE_THUMB) ? true : false),
1285                                                                                         ((__scrollStyle == TABLE_VIEW_SCROLL_BAR_STYLE_FIXED) ? true : false),
1286                                                                                         bounds.height,
1287                                                                                         bounds.height,
1288                                                                                         0);
1289                         SysTryReturnVoidResult(NID_UI_CTRL, pScroll != null, GetLastResult(), "[%s] Propagating", GetErrorMessage(GetLastResult()));
1290
1291                         pScroll->EnableScrollingEffect(true);
1292                         _ScrollPanel::SetScrollBar(pScroll);
1293
1294                         pScroll->AddScrollEventListener(*this);
1295                         AttachSystemChild(*pScroll);
1296                 }
1297         }
1298
1299         _ScrollPanel::OnBoundsChanged();
1300 }
1301
1302 void
1303 _TableView::OnChangeLayout(_ControlOrientation orientation)
1304 {
1305         __pTableViewPresenter->OnChangeLayout(orientation);
1306 }
1307
1308 _UiTouchEventDelivery
1309 _TableView::OnPreviewTouchPressed(const _Control& source, const _TouchInfo& touchinfo)
1310 {
1311         return __pTableViewPresenter->OnPreviewTouchPressed(source, touchinfo);
1312 }
1313
1314 _UiTouchEventDelivery
1315 _TableView::OnPreviewTouchMoved(const _Control& source, const _TouchInfo& touchinfo)
1316 {
1317         return __pTableViewPresenter->OnPreviewTouchMoved(source, touchinfo);
1318 }
1319
1320 _UiTouchEventDelivery
1321 _TableView::OnPreviewTouchReleased(const _Control& source, const _TouchInfo& touchinfo)
1322 {
1323         return __pTableViewPresenter->OnPreviewTouchReleased(source, touchinfo);
1324 }
1325
1326 _UiTouchEventDelivery
1327 _TableView::OnPreviewTouchCanceled(const _Control& source, const _TouchInfo& touchinfo)
1328 {
1329         return __pTableViewPresenter->OnPreviewTouchCanceled(source, touchinfo);
1330 }
1331
1332 bool
1333 _TableView::OnTouchPressed(const _Control& source, const _TouchInfo& touchinfo)
1334 {
1335         return __pTableViewPresenter->OnTouchPressed(source, touchinfo);
1336 }
1337
1338 bool
1339 _TableView::OnTouchMoved(const _Control& source, const _TouchInfo& touchinfo)
1340 {
1341         return __pTableViewPresenter->OnTouchMoved(source, touchinfo);
1342 }
1343
1344 bool
1345 _TableView::OnTouchReleased(const _Control& source, const _TouchInfo& touchinfo)
1346 {
1347         return __pTableViewPresenter->OnTouchReleased(source, touchinfo);
1348 }
1349
1350 bool
1351 _TableView::OnTouchCanceled(const _Control& source, const _TouchInfo& touchinfo)
1352 {
1353         return __pTableViewPresenter->OnTouchCanceled(source, touchinfo);
1354 }
1355
1356 bool
1357 _TableView::OnFocusGained(const _Control& source)
1358 {
1359         __pTableViewPresenter->SetTableViewFocused(true);
1360
1361         return true;
1362 }
1363
1364 void
1365 _TableView::SetFocusItemOnPressedState(int groupIndex, int itemIndex)
1366 {
1367         __pTableViewPresenter->SetFocusItemOnPressedState(groupIndex, itemIndex);
1368 }
1369
1370 bool
1371 _TableView::OnTraversalControlFocusGained(void)
1372 {
1373         return __pTableViewPresenter->OnTraversalControlFocusGained();
1374 }
1375
1376 bool
1377 _TableView::OnTraversalControlFocusLost(void)
1378 {
1379         return __pTableViewPresenter->OnTraversalControlFocusLost();
1380 }
1381
1382 bool
1383 _TableView::OnFlickGestureDetected(_TouchFlickGestureDetector& gesture)
1384 {
1385         return __pTableViewPresenter->OnFlickGestureDetected(gesture);
1386 }
1387
1388 bool
1389 _TableView::OnFlickGestureCanceled(_TouchFlickGestureDetector& gesture)
1390 {
1391         return __pTableViewPresenter->OnFlickGestureCanceled(gesture);
1392 }
1393
1394 result
1395 _TableView::SetTableViewStatusChanged(bool changed)
1396 {
1397         return __pTableViewPresenter->SetStatusChanged(changed);
1398 }
1399
1400 bool
1401 _TableView::IsOnProcessing(void)
1402 {
1403         _TableViewItemProviderAdaptor* pProviderAdapter = __pTableViewPresenter->GetTableViewItemProviderAdaptor();
1404         if (pProviderAdapter != null)
1405         {
1406                 if (pProviderAdapter->IsOnProcessing())
1407                 {
1408                         return true;
1409                 }
1410         }
1411
1412         return false;
1413 }
1414
1415 VisualElementValueAnimation*
1416 _TableView::GetVisualElementValueAnimation(const Tizen::Base::String& keyName) const
1417 {
1418         ClearLastResult();
1419
1420         VisualElementValueAnimation* pAnimation = null;
1421
1422         if (keyName == L"EXPAND_GROUP_ANIMATION")
1423         {
1424                 pAnimation = __pExpandGroupAnimation;
1425         }
1426         else if (keyName == L"COLLAPSE_GROUP_ANIMATION")
1427         {
1428                 pAnimation = __pCollapseGroupAnimation;
1429         }
1430         else if (keyName == L"SWEEP_ITEM_ANIMATION")
1431         {
1432                 pAnimation = __pSweptAnimation;
1433         }
1434         else if (keyName == L"REMOVE_ITEM_ANIMATION")
1435         {
1436                 pAnimation = __pRemoveItemtAnimation;
1437         }
1438
1439         return pAnimation;
1440 }
1441
1442 void
1443 _TableView::SetFocusDuringOrientationChange(void)
1444 {
1445         __pTableViewPresenter->SetFocusDuringOrientationChange();
1446 }
1447
1448 bool
1449 _TableView::OnKeyPressed(const _Control& source, const _KeyInfo& keyInfo)
1450 {
1451         return __pTableViewPresenter->OnKeyPressed(source, keyInfo);
1452 }
1453
1454 bool
1455 _TableView::OnKeyReleased(const _Control& source, const _KeyInfo& keyInfo)
1456 {
1457         return __pTableViewPresenter->OnKeyReleased(source, keyInfo);
1458 }
1459
1460 bool
1461 _TableView::IsChildControlFocusManage(void) const
1462 {
1463         return true;
1464 }
1465
1466 void
1467 _TableView::OnDrawFocus(void)
1468 {
1469         return __pTableViewPresenter->OnDrawFocus();
1470 }
1471
1472 void
1473 _TableView::OnFocusModeStateChanged(void)
1474 {
1475         return __pTableViewPresenter->OnFocusModeStateChanged();
1476 }
1477
1478 void
1479 _TableView::OnVisibleStateChanged(void)
1480 {
1481         return __pTableViewPresenter->OnVisibleStateChanged();
1482 }
1483
1484 void
1485 _TableView::OnAncestorEnableStateChanged(const _Control& control)
1486 {
1487         return __pTableViewPresenter->OnAncestorEnableStateChanged(control);
1488 }
1489
1490 void
1491 _TableView::OnAncestorVisibleStateChanged(const _Control& control)
1492 {
1493         return __pTableViewPresenter->OnAncestorVisibleStateChanged(control);
1494 }
1495
1496 void
1497 _TableView::OnFocusableStateChanged(bool focusalbeState)
1498 {
1499         return __pTableViewPresenter->OnFocusableStateChanged(focusalbeState);
1500 }
1501
1502 }}} // Tizen::Ui::Controls