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