src/ui/controls/FUiCtrl_FooterImpl.cpp

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