src/ui/controls/FUiCtrl_ListViewItem.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_ListViewItem.cpp
  20  * @brief   This is the implementation file for _ListViewItem class.
  21  *
  22  * This file contains the implementation of _ListViewItem class.
  23  */
  24
  25 #include <FBaseSysLog.h>
  26 #include <FGrp_BitmapImpl.h>
  27 #include <FGrp_EnrichedTextImpl.h>
  28 #include <FGrp_TextElementImpl.h>
  29 #include <FGrp_TextTextCutLink.h>
  30 #include <FGrp_TextTextCutLinkParser.h>
  31 #include <FGrp_TextTextSimple.h>
  32 #include "FUi_AccessibilityContainer.h"
  33 #include "FUi_AccessibilityElement.h"
  34 #include "FUi_CoordinateSystemUtils.h"
  35 #include "FUi_Math.h"
  36 #include "FUi_ResourceManager.h"
  37 #include "FUiAnim_VisualElement.h"
  38 #include "FUiCtrl_Label.h"
  39 #include "FUiCtrl_ListViewContextItem.h"
  40 #include "FUiCtrl_ListViewItem.h"
  41 #include "FUiCtrl_UiListViewItemEvent.h"
  42 #include "FUiCtrl_UiListViewItemEventArg.h"
  43
  44 #ifdef MEMORY_LEAK_CHECK
  45 #include "mem_leak_check.h"
  46 #endif
  47
  48 using namespace Tizen::Base;
  49 using namespace Tizen::Base::Runtime;
  50 using namespace Tizen::Base::Utility;
  51 using namespace Tizen::Graphics;
  52 using namespace Tizen::Graphics::_Text;
  53 using namespace Tizen::Ui;
  54 using namespace Tizen::Ui::Animations;
  55
  56 namespace Tizen { namespace Ui { namespace Controls
  57 {
  58
  59 _ListViewItem::_ListViewItem(float itemHeight)
  60         : _TableViewItem(itemHeight)
  61         , __needAlignContextItem(false)
  62         , __touchPressed(false)
  63         , __touchEnabled(false)
  64         , __selectedElementId(-1)
  65         , __descriptionTextShowState(false)
  66         , __pDescriptionText(null)
  67         , __pDivider(null)
  68         , __selectionEabled(false)
  69         , __fontStyle(0)
  70         , __fontSize(0.0f)
  71         , __fontName(L"")
  72         , __prevTouchPos(-1.0f, -1.0f)
  73         , __pTextSlideTimer(null)
  74         , __pAccessibilityElement(null)
  75         , __isContextItemListenerActivated(false)
  76 {
  77         GET_COLOR_CONFIG(TABLEVIEW::ITEM_DESCRIPTION_TEXT_NORMAL, __descriptionTextColor);
  78
  79         ___stateChangedInfo.selectionType = LISTVIEW_ITEM_SELECTED;
  80         ___stateChangedInfo.elementId = -1;
  81         ___stateChangedInfo.pUiLinkInfo = null;
  82 }
  83
  84 _ListViewItem::~_ListViewItem(void)
  85 {
  86         DeleteAllElement();
  87
  88         delete ___stateChangedInfo.pUiLinkInfo;
  89         ___stateChangedInfo.pUiLinkInfo = null;
  90
  91         delete __pTextSlideTimer;
  92         __pTextSlideTimer = null;
  93
  94         if (__pDescriptionText != null)
  95         {
  96                 DetachChild(*__pDescriptionText);
  97
  98                 delete __pDescriptionText;
  99                 __pDescriptionText = null;
 100         }
 101
 102         if (__pDivider != null)
 103         {
 104                 DetachChild(*__pDivider);
 105
 106                 delete __pDivider;
 107                 __pDivider = null;
 108         }
 109
 110         _ListViewContextItem* pContextItem = static_cast<_ListViewContextItem*>(GetContextItem());
 111         if ((pContextItem != null) && (__pContextItemEventListener != null))
 112         {
 113                 if (__isContextItemListenerActivated)
 114                 {
 115                         pContextItem->RemoveContextItemEventListener(*__pContextItemEventListener);
 116                 }
 117                 __pContextItemEventListener = null;
 118                 __isContextItemListenerActivated = false;
 119         }
 120
 121         _AccessibilityContainer* pContainer = GetAccessibilityContainer();
 122
 123         if ((__pAccessibilityElement != null) && (pContainer != null))
 124         {
 125                 pContainer->RemoveAllElement();
 126                 __pAccessibilityElement = null;
 127         }
 128 }
 129
 130 _ListViewItem*
 131 _ListViewItem::CreateListViewItemN(float itemHeight)
 132 {
 133         _ListViewItem* pItem = new (std::nothrow) _ListViewItem(itemHeight);
 134         SysTryReturn(NID_UI_CTRL, (pItem != null), null, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] The memory is insufficient.");
 135
 136         pItem->AcquireHandle();
 137
 138         result r = pItem->Initialize();
 139         SysTryCatch(NID_UI_CTRL, r == E_SUCCESS, , r = E_SYSTEM, "[E_SYSTEM] Unable to create _ListViewItem");
 140
 141         return pItem;
 142
 143 CATCH:
 144         delete pItem;
 145
 146         return null;
 147 }
 148
 149 void
 150 _ListViewItem::SetListViewItemType(ListViewItemType type)
 151 {
 152         __itemType = type;
 153 }
 154
 155 result
 156 _ListViewItem::AddElement(FloatRectangle& rect, int elementId, const String& text, bool textSliding)
 157 {
 158         result r = E_SUCCESS;
 159
 160         SysTryReturn(NID_UI_CTRL, (HasElement(elementId) == false), E_INVALID_ARG, E_INVALID_ARG,
 161                         ("[E_INVALID_ARG] This elementId already exists."));
 162
 163         // Convert String to TextObject
 164         TextObject* pText = new (std::nothrow) TextObject();
 165         pText->Construct();
 166
 167         if (text.IsEmpty() == false)
 168         {
 169                 TextSimple* pSimpleText = new (std::nothrow) TextSimple(const_cast <wchar_t*>(text.GetPointer()), text.GetLength());
 170                 pText->AppendElement(*pSimpleText);
 171
 172                 pText->SetAlignment(TEXT_OBJECT_ALIGNMENT_LEFT | TEXT_OBJECT_ALIGNMENT_MIDDLE);
 173                 pText->SetWrap(TEXT_OBJECT_WRAP_TYPE_NONE);
 174         }
 175
 176         // Make element object
 177         _ListViewItemElement element;
 178         memset(&element, 0, sizeof(_ListViewItemElement));
 179
 180         element.elementId = elementId;
 181         element.elementType = LISTVIEW_ITEM_ELEMENT_TEXT;
 182         element.bounds = rect;
 183
 184         element.pTextElement = new (std::nothrow) _ListViewItemElementText();
 185         SysTryReturn(NID_UI_CTRL, (element.pTextElement != null), (r = GetLastResult()), r, "[%s] Propagating.", GetErrorMessage(r));
 186
 187         element.pTextElement->pTextObject = pText;
 188         element.pTextElement->textSlidingEnabled = textSliding;
 189
 190         GET_SHAPE_CONFIG(LISTVIEW::ITEM_DEFAULT_FONT_SIZE, _CONTROL_ORIENTATION_PORTRAIT, element.pTextElement->textSize);
 191         GET_COLOR_CONFIG(TABLEVIEW::ITEM_TEXT_NORMAL, element.pTextElement->textColor[LISTVIEW_ITEM_STATUS_NORMAL]);
 192         GET_COLOR_CONFIG(TABLEVIEW::ITEM_TEXT_PRESSED, element.pTextElement->textColor[LISTVIEW_ITEM_STATUS_PRESSED]);
 193         GET_COLOR_CONFIG(TABLEVIEW::ITEM_TEXT_HIGHLIGHTED, element.pTextElement->textColor[LISTVIEW_ITEM_STATUS_HIGHLIGHTED]);
 194
 195         // Set Visual element for this element
 196         _VisualElement* pVE = new (std::nothrow) _VisualElement();
 197         pVE->Construct();
 198         pVE->SetImplicitAnimationEnabled(false);
 199         pVE->SetContentProvider(&__hitTestVEDelegator);
 200         element.pTextElement->pVE = pVE;
 201
 202         __elements.push_back(element);
 203
 204         return r;
 205 }
 206
 207 result
 208 _ListViewItem::AddElement(FloatRectangle& rect, int elementId, const EnrichedText* pEnrichedText)
 209 {
 210         SysTryReturn(NID_UI_CTRL, (HasElement(elementId) == false), E_INVALID_ARG, E_INVALID_ARG,
 211                         ("[E_INVALID_ARG] This elementId already exists."));
 212
 213         SysTryReturn(NID_GRP, (pEnrichedText != null) && (_EnrichedTextImpl::GetInstance(*pEnrichedText) != null),
 214                         E_INVALID_ARG, E_INVALID_ARG, "[E_INVALID_ARG] This _EnrichedText element is null.");
 215
 216         // Set Text element
 217         _EnrichedTextImpl* pCloneText = _EnrichedTextImpl::GetInstance(*pEnrichedText)->GetCloneN();
 218         SysTryReturn(NID_GRP, (pCloneText != null), E_INVALID_ARG, E_INVALID_ARG, "[E_INVALID_ARG] This _EnrichedText element can not clone.");
 219
 220         TextObject* pText = pCloneText->GetTextObject();
 221
 222         // Make element object
 223         _ListViewItemElement element;
 224         memset(&element, 0, sizeof(_ListViewItemElement));
 225
 226         element.elementId = elementId;
 227         element.elementType = LISTVIEW_ITEM_ELEMENT_TEXT;
 228         element.bounds = rect;
 229
 230         element.pTextElement = new (std::nothrow) _ListViewItemElementText();
 231         SysTryReturn(NID_UI_CTRL, (element.pTextElement != null), GetLastResult(), GetLastResult(), "[%s] Propagating.",
 232                         GetErrorMessage(GetLastResult()));
 233
 234         element.pTextElement->pTextObject = pText;
 235         element.pTextElement->pEnrichedText = pCloneText;
 236         element.pTextElement->textSlidingEnabled = false;
 237
 238         GET_COLOR_CONFIG(TABLEVIEW::ITEM_TEXT_NORMAL, element.pTextElement->textColor[LISTVIEW_ITEM_STATUS_NORMAL]);
 239         GET_COLOR_CONFIG(TABLEVIEW::ITEM_TEXT_PRESSED, element.pTextElement->textColor[LISTVIEW_ITEM_STATUS_PRESSED]);
 240         GET_COLOR_CONFIG(TABLEVIEW::ITEM_TEXT_HIGHLIGHTED, element.pTextElement->textColor[LISTVIEW_ITEM_STATUS_HIGHLIGHTED]);
 241
 242         // Set Visual element for this element
 243         _VisualElement* pVE = new (std::nothrow) _VisualElement();
 244         SysTryReturn(NID_UI_CTRL, (pVE != null), E_OUT_OF_MEMORY, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] Memory allocation failed.");
 245
 246         pVE->Construct();
 247         pVE->SetImplicitAnimationEnabled(false);
 248         pVE->SetContentProvider(&__hitTestVEDelegator);
 249         element.pTextElement->pVE = pVE;
 250
 251         __elements.push_back(element);
 252
 253         return E_SUCCESS;
 254 }
 255
 256 result
 257 _ListViewItem::AddElement(FloatRectangle& rect, int elementId, const Bitmap* pNormalBitmap, const Bitmap* pPressedBitmap, const Bitmap* pHighlightedBitmap)
 258 {
 259         SysTryReturn(NID_UI_CTRL, (HasElement(elementId) == false), E_INVALID_ARG, E_INVALID_ARG,
 260                         ("[E_INVALID_ARG] This elementId already exists."));
 261
 262         SysTryReturn(NID_GRP, (pNormalBitmap != null), E_INVALID_ARG, E_INVALID_ARG, "[E_INVALID_ARG] This Bitmap element is null.");
 263
 264         _ListViewItemElement element;
 265         _VisualElement* pVE = null;
 266         Bitmap* pClonePressedBitmap = null;
 267         Bitmap* pCloneHighlightedBitmap = null;
 268         result r = E_SUCCESS;
 269
 270         Bitmap* pCloneNormalBitmap = _BitmapImpl::CloneN(*pNormalBitmap);
 271         SysTryReturn(NID_UI_CTRL, (pCloneNormalBitmap != null), (r = GetLastResult()), r, "[%s] Propagating.", GetErrorMessage(GetLastResult()));
 272
 273         if (pPressedBitmap != null)
 274         {
 275                 pClonePressedBitmap = _BitmapImpl::CloneN(*pPressedBitmap);
 276                 SysTryCatch(NID_UI_CTRL, (pClonePressedBitmap != null), (r = GetLastResult()), r, "[%s] Propagating.", GetErrorMessage(GetLastResult()));
 277         }
 278
 279         if (pHighlightedBitmap != null)
 280         {
 281                 pCloneHighlightedBitmap = _BitmapImpl::CloneN(*pHighlightedBitmap);
 282                 SysTryCatch(NID_UI_CTRL, (pCloneHighlightedBitmap != null), (r = GetLastResult()), r, "[%s] Propagating.", GetErrorMessage(GetLastResult()));
 283         }
 284
 285         // Make element object
 286         memset(&element, 0, sizeof(_ListViewItemElement));
 287
 288         element.elementId = elementId;
 289         element.elementType = LISTVIEW_ITEM_ELEMENT_BITMAP;
 290         element.bounds = rect;
 291
 292         element.pBitmapElement = new (std::nothrow) _ListViewItemElementBitmap();
 293         SysTryCatch(NID_UI_CTRL, (element.pBitmapElement != null), (r = GetLastResult()), r, "[%s] Propagating.", GetErrorMessage(GetLastResult()));
 294
 295         element.pBitmapElement->pBitmap[LISTVIEW_ITEM_STATUS_NORMAL] = pCloneNormalBitmap;
 296         element.pBitmapElement->pBitmap[LISTVIEW_ITEM_STATUS_PRESSED] = pClonePressedBitmap;
 297         element.pBitmapElement->pBitmap[LISTVIEW_ITEM_STATUS_HIGHLIGHTED] = pCloneHighlightedBitmap;
 298
 299         pVE = new (std::nothrow) _VisualElement();
 300         SysTryCatch(NID_UI_CTRL, pVE, , E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] Memory allocation failed.");
 301
 302         pVE->Construct();
 303         pVE->SetImplicitAnimationEnabled(false);
 304         pVE->SetContentProvider(&__hitTestVEDelegator);
 305         element.pBitmapElement->pVE = pVE;
 306
 307         __elements.push_back(element);
 308
 309         return E_SUCCESS;
 310
 311 CATCH:
 312         delete pCloneNormalBitmap;
 313         delete pClonePressedBitmap;
 314         delete pCloneHighlightedBitmap;
 315
 316         return r;
 317 }
 318
 319 result
 320 _ListViewItem::AddElement(FloatRectangle& rect, int elementId, const _ICustomElement* pCustom)
 321 {
 322         SysTryReturn(NID_UI_CTRL, (HasElement(elementId) == false), E_INVALID_ARG, E_INVALID_ARG,
 323                         ("[E_INVALID_ARG] This elementId already exists."));
 324
 325         SysTryReturn(NID_GRP, (pCustom != null), E_INVALID_ARG, E_INVALID_ARG, "[E_INVALID_ARG] This Custom element is null.");
 326
 327         // Make element object
 328         _ListViewItemElement element;
 329         memset(&element, 0, sizeof(_ListViewItemElement));
 330
 331         element.elementId = elementId;
 332         element.elementType = LISTVIEW_ITEM_ELEMENT_OBJ;
 333         element.bounds = rect;
 334
 335         element.pCustomElement = new (std::nothrow) _ListViewItemElementCustom();
 336         SysTryReturn(NID_UI_CTRL, (element.pCustomElement != null), GetLastResult(), GetLastResult(), "[%s] Propagating.", GetErrorMessage(GetLastResult()));
 337
 338         element.pCustomElement->pCustom = const_cast<_ICustomElement*>(pCustom);
 339
 340         _VisualElement* pVE = new (std::nothrow) _VisualElement();
 341         SysTryReturn(NID_UI_CTRL, (pVE != null), E_OUT_OF_MEMORY, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] Memory allocation failed.");
 342         pVE->Construct();
 343         pVE->SetImplicitAnimationEnabled(false);
 344         pVE->SetContentProvider(&__hitTestVEDelegator);
 345         element.pCustomElement->pVE = pVE;
 346
 347         if (pVE->GetParent() == null)
 348         {
 349                 GetVisualElement()->AttachChild(*(pVE));
 350                 pVE->SetShowState(true);
 351                 pVE->SetBounds(rect);
 352         }
 353
 354         __elements.push_back(element);
 355
 356         return E_SUCCESS;
 357 }
 358
 359 bool
 360 _ListViewItem::DeleteElement(int elementId)
 361 {
 362         _LinkedList <_ListViewItemElement>::_Iterator iter;
 363
 364         for (iter = __elements.begin(); iter != __elements.end(); iter++)
 365         {
 366                 if (iter->elementId == elementId)
 367                 {
 368                         DeleteElement(&(*iter));
 369                         __elements.erase(iter);
 370
 371                         return true;
 372                 }
 373         }
 374
 375         return false;
 376 }
 377
 378 void
 379 _ListViewItem::DeleteAllElement(void)
 380 {
 381         _LinkedList <_ListViewItemElement>::_Iterator iter;
 382
 383         for (iter = __elements.begin(); iter != __elements.end(); iter++)
 384         {
 385                 DeleteElement(&(*iter));
 386         }
 387
 388         __elements.clear();
 389 }
 390
 391 void
 392 _ListViewItem::DeleteElement(_ListViewItemElement* pElement)
 393 {
 394         if (pElement->pTextElement != null)
 395         {
 396                 if (pElement->pTextElement->pEnrichedText != null)
 397                 {
 398                         (pElement->pTextElement->pEnrichedText)->RemoveAllTextElements(true);
 399
 400                         delete pElement->pTextElement->pEnrichedText;
 401                         pElement->pTextElement->pEnrichedText = null;
 402
 403                         pElement->pTextElement->pTextObject = null;
 404                 }
 405                 else
 406                 {
 407                         delete pElement->pTextElement->pTextObject;
 408                         pElement->pTextElement->pTextObject = null;
 409                 }
 410
 411                 if (pElement->pTextElement->pVE != null)
 412                 {
 413                         pElement->pTextElement->pVE->Destroy();
 414                         pElement->pTextElement->pVE = null;
 415                 }
 416
 417                 delete pElement->pTextElement;
 418                 pElement->pTextElement = null;
 419         }
 420
 421         if (pElement->pBitmapElement != null)
 422         {
 423                 for (int i = 0; i < LISTVIEW_ITEM_STATUS_MAX; i++)
 424                 {
 425                         delete pElement->pBitmapElement->pBitmap[i];
 426                         pElement->pBitmapElement->pBitmap[i] = null;
 427                 }
 428
 429                 if (pElement->pBitmapElement->pVE != null)
 430                 {
 431                         pElement->pBitmapElement->pVE->Destroy();
 432                         pElement->pBitmapElement->pVE = null;
 433                 }
 434
 435                 delete pElement->pBitmapElement;
 436                 pElement->pBitmapElement = null;
 437         }
 438
 439         if (pElement->pCustomElement)
 440         {
 441                 delete pElement->pCustomElement->pCustom;
 442                 pElement->pCustomElement->pCustom = null;
 443
 444                 if (pElement->pCustomElement->pVE != null)
 445                 {
 446                         pElement->pCustomElement->pVE->Destroy();
 447                         pElement->pCustomElement->pVE = null;
 448                 }
 449
 450                 delete pElement->pCustomElement;
 451                 pElement->pCustomElement = null;
 452         }
 453 }
 454
 455 bool
 456 _ListViewItem::HasElement(int elementId)
 457 {
 458         _ListViewItemElement* pElement = GetElement(elementId);
 459
 460         return (pElement != null);
 461 }
 462
 463 bool
 464 _ListViewItem::RefreshElement(int elementId)
 465 {
 466         _ListViewItemElement* pElement = GetElement(elementId);
 467
 468         if (pElement != null)
 469         {
 470                 DrawElement(pElement);
 471         }
 472
 473         return (pElement != null);
 474 }
 475
 476 void
 477 _ListViewItem::SetLastStateChangedInfo(void)
 478 {
 479         ClearLastStateChangedInfo();
 480
 481         int elementId = GetElementIdFromCurrentTouchPosition();
 482         _ListViewItemElement* pElement = GetElement(elementId);
 483
 484         if ((pElement != null) && (__itemType == LISTVIEW_ITEM_TYPE_CUSTOM))
 485         {
 486                 _ListViewItemUiLinkInfo* pInfo = null;
 487                 int cutlinkTextTouchedIndex = -1;
 488
 489                 if (IsCutlinkTextSelected(__prevTouchPos, &cutlinkTextTouchedIndex, &pInfo))
 490                 {
 491                         if ((GetItemStyle() == TABLE_VIEW_ANNEX_STYLE_DETAILED)
 492                                         && (pElement->actionElement == true) && (pElement->selectionEnabled == false))
 493                         {
 494                                 elementId = -1;
 495                         }
 496
 497                         if (cutlinkTextTouchedIndex >= 0)
 498                         {
 499                                 ___stateChangedInfo.selectionType = LISTVIEW_ITEM_UILINK_SELECTED;
 500                                 ___stateChangedInfo.elementId = elementId;
 501                                 ___stateChangedInfo.pUiLinkInfo = pInfo;
 502                         }
 503                         else
 504                         {
 505                                 ___stateChangedInfo.selectionType = LISTVIEW_ITEM_ELEMENT_SELECTED;
 506                                 ___stateChangedInfo.elementId = elementId;
 507                         }
 508                 }
 509                 else
 510                 {
 511                         if ((GetItemStyle() == TABLE_VIEW_ANNEX_STYLE_DETAILED)
 512                                         && (pElement->actionElement == true) && (pElement->selectionEnabled == false))
 513                         {
 514                                 elementId = -1;
 515                         }
 516
 517                         ___stateChangedInfo.selectionType = LISTVIEW_ITEM_ELEMENT_SELECTED;
 518                         ___stateChangedInfo.elementId = elementId;
 519                 }
 520         }
 521         else
 522         {
 523                 ___stateChangedInfo.selectionType = LISTVIEW_ITEM_ELEMENT_SELECTED;
 524                 ___stateChangedInfo.elementId = -1;
 525         }
 526 }
 527
 528 bool
 529 _ListViewItem::GetLastStateChangedInfo(_ListViewItemStateChangedInfo& changedInfo) const
 530 {
 531         changedInfo = ___stateChangedInfo;
 532
 533         return (___stateChangedInfo.selectionType != LISTVIEW_ITEM_SELECTED);
 534 }
 535
 536 void
 537 _ListViewItem::ClearLastStateChangedInfo(void)
 538 {
 539         delete ___stateChangedInfo.pUiLinkInfo;
 540
 541         ___stateChangedInfo.selectionType = LISTVIEW_ITEM_SELECTED;
 542         ___stateChangedInfo.elementId = -1;
 543         ___stateChangedInfo.pUiLinkInfo = null;
 544 }
 545
 546 void
 547 _ListViewItem::SetCurrentStatus(_ListViewItemStatus& currentStatus)
 548 {
 549         // This function was made to modify of ListView::RefreshList().
 550         // This function could adversely affect touch event handling. So, you should be used with caution.
 551
 552         SetPressedControl((currentStatus.annexStyle == GetItemStyle()) ? currentStatus.pressedControl : TABLE_VIEW_ITEM_PRESSED_ITEM);
 553         SetSelectionState(currentStatus.itemSelected);
 554         SetLastTouchPressedPosition(currentStatus.currentTouchPosition);
 555
 556         if (!currentStatus.itemSelected)
 557         {
 558                 SetItemDrawingStatus(LISTVIEW_ITEM_STATUS_NORMAL);
 559         }
 560
 561         __prevTouchPos = currentStatus.currentTouchPosition;
 562         __touchEnabled = currentStatus.touchEnabled;
 563         __selectionEabled = currentStatus.elementSelectionEnabled;
 564         __selectedElementId = currentStatus.selectedElementId;
 565         __touchPressed = (currentStatus.itemSelected || currentStatus.elementSelectionEnabled);
 566
 567         if (__selectionEabled)
 568         {
 569                 SetItemDrawingStatus(LISTVIEW_ITEM_STATUS_NORMAL);
 570         }
 571
 572         _ListViewItemElement* pElement = GetElement(__selectedElementId);
 573
 574         // text sliding check and invoke
 575         if (pElement != null)
 576         {
 577                 if (pElement->elementType == LISTVIEW_ITEM_ELEMENT_TEXT)
 578                 {
 579                         RefreshElement(__selectedElementId);
 580
 581                         SetCutlinkTextFocus(currentStatus.currentTouchPosition);
 582
 583                         if (pElement->pTextElement->textSlidingEnabled)
 584                         {
 585                                 pElement->pTextElement->pTextObject->SetAction(TEXT_OBJECT_ACTION_TYPE_SLIDE_LEFT);
 586                                 pElement->pTextElement->pTextObject->Compose();
 587
 588                                 if (pElement->pTextElement->pTextObject->IsActionOn())
 589                                 {
 590                                         StartTextSlideTimer();
 591                                 }
 592                         }
 593                 }
 594         }
 595
 596         Draw();
 597         Show();
 598
 599         // set item state changed info
 600         SetLastStateChangedInfo();
 601 }
 602
 603 void
 604 _ListViewItem::GetCurrentStatus(_ListViewItemStatus& currentStatus)
 605 {
 606         // for _TableViewItem
 607         currentStatus.annexStyle = GetItemStyle();
 608         currentStatus.pressedControl = GetPressedControl();
 609         currentStatus.itemSelected = GetSelectionState();
 610         currentStatus.currentTouchPosition = __prevTouchPos;
 611
 612         // for _ListViewItem
 613         currentStatus.touchEnabled = __touchEnabled;
 614         currentStatus.elementSelectionEnabled = __selectionEabled;
 615         currentStatus.selectedElementId = __selectedElementId;
 616 }
 617
 618 bool
 619 _ListViewItem::IsItemSelected(void)
 620 {
 621         return __touchEnabled;
 622 }
 623
 624 int
 625 _ListViewItem::GetElementIdFromPosition(const FloatPoint& position) const
 626 {
 627         _LinkedList <_ListViewItemElement>::_ReverseIterator reverseIter;
 628
 629         for (reverseIter = __elements.rbegin(); reverseIter != __elements.rend(); reverseIter++)
 630         {
 631                 if ((*reverseIter).bounds.Contains(position))
 632                 {
 633                         return (*reverseIter).elementId;
 634                 }
 635         }
 636
 637         return -1;
 638 }
 639
 640 int
 641 _ListViewItem::GetElementIdFromCurrentTouchPosition(void) const
 642 {
 643         return GetElementIdFromPosition(__prevTouchPos);
 644 }
 645
 646 _ListViewItemElement*
 647 _ListViewItem::GetElement(int elementId) const
 648 {
 649         _LinkedList <_ListViewItemElement>::_Iterator iter;
 650
 651         for (iter = __elements.begin(); iter != __elements.end(); iter++)
 652         {
 653                 if (iter->elementId == elementId)
 654                 {
 655                         return &(*iter);
 656                 }
 657         }
 658
 659         return null;
 660 }
 661
 662 ListViewItemElementType
 663 _ListViewItem::GetElementType(int elementId) const
 664 {
 665         _ListViewItemElement* pElement = GetElement(elementId);
 666
 667         return ((pElement != null) ? pElement->elementType : LISTVIEW_ITEM_ELEMENT_INVALID);
 668 }
 669
 670 TextObject*
 671 _ListViewItem::GetTextObjectInElement(int elementId) const
 672 {
 673         _ListViewItemElementText* pElement = GetElementText(elementId);
 674
 675         return ((pElement != null) ? pElement->pTextObject : null);
 676 }
 677
 678 _ListViewItemElementText*
 679 _ListViewItem::GetElementText(int elementId) const
 680 {
 681         _ListViewItemElement* pElement = GetElement(elementId);
 682
 683         if ((pElement != null) && (pElement->elementType == LISTVIEW_ITEM_ELEMENT_TEXT)
 684                         &&  (pElement->pTextElement->pTextObject != null))
 685         {
 686                 return pElement->pTextElement;
 687         }
 688
 689         return null;
 690 }
 691
 692 _ListViewItemElementBitmap*
 693 _ListViewItem::GetElementBitmap(int elementId) const
 694 {
 695         _ListViewItemElement* pElement = GetElement(elementId);
 696
 697         if ((pElement != null) && (pElement->elementType == LISTVIEW_ITEM_ELEMENT_BITMAP))
 698         {
 699                 return pElement->pBitmapElement;
 700         }
 701
 702         return null;
 703 }
 704
 705 bool
 706 _ListViewItem::SetElementSelectionEnabled(int elementId, bool enable)
 707 {
 708         _ListViewItemElement* pElement = GetElement(elementId);
 709
 710         if (pElement == null)
 711         {
 712                 return false;
 713         }
 714
 715         pElement->actionElement = true;
 716         pElement->selectionEnabled = enable;
 717
 718         return true;
 719 }
 720
 721 bool
 722 _ListViewItem::GetElementSelectionEnabled(int elementId, bool& enable)
 723 {
 724         _ListViewItemElement* pElement = GetElement(elementId);
 725
 726         if ((pElement == null) || (pElement->actionElement == false))
 727         {
 728                 return false;
 729         }
 730
 731         enable = pElement->selectionEnabled;
 732
 733         return true;
 734 }
 735
 736 bool
 737 _ListViewItem::SetTextCutlinkMask(int elementId, unsigned long mask)
 738 {
 739         _ListViewItemElementText* pElement = GetElementText(elementId);
 740
 741         if (pElement == null)
 742         {
 743                 return false;
 744         }
 745
 746         pElement->cutlinkMaskType = mask;
 747
 748         return true;
 749 }
 750
 751 bool
 752 _ListViewItem::SetTextCutlinkViewMode(int elementId, bool cutlinkViewMode, bool cutlinkParseEnable)
 753 {
 754         _ListViewItemElementText* pElement = GetElementText(elementId);
 755
 756         if (pElement == null)
 757         {
 758                 return false;
 759         }
 760
 761         pElement->cutlinkViewModeEnabled = cutlinkViewMode;
 762         pElement->cutlinkParseEnabled = cutlinkParseEnable;
 763         pElement->cutlinkMaskType = LINK_TYPE_MAX;
 764
 765         return true;
 766 }
 767
 768 bool
 769 _ListViewItem::SetTextAlignment(int elementId, TextObjectAlignment textAlignment)
 770 {
 771         TextObject* pTextObject = GetTextObjectInElement(elementId);
 772
 773         if (pTextObject == null)
 774         {
 775                 return false;
 776         }
 777
 778         TextObjectAlignment originAlign = pTextObject->GetAlignment();
 779
 780         // reset original alignment
 781         if ((0x0007 & textAlignment) != 0x0000)                 // TextHorizontalAlignment
 782         {
 783                 originAlign &= 0x0700;
 784         }
 785         else if ((0x0700 & textAlignment) != 0x0000)    // TextVerticalAlignment
 786         {
 787                 originAlign &= 0x0007;
 788         }
 789
 790         pTextObject->SetAlignment(originAlign | textAlignment);
 791
 792         return true;
 793 }
 794
 795 bool
 796 _ListViewItem::GetTextAlignment(int elementId, TextObjectAlignment& textAlignment) const
 797 {
 798         TextObject* pTextObject = GetTextObjectInElement(elementId);
 799
 800         if (pTextObject == null)
 801         {
 802                 return false;
 803         }
 804
 805         textAlignment = pTextObject->GetAlignment();
 806
 807         return true;
 808 }
 809
 810 bool
 811 _ListViewItem::SetTextWrapType(int elementId, TextObjectWrapType wrapType)
 812 {
 813         TextObject* pTextObject = GetTextObjectInElement(elementId);
 814
 815         if (pTextObject == null)
 816         {
 817                 return false;
 818         }
 819
 820         pTextObject->SetWrap(wrapType);
 821
 822         return true;
 823 }
 824
 825 bool
 826 _ListViewItem::SetTextSize(int elementId, float textSize)
 827 {
 828         _ListViewItemElementText* pElement = GetElementText(elementId);
 829
 830         if ((pElement != null) && (textSize > 0.0f))
 831         {
 832                 pElement->textSize = textSize;
 833
 834                 return true;
 835         }
 836
 837         return false;
 838 }
 839
 840 bool
 841 _ListViewItem::SetTextColor(int elementId, Color textColor, ListViewItemDrawingStatus status)
 842 {
 843         _ListViewItemElementText* pElement = GetElementText(elementId);
 844
 845         if (pElement == null)
 846         {
 847                 return false;
 848         }
 849
 850         pElement->textColor[status] = textColor;
 851
 852         return true;
 853 }
 854
 855 bool
 856 _ListViewItem::GetTextColor(int elementId, Color& textColor, ListViewItemDrawingStatus status) const
 857 {
 858         _ListViewItemElementText* pElement = GetElementText(elementId);
 859
 860         if (pElement == null)
 861         {
 862                 return false;
 863         }
 864
 865         textColor = pElement->textColor[status];
 866
 867         return true;
 868 }
 869
 870 bool
 871 _ListViewItem::SetDescriptionText(const String& text)
 872 {
 873         if (text.IsEmpty())
 874         {
 875                 if (__pDescriptionText != null)
 876                 {
 877                         DetachChild(*__pDescriptionText);
 878
 879                         delete __pDescriptionText;
 880                         __pDescriptionText = null;
 881                 }
 882
 883                 return true;
 884         }
 885         else
 886         {
 887                 if (__pDescriptionText == null)
 888                 {
 889                         __pDescriptionText = _Label::CreateLabelN();
 890                         result r = GetLastResult();
 891                         SysTryReturn(NID_UI_CTRL, (__pDescriptionText != null), r, r, "[%s] Propagating.", GetErrorMessage(r));
 892
 893                         __pDescriptionText->SetVisibleState(false);
 894                         __pDescriptionText->SetMargin(0.0f, 0.0f, 0.0f, 0.0f);
 895                         __pDescriptionText->SetTextHorizontalAlignment(ALIGNMENT_LEFT);
 896
 897                         AttachChild(*__pDescriptionText);
 898                 }
 899
 900                 FloatRectangle bounds = GetBoundsF();
 901                 FloatRectangle textBounds;
 902                 float textSize = 0.0f;
 903                 bool ret = true;
 904
 905                 GET_SHAPE_CONFIG(LISTVIEW::ITEM_DESCRIPTION_TEXT_LEFT_MARGIN, _CONTROL_ORIENTATION_PORTRAIT, textBounds.x);
 906                 GET_SHAPE_CONFIG(LISTVIEW::ITEM_DESCRIPTION_TEXT_TOP_MARGIN, _CONTROL_ORIENTATION_PORTRAIT, textBounds.y);
 907                 GET_SHAPE_CONFIG(LISTVIEW::ITEM_DESCRIPTION_TEXT_FONT_SIZE, _CONTROL_ORIENTATION_PORTRAIT, textSize);
 908
 909                 textBounds.width = bounds.width - (textBounds.x * 2.0f);
 910
 911                 TextObject* pText = new (std::nothrow) TextObject();
 912                 SysTryReturn(NID_UI_CTRL, (pText != null), false, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] The memory is insufficient.");
 913
 914                 pText->Construct();
 915
 916                 TextSimple* pSimpleText = new (std::nothrow) TextSimple((const_cast<wchar_t*>(text.GetPointer())), text.GetLength());
 917                 SysTryCatch(NID_UI_CTRL, (pSimpleText != null), (ret = false), E_OUT_OF_MEMORY, "[%s] Propagating.", GetErrorMessage(GetLastResult()));
 918
 919                 pText->AppendElement(*pSimpleText);
 920                 pText->SetAlignment(TEXT_OBJECT_ALIGNMENT_LEFT | TEXT_OBJECT_ALIGNMENT_TOP);
 921                 pText->SetWrap(TEXT_OBJECT_WRAP_TYPE_WORD);
 922                 pText->SetFont(GetFont(FONT_STYLE_PLAIN, textSize), 0, pText->GetTextLength());
 923                 pText->SetBounds(FloatRectangle(0.0f, 0.0f, textBounds.width, 1.0f));
 924                 pText->Compose();
 925
 926                 textBounds.height = pText->GetTotalHeight();
 927
 928                 __pDescriptionText->SetBounds(FloatRectangle(textBounds.x, bounds.height + textBounds.y, textBounds.width, textBounds.height));
 929                 __pDescriptionText->SetBackgroundColor(Color(0, 0, 0, 0));
 930                 __pDescriptionText->SetTextColor(__descriptionTextColor);
 931                 __pDescriptionText->SetTextConfig(textSize, LABEL_TEXT_STYLE_NORMAL);
 932                 __pDescriptionText->SetText(text);
 933
 934 CATCH:
 935                 delete pText;
 936
 937                 return ret;
 938         }
 939 }
 940
 941 void
 942 _ListViewItem::SetDescriptionTextColor(const Color& color)
 943 {
 944         __descriptionTextColor = color;
 945 }
 946
 947 float
 948 _ListViewItem::GetDescriptionTextHeight(void)
 949 {
 950         if (__pDescriptionText != null)
 951         {
 952                 float margin = 0.0f;
 953                 GET_SHAPE_CONFIG(LISTVIEW::ITEM_DESCRIPTION_TEXT_TOP_MARGIN, _CONTROL_ORIENTATION_PORTRAIT, margin);
 954
 955                 return ((margin * 2.0f) + __pDescriptionText->GetBoundsF().height);
 956         }
 957
 958         return 0.0f;
 959 }
 960
 961 void
 962 _ListViewItem::SetDescriptionTextShowState(bool show)
 963 {
 964         if (__descriptionTextShowState != show)
 965         {
 966                 __descriptionTextShowState = show;
 967
 968                 if (__pDescriptionText != null)
 969                 {
 970                         __pDescriptionText->SetVisibleState(__descriptionTextShowState);
 971
 972                         FloatDimension itemDimension = GetSizeF();
 973                         float descriptionTextHeight = GetDescriptionTextHeight();
 974
 975                         itemDimension.height += ((__descriptionTextShowState) ? (descriptionTextHeight) : (-descriptionTextHeight));
 976
 977                         // Set position & item height
 978                         SetItemCustomHeight((__descriptionTextShowState ? (itemDimension.height - descriptionTextHeight) : 0.0f));
 979                         SetItemHeight(itemDimension.height);
 980
 981                         SetSize(itemDimension);
 982
 983                         if (__pAccessibilityElement != null)
 984                         {
 985                                 SetAccessibilityElement();
 986                         }
 987                 }
 988         }
 989 }
 990
 991 void
 992 _ListViewItem::SetContextItemEventListener(_IActionEventListener& listener)
 993 {
 994         __pContextItemEventListener = &listener;
 995 }
 996
 997 void
 998 _ListViewItem::SetContextItemActivationState(bool activate)
 999 {
1000         _ListViewContextItem* pContextItem = static_cast<_ListViewContextItem*>(GetContextItem());
1001
1002         if ((pContextItem != null) && (__pContextItemEventListener != null))
1003         {
1004                 if (activate)
1005                 {
1006                         pContextItem->AddContextItemEventListener(*__pContextItemEventListener);
1007                         __isContextItemListenerActivated = true;
1008                 }
1009                 else
1010                 {
1011                         pContextItem->RemoveContextItemEventListener(*__pContextItemEventListener);
1012                         __isContextItemListenerActivated = false;
1013                 }
1014         }
1015 }
1016
1017 bool
1018 _ListViewItem::OnTouchPressed(const _Control& source, const _TouchInfo& touchinfo)
1019 {
1020         if ((&source != this) && (source.GetParent() != this))
1021         {
1022                 return false;
1023         }
1024
1025         if (IsTouchPressOnScroll())
1026         {
1027                 return false;
1028         }
1029
1030         ClearLastStateChangedInfo();
1031         StopTextSlideTimer();
1032
1033         FloatPoint pos = touchinfo.GetCurrentPosition();
1034         __prevTouchPos.SetPosition(pos.x, pos.y);
1035
1036         __selectedElementId = GetElementIdFromPosition(pos);
1037
1038         _ListViewItemElement* pElement = GetElement(__selectedElementId);
1039
1040         if (pElement != null)
1041         {
1042                 if ((pElement->actionElement) && (pElement->selectionEnabled))
1043                 {
1044                         __selectionEabled = true;
1045                 }
1046
1047                 if (pElement->elementType == LISTVIEW_ITEM_ELEMENT_TEXT)
1048                 {
1049                         SetCutlinkTextFocus(pos);
1050
1051                         if (pElement->pTextElement->textSlidingEnabled)
1052                         {
1053                                 pElement->pTextElement->pTextObject->SetAction(TEXT_OBJECT_ACTION_TYPE_SLIDE_LEFT);
1054                                 pElement->pTextElement->pTextObject->Compose();
1055
1056                                 if (pElement->pTextElement->pTextObject->IsActionOn())
1057                                 {
1058                                         StartTextSlideTimer();
1059                                 }
1060                         }
1061                 }
1062         }
1063
1064         __touchPressed = true;
1065         __touchEnabled = true;
1066
1067         SetLastStateChangedInfo();
1068
1069         _TableViewItem::OnTouchPressed(source, touchinfo);
1070
1071         // for do not occur annex selection.
1072         if (__selectionEabled)
1073         {
1074                 StopTouchPressedTimer();
1075                 SetSelectionState(false);
1076
1077                 RefreshElement(__selectedElementId);
1078         }
1079
1080         return false;
1081 }
1082
1083 bool
1084 _ListViewItem::OnTouchReleased(const _Control& source, const _TouchInfo& touchinfo)
1085 {
1086         if ((&source != this) && (source.GetParent() != this))
1087         {
1088                 return false;
1089         }
1090
1091         if (IsTouchPressOnScroll())
1092         {
1093                 SetTouchPressOnScroll(false);
1094                 return false;
1095         }
1096
1097         FloatPoint pos = touchinfo.GetCurrentPosition();
1098         __prevTouchPos.SetPosition(pos.x, pos.y);
1099
1100         __touchPressed = false;
1101         __touchEnabled = false;
1102
1103         ResetTextSlide();
1104         ResetCutlinkFocus();
1105
1106         _TableViewItem::OnTouchReleased(source, touchinfo);
1107
1108         if (__selectionEabled)
1109         {
1110                 __selectionEabled = false;
1111
1112                 //Invalidate();
1113                 RefreshElement(__selectedElementId);
1114
1115                 bool enabled = SetItemTapSoundEnabled(false);
1116                 FireItemEvent();
1117                 SetItemTapSoundEnabled(enabled);
1118         }
1119
1120         __selectedElementId = -1;
1121
1122         return false;
1123 }
1124
1125 bool
1126 _ListViewItem::OnTouchMoved(const _Control& source, const _TouchInfo& touchinfo)
1127 {
1128         FloatPoint pos = touchinfo.GetCurrentPosition();
1129         __prevTouchPos.SetPosition(pos.x, pos.y);
1130
1131         if (IsTouchPressOnScroll())
1132         {
1133                 SetTouchPressOnScroll(false);
1134         }
1135
1136         if (__touchPressed)
1137         {
1138                 ClearLastStateChangedInfo();
1139         }
1140
1141         ResetTextSlide();
1142
1143         __selectedElementId = -1;
1144         __selectionEabled = false;
1145         __touchPressed = false;
1146
1147         _TableViewItem::OnTouchMoved(source, touchinfo);
1148
1149         return false;
1150 }
1151
1152 bool
1153 _ListViewItem::OnTouchCanceled(const _Control& source, const _TouchInfo& touchinfo)
1154 {
1155         FloatPoint pos = touchinfo.GetCurrentPosition();
1156         __prevTouchPos.SetPosition(pos.x, pos.y);
1157
1158         ResetTextSlide();
1159
1160         __selectedElementId = -1;
1161         __selectionEabled = false;
1162         __touchPressed = false;
1163         __touchEnabled = false;
1164
1165         _TableViewItem::OnTouchCanceled(source, touchinfo);
1166
1167         return false;
1168 }
1169
1170 void
1171 _ListViewItem::OnDraw(void)
1172 {
1173         bool needDraw = IsItemChanged();
1174
1175         _TableViewItem::OnDraw();
1176
1177         if (needDraw)
1178         {
1179                 DrawElements();
1180                 DrawDivider();
1181         }
1182 }
1183
1184 result
1185 _ListViewItem::OnBoundsChanging(const FloatRectangle& bounds)
1186 {
1187         FloatDimension currentSize = GetSizeF();
1188
1189         if (!_FloatCompare(currentSize.width, bounds.width) || !_FloatCompare(currentSize.height, bounds.height))
1190         {
1191                 __needAlignContextItem = true;
1192         }
1193
1194         return E_SUCCESS;
1195 }
1196
1197 void
1198 _ListViewItem::OnBoundsChanged(void)
1199 {
1200         _TableViewItem::OnBoundsChanged();
1201
1202         if (__needAlignContextItem)
1203         {
1204                 _ListViewContextItem* pContextItem = static_cast<_ListViewContextItem*>(GetContextItem());
1205
1206                 if (pContextItem != null)
1207                 {
1208                         FloatRectangle bounds = GetBoundsF();
1209                         pContextItem->AdjustItemBounds(bounds);
1210
1211                         __needAlignContextItem = false;
1212                 }
1213         }
1214 }
1215
1216 void
1217 _ListViewItem::SetItemDrawingStatus(ListViewItemDrawingStatus status)
1218 {
1219         TableViewItemDrawingStatus parentStatus = TABLE_VIEW_ITEM_DRAWING_STATUS_NORMAL;
1220
1221         switch (status)
1222         {
1223         case LISTVIEW_ITEM_STATUS_PRESSED:
1224                 parentStatus = TABLE_VIEW_ITEM_DRAWING_STATUS_PRESSED;
1225                 break;
1226
1227         case LISTVIEW_ITEM_STATUS_HIGHLIGHTED:
1228                 parentStatus = TABLE_VIEW_ITEM_DRAWING_STATUS_HIGHLIGHTED;
1229                 break;
1230
1231         default:
1232                 parentStatus = TABLE_VIEW_ITEM_DRAWING_STATUS_NORMAL;
1233                 break;
1234         }
1235
1236         SetDrawingStatus(parentStatus);
1237 }
1238
1239 ListViewItemDrawingStatus
1240 _ListViewItem::GetItemDrawingStatus(void)
1241 {
1242         TableViewItemDrawingStatus parentStatus = GetDrawingStatus();
1243
1244         switch (parentStatus)
1245         {
1246         case TABLE_VIEW_ITEM_DRAWING_STATUS_PRESSED:
1247                 return LISTVIEW_ITEM_STATUS_PRESSED;
1248
1249         case TABLE_VIEW_ITEM_DRAWING_STATUS_HIGHLIGHTED:
1250                 return LISTVIEW_ITEM_STATUS_HIGHLIGHTED;
1251
1252         default:
1253                 return LISTVIEW_ITEM_STATUS_NORMAL;
1254         }
1255 }
1256
1257 void
1258 _ListViewItem::DrawElement(_ListViewItemElement* pElement)
1259 {
1260         // Get Current TableViewItem drawing status
1261         ListViewItemDrawingStatus status = GetItemDrawingStatus();
1262         FloatRectangle elementRect;
1263
1264         // Check element selection enabled
1265         if (status != LISTVIEW_ITEM_STATUS_NORMAL)
1266         {
1267                 if (__selectedElementId == -1)
1268                 {
1269                         if ((pElement->actionElement) && (pElement->selectionEnabled))
1270                         {
1271                                 status = LISTVIEW_ITEM_STATUS_NORMAL;
1272                         }
1273                 }
1274                 else if (__selectedElementId != pElement->elementId)
1275                 {
1276                         bool enabled = false;
1277                         if (GetElementSelectionEnabled(__selectedElementId, enabled) && enabled)
1278                         {
1279                                 status = LISTVIEW_ITEM_STATUS_NORMAL;
1280                         }
1281                         else if ((pElement->actionElement) && (pElement->selectionEnabled))
1282                         {
1283                                 status = LISTVIEW_ITEM_STATUS_NORMAL;
1284                         }
1285                 }
1286         }
1287         else
1288         {
1289                 if ((__selectedElementId == pElement->elementId) && __selectionEabled)
1290                 {
1291                         status = LISTVIEW_ITEM_STATUS_PRESSED;
1292                 }
1293         }
1294
1295         Canvas* pCanvas = null;
1296
1297         switch (pElement->elementType)
1298         {
1299         case LISTVIEW_ITEM_ELEMENT_TEXT:
1300                 DrawText(pElement->bounds, status, pElement->pTextElement);
1301                 break;
1302
1303         case LISTVIEW_ITEM_ELEMENT_BITMAP:
1304                 DrawBitmap(pElement->bounds, status, pElement->pBitmapElement);
1305                 break;
1306
1307         case LISTVIEW_ITEM_ELEMENT_OBJ:
1308                 pCanvas = pElement->pCustomElement->pVE->GetCanvasN();
1309
1310                 if (pCanvas != null)
1311                 {
1312                         pCanvas->SetBackgroundColor(Color(0, 0, 0, 0));
1313                         pCanvas->Clear();
1314                         elementRect.SetBounds(0.0f, 0.0f, pElement->bounds.width, pElement->bounds.height);
1315
1316                         pElement->pCustomElement->pCustom->DrawElement(pCanvas, elementRect, status);
1317                 }
1318                 break;
1319
1320         default:
1321                 break;
1322         }
1323
1324         delete pCanvas;
1325 }
1326
1327 void
1328 _ListViewItem::DrawElements(void)
1329 {
1330         _LinkedList <_ListViewItemElement>::_Iterator iter;
1331
1332         for (iter = __elements.begin(); iter != __elements.end(); iter++)
1333         {
1334                 DrawElement(&(*iter));
1335         }
1336 }
1337
1338 bool
1339 _ListViewItem::DrawText(FloatRectangle& rect, ListViewItemDrawingStatus status, _ListViewItemElementText* pText)
1340 {
1341         SysTryReturn(NID_UI_CTRL, (pText != null), false, E_INVALID_ARG, "[E_INVALID_ARG] This Text element is null.");
1342
1343         FloatRectangle bounds(rect.x, rect.y, rect.width, rect.height);
1344
1345         if (pText->pVE->GetParent() == null)
1346         {
1347                 GetVisualElement()->AttachChild(*(pText->pVE));
1348                 pText->pVE->SetShowState(true);
1349         }
1350
1351         if (pText->textSize > 0)
1352         {
1353                 pText->pTextObject->SetFont(GetFont(FONT_STYLE_PLAIN, pText->textSize), 0, pText->pTextObject->GetTextLength());
1354         }
1355
1356         // Calculate Text element bounds
1357         if (pText->pEnrichedText == null)
1358         {
1359                 FloatDimension textDimension = pText->pTextObject->GetTextExtentF(0, pText->pTextObject->GetTextLength());
1360                 textDimension.height += 2.0f;
1361                 TextObjectAlignment textAlign = pText->pTextObject->GetAlignment();
1362
1363                 if (__itemType == LISTVIEW_ITEM_TYPE_CUSTOM)
1364                 {
1365                         if (textDimension.width < bounds.width)
1366                         {
1367                                 bounds.width = textDimension.width;
1368
1369                                 if ((0x0007 & textAlign) == TEXT_OBJECT_ALIGNMENT_CENTER)
1370                                 {
1371                                         bounds.x = rect.x + ((rect.width - bounds.width) / 2.0f);
1372                                 }
1373                                 else if ((0x0007 & textAlign) == TEXT_OBJECT_ALIGNMENT_RIGHT)
1374                                 {
1375                                         bounds.x = rect.x + (rect.width - bounds.width);
1376                                 }
1377                         }
1378                         if (textDimension.height < bounds.height)
1379                         {
1380                                 bounds.height = textDimension.height;
1381
1382                                 if ((0x0700 & textAlign) == TEXT_OBJECT_ALIGNMENT_MIDDLE)
1383                                 {
1384                                         bounds.y = rect.y + ((rect.height - bounds.height) / 2.0f);
1385                                 }
1386                                 else if ((0x0700 & textAlign) == TEXT_OBJECT_ALIGNMENT_BOTTOM)
1387                                 {
1388                                         bounds.y = rect.y + (rect.height - bounds.height);
1389                                 }
1390                         }
1391                 }
1392                 else
1393                 {
1394                         FloatDimension itemDimension = GetSizeF();
1395
1396                         if ((itemDimension.width < (bounds.x + bounds.width)) || (itemDimension.height < (bounds.y + bounds.height))
1397                                         || !_FloatCompare(bounds.width, textDimension.width) || !_FloatCompare(bounds.height, textDimension.height))
1398                         {
1399                                 TableViewAnnexStyle style = GetItemStyle();
1400                                 float annexWidth = 0.0f;
1401                                 float margin = 0.0f;
1402
1403                                 GET_SHAPE_CONFIG(LISTVIEW::ITEM_ELEMENT_LEFT_MARGIN, _CONTROL_ORIENTATION_PORTRAIT, margin);
1404
1405                                 if ((style == TABLE_VIEW_ANNEX_STYLE_DETAILED) || (style == TABLE_VIEW_ANNEX_STYLE_ONOFF_SLIDING)
1406                                                 || (style == TABLE_VIEW_ANNEX_STYLE_ONOFF_SLIDING_WITH_DIVIDER))
1407                                 {
1408                                         annexWidth = _TableViewItem::GetAnnexWidth(style);
1409                                 }
1410
1411                                 // initialize element width
1412                                 bounds.width = GetSize().width - bounds.x - annexWidth - margin;
1413
1414                                 bounds.x = rect.x;
1415                                 bounds.y = rect.y + ((rect.height - textDimension.height) / 2.0f);
1416                                 bounds.width = (bounds.width > textDimension.width) ? textDimension.width : bounds.width;
1417                                 bounds.height = textDimension.height;
1418
1419                                 rect = bounds;
1420                         }
1421                 }
1422         }
1423
1424         pText->pVE->SetBounds(bounds);
1425
1426         // Check to EnrichedText contains Cutlink
1427         if ((pText->pEnrichedText != null) && (pText->cutlinkViewModeEnabled) && (pText->cutlinkParseEnabled)
1428                         && (pText->pTextObject->GetTotalCutLinkElementCount() <= 0))
1429         {
1430                 if (ParseCutlinkText(pText))
1431                 {
1432                         pText->pTextObject->SetCutLinkViewMode(true);
1433                 }
1434         }
1435         else if (pText->pEnrichedText == null)
1436         {
1437                 if (IsItemEnabled())
1438                 {
1439                         pText->pTextObject->SetForegroundColor(pText->textColor[status], 0, pText->pTextObject->GetTextLength());
1440                 }
1441                 else
1442                 {
1443                         Color disableTextColor;
1444                         GET_COLOR_CONFIG(TABLEVIEW::ITEM_TEXT_DISABLED, disableTextColor);
1445
1446                         pText->pTextObject->SetForegroundColor(disableTextColor, 0, pText->pTextObject->GetTextLength());
1447                 }
1448         }
1449
1450         pText->pTextObject->SetAction(TEXT_OBJECT_ACTION_TYPE_ABBREV);
1451         pText->pTextObject->SetBounds(FloatRectangle(0.0f, 0.0f, bounds.width, bounds.height));
1452
1453         Canvas* pCanvas = pText->pVE->GetCanvasN();
1454         SysTryReturn(NID_UI_CTRL, (pCanvas != null), false, GetLastResult(), "[%s] Propagating.", GetErrorMessage(GetLastResult()));
1455
1456         pCanvas->SetBackgroundColor(Color(0, 0, 0, 0));
1457         pCanvas->Clear();
1458
1459         pText->pTextObject->Draw(*_CanvasImpl::GetInstance(*pCanvas));
1460
1461         delete pCanvas;
1462
1463         return true;
1464 }
1465
1466 bool
1467 _ListViewItem::DrawBitmap(FloatRectangle& rect, ListViewItemDrawingStatus status, _ListViewItemElementBitmap* pBitmap)
1468 {
1469         SysTryReturn(NID_UI_CTRL, (pBitmap != null), false, E_INVALID_ARG, "[E_INVALID_ARG] This Bitmap element is null.");
1470
1471         Bitmap* pDrawBitmap = pBitmap->pBitmap[status];
1472         if ((pDrawBitmap == null) && (status != LISTVIEW_ITEM_STATUS_NORMAL))
1473         {
1474                 pDrawBitmap = pBitmap->pBitmap[LISTVIEW_ITEM_STATUS_NORMAL];
1475         }
1476
1477         SysTryReturn(NID_UI_CTRL, (pDrawBitmap != null), false, E_INVALID_ARG, "[E_INVALID_ARG] This Bitmap element is null.");
1478
1479         if (pBitmap->pVE->GetParent() == null)
1480         {
1481                 GetVisualElement()->AttachChild(*(pBitmap->pVE));
1482                 pBitmap->pVE->SetShowState(true);
1483         }
1484
1485         pBitmap->pVE->SetBounds(rect);
1486
1487         bool isNinePatchedBitmap = _BitmapImpl::CheckNinePatchedBitmapStrictly(*pDrawBitmap);
1488         String imagePath = _BitmapImpl::GetInstance(*pDrawBitmap)->GetFileName();
1489
1490         if (!isNinePatchedBitmap && !imagePath.IsEmpty())
1491         {
1492                 pBitmap->pVE->SetBackgroundColor(_Colorf(0.0f, 0.0f, 0.0f, 0.0f));
1493                 pBitmap->pVE->SetImageSource(imagePath);
1494         }
1495         else
1496         {
1497                 pBitmap->pVE->SetImageSource(L"");
1498
1499                 Canvas* pCanvas = pBitmap->pVE->GetCanvasN();
1500                 SysTryReturn(NID_UI_CTRL, (pCanvas != null), false, GetLastResult(), "[%s] Propagating.", GetErrorMessage(GetLastResult()));
1501
1502                 pCanvas->SetBackgroundColor(Color(0, 0, 0, 0));
1503                 pCanvas->Clear();
1504
1505                 if (isNinePatchedBitmap)
1506                 {
1507                         pCanvas->DrawNinePatchedBitmap(FloatRectangle(0.0f, 0.0f, rect.width, rect.height), *pDrawBitmap);
1508                 }
1509                 else
1510                 {
1511                         pCanvas->DrawBitmap(FloatRectangle(0.0f, 0.0f, rect.width, rect.height), *pDrawBitmap);
1512                 }
1513
1514                 delete pCanvas;
1515         }
1516
1517         return true;
1518 }
1519
1520 void
1521 _ListViewItem::DrawDivider(void)
1522 {
1523         if ((__itemType == LISTVIEW_ITEM_TYPE_GROUP) && (GetItemBackgroundBitmap(LIST_ITEM_STATE_NORMAL) == null))
1524         {
1525                 float lineHeight = 0.0f;
1526                 float lineLeftMargin = 0.0f;
1527                 float lineBottomMargin = 0.0f;
1528                 float lineTopMargin = 0.0f;
1529                 GET_SHAPE_CONFIG(LISTVIEW::GROUPITEM_DIVIDER_HEIGHT, _CONTROL_ORIENTATION_PORTRAIT, lineHeight);
1530                 GET_SHAPE_CONFIG(LISTVIEW::GROUPITEM_DIVIDER_LEFT_MARGIN, _CONTROL_ORIENTATION_PORTRAIT, lineLeftMargin);
1531                 GET_SHAPE_CONFIG(LISTVIEW::GROUPITEM_DIVIDER_BOTTOM_MARGIN, _CONTROL_ORIENTATION_PORTRAIT, lineBottomMargin);
1532
1533                 FloatRectangle textBounds;
1534                 FloatRectangle bitmapBounds;
1535                 _ListViewItemElementText* pElementText = GetElementText(LIST_ITEM_RESERVED_ID_3);
1536                 _ListViewItemElementBitmap* pElementBitmap = GetElementBitmap(LIST_ITEM_RESERVED_ID_2);
1537
1538                 if ((pElementText != null) && (pElementText->pVE != null))
1539                 {
1540                         textBounds = pElementText->pVE->GetBounds();
1541                 }
1542
1543                 if ((pElementBitmap != null) && (pElementBitmap->pVE != null))
1544                 {
1545                         bitmapBounds = pElementBitmap->pVE->GetBounds();
1546                 }
1547
1548                 float textBottomPos = textBounds.y + textBounds.height;
1549                 float bitmapBottomPos = bitmapBounds.y + bitmapBounds.height;
1550
1551                 lineTopMargin = (textBottomPos > bitmapBottomPos) ? textBottomPos : bitmapBottomPos;
1552
1553                 FloatRectangle bounds = GetBoundsF();
1554                 float defaultMargin = bounds.height - lineBottomMargin;
1555                 lineTopMargin = (lineTopMargin > defaultMargin) ? lineTopMargin : defaultMargin;
1556
1557                 if (bounds.height <= lineTopMargin)
1558                 {
1559                         return;
1560                 }
1561
1562                 if (__pDivider == null)
1563                 {
1564                         __pDivider = _Label::CreateLabelN();
1565                         SysTryReturnVoidResult(NID_UI_CTRL, __pDivider != null, E_OUT_OF_MEMORY, "[%s] Propagating.", GetErrorMessage(GetLastResult()));
1566
1567                         AttachSystemChild(*__pDivider);
1568
1569                         _AccessibilityContainer* pContainer = __pDivider->GetAccessibilityContainer();
1570                         if (pContainer != null)
1571                         {
1572                                 pContainer->Activate(false);
1573                         }
1574                 }
1575
1576                 Color underLineColor;
1577                 GET_COLOR_CONFIG(TABLEVIEW::GROUPITEM_INDEX_BAR_NORMAL, underLineColor);
1578
1579                 __pDivider->SetBounds(FloatRectangle(lineLeftMargin, lineTopMargin, bounds.width - lineLeftMargin * 2.0f, lineHeight));
1580                 __pDivider->SetBackgroundColor(underLineColor);
1581                 __pDivider->Invalidate();
1582         }
1583 }
1584
1585 void
1586 _ListViewItem::StartTextSlideTimer(void)
1587 {
1588         result r = E_SUCCESS;
1589
1590         if (__pTextSlideTimer == null)
1591         {
1592                 __pTextSlideTimer = new (std::nothrow) Timer();
1593
1594                 r = __pTextSlideTimer->Construct(*this);
1595                 SysTryCatch(NID_UI, (r == E_SUCCESS), ,E_SYSTEM, ("[E_SYSTEM] Timer cannot construct."));
1596         }
1597         else
1598         {
1599                 __pTextSlideTimer->Cancel();
1600         }
1601
1602         r = __pTextSlideTimer->Start(TEXT_SLIDING_TIMER_DURATION);
1603         SysTryCatch(NID_UI, (r == E_SUCCESS), , E_SYSTEM, ("[E_SYSTEM] Timer Start failed."));
1604
1605         return;
1606
1607 CATCH:
1608         StopTextSlideTimer();
1609 }
1610
1611 void
1612 _ListViewItem::StopTextSlideTimer(void)
1613 {
1614         delete __pTextSlideTimer;
1615         __pTextSlideTimer = null;
1616 }
1617
1618 bool
1619 _ListViewItem::IsTextSlideTimerRunning(void)
1620 {
1621         return (__pTextSlideTimer != null);
1622 }
1623
1624 void
1625 _ListViewItem::OnTextSlideTimerExpired(void)
1626 {
1627         if (__selectedElementId != -1)
1628         {
1629                 _ListViewItemElement* pElement = GetElement(__selectedElementId);
1630
1631                 if ((pElement != null) && (pElement->pTextElement->pTextObject != null))
1632                 {
1633                         TextObject* pTextObject = pElement->pTextElement->pTextObject;
1634
1635                         Canvas* pCanvas = (pElement->pTextElement->pVE)->GetCanvasN();
1636                         SysTryReturnVoidResult(NID_UI_CTRL, (pCanvas != null), GetLastResult(), "[%s] Propagating.", GetErrorMessage(GetLastResult()));
1637
1638                         pCanvas->SetBackgroundColor(Color(0, 0, 0, 0));
1639                         pCanvas->Clear();
1640
1641                         pTextObject->SetForegroundColor(pElement->pTextElement->textColor[LISTVIEW_ITEM_STATUS_PRESSED], 0, pTextObject->GetTextLength());
1642                         pTextObject->SetAction(TEXT_OBJECT_ACTION_TYPE_SLIDE_LEFT);
1643                         pTextObject->Compose();
1644                         if (pTextObject->DrawWithOffset(*_CanvasImpl::GetInstance(*pCanvas)) == E_SUCCESS)
1645                         {
1646                                 pCanvas->Show(_CoordinateSystemUtils::ConvertToInteger(pElement->bounds));
1647                                 StartTextSlideTimer();
1648                         }
1649                         else
1650                         {
1651                                 Invalidate();
1652                         }
1653
1654                         delete pCanvas;
1655                         pCanvas = null;
1656                 }
1657         }
1658 }
1659
1660 void
1661 _ListViewItem::ResetTextSlide(void)
1662 {
1663         if (IsTextSlideTimerRunning())
1664         {
1665                 StopTextSlideTimer();
1666
1667                 _ListViewItemElement* pElement = GetElement(__selectedElementId);
1668
1669                 if ((pElement != null) && (pElement->pTextElement->pTextObject != null))
1670                 {
1671                         pElement->pTextElement->pTextObject->SetAction(TEXT_OBJECT_ACTION_TYPE_ABBREV);
1672                         pElement->pTextElement->pTextObject->SetForegroundColor(pElement->pTextElement->textColor[LISTVIEW_ITEM_STATUS_NORMAL],
1673                                         0, pElement->pTextElement->pTextObject->GetTextLength());
1674                 }
1675         }
1676 }
1677
1678 void
1679 _ListViewItem::OnTimerExpired(Timer& timer)
1680 {
1681         _TableViewItem::OnTimerExpired(timer);
1682
1683         if (&timer == __pTextSlideTimer)
1684         {
1685                 OnTextSlideTimerExpired();
1686         }
1687 }
1688
1689 bool
1690 _ListViewItem::ParseCutlinkText(_ListViewItemElementText* pElementText)
1691 {
1692         if ((pElementText == null) || (pElementText->pEnrichedText == null))
1693         {
1694                 return false;
1695         }
1696
1697         TextObject* pTextObject = pElementText->pTextObject;
1698         unsigned long cutlinkMaskType = pElementText->cutlinkMaskType;
1699         TextLinkInfo* pTextLinkInfo = null;
1700         TextLinkInfo* pNextLinkInfo = null;
1701         int currentOffset = 0;
1702         bool isChangingCutlink = false;
1703         wchar_t* pCutlinkString = null;
1704         bool ret = true;
1705
1706         int strLength = pTextObject->GetTextLength();
1707         wchar_t* pStr = new (std::nothrow) wchar_t[strLength + 1];
1708         SysTryReturn(NID_UI, (pStr != null), false, E_OUT_OF_MEMORY, ("[E_OUT_OF_MEMORY] The memory is insufficient."));
1709
1710         pTextObject->GetText(pStr, strLength);
1711
1712         TextCutLinkParser* pParser = new (std::nothrow) TextCutLinkParser();
1713         SysTryCatch(NID_UI, (pParser != null), (ret = false), E_OUT_OF_MEMORY, ("[E_OUT_OF_MEMORY] The memory is insufficient."));
1714
1715         pParser->SetCutLinkMask(cutlinkMaskType);
1716
1717         pTextLinkInfo = pParser->Parse(pStr, strLength, 0);
1718         SysTryCatch(NID_UI, (pTextLinkInfo != null), (ret = false), E_SYSTEM, ("[E_SYSTEM] TextLinkInfo is not valid."));
1719
1720         // remove all text element in _EnrichedTextImpl
1721         pElementText->pEnrichedText->RemoveAllTextElements(true);
1722         //pTextObject->RemoveAll(true);
1723
1724         while (pTextLinkInfo != null)
1725         {
1726                 isChangingCutlink = false;
1727
1728                 switch (pTextLinkInfo->linkType)
1729                 {
1730                 case LINK_TYPE_URL:
1731                         if (cutlinkMaskType & LINK_TYPE_URL)
1732                         {
1733                                 isChangingCutlink = true;
1734                         }
1735                         break;
1736
1737                 case LINK_TYPE_EMAIL:
1738                         if (cutlinkMaskType & LINK_TYPE_EMAIL)
1739                         {
1740                                 isChangingCutlink = true;
1741                         }
1742                         break;
1743
1744                 case LINK_TYPE_TEL_NUM:
1745                         if (cutlinkMaskType & LINK_TYPE_TEL_NUM)
1746                         {
1747                                 isChangingCutlink = true;
1748                         }
1749                         break;
1750
1751                 case LINK_TYPE_APPCONTROL:
1752                         if (cutlinkMaskType & LINK_TYPE_APPCONTROL)
1753                         {
1754                                 isChangingCutlink = true;
1755                         }
1756                         break;
1757
1758                 case LINK_TYPE_MIME:
1759                         if (cutlinkMaskType & LINK_TYPE_MIME)
1760                         {
1761                                 isChangingCutlink = true;
1762                         }
1763                         break;
1764
1765                 default:
1766                         break;
1767                 }
1768
1769                 pCutlinkString = new (std::nothrow) wchar_t[pTextLinkInfo->length + 1];
1770
1771                 if (pCutlinkString == null)
1772                 {
1773                         while (pTextLinkInfo != null)
1774                         {
1775                                 pNextLinkInfo = pTextLinkInfo->pNextLinkInfo;
1776                                 delete pTextLinkInfo;
1777                                 pTextLinkInfo = pNextLinkInfo;
1778                         }
1779                         SysTryCatch(NID_UI, (pTextLinkInfo != null), (ret = false), E_SYSTEM, ("[E_SYSTEM] TextLinkInfo is not valid."));
1780                 }
1781
1782                 for (int i = 0; i < pTextLinkInfo->length; i++)
1783                 {
1784                         pCutlinkString[i] = pStr[pTextLinkInfo->srcOffset + i];
1785                 }
1786
1787                 pCutlinkString[pTextLinkInfo->length] = null;
1788
1789                 if (currentOffset < pTextLinkInfo->srcOffset)
1790                 {
1791                         TextSimple* pSimpleText = new (std::nothrow) TextSimple(pStr + currentOffset, pTextLinkInfo->srcOffset - currentOffset);
1792                         pTextObject->AppendElement(*pSimpleText);
1793                 }
1794
1795                 if (isChangingCutlink == true)
1796                 {
1797                         TextCutLink* pTextElement = new (std::nothrow) TextCutLink(false, pTextLinkInfo->linkType, pStr + pTextLinkInfo->srcOffset,
1798                                                                                                                                            pTextLinkInfo->length);
1799                         pTextElement->SetEditModeEnable(true);
1800                         pTextObject->AppendElement(*pTextElement);
1801                 }
1802                 else
1803                 {
1804                         TextSimple* pSimpleText = new (std::nothrow) TextSimple(pCutlinkString, pTextLinkInfo->length);
1805                         pTextObject->AppendElement(*pSimpleText);
1806                 }
1807
1808                 currentOffset = pTextLinkInfo->srcOffset + pTextLinkInfo->length;
1809
1810                 pNextLinkInfo = pTextLinkInfo->pNextLinkInfo;
1811                 delete pTextLinkInfo;
1812                 pTextLinkInfo = pNextLinkInfo;
1813
1814                 delete[] pCutlinkString;
1815                 pCutlinkString = null;
1816         }
1817
1818         if (strLength != currentOffset)
1819         {
1820                 TextSimple* pSimpleText = new (std::nothrow) TextSimple(pStr + currentOffset, strLength - currentOffset);
1821                 pTextObject->AppendElement(*pSimpleText);
1822         }
1823
1824         //pTextObject->SetRange(0, pTextObject->GetLength());
1825         //pTextObject->NotifyTextChanged(0, pTextObject->GetLength());
1826         pTextObject->Compose();
1827
1828 CATCH:
1829         delete pParser;
1830         pParser = null;
1831
1832         if (pStr != null)
1833         {
1834                 delete[] pStr;
1835                 pStr = null;
1836         }
1837
1838         return ret;
1839 }
1840
1841 bool
1842 _ListViewItem::IsCutlinkTextSelected(const FloatPoint& position, int* index, _ListViewItemUiLinkInfo** ppInfo) const
1843 {
1844         int elementId = GetElementIdFromPosition(position);
1845         _ListViewItemElementText* pElement = GetElementText(elementId);
1846
1847         if ((pElement != null) && (pElement->pTextObject) && (pElement->cutlinkViewModeEnabled))
1848         {
1849                 TextObject* pTextObject = pElement->pTextObject;
1850                 FloatRectangle displayRect = pTextObject->GetBoundsF();
1851                 int selectedIndex = pTextObject->GetCutLinkIndexFromPositionData(position.x - displayRect.x, position.y - displayRect.y);
1852
1853                 if (selectedIndex >= 0)
1854                 {
1855                         *index = selectedIndex;
1856                         TextCutLink* pCutLinkObject = dynamic_cast<TextCutLink*>(pTextObject->GetCutLinkElementAtCutLinkElementIndex(selectedIndex));
1857                         if (pCutLinkObject == null)
1858                         {
1859                                 return false;
1860                         }
1861
1862                         String cutLinkString(pCutLinkObject->GetText());
1863                         LinkType baseLinkType = pCutLinkObject->GetCutLinkType();
1864
1865                         if (baseLinkType & pElement->cutlinkMaskType)
1866                         {
1867                                 _ListViewItemUiLinkInfo* pUiLinkInfo = new (std::nothrow) _ListViewItemUiLinkInfo();
1868
1869                                 pUiLinkInfo->textInfo = cutLinkString;
1870                                 pUiLinkInfo->linkType = baseLinkType;
1871                                 pUiLinkInfo->linkInfo = cutLinkString;
1872
1873                                 *ppInfo = pUiLinkInfo;
1874                         }
1875                 }
1876
1877                 return true;
1878         }
1879
1880         return false;
1881 }
1882
1883 bool
1884 _ListViewItem::SetCutlinkTextFocus(const FloatPoint& position)
1885 {
1886         int elementId = GetElementIdFromPosition(position);
1887         _ListViewItemElementText* pElement = GetElementText(elementId);
1888
1889         if ((pElement != null) && (pElement->pTextObject != null) && (pElement->cutlinkViewModeEnabled))
1890         {
1891                 TextObject* pTextObject = pElement->pTextObject;
1892                 FloatRectangle displayRect = pTextObject->GetBoundsF();
1893
1894                 int index = pTextObject->GetCutLinkIndexFromPositionData(position.x - displayRect.x, position.y - displayRect.y);
1895
1896                 if (index >= 0)
1897                 {
1898                         pTextObject->ChangeCutLinkState(index, true);
1899                         return true;
1900                 }
1901         }
1902
1903         return false;
1904 }
1905
1906 bool
1907 _ListViewItem::ResetCutlinkFocus(void)
1908 {
1909         _LinkedList <_ListViewItemElement>::_Iterator iter;
1910
1911         for (iter = __elements.begin(); iter != __elements.end(); iter++)
1912         {
1913                 if ((iter->elementType == LISTVIEW_ITEM_ELEMENT_TEXT) && (iter->pTextElement->pTextObject))
1914                 {
1915                         iter->pTextElement->pTextObject->ResetAllCutLinkElementsState();
1916                 }
1917         }
1918
1919         return true;
1920 }
1921
1922 Font*
1923 _ListViewItem::GetFont(unsigned long fontStyle, float fontSize)
1924 {
1925         __fontStyle = fontStyle;
1926         __fontSize = fontSize;
1927
1928         return GetFallbackFont();
1929 }
1930
1931 void
1932 _ListViewItem::OnFontChanged(Font* pFont)
1933 {
1934         __fontName = _Control::GetFont();
1935
1936         if (__pDescriptionText != null)
1937         {
1938                 __pDescriptionText->SetFont(__fontName);
1939         }
1940
1941         if (GetContextItem() != null)
1942         {
1943                 GetContextItem()->SetFont(__fontName);
1944         }
1945 }
1946
1947 void
1948 _ListViewItem::OnFontInfoRequested(unsigned long& style, int& size)
1949 {
1950         style = __fontStyle;
1951         size = _CoordinateSystemUtils::ConvertToInteger(__fontSize);
1952 }
1953
1954 void
1955 _ListViewItem::OnFontInfoRequested(unsigned long& style, float& size)
1956 {
1957         style = __fontStyle;
1958         size =  __fontSize;
1959 }
1960
1961 bool
1962 CompareAccessibilityElement(_ListViewItemElement* a, _ListViewItemElement* b)
1963 {
1964         if (_FloatCompare(a->bounds.y, b->bounds.y))
1965         {
1966                 return (a->bounds.x < b->bounds.x);
1967         }
1968
1969         return (a->bounds.y < b->bounds.y);
1970 }
1971
1972 void
1973 _ListViewItem::SetAccessibilityElement(void)
1974 {
1975         _AccessibilityContainer* pContainer = GetAccessibilityContainer();
1976
1977         if (pContainer != null)
1978         {
1979                 if (__pAccessibilityElement == null)
1980                 {
1981                         __pAccessibilityElement = new (std::nothrow) _AccessibilityElement(true);
1982                         SysTryReturnVoidResult(NID_UI_CTRL, (__pAccessibilityElement != null), E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] The memory is insufficient.");
1983
1984                         pContainer->AddElement(*__pAccessibilityElement);
1985                 }
1986
1987                 __pAccessibilityElement->SetBounds(FloatRectangle(0.0f, 0.0f, GetBoundsF().width, GetBoundsF().height));
1988         }
1989 }
1990 void
1991 _ListViewItem::SetAccessibilityElementTrait(void)
1992 {
1993         if(__pAccessibilityElement == null)
1994         {
1995                 return;
1996         }
1997         int groupIndex = -1;
1998         int itemIndex = -1;
1999
2000         switch (GetItemStyle())
2001         {
2002         case TABLE_VIEW_ANNEX_STYLE_NORMAL:
2003                 GetItemIndex(groupIndex, itemIndex);
2004                 if(groupIndex != -1 && itemIndex == -1)
2005                 {
2006                         __pAccessibilityElement->SetTraitWithStringId("IDS_TPLATFORM_BODY_GROUP_INDEX");
2007                 }
2008                 break;
2009
2010         case TABLE_VIEW_ANNEX_STYLE_MARK:
2011                 __pAccessibilityElement->SetTraitWithStringId("IDS_TPLATFORM_BODY_TICKBOX_T_TTS");
2012                 break;
2013
2014         case TABLE_VIEW_ANNEX_STYLE_ONOFF_SLIDING:
2015         case TABLE_VIEW_ANNEX_STYLE_ONOFF_SLIDING_WITH_DIVIDER:
2016                 __pAccessibilityElement->SetTraitWithStringId("IDS_TPLATFORM_BODY_ON_OFF_BUTTON_T_TTS");
2017                 break;
2018
2019         case TABLE_VIEW_ANNEX_STYLE_DETAILED:
2020                 __pAccessibilityElement->SetTraitWithStringId("IDS_TPLATFORM_BODY_BUTTON_T_TTS");
2021                 break;
2022
2023         case TABLE_VIEW_ANNEX_STYLE_RADIO:
2024                 __pAccessibilityElement->SetTraitWithStringId("IDS_TPLATFORM_BODY_RADIO_BUTTON_T_TTS");
2025                 break;
2026
2027         default:
2028                 break;
2029         }
2030 }
2031 void
2032 _ListViewItem::SetAccessibilityElementValue(void)
2033 {
2034         if(__pAccessibilityElement == null)
2035         {
2036                 return;
2037         }
2038
2039         switch (GetItemStyle())
2040         {
2041         case TABLE_VIEW_ANNEX_STYLE_MARK:
2042                 if (IsChecked())
2043                 {
2044                         __pAccessibilityElement->SetValueWithStringId("IDS_TPLATFORM_BODY_TICK_T_TTS");
2045                 }
2046                 else
2047                 {
2048                         __pAccessibilityElement->SetValueWithStringId("IDS_TPLATFORM_BODY_UNTICK_T_TTS");
2049                 }
2050                 break;
2051
2052         case TABLE_VIEW_ANNEX_STYLE_ONOFF_SLIDING:
2053         case TABLE_VIEW_ANNEX_STYLE_ONOFF_SLIDING_WITH_DIVIDER:
2054                 if (IsChecked())
2055                 {
2056                         __pAccessibilityElement->SetValueWithStringId("IDS_TPLATFORM_BODY_ON");
2057                 }
2058                 else
2059                 {
2060                         __pAccessibilityElement->SetValueWithStringId("IDS_TPLATFORM_BODY_OFF");
2061                 }
2062                 break;
2063
2064         case TABLE_VIEW_ANNEX_STYLE_RADIO:
2065                 if (IsChecked())
2066                 {
2067                         __pAccessibilityElement->SetValueWithStringId("IDS_TPLATFORM_BODY_SELECTED_T_TTS");
2068                 }
2069                 else
2070                 {
2071                         __pAccessibilityElement->SetValue(L"Unselected");
2072                 }
2073                 break;
2074
2075         default:
2076                 break;
2077         }
2078 }
2079 void
2080 _ListViewItem::SetAccessibilityElementLabel(void)
2081 {
2082         if(__pAccessibilityElement == null)
2083         {
2084                 return;
2085         }
2086         if(__pAccessibilityElement->GetLabel().GetLength() > 0)
2087         {
2088                 return;
2089         }
2090         _LinkedList <_ListViewItemElement*> accessibilityElementList;
2091         _LinkedList <_ListViewItemElement>::_Iterator iter;
2092         _LinkedList <_ListViewItemElement*>::_Iterator accessibilityIter;
2093         _ListViewItemElement* pElement = null;
2094         String accessibilityName;
2095         String accessibilityLabel;
2096         int groupIndex = -1;
2097         int itemIndex = -1;
2098
2099         // accessibility element name
2100         GetItemIndex(groupIndex, itemIndex);
2101
2102         if (__itemType == LISTVIEW_ITEM_TYPE_GROUP)
2103         {
2104                 accessibilityName = L"GroupIndex" + Integer::ToString(groupIndex);
2105         }
2106         else
2107         {
2108                 accessibilityName = L"ListViewItem" + Integer::ToString(groupIndex) + L"_" + Integer::ToString(itemIndex);
2109         }
2110
2111         // accessibility element label
2112         for (iter = __elements.begin(); iter != __elements.end(); iter++)
2113         {
2114                 if ((iter->elementType == LISTVIEW_ITEM_ELEMENT_TEXT) || (iter->elementType == LISTVIEW_ITEM_ELEMENT_BITMAP))
2115                 {
2116                         accessibilityElementList.push_back(&(*iter));
2117                 }
2118         }
2119
2120         accessibilityElementList.sort(CompareAccessibilityElement);
2121
2122         for (accessibilityIter = accessibilityElementList.begin(); accessibilityIter != accessibilityElementList.end(); accessibilityIter++)
2123         {
2124                 pElement = *accessibilityIter;
2125
2126                 if (pElement->elementType == LISTVIEW_ITEM_ELEMENT_TEXT)
2127                 {
2128                         int textLength = pElement->pTextElement->pTextObject->GetTextLength();
2129
2130                         if (textLength > 0)
2131                         {
2132                                 wchar_t* pAccessibilityText = new (std::nothrow) wchar_t[textLength + 1];
2133                                 SysTryReturnVoidResult(NID_UI_CTRL, (pAccessibilityText != null), E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] The memory is insufficient.");
2134
2135                                 pElement->pTextElement->pTextObject->GetText(pAccessibilityText, textLength);
2136
2137                                 accessibilityLabel += String(pAccessibilityText);
2138                                 accessibilityLabel += L", ";
2139
2140                                 delete[] pAccessibilityText;
2141                         }
2142                 }
2143                 else if (pElement->elementType == LISTVIEW_ITEM_ELEMENT_BITMAP)
2144                 {
2145                         accessibilityLabel += L"Icon, ";
2146                 }
2147         }
2148
2149         accessibilityElementList.clear();
2150
2151         if (accessibilityLabel.IsEmpty())
2152         {
2153                 accessibilityLabel = L"ListViewItem";
2154         }
2155
2156         if (__descriptionTextShowState)
2157         {
2158                 String descriptionText = __pDescriptionText->GetText();
2159                 accessibilityLabel += ((descriptionText.GetLength() > 0) ? (L", " + descriptionText + L"") : L"");
2160         }
2161         __pAccessibilityElement->SetName(accessibilityName);
2162         __pAccessibilityElement->SetLabel(accessibilityLabel);
2163 }
2164
2165 result
2166 _ListViewItem::OnAttachedToMainTree(void)
2167 {
2168         if((GetParent() != null) && (GetParent()->GetAccessibilityContainer() != null))
2169         {
2170                 GetParent()->GetAccessibilityContainer()->AddChildContainer(*GetAccessibilityContainer());
2171         }
2172
2173         return _TableViewItem::OnAttachedToMainTree();
2174 }
2175
2176 result
2177 _ListViewItem::OnDetachingFromMainTree(void)
2178 {
2179         if((GetParent() != null) && (GetParent()->GetAccessibilityContainer() != null))
2180         {
2181                 GetParent()->GetAccessibilityContainer()->RemoveChildContainer(*GetAccessibilityContainer());
2182         }
2183
2184         return _Control::OnDetachingFromMainTree();
2185 }
2186
2187 _ListViewItemHitTestVEDelegator::_ListViewItemHitTestVEDelegator(void)
2188 {
2189 }
2190
2191 _ListViewItemHitTestVEDelegator::~_ListViewItemHitTestVEDelegator(void)
2192 {
2193 }
2194
2195 HitTestResult
2196 _ListViewItemHitTestVEDelegator::HitTest(VisualElement& target, const FloatPoint& point)
2197 {
2198         return HIT_TEST_NOWHERE;
2199 }
2200
2201 }}} // Tizen::Ui::Controls