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
4014                         if (__pDrawingProperty != null)
4015                         {
4016                                 leftMargin += __pDrawingProperty->scrollMargin;
4017                         }
4018
4019                         annexPositionX = GetBoundsF().width - annexBounds.width - leftMargin;
4020                         if (__pDrawingProperty != null && __pDrawingProperty->groupedLookEnabled)
4021                         {
4022                                 float groupedBarMargin = 0.0f;
4023                                 GET_SHAPE_CONFIG(TABLEVIEW::GROUPITEM_BAR_WIDTH, _CONTROL_ORIENTATION_PORTRAIT, groupedBarMargin);
4024
4025                                 annexPositionX += groupedBarMargin;
4026                         }
4027
4028                         if (!_FloatCompare(annexPositionX, annexBounds.x))
4029                         {
4030                                 __pItemAnnex->SetPosition(FloatPoint(annexPositionX, annexBounds.y));
4031
4032                                 if (__pAccessibilityOnOffElement != null)
4033                                 {
4034                                         __pAccessibilityOnOffElement->SetBounds(__pItemAnnex->GetBoundsF());
4035                                 }
4036                         }
4037                 }
4038         }
4039
4040         // v align
4041         FloatRectangle itemBounds = GetBoundsF();
4042         FloatRectangle annexBounds = __pItemAnnex->GetBoundsF();
4043
4044         if (__customHeight > 0)
4045         {
4046                 itemBounds.height = __customHeight;
4047         }
4048
4049         annexBounds.y = (itemBounds.height - annexBounds.height) / 2;
4050         __pItemAnnex->SetPosition(FloatPoint(annexBounds.x, annexBounds.y));
4051         if (__pAccessibilityOnOffElement != null)
4052         {
4053                 __pAccessibilityOnOffElement->SetBounds(__pItemAnnex->GetBoundsF());
4054         }
4055 }
4056
4057 void
4058 _TableViewItem::SetItemCustomHeight(float height)
4059 {
4060         __customHeight = height;
4061 }
4062
4063 float
4064 _TableViewItem::GetItemCustomHeight(void)
4065 {
4066         return __customHeight;
4067 }
4068
4069 void
4070 _TableViewItem::AdjustChildControlCenterAlign(void)
4071 {
4072         if (__childControlCenterAlign)
4073         {
4074                 FloatDimension itemSize = GetSizeF();
4075
4076                 int childControlCount = GetChildCount();
4077
4078                 for (int i = 0; i < childControlCount; i++)
4079                 {
4080                         _Control* pChildControl = GetChild(i);
4081
4082                         if (pChildControl == null)
4083                         {
4084                                 continue;
4085                         }
4086
4087                         if (__pItemDivider == pChildControl)
4088                         {
4089                                 float positionX = pChildControl->GetPositionF().x;
4090                                 pChildControl->SetPosition(FloatPoint(positionX, itemSize.height - 1));
4091                                 continue;
4092                         }
4093
4094                         if (__pItemTopDivider == pChildControl)
4095                         {
4096                                 float positionX = pChildControl->GetPositionF().x;
4097                                 pChildControl->SetPosition(FloatPoint(positionX, 0));
4098                                 continue;
4099                         }
4100
4101                         FloatRectangle itemBounds = pChildControl->GetBoundsF();
4102
4103                         itemBounds.y = (itemSize.height - itemBounds.height) / 2;
4104
4105                         pChildControl->SetPosition(FloatPoint(itemBounds.x, itemBounds.y));
4106                 }
4107         }
4108 }
4109
4110 void
4111 _TableViewItem::SetChildControlCenterAlign(bool centerAlign)
4112 {
4113         __childControlCenterAlign = centerAlign;
4114 }
4115
4116 Point
4117 _TableViewItem::GetLastTouchPressedPosition(void)
4118 {
4119         return _CoordinateSystemUtils::ConvertToInteger(__touchStartPosition);
4120 }
4121
4122 FloatPoint
4123 _TableViewItem::GetLastTouchPressedPositionF(void)
4124 {
4125         return __touchStartPosition;
4126 }
4127
4128 void
4129 _TableViewItem::SetLastTouchPressedPosition(FloatPoint position)
4130 {
4131         // This function was made to modify of ListView::RefreshList().
4132         // This function could adversely affect touch event handling. So, you should be used with caution.
4133         __touchStartPosition = position;
4134 }
4135
4136 void
4137 _TableViewItem::SetLastTouchPressedPosition(Point position)
4138 {
4139         // This function was made to modify of ListView::RefreshList().
4140         // This function could adversely affect touch event handling. So, you should be used with caution.
4141         __touchStartPosition = _CoordinateSystemUtils::ConvertToFloat(position);
4142 }
4143
4144 bool
4145 _TableViewItem::GetSelectionState(void)
4146 {
4147         return __itemSelected;
4148 }
4149
4150 void
4151 _TableViewItem::SetSelectionState(bool selected)
4152 {
4153         // This function was made to modify of ListView::RefreshList().
4154         // This function could adversely affect touch event handling. So, you should be used with caution.
4155         __itemSelected = selected;
4156 }
4157
4158 bool
4159 _TableViewItem::MoveItem(FloatPoint position, int duration, int delay)
4160 {
4161         _VisualElement* pVisualElement = GetVisualElement();
4162         VisualElementValueAnimation* pAnimation = null;
4163         String animationName = L"MOVE_ITEM";
4164         FloatPoint itemPosition = GetPositionF();
4165         result r = E_SUCCESS;
4166
4167         if (position == itemPosition)
4168         {
4169                 return false;
4170         }
4171
4172         if (__pMoveItemAnimation == null)
4173         {
4174                 __pMoveItemAnimation = new (std::nothrow) VisualElementValueAnimation;
4175                 SysTryCatch(NID_UI_CTRL, __pMoveItemAnimation != null, , E_OUT_OF_MEMORY, "[%s] Memory allocation failed.", GetErrorMessage(E_OUT_OF_MEMORY));
4176
4177                 __pMoveItemAnimation->SetVisualElementAnimationTickEventListener(this);
4178                 r = GetLastResult();
4179                 SysTryCatch(NID_UI_CTRL, r == E_SUCCESS, , r, "[%s] Propagating.", GetErrorMessage(r));
4180
4181                 __pMoveItemAnimation->SetVisualElementAnimationStatusEventListener(this);
4182                 r = GetLastResult();
4183                 SysTryCatch(NID_UI_CTRL, r == E_SUCCESS, , r, "[%s] Propagating.", GetErrorMessage(r));
4184         }
4185
4186         pAnimation = __pMoveItemAnimation;
4187
4188         pAnimation->SetTimingFunction(VisualElementAnimation::GetTimingFunctionByName("EaseInOut"));
4189         pAnimation->SetDuration(duration);
4190         pAnimation->SetDelay(delay);
4191         pAnimation->SetStartValue(Variant(GetPositionF()));
4192         pAnimation->SetEndValue(Variant(position));
4193
4194         if (pVisualElement->AddAnimation(animationName, *pAnimation) != E_SUCCESS)
4195         {
4196                 return false;
4197         }
4198
4199         __animationCount++;
4200
4201         return true;
4202
4203 CATCH:
4204
4205         delete __pMoveItemAnimation;
4206         __pMoveItemAnimation = null;
4207
4208         return false;
4209 }
4210
4211 bool
4212 _TableViewItem::ZoomInOutItem(bool zoomOut, int duration, int delay)
4213 {
4214         _VisualElement* pVisualElement = GetVisualElement();
4215         VisualElementValueAnimation* pAnimation = null;
4216         String animationName = L"ZOOM_IN_OUT_ITEM";
4217         FloatDimension itemSize = GetSizeF();
4218         FloatDimension startValue;
4219         FloatDimension endValue;
4220         result r = E_SUCCESS;
4221
4222         if (__pZoomInOutItemAnimation == null)
4223         {
4224                 __pZoomInOutItemAnimation = new (std::nothrow) VisualElementValueAnimation;
4225                 SysTryCatch(NID_UI_CTRL, __pZoomInOutItemAnimation != null, , E_OUT_OF_MEMORY, "[%s] Memory allocation failed.", GetErrorMessage(E_OUT_OF_MEMORY));
4226
4227                 __pZoomInOutItemAnimation->SetVisualElementAnimationTickEventListener(this);
4228                 r = GetLastResult();
4229                 SysTryCatch(NID_UI_CTRL, r == E_SUCCESS, , r, "[%s] Propagating.", GetErrorMessage(r));
4230
4231                 __pZoomInOutItemAnimation->SetVisualElementAnimationStatusEventListener(this);
4232                 r = GetLastResult();
4233                 SysTryCatch(NID_UI_CTRL, r == E_SUCCESS, , r, "[%s] Propagating.", GetErrorMessage(r));
4234         }
4235
4236         pAnimation = __pZoomInOutItemAnimation;
4237
4238         if (zoomOut)
4239         {
4240                 startValue = itemSize;
4241                 endValue = FloatDimension(itemSize.width, itemSize.height / 2);
4242                 pAnimation->SetTimingFunction(VisualElementAnimation::GetTimingFunctionByName(L"EaseOut"));
4243         }
4244         else
4245         {
4246                 startValue = FloatDimension(itemSize.width, itemSize.height / 2);
4247                 endValue = itemSize;
4248                 pAnimation->SetTimingFunction(VisualElementAnimation::GetTimingFunctionByName(L"EaseIn"));
4249         }
4250
4251         pAnimation->SetDuration(duration);
4252         pAnimation->SetDelay(delay);
4253         pAnimation->SetStartValue(Variant(startValue));
4254         pAnimation->SetEndValue(Variant(endValue));
4255
4256         if (pVisualElement->AddAnimation(animationName, *pAnimation) != E_SUCCESS)
4257         {
4258                 return false;
4259         }
4260
4261         __animationCount++;
4262
4263         return true;
4264
4265 CATCH:
4266         delete __pZoomInOutItemAnimation;
4267         __pZoomInOutItemAnimation = null;
4268
4269         return false;
4270 }
4271
4272 bool
4273 _TableViewItem::FadeInOutItem(bool fadeOut, int duration, int delay)
4274 {
4275         _VisualElement* pVisualElement = GetVisualElement();
4276         VisualElementValueAnimation* pAnimation = null;
4277         String animationName = L"FADE_IN_OUT_ITEM";
4278         float startValue = 0.0f;
4279         float endValue = 1.0f;
4280         result r = E_SUCCESS;
4281
4282         if (__pFadeInOutItemtAnimation == null)
4283         {
4284                 __pFadeInOutItemtAnimation = new (std::nothrow) VisualElementValueAnimation;
4285                 SysTryCatch(NID_UI_CTRL, __pFadeInOutItemtAnimation != null, , E_OUT_OF_MEMORY, "[%s] Memory allocation failed.", GetErrorMessage(E_OUT_OF_MEMORY));
4286
4287                 __pFadeInOutItemtAnimation->SetVisualElementAnimationTickEventListener(this);
4288                 r = GetLastResult();
4289                 SysTryCatch(NID_UI_CTRL, r == E_SUCCESS, , r, "[%s] Propagating.", GetErrorMessage(r));
4290
4291                 __pFadeInOutItemtAnimation->SetVisualElementAnimationStatusEventListener(this);
4292                 r = GetLastResult();
4293                 SysTryCatch(NID_UI_CTRL, r == E_SUCCESS, , r, "[%s] Propagating.", GetErrorMessage(r));
4294         }
4295
4296         pAnimation = __pFadeInOutItemtAnimation;
4297
4298         if (fadeOut)
4299         {
4300                 startValue = 1.0f;
4301                 endValue = 0.0f;
4302                 pAnimation->SetTimingFunction(VisualElementAnimation::GetTimingFunctionByName(L"EaseOut"));
4303         }
4304         else
4305         {
4306                 pAnimation->SetTimingFunction(VisualElementAnimation::GetTimingFunctionByName(L"EaseIn"));
4307         }
4308
4309         pAnimation->SetTimingFunction(VisualElementAnimation::GetTimingFunctionByName("EaseIn"));
4310         pAnimation->SetDuration(duration);
4311         pAnimation->SetDelay(delay);
4312         pAnimation->SetStartValue(Variant(startValue));
4313         pAnimation->SetEndValue(Variant(endValue));
4314
4315         if (pVisualElement->AddAnimation(animationName, *pAnimation) != E_SUCCESS)
4316         {
4317                 return false;
4318         }
4319
4320         pVisualElement->SetOpacity(startValue);
4321
4322         __animationCount++;
4323
4324         return true;
4325
4326 CATCH:
4327
4328         delete __pFadeInOutItemtAnimation;
4329         __pFadeInOutItemtAnimation = null;
4330
4331         return false;
4332 }
4333
4334 result
4335 _TableViewItem::SetIndividualSelectionEnabled(const _Control& control, bool enable)
4336 {
4337         result r = E_SUCCESS;
4338         if (enable)
4339         {
4340                 if (!__individualSelectionControls.Contains(control))
4341                 {
4342                         r =  __individualSelectionControls.Add(control);
4343                 }
4344
4345                 _AccessibilityContainer* pContainer = const_cast<_Control*>(&control)->GetAccessibilityContainer();
4346                 pContainer->Activate(true);
4347                 int controlCount = 0;
4348                 for (int i=0; i<GetChildCount(); i++)
4349                 {
4350                         _Control* pChildControl = GetChild(i);
4351                         if (pChildControl == static_cast<_Control*>(__pItemAnnexLeftDivider)
4352                                 || pChildControl == static_cast<_Control*>(__pItemAnnexRightDivider)
4353                                 || pChildControl == static_cast<_Control*>(__pItemCover)
4354                                 || pChildControl == static_cast<_Control*>(__pItemDivider)
4355                                 || pChildControl== static_cast<_Control*>(__pItemTopDivider))
4356                         {
4357                                 continue;
4358                         }
4359
4360                         controlCount++;
4361                 }
4362
4363                 if (controlCount == 0 || __individualSelectionControls.GetCount() == controlCount)
4364                 {
4365                         GetAccessibilityContainer()->Activate(false);
4366                 }
4367                 else
4368                 {
4369                         GetAccessibilityContainer()->Activate(true);
4370                 }
4371         }
4372         else
4373         {
4374                 if (__individualSelectionControls.Contains(control))
4375                 {
4376                         r = __individualSelectionControls.Remove(control, false);
4377                 }
4378         }
4379         return r;
4380 }
4381
4382 bool
4383 _TableViewItem::IsIndividualSelectionEnabled(const _Control& control)
4384 {
4385         return __individualSelectionControls.Contains(control);
4386 }
4387
4388 int
4389 _TableViewItem::AddRef(void)
4390 {
4391         return ++__refCount;
4392 }
4393
4394 int
4395 _TableViewItem::Release(void)
4396 {
4397         --__refCount;
4398         if (__refCount <= 0)
4399         {
4400                 delete this;
4401                 return 0;
4402         }
4403
4404         return __refCount;
4405 }
4406
4407 bool
4408 _TableViewItem::IsAnimationPlaying(void)
4409 {
4410         if (__animationCount > 0)
4411         {
4412                 return true;
4413         }
4414
4415         return false;
4416 }
4417
4418 void
4419 _TableViewItem::StopAllAnimation(void)
4420 {
4421         _VisualElement* pVisualElement = GetVisualElement();
4422
4423         pVisualElement->RemoveAllAnimations();
4424 }
4425
4426 void
4427 _TableViewItem::SetItemDividerEnabled(bool enable)
4428 {
4429         __itemDividerEnabled = enable;
4430 }
4431
4432 void
4433 _TableViewItem::OnTickOccurred(const Tizen::Ui::Animations::VisualElementAnimation& animation, const Tizen::Base::String& keyName, Tizen::Ui::Animations::VisualElement& target, const Tizen::Ui::Variant& currentValue)
4434 {
4435         if (keyName == L"MOVE_ITEM")
4436         {
4437                 FloatPoint position = currentValue.ToFloatPoint();
4438                 SetPosition(position);
4439         }
4440         else if (keyName == L"FADE_IN_OUT_ITEM")
4441         {
4442                 float opacity = currentValue.ToFloat();
4443
4444                 _VisualElement* pVisualElement = GetVisualElement();
4445
4446                 if (pVisualElement != null)
4447                 {
4448                         pVisualElement->SetOpacity(opacity);
4449                 }
4450         }
4451         else if (keyName == L"ZOOM_IN_OUT_ITEM")
4452         {
4453                 FloatDimension size = currentValue.ToFloatDimension();
4454                 SetSize(size);
4455         }
4456 }
4457
4458 void
4459 _TableViewItem::OnVisualElementAnimationStarted(const Tizen::Ui::Animations::VisualElementAnimation& animation, const Tizen::Base::String& keyName, Tizen::Ui::Animations::VisualElement& target)
4460 {
4461         if (keyName == L"MOVE_ITEM")
4462         {
4463                 __isMoveItemAnimationEnabled = true;
4464         }
4465         else if (keyName == L"FADE_IN_OUT_ITEM")
4466         {
4467                 __isFadeInOutItemAnimationEnabled = true;
4468         }
4469         else if (keyName == L"ZOOM_IN_OUT_ITEM")
4470         {
4471                 __isZoomInOutItemAnimationEnabled = true;
4472         }
4473 }
4474
4475 void
4476 _TableViewItem::OnVisualElementAnimationRepeated(const Tizen::Ui::Animations::VisualElementAnimation& animation, const Tizen::Base::String& keyName, Tizen::Ui::Animations::VisualElement& target, long currentRepeatCount)
4477 {
4478 }
4479
4480 void
4481 _TableViewItem::OnVisualElementAnimationFinished(const Tizen::Ui::Animations::VisualElementAnimation& animation, const Tizen::Base::String& keyName, Tizen::Ui::Animations::VisualElement& target, bool completedNormally)
4482 {
4483         if (__isAnimationCallbackBlocked)
4484         {
4485                 return;
4486         }
4487
4488         bool tableViewItemAnimation = true;
4489         const VisualElementValueAnimation *pAnimation = dynamic_cast<const VisualElementValueAnimation*>(&(animation));
4490
4491         if (keyName == L"MOVE_ITEM")
4492         {
4493                 if (pAnimation != null)
4494                 {
4495                         FloatPoint position = pAnimation->GetEndValue().ToFloatPoint();
4496
4497                         SetPosition(position);
4498                 }
4499                 __isMoveItemAnimationEnabled = false;
4500         }
4501         else if (keyName == L"FADE_IN_OUT_ITEM")
4502         {
4503                 if (pAnimation != null)
4504                 {
4505                         float opacity = pAnimation->GetEndValue().ToFloat();
4506
4507                         _VisualElement* pVisualElement = GetVisualElement();
4508
4509                         if (pVisualElement != null)
4510                         {
4511                                 pVisualElement->SetOpacity(opacity);
4512                                 Invalidate();
4513                         }
4514                 }
4515                 __isFadeInOutItemAnimationEnabled = false;
4516         }
4517         else if (keyName == L"ZOOM_IN_OUT_ITEM")
4518         {
4519                 if (pAnimation != null)
4520                 {
4521                         FloatDimension size = pAnimation->GetEndValue().ToFloatDimension();
4522
4523                         SetSize(size);
4524                 }
4525                 __isZoomInOutItemAnimationEnabled = false;
4526         }
4527         else
4528         {
4529                 tableViewItemAnimation = false;
4530         }
4531
4532         if (tableViewItemAnimation)
4533         {
4534                 __animationCount--;
4535         }
4536
4537         return;
4538 }
4539
4540 result
4541 _TableViewItem::OnAttachedToMainTree(void)
4542 {
4543         if (!_FloatCompare(GetBoundsF().height, 0.0f))
4544         {
4545                 SetAccessibilityElement();
4546         }
4547
4548         return E_SUCCESS;
4549 }
4550
4551 void
4552 _TableViewItem::SetAccessibilityElement(void)
4553 {
4554         _AccessibilityContainer* pContainer = GetAccessibilityContainer();
4555
4556         if (pContainer != null)
4557         {
4558                 if (__pAccessibilityElement == null)
4559                 {
4560                         __pAccessibilityElement = new (std::nothrow) _AccessibilityElement(true);
4561                         SysTryReturnVoidResult(NID_UI_CTRL, __pAccessibilityElement, E_OUT_OF_MEMORY, "[%s] Memory allocation failed.", GetErrorMessage(E_OUT_OF_MEMORY));
4562
4563                         __pAccessibilityElement->SetTrait(ACCESSIBILITY_TRAITS_NONE);
4564                         __pAccessibilityElement->SetName(L"TableViewItem");
4565
4566                         pContainer->AddElement(*__pAccessibilityElement);
4567                 }
4568                 __pAccessibilityElement->SetBounds(FloatRectangle(0.0f,0.0f, GetBoundsF().width, GetBoundsF().height));
4569
4570                 if (__pAccessibilityOnOffElement == null && __annexStyle == TABLE_VIEW_ANNEX_STYLE_ONOFF_SLIDING_WITH_DIVIDER)
4571                 {
4572                         __pAccessibilityOnOffElement = new (std::nothrow) _AccessibilityElement(true);
4573                         SysTryReturnVoidResult(NID_UI_CTRL, __pAccessibilityOnOffElement, E_OUT_OF_MEMORY, "[%s] Memory allocation failed.", GetErrorMessage(E_OUT_OF_MEMORY));
4574
4575                         __pAccessibilityOnOffElement->SetTraitWithStringId("IDS_TPLATFORM_BODY_ON_OFF_BUTTON_T_TTS");
4576                         __pAccessibilityOnOffElement->SetName(L"OnOffButton");
4577                         __pAccessibilityOnOffElement->SetHintWithStringId("IDS_TPLATFORM_BODY_DOUBLE_TAP_TO_MOVE_TO_CONTENT_T_TTS");
4578
4579                         pContainer->AddElement(*__pAccessibilityOnOffElement);
4580                         __pAccessibilityOnOffElement->SetBounds(FloatRectangle(0.0f, 0.0f, 0.0f, 0.0f));
4581                 }
4582         }
4583 }
4584
4585 _AccessibilityElement*
4586 _TableViewItem::GetAccessibilityElement(void)
4587 {
4588         return __pAccessibilityElement;
4589 }
4590 void
4591 _TableViewItem::SetAccessibilityElementTrait(void)
4592 {
4593         if (__pAccessibilityElement == null)
4594         {
4595                 return;
4596         }
4597         int groupIndex = -1;
4598         int itemIndex = -1;
4599
4600         switch (__annexStyle)
4601         {
4602         case TABLE_VIEW_ANNEX_STYLE_NORMAL:
4603                 GetItemIndex(groupIndex, itemIndex);
4604                 if (groupIndex != -1 && itemIndex == -1)
4605                 {
4606                         __pAccessibilityElement->SetTraitWithStringId("IDS_TPLATFORM_BODY_GROUP_INDEX");
4607                 }
4608                 break;
4609
4610         case TABLE_VIEW_ANNEX_STYLE_MARK:
4611                 __pAccessibilityElement->SetTraitWithStringId("IDS_TPLATFORM_BODY_TICKBOX_T_TTS");
4612                 break;
4613
4614         case TABLE_VIEW_ANNEX_STYLE_ONOFF_SLIDING:
4615                 __pAccessibilityElement->SetTraitWithStringId("IDS_TPLATFORM_BODY_ON_OFF_BUTTON_T_TTS");
4616                 break;
4617
4618         case TABLE_VIEW_ANNEX_STYLE_ONOFF_SLIDING_WITH_DIVIDER:
4619                 break;
4620
4621         case TABLE_VIEW_ANNEX_STYLE_DETAILED:
4622                 __pAccessibilityElement->SetTraitWithStringId("IDS_TPLATFORM_BODY_BUTTON_T_TTS");
4623                 break;
4624
4625         case TABLE_VIEW_ANNEX_STYLE_RADIO:
4626                 __pAccessibilityElement->SetTraitWithStringId("IDS_TPLATFORM_BODY_RADIO_BUTTON_T_TTS");
4627                 break;
4628
4629         default:
4630                 break;
4631         }
4632 }
4633 void
4634 _TableViewItem::SetAccessibilityElementValue(void)
4635 {
4636         if (__pAccessibilityElement == null)
4637         {
4638                 return;
4639         }
4640
4641         switch (__annexStyle)
4642         {
4643         case TABLE_VIEW_ANNEX_STYLE_MARK:
4644                 if (IsChecked())
4645                 {
4646                         __pAccessibilityElement->SetValueWithStringId("IDS_TPLATFORM_BODY_TICK_T_TTS");
4647                 }
4648                 else
4649                 {
4650                         __pAccessibilityElement->SetValueWithStringId("IDS_TPLATFORM_BODY_UNTICK_T_TTS");
4651                 }
4652                 break;
4653
4654         case TABLE_VIEW_ANNEX_STYLE_ONOFF_SLIDING:
4655                 if (IsChecked())
4656                 {
4657                         __pAccessibilityElement->SetValueWithStringId("IDS_TPLATFORM_BODY_ON");
4658                 }
4659                 else
4660                 {
4661                         __pAccessibilityElement->SetValueWithStringId("IDS_TPLATFORM_BODY_OFF");
4662                 }
4663                 break;
4664
4665         case TABLE_VIEW_ANNEX_STYLE_ONOFF_SLIDING_WITH_DIVIDER:
4666                 if (IsChecked())
4667                 {
4668                         if (__pAccessibilityOnOffElement != null)
4669                         {
4670                                 __pAccessibilityOnOffElement->SetValueWithStringId("IDS_TPLATFORM_BODY_ON");
4671                         }
4672                 }
4673                 else
4674                 {
4675                         if (__pAccessibilityOnOffElement != null)
4676                         {
4677                                 __pAccessibilityOnOffElement->SetValueWithStringId("IDS_TPLATFORM_BODY_OFF");
4678                         }
4679                 }
4680                 break;
4681
4682         case TABLE_VIEW_ANNEX_STYLE_RADIO:
4683                 if (IsChecked())
4684                 {
4685                         __pAccessibilityElement->SetValueWithStringId("IDS_TPLATFORM_BODY_SELECTED_T_TTS");
4686                 }
4687                 else
4688                 {
4689                         __pAccessibilityElement->SetValueWithStringId("IDS_TPLATFORM_BODY_NOT_SELECTED_T_TTS");
4690                 }
4691                 break;
4692
4693         default:
4694                 break;
4695         }
4696 }
4697 void
4698 _TableViewItem::SetAccessibilityElementLabel(void)
4699 {
4700         if (__pAccessibilityElement == null)
4701         {
4702                 return;
4703         }
4704
4705         if (__pAccessibilityElement->IsPublicLabelUpdated())
4706         {
4707                 return;
4708         }
4709
4710         String accessibilityLabel;
4711         String space = L" ";
4712         int childControlCount = GetChildCount();
4713
4714         for (int i = 0; i < childControlCount; i++)
4715         {
4716                 _Control* pChildControl = GetChild(i);
4717
4718                 if (pChildControl == null)
4719                 {
4720                         continue;
4721                 }
4722
4723                 if (__pItemDivider == pChildControl || __pItemTopDivider == pChildControl || __pItemCover == pChildControl)
4724                 {
4725                         continue;
4726                 }
4727
4728                 accessibilityLabel += GetChildAccessibilityLabelContent(*pChildControl);
4729                 accessibilityLabel += space;
4730         }
4731
4732         __pAccessibilityElement->SetLabel(accessibilityLabel);
4733 }
4734
4735
4736 bool
4737 _TableViewItem::OnAccessibilityFocusMovedNext(const _AccessibilityContainer& control, const _AccessibilityElement& element)
4738 {
4739         return false;
4740 }
4741
4742 bool
4743 _TableViewItem::OnAccessibilityFocusMovedPrevious(const _AccessibilityContainer& control, const _AccessibilityElement& element)
4744 {
4745         return false;
4746 }
4747
4748 bool
4749 _TableViewItem::OnAccessibilityReadElement(const _AccessibilityContainer& control, const _AccessibilityElement& element)
4750 {
4751         return false;
4752 }
4753
4754 bool
4755 _TableViewItem::OnAccessibilityReadingElement(const _AccessibilityContainer& control, const _AccessibilityElement& element)
4756 {
4757         SetAccessibilityElementLabel();
4758         SetAccessibilityElementTrait();
4759         SetAccessibilityElementValue();
4760         return false;
4761 }
4762
4763 bool
4764 _TableViewItem::OnAccessibilityFocusIn(const _AccessibilityContainer& control, const _AccessibilityElement& element)
4765 {
4766         return false;
4767 }
4768
4769 bool
4770 _TableViewItem::OnAccessibilityFocusOut(const _AccessibilityContainer& control, const _AccessibilityElement& element)
4771 {
4772         return false;
4773 }
4774
4775 bool
4776 _TableViewItem::OnAccessibilityActionPerformed(const _AccessibilityContainer& control, const _AccessibilityElement& element)
4777 {
4778         switch (__annexStyle)
4779         {
4780         case TABLE_VIEW_ANNEX_STYLE_NORMAL:
4781                 break;
4782
4783         case TABLE_VIEW_ANNEX_STYLE_MARK:
4784                 if (IsChecked())
4785                 {
4786                         String string;
4787                         GET_STRING_CONFIG(IDS_TPLATFORM_BODY_TICK_T_TTS,string);
4788                         _AccessibilityManager::GetInstance()->ReadContent(string);
4789                 }
4790                 else
4791                 {
4792                         String string;
4793                         GET_STRING_CONFIG(IDS_TPLATFORM_BODY_UNTICK_T_TTS,string);
4794                         _AccessibilityManager::GetInstance()->ReadContent(string);
4795                 }
4796                 break;
4797         case TABLE_VIEW_ANNEX_STYLE_ONOFF_SLIDING:
4798                 if (IsChecked())
4799                 {
4800                         String string;
4801                         GET_STRING_CONFIG(IDS_TPLATFORM_BODY_ON,string);
4802                         _AccessibilityManager::GetInstance()->ReadContent(string);
4803                 }
4804                 else
4805                 {
4806                         String string;
4807                         GET_STRING_CONFIG(IDS_TPLATFORM_BODY_OFF,string);
4808                         _AccessibilityManager::GetInstance()->ReadContent(string);
4809                 }
4810                 break;
4811
4812         case TABLE_VIEW_ANNEX_STYLE_ONOFF_SLIDING_WITH_DIVIDER:
4813                 if (&element == __pAccessibilityOnOffElement && IsEnabled())
4814                 {
4815                         if (IsChecked())
4816                         {
4817                                 SetChecked(false);
4818                                 String string;
4819                                 GET_STRING_CONFIG(IDS_TPLATFORM_BODY_OFF,string);
4820                                 _AccessibilityManager::GetInstance()->ReadContent(string);
4821                         }
4822                         else
4823                         {
4824                                 SetChecked(true);
4825                                 String string;
4826                                 GET_STRING_CONFIG(IDS_TPLATFORM_BODY_ON,string);
4827                                 _AccessibilityManager::GetInstance()->ReadContent(string);
4828                         }
4829                 }
4830                 break;
4831
4832         case TABLE_VIEW_ANNEX_STYLE_DETAILED:
4833                 break;
4834
4835         case TABLE_VIEW_ANNEX_STYLE_RADIO:
4836                 if (IsChecked())
4837                 {
4838                         String string;
4839                         GET_STRING_CONFIG(IDS_TPLATFORM_OPT_SELECT,string);
4840                         _AccessibilityManager::GetInstance()->ReadContent(string);
4841                 }
4842                 else
4843                 {
4844                         String string;
4845                         GET_STRING_CONFIG(IDS_TPLATFORM_BODY_NOT_SELECTED_T_TTS,string);
4846                         _AccessibilityManager::GetInstance()->ReadContent(string);
4847                 }
4848                 break;
4849         default:
4850                 break;
4851         }
4852
4853         return false;
4854 }
4855
4856 bool
4857 _TableViewItem::OnAccessibilityValueIncreased(const _AccessibilityContainer& control, const _AccessibilityElement& element)
4858 {
4859         return false;
4860 }
4861
4862 bool
4863 _TableViewItem::OnAccessibilityValueDecreased(const _AccessibilityContainer& control, const _AccessibilityElement& element)
4864 {
4865         return false;
4866 }
4867
4868 bool
4869 _TableViewItem::OnKeyPressed(const _Control& source, const _KeyInfo& keyInfo)
4870 {
4871         __isTouchCancelOnPressRelease = false;
4872
4873         if (!IsFocusModeStateEnabled())
4874         {
4875                 return false;
4876         }
4877
4878         _TableView* pParent = dynamic_cast<_TableView*>(GetParent());
4879         _KeyCode keyCode = keyInfo.GetKeyCode();
4880         IListT<_Control*>* pFocusList = GetFocusListN();
4881         SysTryReturn(NID_UI_CTRL, pFocusList != null, true, GetLastResult(), "[%s] propagating.", GetErrorMessage(GetLastResult()));
4882
4883         _Control* pChildControl = null;
4884         _Control* pFocusedControl = null;
4885         _Window* pTop = source.GetRootWindow();
4886
4887         if (pTop)
4888         {
4889                 pFocusedControl = pTop->GetCurrentFocusControl();
4890         }
4891
4892         int count  = pFocusList->GetCount();
4893
4894         if (pFocusedControl == null)
4895         {
4896                   return false;
4897         }
4898
4899         switch (keyCode)
4900         {
4901         case _KEY_LEFT:
4902                 if (!IsFocused())
4903                 {
4904                         for (int i=count-1; i>=0; i--)
4905                         {
4906                                 pFocusList->GetAt(i, pChildControl);
4907                                 if (pChildControl == null)
4908                                 {
4909                                         continue;
4910                                 }
4911
4912                                 if (pChildControl->IsFocused())
4913                                 {
4914                                         if (i == 0)
4915                                         {
4916                                                 pChildControl = null;
4917                                                 break;
4918                                         }
4919
4920                                         for (int j=i-1; j>=0; j--)
4921                                         {
4922                                                 pFocusList->GetAt(j, pChildControl);
4923                                                 if (pChildControl == null)
4924                                                 {
4925                                                         continue;
4926                                                 }
4927
4928                                                 if (pChildControl->IsFocusable() && pChildControl->GetEnableState()
4929                                                                 && pChildControl->GetVisibleState())
4930                                                 {
4931                                                         break;
4932                                                 }
4933                                                 else
4934                                                 {
4935                                                         pChildControl = null;
4936                                                 }
4937                                         }
4938                                         break;
4939                                 }
4940                         }
4941
4942                         if (pChildControl && pChildControl->GetEnableState()
4943                                         && pChildControl->GetVisibleState() && pChildControl->IsFocusable())
4944                         {
4945                                 if (pParent != null)
4946                                 {
4947                                         pParent->SetAnnexFocused(true);
4948                                 }
4949                                 pChildControl->SetFocused(true);
4950                                 pChildControl->DrawFocus();
4951                         }
4952                         else
4953                         {
4954                                 _Control* pParentControl = pFocusedControl->GetParent();
4955                                 _TableViewItem* pItem = dynamic_cast<_TableViewItem*>(pParentControl);
4956
4957                                 if (pItem != null && pItem->GetEnableState() && !pItem->IsFocused()
4958                                                 && pItem->GetVisibleState() && pItem->IsFocusable())
4959                                 {
4960                                         if (pParent != null)
4961                                         {
4962                                                 pParent->SetAnnexFocused(false);
4963                                         }
4964                                         pItem->SetFocused(true);
4965                                         pItem->DrawFocus();
4966                                 }
4967                         }
4968                 }
4969                 break;
4970
4971         case _KEY_RIGHT:
4972                 if (IsFocused())
4973                 {
4974                         if (pChildControl == null)
4975                         {
4976                                 for (int i=0; i<count; i++)
4977                                 {
4978                                         pFocusList->GetAt(i, pChildControl);
4979                                         if (pChildControl == null)
4980                                         {
4981                                                 continue;
4982                                         }
4983
4984                                         if (pChildControl->IsFocusable() && pChildControl->GetEnableState()
4985                                                         && pChildControl->GetVisibleState())
4986                                         {
4987                                                 break;
4988                                         }
4989                                         else
4990                                         {
4991                                                 pChildControl = null;
4992                                         }
4993                                 }
4994                         }
4995                 }
4996                 else
4997                 {
4998                         for (int i=0; i<count; i++)
4999                         {
5000                                 pFocusList->GetAt(i, pChildControl);
5001                                 if (pChildControl == null)
5002                                 {
5003                                         continue;
5004                                 }
5005
5006                                 if (pChildControl->IsFocused())
5007                                 {
5008                                         if (i == count -1)
5009                                         {
5010                                                 pChildControl = null;
5011                                                 break;
5012                                         }
5013
5014                                         for (int j=i+1; j<count; j++)
5015                                         {
5016                                                 pFocusList->GetAt(j, pChildControl);
5017                                                 if (pChildControl == null)
5018                                                 {
5019                                                         continue;
5020                                                 }
5021
5022                                                 if (pChildControl->IsFocusable() && pChildControl->GetEnableState()
5023                                                                 && pChildControl->GetVisibleState())
5024                                                 {
5025                                                         break;
5026                                                 }
5027                                                 else
5028                                                 {
5029                                                         pChildControl = null;
5030                                                 }
5031                                         }
5032                                         break;
5033                                 }
5034                         }
5035                 }
5036
5037                 if (pChildControl && pChildControl->GetEnableState() && pChildControl->GetVisibleState()
5038                                 && pChildControl->IsFocusable())
5039                 {
5040                         if (pParent != null)
5041                         {
5042                                 pParent->SetAnnexFocused(true);
5043                         }
5044                         pChildControl->SetFocused(true);
5045                         pChildControl->DrawFocus();
5046                 }
5047                 break;
5048
5049         case _KEY_ENTER:
5050                 if (&source == this)
5051                 {
5052                         __pressedControl = TABLE_VIEW_ITEM_PRESSED_ITEM;
5053                 }
5054                 else if (&source == GetLabelCore(__pItemAnnex))
5055                 {
5056                         __pressedControl = TABLE_VIEW_ITEM_PRESSED_ANNEX;
5057                 }
5058                 else if (IsIndividualSelectionEnabled(source))
5059                 {
5060                         __pressedControl = TABLE_VIEW_ITEM_PRESSED_INDIVIDUAL;
5061                 }
5062                 else
5063                 {
5064                         __pressedControl = TABLE_VIEW_ITEM_PRESSED_NONE;
5065                 }
5066                 __itemSelected = true;
5067                 FireItemTouchPressed();
5068                 break;
5069
5070         default:
5071                 if (__itemSelected)
5072                 {
5073                         __annexOnOffHandlerMoved = false;
5074                         __itemTouchMoved = false;
5075
5076                         __itemSelected = false;
5077                         __drawingStatus = TABLE_VIEW_ITEM_DRAWING_STATUS_NORMAL;
5078
5079                         if (__annexStyle == TABLE_VIEW_ANNEX_STYLE_DETAILED)
5080                         {
5081                                 __isSelectedDetailButton = false;
5082                         }
5083
5084                         SetItemChanged(true);
5085                         Invalidate();
5086                 }
5087                 return false;
5088         }
5089
5090         return true;
5091 }
5092
5093 bool
5094 _TableViewItem::OnKeyReleased(const _Control& source, const _KeyInfo& keyInfo)
5095 {
5096         if (!IsFocusModeStateEnabled())
5097         {
5098                 return false;
5099         }
5100
5101         _KeyCode keyCode = keyInfo.GetKeyCode();
5102
5103         if (keyCode == _KEY_ENTER)
5104         {
5105                 _TableView* pParent = dynamic_cast<_TableView*>(GetParent());
5106                 SysTryReturn(NID_UI_CTRL, pParent != null, true, GetLastResult(), "[%s] propagating.", GetErrorMessage(GetLastResult()));
5107
5108                 pParent->StopExpandCollapseAnimation();
5109                 if (&source == this)
5110                 {
5111                         __releasedControl = TABLE_VIEW_ITEM_PRESSED_ITEM;
5112                 }
5113                 else if (&source == GetLabelCore(__pItemAnnex))
5114                 {
5115                         __releasedControl = TABLE_VIEW_ITEM_PRESSED_ANNEX;
5116                 }
5117                 else if (IsIndividualSelectionEnabled(source))
5118                 {
5119                         __releasedControl = TABLE_VIEW_ITEM_PRESSED_INDIVIDUAL;
5120                 }
5121                 else
5122                 {
5123                         __releasedControl = TABLE_VIEW_ITEM_PRESSED_NONE;
5124                 }
5125                 FireItemTouchReleased();
5126                 return true;
5127         }
5128         else if (keyCode == _KEY_LEFT || keyCode == _KEY_RIGHT)
5129         {
5130                 return true;
5131         }
5132
5133         return false;
5134 }
5135
5136 void
5137 _TableViewItem::OnFocusModeStateChanged(void)
5138 {
5139         __releasedControl = TABLE_VIEW_ITEM_PRESSED_NONE;
5140
5141         ResetItemState();
5142 }
5143
5144 void
5145 _TableViewItem::ResetItemState(void)
5146 {
5147         __itemSelected = false;
5148         __drawingStatus = TABLE_VIEW_ITEM_DRAWING_STATUS_NORMAL;
5149
5150         if (__annexStyle == TABLE_VIEW_ANNEX_STYLE_DETAILED)
5151         {
5152                 __isSelectedDetailButton = false;
5153         }
5154
5155         SetItemChanged(true);
5156         Invalidate();
5157 }
5158
5159 _Control*
5160 _TableViewItem::GetPreviousFocusChildControl(const _Control& source)
5161 {
5162          _Control* pParentControl = null;
5163          float sourcePosition = 0.0f;
5164
5165          _Control* pSource = const_cast<_Control*>(&source);
5166          _TableViewItem* pItem = dynamic_cast<_TableViewItem*>(pSource);
5167          if (pItem != null)
5168          {
5169                  pParentControl = pSource;
5170                  sourcePosition = pParentControl->GetBoundsF().width;
5171          }
5172          else
5173          {
5174                  pParentControl = source.GetParent();
5175                  sourcePosition = source.GetBoundsF().x;
5176          }
5177
5178          if (pParentControl == null)
5179          {
5180                  return null;
5181          }
5182
5183          int childControlCount = pParentControl->GetChildCount();
5184          float position = 0.0f;
5185          _Control* destination = null;
5186
5187          for (int i=0; i<childControlCount; i++)
5188          {
5189                  _Control* pChildControl = pParentControl->GetChild(i);
5190                  if (pChildControl != null && pChildControl->IsFocusable())
5191                  {
5192                          float childPosition = pChildControl->GetBoundsF().x;
5193                          if (childPosition < sourcePosition)
5194                          {
5195                                  if (childPosition > position)
5196                                  {
5197                                          position = childPosition;
5198                                          destination = pChildControl;
5199                                  }
5200                                  else if (_FloatCompare(position, 0.0f))
5201                                  {
5202                                          position = childPosition;
5203                                          destination = pChildControl;
5204                                  }
5205                          }
5206                  }
5207          }
5208          return destination;
5209 }
5210
5211 _Control*
5212 _TableViewItem::GetNextFocusChildControl(const _Control& source)
5213 {
5214          _Control* pParentControl = null;
5215          float sourcePosition = 0.0f;
5216
5217          _Control* pSource = const_cast<_Control*>(&source);
5218          _TableViewItem* pItem = dynamic_cast<_TableViewItem*>(pSource);
5219          if (pItem != null)
5220          {
5221                  pParentControl = pSource;
5222                  sourcePosition = 0.0f;
5223          }
5224          else
5225          {
5226                  pParentControl = source.GetParent();
5227                  sourcePosition = source.GetBoundsF().x;
5228          }
5229
5230          if (pParentControl == null)
5231          {
5232                  return null;
5233          }
5234
5235          int childControlCount = pParentControl->GetChildCount();
5236          float position = 0.0f;
5237          _Control* destination = null;
5238
5239          for (int i=0; i<childControlCount; i++)
5240          {
5241                  _Control* pChildControl = pParentControl->GetChild(i);
5242                  if (pChildControl != null && pChildControl->IsFocusable())
5243                  {
5244                          float childPosition = pChildControl->GetBoundsF().x;
5245                          if (childPosition > sourcePosition)
5246                          {
5247                                  if (childPosition < position)
5248                                  {
5249                                          position = childPosition;
5250                                          destination = pChildControl;
5251                                  }
5252                                  else if (_FloatCompare(position, 0.0f))
5253                                  {
5254                                          position = childPosition;
5255                                          destination = pChildControl;
5256                                  }
5257                          }
5258                  }
5259          }
5260          return destination;
5261 }
5262
5263 bool
5264 _TableViewItem::IsChildControlFocusManage(void) const
5265 {
5266         return true;
5267 }
5268
5269 void
5270 _TableViewItem::SetSimpleLastItemEnabled(bool enable)
5271 {
5272         __isSimpleLastItem = enable;
5273 }
5274
5275 void
5276 _TableViewItem::SetSectionItem(bool isSectionItem)
5277 {
5278     __isSectionItem = isSectionItem;
5279 }
5280
5281 void
5282 _TableViewItem::SetTouchPressOnScroll(bool isTouch)
5283 {
5284         __isTouchPressOnScroll = isTouch;
5285 }
5286
5287 bool
5288 _TableViewItem::IsTouchPressOnScroll(void) const
5289 {
5290         return __isTouchPressOnScroll;
5291 }
5292
5293 void
5294 _TableViewItem::OnVisibleStateChanged(void)
5295 {
5296         if (IsFocused())
5297         {
5298                 RemoveFocusRing();
5299         }
5300 }
5301
5302 void
5303 _TableViewItem::OnAncestorEnableStateChanged(const _Control& control)
5304 {
5305         if (IsFocused())
5306         {
5307                 RemoveFocusRing();
5308         }
5309 }
5310
5311 void
5312 _TableViewItem::OnAncestorVisibleStateChanged(const _Control& control)
5313 {
5314         if (IsFocused())
5315         {
5316                 RemoveFocusRing();
5317         }
5318 }
5319
5320 void
5321 _TableViewItem::OnFocusableStateChanged(bool focusableState)
5322 {
5323         if (IsFocused() && !focusableState)
5324         {
5325                 RemoveFocusRing();
5326         }
5327 }
5328
5329 void
5330 _TableViewItem::SetPublicLabelUpdate(bool resetPublicLabelUpdate)
5331 {
5332         if (__pAccessibilityElement)
5333         {
5334                 __pAccessibilityElement->SetPublicLabelUpdate(resetPublicLabelUpdate);
5335         }
5336 }
5337
5338 String
5339 _TableViewItem::GetChildAccessibilityLabelContent(const _Control& source)
5340 {
5341         String accessibilityLabel = L"";
5342         String space = L" ";
5343
5344         if (IsIndividualSelectionEnabled(source))
5345         {
5346                 return accessibilityLabel;
5347         }
5348
5349         if (!source.IsVisible() || !source.GetEnableState())
5350         {
5351                 return accessibilityLabel;
5352         }
5353
5354         _Control* pSource = const_cast<_Control*>(&source);
5355
5356         if (pSource)
5357         {
5358                 _AccessibilityContainer* pContainer = pSource->GetAccessibilityContainer();
5359                 LinkedListT<_AccessibilityElement*> accessibilityElements;
5360                 _AccessibilityElement* pElement = null;
5361
5362                 if (pContainer)
5363                 {
5364                         pContainer->GetElements(accessibilityElements);
5365                         int elementCount = accessibilityElements.GetCount();
5366
5367                         for (int i = 0; i < elementCount; i++)
5368                         {
5369                                 if (accessibilityElements.GetAt(i, pElement) == E_SUCCESS)
5370                                 {
5371                                         accessibilityLabel += pElement->GetLabel();
5372                                         accessibilityLabel += space;
5373                                 }
5374                         }
5375                 }
5376         }
5377
5378         //check for children
5379         int childControlCount = source.GetChildCount();
5380
5381         for (int i = 0; i < childControlCount; i++)
5382         {
5383                 _Control* pChildControl = source.GetChild(i);
5384
5385                 if (pChildControl == null)
5386                 {
5387                         continue;
5388                 }
5389
5390                 accessibilityLabel += GetChildAccessibilityLabelContent(*pChildControl);
5391         }
5392
5393         return accessibilityLabel;
5394 }
5395
5396 void
5397 _TableViewItem::DeactivateChildAccessibilityContainer(const _Control& source)
5398 {
5399         _Control* pControl = const_cast<_Control*>(&source);
5400
5401         if (pControl)
5402         {
5403                 _AccessibilityContainer* pContainer = pControl->GetAccessibilityContainer();
5404
5405                 if (pContainer)
5406                 {
5407                         if (__individualSelectionControls.Contains(source))
5408                         {
5409                                 pContainer->Activate(true);
5410                         }
5411                         else
5412                         {
5413                                 pContainer->Activate(false);
5414                         }
5415                 }
5416         }
5417
5418         //check for children
5419         int childControlCount = source.GetChildCount();
5420
5421         for (int i = 0; i < childControlCount; i++)
5422         {
5423                 _Control* pChildControl = source.GetChild(i);
5424
5425                 if (pChildControl == null)
5426                 {
5427                         continue;
5428                 }
5429
5430                 DeactivateChildAccessibilityContainer(*pChildControl);
5431         }
5432 }
5433
5434 }}} // Tizen::Ui::Controls
5435