src/ui/controls/FUiCtrl_FormImpl.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 #include <app.h>
  19 #include <new>
  20 #include <FUiControls.h>
  21 #include <FBaseInteger.h>
  22 #include <FBaseColLinkedListT.h>
  23 #include <FUiCtrlHeader.h>
  24 #include <FUiCtrlFooter.h>
  25 #include <FUiCtrlTab.h>
  26 #include <FUiLayout.h>
  27 #include <FBaseSysLog.h>
  28 #include <FApp_AppInfo.h>
  29 #include <FGrpFloatRectangle.h>
  30 #include "FUi_LayoutImpl.h"
  31 #include "FUi_LayoutLayoutMaker.h"
  32 #include "FUi_EcoreEvasMgr.h"
  33 #include "FUi_EcoreEvas.h"
  34 #include "FUi_ControlImplManager.h"
  35 #include "FUi_OrientationAgent.h"
  36 #include "FUi_ImeOrientationAgent.h"
  37 #include "FUi_UiBuilder.h"
  38 #include "FUi_CoordinateSystemUtils.h"
  39 #include "FUi_DataBindingContextImpl.h"
  40 #include "FUi_ResourceSizeInfo.h"
  41 #include "FUi_ResourceManager.h"
  42 #include "FUiAnim_VisualElement.h"
  43 #include "FUiCtrl_FormImpl.h"
  44 #include "FUiCtrl_HeaderImpl.h"
  45 #include "FUiCtrl_FooterImpl.h"
  46 #include "FUiCtrl_Form.h"
  47 #include "FUiCtrl_Frame.h"
  48 #include "FUiCtrl_FrameImpl.h"
  49 #include "FUiCtrl_TabImpl.h"
  50 #include "FUiCtrl_Indicator.h"
  51
  52 using namespace Tizen::App;
  53 using namespace Tizen::Base;
  54 using namespace Tizen::Base::Runtime;
  55 using namespace Tizen::Base::Collection;
  56 using namespace Tizen::Graphics;
  57 using namespace Tizen::Ui;
  58 using namespace Tizen::Ui::Animations;
  59
  60 #define OPTIONKEY       SOFTKEY_COUNT
  61
  62 namespace Tizen { namespace Ui { namespace Controls
  63 {
  64
  65 const String _REQUEST_ORIENTATION_EVENT = L"RequestOrientationEvent";
  66
  67 Dimension
  68 _FormImpl::FormSizeInfo::GetDefaultMinimumSize(_ControlOrientation orientation) const
  69 {
  70         result r = E_SUCCESS;
  71         Dimension dimension(0, 0);
  72         SetLastResult(r);
  73
  74         return dimension;
  75 }
  76
  77 FloatDimension
  78 _FormImpl::FormSizeInfo::GetDefaultMinimumSizeF(_ControlOrientation orientation) const
  79 {
  80         result r = E_SUCCESS;
  81         FloatDimension dimension(0.0f, 0.0f);
  82         SetLastResult(r);
  83
  84         return dimension;
  85 }
  86
  87 const _FormImpl*
  88 _FormImpl::GetInstance(const Form& form)
  89 {
  90         return static_cast<const _FormImpl*> (form._pControlImpl);
  91 }
  92
  93 _FormImpl*
  94 _FormImpl::GetInstance(Form& form)
  95 {
  96         return static_cast<_FormImpl*> (form._pControlImpl);
  97 }
  98
  99 _FormImpl::_FormImpl(Form* pPublic, _Form* pCore, Layout* pPublicPortraitLayout, Layout* pPublicLandscapeLayout)
 100         : _ContainerImpl(pPublic, pCore, pPublicPortraitLayout, pPublicLandscapeLayout)
 101         , __pForm(null)
 102         , __pFormBackEventListener(null)
 103         , __pFormMenuEventListener(null)
 104         , __pOriAgent(null)
 105         , __pImeOriAgent(null)
 106         , __pLeftSoftkeyActionEvent(null)
 107         , __pRightSoftkeyActionEvent(null)
 108         , __pOptionMenuActionEvent(null)
 109 {
 110         __pForm = pCore;
 111
 112         int appType = _AppInfo::GetAppType();
 113         if (appType & _APP_TYPE_IME_APP)
 114         {
 115                 __pImeOriAgent = _ImeOrientationAgent::CreateInstanceN(*pPublic);
 116                 SysTryReturnVoidResult(NID_UI_CTRL, __pImeOriAgent != null, GetLastResult(), "[%s] Propagating.", GetErrorMessage(GetLastResult()));
 117         }
 118         else
 119         {
 120                 __pOriAgent = _OrientationAgent::CreateInstanceN(*pPublic);
 121                 SysTryReturnVoidResult(NID_UI_CTRL, __pOriAgent != null, GetLastResult(), "[%s] Propagating.", GetErrorMessage(GetLastResult()));
 122         }
 123 }
 124
 125 _FormImpl::~_FormImpl(void)
 126 {
 127         if (__pImeOriAgent)
 128         {
 129                 delete __pImeOriAgent;
 130                 __pImeOriAgent = null;
 131         }
 132
 133         if (__pOriAgent)
 134         {
 135                 delete __pOriAgent;
 136                 __pOriAgent = null;
 137         }
 138
 139         if (__pLeftSoftkeyActionEvent)
 140         {
 141                 delete __pLeftSoftkeyActionEvent;
 142                 __pLeftSoftkeyActionEvent = null;
 143         }
 144
 145         if (__pRightSoftkeyActionEvent)
 146         {
 147                 delete __pRightSoftkeyActionEvent;
 148                 __pRightSoftkeyActionEvent = null;
 149         }
 150
 151         if (__pOptionMenuActionEvent)
 152         {
 153                 delete __pOptionMenuActionEvent;
 154                 __pOptionMenuActionEvent = null;
 155         }
 156
 157         __leftSoftkeyActionList.RemoveAll(false);
 158         __rightSoftkeyActionList.RemoveAll(false);
 159
 160         RemoveHeader();
 161         RemoveFooter();
 162         RemoveTabImpl();
 163
 164         __pForm = null;
 165
 166         ClearLastResult();
 167 }
 168
 169 _FormImpl*
 170 _FormImpl::CreateFormImplN(Form* pControl, Layout* pPublicPortraitLayout, Layout* pPublicLandscapeLayout)
 171 {
 172         result r = E_SUCCESS;
 173         _VisualElement* pVisualElement = null;
 174
 175         _Form* pCore = _Form::CreateFormN();
 176         r = GetLastResult();
 177         SysTryReturn(NID_UI_CTRL, pCore, null, r, "[%s] Propagating.", GetErrorMessage(r)); // [ToDo] interpret last result.
 178
 179         _FormImpl* pImpl = new (std::nothrow) _FormImpl(pControl, pCore, pPublicPortraitLayout, pPublicLandscapeLayout);
 180
 181         r = _ControlImpl::CheckConstruction(pCore, pImpl);
 182         SysTryReturn(NID_UI_CTRL, r == E_SUCCESS, null, r, "[%s] Propagating.", GetErrorMessage(r));
 183
 184         const FloatDimension portraitSize = _ControlManager::GetInstance()->_ControlManager::GetScreenSizeF();
 185         const FloatDimension landscapeSize = FloatDimension(portraitSize.height, portraitSize.width);
 186
 187         _ControlOrientation orientation = pCore->GetOrientation();
 188
 189         if (orientation == _CONTROL_ORIENTATION_PORTRAIT)
 190         {
 191                 r = pImpl->InitializeBoundsPropertiesF(GET_SIZE_INFO(Form), portraitSize, orientation);
 192         }
 193         else
 194         {
 195                 r = pImpl->InitializeBoundsPropertiesF(GET_SIZE_INFO(Form), landscapeSize, orientation);
 196         }
 197         SysAssert(r == E_SUCCESS);
 198
 199         pCore->SetFormOrientationStatusEventListener(pImpl);
 200
 201         // Make surface opaque.
 202         pVisualElement = pCore->GetVisualElement();
 203         SysTryCatch(NID_UI_CTRL, pVisualElement, , GetLastResult(), "[%s] Propagating.", GetErrorMessage(GetLastResult()));
 204         r = pVisualElement->SetSurfaceOpaque(true);
 205         SysTryCatch(NID_UI_CTRL, r == E_SUCCESS, , r, "[%s] Propagating.", GetErrorMessage(r)); // [ToDo] interpret last result.
 206
 207         SetLastResult(E_SUCCESS);
 208
 209         return pImpl;
 210
 211 CATCH:
 212         delete pCore;
 213         delete pImpl;
 214
 215         return null;
 216 }
 217
 218 const char*
 219 _FormImpl::GetPublicClassName(void) const
 220 {
 221         return "Tizen::Ui::Controls::Form";
 222 }
 223
 224 const Form&
 225 _FormImpl::GetPublic(void) const
 226 {
 227         return static_cast<const Form&>(_ControlImpl::GetPublic());
 228 }
 229
 230 Form&
 231 _FormImpl::GetPublic(void)
 232 {
 233         return static_cast<Form&>(_ControlImpl::GetPublic());
 234 }
 235
 236 const _Form&
 237 _FormImpl::GetCore(void) const
 238 {
 239         return static_cast<const _Form&>(_ControlImpl::GetCore());
 240 }
 241
 242 _Form&
 243 _FormImpl::GetCore(void)
 244 {
 245         return static_cast<_Form&>(_ControlImpl::GetCore());
 246 }
 247
 248 _ControlImpl*
 249 _FormImpl::GetFocusControl(void)
 250 {
 251         return null;
 252 }
 253
 254 unsigned long
 255 _FormImpl::GetFormStyle(void) const
 256 {
 257         return GetCore().GetFormStyle();
 258 }
 259
 260 bool
 261 _FormImpl::HasIndicator(void) const
 262 {
 263         return GetCore().HasIndicator();
 264 }
 265
 266 void
 267 _FormImpl::SetFormStyle(unsigned long formStyle)
 268 {
 269         result r = E_SUCCESS;
 270
 271         _HeaderImpl* pHeader = GetHeader();
 272         _FooterImpl* pFooter = GetFooter();
 273         _TabImpl* pTabImpl = GetTabImpl();
 274
 275         if (IsAttachedToMainTree())
 276         {
 277                 if (FORM_STYLE_INDICATOR & formStyle)
 278                 {
 279                         _Frame* pFrame = dynamic_cast<_Frame*>(GetCore().GetParent());
 280                         SysTryReturnVoidResult(NID_UI_CTRL, pFrame != null, E_INVALID_ARG, "A Form which has FORM_STYLE_INDICATOR style cannot be added to a container except Frame.");
 281                 }
 282         }
 283
 284         if ((formStyle & FORM_STYLE_INDICATOR) && (formStyle & FORM_STYLE_INDICATOR_AUTO_HIDE))
 285         {
 286                 SysLogException(NID_UI_CTRL, E_INVALID_ARG, "[E_INVALID_ARG] Invalid form style. FORM_STYLE_INDICATOR and FORM_STYLE_INDICATOR_AUTO_HIDE can't use each other.");
 287                 return;
 288         }
 289
 290         // check formstyle
 291         if (((formStyle & FORM_STYLE_TITLE) || (formStyle & FORM_STYLE_TEXT_TAB) || (formStyle & FORM_STYLE_ICON_TAB)) && (formStyle & FORM_STYLE_HEADER))
 292         {
 293                 SysLogException(NID_UI_CTRL, E_INVALID_ARG, "[E_INVALID_ARG] Invalid form style. FORM_STYLE_TITLE, FORM_STYLE_TEXT_TAB or FORM_STYLE_ICON_TAB and FORM_STYLE_HEADER can't use each other.");
 294
 295                 // remove Header
 296                 if (pHeader)
 297                 {
 298                         RemoveHeader();
 299                         r = GetLastResult();
 300                         SysTryReturnVoidResult(NID_UI_CTRL, r == E_SUCCESS, r, "[%s] Propagating.", GetErrorMessage(r));
 301                 }
 302
 303                 return;
 304         }
 305
 306         if (((formStyle & FORM_STYLE_SOFTKEY_0) || (formStyle & FORM_STYLE_SOFTKEY_1) || (formStyle & FORM_STYLE_OPTIONKEY)) && (formStyle & FORM_STYLE_FOOTER))
 307         {
 308                 SysLogException(NID_UI_CTRL, E_INVALID_ARG, "[E_INVALID_ARG] Invalid form style. FORM_STYLE_SOFTKEY0, FORM_STYLE_SOFTKEY_1 or FORM_STYLE_OPTIONKEY and FORM_STYLE_FOOTER can't use each other.");
 309
 310                 // remove Footer
 311                 if (pFooter)
 312                 {
 313                         RemoveFooter();
 314                         r = GetLastResult();
 315                         SysTryReturnVoidResult(NID_UI_CTRL, r == E_SUCCESS, r, "[%s] Propagating.", GetErrorMessage(r));
 316                 }
 317                 return;
 318         }
 319
 320         _EcoreEvas* pEcoreEvas = GetEcoreEvasMgr()->GetEcoreEvas();
 321         SysTryReturnVoidResult(NID_UI_CTRL, pEcoreEvas, E_SYSTEM, "[E_SYSTEM] Unable to get evas.");
 322
 323         GetCore().SetFormStyle(formStyle);
 324
 325         FloatRectangle indicatorBounds(0.0f, 0.0f, 0.0f, 0.0f);
 326
 327         if (FORM_STYLE_INDICATOR & formStyle)
 328         {
 329                 GetCore().SetIndicatorShowState(true);
 330                 indicatorBounds = GetCore().GetIndicatorBoundsF();
 331                 GetCore().SetIndicatorAutoHide(false);
 332                 r = GetLastResult();
 333                 SysTryReturnVoidResult(NID_UI_CTRL, r == E_SUCCESS, r, "[%s] Propagating.", GetErrorMessage(r));
 334
 335         }
 336         else if(FORM_STYLE_INDICATOR_AUTO_HIDE & formStyle)
 337         {
 338                 r = GetCore().SetIndicatorShowState(true);
 339                 GetCore().SetIndicatorAutoHide(true);
 340                 SysTryReturnVoidResult(NID_UI_CTRL, r == E_SUCCESS, r, "[%s] Propagating.", GetErrorMessage(r));
 341         }
 342         else
 343         {
 344                 r = GetCore().SetIndicatorShowState(false);
 345                 GetCore().SetIndicatorAutoHide(false);
 346                 SysTryReturnVoidResult(NID_UI_CTRL, r == E_SUCCESS, r, "[%s] Propagating.", GetErrorMessage(r));
 347         }
 348
 349         if (formStyle & FORM_STYLE_HEADER)
 350         {
 351                 if (!pHeader)
 352                 {
 353                         pHeader = CreateHeaderN();
 354                         SysTryReturnVoidResult(NID_UI_CTRL, pHeader != null, r, "[%s] Propagating.", GetErrorMessage(r));
 355
 356                         GetCore().SetHeader(&pHeader->GetCore());
 357                         GetCore().AdjustClientBounds();
 358
 359                         if (GetCore().IsIndicatorTranslucent())
 360                         {
 361                                 if (!GetCore().IsHeaderTranslucent())
 362                                 {
 363                                         indicatorBounds.height = 0.0f;
 364                                 }
 365                                 else
 366                                 {
 367                                         if (GetOrientation() == _CONTROL_ORIENTATION_LANDSCAPE)
 368                                         {
 369                                                 indicatorBounds.height = 0.0f;
 370                                         }
 371                                 }
 372                         }
 373
 374                         FloatRectangle bounds(0.0f, indicatorBounds.height, GetClientBoundsF().width, GetCore().GetToolbarHeightF(true));
 375                         GetCore().SetHeaderBounds(bounds);
 376
 377                         r = GetCore().AttachSystemChild(pHeader->GetCore());
 378                         SysTryReturnVoidResult(NID_UI_CTRL, r == E_SUCCESS, r, "[%s] Propagating.", GetErrorMessage(r));
 379
 380                         GetCore().SetFormBackEventListener(this);
 381                 }
 382         }
 383         else if (formStyle & FORM_STYLE_TITLE)
 384         {
 385                 if (!pHeader)
 386                 {
 387                         pHeader = CreateHeaderN();
 388                         SysTryReturnVoidResult(NID_UI_CTRL, pHeader != null, r, "[%s] Propagating.", GetErrorMessage(r));
 389
 390                         GetCore().SetHeader(&pHeader->GetCore());
 391                         GetCore().AdjustClientBounds();
 392
 393                         FloatRectangle bounds(0.0f, indicatorBounds.height, GetClientBoundsF().width, GetCore().GetToolbarHeightF(true));
 394                         GetCore().SetHeaderBounds(bounds);
 395
 396                         r = GetCore().AttachSystemChild(pHeader->GetCore());
 397                         SysTryReturnVoidResult(NID_UI_CTRL, r == E_SUCCESS, r, "[%s] Propagating.", GetErrorMessage(r));
 398                 }
 399         }
 400         else
 401         {
 402                 // remove Header
 403                 if (pHeader)
 404                 {
 405                         RemoveHeader();
 406                         r = GetLastResult();
 407                         SysTryReturnVoidResult(NID_UI_CTRL, r == E_SUCCESS, r, "[%s] Propagating.", GetErrorMessage(r));
 408                 }
 409         }
 410
 411         if (formStyle & FORM_STYLE_TEXT_TAB)
 412         {
 413                 float titleHeight = 0.0f;
 414
 415                 if (formStyle & FORM_STYLE_TITLE)
 416                 {
 417                         if (pHeader)
 418                         {
 419                                 titleHeight = pHeader->GetBoundsF().height;
 420                         }
 421                 }
 422
 423                 if (!pTabImpl)
 424                 {
 425                         pTabImpl = CreateTabImplN();
 426                         SysTryReturnVoidResult(NID_UI_CTRL, pTabImpl != null, r, "[%s] Propagating.", GetErrorMessage(r));
 427
 428                         float posY = indicatorBounds.height + titleHeight;
 429
 430                         GetCore().SetTab(&pTabImpl->GetCore());
 431                         GetCore().AdjustClientBounds();
 432
 433                         FloatRectangle bounds(0.0f, posY, GetClientBoundsF().width, GetCore().GetTabHeightF());
 434                         GetCore().SetTabBounds(bounds);
 435
 436                         r = GetCore().AttachSystemChild(pTabImpl->GetCore());
 437                         SysTryReturnVoidResult(NID_UI_CTRL, r == E_SUCCESS, r, "[%s] Propagating.", GetErrorMessage(r));
 438                 }
 439                 GetCore().SetTabStyle(_TAB_STYLE_TEXT);
 440         }
 441         else if (formStyle & FORM_STYLE_ICON_TAB)
 442         {
 443                 float titleHeight = 0.0f;
 444
 445                 if (formStyle & FORM_STYLE_TITLE)
 446                 {
 447                         if (pHeader)
 448                         {
 449                                 titleHeight = pHeader->GetBoundsF().height;
 450                         }
 451                 }
 452
 453                 if (!pTabImpl)
 454                 {
 455                         pTabImpl = CreateTabImplN();
 456                         SysTryReturnVoidResult(NID_UI_CTRL, pTabImpl != null, r, "[%s] Propagating.", GetErrorMessage(r));
 457
 458                         float posY = indicatorBounds.height + titleHeight;
 459
 460                         GetCore().SetTab(&pTabImpl->GetCore());
 461                         GetCore().AdjustClientBounds();
 462
 463                         FloatRectangle bounds(0.0f, posY, GetClientBoundsF().width, GetCore().GetTabHeightF());
 464                         GetCore().SetTabBounds(bounds);
 465
 466                         r = GetCore().AttachSystemChild(pTabImpl->GetCore());
 467                         SysTryReturnVoidResult(NID_UI_CTRL, r == E_SUCCESS, r, "[%s] Propagating.", GetErrorMessage(r));
 468                 }
 469                 GetCore().SetTabStyle(_TAB_STYLE_ICON);
 470         }
 471         else
 472         {
 473                 if (pTabImpl)
 474                 {
 475                         RemoveTabImpl();
 476                         r = GetLastResult();
 477                         SysTryReturnVoidResult(NID_UI_CTRL, r == E_SUCCESS, r, "[%s] Propagating.", GetErrorMessage(r));
 478                 }
 479         }
 480
 481         if (formStyle & FORM_STYLE_FOOTER)
 482         {
 483                 if (!pFooter)
 484                 {
 485                         pFooter = CreateFooterN();
 486                         SysTryReturnVoidResult(NID_UI_CTRL, pFooter != null, r, "[%s] Propagating.", GetErrorMessage(r));
 487
 488                         GetCore().SetFooter(&pFooter->GetCore());
 489                         GetCore().AdjustClientBounds();
 490
 491                         FloatRectangle clientbounds = GetClientBoundsF();
 492                         FloatRectangle bounds(0.0f, clientbounds.y + clientbounds.height, clientbounds.width, GetCore().GetToolbarHeightF(false));
 493
 494                         GetCore().SetFooterBounds(bounds);
 495
 496                         r = GetCore().AttachSystemChild(pFooter->GetCore());
 497                         SysTryReturnVoidResult(NID_UI_CTRL, r == E_SUCCESS, r, "[%s] Propagating.", GetErrorMessage(r));
 498
 499                         GetCore().SetFormBackEventListener(this);
 500                         GetCore().SetFormMenuEventListener(this);
 501                 }
 502         }
 503         else if (formStyle & FORM_STYLE_SOFTKEY_0 || formStyle & FORM_STYLE_SOFTKEY_1 || formStyle & FORM_STYLE_OPTIONKEY)
 504         {
 505                 if (pFooter)
 506                 {
 507                         RemoveFooter();
 508                         r = GetLastResult();
 509                         SysTryReturnVoidResult(NID_UI_CTRL, r == E_SUCCESS, r, "[%s] Propagating.", GetErrorMessage(r));
 510                 }
 511
 512                 pFooter = GetFooter();
 513
 514                 if (!pFooter)
 515                 {
 516                         pFooter = CreateFooterN();
 517                         SysTryReturnVoidResult(NID_UI_CTRL, pFooter != null, r, "[%s] Propagating.", GetErrorMessage(r));
 518
 519                         GetCore().SetFooter(&pFooter->GetCore());
 520                         GetCore().AdjustClientBounds();
 521
 522                         FloatRectangle clientbounds = GetClientBoundsF();
 523                         FloatRectangle bounds(0.0f, clientbounds.y + clientbounds.height - GetCore().GetToolbarHeightF(false), clientbounds.width, GetCore().GetToolbarHeightF(false));
 524
 525                         GetCore().SetFooterBounds(bounds);
 526
 527                         r = GetCore().AttachSystemChild(pFooter->GetCore());
 528                         SysTryReturnVoidResult(NID_UI_CTRL, r == E_SUCCESS, r, "[%s] Propagating.", GetErrorMessage(r));
 529
 530                         GetCore().CreateSoftkey(formStyle);
 531
 532                         pFooter->GetCore().AddActionEventListener(*this);
 533                 }
 534         }
 535         else
 536         {
 537                 // remove Footer
 538                 if (pFooter)
 539                 {
 540                         RemoveFooter();
 541                         r = GetLastResult();
 542                         SysTryReturnVoidResult(NID_UI_CTRL, r == E_SUCCESS, r, "[%s] Propagating.", GetErrorMessage(r));
 543                         GetCore().AdjustClientBounds();
 544                 }
 545         }
 546
 547         GetCore().AdjustClientBounds();
 548
 549         SetLastResult(E_SUCCESS);
 550
 551         return;
 552 }
 553
 554 _FooterImpl*
 555 _FormImpl::GetFooter(void) const
 556 {
 557         _Toolbar* pToolbar = __pForm->GetFooter();
 558         if (pToolbar == null)
 559         {
 560                 return null;
 561         }
 562
 563         _FooterImpl* pFooterImpl = static_cast<_FooterImpl*>(pToolbar->GetUserData());
 564
 565         return pFooterImpl;
 566 }
 567
 568 _HeaderImpl*
 569 _FormImpl::GetHeader(void) const
 570 {
 571         _Toolbar* pToolbar = __pForm->GetHeader();
 572         if (pToolbar == null)
 573         {
 574                 return null;
 575         }
 576
 577         _HeaderImpl* pHeaderImpl = static_cast<_HeaderImpl*>(pToolbar->GetUserData());
 578
 579         return pHeaderImpl;
 580 }
 581
 582 // Ki-Dong,Hong.Temp
 583 _TabImpl*
 584 _FormImpl::GetTabImpl(void) const
 585 {
 586         _Tab* pTab = __pForm->GetTab();
 587         if (pTab == null)
 588         {
 589                 return null;
 590         }
 591
 592         _TabImpl* pTabImpl = static_cast<_TabImpl*>(pTab->GetUserData());
 593
 594         return pTabImpl;
 595 }
 596
 597 String
 598 _FormImpl::GetTitleText(void) const
 599 {
 600         return GetCore().GetTitleText();
 601 }
 602
 603 HorizontalAlignment
 604 _FormImpl::GetTitleTextHorizontalAlignment(void) const
 605 {
 606         return GetCore().GetTitleTextHorizontalAlignment();
 607 }
 608
 609 bool
 610 _FormImpl::HasFooter(void) const
 611 {
 612         return GetCore().HasFooter();
 613 }
 614
 615 bool
 616 _FormImpl::HasHeader(void) const
 617 {
 618         return GetCore().HasHeader();
 619 }
 620
 621 bool
 622 _FormImpl::HasTitle(void) const
 623 {
 624         return GetCore().HasTitle();
 625 }
 626
 627 bool
 628 _FormImpl::HasTab(void) const
 629 {
 630         return GetCore().HasTab();
 631 }
 632
 633 bool
 634 _FormImpl::IsIndicatorVisible(void) const
 635 {
 636         return GetCore().IsIndicatorVisible();
 637 }
 638
 639 bool
 640 _FormImpl::IsHeaderVisible(void) const
 641 {
 642         return GetCore().IsHeaderVisible();
 643 }
 644
 645 bool
 646 _FormImpl::IsFooterVisible(void) const
 647 {
 648         return GetCore().IsFooterVisible();
 649 }
 650
 651 bool
 652 _FormImpl::IsIndicatorTranslucent(void) const
 653 {
 654         return GetCore().IsIndicatorTranslucent();
 655 }
 656
 657 bool
 658 _FormImpl::IsHeaderTranslucent(void) const
 659 {
 660         return GetCore().IsHeaderTranslucent();
 661 }
 662
 663 bool
 664 _FormImpl::IsFooterTranslucent(void) const
 665 {
 666         return GetCore().IsFooterTranslucent();
 667 }
 668
 669 // Ki-Dong,Hong.Temp
 670 bool
 671 _FormImpl::IsTabTranslucent(void) const
 672 {
 673         return GetCore().IsTabTranslucent();
 674 }
 675
 676 result
 677 _FormImpl::SetActionBarsTranslucent(unsigned long actionBars, bool translucent)
 678 {
 679         return GetCore().SetActionBarsTranslucent(actionBars, translucent);
 680 }
 681
 682 result
 683 _FormImpl::SetActionBarsVisible(unsigned long actionBars, bool visible)
 684 {
 685         return GetCore().SetActionBarsVisible(actionBars, visible);
 686 }
 687
 688 result
 689 _FormImpl::SetTitleIcon(const Bitmap* pTitleBitmap)
 690 {
 691         return GetCore().SetTitleIcon(pTitleBitmap);
 692 }
 693
 694 result
 695 _FormImpl::SetTitleText(const String& title, HorizontalAlignment alignment)
 696 {
 697         return GetCore().SetTitleText(title, alignment);
 698 }
 699
 700 OverlayRegion*
 701 _FormImpl::GetOverlayRegionN(const Rectangle& rect, OverlayRegionType regionType)
 702 {
 703         return GetCore().GetOverlayRegionN(rect, regionType);
 704 }
 705
 706 OverlayRegion*
 707 _FormImpl::GetOverlayRegionN(const FloatRectangle& rect, OverlayRegionType regionType)
 708 {
 709         return GetCore().GetOverlayRegionN(rect, regionType);
 710 }
 711
 712 void
 713 _FormImpl::OnDraw(void)
 714 {
 715         if (__pOriAgent)
 716         {
 717                 __pOriAgent->FireOrientationEvent();
 718         }
 719
 720         _ContainerImpl::OnDraw();
 721 }
 722
 723 bool
 724 _FormImpl::OnKeyReleased(const _ControlImpl& source, _KeyCode keyCode)
 725 {
 726         switch (keyCode)
 727         {
 728         case _KEY_BACKSPACE:
 729                 if (GetCore().GetFooter() || GetCore().GetHeader())
 730                 {
 731                         if (__pFormBackEventListener)
 732                         {
 733                                 Form* pForm = dynamic_cast <Form*>(&GetPublic());
 734                                 if (pForm)
 735                                 {
 736                                         __pFormBackEventListener->OnFormBackRequested(*pForm);
 737                                 }
 738                         }
 739                         else
 740                         {
 741                                 break;
 742                         }
 743                 }
 744                 else
 745                 {
 746                         break;
 747                 }
 748                 break;
 749
 750         default:
 751                 return false;
 752         }
 753
 754         return true;
 755 }
 756
 757 void
 758 _FormImpl::OnActionPerformed(const _Control& source, int actionId)
 759 {
 760         if (GetFormStyle() & FORM_STYLE_SOFTKEY_0 || GetFormStyle() & FORM_STYLE_SOFTKEY_1 || GetFormStyle() & FORM_STYLE_OPTIONKEY)
 761         {
 762                 Tizen::Base::Runtime::IEventArg* tempArg = null;
 763                 tempArg = _PublicActionEvent::CreateActionEventArgN(actionId);
 764                 SysTryReturnVoidResult(NID_UI_CTRL, tempArg , E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] Unable to create Eventarg.");
 765                 bool fired = true;
 766
 767                 _PublicActionEvent* pSoftkeyActionEvent = null;
 768
 769                 if (GetCore().GetFooter()->IsButtonSet(LEFT_BUTTON) && GetSoftkeyActionId(SOFTKEY_0) == actionId)
 770                 {
 771                         for (int i = 0; i < __leftSoftkeyActionList.GetCount(); i++)
 772                         {
 773                                 pSoftkeyActionEvent = dynamic_cast<_PublicActionEvent*>(__leftSoftkeyActionList.GetAt(i));
 774
 775                                 if (pSoftkeyActionEvent)
 776                                 {
 777                                         pSoftkeyActionEvent->Fire(*tempArg);
 778                                         fired = false;
 779                                 }
 780                         }
 781                 }
 782
 783                 if (GetCore().GetFooter()->IsButtonSet(RIGHT_BUTTON) && GetSoftkeyActionId(SOFTKEY_1) == actionId)
 784                 {
 785                         for (int i = 0; i < __rightSoftkeyActionList.GetCount(); i++)
 786                         {
 787                                 pSoftkeyActionEvent = dynamic_cast<_PublicActionEvent*>(__rightSoftkeyActionList.GetAt(i));
 788
 789                                 if (pSoftkeyActionEvent)
 790                                 {
 791                                         pSoftkeyActionEvent->Fire(*tempArg);
 792                                         fired = false;
 793                                 }
 794                         }
 795                 }
 796
 797                 if (GetCore().GetFooter()->IsButtonSet(MIDDLE_BUTTON) && GetOptionkeyActionId() == actionId)
 798                 {
 799                         if (__pOptionMenuActionEvent)
 800                         {
 801                                 __pOptionMenuActionEvent->Fire(*tempArg);
 802                                 fired = false;
 803                         }
 804                 }
 805                 if (fired)
 806                 {
 807                         delete tempArg;
 808                 }
 809         }
 810 }
 811
 812 Canvas*
 813 _FormImpl::GetClientAreaCanvasN(void) const
 814 {
 815         return GetCore().GetClientAreaCanvasN();
 816 }
 817
 818 Point
 819 _FormImpl::TranslateToClientAreaPosition(const Point& position) const
 820 {
 821         return GetCore().TranslateToClientAreaPosition(position);
 822 }
 823
 824 FloatPoint
 825 _FormImpl::TranslateToClientAreaPosition(const FloatPoint& position) const
 826 {
 827         return GetCore().TranslateToClientAreaPosition(position);
 828 }
 829
 830 Point
 831 _FormImpl::TranslateFromClientAreaPosition(const Point& clientPosition) const
 832 {
 833         return GetCore().TranslateFromClientAreaPosition(clientPosition);
 834 }
 835
 836 FloatPoint
 837 _FormImpl::TranslateFromClientAreaPosition(const FloatPoint& clientPosition) const
 838 {
 839         return GetCore().TranslateFromClientAreaPosition(clientPosition);
 840 }
 841
 842 void
 843 _FormImpl::SetFormBackEventListener(const IFormBackEventListener* pFormBackEventListener)
 844 {
 845         bool isBackButton = false;
 846
 847         Tizen::System::SystemInfo::GetValue(L"http://tizen.org/feature/input.keys.back", isBackButton);
 848
 849         if(!isBackButton)
 850         {
 851                 SysTryReturnVoidResult(NID_UI_CTRL, GetFooter() || GetHeader(), E_INVALID_STATE, "[E_INVALID_STATE] Footer isn't constructed.");
 852         }
 853
 854         __pFormBackEventListener = const_cast <IFormBackEventListener*>(pFormBackEventListener);
 855         GetCore().SetFormBackEventListener(this);
 856         result r = GetLastResult();
 857         SysTryReturnVoidResult(NID_UI_CTRL, r == E_SUCCESS, r, "[%s] Propagating.", GetErrorMessage(r));
 858 }
 859
 860 void
 861 _FormImpl::SetFormMenuEventListener(const IFormMenuEventListener* pFormMenuEventListener)
 862 {
 863         bool isMenuButton = false;
 864
 865         Tizen::System::SystemInfo::GetValue(L"http://tizen.org/feature/input.keys.menu", isMenuButton);
 866
 867         if(!isMenuButton)
 868         {
 869                 SysTryReturnVoidResult(NID_UI_CTRL, GetFooter() || GetHeader(), E_INVALID_STATE, "[E_INVALID_STATE] Footer isn't constructed.");
 870         }
 871         __pFormMenuEventListener = const_cast <IFormMenuEventListener*>(pFormMenuEventListener);
 872         GetCore().SetFormMenuEventListener(this);
 873         result r = GetLastResult();
 874         SysTryReturnVoidResult(NID_UI_CTRL, r == E_SUCCESS, r, "[%s] Propagating.", GetErrorMessage(r));
 875 }
 876
 877 void
 878 _FormImpl::AddOrientationEventListener(IOrientationEventListener& listener)
 879 {
 880         if (__pOriAgent)
 881         {
 882                 __pOriAgent->AddListener(listener);
 883         }
 884         else if (__pImeOriAgent)
 885         {
 886                 __pImeOriAgent->AddListener(listener);
 887         }
 888 }
 889
 890 void
 891 _FormImpl::AddOptionkeyActionListener(const IActionEventListener& listener)
 892 {
 893         if (HasOptionkey() == false)
 894         {
 895                 return ;
 896         }
 897
 898         __pOptionMenuActionEvent = _PublicActionEvent::CreateInstanceN(GetPublic());
 899
 900         SysTryReturnVoidResult(NID_UI_CTRL, __pOptionMenuActionEvent != null, GetLastResult(), "[%s] Propagating.", GetErrorMessage(GetLastResult()));
 901
 902         __pOptionMenuActionEvent->AddListener(listener);
 903 }
 904
 905 void
 906 _FormImpl::AddSoftkeyActionListener(Softkey softkey, const IActionEventListener& listener)
 907 {
 908         _Softkey _softkey = ConvertSoftkey(softkey);
 909
 910         if (GetCore().CheckSoftkey(_softkey) == false)
 911         {
 912                 return ;
 913         }
 914
 915         if (softkey == SOFTKEY_0)
 916         {
 917                 __pLeftSoftkeyActionEvent = _PublicActionEvent::CreateInstanceN(GetPublic());
 918
 919                 SysTryReturnVoidResult(NID_UI_CTRL, __pLeftSoftkeyActionEvent != null, GetLastResult(), "[%s] Propagating.", GetErrorMessage(GetLastResult()));
 920
 921                 __pLeftSoftkeyActionEvent->AddListener(listener);
 922
 923                 __leftSoftkeyActionList.Add(*__pLeftSoftkeyActionEvent);
 924         }
 925         else if (softkey == SOFTKEY_1)
 926         {
 927                 __pRightSoftkeyActionEvent = _PublicActionEvent::CreateInstanceN(GetPublic());
 928
 929                 SysTryReturnVoidResult(NID_UI_CTRL, __pRightSoftkeyActionEvent != null, GetLastResult(), "[%s] Propagating.", GetErrorMessage(GetLastResult()));
 930
 931                 __pRightSoftkeyActionEvent->AddListener(listener);
 932
 933                 __rightSoftkeyActionList.Add(*__pRightSoftkeyActionEvent);
 934         }
 935 }
 936
 937 void
 938 _FormImpl::RemoveOrientationEventListener(IOrientationEventListener& listener)
 939 {
 940         if (__pOriAgent)
 941         {
 942                 __pOriAgent->RemoveListener(listener);
 943         }
 944         else if (__pImeOriAgent)
 945         {
 946                 __pImeOriAgent->RemoveListener(listener);
 947         }
 948 }
 949
 950 void
 951 _FormImpl::RemoveOptionkeyActionListener(const IActionEventListener& listener)
 952 {
 953         if (HasOptionkey() == false)
 954         {
 955                 return ;
 956         }
 957
 958         if (__pOptionMenuActionEvent)
 959         {
 960                 __pOptionMenuActionEvent->RemoveListener(listener);
 961         }
 962 }
 963
 964 void
 965 _FormImpl::RemoveSoftkeyActionListener(Softkey softkey, const IActionEventListener& listener)
 966 {
 967         _Softkey _softkey = ConvertSoftkey(softkey);
 968
 969         if (GetCore().CheckSoftkey(_softkey) == false)
 970         {
 971                 return ;
 972         }
 973
 974         if (softkey == SOFTKEY_0)
 975         {
 976                 if (__pLeftSoftkeyActionEvent)
 977                 {
 978                         __pLeftSoftkeyActionEvent->RemoveListener(listener);
 979                 }
 980         }
 981         else if (softkey == SOFTKEY_1)
 982         {
 983                 if (__pRightSoftkeyActionEvent)
 984                 {
 985                         __pRightSoftkeyActionEvent->RemoveListener(listener);
 986                 }
 987         }
 988 }
 989
 990 void
 991 _FormImpl::SetOrientation(Orientation orientation)
 992 {
 993         if (__pOriAgent)
 994         {
 995                 __pOriAgent->SetMode(orientation);
 996         }
 997 }
 998
 999 Orientation
1000 _FormImpl::GetOrientation(void) const
1001 {
1002         if (__pOriAgent)
1003         {
1004                 return __pOriAgent->GetMode();
1005         }
1006
1007         return ORIENTATION_NONE;
1008 }
1009
1010 OrientationStatus
1011 _FormImpl::GetOrientationStatus(void) const
1012 {
1013         if (__pOriAgent)
1014         {
1015                 return __pOriAgent->GetStatus();
1016         }
1017         else if (__pImeOriAgent)
1018         {
1019                 return __pImeOriAgent->GetStatus();
1020         }
1021
1022         return ORIENTATION_STATUS_NONE;
1023 }
1024
1025 void
1026 _FormImpl::UpdateOrientationStatus(bool draw)
1027 {
1028         if (__pOriAgent)
1029         {
1030                 __pOriAgent->Update(draw);
1031         }
1032 }
1033
1034 void
1035 _FormImpl::UpdateOrientation(void)
1036 {
1037         if (__pOriAgent)
1038         {
1039                 __pOriAgent->UpdateOrientation();
1040         }
1041 }
1042
1043 void
1044 _FormImpl::UpdateOrientation(int angle)
1045 {
1046         SysLog(NID_UI_CTRL, "[Ime Rotation]");
1047
1048         if (__pImeOriAgent)
1049         {
1050                 __pImeOriAgent->UpdateOrientation(angle);
1051         }
1052 }
1053
1054 bool
1055 _FormImpl::HasOptionkey(void) const
1056 {
1057         return GetCore().HasOptionkey();
1058 }
1059
1060 bool
1061 _FormImpl::HasSoftkey(Softkey softkey) const
1062 {
1063         _Softkey _softkey = ConvertSoftkey(softkey);
1064
1065         return GetCore().HasSoftkey(_softkey);
1066 }
1067
1068 result
1069 _FormImpl::SetSoftkeyEnabled(Softkey softkey, bool enable)
1070 {
1071         _Softkey _softkey = ConvertSoftkey(softkey);
1072
1073         result r = GetCore().SetSoftkeyEnabled(_softkey, enable);
1074         SysTryLog(NID_UI_CTRL, r == E_SUCCESS, "[%s] Propagating.", GetErrorMessage(r));
1075
1076         return r;
1077 }
1078
1079 bool
1080 _FormImpl::IsSoftkeyEnabled(Softkey softkey) const
1081 {
1082         _Softkey _softkey = ConvertSoftkey(softkey);
1083
1084         return GetCore().IsSoftkeyEnabled(_softkey);
1085 }
1086
1087 int
1088 _FormImpl::GetSoftkeyActionId(Softkey softkey) const
1089 {
1090         _Softkey _softkey = ConvertSoftkey(softkey);
1091
1092         return GetCore().GetSoftkeyActionId(_softkey);
1093 }
1094
1095 int
1096 _FormImpl::GetOptionkeyActionId(void) const
1097 {
1098         return GetCore().GetOptionkeyActionId();
1099 }
1100
1101 String
1102 _FormImpl::GetSoftkeyText(Softkey softkey) const
1103 {
1104         _Softkey _softkey = ConvertSoftkey(softkey);
1105
1106         return GetCore().GetSoftkeyText(_softkey);
1107 }
1108
1109 result
1110 _FormImpl::SetOptionkeyActionId(int actionId)
1111 {
1112         result r = GetCore().SetOptionkeyActionId(actionId);
1113         SysTryLog(NID_UI_CTRL, r == E_SUCCESS, "[%s] Propagating.", GetErrorMessage(r));
1114
1115         return r;
1116 }
1117
1118 result
1119 _FormImpl::SetSoftkeyActionId(Softkey softkey, int actionId)
1120 {
1121         _Softkey _softkey = ConvertSoftkey(softkey);
1122
1123         result r = GetCore().SetSoftkeyActionId(_softkey, actionId);
1124         SysTryLog(NID_UI_CTRL, r == E_SUCCESS, "[%s] Propagating.", GetErrorMessage(r));
1125
1126         return r;
1127 }
1128
1129 result
1130 _FormImpl::SetSoftkeyText(Softkey softkey, const String& text)
1131 {
1132         _Softkey _softkey = ConvertSoftkey(softkey);
1133
1134         result r = GetCore().SetSoftkeyText(_softkey, text);
1135         SysTryLog(NID_UI_CTRL, r == E_SUCCESS, "[%s] Propagating.", GetErrorMessage(r));
1136
1137         return r;
1138 }
1139
1140 result
1141 _FormImpl::SetSoftkeyIcon(Softkey softkey, const Bitmap& pNormalBitmap, const Bitmap* ppPressedBitmap)
1142 {
1143         _Softkey _softkey = ConvertSoftkey(softkey);
1144
1145         result r = GetCore().SetSoftkeyIcon(_softkey, pNormalBitmap, ppPressedBitmap);
1146         SysTryLog(NID_UI_CTRL, r == E_SUCCESS, "[%s] Propagating.", GetErrorMessage(r));
1147
1148         return r;
1149 }
1150
1151 void
1152 _FormImpl::OnChangeLayout(_ControlOrientation orientation)
1153 {
1154         FloatDimension portraitSize = _ControlManager::GetInstance()->_ControlManager::GetScreenSizeF();
1155         FloatDimension landscapeSize = FloatDimension(portraitSize.height, portraitSize.width);
1156
1157         // Adjust the position of the partial Frame.
1158         _FrameImpl* pFrameImpl = dynamic_cast<_FrameImpl*>(GetParent());
1159         if (pFrameImpl)
1160         {
1161                 FrameShowMode frameShowMode = pFrameImpl->GetShowMode();
1162
1163                 if ((frameShowMode == FRAME_SHOW_MODE_PARTIAL_SCREEN) || (frameShowMode == FRAME_SHOW_MODE_PARTIAL_SCREEN_FLOATING))
1164                 {
1165                         bool movable = pFrameImpl->GetCore().IsMovable();
1166                         pFrameImpl->GetCore().SetMovable(true);
1167
1168                         FloatPoint prevPoint = pFrameImpl->GetPositionF();
1169
1170                         FloatPoint curPoint(0.0f, 0.0f);
1171
1172                         if (orientation == _CONTROL_ORIENTATION_PORTRAIT)
1173                         {
1174                                 if (prevPoint.x < 0.0f)
1175                                 {
1176                                         curPoint.x = portraitSize.height / portraitSize.width * prevPoint.x;
1177                                 }
1178                                 else
1179                                 {
1180                                         curPoint.x = portraitSize.width / portraitSize.height * prevPoint.x;
1181                                 }
1182
1183                                 if (prevPoint.y < 0.0f)
1184                                 {
1185                                         curPoint.y = portraitSize.width / portraitSize.height * prevPoint.y;
1186                                 }
1187                                 else
1188                                 {
1189                                         curPoint.y = portraitSize.height / portraitSize.width * prevPoint.y;
1190                                 }
1191                         }
1192                         else
1193                         {
1194                                 if (prevPoint.x < 0.0f)
1195                                 {
1196                                         curPoint.x = portraitSize.width / portraitSize.height * prevPoint.x;
1197                                 }
1198                                 else
1199                                 {
1200                                         curPoint.x = portraitSize.height / portraitSize.width * prevPoint.x;
1201                                 }
1202
1203                                 if (prevPoint.y < 0.0f)
1204                                 {
1205                                         curPoint.y = portraitSize.height / portraitSize.width * prevPoint.y;
1206                                 }
1207                                 else
1208                                 {
1209                                         curPoint.y = portraitSize.width / portraitSize.height * prevPoint.y;
1210                                 }
1211                         }
1212
1213                         pFrameImpl->SetPosition(curPoint);
1214
1215                         portraitSize = pFrameImpl->GetSizeF();
1216                         landscapeSize = portraitSize;
1217
1218                         pFrameImpl->GetCore().SetMovable(movable);
1219                 }
1220         }
1221
1222         // Change layout.
1223         _ContainerImpl::OnChangeLayout(orientation);
1224         SysTryReturnVoidResult(NID_UI_CTRL, GetLastResult() == E_SUCCESS, GetLastResult(), "[%s] Propagating.", GetErrorMessage(GetLastResult()));
1225
1226         if (orientation == _CONTROL_ORIENTATION_PORTRAIT)
1227         {
1228                 SetSize(portraitSize);
1229         }
1230         else
1231         {
1232                 SetSize(landscapeSize);
1233         }
1234
1235         float indicatorheight = 0.0f;
1236
1237         GET_SHAPE_CONFIG(FORM::INDICATOR_HEIGHT, GetCore().GetOrientation(), indicatorheight);
1238         _Indicator* pIndicator = GetCore().GetIndicator();
1239         if (GetCore().HasIndicator())
1240         {
1241                 if (pIndicator)
1242                 {
1243                         if (orientation == _CONTROL_ORIENTATION_PORTRAIT)
1244                         {
1245                                 pIndicator->SetBounds(FloatRectangle(0.0f, 0.0f, GetClientBoundsF().width, indicatorheight));
1246                         }
1247                         else
1248                         {
1249                                 GET_SHAPE_CONFIG(FORM::INDICATOR_MINIMIZE_HEIGHT, GetCore().GetOrientation(), indicatorheight);
1250                                 pIndicator->SetBounds(FloatRectangle(0.0f, 0.0f, GetClientBoundsF().width, indicatorheight));
1251                         }
1252                 }
1253                 GetCore().AdjustClientBounds();
1254         }
1255         if (pIndicator)
1256         {
1257                 pIndicator->OnChangeLayout(orientation);
1258         }
1259
1260
1261         float adjHeight = 0.0f;
1262
1263         if (GetCore().HasHeader())
1264         {
1265                 FloatRectangle indicatorBounds(0.0f, 0.0f, 0.0f, 0.0f);
1266                 if (GetCore().IsIndicatorVisible())
1267                 {
1268                         indicatorBounds = GetCore().GetIndicatorBoundsF();
1269                         if (GetCore().IsIndicatorTranslucent())
1270                         {
1271                                 if (!GetCore().IsHeaderTranslucent())
1272                                 {
1273                                         indicatorBounds.height = 0.0f;
1274                                 }
1275                                 else
1276                                 {
1277                                         if (orientation == _CONTROL_ORIENTATION_LANDSCAPE)
1278                                         {
1279                                                 indicatorBounds.height = 0.0f;
1280                                         }
1281                                 }
1282                         }
1283                 }
1284
1285                 FloatRectangle bounds(0.0f, indicatorBounds.height, GetClientBoundsF().width, GetCore().GetToolbarHeightF(true));
1286                 GetCore().SetHeaderBounds(bounds);
1287         }
1288
1289         if (GetCore().HasTab())                         // Ki-Dong,Hong.Temp
1290         {
1291                 float titleHeight = 0.0f;
1292
1293                 if (GetCore().GetFormStyle() & FORM_STYLE_TITLE)
1294                 {
1295                         if (GetCore().HasHeader())
1296                         {
1297                                 _HeaderImpl* pHeaderImpl = GetHeader();
1298                                 if (pHeaderImpl)
1299                                 {
1300                                         titleHeight = pHeaderImpl->GetBoundsF().height;
1301                                 }
1302                         }
1303                 }
1304
1305                 FloatRectangle indicatorBounds(0.0f, 0.0f, 0.0f, 0.0f);
1306
1307                 if (GetCore().IsIndicatorVisible())
1308                 {
1309                         indicatorBounds = GetCore().GetIndicatorBoundsF();
1310                         if (GetCore().IsIndicatorTranslucent())
1311                         {
1312                                 if (!GetCore().IsHeaderTranslucent())
1313                                 {
1314                                         indicatorBounds.height = 0.0f;
1315                                 }
1316                                 else
1317                                 {
1318                                         if (orientation == _CONTROL_ORIENTATION_LANDSCAPE)
1319                                         {
1320                                                 indicatorBounds.height = 0.0f;
1321                                         }
1322                                 }
1323                         }
1324                 }
1325
1326                 float posY = indicatorBounds.height + titleHeight;
1327
1328                 FloatRectangle bounds(0.0f, posY, GetClientBoundsF().width, GetCore().GetTabHeightF());
1329                 GetCore().SetTabBounds(bounds);
1330         }
1331
1332         if (GetCore().HasFooter())
1333         {
1334                 if (GetCore().GetFooter()->GetVisibleState() && !GetCore().IsFooterTranslucent())
1335                 {
1336                         adjHeight = 0.0f;
1337                 }
1338                 else
1339                 {
1340                         adjHeight = GetCore().GetToolbarHeightF(false);
1341                 }
1342
1343                 if (!(GetCore().GetFormStyle() & FORM_STYLE_FOOTER || GetCore().GetFormStyle() & FORM_STYLE_SOFTKEY_0 || GetCore().GetFormStyle() & FORM_STYLE_SOFTKEY_1
1344                                 || GetCore().GetFormStyle() & FORM_STYLE_OPTIONKEY))
1345                 {
1346                         adjHeight = GetCore().GetToolbarHeightF(false);
1347                 }
1348
1349                 FloatRectangle bounds(0.0f, GetClientBoundsF().y + GetClientBoundsF().height - adjHeight,
1350                                                                                 GetClientBoundsF().width, GetCore().GetToolbarHeightF(false));
1351                 GetCore().SetFooterBounds(bounds);
1352         }
1353 }
1354
1355 _HeaderImpl*
1356 _FormImpl::CreateHeaderN(void)
1357 {
1358         result r = E_SUCCESS;
1359
1360         Header* pHeader = new (std::nothrow) Header;
1361         SysTryReturn(NID_UI_CTRL, pHeader, null, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] Memory is insufficient.");
1362
1363         r = pHeader->Construct();
1364         SysTryReturn(NID_UI_CTRL, r == E_SUCCESS, null, r, "[%s] Propagating.", GetErrorMessage(r));
1365
1366         _HeaderImpl* pHeaderImpl = _HeaderImpl::GetInstance(*pHeader);
1367
1368         SetLastResult(E_SUCCESS);
1369
1370         return pHeaderImpl;
1371 }
1372
1373 _FooterImpl*
1374 _FormImpl::CreateFooterN(void)
1375 {
1376         result r = E_SUCCESS;
1377
1378         Footer* pFooter = new (std::nothrow) Footer;
1379         SysTryReturn(NID_UI_CTRL, pFooter, null, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] Memory is insufficient.");
1380
1381         r = pFooter->Construct();
1382         SysTryReturn(NID_UI_CTRL, r == E_SUCCESS, null, r, "[%s] Propagating.", GetErrorMessage(r));
1383
1384         _FooterImpl* pFooterImpl = _FooterImpl::GetInstance(*pFooter);
1385
1386         SetLastResult(E_SUCCESS);
1387
1388         return pFooterImpl;
1389 }
1390
1391 // Ki-Dong,Hong.Temp
1392 _TabImpl*
1393 _FormImpl::CreateTabImplN(void)
1394 {
1395         //result r = E_SUCCESS;
1396
1397         //Tab* pTab = new (std::nothrow) Tab;
1398         //SysTryReturn(NID_UI_CTRL, pTab, null, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] Memory shortage.");
1399
1400         //r = pTab->Construct();
1401         //SysTryReturn(NID_UI_CTRL, r == E_SUCCESS, null, E_SYSTEM, "[E_SYSTEM] Unable to consturct tab.");
1402
1403         //return pTab->GetTabImpl();
1404         Tab* pTab = _TabImpl::CreateTabN();
1405         SysTryReturn(NID_UI_CTRL, pTab, null, GetLastResult(), "[%s] Propagating.", GetErrorMessage(GetLastResult()));
1406
1407         _TabImpl* pTabImpl = _TabImpl::GetInstance(*pTab);
1408
1409         SetLastResult(E_SUCCESS);
1410
1411         return pTabImpl;
1412 }
1413
1414 bool
1415 _FormImpl::DeflateClientRectHeight(int height)
1416 {
1417         return GetCore().DeflateClientRectHeight(height);
1418 }
1419
1420 bool
1421 _FormImpl::DeflateClientRectHeight(float height)
1422 {
1423         return GetCore().DeflateClientRectHeight(height);
1424 }
1425
1426 bool
1427 _FormImpl::RemoveHeader(void)
1428 {
1429         _HeaderImpl* pHeaderImpl = GetHeader();
1430
1431         if (pHeaderImpl)
1432         {
1433                 __pForm->RemoveHeader();
1434                 result r = GetLastResult();
1435                 SysTryReturn(NID_UI_CTRL, r == E_SUCCESS, false, r, "[%s] Propagating.", GetErrorMessage(r));
1436                 Header* pHeader = pHeaderImpl->GetHeader();
1437
1438                 delete pHeader;
1439         }
1440         else
1441                 return false;
1442
1443         return true;
1444 }
1445
1446 bool
1447 _FormImpl::RemoveFooter(void)
1448 {
1449         _FooterImpl* pFooterImpl = GetFooter();
1450
1451         if (pFooterImpl)
1452         {
1453                 __pForm->RemoveFooter();
1454                 result r = GetLastResult();
1455                 SysTryReturn(NID_UI_CTRL, r == E_SUCCESS, false, r, "[%s] Propagating.", GetErrorMessage(r));
1456                 Footer* pFooter = pFooterImpl->GetFooter();
1457
1458                 delete pFooter;
1459         }
1460         else
1461         {
1462                 return false;
1463         }
1464
1465         return true;
1466 }
1467
1468 // Ki-Dong,Hong.Temp
1469 bool
1470 _FormImpl::RemoveTabImpl(void)
1471 {
1472         _TabImpl* pTabImpl = GetTabImpl();
1473
1474         if (pTabImpl)
1475         {
1476                 __pForm->RemoveTab();
1477                 result r = GetLastResult();
1478                 SysTryReturn(NID_UI_CTRL, r == E_SUCCESS, false, r, "[%s] Propagating.", GetErrorMessage(r));
1479                 Tab* pTab = pTabImpl->GetTab();
1480
1481                 pTabImpl->DeleteTab(pTab);
1482         }
1483         else
1484         {
1485                 return false;
1486         }
1487
1488         return true;
1489 }
1490
1491 DataBindingContext*
1492 _FormImpl::GetDataBindingContextN(void) const
1493 {
1494         return _DataBindingContextImpl::GetDataBindingContextN(*this);
1495 }
1496
1497 result
1498 _FormImpl::OnAttaching(const _Control* pParent)
1499 {
1500         result r = E_SUCCESS;
1501         _Frame* pFrame = dynamic_cast<_Frame*>(const_cast<_Control*>((pParent)));
1502         if (FORM_STYLE_INDICATOR & GetCore().GetFormStyle())
1503         {
1504                 SysTryReturnResult(NID_UI_CTRL, pFrame != null, E_INVALID_ARG, "A Form which has FORM_STYLE_INDICATOR style cannot be added to a container except Frame.");
1505         }
1506         r = _ControlImpl::OnAttaching(pParent);
1507         return r;
1508 }
1509
1510 result
1511 _FormImpl::OnAttachedToMainTree(void)
1512 {
1513         result r = E_SUCCESS;
1514   SetFocused();
1515
1516   r = GetCore().AttachedToMainTree();
1517   r = _ContainerImpl::OnAttachedToMainTree();
1518
1519         FloatRectangle indicatorBounds(0.0f, 0.0f, 0.0f, 0.0f);
1520
1521         if (FORM_STYLE_INDICATOR & GetCore().GetFormStyle())
1522         {
1523                 indicatorBounds = GetCore().GetIndicatorBoundsF();
1524                 r = GetLastResult();
1525                 SysTryReturnResult(NID_UI_CTRL, r == E_SUCCESS, r, "[%s] Propagating.", GetErrorMessage(r));
1526         }
1527
1528         _HeaderImpl* pHeader = GetHeader();
1529         _FooterImpl* pFooter = GetFooter();
1530         _TabImpl* pTabImpl = GetTabImpl();
1531
1532         if (pHeader)
1533         {
1534                 if (GetCore().IsIndicatorTranslucent())
1535                 {
1536                         if (!GetCore().IsHeaderTranslucent())
1537                         {
1538                                 indicatorBounds.height = 0.0f;
1539                         }
1540                         else
1541                         {
1542                                 if (GetCore().GetOrientation() == _CONTROL_ORIENTATION_LANDSCAPE)
1543                                 {
1544                                         indicatorBounds.height = 0.0f;
1545                                 }
1546                         }
1547                 }
1548                 FloatRectangle bounds(0.0f, indicatorBounds.height, GetClientBoundsF().width, GetCore().GetToolbarHeightF(true));
1549                 GetCore().SetHeaderBounds(bounds);
1550         }
1551
1552         float titleHeight = 0.0f;
1553
1554         if (pHeader)
1555         {
1556                 titleHeight = pHeader->GetBoundsF().height;
1557         }
1558
1559         if (pTabImpl)
1560         {
1561                 float posY = indicatorBounds.height + titleHeight;
1562
1563                         FloatRectangle bounds(0.0f, posY, GetClientBoundsF().width, GetCore().GetTabHeightF());
1564                         GetCore().SetTabBounds(bounds);
1565         }
1566
1567         if (pFooter)
1568         {
1569                 float adjHeight = 0.0f;
1570
1571                 if (!(GetCore().GetFooter()->GetVisibleState()) || GetCore().IsFooterTranslucent())
1572                 {
1573                         adjHeight = GetCore().GetToolbarHeightF(false);
1574                 }
1575
1576                 if (!(GetCore().GetFormStyle() & FORM_STYLE_FOOTER || GetCore().GetFormStyle() & FORM_STYLE_SOFTKEY_0 || GetCore().GetFormStyle() & FORM_STYLE_SOFTKEY_1
1577                                 || GetCore().GetFormStyle() & FORM_STYLE_OPTIONKEY))
1578                 {
1579                         adjHeight = GetCore().GetToolbarHeightF(false);
1580                 }
1581
1582                 FloatRectangle clientbounds = GetClientBoundsF();
1583                 FloatRectangle bounds(0.0f, clientbounds.y + clientbounds.height - adjHeight, clientbounds.width, GetCore().GetToolbarHeightF(false));
1584
1585                 GetCore().SetFooterBounds(bounds);
1586         }
1587
1588         UpdateOrientationStatus();
1589
1590         if (__pOriAgent)
1591         {
1592                 __pOriAgent->RequestOrientationEvent();
1593         }
1594
1595         return r;
1596 }
1597
1598 result
1599 _FormImpl::OnDetachingFromMainTree(void)
1600 {
1601         result r = E_SUCCESS;
1602         r = GetCore().DetachingFromMainTree();
1603         r = _ContainerImpl::OnDetachingFromMainTree();
1604
1605         return r;
1606 }
1607
1608 bool
1609 _FormImpl::OnNotifiedN(const _ControlImpl& source, IList* pArgs)
1610 {
1611         String* pString = dynamic_cast <Tizen::Base::String*>(pArgs->GetAt(0));
1612         if (pString)
1613         {
1614                 if (*pString == _REQUEST_ORIENTATION_EVENT)
1615                 {
1616                         if (__pOriAgent)
1617                         {
1618                                 __pOriAgent->FireOrientationEvent();
1619                         }
1620
1621                         pArgs->RemoveAll(true);
1622                         delete pArgs;
1623
1624                         return true;
1625                 }
1626         }
1627
1628         return false;
1629 }
1630
1631 void
1632 _FormImpl::OnFormBackRequested(Tizen::Ui::Controls::_Form& source)
1633 {
1634         if (__pFormBackEventListener)
1635         {
1636                 _FormImpl* pFormImpl = static_cast<_FormImpl*>(source.GetUserData());
1637                 Form* pForm = dynamic_cast <Form*>(&pFormImpl->GetPublic());
1638                 if (pForm)
1639                 {
1640                         __pFormBackEventListener->OnFormBackRequested(*pForm);
1641                 }
1642                 else
1643                 {
1644                         return;
1645                 }
1646         }
1647 }
1648
1649 void
1650 _FormImpl::OnFormMenuRequested(Tizen::Ui::Controls::_Form& source)
1651 {
1652         if (__pFormMenuEventListener)
1653         {
1654                 _FormImpl* pFormImpl = static_cast<_FormImpl*>(source.GetUserData());
1655                 Form* pForm = dynamic_cast <Form*>(&pFormImpl->GetPublic());
1656                 if (pForm)
1657                 {
1658                         __pFormMenuEventListener->OnFormMenuRequested(*pForm);
1659                 }
1660                 else
1661                 {
1662                         return;
1663                 }
1664         }
1665 }
1666
1667 OrientationStatus
1668 _FormImpl::OnFormOrientationStatusRequested(void)
1669 {
1670         _ControlImplManager* pImplManager = _ControlImplManager::GetInstance();
1671         SysAssert(pImplManager);
1672
1673         OrientationStatus status = ORIENTATION_STATUS_PORTRAIT;
1674         int appType = _AppInfo::GetAppType();
1675         if (!(appType & _APP_TYPE_IME_APP))
1676         {
1677                 status = pImplManager->GetOrientationStatus(GetOrientation());
1678         }
1679         return status;
1680 }
1681
1682 bool
1683 _FormImpl::IsOpaque(void) const
1684 {
1685         //return true;
1686         return false;
1687 }
1688
1689 _Softkey
1690 _FormImpl::ConvertSoftkey(Softkey softkey) const
1691 {
1692         _Softkey _softkey;
1693
1694         if (softkey == SOFTKEY_0)
1695         {
1696                 _softkey = _SOFTKEY_0;
1697         }
1698         else if (softkey == SOFTKEY_1)
1699         {
1700                 _softkey = _SOFTKEY_1;
1701         }
1702         else
1703         {
1704                 _softkey = _SOFTKEY_COUNT;
1705         }
1706
1707         return _softkey;
1708 }
1709
1710 result
1711 _FormImpl::SetNotificationTrayOpenEnabled(bool enable)
1712 {
1713         return GetCore().SetNotificationTrayOpenEnabled(enable);
1714 }
1715
1716 bool
1717 _FormImpl::IsNotificationTrayOpenEnabled(void) const
1718 {
1719         return GetCore().IsNotificationTrayOpenEnabled();
1720 }
1721
1722 class _FormMaker
1723         : public _UiBuilderControlMaker
1724 {
1725 public:
1726         _FormMaker(_UiBuilder* uibuilder)
1727                 : _UiBuilderControlMaker(uibuilder){};
1728         virtual ~_FormMaker()
1729         {
1730         };
1731         static _UiBuilderControlMaker* GetInstance(_UiBuilder* uibuilder)
1732         {
1733                 _FormMaker* pFormMaker = new (std::nothrow) _FormMaker(uibuilder);
1734                 return pFormMaker;
1735         };
1736 protected:
1737         virtual Control* Make(_UiBuilderControl* pControl)
1738         {
1739                 _UiBuilderControlLayout* pControlProperty = null;
1740                 result r = E_SUCCESS;
1741                 int style = 0;
1742                 int opacity = 0;
1743                 Tizen::Base::String elementString;
1744                 bool isTitleAlign = false;
1745                 Color color;
1746
1747                 HorizontalAlignment align = ALIGNMENT_CENTER;
1748                 Form* pForm = (Form*) GetContainer();
1749
1750                 // Get control manager
1751                 _ControlManager* pControlManager = _ControlManager::GetInstance();
1752                 if (pControlManager == null)
1753                 {
1754                         SysLog(NID_UI_CTRL, "Unable to get the control manager.n");
1755                         return null;
1756                 }
1757                 FloatDimension screenSize = pControlManager->GetScreenSizeF();
1758
1759                 //Set rect
1760                 (pControl->GetAttribute(UIBUILDER_ATTRIBUTE_PORTRAIT))->SetRect(0.0f, 0.0f, screenSize.width, screenSize.height);
1761                 (pControl->GetAttribute(UIBUILDER_ATTRIBUTE_LANDSCAPE))->SetRect(0.0f, 0.0f, screenSize.height, screenSize.width);
1762
1763                 // Get device orientation
1764                 app_device_orientation_e deviceOrientation = app_get_device_orientation();
1765                 bool isHorizontal = (deviceOrientation == APP_DEVICE_ORIENTATION_90) || (deviceOrientation == APP_DEVICE_ORIENTATION_270);
1766
1767                 if (isHorizontal)
1768                 {
1769                         pControlProperty = pControl->GetAttribute(UIBUILDER_ATTRIBUTE_LANDSCAPE);
1770                 }
1771                 else
1772                 {
1773                         pControlProperty = pControl->GetAttribute(UIBUILDER_ATTRIBUTE_PORTRAIT);
1774                 }
1775
1776                 if (pControlProperty == null)
1777                 {
1778                         SysLogException(NID_UI_CTRL, E_SYSTEM, "[E_SYSTEM] Can't read attributes");
1779                         return null;
1780                 }
1781
1782                 pControlProperty = pControl->GetAttribute(UIBUILDER_ATTRIBUTE_PORTRAIT);
1783                 Tizen::Base::String styleString;
1784                 styleString = pControlProperty->GetStyle();
1785
1786                 if (styleString.Contains(L"FORM_STYLE_TITLE"))
1787                 {
1788                         style |= FORM_STYLE_TITLE;
1789                 }
1790                 if (styleString.Contains(L"FORM_STYLE_SOFTKEY_0"))
1791                 {
1792                         style |= FORM_STYLE_SOFTKEY_0;
1793                 }
1794                 if (styleString.Contains(L"FORM_STYLE_SOFTKEY_1"))
1795                 {
1796                         style |= FORM_STYLE_SOFTKEY_1;
1797                 }
1798                 if (styleString.Contains(L"FORM_STYLE_OPTIONKEY"))
1799                 {
1800                         style |= FORM_STYLE_OPTIONKEY;
1801                 }
1802                 if (styleString.Contains(L"FORM_STYLE_INDICATOR"))
1803                 {
1804                         if (styleString.Contains(L"FORM_STYLE_INDICATOR_AUTO_HIDE"))
1805                         {
1806                                 style |= FORM_STYLE_INDICATOR_AUTO_HIDE;
1807                         }
1808                         else
1809                         {
1810                                 style |= FORM_STYLE_INDICATOR;
1811                         }
1812                 }
1813                 if (styleString.Contains(L"FORM_STYLE_TEXT_TAB"))
1814                 {
1815                         style |= FORM_STYLE_TEXT_TAB;
1816                 }
1817                 if (styleString.Contains(L"FORM_STYLE_ICON_TAB"))
1818                 {
1819                         style |= FORM_STYLE_ICON_TAB;
1820                 }
1821                 if (styleString.Contains(L"FORM_STYLE_HEADER"))
1822                 {
1823                         style |= FORM_STYLE_HEADER;
1824                 }
1825                 if (styleString.Contains(L"FORM_STYLE_FOOTER"))
1826                 {
1827                         style |= FORM_STYLE_FOOTER;
1828                 }
1829
1830                 _UiBuilderLayoutType layoutType = UIBUILDER_LAYOUT_NONE;
1831                 __pLayoutMaker->GetLayoutType(pControlProperty, layoutType);
1832                 if (layoutType == UIBUILDER_LAYOUT_NONE)
1833                 {
1834                         // Construct
1835                         r = pForm->Construct(style);
1836                 }
1837                 else
1838                 {
1839                         Layout* pPortraitLayout = null;
1840                         Layout* pLandscapeLayout = null;
1841                         result tempResult = E_SUCCESS;
1842                         tempResult = __pLayoutMaker->GetLayoutN(pControl, pPortraitLayout, pLandscapeLayout);
1843                         if (E_SUCCESS == tempResult)
1844                         {
1845                                 r = pForm->Construct(*pPortraitLayout, *pLandscapeLayout, style);
1846                         }
1847                         else
1848                         {
1849                                 r = tempResult;
1850                         }
1851
1852                         _UiBuilderLayoutType layoutType = UIBUILDER_LAYOUT_NONE;
1853
1854                         if (__pLayoutMaker->GetLayoutType(pControlProperty, layoutType) == false)
1855                         {
1856                                 return null;
1857                         }
1858
1859                         if ( layoutType == UIBUILDER_LAYOUT_GRID)
1860                         {
1861                                 for (int i = 0; i < UIBUILDER_ATTRIBUTE_NUM; i++)
1862                                 {
1863                                         GridLayout* pGridLayout = null;
1864                                         pControlProperty = pControl->GetAttribute(i);
1865
1866                                         if ( i == UIBUILDER_ATTRIBUTE_PORTRAIT)
1867                                         {
1868                                                 pGridLayout = dynamic_cast<GridLayout*>(pPortraitLayout);
1869                                         }
1870                                         else
1871                                         {
1872                                                 pGridLayout = dynamic_cast<GridLayout*>(pLandscapeLayout);
1873                                         }
1874                                         __pLayoutMaker->SetGridLayoutContainerProperty(pGridLayout, pControlProperty);
1875                                 }
1876                         }
1877                         delete pPortraitLayout;
1878                         if (pPortraitLayout != pLandscapeLayout)
1879                         {
1880                                 delete pLandscapeLayout;
1881                         }
1882                 }
1883
1884                 if (r != E_SUCCESS)
1885                 {
1886                         SysLog(NID_UI_CTRL, "Failed to create Form.");
1887                         return null;
1888                 }
1889
1890                 // Set Property
1891                 if (pControl->GetElement(L"titleAlign", elementString))
1892                 {
1893                         if (elementString.Equals(L"ALIGN_CENTER", false))
1894                         {
1895                                 align = ALIGNMENT_CENTER;
1896                         }
1897                         else if (elementString.Equals(L"ALIGN_RIGHT", false))
1898                         {
1899                                 align = ALIGNMENT_RIGHT;
1900                         }
1901                         else
1902                         {
1903                                 align = ALIGNMENT_LEFT;
1904                         }
1905                         isTitleAlign = true;
1906                 }
1907
1908                 if (style & FORM_STYLE_TITLE)
1909                 {
1910                         if (pControl->GetElement(L"title", elementString))
1911                         {
1912                                 if (isTitleAlign)
1913                                 {
1914                                         pForm->SetTitleText(elementString, align);
1915                                 }
1916                                 else
1917                                 {
1918                                         pForm->SetTitleText(elementString);
1919                                 }
1920                         }
1921                         else
1922                         {
1923                                 if (isTitleAlign)
1924                                 {
1925                                         pForm->SetTitleText(L"", align);
1926                                 }
1927                                 else
1928                                 {
1929                                         pForm->SetTitleText(L"");
1930                                 }
1931                         }
1932                 }
1933
1934                 if (pControl->GetElement(L"titleIcon", elementString))
1935                 {
1936                         Bitmap* pBitmap = null;
1937                         pBitmap = LoadBitmapN(elementString);
1938                         if (pBitmap != null)
1939                         {
1940                                 r = pForm->SetTitleIcon(pBitmap);
1941                                 delete pBitmap;
1942                                 if (IsFailed(r))
1943                                 {
1944                                         SysLog(NID_UI_CTRL, "Failed to set TitleIcon.");
1945                                 }
1946                         }
1947                 }
1948
1949                 if (pControl->GetElement(L"softKey0Text", elementString))
1950                 {
1951                         pForm->SetSoftkeyText(SOFTKEY_0, elementString);
1952                 }
1953                 if (pControl->GetElement(L"softKey1Text", elementString))
1954                 {
1955                         pForm->SetSoftkeyText(SOFTKEY_1, elementString);
1956                 }
1957                 if (pControl->GetElement(L"backgroundColorOpacity", elementString) || pControl->GetElement(L"BGColorOpacity", elementString))
1958                 {
1959                         Base::Integer::Parse(elementString, opacity);
1960                 }
1961                 if (pControl->GetElement(L"backgroundColor", elementString) || pControl->GetElement(L"BGColor", elementString))
1962                 {
1963                         ConvertStringToColor32(elementString, opacity, color);
1964                         pForm->SetBackgroundColor(color);
1965                 }
1966                 else
1967                 {
1968                         Color color;
1969                         r = GET_COLOR_CONFIG(FORM::BG_NORMAL,color);
1970                         if (r == E_SUCCESS)
1971                         {
1972                                 pForm->SetBackgroundColor(color);
1973                         }
1974                         else
1975                         {
1976                                 pForm->SetBackgroundColor(0xff000000);
1977                         }
1978                 }
1979
1980                 if (pControl->GetElement(L"softKey0Icon", elementString) || pControl->GetElement(L"softKey0NormalIcon", elementString))
1981                 {
1982                         Bitmap* pNormalBitmap = null;
1983                         Bitmap* pPressedBitmap = null;
1984                         pNormalBitmap = LoadBitmapN(elementString); //__image->DecodeN(path,BITMAP_PIXEL_FORMAT_RGB565);
1985
1986                         if (pNormalBitmap != null)
1987                         {
1988                                 if (pControl->GetElement(L"softKey0PressedIcon", elementString))
1989                                 {
1990                                         pPressedBitmap = LoadBitmapN(elementString);
1991                                 }
1992
1993                                 if (pPressedBitmap != null)
1994                                 {
1995                                         pForm->SetSoftkeyIcon(SOFTKEY_0, *pNormalBitmap, pPressedBitmap);
1996                                         delete pNormalBitmap;
1997                                         delete pPressedBitmap;
1998                                 }
1999                                 else
2000                                 {
2001                                         pForm->SetSoftkeyIcon(SOFTKEY_0, *pNormalBitmap, null);
2002                                         delete pNormalBitmap;
2003                                 }
2004                         }
2005                 }
2006                 if (pControl->GetElement(L"softKey1Icon", elementString) || pControl->GetElement(L"softKey1NormalIcon", elementString))
2007                 {
2008                         Bitmap* pNormalBitmap = null;
2009                         Bitmap* pPressedBitmap = null;
2010                         pNormalBitmap = LoadBitmapN(elementString); //__image->DecodeN(path,BITMAP_PIXEL_FORMAT_RGB565);
2011
2012                         if (pNormalBitmap != null)
2013                         {
2014                                 if (pControl->GetElement(L"softKey1PressedIcon", elementString))
2015                                 {
2016                                         pPressedBitmap = LoadBitmapN(elementString); // __image->DecodeN(path,BITMAP_PIXEL_FORMAT_RGB565);
2017                                 }
2018
2019                                 if (pPressedBitmap != null)
2020                                 {
2021                                         pForm->SetSoftkeyIcon(SOFTKEY_1, *pNormalBitmap, pPressedBitmap);
2022                                         delete pNormalBitmap;
2023                                         delete pPressedBitmap;
2024                                 }
2025                                 else
2026                                 {
2027                                         pForm->SetSoftkeyIcon(SOFTKEY_1, *pNormalBitmap, null);
2028                                         delete pNormalBitmap;
2029                                 }
2030                         }
2031                 }
2032
2033                 if (pControl->GetElement(L"Orientation", elementString) || pControl->GetElement(L"orientation", elementString))
2034                 {
2035                         //ORIENTATION_NONE,
2036                         //ORIENTATION_PORTRAIT,
2037                         //ORIENTATION_LANDSACPE,
2038                         //ORIENTATION_PORTRAIT_REVERSE,
2039                         //ORIENTATION_LANDSACPE_REVERSE,
2040                         //ORIENTATION_AUTO = 6,
2041                         //ORIENTATION_AUTO_FOUR_DIRECTION = 8,
2042
2043                         if (elementString.Equals(L"Automatic:2Dir", false) || elementString.Equals(L"Automatic", false))
2044                         {
2045                                 pForm->SetOrientation(ORIENTATION_AUTOMATIC);
2046                         }
2047                         else if (elementString.Equals(L"Automatic:4Dir", false))
2048                         {
2049                                 pForm->SetOrientation(ORIENTATION_AUTOMATIC_FOUR_DIRECTION);
2050                         }
2051                         else if (elementString.Equals(L"Landscape", false))
2052                         {
2053                                 pForm->SetOrientation(ORIENTATION_LANDSCAPE);
2054                                 SetUiBuilderRotateState(UIBUIDER_SCREEN_HORIZONTAL);
2055                         }
2056                         else if (elementString.Equals(L"Landscape:Reverse", false))
2057                         {
2058                                 pForm->SetOrientation(ORIENTATION_LANDSCAPE_REVERSE);
2059                                 SetUiBuilderRotateState(UIBUIDER_SCREEN_HORIZONTAL);
2060                         }
2061                         else if (elementString.Equals(L"Portrait", false))
2062                         {
2063                                 pForm->SetOrientation(ORIENTATION_PORTRAIT);
2064                                 SetUiBuilderRotateState(UIBUIDER_SCREEN_VERTICAL);
2065                         }
2066                         else if (elementString.Equals(L"Portrait:Reverse", false))
2067                         {
2068                                 pForm->SetOrientation(ORIENTATION_PORTRAIT_REVERSE);
2069                                 SetUiBuilderRotateState(UIBUIDER_SCREEN_VERTICAL);
2070                         }
2071                 }
2072
2073                 if (style & FORM_STYLE_HEADER)
2074                 {
2075                         if (pControl->GetElement(L"translucentHeader", elementString))
2076                         {
2077                                 if (elementString.Equals(L"true", false))
2078                                 {
2079                                         pForm->SetActionBarsTranslucent(FORM_ACTION_BAR_HEADER, true);
2080                                 }
2081                         }
2082                 }
2083
2084                 if (style & FORM_STYLE_FOOTER)
2085                 {
2086                         if (pControl->GetElement(L"translucentFooter", elementString))
2087                         {
2088                                 if (elementString.Equals(L"true", false))
2089                                 {
2090                                         pForm->SetActionBarsTranslucent(FORM_ACTION_BAR_FOOTER, true);
2091                                 }
2092                         }
2093                 }
2094
2095                 if (style & FORM_STYLE_INDICATOR)
2096                 {
2097                         if (pControl->GetElement(L"translucentIndicator", elementString))
2098                         {
2099                                 if (elementString.Equals(L"true", false))
2100                                 {
2101                                         pForm->SetActionBarsTranslucent(FORM_ACTION_BAR_INDICATOR, true);
2102                                 }
2103                         }
2104                 }
2105
2106                 return pForm;
2107         }
2108
2109 };
2110
2111 _FormRegister::_FormRegister()
2112 {
2113         _UiBuilderControlTableManager* pUiBuilderControlTableManager = _UiBuilderControlTableManager::GetInstance();
2114         pUiBuilderControlTableManager->RegisterControl(L"Form", _FormMaker::GetInstance);
2115 }
2116 _FormRegister::~_FormRegister()
2117 {
2118         _UiBuilderControlTableManager* pUiBuilderControlTableManager = _UiBuilderControlTableManager::GetInstance();
2119         pUiBuilderControlTableManager->UnregisterControl(L"Form");
2120 }
2121 static _FormRegister FormRegisterToUiBuilder;
2122 }}} // Tizen::Ui::Controls