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 Flora License, Version 1.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://floralicense.org/license/
  10 //
  11 // Unless required by applicable law or agreed to in writing, software
  12 // distributed under the License is distributed on an AS IS BASIS,
  13 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  14 // See the License for the specific language governing permissions and
  15 // limitations under the License.
  16 //
  17 /**
  18  * @file                FUiCtrl_Toolbar.cpp
  19  * @brief               This is the implementation file for the _Toolbar class.
  20  */
  21
  22 #include <FBaseSysLog.h>
  23 #include <FGrp_BitmapImpl.h>
  24 #include "FUi_CoordinateSystemUtils.h"
  25 #include "FUi_AccessibilityContainer.h"
  26 #include "FUi_AccessibilityElement.h"
  27 #include "FUi_AccessibilityManager.h"
  28 #include "FUi_IAccessibilityListener.h"
  29 #include "FUi_CoordinateSystemUtils.h"
  30 #include "FUi_TouchLongPressGestureDetector.h"
  31 #include "FUi_ResourceManager.h"
  32 #include "FUiCtrl_ActionEvent.h"
  33 #include "FUiCtrl_Toolbar.h"
  34 #include "FUiCtrl_ToolbarPresenter.h"
  35 #include "FUiCtrl_Label.h"
  36 #include "FUiCtrl_Form.h"
  37
  38 using namespace Tizen::Base;
  39 using namespace Tizen::Base::Collection;
  40 using namespace Tizen::Graphics;
  41 using namespace Tizen::Ui;
  42
  43 namespace
  44 {
  45 class FooterItemAccessibilityListener
  46         : public _IAccessibilityListener
  47 {
  48 public:
  49         FooterItemAccessibilityListener(void){}
  50         virtual ~FooterItemAccessibilityListener(void){}
  51         virtual bool OnAccessibilityFocusMovedNext(const _AccessibilityContainer& control, const _AccessibilityElement& element){return true;}
  52         virtual bool OnAccessibilityFocusMovedPrevious(const _AccessibilityContainer& control, const _AccessibilityElement& element){return true;}
  53         virtual bool OnAccessibilityReadingElement(const _AccessibilityContainer& control, const _AccessibilityElement& element){return true;}
  54         virtual bool OnAccessibilityReadedElement(const _AccessibilityContainer& control, const _AccessibilityElement& element){return true;}
  55         virtual bool OnAccessibilityFocusIn(const _AccessibilityContainer& control, const _AccessibilityElement& element){return true;}
  56         virtual bool OnAccessibilityFocusOut(const _AccessibilityContainer& control, const _AccessibilityElement& element){return true;}
  57         virtual bool OnAccessibilityValueIncreased(const _AccessibilityContainer& control, const _AccessibilityElement& element){return true;}
  58         virtual bool OnAccessibilityValueDecreased(const _AccessibilityContainer& control, const _AccessibilityElement& element){return true;}
  59         virtual bool OnAccessibilityActionPerformed(const _AccessibilityContainer& control, const _AccessibilityElement& element)
  60         {
  61                 _AccessibilityManager::GetInstance()->RequestAutoReading(_ACCESSIBILITY_AUTO_READING_MODE_FIRST_ITEM_OF_CONTENTS);
  62                 return true;
  63         }
  64 };
  65 FooterItemAccessibilityListener footerItemAccessibilityListener;
  66 }
  67
  68 namespace Tizen { namespace Ui { namespace Controls
  69 {
  70
  71 IMPLEMENT_PROPERTY(_Toolbar);
  72
  73 _Toolbar::_Toolbar(void)
  74         : __header(false)
  75         , __pToolbarPresenter(null)
  76         , __pActionEventListener(null)
  77         , __pBackEventListener(null)
  78         , __pLongPressGesture(null)
  79         , __pFlickGesture(null)
  80         , __pToolbarBackgroundBitmap(null)
  81         , __pTitleIcon(null)
  82         , __titleText(L"")
  83         , __descriptionText(L"")
  84         , __titleTextAlignment(ALIGNMENT_LEFT)
  85         , __pItems(null)
  86         , __pTitleBadgeIcon(null)
  87         , __backActionId(-1)
  88         , __itemCount(0)
  89         , __style(TOOLBAR_TITLE)
  90         , __transparent(false)
  91         , __isUserBackgroundBitmap(false)
  92         , __titleTextArea(FloatRectangle(0.0f, 0.0f, 0.0f, 0.0f))
  93         , __itemArea(FloatRectangle(0.0f, 0.0f, 0.0f, 0.0f))
  94         , __pTitleTextElement(null)
  95 {
  96         _AccessibilityContainer* pContainer = null;
  97
  98         __pButtonItems[LEFT_BUTTON] = null;
  99         __pButtonItems[RIGHT_BUTTON] = null;
 100         __pButtonItems[BACK_BUTTON] = null;
 101         __pButtonItems[MIDDLE_BUTTON] = null;
 102
 103         for (int i = 0; i < TOOLBAR_ANIMATION_POSITION_MAX; i++)
 104         {
 105                 __pAnimation[i] = null;
 106                 __pAnimationFrameList[i] = null;
 107         }
 108
 109         Color bgColor;
 110
 111         GET_COLOR_CONFIG(FOOTER::BG_NORMAL, bgColor);
 112
 113         SetColor(bgColor);
 114
 115         _Control::SetResizable(false);
 116
 117         _Control::SetMovable(false);
 118
 119         _ToolbarPresenter* pPresenter = new (std::nothrow) _ToolbarPresenter();
 120
 121         SetPresenter(*pPresenter);
 122
 123         pPresenter->Construct(*this);
 124
 125         pPresenter->Install();
 126
 127         pContainer = GetAccessibilityContainer();
 128
 129         if(pContainer)
 130         {
 131                 pContainer->Activate(true);
 132         }
 133
 134         for (int i = 0; i < TOOLBAR_ITEM_MAX_STATE_COUNT; i++)
 135         {
 136                 __isItemBgColorSetByUser[i] = false;
 137                 __isItemTextColorSetByUser[i] = false;
 138         }
 139
 140         for (int i = 0; i < TOOLBAR_BUTTON_MAX_STATE_COUNT; i++)
 141         {
 142                 __isButtonBgColorSetByUser[i] = false;
 143                 __isButtonTextColorSetByUser[i] = false;
 144         }
 145 }
 146
 147 _Toolbar::~_Toolbar(void)
 148 {
 149         RemoveAllItems();               //__pMoreButton would be deleted in this function
 150         RemoveAllButtons();
 151
 152         if (__pToolbarPresenter)
 153         {
 154                 delete __pToolbarPresenter;
 155                 __pToolbarPresenter = null;
 156         }
 157
 158         if (__pActionEventListener)
 159         {
 160                 __pActionEventListener = null;
 161         }
 162
 163         if (__pBackEventListener)
 164         {
 165                 __pBackEventListener = null;
 166         }
 167
 168         if (__pLongPressGesture != null)
 169         {
 170                 __pLongPressGesture->RemoveGestureListener(*this);
 171                 RemoveGestureDetector(*__pLongPressGesture);
 172
 173                 delete __pLongPressGesture;
 174                 __pLongPressGesture = null;
 175         }
 176
 177         if (__pFlickGesture != null)
 178         {
 179                 __pFlickGesture->RemoveGestureListener(*this);
 180                 RemoveGestureDetector(*__pFlickGesture);
 181
 182                 delete __pFlickGesture;
 183                 __pFlickGesture = null;
 184         }
 185
 186         if (__pToolbarBackgroundBitmap)
 187         {
 188                 delete __pToolbarBackgroundBitmap;
 189                 __pToolbarBackgroundBitmap = null;
 190         }
 191
 192         if (__pTitleIcon)
 193         {
 194                 delete __pTitleIcon;
 195                 __pTitleIcon = null;
 196         }
 197
 198         for (int i = 0; i < TOOLBAR_ANIMATION_POSITION_MAX; i++)
 199         {
 200                 if (__pAnimationFrameList[i])
 201                 {
 202                         __pAnimationFrameList[i]->RemoveAll(true);
 203
 204                         delete __pAnimationFrameList[i];
 205                         __pAnimationFrameList[i] = null;
 206                 }
 207         }
 208
 209         if (__pAnimation[TOOLBAR_ANIMATION_POSITION_TITLE])
 210         {
 211                 DetachChild(*__pAnimation[TOOLBAR_ANIMATION_POSITION_TITLE]);
 212                 delete __pAnimation[TOOLBAR_ANIMATION_POSITION_TITLE];
 213                 __pAnimation[TOOLBAR_ANIMATION_POSITION_TITLE] = null;
 214         }
 215
 216         if (__pTitleBadgeIcon)
 217         {
 218                 DetachChild(*__pTitleBadgeIcon);
 219
 220                 delete __pTitleBadgeIcon;
 221                 __pTitleBadgeIcon = null;
 222         }
 223
 224         if (__pTitleTextElement)
 225         {
 226                 __pTitleTextElement->Activate(false);
 227                 __pTitleTextElement = null;
 228         }
 229
 230         ClearLastResult();
 231 }
 232
 233 _Toolbar*
 234 _Toolbar::CreateToolbarN(bool header)
 235 {
 236         _Toolbar* pToolbar = new (std::nothrow) _Toolbar();
 237         SysTryReturn(NID_UI_CTRL, pToolbar, null, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] Memory shortage.");
 238
 239         pToolbar->Initialize(header);
 240         pToolbar->AcquireHandle();
 241
 242         return pToolbar;
 243 }
 244
 245 result
 246 _Toolbar::Initialize(bool header)
 247 {
 248         __header = header;
 249
 250         return E_SUCCESS;
 251 }
 252
 253 bool
 254 _Toolbar::IsHeader(void)
 255 {
 256         return __header;
 257 }
 258
 259 result
 260 _Toolbar::InitToolbarColor(void)
 261 {
 262         if (__header == true)
 263         {
 264                 if (__transparent) // header && transparent
 265                 {
 266                         GET_COLOR_CONFIG(HEADER::TRANSLUCENT_TITLE_TEXT_NORMAL, __transTitleTextColor);
 267                         GET_COLOR_CONFIG(HEADER::TRANSLUCENT_DESCRIPTION_TEXT_NORMAL, __transDescriptionTextColor);
 268
 269                         if (__style == TOOLBAR_TEXT || __style == TOOLBAR_ICON || __style == TOOLBAR_ICON_TEXT)
 270                         {
 271                                 GET_COLOR_CONFIG(FOOTER::BUTTON_ITEM_TRANSLUCENT_BG_NORMAL, __itemTransBackgroundColor[_BUTTON_STATUS_NORMAL]);
 272                                 GET_COLOR_CONFIG(FOOTER::BUTTON_ITEM_TRANSLUCENT_BG_DISABLED, __itemTransBackgroundColor[_BUTTON_STATUS_DISABLED]);
 273                                 GET_COLOR_CONFIG(FOOTER::BUTTON_ITEM_TRANSLUCENT_BG_PRESSED, __itemTransBackgroundColor[_BUTTON_STATUS_PRESSED]);
 274                                 GET_COLOR_CONFIG(FOOTER::BUTTON_ITEM_TRANSLUCENT_BG_HIGHLIGHTED, __itemTransBackgroundColor[_BUTTON_STATUS_HIGHLIGHTED]);
 275                                 //GET_COLOR_CONFIG(FOOTER::BUTTON_ITEM_TRANSLUCENT_BG_SELECTED, __itemTransBackgroundColor[_BUTTON_STATUS_SELECTED]);
 276
 277                                 GET_COLOR_CONFIG(FOOTER::BUTTON_ITEM_TRANSLUCENT_TEXT_NORMAL, __itemTransTextColor[_BUTTON_STATUS_NORMAL]);
 278                                 GET_COLOR_CONFIG(FOOTER::BUTTON_ITEM_TRANSLUCENT_TEXT_DISABLED, __itemTransTextColor[_BUTTON_STATUS_DISABLED]);
 279                                 GET_COLOR_CONFIG(FOOTER::BUTTON_ITEM_TRANSLUCENT_TEXT_PRESSED, __itemTransTextColor[_BUTTON_STATUS_PRESSED]);
 280                                 GET_COLOR_CONFIG(FOOTER::BUTTON_ITEM_TRANSLUCENT_TEXT_HIGHLIGHTED, __itemTransTextColor[_BUTTON_STATUS_HIGHLIGHTED]);
 281                                 //GET_COLOR_CONFIG(FOOTER::BUTTON_ITEM_TRANSLUCENT_TEXT_SELECTED, __itemTransTextColor[_BUTTON_STATUS_SELECTED]);
 282                         }
 283                         else if (__style == TOOLBAR_TAB || __style == TOOLBAR_TAB_WITH_TITLE)
 284                         {
 285                                 GET_COLOR_CONFIG(HEADER::TAB_ITEM_TRANSLUCENT_BG_NORMAL, __itemTransBackgroundColor[_BUTTON_STATUS_NORMAL]);
 286                                 GET_COLOR_CONFIG(HEADER::TAB_ITEM_TRANSLUCENT_BG_DISABLED, __itemTransBackgroundColor[_BUTTON_STATUS_DISABLED]);
 287                                 GET_COLOR_CONFIG(HEADER::TAB_ITEM_TRANSLUCENT_BG_PRESSED, __itemTransBackgroundColor[_BUTTON_STATUS_PRESSED]);
 288                                 GET_COLOR_CONFIG(HEADER::TAB_ITEM_TRANSLUCENT_BG_HIGHLIGHTED, __itemTransBackgroundColor[_BUTTON_STATUS_HIGHLIGHTED]);
 289                                 GET_COLOR_CONFIG(HEADER::TAB_ITEM_TRANSLUCENT_BG_SELECTED, __itemTransBackgroundColor[_BUTTON_STATUS_SELECTED]);
 290
 291                                 GET_COLOR_CONFIG(HEADER::TAB_ITEM_TRANSLUCENT_TEXT_NORMAL, __itemTransTextColor[_BUTTON_STATUS_NORMAL]);
 292                                 GET_COLOR_CONFIG(HEADER::TAB_ITEM_TRANSLUCENT_TEXT_DISABLED, __itemTransTextColor[_BUTTON_STATUS_DISABLED]);
 293                                 GET_COLOR_CONFIG(HEADER::TAB_ITEM_TRANSLUCENT_TEXT_PRESSED, __itemTransTextColor[_BUTTON_STATUS_PRESSED]);
 294                                 GET_COLOR_CONFIG(HEADER::TAB_ITEM_TRANSLUCENT_TEXT_HIGHLIGHTED, __itemTransTextColor[_BUTTON_STATUS_HIGHLIGHTED]);
 295                                 GET_COLOR_CONFIG(HEADER::TAB_ITEM_TRANSLUCENT_TEXT_SELECTED, __itemTransTextColor[_BUTTON_STATUS_SELECTED]);
 296                         }
 297                         else // TOOLBAR_TITLE, TOOLBAR_HEADER_SEGMENTED, TOOLBAR_HEADER_SEGMENTED_WITH_TITLE
 298                         {
 299                                 GET_COLOR_CONFIG(HEADER::SEGMENTED_ITEM_TRANSLUCENT_BG_NORMAL, __itemTransBackgroundColor[_BUTTON_STATUS_NORMAL]);
 300                                 GET_COLOR_CONFIG(HEADER::SEGMENTED_ITEM_TRANSLUCENT_BG_DISABLED, __itemTransBackgroundColor[_BUTTON_STATUS_DISABLED]);
 301                                 GET_COLOR_CONFIG(HEADER::SEGMENTED_ITEM_TRANSLUCENT_BG_PRESSED, __itemTransBackgroundColor[_BUTTON_STATUS_PRESSED]);
 302                                 GET_COLOR_CONFIG(HEADER::SEGMENTED_ITEM_TRANSLUCENT_BG_HIGHLIGHTED, __itemTransBackgroundColor[_BUTTON_STATUS_HIGHLIGHTED]);
 303                                 GET_COLOR_CONFIG(HEADER::SEGMENTED_ITEM_TRANSLUCENT_BG_SELECTED, __itemTransBackgroundColor[_BUTTON_STATUS_SELECTED]);
 304
 305                                 GET_COLOR_CONFIG(HEADER::SEGMENTED_ITEM_TRANSLUCENT_TEXT_NORMAL, __itemTransTextColor[_BUTTON_STATUS_NORMAL]);
 306                                 GET_COLOR_CONFIG(HEADER::SEGMENTED_ITEM_TRANSLUCENT_TEXT_DISABLED, __itemTransTextColor[_BUTTON_STATUS_DISABLED]);
 307                                 GET_COLOR_CONFIG(HEADER::SEGMENTED_ITEM_TRANSLUCENT_TEXT_PRESSED, __itemTransTextColor[_BUTTON_STATUS_PRESSED]);
 308                                 GET_COLOR_CONFIG(HEADER::SEGMENTED_ITEM_TRANSLUCENT_TEXT_HIGHLIGHTED, __itemTransTextColor[_BUTTON_STATUS_HIGHLIGHTED]);
 309                                 GET_COLOR_CONFIG(HEADER::SEGMENTED_ITEM_TRANSLUCENT_TEXT_SELECTED, __itemTransTextColor[_BUTTON_STATUS_SELECTED]);
 310                         }
 311
 312                         __itemTransBackgroundColor[_BUTTON_STATUS_NORMAL].SetAlpha(0x00);
 313                         __itemTransBackgroundColor[_BUTTON_STATUS_DISABLED].SetAlpha(0x00);
 314                         __itemTransBackgroundColor[_BUTTON_STATUS_PRESSED].SetAlpha(0xFF);
 315                         __itemTransBackgroundColor[_BUTTON_STATUS_HIGHLIGHTED].SetAlpha(0x00);
 316                         __itemTransBackgroundColor[_BUTTON_STATUS_SELECTED].SetAlpha(0x00);
 317
 318                         GET_COLOR_CONFIG(HEADER::BUTTON_TRANSLUCENT_BG_NORMAL, __buttonTransBackgroundColor[_BUTTON_STATUS_NORMAL]);
 319                         GET_COLOR_CONFIG(HEADER::BUTTON_TRANSLUCENT_BG_DISABLED, __buttonTransBackgroundColor[_BUTTON_STATUS_DISABLED]);
 320                         GET_COLOR_CONFIG(HEADER::BUTTON_TRANSLUCENT_BG_PRESSED, __buttonTransBackgroundColor[_BUTTON_STATUS_PRESSED]);
 321                         GET_COLOR_CONFIG(HEADER::BUTTON_TRANSLUCENT_BG_HIGHLIGHTED, __buttonTransBackgroundColor[_BUTTON_STATUS_HIGHLIGHTED]);
 322
 323                         __buttonTransBackgroundColor[_BUTTON_STATUS_NORMAL].SetAlpha(0x00);
 324                         __buttonTransBackgroundColor[_BUTTON_STATUS_DISABLED].SetAlpha(0x00);
 325                         __buttonTransBackgroundColor[_BUTTON_STATUS_PRESSED].SetAlpha(0x00);
 326                         __buttonTransBackgroundColor[_BUTTON_STATUS_HIGHLIGHTED].SetAlpha(0x00);
 327
 328                         GET_COLOR_CONFIG(HEADER::BUTTON_TRANSLUCENT_TEXT_NORMAL, __buttonTransTextColor[_BUTTON_STATUS_NORMAL]);
 329                         GET_COLOR_CONFIG(HEADER::BUTTON_TRANSLUCENT_TEXT_DISABLED, __buttonTransTextColor[_BUTTON_STATUS_DISABLED]);
 330                         GET_COLOR_CONFIG(HEADER::BUTTON_TRANSLUCENT_TEXT_PRESSED, __buttonTransTextColor[_BUTTON_STATUS_PRESSED]);
 331                         GET_COLOR_CONFIG(HEADER::BUTTON_TRANSLUCENT_TEXT_HIGHLIGHTED, __buttonTransTextColor[_BUTTON_STATUS_HIGHLIGHTED]);
 332                 }
 333                 else // header && not transparent
 334                 {
 335                         GET_COLOR_CONFIG(HEADER::TITLE_TEXT_NORMAL, __titleTextColor);
 336                         GET_COLOR_CONFIG(HEADER::TITLE_TEXT_NORMAL, __descriptionTextColor);
 337
 338
 339                         if (__style == TOOLBAR_TEXT || __style == TOOLBAR_ICON || __style == TOOLBAR_ICON_TEXT)
 340                         {
 341                                 if (!__isItemBgColorSetByUser[_BUTTON_STATUS_NORMAL])
 342                                 {
 343                                         GET_COLOR_CONFIG(FOOTER::BUTTON_ITEM_BG_NORMAL, __itemBackgroundColor[_BUTTON_STATUS_NORMAL]);
 344                                 }
 345                                 if (!__isItemBgColorSetByUser[_BUTTON_STATUS_DISABLED])
 346                                 {
 347                                         GET_COLOR_CONFIG(FOOTER::BUTTON_ITEM_BG_DISABLED, __itemBackgroundColor[_BUTTON_STATUS_DISABLED]);
 348                                 }
 349                                 if (!__isItemBgColorSetByUser[_BUTTON_STATUS_PRESSED])
 350                                 {
 351                                         GET_COLOR_CONFIG(FOOTER::BUTTON_ITEM_BG_PRESSED, __itemBackgroundColor[_BUTTON_STATUS_PRESSED]);
 352                                 }
 353                                 if (!__isItemBgColorSetByUser[_BUTTON_STATUS_HIGHLIGHTED])
 354                                 {
 355                                         GET_COLOR_CONFIG(FOOTER::BUTTON_ITEM_BG_HIGHLIGHTED, __itemBackgroundColor[_BUTTON_STATUS_HIGHLIGHTED]);
 356                                 }
 357                                 //if (!__isItemBgColorSetByUser[_BUTTON_STATUS_SELECTED])
 358                                 //{
 359                                 //      GET_COLOR_CONFIG(FOOTER::BUTTON_ITEM_BG_SELECTED, __itemBackgroundColor[_BUTTON_STATUS_SELECTED]);
 360                                 //}
 361
 362                                 if (!__isItemTextColorSetByUser[_BUTTON_STATUS_NORMAL])
 363                                 {
 364                                         GET_COLOR_CONFIG(FOOTER::BUTTON_ITEM_TEXT_NORMAL, __itemTextColor[_BUTTON_STATUS_NORMAL]);
 365                                 }
 366                                 if (!__isItemTextColorSetByUser[_BUTTON_STATUS_DISABLED])
 367                                 {
 368                                         GET_COLOR_CONFIG(FOOTER::BUTTON_ITEM_TEXT_DISABLED, __itemTextColor[_BUTTON_STATUS_DISABLED]);
 369                                 }
 370                                 if (!__isItemTextColorSetByUser[_BUTTON_STATUS_PRESSED])
 371                                 {
 372                                         GET_COLOR_CONFIG(FOOTER::BUTTON_ITEM_TEXT_PRESSED, __itemTextColor[_BUTTON_STATUS_PRESSED]);
 373                                 }
 374                                 if (!__isItemTextColorSetByUser[_BUTTON_STATUS_HIGHLIGHTED])
 375                                 {
 376                                         GET_COLOR_CONFIG(FOOTER::BUTTON_ITEM_TEXT_HIGHLIGHTED, __itemTextColor[_BUTTON_STATUS_HIGHLIGHTED]);
 377                                 }
 378                                 //if (!__isItemTextColorSetByUser[_BUTTON_STATUS_SELECTED])
 379                                 //{
 380                                 //      GET_COLOR_CONFIG(FOOTER::BUTTON_ITEM_TEXT_SELECTED, __itemTextColor[_BUTTON_STATUS_SELECTED]);
 381                                 //}
 382                         }
 383                         else if (__style == TOOLBAR_TAB || __style == TOOLBAR_TAB_WITH_TITLE) // header
 384                         {
 385                                 if (!__isItemBgColorSetByUser[_BUTTON_STATUS_NORMAL])
 386                                 {
 387                                         GET_COLOR_CONFIG(HEADER::TAB_ITEM_BG_NORMAL, __itemBackgroundColor[_BUTTON_STATUS_NORMAL]);
 388                                 }
 389                                 if (!__isItemBgColorSetByUser[_BUTTON_STATUS_DISABLED])
 390                                 {
 391                                         GET_COLOR_CONFIG(HEADER::TAB_ITEM_BG_DISABLED, __itemBackgroundColor[_BUTTON_STATUS_DISABLED]);
 392                                 }
 393                                 if (!__isItemBgColorSetByUser[_BUTTON_STATUS_PRESSED])
 394                                 {
 395                                         GET_COLOR_CONFIG(HEADER::TAB_ITEM_BG_PRESSED, __itemBackgroundColor[_BUTTON_STATUS_PRESSED]);
 396                                 }
 397                                 if (!__isItemBgColorSetByUser[_BUTTON_STATUS_HIGHLIGHTED])
 398                                 {
 399                                         GET_COLOR_CONFIG(HEADER::TAB_ITEM_BG_HIGHLIGHTED, __itemBackgroundColor[_BUTTON_STATUS_HIGHLIGHTED]);
 400                                 }
 401                                 if (!__isItemBgColorSetByUser[_BUTTON_STATUS_SELECTED])
 402                                 {
 403                                         GET_COLOR_CONFIG(HEADER::TAB_ITEM_BG_SELECTED, __itemBackgroundColor[_BUTTON_STATUS_SELECTED]);
 404                                 }
 405
 406                                 if (!__isItemTextColorSetByUser[_BUTTON_STATUS_NORMAL])
 407                                 {
 408                                         GET_COLOR_CONFIG(HEADER::TAB_ITEM_TEXT_NORMAL, __itemTextColor[_BUTTON_STATUS_NORMAL]);
 409                                 }
 410                                 if (!__isItemTextColorSetByUser[_BUTTON_STATUS_DISABLED])
 411                                 {
 412                                         GET_COLOR_CONFIG(HEADER::TAB_ITEM_TEXT_DISABLED, __itemTextColor[_BUTTON_STATUS_DISABLED]);
 413                                 }
 414                                 if (!__isItemTextColorSetByUser[_BUTTON_STATUS_PRESSED])
 415                                 {
 416                                         GET_COLOR_CONFIG(HEADER::TAB_ITEM_TEXT_PRESSED, __itemTextColor[_BUTTON_STATUS_PRESSED]);
 417                                 }
 418                                 if (!__isItemTextColorSetByUser[_BUTTON_STATUS_HIGHLIGHTED])
 419                                 {
 420                                         GET_COLOR_CONFIG(HEADER::TAB_ITEM_TEXT_HIGHLIGHTED, __itemTextColor[_BUTTON_STATUS_HIGHLIGHTED]);
 421                                 }
 422                                 if (!__isItemTextColorSetByUser[_BUTTON_STATUS_SELECTED])
 423                                 {
 424                                         GET_COLOR_CONFIG(HEADER::TAB_ITEM_TEXT_SELECTED, __itemTextColor[_BUTTON_STATUS_SELECTED]);
 425                                 }
 426                         }
 427                         else // TOOLBAR_TITLE, TOOLBAR_HEADER_SEGMENTED, TOOLBAR_HEADER_SEGMENTED_WITH_TITLE,
 428                         {
 429                                 if (!__isItemBgColorSetByUser[_BUTTON_STATUS_NORMAL])
 430                                 {
 431                                         GET_COLOR_CONFIG(HEADER::SEGMENTED_ITEM_BG_NORMAL, __itemBackgroundColor[_BUTTON_STATUS_NORMAL]);
 432                                 }
 433                                 if (!__isItemBgColorSetByUser[_BUTTON_STATUS_DISABLED])
 434                                 {
 435                                         GET_COLOR_CONFIG(HEADER::SEGMENTED_ITEM_BG_DISABLED, __itemBackgroundColor[_BUTTON_STATUS_DISABLED]);
 436                                 }
 437                                 if (!__isItemBgColorSetByUser[_BUTTON_STATUS_PRESSED])
 438                                 {
 439                                         GET_COLOR_CONFIG(HEADER::SEGMENTED_ITEM_BG_PRESSED, __itemBackgroundColor[_BUTTON_STATUS_PRESSED]);
 440                                 }
 441                                 if (!__isItemBgColorSetByUser[_BUTTON_STATUS_HIGHLIGHTED])
 442                                 {
 443                                         GET_COLOR_CONFIG(HEADER::SEGMENTED_ITEM_BG_HIGHLIGHTED, __itemBackgroundColor[_BUTTON_STATUS_HIGHLIGHTED]);
 444                                 }
 445                                 if (!__isItemBgColorSetByUser[_BUTTON_STATUS_SELECTED])
 446                                 {
 447                                         GET_COLOR_CONFIG(HEADER::SEGMENTED_ITEM_BG_SELECTED, __itemBackgroundColor[_BUTTON_STATUS_SELECTED]);
 448                                 }
 449
 450                                 if (!__isItemTextColorSetByUser[_BUTTON_STATUS_NORMAL])
 451                                 {
 452                                         GET_COLOR_CONFIG(HEADER::SEGMENTED_ITEM_TEXT_NORMAL, __itemTextColor[_BUTTON_STATUS_NORMAL]);
 453                                 }
 454                                 if (!__isItemTextColorSetByUser[_BUTTON_STATUS_DISABLED])
 455                                 {
 456                                         GET_COLOR_CONFIG(HEADER::SEGMENTED_ITEM_TEXT_DISABLED, __itemTextColor[_BUTTON_STATUS_DISABLED]);
 457                                 }
 458                                 if (!__isItemTextColorSetByUser[_BUTTON_STATUS_PRESSED])
 459                                 {
 460                                         GET_COLOR_CONFIG(HEADER::SEGMENTED_ITEM_TEXT_PRESSED, __itemTextColor[_BUTTON_STATUS_PRESSED]);
 461                                 }
 462                                 if (!__isItemTextColorSetByUser[_BUTTON_STATUS_HIGHLIGHTED])
 463                                 {
 464                                         GET_COLOR_CONFIG(HEADER::SEGMENTED_ITEM_TEXT_HIGHLIGHTED, __itemTextColor[_BUTTON_STATUS_HIGHLIGHTED]);
 465                                 }
 466                                 if (!__isItemTextColorSetByUser[_BUTTON_STATUS_SELECTED])
 467                                 {
 468                                         GET_COLOR_CONFIG(HEADER::SEGMENTED_ITEM_TEXT_SELECTED, __itemTextColor[_BUTTON_STATUS_SELECTED]);
 469                                 }
 470                         }
 471
 472                         if (!__isButtonBgColorSetByUser[_BUTTON_STATUS_NORMAL])
 473                         {
 474                                 GET_COLOR_CONFIG(HEADER::BUTTON_BG_NORMAL, __buttonBackgroundColor[_BUTTON_STATUS_NORMAL]);
 475                         }
 476                         if (!__isButtonBgColorSetByUser[_BUTTON_STATUS_DISABLED])
 477                         {
 478                                 GET_COLOR_CONFIG(HEADER::BUTTON_BG_DISABLED, __buttonBackgroundColor[_BUTTON_STATUS_DISABLED]);
 479                         }
 480                         if (!__isButtonBgColorSetByUser[_BUTTON_STATUS_PRESSED])
 481                         {
 482                                 GET_COLOR_CONFIG(HEADER::BUTTON_BG_PRESSED, __buttonBackgroundColor[_BUTTON_STATUS_PRESSED]);
 483                         }
 484                         if (!__isButtonBgColorSetByUser[_BUTTON_STATUS_HIGHLIGHTED])
 485                         {
 486                                 GET_COLOR_CONFIG(HEADER::BUTTON_BG_HIGHLIGHTED, __buttonBackgroundColor[_BUTTON_STATUS_HIGHLIGHTED]);
 487                         }
 488
 489                         if (!__isButtonTextColorSetByUser[_BUTTON_STATUS_NORMAL])
 490                         {
 491                                 GET_COLOR_CONFIG(HEADER::BUTTON_TEXT_NORMAL, __buttonTextColor[_BUTTON_STATUS_NORMAL]);
 492                         }
 493                         if (!__isButtonTextColorSetByUser[_BUTTON_STATUS_DISABLED])
 494                         {
 495                                 GET_COLOR_CONFIG(HEADER::BUTTON_TEXT_DISABLED, __buttonTextColor[_BUTTON_STATUS_DISABLED]);
 496                         }
 497                         if (!__isButtonTextColorSetByUser[_BUTTON_STATUS_PRESSED])
 498                         {
 499                                 GET_COLOR_CONFIG(HEADER::BUTTON_TEXT_PRESSED, __buttonTextColor[_BUTTON_STATUS_PRESSED]);
 500                         }
 501                         if (!__isButtonTextColorSetByUser[_BUTTON_STATUS_HIGHLIGHTED])
 502                         {
 503                                 GET_COLOR_CONFIG(HEADER::BUTTON_TEXT_HIGHLIGHTED, __buttonTextColor[_BUTTON_STATUS_HIGHLIGHTED]);
 504                         }
 505                 }
 506         }
 507         else
 508         {
 509                 if (__transparent) // footer && transparent
 510                 {
 511                         if (__style == TOOLBAR_TEXT || __style == TOOLBAR_ICON || __style == TOOLBAR_ICON_TEXT)
 512                         {
 513                                 GET_COLOR_CONFIG(FOOTER::BUTTON_ITEM_TRANSLUCENT_BG_NORMAL, __itemTransBackgroundColor[_BUTTON_STATUS_NORMAL]);
 514                                 GET_COLOR_CONFIG(FOOTER::BUTTON_ITEM_TRANSLUCENT_BG_DISABLED, __itemTransBackgroundColor[_BUTTON_STATUS_DISABLED]);
 515                                 GET_COLOR_CONFIG(FOOTER::BUTTON_ITEM_TRANSLUCENT_BG_PRESSED, __itemTransBackgroundColor[_BUTTON_STATUS_PRESSED]);
 516                                 GET_COLOR_CONFIG(FOOTER::BUTTON_ITEM_TRANSLUCENT_BG_HIGHLIGHTED, __itemTransBackgroundColor[_BUTTON_STATUS_HIGHLIGHTED]);
 517                                 //GET_COLOR_CONFIG(FOOTER::BUTTON_ITEM_TRANSLUCENT_BG_SELECTED, __itemTransBackgroundColor[_BUTTON_STATUS_SELECTED]);
 518
 519                                 GET_COLOR_CONFIG(FOOTER::BUTTON_ITEM_TRANSLUCENT_TEXT_NORMAL, __itemTransTextColor[_BUTTON_STATUS_NORMAL]);
 520                                 GET_COLOR_CONFIG(FOOTER::BUTTON_ITEM_TRANSLUCENT_TEXT_DISABLED, __itemTransTextColor[_BUTTON_STATUS_DISABLED]);
 521                                 GET_COLOR_CONFIG(FOOTER::BUTTON_ITEM_TRANSLUCENT_TEXT_PRESSED, __itemTransTextColor[_BUTTON_STATUS_PRESSED]);
 522                                 GET_COLOR_CONFIG(FOOTER::BUTTON_ITEM_TRANSLUCENT_TEXT_HIGHLIGHTED, __itemTransTextColor[_BUTTON_STATUS_HIGHLIGHTED]);
 523                                 //GET_COLOR_CONFIG(FOOTER::BUTTON_ITEM_TRANSLUCENT_TEXT_SELECTED, __itemTransTextColor[_BUTTON_STATUS_SELECTED]);
 524                         }
 525                         else if (__style == TOOLBAR_TAB)
 526                         {
 527                                 GET_COLOR_CONFIG(FOOTER::TAB_ITEM_TRANSLUCENT_BG_NORMAL, __itemTransBackgroundColor[_BUTTON_STATUS_NORMAL]);
 528                                 GET_COLOR_CONFIG(FOOTER::TAB_ITEM_TRANSLUCENT_BG_DISABLED, __itemTransBackgroundColor[_BUTTON_STATUS_DISABLED]);
 529                                 GET_COLOR_CONFIG(FOOTER::TAB_ITEM_TRANSLUCENT_BG_PRESSED, __itemTransBackgroundColor[_BUTTON_STATUS_PRESSED]);
 530                                 GET_COLOR_CONFIG(FOOTER::TAB_ITEM_TRANSLUCENT_BG_HIGHLIGHTED, __itemTransBackgroundColor[_BUTTON_STATUS_HIGHLIGHTED]);
 531                                 GET_COLOR_CONFIG(FOOTER::TAB_ITEM_TRANSLUCENT_BG_SELECTED, __itemTransBackgroundColor[_BUTTON_STATUS_SELECTED]);
 532
 533                                 GET_COLOR_CONFIG(FOOTER::TAB_ITEM_TRANSLUCENT_TEXT_NORMAL, __itemTransTextColor[_BUTTON_STATUS_NORMAL]);
 534                                 GET_COLOR_CONFIG(FOOTER::TAB_ITEM_TRANSLUCENT_TEXT_DISABLED, __itemTransTextColor[_BUTTON_STATUS_DISABLED]);
 535                                 GET_COLOR_CONFIG(FOOTER::TAB_ITEM_TRANSLUCENT_TEXT_PRESSED, __itemTransTextColor[_BUTTON_STATUS_PRESSED]);
 536                                 GET_COLOR_CONFIG(FOOTER::TAB_ITEM_TRANSLUCENT_TEXT_HIGHLIGHTED, __itemTransTextColor[_BUTTON_STATUS_HIGHLIGHTED]);
 537                                 GET_COLOR_CONFIG(FOOTER::TAB_ITEM_TRANSLUCENT_TEXT_SELECTED, __itemTransTextColor[_BUTTON_STATUS_SELECTED]);
 538                         }
 539                         else // TOOLBAR_SEGMENTED
 540                         {
 541                                 GET_COLOR_CONFIG(FOOTER::SEGMENTED_ITEM_TRANSLUCENT_BG_NORMAL, __itemTransBackgroundColor[_BUTTON_STATUS_NORMAL]);
 542                                 GET_COLOR_CONFIG(FOOTER::SEGMENTED_ITEM_TRANSLUCENT_BG_DISABLED, __itemTransBackgroundColor[_BUTTON_STATUS_DISABLED]);
 543                                 GET_COLOR_CONFIG(FOOTER::SEGMENTED_ITEM_TRANSLUCENT_BG_PRESSED, __itemTransBackgroundColor[_BUTTON_STATUS_PRESSED]);
 544                                 GET_COLOR_CONFIG(FOOTER::SEGMENTED_ITEM_TRANSLUCENT_BG_HIGHLIGHTED, __itemTransBackgroundColor[_BUTTON_STATUS_HIGHLIGHTED]);
 545                                 GET_COLOR_CONFIG(FOOTER::SEGMENTED_ITEM_TRANSLUCENT_BG_SELECTED, __itemTransBackgroundColor[_BUTTON_STATUS_SELECTED]);
 546
 547                                 GET_COLOR_CONFIG(FOOTER::SEGMENTED_ITEM_TRANSLUCENT_TEXT_NORMAL, __itemTransTextColor[_BUTTON_STATUS_NORMAL]);
 548                                 GET_COLOR_CONFIG(FOOTER::SEGMENTED_ITEM_TRANSLUCENT_TEXT_DISABLED, __itemTransTextColor[_BUTTON_STATUS_DISABLED]);
 549                                 GET_COLOR_CONFIG(FOOTER::SEGMENTED_ITEM_TRANSLUCENT_TEXT_PRESSED, __itemTransTextColor[_BUTTON_STATUS_PRESSED]);
 550                                 GET_COLOR_CONFIG(FOOTER::SEGMENTED_ITEM_TRANSLUCENT_TEXT_HIGHLIGHTED, __itemTransTextColor[_BUTTON_STATUS_HIGHLIGHTED]);
 551                                 GET_COLOR_CONFIG(FOOTER::SEGMENTED_ITEM_TRANSLUCENT_TEXT_SELECTED, __itemTransTextColor[_BUTTON_STATUS_SELECTED]);
 552                         }
 553
 554                         __itemTransBackgroundColor[_BUTTON_STATUS_NORMAL].SetAlpha(0x00);
 555                         __itemTransBackgroundColor[_BUTTON_STATUS_DISABLED].SetAlpha(0x00);
 556                         __itemTransBackgroundColor[_BUTTON_STATUS_PRESSED].SetAlpha(0xFF);
 557                         __itemTransBackgroundColor[_BUTTON_STATUS_HIGHLIGHTED].SetAlpha(0x00);
 558                         __itemTransBackgroundColor[_BUTTON_STATUS_SELECTED].SetAlpha(0x00);
 559
 560
 561                         GET_COLOR_CONFIG(FOOTER::BUTTON_TRANSLUCENT_BG_NORMAL, __buttonTransBackgroundColor[_BUTTON_STATUS_NORMAL]);
 562                         GET_COLOR_CONFIG(FOOTER::BUTTON_TRANSLUCENT_BG_DISABLED, __buttonTransBackgroundColor[_BUTTON_STATUS_DISABLED]);
 563                         GET_COLOR_CONFIG(FOOTER::BUTTON_TRANSLUCENT_BG_PRESSED, __buttonTransBackgroundColor[_BUTTON_STATUS_PRESSED]);
 564                         GET_COLOR_CONFIG(FOOTER::BUTTON_TRANSLUCENT_BG_HIGHLIGHTED, __buttonTransBackgroundColor[_BUTTON_STATUS_HIGHLIGHTED]);
 565
 566                         __buttonTransBackgroundColor[_BUTTON_STATUS_NORMAL].SetAlpha(0x00);
 567                         __buttonTransBackgroundColor[_BUTTON_STATUS_DISABLED].SetAlpha(0x00);
 568                         __buttonTransBackgroundColor[_BUTTON_STATUS_PRESSED].SetAlpha(0x00);
 569                         __buttonTransBackgroundColor[_BUTTON_STATUS_HIGHLIGHTED].SetAlpha(0x00);
 570
 571                         GET_COLOR_CONFIG(FOOTER::BUTTON_TRANSLUCENT_TEXT_NORMAL, __buttonTransTextColor[_BUTTON_STATUS_NORMAL]);
 572                         GET_COLOR_CONFIG(FOOTER::BUTTON_TRANSLUCENT_TEXT_DISABLED, __buttonTransTextColor[_BUTTON_STATUS_DISABLED]);
 573                         GET_COLOR_CONFIG(FOOTER::BUTTON_TRANSLUCENT_TEXT_PRESSED, __buttonTransTextColor[_BUTTON_STATUS_PRESSED]);
 574                         GET_COLOR_CONFIG(FOOTER::BUTTON_TRANSLUCENT_TEXT_HIGHLIGHTED, __buttonTransTextColor[_BUTTON_STATUS_HIGHLIGHTED]);
 575                 }
 576                 else // footer && not transparent
 577                 {
 578                         if (__style == TOOLBAR_TEXT || __style == TOOLBAR_ICON || __style == TOOLBAR_ICON_TEXT)
 579                         {
 580                                 if (!__isItemBgColorSetByUser[_BUTTON_STATUS_NORMAL])
 581                                 {
 582                                         GET_COLOR_CONFIG(FOOTER::BUTTON_ITEM_BG_NORMAL, __itemBackgroundColor[_BUTTON_STATUS_NORMAL]);
 583                                 }
 584                                 if (!__isItemBgColorSetByUser[_BUTTON_STATUS_DISABLED])
 585                                 {
 586                                         GET_COLOR_CONFIG(FOOTER::BUTTON_ITEM_BG_DISABLED, __itemBackgroundColor[_BUTTON_STATUS_DISABLED]);
 587                                 }
 588                                 if (!__isItemBgColorSetByUser[_BUTTON_STATUS_PRESSED])
 589                                 {
 590                                         GET_COLOR_CONFIG(FOOTER::BUTTON_ITEM_BG_PRESSED, __itemBackgroundColor[_BUTTON_STATUS_PRESSED]);
 591                                 }
 592                                 if (!__isItemBgColorSetByUser[_BUTTON_STATUS_HIGHLIGHTED])
 593                                 {
 594                                         GET_COLOR_CONFIG(FOOTER::BUTTON_ITEM_BG_HIGHLIGHTED, __itemBackgroundColor[_BUTTON_STATUS_HIGHLIGHTED]);
 595                                 }
 596                                 //if (!__isItemBgColorSetByUser[_BUTTON_STATUS_SELECTED])
 597                                 //{
 598                                 //      GET_COLOR_CONFIG(FOOTER::BUTTON_ITEM_BG_SELECTED, __itemBackgroundColor[_BUTTON_STATUS_SELECTED]);
 599                                 //}
 600
 601                                 if (!__isItemTextColorSetByUser[_BUTTON_STATUS_NORMAL])
 602                                 {
 603                                         GET_COLOR_CONFIG(FOOTER::BUTTON_ITEM_TEXT_NORMAL, __itemTextColor[_BUTTON_STATUS_NORMAL]);
 604                                 }
 605                                 if (!__isItemTextColorSetByUser[_BUTTON_STATUS_DISABLED])
 606                                 {
 607                                         GET_COLOR_CONFIG(FOOTER::BUTTON_ITEM_TEXT_DISABLED, __itemTextColor[_BUTTON_STATUS_DISABLED]);
 608                                 }
 609                                 if (!__isItemTextColorSetByUser[_BUTTON_STATUS_PRESSED])
 610                                 {
 611                                         GET_COLOR_CONFIG(FOOTER::BUTTON_ITEM_TEXT_PRESSED, __itemTextColor[_BUTTON_STATUS_PRESSED]);
 612                                 }
 613                                 if (!__isItemTextColorSetByUser[_BUTTON_STATUS_HIGHLIGHTED])
 614                                 {
 615                                         GET_COLOR_CONFIG(FOOTER::BUTTON_ITEM_TEXT_HIGHLIGHTED, __itemTextColor[_BUTTON_STATUS_HIGHLIGHTED]);
 616                                 }
 617                                 //if (!__isItemTextColorSetByUser[_BUTTON_STATUS_SELECTED])
 618                                 //{
 619                                 //      GET_COLOR_CONFIG(FOOTER::BUTTON_ITEM_TEXT_SELECTED, __itemTextColor[_BUTTON_STATUS_SELECTED]);
 620                                 //}
 621                         }
 622                         else if (__style == TOOLBAR_TAB)
 623                         {
 624                                 if (!__isItemBgColorSetByUser[_BUTTON_STATUS_NORMAL])
 625                                 {
 626                                         GET_COLOR_CONFIG(FOOTER::TAB_ITEM_BG_NORMAL, __itemBackgroundColor[_BUTTON_STATUS_NORMAL]);
 627                                 }
 628                                 if (!__isItemBgColorSetByUser[_BUTTON_STATUS_DISABLED])
 629                                 {
 630                                         GET_COLOR_CONFIG(FOOTER::TAB_ITEM_BG_DISABLED, __itemBackgroundColor[_BUTTON_STATUS_DISABLED]);
 631                                 }
 632                                 if (!__isItemBgColorSetByUser[_BUTTON_STATUS_PRESSED])
 633                                 {
 634                                         GET_COLOR_CONFIG(FOOTER::TAB_ITEM_BG_PRESSED, __itemBackgroundColor[_BUTTON_STATUS_PRESSED]);
 635                                 }
 636                                 if (!__isItemBgColorSetByUser[_BUTTON_STATUS_HIGHLIGHTED])
 637                                 {
 638                                         GET_COLOR_CONFIG(FOOTER::TAB_ITEM_BG_HIGHLIGHTED, __itemBackgroundColor[_BUTTON_STATUS_HIGHLIGHTED]);
 639                                 }
 640                                 if (!__isItemBgColorSetByUser[_BUTTON_STATUS_SELECTED])
 641                                 {
 642                                         GET_COLOR_CONFIG(FOOTER::TAB_ITEM_BG_SELECTED, __itemBackgroundColor[_BUTTON_STATUS_SELECTED]);
 643                                 }
 644
 645                                 if (!__isItemTextColorSetByUser[_BUTTON_STATUS_NORMAL])
 646                                 {
 647                                         GET_COLOR_CONFIG(FOOTER::TAB_ITEM_TEXT_NORMAL, __itemTextColor[_BUTTON_STATUS_NORMAL]);
 648                                 }
 649                                 if (!__isItemTextColorSetByUser[_BUTTON_STATUS_DISABLED])
 650                                 {
 651                                         GET_COLOR_CONFIG(FOOTER::TAB_ITEM_TEXT_DISABLED, __itemTextColor[_BUTTON_STATUS_DISABLED]);
 652                                 }
 653                                 if (!__isItemTextColorSetByUser[_BUTTON_STATUS_PRESSED])
 654                                 {
 655                                         GET_COLOR_CONFIG(FOOTER::TAB_ITEM_TEXT_PRESSED, __itemTextColor[_BUTTON_STATUS_PRESSED]);
 656                                 }
 657                                 if (!__isItemTextColorSetByUser[_BUTTON_STATUS_HIGHLIGHTED])
 658                                 {
 659                                         GET_COLOR_CONFIG(FOOTER::TAB_ITEM_TEXT_HIGHLIGHTED, __itemTextColor[_BUTTON_STATUS_HIGHLIGHTED]);
 660                                 }
 661                                 if (!__isItemTextColorSetByUser[_BUTTON_STATUS_SELECTED])
 662                                 {
 663                                         GET_COLOR_CONFIG(FOOTER::TAB_ITEM_TEXT_SELECTED, __itemTextColor[_BUTTON_STATUS_SELECTED]);
 664                                 }
 665                         }
 666                         else // TOOLBAR_SEGMENTED
 667                         {
 668                                 if (!__isItemBgColorSetByUser[_BUTTON_STATUS_NORMAL])
 669                                 {
 670                                         GET_COLOR_CONFIG(FOOTER::SEGMENTED_ITEM_BG_NORMAL, __itemBackgroundColor[_BUTTON_STATUS_NORMAL]);
 671                                 }
 672                                 if (!__isItemBgColorSetByUser[_BUTTON_STATUS_DISABLED])
 673                                 {
 674                                         GET_COLOR_CONFIG(FOOTER::SEGMENTED_ITEM_BG_DISABLED, __itemBackgroundColor[_BUTTON_STATUS_DISABLED]);
 675                                 }
 676                                 if (!__isItemBgColorSetByUser[_BUTTON_STATUS_PRESSED])
 677                                 {
 678                                         GET_COLOR_CONFIG(FOOTER::SEGMENTED_ITEM_BG_PRESSED, __itemBackgroundColor[_BUTTON_STATUS_PRESSED]);
 679                                 }
 680                                 if (!__isItemBgColorSetByUser[_BUTTON_STATUS_HIGHLIGHTED])
 681                                 {
 682                                         GET_COLOR_CONFIG(FOOTER::SEGMENTED_ITEM_BG_HIGHLIGHTED, __itemBackgroundColor[_BUTTON_STATUS_HIGHLIGHTED]);
 683                                 }
 684                                 if (!__isItemBgColorSetByUser[_BUTTON_STATUS_SELECTED])
 685                                 {
 686                                         GET_COLOR_CONFIG(FOOTER::SEGMENTED_ITEM_BG_SELECTED, __itemBackgroundColor[_BUTTON_STATUS_SELECTED]);
 687                                 }
 688
 689                                 if (!__isItemTextColorSetByUser[_BUTTON_STATUS_NORMAL])
 690                                 {
 691                                         GET_COLOR_CONFIG(FOOTER::SEGMENTED_ITEM_TEXT_NORMAL, __itemTextColor[_BUTTON_STATUS_NORMAL]);
 692                                 }
 693                                 if (!__isItemTextColorSetByUser[_BUTTON_STATUS_DISABLED])
 694                                 {
 695                                         GET_COLOR_CONFIG(FOOTER::SEGMENTED_ITEM_TEXT_DISABLED, __itemTextColor[_BUTTON_STATUS_DISABLED]);
 696                                 }
 697                                 if (!__isItemTextColorSetByUser[_BUTTON_STATUS_PRESSED])
 698                                 {
 699                                         GET_COLOR_CONFIG(FOOTER::SEGMENTED_ITEM_TEXT_PRESSED, __itemTextColor[_BUTTON_STATUS_PRESSED]);
 700                                 }
 701                                 if (!__isItemTextColorSetByUser[_BUTTON_STATUS_HIGHLIGHTED])
 702                                 {
 703                                         GET_COLOR_CONFIG(FOOTER::SEGMENTED_ITEM_TEXT_HIGHLIGHTED, __itemTextColor[_BUTTON_STATUS_HIGHLIGHTED]);
 704                                 }
 705                                 if (!__isItemTextColorSetByUser[_BUTTON_STATUS_SELECTED])
 706                                 {
 707                                         GET_COLOR_CONFIG(FOOTER::SEGMENTED_ITEM_TEXT_SELECTED, __itemTextColor[_BUTTON_STATUS_SELECTED]);
 708                                 }
 709                         }
 710
 711                         if (!__isButtonBgColorSetByUser[_BUTTON_STATUS_NORMAL])
 712                         {
 713                                 GET_COLOR_CONFIG(FOOTER::BUTTON_BG_NORMAL, __buttonBackgroundColor[_BUTTON_STATUS_NORMAL]);
 714                         }
 715                         if (!__isButtonBgColorSetByUser[_BUTTON_STATUS_DISABLED])
 716                         {
 717                                 GET_COLOR_CONFIG(FOOTER::BUTTON_BG_DISABLED, __buttonBackgroundColor[_BUTTON_STATUS_DISABLED]);
 718                         }
 719                         if (!__isButtonBgColorSetByUser[_BUTTON_STATUS_PRESSED])
 720                         {
 721                                 GET_COLOR_CONFIG(FOOTER::BUTTON_BG_PRESSED, __buttonBackgroundColor[_BUTTON_STATUS_PRESSED]);
 722                         }
 723                         if (!__isButtonBgColorSetByUser[_BUTTON_STATUS_HIGHLIGHTED])
 724                         {
 725                                 GET_COLOR_CONFIG(FOOTER::BUTTON_BG_HIGHLIGHTED, __buttonBackgroundColor[_BUTTON_STATUS_HIGHLIGHTED]);
 726                         }
 727
 728                         if (!__isButtonTextColorSetByUser[_BUTTON_STATUS_NORMAL])
 729                         {
 730                                 GET_COLOR_CONFIG(FOOTER::BUTTON_TEXT_NORMAL, __buttonTextColor[_BUTTON_STATUS_NORMAL]);
 731                         }
 732                         if (!__isButtonTextColorSetByUser[_BUTTON_STATUS_DISABLED])
 733                         {
 734                                 GET_COLOR_CONFIG(FOOTER::BUTTON_TEXT_DISABLED, __buttonTextColor[_BUTTON_STATUS_DISABLED]);
 735                         }
 736                         if (!__isButtonTextColorSetByUser[_BUTTON_STATUS_PRESSED])
 737                         {
 738                                 GET_COLOR_CONFIG(FOOTER::BUTTON_TEXT_PRESSED, __buttonTextColor[_BUTTON_STATUS_PRESSED]);
 739                         }
 740                         if (!__isButtonTextColorSetByUser[_BUTTON_STATUS_HIGHLIGHTED])
 741                         {
 742                                 GET_COLOR_CONFIG(FOOTER::BUTTON_TEXT_HIGHLIGHTED, __buttonTextColor[_BUTTON_STATUS_HIGHLIGHTED]);
 743                         }
 744                 }
 745         }
 746
 747         return E_SUCCESS;
 748 }
 749
 750 result
 751 _Toolbar::InitializeLongPressGesture(void)
 752 {
 753         result r = E_SUCCESS;
 754
 755         __pLongPressGesture = new (std::nothrow) _TouchLongPressGestureDetector();
 756         SysTryReturn(NID_UI_CTRL, __pLongPressGesture, E_OUT_OF_MEMORY, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] Failed to create touch long press gesture.");
 757
 758         __pLongPressGesture->SetDuration(300);
 759
 760         r = AddGestureDetector(*__pLongPressGesture);
 761         SysTryReturn(NID_UI_CTRL, r == E_SUCCESS, r, r, "[%s] Failed to add gesture detector", GetErrorMessage(r));
 762
 763         r = __pLongPressGesture->AddGestureListener(*(dynamic_cast<_ITouchLongPressGestureEventListener*>(this)));
 764         SysTryReturn(NID_UI_CTRL, r == E_SUCCESS, r, r, "[%s] Failed to add gesture listener", GetErrorMessage(r));
 765
 766         return r;
 767 }
 768
 769 result
 770 _Toolbar::InitializeFlickGesture(void)
 771 {
 772         result r = E_SUCCESS;
 773
 774         __pFlickGesture = new (std::nothrow) _TouchFlickGestureDetector();
 775         SysTryReturn(NID_UI_CTRL, __pFlickGesture, E_OUT_OF_MEMORY, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] Failed to create flick gesture.");
 776
 777         r = AddGestureDetector(*__pFlickGesture);
 778         SysTryReturn(NID_UI_CTRL, r == E_SUCCESS, r, r, "[%s] Failed to add gesture detector", GetErrorMessage(r));
 779
 780         r = __pFlickGesture->AddGestureListener(*(dynamic_cast<_ITouchFlickGestureEventListener*>(this)));
 781         SysTryReturn(NID_UI_CTRL, r == E_SUCCESS, r, r, "[%s] Failed to add gesture listener", GetErrorMessage(r));
 782
 783         return r;
 784 }
 785
 786 result
 787 _Toolbar::Construct(void)
 788 {
 789         result r = E_SUCCESS;
 790
 791         return r;
 792 }
 793
 794 result
 795 _Toolbar::AddItem(_Button* pButton)
 796 {
 797         SysTryReturnResult(NID_UI_CTRL, (__itemCount < TAB_ITEM_MAX), E_MAX_EXCEEDED,
 798                                 "[E_MAX_EXCEEDED] The number of items have exceeded the maximum limit.");
 799
 800         if (__pActionEventListener != null)
 801         {
 802                 pButton->AddActionEventListener(*__pActionEventListener);
 803         }
 804
 805         __pItems.push_back(pButton);
 806         __itemCount++;
 807
 808         AttachChild(*pButton);
 809
 810         ApplyUserGUI(TOOLBAR_ITEM, pButton);
 811
 812         RearrangeItems();
 813
 814         AddAccessibilityElement(pButton);
 815
 816         return E_SUCCESS;
 817 }
 818
 819 Bitmap*
 820 _Toolbar::GetBackgroundBitmap(void) const
 821 {
 822         result r = E_SUCCESS;
 823
 824         _Toolbar* pToolbar = const_cast<_Toolbar*>(this);
 825
 826         if (!pToolbar->__pToolbarBackgroundBitmap)
 827         {
 828                 if(__header == true)
 829                 {
 830                         r = GET_BITMAP_CONFIG_N(HEADER::BG_NORMAL, BITMAP_PIXEL_FORMAT_ARGB8888, pToolbar->__pToolbarBackgroundBitmap);
 831                         SysTryReturn(NID_UI_CTRL, r == E_SUCCESS, null, r, "[%s] Propagating.", GetErrorMessage(r));
 832                 }
 833                 else
 834                 {
 835                         r = GET_BITMAP_CONFIG_N(FOOTER::BG_NORMAL, BITMAP_PIXEL_FORMAT_ARGB8888, pToolbar->__pToolbarBackgroundBitmap);
 836                         SysTryReturn(NID_UI_CTRL, r == E_SUCCESS, null, r, "[%s] Propagating.", GetErrorMessage(r));
 837                 }
 838         }
 839
 840         return pToolbar->__pToolbarBackgroundBitmap;
 841 }
 842
 843 _Button*
 844 _Toolbar::GetButton(ToolbarButton position) const
 845 {
 846         SysTryReturn(NID_UI_CTRL, (position >= LEFT_BUTTON && position < BUTTON_MAX), null, E_OUT_OF_RANGE,
 847                                 ("[E_OUT_OF_RANGE] The position is out of range."));
 848
 849         return __pButtonItems[position];
 850 }
 851
 852 _Label*
 853 _Toolbar::GetTitleBadgeIcon(void) const
 854 {
 855         return __pTitleBadgeIcon;
 856 }
 857
 858 Color
 859 _Toolbar::GetButtonColor(_ButtonStatus status) const
 860 {
 861         Variant color;
 862
 863         switch (status)
 864         {
 865         case _BUTTON_STATUS_NORMAL:
 866                 color = GetProperty(L"normalButtonColor");
 867                 break;
 868         case _BUTTON_STATUS_DISABLED:
 869                 color = GetProperty(L"disabledButtonColor");
 870                 break;
 871         case _BUTTON_STATUS_PRESSED:
 872                 color = GetProperty(L"pressedButtonColor");
 873                 break;
 874         case _BUTTON_STATUS_HIGHLIGHTED:
 875                 color = GetProperty(L"highlightedButtonColor");
 876                 break;
 877         default:
 878                 color = GetProperty(L"normalButtonColor");
 879                 break;
 880         }
 881
 882         return color.ToColor();
 883 }
 884
 885 _ButtonStatus
 886 _Toolbar::GetButtonStatus(ToolbarButton position) const
 887 {
 888         return __pButtonItems[position]->GetButtonStatus();
 889 }
 890
 891 Color
 892 _Toolbar::GetButtonTextColor(_ButtonStatus status) const
 893 {
 894         Variant color;
 895
 896         switch (status)
 897         {
 898         case _BUTTON_STATUS_NORMAL:
 899                 color = GetProperty(L"normalButtonTextColor");
 900                 break;
 901         case _BUTTON_STATUS_DISABLED:
 902                 color = GetProperty(L"disabledButtonTextColor");
 903                 break;
 904         case _BUTTON_STATUS_PRESSED:
 905                 color = GetProperty(L"pressedButtonTextColor");
 906                 break;
 907         case _BUTTON_STATUS_HIGHLIGHTED:
 908                 color = GetProperty(L"highlightedButtonTextColor");
 909                 break;
 910         default:
 911                 color = GetProperty(L"normalButtonTextColor");
 912                 break;
 913         }
 914
 915         return color.ToColor();
 916 }
 917
 918 Color
 919 _Toolbar::GetColor(void) const
 920 {
 921         Variant color = GetProperty(L"color");
 922
 923         return color.ToColor();
 924 }
 925
 926 String
 927 _Toolbar::GetDescriptionText(void) const
 928 {
 929         Variant text = GetProperty(L"descriptionText");
 930
 931         return text.ToString();
 932 }
 933
 934 Color
 935 _Toolbar::GetDescriptionTextColor(void) const
 936 {
 937         Variant color = GetProperty(L"descriptionTextColor");
 938
 939         return color.ToColor();
 940 }
 941
 942 int
 943 _Toolbar::GetFirstEnabledItemIndex(void) const
 944 {
 945         int firstEnabledItemIndex = -1;
 946
 947         for (int i = 0; i < __itemCount; i++)
 948         {
 949                 if(__pItems.at(i)->GetButtonStatus() != _BUTTON_STATUS_DISABLED)
 950                 {
 951                         firstEnabledItemIndex = i;
 952                         break;
 953                 }
 954         }
 955
 956         return firstEnabledItemIndex;
 957 }
 958
 959 _Button*
 960 _Toolbar::GetItem(int itemIndex) const
 961 {
 962         if (__pItems.at(itemIndex) == null)
 963         {
 964                 SysLogException(NID_UI_CTRL, E_SYSTEM, "[E_SYSTEM] Unable to get item.");
 965                 return null;
 966         }
 967
 968         return __pItems.at(itemIndex);
 969 }
 970
 971 Color
 972 _Toolbar::GetItemColor(_ButtonStatus status) const
 973 {
 974         Variant color;
 975
 976         switch (status)
 977         {
 978         case _BUTTON_STATUS_NORMAL:
 979                 color = GetProperty(L"normalItemColor");
 980                 break;
 981         case _BUTTON_STATUS_DISABLED:
 982                 color = GetProperty(L"disabledItemColor");
 983                 break;
 984         case _BUTTON_STATUS_PRESSED:
 985                 color = GetProperty(L"pressedItemColor");
 986                 break;
 987         case _BUTTON_STATUS_HIGHLIGHTED:
 988                 color = GetProperty(L"highlightedItemColor");
 989                 break;
 990         case _BUTTON_STATUS_SELECTED:
 991                 color = GetProperty(L"selectedItemColor");
 992                 break;
 993         default:
 994                 color = GetProperty(L"normalItemColor");
 995                 break;
 996         }
 997
 998         return color.ToColor();
 999 }
1000
1001 int
1002 _Toolbar::GetItemCount(void) const
1003 {
1004         return __itemCount;
1005 }
1006
1007 int
1008 _Toolbar::GetItemIndexFromPosition(const FloatPoint& point) const
1009 {
1010         if (__itemCount <= 0)
1011         {
1012                 return -1;
1013         }
1014
1015         for (int i = 0; i < __itemCount; i++)
1016         {
1017                 FloatRectangle bounds = __pItems.at(i)->GetBoundsF();
1018
1019                 if (bounds.Contains(point) && __pItems.at(i)->GetVisibleState() == true)
1020                 {
1021                         return i;
1022                 }
1023         }
1024
1025         return -1;
1026 }
1027
1028 result
1029 _Toolbar::GetItemStatus(int itemIndex, _ButtonStatus& status) const
1030 {
1031         status = _BUTTON_STATUS_NORMAL;
1032
1033         SysTryReturnResult(NID_UI_CTRL, (itemIndex >= 0 && itemIndex <= __itemCount), E_OUT_OF_RANGE,
1034                                 "[E_OUT_OF_RANGE] The itemIndex is out of range.");
1035
1036         status = __pItems.at(itemIndex)->GetButtonStatus();
1037
1038         return E_SUCCESS;
1039 }
1040
1041 Color
1042 _Toolbar::GetItemTextColor(_ButtonStatus status) const
1043 {
1044         Variant color;
1045
1046         switch (status)
1047         {
1048         case _BUTTON_STATUS_NORMAL:
1049                 color = GetProperty(L"normalItemTextColor");
1050                 break;
1051         case _BUTTON_STATUS_DISABLED:
1052                 color = GetProperty(L"disabledItemTextColor");
1053                 break;
1054         case _BUTTON_STATUS_PRESSED:
1055                 color = GetProperty(L"pressedItemTextColor");
1056                 break;
1057         case _BUTTON_STATUS_HIGHLIGHTED:
1058                 color = GetProperty(L"highlightedItemTextColor");
1059                 break;
1060         case _BUTTON_STATUS_SELECTED:
1061                 color = GetProperty(L"selectedItemTextColor");
1062                 break;
1063         default:
1064                 color = GetProperty(L"normalItemTextColor");
1065                 break;
1066         }
1067
1068         return color.ToColor();
1069 }
1070
1071 int
1072 _Toolbar::GetSelectedItemIndex(void) const
1073 {
1074         return __pToolbarPresenter->GetSelectedItemIndex();
1075 }
1076
1077 ToolbarStyle
1078 _Toolbar::GetStyle(void) const
1079 {
1080         return ToolbarStyle(__style);
1081 }
1082
1083 Bitmap*
1084 _Toolbar::GetTitleIcon(void) const
1085 {
1086         return __pTitleIcon;
1087 }
1088
1089 String
1090 _Toolbar::GetTitleText(void) const
1091 {
1092         Variant text = GetProperty(L"titleText");
1093         return text.ToString();
1094 }
1095
1096 Color
1097 _Toolbar::GetTitleTextColor(void) const
1098 {
1099         Variant color = GetProperty(L"titleTextColor");
1100         return color.ToColor();
1101 }
1102
1103 HorizontalAlignment
1104 _Toolbar::GetTitleTextHorizontalAlignment(void) const
1105 {
1106         return __titleTextAlignment;
1107 }
1108
1109 bool
1110 _Toolbar::IsInitialDraw(void) const
1111 {
1112         return __pToolbarPresenter->IsInitialDraw();
1113 }
1114
1115 bool
1116 _Toolbar::IsTabEditModeEnabled(void) const
1117 {
1118         return __pToolbarPresenter->IsTabEditModeEnabled();
1119 }
1120
1121 bool
1122 _Toolbar::IsTransparent(void) const
1123 {
1124         return __transparent;
1125 }
1126
1127
1128 AnimationStatus
1129 _Toolbar::GetWaitingAnimationStatus(ToolbarAnimationPosition animationPos) const
1130 {
1131         if (animationPos < TOOLBAR_ANIMATION_POSITION_TITLE || animationPos >= TOOLBAR_ANIMATION_POSITION_MAX)
1132         {
1133                 return ANIMATION_STOPPED;
1134         }
1135
1136         if (__pAnimation[animationPos] == null)
1137         {
1138                 return ANIMATION_STOPPED;
1139         }
1140
1141         return __pAnimation[animationPos]->GetStatus();
1142 }
1143
1144 result
1145 _Toolbar::InsertItemAt(int itemIndex, _Button* pButton)
1146 {
1147         SysTryReturnResult(NID_UI_CTRL, (itemIndex >= 0 && itemIndex <= __itemCount), E_OUT_OF_RANGE,
1148                                 "[E_OUT_OF_RANGE] The itemIndex is out of range.");
1149
1150         if (__pActionEventListener != null)
1151         {
1152                 pButton->AddActionEventListener(*__pActionEventListener);
1153         }
1154
1155         __pItems.insert(__pItems.begin() + itemIndex, pButton);
1156         __itemCount++;
1157
1158         AttachChild(*pButton);
1159
1160         ApplyUserGUI(TOOLBAR_ITEM, pButton);
1161
1162         RearrangeItems();
1163
1164         AddAccessibilityElement(pButton);
1165
1166         return E_SUCCESS;
1167 }
1168
1169 bool
1170 _Toolbar::IsButtonSet(ToolbarButton position) const
1171 {
1172         if (__pButtonItems[position] != null)
1173         {
1174                 return true;
1175         }
1176
1177         return false;
1178 }
1179
1180 result
1181 _Toolbar::MoveItem(const int srcIndex, const int destIndex)
1182 {
1183         if (srcIndex == destIndex)
1184         {
1185                 SetItemSelected(destIndex, true);
1186
1187                 return E_SUCCESS;
1188         }
1189
1190         if (srcIndex < 0 || destIndex < 0 || srcIndex > __itemCount || destIndex > __itemCount)
1191         {
1192                 return E_INVALID_OPERATION;
1193         }
1194
1195         _Button* pSrcButton = null;
1196         pSrcButton = GetItem(srcIndex);
1197
1198         _Button* pDestButton = null;
1199         pDestButton = GetItem(destIndex);
1200
1201         __pItems.erase(__pItems.begin() + destIndex);
1202         __pItems.insert(__pItems.begin() + destIndex, pSrcButton);
1203
1204         __pItems.erase(__pItems.begin() + srcIndex);
1205         __pItems.insert(__pItems.begin() + srcIndex, pDestButton);
1206
1207         for (int i = 0; i < __itemCount; i++)
1208         {
1209                 __pItems.at(i)->SetButtonStatus(_BUTTON_STATUS_NORMAL);
1210                 _AccessibilityElement* pElement = __pItems.at(i)->GetAccessibilityContainer()->GetChildElement(0);
1211                 if (pElement)
1212                 {
1213                         pElement->SetStatus(L"");
1214                         pElement->SetHintDisabled(false);
1215                 }
1216         }
1217
1218         SetItemSelected(destIndex, true);
1219
1220         RearrangeItems();
1221
1222         Invalidate(true);
1223
1224         return E_SUCCESS;
1225 }
1226
1227 result
1228 _Toolbar::PauseWaitingAnimation(ToolbarAnimationPosition animationPos)
1229 {
1230         SysTryReturnResult(NID_UI_CTRL,
1231                         (TOOLBAR_ANIMATION_POSITION_TITLE <= animationPos && animationPos < TOOLBAR_ANIMATION_POSITION_MAX), E_INVALID_ARG,
1232                         "[E_INVALID_ARG] The animationPos is invalid.");
1233         SysTryReturnResult(NID_UI_CTRL, (__pAnimation[animationPos]), E_INVALID_STATE,
1234                         "[E_INVALID_STATE] __pAnimation isn't constructed.");
1235
1236         __pAnimation[animationPos]->Pause();
1237
1238         return E_SUCCESS;
1239 }
1240
1241 result
1242 _Toolbar::PlayWaitingAnimation(ToolbarAnimationPosition animationPos)
1243 {
1244         SysTryReturnResult(NID_UI_CTRL,
1245                         (TOOLBAR_ANIMATION_POSITION_TITLE <= animationPos && animationPos < TOOLBAR_ANIMATION_POSITION_MAX), E_INVALID_ARG,
1246                         "[E_INVALID_ARG] The animationPos is invalid.");
1247
1248         if ((animationPos == TOOLBAR_ANIMATION_POSITION_TITLE && __style != TOOLBAR_TITLE)
1249                         || (animationPos == TOOLBAR_ANIMATION_POSITION_BUTTON_LEFT && __pButtonItems[LEFT_BUTTON] == null)
1250                         ||  (animationPos == TOOLBAR_ANIMATION_POSITION_BUTTON_RIGHT && __pButtonItems[RIGHT_BUTTON] == null))
1251         {
1252                 return E_UNSUPPORTED_OPERATION;
1253         }
1254
1255         if (__pAnimation[animationPos])
1256         {
1257                 if (__pAnimation[animationPos]->GetStatus() == ANIMATION_PLAYING)
1258                 {
1259                         return E_SUCCESS;
1260                 }
1261         }
1262         else
1263         {
1264                 SetAnimation(animationPos);
1265         }
1266
1267         if (__pAnimation[animationPos])
1268         {
1269                 __pAnimation[animationPos]->Play();
1270         }
1271
1272         return E_SUCCESS;
1273 }
1274
1275 result
1276 _Toolbar::RemoveAllButtons(void)
1277 {
1278         for (int i = 0; i < BUTTON_MAX; i++)
1279         {
1280                 _Button* pButtonItem = __pButtonItems[i];
1281
1282                 if (pButtonItem != null)
1283                 {
1284                          if (i == LEFT_BUTTON)
1285                         {
1286                                  StopWaitingAnimation(TOOLBAR_ANIMATION_POSITION_BUTTON_LEFT);
1287                         }
1288                         else if (i == RIGHT_BUTTON)
1289                         {
1290                                 StopWaitingAnimation(TOOLBAR_ANIMATION_POSITION_BUTTON_RIGHT);
1291                         }
1292
1293                         if (pButtonItem->GetChildCount() != 0)
1294                         {
1295                                 _Label* pTempBadgeIcon = dynamic_cast<_Label*>(pButtonItem->GetChild(0));
1296                                 SysTryReturnResult(NID_UI_CTRL, pTempBadgeIcon, E_INVALID_STATE, "[E_INVALID_STATE] Couldn't get a badge icon.");
1297
1298                                 pButtonItem->DetachChild(*pTempBadgeIcon);
1299
1300                                 delete pTempBadgeIcon;
1301                                 pTempBadgeIcon = null;
1302                         }
1303
1304                         DetachChild(*pButtonItem);
1305                         delete pButtonItem;
1306                         pButtonItem = null;
1307
1308                         __pButtonItems[i] = null;
1309                 }
1310         }
1311
1312         return E_SUCCESS;
1313 }
1314
1315 result
1316 _Toolbar::RemoveAllItems(void)
1317 {
1318         __itemCount = 0;
1319
1320         int itemCount = __pItems.size();
1321
1322         _Button* pItem = null;
1323
1324         // frees item nodes from the memory
1325         if (itemCount > 0)
1326         {
1327                 for (int i = itemCount - 1; i >= 0; i--)
1328                 {
1329                         pItem = __pItems.at(i);
1330
1331                         if (pItem != null)
1332                         {
1333                                 if (pItem->GetChildCount() != 0)
1334                                 {
1335                                         _Label* pTempBadgeIcon = dynamic_cast<_Label*>(pItem->GetChild(0));
1336                                         SysTryReturnResult(NID_UI_CTRL, pTempBadgeIcon, E_INVALID_STATE, "[E_INVALID_STATE] Couldn't get a badge icon.");
1337
1338                                         pItem->DetachChild(*pTempBadgeIcon);
1339
1340                                         delete pTempBadgeIcon;
1341                                         pTempBadgeIcon = null;
1342                                 }
1343
1344                                 DetachChild(*pItem);
1345                                 delete pItem;
1346
1347                                 pItem = null;
1348                         }
1349                 }
1350         }
1351
1352         // clears vector
1353         __pItems.clear();
1354
1355         __pToolbarPresenter->SetInitialDrawState(true);
1356
1357         SetItemSelected(-1);
1358
1359         return E_SUCCESS;
1360 }
1361
1362 result
1363 _Toolbar::RemoveButtonAt(ToolbarButton position)
1364 {
1365         if (__pButtonItems[position] != null)
1366         {
1367                 if (position == LEFT_BUTTON)
1368                 {
1369                         StopWaitingAnimation(TOOLBAR_ANIMATION_POSITION_BUTTON_LEFT);
1370                 }
1371                 else if (position == RIGHT_BUTTON)
1372                 {
1373                         StopWaitingAnimation(TOOLBAR_ANIMATION_POSITION_BUTTON_RIGHT);
1374                 }
1375
1376                 DetachChild(*__pButtonItems[position]);
1377                 delete __pButtonItems[position];
1378                 __pButtonItems[position] = null;
1379         }
1380
1381         return E_SUCCESS;
1382 }
1383
1384 result
1385 _Toolbar::RemoveItemAt(int itemIndex)
1386 {
1387         SysTryReturnResult(NID_UI_CTRL, (__itemCount > 0 && itemIndex < __itemCount && itemIndex >= 0), E_INVALID_ARG,
1388                                 "[E_INVALID_ARG] itemIndex is invalid.");
1389
1390         _Button* pItem = __pItems.at(itemIndex);
1391
1392         SysTryReturnResult(NID_UI_CTRL, (pItem != null), E_INVALID_STATE, "[E_INVALID_ARG] No item at the designated index.");
1393
1394         if (pItem->GetChildCount() != 0)
1395         {
1396                 _Label* pTempBadgeIcon = dynamic_cast<_Label*>(pItem->GetChild(0));
1397                 SysTryReturnResult(NID_UI_CTRL, pTempBadgeIcon, E_INVALID_STATE, "[E_INVALID_STATE] Couldn't get a badge icon.");
1398
1399                 pItem->DetachChild(*pTempBadgeIcon);
1400
1401                 delete pTempBadgeIcon;
1402                 pTempBadgeIcon = null;
1403         }
1404
1405         // Free 'pItem' from the item nodes
1406         DetachChild(*pItem);
1407         delete pItem;
1408         pItem = null;
1409
1410         __itemCount--;
1411
1412         __pItems.erase(__pItems.begin() + itemIndex);
1413
1414         return E_SUCCESS;
1415 }
1416
1417 result
1418 _Toolbar::SetBackgroundBitmap(const Bitmap& bitmap)
1419 {
1420         result r = E_SYSTEM;
1421
1422         Bitmap* pClonedBitmap = _BitmapImpl::CloneN(bitmap);
1423
1424         if (pClonedBitmap)
1425         {
1426                 if (__pToolbarBackgroundBitmap)
1427                 {
1428                         delete __pToolbarBackgroundBitmap;
1429                 }
1430
1431                 __pToolbarBackgroundBitmap = pClonedBitmap;
1432                 __isUserBackgroundBitmap = true;
1433
1434                 r = E_SUCCESS;
1435         }
1436
1437         return r;
1438 }
1439
1440 bool
1441 _Toolbar::IsUserBackgroundBitmap() const
1442 {
1443         return __isUserBackgroundBitmap;
1444 }
1445
1446 result
1447 _Toolbar::SetButton(ToolbarButton position, _Button* pButton)
1448 {
1449         SysTryReturnResult(NID_UI_CTRL, (pButton), E_INVALID_ARG, "[E_INVALID_ARG] The pButton is invalid.");
1450
1451         float buttonWidth = pButton->GetSizeF().width;
1452
1453         float toolbarWidth = GetBoundsF().width;
1454
1455         if (CalculateMinimumToolbarWidth() > toolbarWidth)
1456         {
1457                 toolbarWidth = CalculateMinimumToolbarWidth();
1458         }
1459
1460         float horizontalMargin = 0.0f;
1461         float verticalMargin = 0.0f;
1462
1463         if (__header == true && __style != TOOLBAR_TEXT)
1464         {
1465                 float buttonItemGap = 0.0f;
1466                 float buttonTopMargin = 0.0f;
1467
1468                 GET_SHAPE_CONFIG(HEADER::BUTTON_ITEM_TOP_MARGIN, GetOrientation(), buttonTopMargin);
1469                 GET_SHAPE_CONFIG(HEADER::BUTTON_ITEM_GAP, GetOrientation(), buttonItemGap);
1470
1471                 switch (position)
1472                 {
1473                 case RIGHT_BUTTON:
1474                         if (__pButtonItems[LEFT_BUTTON])
1475                         {
1476                                 pButton->SetPosition(FloatPoint(toolbarWidth - buttonWidth , buttonTopMargin));
1477                                 __pButtonItems[LEFT_BUTTON]->SetPosition(FloatPoint(toolbarWidth - buttonWidth *2 - buttonItemGap, buttonTopMargin));
1478                         }
1479                         else
1480                         {
1481                                 pButton->SetPosition(FloatPoint(toolbarWidth - buttonWidth , buttonTopMargin));
1482                         }
1483                         break;
1484                 case LEFT_BUTTON:
1485                         if (__pButtonItems[RIGHT_BUTTON])
1486                         {
1487                                 pButton->SetPosition(FloatPoint(toolbarWidth - buttonWidth * 2 - buttonItemGap, buttonTopMargin));
1488                         }
1489                         else
1490                         {
1491                                 pButton->SetPosition(FloatPoint(toolbarWidth - buttonWidth, buttonTopMargin));
1492                         }
1493                         break;
1494
1495                 default:
1496                         break;
1497                 }
1498         }
1499         else // footer or HEADER_STYLE_BUTTON
1500         {
1501                 switch (position)
1502                 {
1503                         case LEFT_BUTTON:
1504                                 pButton->SetPosition(FloatPoint(horizontalMargin, verticalMargin));
1505                                 break;
1506
1507                         case RIGHT_BUTTON:
1508                                 pButton->SetPosition(FloatPoint(toolbarWidth - buttonWidth - horizontalMargin, verticalMargin));
1509                                 break;
1510
1511                         case BACK_BUTTON:
1512                                 pButton->SetPosition(FloatPoint(toolbarWidth - buttonWidth, 0.0f));
1513                                 if (__pBackEventListener)
1514                                 {
1515                                         pButton->AddActionEventListener(*__pBackEventListener);
1516                                         pButton->SetActionId(__backActionId);
1517                                 }
1518                                 break;
1519
1520                         case MIDDLE_BUTTON:
1521                                 pButton->SetPosition(FloatPoint((toolbarWidth - buttonWidth - horizontalMargin)/2, verticalMargin));
1522                                 break;
1523
1524                         default:
1525                                 break;
1526                 }
1527         }
1528
1529         if (position != BACK_BUTTON && __pActionEventListener != null)
1530         {
1531                 pButton->AddActionEventListener(*__pActionEventListener);
1532         }
1533
1534         if (__pButtonItems[position])
1535         {
1536                 if (position == LEFT_BUTTON)
1537                 {
1538                         StopWaitingAnimation(TOOLBAR_ANIMATION_POSITION_BUTTON_LEFT);
1539                 }
1540                 else if (position == RIGHT_BUTTON)
1541                 {
1542                         StopWaitingAnimation(TOOLBAR_ANIMATION_POSITION_BUTTON_RIGHT);
1543                 }
1544
1545                 if (__pButtonItems[position]->GetChildCount() != 0)
1546                 {
1547                         _Label* pTempBadgeIcon = dynamic_cast<_Label*>(__pButtonItems[position]->GetChild(0));
1548                         SysTryReturnResult(NID_UI_CTRL, pTempBadgeIcon, E_INVALID_STATE, "[E_INVALID_STATE] Couldn't get a badge icon.");
1549
1550                         __pButtonItems[position]->DetachChild(*pTempBadgeIcon);
1551
1552                         delete pTempBadgeIcon;
1553                         pTempBadgeIcon = null;
1554                 }
1555
1556                 DetachChild(*__pButtonItems[position]);
1557
1558                 delete __pButtonItems[position];
1559                 __pButtonItems[position] = null;
1560         }
1561
1562         __pButtonItems[position] = pButton;
1563
1564         AttachChild(*pButton);
1565
1566         if (__style != TOOLBAR_SOFTKEY)
1567         {
1568                 ApplyUserGUI(TOOLBAR_BUTTON, __pButtonItems[position]);
1569         }
1570
1571         RearrangeItems();
1572         AddAccessibilityElement(position, pButton);
1573         return E_SUCCESS;
1574 }
1575
1576 result
1577 _Toolbar::SetButtonColor(_ButtonStatus status, const Color& color)
1578 {
1579         switch (status)
1580         {
1581         case _BUTTON_STATUS_NORMAL:
1582                 __isButtonBgColorSetByUser[_BUTTON_STATUS_NORMAL] = true;
1583                 return SetProperty(L"normalButtonColor", Variant(color));
1584                 break;
1585         case _BUTTON_STATUS_DISABLED:
1586                 __isButtonBgColorSetByUser[_BUTTON_STATUS_DISABLED] = true;
1587                 return SetProperty(L"disabledButtonColor", Variant(color));
1588                 break;
1589         case _BUTTON_STATUS_PRESSED:
1590                 __isButtonBgColorSetByUser[_BUTTON_STATUS_PRESSED] = true;
1591                 return SetProperty(L"pressedButtonColor", Variant(color));
1592                 break;
1593         case _BUTTON_STATUS_HIGHLIGHTED:
1594                 __isButtonBgColorSetByUser[_BUTTON_STATUS_HIGHLIGHTED] = true;
1595                 return SetProperty(L"highlightedButtonColor", Variant(color));
1596                 break;
1597         default:
1598                 __isButtonBgColorSetByUser[_BUTTON_STATUS_NORMAL] = true;
1599                 return SetProperty(L"normalButtonColor", Variant(color));
1600                 break;
1601         }
1602 }
1603
1604 result
1605 _Toolbar::SetButtonEnabled(ToolbarButton position, bool enabled)
1606 {
1607         SysTryReturnResult(NID_UI_CTRL, __pButtonItems[position], E_INVALID_OPERATION,
1608                                 "[E_INVALID_OPERATION] No button item is at the position.");
1609
1610         if (enabled)
1611         {
1612                 __pButtonItems[position]->SetButtonStatus(_BUTTON_STATUS_NORMAL);
1613                 _AccessibilityElement* pElement = __pButtonItems[position]->GetAccessibilityContainer()->GetChildElement(0);
1614                 if (pElement)
1615                 {
1616                         pElement->SetStatus(L"");
1617                         pElement->SetHintDisabled(false);
1618                 }
1619         }
1620         else
1621         {
1622                 __pButtonItems[position]->SetButtonStatus(_BUTTON_STATUS_DISABLED);
1623                 _AccessibilityElement* pElement = __pButtonItems[position]->GetAccessibilityContainer()->GetChildElement(0);
1624                 if (pElement)
1625                 {
1626                         pElement->SetStatus(L"");
1627                         pElement->SetHintDisabled(false);
1628                 }
1629         }
1630
1631         return E_SUCCESS;
1632 }
1633
1634 result
1635 _Toolbar::SetButtonTextColor(_ButtonStatus status, const Color& color)
1636 {
1637         switch (status)
1638         {
1639         case _BUTTON_STATUS_NORMAL:
1640                 __isButtonTextColorSetByUser[_BUTTON_STATUS_NORMAL] = true;
1641                 return SetProperty(L"normalButtonTextColor", Variant(color));
1642                 break;
1643         case _BUTTON_STATUS_DISABLED:
1644                 __isButtonTextColorSetByUser[_BUTTON_STATUS_DISABLED] = true;
1645                 return SetProperty(L"disabledButtonTextColor", Variant(color));
1646                 break;
1647         case _BUTTON_STATUS_PRESSED:
1648                 __isButtonTextColorSetByUser[_BUTTON_STATUS_PRESSED] = true;
1649                 return SetProperty(L"pressedButtonTextColor", Variant(color));
1650                 break;
1651         case _BUTTON_STATUS_HIGHLIGHTED:
1652                 __isButtonTextColorSetByUser[_BUTTON_STATUS_HIGHLIGHTED] = true;
1653                 return SetProperty(L"highlightedButtonTextColor", Variant(color));
1654                 break;
1655         default:
1656                 __isButtonTextColorSetByUser[_BUTTON_STATUS_NORMAL] = true;
1657                 return SetProperty(L"normalButtonTextColor", Variant(color));
1658                 break;
1659         }
1660 }
1661
1662 result
1663 _Toolbar::SetButtonBadgeIcon(ToolbarButton position, const Bitmap* pBadgeIcon)
1664 {
1665         int childCount = 0;
1666
1667         childCount = __pButtonItems[position]->GetChildCount();
1668
1669         if (childCount != 0)
1670         {
1671                 for(int i = 0; i < childCount; i++)
1672                 {
1673                         _Label* pTempBadgeIcon = dynamic_cast<_Label*>(__pButtonItems[position]->GetChild(i));
1674
1675                         if (pTempBadgeIcon)
1676                         {
1677                                 __pButtonItems[position]->DetachChild(*pTempBadgeIcon);
1678
1679                                 delete pTempBadgeIcon;
1680                                 pTempBadgeIcon = null;
1681                         }
1682                 }
1683         }
1684
1685         if (pBadgeIcon == null)
1686         {
1687                 return E_SUCCESS;
1688         }
1689
1690         FloatRectangle bounds = __pButtonItems[position]->GetBoundsF();
1691
1692         float topTouchMargin = __pButtonItems[position]->GetTopTouchMarginF();
1693         float rightTouchMargin = __pButtonItems[position]->GetRightTouchMarginF();
1694
1695         bounds.y = bounds.y + topTouchMargin;
1696         bounds.width = bounds.width - rightTouchMargin;
1697
1698         float height = 0.0f;
1699
1700         GET_SHAPE_CONFIG(HEADER::BADGE_HEIGHT_WITH_BUTTON, GetOrientation(), height);
1701
1702         _Label* pBadgeIconLabel = _Label::CreateLabelN();
1703
1704         if (pBadgeIconLabel)
1705         {
1706                 pBadgeIconLabel->SetBounds(FloatRectangle(bounds.width - height, bounds.y, height, height));
1707                 pBadgeIconLabel->SetBackgroundBitmap(*pBadgeIcon);
1708
1709                 __pButtonItems[position]->AttachChild(*pBadgeIconLabel);
1710                 __pButtonItems[position]->SetChildAlwaysOnTop(*pBadgeIconLabel);
1711         }
1712
1713         return E_SUCCESS;
1714 }
1715
1716 result
1717 _Toolbar::SetButtonNumberedBadgeIcon(ToolbarButton position, int number)
1718 {
1719         int childCount = 0;
1720
1721         childCount = __pButtonItems[position]->GetChildCount();
1722
1723         _Label* existingBadgeIcon = null;
1724
1725         if (number == 0)
1726         {
1727                 if (childCount != 0)
1728                 {
1729                         for(int i = 0; i < childCount; i++)
1730                         {
1731                                 existingBadgeIcon = dynamic_cast<_Label*>(__pButtonItems[position]->GetChild(i));
1732
1733                                 if (existingBadgeIcon)
1734                                 {
1735                                         __pButtonItems[position]->DetachChild(*existingBadgeIcon);
1736
1737                                         delete existingBadgeIcon;
1738                                         existingBadgeIcon = null;
1739                                 }
1740                         }
1741                 }
1742                 else
1743                 {
1744                         return E_SUCCESS;
1745                 }
1746         }
1747         else
1748         {
1749                 bool needToCreateNewIcon = true;
1750
1751                 if (childCount != 0)
1752                 {
1753                         for(int i = 0; i < childCount; i++)
1754                         {
1755                                 existingBadgeIcon = dynamic_cast<_Label*>(__pButtonItems[position]->GetChild(i));
1756
1757                                 if (existingBadgeIcon)
1758                                 {
1759                                         if (existingBadgeIcon->GetText() == L"")
1760                                         {
1761                                                 __pButtonItems[position]->DetachChild(*existingBadgeIcon);
1762
1763                                                 delete existingBadgeIcon;
1764                                                 existingBadgeIcon = null;
1765
1766                                                 needToCreateNewIcon = true;
1767                                         }
1768                                         else
1769                                         {
1770                                                 needToCreateNewIcon = false;
1771                                         }
1772                                 }
1773                         }
1774                 }
1775
1776                 if (needToCreateNewIcon)
1777                 {
1778                         _Label* pLabel = _Label::CreateLabelN();
1779
1780                         SysTryReturnResult(NID_UI_CTRL, pLabel, E_INVALID_STATE,
1781                                                 "[E_INVALID_STATE] The badge icon instance isn't constructed.");
1782
1783                         Bitmap* pNumberedBadgeIconBitmap = null;
1784                         Bitmap* pNumberedBadgeIconEffectBitmap = null;
1785                         Bitmap* pColorReplacedBitmap = null;
1786                         Color badgeIconBgColor;
1787                         Color badgeIconTextColor;
1788
1789                         GET_BITMAP_CONFIG_N(HEADER::BADGE_ICON_BG_NORMAL, BITMAP_PIXEL_FORMAT_ARGB8888, pNumberedBadgeIconBitmap);
1790
1791                         bool themeBadgeNormalBackgroundBitmap = IS_CUSTOM_BITMAP(HEADER::BADGE_ICON_BG_NORMAL);
1792                         if (!themeBadgeNormalBackgroundBitmap)
1793                         {
1794                                 GET_BITMAP_CONFIG_N(HEADER::BADGE_ICON_BG_EFFECT_NORMAL, BITMAP_PIXEL_FORMAT_ARGB8888, pNumberedBadgeIconEffectBitmap);
1795                         }
1796
1797                         GET_COLOR_CONFIG(HEADER::BADGE_ICON_BG_NORMAL, badgeIconBgColor);
1798                         GET_COLOR_CONFIG(HEADER::BADGE_ICON_TEXT_NORMAL, badgeIconTextColor);
1799
1800                         if (pNumberedBadgeIconBitmap)
1801                         {
1802                                 pColorReplacedBitmap = _BitmapImpl::GetColorReplacedBitmapN(*pNumberedBadgeIconBitmap,
1803                                                 Color::GetColor(COLOR_ID_MAGENTA), badgeIconBgColor);
1804
1805                                 pLabel->SetBackgroundBitmap(*pColorReplacedBitmap);
1806
1807                                 delete pColorReplacedBitmap;
1808                                 delete pNumberedBadgeIconBitmap;
1809                         }
1810
1811                         if (pNumberedBadgeIconEffectBitmap)
1812                         {
1813                                 pLabel->SetBackgroundEffectBitmap(*pNumberedBadgeIconEffectBitmap);
1814
1815                                 delete pNumberedBadgeIconEffectBitmap;
1816                         }
1817
1818                         pLabel->SetTextHorizontalAlignment(ALIGNMENT_CENTER);
1819                         pLabel->SetTextVerticalAlignment(ALIGNMENT_MIDDLE);
1820                         pLabel->SetTextColor(badgeIconTextColor);
1821                         pLabel->SetMargin(10, 0, 5, 0);
1822
1823                         __pButtonItems[position]->AttachChild(*pLabel);
1824                         __pButtonItems[position]->SetChildAlwaysOnTop(*pLabel);
1825
1826                         existingBadgeIcon = pLabel;
1827                 }
1828
1829                 SysTryReturnResult(NID_UI_CTRL, (existingBadgeIcon), E_INVALID_STATE, "[E_INVALID_STATE] Failed to set a BadgeIcon.");
1830
1831                 FloatRectangle bounds = __pButtonItems[position]->GetBoundsF();
1832
1833                 float topTouchMargin = __pButtonItems[position]->GetTopTouchMarginF();
1834                 float rightTouchMargin = __pButtonItems[position]->GetRightTouchMarginF();
1835
1836                 bounds.y = bounds.y + topTouchMargin;
1837                 bounds.width = bounds.width - rightTouchMargin;
1838
1839                 if (existingBadgeIcon)
1840                 {
1841                         float fontSize = 0.0f;
1842                         float height = 0.0f;
1843                         float width = 0.0f;
1844
1845                         GET_SHAPE_CONFIG(HEADER::BADGE_HEIGHT_WITH_BUTTON, GetOrientation(), height);
1846
1847                         if (number < 10)
1848                         {
1849                                 GET_SHAPE_CONFIG(HEADER::BADGE_FONT_SIZE_WITH_BUTTON, GetOrientation(), fontSize);
1850                                 GET_SHAPE_CONFIG(HEADER::BADGE_WIDTH_1DIGIT, GetOrientation(), width);
1851                         }
1852                         else if (number < 100)
1853                         {
1854                                 GET_SHAPE_CONFIG(HEADER::BADGE_FONT_SIZE_WITH_BUTTON, GetOrientation(), fontSize);
1855                                 GET_SHAPE_CONFIG(HEADER::BADGE_WIDTH_1DIGIT, GetOrientation(), width);
1856                         }
1857                         else if (number < 1000)
1858                         {
1859                                 GET_SHAPE_CONFIG(HEADER::BADGE_FONT_SIZE_WITH_BUTTON, GetOrientation(), fontSize);
1860                                 GET_SHAPE_CONFIG(HEADER::BADGE_WIDTH_2DIGIT, GetOrientation(), width);
1861                         }
1862                         else if (number < 10000)
1863                         {
1864                                 GET_SHAPE_CONFIG(HEADER::BADGE_FONT_SIZE_WITH_BUTTON, GetOrientation(), fontSize);
1865                                 GET_SHAPE_CONFIG(HEADER::BADGE_WIDTH_2DIGIT, GetOrientation(), width);
1866                         }
1867                         else
1868                         {
1869                                 GET_SHAPE_CONFIG(HEADER::BADGE_FONT_SIZE_WITH_BUTTON_2, GetOrientation(), fontSize);
1870                                 GET_SHAPE_CONFIG(HEADER::BADGE_WIDTH_2DIGIT, GetOrientation(), width);
1871                         }
1872
1873                         existingBadgeIcon->SetBounds(FloatRectangle(bounds.width - width, bounds.y, width, height));
1874                         existingBadgeIcon->SetTextConfig(fontSize, LABEL_TEXT_STYLE_NORMAL);
1875
1876                         Integer tempNumber(number);
1877                         existingBadgeIcon->SetText(tempNumber.ToString());
1878                 }
1879         }
1880
1881         return E_SUCCESS;
1882 }
1883
1884 result
1885 _Toolbar::SetColor(const Color& color)
1886 {
1887         return SetProperty(L"color", Variant(color));
1888 }
1889
1890 result
1891 _Toolbar::SetDescriptionText(const String& text)
1892 {
1893         return SetProperty(L"descriptionText", Variant(text));
1894 }
1895
1896 result
1897 _Toolbar::SetDescriptionTextColor(const Color& color)
1898 {
1899         return SetProperty(L"descriptionTextColor", Variant(color));
1900 }
1901
1902 result
1903 _Toolbar::SetItemAt(int itemIndex, const _Button* pButton)
1904 {
1905         SysTryReturnResult(NID_UI_CTRL, (itemIndex >= 0 && itemIndex < __itemCount), E_OUT_OF_RANGE,
1906                                 "[E_OUT_OF_RANGE] The itemIndex is out of range.");
1907
1908         if (pButton->GetActionId() < TOOLBAR_ACTION_ID_MIN || pButton->GetActionId() > TOOLBAR_ACTION_ID_MAX)
1909         {
1910                 SysLog(NID_UI_CTRL, "[E_INVALID_ARG] The actionId is invalid.");
1911                 return E_OUT_OF_RANGE;
1912         }
1913
1914         SysTryReturnResult(NID_UI_CTRL, (null != __pItems.at(itemIndex)), E_INVALID_OPERATION,
1915                                 "[E_INVALID_OPERATION] No button item is at the position.");
1916
1917         if (__pItems.at(itemIndex)->GetChildCount() != 0)
1918         {
1919                 _Label* pTempBadgeIcon = dynamic_cast<_Label*>(__pItems.at(itemIndex)->GetChild(0));
1920                 SysTryReturnResult(NID_UI_CTRL, pTempBadgeIcon, E_INVALID_STATE, "[E_INVALID_STATE] Couldn't get a badge icon.");
1921
1922                 __pItems.at(itemIndex)->DetachChild(*pTempBadgeIcon);
1923
1924                 delete pTempBadgeIcon;
1925                 pTempBadgeIcon = null;
1926         }
1927
1928         __pItems.at(itemIndex)->SetText(pButton->GetText());
1929         __pItems.at(itemIndex)->SetActionId(pButton->GetActionId());
1930
1931         Bitmap* pIconBitmap = null;
1932         FloatPoint iconPosition(0.0f, 0.0f);
1933
1934         pIconBitmap = const_cast<Bitmap*>(pButton->GetBitmap(_BUTTON_STATUS_NORMAL));
1935
1936         if (pIconBitmap)
1937         {
1938                 iconPosition = pButton->GetBitmapPositionF(_BUTTON_STATUS_NORMAL);
1939
1940                 __pItems.at(itemIndex)->SetBitmap(_BUTTON_STATUS_NORMAL, iconPosition, *pIconBitmap);
1941                 __pItems.at(itemIndex)->SetBitmap(_BUTTON_STATUS_PRESSED, iconPosition, *pIconBitmap);
1942                 __pItems.at(itemIndex)->SetBitmap(_BUTTON_STATUS_SELECTED, iconPosition, *pIconBitmap);
1943                 __pItems.at(itemIndex)->SetBitmap(_BUTTON_STATUS_HIGHLIGHTED, iconPosition, *pIconBitmap);
1944                 __pItems.at(itemIndex)->SetBitmap(_BUTTON_STATUS_DISABLED, iconPosition, *pIconBitmap);
1945         }
1946
1947         pIconBitmap = const_cast<Bitmap*>(pButton->GetBitmap(_BUTTON_STATUS_PRESSED));
1948
1949         if (pIconBitmap)
1950         {
1951                 iconPosition = pButton->GetBitmapPositionF(_BUTTON_STATUS_PRESSED);
1952
1953                 __pItems.at(itemIndex)->SetBitmap(_BUTTON_STATUS_PRESSED, iconPosition, *pIconBitmap);
1954         }
1955
1956         pIconBitmap = const_cast<Bitmap*>(pButton->GetBitmap(_BUTTON_STATUS_SELECTED));
1957
1958         if (pIconBitmap)
1959         {
1960                 iconPosition = pButton->GetBitmapPositionF(_BUTTON_STATUS_SELECTED);
1961
1962                 __pItems.at(itemIndex)->SetBitmap(_BUTTON_STATUS_SELECTED, iconPosition, *pIconBitmap);
1963         }
1964
1965         pIconBitmap = const_cast<Bitmap*>(pButton->GetBitmap(_BUTTON_STATUS_HIGHLIGHTED));
1966
1967         if (pIconBitmap)
1968         {
1969                 iconPosition = pButton->GetBitmapPositionF(_BUTTON_STATUS_HIGHLIGHTED);
1970
1971                 __pItems.at(itemIndex)->SetBitmap(_BUTTON_STATUS_HIGHLIGHTED, iconPosition, *pIconBitmap);
1972         }
1973
1974         pIconBitmap = const_cast<Bitmap*>(pButton->GetBitmap(_BUTTON_STATUS_DISABLED));
1975
1976         if (pIconBitmap)
1977         {
1978                 iconPosition = pButton->GetBitmapPositionF(_BUTTON_STATUS_DISABLED);
1979
1980                 __pItems.at(itemIndex)->SetBitmap(_BUTTON_STATUS_DISABLED, iconPosition, *pIconBitmap);
1981         }
1982
1983         ApplyUserGUI(TOOLBAR_ITEM, __pItems.at(itemIndex));
1984
1985         RearrangeItems();
1986
1987         RealignItem(__pItems.at(itemIndex), __pItems.at(itemIndex)->GetTextExtentSizeF());
1988
1989         delete pButton;
1990
1991         return E_SUCCESS;
1992 }
1993
1994 result
1995 _Toolbar::SetItemBadgeIcon(int itemIndex, const Bitmap* pBadgeIcon)
1996 {
1997         SysTryReturnResult(NID_UI_CTRL, (itemIndex >= 0 && itemIndex < __itemCount), E_INVALID_ARG,
1998                                 "[E_INVALID_ARG] The itemIndex is invalid.");
1999
2000         SysTryReturnResult(NID_UI_CTRL, (__pItems.at(itemIndex)), E_INVALID_STATE,
2001                                 "[E_INVALID_STATE] The badge icon instance isn't constructed.");
2002
2003         if (__pItems.at(itemIndex)->GetChildCount() != 0)
2004         {
2005                 _Label* pTempBadgeIcon = dynamic_cast<_Label*>(__pItems.at(itemIndex)->GetChild(0));
2006
2007                 if (pTempBadgeIcon)
2008                 {
2009                         __pItems.at(itemIndex)->DetachChild(*pTempBadgeIcon);
2010
2011                         delete pTempBadgeIcon;
2012                         pTempBadgeIcon = null;
2013                 }
2014         }
2015
2016         if (pBadgeIcon == null)
2017         {
2018                 return E_SUCCESS;
2019         }
2020
2021         FloatRectangle bounds = __pItems.at(itemIndex)->GetBoundsF();
2022
2023         _Label* pBadgeIconLabel = _Label::CreateLabelN();
2024
2025         float height = 0.0f;
2026
2027         GET_SHAPE_CONFIG(HEADER::BADGE_HEIGHT, GetOrientation(), height);
2028
2029         if (pBadgeIconLabel)
2030         {
2031                 pBadgeIconLabel->SetBounds(FloatRectangle(bounds.width - height, 0.0f, height, height));
2032                 pBadgeIconLabel->SetBackgroundBitmap(*pBadgeIcon);
2033
2034                 __pItems.at(itemIndex)->AttachChild(*pBadgeIconLabel);
2035                 __pItems.at(itemIndex)->SetChildAlwaysOnTop(*pBadgeIconLabel);
2036         }
2037
2038         return E_SUCCESS;
2039 }
2040
2041 result
2042 _Toolbar::SetItemColor(_ButtonStatus status, const Color& color)
2043 {
2044         switch (status)
2045         {
2046         case _BUTTON_STATUS_NORMAL:
2047                 __isItemBgColorSetByUser[_BUTTON_STATUS_NORMAL] = true;
2048                 return SetProperty(L"normalItemColor", Variant(color));
2049                 break;
2050         case _BUTTON_STATUS_DISABLED:
2051                 __isItemBgColorSetByUser[_BUTTON_STATUS_DISABLED] = true;
2052                 return SetProperty(L"disabledItemColor", Variant(color));
2053                 break;
2054         case _BUTTON_STATUS_PRESSED:
2055                 __isItemBgColorSetByUser[_BUTTON_STATUS_PRESSED] = true;
2056                 return SetProperty(L"pressedItemColor", Variant(color));
2057                 break;
2058         case _BUTTON_STATUS_HIGHLIGHTED:
2059                 __isItemBgColorSetByUser[_BUTTON_STATUS_HIGHLIGHTED] = true;
2060                 return SetProperty(L"highlightedItemColor", Variant(color));
2061                 break;
2062         case _BUTTON_STATUS_SELECTED:
2063                 __isItemBgColorSetByUser[_BUTTON_STATUS_SELECTED] = true;
2064                 return SetProperty(L"selectedItemColor", Variant(color));
2065                 break;
2066         default:
2067                 __isItemBgColorSetByUser[_BUTTON_STATUS_NORMAL] = true;
2068                 return SetProperty(L"normalItemColor", Variant(color));
2069                 break;
2070         }
2071 }
2072
2073 result
2074 _Toolbar::SetItemEnabled(int itemIndex, bool enabled)
2075 {
2076         SysTryReturnResult(NID_UI_CTRL, (null != __pItems.at(itemIndex)), E_INVALID_OPERATION,
2077                                 "[E_INVALID_OPERATION] No button item is at the position.");
2078
2079         if (enabled)
2080         {
2081                 _AccessibilityElement* pElement = __pItems.at(itemIndex)->GetAccessibilityContainer()->GetChildElement(0);
2082                 if (pElement)
2083                 {
2084                         pElement->SetStatus(L"");
2085                         pElement->SetHintDisabled(false);
2086                 }
2087                 return __pItems.at(itemIndex)->SetButtonStatus(_BUTTON_STATUS_NORMAL);
2088         }
2089         else
2090         {
2091                 _AccessibilityElement* pElement = __pItems.at(itemIndex)->GetAccessibilityContainer()->GetChildElement(0);
2092                 if (pElement)
2093                 {
2094                         pElement->SetStatus(L"");
2095                         pElement->SetHintDisabled(true);
2096                 }
2097                 return __pItems.at(itemIndex)->SetButtonStatus(_BUTTON_STATUS_DISABLED);
2098         }
2099
2100         return E_SUCCESS;
2101 }
2102
2103 result
2104 _Toolbar::SetItemNumberedBadgeIcon(int itemIndex, int number)
2105 {
2106         SysTryReturnResult(NID_UI_CTRL, (itemIndex >= 0 && itemIndex < __itemCount), E_INVALID_ARG,
2107                                 "[E_INVALID_ARG] The itemIndex is invalid.");
2108
2109         SysTryReturnResult(NID_UI_CTRL, (number >= 0 && number < 100000), E_INVALID_ARG,
2110                                 "[E_INVALID_ARG] The number is out of bounds.");
2111
2112         SysTryReturnResult(NID_UI_CTRL, (__pItems.at(itemIndex)), E_INVALID_STATE,
2113                                 "[E_INVALID_STATE] The badge icon instance isn't constructed.");
2114
2115         if (number == 0)
2116         {
2117                 if (__pItems.at(itemIndex)->GetChildCount() != 0)
2118                 {
2119                         _Label* existingBadgeIcon = dynamic_cast<_Label*>(__pItems.at(itemIndex)->GetChild(0));
2120
2121                         if (existingBadgeIcon)
2122                         {
2123                                 __pItems.at(itemIndex)->DetachChild(*existingBadgeIcon);
2124
2125                                 delete existingBadgeIcon;
2126                                 existingBadgeIcon = null;
2127                         }
2128                 }
2129                 else
2130                 {
2131                         return E_SUCCESS;
2132                 }
2133         }
2134         else
2135         {
2136                 if (__pItems.at(itemIndex)->GetChildCount() == 0)
2137                 {
2138                         _Label* pLabel = _Label::CreateLabelN();
2139
2140                         SysTryReturnResult(NID_UI_CTRL, pLabel, E_INVALID_STATE,
2141                                                 "[E_INVALID_STATE] The badge icon instance isn't constructed.");
2142
2143                         Bitmap* pNumberedBadgeIconBitmap = null;
2144                         Bitmap* pNumberedBadgeIconEffectBitmap = null;
2145                         Bitmap* pColorReplacedBitmap = null;
2146                         Color badgeIconBgColor;
2147                         Color badgeIconTextColor;
2148
2149                         GET_BITMAP_CONFIG_N(HEADER::BADGE_ICON_BG_NORMAL, BITMAP_PIXEL_FORMAT_ARGB8888, pNumberedBadgeIconBitmap);
2150
2151                         bool themeBadgeNormalBackgroundBitmap = IS_CUSTOM_BITMAP(HEADER::BADGE_ICON_BG_NORMAL);
2152                         if (!themeBadgeNormalBackgroundBitmap)
2153                         {
2154                                 GET_BITMAP_CONFIG_N(HEADER::BADGE_ICON_BG_EFFECT_NORMAL, BITMAP_PIXEL_FORMAT_ARGB8888, pNumberedBadgeIconEffectBitmap);
2155                         }
2156
2157                         GET_COLOR_CONFIG(HEADER::BADGE_ICON_BG_NORMAL, badgeIconBgColor);
2158                         GET_COLOR_CONFIG(HEADER::BADGE_ICON_TEXT_NORMAL, badgeIconTextColor);
2159
2160                         if (pNumberedBadgeIconBitmap)
2161                         {
2162                                 pColorReplacedBitmap = _BitmapImpl::GetColorReplacedBitmapN(*pNumberedBadgeIconBitmap,
2163                                                 Color::GetColor(COLOR_ID_MAGENTA), badgeIconBgColor);
2164
2165                                 pLabel->SetBackgroundBitmap(*pColorReplacedBitmap);
2166
2167                                 delete pColorReplacedBitmap;
2168                                 delete pNumberedBadgeIconBitmap;
2169                         }
2170
2171                         if (pNumberedBadgeIconEffectBitmap)
2172                         {
2173                                 pLabel->SetBackgroundEffectBitmap(*pNumberedBadgeIconEffectBitmap);
2174
2175                                 delete pNumberedBadgeIconEffectBitmap;
2176                         }
2177
2178                         pLabel->SetTextHorizontalAlignment(ALIGNMENT_RIGHT);
2179                         pLabel->SetTextVerticalAlignment(ALIGNMENT_MIDDLE);
2180                         pLabel->SetTextColor(badgeIconTextColor);
2181                         pLabel->SetMargin(0, 10);
2182
2183                         __pItems.at(itemIndex)->AttachChild(*pLabel);
2184                         __pItems.at(itemIndex)->SetChildAlwaysOnTop(*pLabel);
2185                 }
2186
2187                 // SetItemNumberedBadgeIcon
2188
2189                 _Label* existingBadgeIcon = dynamic_cast<_Label*>(__pItems.at(itemIndex)->GetChild(0));
2190
2191                 FloatRectangle bounds = __pItems.at(itemIndex)->GetBoundsF();
2192
2193                 if (existingBadgeIcon)
2194                 {
2195                         float fontSize = 0.0f;
2196                         float height = 0.0f;
2197                         float width = 0.0f;
2198
2199                         GET_SHAPE_CONFIG(HEADER::BADGE_FONT_SIZE, GetOrientation(), fontSize);
2200                         GET_SHAPE_CONFIG(HEADER::BADGE_HEIGHT, GetOrientation(), height);
2201
2202                         if (number < 10)
2203                         {
2204                                 GET_SHAPE_CONFIG(HEADER::BADGE_WIDTH_1DIGIT, GetOrientation(), width);
2205                         }
2206                         else if (number < 100)
2207                         {
2208                                 GET_SHAPE_CONFIG(HEADER::BADGE_WIDTH_2DIGIT, GetOrientation(), width);
2209                         }
2210                         else if (number < 1000)
2211                         {
2212                                 GET_SHAPE_CONFIG(HEADER::BADGE_WIDTH_3DIGIT, GetOrientation(), width);
2213                         }
2214                         else if (number < 10000)
2215                         {
2216                                 GET_SHAPE_CONFIG(HEADER::BADGE_WIDTH_4DIGIT, GetOrientation(), width);
2217                         }
2218                         else
2219                         {
2220                                 GET_SHAPE_CONFIG(HEADER::BADGE_WIDTH_5DIGIT, GetOrientation(), width);
2221                         }
2222
2223                         existingBadgeIcon->SetBounds(FloatRectangle(bounds.width - width, 0.0f, width, height));
2224                         existingBadgeIcon->SetTextConfig(fontSize, LABEL_TEXT_STYLE_NORMAL);
2225
2226                         Integer tempNumber(number);
2227                         existingBadgeIcon->SetText(tempNumber.ToString());
2228                 }
2229         }
2230
2231         return E_SUCCESS;
2232 }
2233
2234 result
2235 _Toolbar::SetItemSelected(int itemIndex, bool fire)
2236 {
2237         SysTryReturnResult(NID_UI_CTRL, (itemIndex >= -1 && itemIndex < __itemCount), E_INVALID_STATE,
2238                                         "[E_INVALID_STATE] Failed to process SetItemSelected()");
2239
2240         result r = E_SUCCESS;
2241
2242         int currentSelectedItemIndex = 0;
2243         currentSelectedItemIndex = GetSelectedItemIndex();
2244
2245         r = __pToolbarPresenter->SetItemSelected(itemIndex);
2246
2247         if (itemIndex != -1 && itemIndex == currentSelectedItemIndex && __pItems.at(itemIndex) != null) // same item selected
2248         {
2249                 if (!IsInitialDraw() && fire)
2250                 {
2251                         PLAY_FEEDBACK(_RESOURCE_FEEDBACK_PATTERN_TAP);
2252                 }
2253                 __pItems.at(itemIndex)->SetButtonStatus(_BUTTON_STATUS_SELECTED, fire);
2254                 __pItems.at(itemIndex)->Draw();
2255                 _AccessibilityElement* pElement = __pItems.at(currentSelectedItemIndex)->GetAccessibilityContainer()->GetChildElement(0);
2256                 if (pElement)
2257                 {
2258                         pElement->SetStatus(L"Selected");
2259                         pElement->SetHintDisabled(true);
2260                 }
2261
2262                 return r;
2263         }
2264
2265         if (__itemCount == 0 || __itemCount > TAB_ITEM_MAX || itemIndex == -1)
2266         {
2267                 return r;
2268         }
2269
2270         SysTryReturnResult(NID_UI_CTRL, r == E_SUCCESS, E_INVALID_STATE, "[E_INVALID_STATE] Failed to process SetItemSelected()");
2271
2272         if (__pItems.at(itemIndex) != null)
2273         {
2274                 if (!IsInitialDraw() && fire)
2275                 {
2276                         PLAY_FEEDBACK(_RESOURCE_FEEDBACK_PATTERN_TAP);
2277                 }
2278                 __pItems.at(itemIndex)->SetButtonStatus(_BUTTON_STATUS_SELECTED, fire);
2279                 _AccessibilityElement* pElement = __pItems.at(itemIndex)->GetAccessibilityContainer()->GetChildElement(0);
2280                 if (pElement)
2281                 {
2282                         pElement->SetStatus(L"Selected");
2283                         pElement->SetHintDisabled(true);
2284                 }
2285         }
2286
2287         if (__itemCount == 0 || __itemCount > TAB_ITEM_MAX || itemIndex == -1)
2288         {
2289                 return r;
2290         }
2291
2292         if (currentSelectedItemIndex != -1 && __pItems.at(currentSelectedItemIndex) != null)
2293         {
2294                 __pItems.at(currentSelectedItemIndex)->SetButtonStatus(_BUTTON_STATUS_NORMAL);
2295                 __pItems.at(currentSelectedItemIndex)->Draw();
2296                 _AccessibilityElement* pElement = __pItems.at(currentSelectedItemIndex)->GetAccessibilityContainer()->GetChildElement(0);
2297                 if (pElement)
2298                 {
2299                         pElement->SetStatus(L"");
2300                         pElement->SetHintDisabled(false);
2301                 }
2302         }
2303
2304         if (__pItems.at(itemIndex) != null)
2305         {
2306                 __pItems.at(itemIndex)->Draw();
2307         }
2308
2309         return r;
2310 }
2311
2312 result
2313 _Toolbar::SetItemTextColor(_ButtonStatus status, const Color& color)
2314 {
2315         switch(status)
2316         {
2317         case _BUTTON_STATUS_NORMAL:
2318                 __isItemTextColorSetByUser[_BUTTON_STATUS_NORMAL] = true;
2319                 return SetProperty(L"normalItemTextColor", Variant(color));
2320                 break;
2321         case _BUTTON_STATUS_DISABLED:
2322                 __isItemTextColorSetByUser[_BUTTON_STATUS_DISABLED] = true;
2323                 return SetProperty(L"disabledItemTextColor", Variant(color));
2324                 break;
2325         case _BUTTON_STATUS_PRESSED:
2326                 __isItemTextColorSetByUser[_BUTTON_STATUS_PRESSED] = true;
2327                 return SetProperty(L"pressedItemTextColor", Variant(color));
2328                 break;
2329         case _BUTTON_STATUS_HIGHLIGHTED:
2330                 __isItemTextColorSetByUser[_BUTTON_STATUS_HIGHLIGHTED] = true;
2331                 return SetProperty(L"highlightedItemTextColor", Variant(color));
2332                 break;
2333         case _BUTTON_STATUS_SELECTED:
2334                 __isItemTextColorSetByUser[_BUTTON_STATUS_SELECTED] = true;
2335                 return SetProperty(L"selectedItemTextColor", Variant(color));
2336                 break;
2337         default:
2338                 __isItemTextColorSetByUser[_BUTTON_STATUS_NORMAL] = true;
2339                 return SetProperty(L"normalItemTextColor", Variant(color));
2340                 break;
2341         }
2342 }
2343
2344 result
2345 _Toolbar::SetStyle(ToolbarStyle style)
2346 {
2347         __style = style;
2348
2349         __pToolbarPresenter->SetInitialDrawState(true);
2350
2351         if (__style == TOOLBAR_TAB || __style == TOOLBAR_TAB_WITH_TITLE)
2352         {
2353                 SetTabEditModeEnabled(true);
2354         }
2355
2356         AdjustToolbarBounds();
2357
2358         InitToolbarColor();
2359
2360         __titleText = L"";
2361
2362         __descriptionText = L"";
2363
2364         if (__style == TOOLBAR_TITLE || __style == TOOLBAR_HEADER_SEGMENTED_WITH_TITLE || __style == TOOLBAR_TAB_WITH_TITLE)
2365         {
2366                 if(__pTitleTextElement)
2367                 {
2368                         __pTitleTextElement->SetLabel(L"");
2369                 }
2370         }
2371         else
2372         {
2373                 if(__pTitleTextElement)
2374                 {
2375                         GetAccessibilityContainer()->RemoveElement(*__pTitleTextElement);
2376                         __pTitleTextElement = null;
2377                 }
2378         }
2379
2380         return E_SUCCESS;
2381 }
2382
2383 result
2384 _Toolbar::AdjustToolbarBounds(void)
2385 {
2386         float width = 0.0f;
2387         float height = 0.0f;
2388
2389         const FloatDimension portraitSize = _ControlManager::GetInstance()->_ControlManager::GetScreenSizeF();
2390         const FloatDimension landscapeSize = FloatDimension(portraitSize.height, portraitSize.width);
2391
2392         if (GetOrientation() == _CONTROL_ORIENTATION_PORTRAIT)
2393         {
2394                 width = portraitSize.width;
2395         }
2396         else
2397         {
2398                 width = landscapeSize.width;
2399         }
2400
2401         SetResizable(true);
2402
2403         if (__header == true)
2404         {
2405                 if (__style == TOOLBAR_HEADER_SEGMENTED_WITH_TITLE || __style == TOOLBAR_TAB_WITH_TITLE)
2406                 {
2407                         //GET_SHAPE_CONFIG(HEADER::WIDTH, GetOrientation(), width);
2408                         GET_SHAPE_CONFIG(HEADER::TITLE_TOTAL_HEIGHT_WITH_SEGMENTED_ITEM, GetOrientation(), height);
2409                         SetSize(FloatDimension(width, height));
2410                 }
2411                 else if (__style == TOOLBAR_TEXT && GetOrientation() == _CONTROL_ORIENTATION_LANDSCAPE) // sip & landscape => footer height
2412                 {
2413                         //GET_SHAPE_CONFIG(HEADER::WIDTH, GetOrientation(), width);
2414                         GET_SHAPE_CONFIG(FOOTER::HEIGHT, GetOrientation(), height);
2415                         SetSize(FloatDimension(width, height));
2416                 }
2417                 else
2418                 {
2419                         //GET_SHAPE_CONFIG(HEADER::WIDTH, GetOrientation(), width);
2420                         GET_SHAPE_CONFIG(HEADER::HEIGHT, GetOrientation(), height);
2421                         SetSize(FloatDimension(width, height));
2422                 }
2423         }
2424         else
2425         {
2426                 //GET_SHAPE_CONFIG(FOOTER::WIDTH, GetOrientation(), width);
2427
2428                 if (__style == TOOLBAR_SOFTKEY)
2429                 {
2430                         GET_SHAPE_CONFIG(FOOTER::SOFTKEY_HEIGHT, GetOrientation(), height);
2431                 }
2432                 else
2433                 {
2434                         GET_SHAPE_CONFIG(FOOTER::HEIGHT, GetOrientation(), height);
2435                 }
2436
2437                 SetSize(FloatDimension(width, height));
2438         }
2439
2440         SetResizable(false);
2441
2442         _Form* pParent = dynamic_cast<_Form*>(GetParent());
2443
2444         if (pParent != null)
2445         {
2446                 pParent->AdjustClientBounds();
2447
2448                 if (__header == false)
2449                 {
2450                         FloatRectangle bounds(0.0f, pParent->GetClientBoundsF().y + pParent->GetClientBoundsF().height, width, height);
2451                         FloatDimension dimension(width, height);
2452                         dimension = pParent->TranslateSize(dimension);
2453                         bounds.height = dimension.height;
2454
2455                         if (__transparent || !GetVisibleState())
2456                         {
2457                                 bounds.y -= bounds.height;
2458                         }
2459
2460                         pParent->SetFooterBounds(bounds);
2461                 }
2462         }
2463
2464         return E_SUCCESS;
2465 }
2466
2467 result
2468 _Toolbar::SetTabEditModeEnabled(bool enable)
2469 {
2470         return __pToolbarPresenter->SetTabEditModeEnabled(enable);
2471 }
2472
2473 result
2474 _Toolbar::SetTitleIcon(const Bitmap& bitmap)
2475 {
2476         result r = E_SYSTEM;
2477
2478         Bitmap* pClonedBitmap = _BitmapImpl::CloneN(bitmap);
2479
2480         if (pClonedBitmap)
2481         {
2482                 if (__pTitleIcon)
2483                 {
2484                         delete __pTitleIcon;
2485                 }
2486
2487                 __pTitleIcon = pClonedBitmap;
2488
2489                 r = E_SUCCESS;
2490         }
2491
2492         return r;
2493 }
2494
2495 result
2496 _Toolbar::SetTitleText(const String& text, HorizontalAlignment alignment)
2497 {
2498         result r = E_SYSTEM;
2499         __titleText = text;
2500         __titleTextAlignment = alignment;
2501
2502         RearrangeItems();
2503
2504         r = __pToolbarPresenter->SetTitleText(__titleText, __titleTextAlignment);
2505
2506         if(likely(!(_AccessibilityManager::IsActivated())))
2507         {
2508                 return r ;
2509         }
2510
2511         if (__pTitleTextElement == null)
2512         {
2513                 __pTitleTextElement = new (std::nothrow) _AccessibilityElement(true);
2514                 SysTryReturnResult(NID_UI_CTRL, __pTitleTextElement, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] Memory shortage.");
2515                 GetAccessibilityContainer()->SetPriority(ACCESSIBILITY_PRIORITY_TOP);
2516                 GetAccessibilityContainer()->AddElement(*__pTitleTextElement);
2517         }
2518
2519         if( __descriptionText.IsEmpty())
2520         {
2521                 __pTitleTextElement->SetLabel(__titleText);
2522                 __pTitleTextElement->SetBounds(FloatRectangle(__pToolbarPresenter->GetTitleTextBoundsF()));
2523         }
2524         else
2525         {
2526                 __pTitleTextElement->SetLabel(__titleText + L"," + __descriptionText);
2527
2528                 FloatRectangle descriptionBounds = __pToolbarPresenter->GetDescriptionBoundsF();
2529                 FloatRectangle titleBounds = __pToolbarPresenter->GetTitleTextBoundsF();
2530
2531                 __pTitleTextElement->SetBounds(FloatRectangle(titleBounds.x, titleBounds.y, titleBounds.width, titleBounds.height + descriptionBounds.height));
2532         }
2533         __pTitleTextElement->SetTrait(L"Title");
2534         __pTitleTextElement->SetName(L"HeaderTitleText");
2535
2536         return r;
2537 }
2538
2539 result
2540 _Toolbar::SetTitleTextColor(const Color& color)
2541 {
2542         __titleTextColor = color;
2543
2544         return E_SUCCESS;
2545 }
2546
2547 result
2548 _Toolbar::SetTransparent(bool transparent)
2549 {
2550         if (__style == TOOLBAR_SOFTKEY)
2551         {
2552                 return E_SUCCESS;
2553         }
2554
2555         __transparent = transparent;
2556
2557         InitToolbarColor();
2558
2559         __isUserBackgroundBitmap = true;
2560
2561
2562         Bitmap* pMagentaBackgroundBitmap = null;
2563
2564         if (__pToolbarBackgroundBitmap)
2565         {
2566                 delete __pToolbarBackgroundBitmap;
2567                 __pToolbarBackgroundBitmap = null;
2568         }
2569
2570         GET_BITMAP_CONFIG_N(HEADER::BG_NORMAL, BITMAP_PIXEL_FORMAT_ARGB8888, pMagentaBackgroundBitmap);
2571
2572         if (__transparent)
2573         {
2574                 Color tempColor;
2575
2576                 GET_COLOR_CONFIG(HEADER::TRANSLUCENT_BG_NORMAL, tempColor);
2577
2578                 if (pMagentaBackgroundBitmap)
2579                 {
2580                         __pToolbarBackgroundBitmap = _BitmapImpl::GetColorReplacedBitmapN(*(pMagentaBackgroundBitmap),
2581                                         Color::GetColor(COLOR_ID_MAGENTA), tempColor);
2582
2583                         if (__pToolbarBackgroundBitmap)
2584                         {
2585                                 __pToolbarBackgroundBitmap->SetAlphaConstant(0x7F);
2586                         }
2587                 }
2588
2589                 SetTitleTextColor(__transTitleTextColor);
2590                 SetDescriptionTextColor(__transDescriptionTextColor);
2591
2592                 for (int i = 0; i < __itemCount ; i ++)
2593                 {
2594                         if (__pItems.at(i) != null)
2595                         {
2596                                 ApplyUserGUI(TOOLBAR_ITEM, __pItems.at(i));
2597                         }
2598                 }
2599
2600                 for (int i = 0; i < BUTTON_MAX; i++)
2601                 {
2602                         if (__pButtonItems[i] != null)
2603                         {
2604                                 ApplyUserGUI(TOOLBAR_BUTTON, __pButtonItems[i]);
2605                         }
2606                 }
2607
2608                 SetTransBackButton(true);
2609         }
2610         else // not transparent
2611         {
2612                 __pToolbarBackgroundBitmap = _BitmapImpl::GetColorReplacedBitmapN(*(pMagentaBackgroundBitmap),
2613                                 Color::GetColor(COLOR_ID_MAGENTA), GetColor());
2614
2615                 SetTitleTextColor(__titleTextColor);
2616                 SetDescriptionTextColor(__descriptionTextColor);
2617
2618                 for (int i = 0; i < __itemCount ; i ++)
2619                 {
2620                         if (__pItems.at(i) != null)
2621                         {
2622                                 ApplyUserGUI(TOOLBAR_ITEM, __pItems.at(i));
2623                         }
2624                 }
2625
2626                 for (int i = 0; i < BUTTON_MAX; i++)
2627                 {
2628                         if (__pButtonItems[i] != null)
2629                         {
2630                                 ApplyUserGUI(TOOLBAR_BUTTON, __pButtonItems[i]);
2631                         }
2632                 }
2633
2634                 SetTransBackButton(false);
2635         }
2636
2637         delete pMagentaBackgroundBitmap;
2638
2639         return E_SUCCESS;
2640 }
2641
2642 result
2643 _Toolbar::SetWaitingAnimationPosition(ToolbarAnimationPosition animationPos, float x, float y)
2644 {
2645         if (__pAnimation[animationPos])
2646         {
2647                 __pAnimation[animationPos]->SetPosition(FloatPoint(x, y));
2648         }
2649
2650         return E_SUCCESS;
2651 }
2652
2653 result
2654 _Toolbar::StopWaitingAnimation(ToolbarAnimationPosition animationPos)
2655 {
2656         SysTryReturnResult(NID_UI_CTRL,
2657                         (TOOLBAR_ANIMATION_POSITION_TITLE <= animationPos && animationPos < TOOLBAR_ANIMATION_POSITION_MAX), E_INVALID_ARG,
2658                         "[E_INVALID_ARG] The animationPos is invalid.");
2659         SysTryReturnResult(NID_UI_CTRL, (__pAnimation[animationPos]), E_INVALID_STATE,
2660                         "[E_INVALID_STATE] __pAnimation isn't constructed.");
2661
2662         __pAnimation[animationPos]->Stop();
2663
2664         if (animationPos == TOOLBAR_ANIMATION_POSITION_TITLE)
2665         {
2666                 DetachChild(*__pAnimation[animationPos]);
2667         }
2668         else if (animationPos == TOOLBAR_ANIMATION_POSITION_BUTTON_LEFT && __pButtonItems[LEFT_BUTTON] != null)
2669         {
2670                 __pButtonItems[LEFT_BUTTON]->DetachChild(*__pAnimation[animationPos]);
2671         }
2672         else if (animationPos == TOOLBAR_ANIMATION_POSITION_BUTTON_RIGHT && __pButtonItems[RIGHT_BUTTON] != null)
2673         {
2674                 __pButtonItems[RIGHT_BUTTON]->DetachChild(*__pAnimation[animationPos]);
2675         }
2676
2677         delete __pAnimation[animationPos];
2678         __pAnimation[animationPos] = null;
2679
2680         return E_SUCCESS;
2681 }
2682
2683 void
2684 _Toolbar::OnAnimationStopped(const _Control& source)
2685 {
2686         ClearLastResult();
2687
2688         if (&source == __pAnimation[TOOLBAR_ANIMATION_POSITION_BUTTON_LEFT])
2689         {
2690                 __pAnimation[TOOLBAR_ANIMATION_POSITION_BUTTON_LEFT]->Play();
2691         }
2692         else if (&source == __pAnimation[TOOLBAR_ANIMATION_POSITION_BUTTON_RIGHT])
2693         {
2694                 __pAnimation[TOOLBAR_ANIMATION_POSITION_BUTTON_RIGHT]->Play();
2695         }
2696         else if (__pAnimation[TOOLBAR_ANIMATION_POSITION_TITLE])
2697         {
2698                 __pAnimation[TOOLBAR_ANIMATION_POSITION_TITLE]->Play();
2699         }
2700
2701         return;
2702 }
2703
2704 result
2705 _Toolbar::OnAttachedToMainTree(void)
2706 {
2707         return E_SUCCESS;
2708 }
2709
2710 void
2711 _Toolbar::AddAccessibilityElement(ToolbarButton position, _Button* pButton)
2712 {
2713         if(likely(!(_AccessibilityManager::IsActivated())))
2714         {
2715                 return;
2716         }
2717         String name = L"";
2718         switch(position)
2719         {
2720                 case LEFT_BUTTON:
2721                         name = L"LeftButtonText";
2722                         break;
2723                 case RIGHT_BUTTON:
2724                         name = L"RightButtonText";
2725                         break;
2726                 case BACK_BUTTON:
2727                         name = L"BackButtonText";
2728                         break;
2729                 case MIDDLE_BUTTON:
2730                         name = L"MiddleButtonText";
2731                         break;
2732                 default:
2733                         return;
2734                         break;
2735         }
2736         _AccessibilityContainer* pContainer = GetAccessibilityContainer();
2737         _AccessibilityElement* pButtonElement = null;
2738
2739         _AccessibilityContainer* pButtonContainer = pButton->GetAccessibilityContainer();
2740
2741         if (pButtonContainer)
2742         {
2743                 pButtonContainer->SetPriority(__header?ACCESSIBILITY_PRIORITY_TOP:ACCESSIBILITY_PRIORITY_BOTTOM);
2744                 pContainer->AddChildContainer(*pButtonContainer);
2745                 pButtonElement = pButtonContainer->GetChildElement(L"ButtonText");
2746         }
2747
2748         if(pButtonElement)
2749         {
2750                 pButtonElement->SetName(name);
2751
2752                 if (position == BACK_BUTTON)
2753                 {
2754                         pButtonElement->SetLabel("Back");
2755                         pButtonElement->SetTrait("Back Button");
2756                 }
2757                 else
2758                 {
2759                         pButtonElement->SetTrait(L"Button");
2760                 }
2761
2762                 pButtonElement->SetBounds(GetButtonBoundsF(position));
2763         }
2764 }
2765
2766 void
2767 _Toolbar::AddAccessibilityElement(_Button* pButton)
2768 {
2769         if(likely(!(_AccessibilityManager::IsActivated())))
2770         {
2771                 return;
2772         }
2773
2774         _AccessibilityContainer* pContainer = GetAccessibilityContainer();
2775         if(pContainer == null)
2776         {
2777                 return;
2778         }
2779
2780         int priorty = 0;
2781         if(__header)
2782         {
2783                 priorty = ACCESSIBILITY_PRIORITY_TOP;
2784         }
2785         else
2786         {
2787                 priorty = ACCESSIBILITY_PRIORITY_BOTTOM;
2788         }
2789         pContainer->SetPriority(priorty);
2790
2791         ToolbarStyle style = GetStyle();
2792         String trait = L"";
2793         String name = L"";
2794         switch (style)
2795         {
2796                 case TOOLBAR_HEADER_SEGMENTED:
2797                         //fall through
2798                 case TOOLBAR_HEADER_SEGMENTED_WITH_TITLE:
2799                         //fall through
2800                 case TOOLBAR_SEGMENTED:
2801                         name = L"Segment" + Integer::ToString(__itemCount);
2802                         name.Append(L"Text");
2803                         trait = L"Segmented control";
2804                         break;
2805                 case TOOLBAR_TAB_WITH_TITLE:
2806                         //fall through
2807                 case TOOLBAR_TAB:
2808                         name = L"Tab" + Integer::ToString(__itemCount);
2809                         name.Append(L"Text");
2810                         trait = L"Tab";
2811                         break;
2812                 default:
2813                         name = L"Button" + Integer::ToString(__itemCount);
2814                         name.Append(L"Text");
2815                         trait = L"Button";
2816                         break;
2817         }
2818
2819         if (pButton != null)
2820         {
2821                 _AccessibilityElement* pElement = null;
2822                 _AccessibilityContainer* pButtonContainer = pButton->GetAccessibilityContainer();
2823
2824                 if (pButtonContainer)
2825                 {
2826                         pButtonContainer->SetPriority(priorty);
2827                         pContainer->AddChildContainer(*pButtonContainer);
2828                         pElement = pButtonContainer->GetChildElement(L"ButtonText");
2829                 }
2830
2831                 if(pElement)
2832                 {
2833                         pElement->SetName(name);
2834                         pElement->SetTrait(trait);
2835                         if(style == TOOLBAR_HEADER_SEGMENTED || style == TOOLBAR_HEADER_SEGMENTED_WITH_TITLE
2836                                 || style == TOOLBAR_SEGMENTED || style == TOOLBAR_TAB_WITH_TITLE
2837                                 || style == TOOLBAR_TAB)
2838                         {
2839                                 pElement->SetHint(L"Double tap to move to contents");
2840                                 pButton->GetAccessibilityContainer()->AddListener(footerItemAccessibilityListener);
2841                         }
2842                 }
2843         }
2844
2845         return;
2846 }
2847
2848 void
2849 _Toolbar::OnBoundsChanged(void)
2850 {
2851         RearrangeItems();
2852
2853         if(likely(!(_AccessibilityManager::IsActivated())))
2854         {
2855                 return;
2856         }
2857
2858         if(__pTitleTextElement)
2859         {
2860                 if( __descriptionText.IsEmpty())
2861                 {
2862                         __pTitleTextElement->SetBounds(FloatRectangle(__pToolbarPresenter->GetTitleTextBoundsF()));
2863                 }
2864                 else
2865                 {
2866                         FloatRectangle descriptionBounds = __pToolbarPresenter->GetDescriptionBoundsF();
2867                         FloatRectangle titleBounds = __pToolbarPresenter->GetTitleTextBoundsF();
2868
2869                         __pTitleTextElement->SetBounds(FloatRectangle(titleBounds.x, titleBounds.y, titleBounds.width, titleBounds.height + descriptionBounds.height));
2870                 }
2871         }
2872         return;
2873 }
2874
2875 void
2876 _Toolbar::OnFontChanged(Font* pFont)
2877 {
2878         __pToolbarPresenter->OnFontChanged(pFont);
2879
2880         return;
2881 }
2882
2883 void
2884 _Toolbar::OnFontInfoRequested(unsigned long& style, int& size)
2885 {
2886         __pToolbarPresenter->OnFontInfoRequested(style, size);
2887
2888         return;
2889 }
2890
2891 void
2892 _Toolbar::OnChangeLayout(_ControlOrientation orientationStatus)
2893 {
2894         float toolbarWidth = GetBoundsF().width;
2895
2896         if (CalculateMinimumToolbarWidth() > toolbarWidth)
2897         {
2898                 toolbarWidth = CalculateMinimumToolbarWidth();
2899         }
2900
2901         AdjustToolbarBounds();
2902
2903         RearrangeItems();
2904
2905         __pToolbarPresenter->OnChangeLayout(orientationStatus);
2906
2907         return;
2908 }
2909
2910 void
2911 _Toolbar::OnDraw(void)
2912 {
2913         ClearLastResult();
2914
2915         __pToolbarPresenter->Draw();
2916
2917         if(likely(!(_AccessibilityManager::IsActivated())))
2918         {
2919                 return;
2920         }
2921         if(__pTitleTextElement)
2922         {
2923                 if( __descriptionText.IsEmpty())
2924                 {
2925                         __pTitleTextElement->SetBounds(FloatRectangle(__pToolbarPresenter->GetTitleTextBoundsF()));
2926                 }
2927                 else
2928                 {
2929                         FloatRectangle descriptionBounds = __pToolbarPresenter->GetDescriptionBoundsF();
2930                         FloatRectangle titleBounds = __pToolbarPresenter->GetTitleTextBoundsF();
2931
2932                         __pTitleTextElement->SetBounds(FloatRectangle(titleBounds.x, titleBounds.y, titleBounds.width, titleBounds.height + descriptionBounds.height));
2933                 }
2934         }
2935         return;
2936 }
2937
2938 bool
2939 _Toolbar::OnLongPressGestureDetected(_TouchLongPressGestureDetector& gesture)
2940 {
2941         return __pToolbarPresenter->OnLongPressGestureDetected();
2942 }
2943
2944 bool
2945 _Toolbar::OnLongPressGestureCanceled(_TouchLongPressGestureDetector& gesture)
2946 {
2947         return false;
2948 }
2949
2950 bool
2951 _Toolbar::OnFlickGestureDetected(_TouchFlickGestureDetector& gesture)
2952 {
2953         return __pToolbarPresenter->OnFlickGestureDetected(gesture);
2954 }
2955
2956 bool
2957 _Toolbar::OnFlickGestureCanceled(_TouchFlickGestureDetector& gesture)
2958 {
2959         return false;
2960 }
2961
2962 bool
2963 _Toolbar::OnTouchPressed(const _Control& source, const _TouchInfo& touchinfo)
2964 {
2965         ClearLastResult();
2966
2967         return __pToolbarPresenter->OnTouchPressed(source, touchinfo);
2968 }
2969
2970 bool
2971 _Toolbar::OnTouchReleased(const _Control& source, const _TouchInfo& touchinfo)
2972 {
2973         ClearLastResult();
2974
2975         return __pToolbarPresenter->OnTouchReleased(source, touchinfo);
2976 }
2977
2978 bool
2979 _Toolbar::OnTouchMoved(const _Control& source, const _TouchInfo& touchinfo)
2980 {
2981         ClearLastResult();
2982
2983         return __pToolbarPresenter->OnTouchMoved(source, touchinfo);
2984 }
2985
2986 bool
2987 _Toolbar::OnTouchCanceled(const _Control& source, const _TouchInfo& touchinfo)
2988 {
2989         ClearLastResult();
2990
2991         return __pToolbarPresenter->OnTouchCanceled(source, touchinfo);
2992 }
2993
2994 void
2995 _Toolbar::AddActionEventListener(const Controls::_IActionEventListener& listener)
2996 {
2997         __pActionEventListener = const_cast<Controls::_IActionEventListener*>(&listener);
2998
2999         for (int i = 0; i < __itemCount; i++)
3000         {
3001                 __pItems.at(i)->AddActionEventListener(listener);
3002         }
3003
3004         for (int j = 0; j < BUTTON_MAX; j++)
3005         {
3006                 if (__pButtonItems[j])
3007                 {
3008                         __pButtonItems[j]->AddActionEventListener(listener);
3009                 }
3010         }
3011
3012         return;
3013 }
3014
3015 void
3016 _Toolbar::RemoveActionEventListener(const Controls::_IActionEventListener& listener)
3017 {
3018         __pActionEventListener = null;
3019
3020         for (int i = 0; i < __itemCount; i++)
3021         {
3022                 __pItems.at(i)->RemoveActionEventListener(listener);
3023         }
3024
3025         for (int j = 0; j < MIDDLE_BUTTON; j++)
3026         {
3027                 if (__pButtonItems[j])
3028                 {
3029                         __pButtonItems[j]->RemoveActionEventListener(listener);
3030                 }
3031         }
3032
3033         return;
3034
3035 }
3036
3037 void
3038 _Toolbar::SetBackEventListener(const Controls::_IActionEventListener& listener, int actionId)
3039 {
3040         __backActionId = actionId;
3041         __pBackEventListener = const_cast<_IActionEventListener*>(&listener);
3042
3043         return;
3044 }
3045
3046 result
3047 _Toolbar::SetPresenter(const _ToolbarPresenter& toolbarPresenter)
3048 {
3049         __pToolbarPresenter = const_cast<_ToolbarPresenter*>(&toolbarPresenter);
3050
3051         return E_SUCCESS;
3052 }
3053
3054 result
3055 _Toolbar::ApplyUserGUI(ButtonType buttonType, _Button* pButton)
3056 {
3057         SysTryReturnResult(NID_UI_CTRL, pButton, E_INVALID_ARG, "[E_INVALID_ARG] The pButton is invalid.");
3058
3059         if (TOOLBAR_BUTTON == buttonType)
3060         {
3061                 Bitmap* pNormalBackgroundBitmap = null;
3062                 Bitmap* pColorReplacedBitmap = null;
3063
3064                 if (__header)
3065                 {
3066                         GET_BITMAP_CONFIG_N(HEADER::BUTTON_BG_NORMAL, BITMAP_PIXEL_FORMAT_ARGB8888, pNormalBackgroundBitmap);
3067                 }
3068                 else
3069                 {
3070                         GET_BITMAP_CONFIG_N(FOOTER::BUTTON_BG_NORMAL, BITMAP_PIXEL_FORMAT_ARGB8888, pNormalBackgroundBitmap);
3071                 }
3072
3073                 if (__transparent)
3074                 {
3075                         pButton->SetTextColor(_BUTTON_STATUS_NORMAL, __buttonTransTextColor[_BUTTON_STATUS_NORMAL]);
3076                         pButton->SetTextColor(_BUTTON_STATUS_PRESSED, __buttonTransTextColor[_BUTTON_STATUS_PRESSED]);
3077                         pButton->SetTextColor(_BUTTON_STATUS_HIGHLIGHTED, __buttonTransTextColor[_BUTTON_STATUS_HIGHLIGHTED]);
3078                         pButton->SetTextColor(_BUTTON_STATUS_DISABLED, __buttonTransTextColor[_BUTTON_STATUS_DISABLED]);
3079
3080                         if (pNormalBackgroundBitmap)
3081                         {
3082                                 pColorReplacedBitmap = _BitmapImpl::GetColorReplacedBitmapN(*pNormalBackgroundBitmap,
3083                                                 Color::GetColor(COLOR_ID_MAGENTA), __buttonTransBackgroundColor[_BUTTON_STATUS_NORMAL]);
3084                                 pButton->SetBackgroundBitmap(_BUTTON_STATUS_NORMAL, *pColorReplacedBitmap);
3085                                 delete pColorReplacedBitmap;
3086
3087                                 pColorReplacedBitmap = _BitmapImpl::GetColorReplacedBitmapN(*pNormalBackgroundBitmap,
3088                                                 Color::GetColor(COLOR_ID_MAGENTA), __buttonTransBackgroundColor[_BUTTON_STATUS_PRESSED]);
3089                                 pButton->SetBackgroundBitmap(_BUTTON_STATUS_PRESSED, *pColorReplacedBitmap);
3090                                 delete pColorReplacedBitmap;
3091
3092                                 pColorReplacedBitmap = _BitmapImpl::GetColorReplacedBitmapN(*pNormalBackgroundBitmap,
3093                                                 Color::GetColor(COLOR_ID_MAGENTA), __buttonTransBackgroundColor[_BUTTON_STATUS_HIGHLIGHTED]);
3094                                 pButton->SetBackgroundBitmap(_BUTTON_STATUS_HIGHLIGHTED, *pColorReplacedBitmap);
3095                                 delete pColorReplacedBitmap;
3096
3097                                 pColorReplacedBitmap = _BitmapImpl::GetColorReplacedBitmapN(*pNormalBackgroundBitmap,
3098                                                 Color::GetColor(COLOR_ID_MAGENTA), __buttonTransBackgroundColor[_BUTTON_STATUS_DISABLED]);
3099                                 pButton->SetBackgroundBitmap(_BUTTON_STATUS_DISABLED, *pColorReplacedBitmap);
3100                                 delete pColorReplacedBitmap;
3101
3102                                 delete pNormalBackgroundBitmap;
3103                         }
3104                 }
3105                 else
3106                 {
3107                         pButton->SetTextColor(_BUTTON_STATUS_NORMAL, __buttonTextColor[_BUTTON_STATUS_NORMAL]);
3108                         pButton->SetTextColor(_BUTTON_STATUS_PRESSED, __buttonTextColor[_BUTTON_STATUS_PRESSED]);
3109                         pButton->SetTextColor(_BUTTON_STATUS_HIGHLIGHTED, __buttonTextColor[_BUTTON_STATUS_HIGHLIGHTED]);
3110                         pButton->SetTextColor(_BUTTON_STATUS_DISABLED, __buttonTextColor[_BUTTON_STATUS_DISABLED]);
3111
3112                         if (pNormalBackgroundBitmap)
3113                         {
3114                                 pColorReplacedBitmap = _BitmapImpl::GetColorReplacedBitmapN(*pNormalBackgroundBitmap,
3115                                                 Color::GetColor(COLOR_ID_MAGENTA), __buttonBackgroundColor[_BUTTON_STATUS_NORMAL]);
3116                                 pButton->SetBackgroundBitmap(_BUTTON_STATUS_NORMAL, *pColorReplacedBitmap);
3117                                 delete pColorReplacedBitmap;
3118
3119                                 pColorReplacedBitmap = _BitmapImpl::GetColorReplacedBitmapN(*pNormalBackgroundBitmap,
3120                                                 Color::GetColor(COLOR_ID_MAGENTA), __buttonBackgroundColor[_BUTTON_STATUS_PRESSED]);
3121                                 pButton->SetBackgroundBitmap(_BUTTON_STATUS_PRESSED, *pColorReplacedBitmap);
3122                                 delete pColorReplacedBitmap;
3123
3124                                 pColorReplacedBitmap = _BitmapImpl::GetColorReplacedBitmapN(*pNormalBackgroundBitmap,
3125                                                 Color::GetColor(COLOR_ID_MAGENTA), __buttonBackgroundColor[_BUTTON_STATUS_HIGHLIGHTED]);
3126                                 pButton->SetBackgroundBitmap(_BUTTON_STATUS_HIGHLIGHTED, *pColorReplacedBitmap);
3127                                 delete pColorReplacedBitmap;
3128
3129                                 pColorReplacedBitmap = _BitmapImpl::GetColorReplacedBitmapN(*pNormalBackgroundBitmap,
3130                                                 Color::GetColor(COLOR_ID_MAGENTA), __buttonBackgroundColor[_BUTTON_STATUS_DISABLED]);
3131                                 pButton->SetBackgroundBitmap(_BUTTON_STATUS_DISABLED, *pColorReplacedBitmap);
3132                                 delete pColorReplacedBitmap;
3133
3134                                 delete pNormalBackgroundBitmap;
3135                         }
3136                 }
3137         }
3138         else if (TOOLBAR_ITEM == buttonType)
3139         {
3140                 Bitmap* pNormalBackgroundBitmap = null;
3141                 Bitmap* pPressedBackgroundBitmap = null;
3142                 Bitmap* pNormalBackgroundEffectBitmap = null;
3143                 Bitmap* pPressedBackgroundEffectBitmap = null;
3144                 Bitmap* pColorReplacedBitmap = null;
3145
3146                 if (__style == TOOLBAR_TEXT || __style == TOOLBAR_ICON || __style == TOOLBAR_ICON_TEXT)
3147                 {
3148                         GET_BITMAP_CONFIG_N(FOOTER::BUTTON_ITEM_BG_NORMAL, BITMAP_PIXEL_FORMAT_ARGB8888, pNormalBackgroundBitmap);
3149                         GET_BITMAP_CONFIG_N(FOOTER::BUTTON_ITEM_BG_PRESSED, BITMAP_PIXEL_FORMAT_ARGB8888, pPressedBackgroundBitmap);
3150
3151                         bool themeNormalBackgroundBitmap = IS_CUSTOM_BITMAP(FOOTER::BUTTON_ITEM_BG_NORMAL);
3152                         if (!themeNormalBackgroundBitmap)
3153                         {
3154                                 GET_BITMAP_CONFIG_N(FOOTER::BUTTON_ITEM_BG_EFFECT_NORMAL, BITMAP_PIXEL_FORMAT_ARGB8888, pNormalBackgroundEffectBitmap);
3155                         }
3156
3157                         bool themePressedBackgroundBitmap = IS_CUSTOM_BITMAP(FOOTER::BUTTON_ITEM_BG_PRESSED);
3158                         if (!themePressedBackgroundBitmap)
3159                         {
3160                                 GET_BITMAP_CONFIG_N(FOOTER::BUTTON_ITEM_BG_EFFECT_PRESSED, BITMAP_PIXEL_FORMAT_ARGB8888, pPressedBackgroundEffectBitmap);
3161                         }
3162                 }
3163                 else if (__style == TOOLBAR_HEADER_SEGMENTED || __style == TOOLBAR_HEADER_SEGMENTED_WITH_TITLE || __style == TOOLBAR_SEGMENTED
3164                                 || __style == TOOLBAR_TAB || __style == TOOLBAR_TAB_WITH_TITLE || __style == TOOLBAR_TITLE)
3165                 {
3166                         GET_BITMAP_CONFIG_N(HEADER::TAB_ITEM_BG_NORMAL, BITMAP_PIXEL_FORMAT_ARGB8888, pNormalBackgroundBitmap);
3167
3168                         bool themeNormalBackgroundBitmap = IS_CUSTOM_BITMAP(HEADER::TAB_ITEM_BG_NORMAL);
3169                         if (!themeNormalBackgroundBitmap)
3170                         {
3171                                 GET_BITMAP_CONFIG_N(HEADER::TAB_ITEM_BG_EFFECT_PRESSED, BITMAP_PIXEL_FORMAT_ARGB8888, pPressedBackgroundBitmap);
3172                         }
3173                 }
3174                 else
3175                 {
3176                         GET_BITMAP_CONFIG_N(HEADER::TAB_ITEM_BG_NORMAL, BITMAP_PIXEL_FORMAT_ARGB8888, pNormalBackgroundBitmap);
3177                         bool themeNormalBackgroundBitmap = IS_CUSTOM_BITMAP(HEADER::TAB_ITEM_BG_NORMAL);
3178                         if (!themeNormalBackgroundBitmap)
3179                         {
3180                                 GET_BITMAP_CONFIG_N(HEADER::TAB_ITEM_BG_NORMAL, BITMAP_PIXEL_FORMAT_ARGB8888, pPressedBackgroundBitmap);
3181                         }
3182                 }
3183
3184                 if (pNormalBackgroundEffectBitmap)
3185                 {
3186                         pButton->SetBackgroundEffectBitmap(_BUTTON_STATUS_NORMAL, *pNormalBackgroundEffectBitmap);
3187                         pButton->SetBackgroundEffectBitmap(_BUTTON_STATUS_HIGHLIGHTED, *pNormalBackgroundEffectBitmap);
3188                         pButton->SetBackgroundEffectBitmap(_BUTTON_STATUS_DISABLED, *pNormalBackgroundEffectBitmap);
3189                         delete pNormalBackgroundEffectBitmap;
3190                 }
3191
3192                 if (pPressedBackgroundEffectBitmap)
3193                 {
3194                         pButton->SetBackgroundEffectBitmap(_BUTTON_STATUS_PRESSED, *pPressedBackgroundEffectBitmap);
3195                         pButton->SetBackgroundEffectBitmap(_BUTTON_STATUS_SELECTED, *pPressedBackgroundEffectBitmap);
3196                         delete pPressedBackgroundEffectBitmap;
3197                 }
3198
3199                 if (__transparent)
3200                 {
3201                         pButton->SetTextColor(_BUTTON_STATUS_NORMAL, __itemTransTextColor[_BUTTON_STATUS_NORMAL]);
3202                         pButton->SetTextColor(_BUTTON_STATUS_PRESSED, __itemTransTextColor[_BUTTON_STATUS_PRESSED]);
3203                         pButton->SetTextColor(_BUTTON_STATUS_HIGHLIGHTED, __itemTransTextColor[_BUTTON_STATUS_HIGHLIGHTED]);
3204                         pButton->SetTextColor(_BUTTON_STATUS_DISABLED, __itemTransTextColor[_BUTTON_STATUS_DISABLED]);
3205                         pButton->SetTextColor(_BUTTON_STATUS_SELECTED, __itemTransTextColor[_BUTTON_STATUS_SELECTED]);
3206
3207                         if (pNormalBackgroundBitmap)
3208                         {
3209                                 pColorReplacedBitmap = _BitmapImpl::GetColorReplacedBitmapN(*pNormalBackgroundBitmap,
3210                                                 Color::GetColor(COLOR_ID_MAGENTA), __itemTransBackgroundColor[_BUTTON_STATUS_NORMAL]);
3211                                 pButton->SetBackgroundBitmap(_BUTTON_STATUS_NORMAL, *pColorReplacedBitmap);
3212                                 delete pColorReplacedBitmap;
3213
3214                                 pColorReplacedBitmap = _BitmapImpl::GetColorReplacedBitmapN(*pNormalBackgroundBitmap,
3215                                                 Color::GetColor(COLOR_ID_MAGENTA), __itemTransBackgroundColor[_BUTTON_STATUS_SELECTED]);
3216                                 pButton->SetBackgroundBitmap(_BUTTON_STATUS_SELECTED, *pColorReplacedBitmap);
3217                                 delete pColorReplacedBitmap;
3218
3219                                 pColorReplacedBitmap = _BitmapImpl::GetColorReplacedBitmapN(*pNormalBackgroundBitmap,
3220                                                 Color::GetColor(COLOR_ID_MAGENTA), __itemTransBackgroundColor[_BUTTON_STATUS_HIGHLIGHTED]);
3221                                 pButton->SetBackgroundBitmap(_BUTTON_STATUS_HIGHLIGHTED, *pColorReplacedBitmap);
3222                                 delete pColorReplacedBitmap;
3223
3224                                 pColorReplacedBitmap = _BitmapImpl::GetColorReplacedBitmapN(*pNormalBackgroundBitmap,
3225                                                 Color::GetColor(COLOR_ID_MAGENTA), __itemTransBackgroundColor[_BUTTON_STATUS_DISABLED]);
3226                                 pButton->SetBackgroundBitmap(_BUTTON_STATUS_DISABLED, *pColorReplacedBitmap);
3227                                 delete pColorReplacedBitmap;
3228
3229                                 delete pNormalBackgroundBitmap;
3230                         }
3231
3232                         if (pPressedBackgroundBitmap)
3233                         {
3234                                 pColorReplacedBitmap = _BitmapImpl::GetColorReplacedBitmapN(*pPressedBackgroundBitmap,
3235                                                 Color::GetColor(COLOR_ID_MAGENTA), __itemTransBackgroundColor[_BUTTON_STATUS_PRESSED]);
3236
3237                                 pButton->SetBackgroundBitmap(_BUTTON_STATUS_PRESSED, *pColorReplacedBitmap);
3238                                 delete pColorReplacedBitmap;
3239
3240                                 delete pPressedBackgroundBitmap;
3241                         }
3242                 }
3243                 else
3244                 {
3245                         pButton->SetTextColor(_BUTTON_STATUS_NORMAL, __itemTextColor[_BUTTON_STATUS_NORMAL]);
3246                         pButton->SetTextColor(_BUTTON_STATUS_PRESSED, __itemTextColor[_BUTTON_STATUS_PRESSED]);
3247                         pButton->SetTextColor(_BUTTON_STATUS_HIGHLIGHTED, __itemTextColor[_BUTTON_STATUS_HIGHLIGHTED]);
3248                         pButton->SetTextColor(_BUTTON_STATUS_DISABLED, __itemTextColor[_BUTTON_STATUS_DISABLED]);
3249                         pButton->SetTextColor(_BUTTON_STATUS_SELECTED, __itemTextColor[_BUTTON_STATUS_SELECTED]);
3250
3251                         if (pNormalBackgroundBitmap)
3252                         {
3253                                 pColorReplacedBitmap = _BitmapImpl::GetColorReplacedBitmapN(*pNormalBackgroundBitmap,
3254                                                 Color::GetColor(COLOR_ID_MAGENTA), __itemBackgroundColor[_BUTTON_STATUS_NORMAL]);
3255                                 pButton->SetBackgroundBitmap(_BUTTON_STATUS_NORMAL, *pColorReplacedBitmap);
3256                                 delete pColorReplacedBitmap;
3257
3258                                 pColorReplacedBitmap = _BitmapImpl::GetColorReplacedBitmapN(*pNormalBackgroundBitmap,
3259                                                 Color::GetColor(COLOR_ID_MAGENTA), __itemBackgroundColor[_BUTTON_STATUS_SELECTED]);
3260                                 pButton->SetBackgroundBitmap(_BUTTON_STATUS_SELECTED, *pColorReplacedBitmap);
3261                                 delete pColorReplacedBitmap;
3262
3263                                 pColorReplacedBitmap = _BitmapImpl::GetColorReplacedBitmapN(*pNormalBackgroundBitmap,
3264                                                 Color::GetColor(COLOR_ID_MAGENTA), __itemBackgroundColor[_BUTTON_STATUS_HIGHLIGHTED]);
3265                                 pButton->SetBackgroundBitmap(_BUTTON_STATUS_HIGHLIGHTED, *pColorReplacedBitmap);
3266                                 delete pColorReplacedBitmap;
3267
3268                                 pColorReplacedBitmap = _BitmapImpl::GetColorReplacedBitmapN(*pNormalBackgroundBitmap,
3269                                                 Color::GetColor(COLOR_ID_MAGENTA), __itemBackgroundColor[_BUTTON_STATUS_DISABLED]);
3270                                 pButton->SetBackgroundBitmap(_BUTTON_STATUS_DISABLED, *pColorReplacedBitmap);
3271                                 delete pColorReplacedBitmap;
3272
3273                                 delete pNormalBackgroundBitmap;
3274                         }
3275
3276                         if (pPressedBackgroundBitmap)
3277                         {
3278                                 pColorReplacedBitmap = _BitmapImpl::GetColorReplacedBitmapN(*pPressedBackgroundBitmap,
3279                                                 Color::GetColor(COLOR_ID_MAGENTA), __itemBackgroundColor[_BUTTON_STATUS_PRESSED]);
3280
3281                                 pButton->SetBackgroundBitmap(_BUTTON_STATUS_PRESSED, *pColorReplacedBitmap);
3282                                 delete pColorReplacedBitmap;
3283
3284                                 delete pPressedBackgroundBitmap;
3285                         }
3286                 }
3287         }
3288
3289         return E_SUCCESS;
3290 }
3291
3292 int
3293 _Toolbar::CalculateMinimumToolbarWidth(void)
3294 {
3295         float totalWidth = 0.0f;
3296         float itemMinimumWidth = 0.0f;
3297         float horizontalMargin = 0.0f;
3298
3299         if (__header == true && __style == TOOLBAR_TEXT)
3300         {
3301                 if (IsButtonSet(LEFT_BUTTON))
3302                 {
3303                         //if (__pButtonItems[LEFT_BUTTON]->GetText().IsEmpty())
3304                         //{
3305                                 GET_SHAPE_CONFIG(HEADER::BUTTON_ITEM_WIDTH, GetOrientation(), itemMinimumWidth);
3306                         //}
3307                         //else
3308                         //{
3309                         //      GET_SHAPE_CONFIG(HEADER::BUTTON_ITEM_WIDTH_WITH_TEXT, GetOrientation(), itemMinimumWidth);
3310                         //}
3311
3312                         totalWidth += itemMinimumWidth;
3313                 }
3314                 if (IsButtonSet(RIGHT_BUTTON))
3315                 {
3316                         //if (__pButtonItems[RIGHT_BUTTON]->GetText().IsEmpty())
3317                         //{
3318                                 GET_SHAPE_CONFIG(HEADER::BUTTON_ITEM_WIDTH, GetOrientation(), itemMinimumWidth);
3319                         //}
3320                         //else
3321                         //{
3322                         //      GET_SHAPE_CONFIG(HEADER::BUTTON_ITEM_WIDTH_WITH_TEXT, GetOrientation(), itemMinimumWidth);
3323                         //}
3324
3325                         totalWidth += itemMinimumWidth;
3326                 }
3327         }
3328         else // footer or HEADER_TITLE_BUTTON
3329         {
3330                 if (IsButtonSet(LEFT_BUTTON))
3331                 {
3332                         GET_SHAPE_CONFIG(FOOTER::BUTTON_ITEM_WIDTH, GetOrientation(), itemMinimumWidth);
3333                         totalWidth += itemMinimumWidth;
3334                 }
3335                 if (IsButtonSet(RIGHT_BUTTON))
3336                 {
3337                         GET_SHAPE_CONFIG(FOOTER::BUTTON_ITEM_WIDTH, GetOrientation(), itemMinimumWidth);
3338                         totalWidth += itemMinimumWidth;
3339                 }
3340                 else if (IsButtonSet(BACK_BUTTON))
3341                 {
3342                         GET_SHAPE_CONFIG(FOOTER::BUTTON_ITEM_WIDTH, GetOrientation(), itemMinimumWidth);
3343                         totalWidth += itemMinimumWidth;
3344                 }
3345         }
3346
3347         if (__style == TOOLBAR_TITLE)
3348         {
3349                 GET_SHAPE_CONFIG(HEADER::TITLE_MINIMUM_WIDTH, GetOrientation(), itemMinimumWidth);
3350                 totalWidth += itemMinimumWidth;
3351         }
3352         else if (__style == TOOLBAR_HEADER_SEGMENTED_WITH_TITLE || __style == TOOLBAR_HEADER_SEGMENTED)
3353         {
3354                 GET_SHAPE_CONFIG(HEADER::ITEM_MINIMUM_WIDTH, GetOrientation(), itemMinimumWidth);
3355                 GET_SHAPE_CONFIG(HEADER::COMMON_MINIMUM_MARGIN, GetOrientation(), horizontalMargin);
3356                 totalWidth += itemMinimumWidth * __itemCount + horizontalMargin * 2;
3357         }
3358         else if (__style == TOOLBAR_SEGMENTED)
3359         {
3360                 GET_SHAPE_CONFIG(FOOTER::ITEM_MINIMUM_WIDTH, GetOrientation(), itemMinimumWidth);
3361                 GET_SHAPE_CONFIG(FOOTER::COMMON_MINIMUM_MARGIN, GetOrientation(), horizontalMargin);
3362                 totalWidth += itemMinimumWidth * __itemCount + horizontalMargin * 2;
3363         }
3364         else
3365         {
3366                 GET_SHAPE_CONFIG(FOOTER::ITEM_MINIMUM_WIDTH, GetOrientation(), itemMinimumWidth);
3367
3368                 if ((__style == TOOLBAR_TAB || __style == TOOLBAR_TAB_WITH_TITLE) && __itemCount > 4)
3369                 {
3370                         totalWidth += itemMinimumWidth * 4;
3371                 }
3372                 else
3373                 {
3374                         totalWidth += itemMinimumWidth * __itemCount;
3375                 }
3376         }
3377
3378         return totalWidth;
3379 }
3380
3381 float
3382 _Toolbar::CalculateMinimumToolbarWidthF(void)
3383 {
3384         float totalWidth = 0.0f;
3385         float itemMinimumWidth = 0.0f;
3386         float horizontalMargin = 0.0f;
3387
3388         if (__header == true && __style == TOOLBAR_TEXT)
3389         {
3390                 if (IsButtonSet(LEFT_BUTTON))
3391                 {
3392                         //if (__pButtonItems[LEFT_BUTTON]->GetText().IsEmpty())
3393                         //{
3394                                 GET_SHAPE_CONFIG(HEADER::BUTTON_ITEM_WIDTH, GetOrientation(), itemMinimumWidth);
3395                         //}
3396                         //else
3397                         //{
3398                         //      GET_SHAPE_CONFIG(HEADER::BUTTON_ITEM_WIDTH_WITH_TEXT, GetOrientation(), itemMinimumWidth);
3399                         //}
3400
3401                         totalWidth += itemMinimumWidth;
3402                 }
3403                 if (IsButtonSet(RIGHT_BUTTON))
3404                 {
3405                         //if (__pButtonItems[RIGHT_BUTTON]->GetText().IsEmpty())
3406                         //{
3407                                 GET_SHAPE_CONFIG(HEADER::BUTTON_ITEM_WIDTH, GetOrientation(), itemMinimumWidth);
3408                         //}
3409                         //else
3410                         //{
3411                         //      GET_SHAPE_CONFIG(HEADER::BUTTON_ITEM_WIDTH_WITH_TEXT, GetOrientation(), itemMinimumWidth);
3412                         //}
3413
3414                         totalWidth += itemMinimumWidth;
3415                 }
3416         }
3417         else // footer or HEADER_TITLE_BUTTON
3418         {
3419                 if (IsButtonSet(LEFT_BUTTON))
3420                 {
3421                         GET_SHAPE_CONFIG(FOOTER::BUTTON_ITEM_WIDTH, GetOrientation(), itemMinimumWidth);
3422                         totalWidth += itemMinimumWidth;
3423                 }
3424                 if (IsButtonSet(RIGHT_BUTTON))
3425                 {
3426                         GET_SHAPE_CONFIG(FOOTER::BUTTON_ITEM_WIDTH, GetOrientation(), itemMinimumWidth);
3427                         totalWidth += itemMinimumWidth;
3428                 }
3429                 else if (IsButtonSet(BACK_BUTTON))
3430                 {
3431                         GET_SHAPE_CONFIG(FOOTER::BUTTON_ITEM_WIDTH, GetOrientation(), itemMinimumWidth);
3432                         totalWidth += itemMinimumWidth;
3433                 }
3434         }
3435
3436         if (__style == TOOLBAR_TITLE)
3437         {
3438                 GET_SHAPE_CONFIG(HEADER::TITLE_MINIMUM_WIDTH, GetOrientation(), itemMinimumWidth);
3439                 totalWidth += itemMinimumWidth;
3440         }
3441         else if (__style == TOOLBAR_HEADER_SEGMENTED_WITH_TITLE || __style == TOOLBAR_HEADER_SEGMENTED)
3442         {
3443                 GET_SHAPE_CONFIG(HEADER::ITEM_MINIMUM_WIDTH, GetOrientation(), itemMinimumWidth);
3444                 GET_SHAPE_CONFIG(HEADER::COMMON_MINIMUM_MARGIN, GetOrientation(), horizontalMargin);
3445                 totalWidth += itemMinimumWidth * __itemCount + horizontalMargin * 2;
3446         }
3447         else if (__style == TOOLBAR_SEGMENTED)
3448         {
3449                 GET_SHAPE_CONFIG(FOOTER::ITEM_MINIMUM_WIDTH, GetOrientation(), itemMinimumWidth);
3450                 GET_SHAPE_CONFIG(FOOTER::COMMON_MINIMUM_MARGIN, GetOrientation(), horizontalMargin);
3451                 totalWidth += itemMinimumWidth * __itemCount + horizontalMargin * 2;
3452         }
3453         else
3454         {
3455                 GET_SHAPE_CONFIG(FOOTER::ITEM_MINIMUM_WIDTH, GetOrientation(), itemMinimumWidth);
3456
3457                 if ((__style == TOOLBAR_TAB || __style == TOOLBAR_TAB_WITH_TITLE) && __itemCount > 4)
3458                 {
3459                         totalWidth += itemMinimumWidth * 4;
3460                 }
3461                 else
3462                 {
3463                         totalWidth += itemMinimumWidth * __itemCount;
3464                 }
3465         }
3466
3467         return totalWidth;
3468 }
3469
3470 result
3471 _Toolbar::RealignItem(_Button* pButton, float textExtentSize)
3472 {
3473         SysTryReturnResult(NID_UI_CTRL, pButton, E_INVALID_STATE, "[E_INVALID_STATE] pButton doesn't exist.");
3474
3475         float buttonItemWidth = pButton->GetSizeF().width;
3476         float buttonItemHeight = pButton->GetSizeF().height;
3477         float sideMargin = 0.0f;
3478         float buttonTextTopMargin = 0.0f;
3479         float iconTextGap = 0.0f;
3480         float contentLength = 0.0f;
3481         float segmentedTextAreaHeight = 0.0f;
3482         float revisedTopMargin = 5.0f;
3483
3484         float leftTouchMargin = pButton->GetLeftTouchMarginF();
3485         float topTouchMargin = pButton->GetTopTouchMarginF();
3486         float rightTouchMargin = pButton->GetRightTouchMarginF();
3487         float bottomTouchMargin = pButton->GetBottomTouchMarginF();
3488
3489         GET_SHAPE_CONFIG(FOOTER::BUTTON_ITEM_TEXT_LEFT_MARGIN, GetOrientation(), sideMargin);
3490         GET_SHAPE_CONFIG(HEADER::ICON_TEXT_GAP, GetOrientation(), iconTextGap);
3491         GET_SHAPE_CONFIG(HEADER::SEGMENTED_ITEM_HEIGHT, GetOrientation(), segmentedTextAreaHeight);
3492
3493         if (__style == TOOLBAR_TEXT || __style == TOOLBAR_ICON || __style == TOOLBAR_ICON_TEXT)
3494         {
3495                 GET_SHAPE_CONFIG(FOOTER::FOOTER_ITEM_BUTTON_STYLE_SIDE_MARGIN, GetOrientation(), sideMargin);
3496                 GET_SHAPE_CONFIG(FOOTER::BUTTON_ITEM_TEXT_TOP_MARGIN, GetOrientation(), buttonTextTopMargin);
3497         }
3498         else if (__style == TOOLBAR_HEADER_SEGMENTED || __style == TOOLBAR_SEGMENTED || __style == TOOLBAR_TAB)
3499         {
3500                 GET_SHAPE_CONFIG(FOOTER::BUTTON_ITEM_TEXT_LEFT_MARGIN, GetOrientation(), sideMargin);
3501
3502                 buttonTextTopMargin = (buttonItemHeight - segmentedTextAreaHeight) / 2 - revisedTopMargin;
3503         }
3504         else if (__style == TOOLBAR_HEADER_SEGMENTED_WITH_TITLE || __style == TOOLBAR_TAB_WITH_TITLE)
3505         {
3506                 GET_SHAPE_CONFIG(FOOTER::BUTTON_ITEM_TEXT_LEFT_MARGIN, GetOrientation(), sideMargin);
3507
3508                 buttonTextTopMargin = 0;
3509         }
3510
3511         if (pButton->GetText() != L"")
3512         {
3513                 float iconAreaWidth = 0.0f;
3514
3515                 if (pButton->GetBitmap(_BUTTON_STATUS_NORMAL) != null)
3516                 {
3517                         iconAreaWidth = pButton->GetBitmap(_BUTTON_STATUS_NORMAL)->GetWidthF();
3518                         contentLength = iconAreaWidth + iconTextGap + textExtentSize;
3519
3520                         if (contentLength > buttonItemWidth - sideMargin * 2)
3521                         {
3522                                 contentLength = buttonItemWidth - sideMargin * 2;
3523                         }
3524
3525                         pButton->SetBitmap(_BUTTON_STATUS_NORMAL,
3526                                         FloatPoint((buttonItemWidth - contentLength) / 2, (buttonItemHeight - (pButton->GetBitmap(_BUTTON_STATUS_NORMAL))->GetHeightF()) / 2),
3527                                                         *(pButton->GetBitmap(_BUTTON_STATUS_NORMAL)));
3528                 }
3529                 if (pButton->GetBitmap(_BUTTON_STATUS_PRESSED) != null)
3530                 {
3531                         iconAreaWidth = pButton->GetBitmap(_BUTTON_STATUS_PRESSED)->GetWidthF();
3532                         contentLength = iconAreaWidth + iconTextGap + textExtentSize;
3533
3534                         if (contentLength > buttonItemWidth - sideMargin * 2)
3535                         {
3536                                 contentLength = buttonItemWidth - sideMargin * 2;
3537                         }
3538
3539                         pButton->SetBitmap(_BUTTON_STATUS_PRESSED,
3540                                         FloatPoint((buttonItemWidth - contentLength) / 2, (buttonItemHeight - (pButton->GetBitmap(_BUTTON_STATUS_PRESSED))->GetHeightF()) / 2),
3541                                                         *(pButton->GetBitmap(_BUTTON_STATUS_PRESSED)));
3542                 }
3543                 if (pButton->GetBitmap(_BUTTON_STATUS_SELECTED) != null)
3544                 {
3545                         iconAreaWidth = pButton->GetBitmap(_BUTTON_STATUS_SELECTED)->GetWidthF();
3546                         contentLength = iconAreaWidth + iconTextGap + textExtentSize;
3547
3548                         if (contentLength > buttonItemWidth - sideMargin * 2)
3549                         {
3550                                 contentLength = buttonItemWidth - sideMargin * 2;
3551                         }
3552
3553                         pButton->SetBitmap(_BUTTON_STATUS_SELECTED,
3554                                         FloatPoint((buttonItemWidth - contentLength) / 2, (buttonItemHeight - (pButton->GetBitmap(_BUTTON_STATUS_SELECTED))->GetHeightF()) / 2),
3555                                                         *(pButton->GetBitmap(_BUTTON_STATUS_SELECTED)));
3556                 }
3557                 if (pButton->GetBitmap(_BUTTON_STATUS_HIGHLIGHTED) != null)
3558                 {
3559                         iconAreaWidth = pButton->GetBitmap(_BUTTON_STATUS_HIGHLIGHTED)->GetWidthF();
3560                         contentLength = iconAreaWidth + iconTextGap + textExtentSize;
3561
3562                         if (contentLength > buttonItemWidth - sideMargin * 2)
3563                         {
3564                                 contentLength = buttonItemWidth - sideMargin * 2;
3565                         }
3566
3567                         pButton->SetBitmap(_BUTTON_STATUS_HIGHLIGHTED,
3568                                         FloatPoint((buttonItemWidth - contentLength) / 2, (buttonItemHeight - (pButton->GetBitmap(_BUTTON_STATUS_HIGHLIGHTED))->GetHeightF()) / 2),
3569                                                         *(pButton->GetBitmap(_BUTTON_STATUS_HIGHLIGHTED)));
3570                 }
3571                 if (pButton->GetBitmap(_BUTTON_STATUS_DISABLED) != null)
3572                 {
3573                         iconAreaWidth = pButton->GetBitmap(_BUTTON_STATUS_DISABLED)->GetWidthF();
3574                         contentLength = iconAreaWidth + iconTextGap + textExtentSize;
3575
3576                         if (contentLength > buttonItemWidth - sideMargin * 2)
3577                         {
3578                                 contentLength = buttonItemWidth - sideMargin * 2;
3579                         }
3580
3581                         pButton->SetBitmap(_BUTTON_STATUS_DISABLED,
3582                                         FloatPoint((buttonItemWidth - contentLength) / 2, (buttonItemHeight - (pButton->GetBitmap(_BUTTON_STATUS_DISABLED))->GetHeightF()) / 2),
3583                                                         *(pButton->GetBitmap(_BUTTON_STATUS_DISABLED)));
3584                 }
3585
3586                 if (iconAreaWidth != 0)
3587                 {
3588                         pButton->SetTextHorizontalAlignment(ALIGNMENT_LEFT);
3589                         pButton->SetUserDefinedTextArea(FloatRectangle((buttonItemWidth - contentLength) / 2 + iconAreaWidth + iconTextGap, buttonTextTopMargin, buttonItemWidth - iconAreaWidth - iconTextGap - sideMargin * 2, buttonItemHeight - buttonTextTopMargin * 2));
3590                 }
3591                 else
3592                 {
3593                         pButton->SetUserDefinedTextArea(FloatRectangle(sideMargin, buttonTextTopMargin, buttonItemWidth - sideMargin * 2, buttonItemHeight - buttonTextTopMargin * 2));
3594                 }
3595         }
3596         else
3597         {
3598                 if (pButton->GetBitmap(_BUTTON_STATUS_NORMAL) != null)
3599                 {
3600                         pButton->SetBitmap(_BUTTON_STATUS_NORMAL,
3601                                         FloatPoint((buttonItemWidth - (leftTouchMargin + rightTouchMargin) - (pButton->GetBitmap(_BUTTON_STATUS_NORMAL))->GetWidthF()) / 2,
3602                                                         (buttonItemHeight - (topTouchMargin + bottomTouchMargin) - (pButton->GetBitmap(_BUTTON_STATUS_NORMAL))->GetHeightF()) / 2),
3603                                                         *(pButton->GetBitmap(_BUTTON_STATUS_NORMAL)));
3604                 }
3605                 if (pButton->GetBitmap(_BUTTON_STATUS_PRESSED) != null)
3606                 {
3607                         pButton->SetBitmap(_BUTTON_STATUS_PRESSED,
3608                                         FloatPoint((buttonItemWidth - (leftTouchMargin + rightTouchMargin) - (pButton->GetBitmap(_BUTTON_STATUS_PRESSED))->GetWidthF()) / 2,
3609                                                         (buttonItemHeight - (topTouchMargin + bottomTouchMargin) - (pButton->GetBitmap(_BUTTON_STATUS_PRESSED))->GetHeightF()) / 2),
3610                                                         *(pButton->GetBitmap(_BUTTON_STATUS_PRESSED)));
3611                 }
3612                 if (pButton->GetBitmap(_BUTTON_STATUS_HIGHLIGHTED) != null)
3613                 {
3614                         pButton->SetBitmap(_BUTTON_STATUS_HIGHLIGHTED,
3615                                         FloatPoint((buttonItemWidth - (leftTouchMargin + rightTouchMargin) - (pButton->GetBitmap(_BUTTON_STATUS_HIGHLIGHTED))->GetWidthF()) / 2,
3616                                                         (buttonItemHeight - (topTouchMargin + bottomTouchMargin) - (pButton->GetBitmap(_BUTTON_STATUS_HIGHLIGHTED))->GetHeightF()) / 2),
3617                                                         *(pButton->GetBitmap(_BUTTON_STATUS_HIGHLIGHTED)));
3618                 }
3619                 if (pButton->GetBitmap(_BUTTON_STATUS_DISABLED) != null)
3620                 {
3621                         pButton->SetBitmap(_BUTTON_STATUS_DISABLED,
3622                                         FloatPoint((buttonItemWidth - (leftTouchMargin + rightTouchMargin) - (pButton->GetBitmap(_BUTTON_STATUS_DISABLED))->GetWidthF()) / 2,
3623                                                         (buttonItemHeight - (topTouchMargin + bottomTouchMargin) - (pButton->GetBitmap(_BUTTON_STATUS_DISABLED))->GetHeightF()) / 2),
3624                                                         *(pButton->GetBitmap(_BUTTON_STATUS_DISABLED)));
3625                 }
3626                 if (pButton->GetBitmap(_BUTTON_STATUS_SELECTED) != null)
3627                 {
3628                         pButton->SetBitmap(_BUTTON_STATUS_SELECTED,
3629                                         FloatPoint((buttonItemWidth - (leftTouchMargin + rightTouchMargin) - (pButton->GetBitmap(_BUTTON_STATUS_SELECTED))->GetWidthF()) / 2,
3630                                                         (buttonItemHeight - (topTouchMargin + bottomTouchMargin) - (pButton->GetBitmap(_BUTTON_STATUS_SELECTED))->GetHeightF()) / 2),
3631                                                         *(pButton->GetBitmap(_BUTTON_STATUS_SELECTED)));
3632                 }
3633
3634                 pButton->SetMargin(sideMargin, buttonTextTopMargin, sideMargin, buttonTextTopMargin);
3635         }
3636
3637         return E_SUCCESS;
3638 }
3639
3640 result
3641 _Toolbar::RealignButtonItem(_Button* pButton)
3642 {
3643         SysTryReturnResult(NID_UI_CTRL, pButton, E_INVALID_STATE, "[E_INVALID_STATE] pButton doesn't exist.");
3644
3645         float buttonItemWidth = pButton->GetSizeF().width;
3646         float buttonItemHeight = pButton->GetSizeF().height;
3647
3648         float leftTouchMargin = pButton->GetLeftTouchMarginF();
3649         float topTouchMargin = pButton->GetTopTouchMarginF();
3650         float rightTouchMargin = pButton->GetRightTouchMarginF();
3651         float bottomTouchMargin = pButton->GetBottomTouchMarginF();
3652
3653         if (pButton->GetBitmap(_BUTTON_STATUS_NORMAL) != null)
3654         {
3655                 pButton->SetBitmap(_BUTTON_STATUS_NORMAL,
3656                                 FloatPoint((buttonItemWidth - (leftTouchMargin + rightTouchMargin) - (pButton->GetBitmap(_BUTTON_STATUS_NORMAL))->GetWidthF()) / 2,
3657                                                 (buttonItemHeight - (topTouchMargin + bottomTouchMargin) - (pButton->GetBitmap(_BUTTON_STATUS_NORMAL))->GetHeightF()) / 2),
3658                                                 *(pButton->GetBitmap(_BUTTON_STATUS_NORMAL)));
3659         }
3660         if (pButton->GetBitmap(_BUTTON_STATUS_PRESSED) != null)
3661         {
3662                 pButton->SetBitmap(_BUTTON_STATUS_PRESSED,
3663                                 FloatPoint((buttonItemWidth - (leftTouchMargin + rightTouchMargin) - (pButton->GetBitmap(_BUTTON_STATUS_PRESSED))->GetWidthF()) / 2,
3664                                                 (buttonItemHeight - (topTouchMargin + bottomTouchMargin) - (pButton->GetBitmap(_BUTTON_STATUS_PRESSED))->GetHeightF()) / 2),
3665                                                 *(pButton->GetBitmap(_BUTTON_STATUS_PRESSED)));
3666         }
3667         if (pButton->GetBitmap(_BUTTON_STATUS_HIGHLIGHTED) != null)
3668         {
3669                 pButton->SetBitmap(_BUTTON_STATUS_HIGHLIGHTED,
3670                                 FloatPoint((buttonItemWidth - (leftTouchMargin + rightTouchMargin) - (pButton->GetBitmap(_BUTTON_STATUS_HIGHLIGHTED))->GetWidthF()) / 2,
3671                                                 (buttonItemHeight - (topTouchMargin + bottomTouchMargin) - (pButton->GetBitmap(_BUTTON_STATUS_HIGHLIGHTED))->GetHeightF()) / 2),
3672                                                 *(pButton->GetBitmap(_BUTTON_STATUS_HIGHLIGHTED)));
3673         }
3674         if (pButton->GetBitmap(_BUTTON_STATUS_DISABLED) != null)
3675         {
3676                 pButton->SetBitmap(_BUTTON_STATUS_DISABLED,
3677                                 FloatPoint((buttonItemWidth - (leftTouchMargin + rightTouchMargin) - (pButton->GetBitmap(_BUTTON_STATUS_DISABLED))->GetWidthF()) / 2,
3678                                                 (buttonItemHeight - (topTouchMargin + bottomTouchMargin) - (pButton->GetBitmap(_BUTTON_STATUS_DISABLED))->GetHeightF()) / 2),
3679                                                 *(pButton->GetBitmap(_BUTTON_STATUS_DISABLED)));
3680         }
3681         if (pButton->GetBitmap(_BUTTON_STATUS_SELECTED) != null)
3682         {
3683                 pButton->SetBitmap(_BUTTON_STATUS_SELECTED,
3684                                 FloatPoint((buttonItemWidth - (leftTouchMargin + rightTouchMargin) - (pButton->GetBitmap(_BUTTON_STATUS_SELECTED))->GetWidthF()) / 2,
3685                                                 (buttonItemHeight - (topTouchMargin + bottomTouchMargin) - (pButton->GetBitmap(_BUTTON_STATUS_SELECTED))->GetHeightF()) / 2),
3686                                                 *(pButton->GetBitmap(_BUTTON_STATUS_SELECTED)));
3687         }
3688
3689         if (pButton->GetEffectBitmap(_BUTTON_STATUS_NORMAL) != null)
3690         {
3691                 pButton->SetEffectBitmap(_BUTTON_STATUS_NORMAL,
3692                                 FloatPoint((buttonItemWidth - (leftTouchMargin + rightTouchMargin) - (pButton->GetEffectBitmap(_BUTTON_STATUS_NORMAL))->GetWidthF()) / 2,
3693                                                 (buttonItemHeight - (topTouchMargin + bottomTouchMargin) - (pButton->GetEffectBitmap(_BUTTON_STATUS_NORMAL))->GetHeightF()) / 2),
3694                                                 *(pButton->GetEffectBitmap(_BUTTON_STATUS_NORMAL)));
3695         }
3696
3697         if (pButton->GetEffectBitmap(_BUTTON_STATUS_PRESSED) != null)
3698         {
3699                 pButton->SetEffectBitmap(_BUTTON_STATUS_PRESSED,
3700                                 FloatPoint((buttonItemWidth - (leftTouchMargin + rightTouchMargin) - (pButton->GetEffectBitmap(_BUTTON_STATUS_PRESSED))->GetWidthF()) / 2,
3701                                                 (buttonItemHeight - (topTouchMargin + bottomTouchMargin) - (pButton->GetEffectBitmap(_BUTTON_STATUS_PRESSED))->GetHeightF()) / 2),
3702                                                 *(pButton->GetEffectBitmap(_BUTTON_STATUS_PRESSED)));
3703         }
3704         if (pButton->GetEffectBitmap(_BUTTON_STATUS_HIGHLIGHTED) != null)
3705         {
3706                 pButton->SetEffectBitmap(_BUTTON_STATUS_HIGHLIGHTED,
3707                                 FloatPoint((buttonItemWidth - (leftTouchMargin + rightTouchMargin) - (pButton->GetEffectBitmap(_BUTTON_STATUS_HIGHLIGHTED))->GetWidthF()) / 2,
3708                                                 (buttonItemHeight - (topTouchMargin + bottomTouchMargin) - (pButton->GetEffectBitmap(_BUTTON_STATUS_HIGHLIGHTED))->GetHeightF()) / 2),
3709                                                 *(pButton->GetEffectBitmap(_BUTTON_STATUS_HIGHLIGHTED)));
3710         }
3711         if (pButton->GetEffectBitmap(_BUTTON_STATUS_DISABLED) != null)
3712         {
3713                 pButton->SetEffectBitmap(_BUTTON_STATUS_DISABLED,
3714                                 FloatPoint((buttonItemWidth - (leftTouchMargin + rightTouchMargin) - (pButton->GetEffectBitmap(_BUTTON_STATUS_DISABLED))->GetWidthF()) / 2,
3715                                                 (buttonItemHeight - (topTouchMargin + bottomTouchMargin) - (pButton->GetEffectBitmap(_BUTTON_STATUS_DISABLED))->GetHeightF()) / 2),
3716                                                 *(pButton->GetEffectBitmap(_BUTTON_STATUS_DISABLED)));
3717         }
3718         if (pButton->GetEffectBitmap(_BUTTON_STATUS_SELECTED) != null)
3719         {
3720                 pButton->SetEffectBitmap(_BUTTON_STATUS_SELECTED,
3721                                 FloatPoint((buttonItemWidth - (leftTouchMargin + rightTouchMargin) - (pButton->GetEffectBitmap(_BUTTON_STATUS_SELECTED))->GetWidthF()) / 2,
3722                                                 (buttonItemHeight - (topTouchMargin + bottomTouchMargin) - (pButton->GetEffectBitmap(_BUTTON_STATUS_SELECTED))->GetHeightF()) / 2),
3723                                                 *(pButton->GetEffectBitmap(_BUTTON_STATUS_SELECTED)));
3724         }
3725
3726         return E_SUCCESS;
3727 }
3728
3729 result
3730 _Toolbar::RearrangeItems(void)
3731 {
3732         __titleTextArea = _Control::GetBoundsF();
3733
3734         const FloatDimension portraitSize = _ControlManager::GetInstance()->_ControlManager::GetScreenSizeF();
3735         const FloatDimension landscapeSize = FloatDimension(portraitSize.height, portraitSize.width);
3736
3737         if (CalculateMinimumToolbarWidth() > __titleTextArea.width)
3738         {
3739                 __titleTextArea.width = CalculateMinimumToolbarWidth();
3740         }
3741
3742         if (GetOrientation() == _CONTROL_ORIENTATION_PORTRAIT)
3743         {
3744                 if (__titleTextArea.width > portraitSize.width)
3745                 {
3746                         __titleTextArea.width = portraitSize.width;
3747                 }
3748         }
3749         else
3750         {
3751                 if (__titleTextArea.width > landscapeSize.width)
3752                 {
3753                         __titleTextArea.width = landscapeSize.width;
3754                 }
3755         }
3756
3757         __itemArea = __titleTextArea;
3758
3759         if (__header == true && __style != TOOLBAR_TEXT) // right align
3760         {
3761                 float headerLeftButtonWidth = 0.0f;
3762                 float headerRightButtonWidth = 0.0f;
3763                 float headerTopMargin = 0.0f;
3764                 float vmargin = 0.0f;
3765                 float buttonItemGap = 0.0f;
3766                 float headerButtonItemHeight = 0.0f;
3767                 float headerLeftMargin = 0.0f;
3768                 float headerRightMargin = 0.0f;
3769                 float tabLeftMargin = 0.0f;
3770
3771                 float leftTouchMargin = 0.0f;
3772                 float topTouchMargin = 0.0f;
3773                 float rightTouchMargin = 0.0f;
3774                 float bottomTouchMargin = 0.0f;
3775
3776                 GET_SHAPE_CONFIG(HEADER::TOP_MARGIN, GetOrientation(), headerTopMargin);
3777                 GET_SHAPE_CONFIG(HEADER::BUTTON_ITEM_GAP, GetOrientation(), buttonItemGap);
3778                 GET_SHAPE_CONFIG(HEADER::LEFT_MARGIN, GetOrientation(), headerLeftMargin);
3779                 GET_SHAPE_CONFIG(HEADER::RIGHT_MARGIN, GetOrientation(), headerRightMargin);
3780                 GET_SHAPE_CONFIG(HEADER::TAB_LEFT_MARGIN, GetOrientation(), tabLeftMargin);
3781
3782                 GET_SHAPE_CONFIG(HEADER::BUTTON_ITEM_LEFT_TOUCH_MARGIN, GetOrientation(), leftTouchMargin);
3783                 GET_SHAPE_CONFIG(HEADER::BUTTON_ITEM_TOP_TOUCH_MARGIN, GetOrientation(), topTouchMargin);
3784                 GET_SHAPE_CONFIG(HEADER::BUTTON_ITEM_RIGHT_TOUCH_MARGIN, GetOrientation(), rightTouchMargin);
3785                 GET_SHAPE_CONFIG(HEADER::BUTTON_ITEM_BOTTOM_TOUCH_MARGIN, GetOrientation(), bottomTouchMargin);
3786
3787                 if (__pButtonItems[LEFT_BUTTON])
3788                 {
3789                         headerLeftButtonWidth = __pButtonItems[LEFT_BUTTON]->GetSizeF().width;
3790                 }
3791
3792                 if (__pButtonItems[RIGHT_BUTTON])
3793                 {
3794                         headerRightButtonWidth = __pButtonItems[RIGHT_BUTTON]->GetSizeF().width;
3795                 }
3796
3797                 if (__style == TOOLBAR_HEADER_SEGMENTED_WITH_TITLE || __style == TOOLBAR_TAB_WITH_TITLE)
3798                 {
3799                         GET_SHAPE_CONFIG(HEADER::TITLE_HEIGHT_WITH_SEGMENTED_ITEM, GetOrientation(), vmargin);
3800                         GET_SHAPE_CONFIG(HEADER::SEGMENTED_ITEM_HEIGHT, GetOrientation(), headerButtonItemHeight);
3801                 }
3802                 else
3803                 {
3804                         GET_SHAPE_CONFIG(HEADER::BUTTON_ITEM_TOP_MARGIN, GetOrientation(), vmargin);
3805                         GET_SHAPE_CONFIG(HEADER::BUTTON_ITEM_HEIGHT, GetOrientation(), headerButtonItemHeight);
3806                 }
3807
3808                 __titleTextArea.x = headerLeftMargin;
3809                 __titleTextArea.y = headerTopMargin;
3810
3811                 if (__pButtonItems[RIGHT_BUTTON])
3812                 {
3813                         if (__pButtonItems[LEFT_BUTTON])
3814                         {
3815                                 if (__pButtonItems[LEFT_BUTTON]->GetText() == L"")
3816                                 {
3817                                         if (__pButtonItems[RIGHT_BUTTON]->GetText() == L"")
3818                                         {
3819                                                 __pButtonItems[RIGHT_BUTTON]->SetBounds(FloatRectangle(__titleTextArea.width - headerRightButtonWidth - headerRightMargin + rightTouchMargin, vmargin,
3820                                                                 headerRightButtonWidth, headerButtonItemHeight));
3821                                                 __pButtonItems[LEFT_BUTTON]->SetBounds(FloatRectangle(__titleTextArea.width - headerRightButtonWidth - headerLeftButtonWidth - headerRightMargin + rightTouchMargin, vmargin,
3822                                                                 headerLeftButtonWidth, headerButtonItemHeight));
3823
3824                                                 if (__style == TOOLBAR_HEADER_SEGMENTED_WITH_TITLE || __style == TOOLBAR_TAB_WITH_TITLE)
3825                                                 {
3826                                                         __pButtonItems[RIGHT_BUTTON]->SetTouchMargin(leftTouchMargin, 0.0f, rightTouchMargin, 0.0f);
3827                                                         __pButtonItems[LEFT_BUTTON]->SetTouchMargin(leftTouchMargin, 0.0f, rightTouchMargin, 0.0f);
3828
3829                                                         __itemArea.width -= (headerLeftButtonWidth + headerRightButtonWidth + headerLeftMargin - leftTouchMargin * 2);
3830                                                 }
3831                                                 else
3832                                                 {
3833                                                         __pButtonItems[RIGHT_BUTTON]->SetTouchMargin(leftTouchMargin, topTouchMargin, rightTouchMargin, bottomTouchMargin);
3834                                                         __pButtonItems[LEFT_BUTTON]->SetTouchMargin(leftTouchMargin, topTouchMargin, rightTouchMargin, bottomTouchMargin);
3835
3836                                                         __titleTextArea.width -= (headerLeftButtonWidth + headerRightButtonWidth + headerLeftMargin - leftTouchMargin * 2);
3837                                                         __itemArea.width -= (headerLeftButtonWidth + headerRightButtonWidth + headerLeftMargin - leftTouchMargin * 2);
3838                                                 }
3839                                         }
3840                                         else
3841                                         {
3842                                                 __pButtonItems[RIGHT_BUTTON]->SetBounds(FloatRectangle(__titleTextArea.width - headerRightButtonWidth - headerRightMargin, vmargin,
3843                                                                 headerRightButtonWidth, headerButtonItemHeight));
3844                                                 __pButtonItems[LEFT_BUTTON]->SetBounds(FloatRectangle(__titleTextArea.width - headerRightButtonWidth - headerLeftButtonWidth - headerRightMargin, vmargin,
3845                                                                 headerLeftButtonWidth, headerButtonItemHeight));
3846
3847                                                 if (__style == TOOLBAR_HEADER_SEGMENTED_WITH_TITLE || __style == TOOLBAR_TAB_WITH_TITLE)
3848                                                 {
3849                                                         //__pButtonItems[RIGHT_BUTTON]->SetTouchMargin(0, 0, 0, 0);
3850                                                         __pButtonItems[LEFT_BUTTON]->SetTouchMargin(leftTouchMargin, 0.0f, rightTouchMargin, 0.0f);
3851
3852                                                         __itemArea.width -= (headerLeftButtonWidth + headerRightButtonWidth + headerLeftMargin - leftTouchMargin);
3853                                                 }
3854                                                 else
3855                                                 {
3856                                                         __pButtonItems[RIGHT_BUTTON]->SetTouchMargin(0.0f, topTouchMargin, 0.0f, bottomTouchMargin);
3857                                                         __pButtonItems[LEFT_BUTTON]->SetTouchMargin(leftTouchMargin, topTouchMargin, rightTouchMargin, bottomTouchMargin);
3858
3859                                                         __titleTextArea.width -= (headerLeftButtonWidth + headerRightButtonWidth + headerLeftMargin - leftTouchMargin);
3860                                                         __itemArea.width -= (headerLeftButtonWidth + headerRightButtonWidth + headerLeftMargin - leftTouchMargin);
3861                                                 }
3862                                         }
3863                                 }
3864                                 else
3865                                 {
3866                                         if (__pButtonItems[RIGHT_BUTTON]->GetText() == L"")
3867                                         {
3868                                                 __pButtonItems[RIGHT_BUTTON]->SetBounds(FloatRectangle(__titleTextArea.width - headerRightButtonWidth - headerRightMargin + rightTouchMargin, vmargin,
3869                                                                 headerRightButtonWidth, headerButtonItemHeight));
3870                                                 __pButtonItems[LEFT_BUTTON]->SetBounds(FloatRectangle(__titleTextArea.width - headerRightButtonWidth - headerLeftButtonWidth - headerRightMargin + rightTouchMargin, vmargin,
3871                                                                 headerLeftButtonWidth, headerButtonItemHeight));
3872
3873                                                 if (__style == TOOLBAR_HEADER_SEGMENTED_WITH_TITLE || __style == TOOLBAR_TAB_WITH_TITLE)
3874                                                 {
3875                                                         //__pButtonItems[LEFT_BUTTON]->SetTouchMargin(0, 0, 0, 0);
3876                                                         __pButtonItems[RIGHT_BUTTON]->SetTouchMargin(leftTouchMargin, 0.0f, rightTouchMargin, 0.0f);
3877
3878                                                         __itemArea.width -= (headerLeftButtonWidth + headerRightButtonWidth + headerLeftMargin - leftTouchMargin);
3879                                                 }
3880                                                 else
3881                                                 {
3882                                                         __pButtonItems[LEFT_BUTTON]->SetTouchMargin(0.0f, topTouchMargin, 0.0f, bottomTouchMargin);
3883                                                         __pButtonItems[RIGHT_BUTTON]->SetTouchMargin(leftTouchMargin, topTouchMargin, rightTouchMargin, bottomTouchMargin);
3884
3885                                                         __titleTextArea.width -= (headerLeftButtonWidth + headerRightButtonWidth + headerLeftMargin - leftTouchMargin);
3886                                                         __itemArea.width -= (headerLeftButtonWidth + headerRightButtonWidth + headerLeftMargin - leftTouchMargin);
3887                                                 }
3888                                         }
3889                                         else
3890                                         {
3891                                                 __pButtonItems[RIGHT_BUTTON]->SetBounds(FloatRectangle(__titleTextArea.width - headerRightButtonWidth - headerRightMargin, vmargin,
3892                                                                 headerRightButtonWidth, headerButtonItemHeight));
3893                                                 __pButtonItems[LEFT_BUTTON]->SetBounds(FloatRectangle(__titleTextArea.width - headerRightButtonWidth - headerLeftButtonWidth - buttonItemGap - headerRightMargin, vmargin,
3894                                                                 headerLeftButtonWidth, headerButtonItemHeight));
3895
3896                                                 if (__style == TOOLBAR_HEADER_SEGMENTED_WITH_TITLE || __style == TOOLBAR_TAB_WITH_TITLE)
3897                                                 {
3898                                                         //__pButtonItems[LEFT_BUTTON]->SetTouchMargin(0, 0, 0, 0);
3899                                                         //__pButtonItems[RIGHT_BUTTON]->SetTouchMargin(0, 0, 0, 0);
3900
3901                                                         __itemArea.width -= (headerLeftButtonWidth + headerRightButtonWidth + buttonItemGap + headerLeftMargin);
3902                                                 }
3903                                                 else
3904                                                 {
3905                                                         __pButtonItems[LEFT_BUTTON]->SetTouchMargin(0.0f, topTouchMargin, 0.0f, bottomTouchMargin);
3906                                                         __pButtonItems[RIGHT_BUTTON]->SetTouchMargin(0.0f, topTouchMargin, 0.0f, bottomTouchMargin);
3907
3908                                                         __titleTextArea.width -= (headerLeftButtonWidth + headerRightButtonWidth + buttonItemGap + headerLeftMargin);
3909                                                         __itemArea.width -= (headerLeftButtonWidth + headerRightButtonWidth + buttonItemGap + headerLeftMargin);
3910                                                 }
3911                                         }
3912                                 }
3913                         }
3914                         else
3915                         {
3916                                 if (__pButtonItems[RIGHT_BUTTON]->GetText() == L"")
3917                                 {
3918                                         __pButtonItems[RIGHT_BUTTON]->SetBounds(FloatRectangle(__titleTextArea.width - headerRightButtonWidth - headerRightMargin + rightTouchMargin, vmargin,
3919                                                         headerRightButtonWidth, headerButtonItemHeight));
3920
3921                                         if (__style == TOOLBAR_HEADER_SEGMENTED_WITH_TITLE || __style == TOOLBAR_TAB_WITH_TITLE)
3922                                         {
3923                                                 __pButtonItems[RIGHT_BUTTON]->SetTouchMargin(leftTouchMargin, 0.0f, rightTouchMargin, 0.0f);
3924
3925                                                 __itemArea.width -= (headerRightButtonWidth + headerLeftMargin - leftTouchMargin - rightTouchMargin);
3926                                         }
3927                                         else
3928                                         {
3929                                                 __pButtonItems[RIGHT_BUTTON]->SetTouchMargin(leftTouchMargin, topTouchMargin, rightTouchMargin, bottomTouchMargin);
3930
3931                                                 __titleTextArea.width -= (headerRightButtonWidth + headerLeftMargin - leftTouchMargin - rightTouchMargin);
3932                                                 __itemArea.width -= (headerRightButtonWidth + headerLeftMargin - leftTouchMargin - rightTouchMargin);
3933                                         }
3934                                 }
3935                                 else
3936                                 {
3937                                         __pButtonItems[RIGHT_BUTTON]->SetBounds(FloatRectangle(__titleTextArea.width - headerRightButtonWidth - headerRightMargin, vmargin,
3938                                                         headerRightButtonWidth, headerButtonItemHeight));
3939
3940                                         if (__style == TOOLBAR_HEADER_SEGMENTED_WITH_TITLE || __style == TOOLBAR_TAB_WITH_TITLE)
3941                                         {
3942                                                 //__pButtonItems[RIGHT_BUTTON]->SetTouchMargin(0, 0, 0, 0);
3943
3944                                                 __itemArea.width -= (headerRightButtonWidth + headerLeftMargin);
3945                                         }
3946                                         else
3947                                         {
3948                                                 __pButtonItems[RIGHT_BUTTON]->SetTouchMargin(0.0f, topTouchMargin, 0.0f, bottomTouchMargin);
3949
3950                                                 __titleTextArea.width -= (headerRightButtonWidth + headerLeftMargin);
3951                                                 __itemArea.width -= (headerRightButtonWidth + headerLeftMargin);
3952                                         }
3953                                 }
3954                         }
3955                 }
3956                 else if (__pButtonItems[LEFT_BUTTON])
3957                 {
3958                         if (__pButtonItems[LEFT_BUTTON]->GetText() == L"")
3959                         {
3960                                 __pButtonItems[LEFT_BUTTON]->SetBounds(FloatRectangle(__titleTextArea.width - headerLeftButtonWidth - headerRightMargin + rightTouchMargin, vmargin,
3961                                                 headerLeftButtonWidth, headerButtonItemHeight));
3962
3963                                 if (__style == TOOLBAR_HEADER_SEGMENTED_WITH_TITLE || __style == TOOLBAR_TAB_WITH_TITLE)
3964                                 {
3965                                         __pButtonItems[LEFT_BUTTON]->SetTouchMargin(leftTouchMargin, 0.0f, rightTouchMargin, 0.0f);
3966
3967                                         __itemArea.width -= (headerLeftButtonWidth + headerLeftMargin - leftTouchMargin - rightTouchMargin);
3968                                 }
3969                                 else
3970                                 {
3971                                         __pButtonItems[LEFT_BUTTON]->SetTouchMargin(leftTouchMargin, topTouchMargin, rightTouchMargin, bottomTouchMargin);
3972
3973                                         __titleTextArea.width -= (headerLeftButtonWidth + headerLeftMargin - leftTouchMargin - rightTouchMargin);
3974                                         __itemArea.width -= (headerLeftButtonWidth + headerLeftMargin - leftTouchMargin - rightTouchMargin);
3975                                 }
3976                         }
3977                         else
3978                         {
3979                                 __pButtonItems[LEFT_BUTTON]->SetBounds(FloatRectangle(__titleTextArea.width - headerLeftButtonWidth - headerRightMargin, vmargin,
3980                                                 headerLeftButtonWidth, headerButtonItemHeight));
3981
3982                                 if (__style == TOOLBAR_HEADER_SEGMENTED_WITH_TITLE || __style == TOOLBAR_TAB_WITH_TITLE)
3983                                 {
3984                                         //__pButtonItems[LEFT_BUTTON]->SetTouchMargin(0, 0, 0, 0);
3985
3986                                         __itemArea.width -= (headerLeftButtonWidth + headerLeftMargin);
3987                                 }
3988                                 else
3989                                 {
3990                                         __pButtonItems[LEFT_BUTTON]->SetTouchMargin(0.0f, topTouchMargin, 0.0f, bottomTouchMargin);
3991
3992                                         __titleTextArea.width -= (headerLeftButtonWidth + headerLeftMargin);
3993                                         __itemArea.width -= (headerLeftButtonWidth + headerLeftMargin);
3994                                 }
3995                         }
3996                 }
3997
3998                 if ((__style == TOOLBAR_HEADER_SEGMENTED || __style == TOOLBAR_HEADER_SEGMENTED_WITH_TITLE)
3999                                 && __pButtonItems[LEFT_BUTTON] == null && __pButtonItems[RIGHT_BUTTON] == null)
4000                 {
4001                         // segment style with no button's right margin is same as left
4002                         __titleTextArea.width -= (headerLeftMargin + headerRightMargin);
4003                         __itemArea.width -= (headerLeftMargin + headerLeftMargin);
4004                 }
4005                 else if (!(__style == TOOLBAR_TAB || __style == TOOLBAR_TAB_WITH_TITLE))
4006                 {
4007                         __titleTextArea.width -= (headerLeftMargin + headerRightMargin);
4008                         __itemArea.width -= (headerLeftMargin + headerRightMargin);
4009                 }
4010
4011                 if (__style == TOOLBAR_TAB_WITH_TITLE)
4012                 {
4013                         __titleTextArea.width -= (headerLeftMargin + headerRightMargin);
4014                 }
4015
4016                 float processingAnimationIconSize = 0.0f;
4017
4018                 GET_SHAPE_CONFIG(HEADER::PROCESSING_ANIMATION_ICON_SIZE, GetOrientation(), processingAnimationIconSize);
4019
4020                 if (__pButtonItems[LEFT_BUTTON] && GetWaitingAnimationStatus(TOOLBAR_ANIMATION_POSITION_BUTTON_LEFT) != ANIMATION_STOPPED)
4021                 {
4022                         SetWaitingAnimationPosition(TOOLBAR_ANIMATION_POSITION_BUTTON_LEFT,
4023                                         (__pButtonItems[LEFT_BUTTON]->GetSizeF().width - processingAnimationIconSize) / 2,
4024                                         topTouchMargin + (__pButtonItems[LEFT_BUTTON]->GetSizeF().height - topTouchMargin - bottomTouchMargin - processingAnimationIconSize) / 2);
4025                 }
4026
4027                 if (__pButtonItems[RIGHT_BUTTON] && GetWaitingAnimationStatus(TOOLBAR_ANIMATION_POSITION_BUTTON_RIGHT) != ANIMATION_STOPPED)
4028                 {
4029                         SetWaitingAnimationPosition(TOOLBAR_ANIMATION_POSITION_BUTTON_RIGHT,
4030                                         (__pButtonItems[RIGHT_BUTTON]->GetSizeF().width - processingAnimationIconSize) / 2,
4031                                         topTouchMargin + (__pButtonItems[RIGHT_BUTTON]->GetSizeF().height - topTouchMargin - bottomTouchMargin - processingAnimationIconSize) / 2);
4032                 }
4033         }
4034         else  // footer or edit or HEADER_STYLE_BUTTON // side align
4035         {
4036                 float footerButtonItemWidth = 0.0f;
4037                 float footerButtonItemHeight = 0.0f;
4038                 float sipButtonItemTopMargin = 0.0f;
4039                 float footerLeftMargin = 0.0f;
4040                 FloatDimension softkeyDimension(0.0f, 0.0f);
4041
4042                 float leftTouchMargin = 0.0f;
4043                 float topTouchMargin = 0.0f;
4044                 float rightTouchMargin = 0.0f;
4045                 float bottomTouchMargin = 0.0f;
4046
4047                 if (__header == true && __style == TOOLBAR_TEXT) // sip
4048                 {
4049                         GET_SHAPE_CONFIG(HEADER::SIP_BUTTON_ITEM_LEFT_TOUCH_MARGIN, GetOrientation(), leftTouchMargin);
4050                         GET_SHAPE_CONFIG(HEADER::SIP_BUTTON_ITEM_TOP_TOUCH_MARGIN, GetOrientation(), topTouchMargin);
4051                         GET_SHAPE_CONFIG(HEADER::SIP_BUTTON_ITEM_RIGHT_TOUCH_MARGIN, GetOrientation(), rightTouchMargin);
4052                         GET_SHAPE_CONFIG(HEADER::SIP_BUTTON_ITEM_BOTTOM_TOUCH_MARGIN, GetOrientation(), bottomTouchMargin);
4053                 }
4054                 else
4055                 {
4056                         GET_SHAPE_CONFIG(FOOTER::BUTTON_ITEM_LEFT_TOUCH_MARGIN, GetOrientation(), leftTouchMargin);
4057                         GET_SHAPE_CONFIG(FOOTER::BUTTON_ITEM_TOP_TOUCH_MARGIN, GetOrientation(), topTouchMargin);
4058                         GET_SHAPE_CONFIG(FOOTER::BUTTON_ITEM_RIGHT_TOUCH_MARGIN, GetOrientation(), rightTouchMargin);
4059                         GET_SHAPE_CONFIG(FOOTER::BUTTON_ITEM_BOTTOM_TOUCH_MARGIN, GetOrientation(), bottomTouchMargin);
4060                 }
4061
4062                 if (__header == true && __style == TOOLBAR_TEXT)
4063                 {
4064                         GET_SHAPE_CONFIG(HEADER::BUTTON_ITEM_WIDTH, GetOrientation(), footerButtonItemWidth);
4065
4066                         if (GetOrientation() == _CONTROL_ORIENTATION_PORTRAIT) // sip && portrait
4067                         {
4068                                 GET_SHAPE_CONFIG(HEADER::BUTTON_ITEM_HEIGHT, GetOrientation(), footerButtonItemHeight);
4069                         }
4070                         else
4071                         {
4072                                 GET_SHAPE_CONFIG(FOOTER::BUTTON_ITEM_HEIGHT, GetOrientation(), footerButtonItemHeight);
4073                         }
4074                 }
4075                 else
4076                 {
4077                         GET_SHAPE_CONFIG(FOOTER::BUTTON_ITEM_WIDTH, GetOrientation(), footerButtonItemWidth);
4078                         GET_SHAPE_CONFIG(FOOTER::BUTTON_ITEM_HEIGHT, GetOrientation(), footerButtonItemHeight);
4079                 }
4080
4081                 GET_SHAPE_CONFIG(HEADER::SIP_BUTTON_ITEM_TOP_MARGIN, GetOrientation(), sipButtonItemTopMargin);
4082                 GET_SHAPE_CONFIG(FOOTER::LEFT_MARGIN, GetOrientation(), footerLeftMargin);
4083                 GET_DIMENSION_CONFIG(FOOTER::SOFTKEY_RECT_WITH_TEXT, GetOrientation(), softkeyDimension);
4084
4085                 if (__pButtonItems[MIDDLE_BUTTON])
4086                 {
4087                         __pButtonItems[MIDDLE_BUTTON]->SetPosition(FloatPoint((__itemArea.width - __pButtonItems[MIDDLE_BUTTON]->GetSizeF().width) / 2,
4088                                         __itemArea.height - __pButtonItems[MIDDLE_BUTTON]->GetSizeF().height));
4089                 }
4090
4091                 // footer or edit or HEADER_STYLE_BUTTON // side align
4092                 if (__pButtonItems[RIGHT_BUTTON])
4093                 {
4094                         if (__pButtonItems[LEFT_BUTTON])
4095                         {
4096                                 if (__pButtonItems[BACK_BUTTON])
4097                                 {
4098                                         __pButtonItems[BACK_BUTTON]->SetBounds(FloatRectangle(__itemArea.width - footerButtonItemWidth - footerLeftMargin + rightTouchMargin,
4099                                                         (__itemArea.height - footerButtonItemHeight) / 2, footerButtonItemWidth, footerButtonItemHeight));
4100
4101                                         __pButtonItems[LEFT_BUTTON]->SetBounds(FloatRectangle(footerLeftMargin - leftTouchMargin, (__itemArea.height - footerButtonItemHeight) / 2,
4102                                                         footerButtonItemWidth, footerButtonItemHeight));
4103
4104                                         __pButtonItems[BACK_BUTTON]->SetTouchMargin(leftTouchMargin, topTouchMargin, rightTouchMargin, bottomTouchMargin);
4105                                         __pButtonItems[LEFT_BUTTON]->SetTouchMargin(leftTouchMargin, topTouchMargin, rightTouchMargin, bottomTouchMargin);
4106                                 }
4107                                 else
4108                                 {
4109                                         if (__style != TOOLBAR_SOFTKEY)
4110                                         {
4111                                                 __pButtonItems[RIGHT_BUTTON]->SetBounds(FloatRectangle(__itemArea.width - footerButtonItemWidth - footerLeftMargin + rightTouchMargin,
4112                                                                 (__itemArea.height - footerButtonItemHeight) / 2, footerButtonItemWidth, footerButtonItemHeight));
4113
4114                                                 __pButtonItems[LEFT_BUTTON]->SetBounds(FloatRectangle(footerLeftMargin - leftTouchMargin, sipButtonItemTopMargin,
4115                                                                 footerButtonItemWidth, footerButtonItemHeight));
4116
4117                                                 __pButtonItems[RIGHT_BUTTON]->SetTouchMargin(leftTouchMargin, topTouchMargin, rightTouchMargin, bottomTouchMargin);
4118                                                 __pButtonItems[LEFT_BUTTON]->SetTouchMargin(leftTouchMargin, topTouchMargin, rightTouchMargin, bottomTouchMargin);
4119                                         }
4120                                         else
4121                                         {
4122                                                 if (__pButtonItems[RIGHT_BUTTON]->GetText() == L"")
4123                                                 {
4124                                                         __pButtonItems[RIGHT_BUTTON]->SetPosition(FloatPoint(__itemArea.width - __pButtonItems[RIGHT_BUTTON]->GetSizeF().width,
4125                                                                 __itemArea.height - __pButtonItems[RIGHT_BUTTON]->GetSizeF().height));
4126                                                 }
4127                                                 else
4128                                                 {
4129                                                         __pButtonItems[RIGHT_BUTTON]->SetBounds(FloatRectangle(__itemArea.width - softkeyDimension.width, __itemArea.height - softkeyDimension.height,
4130                                                                         softkeyDimension.width, softkeyDimension.height));
4131                                                 }
4132                                         }
4133
4134                                         if (__style != TOOLBAR_SOFTKEY)
4135                                         {
4136                                                 __pButtonItems[LEFT_BUTTON]->SetBounds(FloatRectangle(footerLeftMargin - leftTouchMargin, (__itemArea.height - footerButtonItemHeight) / 2,
4137                                                                                                                         footerButtonItemWidth, footerButtonItemHeight));
4138
4139                                                 __pButtonItems[LEFT_BUTTON]->SetTouchMargin(leftTouchMargin, topTouchMargin, rightTouchMargin, bottomTouchMargin);
4140                                         }
4141                                         else
4142                                         {
4143                                                 if (__pButtonItems[LEFT_BUTTON]->GetText() == L"")
4144                                                 {
4145                                                         __pButtonItems[LEFT_BUTTON]->SetPosition(FloatPoint(0.0f, __itemArea.height - __pButtonItems[LEFT_BUTTON]->GetSizeF().height));
4146                                                 }
4147                                                 else
4148                                                 {
4149                                                         __pButtonItems[LEFT_BUTTON]->SetBounds(FloatRectangle(0.0f, __itemArea.height - softkeyDimension.height,
4150                                                                         softkeyDimension.width, softkeyDimension.height));
4151                                                 }
4152                                         }
4153                                 }
4154                         }
4155                         else
4156                         {
4157                                 if (__pButtonItems[BACK_BUTTON])
4158                                 {
4159                                         __pButtonItems[BACK_BUTTON]->SetBounds(FloatRectangle(__itemArea.width - footerButtonItemWidth - footerLeftMargin + rightTouchMargin,
4160                                                         (__itemArea.height - footerButtonItemHeight) / 2, footerButtonItemWidth, footerButtonItemHeight));
4161
4162                                         __pButtonItems[BACK_BUTTON]->SetTouchMargin(leftTouchMargin, topTouchMargin, rightTouchMargin, bottomTouchMargin);
4163                                 }
4164                                 else
4165                                 {
4166                                         if (__style != TOOLBAR_SOFTKEY)
4167                                         {
4168                                                 __pButtonItems[RIGHT_BUTTON]->SetBounds(FloatRectangle(__itemArea.width - footerButtonItemWidth - footerLeftMargin + rightTouchMargin,
4169                                                                 (__itemArea.height - footerButtonItemHeight) / 2, footerButtonItemWidth, footerButtonItemHeight));
4170
4171                                                 __pButtonItems[RIGHT_BUTTON]->SetTouchMargin(leftTouchMargin, topTouchMargin, rightTouchMargin, bottomTouchMargin);
4172                                         }
4173                                         else
4174                                         {
4175                                                 if (__pButtonItems[RIGHT_BUTTON]->GetText() == L"")
4176                                                 {
4177                                                         __pButtonItems[RIGHT_BUTTON]->SetPosition(FloatPoint(__itemArea.width - __pButtonItems[RIGHT_BUTTON]->GetSizeF().width,
4178                                                                         __itemArea.height - __pButtonItems[RIGHT_BUTTON]->GetSizeF().height));
4179                                                 }
4180                                                 else
4181                                                 {
4182                                                         __pButtonItems[RIGHT_BUTTON]->SetBounds(FloatRectangle(__itemArea.width - softkeyDimension.width, __itemArea.height - softkeyDimension.height,
4183                                                                         softkeyDimension.width, softkeyDimension.height));
4184                                                 }
4185                                         }
4186                                 }
4187                         }
4188                 }
4189                 else if (__pButtonItems[LEFT_BUTTON])
4190                 {
4191                         if (__pButtonItems[BACK_BUTTON])
4192                         {
4193                                 __pButtonItems[BACK_BUTTON]->SetBounds(FloatRectangle(__itemArea.width - footerButtonItemWidth - footerLeftMargin + rightTouchMargin,
4194                                                 (__itemArea.height - footerButtonItemHeight) / 2, footerButtonItemWidth, footerButtonItemHeight));
4195
4196                                 __pButtonItems[LEFT_BUTTON]->SetBounds(FloatRectangle(footerLeftMargin - leftTouchMargin, (__itemArea.height - footerButtonItemHeight) / 2,
4197                                                 footerButtonItemWidth, footerButtonItemHeight));
4198
4199                                 __pButtonItems[BACK_BUTTON]->SetTouchMargin(leftTouchMargin, topTouchMargin, rightTouchMargin, bottomTouchMargin);
4200                                 __pButtonItems[LEFT_BUTTON]->SetTouchMargin(leftTouchMargin, topTouchMargin, rightTouchMargin, bottomTouchMargin);
4201                         }
4202                         else
4203                         {
4204                                 if (__style != TOOLBAR_SOFTKEY)
4205                                 {
4206                                         __pButtonItems[LEFT_BUTTON]->SetBounds(FloatRectangle(footerLeftMargin - leftTouchMargin, (__itemArea.height - footerButtonItemHeight) / 2,
4207                                                         footerButtonItemWidth, footerButtonItemHeight));
4208
4209                                         __pButtonItems[LEFT_BUTTON]->SetTouchMargin(leftTouchMargin, topTouchMargin, rightTouchMargin, bottomTouchMargin);
4210                                 }
4211                                 else
4212                                 {
4213                                         if (__pButtonItems[LEFT_BUTTON]->GetText() == L"")
4214                                         {
4215                                                 __pButtonItems[LEFT_BUTTON]->SetPosition(FloatPoint(0.0f, __itemArea.height - __pButtonItems[LEFT_BUTTON]->GetSizeF().height));
4216                                         }
4217                                         else
4218                                         {
4219                                                 __pButtonItems[LEFT_BUTTON]->SetBounds(FloatRectangle(0.0f, __itemArea.height - softkeyDimension.height,
4220                                                                 softkeyDimension.width, softkeyDimension.height));
4221                                         }
4222                                 }
4223                         }
4224                 }
4225                 else
4226                 {
4227                         if (__pButtonItems[BACK_BUTTON])
4228                         {
4229                                 __pButtonItems[BACK_BUTTON]->SetBounds(FloatRectangle(__itemArea.width - footerButtonItemWidth - footerLeftMargin + rightTouchMargin,
4230                                                 (__itemArea.height - footerButtonItemHeight) / 2, footerButtonItemWidth, footerButtonItemHeight));
4231
4232                                 __pButtonItems[BACK_BUTTON]->SetTouchMargin(leftTouchMargin, topTouchMargin, rightTouchMargin, bottomTouchMargin);
4233                         }
4234                 }
4235         }
4236
4237         if (__style != TOOLBAR_SOFTKEY)
4238         {
4239                 for (int i = 0; i < BUTTON_MAX; i++)
4240                 {
4241                         if (__pButtonItems[i] != null)
4242                         {
4243                                 RealignButtonItem(__pButtonItems[i]);
4244                         }
4245                 }
4246         }
4247
4248         __pToolbarPresenter->SetUsableAreaBounds(__titleTextArea);
4249
4250         if (0 == __itemCount)
4251         {
4252                 return E_SUCCESS;
4253         }
4254
4255         switch (__style)
4256         {
4257         case TOOLBAR_HEADER_SEGMENTED:
4258                 //fall through
4259         case TOOLBAR_HEADER_SEGMENTED_WITH_TITLE:
4260                 RearrangeHeaderSegmentedItems();
4261                 break;
4262
4263         case TOOLBAR_SEGMENTED:
4264                 RearrangeFooterSegmentedItems();
4265                 break;
4266
4267         case TOOLBAR_TAB:
4268                 //fall through
4269         case TOOLBAR_TAB_WITH_TITLE:
4270                 RearrangeTabItmes();
4271                 break;
4272
4273         default:
4274                 RearrangeButtonItems();
4275                 break;
4276         }
4277
4278         return E_SUCCESS;
4279 }
4280
4281 result
4282 _Toolbar::RearrangeHeaderSegmentedItems(void)
4283 {
4284         float segmentedItemHeight = 0.0f;
4285         float leftMargin = 0.0f;
4286         float dividerWidth = 0.0f;
4287         float vmargin = 0.0f;
4288         float blockWidth[__itemCount];
4289         float fontSize = 0.0f;
4290         float multilineFontSize = 0.0f;
4291
4292         GET_SHAPE_CONFIG(HEADER::LEFT_MARGIN, GetOrientation(), leftMargin);
4293         GET_SHAPE_CONFIG(HEADER::DIVIDER_WIDTH, GetOrientation(), dividerWidth);
4294
4295         if (__style == TOOLBAR_HEADER_SEGMENTED)
4296         {
4297                 segmentedItemHeight = __itemArea.height;
4298                 GET_SHAPE_CONFIG(HEADER::BUTTON_ITEM_TOP_MARGIN, GetOrientation(), vmargin);
4299         }
4300         else if (__style == TOOLBAR_HEADER_SEGMENTED_WITH_TITLE)
4301         {
4302                 GET_SHAPE_CONFIG(HEADER::SEGMENTED_ITEM_HEIGHT, GetOrientation(), segmentedItemHeight);
4303                 GET_SHAPE_CONFIG(HEADER::TITLE_HEIGHT_WITH_SEGMENTED_ITEM, GetOrientation(), vmargin);
4304         }
4305
4306         if (__itemCount == 1 || __itemCount == 2)
4307         {
4308                 blockWidth[0] = blockWidth[1] = (__itemArea.width - dividerWidth) / 2;
4309
4310                 for (int i = 0; i < __itemCount ; i++)
4311                 {
4312                         __pItems.at(i)->SetBounds(FloatRectangle(leftMargin + blockWidth[0] * i + dividerWidth * i, vmargin, blockWidth[i], segmentedItemHeight));
4313
4314                         if (__pItems.at(i)->GetChildCount() != 0)
4315                         {
4316                                 _Label* existingBadgeIcon = dynamic_cast<_Label*>(__pItems.at(i)->GetChild(0));
4317
4318                                 if (existingBadgeIcon)
4319                                 {
4320                                         existingBadgeIcon->SetPosition(FloatPoint(blockWidth[1] - existingBadgeIcon->GetSizeF().width, 0));
4321                                         existingBadgeIcon = null;
4322                                 }
4323                         }
4324                 }
4325
4326                 GET_SHAPE_CONFIG(HEADER::SEGMENTED_ITEM_FONT_SIZE, GetOrientation(), fontSize); // 30
4327
4328                 if (__style == TOOLBAR_HEADER_SEGMENTED)
4329                 {
4330                         GET_SHAPE_CONFIG(HEADER::SEGMENTED_ITEM_MULTILINE_FONT_SIZE, GetOrientation(), multilineFontSize); // 28
4331                 }
4332                 else if (__style == TOOLBAR_HEADER_SEGMENTED_WITH_TITLE)
4333                 {
4334                         GET_SHAPE_CONFIG(HEADER::SEGMENTED_ITEM_FONT_SIZE_4_ITEM, GetOrientation(), multilineFontSize); // 24
4335                 }
4336         }
4337         else if (__itemCount == 3)
4338         {
4339                 blockWidth[0] = blockWidth[1] = blockWidth[2] = (__itemArea.width - dividerWidth * 2) / 3;
4340
4341                 __pItems.at(0)->SetBounds(FloatRectangle(leftMargin, vmargin, blockWidth[0], segmentedItemHeight));
4342                 __pItems.at(1)->SetBounds(FloatRectangle(leftMargin + blockWidth[0] + dividerWidth, vmargin, blockWidth[1], segmentedItemHeight));
4343                 __pItems.at(2)->SetBounds(FloatRectangle(leftMargin + blockWidth[0] + blockWidth[1] + dividerWidth * 2,
4344                                 vmargin, blockWidth[2], segmentedItemHeight));
4345
4346                 for (int i = 0; i < __itemCount; i++)
4347                 {
4348                         if (__pItems.at(i)->GetChildCount() != 0)
4349                         {
4350                                 _Label* existingBadgeIcon = dynamic_cast<_Label*>(__pItems.at(i)->GetChild(0));
4351
4352                                 if (existingBadgeIcon)
4353                                 {
4354                                         existingBadgeIcon->SetPosition(FloatPoint(blockWidth[i] - existingBadgeIcon->GetSizeF().width, 0));
4355                                         existingBadgeIcon = null;
4356                                 }
4357                         }
4358                 }
4359
4360                 GET_SHAPE_CONFIG(HEADER::SEGMENTED_ITEM_FONT_SIZE_3_ITEM, GetOrientation(), fontSize); // 26
4361
4362                 if (__style == TOOLBAR_HEADER_SEGMENTED)
4363                 {
4364                         GET_SHAPE_CONFIG(HEADER::SEGMENTED_ITEM_FONT_SIZE_3_ITEM, GetOrientation(), multilineFontSize); // 26
4365                 }
4366                 else if (__style == TOOLBAR_HEADER_SEGMENTED_WITH_TITLE)
4367                 {
4368                         GET_SHAPE_CONFIG(HEADER::SEGMENTED_ITEM_FONT_SIZE_4_ITEM, GetOrientation(), multilineFontSize); //24
4369                 }
4370         }
4371         else if (__itemCount == 4)
4372         {
4373                 blockWidth[0] = blockWidth[1] = blockWidth[2] = blockWidth[3] = (__itemArea.width - dividerWidth * 3) / 4;
4374
4375                 __pItems.at(0)->SetBounds(FloatRectangle(leftMargin, vmargin, blockWidth[0], segmentedItemHeight));
4376                 __pItems.at(1)->SetBounds(FloatRectangle(leftMargin + blockWidth[0] + dividerWidth, vmargin, blockWidth[1], segmentedItemHeight));
4377                 __pItems.at(2)->SetBounds(FloatRectangle(leftMargin + blockWidth[0] + blockWidth[1] + dividerWidth * 2,
4378                                 vmargin, blockWidth[2], segmentedItemHeight));
4379                 __pItems.at(3)->SetBounds(FloatRectangle(leftMargin + blockWidth[0] + blockWidth[1] + blockWidth[2] + dividerWidth * 3,
4380                                 vmargin, blockWidth[3], segmentedItemHeight));
4381
4382                 for (int i = 0; i < __itemCount ; i++)
4383                 {
4384                         if (__pItems.at(i)->GetChildCount() != 0)
4385                         {
4386                                 _Label* existingBadgeIcon = dynamic_cast<_Label*>(__pItems.at(i)->GetChild(0));
4387
4388                                 if (existingBadgeIcon)
4389                                 {
4390                                         existingBadgeIcon->SetPosition(FloatPoint(blockWidth[i] - existingBadgeIcon->GetSizeF().width, 0));
4391                                         existingBadgeIcon = null;
4392                                 }
4393                         }
4394                 }
4395
4396                 GET_SHAPE_CONFIG(HEADER::SEGMENTED_ITEM_FONT_SIZE_4_ITEM, GetOrientation(), fontSize);
4397                 GET_SHAPE_CONFIG(HEADER::SEGMENTED_ITEM_FONT_SIZE_4_ITEM, GetOrientation(), multilineFontSize);
4398         }
4399
4400         for (int i = 0; i < __itemCount; i++)
4401         {
4402                 __pItems.at(i)->SetTextSize(fontSize, FONT_STYLE_BOLD);
4403                 __pItems.at(i)->SetMultilineTextSize(multilineFontSize);
4404
4405                 RealignItem(__pItems.at(i), __pItems.at(i)->GetTextExtentSizeF());
4406         }
4407
4408         return E_SUCCESS;
4409 }
4410
4411 result
4412 _Toolbar::RearrangeFooterSegmentedItems(void)
4413 {
4414         float segmentedItemHeight = __itemArea.height;
4415
4416         float leftMargin = 0.0f;
4417         float rightMargin = 0.0f;
4418         float footerLeftMargin = 0.0f;
4419         float iconSize = 0.0f;
4420         float dividerWidth = 0.0f;
4421         float blockWidth[__itemCount];
4422         float fontSize = 0.0f;
4423         float multilineFontSize = 0.0f;
4424
4425         float itemButtonLeftGap = 0.0f;
4426         float itemButtonRightGap = 0.0f;
4427
4428         GET_SHAPE_CONFIG(HEADER::LEFT_MARGIN, GetOrientation(), leftMargin);
4429         GET_SHAPE_CONFIG(FOOTER::LEFT_MARGIN, GetOrientation(), footerLeftMargin);
4430         GET_SHAPE_CONFIG(FOOTER::FOOTER_ITEM_ICON_SIZE, GetOrientation(), iconSize);
4431         GET_SHAPE_CONFIG(HEADER::DIVIDER_WIDTH, GetOrientation(), dividerWidth);
4432
4433         rightMargin = leftMargin;
4434
4435         if (__itemCount == 1 || __itemCount == 2)
4436         {
4437                 leftMargin = footerLeftMargin;
4438                 itemButtonLeftGap = footerLeftMargin;
4439                 __itemArea.width -= ((leftMargin + iconSize + itemButtonLeftGap) * 2);
4440
4441                 blockWidth[0] = blockWidth[1] = (__itemArea.width - dividerWidth) / 2;
4442
4443                 for (int i = 0; i < __itemCount ; i++)
4444                 {
4445                         __pItems.at(i)->SetBounds(FloatRectangle(leftMargin + iconSize + itemButtonLeftGap + blockWidth[0] * i + dividerWidth * i,
4446                                         (GetSizeF().height - segmentedItemHeight) / 2, blockWidth[i], segmentedItemHeight));
4447
4448                         if (__pItems.at(i)->GetChildCount() != 0)
4449                         {
4450                                 _Label* existingBadgeIcon = dynamic_cast<_Label*>(__pItems.at(i)->GetChild(0));
4451
4452                                 if (existingBadgeIcon)
4453                                 {
4454                                         existingBadgeIcon->SetPosition(FloatPoint(blockWidth[i] - existingBadgeIcon->GetSizeF().width, 0));
4455                                         existingBadgeIcon = null;
4456                                 }
4457                         }
4458                 }
4459
4460                 GET_SHAPE_CONFIG(HEADER::SEGMENTED_ITEM_FONT_SIZE, GetOrientation(), fontSize);
4461                 GET_SHAPE_CONFIG(HEADER::SEGMENTED_ITEM_MULTILINE_FONT_SIZE, GetOrientation(), multilineFontSize);
4462         }
4463         else if (__itemCount == 3)
4464         {
4465                 if (__pButtonItems[LEFT_BUTTON])
4466                 {
4467                         if (__pButtonItems[RIGHT_BUTTON] || __pButtonItems[BACK_BUTTON])
4468                         {
4469                                 leftMargin = footerLeftMargin;
4470                                 itemButtonLeftGap = footerLeftMargin;
4471                                 __itemArea.width -= ((leftMargin + iconSize + itemButtonLeftGap) * 2);
4472                         }
4473                         else
4474                         {
4475                                 leftMargin = footerLeftMargin;
4476                                 itemButtonLeftGap = footerLeftMargin;
4477                                 __itemArea.width -= (leftMargin + iconSize + itemButtonLeftGap + rightMargin);
4478                         }
4479                 }
4480                 else
4481                 {
4482                         if (__pButtonItems[RIGHT_BUTTON] || __pButtonItems[BACK_BUTTON])
4483                         {
4484                                 rightMargin = footerLeftMargin;
4485                                 itemButtonRightGap = footerLeftMargin;
4486                                 __itemArea.width -= (leftMargin + itemButtonRightGap + iconSize + rightMargin);
4487                         }
4488                         else
4489                         {
4490                                 __itemArea.width -= leftMargin * 2;
4491                         }
4492
4493                         iconSize = 0;
4494                 }
4495
4496                 blockWidth[0] = blockWidth[1] = blockWidth[2] = (__itemArea.width - dividerWidth * 2) / 3;
4497
4498                 __pItems.at(0)->SetBounds(FloatRectangle(leftMargin + iconSize + itemButtonLeftGap, (GetSizeF().height - segmentedItemHeight) / 2, blockWidth[0], segmentedItemHeight));
4499                 __pItems.at(1)->SetBounds(FloatRectangle(leftMargin + iconSize + itemButtonLeftGap + blockWidth[0] + dividerWidth, (GetSizeF().height - segmentedItemHeight) / 2, blockWidth[1], segmentedItemHeight));
4500                 __pItems.at(2)->SetBounds(FloatRectangle(leftMargin + iconSize + itemButtonLeftGap + blockWidth[0] + blockWidth[1] + dividerWidth * 2,
4501                                 (GetSizeF().height - segmentedItemHeight) / 2, blockWidth[2], segmentedItemHeight));
4502
4503                 for (int i = 0; i < __itemCount ; i++)
4504                 {
4505                         if (__pItems.at(i)->GetChildCount() != 0)
4506                         {
4507                                 _Label* existingBadgeIcon = dynamic_cast<_Label*>(__pItems.at(i)->GetChild(0));
4508
4509                                 if (existingBadgeIcon)
4510                                 {
4511                                         existingBadgeIcon->SetPosition(FloatPoint(blockWidth[i] - existingBadgeIcon->GetSizeF().width, 0));
4512                                         existingBadgeIcon = null;
4513                                 }
4514                         }
4515                 }
4516
4517                 GET_SHAPE_CONFIG(HEADER::SEGMENTED_ITEM_FONT_SIZE_3_ITEM, GetOrientation(), fontSize);
4518                 GET_SHAPE_CONFIG(HEADER::SEGMENTED_ITEM_FONT_SIZE_3_ITEM, GetOrientation(), multilineFontSize);
4519         }
4520         else if (__itemCount == 4)
4521         {
4522                 if (__pButtonItems[BACK_BUTTON])
4523                 {
4524                         rightMargin = footerLeftMargin;
4525                         itemButtonRightGap = footerLeftMargin;
4526                         __itemArea.width -= (leftMargin + itemButtonRightGap + iconSize + rightMargin);
4527                 }
4528                 else
4529                 {
4530                         __itemArea.width -= leftMargin * 2;
4531                 }
4532
4533                 blockWidth[0] = blockWidth[1] = blockWidth[2] = blockWidth[3] = (__itemArea.width - dividerWidth * 3) / 4;
4534
4535                 __pItems.at(0)->SetBounds(FloatRectangle(leftMargin, (GetSizeF().height - segmentedItemHeight) / 2, blockWidth[0], segmentedItemHeight));
4536                 __pItems.at(1)->SetBounds(FloatRectangle(leftMargin + blockWidth[0] + dividerWidth, (GetSizeF().height - segmentedItemHeight) / 2, blockWidth[1], segmentedItemHeight));
4537                 __pItems.at(2)->SetBounds(FloatRectangle(leftMargin + blockWidth[0] + blockWidth[1] + dividerWidth * 2,
4538                                 (GetSizeF().height - segmentedItemHeight) / 2, blockWidth[2], segmentedItemHeight));
4539                 __pItems.at(3)->SetBounds(FloatRectangle(leftMargin + blockWidth[0] + blockWidth[1] + blockWidth[2] + dividerWidth * 3,
4540                                 (GetSizeF().height - segmentedItemHeight) / 2, blockWidth[3], segmentedItemHeight));
4541
4542                 for (int i = 0; i < __itemCount ; i++)
4543                 {
4544                         if (__pItems.at(i)->GetChildCount() != 0)
4545                         {
4546                                 _Label* existingBadgeIcon = dynamic_cast<_Label*>(__pItems.at(i)->GetChild(0));
4547
4548                                 if (existingBadgeIcon)
4549                                 {
4550                                         existingBadgeIcon->SetPosition(FloatPoint(blockWidth[i] - existingBadgeIcon->GetSizeF().width, 0));
4551                                         existingBadgeIcon = null;
4552                                 }
4553                         }
4554                 }
4555
4556                 GET_SHAPE_CONFIG(HEADER::SEGMENTED_ITEM_FONT_SIZE_4_ITEM, GetOrientation(), fontSize);
4557                 GET_SHAPE_CONFIG(HEADER::SEGMENTED_ITEM_FONT_SIZE_4_ITEM, GetOrientation(), multilineFontSize);
4558         }
4559
4560         for (int i = 0; i < __itemCount ; i++)
4561         {
4562                 __pItems.at(i)->SetTextSize(fontSize, FONT_STYLE_BOLD);
4563                 __pItems.at(i)->SetMultilineTextSize(multilineFontSize);
4564
4565                 RealignItem(__pItems.at(i), __pItems.at(i)->GetTextExtentSizeF());
4566         }
4567
4568         return E_SUCCESS;
4569 }
4570
4571 result
4572 _Toolbar::RearrangeTabItmes(void)
4573 {
4574         float itemWidth[__itemCount];
4575         float fontSize = 0.0f;
4576         float multilineFontSize = 0.0f;
4577         float segmentedItemHeight = 0.0f;
4578         float tabLeftMargin = 0.0f;
4579         float vmargin = 0.0f;
4580         float dividerWidth = 0.0f;
4581
4582         GET_SHAPE_CONFIG(HEADER::TAB_LEFT_MARGIN, GetOrientation(), tabLeftMargin);
4583         GET_SHAPE_CONFIG(HEADER::DIVIDER_WIDTH, GetOrientation(), dividerWidth);
4584
4585         if (__style == TOOLBAR_TAB)
4586         {
4587                 segmentedItemHeight = __itemArea.height;
4588         }
4589         else if (__style == TOOLBAR_TAB_WITH_TITLE)
4590         {
4591                 GET_SHAPE_CONFIG(HEADER::SEGMENTED_ITEM_HEIGHT, GetOrientation(), segmentedItemHeight);
4592                 GET_SHAPE_CONFIG(HEADER::TITLE_HEIGHT_WITH_SEGMENTED_ITEM, GetOrientation(), vmargin);
4593         }
4594
4595         if (__itemCount == 1)
4596         {
4597                 itemWidth[0] = __itemArea.width - tabLeftMargin * 2;
4598                 __pItems.at(0)->SetBounds(FloatRectangle(tabLeftMargin, vmargin, itemWidth[0], segmentedItemHeight));
4599
4600
4601                 GET_SHAPE_CONFIG(HEADER::TAB_ITEM_FONT_SIZE, GetOrientation(), fontSize); // 30
4602
4603                 if (__style == TOOLBAR_TAB)
4604                 {
4605                         GET_SHAPE_CONFIG(HEADER::TAB_ITEM_MULTILINE_FONT_SIZE, GetOrientation(), multilineFontSize); // 28
4606                 }
4607                 else if (__style == TOOLBAR_TAB_WITH_TITLE)
4608                 {
4609                         GET_SHAPE_CONFIG(HEADER::TAB_ITEM_FONT_SIZE_4_ITEM, GetOrientation(), multilineFontSize); // 24
4610                 }
4611         }
4612         else if (__itemCount == 2)
4613         {
4614                 itemWidth[0] = itemWidth[1] = (__itemArea.width - tabLeftMargin * 2 - dividerWidth) / 2;
4615
4616                 __pItems.at(0)->SetBounds(FloatRectangle(tabLeftMargin, vmargin, itemWidth[0], segmentedItemHeight));
4617                 __pItems.at(1)->SetBounds(FloatRectangle(tabLeftMargin + itemWidth[0] + dividerWidth, vmargin, itemWidth[1], segmentedItemHeight));
4618
4619                 GET_SHAPE_CONFIG(HEADER::TAB_ITEM_FONT_SIZE, GetOrientation(), fontSize); // 30
4620
4621                 if (__style == TOOLBAR_TAB)
4622                 {
4623                         GET_SHAPE_CONFIG(HEADER::TAB_ITEM_MULTILINE_FONT_SIZE, GetOrientation(), multilineFontSize); // 28
4624                 }
4625                 else if (__style == TOOLBAR_TAB_WITH_TITLE)
4626                 {
4627                         GET_SHAPE_CONFIG(HEADER::TAB_ITEM_FONT_SIZE_4_ITEM, GetOrientation(), multilineFontSize); // 24
4628                 }
4629         }
4630         else if (__itemCount == 3)
4631         {
4632                 itemWidth[0] = itemWidth[1] = itemWidth[2] = (__itemArea.width - tabLeftMargin * 2 - dividerWidth * 2) / 3;
4633
4634                 __pItems.at(0)->SetBounds(FloatRectangle(tabLeftMargin, vmargin, itemWidth[0], segmentedItemHeight));
4635                 __pItems.at(1)->SetBounds(FloatRectangle(tabLeftMargin + itemWidth[0] + dividerWidth, vmargin, itemWidth[1], segmentedItemHeight));
4636                 __pItems.at(2)->SetBounds(FloatRectangle(tabLeftMargin + itemWidth[0] + itemWidth[1] + dividerWidth * 2, vmargin, itemWidth[2], segmentedItemHeight));
4637
4638                 GET_SHAPE_CONFIG(HEADER::TAB_ITEM_FONT_SIZE_3_ITEM, GetOrientation(), fontSize); // 26
4639
4640                 if (__style == TOOLBAR_TAB)
4641                 {
4642                         GET_SHAPE_CONFIG(HEADER::TAB_ITEM_FONT_SIZE_3_ITEM, GetOrientation(), multilineFontSize); // 26
4643                 }
4644                 else if (__style == TOOLBAR_TAB_WITH_TITLE)
4645                 {
4646                         GET_SHAPE_CONFIG(HEADER::TAB_ITEM_FONT_SIZE_4_ITEM, GetOrientation(), multilineFontSize); // 24
4647                 }
4648         }
4649         else
4650         {
4651                 itemWidth[0] = itemWidth[1] = itemWidth[2] = itemWidth[3] = (__itemArea.width - tabLeftMargin * 2 - dividerWidth * 3) / 4;
4652
4653                 __pItems.at(0)->SetBounds(FloatRectangle(tabLeftMargin, vmargin, itemWidth[0], segmentedItemHeight));
4654                 __pItems.at(1)->SetBounds(FloatRectangle(tabLeftMargin + itemWidth[0] + dividerWidth, vmargin, itemWidth[1], segmentedItemHeight));
4655                 __pItems.at(2)->SetBounds(FloatRectangle(tabLeftMargin + itemWidth[0] + itemWidth[1] + dividerWidth * 2,
4656                                 vmargin, itemWidth[2], segmentedItemHeight));
4657                 __pItems.at(3)->SetBounds(FloatRectangle(tabLeftMargin + itemWidth[0] + itemWidth[1] + itemWidth[2] + dividerWidth * 3,
4658                                 vmargin, itemWidth[3], segmentedItemHeight));
4659
4660                 GET_SHAPE_CONFIG(HEADER::TAB_ITEM_FONT_SIZE_4_ITEM, GetOrientation(), fontSize); // 24
4661                 GET_SHAPE_CONFIG(HEADER::TAB_ITEM_FONT_SIZE_4_ITEM, GetOrientation(), multilineFontSize); // 24
4662         }
4663
4664         for (int i = 4; i < __itemCount ; i++)
4665         {
4666                 itemWidth[i] = itemWidth[0];
4667
4668                 __pItems.at(i)->SetBounds(FloatRectangle(__pItems.at(i-1)->GetBoundsF().x + dividerWidth + itemWidth[i], vmargin, itemWidth[i], segmentedItemHeight));
4669         }
4670
4671         for (int i = 0; i < __itemCount ; i++)
4672         {
4673                 __pItems.at(i)->SetTextSize(fontSize, FONT_STYLE_BOLD);
4674                 __pItems.at(i)->SetMultilineTextSize(multilineFontSize);
4675
4676                 if (__pItems.at(i)->GetChildCount() != 0)
4677                 {
4678                         _Label* existingBadgeIcon = dynamic_cast<_Label*>(__pItems.at(i)->GetChild(0));
4679
4680                         if (existingBadgeIcon)
4681                         {
4682                                 existingBadgeIcon->SetPosition(FloatPoint(__pItems.at(i)->GetSizeF().width - existingBadgeIcon->GetSizeF().width, 0));
4683                                 existingBadgeIcon = null;
4684                         }
4685                 }
4686
4687                 RealignItem(__pItems.at(i), __pItems.at(i)->GetTextExtentSizeF());
4688         }
4689
4690         return E_SUCCESS;
4691 }
4692
4693 result
4694 _Toolbar::RearrangeButtonItems(void)
4695 {
4696         float itemHeight = 0.0f;
4697         float maxItemLength = 0.0f;
4698         float minItemLength = 0.0f;
4699         float iconSizeWithText = 0.0f;
4700         float sideMargin = 0.0f;
4701         float topMargin = 0.0f;
4702         float itemButtonLeftGap = 0.0f;
4703         float itemButtonRightGap = 0.0f;
4704         float tabLeftMargin = 0.0f;
4705         float sipFooterItemTopMargin = 0.0f;
4706         float dividerWidth = 0.0f;
4707         float iconSize = 0.0f;
4708         float footerLeftMargin = 0.0f;
4709         float segmentedItemHeight = 0.0f;
4710         float headerLeftMargin = 0.0f;
4711         float blockWidth[__itemCount];
4712         float fontSize = 0.0f;
4713         float multilineFontSize = 0.0f;
4714
4715         GET_SHAPE_CONFIG(HEADER::SIP_FOOTER_ITEM_TOP_MARGIN, GetOrientation(), sipFooterItemTopMargin);
4716         GET_SHAPE_CONFIG(HEADER::DIVIDER_WIDTH, GetOrientation(), dividerWidth);
4717         GET_SHAPE_CONFIG(FOOTER::FOOTER_ITEM_ICON_SIZE, GetOrientation(), iconSize);
4718         GET_SHAPE_CONFIG(FOOTER::LEFT_MARGIN, GetOrientation(), footerLeftMargin);
4719         GET_SHAPE_CONFIG(HEADER::TAB_LEFT_MARGIN, GetOrientation(), tabLeftMargin);
4720         GET_SHAPE_CONFIG(FOOTER::FOOTER_ITEM_BUTTON_STYLE_SIDE_MARGIN, GetOrientation(), sideMargin);
4721         GET_SHAPE_CONFIG(HEADER::BUTTON_ITEM_ICON_TOP_MARGIN, GetOrientation(), topMargin);
4722         GET_SHAPE_CONFIG(HEADER::SEGMENTED_ITEM_HEIGHT, GetOrientation(), segmentedItemHeight);
4723         GET_SHAPE_CONFIG(HEADER::LEFT_MARGIN, GetOrientation(), headerLeftMargin);
4724
4725         float tabRightMargin = tabLeftMargin;
4726
4727         if (__style == TOOLBAR_TEXT || __style == TOOLBAR_ICON || __style == TOOLBAR_ICON_TEXT)
4728         {
4729                 GET_SHAPE_CONFIG(FOOTER::BUTTON_ITEM_TEXT_HEIGHT, GetOrientation(), itemHeight);
4730         }
4731         else
4732         {
4733                 itemHeight = GetSizeF().height;
4734         }
4735
4736         if (__itemCount == 1)
4737         {
4738                 float textExtentSize_0 = __pItems.at(0)->GetTextExtentSizeF();
4739
4740                 if (__style == TOOLBAR_TITLE) // item 1, HEADER_STYLE_TITLE_BUTTON
4741                 {
4742                         blockWidth[0] = __titleTextArea.width;
4743                         itemHeight = segmentedItemHeight;
4744                         __pItems.at(0)->SetBounds(FloatRectangle(headerLeftMargin, topMargin, blockWidth[0], itemHeight));
4745                         __pItems.at(0)->SetMargin(0.0f, 0.0f, 0.0f, 0.0f);
4746                 }
4747                 else
4748                 {
4749                         GET_SHAPE_CONFIG(FOOTER::FOOTER_ITEM_WIDTH_1_MAX, GetOrientation(), maxItemLength);
4750                         GET_SHAPE_CONFIG(FOOTER::FOOTER_ITEM_WIDTH_1_MIN, GetOrientation(), minItemLength);
4751                         GET_SHAPE_CONFIG(FOOTER::FOOTER_ITEM_BUTTON_STYLE_ICON_SIZE_WITH_TEXT, GetOrientation(), iconSizeWithText);
4752
4753                         if (!(__pItems.at(0)->GetBitmap(_BUTTON_STATUS_NORMAL) == null
4754                                         && __pItems.at(0)->GetBitmap(_BUTTON_STATUS_DISABLED) == null
4755                                         && __pItems.at(0)->GetBitmap(_BUTTON_STATUS_PRESSED) == null
4756                                         && __pItems.at(0)->GetBitmap(_BUTTON_STATUS_SELECTED) == null
4757                                         && __pItems.at(0)->GetBitmap(_BUTTON_STATUS_HIGHLIGHTED) == null)) // at least 1 bitmap
4758                         {
4759                                 blockWidth[0] = textExtentSize_0 + iconSizeWithText + sideMargin * 3;
4760                         }
4761                         else
4762                         {
4763                                 blockWidth[0] = textExtentSize_0 + sideMargin * 2;
4764                         }
4765
4766                         if (blockWidth[0] > maxItemLength)
4767                         {
4768                                 blockWidth[0] = maxItemLength;
4769                         }
4770                         if (blockWidth[0] < minItemLength)
4771                         {
4772                                 blockWidth[0] = minItemLength;
4773                         }
4774
4775                         tabLeftMargin = footerLeftMargin;
4776                         itemButtonLeftGap = footerLeftMargin;
4777                         __itemArea.width -= ((tabLeftMargin + iconSize + itemButtonLeftGap) * 2);
4778
4779                         if (blockWidth[0] > __itemArea.width)
4780                         {
4781                                 blockWidth[0] = __itemArea.width;
4782                         }
4783
4784                         if (__header == true && __style == TOOLBAR_TEXT && GetOrientation() == _CONTROL_ORIENTATION_PORTRAIT) // sip
4785                         {
4786                                 __pItems.at(0)->SetBounds(FloatRectangle((GetSizeF().width - blockWidth[0]) / 2, sipFooterItemTopMargin, blockWidth[0], itemHeight));
4787                         }
4788                         else
4789                         {
4790                                 __pItems.at(0)->SetBounds(FloatRectangle((GetSizeF().width - blockWidth[0]) / 2, (GetSizeF().height - itemHeight) / 2, blockWidth[0], itemHeight));
4791                         }
4792                 }
4793
4794                 for (int i = 0; i < __itemCount; i++)
4795                 {
4796                         if (__pItems.at(i)->GetChildCount() != 0)
4797                         {
4798                                 _Label* existingBadgeIcon = dynamic_cast<_Label*>(__pItems.at(i)->GetChild(0));
4799
4800                                 if (existingBadgeIcon)
4801                                 {
4802                                         existingBadgeIcon->SetPosition(FloatPoint(blockWidth[i] - existingBadgeIcon->GetSizeF().width, 0));
4803                                         existingBadgeIcon = null;
4804                                 }
4805                         }
4806                 }
4807
4808                 RealignItem(__pItems.at(0), textExtentSize_0);
4809         }
4810         else if(__itemCount == 2)
4811         {
4812                 float itemGap = 0.0f;
4813
4814                 float textExtentSize_0 = __pItems.at(0)->GetTextExtentSizeF();
4815                 float textExtentSize_1 = __pItems.at(1)->GetTextExtentSizeF();
4816
4817                 GET_SHAPE_CONFIG(FOOTER::FOOTER_ITEM_WIDTH_2_MAX, GetOrientation(), maxItemLength);
4818                 GET_SHAPE_CONFIG(FOOTER::FOOTER_ITEM_WIDTH_2_MIN, GetOrientation(), minItemLength);
4819                 GET_SHAPE_CONFIG(FOOTER::FOOTER_ITEM_BUTTON_STYLE_ICON_SIZE_WITH_TEXT, GetOrientation(), iconSizeWithText);
4820                 GET_SHAPE_CONFIG(FOOTER::FOOTER_ITEM_BUTTON_STYLE_ITEM_GAP, GetOrientation(), itemGap);
4821
4822                 if (!(__pItems.at(0)->GetBitmap(_BUTTON_STATUS_NORMAL) == null
4823                                 && __pItems.at(0)->GetBitmap(_BUTTON_STATUS_DISABLED) == null
4824                                 && __pItems.at(0)->GetBitmap(_BUTTON_STATUS_PRESSED) == null
4825                                 && __pItems.at(0)->GetBitmap(_BUTTON_STATUS_SELECTED) == null
4826                                 && __pItems.at(0)->GetBitmap(_BUTTON_STATUS_HIGHLIGHTED) == null)) // at least 1 bitmap
4827                 {
4828                         blockWidth[0] = textExtentSize_0 + iconSizeWithText + sideMargin * 3;
4829                 }
4830                 else
4831                 {
4832                         blockWidth[0] = textExtentSize_0 + sideMargin * 2;
4833                 }
4834
4835                 if (blockWidth[0] > maxItemLength)
4836                 {
4837                         blockWidth[0] = maxItemLength;
4838                 }
4839                 if (blockWidth[0] < minItemLength)
4840                 {
4841                         blockWidth[0] = minItemLength;
4842                 }
4843
4844                 if (!(__pItems.at(1)->GetBitmap(_BUTTON_STATUS_NORMAL) == null
4845                                 && __pItems.at(1)->GetBitmap(_BUTTON_STATUS_DISABLED) == null
4846                                 && __pItems.at(1)->GetBitmap(_BUTTON_STATUS_PRESSED) == null
4847                                 && __pItems.at(1)->GetBitmap(_BUTTON_STATUS_SELECTED) == null
4848                                 && __pItems.at(1)->GetBitmap(_BUTTON_STATUS_HIGHLIGHTED) == null)) // at least 1 bitmap
4849                 {
4850                         blockWidth[1] = textExtentSize_1 + iconSizeWithText + sideMargin * 3;
4851                 }
4852                 else
4853                 {
4854                         blockWidth[1] = textExtentSize_1 + sideMargin * 2;
4855                 }
4856
4857                 if (blockWidth[1] > maxItemLength)
4858                 {
4859                         blockWidth[1] = maxItemLength;
4860                 }
4861                 if (blockWidth[1] < minItemLength)
4862                 {
4863                         blockWidth[1] = minItemLength;
4864                 }
4865
4866                 tabLeftMargin = footerLeftMargin;
4867                 itemButtonLeftGap = footerLeftMargin;
4868                 __itemArea.width -= ((tabLeftMargin + iconSize + itemButtonLeftGap) * 2);
4869
4870                 if (blockWidth[0] > (__itemArea.width - itemGap * 2) / 2)
4871                 {
4872                         blockWidth[0] = (__itemArea.width - itemGap * 2) / 2;
4873                 }
4874
4875                 if (blockWidth[1] > (__itemArea.width - itemGap * 2) / 2)
4876                 {
4877                         blockWidth[1] = (__itemArea.width - itemGap * 2) / 2;
4878                 }
4879
4880                 if (__header == true && __style == TOOLBAR_TEXT && GetOrientation() == _CONTROL_ORIENTATION_PORTRAIT) // sip
4881                 {
4882                         __pItems.at(0)->SetBounds(FloatRectangle(GetSizeF().width / 2 - itemGap - blockWidth[0], sipFooterItemTopMargin, blockWidth[0], itemHeight));
4883                         __pItems.at(1)->SetBounds(FloatRectangle(GetSizeF().width / 2 + itemGap, sipFooterItemTopMargin, blockWidth[1], itemHeight));
4884                 }
4885                 else
4886                 {
4887                         __pItems.at(0)->SetBounds(FloatRectangle(GetSizeF().width / 2 - itemGap - blockWidth[0], (GetSizeF().height - itemHeight) / 2, blockWidth[0], itemHeight));
4888                         __pItems.at(1)->SetBounds(FloatRectangle(GetSizeF().width / 2 + itemGap, (GetSizeF().height - itemHeight) / 2, blockWidth[1], itemHeight));
4889                 }
4890
4891                 for (int i = 0; i < __itemCount; i++)
4892                 {
4893                         if (__pItems.at(i)->GetChildCount() != 0)
4894                         {
4895                                 _Label* existingBadgeIcon = dynamic_cast<_Label*>(__pItems.at(i)->GetChild(0));
4896
4897                                 if (existingBadgeIcon)
4898                                 {
4899                                         existingBadgeIcon->SetPosition(FloatPoint(blockWidth[i] - existingBadgeIcon->GetSizeF().width, 0));
4900                                         existingBadgeIcon = null;
4901                                 }
4902                         }
4903                 }
4904
4905                 RealignItem(__pItems.at(0), textExtentSize_0);
4906                 RealignItem(__pItems.at(1), textExtentSize_1);
4907         }
4908         else if (__itemCount == 3)
4909         {
4910                 if (__pButtonItems[LEFT_BUTTON])
4911                 {
4912                         if (__pButtonItems[RIGHT_BUTTON] || __pButtonItems[BACK_BUTTON])
4913                         {
4914                                 tabLeftMargin = footerLeftMargin;
4915                                 itemButtonLeftGap = footerLeftMargin;
4916                                 __itemArea.width -= ((tabLeftMargin + iconSize + itemButtonLeftGap) * 2);
4917                         }
4918                         else
4919                         {
4920                                 tabLeftMargin = footerLeftMargin;
4921                                 itemButtonLeftGap = footerLeftMargin;
4922                                 __itemArea.width -= (tabLeftMargin + iconSize + itemButtonLeftGap + tabRightMargin);
4923                         }
4924                 }
4925                 else
4926                 {
4927                         if (__pButtonItems[RIGHT_BUTTON] || __pButtonItems[BACK_BUTTON])
4928                         {
4929                                 tabRightMargin = footerLeftMargin;
4930                                 itemButtonRightGap = footerLeftMargin;
4931                                 __itemArea.width -= (tabLeftMargin + itemButtonRightGap + iconSize + tabRightMargin);
4932                         }
4933                         else
4934                         {
4935                                 __itemArea.width -= tabLeftMargin * 2;
4936                         }
4937
4938                         iconSize = 0;
4939                 }
4940
4941                 blockWidth[0] = blockWidth[1] = blockWidth[2] = (__itemArea.width - dividerWidth * 2) / 3;
4942
4943                 if (__header == true && __style == TOOLBAR_TEXT && GetOrientation() == _CONTROL_ORIENTATION_PORTRAIT) // sip
4944                 {
4945                         __pItems.at(0)->SetBounds(FloatRectangle(tabLeftMargin + iconSize + itemButtonLeftGap, sipFooterItemTopMargin, blockWidth[0], itemHeight));
4946                         __pItems.at(1)->SetBounds(FloatRectangle(tabLeftMargin + iconSize + itemButtonLeftGap + blockWidth[0] + dividerWidth, sipFooterItemTopMargin, blockWidth[1], itemHeight));
4947                         __pItems.at(2)->SetBounds(FloatRectangle(tabLeftMargin + iconSize + itemButtonLeftGap + blockWidth[0] + blockWidth[1] + dividerWidth * 2,
4948                                         sipFooterItemTopMargin, blockWidth[2], itemHeight));
4949                 }
4950                 else
4951                 {
4952                         __pItems.at(0)->SetBounds(FloatRectangle(tabLeftMargin + iconSize + itemButtonLeftGap, (GetSizeF().height - itemHeight) / 2, blockWidth[0], itemHeight));
4953                         __pItems.at(1)->SetBounds(FloatRectangle(tabLeftMargin + iconSize + itemButtonLeftGap + blockWidth[0] + dividerWidth, (GetSizeF().height - itemHeight) / 2, blockWidth[1], itemHeight));
4954                         __pItems.at(2)->SetBounds(FloatRectangle(tabLeftMargin + iconSize + itemButtonLeftGap + blockWidth[0] + blockWidth[1] + dividerWidth * 2,
4955                                         (GetSizeF().height - itemHeight) / 2, blockWidth[2], itemHeight));
4956                 }
4957
4958                 for (int i = 0; i < __itemCount; i++)
4959                 {
4960                         if (__pItems.at(i)->GetChildCount() != 0)
4961                         {
4962                                 _Label* existingBadgeIcon = dynamic_cast<_Label*>(__pItems.at(i)->GetChild(0));
4963
4964                                 if (existingBadgeIcon)
4965                                 {
4966                                         existingBadgeIcon->SetPosition(FloatPoint(blockWidth[i] - existingBadgeIcon->GetSizeF().width, 0));
4967                                         existingBadgeIcon = null;
4968                                 }
4969                         }
4970
4971                         RealignItem(__pItems.at(i), __pItems.at(i)->GetTextExtentSizeF());
4972                 }
4973         }
4974         else if (__itemCount == 4)
4975         {
4976                 if (__pButtonItems[BACK_BUTTON])
4977                 {
4978                         tabRightMargin = footerLeftMargin;
4979                         itemButtonRightGap = footerLeftMargin;
4980                         __itemArea.width -= (tabLeftMargin + itemButtonRightGap + iconSize + tabRightMargin);
4981                 }
4982                 else
4983                 {
4984                         __itemArea.width -= tabLeftMargin * 2;
4985                 }
4986
4987                 blockWidth[0] = blockWidth[1] = blockWidth[2] = blockWidth[3] = (__itemArea.width - dividerWidth * 3) / 4;
4988
4989                 if (__header == true && __style == TOOLBAR_TEXT && GetOrientation() == _CONTROL_ORIENTATION_PORTRAIT) // sip
4990                 {
4991                         __pItems.at(0)->SetBounds(FloatRectangle(tabLeftMargin, sipFooterItemTopMargin, blockWidth[0], itemHeight));
4992                         __pItems.at(1)->SetBounds(FloatRectangle(tabLeftMargin + blockWidth[0] + dividerWidth, sipFooterItemTopMargin, blockWidth[1], itemHeight));
4993                         __pItems.at(2)->SetBounds(FloatRectangle(tabLeftMargin + blockWidth[0] + blockWidth[1] + dividerWidth * 2,
4994                                         sipFooterItemTopMargin, blockWidth[2], itemHeight));
4995                         __pItems.at(3)->SetBounds(FloatRectangle(tabLeftMargin + blockWidth[0] + blockWidth[1] + blockWidth[2] + dividerWidth * 3,
4996                                         sipFooterItemTopMargin, blockWidth[3], itemHeight));
4997                 }
4998                 else
4999                 {
5000                         __pItems.at(0)->SetBounds(FloatRectangle(tabLeftMargin, (GetSizeF().height - itemHeight) / 2, blockWidth[0], itemHeight));
5001                         __pItems.at(1)->SetBounds(FloatRectangle(tabLeftMargin + blockWidth[0] + dividerWidth, (GetSizeF().height - itemHeight) / 2, blockWidth[1], itemHeight));
5002                         __pItems.at(2)->SetBounds(FloatRectangle(tabLeftMargin + blockWidth[0] + blockWidth[1] + dividerWidth * 2,
5003                                         (GetSizeF().height - itemHeight) / 2, blockWidth[2], itemHeight));
5004                         __pItems.at(3)->SetBounds(FloatRectangle(tabLeftMargin + blockWidth[0] + blockWidth[1] + blockWidth[2] + dividerWidth * 3,
5005                                         (GetSizeF().height - itemHeight) / 2, blockWidth[3], itemHeight));
5006                 }
5007
5008                 for (int i = 0; i < __itemCount; i++)
5009                 {
5010                         if (__pItems.at(i)->GetChildCount() != 0)
5011                         {
5012                                 _Label* existingBadgeIcon = dynamic_cast<_Label*>(__pItems.at(i)->GetChild(0));
5013
5014                                 if (existingBadgeIcon)
5015                                 {
5016                                         existingBadgeIcon->SetPosition(FloatPoint(blockWidth[i] - existingBadgeIcon->GetSizeF().width, 0));
5017                                         existingBadgeIcon = null;
5018                                 }
5019                         }
5020
5021                         RealignItem(__pItems.at(i), __pItems.at(i)->GetTextExtentSizeF());
5022                 }
5023         }
5024         else if (__itemCount == 5)
5025         {
5026                 if (__pButtonItems[BACK_BUTTON])
5027                 {
5028                         tabRightMargin = footerLeftMargin;
5029                         itemButtonRightGap = footerLeftMargin;
5030                         __itemArea.width -= (tabLeftMargin + itemButtonRightGap + iconSize + tabRightMargin);
5031                 }
5032                 else
5033                 {
5034                         __itemArea.width -= tabLeftMargin * 2;
5035                 }
5036
5037                 blockWidth[0] = blockWidth[1] = blockWidth[2] = blockWidth[3] = blockWidth[4] = (__itemArea.width - dividerWidth * 4) / 5;
5038
5039                 if (__header == true && __style == TOOLBAR_TEXT && GetOrientation() == _CONTROL_ORIENTATION_PORTRAIT) // sip
5040                 {
5041                         __pItems.at(0)->SetBounds(FloatRectangle(tabLeftMargin, sipFooterItemTopMargin, blockWidth[0], itemHeight));
5042                         __pItems.at(1)->SetBounds(FloatRectangle(tabLeftMargin + blockWidth[0] + dividerWidth, sipFooterItemTopMargin, blockWidth[1], itemHeight));
5043                         __pItems.at(2)->SetBounds(FloatRectangle(tabLeftMargin + blockWidth[0] + blockWidth[1] + dividerWidth * 2,
5044                                         sipFooterItemTopMargin, blockWidth[2], itemHeight));
5045                         __pItems.at(3)->SetBounds(FloatRectangle(tabLeftMargin + blockWidth[0] + blockWidth[1] + blockWidth[2] + dividerWidth * 3,
5046                                         sipFooterItemTopMargin, blockWidth[3], itemHeight));
5047                         __pItems.at(4)->SetBounds(FloatRectangle(tabLeftMargin + blockWidth[0] + blockWidth[1] + blockWidth[2] + blockWidth[3] + dividerWidth * 4,
5048                                         sipFooterItemTopMargin, blockWidth[4], itemHeight));
5049                 }
5050                 else
5051                 {
5052                         __pItems.at(0)->SetBounds(FloatRectangle(tabLeftMargin, (GetSizeF().height - itemHeight) / 2, blockWidth[0], itemHeight));
5053                         __pItems.at(1)->SetBounds(FloatRectangle(tabLeftMargin + blockWidth[0] + dividerWidth, (GetSizeF().height - itemHeight) / 2, blockWidth[1], itemHeight));
5054                         __pItems.at(2)->SetBounds(FloatRectangle(tabLeftMargin + blockWidth[0] + blockWidth[1] + dividerWidth * 2,
5055                                         (GetSizeF().height - itemHeight) / 2, blockWidth[2], itemHeight));
5056                         __pItems.at(3)->SetBounds(FloatRectangle(tabLeftMargin + blockWidth[0] + blockWidth[1] + blockWidth[2] + dividerWidth * 3,
5057                                         (GetSizeF().height - itemHeight) / 2, blockWidth[3], itemHeight));
5058                         __pItems.at(4)->SetBounds(FloatRectangle(tabLeftMargin + blockWidth[0] + blockWidth[1] + blockWidth[2] + blockWidth[3] + dividerWidth * 4,
5059                                         (GetSizeF().height - itemHeight) / 2, blockWidth[4], itemHeight));
5060                 }
5061
5062                 for (int i = 0; i < __itemCount; i++)
5063                 {
5064                         if (__pItems.at(i)->GetChildCount() != 0)
5065                         {
5066                                 _Label* existingBadgeIcon = dynamic_cast<_Label*>(__pItems.at(i)->GetChild(0));
5067
5068                                 if (existingBadgeIcon)
5069                                 {
5070                                         existingBadgeIcon->SetPosition(FloatPoint(blockWidth[i] - existingBadgeIcon->GetSizeF().width, 0));
5071                                         existingBadgeIcon = null;
5072                                 }
5073                         }
5074
5075                         RealignItem(__pItems.at(i), __pItems.at(i)->GetTextExtentSizeF());
5076                 }
5077         }
5078
5079         GET_SHAPE_CONFIG(FOOTER::FOOTER_ITEM_FONT_SIZE, GetOrientation(), fontSize);//32
5080
5081         for (int i = 0; i < __itemCount; i++)
5082         {
5083                 if (__style == TOOLBAR_ICON_TEXT && (__pItems.at(i)->GetBitmap(_BUTTON_STATUS_NORMAL) || __pItems.at(i)->GetBitmap(_BUTTON_STATUS_PRESSED)))
5084                 {
5085                         if (__itemCount == 5)
5086                         {
5087                                 GET_SHAPE_CONFIG(FOOTER::BUTTON_ITEM_TEXT_FONT_SIZE_ITEM_5_WITH_ICON, GetOrientation(), multilineFontSize);//18
5088                         }
5089                         else
5090                         {
5091                                 GET_SHAPE_CONFIG(FOOTER::BUTTON_ITEM_TEXT_FONT_SIZE_ITEM_3_WITH_ICON, GetOrientation(), multilineFontSize);//22
5092                         }
5093                 }
5094                 else
5095                 {
5096                         if (__itemCount == 5)
5097                         {
5098                                 GET_SHAPE_CONFIG(FOOTER::BUTTON_ITEM_TEXT_FONT_SIZE_ITEM_5, GetOrientation(), multilineFontSize);//22
5099                         }
5100                         else
5101                         {
5102                                 GET_SHAPE_CONFIG(FOOTER::BUTTON_ITEM_TEXT_FONT_SIZE_ITEM_3, GetOrientation(), multilineFontSize);//24
5103                         }
5104                 }
5105
5106                 __pItems.at(i)->SetTextSize(fontSize, FONT_STYLE_BOLD);
5107                 __pItems.at(i)->SetMultilineTextSize(multilineFontSize);
5108         }
5109
5110         return E_SUCCESS;
5111 }
5112
5113 result
5114 _Toolbar::SetAnimation(ToolbarAnimationPosition animationPos)
5115 {
5116         SysTryReturnResult(NID_UI_CTRL, (0 <= animationPos && animationPos < 3), E_INVALID_ARG,
5117                                 "[E_INVALID_ARG] The animationPos is invalid.");
5118
5119         if (__pAnimation[animationPos])
5120         {
5121                 if (__pAnimation[animationPos]->GetStatus() == ANIMATION_PLAYING)
5122                 {
5123                         return E_SUCCESS;
5124                 }
5125         }
5126
5127         if (__pAnimationFrameList[animationPos])
5128         {
5129                 __pAnimationFrameList[animationPos]->RemoveAll(true);
5130
5131                 delete __pAnimationFrameList[animationPos];
5132                 __pAnimationFrameList[animationPos] = null;
5133         }
5134
5135         result r = GET_ANIMATION_CONFIG_N(HEADER::PROCESSING_ANIMATION, __pAnimationFrameList[animationPos]);
5136         SysTryReturnResult(NID_UI_CTRL, r == E_SUCCESS, E_SYSTEM, "[E_SYSTEM] Couldn't get an animationframe.");
5137
5138         delete __pAnimation[animationPos];
5139         __pAnimation[animationPos] = null;
5140
5141         __pAnimation[animationPos] = _Animation::CreateAnimationN();
5142
5143         float processingAnimationIconSize = 0.0f;
5144
5145         GET_SHAPE_CONFIG(HEADER::PROCESSING_ANIMATION_ICON_SIZE, GetOrientation(), processingAnimationIconSize);
5146
5147         if (__pAnimation[animationPos])
5148         {
5149                 __pAnimation[animationPos]->SetSize(FloatDimension(processingAnimationIconSize, processingAnimationIconSize));
5150
5151                 if (__pAnimationFrameList[animationPos])
5152                 {
5153                         __pAnimation[animationPos]->SetAnimationFrames(*__pAnimationFrameList[animationPos]);
5154                         __pAnimation[animationPos]->SetImageCount(__pAnimationFrameList[animationPos]->GetCount());
5155                         __pAnimation[animationPos]->SetRepeatCount(100);
5156                         __pAnimation[animationPos]->AddAnimationEventListener(*this);
5157                 }
5158
5159                 if (animationPos == TOOLBAR_ANIMATION_POSITION_TITLE)
5160                 {
5161                         AttachChild(*__pAnimation[animationPos]);
5162                 }
5163                 else if (animationPos == TOOLBAR_ANIMATION_POSITION_BUTTON_LEFT)
5164                 {
5165                         __pButtonItems[LEFT_BUTTON]->AttachChild(*__pAnimation[animationPos]);
5166
5167                         float topTouchMargin = __pButtonItems[LEFT_BUTTON]->GetTopTouchMarginF();
5168                         float bottomTouchMargin = __pButtonItems[LEFT_BUTTON]->GetBottomTouchMarginF();
5169
5170                         SetWaitingAnimationPosition(TOOLBAR_ANIMATION_POSITION_BUTTON_LEFT,
5171                                         (__pButtonItems[LEFT_BUTTON]->GetSizeF().width - processingAnimationIconSize) / 2,
5172                                         topTouchMargin + (__pButtonItems[LEFT_BUTTON]->GetSizeF().height - topTouchMargin - bottomTouchMargin - processingAnimationIconSize) / 2);
5173                 }
5174                 else if (animationPos == TOOLBAR_ANIMATION_POSITION_BUTTON_RIGHT)
5175                 {
5176                         __pButtonItems[RIGHT_BUTTON]->AttachChild(*__pAnimation[animationPos]);
5177
5178                         float topTouchMargin = __pButtonItems[RIGHT_BUTTON]->GetTopTouchMarginF();
5179                         float bottomTouchMargin = __pButtonItems[RIGHT_BUTTON]->GetBottomTouchMarginF();
5180
5181                         SetWaitingAnimationPosition(TOOLBAR_ANIMATION_POSITION_BUTTON_RIGHT,
5182                                         (__pButtonItems[RIGHT_BUTTON]->GetSizeF().width - processingAnimationIconSize) / 2,
5183                                         topTouchMargin + (__pButtonItems[RIGHT_BUTTON]->GetSizeF().height - topTouchMargin - bottomTouchMargin - processingAnimationIconSize) / 2);
5184                 }
5185                 _AccessibilityContainer* pContainer = __pAnimation[animationPos]->GetAccessibilityContainer();
5186                 if (pContainer)
5187                 {
5188                         pContainer->Activate(false);
5189                 }
5190         }
5191
5192         return E_SUCCESS;
5193 }
5194
5195 result
5196 _Toolbar::SetColorReplacedBitmap(_Button* pButton, const _ButtonStatus status,
5197                 const Color& color, const Bitmap* pBitmap)
5198 {
5199         SysTryReturnResult(NID_UI_CTRL, pButton, E_INVALID_ARG, "[E_INVALID_ARG] The button pointer is null.");
5200         SysTryReturnResult(NID_UI_CTRL, pBitmap, E_INVALID_ARG, "[E_INVALID_ARG] The bitmap pointer is null.");
5201
5202         Bitmap* __pColorReplacedBitmap = null;
5203
5204         __pColorReplacedBitmap = _BitmapImpl::GetColorReplacedBitmapN(*pBitmap, Color::GetColor(COLOR_ID_MAGENTA), color);
5205
5206         if (__pColorReplacedBitmap)
5207         {
5208                 if (color.GetAlpha() != 0xFF)
5209                 {
5210                         __pColorReplacedBitmap->SetAlphaConstant(color.GetAlpha());
5211                 }
5212
5213                 pButton->SetBackgroundBitmap(status, *__pColorReplacedBitmap);
5214                 delete __pColorReplacedBitmap;
5215         }
5216
5217         return E_SUCCESS;
5218 }
5219
5220 result
5221 _Toolbar::SetPropertyColor(const Variant& color)
5222 {
5223         result r = E_SUCCESS;
5224
5225         _Control::SetBackgroundColor(color.ToColor());
5226
5227         return r;
5228 }
5229
5230 Variant
5231 _Toolbar::GetPropertyColor(void) const
5232 {
5233         return Variant(_Control::GetBackgroundColor());
5234 }
5235
5236 result
5237 _Toolbar::SetPropertyDescriptionText(const Variant& text)
5238 {
5239         __descriptionText = text.ToString();
5240
5241         result r = E_SUCCESS;
5242
5243         r = __pToolbarPresenter->SetDescriptionText(__descriptionText);
5244
5245         if(__pTitleTextElement)
5246         {
5247                 if (text.IsEmpty())
5248                 {
5249                         __pTitleTextElement->SetLabel(__titleText);
5250                 }
5251                 else
5252                 {
5253                         __pTitleTextElement->SetLabel(__titleText + L", " + __descriptionText);
5254                 }
5255         }
5256
5257         return r;
5258 }
5259
5260 Variant
5261 _Toolbar::GetPropertyDescriptionText(void) const
5262 {
5263         return Variant(__descriptionText);
5264 }
5265
5266 result
5267 _Toolbar::SetPropertyDescriptionTextColor(const Variant& color)
5268 {
5269         __descriptionTextColor = color.ToColor();
5270
5271         return E_SUCCESS;
5272 }
5273
5274 Variant
5275 _Toolbar::GetPropertyDescriptionTextColor(void) const
5276 {
5277         return Variant(__descriptionTextColor);
5278 }
5279
5280 result
5281 _Toolbar::SetPropertyTitleText(const Variant& text)
5282 {
5283         __titleText = text.ToString();
5284
5285         if(__pTitleTextElement)
5286         {
5287                 __pTitleTextElement->SetLabel(__titleText);
5288         }
5289
5290         return E_SUCCESS;
5291 }
5292
5293 Variant
5294 _Toolbar::GetPropertyTitleText(void) const
5295 {
5296         return Variant(__titleText);
5297 }
5298
5299 result
5300 _Toolbar::SetPropertyTitleTextColor(const Variant& color)
5301 {
5302         __titleTextColor = color.ToColor();
5303
5304         return E_SUCCESS;
5305 }
5306
5307 Variant
5308 _Toolbar::GetPropertyTitleTextColor(void) const
5309 {
5310         return Variant(__titleTextColor);
5311 }
5312
5313 result
5314 _Toolbar::SetPropertyDisabledButtonColor(const Variant& color)
5315 {
5316         __buttonBackgroundColor[_BUTTON_STATUS_DISABLED] = color.ToColor();
5317
5318         Bitmap* __pBaseBackgroundBitmap = null;
5319
5320         GET_BITMAP_CONFIG_N(HEADER::BUTTON_BG_DISABLED, BITMAP_PIXEL_FORMAT_ARGB8888, __pBaseBackgroundBitmap);
5321
5322         for (int i = 0; i < BUTTON_MAX; i++)
5323         {
5324                 if (__pButtonItems[i] != null)
5325                 {
5326                         if (__pBaseBackgroundBitmap)
5327                         {
5328                                 SetColorReplacedBitmap(__pButtonItems[i], _BUTTON_STATUS_DISABLED, __buttonBackgroundColor[_BUTTON_STATUS_DISABLED], __pBaseBackgroundBitmap);
5329                         }
5330                 }
5331         }
5332
5333         delete __pBaseBackgroundBitmap;
5334
5335         return E_SUCCESS;
5336 }
5337
5338 Variant
5339 _Toolbar::GetPropertyDisabledButtonColor(void) const
5340 {
5341         return Variant(__buttonBackgroundColor[_BUTTON_STATUS_DISABLED]);
5342 }
5343
5344 result
5345 _Toolbar::SetPropertyDisabledButtonTextColor(const Variant& color)
5346 {
5347         __buttonTextColor[_BUTTON_STATUS_DISABLED] = color.ToColor();
5348
5349         for (int i = 0; i < BUTTON_MAX; i++)
5350         {
5351                 if (__pButtonItems[i] != null)
5352                 {
5353                         __pButtonItems[i]->SetTextColor(_BUTTON_STATUS_DISABLED, __buttonTextColor[_BUTTON_STATUS_DISABLED]);
5354                 }
5355         }
5356
5357         return E_SUCCESS;
5358 }
5359
5360 Variant
5361 _Toolbar::GetPropertyDisabledButtonTextColor(void) const
5362 {
5363         return Variant(__buttonTextColor[_BUTTON_STATUS_DISABLED]);
5364 }
5365
5366 result
5367 _Toolbar::SetPropertyHighlightedButtonColor(const Variant& color)
5368 {
5369         __buttonBackgroundColor[_BUTTON_STATUS_HIGHLIGHTED] = color.ToColor();
5370
5371         Bitmap* __pBaseBackgroundBitmap = null;
5372
5373         GET_BITMAP_CONFIG_N(HEADER::BUTTON_BG_HIGHLIGHTED, BITMAP_PIXEL_FORMAT_ARGB8888, __pBaseBackgroundBitmap);
5374
5375         for (int i = 0; i < BUTTON_MAX; i++)
5376         {
5377                 if (__pButtonItems[i] != null)
5378                 {
5379                         if (__pBaseBackgroundBitmap)
5380                         {
5381                                 SetColorReplacedBitmap(__pButtonItems[i], _BUTTON_STATUS_HIGHLIGHTED, __buttonBackgroundColor[_BUTTON_STATUS_HIGHLIGHTED], __pBaseBackgroundBitmap);
5382                         }
5383                 }
5384         }
5385
5386         delete __pBaseBackgroundBitmap;
5387
5388         return E_SUCCESS;
5389 }
5390
5391 Variant
5392 _Toolbar::GetPropertyHighlightedButtonColor(void) const
5393 {
5394         return Variant(__buttonBackgroundColor[_BUTTON_STATUS_HIGHLIGHTED]);
5395 }
5396
5397 result
5398 _Toolbar::SetPropertyHighlightedButtonTextColor(const Variant& color)
5399 {
5400         __buttonTextColor[_BUTTON_STATUS_HIGHLIGHTED] = color.ToColor();
5401
5402         for (int i = 0; i < BUTTON_MAX; i++)
5403         {
5404                 if (__pButtonItems[i] != null)
5405                 {
5406                         __pButtonItems[i]->SetTextColor(_BUTTON_STATUS_HIGHLIGHTED, __buttonTextColor[_BUTTON_STATUS_HIGHLIGHTED]);
5407                 }
5408         }
5409
5410         return E_SUCCESS;
5411 }
5412
5413 Variant
5414 _Toolbar::GetPropertyHighlightedButtonTextColor(void) const
5415 {
5416         return Variant(__buttonTextColor[_BUTTON_STATUS_HIGHLIGHTED]);
5417 }
5418
5419 result
5420 _Toolbar::SetPropertyNormalButtonColor(const Variant& color)
5421 {
5422         __buttonBackgroundColor[_BUTTON_STATUS_NORMAL] = color.ToColor();
5423
5424         Bitmap* __pBaseBackgroundBitmap = null;
5425
5426         GET_BITMAP_CONFIG_N(HEADER::BUTTON_BG_NORMAL, BITMAP_PIXEL_FORMAT_ARGB8888, __pBaseBackgroundBitmap);
5427
5428         for (int i = 0; i < BUTTON_MAX; i++)
5429         {
5430                 if (__pButtonItems[i] != null)
5431                 {
5432                         if (__pBaseBackgroundBitmap)
5433                         {
5434                                 SetColorReplacedBitmap(__pButtonItems[i], _BUTTON_STATUS_NORMAL, __buttonBackgroundColor[_BUTTON_STATUS_NORMAL], __pBaseBackgroundBitmap);
5435                         }
5436                 }
5437         }
5438
5439         delete __pBaseBackgroundBitmap;
5440
5441         return E_SUCCESS;
5442 }
5443
5444 Variant
5445 _Toolbar::GetPropertyNormalButtonColor(void) const
5446 {
5447         return Variant(__buttonBackgroundColor[_BUTTON_STATUS_NORMAL]);
5448 }
5449
5450 result
5451 _Toolbar::SetPropertyNormalButtonTextColor(const Variant& color)
5452 {
5453         __buttonTextColor[_BUTTON_STATUS_NORMAL] = color.ToColor();
5454
5455         for (int i = 0; i < BUTTON_MAX; i++)
5456         {
5457                 if (__pButtonItems[i] != null)
5458                 {
5459                         __pButtonItems[i]->SetTextColor(_BUTTON_STATUS_NORMAL, __buttonTextColor[_BUTTON_STATUS_NORMAL]);
5460                 }
5461         }
5462
5463         return E_SUCCESS;
5464 }
5465
5466 Variant
5467 _Toolbar::GetPropertyNormalButtonTextColor(void) const
5468 {
5469         return Variant(__buttonTextColor[_BUTTON_STATUS_NORMAL]);
5470 }
5471
5472 result
5473 _Toolbar::SetPropertyPressedButtonColor(const Variant& color)
5474 {
5475         __buttonBackgroundColor[_BUTTON_STATUS_PRESSED] = color.ToColor();
5476
5477         Bitmap* __pBaseBackgroundBitmap = null;
5478
5479         GET_BITMAP_CONFIG_N(HEADER::BUTTON_BG_PRESSED, BITMAP_PIXEL_FORMAT_ARGB8888, __pBaseBackgroundBitmap);
5480
5481         for (int i = 0; i < BUTTON_MAX; i++)
5482         {
5483                 if (__pButtonItems[i] != null)
5484                 {
5485                         if (__pBaseBackgroundBitmap)
5486                         {
5487                                 SetColorReplacedBitmap(__pButtonItems[i], _BUTTON_STATUS_PRESSED, __buttonBackgroundColor[_BUTTON_STATUS_PRESSED], __pBaseBackgroundBitmap);
5488                         }
5489                 }
5490         }
5491
5492         delete __pBaseBackgroundBitmap;
5493
5494         return E_SUCCESS;
5495 }
5496
5497 Variant
5498 _Toolbar::GetPropertyPressedButtonColor(void) const
5499 {
5500         return Variant(__buttonBackgroundColor[_BUTTON_STATUS_PRESSED]);
5501 }
5502
5503 result
5504 _Toolbar::SetPropertyPressedButtonTextColor(const Variant& color)
5505 {
5506         __buttonTextColor[_BUTTON_STATUS_PRESSED] = color.ToColor();
5507
5508         for (int i = 0; i < BUTTON_MAX; i++)
5509         {
5510                 if (__pButtonItems[i] != null)
5511                 {
5512                         __pButtonItems[i]->SetTextColor(_BUTTON_STATUS_PRESSED, __buttonTextColor[_BUTTON_STATUS_PRESSED]);
5513                 }
5514         }
5515
5516         return E_SUCCESS;
5517 }
5518
5519 Variant
5520 _Toolbar::GetPropertyPressedButtonTextColor(void) const
5521 {
5522         return Variant(__buttonTextColor[_BUTTON_STATUS_PRESSED]);
5523 }
5524
5525 result
5526 _Toolbar::SetPropertyDisabledItemColor(const Variant& color)
5527 {
5528         __itemBackgroundColor[_BUTTON_STATUS_DISABLED] = color.ToColor();
5529
5530         Bitmap* __pBaseBackgroundBitmap = null;
5531
5532         if (__style == TOOLBAR_TEXT || __style == TOOLBAR_ICON || __style == TOOLBAR_ICON_TEXT)
5533         {
5534                 GET_BITMAP_CONFIG_N(FOOTER::BUTTON_ITEM_BG_DISABLED, BITMAP_PIXEL_FORMAT_ARGB8888, __pBaseBackgroundBitmap);
5535         }
5536         else
5537         {
5538                 GET_BITMAP_CONFIG_N(HEADER::TAB_ITEM_BG_DISABLED, BITMAP_PIXEL_FORMAT_ARGB8888, __pBaseBackgroundBitmap);
5539         }
5540
5541         for (int i = 0; i < __itemCount; i++)
5542         {
5543                 if (__pItems.at(i) != null)
5544                 {
5545                         if (__pBaseBackgroundBitmap)
5546                         {
5547                                 SetColorReplacedBitmap(__pItems.at(i), _BUTTON_STATUS_DISABLED, __itemBackgroundColor[_BUTTON_STATUS_DISABLED], __pBaseBackgroundBitmap);
5548                         }
5549                 }
5550         }
5551
5552         delete __pBaseBackgroundBitmap;
5553
5554         return E_SUCCESS;
5555 }
5556
5557 Variant
5558 _Toolbar::GetPropertyDisabledItemColor(void) const
5559 {
5560         return Variant(__itemBackgroundColor[_BUTTON_STATUS_DISABLED]);
5561 }
5562
5563 result
5564 _Toolbar::SetPropertyDisabledItemTextColor(const Variant& color)
5565 {
5566         __itemTextColor[_BUTTON_STATUS_DISABLED] = color.ToColor();
5567
5568         for (int i = 0; i < __itemCount; i++)
5569         {
5570                 if (__pItems.at(i) != null)
5571                 {
5572                         __pItems.at(i)->SetTextColor(_BUTTON_STATUS_DISABLED, __itemTextColor[_BUTTON_STATUS_DISABLED]);
5573                 }
5574         }
5575
5576         return E_SUCCESS;
5577 }
5578
5579 Variant
5580 _Toolbar::GetPropertyDisabledItemTextColor(void) const
5581 {
5582         return Variant(__itemTextColor[_BUTTON_STATUS_DISABLED]);
5583 }
5584
5585 result
5586 _Toolbar::SetPropertyHighlightedItemColor(const Variant& color)
5587 {
5588         __itemBackgroundColor[_BUTTON_STATUS_HIGHLIGHTED] = color.ToColor();
5589
5590         Bitmap* __pBaseBackgroundBitmap = null;
5591
5592         if (__style == TOOLBAR_TEXT || __style == TOOLBAR_ICON || __style == TOOLBAR_ICON_TEXT)
5593         {
5594                 GET_BITMAP_CONFIG_N(FOOTER::BUTTON_ITEM_BG_HIGHLIGHTED, BITMAP_PIXEL_FORMAT_ARGB8888, __pBaseBackgroundBitmap);
5595         }
5596         else
5597         {
5598                 GET_BITMAP_CONFIG_N(HEADER::TAB_ITEM_BG_HIGHLIGHTED, BITMAP_PIXEL_FORMAT_ARGB8888, __pBaseBackgroundBitmap);
5599         }
5600
5601         for (int i = 0; i < __itemCount; i++)
5602         {
5603                 if (__pItems.at(i) != null)
5604                 {
5605                         if (__pBaseBackgroundBitmap)
5606                         {
5607                                 SetColorReplacedBitmap(__pItems.at(i), _BUTTON_STATUS_HIGHLIGHTED, __itemBackgroundColor[_BUTTON_STATUS_HIGHLIGHTED], __pBaseBackgroundBitmap);
5608                         }
5609                 }
5610         }
5611
5612         delete __pBaseBackgroundBitmap;
5613
5614         return E_SUCCESS;
5615 }
5616
5617 Variant
5618 _Toolbar::GetPropertyHighlightedItemColor(void) const
5619 {
5620         return Variant(__itemBackgroundColor[_BUTTON_STATUS_HIGHLIGHTED]);
5621 }
5622
5623 result
5624 _Toolbar::SetPropertyHighlightedItemTextColor(const Variant& color)
5625 {
5626         __itemTextColor[_BUTTON_STATUS_HIGHLIGHTED] = color.ToColor();
5627
5628         for (int i = 0; i < __itemCount; i++)
5629         {
5630                 if (__pItems.at(i) != null)
5631                 {
5632                         __pItems.at(i)->SetTextColor(_BUTTON_STATUS_HIGHLIGHTED, __itemTextColor[_BUTTON_STATUS_HIGHLIGHTED]);
5633                 }
5634         }
5635
5636         return E_SUCCESS;
5637 }
5638
5639 Variant
5640 _Toolbar::GetPropertyHighlightedItemTextColor(void) const
5641 {
5642         return Variant(__itemTextColor[_BUTTON_STATUS_HIGHLIGHTED]);
5643 }
5644
5645 result
5646 _Toolbar::SetPropertyNormalItemColor(const Variant& color)
5647 {
5648         __itemBackgroundColor[_BUTTON_STATUS_NORMAL] = color.ToColor();
5649
5650         Bitmap* __pBaseBackgroundBitmap = null;
5651
5652         if (__style == TOOLBAR_TEXT || __style == TOOLBAR_ICON || __style == TOOLBAR_ICON_TEXT)
5653         {
5654                 GET_BITMAP_CONFIG_N(FOOTER::BUTTON_ITEM_BG_NORMAL, BITMAP_PIXEL_FORMAT_ARGB8888, __pBaseBackgroundBitmap);
5655         }
5656         else
5657         {
5658                 GET_BITMAP_CONFIG_N(HEADER::TAB_ITEM_BG_NORMAL, BITMAP_PIXEL_FORMAT_ARGB8888, __pBaseBackgroundBitmap);
5659         }
5660
5661         for (int i = 0; i < __itemCount; i++)
5662         {
5663                 if (__pItems.at(i) != null)
5664                 {
5665                         if (__pBaseBackgroundBitmap)
5666                         {
5667                                 SetColorReplacedBitmap(__pItems.at(i), _BUTTON_STATUS_NORMAL, __itemBackgroundColor[_BUTTON_STATUS_NORMAL], __pBaseBackgroundBitmap);
5668                         }
5669                 }
5670         }
5671
5672         delete __pBaseBackgroundBitmap;
5673
5674         return E_SUCCESS;
5675 }
5676
5677 Variant
5678 _Toolbar::GetPropertyNormalItemColor(void) const
5679 {
5680         return Variant(__itemBackgroundColor[_BUTTON_STATUS_NORMAL]);
5681 }
5682
5683 result
5684 _Toolbar::SetPropertyNormalItemTextColor(const Variant& color)
5685 {
5686         __itemTextColor[_BUTTON_STATUS_NORMAL] = color.ToColor();
5687
5688         for (int i = 0; i < __itemCount; i++)
5689         {
5690                 if (__pItems.at(i) != null)
5691                 {
5692                         __pItems.at(i)->SetTextColor(_BUTTON_STATUS_NORMAL, __itemTextColor[_BUTTON_STATUS_NORMAL]);
5693                 }
5694         }
5695
5696         return E_SUCCESS;
5697 }
5698
5699 Variant
5700 _Toolbar::GetPropertyNormalItemTextColor(void) const
5701 {
5702         return Variant(__itemTextColor[_BUTTON_STATUS_NORMAL]);
5703 }
5704
5705 result
5706 _Toolbar::SetPropertyPressedItemColor(const Variant& color)
5707 {
5708         __itemBackgroundColor[_BUTTON_STATUS_PRESSED] = color.ToColor();
5709
5710         Bitmap* __pBaseBackgroundBitmap = null;
5711
5712         if (__style == TOOLBAR_TEXT || __style == TOOLBAR_ICON || __style == TOOLBAR_ICON_TEXT)
5713         {
5714                 GET_BITMAP_CONFIG_N(FOOTER::BUTTON_ITEM_BG_PRESSED, BITMAP_PIXEL_FORMAT_ARGB8888, __pBaseBackgroundBitmap);
5715         }
5716         else if (__style == TOOLBAR_HEADER_SEGMENTED || __style == TOOLBAR_HEADER_SEGMENTED_WITH_TITLE || __style == TOOLBAR_SEGMENTED
5717                         || __style == TOOLBAR_TAB || __style == TOOLBAR_TAB_WITH_TITLE || __style == TOOLBAR_TITLE)
5718         {
5719                 GET_BITMAP_CONFIG_N(HEADER::TAB_ITEM_BG_EFFECT_PRESSED, BITMAP_PIXEL_FORMAT_ARGB8888, __pBaseBackgroundBitmap);
5720         }
5721         else
5722         {
5723                 GET_BITMAP_CONFIG_N(HEADER::TAB_ITEM_BG_PRESSED, BITMAP_PIXEL_FORMAT_ARGB8888, __pBaseBackgroundBitmap);
5724         }
5725
5726         for (int i = 0; i < __itemCount; i++)
5727         {
5728                 if (__pItems.at(i) != null)
5729                 {
5730                         if (__pBaseBackgroundBitmap)
5731                         {
5732                                 SetColorReplacedBitmap(__pItems.at(i), _BUTTON_STATUS_PRESSED, __itemBackgroundColor[_BUTTON_STATUS_PRESSED], __pBaseBackgroundBitmap);
5733                         }
5734                 }
5735         }
5736
5737         delete __pBaseBackgroundBitmap;
5738
5739         return E_SUCCESS;
5740 }
5741
5742 Variant
5743 _Toolbar::GetPropertyPressedItemColor(void) const
5744 {
5745         return Variant(__itemBackgroundColor[_BUTTON_STATUS_PRESSED]);
5746 }
5747
5748 result
5749 _Toolbar::SetPropertyPressedItemTextColor(const Variant& color)
5750 {
5751         __itemTextColor[_BUTTON_STATUS_PRESSED] = color.ToColor();
5752
5753         for (int i = 0; i < __itemCount; i++)
5754         {
5755                 if (__pItems.at(i) != null)
5756                 {
5757                         __pItems.at(i)->SetTextColor(_BUTTON_STATUS_PRESSED, __itemTextColor[_BUTTON_STATUS_PRESSED]);
5758                 }
5759         }
5760
5761         return E_SUCCESS;
5762 }
5763
5764 Variant
5765 _Toolbar::GetPropertyPressedItemTextColor(void) const
5766 {
5767         return Variant(__itemTextColor[_BUTTON_STATUS_PRESSED]);
5768 }
5769
5770 result
5771 _Toolbar::SetPropertySelectedItemColor(const Variant& color)
5772 {
5773         __itemBackgroundColor[_BUTTON_STATUS_SELECTED] = color.ToColor();
5774
5775         Bitmap* __pBaseBackgroundBitmap = null;
5776
5777         if (__style == TOOLBAR_TEXT || __style == TOOLBAR_ICON || __style == TOOLBAR_ICON_TEXT)
5778         {
5779                 GET_BITMAP_CONFIG_N(FOOTER::BUTTON_ITEM_BG_NORMAL, BITMAP_PIXEL_FORMAT_ARGB8888, __pBaseBackgroundBitmap);
5780         }
5781         else
5782         {
5783                 GET_BITMAP_CONFIG_N(HEADER::TAB_ITEM_BG_SELECTED, BITMAP_PIXEL_FORMAT_ARGB8888, __pBaseBackgroundBitmap);
5784         }
5785
5786         for (int i = 0; i < __itemCount; i++)
5787         {
5788                 if (__pItems.at(i) != null)
5789                 {
5790                         if (__pBaseBackgroundBitmap)
5791                         {
5792                                 SetColorReplacedBitmap(__pItems.at(i), _BUTTON_STATUS_SELECTED, __itemBackgroundColor[_BUTTON_STATUS_SELECTED], __pBaseBackgroundBitmap);
5793                         }
5794                 }
5795         }
5796
5797         delete __pBaseBackgroundBitmap;
5798
5799         return E_SUCCESS;
5800 }
5801
5802 Variant
5803 _Toolbar::GetPropertySelectedItemColor(void) const
5804 {
5805         return Variant(__itemBackgroundColor[_BUTTON_STATUS_SELECTED]);
5806 }
5807
5808 result
5809 _Toolbar::SetPropertySelectedItemTextColor(const Variant& color)
5810 {
5811         __itemTextColor[_BUTTON_STATUS_SELECTED] = color.ToColor();
5812
5813         for (int i = 0; i < __itemCount; i++)
5814         {
5815                 if (__pItems.at(i) != null)
5816                 {
5817                         __pItems.at(i)->SetTextColor(_BUTTON_STATUS_SELECTED, __itemTextColor[_BUTTON_STATUS_SELECTED]);
5818                 }
5819         }
5820
5821         return E_SUCCESS;
5822 }
5823
5824 Variant
5825 _Toolbar::GetPropertySelectedItemTextColor(void) const
5826 {
5827         return Variant(__itemTextColor[_BUTTON_STATUS_SELECTED]);
5828 }
5829
5830 Rectangle
5831 _Toolbar::GetButtonBounds(ToolbarButton position) const
5832 {
5833         return _CoordinateSystemUtils::ConvertToInteger(GetButtonBoundsF(position));
5834 }
5835
5836 FloatRectangle
5837 _Toolbar::GetButtonBoundsF(ToolbarButton position) const
5838 {
5839         FloatRectangle bounds = __pButtonItems[position]->GetBoundsF();
5840
5841         float leftTouchMargin = __pButtonItems[position]->GetLeftTouchMarginF();
5842         float topTouchMargin = __pButtonItems[position]->GetTopTouchMarginF();
5843         float rightTouchMargin = __pButtonItems[position]->GetRightTouchMarginF();
5844         float bottomTouchMargin = __pButtonItems[position]->GetBottomTouchMarginF();
5845
5846         bounds.x = bounds.x + leftTouchMargin;
5847         bounds.y = bounds.y + topTouchMargin;
5848         bounds.width = bounds.width - (leftTouchMargin + rightTouchMargin);
5849         bounds.height = bounds.height - (topTouchMargin + bottomTouchMargin);
5850
5851         return bounds;
5852 }
5853
5854 result
5855 _Toolbar::SetTitleBadgeIcon(const Bitmap* pBadgeIcon)
5856 {
5857         if (pBadgeIcon == null)
5858         {
5859                 return E_SUCCESS;
5860         }
5861
5862         if (__pTitleBadgeIcon)
5863         {
5864                 DetachChild(*__pTitleBadgeIcon);
5865
5866                 delete __pTitleBadgeIcon;
5867                 __pTitleBadgeIcon = null;
5868         }
5869
5870         float height = 0.0f;
5871         GET_SHAPE_CONFIG(HEADER::BADGE_HEIGHT, GetOrientation(), height);
5872
5873         __pTitleBadgeIcon = _Label::CreateLabelN();
5874
5875         if (__pTitleBadgeIcon)
5876         {
5877                 __pTitleBadgeIcon->SetBounds(FloatRectangle(0.0f, 0.0f, height, height));
5878                 __pTitleBadgeIcon->SetBackgroundBitmap(*pBadgeIcon);
5879
5880                 AttachChild(*__pTitleBadgeIcon);
5881                 SetChildAlwaysOnTop(*__pTitleBadgeIcon);
5882         }
5883
5884         return E_SUCCESS;
5885 }
5886
5887 result
5888 _Toolbar::SetTitleNumberedBadgeIcon(int number)
5889 {
5890         SysTryReturnResult(NID_UI_CTRL, (number >= 0 && number < 100000), E_INVALID_ARG,
5891                                 "[E_INVALID_ARG] The number is out of bounds.");
5892
5893         if (__pTitleBadgeIcon)
5894         {
5895                 DetachChild(*__pTitleBadgeIcon);
5896
5897                 delete __pTitleBadgeIcon;
5898                 __pTitleBadgeIcon = null;
5899         }
5900
5901         if (number != 0)
5902         {
5903                 __pTitleBadgeIcon = _Label::CreateLabelN();
5904
5905                 SysTryReturnResult(NID_UI_CTRL, __pTitleBadgeIcon, E_INVALID_STATE, "[E_INVALID_STATE] The badge icon instance isn't constructed.");
5906
5907                 Bitmap* pNumberedBadgeIconBitmap = null;
5908                 Bitmap* pNumberedBadgeIconEffectBitmap = null;
5909                 Bitmap* pColorReplacedBitmap = null;
5910                 Color badgeIconBgColor;
5911                 Color badgeIconTextColor;
5912
5913                 GET_BITMAP_CONFIG_N(HEADER::BADGE_ICON_BG_NORMAL, BITMAP_PIXEL_FORMAT_ARGB8888, pNumberedBadgeIconBitmap);
5914
5915                 bool themeBadgeNormalBackgroundBitmap = IS_CUSTOM_BITMAP(HEADER::BADGE_ICON_BG_NORMAL);
5916                 if (!themeBadgeNormalBackgroundBitmap)
5917                 {
5918                         GET_BITMAP_CONFIG_N(HEADER::BADGE_ICON_BG_EFFECT_NORMAL, BITMAP_PIXEL_FORMAT_ARGB8888, pNumberedBadgeIconEffectBitmap);
5919                 }
5920
5921                 GET_COLOR_CONFIG(HEADER::BADGE_ICON_BG_NORMAL, badgeIconBgColor);
5922                 GET_COLOR_CONFIG(HEADER::BADGE_ICON_TEXT_NORMAL, badgeIconTextColor);
5923
5924                 if (pNumberedBadgeIconBitmap)
5925                 {
5926                         pColorReplacedBitmap = _BitmapImpl::GetColorReplacedBitmapN(*pNumberedBadgeIconBitmap,
5927                                         Color::GetColor(COLOR_ID_MAGENTA), badgeIconBgColor);
5928
5929                         __pTitleBadgeIcon->SetBackgroundBitmap(*pColorReplacedBitmap);
5930
5931                         delete pColorReplacedBitmap;
5932                         delete pNumberedBadgeIconBitmap;
5933                 }
5934
5935                 if (pNumberedBadgeIconEffectBitmap)
5936                 {
5937                         __pTitleBadgeIcon->SetBackgroundEffectBitmap(*pNumberedBadgeIconEffectBitmap);
5938
5939                         delete pNumberedBadgeIconEffectBitmap;
5940                 }
5941
5942                 __pTitleBadgeIcon->SetTextHorizontalAlignment(ALIGNMENT_RIGHT);
5943                 __pTitleBadgeIcon->SetTextVerticalAlignment(ALIGNMENT_MIDDLE);
5944                 __pTitleBadgeIcon->SetTextColor(badgeIconTextColor);
5945                 __pTitleBadgeIcon->SetMargin(0, 10);
5946
5947                 float fontSize = 0.0f;
5948                 float height = 0.0f;
5949                 float width = 0.0f;
5950
5951                 GET_SHAPE_CONFIG(HEADER::BADGE_FONT_SIZE, GetOrientation(), fontSize);
5952                 GET_SHAPE_CONFIG(HEADER::BADGE_HEIGHT, GetOrientation(), height);
5953
5954                 if (number < 10)
5955                 {
5956                         GET_SHAPE_CONFIG(HEADER::BADGE_WIDTH_1DIGIT, GetOrientation(), width);
5957                 }
5958                 else if (number < 100)
5959                 {
5960                         GET_SHAPE_CONFIG(HEADER::BADGE_WIDTH_2DIGIT, GetOrientation(), width);
5961                 }
5962                 else if (number < 1000)
5963                 {
5964                         GET_SHAPE_CONFIG(HEADER::BADGE_WIDTH_3DIGIT, GetOrientation(), width);
5965                 }
5966                 else if (number < 10000)
5967                 {
5968                         GET_SHAPE_CONFIG(HEADER::BADGE_WIDTH_4DIGIT, GetOrientation(), width);
5969                 }
5970                 else
5971                 {
5972                         GET_SHAPE_CONFIG(HEADER::BADGE_WIDTH_5DIGIT, GetOrientation(), width);
5973                 }
5974
5975                 __pTitleBadgeIcon->SetBounds(FloatRectangle(0.0f, 0.0f, width, height));
5976                 __pTitleBadgeIcon->SetTextConfig(fontSize, LABEL_TEXT_STYLE_NORMAL);
5977
5978                 Integer tempNumber(number);
5979                 __pTitleBadgeIcon->SetText(tempNumber.ToString());
5980
5981                 AttachChild(*__pTitleBadgeIcon);
5982                 SetChildAlwaysOnTop(*__pTitleBadgeIcon);
5983         }
5984
5985         return E_SUCCESS;
5986 }
5987
5988 result
5989 _Toolbar::SetHideButton(bool hideButton)
5990 {
5991         SysTryReturnResult(NID_UI_CTRL, __pButtonItems[BACK_BUTTON], E_INVALID_OPERATION,
5992                         "[E_INVALID_OPERATION] BackButton is not exist.");
5993
5994         Bitmap* pColorReplacedBitmap = null;
5995         Bitmap* pIconNormalBitmap = null;
5996         Bitmap* pIconNormalEffectBitmap = null;
5997
5998         float iconSize = 0.0f;
5999         float buttonWidth = __pButtonItems[BACK_BUTTON]->GetSizeF().width;
6000         float buttonHeight = __pButtonItems[BACK_BUTTON]->GetSizeF().height;
6001         bool themeBackNormalBitmap = IS_CUSTOM_BITMAP(FOOTER::BACK_ICON_NORMAL);
6002
6003         float leftTouchMargin = __pButtonItems[BACK_BUTTON]->GetLeftTouchMarginF();
6004         float topTouchMargin = __pButtonItems[BACK_BUTTON]->GetTopTouchMarginF();
6005         float rightTouchMargin = __pButtonItems[BACK_BUTTON]->GetRightTouchMarginF();
6006         float bottomTouchMargin = __pButtonItems[BACK_BUTTON]->GetBottomTouchMarginF();
6007
6008         GET_SHAPE_CONFIG(FOOTER::BUTTON_ITEM_ICON_SIZE, GetOrientation(), iconSize);
6009
6010         _AccessibilityElement* pBackButtonElement = __pButtonItems[BACK_BUTTON]->GetAccessibilityContainer()->GetChildElement(0);
6011
6012         if (hideButton)
6013         {
6014                 GET_BITMAP_CONFIG_N(FOOTER::HIDE_ICON_NORMAL, BITMAP_PIXEL_FORMAT_ARGB8888, pIconNormalBitmap);
6015
6016                 if (!themeBackNormalBitmap)
6017                 {
6018                         GET_BITMAP_CONFIG_N(FOOTER::HIDE_ICON_EFFECT_NORMAL, BITMAP_PIXEL_FORMAT_ARGB8888, pIconNormalEffectBitmap);
6019                 }
6020
6021                 if (pBackButtonElement)
6022                 {
6023                         pBackButtonElement->SetLabel("Hide");
6024                         pBackButtonElement->SetTrait("Hide Button");
6025                 }
6026         }
6027         else
6028         {
6029                 GET_BITMAP_CONFIG_N(FOOTER::BACK_ICON_NORMAL, BITMAP_PIXEL_FORMAT_ARGB8888, pIconNormalBitmap);
6030
6031                 if (!themeBackNormalBitmap)
6032                 {
6033                         GET_BITMAP_CONFIG_N(FOOTER::BACK_ICON_EFFECT_NORMAL, BITMAP_PIXEL_FORMAT_ARGB8888, pIconNormalEffectBitmap);
6034                 }
6035
6036                 if (pBackButtonElement)
6037                 {
6038                         pBackButtonElement->SetLabel("Back");
6039                         pBackButtonElement->SetTrait("Back Button");
6040                 }
6041         }
6042
6043         if (pIconNormalBitmap)
6044         {
6045                 Color normalColor;
6046                 Color pressedColor;
6047                 Color disabledColor;
6048
6049                 GET_COLOR_CONFIG(FOOTER::BACK_ICON_NORMAL, normalColor);
6050                 GET_COLOR_CONFIG(FOOTER::BACK_ICON_PRESSED, pressedColor);
6051                 GET_COLOR_CONFIG(FOOTER::BACK_ICON_DISABLED, disabledColor);
6052
6053                 pIconNormalBitmap->Scale(FloatDimension(iconSize, iconSize));
6054
6055                 pColorReplacedBitmap = _BitmapImpl::GetColorReplacedBitmapN(*pIconNormalBitmap, Color::GetColor(COLOR_ID_MAGENTA), normalColor);
6056                 if (pColorReplacedBitmap)
6057                 {
6058                         __pButtonItems[BACK_BUTTON]->SetBitmap(_BUTTON_STATUS_NORMAL, FloatPoint((buttonWidth - (leftTouchMargin + rightTouchMargin) - iconSize) / 2,
6059                                         (buttonHeight - (topTouchMargin + bottomTouchMargin) - iconSize) / 2), *pColorReplacedBitmap);
6060
6061                         delete pColorReplacedBitmap;
6062                 }
6063
6064                 pColorReplacedBitmap = _BitmapImpl::GetColorReplacedBitmapN(*pIconNormalBitmap, Color::GetColor(COLOR_ID_MAGENTA), disabledColor);
6065                 if (pColorReplacedBitmap)
6066                 {
6067                         __pButtonItems[BACK_BUTTON]->SetBitmap(_BUTTON_STATUS_DISABLED, FloatPoint((buttonWidth - (leftTouchMargin + rightTouchMargin) - iconSize) / 2,
6068                                         (buttonHeight - (topTouchMargin + bottomTouchMargin) - iconSize) / 2), *pColorReplacedBitmap);
6069                         delete pColorReplacedBitmap;
6070                 }
6071
6072                 pColorReplacedBitmap = _BitmapImpl::GetColorReplacedBitmapN(*pIconNormalBitmap, Color::GetColor(COLOR_ID_MAGENTA), pressedColor);
6073                 if (pColorReplacedBitmap)
6074                 {
6075                         __pButtonItems[BACK_BUTTON]->SetBitmap(_BUTTON_STATUS_PRESSED, FloatPoint((buttonWidth - (leftTouchMargin + rightTouchMargin) - iconSize) / 2,
6076                                         (buttonHeight - (topTouchMargin + bottomTouchMargin) - iconSize) / 2), *pColorReplacedBitmap);
6077                         delete pColorReplacedBitmap;
6078                 }
6079
6080                 pColorReplacedBitmap = _BitmapImpl::GetColorReplacedBitmapN(*pIconNormalBitmap, Color::GetColor(COLOR_ID_MAGENTA), normalColor);
6081                 if (pColorReplacedBitmap)
6082                 {
6083                         __pButtonItems[BACK_BUTTON]->SetBitmap(_BUTTON_STATUS_HIGHLIGHTED, FloatPoint((buttonWidth - (leftTouchMargin + rightTouchMargin) - iconSize) / 2,
6084                                         (buttonHeight - (topTouchMargin + bottomTouchMargin) - iconSize) / 2), *pColorReplacedBitmap);
6085                         delete pColorReplacedBitmap;
6086                 }
6087
6088                 pColorReplacedBitmap = _BitmapImpl::GetColorReplacedBitmapN(*pIconNormalBitmap, Color::GetColor(COLOR_ID_MAGENTA), normalColor);
6089                 if (pColorReplacedBitmap)
6090                 {
6091                         __pButtonItems[BACK_BUTTON]->SetBitmap(_BUTTON_STATUS_SELECTED, FloatPoint((buttonWidth - (leftTouchMargin + rightTouchMargin) - iconSize) / 2,
6092                                         (buttonHeight - (topTouchMargin + bottomTouchMargin) - iconSize) / 2), *pColorReplacedBitmap);
6093                         delete pColorReplacedBitmap;
6094                 }
6095
6096                 delete pIconNormalBitmap;
6097         }
6098
6099         if (pIconNormalEffectBitmap)
6100         {
6101                 __pButtonItems[BACK_BUTTON]->SetEffectBitmap(_BUTTON_STATUS_NORMAL, FloatPoint((buttonWidth - (leftTouchMargin + rightTouchMargin) - iconSize) / 2,
6102                                 (buttonHeight - (topTouchMargin + bottomTouchMargin) - iconSize) / 2), *pIconNormalEffectBitmap);
6103                 __pButtonItems[BACK_BUTTON]->SetEffectBitmap(_BUTTON_STATUS_DISABLED, FloatPoint((buttonWidth - (leftTouchMargin + rightTouchMargin) - iconSize) / 2,
6104                                 (buttonHeight - (topTouchMargin + bottomTouchMargin) - iconSize) / 2), *pIconNormalEffectBitmap);
6105                 __pButtonItems[BACK_BUTTON]->SetEffectBitmap(_BUTTON_STATUS_PRESSED, FloatPoint((buttonWidth - (leftTouchMargin + rightTouchMargin) - iconSize) / 2,
6106                                 (buttonHeight - (topTouchMargin + bottomTouchMargin) - iconSize) / 2), *pIconNormalEffectBitmap);
6107                 __pButtonItems[BACK_BUTTON]->SetEffectBitmap(_BUTTON_STATUS_HIGHLIGHTED, FloatPoint((buttonWidth - (leftTouchMargin + rightTouchMargin) - iconSize) / 2,
6108                                 (buttonHeight - (topTouchMargin + bottomTouchMargin) - iconSize) / 2), *pIconNormalEffectBitmap);
6109                 __pButtonItems[BACK_BUTTON]->SetEffectBitmap(_BUTTON_STATUS_SELECTED, FloatPoint((buttonWidth - (leftTouchMargin + rightTouchMargin) - iconSize) / 2,
6110                                 (buttonHeight - (topTouchMargin + bottomTouchMargin) - iconSize) / 2), *pIconNormalEffectBitmap);
6111
6112                 delete pIconNormalEffectBitmap;
6113         }
6114
6115         return E_SUCCESS;
6116 }
6117
6118 result
6119 _Toolbar::SetTransBackButton(bool transparent)
6120 {
6121         SysTryReturnResult(NID_UI_CTRL, __pButtonItems[BACK_BUTTON], E_INVALID_OPERATION,
6122                         "[E_INVALID_OPERATION] BackButton is not exist.");
6123
6124         Bitmap* pIconNormalEffectBitmap = null;
6125
6126         float iconSize = 0.0f;
6127         float buttonWidth = __pButtonItems[BACK_BUTTON]->GetSizeF().width;
6128         float buttonHeight = __pButtonItems[BACK_BUTTON]->GetSizeF().height;
6129         bool themeBackNormalBitmap = IS_CUSTOM_BITMAP(FOOTER::BACK_ICON_NORMAL);
6130
6131         float leftTouchMargin = __pButtonItems[BACK_BUTTON]->GetLeftTouchMarginF();
6132         float topTouchMargin = __pButtonItems[BACK_BUTTON]->GetTopTouchMarginF();
6133         float rightTouchMargin = __pButtonItems[BACK_BUTTON]->GetRightTouchMarginF();
6134         float bottomTouchMargin = __pButtonItems[BACK_BUTTON]->GetBottomTouchMarginF();
6135
6136         GET_SHAPE_CONFIG(FOOTER::BUTTON_ITEM_ICON_SIZE, GetOrientation(), iconSize);
6137
6138         if (transparent)
6139         {
6140                 if (!themeBackNormalBitmap)
6141                 {
6142                         GET_BITMAP_CONFIG_N(FOOTER::BACK_ICON_TRANSLUCENT_EFFECT_NORMAL, BITMAP_PIXEL_FORMAT_ARGB8888, pIconNormalEffectBitmap);
6143                 }
6144         }
6145         else
6146         {
6147                 if (!themeBackNormalBitmap)
6148                 {
6149                         GET_BITMAP_CONFIG_N(FOOTER::BACK_ICON_EFFECT_NORMAL, BITMAP_PIXEL_FORMAT_ARGB8888, pIconNormalEffectBitmap);
6150                 }
6151         }
6152
6153         if (pIconNormalEffectBitmap)
6154         {
6155                 __pButtonItems[BACK_BUTTON]->SetEffectBitmap(_BUTTON_STATUS_NORMAL, FloatPoint((buttonWidth - (leftTouchMargin + rightTouchMargin) - iconSize) / 2,
6156                                 (buttonHeight - (topTouchMargin + bottomTouchMargin) - iconSize) / 2), *pIconNormalEffectBitmap);
6157                 __pButtonItems[BACK_BUTTON]->SetEffectBitmap(_BUTTON_STATUS_DISABLED, FloatPoint((buttonWidth - (leftTouchMargin + rightTouchMargin) - iconSize) / 2,
6158                                 (buttonHeight - (topTouchMargin + bottomTouchMargin) - iconSize) / 2), *pIconNormalEffectBitmap);
6159                 __pButtonItems[BACK_BUTTON]->SetEffectBitmap(_BUTTON_STATUS_PRESSED, FloatPoint((buttonWidth - (leftTouchMargin + rightTouchMargin) - iconSize) / 2,
6160                                 (buttonHeight - (topTouchMargin + bottomTouchMargin) - iconSize) / 2), *pIconNormalEffectBitmap);
6161                 __pButtonItems[BACK_BUTTON]->SetEffectBitmap(_BUTTON_STATUS_HIGHLIGHTED, FloatPoint((buttonWidth - (leftTouchMargin + rightTouchMargin) - iconSize) / 2,
6162                                 (buttonHeight - (topTouchMargin + bottomTouchMargin) - iconSize) / 2), *pIconNormalEffectBitmap);
6163                 __pButtonItems[BACK_BUTTON]->SetEffectBitmap(_BUTTON_STATUS_SELECTED, FloatPoint((buttonWidth - (leftTouchMargin + rightTouchMargin) - iconSize) / 2,
6164                                 (buttonHeight - (topTouchMargin + bottomTouchMargin) - iconSize) / 2), *pIconNormalEffectBitmap);
6165
6166                 delete pIconNormalEffectBitmap;
6167         }
6168
6169         return E_SUCCESS;
6170 }
6171
6172 }}} // Tizen::Ui::Controls