src/ui/controls/FUiCtrl_HeaderImpl.cpp

   1 //
   2 // Open Service Platform
   3 // Copyright (c) 2012-2013 Samsung Electronics Co., Ltd.
   4 //
   5 // Licensed under the Apache License, Version 2.0 (the License);
   6 // you may not use this file except in compliance with the License.
   7 // You may obtain a copy of the License at
   8 //
   9 //     http://www.apache.org/licenses/LICENSE-2.0/
  10 //
  11 // Unless required by applicable law or agreed to in writing, software
  12 // distributed under the License is distributed on an "AS IS" BASIS,
  13 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  14 // See the License for the specific language governing permissions and
  15 // limitations under the License.
  16 //
  17 /**
  18  * @file                FUiCtrl_HeaderImpl.cpp
  19  * @brief               This is the implementation file for the _HeaderImpl class.
  20  */
  21
  22 #include <stdlib.h>
  23 #include <FGrp_BitmapImpl.h>
  24 #include <FUiAccessibilityContainer.h>
  25 #include <FUiAccessibilityElement.h>
  26 #include "FUi_AccessibilityContainer.h"
  27 #include "FUi_AccessibilityElement.h"
  28 #include "FUi_Control.h"
  29 #include "FUi_EcoreEvasMgr.h"
  30 #include "FUi_EcoreEvas.h"
  31 #include "FUi_ResourceManager.h"
  32 #include "FUi_UiBuilder.h"
  33 #include "FUiCtrl_ButtonItemImpl.h"
  34 #include "FUiCtrl_HeaderImpl.h"
  35 #include "FUiCtrl_HeaderItemImpl.h"
  36 #include "FUiCtrl_IActionEventListener.h"
  37 #include "FUiCtrl_PanelImpl.h"
  38 #include "FUiCtrl_PublicActionEvent.h"
  39
  40 using namespace Tizen::Base;
  41 using namespace Tizen::Graphics;
  42
  43 namespace Tizen { namespace Ui { namespace Controls
  44 {
  45
  46 _HeaderImpl*
  47 _HeaderImpl::CreateHeaderImplN(Header* pControl)
  48 {
  49         ClearLastResult();
  50         result r = E_SUCCESS;
  51
  52         _Toolbar* pCore = null;
  53
  54         pCore = _Toolbar::CreateToolbarN(true);
  55         r = GetLastResult();
  56         SysTryReturn(NID_UI_CTRL, pCore, null, GetLastResult(), "[%s] Propagating.", GetErrorMessage(r));
  57
  58         r = pCore->InitializeLongPressGesture();
  59         SysTryReturn(NID_UI_CTRL, r == E_SUCCESS, null, r, "[%s] Propagating.", GetErrorMessage(r));
  60
  61         r = pCore->InitializeFlickGesture();
  62         SysTryReturn(NID_UI_CTRL, r == E_SUCCESS, null, r, "[%s] Propagating.", GetErrorMessage(r));
  63
  64         _HeaderImpl* pHeaderImpl = new (std::nothrow) _HeaderImpl(pControl, pCore);
  65
  66         r = CheckConstruction(pCore, pHeaderImpl);
  67         SysTryReturn(NID_UI_CTRL, r == E_SUCCESS, null, r, "[%s] Propagating.", GetErrorMessage(r));
  68
  69         return pHeaderImpl;
  70 }
  71
  72 _HeaderImpl::_HeaderImpl(Header* pPublic, _Toolbar* pCore)
  73         : _ControlImpl(pPublic, pCore)
  74         , __style(HEADER_STYLE_TITLE)
  75         , __pPublicActionEvent(null)
  76         //, __calledBySetItemSelected(false)
  77 {
  78         result r = GetLastResult(); // Check if _ControlImpl succeeded.
  79         SysTryReturnVoidResult(NID_UI_CTRL, r == E_SUCCESS, r, "[%s] Propagating.", GetErrorMessage(r));
  80
  81         pCore->SetStyle(TOOLBAR_TITLE);
  82
  83         Color tempColor = Color(0);
  84
  85         GET_COLOR_CONFIG(HEADER::BG_NORMAL, tempColor);
  86         pCore->SetColor(tempColor);
  87 }
  88
  89 _HeaderImpl::~_HeaderImpl(void)
  90 {
  91         if (__pPublicActionEvent)
  92         {
  93                 delete __pPublicActionEvent;
  94                 __pPublicActionEvent = null;
  95         }
  96 }
  97
  98 Header*
  99 _HeaderImpl::GetHeader(void) const
 100 {
 101         return &const_cast <Header&>(GetPublic());
 102 }
 103
 104 const char*
 105 _HeaderImpl::GetPublicClassName(void) const
 106 {
 107         return "Tizen::Ui::Controls::Header";
 108 }
 109
 110 const Header&
 111 _HeaderImpl::GetPublic(void) const
 112 {
 113         return static_cast<const Header&>(_ControlImpl::GetPublic());
 114 }
 115
 116 Header&
 117 _HeaderImpl::GetPublic(void)
 118 {
 119         return static_cast<Header&>(_ControlImpl::GetPublic());
 120 }
 121
 122 const _Toolbar&
 123 _HeaderImpl::GetCore(void) const
 124 {
 125         return static_cast<const _Toolbar&>(_ControlImpl::GetCore());
 126 }
 127
 128 _Toolbar&
 129 _HeaderImpl::GetCore(void)
 130 {
 131         return static_cast<_Toolbar&>(_ControlImpl::GetCore());
 132 }
 133
 134 const _HeaderImpl*
 135 _HeaderImpl::GetInstance(const Header& header)
 136 {
 137         return static_cast<const _HeaderImpl*> (header._pControlImpl);
 138 }
 139
 140 _HeaderImpl*
 141 _HeaderImpl::GetInstance(Header& header)
 142 {
 143         return static_cast<_HeaderImpl*> (header._pControlImpl);
 144 }
 145
 146 result
 147 _HeaderImpl::AddItem(const HeaderItem& item)
 148 {
 149         SysTryReturnResult(NID_UI_CTRL, (__style != HEADER_STYLE_TITLE), E_SYSTEM, "[E_SYSTEM] Unable to add the item because the current style does not support it.");
 150
 151         result r = CheckItemValidate(item);
 152
 153         if (IsFailed(r))
 154         {
 155                 return r;
 156         }
 157
 158         if (__style == HEADER_STYLE_TITLE_BUTTON && GetItemCount() >= 1)
 159         {
 160                 SysLogException(NID_UI_CTRL, E_MAX_EXCEEDED, "[E_MAX_EXCEEDED] Only 1 HeaderItem can be added to HEADER_STYLE_TITLE_BUTTON ");
 161                 return E_MAX_EXCEEDED;
 162         }
 163
 164         _Button* pButton = ConvertHeaderItem(item);
 165
 166         if (__style == HEADER_STYLE_SEGMENTED || __style == HEADER_STYLE_SEGMENTED_WITH_TITLE
 167                         || __style == HEADER_STYLE_TAB || __style == HEADER_STYLE_TAB_WITH_TITLE || __style == HEADER_STYLE_TAB_LARGE)
 168         {
 169                 pButton->SetButtonStyle(_BUTTON_STYLE_SEGMENT);
 170         }
 171
 172         return GetCore().AddItem(pButton);
 173 }
 174
 175 ButtonItemStatus
 176 _HeaderImpl::GetButtonStatus(ButtonPosition position) const
 177 {
 178         bool isButtonSet = IsButtonSet(position);
 179
 180         SysTryReturn(NID_UI_CTRL, isButtonSet == true, BUTTON_ITEM_STATUS_NORMAL, E_INVALID_OPERATION,
 181                         "[E_INVALID_OPERATION] No button item is set at the specified position.");
 182
 183         _ButtonStatus buttonStatus = _BUTTON_STATUS_NORMAL;
 184
 185         if (position == BUTTON_POSITION_LEFT)
 186         {
 187                 buttonStatus = GetCore().GetButtonStatus(LEFT_BUTTON);
 188         }
 189         else if (position == BUTTON_POSITION_RIGHT)
 190         {
 191                 buttonStatus = GetCore().GetButtonStatus(RIGHT_BUTTON);
 192         }
 193
 194         return ConvertButtonItemStatus(buttonStatus);
 195 }
 196
 197 Color
 198 _HeaderImpl::GetButtonColor(ButtonItemStatus status) const
 199 {
 200         _ButtonStatus tempStatus = ConvertButtonStatus(status);
 201
 202         return GetCore().GetButtonColor(tempStatus);
 203 }
 204
 205 Color
 206 _HeaderImpl::GetButtonTextColor(ButtonItemStatus status) const
 207 {
 208         _ButtonStatus tempStatus = ConvertButtonStatus(status);
 209
 210         return GetCore().GetButtonTextColor(tempStatus);
 211 }
 212
 213 String
 214 _HeaderImpl::GetDescriptionText(void) const
 215 {
 216         return GetCore().GetDescriptionText();
 217 }
 218
 219 Color
 220 _HeaderImpl::GetDescriptionTextColor(void) const
 221 {
 222         return GetCore().GetDescriptionTextColor();
 223 }
 224
 225 Color
 226 _HeaderImpl::GetItemColor(HeaderItemStatus status) const
 227 {
 228         _ButtonStatus tempStatus = ConvertButtonStatus(status);
 229
 230         return GetCore().GetItemColor(tempStatus);
 231 }
 232
 233 int
 234 _HeaderImpl::GetItemCount(void) const
 235 {
 236         return GetCore().GetItemCount();
 237 }
 238
 239 result
 240 _HeaderImpl::GetItemStatus(int itemIndex, HeaderItemStatus& status) const
 241 {
 242         int count = GetItemCount();
 243
 244         SysTryReturnResult(NID_UI_CTRL, (itemIndex >= 0 && itemIndex <= count), E_OUT_OF_RANGE,
 245                            "[E_OUT_OF_RANGE] The itemIndex is out of range.");
 246
 247         _Button* pButton = GetCore().GetItem(itemIndex);
 248
 249         SysTryReturnResult(NID_UI_CTRL, pButton, E_SYSTEM, "[E_SYSTEM] Unable to get the item status.");
 250
 251         status = ConvertHeaderItemStatus(pButton->GetButtonStatus());
 252
 253         return E_SUCCESS;
 254 }
 255
 256 Color
 257 _HeaderImpl::GetItemTextColor(HeaderItemStatus status) const
 258 {
 259         _ButtonStatus tempStatus = ConvertButtonStatus(status);
 260
 261         return GetCore().GetItemTextColor(tempStatus);
 262 }
 263
 264 HeaderStyle
 265 _HeaderImpl::GetStyle(void) const
 266 {
 267         return __style;
 268 }
 269
 270 int
 271 _HeaderImpl::GetSelectedItemIndex(void) const
 272 {
 273         SysTryReturn(NID_UI_CTRL, (__style == HEADER_STYLE_SEGMENTED || __style == HEADER_STYLE_SEGMENTED_WITH_TITLE
 274                         || __style == HEADER_STYLE_TAB || __style == HEADER_STYLE_TAB_WITH_TITLE || __style == HEADER_STYLE_TAB_LARGE), -1,
 275                         E_UNSUPPORTED_OPERATION, "[E_UNSUPPORTED_OPERATION] Unable to get the selected item index because the current style does not support it.")
 276
 277         return GetCore().GetSelectedItemIndex();
 278 }
 279
 280 String
 281 _HeaderImpl::GetTitleText(void) const
 282 {
 283         return GetCore().GetTitleText();
 284 }
 285
 286 Color
 287 _HeaderImpl::GetTitleTextColor(void) const
 288 {
 289         return GetCore().GetTitleTextColor();
 290 }
 291
 292 Color
 293 _HeaderImpl::GetColor(void) const
 294 {
 295         return GetCore().GetColor();
 296 }
 297
 298 result
 299 _HeaderImpl::InsertItemAt(int itemIndex, const HeaderItem& item)
 300 {
 301         result r = CheckItemValidate(item);
 302
 303         if (IsFailed(r))
 304         {
 305                 return r;
 306         }
 307
 308         SysTryReturnResult(NID_UI_CTRL, (__style == HEADER_STYLE_SEGMENTED || __style == HEADER_STYLE_SEGMENTED_WITH_TITLE
 309                         || __style == HEADER_STYLE_TAB || __style == HEADER_STYLE_TAB_WITH_TITLE || __style ==  HEADER_STYLE_TAB_LARGE
 310                         || __style == HEADER_STYLE_BUTTON), E_SYSTEM,
 311                         "[E_SYSTEM] Unable to add the item because the current style does not support it.");
 312
 313         int count = GetItemCount();
 314
 315         SysTryReturnResult(NID_UI_CTRL, (itemIndex >= 0 && itemIndex <= count), E_OUT_OF_RANGE,
 316                         "[E_OUT_OF_RANGE] The itemIndex is out of range.");
 317
 318         _Button* pButton = ConvertHeaderItem(item);
 319
 320         if (__style == HEADER_STYLE_SEGMENTED || __style == HEADER_STYLE_SEGMENTED_WITH_TITLE
 321                         || __style == HEADER_STYLE_TAB || __style == HEADER_STYLE_TAB_WITH_TITLE || __style == HEADER_STYLE_TAB_LARGE)
 322         {
 323                 pButton->SetButtonStyle(_BUTTON_STYLE_SEGMENT);
 324         }
 325
 326         return GetCore().InsertItemAt(itemIndex, pButton);
 327 }
 328
 329 bool
 330 _HeaderImpl::IsButtonSet(ButtonPosition position) const
 331 {
 332         if (position == BUTTON_POSITION_LEFT)
 333         {
 334                 return GetCore().IsButtonSet(LEFT_BUTTON);
 335         }
 336         else if (position == BUTTON_POSITION_RIGHT)
 337         {
 338                 return GetCore().IsButtonSet(RIGHT_BUTTON);
 339         }
 340
 341         return false;
 342 }
 343
 344 result
 345 _HeaderImpl::PlayWaitingAnimation(HeaderAnimationPosition animationPos)
 346 {
 347         if ((__style == HEADER_STYLE_SEGMENTED || __style == HEADER_STYLE_TITLE_BUTTON || __style == HEADER_STYLE_BUTTON
 348                         || __style == HEADER_STYLE_TAB || __style == HEADER_STYLE_TAB_LARGE)
 349                         && animationPos == HEADER_ANIMATION_POSITION_TITLE)
 350         {
 351                 SysLogException(NID_UI_CTRL, E_INVALID_OPERATION, "[E_INVALID_OPERATION] Unable to pause the waiting animation because the current style does not support it.");
 352                 return E_INVALID_OPERATION;
 353         }
 354
 355         if ((IsButtonSet(BUTTON_POSITION_LEFT) == false && animationPos == HEADER_ANIMATION_POSITION_BUTTON_LEFT)
 356                 || (IsButtonSet(BUTTON_POSITION_RIGHT) == false && animationPos == HEADER_ANIMATION_POSITION_BUTTON_RIGHT))
 357         {
 358                 SysLogException(NID_UI_CTRL, E_INVALID_OPERATION,
 359                                 "[E_INVALID_OPERATION] Unable to play the waiting animation because no button is set at the specified position.");
 360                 return E_INVALID_OPERATION;
 361         }
 362
 363         ToolbarAnimationPosition toolbarAnimPos = TOOLBAR_ANIMATION_POSITION_TITLE;
 364
 365         if (animationPos == HEADER_ANIMATION_POSITION_TITLE)
 366         {
 367                 toolbarAnimPos = TOOLBAR_ANIMATION_POSITION_TITLE;
 368         }
 369         else if (animationPos == HEADER_ANIMATION_POSITION_BUTTON_LEFT)
 370         {
 371                 toolbarAnimPos = TOOLBAR_ANIMATION_POSITION_BUTTON_LEFT;
 372         }
 373         else if (animationPos == HEADER_ANIMATION_POSITION_BUTTON_RIGHT)
 374         {
 375                 toolbarAnimPos = TOOLBAR_ANIMATION_POSITION_BUTTON_RIGHT;
 376         }
 377
 378         return GetCore().PlayWaitingAnimation(toolbarAnimPos);
 379 }
 380
 381 result
 382 _HeaderImpl::StopWaitingAnimation(HeaderAnimationPosition animationPos)
 383 {
 384         if ((__style == HEADER_STYLE_SEGMENTED || __style == HEADER_STYLE_TITLE_BUTTON || __style == HEADER_STYLE_BUTTON
 385                         || __style == HEADER_STYLE_TAB || __style == HEADER_STYLE_TAB_LARGE)
 386                         && animationPos == HEADER_ANIMATION_POSITION_TITLE)
 387         {
 388                 SysLogException(NID_UI_CTRL, E_INVALID_OPERATION, "[E_INVALID_OPERATION] A Header in this style doesn't support title animation.");
 389                 return E_INVALID_OPERATION;
 390         }
 391
 392         SysTryReturnResult(NID_UI_CTRL, (GetWaitingAnimationStatus(animationPos) != ANIMATION_STOPPED), E_INVALID_OPERATION,
 393                            "[E_INVALID_OPERATION] The animation is not playing currently.");
 394
 395         ToolbarAnimationPosition toolbarAnimPos = TOOLBAR_ANIMATION_POSITION_TITLE;
 396
 397         if (animationPos == HEADER_ANIMATION_POSITION_TITLE)
 398         {
 399                 toolbarAnimPos = TOOLBAR_ANIMATION_POSITION_TITLE;
 400         }
 401         else if (animationPos == HEADER_ANIMATION_POSITION_BUTTON_LEFT)
 402         {
 403                 toolbarAnimPos = TOOLBAR_ANIMATION_POSITION_BUTTON_LEFT;
 404         }
 405         else if (animationPos == HEADER_ANIMATION_POSITION_BUTTON_RIGHT)
 406         {
 407                 toolbarAnimPos = TOOLBAR_ANIMATION_POSITION_BUTTON_RIGHT;
 408         }
 409
 410         return GetCore().StopWaitingAnimation(toolbarAnimPos);
 411 }
 412
 413 result
 414 _HeaderImpl::PauseWaitingAnimation(HeaderAnimationPosition animationPos)
 415 {
 416         if ((__style == HEADER_STYLE_SEGMENTED || __style == HEADER_STYLE_TITLE_BUTTON || __style == HEADER_STYLE_BUTTON
 417                         || __style == HEADER_STYLE_TAB || __style == HEADER_STYLE_TAB_LARGE)
 418                         && animationPos == HEADER_ANIMATION_POSITION_TITLE)
 419         {
 420                 SysLogException(NID_UI_CTRL, E_INVALID_OPERATION, "[E_INVALID_OPERATION] Unable to pause the waiting animation because the current style does not support it.");
 421                 return E_INVALID_OPERATION;
 422         }
 423
 424         SysTryReturnResult(NID_UI_CTRL, (GetWaitingAnimationStatus(animationPos) != ANIMATION_STOPPED), E_INVALID_OPERATION,
 425                         "[E_INVALID_OPERATION] No waiting animation is in progress at the specified position.");
 426
 427         SysTryReturnResult(NID_UI_CTRL,
 428                         (animationPos >= HEADER_ANIMATION_POSITION_TITLE && animationPos <= HEADER_ANIMATION_POSITION_BUTTON_RIGHT),
 429                         E_INVALID_ARG, "[E_INVALID_ARG] The animationPos is invalid");
 430
 431         ToolbarAnimationPosition toolbarAnimPos = TOOLBAR_ANIMATION_POSITION_TITLE;
 432
 433         if (animationPos == HEADER_ANIMATION_POSITION_TITLE)
 434         {
 435                 toolbarAnimPos = TOOLBAR_ANIMATION_POSITION_TITLE;
 436         }
 437         else if (animationPos == HEADER_ANIMATION_POSITION_BUTTON_LEFT)
 438         {
 439                 toolbarAnimPos = TOOLBAR_ANIMATION_POSITION_BUTTON_LEFT;
 440         }
 441         else if (animationPos == HEADER_ANIMATION_POSITION_BUTTON_RIGHT)
 442         {
 443                 toolbarAnimPos = TOOLBAR_ANIMATION_POSITION_BUTTON_RIGHT;
 444         }
 445
 446         return GetCore().PauseWaitingAnimation(toolbarAnimPos);
 447 }
 448
 449 AnimationStatus
 450 _HeaderImpl::GetWaitingAnimationStatus(HeaderAnimationPosition animationPos) const
 451 {
 452         ToolbarAnimationPosition toolbarAnimPos = TOOLBAR_ANIMATION_POSITION_TITLE;
 453
 454         if (HEADER_ANIMATION_POSITION_TITLE == animationPos)
 455         {
 456                 toolbarAnimPos = TOOLBAR_ANIMATION_POSITION_TITLE;
 457         }
 458         else if (animationPos == HEADER_ANIMATION_POSITION_BUTTON_LEFT)
 459         {
 460                 toolbarAnimPos = TOOLBAR_ANIMATION_POSITION_BUTTON_LEFT;
 461         }
 462         else if (animationPos == HEADER_ANIMATION_POSITION_BUTTON_RIGHT)
 463         {
 464                 toolbarAnimPos = TOOLBAR_ANIMATION_POSITION_BUTTON_RIGHT;
 465         }
 466
 467         return GetCore().GetWaitingAnimationStatus(toolbarAnimPos);
 468 }
 469
 470 result
 471 _HeaderImpl::RemoveAllButtons(void)
 472 {
 473         return GetCore().RemoveAllButtons();
 474 }
 475
 476 result
 477 _HeaderImpl::RemoveAllItems(void)
 478 {
 479         return GetCore().RemoveAllItems();
 480 }
 481
 482 result
 483 _HeaderImpl::RemoveItemAt(int itemIndex)
 484 {
 485         int count = GetItemCount();
 486
 487         SysTryReturnResult(NID_UI_CTRL, (itemIndex >= 0 && itemIndex <= count), E_OUT_OF_RANGE,
 488                         "[E_OUT_OF_RANGE] The itemIndex is out of range.");
 489
 490
 491         return GetCore().RemoveItemAt(itemIndex);
 492 }
 493
 494 result
 495 _HeaderImpl::RemoveButtonAt(ButtonPosition position)
 496 {
 497         if (BUTTON_POSITION_LEFT == position)
 498         {
 499                 return GetCore().RemoveButtonAt(LEFT_BUTTON);
 500         }
 501         else if (BUTTON_POSITION_RIGHT == position)
 502         {
 503                 return GetCore().RemoveButtonAt(RIGHT_BUTTON);
 504         }
 505
 506         return E_SUCCESS;
 507 }
 508
 509 result
 510 _HeaderImpl::SetBackgroundBitmap(const Bitmap* pBitmap)
 511 {
 512         return GetCore().SetBackgroundBitmap(*pBitmap);
 513 }
 514
 515 result
 516 _HeaderImpl::SetButton(ButtonPosition position, const ButtonItem& button)
 517 {
 518         SysTryReturnResult(NID_UI_CTRL, (!(__style == HEADER_STYLE_TAB || __style == HEADER_STYLE_TAB_WITH_TITLE || __style == HEADER_STYLE_TAB_LARGE)), E_INVALID_OPERATION,
 519                         "[E_INVALID_OPERATION] This operation is not supported.");
 520
 521         SysTryReturnResult(NID_UI_CTRL, (button.GetActionId() >= HEADER_ACTION_ID_MIN && button.GetActionId() <= HEADER_ACTION_ID_MAX),
 522                         E_INVALID_ARG, "[E_INVALID_ARG] The actionId is invalid.");
 523
 524         int count = GetItemCount();
 525
 526         SysTryReturnResult(NID_UI_CTRL, (count <= HEADER_MAX_ITEM_COUNT_WITH_BUTTON), E_SYSTEM,
 527                            "[E_SYSTEM] If the item count is larger then 4, no button can be set.");
 528
 529         SysTryReturnResult(NID_UI_CTRL, (position == BUTTON_POSITION_LEFT || position == BUTTON_POSITION_RIGHT), E_INVALID_ARG,
 530                            "[E_INVALID_ARG] The position is invalid.");
 531
 532         _Button* pButton = ConvertButtonItem(button);
 533
 534         if (position == BUTTON_POSITION_LEFT)
 535         {
 536                 return GetCore().SetButton(LEFT_BUTTON, pButton);
 537         }
 538         else if (position == BUTTON_POSITION_RIGHT)
 539         {
 540                 return GetCore().SetButton(RIGHT_BUTTON, pButton);
 541         }
 542
 543         return E_SUCCESS;
 544 }
 545
 546 result
 547 _HeaderImpl::SetButtonColor(ButtonItemStatus status, const Color& color)
 548 {
 549         _ButtonStatus tempStatus = ConvertButtonStatus(status);
 550
 551         return GetCore().SetButtonColor(tempStatus, color);
 552 }
 553
 554 result
 555 _HeaderImpl::SetButtonEnabled(ButtonPosition position, bool enable)
 556 {
 557         bool isButtonSet = IsButtonSet(position);
 558
 559         SysTryReturnResult(NID_UI_CTRL, isButtonSet, E_INVALID_OPERATION,
 560                         "[E_INVALID_OPERATION] No button item is set at the specified position.");
 561
 562         if (position == BUTTON_POSITION_LEFT)
 563         {
 564                 GetCore().SetButtonEnabled(LEFT_BUTTON, enable);
 565         }
 566         else if (position == BUTTON_POSITION_RIGHT)
 567         {
 568                 GetCore().SetButtonEnabled(RIGHT_BUTTON, enable);
 569         }
 570
 571         return E_SUCCESS;
 572 }
 573
 574 result
 575 _HeaderImpl::SetButtonTextColor(ButtonItemStatus status, const Color& color)
 576 {
 577         _ButtonStatus tempStatus = ConvertButtonStatus(status);
 578
 579         return GetCore().SetButtonTextColor(tempStatus, color);
 580 }
 581
 582 result
 583 _HeaderImpl::SetButtonBadgeIcon(ButtonPosition position, const Bitmap* pBadgeIcon)
 584 {
 585         SysTryReturnResult(NID_UI_CTRL, (position == BUTTON_POSITION_LEFT || position == BUTTON_POSITION_RIGHT), E_SYSTEM,
 586                            "[E_SYSTEM] The position is invalid.");
 587
 588         bool isButtonSet = IsButtonSet(position);
 589
 590         SysTryReturnResult(NID_UI_CTRL, isButtonSet, E_INVALID_STATE,
 591                         "[E_INVALID_STATE] No button item is set at the specified position.");
 592
 593         if (position == BUTTON_POSITION_LEFT)
 594         {
 595                 return GetCore().SetButtonBadgeIcon(LEFT_BUTTON, pBadgeIcon);
 596         }
 597         else
 598         {
 599                 return GetCore().SetButtonBadgeIcon(RIGHT_BUTTON, pBadgeIcon);
 600         }
 601 }
 602
 603 result
 604 _HeaderImpl::SetButtonNumberedBadgeIcon(ButtonPosition position, int number)
 605 {
 606         SysTryReturnResult(NID_UI_CTRL, (position == BUTTON_POSITION_LEFT || position == BUTTON_POSITION_RIGHT), E_SYSTEM,
 607                            "[E_SYSTEM] The position is invalid.");
 608
 609         bool isButtonSet = IsButtonSet(position);
 610
 611         SysTryReturnResult(NID_UI_CTRL, isButtonSet, E_INVALID_STATE,
 612                         "[E_INVALID_STATE] No button item is set at the specified position.");
 613
 614         SysTryReturnResult(NID_UI_CTRL, (0 <= number && number <= HEADER_NUMBERD_BADGE_ICON_NUMBER_MAX), E_INVALID_ARG,
 615                            "[E_INVALID_ARG] The number is invalid.");
 616
 617         if (position == BUTTON_POSITION_LEFT)
 618         {
 619                 return GetCore().SetButtonNumberedBadgeIcon(LEFT_BUTTON, number);
 620         }
 621         else
 622         {
 623                 return GetCore().SetButtonNumberedBadgeIcon(RIGHT_BUTTON, number);
 624         }
 625 }
 626
 627 result
 628 _HeaderImpl::SetItemAt(int itemIndex, const HeaderItem& item)
 629 {
 630         SysTryReturnResult(NID_UI_CTRL, (item.GetActionId() != -1), E_INVALID_ARG, "[E_INVALID_ARG] The HeaderItem isn't constructed.");
 631
 632         if (item.GetActionId() < HEADER_ACTION_ID_MIN || item.GetActionId() > HEADER_ACTION_ID_MAX)
 633         {
 634                 SysLogException(NID_UI_CTRL, E_INVALID_ARG, "[E_INVALID_ARG] The actionId is invalid.");
 635                 return E_INVALID_ARG;
 636         }
 637
 638         int count = GetItemCount();
 639
 640         SysTryReturnResult(NID_UI_CTRL, (itemIndex >= 0 && itemIndex <= count && __style != HEADER_STYLE_TITLE), E_OUT_OF_RANGE,
 641                            "[E_OUT_OF_RANGE] The itemIndex is out of range.");
 642
 643         _Button* pButton = ConvertHeaderItem(item);
 644
 645         if (__style == HEADER_STYLE_SEGMENTED || __style == HEADER_STYLE_SEGMENTED_WITH_TITLE
 646                         || __style == HEADER_STYLE_TAB || __style == HEADER_STYLE_TAB_WITH_TITLE || __style == HEADER_STYLE_TAB_LARGE)
 647         {
 648                 pButton->SetButtonStyle(_BUTTON_STYLE_SEGMENT);
 649         }
 650
 651         return GetCore().SetItemAt(itemIndex, pButton);
 652 }
 653
 654 result
 655 _HeaderImpl::SetItemBadgeIcon(int itemIndex, const Bitmap* pBadgeIcon)
 656 {
 657         SysTryReturnResult(NID_UI_CTRL, __style != HEADER_STYLE_TITLE,
 658                         E_UNSUPPORTED_OPERATION, "[E_UNSUPPORTED_OPERATION] Unable to set the badge icon because the current style does not support it.");
 659
 660         int count = GetItemCount();
 661
 662         SysTryReturnResult(NID_UI_CTRL, (itemIndex >= 0 && itemIndex < count), E_OUT_OF_RANGE,
 663                            "[E_OUT_OF_RANGE] The itemIndex is out of range.");
 664
 665         return GetCore().SetItemBadgeIcon(itemIndex, pBadgeIcon);
 666 }
 667
 668 result
 669 _HeaderImpl::SetItemNumberedBadgeIcon(int itemIndex, int number)
 670 {
 671         SysTryReturnResult(NID_UI_CTRL, __style != HEADER_STYLE_TITLE,
 672                         E_UNSUPPORTED_OPERATION, "[E_UNSUPPORTED_OPERATION] Unable to set the badge icon because the current style does not support it.");
 673
 674         SysTryReturnResult(NID_UI_CTRL, (0 <= number && number <= HEADER_NUMBERD_BADGE_ICON_NUMBER_MAX), E_INVALID_ARG,
 675                            "[E_INVALID_ARG] The number is invalid.");
 676
 677         int count = GetItemCount();
 678
 679         SysTryReturnResult(NID_UI_CTRL, (itemIndex >= 0 && itemIndex < count), E_OUT_OF_RANGE,
 680                            "[E_OUT_OF_RANGE] The itemIndex is out of range.");
 681
 682         return GetCore().SetItemNumberedBadgeIcon(itemIndex, number);
 683 }
 684
 685 result
 686 _HeaderImpl::SetItemColor(HeaderItemStatus status, const Color& color)
 687 {
 688         _ButtonStatus tempStatus = ConvertButtonStatus(status);
 689
 690         return GetCore().SetItemColor(tempStatus, color);
 691 }
 692
 693 result
 694 _HeaderImpl::SetItemEnabled(int itemIndex, bool enable)
 695 {
 696         int count = GetItemCount();
 697
 698         SysTryReturnResult(NID_UI_CTRL, (count != 0), E_SYSTEM, "[E_SYSTEM] No item to be enabled exists.")
 699
 700         SysTryReturnResult(NID_UI_CTRL, (itemIndex >= 0 && itemIndex < count), E_OUT_OF_RANGE,
 701                         "[E_OUT_OF_RANGE] The itemIndex is out of range.");
 702
 703         // Selected item cannot be disabled.
 704         int selectedItemIndex = GetSelectedItemIndex();
 705
 706         if (__style == HEADER_STYLE_SEGMENTED || __style ==  HEADER_STYLE_SEGMENTED_WITH_TITLE
 707                         || __style == HEADER_STYLE_TAB || __style == HEADER_STYLE_TAB_WITH_TITLE || __style == HEADER_STYLE_TAB_LARGE)
 708         {
 709                 if ((selectedItemIndex == itemIndex && enable == false) || (selectedItemIndex == -1 && itemIndex == 0 && enable == false))
 710                 {
 711                         SysLogException(NID_UI_CTRL, E_INVALID_OPERATION, "[E_INVALID_OPERATION] The Selected item cannot be disabled.");
 712                         return E_INVALID_OPERATION;
 713                 }
 714         }
 715
 716         return GetCore().SetItemEnabled(itemIndex, enable);
 717 }
 718
 719 result
 720 _HeaderImpl::SetItemTextColor(HeaderItemStatus status, const Color& color)
 721 {
 722         _ButtonStatus tempStatus = ConvertButtonStatus(status);
 723
 724         return GetCore().SetItemTextColor(tempStatus, color);
 725 }
 726
 727 result
 728 _HeaderImpl::SetItemSelected(int itemIndex)
 729 {
 730         SysTryReturnResult(NID_UI_CTRL, (__style == HEADER_STYLE_SEGMENTED || __style == HEADER_STYLE_SEGMENTED_WITH_TITLE
 731                         || __style == HEADER_STYLE_TAB || __style == HEADER_STYLE_TAB_WITH_TITLE || __style == HEADER_STYLE_TAB_LARGE),
 732                         E_UNSUPPORTED_OPERATION, "[E_UNSUPPORTED_OPERATION] Unable to select the item because the current style does not support it.");
 733
 734         int count = GetItemCount();
 735
 736         SysTryReturnResult(NID_UI_CTRL, (count != 0 && itemIndex >= 0 && itemIndex < count), E_OUT_OF_RANGE,
 737                            "[E_OUT_OF_RANGE] The itemIndex is out of range.");
 738
 739         // Disabled items can not be selected.
 740         HeaderItemStatus status;
 741
 742         result r = GetItemStatus(itemIndex, status);
 743
 744         SysTryReturnResult(NID_UI_CTRL, (r == E_SUCCESS), r, "[E_INVALID_STATE] Failed to get item status.");
 745
 746         SysTryReturnResult(NID_UI_CTRL, (status != HEADER_ITEM_STATUS_DISABLED), E_INVALID_OPERATION,
 747                           "[E_INVALID_OPERATION] The disabled item can not be selected.");
 748
 749         //__calledBySetItemSelected = true;
 750
 751         return GetCore().SetItemSelected(itemIndex);
 752 }
 753
 754 result
 755 _HeaderImpl::SetColor(const Color& color)
 756 {
 757         return GetCore().SetColor(color);
 758 }
 759
 760 result
 761 _HeaderImpl::SetStyle(HeaderStyle style)
 762 {
 763         RemoveAllItems();
 764         RemoveAllButtons();
 765
 766         __style = style;
 767
 768         return GetCore().SetStyle(ConvertHeaderStyle(__style));
 769 }
 770
 771 result
 772 _HeaderImpl::SetTitleIcon(const Bitmap* pIcon)
 773 {
 774         SysTryReturnResult(NID_UI_CTRL, (__style == HEADER_STYLE_TITLE || __style == HEADER_STYLE_SEGMENTED_WITH_TITLE
 775                         || __style == HEADER_STYLE_TAB_WITH_TITLE),
 776                         E_UNSUPPORTED_OPERATION, "[E_UNSUPPORTED_OPERATION] Unable to set the title icon because the current style does not support it.");
 777
 778         return GetCore().SetTitleIcon(*pIcon);
 779 }
 780
 781 result
 782 _HeaderImpl::SetTitleText(const String& text)
 783 {
 784         SysTryReturnResult(NID_UI_CTRL, (__style == HEADER_STYLE_TITLE || __style == HEADER_STYLE_SEGMENTED_WITH_TITLE
 785                         || __style == HEADER_STYLE_TAB_WITH_TITLE),
 786                         E_UNSUPPORTED_OPERATION, "[E_UNSUPPORTED_OPERATION] Unable to set the title icon because the current style does not support it.");
 787
 788         return GetCore().SetTitleText(text);
 789 }
 790
 791 result
 792 _HeaderImpl::SetTitleTextColor(const Color& color)
 793 {
 794         SysTryReturnResult(NID_UI_CTRL, (__style == HEADER_STYLE_TITLE || __style == HEADER_STYLE_SEGMENTED_WITH_TITLE
 795                         || __style == HEADER_STYLE_TAB_WITH_TITLE),
 796                         E_UNSUPPORTED_OPERATION, "[E_UNSUPPORTED_OPERATION] Unable to set the title icon because the current style does not support it.");
 797
 798         return GetCore().SetTitleTextColor(color);
 799 }
 800
 801 result
 802 _HeaderImpl::SetTransparent(bool transparent)
 803 {
 804         return GetCore().SetTransparent(transparent);
 805 }
 806
 807 result
 808 _HeaderImpl::SetDescriptionText(const String& text)
 809 {
 810         SysTryReturnResult(NID_UI_CTRL, (__style == HEADER_STYLE_TITLE), E_UNSUPPORTED_OPERATION,
 811                           "[E_UNSUPPORTED_OPERATION] Unable to set the description text icon because the current style does not support it.");
 812
 813         return GetCore().SetDescriptionText(text);
 814 }
 815
 816 result
 817 _HeaderImpl::SetDescriptionTextColor(const Color& color)
 818 {
 819         SysTryReturnResult(NID_UI_CTRL, (__style == HEADER_STYLE_TITLE), E_UNSUPPORTED_OPERATION,
 820                           "[E_UNSUPPORTED_OPERATION] Unable to set the description text icon because the current style does not support it.");
 821
 822         return GetCore().SetDescriptionTextColor(color);
 823 }
 824
 825 bool
 826 _HeaderImpl::IsTabEditModeEnabled(void) const
 827 {
 828         return GetCore().IsTabEditModeEnabled();
 829 }
 830
 831 result
 832 _HeaderImpl::SetTabEditModeEnabled(bool enable)
 833 {
 834         SysTryReturnResult(NID_UI_CTRL, (__style == HEADER_STYLE_TAB || __style == HEADER_STYLE_TAB_WITH_TITLE || __style == HEADER_STYLE_TAB_LARGE), E_UNSUPPORTED_OPERATION,
 835                         "[E_UNSUPPORTED_OPERATION] This operation is only for HEADER_STYLE_TAB, HEADER_STYLE_TAB_WITH_TITLE or HEADER_STYLE_TAB_LARGE");
 836
 837         return GetCore().SetTabEditModeEnabled(enable);
 838 }
 839
 840 result
 841 _HeaderImpl::SetBackButton(void)
 842 {
 843         return E_UNSUPPORTED_OPERATION;
 844 }
 845
 846 bool
 847 _HeaderImpl::IsBackButtonSet(void) const
 848 {
 849         return false;
 850 }
 851
 852 void
 853 _HeaderImpl::RemoveBackButton(void)
 854 {
 855         return;
 856 }
 857
 858 result
 859 _HeaderImpl::SetBackButtonEnabled(bool enable)
 860 {
 861         return E_INVALID_OPERATION;
 862 }
 863
 864 ButtonItemStatus
 865 _HeaderImpl::GetBackButtonStatus(void) const
 866 {
 867         SysTryReturn(NID_UI_CTRL, 0, BUTTON_ITEM_STATUS_NORMAL, E_INVALID_OPERATION,
 868                         "[E_INVALID_OPERATION] No button item is set at the specified position.");
 869 }
 870
 871 Rectangle
 872 _HeaderImpl::GetButtonBounds(ButtonPosition position) const
 873 {
 874         bool isButtonSet = IsButtonSet(position);
 875
 876         SysTryReturn(NID_UI_CTRL, isButtonSet, Rectangle(-1, -1, -1, -1), E_INVALID_OPERATION, "[E_INVALID_OPERATION] No button item is set at the specified position.");
 877
 878         Rectangle rect;
 879
 880         if (position == BUTTON_POSITION_LEFT)
 881         {
 882                 rect = GetCore().GetButtonBounds(LEFT_BUTTON);
 883         }
 884         else if (position == BUTTON_POSITION_RIGHT)
 885         {
 886                 rect = GetCore().GetButtonBounds(RIGHT_BUTTON);
 887         }
 888
 889         return rect;
 890 }
 891
 892 FloatRectangle
 893 _HeaderImpl::GetButtonBoundsF(ButtonPosition position) const
 894 {
 895         bool isButtonSet = IsButtonSet(position);
 896
 897         SysTryReturn(NID_UI_CTRL, isButtonSet, FloatRectangle(-1.0f, -1.0f, -1.0f, -1.0f),
 898                         E_INVALID_OPERATION, "[E_INVALID_OPERATION] No button item is set at the specified position.");
 899
 900         FloatRectangle rect;
 901
 902         if (position == BUTTON_POSITION_LEFT)
 903         {
 904                 rect = GetCore().GetButtonBoundsF(LEFT_BUTTON);
 905         }
 906         else if (position == BUTTON_POSITION_RIGHT)
 907         {
 908                 rect = GetCore().GetButtonBoundsF(RIGHT_BUTTON);
 909         }
 910
 911         return rect;
 912 }
 913
 914 result
 915 _HeaderImpl::SetTitleBadgeIcon(const Bitmap* pBadgeIcon)
 916 {
 917         SysTryReturnResult(NID_UI_CTRL, (__style == HEADER_STYLE_TITLE || __style == HEADER_STYLE_SEGMENTED_WITH_TITLE
 918                         || __style == HEADER_STYLE_TAB_WITH_TITLE),
 919                         E_INVALID_OPERATION, "[E_INVALID_OPERATION] Unable to set the title badge icon because the current style does not support it.");
 920
 921         return GetCore().SetTitleBadgeIcon(pBadgeIcon);
 922 }
 923
 924 result
 925 _HeaderImpl::SetTitleNumberedBadgeIcon(int number)
 926 {
 927         SysTryReturnResult(NID_UI_CTRL, (__style == HEADER_STYLE_TITLE || __style == HEADER_STYLE_SEGMENTED_WITH_TITLE
 928                         || __style == HEADER_STYLE_TAB_WITH_TITLE),
 929                         E_INVALID_OPERATION, "[E_INVALID_OPERATION] Unable to set the title badge icon because the current style does not support it.");
 930
 931         SysTryReturnResult(NID_UI_CTRL, (0 <= number && number <= HEADER_NUMBERD_BADGE_ICON_NUMBER_MAX), E_INVALID_ARG,
 932                         "[E_INVALID_ARG] The number is invalid.");
 933
 934         return GetCore().SetTitleNumberedBadgeIcon(number);
 935 }
 936
 937 void
 938 _HeaderImpl::AddActionEventListener(IActionEventListener& listener)
 939 {
 940         if (__pPublicActionEvent == null)
 941         {
 942                 __pPublicActionEvent = _PublicActionEvent::CreateInstanceN(GetPublic());
 943
 944                 if (IsFailed(GetLastResult()))
 945                 {
 946                         SysLogException(NID_UI_CTRL, E_SYSTEM, "[E_SYSTEM] System error occurred.");
 947                         delete __pPublicActionEvent;
 948
 949                         return;
 950                 }
 951         }
 952
 953         __pPublicActionEvent->AddListener(listener);
 954
 955         GetCore().AddActionEventListener(*this);
 956
 957         return;
 958 }
 959
 960 void
 961 _HeaderImpl::RemoveActionEventListener(IActionEventListener& listener)
 962 {
 963         SysTryReturnVoidResult(NID_UI_CTRL, __pPublicActionEvent, E_INVALID_STATE, "[E_INVALID_STATE] This instance isn't constructed.");
 964
 965         // Todo : check fail case of RemoveListener
 966         __pPublicActionEvent->RemoveListener(listener);
 967
 968         GetCore().RemoveActionEventListener(*this);
 969
 970         return;
 971 }
 972
 973 void
 974 _HeaderImpl::OnActionPerformed(const _Control& source, int actionId)
 975 {
 976         if (GetCore().IsInitialDraw() == true && GetCore().GetSelectedItemIndex() == 0)
 977         {
 978                 return;
 979         }
 980
 981         if (__pPublicActionEvent != null)
 982         {
 983                 __pPublicActionEvent->Fire(*_PublicActionEvent::CreateActionEventArgN(actionId));
 984         }
 985
 986         return;
 987 }
 988
 989 result
 990 _HeaderImpl::CheckItemValidate(const HeaderItem& item)
 991 {
 992         result r = E_SUCCESS;
 993
 994         SysTryReturnResult(NID_UI_CTRL, (item.GetActionId() != -1), E_INVALID_ARG, "[E_INVALID_ARG] The HeaderItem isn't constructed.");
 995
 996         int count = GetItemCount();
 997
 998         if (__style == HEADER_STYLE_TAB || __style == HEADER_STYLE_TAB_WITH_TITLE || __style == HEADER_STYLE_TAB_LARGE)
 999         {
1000                 SysTryReturnResult(NID_UI_CTRL, (count < HEADER_TAB_STYLE_MAX_ITEM_COUNT), E_MAX_EXCEEDED,
1001                                 "[E_MAX_EXCEEDED] The number of items have exceeded the maximum limit.");
1002         }
1003         else
1004         {
1005                 SysTryReturnResult(NID_UI_CTRL, (count < HEADER_ITEM_MAX_COUNT), E_MAX_EXCEEDED,
1006                                 "[E_MAX_EXCEEDED] The number of items have exceeded the maximum limit.");
1007         }
1008
1009         if ((HEADER_STYLE_TITLE_BUTTON == __style) && (HEADER_TITLE_BUTTON_STYLE_MAX_ITEM_COUNT <= count))
1010         {
1011                 SysLogException(NID_UI_CTRL, E_MAX_EXCEEDED, "[E_MAX_EXCEEDED] The number of items exceeded the maximum limit.");
1012                 r = E_MAX_EXCEEDED;
1013                 goto CATCH;
1014         }
1015
1016         if ((count >= HEADER_MAX_ITEM_COUNT_WITH_BUTTON) &&
1017                 (true == IsButtonSet(BUTTON_POSITION_LEFT) || true == IsButtonSet(BUTTON_POSITION_RIGHT)))
1018         {
1019                 SysLogException(NID_UI_CTRL, E_MAX_EXCEEDED, "[E_MAX_EXCEEDED] The number of items with button have exceeded the maximum limit.");
1020                 r = E_MAX_EXCEEDED;
1021                 goto CATCH;
1022         }
1023
1024         if (item.GetActionId() < HEADER_ACTION_ID_MIN || item.GetActionId() > HEADER_ACTION_ID_MAX)
1025         {
1026                 SysLogException(NID_UI_CTRL, E_INVALID_ARG, "[E_INVALID_ARG] The actionId is invalid.");
1027                 r = E_INVALID_ARG;
1028                 goto CATCH;
1029         }
1030
1031         return (r);
1032
1033 CATCH:
1034         return (r);
1035 }
1036
1037 ToolbarStyle
1038 _HeaderImpl::ConvertHeaderStyle(HeaderStyle style)
1039 {
1040         ToolbarStyle viewStyle = TOOLBAR_TITLE;
1041
1042         if (style == HEADER_STYLE_TITLE || style == HEADER_STYLE_TITLE_BUTTON)
1043         {
1044                 viewStyle = TOOLBAR_TITLE;
1045         }
1046         else if (style == HEADER_STYLE_SEGMENTED)
1047         {
1048                 viewStyle = TOOLBAR_HEADER_SEGMENTED;
1049         }
1050         else if (style == HEADER_STYLE_SEGMENTED_WITH_TITLE)
1051         {
1052                 viewStyle = TOOLBAR_HEADER_SEGMENTED_WITH_TITLE;
1053         }
1054         else if (style == HEADER_STYLE_TAB)
1055         {
1056                 viewStyle = TOOLBAR_TAB;
1057         }
1058         else if (style == HEADER_STYLE_TAB_WITH_TITLE)
1059         {
1060                 viewStyle = TOOLBAR_TAB_WITH_TITLE;
1061         }
1062         else if (style == HEADER_STYLE_BUTTON)
1063         {
1064                 viewStyle = TOOLBAR_TEXT;
1065         }
1066         else if (style == HEADER_STYLE_TAB_LARGE)
1067         {
1068                 viewStyle = TOOLBAR_TAB_LARGE;
1069         }
1070
1071         return viewStyle;
1072 }
1073
1074 _Button*
1075 _HeaderImpl::ConvertButtonItem(const ButtonItem& buttonItem)
1076 {
1077         result r = E_SUCCESS;
1078
1079         _Button* pButton = _Button::CreateButtonN();
1080
1081         pButton->SetMargin(0.0f, 0.0f, 0.0f, 0.0f);
1082
1083         float fontSize = 0.0f;
1084         float multilineFontSize = 0.0f;
1085
1086         if (__style == HEADER_STYLE_BUTTON)
1087         {
1088                 r = GET_SHAPE_CONFIG(FOOTER::BUTTON_ITEM_FONT_SIZE, GetCore().GetOrientation(), fontSize);
1089                 if (!IsFailed(r))
1090                 {
1091                         pButton->SetTextSize(fontSize, FONT_STYLE_BOLD);
1092                 }
1093
1094                 r = GET_SHAPE_CONFIG(FOOTER::BUTTON_ITEM_MULTILINE_FONT_SIZE, GetCore().GetOrientation(), multilineFontSize);
1095                 if (!IsFailed(r))
1096                 {
1097                         pButton->SetMultilineTextSize(multilineFontSize);
1098                 }
1099         }
1100         else
1101         {
1102                 r = GET_SHAPE_CONFIG(HEADER::BUTTON_ITEM_FONT_SIZE, GetCore().GetOrientation(), fontSize);
1103                 if (!IsFailed(r))
1104                 {
1105                         pButton->SetTextSize(fontSize, FONT_STYLE_BOLD);
1106                 }
1107
1108                 r = GET_SHAPE_CONFIG(HEADER::BUTTON_ITEM_MULTILINE_FONT_SIZE, GetCore().GetOrientation(), multilineFontSize);
1109                 if (!IsFailed(r))
1110                 {
1111                         pButton->SetMultilineTextSize(multilineFontSize);
1112                 }
1113         }
1114
1115         pButton->SetText(buttonItem.GetText());
1116
1117         float buttonItemWidth = 0.0f;
1118         float buttonItemHeight = 0.0f;
1119         float textMargin = 0.0f;
1120
1121         GET_SHAPE_CONFIG(HEADER::BUTTON_ITEM_HEIGHT, GetCore().GetOrientation(), buttonItemHeight);
1122         GET_SHAPE_CONFIG(HEADER::BUTTON_ITEM_WIDTH, GetCore().GetOrientation(), buttonItemWidth);
1123         GET_SHAPE_CONFIG(HEADER::BUTTON_ITEM_MARGIN_WITH_TEXT, GetCore().GetOrientation(), textMargin);
1124
1125         if (buttonItem.GetText() != L"")
1126         {
1127                 pButton->SetBounds(FloatRectangle(0.0f, 0.0f, buttonItemWidth, buttonItemHeight));
1128
1129                 float extentSize = 0.0f;
1130                 float extentSizeMax = 0.0f;
1131                 float extentSizeMin = 0.0f;
1132
1133                 GET_SHAPE_CONFIG(HEADER::BUTTON_ITEM_WIDTH_WITH_TEXT, GetCore().GetOrientation(), extentSizeMax);
1134                 GET_SHAPE_CONFIG(HEADER::BUTTON_ITEM_WIDTH, GetCore().GetOrientation(), extentSizeMin);
1135
1136                 extentSize = pButton->GetTextExtentSizeF() + textMargin * 2;
1137
1138                 if (extentSize > extentSizeMax)
1139                 {
1140                         extentSize = extentSizeMax;
1141                 }
1142
1143                 if (extentSize < extentSizeMin)
1144                 {
1145                         extentSize = extentSizeMin;
1146                 }
1147
1148                 pButton->SetMargin(textMargin, 0.0f, textMargin, 0.0f);
1149                 pButton->SetBounds(FloatRectangle(0.0f, 0.0f, extentSize, buttonItemHeight));
1150         }
1151         else
1152         {
1153                 pButton->SetBounds(FloatRectangle(0.0f, 0.0f, buttonItemWidth, buttonItemHeight));
1154         }
1155
1156         pButton->SetActionId(buttonItem.GetActionId());
1157         pButton->SetTextMaxLine(2);
1158
1159         float iconSize = 0.0f;
1160
1161         if (__style == HEADER_STYLE_BUTTON)
1162         {
1163                 GET_SHAPE_CONFIG(FOOTER::BUTTON_ITEM_ICON_SIZE, GetCore().GetOrientation(), iconSize); // 63
1164         }
1165         else
1166         {
1167                 if (__style == HEADER_STYLE_SEGMENTED_WITH_TITLE)
1168                 {
1169                         GET_SHAPE_CONFIG(HEADER::TAB_ITEM_ICON_SIZE, GetCore().GetOrientation(), iconSize); //63
1170                 }
1171                 else
1172                 {
1173                         GET_SHAPE_CONFIG(HEADER::BUTTON_ITEM_ICON_SIZE, GetCore().GetOrientation(), iconSize); //63
1174                 }
1175         }
1176
1177         Bitmap* pIconBitmap = null;
1178         pIconBitmap = const_cast<Bitmap*>(buttonItem.__pImpl->GetIcon(BUTTON_ITEM_STATUS_NORMAL));
1179
1180         if (pIconBitmap)
1181         {
1182                 pIconBitmap->Scale(FloatDimension(iconSize, iconSize));
1183
1184                 pButton->SetBitmap(_BUTTON_STATUS_NORMAL, FloatPoint(0.0f, 0.0f), *pIconBitmap);
1185                 pButton->SetBitmap(_BUTTON_STATUS_PRESSED, FloatPoint(0.0f, 0.0f), *pIconBitmap);
1186                 pButton->SetBitmap(_BUTTON_STATUS_HIGHLIGHTED, FloatPoint(0.0f, 0.0f), *pIconBitmap);
1187                 pButton->SetBitmap(_BUTTON_STATUS_DISABLED, FloatPoint(0.0f, 0.0f), *pIconBitmap);
1188         }
1189
1190         pIconBitmap = const_cast<Bitmap*>(buttonItem.__pImpl->GetIcon(BUTTON_ITEM_STATUS_PRESSED));
1191
1192         if (pIconBitmap)
1193         {
1194                 pIconBitmap->Scale(FloatDimension(iconSize, iconSize));
1195
1196                 pButton->SetBitmap(_BUTTON_STATUS_PRESSED, FloatPoint(0.0f, 0.0f), *pIconBitmap);
1197         }
1198
1199         pIconBitmap = const_cast<Bitmap*>(buttonItem.__pImpl->GetIcon(BUTTON_ITEM_STATUS_HIGHLIGHTED));
1200
1201         if (pIconBitmap)
1202         {
1203                 pIconBitmap->Scale(FloatDimension(iconSize, iconSize));
1204
1205                 pButton->SetBitmap(_BUTTON_STATUS_HIGHLIGHTED, FloatPoint(0.0f, 0.0f), *pIconBitmap);
1206         }
1207
1208         pIconBitmap = const_cast<Bitmap*>(buttonItem.__pImpl->GetIcon(BUTTON_ITEM_STATUS_DISABLED));
1209
1210         if (pIconBitmap)
1211         {
1212                 pIconBitmap->Scale(FloatDimension(iconSize, iconSize));
1213
1214                 pButton->SetBitmap(_BUTTON_STATUS_DISABLED, FloatPoint(0.0f, 0.0f),     *pIconBitmap);
1215         }
1216
1217         Bitmap* pNormalBackgroundBitmap = null;
1218         Bitmap* pDisabledBackgroundBitmap = null;
1219         Bitmap* pPressedBackgroundBitmap = null;
1220         Bitmap* pHighlightedBackgroundBitmap = null;
1221
1222         Bitmap* pColorReplacedBitmap = null;
1223
1224         GET_BITMAP_CONFIG_N(HEADER::BUTTON_BG_NORMAL, BITMAP_PIXEL_FORMAT_ARGB8888, pNormalBackgroundBitmap);
1225         GET_BITMAP_CONFIG_N(HEADER::BUTTON_BG_DISABLED, BITMAP_PIXEL_FORMAT_ARGB8888, pDisabledBackgroundBitmap);
1226         GET_BITMAP_CONFIG_N(HEADER::BUTTON_BG_PRESSED, BITMAP_PIXEL_FORMAT_ARGB8888, pPressedBackgroundBitmap);
1227         GET_BITMAP_CONFIG_N(HEADER::BUTTON_BG_HIGHLIGHTED, BITMAP_PIXEL_FORMAT_ARGB8888, pHighlightedBackgroundBitmap);
1228
1229         if (pNormalBackgroundBitmap)
1230         {
1231                 pColorReplacedBitmap = _BitmapImpl::GetColorReplacedBitmapN(*pNormalBackgroundBitmap, Color::GetColor(COLOR_ID_MAGENTA),
1232                                 GetCore().GetButtonColor(_BUTTON_STATUS_NORMAL));
1233
1234                 if (GetCore().GetButtonColor(_BUTTON_STATUS_NORMAL).GetAlpha() != 0xFF)
1235                 {
1236                         pColorReplacedBitmap->SetAlphaConstant(GetCore().GetButtonColor(_BUTTON_STATUS_NORMAL).GetAlpha());
1237                 }
1238
1239                 pButton->SetBackgroundBitmap(_BUTTON_STATUS_NORMAL, *pColorReplacedBitmap);
1240
1241                 delete pColorReplacedBitmap;
1242                 delete pNormalBackgroundBitmap;
1243         }
1244
1245         if (pDisabledBackgroundBitmap)
1246         {
1247                 pColorReplacedBitmap = _BitmapImpl::GetColorReplacedBitmapN(*pDisabledBackgroundBitmap, Color::GetColor(COLOR_ID_MAGENTA),
1248                                 GetCore().GetButtonColor(_BUTTON_STATUS_DISABLED));
1249
1250                 if (GetCore().GetButtonColor(_BUTTON_STATUS_DISABLED).GetAlpha() != 0xFF)
1251                 {
1252                         pColorReplacedBitmap->SetAlphaConstant(GetCore().GetButtonColor(_BUTTON_STATUS_DISABLED).GetAlpha());
1253                 }
1254
1255                 pButton->SetBackgroundBitmap(_BUTTON_STATUS_DISABLED, *pColorReplacedBitmap);
1256
1257                 delete pColorReplacedBitmap;
1258                 delete pDisabledBackgroundBitmap;
1259         }
1260
1261         if (pPressedBackgroundBitmap)
1262         {
1263                 pColorReplacedBitmap = _BitmapImpl::GetColorReplacedBitmapN(*pPressedBackgroundBitmap, Color::GetColor(COLOR_ID_MAGENTA),
1264                                 GetCore().GetButtonColor(_BUTTON_STATUS_PRESSED));
1265
1266                 if (GetCore().GetButtonColor(_BUTTON_STATUS_PRESSED).GetAlpha() != 0xFF)
1267                 {
1268                         pColorReplacedBitmap->SetAlphaConstant(GetCore().GetButtonColor(_BUTTON_STATUS_PRESSED).GetAlpha());
1269                 }
1270
1271                 pButton->SetBackgroundBitmap(_BUTTON_STATUS_PRESSED, *pColorReplacedBitmap);
1272
1273                 delete pColorReplacedBitmap;
1274                 delete pPressedBackgroundBitmap;
1275         }
1276
1277         if (pHighlightedBackgroundBitmap)
1278         {
1279                 pColorReplacedBitmap = _BitmapImpl::GetColorReplacedBitmapN(*pHighlightedBackgroundBitmap, Color::GetColor(COLOR_ID_MAGENTA),
1280                                 GetCore().GetButtonColor(_BUTTON_STATUS_HIGHLIGHTED));
1281
1282                 if (GetCore().GetButtonColor(_BUTTON_STATUS_HIGHLIGHTED).GetAlpha() != 0xFF)
1283                 {
1284                         pColorReplacedBitmap->SetAlphaConstant(GetCore().GetButtonColor(_BUTTON_STATUS_HIGHLIGHTED).GetAlpha());
1285                 }
1286
1287                 pButton->SetBackgroundBitmap(_BUTTON_STATUS_HIGHLIGHTED, *pColorReplacedBitmap);
1288
1289                 delete pColorReplacedBitmap;
1290                 delete pHighlightedBackgroundBitmap;
1291         }
1292
1293         if (buttonItem.__pImpl->GetBackgroundBitmap(BUTTON_ITEM_STATUS_NORMAL) != null)
1294         {
1295                 pButton->SetToolbarItemBackgroundBitmap(_BUTTON_STATUS_NORMAL,
1296                                 *buttonItem.__pImpl->GetBackgroundBitmap(BUTTON_ITEM_STATUS_NORMAL));
1297         }
1298         if (buttonItem.__pImpl->GetBackgroundBitmap(BUTTON_ITEM_STATUS_PRESSED) != null)
1299         {
1300                 pButton->SetToolbarItemBackgroundBitmap(_BUTTON_STATUS_PRESSED,
1301                                 *buttonItem.__pImpl->GetBackgroundBitmap(BUTTON_ITEM_STATUS_PRESSED));
1302         }
1303         if (buttonItem.__pImpl->GetBackgroundBitmap(BUTTON_ITEM_STATUS_HIGHLIGHTED) != null)
1304         {
1305                 pButton->SetToolbarItemBackgroundBitmap(_BUTTON_STATUS_HIGHLIGHTED,
1306                                 *buttonItem.__pImpl->GetBackgroundBitmap(BUTTON_ITEM_STATUS_HIGHLIGHTED));
1307         }
1308         if (buttonItem.__pImpl->GetBackgroundBitmap(BUTTON_ITEM_STATUS_DISABLED) != null)
1309         {
1310                 pButton->SetToolbarItemBackgroundBitmap(_BUTTON_STATUS_DISABLED,
1311                                 *buttonItem.__pImpl->GetBackgroundBitmap(BUTTON_ITEM_STATUS_DISABLED));
1312         }
1313
1314         if (buttonItem.__pImpl->__accessibilityHint.GetLength() > 0)
1315         {
1316                 _AccessibilityContainer* pContainer = pButton->GetAccessibilityContainer();
1317                 if (pContainer)
1318                 {
1319                         _AccessibilityElement* pElement = pContainer->GetChildElement(L"ButtonText");
1320                         if (pElement)
1321                         {
1322                                 pElement->SetHint(buttonItem.__pImpl->__accessibilityHint);
1323                         }
1324                 }
1325         }
1326
1327         return pButton;
1328 }
1329
1330 _Button*
1331 _HeaderImpl::ConvertHeaderItem(const HeaderItem& headerItem)
1332 {
1333         _Button* pButton = _Button::CreateButtonN();
1334
1335         float minItemLength = 0.0f;
1336
1337         GET_SHAPE_CONFIG(HEADER::ITEM_MINIMUM_WIDTH, GetCore().GetOrientation(), minItemLength);
1338
1339         pButton->SetBounds(FloatRectangle(0.0f, 0.0f, minItemLength, minItemLength));
1340
1341         pButton->SetActionId(headerItem.GetActionId());
1342
1343         pButton->SetText(headerItem.GetText());
1344
1345         pButton->SetTextMaxLine(2);
1346
1347         float fontSize = 0.0f;
1348         result r = E_SUCCESS;
1349
1350         bool customTheme = false;
1351
1352         if (__style == HEADER_STYLE_SEGMENTED || __style == HEADER_STYLE_SEGMENTED_WITH_TITLE || __style == HEADER_STYLE_TITLE_BUTTON)
1353         {
1354                 r = GET_SHAPE_CONFIG(HEADER::SEGMENTED_ITEM_FONT_SIZE, GetCore().GetOrientation(), fontSize);
1355         }
1356         else if (__style == HEADER_STYLE_TAB || __style == HEADER_STYLE_TAB_WITH_TITLE || __style == HEADER_STYLE_TAB_LARGE)
1357         {
1358                 r = GET_SHAPE_CONFIG(HEADER::TAB_ITEM_FONT_SIZE, GetCore().GetOrientation(), fontSize);
1359         }
1360         else // __style == HEADER_STYLE_BUTTON
1361         {
1362                 r = GET_SHAPE_CONFIG(FOOTER::FOOTER_ITEM_FONT_SIZE, GetCore().GetOrientation(), fontSize);
1363         }
1364
1365         if (!IsFailed(r))
1366         {
1367                 pButton->SetTextSize(fontSize, FONT_STYLE_BOLD);
1368         }
1369
1370         float iconSize = 0.0f;
1371
1372         if (__style == HEADER_STYLE_SEGMENTED || __style == HEADER_STYLE_SEGMENTED_WITH_TITLE
1373                         || __style == HEADER_STYLE_TAB_WITH_TITLE || __style == HEADER_STYLE_TAB || __style == HEADER_STYLE_TAB_LARGE)
1374         {
1375                 if (headerItem.GetText() != L"" && __style != HEADER_STYLE_TAB_LARGE)
1376                 {
1377                         GET_SHAPE_CONFIG(HEADER::TAB_ITEM_ICON_SIZE_WITH_TEXT, GetCore().GetOrientation(), iconSize); // 45
1378                 }
1379                 else
1380                 {
1381                         GET_SHAPE_CONFIG(HEADER::TAB_ITEM_ICON_SIZE, GetCore().GetOrientation(), iconSize); // 63
1382                 }
1383
1384                 Bitmap* pSelectedBitmap = null;
1385                 Bitmap* pColorReplacedBitmap = null;
1386                 Color selectedBitmapColor;
1387
1388                 GET_BITMAP_CONFIG_N(HEADER::TAB_ITEM_SELECTED, BITMAP_PIXEL_FORMAT_ARGB8888, pSelectedBitmap);
1389                 GET_COLOR_CONFIG(HEADER::SELECTED_BAR_BG_NORMAL, selectedBitmapColor);
1390
1391                 pColorReplacedBitmap = _BitmapImpl::GetColorReplacedBitmapN(*pSelectedBitmap, Color::GetColor(COLOR_ID_MAGENTA), selectedBitmapColor);
1392
1393                 if (__style == HEADER_STYLE_SEGMENTED || __style == HEADER_STYLE_SEGMENTED_WITH_TITLE)
1394                 {
1395                         if (GetCore().IsTransparent() == true)
1396                         {
1397                                 customTheme = IS_CUSTOM_BITMAP(HEADER::SEGMENTED_ITEM_TRANSLUCENT_BG_SELECTED);
1398                         }
1399                         else
1400                         {
1401                                 customTheme = IS_CUSTOM_BITMAP(HEADER::SEGMENTED_ITEM_BG_SELECTED);
1402                         }
1403                 }
1404                 else if (__style == HEADER_STYLE_TAB_WITH_TITLE || __style == HEADER_STYLE_TAB || __style == HEADER_STYLE_TAB_LARGE)
1405                 {
1406                         if (GetCore().IsTransparent() == true)
1407                         {
1408                                 customTheme = IS_CUSTOM_BITMAP(HEADER::TAB_ITEM_TRANSLUCENT_BG_SELECTED);
1409                         }
1410                         else
1411                         {
1412                                 customTheme = IS_CUSTOM_BITMAP(HEADER::TAB_ITEM_BG_SELECTED);
1413                         }
1414                 }
1415
1416                 if (pColorReplacedBitmap && customTheme == false)
1417                 {
1418                         if (__style == HEADER_STYLE_SEGMENTED_WITH_TITLE || __style == HEADER_STYLE_TAB_WITH_TITLE)
1419                         {
1420                                 pButton->SetUnderlineBitmap(*pColorReplacedBitmap);
1421                         }
1422                         else
1423                         {
1424                                 pButton->SetUnderlineBitmap(*pColorReplacedBitmap);
1425                         }
1426                 }
1427
1428                 delete pColorReplacedBitmap;
1429                 delete pSelectedBitmap;
1430
1431                 if (__style == HEADER_STYLE_TAB_LARGE || __style == HEADER_STYLE_SEGMENTED_WITH_TITLE || __style == HEADER_STYLE_TAB_WITH_TITLE)
1432                 {
1433                         pButton->SetTabTextSlide(true);
1434                 }
1435         }
1436         else // __style == HEADER_STYLE_BUTTON
1437         {
1438                 if (headerItem.GetText() != L"")
1439                 {
1440                         GET_SHAPE_CONFIG(FOOTER::FOOTER_ITEM_BUTTON_STYLE_ICON_SIZE_WITH_TEXT, GetCore().GetOrientation(), iconSize); //45
1441                 }
1442                 else
1443                 {
1444                         GET_SHAPE_CONFIG(FOOTER::FOOTER_ITEM_BUTTON_STYLE_ICON_SIZE, GetCore().GetOrientation(), iconSize); // 63
1445                 }
1446         }
1447
1448         Bitmap* pIconBitmap = null;
1449
1450         pIconBitmap = const_cast<Bitmap*>(headerItem.__pImpl->GetIcon(HEADER_ITEM_STATUS_NORMAL));
1451         if (pIconBitmap)
1452         {
1453                 pIconBitmap->Scale(FloatDimension(iconSize, iconSize));
1454
1455                 pButton->SetBitmap(_BUTTON_STATUS_NORMAL, FloatPoint(0.0f, 0.0f), *pIconBitmap);
1456                 pButton->SetBitmap(_BUTTON_STATUS_PRESSED, FloatPoint(0.0f, 0.0f), *pIconBitmap);
1457                 pButton->SetBitmap(_BUTTON_STATUS_SELECTED, FloatPoint(0.0f, 0.0f), *pIconBitmap);
1458                 pButton->SetBitmap(_BUTTON_STATUS_HIGHLIGHTED, FloatPoint(0.0f, 0.0f), *pIconBitmap);
1459                 pButton->SetBitmap(_BUTTON_STATUS_DISABLED, FloatPoint(0.0f, 0.0f), *pIconBitmap);
1460         }
1461
1462         pIconBitmap = const_cast<Bitmap*>(headerItem.__pImpl->GetIcon(HEADER_ITEM_STATUS_PRESSED));
1463
1464         if (pIconBitmap)
1465         {
1466                 pIconBitmap->Scale(FloatDimension(iconSize, iconSize));
1467
1468                 pButton->SetBitmap(_BUTTON_STATUS_PRESSED, FloatPoint(0.0f, 0.0f), *pIconBitmap);
1469         }
1470
1471         pIconBitmap = const_cast<Bitmap*>(headerItem.__pImpl->GetIcon(HEADER_ITEM_STATUS_SELECTED));
1472
1473         if (pIconBitmap)
1474         {
1475                 pIconBitmap->Scale(FloatDimension(iconSize, iconSize));
1476
1477                 pButton->SetBitmap(_BUTTON_STATUS_SELECTED, FloatPoint(0.0f, 0.0f), *pIconBitmap);
1478         }
1479
1480         pIconBitmap = const_cast<Bitmap*>(headerItem.__pImpl->GetIcon(HEADER_ITEM_STATUS_HIGHLIGHTED));
1481
1482         if (pIconBitmap)
1483         {
1484                 pIconBitmap->Scale(FloatDimension(iconSize, iconSize));
1485
1486                 pButton->SetBitmap(_BUTTON_STATUS_HIGHLIGHTED, FloatPoint(0.0f, 0.0f), *pIconBitmap);
1487         }
1488
1489         pIconBitmap = const_cast<Bitmap*>(headerItem.__pImpl->GetIcon(HEADER_ITEM_STATUS_DISABLED));
1490
1491         if (pIconBitmap)
1492         {
1493                 pIconBitmap->Scale(FloatDimension(iconSize, iconSize));
1494
1495                 pButton->SetBitmap(_BUTTON_STATUS_DISABLED, FloatPoint(0.0f, 0.0f), *pIconBitmap);
1496         }
1497
1498         if (headerItem.__pImpl->GetBackgroundBitmap(HEADER_ITEM_STATUS_NORMAL) != null)
1499         {
1500                 pButton->SetToolbarItemBackgroundBitmap(_BUTTON_STATUS_NORMAL,
1501                                 *headerItem.__pImpl->GetBackgroundBitmap(HEADER_ITEM_STATUS_NORMAL));
1502         }
1503         if (headerItem.__pImpl->GetBackgroundBitmap(HEADER_ITEM_STATUS_PRESSED) != null)
1504         {
1505                 pButton->SetToolbarItemBackgroundBitmap(_BUTTON_STATUS_PRESSED,
1506                                 *headerItem.__pImpl->GetBackgroundBitmap(HEADER_ITEM_STATUS_PRESSED));
1507         }
1508         if (headerItem.__pImpl->GetBackgroundBitmap(HEADER_ITEM_STATUS_SELECTED) != null)
1509         {
1510                 pButton->SetToolbarItemBackgroundBitmap(_BUTTON_STATUS_SELECTED,
1511                                 *headerItem.__pImpl->GetBackgroundBitmap(HEADER_ITEM_STATUS_SELECTED));
1512         }
1513         if (headerItem.__pImpl->GetBackgroundBitmap(HEADER_ITEM_STATUS_HIGHLIGHTED) != null)
1514         {
1515                 pButton->SetToolbarItemBackgroundBitmap(_BUTTON_STATUS_HIGHLIGHTED,
1516                                 *headerItem.__pImpl->GetBackgroundBitmap(HEADER_ITEM_STATUS_HIGHLIGHTED));
1517         }
1518         if (headerItem.__pImpl->GetBackgroundBitmap(HEADER_ITEM_STATUS_DISABLED) != null)
1519         {
1520                 pButton->SetToolbarItemBackgroundBitmap(_BUTTON_STATUS_DISABLED,
1521                                 *headerItem.__pImpl->GetBackgroundBitmap(HEADER_ITEM_STATUS_DISABLED));
1522         }
1523
1524         if (headerItem.__pImpl->__accessibilityHint.GetLength() > 0)
1525         {
1526                 _AccessibilityContainer* pContainer = pButton->GetAccessibilityContainer();
1527                 if (pContainer)
1528                 {
1529                         _AccessibilityElement* pElement = pContainer->GetChildElement(L"ButtonText");
1530                         if (pElement)
1531                         {
1532                                 pElement->SetHint(headerItem.__pImpl->__accessibilityHint);
1533                         }
1534                 }
1535         }
1536
1537         return pButton;
1538 }
1539
1540 ButtonItemStatus
1541 _HeaderImpl::ConvertButtonItemStatus(_ButtonStatus status) const
1542 {
1543         switch (status)
1544         {
1545         case _BUTTON_STATUS_NORMAL:
1546                 return BUTTON_ITEM_STATUS_NORMAL;
1547                 break;
1548
1549         case _BUTTON_STATUS_DISABLED:
1550                 return BUTTON_ITEM_STATUS_DISABLED;
1551                 break;
1552
1553         case _BUTTON_STATUS_PRESSED:
1554                 return BUTTON_ITEM_STATUS_PRESSED;
1555                 break;
1556
1557         case _BUTTON_STATUS_HIGHLIGHTED:
1558                 return BUTTON_ITEM_STATUS_HIGHLIGHTED;
1559                 break;
1560
1561         default:
1562                 return BUTTON_ITEM_STATUS_DISABLED;
1563                 break;
1564         }
1565 }
1566
1567 HeaderItemStatus
1568 _HeaderImpl::ConvertHeaderItemStatus(_ButtonStatus status) const
1569 {
1570         switch (status)
1571         {
1572         case _BUTTON_STATUS_NORMAL:
1573                 return HEADER_ITEM_STATUS_NORMAL;
1574                 break;
1575
1576         case _BUTTON_STATUS_DISABLED:
1577                 return HEADER_ITEM_STATUS_DISABLED;
1578                 break;
1579
1580         case _BUTTON_STATUS_PRESSED:
1581                 return HEADER_ITEM_STATUS_PRESSED;
1582                 break;
1583
1584         case _BUTTON_STATUS_HIGHLIGHTED:
1585                 return HEADER_ITEM_STATUS_HIGHLIGHTED;
1586                 break;
1587
1588         case _BUTTON_STATUS_SELECTED:
1589                 return HEADER_ITEM_STATUS_SELECTED;
1590                 break;
1591
1592         default:
1593                 return HEADER_ITEM_STATUS_DISABLED;
1594                 break;
1595         }
1596 }
1597
1598 _ButtonStatus
1599 _HeaderImpl::ConvertButtonStatus(ButtonItemStatus status) const
1600 {
1601         switch (status)
1602         {
1603         case BUTTON_ITEM_STATUS_NORMAL:
1604                 return _BUTTON_STATUS_NORMAL;
1605                 break;
1606
1607         case BUTTON_ITEM_STATUS_DISABLED:
1608                 return _BUTTON_STATUS_DISABLED;
1609                 break;
1610
1611         case BUTTON_ITEM_STATUS_PRESSED:
1612                 return _BUTTON_STATUS_PRESSED;
1613                 break;
1614
1615         case BUTTON_ITEM_STATUS_HIGHLIGHTED:
1616                 return _BUTTON_STATUS_HIGHLIGHTED;
1617                 break;
1618
1619         default:
1620                 return _BUTTON_STATUS_DISABLED;
1621                 break;
1622         }
1623 }
1624
1625 _ButtonStatus
1626 _HeaderImpl::ConvertButtonStatus(HeaderItemStatus status) const
1627 {
1628         switch (status)
1629         {
1630         case HEADER_ITEM_STATUS_NORMAL:
1631                 return _BUTTON_STATUS_NORMAL;
1632                 break;
1633
1634         case HEADER_ITEM_STATUS_DISABLED:
1635                 return _BUTTON_STATUS_DISABLED;
1636                 break;
1637
1638         case HEADER_ITEM_STATUS_PRESSED:
1639                 return _BUTTON_STATUS_PRESSED;
1640                 break;
1641
1642         case HEADER_ITEM_STATUS_HIGHLIGHTED:
1643                 return _BUTTON_STATUS_HIGHLIGHTED;
1644                 break;
1645
1646         case HEADER_ITEM_STATUS_SELECTED:
1647                 return _BUTTON_STATUS_SELECTED;
1648                 break;
1649
1650         default:
1651                 return _BUTTON_STATUS_DISABLED;
1652                 break;
1653         }
1654 }
1655
1656 class _HeaderMaker
1657         : public _UiBuilderControlMaker
1658 {
1659 public:
1660         _HeaderMaker(_UiBuilder* uibuilder)
1661                 : _UiBuilderControlMaker(uibuilder){};
1662         virtual ~_HeaderMaker(){};
1663         static _UiBuilderControlMaker* GetInstance(_UiBuilder* uibuilder)
1664         {
1665                 _HeaderMaker* pHeaderMaker = new (std::nothrow) _HeaderMaker(uibuilder);
1666                 return pHeaderMaker;
1667         };
1668 protected:
1669         virtual Control* Make(_UiBuilderControl* pControl)
1670         {
1671                 Header* pHeader = null;
1672                 String elementString;
1673                 int opacity = 0;
1674                 int numberedBadge = 0;
1675                 Color color;
1676
1677                 //Construct
1678                 HeaderStyle hstyle = HEADER_STYLE_TITLE;
1679                 Form* pForm = static_cast<Form*>(GetContainer());
1680                 pHeader = pForm->GetHeader();
1681
1682                 if (null == pHeader)
1683                 {
1684                         return null;
1685                 }
1686
1687                 if (pControl->GetElement(L"headerStyle", elementString))
1688                 {
1689                         if (elementString.Equals(L"HEADER_STYLE_TITLE", false))
1690                         {
1691                                 hstyle = HEADER_STYLE_TITLE;
1692                         }
1693                         else if (elementString.Equals(L"HEADER_STYLE_SEGMENTED", false))
1694                         {
1695                                 hstyle = HEADER_STYLE_SEGMENTED;
1696                         }
1697                         else if (elementString.Equals(L"HEADER_STYLE_TITLE_BUTTON", false))
1698                         {
1699                                 hstyle = HEADER_STYLE_TITLE_BUTTON;
1700                         }
1701                         else if (elementString.Equals(L"HEADER_STYLE_SEGMENTED_WITH_TITLE", false))
1702                         {
1703                                 hstyle = HEADER_STYLE_SEGMENTED_WITH_TITLE;
1704                         }
1705                         else if (elementString.Equals(L"HEADER_STYLE_TAB", false))
1706                         {
1707                                 hstyle = HEADER_STYLE_TAB;
1708                         }
1709                         else if (elementString.Equals(L"HEADER_STYLE_TAB_WITH_TITLE", false))
1710                         {
1711                                 hstyle = HEADER_STYLE_TAB_WITH_TITLE;
1712                         }
1713                         else if (elementString.Equals(L"HEADER_STYLE_BUTTON", false))
1714                         {
1715                                 hstyle = HEADER_STYLE_BUTTON;
1716                         }
1717                         else if (elementString.Equals(L"HEADER_STYLE_TAB_LARGE", false))
1718                         {
1719                                 hstyle = HEADER_STYLE_TAB_LARGE;
1720                         }
1721
1722                         pHeader->SetStyle(hstyle);
1723                 }
1724
1725                 if (pControl->GetElement(L"backgroundBitmapPath", elementString) || pControl->GetElement(L"BGBitmapPath", elementString))
1726                 {
1727                         Bitmap* pBitmap = null;
1728                         pBitmap = LoadBitmapN(elementString);
1729                         pHeader->SetBackgroundBitmap(pBitmap);
1730                 }
1731
1732                 // header color
1733                 if (pControl->GetElement(L"colorOpacity", elementString))
1734                 {
1735                         Base::Integer::Parse(elementString, opacity);
1736                 }
1737
1738                 if (pControl->GetElement(L"color", elementString))
1739                 {
1740                         ConvertStringToColor32(elementString, opacity, color);
1741                         pHeader->SetColor(color);
1742                 }
1743
1744                 if (HEADER_STYLE_TITLE == hstyle || HEADER_STYLE_SEGMENTED_WITH_TITLE == hstyle || HEADER_STYLE_TAB_WITH_TITLE == hstyle)
1745                 {
1746                         // title
1747                         if (pControl->GetElement(L"titleText", elementString))
1748                         {
1749                                 pHeader->SetTitleText(elementString);
1750                         }
1751
1752                         if (pControl->GetElement(L"titleTextColor", elementString))
1753                         {
1754                                 ConvertStringToColor(elementString, color);
1755                                 result r = pHeader->SetTitleTextColor(color);
1756                                 SysLogException(NID_UI_CTRL, r, "[E_INVALID_STATE] Failed to set title text color");
1757                         }
1758
1759                         if (pControl->GetElement(L"titleIconPath", elementString))
1760                         {
1761                                 Bitmap* pBitmap = null;
1762                                 pBitmap = LoadBitmapN(elementString);
1763                                 result r = pHeader->SetTitleIcon(pBitmap);
1764                                 SysLogException(NID_UI_CTRL, r, "[E_INVALID_STATE] Failed to set an icon");
1765                         }
1766
1767                         if (pControl->GetElement(L"titleBadgeIconPath", elementString))
1768                         {
1769                                 Bitmap* pBitmap = null;
1770                                 pBitmap = LoadBitmapN(elementString);
1771                                 result r = pHeader->SetTitleBadgeIcon(pBitmap);
1772                                 SysLogException(NID_UI_CTRL, r, "[E_INVALID_STATE] Failed to set an icon");
1773                         }
1774
1775                         if (pControl->GetElement(L"titleNumberedBadgeIcon", elementString))
1776                         {
1777                                 Base::Integer::Parse(elementString, numberedBadge);
1778                                 result r = pHeader->SetTitleNumberedBadgeIcon(numberedBadge);
1779                                 SysLogException(NID_UI_CTRL, r, "[E_INVALID_STATE] Failed to set a numbered icon");
1780                         }
1781
1782                         // description
1783                         if (pControl->GetElement(L"descriptionText", elementString))
1784                         {
1785                                 result r = pHeader->SetDescriptionText(elementString);
1786                                 SysLogException(NID_UI_CTRL, r, "[E_INVALID_STATE] Failed to set description text");
1787                         }
1788
1789                         if (pControl->GetElement(L"descriptionTextColor", elementString))
1790                         {
1791                                 ConvertStringToColor(elementString, color);
1792                                 result r = pHeader->SetDescriptionTextColor(color);
1793                                 SysLogException(NID_UI_CTRL, r, "[E_INVALID_STATE] Failed to set description text color");
1794                         }
1795                 }
1796
1797                 if (pControl->GetElement(L"accessibilityHint", elementString))
1798                 {
1799                         AccessibilityContainer* pContainer = pHeader->GetAccessibilityContainer();
1800                         if (pContainer)
1801                         {
1802                                 AccessibilityElement* pElement = pContainer->GetElement(L"HeaderTitleText");
1803                                 if (pElement)
1804                                 {
1805                                         pElement->SetHint(elementString);
1806                                 }
1807                         }
1808                 }
1809
1810                 // normal button
1811                 if (pControl->GetElement(L"normalButtonColorOpacity", elementString))
1812                 {
1813                         Base::Integer::Parse(elementString, opacity);
1814                 }
1815
1816                 if (pControl->GetElement(L"normalButtonColor", elementString))
1817                 {
1818                         ConvertStringToColor32(elementString, opacity, color);
1819                         pHeader->SetButtonColor(BUTTON_ITEM_STATUS_NORMAL, color);
1820                 }
1821
1822                 if (pControl->GetElement(L"normalButtonTextColor", elementString))
1823                 {
1824                         ConvertStringToColor(elementString, color);
1825                         pHeader->SetButtonTextColor(BUTTON_ITEM_STATUS_NORMAL, color);
1826                 }
1827
1828                 // pressed button
1829                 if (pControl->GetElement(L"pressedButtonColorOpacity", elementString))
1830                 {
1831                         Base::Integer::Parse(elementString, opacity);
1832                 }
1833
1834                 if (pControl->GetElement(L"pressedButtonColor", elementString))
1835                 {
1836                         ConvertStringToColor32(elementString, opacity, color);
1837                         pHeader->SetButtonColor(BUTTON_ITEM_STATUS_PRESSED, color);
1838                 }
1839
1840                 if (pControl->GetElement(L"pressedButtonTextColor", elementString))
1841                 {
1842                         ConvertStringToColor(elementString, color);
1843                         pHeader->SetButtonTextColor(BUTTON_ITEM_STATUS_PRESSED, color);
1844                 }
1845
1846                 // highlighted button
1847                 if (pControl->GetElement(L"highlightedButtonColorOpacity", elementString))
1848                 {
1849                         Base::Integer::Parse(elementString, opacity);
1850                 }
1851
1852                 if (pControl->GetElement(L"highlightedButtonColor", elementString))
1853                 {
1854                         ConvertStringToColor32(elementString, opacity, color);
1855                         pHeader->SetButtonColor(BUTTON_ITEM_STATUS_HIGHLIGHTED, color);
1856                 }
1857
1858                 if (pControl->GetElement(L"highlightedButtonTextColor", elementString))
1859                 {
1860                         ConvertStringToColor(elementString, color);
1861                         pHeader->SetButtonTextColor(BUTTON_ITEM_STATUS_HIGHLIGHTED, color);
1862                 }
1863
1864                 // disabled button
1865                 if (pControl->GetElement(L"disabledButtonColorOpacity", elementString))
1866                 {
1867                         Base::Integer::Parse(elementString, opacity);
1868                 }
1869
1870                 if (pControl->GetElement(L"disabledButtonColor", elementString))
1871                 {
1872                         ConvertStringToColor32(elementString, opacity, color);
1873                         pHeader->SetButtonColor(BUTTON_ITEM_STATUS_DISABLED, color);
1874                 }
1875
1876                 if (pControl->GetElement(L"disabledButtonTextColor", elementString))
1877                 {
1878                         ConvertStringToColor(elementString, color);
1879                         pHeader->SetButtonTextColor(BUTTON_ITEM_STATUS_DISABLED, color);
1880                 }
1881
1882                 if (HEADER_STYLE_TITLE != hstyle)
1883                 {
1884                         // normal item
1885                         if (pControl->GetElement(L"normalItemColorOpacity", elementString))
1886                         {
1887                                 Base::Integer::Parse(elementString, opacity);
1888                         }
1889
1890                         if (pControl->GetElement(L"normalItemColor", elementString))
1891                         {
1892                                 ConvertStringToColor32(elementString, opacity, color);
1893                                 pHeader->SetItemColor(HEADER_ITEM_STATUS_NORMAL, color);
1894                         }
1895
1896                         if (pControl->GetElement(L"normalItemTextColor", elementString))
1897                         {
1898                                 ConvertStringToColor(elementString, color);
1899                                 pHeader->SetItemTextColor(HEADER_ITEM_STATUS_NORMAL, color);
1900                         }
1901
1902                         // pressed item
1903                         if (pControl->GetElement(L"pressedItemColorOpacity", elementString))
1904                         {
1905                                 Base::Integer::Parse(elementString, opacity);
1906                         }
1907
1908                         if (pControl->GetElement(L"pressedItemColor", elementString))
1909                         {
1910                                 ConvertStringToColor32(elementString, opacity, color);
1911                                 pHeader->SetItemColor(HEADER_ITEM_STATUS_PRESSED, color);
1912                         }
1913
1914                         if (pControl->GetElement(L"pressedItemTextColor", elementString))
1915                         {
1916                                 ConvertStringToColor(elementString, color);
1917                                 pHeader->SetItemTextColor(HEADER_ITEM_STATUS_PRESSED, color);
1918                         }
1919
1920                         if (hstyle == HEADER_STYLE_SEGMENTED || hstyle == HEADER_STYLE_SEGMENTED_WITH_TITLE
1921                                         || hstyle == HEADER_STYLE_TAB || hstyle == HEADER_STYLE_TAB_WITH_TITLE || hstyle == HEADER_STYLE_TAB_LARGE)
1922                         {
1923                                 // selected item
1924                                 if (pControl->GetElement(L"selectedItemColorOpacity", elementString))
1925                                 {
1926                                         Base::Integer::Parse(elementString, opacity);
1927                                 }
1928
1929                                 if (pControl->GetElement(L"selectedItemColor", elementString))
1930                                 {
1931                                         ConvertStringToColor32(elementString, opacity, color);
1932                                         pHeader->SetItemColor(HEADER_ITEM_STATUS_SELECTED, color);
1933                                 }
1934
1935                                 if (pControl->GetElement(L"selectedItemTextColor", elementString))
1936                                 {
1937                                         ConvertStringToColor(elementString, color);
1938                                         pHeader->SetItemTextColor(HEADER_ITEM_STATUS_SELECTED, color);
1939                                 }
1940                         }
1941
1942                         // highlighted item
1943                         if (pControl->GetElement(L"highlightedItemColorOpacity", elementString))
1944                         {
1945                                 Base::Integer::Parse(elementString, opacity);
1946                         }
1947
1948                         if (pControl->GetElement(L"highlightedItemColor", elementString))
1949                         {
1950                                 ConvertStringToColor32(elementString, opacity, color);
1951                                 pHeader->SetItemColor(HEADER_ITEM_STATUS_HIGHLIGHTED, color);
1952                         }
1953
1954                         if (pControl->GetElement(L"highlightedItemTextColor", elementString))
1955                         {
1956                                 ConvertStringToColor(elementString, color);
1957                                 pHeader->SetItemTextColor(HEADER_ITEM_STATUS_HIGHLIGHTED, color);
1958                         }
1959
1960                         // disabled item
1961                         if (pControl->GetElement(L"disabledItemColorOpacity", elementString))
1962                         {
1963                                 Base::Integer::Parse(elementString, opacity);
1964                         }
1965
1966                         if (pControl->GetElement(L"disabledItemColor", elementString))
1967                         {
1968                                 ConvertStringToColor32(elementString, opacity, color);
1969                                 pHeader->SetItemColor(HEADER_ITEM_STATUS_DISABLED, color);
1970                         }
1971
1972                         if (pControl->GetElement(L"disabledItemTextColor", elementString))
1973                         {
1974                                 ConvertStringToColor(elementString, color);
1975                                 pHeader->SetItemTextColor(HEADER_ITEM_STATUS_DISABLED, color);
1976                         }
1977                 }
1978
1979                 int itemCnt = pControl->GetItemCount();
1980                 ButtonItemStyle buttonItemStyle = BUTTON_ITEM_STYLE_TEXT;
1981                 ButtonPosition buttonPosition = BUTTON_POSITION_LEFT;
1982                 String headerItemString;
1983
1984                 for (int i = 0; i < itemCnt; i++)
1985                 {
1986                         headerItemString = pControl->GetItemName(i);
1987                         if ((HEADER_STYLE_TITLE != hstyle) && (headerItemString.Equals(L"headerItem", false)))
1988                         {
1989                                 HeaderItem headerItem;
1990
1991                                 // get Action Id
1992                                 if (pControl->GetItemElement(i, "actionId", headerItemString))
1993                                 {
1994                                         int actionId;
1995                                         Base::Integer::Parse(headerItemString, actionId);
1996                                         headerItem.Construct(actionId);
1997                                 }
1998
1999                                 // get text
2000                                 if (pControl->GetItemElement(i, "text", headerItemString))
2001                                 {
2002                                         headerItem.SetText(headerItemString);
2003                                 }
2004
2005                                 // headeritem icon bitmap setting
2006                                 // normal
2007                                 if (pControl->GetItemElement(i, "normalIconPath", headerItemString))
2008                                 {
2009                                         Bitmap* pBitmap = null;
2010                                         pBitmap = LoadBitmapN(headerItemString);
2011                                         headerItem.SetIcon(HEADER_ITEM_STATUS_NORMAL, pBitmap);
2012                                 }
2013
2014                                 // pressed
2015                                 if (pControl->GetItemElement(i, "pressedIconPath", headerItemString))
2016                                 {
2017                                         Bitmap* pBitmap = null;
2018                                         pBitmap = LoadBitmapN(headerItemString);
2019                                         headerItem.SetIcon(HEADER_ITEM_STATUS_PRESSED, pBitmap);
2020                                 }
2021
2022                                 // selected
2023                                 if (pControl->GetItemElement(i, "selectedIconPath", headerItemString))
2024                                 {
2025                                         Bitmap* pBitmap = null;
2026                                         pBitmap = LoadBitmapN(headerItemString);
2027                                         headerItem.SetIcon(HEADER_ITEM_STATUS_SELECTED, pBitmap);
2028                                 }
2029
2030                                 // highlighted
2031                                 if (pControl->GetItemElement(i, "highlightedIconPath", headerItemString))
2032                                 {
2033                                         Bitmap* pBitmap = null;
2034                                         pBitmap = LoadBitmapN(headerItemString);
2035                                         headerItem.SetIcon(HEADER_ITEM_STATUS_HIGHLIGHTED, pBitmap);
2036                                 }
2037
2038                                 // disabled
2039                                 if (pControl->GetItemElement(i, "disabledIconPath", headerItemString))
2040                                 {
2041                                         Bitmap* pBitmap = null;
2042                                         pBitmap = LoadBitmapN(headerItemString);
2043                                         headerItem.SetIcon(HEADER_ITEM_STATUS_DISABLED, pBitmap);
2044                                 }
2045
2046                                 // headeritem background bitmap path setting
2047                                 // normal bg bitmap
2048                                 if (pControl->GetItemElement(i, "normalBGBitmapPath", headerItemString))
2049                                 {
2050                                         Bitmap* pBitmap = null;
2051                                         pBitmap = LoadBitmapN(headerItemString);
2052                                         headerItem.SetBackgroundBitmap(HEADER_ITEM_STATUS_NORMAL, pBitmap);
2053                                 }
2054
2055                                 // pressed bg bitmap
2056                                 if (pControl->GetItemElement(i, "pressedBGBitmapPath", headerItemString))
2057                                 {
2058                                         Bitmap* pBitmap = null;
2059                                         pBitmap = LoadBitmapN(headerItemString);
2060                                         headerItem.SetBackgroundBitmap(HEADER_ITEM_STATUS_PRESSED, pBitmap);
2061                                 }
2062
2063                                 // selected bg bitmap
2064                                 if (pControl->GetItemElement(i, "selectedBGBitmapPath", headerItemString))
2065                                 {
2066                                         Bitmap* pBitmap = null;
2067                                         pBitmap = LoadBitmapN(headerItemString);
2068                                         headerItem.SetBackgroundBitmap(HEADER_ITEM_STATUS_SELECTED, pBitmap);
2069                                 }
2070
2071                                 // highlighted bg bitmap
2072                                 if (pControl->GetItemElement(i, "highlightedBGBitmapPath", headerItemString))
2073                                 {
2074                                         Bitmap* pBitmap = null;
2075                                         pBitmap = LoadBitmapN(headerItemString);
2076                                         headerItem.SetBackgroundBitmap(HEADER_ITEM_STATUS_HIGHLIGHTED, pBitmap);
2077                                 }
2078
2079                                 // disabled bg bitmap
2080                                 if (pControl->GetItemElement(i, "disabledBGBitmapPath", headerItemString))
2081                                 {
2082                                         Bitmap* pBitmap = null;
2083                                         pBitmap = LoadBitmapN(headerItemString);
2084                                         headerItem.SetBackgroundBitmap(HEADER_ITEM_STATUS_DISABLED, pBitmap);
2085                                 }
2086
2087                                 if (pControl->GetItemElement(i, L"accessibilityHint", elementString))
2088                                 {
2089                                         _HeaderItemImpl::GetInstance(headerItem)->SetAccessibilityHint(elementString);
2090                                 }
2091
2092                                 pHeader->AddItem(headerItem);
2093
2094                                 if (pControl->GetItemElement(i, "headerItemBadgeIconPath", headerItemString))
2095                                 {
2096                                         Bitmap* pBitmap = null;
2097                                         pBitmap = LoadBitmapN(headerItemString);
2098                                         result r = pHeader->SetItemBadgeIcon(i, pBitmap);
2099                                         SysLogException(NID_UI_CTRL, r, "[E_INVALID_STATE] Failed to set an icon");
2100                                 }
2101
2102                                 if (pControl->GetItemElement(i, "headerItemNumberedBadgeIcon", headerItemString))
2103                                 {
2104                                         Base::Integer::Parse(headerItemString, numberedBadge);
2105                                         result r = pHeader->SetItemNumberedBadgeIcon(i, numberedBadge);
2106                                         SysLogException(NID_UI_CTRL, r, "[E_INVALID_STATE] Failed to set a numbered icon");
2107                                 }
2108                         }
2109                         else if (headerItemString.Equals(L"buttonItem", false))
2110                         {
2111                                 ButtonItem buttonItem;
2112
2113                                 // set button style
2114                                 if (pControl->GetItemElement(i, "style", headerItemString))
2115                                 {
2116                                         if (headerItemString.Equals(L"BUTTON_ITEM_STYLE_TEXT", false))
2117                                         {
2118                                                 buttonItemStyle = BUTTON_ITEM_STYLE_TEXT;
2119                                         }
2120                                         else if (headerItemString.Equals(L"BUTTON_ITEM_STYLE_ICON", false))
2121                                         {
2122                                                 buttonItemStyle = BUTTON_ITEM_STYLE_ICON;
2123                                         }
2124                                 }
2125
2126                                 // set button position
2127                                 if (pControl->GetItemElement(i, "position", headerItemString))
2128                                 {
2129                                         if (headerItemString.Equals(L"BUTTON_POSITION_LEFT", false))
2130                                         {
2131                                                 buttonPosition = BUTTON_POSITION_LEFT;
2132                                         }
2133                                         else if (headerItemString.Equals(L"BUTTON_POSITION_RIGHT", false))
2134                                         {
2135                                                 buttonPosition = BUTTON_POSITION_RIGHT;
2136                                         }
2137                                 }
2138
2139                                 if (pControl->GetItemElement(i, "actionId", headerItemString))
2140                                 {
2141                                         int actionId;
2142                                         Base::Integer::Parse(headerItemString, actionId);
2143                                         buttonItem.Construct(buttonItemStyle, actionId);
2144                                 }
2145
2146                                 if (pControl->GetItemElement(i, "text", headerItemString))
2147                                 {
2148                                         buttonItem.SetText(headerItemString);
2149                                 }
2150
2151                                 // buttonitem background bitmap path setting
2152                                 // normal bg bitmap
2153                                 if (pControl->GetItemElement(i, "normalBGBitmapPath", headerItemString))
2154                                 {
2155                                         Bitmap* pBitmap = null;
2156                                         pBitmap = LoadBitmapN(headerItemString);
2157                                         buttonItem.SetBackgroundBitmap(BUTTON_ITEM_STATUS_NORMAL, pBitmap);
2158                                 }
2159
2160                                 // pressed bg bitmap
2161                                 if (pControl->GetItemElement(i, "pressedBGBitmapPath", headerItemString))
2162                                 {
2163                                         Bitmap* pBitmap = null;
2164                                         pBitmap = LoadBitmapN(headerItemString);
2165                                         buttonItem.SetBackgroundBitmap(BUTTON_ITEM_STATUS_PRESSED, pBitmap);
2166                                 }
2167
2168                                 // highlighted bg bitmap
2169                                 if (pControl->GetItemElement(i, "highlightedBGBitmapPath", headerItemString))
2170                                 {
2171                                         Bitmap* pBitmap = null;
2172                                         pBitmap = LoadBitmapN(headerItemString);
2173                                         buttonItem.SetBackgroundBitmap(BUTTON_ITEM_STATUS_HIGHLIGHTED, pBitmap);
2174                                 }
2175
2176                                 // disabled bg bitmap
2177                                 if (pControl->GetItemElement(i, "disabledBGBitmapPath", headerItemString))
2178                                 {
2179                                         Bitmap* pBitmap = null;
2180                                         pBitmap = LoadBitmapN(headerItemString);
2181                                         buttonItem.SetBackgroundBitmap(BUTTON_ITEM_STATUS_DISABLED, pBitmap);
2182                                 }
2183
2184                                 // buttonitem icon bitmap setting
2185                                 if (pControl->GetItemElement(i, "normalIconPath", headerItemString))
2186                                 {
2187                                         Bitmap* pBitmap = null;
2188                                         pBitmap = LoadBitmapN(headerItemString);
2189                                         buttonItem.SetIcon(BUTTON_ITEM_STATUS_NORMAL, pBitmap);
2190                                 }
2191
2192                                 if (pControl->GetItemElement(i, "pressedIconPath", headerItemString))
2193                                 {
2194                                         Bitmap* pBitmap = null;
2195                                         pBitmap = LoadBitmapN(headerItemString);
2196                                         buttonItem.SetIcon(BUTTON_ITEM_STATUS_PRESSED, pBitmap);
2197                                 }
2198
2199                                 if (pControl->GetItemElement(i, "highlightedIconPath", headerItemString))
2200                                 {
2201                                         Bitmap* pBitmap = null;
2202                                         pBitmap = LoadBitmapN(headerItemString);
2203                                         buttonItem.SetIcon(BUTTON_ITEM_STATUS_HIGHLIGHTED, pBitmap);
2204                                 }
2205
2206                                 if (pControl->GetItemElement(i, "disabledIconPath", headerItemString))
2207                                 {
2208                                         Bitmap* pBitmap = null;
2209                                         pBitmap = LoadBitmapN(headerItemString);
2210                                         buttonItem.SetIcon(BUTTON_ITEM_STATUS_DISABLED, pBitmap);
2211                                 }
2212
2213                                 if (pControl->GetItemElement(i, L"accessibilityHint", elementString))
2214                                 {
2215                                         _ButtonItemImpl::GetInstance(buttonItem)->SetAccessibilityHint(elementString);
2216                                 }
2217                                 pHeader->SetButton(buttonPosition, buttonItem);
2218
2219                                 if (pControl->GetItemElement(i, "buttonItemBadgeIconPath", headerItemString))
2220                                 {
2221                                         Bitmap* pBitmap = null;
2222                                         pBitmap = LoadBitmapN(headerItemString);
2223                                         result r = pHeader->SetButtonBadgeIcon(buttonPosition, pBitmap);
2224                                         SysLogException(NID_UI_CTRL, r, "[E_INVALID_STATE] Failed to set an icon");
2225                                 }
2226
2227                                 if (pControl->GetItemElement(i, "buttonItemNumberedBadgeIcon", headerItemString))
2228                                 {
2229                                         Base::Integer::Parse(headerItemString, numberedBadge);
2230                                         result r = pHeader->SetButtonNumberedBadgeIcon(buttonPosition, numberedBadge);
2231                                         SysLogException(NID_UI_CTRL, r, "[E_INVALID_STATE] Failed to set a numbered icon");
2232                                 }
2233                         }
2234
2235                 }
2236
2237                 return pHeader;
2238         }
2239
2240 private:
2241
2242 };
2243
2244 _HeaderRegister::_HeaderRegister()
2245 {
2246           _UiBuilderControlTableManager* pUiBuilderControlTableManager = _UiBuilderControlTableManager::GetInstance();
2247           pUiBuilderControlTableManager->RegisterControl(L"Header", _HeaderMaker::GetInstance);
2248 }
2249
2250 _HeaderRegister::~_HeaderRegister()
2251 {
2252           _UiBuilderControlTableManager* pUiBuilderControlTableManager = _UiBuilderControlTableManager::GetInstance();
2253           pUiBuilderControlTableManager->UnregisterControl(L"Header");
2254 }
2255
2256 static _HeaderRegister HeaderRegisterToUiBuilder;
2257
2258 }}} // Tizen::Ui::Controls