src/ui/controls/FUiCtrl_TableViewItem.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_TableViewItem.cpp
  20  * @brief       This is the implementation file for _TableViewItem class.
  21  *
  22  * This file contains the implementation of _TableViewItem class.
  23  */
  24
  25 #include <FBaseUtilMath.h>
  26 #include <FGrp_BitmapImpl.h>
  27 #include "FUi_ResourceManager.h"
  28 #include "FUi_UiTouchEvent.h"
  29 #include "FUiAnim_VisualElement.h"
  30 #include "FUiAnim_ControlVisualElement.h"
  31 #include "FUiCtrl_TableViewItem.h"
  32 #include "FUiCtrl_TableView.h"
  33 #include "FUi_CoordinateSystemUtils.h"
  34 #include "FUi_Math.h"
  35 #include "FUiCtrl_LabelImpl.h"
  36 #include "FUi_Window.h"
  37
  38 using namespace Tizen::Base;
  39 using namespace Tizen::Base::Runtime;
  40 using namespace Tizen::Base::Collection;
  41 using namespace Tizen::Ui::Animations;
  42 using namespace Tizen::Graphics;
  43
  44 namespace Tizen { namespace Ui { namespace Controls
  45 {
  46
  47 _TableViewItemControl::_TableViewItemControl(void)
  48         :__pBackgroundBitmap(null)
  49 {
  50 }
  51
  52 _TableViewItemControl::~_TableViewItemControl(void)
  53 {
  54         if (__pBackgroundBitmap)
  55         {
  56                 delete __pBackgroundBitmap;
  57                 __pBackgroundBitmap = null;
  58         }
  59         ClearLastResult();
  60 }
  61
  62 void
  63 _TableViewItemControl::OnDraw(void)
  64 {
  65         Bitmap* pBitmap = GetBackgroundBitmap();
  66
  67         FloatRectangle bounds(0.0f, 0.0f, GetBoundsF().width, GetBoundsF().height); // +++ check floating
  68
  69         Color bgColor = GetBackgroundColor();
  70
  71         Canvas* pCanvas = null;
  72
  73         if (pBitmap != null)
  74         {
  75                 pCanvas = GetCanvasN();
  76                 if (pCanvas == null)
  77                 {
  78                         SysLog(NID_UI_CTRL, "Cannot get a canvas.");
  79
  80                         return;
  81                 }
  82
  83                 pCanvas->SetBackgroundColor(Color(0, 0, 0, 0));
  84                 pCanvas->Clear();
  85
  86                 if (_BitmapImpl::CheckNinePatchedBitmapStrictly(*pBitmap))
  87                 {
  88                         pCanvas->DrawNinePatchedBitmap(bounds, *pBitmap);
  89                 }
  90                 else
  91                 {
  92                         FloatRectangle drawingRect(0.0f, 0.0f, bounds.width, bounds.height);
  93                         pCanvas->DrawBitmap(drawingRect, *pBitmap);
  94                 }
  95
  96         }
  97         else
  98         {
  99                 if (IsCalledGetCanvasN() == false)
 100                 {
 101                         GetVisualElement()->SetBackgroundColor(_Colorf((float)bgColor.GetRed() / 255, (float)bgColor.GetGreen() / 255, (float)bgColor.GetBlue() / 255, (float)bgColor.GetAlpha() / 255));
 102                 }
 103                 else
 104                 {
 105                         pCanvas = GetCanvasN();
 106                         if (pCanvas == null)
 107                         {
 108                                 SysLog(NID_UI_CTRL, "Cannot get a canvas.");
 109
 110                                 return;
 111                         }
 112
 113                         pCanvas->SetBackgroundColor(Color(0, 0, 0, 0));
 114                         pCanvas->Clear();
 115                         pCanvas->FillRectangle(GetBackgroundColor(), bounds); // +++ check floating
 116                 }
 117         }
 118
 119         if (pCanvas)
 120         {
 121                 delete pCanvas;
 122         }
 123
 124         return;
 125 }
 126
 127 HitTestResult
 128 _TableViewItemControl::HitTest(const  Graphics :: FloatPoint & point)
 129 {
 130         return HIT_TEST_NOWHERE;
 131 }
 132
 133 _TableViewItemControl*
 134 _TableViewItemControl::CreateTableViewItemControlN(void)
 135 {
 136         _TableViewItemControl* pItemControl = new (std::nothrow) _TableViewItemControl();
 137         SysTryReturn(NID_UI_CTRL, pItemControl, null, E_OUT_OF_MEMORY, "[%s] Memory allocation failed.", GetErrorMessage(E_OUT_OF_MEMORY));
 138         SysTryCatch(NID_UI_CTRL, GetLastResult() == E_SUCCESS, , E_SYSTEM, "[%s] A system error has been occurred.", GetErrorMessage(E_SYSTEM));
 139
 140
 141         pItemControl->AcquireHandle();
 142
 143         return pItemControl;
 144
 145 CATCH:
 146         delete pItemControl;
 147         return null;
 148 }
 149
 150 result
 151 _TableViewItemControl::SetBackgroundBitmap(const Bitmap& bitmap)
 152 {
 153         result r = E_SYSTEM;
 154
 155         Bitmap* pClonedBitmap = _BitmapImpl::CloneN(bitmap);
 156
 157         if (pClonedBitmap)
 158         {
 159                 if (__pBackgroundBitmap != null)
 160                 {
 161                         delete __pBackgroundBitmap;
 162                 }
 163
 164                 __pBackgroundBitmap = pClonedBitmap;
 165
 166                 r = E_SUCCESS;
 167         }
 168
 169         return r;
 170 }
 171
 172 Bitmap*
 173 _TableViewItemControl::GetBackgroundBitmap(void) const
 174 {
 175         return __pBackgroundBitmap;
 176 }
 177
 178 _TableViewItem::_TableViewItem(float itemHeight)
 179         : _Control()
 180         , __pAppInfo(null)
 181         , __refCount(1)
 182         , __itemHeight(itemHeight)
 183         , __itemGroupIndex(-1)
 184         , __itemIndex(-1)
 185         , __checkedState(false)
 186         , __enabledState(true)
 187         , __itemChanged(true)
 188         , __reorderMode(false)
 189         , __itemSelected(false)
 190         , __itemTouchMoved(false)
 191         , __childMarginState(false)
 192         , __annexStyle(TABLE_VIEW_ANNEX_STYLE_NORMAL)
 193         , __drawingStatus(TABLE_VIEW_ITEM_DRAWING_STATUS_NORMAL)
 194         , __selectionStyle(TABLE_VIEW_ITEM_SELECTION_STYLE_WHOLE)
 195         , __itemType(TABLE_VIEW_ITEM_TYPE_NONE)
 196         , __pContextItem(null)
 197         , __isContextItem(false)
 198         , __isContextItemActivated(false)
 199         , __checkItemHeightNeeded(false)
 200         , __pItemDivider(null)
 201         , __pItemTopDivider(null)
 202         , __pItemAnnex(null)
 203         , __pItemCover(null)
 204         , __pItemAnnexLeftDivider(null)
 205         , __pItemAnnexRightDivider(null)
 206         , __itemWidth(0.0f)
 207         , __pDrawingProperty(null)
 208         , __itemDividerEnabled(true)
 209         , __pSimpleItemText(null)
 210         , __pSimpleItemBitmap(null)
 211         , __simpleItemTextSize(0)
 212         , __pHeaderFooterItemText(null)
 213         , __pDimLayer(null)
 214         , __touchStartPosition(0.0f, 0.0f)
 215         , __annexTouchStartPosition(0)
 216         , __annexOnOffHandlerMoved(false)
 217         , __annexOnOffHandlerPositionX(0.0f)
 218         , __childControlCenterAlign(false)
 219         , __customHeight(0.0f)
 220         , __animationCount(0)
 221         , __pAccessibilityElement(null)
 222         , __pAccessibilityOnOffElement(null)
 223         , __pPressedTimer(null)
 224         , __pReleasedTimer(null)
 225         , __isPressedTimerEnabled(false)
 226         , __isReleasedTimerEnabled(false)
 227         , __pressedControl(TABLE_VIEW_ITEM_PRESSED_NONE)
 228         , __releasedControl(TABLE_VIEW_ITEM_PRESSED_NONE)
 229         , __pCheckedTimer(null)
 230         , __isCheckedTimerEnabled(false)
 231         , __isCheckedAnimationEnabled(false)
 232         , __checkedCount(0)
 233         , __checkedBounds(FloatRectangle(0.0f, 0.0f, 0.0f, 0.0f))
 234         , __isItemLayoutEnabled(false)
 235         , __isMoveItemAnimationEnabled(false)
 236         , __isZoomInOutItemAnimationEnabled(false)
 237         , __isFadeInOutItemAnimationEnabled(false)
 238         , __isAnimationCallbackBlocked(false)
 239         , __isItemTapSoundEnabled(true)
 240         , __isTabSoundPlayed(false)
 241         , __isSelectedDetailButton(false)
 242         , __isSimpleLastItem(false)
 243         , __isSectionItem(false)
 244         , __isTouchPressOnScroll(false)
 245         , __isTouchCancelOnPressRelease(false)
 246         , __pHighlightVisualElement(null)
 247         , __pBitmapVisualElement(null)
 248         , __pMoveItemAnimation(null)
 249         , __pZoomInOutItemAnimation(null)
 250         , __pFadeInOutItemtAnimation(null)
 251 {
 252         for (int i = 0; i < 3; i++)
 253         {
 254                 __pItemBgBitmap[i] = null;
 255         }
 256
 257         GET_COLOR_CONFIG(TABLEVIEW::ITEM_BG_NORMAL, __colorItemBg[TABLE_VIEW_ITEM_DRAWING_STATUS_NORMAL]); // for support opacity 0x00
 258         GET_COLOR_CONFIG(TABLEVIEW::ITEM_BG_PRESSED, __colorItemBg[TABLE_VIEW_ITEM_DRAWING_STATUS_PRESSED]);
 259         GET_COLOR_CONFIG(TABLEVIEW::ITEM_BG_HIGHLIGHTED, __colorItemBg[TABLE_VIEW_ITEM_DRAWING_STATUS_HIGHLIGHTED]);
 260
 261         GET_COLOR_CONFIG(TABLEVIEW::ITEM_TEXT_NORMAL, __simpleItemTextColor[TABLE_VIEW_ITEM_DRAWING_STATUS_NORMAL]);
 262         GET_COLOR_CONFIG(TABLEVIEW::ITEM_TEXT_PRESSED, __simpleItemTextColor[TABLE_VIEW_ITEM_DRAWING_STATUS_PRESSED]);
 263         GET_COLOR_CONFIG(TABLEVIEW::ITEM_TEXT_HIGHLIGHTED, __simpleItemTextColor[TABLE_VIEW_ITEM_DRAWING_STATUS_HIGHLIGHTED]);
 264         GET_COLOR_CONFIG(TABLEVIEW::GROUPITEM_TEXT_NORMAL, __simpleItemTextColor[TABLE_VIEW_GROUPITEM_DRAWING_STATUS_NORMAL]);
 265         GET_COLOR_CONFIG(TABLEVIEW::GROUPITEM_TEXT_PRESSED, __simpleItemTextColor[TABLE_VIEW_GROUPITEM_DRAWING_STATUS_PRESSED]);
 266         GET_COLOR_CONFIG(TABLEVIEW::ITEM_TEXT_DISABLED, __simpleItemTextColor[TABLE_VIEW_SIMPLEITEM_DRAWING_STATUS_DISABLED]);
 267
 268
 269         _AccessibilityContainer* pContainer = GetAccessibilityContainer();
 270         if (pContainer)
 271         {
 272                 pContainer->Activate(true);
 273                 pContainer->AddListener(*this);
 274         }
 275 }
 276
 277 _TableViewItem::~_TableViewItem()
 278 {
 279         __isAnimationCallbackBlocked = true;
 280
 281         StopTouchPressedTimer(true);
 282         delete __pPressedTimer;
 283         __pPressedTimer = null;
 284
 285         StopTouchReleasedTimer(true);
 286         delete __pReleasedTimer;
 287         __pReleasedTimer = null;
 288
 289         _VisualElement* pVisualElement = GetVisualElement();
 290         if (pVisualElement != null)
 291         {
 292                 if (__pMoveItemAnimation != null)
 293                 {
 294                         __pMoveItemAnimation->SetVisualElementAnimationTickEventListener(null);
 295                         __pMoveItemAnimation->SetVisualElementAnimationStatusEventListener(null);
 296                 }
 297
 298                 if (__pZoomInOutItemAnimation != null)
 299                 {
 300                         __pZoomInOutItemAnimation->SetVisualElementAnimationTickEventListener(null);
 301                         __pZoomInOutItemAnimation->SetVisualElementAnimationStatusEventListener(null);
 302                 }
 303
 304                 if (__pFadeInOutItemtAnimation != null)
 305                 {
 306                         __pFadeInOutItemtAnimation->SetVisualElementAnimationTickEventListener(null);
 307                         __pFadeInOutItemtAnimation->SetVisualElementAnimationStatusEventListener(null);
 308                 }
 309                 pVisualElement->RemoveAllAnimations();
 310         }
 311
 312         for (int j = 0; j < 3; j++)
 313         {
 314                 delete __pItemBgBitmap[j];
 315                 __pItemBgBitmap[j] = null;
 316         }
 317
 318         if (__pHighlightVisualElement != null)
 319         {
 320                 __pHighlightVisualElement->RemoveAllAnimations();
 321                 __pHighlightVisualElement->SetAnimationProvider(null);
 322                 __pHighlightVisualElement->Destroy();
 323                 __pHighlightVisualElement = null;
 324         }
 325
 326         if (__pBitmapVisualElement != null)
 327         {
 328                 __pBitmapVisualElement->RemoveAllAnimations();
 329                 __pBitmapVisualElement->SetAnimationProvider(null);
 330                 __pBitmapVisualElement->Destroy();
 331                 __pBitmapVisualElement = null;
 332         }
 333
 334         DetachAllChildren();
 335
 336         if (GetParent() != null && __isContextItem == true)
 337         {
 338                 GetParent()->DetachChild(*this);
 339         }
 340
 341         delete __pItemDivider;
 342         __pItemDivider = null;
 343
 344         delete __pItemTopDivider;
 345         __pItemTopDivider = null;
 346
 347         delete __pItemAnnexLeftDivider;
 348         __pItemAnnexLeftDivider = null;
 349
 350         delete __pItemAnnexRightDivider;
 351         __pItemAnnexRightDivider = null;
 352
 353         delete __pItemAnnex;
 354         __pItemAnnex = null;
 355
 356         delete __pDimLayer;
 357         __pDimLayer = null;
 358
 359         delete __pItemCover;
 360         __pItemCover = null;
 361
 362         delete __pHeaderFooterItemText;
 363         __pHeaderFooterItemText = null;
 364
 365         delete __pMoveItemAnimation;
 366         __pMoveItemAnimation = null;
 367
 368         delete __pZoomInOutItemAnimation;
 369         __pZoomInOutItemAnimation = null;
 370
 371         delete __pFadeInOutItemtAnimation;
 372         __pFadeInOutItemtAnimation = null;
 373
 374         if (__isCheckedTimerEnabled)
 375         {
 376                 __pCheckedTimer->Cancel();
 377         }
 378
 379         delete __pCheckedTimer;
 380         __pCheckedTimer = null;
 381
 382         if (__pAccessibilityElement)
 383         {
 384                 _AccessibilityContainer* pContainer = GetAccessibilityContainer();
 385                 if (pContainer)
 386                 {
 387                         pContainer->RemoveAllElement();
 388                 }
 389                 __pAccessibilityElement = null;
 390
 391                 if (__pAccessibilityOnOffElement)
 392                 {
 393                         __pAccessibilityOnOffElement = null;
 394                 }
 395         }
 396 }
 397
 398 _TableViewItem*
 399 _TableViewItem::CreateTableViewItemN(float itemHeight)
 400 {
 401         result r = E_SUCCESS;
 402
 403         _TableViewItem* pItem = null;
 404         pItem = new (std::nothrow) _TableViewItem(itemHeight);
 405         SysTryReturn(NID_UI_CTRL, pItem, null, E_OUT_OF_MEMORY, "[%s] Memory allocation failed.", GetErrorMessage(E_OUT_OF_MEMORY));
 406
 407         pItem->AcquireHandle();
 408
 409         r = pItem->Initialize();
 410         SysTryCatch(NID_UI_CTRL, r == E_SUCCESS, , r = E_SYSTEM, "[%s] A system error has been occurred.", GetErrorMessage(E_SYSTEM));
 411
 412
 413         return pItem;
 414
 415 CATCH:
 416         delete pItem;
 417
 418         return null;
 419 }
 420
 421 result
 422 _TableViewItem::Initialize(void)
 423 {
 424         GetVisualElement()->SetSurfaceOpaque(false);
 425
 426         result r = E_SUCCESS;
 427
 428         __pHighlightVisualElement = new (std::nothrow) _VisualElement();
 429         SysTryCatch(NID_UI_CTRL, __pHighlightVisualElement != null, r = E_OUT_OF_MEMORY, E_OUT_OF_MEMORY, "[%s] Memory allocation failed.", GetErrorMessage(E_OUT_OF_MEMORY));
 430
 431         r = __pHighlightVisualElement->Construct();
 432         SysTryCatch(NID_UI_CTRL, r == E_SUCCESS, , r, "[%s] Failed to construct Visual Element.", GetErrorMessage(r));
 433
 434         r = __pHighlightVisualElement->SetSurfaceOpaque(false);
 435         SysTryCatch(NID_UI_CTRL, r == E_SUCCESS, , r, "[%s] Failed to set surface opaque.", GetErrorMessage(r));
 436
 437         __pHighlightVisualElement->SetImplicitAnimationEnabled(false);
 438
 439         r = GetVisualElement()->AttachChild(*__pHighlightVisualElement);
 440         SysTryCatch(NID_UI_CTRL, r == E_SUCCESS, , r, "[%s] Failed to attach child to the control VisualElement.", GetErrorMessage(r));
 441
 442         r = SetItemHighlightBounds(*__pHighlightVisualElement, CalculateItemHighlightBounds());
 443         SysTryCatch(NID_UI_CTRL, r == E_SUCCESS, , r, "[%s] Failed to set bounds.", GetErrorMessage(r));
 444
 445         __pHighlightVisualElement->SetBackgroundColor(_Colorf(0.0f, 0.0f, 0.0f, 0.0f));
 446         __pHighlightVisualElement->SetShowState(true);
 447
 448         r = __individualSelectionControls.Construct(DEFAULT_CAPTURED_CONTROL_COUNT);
 449         SysTryCatch(NID_UI_CTRL, r == E_SUCCESS, , r, "[%s] Failed to construct ArrayList", GetErrorMessage(r));
 450
 451         SetTouchPressThreshold(SENSITIVE);
 452
 453         if (!_FloatCompare(__itemHeight, 0.0f))
 454         {
 455                 SetAccessibilityElement();
 456         }
 457
 458         GetAccessibilityContainer()->Activate(false);
 459
 460         return r;
 461
 462 CATCH:
 463         if (__pHighlightVisualElement != null)
 464         {
 465                 __pHighlightVisualElement->RemoveAllAnimations();
 466                 __pHighlightVisualElement->SetAnimationProvider(null);
 467                 __pHighlightVisualElement->Destroy();
 468                 __pHighlightVisualElement = null;
 469         }
 470
 471         return r;
 472 }
 473
 474 _TableViewItem*
 475 _TableViewItem::GetContextItem(void) const
 476 {
 477         return __pContextItem;
 478 }
 479
 480 void
 481 _TableViewItem::SetContextItem(_TableViewItem* pContextItem)
 482 {
 483         if (pContextItem != null)
 484         {
 485                 pContextItem->__isContextItem = true;
 486         }
 487
 488         __pContextItem = pContextItem;
 489 }
 490
 491 bool
 492 _TableViewItem::IsContextItem(void) const
 493 {
 494         return __isContextItem;
 495 }
 496
 497 void
 498 _TableViewItem::SetContextItemActivation(bool activated)
 499 {
 500         __isContextItemActivated = activated;
 501 }
 502
 503 bool
 504 _TableViewItem::IsContextItemActivated(void) const
 505 {
 506         return __isContextItemActivated;
 507 }
 508
 509 result
 510 _TableViewItem::CreateItemDimLayer(void)
 511 {
 512         result r = E_SUCCESS;
 513
 514         if (__pDimLayer == null)
 515         {
 516                 __pDimLayer = _Label::CreateLabelN();
 517
 518                 r = GetLastResult();
 519                 SysTryReturn(NID_UI_CTRL, __pDimLayer != null, r, r, "[%s] Propagating.", GetErrorMessage(r));
 520
 521                 __pDimLayer->SetBackgroundColor(Color(0, 0, 0, BACKGROUND_DIMMED_OPACITY * 0xff));
 522                 __pDimLayer->SetVisibleState(false);
 523
 524                 AttachSystemChild(*__pDimLayer);
 525         }
 526
 527         return r;
 528 }
 529
 530 result
 531 _TableViewItem::CreateItemDivider(void)
 532 {
 533         result r = E_SUCCESS;
 534
 535         if (__pItemDivider == null)
 536         {
 537                 __pItemDivider = _TableViewItemControl::CreateTableViewItemControlN();
 538                 r = GetLastResult();
 539                 SysTryReturn(NID_UI_CTRL, __pItemDivider != null, r, r, "[%s] Propagating.", GetErrorMessage(r));
 540                 __pItemDivider->SetFocusable(false);
 541                 AttachSystemChild(*__pItemDivider);
 542
 543                 _AccessibilityContainer* pContainer = __pItemDivider->GetAccessibilityContainer();
 544                 pContainer->Activate(false);
 545         }
 546
 547         if (__pItemTopDivider == null)
 548         {
 549                 __pItemTopDivider = _TableViewItemControl::CreateTableViewItemControlN();
 550                 SysTryReturn(NID_UI_CTRL, __pItemTopDivider != null, r, r, "[%s] Propagating.", GetErrorMessage(r));
 551                 __pItemTopDivider->SetFocusable(false);
 552                 AttachSystemChild(*__pItemTopDivider);
 553
 554                 _AccessibilityContainer* pContainer = __pItemTopDivider->GetAccessibilityContainer();
 555                 pContainer->Activate(false);
 556         }
 557
 558         return r;
 559 }
 560
 561 result
 562 _TableViewItem::CreateItemAnnexDivider(void)
 563 {
 564         result r = E_SUCCESS;
 565
 566         if (__pItemAnnexLeftDivider == null)
 567         {
 568                 __pItemAnnexLeftDivider = _TableViewItemControl::CreateTableViewItemControlN();
 569                 r = GetLastResult();
 570                 SysTryReturn(NID_UI_CTRL, __pItemAnnexLeftDivider != null, r, r, "[%s] Propagating.", GetErrorMessage(r));
 571                 __pItemAnnexLeftDivider->SetFocusable(false);
 572                 AttachSystemChild(*__pItemAnnexLeftDivider);
 573         }
 574
 575         if (__pItemAnnexRightDivider == null)
 576         {
 577                 __pItemAnnexRightDivider = _TableViewItemControl::CreateTableViewItemControlN();
 578                 SysTryReturn(NID_UI_CTRL, __pItemAnnexRightDivider != null, r, r, "[%s] Propagating.", GetErrorMessage(r));
 579                 __pItemAnnexRightDivider->SetFocusable(false);
 580                 AttachSystemChild(*__pItemAnnexRightDivider);
 581         }
 582
 583         return r;
 584 }
 585
 586 result
 587 _TableViewItem::CreateItemCover(void)
 588 {
 589         result r = E_SUCCESS;
 590
 591         if (__pItemCover == null)
 592         {
 593                 __pItemCover = _TableViewItemControl::CreateTableViewItemControlN();
 594                 r = GetLastResult();
 595                 SysTryReturn(NID_UI_CTRL, __pItemCover != null, r, r, "[%s] Propagating.", GetErrorMessage(r));
 596                 __pItemCover->SetFocusable(false);
 597                 AttachSystemChild(*__pItemCover);
 598         }
 599
 600         return r;
 601 }
 602
 603 result
 604 _TableViewItem::CreateCheckBox(void)
 605 {
 606         result r = E_SUCCESS;
 607
 608         if (__pItemAnnex == null)
 609         {
 610                 float annexWidth = 0.0f;
 611                 float annexHeight = 0.0f;
 612                 GET_SHAPE_CONFIG(TABLEVIEW::ITEM_ANNEX_WIDTH, _CONTROL_ORIENTATION_PORTRAIT, annexWidth);
 613                 GET_SHAPE_CONFIG(TABLEVIEW::ITEM_ANNEX_HEIGHT, _CONTROL_ORIENTATION_PORTRAIT, annexHeight);
 614
 615                 __pItemAnnex = new (std::nothrow) Label();
 616                 r = GetLastResult();
 617                 SysTryReturn(NID_UI_CTRL, __pItemAnnex != null, r, r, "[%s] Propagating.", GetErrorMessage(r));
 618
 619                 float leftMargin = 0.0f;
 620                 GET_SHAPE_CONFIG(TABLEVIEW::ITEM_LEFT_MARGIN, _CONTROL_ORIENTATION_PORTRAIT, leftMargin);
 621
 622                 float itemHeight = ((__customHeight > 0) ? __customHeight : GetBoundsF().height);
 623                 __pItemAnnex->Construct(FloatRectangle(leftMargin, ((itemHeight - annexHeight) / 2), annexWidth, annexHeight), L"");
 624                 __pItemAnnex->SetBackgroundColor(Color(0, 0, 0, 0));
 625                 GetLabelCore(__pItemAnnex)->SetFocusable(true);
 626
 627                 AttachSystemChild(*GetLabelCore(__pItemAnnex));
 628         }
 629
 630         return r;
 631 }
 632
 633
 634 result
 635 _TableViewItem::CreateRadioBox(void)
 636 {
 637         result r = E_SUCCESS;
 638
 639         if (__pItemAnnex == null)
 640         {
 641                 float annexWidth = 0.0f;
 642                 float annexHeight = 0.0f;
 643                 GET_SHAPE_CONFIG(TABLEVIEW::ITEM_ANNEX_WIDTH, _CONTROL_ORIENTATION_PORTRAIT, annexWidth);
 644                 GET_SHAPE_CONFIG(TABLEVIEW::ITEM_ANNEX_HEIGHT, _CONTROL_ORIENTATION_PORTRAIT, annexHeight);
 645
 646                 __pItemAnnex = new (std::nothrow) Label();
 647                 r = GetLastResult();
 648                 SysTryReturn(NID_UI_CTRL, __pItemAnnex != null, r, r, "[%s] Propagating.", GetErrorMessage(r));
 649
 650                 float leftMargin = 0.0f;
 651                 GET_SHAPE_CONFIG(TABLEVIEW::ITEM_LEFT_MARGIN, _CONTROL_ORIENTATION_PORTRAIT, leftMargin);
 652
 653                 float itemHeight = ((__customHeight > 0) ? __customHeight : GetBoundsF().height);
 654                 __pItemAnnex->Construct(FloatRectangle(leftMargin, ((itemHeight - annexHeight) / 2), annexWidth, annexHeight), L"");
 655                 __pItemAnnex->SetBackgroundColor(Color(0, 0, 0, 0));
 656                 GetLabelCore(__pItemAnnex)->SetFocusable(true);
 657
 658                 AttachSystemChild(*GetLabelCore(__pItemAnnex));
 659         }
 660
 661         return r;
 662 }
 663
 664 result
 665 _TableViewItem::CreateOnOffButton(void)
 666 {
 667         result r = E_SUCCESS;
 668
 669         if (__pItemAnnex == null)
 670         {
 671                 float annexWidth = 0.0f;
 672                 float annexHeight = 0.0f;
 673
 674                 GET_SHAPE_CONFIG(TABLEVIEW::ITEM_ANNEX_ONOFF_WIDTH, _CONTROL_ORIENTATION_PORTRAIT, annexWidth);
 675                 GET_SHAPE_CONFIG(TABLEVIEW::ITEM_ANNEX_ONOFF_HEIGHT, _CONTROL_ORIENTATION_PORTRAIT, annexHeight);
 676
 677                 __pItemAnnex = new (std::nothrow) Label();
 678                 r = GetLastResult();
 679                 SysTryReturn(NID_UI_CTRL, __pItemAnnex != null, r, r, "[%s] Propagating.", GetErrorMessage(r));
 680
 681                 float leftMargin = 0.0f;
 682                 GET_SHAPE_CONFIG(TABLEVIEW::ITEM_LEFT_MARGIN, _CONTROL_ORIENTATION_PORTRAIT, leftMargin);
 683
 684                 leftMargin += __pDrawingProperty->scrollMargin;
 685
 686                 float itemHeight = ((__customHeight > 0) ? __customHeight : GetBoundsF().height);
 687                 __pItemAnnex->Construct(FloatRectangle((GetBoundsF().width - annexWidth - leftMargin), ((itemHeight - annexHeight) / 2), annexWidth, annexHeight), L"");
 688                 __pItemAnnex->SetBackgroundColor(Color(0, 0, 0, 0));
 689                 GetLabelCore(__pItemAnnex)->SetFocusable(true);
 690
 691                 AttachSystemChild(*GetLabelCore(__pItemAnnex));
 692         }
 693
 694         return r;
 695 }
 696
 697 result
 698 _TableViewItem::CreateDetailButton(void)
 699 {
 700         result r = E_SUCCESS;
 701
 702         if (__pItemAnnex == null)
 703         {
 704                 float annexWidth = 0.0f;
 705                 float annexHeight = 0.0f;
 706
 707                 GET_SHAPE_CONFIG(TABLEVIEW::ITEM_ANNEX_MORE_WIDTH, _CONTROL_ORIENTATION_PORTRAIT, annexWidth);
 708                 GET_SHAPE_CONFIG(TABLEVIEW::ITEM_ANNEX_MORE_HEIGHT, _CONTROL_ORIENTATION_PORTRAIT, annexHeight);
 709                 __pItemAnnex = new (std::nothrow) Label();
 710                 r = GetLastResult();
 711                 SysTryReturn(NID_UI_CTRL, __pItemAnnex != null, r, r, "[%s] Propagating.", GetErrorMessage(r));
 712
 713                 float leftMargin = 0.0f;
 714                 GET_SHAPE_CONFIG(TABLEVIEW::ITEM_LEFT_MARGIN, _CONTROL_ORIENTATION_PORTRAIT, leftMargin);
 715
 716                 leftMargin += __pDrawingProperty->scrollMargin;
 717                 float itemHeight = ((__customHeight > 0) ? __customHeight : GetBoundsF().height);
 718                 __pItemAnnex->Construct(FloatRectangle((GetBoundsF().width - annexWidth - leftMargin), ((itemHeight - annexHeight) / 2), annexWidth, annexHeight), L"");
 719                 __pItemAnnex->SetBackgroundColor(Color(0, 0, 0, 0));
 720                 GetLabelCore(__pItemAnnex)->SetFocusable(true);
 721
 722                 AttachSystemChild(*GetLabelCore(__pItemAnnex));
 723         }
 724
 725         return r;
 726 }
 727
 728 _Label*
 729 _TableViewItem::GetLabelCore(Label* label)
 730 {
 731         if (label == null)
 732         {
 733                 return null;
 734         }
 735
 736         _LabelImpl* pImpl = _LabelImpl::GetInstance(*label);
 737         return &pImpl->GetCore();
 738 }
 739
 740 void
 741 _TableViewItem::ExposeContextItem(FloatRectangle itemBounds, float targetWidth)
 742 {
 743         DrawItemDivider();
 744         if (__pDimLayer == null)
 745         {
 746                 if (CreateItemDimLayer() != E_SUCCESS)
 747                 {
 748                         return;
 749                 }
 750         }
 751
 752         SetBounds(itemBounds);
 753
 754         bool visible = true;
 755
 756         if ((itemBounds.width <= 0) || (itemBounds.width >= targetWidth)) // +++ check floating
 757         {
 758                 visible = false;
 759         }
 760
 761         if (visible)
 762         {
 763                 float rightMargin = 0.0f;
 764                 float dimLayerOpacity = 0.0f;
 765
 766                 GET_SHAPE_CONFIG(TABLEVIEW::CONTEXTITEM_RIGHT_MARGIN, _CONTROL_ORIENTATION_PORTRAIT, rightMargin);
 767
 768                 dimLayerOpacity = BACKGROUND_DIMMED_OPACITY - ((itemBounds.width * BACKGROUND_DIMMED_OPACITY) / (targetWidth - rightMargin));
 769                 dimLayerOpacity = ((dimLayerOpacity < 0) ? 0 :  dimLayerOpacity); // +++ check floating
 770
 771                 __pDimLayer->SetBounds(FloatRectangle(0.0f, 0.0f, itemBounds.width, itemBounds.height));
 772                 __pDimLayer->SetBackgroundColor(Color(0.0f, 0.0f, 0.0f, dimLayerOpacity * 0xff));
 773         }
 774
 775         __pDimLayer->SetVisibleState(visible);
 776
 777 }
 778
 779 void
 780 _TableViewItem::DrawItemDimLayer(bool visible)
 781 {
 782         if (__pDimLayer == null)
 783         {
 784                 if (CreateItemDimLayer() != E_SUCCESS)
 785                 {
 786                         return;
 787                 }
 788         }
 789
 790         if (visible)
 791         {
 792                 FloatDimension itemSize = GetSizeF();
 793                 __pDimLayer->SetBounds(FloatRectangle(0.0f, 0.0f, itemSize.width, itemSize.height));
 794                 __pDimLayer->SetBackgroundColor(Color(0, 0, 0, BACKGROUND_DISABLED_OPACITY * 0xff));
 795         }
 796
 797         __pDimLayer->SetVisibleState(visible);
 798 }
 799
 800 void
 801 _TableViewItem::SetItemWidth(float width)
 802 {
 803         __itemWidth = width;
 804 }
 805
 806 bool
 807 _TableViewItem::SetItemBackgroundBitmap(ListItemState itemState, const Bitmap* pBitmap)
 808 {
 809         Bitmap* pCopyBitmap = null;
 810
 811         pCopyBitmap = _BitmapImpl::CloneN(*pBitmap);
 812         SysTryReturn(NID_UI_CTRL, pCopyBitmap != null, false, E_OUT_OF_MEMORY, "[%s] Memory allocation failed.", GetErrorMessage(E_OUT_OF_MEMORY));
 813
 814         delete __pItemBgBitmap[itemState];
 815         __pItemBgBitmap[itemState] = pCopyBitmap;
 816
 817
 818         if (__pItemBgBitmap[TABLE_VIEW_ITEM_DRAWING_STATUS_NORMAL] == null &&
 819                 __pItemBgBitmap[TABLE_VIEW_ITEM_DRAWING_STATUS_PRESSED] == null &&
 820                 __pItemBgBitmap[TABLE_VIEW_ITEM_DRAWING_STATUS_HIGHLIGHTED] == null)
 821         {
 822                 if (__pBitmapVisualElement != null)
 823                 {
 824                         __pBitmapVisualElement->Destroy();
 825                         __pBitmapVisualElement = null;
 826                 }
 827         }
 828         else
 829         {
 830                 if (__pBitmapVisualElement == null)
 831                 {
 832                         FloatRectangle bounds = GetBoundsF();
 833                         result r = E_SUCCESS;
 834
 835                         __pBitmapVisualElement = new (std::nothrow) _VisualElement();
 836                         SysTryCatch(NID_UI_CTRL, __pBitmapVisualElement != null, , E_OUT_OF_MEMORY, "[%s] Memory allocation failed.", GetErrorMessage(E_OUT_OF_MEMORY));
 837
 838                         r = __pBitmapVisualElement->Construct();
 839                         SysTryCatch(NID_UI_CTRL, r == E_SUCCESS, , r, "[%s] Propagating.", GetErrorMessage(r));
 840
 841                         __pBitmapVisualElement->SetSurfaceOpaque(false);
 842                         SysTryCatch(NID_UI_CTRL, r == E_SUCCESS, , r, "[%s] Failed to set surface opaque.", GetErrorMessage(r));
 843
 844                         __pBitmapVisualElement->SetImplicitAnimationEnabled(false);
 845                         __pBitmapVisualElement->SetBounds(FloatRectangle(0.0f, 0.0f, bounds.width, bounds.height));
 846                         __pBitmapVisualElement->SetShowState(true);
 847
 848                         GetVisualElement()->AttachChild(*__pBitmapVisualElement);
 849                 }
 850         }
 851
 852         SetItemChanged(true);
 853         return true;
 854 CATCH:
 855         if (__pBitmapVisualElement != null)
 856         {
 857                 __pBitmapVisualElement->RemoveAllAnimations();
 858                 __pBitmapVisualElement->SetAnimationProvider(null);
 859                 __pBitmapVisualElement->Destroy();
 860                 __pBitmapVisualElement = null;
 861         }
 862         return false;
 863 }
 864
 865 Tizen::Graphics::Bitmap*
 866 _TableViewItem::GetItemBackgroundBitmap(ListItemState itemState) const
 867 {
 868         return __pItemBgBitmap[itemState];
 869 }
 870
 871 void
 872 _TableViewItem::SetItemBackgroundColor(ListItemState itemState, const Color bgColor)
 873 {
 874         if (__colorItemBg[itemState] == bgColor)
 875         {
 876                 return;
 877         }
 878
 879         __colorItemBg[itemState] = bgColor;
 880
 881         SetItemChanged(true);
 882 }
 883
 884 Color
 885 _TableViewItem::GetItemBackgroundColor(ListItemState itemState) const
 886 {
 887         return __colorItemBg[itemState];
 888 }
 889
 890 void
 891 _TableViewItem::SetItemStyle(TableViewAnnexStyle style)
 892 {
 893         if (__annexStyle == style)
 894         {
 895                 return;
 896         }
 897
 898         __annexStyle = style;
 899 }
 900
 901 result
 902 _TableViewItem::SetSelectionStyle(TableViewItemSelectionStyle style)
 903 {
 904         __selectionStyle = style;
 905
 906         return E_SUCCESS;
 907 }
 908
 909 TableViewItemSelectionStyle
 910 _TableViewItem::GetSelectionStyle(void) const
 911 {
 912         return __selectionStyle;
 913 }
 914
 915 float
 916 _TableViewItem::GetItemHeight(void) const
 917 {
 918         return GetSizeF().height;
 919 }
 920
 921 void
 922 _TableViewItem::SetItemHeight(int itemHeight)
 923 {
 924         SetItemHeight(_CoordinateSystemUtils::ConvertToFloat(itemHeight));
 925 }
 926
 927 void
 928 _TableViewItem::SetItemHeight(float itemHeight)
 929 {
 930         if (_FloatCompare(GetSizeF().height, itemHeight))
 931         {
 932                 return;
 933         }
 934
 935         SetSize(FloatDimension(GetSizeF().width, itemHeight));
 936 }
 937
 938 void
 939 _TableViewItem::SetChecked(bool checked)
 940 {
 941         if (__checkedState == checked)
 942         {
 943                 return;
 944         }
 945
 946         __checkedState = checked;
 947
 948         SetItemChanged(true);
 949 }
 950
 951 bool
 952 _TableViewItem::IsChecked(void) const
 953 {
 954         return __checkedState;
 955 }
 956
 957 void
 958 _TableViewItem::SetCheckedAnimationEnabled(bool enabled)
 959 {
 960         if (__isCheckedAnimationEnabled == enabled)
 961         {
 962                 return;
 963         }
 964
 965         __isCheckedAnimationEnabled = enabled;
 966
 967         if (__isCheckedAnimationEnabled == false)
 968         {
 969                 StopCheckBoxAnimation();
 970         }
 971 }
 972
 973 void
 974 _TableViewItem::SetItemEnabled(bool enabled)
 975 {
 976         if (__enabledState == enabled)
 977         {
 978                 return;
 979         }
 980
 981         __enabledState = enabled;
 982
 983         SetEnableState(enabled);
 984
 985         SetItemChanged(true);
 986
 987         Invalidate();
 988
 989         return;
 990 }
 991
 992 bool
 993 _TableViewItem::IsItemEnabled(void) const
 994 {
 995         return __enabledState;
 996 }
 997
 998 void
 999 _TableViewItem::SetItemType(const TableViewItemType itemType)
1000 {
1001         if (__itemType == itemType)
1002         {
1003                 return;
1004         }
1005
1006         __itemType = itemType;
1007
1008         if (__pContextItem != null)
1009         {
1010                 __pContextItem->SetItemType(__itemType);
1011         }
1012
1013         if (itemType == TABLE_VIEW_ITEM_TYPE_TITLE)
1014         {
1015                 Color titleColor;
1016                 GET_COLOR_CONFIG(TABLEVIEW::ITEM_BG_PRESSED, titleColor);
1017                 if (titleColor == __colorItemBg[TABLE_VIEW_ITEM_DRAWING_STATUS_PRESSED])
1018                 {
1019                         GET_COLOR_CONFIG(TABLEVIEW::GROUPITEM_BG_PRESSED, __colorItemBg[TABLE_VIEW_ITEM_DRAWING_STATUS_PRESSED]);
1020                 }
1021                 GetAccessibilityContainer()->Activate(true);
1022         }
1023 }
1024
1025 void
1026 _TableViewItem::SetItemIndex(int groupIndex, int itemIndex)
1027 {
1028         __itemGroupIndex = groupIndex;
1029         __itemIndex = itemIndex;
1030 }
1031
1032 void
1033 _TableViewItem::GetItemIndex(int& groupIndex, int& itemIndex) const
1034 {
1035         groupIndex = __itemGroupIndex;
1036         itemIndex = __itemIndex;
1037 }
1038
1039
1040 TableViewItemType
1041 _TableViewItem::GetItemType(void) const
1042 {
1043         return __itemType;
1044 }
1045
1046 bool
1047 _TableViewItem::IsReorderMode(void) const
1048 {
1049         return __reorderMode;
1050 }
1051
1052 void
1053 _TableViewItem::SetReorderMode(bool enabled)
1054 {
1055         __reorderMode = enabled;
1056 }
1057
1058 void
1059 _TableViewItem::SetAppInfo(const void* pAppInfo)
1060 {
1061         __pAppInfo = const_cast<void*>(pAppInfo);
1062 }
1063
1064 void*
1065 _TableViewItem::GetAppInfo(void) const
1066 {
1067         return __pAppInfo;
1068 }
1069
1070 void
1071 _TableViewItem::SetItemChanged(bool changed)
1072 {
1073         __itemChanged = changed;
1074 }
1075
1076 bool
1077 _TableViewItem::IsItemChanged(void) const
1078 {
1079         return __itemChanged;
1080 }
1081
1082 bool
1083 _TableViewItem::IsAnnexOnOffSliding(void)
1084 {
1085         return __annexOnOffHandlerMoved;
1086 }
1087
1088 TableViewAnnexStyle
1089 _TableViewItem::GetItemStyle(void) const
1090 {
1091         return __annexStyle;
1092 }
1093
1094 bool
1095 _TableViewItem::DrawItem(FloatRectangle& rcItem, ListItemState itemState, bool itemDivider)
1096 {
1097         return true;
1098 }
1099
1100 bool
1101 _TableViewItem::SetItemTapSoundEnabled(bool tapSoundEnabled)
1102 {
1103         bool oldValue = __isItemTapSoundEnabled;
1104         __isItemTapSoundEnabled = tapSoundEnabled;
1105         return oldValue;
1106 }
1107
1108 bool
1109 _TableViewItem::GetItemTapSoundEnabled(void)
1110 {
1111         return __isItemTapSoundEnabled;
1112 }
1113
1114 void
1115 _TableViewItem::DrawAnnexFocus(void)
1116 {
1117         if (__pItemAnnex)
1118         {
1119                 __pItemAnnex->SetFocus();
1120         }
1121         return;
1122 }
1123
1124 Tizen::Graphics::Canvas*
1125 _TableViewItem::OnCanvasRequestedN(const Tizen::Graphics::FloatRectangle& bounds)
1126 {
1127         Canvas* pCanvas = null;
1128
1129         if (__pBitmapVisualElement != null && __pBitmapVisualElement->GetImageSource().IsEmpty())
1130         {
1131                 Bitmap* pDrawBitmap = __pItemBgBitmap[__drawingStatus];
1132                 if (pDrawBitmap != null)
1133                 {
1134                         pCanvas = __pBitmapVisualElement->GetCanvasN();
1135                         SysTryCatch(NID_UI_CTRL, pCanvas != null, , E_OUT_OF_MEMORY, "[%s] Memory allocation failed.", GetErrorMessage(E_OUT_OF_MEMORY));
1136                         pCanvas->SetBackgroundColor(Color(0, 0, 0, 0));
1137                         pCanvas->Clear();
1138
1139                         pDrawBitmap->IsNinePatchedBitmap();
1140                         DrawBitmap(*pCanvas, FloatRectangle(0.0f, 0.0f, bounds.width, bounds.height), *pDrawBitmap);
1141                 }
1142         }
1143
1144 CATCH:
1145
1146         return pCanvas;
1147 }
1148
1149 void
1150 _TableViewItem::FireItemEvent(bool selectedItem)
1151 {
1152         if (!HasParent()
1153                 || IsContextItem()
1154                 || __itemType == TABLE_VIEW_ITEM_TYPE_HEADER
1155                 || __itemType == TABLE_VIEW_ITEM_TYPE_FOOTER)
1156         {
1157                 return;
1158         }
1159
1160         _TableView* pParent = dynamic_cast<_TableView*>(GetParent());
1161         if (pParent == null)
1162         {
1163                 return;
1164         }
1165
1166         TableViewNotifyType eventType = TABLEVIEW_NOTIFY_TYPE_SELECTED_ITEM;
1167
1168         if ((__annexStyle == TABLE_VIEW_ANNEX_STYLE_MARK)
1169                 || (__annexStyle == TABLE_VIEW_ANNEX_STYLE_RADIO)
1170                 || (__annexStyle == TABLE_VIEW_ANNEX_STYLE_ONOFF_SLIDING))
1171         {
1172                 if (IsChecked())
1173                 {
1174                         eventType = TABLEVIEW_NOTIFY_TYPE_ANNEX_CHECK;
1175                 }
1176                 else
1177                 {
1178                         eventType = TABLEVIEW_NOTIFY_TYPE_ANNEX_UNCHECK;
1179                 }
1180         }
1181         else if (__annexStyle == TABLE_VIEW_ANNEX_STYLE_DETAILED)
1182         {
1183                 if (!selectedItem)
1184                 {
1185                         eventType = TABLEVIEW_NOTIFY_TYPE_ANNEX_MORE;
1186                 }
1187         }
1188         else if (__annexStyle == TABLE_VIEW_ANNEX_STYLE_ONOFF_SLIDING_WITH_DIVIDER)
1189         {
1190                 if (selectedItem)
1191                 {
1192                         eventType = TABLEVIEW_NOTIFY_TYPE_SELECTED_ITEM;
1193                 }
1194                 else
1195                 {
1196                         if (IsChecked())
1197                         {
1198                                 eventType = TABLEVIEW_NOTIFY_TYPE_ANNEX_CHECK;
1199                         }
1200                         else
1201                         {
1202                                 eventType = TABLEVIEW_NOTIFY_TYPE_ANNEX_UNCHECK;
1203                         }
1204                 }
1205         }
1206
1207         if (__isItemTapSoundEnabled)
1208         {
1209                 if (!__isTabSoundPlayed)
1210                 {
1211                         PLAY_FEEDBACK(_RESOURCE_FEEDBACK_PATTERN_TAP, this);
1212                 }
1213         }
1214
1215         __isTabSoundPlayed = false;
1216         __checkItemHeightNeeded = true;
1217
1218         int groupIndex = -1;
1219         int itemIndex = -1;
1220         GetItemIndex(groupIndex, itemIndex);
1221         pParent->FireTableViewItemEvent(groupIndex, itemIndex, eventType, this);
1222 }
1223
1224 void
1225 _TableViewItem::FireItemSweepEvent(TableViewSweepDirection direction)
1226 {
1227         if (HasParent() == false)
1228         {
1229                 return;
1230         }
1231
1232         _TableView* pParent = dynamic_cast<_TableView*>(GetParent());
1233         if (pParent == null)
1234         {
1235                 return;
1236         }
1237
1238         int groupIndex = -1;
1239         int itemIndex = -1;
1240         GetItemIndex(groupIndex, itemIndex);
1241
1242         pParent->FireTableViewItemSweepEvent(groupIndex, itemIndex, direction);
1243 }
1244
1245 bool
1246 _TableViewItem::OnTouchPressed(const _Control& source, const _TouchInfo& touchinfo)
1247 {
1248         __isTouchCancelOnPressRelease = false;
1249
1250         if (IsContextItem() ||
1251                 __isContextItemActivated ||
1252                 IsAnimationPlaying() ||
1253                 IsReorderMode())
1254         {
1255                 return true;
1256         }
1257
1258         if (IsTouchPressOnScroll())
1259         {
1260                 return true;
1261         }
1262
1263         __annexOnOffHandlerMoved = false;
1264         __touchStartPosition = touchinfo.GetCurrentPosition();
1265
1266         if (&source == this)
1267         {
1268                 __pressedControl = TABLE_VIEW_ITEM_PRESSED_ITEM;
1269         }
1270         else if (&source == GetLabelCore(__pItemAnnex))
1271         {
1272                 __pressedControl = TABLE_VIEW_ITEM_PRESSED_ANNEX;
1273
1274                 if (__annexStyle == TABLE_VIEW_ANNEX_STYLE_ONOFF_SLIDING ||
1275                         __annexStyle == TABLE_VIEW_ANNEX_STYLE_ONOFF_SLIDING_WITH_DIVIDER)
1276                 {
1277                         __annexTouchStartPosition = touchinfo.GetCurrentPosition().x;
1278                 }
1279         }
1280         else if (IsIndividualSelectionEnabled(source))
1281         {
1282                 __pressedControl = TABLE_VIEW_ITEM_PRESSED_INDIVIDUAL;
1283         }
1284         else
1285         {
1286                 __pressedControl = TABLE_VIEW_ITEM_PRESSED_NONE;
1287         }
1288
1289         if (__isReleasedTimerEnabled)
1290         {
1291                 StopTouchReleasedTimer();
1292
1293                 _TableView* pParent = dynamic_cast<_TableView*>(GetParent());
1294                 if (pParent != null)
1295                 {
1296                         int groupIndex = -1;
1297                         int itemIndex = -1;
1298                         GetItemIndex(groupIndex, itemIndex);
1299                         pParent->FireItemTouchReleasedEventDuringPressing(groupIndex, itemIndex);
1300                 }
1301         }
1302         else
1303         {
1304                 if (!IsIndividualSelectionEnabled(source))
1305                 {
1306                         __itemSelected = true;
1307                         if (unlikely((_AccessibilityManager::IsActivated())))
1308                         {
1309                                 FireItemTouchPressed();
1310                         }
1311                         else
1312                         {
1313                                 StartTouchPressedTimer(source, touchinfo);
1314                         }
1315                 }
1316         }
1317
1318         return true;
1319 }
1320
1321 bool
1322 _TableViewItem::OnTouchReleased(const _Control& source, const _TouchInfo& touchinfo)
1323 {
1324         if (IsReorderMode())
1325         {
1326                 return true;
1327         }
1328
1329         if (IsTouchPressOnScroll())
1330         {
1331                 SetTouchPressOnScroll(false);
1332                 return true;
1333         }
1334
1335         if (&source == this)
1336         {
1337                 __releasedControl = TABLE_VIEW_ITEM_PRESSED_ITEM;
1338         }
1339         else if (&source == GetLabelCore(__pItemAnnex))
1340         {
1341                 __releasedControl = TABLE_VIEW_ITEM_PRESSED_ANNEX;
1342         }
1343         else if (IsIndividualSelectionEnabled(source))
1344         {
1345                 __releasedControl = TABLE_VIEW_ITEM_PRESSED_INDIVIDUAL;
1346         }
1347         else
1348         {
1349                 __releasedControl = TABLE_VIEW_ITEM_PRESSED_NONE;
1350         }
1351
1352         __isTabSoundPlayed = IS_PLAYED_FEEDBACK();
1353
1354         if (!__itemTouchMoved && __isPressedTimerEnabled)
1355         {
1356                 StopTouchPressedTimer();
1357
1358                 if (!IsContextItem())
1359                 {
1360                         FireItemTouchPressed();
1361                 }
1362
1363                 StartTouchReleasedTimer();
1364                 return true;
1365         }
1366
1367         FireItemTouchReleased();
1368         return true;
1369 }
1370
1371 void
1372 _TableViewItem::FireItemTouchPressed()
1373 {
1374         if (__isTouchCancelOnPressRelease == true)
1375         {
1376                 return;
1377         }
1378
1379         if (__pressedControl == TABLE_VIEW_ITEM_PRESSED_ITEM)
1380         {
1381                 __drawingStatus = TABLE_VIEW_ITEM_DRAWING_STATUS_PRESSED;
1382                 SetItemChanged(true);
1383                 Invalidate();
1384         }
1385         else if (__pressedControl == TABLE_VIEW_ITEM_PRESSED_ANNEX)
1386         {
1387                 if (__annexStyle == TABLE_VIEW_ANNEX_STYLE_DETAILED)
1388                 {
1389                         __drawingStatus = TABLE_VIEW_ITEM_DRAWING_STATUS_NORMAL;
1390                         __isSelectedDetailButton = true;
1391                         DrawAnnexStyle();
1392                 }
1393                 else if (__annexStyle == TABLE_VIEW_ANNEX_STYLE_ONOFF_SLIDING ||
1394                                         __annexStyle == TABLE_VIEW_ANNEX_STYLE_ONOFF_SLIDING_WITH_DIVIDER)
1395                 {
1396                         __drawingStatus = TABLE_VIEW_ITEM_DRAWING_STATUS_NORMAL;
1397                 }
1398                 else
1399                 {
1400                         __drawingStatus = TABLE_VIEW_ITEM_DRAWING_STATUS_PRESSED;
1401                         SetItemChanged(true);
1402                         Invalidate();
1403                 }
1404         }
1405         else
1406         {
1407                 if (__pressedControl != TABLE_VIEW_ITEM_PRESSED_INDIVIDUAL)
1408                 {
1409                         __drawingStatus = TABLE_VIEW_ITEM_DRAWING_STATUS_PRESSED;
1410                         SetItemChanged(true);
1411                         Invalidate();
1412                 }
1413         }
1414 }
1415
1416 void
1417 _TableViewItem::FireItemTouchReleased()
1418 {
1419         if (__isTouchCancelOnPressRelease == true)
1420         {
1421                 return;
1422         }
1423
1424         bool fireItemEvent = false;
1425         bool selectedItem = true;
1426
1427         __drawingStatus = TABLE_VIEW_ITEM_DRAWING_STATUS_NORMAL;
1428
1429         if (__itemSelected == true)
1430         {
1431                 bool checked = IsChecked();
1432                 fireItemEvent = true;
1433
1434                 if (__releasedControl == TABLE_VIEW_ITEM_PRESSED_ITEM)
1435                 {
1436                         if ((__annexStyle == TABLE_VIEW_ANNEX_STYLE_RADIO)
1437                                 || (__annexStyle == TABLE_VIEW_ANNEX_STYLE_ONOFF_SLIDING))
1438                         {
1439                                 SetChecked(!checked);
1440                         }
1441                         else if (__annexStyle == TABLE_VIEW_ANNEX_STYLE_MARK)
1442                         {
1443                                 SetChecked(!checked);
1444                                 SetCheckedAnimationEnabled(!checked);
1445                         }
1446                 }
1447                 else if (__releasedControl == TABLE_VIEW_ITEM_PRESSED_ANNEX)
1448                 {
1449                         if (__annexStyle == TABLE_VIEW_ANNEX_STYLE_DETAILED)
1450                         {
1451                                 __isSelectedDetailButton = false;
1452                                 DrawAnnexStyle();
1453                                 selectedItem = false;
1454                         }
1455                         else if (__annexStyle == TABLE_VIEW_ANNEX_STYLE_ONOFF_SLIDING ||
1456                                 __annexStyle == TABLE_VIEW_ANNEX_STYLE_ONOFF_SLIDING_WITH_DIVIDER)
1457                         {
1458                                 bool isPreviousChecked = IsChecked();
1459                                 AdjustAnnexOnOffHandlerPosition();
1460                                 selectedItem = false;
1461                                 if (isPreviousChecked == IsChecked())
1462                                 {
1463                                         fireItemEvent = false;
1464                                 }
1465                         }
1466                         else
1467                         {
1468                                 SetChecked(!checked);
1469                                 SetCheckedAnimationEnabled(!checked);
1470                         }
1471                 }
1472                 else
1473                 {
1474                         if (__releasedControl != TABLE_VIEW_ITEM_PRESSED_INDIVIDUAL)
1475                         {
1476                                 if ((__annexStyle == TABLE_VIEW_ANNEX_STYLE_MARK)
1477                                         || (__annexStyle == TABLE_VIEW_ANNEX_STYLE_RADIO)
1478                                         || (__annexStyle == TABLE_VIEW_ANNEX_STYLE_ONOFF_SLIDING))
1479                                 {
1480                                         SetChecked(!checked);
1481                                         SetCheckedAnimationEnabled(!checked);
1482                                 }
1483                         }
1484                         else
1485                         {
1486                                 fireItemEvent = false;
1487                         }
1488                 }
1489
1490                 SetItemChanged(true);
1491                 Invalidate();
1492         }
1493         else
1494         {
1495                 if (__releasedControl == TABLE_VIEW_ITEM_PRESSED_ANNEX)
1496                 {
1497                         if (__annexStyle == TABLE_VIEW_ANNEX_STYLE_ONOFF_SLIDING ||
1498                                 __annexStyle == TABLE_VIEW_ANNEX_STYLE_ONOFF_SLIDING_WITH_DIVIDER)
1499                         {
1500                                 bool isPreviousChecked = IsChecked();
1501                                 AdjustAnnexOnOffHandlerPosition();
1502                                 fireItemEvent = true;
1503                                 if (isPreviousChecked == IsChecked())
1504                                 {
1505                                         fireItemEvent = false;
1506                                 }
1507                         }
1508                 }
1509         }
1510
1511         __itemSelected = false;
1512         __annexOnOffHandlerMoved = false;
1513         __itemTouchMoved = false;
1514
1515         if (fireItemEvent)
1516         {
1517                 FireItemEvent(selectedItem);
1518         }
1519 }
1520
1521 bool
1522 _TableViewItem::OnTouchMoved(const _Control& source, const _TouchInfo& touchinfo)
1523 {
1524         if (IsReorderMode())
1525         {
1526                 return false;
1527         }
1528
1529         if (IsTouchPressOnScroll())
1530         {
1531                 SetTouchPressOnScroll(false);
1532         }
1533
1534         if (__isPressedTimerEnabled)
1535         {
1536                 StopTouchPressedTimer();
1537         }
1538
1539         bool retVal = false;
1540
1541         if (&source == this)
1542         {
1543                 __itemSelected = false;
1544                 __drawingStatus = TABLE_VIEW_ITEM_DRAWING_STATUS_NORMAL;
1545
1546                 SetItemChanged(true);
1547                 Invalidate();
1548         }
1549         else if (&source == GetLabelCore(__pItemAnnex))
1550         {
1551                 if (__annexStyle == TABLE_VIEW_ANNEX_STYLE_DETAILED)
1552                 {
1553                         __isSelectedDetailButton = false;
1554                         __itemSelected = false;
1555                         DrawAnnexStyle();
1556                 }
1557                 else if (__annexStyle == TABLE_VIEW_ANNEX_STYLE_ONOFF_SLIDING ||
1558                         __annexStyle == TABLE_VIEW_ANNEX_STYLE_ONOFF_SLIDING_WITH_DIVIDER)
1559                 {
1560                         __annexOnOffHandlerMoved = true;
1561                         DrawAnnexOnOffHandler(touchinfo.GetCurrentPosition().x);
1562                         retVal = true;
1563                 }
1564                 else
1565                 {
1566                         __itemSelected = false;
1567                         __drawingStatus = TABLE_VIEW_ITEM_DRAWING_STATUS_NORMAL;
1568
1569                         SetItemChanged(true);
1570                         Invalidate();
1571                 }
1572         }
1573         else
1574         {
1575                 if (!IsIndividualSelectionEnabled(source))
1576                 {
1577                         __itemSelected = false;
1578                         __drawingStatus = TABLE_VIEW_ITEM_DRAWING_STATUS_NORMAL;
1579
1580                         SetItemChanged(true);
1581                         Invalidate();
1582                 }
1583         }
1584
1585         __itemTouchMoved = true;
1586
1587         return retVal;
1588 }
1589
1590 bool
1591 _TableViewItem::OnTouchCanceled(const _Control& source, const _TouchInfo& touchinfo)
1592 {
1593         __isTouchCancelOnPressRelease = true;
1594
1595         if (__isPressedTimerEnabled)
1596         {
1597                 StopTouchPressedTimer();
1598         }
1599
1600         __annexOnOffHandlerMoved = false;
1601         __itemTouchMoved = false;
1602
1603         ResetItemState();
1604
1605         if (&source != this)
1606         {
1607                 return false;
1608         }
1609
1610         return true;
1611 }
1612
1613 _UiTouchEventDelivery
1614 _TableViewItem::OnPreviewTouchPressed(const _Control& source, const _TouchInfo& touchinfo)
1615 {
1616         if (IsTouchPressOnScroll())
1617         {
1618                 SetTouchPressOnScroll(false);
1619                 return _UI_TOUCH_EVENT_DELIVERY_NO;
1620         }
1621         return _UI_TOUCH_EVENT_DELIVERY_FORCED_YES;
1622 }
1623
1624 _UiTouchEventDelivery
1625 _TableViewItem::OnPreviewTouchReleased(const _Control& source, const _TouchInfo& touchinfo)
1626 {
1627         return _UI_TOUCH_EVENT_DELIVERY_FORCED_YES;
1628 }
1629
1630 _UiTouchEventDelivery
1631 _TableViewItem::OnPreviewTouchMoved(const _Control& source, const _TouchInfo& touchinfo)
1632 {
1633         return _UI_TOUCH_EVENT_DELIVERY_YES;
1634 }
1635
1636 _UiTouchEventDelivery
1637 _TableViewItem::OnPreviewTouchCanceled(const _Control& source, const _TouchInfo& touchinfo)
1638 {
1639         return _UI_TOUCH_EVENT_DELIVERY_FORCED_YES;
1640 }
1641
1642 void
1643 _TableViewItem::OnDraw(void)
1644 {
1645         if (IsItemChanged() == true)
1646         {
1647                 DrawItemBackground();
1648                 DrawAnnexStyle();
1649                 DrawItemDivider();
1650                 DrawSimpleItem();
1651                 DrawSectionStyleBackgroundCover();
1652
1653                 SetItemChanged(false);
1654         }
1655 }
1656
1657 void
1658 _TableViewItem::OnChildAttached(const _Control& child)
1659 {
1660         _Control* pControl = const_cast<_Control*>(&child);
1661         _AccessibilityContainer* pContainer = pControl->GetAccessibilityContainer();
1662
1663         if (__individualSelectionControls.Contains(child))
1664         {
1665                 pContainer->Activate(true);
1666         }
1667         else
1668         {
1669                 pContainer->Activate(false);
1670
1671                 if (!(pControl == static_cast<_Control*>(__pItemAnnexLeftDivider)
1672                         || pControl == static_cast<_Control*>(__pItemAnnexRightDivider)
1673                         || pControl == static_cast<_Control*>(__pItemCover)
1674                         || pControl == static_cast<_Control*>(__pItemDivider)
1675                         || pControl== static_cast<_Control*>(__pItemTopDivider)))
1676                 {
1677                         GetAccessibilityContainer()->Activate(true);
1678                 }
1679         }
1680
1681         DeactivateChildAccessibilityContainer(child);
1682
1683         pControl->SetTouchPressThreshold(SENSITIVE);
1684
1685         FloatRectangle bounds = child.GetBoundsF();
1686
1687         if (__pDrawingProperty != null && __pDrawingProperty->groupedLookEnabled)
1688         {
1689                 float groupedBarMargin = 0.0f;
1690                 GET_SHAPE_CONFIG(TABLEVIEW::GROUPITEM_BAR_WIDTH, _CONTROL_ORIENTATION_PORTRAIT, groupedBarMargin);
1691
1692                 bounds.x += groupedBarMargin;
1693         }
1694
1695         if ((__annexStyle == TABLE_VIEW_ANNEX_STYLE_MARK) || (__annexStyle == TABLE_VIEW_ANNEX_STYLE_RADIO))
1696         {
1697                 if (GetLabelCore(__pItemAnnex) == &child ||
1698                         GetLabelCore(__pSimpleItemBitmap) == &child ||
1699                         GetLabelCore(__pSimpleItemText) == &child)
1700                 {
1701                         return;
1702                 }
1703
1704                 float leftMargin = 0.0f;
1705                 float annexWidth = 0.0f;
1706
1707                 GET_SHAPE_CONFIG(TABLEVIEW::ITEM_LEFT_MARGIN, _CONTROL_ORIENTATION_PORTRAIT, leftMargin);
1708                 GET_SHAPE_CONFIG(TABLEVIEW::ITEM_ANNEX_WIDTH, _CONTROL_ORIENTATION_PORTRAIT, annexWidth);
1709
1710                 bounds.x += (leftMargin * 2) + annexWidth;
1711         }
1712
1713         pControl->SetBounds(bounds);
1714 }
1715
1716 void
1717 _TableViewItem::OnChildDetached(const _Control& child)
1718 {
1719         if (__individualSelectionControls.Contains(child))
1720         {
1721                 __individualSelectionControls.Remove(child, false);
1722         }
1723
1724         _Label* pSimpleItemTextCore = GetLabelCore(__pSimpleItemText);
1725         _Label* pSimpleItemBitmapCore = GetLabelCore(__pSimpleItemBitmap);
1726
1727         if (&child == pSimpleItemTextCore)
1728         {
1729                 __pSimpleItemText = null;
1730         }
1731
1732         if (&child == pSimpleItemBitmapCore)
1733         {
1734                 __pSimpleItemBitmap = null;
1735         }
1736 }
1737
1738 void
1739 _TableViewItem::OnTimerExpired(Tizen::Base::Runtime::Timer& timer)
1740 {
1741         result r = E_SUCCESS;
1742
1743         if (&timer == __pCheckedTimer)
1744         {
1745                 if (__checkedCount < MAX_CHECKED_COUNT)
1746                 {
1747                         r = __pCheckedTimer->Start(CHECKED_ANIMATION_DURATION);
1748                         SysTryReturnVoidResult(NID_UI_CTRL, r == E_SUCCESS, r, "[%s] Propagating.", GetErrorMessage(r));
1749                 }
1750
1751                 r = PlayCheckBoxAnimation();
1752                 SysTryReturnVoidResult(NID_UI_CTRL, r == E_SUCCESS, r, "[%s] Propagating.", GetErrorMessage(r));
1753
1754                 if (__checkedCount < MAX_CHECKED_COUNT)
1755                 {
1756                         __checkedCount++;
1757                 }
1758                 else
1759                 {
1760                         __checkedCount = 0;
1761                         __isCheckedAnimationEnabled = false;
1762                         __isCheckedTimerEnabled = false;
1763                 }
1764         }
1765         else if (&timer == __pPressedTimer)
1766         {
1767                 __isPressedTimerEnabled = false;
1768                 FireItemTouchPressed();
1769         }
1770         else if (&timer == __pReleasedTimer)
1771         {
1772                 __isReleasedTimerEnabled = false;
1773                 FireItemTouchReleased();
1774         }
1775 }
1776
1777 result
1778 _TableViewItem::StartTouchPressedTimer(const _Control& source, const _TouchInfo& touchinfo)
1779 {
1780         result r = E_SUCCESS;
1781
1782         if (__pPressedTimer == null)
1783         {
1784                 __pPressedTimer = new (std::nothrow) Timer();
1785                 SysTryCatch(NID_UI_CTRL, __pPressedTimer != null, r = E_OUT_OF_MEMORY, E_OUT_OF_MEMORY, "[%s] Memory allocation failed.", GetErrorMessage(E_OUT_OF_MEMORY));
1786
1787                 r = __pPressedTimer->Construct(*this);
1788                 SysTryCatch(NID_UI_CTRL, r == E_SUCCESS, , r, "[%s] Propagating.", GetErrorMessage);
1789         }
1790
1791         if (__isPressedTimerEnabled == false)
1792         {
1793                 r = __pPressedTimer->Start(TOUCH_PRESSED_DURATION);
1794                 SysTryReturnResult(NID_UI_CTRL, r == E_SUCCESS, r, "Propagating.");
1795
1796                 __isPressedTimerEnabled = true;
1797         }
1798
1799         return r;
1800
1801 CATCH:
1802         if (__isPressedTimerEnabled && __pPressedTimer != null)
1803         {
1804                 __pPressedTimer->Cancel();
1805         }
1806
1807         delete __pPressedTimer;
1808         __pPressedTimer = null;
1809
1810         return r;
1811 }
1812
1813 void
1814 _TableViewItem::StopTouchPressedTimer(bool forceStop)
1815 {
1816         result r = E_SUCCESS;
1817
1818         if (__pPressedTimer == null)
1819         {
1820                 return;
1821         }
1822
1823         if (__isPressedTimerEnabled || forceStop)
1824         {
1825                 r = __pPressedTimer->Cancel();
1826                 SysTryReturnVoidResult(NID_UI_CTRL, r == E_SUCCESS, r, "[%s] Propagating.", GetErrorMessage(r));
1827         }
1828
1829         __isPressedTimerEnabled = false;
1830
1831         return;
1832 }
1833
1834 result
1835 _TableViewItem::StartTouchReleasedTimer()
1836 {
1837         result r = E_SUCCESS;
1838
1839         if (__pReleasedTimer == null)
1840         {
1841                 __pReleasedTimer = new (std::nothrow) Timer();
1842                 SysTryCatch(NID_UI_CTRL, __pReleasedTimer != null, r = E_OUT_OF_MEMORY, E_OUT_OF_MEMORY, "[%s] Memory allocation failed.", GetErrorMessage(E_OUT_OF_MEMORY));
1843
1844
1845                 r = __pReleasedTimer->Construct(*this);
1846                 SysTryCatch(NID_UI_CTRL, r == E_SUCCESS, , r, "[%s] Propagating.", GetErrorMessage);
1847         }
1848
1849         if (!__isReleasedTimerEnabled)
1850         {
1851                 r = __pReleasedTimer->Start(TOUCH_RELEASED_DURATION);
1852                 SysTryReturnResult(NID_UI_CTRL, r == E_SUCCESS, r, "Propagating.");
1853         }
1854         __isReleasedTimerEnabled = true;
1855
1856         return r;
1857
1858 CATCH:
1859         if (__isReleasedTimerEnabled && __pReleasedTimer != null)
1860         {
1861                 __pReleasedTimer->Cancel();
1862         }
1863
1864         delete __pReleasedTimer;
1865         __pReleasedTimer = null;
1866
1867         return r;
1868 }
1869
1870 void
1871 _TableViewItem::StopTouchReleasedTimer(bool forceStop)
1872 {
1873         result r = E_SUCCESS;
1874
1875         if (__pReleasedTimer == null)
1876         {
1877                 return;
1878         }
1879
1880         if (__isReleasedTimerEnabled || forceStop)
1881         {
1882                 r = __pReleasedTimer->Cancel();
1883                 SysTryReturnVoidResult(NID_UI_CTRL, r == E_SUCCESS, r, "[%s] Propagating.", GetErrorMessage(r));
1884         }
1885
1886         __isReleasedTimerEnabled = false;
1887
1888         return;
1889 }
1890
1891 void
1892 _TableViewItem::OnAncestorInputEnableStateChanged(const _Control& control)
1893 {
1894         if (__isPressedTimerEnabled)
1895         {
1896                 StopTouchPressedTimer();
1897         }
1898
1899         __annexOnOffHandlerMoved = false;
1900         __itemTouchMoved = false;
1901
1902         __itemSelected = false;
1903         __drawingStatus = TABLE_VIEW_ITEM_DRAWING_STATUS_NORMAL;
1904
1905         if (__annexStyle == TABLE_VIEW_ANNEX_STYLE_DETAILED)
1906         {
1907                 __isSelectedDetailButton = false;
1908         }
1909
1910         SetItemChanged(true);
1911         Invalidate();
1912 }
1913
1914 result
1915 _TableViewItem::StartCheckBoxAnimation(void)
1916 {
1917         result r = E_SUCCESS;
1918
1919         if (__pCheckedTimer == null)
1920         {
1921                 __pCheckedTimer = new (std::nothrow) Timer();
1922                 SysTryCatch(NID_UI_CTRL, __pCheckedTimer != null, r = E_OUT_OF_MEMORY, E_OUT_OF_MEMORY, "[%s] Memory allocation failed.", GetErrorMessage(E_OUT_OF_MEMORY));
1923 ;
1924
1925                 r = __pCheckedTimer->Construct(*this);
1926                 SysTryCatch(NID_UI_CTRL, r == E_SUCCESS, , r, "[%s] Propagating.", GetErrorMessage);
1927         }
1928
1929         if (__isCheckedTimerEnabled == false)
1930         {
1931                 r = __pCheckedTimer->Start(CHECKED_ANIMATION_DURATION);
1932                 SysTryReturnResult(NID_UI_CTRL, r == E_SUCCESS, r, "Propagating.");
1933
1934                 __isCheckedTimerEnabled = true;
1935         }
1936
1937         return r;
1938
1939 CATCH:
1940         if (__isCheckedTimerEnabled)
1941         {
1942                 __pCheckedTimer->Cancel();
1943         }
1944
1945         delete __pCheckedTimer;
1946         __pCheckedTimer = null;
1947
1948         return r;
1949 }
1950
1951 void
1952 _TableViewItem::StopCheckBoxAnimation(void)
1953 {
1954         result r = E_SUCCESS;
1955
1956         SysTryReturnVoidResult(NID_UI_CTRL, __pCheckedTimer != null, E_SYSTEM, "[%s] A system error has been occurred. Timer is invalid.", GetErrorMessage(E_SYSTEM));
1957
1958
1959         if (__isCheckedTimerEnabled)
1960         {
1961                 r = __pCheckedTimer->Cancel();
1962                 SysTryReturnVoidResult(NID_UI_CTRL, r == E_SUCCESS, r, "[%s] Propagating.", GetErrorMessage(r));
1963         }
1964
1965         __checkedCount = 0;
1966         __isCheckedAnimationEnabled = false;
1967         __isCheckedTimerEnabled = false;
1968
1969         return;
1970 }
1971
1972 result
1973 _TableViewItem::PlayCheckBoxAnimation(void)
1974 {
1975         Bitmap* pCheckBox = null;
1976         Bitmap* pCheckBoxBg = null;
1977         Bitmap* pMergeBitmap = null;
1978         Canvas* pCanvas = null;
1979         result r = E_SUCCESS;
1980
1981         FloatRectangle bounds;
1982
1983         float annexWidth = 0.0f;
1984         float annexHeight = 0.0f;
1985
1986         if (__drawingStatus == TABLE_VIEW_ITEM_DRAWING_STATUS_NORMAL)
1987         {
1988                 r = GET_BITMAP_CONFIG_N(TABLEVIEW::CHECKBOX_BG_NORMAL, BITMAP_PIXEL_FORMAT_ARGB8888, pCheckBoxBg);
1989         }
1990         else if ((__drawingStatus == TABLE_VIEW_ITEM_DRAWING_STATUS_PRESSED) || (__drawingStatus == TABLE_VIEW_ITEM_DRAWING_STATUS_HIGHLIGHTED))
1991         {
1992                 r = GET_BITMAP_CONFIG_N(TABLEVIEW::CHECKBOX_BG_PRESSED, BITMAP_PIXEL_FORMAT_ARGB8888, pCheckBoxBg);
1993         }
1994         SysTryCatch(NID_UI_CTRL, (r == E_SUCCESS) && (pCheckBoxBg != null), , E_SYSTEM, "[%s] Propagating.", GetErrorMessage(r));
1995
1996         r = GET_BITMAP_CONFIG_N(TABLEVIEW::CHECKBOX_CHECK_MARK_NORMAL, BITMAP_PIXEL_FORMAT_ARGB8888, pCheckBox);
1997         SysTryCatch(NID_UI_CTRL,(r == E_SUCCESS) && (pCheckBox != null), , E_SYSTEM, "[%s] Propagating.", GetErrorMessage(r));
1998
1999         GET_SHAPE_CONFIG(TABLEVIEW::ITEM_ANNEX_WIDTH, _CONTROL_ORIENTATION_PORTRAIT, annexWidth);
2000         GET_SHAPE_CONFIG(TABLEVIEW::ITEM_ANNEX_HEIGHT, _CONTROL_ORIENTATION_PORTRAIT, annexHeight);
2001
2002         bounds.SetBounds(0, 0, annexWidth, annexHeight);
2003
2004         pCanvas = new (std::nothrow) Canvas();
2005         SysTryCatch(NID_UI_CTRL, pCanvas != null, , E_OUT_OF_MEMORY,  "[%s] Memory allocation failed.", GetErrorMessage(E_OUT_OF_MEMORY));
2006
2007         r = pCanvas->Construct(bounds);
2008         pCanvas->SetBackgroundColor(Color(0, 0, 0, 0));
2009         pCanvas->Clear();
2010
2011         DrawBitmap(*pCanvas, CalculateAnnexBitmapBounds(annexWidth, annexHeight, *pCheckBoxBg), *pCheckBoxBg);
2012
2013         __checkedBounds = CalculateAnnexBitmapBounds(annexWidth, annexHeight, *pCheckBox);
2014         if (IsChecked() == true)
2015         {
2016                 if (_BitmapImpl::CheckNinePatchedBitmapStrictly(*pCheckBox))
2017                 {
2018                         FloatRectangle drawingRect(__checkedBounds.x, __checkedBounds.y, __checkedBounds.width, __checkedBounds.height);
2019                         r = pCanvas->DrawNinePatchedBitmap(drawingRect, *pCheckBox); // +++ check floating
2020                 }
2021                 else
2022                 {
2023                         FloatRectangle bitmapSourceRect(0.0f, 0.0f, pCheckBox->GetWidthF()*__checkedCount * 0.1, pCheckBox->GetHeightF());
2024                         FloatRectangle drawingRect(__checkedBounds.x, __checkedBounds.y, __checkedBounds.width * __checkedCount * 0.1, __checkedBounds.height);
2025                         r = pCanvas->DrawBitmap(drawingRect, *pCheckBox, bitmapSourceRect); // +++ check floating
2026                 }
2027         }
2028
2029         pMergeBitmap = new (std::nothrow) Bitmap();
2030         SysTryCatch(NID_UI_CTRL, pMergeBitmap != null, , E_OUT_OF_MEMORY,  "[%s] Memory allocation failed.", GetErrorMessage(E_OUT_OF_MEMORY));
2031
2032         pMergeBitmap->Construct(*pCanvas, bounds);
2033         _BitmapImpl::ConvertToNonpremultiplied(*pMergeBitmap, true);
2034
2035         if (__pItemAnnex)
2036         {
2037                 __pItemAnnex->SetBackgroundBitmap(*pMergeBitmap);
2038                 __pItemAnnex->Invalidate(false);
2039         }
2040
2041 CATCH:
2042         delete pCheckBox;
2043         delete pCheckBoxBg;
2044         delete pMergeBitmap;
2045         delete pCanvas;
2046
2047         return r;
2048 }
2049
2050 void
2051 _TableViewItem::SetItemLayoutEnabled(bool enabled)
2052 {
2053         __isItemLayoutEnabled = enabled;
2054 }
2055
2056 bool
2057 _TableViewItem::GetItemLayoutEnabled(void)
2058 {
2059         return __isItemLayoutEnabled;
2060 }
2061
2062 void
2063 _TableViewItem::OnBoundsChanged(void)
2064 {
2065         if (__checkItemHeightNeeded && HasParent())
2066         {
2067                 _TableView* pParent = dynamic_cast<_TableView*>(GetParent());
2068                 if (pParent != null)
2069                 {
2070                         int groupIndex = -1;
2071                         int itemIndex = -1;
2072                         GetItemIndex(groupIndex, itemIndex);
2073
2074                         pParent->CheckItemHeightAndRefreshLayout(groupIndex, itemIndex);
2075                 }
2076
2077                 __checkItemHeightNeeded = false;
2078         }
2079
2080         AdjustAnnexBounds();
2081
2082         SetItemHighlightBounds(*__pHighlightVisualElement, CalculateItemHighlightBounds());
2083
2084         if (__pHeaderFooterItemText != null)
2085         {
2086                 FloatRectangle textBounds = __pHeaderFooterItemText->GetBoundsF();
2087                 textBounds.width = GetBoundsF().width;
2088
2089                 if (__itemType == TABLE_VIEW_ITEM_TYPE_FOOTER)
2090                 {
2091                         textBounds.x -= __pDrawingProperty->scrollMargin;
2092                 }
2093
2094                 __pHeaderFooterItemText->SetBounds(textBounds);
2095         }
2096
2097         if (__pBitmapVisualElement != null)
2098         {
2099                 FloatRectangle bounds = GetBoundsF();
2100                 __pBitmapVisualElement->SetBounds(FloatRectangle(0.0f, 0.0f, bounds.width, bounds.height));
2101         }
2102
2103         if (__pAccessibilityElement != null)
2104         {
2105                 __pAccessibilityElement->SetBounds(FloatRectangle(0.0f,0.0f, GetBoundsF().width, GetBoundsF().height));
2106         }
2107 }
2108
2109 void
2110 _TableViewItem::SetDrawingProperty(_ItemDrawingProperty* pDrawingProperty)
2111 {
2112
2113         SysTryReturnVoidResult(NID_UI_CTRL, pDrawingProperty != null, E_INVALID_ARG, "[%s] Invalid argument(s) is used. The pDrawingProperty is null.", GetErrorMessage(E_INVALID_ARG));
2114
2115         __pDrawingProperty = pDrawingProperty;
2116
2117         if (__pDrawingProperty->sectionStyleEnabled == true &&
2118                 !IsContextItem())
2119         {
2120                 CreateItemCover();
2121         }
2122
2123         if (__pDrawingProperty->itemDividerEnabled)
2124         {
2125                 CreateItemDivider();
2126         }
2127
2128         CreateAnnexStyle();
2129 }
2130
2131 _ItemDrawingProperty*
2132 _TableViewItem::GetDrawingProperty(void)
2133 {
2134         return __pDrawingProperty;
2135 }
2136
2137 void
2138 _TableViewItem::DrawItemBackground(void)
2139 {
2140         Canvas* pCanvas = null;
2141         Bitmap* pDrawBitmap = __pItemBgBitmap[__drawingStatus];
2142         Color bgColor = __colorItemBg[__drawingStatus];
2143         FloatRectangle bounds = GetBoundsF();
2144
2145         SetItemHighlightBounds(*__pHighlightVisualElement, CalculateItemHighlightBounds());
2146         __pHighlightVisualElement->SetBackgroundColor(_Colorf(0.0f, 0.0f, 0.0f, 0.0f));
2147
2148         if (pDrawBitmap != null && __enabledState)
2149         {
2150                 if (__pBitmapVisualElement == null)
2151                 {
2152                         return;
2153                 }
2154
2155                 String imagePath = null;
2156                 if (_BitmapImpl::CheckNinePatchedBitmapStrictly(*pDrawBitmap) == false)
2157                 {
2158                         imagePath = _BitmapImpl::GetInstance(*pDrawBitmap)->GetFileName();
2159                 }
2160
2161                 if (imagePath.IsEmpty() == false)
2162                 {
2163                         __pBitmapVisualElement->SetBackgroundColor(_Colorf((float)bgColor.GetRed() /255, (float)bgColor.GetGreen() / 255, (float)bgColor.GetBlue() / 255, (float)bgColor.GetAlpha() / 255));
2164                         __pBitmapVisualElement->SetImageSource(imagePath);
2165                 }
2166                 else
2167                 {
2168                         pCanvas = __pBitmapVisualElement->GetCanvasN();
2169                         SysTryCatch(NID_UI_CTRL, pCanvas != null, , E_OUT_OF_MEMORY, "[%s] Memory allocation failed.", GetErrorMessage(E_OUT_OF_MEMORY));
2170                         pCanvas->SetBackgroundColor(Color(0, 0, 0, 0));
2171                         pCanvas->Clear();
2172
2173                         DrawBitmap(*pCanvas, FloatRectangle(0.0f, 0.0f, bounds.width, bounds.height), *pDrawBitmap);
2174                 }
2175         }
2176
2177         if (IsContextItem())
2178         {
2179                 DrawContextItemBackground();
2180         }
2181         else if (__pDrawingProperty->sectionStyleEnabled == true)
2182         {
2183                 DrawSectionStyleBackground();
2184         }
2185         else
2186         {
2187                 if (__enabledState)
2188                 {
2189                         if (__itemType == TABLE_VIEW_ITEM_TYPE_HEADER || __itemType == TABLE_VIEW_ITEM_TYPE_FOOTER)
2190                         {
2191                                 SetBackgroundColor(Color(0, 0, 0, 0));
2192                                 __pHighlightVisualElement->SetBackgroundColor(_Colorf(0.0f, 0.0f, 0.0f, 0.0f));
2193                         }
2194                         else if (__itemType == TABLE_VIEW_ITEM_TYPE_TITLE)
2195                         {
2196                                 __pHighlightVisualElement->SetBackgroundColor(_Colorf((float)bgColor.GetRed() / 255.0f, (float)bgColor.GetGreen() / 255.0f, (float)bgColor.GetBlue() / 255.0f, (float)bgColor.GetAlpha() / 255.0f));
2197                         }
2198                         else
2199                         {
2200                                 SetBackgroundColor(__colorItemBg[TABLE_VIEW_ITEM_DRAWING_STATUS_NORMAL]);
2201
2202                                 __pHighlightVisualElement->SetBackgroundColor(_Colorf((float)bgColor.GetRed() / 255.0f, (float)bgColor.GetGreen() / 255.0f, (float)bgColor.GetBlue() / 255.0f, (float)bgColor.GetAlpha() / 255.0f));
2203
2204                                 if (__pDrawingProperty->groupedLookEnabled == true)
2205                                 {
2206                                         DrawGroupedLook();
2207                                 }
2208                         }
2209                 }
2210                 else
2211                 {
2212                         GET_COLOR_CONFIG(TABLEVIEW::ITEM_BG_DISABLED, bgColor);
2213                         SetBackgroundColor(bgColor);
2214                         __pHighlightVisualElement->SetBackgroundColor(_Colorf((float)bgColor.GetRed() / 255.0f, (float)bgColor.GetGreen() / 255.0f, (float)bgColor.GetBlue() / 255.0f, (float)bgColor.GetAlpha() / 255.0f));
2215
2216                         if (__pDrawingProperty->groupedLookEnabled == true)
2217                         {
2218                                 DrawGroupedLook();
2219                         }
2220                 }
2221         }
2222
2223         delete pCanvas;
2224         return;
2225
2226 CATCH:
2227
2228         if (__pBitmapVisualElement != null)
2229         {
2230                 __pBitmapVisualElement->RemoveAllAnimations();
2231                 __pBitmapVisualElement->SetAnimationProvider(null);
2232                 __pBitmapVisualElement->Destroy();
2233                 __pBitmapVisualElement = null;
2234         }
2235 }
2236
2237 void
2238 _TableViewItem::DrawGroupedLook(void)
2239 {
2240         if (IsTitleStyleItem() || IsContextItem())
2241         {
2242                 return;
2243         }
2244
2245         Color barColor;
2246         Color outlineColor = __pDrawingProperty->dividerColor;
2247
2248         float barWidth = 0.0f;
2249
2250         Canvas* pCanvas = GetVisualElement()->GetCanvasN();
2251         SysTryReturnVoidResult(NID_UI_CTRL, pCanvas != null, GetLastResult(), "[%s] Propagating.", GetErrorMessage(GetLastResult()));
2252
2253         FloatRectangle bounds = GetBoundsF();
2254         pCanvas->SetBackgroundColor(GetBackgroundColor());
2255         pCanvas->Clear();
2256
2257         GET_COLOR_CONFIG(TABLEVIEW::GROUPITEM_BAR_NORMAL, barColor);
2258         GET_SHAPE_CONFIG(TABLEVIEW::GROUPITEM_BAR_WIDTH, _CONTROL_ORIENTATION_PORTRAIT, barWidth);
2259
2260         pCanvas->FillRectangle(barColor, FloatRectangle(0.0f, 0.0f, barWidth, bounds.height));
2261
2262         if (__pDrawingProperty->sectionStyleEnabled == true)
2263         {
2264                 pCanvas->FillRectangle(outlineColor, FloatRectangle(bounds.width - 1.0f, 0.0f, 1.0f, bounds.height));
2265
2266                 if (__itemType == TABLE_VIEW_ITEM_TYPE_TOP || __itemType == TABLE_VIEW_ITEM_TYPE_ONE)
2267                 {
2268                         pCanvas->FillRectangle(outlineColor, FloatRectangle(0.0f, 0.0f, bounds.width, 1.0f));
2269                 }
2270         }
2271
2272         delete pCanvas;
2273 }
2274
2275 void
2276 _TableViewItem::DrawSectionStyleBackground(void)
2277 {
2278         Canvas* pCanvas = null;
2279         Bitmap* pReplacementSectionPressBg = null;
2280         Bitmap* pReplacementSectionBg = null;
2281         Bitmap* pReplacementSectionDisabledBg = null;
2282         Color bgColor = __colorItemBg[__drawingStatus];
2283         FloatRectangle bounds = GetBoundsF();
2284         float dividerHeight = 0.0f;
2285
2286         result r = E_SUCCESS;
2287
2288         pCanvas = GetVisualElement()->GetCanvasN();
2289         SysTryReturnVoidResult(NID_UI_CTRL, pCanvas != null, GetLastResult(), "[%s] Propagating.", GetErrorMessage(r));
2290
2291         pCanvas->SetBackgroundColor(Color(0, 0, 0, 0));
2292         pCanvas->Clear();
2293
2294         if (bgColor != null)
2295         {
2296                 if (__itemType == TABLE_VIEW_ITEM_TYPE_ONE)
2297                 {
2298                         r = GET_REPLACED_BITMAP_CONFIG_N(TABLEVIEW::SECTIONITEM_SINGLE_BG_NORMAL, BITMAP_PIXEL_FORMAT_ARGB8888, bgColor, pReplacementSectionBg);
2299                 }
2300                 else if (__itemType == TABLE_VIEW_ITEM_TYPE_TOP)
2301                 {
2302                         r = GET_REPLACED_BITMAP_CONFIG_N(TABLEVIEW::SECTIONITEM_TOP_BG_NORMAL, BITMAP_PIXEL_FORMAT_ARGB8888, bgColor, pReplacementSectionBg);
2303                 }
2304                 else if (__itemType == TABLE_VIEW_ITEM_TYPE_MIDDLE)
2305                 {
2306                         r = GET_REPLACED_BITMAP_CONFIG_N(TABLEVIEW::SECTIONITEM_CENTER_BG_NORMAL, BITMAP_PIXEL_FORMAT_ARGB8888, bgColor, pReplacementSectionBg);
2307                 }
2308                 else if (__itemType == TABLE_VIEW_ITEM_TYPE_BOTTOM)
2309                 {
2310                         r = GET_REPLACED_BITMAP_CONFIG_N(TABLEVIEW::SECTIONITEM_BOTTOM_BG_NORMAL, BITMAP_PIXEL_FORMAT_ARGB8888, bgColor, pReplacementSectionBg);
2311                 }
2312                 else
2313                 {
2314                         r = E_SYSTEM;
2315                 }
2316         }
2317         else
2318         {
2319                 if (__itemType == TABLE_VIEW_ITEM_TYPE_ONE)
2320                 {
2321                         r = GET_REPLACED_BITMAP_CONFIG_N(TABLEVIEW::SECTIONITEM_SINGLE_BG_NORMAL, BITMAP_PIXEL_FORMAT_ARGB8888, __pDrawingProperty->sectionStyleBgColor, pReplacementSectionBg);
2322                 }
2323                 else if (__itemType == TABLE_VIEW_ITEM_TYPE_TOP)
2324                 {
2325                         r = GET_REPLACED_BITMAP_CONFIG_N(TABLEVIEW::SECTIONITEM_TOP_BG_NORMAL, BITMAP_PIXEL_FORMAT_ARGB8888, __pDrawingProperty->sectionStyleBgColor, pReplacementSectionBg);
2326                 }
2327                 else if (__itemType == TABLE_VIEW_ITEM_TYPE_MIDDLE)
2328                 {
2329                         r = GET_REPLACED_BITMAP_CONFIG_N(TABLEVIEW::SECTIONITEM_CENTER_BG_NORMAL, BITMAP_PIXEL_FORMAT_ARGB8888, __pDrawingProperty->sectionStyleBgColor, pReplacementSectionBg);
2330                 }
2331                 else if (__itemType == TABLE_VIEW_ITEM_TYPE_BOTTOM)
2332                 {
2333                         r = GET_REPLACED_BITMAP_CONFIG_N(TABLEVIEW::SECTIONITEM_BOTTOM_BG_NORMAL, BITMAP_PIXEL_FORMAT_ARGB8888, __pDrawingProperty->sectionStyleBgColor, pReplacementSectionBg);
2334                 }
2335                 else
2336                 {
2337                         r = E_SYSTEM;
2338                 }
2339         }
2340         SysTryCatch(NID_UI_CTRL, r == E_SUCCESS, , E_SYSTEM, "[%s] A system error has been occurred.  SectionStyle image load failed", GetErrorMessage(E_SYSTEM) );
2341
2342         if (__enabledState)
2343         {
2344                 if (__drawingStatus == TABLE_VIEW_ITEM_DRAWING_STATUS_PRESSED || __drawingStatus == TABLE_VIEW_ITEM_DRAWING_STATUS_HIGHLIGHTED)
2345                 {
2346                         if (__itemType == TABLE_VIEW_ITEM_TYPE_ONE)
2347                         {
2348                                 if (IS_CUSTOM_BITMAP(TABLEVIEW::SECTIONITEM_SINGLE_BG_PRESSED))
2349                                 {
2350                                         r = GET_REPLACED_BITMAP_CONFIG_N(TABLEVIEW::SECTIONITEM_SINGLE_BG_PRESSED, BITMAP_PIXEL_FORMAT_ARGB8888, bgColor, pReplacementSectionPressBg);
2351                                         SysTryCatch(NID_UI_CTRL, r == E_SUCCESS, , E_SYSTEM, "[%s] A system error has been occurred. SectionStyle image load failed", GetErrorMessage(E_SYSTEM) );
2352                                 }
2353                         }
2354                         else if (__itemType == TABLE_VIEW_ITEM_TYPE_TOP)
2355                         {
2356                                 if (IS_CUSTOM_BITMAP(TABLEVIEW::SECTIONITEM_TOP_BG_PRESSED))
2357                                 {
2358                                         r = GET_REPLACED_BITMAP_CONFIG_N(TABLEVIEW::SECTIONITEM_TOP_BG_PRESSED, BITMAP_PIXEL_FORMAT_ARGB8888, bgColor, pReplacementSectionPressBg);
2359                                         SysTryCatch(NID_UI_CTRL, r == E_SUCCESS, , E_SYSTEM, "[%s] A system error has been occurred. SectionStyle image load failed", GetErrorMessage(E_SYSTEM) );
2360                                 }
2361                         }
2362                         else if (__itemType == TABLE_VIEW_ITEM_TYPE_MIDDLE)
2363                         {
2364                                 if (IS_CUSTOM_BITMAP(TABLEVIEW::SECTIONITEM_CENTER_BG_PRESSED))
2365                                 {
2366                                         r = GET_REPLACED_BITMAP_CONFIG_N(TABLEVIEW::SECTIONITEM_CENTER_BG_PRESSED, BITMAP_PIXEL_FORMAT_ARGB8888, bgColor, pReplacementSectionPressBg);
2367                                         SysTryCatch(NID_UI_CTRL, r == E_SUCCESS, , E_SYSTEM, "[%s] A system error has been occurred. SectionStyle image load failed", GetErrorMessage(E_SYSTEM) );
2368                                 }
2369                         }
2370                         else if (__itemType == TABLE_VIEW_ITEM_TYPE_BOTTOM)
2371                         {
2372                                 if (IS_CUSTOM_BITMAP(TABLEVIEW::SECTIONITEM_BOTTOM_BG_PRESSED))
2373                                 {
2374                                         r = GET_REPLACED_BITMAP_CONFIG_N(TABLEVIEW::SECTIONITEM_BOTTOM_BG_PRESSED, BITMAP_PIXEL_FORMAT_ARGB8888, bgColor, pReplacementSectionPressBg);
2375                                         SysTryCatch(NID_UI_CTRL, r == E_SUCCESS, , E_SYSTEM, "[%s] A system error has been occurred. SectionStyle image load failed", GetErrorMessage(E_SYSTEM) );
2376                                 }
2377                         }
2378
2379                         GET_FIXED_VALUE_CONFIG(TABLEVIEW::ITEM_DIVIDER_HEIGHT, _CONTROL_ORIENTATION_PORTRAIT, dividerHeight);
2380
2381                         if (pReplacementSectionPressBg)
2382                         {
2383                                 DrawBitmap(*pCanvas, FloatRectangle(0.0f, dividerHeight, bounds.width, bounds.height - (dividerHeight * 2)), *pReplacementSectionPressBg);
2384                         }
2385                         else
2386                         {
2387                                 DrawBitmap(*pCanvas, FloatRectangle(0.0f, dividerHeight, bounds.width, bounds.height - (dividerHeight * 2)), *pReplacementSectionBg);
2388                         }
2389                 }
2390                 else
2391                 {
2392                         DrawBitmap(*pCanvas, FloatRectangle(0.0f, 0.0f, bounds.width, bounds.height), *pReplacementSectionBg);
2393                 }
2394         }
2395         else
2396         {
2397                 GET_COLOR_CONFIG(TABLEVIEW::ITEM_BG_DISABLED, bgColor);
2398
2399                 if (__itemType == TABLE_VIEW_ITEM_TYPE_ONE)
2400                 {
2401                         if (IS_CUSTOM_BITMAP(TABLEVIEW::SECTIONITEM_SINGLE_BG_DISABLED))
2402                         {
2403                                 r = GET_REPLACED_BITMAP_CONFIG_N(TABLEVIEW::SECTIONITEM_SINGLE_BG_DISABLED, BITMAP_PIXEL_FORMAT_ARGB8888, bgColor, pReplacementSectionDisabledBg);
2404                                 SysTryCatch(NID_UI_CTRL, r == E_SUCCESS, , E_SYSTEM, "[%s] A system error has been occurred. SectionStyle image load failed", GetErrorMessage(E_SYSTEM) );
2405                         }
2406                 }
2407                 else if (__itemType == TABLE_VIEW_ITEM_TYPE_TOP)
2408                 {
2409                         if (IS_CUSTOM_BITMAP(TABLEVIEW::SECTIONITEM_TOP_BG_DISABLED))
2410                         {
2411                                 r = GET_REPLACED_BITMAP_CONFIG_N(TABLEVIEW::SECTIONITEM_TOP_BG_DISABLED, BITMAP_PIXEL_FORMAT_ARGB8888, bgColor, pReplacementSectionDisabledBg);
2412                                 SysTryCatch(NID_UI_CTRL, r == E_SUCCESS, , E_SYSTEM, "[%s] A system error has been occurred. SectionStyle image load failed", GetErrorMessage(E_SYSTEM) );
2413                         }
2414                 }
2415                 else if (__itemType == TABLE_VIEW_ITEM_TYPE_MIDDLE)
2416                 {
2417                         if (IS_CUSTOM_BITMAP(TABLEVIEW::SECTIONITEM_CENTER_BG_DISABLED))
2418                         {
2419                                 r = GET_REPLACED_BITMAP_CONFIG_N(TABLEVIEW::SECTIONITEM_CENTER_BG_DISABLED, BITMAP_PIXEL_FORMAT_ARGB8888, bgColor, pReplacementSectionDisabledBg);
2420                                 SysTryCatch(NID_UI_CTRL, r == E_SUCCESS, , E_SYSTEM, "[%s] A system error has been occurred. SectionStyle image load failed", GetErrorMessage(E_SYSTEM) );
2421                         }
2422                 }
2423                 else if (__itemType == TABLE_VIEW_ITEM_TYPE_BOTTOM)
2424                 {
2425                         if (IS_CUSTOM_BITMAP(TABLEVIEW::SECTIONITEM_BOTTOM_BG_DISABLED))
2426                         {
2427                                 r = GET_REPLACED_BITMAP_CONFIG_N(TABLEVIEW::SECTIONITEM_BOTTOM_BG_DISABLED, BITMAP_PIXEL_FORMAT_ARGB8888, bgColor, pReplacementSectionDisabledBg);
2428                                 SysTryCatch(NID_UI_CTRL, r == E_SUCCESS, , E_SYSTEM, "[%s] A system error has been occurred. SectionStyle image load failed", GetErrorMessage(E_SYSTEM) );
2429                         }
2430                 }
2431
2432                 if (pReplacementSectionDisabledBg)
2433                 {
2434                         DrawBitmap(*pCanvas, FloatRectangle(0.0f, 0.0f, bounds.width, bounds.height), *pReplacementSectionDisabledBg);
2435                 }
2436                 else
2437                 {
2438                         DrawBitmap(*pCanvas, FloatRectangle(0.0f, 0.0f, bounds.width, bounds.height), *pReplacementSectionBg);
2439                 }
2440         }
2441
2442         if (__pDrawingProperty->groupedLookEnabled == true)
2443         {
2444                 Color barColor;
2445
2446                 float barWidth = 0.0f;
2447                 float barMargin = 0.0f;
2448
2449                 GET_COLOR_CONFIG(TABLEVIEW::GROUPITEM_BAR_NORMAL, barColor);
2450                 GET_SHAPE_CONFIG(TABLEVIEW::GROUPITEM_BAR_WIDTH, _CONTROL_ORIENTATION_PORTRAIT, barWidth);
2451                 GET_SHAPE_CONFIG(TABLEVIEW::GROUPITEM_BAR_TOP_MARGIN, _CONTROL_ORIENTATION_PORTRAIT, barMargin);
2452
2453                 pCanvas->FillRectangle(barColor, FloatRectangle(0.0f, barMargin, barWidth, bounds.height-barMargin));
2454         }
2455
2456 CATCH:
2457         delete pReplacementSectionPressBg;
2458         delete pReplacementSectionBg;
2459         delete pReplacementSectionDisabledBg;
2460         delete pCanvas;
2461 }
2462
2463 void
2464 _TableViewItem::DrawSectionStyleBackgroundCover(void)
2465 {
2466         if (!__pDrawingProperty->sectionStyleEnabled ||
2467                 __pItemCover == null)
2468         {
2469                 return;
2470         }
2471
2472         Bitmap* pReplacementSectionBgEf = null;
2473         Bitmap* pReplacementSectionBg = null;
2474         Bitmap* pMergeBitmap = null;
2475         Canvas* pCanvas = null;
2476         Color bgColor;
2477
2478         result r = E_SUCCESS;
2479         FloatRectangle bounds = GetBoundsF();
2480
2481         if (__enabledState)
2482         {
2483                 _TableView* pParent = dynamic_cast<_TableView*>(GetParent());
2484                 SysTryCatch(NID_UI_CTRL, pParent != null, , E_SYSTEM, "[%s] A system error has been occurred. SectionTableView  load failed", GetErrorMessage(E_SYSTEM) );
2485
2486                 bgColor = pParent->GetBackgroundColor();
2487         }
2488         else
2489         {
2490                 GET_COLOR_CONFIG(TABLEVIEW::ITEM_BG_DISABLED, bgColor);
2491         }
2492
2493         if (__itemType == TABLE_VIEW_ITEM_TYPE_ONE)
2494         {
2495                 r = GET_REPLACED_BITMAP_CONFIG_N(TABLEVIEW::SECTIONITEM_SINGLE_COVER_BG_NORMAL, BITMAP_PIXEL_FORMAT_ARGB8888, bgColor, pReplacementSectionBgEf);
2496         }
2497         else if (__itemType == TABLE_VIEW_ITEM_TYPE_TOP)
2498         {
2499                 r = GET_REPLACED_BITMAP_CONFIG_N(TABLEVIEW::SECTIONITEM_TOP_COVER_BG_NORMAL, BITMAP_PIXEL_FORMAT_ARGB8888, bgColor, pReplacementSectionBgEf);
2500         }
2501         else if (__itemType == TABLE_VIEW_ITEM_TYPE_MIDDLE)
2502         {
2503                 r = GET_REPLACED_BITMAP_CONFIG_N(TABLEVIEW::SECTIONITEM_CENTER_COVER_BG_NORMAL, BITMAP_PIXEL_FORMAT_ARGB8888, bgColor, pReplacementSectionBgEf);
2504         }
2505         else if (__itemType == TABLE_VIEW_ITEM_TYPE_BOTTOM)
2506         {
2507                 r = GET_REPLACED_BITMAP_CONFIG_N(TABLEVIEW::SECTIONITEM_BOTTOM_COVER_BG_NORMAL, BITMAP_PIXEL_FORMAT_ARGB8888, bgColor, pReplacementSectionBgEf);
2508         }
2509         else
2510         {
2511                 r = E_SYSTEM;
2512         }
2513         SysTryCatch(NID_UI_CTRL, r == E_SUCCESS, , E_SYSTEM, "[%s] A system error has been occurred. SectionStyle image load failed", GetErrorMessage(E_SYSTEM) );
2514
2515         if (__itemType == TABLE_VIEW_ITEM_TYPE_ONE)
2516         {
2517                 r = GET_REPLACED_BITMAP_CONFIG_N(TABLEVIEW::SECTIONITEM_SINGLE_COVER_ROUND_BG_NORMAL, BITMAP_PIXEL_FORMAT_ARGB8888, bgColor, pReplacementSectionBg);
2518         }
2519         else if (__itemType == TABLE_VIEW_ITEM_TYPE_TOP)
2520         {
2521                 r = GET_REPLACED_BITMAP_CONFIG_N(TABLEVIEW::SECTIONITEM_TOP_COVER_ROUND_BG_NORMAL, BITMAP_PIXEL_FORMAT_ARGB8888, bgColor, pReplacementSectionBg);
2522         }
2523         else if (__itemType == TABLE_VIEW_ITEM_TYPE_MIDDLE)
2524         {
2525                 r = GET_REPLACED_BITMAP_CONFIG_N(TABLEVIEW::SECTIONITEM_CENTER_COVER_ROUND_BG_NORMAL, BITMAP_PIXEL_FORMAT_ARGB8888, bgColor, pReplacementSectionBg);
2526         }
2527         else if (__itemType == TABLE_VIEW_ITEM_TYPE_BOTTOM)
2528         {
2529                 r = GET_REPLACED_BITMAP_CONFIG_N(TABLEVIEW::SECTIONITEM_BOTTOM_COVER_ROUND_BG_NORMAL, BITMAP_PIXEL_FORMAT_ARGB8888, bgColor, pReplacementSectionBg);
2530         }
2531         else
2532         {
2533                 r = E_SYSTEM;
2534         }
2535         SysTryCatch(NID_UI_CTRL, r == E_SUCCESS, , E_SYSTEM, "[%s] A system error has been occurred. SectionStyle image load failed", GetErrorMessage(E_SYSTEM) );
2536
2537         __pItemCover->SetBounds(FloatRectangle(0.0f, 0.0f, bounds.width, bounds.height));
2538
2539         pCanvas = new (std::nothrow) Canvas();
2540         SysTryCatch(NID_UI_CTRL, pCanvas != null, , E_OUT_OF_MEMORY, "[%s] Memory allocation failed.", GetErrorMessage(E_OUT_OF_MEMORY));
2541         pCanvas->Construct(FloatRectangle(0.0f, 0.0f, bounds.width, bounds.height));
2542         pCanvas->SetBackgroundColor(Color(0, 0, 0, 0));
2543         pCanvas->Clear();
2544
2545         DrawBitmap(*pCanvas, FloatRectangle(0.0f, 0.0f, bounds.width, bounds.height), *pReplacementSectionBg);
2546         DrawBitmap(*pCanvas, FloatRectangle(0.0f, 0.0f, bounds.width, bounds.height), *pReplacementSectionBgEf);
2547
2548         pMergeBitmap = new (std::nothrow) Bitmap();
2549         SysTryCatch(NID_UI_CTRL, pMergeBitmap != null, , E_OUT_OF_MEMORY, "[%s] Memory allocation failed.", GetErrorMessage(E_OUT_OF_MEMORY));
2550
2551         pMergeBitmap->Construct(*pCanvas, FloatRectangle(0.0f, 0.0f, bounds.width, bounds.height));
2552
2553         _BitmapImpl::ConvertToNonpremultiplied(*pMergeBitmap, true);
2554
2555         __pItemCover->SetBackgroundBitmap(*pMergeBitmap);
2556
2557 CATCH:
2558         delete pReplacementSectionBgEf;
2559         delete pReplacementSectionBg;
2560         delete pCanvas;
2561         delete pMergeBitmap;
2562 }
2563
2564 void
2565 _TableViewItem::DrawContextItemBackground(void)
2566 {
2567         Canvas* pCanvas = null;
2568         Bitmap* pContextBgEf = null;
2569         Bitmap* pReplacementContextBg = null;
2570         Color bgColor = __colorItemBg[__drawingStatus];
2571
2572         FloatRectangle bounds = GetBoundsF();
2573         result r = E_SUCCESS;
2574
2575         if (__enabledState)
2576         {
2577                 if (bgColor == null)
2578                 {
2579                         GET_COLOR_CONFIG(TABLEVIEW::CONTEXTITEM_BG_NORMAL, bgColor);
2580                 }
2581         }
2582         else
2583         {
2584                 GET_COLOR_CONFIG(TABLEVIEW::ITEM_BG_DISABLED, bgColor);
2585         }
2586
2587         r = GET_REPLACED_BITMAP_CONFIG_N(TABLEVIEW::QUICK_MENU_BG_NORMAL, BITMAP_PIXEL_FORMAT_ARGB8888, bgColor, pReplacementContextBg);
2588         SysTryCatch(NID_UI_CTRL, r == E_SUCCESS, , E_SYSTEM, "[%s] A system error has been occurred. ContextItem image load failed", GetErrorMessage(E_SYSTEM));
2589
2590         r = GET_BITMAP_CONFIG_N(TABLEVIEW::QUICK_MENU_BG_EFFECT, BITMAP_PIXEL_FORMAT_ARGB8888, pContextBgEf);
2591         SysTryCatch(NID_UI_CTRL, r == E_SUCCESS, , E_SYSTEM, "[%s] A system error has been occurred. ContextItem image load failed", GetErrorMessage(E_SYSTEM));
2592
2593         pCanvas = GetVisualElement()->GetCanvasN();
2594         SysTryCatch(NID_UI_CTRL, pCanvas != null, , E_OUT_OF_MEMORY, "[%s] Memory allocation failed.", GetErrorMessage(E_OUT_OF_MEMORY));
2595
2596         pCanvas->SetBackgroundColor(Color(0, 0, 0, 0));
2597         pCanvas->Clear();
2598
2599         DrawBitmap(*pCanvas, FloatRectangle(0.0f, 0.0f, bounds.width, bounds.height), *pReplacementContextBg);
2600         DrawBitmap(*pCanvas, FloatRectangle(0.0f, 0.0f, bounds.width, bounds.height), *pContextBgEf);
2601
2602 CATCH:
2603         delete pCanvas;
2604         delete pContextBgEf;
2605         delete pReplacementContextBg;
2606 }
2607
2608
2609 void
2610 _TableViewItem::CreateAnnexStyle(void)
2611 {
2612         switch (__annexStyle)
2613         {
2614         case TABLE_VIEW_ANNEX_STYLE_MARK:
2615                 CreateCheckBox();
2616                 break;
2617         case TABLE_VIEW_ANNEX_STYLE_RADIO:
2618                 CreateRadioBox();
2619                 break;
2620         case TABLE_VIEW_ANNEX_STYLE_ONOFF_SLIDING:
2621                 CreateOnOffButton();
2622                 break;
2623         case TABLE_VIEW_ANNEX_STYLE_ONOFF_SLIDING_WITH_DIVIDER:
2624                 CreateItemAnnexDivider();
2625                 CreateOnOffButton();
2626                 break;
2627         case TABLE_VIEW_ANNEX_STYLE_DETAILED:
2628                 CreateDetailButton();
2629                 break;
2630         default:
2631                 break;
2632         }
2633 }
2634
2635 void
2636 _TableViewItem::DrawAnnexStyle(void)
2637 {
2638         switch (__annexStyle)
2639         {
2640         case TABLE_VIEW_ANNEX_STYLE_MARK:
2641                 DrawCheckBox();
2642                 break;
2643         case TABLE_VIEW_ANNEX_STYLE_RADIO:
2644                 DrawRadioBox();
2645                 break;
2646         case TABLE_VIEW_ANNEX_STYLE_ONOFF_SLIDING:
2647                 DrawOnOffButton();
2648                 break;
2649         case TABLE_VIEW_ANNEX_STYLE_ONOFF_SLIDING_WITH_DIVIDER:
2650                 DrawItemAnnexDivider();
2651                 DrawOnOffButton();
2652                 break;
2653         case TABLE_VIEW_ANNEX_STYLE_DETAILED:
2654                 DrawDetailButton();
2655                 break;
2656         default:
2657                 break;
2658         }
2659 }
2660
2661 void
2662 _TableViewItem::DrawCheckBox(void)
2663 {
2664         Bitmap* pCheckBox = null;
2665         Bitmap* pCheckBoxBg = null;
2666         Bitmap* pMergeBitmap = null;
2667         Canvas* pCanvas = null;
2668         result r = E_SUCCESS;
2669
2670         FloatRectangle bounds;
2671         float annexWidth = 0.0f;
2672         float annexHeight = 0.0f;
2673
2674         if (__enabledState)
2675         {
2676                 if (__drawingStatus == TABLE_VIEW_ITEM_DRAWING_STATUS_NORMAL)
2677                 {
2678                         r = GET_BITMAP_CONFIG_N(TABLEVIEW::CHECKBOX_BG_NORMAL, BITMAP_PIXEL_FORMAT_ARGB8888, pCheckBoxBg);
2679                         SysTryCatch(NID_UI_CTRL, (r == E_SUCCESS) && (pCheckBoxBg != null), , E_SYSTEM, "[%s] Propagating.", GetErrorMessage(r));
2680
2681                         r = GET_BITMAP_CONFIG_N(TABLEVIEW::CHECKBOX_CHECK_MARK_NORMAL, BITMAP_PIXEL_FORMAT_ARGB8888, pCheckBox);
2682                         SysTryCatch(NID_UI_CTRL, (r == E_SUCCESS) && (pCheckBox != null), , E_SYSTEM, "[%s] Propagating.", GetErrorMessage(r));
2683                 }
2684                 else if ((__drawingStatus == TABLE_VIEW_ITEM_DRAWING_STATUS_PRESSED) || (__drawingStatus == TABLE_VIEW_ITEM_DRAWING_STATUS_HIGHLIGHTED))
2685                 {
2686                         r = GET_BITMAP_CONFIG_N(TABLEVIEW::CHECKBOX_BG_PRESSED, BITMAP_PIXEL_FORMAT_ARGB8888, pCheckBoxBg);
2687                         SysTryCatch(NID_UI_CTRL, (r == E_SUCCESS) && (pCheckBoxBg != null), , E_SYSTEM, "[%s] Propagating.", GetErrorMessage(r));
2688
2689                         r = GET_BITMAP_CONFIG_N(TABLEVIEW::CHECKBOX_CHECK_MARK_PRESSED, BITMAP_PIXEL_FORMAT_ARGB8888, pCheckBox);
2690                         SysTryCatch(NID_UI_CTRL, (r == E_SUCCESS) && (pCheckBox != null), , E_SYSTEM, "[%s] Propagating.", GetErrorMessage(r));
2691                 }
2692
2693         }
2694         else
2695         {
2696                 r = GET_BITMAP_CONFIG_N(TABLEVIEW::CHECKBOX_BG_DISABLED, BITMAP_PIXEL_FORMAT_ARGB8888, pCheckBoxBg);
2697                 SysTryCatch(NID_UI_CTRL, (r == E_SUCCESS) && (pCheckBoxBg != null), , E_SYSTEM, "[%s] Propagating.", GetErrorMessage(r));
2698
2699                 r = GET_BITMAP_CONFIG_N(TABLEVIEW::CHECKBOX_CHECK_MARK_DISABLED, BITMAP_PIXEL_FORMAT_ARGB8888, pCheckBox);
2700                 SysTryCatch(NID_UI_CTRL, (r == E_SUCCESS) && (pCheckBox != null), , E_SYSTEM, "[%s] Propagating.", GetErrorMessage(r));
2701         }
2702
2703         GET_SHAPE_CONFIG(TABLEVIEW::ITEM_ANNEX_WIDTH, _CONTROL_ORIENTATION_PORTRAIT, annexWidth);
2704         GET_SHAPE_CONFIG(TABLEVIEW::ITEM_ANNEX_HEIGHT, _CONTROL_ORIENTATION_PORTRAIT, annexHeight);
2705
2706         bounds.SetBounds(0.0f, 0.0f, annexWidth, annexHeight);
2707
2708         pCanvas = new (std::nothrow) Canvas();
2709         SysTryCatch(NID_UI_CTRL, pCanvas != null, , E_OUT_OF_MEMORY, "[%s] Memory allocation failed.", GetErrorMessage(E_OUT_OF_MEMORY));
2710
2711         pCanvas->Construct(bounds);
2712         pCanvas->SetBackgroundColor(Color(0, 0, 0, 0));
2713         pCanvas->Clear();
2714
2715         DrawBitmap(*pCanvas, CalculateAnnexBitmapBounds(annexWidth, annexHeight, *pCheckBoxBg), *pCheckBoxBg);
2716
2717         if (__isCheckedAnimationEnabled == true)
2718         {
2719                 StartCheckBoxAnimation();
2720         }
2721         else
2722         {
2723                 if (IsChecked() == true && pCheckBox != null)
2724                 {
2725                         DrawBitmap(*pCanvas, CalculateAnnexBitmapBounds(annexWidth, annexHeight, *pCheckBox), *pCheckBox);
2726                 }
2727         }
2728
2729         pMergeBitmap = new (std::nothrow) Bitmap();
2730         SysTryCatch(NID_UI_CTRL, pMergeBitmap != null, , E_OUT_OF_MEMORY, "[%s] Memory allocation failed.", GetErrorMessage(E_OUT_OF_MEMORY));
2731
2732         pMergeBitmap->Construct(*pCanvas, bounds);
2733         _BitmapImpl::ConvertToNonpremultiplied(*pMergeBitmap, true);
2734
2735         __pItemAnnex->SetBackgroundBitmap(*pMergeBitmap);
2736         __pItemAnnex->Invalidate(false);
2737
2738 CATCH:
2739         delete pCheckBox;
2740         delete pCheckBoxBg;
2741         delete pMergeBitmap;
2742         delete pCanvas;
2743
2744         return;
2745 }
2746
2747 void
2748 _TableViewItem::DrawRadioBox(void)
2749 {
2750         Bitmap* pRadioButton = null;
2751         Bitmap* pRadioButtonBg = null;
2752         Bitmap* pMergeBitmap = null;
2753         Canvas* pCanvas = null;
2754         result r = E_SUCCESS;
2755
2756         FloatRectangle bounds;
2757         float annexWidth = 0.0f;
2758         float annexHeight = 0.0f;
2759
2760         if (__enabledState)
2761         {
2762                 if (__drawingStatus == TABLE_VIEW_ITEM_DRAWING_STATUS_NORMAL)
2763                 {
2764                         r = GET_BITMAP_CONFIG_N(TABLEVIEW::RADIOBUTTON_NORMAL, BITMAP_PIXEL_FORMAT_ARGB8888, pRadioButtonBg);
2765                         SysTryCatch(NID_UI_CTRL, (r == E_SUCCESS) && (pRadioButtonBg != null), , E_SYSTEM, "[%s] A system error has been occurred. RadioButtonBg image load failed", GetErrorMessage(E_SYSTEM));
2766
2767                         r = GET_BITMAP_CONFIG_N(TABLEVIEW::RADIOBUTTON_BUTTON_NORMAL, BITMAP_PIXEL_FORMAT_ARGB8888, pRadioButton);
2768                         SysTryCatch(NID_UI_CTRL, (r == E_SUCCESS) && (pRadioButton != null), , E_SYSTEM, "[%s] A system error has been occurred.CheckBox image load failed", GetErrorMessage(E_SYSTEM));
2769                 }
2770                 else if ((__drawingStatus == TABLE_VIEW_ITEM_DRAWING_STATUS_PRESSED) || (__drawingStatus == TABLE_VIEW_ITEM_DRAWING_STATUS_HIGHLIGHTED))
2771                 {
2772                         r = GET_BITMAP_CONFIG_N(TABLEVIEW::RADIOBUTTON_PRESSED, BITMAP_PIXEL_FORMAT_ARGB8888, pRadioButtonBg);
2773                         SysTryCatch(NID_UI_CTRL, (r == E_SUCCESS) && (pRadioButtonBg != null), , E_SYSTEM, "[%s] A system error has been occurred. RadioButtonBg image load failed", GetErrorMessage(E_SYSTEM));
2774
2775
2776                         r = GET_BITMAP_CONFIG_N(TABLEVIEW::RADIOBUTTON_BUTTON_PRESSED, BITMAP_PIXEL_FORMAT_ARGB8888, pRadioButton);
2777                         SysTryCatch(NID_UI_CTRL, (r == E_SUCCESS) && (pRadioButton != null), , E_SYSTEM, "[%s] A system error has been occurred.CheckBox image load failed", GetErrorMessage(E_SYSTEM));
2778                 }
2779         }
2780         else
2781         {
2782                 r = GET_BITMAP_CONFIG_N(TABLEVIEW::RADIOBUTTON_NORMAL_DISABLED, BITMAP_PIXEL_FORMAT_ARGB8888, pRadioButtonBg);
2783                 SysTryCatch(NID_UI_CTRL, (r == E_SUCCESS) && (pRadioButtonBg != null), , E_SYSTEM, "[%s] A system error has been occurred. RadioButtonBg image load failed", GetErrorMessage(E_SYSTEM));
2784
2785                 r = GET_BITMAP_CONFIG_N(TABLEVIEW::RADIOBUTTON_BUTTON_DISABLED, BITMAP_PIXEL_FORMAT_ARGB8888, pRadioButton);
2786                 SysTryCatch(NID_UI_CTRL, (r == E_SUCCESS) && (pRadioButton != null), , E_SYSTEM, "[%s] A system error has been occurred.CheckBox image load failed", GetErrorMessage(E_SYSTEM));
2787         }
2788
2789         GET_SHAPE_CONFIG(TABLEVIEW::ITEM_ANNEX_WIDTH, _CONTROL_ORIENTATION_PORTRAIT, annexWidth);
2790         GET_SHAPE_CONFIG(TABLEVIEW::ITEM_ANNEX_HEIGHT, _CONTROL_ORIENTATION_PORTRAIT, annexHeight);
2791         bounds.SetBounds(0.0f, 0.0f, annexWidth, annexHeight);
2792
2793         pCanvas = new (std::nothrow) Canvas();
2794         SysTryCatch(NID_UI_CTRL, pCanvas != null, , E_OUT_OF_MEMORY, "[%s] Memory allocation failed.", GetErrorMessage(E_OUT_OF_MEMORY));
2795
2796         pCanvas->Construct(bounds);
2797         pCanvas->SetBackgroundColor(Color(0, 0, 0, 0));
2798         pCanvas->Clear();
2799
2800         DrawBitmap(*pCanvas, CalculateAnnexBitmapBounds(annexWidth, annexHeight, *pRadioButtonBg), *pRadioButtonBg);
2801
2802         if (pRadioButton != null && IsChecked() == true)
2803         {
2804                 DrawBitmap(*pCanvas, CalculateAnnexBitmapBounds(annexWidth, annexHeight, *pRadioButton), *pRadioButton);
2805         }
2806
2807         pMergeBitmap = new (std::nothrow) Bitmap();
2808         SysTryCatch(NID_UI_CTRL, pMergeBitmap != null, , E_OUT_OF_MEMORY, "[%s] Memory allocation failed.", GetErrorMessage(E_OUT_OF_MEMORY));
2809
2810         pMergeBitmap->Construct(*pCanvas, bounds);
2811         _BitmapImpl::ConvertToNonpremultiplied(*pMergeBitmap, true);
2812
2813         __pItemAnnex->SetBackgroundBitmap(*pMergeBitmap);
2814         __pItemAnnex->Invalidate(false);
2815
2816 CATCH:
2817         delete pRadioButton;
2818         delete pRadioButtonBg;
2819         delete pMergeBitmap;
2820         delete pCanvas;
2821
2822         return;
2823 }
2824
2825 void
2826 _TableViewItem::DrawOnOffButton(void)
2827 {
2828         Bitmap* pOnOffButton = null;
2829         Bitmap* pOnOffButtonHandler = null;
2830         Bitmap* pMergeBitmap = null;
2831         Canvas* pCanvas = null;
2832         result r = E_SUCCESS;
2833
2834         FloatRectangle bounds;
2835         FloatRectangle backgroundBounds;
2836         FloatRectangle handlerBounds;
2837         float annexWidth = 0.0f;
2838         float annexHeight = 0.0f;
2839         float annexMargin = 0.0f;
2840
2841         if (IsChecked() == true)
2842         {
2843                 if (__enabledState)
2844                 {
2845                         r = GET_BITMAP_CONFIG_N(TABLEVIEW::ONOFFBUTTON_ON_HANDLER, BITMAP_PIXEL_FORMAT_ARGB8888, pOnOffButtonHandler);
2846                 }
2847                 else
2848                 {
2849                         r = GET_BITMAP_CONFIG_N(TABLEVIEW::ONOFFBUTTON_ON_HANDLER_DISABLED, BITMAP_PIXEL_FORMAT_ARGB8888, pOnOffButtonHandler);
2850                 }
2851         }
2852         else
2853         {
2854                 if (__enabledState)
2855                 {
2856                         r = GET_BITMAP_CONFIG_N(TABLEVIEW::ONOFFBUTTON_OFF_HANDLER, BITMAP_PIXEL_FORMAT_ARGB8888, pOnOffButtonHandler);
2857                 }
2858                 else
2859                 {
2860                         r = GET_BITMAP_CONFIG_N(TABLEVIEW::ONOFFBUTTON_OFF_HANDLER_DISABLED, BITMAP_PIXEL_FORMAT_ARGB8888, pOnOffButtonHandler);
2861                 }
2862         }
2863         SysTryCatch(NID_UI_CTRL, (r == E_SUCCESS) && (pOnOffButtonHandler != null), , E_SYSTEM, "[%s] A system error has been occurred. OnOffButtonHandler image load failed", GetErrorMessage(E_SYSTEM));
2864
2865         if (__enabledState)
2866         {
2867                 r = GET_BITMAP_CONFIG_N(TABLEVIEW::ONOFFBUTTON_BG, BITMAP_PIXEL_FORMAT_ARGB8888, pOnOffButton);
2868         }
2869         else
2870         {
2871                 r = GET_BITMAP_CONFIG_N(TABLEVIEW::ONOFFBUTTON_BG_DISABLED, BITMAP_PIXEL_FORMAT_ARGB8888, pOnOffButton);
2872         }
2873         SysTryCatch(NID_UI_CTRL, (r == E_SUCCESS) && (pOnOffButton != null), , E_SYSTEM, "[%s] A system error has been occurred. OnOffButton image load failed", GetErrorMessage(E_SYSTEM));
2874
2875         GET_SHAPE_CONFIG(TABLEVIEW::ITEM_ANNEX_ONOFF_WIDTH, _CONTROL_ORIENTATION_PORTRAIT, annexWidth);
2876         GET_SHAPE_CONFIG(TABLEVIEW::ITEM_ANNEX_ONOFF_HEIGHT, _CONTROL_ORIENTATION_PORTRAIT, annexHeight);
2877         bounds.SetBounds(0, 0, annexWidth, annexHeight);
2878
2879         pCanvas = new (std::nothrow) Canvas();
2880         SysTryCatch(NID_UI_CTRL, pCanvas != null, , E_OUT_OF_MEMORY, "[%s] Memory allocation failed.", GetErrorMessage(E_OUT_OF_MEMORY));
2881
2882         pCanvas->Construct(bounds);
2883         pCanvas->SetBackgroundColor(Color(0, 0, 0, 0));
2884         pCanvas->Clear();
2885
2886         backgroundBounds = CalculateAnnexBitmapBounds(annexWidth, annexHeight, *pOnOffButton);
2887         DrawBitmap(*pCanvas, backgroundBounds, *pOnOffButton);
2888
2889         handlerBounds = CalculateAnnexBitmapBounds(annexWidth, annexHeight, *pOnOffButtonHandler);
2890         GET_SHAPE_CONFIG(TABLEVIEW::ITEM_ANNEX_ONOFF_MARGIN, _CONTROL_ORIENTATION_PORTRAIT, annexMargin);
2891         if (IsChecked() == true)
2892         {
2893                 handlerBounds.x = backgroundBounds.width - handlerBounds.width - annexMargin;
2894         }
2895         else
2896         {
2897                 handlerBounds.x = backgroundBounds.x + annexMargin;
2898         }
2899
2900         DrawBitmap(*pCanvas, handlerBounds, *pOnOffButtonHandler);
2901
2902         pMergeBitmap = new (std::nothrow) Bitmap();
2903         SysTryCatch(NID_UI_CTRL, pMergeBitmap != null, , E_OUT_OF_MEMORY, "[%s] Memory allocation failed.", GetErrorMessage(E_OUT_OF_MEMORY));
2904
2905         pMergeBitmap->Construct(*pCanvas, bounds);
2906         _BitmapImpl::ConvertToNonpremultiplied(*pMergeBitmap, true);
2907
2908         __pItemAnnex->SetBackgroundBitmap(*pMergeBitmap);
2909         __pItemAnnex->Invalidate(false);
2910
2911 CATCH:
2912         delete pOnOffButton;
2913         delete pOnOffButtonHandler;
2914         delete pMergeBitmap;
2915         delete pCanvas;
2916
2917         return;
2918 }
2919
2920 void
2921 _TableViewItem::AdjustAnnexOnOffHandlerPosition()
2922 {
2923         float annexWidth = 0.0f;
2924         float annexHeight = 0.0f;
2925         float annexMargin = 0.0f;
2926
2927         float annexStartPositionX = 0.0f;
2928         float annexEndPositionX = 0.0f;
2929         float handlerPositionX = 0.0f;
2930         FloatRectangle handlerBounds;
2931         result r = E_SUCCESS;
2932
2933         GET_SHAPE_CONFIG(TABLEVIEW::ITEM_ANNEX_ONOFF_MARGIN, _CONTROL_ORIENTATION_PORTRAIT, annexMargin);
2934
2935         Bitmap* pOnOffButtonHandler = null;
2936         if (IsChecked() == true)
2937         {
2938                 r = GET_BITMAP_CONFIG_N(TABLEVIEW::ONOFFBUTTON_ON_HANDLER, BITMAP_PIXEL_FORMAT_ARGB8888, pOnOffButtonHandler);
2939         }
2940         else
2941         {
2942                 r = GET_BITMAP_CONFIG_N(TABLEVIEW::ONOFFBUTTON_OFF_HANDLER, BITMAP_PIXEL_FORMAT_ARGB8888, pOnOffButtonHandler);
2943         }
2944         SysTryReturnVoidResult(NID_UI_CTRL, (r == E_SUCCESS) && (pOnOffButtonHandler != null), E_SYSTEM, "[%s] A system error has been occurred. OnOffHandlerButton button image load failed.", GetErrorMessage(E_SYSTEM));
2945
2946         GET_SHAPE_CONFIG(TABLEVIEW::ITEM_ANNEX_ONOFF_WIDTH, _CONTROL_ORIENTATION_PORTRAIT, annexWidth);
2947         GET_SHAPE_CONFIG(TABLEVIEW::ITEM_ANNEX_ONOFF_HEIGHT, _CONTROL_ORIENTATION_PORTRAIT, annexHeight);
2948
2949         annexStartPositionX = __pItemAnnex->GetBoundsF().x;
2950         annexEndPositionX = annexStartPositionX + annexWidth + annexMargin;
2951
2952         handlerBounds = CalculateAnnexBitmapBounds(annexWidth, annexHeight, *pOnOffButtonHandler);
2953
2954         if (__annexOnOffHandlerMoved)
2955         {
2956                 if (annexStartPositionX <= __annexOnOffHandlerPositionX
2957                         && annexEndPositionX >= __annexOnOffHandlerPositionX)
2958                 {
2959                         if (((annexEndPositionX - annexStartPositionX) / 2) < (__annexOnOffHandlerPositionX + (handlerBounds.width / 2)) - annexStartPositionX )
2960                         {
2961                                 handlerPositionX = annexEndPositionX;
2962                                 SetChecked(true);
2963                         }
2964                         else
2965                         {
2966                                 handlerPositionX = annexStartPositionX;
2967                                 SetChecked(false);
2968                         }
2969                 }
2970         }
2971         else
2972         {
2973                 SetChecked(!IsChecked());
2974                 if (IsChecked())
2975                 {
2976                         handlerPositionX = annexEndPositionX;
2977                 }
2978                 else
2979                 {
2980                         handlerPositionX = annexStartPositionX;
2981                 }
2982         }
2983
2984         DrawAnnexOnOffHandler(handlerPositionX);
2985
2986         delete pOnOffButtonHandler;
2987
2988         return;
2989 }
2990
2991 void
2992 _TableViewItem::DrawAnnexOnOffHandler(float touchEndPosition)
2993 {
2994         if (__pItemAnnex == null)
2995         {
2996                 return;
2997         }
2998
2999         Bitmap* pOnOffButton = null;
3000         Bitmap* pOnOffButtonHandler = null;
3001         Bitmap* pMergeBitmap = null;
3002         Canvas* pCanvas = null;
3003         result r = E_SUCCESS;
3004
3005         FloatRectangle backgroundBounds;
3006         FloatRectangle handlerBounds;
3007         float annexWidth = 0.0f;
3008         float annexHeight = 0.0f;
3009         float annexMargin = 0.0f;
3010         float annexX = 0.0f;
3011         float nextHandlerX = 0.0f;
3012
3013         r = GET_BITMAP_CONFIG_N(TABLEVIEW::ONOFFBUTTON_BG, BITMAP_PIXEL_FORMAT_ARGB8888, pOnOffButton);
3014         SysTryReturnVoidResult(NID_UI_CTRL, (r == E_SUCCESS) && (pOnOffButton != null), E_SYSTEM, "[%s] A system error has been occurred. OnOffButton image load failed", GetErrorMessage(E_SYSTEM));
3015
3016         if (IsChecked() == true)
3017         {
3018                 r = GET_BITMAP_CONFIG_N(TABLEVIEW::ONOFFBUTTON_ON_HANDLER, BITMAP_PIXEL_FORMAT_ARGB8888, pOnOffButtonHandler);
3019         }
3020         else
3021         {
3022                 r = GET_BITMAP_CONFIG_N(TABLEVIEW::ONOFFBUTTON_OFF_HANDLER, BITMAP_PIXEL_FORMAT_ARGB8888, pOnOffButtonHandler);
3023         }
3024         SysTryCatch(NID_UI_CTRL, (r == E_SUCCESS) && (pOnOffButtonHandler != null), , E_SYSTEM, "[%s] A system error has been occurred. OnOffHandlerButton button image load failed.", GetErrorMessage(E_SYSTEM));
3025
3026         GET_SHAPE_CONFIG(TABLEVIEW::ITEM_ANNEX_ONOFF_WIDTH, _CONTROL_ORIENTATION_PORTRAIT, annexWidth);
3027         GET_SHAPE_CONFIG(TABLEVIEW::ITEM_ANNEX_ONOFF_HEIGHT, _CONTROL_ORIENTATION_PORTRAIT, annexHeight);
3028         GET_SHAPE_CONFIG(TABLEVIEW::ITEM_ANNEX_ONOFF_MARGIN, _CONTROL_ORIENTATION_PORTRAIT, annexMargin);
3029
3030         pCanvas = new (std::nothrow) Canvas();
3031         SysTryCatch(NID_UI_CTRL, pCanvas != null, , E_OUT_OF_MEMORY, "[%s] Memory allocation failed.", GetErrorMessage(E_OUT_OF_MEMORY));
3032
3033         pCanvas->Construct(FloatRectangle(0, 0, annexWidth, annexHeight));
3034         pCanvas->SetBackgroundColor(Color(0, 0, 0, 0));
3035         pCanvas->Clear();
3036
3037         backgroundBounds = CalculateAnnexBitmapBounds(annexWidth, annexHeight, *pOnOffButton);
3038         DrawBitmap(*pCanvas, backgroundBounds, *pOnOffButton);
3039
3040         handlerBounds = CalculateAnnexBitmapBounds(annexWidth, annexHeight, *pOnOffButtonHandler);
3041         handlerBounds.y  = backgroundBounds.y;
3042
3043         if (IsChecked())
3044         {
3045                 handlerBounds.x = backgroundBounds.width - handlerBounds.width - annexMargin;
3046         }
3047         else
3048         {
3049                 handlerBounds.x = backgroundBounds.x + annexMargin;
3050         }
3051
3052         nextHandlerX = handlerBounds.x + (touchEndPosition - __annexTouchStartPosition);
3053         annexX = __pItemAnnex->GetBoundsF().x;
3054
3055         if ((annexX + nextHandlerX + handlerBounds.width) < (annexX + annexWidth + annexMargin)
3056                 && (annexX + nextHandlerX) > annexX)
3057         {
3058                 handlerBounds.x = nextHandlerX;
3059         }
3060         else if (_FloatCompareGE((annexX + nextHandlerX + handlerBounds.width), (annexX + annexWidth + annexMargin)))
3061         {
3062                 handlerBounds.x = backgroundBounds.width - handlerBounds.width - annexMargin;
3063         }
3064         else if (_FloatCompareLE((annexX + nextHandlerX), annexX))
3065         {
3066                 handlerBounds.x = backgroundBounds.x + annexMargin;
3067         }
3068
3069         __annexOnOffHandlerPositionX = annexX + handlerBounds.x;
3070         DrawBitmap(*pCanvas, handlerBounds, *pOnOffButtonHandler);
3071
3072         pMergeBitmap = new (std::nothrow) Bitmap();
3073         SysTryCatch(NID_UI_CTRL, pMergeBitmap != null, , E_OUT_OF_MEMORY, "[%s] Memory allocation failed.", GetErrorMessage(E_OUT_OF_MEMORY));
3074
3075         pMergeBitmap->Construct(*pCanvas, FloatRectangle(0, 0, annexWidth, annexHeight));
3076         _BitmapImpl::ConvertToNonpremultiplied(*pMergeBitmap, true);
3077
3078         __pItemAnnex->SetBackgroundBitmap(*pMergeBitmap);
3079         __pItemAnnex->Invalidate(false);
3080
3081 CATCH:
3082         delete pOnOffButton;
3083         delete pOnOffButtonHandler;
3084         delete pMergeBitmap;
3085         delete pCanvas;
3086
3087         return;
3088 }
3089
3090 void
3091 _TableViewItem::DrawDetailButton(void)
3092 {
3093         Bitmap* pDetailBgEffect = null;
3094         Bitmap* pDetailEffect = null;
3095         Bitmap* pReplacementDetail = null;
3096         Bitmap* pReplacementDetailBg = null;
3097         Bitmap* pMergeBitmap = null;
3098         Canvas* pCanvas = null;
3099         Color replacementNewColor;
3100         Color replacementNewBgColor;
3101         result r = E_SUCCESS;
3102
3103         FloatRectangle bounds;
3104         float annexWidth = 0.0f;
3105         float annexHeight = 0.0f;
3106         bool themeBackgroundBitmap = false;
3107
3108         themeBackgroundBitmap = IS_CUSTOM_BITMAP(TABLEVIEW::CIRCLE_BUTTON_BG_NORMAL);
3109
3110         if (__enabledState)
3111         {
3112                 if (__isSelectedDetailButton)
3113                 {
3114                         if (!themeBackgroundBitmap)
3115                         {
3116                                 r = GET_BITMAP_CONFIG_N(TABLEVIEW::CIRCLE_BUTTON_BG_PRESSED, BITMAP_PIXEL_FORMAT_ARGB8888, pDetailBgEffect);
3117                                 SysTryCatch(NID_UI_CTRL, (r == E_SUCCESS) && (pDetailBgEffect != null), , E_SYSTEM, "[%s] A system error has been occurred. Detail button image load failed", GetErrorMessage(E_SYSTEM));
3118
3119                                 r = GET_BITMAP_CONFIG_N(TABLEVIEW::CIRCLE_BUTTON_REVEAL_EFFECT, BITMAP_PIXEL_FORMAT_ARGB8888, pDetailEffect);
3120                                 SysTryCatch(NID_UI_CTRL, (r == E_SUCCESS) && (pDetailEffect != null), , E_SYSTEM,"[%s] A system error has been occurred. Detail button image load failed", GetErrorMessage(E_SYSTEM));
3121                         }
3122
3123                         GET_COLOR_CONFIG(TABLEVIEW::ITEM_ANNEX_DETAIL_PRESSED, replacementNewColor);
3124
3125                         r = GET_REPLACED_BITMAP_CONFIG_N(TABLEVIEW::CIRCLE_BUTTON_REVEAL_PRESSED, BITMAP_PIXEL_FORMAT_ARGB8888, replacementNewColor, pReplacementDetail);
3126                         SysTryCatch(NID_UI_CTRL, (r == E_SUCCESS) && (pReplacementDetail != null), , E_SYSTEM, "[%s] A system error has been occurred. Detail button image load failed", GetErrorMessage(E_SYSTEM));
3127
3128                         GET_COLOR_CONFIG(TABLEVIEW::ITEM_ANNEX_DETAIL_BG_PRESSED, replacementNewBgColor);
3129                 }
3130                 else
3131                 {
3132                         if (!themeBackgroundBitmap)
3133                         {
3134                                 r = GET_BITMAP_CONFIG_N(TABLEVIEW::CIRCLE_BUTTON_BG_EFFECT, BITMAP_PIXEL_FORMAT_ARGB8888, pDetailBgEffect);
3135                                 SysTryCatch(NID_UI_CTRL, (r == E_SUCCESS) && (pDetailBgEffect != null), , E_SYSTEM, "[%s] A system error has been occurred. Detail button image load failed", GetErrorMessage(E_SYSTEM));
3136
3137                                 r = GET_BITMAP_CONFIG_N(TABLEVIEW::CIRCLE_BUTTON_REVEAL_EFFECT, BITMAP_PIXEL_FORMAT_ARGB8888, pDetailEffect);
3138                                 SysTryCatch(NID_UI_CTRL, (r == E_SUCCESS) && (pDetailEffect != null), , E_SYSTEM, "[%s] A system error has been occurred. Detail button image load failed", GetErrorMessage(E_SYSTEM));
3139                         }
3140
3141                         GET_COLOR_CONFIG(TABLEVIEW::ITEM_ANNEX_DETAIL_NORMAL, replacementNewColor);
3142
3143                         r = GET_REPLACED_BITMAP_CONFIG_N(TABLEVIEW::CIRCLE_BUTTON_REVEAL_NORMAL, BITMAP_PIXEL_FORMAT_ARGB8888, replacementNewColor, pReplacementDetail);
3144                         SysTryCatch(NID_UI_CTRL, (r == E_SUCCESS) && (pReplacementDetail != null), , E_SYSTEM, "[%s] A system error has been occurred. Detail button image load failed", GetErrorMessage(E_SYSTEM));
3145
3146                         GET_COLOR_CONFIG(TABLEVIEW::ITEM_ANNEX_DETAIL_BG_NORMAL, replacementNewBgColor);
3147                 }
3148         }
3149         else
3150         {
3151                 if (!themeBackgroundBitmap)
3152                 {
3153                         r = GET_BITMAP_CONFIG_N(TABLEVIEW::CIRCLE_BUTTON_BG_EFFECT_DISABLED, BITMAP_PIXEL_FORMAT_ARGB8888, pDetailBgEffect);
3154                         SysTryCatch(NID_UI_CTRL, (r == E_SUCCESS) && (pDetailBgEffect != null), , E_SYSTEM, "[%s] A system error has been occurred. Detail button image load failed", GetErrorMessage(E_SYSTEM));
3155
3156                         r = GET_BITMAP_CONFIG_N(TABLEVIEW::CIRCLE_BUTTON_REVEAL_EFFECT, BITMAP_PIXEL_FORMAT_ARGB8888, pDetailEffect);
3157                         SysTryCatch(NID_UI_CTRL, (r == E_SUCCESS) && (pDetailEffect != null), , E_SYSTEM, "[%s] A system error has been occurred. Detail button image load failed", GetErrorMessage(E_SYSTEM));
3158                 }
3159
3160                 GET_COLOR_CONFIG(TABLEVIEW::ITEM_ANNEX_DETAIL_NORMAL, replacementNewColor);
3161
3162                 r = GET_REPLACED_BITMAP_CONFIG_N(TABLEVIEW::CIRCLE_BUTTON_REVEAL_DISABLED, BITMAP_PIXEL_FORMAT_ARGB8888, replacementNewColor, pReplacementDetail);
3163                 SysTryCatch(NID_UI_CTRL, (r == E_SUCCESS) && (pReplacementDetail != null), , E_SYSTEM, "[%s] A system error has been occurred. Detail button image load failed", GetErrorMessage(E_SYSTEM));
3164
3165                 r = GET_REPLACED_BITMAP_CONFIG_N(TABLEVIEW::CIRCLE_BUTTON_BG_DISABLED, BITMAP_PIXEL_FORMAT_ARGB8888, replacementNewBgColor, pReplacementDetailBg);
3166                 SysTryCatch(NID_UI_CTRL, (r == E_SUCCESS) && (pReplacementDetailBg != null), , E_SYSTEM, "[%s] A system error has been occurred. Detail button image load failed", GetErrorMessage(E_SYSTEM));
3167         }
3168
3169         if (pReplacementDetailBg == null)
3170         {
3171                 r = GET_REPLACED_BITMAP_CONFIG_N(TABLEVIEW::CIRCLE_BUTTON_BG_NORMAL, BITMAP_PIXEL_FORMAT_ARGB8888, replacementNewBgColor, pReplacementDetailBg);
3172                 SysTryCatch(NID_UI_CTRL, (r == E_SUCCESS) && (pReplacementDetailBg != null), , E_SYSTEM, "[%s] A system error has been occurred. Detail button image load failed", GetErrorMessage(E_SYSTEM));
3173         }
3174
3175         GET_SHAPE_CONFIG(TABLEVIEW::ITEM_ANNEX_MORE_WIDTH, _CONTROL_ORIENTATION_PORTRAIT, annexWidth);
3176         GET_SHAPE_CONFIG(TABLEVIEW::ITEM_ANNEX_MORE_HEIGHT, _CONTROL_ORIENTATION_PORTRAIT, annexHeight);
3177
3178         bounds.SetBounds(0, 0, annexWidth, annexHeight);
3179
3180         pCanvas = new (std::nothrow) Canvas();
3181         SysTryCatch(NID_UI_CTRL, pCanvas != null, , E_OUT_OF_MEMORY, "[%s] Memory allocation failed.", GetErrorMessage(E_OUT_OF_MEMORY));
3182
3183         pCanvas->Construct(bounds);
3184         pCanvas->SetBackgroundColor(Color(0, 0, 0, 0));
3185         pCanvas->Clear();
3186
3187         DrawBitmap(*pCanvas, CalculateAnnexBitmapBounds(annexWidth, annexHeight, *pReplacementDetailBg), *pReplacementDetailBg);
3188         if (pDetailBgEffect)
3189         {
3190                 DrawBitmap(*pCanvas, CalculateAnnexBitmapBounds(annexWidth, annexHeight, *pDetailBgEffect), *pDetailBgEffect);
3191         }
3192         DrawBitmap(*pCanvas, CalculateAnnexBitmapBounds(annexWidth, annexHeight, *pReplacementDetail), *pReplacementDetail);
3193         if (pDetailEffect)
3194         {
3195                 DrawBitmap(*pCanvas, CalculateAnnexBitmapBounds(annexWidth, annexHeight, *pDetailEffect), *pDetailEffect);
3196         }
3197
3198         pMergeBitmap = new (std::nothrow) Bitmap();
3199         SysTryCatch(NID_UI_CTRL, pMergeBitmap != null, , E_OUT_OF_MEMORY, "[%s] Memory allocation failed.", GetErrorMessage(E_OUT_OF_MEMORY));
3200         pMergeBitmap->Construct(*pCanvas, bounds);
3201         _BitmapImpl::ConvertToNonpremultiplied(*pMergeBitmap, true);
3202
3203         __pItemAnnex->SetBackgroundBitmap(*pMergeBitmap);
3204         __pItemAnnex->Invalidate(false);
3205
3206 CATCH:
3207         delete pDetailBgEffect;
3208         delete pDetailEffect;
3209         delete pReplacementDetail;
3210         delete pReplacementDetailBg;
3211         delete pMergeBitmap;
3212         delete pCanvas;
3213
3214         return;
3215 }
3216
3217 void
3218 _TableViewItem::DrawItemDivider(void)
3219 {
3220         if (__pItemDivider == null || __pItemTopDivider == null)
3221         {
3222                 return;
3223         }
3224
3225         if (__pDrawingProperty->itemDividerEnabled == false ||
3226                 __itemType == TABLE_VIEW_ITEM_TYPE_HEADER ||
3227                 __itemType == TABLE_VIEW_ITEM_TYPE_FOOTER ||
3228                 __itemDividerEnabled == false ||
3229                 __isSectionItem)
3230         {
3231                 __pItemDivider->SetVisibleState(false);
3232                 __pItemTopDivider->SetVisibleState(false);
3233
3234                 return;
3235         }
3236
3237         FloatRectangle dividerBottomBounds;
3238         FloatRectangle dividerTopBounds;
3239         Color topLineColor;
3240         Color bottomLineColor;
3241         Color customDividerColor;
3242         FloatRectangle bounds;
3243         FloatPoint bottomPoint;
3244
3245         __pItemDivider->SetVisibleState(true);
3246         __pItemTopDivider->SetVisibleState(true);
3247
3248         if (    __drawingStatus == TABLE_VIEW_ITEM_DRAWING_STATUS_PRESSED ||
3249                 __drawingStatus == TABLE_VIEW_ITEM_DRAWING_STATUS_HIGHLIGHTED)
3250         {
3251                 if (__colorItemBg[TABLE_VIEW_ITEM_DRAWING_STATUS_NORMAL] != __colorItemBg[TABLE_VIEW_ITEM_DRAWING_STATUS_PRESSED])
3252                 {
3253                         if (__itemType != TABLE_VIEW_ITEM_TYPE_TITLE)
3254                         {
3255                                 __pItemDivider->SetVisibleState(false);
3256                         }
3257
3258                         __pItemTopDivider->SetVisibleState(false);
3259                 }
3260         }
3261
3262         if (__itemType == TABLE_VIEW_ITEM_TYPE_TITLE)
3263         {
3264                 if (__pItemBgBitmap[__drawingStatus] != null)
3265                 {
3266                         __pItemDivider->SetVisibleState(false);
3267                 }
3268                 else
3269                 {
3270                         float lineHeight = 0.0f;
3271                         float lineLeftMargin = 0.0f;
3272                         float lineBottomMargin = 0.0f;
3273                         bounds = GetBoundsF();
3274
3275                         if (__drawingStatus == TABLE_VIEW_ITEM_DRAWING_STATUS_NORMAL)
3276                         {
3277                                 GET_COLOR_CONFIG(TABLEVIEW::GROUPITEM_INDEX_BAR_NORMAL, bottomLineColor);
3278                         }
3279                         else
3280                         {
3281                                 GET_COLOR_CONFIG(TABLEVIEW::GROUPITEM_INDEX_BAR_PRESSED, bottomLineColor);
3282                         }
3283
3284                         GET_SHAPE_CONFIG(TABLEVIEW::GROUPITEM_INDEX_BAR_HEIGHT, _CONTROL_ORIENTATION_PORTRAIT, lineHeight);
3285                         GET_SHAPE_CONFIG(TABLEVIEW::GROUPITEM_INDEX_BAR_LEFT_MARGIN, _CONTROL_ORIENTATION_PORTRAIT, lineLeftMargin);
3286                         GET_SHAPE_CONFIG(TABLEVIEW::GROUPITEM_INDEX_BAR_BOTTOM_MARGIN, _CONTROL_ORIENTATION_PORTRAIT, lineBottomMargin);
3287
3288                         lineHeight = Tizen::Graphics::CoordinateSystem::ConvertToLogicalY(lineHeight);
3289                         lineBottomMargin = Tizen::Graphics::CoordinateSystem::ConvertToLogicalY(lineBottomMargin);
3290                         bottomPoint = Tizen::Graphics::CoordinateSystem::AlignToDevice(FloatPoint(lineLeftMargin, bounds.height));
3291                         dividerBottomBounds = FloatRectangle(bottomPoint.x, bottomPoint.y - lineBottomMargin, bounds.width - lineLeftMargin * 2.0f, lineHeight);
3292                 }
3293         }
3294         else
3295         {
3296                 float lineLeftMargin = 0.0f;
3297                 float lineHeight = 0.0f;
3298                 bounds = GetBoundsF();
3299
3300                 if (!IsContextItem())
3301                 {
3302                         if (!__isSimpleLastItem)
3303                         {
3304                                 if (__itemType == TABLE_VIEW_ITEM_TYPE_BOTTOM || __itemType == TABLE_VIEW_ITEM_TYPE_ONE)
3305                                 {
3306                                         __pItemDivider->SetVisibleState(false);
3307                                         __pItemTopDivider->SetVisibleState(false);
3308                                 }
3309                         }
3310                 }
3311
3312                 customDividerColor = __pDrawingProperty->dividerColor;
3313                 GET_COLOR_CONFIG(TABLEVIEW::ITEM_DIVIDER_TOP_BG_NORMAL, topLineColor);
3314                 GET_COLOR_CONFIG(TABLEVIEW::ITEM_DIVIDER_BOTTOM_BG_NORMAL, bottomLineColor);
3315                 GET_FIXED_VALUE_CONFIG(TABLEVIEW::ITEM_DIVIDER_LEFT_MARGIN, _CONTROL_ORIENTATION_PORTRAIT, lineLeftMargin);
3316                 GET_FIXED_VALUE_CONFIG(TABLEVIEW::ITEM_DIVIDER_HEIGHT, _CONTROL_ORIENTATION_PORTRAIT, lineHeight);
3317
3318                 lineLeftMargin = Tizen::Graphics::CoordinateSystem::ConvertToLogicalX(lineLeftMargin);
3319                 lineHeight = Tizen::Graphics::CoordinateSystem::ConvertToLogicalY(lineHeight);
3320                 bottomPoint = Tizen::Graphics::CoordinateSystem::AlignToDevice(FloatPoint(lineLeftMargin, (bounds.height)));
3321
3322                 dividerTopBounds.SetBounds(lineLeftMargin, bottomPoint.y - (lineHeight * 2.0f), bounds.width - lineLeftMargin * 2.0f, lineHeight);
3323                 dividerBottomBounds.SetBounds(lineLeftMargin, bottomPoint.y - lineHeight, bounds.width - lineLeftMargin * 2.0f, lineHeight);
3324         }
3325
3326         if (__pItemDivider->GetVisibleState())
3327         {
3328                 __pItemDivider->SetBounds(dividerBottomBounds);
3329                 if (customDividerColor == bottomLineColor || __itemType == TABLE_VIEW_ITEM_TYPE_TITLE)
3330                 {
3331                         __pItemDivider->SetBackgroundColor(bottomLineColor);
3332                 }
3333                 else
3334                 {
3335                         __pItemDivider->SetBackgroundColor(customDividerColor);
3336                         __pItemDivider->GetVisualElement()->SetOpacity(ITEM_BOTTOM_DIVIDER_OPACITY);
3337                 }
3338                         __pItemDivider->Invalidate();
3339         }
3340
3341         if (__pItemTopDivider->GetVisibleState())
3342         {
3343                 __pItemTopDivider->SetBounds(dividerTopBounds);
3344                 if (customDividerColor == bottomLineColor)
3345                 {
3346                         __pItemTopDivider->SetBackgroundColor(topLineColor);
3347                 }
3348                 else
3349                 {
3350                         __pItemTopDivider->SetBackgroundColor(customDividerColor);
3351                         __pItemTopDivider->GetVisualElement()->SetOpacity(ITEM_TOP_DIVIDER_OPACITY);
3352                 }
3353                 __pItemTopDivider->Invalidate();
3354         }
3355 }
3356
3357 void
3358 _TableViewItem::DrawItemAnnexDivider(void)
3359 {
3360         if (__itemType == TABLE_VIEW_ITEM_TYPE_HEADER || __itemType == TABLE_VIEW_ITEM_TYPE_FOOTER)
3361         {
3362                 if (__pItemAnnexLeftDivider != null)
3363                 {
3364                         __pItemAnnexLeftDivider->SetVisibleState(false);
3365                 }
3366
3367                 if (__pItemAnnexRightDivider != null)
3368                 {
3369                         __pItemAnnexRightDivider->SetVisibleState(false);
3370                 }
3371         }
3372         else
3373         {
3374                 Color dividerLeftColor;
3375                 Color dividerRightColor;
3376                 Color customDividerColor;
3377                 Color bottomLineColor;
3378                 FloatRectangle bounds = GetBoundsF();
3379                 float dividerHeight = 0;
3380                 float itemHeight = 0;
3381                 float dividerWidth = 0.0f;
3382                 float dividerTopMargin = 0.0f;
3383                 float annexWidth = 0.0f;
3384                 float annexLeftMargin = 0.0f;
3385                 float itemLeftMargin = 0.0f;
3386
3387                 customDividerColor = __pDrawingProperty->dividerColor;
3388                 GET_SHAPE_CONFIG(TABLEVIEW::ITEM_LEFT_MARGIN, _CONTROL_ORIENTATION_PORTRAIT, itemLeftMargin);
3389                 GET_SHAPE_CONFIG(TABLEVIEW::ITEM_ANNEX_MARGIN, _CONTROL_ORIENTATION_PORTRAIT, annexLeftMargin);
3390                 GET_SHAPE_CONFIG(TABLEVIEW::ITEM_ANNEX_ONOFF_WIDTH, _CONTROL_ORIENTATION_PORTRAIT, annexWidth);
3391                 GET_COLOR_CONFIG(TABLEVIEW::ITEM_ANNEX_DIVIDER_LEFT_BG_NORMAL, dividerLeftColor);
3392                 GET_COLOR_CONFIG(TABLEVIEW::ITEM_ANNEX_DIVIDER_RIGHT_BG_NORMAL, dividerRightColor);
3393                 GET_COLOR_CONFIG(TABLEVIEW::ITEM_DIVIDER_BOTTOM_BG_NORMAL, bottomLineColor);
3394                 GET_FIXED_VALUE_CONFIG(TABLEVIEW::ITEM_ANNEX_DIVIDER_WIDTH, _CONTROL_ORIENTATION_PORTRAIT, dividerWidth);
3395                 GET_FIXED_VALUE_CONFIG(TABLEVIEW::ITEM_ANNEX_DIVIDER_MARGIN, _CONTROL_ORIENTATION_PORTRAIT, dividerTopMargin);
3396
3397                 itemLeftMargin += __pDrawingProperty->scrollMargin;
3398                 itemHeight = ((__customHeight > 0) ? __customHeight : GetBoundsF().height);
3399                 dividerHeight = itemHeight - (dividerTopMargin*2);
3400                 dividerHeight = (dividerHeight > 0) ? dividerHeight : 0;
3401                 __pItemAnnexLeftDivider->SetBounds(FloatRectangle((GetBoundsF().width - annexWidth - (itemLeftMargin + annexLeftMargin) - (dividerWidth*2)), dividerTopMargin, dividerWidth, dividerHeight));
3402                 __pItemAnnexRightDivider->SetBounds(FloatRectangle((GetBoundsF().width - annexWidth - (itemLeftMargin + annexLeftMargin) - dividerWidth), dividerTopMargin, dividerWidth, dividerHeight));
3403
3404                 if (customDividerColor == bottomLineColor)
3405                 {
3406                         __pItemAnnexLeftDivider->SetBackgroundColor(dividerLeftColor);
3407                 }
3408                 else
3409                 {
3410                         __pItemAnnexLeftDivider->SetBackgroundColor(customDividerColor);
3411                         __pItemAnnexLeftDivider->GetVisualElement()->SetOpacity(ITEM_TOP_DIVIDER_OPACITY);
3412                 }
3413
3414                 if (customDividerColor == bottomLineColor)
3415                 {
3416                         __pItemAnnexRightDivider->SetBackgroundColor(dividerRightColor);
3417                 }
3418                 else
3419                 {
3420                         __pItemAnnexRightDivider->SetBackgroundColor(customDividerColor);
3421                         __pItemAnnexRightDivider->GetVisualElement()->SetOpacity(ITEM_BOTTOM_DIVIDER_OPACITY);
3422                 }
3423
3424                 __pItemAnnexLeftDivider->Invalidate();
3425                 __pItemAnnexRightDivider->Invalidate();
3426         }
3427
3428         if (__pItemAnnexLeftDivider != null)
3429         {
3430                 _AccessibilityContainer* pContainer = __pItemAnnexLeftDivider->GetAccessibilityContainer();
3431                 pContainer->Activate(false);
3432         }
3433
3434         if (__pItemAnnexRightDivider != null)
3435         {
3436                 _AccessibilityContainer* pContainer = __pItemAnnexRightDivider->GetAccessibilityContainer();
3437                 pContainer->Activate(false);
3438         }
3439 }
3440
3441
3442 result
3443 _TableViewItem::DrawBitmap(Canvas& canvas, const FloatRectangle& bounds, const Bitmap& bitmap)
3444 {
3445         result r = E_SUCCESS;
3446         if (_BitmapImpl::CheckNinePatchedBitmapStrictly(bitmap))
3447         {
3448                 r = canvas.DrawNinePatchedBitmap(bounds, bitmap);
3449                 SysTryReturnResult(NID_UI_CTRL, r == E_SUCCESS, r, "Fail to draw ninepatched bitmap.");
3450         }
3451         else
3452         {
3453                 r = canvas.DrawBitmap(bounds, bitmap);
3454                 SysTryReturnResult(NID_UI_CTRL, r == E_SUCCESS, r, "Fail to draw bitmap.");
3455         }
3456
3457         return r;
3458 }
3459
3460 result
3461 _TableViewItem::SetItemHighlightBounds(_VisualElement& highlightVisualElement, const FloatRectangle& bounds)
3462 {
3463         return highlightVisualElement.SetBounds(bounds);
3464 }
3465
3466 FloatRectangle
3467 _TableViewItem::CalculateItemHighlightBounds(void)
3468 {
3469         FloatRectangle itemBounds = GetBoundsF();
3470         return FloatRectangle(0.0f, 0.0f, itemBounds.width, itemBounds.height);
3471 }
3472
3473 FloatRectangle
3474 _TableViewItem::CalculateAnnexBitmapBounds(float annexWidth, float annexHeight, const Bitmap& bitmap)
3475 {
3476         FloatRectangle bounds;
3477         float width = 0;
3478         float height = 0;
3479         float leftMargin = 0;
3480         float topMargin = 0;
3481
3482         if (annexWidth > bitmap.GetWidthF())
3483         {
3484                 leftMargin = (annexWidth - bitmap.GetWidthF()) / 2;
3485                 width = bitmap.GetWidthF();
3486         }
3487         else
3488         {
3489                 width = annexWidth;
3490         }
3491
3492         if (annexHeight > bitmap.GetHeightF())
3493         {
3494                 topMargin = (annexHeight - bitmap.GetHeightF()) / 2;
3495                 height = bitmap.GetHeightF();
3496         }
3497         else
3498         {
3499                 height = annexHeight;
3500         }
3501
3502         bounds.SetBounds(leftMargin, topMargin, width, height);
3503
3504         return bounds;
3505 }
3506
3507 bool
3508 _TableViewItem::IsTitleStyleItem(void) const
3509 {
3510         if (__itemType == TABLE_VIEW_ITEM_TYPE_TITLE || __itemType == TABLE_VIEW_ITEM_TYPE_HEADER || __itemType == TABLE_VIEW_ITEM_TYPE_FOOTER)
3511         {
3512                 return true;
3513         }
3514
3515         return false;
3516 }
3517
3518 bool
3519 _TableViewItem::IsValidSelectionState(void)
3520 {
3521         _TableView* pParent = dynamic_cast<_TableView*>(GetParent());
3522         if (pParent == null)
3523         {
3524                 return true;
3525         }
3526
3527         if (pParent->GetPressedItemCount() > 0)
3528         {
3529                 return false;
3530         }
3531
3532         return true;
3533 }
3534
3535 void
3536 _TableViewItem::DrawSimpleItem(void)
3537 {
3538         if (__pSimpleItemText != null)
3539         {
3540                 Color textColor = __simpleItemTextColor[__drawingStatus];
3541                 if (!IsEnabled())
3542                 {
3543                         textColor = __simpleItemTextColor[TABLE_VIEW_SIMPLEITEM_DRAWING_STATUS_DISABLED];
3544                 }
3545
3546                 if (__itemType == TABLE_VIEW_ITEM_TYPE_TITLE)
3547                 {
3548                         if (__drawingStatus == TABLE_VIEW_ITEM_DRAWING_STATUS_NORMAL)
3549                         {
3550                                 textColor = __simpleItemTextColor[TABLE_VIEW_GROUPITEM_DRAWING_STATUS_NORMAL];
3551                         }
3552                         else
3553                         {
3554                                 textColor = __simpleItemTextColor[TABLE_VIEW_GROUPITEM_DRAWING_STATUS_PRESSED];
3555                         }
3556                 }
3557
3558                 __pSimpleItemText->SetTextColor(textColor);
3559                 __pSimpleItemText->Invalidate(false);
3560         }
3561 }
3562 result
3563 _TableViewItem::SetSimpleItemContents(const Tizen::Base::String& text, const Tizen::Graphics::Bitmap* pBitmap, bool groupType)
3564 {
3565         result r = E_SUCCESS;
3566         bool textOnly = true;
3567
3568         if (pBitmap != null)
3569         {
3570                 textOnly = false;
3571         }
3572
3573         r = CreateSimpleItemContents(textOnly);
3574         SysTryReturn(NID_UI_CTRL, r == E_SUCCESS, r, r, "[%s] Propagating.", GetErrorMessage(r));
3575
3576         FloatRectangle bitmapRect = FloatRectangle(0.0f, 0.0f, 0.0f, 0.0f);
3577         FloatRectangle textRect = FloatRectangle(0.0f, 0.0f, 0.0f, 0.0f);
3578         float leftMargin = 0.0f;
3579         float annexMargin = 0.0f;
3580         float elementWidth = 0;
3581         float elementHeight = 0;
3582         float itemHeight = GetBoundsF().height;
3583         float itemWidth = GetBoundsF().width;
3584         float annexWidth = GetAnnexWidth(__annexStyle);
3585
3586         if (groupType)
3587         {
3588                 if (__simpleItemTextSize == 0)
3589                 {
3590                         GET_SHAPE_CONFIG(TABLEVIEW::GROUPITEM_DEFAULT_FONT_SIZE, _CONTROL_ORIENTATION_PORTRAIT, __simpleItemTextSize);
3591                 }
3592                 GET_SHAPE_CONFIG(TABLEVIEW::GROUPITEM_LEFT_MARGIN, _CONTROL_ORIENTATION_PORTRAIT, leftMargin);
3593         }
3594         else
3595         {
3596                 if (__simpleItemTextSize == 0)
3597                 {
3598                         GET_SHAPE_CONFIG(TABLEVIEW::ITEM_DEFAULT_FONT_SIZE, _CONTROL_ORIENTATION_PORTRAIT, __simpleItemTextSize);
3599                 }
3600                 GET_SHAPE_CONFIG(TABLEVIEW::ITEM_LEFT_MARGIN, _CONTROL_ORIENTATION_PORTRAIT, leftMargin);
3601         }
3602
3603         if (!textOnly)
3604         {
3605                 elementWidth = itemHeight * SIMPLE_ITEM_ELEMENT_BITMAP_SIZE_RATIO;
3606                 elementHeight = elementWidth;
3607
3608                 bitmapRect.x = leftMargin;
3609                 bitmapRect.y = (itemHeight - elementHeight) / 2;
3610                 bitmapRect.width = elementWidth;
3611                 bitmapRect.height = elementHeight;
3612         }
3613
3614         if (__annexStyle == TABLE_VIEW_ANNEX_STYLE_NORMAL)
3615         {
3616                 textRect.x = bitmapRect.x + elementWidth + leftMargin;
3617                 elementWidth = itemWidth - textRect.x - leftMargin;
3618         }
3619         else
3620         {
3621                 GET_SHAPE_CONFIG(TABLEVIEW::ITEM_ANNEX_MARGIN, _CONTROL_ORIENTATION_PORTRAIT, annexMargin);
3622                 if (__annexStyle == TABLE_VIEW_ANNEX_STYLE_MARK || __annexStyle == TABLE_VIEW_ANNEX_STYLE_RADIO)
3623                 {
3624                         bitmapRect.x = leftMargin + annexWidth + annexMargin;
3625                         textRect.x = bitmapRect.x + elementWidth + leftMargin;
3626                         elementWidth = itemWidth - textRect.x - leftMargin;
3627                 }
3628                 else
3629                 {
3630                         textRect.x = bitmapRect.x + elementWidth + leftMargin;
3631                         elementWidth = itemWidth - textRect.x - annexWidth - leftMargin - annexMargin;
3632                 }
3633         }
3634
3635         textRect.y = 0.0f;
3636         textRect.width = elementWidth < 0 ? 0 : elementWidth;;
3637         textRect.height = itemHeight;
3638
3639         if (__pSimpleItemBitmap != null && pBitmap != null)
3640         {
3641                 __pSimpleItemBitmap->SetBackgroundBitmap(*pBitmap);
3642                 __pSimpleItemBitmap->SetBounds(bitmapRect);
3643
3644                 _Label* pSimpleItemBitmapCore = GetLabelCore(__pSimpleItemBitmap);
3645                 if (!pSimpleItemBitmapCore->HasParent())
3646                 {
3647                         r = AttachChild(*pSimpleItemBitmapCore);
3648                         SysTryReturn(NID_UI_CTRL, __pSimpleItemBitmap != null, r, r, "[%s] Propagating.", GetErrorMessage(r));
3649                 }
3650         }
3651
3652         if (__pSimpleItemText != null)
3653         {
3654                 __pSimpleItemText->SetTextConfig(__simpleItemTextSize, LABEL_TEXT_STYLE_NORMAL);
3655                 __pSimpleItemText->SetText(text);
3656                 __pSimpleItemText->SetBounds(textRect);
3657
3658                 _Label* pSimpleItemTextCore = GetLabelCore(__pSimpleItemText);
3659                 if (!pSimpleItemTextCore->HasParent())
3660                 {
3661                         r = AttachChild(*pSimpleItemTextCore);
3662                         SysTryReturn(NID_UI_CTRL, __pSimpleItemText != null, r, r, "[%s] Propagating.", GetErrorMessage(r));
3663                 }
3664         }
3665
3666         return E_SUCCESS;
3667 }
3668
3669 result
3670 _TableViewItem::CreateSimpleItemContents(bool textOnly)
3671 {
3672         result r = E_SUCCESS;
3673
3674         if (__pSimpleItemText == null)
3675         {
3676                 __pSimpleItemText = new (std::nothrow) Label();
3677
3678                 r = GetLastResult();
3679                 SysTryReturn(NID_UI_CTRL, __pSimpleItemText != null, r, r, "[%s] Propagating.", GetErrorMessage(r));
3680
3681                 __pSimpleItemText->Construct(FloatRectangle(0.0f, 0.0f, 0.0f, 0.0f), L"");
3682
3683                 __pSimpleItemText->SetTextHorizontalAlignment(ALIGNMENT_LEFT);
3684                 __pSimpleItemText->SetTextVerticalAlignment(ALIGNMENT_MIDDLE);
3685                 if (__itemType == TABLE_VIEW_ITEM_TYPE_TITLE)
3686                 {
3687                         __pSimpleItemText->SetTextColor(__simpleItemTextColor[TABLE_VIEW_GROUPITEM_DRAWING_STATUS_NORMAL]);
3688                 }
3689                 else
3690                 {
3691                         __pSimpleItemText->SetTextColor(__simpleItemTextColor[TABLE_VIEW_ITEM_DRAWING_STATUS_NORMAL]);
3692                 }
3693                 __pSimpleItemText->SetBackgroundColor(Color(0, 0, 0, 0));
3694                 GetLabelCore(__pSimpleItemText)->SetFocusable(true);
3695
3696         }
3697
3698         if (!textOnly)
3699         {
3700                 if (__pSimpleItemBitmap == null)
3701                 {
3702                         __pSimpleItemBitmap = new (std::nothrow) Label();
3703
3704                         r = GetLastResult();
3705                         SysTryReturn(NID_UI_CTRL, __pSimpleItemBitmap != null, r, r, "[%s] Propagating.", GetErrorMessage(r));
3706
3707                         __pSimpleItemBitmap->Construct(FloatRectangle(0.0f, 0.0f, 0.0f, 0.0f), L"");
3708                         __pSimpleItemBitmap->SetBackgroundColor(Color(0, 0, 0, 0));
3709                         GetLabelCore(__pSimpleItemBitmap)->SetFocusable(true);
3710                 }
3711
3712         }
3713         else
3714         {
3715                 if (__pSimpleItemBitmap != null)
3716                 {
3717                         delete __pSimpleItemBitmap;
3718                         __pSimpleItemBitmap = null;
3719                 }
3720         }
3721
3722         return E_SUCCESS;
3723 }
3724
3725 result
3726 _TableViewItem::SetSimpleTextColor(const Tizen::Graphics::Color& color, TableViewItemDrawingStatus status)
3727 {
3728         __simpleItemTextColor[status] = color;
3729
3730         return E_SUCCESS;
3731 }
3732
3733 Tizen::Graphics::Color
3734 _TableViewItem::GetSimpleItemTextColor(TableViewItemDrawingStatus status) const
3735 {
3736         return __simpleItemTextColor[status];
3737 }
3738
3739 result
3740 _TableViewItem::SetSimpleGroupItemTextColor(const Tizen::Graphics::Color& color, TableViewItemDrawingStatus status)
3741 {
3742         if (status == TABLE_VIEW_ITEM_DRAWING_STATUS_NORMAL)
3743         {
3744                 __simpleItemTextColor[TABLE_VIEW_GROUPITEM_DRAWING_STATUS_NORMAL] = color;
3745         }
3746         else if (status == TABLE_VIEW_ITEM_DRAWING_STATUS_PRESSED)
3747         {
3748                 __simpleItemTextColor[TABLE_VIEW_GROUPITEM_DRAWING_STATUS_PRESSED] = color;
3749         }
3750
3751         return E_SUCCESS;
3752 }
3753
3754 Tizen::Graphics::Color
3755 _TableViewItem::GetSimpleGroupItemTextColor(TableViewItemDrawingStatus status) const
3756 {
3757         if (status == TABLE_VIEW_ITEM_DRAWING_STATUS_PRESSED)
3758         {
3759                 return __simpleItemTextColor[TABLE_VIEW_GROUPITEM_DRAWING_STATUS_PRESSED];
3760         }
3761         else
3762         {
3763                 return __simpleItemTextColor[TABLE_VIEW_GROUPITEM_DRAWING_STATUS_NORMAL];
3764         }
3765 }
3766
3767 result
3768 _TableViewItem::SetSimpleItemTextSize(int size)
3769 {
3770         if (__simpleItemTextSize == size)
3771         {
3772                 return E_SUCCESS;
3773         }
3774
3775         __simpleItemTextSize = size;
3776
3777         if (__pSimpleItemText != null)
3778         {
3779                 __pSimpleItemText->SetTextConfig(__simpleItemTextSize, LABEL_TEXT_STYLE_NORMAL);
3780         }
3781         return E_SUCCESS;
3782 }
3783
3784 int
3785 _TableViewItem::GetSimpleItemTextSize(void) const
3786 {
3787         return __simpleItemTextSize;
3788 }
3789
3790 result
3791 _TableViewItem::SetSectionHeaderFooterContents(const Tizen::Base::String& text, HorizontalAlignment alignment, bool isHeader)
3792 {
3793         if (__pHeaderFooterItemText == null)
3794         {
3795                 result r = E_SUCCESS;
3796                 float contentsHeight = 0.0f;
3797                 float positionY = 0.0f;
3798                 Color textColor;
3799
3800                 GET_COLOR_CONFIG(TABLEVIEW::GROUPITEM_TEXT_NORMAL, textColor);
3801                 GET_SHAPE_CONFIG(TABLEVIEW::GROUPITEM_DEFAULT_TEXT_HEIGHT, _CONTROL_ORIENTATION_PORTRAIT, contentsHeight);
3802
3803                 __pHeaderFooterItemText = new (std::nothrow) Label();
3804
3805                 r = GetLastResult();
3806                 SysTryReturn(NID_UI_CTRL, __pHeaderFooterItemText != null, r, r, "[%s] Propagating.", GetErrorMessage(r));
3807
3808                 if (isHeader)
3809                 {
3810                         positionY = GetBoundsF().height - contentsHeight;
3811                 }
3812                 __pHeaderFooterItemText->Construct(FloatRectangle(0.0f, positionY, GetBoundsF().width, contentsHeight), text);
3813                 __pHeaderFooterItemText->SetTextHorizontalAlignment(alignment);
3814                 __pHeaderFooterItemText->SetTextColor(textColor);
3815                 __pHeaderFooterItemText->SetBackgroundColor(Color(0, 0, 0, 0));
3816
3817                 _Label* pHeaderFooterItemTextCore = GetLabelCore(__pHeaderFooterItemText);
3818                 pHeaderFooterItemTextCore->SetFocusable(false);
3819                 AttachChild(*pHeaderFooterItemTextCore);
3820         }
3821
3822         return E_SUCCESS;
3823 }
3824
3825 result
3826 _TableViewItem::SetSectionHeaderFooterAlignment(HorizontalAlignment alignment)
3827 {
3828         if (__pHeaderFooterItemText != null)
3829         {
3830                 __pHeaderFooterItemText->SetTextHorizontalAlignment(alignment);
3831                 __pHeaderFooterItemText->Invalidate(false);
3832         }
3833
3834         return E_SUCCESS;
3835 }
3836
3837 float
3838 _TableViewItem::GetAnnexWidth(TableViewAnnexStyle style)
3839 {
3840         float annexWidth = 0.0f;
3841         float annexDividerWidth = 0.0f;
3842
3843         switch (style)
3844         {
3845         case TABLE_VIEW_ANNEX_STYLE_NORMAL:
3846                 annexWidth = 0.0f;
3847                 break;
3848
3849         case TABLE_VIEW_ANNEX_STYLE_MARK:
3850                 GET_SHAPE_CONFIG(TABLEVIEW::ITEM_ANNEX_WIDTH, _CONTROL_ORIENTATION_PORTRAIT, annexWidth);
3851                 break;
3852
3853         case TABLE_VIEW_ANNEX_STYLE_ONOFF_SLIDING:
3854                 GET_SHAPE_CONFIG(TABLEVIEW::ITEM_ANNEX_ONOFF_WIDTH, _CONTROL_ORIENTATION_PORTRAIT, annexWidth);
3855                 break;
3856
3857         case TABLE_VIEW_ANNEX_STYLE_ONOFF_SLIDING_WITH_DIVIDER:
3858                 GET_SHAPE_CONFIG(TABLEVIEW::ITEM_ANNEX_MARGIN, _CONTROL_ORIENTATION_PORTRAIT, annexDividerWidth);
3859                 GET_FIXED_VALUE_CONFIG(TABLEVIEW::ITEM_ANNEX_DIVIDER_WIDTH, _CONTROL_ORIENTATION_PORTRAIT, annexDividerWidth);
3860                 GET_SHAPE_CONFIG(TABLEVIEW::ITEM_ANNEX_ONOFF_WIDTH, _CONTROL_ORIENTATION_PORTRAIT, annexWidth);
3861                 annexWidth = annexWidth + (annexDividerWidth*2) + annexDividerWidth;
3862                 break;
3863
3864         case TABLE_VIEW_ANNEX_STYLE_DETAILED:
3865                 GET_SHAPE_CONFIG(TABLEVIEW::ITEM_ANNEX_MORE_WIDTH, _CONTROL_ORIENTATION_PORTRAIT, annexWidth);
3866                 break;
3867
3868         case TABLE_VIEW_ANNEX_STYLE_RADIO:
3869                 GET_SHAPE_CONFIG(TABLEVIEW::ITEM_ANNEX_WIDTH, _CONTROL_ORIENTATION_PORTRAIT, annexWidth);
3870                 break;
3871
3872         default:
3873                 break;
3874         }
3875
3876         return annexWidth;
3877 }
3878
3879 void
3880 _TableViewItem::SetDrawingStatus(TableViewItemDrawingStatus status)
3881 {
3882         __drawingStatus = status;
3883 }
3884
3885 TableViewItemDrawingStatus
3886 _TableViewItem::GetDrawingStatus(void)
3887 {
3888         return __drawingStatus;
3889 }
3890
3891 void
3892 _TableViewItem::SetPressedControl(TableViewItemPressedControl pressedControl)
3893 {
3894         __pressedControl = pressedControl;
3895
3896         if (__pressedControl == TABLE_VIEW_ITEM_PRESSED_ITEM)
3897         {
3898                 __drawingStatus = TABLE_VIEW_ITEM_DRAWING_STATUS_PRESSED;
3899         }
3900         else if (__pressedControl == TABLE_VIEW_ITEM_PRESSED_ANNEX)
3901         {
3902                 if (__annexStyle == TABLE_VIEW_ANNEX_STYLE_DETAILED)
3903                 {
3904                         __isSelectedDetailButton = true;
3905                         __drawingStatus = TABLE_VIEW_ITEM_DRAWING_STATUS_NORMAL;
3906                 }
3907                 else if (__annexStyle == TABLE_VIEW_ANNEX_STYLE_ONOFF_SLIDING ||
3908                         __annexStyle == TABLE_VIEW_ANNEX_STYLE_ONOFF_SLIDING_WITH_DIVIDER)
3909                 {
3910                         __drawingStatus = TABLE_VIEW_ITEM_DRAWING_STATUS_NORMAL;
3911                 }
3912                 else
3913                 {
3914                         __drawingStatus = TABLE_VIEW_ITEM_DRAWING_STATUS_PRESSED;
3915                 }
3916         }
3917         else
3918         {
3919                 if (__pressedControl != TABLE_VIEW_ITEM_PRESSED_INDIVIDUAL)
3920                 {
3921                         __drawingStatus = TABLE_VIEW_ITEM_DRAWING_STATUS_PRESSED;
3922                 }
3923         }
3924 }
3925
3926 TableViewItemPressedControl
3927 _TableViewItem::GetPressedControl(void)
3928 {
3929         return __pressedControl;
3930 }
3931
3932 void
3933 _TableViewItem::AdjustChildControlMargin(void)
3934 {
3935         if (__childMarginState)
3936         {
3937                 return;
3938         }
3939
3940         if (IsTitleStyleItem())
3941         {
3942                 return;
3943         }
3944
3945         __childMarginState = true;
3946
3947         float margin = 0;
3948
3949         if (__pDrawingProperty->groupedLookEnabled)
3950         {
3951                 float groupedBarMargin = 0.0f;
3952                 GET_SHAPE_CONFIG(TABLEVIEW::GROUPITEM_BAR_WIDTH, _CONTROL_ORIENTATION_PORTRAIT, groupedBarMargin);
3953
3954                 margin = margin + groupedBarMargin;
3955         }
3956
3957         if (margin > 0)
3958         {
3959                 _VisualElement* pVisualElement = GetVisualElement();
3960
3961                 if (pVisualElement != null)
3962                 {
3963                         FloatPoint position;
3964
3965                         position.SetPosition(margin, 0.0f);
3966                         pVisualElement->ScrollByPoint(position, false);
3967                 }
3968         }
3969 }
3970
3971 void
3972 _TableViewItem::AdjustContextItemBounds(void)
3973 {
3974         _TableViewItem* pContextItem = GetContextItem();
3975
3976         if (pContextItem == null)
3977         {
3978                 return;
3979         }
3980
3981         FloatDimension contextItemSize = pContextItem->GetSizeF();
3982         FloatDimension itemSize = GetSizeF();
3983
3984         if (!_FloatCompare(contextItemSize.height, itemSize.height))
3985         {
3986                 contextItemSize.height = itemSize.height;
3987
3988                 pContextItem->SetSize(contextItemSize);
3989         }
3990
3991         pContextItem->AdjustChildControlCenterAlign();
3992 }
3993
3994 void
3995 _TableViewItem::AdjustAnnexBounds(void)
3996 {
3997         if (__pItemAnnex == null || __isMoveItemAnimationEnabled || __isZoomInOutItemAnimationEnabled ||__isFadeInOutItemAnimationEnabled)
3998         {
3999                 return;
4000         }
4001
4002         // h align
4003         if (__annexStyle == TABLE_VIEW_ANNEX_STYLE_ONOFF_SLIDING || __annexStyle == TABLE_VIEW_ANNEX_STYLE_ONOFF_SLIDING_WITH_DIVIDER || __annexStyle == TABLE_VIEW_ANNEX_STYLE_DETAILED)
4004         {
4005                 _Label* pAnnexCore = GetLabelCore(__pItemAnnex);
4006                 if (pAnnexCore->HasParent())
4007                 {
4008                         FloatRectangle annexBounds = __pItemAnnex->GetBoundsF();
4009                         float annexPositionX = annexBounds.x;
4010                         float leftMargin = 0.0f;
4011
4012                         GET_SHAPE_CONFIG(TABLEVIEW::ITEM_LEFT_MARGIN, _CONTROL_ORIENTATION_PORTRAIT, leftMargin);
4013                         leftMargin += __pDrawingProperty->scrollMargin;
4014
4015                         annexPositionX = GetBoundsF().width - annexBounds.width - leftMargin;
4016
4017                         if (!_FloatCompare(annexPositionX, annexBounds.x))
4018                         {
4019                                 __pItemAnnex->SetPosition(FloatPoint(annexPositionX, annexBounds.y));
4020
4021                                 if (__pAccessibilityOnOffElement != null)
4022                                 {
4023                                         __pAccessibilityOnOffElement->SetBounds(__pItemAnnex->GetBoundsF());
4024                                 }
4025                         }
4026                 }
4027         }
4028
4029         // v align
4030         FloatRectangle itemBounds = GetBoundsF();
4031         FloatRectangle annexBounds = __pItemAnnex->GetBoundsF();
4032
4033         if (__customHeight > 0)
4034         {
4035                 itemBounds.height = __customHeight;
4036         }
4037
4038         annexBounds.y = (itemBounds.height - annexBounds.height) / 2;
4039         __pItemAnnex->SetPosition(FloatPoint(annexBounds.x, annexBounds.y));
4040         if (__pAccessibilityOnOffElement != null)
4041         {
4042                 __pAccessibilityOnOffElement->SetBounds(__pItemAnnex->GetBoundsF());
4043         }
4044 }
4045
4046 void
4047 _TableViewItem::SetItemCustomHeight(float height)
4048 {
4049         __customHeight = height;
4050 }
4051
4052 float
4053 _TableViewItem::GetItemCustomHeight(void)
4054 {
4055         return __customHeight;
4056 }
4057
4058 void
4059 _TableViewItem::AdjustChildControlCenterAlign(void)
4060 {
4061         if (__childControlCenterAlign)
4062         {
4063                 FloatDimension itemSize = GetSizeF();
4064
4065                 int childControlCount = GetChildCount();
4066
4067                 for (int i = 0; i < childControlCount; i++)
4068                 {
4069                         _Control* pChildControl = GetChild(i);
4070
4071                         if (pChildControl == null)
4072                         {
4073                                 continue;
4074                         }
4075
4076                         if (__pItemDivider == pChildControl)
4077                         {
4078                                 float positionX = pChildControl->GetPositionF().x;
4079                                 pChildControl->SetPosition(FloatPoint(positionX, itemSize.height - 1));
4080                                 continue;
4081                         }
4082
4083                         if (__pItemTopDivider == pChildControl)
4084                         {
4085                                 float positionX = pChildControl->GetPositionF().x;
4086                                 pChildControl->SetPosition(FloatPoint(positionX, 0));
4087                                 continue;
4088                         }
4089
4090                         FloatRectangle itemBounds = pChildControl->GetBoundsF();
4091
4092                         itemBounds.y = (itemSize.height - itemBounds.height) / 2;
4093
4094                         pChildControl->SetPosition(FloatPoint(itemBounds.x, itemBounds.y));
4095                 }
4096         }
4097 }
4098
4099 void
4100 _TableViewItem::SetChildControlCenterAlign(bool centerAlign)
4101 {
4102         __childControlCenterAlign = centerAlign;
4103 }
4104
4105 Point
4106 _TableViewItem::GetLastTouchPressedPosition(void)
4107 {
4108         return _CoordinateSystemUtils::ConvertToInteger(__touchStartPosition);
4109 }
4110
4111 FloatPoint
4112 _TableViewItem::GetLastTouchPressedPositionF(void)
4113 {
4114         return __touchStartPosition;
4115 }
4116
4117 void
4118 _TableViewItem::SetLastTouchPressedPosition(FloatPoint position)
4119 {
4120         // This function was made to modify of ListView::RefreshList().
4121         // This function could adversely affect touch event handling. So, you should be used with caution.
4122         __touchStartPosition = position;
4123 }
4124
4125 void
4126 _TableViewItem::SetLastTouchPressedPosition(Point position)
4127 {
4128         // This function was made to modify of ListView::RefreshList().
4129         // This function could adversely affect touch event handling. So, you should be used with caution.
4130         __touchStartPosition = _CoordinateSystemUtils::ConvertToFloat(position);
4131 }
4132
4133 bool
4134 _TableViewItem::GetSelectionState(void)
4135 {
4136         return __itemSelected;
4137 }
4138
4139 void
4140 _TableViewItem::SetSelectionState(bool selected)
4141 {
4142         // This function was made to modify of ListView::RefreshList().
4143         // This function could adversely affect touch event handling. So, you should be used with caution.
4144         __itemSelected = selected;
4145 }
4146
4147 bool
4148 _TableViewItem::MoveItem(FloatPoint position, int duration, int delay)
4149 {
4150         _VisualElement* pVisualElement = GetVisualElement();
4151         VisualElementValueAnimation* pAnimation = null;
4152         String animationName = L"MOVE_ITEM";
4153         FloatPoint itemPosition = GetPositionF();
4154         result r = E_SUCCESS;
4155
4156         if (position == itemPosition)
4157         {
4158                 return false;
4159         }
4160
4161         if (__pMoveItemAnimation == null)
4162         {
4163                 __pMoveItemAnimation = new (std::nothrow) VisualElementValueAnimation;
4164                 SysTryCatch(NID_UI_CTRL, __pMoveItemAnimation != null, , E_OUT_OF_MEMORY, "[%s] Memory allocation failed.", GetErrorMessage(E_OUT_OF_MEMORY));
4165
4166                 __pMoveItemAnimation->SetVisualElementAnimationTickEventListener(this);
4167                 r = GetLastResult();
4168                 SysTryCatch(NID_UI_CTRL, r == E_SUCCESS, , r, "[%s] Propagating.", GetErrorMessage(r));
4169
4170                 __pMoveItemAnimation->SetVisualElementAnimationStatusEventListener(this);
4171                 r = GetLastResult();
4172                 SysTryCatch(NID_UI_CTRL, r == E_SUCCESS, , r, "[%s] Propagating.", GetErrorMessage(r));
4173         }
4174
4175         pAnimation = __pMoveItemAnimation;
4176
4177         pAnimation->SetTimingFunction(VisualElementAnimation::GetTimingFunctionByName("EaseInOut"));
4178         pAnimation->SetDuration(duration);
4179         pAnimation->SetDelay(delay);
4180         pAnimation->SetStartValue(Variant(GetPositionF()));
4181         pAnimation->SetEndValue(Variant(position));
4182
4183         if (pVisualElement->AddAnimation(animationName, *pAnimation) != E_SUCCESS)
4184         {
4185                 return false;
4186         }
4187
4188         __animationCount++;
4189
4190         return true;
4191
4192 CATCH:
4193
4194         delete __pMoveItemAnimation;
4195         __pMoveItemAnimation = null;
4196
4197         return false;
4198 }
4199
4200 bool
4201 _TableViewItem::ZoomInOutItem(bool zoomOut, int duration, int delay)
4202 {
4203         _VisualElement* pVisualElement = GetVisualElement();
4204         VisualElementValueAnimation* pAnimation = null;
4205         String animationName = L"ZOOM_IN_OUT_ITEM";
4206         FloatDimension itemSize = GetSizeF();
4207         FloatDimension startValue;
4208         FloatDimension endValue;
4209         result r = E_SUCCESS;
4210
4211         if (__pZoomInOutItemAnimation == null)
4212         {
4213                 __pZoomInOutItemAnimation = new (std::nothrow) VisualElementValueAnimation;
4214                 SysTryCatch(NID_UI_CTRL, __pZoomInOutItemAnimation != null, , E_OUT_OF_MEMORY, "[%s] Memory allocation failed.", GetErrorMessage(E_OUT_OF_MEMORY));
4215
4216                 __pZoomInOutItemAnimation->SetVisualElementAnimationTickEventListener(this);
4217                 r = GetLastResult();
4218                 SysTryCatch(NID_UI_CTRL, r == E_SUCCESS, , r, "[%s] Propagating.", GetErrorMessage(r));
4219
4220                 __pZoomInOutItemAnimation->SetVisualElementAnimationStatusEventListener(this);
4221                 r = GetLastResult();
4222                 SysTryCatch(NID_UI_CTRL, r == E_SUCCESS, , r, "[%s] Propagating.", GetErrorMessage(r));
4223         }
4224
4225         pAnimation = __pZoomInOutItemAnimation;
4226
4227         if (zoomOut)
4228         {
4229                 startValue = itemSize;
4230                 endValue = FloatDimension(itemSize.width, itemSize.height / 2);
4231                 pAnimation->SetTimingFunction(VisualElementAnimation::GetTimingFunctionByName(L"EaseOut"));
4232         }
4233         else
4234         {
4235                 startValue = FloatDimension(itemSize.width, itemSize.height / 2);
4236                 endValue = itemSize;
4237                 pAnimation->SetTimingFunction(VisualElementAnimation::GetTimingFunctionByName(L"EaseIn"));
4238         }
4239
4240         pAnimation->SetDuration(duration);
4241         pAnimation->SetDelay(delay);
4242         pAnimation->SetStartValue(Variant(startValue));
4243         pAnimation->SetEndValue(Variant(endValue));
4244
4245         if (pVisualElement->AddAnimation(animationName, *pAnimation) != E_SUCCESS)
4246         {
4247                 return false;
4248         }
4249
4250         __animationCount++;
4251
4252         return true;
4253
4254 CATCH:
4255         delete __pZoomInOutItemAnimation;
4256         __pZoomInOutItemAnimation = null;
4257
4258         return false;
4259 }
4260
4261 bool
4262 _TableViewItem::FadeInOutItem(bool fadeOut, int duration, int delay)
4263 {
4264         _VisualElement* pVisualElement = GetVisualElement();
4265         VisualElementValueAnimation* pAnimation = null;
4266         String animationName = L"FADE_IN_OUT_ITEM";
4267         float startValue = 0.0f;
4268         float endValue = 1.0f;
4269         result r = E_SUCCESS;
4270
4271         if (__pFadeInOutItemtAnimation == null)
4272         {
4273                 __pFadeInOutItemtAnimation = new (std::nothrow) VisualElementValueAnimation;
4274                 SysTryCatch(NID_UI_CTRL, __pFadeInOutItemtAnimation != null, , E_OUT_OF_MEMORY, "[%s] Memory allocation failed.", GetErrorMessage(E_OUT_OF_MEMORY));
4275
4276                 __pFadeInOutItemtAnimation->SetVisualElementAnimationTickEventListener(this);
4277                 r = GetLastResult();
4278                 SysTryCatch(NID_UI_CTRL, r == E_SUCCESS, , r, "[%s] Propagating.", GetErrorMessage(r));
4279
4280                 __pFadeInOutItemtAnimation->SetVisualElementAnimationStatusEventListener(this);
4281                 r = GetLastResult();
4282                 SysTryCatch(NID_UI_CTRL, r == E_SUCCESS, , r, "[%s] Propagating.", GetErrorMessage(r));
4283         }
4284
4285         pAnimation = __pFadeInOutItemtAnimation;
4286
4287         if (fadeOut)
4288         {
4289                 startValue = 1.0f;
4290                 endValue = 0.0f;
4291                 pAnimation->SetTimingFunction(VisualElementAnimation::GetTimingFunctionByName(L"EaseOut"));
4292         }
4293         else
4294         {
4295                 pAnimation->SetTimingFunction(VisualElementAnimation::GetTimingFunctionByName(L"EaseIn"));
4296         }
4297
4298         pAnimation->SetTimingFunction(VisualElementAnimation::GetTimingFunctionByName("EaseIn"));
4299         pAnimation->SetDuration(duration);
4300         pAnimation->SetDelay(delay);
4301         pAnimation->SetStartValue(Variant(startValue));
4302         pAnimation->SetEndValue(Variant(endValue));
4303
4304         if (pVisualElement->AddAnimation(animationName, *pAnimation) != E_SUCCESS)
4305         {
4306                 return false;
4307         }
4308
4309         pVisualElement->SetOpacity(startValue);
4310
4311         __animationCount++;
4312
4313         return true;
4314
4315 CATCH:
4316
4317         delete __pFadeInOutItemtAnimation;
4318         __pFadeInOutItemtAnimation = null;
4319
4320         return false;
4321 }
4322
4323 result
4324 _TableViewItem::SetIndividualSelectionEnabled(const _Control& control, bool enable)
4325 {
4326         result r = E_SUCCESS;
4327         if (enable)
4328         {
4329                 if (!__individualSelectionControls.Contains(control))
4330                 {
4331                         r =  __individualSelectionControls.Add(control);
4332                 }
4333
4334                 _AccessibilityContainer* pContainer = const_cast<_Control*>(&control)->GetAccessibilityContainer();
4335                 pContainer->Activate(true);
4336                 int controlCount = 0;
4337                 for (int i=0; i<GetChildCount(); i++)
4338                 {
4339                         _Control* pChildControl = GetChild(i);
4340                         if (pChildControl == static_cast<_Control*>(__pItemAnnexLeftDivider)
4341                                 || pChildControl == static_cast<_Control*>(__pItemAnnexRightDivider)
4342                                 || pChildControl == static_cast<_Control*>(__pItemCover)
4343                                 || pChildControl == static_cast<_Control*>(__pItemDivider)
4344                                 || pChildControl== static_cast<_Control*>(__pItemTopDivider))
4345                         {
4346                                 continue;
4347                         }
4348
4349                         controlCount++;
4350                 }
4351
4352                 if (controlCount == 0 || __individualSelectionControls.GetCount() == controlCount)
4353                 {
4354                         GetAccessibilityContainer()->Activate(false);
4355                 }
4356                 else
4357                 {
4358                         GetAccessibilityContainer()->Activate(true);
4359                 }
4360         }
4361         else
4362         {
4363                 if (__individualSelectionControls.Contains(control))
4364                 {
4365                         r = __individualSelectionControls.Remove(control, false);
4366                 }
4367         }
4368         return r;
4369 }
4370
4371 bool
4372 _TableViewItem::IsIndividualSelectionEnabled(const _Control& control)
4373 {
4374         return __individualSelectionControls.Contains(control);
4375 }
4376
4377 int
4378 _TableViewItem::AddRef(void)
4379 {
4380         return ++__refCount;
4381 }
4382
4383 int
4384 _TableViewItem::Release(void)
4385 {
4386         --__refCount;
4387         if (__refCount <= 0)
4388         {
4389                 delete this;
4390                 return 0;
4391         }
4392
4393         return __refCount;
4394 }
4395
4396 bool
4397 _TableViewItem::IsAnimationPlaying(void)
4398 {
4399         if (__animationCount > 0)
4400         {
4401                 return true;
4402         }
4403
4404         return false;
4405 }
4406
4407 void
4408 _TableViewItem::StopAllAnimation(void)
4409 {
4410         _VisualElement* pVisualElement = GetVisualElement();
4411
4412         pVisualElement->RemoveAllAnimations();
4413 }
4414
4415 void
4416 _TableViewItem::SetItemDividerEnabled(bool enable)
4417 {
4418         __itemDividerEnabled = enable;
4419 }
4420
4421 void
4422 _TableViewItem::OnTickOccurred(const Tizen::Ui::Animations::VisualElementAnimation& animation, const Tizen::Base::String& keyName, Tizen::Ui::Animations::VisualElement& target, const Tizen::Ui::Variant& currentValue)
4423 {
4424         if (keyName == L"MOVE_ITEM")
4425         {
4426                 FloatPoint position = currentValue.ToFloatPoint();
4427                 SetPosition(position);
4428         }
4429         else if (keyName == L"FADE_IN_OUT_ITEM")
4430         {
4431                 float opacity = currentValue.ToFloat();
4432
4433                 _VisualElement* pVisualElement = GetVisualElement();
4434
4435                 if (pVisualElement != null)
4436                 {
4437                         pVisualElement->SetOpacity(opacity);
4438                 }
4439         }
4440         else if (keyName == L"ZOOM_IN_OUT_ITEM")
4441         {
4442                 FloatDimension size = currentValue.ToFloatDimension();
4443                 SetSize(size);
4444         }
4445 }
4446
4447 void
4448 _TableViewItem::OnVisualElementAnimationStarted(const Tizen::Ui::Animations::VisualElementAnimation& animation, const Tizen::Base::String& keyName, Tizen::Ui::Animations::VisualElement& target)
4449 {
4450         if (keyName == L"MOVE_ITEM")
4451         {
4452                 __isMoveItemAnimationEnabled = true;
4453         }
4454         else if (keyName == L"FADE_IN_OUT_ITEM")
4455         {
4456                 __isFadeInOutItemAnimationEnabled = true;
4457         }
4458         else if (keyName == L"ZOOM_IN_OUT_ITEM")
4459         {
4460                 __isZoomInOutItemAnimationEnabled = true;
4461         }
4462 }
4463
4464 void
4465 _TableViewItem::OnVisualElementAnimationRepeated(const Tizen::Ui::Animations::VisualElementAnimation& animation, const Tizen::Base::String& keyName, Tizen::Ui::Animations::VisualElement& target, long currentRepeatCount)
4466 {
4467 }
4468
4469 void
4470 _TableViewItem::OnVisualElementAnimationFinished(const Tizen::Ui::Animations::VisualElementAnimation& animation, const Tizen::Base::String& keyName, Tizen::Ui::Animations::VisualElement& target, bool completedNormally)
4471 {
4472         if (__isAnimationCallbackBlocked)
4473         {
4474                 return;
4475         }
4476
4477         bool tableViewItemAnimation = true;
4478         const VisualElementValueAnimation *pAnimation = dynamic_cast<const VisualElementValueAnimation*>(&(animation));
4479
4480         if (keyName == L"MOVE_ITEM")
4481         {
4482                 if (pAnimation != null)
4483                 {
4484                         FloatPoint position = pAnimation->GetEndValue().ToFloatPoint();
4485
4486                         SetPosition(position);
4487                 }
4488                 __isMoveItemAnimationEnabled = false;
4489         }
4490         else if (keyName == L"FADE_IN_OUT_ITEM")
4491         {
4492                 if (pAnimation != null)
4493                 {
4494                         float opacity = pAnimation->GetEndValue().ToFloat();
4495
4496                         _VisualElement* pVisualElement = GetVisualElement();
4497
4498                         if (pVisualElement != null)
4499                         {
4500                                 pVisualElement->SetOpacity(opacity);
4501                                 Invalidate();
4502                         }
4503                 }
4504                 __isFadeInOutItemAnimationEnabled = false;
4505         }
4506         else if (keyName == L"ZOOM_IN_OUT_ITEM")
4507         {
4508                 if (pAnimation != null)
4509                 {
4510                         FloatDimension size = pAnimation->GetEndValue().ToFloatDimension();
4511
4512                         SetSize(size);
4513                 }
4514                 __isZoomInOutItemAnimationEnabled = false;
4515         }
4516         else
4517         {
4518                 tableViewItemAnimation = false;
4519         }
4520
4521         if (tableViewItemAnimation)
4522         {
4523                 __animationCount--;
4524         }
4525
4526         return;
4527 }
4528
4529 result
4530 _TableViewItem::OnAttachedToMainTree(void)
4531 {
4532         if (!_FloatCompare(GetBoundsF().height, 0.0f))
4533         {
4534                 SetAccessibilityElement();
4535         }
4536
4537         return E_SUCCESS;
4538 }
4539
4540 void
4541 _TableViewItem::SetAccessibilityElement(void)
4542 {
4543         _AccessibilityContainer* pContainer = GetAccessibilityContainer();
4544
4545         if (pContainer != null)
4546         {
4547                 if (__pAccessibilityElement == null)
4548                 {
4549                         __pAccessibilityElement = new (std::nothrow) _AccessibilityElement(true);
4550                         SysTryReturnVoidResult(NID_UI_CTRL, __pAccessibilityElement, E_OUT_OF_MEMORY, "[%s] Memory allocation failed.", GetErrorMessage(E_OUT_OF_MEMORY));
4551
4552                         __pAccessibilityElement->SetTrait(ACCESSIBILITY_TRAITS_NONE);
4553                         __pAccessibilityElement->SetName(L"TableViewItem");
4554
4555                         pContainer->AddElement(*__pAccessibilityElement);
4556                 }
4557                 __pAccessibilityElement->SetBounds(FloatRectangle(0.0f,0.0f, GetBoundsF().width, GetBoundsF().height));
4558
4559                 if (__pAccessibilityOnOffElement == null && __annexStyle == TABLE_VIEW_ANNEX_STYLE_ONOFF_SLIDING_WITH_DIVIDER)
4560                 {
4561                         __pAccessibilityOnOffElement = new (std::nothrow) _AccessibilityElement(true);
4562                         SysTryReturnVoidResult(NID_UI_CTRL, __pAccessibilityOnOffElement, E_OUT_OF_MEMORY, "[%s] Memory allocation failed.", GetErrorMessage(E_OUT_OF_MEMORY));
4563
4564                         __pAccessibilityOnOffElement->SetTraitWithStringId("IDS_TPLATFORM_BODY_ON_OFF_BUTTON_T_TTS");
4565                         __pAccessibilityOnOffElement->SetName(L"OnOffButton");
4566                         __pAccessibilityOnOffElement->SetHintWithStringId("IDS_TPLATFORM_BODY_DOUBLE_TAP_TO_MOVE_TO_CONTENT_T_TTS");
4567
4568                         pContainer->AddElement(*__pAccessibilityOnOffElement);
4569                         __pAccessibilityOnOffElement->SetBounds(FloatRectangle(0.0f, 0.0f, 0.0f, 0.0f));
4570                 }
4571         }
4572 }
4573
4574 _AccessibilityElement*
4575 _TableViewItem::GetAccessibilityElement(void)
4576 {
4577         return __pAccessibilityElement;
4578 }
4579 void
4580 _TableViewItem::SetAccessibilityElementTrait(void)
4581 {
4582         if (__pAccessibilityElement == null)
4583         {
4584                 return;
4585         }
4586         int groupIndex = -1;
4587         int itemIndex = -1;
4588
4589         switch (__annexStyle)
4590         {
4591         case TABLE_VIEW_ANNEX_STYLE_NORMAL:
4592                 GetItemIndex(groupIndex, itemIndex);
4593                 if (groupIndex != -1 && itemIndex == -1)
4594                 {
4595                         __pAccessibilityElement->SetTraitWithStringId("IDS_TPLATFORM_BODY_GROUP_INDEX");
4596                 }
4597                 break;
4598
4599         case TABLE_VIEW_ANNEX_STYLE_MARK:
4600                 __pAccessibilityElement->SetTraitWithStringId("IDS_TPLATFORM_BODY_TICKBOX_T_TTS");
4601                 break;
4602
4603         case TABLE_VIEW_ANNEX_STYLE_ONOFF_SLIDING:
4604                 __pAccessibilityElement->SetTraitWithStringId("IDS_TPLATFORM_BODY_ON_OFF_BUTTON_T_TTS");
4605                 break;
4606
4607         case TABLE_VIEW_ANNEX_STYLE_ONOFF_SLIDING_WITH_DIVIDER:
4608                 break;
4609
4610         case TABLE_VIEW_ANNEX_STYLE_DETAILED:
4611                 __pAccessibilityElement->SetTraitWithStringId("IDS_TPLATFORM_BODY_BUTTON_T_TTS");
4612                 break;
4613
4614         case TABLE_VIEW_ANNEX_STYLE_RADIO:
4615                 __pAccessibilityElement->SetTraitWithStringId("IDS_TPLATFORM_BODY_RADIO_BUTTON_T_TTS");
4616                 break;
4617
4618         default:
4619                 break;
4620         }
4621 }
4622 void
4623 _TableViewItem::SetAccessibilityElementValue(void)
4624 {
4625         if (__pAccessibilityElement == null)
4626         {
4627                 return;
4628         }
4629
4630         switch (__annexStyle)
4631         {
4632         case TABLE_VIEW_ANNEX_STYLE_MARK:
4633                 if (IsChecked())
4634                 {
4635                         __pAccessibilityElement->SetValueWithStringId("IDS_TPLATFORM_BODY_TICK_T_TTS");
4636                 }
4637                 else
4638                 {
4639                         __pAccessibilityElement->SetValueWithStringId("IDS_TPLATFORM_BODY_UNTICK_T_TTS");
4640                 }
4641                 break;
4642
4643         case TABLE_VIEW_ANNEX_STYLE_ONOFF_SLIDING:
4644                 if (IsChecked())
4645                 {
4646                         __pAccessibilityElement->SetValueWithStringId("IDS_TPLATFORM_BODY_ON");
4647                 }
4648                 else
4649                 {
4650                         __pAccessibilityElement->SetValueWithStringId("IDS_TPLATFORM_BODY_OFF");
4651                 }
4652                 break;
4653
4654         case TABLE_VIEW_ANNEX_STYLE_ONOFF_SLIDING_WITH_DIVIDER:
4655                 if (IsChecked())
4656                 {
4657                         if (__pAccessibilityOnOffElement != null)
4658                         {
4659                                 __pAccessibilityOnOffElement->SetValueWithStringId("IDS_TPLATFORM_BODY_ON");
4660                         }
4661                 }
4662                 else
4663                 {
4664                         if (__pAccessibilityOnOffElement != null)
4665                         {
4666                                 __pAccessibilityOnOffElement->SetValueWithStringId("IDS_TPLATFORM_BODY_OFF");
4667                         }
4668                 }
4669                 break;
4670
4671         case TABLE_VIEW_ANNEX_STYLE_RADIO:
4672                 if (IsChecked())
4673                 {
4674                         __pAccessibilityElement->SetValueWithStringId("IDS_TPLATFORM_BODY_SELECTED_T_TTS");
4675                 }
4676                 else
4677                 {
4678                         __pAccessibilityElement->SetValueWithStringId("IDS_TPLATFORM_BODY_NOT_SELECTED_T_TTS");
4679                 }
4680                 break;
4681
4682         default:
4683                 break;
4684         }
4685 }
4686 void
4687 _TableViewItem::SetAccessibilityElementLabel(void)
4688 {
4689         if (__pAccessibilityElement == null)
4690         {
4691                 return;
4692         }
4693
4694         if (__pAccessibilityElement->IsPublicLabelUpdated())
4695         {
4696                 return;
4697         }
4698
4699         String accessibilityLabel;
4700         String space = L" ";
4701         int childControlCount = GetChildCount();
4702
4703         for (int i = 0; i < childControlCount; i++)
4704         {
4705                 _Control* pChildControl = GetChild(i);
4706
4707                 if (pChildControl == null)
4708                 {
4709                         continue;
4710                 }
4711
4712                 if (__pItemDivider == pChildControl || __pItemTopDivider == pChildControl || __pItemCover == pChildControl)
4713                 {
4714                         continue;
4715                 }
4716
4717                 accessibilityLabel += GetChildAccessibilityLabelContent(*pChildControl);
4718                 accessibilityLabel += space;
4719         }
4720
4721         __pAccessibilityElement->SetLabel(accessibilityLabel);
4722 }
4723
4724
4725 bool
4726 _TableViewItem::OnAccessibilityFocusMovedNext(const _AccessibilityContainer& control, const _AccessibilityElement& element)
4727 {
4728         return false;
4729 }
4730
4731 bool
4732 _TableViewItem::OnAccessibilityFocusMovedPrevious(const _AccessibilityContainer& control, const _AccessibilityElement& element)
4733 {
4734         return false;
4735 }
4736
4737 bool
4738 _TableViewItem::OnAccessibilityReadElement(const _AccessibilityContainer& control, const _AccessibilityElement& element)
4739 {
4740         return false;
4741 }
4742
4743 bool
4744 _TableViewItem::OnAccessibilityReadingElement(const _AccessibilityContainer& control, const _AccessibilityElement& element)
4745 {
4746         SetAccessibilityElementLabel();
4747         SetAccessibilityElementTrait();
4748         SetAccessibilityElementValue();
4749         return false;
4750 }
4751
4752 bool
4753 _TableViewItem::OnAccessibilityFocusIn(const _AccessibilityContainer& control, const _AccessibilityElement& element)
4754 {
4755         return false;
4756 }
4757
4758 bool
4759 _TableViewItem::OnAccessibilityFocusOut(const _AccessibilityContainer& control, const _AccessibilityElement& element)
4760 {
4761         return false;
4762 }
4763
4764 bool
4765 _TableViewItem::OnAccessibilityActionPerformed(const _AccessibilityContainer& control, const _AccessibilityElement& element)
4766 {
4767         switch (__annexStyle)
4768         {
4769         case TABLE_VIEW_ANNEX_STYLE_NORMAL:
4770                 break;
4771
4772         case TABLE_VIEW_ANNEX_STYLE_MARK:
4773                 if (IsChecked())
4774                 {
4775                         String string;
4776                         GET_STRING_CONFIG(IDS_TPLATFORM_BODY_TICK_T_TTS,string);
4777                         _AccessibilityManager::GetInstance()->ReadContent(string);
4778                 }
4779                 else
4780                 {
4781                         String string;
4782                         GET_STRING_CONFIG(IDS_TPLATFORM_BODY_UNTICK_T_TTS,string);
4783                         _AccessibilityManager::GetInstance()->ReadContent(string);
4784                 }
4785                 break;
4786         case TABLE_VIEW_ANNEX_STYLE_ONOFF_SLIDING:
4787                 if (IsChecked())
4788                 {
4789                         String string;
4790                         GET_STRING_CONFIG(IDS_TPLATFORM_BODY_ON,string);
4791                         _AccessibilityManager::GetInstance()->ReadContent(string);
4792                 }
4793                 else
4794                 {
4795                         String string;
4796                         GET_STRING_CONFIG(IDS_TPLATFORM_BODY_OFF,string);
4797                         _AccessibilityManager::GetInstance()->ReadContent(string);
4798                 }
4799                 break;
4800
4801         case TABLE_VIEW_ANNEX_STYLE_ONOFF_SLIDING_WITH_DIVIDER:
4802                 if (&element == __pAccessibilityOnOffElement && IsEnabled())
4803                 {
4804                         if (IsChecked())
4805                         {
4806                                 SetChecked(false);
4807                                 String string;
4808                                 GET_STRING_CONFIG(IDS_TPLATFORM_BODY_OFF,string);
4809                                 _AccessibilityManager::GetInstance()->ReadContent(string);
4810                         }
4811                         else
4812                         {
4813                                 SetChecked(true);
4814                                 String string;
4815                                 GET_STRING_CONFIG(IDS_TPLATFORM_BODY_ON,string);
4816                                 _AccessibilityManager::GetInstance()->ReadContent(string);
4817                         }
4818                 }
4819                 break;
4820
4821         case TABLE_VIEW_ANNEX_STYLE_DETAILED:
4822                 break;
4823
4824         case TABLE_VIEW_ANNEX_STYLE_RADIO:
4825                 if (IsChecked())
4826                 {
4827                         String string;
4828                         GET_STRING_CONFIG(IDS_TPLATFORM_OPT_SELECT,string);
4829                         _AccessibilityManager::GetInstance()->ReadContent(string);
4830                 }
4831                 else
4832                 {
4833                         String string;
4834                         GET_STRING_CONFIG(IDS_TPLATFORM_BODY_NOT_SELECTED_T_TTS,string);
4835                         _AccessibilityManager::GetInstance()->ReadContent(string);
4836                 }
4837                 break;
4838         default:
4839                 break;
4840         }
4841
4842         return false;
4843 }
4844
4845 bool
4846 _TableViewItem::OnAccessibilityValueIncreased(const _AccessibilityContainer& control, const _AccessibilityElement& element)
4847 {
4848         return false;
4849 }
4850
4851 bool
4852 _TableViewItem::OnAccessibilityValueDecreased(const _AccessibilityContainer& control, const _AccessibilityElement& element)
4853 {
4854         return false;
4855 }
4856
4857 bool
4858 _TableViewItem::OnKeyPressed(const _Control& source, const _KeyInfo& keyInfo)
4859 {
4860         __isTouchCancelOnPressRelease = false;
4861
4862         if (!IsFocusModeStateEnabled())
4863         {
4864                 return false;
4865         }
4866
4867         _TableView* pParent = dynamic_cast<_TableView*>(GetParent());
4868         _KeyCode keyCode = keyInfo.GetKeyCode();
4869         IListT<_Control*>* pFocusList = GetFocusListN();
4870         SysTryReturn(NID_UI_CTRL, pFocusList != null, true, GetLastResult(), "[%s] propagating.", GetErrorMessage(GetLastResult()));
4871
4872         _Control* pChildControl = null;
4873         _Control* pFocusedControl = null;
4874         _Window* pTop = source.GetRootWindow();
4875
4876         if (pTop)
4877         {
4878                 pFocusedControl = pTop->GetCurrentFocusControl();
4879         }
4880
4881         int count  = pFocusList->GetCount();
4882
4883         if (pFocusedControl == null)
4884         {
4885                   return false;
4886         }
4887
4888         switch (keyCode)
4889         {
4890         case _KEY_LEFT:
4891                 if (!IsFocused())
4892                 {
4893                         for (int i=count-1; i>=0; i--)
4894                         {
4895                                 pFocusList->GetAt(i, pChildControl);
4896                                 if (pChildControl == null)
4897                                 {
4898                                         continue;
4899                                 }
4900
4901                                 if (pChildControl->IsFocused())
4902                                 {
4903                                         if (i == 0)
4904                                         {
4905                                                 pChildControl = null;
4906                                                 break;
4907                                         }
4908
4909                                         for (int j=i-1; j>=0; j--)
4910                                         {
4911                                                 pFocusList->GetAt(j, pChildControl);
4912                                                 if (pChildControl == null)
4913                                                 {
4914                                                         continue;
4915                                                 }
4916
4917                                                 if (pChildControl->IsFocusable() && pChildControl->GetEnableState()
4918                                                                 && pChildControl->GetVisibleState())
4919                                                 {
4920                                                         break;
4921                                                 }
4922                                                 else
4923                                                 {
4924                                                         pChildControl = null;
4925                                                 }
4926                                         }
4927                                         break;
4928                                 }
4929                         }
4930
4931                         if (pChildControl && pChildControl->GetEnableState()
4932                                         && pChildControl->GetVisibleState() && pChildControl->IsFocusable())
4933                         {
4934                                 if (pParent != null)
4935                                 {
4936                                         pParent->SetAnnexFocused(true);
4937                                 }
4938                                 pChildControl->SetFocused(true);
4939                                 pChildControl->DrawFocus();
4940                         }
4941                         else
4942                         {
4943                                 _Control* pParentControl = pFocusedControl->GetParent();
4944                                 _TableViewItem* pItem = dynamic_cast<_TableViewItem*>(pParentControl);
4945
4946                                 if (pItem != null && pItem->GetEnableState() && !pItem->IsFocused()
4947                                                 && pItem->GetVisibleState() && pItem->IsFocusable())
4948                                 {
4949                                         if (pParent != null)
4950                                         {
4951                                                 pParent->SetAnnexFocused(false);
4952                                         }
4953                                         pItem->SetFocused(true);
4954                                         pItem->DrawFocus();
4955                                 }
4956                         }
4957                 }
4958                 break;
4959
4960         case _KEY_RIGHT:
4961                 if (IsFocused())
4962                 {
4963                         if (pChildControl == null)
4964                         {
4965                                 for (int i=0; i<count; i++)
4966                                 {
4967                                         pFocusList->GetAt(i, pChildControl);
4968                                         if (pChildControl == null)
4969                                         {
4970                                                 continue;
4971                                         }
4972
4973                                         if (pChildControl->IsFocusable() && pChildControl->GetEnableState()
4974                                                         && pChildControl->GetVisibleState())
4975                                         {
4976                                                 break;
4977                                         }
4978                                         else
4979                                         {
4980                                                 pChildControl = null;
4981                                         }
4982                                 }
4983                         }
4984                 }
4985                 else
4986                 {
4987                         for (int i=0; i<count; i++)
4988                         {
4989                                 pFocusList->GetAt(i, pChildControl);
4990                                 if (pChildControl == null)
4991                                 {
4992                                         continue;
4993                                 }
4994
4995                                 if (pChildControl->IsFocused())
4996                                 {
4997                                         if (i == count -1)
4998                                         {
4999                                                 pChildControl = null;
5000                                                 break;
5001                                         }
5002
5003                                         for (int j=i+1; j<count; j++)
5004                                         {
5005                                                 pFocusList->GetAt(j, pChildControl);
5006                                                 if (pChildControl == null)
5007                                                 {
5008                                                         continue;
5009                                                 }
5010
5011                                                 if (pChildControl->IsFocusable() && pChildControl->GetEnableState()
5012                                                                 && pChildControl->GetVisibleState())
5013                                                 {
5014                                                         break;
5015                                                 }
5016                                                 else
5017                                                 {
5018                                                         pChildControl = null;
5019                                                 }
5020                                         }
5021                                         break;
5022                                 }
5023                         }
5024                 }
5025
5026                 if (pChildControl && pChildControl->GetEnableState() && pChildControl->GetVisibleState()
5027                                 && pChildControl->IsFocusable())
5028                 {
5029                         if (pParent != null)
5030                         {
5031                                 pParent->SetAnnexFocused(true);
5032                         }
5033                         pChildControl->SetFocused(true);
5034                         pChildControl->DrawFocus();
5035                 }
5036                 break;
5037
5038         case _KEY_ENTER:
5039                 if (&source == this)
5040                 {
5041                         __pressedControl = TABLE_VIEW_ITEM_PRESSED_ITEM;
5042                 }
5043                 else if (&source == GetLabelCore(__pItemAnnex))
5044                 {
5045                         __pressedControl = TABLE_VIEW_ITEM_PRESSED_ANNEX;
5046                 }
5047                 else if (IsIndividualSelectionEnabled(source))
5048                 {
5049                         __pressedControl = TABLE_VIEW_ITEM_PRESSED_INDIVIDUAL;
5050                 }
5051                 else
5052                 {
5053                         __pressedControl = TABLE_VIEW_ITEM_PRESSED_NONE;
5054                 }
5055                 __itemSelected = true;
5056                 FireItemTouchPressed();
5057                 break;
5058
5059         default:
5060                 if (__itemSelected)
5061                 {
5062                         __annexOnOffHandlerMoved = false;
5063                         __itemTouchMoved = false;
5064
5065                         __itemSelected = false;
5066                         __drawingStatus = TABLE_VIEW_ITEM_DRAWING_STATUS_NORMAL;
5067
5068                         if (__annexStyle == TABLE_VIEW_ANNEX_STYLE_DETAILED)
5069                         {
5070                                 __isSelectedDetailButton = false;
5071                         }
5072
5073                         SetItemChanged(true);
5074                         Invalidate();
5075                 }
5076                 return false;
5077         }
5078
5079         return true;
5080 }
5081
5082 bool
5083 _TableViewItem::OnKeyReleased(const _Control& source, const _KeyInfo& keyInfo)
5084 {
5085         if (!IsFocusModeStateEnabled())
5086         {
5087                 return false;
5088         }
5089
5090         _KeyCode keyCode = keyInfo.GetKeyCode();
5091
5092         if (keyCode == _KEY_ENTER)
5093         {
5094                 _TableView* pParent = dynamic_cast<_TableView*>(GetParent());
5095                 SysTryReturn(NID_UI_CTRL, pParent != null, true, GetLastResult(), "[%s] propagating.", GetErrorMessage(GetLastResult()));
5096
5097                 pParent->StopExpandCollapseAnimation();
5098                 if (&source == this)
5099                 {
5100                         __releasedControl = TABLE_VIEW_ITEM_PRESSED_ITEM;
5101                 }
5102                 else if (&source == GetLabelCore(__pItemAnnex))
5103                 {
5104                         __releasedControl = TABLE_VIEW_ITEM_PRESSED_ANNEX;
5105                 }
5106                 else if (IsIndividualSelectionEnabled(source))
5107                 {
5108                         __releasedControl = TABLE_VIEW_ITEM_PRESSED_INDIVIDUAL;
5109                 }
5110                 else
5111                 {
5112                         __releasedControl = TABLE_VIEW_ITEM_PRESSED_NONE;
5113                 }
5114                 FireItemTouchReleased();
5115                 return true;
5116         }
5117         else if (keyCode == _KEY_LEFT || keyCode == _KEY_RIGHT)
5118         {
5119                 return true;
5120         }
5121
5122         return false;
5123 }
5124
5125 void
5126 _TableViewItem::OnFocusModeStateChanged(void)
5127 {
5128         __releasedControl = TABLE_VIEW_ITEM_PRESSED_NONE;
5129
5130         ResetItemState();
5131 }
5132
5133 void
5134 _TableViewItem::ResetItemState(void)
5135 {
5136         __itemSelected = false;
5137         __drawingStatus = TABLE_VIEW_ITEM_DRAWING_STATUS_NORMAL;
5138
5139         if (__annexStyle == TABLE_VIEW_ANNEX_STYLE_DETAILED)
5140         {
5141                 __isSelectedDetailButton = false;
5142         }
5143
5144         SetItemChanged(true);
5145         Invalidate();
5146 }
5147
5148 _Control*
5149 _TableViewItem::GetPreviousFocusChildControl(const _Control& source)
5150 {
5151          _Control* pParentControl = null;
5152          float sourcePosition = 0.0f;
5153
5154          _Control* pSource = const_cast<_Control*>(&source);
5155          _TableViewItem* pItem = dynamic_cast<_TableViewItem*>(pSource);
5156          if (pItem != null)
5157          {
5158                  pParentControl = pSource;
5159                  sourcePosition = pParentControl->GetBoundsF().width;
5160          }
5161          else
5162          {
5163                  pParentControl = source.GetParent();
5164                  sourcePosition = source.GetBoundsF().x;
5165          }
5166
5167          if (pParentControl == null)
5168          {
5169                  return null;
5170          }
5171
5172          int childControlCount = pParentControl->GetChildCount();
5173          float position = 0.0f;
5174          _Control* destination = null;
5175
5176          for (int i=0; i<childControlCount; i++)
5177          {
5178                  _Control* pChildControl = pParentControl->GetChild(i);
5179                  if (pChildControl != null && pChildControl->IsFocusable())
5180                  {
5181                          float childPosition = pChildControl->GetBoundsF().x;
5182                          if (childPosition < sourcePosition)
5183                          {
5184                                  if (childPosition > position)
5185                                  {
5186                                          position = childPosition;
5187                                          destination = pChildControl;
5188                                  }
5189                                  else if (_FloatCompare(position, 0.0f))
5190                                  {
5191                                          position = childPosition;
5192                                          destination = pChildControl;
5193                                  }
5194                          }
5195                  }
5196          }
5197          return destination;
5198 }
5199
5200 _Control*
5201 _TableViewItem::GetNextFocusChildControl(const _Control& source)
5202 {
5203          _Control* pParentControl = null;
5204          float sourcePosition = 0.0f;
5205
5206          _Control* pSource = const_cast<_Control*>(&source);
5207          _TableViewItem* pItem = dynamic_cast<_TableViewItem*>(pSource);
5208          if (pItem != null)
5209          {
5210                  pParentControl = pSource;
5211                  sourcePosition = 0.0f;
5212          }
5213          else
5214          {
5215                  pParentControl = source.GetParent();
5216                  sourcePosition = source.GetBoundsF().x;
5217          }
5218
5219          if (pParentControl == null)
5220          {
5221                  return null;
5222          }
5223
5224          int childControlCount = pParentControl->GetChildCount();
5225          float position = 0.0f;
5226          _Control* destination = null;
5227
5228          for (int i=0; i<childControlCount; i++)
5229          {
5230                  _Control* pChildControl = pParentControl->GetChild(i);
5231                  if (pChildControl != null && pChildControl->IsFocusable())
5232                  {
5233                          float childPosition = pChildControl->GetBoundsF().x;
5234                          if (childPosition > sourcePosition)
5235                          {
5236                                  if (childPosition < position)
5237                                  {
5238                                          position = childPosition;
5239                                          destination = pChildControl;
5240                                  }
5241                                  else if (_FloatCompare(position, 0.0f))
5242                                  {
5243                                          position = childPosition;
5244                                          destination = pChildControl;
5245                                  }
5246                          }
5247                  }
5248          }
5249          return destination;
5250 }
5251
5252 bool
5253 _TableViewItem::IsChildControlFocusManage(void) const
5254 {
5255         return true;
5256 }
5257
5258 void
5259 _TableViewItem::SetSimpleLastItemEnabled(bool enable)
5260 {
5261         __isSimpleLastItem = enable;
5262 }
5263
5264 void
5265 _TableViewItem::SetSectionItem(bool isSectionItem)
5266 {
5267     __isSectionItem = isSectionItem;
5268 }
5269
5270 void
5271 _TableViewItem::SetTouchPressOnScroll(bool isTouch)
5272 {
5273         __isTouchPressOnScroll = isTouch;
5274 }
5275
5276 bool
5277 _TableViewItem::IsTouchPressOnScroll(void) const
5278 {
5279         return __isTouchPressOnScroll;
5280 }
5281
5282 void
5283 _TableViewItem::OnVisibleStateChanged(void)
5284 {
5285         if (IsFocused())
5286         {
5287                 RemoveFocusRing();
5288         }
5289 }
5290
5291 void
5292 _TableViewItem::OnAncestorEnableStateChanged(const _Control& control)
5293 {
5294         if (IsFocused())
5295         {
5296                 RemoveFocusRing();
5297         }
5298 }
5299
5300 void
5301 _TableViewItem::OnAncestorVisibleStateChanged(const _Control& control)
5302 {
5303         if (IsFocused())
5304         {
5305                 RemoveFocusRing();
5306         }
5307 }
5308
5309 void
5310 _TableViewItem::OnFocusableStateChanged(bool focusableState)
5311 {
5312         if (IsFocused() && !focusableState)
5313         {
5314                 RemoveFocusRing();
5315         }
5316 }
5317
5318 void
5319 _TableViewItem::SetPublicLabelUpdate(bool resetPublicLabelUpdate)
5320 {
5321         if (__pAccessibilityElement)
5322         {
5323                 __pAccessibilityElement->SetPublicLabelUpdate(resetPublicLabelUpdate);
5324         }
5325 }
5326
5327 String
5328 _TableViewItem::GetChildAccessibilityLabelContent(const _Control& source)
5329 {
5330         String accessibilityLabel = L"";
5331         String space = L" ";
5332
5333         if (IsIndividualSelectionEnabled(source))
5334         {
5335                 return accessibilityLabel;
5336         }
5337
5338         if (!source.IsVisible() || !source.GetEnableState())
5339         {
5340                 return accessibilityLabel;
5341         }
5342
5343         _Control* pSource = const_cast<_Control*>(&source);
5344
5345         if (pSource)
5346         {
5347                 _AccessibilityContainer* pContainer = pSource->GetAccessibilityContainer();
5348                 LinkedListT<_AccessibilityElement*> accessibilityElements;
5349                 _AccessibilityElement* pElement = null;
5350
5351                 if (pContainer)
5352                 {
5353                         pContainer->GetElements(accessibilityElements);
5354                         int elementCount = accessibilityElements.GetCount();
5355
5356                         for (int i = 0; i < elementCount; i++)
5357                         {
5358                                 if (accessibilityElements.GetAt(i, pElement) == E_SUCCESS)
5359                                 {
5360                                         accessibilityLabel += pElement->GetLabel();
5361                                         accessibilityLabel += space;
5362                                 }
5363                         }
5364                 }
5365         }
5366
5367         //check for children
5368         int childControlCount = source.GetChildCount();
5369
5370         for (int i = 0; i < childControlCount; i++)
5371         {
5372                 _Control* pChildControl = source.GetChild(i);
5373
5374                 if (pChildControl == null)
5375                 {
5376                         continue;
5377                 }
5378
5379                 accessibilityLabel += GetChildAccessibilityLabelContent(*pChildControl);
5380         }
5381
5382         return accessibilityLabel;
5383 }
5384
5385 void
5386 _TableViewItem::DeactivateChildAccessibilityContainer(const _Control& source)
5387 {
5388         _Control* pControl = const_cast<_Control*>(&source);
5389
5390         if (pControl)
5391         {
5392                 _AccessibilityContainer* pContainer = pControl->GetAccessibilityContainer();
5393
5394                 if (pContainer)
5395                 {
5396                         if (__individualSelectionControls.Contains(source))
5397                         {
5398                                 pContainer->Activate(true);
5399                         }
5400                         else
5401                         {
5402                                 pContainer->Activate(false);
5403                         }
5404                 }
5405         }
5406
5407         //check for children
5408         int childControlCount = source.GetChildCount();
5409
5410         for (int i = 0; i < childControlCount; i++)
5411         {
5412                 _Control* pChildControl = source.GetChild(i);
5413
5414                 if (pChildControl == null)
5415                 {
5416                         continue;
5417                 }
5418
5419                 DeactivateChildAccessibilityContainer(*pChildControl);
5420         }
5421 }
5422
5423 }}} // Tizen::Ui::Controls
5424