src/ui/controls/FUiCtrl_HeaderImpl.cpp

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