src/ui/controls/FUiCtrl_Tab.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_Tab.cpp
  20  * @brief               This is the implementation file for the _Tab class.
  21  */
  22
  23 #include <FBaseErrorDefine.h>
  24 #include <FBaseSysLog.h>
  25 #include <FGrp_BitmapImpl.h>
  26 #include "FUi_ResourceManager.h"
  27 #include "FUi_UiTouchEvent.h"
  28 #include "FUi_AccessibilityContainer.h"
  29 #include "FUi_AccessibilityElement.h"
  30 #include "FUi_TouchLongPressGestureDetector.h"
  31 #include "FUiCtrl_Tab.h"
  32 #include "FUi_CoordinateSystemUtils.h"
  33
  34 using namespace Tizen::Base;
  35 using namespace Tizen::Graphics;
  36 using namespace Tizen::Base::Runtime;
  37
  38 namespace Tizen { namespace Ui { namespace Controls {
  39
  40 _Tab::_Tab(void)
  41         : __pTabPresenter(null)
  42         , __style(_TAB_STYLE_TEXT)
  43         , __currentHighlightedItemIndex(-1)
  44         , __tabStatus(_TAB_STATUS_NORMAL)
  45         , __pActionEvent(null)
  46         , __pGestureLongPress(null)
  47         , __pFlickGesture(null)
  48         , __pBackgroundBitmap(null)
  49         , __pDisabledBackgroundBitmap(null)
  50         , __pPressedItemBackgroundBitmap(null)
  51         , __pPressedItemBackgroundEffectBitmap(null)
  52         , __pSelectedItemBackgroundBitmap(null)
  53         , __pHighlightedItemBackgroundBitmap(null)
  54 {
  55         ClearLastResult();
  56         result r = E_SUCCESS;
  57
  58         __tabItems.Construct();
  59
  60         GET_COLOR_CONFIG(TAB::ITEM_BG_NORMAL, __itemBgColor[_TAB_STATUS_NORMAL]);
  61         GET_COLOR_CONFIG(TAB::ITEM_BG_PRESSED, __itemBgColor[_TAB_STATUS_PRESSED]);
  62         GET_COLOR_CONFIG(TAB::ITEM_BG_SELECTED, __itemBgColor[_TAB_STATUS_SELECTED]);
  63         GET_COLOR_CONFIG(TAB::ITEM_BG_HIGHLIGHTED, __itemBgColor[_TAB_STATUS_HIGHLIGHTED]);
  64         GET_COLOR_CONFIG(TAB::ITEM_BG_DISABLED, __itemBgColor[_TAB_STATUS_DISABLED]);
  65
  66         GET_COLOR_CONFIG(TAB::ITEM_TEXT_NORMAL, __itemTextColor[_TAB_STATUS_NORMAL]);
  67         GET_COLOR_CONFIG(TAB::ITEM_TEXT_PRESSED, __itemTextColor[_TAB_STATUS_PRESSED]);
  68         GET_COLOR_CONFIG(TAB::ITEM_TEXT_SELECTED, __itemTextColor[_TAB_STATUS_SELECTED]);
  69         GET_COLOR_CONFIG(TAB::ITEM_TEXT_HIGHLIGHTED, __itemTextColor[_TAB_STATUS_HIGHLIGHTED]);
  70         GET_COLOR_CONFIG(TAB::ITEM_TEXT_DISABLED, __itemTextColor[_TAB_STATUS_DISABLED]);
  71
  72         r = LoadBitmap();
  73         SysTryReturnVoidResult(NID_UI_CTRL, r == E_SUCCESS, E_SYSTEM, "[E_SYSTEM] A system error has occurred. Failed to load bitmap.");
  74
  75         _Control::SetResizable(false);
  76         _Control::SetMovable(false);
  77
  78         _TabPresenter* pPresenter = new (std::nothrow) _TabPresenter;
  79         SysTryReturnVoidResult(NID_UI_CTRL, pPresenter, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] Memory allocation failed.");
  80
  81         r = SetPresenter(*pPresenter);
  82         SysTryReturnVoidResult(NID_UI_CTRL, r == E_SUCCESS, E_SYSTEM, "[E_SYSTEM] A system error has occurred. The _TabPresenter instance could not be set.");
  83
  84         r = pPresenter->Construct(*this);
  85         SysTryReturnVoidResult(NID_UI_CTRL, r == E_SUCCESS, E_SYSTEM, "[E_SYSTEM] A system error has occurred. The _TabPresenter instance construct failed.");
  86
  87 }
  88
  89 _Tab::~_Tab(void)
  90 {
  91         delete __pTabPresenter;
  92         __pTabPresenter = null;
  93
  94         if (__pActionEvent)
  95         {
  96                 delete __pActionEvent;
  97                 __pActionEvent = null;
  98         }
  99
 100         __tabItems.RemoveAll(true);
 101
 102         if (__pFlickGesture != null)
 103         {
 104                 __pFlickGesture->RemoveGestureListener(*this);
 105                 RemoveGestureDetector(*__pFlickGesture);
 106
 107                 delete __pFlickGesture;
 108                 __pFlickGesture = null;
 109         }
 110
 111         if (__pGestureLongPress != null)
 112         {
 113                 __pGestureLongPress->RemoveGestureListener(*this);
 114                 RemoveGestureDetector(*__pGestureLongPress);
 115
 116                 delete __pGestureLongPress;
 117                 __pGestureLongPress = null;
 118         }
 119
 120         if (__pBackgroundBitmap)
 121         {
 122                 delete __pBackgroundBitmap;
 123                 __pBackgroundBitmap = null;
 124         }
 125
 126         if (__pDisabledBackgroundBitmap)
 127         {
 128                 delete __pDisabledBackgroundBitmap;
 129                 __pDisabledBackgroundBitmap = null;
 130         }
 131
 132         if (__pPressedItemBackgroundBitmap)
 133         {
 134                 delete __pPressedItemBackgroundBitmap;
 135                 __pPressedItemBackgroundBitmap = null;
 136         }
 137
 138         if (__pPressedItemBackgroundEffectBitmap)
 139         {
 140                 delete __pPressedItemBackgroundEffectBitmap;
 141                 __pPressedItemBackgroundEffectBitmap = null;
 142         }
 143
 144         if (__pSelectedItemBackgroundBitmap)
 145         {
 146                 delete __pSelectedItemBackgroundBitmap;
 147                 __pSelectedItemBackgroundBitmap = null;
 148         }
 149
 150         if (__pHighlightedItemBackgroundBitmap)
 151         {
 152                 delete __pHighlightedItemBackgroundBitmap;
 153                 __pHighlightedItemBackgroundBitmap = null;
 154         }
 155
 156         RemoveAllAccessibilityElement();
 157 }
 158
 159 _Tab*
 160 _Tab::CreateTabN(void)
 161 {
 162         result r = E_SUCCESS;
 163
 164         _Tab* pTab = new (std::nothrow) _Tab;
 165         SysTryReturn(NID_UI_CTRL, pTab, null, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] Memory allocation failed.");
 166
 167         if (IsFailed(GetLastResult()))
 168         {
 169                 goto CATCH;
 170         }
 171
 172         pTab->AcquireHandle();
 173
 174         pTab->__pGestureLongPress = new (std::nothrow) _TouchLongPressGestureDetector;
 175         SysTryCatch(NID_UI_CTRL, pTab->__pGestureLongPress, , E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] Memory allocation failed.");
 176
 177         pTab->__pGestureLongPress->SetDuration(500);
 178         pTab->AddGestureDetector(*(pTab->__pGestureLongPress));
 179         r = pTab->__pGestureLongPress->AddGestureListener(*pTab);
 180         SysTryCatch(NID_UI_CTRL, (r == E_SUCCESS), , r = E_SYSTEM, "[E_SYSTEM] A system error has occurred. The _ITouchGestureEventListener instance could not be set.");
 181
 182         pTab->__pFlickGesture = new (std::nothrow) _TouchFlickGestureDetector;
 183         SysTryCatch(NID_UI_CTRL, pTab->__pFlickGesture, , E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] Memory allocation failed.");
 184
 185         r = pTab->AddGestureDetector(*(pTab->__pFlickGesture));
 186         SysTryCatch(NID_UI_CTRL, r == E_SUCCESS, , r, "[%s] Propagating", GetErrorMessage(r));
 187
 188         r = pTab->__pFlickGesture->AddGestureListener(*pTab);
 189         SysTryCatch(NID_UI_CTRL, (r == E_SUCCESS), , r = E_SYSTEM, "[E_SYSTEM] A system error has occurred. The _ITouchGestureEventListener instance could not be set.");
 190
 191         return pTab;
 192
 193 CATCH:
 194         if (pTab->__pGestureLongPress != null)
 195         {
 196                 pTab->__pGestureLongPress->RemoveGestureListener(*pTab);
 197                 pTab->RemoveGestureDetector(*pTab->__pGestureLongPress);
 198
 199                 delete pTab->__pGestureLongPress;
 200                 pTab->__pGestureLongPress = null;
 201         }
 202         if (pTab->__pFlickGesture != null)
 203         {
 204                 pTab->__pFlickGesture->RemoveGestureListener(*pTab);
 205                 pTab->RemoveGestureDetector(*pTab->__pFlickGesture);
 206
 207                 delete pTab->__pFlickGesture;
 208                 pTab->__pFlickGesture = null;
 209         }
 210
 211         delete pTab;
 212         return null;
 213 }
 214
 215 result
 216 _Tab::SetPresenter(const _TabPresenter& tabPresenter)
 217 {
 218         ClearLastResult();
 219         __pTabPresenter = const_cast<_TabPresenter*>(&tabPresenter);
 220
 221         return E_SUCCESS;
 222 }
 223
 224 result
 225 _Tab::AddItem(const Bitmap& icon, const String& text, int actionId)
 226 {
 227         if (actionId < _TAB_ACTION_ID_MIN || actionId > _TAB_ACTION_ID_MAX)
 228         {
 229                 SysLog(NID_UI_CTRL, "[E_OUT_OF_RANGE] The actionId (%d) is out of range.", actionId);
 230                 return E_OUT_OF_RANGE;
 231         }
 232
 233         if (!((__style == _TAB_STYLE_TEXT) || (__style == _TAB_STYLE_ICON_TEXT)))
 234         {
 235                 return E_SYSTEM;
 236         }
 237
 238         __style = _TAB_STYLE_ICON_TEXT;
 239
 240         bool isDuplicate = CheckDuplicatedActionId(actionId);
 241         SysTryReturnResult(NID_UI_CTRL, isDuplicate == false, E_SYSTEM, "A system error has occurred. The tab already has an item with same action id (%d).", actionId);
 242
 243         int itemCount = __tabItems.GetCount();
 244
 245         SysTryReturnResult(NID_UI_CTRL, itemCount < _TAB_ITEM_MAXCOUNT, E_SYSTEM, "A system error has occurred. The tab has maximum number of items.");
 246
 247         _TabItem *pItem = new (std::nothrow) _TabItem;
 248         SysTryReturnResult(NID_UI_CTRL, pItem != null, E_OUT_OF_MEMORY, "Memory allocation failed.");
 249
 250         pItem->SetIcon(icon);
 251         pItem->SetText(text);
 252         pItem->SetActionId(actionId);
 253         pItem->SetUpdateState(true);
 254
 255         if (itemCount > 0)
 256         {
 257                 pItem->SetStatus(_TABITEM_STATUS_NORMAL);
 258         }
 259         else
 260         {
 261                 pItem->SetStatus(_TABITEM_STATUS_SELECTED);
 262         }
 263
 264         __pTabPresenter->SetRecalculateItemBounds(true);
 265
 266         if (__pTabPresenter->GetItemStatus(__currentHighlightedItemIndex) == _TABITEM_STATUS_HIGHLIGHTED)
 267         {
 268                 __pTabPresenter->SetItemStatus(__currentHighlightedItemIndex, _TABITEM_STATUS_NORMAL);
 269         }
 270         __currentHighlightedItemIndex = 0;
 271
 272         return __tabItems.Add(*pItem);
 273 }
 274
 275 result
 276 _Tab::AddItem(const Bitmap& icon, int actionId)
 277 {
 278         if (actionId < _TAB_ACTION_ID_MIN || actionId > _TAB_ACTION_ID_MAX)
 279         {
 280                 SysLog(NID_UI_CTRL, "[E_OUT_OF_RANGE] The actionId (%d) is out of range.", actionId);
 281                 return E_OUT_OF_RANGE;
 282         }
 283
 284         if (__style != _TAB_STYLE_ICON)
 285         {
 286                 return E_SYSTEM;
 287         }
 288
 289         bool isDuplicate = CheckDuplicatedActionId(actionId);
 290         SysTryReturnResult(NID_UI_CTRL, isDuplicate == false, E_SYSTEM, "A system error has occurred. The tab already has an item with same action id (%d).", actionId);
 291
 292         int itemCount = __tabItems.GetCount();
 293
 294         SysTryReturnResult(NID_UI_CTRL, itemCount < _TAB_ITEM_MAXCOUNT, E_SYSTEM, "A system error has occurred. The tab has maximum number of items.");
 295
 296         _TabItem *pItem = new (std::nothrow) _TabItem;
 297         SysTryReturnResult(NID_UI_CTRL, pItem != null, E_OUT_OF_MEMORY, "Memory allocation failed.");
 298
 299         pItem->SetIcon(icon);
 300         pItem->SetActionId(actionId);
 301         pItem->SetUpdateState(true);
 302
 303         if (itemCount > 0)
 304         {
 305                 pItem->SetStatus(_TABITEM_STATUS_NORMAL);
 306         }
 307         else
 308         {
 309                 pItem->SetStatus(_TABITEM_STATUS_SELECTED);
 310         }
 311
 312         __pTabPresenter->SetRecalculateItemBounds(true);
 313
 314         if (__pTabPresenter->GetItemStatus(__currentHighlightedItemIndex) == _TABITEM_STATUS_HIGHLIGHTED)
 315         {
 316                 __pTabPresenter->SetItemStatus(__currentHighlightedItemIndex, _TABITEM_STATUS_NORMAL);
 317         }
 318         __currentHighlightedItemIndex = 0;
 319
 320         return __tabItems.Add(*pItem);
 321 }
 322
 323 result
 324 _Tab::AddItem(const String& text, int actionId)
 325 {
 326         if (actionId < _TAB_ACTION_ID_MIN || actionId > _TAB_ACTION_ID_MAX)
 327         {
 328                 SysLog(NID_UI_CTRL, "[E_OUT_OF_RANGE] The actionId (%d) is out of range.", actionId);
 329                 return E_OUT_OF_RANGE;
 330         }
 331
 332         if (!((__style == _TAB_STYLE_TEXT) || (__style == _TAB_STYLE_ICON_TEXT)))
 333         {
 334                 return E_SYSTEM;
 335         }
 336
 337         bool isDuplicate = CheckDuplicatedActionId(actionId);
 338         SysTryReturnResult(NID_UI_CTRL, isDuplicate == false, E_SYSTEM, "A system error has occurred. The tab already has an item with same action id (%d).", actionId);
 339
 340         int itemCount = __tabItems.GetCount();
 341
 342         SysTryReturnResult(NID_UI_CTRL, itemCount < _TAB_ITEM_MAXCOUNT, E_SYSTEM, "A system error has occurred. The tab has maximum number of items.");
 343
 344         _TabItem *pItem = new (std::nothrow) _TabItem;
 345         SysTryReturnResult(NID_UI_CTRL, pItem != null, E_OUT_OF_MEMORY, "Memory allocation failed.");
 346
 347         pItem->SetText(text);
 348         pItem->SetActionId(actionId);
 349         pItem->SetUpdateState(true);
 350
 351         if (itemCount > 0)
 352         {
 353                 pItem->SetStatus(_TABITEM_STATUS_NORMAL);
 354         }
 355         else
 356         {
 357                 pItem->SetStatus(_TABITEM_STATUS_SELECTED);
 358         }
 359
 360         __pTabPresenter->SetRecalculateItemBounds(true);
 361
 362         if (__pTabPresenter->GetItemStatus(__currentHighlightedItemIndex) == _TABITEM_STATUS_HIGHLIGHTED)
 363         {
 364                 __pTabPresenter->SetItemStatus(__currentHighlightedItemIndex, _TABITEM_STATUS_NORMAL);
 365         }
 366         __currentHighlightedItemIndex = 0;
 367
 368         return __tabItems.Add(*pItem);
 369 }
 370
 371 result
 372 _Tab::InsertItemAt(int index, const Bitmap& icon, const String& text, int actionId)
 373 {
 374         result r = E_SUCCESS;
 375         bool isSelected = false;
 376
 377         if (actionId < _TAB_ACTION_ID_MIN || actionId > _TAB_ACTION_ID_MAX)
 378         {
 379                 SysLog(NID_UI_CTRL, "[E_OUT_OF_RANGE] The actionId (%d) is out of range.", actionId);
 380                 return E_OUT_OF_RANGE;
 381         }
 382
 383         if (!((__style == _TAB_STYLE_TEXT) || (__style == _TAB_STYLE_ICON_TEXT)))
 384         {
 385                 return E_SYSTEM;
 386         }
 387
 388         __style = _TAB_STYLE_ICON_TEXT;
 389
 390         bool isDuplicate = CheckDuplicatedActionId(actionId);
 391         SysTryReturnResult(NID_UI_CTRL, isDuplicate == false, E_SYSTEM, "A system error has occurred.The tab already has an item with same action id (%d).", actionId);
 392
 393         int itemCount = __tabItems.GetCount();
 394
 395         SysTryReturnResult(NID_UI_CTRL, itemCount < _TAB_ITEM_MAXCOUNT, E_SYSTEM, "A system error has occurred. The tab has maximum number of items.");
 396
 397         _TabItem *pItem = new (std::nothrow) _TabItem;
 398         SysTryReturnResult(NID_UI_CTRL, pItem != null, E_OUT_OF_MEMORY, "Memory allocation failed.");
 399
 400         pItem->SetIcon(icon);
 401         pItem->SetText(text);
 402         pItem->SetActionId(actionId);
 403         pItem->SetUpdateState(true);
 404
 405         int selectedIndex = GetSelectedItemIndex();
 406
 407         if (selectedIndex >= index)
 408         {
 409                 _TabItem *pSelectedItem = null;
 410                 pSelectedItem = GetItemAt(selectedIndex);
 411                 if (pSelectedItem != null)
 412                 {
 413                         isSelected = true;
 414                         pSelectedItem->SetStatus(_TABITEM_STATUS_NORMAL);
 415                 }
 416         }
 417         else
 418         {
 419                 pItem->SetStatus(_TABITEM_STATUS_NORMAL);
 420         }
 421
 422         __pTabPresenter->SetRecalculateItemBounds(true);
 423
 424         r = __tabItems.InsertAt(*pItem, index);
 425
 426         if (isSelected)
 427         {
 428                 SetSelectedItemIndex(selectedIndex);
 429         }
 430
 431         if (__pTabPresenter->GetItemStatus(__currentHighlightedItemIndex) == _TABITEM_STATUS_HIGHLIGHTED)
 432         {
 433                 __pTabPresenter->SetItemStatus(__currentHighlightedItemIndex, _TABITEM_STATUS_NORMAL);
 434         }
 435         __currentHighlightedItemIndex = 0;
 436
 437         return r;
 438 }
 439
 440 result
 441 _Tab::InsertItemAt(int index, const Bitmap& icon, int actionId)
 442 {
 443         result r = E_SUCCESS;
 444         bool isSelected = false;
 445
 446         if (actionId < _TAB_ACTION_ID_MIN || actionId > _TAB_ACTION_ID_MAX)
 447         {
 448                 SysLog(NID_UI_CTRL, "[E_OUT_OF_RANGE] The actionId (%d) is out of range.", actionId);
 449                 return E_OUT_OF_RANGE;
 450         }
 451
 452         if (__style != _TAB_STYLE_ICON)
 453         {
 454                 return E_SYSTEM;
 455         }
 456
 457         bool isDuplicate = CheckDuplicatedActionId(actionId);
 458         SysTryReturnResult(NID_UI_CTRL, isDuplicate == false, E_SYSTEM, "A system error has occurred.The tab already has an item with same action id (%d).", actionId);
 459
 460         int itemCount = __tabItems.GetCount();
 461
 462         SysTryReturnResult(NID_UI_CTRL, itemCount < _TAB_ITEM_MAXCOUNT, E_SYSTEM, "A system error has occurred. The tab has maximum number of items.");
 463
 464         _TabItem *pItem = new (std::nothrow) _TabItem;
 465         SysTryReturnResult(NID_UI_CTRL, pItem != null, E_OUT_OF_MEMORY, "Memory allocation failed.");
 466
 467         pItem->SetIcon(icon);
 468         pItem->SetActionId(actionId);
 469         pItem->SetUpdateState(true);
 470         int selectedIndex = GetSelectedItemIndex();
 471
 472         if (selectedIndex >= index)
 473         {
 474                 _TabItem *pSelectedItem = null;
 475                 pSelectedItem = GetItemAt(selectedIndex);
 476                 if (pSelectedItem != null)
 477                 {
 478                         isSelected = true;
 479                         pSelectedItem->SetStatus(_TABITEM_STATUS_NORMAL);
 480                 }
 481         }
 482         else
 483         {
 484                 pItem->SetStatus(_TABITEM_STATUS_NORMAL);
 485         }
 486
 487         __pTabPresenter->SetRecalculateItemBounds(true);
 488
 489         r = __tabItems.InsertAt(*pItem, index);
 490
 491         if (isSelected)
 492         {
 493                 SetSelectedItemIndex(selectedIndex);
 494         }
 495
 496         if (__pTabPresenter->GetItemStatus(__currentHighlightedItemIndex) == _TABITEM_STATUS_HIGHLIGHTED)
 497         {
 498                 __pTabPresenter->SetItemStatus(__currentHighlightedItemIndex, _TABITEM_STATUS_NORMAL);
 499         }
 500         __currentHighlightedItemIndex = 0;
 501
 502         return r;
 503 }
 504
 505 result
 506 _Tab::InsertItemAt(int index, const String& text, int actionId)
 507 {
 508         result r = E_SUCCESS;
 509         bool isSelected = false;
 510
 511         if (actionId < _TAB_ACTION_ID_MIN || actionId > _TAB_ACTION_ID_MAX)
 512         {
 513                 SysLog(NID_UI_CTRL, "[E_OUT_OF_RANGE] The actionId (%d) is out of range.", actionId);
 514                 return E_OUT_OF_RANGE;
 515         }
 516
 517         bool isDuplicate = CheckDuplicatedActionId(actionId);
 518         SysTryReturnResult(NID_UI_CTRL, isDuplicate == false, E_SYSTEM, "A system error has occurred.The tab already has an item with same action id (%d).", actionId);
 519
 520         if (!((__style == _TAB_STYLE_TEXT) || (__style == _TAB_STYLE_ICON_TEXT)))
 521         {
 522                 return E_SYSTEM;
 523         }
 524
 525         int itemCount = __tabItems.GetCount();
 526
 527         SysTryReturnResult(NID_UI_CTRL, itemCount < _TAB_ITEM_MAXCOUNT, E_SYSTEM, "A system error has occurred. The tab has maximum number of items.");
 528
 529         _TabItem *pItem = new (std::nothrow) _TabItem;
 530         SysTryReturnResult(NID_UI_CTRL, pItem != null, E_OUT_OF_MEMORY, "Memory allocation failed.");
 531
 532         pItem->SetText(text);
 533         pItem->SetActionId(actionId);
 534         pItem->SetUpdateState(true);
 535         int selectedIndex = GetSelectedItemIndex();
 536
 537         if (selectedIndex >= index)
 538         {
 539                 _TabItem *pSelectedItem = null;
 540                 pSelectedItem = GetItemAt(selectedIndex);
 541                 if (pSelectedItem != null)
 542                 {
 543                         isSelected = true;
 544                         pSelectedItem->SetStatus(_TABITEM_STATUS_NORMAL);
 545                 }
 546         }
 547         else
 548         {
 549                 pItem->SetStatus(_TABITEM_STATUS_NORMAL);
 550         }
 551
 552         __pTabPresenter->SetRecalculateItemBounds(true);
 553
 554         r = __tabItems.InsertAt(*pItem, index);
 555
 556         if (isSelected)
 557         {
 558                 SetSelectedItemIndex(selectedIndex);
 559         }
 560
 561         if (__pTabPresenter->GetItemStatus(__currentHighlightedItemIndex) == _TABITEM_STATUS_HIGHLIGHTED)
 562         {
 563                 __pTabPresenter->SetItemStatus(__currentHighlightedItemIndex, _TABITEM_STATUS_NORMAL);
 564         }
 565         __currentHighlightedItemIndex = 0;
 566
 567         return r;
 568 }
 569
 570 result
 571 _Tab::SetItemAt(int index, const Bitmap& icon, const String& text, int actionId)
 572 {
 573         if (actionId < _TAB_ACTION_ID_MIN || actionId > _TAB_ACTION_ID_MAX)
 574         {
 575                 SysLog(NID_UI_CTRL, "[E_OUT_OF_RANGE] The actionId (%d) is out of range.", actionId);
 576                 return E_OUT_OF_RANGE;
 577         }
 578
 579         if (!((__style == _TAB_STYLE_TEXT) || (__style == _TAB_STYLE_ICON_TEXT)))
 580         {
 581                 return E_SYSTEM;
 582         }
 583
 584         __style = _TAB_STYLE_ICON_TEXT;
 585
 586         int itemCount = __tabItems.GetCount();
 587
 588         if ((index < 0) || (index >= itemCount))
 589         {
 590                 return E_OUT_OF_RANGE;
 591         }
 592
 593         SysTryReturnResult(NID_UI_CTRL, itemCount < _TAB_ITEM_MAXCOUNT, E_SYSTEM, "A system error has occurred. The tab has maximum number of items.");
 594
 595         if (GetItemIndex(actionId) != index)
 596         {
 597                 return E_SYSTEM;
 598         }
 599
 600         _TabItem *pItem = static_cast<_TabItem*>(__tabItems.GetAt(index));
 601         result r = GetLastResult();
 602         SysTryReturnResult(NID_UI_CTRL, pItem != null, r, "[%s] Propagating.", GetErrorMessage(r));
 603
 604         pItem->SetIcon(icon);
 605         pItem->SetText(text);
 606         pItem->SetActionId(actionId);
 607         pItem->SetUpdateState(true);
 608
 609         return E_SUCCESS;
 610 }
 611
 612 result
 613 _Tab::SetItemAt(int index, const Bitmap& icon, int actionId)
 614 {
 615         if (actionId < _TAB_ACTION_ID_MIN || actionId > _TAB_ACTION_ID_MAX)
 616         {
 617                 SysLog(NID_UI_CTRL, "[E_OUT_OF_RANGE] The actionId (%d) is out of range.", actionId);
 618                 return E_OUT_OF_RANGE;
 619         }
 620
 621         if (__style != _TAB_STYLE_ICON)
 622         {
 623                 return E_SYSTEM;
 624         }
 625
 626         int itemCount = __tabItems.GetCount();
 627
 628         if ((index < 0) || (index >= itemCount))
 629         {
 630                 return E_OUT_OF_RANGE;
 631         }
 632
 633         SysTryReturnResult(NID_UI_CTRL, itemCount < _TAB_ITEM_MAXCOUNT, E_SYSTEM, "A system error has occurred. The tab has maximum number of items.");
 634
 635         if (GetItemIndex(actionId) != index)
 636         {
 637                 return E_SYSTEM;
 638         }
 639
 640         _TabItem *pItem = static_cast<_TabItem*>(__tabItems.GetAt(index));
 641         result r = GetLastResult();
 642         SysTryReturnResult(NID_UI_CTRL, pItem != null, r, "[%s] Propagating.", GetErrorMessage(r));
 643
 644         pItem->SetIcon(icon);
 645         pItem->SetActionId(actionId);
 646         pItem->SetUpdateState(true);
 647
 648         return E_SUCCESS;
 649 }
 650
 651 result
 652 _Tab::SetItemAt(int index, const String& text, int actionId)
 653 {
 654         if (actionId < _TAB_ACTION_ID_MIN || actionId > _TAB_ACTION_ID_MAX)
 655         {
 656                 SysLog(NID_UI_CTRL, "[E_OUT_OF_RANGE] The actionId (%d) is out of range.", actionId);
 657                 return E_OUT_OF_RANGE;
 658         }
 659
 660         if (!((__style == _TAB_STYLE_TEXT) || (__style == _TAB_STYLE_ICON_TEXT)))
 661         {
 662                 return E_SYSTEM;
 663         }
 664
 665         int itemCount = __tabItems.GetCount();
 666
 667         if ((index < 0) || (index >= itemCount))
 668         {
 669                 return E_OUT_OF_RANGE;
 670         }
 671
 672         SysTryReturnResult(NID_UI_CTRL, itemCount < _TAB_ITEM_MAXCOUNT, E_SYSTEM, "A system error has occurred. The tab has maximum number of items.");
 673
 674         if (GetItemIndex(actionId) != index)
 675         {
 676                 return E_SYSTEM;
 677         }
 678
 679         _TabItem *pItem = static_cast<_TabItem*>(__tabItems.GetAt(index));
 680         result r = GetLastResult();
 681         SysTryReturnResult(NID_UI_CTRL, pItem != null, r, "[%s] Propagating.", GetErrorMessage(r));
 682
 683         pItem->SetText(text);
 684         pItem->SetActionId(actionId);
 685         pItem->SetUpdateState(true);
 686
 687         return E_SUCCESS;
 688 }
 689
 690 result
 691 _Tab::RemoveItemAt(int index)
 692 {
 693         result r = E_SUCCESS;
 694         int selectedIndex = GetSelectedItemIndex();
 695
 696         if (selectedIndex >= index)
 697         {
 698                 _TabItem *pSelectedItem = null;
 699                 pSelectedItem = GetItemAt(selectedIndex);
 700                 if (pSelectedItem != null)
 701                 {
 702                         pSelectedItem->SetStatus(_TABITEM_STATUS_NORMAL);
 703                 }
 704         }
 705         __pTabPresenter->SetRecalculateItemBounds(true);
 706
 707         r = __tabItems.RemoveAt(index, true);
 708
 709         SetSelectedItemIndex(0);
 710
 711         if (__pTabPresenter->GetItemStatus(__currentHighlightedItemIndex) == _TABITEM_STATUS_HIGHLIGHTED)
 712         {
 713                 __pTabPresenter->SetItemStatus(__currentHighlightedItemIndex, _TABITEM_STATUS_NORMAL);
 714         }
 715         if(GetItemCount() > 0)
 716         {
 717                 __currentHighlightedItemIndex = 0;
 718         }
 719         else
 720         {
 721                 __currentHighlightedItemIndex = -1;
 722         }
 723
 724         return r;
 725 }
 726
 727 result
 728 _Tab::RemoveAllItems(void)
 729 {
 730         if (__pTabPresenter->GetItemStatus(__currentHighlightedItemIndex) == _TABITEM_STATUS_HIGHLIGHTED)
 731         {
 732                 __pTabPresenter->SetItemStatus(__currentHighlightedItemIndex, _TABITEM_STATUS_NORMAL);
 733         }
 734         __currentHighlightedItemIndex = -1;
 735
 736         __pTabPresenter->SetRecalculateItemBounds(true);
 737         SetSelectedItemIndex(0);
 738         SetFirstDrawnItemIndex(-1);
 739
 740         __tabItems.RemoveAll(true);
 741
 742         return E_SUCCESS;
 743 }
 744
 745 bool
 746 _Tab::ChangeItemAt(const int srcIndex, const int destIndex)
 747 {
 748         _TabItem* pItem = null;
 749         pItem = GetItemAt(srcIndex);
 750
 751         __tabItems.InsertAt(*pItem, destIndex);
 752
 753         if (srcIndex > destIndex)
 754         {
 755                 __tabItems.RemoveAt((srcIndex + 1), false);
 756         }
 757         else
 758         {
 759                 __tabItems.RemoveAt(srcIndex, false);
 760         }
 761
 762         return true;
 763 }
 764
 765 int
 766 _Tab::GetItemIndex(int actionId)
 767 {
 768         int itemCount = __tabItems.GetCount();
 769
 770         _TabItem* pItem = null;
 771
 772         for (int i = 0; i < itemCount; i++)
 773         {
 774                 pItem = GetItemAt(i);
 775
 776                 if ((pItem != null) && (actionId == pItem->GetActionId()))
 777                 {
 778                         return i;
 779                 }
 780         }
 781
 782         return -1;
 783 }
 784
 785 bool
 786 _Tab::CheckDuplicatedActionId(int actionId)
 787 {
 788         int itemIndex = GetItemIndex(actionId);
 789
 790         if (itemIndex >= 0)
 791         {
 792                 return true;
 793         }
 794
 795         return false;
 796 }
 797
 798 result
 799 _Tab::LoadBitmap(void)
 800 {
 801         result r = E_SUCCESS;
 802         Bitmap* pPressedItemBackgroundBitmap = null;
 803         Bitmap* pItemBackgroundBitmap = null;
 804         Bitmap* pDisabledBackgroundBitmap = null;
 805         Bitmap* pSelectedItemBackgroundBitmap = null;
 806         Bitmap* pPressedItemBackgroundEffectBitmap = null;
 807         Bitmap* pHighlightedItemBackgroundBitmap = null;
 808         Color pressedEffectColor;
 809         GET_COLOR_CONFIG(TAB::ITEM_BG_EFFECT_PRESSED, pressedEffectColor);
 810
 811         r = GET_BITMAP_CONFIG_N(TAB::ITEM_BG_DISABLED, BITMAP_PIXEL_FORMAT_ARGB8888, pDisabledBackgroundBitmap);
 812         SysTryLog(NID_UI_CTRL, r == E_SUCCESS, "Failed to locate disabled item background bitmap.");
 813
 814         if (pDisabledBackgroundBitmap)
 815         {
 816                 __pDisabledBackgroundBitmap = _BitmapImpl::GetColorReplacedBitmapN(*pDisabledBackgroundBitmap, Color::GetColor(COLOR_ID_MAGENTA), GetDisabledItemBackgroundColor());
 817                 SysTryLog(NID_UI_CTRL, (__pDisabledBackgroundBitmap != null), "Failed to locate disabled item background bitmap.");
 818
 819                 delete pDisabledBackgroundBitmap;
 820         }
 821
 822         r = GET_BITMAP_CONFIG_N(TAB::ITEM_BG_NORMAL, BITMAP_PIXEL_FORMAT_ARGB8888, pItemBackgroundBitmap);
 823         SysTryLog(NID_UI_CTRL, r == E_SUCCESS, "Failed to locate item background bitmap.");
 824
 825         if (pItemBackgroundBitmap)
 826         {
 827                 __pBackgroundBitmap = _BitmapImpl::GetColorReplacedBitmapN(*pItemBackgroundBitmap, Color::GetColor(COLOR_ID_MAGENTA), GetItemBackgroundColor());
 828                 SysTryLog(NID_UI_CTRL, (__pBackgroundBitmap != null), "Failed to locate item background bitmap.");
 829
 830                 delete pItemBackgroundBitmap;
 831         }
 832
 833         r = GET_BITMAP_CONFIG_N(TAB::ITEM_BG_PRESSED, BITMAP_PIXEL_FORMAT_ARGB8888, pPressedItemBackgroundBitmap);
 834         SysTryLog(NID_UI_CTRL, r == E_SUCCESS, "Failed to locate pressed item background bitmap.");
 835
 836         if (pPressedItemBackgroundBitmap)
 837         {
 838                 __pPressedItemBackgroundBitmap = _BitmapImpl::GetColorReplacedBitmapN(*pPressedItemBackgroundBitmap, Color::GetColor(COLOR_ID_MAGENTA), GetPressedItemBackgroundColor());
 839                 SysTryLog(NID_UI_CTRL, (__pPressedItemBackgroundBitmap != null), "Failed to locate pressed item background bitmap.");
 840
 841                 delete pPressedItemBackgroundBitmap;
 842         }
 843
 844         r = GET_BITMAP_CONFIG_N(TAB::ITEM_BG_SELECTED, BITMAP_PIXEL_FORMAT_ARGB8888, pSelectedItemBackgroundBitmap);
 845         SysTryLog(NID_UI_CTRL, r == E_SUCCESS, "Failed to locate selected item background bitmap.");
 846
 847         if (pSelectedItemBackgroundBitmap)
 848         {
 849                 __pSelectedItemBackgroundBitmap = _BitmapImpl::GetColorReplacedBitmapN(*pSelectedItemBackgroundBitmap, Color::GetColor(COLOR_ID_MAGENTA), GetSelectedItemBackgroundColor());
 850                 SysTryLog(NID_UI_CTRL, (__pSelectedItemBackgroundBitmap != null), "Failed to locate selected item background bitmap.");
 851
 852                 delete pSelectedItemBackgroundBitmap;
 853         }
 854
 855         r = GET_BITMAP_CONFIG_N(TAB::ITEM_BG_EFFECT_PRESSED, BITMAP_PIXEL_FORMAT_ARGB8888, pPressedItemBackgroundEffectBitmap);
 856         SysTryLog(NID_UI_CTRL, r == E_SUCCESS, "Failed to locate selected item background bitmap.");
 857
 858         if (pPressedItemBackgroundEffectBitmap)
 859         {
 860                 __pPressedItemBackgroundEffectBitmap = _BitmapImpl::GetColorReplacedBitmapN(*pPressedItemBackgroundEffectBitmap, Color::GetColor(COLOR_ID_MAGENTA), pressedEffectColor);
 861                 SysTryLog(NID_UI_CTRL, (__pPressedItemBackgroundEffectBitmap != null), "Failed to locate selected item background bitmap.");
 862
 863                 delete pPressedItemBackgroundEffectBitmap;
 864         }
 865
 866         r = GET_BITMAP_CONFIG_N(TAB::ITEM_BG_HIGHLIGHTED, BITMAP_PIXEL_FORMAT_ARGB8888, pHighlightedItemBackgroundBitmap);
 867         SysTryLog(NID_UI_CTRL, r == E_SUCCESS, "Failed to locate highlighted item background bitmap.");
 868
 869         if (pHighlightedItemBackgroundBitmap)
 870         {
 871                 __pHighlightedItemBackgroundBitmap = _BitmapImpl::GetColorReplacedBitmapN(*pHighlightedItemBackgroundBitmap, Color::GetColor(COLOR_ID_MAGENTA), GetHighlightedItemBackgroundColor());
 872                 SysTryLog(NID_UI_CTRL, (__pHighlightedItemBackgroundBitmap != null), "Failed to locate highlighted item background bitmap.");
 873
 874                 delete pHighlightedItemBackgroundBitmap;
 875         }
 876         return r;
 877 }
 878
 879 result
 880 _Tab::SetBadgeIcon(int actionId, const Bitmap* pBadgeIcon)
 881 {
 882         result r = E_SUCCESS;
 883
 884         if (actionId < _TAB_ACTION_ID_MIN || actionId > _TAB_ACTION_ID_MAX)
 885         {
 886                 SysLog(NID_UI_CTRL, "[E_OUT_OF_RANGE] The actionId (%d) is out of range.", actionId);
 887                 return E_OUT_OF_RANGE;
 888         }
 889
 890         int itemIndex = GetItemIndexFromActionId(actionId);
 891
 892         _TabItem *pItem = null;
 893
 894         if (itemIndex < 0)
 895         {
 896                 SysLog(NID_UI_CTRL, "[E_INVALID_ARG] Invalid argument(s) is used. The specified actionId is not found.");
 897                 return E_INVALID_ARG;
 898         }
 899
 900         pItem = dynamic_cast<_TabItem*>(__tabItems.GetAt(itemIndex));
 901
 902         if (pItem != null)
 903         {
 904                 pItem->SetBadgeIcon(*pBadgeIcon);
 905
 906                 r = __tabItems.SetAt(*pItem, itemIndex, false);
 907         }
 908
 909         return r;
 910 }
 911
 912 int
 913 _Tab::GetItemCount(void) const
 914 {
 915         return __tabItems.GetCount();
 916 }
 917
 918 int
 919 _Tab::GetItemIndexFromActionId(int actionId) const
 920 {
 921         if (actionId < _TAB_ACTION_ID_MIN || actionId > _TAB_ACTION_ID_MAX)
 922         {
 923                 SysLog(NID_UI_CTRL, "[E_OUT_OF_RANGE] The actionId (%d) is out of range.", actionId);
 924                 return -1;
 925         }
 926
 927         int index = 0;
 928         int itemCount = __tabItems.GetCount();
 929
 930         for (index = 0; index < itemCount; index++)
 931         {
 932                 const _TabItem *pItem = dynamic_cast<const _TabItem*>(__tabItems.GetAt(index));
 933
 934                 if (pItem != null)
 935                 {
 936                         if (pItem->GetActionId() == actionId)
 937                         {
 938                                 return index;
 939                         }
 940                 }
 941         }
 942
 943         return -1;
 944 }
 945
 946 int
 947 _Tab::GetItemActionIdAt(int index) const
 948 {
 949         if (__tabItems.GetAt(index) == null )
 950         {
 951                 return -1;
 952         }
 953
 954         const _TabItem *pItem = dynamic_cast<const _TabItem*>(__tabItems.GetAt(index));
 955         SysTryReturn(NID_UI_CTRL, pItem != null, E_SYSTEM, E_SYSTEM,"[E_SYSTEM] A system error has occurred. Failed to get an item at index (%d).", index);
 956
 957         return pItem->GetActionId();
 958 }
 959
 960 _TabItem*
 961 _Tab::GetItemAt(int index)
 962 {
 963         if (__tabItems.GetAt(index) == null )
 964         {
 965                 return null;
 966         }
 967
 968         _TabItem *pItem = static_cast<_TabItem*>(__tabItems.GetAt(index));
 969         result r = GetLastResult();
 970         SysTryReturn(NID_UI_CTRL, pItem != null, null, r, "[%s] Propagating.", GetErrorMessage(r));
 971
 972         return pItem;
 973 }
 974
 975 void
 976 _Tab::SetSelectedItemIndex(int index)
 977 {
 978         __pTabPresenter->SetSelectedItemIndex(index);
 979         return;
 980 }
 981
 982 int
 983 _Tab::GetSelectedItemIndex(void) const
 984 {
 985         return __pTabPresenter->GetSelectedItemIndex();
 986 }
 987
 988 void
 989 _Tab::SetFirstDrawnItemIndex(int index)
 990 {
 991         __pTabPresenter->SetFirstDrawnItemIndex(index);
 992         return;
 993 }
 994
 995 int
 996 _Tab::GetFirstDrawnItemIndex(void) const
 997 {
 998         return __pTabPresenter->GetFirstDrawnItemIndex();
 999 }
1000
1001 void
1002 _Tab::SetEditModeEnabled(bool isEnabled)
1003 {
1004         return __pTabPresenter->SetEditModeEnabled(isEnabled);
1005 }
1006
1007 bool
1008 _Tab::IsEditModeEnabled(void) const
1009 {
1010         return __pTabPresenter->IsEditModeEnabled();
1011 }
1012
1013 result
1014 _Tab::SetBackgroundBitmap(const Bitmap& bitmap)
1015 {
1016         ClearLastResult();
1017
1018         Tizen::Graphics::Bitmap* pBitmap = _BitmapImpl::CloneN(bitmap);
1019
1020         SysTryReturn(NID_UI_CTRL, (pBitmap), GetLastResult(), GetLastResult(), "[%s] Propagating.", GetErrorMessage(GetLastResult()));
1021
1022         if (__pBackgroundBitmap)
1023         {
1024                 delete __pBackgroundBitmap;
1025                 __pBackgroundBitmap = null;
1026         }
1027
1028         __pBackgroundBitmap = pBitmap;
1029
1030         if (__pDisabledBackgroundBitmap)
1031         {
1032                 delete __pDisabledBackgroundBitmap;
1033                 __pDisabledBackgroundBitmap = null;
1034         }
1035
1036         return E_SUCCESS;
1037 }
1038
1039 Bitmap*
1040 _Tab::GetBackgroundBitmap(void) const
1041 {
1042         return __pBackgroundBitmap;
1043 }
1044
1045 Bitmap*
1046 _Tab::GetDisabledBackgroundBitmap(void) const
1047 {
1048         return __pDisabledBackgroundBitmap;
1049 }
1050
1051 Bitmap*
1052 _Tab::GetPressedItemBackgroundBitmap(void) const
1053 {
1054         return __pPressedItemBackgroundBitmap;
1055 }
1056
1057 Bitmap*
1058 _Tab::GetPressedItemBackgroundEffectBitmap(void) const
1059 {
1060         return __pPressedItemBackgroundEffectBitmap;
1061 }
1062
1063 result
1064 _Tab::SetSelectedItemBackgroundBitmap(const Bitmap& bitmap)
1065 {
1066         ClearLastResult();
1067
1068         Tizen::Graphics::Bitmap* pBitmap = _BitmapImpl::CloneN(bitmap);
1069
1070         SysTryReturn(NID_UI_CTRL, (pBitmap), GetLastResult(), GetLastResult(), "[%s] Propagating.", GetErrorMessage(GetLastResult()));
1071
1072         if (__pSelectedItemBackgroundBitmap)
1073         {
1074                 delete __pSelectedItemBackgroundBitmap;
1075                 __pSelectedItemBackgroundBitmap = null;
1076         }
1077         __pSelectedItemBackgroundBitmap = pBitmap;
1078         __pTabPresenter->FreeHorizontalLineBitmap();
1079
1080         return E_SUCCESS;
1081 }
1082
1083
1084 Bitmap*
1085 _Tab::GetSelectedItemBackgroundBitmap(void) const
1086 {
1087         return __pSelectedItemBackgroundBitmap;
1088 }
1089
1090 result
1091 _Tab::SetHighlightedItemBackgroundBitmap(const Bitmap& bitmap)
1092 {
1093         ClearLastResult();
1094
1095         Tizen::Graphics::Bitmap* pBitmap = _BitmapImpl::CloneN(bitmap);
1096
1097         SysTryReturn(NID_UI_CTRL, (pBitmap), GetLastResult(), GetLastResult(), "[%s] Propagating.", GetErrorMessage(GetLastResult()));
1098
1099         if (__pHighlightedItemBackgroundBitmap)
1100         {
1101                 delete __pHighlightedItemBackgroundBitmap;
1102                 __pHighlightedItemBackgroundBitmap = null;
1103         }
1104
1105         __pHighlightedItemBackgroundBitmap = pBitmap;
1106
1107         return E_SUCCESS;
1108 }
1109
1110 Bitmap*
1111 _Tab::GetHighlightedItemBackgroundBitmap(void) const
1112 {
1113         return __pHighlightedItemBackgroundBitmap;
1114 }
1115
1116 void
1117 _Tab::SetItemBackgroundColor(Color color)
1118 {
1119         __itemBgColor[_TAB_STATUS_NORMAL] = color;
1120         return;
1121 }
1122
1123 Color
1124 _Tab::GetItemBackgroundColor(void) const
1125 {
1126         return __itemBgColor[_TAB_STATUS_NORMAL];
1127 }
1128
1129 Color
1130 _Tab::GetPressedItemBackgroundColor(void) const
1131 {
1132         return __itemBgColor[_TAB_STATUS_PRESSED];
1133 }
1134
1135 void
1136 _Tab::SetSelectedItemBackgroundColor(Color color)
1137 {
1138         __itemBgColor[_TAB_STATUS_SELECTED] = color;
1139         return;
1140 }
1141
1142 Color
1143 _Tab::GetSelectedItemBackgroundColor(void) const
1144 {
1145         return __itemBgColor[_TAB_STATUS_SELECTED];
1146 }
1147
1148 void
1149 _Tab::SetHighlightedItemBackgroundColor(Color color)
1150 {
1151         __itemBgColor[_TAB_STATUS_HIGHLIGHTED] = color;
1152         return;
1153 }
1154
1155 Color
1156 _Tab::GetHighlightedItemBackgroundColor(void) const
1157 {
1158         return __itemBgColor[_TAB_STATUS_HIGHLIGHTED];
1159 }
1160
1161 Color
1162 _Tab::GetDisabledItemBackgroundColor(void) const
1163 {
1164         return __itemBgColor[_TAB_STATUS_DISABLED];
1165 }
1166
1167 void
1168 _Tab::SetTextColor(const Color& textColor)
1169 {
1170         __itemTextColor[_TAB_STATUS_NORMAL] = textColor;
1171         return;
1172 }
1173
1174 Color
1175 _Tab::GetTextColor(void) const
1176 {
1177         return  __itemTextColor[_TAB_STATUS_NORMAL];
1178 }
1179
1180 Color
1181 _Tab::GetDisabledTextColor(void) const
1182 {
1183         return  __itemTextColor[_TAB_STATUS_DISABLED];
1184 }
1185
1186 void
1187 _Tab::SetPressedTextColor(const Color& textColor)
1188 {
1189         __itemTextColor[_TAB_STATUS_PRESSED] = textColor;
1190         return;
1191 }
1192
1193 Color
1194 _Tab::GetPressedTextColor(void) const
1195 {
1196         return __itemTextColor[_TAB_STATUS_PRESSED];
1197 }
1198
1199 void
1200 _Tab::SetSelectedTextColor(const Color& textColor)
1201 {
1202         __itemTextColor[_TAB_STATUS_SELECTED] = textColor;
1203         return;
1204 }
1205
1206 Color
1207 _Tab::GetSelectedTextColor(void) const
1208 {
1209         return __itemTextColor[_TAB_STATUS_SELECTED];
1210 }
1211
1212 void
1213 _Tab::SetHighlightedTextColor(const Color& color)
1214 {
1215         __itemTextColor[_TAB_STATUS_HIGHLIGHTED] = color;
1216         return;
1217 }
1218
1219 Color
1220 _Tab::GetHighlightedTextColor(void) const
1221 {
1222         return __itemTextColor[_TAB_STATUS_HIGHLIGHTED];
1223 }
1224
1225 void
1226 _Tab::SetStyle(int style)
1227 {
1228         __style = style;
1229         return;
1230 }
1231
1232 _TabStyle
1233 _Tab::GetStyle(void) const
1234 {
1235         return _TabStyle(__style);
1236 }
1237
1238 int
1239 _Tab::GetCurrentHighlightedItemIndex(void) const
1240 {
1241         return __currentHighlightedItemIndex;
1242 }
1243
1244 void
1245 _Tab::AddActionEventListener(const _IActionEventListener& listener)
1246 {
1247         ClearLastResult();
1248
1249         if (__pActionEvent == null)
1250         {
1251                 __pActionEvent = _ActionEvent::CreateInstanceN(*this);
1252
1253                 if (__pActionEvent == null || IsFailed(GetLastResult()))
1254                 {
1255                         SetLastResult(E_SYSTEM);
1256                         delete __pActionEvent;
1257                         return;
1258                 }
1259         }
1260         __pActionEvent->AddListener(listener);
1261         return;
1262 }
1263
1264 void
1265 _Tab::RemoveActionEventListener(const _IActionEventListener& listener)
1266 {
1267         ClearLastResult();
1268
1269         __pActionEvent->RemoveListener(listener);
1270         return;
1271 }
1272
1273 bool
1274 _Tab::OnTouchPressed(const _Control& source, const _TouchInfo& touchinfo)
1275 {
1276         if (this != &source)
1277         {
1278                 return true;
1279         }
1280
1281         if (__pTabPresenter->GetItemStatus(__currentHighlightedItemIndex) == _TABITEM_STATUS_HIGHLIGHTED)
1282         {
1283                 __pTabPresenter->SetItemStatus(__currentHighlightedItemIndex, _TABITEM_STATUS_NORMAL);
1284         }
1285         __currentHighlightedItemIndex = -1;
1286
1287         return __pTabPresenter->OnTouchPressed(source, touchinfo);
1288 }
1289
1290 bool
1291 _Tab::OnTouchReleased(const _Control& source, const _TouchInfo& touchinfo)
1292 {
1293         if (this != &source)
1294         {
1295                 return true;
1296         }
1297
1298         __pTabPresenter->OnTouchReleased(source, touchinfo);
1299
1300         int index = __pTabPresenter->GetItemIndexFromPosition(touchinfo.GetCurrentPosition());
1301
1302         _TabItem* pItem = __pTabPresenter->GetItemAt(index);
1303
1304         if (pItem == null)
1305         {
1306                 return true;
1307         }
1308
1309         if (__pActionEvent)
1310         {
1311                 IEventArg* pEventArg = _ActionEvent::CreateActionEventArgN(pItem->GetActionId());
1312                 SysTryReturn(NID_UI_CTRL, pEventArg, GetLastResult(), GetLastResult(), "[%s] Propagating.", GetErrorMessage(GetLastResult()));
1313
1314                 __pActionEvent->Fire(*pEventArg);
1315         }
1316
1317         return true;
1318 }
1319
1320 bool
1321 _Tab::OnTouchMoved(const _Control& source, const _TouchInfo& touchinfo)
1322 {
1323         if (this != &source)
1324         {
1325                 return true;
1326         }
1327
1328         return __pTabPresenter->OnTouchMoved(source, touchinfo);
1329 }
1330
1331 bool
1332 _Tab::OnLongPressGestureDetected(_TouchLongPressGestureDetector& gesture)
1333 {
1334         return __pTabPresenter->OnLongPressGestureDetected();
1335 }
1336
1337 bool
1338 _Tab::OnLongPressGestureCanceled(_TouchLongPressGestureDetector& gesture)
1339 {
1340         return false;
1341 }
1342
1343 bool
1344 _Tab::OnFlickGestureDetected(_TouchFlickGestureDetector& gesture)
1345 {
1346
1347         return __pTabPresenter->OnFlickGestureDetected(gesture);
1348 }
1349
1350 bool
1351 _Tab::OnFlickGestureCanceled(_TouchFlickGestureDetector& gesture)
1352 {
1353         return false;
1354 }
1355
1356 void
1357 _Tab::OnDraw(void)
1358 {
1359         ClearLastResult();
1360         __pTabPresenter->Draw();
1361         return;
1362
1363 }
1364
1365 void
1366 _Tab::OnBoundsChanged(void)
1367 {
1368         __pTabPresenter->OnBoundsChanged();
1369 }
1370
1371 result
1372 _Tab::OnAttachedToMainTree(void)
1373 {
1374         _AccessibilityContainer* pContainer = null;
1375
1376         pContainer = GetAccessibilityContainer();
1377
1378         if (pContainer)
1379         {
1380                 pContainer->Activate(true);
1381                 pContainer->AddListener(*this);
1382         }
1383
1384         return E_SUCCESS;
1385 }
1386
1387 void
1388 _Tab::OnFontChanged(Font* pFont)
1389 {
1390     __pTabPresenter->OnFontChanged(pFont);
1391     return;
1392 }
1393
1394 void
1395 _Tab::OnFontInfoRequested(unsigned long& style, float& size)
1396 {
1397     __pTabPresenter->OnFontInfoRequested(style, size);
1398     return;
1399 }
1400
1401 bool
1402 _Tab::OnKeyPressed(const _Control& source, const _KeyInfo& keyInfo)
1403 {
1404         if (this != &source)
1405         {
1406                 return false;
1407         }
1408         _KeyCode keyCode = keyInfo.GetKeyCode();
1409         int itemCount = __pTabPresenter->GetItemCount();
1410         if(itemCount == 0)
1411         {
1412                 return false;
1413         }
1414
1415         if (keyCode == _KEY_RIGHT)
1416         {
1417                 if (__currentHighlightedItemIndex < (itemCount - 1))
1418                 {
1419                         if (__pTabPresenter->GetItemStatus(__currentHighlightedItemIndex) != _TABITEM_STATUS_SELECTED)
1420                         {
1421                                 __pTabPresenter->SetItemStatus(__currentHighlightedItemIndex, _TABITEM_STATUS_NORMAL);
1422                         }
1423
1424                         __currentHighlightedItemIndex++;
1425
1426                         if (__pTabPresenter->GetItemStatus(__currentHighlightedItemIndex) != _TABITEM_STATUS_SELECTED)
1427                         {
1428                                 __pTabPresenter->SetItemStatus(__currentHighlightedItemIndex, _TABITEM_STATUS_HIGHLIGHTED);
1429                         }
1430                         __pTabPresenter->ShiftToFocusedItem(__currentHighlightedItemIndex, _FOCUS_DIRECTION_MOVE_RIGHT);
1431                 }
1432                 return true;
1433         }
1434
1435         if (keyCode == _KEY_LEFT)
1436         {
1437                 if (__currentHighlightedItemIndex >= -1)
1438                 {
1439                         if (__pTabPresenter->GetItemStatus(__currentHighlightedItemIndex) != _TABITEM_STATUS_SELECTED)
1440                         {
1441                                 __pTabPresenter->SetItemStatus(__currentHighlightedItemIndex, _TABITEM_STATUS_NORMAL);
1442                         }
1443                         if (__currentHighlightedItemIndex == -1)
1444                         {
1445                                 __currentHighlightedItemIndex = 0;
1446                         }
1447                         if (__currentHighlightedItemIndex > 0)
1448                         {
1449                                 __currentHighlightedItemIndex--;
1450                         }
1451                         if (__pTabPresenter->GetItemStatus(__currentHighlightedItemIndex) != _TABITEM_STATUS_SELECTED)
1452                         {
1453                                 __pTabPresenter->SetItemStatus(__currentHighlightedItemIndex, _TABITEM_STATUS_HIGHLIGHTED);
1454                         }
1455                         __pTabPresenter->ShiftToFocusedItem(__currentHighlightedItemIndex, _FOCUS_DIRECTION_MOVE_LEFT);
1456                 }
1457                 return true;
1458         }
1459
1460         if (keyCode == _KEY_ENTER && __currentHighlightedItemIndex != -1)
1461         {
1462                 __pTabPresenter->SetItemStatus(__currentHighlightedItemIndex, _TABITEM_STATUS_SELECTED);
1463                 __pTabPresenter->SetSelectedItemIndex(__currentHighlightedItemIndex);
1464                 Invalidate();
1465                 return true;
1466         }
1467         return false;
1468 }
1469
1470 bool
1471 _Tab::OnKeyReleased(const _Control& source, const _KeyInfo& keyInfo)
1472 {
1473         return false;
1474 }
1475
1476 bool
1477 _Tab::OnFocusGained(const _Control & source)
1478 {
1479         if (this != &source)
1480         {
1481                 return false;
1482         }
1483
1484         if(__pTabPresenter->GetItemCount() > 0)
1485         {
1486                 __currentHighlightedItemIndex = 0;
1487         }
1488         else
1489         {
1490                 __currentHighlightedItemIndex = -1;
1491         }
1492         return true;
1493 }
1494
1495 bool
1496 _Tab::OnFocusLost(const _Control & source)
1497 {
1498         if (this != &source)
1499         {
1500                 return false;
1501         }
1502
1503         if (__pTabPresenter->GetItemStatus(__currentHighlightedItemIndex) == _TABITEM_STATUS_HIGHLIGHTED)
1504         {
1505                 __pTabPresenter->SetItemStatus(__currentHighlightedItemIndex, _TABITEM_STATUS_NORMAL);
1506         }
1507         __currentHighlightedItemIndex = -1;
1508         Invalidate();
1509         return true;
1510 }
1511
1512 void
1513 _Tab::OnDrawFocus()
1514 {
1515         if (__pTabPresenter->GetItemStatus(__currentHighlightedItemIndex) != _TABITEM_STATUS_SELECTED)
1516         {
1517                 __pTabPresenter->SetItemStatus(__currentHighlightedItemIndex, _TABITEM_STATUS_HIGHLIGHTED);
1518         }
1519         __pTabPresenter->ShiftToFocusedItem(__currentHighlightedItemIndex, _FOCUS_DIRECTION_MOVE_LEFT);
1520         return;
1521 }
1522
1523 void
1524 _Tab::AddAccessibilityElement(const FloatRectangle& itemBounds, const String& itemText, _TabItemStatus status)
1525 {
1526         _AccessibilityContainer* pContainer = GetAccessibilityContainer();
1527
1528         if (pContainer != null)
1529         {
1530                 _AccessibilityElement* pAccessibilityElement = new (std::nothrow) _AccessibilityElement(true);
1531                 SysTryReturnVoidResult(NID_UI_CTRL, pAccessibilityElement != null, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] Memory allocation failed.");
1532
1533                 pAccessibilityElement->SetTrait(L"Tab");
1534                 pAccessibilityElement->SetHint(L"Double tap to move to contents");
1535                 pAccessibilityElement->SetBounds(itemBounds);
1536
1537                 if (GetStyle() != _TAB_STYLE_ICON)
1538                 {
1539                         pAccessibilityElement->SetLabel(itemText);
1540                 }
1541
1542                 if (status == _TABITEM_STATUS_SELECTED)
1543                 {
1544                         pAccessibilityElement->SetStatus("Selected");
1545                         pAccessibilityElement->SetHintDisabled(true);
1546                 }
1547                 else
1548                 {
1549                         pAccessibilityElement->SetStatus("");
1550                         pAccessibilityElement->SetHintDisabled(false);
1551                 }
1552
1553                 pContainer->AddElement(*pAccessibilityElement);
1554                 __accessibilityElements.Add(pAccessibilityElement);
1555         }
1556
1557         return;
1558 }
1559
1560 void
1561 _Tab::RemoveAllAccessibilityElement(void)
1562 {
1563         _AccessibilityContainer* pContainer = GetAccessibilityContainer();
1564
1565         if (pContainer == null)
1566         {
1567                 return;
1568         }
1569
1570         _AccessibilityElement* pAccessibilityElement = null;
1571
1572         while (__accessibilityElements.GetCount() > 0)
1573         {
1574                 if ((__accessibilityElements.GetAt(0, pAccessibilityElement)) == E_SUCCESS)
1575                 {
1576                         pContainer->RemoveElement(*pAccessibilityElement);
1577                         __accessibilityElements.RemoveAt(0);
1578                 }
1579                 else
1580                 {
1581                         __accessibilityElements.RemoveAt(0);
1582                 }
1583         }
1584
1585         return;
1586 }
1587
1588 void
1589 _Tab::OnChangeLayout(_ControlOrientation orientation)
1590 {
1591         __pTabPresenter->OnChangeLayout(orientation);
1592
1593         return;
1594 }
1595
1596 bool
1597 _Tab::OnAccessibilityFocusMovedNext(const _AccessibilityContainer& control, const _AccessibilityElement& element)
1598 {
1599         ClearLastResult();
1600
1601         return __pTabPresenter->OnAccessibilityFocusMovedNext(control, element);
1602 }
1603
1604 bool
1605 _Tab::OnAccessibilityFocusMovedPrevious(const _AccessibilityContainer& control, const _AccessibilityElement& element)
1606 {
1607         ClearLastResult();
1608
1609         return __pTabPresenter->OnAccessibilityFocusMovedPrevious(control, element);
1610 }
1611
1612 bool
1613 _Tab::OnAccessibilityReadingElement(const _AccessibilityContainer& control, const _AccessibilityElement& element)
1614 {
1615         return false;
1616 }
1617 bool
1618 _Tab::OnAccessibilityReadElement(const _AccessibilityContainer& control, const _AccessibilityElement& element)
1619 {
1620         return false;
1621 }
1622
1623 bool
1624 _Tab::OnAccessibilityFocusIn(const _AccessibilityContainer& control, const _AccessibilityElement& element)
1625 {
1626         return false;
1627 }
1628
1629 bool
1630 _Tab::OnAccessibilityFocusOut(const _AccessibilityContainer& control, const _AccessibilityElement& element)
1631 {
1632         return false;
1633 }
1634
1635 bool
1636 _Tab::OnAccessibilityActionPerformed(const _AccessibilityContainer& control, const _AccessibilityElement& element)
1637 {
1638         return false;
1639 }
1640
1641 bool
1642 _Tab::OnAccessibilityValueIncreased(const Tizen::Ui::_AccessibilityContainer&, const Tizen::Ui::_AccessibilityElement&)
1643 {
1644         return false;
1645 }
1646
1647 bool
1648 _Tab::OnAccessibilityValueDecreased(const Tizen::Ui::_AccessibilityContainer&, const Tizen::Ui::_AccessibilityElement&)
1649 {
1650         return false;
1651 }
1652
1653 }}} // Tizen::Ui::Controls
1654