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