src/ui/controls/FUiCtrl_Toolbar.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  * @file                FUiCtrl_Toolbar.cpp
  19  * @brief               This is the implementation file for the _Toolbar class.
  20  */
  21
  22 #include <FBaseSysLog.h>
  23 #include <FGrp_BitmapImpl.h>
  24 #include "FUi_CoordinateSystemUtils.h"
  25 #include "FUi_AccessibilityContainer.h"
  26 #include "FUi_AccessibilityElement.h"
  27 #include "FUi_AccessibilityManager.h"
  28 #include "FUi_IAccessibilityListener.h"
  29 #include "FUi_CoordinateSystemUtils.h"
  30 #include "FUi_TouchLongPressGestureDetector.h"
  31 #include "FUi_ResourceManager.h"
  32 #include "FUiCtrl_ActionEvent.h"
  33 #include "FUiCtrl_Toolbar.h"
  34 #include "FUiCtrl_ToolbarPresenter.h"
  35 #include "FUiCtrl_Label.h"
  36 #include "FUiCtrl_Form.h"
  37
  38 using namespace Tizen::Base;
  39 using namespace Tizen::Base::Collection;
  40 using namespace Tizen::Graphics;
  41 using namespace Tizen::Ui;
  42
  43 namespace
  44 {
  45 class FooterItemAccessibilityListener
  46         : public _IAccessibilityListener
  47 {
  48 public:
  49         FooterItemAccessibilityListener(const Tizen::Ui::Controls::_Toolbar* toolbar)
  50         :__pToolbar(null)
  51         {
  52                 __pToolbar = const_cast<Tizen::Ui::Controls::_Toolbar*>(toolbar);
  53         }
  54         virtual ~FooterItemAccessibilityListener(void){}
  55         virtual bool OnAccessibilityFocusMovedNext(const _AccessibilityContainer& control, const _AccessibilityElement& element){return false;}
  56         virtual bool OnAccessibilityFocusMovedPrevious(const _AccessibilityContainer& control, const _AccessibilityElement& element){return false;}
  57         virtual bool OnAccessibilityReadingElement(const _AccessibilityContainer& control, const _AccessibilityElement& element){return false;}
  58         virtual bool OnAccessibilityReadElement(const _AccessibilityContainer& control, const _AccessibilityElement& element){return false;}
  59         virtual bool OnAccessibilityFocusIn(const _AccessibilityContainer& control, const _AccessibilityElement& element)
  60         {
  61                 FloatRectangle rect = element.GetAbsoluteBounds();
  62                 Dimension screen = _ResourceManager::GetInstance()->GetLogicalScreenSizen();
  63                 int screenW = _ControlManager::GetInstance()->GetOrientation() == _CONTROL_ORIENTATION_PORTRAIT ? screen.width : screen.height;
  64                 if(rect.x < 0.0f)
  65                 {
  66                         __pToolbar->GetPresenter()->AdjustItemPositionX(-(rect.x));
  67                         __pToolbar->Invalidate(true);
  68                 }
  69                 else if(rect.x + rect.width > screenW)
  70                 {
  71                         float adjustX = 0.0f;
  72                         if(rect.x + rect.width > screenW)
  73                         {
  74                                 adjustX = -(rect.x + rect.width - screenW);
  75                         }
  76                         else
  77                         {
  78                                 adjustX = -rect.x;
  79                         }
  80                         __pToolbar->GetPresenter()->AdjustItemPositionX(adjustX);
  81                         __pToolbar->Invalidate(true);
  82                 }
  83                 return true;
  84         }
  85         virtual bool OnAccessibilityFocusOut(const _AccessibilityContainer& control, const _AccessibilityElement& element){return false;}
  86         virtual bool OnAccessibilityValueIncreased(const _AccessibilityContainer& control, const _AccessibilityElement& element){return false;}
  87         virtual bool OnAccessibilityValueDecreased(const _AccessibilityContainer& control, const _AccessibilityElement& element){return false;}
  88         virtual bool OnAccessibilityActionPerformed(const _AccessibilityContainer& control, const _AccessibilityElement& element)
  89         {
  90                 _AccessibilityManager::GetInstance()->RequestAutoReading(_ACCESSIBILITY_AUTO_READING_MODE_FIRST_ITEM_OF_CONTENTS);
  91                 return true;
  92         }
  93 private:
  94         Tizen::Ui::Controls::_Toolbar* __pToolbar;
  95 };
  96 }
  97
  98 namespace Tizen { namespace Ui { namespace Controls
  99 {
 100
 101 IMPLEMENT_PROPERTY(_Toolbar);
 102
 103 _Toolbar::_Toolbar(void)
 104         : __header(false)
 105         , __pToolbarPresenter(null)
 106         , __pActionEventListener(null)
 107         , __pBackEventListener(null)
 108         , __pMenuEventListener(null)
 109         , __pLongPressGesture(null)
 110         , __pFlickGesture(null)
 111         , __pToolbarBackgroundBitmap(null)
 112         , __pToolbarBackgroundEffectBitmap(null)
 113         , __pTitleIcon(null)
 114         , __titleText(L"")
 115         , __descriptionText(L"")
 116         , __titleTextAlignment(ALIGNMENT_LEFT)
 117         , __pItems(null)
 118         , __pTitleBadgeIcon(null)
 119         , __backActionId(-1)
 120         , __menuActionId(-1)
 121         , __itemCount(0)
 122         , __style(TOOLBAR_TITLE)
 123         , __transparent(false)
 124         , __isUserBackgroundBitmap(false)
 125         , __highlightedItemIndex(0)
 126         , __lastHighlightedItemIndex(0)
 127         , __highlighted(false)
 128         , __titleTextArea(FloatRectangle(0.0f, 0.0f, 0.0f, 0.0f))
 129         , __itemArea(FloatRectangle(0.0f, 0.0f, 0.0f, 0.0f))
 130         , __pTitleTextElement(null)
 131         , __pAccessibilityListener(null)
 132 {
 133         _AccessibilityContainer* pContainer = null;
 134
 135         __pButtonItems[LEFT_BUTTON] = null;
 136         __pButtonItems[RIGHT_BUTTON] = null;
 137         __pButtonItems[MIDDLE_BUTTON] = null;
 138
 139         for (int i = 0; i < TOOLBAR_ANIMATION_POSITION_MAX; i++)
 140         {
 141                 __pAnimation[i] = null;
 142                 __pAnimationFrameList[i] = null;
 143         }
 144
 145         Color bgColor;
 146
 147         if (__header == true)
 148         {
 149                 GET_COLOR_CONFIG(HEADER::BG_NORMAL, bgColor);
 150         }
 151         else
 152         {
 153                 GET_COLOR_CONFIG(FOOTER::BG_NORMAL, bgColor);
 154         }
 155
 156         SetColor(bgColor);
 157
 158         _Control::SetResizable(false);
 159
 160         _Control::SetMovable(false);
 161
 162         _ToolbarPresenter* pPresenter = new (std::nothrow) _ToolbarPresenter();
 163
 164         SetPresenter(*pPresenter);
 165
 166         pPresenter->Construct(*this);
 167
 168         pPresenter->Install();
 169
 170         pContainer = GetAccessibilityContainer();
 171
 172         if(pContainer)
 173         {
 174                 pContainer->Activate(true);
 175         }
 176
 177         for (int i = 0; i < TOOLBAR_ITEM_MAX_STATE_COUNT; i++)
 178         {
 179                 __isItemBgColorSetByUser[i] = false;
 180                 __isItemTextColorSetByUser[i] = false;
 181         }
 182
 183         for (int i = 0; i < TOOLBAR_BUTTON_MAX_STATE_COUNT; i++)
 184         {
 185                 __isButtonBgColorSetByUser[i] = false;
 186                 __isButtonTextColorSetByUser[i] = false;
 187         }
 188         __pAccessibilityListener = new (std::nothrow) FooterItemAccessibilityListener(this);
 189
 190         SetFocusNavigateEnabled(false);
 191 }
 192
 193 _Toolbar::~_Toolbar(void)
 194 {
 195         RemoveAllItems();               //__pMoreButton would be deleted in this function
 196         RemoveAllButtons();
 197
 198         if (__pToolbarPresenter)
 199         {
 200                 delete __pToolbarPresenter;
 201                 __pToolbarPresenter = null;
 202         }
 203
 204         if (__pActionEventListener)
 205         {
 206                 __pActionEventListener = null;
 207         }
 208
 209         if (__pBackEventListener)
 210         {
 211                 __pBackEventListener = null;
 212         }
 213
 214         if (__pMenuEventListener)
 215         {
 216                 __pMenuEventListener = null;
 217         }
 218
 219         if (__pLongPressGesture != null)
 220         {
 221                 __pLongPressGesture->RemoveGestureListener(*this);
 222                 RemoveGestureDetector(*__pLongPressGesture);
 223
 224                 delete __pLongPressGesture;
 225                 __pLongPressGesture = null;
 226         }
 227
 228         if (__pFlickGesture != null)
 229         {
 230                 __pFlickGesture->RemoveGestureListener(*this);
 231                 RemoveGestureDetector(*__pFlickGesture);
 232
 233                 delete __pFlickGesture;
 234                 __pFlickGesture = null;
 235         }
 236
 237         if (__pToolbarBackgroundBitmap)
 238         {
 239                 delete __pToolbarBackgroundBitmap;
 240                 __pToolbarBackgroundBitmap = null;
 241         }
 242
 243         if (__pToolbarBackgroundEffectBitmap)
 244         {
 245                 delete __pToolbarBackgroundEffectBitmap;
 246                 __pToolbarBackgroundEffectBitmap = null;
 247         }
 248
 249         if (__pTitleIcon)
 250         {
 251                 delete __pTitleIcon;
 252                 __pTitleIcon = null;
 253         }
 254
 255         for (int i = 0; i < TOOLBAR_ANIMATION_POSITION_MAX; i++)
 256         {
 257                 if (__pAnimationFrameList[i])
 258                 {
 259                         __pAnimationFrameList[i]->RemoveAll(true);
 260
 261                         delete __pAnimationFrameList[i];
 262                         __pAnimationFrameList[i] = null;
 263                 }
 264         }
 265
 266         if (__pAnimation[TOOLBAR_ANIMATION_POSITION_TITLE])
 267         {
 268                 DetachChild(*__pAnimation[TOOLBAR_ANIMATION_POSITION_TITLE]);
 269                 delete __pAnimation[TOOLBAR_ANIMATION_POSITION_TITLE];
 270                 __pAnimation[TOOLBAR_ANIMATION_POSITION_TITLE] = null;
 271         }
 272
 273         if (__pTitleBadgeIcon)
 274         {
 275                 DetachChild(*__pTitleBadgeIcon);
 276
 277                 delete __pTitleBadgeIcon;
 278                 __pTitleBadgeIcon = null;
 279         }
 280
 281         if (__pTitleTextElement)
 282         {
 283                 __pTitleTextElement->Activate(false);
 284                 __pTitleTextElement = null;
 285         }
 286
 287         if(__pAccessibilityListener)
 288         {
 289                 delete __pAccessibilityListener;
 290                 __pAccessibilityListener = null;
 291         }
 292         ClearLastResult();
 293 }
 294
 295 _Toolbar*
 296 _Toolbar::CreateToolbarN(bool header)
 297 {
 298         _Toolbar* pToolbar = new (std::nothrow) _Toolbar();
 299         SysTryReturn(NID_UI_CTRL, pToolbar, null, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] Memory shortage.");
 300
 301         pToolbar->Initialize(header);
 302         pToolbar->AcquireHandle();
 303
 304         pToolbar->SetTouchPressThreshold(SENSITIVE);
 305
 306         return pToolbar;
 307 }
 308
 309 result
 310 _Toolbar::Initialize(bool header)
 311 {
 312         __header = header;
 313
 314         return E_SUCCESS;
 315 }
 316
 317 bool
 318 _Toolbar::IsHeader(void)
 319 {
 320         return __header;
 321 }
 322
 323 result
 324 _Toolbar::InitToolbarColor(void)
 325 {
 326         if (__header == true)
 327         {
 328                 if (__transparent == true) // header && transparent
 329                 {
 330                         GET_COLOR_CONFIG(HEADER::TRANSLUCENT_TITLE_TEXT_NORMAL, __transTitleTextColor);
 331                         GET_COLOR_CONFIG(HEADER::TRANSLUCENT_DESCRIPTION_TEXT_NORMAL, __transDescriptionTextColor);
 332
 333                         if (__style == TOOLBAR_TEXT || __style == TOOLBAR_ICON || __style == TOOLBAR_ICON_TEXT || __style == TOOLBAR_COMMAND)
 334                         {
 335                                 GET_COLOR_CONFIG(HEADER::BUTTON_ITEM_TRANSLUCENT_BG_NORMAL, __itemTransBackgroundColor[_BUTTON_STATUS_NORMAL]);
 336                                 GET_COLOR_CONFIG(HEADER::BUTTON_ITEM_TRANSLUCENT_BG_DISABLED, __itemTransBackgroundColor[_BUTTON_STATUS_DISABLED]);
 337                                 GET_COLOR_CONFIG(HEADER::BUTTON_ITEM_TRANSLUCENT_BG_PRESSED, __itemTransBackgroundColor[_BUTTON_STATUS_PRESSED]);
 338                                 GET_COLOR_CONFIG(HEADER::BUTTON_ITEM_TRANSLUCENT_BG_HIGHLIGHTED, __itemTransBackgroundColor[_BUTTON_STATUS_HIGHLIGHTED]);
 339                                 //GET_COLOR_CONFIG(FOOTER::BUTTON_ITEM_TRANSLUCENT_BG_SELECTED, __itemTransBackgroundColor[_BUTTON_STATUS_SELECTED]);
 340
 341                                 GET_COLOR_CONFIG(HEADER::BUTTON_ITEM_TRANSLUCENT_TEXT_NORMAL, __itemTransTextColor[_BUTTON_STATUS_NORMAL]);
 342                                 GET_COLOR_CONFIG(HEADER::BUTTON_ITEM_TRANSLUCENT_TEXT_DISABLED, __itemTransTextColor[_BUTTON_STATUS_DISABLED]);
 343                                 GET_COLOR_CONFIG(HEADER::BUTTON_ITEM_TRANSLUCENT_TEXT_PRESSED, __itemTransTextColor[_BUTTON_STATUS_PRESSED]);
 344                                 GET_COLOR_CONFIG(HEADER::BUTTON_ITEM_TRANSLUCENT_TEXT_HIGHLIGHTED, __itemTransTextColor[_BUTTON_STATUS_HIGHLIGHTED]);
 345                                 //GET_COLOR_CONFIG(FOOTER::BUTTON_ITEM_TRANSLUCENT_TEXT_SELECTED, __itemTransTextColor[_BUTTON_STATUS_SELECTED]);
 346                         }
 347                         else if (__style == TOOLBAR_TAB || __style == TOOLBAR_TAB_WITH_TITLE || __style == TOOLBAR_TAB_LARGE)
 348                         {
 349                                 GET_COLOR_CONFIG(HEADER::TAB_ITEM_TRANSLUCENT_BG_NORMAL, __itemTransBackgroundColor[_BUTTON_STATUS_NORMAL]);
 350                                 GET_COLOR_CONFIG(HEADER::TAB_ITEM_TRANSLUCENT_BG_DISABLED, __itemTransBackgroundColor[_BUTTON_STATUS_DISABLED]);
 351                                 GET_COLOR_CONFIG(HEADER::TAB_ITEM_TRANSLUCENT_BG_PRESSED, __itemTransBackgroundColor[_BUTTON_STATUS_PRESSED]);
 352                                 GET_COLOR_CONFIG(HEADER::TAB_ITEM_TRANSLUCENT_BG_HIGHLIGHTED, __itemTransBackgroundColor[_BUTTON_STATUS_HIGHLIGHTED]);
 353                                 GET_COLOR_CONFIG(HEADER::TAB_ITEM_TRANSLUCENT_BG_SELECTED, __itemTransBackgroundColor[_BUTTON_STATUS_SELECTED]);
 354
 355                                 GET_COLOR_CONFIG(HEADER::TAB_ITEM_TRANSLUCENT_TEXT_NORMAL, __itemTransTextColor[_BUTTON_STATUS_NORMAL]);
 356                                 GET_COLOR_CONFIG(HEADER::TAB_ITEM_TRANSLUCENT_TEXT_DISABLED, __itemTransTextColor[_BUTTON_STATUS_DISABLED]);
 357                                 GET_COLOR_CONFIG(HEADER::TAB_ITEM_TRANSLUCENT_TEXT_PRESSED, __itemTransTextColor[_BUTTON_STATUS_PRESSED]);
 358                                 GET_COLOR_CONFIG(HEADER::TAB_ITEM_TRANSLUCENT_TEXT_HIGHLIGHTED, __itemTransTextColor[_BUTTON_STATUS_HIGHLIGHTED]);
 359                                 GET_COLOR_CONFIG(HEADER::TAB_ITEM_TRANSLUCENT_TEXT_SELECTED, __itemTransTextColor[_BUTTON_STATUS_SELECTED]);
 360                         }
 361                         else // TOOLBAR_TITLE, TOOLBAR_HEADER_SEGMENTED, TOOLBAR_HEADER_SEGMENTED_WITH_TITLE
 362                         {
 363                                 GET_COLOR_CONFIG(HEADER::SEGMENTED_ITEM_TRANSLUCENT_BG_NORMAL, __itemTransBackgroundColor[_BUTTON_STATUS_NORMAL]);
 364                                 GET_COLOR_CONFIG(HEADER::SEGMENTED_ITEM_TRANSLUCENT_BG_DISABLED, __itemTransBackgroundColor[_BUTTON_STATUS_DISABLED]);
 365                                 GET_COLOR_CONFIG(HEADER::SEGMENTED_ITEM_TRANSLUCENT_BG_PRESSED, __itemTransBackgroundColor[_BUTTON_STATUS_PRESSED]);
 366                                 GET_COLOR_CONFIG(HEADER::SEGMENTED_ITEM_TRANSLUCENT_BG_HIGHLIGHTED, __itemTransBackgroundColor[_BUTTON_STATUS_HIGHLIGHTED]);
 367                                 GET_COLOR_CONFIG(HEADER::SEGMENTED_ITEM_TRANSLUCENT_BG_SELECTED, __itemTransBackgroundColor[_BUTTON_STATUS_SELECTED]);
 368
 369                                 GET_COLOR_CONFIG(HEADER::SEGMENTED_ITEM_TRANSLUCENT_TEXT_NORMAL, __itemTransTextColor[_BUTTON_STATUS_NORMAL]);
 370                                 GET_COLOR_CONFIG(HEADER::SEGMENTED_ITEM_TRANSLUCENT_TEXT_DISABLED, __itemTransTextColor[_BUTTON_STATUS_DISABLED]);
 371                                 GET_COLOR_CONFIG(HEADER::SEGMENTED_ITEM_TRANSLUCENT_TEXT_PRESSED, __itemTransTextColor[_BUTTON_STATUS_PRESSED]);
 372                                 GET_COLOR_CONFIG(HEADER::SEGMENTED_ITEM_TRANSLUCENT_TEXT_HIGHLIGHTED, __itemTransTextColor[_BUTTON_STATUS_HIGHLIGHTED]);
 373                                 GET_COLOR_CONFIG(HEADER::SEGMENTED_ITEM_TRANSLUCENT_TEXT_SELECTED, __itemTransTextColor[_BUTTON_STATUS_SELECTED]);
 374                         }
 375
 376                         __itemTransBackgroundColor[_BUTTON_STATUS_NORMAL].SetAlpha(0x00);
 377                         __itemTransBackgroundColor[_BUTTON_STATUS_DISABLED].SetAlpha(0x00);
 378                         __itemTransBackgroundColor[_BUTTON_STATUS_PRESSED].SetAlpha(0x7F);
 379                         __itemTransBackgroundColor[_BUTTON_STATUS_HIGHLIGHTED].SetAlpha(0xFF);
 380                         __itemTransBackgroundColor[_BUTTON_STATUS_SELECTED].SetAlpha(0x00);
 381
 382                         GET_COLOR_CONFIG(HEADER::BUTTON_TRANSLUCENT_BG_NORMAL, __buttonTransBackgroundColor[_BUTTON_STATUS_NORMAL]);
 383                         GET_COLOR_CONFIG(HEADER::BUTTON_TRANSLUCENT_BG_DISABLED, __buttonTransBackgroundColor[_BUTTON_STATUS_DISABLED]);
 384                         GET_COLOR_CONFIG(HEADER::BUTTON_TRANSLUCENT_BG_PRESSED, __buttonTransBackgroundColor[_BUTTON_STATUS_PRESSED]);
 385                         GET_COLOR_CONFIG(HEADER::BUTTON_TRANSLUCENT_BG_HIGHLIGHTED, __buttonTransBackgroundColor[_BUTTON_STATUS_HIGHLIGHTED]);
 386
 387                         __buttonTransBackgroundColor[_BUTTON_STATUS_NORMAL].SetAlpha(0x00);
 388                         __buttonTransBackgroundColor[_BUTTON_STATUS_DISABLED].SetAlpha(0x00);
 389                         __buttonTransBackgroundColor[_BUTTON_STATUS_PRESSED].SetAlpha(0x7F);
 390                         __buttonTransBackgroundColor[_BUTTON_STATUS_HIGHLIGHTED].SetAlpha(0xFF);
 391
 392                         GET_COLOR_CONFIG(HEADER::BUTTON_TRANSLUCENT_TEXT_NORMAL, __buttonTransTextColor[_BUTTON_STATUS_NORMAL]);
 393                         GET_COLOR_CONFIG(HEADER::BUTTON_TRANSLUCENT_TEXT_DISABLED, __buttonTransTextColor[_BUTTON_STATUS_DISABLED]);
 394                         GET_COLOR_CONFIG(HEADER::BUTTON_TRANSLUCENT_TEXT_PRESSED, __buttonTransTextColor[_BUTTON_STATUS_PRESSED]);
 395                         GET_COLOR_CONFIG(HEADER::BUTTON_TRANSLUCENT_TEXT_HIGHLIGHTED, __buttonTransTextColor[_BUTTON_STATUS_HIGHLIGHTED]);
 396                 }
 397                 else // header && not transparent
 398                 {
 399                         GET_COLOR_CONFIG(HEADER::TITLE_TEXT_NORMAL, __titleTextColor);
 400                         GET_COLOR_CONFIG(HEADER::DESCRIPTION_TEXT_NORMAL, __descriptionTextColor);
 401
 402                         if (__style == TOOLBAR_TEXT || __style == TOOLBAR_ICON || __style == TOOLBAR_ICON_TEXT || __style == TOOLBAR_COMMAND)
 403                         {
 404                                 if (!__isItemBgColorSetByUser[_BUTTON_STATUS_NORMAL])
 405                                 {
 406                                         GET_COLOR_CONFIG(HEADER::BUTTON_ITEM_BG_NORMAL, __itemBackgroundColor[_BUTTON_STATUS_NORMAL]);
 407                                 }
 408                                 if (!__isItemBgColorSetByUser[_BUTTON_STATUS_DISABLED])
 409                                 {
 410                                         GET_COLOR_CONFIG(HEADER::BUTTON_ITEM_BG_DISABLED, __itemBackgroundColor[_BUTTON_STATUS_DISABLED]);
 411                                 }
 412                                 if (!__isItemBgColorSetByUser[_BUTTON_STATUS_PRESSED])
 413                                 {
 414                                         GET_COLOR_CONFIG(HEADER::BUTTON_ITEM_BG_PRESSED, __itemBackgroundColor[_BUTTON_STATUS_PRESSED]);
 415                                 }
 416                                 if (!__isItemBgColorSetByUser[_BUTTON_STATUS_HIGHLIGHTED])
 417                                 {
 418                                         GET_COLOR_CONFIG(HEADER::BUTTON_ITEM_BG_HIGHLIGHTED, __itemBackgroundColor[_BUTTON_STATUS_HIGHLIGHTED]);
 419                                 }
 420                                 //if (!__isItemBgColorSetByUser[_BUTTON_STATUS_SELECTED])
 421                                 //{
 422                                 //      GET_COLOR_CONFIG(FOOTER::BUTTON_ITEM_BG_SELECTED, __itemBackgroundColor[_BUTTON_STATUS_SELECTED]);
 423                                 //}
 424
 425                                 if (!__isItemTextColorSetByUser[_BUTTON_STATUS_NORMAL])
 426                                 {
 427                                         GET_COLOR_CONFIG(HEADER::BUTTON_ITEM_TEXT_NORMAL, __itemTextColor[_BUTTON_STATUS_NORMAL]);
 428                                 }
 429                                 if (!__isItemTextColorSetByUser[_BUTTON_STATUS_DISABLED])
 430                                 {
 431                                         GET_COLOR_CONFIG(HEADER::BUTTON_ITEM_TEXT_DISABLED, __itemTextColor[_BUTTON_STATUS_DISABLED]);
 432                                 }
 433                                 if (!__isItemTextColorSetByUser[_BUTTON_STATUS_PRESSED])
 434                                 {
 435                                         GET_COLOR_CONFIG(HEADER::BUTTON_ITEM_TEXT_PRESSED, __itemTextColor[_BUTTON_STATUS_PRESSED]);
 436                                 }
 437                                 if (!__isItemTextColorSetByUser[_BUTTON_STATUS_HIGHLIGHTED])
 438                                 {
 439                                         GET_COLOR_CONFIG(HEADER::BUTTON_ITEM_TEXT_HIGHLIGHTED, __itemTextColor[_BUTTON_STATUS_HIGHLIGHTED]);
 440                                 }
 441                                 //if (!__isItemTextColorSetByUser[_BUTTON_STATUS_SELECTED])
 442                                 //{
 443                                 //      GET_COLOR_CONFIG(FOOTER::BUTTON_ITEM_TEXT_SELECTED, __itemTextColor[_BUTTON_STATUS_SELECTED]);
 444                                 //}
 445                         }
 446                         else if (__style == TOOLBAR_TAB || __style == TOOLBAR_TAB_WITH_TITLE || __style == TOOLBAR_TAB_LARGE) // header
 447                         {
 448                                 if (!__isItemBgColorSetByUser[_BUTTON_STATUS_NORMAL])
 449                                 {
 450                                         GET_COLOR_CONFIG(HEADER::TAB_ITEM_BG_NORMAL, __itemBackgroundColor[_BUTTON_STATUS_NORMAL]);
 451                                 }
 452                                 if (!__isItemBgColorSetByUser[_BUTTON_STATUS_DISABLED])
 453                                 {
 454                                         GET_COLOR_CONFIG(HEADER::TAB_ITEM_BG_DISABLED, __itemBackgroundColor[_BUTTON_STATUS_DISABLED]);
 455                                 }
 456                                 if (!__isItemBgColorSetByUser[_BUTTON_STATUS_PRESSED])
 457                                 {
 458                                         GET_COLOR_CONFIG(HEADER::TAB_ITEM_BG_PRESSED, __itemBackgroundColor[_BUTTON_STATUS_PRESSED]);
 459                                 }
 460                                 if (!__isItemBgColorSetByUser[_BUTTON_STATUS_HIGHLIGHTED])
 461                                 {
 462                                         GET_COLOR_CONFIG(HEADER::TAB_ITEM_BG_HIGHLIGHTED, __itemBackgroundColor[_BUTTON_STATUS_HIGHLIGHTED]);
 463                                 }
 464                                 if (!__isItemBgColorSetByUser[_BUTTON_STATUS_SELECTED])
 465                                 {
 466                                         GET_COLOR_CONFIG(HEADER::TAB_ITEM_BG_SELECTED, __itemBackgroundColor[_BUTTON_STATUS_SELECTED]);
 467                                 }
 468
 469                                 if (!__isItemTextColorSetByUser[_BUTTON_STATUS_NORMAL])
 470                                 {
 471                                         GET_COLOR_CONFIG(HEADER::TAB_ITEM_TEXT_NORMAL, __itemTextColor[_BUTTON_STATUS_NORMAL]);
 472                                 }
 473                                 if (!__isItemTextColorSetByUser[_BUTTON_STATUS_DISABLED])
 474                                 {
 475                                         GET_COLOR_CONFIG(HEADER::TAB_ITEM_TEXT_DISABLED, __itemTextColor[_BUTTON_STATUS_DISABLED]);
 476                                 }
 477                                 if (!__isItemTextColorSetByUser[_BUTTON_STATUS_PRESSED])
 478                                 {
 479                                         GET_COLOR_CONFIG(HEADER::TAB_ITEM_TEXT_PRESSED, __itemTextColor[_BUTTON_STATUS_PRESSED]);
 480                                 }
 481                                 if (!__isItemTextColorSetByUser[_BUTTON_STATUS_HIGHLIGHTED])
 482                                 {
 483                                         GET_COLOR_CONFIG(HEADER::TAB_ITEM_TEXT_HIGHLIGHTED, __itemTextColor[_BUTTON_STATUS_HIGHLIGHTED]);
 484                                 }
 485                                 if (!__isItemTextColorSetByUser[_BUTTON_STATUS_SELECTED])
 486                                 {
 487                                         GET_COLOR_CONFIG(HEADER::TAB_ITEM_TEXT_SELECTED, __itemTextColor[_BUTTON_STATUS_SELECTED]);
 488                                 }
 489                         }
 490                         else // TOOLBAR_TITLE, TOOLBAR_HEADER_SEGMENTED, TOOLBAR_HEADER_SEGMENTED_WITH_TITLE,
 491                         {
 492                                 if (!__isItemBgColorSetByUser[_BUTTON_STATUS_NORMAL])
 493                                 {
 494                                         GET_COLOR_CONFIG(HEADER::SEGMENTED_ITEM_BG_NORMAL, __itemBackgroundColor[_BUTTON_STATUS_NORMAL]);
 495                                 }
 496                                 if (!__isItemBgColorSetByUser[_BUTTON_STATUS_DISABLED])
 497                                 {
 498                                         GET_COLOR_CONFIG(HEADER::SEGMENTED_ITEM_BG_DISABLED, __itemBackgroundColor[_BUTTON_STATUS_DISABLED]);
 499                                 }
 500                                 if (!__isItemBgColorSetByUser[_BUTTON_STATUS_PRESSED])
 501                                 {
 502                                         GET_COLOR_CONFIG(HEADER::SEGMENTED_ITEM_BG_PRESSED, __itemBackgroundColor[_BUTTON_STATUS_PRESSED]);
 503                                 }
 504                                 if (!__isItemBgColorSetByUser[_BUTTON_STATUS_HIGHLIGHTED])
 505                                 {
 506                                         GET_COLOR_CONFIG(HEADER::SEGMENTED_ITEM_BG_HIGHLIGHTED, __itemBackgroundColor[_BUTTON_STATUS_HIGHLIGHTED]);
 507                                 }
 508                                 if (!__isItemBgColorSetByUser[_BUTTON_STATUS_SELECTED])
 509                                 {
 510                                         GET_COLOR_CONFIG(HEADER::SEGMENTED_ITEM_BG_SELECTED, __itemBackgroundColor[_BUTTON_STATUS_SELECTED]);
 511                                 }
 512
 513                                 if (!__isItemTextColorSetByUser[_BUTTON_STATUS_NORMAL])
 514                                 {
 515                                         GET_COLOR_CONFIG(HEADER::SEGMENTED_ITEM_TEXT_NORMAL, __itemTextColor[_BUTTON_STATUS_NORMAL]);
 516                                 }
 517                                 if (!__isItemTextColorSetByUser[_BUTTON_STATUS_DISABLED])
 518                                 {
 519                                         GET_COLOR_CONFIG(HEADER::SEGMENTED_ITEM_TEXT_DISABLED, __itemTextColor[_BUTTON_STATUS_DISABLED]);
 520                                 }
 521                                 if (!__isItemTextColorSetByUser[_BUTTON_STATUS_PRESSED])
 522                                 {
 523                                         GET_COLOR_CONFIG(HEADER::SEGMENTED_ITEM_TEXT_PRESSED, __itemTextColor[_BUTTON_STATUS_PRESSED]);
 524                                 }
 525                                 if (!__isItemTextColorSetByUser[_BUTTON_STATUS_HIGHLIGHTED])
 526                                 {
 527                                         GET_COLOR_CONFIG(HEADER::SEGMENTED_ITEM_TEXT_HIGHLIGHTED, __itemTextColor[_BUTTON_STATUS_HIGHLIGHTED]);
 528                                 }
 529                                 if (!__isItemTextColorSetByUser[_BUTTON_STATUS_SELECTED])
 530                                 {
 531                                         GET_COLOR_CONFIG(HEADER::SEGMENTED_ITEM_TEXT_SELECTED, __itemTextColor[_BUTTON_STATUS_SELECTED]);
 532                                 }
 533                         }
 534
 535                         if (!__isButtonBgColorSetByUser[_BUTTON_STATUS_NORMAL])
 536                         {
 537                                 GET_COLOR_CONFIG(HEADER::BUTTON_BG_NORMAL, __buttonBackgroundColor[_BUTTON_STATUS_NORMAL]);
 538                         }
 539                         if (!__isButtonBgColorSetByUser[_BUTTON_STATUS_DISABLED])
 540                         {
 541                                 GET_COLOR_CONFIG(HEADER::BUTTON_BG_DISABLED, __buttonBackgroundColor[_BUTTON_STATUS_DISABLED]);
 542                         }
 543                         if (!__isButtonBgColorSetByUser[_BUTTON_STATUS_PRESSED])
 544                         {
 545                                 GET_COLOR_CONFIG(HEADER::BUTTON_BG_PRESSED, __buttonBackgroundColor[_BUTTON_STATUS_PRESSED]);
 546                         }
 547                         if (!__isButtonBgColorSetByUser[_BUTTON_STATUS_HIGHLIGHTED])
 548                         {
 549                                 GET_COLOR_CONFIG(HEADER::BUTTON_BG_HIGHLIGHTED, __buttonBackgroundColor[_BUTTON_STATUS_HIGHLIGHTED]);
 550                         }
 551
 552                         if (!__isButtonTextColorSetByUser[_BUTTON_STATUS_NORMAL])
 553                         {
 554                                 GET_COLOR_CONFIG(HEADER::BUTTON_TEXT_NORMAL, __buttonTextColor[_BUTTON_STATUS_NORMAL]);
 555                         }
 556                         if (!__isButtonTextColorSetByUser[_BUTTON_STATUS_DISABLED])
 557                         {
 558                                 GET_COLOR_CONFIG(HEADER::BUTTON_TEXT_DISABLED, __buttonTextColor[_BUTTON_STATUS_DISABLED]);
 559                         }
 560                         if (!__isButtonTextColorSetByUser[_BUTTON_STATUS_PRESSED])
 561                         {
 562                                 GET_COLOR_CONFIG(HEADER::BUTTON_TEXT_PRESSED, __buttonTextColor[_BUTTON_STATUS_PRESSED]);
 563                         }
 564                         if (!__isButtonTextColorSetByUser[_BUTTON_STATUS_HIGHLIGHTED])
 565                         {
 566                                 GET_COLOR_CONFIG(HEADER::BUTTON_TEXT_HIGHLIGHTED, __buttonTextColor[_BUTTON_STATUS_HIGHLIGHTED]);
 567                         }
 568                 }
 569         }
 570         else
 571         {
 572                 if (__transparent == true) // footer && transparent
 573                 {
 574                         if (__style == TOOLBAR_TEXT || __style == TOOLBAR_ICON || __style == TOOLBAR_ICON_TEXT || __style == TOOLBAR_COMMAND)
 575                         {
 576                                 GET_COLOR_CONFIG(FOOTER::BUTTON_ITEM_TRANSLUCENT_BG_NORMAL, __itemTransBackgroundColor[_BUTTON_STATUS_NORMAL]);
 577                                 GET_COLOR_CONFIG(FOOTER::BUTTON_ITEM_TRANSLUCENT_BG_DISABLED, __itemTransBackgroundColor[_BUTTON_STATUS_DISABLED]);
 578                                 GET_COLOR_CONFIG(FOOTER::BUTTON_ITEM_TRANSLUCENT_BG_PRESSED, __itemTransBackgroundColor[_BUTTON_STATUS_PRESSED]);
 579                                 GET_COLOR_CONFIG(FOOTER::BUTTON_ITEM_TRANSLUCENT_BG_HIGHLIGHTED, __itemTransBackgroundColor[_BUTTON_STATUS_HIGHLIGHTED]);
 580                                 //GET_COLOR_CONFIG(FOOTER::BUTTON_ITEM_TRANSLUCENT_BG_SELECTED, __itemTransBackgroundColor[_BUTTON_STATUS_SELECTED]);
 581
 582                                 GET_COLOR_CONFIG(FOOTER::BUTTON_ITEM_TRANSLUCENT_TEXT_NORMAL, __itemTransTextColor[_BUTTON_STATUS_NORMAL]);
 583                                 GET_COLOR_CONFIG(FOOTER::BUTTON_ITEM_TRANSLUCENT_TEXT_DISABLED, __itemTransTextColor[_BUTTON_STATUS_DISABLED]);
 584                                 GET_COLOR_CONFIG(FOOTER::BUTTON_ITEM_TRANSLUCENT_TEXT_PRESSED, __itemTransTextColor[_BUTTON_STATUS_PRESSED]);
 585                                 GET_COLOR_CONFIG(FOOTER::BUTTON_ITEM_TRANSLUCENT_TEXT_HIGHLIGHTED, __itemTransTextColor[_BUTTON_STATUS_HIGHLIGHTED]);
 586                                 //GET_COLOR_CONFIG(FOOTER::BUTTON_ITEM_TRANSLUCENT_TEXT_SELECTED, __itemTransTextColor[_BUTTON_STATUS_SELECTED]);
 587                         }
 588                         else if (__style == TOOLBAR_TAB || __style == TOOLBAR_TAB_LARGE)
 589                         {
 590                                 GET_COLOR_CONFIG(FOOTER::TAB_ITEM_TRANSLUCENT_BG_NORMAL, __itemTransBackgroundColor[_BUTTON_STATUS_NORMAL]);
 591                                 GET_COLOR_CONFIG(FOOTER::TAB_ITEM_TRANSLUCENT_BG_DISABLED, __itemTransBackgroundColor[_BUTTON_STATUS_DISABLED]);
 592                                 GET_COLOR_CONFIG(FOOTER::TAB_ITEM_TRANSLUCENT_BG_PRESSED, __itemTransBackgroundColor[_BUTTON_STATUS_PRESSED]);
 593                                 GET_COLOR_CONFIG(FOOTER::TAB_ITEM_TRANSLUCENT_BG_HIGHLIGHTED, __itemTransBackgroundColor[_BUTTON_STATUS_HIGHLIGHTED]);
 594                                 GET_COLOR_CONFIG(FOOTER::TAB_ITEM_TRANSLUCENT_BG_SELECTED, __itemTransBackgroundColor[_BUTTON_STATUS_SELECTED]);
 595
 596                                 GET_COLOR_CONFIG(FOOTER::TAB_ITEM_TRANSLUCENT_TEXT_NORMAL, __itemTransTextColor[_BUTTON_STATUS_NORMAL]);
 597                                 GET_COLOR_CONFIG(FOOTER::TAB_ITEM_TRANSLUCENT_TEXT_DISABLED, __itemTransTextColor[_BUTTON_STATUS_DISABLED]);
 598                                 GET_COLOR_CONFIG(FOOTER::TAB_ITEM_TRANSLUCENT_TEXT_PRESSED, __itemTransTextColor[_BUTTON_STATUS_PRESSED]);
 599                                 GET_COLOR_CONFIG(FOOTER::TAB_ITEM_TRANSLUCENT_TEXT_HIGHLIGHTED, __itemTransTextColor[_BUTTON_STATUS_HIGHLIGHTED]);
 600                                 GET_COLOR_CONFIG(FOOTER::TAB_ITEM_TRANSLUCENT_TEXT_SELECTED, __itemTransTextColor[_BUTTON_STATUS_SELECTED]);
 601                         }
 602                         else // TOOLBAR_SEGMENTED
 603                         {
 604                                 GET_COLOR_CONFIG(FOOTER::SEGMENTED_ITEM_TRANSLUCENT_BG_NORMAL, __itemTransBackgroundColor[_BUTTON_STATUS_NORMAL]);
 605                                 GET_COLOR_CONFIG(FOOTER::SEGMENTED_ITEM_TRANSLUCENT_BG_DISABLED, __itemTransBackgroundColor[_BUTTON_STATUS_DISABLED]);
 606                                 GET_COLOR_CONFIG(FOOTER::SEGMENTED_ITEM_TRANSLUCENT_BG_PRESSED, __itemTransBackgroundColor[_BUTTON_STATUS_PRESSED]);
 607                                 GET_COLOR_CONFIG(FOOTER::SEGMENTED_ITEM_TRANSLUCENT_BG_HIGHLIGHTED, __itemTransBackgroundColor[_BUTTON_STATUS_HIGHLIGHTED]);
 608                                 GET_COLOR_CONFIG(FOOTER::SEGMENTED_ITEM_TRANSLUCENT_BG_SELECTED, __itemTransBackgroundColor[_BUTTON_STATUS_SELECTED]);
 609
 610                                 GET_COLOR_CONFIG(FOOTER::SEGMENTED_ITEM_TRANSLUCENT_TEXT_NORMAL, __itemTransTextColor[_BUTTON_STATUS_NORMAL]);
 611                                 GET_COLOR_CONFIG(FOOTER::SEGMENTED_ITEM_TRANSLUCENT_TEXT_DISABLED, __itemTransTextColor[_BUTTON_STATUS_DISABLED]);
 612                                 GET_COLOR_CONFIG(FOOTER::SEGMENTED_ITEM_TRANSLUCENT_TEXT_PRESSED, __itemTransTextColor[_BUTTON_STATUS_PRESSED]);
 613                                 GET_COLOR_CONFIG(FOOTER::SEGMENTED_ITEM_TRANSLUCENT_TEXT_HIGHLIGHTED, __itemTransTextColor[_BUTTON_STATUS_HIGHLIGHTED]);
 614                                 GET_COLOR_CONFIG(FOOTER::SEGMENTED_ITEM_TRANSLUCENT_TEXT_SELECTED, __itemTransTextColor[_BUTTON_STATUS_SELECTED]);
 615                         }
 616
 617                         __itemTransBackgroundColor[_BUTTON_STATUS_NORMAL].SetAlpha(0x00);
 618                         __itemTransBackgroundColor[_BUTTON_STATUS_DISABLED].SetAlpha(0x00);
 619                         __itemTransBackgroundColor[_BUTTON_STATUS_PRESSED].SetAlpha(0x7F);
 620                         __itemTransBackgroundColor[_BUTTON_STATUS_HIGHLIGHTED].SetAlpha(0xFF);
 621                         __itemTransBackgroundColor[_BUTTON_STATUS_SELECTED].SetAlpha(0x00);
 622
 623
 624                         GET_COLOR_CONFIG(FOOTER::BUTTON_TRANSLUCENT_BG_NORMAL, __buttonTransBackgroundColor[_BUTTON_STATUS_NORMAL]);
 625                         GET_COLOR_CONFIG(FOOTER::BUTTON_TRANSLUCENT_BG_DISABLED, __buttonTransBackgroundColor[_BUTTON_STATUS_DISABLED]);
 626                         GET_COLOR_CONFIG(FOOTER::BUTTON_TRANSLUCENT_BG_PRESSED, __buttonTransBackgroundColor[_BUTTON_STATUS_PRESSED]);
 627                         GET_COLOR_CONFIG(FOOTER::BUTTON_TRANSLUCENT_BG_HIGHLIGHTED, __buttonTransBackgroundColor[_BUTTON_STATUS_HIGHLIGHTED]);
 628
 629                         __buttonTransBackgroundColor[_BUTTON_STATUS_NORMAL].SetAlpha(0x00);
 630                         __buttonTransBackgroundColor[_BUTTON_STATUS_DISABLED].SetAlpha(0x00);
 631                         __buttonTransBackgroundColor[_BUTTON_STATUS_PRESSED].SetAlpha(0x7F);
 632                         __buttonTransBackgroundColor[_BUTTON_STATUS_HIGHLIGHTED].SetAlpha(0xFF);
 633
 634                         GET_COLOR_CONFIG(FOOTER::BUTTON_TRANSLUCENT_TEXT_NORMAL, __buttonTransTextColor[_BUTTON_STATUS_NORMAL]);
 635                         GET_COLOR_CONFIG(FOOTER::BUTTON_TRANSLUCENT_TEXT_DISABLED, __buttonTransTextColor[_BUTTON_STATUS_DISABLED]);
 636                         GET_COLOR_CONFIG(FOOTER::BUTTON_TRANSLUCENT_TEXT_PRESSED, __buttonTransTextColor[_BUTTON_STATUS_PRESSED]);
 637                         GET_COLOR_CONFIG(FOOTER::BUTTON_TRANSLUCENT_TEXT_HIGHLIGHTED, __buttonTransTextColor[_BUTTON_STATUS_HIGHLIGHTED]);
 638                 }
 639                 else // footer && not transparent
 640                 {
 641                         if (__style == TOOLBAR_TEXT || __style == TOOLBAR_ICON || __style == TOOLBAR_ICON_TEXT || __style == TOOLBAR_COMMAND)
 642                         {
 643                                 if (!__isItemBgColorSetByUser[_BUTTON_STATUS_NORMAL])
 644                                 {
 645                                         GET_COLOR_CONFIG(FOOTER::BUTTON_ITEM_BG_NORMAL, __itemBackgroundColor[_BUTTON_STATUS_NORMAL]);
 646                                 }
 647                                 if (!__isItemBgColorSetByUser[_BUTTON_STATUS_DISABLED])
 648                                 {
 649                                         GET_COLOR_CONFIG(FOOTER::BUTTON_ITEM_BG_DISABLED, __itemBackgroundColor[_BUTTON_STATUS_DISABLED]);
 650                                 }
 651                                 if (!__isItemBgColorSetByUser[_BUTTON_STATUS_PRESSED])
 652                                 {
 653                                         GET_COLOR_CONFIG(FOOTER::BUTTON_ITEM_BG_PRESSED, __itemBackgroundColor[_BUTTON_STATUS_PRESSED]);
 654                                 }
 655                                 if (!__isItemBgColorSetByUser[_BUTTON_STATUS_HIGHLIGHTED])
 656                                 {
 657                                         GET_COLOR_CONFIG(FOOTER::BUTTON_ITEM_BG_HIGHLIGHTED, __itemBackgroundColor[_BUTTON_STATUS_HIGHLIGHTED]);
 658                                 }
 659                                 //if (!__isItemBgColorSetByUser[_BUTTON_STATUS_SELECTED])
 660                                 //{
 661                                 //      GET_COLOR_CONFIG(FOOTER::BUTTON_ITEM_BG_SELECTED, __itemBackgroundColor[_BUTTON_STATUS_SELECTED]);
 662                                 //}
 663
 664                                 if (!__isItemTextColorSetByUser[_BUTTON_STATUS_NORMAL])
 665                                 {
 666                                         GET_COLOR_CONFIG(FOOTER::BUTTON_ITEM_TEXT_NORMAL, __itemTextColor[_BUTTON_STATUS_NORMAL]);
 667                                 }
 668                                 if (!__isItemTextColorSetByUser[_BUTTON_STATUS_DISABLED])
 669                                 {
 670                                         GET_COLOR_CONFIG(FOOTER::BUTTON_ITEM_TEXT_DISABLED, __itemTextColor[_BUTTON_STATUS_DISABLED]);
 671                                 }
 672                                 if (!__isItemTextColorSetByUser[_BUTTON_STATUS_PRESSED])
 673                                 {
 674                                         GET_COLOR_CONFIG(FOOTER::BUTTON_ITEM_TEXT_PRESSED, __itemTextColor[_BUTTON_STATUS_PRESSED]);
 675                                 }
 676                                 if (!__isItemTextColorSetByUser[_BUTTON_STATUS_HIGHLIGHTED])
 677                                 {
 678                                         GET_COLOR_CONFIG(FOOTER::BUTTON_ITEM_TEXT_HIGHLIGHTED, __itemTextColor[_BUTTON_STATUS_HIGHLIGHTED]);
 679                                 }
 680                                 //if (!__isItemTextColorSetByUser[_BUTTON_STATUS_SELECTED])
 681                                 //{
 682                                 //      GET_COLOR_CONFIG(FOOTER::BUTTON_ITEM_TEXT_SELECTED, __itemTextColor[_BUTTON_STATUS_SELECTED]);
 683                                 //}
 684                         }
 685                         else if (__style == TOOLBAR_TAB || __style == TOOLBAR_TAB_LARGE)
 686                         {
 687                                 if (!__isItemBgColorSetByUser[_BUTTON_STATUS_NORMAL])
 688                                 {
 689                                         GET_COLOR_CONFIG(FOOTER::TAB_ITEM_BG_NORMAL, __itemBackgroundColor[_BUTTON_STATUS_NORMAL]);
 690                                 }
 691                                 if (!__isItemBgColorSetByUser[_BUTTON_STATUS_DISABLED])
 692                                 {
 693                                         GET_COLOR_CONFIG(FOOTER::TAB_ITEM_BG_DISABLED, __itemBackgroundColor[_BUTTON_STATUS_DISABLED]);
 694                                 }
 695                                 if (!__isItemBgColorSetByUser[_BUTTON_STATUS_PRESSED])
 696                                 {
 697                                         GET_COLOR_CONFIG(FOOTER::TAB_ITEM_BG_PRESSED, __itemBackgroundColor[_BUTTON_STATUS_PRESSED]);
 698                                 }
 699                                 if (!__isItemBgColorSetByUser[_BUTTON_STATUS_HIGHLIGHTED])
 700                                 {
 701                                         GET_COLOR_CONFIG(FOOTER::TAB_ITEM_BG_HIGHLIGHTED, __itemBackgroundColor[_BUTTON_STATUS_HIGHLIGHTED]);
 702                                 }
 703                                 if (!__isItemBgColorSetByUser[_BUTTON_STATUS_SELECTED])
 704                                 {
 705                                         GET_COLOR_CONFIG(FOOTER::TAB_ITEM_BG_SELECTED, __itemBackgroundColor[_BUTTON_STATUS_SELECTED]);
 706                                 }
 707
 708                                 if (!__isItemTextColorSetByUser[_BUTTON_STATUS_NORMAL])
 709                                 {
 710                                         GET_COLOR_CONFIG(FOOTER::TAB_ITEM_TEXT_NORMAL, __itemTextColor[_BUTTON_STATUS_NORMAL]);
 711                                 }
 712                                 if (!__isItemTextColorSetByUser[_BUTTON_STATUS_DISABLED])
 713                                 {
 714                                         GET_COLOR_CONFIG(FOOTER::TAB_ITEM_TEXT_DISABLED, __itemTextColor[_BUTTON_STATUS_DISABLED]);
 715                                 }
 716                                 if (!__isItemTextColorSetByUser[_BUTTON_STATUS_PRESSED])
 717                                 {
 718                                         GET_COLOR_CONFIG(FOOTER::TAB_ITEM_TEXT_PRESSED, __itemTextColor[_BUTTON_STATUS_PRESSED]);
 719                                 }
 720                                 if (!__isItemTextColorSetByUser[_BUTTON_STATUS_HIGHLIGHTED])
 721                                 {
 722                                         GET_COLOR_CONFIG(FOOTER::TAB_ITEM_TEXT_HIGHLIGHTED, __itemTextColor[_BUTTON_STATUS_HIGHLIGHTED]);
 723                                 }
 724                                 if (!__isItemTextColorSetByUser[_BUTTON_STATUS_SELECTED])
 725                                 {
 726                                         GET_COLOR_CONFIG(FOOTER::TAB_ITEM_TEXT_SELECTED, __itemTextColor[_BUTTON_STATUS_SELECTED]);
 727                                 }
 728                         }
 729                         else // TOOLBAR_SEGMENTED
 730                         {
 731                                 if (!__isItemBgColorSetByUser[_BUTTON_STATUS_NORMAL])
 732                                 {
 733                                         GET_COLOR_CONFIG(FOOTER::SEGMENTED_ITEM_BG_NORMAL, __itemBackgroundColor[_BUTTON_STATUS_NORMAL]);
 734                                 }
 735                                 if (!__isItemBgColorSetByUser[_BUTTON_STATUS_DISABLED])
 736                                 {
 737                                         GET_COLOR_CONFIG(FOOTER::SEGMENTED_ITEM_BG_DISABLED, __itemBackgroundColor[_BUTTON_STATUS_DISABLED]);
 738                                 }
 739                                 if (!__isItemBgColorSetByUser[_BUTTON_STATUS_PRESSED])
 740                                 {
 741                                         GET_COLOR_CONFIG(FOOTER::SEGMENTED_ITEM_BG_PRESSED, __itemBackgroundColor[_BUTTON_STATUS_PRESSED]);
 742                                 }
 743                                 if (!__isItemBgColorSetByUser[_BUTTON_STATUS_HIGHLIGHTED])
 744                                 {
 745                                         GET_COLOR_CONFIG(FOOTER::SEGMENTED_ITEM_BG_HIGHLIGHTED, __itemBackgroundColor[_BUTTON_STATUS_HIGHLIGHTED]);
 746                                 }
 747                                 if (!__isItemBgColorSetByUser[_BUTTON_STATUS_SELECTED])
 748                                 {
 749                                         GET_COLOR_CONFIG(FOOTER::SEGMENTED_ITEM_BG_SELECTED, __itemBackgroundColor[_BUTTON_STATUS_SELECTED]);
 750                                 }
 751
 752                                 if (!__isItemTextColorSetByUser[_BUTTON_STATUS_NORMAL])
 753                                 {
 754                                         GET_COLOR_CONFIG(FOOTER::SEGMENTED_ITEM_TEXT_NORMAL, __itemTextColor[_BUTTON_STATUS_NORMAL]);
 755                                 }
 756                                 if (!__isItemTextColorSetByUser[_BUTTON_STATUS_DISABLED])
 757                                 {
 758                                         GET_COLOR_CONFIG(FOOTER::SEGMENTED_ITEM_TEXT_DISABLED, __itemTextColor[_BUTTON_STATUS_DISABLED]);
 759                                 }
 760                                 if (!__isItemTextColorSetByUser[_BUTTON_STATUS_PRESSED])
 761                                 {
 762                                         GET_COLOR_CONFIG(FOOTER::SEGMENTED_ITEM_TEXT_PRESSED, __itemTextColor[_BUTTON_STATUS_PRESSED]);
 763                                 }
 764                                 if (!__isItemTextColorSetByUser[_BUTTON_STATUS_HIGHLIGHTED])
 765                                 {
 766                                         GET_COLOR_CONFIG(FOOTER::SEGMENTED_ITEM_TEXT_HIGHLIGHTED, __itemTextColor[_BUTTON_STATUS_HIGHLIGHTED]);
 767                                 }
 768                                 if (!__isItemTextColorSetByUser[_BUTTON_STATUS_SELECTED])
 769                                 {
 770                                         GET_COLOR_CONFIG(FOOTER::SEGMENTED_ITEM_TEXT_SELECTED, __itemTextColor[_BUTTON_STATUS_SELECTED]);
 771                                 }
 772                         }
 773
 774                         if (!__isButtonBgColorSetByUser[_BUTTON_STATUS_NORMAL])
 775                         {
 776                                 GET_COLOR_CONFIG(FOOTER::BUTTON_BG_NORMAL, __buttonBackgroundColor[_BUTTON_STATUS_NORMAL]);
 777                         }
 778                         if (!__isButtonBgColorSetByUser[_BUTTON_STATUS_DISABLED])
 779                         {
 780                                 GET_COLOR_CONFIG(FOOTER::BUTTON_BG_DISABLED, __buttonBackgroundColor[_BUTTON_STATUS_DISABLED]);
 781                         }
 782                         if (!__isButtonBgColorSetByUser[_BUTTON_STATUS_PRESSED])
 783                         {
 784                                 GET_COLOR_CONFIG(FOOTER::BUTTON_BG_PRESSED, __buttonBackgroundColor[_BUTTON_STATUS_PRESSED]);
 785                         }
 786                         if (!__isButtonBgColorSetByUser[_BUTTON_STATUS_HIGHLIGHTED])
 787                         {
 788                                 GET_COLOR_CONFIG(FOOTER::BUTTON_BG_HIGHLIGHTED, __buttonBackgroundColor[_BUTTON_STATUS_HIGHLIGHTED]);
 789                         }
 790
 791                         if (!__isButtonTextColorSetByUser[_BUTTON_STATUS_NORMAL])
 792                         {
 793                                 GET_COLOR_CONFIG(FOOTER::BUTTON_TEXT_NORMAL, __buttonTextColor[_BUTTON_STATUS_NORMAL]);
 794                         }
 795                         if (!__isButtonTextColorSetByUser[_BUTTON_STATUS_DISABLED])
 796                         {
 797                                 GET_COLOR_CONFIG(FOOTER::BUTTON_TEXT_DISABLED, __buttonTextColor[_BUTTON_STATUS_DISABLED]);
 798                         }
 799                         if (!__isButtonTextColorSetByUser[_BUTTON_STATUS_PRESSED])
 800                         {
 801                                 GET_COLOR_CONFIG(FOOTER::BUTTON_TEXT_PRESSED, __buttonTextColor[_BUTTON_STATUS_PRESSED]);
 802                         }
 803                         if (!__isButtonTextColorSetByUser[_BUTTON_STATUS_HIGHLIGHTED])
 804                         {
 805                                 GET_COLOR_CONFIG(FOOTER::BUTTON_TEXT_HIGHLIGHTED, __buttonTextColor[_BUTTON_STATUS_HIGHLIGHTED]);
 806                         }
 807                 }
 808         }
 809
 810         return E_SUCCESS;
 811 }
 812
 813 result
 814 _Toolbar::InitializeLongPressGesture(void)
 815 {
 816         result r = E_SUCCESS;
 817
 818         __pLongPressGesture = new (std::nothrow) _TouchLongPressGestureDetector();
 819         SysTryReturn(NID_UI_CTRL, __pLongPressGesture, E_OUT_OF_MEMORY, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] Failed to create touch long press gesture.");
 820
 821         __pLongPressGesture->SetDuration(500);
 822
 823         r = AddGestureDetector(*__pLongPressGesture);
 824         SysTryReturn(NID_UI_CTRL, r == E_SUCCESS, r, r, "[%s] Failed to add gesture detector", GetErrorMessage(r));
 825
 826         r = __pLongPressGesture->AddGestureListener(*(dynamic_cast<_ITouchLongPressGestureEventListener*>(this)));
 827         SysTryReturn(NID_UI_CTRL, r == E_SUCCESS, r, r, "[%s] Failed to add gesture listener", GetErrorMessage(r));
 828
 829         return r;
 830 }
 831
 832 result
 833 _Toolbar::InitializeFlickGesture(void)
 834 {
 835         result r = E_SUCCESS;
 836
 837         __pFlickGesture = new (std::nothrow) _TouchFlickGestureDetector();
 838         SysTryReturn(NID_UI_CTRL, __pFlickGesture, E_OUT_OF_MEMORY, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] Failed to create flick gesture.");
 839
 840         r = AddGestureDetector(*__pFlickGesture);
 841         SysTryReturn(NID_UI_CTRL, r == E_SUCCESS, r, r, "[%s] Failed to add gesture detector", GetErrorMessage(r));
 842
 843         r = __pFlickGesture->AddGestureListener(*(dynamic_cast<_ITouchFlickGestureEventListener*>(this)));
 844         SysTryReturn(NID_UI_CTRL, r == E_SUCCESS, r, r, "[%s] Failed to add gesture listener", GetErrorMessage(r));
 845
 846         return r;
 847 }
 848
 849 result
 850 _Toolbar::Construct(void)
 851 {
 852         result r = E_SUCCESS;
 853
 854         return r;
 855 }
 856
 857 result
 858 _Toolbar::AddItem(_Button* pButton)
 859 {
 860         SysTryReturnResult(NID_UI_CTRL, (__itemCount < TAB_ITEM_MAX), E_MAX_EXCEEDED,
 861                                 "[E_MAX_EXCEEDED] The number of items have exceeded the maximum limit.");
 862
 863         if (__pActionEventListener != null)
 864         {
 865                 pButton->AddActionEventListener(*__pActionEventListener);
 866         }
 867
 868         __pItems.push_back(pButton);
 869         __itemCount++;
 870
 871         SetFocusNavigateEnabled(true);
 872
 873         AttachChild(*pButton);
 874
 875         ApplyUserGUI(TOOLBAR_ITEM, pButton);
 876
 877         RearrangeItems();
 878
 879         AddAccessibilityElement(pButton);
 880
 881         return E_SUCCESS;
 882 }
 883
 884 Bitmap*
 885 _Toolbar::GetBackgroundBitmap(void) const
 886 {
 887         result r = E_SUCCESS;
 888
 889         _Toolbar* pToolbar = const_cast<_Toolbar*>(this);
 890
 891         if (!pToolbar->__pToolbarBackgroundBitmap)
 892         {
 893                 if(__header == true)
 894                 {
 895                         r = GET_BITMAP_CONFIG_N(HEADER::BG_NORMAL, BITMAP_PIXEL_FORMAT_ARGB8888, pToolbar->__pToolbarBackgroundBitmap);
 896                         SysTryReturn(NID_UI_CTRL, r == E_SUCCESS, null, r, "[%s] Propagating.", GetErrorMessage(r));
 897                 }
 898                 else
 899                 {
 900                         r = GET_BITMAP_CONFIG_N(FOOTER::BG_NORMAL, BITMAP_PIXEL_FORMAT_ARGB8888, pToolbar->__pToolbarBackgroundBitmap);
 901                         SysTryReturn(NID_UI_CTRL, r == E_SUCCESS, null, r, "[%s] Propagating.", GetErrorMessage(r));
 902                 }
 903         }
 904
 905         return pToolbar->__pToolbarBackgroundBitmap;
 906 }
 907
 908 Bitmap*
 909 _Toolbar::GetBackgroundEffectBitmap(void) const
 910 {
 911         result r = E_SUCCESS;
 912
 913         _Toolbar* pToolbar = const_cast<_Toolbar*>(this);
 914
 915         if (!pToolbar->__pToolbarBackgroundEffectBitmap)
 916         {
 917                 if(__header == true)
 918                 {
 919                         bool customTheme = IS_CUSTOM_BITMAP(HEADER::BG_NORMAL);
 920                         if (customTheme == false)
 921                         {
 922                                 r = GET_BITMAP_CONFIG_N(HEADER::BG_EFFECT_NORMAL, BITMAP_PIXEL_FORMAT_ARGB8888, pToolbar->__pToolbarBackgroundEffectBitmap);
 923                                 SysTryReturn(NID_UI_CTRL, r == E_SUCCESS, null, r, "[%s] Propagating.", GetErrorMessage(r));
 924                         }
 925                 }
 926                 else
 927                 {
 928                         bool customTheme = IS_CUSTOM_BITMAP(FOOTER::BG_NORMAL);
 929                         if (customTheme == false)
 930                         {
 931                                 r = GET_BITMAP_CONFIG_N(FOOTER::BG_EFFECT_NORMAL, BITMAP_PIXEL_FORMAT_ARGB8888, pToolbar->__pToolbarBackgroundEffectBitmap);
 932                                 SysTryReturn(NID_UI_CTRL, r == E_SUCCESS, null, r, "[%s] Propagating.", GetErrorMessage(r));
 933                         }
 934                 }
 935         }
 936
 937         return pToolbar->__pToolbarBackgroundEffectBitmap;
 938 }
 939
 940 _Button*
 941 _Toolbar::GetButton(ToolbarButton position) const
 942 {
 943         SysTryReturn(NID_UI_CTRL, (position >= LEFT_BUTTON && position < BUTTON_MAX), null, E_OUT_OF_RANGE,
 944                                 ("[E_OUT_OF_RANGE] The position is out of range."));
 945
 946         return __pButtonItems[position];
 947 }
 948
 949 _Label*
 950 _Toolbar::GetTitleBadgeIcon(void) const
 951 {
 952         return __pTitleBadgeIcon;
 953 }
 954
 955 Color
 956 _Toolbar::GetButtonColor(_ButtonStatus status) const
 957 {
 958         Variant color;
 959
 960         switch (status)
 961         {
 962         case _BUTTON_STATUS_NORMAL:
 963                 color = GetProperty(L"normalButtonColor");
 964                 break;
 965         case _BUTTON_STATUS_DISABLED:
 966                 color = GetProperty(L"disabledButtonColor");
 967                 break;
 968         case _BUTTON_STATUS_PRESSED:
 969                 color = GetProperty(L"pressedButtonColor");
 970                 break;
 971         case _BUTTON_STATUS_HIGHLIGHTED:
 972                 color = GetProperty(L"highlightedButtonColor");
 973                 break;
 974         default:
 975                 color = GetProperty(L"normalButtonColor");
 976                 break;
 977         }
 978
 979         return color.ToColor();
 980 }
 981
 982 _ButtonStatus
 983 _Toolbar::GetButtonStatus(ToolbarButton position) const
 984 {
 985         return __pButtonItems[position]->GetButtonStatus();
 986 }
 987
 988 Color
 989 _Toolbar::GetButtonTextColor(_ButtonStatus status) const
 990 {
 991         Variant color;
 992
 993         switch (status)
 994         {
 995         case _BUTTON_STATUS_NORMAL:
 996                 color = GetProperty(L"normalButtonTextColor");
 997                 break;
 998         case _BUTTON_STATUS_DISABLED:
 999                 color = GetProperty(L"disabledButtonTextColor");
1000                 break;
1001         case _BUTTON_STATUS_PRESSED:
1002                 color = GetProperty(L"pressedButtonTextColor");
1003                 break;
1004         case _BUTTON_STATUS_HIGHLIGHTED:
1005                 color = GetProperty(L"highlightedButtonTextColor");
1006                 break;
1007         default:
1008                 color = GetProperty(L"normalButtonTextColor");
1009                 break;
1010         }
1011
1012         return color.ToColor();
1013 }
1014
1015 Color
1016 _Toolbar::GetColor(void) const
1017 {
1018         Variant color = GetProperty(L"color");
1019
1020         return color.ToColor();
1021 }
1022
1023 String
1024 _Toolbar::GetDescriptionText(void) const
1025 {
1026         Variant text = GetProperty(L"descriptionText");
1027
1028         return text.ToString();
1029 }
1030
1031 Color
1032 _Toolbar::GetDescriptionTextColor(void) const
1033 {
1034         Variant color = GetProperty(L"descriptionTextColor");
1035
1036         return color.ToColor();
1037 }
1038
1039 int
1040 _Toolbar::GetFirstEnabledItemIndex(void) const
1041 {
1042         int firstEnabledItemIndex = -1;
1043
1044         for (int i = 0; i < __itemCount; i++)
1045         {
1046                 if(__pItems.at(i)->GetButtonStatus() != _BUTTON_STATUS_DISABLED)
1047                 {
1048                         firstEnabledItemIndex = i;
1049                         break;
1050                 }
1051         }
1052
1053         return firstEnabledItemIndex;
1054 }
1055
1056 _Button*
1057 _Toolbar::GetItem(int itemIndex) const
1058 {
1059         if (__pItems.at(itemIndex) == null)
1060         {
1061                 SysLogException(NID_UI_CTRL, E_SYSTEM, "[E_SYSTEM] Unable to get item.");
1062                 return null;
1063         }
1064
1065         return __pItems.at(itemIndex);
1066 }
1067
1068 Color
1069 _Toolbar::GetItemColor(_ButtonStatus status) const
1070 {
1071         Variant color;
1072
1073         switch (status)
1074         {
1075         case _BUTTON_STATUS_NORMAL:
1076                 color = GetProperty(L"normalItemColor");
1077                 break;
1078         case _BUTTON_STATUS_DISABLED:
1079                 color = GetProperty(L"disabledItemColor");
1080                 break;
1081         case _BUTTON_STATUS_PRESSED:
1082                 color = GetProperty(L"pressedItemColor");
1083                 break;
1084         case _BUTTON_STATUS_HIGHLIGHTED:
1085                 color = GetProperty(L"highlightedItemColor");
1086                 break;
1087         case _BUTTON_STATUS_SELECTED:
1088                 color = GetProperty(L"selectedItemColor");
1089                 break;
1090         default:
1091                 color = GetProperty(L"normalItemColor");
1092                 break;
1093         }
1094
1095         return color.ToColor();
1096 }
1097
1098 int
1099 _Toolbar::GetItemCount(void) const
1100 {
1101         return __itemCount;
1102 }
1103
1104 int
1105 _Toolbar::GetItemIndexFromPosition(const FloatPoint& point) const
1106 {
1107         if (__itemCount <= 0)
1108         {
1109                 return -1;
1110         }
1111
1112         for (int i = 0; i < __itemCount; i++)
1113         {
1114                 FloatRectangle bounds = __pItems.at(i)->GetBoundsF();
1115
1116                 if (bounds.Contains(point) && __pItems.at(i)->GetVisibleState() == true)
1117                 {
1118                         return i;
1119                 }
1120         }
1121
1122         return -1;
1123 }
1124
1125 result
1126 _Toolbar::GetItemStatus(int itemIndex, _ButtonStatus& status) const
1127 {
1128         status = _BUTTON_STATUS_NORMAL;
1129
1130         SysTryReturnResult(NID_UI_CTRL, (itemIndex >= 0 && itemIndex <= __itemCount), E_OUT_OF_RANGE,
1131                                 "[E_OUT_OF_RANGE] The itemIndex is out of range.");
1132
1133         status = __pItems.at(itemIndex)->GetButtonStatus();
1134
1135         return E_SUCCESS;
1136 }
1137
1138 Color
1139 _Toolbar::GetItemTextColor(_ButtonStatus status) const
1140 {
1141         Variant color;
1142
1143         switch (status)
1144         {
1145         case _BUTTON_STATUS_NORMAL:
1146                 color = GetProperty(L"normalItemTextColor");
1147                 break;
1148         case _BUTTON_STATUS_DISABLED:
1149                 color = GetProperty(L"disabledItemTextColor");
1150                 break;
1151         case _BUTTON_STATUS_PRESSED:
1152                 color = GetProperty(L"pressedItemTextColor");
1153                 break;
1154         case _BUTTON_STATUS_HIGHLIGHTED:
1155                 color = GetProperty(L"highlightedItemTextColor");
1156                 break;
1157         case _BUTTON_STATUS_SELECTED:
1158                 color = GetProperty(L"selectedItemTextColor");
1159                 break;
1160         default:
1161                 color = GetProperty(L"normalItemTextColor");
1162                 break;
1163         }
1164
1165         return color.ToColor();
1166 }
1167
1168 int
1169 _Toolbar::GetSelectedItemIndex(void) const
1170 {
1171         return __pToolbarPresenter->GetSelectedItemIndex();
1172 }
1173
1174 ToolbarStyle
1175 _Toolbar::GetStyle(void) const
1176 {
1177         return ToolbarStyle(__style);
1178 }
1179
1180 Bitmap*
1181 _Toolbar::GetTitleIcon(void) const
1182 {
1183         return __pTitleIcon;
1184 }
1185
1186 String
1187 _Toolbar::GetTitleText(void) const
1188 {
1189         Variant text = GetProperty(L"titleText");
1190         return text.ToString();
1191 }
1192
1193 Color
1194 _Toolbar::GetTitleTextColor(void) const
1195 {
1196         Variant color = GetProperty(L"titleTextColor");
1197         return color.ToColor();
1198 }
1199
1200 HorizontalAlignment
1201 _Toolbar::GetTitleTextHorizontalAlignment(void) const
1202 {
1203         return __titleTextAlignment;
1204 }
1205
1206 bool
1207 _Toolbar::IsInitialDraw(void) const
1208 {
1209         return __pToolbarPresenter->IsInitialDraw();
1210 }
1211
1212 bool
1213 _Toolbar::IsTabEditModeEnabled(void) const
1214 {
1215         return __pToolbarPresenter->IsTabEditModeEnabled();
1216 }
1217
1218 bool
1219 _Toolbar::IsTransparent(void) const
1220 {
1221         return __transparent;
1222 }
1223
1224
1225 AnimationStatus
1226 _Toolbar::GetWaitingAnimationStatus(ToolbarAnimationPosition animationPos) const
1227 {
1228         if (animationPos < TOOLBAR_ANIMATION_POSITION_TITLE || animationPos >= TOOLBAR_ANIMATION_POSITION_MAX)
1229         {
1230                 return ANIMATION_STOPPED;
1231         }
1232
1233         if (__pAnimation[animationPos] == null)
1234         {
1235                 return ANIMATION_STOPPED;
1236         }
1237
1238         return __pAnimation[animationPos]->GetStatus();
1239 }
1240
1241 result
1242 _Toolbar::InsertItemAt(int itemIndex, _Button* pButton)
1243 {
1244         SysTryReturnResult(NID_UI_CTRL, (itemIndex >= 0 && itemIndex <= __itemCount), E_OUT_OF_RANGE,
1245                                 "[E_OUT_OF_RANGE] The itemIndex is out of range.");
1246
1247         if (__pActionEventListener != null)
1248         {
1249                 pButton->AddActionEventListener(*__pActionEventListener);
1250         }
1251
1252         __pItems.insert(__pItems.begin() + itemIndex, pButton);
1253         __itemCount++;
1254
1255         SetFocusNavigateEnabled(true);
1256
1257         AttachChild(*pButton);
1258
1259         ApplyUserGUI(TOOLBAR_ITEM, pButton);
1260
1261         RearrangeItems();
1262
1263         AddAccessibilityElement(pButton);
1264
1265         return E_SUCCESS;
1266 }
1267
1268 bool
1269 _Toolbar::IsButtonSet(ToolbarButton position) const
1270 {
1271         if (__pButtonItems[position] != null)
1272         {
1273                 return true;
1274         }
1275
1276         return false;
1277 }
1278
1279 result
1280 _Toolbar::MoveItem(const int srcIndex, const int destIndex)
1281 {
1282         if (srcIndex == destIndex)
1283         {
1284                 SetItemSelected(destIndex, true, false);
1285
1286                 return E_SUCCESS;
1287         }
1288
1289         if (srcIndex < 0 || destIndex < 0 || srcIndex > __itemCount || destIndex > __itemCount)
1290         {
1291                 return E_INVALID_OPERATION;
1292         }
1293
1294         _Button* pSrcButton = null;
1295         pSrcButton = GetItem(srcIndex);
1296         SysTryReturnResult(NID_UI_CTRL, pSrcButton, E_INVALID_STATE, "[E_INVALID_ARG] No item at the pressed index.");
1297
1298         _Button* pDestButton = null;
1299         pDestButton = GetItem(destIndex);
1300         SysTryReturnResult(NID_UI_CTRL, pDestButton, E_INVALID_STATE, "[E_INVALID_ARG] No item at the released index.");
1301
1302         if (pDestButton->GetButtonStatus() == _BUTTON_STATUS_DISABLED)
1303         {
1304                 SetItemSelected(GetSelectedItemIndex(), true, false);
1305
1306                 return E_INVALID_OPERATION;
1307         }
1308
1309         __pItems.erase(__pItems.begin() + destIndex);
1310         __pItems.insert(__pItems.begin() + destIndex, pSrcButton);
1311
1312         __pItems.erase(__pItems.begin() + srcIndex);
1313         __pItems.insert(__pItems.begin() + srcIndex, pDestButton);
1314
1315         for (int i = 0; i < __itemCount; i++)
1316         {
1317                 if (__pItems.at(i)->GetButtonStatus() != _BUTTON_STATUS_DISABLED)
1318                 {
1319                         __pItems.at(i)->SetButtonStatus(_BUTTON_STATUS_NORMAL);
1320                 }
1321
1322                 _AccessibilityElement* pElement = __pItems.at(i)->GetAccessibilityContainer()->GetChildElement(0);
1323                 if (pElement)
1324                 {
1325                         pElement->SetStatus(L"");
1326                         pElement->SetHintDisabled(false);
1327                 }
1328         }
1329
1330         SetItemSelected(destIndex, true, false);
1331
1332         RearrangeItems();
1333
1334         Invalidate(true);
1335
1336         return E_SUCCESS;
1337 }
1338
1339 result
1340 _Toolbar::PauseWaitingAnimation(ToolbarAnimationPosition animationPos)
1341 {
1342         SysTryReturnResult(NID_UI_CTRL,
1343                         (TOOLBAR_ANIMATION_POSITION_TITLE <= animationPos && animationPos < TOOLBAR_ANIMATION_POSITION_MAX), E_INVALID_ARG,
1344                         "[E_INVALID_ARG] The animationPos is invalid.");
1345         SysTryReturnResult(NID_UI_CTRL, (__pAnimation[animationPos]), E_INVALID_STATE,
1346                         "[E_INVALID_STATE] __pAnimation isn't constructed.");
1347
1348         __pAnimation[animationPos]->Pause();
1349
1350         return E_SUCCESS;
1351 }
1352
1353 result
1354 _Toolbar::PlayWaitingAnimation(ToolbarAnimationPosition animationPos)
1355 {
1356         SysTryReturnResult(NID_UI_CTRL,
1357                         (TOOLBAR_ANIMATION_POSITION_TITLE <= animationPos && animationPos < TOOLBAR_ANIMATION_POSITION_MAX), E_INVALID_ARG,
1358                         "[E_INVALID_ARG] The animationPos is invalid.");
1359
1360         if ((animationPos == TOOLBAR_ANIMATION_POSITION_TITLE && __style != TOOLBAR_TITLE)
1361                         || (animationPos == TOOLBAR_ANIMATION_POSITION_BUTTON_LEFT && __pButtonItems[LEFT_BUTTON] == null)
1362                         ||  (animationPos == TOOLBAR_ANIMATION_POSITION_BUTTON_RIGHT && __pButtonItems[RIGHT_BUTTON] == null))
1363         {
1364                 return E_UNSUPPORTED_OPERATION;
1365         }
1366
1367         if (__pAnimation[animationPos])
1368         {
1369                 if (__pAnimation[animationPos]->GetStatus() == ANIMATION_PLAYING)
1370                 {
1371                         return E_SUCCESS;
1372                 }
1373         }
1374         else
1375         {
1376                 SetAnimation(animationPos);
1377         }
1378
1379         if (__pAnimation[animationPos])
1380         {
1381                 __pAnimation[animationPos]->Play();
1382         }
1383
1384         return E_SUCCESS;
1385 }
1386
1387 result
1388 _Toolbar::RemoveAllButtons(void)
1389 {
1390         for (int i = 0; i < BUTTON_MAX; i++)
1391         {
1392                 _Button* pButtonItem = __pButtonItems[i];
1393
1394                 if (pButtonItem != null)
1395                 {
1396                          if (i == LEFT_BUTTON)
1397                         {
1398                                  StopWaitingAnimation(TOOLBAR_ANIMATION_POSITION_BUTTON_LEFT);
1399                         }
1400                         else if (i == RIGHT_BUTTON)
1401                         {
1402                                 StopWaitingAnimation(TOOLBAR_ANIMATION_POSITION_BUTTON_RIGHT);
1403                         }
1404
1405                         if (pButtonItem->GetChildCount() != 0)
1406                         {
1407                                 _Label* pTempBadgeIcon = dynamic_cast<_Label*>(pButtonItem->GetChild(0));
1408                                 SysTryReturnResult(NID_UI_CTRL, pTempBadgeIcon, E_INVALID_STATE, "[E_INVALID_STATE] Couldn't get a badge icon.");
1409
1410                                 pButtonItem->DetachChild(*pTempBadgeIcon);
1411
1412                                 delete pTempBadgeIcon;
1413                                 pTempBadgeIcon = null;
1414                         }
1415
1416                         DetachChild(*pButtonItem);
1417                         delete pButtonItem;
1418                         pButtonItem = null;
1419
1420                         __pButtonItems[i] = null;
1421                 }
1422         }
1423
1424         return E_SUCCESS;
1425 }
1426
1427 result
1428 _Toolbar::RemoveAllItems(void)
1429 {
1430         __itemCount = 0;
1431
1432         int itemCount = __pItems.size();
1433
1434         _Button* pItem = null;
1435
1436         // frees item nodes from the memory
1437         if (itemCount > 0)
1438         {
1439                 for (int i = itemCount - 1; i >= 0; i--)
1440                 {
1441                         pItem = __pItems.at(i);
1442
1443                         if (pItem != null)
1444                         {
1445                                 if (pItem->GetChildCount() != 0)
1446                                 {
1447                                         _Label* pTempBadgeIcon = dynamic_cast<_Label*>(pItem->GetChild(0));
1448                                         SysTryReturnResult(NID_UI_CTRL, pTempBadgeIcon, E_INVALID_STATE, "[E_INVALID_STATE] Couldn't get a badge icon.");
1449
1450                                         pItem->DetachChild(*pTempBadgeIcon);
1451
1452                                         delete pTempBadgeIcon;
1453                                         pTempBadgeIcon = null;
1454                                 }
1455
1456                                 DetachChild(*pItem);
1457                                 delete pItem;
1458
1459                                 pItem = null;
1460                         }
1461                 }
1462         }
1463
1464         // clears vector
1465         __pItems.clear();
1466
1467         __pToolbarPresenter->SetInitialDrawState(true);
1468
1469         SetItemSelected(-1);
1470
1471         return E_SUCCESS;
1472 }
1473
1474 result
1475 _Toolbar::RemoveButtonAt(ToolbarButton position)
1476 {
1477         if (__pButtonItems[position] != null)
1478         {
1479                 if (position == LEFT_BUTTON)
1480                 {
1481                         StopWaitingAnimation(TOOLBAR_ANIMATION_POSITION_BUTTON_LEFT);
1482                 }
1483                 else if (position == RIGHT_BUTTON)
1484                 {
1485                         StopWaitingAnimation(TOOLBAR_ANIMATION_POSITION_BUTTON_RIGHT);
1486                 }
1487
1488                 if (__pButtonItems[position]->GetChildCount() != 0)
1489                 {
1490                         _Label* pTempBadgeIcon = dynamic_cast<_Label*>(__pButtonItems[position]->GetChild(0));
1491                         SysTryReturnResult(NID_UI_CTRL, pTempBadgeIcon, E_INVALID_STATE, "[E_INVALID_STATE] Couldn't get a badge icon.");
1492
1493                         __pButtonItems[position]->DetachChild(*pTempBadgeIcon);
1494
1495                         delete pTempBadgeIcon;
1496                         pTempBadgeIcon = null;
1497                 }
1498
1499                 DetachChild(*__pButtonItems[position]);
1500                 delete __pButtonItems[position];
1501                 __pButtonItems[position] = null;
1502         }
1503
1504         if (__itemCount == 0 && __pButtonItems[LEFT_BUTTON] == null && __pButtonItems[RIGHT_BUTTON] == null)
1505         {
1506                 SetFocusNavigateEnabled(false);
1507         }
1508
1509         RearrangeItems();
1510
1511         return E_SUCCESS;
1512 }
1513
1514 result
1515 _Toolbar::RemoveItemAt(int itemIndex)
1516 {
1517         SysTryReturnResult(NID_UI_CTRL, (__itemCount > 0 && itemIndex < __itemCount && itemIndex >= 0), E_INVALID_ARG,
1518                                 "[E_INVALID_ARG] itemIndex is invalid.");
1519
1520         _Button* pItem = __pItems.at(itemIndex);
1521
1522         SysTryReturnResult(NID_UI_CTRL, (pItem != null), E_INVALID_STATE, "[E_INVALID_ARG] No item at the designated index.");
1523
1524         if (pItem->GetChildCount() != 0)
1525         {
1526                 _Label* pTempBadgeIcon = dynamic_cast<_Label*>(pItem->GetChild(0));
1527                 SysTryReturnResult(NID_UI_CTRL, pTempBadgeIcon, E_INVALID_STATE, "[E_INVALID_STATE] Couldn't get a badge icon.");
1528
1529                 pItem->DetachChild(*pTempBadgeIcon);
1530
1531                 delete pTempBadgeIcon;
1532                 pTempBadgeIcon = null;
1533         }
1534
1535         // Free 'pItem' from the item nodes
1536         DetachChild(*pItem);
1537         delete pItem;
1538         pItem = null;
1539
1540         __itemCount--;
1541
1542         if (__itemCount == 0 && __pButtonItems[LEFT_BUTTON] == null && __pButtonItems[RIGHT_BUTTON] == null)
1543         {
1544                 SetFocusNavigateEnabled(false);
1545         }
1546
1547         __pItems.erase(__pItems.begin() + itemIndex);
1548
1549         RearrangeItems();
1550
1551         return E_SUCCESS;
1552 }
1553
1554 result
1555 _Toolbar::SetBackgroundBitmap(const Bitmap& bitmap)
1556 {
1557         result r = E_SYSTEM;
1558
1559         Bitmap* pClonedBitmap = _BitmapImpl::CloneN(bitmap);
1560
1561         if (pClonedBitmap)
1562         {
1563                 if (__pToolbarBackgroundBitmap)
1564                 {
1565                         delete __pToolbarBackgroundBitmap;
1566                 }
1567
1568                 __pToolbarBackgroundBitmap = pClonedBitmap;
1569                 __isUserBackgroundBitmap = true;
1570
1571                 r = E_SUCCESS;
1572         }
1573
1574         return r;
1575 }
1576
1577 bool
1578 _Toolbar::IsUserBackgroundBitmap() const
1579 {
1580         return __isUserBackgroundBitmap;
1581 }
1582
1583 result
1584 _Toolbar::SetButton(ToolbarButton position, _Button* pButton)
1585 {
1586         SysTryReturnResult(NID_UI_CTRL, (pButton), E_INVALID_ARG, "[E_INVALID_ARG] The pButton is invalid.");
1587
1588         float buttonWidth = pButton->GetSizeF().width;
1589
1590         float toolbarWidth = GetBoundsF().width;
1591
1592         if (CalculateMinimumToolbarWidth() > toolbarWidth)
1593         {
1594                 toolbarWidth = CalculateMinimumToolbarWidth();
1595         }
1596
1597         float horizontalMargin = 0.0f;
1598         float verticalMargin = 0.0f;
1599
1600         if (__header == true && __style != TOOLBAR_TEXT)
1601         {
1602                 float buttonItemGap = 0.0f;
1603                 float buttonTopMargin = 0.0f;
1604
1605                 GET_SHAPE_CONFIG(HEADER::BUTTON_ITEM_TOP_MARGIN, GetOrientation(), buttonTopMargin);
1606                 GET_SHAPE_CONFIG(HEADER::BUTTON_ITEM_GAP, GetOrientation(), buttonItemGap);
1607
1608                 switch (position)
1609                 {
1610                 case RIGHT_BUTTON:
1611                         if (__pButtonItems[LEFT_BUTTON])
1612                         {
1613                                 pButton->SetPosition(FloatPoint(toolbarWidth - buttonWidth , buttonTopMargin));
1614                                 __pButtonItems[LEFT_BUTTON]->SetPosition(FloatPoint(toolbarWidth - buttonWidth *2 - buttonItemGap, buttonTopMargin));
1615                         }
1616                         else
1617                         {
1618                                 pButton->SetPosition(FloatPoint(toolbarWidth - buttonWidth , buttonTopMargin));
1619                         }
1620                         break;
1621                 case LEFT_BUTTON:
1622                         if (__pButtonItems[RIGHT_BUTTON])
1623                         {
1624                                 pButton->SetPosition(FloatPoint(toolbarWidth - buttonWidth * 2 - buttonItemGap, buttonTopMargin));
1625                         }
1626                         else
1627                         {
1628                                 pButton->SetPosition(FloatPoint(toolbarWidth - buttonWidth, buttonTopMargin));
1629                         }
1630                         break;
1631
1632                 default:
1633                         break;
1634                 }
1635         }
1636         else // footer or HEADER_STYLE_BUTTON
1637         {
1638                 switch (position)
1639                 {
1640                         case LEFT_BUTTON:
1641                                 pButton->SetPosition(FloatPoint(horizontalMargin, verticalMargin));
1642                                 break;
1643
1644                         case RIGHT_BUTTON:
1645                                 pButton->SetPosition(FloatPoint(toolbarWidth - buttonWidth - horizontalMargin, verticalMargin));
1646                                 break;
1647
1648                         case MIDDLE_BUTTON:
1649                                 pButton->SetPosition(FloatPoint((toolbarWidth - buttonWidth - horizontalMargin)/2, verticalMargin));
1650                                 break;
1651
1652                         default:
1653                                 break;
1654                 }
1655         }
1656
1657         if (__pActionEventListener != null)
1658         {
1659                 pButton->AddActionEventListener(*__pActionEventListener);
1660         }
1661
1662         if (__pButtonItems[position])
1663         {
1664                 if (position == LEFT_BUTTON)
1665                 {
1666                         StopWaitingAnimation(TOOLBAR_ANIMATION_POSITION_BUTTON_LEFT);
1667                 }
1668                 else if (position == RIGHT_BUTTON)
1669                 {
1670                         StopWaitingAnimation(TOOLBAR_ANIMATION_POSITION_BUTTON_RIGHT);
1671                 }
1672
1673                 if (__pButtonItems[position]->GetChildCount() != 0)
1674                 {
1675                         _Label* pTempBadgeIcon = dynamic_cast<_Label*>(__pButtonItems[position]->GetChild(0));
1676                         SysTryReturnResult(NID_UI_CTRL, pTempBadgeIcon, E_INVALID_STATE, "[E_INVALID_STATE] Couldn't get a badge icon.");
1677
1678                         __pButtonItems[position]->DetachChild(*pTempBadgeIcon);
1679
1680                         delete pTempBadgeIcon;
1681                         pTempBadgeIcon = null;
1682                 }
1683
1684                 DetachChild(*__pButtonItems[position]);
1685
1686                 delete __pButtonItems[position];
1687                 __pButtonItems[position] = null;
1688         }
1689
1690         __pButtonItems[position] = pButton;
1691
1692         AttachChild(*pButton);
1693
1694         SetFocusNavigateEnabled(true);
1695
1696         if (__style != TOOLBAR_SOFTKEY)
1697         {
1698                 ApplyUserGUI(TOOLBAR_BUTTON, __pButtonItems[position]);
1699         }
1700
1701         RearrangeItems();
1702         AddAccessibilityElement(position, pButton);
1703         return E_SUCCESS;
1704 }
1705
1706 result
1707 _Toolbar::SetButtonColor(_ButtonStatus status, const Color& color)
1708 {
1709         switch (status)
1710         {
1711         case _BUTTON_STATUS_NORMAL:
1712                 __isButtonBgColorSetByUser[_BUTTON_STATUS_NORMAL] = true;
1713                 return SetProperty(L"normalButtonColor", Variant(color));
1714                 break;
1715         case _BUTTON_STATUS_DISABLED:
1716                 __isButtonBgColorSetByUser[_BUTTON_STATUS_DISABLED] = true;
1717                 return SetProperty(L"disabledButtonColor", Variant(color));
1718                 break;
1719         case _BUTTON_STATUS_PRESSED:
1720                 __isButtonBgColorSetByUser[_BUTTON_STATUS_PRESSED] = true;
1721                 return SetProperty(L"pressedButtonColor", Variant(color));
1722                 break;
1723         case _BUTTON_STATUS_HIGHLIGHTED:
1724                 __isButtonBgColorSetByUser[_BUTTON_STATUS_HIGHLIGHTED] = true;
1725                 return SetProperty(L"highlightedButtonColor", Variant(color));
1726                 break;
1727         default:
1728                 __isButtonBgColorSetByUser[_BUTTON_STATUS_NORMAL] = true;
1729                 return SetProperty(L"normalButtonColor", Variant(color));
1730                 break;
1731         }
1732 }
1733
1734 result
1735 _Toolbar::SetButtonEnabled(ToolbarButton position, bool enabled)
1736 {
1737         SysTryReturnResult(NID_UI_CTRL, __pButtonItems[position], E_INVALID_OPERATION,
1738                                 "[E_INVALID_OPERATION] No button item is at the position.");
1739
1740         if (enabled)
1741         {
1742                 __pButtonItems[position]->SetButtonStatus(_BUTTON_STATUS_NORMAL);
1743                 _AccessibilityElement* pElement = __pButtonItems[position]->GetAccessibilityContainer()->GetChildElement(0);
1744                 if (pElement)
1745                 {
1746                         pElement->SetStatus(L"");
1747                         pElement->SetHintDisabled(false);
1748                 }
1749         }
1750         else
1751         {
1752                 __pButtonItems[position]->SetButtonStatus(_BUTTON_STATUS_DISABLED);
1753                 _AccessibilityElement* pElement = __pButtonItems[position]->GetAccessibilityContainer()->GetChildElement(0);
1754                 if (pElement)
1755                 {
1756                         pElement->SetStatus(L"");
1757                         pElement->SetHintDisabled(false);
1758                 }
1759         }
1760
1761         return E_SUCCESS;
1762 }
1763
1764 result
1765 _Toolbar::SetButtonTextColor(_ButtonStatus status, const Color& color)
1766 {
1767         switch (status)
1768         {
1769         case _BUTTON_STATUS_NORMAL:
1770                 __isButtonTextColorSetByUser[_BUTTON_STATUS_NORMAL] = true;
1771                 return SetProperty(L"normalButtonTextColor", Variant(color));
1772                 break;
1773         case _BUTTON_STATUS_DISABLED:
1774                 __isButtonTextColorSetByUser[_BUTTON_STATUS_DISABLED] = true;
1775                 return SetProperty(L"disabledButtonTextColor", Variant(color));
1776                 break;
1777         case _BUTTON_STATUS_PRESSED:
1778                 __isButtonTextColorSetByUser[_BUTTON_STATUS_PRESSED] = true;
1779                 return SetProperty(L"pressedButtonTextColor", Variant(color));
1780                 break;
1781         case _BUTTON_STATUS_HIGHLIGHTED:
1782                 __isButtonTextColorSetByUser[_BUTTON_STATUS_HIGHLIGHTED] = true;
1783                 return SetProperty(L"highlightedButtonTextColor", Variant(color));
1784                 break;
1785         default:
1786                 __isButtonTextColorSetByUser[_BUTTON_STATUS_NORMAL] = true;
1787                 return SetProperty(L"normalButtonTextColor", Variant(color));
1788                 break;
1789         }
1790 }
1791
1792 result
1793 _Toolbar::SetButtonBadgeIcon(ToolbarButton position, const Bitmap* pBadgeIcon)
1794 {
1795         int childCount = 0;
1796
1797         childCount = __pButtonItems[position]->GetChildCount();
1798
1799         if (childCount != 0)
1800         {
1801                 for(int i = 0; i < childCount; i++)
1802                 {
1803                         _Label* pTempBadgeIcon = dynamic_cast<_Label*>(__pButtonItems[position]->GetChild(i));
1804
1805                         if (pTempBadgeIcon)
1806                         {
1807                                 __pButtonItems[position]->DetachChild(*pTempBadgeIcon);
1808
1809                                 delete pTempBadgeIcon;
1810                                 pTempBadgeIcon = null;
1811                         }
1812                 }
1813         }
1814
1815         if (pBadgeIcon == null)
1816         {
1817                 return E_SUCCESS;
1818         }
1819
1820         FloatRectangle bounds = __pButtonItems[position]->GetBoundsF();
1821
1822         float topTouchMargin = __pButtonItems[position]->GetTopTouchMarginF();
1823         float rightTouchMargin = __pButtonItems[position]->GetRightTouchMarginF();
1824
1825         bounds.y = bounds.y + topTouchMargin;
1826         bounds.width = bounds.width - rightTouchMargin;
1827
1828         float height = 0.0f;
1829
1830         GET_SHAPE_CONFIG(HEADER::BADGE_HEIGHT_WITH_BUTTON, GetOrientation(), height);
1831
1832         _Label* pBadgeIconLabel = _Label::CreateLabelN();
1833
1834         if (pBadgeIconLabel)
1835         {
1836                 pBadgeIconLabel->SetBounds(FloatRectangle(bounds.width - height, bounds.y, height, height));
1837                 pBadgeIconLabel->SetBackgroundBitmap(*pBadgeIcon);
1838
1839                 __pButtonItems[position]->AttachChild(*pBadgeIconLabel);
1840                 __pButtonItems[position]->SetChildAlwaysOnTop(*pBadgeIconLabel);
1841         }
1842
1843         return E_SUCCESS;
1844 }
1845
1846 result
1847 _Toolbar::SetButtonNumberedBadgeIcon(ToolbarButton position, int number)
1848 {
1849         int childCount = 0;
1850
1851         childCount = __pButtonItems[position]->GetChildCount();
1852
1853         _Label* existingBadgeIcon = null;
1854
1855         if (number == 0)
1856         {
1857                 if (childCount != 0)
1858                 {
1859                         for(int i = 0; i < childCount; i++)
1860                         {
1861                                 existingBadgeIcon = dynamic_cast<_Label*>(__pButtonItems[position]->GetChild(i));
1862
1863                                 if (existingBadgeIcon)
1864                                 {
1865                                         __pButtonItems[position]->DetachChild(*existingBadgeIcon);
1866
1867                                         delete existingBadgeIcon;
1868                                         existingBadgeIcon = null;
1869                                 }
1870                         }
1871                 }
1872                 else
1873                 {
1874                         return E_SUCCESS;
1875                 }
1876         }
1877         else
1878         {
1879                 bool needToCreateNewIcon = true;
1880
1881                 if (childCount != 0)
1882                 {
1883                         for(int i = 0; i < childCount; i++)
1884                         {
1885                                 existingBadgeIcon = dynamic_cast<_Label*>(__pButtonItems[position]->GetChild(i));
1886
1887                                 if (existingBadgeIcon)
1888                                 {
1889                                         if (existingBadgeIcon->GetText() == L"")
1890                                         {
1891                                                 __pButtonItems[position]->DetachChild(*existingBadgeIcon);
1892
1893                                                 delete existingBadgeIcon;
1894                                                 existingBadgeIcon = null;
1895
1896                                                 needToCreateNewIcon = true;
1897                                         }
1898                                         else
1899                                         {
1900                                                 needToCreateNewIcon = false;
1901                                         }
1902                                 }
1903                         }
1904                 }
1905
1906                 if (needToCreateNewIcon)
1907                 {
1908                         _Label* pLabel = _Label::CreateLabelN();
1909
1910                         SysTryReturnResult(NID_UI_CTRL, pLabel, E_INVALID_STATE,
1911                                                 "[E_INVALID_STATE] The badge icon instance isn't constructed.");
1912
1913                         Bitmap* pNumberedBadgeIconBitmap = null;
1914                         Bitmap* pNumberedBadgeIconEffectBitmap = null;
1915                         Bitmap* pColorReplacedBitmap = null;
1916                         Color badgeIconBgNormalColor;
1917                         Color badgeIconTextNormalColor;
1918
1919                         GET_BITMAP_CONFIG_N(HEADER::BADGE_ICON_BG_NORMAL, BITMAP_PIXEL_FORMAT_ARGB8888, pNumberedBadgeIconBitmap);
1920
1921                         bool customTheme = IS_CUSTOM_BITMAP(HEADER::BADGE_ICON_BG_NORMAL);
1922                         if (customTheme == false)
1923                         {
1924                                 GET_BITMAP_CONFIG_N(HEADER::BADGE_ICON_BG_EFFECT_NORMAL, BITMAP_PIXEL_FORMAT_ARGB8888, pNumberedBadgeIconEffectBitmap);
1925                         }
1926
1927                         GET_COLOR_CONFIG(HEADER::BADGE_ICON_BG_NORMAL, badgeIconBgNormalColor);
1928                         GET_COLOR_CONFIG(HEADER::BADGE_ICON_TEXT_NORMAL, badgeIconTextNormalColor);
1929
1930                         if (pNumberedBadgeIconBitmap)
1931                         {
1932                                 pColorReplacedBitmap = _BitmapImpl::GetColorReplacedBitmapN(*pNumberedBadgeIconBitmap,
1933                                                 Color::GetColor(COLOR_ID_MAGENTA), badgeIconBgNormalColor);
1934
1935                                 pLabel->SetBackgroundBitmap(*pColorReplacedBitmap);
1936
1937                                 delete pColorReplacedBitmap;
1938                                 delete pNumberedBadgeIconBitmap;
1939                         }
1940
1941                         if (pNumberedBadgeIconEffectBitmap)
1942                         {
1943                                 pLabel->SetBackgroundEffectBitmap(*pNumberedBadgeIconEffectBitmap);
1944
1945                                 delete pNumberedBadgeIconEffectBitmap;
1946                         }
1947
1948                         pLabel->SetTextHorizontalAlignment(ALIGNMENT_CENTER);
1949                         pLabel->SetTextVerticalAlignment(ALIGNMENT_MIDDLE);
1950                         pLabel->SetTextColor(badgeIconTextNormalColor);
1951                         pLabel->SetMargin(10, 0, 5, 0);
1952
1953                         __pButtonItems[position]->AttachChild(*pLabel);
1954                         __pButtonItems[position]->SetChildAlwaysOnTop(*pLabel);
1955
1956                         existingBadgeIcon = pLabel;
1957                 }
1958
1959                 SysTryReturnResult(NID_UI_CTRL, (existingBadgeIcon), E_INVALID_STATE, "[E_INVALID_STATE] Failed to set a BadgeIcon.");
1960
1961                 FloatRectangle bounds = __pButtonItems[position]->GetBoundsF();
1962
1963                 float topTouchMargin = __pButtonItems[position]->GetTopTouchMarginF();
1964                 float rightTouchMargin = __pButtonItems[position]->GetRightTouchMarginF();
1965
1966                 bounds.y = bounds.y + topTouchMargin;
1967                 bounds.width = bounds.width - rightTouchMargin;
1968
1969                 if (existingBadgeIcon)
1970                 {
1971                         float fontSize = 0.0f;
1972                         float height = 0.0f;
1973                         float width = 0.0f;
1974
1975                         GET_SHAPE_CONFIG(HEADER::BADGE_HEIGHT_WITH_BUTTON, GetOrientation(), height);
1976
1977                         if (number < 10)
1978                         {
1979                                 GET_SHAPE_CONFIG(HEADER::BADGE_FONT_SIZE_WITH_BUTTON, GetOrientation(), fontSize);
1980                                 GET_SHAPE_CONFIG(HEADER::BADGE_WIDTH_1DIGIT, GetOrientation(), width);
1981                         }
1982                         else if (number < 100)
1983                         {
1984                                 GET_SHAPE_CONFIG(HEADER::BADGE_FONT_SIZE_WITH_BUTTON, GetOrientation(), fontSize);
1985                                 GET_SHAPE_CONFIG(HEADER::BADGE_WIDTH_1DIGIT, GetOrientation(), width);
1986                         }
1987                         else if (number < 1000)
1988                         {
1989                                 GET_SHAPE_CONFIG(HEADER::BADGE_FONT_SIZE_WITH_BUTTON, GetOrientation(), fontSize);
1990                                 GET_SHAPE_CONFIG(HEADER::BADGE_WIDTH_2DIGIT, GetOrientation(), width);
1991                         }
1992                         else if (number < 10000)
1993                         {
1994                                 GET_SHAPE_CONFIG(HEADER::BADGE_FONT_SIZE_WITH_BUTTON, GetOrientation(), fontSize);
1995                                 GET_SHAPE_CONFIG(HEADER::BADGE_WIDTH_2DIGIT, GetOrientation(), width);
1996                         }
1997                         else
1998                         {
1999                                 GET_SHAPE_CONFIG(HEADER::BADGE_FONT_SIZE_WITH_BUTTON_2, GetOrientation(), fontSize);
2000                                 GET_SHAPE_CONFIG(HEADER::BADGE_WIDTH_2DIGIT, GetOrientation(), width);
2001                         }
2002
2003                         existingBadgeIcon->SetBounds(FloatRectangle(bounds.width - width, bounds.y, width, height));
2004                         existingBadgeIcon->SetTextConfig(fontSize, LABEL_TEXT_STYLE_NORMAL);
2005
2006                         Integer tempNumber(number);
2007                         existingBadgeIcon->SetText(tempNumber.ToString());
2008                 }
2009         }
2010
2011         return E_SUCCESS;
2012 }
2013
2014 result
2015 _Toolbar::SetColor(const Color& color)
2016 {
2017         return SetProperty(L"color", Variant(color));
2018 }
2019
2020 result
2021 _Toolbar::SetDescriptionText(const String& text)
2022 {
2023         return SetProperty(L"descriptionText", Variant(text));
2024 }
2025
2026 result
2027 _Toolbar::SetDescriptionTextColor(const Color& color)
2028 {
2029         return SetProperty(L"descriptionTextColor", Variant(color));
2030 }
2031
2032 result
2033 _Toolbar::SetItemAt(int itemIndex, const _Button* pButton)
2034 {
2035         SysTryReturnResult(NID_UI_CTRL, (itemIndex >= 0 && itemIndex < __itemCount), E_OUT_OF_RANGE,
2036                                 "[E_OUT_OF_RANGE] The itemIndex is out of range.");
2037
2038         if (pButton->GetActionId() < TOOLBAR_ACTION_ID_MIN || pButton->GetActionId() > TOOLBAR_ACTION_ID_MAX)
2039         {
2040                 SysLog(NID_UI_CTRL, "[E_INVALID_ARG] The actionId is invalid.");
2041                 return E_OUT_OF_RANGE;
2042         }
2043
2044         SysTryReturnResult(NID_UI_CTRL, (null != __pItems.at(itemIndex)), E_INVALID_OPERATION,
2045                                 "[E_INVALID_OPERATION] No button item is at the position.");
2046
2047         if (__pItems.at(itemIndex)->GetChildCount() != 0)
2048         {
2049                 _Label* pTempBadgeIcon = dynamic_cast<_Label*>(__pItems.at(itemIndex)->GetChild(0));
2050                 SysTryReturnResult(NID_UI_CTRL, pTempBadgeIcon, E_INVALID_STATE, "[E_INVALID_STATE] Couldn't get a badge icon.");
2051
2052                 __pItems.at(itemIndex)->DetachChild(*pTempBadgeIcon);
2053
2054                 delete pTempBadgeIcon;
2055                 pTempBadgeIcon = null;
2056         }
2057
2058         __pItems.at(itemIndex)->SetText(pButton->GetText());
2059         __pItems.at(itemIndex)->SetActionId(pButton->GetActionId());
2060
2061         Bitmap* pIconBitmap = null;
2062         FloatPoint iconPosition(0.0f, 0.0f);
2063
2064         pIconBitmap = const_cast<Bitmap*>(pButton->GetBitmap(_BUTTON_STATUS_NORMAL));
2065
2066         if (pIconBitmap)
2067         {
2068                 iconPosition = pButton->GetBitmapPositionF(_BUTTON_STATUS_NORMAL);
2069
2070                 __pItems.at(itemIndex)->SetBitmap(_BUTTON_STATUS_NORMAL, iconPosition, *pIconBitmap);
2071                 __pItems.at(itemIndex)->SetBitmap(_BUTTON_STATUS_PRESSED, iconPosition, *pIconBitmap);
2072                 __pItems.at(itemIndex)->SetBitmap(_BUTTON_STATUS_SELECTED, iconPosition, *pIconBitmap);
2073                 __pItems.at(itemIndex)->SetBitmap(_BUTTON_STATUS_HIGHLIGHTED, iconPosition, *pIconBitmap);
2074                 __pItems.at(itemIndex)->SetBitmap(_BUTTON_STATUS_DISABLED, iconPosition, *pIconBitmap);
2075         }
2076
2077         pIconBitmap = const_cast<Bitmap*>(pButton->GetBitmap(_BUTTON_STATUS_PRESSED));
2078
2079         if (pIconBitmap)
2080         {
2081                 iconPosition = pButton->GetBitmapPositionF(_BUTTON_STATUS_PRESSED);
2082
2083                 __pItems.at(itemIndex)->SetBitmap(_BUTTON_STATUS_PRESSED, iconPosition, *pIconBitmap);
2084         }
2085
2086         pIconBitmap = const_cast<Bitmap*>(pButton->GetBitmap(_BUTTON_STATUS_SELECTED));
2087
2088         if (pIconBitmap)
2089         {
2090                 iconPosition = pButton->GetBitmapPositionF(_BUTTON_STATUS_SELECTED);
2091
2092                 __pItems.at(itemIndex)->SetBitmap(_BUTTON_STATUS_SELECTED, iconPosition, *pIconBitmap);
2093         }
2094
2095         pIconBitmap = const_cast<Bitmap*>(pButton->GetBitmap(_BUTTON_STATUS_HIGHLIGHTED));
2096
2097         if (pIconBitmap)
2098         {
2099                 iconPosition = pButton->GetBitmapPositionF(_BUTTON_STATUS_HIGHLIGHTED);
2100
2101                 __pItems.at(itemIndex)->SetBitmap(_BUTTON_STATUS_HIGHLIGHTED, iconPosition, *pIconBitmap);
2102         }
2103
2104         pIconBitmap = const_cast<Bitmap*>(pButton->GetBitmap(_BUTTON_STATUS_DISABLED));
2105
2106         if (pIconBitmap)
2107         {
2108                 iconPosition = pButton->GetBitmapPositionF(_BUTTON_STATUS_DISABLED);
2109
2110                 __pItems.at(itemIndex)->SetBitmap(_BUTTON_STATUS_DISABLED, iconPosition, *pIconBitmap);
2111         }
2112
2113         ApplyUserGUI(TOOLBAR_ITEM, __pItems.at(itemIndex));
2114
2115         RearrangeItems();
2116
2117         RealignItem(__pItems.at(itemIndex), __pItems.at(itemIndex)->GetTextExtentSizeF());
2118
2119         delete pButton;
2120
2121         return E_SUCCESS;
2122 }
2123
2124 result
2125 _Toolbar::SetItemBadgeIcon(int itemIndex, const Bitmap* pBadgeIcon)
2126 {
2127         SysTryReturnResult(NID_UI_CTRL, (itemIndex >= 0 && itemIndex < __itemCount), E_INVALID_ARG,
2128                                 "[E_INVALID_ARG] The itemIndex is invalid.");
2129
2130         SysTryReturnResult(NID_UI_CTRL, (__pItems.at(itemIndex)), E_INVALID_STATE,
2131                                 "[E_INVALID_STATE] The badge icon instance isn't constructed.");
2132
2133         if (__pItems.at(itemIndex)->GetChildCount() != 0)
2134         {
2135                 _Label* pTempBadgeIcon = dynamic_cast<_Label*>(__pItems.at(itemIndex)->GetChild(0));
2136
2137                 if (pTempBadgeIcon)
2138                 {
2139                         __pItems.at(itemIndex)->DetachChild(*pTempBadgeIcon);
2140
2141                         delete pTempBadgeIcon;
2142                         pTempBadgeIcon = null;
2143                 }
2144         }
2145
2146         if (pBadgeIcon == null)
2147         {
2148                 return E_SUCCESS;
2149         }
2150
2151         FloatRectangle bounds = __pItems.at(itemIndex)->GetBoundsF();
2152
2153         _Label* pBadgeIconLabel = _Label::CreateLabelN();
2154
2155         float height = 0.0f;
2156
2157         GET_SHAPE_CONFIG(HEADER::BADGE_HEIGHT, GetOrientation(), height);
2158
2159         if (pBadgeIconLabel)
2160         {
2161                 pBadgeIconLabel->SetBounds(FloatRectangle(bounds.width - height, 0.0f, height, height));
2162                 pBadgeIconLabel->SetBackgroundBitmap(*pBadgeIcon);
2163
2164                 __pItems.at(itemIndex)->AttachChild(*pBadgeIconLabel);
2165                 __pItems.at(itemIndex)->SetChildAlwaysOnTop(*pBadgeIconLabel);
2166         }
2167
2168         return E_SUCCESS;
2169 }
2170
2171 result
2172 _Toolbar::SetItemColor(_ButtonStatus status, const Color& color)
2173 {
2174         switch (status)
2175         {
2176         case _BUTTON_STATUS_NORMAL:
2177                 __isItemBgColorSetByUser[_BUTTON_STATUS_NORMAL] = true;
2178                 return SetProperty(L"normalItemColor", Variant(color));
2179                 break;
2180         case _BUTTON_STATUS_DISABLED:
2181                 __isItemBgColorSetByUser[_BUTTON_STATUS_DISABLED] = true;
2182                 return SetProperty(L"disabledItemColor", Variant(color));
2183                 break;
2184         case _BUTTON_STATUS_PRESSED:
2185                 __isItemBgColorSetByUser[_BUTTON_STATUS_PRESSED] = true;
2186                 return SetProperty(L"pressedItemColor", Variant(color));
2187                 break;
2188         case _BUTTON_STATUS_HIGHLIGHTED:
2189                 __isItemBgColorSetByUser[_BUTTON_STATUS_HIGHLIGHTED] = true;
2190                 return SetProperty(L"highlightedItemColor", Variant(color));
2191                 break;
2192         case _BUTTON_STATUS_SELECTED:
2193                 __isItemBgColorSetByUser[_BUTTON_STATUS_SELECTED] = true;
2194                 return SetProperty(L"selectedItemColor", Variant(color));
2195                 break;
2196         default:
2197                 __isItemBgColorSetByUser[_BUTTON_STATUS_NORMAL] = true;
2198                 return SetProperty(L"normalItemColor", Variant(color));
2199                 break;
2200         }
2201 }
2202
2203 result
2204 _Toolbar::SetItemEnabled(int itemIndex, bool enabled)
2205 {
2206         SysTryReturnResult(NID_UI_CTRL, (null != __pItems.at(itemIndex)), E_INVALID_OPERATION,
2207                                 "[E_INVALID_OPERATION] No button item is at the position.");
2208
2209         if (enabled)
2210         {
2211                 _AccessibilityElement* pElement = __pItems.at(itemIndex)->GetAccessibilityContainer()->GetChildElement(0);
2212                 if (pElement)
2213                 {
2214                         pElement->SetStatus(L"");
2215                         pElement->SetHintDisabled(false);
2216                 }
2217                 return __pItems.at(itemIndex)->SetButtonStatus(_BUTTON_STATUS_NORMAL);
2218         }
2219         else
2220         {
2221                 _AccessibilityElement* pElement = __pItems.at(itemIndex)->GetAccessibilityContainer()->GetChildElement(0);
2222                 if (pElement)
2223                 {
2224                         pElement->SetStatus(L"");
2225                         pElement->SetHintDisabled(true);
2226                 }
2227                 return __pItems.at(itemIndex)->SetButtonStatus(_BUTTON_STATUS_DISABLED);
2228         }
2229
2230         return E_SUCCESS;
2231 }
2232
2233 result
2234 _Toolbar::SetItemNumberedBadgeIcon(int itemIndex, int number)
2235 {
2236         SysTryReturnResult(NID_UI_CTRL, (itemIndex >= 0 && itemIndex < __itemCount), E_INVALID_ARG,
2237                                 "[E_INVALID_ARG] The itemIndex is invalid.");
2238
2239         SysTryReturnResult(NID_UI_CTRL, (number >= 0 && number < 100000), E_INVALID_ARG,
2240                                 "[E_INVALID_ARG] The number is out of bounds.");
2241
2242         SysTryReturnResult(NID_UI_CTRL, (__pItems.at(itemIndex)), E_INVALID_STATE,
2243                                 "[E_INVALID_STATE] The badge icon instance isn't constructed.");
2244
2245         if (number == 0)
2246         {
2247                 if (__pItems.at(itemIndex)->GetChildCount() != 0)
2248                 {
2249                         _Label* existingBadgeIcon = dynamic_cast<_Label*>(__pItems.at(itemIndex)->GetChild(0));
2250
2251                         if (existingBadgeIcon)
2252                         {
2253                                 __pItems.at(itemIndex)->DetachChild(*existingBadgeIcon);
2254
2255                                 delete existingBadgeIcon;
2256                                 existingBadgeIcon = null;
2257                         }
2258                 }
2259                 else
2260                 {
2261                         return E_SUCCESS;
2262                 }
2263         }
2264         else
2265         {
2266                 if (__pItems.at(itemIndex)->GetChildCount() == 0)
2267                 {
2268                         _Label* pLabel = _Label::CreateLabelN();
2269
2270                         SysTryReturnResult(NID_UI_CTRL, pLabel, E_INVALID_STATE,
2271                                                 "[E_INVALID_STATE] The badge icon instance isn't constructed.");
2272
2273                         Bitmap* pNumberedBadgeIconBitmap = null;
2274                         Bitmap* pNumberedBadgeIconEffectBitmap = null;
2275                         Bitmap* pColorReplacedBitmap = null;
2276                         Color badgeIconBgNormalColor;
2277                         Color badgeIconTextNormalColor;
2278
2279                         GET_BITMAP_CONFIG_N(HEADER::BADGE_ICON_BG_NORMAL, BITMAP_PIXEL_FORMAT_ARGB8888, pNumberedBadgeIconBitmap);
2280
2281                         bool customTheme = IS_CUSTOM_BITMAP(HEADER::BADGE_ICON_BG_NORMAL);
2282                         if (customTheme == false)
2283                         {
2284                                 GET_BITMAP_CONFIG_N(HEADER::BADGE_ICON_BG_EFFECT_NORMAL, BITMAP_PIXEL_FORMAT_ARGB8888, pNumberedBadgeIconEffectBitmap);
2285                         }
2286
2287                         GET_COLOR_CONFIG(HEADER::BADGE_ICON_BG_NORMAL, badgeIconBgNormalColor);
2288                         GET_COLOR_CONFIG(HEADER::BADGE_ICON_TEXT_NORMAL, badgeIconTextNormalColor);
2289
2290                         if (pNumberedBadgeIconBitmap)
2291                         {
2292                                 pColorReplacedBitmap = _BitmapImpl::GetColorReplacedBitmapN(*pNumberedBadgeIconBitmap,
2293                                                 Color::GetColor(COLOR_ID_MAGENTA), badgeIconBgNormalColor);
2294
2295                                 pLabel->SetBackgroundBitmap(*pColorReplacedBitmap);
2296
2297                                 delete pColorReplacedBitmap;
2298                                 delete pNumberedBadgeIconBitmap;
2299                         }
2300
2301                         if (pNumberedBadgeIconEffectBitmap)
2302                         {
2303                                 pLabel->SetBackgroundEffectBitmap(*pNumberedBadgeIconEffectBitmap);
2304
2305                                 delete pNumberedBadgeIconEffectBitmap;
2306                         }
2307
2308                         pLabel->SetTextHorizontalAlignment(ALIGNMENT_RIGHT);
2309                         pLabel->SetTextVerticalAlignment(ALIGNMENT_MIDDLE);
2310                         pLabel->SetTextColor(badgeIconTextNormalColor);
2311                         pLabel->SetMargin(0, 10);
2312
2313                         __pItems.at(itemIndex)->AttachChild(*pLabel);
2314                         __pItems.at(itemIndex)->SetChildAlwaysOnTop(*pLabel);
2315                 }
2316
2317                 // SetItemNumberedBadgeIcon
2318
2319                 _Label* existingBadgeIcon = dynamic_cast<_Label*>(__pItems.at(itemIndex)->GetChild(0));
2320
2321                 FloatRectangle bounds = __pItems.at(itemIndex)->GetBoundsF();
2322
2323                 if (existingBadgeIcon)
2324                 {
2325                         float fontSize = 0.0f;
2326                         float height = 0.0f;
2327                         float width = 0.0f;
2328
2329                         GET_SHAPE_CONFIG(HEADER::BADGE_FONT_SIZE, GetOrientation(), fontSize);
2330                         GET_SHAPE_CONFIG(HEADER::BADGE_HEIGHT, GetOrientation(), height);
2331
2332                         if (number < 10)
2333                         {
2334                                 GET_SHAPE_CONFIG(HEADER::BADGE_WIDTH_1DIGIT, GetOrientation(), width);
2335                         }
2336                         else if (number < 100)
2337                         {
2338                                 GET_SHAPE_CONFIG(HEADER::BADGE_WIDTH_2DIGIT, GetOrientation(), width);
2339                         }
2340                         else if (number < 1000)
2341                         {
2342                                 GET_SHAPE_CONFIG(HEADER::BADGE_WIDTH_3DIGIT, GetOrientation(), width);
2343                         }
2344                         else if (number < 10000)
2345                         {
2346                                 GET_SHAPE_CONFIG(HEADER::BADGE_WIDTH_4DIGIT, GetOrientation(), width);
2347                         }
2348                         else
2349                         {
2350                                 GET_SHAPE_CONFIG(HEADER::BADGE_WIDTH_5DIGIT, GetOrientation(), width);
2351                         }
2352
2353                         existingBadgeIcon->SetBounds(FloatRectangle(bounds.width - width, 0.0f, width, height));
2354                         existingBadgeIcon->SetTextConfig(fontSize, LABEL_TEXT_STYLE_NORMAL);
2355
2356                         Integer tempNumber(number);
2357                         existingBadgeIcon->SetText(tempNumber.ToString());
2358                 }
2359         }
2360
2361         return E_SUCCESS;
2362 }
2363
2364 result
2365 _Toolbar::SetItemSelected(int itemIndex, bool fire, bool adjust)
2366 {
2367         SysTryReturnResult(NID_UI_CTRL, (itemIndex >= -1 && itemIndex < __itemCount), E_INVALID_STATE,
2368                                         "[E_INVALID_STATE] Failed to process SetItemSelected()");
2369
2370         result r = E_SUCCESS;
2371
2372         int currentSelectedItemIndex = 0;
2373         currentSelectedItemIndex = GetSelectedItemIndex();
2374
2375         r = __pToolbarPresenter->SetItemSelected(itemIndex, adjust);
2376
2377         if (itemIndex != -1 && itemIndex == currentSelectedItemIndex && __pItems.at(itemIndex) != null) // same item selected
2378         {
2379                 if (!IsInitialDraw() && fire)
2380                 {
2381                         PLAY_FEEDBACK(_RESOURCE_FEEDBACK_PATTERN_TAP, __pItems.at(itemIndex));
2382                 }
2383
2384                 __pItems.at(itemIndex)->SetButtonStatus(_BUTTON_STATUS_SELECTED, fire);
2385
2386                 for (int i = 0; i < __itemCount; i++)
2387                 {
2388                         __pItems.at(i)->ShowUnderlineBitmap(false);
2389                 }
2390
2391                 __pItems.at(itemIndex)->ShowUnderlineBitmap(true);
2392
2393                 _AccessibilityElement* pElement = __pItems.at(currentSelectedItemIndex)->GetAccessibilityContainer()->GetChildElement(0);
2394                 if (pElement)
2395                 {
2396                         pElement->SetStatusWithStringId("IDS_TPLATFORM_BODY_SELECTED_T_TTS");
2397                         pElement->SetHintDisabled(true);
2398                 }
2399
2400                 return r;
2401         }
2402
2403         if (__itemCount == 0 || __itemCount > TAB_ITEM_MAX || itemIndex == -1)
2404         {
2405                 return r;
2406         }
2407
2408         SysTryReturnResult(NID_UI_CTRL, r == E_SUCCESS, E_INVALID_STATE, "[E_INVALID_STATE] Failed to process SetItemSelected()");
2409
2410         if (__pItems.at(itemIndex) != null)
2411         {
2412                 if (!IsInitialDraw() && fire)
2413                 {
2414                         PLAY_FEEDBACK(_RESOURCE_FEEDBACK_PATTERN_TAP, __pItems.at(itemIndex));
2415                 }
2416                 __pItems.at(itemIndex)->SetButtonStatus(_BUTTON_STATUS_SELECTED, fire);
2417                 __pItems.at(itemIndex)->ShowUnderlineBitmap(true);
2418
2419                 _AccessibilityElement* pElement = __pItems.at(itemIndex)->GetAccessibilityContainer()->GetChildElement(0);
2420                 if (pElement)
2421                 {
2422                         pElement->SetStatusWithStringId("IDS_TPLATFORM_BODY_SELECTED_T_TTS");
2423                         pElement->SetHintDisabled(true);
2424                 }
2425         }
2426
2427         if (__itemCount == 0 || __itemCount > TAB_ITEM_MAX || itemIndex == -1)
2428         {
2429                 return r;
2430         }
2431
2432         if (currentSelectedItemIndex != -1 && __pItems.at(currentSelectedItemIndex) != null)
2433         {
2434                 __pItems.at(currentSelectedItemIndex)->SetButtonStatus(_BUTTON_STATUS_NORMAL);
2435                 __pItems.at(currentSelectedItemIndex)->ShowUnderlineBitmap(false);
2436
2437                 _AccessibilityElement* pElement = __pItems.at(currentSelectedItemIndex)->GetAccessibilityContainer()->GetChildElement(0);
2438                 if (pElement)
2439                 {
2440                         pElement->SetStatus(L"");
2441                         pElement->SetHintDisabled(false);
2442                 }
2443         }
2444
2445         if (__pItems.at(itemIndex) != null)
2446         {
2447                 __pItems.at(itemIndex)->Draw();
2448         }
2449
2450         return r;
2451 }
2452
2453 result
2454 _Toolbar::SetItemHighlighted(int itemIndex, bool fire, bool adjust)
2455 {
2456         SysTryReturnResult(NID_UI_CTRL, (itemIndex >= -1 && itemIndex < __itemCount), E_INVALID_STATE,
2457                                         "[E_INVALID_STATE] Failed to process SetItemHighlighted()");
2458
2459         result r = E_SUCCESS;
2460
2461         int currentSelectedItemIndex = 0;
2462         currentSelectedItemIndex = GetSelectedItemIndex();
2463
2464         r = __pToolbarPresenter->SetItemSelected(itemIndex, adjust);
2465
2466         if (itemIndex != -1 && itemIndex == currentSelectedItemIndex && __pItems.at(itemIndex) != null) // same item selected
2467         {
2468                 if (!IsInitialDraw() && fire)
2469                 {
2470                         PLAY_FEEDBACK(_RESOURCE_FEEDBACK_PATTERN_TAP, __pItems.at(itemIndex));
2471                 }
2472
2473                 __pItems.at(itemIndex)->SetButtonStatus(_BUTTON_STATUS_HIGHLIGHTED, fire);
2474                 __pItems.at(itemIndex)->ShowUnderlineBitmap(true);
2475                 __pItems.at(itemIndex)->Draw();
2476
2477                 __highlightedItemIndex = itemIndex;
2478                 __lastHighlightedItemIndex = __highlightedItemIndex;
2479                 __highlighted = true;
2480
2481                 _AccessibilityElement* pElement = __pItems.at(currentSelectedItemIndex)->GetAccessibilityContainer()->GetChildElement(0);
2482                 if (pElement)
2483                 {
2484                         pElement->SetStatus(L"Highlighted");
2485                         pElement->SetHintDisabled(true);
2486                 }
2487
2488                 return r;
2489         }
2490
2491         if (__itemCount == 0 || __itemCount > TAB_ITEM_MAX || itemIndex == -1)
2492         {
2493                 return r;
2494         }
2495
2496         SysTryReturnResult(NID_UI_CTRL, r == E_SUCCESS, E_INVALID_STATE, "[E_INVALID_STATE] Failed to process SetItemHighlighted()");
2497
2498         if (__pItems.at(itemIndex) != null)
2499         {
2500                 if (!IsInitialDraw() && fire)
2501                 {
2502                         PLAY_FEEDBACK(_RESOURCE_FEEDBACK_PATTERN_TAP, __pItems.at(itemIndex));
2503                 }
2504
2505                 __pItems.at(itemIndex)->SetButtonStatus(_BUTTON_STATUS_HIGHLIGHTED, fire);
2506                 __pItems.at(itemIndex)->Draw();
2507
2508                 for (int i = 0; i < __itemCount; i++)
2509                 {
2510                         __pItems.at(i)->ShowUnderlineBitmap(false);
2511                 }
2512
2513                 __pItems.at(itemIndex)->ShowUnderlineBitmap(true);
2514                 __pItems.at(itemIndex)->Draw();
2515
2516                 __highlightedItemIndex = itemIndex;
2517                 __lastHighlightedItemIndex = __highlightedItemIndex;
2518                 __highlighted = true;
2519
2520                 _AccessibilityElement* pElement = __pItems.at(itemIndex)->GetAccessibilityContainer()->GetChildElement(0);
2521                 if (pElement)
2522                 {
2523                         pElement->SetStatus(L"Highlighted");
2524                         pElement->SetHintDisabled(true);
2525                 }
2526         }
2527
2528         if (__itemCount == 0 || __itemCount > TAB_ITEM_MAX || itemIndex == -1)
2529         {
2530                 return r;
2531         }
2532
2533         if (currentSelectedItemIndex != -1 && __pItems.at(currentSelectedItemIndex) != null)
2534         {
2535                 __pItems.at(currentSelectedItemIndex)->SetButtonStatus(_BUTTON_STATUS_NORMAL);
2536                 __pItems.at(currentSelectedItemIndex)->ShowUnderlineBitmap(false);
2537                 __pItems.at(currentSelectedItemIndex)->Draw();
2538
2539                 _AccessibilityElement* pElement = __pItems.at(currentSelectedItemIndex)->GetAccessibilityContainer()->GetChildElement(0);
2540                 if (pElement)
2541                 {
2542                         pElement->SetStatus(L"");
2543                         pElement->SetHintDisabled(false);
2544                 }
2545         }
2546
2547         return r;
2548 }
2549
2550 result
2551 _Toolbar::SetItemTextColor(_ButtonStatus status, const Color& color)
2552 {
2553         switch(status)
2554         {
2555         case _BUTTON_STATUS_NORMAL:
2556                 __isItemTextColorSetByUser[_BUTTON_STATUS_NORMAL] = true;
2557                 return SetProperty(L"normalItemTextColor", Variant(color));
2558                 break;
2559         case _BUTTON_STATUS_DISABLED:
2560                 __isItemTextColorSetByUser[_BUTTON_STATUS_DISABLED] = true;
2561                 return SetProperty(L"disabledItemTextColor", Variant(color));
2562                 break;
2563         case _BUTTON_STATUS_PRESSED:
2564                 __isItemTextColorSetByUser[_BUTTON_STATUS_PRESSED] = true;
2565                 return SetProperty(L"pressedItemTextColor", Variant(color));
2566                 break;
2567         case _BUTTON_STATUS_HIGHLIGHTED:
2568                 __isItemTextColorSetByUser[_BUTTON_STATUS_HIGHLIGHTED] = true;
2569                 return SetProperty(L"highlightedItemTextColor", Variant(color));
2570                 break;
2571         case _BUTTON_STATUS_SELECTED:
2572                 __isItemTextColorSetByUser[_BUTTON_STATUS_SELECTED] = true;
2573                 return SetProperty(L"selectedItemTextColor", Variant(color));
2574                 break;
2575         default:
2576                 __isItemTextColorSetByUser[_BUTTON_STATUS_NORMAL] = true;
2577                 return SetProperty(L"normalItemTextColor", Variant(color));
2578                 break;
2579         }
2580 }
2581
2582 result
2583 _Toolbar::SetStyle(ToolbarStyle style)
2584 {
2585         __style = style;
2586
2587         __pToolbarPresenter->SetInitialDrawState(true);
2588
2589         if (__style == TOOLBAR_TAB || __style == TOOLBAR_TAB_WITH_TITLE || __style == TOOLBAR_TAB_LARGE)
2590         {
2591                 SetTabEditModeEnabled(true);
2592         }
2593
2594         AdjustToolbarBounds();
2595
2596         InitToolbarColor();
2597
2598         __titleText = L"";
2599
2600         __descriptionText = L"";
2601
2602         __highlightedItemIndex = 0;
2603         __lastHighlightedItemIndex = 0;
2604         __highlighted = false;
2605
2606         if (__style == TOOLBAR_TITLE || __style == TOOLBAR_HEADER_SEGMENTED_WITH_TITLE || __style == TOOLBAR_TAB_WITH_TITLE)
2607         {
2608                 if(__pTitleTextElement)
2609                 {
2610                         __pTitleTextElement->SetLabel(L"");
2611                 }
2612         }
2613         else
2614         {
2615                 if(__pTitleTextElement)
2616                 {
2617                         GetAccessibilityContainer()->RemoveElement(*__pTitleTextElement);
2618                         __pTitleTextElement = null;
2619                 }
2620         }
2621
2622         if (__itemCount == 0 && __pButtonItems[LEFT_BUTTON] == null && __pButtonItems[RIGHT_BUTTON] == null)
2623         {
2624                 SetFocusNavigateEnabled(false);
2625         }
2626         else
2627         {
2628                 SetFocusNavigateEnabled(true);
2629         }
2630
2631         return E_SUCCESS;
2632 }
2633
2634 result
2635 _Toolbar::AdjustToolbarBounds(void)
2636 {
2637         float width = 0.0f;
2638         float height = 0.0f;
2639
2640         const FloatDimension portraitSize = _ControlManager::GetInstance()->_ControlManager::GetScreenSizeF();
2641         const FloatDimension landscapeSize = FloatDimension(portraitSize.height, portraitSize.width);
2642
2643         if (GetOrientation() == _CONTROL_ORIENTATION_PORTRAIT)
2644         {
2645                 width = portraitSize.width;
2646         }
2647         else
2648         {
2649                 width = landscapeSize.width;
2650         }
2651
2652         SetResizable(true);
2653
2654         if (__header == true)
2655         {
2656                 if (__style == TOOLBAR_HEADER_SEGMENTED_WITH_TITLE || __style == TOOLBAR_TAB_WITH_TITLE)
2657                 {
2658                         //GET_SHAPE_CONFIG(HEADER::WIDTH, GetOrientation(), width);
2659                         GET_SHAPE_CONFIG(HEADER::TITLE_TOTAL_HEIGHT_WITH_SEGMENTED_ITEM, GetOrientation(), height);
2660                         SetSize(FloatDimension(width, height));
2661                 }
2662                 else if (__style == TOOLBAR_TEXT && GetOrientation() == _CONTROL_ORIENTATION_LANDSCAPE) // sip & landscape => footer height
2663                 {
2664                         //GET_SHAPE_CONFIG(HEADER::WIDTH, GetOrientation(), width);
2665                         GET_SHAPE_CONFIG(FOOTER::HEIGHT, GetOrientation(), height);
2666                         SetSize(FloatDimension(width, height));
2667                 }
2668                 else if (__style == TOOLBAR_TAB_LARGE)
2669                 {
2670                         //GET_SHAPE_CONFIG(HEADER::WIDTH, GetOrientation(), width);
2671                         GET_SHAPE_CONFIG(HEADER::TAB_LARGE_HEIGHT, GetOrientation(), height);
2672                         SetSize(FloatDimension(width, height));
2673                 }
2674                 else
2675                 {
2676                         //GET_SHAPE_CONFIG(HEADER::WIDTH, GetOrientation(), width);
2677                         GET_SHAPE_CONFIG(HEADER::HEIGHT, GetOrientation(), height);
2678                         SetSize(FloatDimension(width, height));
2679                 }
2680         }
2681         else
2682         {
2683                 //GET_SHAPE_CONFIG(FOOTER::WIDTH, GetOrientation(), width);
2684
2685                 if (__style == TOOLBAR_SOFTKEY)
2686                 {
2687                         GET_SHAPE_CONFIG(FOOTER::SOFTKEY_HEIGHT, GetOrientation(), height);
2688                 }
2689                 else if (__style == TOOLBAR_TAB_LARGE)
2690                 {
2691                         GET_SHAPE_CONFIG(FOOTER::TAB_LARGE_HEIGHT, GetOrientation(), height);
2692                 }
2693                 else
2694                 {
2695                         GET_SHAPE_CONFIG(FOOTER::HEIGHT, GetOrientation(), height);
2696                 }
2697
2698                 SetSize(FloatDimension(width, height));
2699         }
2700
2701         SetResizable(false);
2702
2703         _Form* pParent = dynamic_cast<_Form*>(GetParent());
2704
2705         if (pParent != null)
2706         {
2707                 pParent->AdjustClientBounds();
2708
2709                 if (__header == false)
2710                 {
2711                         FloatRectangle bounds(0.0f, pParent->GetClientBoundsF().y + pParent->GetClientBoundsF().height, width, height);
2712                         FloatDimension dimension(width, height);
2713                         dimension = pParent->TranslateSize(dimension);
2714                         bounds.height = dimension.height;
2715
2716                         if ((__transparent == true || !GetVisibleState()) && __style != TOOLBAR_COMMAND)
2717                         {
2718                                 bounds.y -= bounds.height;
2719                         }
2720
2721                         pParent->SetFooterBounds(bounds);
2722                 }
2723         }
2724
2725         return E_SUCCESS;
2726 }
2727
2728 result
2729 _Toolbar::SetTabEditModeEnabled(bool enable)
2730 {
2731         return __pToolbarPresenter->SetTabEditModeEnabled(enable);
2732 }
2733
2734 result
2735 _Toolbar::SetTitleIcon(const Bitmap& bitmap)
2736 {
2737         result r = E_SYSTEM;
2738
2739         Bitmap* pClonedBitmap = _BitmapImpl::CloneN(bitmap);
2740
2741         if (pClonedBitmap)
2742         {
2743                 if (__pTitleIcon)
2744                 {
2745                         delete __pTitleIcon;
2746                 }
2747
2748                 __pTitleIcon = pClonedBitmap;
2749
2750                 r = E_SUCCESS;
2751         }
2752
2753         return r;
2754 }
2755
2756 result
2757 _Toolbar::SetTitleText(const String& text, HorizontalAlignment alignment)
2758 {
2759         result r = E_SYSTEM;
2760         __titleText = text;
2761         __titleTextAlignment = alignment;
2762
2763         RearrangeItems();
2764
2765         r = __pToolbarPresenter->SetTitleText(__titleText, __titleTextAlignment);
2766
2767         if (__pTitleTextElement == null)
2768         {
2769                 __pTitleTextElement = new (std::nothrow) _AccessibilityElement(true);
2770                 SysTryReturnResult(NID_UI_CTRL, __pTitleTextElement, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] Memory shortage.");
2771                 GetAccessibilityContainer()->SetPriority(ACCESSIBILITY_PRIORITY_TOP);
2772                 GetAccessibilityContainer()->AddElement(*__pTitleTextElement);
2773         }
2774
2775         if( __descriptionText.IsEmpty())
2776         {
2777                 __pTitleTextElement->SetLabel(__titleText);
2778                 __pTitleTextElement->SetBounds(FloatRectangle(__pToolbarPresenter->GetTitleTextBoundsF()));
2779         }
2780         else
2781         {
2782                 __pTitleTextElement->SetLabel(__titleText + L"," + __descriptionText);
2783
2784                 FloatRectangle descriptionBounds = __pToolbarPresenter->GetDescriptionBoundsF();
2785                 FloatRectangle titleBounds = __pToolbarPresenter->GetTitleTextBoundsF();
2786
2787                 __pTitleTextElement->SetBounds(FloatRectangle(titleBounds.x, titleBounds.y, titleBounds.width, titleBounds.height + descriptionBounds.height));
2788         }
2789         __pTitleTextElement->SetTraitWithStringId("IDS_TPLATFORM_BODY_TITLE");
2790         __pTitleTextElement->SetName(L"HeaderTitleText");
2791
2792         return r;
2793 }
2794
2795 result
2796 _Toolbar::SetTitleTextColor(const Color& color)
2797 {
2798         __titleTextColor = color;
2799
2800         return E_SUCCESS;
2801 }
2802
2803 result
2804 _Toolbar::SetTransparent(bool transparent)
2805 {
2806         if (__style == TOOLBAR_SOFTKEY)
2807         {
2808                 return E_SUCCESS;
2809         }
2810
2811         __transparent = transparent;
2812
2813         InitToolbarColor();
2814
2815         __isUserBackgroundBitmap = true;
2816
2817
2818         Bitmap* pMagentaBackgroundBitmap = null;
2819
2820         if (__pToolbarBackgroundBitmap)
2821         {
2822                 delete __pToolbarBackgroundBitmap;
2823                 __pToolbarBackgroundBitmap = null;
2824         }
2825
2826         if (__pToolbarBackgroundEffectBitmap)
2827         {
2828                 delete __pToolbarBackgroundEffectBitmap;
2829                 __pToolbarBackgroundEffectBitmap = null;
2830         }
2831
2832
2833         if (__transparent == true)
2834         {
2835                 if (__header == true)
2836                 {
2837                         GET_BITMAP_CONFIG_N(HEADER::TRANSLUCENT_BG_NORMAL, BITMAP_PIXEL_FORMAT_ARGB8888, pMagentaBackgroundBitmap);
2838
2839                         bool customTheme = IS_CUSTOM_BITMAP(HEADER::TRANSLUCENT_BG_NORMAL);
2840                         if (customTheme == false)
2841                         {
2842                                 GET_BITMAP_CONFIG_N(HEADER::TRANSLUCENT_BG_EFFECT_NORMAL, BITMAP_PIXEL_FORMAT_ARGB8888, __pToolbarBackgroundEffectBitmap);
2843                         }
2844                 }
2845                 else
2846                 {
2847                         GET_BITMAP_CONFIG_N(FOOTER::TRANSLUCENT_BG_NORMAL, BITMAP_PIXEL_FORMAT_ARGB8888, pMagentaBackgroundBitmap);
2848
2849                         bool customTheme = IS_CUSTOM_BITMAP(FOOTER::TRANSLUCENT_BG_NORMAL);
2850                         if (customTheme == false)
2851                         {
2852                                 GET_BITMAP_CONFIG_N(FOOTER::TRANSLUCENT_BG_EFFECT_NORMAL, BITMAP_PIXEL_FORMAT_ARGB8888, __pToolbarBackgroundEffectBitmap);
2853                         }
2854                 }
2855         }
2856         else
2857         {
2858                 if (__header == true)
2859                 {
2860                         GET_BITMAP_CONFIG_N(HEADER::BG_NORMAL, BITMAP_PIXEL_FORMAT_ARGB8888, pMagentaBackgroundBitmap);
2861
2862                         bool customTheme = IS_CUSTOM_BITMAP(HEADER::BG_NORMAL);
2863                         if (customTheme == false)
2864                         {
2865                                 GET_BITMAP_CONFIG_N(HEADER::BG_EFFECT_NORMAL, BITMAP_PIXEL_FORMAT_ARGB8888, __pToolbarBackgroundEffectBitmap);
2866                         }
2867                 }
2868                 else
2869                 {
2870                         GET_BITMAP_CONFIG_N(FOOTER::BG_NORMAL, BITMAP_PIXEL_FORMAT_ARGB8888, pMagentaBackgroundBitmap);
2871
2872                         bool customTheme = IS_CUSTOM_BITMAP(FOOTER::BG_NORMAL);
2873                         if (customTheme == false)
2874                         {
2875                                 GET_BITMAP_CONFIG_N(FOOTER::BG_EFFECT_NORMAL, BITMAP_PIXEL_FORMAT_ARGB8888, __pToolbarBackgroundEffectBitmap);
2876                         }
2877                 }
2878         }
2879
2880         if (__transparent == true)
2881         {
2882                 Color tempColor;
2883
2884                 if (__header == true)
2885                 {
2886                         GET_COLOR_CONFIG(HEADER::TRANSLUCENT_BG_NORMAL, tempColor);
2887                 }
2888                 else
2889                 {
2890                         GET_COLOR_CONFIG(FOOTER::TRANSLUCENT_BG_NORMAL, tempColor);
2891                 }
2892
2893                 if (pMagentaBackgroundBitmap)
2894                 {
2895                         __pToolbarBackgroundBitmap = _BitmapImpl::GetColorReplacedBitmapN(*(pMagentaBackgroundBitmap),
2896                                         Color::GetColor(COLOR_ID_MAGENTA), tempColor);
2897
2898                         if (__pToolbarBackgroundBitmap)
2899                         {
2900                                 __pToolbarBackgroundBitmap->SetAlphaConstant(0x7F);
2901                         }
2902                 }
2903
2904                 SetTitleTextColor(__transTitleTextColor);
2905                 SetDescriptionTextColor(__transDescriptionTextColor);
2906
2907                 for (int i = 0; i < __itemCount ; i ++)
2908                 {
2909                         if (__pItems.at(i) != null)
2910                         {
2911                                 ApplyUserGUI(TOOLBAR_ITEM, __pItems.at(i));
2912                         }
2913                 }
2914
2915                 for (int i = 0; i < BUTTON_MAX; i++)
2916                 {
2917                         if (__pButtonItems[i] != null)
2918                         {
2919                                 ApplyUserGUI(TOOLBAR_BUTTON, __pButtonItems[i]);
2920                         }
2921                 }
2922         }
2923         else // not transparent
2924         {
2925                 __pToolbarBackgroundBitmap = _BitmapImpl::GetColorReplacedBitmapN(*(pMagentaBackgroundBitmap),
2926                                 Color::GetColor(COLOR_ID_MAGENTA), GetColor());
2927
2928                 SetTitleTextColor(__titleTextColor);
2929                 SetDescriptionTextColor(__descriptionTextColor);
2930
2931                 for (int i = 0; i < __itemCount ; i ++)
2932                 {
2933                         if (__pItems.at(i) != null)
2934                         {
2935                                 ApplyUserGUI(TOOLBAR_ITEM, __pItems.at(i));
2936                         }
2937                 }
2938
2939                 for (int i = 0; i < BUTTON_MAX; i++)
2940                 {
2941                         if (__pButtonItems[i] != null)
2942                         {
2943                                 ApplyUserGUI(TOOLBAR_BUTTON, __pButtonItems[i]);
2944                         }
2945                 }
2946         }
2947
2948         delete pMagentaBackgroundBitmap;
2949
2950         return E_SUCCESS;
2951 }
2952
2953 result
2954 _Toolbar::SetWaitingAnimationPosition(ToolbarAnimationPosition animationPos, float x, float y)
2955 {
2956         if (__pAnimation[animationPos])
2957         {
2958                 __pAnimation[animationPos]->SetPosition(FloatPoint(x, y));
2959         }
2960
2961         return E_SUCCESS;
2962 }
2963
2964 result
2965 _Toolbar::StopWaitingAnimation(ToolbarAnimationPosition animationPos)
2966 {
2967         SysTryReturnResult(NID_UI_CTRL,
2968                         (TOOLBAR_ANIMATION_POSITION_TITLE <= animationPos && animationPos < TOOLBAR_ANIMATION_POSITION_MAX), E_INVALID_ARG,
2969                         "[E_INVALID_ARG] The animationPos is invalid.");
2970         SysTryReturnResult(NID_UI_CTRL, (__pAnimation[animationPos]), E_INVALID_STATE,
2971                         "[E_INVALID_STATE] __pAnimation isn't constructed.");
2972
2973         __pAnimation[animationPos]->Stop();
2974
2975         if (animationPos == TOOLBAR_ANIMATION_POSITION_TITLE)
2976         {
2977                 DetachChild(*__pAnimation[animationPos]);
2978         }
2979         else if (animationPos == TOOLBAR_ANIMATION_POSITION_BUTTON_LEFT && __pButtonItems[LEFT_BUTTON] != null)
2980         {
2981                 __pButtonItems[LEFT_BUTTON]->DetachChild(*__pAnimation[animationPos]);
2982         }
2983         else if (animationPos == TOOLBAR_ANIMATION_POSITION_BUTTON_RIGHT && __pButtonItems[RIGHT_BUTTON] != null)
2984         {
2985                 __pButtonItems[RIGHT_BUTTON]->DetachChild(*__pAnimation[animationPos]);
2986         }
2987
2988         delete __pAnimation[animationPos];
2989         __pAnimation[animationPos] = null;
2990
2991         return E_SUCCESS;
2992 }
2993
2994 void
2995 _Toolbar::OnAnimationStopped(const _Control& source)
2996 {
2997         ClearLastResult();
2998
2999         if (&source == __pAnimation[TOOLBAR_ANIMATION_POSITION_BUTTON_LEFT])
3000         {
3001                 __pAnimation[TOOLBAR_ANIMATION_POSITION_BUTTON_LEFT]->Play();
3002         }
3003         else if (&source == __pAnimation[TOOLBAR_ANIMATION_POSITION_BUTTON_RIGHT])
3004         {
3005                 __pAnimation[TOOLBAR_ANIMATION_POSITION_BUTTON_RIGHT]->Play();
3006         }
3007         else if (__pAnimation[TOOLBAR_ANIMATION_POSITION_TITLE])
3008         {
3009                 __pAnimation[TOOLBAR_ANIMATION_POSITION_TITLE]->Play();
3010         }
3011
3012         return;
3013 }
3014
3015 result
3016 _Toolbar::OnAttachedToMainTree(void)
3017 {
3018         return E_SUCCESS;
3019 }
3020
3021 void
3022 _Toolbar::AddAccessibilityElement(ToolbarButton position, _Button* pButton)
3023 {
3024         String name = L"";
3025         switch(position)
3026         {
3027                 case LEFT_BUTTON:
3028                         name = L"LeftButtonText";
3029                         break;
3030                 case RIGHT_BUTTON:
3031                         name = L"RightButtonText";
3032                         break;
3033                 case MIDDLE_BUTTON:
3034                         name = L"MiddleButtonText";
3035                         break;
3036                 default:
3037                         return;
3038                         break;
3039         }
3040         _AccessibilityContainer* pContainer = GetAccessibilityContainer();
3041         _AccessibilityElement* pButtonElement = null;
3042
3043         _AccessibilityContainer* pButtonContainer = pButton->GetAccessibilityContainer();
3044
3045         if (pButtonContainer)
3046         {
3047                 pButtonContainer->SetPriority(__header?ACCESSIBILITY_PRIORITY_TOP:ACCESSIBILITY_PRIORITY_BOTTOM);
3048                 pContainer->AddChildContainer(*pButtonContainer);
3049                 pButtonElement = pButtonContainer->GetChildElement(L"ButtonText");
3050         }
3051
3052         if(pButtonElement)
3053         {
3054                 pButtonElement->SetName(name);
3055
3056                 pButtonElement->SetTraitWithStringId("IDS_TPLATFORM_BODY_BUTTON_T_TTS");
3057                 FloatRectangle floatRect = GetButtonBoundsF(position);
3058                 pButtonElement->SetBounds(FloatRectangle(0,floatRect.y, pButton->GetBoundsF().width, floatRect.height));
3059         }
3060 }
3061
3062 void
3063 _Toolbar::AddAccessibilityElement(_Button* pButton)
3064 {
3065         _AccessibilityContainer* pContainer = GetAccessibilityContainer();
3066         if(pContainer == null)
3067         {
3068                 return;
3069         }
3070
3071         int priorty = 0;
3072         if(__header == true)
3073         {
3074                 priorty = ACCESSIBILITY_PRIORITY_TOP;
3075         }
3076         else
3077         {
3078                 priorty = ACCESSIBILITY_PRIORITY_BOTTOM;
3079         }
3080         pContainer->SetPriority(priorty);
3081
3082         ToolbarStyle style = GetStyle();
3083         String trait = L"";
3084         String name = L"";
3085         switch (style)
3086         {
3087                 case TOOLBAR_HEADER_SEGMENTED:
3088                         //fall through
3089                 case TOOLBAR_HEADER_SEGMENTED_WITH_TITLE:
3090                         //fall through
3091                 case TOOLBAR_SEGMENTED:
3092                         name = L"Segment" + Integer::ToString(__itemCount);
3093                         name.Append(L"Text");
3094                         trait = L"Segmented control";
3095                         break;
3096                 case TOOLBAR_TAB_WITH_TITLE:
3097                         //fall through
3098                 case TOOLBAR_TAB_LARGE:
3099                         //fall through
3100                 case TOOLBAR_TAB:
3101                         name = L"Tab" + Integer::ToString(__itemCount);
3102                         name.Append(L"Text");
3103                         trait = L"Tab";
3104                         break;
3105                 default:
3106                         name = L"Button" + Integer::ToString(__itemCount);
3107                         name.Append(L"Text");
3108                         trait = L"Button";
3109                         break;
3110         }
3111
3112         if (pButton != null)
3113         {
3114                 _AccessibilityElement* pElement = null;
3115                 _AccessibilityContainer* pButtonContainer = pButton->GetAccessibilityContainer();
3116
3117                 if (pButtonContainer)
3118                 {
3119                         pButtonContainer->SetPriority(priorty);
3120                         pContainer->AddChildContainer(*pButtonContainer);
3121                         pElement = pButtonContainer->GetChildElement(L"ButtonText");
3122                 }
3123
3124                 if(pElement)
3125                 {
3126                         pElement->SetName(name);
3127                         pElement->SetTrait(trait);
3128                         if(style == TOOLBAR_HEADER_SEGMENTED || style == TOOLBAR_HEADER_SEGMENTED_WITH_TITLE
3129                                 || style == TOOLBAR_SEGMENTED || style == TOOLBAR_TAB_WITH_TITLE
3130                                 || style == TOOLBAR_TAB || __style == TOOLBAR_TAB_LARGE)
3131                         {
3132                                 pElement->SetHintWithStringId("IDS_TPLATFORM_BODY_DOUBLE_TAP_TO_MOVE_TO_CONTENT_T_TTS");
3133                                 pButton->GetAccessibilityContainer()->AddListener(*__pAccessibilityListener);
3134                         }
3135                 }
3136         }
3137
3138         return;
3139 }
3140
3141 void
3142 _Toolbar::OnBoundsChanged(void)
3143 {
3144         RearrangeItems();
3145
3146         if(__pTitleTextElement)
3147         {
3148                 if( __descriptionText.IsEmpty())
3149                 {
3150                         __pTitleTextElement->SetBounds(FloatRectangle(__pToolbarPresenter->GetTitleTextBoundsF()));
3151                 }
3152                 else
3153                 {
3154                         FloatRectangle descriptionBounds = __pToolbarPresenter->GetDescriptionBoundsF();
3155                         FloatRectangle titleBounds = __pToolbarPresenter->GetTitleTextBoundsF();
3156
3157                         __pTitleTextElement->SetBounds(FloatRectangle(titleBounds.x, titleBounds.y, titleBounds.width, titleBounds.height + descriptionBounds.height));
3158                 }
3159         }
3160         return;
3161 }
3162
3163 void
3164 _Toolbar::OnFontChanged(Font* pFont)
3165 {
3166         __pToolbarPresenter->OnFontChanged(pFont);
3167
3168         return;
3169 }
3170
3171 void
3172 _Toolbar::OnFontInfoRequested(unsigned long& style, int& size)
3173 {
3174         __pToolbarPresenter->OnFontInfoRequested(style, size);
3175
3176         return;
3177 }
3178
3179 void
3180 _Toolbar::OnAncestorVisibleStateChanged(const _Control& control)
3181 {
3182         __pToolbarPresenter->OnAncestorVisibleStateChanged(control);
3183
3184         _Control::OnAncestorVisibleStateChanged(control);
3185         return;
3186 }
3187
3188 void
3189 _Toolbar::OnDrawFocus(void)
3190 {
3191         if (IsFocusModeStateEnabled() == false)
3192         {
3193                 if (__itemCount == 0)
3194                 {
3195                         if (__pButtonItems[LEFT_BUTTON])
3196                         {
3197                                 if (__pButtonItems[RIGHT_BUTTON])
3198                                 {
3199                                         if (__highlightedItemIndex == __itemCount)
3200                                         {
3201                                                 if (__pButtonItems[LEFT_BUTTON]->GetButtonStatus() != _BUTTON_STATUS_DISABLED)
3202                                                 {
3203                                                         __pButtonItems[LEFT_BUTTON]->SetButtonStatus(_BUTTON_STATUS_HIGHLIGHTED, false);
3204                                                 }
3205                                         }
3206                                         else if (__highlightedItemIndex == __itemCount + 1)
3207                                         {
3208                                                 if (__pButtonItems[RIGHT_BUTTON]->GetButtonStatus() != _BUTTON_STATUS_DISABLED)
3209                                                 {
3210                                                         __pButtonItems[RIGHT_BUTTON]->SetButtonStatus(_BUTTON_STATUS_HIGHLIGHTED, false);
3211                                                 }
3212                                         }
3213                                 }
3214                                 else
3215                                 {
3216                                         if (__highlightedItemIndex == __itemCount)
3217                                         {
3218                                                 if (__pButtonItems[LEFT_BUTTON]->GetButtonStatus() != _BUTTON_STATUS_DISABLED)
3219                                                 {
3220                                                         __pButtonItems[LEFT_BUTTON]->SetButtonStatus(_BUTTON_STATUS_HIGHLIGHTED, false);
3221                                                 }
3222                                         }
3223                                 }
3224                         }
3225                         else
3226                         {
3227                                 if (__pButtonItems[RIGHT_BUTTON])
3228                                 {
3229                                         if (__highlightedItemIndex == __itemCount)
3230                                         {
3231                                                 if (__pButtonItems[RIGHT_BUTTON]->GetButtonStatus() != _BUTTON_STATUS_DISABLED)
3232                                                 {
3233                                                         __pButtonItems[RIGHT_BUTTON]->SetButtonStatus(_BUTTON_STATUS_HIGHLIGHTED, false);
3234                                                 }
3235                                         }
3236                                 }
3237                         }
3238                 }
3239                 else // __itemCount != 0
3240                 {
3241                         if (__highlightedItemIndex < __itemCount)
3242                         {
3243                                 if (__pItems.at(__highlightedItemIndex))
3244                                 {
3245                                         if (__pItems.at(__highlightedItemIndex)->GetButtonStatus() != _BUTTON_STATUS_DISABLED)
3246                                         {
3247                                                 __pItems.at(__highlightedItemIndex)->SetButtonStatus(_BUTTON_STATUS_HIGHLIGHTED, false);
3248                                         }
3249                                 }
3250                         }
3251                         else
3252                         {
3253                                 if (__pButtonItems[LEFT_BUTTON])
3254                                 {
3255                                         if (__pButtonItems[RIGHT_BUTTON])
3256                                         {
3257                                                 if (__highlightedItemIndex == __itemCount)
3258                                                 {
3259                                                         if (__pButtonItems[LEFT_BUTTON]->GetButtonStatus() != _BUTTON_STATUS_DISABLED)
3260                                                         {
3261                                                                 __pButtonItems[LEFT_BUTTON]->SetButtonStatus(_BUTTON_STATUS_HIGHLIGHTED, false);
3262                                                         }
3263                                                 }
3264                                                 else if (__highlightedItemIndex == __itemCount + 1)
3265                                                 {
3266                                                         if (__pButtonItems[RIGHT_BUTTON]->GetButtonStatus() != _BUTTON_STATUS_DISABLED)
3267                                                         {
3268                                                                 __pButtonItems[RIGHT_BUTTON]->SetButtonStatus(_BUTTON_STATUS_HIGHLIGHTED, false);
3269                                                         }
3270                                                 }
3271                                         }
3272                                         else
3273                                         {
3274                                                 if (__highlightedItemIndex == __itemCount)
3275                                                 {
3276                                                         if (__pButtonItems[LEFT_BUTTON]->GetButtonStatus() != _BUTTON_STATUS_DISABLED)
3277                                                         {
3278                                                                 __pButtonItems[LEFT_BUTTON]->SetButtonStatus(_BUTTON_STATUS_HIGHLIGHTED, false);
3279                                                         }
3280                                                 }
3281                                         }
3282                                 }
3283                                 else
3284                                 {
3285                                         if (__pButtonItems[RIGHT_BUTTON])
3286                                         {
3287                                                 if (__highlightedItemIndex == __itemCount)
3288                                                 {
3289                                                         if (__pButtonItems[RIGHT_BUTTON]->GetButtonStatus() != _BUTTON_STATUS_DISABLED)
3290                                                         {
3291                                                                 __pButtonItems[RIGHT_BUTTON]->SetButtonStatus(_BUTTON_STATUS_HIGHLIGHTED, false);
3292                                                         }
3293                                                 }
3294                                         }
3295                                 }
3296                         }
3297                 }
3298         }
3299
3300         Invalidate(true);
3301
3302         return;
3303 } //_Toolbar::OnDrawFocus(void)
3304
3305 void
3306 _Toolbar::OnChildControlFocusMoved(const _Control& control)
3307 {
3308         __pToolbarPresenter->OnChildControlFocusMoved(control);
3309
3310         return;
3311 }
3312
3313 bool
3314 _Toolbar::IsChildControlFocusManage(void) const
3315 {
3316         __pToolbarPresenter->IsChildControlFocusManage();
3317
3318         return true;
3319 }
3320
3321 void
3322 _Toolbar::OnFocusableStateChanged(bool focusalbeState)
3323 {
3324         __pToolbarPresenter->OnFocusableStateChanged(focusalbeState);
3325
3326         return;
3327 }
3328
3329 void
3330 _Toolbar::OnFocusModeStateChanged(void)
3331 {
3332         if (__itemCount == 0)
3333         {
3334                 if (__pButtonItems[LEFT_BUTTON])
3335                 {
3336                         if (__pButtonItems[RIGHT_BUTTON])
3337                         {
3338                                 if (__highlightedItemIndex == __itemCount)
3339                                 {
3340                                         if (__pButtonItems[LEFT_BUTTON]->GetButtonStatus() != _BUTTON_STATUS_DISABLED)
3341                                         {
3342                                                 __pButtonItems[LEFT_BUTTON]->SetButtonStatus(_BUTTON_STATUS_NORMAL);
3343                                         }
3344                                 }
3345                                 else if (__highlightedItemIndex == __itemCount + 1)
3346                                 {
3347                                         if (__pButtonItems[RIGHT_BUTTON]->GetButtonStatus() != _BUTTON_STATUS_DISABLED)
3348                                         {
3349                                                 __pButtonItems[RIGHT_BUTTON]->SetButtonStatus(_BUTTON_STATUS_NORMAL);
3350                                         }
3351                                 }
3352                         }
3353                         else
3354                         {
3355                                 if (__highlightedItemIndex == __itemCount)
3356                                 {
3357                                         if (__pButtonItems[LEFT_BUTTON]->GetButtonStatus() != _BUTTON_STATUS_DISABLED)
3358                                         {
3359                                                 __pButtonItems[LEFT_BUTTON]->SetButtonStatus(_BUTTON_STATUS_NORMAL);
3360                                         }
3361                                 }
3362                         }
3363                 }
3364                 else
3365                 {
3366                         if (__pButtonItems[RIGHT_BUTTON])
3367                         {
3368                                 if (__highlightedItemIndex == __itemCount)
3369                                 {
3370                                         if (__pButtonItems[RIGHT_BUTTON]->GetButtonStatus() != _BUTTON_STATUS_DISABLED)
3371                                         {
3372                                                 __pButtonItems[RIGHT_BUTTON]->SetButtonStatus(_BUTTON_STATUS_NORMAL);
3373                                         }
3374                                 }
3375                         }
3376                 }
3377         }
3378         else // __itemCount != 0
3379         {
3380                 if (__highlightedItemIndex < __itemCount)
3381                 {
3382                         if (__pItems.at(__highlightedItemIndex))
3383                         {
3384                                 if (__pItems.at(__highlightedItemIndex)->GetButtonStatus() != _BUTTON_STATUS_DISABLED)
3385                                 {
3386                                         __pItems.at(__highlightedItemIndex)->SetButtonStatus(_BUTTON_STATUS_NORMAL);
3387                                 }
3388                         }
3389                 }
3390                 else
3391                 {
3392                         if (__pButtonItems[LEFT_BUTTON])
3393                         {
3394                                 if (__pButtonItems[RIGHT_BUTTON])
3395                                 {
3396                                         if (__highlightedItemIndex == __itemCount)
3397                                         {
3398                                                 if (__pButtonItems[LEFT_BUTTON]->GetButtonStatus() != _BUTTON_STATUS_DISABLED)
3399                                                 {
3400                                                         __pButtonItems[LEFT_BUTTON]->SetButtonStatus(_BUTTON_STATUS_NORMAL);
3401                                                 }
3402                                         }
3403                                         else if (__highlightedItemIndex == __itemCount + 1)
3404                                         {
3405                                                 if (__pButtonItems[RIGHT_BUTTON]->GetButtonStatus() != _BUTTON_STATUS_DISABLED)
3406                                                 {
3407                                                         __pButtonItems[RIGHT_BUTTON]->SetButtonStatus(_BUTTON_STATUS_NORMAL);
3408                                                 }
3409                                         }
3410                                 }
3411                                 else
3412                                 {
3413                                         if (__highlightedItemIndex == __itemCount)
3414                                         {
3415                                                 if (__pButtonItems[LEFT_BUTTON]->GetButtonStatus() != _BUTTON_STATUS_DISABLED)
3416                                                 {
3417                                                         __pButtonItems[LEFT_BUTTON]->SetButtonStatus(_BUTTON_STATUS_NORMAL);
3418                                                 }
3419                                         }
3420                                 }
3421                         }
3422                         else
3423                         {
3424                                 if (__pButtonItems[RIGHT_BUTTON])
3425                                 {
3426                                         if (__highlightedItemIndex == __itemCount)
3427                                         {
3428                                                 if (__pButtonItems[RIGHT_BUTTON]->GetButtonStatus() != _BUTTON_STATUS_DISABLED)
3429                                                 {
3430                                                         __pButtonItems[RIGHT_BUTTON]->SetButtonStatus(_BUTTON_STATUS_NORMAL);
3431                                                 }
3432                                         }
3433                                 }
3434                         }
3435                 }
3436
3437                 int selectedItemIndex = GetSelectedItemIndex();
3438
3439                 if(selectedItemIndex != -1 && __pItems.at(selectedItemIndex))
3440                 {
3441                         __pItems.at(selectedItemIndex)->SetButtonStatus(_BUTTON_STATUS_SELECTED, false);
3442                 }
3443         }
3444
3445         Invalidate(true);
3446
3447         return;
3448 } // OnFocusModeStateChanged
3449
3450 bool
3451 _Toolbar::OnFocusGained(const _Control& source)
3452 {
3453         if (IsFocusModeStateEnabled() == true)
3454         {
3455                 if (__header == true && __style != TOOLBAR_TEXT) // right align
3456                 {
3457                         if (__itemCount != 0)
3458                         {
3459                                 if (__style == TOOLBAR_HEADER_SEGMENTED || __style ==TOOLBAR_HEADER_SEGMENTED_WITH_TITLE || __style == TOOLBAR_SEGMENTED
3460                                                 || __style == TOOLBAR_TAB || __style == TOOLBAR_TAB_WITH_TITLE || __style == TOOLBAR_TAB_LARGE)
3461                                 {
3462                                         __highlightedItemIndex = GetSelectedItemIndex();
3463                                 }
3464                                 else // not segmented
3465                                 {
3466                                         __highlightedItemIndex = 0;
3467                                 }
3468                         }
3469
3470                         OnHeaderFocusGained(source);
3471                 }
3472                 else
3473                 {
3474                         if (__itemCount != 0)
3475                         {
3476                                 if (__style == TOOLBAR_HEADER_SEGMENTED || __style ==TOOLBAR_HEADER_SEGMENTED_WITH_TITLE || __style == TOOLBAR_SEGMENTED
3477                                                 || __style == TOOLBAR_TAB || __style == TOOLBAR_TAB_WITH_TITLE || __style == TOOLBAR_TAB_LARGE)
3478                                 {
3479                                         __highlightedItemIndex = GetSelectedItemIndex();
3480                                 }
3481                                 else // not segmented
3482                                 {
3483                                         __highlightedItemIndex = 0;
3484                                 }
3485                         }
3486
3487                         OnFooterFocusGained(source);
3488                 }
3489         }
3490
3491         Invalidate(true);
3492
3493         return true;
3494 } // OnFocusGained
3495
3496 result
3497 _Toolbar::OnHeaderFocusGained(const _Control& source)
3498 {
3499         if (__itemCount == 0)
3500         {
3501                 if (__pButtonItems[LEFT_BUTTON])
3502                 {
3503                         if (__pButtonItems[RIGHT_BUTTON])
3504                         {
3505                                 if (__highlightedItemIndex == __itemCount)
3506                                 {
3507                                         if(__pButtonItems[LEFT_BUTTON]->GetButtonStatus() != _BUTTON_STATUS_DISABLED)
3508                                         {
3509                                                 __pButtonItems[LEFT_BUTTON]->SetButtonStatus(_BUTTON_STATUS_HIGHLIGHTED, false);
3510                                                 __lastHighlightedItemIndex = __highlightedItemIndex;
3511                                                 __highlighted = true;
3512                                         }
3513                                 }
3514                                 else if (__highlightedItemIndex == __itemCount + 1)
3515                                 {
3516                                         if (__pButtonItems[RIGHT_BUTTON])
3517                                         {
3518                                                 if(__pButtonItems[RIGHT_BUTTON]->GetButtonStatus() != _BUTTON_STATUS_DISABLED)
3519                                                 {
3520                                                         __pButtonItems[RIGHT_BUTTON]->SetButtonStatus(_BUTTON_STATUS_HIGHLIGHTED, false);
3521                                                         __lastHighlightedItemIndex = __highlightedItemIndex;
3522                                                         __highlighted = true;
3523                                                 }
3524                                         }
3525                                 }
3526                         }
3527                         else
3528                         {
3529                                 if (__highlightedItemIndex == __itemCount)
3530                                 {
3531                                         if(__pButtonItems[LEFT_BUTTON]->GetButtonStatus() != _BUTTON_STATUS_DISABLED)
3532                                         {
3533                                                 __pButtonItems[LEFT_BUTTON]->SetButtonStatus(_BUTTON_STATUS_HIGHLIGHTED, false);
3534                                                 __lastHighlightedItemIndex = __highlightedItemIndex;
3535                                                 __highlighted = true;
3536                                         }
3537                                 }
3538                         }
3539                 }
3540                 else
3541                 {
3542                         if (__pButtonItems[RIGHT_BUTTON])
3543                         {
3544                                 if (__highlightedItemIndex == __itemCount)
3545                                 {
3546                                         if(__pButtonItems[RIGHT_BUTTON]->GetButtonStatus() != _BUTTON_STATUS_DISABLED)
3547                                         {
3548                                                 __pButtonItems[RIGHT_BUTTON]->SetButtonStatus(_BUTTON_STATUS_HIGHLIGHTED, false);
3549                                                 __lastHighlightedItemIndex = __highlightedItemIndex;
3550                                                 __highlighted = true;
3551                                         }
3552                                 }
3553                         }
3554                 }
3555         }
3556         else // itemCount != 0
3557         {
3558                 if (__pItems.at(__highlightedItemIndex))
3559                 {
3560                         if (__pItems.at(__highlightedItemIndex)->GetButtonStatus() != _BUTTON_STATUS_DISABLED)
3561                         {
3562                                 __pItems.at(__highlightedItemIndex)->SetButtonStatus(_BUTTON_STATUS_HIGHLIGHTED, false);
3563
3564                                 __lastHighlightedItemIndex = __highlightedItemIndex;
3565                                 __highlighted = true;
3566                         }
3567                         else
3568                         {
3569                                 if (__highlightedItemIndex < __itemCount - 1)
3570                                 {
3571                                         __highlightedItemIndex++;
3572
3573                                         OnHeaderFocusGained(source);
3574                                 }
3575                                 else if (__highlightedItemIndex == __itemCount - 1)
3576                                 {
3577                                         if (__pButtonItems[LEFT_BUTTON])
3578                                         {
3579                                                 if(__pButtonItems[LEFT_BUTTON]->GetButtonStatus() != _BUTTON_STATUS_DISABLED)
3580                                                 {
3581                                                         __pButtonItems[LEFT_BUTTON]->SetButtonStatus(_BUTTON_STATUS_HIGHLIGHTED, false);
3582
3583                                                         __highlightedItemIndex = __itemCount;
3584                                                         __lastHighlightedItemIndex = __highlightedItemIndex;
3585                                                         __highlighted = true;
3586                                                 }
3587                                                 else
3588                                                 {
3589                                                         if (__pButtonItems[RIGHT_BUTTON])
3590                                                         {
3591                                                                 if(__pButtonItems[RIGHT_BUTTON]->GetButtonStatus() != _BUTTON_STATUS_DISABLED)
3592                                                                 {
3593                                                                         __pButtonItems[RIGHT_BUTTON]->SetButtonStatus(_BUTTON_STATUS_HIGHLIGHTED, false);
3594
3595                                                                         __highlightedItemIndex = __itemCount + 1;
3596                                                                         __lastHighlightedItemIndex = __highlightedItemIndex;
3597                                                                         __highlighted = true;
3598                                                                 }
3599                                                         }
3600                                                 }
3601                                         }
3602                                         else if (__pButtonItems[RIGHT_BUTTON])
3603                                         {
3604                                                 if(__pButtonItems[RIGHT_BUTTON]->GetButtonStatus() != _BUTTON_STATUS_DISABLED)
3605                                                 {
3606                                                         __pButtonItems[RIGHT_BUTTON]->SetButtonStatus(_BUTTON_STATUS_HIGHLIGHTED, false);
3607
3608                                                         __highlightedItemIndex = __itemCount;
3609                                                         __lastHighlightedItemIndex = __highlightedItemIndex;
3610                                                         __highlighted = true;
3611                                                 }
3612                                         }
3613                                 }
3614                         }
3615                 }
3616         }
3617
3618         return E_SUCCESS;
3619 }
3620
3621 result
3622 _Toolbar::OnFooterFocusGained(const _Control& source)
3623 {
3624         if (__itemCount == 0)
3625         {
3626                 if (__pButtonItems[LEFT_BUTTON])
3627                 {
3628                         if(__pButtonItems[LEFT_BUTTON]->GetButtonStatus() != _BUTTON_STATUS_DISABLED)
3629                         {
3630                                 __pButtonItems[LEFT_BUTTON]->SetButtonStatus(_BUTTON_STATUS_HIGHLIGHTED, false);
3631
3632                                 __highlightedItemIndex = __itemCount;
3633                                 __lastHighlightedItemIndex = __highlightedItemIndex;
3634                                 __highlighted = true;
3635                         }
3636                         else
3637                         {
3638                                 if (__pButtonItems[RIGHT_BUTTON])
3639                                 {
3640                                         if(__pButtonItems[RIGHT_BUTTON]->GetButtonStatus() != _BUTTON_STATUS_DISABLED)
3641                                         {
3642                                                 __pButtonItems[RIGHT_BUTTON]->SetButtonStatus(_BUTTON_STATUS_HIGHLIGHTED, false);
3643
3644                                                 __highlightedItemIndex = __itemCount + 1;
3645                                                 __lastHighlightedItemIndex = __highlightedItemIndex;
3646                                                 __highlighted = true;
3647                                         }
3648                                 }
3649                         }
3650                 }
3651                 else if (__pButtonItems[RIGHT_BUTTON])
3652                 {
3653                         if(__pButtonItems[RIGHT_BUTTON]->GetButtonStatus() != _BUTTON_STATUS_DISABLED)
3654                         {
3655                                 __pButtonItems[RIGHT_BUTTON]->SetButtonStatus(_BUTTON_STATUS_HIGHLIGHTED, false);
3656
3657                                 __highlightedItemIndex = __itemCount;
3658                                 __lastHighlightedItemIndex = __highlightedItemIndex;
3659                                 __highlighted = true;
3660                         }
3661                 }
3662         }
3663         else // itemCount != 0
3664         {
3665                 if (__style == TOOLBAR_HEADER_SEGMENTED || __style ==TOOLBAR_HEADER_SEGMENTED_WITH_TITLE || __style == TOOLBAR_SEGMENTED
3666                                 || __style == TOOLBAR_TAB || __style == TOOLBAR_TAB_WITH_TITLE || __style == TOOLBAR_TAB_LARGE)
3667                 {
3668                         __highlightedItemIndex = GetSelectedItemIndex();
3669
3670                         if (__pItems.at(__highlightedItemIndex))
3671                         {
3672                                 __pItems.at(__highlightedItemIndex)->SetButtonStatus(_BUTTON_STATUS_HIGHLIGHTED, false);
3673
3674                                 __lastHighlightedItemIndex = __highlightedItemIndex;
3675                                 __highlighted = true;
3676                         }
3677                 }
3678                 else // not segmented
3679                 {
3680                         if (__pButtonItems[LEFT_BUTTON])
3681                         {
3682                                 if(__pButtonItems[LEFT_BUTTON]->GetButtonStatus() != _BUTTON_STATUS_DISABLED)
3683                                 {
3684                                         __pButtonItems[LEFT_BUTTON]->SetButtonStatus(_BUTTON_STATUS_HIGHLIGHTED, false);
3685
3686                                         __highlightedItemIndex = __itemCount;
3687                                         __lastHighlightedItemIndex = __highlightedItemIndex;
3688                                         __highlighted = true;
3689                                 }
3690                                 else
3691                                 {
3692                                         if (__pItems.at(__highlightedItemIndex))
3693                                         {
3694                                                 if (__pItems.at(__highlightedItemIndex)->GetButtonStatus() != _BUTTON_STATUS_DISABLED)
3695                                                 {
3696                                                         __pItems.at(__highlightedItemIndex)->SetButtonStatus(_BUTTON_STATUS_HIGHLIGHTED, false);
3697
3698                                                         __lastHighlightedItemIndex = __highlightedItemIndex;
3699                                                         __highlighted = true;
3700                                                 }
3701                                                 else
3702                                                 {
3703                                                         for (__highlightedItemIndex = 0; __highlightedItemIndex < __itemCount; __highlightedItemIndex++)
3704                                                         {
3705                                                                 if (__pItems.at(__highlightedItemIndex)->GetButtonStatus() != _BUTTON_STATUS_DISABLED)
3706                                                                 {
3707                                                                         __pItems.at(__highlightedItemIndex)->SetButtonStatus(_BUTTON_STATUS_HIGHLIGHTED, false);
3708
3709                                                                         __lastHighlightedItemIndex = __highlightedItemIndex;
3710                                                                         __highlighted = true;
3711
3712                                                                         break;
3713                                                                 }
3714                                                         }
3715
3716                                                         if (__highlightedItemIndex == __itemCount)
3717                                                         {
3718                                                                 if (__pButtonItems[RIGHT_BUTTON])
3719                                                                 {
3720                                                                         if(__pButtonItems[RIGHT_BUTTON]->GetButtonStatus() != _BUTTON_STATUS_DISABLED)
3721                                                                         {
3722                                                                                 __pButtonItems[RIGHT_BUTTON]->SetButtonStatus(_BUTTON_STATUS_HIGHLIGHTED, false);
3723
3724                                                                                 __highlightedItemIndex = __itemCount + 1;
3725                                                                                 __lastHighlightedItemIndex = __highlightedItemIndex;
3726                                                                                 __highlighted = true;
3727                                                                         }
3728                                                                 }
3729                                                         }
3730                                                 }
3731                                         }
3732                                 }
3733                         }
3734                         else
3735                         {
3736                                 if (__pItems.at(__highlightedItemIndex))
3737                                 {
3738                                         if (__pItems.at(__highlightedItemIndex)->GetButtonStatus() != _BUTTON_STATUS_DISABLED)
3739                                         {
3740                                                 __pItems.at(__highlightedItemIndex)->SetButtonStatus(_BUTTON_STATUS_HIGHLIGHTED, false);
3741
3742                                                 __lastHighlightedItemIndex = __highlightedItemIndex;
3743                                                 __highlighted = true;
3744                                         }
3745                                         else
3746                                         {
3747                                                 for (__highlightedItemIndex = 0; __highlightedItemIndex < __itemCount; __highlightedItemIndex++)
3748                                                 {
3749                                                         if (__pItems.at(__highlightedItemIndex)->GetButtonStatus() != _BUTTON_STATUS_DISABLED)
3750                                                         {
3751                                                                 __pItems.at(__highlightedItemIndex)->SetButtonStatus(_BUTTON_STATUS_HIGHLIGHTED, false);
3752
3753                                                                 __lastHighlightedItemIndex = __highlightedItemIndex;
3754                                                                 __highlighted = true;
3755
3756                                                                 break;
3757                                                         }
3758                                                 }
3759
3760                                                 if (__highlightedItemIndex == __itemCount)
3761                                                 {
3762                                                         if (__pButtonItems[RIGHT_BUTTON])
3763                                                         {
3764                                                                 if(__pButtonItems[RIGHT_BUTTON]->GetButtonStatus() != _BUTTON_STATUS_DISABLED)
3765                                                                 {
3766                                                                         __pButtonItems[RIGHT_BUTTON]->SetButtonStatus(_BUTTON_STATUS_HIGHLIGHTED, false);
3767
3768                                                                         __highlightedItemIndex = __itemCount;
3769                                                                         __lastHighlightedItemIndex = __highlightedItemIndex;
3770                                                                         __highlighted = true;
3771                                                                 }
3772                                                         }
3773                                                 }
3774                                         }
3775                                 }
3776                         }
3777                 }
3778         }
3779
3780         return E_SUCCESS;
3781 }
3782
3783 bool
3784 _Toolbar::OnFocusLost(const _Control& source)
3785 {
3786         if (__itemCount == 0)
3787         {
3788                 if (__pButtonItems[LEFT_BUTTON])
3789                 {
3790                         if (__pButtonItems[RIGHT_BUTTON])
3791                         {
3792                                 if (__highlightedItemIndex == __itemCount)
3793                                 {
3794                                         if (__pButtonItems[LEFT_BUTTON]->GetButtonStatus() != _BUTTON_STATUS_DISABLED)
3795                                         {
3796                                                 __pButtonItems[LEFT_BUTTON]->SetButtonStatus(_BUTTON_STATUS_NORMAL);
3797                                         }
3798                                 }
3799                                 else if (__highlightedItemIndex == __itemCount + 1)
3800                                 {
3801                                         if (__pButtonItems[RIGHT_BUTTON]->GetButtonStatus() != _BUTTON_STATUS_DISABLED)
3802                                         {
3803                                                 __pButtonItems[RIGHT_BUTTON]->SetButtonStatus(_BUTTON_STATUS_NORMAL);
3804                                         }
3805                                 }
3806                         }
3807                         else
3808                         {
3809                                 if (__highlightedItemIndex == __itemCount)
3810                                 {
3811                                         if (__pButtonItems[LEFT_BUTTON]->GetButtonStatus() != _BUTTON_STATUS_DISABLED)
3812                                         {
3813                                                 __pButtonItems[LEFT_BUTTON]->SetButtonStatus(_BUTTON_STATUS_NORMAL);
3814                                         }
3815                                 }
3816                         }
3817                 }
3818                 else
3819                 {
3820                         if (__pButtonItems[RIGHT_BUTTON])
3821                         {
3822                                 if (__highlightedItemIndex == __itemCount)
3823                                 {
3824                                         if (__pButtonItems[RIGHT_BUTTON]->GetButtonStatus() != _BUTTON_STATUS_DISABLED)
3825                                         {
3826                                                 __pButtonItems[RIGHT_BUTTON]->SetButtonStatus(_BUTTON_STATUS_NORMAL);
3827                                         }
3828                                 }
3829                         }
3830                 }
3831         }
3832         else // __itemCount != 0
3833         {
3834                 if (__highlightedItemIndex < __itemCount)
3835                 {
3836                         if(__pItems.at(__highlightedItemIndex))
3837                         {
3838                                 if (__pItems.at(__highlightedItemIndex)->GetButtonStatus() != _BUTTON_STATUS_DISABLED)
3839                                 {
3840                                         __pItems.at(__highlightedItemIndex)->SetButtonStatus(_BUTTON_STATUS_NORMAL);
3841                                 }
3842                         }
3843                 }
3844                 else
3845                 {
3846                         if (__pButtonItems[LEFT_BUTTON])
3847                         {
3848                                 if (__pButtonItems[RIGHT_BUTTON])
3849                                 {
3850                                         if (__highlightedItemIndex == __itemCount)
3851                                         {
3852                                                 if (__pButtonItems[LEFT_BUTTON]->GetButtonStatus() != _BUTTON_STATUS_DISABLED)
3853                                                 {
3854                                                         __pButtonItems[LEFT_BUTTON]->SetButtonStatus(_BUTTON_STATUS_NORMAL);
3855                                                 }
3856                                         }
3857                                         else if (__highlightedItemIndex == __itemCount + 1)
3858                                         {
3859                                                 if (__pButtonItems[RIGHT_BUTTON]->GetButtonStatus() != _BUTTON_STATUS_DISABLED)
3860                                                 {
3861                                                         __pButtonItems[RIGHT_BUTTON]->SetButtonStatus(_BUTTON_STATUS_NORMAL);
3862                                                 }
3863                                         }
3864                                 }
3865                                 else
3866                                 {
3867                                         if (__highlightedItemIndex == __itemCount)
3868                                         {
3869                                                 if (__pButtonItems[LEFT_BUTTON]->GetButtonStatus() != _BUTTON_STATUS_DISABLED)
3870                                                 {
3871                                                         __pButtonItems[LEFT_BUTTON]->SetButtonStatus(_BUTTON_STATUS_NORMAL);
3872                                                 }
3873                                         }
3874                                 }
3875                         }
3876                         else
3877                         {
3878                                 if (__pButtonItems[RIGHT_BUTTON])
3879                                 {
3880                                         if (__highlightedItemIndex == __itemCount)
3881                                         {
3882                                                 if (__pButtonItems[RIGHT_BUTTON]->GetButtonStatus() != _BUTTON_STATUS_DISABLED)
3883                                                 {
3884                                                         __pButtonItems[RIGHT_BUTTON]->SetButtonStatus(_BUTTON_STATUS_NORMAL);
3885                                                 }
3886                                         }
3887                                 }
3888                         }
3889                 }
3890
3891                 int selectedItemIndex = GetSelectedItemIndex();
3892
3893                 if(selectedItemIndex != -1 && __pItems.at(selectedItemIndex))
3894                 {
3895                         if (__pItems.at(selectedItemIndex)->GetButtonStatus() != _BUTTON_STATUS_DISABLED)
3896                         {
3897                                 __pItems.at(selectedItemIndex)->SetButtonStatus(_BUTTON_STATUS_SELECTED, false);
3898                         }
3899                 }
3900         }
3901
3902         Invalidate(true);
3903
3904         return true;
3905 } // OnFocusLost
3906
3907 bool
3908 _Toolbar::OnKeyReleased(const _Control& source, const _KeyInfo& keyInfo)
3909 {
3910         _KeyCode keyCode = keyInfo.GetKeyCode();
3911
3912         int selectedItemIndex  = GetSelectedItemIndex();
3913
3914         if (IsFocusModeStateEnabled() == true && keyCode == _KEY_RIGHT)
3915         {
3916                 __highlighted = false;
3917
3918                 if (__header == true && __style != TOOLBAR_TEXT) // right align
3919                 {
3920                         if (__itemCount != 0)
3921                         {
3922                                 if (__highlightedItemIndex < (__itemCount - 1)) // 0,1
3923                                 {
3924                                         if (__pItems.at(__highlightedItemIndex) != null)
3925                                         {
3926                                                 if (__highlightedItemIndex == selectedItemIndex)
3927                                                 {
3928                                                         if (__pItems.at(__highlightedItemIndex)->GetButtonStatus() != _BUTTON_STATUS_DISABLED)
3929                                                         {
3930                                                                 __pItems.at(__highlightedItemIndex)->SetButtonStatus(_BUTTON_STATUS_SELECTED, false);
3931                                                         }
3932                                                 }
3933                                                 else
3934                                                 {
3935                                                         if (__pItems.at(__highlightedItemIndex)->GetButtonStatus() != _BUTTON_STATUS_DISABLED)
3936                                                         {
3937                                                                 __pItems.at(__highlightedItemIndex)->SetButtonStatus(_BUTTON_STATUS_NORMAL);
3938                                                         }
3939                                                 }
3940
3941                                                 __highlightedItemIndex++;
3942
3943                                                 if (__pItems.at(__highlightedItemIndex)->GetButtonStatus() != _BUTTON_STATUS_DISABLED)
3944                                                 {
3945                                                         __pItems.at(__highlightedItemIndex)->SetButtonStatus(_BUTTON_STATUS_HIGHLIGHTED, false);
3946
3947                                                         __lastHighlightedItemIndex = __highlightedItemIndex;
3948                                                         __highlighted = true;
3949
3950                                                         if (__highlightedItemIndex - __pToolbarPresenter->GetFirstLoadedItemIndex() == SEGMENTED_ITEM_MAX)
3951                                                         {
3952                                                                 if (__style == TOOLBAR_TAB || __style == TOOLBAR_TAB_WITH_TITLE || __style == TOOLBAR_TAB_LARGE)
3953                                                                 {
3954                                                                         __pToolbarPresenter->SetItemFit(__highlightedItemIndex - (SEGMENTED_ITEM_MAX - 1));
3955                                                                 }
3956                                                         }
3957                                                 }
3958                                                 else
3959                                                 {
3960                                                         OnKeyReleased(source, keyInfo);
3961                                                 }
3962                                         }
3963                                 }
3964                                 else // 2, L, R, B,
3965                                 {
3966                                         if (__pButtonItems[LEFT_BUTTON] || __pButtonItems[RIGHT_BUTTON])
3967                                         {
3968                                                 if (__highlightedItemIndex == __itemCount - 1)
3969                                                 {
3970                                                         if (__pItems.at(__highlightedItemIndex) != null)
3971                                                         {
3972                                                                 if (__highlightedItemIndex == selectedItemIndex)
3973                                                                 {
3974                                                                         if (__pItems.at(__highlightedItemIndex)->GetButtonStatus() != _BUTTON_STATUS_DISABLED)
3975                                                                         {
3976                                                                                 __pItems.at(__highlightedItemIndex)->SetButtonStatus(_BUTTON_STATUS_SELECTED, false);
3977                                                                         }
3978                                                                 }
3979                                                                 else
3980                                                                 {
3981                                                                         if (__pItems.at(__highlightedItemIndex)->GetButtonStatus() != _BUTTON_STATUS_DISABLED)
3982                                                                         {
3983                                                                                 __pItems.at(__highlightedItemIndex)->SetButtonStatus(_BUTTON_STATUS_NORMAL);
3984                                                                         }
3985                                                                 }
3986                                                         }
3987                                                 }
3988                                         }
3989
3990                                         if (__pButtonItems[LEFT_BUTTON])
3991                                         {
3992                                                 if (__pButtonItems[RIGHT_BUTTON])
3993                                                 {
3994                                                         if (__highlightedItemIndex == __itemCount - 1)
3995                                                         {
3996                                                                 __highlightedItemIndex++;
3997
3998                                                                 if (__pButtonItems[LEFT_BUTTON]->GetButtonStatus() != _BUTTON_STATUS_DISABLED)
3999                                                                 {
4000                                                                         __pButtonItems[LEFT_BUTTON]->SetButtonStatus(_BUTTON_STATUS_HIGHLIGHTED, false);
4001
4002                                                                         __lastHighlightedItemIndex = __highlightedItemIndex;
4003                                                                         __highlighted = true;
4004                                                                 }
4005                                                                 else
4006                                                                 {
4007                                                                         OnKeyReleased(source, keyInfo);
4008                                                                 }
4009                                                         }
4010                                                         else if (__highlightedItemIndex == __itemCount)
4011                                                         {
4012                                                                 __highlightedItemIndex++;
4013
4014                                                                 if (__pButtonItems[LEFT_BUTTON]->GetButtonStatus() != _BUTTON_STATUS_DISABLED)
4015                                                                 {
4016                                                                         __pButtonItems[LEFT_BUTTON]->SetButtonStatus(_BUTTON_STATUS_NORMAL);
4017                                                                 }
4018
4019                                                                 if (__pButtonItems[RIGHT_BUTTON]->GetButtonStatus() != _BUTTON_STATUS_DISABLED)
4020                                                                 {
4021                                                                         __pButtonItems[RIGHT_BUTTON]->SetButtonStatus(_BUTTON_STATUS_HIGHLIGHTED, false);
4022
4023                                                                         __lastHighlightedItemIndex = __highlightedItemIndex;
4024                                                                         __highlighted = true;
4025                                                                 }
4026                                                                 else
4027                                                                 {
4028                                                                         OnKeyReleased(source, keyInfo);
4029                                                                 }
4030                                                         }
4031                                                 }
4032                                                 else
4033                                                 {
4034                                                         if (__highlightedItemIndex == __itemCount - 1)
4035                                                         {
4036                                                                 __highlightedItemIndex++;
4037
4038                                                                 if (__pButtonItems[LEFT_BUTTON]->GetButtonStatus() != _BUTTON_STATUS_DISABLED)
4039                                                                 {
4040                                                                         __pButtonItems[LEFT_BUTTON]->SetButtonStatus(_BUTTON_STATUS_HIGHLIGHTED, false);
4041
4042                                                                         __lastHighlightedItemIndex = __highlightedItemIndex;
4043                                                                         __highlighted = true;
4044                                                                 }
4045                                                                 else
4046                                                                 {
4047                                                                         OnKeyReleased(source, keyInfo);
4048                                                                 }
4049                                                         }
4050                                                 }
4051                                         }
4052                                         else
4053                                         {
4054                                                 if (__pButtonItems[RIGHT_BUTTON])
4055                                                 {
4056                                                         if (__highlightedItemIndex == __itemCount - 1)
4057                                                         {
4058                                                                 __highlightedItemIndex++;
4059
4060                                                                 if (__pButtonItems[RIGHT_BUTTON]->GetButtonStatus() != _BUTTON_STATUS_DISABLED)
4061                                                                 {
4062                                                                         __pButtonItems[RIGHT_BUTTON]->SetButtonStatus(_BUTTON_STATUS_HIGHLIGHTED, false);
4063
4064                                                                         __lastHighlightedItemIndex = __highlightedItemIndex;
4065                                                                         __highlighted = true;
4066                                                                 }
4067                                                                 else
4068                                                                 {
4069                                                                         OnKeyReleased(source, keyInfo);
4070                                                                 }
4071                                                         }
4072                                                 }
4073                                         }
4074                                 }
4075
4076                                 if (__highlighted == false)
4077                                 {
4078                                         __highlightedItemIndex = __lastHighlightedItemIndex;
4079
4080                                         if (__highlightedItemIndex < __itemCount)
4081                                         {
4082                                                 if (__pItems.at(__highlightedItemIndex))
4083                                                 {
4084                                                         if (__pItems.at(__highlightedItemIndex)->GetButtonStatus() != _BUTTON_STATUS_DISABLED)
4085                                                         {
4086                                                                 __pItems.at(__highlightedItemIndex)->SetButtonStatus(_BUTTON_STATUS_HIGHLIGHTED, false);
4087                                                         }
4088                                                 }
4089                                         }
4090                                         else if (__highlightedItemIndex == __itemCount)
4091                                         {
4092                                                 if (__pButtonItems[LEFT_BUTTON])
4093                                                 {
4094                                                         if (__pButtonItems[LEFT_BUTTON]->GetButtonStatus() != _BUTTON_STATUS_DISABLED)
4095                                                         {
4096                                                                 __pButtonItems[LEFT_BUTTON]->SetButtonStatus(_BUTTON_STATUS_HIGHLIGHTED, false);
4097                                                         }
4098                                                 }
4099                                                 else if (__pButtonItems[RIGHT_BUTTON])
4100                                                 {
4101                                                         if (__pButtonItems[RIGHT_BUTTON]->GetButtonStatus() != _BUTTON_STATUS_DISABLED)
4102                                                         {
4103                                                                 __pButtonItems[RIGHT_BUTTON]->SetButtonStatus(_BUTTON_STATUS_HIGHLIGHTED, false);
4104                                                         }
4105                                                 }
4106                                         }
4107                                         else if (__highlightedItemIndex == __itemCount + 1)
4108                                         {
4109                                                 if (__pButtonItems[RIGHT_BUTTON])
4110                                                 {
4111                                                         if (__pButtonItems[RIGHT_BUTTON]->GetButtonStatus() != _BUTTON_STATUS_DISABLED)
4112                                                         {
4113                                                                 __pButtonItems[RIGHT_BUTTON]->SetButtonStatus(_BUTTON_STATUS_HIGHLIGHTED, false);
4114                                                         }
4115                                                 }
4116                                         }
4117
4118                                         __highlighted = true;
4119                                 }
4120                         }
4121                         else // itemCount == 0
4122                         {
4123                                 if (__pButtonItems[LEFT_BUTTON])
4124                                 {
4125                                         if (__pButtonItems[RIGHT_BUTTON])
4126                                         {
4127                                                 if (__highlightedItemIndex == 0)
4128                                                 {
4129                                                         __highlightedItemIndex++;
4130
4131                                                         if (__pButtonItems[LEFT_BUTTON]->GetButtonStatus() != _BUTTON_STATUS_DISABLED)
4132                                                         {
4133                                                                 __pButtonItems[LEFT_BUTTON]->SetButtonStatus(_BUTTON_STATUS_NORMAL);
4134                                                         }
4135
4136                                                         if (__pButtonItems[RIGHT_BUTTON]->GetButtonStatus() != _BUTTON_STATUS_DISABLED)
4137                                                         {
4138                                                                 __pButtonItems[RIGHT_BUTTON]->SetButtonStatus(_BUTTON_STATUS_HIGHLIGHTED, false);
4139
4140                                                                 __lastHighlightedItemIndex = __highlightedItemIndex;
4141                                                                 __highlighted = true;
4142                                                         }
4143                                                         else
4144                                                         {
4145                                                                 OnKeyReleased(source, keyInfo);
4146                                                         }
4147                                                 }
4148                                         }
4149                                 }
4150
4151                                 if (__highlighted == false)
4152                                 {
4153                                         __highlightedItemIndex = __lastHighlightedItemIndex;
4154
4155                                         if (__highlightedItemIndex == __itemCount)
4156                                         {
4157                                                 if (__pButtonItems[LEFT_BUTTON])
4158                                                 {
4159                                                         if (__pButtonItems[LEFT_BUTTON]->GetButtonStatus() != _BUTTON_STATUS_DISABLED)
4160                                                         {
4161                                                                 __pButtonItems[LEFT_BUTTON]->SetButtonStatus(_BUTTON_STATUS_HIGHLIGHTED, false);
4162                                                         }
4163                                                 }
4164                                                 else if (__pButtonItems[RIGHT_BUTTON])
4165                                                 {
4166                                                         if (__pButtonItems[RIGHT_BUTTON]->GetButtonStatus() != _BUTTON_STATUS_DISABLED)
4167                                                         {
4168                                                                 __pButtonItems[RIGHT_BUTTON]->SetButtonStatus(_BUTTON_STATUS_HIGHLIGHTED, false);
4169                                                         }
4170                                                 }
4171                                         }
4172                                         else if (__highlightedItemIndex == __itemCount + 1)
4173                                         {
4174                                                 if (__pButtonItems[RIGHT_BUTTON])
4175                                                 {
4176                                                         if (__pButtonItems[RIGHT_BUTTON]->GetButtonStatus() != _BUTTON_STATUS_DISABLED)
4177                                                         {
4178                                                                 __pButtonItems[RIGHT_BUTTON]->SetButtonStatus(_BUTTON_STATUS_HIGHLIGHTED, false);
4179                                                         }
4180                                                 }
4181                                         }
4182
4183                                         __highlighted = true;
4184                                 }
4185                         }
4186                 }
4187                 else // footer // right key
4188                 {
4189                         if (__itemCount != 0)
4190                         {
4191                                 if (__pButtonItems[LEFT_BUTTON])
4192                                 {
4193                                         if (__pButtonItems[RIGHT_BUTTON]) // L Item  R
4194                                         {
4195                                                 if (__highlightedItemIndex == __itemCount)
4196                                                 {
4197                                                         if (__pButtonItems[LEFT_BUTTON]->GetButtonStatus() != _BUTTON_STATUS_DISABLED)
4198                                                         {
4199                                                                 __pButtonItems[LEFT_BUTTON]->SetButtonStatus(_BUTTON_STATUS_NORMAL);
4200                                                         }
4201
4202                                                         __highlightedItemIndex = 0;
4203
4204                                                         if (__pItems.at(__highlightedItemIndex)->GetButtonStatus() != _BUTTON_STATUS_DISABLED)
4205                                                         {
4206                                                                 __pItems.at(__highlightedItemIndex)->SetButtonStatus(_BUTTON_STATUS_HIGHLIGHTED, false);
4207
4208                                                                 __lastHighlightedItemIndex = __highlightedItemIndex;
4209                                                                 __highlighted = true;
4210                                                         }
4211                                                         else
4212                                                         {
4213                                                                 OnKeyReleased(source, keyInfo);
4214                                                         }
4215                                                 }
4216                                                 else if (__highlightedItemIndex < __itemCount - 1)
4217                                                 {
4218                                                         if (__highlightedItemIndex == selectedItemIndex)
4219                                                         {
4220                                                                 if (__pItems.at(__highlightedItemIndex)->GetButtonStatus() != _BUTTON_STATUS_DISABLED)
4221                                                                 {
4222                                                                         __pItems.at(__highlightedItemIndex)->SetButtonStatus(_BUTTON_STATUS_SELECTED, false);
4223                                                                 }
4224                                                         }
4225                                                         else
4226                                                         {
4227                                                                 if (__pItems.at(__highlightedItemIndex)->GetButtonStatus() != _BUTTON_STATUS_DISABLED)
4228                                                                 {
4229                                                                         __pItems.at(__highlightedItemIndex)->SetButtonStatus(_BUTTON_STATUS_NORMAL);
4230                                                                 }
4231                                                         }
4232
4233                                                         __highlightedItemIndex++;
4234
4235                                                         if (__pItems.at(__highlightedItemIndex)->GetButtonStatus() != _BUTTON_STATUS_DISABLED)
4236                                                         {
4237                                                                 __pItems.at(__highlightedItemIndex)->SetButtonStatus(_BUTTON_STATUS_HIGHLIGHTED, false);
4238
4239                                                                 __lastHighlightedItemIndex = __highlightedItemIndex;
4240                                                                 __highlighted = true;
4241                                                         }
4242                                                         else
4243                                                         {
4244                                                                 OnKeyReleased(source, keyInfo);
4245                                                         }
4246                                                 }
4247                                                 else if (__highlightedItemIndex == __itemCount -1)
4248                                                 {
4249                                                         if (__highlightedItemIndex == selectedItemIndex)
4250                                                         {
4251                                                                 if (__pItems.at(__highlightedItemIndex)->GetButtonStatus() != _BUTTON_STATUS_DISABLED)
4252                                                                 {
4253                                                                         __pItems.at(__highlightedItemIndex)->SetButtonStatus(_BUTTON_STATUS_SELECTED, false);
4254                                                                 }
4255                                                         }
4256                                                         else
4257                                                         {
4258                                                                 if (__pItems.at(__highlightedItemIndex)->GetButtonStatus() != _BUTTON_STATUS_DISABLED)
4259                                                                 {
4260                                                                         __pItems.at(__highlightedItemIndex)->SetButtonStatus(_BUTTON_STATUS_NORMAL);
4261                                                                 }
4262                                                         }
4263
4264                                                         __highlightedItemIndex = __itemCount + 1;
4265
4266                                                         if (__pButtonItems[RIGHT_BUTTON])
4267                                                         {
4268                                                                 if (__pButtonItems[RIGHT_BUTTON]->GetButtonStatus() != _BUTTON_STATUS_DISABLED)
4269                                                                 {
4270                                                                         __pButtonItems[RIGHT_BUTTON]->SetButtonStatus(_BUTTON_STATUS_HIGHLIGHTED, false);
4271
4272                                                                         __lastHighlightedItemIndex = __highlightedItemIndex;
4273                                                                         __highlighted = true;
4274                                                                 }
4275                                                                 else
4276                                                                 {
4277                                                                         OnKeyReleased(source, keyInfo);
4278                                                                 }
4279                                                         }
4280                                                 }
4281                                         }
4282                                         else  // L, M  Item
4283                                         {
4284                                                 if (__highlightedItemIndex == __itemCount)
4285                                                 {
4286                                                         if (__pButtonItems[LEFT_BUTTON]->GetButtonStatus() != _BUTTON_STATUS_DISABLED)
4287                                                         {
4288                                                                 __pButtonItems[LEFT_BUTTON]->SetButtonStatus(_BUTTON_STATUS_NORMAL);
4289                                                         }
4290
4291                                                         __highlightedItemIndex = 0;
4292
4293                                                         if (__pItems.at(__highlightedItemIndex)->GetButtonStatus() != _BUTTON_STATUS_DISABLED)
4294                                                         {
4295                                                                 __pItems.at(__highlightedItemIndex)->SetButtonStatus(_BUTTON_STATUS_HIGHLIGHTED, false);
4296
4297                                                                 __lastHighlightedItemIndex = __highlightedItemIndex;
4298                                                                 __highlighted = true;
4299                                                         }
4300                                                         else
4301                                                         {
4302                                                                 OnKeyReleased(source, keyInfo);
4303                                                         }
4304                                                 }
4305                                                 else if (__highlightedItemIndex < __itemCount - 1)
4306                                                 {
4307                                                         if (__highlightedItemIndex == selectedItemIndex)
4308                                                         {
4309                                                                 if (__pItems.at(__highlightedItemIndex)->GetButtonStatus() != _BUTTON_STATUS_DISABLED)
4310                                                                 {
4311                                                                         __pItems.at(__highlightedItemIndex)->SetButtonStatus(_BUTTON_STATUS_SELECTED, false);
4312                                                                 }
4313                                                         }
4314                                                         else
4315                                                         {
4316                                                                 if (__pItems.at(__highlightedItemIndex)->GetButtonStatus() != _BUTTON_STATUS_DISABLED)
4317                                                                 {
4318                                                                         __pItems.at(__highlightedItemIndex)->SetButtonStatus(_BUTTON_STATUS_NORMAL);
4319                                                                 }
4320                                                         }
4321
4322                                                         __highlightedItemIndex++;
4323
4324                                                         if (__pItems.at(__highlightedItemIndex)->GetButtonStatus() != _BUTTON_STATUS_DISABLED)
4325                                                         {
4326                                                                 __pItems.at(__highlightedItemIndex)->SetButtonStatus(_BUTTON_STATUS_HIGHLIGHTED, false);
4327
4328                                                                 __lastHighlightedItemIndex = __highlightedItemIndex;
4329                                                                 __highlighted = true;
4330                                                         }
4331                                                         else
4332                                                         {
4333                                                                 OnKeyReleased(source, keyInfo);
4334                                                         }
4335                                                 }
4336                                         }
4337                                 }
4338                                 else // L is null
4339                                 {
4340                                         if (__pButtonItems[RIGHT_BUTTON]) // Item  R, B
4341                                         {
4342                                                 if (__highlightedItemIndex < __itemCount - 1)
4343                                                 {
4344                                                         if (__highlightedItemIndex == selectedItemIndex)
4345                                                         {
4346                                                                 if (__pItems.at(__highlightedItemIndex)->GetButtonStatus() != _BUTTON_STATUS_DISABLED)
4347                                                                 {
4348                                                                         __pItems.at(__highlightedItemIndex)->SetButtonStatus(_BUTTON_STATUS_SELECTED, false);
4349                                                                 }
4350                                                         }
4351                                                         else
4352                                                         {
4353                                                                 if (__pItems.at(__highlightedItemIndex)->GetButtonStatus() != _BUTTON_STATUS_DISABLED)
4354                                                                 {
4355                                                                         __pItems.at(__highlightedItemIndex)->SetButtonStatus(_BUTTON_STATUS_NORMAL);
4356                                                                 }
4357                                                         }
4358
4359                                                         __highlightedItemIndex++;
4360
4361                                                         if (__pItems.at(__highlightedItemIndex)->GetButtonStatus() != _BUTTON_STATUS_DISABLED)
4362                                                         {
4363                                                                 __pItems.at(__highlightedItemIndex)->SetButtonStatus(_BUTTON_STATUS_HIGHLIGHTED, false);
4364
4365                                                                 __lastHighlightedItemIndex = __highlightedItemIndex;
4366                                                                 __highlighted = true;
4367                                                         }
4368                                                         else
4369                                                         {
4370                                                                 OnKeyReleased(source, keyInfo);
4371                                                         }
4372                                                 }
4373                                                 else if (__highlightedItemIndex == __itemCount -1)
4374                                                 {
4375                                                         if (__highlightedItemIndex == selectedItemIndex)
4376                                                         {
4377                                                                 if (__pItems.at(__highlightedItemIndex)->GetButtonStatus() != _BUTTON_STATUS_DISABLED)
4378                                                                 {
4379                                                                         __pItems.at(__highlightedItemIndex)->SetButtonStatus(_BUTTON_STATUS_SELECTED, false);
4380                                                                 }
4381                                                         }
4382                                                         else
4383                                                         {
4384                                                                 if (__pItems.at(__highlightedItemIndex)->GetButtonStatus() != _BUTTON_STATUS_DISABLED)
4385                                                                 {
4386                                                                         __pItems.at(__highlightedItemIndex)->SetButtonStatus(_BUTTON_STATUS_NORMAL);
4387                                                                 }
4388                                                         }
4389
4390                                                         __highlightedItemIndex++;
4391
4392                                                         if (__pButtonItems[RIGHT_BUTTON])
4393                                                         {
4394                                                                 if (__pButtonItems[RIGHT_BUTTON]->GetButtonStatus() != _BUTTON_STATUS_DISABLED)
4395                                                                 {
4396                                                                         __pButtonItems[RIGHT_BUTTON]->SetButtonStatus(_BUTTON_STATUS_HIGHLIGHTED, false);
4397
4398                                                                         __lastHighlightedItemIndex = __highlightedItemIndex;
4399                                                                         __highlighted = true;
4400                                                                 }
4401                                                                 else
4402                                                                 {
4403                                                                         OnKeyReleased(source, keyInfo);
4404                                                                 }
4405                                                         }
4406                                                 }
4407                                         }
4408                                         else  // Item
4409                                         {
4410                                                 if (__highlightedItemIndex < __itemCount - 1)
4411                                                 {
4412                                                         if (__highlightedItemIndex == selectedItemIndex)
4413                                                         {
4414                                                                 if (__pItems.at(__highlightedItemIndex)->GetButtonStatus() != _BUTTON_STATUS_DISABLED)
4415                                                                 {
4416                                                                         __pItems.at(__highlightedItemIndex)->SetButtonStatus(_BUTTON_STATUS_SELECTED, false);
4417                                                                 }
4418                                                         }
4419                                                         else
4420                                                         {
4421                                                                 if (__pItems.at(__highlightedItemIndex)->GetButtonStatus() != _BUTTON_STATUS_DISABLED)
4422                                                                 {
4423                                                                         __pItems.at(__highlightedItemIndex)->SetButtonStatus(_BUTTON_STATUS_NORMAL);
4424                                                                 }
4425                                                         }
4426
4427                                                         __highlightedItemIndex++;
4428
4429                                                         if (__pItems.at(__highlightedItemIndex)->GetButtonStatus() != _BUTTON_STATUS_DISABLED)
4430                                                         {
4431                                                                 __pItems.at(__highlightedItemIndex)->SetButtonStatus(_BUTTON_STATUS_HIGHLIGHTED, false);
4432
4433                                                                 __lastHighlightedItemIndex = __highlightedItemIndex;
4434                                                                 __highlighted = true;
4435
4436                                                                 if (__highlightedItemIndex - __pToolbarPresenter->GetFirstLoadedItemIndex() == SEGMENTED_ITEM_MAX)
4437                                                                 {
4438                                                                         if (__style == TOOLBAR_TAB || __style == TOOLBAR_TAB_WITH_TITLE || __style == TOOLBAR_TAB_LARGE)
4439                                                                         {
4440                                                                                 __pToolbarPresenter->SetItemFit(__highlightedItemIndex - (SEGMENTED_ITEM_MAX - 1));
4441                                                                         }
4442                                                                 }
4443                                                         }
4444                                                         else
4445                                                         {
4446                                                                 OnKeyReleased(source, keyInfo);
4447                                                         }
4448                                                 }
4449                                         }
4450                                 }
4451
4452                                 if (__highlighted == false)
4453                                 {
4454                                         __highlightedItemIndex = __lastHighlightedItemIndex;
4455
4456                                         if (__highlightedItemIndex < __itemCount)
4457                                         {
4458                                                 if (__pItems.at(__highlightedItemIndex))
4459                                                 {
4460                                                         if (__pItems.at(__highlightedItemIndex)->GetButtonStatus() != _BUTTON_STATUS_DISABLED)
4461                                                         {
4462                                                                 __pItems.at(__highlightedItemIndex)->SetButtonStatus(_BUTTON_STATUS_HIGHLIGHTED, false);
4463                                                         }
4464                                                 }
4465                                         }
4466                                         else if (__highlightedItemIndex == __itemCount)
4467                                         {
4468                                                 if (__pButtonItems[LEFT_BUTTON])
4469                                                 {
4470                                                         if (__pButtonItems[LEFT_BUTTON]->GetButtonStatus() != _BUTTON_STATUS_DISABLED)
4471                                                         {
4472                                                                 __pButtonItems[LEFT_BUTTON]->SetButtonStatus(_BUTTON_STATUS_HIGHLIGHTED, false);
4473                                                         }
4474                                                 }
4475                                                 else if (__pButtonItems[RIGHT_BUTTON])
4476                                                 {
4477                                                         if (__pButtonItems[RIGHT_BUTTON]->GetButtonStatus() != _BUTTON_STATUS_DISABLED)
4478                                                         {
4479                                                                 __pButtonItems[RIGHT_BUTTON]->SetButtonStatus(_BUTTON_STATUS_HIGHLIGHTED, false);
4480                                                         }
4481                                                 }
4482                                         }
4483                                         else if (__highlightedItemIndex == __itemCount + 1)
4484                                         {
4485                                                 if (__pButtonItems[RIGHT_BUTTON])
4486                                                 {
4487                                                         if (__pButtonItems[RIGHT_BUTTON]->GetButtonStatus() != _BUTTON_STATUS_DISABLED)
4488                                                         {
4489                                                                 __pButtonItems[RIGHT_BUTTON]->SetButtonStatus(_BUTTON_STATUS_HIGHLIGHTED, false);
4490                                                         }
4491                                                 }
4492                                         }
4493
4494                                         __highlighted = true;
4495                                 }
4496                         }
4497                         else // __itemCount = 0
4498                         {
4499                                 if (__pButtonItems[LEFT_BUTTON])
4500                                 {
4501                                         if (__pButtonItems[RIGHT_BUTTON])
4502                                         {
4503                                                 if (__highlightedItemIndex == 0)
4504                                                 {
4505                                                         __highlightedItemIndex++;
4506
4507                                                         if (__pButtonItems[LEFT_BUTTON])
4508                                                         {
4509                                                                 if (__pButtonItems[LEFT_BUTTON]->GetButtonStatus() != _BUTTON_STATUS_DISABLED)
4510                                                                 {
4511                                                                         __pButtonItems[LEFT_BUTTON]->SetButtonStatus(_BUTTON_STATUS_NORMAL);
4512                                                                 }
4513                                                         }
4514
4515                                                         if (__pButtonItems[RIGHT_BUTTON])
4516                                                         {
4517                                                                 if (__pButtonItems[RIGHT_BUTTON]->GetButtonStatus() != _BUTTON_STATUS_DISABLED)
4518                                                                 {
4519                                                                         __pButtonItems[RIGHT_BUTTON]->SetButtonStatus(_BUTTON_STATUS_HIGHLIGHTED, false);
4520
4521                                                                         __lastHighlightedItemIndex = __highlightedItemIndex;
4522                                                                         __highlighted = true;
4523                                                                 }
4524                                                                 else
4525                                                                 {
4526                                                                         OnKeyReleased(source, keyInfo);
4527                                                                 }
4528                                                         }
4529                                                 }
4530                                         }
4531                                 }
4532
4533                                 if (__highlighted == false)
4534                                 {
4535                                         __highlightedItemIndex = __lastHighlightedItemIndex;
4536
4537                                         if (__highlightedItemIndex == __itemCount)
4538                                         {
4539                                                 if (__pButtonItems[LEFT_BUTTON])
4540                                                 {
4541                                                         if (__pButtonItems[LEFT_BUTTON]->GetButtonStatus() != _BUTTON_STATUS_DISABLED)
4542                                                         {
4543                                                                 __pButtonItems[LEFT_BUTTON]->SetButtonStatus(_BUTTON_STATUS_HIGHLIGHTED, false);
4544                                                         }
4545                                                 }
4546                                                 else if (__pButtonItems[RIGHT_BUTTON])
4547                                                 {
4548                                                         if (__pButtonItems[RIGHT_BUTTON]->GetButtonStatus() != _BUTTON_STATUS_DISABLED)
4549                                                         {
4550                                                                 __pButtonItems[RIGHT_BUTTON]->SetButtonStatus(_BUTTON_STATUS_HIGHLIGHTED, false);
4551                                                         }
4552                                                 }
4553                                         }
4554                                         else if (__highlightedItemIndex == __itemCount + 1)
4555                                         {
4556                                                 if (__pButtonItems[RIGHT_BUTTON])
4557                                                 {
4558                                                         if (__pButtonItems[RIGHT_BUTTON]->GetButtonStatus() != _BUTTON_STATUS_DISABLED)
4559                                                         {
4560                                                                 __pButtonItems[RIGHT_BUTTON]->SetButtonStatus(_BUTTON_STATUS_HIGHLIGHTED, false);
4561                                                         }
4562                                                 }
4563                                         }
4564
4565                                         __highlighted = true;
4566                                 }
4567                         }
4568                 }
4569
4570                 Invalidate(true);
4571         }
4572         else if (IsFocusModeStateEnabled() == true && keyCode == _KEY_LEFT)
4573         {
4574                 __highlighted = false;
4575
4576                 if (__header == true && __style != TOOLBAR_TEXT) // right align
4577                 {
4578                         if (__itemCount != 0)
4579                         {
4580                                 if (__highlightedItemIndex == __itemCount + 1)
4581                                 {
4582                                         __highlightedItemIndex--;
4583
4584                                         if (__pButtonItems[RIGHT_BUTTON])
4585                                         {
4586                                                 if (__pButtonItems[RIGHT_BUTTON]->GetButtonStatus() != _BUTTON_STATUS_DISABLED)
4587                                                 {
4588                                                         __pButtonItems[RIGHT_BUTTON]->SetButtonStatus(_BUTTON_STATUS_NORMAL);
4589                                                 }
4590                                         }
4591
4592                                         if (__pButtonItems[LEFT_BUTTON]->GetButtonStatus() != _BUTTON_STATUS_DISABLED)
4593                                         {
4594                                                 __pButtonItems[LEFT_BUTTON]->SetButtonStatus(_BUTTON_STATUS_HIGHLIGHTED, false);
4595
4596                                                 __lastHighlightedItemIndex = __highlightedItemIndex;
4597                                                 __highlighted = true;
4598                                         }
4599                                         else
4600                                         {
4601                                                 OnKeyReleased(source, keyInfo);
4602                                         }
4603                                 }
4604                                 else if (__highlightedItemIndex == __itemCount)
4605                                 {
4606                                         __highlightedItemIndex--;
4607
4608                                         if (__pButtonItems[LEFT_BUTTON])
4609                                         {
4610                                                 if (__pButtonItems[LEFT_BUTTON]->GetButtonStatus() != _BUTTON_STATUS_DISABLED)
4611                                                 {
4612                                                         __pButtonItems[LEFT_BUTTON]->SetButtonStatus(_BUTTON_STATUS_NORMAL);
4613                                                 }
4614                                         }
4615                                         else if (__pButtonItems[RIGHT_BUTTON])
4616                                         {
4617                                                 if (__pButtonItems[RIGHT_BUTTON]->GetButtonStatus() != _BUTTON_STATUS_DISABLED)
4618                                                 {
4619                                                         __pButtonItems[RIGHT_BUTTON]->SetButtonStatus(_BUTTON_STATUS_NORMAL);
4620                                                 }
4621                                         }
4622
4623                                         if (__pItems.at(__highlightedItemIndex)->GetButtonStatus() != _BUTTON_STATUS_DISABLED)
4624                                         {
4625                                                 __pItems.at(__highlightedItemIndex)->SetButtonStatus(_BUTTON_STATUS_HIGHLIGHTED, false);
4626
4627                                                 __lastHighlightedItemIndex = __highlightedItemIndex;
4628                                                 __highlighted = true;
4629                                         }
4630                                         else
4631                                         {
4632                                                 OnKeyReleased(source, keyInfo);
4633                                         }
4634                                 }
4635                                 else if (__highlightedItemIndex > 0)
4636                                 {
4637                                         if (__pItems.at(__highlightedItemIndex) != null)
4638                                         {
4639                                                 if (__highlightedItemIndex == selectedItemIndex)
4640                                                 {
4641                                                         if (__pItems.at(__highlightedItemIndex)->GetButtonStatus() != _BUTTON_STATUS_DISABLED)
4642                                                         {
4643                                                                 __pItems.at(__highlightedItemIndex)->SetButtonStatus(_BUTTON_STATUS_SELECTED, false);
4644                                                         }
4645                                                 }
4646                                                 else
4647                                                 {
4648                                                         if (__pItems.at(__highlightedItemIndex)->GetButtonStatus() != _BUTTON_STATUS_DISABLED)
4649                                                         {
4650                                                                 __pItems.at(__highlightedItemIndex)->SetButtonStatus(_BUTTON_STATUS_NORMAL);
4651                                                         }
4652                                                 }
4653
4654                                                 __highlightedItemIndex--;
4655
4656                                                 if (__pItems.at(__highlightedItemIndex)->GetButtonStatus() != _BUTTON_STATUS_DISABLED)
4657                                                 {
4658                                                         __pItems.at(__highlightedItemIndex)->SetButtonStatus(_BUTTON_STATUS_HIGHLIGHTED, false);
4659
4660                                                         __lastHighlightedItemIndex = __highlightedItemIndex;
4661                                                         __highlighted = true;
4662
4663                                                         if (__pToolbarPresenter->GetFirstLoadedItemIndex() > __highlightedItemIndex)
4664                                                         {
4665                                                                 if (__style == TOOLBAR_TAB || __style == TOOLBAR_TAB_WITH_TITLE || __style == TOOLBAR_TAB_LARGE)
4666                                                                 {
4667                                                                         __pToolbarPresenter->SetItemFit(__highlightedItemIndex);
4668                                                                 }
4669                                                         }
4670                                                 }
4671                                                 else
4672                                                 {
4673                                                         OnKeyReleased(source, keyInfo);
4674                                                 }
4675                                         }
4676                                 }
4677
4678                                 if (__highlighted == false)
4679                                 {
4680                                         __highlightedItemIndex = __lastHighlightedItemIndex;
4681
4682                                         if (__highlightedItemIndex < __itemCount)
4683                                         {
4684                                                 if (__pItems.at(__highlightedItemIndex))
4685                                                 {
4686                                                         if (__pItems.at(__highlightedItemIndex)->GetButtonStatus() != _BUTTON_STATUS_DISABLED)
4687                                                         {
4688                                                                 __pItems.at(__highlightedItemIndex)->SetButtonStatus(_BUTTON_STATUS_HIGHLIGHTED, false);
4689                                                         }
4690                                                 }
4691                                         }
4692                                         else if (__highlightedItemIndex == __itemCount)
4693                                         {
4694                                                 if (__pButtonItems[LEFT_BUTTON])
4695                                                 {
4696                                                         if (__pButtonItems[LEFT_BUTTON]->GetButtonStatus() != _BUTTON_STATUS_DISABLED)
4697                                                         {
4698                                                                 __pButtonItems[LEFT_BUTTON]->SetButtonStatus(_BUTTON_STATUS_HIGHLIGHTED, false);
4699                                                         }
4700                                                 }
4701                                                 else if (__pButtonItems[RIGHT_BUTTON])
4702                                                 {
4703                                                         if (__pButtonItems[RIGHT_BUTTON]->GetButtonStatus() != _BUTTON_STATUS_DISABLED)
4704                                                         {
4705                                                                 __pButtonItems[RIGHT_BUTTON]->SetButtonStatus(_BUTTON_STATUS_HIGHLIGHTED, false);
4706                                                         }
4707                                                 }
4708                                         }
4709                                         else if (__highlightedItemIndex == __itemCount + 1)
4710                                         {
4711                                                 if (__pButtonItems[RIGHT_BUTTON])
4712                                                 {
4713                                                         if (__pButtonItems[RIGHT_BUTTON]->GetButtonStatus() != _BUTTON_STATUS_DISABLED)
4714                                                         {
4715                                                                 __pButtonItems[RIGHT_BUTTON]->SetButtonStatus(_BUTTON_STATUS_HIGHLIGHTED, false);
4716                                                         }
4717                                                 }
4718                                         }
4719
4720                                         __highlighted = true;
4721                                 }
4722                         }
4723                         else // __itemCount == 0
4724                         {
4725                                 if (__highlightedItemIndex == __itemCount + 1)
4726                                 {
4727                                         __highlightedItemIndex--;
4728
4729                                         if (__pButtonItems[RIGHT_BUTTON])
4730                                         {
4731                                                 if (__pButtonItems[RIGHT_BUTTON]->GetButtonStatus() != _BUTTON_STATUS_DISABLED)
4732                                                 {
4733                                                         __pButtonItems[RIGHT_BUTTON]->SetButtonStatus(_BUTTON_STATUS_NORMAL);
4734                                                 }
4735                                         }
4736
4737                                         if (__pButtonItems[LEFT_BUTTON]->GetButtonStatus() != _BUTTON_STATUS_DISABLED)
4738                                         {
4739                                                 __pButtonItems[LEFT_BUTTON]->SetButtonStatus(_BUTTON_STATUS_HIGHLIGHTED, false);
4740
4741                                                 __lastHighlightedItemIndex = __highlightedItemIndex;
4742                                                 __highlighted = true;
4743                                         }
4744                                         else
4745                                         {
4746                                                 OnKeyReleased(source, keyInfo);
4747                                         }
4748                                 }
4749
4750                                 if (__highlighted == false)
4751                                 {
4752                                         __highlightedItemIndex = __lastHighlightedItemIndex;
4753
4754                                         if (__highlightedItemIndex == __itemCount)
4755                                         {
4756                                                 if (__pButtonItems[LEFT_BUTTON])
4757                                                 {
4758                                                         if (__pButtonItems[LEFT_BUTTON]->GetButtonStatus() != _BUTTON_STATUS_DISABLED)
4759                                                         {
4760                                                                 __pButtonItems[LEFT_BUTTON]->SetButtonStatus(_BUTTON_STATUS_HIGHLIGHTED, false);
4761                                                         }
4762                                                 }
4763                                                 else if (__pButtonItems[RIGHT_BUTTON])
4764                                                 {
4765                                                         if (__pButtonItems[RIGHT_BUTTON]->GetButtonStatus() != _BUTTON_STATUS_DISABLED)
4766                                                         {
4767                                                                 __pButtonItems[RIGHT_BUTTON]->SetButtonStatus(_BUTTON_STATUS_HIGHLIGHTED, false);
4768                                                         }
4769                                                 }
4770                                         }
4771                                         else if (__highlightedItemIndex == __itemCount + 1)
4772                                         {
4773                                                 if (__pButtonItems[RIGHT_BUTTON])
4774                                                 {
4775                                                         if (__pButtonItems[RIGHT_BUTTON]->GetButtonStatus() != _BUTTON_STATUS_DISABLED)
4776                                                         {
4777                                                                 __pButtonItems[RIGHT_BUTTON]->SetButtonStatus(_BUTTON_STATUS_HIGHLIGHTED, false);
4778                                                         }
4779                                                 }
4780                                         }
4781
4782                                         __highlighted = true;
4783                                 }
4784                         }
4785                 }
4786                 else // footer << leftkey
4787                 {
4788                         if (__itemCount != 0)
4789                         {
4790                                 if (__pButtonItems[LEFT_BUTTON])
4791                                 {
4792                                         if (__pButtonItems[RIGHT_BUTTON]) // L  Item  R
4793                                         {
4794                                                 if (__highlightedItemIndex == 0)
4795                                                 {
4796                                                         if (__highlightedItemIndex == selectedItemIndex)
4797                                                         {
4798                                                                 if (__pItems.at(__highlightedItemIndex)->GetButtonStatus() != _BUTTON_STATUS_DISABLED)
4799                                                                 {
4800                                                                         __pItems.at(__highlightedItemIndex)->SetButtonStatus(_BUTTON_STATUS_SELECTED, false);
4801                                                                 }
4802                                                         }
4803                                                         else
4804                                                         {
4805                                                                 if (__pItems.at(__highlightedItemIndex)->GetButtonStatus() != _BUTTON_STATUS_DISABLED)
4806                                                                 {
4807                                                                         __pItems.at(__highlightedItemIndex)->SetButtonStatus(_BUTTON_STATUS_NORMAL);
4808                                                                 }
4809                                                         }
4810
4811                                                         __highlightedItemIndex = __itemCount;
4812
4813                                                         if (__pButtonItems[LEFT_BUTTON])
4814                                                         {
4815                                                                 if (__pButtonItems[LEFT_BUTTON]->GetButtonStatus() != _BUTTON_STATUS_DISABLED)
4816                                                                 {
4817                                                                         __pButtonItems[LEFT_BUTTON]->SetButtonStatus(_BUTTON_STATUS_HIGHLIGHTED, false);
4818
4819                                                                         __lastHighlightedItemIndex = __highlightedItemIndex;
4820                                                                         __highlighted = true;
4821                                                                 }
4822                                                                 else
4823                                                                 {
4824                                                                         //empty
4825                                                                 }
4826                                                         }
4827                                                 }
4828                                                 else if (__highlightedItemIndex < __itemCount)
4829                                                 {
4830                                                         if (__highlightedItemIndex == selectedItemIndex)
4831                                                         {
4832                                                                 if (__pItems.at(__highlightedItemIndex)->GetButtonStatus() != _BUTTON_STATUS_DISABLED)
4833                                                                 {
4834                                                                         __pItems.at(__highlightedItemIndex)->SetButtonStatus(_BUTTON_STATUS_SELECTED, false);
4835                                                                 }
4836                                                         }
4837                                                         else
4838                                                         {
4839                                                                 if (__pItems.at(__highlightedItemIndex)->GetButtonStatus() != _BUTTON_STATUS_DISABLED)
4840                                                                 {
4841                                                                         __pItems.at(__highlightedItemIndex)->SetButtonStatus(_BUTTON_STATUS_NORMAL);
4842                                                                 }
4843                                                         }
4844
4845                                                         __highlightedItemIndex--;
4846
4847                                                         if (__pItems.at(__highlightedItemIndex)->GetButtonStatus() != _BUTTON_STATUS_DISABLED)
4848                                                         {
4849                                                                 __pItems.at(__highlightedItemIndex)->SetButtonStatus(_BUTTON_STATUS_HIGHLIGHTED, false);
4850
4851                                                                 __lastHighlightedItemIndex = __highlightedItemIndex;
4852                                                                 __highlighted = true;
4853                                                         }
4854                                                         else
4855                                                         {
4856                                                                 OnKeyReleased(source, keyInfo);
4857                                                         }
4858                                                 }
4859                                                 else if (__highlightedItemIndex == __itemCount + 1)
4860                                                 {
4861                                                         if (__pButtonItems[RIGHT_BUTTON])
4862                                                         {
4863                                                                 if (__pButtonItems[RIGHT_BUTTON]->GetButtonStatus() != _BUTTON_STATUS_DISABLED)
4864                                                                 {
4865                                                                         __pButtonItems[RIGHT_BUTTON]->SetButtonStatus(_BUTTON_STATUS_NORMAL);
4866                                                                 }
4867                                                         }
4868
4869                                                         __highlightedItemIndex = __itemCount - 1;
4870
4871                                                         if (__pItems.at(__highlightedItemIndex)->GetButtonStatus() != _BUTTON_STATUS_DISABLED)
4872                                                         {
4873                                                                 __pItems.at(__highlightedItemIndex)->SetButtonStatus(_BUTTON_STATUS_HIGHLIGHTED, false);
4874
4875                                                                 __lastHighlightedItemIndex = __highlightedItemIndex;
4876                                                                 __highlighted = true;
4877                                                         }
4878                                                         else
4879                                                         {
4880                                                                 OnKeyReleased(source, keyInfo);
4881                                                         }
4882                                                 }
4883                                         }
4884                                         else  // L, M  Item
4885                                         {
4886                                                 if (__highlightedItemIndex == 0)
4887                                                 {
4888                                                         if (__highlightedItemIndex == selectedItemIndex)
4889                                                         {
4890                                                                 if (__pItems.at(__highlightedItemIndex)->GetButtonStatus() != _BUTTON_STATUS_DISABLED)
4891                                                                 {
4892                                                                         __pItems.at(__highlightedItemIndex)->SetButtonStatus(_BUTTON_STATUS_SELECTED, false);
4893                                                                 }
4894                                                         }
4895                                                         else
4896                                                         {
4897                                                                 if (__pItems.at(__highlightedItemIndex)->GetButtonStatus() != _BUTTON_STATUS_DISABLED)
4898                                                                 {
4899                                                                         __pItems.at(__highlightedItemIndex)->SetButtonStatus(_BUTTON_STATUS_NORMAL);
4900                                                                 }
4901                                                         }
4902
4903                                                         __highlightedItemIndex = __itemCount;
4904
4905                                                         if (__pButtonItems[LEFT_BUTTON])
4906                                                         {
4907                                                                 if (__pButtonItems[LEFT_BUTTON]->GetButtonStatus() != _BUTTON_STATUS_DISABLED)
4908                                                                 {
4909                                                                         __pButtonItems[LEFT_BUTTON]->SetButtonStatus(_BUTTON_STATUS_HIGHLIGHTED, false);
4910
4911                                                                         __lastHighlightedItemIndex = __highlightedItemIndex;
4912                                                                         __highlighted = true;
4913                                                                 }
4914                                                                 else
4915                                                                 {
4916                                                                         //empty
4917                                                                 }
4918                                                         }
4919                                                 }
4920                                                 else if (__highlightedItemIndex < __itemCount)
4921                                                 {
4922                                                         if (__highlightedItemIndex == selectedItemIndex)
4923                                                         {
4924                                                                 if (__pItems.at(__highlightedItemIndex)->GetButtonStatus() != _BUTTON_STATUS_DISABLED)
4925                                                                 {
4926                                                                         __pItems.at(__highlightedItemIndex)->SetButtonStatus(_BUTTON_STATUS_SELECTED, false);
4927                                                                 }
4928                                                         }
4929                                                         else
4930                                                         {
4931                                                                 if (__pItems.at(__highlightedItemIndex)->GetButtonStatus() != _BUTTON_STATUS_DISABLED)
4932                                                                 {
4933                                                                         __pItems.at(__highlightedItemIndex)->SetButtonStatus(_BUTTON_STATUS_NORMAL);
4934                                                                 }
4935                                                         }
4936
4937                                                         __highlightedItemIndex--;
4938
4939                                                         if (__pItems.at(__highlightedItemIndex)->GetButtonStatus() != _BUTTON_STATUS_DISABLED)
4940                                                         {
4941                                                                 __pItems.at(__highlightedItemIndex)->SetButtonStatus(_BUTTON_STATUS_HIGHLIGHTED, false);
4942
4943                                                                 __lastHighlightedItemIndex = __highlightedItemIndex;
4944                                                                 __highlighted = true;
4945                                                         }
4946                                                         else
4947                                                         {
4948                                                                 OnKeyReleased(source, keyInfo);
4949                                                         }
4950                                                 }
4951                                         }
4952                                 }
4953                                 else // L is null
4954                                 {
4955                                         if (__pButtonItems[RIGHT_BUTTON]) // Item  R
4956                                         {
4957                                                 if (__highlightedItemIndex == 0)
4958                                                 {
4959                                                         // empty
4960                                                 }
4961                                                 else if (__highlightedItemIndex < __itemCount)
4962                                                 {
4963                                                         if (__highlightedItemIndex == selectedItemIndex)
4964                                                         {
4965                                                                 if (__pItems.at(__highlightedItemIndex)->GetButtonStatus() != _BUTTON_STATUS_DISABLED)
4966                                                                 {
4967                                                                         __pItems.at(__highlightedItemIndex)->SetButtonStatus(_BUTTON_STATUS_SELECTED, false);
4968                                                                 }
4969                                                         }
4970                                                         else
4971                                                         {
4972                                                                 if (__pItems.at(__highlightedItemIndex)->GetButtonStatus() != _BUTTON_STATUS_DISABLED)
4973                                                                 {
4974                                                                         __pItems.at(__highlightedItemIndex)->SetButtonStatus(_BUTTON_STATUS_NORMAL);
4975                                                                 }
4976                                                         }
4977
4978                                                         __highlightedItemIndex--;
4979
4980                                                         if (__pItems.at(__highlightedItemIndex)->GetButtonStatus() != _BUTTON_STATUS_DISABLED)
4981                                                         {
4982                                                                 __pItems.at(__highlightedItemIndex)->SetButtonStatus(_BUTTON_STATUS_HIGHLIGHTED, false);
4983
4984                                                                 __lastHighlightedItemIndex = __highlightedItemIndex;
4985                                                                 __highlighted = true;
4986                                                         }
4987                                                         else
4988                                                         {
4989                                                                 OnKeyReleased(source, keyInfo);
4990                                                         }
4991                                                 }
4992                                                 else if (__highlightedItemIndex == __itemCount)
4993                                                 {
4994                                                         if (__pButtonItems[RIGHT_BUTTON])
4995                                                         {
4996                                                                 if (__pButtonItems[RIGHT_BUTTON]->GetButtonStatus() != _BUTTON_STATUS_DISABLED)
4997                                                                 {
4998                                                                         __pButtonItems[RIGHT_BUTTON]->SetButtonStatus(_BUTTON_STATUS_NORMAL);
4999                                                                 }
5000                                                         }
5001
5002                                                         __highlightedItemIndex--;
5003
5004                                                         if (__pItems.at(__highlightedItemIndex)->GetButtonStatus() != _BUTTON_STATUS_DISABLED)
5005                                                         {
5006                                                                 __pItems.at(__highlightedItemIndex)->SetButtonStatus(_BUTTON_STATUS_HIGHLIGHTED, false);
5007
5008                                                                 __lastHighlightedItemIndex = __highlightedItemIndex;
5009                                                                 __highlighted = true;
5010                                                         }
5011                                                         else
5012                                                         {
5013                                                                 OnKeyReleased(source, keyInfo);
5014                                                         }
5015                                                 }
5016                                         }
5017                                         else // Item
5018                                         {
5019                                                 if (__highlightedItemIndex == 0)
5020                                                 {
5021                                                         // empty
5022                                                 }
5023                                                 else if (__highlightedItemIndex < __itemCount)
5024                                                 {
5025                                                         if (__highlightedItemIndex == selectedItemIndex)
5026                                                         {
5027                                                                 if (__pItems.at(__highlightedItemIndex)->GetButtonStatus() != _BUTTON_STATUS_DISABLED)
5028                                                                 {
5029                                                                         __pItems.at(__highlightedItemIndex)->SetButtonStatus(_BUTTON_STATUS_SELECTED, false);
5030                                                                 }
5031                                                         }
5032                                                         else
5033                                                         {
5034                                                                 if (__pItems.at(__highlightedItemIndex)->GetButtonStatus() != _BUTTON_STATUS_DISABLED)
5035                                                                 {
5036                                                                         __pItems.at(__highlightedItemIndex)->SetButtonStatus(_BUTTON_STATUS_NORMAL);
5037                                                                 }
5038                                                         }
5039
5040                                                         __highlightedItemIndex--;
5041
5042                                                         if (__pItems.at(__highlightedItemIndex)->GetButtonStatus() != _BUTTON_STATUS_DISABLED)
5043                                                         {
5044                                                                 __pItems.at(__highlightedItemIndex)->SetButtonStatus(_BUTTON_STATUS_HIGHLIGHTED, false);
5045
5046                                                                 __lastHighlightedItemIndex = __highlightedItemIndex;
5047                                                                 __highlighted = true;
5048
5049                                                                 if (__pToolbarPresenter->GetFirstLoadedItemIndex() > __highlightedItemIndex)
5050                                                                 {
5051                                                                         if (__style == TOOLBAR_TAB || __style == TOOLBAR_TAB_WITH_TITLE || __style == TOOLBAR_TAB_LARGE)
5052                                                                         {
5053                                                                                 __pToolbarPresenter->SetItemFit(__highlightedItemIndex);
5054                                                                         }
5055                                                                 }
5056                                                         }
5057                                                         else
5058                                                         {
5059                                                                 OnKeyReleased(source, keyInfo);
5060                                                         }
5061                                                 }
5062                                         }
5063                                 }
5064
5065                                 if (__highlighted == false)
5066                                 {
5067                                         __highlightedItemIndex = __lastHighlightedItemIndex;
5068
5069                                         if (__highlightedItemIndex < __itemCount)
5070                                         {
5071                                                 if (__pItems.at(__highlightedItemIndex))
5072                                                 {
5073                                                         if (__pItems.at(__highlightedItemIndex)->GetButtonStatus() != _BUTTON_STATUS_DISABLED)
5074                                                         {
5075                                                                 __pItems.at(__highlightedItemIndex)->SetButtonStatus(_BUTTON_STATUS_HIGHLIGHTED, false);
5076                                                         }
5077                                                 }
5078                                         }
5079                                         else if (__highlightedItemIndex == __itemCount)
5080                                         {
5081                                                 if (__pButtonItems[LEFT_BUTTON])
5082                                                 {
5083                                                         if (__pButtonItems[LEFT_BUTTON]->GetButtonStatus() != _BUTTON_STATUS_DISABLED)
5084                                                         {
5085                                                                 __pButtonItems[LEFT_BUTTON]->SetButtonStatus(_BUTTON_STATUS_HIGHLIGHTED, false);
5086                                                         }
5087                                                 }
5088                                                 else if (__pButtonItems[RIGHT_BUTTON])
5089                                                 {
5090                                                         if (__pButtonItems[RIGHT_BUTTON]->GetButtonStatus() != _BUTTON_STATUS_DISABLED)
5091                                                         {
5092                                                                 __pButtonItems[RIGHT_BUTTON]->SetButtonStatus(_BUTTON_STATUS_HIGHLIGHTED, false);
5093                                                         }
5094                                                 }
5095                                         }
5096                                         else if (__highlightedItemIndex == __itemCount + 1)
5097                                         {
5098                                                 if (__pButtonItems[RIGHT_BUTTON])
5099                                                 {
5100                                                         if (__pButtonItems[RIGHT_BUTTON]->GetButtonStatus() != _BUTTON_STATUS_DISABLED)
5101                                                         {
5102                                                                 __pButtonItems[RIGHT_BUTTON]->SetButtonStatus(_BUTTON_STATUS_HIGHLIGHTED, false);
5103                                                         }
5104                                                 }
5105                                         }
5106
5107                                         __highlighted = true;
5108                                 }
5109                         }
5110                         else // __itemCount == 0
5111                         {
5112                                 if (__pButtonItems[LEFT_BUTTON])
5113                                 {
5114                                         if (__pButtonItems[RIGHT_BUTTON])
5115                                         {
5116                                                 if (__highlightedItemIndex == __itemCount + 1)
5117                                                 {
5118                                                         if (__pButtonItems[RIGHT_BUTTON]->GetButtonStatus() != _BUTTON_STATUS_DISABLED)
5119                                                         {
5120                                                                 __pButtonItems[RIGHT_BUTTON]->SetButtonStatus(_BUTTON_STATUS_NORMAL);
5121                                                         }
5122
5123                                                         __highlightedItemIndex--;
5124
5125                                                         if (__pButtonItems[LEFT_BUTTON])
5126                                                         {
5127                                                                 if (__pButtonItems[LEFT_BUTTON]->GetButtonStatus() != _BUTTON_STATUS_DISABLED)
5128                                                                 {
5129                                                                         __pButtonItems[LEFT_BUTTON]->SetButtonStatus(_BUTTON_STATUS_HIGHLIGHTED, false);
5130
5131                                                                         __lastHighlightedItemIndex = __highlightedItemIndex;
5132                                                                         __highlighted = true;
5133                                                                 }
5134                                                                 else
5135                                                                 {
5136                                                                         //empty
5137                                                                 }
5138                                                         }
5139                                                 }
5140                                         }
5141                                 }
5142
5143                                 if (__highlighted == false)
5144                                 {
5145                                         __highlightedItemIndex = __lastHighlightedItemIndex;
5146
5147                                         if (__highlightedItemIndex == __itemCount)
5148                                         {
5149                                                 if (__pButtonItems[LEFT_BUTTON])
5150                                                 {
5151                                                         if (__pButtonItems[LEFT_BUTTON]->GetButtonStatus() != _BUTTON_STATUS_DISABLED)
5152                                                         {
5153                                                                 __pButtonItems[LEFT_BUTTON]->SetButtonStatus(_BUTTON_STATUS_HIGHLIGHTED, false);
5154                                                         }
5155                                                 }
5156                                                 else if (__pButtonItems[RIGHT_BUTTON])
5157                                                 {
5158                                                         if (__pButtonItems[RIGHT_BUTTON]->GetButtonStatus() != _BUTTON_STATUS_DISABLED)
5159                                                         {
5160                                                                 __pButtonItems[RIGHT_BUTTON]->SetButtonStatus(_BUTTON_STATUS_HIGHLIGHTED, false);
5161                                                         }
5162                                                 }
5163                                         }
5164                                         else if (__highlightedItemIndex == __itemCount + 1)
5165                                         {
5166                                                 if (__pButtonItems[RIGHT_BUTTON])
5167                                                 {
5168                                                         if (__pButtonItems[RIGHT_BUTTON]->GetButtonStatus() != _BUTTON_STATUS_DISABLED)
5169                                                         {
5170                                                                 __pButtonItems[RIGHT_BUTTON]->SetButtonStatus(_BUTTON_STATUS_HIGHLIGHTED, false);
5171                                                         }
5172                                                 }
5173                                         }
5174
5175                                         __highlighted = true;
5176                                 }
5177                         }
5178                 }
5179
5180                 Invalidate(true);
5181         }
5182         else if (IsFocusModeStateEnabled() == true && keyCode == _KEY_ENTER)
5183         {
5184                 if (__itemCount != 0)
5185                 {
5186                         if (__pButtonItems[LEFT_BUTTON])
5187                         {
5188                                 if (__pButtonItems[RIGHT_BUTTON]) // L  Item  R
5189                                 {
5190                                         if (__highlightedItemIndex < __itemCount)
5191                                         {
5192                                                 if (__style == TOOLBAR_HEADER_SEGMENTED || __style ==TOOLBAR_HEADER_SEGMENTED_WITH_TITLE || __style == TOOLBAR_SEGMENTED
5193                                                                 || __style == TOOLBAR_TAB || __style == TOOLBAR_TAB_WITH_TITLE || __style == TOOLBAR_TAB_LARGE)
5194                                                 {
5195                                                         if (__pItems.at(__highlightedItemIndex)->GetButtonStatus() != _BUTTON_STATUS_DISABLED)
5196                                                         {
5197                                                                 SetItemHighlighted(__highlightedItemIndex, true, false);
5198                                                         }
5199                                                 }
5200                                                 else
5201                                                 {
5202                                                         if (__pItems.at(__highlightedItemIndex)->GetButtonStatus() != _BUTTON_STATUS_DISABLED)
5203                                                         {
5204                                                                 __pItems.at(__highlightedItemIndex)->SetButtonStatus(_BUTTON_STATUS_HIGHLIGHTED);
5205
5206                                                                 __lastHighlightedItemIndex = __highlightedItemIndex;
5207                                                                 __highlighted = true;
5208                                                         }
5209                                                 }
5210                                         }
5211                                         else if (__highlightedItemIndex == __itemCount)
5212                                         {
5213                                                 if (__pButtonItems[LEFT_BUTTON])
5214                                                 {
5215                                                         if (__pButtonItems[LEFT_BUTTON]->GetButtonStatus() != _BUTTON_STATUS_DISABLED)
5216                                                         {
5217                                                                 __pButtonItems[LEFT_BUTTON]->SetButtonStatus(_BUTTON_STATUS_NORMAL);
5218                                                                 __pButtonItems[LEFT_BUTTON]->Invalidate();
5219
5220                                                                 __pButtonItems[LEFT_BUTTON]->SetButtonStatus(_BUTTON_STATUS_HIGHLIGHTED);
5221
5222                                                                 __lastHighlightedItemIndex = __highlightedItemIndex = __itemCount;
5223                                                                 __highlighted = true;
5224                                                         }
5225                                                 }
5226                                         }
5227                                         else if (__highlightedItemIndex == __itemCount + 1)
5228                                         {
5229                                                 if (__pButtonItems[RIGHT_BUTTON])
5230                                                 {
5231                                                         if (__pButtonItems[RIGHT_BUTTON]->GetButtonStatus() != _BUTTON_STATUS_DISABLED)
5232                                                         {
5233                                                                 __pButtonItems[RIGHT_BUTTON]->SetButtonStatus(_BUTTON_STATUS_NORMAL);
5234                                                                 __pButtonItems[RIGHT_BUTTON]->Invalidate();
5235
5236                                                                 __pButtonItems[RIGHT_BUTTON]->SetButtonStatus(_BUTTON_STATUS_HIGHLIGHTED);
5237
5238                                                                 __lastHighlightedItemIndex = __highlightedItemIndex = __itemCount + 1;
5239                                                                 __highlighted = true;
5240                                                         }
5241                                                 }
5242                                         }
5243                                 }
5244                                 else  // L  Item
5245                                 {
5246                                         if (__highlightedItemIndex < __itemCount)
5247                                         {
5248                                                 if (__style == TOOLBAR_HEADER_SEGMENTED || __style ==TOOLBAR_HEADER_SEGMENTED_WITH_TITLE || __style == TOOLBAR_SEGMENTED
5249                                                                 || __style == TOOLBAR_TAB || __style == TOOLBAR_TAB_WITH_TITLE || __style == TOOLBAR_TAB_LARGE)
5250                                                 {
5251                                                         if (__pItems.at(__highlightedItemIndex)->GetButtonStatus() != _BUTTON_STATUS_DISABLED)
5252                                                         {
5253                                                                 SetItemHighlighted(__highlightedItemIndex, true, false);
5254                                                         }
5255                                                 }
5256                                                 else
5257                                                 {
5258                                                         if (__pItems.at(__highlightedItemIndex)->GetButtonStatus() != _BUTTON_STATUS_DISABLED)
5259                                                         {
5260                                                                 __pItems.at(__highlightedItemIndex)->SetButtonStatus(_BUTTON_STATUS_HIGHLIGHTED);
5261
5262                                                                 __lastHighlightedItemIndex = __highlightedItemIndex;
5263                                                                 __highlighted = true;
5264                                                         }
5265                                                 }
5266                                         }
5267                                         else if (__highlightedItemIndex == __itemCount)
5268                                         {
5269                                                 if (__pButtonItems[LEFT_BUTTON])
5270                                                 {
5271                                                         if (__pButtonItems[LEFT_BUTTON]->GetButtonStatus() != _BUTTON_STATUS_DISABLED)
5272                                                         {
5273                                                                 __pButtonItems[LEFT_BUTTON]->SetButtonStatus(_BUTTON_STATUS_NORMAL);
5274                                                                 __pButtonItems[LEFT_BUTTON]->Invalidate();
5275
5276                                                                 __pButtonItems[LEFT_BUTTON]->SetButtonStatus(_BUTTON_STATUS_HIGHLIGHTED);
5277
5278                                                                 __lastHighlightedItemIndex = __highlightedItemIndex = __itemCount;
5279                                                                 __highlighted = true;
5280                                                         }
5281                                                 }
5282                                         }
5283                                 }
5284                         }
5285                         else // L is null
5286                         {
5287                                 if (__pButtonItems[RIGHT_BUTTON]) // Item  R
5288                                 {
5289                                         if (__highlightedItemIndex < __itemCount)
5290                                         {
5291                                                 if (__style == TOOLBAR_HEADER_SEGMENTED || __style ==TOOLBAR_HEADER_SEGMENTED_WITH_TITLE || __style == TOOLBAR_SEGMENTED
5292                                                                 || __style == TOOLBAR_TAB || __style == TOOLBAR_TAB_WITH_TITLE || __style == TOOLBAR_TAB_LARGE)
5293                                                 {
5294                                                         if (__pItems.at(__highlightedItemIndex)->GetButtonStatus() != _BUTTON_STATUS_DISABLED)
5295                                                         {
5296                                                                 SetItemHighlighted(__highlightedItemIndex, true, false);
5297                                                         }
5298                                                 }
5299                                                 else
5300                                                 {
5301                                                         if (__pItems.at(__highlightedItemIndex)->GetButtonStatus() != _BUTTON_STATUS_DISABLED)
5302                                                         {
5303                                                                 __pItems.at(__highlightedItemIndex)->SetButtonStatus(_BUTTON_STATUS_HIGHLIGHTED);
5304
5305                                                                 __lastHighlightedItemIndex = __highlightedItemIndex;
5306                                                                 __highlighted = true;
5307                                                         }
5308                                                 }
5309                                         }
5310                                         else if (__highlightedItemIndex == __itemCount)
5311                                         {
5312                                                 if (__pButtonItems[RIGHT_BUTTON])
5313                                                 {
5314                                                         if (__pButtonItems[RIGHT_BUTTON]->GetButtonStatus() != _BUTTON_STATUS_DISABLED)
5315                                                         {
5316                                                                 __pButtonItems[RIGHT_BUTTON]->SetButtonStatus(_BUTTON_STATUS_NORMAL);
5317                                                                 __pButtonItems[RIGHT_BUTTON]->Invalidate();
5318
5319                                                                 __pButtonItems[RIGHT_BUTTON]->SetButtonStatus(_BUTTON_STATUS_HIGHLIGHTED);
5320
5321                                                                 __lastHighlightedItemIndex = __highlightedItemIndex = __itemCount;
5322                                                                 __highlighted = true;
5323                                                         }
5324                                                 }
5325                                         }
5326                                 }
5327                                 else // Item
5328                                 {
5329                                         if (__highlightedItemIndex < __itemCount)
5330                                         {
5331                                                 if (__style == TOOLBAR_HEADER_SEGMENTED || __style ==TOOLBAR_HEADER_SEGMENTED_WITH_TITLE || __style == TOOLBAR_SEGMENTED
5332                                                                 || __style == TOOLBAR_TAB || __style == TOOLBAR_TAB_WITH_TITLE || __style == TOOLBAR_TAB_LARGE)
5333                                                 {
5334                                                         if (__pItems.at(__highlightedItemIndex)->GetButtonStatus() != _BUTTON_STATUS_DISABLED)
5335                                                         {
5336                                                                 SetItemHighlighted(__highlightedItemIndex, true, false);
5337                                                         }
5338                                                 }
5339                                                 else
5340                                                 {
5341                                                         if (__pItems.at(__highlightedItemIndex)->GetButtonStatus() != _BUTTON_STATUS_DISABLED)
5342                                                         {
5343                                                                 __pItems.at(__highlightedItemIndex)->SetButtonStatus(_BUTTON_STATUS_HIGHLIGHTED);
5344
5345                                                                 __lastHighlightedItemIndex = __highlightedItemIndex;
5346                                                                 __highlighted = true;
5347                                                         }
5348                                                 }
5349                                         }
5350                                 }
5351                         }
5352                 }
5353                 else // __itemCount == 0
5354                 {
5355                         if (__pButtonItems[LEFT_BUTTON])
5356                         {
5357                                 if (__pButtonItems[RIGHT_BUTTON]) // L   R
5358                                 {
5359                                         if (__highlightedItemIndex == 0)
5360                                         {
5361                                                 if (__pButtonItems[LEFT_BUTTON])
5362                                                 {
5363                                                         if (__pButtonItems[LEFT_BUTTON]->GetButtonStatus() != _BUTTON_STATUS_DISABLED)
5364                                                         {
5365                                                                 __pButtonItems[LEFT_BUTTON]->SetButtonStatus(_BUTTON_STATUS_NORMAL);
5366                                                                 __pButtonItems[LEFT_BUTTON]->Invalidate();
5367
5368                                                                 __pButtonItems[LEFT_BUTTON]->SetButtonStatus(_BUTTON_STATUS_HIGHLIGHTED);
5369
5370                                                                 __lastHighlightedItemIndex = __highlightedItemIndex = __itemCount;
5371                                                                 __highlighted = true;
5372                                                         }
5373                                                 }
5374                                         }
5375                                         else if (__highlightedItemIndex == 1)
5376                                         {
5377                                                 if (__pButtonItems[RIGHT_BUTTON])
5378                                                 {
5379                                                         if (__pButtonItems[RIGHT_BUTTON]->GetButtonStatus() != _BUTTON_STATUS_DISABLED)
5380                                                         {
5381                                                                 __pButtonItems[RIGHT_BUTTON]->SetButtonStatus(_BUTTON_STATUS_NORMAL);
5382                                                                 __pButtonItems[RIGHT_BUTTON]->Invalidate();
5383
5384                                                                 __pButtonItems[RIGHT_BUTTON]->SetButtonStatus(_BUTTON_STATUS_HIGHLIGHTED);
5385
5386                                                                 __lastHighlightedItemIndex = __highlightedItemIndex = __itemCount + 1;
5387                                                                 __highlighted = true;
5388                                                         }
5389                                                 }
5390                                         }
5391                                 }
5392                                 else  // L
5393                                 {
5394                                         if (__highlightedItemIndex == 0)
5395                                         {
5396                                                 if (__pButtonItems[LEFT_BUTTON])
5397                                                 {
5398                                                         if (__pButtonItems[LEFT_BUTTON]->GetButtonStatus() != _BUTTON_STATUS_DISABLED)
5399                                                         {
5400                                                                 __pButtonItems[LEFT_BUTTON]->SetButtonStatus(_BUTTON_STATUS_NORMAL);
5401                                                                 __pButtonItems[LEFT_BUTTON]->Invalidate();
5402
5403                                                                 __pButtonItems[LEFT_BUTTON]->SetButtonStatus(_BUTTON_STATUS_HIGHLIGHTED);
5404
5405                                                                 __lastHighlightedItemIndex = __highlightedItemIndex = __itemCount;
5406                                                                 __highlighted = true;
5407                                                         }
5408                                                 }
5409                                         }
5410                                 }
5411                         }
5412                         else // L is null
5413                         {
5414                                 if (__pButtonItems[RIGHT_BUTTON]) //  R
5415                                 {
5416                                         if (__highlightedItemIndex == 0)
5417                                         {
5418                                                 if (__pButtonItems[RIGHT_BUTTON]->GetButtonStatus() != _BUTTON_STATUS_DISABLED)
5419                                                 {
5420                                                         __pButtonItems[RIGHT_BUTTON]->SetButtonStatus(_BUTTON_STATUS_NORMAL);
5421                                                         __pButtonItems[RIGHT_BUTTON]->Invalidate();
5422
5423                                                         __pButtonItems[RIGHT_BUTTON]->SetButtonStatus(_BUTTON_STATUS_HIGHLIGHTED);
5424
5425                                                         __lastHighlightedItemIndex = __highlightedItemIndex = __itemCount;
5426                                                         __highlighted = true;
5427                                                 }
5428                                         }
5429                                 }
5430                         }
5431                 }
5432         }
5433
5434         return false;
5435 } // OnKeyReleased
5436
5437 void
5438 _Toolbar::OnChangeLayout(_ControlOrientation orientationStatus)
5439 {
5440         float toolbarWidth = GetBoundsF().width;
5441
5442         if (CalculateMinimumToolbarWidth() > toolbarWidth)
5443         {
5444                 toolbarWidth = CalculateMinimumToolbarWidth();
5445         }
5446
5447         AdjustToolbarBounds();
5448
5449         RearrangeItems();
5450
5451         __pToolbarPresenter->OnChangeLayout(orientationStatus);
5452
5453         return;
5454 }
5455
5456 void
5457 _Toolbar::OnDraw(void)
5458 {
5459         ClearLastResult();
5460
5461         __pToolbarPresenter->Draw();
5462
5463         if(__pTitleTextElement)
5464         {
5465                 if( __descriptionText.IsEmpty())
5466                 {
5467                         __pTitleTextElement->SetBounds(FloatRectangle(__pToolbarPresenter->GetTitleTextBoundsF()));
5468                 }
5469                 else
5470                 {
5471                         FloatRectangle descriptionBounds = __pToolbarPresenter->GetDescriptionBoundsF();
5472                         FloatRectangle titleBounds = __pToolbarPresenter->GetTitleTextBoundsF();
5473
5474                         __pTitleTextElement->SetBounds(FloatRectangle(titleBounds.x, titleBounds.y, titleBounds.width, titleBounds.height + descriptionBounds.height));
5475                 }
5476         }
5477         return;
5478 }
5479
5480 bool
5481 _Toolbar::OnLongPressGestureDetected(_TouchLongPressGestureDetector& gesture)
5482 {
5483         return __pToolbarPresenter->OnLongPressGestureDetected();
5484 }
5485
5486 bool
5487 _Toolbar::OnLongPressGestureCanceled(_TouchLongPressGestureDetector& gesture)
5488 {
5489         return false;
5490 }
5491
5492 bool
5493 _Toolbar::OnFlickGestureDetected(_TouchFlickGestureDetector& gesture)
5494 {
5495         return __pToolbarPresenter->OnFlickGestureDetected(gesture);
5496 }
5497
5498 bool
5499 _Toolbar::OnFlickGestureCanceled(_TouchFlickGestureDetector& gesture)
5500 {
5501         return false;
5502 }
5503
5504 bool
5505 _Toolbar::OnTouchPressed(const _Control& source, const _TouchInfo& touchinfo)
5506 {
5507         ClearLastResult();
5508
5509         return __pToolbarPresenter->OnTouchPressed(source, touchinfo);
5510 }
5511
5512 bool
5513 _Toolbar::OnTouchReleased(const _Control& source, const _TouchInfo& touchinfo)
5514 {
5515         ClearLastResult();
5516
5517         return __pToolbarPresenter->OnTouchReleased(source, touchinfo);
5518 }
5519
5520 bool
5521 _Toolbar::OnTouchMoved(const _Control& source, const _TouchInfo& touchinfo)
5522 {
5523         ClearLastResult();
5524
5525         return __pToolbarPresenter->OnTouchMoved(source, touchinfo);
5526 }
5527
5528 bool
5529 _Toolbar::OnTouchCanceled(const _Control& source, const _TouchInfo& touchinfo)
5530 {
5531         ClearLastResult();
5532
5533         return __pToolbarPresenter->OnTouchCanceled(source, touchinfo);
5534 }
5535
5536 bool
5537 _Toolbar::OnKeyPressed(const _Control& source, const _KeyInfo& keyInfo)
5538 {
5539         _KeyCode keyCode = keyInfo.GetKeyCode();
5540
5541         if (IsFocusModeStateEnabled() == true && keyCode == _KEY_ENTER)
5542         {
5543                 if (__itemCount != 0)
5544                 {
5545                         if (__pButtonItems[LEFT_BUTTON])
5546                         {
5547                                 if (__pButtonItems[RIGHT_BUTTON]) // L  Item  R
5548                                 {
5549                                         if (__highlightedItemIndex < __itemCount)
5550                                         {
5551                                                 if (__pItems.at(__highlightedItemIndex)->GetButtonStatus() != _BUTTON_STATUS_DISABLED)
5552                                                 {
5553                                                         __pItems.at(__highlightedItemIndex)->SetButtonStatus(_BUTTON_STATUS_PRESSED);
5554                                                 }
5555                                         }
5556                                         else if (__highlightedItemIndex == __itemCount)
5557                                         {
5558                                                 if (__pButtonItems[LEFT_BUTTON])
5559                                                 {
5560                                                         if (__pButtonItems[LEFT_BUTTON]->GetButtonStatus() != _BUTTON_STATUS_DISABLED)
5561                                                         {
5562                                                                 __pButtonItems[LEFT_BUTTON]->SetButtonStatus(_BUTTON_STATUS_PRESSED);
5563                                                         }
5564                                                 }
5565                                         }
5566                                         else if (__highlightedItemIndex == __itemCount + 1)
5567                                         {
5568                                                 if (__pButtonItems[RIGHT_BUTTON])
5569                                                 {
5570                                                         if (__pButtonItems[RIGHT_BUTTON]->GetButtonStatus() != _BUTTON_STATUS_DISABLED)
5571                                                         {
5572                                                                 __pButtonItems[RIGHT_BUTTON]->SetButtonStatus(_BUTTON_STATUS_PRESSED);
5573                                                         }
5574                                                 }
5575                                         }
5576                                 }
5577                                 else  // L  Item
5578                                 {
5579                                         if (__highlightedItemIndex < __itemCount)
5580                                         {
5581                                                 if (__pItems.at(__highlightedItemIndex)->GetButtonStatus() != _BUTTON_STATUS_DISABLED)
5582                                                 {
5583                                                         __pItems.at(__highlightedItemIndex)->SetButtonStatus(_BUTTON_STATUS_PRESSED);
5584                                                 }
5585                                         }
5586                                         else if (__highlightedItemIndex == __itemCount)
5587                                         {
5588                                                 if (__pButtonItems[LEFT_BUTTON])
5589                                                 {
5590                                                         if (__pButtonItems[LEFT_BUTTON]->GetButtonStatus() != _BUTTON_STATUS_DISABLED)
5591                                                         {
5592                                                                 __pButtonItems[LEFT_BUTTON]->SetButtonStatus(_BUTTON_STATUS_PRESSED);
5593                                                         }
5594                                                 }
5595                                         }
5596                                 }
5597                         }
5598                         else // L is null
5599                         {
5600                                 if (__pButtonItems[RIGHT_BUTTON]) // Item  R
5601                                 {
5602                                         if (__highlightedItemIndex < __itemCount)
5603                                         {
5604                                                 if (__pItems.at(__highlightedItemIndex)->GetButtonStatus() != _BUTTON_STATUS_DISABLED)
5605                                                 {
5606                                                         __pItems.at(__highlightedItemIndex)->SetButtonStatus(_BUTTON_STATUS_PRESSED);
5607                                                 }
5608                                         }
5609                                         else if (__highlightedItemIndex == __itemCount)
5610                                         {
5611                                                 if (__pButtonItems[RIGHT_BUTTON])
5612                                                 {
5613                                                         if (__pButtonItems[RIGHT_BUTTON]->GetButtonStatus() != _BUTTON_STATUS_DISABLED)
5614                                                         {
5615                                                                 __pButtonItems[RIGHT_BUTTON]->SetButtonStatus(_BUTTON_STATUS_PRESSED);
5616                                                         }
5617                                                 }
5618                                         }
5619                                 }
5620                                 else // Item
5621                                 {
5622                                         if (__highlightedItemIndex < __itemCount)
5623                                         {
5624                                                 if (__pItems.at(__highlightedItemIndex)->GetButtonStatus() != _BUTTON_STATUS_DISABLED)
5625                                                 {
5626                                                         __pItems.at(__highlightedItemIndex)->SetButtonStatus(_BUTTON_STATUS_PRESSED);
5627                                                 }
5628                                         }
5629                                 }
5630                         }
5631                 }
5632                 else // __itemCount == 0
5633                 {
5634                         if (__pButtonItems[LEFT_BUTTON])
5635                         {
5636                                 if (__pButtonItems[RIGHT_BUTTON]) // L   R
5637                                 {
5638                                         if (__highlightedItemIndex == 0)
5639                                         {
5640                                                 if (__pButtonItems[LEFT_BUTTON])
5641                                                 {
5642                                                         if (__pButtonItems[LEFT_BUTTON]->GetButtonStatus() != _BUTTON_STATUS_DISABLED)
5643                                                         {
5644                                                                 __pButtonItems[LEFT_BUTTON]->SetButtonStatus(_BUTTON_STATUS_PRESSED);
5645                                                         }
5646                                                 }
5647                                         }
5648                                         else if (__highlightedItemIndex == 1)
5649                                         {
5650                                                 if (__pButtonItems[RIGHT_BUTTON])
5651                                                 {
5652                                                         if (__pButtonItems[RIGHT_BUTTON]->GetButtonStatus() != _BUTTON_STATUS_DISABLED)
5653                                                         {
5654                                                                 __pButtonItems[RIGHT_BUTTON]->SetButtonStatus(_BUTTON_STATUS_PRESSED);
5655                                                         }
5656                                                 }
5657                                         }
5658                                 }
5659                                 else  // L
5660                                 {
5661                                         if (__highlightedItemIndex == 0)
5662                                         {
5663                                                 if (__pButtonItems[LEFT_BUTTON])
5664                                                 {
5665                                                         if (__pButtonItems[LEFT_BUTTON]->GetButtonStatus() != _BUTTON_STATUS_DISABLED)
5666                                                         {
5667                                                                 __pButtonItems[LEFT_BUTTON]->SetButtonStatus(_BUTTON_STATUS_PRESSED);
5668                                                         }
5669                                                 }
5670                                         }
5671                                 }
5672                         }
5673                         else // L is null
5674                         {
5675                                 if (__pButtonItems[RIGHT_BUTTON]) //  R
5676                                 {
5677                                         if (__highlightedItemIndex == 0)
5678                                         {
5679                                                 if (__pButtonItems[RIGHT_BUTTON]->GetButtonStatus() != _BUTTON_STATUS_DISABLED)
5680                                                 {
5681                                                         __pButtonItems[RIGHT_BUTTON]->SetButtonStatus(_BUTTON_STATUS_PRESSED);
5682                                                 }
5683                                         }
5684                                 }
5685                         }
5686                 }
5687         }
5688
5689         Invalidate(true);
5690
5691         return false;
5692 }
5693
5694 void
5695 _Toolbar::AddActionEventListener(const Controls::_IActionEventListener& listener)
5696 {
5697         __pActionEventListener = const_cast<Controls::_IActionEventListener*>(&listener);
5698
5699         for (int i = 0; i < __itemCount; i++)
5700         {
5701                 __pItems.at(i)->AddActionEventListener(listener);
5702         }
5703
5704         for (int j = 0; j <= MIDDLE_BUTTON; j++)
5705         {
5706                 if (__pButtonItems[j])
5707                 {
5708                         __pButtonItems[j]->AddActionEventListener(listener);
5709                 }
5710         }
5711
5712         return;
5713 }
5714
5715 void
5716 _Toolbar::RemoveActionEventListener(const Controls::_IActionEventListener& listener)
5717 {
5718         __pActionEventListener = null;
5719
5720         //for (int i = 0; i < __itemCount; i++)
5721         //{
5722                 //__pItems.at(i)->RemoveActionEventListener(listener);
5723         //}
5724
5725         //for (int j = 0; j < MIDDLE_BUTTON; j++)
5726         //{
5727         //      if (__pButtonItems[j])
5728         //      {
5729         //              __pButtonItems[j]->RemoveActionEventListener(listener);
5730         //      }
5731         //}
5732
5733         return;
5734
5735 }
5736
5737 void
5738 _Toolbar::SetBackEventListener(const Controls::_IActionEventListener& listener, int actionId)
5739 {
5740         __backActionId = actionId;
5741         __pBackEventListener = const_cast<_IActionEventListener*>(&listener);
5742
5743         return;
5744 }
5745
5746 void
5747 _Toolbar::SetMenuEventListener(const Controls::_IActionEventListener& listener, int actionId)
5748 {
5749         __menuActionId = actionId;
5750         __pMenuEventListener = const_cast<_IActionEventListener*>(&listener);
5751
5752         return;
5753 }
5754
5755 result
5756 _Toolbar::SetPresenter(const _ToolbarPresenter& toolbarPresenter)
5757 {
5758         __pToolbarPresenter = const_cast<_ToolbarPresenter*>(&toolbarPresenter);
5759
5760         return E_SUCCESS;
5761 }
5762
5763 _ToolbarPresenter*
5764 _Toolbar::GetPresenter(void) const
5765 {
5766         return __pToolbarPresenter;
5767 }
5768
5769 result
5770 _Toolbar::ApplyUserGUI(ButtonType buttonType, _Button* pButton)
5771 {
5772         SysTryReturnResult(NID_UI_CTRL, pButton, E_INVALID_ARG, "[E_INVALID_ARG] The pButton is invalid.");
5773
5774         if (TOOLBAR_BUTTON == buttonType)
5775         {
5776                 Bitmap* pNormalBackgroundBitmap = null;
5777                 Bitmap* pDisabledBackgroundBitmap = null;
5778                 Bitmap* pPressedBackgroundBitmap = null;
5779                 Bitmap* pHighlightedBackgroundBitmap = null;
5780
5781                 Bitmap* pNormalBackgroundEffectBitmap = null;
5782                 Bitmap* pDisabledBackgroundEffectBitmap = null;
5783                 Bitmap* pPressedBackgroundEffectBitmap = null;
5784                 Bitmap* pHighlightedBackgroundEffectBitmap = null;
5785
5786                 Bitmap* pColorReplacedBitmap = null;
5787
5788                 bool customTheme = false;
5789
5790                 if (__header == true)
5791                 {
5792                         if (__transparent == true)
5793                         {
5794                                 GET_BITMAP_CONFIG_N(HEADER::BUTTON_TRANSLUCENT_BG_NORMAL, BITMAP_PIXEL_FORMAT_ARGB8888, pNormalBackgroundBitmap);
5795                                 GET_BITMAP_CONFIG_N(HEADER::BUTTON_TRANSLUCENT_BG_DISABLED, BITMAP_PIXEL_FORMAT_ARGB8888, pDisabledBackgroundBitmap);
5796                                 GET_BITMAP_CONFIG_N(HEADER::BUTTON_TRANSLUCENT_BG_PRESSED, BITMAP_PIXEL_FORMAT_ARGB8888, pPressedBackgroundBitmap);
5797                                 GET_BITMAP_CONFIG_N(HEADER::BUTTON_TRANSLUCENT_BG_HIGHLIGHTED, BITMAP_PIXEL_FORMAT_ARGB8888, pHighlightedBackgroundBitmap);
5798
5799                                 customTheme = IS_CUSTOM_BITMAP(HEADER::BUTTON_TRANSLUCENT_BG_NORMAL);
5800                                 if (customTheme == false)
5801                                 {
5802                                         GET_BITMAP_CONFIG_N(HEADER::BUTTON_TRANSLUCENT_BG_EFFECT_NORMAL, BITMAP_PIXEL_FORMAT_ARGB8888, pNormalBackgroundEffectBitmap);
5803                                 }
5804
5805                                 customTheme = IS_CUSTOM_BITMAP(HEADER::BUTTON_TRANSLUCENT_BG_DISABLED);
5806                                 if (customTheme == false)
5807                                 {
5808                                         GET_BITMAP_CONFIG_N(HEADER::BUTTON_TRANSLUCENT_BG_EFFECT_NORMAL, BITMAP_PIXEL_FORMAT_ARGB8888, pDisabledBackgroundEffectBitmap);
5809                                 }
5810
5811                                 customTheme = IS_CUSTOM_BITMAP(HEADER::BUTTON_TRANSLUCENT_BG_PRESSED);
5812                                 if (customTheme == false)
5813                                 {
5814                                         GET_BITMAP_CONFIG_N(HEADER::BUTTON_TRANSLUCENT_BG_EFFECT_PRESSED, BITMAP_PIXEL_FORMAT_ARGB8888, pPressedBackgroundEffectBitmap);
5815                                 }
5816
5817                                 customTheme = IS_CUSTOM_BITMAP(HEADER::BUTTON_TRANSLUCENT_BG_HIGHLIGHTED);
5818                                 if (customTheme == false)
5819                                 {
5820                                         GET_BITMAP_CONFIG_N(HEADER::BUTTON_TRANSLUCENT_BG_EFFECT_NORMAL, BITMAP_PIXEL_FORMAT_ARGB8888, pHighlightedBackgroundEffectBitmap);
5821                                 }
5822                         }
5823                         else
5824                         {
5825                                 GET_BITMAP_CONFIG_N(HEADER::BUTTON_BG_NORMAL, BITMAP_PIXEL_FORMAT_ARGB8888, pNormalBackgroundBitmap);
5826                                 GET_BITMAP_CONFIG_N(HEADER::BUTTON_BG_DISABLED, BITMAP_PIXEL_FORMAT_ARGB8888, pDisabledBackgroundBitmap);
5827                                 GET_BITMAP_CONFIG_N(HEADER::BUTTON_BG_PRESSED, BITMAP_PIXEL_FORMAT_ARGB8888, pPressedBackgroundBitmap);
5828                                 GET_BITMAP_CONFIG_N(HEADER::BUTTON_BG_HIGHLIGHTED, BITMAP_PIXEL_FORMAT_ARGB8888, pHighlightedBackgroundBitmap);
5829
5830                                 customTheme = IS_CUSTOM_BITMAP(HEADER::BUTTON_BG_NORMAL);
5831                                 if (customTheme == false)
5832                                 {
5833                                         GET_BITMAP_CONFIG_N(HEADER::BUTTON_BG_EFFECT_NORMAL, BITMAP_PIXEL_FORMAT_ARGB8888, pNormalBackgroundEffectBitmap);
5834                                 }
5835
5836                                 customTheme = IS_CUSTOM_BITMAP(HEADER::BUTTON_BG_DISABLED);
5837                                 if (customTheme == false)
5838                                 {
5839                                         GET_BITMAP_CONFIG_N(HEADER::BUTTON_BG_EFFECT_NORMAL, BITMAP_PIXEL_FORMAT_ARGB8888, pDisabledBackgroundEffectBitmap);
5840                                 }
5841
5842                                 customTheme = IS_CUSTOM_BITMAP(HEADER::BUTTON_BG_PRESSED);
5843                                 if (customTheme == false)
5844                                 {
5845                                         GET_BITMAP_CONFIG_N(HEADER::BUTTON_BG_EFFECT_PRESSED, BITMAP_PIXEL_FORMAT_ARGB8888, pPressedBackgroundEffectBitmap);
5846                                 }
5847
5848                                 customTheme = IS_CUSTOM_BITMAP(HEADER::BUTTON_BG_HIGHLIGHTED);
5849                                 if (customTheme == false)
5850                                 {
5851                                         GET_BITMAP_CONFIG_N(HEADER::BUTTON_BG_EFFECT_NORMAL, BITMAP_PIXEL_FORMAT_ARGB8888, pHighlightedBackgroundEffectBitmap);
5852                                 }
5853                         }
5854                 }
5855                 else
5856                 {
5857                         if (__transparent == true)
5858                         {
5859                                 GET_BITMAP_CONFIG_N(FOOTER::BUTTON_TRANSLUCENT_BG_NORMAL, BITMAP_PIXEL_FORMAT_ARGB8888, pNormalBackgroundBitmap);
5860                                 GET_BITMAP_CONFIG_N(FOOTER::BUTTON_TRANSLUCENT_BG_DISABLED, BITMAP_PIXEL_FORMAT_ARGB8888, pDisabledBackgroundBitmap);
5861                                 GET_BITMAP_CONFIG_N(FOOTER::BUTTON_TRANSLUCENT_BG_PRESSED, BITMAP_PIXEL_FORMAT_ARGB8888, pPressedBackgroundBitmap);
5862                                 GET_BITMAP_CONFIG_N(FOOTER::BUTTON_TRANSLUCENT_BG_HIGHLIGHTED, BITMAP_PIXEL_FORMAT_ARGB8888, pHighlightedBackgroundBitmap);
5863
5864                                 customTheme = IS_CUSTOM_BITMAP(FOOTER::BUTTON_TRANSLUCENT_BG_NORMAL);
5865                                 if (customTheme == false)
5866                                 {
5867                                         GET_BITMAP_CONFIG_N(FOOTER::BUTTON_TRANSLUCENT_BG_EFFECT_NORMAL, BITMAP_PIXEL_FORMAT_ARGB8888, pNormalBackgroundEffectBitmap);
5868                                 }
5869
5870                                 customTheme = IS_CUSTOM_BITMAP(FOOTER::BUTTON_TRANSLUCENT_BG_DISABLED);
5871                                 if (customTheme == false)
5872                                 {
5873                                         GET_BITMAP_CONFIG_N(FOOTER::BUTTON_TRANSLUCENT_BG_EFFECT_NORMAL, BITMAP_PIXEL_FORMAT_ARGB8888, pDisabledBackgroundEffectBitmap);
5874                                 }
5875
5876                                 customTheme = IS_CUSTOM_BITMAP(FOOTER::BUTTON_TRANSLUCENT_BG_PRESSED);
5877                                 if (customTheme == false)
5878                                 {
5879                                         GET_BITMAP_CONFIG_N(FOOTER::BUTTON_TRANSLUCENT_BG_EFFECT_PRESSED, BITMAP_PIXEL_FORMAT_ARGB8888, pPressedBackgroundEffectBitmap);
5880                                 }
5881
5882                                 customTheme = IS_CUSTOM_BITMAP(FOOTER::BUTTON_TRANSLUCENT_BG_HIGHLIGHTED);
5883                                 if (customTheme == false)
5884                                 {
5885                                         GET_BITMAP_CONFIG_N(FOOTER::BUTTON_TRANSLUCENT_BG_EFFECT_NORMAL, BITMAP_PIXEL_FORMAT_ARGB8888, pHighlightedBackgroundEffectBitmap);
5886                                 }
5887                         }
5888                         else
5889                         {
5890                                 GET_BITMAP_CONFIG_N(FOOTER::BUTTON_BG_NORMAL, BITMAP_PIXEL_FORMAT_ARGB8888, pNormalBackgroundBitmap);
5891                                 GET_BITMAP_CONFIG_N(FOOTER::BUTTON_BG_DISABLED, BITMAP_PIXEL_FORMAT_ARGB8888, pDisabledBackgroundBitmap);
5892                                 GET_BITMAP_CONFIG_N(FOOTER::BUTTON_BG_PRESSED, BITMAP_PIXEL_FORMAT_ARGB8888, pPressedBackgroundBitmap);
5893                                 GET_BITMAP_CONFIG_N(FOOTER::BUTTON_BG_HIGHLIGHTED, BITMAP_PIXEL_FORMAT_ARGB8888, pHighlightedBackgroundBitmap);
5894
5895                                 customTheme = IS_CUSTOM_BITMAP(FOOTER::BUTTON_BG_NORMAL);
5896                                 if (customTheme == false)
5897                                 {
5898                                         GET_BITMAP_CONFIG_N(FOOTER::BUTTON_BG_EFFECT_NORMAL, BITMAP_PIXEL_FORMAT_ARGB8888, pNormalBackgroundEffectBitmap);
5899                                 }
5900
5901                                 customTheme = IS_CUSTOM_BITMAP(FOOTER::BUTTON_BG_DISABLED);
5902                                 if (customTheme == false)
5903                                 {
5904                                         GET_BITMAP_CONFIG_N(FOOTER::BUTTON_BG_EFFECT_NORMAL, BITMAP_PIXEL_FORMAT_ARGB8888, pDisabledBackgroundEffectBitmap);
5905                                 }
5906
5907                                 customTheme = IS_CUSTOM_BITMAP(FOOTER::BUTTON_BG_PRESSED);
5908                                 if (customTheme == false)
5909                                 {
5910                                         GET_BITMAP_CONFIG_N(FOOTER::BUTTON_BG_EFFECT_PRESSED, BITMAP_PIXEL_FORMAT_ARGB8888, pPressedBackgroundEffectBitmap);
5911                                 }
5912
5913                                 customTheme = IS_CUSTOM_BITMAP(FOOTER::BUTTON_BG_HIGHLIGHTED);
5914                                 if (customTheme == false)
5915                                 {
5916                                         GET_BITMAP_CONFIG_N(FOOTER::BUTTON_BG_EFFECT_NORMAL, BITMAP_PIXEL_FORMAT_ARGB8888, pHighlightedBackgroundEffectBitmap);
5917                                 }
5918                         }
5919                 }
5920
5921                 if (__transparent == true)
5922                 {
5923                         pButton->SetTextColor(_BUTTON_STATUS_NORMAL, __buttonTransTextColor[_BUTTON_STATUS_NORMAL]);
5924                         pButton->SetTextColor(_BUTTON_STATUS_DISABLED, __buttonTransTextColor[_BUTTON_STATUS_DISABLED]);
5925                         pButton->SetTextColor(_BUTTON_STATUS_PRESSED, __buttonTransTextColor[_BUTTON_STATUS_PRESSED]);
5926                         pButton->SetTextColor(_BUTTON_STATUS_HIGHLIGHTED, __buttonTransTextColor[_BUTTON_STATUS_HIGHLIGHTED]);
5927
5928                         if (pNormalBackgroundBitmap)
5929                         {
5930                                 pColorReplacedBitmap = _BitmapImpl::GetColorReplacedBitmapN(*pNormalBackgroundBitmap,
5931                                                 Color::GetColor(COLOR_ID_MAGENTA), __buttonTransBackgroundColor[_BUTTON_STATUS_NORMAL]);
5932                                 pButton->SetBackgroundBitmap(_BUTTON_STATUS_NORMAL, *pColorReplacedBitmap);
5933
5934                                 delete pColorReplacedBitmap;
5935                                 delete pNormalBackgroundBitmap;
5936                         }
5937
5938                         if (pDisabledBackgroundBitmap)
5939                         {
5940                                 pColorReplacedBitmap = _BitmapImpl::GetColorReplacedBitmapN(*pDisabledBackgroundBitmap,
5941                                                 Color::GetColor(COLOR_ID_MAGENTA), __buttonTransBackgroundColor[_BUTTON_STATUS_DISABLED]);
5942                                 pButton->SetBackgroundBitmap(_BUTTON_STATUS_DISABLED, *pColorReplacedBitmap);
5943
5944                                 delete pColorReplacedBitmap;
5945                                 delete pDisabledBackgroundBitmap;
5946                         }
5947
5948                         if (pPressedBackgroundBitmap)
5949                         {
5950                                 pColorReplacedBitmap = _BitmapImpl::GetColorReplacedBitmapN(*pPressedBackgroundBitmap,
5951                                                 Color::GetColor(COLOR_ID_MAGENTA), __buttonTransBackgroundColor[_BUTTON_STATUS_PRESSED]);
5952                                 pButton->SetBackgroundBitmap(_BUTTON_STATUS_PRESSED, *pColorReplacedBitmap);
5953
5954                                 delete pColorReplacedBitmap;
5955                                 delete pPressedBackgroundBitmap;
5956                         }
5957
5958                         if (pHighlightedBackgroundBitmap)
5959                         {
5960                                 pColorReplacedBitmap = _BitmapImpl::GetColorReplacedBitmapN(*pHighlightedBackgroundBitmap,
5961                                                 Color::GetColor(COLOR_ID_MAGENTA), __buttonTransBackgroundColor[_BUTTON_STATUS_HIGHLIGHTED]);
5962                                 pButton->SetBackgroundBitmap(_BUTTON_STATUS_HIGHLIGHTED, *pColorReplacedBitmap);
5963
5964                                 delete pColorReplacedBitmap;
5965                                 delete pHighlightedBackgroundBitmap;
5966                         }
5967                 }
5968                 else
5969                 {
5970                         pButton->SetTextColor(_BUTTON_STATUS_NORMAL, __buttonTextColor[_BUTTON_STATUS_NORMAL]);
5971                         pButton->SetTextColor(_BUTTON_STATUS_DISABLED, __buttonTextColor[_BUTTON_STATUS_DISABLED]);
5972                         pButton->SetTextColor(_BUTTON_STATUS_PRESSED, __buttonTextColor[_BUTTON_STATUS_PRESSED]);
5973                         pButton->SetTextColor(_BUTTON_STATUS_HIGHLIGHTED, __buttonTextColor[_BUTTON_STATUS_HIGHLIGHTED]);
5974
5975                         if (pNormalBackgroundBitmap)
5976                         {
5977                                 pColorReplacedBitmap = _BitmapImpl::GetColorReplacedBitmapN(*pNormalBackgroundBitmap,
5978                                                 Color::GetColor(COLOR_ID_MAGENTA), __buttonBackgroundColor[_BUTTON_STATUS_NORMAL]);
5979                                 pButton->SetBackgroundBitmap(_BUTTON_STATUS_NORMAL, *pColorReplacedBitmap);
5980
5981                                 delete pColorReplacedBitmap;
5982                                 delete pNormalBackgroundBitmap;
5983                         }
5984
5985                         if (pDisabledBackgroundBitmap)
5986                         {
5987                                 pColorReplacedBitmap = _BitmapImpl::GetColorReplacedBitmapN(*pDisabledBackgroundBitmap,
5988                                                 Color::GetColor(COLOR_ID_MAGENTA), __buttonBackgroundColor[_BUTTON_STATUS_DISABLED]);
5989                                 pButton->SetBackgroundBitmap(_BUTTON_STATUS_DISABLED, *pColorReplacedBitmap);
5990
5991                                 delete pColorReplacedBitmap;
5992                                 delete pDisabledBackgroundBitmap;
5993                         }
5994
5995                         if (pPressedBackgroundBitmap)
5996                         {
5997                                 pColorReplacedBitmap = _BitmapImpl::GetColorReplacedBitmapN(*pPressedBackgroundBitmap,
5998                                                 Color::GetColor(COLOR_ID_MAGENTA), __buttonBackgroundColor[_BUTTON_STATUS_PRESSED]);
5999                                 pButton->SetBackgroundBitmap(_BUTTON_STATUS_PRESSED, *pColorReplacedBitmap);
6000
6001                                 delete pColorReplacedBitmap;
6002                                 delete pPressedBackgroundBitmap;
6003                         }
6004
6005                         if (pHighlightedBackgroundBitmap)
6006                         {
6007                                 pColorReplacedBitmap = _BitmapImpl::GetColorReplacedBitmapN(*pHighlightedBackgroundBitmap,
6008                                                 Color::GetColor(COLOR_ID_MAGENTA), __buttonBackgroundColor[_BUTTON_STATUS_HIGHLIGHTED]);
6009                                 pButton->SetBackgroundBitmap(_BUTTON_STATUS_HIGHLIGHTED, *pColorReplacedBitmap);
6010
6011                                 delete pColorReplacedBitmap;
6012                                 delete pHighlightedBackgroundBitmap;
6013                         }
6014                 }
6015
6016                 if (__style != TOOLBAR_SOFTKEY)
6017                 {
6018                         if (pNormalBackgroundEffectBitmap)
6019                         {
6020                         //      pButton->SetBackgroundEffectBitmap(_BUTTON_STATUS_NORMAL, *pNormalBackgroundEffectBitmap);
6021                                 delete pNormalBackgroundEffectBitmap;
6022                         }
6023                         if (pDisabledBackgroundEffectBitmap)
6024                         {
6025                         //      pButton->SetBackgroundEffectBitmap(_BUTTON_STATUS_DISABLED, *pDisabledBackgroundEffectBitmap);
6026                                 delete pDisabledBackgroundEffectBitmap;
6027                         }
6028                         if (pPressedBackgroundEffectBitmap)
6029                         {
6030                                 pButton->SetBackgroundEffectBitmap(_BUTTON_STATUS_PRESSED, *pPressedBackgroundEffectBitmap);
6031                                 delete pPressedBackgroundEffectBitmap;
6032                         }
6033                         if (pHighlightedBackgroundEffectBitmap)
6034                         {
6035                         //      pButton->SetBackgroundEffectBitmap(_BUTTON_STATUS_HIGHLIGHTED, *pHighlightedBackgroundEffectBitmap);
6036                                 delete pHighlightedBackgroundEffectBitmap;
6037                         }
6038                 }
6039
6040                 if (__style == TOOLBAR_HEADER_SEGMENTED_WITH_TITLE || __style == TOOLBAR_TAB_WITH_TITLE)
6041                 {
6042                         Bitmap* pSubTitleEffectBitmap = null;
6043                         Bitmap* pReColorSubTitleEffectBitmap = null;
6044
6045                         Color subTitleEffectColor;
6046
6047                         GET_BITMAP_CONFIG_N(HEADER::SUB_TITLE_EFFECT, BITMAP_PIXEL_FORMAT_ARGB8888, pSubTitleEffectBitmap);
6048                         GET_COLOR_CONFIG(HEADER::SUB_TITLE_EFFECT_NORMAL, subTitleEffectColor);
6049
6050                         pReColorSubTitleEffectBitmap = _BitmapImpl::GetColorReplacedBitmapN(*pSubTitleEffectBitmap, Color::GetColor(COLOR_ID_MAGENTA), subTitleEffectColor);
6051
6052                         if (pReColorSubTitleEffectBitmap)
6053                         {
6054                                 pButton->SetSubTitleEffectBitmap(*pReColorSubTitleEffectBitmap);
6055                         }
6056
6057                         delete pSubTitleEffectBitmap;
6058                         delete pReColorSubTitleEffectBitmap;
6059                 }
6060         }
6061         else if (TOOLBAR_ITEM == buttonType)
6062         {
6063                 Bitmap* pNormalBackgroundBitmap = null;
6064                 Bitmap* pDisabledBackgroundBitmap = null;
6065                 Bitmap* pPressedBackgroundBitmap = null;
6066                 Bitmap* pHighlightedBackgroundBitmap = null;
6067                 Bitmap* pSelectedBackgroundBitmap = null;
6068
6069                 Bitmap* pNormalBackgroundEffectBitmap = null;
6070                 Bitmap* pDisabledBackgroundEffectBitmap = null;
6071                 Bitmap* pPressedBackgroundEffectBitmap = null;
6072                 Bitmap* pHighlightedBackgroundEffectBitmap = null;
6073                 Bitmap* pSelectedBackgroundEffectBitmap = null;
6074
6075                 Bitmap* pColorReplacedBitmap = null;
6076
6077                 bool customTheme = false;
6078
6079                 if (__style == TOOLBAR_TEXT || __style == TOOLBAR_ICON || __style == TOOLBAR_ICON_TEXT || __style == TOOLBAR_COMMAND)
6080                 {
6081                         if (__header == true)
6082                         {
6083                                 if (__transparent == true)
6084                                 {
6085                                         GET_BITMAP_CONFIG_N(HEADER::BUTTON_ITEM_TRANSLUCENT_BG_NORMAL, BITMAP_PIXEL_FORMAT_ARGB8888, pNormalBackgroundBitmap);
6086                                         GET_BITMAP_CONFIG_N(HEADER::BUTTON_ITEM_TRANSLUCENT_BG_DISABLED, BITMAP_PIXEL_FORMAT_ARGB8888, pDisabledBackgroundBitmap);
6087                                         GET_BITMAP_CONFIG_N(HEADER::BUTTON_ITEM_TRANSLUCENT_BG_PRESSED, BITMAP_PIXEL_FORMAT_ARGB8888, pPressedBackgroundBitmap);
6088                                         GET_BITMAP_CONFIG_N(HEADER::BUTTON_ITEM_TRANSLUCENT_BG_HIGHLIGHTED, BITMAP_PIXEL_FORMAT_ARGB8888, pHighlightedBackgroundBitmap);
6089
6090                                         customTheme = IS_CUSTOM_BITMAP(HEADER::BUTTON_ITEM_TRANSLUCENT_BG_NORMAL);
6091                                         if (customTheme == false)
6092                                         {
6093                                                 GET_BITMAP_CONFIG_N(HEADER::BUTTON_ITEM_TRANSLUCENT_BG_EFFECT_NORMAL, BITMAP_PIXEL_FORMAT_ARGB8888, pNormalBackgroundEffectBitmap);
6094                                         }
6095
6096                                         customTheme = IS_CUSTOM_BITMAP(HEADER::BUTTON_ITEM_TRANSLUCENT_BG_DISABLED);
6097                                         if (customTheme == false)
6098                                         {
6099                                                 GET_BITMAP_CONFIG_N(HEADER::BUTTON_ITEM_TRANSLUCENT_BG_EFFECT_NORMAL, BITMAP_PIXEL_FORMAT_ARGB8888, pDisabledBackgroundEffectBitmap);
6100                                         }
6101
6102                                         customTheme = IS_CUSTOM_BITMAP(HEADER::BUTTON_ITEM_TRANSLUCENT_BG_PRESSED);
6103                                         if (customTheme == false)
6104                                         {
6105                                                 GET_BITMAP_CONFIG_N(HEADER::BUTTON_ITEM_TRANSLUCENT_BG_EFFECT_PRESSED, BITMAP_PIXEL_FORMAT_ARGB8888, pPressedBackgroundEffectBitmap);
6106                                         }
6107
6108                                         customTheme = IS_CUSTOM_BITMAP(HEADER::BUTTON_ITEM_TRANSLUCENT_BG_HIGHLIGHTED);
6109                                         if (customTheme == false)
6110                                         {
6111                                                 GET_BITMAP_CONFIG_N(HEADER::BUTTON_ITEM_TRANSLUCENT_BG_EFFECT_NORMAL, BITMAP_PIXEL_FORMAT_ARGB8888, pHighlightedBackgroundEffectBitmap);
6112                                         }
6113                                 }
6114                                 else
6115                                 {
6116                                         GET_BITMAP_CONFIG_N(HEADER::BUTTON_ITEM_BG_NORMAL, BITMAP_PIXEL_FORMAT_ARGB8888, pNormalBackgroundBitmap);
6117                                         GET_BITMAP_CONFIG_N(HEADER::BUTTON_ITEM_BG_DISABLED, BITMAP_PIXEL_FORMAT_ARGB8888, pDisabledBackgroundBitmap);
6118                                         GET_BITMAP_CONFIG_N(HEADER::BUTTON_ITEM_BG_PRESSED, BITMAP_PIXEL_FORMAT_ARGB8888, pPressedBackgroundBitmap);
6119                                         GET_BITMAP_CONFIG_N(HEADER::BUTTON_ITEM_BG_HIGHLIGHTED, BITMAP_PIXEL_FORMAT_ARGB8888, pHighlightedBackgroundBitmap);
6120
6121                                         customTheme = IS_CUSTOM_BITMAP(HEADER::BUTTON_ITEM_BG_NORMAL);
6122                                         if (customTheme == false)
6123                                         {
6124                                                 GET_BITMAP_CONFIG_N(HEADER::BUTTON_ITEM_BG_EFFECT_NORMAL, BITMAP_PIXEL_FORMAT_ARGB8888, pNormalBackgroundEffectBitmap);
6125                                         }
6126
6127                                         customTheme = IS_CUSTOM_BITMAP(HEADER::BUTTON_ITEM_BG_DISABLED);
6128                                         if (customTheme == false)
6129                                         {
6130                                                 GET_BITMAP_CONFIG_N(HEADER::BUTTON_ITEM_BG_EFFECT_NORMAL, BITMAP_PIXEL_FORMAT_ARGB8888, pDisabledBackgroundEffectBitmap);
6131                                         }
6132
6133                                         customTheme = IS_CUSTOM_BITMAP(HEADER::BUTTON_ITEM_BG_PRESSED);
6134                                         if (customTheme == false)
6135                                         {
6136                                                 GET_BITMAP_CONFIG_N(HEADER::BUTTON_ITEM_BG_EFFECT_PRESSED, BITMAP_PIXEL_FORMAT_ARGB8888, pPressedBackgroundEffectBitmap);
6137                                         }
6138
6139                                         customTheme = IS_CUSTOM_BITMAP(HEADER::BUTTON_ITEM_BG_HIGHLIGHTED);
6140                                         if (customTheme == false)
6141                                         {
6142                                                 GET_BITMAP_CONFIG_N(HEADER::BUTTON_ITEM_BG_EFFECT_NORMAL, BITMAP_PIXEL_FORMAT_ARGB8888, pHighlightedBackgroundEffectBitmap);
6143                                         }
6144                                 }
6145                         }
6146                         else
6147                         {
6148                                 if (__transparent == true)
6149                                 {
6150                                         GET_BITMAP_CONFIG_N(FOOTER::BUTTON_ITEM_TRANSLUCENT_BG_NORMAL, BITMAP_PIXEL_FORMAT_ARGB8888, pNormalBackgroundBitmap);
6151                                         GET_BITMAP_CONFIG_N(FOOTER::BUTTON_ITEM_TRANSLUCENT_BG_DISABLED, BITMAP_PIXEL_FORMAT_ARGB8888, pDisabledBackgroundBitmap);
6152                                         GET_BITMAP_CONFIG_N(FOOTER::BUTTON_ITEM_TRANSLUCENT_BG_PRESSED, BITMAP_PIXEL_FORMAT_ARGB8888, pPressedBackgroundBitmap);
6153                                         GET_BITMAP_CONFIG_N(FOOTER::BUTTON_ITEM_TRANSLUCENT_BG_HIGHLIGHTED, BITMAP_PIXEL_FORMAT_ARGB8888, pHighlightedBackgroundBitmap);
6154
6155                                         customTheme = IS_CUSTOM_BITMAP(FOOTER::BUTTON_ITEM_TRANSLUCENT_BG_NORMAL);
6156                                         if (customTheme == false)
6157                                         {
6158                                                 GET_BITMAP_CONFIG_N(FOOTER::BUTTON_ITEM_TRANSLUCENT_BG_EFFECT_NORMAL, BITMAP_PIXEL_FORMAT_ARGB8888, pNormalBackgroundEffectBitmap);
6159                                         }
6160
6161                                         customTheme = IS_CUSTOM_BITMAP(FOOTER::BUTTON_ITEM_TRANSLUCENT_BG_DISABLED);
6162                                         if (customTheme == false)
6163                                         {
6164                                                 GET_BITMAP_CONFIG_N(FOOTER::BUTTON_ITEM_TRANSLUCENT_BG_EFFECT_NORMAL, BITMAP_PIXEL_FORMAT_ARGB8888, pDisabledBackgroundEffectBitmap);
6165                                         }
6166
6167                                         customTheme = IS_CUSTOM_BITMAP(FOOTER::BUTTON_ITEM_TRANSLUCENT_BG_PRESSED);
6168                                         if (customTheme == false)
6169                                         {
6170                                                 GET_BITMAP_CONFIG_N(FOOTER::BUTTON_ITEM_TRANSLUCENT_BG_EFFECT_PRESSED, BITMAP_PIXEL_FORMAT_ARGB8888, pPressedBackgroundEffectBitmap);
6171                                         }
6172
6173                                         customTheme = IS_CUSTOM_BITMAP(FOOTER::BUTTON_ITEM_TRANSLUCENT_BG_HIGHLIGHTED);
6174                                         if (customTheme == false)
6175                                         {
6176                                                 GET_BITMAP_CONFIG_N(FOOTER::BUTTON_ITEM_TRANSLUCENT_BG_EFFECT_NORMAL, BITMAP_PIXEL_FORMAT_ARGB8888, pHighlightedBackgroundEffectBitmap);
6177                                         }
6178                                 }
6179                                 else
6180                                 {
6181                                         GET_BITMAP_CONFIG_N(FOOTER::BUTTON_ITEM_BG_NORMAL, BITMAP_PIXEL_FORMAT_ARGB8888, pNormalBackgroundBitmap);
6182                                         GET_BITMAP_CONFIG_N(FOOTER::BUTTON_ITEM_BG_DISABLED, BITMAP_PIXEL_FORMAT_ARGB8888, pDisabledBackgroundBitmap);
6183                                         GET_BITMAP_CONFIG_N(FOOTER::BUTTON_ITEM_BG_PRESSED, BITMAP_PIXEL_FORMAT_ARGB8888, pPressedBackgroundBitmap);
6184                                         GET_BITMAP_CONFIG_N(FOOTER::BUTTON_ITEM_BG_HIGHLIGHTED, BITMAP_PIXEL_FORMAT_ARGB8888, pHighlightedBackgroundBitmap);
6185
6186                                         customTheme = IS_CUSTOM_BITMAP(FOOTER::BUTTON_ITEM_BG_NORMAL);
6187                                         if (customTheme == false)
6188                                         {
6189                                                 GET_BITMAP_CONFIG_N(FOOTER::BUTTON_ITEM_BG_EFFECT_NORMAL, BITMAP_PIXEL_FORMAT_ARGB8888, pNormalBackgroundEffectBitmap);
6190                                         }
6191
6192                                         customTheme = IS_CUSTOM_BITMAP(FOOTER::BUTTON_ITEM_BG_DISABLED);
6193                                         if (customTheme == false)
6194                                         {
6195                                                 GET_BITMAP_CONFIG_N(FOOTER::BUTTON_ITEM_BG_EFFECT_NORMAL, BITMAP_PIXEL_FORMAT_ARGB8888, pDisabledBackgroundEffectBitmap);
6196                                         }
6197
6198                                         customTheme = IS_CUSTOM_BITMAP(FOOTER::BUTTON_ITEM_BG_PRESSED);
6199                                         if (customTheme == false)
6200                                         {
6201                                                 GET_BITMAP_CONFIG_N(FOOTER::BUTTON_ITEM_BG_EFFECT_PRESSED, BITMAP_PIXEL_FORMAT_ARGB8888, pPressedBackgroundEffectBitmap);
6202                                         }
6203
6204                                         customTheme = IS_CUSTOM_BITMAP(FOOTER::BUTTON_ITEM_BG_HIGHLIGHTED);
6205                                         if (customTheme == false)
6206                                         {
6207                                                 GET_BITMAP_CONFIG_N(FOOTER::BUTTON_ITEM_BG_EFFECT_NORMAL, BITMAP_PIXEL_FORMAT_ARGB8888, pHighlightedBackgroundEffectBitmap);
6208                                         }
6209                                 }
6210                         }
6211                 }
6212                 else if (__style == TOOLBAR_HEADER_SEGMENTED || __style == TOOLBAR_HEADER_SEGMENTED_WITH_TITLE
6213                                 || __style == TOOLBAR_SEGMENTED || __style == TOOLBAR_TITLE)
6214                 {
6215                         if (__header == true)
6216                         {
6217                                 if (__transparent == true)
6218                                 {
6219                                         GET_BITMAP_CONFIG_N(HEADER::SEGMENTED_ITEM_TRANSLUCENT_BG_NORMAL, BITMAP_PIXEL_FORMAT_ARGB8888, pNormalBackgroundBitmap);
6220                                         GET_BITMAP_CONFIG_N(HEADER::SEGMENTED_ITEM_TRANSLUCENT_BG_DISABLED, BITMAP_PIXEL_FORMAT_ARGB8888, pDisabledBackgroundBitmap);
6221                                         GET_BITMAP_CONFIG_N(HEADER::SEGMENTED_ITEM_TRANSLUCENT_BG_PRESSED, BITMAP_PIXEL_FORMAT_ARGB8888, pPressedBackgroundBitmap);
6222                                         GET_BITMAP_CONFIG_N(HEADER::SEGMENTED_ITEM_TRANSLUCENT_BG_HIGHLIGHTED, BITMAP_PIXEL_FORMAT_ARGB8888, pHighlightedBackgroundBitmap);
6223                                         GET_BITMAP_CONFIG_N(HEADER::SEGMENTED_ITEM_TRANSLUCENT_BG_SELECTED, BITMAP_PIXEL_FORMAT_ARGB8888, pSelectedBackgroundBitmap);
6224
6225
6226                                         customTheme = IS_CUSTOM_BITMAP(HEADER::SEGMENTED_ITEM_TRANSLUCENT_BG_NORMAL);
6227                                         if (customTheme == false)
6228                                         {
6229                                                 GET_BITMAP_CONFIG_N(HEADER::SEGMENTED_ITEM_TRANSLUCENT_BG_EFFECT_NORMAL, BITMAP_PIXEL_FORMAT_ARGB8888, pNormalBackgroundEffectBitmap);
6230                                         }
6231
6232                                         customTheme = IS_CUSTOM_BITMAP(HEADER::SEGMENTED_ITEM_TRANSLUCENT_BG_DISABLED);
6233                                         if (customTheme == false)
6234                                         {
6235                                                 GET_BITMAP_CONFIG_N(HEADER::SEGMENTED_ITEM_TRANSLUCENT_BG_EFFECT_NORMAL, BITMAP_PIXEL_FORMAT_ARGB8888, pDisabledBackgroundEffectBitmap);
6236                                         }
6237
6238                                         customTheme = IS_CUSTOM_BITMAP(HEADER::SEGMENTED_ITEM_TRANSLUCENT_BG_PRESSED);
6239                                         if (customTheme == false)
6240                                         {
6241                                                 GET_BITMAP_CONFIG_N(HEADER::SEGMENTED_ITEM_TRANSLUCENT_BG_EFFECT_PRESSED, BITMAP_PIXEL_FORMAT_ARGB8888, pPressedBackgroundEffectBitmap);
6242                                         }
6243
6244                                         customTheme = IS_CUSTOM_BITMAP(HEADER::SEGMENTED_ITEM_TRANSLUCENT_BG_HIGHLIGHTED);
6245                                         if (customTheme == false)
6246                                         {
6247                                                 GET_BITMAP_CONFIG_N(HEADER::SEGMENTED_ITEM_TRANSLUCENT_BG_EFFECT_NORMAL, BITMAP_PIXEL_FORMAT_ARGB8888, pHighlightedBackgroundEffectBitmap);
6248                                         }
6249
6250                                         customTheme = IS_CUSTOM_BITMAP(HEADER::SEGMENTED_ITEM_TRANSLUCENT_BG_SELECTED);
6251                                         if (customTheme == false)
6252                                         {
6253                                                 GET_BITMAP_CONFIG_N(HEADER::SEGMENTED_ITEM_TRANSLUCENT_BG_EFFECT_NORMAL, BITMAP_PIXEL_FORMAT_ARGB8888, pSelectedBackgroundEffectBitmap);
6254                                         }
6255                                 }
6256                                 else
6257                                 {
6258                                         GET_BITMAP_CONFIG_N(HEADER::SEGMENTED_ITEM_BG_NORMAL, BITMAP_PIXEL_FORMAT_ARGB8888, pNormalBackgroundBitmap);
6259                                         GET_BITMAP_CONFIG_N(HEADER::SEGMENTED_ITEM_BG_DISABLED, BITMAP_PIXEL_FORMAT_ARGB8888, pDisabledBackgroundBitmap);
6260                                         GET_BITMAP_CONFIG_N(HEADER::SEGMENTED_ITEM_BG_PRESSED, BITMAP_PIXEL_FORMAT_ARGB8888, pPressedBackgroundBitmap);
6261                                         GET_BITMAP_CONFIG_N(HEADER::SEGMENTED_ITEM_BG_HIGHLIGHTED, BITMAP_PIXEL_FORMAT_ARGB8888, pHighlightedBackgroundBitmap);
6262                                         GET_BITMAP_CONFIG_N(HEADER::SEGMENTED_ITEM_BG_SELECTED, BITMAP_PIXEL_FORMAT_ARGB8888, pSelectedBackgroundBitmap);
6263
6264                                         customTheme = IS_CUSTOM_BITMAP(HEADER::SEGMENTED_ITEM_BG_NORMAL);
6265                                         if (customTheme == false)
6266                                         {
6267                                                 GET_BITMAP_CONFIG_N(HEADER::SEGMENTED_ITEM_BG_EFFECT_NORMAL, BITMAP_PIXEL_FORMAT_ARGB8888, pNormalBackgroundEffectBitmap);
6268                                         }
6269
6270                                         customTheme = IS_CUSTOM_BITMAP(HEADER::SEGMENTED_ITEM_BG_DISABLED);
6271                                         if (customTheme == false)
6272                                         {
6273                                                 GET_BITMAP_CONFIG_N(HEADER::SEGMENTED_ITEM_BG_EFFECT_NORMAL, BITMAP_PIXEL_FORMAT_ARGB8888, pDisabledBackgroundEffectBitmap);
6274                                         }
6275
6276                                         customTheme = IS_CUSTOM_BITMAP(HEADER::SEGMENTED_ITEM_BG_PRESSED);
6277                                         if (customTheme == false)
6278                                         {
6279                                                 GET_BITMAP_CONFIG_N(HEADER::SEGMENTED_ITEM_BG_EFFECT_PRESSED, BITMAP_PIXEL_FORMAT_ARGB8888, pPressedBackgroundEffectBitmap);
6280                                         }
6281
6282                                         customTheme = IS_CUSTOM_BITMAP(HEADER::SEGMENTED_ITEM_BG_HIGHLIGHTED);
6283                                         if (customTheme == false)
6284                                         {
6285                                                 GET_BITMAP_CONFIG_N(HEADER::SEGMENTED_ITEM_BG_EFFECT_NORMAL, BITMAP_PIXEL_FORMAT_ARGB8888, pHighlightedBackgroundEffectBitmap);
6286                                         }
6287
6288                                         customTheme = IS_CUSTOM_BITMAP(HEADER::SEGMENTED_ITEM_BG_SELECTED);
6289                                         if (customTheme == false)
6290                                         {
6291                                                 GET_BITMAP_CONFIG_N(HEADER::SEGMENTED_ITEM_BG_EFFECT_NORMAL, BITMAP_PIXEL_FORMAT_ARGB8888, pSelectedBackgroundEffectBitmap);
6292                                         }
6293                                 }
6294                         }
6295                         else
6296                         {
6297                                 if (__transparent == true)
6298                                 {
6299                                         GET_BITMAP_CONFIG_N(FOOTER::SEGMENTED_ITEM_TRANSLUCENT_BG_NORMAL, BITMAP_PIXEL_FORMAT_ARGB8888, pNormalBackgroundBitmap);
6300                                         GET_BITMAP_CONFIG_N(FOOTER::SEGMENTED_ITEM_TRANSLUCENT_BG_DISABLED, BITMAP_PIXEL_FORMAT_ARGB8888, pDisabledBackgroundBitmap);
6301                                         GET_BITMAP_CONFIG_N(FOOTER::SEGMENTED_ITEM_TRANSLUCENT_BG_PRESSED, BITMAP_PIXEL_FORMAT_ARGB8888, pPressedBackgroundBitmap);
6302                                         GET_BITMAP_CONFIG_N(FOOTER::SEGMENTED_ITEM_TRANSLUCENT_BG_HIGHLIGHTED, BITMAP_PIXEL_FORMAT_ARGB8888, pHighlightedBackgroundBitmap);
6303                                         GET_BITMAP_CONFIG_N(FOOTER::SEGMENTED_ITEM_TRANSLUCENT_BG_SELECTED, BITMAP_PIXEL_FORMAT_ARGB8888, pSelectedBackgroundBitmap);
6304
6305                                         customTheme = IS_CUSTOM_BITMAP(HEADER::SEGMENTED_ITEM_TRANSLUCENT_BG_NORMAL);
6306                                         if (customTheme == false)
6307                                         {
6308                                                 GET_BITMAP_CONFIG_N(HEADER::SEGMENTED_ITEM_TRANSLUCENT_BG_EFFECT_NORMAL, BITMAP_PIXEL_FORMAT_ARGB8888, pNormalBackgroundEffectBitmap);
6309                                         }
6310
6311                                         customTheme = IS_CUSTOM_BITMAP(HEADER::SEGMENTED_ITEM_TRANSLUCENT_BG_DISABLED);
6312                                         if (customTheme == false)
6313                                         {
6314                                                 GET_BITMAP_CONFIG_N(HEADER::SEGMENTED_ITEM_TRANSLUCENT_BG_EFFECT_NORMAL, BITMAP_PIXEL_FORMAT_ARGB8888, pDisabledBackgroundEffectBitmap);
6315                                         }
6316
6317                                         customTheme = IS_CUSTOM_BITMAP(HEADER::SEGMENTED_ITEM_TRANSLUCENT_BG_PRESSED);
6318                                         if (customTheme == false)
6319                                         {
6320                                                 GET_BITMAP_CONFIG_N(HEADER::SEGMENTED_ITEM_TRANSLUCENT_BG_EFFECT_PRESSED, BITMAP_PIXEL_FORMAT_ARGB8888, pPressedBackgroundEffectBitmap);
6321                                         }
6322
6323                                         customTheme = IS_CUSTOM_BITMAP(HEADER::SEGMENTED_ITEM_TRANSLUCENT_BG_HIGHLIGHTED);
6324                                         if (customTheme == false)
6325                                         {
6326                                                 GET_BITMAP_CONFIG_N(HEADER::SEGMENTED_ITEM_TRANSLUCENT_BG_EFFECT_NORMAL, BITMAP_PIXEL_FORMAT_ARGB8888, pHighlightedBackgroundEffectBitmap);
6327                                         }
6328
6329                                         customTheme = IS_CUSTOM_BITMAP(HEADER::SEGMENTED_ITEM_TRANSLUCENT_BG_SELECTED);
6330                                         if (customTheme == false)
6331                                         {
6332                                                 GET_BITMAP_CONFIG_N(HEADER::SEGMENTED_ITEM_TRANSLUCENT_BG_EFFECT_NORMAL, BITMAP_PIXEL_FORMAT_ARGB8888, pSelectedBackgroundEffectBitmap);
6333                                         }
6334                                 }
6335                                 else
6336                                 {
6337                                         GET_BITMAP_CONFIG_N(FOOTER::SEGMENTED_ITEM_BG_NORMAL, BITMAP_PIXEL_FORMAT_ARGB8888, pNormalBackgroundBitmap);
6338                                         GET_BITMAP_CONFIG_N(FOOTER::SEGMENTED_ITEM_BG_DISABLED, BITMAP_PIXEL_FORMAT_ARGB8888, pDisabledBackgroundBitmap);
6339                                         GET_BITMAP_CONFIG_N(FOOTER::SEGMENTED_ITEM_BG_PRESSED, BITMAP_PIXEL_FORMAT_ARGB8888, pPressedBackgroundBitmap);
6340                                         GET_BITMAP_CONFIG_N(FOOTER::SEGMENTED_ITEM_BG_HIGHLIGHTED, BITMAP_PIXEL_FORMAT_ARGB8888, pHighlightedBackgroundBitmap);
6341                                         GET_BITMAP_CONFIG_N(FOOTER::SEGMENTED_ITEM_BG_SELECTED, BITMAP_PIXEL_FORMAT_ARGB8888, pSelectedBackgroundBitmap);
6342
6343                                         customTheme = IS_CUSTOM_BITMAP(HEADER::SEGMENTED_ITEM_BG_NORMAL);
6344                                         if (customTheme == false)
6345                                         {
6346                                                 GET_BITMAP_CONFIG_N(HEADER::SEGMENTED_ITEM_BG_EFFECT_NORMAL, BITMAP_PIXEL_FORMAT_ARGB8888, pNormalBackgroundEffectBitmap);
6347                                         }
6348
6349                                         customTheme = IS_CUSTOM_BITMAP(HEADER::SEGMENTED_ITEM_BG_DISABLED);
6350                                         if (customTheme == false)
6351                                         {
6352                                                 GET_BITMAP_CONFIG_N(HEADER::SEGMENTED_ITEM_BG_EFFECT_NORMAL, BITMAP_PIXEL_FORMAT_ARGB8888, pDisabledBackgroundEffectBitmap);
6353                                         }
6354
6355                                         customTheme = IS_CUSTOM_BITMAP(HEADER::SEGMENTED_ITEM_BG_PRESSED);
6356                                         if (customTheme == false)
6357                                         {
6358                                                 GET_BITMAP_CONFIG_N(HEADER::SEGMENTED_ITEM_BG_EFFECT_PRESSED, BITMAP_PIXEL_FORMAT_ARGB8888, pPressedBackgroundEffectBitmap);
6359                                         }
6360
6361                                         customTheme = IS_CUSTOM_BITMAP(HEADER::SEGMENTED_ITEM_BG_HIGHLIGHTED);
6362                                         if (customTheme == false)
6363                                         {
6364                                                 GET_BITMAP_CONFIG_N(HEADER::SEGMENTED_ITEM_BG_EFFECT_NORMAL, BITMAP_PIXEL_FORMAT_ARGB8888, pHighlightedBackgroundEffectBitmap);
6365                                         }
6366
6367                                         customTheme = IS_CUSTOM_BITMAP(HEADER::SEGMENTED_ITEM_BG_SELECTED);
6368                                         if (customTheme == false)
6369                                         {
6370                                                 GET_BITMAP_CONFIG_N(HEADER::SEGMENTED_ITEM_BG_EFFECT_NORMAL, BITMAP_PIXEL_FORMAT_ARGB8888, pSelectedBackgroundEffectBitmap);
6371                                         }
6372                                 }
6373                         }
6374                 }
6375                 else if (__style == TOOLBAR_TAB || __style == TOOLBAR_TAB_WITH_TITLE || __style == TOOLBAR_TAB_LARGE)
6376                 {
6377                         if (__header == true)
6378                         {
6379                                 if (__transparent == true)
6380                                 {
6381                                         GET_BITMAP_CONFIG_N(HEADER::TAB_ITEM_TRANSLUCENT_BG_NORMAL, BITMAP_PIXEL_FORMAT_ARGB8888, pNormalBackgroundBitmap);
6382                                         GET_BITMAP_CONFIG_N(HEADER::TAB_ITEM_TRANSLUCENT_BG_DISABLED, BITMAP_PIXEL_FORMAT_ARGB8888, pDisabledBackgroundBitmap);
6383                                         GET_BITMAP_CONFIG_N(HEADER::TAB_ITEM_TRANSLUCENT_BG_PRESSED, BITMAP_PIXEL_FORMAT_ARGB8888, pPressedBackgroundBitmap);
6384                                         GET_BITMAP_CONFIG_N(HEADER::TAB_ITEM_TRANSLUCENT_BG_HIGHLIGHTED, BITMAP_PIXEL_FORMAT_ARGB8888, pHighlightedBackgroundBitmap);
6385                                         GET_BITMAP_CONFIG_N(HEADER::TAB_ITEM_TRANSLUCENT_BG_SELECTED, BITMAP_PIXEL_FORMAT_ARGB8888, pSelectedBackgroundBitmap);
6386
6387                                         customTheme = IS_CUSTOM_BITMAP(HEADER::TAB_ITEM_TRANSLUCENT_BG_NORMAL);
6388                                         if (customTheme == false)
6389                                         {
6390                                                 GET_BITMAP_CONFIG_N(HEADER::TAB_ITEM_TRANSLUCENT_BG_EFFECT_NORMAL, BITMAP_PIXEL_FORMAT_ARGB8888, pNormalBackgroundEffectBitmap);
6391                                         }
6392
6393                                         customTheme = IS_CUSTOM_BITMAP(HEADER::TAB_ITEM_TRANSLUCENT_BG_DISABLED);
6394                                         if (customTheme == false)
6395                                         {
6396                                                 GET_BITMAP_CONFIG_N(HEADER::TAB_ITEM_TRANSLUCENT_BG_EFFECT_NORMAL, BITMAP_PIXEL_FORMAT_ARGB8888, pDisabledBackgroundEffectBitmap);
6397                                         }
6398
6399                                         customTheme = IS_CUSTOM_BITMAP(HEADER::TAB_ITEM_TRANSLUCENT_BG_PRESSED);
6400                                         if (customTheme == false)
6401                                         {
6402                                                 GET_BITMAP_CONFIG_N(HEADER::TAB_ITEM_TRANSLUCENT_BG_EFFECT_PRESSED, BITMAP_PIXEL_FORMAT_ARGB8888, pPressedBackgroundEffectBitmap);
6403                                         }
6404
6405                                         customTheme = IS_CUSTOM_BITMAP(HEADER::TAB_ITEM_TRANSLUCENT_BG_HIGHLIGHTED);
6406                                         if (customTheme == false)
6407                                         {
6408                                                 GET_BITMAP_CONFIG_N(HEADER::TAB_ITEM_TRANSLUCENT_BG_EFFECT_NORMAL, BITMAP_PIXEL_FORMAT_ARGB8888, pHighlightedBackgroundEffectBitmap);
6409                                         }
6410
6411                                         customTheme = IS_CUSTOM_BITMAP(HEADER::TAB_ITEM_TRANSLUCENT_BG_SELECTED);
6412                                         if (customTheme == false)
6413                                         {
6414                                                 GET_BITMAP_CONFIG_N(HEADER::TAB_ITEM_TRANSLUCENT_BG_EFFECT_NORMAL, BITMAP_PIXEL_FORMAT_ARGB8888, pSelectedBackgroundEffectBitmap);
6415                                         }
6416                                 }
6417                                 else
6418                                 {
6419                                         GET_BITMAP_CONFIG_N(HEADER::TAB_ITEM_BG_NORMAL, BITMAP_PIXEL_FORMAT_ARGB8888, pNormalBackgroundBitmap);
6420                                         GET_BITMAP_CONFIG_N(HEADER::TAB_ITEM_BG_DISABLED, BITMAP_PIXEL_FORMAT_ARGB8888, pDisabledBackgroundBitmap);
6421                                         GET_BITMAP_CONFIG_N(HEADER::TAB_ITEM_BG_PRESSED, BITMAP_PIXEL_FORMAT_ARGB8888, pPressedBackgroundBitmap);
6422                                         GET_BITMAP_CONFIG_N(HEADER::TAB_ITEM_BG_HIGHLIGHTED, BITMAP_PIXEL_FORMAT_ARGB8888, pHighlightedBackgroundBitmap);
6423                                         GET_BITMAP_CONFIG_N(HEADER::TAB_ITEM_BG_SELECTED, BITMAP_PIXEL_FORMAT_ARGB8888, pSelectedBackgroundBitmap);
6424
6425                                         customTheme = IS_CUSTOM_BITMAP(HEADER::TAB_ITEM_BG_NORMAL);
6426                                         if (customTheme == false)
6427                                         {
6428                                                 GET_BITMAP_CONFIG_N(HEADER::TAB_ITEM_BG_EFFECT_NORMAL, BITMAP_PIXEL_FORMAT_ARGB8888, pNormalBackgroundEffectBitmap);
6429                                         }
6430
6431                                         customTheme = IS_CUSTOM_BITMAP(HEADER::TAB_ITEM_BG_DISABLED);
6432                                         if (customTheme == false)
6433                                         {
6434                                                 GET_BITMAP_CONFIG_N(HEADER::TAB_ITEM_BG_EFFECT_NORMAL, BITMAP_PIXEL_FORMAT_ARGB8888, pDisabledBackgroundEffectBitmap);
6435                                         }
6436
6437                                         customTheme = IS_CUSTOM_BITMAP(HEADER::TAB_ITEM_BG_PRESSED);
6438                                         if (customTheme == false)
6439                                         {
6440                                                 GET_BITMAP_CONFIG_N(HEADER::TAB_ITEM_BG_EFFECT_PRESSED, BITMAP_PIXEL_FORMAT_ARGB8888, pPressedBackgroundEffectBitmap);
6441                                         }
6442
6443                                         customTheme = IS_CUSTOM_BITMAP(HEADER::TAB_ITEM_BG_HIGHLIGHTED);
6444                                         if (customTheme == false)
6445                                         {
6446                                                 GET_BITMAP_CONFIG_N(HEADER::TAB_ITEM_BG_EFFECT_NORMAL, BITMAP_PIXEL_FORMAT_ARGB8888, pHighlightedBackgroundEffectBitmap);
6447                                         }
6448
6449                                         customTheme = IS_CUSTOM_BITMAP(HEADER::TAB_ITEM_BG_SELECTED);
6450                                         if (customTheme == false)
6451                                         {
6452                                                 GET_BITMAP_CONFIG_N(HEADER::TAB_ITEM_BG_EFFECT_NORMAL, BITMAP_PIXEL_FORMAT_ARGB8888, pSelectedBackgroundEffectBitmap);
6453                                         }
6454                                 }
6455                         }
6456                         else
6457                         {
6458                                 if (__transparent == true)
6459                                 {
6460                                         GET_BITMAP_CONFIG_N(FOOTER::TAB_ITEM_TRANSLUCENT_BG_NORMAL, BITMAP_PIXEL_FORMAT_ARGB8888, pNormalBackgroundBitmap);
6461                                         GET_BITMAP_CONFIG_N(FOOTER::TAB_ITEM_TRANSLUCENT_BG_DISABLED, BITMAP_PIXEL_FORMAT_ARGB8888, pDisabledBackgroundBitmap);
6462                                         GET_BITMAP_CONFIG_N(FOOTER::TAB_ITEM_TRANSLUCENT_BG_PRESSED, BITMAP_PIXEL_FORMAT_ARGB8888, pPressedBackgroundBitmap);
6463                                         GET_BITMAP_CONFIG_N(FOOTER::TAB_ITEM_TRANSLUCENT_BG_HIGHLIGHTED, BITMAP_PIXEL_FORMAT_ARGB8888, pHighlightedBackgroundBitmap);
6464                                         GET_BITMAP_CONFIG_N(FOOTER::TAB_ITEM_TRANSLUCENT_BG_SELECTED, BITMAP_PIXEL_FORMAT_ARGB8888, pSelectedBackgroundBitmap);
6465
6466                                         customTheme = IS_CUSTOM_BITMAP(HEADER::TAB_ITEM_TRANSLUCENT_BG_NORMAL);
6467                                         if (customTheme == false)
6468                                         {
6469                                                 GET_BITMAP_CONFIG_N(HEADER::TAB_ITEM_TRANSLUCENT_BG_EFFECT_NORMAL, BITMAP_PIXEL_FORMAT_ARGB8888, pNormalBackgroundEffectBitmap);
6470                                         }
6471
6472                                         customTheme = IS_CUSTOM_BITMAP(HEADER::TAB_ITEM_TRANSLUCENT_BG_DISABLED);
6473                                         if (customTheme == false)
6474                                         {
6475                                                 GET_BITMAP_CONFIG_N(HEADER::TAB_ITEM_TRANSLUCENT_BG_EFFECT_NORMAL, BITMAP_PIXEL_FORMAT_ARGB8888, pDisabledBackgroundEffectBitmap);
6476                                         }
6477
6478                                         customTheme = IS_CUSTOM_BITMAP(HEADER::TAB_ITEM_TRANSLUCENT_BG_PRESSED);
6479                                         if (customTheme == false)
6480                                         {
6481                                                 GET_BITMAP_CONFIG_N(HEADER::TAB_ITEM_TRANSLUCENT_BG_EFFECT_PRESSED, BITMAP_PIXEL_FORMAT_ARGB8888, pPressedBackgroundEffectBitmap);
6482                                         }
6483
6484                                         customTheme = IS_CUSTOM_BITMAP(HEADER::TAB_ITEM_TRANSLUCENT_BG_HIGHLIGHTED);
6485                                         if (customTheme == false)
6486                                         {
6487                                                 GET_BITMAP_CONFIG_N(HEADER::TAB_ITEM_TRANSLUCENT_BG_EFFECT_NORMAL, BITMAP_PIXEL_FORMAT_ARGB8888, pHighlightedBackgroundEffectBitmap);
6488                                         }
6489
6490                                         customTheme = IS_CUSTOM_BITMAP(HEADER::TAB_ITEM_TRANSLUCENT_BG_SELECTED);
6491                                         if (customTheme == false)
6492                                         {
6493                                                 GET_BITMAP_CONFIG_N(HEADER::TAB_ITEM_TRANSLUCENT_BG_EFFECT_NORMAL, BITMAP_PIXEL_FORMAT_ARGB8888, pSelectedBackgroundEffectBitmap);
6494                                         }
6495                                 }
6496                                 else
6497                                 {
6498                                         GET_BITMAP_CONFIG_N(FOOTER::TAB_ITEM_BG_NORMAL, BITMAP_PIXEL_FORMAT_ARGB8888, pNormalBackgroundBitmap);
6499                                         GET_BITMAP_CONFIG_N(FOOTER::TAB_ITEM_BG_DISABLED, BITMAP_PIXEL_FORMAT_ARGB8888, pDisabledBackgroundBitmap);
6500                                         GET_BITMAP_CONFIG_N(FOOTER::TAB_ITEM_BG_PRESSED, BITMAP_PIXEL_FORMAT_ARGB8888, pPressedBackgroundBitmap);
6501                                         GET_BITMAP_CONFIG_N(FOOTER::TAB_ITEM_BG_HIGHLIGHTED, BITMAP_PIXEL_FORMAT_ARGB8888, pHighlightedBackgroundBitmap);
6502                                         GET_BITMAP_CONFIG_N(FOOTER::TAB_ITEM_BG_SELECTED, BITMAP_PIXEL_FORMAT_ARGB8888, pSelectedBackgroundBitmap);
6503
6504                                         customTheme = IS_CUSTOM_BITMAP(HEADER::TAB_ITEM_BG_NORMAL);
6505                                         if (customTheme == false)
6506                                         {
6507                                                 GET_BITMAP_CONFIG_N(HEADER::TAB_ITEM_BG_EFFECT_NORMAL, BITMAP_PIXEL_FORMAT_ARGB8888, pNormalBackgroundEffectBitmap);
6508                                         }
6509
6510                                         customTheme = IS_CUSTOM_BITMAP(HEADER::TAB_ITEM_BG_DISABLED);
6511                                         if (customTheme == false)
6512                                         {
6513                                                 GET_BITMAP_CONFIG_N(HEADER::TAB_ITEM_BG_EFFECT_NORMAL, BITMAP_PIXEL_FORMAT_ARGB8888, pDisabledBackgroundEffectBitmap);
6514                                         }
6515
6516                                         customTheme = IS_CUSTOM_BITMAP(HEADER::TAB_ITEM_BG_PRESSED);
6517                                         if (customTheme == false)
6518                                         {
6519                                                 GET_BITMAP_CONFIG_N(HEADER::TAB_ITEM_BG_EFFECT_PRESSED, BITMAP_PIXEL_FORMAT_ARGB8888, pPressedBackgroundEffectBitmap);
6520                                         }
6521
6522                                         customTheme = IS_CUSTOM_BITMAP(HEADER::TAB_ITEM_BG_HIGHLIGHTED);
6523                                         if (customTheme == false)
6524                                         {
6525                                                 GET_BITMAP_CONFIG_N(HEADER::TAB_ITEM_BG_EFFECT_NORMAL, BITMAP_PIXEL_FORMAT_ARGB8888, pHighlightedBackgroundEffectBitmap);
6526                                         }
6527
6528                                         customTheme = IS_CUSTOM_BITMAP(HEADER::TAB_ITEM_BG_SELECTED);
6529                                         if (customTheme == false)
6530                                         {
6531                                                 GET_BITMAP_CONFIG_N(HEADER::TAB_ITEM_BG_EFFECT_NORMAL, BITMAP_PIXEL_FORMAT_ARGB8888, pSelectedBackgroundEffectBitmap);
6532                                         }
6533                                 }
6534                         }
6535                 }
6536
6537                 if (__transparent == true)
6538                 {
6539                         pButton->SetTextColor(_BUTTON_STATUS_NORMAL, __itemTransTextColor[_BUTTON_STATUS_NORMAL]);
6540                         pButton->SetTextColor(_BUTTON_STATUS_DISABLED, __itemTransTextColor[_BUTTON_STATUS_DISABLED]);
6541                         pButton->SetTextColor(_BUTTON_STATUS_PRESSED, __itemTransTextColor[_BUTTON_STATUS_PRESSED]);
6542                         pButton->SetTextColor(_BUTTON_STATUS_HIGHLIGHTED, __itemTransTextColor[_BUTTON_STATUS_HIGHLIGHTED]);
6543                         pButton->SetTextColor(_BUTTON_STATUS_SELECTED, __itemTransTextColor[_BUTTON_STATUS_SELECTED]);
6544
6545                         if (pNormalBackgroundBitmap)
6546                         {
6547                                 pColorReplacedBitmap = _BitmapImpl::GetColorReplacedBitmapN(*pNormalBackgroundBitmap,
6548                                                 Color::GetColor(COLOR_ID_MAGENTA), __itemTransBackgroundColor[_BUTTON_STATUS_NORMAL]);
6549                                 pButton->SetBackgroundBitmap(_BUTTON_STATUS_NORMAL, *pColorReplacedBitmap);
6550
6551                                 delete pColorReplacedBitmap;
6552                                 delete pNormalBackgroundBitmap;
6553                         }
6554
6555                         if (pDisabledBackgroundBitmap)
6556                         {
6557                                 pColorReplacedBitmap = _BitmapImpl::GetColorReplacedBitmapN(*pDisabledBackgroundBitmap,
6558                                                 Color::GetColor(COLOR_ID_MAGENTA), __itemTransBackgroundColor[_BUTTON_STATUS_DISABLED]);
6559                                 pButton->SetBackgroundBitmap(_BUTTON_STATUS_DISABLED, *pColorReplacedBitmap);
6560
6561                                 delete pColorReplacedBitmap;
6562                                 delete pDisabledBackgroundBitmap;
6563                         }
6564
6565                         if (pPressedBackgroundBitmap)
6566                         {
6567                                 pColorReplacedBitmap = _BitmapImpl::GetColorReplacedBitmapN(*pPressedBackgroundBitmap,
6568                                                 Color::GetColor(COLOR_ID_MAGENTA), __itemTransBackgroundColor[_BUTTON_STATUS_PRESSED]);
6569                                 pButton->SetBackgroundBitmap(_BUTTON_STATUS_PRESSED, *pColorReplacedBitmap);
6570
6571                                 delete pColorReplacedBitmap;
6572                                 delete pPressedBackgroundBitmap;
6573                         }
6574
6575                         if (pHighlightedBackgroundBitmap)
6576                         {
6577                                 pColorReplacedBitmap = _BitmapImpl::GetColorReplacedBitmapN(*pHighlightedBackgroundBitmap,
6578                                                 Color::GetColor(COLOR_ID_MAGENTA), __itemTransBackgroundColor[_BUTTON_STATUS_HIGHLIGHTED]);
6579                                 pButton->SetBackgroundBitmap(_BUTTON_STATUS_HIGHLIGHTED, *pColorReplacedBitmap);
6580
6581                                 delete pColorReplacedBitmap;
6582                                 delete pHighlightedBackgroundBitmap;
6583                         }
6584
6585                         if (pSelectedBackgroundBitmap)
6586                         {
6587                                 pColorReplacedBitmap = _BitmapImpl::GetColorReplacedBitmapN(*pSelectedBackgroundBitmap,
6588                                                 Color::GetColor(COLOR_ID_MAGENTA), __itemTransBackgroundColor[_BUTTON_STATUS_SELECTED]);
6589                                 pButton->SetBackgroundBitmap(_BUTTON_STATUS_SELECTED, *pColorReplacedBitmap);
6590
6591                                 delete pColorReplacedBitmap;
6592                                 delete pSelectedBackgroundBitmap;
6593                         }
6594                 }
6595                 else
6596                 {
6597                         pButton->SetTextColor(_BUTTON_STATUS_NORMAL, __itemTextColor[_BUTTON_STATUS_NORMAL]);
6598                         pButton->SetTextColor(_BUTTON_STATUS_DISABLED, __itemTextColor[_BUTTON_STATUS_DISABLED]);
6599                         pButton->SetTextColor(_BUTTON_STATUS_PRESSED, __itemTextColor[_BUTTON_STATUS_PRESSED]);
6600                         pButton->SetTextColor(_BUTTON_STATUS_HIGHLIGHTED, __itemTextColor[_BUTTON_STATUS_HIGHLIGHTED]);
6601                         pButton->SetTextColor(_BUTTON_STATUS_SELECTED, __itemTextColor[_BUTTON_STATUS_SELECTED]);
6602
6603                         if (pNormalBackgroundBitmap)
6604                         {
6605                                 pColorReplacedBitmap = _BitmapImpl::GetColorReplacedBitmapN(*pNormalBackgroundBitmap,
6606                                                 Color::GetColor(COLOR_ID_MAGENTA), __itemBackgroundColor[_BUTTON_STATUS_NORMAL]);
6607                                 pButton->SetBackgroundBitmap(_BUTTON_STATUS_NORMAL, *pColorReplacedBitmap);
6608
6609                                 delete pColorReplacedBitmap;
6610                                 delete pNormalBackgroundBitmap;
6611                         }
6612
6613                         if (pDisabledBackgroundBitmap)
6614                         {
6615                                 pColorReplacedBitmap = _BitmapImpl::GetColorReplacedBitmapN(*pDisabledBackgroundBitmap,
6616                                                 Color::GetColor(COLOR_ID_MAGENTA), __itemBackgroundColor[_BUTTON_STATUS_DISABLED]);
6617                                 pButton->SetBackgroundBitmap(_BUTTON_STATUS_DISABLED, *pColorReplacedBitmap);
6618
6619                                 delete pColorReplacedBitmap;
6620                                 delete pDisabledBackgroundBitmap;
6621                         }
6622
6623                         if (pPressedBackgroundBitmap)
6624                         {
6625                                 pColorReplacedBitmap = _BitmapImpl::GetColorReplacedBitmapN(*pPressedBackgroundBitmap,
6626                                                 Color::GetColor(COLOR_ID_MAGENTA), __itemBackgroundColor[_BUTTON_STATUS_PRESSED]);
6627                                 pButton->SetBackgroundBitmap(_BUTTON_STATUS_PRESSED, *pColorReplacedBitmap);
6628
6629                                 delete pColorReplacedBitmap;
6630                                 delete pPressedBackgroundBitmap;
6631                         }
6632
6633                         if (pHighlightedBackgroundBitmap)
6634                         {
6635                                 pColorReplacedBitmap = _BitmapImpl::GetColorReplacedBitmapN(*pHighlightedBackgroundBitmap,
6636                                                 Color::GetColor(COLOR_ID_MAGENTA), __itemBackgroundColor[_BUTTON_STATUS_HIGHLIGHTED]);
6637                                 pButton->SetBackgroundBitmap(_BUTTON_STATUS_HIGHLIGHTED, *pColorReplacedBitmap);
6638
6639                                 delete pColorReplacedBitmap;
6640                                 delete pHighlightedBackgroundBitmap;
6641                         }
6642
6643                         if (pSelectedBackgroundBitmap)
6644                         {
6645                                 pColorReplacedBitmap = _BitmapImpl::GetColorReplacedBitmapN(*pSelectedBackgroundBitmap,
6646                                                 Color::GetColor(COLOR_ID_MAGENTA), __itemBackgroundColor[_BUTTON_STATUS_SELECTED]);
6647                                 pButton->SetBackgroundBitmap(_BUTTON_STATUS_SELECTED, *pColorReplacedBitmap);
6648
6649                                 delete pColorReplacedBitmap;
6650                                 delete pSelectedBackgroundBitmap;
6651                         }
6652                 }
6653
6654                 if (__style != TOOLBAR_SOFTKEY)
6655                 {
6656                         if (pNormalBackgroundEffectBitmap)
6657                         {
6658                         //      pButton->SetBackgroundEffectBitmap(_BUTTON_STATUS_NORMAL, *pNormalBackgroundEffectBitmap);
6659                                 delete pNormalBackgroundEffectBitmap;
6660                         }
6661                         if (pDisabledBackgroundEffectBitmap)
6662                         {
6663                         //      pButton->SetBackgroundEffectBitmap(_BUTTON_STATUS_DISABLED, *pDisabledBackgroundEffectBitmap);
6664                                 delete pDisabledBackgroundEffectBitmap;
6665                         }
6666                         if (pPressedBackgroundEffectBitmap)
6667                         {
6668                                 pButton->SetBackgroundEffectBitmap(_BUTTON_STATUS_PRESSED, *pPressedBackgroundEffectBitmap);
6669                                 delete pPressedBackgroundEffectBitmap;
6670                         }
6671                         if (pHighlightedBackgroundEffectBitmap)
6672                         {
6673                         //      pButton->SetBackgroundEffectBitmap(_BUTTON_STATUS_HIGHLIGHTED, *pHighlightedBackgroundEffectBitmap);
6674                                 delete pHighlightedBackgroundEffectBitmap;
6675                         }
6676                         if (pSelectedBackgroundEffectBitmap)
6677                         {
6678                         //      pButton->SetBackgroundEffectBitmap(_BUTTON_STATUS_SELECTED, *pSelectedBackgroundEffectBitmap);
6679                                 delete pSelectedBackgroundEffectBitmap;
6680                         }
6681                 }
6682
6683                 if (__style == TOOLBAR_TAB_LARGE || __style == TOOLBAR_HEADER_SEGMENTED_WITH_TITLE || __style == TOOLBAR_TAB_WITH_TITLE)
6684                 {
6685                         pButton->SetTabTextSlide(true);
6686
6687                         Bitmap* pTabTextDimLeftBitmap = null;
6688                         Bitmap* pTabTextDimRightBitmap = null;
6689                         Bitmap* pReColorTabTextDimLeftBitmap = null;
6690                         Bitmap* pReColorTabTextDimRightBitmap = null;
6691
6692                         Color tabTextDimColor;
6693
6694                         if (__header == true)
6695                         {
6696                                 GET_BITMAP_CONFIG_N(HEADER::TAB_TEXT_DIM_EFFECT_LEFT, BITMAP_PIXEL_FORMAT_ARGB8888, pTabTextDimLeftBitmap);
6697                                 GET_BITMAP_CONFIG_N(HEADER::TAB_TEXT_DIM_EFFECT_RIGHT, BITMAP_PIXEL_FORMAT_ARGB8888, pTabTextDimRightBitmap);
6698                                 if (__transparent == true)
6699                                 {
6700                                         GET_COLOR_CONFIG(HEADER::TAB_TEXT_DIM_TRANSLUCENT_NORMAL, tabTextDimColor);
6701                                         tabTextDimColor.SetAlpha(0x00);
6702                                 }
6703                                 else
6704                                 {
6705                                         GET_COLOR_CONFIG(HEADER::TAB_TEXT_DIM_NORMAL, tabTextDimColor);
6706                                         tabTextDimColor.SetAlpha(0x00);
6707                                 }
6708                         }
6709                         else
6710                         {
6711                                 GET_BITMAP_CONFIG_N(FOOTER::TAB_TEXT_DIM_EFFECT_LEFT, BITMAP_PIXEL_FORMAT_ARGB8888, pTabTextDimLeftBitmap);
6712                                 GET_BITMAP_CONFIG_N(FOOTER::TAB_TEXT_DIM_EFFECT_RIGHT, BITMAP_PIXEL_FORMAT_ARGB8888, pTabTextDimRightBitmap);
6713                                 if (__transparent == true)
6714                                 {
6715                                         GET_COLOR_CONFIG(FOOTER::TAB_TEXT_DIM_TRANSLUCENT_NORMAL, tabTextDimColor);
6716                                         tabTextDimColor.SetAlpha(0x00);
6717                                 }
6718                                 else
6719                                 {
6720                                         GET_COLOR_CONFIG(FOOTER::TAB_TEXT_DIM_NORMAL, tabTextDimColor);
6721                                         tabTextDimColor.SetAlpha(0x00);
6722                                 }
6723                         }
6724
6725                         pReColorTabTextDimLeftBitmap = _BitmapImpl::GetColorReplacedBitmapN(*pTabTextDimLeftBitmap, Color::GetColor(COLOR_ID_MAGENTA), tabTextDimColor);
6726                         pReColorTabTextDimRightBitmap = _BitmapImpl::GetColorReplacedBitmapN(*pTabTextDimRightBitmap, Color::GetColor(COLOR_ID_MAGENTA), tabTextDimColor);
6727
6728                         if (pReColorTabTextDimLeftBitmap)
6729                         {
6730                                 pButton->SetTabTextDimLeftBitmap(*pReColorTabTextDimLeftBitmap);
6731                         }
6732
6733                         if (pReColorTabTextDimRightBitmap)
6734                         {
6735                                 pButton->SetTabTextDimRightBitmap(*pReColorTabTextDimRightBitmap);
6736                         }
6737
6738                         delete pTabTextDimLeftBitmap;
6739                         delete pTabTextDimRightBitmap;
6740                         delete pReColorTabTextDimLeftBitmap;
6741                         delete pReColorTabTextDimRightBitmap;
6742                 }
6743
6744                 if (__style == TOOLBAR_HEADER_SEGMENTED_WITH_TITLE || __style == TOOLBAR_TAB_WITH_TITLE)
6745                 {
6746                         Bitmap* pSubTitleEffectBitmap = null;
6747                         Bitmap* pReColorSubTitleEffectBitmap = null;
6748
6749                         Color subTitleEffectColor;
6750
6751                         GET_BITMAP_CONFIG_N(HEADER::SUB_TITLE_EFFECT, BITMAP_PIXEL_FORMAT_ARGB8888, pSubTitleEffectBitmap);
6752                         GET_COLOR_CONFIG(HEADER::SUB_TITLE_EFFECT_NORMAL, subTitleEffectColor);
6753
6754                         pReColorSubTitleEffectBitmap = _BitmapImpl::GetColorReplacedBitmapN(*pSubTitleEffectBitmap, Color::GetColor(COLOR_ID_MAGENTA), subTitleEffectColor);
6755
6756                         if (pReColorSubTitleEffectBitmap)
6757                         {
6758                                 pButton->SetSubTitleEffectBitmap(*pReColorSubTitleEffectBitmap);
6759                         }
6760
6761                         delete pSubTitleEffectBitmap;
6762                         delete pReColorSubTitleEffectBitmap;
6763                 }
6764         } //if (TOOLBAR_ITEM == buttonType)
6765
6766         return E_SUCCESS;
6767 }
6768
6769 int
6770 _Toolbar::CalculateMinimumToolbarWidth(void)
6771 {
6772         float totalWidth = 0.0f;
6773         float itemMinimumWidth = 0.0f;
6774         float horizontalMargin = 0.0f;
6775
6776         if (__header == true && __style == TOOLBAR_TEXT)
6777         {
6778                 if (IsButtonSet(LEFT_BUTTON))
6779                 {
6780                         //if (__pButtonItems[LEFT_BUTTON]->GetText().IsEmpty())
6781                         //{
6782                                 GET_SHAPE_CONFIG(HEADER::BUTTON_ITEM_WIDTH, GetOrientation(), itemMinimumWidth);
6783                         //}
6784                         //else
6785                         //{
6786                         //      GET_SHAPE_CONFIG(HEADER::BUTTON_ITEM_WIDTH_WITH_TEXT, GetOrientation(), itemMinimumWidth);
6787                         //}
6788
6789                         totalWidth += itemMinimumWidth;
6790                 }
6791                 if (IsButtonSet(RIGHT_BUTTON))
6792                 {
6793                         //if (__pButtonItems[RIGHT_BUTTON]->GetText().IsEmpty())
6794                         //{
6795                                 GET_SHAPE_CONFIG(HEADER::BUTTON_ITEM_WIDTH, GetOrientation(), itemMinimumWidth);
6796                         //}
6797                         //else
6798                         //{
6799                         //      GET_SHAPE_CONFIG(HEADER::BUTTON_ITEM_WIDTH_WITH_TEXT, GetOrientation(), itemMinimumWidth);
6800                         //}
6801
6802                         totalWidth += itemMinimumWidth;
6803                 }
6804         }
6805         else // footer or HEADER_TITLE_BUTTON
6806         {
6807                 if (IsButtonSet(LEFT_BUTTON))
6808                 {
6809                         GET_SHAPE_CONFIG(FOOTER::BUTTON_ITEM_WIDTH, GetOrientation(), itemMinimumWidth);
6810                         totalWidth += itemMinimumWidth;
6811                 }
6812
6813                 if (IsButtonSet(RIGHT_BUTTON))
6814                 {
6815                         GET_SHAPE_CONFIG(FOOTER::BUTTON_ITEM_WIDTH, GetOrientation(), itemMinimumWidth);
6816                         totalWidth += itemMinimumWidth;
6817                 }
6818         }
6819
6820         if (__style == TOOLBAR_TITLE)
6821         {
6822                 GET_SHAPE_CONFIG(HEADER::TITLE_MINIMUM_WIDTH, GetOrientation(), itemMinimumWidth);
6823                 totalWidth += itemMinimumWidth;
6824         }
6825         else if (__style == TOOLBAR_HEADER_SEGMENTED_WITH_TITLE || __style == TOOLBAR_HEADER_SEGMENTED)
6826         {
6827                 GET_SHAPE_CONFIG(HEADER::ITEM_MINIMUM_WIDTH, GetOrientation(), itemMinimumWidth);
6828                 GET_SHAPE_CONFIG(HEADER::COMMON_MINIMUM_MARGIN, GetOrientation(), horizontalMargin);
6829                 totalWidth += itemMinimumWidth * __itemCount + horizontalMargin * 2;
6830         }
6831         else if (__style == TOOLBAR_SEGMENTED)
6832         {
6833                 GET_SHAPE_CONFIG(FOOTER::ITEM_MINIMUM_WIDTH, GetOrientation(), itemMinimumWidth);
6834                 GET_SHAPE_CONFIG(FOOTER::COMMON_MINIMUM_MARGIN, GetOrientation(), horizontalMargin);
6835                 totalWidth += itemMinimumWidth * __itemCount + horizontalMargin * 2;
6836         }
6837         else
6838         {
6839                 GET_SHAPE_CONFIG(FOOTER::ITEM_MINIMUM_WIDTH, GetOrientation(), itemMinimumWidth);
6840
6841                 if ((__style == TOOLBAR_TAB || __style == TOOLBAR_TAB_WITH_TITLE || __style == TOOLBAR_TAB_LARGE) && __itemCount > 4)
6842                 {
6843                         totalWidth += itemMinimumWidth * 4;
6844                 }
6845                 else
6846                 {
6847                         totalWidth += itemMinimumWidth * __itemCount;
6848                 }
6849         }
6850
6851         return totalWidth;
6852 }
6853
6854 float
6855 _Toolbar::CalculateMinimumToolbarWidthF(void)
6856 {
6857         float totalWidth = 0.0f;
6858         float itemMinimumWidth = 0.0f;
6859         float horizontalMargin = 0.0f;
6860
6861         if (__header == true && __style == TOOLBAR_TEXT)
6862         {
6863                 if (IsButtonSet(LEFT_BUTTON))
6864                 {
6865                         //if (__pButtonItems[LEFT_BUTTON]->GetText().IsEmpty())
6866                         //{
6867                                 GET_SHAPE_CONFIG(HEADER::BUTTON_ITEM_WIDTH, GetOrientation(), itemMinimumWidth);
6868                         //}
6869                         //else
6870                         //{
6871                         //      GET_SHAPE_CONFIG(HEADER::BUTTON_ITEM_WIDTH_WITH_TEXT, GetOrientation(), itemMinimumWidth);
6872                         //}
6873
6874                         totalWidth += itemMinimumWidth;
6875                 }
6876                 if (IsButtonSet(RIGHT_BUTTON))
6877                 {
6878                         //if (__pButtonItems[RIGHT_BUTTON]->GetText().IsEmpty())
6879                         //{
6880                                 GET_SHAPE_CONFIG(HEADER::BUTTON_ITEM_WIDTH, GetOrientation(), itemMinimumWidth);
6881                         //}
6882                         //else
6883                         //{
6884                         //      GET_SHAPE_CONFIG(HEADER::BUTTON_ITEM_WIDTH_WITH_TEXT, GetOrientation(), itemMinimumWidth);
6885                         //}
6886
6887                         totalWidth += itemMinimumWidth;
6888                 }
6889         }
6890         else // footer or HEADER_TITLE_BUTTON
6891         {
6892                 if (IsButtonSet(LEFT_BUTTON))
6893                 {
6894                         GET_SHAPE_CONFIG(FOOTER::BUTTON_ITEM_WIDTH, GetOrientation(), itemMinimumWidth);
6895                         totalWidth += itemMinimumWidth;
6896                 }
6897
6898                 if (IsButtonSet(RIGHT_BUTTON))
6899                 {
6900                         GET_SHAPE_CONFIG(FOOTER::BUTTON_ITEM_WIDTH, GetOrientation(), itemMinimumWidth);
6901                         totalWidth += itemMinimumWidth;
6902                 }
6903         }
6904
6905         if (__style == TOOLBAR_TITLE)
6906         {
6907                 GET_SHAPE_CONFIG(HEADER::TITLE_MINIMUM_WIDTH, GetOrientation(), itemMinimumWidth);
6908                 totalWidth += itemMinimumWidth;
6909         }
6910         else if (__style == TOOLBAR_HEADER_SEGMENTED_WITH_TITLE || __style == TOOLBAR_HEADER_SEGMENTED)
6911         {
6912                 GET_SHAPE_CONFIG(HEADER::ITEM_MINIMUM_WIDTH, GetOrientation(), itemMinimumWidth);
6913                 GET_SHAPE_CONFIG(HEADER::COMMON_MINIMUM_MARGIN, GetOrientation(), horizontalMargin);
6914                 totalWidth += itemMinimumWidth * __itemCount + horizontalMargin * 2;
6915         }
6916         else if (__style == TOOLBAR_SEGMENTED)
6917         {
6918                 GET_SHAPE_CONFIG(FOOTER::ITEM_MINIMUM_WIDTH, GetOrientation(), itemMinimumWidth);
6919                 GET_SHAPE_CONFIG(FOOTER::COMMON_MINIMUM_MARGIN, GetOrientation(), horizontalMargin);
6920                 totalWidth += itemMinimumWidth * __itemCount + horizontalMargin * 2;
6921         }
6922         else
6923         {
6924                 GET_SHAPE_CONFIG(FOOTER::ITEM_MINIMUM_WIDTH, GetOrientation(), itemMinimumWidth);
6925
6926                 if ((__style == TOOLBAR_TAB || __style == TOOLBAR_TAB_WITH_TITLE || __style == TOOLBAR_TAB_LARGE) && __itemCount > 4)
6927                 {
6928                         totalWidth += itemMinimumWidth * 4;
6929                 }
6930                 else
6931                 {
6932                         totalWidth += itemMinimumWidth * __itemCount;
6933                 }
6934         }
6935
6936         return totalWidth;
6937 }
6938
6939 result
6940 _Toolbar::RealignItem(_Button* pButton, float textExtentSize)
6941 {
6942         SysTryReturnResult(NID_UI_CTRL, pButton, E_INVALID_STATE, "[E_INVALID_STATE] pButton doesn't exist.");
6943
6944         float buttonItemWidth = pButton->GetSizeF().width;
6945         float buttonItemHeight = pButton->GetSizeF().height;
6946         float sideMargin = 0.0f;
6947         float buttonTextTopMargin = 0.0f;
6948         float iconTextGap = 0.0f;
6949         float contentLength = 0.0f;
6950         float segmentedTextAreaHeight = 0.0f;
6951         float revisedTopMargin = 5.0f;
6952         float largeTabTopMargin = 0.0f;
6953         float largeTabTextHeight = 0.0f;
6954
6955         float leftTouchMargin = pButton->GetLeftTouchMarginF();
6956         float topTouchMargin = pButton->GetTopTouchMarginF();
6957         float rightTouchMargin = pButton->GetRightTouchMarginF();
6958         float bottomTouchMargin = pButton->GetBottomTouchMarginF();
6959
6960         GET_SHAPE_CONFIG(FOOTER::BUTTON_ITEM_TEXT_LEFT_MARGIN, GetOrientation(), sideMargin);
6961         GET_SHAPE_CONFIG(HEADER::ICON_TEXT_GAP, GetOrientation(), iconTextGap);
6962         GET_SHAPE_CONFIG(HEADER::SEGMENTED_ITEM_HEIGHT, GetOrientation(), segmentedTextAreaHeight);
6963         GET_SHAPE_CONFIG(HEADER::TAB_LARGE_TOP_MARGIN, GetOrientation(), largeTabTopMargin);
6964         GET_SHAPE_CONFIG(HEADER::TAB_LARGE_TEXT_HEIGHT, GetOrientation(), largeTabTextHeight);
6965
6966         if (__style == TOOLBAR_TEXT || __style == TOOLBAR_ICON || __style == TOOLBAR_ICON_TEXT || __style == TOOLBAR_COMMAND)
6967         {
6968                 GET_SHAPE_CONFIG(FOOTER::FOOTER_ITEM_BUTTON_STYLE_SIDE_MARGIN, GetOrientation(), sideMargin);
6969                 GET_SHAPE_CONFIG(FOOTER::BUTTON_ITEM_TEXT_TOP_MARGIN, GetOrientation(), buttonTextTopMargin);
6970         }
6971         else if (__style == TOOLBAR_HEADER_SEGMENTED || __style == TOOLBAR_SEGMENTED || __style == TOOLBAR_TAB || __style == TOOLBAR_TAB_LARGE)
6972         {
6973                 GET_SHAPE_CONFIG(FOOTER::BUTTON_ITEM_TEXT_LEFT_MARGIN, GetOrientation(), sideMargin);
6974
6975                 buttonTextTopMargin = (buttonItemHeight - segmentedTextAreaHeight) / 2 - revisedTopMargin;
6976         }
6977         else if (__style == TOOLBAR_HEADER_SEGMENTED_WITH_TITLE || __style == TOOLBAR_TAB_WITH_TITLE)
6978         {
6979                 GET_SHAPE_CONFIG(FOOTER::BUTTON_ITEM_TEXT_LEFT_MARGIN, GetOrientation(), sideMargin);
6980
6981                 buttonTextTopMargin = 0;
6982         }
6983
6984         if (pButton->GetText() != L"")
6985         {
6986                 float iconAreaWidth = 0.0f;
6987
6988                 if (pButton->GetBitmap(_BUTTON_STATUS_NORMAL) != null)
6989                 {
6990                         iconAreaWidth = pButton->GetBitmap(_BUTTON_STATUS_NORMAL)->GetWidthF();
6991                         contentLength = iconAreaWidth + iconTextGap + textExtentSize;
6992
6993                         if (contentLength > buttonItemWidth - sideMargin * 2)
6994                         {
6995                                 contentLength = buttonItemWidth - sideMargin * 2;
6996                         }
6997
6998                         if (__style == TOOLBAR_TAB_LARGE)
6999                         {
7000                                 pButton->SetBitmap(_BUTTON_STATUS_NORMAL,
7001                                                 FloatPoint((buttonItemWidth - iconAreaWidth) / 2, largeTabTopMargin),
7002                                                 *(pButton->GetBitmap(_BUTTON_STATUS_NORMAL)));
7003                         }
7004                         else
7005                         {
7006                                 pButton->SetBitmap(_BUTTON_STATUS_NORMAL,
7007                                                 FloatPoint((buttonItemWidth - contentLength) / 2, (buttonItemHeight - (pButton->GetBitmap(_BUTTON_STATUS_NORMAL))->GetHeightF()) / 2),
7008                                                 *(pButton->GetBitmap(_BUTTON_STATUS_NORMAL)));
7009                         }
7010                 }
7011                 if (pButton->GetBitmap(_BUTTON_STATUS_PRESSED) != null)
7012                 {
7013                         iconAreaWidth = pButton->GetBitmap(_BUTTON_STATUS_PRESSED)->GetWidthF();
7014                         contentLength = iconAreaWidth + iconTextGap + textExtentSize;
7015
7016                         if (contentLength > buttonItemWidth - sideMargin * 2)
7017                         {
7018                                 contentLength = buttonItemWidth - sideMargin * 2;
7019                         }
7020
7021                         if (__style == TOOLBAR_TAB_LARGE)
7022                         {
7023                                 pButton->SetBitmap(_BUTTON_STATUS_PRESSED,
7024                                                 FloatPoint((buttonItemWidth - iconAreaWidth) / 2, largeTabTopMargin),
7025                                                 *(pButton->GetBitmap(_BUTTON_STATUS_PRESSED)));
7026                         }
7027                         else
7028                         {
7029                                 pButton->SetBitmap(_BUTTON_STATUS_PRESSED,
7030                                                 FloatPoint((buttonItemWidth - contentLength) / 2, (buttonItemHeight - (pButton->GetBitmap(_BUTTON_STATUS_PRESSED))->GetHeightF()) / 2),
7031                                                 *(pButton->GetBitmap(_BUTTON_STATUS_PRESSED)));
7032                         }
7033                 }
7034                 if (pButton->GetBitmap(_BUTTON_STATUS_SELECTED) != null)
7035                 {
7036                         iconAreaWidth = pButton->GetBitmap(_BUTTON_STATUS_SELECTED)->GetWidthF();
7037                         contentLength = iconAreaWidth + iconTextGap + textExtentSize;
7038
7039                         if (contentLength > buttonItemWidth - sideMargin * 2)
7040                         {
7041                                 contentLength = buttonItemWidth - sideMargin * 2;
7042                         }
7043
7044                         if (__style == TOOLBAR_TAB_LARGE)
7045                         {
7046                                 pButton->SetBitmap(_BUTTON_STATUS_SELECTED,
7047                                                 FloatPoint((buttonItemWidth - iconAreaWidth) / 2, largeTabTopMargin),
7048                                                 *(pButton->GetBitmap(_BUTTON_STATUS_SELECTED)));
7049                         }
7050                         else
7051                         {
7052                                 pButton->SetBitmap(_BUTTON_STATUS_SELECTED,
7053                                                 FloatPoint((buttonItemWidth - contentLength) / 2, (buttonItemHeight - (pButton->GetBitmap(_BUTTON_STATUS_SELECTED))->GetHeightF()) / 2),
7054                                                 *(pButton->GetBitmap(_BUTTON_STATUS_SELECTED)));
7055                         }
7056                 }
7057                 if (pButton->GetBitmap(_BUTTON_STATUS_HIGHLIGHTED) != null)
7058                 {
7059                         iconAreaWidth = pButton->GetBitmap(_BUTTON_STATUS_HIGHLIGHTED)->GetWidthF();
7060                         contentLength = iconAreaWidth + iconTextGap + textExtentSize;
7061
7062                         if (contentLength > buttonItemWidth - sideMargin * 2)
7063                         {
7064                                 contentLength = buttonItemWidth - sideMargin * 2;
7065                         }
7066
7067                         if (__style == TOOLBAR_TAB_LARGE)
7068                         {
7069                                 pButton->SetBitmap(_BUTTON_STATUS_HIGHLIGHTED,
7070                                                 FloatPoint((buttonItemWidth - iconAreaWidth) / 2, largeTabTopMargin),
7071                                                 *(pButton->GetBitmap(_BUTTON_STATUS_HIGHLIGHTED)));
7072                         }
7073                         else
7074                         {
7075                                 pButton->SetBitmap(_BUTTON_STATUS_HIGHLIGHTED,
7076                                                 FloatPoint((buttonItemWidth - contentLength) / 2, (buttonItemHeight - (pButton->GetBitmap(_BUTTON_STATUS_HIGHLIGHTED))->GetHeightF()) / 2),
7077                                                 *(pButton->GetBitmap(_BUTTON_STATUS_HIGHLIGHTED)));
7078                         }
7079                 }
7080                 if (pButton->GetBitmap(_BUTTON_STATUS_DISABLED) != null)
7081                 {
7082                         iconAreaWidth = pButton->GetBitmap(_BUTTON_STATUS_DISABLED)->GetWidthF();
7083                         contentLength = iconAreaWidth + iconTextGap + textExtentSize;
7084
7085                         if (contentLength > buttonItemWidth - sideMargin * 2)
7086                         {
7087                                 contentLength = buttonItemWidth - sideMargin * 2;
7088                         }
7089
7090                         if (__style == TOOLBAR_TAB_LARGE)
7091                         {
7092                                 pButton->SetBitmap(_BUTTON_STATUS_DISABLED,
7093                                                 FloatPoint((buttonItemWidth - iconAreaWidth) / 2, largeTabTopMargin),
7094                                                 *(pButton->GetBitmap(_BUTTON_STATUS_DISABLED)));
7095                         }
7096                         else
7097                         {
7098                                 pButton->SetBitmap(_BUTTON_STATUS_DISABLED,
7099                                                 FloatPoint((buttonItemWidth - contentLength) / 2, (buttonItemHeight - (pButton->GetBitmap(_BUTTON_STATUS_DISABLED))->GetHeightF()) / 2),
7100                                                 *(pButton->GetBitmap(_BUTTON_STATUS_DISABLED)));
7101                         }
7102                 }
7103
7104                 if (iconAreaWidth != 0)
7105                 {
7106                         if (__style == TOOLBAR_TAB_LARGE)
7107                         {
7108                                 pButton->SetTextHorizontalAlignment(ALIGNMENT_CENTER);
7109                                 pButton->SetUserDefinedTextArea(FloatRectangle(sideMargin, largeTabTopMargin + iconAreaWidth,
7110                                                 buttonItemWidth - sideMargin * 2, largeTabTextHeight));
7111                         }
7112                         else if (__style == TOOLBAR_HEADER_SEGMENTED_WITH_TITLE || __style == TOOLBAR_TAB_WITH_TITLE)
7113                         {
7114                                 pButton->SetTextHorizontalAlignment(ALIGNMENT_LEFT);
7115                                 pButton->SetUserDefinedTextArea(FloatRectangle((buttonItemWidth - contentLength) / 2 + iconAreaWidth + iconTextGap, (buttonItemHeight - largeTabTextHeight) / 2,
7116                                                 buttonItemWidth - iconAreaWidth - iconTextGap - sideMargin * 2, largeTabTextHeight));
7117                         }
7118                         else
7119                         {
7120                                 pButton->SetTextHorizontalAlignment(ALIGNMENT_LEFT);
7121                                 pButton->SetUserDefinedTextArea(FloatRectangle((buttonItemWidth - contentLength) / 2 + iconAreaWidth + iconTextGap,
7122                                                 buttonTextTopMargin, buttonItemWidth - iconAreaWidth - iconTextGap - sideMargin * 2, buttonItemHeight - buttonTextTopMargin * 2));
7123                         }
7124                 }
7125                 else
7126                 {
7127                         if (__style == TOOLBAR_HEADER_SEGMENTED_WITH_TITLE || __style == TOOLBAR_TAB_WITH_TITLE)
7128                         {
7129                                 pButton->SetUserDefinedTextArea(FloatRectangle(sideMargin, (buttonItemHeight - largeTabTextHeight) / 2,
7130                                                 buttonItemWidth - sideMargin * 2, largeTabTextHeight));
7131                         }
7132                         else
7133                         {
7134                                 pButton->SetUserDefinedTextArea(FloatRectangle(sideMargin, buttonTextTopMargin, buttonItemWidth - sideMargin * 2, buttonItemHeight - buttonTextTopMargin * 2));
7135                         }
7136                 }
7137         }
7138         else
7139         {
7140                 if (pButton->GetBitmap(_BUTTON_STATUS_NORMAL) != null)
7141                 {
7142                         pButton->SetBitmap(_BUTTON_STATUS_NORMAL,
7143                                         FloatPoint((buttonItemWidth - (leftTouchMargin + rightTouchMargin) - (pButton->GetBitmap(_BUTTON_STATUS_NORMAL))->GetWidthF()) / 2,
7144                                                         (buttonItemHeight - (topTouchMargin + bottomTouchMargin) - (pButton->GetBitmap(_BUTTON_STATUS_NORMAL))->GetHeightF()) / 2),
7145                                                         *(pButton->GetBitmap(_BUTTON_STATUS_NORMAL)));
7146                 }
7147                 if (pButton->GetBitmap(_BUTTON_STATUS_PRESSED) != null)
7148                 {
7149                         pButton->SetBitmap(_BUTTON_STATUS_PRESSED,
7150                                         FloatPoint((buttonItemWidth - (leftTouchMargin + rightTouchMargin) - (pButton->GetBitmap(_BUTTON_STATUS_PRESSED))->GetWidthF()) / 2,
7151                                                         (buttonItemHeight - (topTouchMargin + bottomTouchMargin) - (pButton->GetBitmap(_BUTTON_STATUS_PRESSED))->GetHeightF()) / 2),
7152                                                         *(pButton->GetBitmap(_BUTTON_STATUS_PRESSED)));
7153                 }
7154                 if (pButton->GetBitmap(_BUTTON_STATUS_HIGHLIGHTED) != null)
7155                 {
7156                         pButton->SetBitmap(_BUTTON_STATUS_HIGHLIGHTED,
7157                                         FloatPoint((buttonItemWidth - (leftTouchMargin + rightTouchMargin) - (pButton->GetBitmap(_BUTTON_STATUS_HIGHLIGHTED))->GetWidthF()) / 2,
7158                                                         (buttonItemHeight - (topTouchMargin + bottomTouchMargin) - (pButton->GetBitmap(_BUTTON_STATUS_HIGHLIGHTED))->GetHeightF()) / 2),
7159                                                         *(pButton->GetBitmap(_BUTTON_STATUS_HIGHLIGHTED)));
7160                 }
7161                 if (pButton->GetBitmap(_BUTTON_STATUS_DISABLED) != null)
7162                 {
7163                         pButton->SetBitmap(_BUTTON_STATUS_DISABLED,
7164                                         FloatPoint((buttonItemWidth - (leftTouchMargin + rightTouchMargin) - (pButton->GetBitmap(_BUTTON_STATUS_DISABLED))->GetWidthF()) / 2,
7165                                                         (buttonItemHeight - (topTouchMargin + bottomTouchMargin) - (pButton->GetBitmap(_BUTTON_STATUS_DISABLED))->GetHeightF()) / 2),
7166                                                         *(pButton->GetBitmap(_BUTTON_STATUS_DISABLED)));
7167                 }
7168                 if (pButton->GetBitmap(_BUTTON_STATUS_SELECTED) != null)
7169                 {
7170                         pButton->SetBitmap(_BUTTON_STATUS_SELECTED,
7171                                         FloatPoint((buttonItemWidth - (leftTouchMargin + rightTouchMargin) - (pButton->GetBitmap(_BUTTON_STATUS_SELECTED))->GetWidthF()) / 2,
7172                                                         (buttonItemHeight - (topTouchMargin + bottomTouchMargin) - (pButton->GetBitmap(_BUTTON_STATUS_SELECTED))->GetHeightF()) / 2),
7173                                                         *(pButton->GetBitmap(_BUTTON_STATUS_SELECTED)));
7174                 }
7175
7176                 pButton->SetMargin(sideMargin, buttonTextTopMargin, sideMargin, buttonTextTopMargin);
7177         }
7178
7179         return E_SUCCESS;
7180 }
7181
7182 result
7183 _Toolbar::RealignButtonItem(_Button* pButton)
7184 {
7185         SysTryReturnResult(NID_UI_CTRL, pButton, E_INVALID_STATE, "[E_INVALID_STATE] pButton doesn't exist.");
7186
7187         float buttonItemWidth = pButton->GetSizeF().width;
7188         float buttonItemHeight = pButton->GetSizeF().height;
7189
7190         float leftTouchMargin = pButton->GetLeftTouchMarginF();
7191         float topTouchMargin = pButton->GetTopTouchMarginF();
7192         float rightTouchMargin = pButton->GetRightTouchMarginF();
7193         float bottomTouchMargin = pButton->GetBottomTouchMarginF();
7194
7195         if (pButton->GetBitmap(_BUTTON_STATUS_NORMAL) != null)
7196         {
7197                 pButton->SetBitmap(_BUTTON_STATUS_NORMAL,
7198                                 FloatPoint((buttonItemWidth - (leftTouchMargin + rightTouchMargin) - (pButton->GetBitmap(_BUTTON_STATUS_NORMAL))->GetWidthF()) / 2,
7199                                                 (buttonItemHeight - (topTouchMargin + bottomTouchMargin) - (pButton->GetBitmap(_BUTTON_STATUS_NORMAL))->GetHeightF()) / 2),
7200                                                 *(pButton->GetBitmap(_BUTTON_STATUS_NORMAL)));
7201         }
7202         if (pButton->GetBitmap(_BUTTON_STATUS_PRESSED) != null)
7203         {
7204                 pButton->SetBitmap(_BUTTON_STATUS_PRESSED,
7205                                 FloatPoint((buttonItemWidth - (leftTouchMargin + rightTouchMargin) - (pButton->GetBitmap(_BUTTON_STATUS_PRESSED))->GetWidthF()) / 2,
7206                                                 (buttonItemHeight - (topTouchMargin + bottomTouchMargin) - (pButton->GetBitmap(_BUTTON_STATUS_PRESSED))->GetHeightF()) / 2),
7207                                                 *(pButton->GetBitmap(_BUTTON_STATUS_PRESSED)));
7208         }
7209         if (pButton->GetBitmap(_BUTTON_STATUS_HIGHLIGHTED) != null)
7210         {
7211                 pButton->SetBitmap(_BUTTON_STATUS_HIGHLIGHTED,
7212                                 FloatPoint((buttonItemWidth - (leftTouchMargin + rightTouchMargin) - (pButton->GetBitmap(_BUTTON_STATUS_HIGHLIGHTED))->GetWidthF()) / 2,
7213                                                 (buttonItemHeight - (topTouchMargin + bottomTouchMargin) - (pButton->GetBitmap(_BUTTON_STATUS_HIGHLIGHTED))->GetHeightF()) / 2),
7214                                                 *(pButton->GetBitmap(_BUTTON_STATUS_HIGHLIGHTED)));
7215         }
7216         if (pButton->GetBitmap(_BUTTON_STATUS_DISABLED) != null)
7217         {
7218                 pButton->SetBitmap(_BUTTON_STATUS_DISABLED,
7219                                 FloatPoint((buttonItemWidth - (leftTouchMargin + rightTouchMargin) - (pButton->GetBitmap(_BUTTON_STATUS_DISABLED))->GetWidthF()) / 2,
7220                                                 (buttonItemHeight - (topTouchMargin + bottomTouchMargin) - (pButton->GetBitmap(_BUTTON_STATUS_DISABLED))->GetHeightF()) / 2),
7221                                                 *(pButton->GetBitmap(_BUTTON_STATUS_DISABLED)));
7222         }
7223         if (pButton->GetBitmap(_BUTTON_STATUS_SELECTED) != null)
7224         {
7225                 pButton->SetBitmap(_BUTTON_STATUS_SELECTED,
7226                                 FloatPoint((buttonItemWidth - (leftTouchMargin + rightTouchMargin) - (pButton->GetBitmap(_BUTTON_STATUS_SELECTED))->GetWidthF()) / 2,
7227                                                 (buttonItemHeight - (topTouchMargin + bottomTouchMargin) - (pButton->GetBitmap(_BUTTON_STATUS_SELECTED))->GetHeightF()) / 2),
7228                                                 *(pButton->GetBitmap(_BUTTON_STATUS_SELECTED)));
7229         }
7230
7231         if (pButton->GetEffectBitmap(_BUTTON_STATUS_NORMAL) != null)
7232         {
7233                 pButton->SetEffectBitmap(_BUTTON_STATUS_NORMAL,
7234                                 FloatPoint((buttonItemWidth - (leftTouchMargin + rightTouchMargin) - (pButton->GetEffectBitmap(_BUTTON_STATUS_NORMAL))->GetWidthF()) / 2,
7235                                                 (buttonItemHeight - (topTouchMargin + bottomTouchMargin) - (pButton->GetEffectBitmap(_BUTTON_STATUS_NORMAL))->GetHeightF()) / 2),
7236                                                 *(pButton->GetEffectBitmap(_BUTTON_STATUS_NORMAL)));
7237         }
7238
7239         if (pButton->GetEffectBitmap(_BUTTON_STATUS_PRESSED) != null)
7240         {
7241                 pButton->SetEffectBitmap(_BUTTON_STATUS_PRESSED,
7242                                 FloatPoint((buttonItemWidth - (leftTouchMargin + rightTouchMargin) - (pButton->GetEffectBitmap(_BUTTON_STATUS_PRESSED))->GetWidthF()) / 2,
7243                                                 (buttonItemHeight - (topTouchMargin + bottomTouchMargin) - (pButton->GetEffectBitmap(_BUTTON_STATUS_PRESSED))->GetHeightF()) / 2),
7244                                                 *(pButton->GetEffectBitmap(_BUTTON_STATUS_PRESSED)));
7245         }
7246         if (pButton->GetEffectBitmap(_BUTTON_STATUS_HIGHLIGHTED) != null)
7247         {
7248                 pButton->SetEffectBitmap(_BUTTON_STATUS_HIGHLIGHTED,
7249                                 FloatPoint((buttonItemWidth - (leftTouchMargin + rightTouchMargin) - (pButton->GetEffectBitmap(_BUTTON_STATUS_HIGHLIGHTED))->GetWidthF()) / 2,
7250                                                 (buttonItemHeight - (topTouchMargin + bottomTouchMargin) - (pButton->GetEffectBitmap(_BUTTON_STATUS_HIGHLIGHTED))->GetHeightF()) / 2),
7251                                                 *(pButton->GetEffectBitmap(_BUTTON_STATUS_HIGHLIGHTED)));
7252         }
7253         if (pButton->GetEffectBitmap(_BUTTON_STATUS_DISABLED) != null)
7254         {
7255                 pButton->SetEffectBitmap(_BUTTON_STATUS_DISABLED,
7256                                 FloatPoint((buttonItemWidth - (leftTouchMargin + rightTouchMargin) - (pButton->GetEffectBitmap(_BUTTON_STATUS_DISABLED))->GetWidthF()) / 2,
7257                                                 (buttonItemHeight - (topTouchMargin + bottomTouchMargin) - (pButton->GetEffectBitmap(_BUTTON_STATUS_DISABLED))->GetHeightF()) / 2),
7258                                                 *(pButton->GetEffectBitmap(_BUTTON_STATUS_DISABLED)));
7259         }
7260         if (pButton->GetEffectBitmap(_BUTTON_STATUS_SELECTED) != null)
7261         {
7262                 pButton->SetEffectBitmap(_BUTTON_STATUS_SELECTED,
7263                                 FloatPoint((buttonItemWidth - (leftTouchMargin + rightTouchMargin) - (pButton->GetEffectBitmap(_BUTTON_STATUS_SELECTED))->GetWidthF()) / 2,
7264                                                 (buttonItemHeight - (topTouchMargin + bottomTouchMargin) - (pButton->GetEffectBitmap(_BUTTON_STATUS_SELECTED))->GetHeightF()) / 2),
7265                                                 *(pButton->GetEffectBitmap(_BUTTON_STATUS_SELECTED)));
7266         }
7267
7268         return E_SUCCESS;
7269 }
7270
7271 result
7272 _Toolbar::RearrangeItems(void)
7273 {
7274         __titleTextArea = _Control::GetBoundsF();
7275
7276         const FloatDimension portraitSize = _ControlManager::GetInstance()->_ControlManager::GetScreenSizeF();
7277         const FloatDimension landscapeSize = FloatDimension(portraitSize.height, portraitSize.width);
7278
7279         if (CalculateMinimumToolbarWidth() > __titleTextArea.width)
7280         {
7281                 __titleTextArea.width = CalculateMinimumToolbarWidth();
7282         }
7283
7284         if (GetOrientation() == _CONTROL_ORIENTATION_PORTRAIT)
7285         {
7286                 if (__titleTextArea.width > portraitSize.width)
7287                 {
7288                         __titleTextArea.width = portraitSize.width;
7289                 }
7290         }
7291         else
7292         {
7293                 if (__titleTextArea.width > landscapeSize.width)
7294                 {
7295                         __titleTextArea.width = landscapeSize.width;
7296                 }
7297         }
7298
7299         __itemArea = __titleTextArea;
7300
7301         if (__header == true && __style != TOOLBAR_TEXT) // right align
7302         {
7303                 float headerLeftButtonWidth = 0.0f;
7304                 float headerRightButtonWidth = 0.0f;
7305                 float headerTopMargin = 0.0f;
7306                 float vmargin = 0.0f;
7307                 float buttonItemGap = 0.0f;
7308                 float headerButtonItemHeight = 0.0f;
7309                 float headerLeftMargin = 0.0f;
7310                 float headerRightMargin = 0.0f;
7311                 float tabLeftMargin = 0.0f;
7312
7313                 float leftTouchMargin = 0.0f;
7314                 float topTouchMargin = 0.0f;
7315                 float rightTouchMargin = 0.0f;
7316                 float bottomTouchMargin = 0.0f;
7317
7318                 GET_SHAPE_CONFIG(HEADER::TOP_MARGIN, GetOrientation(), headerTopMargin);
7319                 GET_SHAPE_CONFIG(HEADER::BUTTON_ITEM_GAP, GetOrientation(), buttonItemGap);
7320                 GET_SHAPE_CONFIG(HEADER::LEFT_MARGIN, GetOrientation(), headerLeftMargin);
7321                 GET_SHAPE_CONFIG(HEADER::RIGHT_MARGIN, GetOrientation(), headerRightMargin);
7322                 GET_SHAPE_CONFIG(HEADER::TAB_LEFT_MARGIN, GetOrientation(), tabLeftMargin);
7323
7324                 GET_SHAPE_CONFIG(HEADER::BUTTON_ITEM_LEFT_TOUCH_MARGIN, GetOrientation(), leftTouchMargin);
7325                 GET_SHAPE_CONFIG(HEADER::BUTTON_ITEM_TOP_TOUCH_MARGIN, GetOrientation(), topTouchMargin);
7326                 GET_SHAPE_CONFIG(HEADER::BUTTON_ITEM_RIGHT_TOUCH_MARGIN, GetOrientation(), rightTouchMargin);
7327                 GET_SHAPE_CONFIG(HEADER::BUTTON_ITEM_BOTTOM_TOUCH_MARGIN, GetOrientation(), bottomTouchMargin);
7328
7329                 if (__pButtonItems[LEFT_BUTTON])
7330                 {
7331                         headerLeftButtonWidth = __pButtonItems[LEFT_BUTTON]->GetSizeF().width;
7332                 }
7333
7334                 if (__pButtonItems[RIGHT_BUTTON])
7335                 {
7336                         headerRightButtonWidth = __pButtonItems[RIGHT_BUTTON]->GetSizeF().width;
7337                 }
7338
7339                 if (__style == TOOLBAR_HEADER_SEGMENTED_WITH_TITLE || __style == TOOLBAR_TAB_WITH_TITLE)
7340                 {
7341                         GET_SHAPE_CONFIG(HEADER::TITLE_HEIGHT_WITH_SEGMENTED_ITEM, GetOrientation(), vmargin);
7342                         GET_SHAPE_CONFIG(HEADER::SEGMENTED_ITEM_HEIGHT, GetOrientation(), headerButtonItemHeight);
7343                 }
7344                 else
7345                 {
7346                         GET_SHAPE_CONFIG(HEADER::BUTTON_ITEM_TOP_MARGIN, GetOrientation(), vmargin);
7347                         GET_SHAPE_CONFIG(HEADER::BUTTON_ITEM_HEIGHT, GetOrientation(), headerButtonItemHeight);
7348                 }
7349
7350                 __titleTextArea.x = headerLeftMargin;
7351                 __titleTextArea.y = headerTopMargin;
7352
7353                 if (__pButtonItems[RIGHT_BUTTON])
7354                 {
7355                         if (__pButtonItems[LEFT_BUTTON])
7356                         {
7357                                 if (__pButtonItems[LEFT_BUTTON]->GetText() == L"")
7358                                 {
7359                                         if (__pButtonItems[RIGHT_BUTTON]->GetText() == L"")
7360                                         {
7361                                                 __pButtonItems[RIGHT_BUTTON]->SetBounds(FloatRectangle(__titleTextArea.width - headerRightButtonWidth, vmargin,
7362                                                                 headerRightButtonWidth, headerButtonItemHeight));
7363                                                 __pButtonItems[LEFT_BUTTON]->SetBounds(FloatRectangle(__titleTextArea.width - headerRightButtonWidth - buttonItemGap - headerLeftButtonWidth, vmargin,
7364                                                                 headerLeftButtonWidth, headerButtonItemHeight));
7365
7366                                                 if (__style == TOOLBAR_HEADER_SEGMENTED_WITH_TITLE || __style == TOOLBAR_TAB_WITH_TITLE)
7367                                                 {
7368                                                         __pButtonItems[RIGHT_BUTTON]->SetTouchMargin(leftTouchMargin, 0.0f, rightTouchMargin, 0.0f);
7369                                                         __pButtonItems[LEFT_BUTTON]->SetTouchMargin(leftTouchMargin, 0.0f, rightTouchMargin, 0.0f);
7370
7371                                                         __itemArea.width -= (headerLeftButtonWidth + buttonItemGap + headerRightButtonWidth);
7372                                                 }
7373                                                 else
7374                                                 {
7375                                                         __pButtonItems[RIGHT_BUTTON]->SetTouchMargin(leftTouchMargin, topTouchMargin, rightTouchMargin, bottomTouchMargin);
7376                                                         __pButtonItems[LEFT_BUTTON]->SetTouchMargin(leftTouchMargin, topTouchMargin, rightTouchMargin, bottomTouchMargin);
7377
7378                                                         __titleTextArea.width -= (headerLeftButtonWidth + buttonItemGap + headerRightButtonWidth);
7379                                                         __itemArea.width -= (headerLeftButtonWidth + buttonItemGap + headerRightButtonWidth);
7380                                                 }
7381                                         }
7382                                         else
7383                                         {
7384                                                 __pButtonItems[RIGHT_BUTTON]->SetBounds(FloatRectangle(__titleTextArea.width - headerRightButtonWidth , vmargin,
7385                                                                 headerRightButtonWidth, headerButtonItemHeight));
7386                                                 __pButtonItems[LEFT_BUTTON]->SetBounds(FloatRectangle(__titleTextArea.width - headerRightButtonWidth - buttonItemGap - headerLeftButtonWidth , vmargin,
7387                                                                 headerLeftButtonWidth, headerButtonItemHeight));
7388
7389                                                 if (__style == TOOLBAR_HEADER_SEGMENTED_WITH_TITLE || __style == TOOLBAR_TAB_WITH_TITLE)
7390                                                 {
7391                                                         //__pButtonItems[RIGHT_BUTTON]->SetTouchMargin(0, 0, 0, 0);
7392                                                         __pButtonItems[LEFT_BUTTON]->SetTouchMargin(leftTouchMargin, 0.0f, rightTouchMargin, 0.0f);
7393
7394                                                         __itemArea.width -= (headerLeftButtonWidth + buttonItemGap + headerRightButtonWidth);
7395                                                 }
7396                                                 else
7397                                                 {
7398                                                         //__pButtonItems[RIGHT_BUTTON]->SetTouchMargin(0.0f, topTouchMargin, 0.0f, bottomTouchMargin);
7399                                                         __pButtonItems[LEFT_BUTTON]->SetTouchMargin(leftTouchMargin, topTouchMargin, rightTouchMargin, bottomTouchMargin);
7400
7401                                                         __titleTextArea.width -= (headerLeftButtonWidth + buttonItemGap + headerRightButtonWidth);
7402                                                         __itemArea.width -= (headerLeftButtonWidth + buttonItemGap + headerRightButtonWidth);
7403                                                 }
7404                                         }
7405                                 }
7406                                 else
7407                                 {
7408                                         if (__pButtonItems[RIGHT_BUTTON]->GetText() == L"")
7409                                         {
7410                                                 __pButtonItems[RIGHT_BUTTON]->SetBounds(FloatRectangle(__titleTextArea.width - headerRightButtonWidth, vmargin,
7411                                                                 headerRightButtonWidth, headerButtonItemHeight));
7412                                                 __pButtonItems[LEFT_BUTTON]->SetBounds(FloatRectangle(__titleTextArea.width - headerRightButtonWidth - buttonItemGap - headerLeftButtonWidth, vmargin,
7413                                                                 headerLeftButtonWidth, headerButtonItemHeight));
7414
7415                                                 if (__style == TOOLBAR_HEADER_SEGMENTED_WITH_TITLE || __style == TOOLBAR_TAB_WITH_TITLE)
7416                                                 {
7417                                                         //__pButtonItems[LEFT_BUTTON]->SetTouchMargin(0, 0, 0, 0);
7418                                                         __pButtonItems[RIGHT_BUTTON]->SetTouchMargin(leftTouchMargin, 0.0f, rightTouchMargin, 0.0f);
7419
7420                                                         __itemArea.width -= (headerLeftButtonWidth + buttonItemGap + headerRightButtonWidth);
7421                                                 }
7422                                                 else
7423                                                 {
7424                                                         //__pButtonItems[LEFT_BUTTON]->SetTouchMargin(0.0f, topTouchMargin, 0.0f, bottomTouchMargin);
7425                                                         __pButtonItems[RIGHT_BUTTON]->SetTouchMargin(leftTouchMargin, topTouchMargin, rightTouchMargin, bottomTouchMargin);
7426
7427                                                         __titleTextArea.width -= (headerLeftButtonWidth + buttonItemGap + headerRightButtonWidth);
7428                                                         __itemArea.width -= (headerLeftButtonWidth + buttonItemGap + headerRightButtonWidth);
7429                                                 }
7430                                         }
7431                                         else
7432                                         {
7433                                                 __pButtonItems[RIGHT_BUTTON]->SetBounds(FloatRectangle(__titleTextArea.width - headerRightButtonWidth , vmargin,
7434                                                                 headerRightButtonWidth, headerButtonItemHeight));
7435                                                 __pButtonItems[LEFT_BUTTON]->SetBounds(FloatRectangle(__titleTextArea.width - headerRightButtonWidth - buttonItemGap - headerLeftButtonWidth , vmargin,
7436                                                                 headerLeftButtonWidth, headerButtonItemHeight));
7437
7438                                                 if (__style == TOOLBAR_HEADER_SEGMENTED_WITH_TITLE || __style == TOOLBAR_TAB_WITH_TITLE)
7439                                                 {
7440                                                         //__pButtonItems[LEFT_BUTTON]->SetTouchMargin(0, 0, 0, 0);
7441                                                         //__pButtonItems[RIGHT_BUTTON]->SetTouchMargin(0, 0, 0, 0);
7442
7443                                                         __itemArea.width -= (headerLeftButtonWidth + buttonItemGap + headerRightButtonWidth);
7444                                                 }
7445                                                 else
7446                                                 {
7447                                                         //__pButtonItems[LEFT_BUTTON]->SetTouchMargin(0.0f, topTouchMargin, 0.0f, bottomTouchMargin);
7448                                                         //__pButtonItems[RIGHT_BUTTON]->SetTouchMargin(0.0f, topTouchMargin, 0.0f, bottomTouchMargin);
7449
7450                                                         __titleTextArea.width -= (headerLeftButtonWidth + buttonItemGap + headerRightButtonWidth);
7451                                                         __itemArea.width -= (headerLeftButtonWidth + buttonItemGap + headerRightButtonWidth);
7452                                                 }
7453                                         }
7454                                 }
7455                         }
7456                         else
7457                         {
7458                                 if (__pButtonItems[RIGHT_BUTTON]->GetText() == L"")
7459                                 {
7460                                         __pButtonItems[RIGHT_BUTTON]->SetBounds(FloatRectangle(__titleTextArea.width - headerRightButtonWidth, vmargin,
7461                                                         headerRightButtonWidth, headerButtonItemHeight));
7462
7463                                         if (__style == TOOLBAR_HEADER_SEGMENTED_WITH_TITLE || __style == TOOLBAR_TAB_WITH_TITLE)
7464                                         {
7465                                                 __pButtonItems[RIGHT_BUTTON]->SetTouchMargin(leftTouchMargin, 0.0f, rightTouchMargin, 0.0f);
7466
7467                                                 __itemArea.width -= (headerRightButtonWidth);
7468                                         }
7469                                         else
7470                                         {
7471                                                 __pButtonItems[RIGHT_BUTTON]->SetTouchMargin(leftTouchMargin, topTouchMargin, rightTouchMargin, bottomTouchMargin);
7472
7473                                                 __titleTextArea.width -= (headerRightButtonWidth);
7474                                                 __itemArea.width -= (headerRightButtonWidth);
7475                                         }
7476                                 }
7477                                 else
7478                                 {
7479                                         __pButtonItems[RIGHT_BUTTON]->SetBounds(FloatRectangle(__titleTextArea.width - headerRightButtonWidth , vmargin,
7480                                                         headerRightButtonWidth, headerButtonItemHeight));
7481
7482                                         if (__style == TOOLBAR_HEADER_SEGMENTED_WITH_TITLE || __style == TOOLBAR_TAB_WITH_TITLE)
7483                                         {
7484                                                 //__pButtonItems[RIGHT_BUTTON]->SetTouchMargin(0, 0, 0, 0);
7485
7486                                                 __itemArea.width -= (headerRightButtonWidth);
7487                                         }
7488                                         else
7489                                         {
7490                                                 //__pButtonItems[RIGHT_BUTTON]->SetTouchMargin(0.0f, topTouchMargin, 0.0f, bottomTouchMargin);
7491
7492                                                 __titleTextArea.width -= (headerRightButtonWidth);
7493                                                 __itemArea.width -= (headerRightButtonWidth);
7494                                         }
7495                                 }
7496                         }
7497                 }
7498                 else if (__pButtonItems[LEFT_BUTTON])
7499                 {
7500                         if (__pButtonItems[LEFT_BUTTON]->GetText() == L"")
7501                         {
7502                                 __pButtonItems[LEFT_BUTTON]->SetBounds(FloatRectangle(__titleTextArea.width - headerLeftButtonWidth, vmargin,
7503                                                 headerLeftButtonWidth, headerButtonItemHeight));
7504
7505                                 if (__style == TOOLBAR_HEADER_SEGMENTED_WITH_TITLE || __style == TOOLBAR_TAB_WITH_TITLE)
7506                                 {
7507                                         __pButtonItems[LEFT_BUTTON]->SetTouchMargin(leftTouchMargin, 0.0f, rightTouchMargin, 0.0f);
7508
7509                                         __itemArea.width -= (headerLeftButtonWidth);
7510                                 }
7511                                 else
7512                                 {
7513                                         __pButtonItems[LEFT_BUTTON]->SetTouchMargin(leftTouchMargin, topTouchMargin, rightTouchMargin, bottomTouchMargin);
7514
7515                                         __titleTextArea.width -= (headerLeftButtonWidth);
7516                                         __itemArea.width -= (headerLeftButtonWidth);
7517                                 }
7518                         }
7519                         else
7520                         {
7521                                 __pButtonItems[LEFT_BUTTON]->SetBounds(FloatRectangle(__titleTextArea.width - headerLeftButtonWidth , vmargin,
7522                                                 headerLeftButtonWidth, headerButtonItemHeight));
7523
7524                                 if (__style == TOOLBAR_HEADER_SEGMENTED_WITH_TITLE || __style == TOOLBAR_TAB_WITH_TITLE)
7525                                 {
7526                                         //__pButtonItems[LEFT_BUTTON]->SetTouchMargin(0, 0, 0, 0);
7527
7528                                         __itemArea.width -= (headerLeftButtonWidth);
7529                                 }
7530                                 else
7531                                 {
7532                                         //__pButtonItems[LEFT_BUTTON]->SetTouchMargin(0.0f, topTouchMargin, 0.0f, bottomTouchMargin);
7533
7534                                         __titleTextArea.width -= (headerLeftButtonWidth);
7535                                         __itemArea.width -= (headerLeftButtonWidth);
7536                                 }
7537                         }
7538                 }
7539
7540                 if ((__style == TOOLBAR_HEADER_SEGMENTED || __style == TOOLBAR_HEADER_SEGMENTED_WITH_TITLE)
7541                                 && __pButtonItems[LEFT_BUTTON] == null && __pButtonItems[RIGHT_BUTTON] == null)
7542                 {
7543                         // segment style with no button's right margin is same as left
7544                         __titleTextArea.width -= (headerLeftMargin + headerRightMargin);
7545                         __itemArea.width -= (headerLeftMargin + headerLeftMargin);
7546                 }
7547                 else if (!(__style == TOOLBAR_TAB || __style == TOOLBAR_TAB_WITH_TITLE || __style == TOOLBAR_TAB_LARGE))
7548                 {
7549                         __titleTextArea.width -= (headerLeftMargin + headerRightMargin);
7550                         __itemArea.width -= (headerLeftMargin + headerRightMargin);
7551                 }
7552
7553                 if (__style == TOOLBAR_TAB_WITH_TITLE)
7554                 {
7555                         __titleTextArea.width -= (headerLeftMargin + headerRightMargin);
7556                 }
7557
7558                 float processingAnimationIconSize = 0.0f;
7559
7560                 GET_SHAPE_CONFIG(HEADER::PROCESSING_ANIMATION_ICON_SIZE, GetOrientation(), processingAnimationIconSize);
7561
7562                 if (__pButtonItems[LEFT_BUTTON] && GetWaitingAnimationStatus(TOOLBAR_ANIMATION_POSITION_BUTTON_LEFT) != ANIMATION_STOPPED)
7563                 {
7564                         SetWaitingAnimationPosition(TOOLBAR_ANIMATION_POSITION_BUTTON_LEFT,
7565                                         (__pButtonItems[LEFT_BUTTON]->GetSizeF().width - processingAnimationIconSize) / 2,
7566                                         topTouchMargin + (__pButtonItems[LEFT_BUTTON]->GetSizeF().height - topTouchMargin - bottomTouchMargin - processingAnimationIconSize) / 2);
7567                 }
7568
7569                 if (__pButtonItems[RIGHT_BUTTON] && GetWaitingAnimationStatus(TOOLBAR_ANIMATION_POSITION_BUTTON_RIGHT) != ANIMATION_STOPPED)
7570                 {
7571                         SetWaitingAnimationPosition(TOOLBAR_ANIMATION_POSITION_BUTTON_RIGHT,
7572                                         (__pButtonItems[RIGHT_BUTTON]->GetSizeF().width - processingAnimationIconSize) / 2,
7573                                         topTouchMargin + (__pButtonItems[RIGHT_BUTTON]->GetSizeF().height - topTouchMargin - bottomTouchMargin - processingAnimationIconSize) / 2);
7574                 }
7575         }
7576         else  // footer or edit or HEADER_STYLE_BUTTON // side align
7577         {
7578                 float footerButtonItemWidth = 0.0f;
7579                 float footerButtonItemHeight = 0.0f;
7580                 float sipButtonItemTopMargin = 0.0f;
7581                 float footerLeftMargin = 0.0f;
7582                 FloatDimension softkeyDimension(0.0f, 0.0f);
7583
7584                 float leftTouchMargin = 0.0f;
7585                 float topTouchMargin = 0.0f;
7586                 float rightTouchMargin = 0.0f;
7587                 float bottomTouchMargin = 0.0f;
7588
7589                 if (__header == true && __style == TOOLBAR_TEXT) // sip
7590                 {
7591                         GET_SHAPE_CONFIG(HEADER::SIP_BUTTON_ITEM_LEFT_TOUCH_MARGIN, GetOrientation(), leftTouchMargin);
7592                         GET_SHAPE_CONFIG(HEADER::SIP_BUTTON_ITEM_TOP_TOUCH_MARGIN, GetOrientation(), topTouchMargin);
7593                         GET_SHAPE_CONFIG(HEADER::SIP_BUTTON_ITEM_RIGHT_TOUCH_MARGIN, GetOrientation(), rightTouchMargin);
7594                         GET_SHAPE_CONFIG(HEADER::SIP_BUTTON_ITEM_BOTTOM_TOUCH_MARGIN, GetOrientation(), bottomTouchMargin);
7595                 }
7596                 else
7597                 {
7598                         GET_SHAPE_CONFIG(FOOTER::BUTTON_ITEM_LEFT_TOUCH_MARGIN, GetOrientation(), leftTouchMargin);
7599                         GET_SHAPE_CONFIG(FOOTER::BUTTON_ITEM_TOP_TOUCH_MARGIN, GetOrientation(), topTouchMargin);
7600                         GET_SHAPE_CONFIG(FOOTER::BUTTON_ITEM_RIGHT_TOUCH_MARGIN, GetOrientation(), rightTouchMargin);
7601                         GET_SHAPE_CONFIG(FOOTER::BUTTON_ITEM_BOTTOM_TOUCH_MARGIN, GetOrientation(), bottomTouchMargin);
7602                 }
7603
7604                 if (__header == true && __style == TOOLBAR_TEXT)
7605                 {
7606                         GET_SHAPE_CONFIG(HEADER::BUTTON_ITEM_WIDTH, GetOrientation(), footerButtonItemWidth);
7607
7608                         if (GetOrientation() == _CONTROL_ORIENTATION_PORTRAIT) // sip && portrait
7609                         {
7610                                 GET_SHAPE_CONFIG(HEADER::BUTTON_ITEM_HEIGHT, GetOrientation(), footerButtonItemHeight);
7611                         }
7612                         else
7613                         {
7614                                 GET_SHAPE_CONFIG(FOOTER::BUTTON_ITEM_HEIGHT, GetOrientation(), footerButtonItemHeight);
7615                         }
7616                 }
7617                 else
7618                 {
7619                         GET_SHAPE_CONFIG(FOOTER::BUTTON_ITEM_WIDTH, GetOrientation(), footerButtonItemWidth);
7620                         GET_SHAPE_CONFIG(FOOTER::BUTTON_ITEM_HEIGHT, GetOrientation(), footerButtonItemHeight);
7621                 }
7622
7623                 GET_SHAPE_CONFIG(HEADER::SIP_BUTTON_ITEM_TOP_MARGIN, GetOrientation(), sipButtonItemTopMargin);
7624                 GET_SHAPE_CONFIG(FOOTER::LEFT_MARGIN, GetOrientation(), footerLeftMargin);
7625                 GET_DIMENSION_CONFIG(FOOTER::SOFTKEY_RECT_WITH_TEXT, GetOrientation(), softkeyDimension);
7626
7627                 if (__pButtonItems[MIDDLE_BUTTON])
7628                 {
7629                         __pButtonItems[MIDDLE_BUTTON]->SetPosition(FloatPoint((__itemArea.width - __pButtonItems[MIDDLE_BUTTON]->GetSizeF().width) / 2,
7630                                         __itemArea.height - __pButtonItems[MIDDLE_BUTTON]->GetSizeF().height));
7631                 }
7632
7633                 // footer or edit or HEADER_STYLE_BUTTON // side align
7634                 if (__pButtonItems[RIGHT_BUTTON])
7635                 {
7636                         if (__pButtonItems[LEFT_BUTTON])
7637                         {
7638                                 if (__style != TOOLBAR_SOFTKEY)
7639                                 {
7640                                         __pButtonItems[RIGHT_BUTTON]->SetBounds(FloatRectangle(__itemArea.width - footerButtonItemWidth - footerLeftMargin + rightTouchMargin,
7641                                                         (__itemArea.height - footerButtonItemHeight) / 2, footerButtonItemWidth, footerButtonItemHeight));
7642
7643                                         __pButtonItems[LEFT_BUTTON]->SetBounds(FloatRectangle(0.0f, (__itemArea.height - footerButtonItemHeight) / 2,
7644                                                         footerButtonItemWidth, footerButtonItemHeight));
7645
7646                                         __pButtonItems[RIGHT_BUTTON]->SetTouchMargin(leftTouchMargin, topTouchMargin, rightTouchMargin, bottomTouchMargin);
7647                                         __pButtonItems[LEFT_BUTTON]->SetTouchMargin(leftTouchMargin, topTouchMargin, rightTouchMargin, bottomTouchMargin);
7648                                 }
7649                                 else
7650                                 {
7651                                         if (__pButtonItems[RIGHT_BUTTON]->GetText() == L"")
7652                                         {
7653                                                 __pButtonItems[RIGHT_BUTTON]->SetPosition(FloatPoint(__itemArea.width - __pButtonItems[RIGHT_BUTTON]->GetSizeF().width,
7654                                                                 __itemArea.height - __pButtonItems[RIGHT_BUTTON]->GetSizeF().height));
7655                                         }
7656                                         else
7657                                         {
7658                                                 __pButtonItems[RIGHT_BUTTON]->SetBounds(FloatRectangle(__itemArea.width - softkeyDimension.width, __itemArea.height - softkeyDimension.height,
7659                                                                 softkeyDimension.width, softkeyDimension.height));
7660                                         }
7661
7662                                         if (__pButtonItems[LEFT_BUTTON]->GetText() == L"")
7663                                         {
7664                                                 __pButtonItems[LEFT_BUTTON]->SetPosition(FloatPoint(0.0f, __itemArea.height - __pButtonItems[LEFT_BUTTON]->GetSizeF().height));
7665                                         }
7666                                         else
7667                                         {
7668                                                 __pButtonItems[LEFT_BUTTON]->SetBounds(FloatRectangle(0.0f, __itemArea.height - softkeyDimension.height,
7669                                                                 softkeyDimension.width, softkeyDimension.height));
7670                                         }
7671                                 }
7672                         }
7673                         else
7674                         {
7675                                 if (__style != TOOLBAR_SOFTKEY)
7676                                 {
7677                                         __pButtonItems[RIGHT_BUTTON]->SetBounds(FloatRectangle(__itemArea.width - footerButtonItemWidth - footerLeftMargin + rightTouchMargin,
7678                                                         (__itemArea.height - footerButtonItemHeight) / 2, footerButtonItemWidth, footerButtonItemHeight));
7679
7680                                         __pButtonItems[RIGHT_BUTTON]->SetTouchMargin(leftTouchMargin, topTouchMargin, rightTouchMargin, bottomTouchMargin);
7681                                 }
7682                                 else
7683                                 {
7684                                         if (__pButtonItems[RIGHT_BUTTON]->GetText() == L"")
7685                                         {
7686                                                 __pButtonItems[RIGHT_BUTTON]->SetPosition(FloatPoint(__itemArea.width - __pButtonItems[RIGHT_BUTTON]->GetSizeF().width,
7687                                                                 __itemArea.height - __pButtonItems[RIGHT_BUTTON]->GetSizeF().height));
7688                                         }
7689                                         else
7690                                         {
7691                                                 __pButtonItems[RIGHT_BUTTON]->SetBounds(FloatRectangle(__itemArea.width - softkeyDimension.width, __itemArea.height - softkeyDimension.height,
7692                                                                 softkeyDimension.width, softkeyDimension.height));
7693                                         }
7694                                 }
7695                         }
7696                 }
7697                 else if (__pButtonItems[LEFT_BUTTON])
7698                 {
7699                         if (__style != TOOLBAR_SOFTKEY)
7700                         {
7701                                 __pButtonItems[LEFT_BUTTON]->SetBounds(FloatRectangle(0.0f, (__itemArea.height - footerButtonItemHeight) / 2,
7702                                                 footerButtonItemWidth, footerButtonItemHeight));
7703
7704                                 __pButtonItems[LEFT_BUTTON]->SetTouchMargin(leftTouchMargin, topTouchMargin, rightTouchMargin, bottomTouchMargin);
7705                         }
7706                         else
7707                         {
7708                                 if (__pButtonItems[LEFT_BUTTON]->GetText() == L"")
7709                                 {
7710                                         __pButtonItems[LEFT_BUTTON]->SetPosition(FloatPoint(0.0f, __itemArea.height - __pButtonItems[LEFT_BUTTON]->GetSizeF().height));
7711                                 }
7712                                 else
7713                                 {
7714                                         __pButtonItems[LEFT_BUTTON]->SetBounds(FloatRectangle(0.0f, __itemArea.height - softkeyDimension.height,
7715                                                         softkeyDimension.width, softkeyDimension.height));
7716                                 }
7717                         }
7718                 }
7719         }
7720
7721         if (__style != TOOLBAR_SOFTKEY)
7722         {
7723                 for (int i = 0; i < BUTTON_MAX; i++)
7724                 {
7725                         if (__pButtonItems[i] != null)
7726                         {
7727                                 RealignButtonItem(__pButtonItems[i]);
7728                         }
7729                 }
7730         }
7731
7732         __pToolbarPresenter->SetUsableAreaBounds(__titleTextArea);
7733
7734         if (0 == __itemCount)
7735         {
7736                 return E_SUCCESS;
7737         }
7738
7739         switch (__style)
7740         {
7741         case TOOLBAR_HEADER_SEGMENTED:
7742                 //fall through
7743         case TOOLBAR_HEADER_SEGMENTED_WITH_TITLE:
7744                 RearrangeHeaderSegmentedItems();
7745                 break;
7746
7747         case TOOLBAR_SEGMENTED:
7748                 RearrangeFooterSegmentedItems();
7749                 break;
7750
7751         case TOOLBAR_TAB:
7752                 //fall through
7753         case TOOLBAR_TAB_LARGE:
7754                 //fall through
7755         case TOOLBAR_TAB_WITH_TITLE:
7756                 RearrangeTabItmes();
7757                 break;
7758
7759         default:
7760                 RearrangeButtonItems();
7761                 break;
7762         }
7763
7764         return E_SUCCESS;
7765 }
7766
7767 result
7768 _Toolbar::RearrangeHeaderSegmentedItems(void)
7769 {
7770         float segmentedItemHeight = 0.0f;
7771         float leftMargin = 0.0f;
7772         float dividerWidth = 0.0f;
7773         float vmargin = 0.0f;
7774         float blockWidth[__itemCount];
7775         float fontSize = 0.0f;
7776         float multilineFontSize = 0.0f;
7777
7778         GET_SHAPE_CONFIG(HEADER::LEFT_MARGIN, GetOrientation(), leftMargin);
7779         GET_SHAPE_CONFIG(HEADER::DIVIDER_WIDTH, GetOrientation(), dividerWidth);
7780
7781         if (__style == TOOLBAR_HEADER_SEGMENTED)
7782         {
7783                 segmentedItemHeight = __itemArea.height;
7784                 GET_SHAPE_CONFIG(HEADER::BUTTON_ITEM_TOP_MARGIN, GetOrientation(), vmargin);
7785         }
7786         else if (__style == TOOLBAR_HEADER_SEGMENTED_WITH_TITLE)
7787         {
7788                 GET_SHAPE_CONFIG(HEADER::SEGMENTED_ITEM_HEIGHT, GetOrientation(), segmentedItemHeight);
7789                 GET_SHAPE_CONFIG(HEADER::TITLE_HEIGHT_WITH_SEGMENTED_ITEM, GetOrientation(), vmargin);
7790         }
7791
7792         if (__itemCount == 1 || __itemCount == 2)
7793         {
7794                 if (!(__pButtonItems[LEFT_BUTTON] || __pButtonItems[RIGHT_BUTTON])) // no button
7795                 {
7796                         blockWidth[0] = blockWidth[1] = (GetSizeF().width - dividerWidth ) / 2;
7797                 }
7798                 else
7799                 {
7800                         blockWidth[0] = blockWidth[1] = (__itemArea.width + leftMargin - dividerWidth) / 2;
7801                 }
7802
7803                 for (int i = 0; i < __itemCount ; i++)
7804                 {
7805                         __pItems.at(i)->SetBounds(FloatRectangle(blockWidth[0] * i + dividerWidth * i, vmargin, blockWidth[i], segmentedItemHeight));
7806
7807                         if (__pItems.at(i)->GetChildCount() != 0)
7808                         {
7809                                 _Label* existingBadgeIcon = dynamic_cast<_Label*>(__pItems.at(i)->GetChild(0));
7810
7811                                 if (existingBadgeIcon)
7812                                 {
7813                                         existingBadgeIcon->SetPosition(FloatPoint(blockWidth[1] - existingBadgeIcon->GetSizeF().width, 0));
7814                                         existingBadgeIcon = null;
7815                                 }
7816                         }
7817                 }
7818
7819                 GET_SHAPE_CONFIG(HEADER::SEGMENTED_ITEM_FONT_SIZE, GetOrientation(), fontSize); // 30
7820
7821                 if (__style == TOOLBAR_HEADER_SEGMENTED)
7822                 {
7823                         GET_SHAPE_CONFIG(HEADER::SEGMENTED_ITEM_MULTILINE_FONT_SIZE, GetOrientation(), multilineFontSize); // 28
7824                 }
7825                 else if (__style == TOOLBAR_HEADER_SEGMENTED_WITH_TITLE)
7826                 {
7827                         GET_SHAPE_CONFIG(HEADER::SEGMENTED_ITEM_FONT_SIZE_4_ITEM, GetOrientation(), multilineFontSize); // 24
7828                 }
7829         }
7830         else if (__itemCount == 3)
7831         {
7832                 if (!(__pButtonItems[LEFT_BUTTON] || __pButtonItems[RIGHT_BUTTON])) // no button
7833                 {
7834                         blockWidth[0] = blockWidth[1] = blockWidth[2] = (GetSizeF().width - dividerWidth * 2) / 3;
7835
7836                         __pItems.at(0)->SetBounds(FloatRectangle(0, vmargin, blockWidth[0], segmentedItemHeight));
7837                         __pItems.at(1)->SetBounds(FloatRectangle(blockWidth[0] + dividerWidth, vmargin, blockWidth[1], segmentedItemHeight));
7838                         __pItems.at(2)->SetBounds(FloatRectangle(GetSizeF().width - blockWidth[2],vmargin, blockWidth[2], segmentedItemHeight));
7839                 }
7840                 else
7841                 {
7842                         blockWidth[0] = blockWidth[1] = blockWidth[2] = (__itemArea.width + leftMargin - dividerWidth * 2) / 3;
7843
7844                         __pItems.at(0)->SetBounds(FloatRectangle(0, vmargin, blockWidth[0], segmentedItemHeight));
7845                         __pItems.at(1)->SetBounds(FloatRectangle(blockWidth[0] + dividerWidth, vmargin, blockWidth[1], segmentedItemHeight));
7846                         __pItems.at(2)->SetBounds(FloatRectangle(blockWidth[0] + blockWidth[1] + dividerWidth * 2,
7847                                         vmargin, blockWidth[2], segmentedItemHeight));
7848                 }
7849
7850                 for (int i = 0; i < __itemCount; i++)
7851                 {
7852                         if (__pItems.at(i)->GetChildCount() != 0)
7853                         {
7854                                 _Label* existingBadgeIcon = dynamic_cast<_Label*>(__pItems.at(i)->GetChild(0));
7855
7856                                 if (existingBadgeIcon)
7857                                 {
7858                                         existingBadgeIcon->SetPosition(FloatPoint(blockWidth[i] - existingBadgeIcon->GetSizeF().width, 0));
7859                                         existingBadgeIcon = null;
7860                                 }
7861                         }
7862                 }
7863
7864                 GET_SHAPE_CONFIG(HEADER::SEGMENTED_ITEM_FONT_SIZE_3_ITEM, GetOrientation(), fontSize); // 26
7865
7866                 if (__style == TOOLBAR_HEADER_SEGMENTED)
7867                 {
7868                         GET_SHAPE_CONFIG(HEADER::SEGMENTED_ITEM_FONT_SIZE_3_ITEM, GetOrientation(), multilineFontSize); // 26
7869                 }
7870                 else if (__style == TOOLBAR_HEADER_SEGMENTED_WITH_TITLE)
7871                 {
7872                         GET_SHAPE_CONFIG(HEADER::SEGMENTED_ITEM_FONT_SIZE_4_ITEM, GetOrientation(), multilineFontSize); //24
7873                 }
7874         }
7875         else if (__itemCount == 4)
7876         {
7877                 if (!(__pButtonItems[LEFT_BUTTON] || __pButtonItems[RIGHT_BUTTON])) // no button
7878                 {
7879                         blockWidth[0] = blockWidth[1] = blockWidth[2] = blockWidth[3] = (GetSizeF().width - dividerWidth * 3) / 4;
7880
7881                         __pItems.at(0)->SetBounds(FloatRectangle(0, vmargin, blockWidth[0], segmentedItemHeight));
7882                         __pItems.at(1)->SetBounds(FloatRectangle(blockWidth[0] + dividerWidth, vmargin, blockWidth[1], segmentedItemHeight));
7883                         __pItems.at(2)->SetBounds(FloatRectangle(blockWidth[0] + blockWidth[1] + dividerWidth * 2,
7884                                         vmargin, blockWidth[2], segmentedItemHeight));
7885                         __pItems.at(3)->SetBounds(FloatRectangle(blockWidth[0] + blockWidth[1] + blockWidth[2] + dividerWidth * 3,
7886                                         vmargin, GetSizeF().width - (blockWidth[0] + blockWidth[1] + blockWidth[2] + dividerWidth * 3), segmentedItemHeight));
7887                 }
7888                 else
7889                 {
7890                         blockWidth[0] = blockWidth[1] = blockWidth[2] = blockWidth[3] = (__itemArea.width + leftMargin - dividerWidth * 3) / 4;
7891
7892                         __pItems.at(0)->SetBounds(FloatRectangle(0, vmargin, blockWidth[0], segmentedItemHeight));
7893                         __pItems.at(1)->SetBounds(FloatRectangle(blockWidth[0] + dividerWidth, vmargin, blockWidth[1], segmentedItemHeight));
7894                         __pItems.at(2)->SetBounds(FloatRectangle(blockWidth[0] + blockWidth[1] + dividerWidth * 2,
7895                                         vmargin, blockWidth[2], segmentedItemHeight));
7896                         __pItems.at(3)->SetBounds(FloatRectangle(blockWidth[0] + blockWidth[1] + blockWidth[2] + dividerWidth * 3,
7897                                         vmargin, blockWidth[3], segmentedItemHeight));
7898                 }
7899
7900                 for (int i = 0; i < __itemCount ; i++)
7901                 {
7902                         if (__pItems.at(i)->GetChildCount() != 0)
7903                         {
7904                                 _Label* existingBadgeIcon = dynamic_cast<_Label*>(__pItems.at(i)->GetChild(0));
7905
7906                                 if (existingBadgeIcon)
7907                                 {
7908                                         existingBadgeIcon->SetPosition(FloatPoint(blockWidth[i] - existingBadgeIcon->GetSizeF().width, 0));
7909                                         existingBadgeIcon = null;
7910                                 }
7911                         }
7912                 }
7913
7914                 GET_SHAPE_CONFIG(HEADER::SEGMENTED_ITEM_FONT_SIZE_4_ITEM, GetOrientation(), fontSize);
7915                 GET_SHAPE_CONFIG(HEADER::SEGMENTED_ITEM_FONT_SIZE_4_ITEM, GetOrientation(), multilineFontSize);
7916         }
7917
7918         for (int i = 0; i < __itemCount; i++)
7919         {
7920                 __pItems.at(i)->SetTextSize(fontSize, FONT_STYLE_BOLD);
7921                 __pItems.at(i)->SetMultilineTextSize(multilineFontSize);
7922
7923                 RealignItem(__pItems.at(i), __pItems.at(i)->GetTextExtentSizeF());
7924         }
7925
7926         return E_SUCCESS;
7927 }
7928
7929 result
7930 _Toolbar::RearrangeFooterSegmentedItems(void)
7931 {
7932         float segmentedItemHeight = __itemArea.height;
7933
7934         float leftMargin = 0.0f;
7935         float rightMargin = 0.0f;
7936         float footerLeftMargin = 0.0f;
7937         float iconSize = 0.0f;
7938         float dividerWidth = 0.0f;
7939         float blockWidth[__itemCount];
7940         float fontSize = 0.0f;
7941         float multilineFontSize = 0.0f;
7942
7943         float itemButtonLeftGap = 0.0f;
7944         float itemButtonRightGap = 0.0f;
7945
7946         GET_SHAPE_CONFIG(HEADER::LEFT_MARGIN, GetOrientation(), leftMargin);
7947         GET_SHAPE_CONFIG(FOOTER::LEFT_MARGIN, GetOrientation(), footerLeftMargin);
7948         GET_SHAPE_CONFIG(FOOTER::FOOTER_ITEM_ICON_SIZE, GetOrientation(), iconSize);
7949         GET_SHAPE_CONFIG(HEADER::DIVIDER_WIDTH, GetOrientation(), dividerWidth);
7950
7951         rightMargin = leftMargin;
7952
7953         if (__itemCount == 1)
7954         {
7955                 if (__pButtonItems[LEFT_BUTTON])
7956                 {
7957                         if (__pButtonItems[RIGHT_BUTTON])
7958                         {
7959                                 leftMargin = footerLeftMargin;
7960                                 itemButtonLeftGap = footerLeftMargin;
7961                                 __itemArea.width -= ((leftMargin + iconSize + itemButtonLeftGap) * 2);
7962                         }
7963                         else
7964                         {
7965                                 leftMargin = footerLeftMargin;
7966                                 itemButtonLeftGap = footerLeftMargin;
7967                                 __itemArea.width -= (iconSize + itemButtonLeftGap + rightMargin);
7968                         }
7969                 }
7970                 else
7971                 {
7972                         if (__pButtonItems[RIGHT_BUTTON])
7973                         {
7974                                 rightMargin = footerLeftMargin;
7975                                 itemButtonRightGap = footerLeftMargin;
7976                                 __itemArea.width -= (itemButtonRightGap + iconSize + rightMargin);
7977                         }
7978
7979                         iconSize = 0;
7980                         leftMargin = 0;
7981                         itemButtonLeftGap = 0;
7982                 }
7983
7984                 blockWidth[0] = __itemArea.width;
7985
7986                 if (__pButtonItems[LEFT_BUTTON])
7987                 {
7988                         if (__pButtonItems[RIGHT_BUTTON])
7989                         {
7990                                 __pItems.at(0)->SetBounds(FloatRectangle(dividerWidth + leftMargin + iconSize + itemButtonLeftGap, (GetSizeF().height - segmentedItemHeight) / 2, blockWidth[0] - dividerWidth * 2, segmentedItemHeight));
7991                         }
7992                         else
7993                         {
7994                                 __pItems.at(0)->SetBounds(FloatRectangle(dividerWidth + leftMargin + iconSize + itemButtonLeftGap, (GetSizeF().height - segmentedItemHeight) / 2, blockWidth[0] - dividerWidth, segmentedItemHeight));
7995                         }
7996                 }
7997                 else
7998                 {
7999                         if (__pButtonItems[RIGHT_BUTTON])
8000                         {
8001                                 __pItems.at(0)->SetBounds(FloatRectangle(leftMargin + iconSize + itemButtonLeftGap, (GetSizeF().height - segmentedItemHeight) / 2, blockWidth[0] - dividerWidth, segmentedItemHeight));
8002                         }
8003                         else
8004                         {
8005                                 __pItems.at(0)->SetBounds(FloatRectangle(leftMargin + iconSize + itemButtonLeftGap, (GetSizeF().height - segmentedItemHeight) / 2, blockWidth[0], segmentedItemHeight));
8006                         }
8007                 }
8008
8009                 for (int i = 0; i < __itemCount ; i++)
8010                 {
8011                         if (__pItems.at(i)->GetChildCount() != 0)
8012                         {
8013                                 _Label* existingBadgeIcon = dynamic_cast<_Label*>(__pItems.at(i)->GetChild(0));
8014
8015                                 if (existingBadgeIcon)
8016                                 {
8017                                         existingBadgeIcon->SetPosition(FloatPoint(blockWidth[i] - existingBadgeIcon->GetSizeF().width, 0));
8018                                         existingBadgeIcon = null;
8019                                 }
8020                         }
8021                 }
8022
8023                 GET_SHAPE_CONFIG(HEADER::SEGMENTED_ITEM_FONT_SIZE, GetOrientation(), fontSize);
8024                 GET_SHAPE_CONFIG(HEADER::SEGMENTED_ITEM_MULTILINE_FONT_SIZE, GetOrientation(), multilineFontSize);
8025         }
8026         else if ( __itemCount == 2)
8027         {
8028                 if (__pButtonItems[LEFT_BUTTON])
8029                 {
8030                         if (__pButtonItems[RIGHT_BUTTON])
8031                         {
8032                                 leftMargin = footerLeftMargin;
8033                                 itemButtonLeftGap = footerLeftMargin;
8034                                 __itemArea.width -= ((leftMargin + iconSize + itemButtonLeftGap) * 2);
8035                         }
8036                         else
8037                         {
8038                                 leftMargin = footerLeftMargin;
8039                                 itemButtonLeftGap = footerLeftMargin;
8040                                 __itemArea.width -= (iconSize + itemButtonLeftGap + rightMargin);
8041                         }
8042                 }
8043                 else
8044                 {
8045                         if (__pButtonItems[RIGHT_BUTTON])
8046                         {
8047                                 rightMargin = footerLeftMargin;
8048                                 itemButtonRightGap = footerLeftMargin;
8049                                 __itemArea.width -= (itemButtonRightGap + iconSize + rightMargin);
8050                         }
8051
8052                         iconSize = 0;
8053                         leftMargin = 0;
8054                         itemButtonLeftGap = 0;
8055                 }
8056
8057                 blockWidth[0] = blockWidth[1] = (__itemArea.width - dividerWidth) / 2;
8058
8059                 if (__pButtonItems[LEFT_BUTTON])
8060                 {
8061                         if (__pButtonItems[RIGHT_BUTTON])
8062                         {
8063                                 __pItems.at(0)->SetBounds(FloatRectangle(dividerWidth + leftMargin + iconSize + itemButtonLeftGap, (GetSizeF().height - segmentedItemHeight) / 2, blockWidth[0] - dividerWidth, segmentedItemHeight));
8064                                 __pItems.at(1)->SetBounds(FloatRectangle(leftMargin + iconSize + itemButtonLeftGap + blockWidth[0] + dividerWidth, (GetSizeF().height - segmentedItemHeight) / 2, blockWidth[1] - dividerWidth, segmentedItemHeight));
8065                         }
8066                         else
8067                         {
8068                                 __pItems.at(0)->SetBounds(FloatRectangle(dividerWidth + leftMargin + iconSize + itemButtonLeftGap, (GetSizeF().height - segmentedItemHeight) / 2, blockWidth[0] - dividerWidth, segmentedItemHeight));
8069                                 __pItems.at(1)->SetBounds(FloatRectangle(leftMargin + iconSize + itemButtonLeftGap + blockWidth[0] + dividerWidth, (GetSizeF().height - segmentedItemHeight) / 2, blockWidth[1], segmentedItemHeight));
8070                         }
8071                 }
8072                 else
8073                 {
8074                         if (__pButtonItems[RIGHT_BUTTON])
8075                         {
8076                                 __pItems.at(0)->SetBounds(FloatRectangle(leftMargin + iconSize + itemButtonLeftGap, (GetSizeF().height - segmentedItemHeight) / 2, blockWidth[0], segmentedItemHeight));
8077                                 __pItems.at(1)->SetBounds(FloatRectangle(leftMargin + iconSize + itemButtonLeftGap + blockWidth[0] + dividerWidth, (GetSizeF().height - segmentedItemHeight) / 2, blockWidth[1] - dividerWidth, segmentedItemHeight));
8078                         }
8079                         else
8080                         {
8081                                 __pItems.at(0)->SetBounds(FloatRectangle(leftMargin + iconSize + itemButtonLeftGap, (GetSizeF().height - segmentedItemHeight) / 2, blockWidth[0], segmentedItemHeight));
8082                                 __pItems.at(1)->SetBounds(FloatRectangle(leftMargin + iconSize + itemButtonLeftGap + blockWidth[0] + dividerWidth, (GetSizeF().height - segmentedItemHeight) / 2, blockWidth[1], segmentedItemHeight));
8083                         }
8084                 }
8085
8086
8087                 for (int i = 0; i < __itemCount ; i++)
8088                 {
8089                         if (__pItems.at(i)->GetChildCount() != 0)
8090                         {
8091                                 _Label* existingBadgeIcon = dynamic_cast<_Label*>(__pItems.at(i)->GetChild(0));
8092
8093                                 if (existingBadgeIcon)
8094                                 {
8095                                         existingBadgeIcon->SetPosition(FloatPoint(blockWidth[i] - existingBadgeIcon->GetSizeF().width, 0));
8096                                         existingBadgeIcon = null;
8097                                 }
8098                         }
8099                 }
8100
8101                 GET_SHAPE_CONFIG(HEADER::SEGMENTED_ITEM_FONT_SIZE, GetOrientation(), fontSize);
8102                 GET_SHAPE_CONFIG(HEADER::SEGMENTED_ITEM_MULTILINE_FONT_SIZE, GetOrientation(), multilineFontSize);
8103         }
8104         else if (__itemCount == 3)
8105         {
8106                 if (__pButtonItems[LEFT_BUTTON])
8107                 {
8108                         if (__pButtonItems[RIGHT_BUTTON])
8109                         {
8110                                 leftMargin = footerLeftMargin;
8111                                 itemButtonLeftGap = footerLeftMargin;
8112                                 __itemArea.width -= ((leftMargin + iconSize + itemButtonLeftGap) * 2);
8113                         }
8114                         else
8115                         {
8116                                 leftMargin = footerLeftMargin;
8117                                 itemButtonLeftGap = footerLeftMargin;
8118                                 __itemArea.width -= (iconSize + itemButtonLeftGap + rightMargin);
8119                         }
8120                 }
8121                 else
8122                 {
8123                         if (__pButtonItems[RIGHT_BUTTON])
8124                         {
8125                                 rightMargin = footerLeftMargin;
8126                                 itemButtonRightGap = footerLeftMargin;
8127                                 __itemArea.width -= (itemButtonRightGap + iconSize + rightMargin);
8128                         }
8129
8130
8131                         iconSize = 0;
8132                         leftMargin = 0;
8133                         itemButtonLeftGap = 0;
8134                 }
8135
8136                 blockWidth[0] = blockWidth[1] = blockWidth[2] = (__itemArea.width - dividerWidth * 2) / 3;
8137
8138                 if (__pButtonItems[LEFT_BUTTON])
8139                 {
8140                         if (__pButtonItems[RIGHT_BUTTON])
8141                         {
8142                                 __pItems.at(0)->SetBounds(FloatRectangle(dividerWidth + leftMargin + iconSize + itemButtonLeftGap, (GetSizeF().height - segmentedItemHeight) / 2, blockWidth[0] - dividerWidth, segmentedItemHeight));
8143                                 __pItems.at(1)->SetBounds(FloatRectangle(leftMargin + iconSize + itemButtonLeftGap + blockWidth[0] + dividerWidth, (GetSizeF().height - segmentedItemHeight) / 2, blockWidth[1], segmentedItemHeight));
8144                                 __pItems.at(2)->SetBounds(FloatRectangle(leftMargin + iconSize + itemButtonLeftGap + blockWidth[0] + blockWidth[1] + dividerWidth * 2,
8145                                                 (GetSizeF().height - segmentedItemHeight) / 2, blockWidth[2] - dividerWidth, segmentedItemHeight));
8146                         }
8147                         else
8148                         {
8149                                 __pItems.at(0)->SetBounds(FloatRectangle(dividerWidth + leftMargin + iconSize + itemButtonLeftGap, (GetSizeF().height - segmentedItemHeight) / 2, blockWidth[0] - dividerWidth, segmentedItemHeight));
8150                                 __pItems.at(1)->SetBounds(FloatRectangle(leftMargin + iconSize + itemButtonLeftGap + blockWidth[0] + dividerWidth, (GetSizeF().height - segmentedItemHeight) / 2, blockWidth[1], segmentedItemHeight));
8151                                 __pItems.at(2)->SetBounds(FloatRectangle(leftMargin + iconSize + itemButtonLeftGap + blockWidth[0] + blockWidth[1] + dividerWidth * 2,
8152                                                 (GetSizeF().height - segmentedItemHeight) / 2, blockWidth[2], segmentedItemHeight));
8153                         }
8154                 }
8155                 else
8156                 {
8157                         if (__pButtonItems[RIGHT_BUTTON])
8158                         {
8159                                 __pItems.at(0)->SetBounds(FloatRectangle(leftMargin + iconSize + itemButtonLeftGap, (GetSizeF().height - segmentedItemHeight) / 2, blockWidth[0], segmentedItemHeight));
8160                                 __pItems.at(1)->SetBounds(FloatRectangle(leftMargin + iconSize + itemButtonLeftGap + blockWidth[0] + dividerWidth, (GetSizeF().height - segmentedItemHeight) / 2, blockWidth[1], segmentedItemHeight));
8161                                 __pItems.at(2)->SetBounds(FloatRectangle(leftMargin + iconSize + itemButtonLeftGap + blockWidth[0] + blockWidth[1] + dividerWidth * 2,
8162                                                 (GetSizeF().height - segmentedItemHeight) / 2, blockWidth[2] - dividerWidth, segmentedItemHeight));
8163                         }
8164                         else
8165                         {
8166                                 __pItems.at(0)->SetBounds(FloatRectangle(leftMargin + iconSize + itemButtonLeftGap, (GetSizeF().height - segmentedItemHeight) / 2, blockWidth[0], segmentedItemHeight));
8167                                 __pItems.at(1)->SetBounds(FloatRectangle(leftMargin + iconSize + itemButtonLeftGap + blockWidth[0] + dividerWidth, (GetSizeF().height - segmentedItemHeight) / 2, blockWidth[1], segmentedItemHeight));
8168                                 __pItems.at(2)->SetBounds(FloatRectangle(leftMargin + iconSize + itemButtonLeftGap + blockWidth[0] + blockWidth[1] + dividerWidth * 2,
8169                                                 (GetSizeF().height - segmentedItemHeight) / 2, blockWidth[2], segmentedItemHeight));
8170                         }
8171                 }
8172
8173                 for (int i = 0; i < __itemCount ; i++)
8174                 {
8175                         if (__pItems.at(i)->GetChildCount() != 0)
8176                         {
8177                                 _Label* existingBadgeIcon = dynamic_cast<_Label*>(__pItems.at(i)->GetChild(0));
8178
8179                                 if (existingBadgeIcon)
8180                                 {
8181                                         existingBadgeIcon->SetPosition(FloatPoint(blockWidth[i] - existingBadgeIcon->GetSizeF().width, 0));
8182                                         existingBadgeIcon = null;
8183                                 }
8184                         }
8185                 }
8186
8187                 GET_SHAPE_CONFIG(HEADER::SEGMENTED_ITEM_FONT_SIZE_3_ITEM, GetOrientation(), fontSize);
8188                 GET_SHAPE_CONFIG(HEADER::SEGMENTED_ITEM_FONT_SIZE_3_ITEM, GetOrientation(), multilineFontSize);
8189         }
8190         else if (__itemCount == 4)
8191         {
8192                 leftMargin = 0;
8193
8194                 blockWidth[0] = blockWidth[1] = blockWidth[2] = blockWidth[3] = (__itemArea.width - dividerWidth * 3) / 4;
8195
8196                 __pItems.at(0)->SetBounds(FloatRectangle(leftMargin, (GetSizeF().height - segmentedItemHeight) / 2, blockWidth[0], segmentedItemHeight));
8197                 __pItems.at(1)->SetBounds(FloatRectangle(leftMargin + blockWidth[0] + dividerWidth, (GetSizeF().height - segmentedItemHeight) / 2, blockWidth[1], segmentedItemHeight));
8198                 __pItems.at(2)->SetBounds(FloatRectangle(leftMargin + blockWidth[0] + blockWidth[1] + dividerWidth * 2,
8199                                 (GetSizeF().height - segmentedItemHeight) / 2, blockWidth[2], segmentedItemHeight));
8200                 __pItems.at(3)->SetBounds(FloatRectangle(leftMargin + blockWidth[0] + blockWidth[1] + blockWidth[2] + dividerWidth * 3,
8201                                 (GetSizeF().height - segmentedItemHeight) / 2, blockWidth[3], segmentedItemHeight));
8202
8203                 for (int i = 0; i < __itemCount ; i++)
8204                 {
8205                         if (__pItems.at(i)->GetChildCount() != 0)
8206                         {
8207                                 _Label* existingBadgeIcon = dynamic_cast<_Label*>(__pItems.at(i)->GetChild(0));
8208
8209                                 if (existingBadgeIcon)
8210                                 {
8211                                         existingBadgeIcon->SetPosition(FloatPoint(blockWidth[i] - existingBadgeIcon->GetSizeF().width, 0));
8212                                         existingBadgeIcon = null;
8213                                 }
8214                         }
8215                 }
8216
8217                 GET_SHAPE_CONFIG(HEADER::SEGMENTED_ITEM_FONT_SIZE_4_ITEM, GetOrientation(), fontSize);
8218                 GET_SHAPE_CONFIG(HEADER::SEGMENTED_ITEM_FONT_SIZE_4_ITEM, GetOrientation(), multilineFontSize);
8219         }
8220
8221         for (int i = 0; i < __itemCount ; i++)
8222         {
8223                 __pItems.at(i)->SetTextSize(fontSize, FONT_STYLE_BOLD);
8224                 __pItems.at(i)->SetMultilineTextSize(multilineFontSize);
8225
8226                 RealignItem(__pItems.at(i), __pItems.at(i)->GetTextExtentSizeF());
8227         }
8228
8229         return E_SUCCESS;
8230 }
8231
8232 result
8233 _Toolbar::RearrangeTabItmes(void)
8234 {
8235         float itemWidth[__itemCount];
8236         float fontSize = 0.0f;
8237         float multilineFontSize = 0.0f;
8238         float segmentedItemHeight = 0.0f;
8239         float tabLeftMargin = 0.0f;
8240         float vmargin = 0.0f;
8241         float dividerWidth = 0.0f;
8242
8243         GET_SHAPE_CONFIG(HEADER::TAB_LEFT_MARGIN, GetOrientation(), tabLeftMargin);
8244         GET_SHAPE_CONFIG(HEADER::DIVIDER_WIDTH, GetOrientation(), dividerWidth);
8245
8246         if (__style == TOOLBAR_TAB || __style == TOOLBAR_TAB_LARGE)
8247         {
8248                 segmentedItemHeight = __itemArea.height;
8249         }
8250         else if (__style == TOOLBAR_TAB_WITH_TITLE)
8251         {
8252                 GET_SHAPE_CONFIG(HEADER::SEGMENTED_ITEM_HEIGHT, GetOrientation(), segmentedItemHeight);
8253                 GET_SHAPE_CONFIG(HEADER::TITLE_HEIGHT_WITH_SEGMENTED_ITEM, GetOrientation(), vmargin);
8254         }
8255
8256         if (__itemCount == 1)
8257         {
8258                 itemWidth[0] = __itemArea.width - tabLeftMargin * 2;
8259                 __pItems.at(0)->SetBounds(FloatRectangle(tabLeftMargin, vmargin, itemWidth[0], segmentedItemHeight));
8260
8261
8262                 GET_SHAPE_CONFIG(HEADER::TAB_ITEM_FONT_SIZE, GetOrientation(), fontSize); // 30
8263
8264                 if (__style == TOOLBAR_TAB || __style == TOOLBAR_TAB_LARGE)
8265                 {
8266                         GET_SHAPE_CONFIG(HEADER::TAB_ITEM_MULTILINE_FONT_SIZE, GetOrientation(), multilineFontSize); // 28
8267                 }
8268                 else if (__style == TOOLBAR_TAB_WITH_TITLE)
8269                 {
8270                         GET_SHAPE_CONFIG(HEADER::TAB_ITEM_FONT_SIZE_4_ITEM, GetOrientation(), multilineFontSize); // 24
8271                 }
8272         }
8273         else if (__itemCount == 2)
8274         {
8275                 itemWidth[0] = itemWidth[1] = (__itemArea.width - tabLeftMargin * 2 - dividerWidth) / 2;
8276
8277                 __pItems.at(0)->SetBounds(FloatRectangle(tabLeftMargin, vmargin, itemWidth[0], segmentedItemHeight));
8278                 __pItems.at(1)->SetBounds(FloatRectangle(tabLeftMargin + itemWidth[0] + dividerWidth, vmargin, itemWidth[1], segmentedItemHeight));
8279
8280                 GET_SHAPE_CONFIG(HEADER::TAB_ITEM_FONT_SIZE, GetOrientation(), fontSize); // 30
8281
8282                 if (__style == TOOLBAR_TAB || __style == TOOLBAR_TAB_LARGE)
8283                 {
8284                         GET_SHAPE_CONFIG(HEADER::TAB_ITEM_MULTILINE_FONT_SIZE, GetOrientation(), multilineFontSize); // 28
8285                 }
8286                 else if (__style == TOOLBAR_TAB_WITH_TITLE)
8287                 {
8288                         GET_SHAPE_CONFIG(HEADER::TAB_ITEM_FONT_SIZE_4_ITEM, GetOrientation(), multilineFontSize); // 24
8289                 }
8290         }
8291         else if (__itemCount == 3)
8292         {
8293                 itemWidth[0] = itemWidth[1] = itemWidth[2] = (__itemArea.width - tabLeftMargin * 2 - dividerWidth * 2) / 3;
8294
8295                 __pItems.at(0)->SetBounds(FloatRectangle(tabLeftMargin, vmargin, itemWidth[0], segmentedItemHeight));
8296                 __pItems.at(1)->SetBounds(FloatRectangle(tabLeftMargin + itemWidth[0] + dividerWidth, vmargin, itemWidth[1], segmentedItemHeight));
8297                 __pItems.at(2)->SetBounds(FloatRectangle(tabLeftMargin + itemWidth[0] + itemWidth[1] + dividerWidth * 2, vmargin, itemWidth[2], segmentedItemHeight));
8298
8299                 GET_SHAPE_CONFIG(HEADER::TAB_ITEM_FONT_SIZE_3_ITEM, GetOrientation(), fontSize); // 26
8300
8301                 if (__style == TOOLBAR_TAB || __style == TOOLBAR_TAB_LARGE)
8302                 {
8303                         GET_SHAPE_CONFIG(HEADER::TAB_ITEM_FONT_SIZE_3_ITEM, GetOrientation(), multilineFontSize); // 26
8304                 }
8305                 else if (__style == TOOLBAR_TAB_WITH_TITLE)
8306                 {
8307                         GET_SHAPE_CONFIG(HEADER::TAB_ITEM_FONT_SIZE_4_ITEM, GetOrientation(), multilineFontSize); // 24
8308                 }
8309         }
8310         else
8311         {
8312                 itemWidth[0] = itemWidth[1] = itemWidth[2] = itemWidth[3] = (__itemArea.width - tabLeftMargin * 2 - dividerWidth * 3) / 4;
8313
8314                 __pItems.at(0)->SetBounds(FloatRectangle(tabLeftMargin, vmargin, itemWidth[0], segmentedItemHeight));
8315                 __pItems.at(1)->SetBounds(FloatRectangle(tabLeftMargin + itemWidth[0] + dividerWidth, vmargin, itemWidth[1], segmentedItemHeight));
8316                 __pItems.at(2)->SetBounds(FloatRectangle(tabLeftMargin + itemWidth[0] + itemWidth[1] + dividerWidth * 2,
8317                                 vmargin, itemWidth[2], segmentedItemHeight));
8318                 __pItems.at(3)->SetBounds(FloatRectangle(tabLeftMargin + itemWidth[0] + itemWidth[1] + itemWidth[2] + dividerWidth * 3,
8319                                 vmargin, itemWidth[3], segmentedItemHeight));
8320
8321                 GET_SHAPE_CONFIG(HEADER::TAB_ITEM_FONT_SIZE_4_ITEM, GetOrientation(), fontSize); // 24
8322                 GET_SHAPE_CONFIG(HEADER::TAB_ITEM_FONT_SIZE_4_ITEM, GetOrientation(), multilineFontSize); // 24
8323         }
8324
8325         for (int i = 4; i < __itemCount ; i++)
8326         {
8327                 itemWidth[i] = itemWidth[0];
8328
8329                 __pItems.at(i)->SetBounds(FloatRectangle(__pItems.at(i-1)->GetBoundsF().x + dividerWidth + itemWidth[i], vmargin, itemWidth[i], segmentedItemHeight));
8330         }
8331
8332         for (int i = 0; i < __itemCount ; i++)
8333         {
8334                 __pItems.at(i)->SetTextSize(fontSize, FONT_STYLE_BOLD);
8335                 __pItems.at(i)->SetMultilineTextSize(multilineFontSize);
8336
8337                 if (__pItems.at(i)->GetChildCount() != 0)
8338                 {
8339                         _Label* existingBadgeIcon = dynamic_cast<_Label*>(__pItems.at(i)->GetChild(0));
8340
8341                         if (existingBadgeIcon)
8342                         {
8343                                 existingBadgeIcon->SetPosition(FloatPoint(__pItems.at(i)->GetSizeF().width - existingBadgeIcon->GetSizeF().width, 0));
8344                                 existingBadgeIcon = null;
8345                         }
8346                 }
8347
8348                 RealignItem(__pItems.at(i), __pItems.at(i)->GetTextExtentSizeF());
8349         }
8350
8351         return E_SUCCESS;
8352 }
8353
8354 result
8355 _Toolbar::RearrangeButtonItems(void)
8356 {
8357         float itemHeight = 0.0f;
8358         float sideMargin = 0.0f;
8359         float itemButtonLeftGap = 0.0f;
8360         float itemButtonRightGap = 0.0f;
8361         float tabLeftMargin = 0.0f;
8362         float dividerWidth = 0.0f;
8363         float iconSize = 0.0f;
8364         float footerLeftMargin = 0.0f;
8365         float segmentedItemHeight = 0.0f;
8366         float headerLeftMargin = 0.0f;
8367         float blockWidth[__itemCount];
8368         float fontSize = 0.0f;
8369         float multilineFontSize = 0.0f;
8370
8371         GET_SHAPE_CONFIG(HEADER::DIVIDER_WIDTH, GetOrientation(), dividerWidth);
8372         GET_SHAPE_CONFIG(FOOTER::FOOTER_ITEM_ICON_SIZE, GetOrientation(), iconSize);
8373         GET_SHAPE_CONFIG(FOOTER::LEFT_MARGIN, GetOrientation(), footerLeftMargin);
8374         GET_SHAPE_CONFIG(HEADER::TAB_LEFT_MARGIN, GetOrientation(), tabLeftMargin);
8375         GET_SHAPE_CONFIG(FOOTER::FOOTER_ITEM_BUTTON_STYLE_SIDE_MARGIN, GetOrientation(), sideMargin);
8376         GET_SHAPE_CONFIG(HEADER::SEGMENTED_ITEM_HEIGHT, GetOrientation(), segmentedItemHeight);
8377         GET_SHAPE_CONFIG(HEADER::LEFT_MARGIN, GetOrientation(), headerLeftMargin);
8378
8379         float tabRightMargin = tabLeftMargin;
8380
8381         itemHeight = GetSizeF().height;
8382
8383         if (__itemCount == 1)
8384         {
8385                 float textExtentSize_0 = __pItems.at(0)->GetTextExtentSizeF();
8386
8387                 if (__style == TOOLBAR_TITLE) // item 1, HEADER_STYLE_TITLE_BUTTON
8388                 {
8389                         if (__pButtonItems[LEFT_BUTTON] || __pButtonItems[RIGHT_BUTTON])
8390                         {
8391                                 blockWidth[0] = __itemArea.width + headerLeftMargin;
8392                         }
8393                         else
8394                         {
8395                                 blockWidth[0] = GetSizeF().width;
8396                         }
8397
8398                         __pItems.at(0)->SetBounds(FloatRectangle(0, (GetSizeF().height - itemHeight) / 2, blockWidth[0], itemHeight));
8399                         __pItems.at(0)->SetMargin(0.0f, 0.0f, 0.0f, 0.0f);
8400                 }
8401                 else
8402                 {
8403                         if (__pButtonItems[LEFT_BUTTON])
8404                         {
8405                                 if (__pButtonItems[RIGHT_BUTTON])
8406                                 {
8407                                         tabLeftMargin = footerLeftMargin;
8408                                         itemButtonLeftGap = footerLeftMargin;
8409                                         __itemArea.width -= ((tabLeftMargin + iconSize + itemButtonLeftGap) * 2);
8410                                 }
8411                                 else
8412                                 {
8413                                         tabLeftMargin = footerLeftMargin;
8414                                         itemButtonLeftGap = footerLeftMargin;
8415                                         __itemArea.width -= (tabLeftMargin + iconSize + itemButtonLeftGap + tabRightMargin);
8416                                 }
8417                         }
8418                         else
8419                         {
8420                                 if (__pButtonItems[RIGHT_BUTTON])
8421                                 {
8422                                         tabRightMargin = footerLeftMargin;
8423                                         itemButtonRightGap = footerLeftMargin;
8424                                         __itemArea.width -= (tabLeftMargin + itemButtonRightGap + iconSize + tabRightMargin);
8425                                 }
8426
8427                                 iconSize = 0;
8428                         }
8429
8430                         blockWidth[0] = __itemArea.width;
8431
8432                         if (__pButtonItems[LEFT_BUTTON])
8433                         {
8434                                 if (__pButtonItems[RIGHT_BUTTON])
8435                                 {
8436                                         __pItems.at(0)->SetBounds(FloatRectangle(dividerWidth + tabLeftMargin + iconSize + itemButtonLeftGap, (GetSizeF().height - itemHeight) / 2, blockWidth[0] - dividerWidth * 2, itemHeight));
8437                                 }
8438                                 else
8439                                 {
8440                                         __pItems.at(0)->SetBounds(FloatRectangle(dividerWidth + tabLeftMargin + iconSize + itemButtonLeftGap, (GetSizeF().height - itemHeight) / 2, blockWidth[0] - dividerWidth, itemHeight));
8441                                 }
8442                         }
8443                         else
8444                         {
8445                                 if (__pButtonItems[RIGHT_BUTTON])
8446                                 {
8447                                         __pItems.at(0)->SetBounds(FloatRectangle(tabLeftMargin + iconSize + itemButtonLeftGap, (GetSizeF().height - itemHeight) / 2, blockWidth[0] - dividerWidth, itemHeight));
8448                                 }
8449                                 else
8450                                 {
8451                                         __pItems.at(0)->SetBounds(FloatRectangle(tabLeftMargin + iconSize + itemButtonLeftGap, (GetSizeF().height - itemHeight) / 2, blockWidth[0], itemHeight));
8452                                 }
8453                         }
8454                 }
8455
8456                 for (int i = 0; i < __itemCount; i++)
8457                 {
8458                         if (__pItems.at(i)->GetChildCount() != 0)
8459                         {
8460                                 _Label* existingBadgeIcon = dynamic_cast<_Label*>(__pItems.at(i)->GetChild(0));
8461
8462                                 if (existingBadgeIcon)
8463                                 {
8464                                         existingBadgeIcon->SetPosition(FloatPoint(blockWidth[i] - existingBadgeIcon->GetSizeF().width, 0));
8465                                         existingBadgeIcon = null;
8466                                 }
8467                         }
8468                 }
8469
8470                 RealignItem(__pItems.at(0), textExtentSize_0);
8471         }
8472         else if(__itemCount == 2)
8473         {
8474                 float textExtentSize_0 = __pItems.at(0)->GetTextExtentSizeF();
8475                 float textExtentSize_1 = __pItems.at(1)->GetTextExtentSizeF();
8476
8477                 if (__pButtonItems[LEFT_BUTTON])
8478                 {
8479                         if (__pButtonItems[RIGHT_BUTTON])
8480                         {
8481                                 tabLeftMargin = footerLeftMargin;
8482                                 itemButtonLeftGap = footerLeftMargin;
8483                                 __itemArea.width -= ((tabLeftMargin + iconSize + itemButtonLeftGap) * 2);
8484                         }
8485                         else
8486                         {
8487                                 tabLeftMargin = footerLeftMargin;
8488                                 itemButtonLeftGap = footerLeftMargin;
8489                                 __itemArea.width -= (tabLeftMargin + iconSize + itemButtonLeftGap + tabRightMargin);
8490                         }
8491                 }
8492                 else
8493                 {
8494                         if (__pButtonItems[RIGHT_BUTTON])
8495                         {
8496                                 tabRightMargin = footerLeftMargin;
8497                                 itemButtonRightGap = footerLeftMargin;
8498                                 __itemArea.width -= (tabLeftMargin + itemButtonRightGap + iconSize + tabRightMargin);
8499                         }
8500
8501                         iconSize = 0;
8502                 }
8503
8504                 blockWidth[0] = blockWidth[1] = (__itemArea.width - dividerWidth * 1) / 2;
8505
8506                 if (__pButtonItems[LEFT_BUTTON])
8507                 {
8508                         if (__pButtonItems[RIGHT_BUTTON])
8509                         {
8510                                 __pItems.at(0)->SetBounds(FloatRectangle(dividerWidth + tabLeftMargin + iconSize + itemButtonLeftGap, (GetSizeF().height - itemHeight) / 2, blockWidth[0] - dividerWidth, itemHeight));
8511                                 __pItems.at(1)->SetBounds(FloatRectangle(tabLeftMargin + iconSize + itemButtonLeftGap + blockWidth[0] + dividerWidth, (GetSizeF().height - itemHeight) / 2, blockWidth[1] - dividerWidth, itemHeight));
8512                         }
8513                         else
8514                         {
8515                                 __pItems.at(0)->SetBounds(FloatRectangle(dividerWidth + tabLeftMargin + iconSize + itemButtonLeftGap, (GetSizeF().height - itemHeight) / 2, blockWidth[0] - dividerWidth, itemHeight));
8516                                 __pItems.at(1)->SetBounds(FloatRectangle(tabLeftMargin + iconSize + itemButtonLeftGap + blockWidth[0] + dividerWidth, (GetSizeF().height - itemHeight) / 2, blockWidth[1], itemHeight));
8517                         }
8518                 }
8519                 else
8520                 {
8521                         if (__pButtonItems[RIGHT_BUTTON])
8522                         {
8523                                 __pItems.at(0)->SetBounds(FloatRectangle(tabLeftMargin + iconSize + itemButtonLeftGap, (GetSizeF().height - itemHeight) / 2, blockWidth[0], itemHeight));
8524                                 __pItems.at(1)->SetBounds(FloatRectangle(tabLeftMargin + iconSize + itemButtonLeftGap + blockWidth[0] + dividerWidth, (GetSizeF().height - itemHeight) / 2, blockWidth[1] - dividerWidth, itemHeight));
8525                         }
8526                         else
8527                         {
8528                                 __pItems.at(0)->SetBounds(FloatRectangle(tabLeftMargin + iconSize + itemButtonLeftGap, (GetSizeF().height - itemHeight) / 2, blockWidth[0], itemHeight));
8529                                 __pItems.at(1)->SetBounds(FloatRectangle(tabLeftMargin + iconSize + itemButtonLeftGap + blockWidth[0] + dividerWidth, (GetSizeF().height - itemHeight) / 2, blockWidth[1], itemHeight));
8530                         }
8531                 }
8532
8533                 for (int i = 0; i < __itemCount; i++)
8534                 {
8535                         if (__pItems.at(i)->GetChildCount() != 0)
8536                         {
8537                                 _Label* existingBadgeIcon = dynamic_cast<_Label*>(__pItems.at(i)->GetChild(0));
8538
8539                                 if (existingBadgeIcon)
8540                                 {
8541                                         existingBadgeIcon->SetPosition(FloatPoint(blockWidth[i] - existingBadgeIcon->GetSizeF().width, 0));
8542                                         existingBadgeIcon = null;
8543                                 }
8544                         }
8545                 }
8546
8547                 RealignItem(__pItems.at(0), textExtentSize_0);
8548                 RealignItem(__pItems.at(1), textExtentSize_1);
8549         }
8550         else if (__itemCount == 3)
8551         {
8552                 if (__pButtonItems[LEFT_BUTTON])
8553                 {
8554                         if (__pButtonItems[RIGHT_BUTTON])
8555                         {
8556                                 tabLeftMargin = footerLeftMargin;
8557                                 itemButtonLeftGap = footerLeftMargin;
8558                                 __itemArea.width -= ((tabLeftMargin + iconSize + itemButtonLeftGap) * 2);
8559                         }
8560                         else
8561                         {
8562                                 tabLeftMargin = footerLeftMargin;
8563                                 itemButtonLeftGap = footerLeftMargin;
8564                                 __itemArea.width -= (tabLeftMargin + iconSize + itemButtonLeftGap + tabRightMargin);
8565                         }
8566                 }
8567                 else
8568                 {
8569                         if (__pButtonItems[RIGHT_BUTTON])
8570                         {
8571                                 tabRightMargin = footerLeftMargin;
8572                                 itemButtonRightGap = footerLeftMargin;
8573                                 __itemArea.width -= (tabLeftMargin + itemButtonRightGap + iconSize + tabRightMargin);
8574                         }
8575                         else
8576                         {
8577                                 __itemArea.width -= tabLeftMargin * 2;
8578                         }
8579
8580                         iconSize = 0;
8581                 }
8582
8583                 blockWidth[0] = blockWidth[1] = blockWidth[2] = (__itemArea.width - dividerWidth * 2) / 3;
8584
8585                 if (__pButtonItems[LEFT_BUTTON])
8586                 {
8587                         if (__pButtonItems[RIGHT_BUTTON])
8588                         {
8589                                 __pItems.at(0)->SetBounds(FloatRectangle(dividerWidth + tabLeftMargin + iconSize + itemButtonLeftGap, (GetSizeF().height - itemHeight) / 2, blockWidth[0] - dividerWidth, itemHeight));
8590                                 __pItems.at(1)->SetBounds(FloatRectangle(tabLeftMargin + iconSize + itemButtonLeftGap + blockWidth[0] + dividerWidth, (GetSizeF().height - itemHeight) / 2, blockWidth[1], itemHeight));
8591                                 __pItems.at(2)->SetBounds(FloatRectangle(tabLeftMargin + iconSize + itemButtonLeftGap + blockWidth[0] + blockWidth[1] + dividerWidth * 2,
8592                                                 (GetSizeF().height - itemHeight) / 2, blockWidth[2] - dividerWidth, itemHeight));
8593                         }
8594                         else
8595                         {
8596                                 __pItems.at(0)->SetBounds(FloatRectangle(dividerWidth + tabLeftMargin + iconSize + itemButtonLeftGap, (GetSizeF().height - itemHeight) / 2, blockWidth[0] - dividerWidth, itemHeight));
8597                                 __pItems.at(1)->SetBounds(FloatRectangle(tabLeftMargin + iconSize + itemButtonLeftGap + blockWidth[0] + dividerWidth, (GetSizeF().height - itemHeight) / 2, blockWidth[1], itemHeight));
8598                                 __pItems.at(2)->SetBounds(FloatRectangle(tabLeftMargin + iconSize + itemButtonLeftGap + blockWidth[0] + blockWidth[1] + dividerWidth * 2,
8599                                                         (GetSizeF().height - itemHeight) / 2, blockWidth[2], itemHeight));
8600                         }
8601                 }
8602                 else
8603                 {
8604                         if (__pButtonItems[RIGHT_BUTTON])
8605                         {
8606                                 __pItems.at(0)->SetBounds(FloatRectangle(tabLeftMargin + iconSize + itemButtonLeftGap, (GetSizeF().height - itemHeight) / 2, blockWidth[0], itemHeight));
8607                                 __pItems.at(1)->SetBounds(FloatRectangle(tabLeftMargin + iconSize + itemButtonLeftGap + blockWidth[0] + dividerWidth, (GetSizeF().height - itemHeight) / 2, blockWidth[1], itemHeight));
8608                                 __pItems.at(2)->SetBounds(FloatRectangle(tabLeftMargin + iconSize + itemButtonLeftGap + blockWidth[0] + blockWidth[1] + dividerWidth * 2,
8609                                                 (GetSizeF().height - itemHeight) / 2, blockWidth[2] - dividerWidth, itemHeight));
8610                         }
8611                         else
8612                         {
8613                                 __pItems.at(0)->SetBounds(FloatRectangle(tabLeftMargin + iconSize + itemButtonLeftGap, (GetSizeF().height - itemHeight) / 2, blockWidth[0], itemHeight));
8614                                 __pItems.at(1)->SetBounds(FloatRectangle(tabLeftMargin + iconSize + itemButtonLeftGap + blockWidth[0] + dividerWidth, (GetSizeF().height - itemHeight) / 2, blockWidth[1], itemHeight));
8615                                 __pItems.at(2)->SetBounds(FloatRectangle(tabLeftMargin + iconSize + itemButtonLeftGap + blockWidth[0] + blockWidth[1] + dividerWidth * 2,
8616                                                 (GetSizeF().height - itemHeight) / 2, blockWidth[2], itemHeight));
8617                         }
8618                 }
8619
8620                 for (int i = 0; i < __itemCount; i++)
8621                 {
8622                         if (__pItems.at(i)->GetChildCount() != 0)
8623                         {
8624                                 _Label* existingBadgeIcon = dynamic_cast<_Label*>(__pItems.at(i)->GetChild(0));
8625
8626                                 if (existingBadgeIcon)
8627                                 {
8628                                         existingBadgeIcon->SetPosition(FloatPoint(blockWidth[i] - existingBadgeIcon->GetSizeF().width, 0));
8629                                         existingBadgeIcon = null;
8630                                 }
8631                         }
8632
8633                         RealignItem(__pItems.at(i), __pItems.at(i)->GetTextExtentSizeF());
8634                 }
8635         }
8636         else if (__itemCount == 4)
8637         {
8638                 __itemArea.width -= tabLeftMargin * 2;
8639
8640                 blockWidth[0] = blockWidth[1] = blockWidth[2] = blockWidth[3] = (__itemArea.width - dividerWidth * 3) / 4;
8641
8642                 __pItems.at(0)->SetBounds(FloatRectangle(tabLeftMargin, (GetSizeF().height - itemHeight) / 2, blockWidth[0], itemHeight));
8643                 __pItems.at(1)->SetBounds(FloatRectangle(tabLeftMargin + blockWidth[0] + dividerWidth, (GetSizeF().height - itemHeight) / 2, blockWidth[1], itemHeight));
8644                 __pItems.at(2)->SetBounds(FloatRectangle(tabLeftMargin + blockWidth[0] + blockWidth[1] + dividerWidth * 2,
8645                                 (GetSizeF().height - itemHeight) / 2, blockWidth[2], itemHeight));
8646                 __pItems.at(3)->SetBounds(FloatRectangle(tabLeftMargin + blockWidth[0] + blockWidth[1] + blockWidth[2] + dividerWidth * 3,
8647                                 (GetSizeF().height - itemHeight) / 2, blockWidth[3], itemHeight));
8648
8649                 for (int i = 0; i < __itemCount; i++)
8650                 {
8651                         if (__pItems.at(i)->GetChildCount() != 0)
8652                         {
8653                                 _Label* existingBadgeIcon = dynamic_cast<_Label*>(__pItems.at(i)->GetChild(0));
8654
8655                                 if (existingBadgeIcon)
8656                                 {
8657                                         existingBadgeIcon->SetPosition(FloatPoint(blockWidth[i] - existingBadgeIcon->GetSizeF().width, 0));
8658                                         existingBadgeIcon = null;
8659                                 }
8660                         }
8661
8662                         RealignItem(__pItems.at(i), __pItems.at(i)->GetTextExtentSizeF());
8663                 }
8664         }
8665         else if (__itemCount == 5)
8666         {
8667                 __itemArea.width -= tabLeftMargin * 2;
8668
8669                 blockWidth[0] = blockWidth[1] = blockWidth[2] = blockWidth[3] = blockWidth[4] = (__itemArea.width - dividerWidth * 4) / 5;
8670
8671                 __pItems.at(0)->SetBounds(FloatRectangle(tabLeftMargin, (GetSizeF().height - itemHeight) / 2, blockWidth[0], itemHeight));
8672                 __pItems.at(1)->SetBounds(FloatRectangle(tabLeftMargin + blockWidth[0] + dividerWidth, (GetSizeF().height - itemHeight) / 2, blockWidth[1], itemHeight));
8673                 __pItems.at(2)->SetBounds(FloatRectangle(tabLeftMargin + blockWidth[0] + blockWidth[1] + dividerWidth * 2,
8674                                 (GetSizeF().height - itemHeight) / 2, blockWidth[2], itemHeight));
8675                 __pItems.at(3)->SetBounds(FloatRectangle(tabLeftMargin + blockWidth[0] + blockWidth[1] + blockWidth[2] + dividerWidth * 3,
8676                                 (GetSizeF().height - itemHeight) / 2, blockWidth[3], itemHeight));
8677                 __pItems.at(4)->SetBounds(FloatRectangle(tabLeftMargin + blockWidth[0] + blockWidth[1] + blockWidth[2] + blockWidth[3] + dividerWidth * 4,
8678                                 (GetSizeF().height - itemHeight) / 2, blockWidth[4], itemHeight));
8679
8680                 for (int i = 0; i < __itemCount; i++)
8681                 {
8682                         if (__pItems.at(i)->GetChildCount() != 0)
8683                         {
8684                                 _Label* existingBadgeIcon = dynamic_cast<_Label*>(__pItems.at(i)->GetChild(0));
8685
8686                                 if (existingBadgeIcon)
8687                                 {
8688                                         existingBadgeIcon->SetPosition(FloatPoint(blockWidth[i] - existingBadgeIcon->GetSizeF().width, 0));
8689                                         existingBadgeIcon = null;
8690                                 }
8691                         }
8692
8693                         RealignItem(__pItems.at(i), __pItems.at(i)->GetTextExtentSizeF());
8694                 }
8695         }
8696
8697         GET_SHAPE_CONFIG(FOOTER::FOOTER_ITEM_FONT_SIZE, GetOrientation(), fontSize);//32
8698
8699         for (int i = 0; i < __itemCount; i++)
8700         {
8701                 if (__style == TOOLBAR_ICON_TEXT && (__pItems.at(i)->GetBitmap(_BUTTON_STATUS_NORMAL) || __pItems.at(i)->GetBitmap(_BUTTON_STATUS_PRESSED)))
8702                 {
8703                         if (__itemCount == 5)
8704                         {
8705                                 GET_SHAPE_CONFIG(FOOTER::BUTTON_ITEM_TEXT_FONT_SIZE_ITEM_5_WITH_ICON, GetOrientation(), multilineFontSize);//20
8706                         }
8707                         else
8708                         {
8709                                 GET_SHAPE_CONFIG(FOOTER::BUTTON_ITEM_TEXT_FONT_SIZE_ITEM_3_WITH_ICON, GetOrientation(), multilineFontSize);//24
8710                         }
8711                 }
8712                 else
8713                 {
8714                         if (__itemCount == 5)
8715                         {
8716                                 GET_SHAPE_CONFIG(FOOTER::BUTTON_ITEM_TEXT_FONT_SIZE_ITEM_5, GetOrientation(), multilineFontSize);//24
8717                         }
8718                         else
8719                         {
8720                                 GET_SHAPE_CONFIG(FOOTER::BUTTON_ITEM_TEXT_FONT_SIZE_ITEM_3, GetOrientation(), multilineFontSize);//26
8721                         }
8722                 }
8723
8724                 //__pItems.at(i)->SetMargin(__pItems.at(i)->GetLeftMarginF(), 0.0f, __pItems.at(i)->GetRightMarginF(), 0.0f);
8725                 __pItems.at(i)->SetTextSize(fontSize, FONT_STYLE_BOLD);
8726                 __pItems.at(i)->SetMultilineTextSize(multilineFontSize);
8727         }
8728
8729         return E_SUCCESS;
8730 }
8731
8732 result
8733 _Toolbar::SetAnimation(ToolbarAnimationPosition animationPos)
8734 {
8735         SysTryReturnResult(NID_UI_CTRL, (0 <= animationPos && animationPos < 3), E_INVALID_ARG,
8736                                 "[E_INVALID_ARG] The animationPos is invalid.");
8737
8738         if (__pAnimation[animationPos])
8739         {
8740                 if (__pAnimation[animationPos]->GetStatus() == ANIMATION_PLAYING)
8741                 {
8742                         return E_SUCCESS;
8743                 }
8744         }
8745
8746         if (__pAnimationFrameList[animationPos])
8747         {
8748                 __pAnimationFrameList[animationPos]->RemoveAll(true);
8749
8750                 delete __pAnimationFrameList[animationPos];
8751                 __pAnimationFrameList[animationPos] = null;
8752         }
8753
8754         result r = GET_ANIMATION_CONFIG_N(HEADER::PROCESSING_ANIMATION, __pAnimationFrameList[animationPos]);
8755         SysTryReturnResult(NID_UI_CTRL, r == E_SUCCESS, E_SYSTEM, "[E_SYSTEM] Couldn't get an animationframe.");
8756
8757         delete __pAnimation[animationPos];
8758         __pAnimation[animationPos] = null;
8759
8760         __pAnimation[animationPos] = _Animation::CreateAnimationN();
8761
8762         float processingAnimationIconSize = 0.0f;
8763
8764         GET_SHAPE_CONFIG(HEADER::PROCESSING_ANIMATION_ICON_SIZE, GetOrientation(), processingAnimationIconSize);
8765
8766         if (__pAnimation[animationPos])
8767         {
8768                 __pAnimation[animationPos]->SetSize(FloatDimension(processingAnimationIconSize, processingAnimationIconSize));
8769
8770                 if (__pAnimationFrameList[animationPos])
8771                 {
8772                         __pAnimation[animationPos]->SetAnimationFrames(*__pAnimationFrameList[animationPos]);
8773                         __pAnimation[animationPos]->SetImageCount(__pAnimationFrameList[animationPos]->GetCount());
8774                         __pAnimation[animationPos]->SetRepeatCount(100);
8775                         __pAnimation[animationPos]->AddAnimationEventListener(*this);
8776                 }
8777
8778                 if (animationPos == TOOLBAR_ANIMATION_POSITION_TITLE)
8779                 {
8780                         AttachChild(*__pAnimation[animationPos]);
8781                 }
8782                 else if (animationPos == TOOLBAR_ANIMATION_POSITION_BUTTON_LEFT)
8783                 {
8784                         __pButtonItems[LEFT_BUTTON]->AttachChild(*__pAnimation[animationPos]);
8785
8786                         float topTouchMargin = __pButtonItems[LEFT_BUTTON]->GetTopTouchMarginF();
8787                         float bottomTouchMargin = __pButtonItems[LEFT_BUTTON]->GetBottomTouchMarginF();
8788
8789                         SetWaitingAnimationPosition(TOOLBAR_ANIMATION_POSITION_BUTTON_LEFT,
8790                                         (__pButtonItems[LEFT_BUTTON]->GetSizeF().width - processingAnimationIconSize) / 2,
8791                                         topTouchMargin + (__pButtonItems[LEFT_BUTTON]->GetSizeF().height - topTouchMargin - bottomTouchMargin - processingAnimationIconSize) / 2);
8792                 }
8793                 else if (animationPos == TOOLBAR_ANIMATION_POSITION_BUTTON_RIGHT)
8794                 {
8795                         __pButtonItems[RIGHT_BUTTON]->AttachChild(*__pAnimation[animationPos]);
8796
8797                         float topTouchMargin = __pButtonItems[RIGHT_BUTTON]->GetTopTouchMarginF();
8798                         float bottomTouchMargin = __pButtonItems[RIGHT_BUTTON]->GetBottomTouchMarginF();
8799
8800                         SetWaitingAnimationPosition(TOOLBAR_ANIMATION_POSITION_BUTTON_RIGHT,
8801                                         (__pButtonItems[RIGHT_BUTTON]->GetSizeF().width - processingAnimationIconSize) / 2,
8802                                         topTouchMargin + (__pButtonItems[RIGHT_BUTTON]->GetSizeF().height - topTouchMargin - bottomTouchMargin - processingAnimationIconSize) / 2);
8803                 }
8804                 _AccessibilityContainer* pContainer = __pAnimation[animationPos]->GetAccessibilityContainer();
8805                 if (pContainer)
8806                 {
8807                         pContainer->Activate(false);
8808                 }
8809         }
8810
8811         return E_SUCCESS;
8812 }
8813
8814 result
8815 _Toolbar::SetColorReplacedBitmap(_Button* pButton, const _ButtonStatus status,
8816                 const Color& color, const Bitmap* pBitmap)
8817 {
8818         SysTryReturnResult(NID_UI_CTRL, pButton, E_INVALID_ARG, "[E_INVALID_ARG] The button pointer is null.");
8819         SysTryReturnResult(NID_UI_CTRL, pBitmap, E_INVALID_ARG, "[E_INVALID_ARG] The bitmap pointer is null.");
8820
8821         Bitmap* __pColorReplacedBitmap = null;
8822
8823         __pColorReplacedBitmap = _BitmapImpl::GetColorReplacedBitmapN(*pBitmap, Color::GetColor(COLOR_ID_MAGENTA), color);
8824
8825         if (__pColorReplacedBitmap)
8826         {
8827                 if (color.GetAlpha() != 0xFF)
8828                 {
8829                         __pColorReplacedBitmap->SetAlphaConstant(color.GetAlpha());
8830                 }
8831
8832                 pButton->SetBackgroundBitmap(status, *__pColorReplacedBitmap);
8833                 delete __pColorReplacedBitmap;
8834         }
8835
8836         return E_SUCCESS;
8837 }
8838
8839 result
8840 _Toolbar::SetPropertyColor(const Variant& color)
8841 {
8842         result r = E_SUCCESS;
8843
8844         _Control::SetBackgroundColor(color.ToColor());
8845
8846         return r;
8847 }
8848
8849 Variant
8850 _Toolbar::GetPropertyColor(void) const
8851 {
8852         return Variant(_Control::GetBackgroundColor());
8853 }
8854
8855 result
8856 _Toolbar::SetPropertyDescriptionText(const Variant& text)
8857 {
8858         __descriptionText = text.ToString();
8859
8860         result r = E_SUCCESS;
8861
8862         r = __pToolbarPresenter->SetDescriptionText(__descriptionText);
8863
8864         if(__pTitleTextElement)
8865         {
8866                 if (text.IsEmpty())
8867                 {
8868                         __pTitleTextElement->SetLabel(__titleText);
8869                 }
8870                 else
8871                 {
8872                         __pTitleTextElement->SetLabel(__titleText + L", " + __descriptionText);
8873                 }
8874         }
8875
8876         return r;
8877 }
8878
8879 Variant
8880 _Toolbar::GetPropertyDescriptionText(void) const
8881 {
8882         return Variant(__descriptionText);
8883 }
8884
8885 result
8886 _Toolbar::SetPropertyDescriptionTextColor(const Variant& color)
8887 {
8888         __descriptionTextColor = color.ToColor();
8889
8890         return E_SUCCESS;
8891 }
8892
8893 Variant
8894 _Toolbar::GetPropertyDescriptionTextColor(void) const
8895 {
8896         return Variant(__descriptionTextColor);
8897 }
8898
8899 result
8900 _Toolbar::SetPropertyTitleText(const Variant& text)
8901 {
8902         __titleText = text.ToString();
8903
8904         if(__pTitleTextElement)
8905         {
8906                 __pTitleTextElement->SetLabel(__titleText);
8907         }
8908
8909         return E_SUCCESS;
8910 }
8911
8912 Variant
8913 _Toolbar::GetPropertyTitleText(void) const
8914 {
8915         return Variant(__titleText);
8916 }
8917
8918 result
8919 _Toolbar::SetPropertyTitleTextColor(const Variant& color)
8920 {
8921         __titleTextColor = color.ToColor();
8922
8923         return E_SUCCESS;
8924 }
8925
8926 Variant
8927 _Toolbar::GetPropertyTitleTextColor(void) const
8928 {
8929         return Variant(__titleTextColor);
8930 }
8931
8932 result
8933 _Toolbar::SetPropertyDisabledButtonColor(const Variant& color)
8934 {
8935         __buttonBackgroundColor[_BUTTON_STATUS_DISABLED] = color.ToColor();
8936
8937         Bitmap* __pBaseBackgroundBitmap = null;
8938
8939         if (__header == true)
8940         {
8941                 if (__transparent == true)
8942                 {
8943                         GET_BITMAP_CONFIG_N(HEADER::BUTTON_TRANSLUCENT_BG_DISABLED, BITMAP_PIXEL_FORMAT_ARGB8888, __pBaseBackgroundBitmap);
8944                 }
8945                 else
8946                 {
8947                         GET_BITMAP_CONFIG_N(HEADER::BUTTON_BG_DISABLED, BITMAP_PIXEL_FORMAT_ARGB8888, __pBaseBackgroundBitmap);
8948                 }
8949         }
8950         else
8951         {
8952                 if (__transparent == true)
8953                 {
8954                         GET_BITMAP_CONFIG_N(FOOTER::BUTTON_TRANSLUCENT_BG_DISABLED, BITMAP_PIXEL_FORMAT_ARGB8888, __pBaseBackgroundBitmap);
8955                 }
8956                 else
8957                 {
8958                         GET_BITMAP_CONFIG_N(FOOTER::BUTTON_BG_DISABLED, BITMAP_PIXEL_FORMAT_ARGB8888, __pBaseBackgroundBitmap);
8959                 }
8960         }
8961
8962         for (int i = 0; i < BUTTON_MAX; i++)
8963         {
8964                 if (__pButtonItems[i] != null)
8965                 {
8966                         if (__pBaseBackgroundBitmap)
8967                         {
8968                                 SetColorReplacedBitmap(__pButtonItems[i], _BUTTON_STATUS_DISABLED, __buttonBackgroundColor[_BUTTON_STATUS_DISABLED], __pBaseBackgroundBitmap);
8969                         }
8970                 }
8971         }
8972
8973         delete __pBaseBackgroundBitmap;
8974
8975         return E_SUCCESS;
8976 }
8977
8978 Variant
8979 _Toolbar::GetPropertyDisabledButtonColor(void) const
8980 {
8981         return Variant(__buttonBackgroundColor[_BUTTON_STATUS_DISABLED]);
8982 }
8983
8984 result
8985 _Toolbar::SetPropertyDisabledButtonTextColor(const Variant& color)
8986 {
8987         __buttonTextColor[_BUTTON_STATUS_DISABLED] = color.ToColor();
8988
8989         for (int i = 0; i < BUTTON_MAX; i++)
8990         {
8991                 if (__pButtonItems[i] != null)
8992                 {
8993                         __pButtonItems[i]->SetTextColor(_BUTTON_STATUS_DISABLED, __buttonTextColor[_BUTTON_STATUS_DISABLED]);
8994                 }
8995         }
8996
8997         return E_SUCCESS;
8998 }
8999
9000 Variant
9001 _Toolbar::GetPropertyDisabledButtonTextColor(void) const
9002 {
9003         return Variant(__buttonTextColor[_BUTTON_STATUS_DISABLED]);
9004 }
9005
9006 result
9007 _Toolbar::SetPropertyHighlightedButtonColor(const Variant& color)
9008 {
9009         __buttonBackgroundColor[_BUTTON_STATUS_HIGHLIGHTED] = color.ToColor();
9010
9011         Bitmap* __pBaseBackgroundBitmap = null;
9012
9013         if (__header == true)
9014         {
9015                 if (__transparent == true)
9016                 {
9017                         GET_BITMAP_CONFIG_N(HEADER::BUTTON_TRANSLUCENT_BG_HIGHLIGHTED, BITMAP_PIXEL_FORMAT_ARGB8888, __pBaseBackgroundBitmap);
9018                 }
9019                 else
9020                 {
9021                         GET_BITMAP_CONFIG_N(HEADER::BUTTON_BG_HIGHLIGHTED, BITMAP_PIXEL_FORMAT_ARGB8888, __pBaseBackgroundBitmap);
9022                 }
9023         }
9024         else
9025         {
9026                 if (__transparent == true)
9027                 {
9028                         GET_BITMAP_CONFIG_N(FOOTER::BUTTON_TRANSLUCENT_BG_HIGHLIGHTED, BITMAP_PIXEL_FORMAT_ARGB8888, __pBaseBackgroundBitmap);
9029                 }
9030                 else
9031                 {
9032                         GET_BITMAP_CONFIG_N(FOOTER::BUTTON_BG_HIGHLIGHTED, BITMAP_PIXEL_FORMAT_ARGB8888, __pBaseBackgroundBitmap);
9033                 }
9034         }
9035
9036         for (int i = 0; i < BUTTON_MAX; i++)
9037         {
9038                 if (__pButtonItems[i] != null)
9039                 {
9040                         if (__pBaseBackgroundBitmap)
9041                         {
9042                                 SetColorReplacedBitmap(__pButtonItems[i], _BUTTON_STATUS_HIGHLIGHTED, __buttonBackgroundColor[_BUTTON_STATUS_HIGHLIGHTED], __pBaseBackgroundBitmap);
9043                         }
9044                 }
9045         }
9046
9047         delete __pBaseBackgroundBitmap;
9048
9049         return E_SUCCESS;
9050 }
9051
9052 Variant
9053 _Toolbar::GetPropertyHighlightedButtonColor(void) const
9054 {
9055         return Variant(__buttonBackgroundColor[_BUTTON_STATUS_HIGHLIGHTED]);
9056 }
9057
9058 result
9059 _Toolbar::SetPropertyHighlightedButtonTextColor(const Variant& color)
9060 {
9061         __buttonTextColor[_BUTTON_STATUS_HIGHLIGHTED] = color.ToColor();
9062
9063         for (int i = 0; i < BUTTON_MAX; i++)
9064         {
9065                 if (__pButtonItems[i] != null)
9066                 {
9067                         __pButtonItems[i]->SetTextColor(_BUTTON_STATUS_HIGHLIGHTED, __buttonTextColor[_BUTTON_STATUS_HIGHLIGHTED]);
9068                 }
9069         }
9070
9071         return E_SUCCESS;
9072 }
9073
9074 Variant
9075 _Toolbar::GetPropertyHighlightedButtonTextColor(void) const
9076 {
9077         return Variant(__buttonTextColor[_BUTTON_STATUS_HIGHLIGHTED]);
9078 }
9079
9080 result
9081 _Toolbar::SetPropertyNormalButtonColor(const Variant& color)
9082 {
9083         __buttonBackgroundColor[_BUTTON_STATUS_NORMAL] = color.ToColor();
9084
9085         Bitmap* __pBaseBackgroundBitmap = null;
9086
9087         if (__header == true)
9088         {
9089                 if (__transparent == true)
9090                 {
9091                         GET_BITMAP_CONFIG_N(HEADER::BUTTON_TRANSLUCENT_BG_NORMAL, BITMAP_PIXEL_FORMAT_ARGB8888, __pBaseBackgroundBitmap);
9092                 }
9093                 else
9094                 {
9095                         GET_BITMAP_CONFIG_N(HEADER::BUTTON_BG_NORMAL, BITMAP_PIXEL_FORMAT_ARGB8888, __pBaseBackgroundBitmap);
9096                 }
9097         }
9098         else
9099         {
9100                 if (__transparent == true)
9101                 {
9102                         GET_BITMAP_CONFIG_N(FOOTER::BUTTON_TRANSLUCENT_BG_NORMAL, BITMAP_PIXEL_FORMAT_ARGB8888, __pBaseBackgroundBitmap);
9103                 }
9104                 else
9105                 {
9106                         GET_BITMAP_CONFIG_N(FOOTER::BUTTON_BG_NORMAL, BITMAP_PIXEL_FORMAT_ARGB8888, __pBaseBackgroundBitmap);
9107                 }
9108         }
9109
9110         for (int i = 0; i < BUTTON_MAX; i++)
9111         {
9112                 if (__pButtonItems[i] != null)
9113                 {
9114                         if (__pBaseBackgroundBitmap)
9115                         {
9116                                 SetColorReplacedBitmap(__pButtonItems[i], _BUTTON_STATUS_NORMAL, __buttonBackgroundColor[_BUTTON_STATUS_NORMAL], __pBaseBackgroundBitmap);
9117                         }
9118                 }
9119         }
9120
9121         delete __pBaseBackgroundBitmap;
9122
9123         return E_SUCCESS;
9124 }
9125
9126 Variant
9127 _Toolbar::GetPropertyNormalButtonColor(void) const
9128 {
9129         return Variant(__buttonBackgroundColor[_BUTTON_STATUS_NORMAL]);
9130 }
9131
9132 result
9133 _Toolbar::SetPropertyNormalButtonTextColor(const Variant& color)
9134 {
9135         __buttonTextColor[_BUTTON_STATUS_NORMAL] = color.ToColor();
9136
9137         for (int i = 0; i < BUTTON_MAX; i++)
9138         {
9139                 if (__pButtonItems[i] != null)
9140                 {
9141                         __pButtonItems[i]->SetTextColor(_BUTTON_STATUS_NORMAL, __buttonTextColor[_BUTTON_STATUS_NORMAL]);
9142                 }
9143         }
9144
9145         return E_SUCCESS;
9146 }
9147
9148 Variant
9149 _Toolbar::GetPropertyNormalButtonTextColor(void) const
9150 {
9151         return Variant(__buttonTextColor[_BUTTON_STATUS_NORMAL]);
9152 }
9153
9154 result
9155 _Toolbar::SetPropertyPressedButtonColor(const Variant& color)
9156 {
9157         __buttonBackgroundColor[_BUTTON_STATUS_PRESSED] = color.ToColor();
9158
9159         Bitmap* __pBaseBackgroundBitmap = null;
9160
9161         if (__header == true)
9162         {
9163                 if (__transparent == true)
9164                 {
9165                         GET_BITMAP_CONFIG_N(HEADER::BUTTON_TRANSLUCENT_BG_PRESSED, BITMAP_PIXEL_FORMAT_ARGB8888, __pBaseBackgroundBitmap);
9166                 }
9167                 else
9168                 {
9169                         GET_BITMAP_CONFIG_N(HEADER::BUTTON_BG_PRESSED, BITMAP_PIXEL_FORMAT_ARGB8888, __pBaseBackgroundBitmap);
9170                 }
9171         }
9172         else
9173         {
9174                 if (__transparent == true)
9175                 {
9176                         GET_BITMAP_CONFIG_N(FOOTER::BUTTON_TRANSLUCENT_BG_PRESSED, BITMAP_PIXEL_FORMAT_ARGB8888, __pBaseBackgroundBitmap);
9177                 }
9178                 else
9179                 {
9180                         GET_BITMAP_CONFIG_N(FOOTER::BUTTON_BG_PRESSED, BITMAP_PIXEL_FORMAT_ARGB8888, __pBaseBackgroundBitmap);
9181                 }
9182         }
9183
9184         for (int i = 0; i < BUTTON_MAX; i++)
9185         {
9186                 if (__pButtonItems[i] != null)
9187                 {
9188                         if (__pBaseBackgroundBitmap)
9189                         {
9190                                 SetColorReplacedBitmap(__pButtonItems[i], _BUTTON_STATUS_PRESSED, __buttonBackgroundColor[_BUTTON_STATUS_PRESSED], __pBaseBackgroundBitmap);
9191                         }
9192                 }
9193         }
9194
9195         delete __pBaseBackgroundBitmap;
9196
9197         return E_SUCCESS;
9198 }
9199
9200 Variant
9201 _Toolbar::GetPropertyPressedButtonColor(void) const
9202 {
9203         return Variant(__buttonBackgroundColor[_BUTTON_STATUS_PRESSED]);
9204 }
9205
9206 result
9207 _Toolbar::SetPropertyPressedButtonTextColor(const Variant& color)
9208 {
9209         __buttonTextColor[_BUTTON_STATUS_PRESSED] = color.ToColor();
9210
9211         for (int i = 0; i < BUTTON_MAX; i++)
9212         {
9213                 if (__pButtonItems[i] != null)
9214                 {
9215                         __pButtonItems[i]->SetTextColor(_BUTTON_STATUS_PRESSED, __buttonTextColor[_BUTTON_STATUS_PRESSED]);
9216                 }
9217         }
9218
9219         return E_SUCCESS;
9220 }
9221
9222 Variant
9223 _Toolbar::GetPropertyPressedButtonTextColor(void) const
9224 {
9225         return Variant(__buttonTextColor[_BUTTON_STATUS_PRESSED]);
9226 }
9227
9228 result
9229 _Toolbar::SetPropertyDisabledItemColor(const Variant& color)
9230 {
9231         __itemBackgroundColor[_BUTTON_STATUS_DISABLED] = color.ToColor();
9232
9233         Bitmap* __pBaseBackgroundBitmap = null;
9234
9235         if (__style == TOOLBAR_TEXT || __style == TOOLBAR_ICON || __style == TOOLBAR_ICON_TEXT || __style == TOOLBAR_COMMAND)
9236         {
9237                 if (__header == true)
9238                 {
9239                         if (__transparent == true)
9240                         {
9241                                 GET_BITMAP_CONFIG_N(HEADER::BUTTON_ITEM_TRANSLUCENT_BG_DISABLED, BITMAP_PIXEL_FORMAT_ARGB8888, __pBaseBackgroundBitmap);
9242                         }
9243                         else
9244                         {
9245                                 GET_BITMAP_CONFIG_N(HEADER::BUTTON_ITEM_BG_DISABLED, BITMAP_PIXEL_FORMAT_ARGB8888, __pBaseBackgroundBitmap);
9246                         }
9247                 }
9248                 else
9249                 {
9250                         if (__transparent == true)
9251                         {
9252                                 GET_BITMAP_CONFIG_N(FOOTER::BUTTON_ITEM_TRANSLUCENT_BG_DISABLED, BITMAP_PIXEL_FORMAT_ARGB8888, __pBaseBackgroundBitmap);
9253                         }
9254                         else
9255                         {
9256                                 GET_BITMAP_CONFIG_N(FOOTER::BUTTON_ITEM_BG_DISABLED, BITMAP_PIXEL_FORMAT_ARGB8888, __pBaseBackgroundBitmap);
9257                         }
9258                 }
9259         }
9260         else if (__style == TOOLBAR_HEADER_SEGMENTED || __style == TOOLBAR_HEADER_SEGMENTED_WITH_TITLE || __style == TOOLBAR_SEGMENTED || __style == TOOLBAR_TITLE)
9261         {
9262                 if (__header == true)
9263                 {
9264                         if (__transparent == true)
9265                         {
9266                                 GET_BITMAP_CONFIG_N(HEADER::SEGMENTED_ITEM_TRANSLUCENT_BG_DISABLED, BITMAP_PIXEL_FORMAT_ARGB8888, __pBaseBackgroundBitmap);
9267                         }
9268                         else
9269                         {
9270                                 GET_BITMAP_CONFIG_N(HEADER::SEGMENTED_ITEM_BG_DISABLED, BITMAP_PIXEL_FORMAT_ARGB8888, __pBaseBackgroundBitmap);
9271                         }
9272                 }
9273                 else
9274                 {
9275                         if (__transparent == true)
9276                         {
9277                                 GET_BITMAP_CONFIG_N(FOOTER::SEGMENTED_ITEM_TRANSLUCENT_BG_DISABLED, BITMAP_PIXEL_FORMAT_ARGB8888, __pBaseBackgroundBitmap);
9278                         }
9279                         else
9280                         {
9281                                 GET_BITMAP_CONFIG_N(FOOTER::SEGMENTED_ITEM_BG_DISABLED, BITMAP_PIXEL_FORMAT_ARGB8888, __pBaseBackgroundBitmap);
9282                         }
9283                 }
9284         }
9285         else if (__style == TOOLBAR_TAB || __style == TOOLBAR_TAB_WITH_TITLE || __style == TOOLBAR_TAB_LARGE)
9286         {
9287                 if (__header == true)
9288                 {
9289                         if (__transparent == true)
9290                         {
9291                                 GET_BITMAP_CONFIG_N(HEADER::TAB_ITEM_TRANSLUCENT_BG_DISABLED, BITMAP_PIXEL_FORMAT_ARGB8888, __pBaseBackgroundBitmap);
9292                         }
9293                         else
9294                         {
9295                                 GET_BITMAP_CONFIG_N(HEADER::TAB_ITEM_BG_DISABLED, BITMAP_PIXEL_FORMAT_ARGB8888, __pBaseBackgroundBitmap);
9296                         }
9297                 }
9298                 else
9299                 {
9300                         if (__transparent == true)
9301                         {
9302                                 GET_BITMAP_CONFIG_N(FOOTER::TAB_ITEM_TRANSLUCENT_BG_DISABLED, BITMAP_PIXEL_FORMAT_ARGB8888, __pBaseBackgroundBitmap);
9303                         }
9304                         else
9305                         {
9306                                 GET_BITMAP_CONFIG_N(FOOTER::TAB_ITEM_BG_DISABLED, BITMAP_PIXEL_FORMAT_ARGB8888, __pBaseBackgroundBitmap);
9307                         }
9308                 }
9309         }
9310
9311         for (int i = 0; i < __itemCount; i++)
9312         {
9313                 if (__pItems.at(i) != null)
9314                 {
9315                         if (__pBaseBackgroundBitmap)
9316                         {
9317                                 SetColorReplacedBitmap(__pItems.at(i), _BUTTON_STATUS_DISABLED, __itemBackgroundColor[_BUTTON_STATUS_DISABLED], __pBaseBackgroundBitmap);
9318                         }
9319                 }
9320         }
9321
9322         delete __pBaseBackgroundBitmap;
9323
9324         return E_SUCCESS;
9325 }
9326
9327 Variant
9328 _Toolbar::GetPropertyDisabledItemColor(void) const
9329 {
9330         return Variant(__itemBackgroundColor[_BUTTON_STATUS_DISABLED]);
9331 }
9332
9333 result
9334 _Toolbar::SetPropertyDisabledItemTextColor(const Variant& color)
9335 {
9336         __itemTextColor[_BUTTON_STATUS_DISABLED] = color.ToColor();
9337
9338         for (int i = 0; i < __itemCount; i++)
9339         {
9340                 if (__pItems.at(i) != null)
9341                 {
9342                         __pItems.at(i)->SetTextColor(_BUTTON_STATUS_DISABLED, __itemTextColor[_BUTTON_STATUS_DISABLED]);
9343                 }
9344         }
9345
9346         return E_SUCCESS;
9347 }
9348
9349 Variant
9350 _Toolbar::GetPropertyDisabledItemTextColor(void) const
9351 {
9352         return Variant(__itemTextColor[_BUTTON_STATUS_DISABLED]);
9353 }
9354
9355 result
9356 _Toolbar::SetPropertyHighlightedItemColor(const Variant& color)
9357 {
9358         __itemBackgroundColor[_BUTTON_STATUS_HIGHLIGHTED] = color.ToColor();
9359
9360         Bitmap* __pBaseBackgroundBitmap = null;
9361
9362         if (__style == TOOLBAR_TEXT || __style == TOOLBAR_ICON || __style == TOOLBAR_ICON_TEXT || __style == TOOLBAR_COMMAND)
9363         {
9364                 if (__header == true)
9365                 {
9366                         if (__transparent == true)
9367                         {
9368                                 GET_BITMAP_CONFIG_N(HEADER::BUTTON_ITEM_TRANSLUCENT_BG_HIGHLIGHTED, BITMAP_PIXEL_FORMAT_ARGB8888, __pBaseBackgroundBitmap);
9369                         }
9370                         else
9371                         {
9372                                 GET_BITMAP_CONFIG_N(HEADER::BUTTON_ITEM_BG_HIGHLIGHTED, BITMAP_PIXEL_FORMAT_ARGB8888, __pBaseBackgroundBitmap);
9373                         }
9374                 }
9375                 else
9376                 {
9377                         if (__transparent == true)
9378                         {
9379                                 GET_BITMAP_CONFIG_N(FOOTER::BUTTON_ITEM_TRANSLUCENT_BG_HIGHLIGHTED, BITMAP_PIXEL_FORMAT_ARGB8888, __pBaseBackgroundBitmap);
9380                         }
9381                         else
9382                         {
9383                                 GET_BITMAP_CONFIG_N(FOOTER::BUTTON_ITEM_BG_HIGHLIGHTED, BITMAP_PIXEL_FORMAT_ARGB8888, __pBaseBackgroundBitmap);
9384                         }
9385                 }
9386         }
9387         else if (__style == TOOLBAR_HEADER_SEGMENTED || __style == TOOLBAR_HEADER_SEGMENTED_WITH_TITLE || __style == TOOLBAR_SEGMENTED || __style == TOOLBAR_TITLE)
9388         {
9389                 if (__header == true)
9390                 {
9391                         if (__transparent == true)
9392                         {
9393                                 GET_BITMAP_CONFIG_N(HEADER::SEGMENTED_ITEM_TRANSLUCENT_BG_HIGHLIGHTED, BITMAP_PIXEL_FORMAT_ARGB8888, __pBaseBackgroundBitmap);
9394                         }
9395                         else
9396                         {
9397                                 GET_BITMAP_CONFIG_N(HEADER::SEGMENTED_ITEM_BG_HIGHLIGHTED, BITMAP_PIXEL_FORMAT_ARGB8888, __pBaseBackgroundBitmap);
9398                         }
9399                 }
9400                 else
9401                 {
9402                         if (__transparent == true)
9403                         {
9404                                 GET_BITMAP_CONFIG_N(FOOTER::SEGMENTED_ITEM_TRANSLUCENT_BG_HIGHLIGHTED, BITMAP_PIXEL_FORMAT_ARGB8888, __pBaseBackgroundBitmap);
9405                         }
9406                         else
9407                         {
9408                                 GET_BITMAP_CONFIG_N(FOOTER::SEGMENTED_ITEM_BG_HIGHLIGHTED, BITMAP_PIXEL_FORMAT_ARGB8888, __pBaseBackgroundBitmap);
9409                         }
9410                 }
9411         }
9412         else if (__style == TOOLBAR_TAB || __style == TOOLBAR_TAB_WITH_TITLE || __style == TOOLBAR_TAB_LARGE)
9413         {
9414                 if (__header == true)
9415                 {
9416                         if (__transparent == true)
9417                         {
9418                                 GET_BITMAP_CONFIG_N(HEADER::TAB_ITEM_TRANSLUCENT_BG_HIGHLIGHTED, BITMAP_PIXEL_FORMAT_ARGB8888, __pBaseBackgroundBitmap);
9419                         }
9420                         else
9421                         {
9422                                 GET_BITMAP_CONFIG_N(HEADER::TAB_ITEM_BG_HIGHLIGHTED, BITMAP_PIXEL_FORMAT_ARGB8888, __pBaseBackgroundBitmap);
9423                         }
9424                 }
9425                 else
9426                 {
9427                         if (__transparent == true)
9428                         {
9429                                 GET_BITMAP_CONFIG_N(FOOTER::TAB_ITEM_TRANSLUCENT_BG_HIGHLIGHTED, BITMAP_PIXEL_FORMAT_ARGB8888, __pBaseBackgroundBitmap);
9430                         }
9431                         else
9432                         {
9433                                 GET_BITMAP_CONFIG_N(FOOTER::TAB_ITEM_BG_HIGHLIGHTED, BITMAP_PIXEL_FORMAT_ARGB8888, __pBaseBackgroundBitmap);
9434                         }
9435                 }
9436         }
9437
9438         for (int i = 0; i < __itemCount; i++)
9439         {
9440                 if (__pItems.at(i) != null)
9441                 {
9442                         if (__pBaseBackgroundBitmap)
9443                         {
9444                                 SetColorReplacedBitmap(__pItems.at(i), _BUTTON_STATUS_HIGHLIGHTED, __itemBackgroundColor[_BUTTON_STATUS_HIGHLIGHTED], __pBaseBackgroundBitmap);
9445                         }
9446                 }
9447         }
9448
9449         delete __pBaseBackgroundBitmap;
9450
9451         return E_SUCCESS;
9452 }
9453
9454 Variant
9455 _Toolbar::GetPropertyHighlightedItemColor(void) const
9456 {
9457         return Variant(__itemBackgroundColor[_BUTTON_STATUS_HIGHLIGHTED]);
9458 }
9459
9460 result
9461 _Toolbar::SetPropertyHighlightedItemTextColor(const Variant& color)
9462 {
9463         __itemTextColor[_BUTTON_STATUS_HIGHLIGHTED] = color.ToColor();
9464
9465         for (int i = 0; i < __itemCount; i++)
9466         {
9467                 if (__pItems.at(i) != null)
9468                 {
9469                         __pItems.at(i)->SetTextColor(_BUTTON_STATUS_HIGHLIGHTED, __itemTextColor[_BUTTON_STATUS_HIGHLIGHTED]);
9470                 }
9471         }
9472
9473         return E_SUCCESS;
9474 }
9475
9476 Variant
9477 _Toolbar::GetPropertyHighlightedItemTextColor(void) const
9478 {
9479         return Variant(__itemTextColor[_BUTTON_STATUS_HIGHLIGHTED]);
9480 }
9481
9482 result
9483 _Toolbar::SetPropertyNormalItemColor(const Variant& color)
9484 {
9485         __itemBackgroundColor[_BUTTON_STATUS_NORMAL] = color.ToColor();
9486
9487         Bitmap* __pBaseBackgroundBitmap = null;
9488
9489         if (__style == TOOLBAR_TEXT || __style == TOOLBAR_ICON || __style == TOOLBAR_ICON_TEXT || __style == TOOLBAR_COMMAND)
9490         {
9491                 if (__header == true)
9492                 {
9493                         if (__transparent == true)
9494                         {
9495                                 GET_BITMAP_CONFIG_N(HEADER::BUTTON_ITEM_TRANSLUCENT_BG_NORMAL, BITMAP_PIXEL_FORMAT_ARGB8888, __pBaseBackgroundBitmap);
9496                         }
9497                         else
9498                         {
9499                                 GET_BITMAP_CONFIG_N(HEADER::BUTTON_ITEM_BG_NORMAL, BITMAP_PIXEL_FORMAT_ARGB8888, __pBaseBackgroundBitmap);
9500                         }
9501                 }
9502                 else
9503                 {
9504                         if (__transparent == true)
9505                         {
9506                                 GET_BITMAP_CONFIG_N(FOOTER::BUTTON_ITEM_TRANSLUCENT_BG_NORMAL, BITMAP_PIXEL_FORMAT_ARGB8888, __pBaseBackgroundBitmap);
9507                         }
9508                         else
9509                         {
9510                                 GET_BITMAP_CONFIG_N(FOOTER::BUTTON_ITEM_BG_NORMAL, BITMAP_PIXEL_FORMAT_ARGB8888, __pBaseBackgroundBitmap);
9511                         }
9512                 }
9513         }
9514         else if (__style == TOOLBAR_HEADER_SEGMENTED || __style == TOOLBAR_HEADER_SEGMENTED_WITH_TITLE || __style == TOOLBAR_SEGMENTED || __style == TOOLBAR_TITLE)
9515         {
9516                 if (__header == true)
9517                 {
9518                         if (__transparent == true)
9519                         {
9520                                 GET_BITMAP_CONFIG_N(HEADER::SEGMENTED_ITEM_TRANSLUCENT_BG_NORMAL, BITMAP_PIXEL_FORMAT_ARGB8888, __pBaseBackgroundBitmap);
9521                         }
9522                         else
9523                         {
9524                                 GET_BITMAP_CONFIG_N(HEADER::SEGMENTED_ITEM_BG_NORMAL, BITMAP_PIXEL_FORMAT_ARGB8888, __pBaseBackgroundBitmap);
9525                         }
9526                 }
9527                 else
9528                 {
9529                         if (__transparent == true)
9530                         {
9531                                 GET_BITMAP_CONFIG_N(FOOTER::SEGMENTED_ITEM_TRANSLUCENT_BG_NORMAL, BITMAP_PIXEL_FORMAT_ARGB8888, __pBaseBackgroundBitmap);
9532                         }
9533                         else
9534                         {
9535                                 GET_BITMAP_CONFIG_N(FOOTER::SEGMENTED_ITEM_BG_NORMAL, BITMAP_PIXEL_FORMAT_ARGB8888, __pBaseBackgroundBitmap);
9536                         }
9537                 }
9538         }
9539         else if (__style == TOOLBAR_TAB || __style == TOOLBAR_TAB_WITH_TITLE || __style == TOOLBAR_TAB_LARGE)
9540         {
9541                 if (__header == true)
9542                 {
9543                         if (__transparent == true)
9544                         {
9545                                 GET_BITMAP_CONFIG_N(HEADER::TAB_ITEM_TRANSLUCENT_BG_NORMAL, BITMAP_PIXEL_FORMAT_ARGB8888, __pBaseBackgroundBitmap);
9546                         }
9547                         else
9548                         {
9549                                 GET_BITMAP_CONFIG_N(HEADER::TAB_ITEM_BG_NORMAL, BITMAP_PIXEL_FORMAT_ARGB8888, __pBaseBackgroundBitmap);
9550                         }
9551                 }
9552                 else
9553                 {
9554                         if (__transparent == true)
9555                         {
9556                                 GET_BITMAP_CONFIG_N(FOOTER::TAB_ITEM_TRANSLUCENT_BG_NORMAL, BITMAP_PIXEL_FORMAT_ARGB8888, __pBaseBackgroundBitmap);
9557                         }
9558                         else
9559                         {
9560                                 GET_BITMAP_CONFIG_N(FOOTER::TAB_ITEM_BG_NORMAL, BITMAP_PIXEL_FORMAT_ARGB8888, __pBaseBackgroundBitmap);
9561                         }
9562                 }
9563         }
9564
9565         for (int i = 0; i < __itemCount; i++)
9566         {
9567                 if (__pItems.at(i) != null)
9568                 {
9569                         if (__pBaseBackgroundBitmap)
9570                         {
9571                                 SetColorReplacedBitmap(__pItems.at(i), _BUTTON_STATUS_NORMAL, __itemBackgroundColor[_BUTTON_STATUS_NORMAL], __pBaseBackgroundBitmap);
9572                         }
9573                 }
9574         }
9575
9576         delete __pBaseBackgroundBitmap;
9577
9578         return E_SUCCESS;
9579 }
9580
9581 Variant
9582 _Toolbar::GetPropertyNormalItemColor(void) const
9583 {
9584         return Variant(__itemBackgroundColor[_BUTTON_STATUS_NORMAL]);
9585 }
9586
9587 result
9588 _Toolbar::SetPropertyNormalItemTextColor(const Variant& color)
9589 {
9590         __itemTextColor[_BUTTON_STATUS_NORMAL] = color.ToColor();
9591
9592         for (int i = 0; i < __itemCount; i++)
9593         {
9594                 if (__pItems.at(i) != null)
9595                 {
9596                         __pItems.at(i)->SetTextColor(_BUTTON_STATUS_NORMAL, __itemTextColor[_BUTTON_STATUS_NORMAL]);
9597                 }
9598         }
9599
9600         return E_SUCCESS;
9601 }
9602
9603 Variant
9604 _Toolbar::GetPropertyNormalItemTextColor(void) const
9605 {
9606         return Variant(__itemTextColor[_BUTTON_STATUS_NORMAL]);
9607 }
9608
9609 result
9610 _Toolbar::SetPropertyPressedItemColor(const Variant& color)
9611 {
9612         __itemBackgroundColor[_BUTTON_STATUS_PRESSED] = color.ToColor();
9613
9614         Bitmap* __pBaseBackgroundBitmap = null;
9615
9616         if (__style == TOOLBAR_TEXT || __style == TOOLBAR_ICON || __style == TOOLBAR_ICON_TEXT || __style == TOOLBAR_COMMAND)
9617         {
9618                 if (__header == true)
9619                 {
9620                         if (__transparent == true)
9621                         {
9622                                 GET_BITMAP_CONFIG_N(HEADER::BUTTON_ITEM_TRANSLUCENT_BG_PRESSED, BITMAP_PIXEL_FORMAT_ARGB8888, __pBaseBackgroundBitmap);
9623                         }
9624                         else
9625                         {
9626                                 GET_BITMAP_CONFIG_N(HEADER::BUTTON_ITEM_BG_PRESSED, BITMAP_PIXEL_FORMAT_ARGB8888, __pBaseBackgroundBitmap);
9627                         }
9628                 }
9629                 else
9630                 {
9631                         if (__transparent == true)
9632                         {
9633                                 GET_BITMAP_CONFIG_N(FOOTER::BUTTON_ITEM_TRANSLUCENT_BG_PRESSED, BITMAP_PIXEL_FORMAT_ARGB8888, __pBaseBackgroundBitmap);
9634                         }
9635                         else
9636                         {
9637                                 GET_BITMAP_CONFIG_N(FOOTER::BUTTON_ITEM_BG_PRESSED, BITMAP_PIXEL_FORMAT_ARGB8888, __pBaseBackgroundBitmap);
9638                         }
9639                 }
9640         }
9641         else if (__style == TOOLBAR_HEADER_SEGMENTED || __style == TOOLBAR_HEADER_SEGMENTED_WITH_TITLE || __style == TOOLBAR_SEGMENTED || __style == TOOLBAR_TITLE)
9642         {
9643                 if (__header == true)
9644                 {
9645                         if (__transparent == true)
9646                         {
9647                                 GET_BITMAP_CONFIG_N(HEADER::SEGMENTED_ITEM_TRANSLUCENT_BG_PRESSED, BITMAP_PIXEL_FORMAT_ARGB8888, __pBaseBackgroundBitmap);
9648                         }
9649                         else
9650                         {
9651                                 GET_BITMAP_CONFIG_N(HEADER::SEGMENTED_ITEM_BG_PRESSED, BITMAP_PIXEL_FORMAT_ARGB8888, __pBaseBackgroundBitmap);
9652                         }
9653                 }
9654                 else
9655                 {
9656                         if (__transparent == true)
9657                         {
9658                                 GET_BITMAP_CONFIG_N(FOOTER::SEGMENTED_ITEM_TRANSLUCENT_BG_PRESSED, BITMAP_PIXEL_FORMAT_ARGB8888, __pBaseBackgroundBitmap);
9659                         }
9660                         else
9661                         {
9662                                 GET_BITMAP_CONFIG_N(FOOTER::SEGMENTED_ITEM_BG_PRESSED, BITMAP_PIXEL_FORMAT_ARGB8888, __pBaseBackgroundBitmap);
9663                         }
9664                 }
9665         }
9666         else if (__style == TOOLBAR_TAB || __style == TOOLBAR_TAB_WITH_TITLE || __style == TOOLBAR_TAB_LARGE)
9667         {
9668                 if (__header == true)
9669                 {
9670                         if (__transparent == true)
9671                         {
9672                                 GET_BITMAP_CONFIG_N(HEADER::TAB_ITEM_TRANSLUCENT_BG_PRESSED, BITMAP_PIXEL_FORMAT_ARGB8888, __pBaseBackgroundBitmap);
9673                         }
9674                         else
9675                         {
9676                                 GET_BITMAP_CONFIG_N(HEADER::TAB_ITEM_BG_PRESSED, BITMAP_PIXEL_FORMAT_ARGB8888, __pBaseBackgroundBitmap);
9677                         }
9678                 }
9679                 else
9680                 {
9681                         if (__transparent == true)
9682                         {
9683                                 GET_BITMAP_CONFIG_N(FOOTER::TAB_ITEM_TRANSLUCENT_BG_PRESSED, BITMAP_PIXEL_FORMAT_ARGB8888, __pBaseBackgroundBitmap);
9684                         }
9685                         else
9686                         {
9687                                 GET_BITMAP_CONFIG_N(FOOTER::TAB_ITEM_BG_PRESSED, BITMAP_PIXEL_FORMAT_ARGB8888, __pBaseBackgroundBitmap);
9688                         }
9689                 }
9690         }
9691
9692         for (int i = 0; i < __itemCount; i++)
9693         {
9694                 if (__pItems.at(i) != null)
9695                 {
9696                         if (__pBaseBackgroundBitmap)
9697                         {
9698                                 SetColorReplacedBitmap(__pItems.at(i), _BUTTON_STATUS_PRESSED, __itemBackgroundColor[_BUTTON_STATUS_PRESSED], __pBaseBackgroundBitmap);
9699                         }
9700                 }
9701         }
9702
9703         delete __pBaseBackgroundBitmap;
9704
9705         return E_SUCCESS;
9706 }
9707
9708 Variant
9709 _Toolbar::GetPropertyPressedItemColor(void) const
9710 {
9711         return Variant(__itemBackgroundColor[_BUTTON_STATUS_PRESSED]);
9712 }
9713
9714 result
9715 _Toolbar::SetPropertyPressedItemTextColor(const Variant& color)
9716 {
9717         __itemTextColor[_BUTTON_STATUS_PRESSED] = color.ToColor();
9718
9719         for (int i = 0; i < __itemCount; i++)
9720         {
9721                 if (__pItems.at(i) != null)
9722                 {
9723                         __pItems.at(i)->SetTextColor(_BUTTON_STATUS_PRESSED, __itemTextColor[_BUTTON_STATUS_PRESSED]);
9724                 }
9725         }
9726
9727         return E_SUCCESS;
9728 }
9729
9730 Variant
9731 _Toolbar::GetPropertyPressedItemTextColor(void) const
9732 {
9733         return Variant(__itemTextColor[_BUTTON_STATUS_PRESSED]);
9734 }
9735
9736 result
9737 _Toolbar::SetPropertySelectedItemColor(const Variant& color)
9738 {
9739         __itemBackgroundColor[_BUTTON_STATUS_SELECTED] = color.ToColor();
9740
9741         Bitmap* __pBaseBackgroundBitmap = null;
9742
9743         if (__style == TOOLBAR_TEXT || __style == TOOLBAR_ICON || __style == TOOLBAR_ICON_TEXT || __style == TOOLBAR_COMMAND)
9744         {
9745                 if (__header == true)
9746                 {
9747                         if (__transparent == true)
9748                         {
9749                                 GET_BITMAP_CONFIG_N(HEADER::BUTTON_ITEM_TRANSLUCENT_BG_NORMAL, BITMAP_PIXEL_FORMAT_ARGB8888, __pBaseBackgroundBitmap);
9750                         }
9751                         else
9752                         {
9753                                 GET_BITMAP_CONFIG_N(HEADER::BUTTON_ITEM_BG_NORMAL, BITMAP_PIXEL_FORMAT_ARGB8888, __pBaseBackgroundBitmap);
9754                         }
9755                 }
9756                 else
9757                 {
9758                         if (__transparent == true)
9759                         {
9760                                 GET_BITMAP_CONFIG_N(FOOTER::BUTTON_ITEM_TRANSLUCENT_BG_NORMAL, BITMAP_PIXEL_FORMAT_ARGB8888, __pBaseBackgroundBitmap);
9761                         }
9762                         else
9763                         {
9764                                 GET_BITMAP_CONFIG_N(FOOTER::BUTTON_ITEM_BG_NORMAL, BITMAP_PIXEL_FORMAT_ARGB8888, __pBaseBackgroundBitmap);
9765                         }
9766                 }
9767         }
9768         else if (__style == TOOLBAR_HEADER_SEGMENTED || __style == TOOLBAR_HEADER_SEGMENTED_WITH_TITLE || __style == TOOLBAR_SEGMENTED || __style == TOOLBAR_TITLE)
9769         {
9770                 if (__header == true)
9771                 {
9772                         if (__transparent == true)
9773                         {
9774                                 GET_BITMAP_CONFIG_N(HEADER::SEGMENTED_ITEM_TRANSLUCENT_BG_SELECTED, BITMAP_PIXEL_FORMAT_ARGB8888, __pBaseBackgroundBitmap);
9775                         }
9776                         else
9777                         {
9778                                 GET_BITMAP_CONFIG_N(HEADER::SEGMENTED_ITEM_BG_SELECTED, BITMAP_PIXEL_FORMAT_ARGB8888, __pBaseBackgroundBitmap);
9779                         }
9780                 }
9781                 else
9782                 {
9783                         if (__transparent == true)
9784                         {
9785                                 GET_BITMAP_CONFIG_N(FOOTER::SEGMENTED_ITEM_TRANSLUCENT_BG_SELECTED, BITMAP_PIXEL_FORMAT_ARGB8888, __pBaseBackgroundBitmap);
9786                         }
9787                         else
9788                         {
9789                                 GET_BITMAP_CONFIG_N(FOOTER::SEGMENTED_ITEM_BG_SELECTED, BITMAP_PIXEL_FORMAT_ARGB8888, __pBaseBackgroundBitmap);
9790                         }
9791                 }
9792         }
9793         else if (__style == TOOLBAR_TAB || __style == TOOLBAR_TAB_WITH_TITLE || __style == TOOLBAR_TAB_LARGE)
9794         {
9795                 if (__header == true)
9796                 {
9797                         if (__transparent == true)
9798                         {
9799                                 GET_BITMAP_CONFIG_N(HEADER::TAB_ITEM_TRANSLUCENT_BG_SELECTED, BITMAP_PIXEL_FORMAT_ARGB8888, __pBaseBackgroundBitmap);
9800                         }
9801                         else
9802                         {
9803                                 GET_BITMAP_CONFIG_N(HEADER::TAB_ITEM_BG_SELECTED, BITMAP_PIXEL_FORMAT_ARGB8888, __pBaseBackgroundBitmap);
9804                         }
9805                 }
9806                 else
9807                 {
9808                         if (__transparent == true)
9809                         {
9810                                 GET_BITMAP_CONFIG_N(FOOTER::TAB_ITEM_TRANSLUCENT_BG_SELECTED, BITMAP_PIXEL_FORMAT_ARGB8888, __pBaseBackgroundBitmap);
9811                         }
9812                         else
9813                         {
9814                                 GET_BITMAP_CONFIG_N(FOOTER::TAB_ITEM_BG_SELECTED, BITMAP_PIXEL_FORMAT_ARGB8888, __pBaseBackgroundBitmap);
9815                         }
9816                 }
9817         }
9818
9819         for (int i = 0; i < __itemCount; i++)
9820         {
9821                 if (__pItems.at(i) != null)
9822                 {
9823                         if (__pBaseBackgroundBitmap)
9824                         {
9825                                 SetColorReplacedBitmap(__pItems.at(i), _BUTTON_STATUS_SELECTED, __itemBackgroundColor[_BUTTON_STATUS_SELECTED], __pBaseBackgroundBitmap);
9826                         }
9827                 }
9828         }
9829
9830         delete __pBaseBackgroundBitmap;
9831
9832         return E_SUCCESS;
9833 }
9834
9835 Variant
9836 _Toolbar::GetPropertySelectedItemColor(void) const
9837 {
9838         return Variant(__itemBackgroundColor[_BUTTON_STATUS_SELECTED]);
9839 }
9840
9841 result
9842 _Toolbar::SetPropertySelectedItemTextColor(const Variant& color)
9843 {
9844         __itemTextColor[_BUTTON_STATUS_SELECTED] = color.ToColor();
9845
9846         for (int i = 0; i < __itemCount; i++)
9847         {
9848                 if (__pItems.at(i) != null)
9849                 {
9850                         __pItems.at(i)->SetTextColor(_BUTTON_STATUS_SELECTED, __itemTextColor[_BUTTON_STATUS_SELECTED]);
9851                 }
9852         }
9853
9854         return E_SUCCESS;
9855 }
9856
9857 Variant
9858 _Toolbar::GetPropertySelectedItemTextColor(void) const
9859 {
9860         return Variant(__itemTextColor[_BUTTON_STATUS_SELECTED]);
9861 }
9862
9863 Rectangle
9864 _Toolbar::GetButtonBounds(ToolbarButton position) const
9865 {
9866         return _CoordinateSystemUtils::ConvertToInteger(GetButtonBoundsF(position));
9867 }
9868
9869 FloatRectangle
9870 _Toolbar::GetButtonBoundsF(ToolbarButton position) const
9871 {
9872         FloatRectangle bounds = __pButtonItems[position]->GetBoundsF();
9873
9874         float leftTouchMargin = __pButtonItems[position]->GetLeftTouchMarginF();
9875         float topTouchMargin = __pButtonItems[position]->GetTopTouchMarginF();
9876         float rightTouchMargin = __pButtonItems[position]->GetRightTouchMarginF();
9877         float bottomTouchMargin = __pButtonItems[position]->GetBottomTouchMarginF();
9878
9879         bounds.x = bounds.x + leftTouchMargin;
9880         bounds.y = bounds.y + topTouchMargin;
9881         bounds.width = bounds.width - (leftTouchMargin + rightTouchMargin);
9882         bounds.height = bounds.height - (topTouchMargin + bottomTouchMargin);
9883
9884         return bounds;
9885 }
9886
9887 result
9888 _Toolbar::SetTitleBadgeIcon(const Bitmap* pBadgeIcon)
9889 {
9890         if (pBadgeIcon == null)
9891         {
9892                 return E_SUCCESS;
9893         }
9894
9895         if (__pTitleBadgeIcon)
9896         {
9897                 DetachChild(*__pTitleBadgeIcon);
9898
9899                 delete __pTitleBadgeIcon;
9900                 __pTitleBadgeIcon = null;
9901         }
9902
9903         float height = 0.0f;
9904         GET_SHAPE_CONFIG(HEADER::BADGE_HEIGHT, GetOrientation(), height);
9905
9906         __pTitleBadgeIcon = _Label::CreateLabelN();
9907
9908         if (__pTitleBadgeIcon)
9909         {
9910                 __pTitleBadgeIcon->SetBounds(FloatRectangle(0.0f, 0.0f, height, height));
9911                 __pTitleBadgeIcon->SetBackgroundBitmap(*pBadgeIcon);
9912
9913                 AttachChild(*__pTitleBadgeIcon);
9914                 SetChildAlwaysOnTop(*__pTitleBadgeIcon);
9915         }
9916
9917         return E_SUCCESS;
9918 }
9919
9920 result
9921 _Toolbar::SetTitleNumberedBadgeIcon(int number)
9922 {
9923         SysTryReturnResult(NID_UI_CTRL, (number >= 0 && number < 100000), E_INVALID_ARG,
9924                                 "[E_INVALID_ARG] The number is out of bounds.");
9925
9926         if (__pTitleBadgeIcon)
9927         {
9928                 DetachChild(*__pTitleBadgeIcon);
9929
9930                 delete __pTitleBadgeIcon;
9931                 __pTitleBadgeIcon = null;
9932         }
9933
9934         if (number != 0)
9935         {
9936                 __pTitleBadgeIcon = _Label::CreateLabelN();
9937
9938                 SysTryReturnResult(NID_UI_CTRL, __pTitleBadgeIcon, E_INVALID_STATE, "[E_INVALID_STATE] The badge icon instance isn't constructed.");
9939
9940                 Bitmap* pNumberedBadgeIconBitmap = null;
9941                 Bitmap* pNumberedBadgeIconEffectBitmap = null;
9942                 Bitmap* pColorReplacedBitmap = null;
9943                 Color badgeIconBgNormalColor;
9944                 Color badgeIconTextNormalColor;
9945
9946                 GET_BITMAP_CONFIG_N(HEADER::BADGE_ICON_BG_NORMAL, BITMAP_PIXEL_FORMAT_ARGB8888, pNumberedBadgeIconBitmap);
9947
9948                 bool customTheme = IS_CUSTOM_BITMAP(HEADER::BADGE_ICON_BG_NORMAL);
9949                 if (customTheme == false)
9950                 {
9951                         GET_BITMAP_CONFIG_N(HEADER::BADGE_ICON_BG_EFFECT_NORMAL, BITMAP_PIXEL_FORMAT_ARGB8888, pNumberedBadgeIconEffectBitmap);
9952                 }
9953
9954                 GET_COLOR_CONFIG(HEADER::BADGE_ICON_BG_NORMAL, badgeIconBgNormalColor);
9955                 GET_COLOR_CONFIG(HEADER::BADGE_ICON_TEXT_NORMAL, badgeIconTextNormalColor);
9956
9957                 if (pNumberedBadgeIconBitmap)
9958                 {
9959                         pColorReplacedBitmap = _BitmapImpl::GetColorReplacedBitmapN(*pNumberedBadgeIconBitmap,
9960                                         Color::GetColor(COLOR_ID_MAGENTA), badgeIconBgNormalColor);
9961
9962                         __pTitleBadgeIcon->SetBackgroundBitmap(*pColorReplacedBitmap);
9963
9964                         delete pColorReplacedBitmap;
9965                         delete pNumberedBadgeIconBitmap;
9966                 }
9967
9968                 if (pNumberedBadgeIconEffectBitmap)
9969                 {
9970                         __pTitleBadgeIcon->SetBackgroundEffectBitmap(*pNumberedBadgeIconEffectBitmap);
9971
9972                         delete pNumberedBadgeIconEffectBitmap;
9973                 }
9974
9975                 __pTitleBadgeIcon->SetTextHorizontalAlignment(ALIGNMENT_RIGHT);
9976                 __pTitleBadgeIcon->SetTextVerticalAlignment(ALIGNMENT_MIDDLE);
9977                 __pTitleBadgeIcon->SetTextColor(badgeIconTextNormalColor);
9978                 __pTitleBadgeIcon->SetMargin(0, 10);
9979
9980                 float fontSize = 0.0f;
9981                 float height = 0.0f;
9982                 float width = 0.0f;
9983
9984                 GET_SHAPE_CONFIG(HEADER::BADGE_FONT_SIZE, GetOrientation(), fontSize);
9985                 GET_SHAPE_CONFIG(HEADER::BADGE_HEIGHT, GetOrientation(), height);
9986
9987                 if (number < 10)
9988                 {
9989                         GET_SHAPE_CONFIG(HEADER::BADGE_WIDTH_1DIGIT, GetOrientation(), width);
9990                 }
9991                 else if (number < 100)
9992                 {
9993                         GET_SHAPE_CONFIG(HEADER::BADGE_WIDTH_2DIGIT, GetOrientation(), width);
9994                 }
9995                 else if (number < 1000)
9996                 {
9997                         GET_SHAPE_CONFIG(HEADER::BADGE_WIDTH_3DIGIT, GetOrientation(), width);
9998                 }
9999                 else if (number < 10000)
10000                 {
10001                         GET_SHAPE_CONFIG(HEADER::BADGE_WIDTH_4DIGIT, GetOrientation(), width);
10002                 }
10003                 else
10004                 {
10005                         GET_SHAPE_CONFIG(HEADER::BADGE_WIDTH_5DIGIT, GetOrientation(), width);
10006                 }
10007
10008                 __pTitleBadgeIcon->SetBounds(FloatRectangle(0.0f, 0.0f, width, height));
10009                 __pTitleBadgeIcon->SetTextConfig(fontSize, LABEL_TEXT_STYLE_NORMAL);
10010
10011                 Integer tempNumber(number);
10012                 __pTitleBadgeIcon->SetText(tempNumber.ToString());
10013
10014                 AttachChild(*__pTitleBadgeIcon);
10015                 SetChildAlwaysOnTop(*__pTitleBadgeIcon);
10016         }
10017
10018         return E_SUCCESS;
10019 }
10020
10021 }}} // Tizen::Ui::Controls