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