src/ui/controls/FUiCtrl_Form.cpp

   1 //
   2 // Open Service Platform
   3 // Copyright (c) 2012-2013 Samsung Electronics Co., Ltd.
   4 //
   5 // Licensed under the Flora License, Version 1.0 (the License);
   6 // you may not use this file except in compliance with the License.
   7 // You may obtain a copy of the License at
   8 //
   9 //     http://floralicense.org/license/
  10 //
  11 // Unless required by applicable law or agreed to in writing, software
  12 // distributed under the License is distributed on an AS IS BASIS,
  13 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  14 // See the License for the specific language governing permissions and
  15 // limitations under the License.
  16 //
  17 /**
  18  * @file                FUiCtrl_Form.cpp
  19  * @brief               This is the implementation file for the _Form class.
  20  */
  21
  22 #include <new>
  23 #include <unique_ptr.h>
  24 #include <FBaseErrorDefine.h>
  25 #include <FBaseInteger.h>
  26 #include <FBaseSysLog.h>
  27 #include <FBaseColArrayListT.h>
  28 #include <FGrpFloatRectangle.h>
  29 #include <FBase_Log.h>
  30 #include <FGrp_BitmapImpl.h>
  31 #include "FUi_ResourceManager.h"
  32 #include "FUi_EcoreEvasMgr.h"
  33 #include "FUi_EcoreEvas.h"
  34 #include "FUi_CoordinateSystemUtils.h"
  35 #include "FUi_DataBindingContext.h"
  36 #include "FUi_AccessibilityContainer.h"
  37 #include "FUi_AccessibilityManager.h"
  38 #include "FUiCtrl_Form.h"
  39 #include "FUiCtrl_Frame.h"
  40 #include "FUiCtrl_FormPresenter.h"
  41 #include "FUiCtrl_Toolbar.h"
  42 #include "FUiCtrl_Tab.h"
  43 #include "FUiCtrl_ActionEvent.h"
  44 #include "FUiCtrl_OverlayRegionImpl.h"
  45 #include "FUiCtrl_OverlayPanelImpl.h"
  46 #include "FUiCtrl_IFormBackEventListener.h"
  47 #include "FUiCtrl_Indicator.h"
  48 #include "FUi_SystemUtilImpl.h"
  49
  50 using namespace std;
  51 using namespace Tizen::Ui::Animations;
  52 using namespace Tizen::Ui;
  53 using namespace Tizen::Base;  // Rotation
  54 using namespace Tizen::Base::Runtime;
  55 using namespace Tizen::Base::Collection;
  56 using namespace Tizen::Graphics;
  57
  58 namespace Tizen { namespace Ui { namespace Controls
  59 {
  60
  61 _Form::_Form(void)
  62         : __pFormPresenter(null)
  63         , __pFormBackEventListener(null)
  64         , __formStyle(0)
  65         , __pActionEvent(null)
  66         , __pHeader(null)
  67         , __pFooter(null)
  68         , __pTab(null)
  69         , __pIndicator(null)
  70         , __transparentIndicator(false)
  71         , __transparentHeader(false)
  72         , __transparentFooter(false)
  73         , __transparentTab(false)
  74         , __indicatorShowState(false)
  75         , __deflated(false)
  76         , __deflatedHeight(0.0f)
  77         , __overlayRegionCount(0)
  78         , __ppOverlayerRegionImplArray(null)
  79         , __softkeyCount(SOFTKEY_COUNT + 1)
  80         , __updatedSoftkeyCount(0)
  81         , __keypadShowstate(false)
  82 {
  83         Color color;
  84         result r = GET_COLOR_CONFIG(FORM::BG_NORMAL,color);
  85         if (r == E_SUCCESS)
  86         {
  87                 SetBackgroundColor(color);
  88         }
  89         else
  90         {
  91                 SetBackgroundColor(0xff000000);
  92         }
  93
  94         _FormPresenter* pPresenter = new (std::nothrow) _FormPresenter(*this);
  95         SysTryReturnVoidResult(NID_UI_CTRL, pPresenter, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] Memory is insufficient.");
  96
  97         SetPresenter(*pPresenter);
  98
  99         for (int i = 0; i < __softkeyCount; i++)
 100         {
 101                 __actionId[_SOFTKEY_0 + i] = 0;
 102                 __softkeyText[_SOFTKEY_0 + i] = String();
 103                 __showSoftkey[_SOFTKEY_0 + i] = false;
 104                 __enableSoftkey[_SOFTKEY_0 + i] = false;
 105         }
 106
 107         for (int i = 0; i < SOFTKEY_COUNT + 1; i++)
 108         {
 109                 __pSoftkeyNormalBitmap[_SOFTKEY_0 + i] = null;
 110                 __pSoftkeyPressedBitmap[_SOFTKEY_0 + i] = null;
 111                 __pSoftkeyNormalEffectBitmap[_SOFTKEY_0 + i] = null;
 112                 __pSoftkeyPressedEffectBitmap[_SOFTKEY_0 + i] = null;
 113
 114                 __pTextSoftkeyNormalBitmap[_SOFTKEY_0 + i] = null;
 115                 __pTextSoftkeyPressedBitmap[_SOFTKEY_0 + i] = null;
 116                 __pTextSoftkeyNormalEffectBitmap[_SOFTKEY_0 + i] = null;
 117                 __pTextSoftkeyPressedEffectBitmap[_SOFTKEY_0 + i] = null;
 118
 119                 __pSoftkeyNormalIcon[_SOFTKEY_0 + i] = null;
 120                 __pSoftkeyPressedIcon[_SOFTKEY_0 + i] = null;
 121         }
 122
 123         //create data binding context
 124         _DataBindingContext* pContext = new (std::nothrow) _DataBindingContext(*this);
 125         r = GetLastResult();
 126         SysTryCatch(NID_UI_CTRL, pContext && GetLastResult() == E_SUCCESS, , r, "[%s] Propagating.", GetErrorMessage(r));
 127         SetDataBindingContext(pContext);
 128
 129         ClearLastResult();
 130         GetAccessibilityContainer()->Activate(true);
 131         return;
 132
 133 CATCH:
 134         delete pContext;
 135 }
 136
 137 _Form::~_Form(void)
 138 {
 139         delete __pFormPresenter;
 140         __pFormPresenter = null;
 141
 142         if (__pActionEvent)
 143         {
 144                 delete __pActionEvent;
 145                 __pActionEvent = null;
 146         }
 147
 148         for (int i = 0; i < SOFTKEY_COUNT+1 ; i++)
 149         {
 150                 if (__pSoftkeyNormalBitmap[i])
 151                 {
 152                         delete __pSoftkeyNormalBitmap[i];
 153                         __pSoftkeyNormalBitmap[i] = null;
 154                 }
 155         }
 156
 157         for (int i = 0; i < SOFTKEY_COUNT+1 ; i++)
 158         {
 159                 if (__pSoftkeyPressedBitmap[i])
 160                 {
 161                         delete __pSoftkeyPressedBitmap[i];
 162                         __pSoftkeyPressedBitmap[i] = null;
 163                 }
 164         }
 165
 166         for (int i = 0; i < SOFTKEY_COUNT+1 ; i++)
 167         {
 168                 if (__pSoftkeyNormalEffectBitmap[i])
 169                 {
 170                         delete __pSoftkeyNormalEffectBitmap[i];
 171                         __pSoftkeyNormalEffectBitmap[i] = null;
 172                 }
 173         }
 174
 175         for (int i = 0; i < SOFTKEY_COUNT+1 ; i++)
 176         {
 177                 if (__pSoftkeyPressedEffectBitmap[i])
 178                 {
 179                         delete __pSoftkeyPressedEffectBitmap[i];
 180                         __pSoftkeyPressedEffectBitmap[i] = null;
 181                 }
 182         }
 183
 184         for (int i = 0; i < SOFTKEY_COUNT+1 ; i++)
 185         {
 186                 if (__pTextSoftkeyNormalBitmap[i])
 187                 {
 188                         delete __pTextSoftkeyNormalBitmap[i];
 189                         __pTextSoftkeyNormalBitmap[i] = null;
 190                 }
 191         }
 192
 193         for (int i = 0; i < SOFTKEY_COUNT+1 ; i++)
 194         {
 195                 if (__pTextSoftkeyPressedBitmap[i])
 196                 {
 197                         delete __pTextSoftkeyPressedBitmap[i];
 198                         __pTextSoftkeyPressedBitmap[i] = null;
 199                 }
 200         }
 201
 202         for (int i = 0; i < SOFTKEY_COUNT+1 ; i++)
 203         {
 204                 if (__pTextSoftkeyNormalEffectBitmap[i])
 205                 {
 206                         delete __pTextSoftkeyNormalEffectBitmap[i];
 207                         __pTextSoftkeyNormalEffectBitmap[i] = null;
 208                 }
 209         }
 210
 211         for (int i = 0; i < SOFTKEY_COUNT+1 ; i++)
 212         {
 213                 if (__pTextSoftkeyPressedEffectBitmap[i])
 214                 {
 215                         delete __pTextSoftkeyPressedEffectBitmap[i];
 216                         __pTextSoftkeyPressedEffectBitmap[i] = null;
 217                 }
 218         }
 219
 220         for (int i = 0; i < SOFTKEY_COUNT+1; i++)
 221         {
 222                 if (__pSoftkeyNormalIcon[i])
 223                 {
 224                         delete __pSoftkeyNormalIcon[i];
 225                         __pSoftkeyNormalIcon[i] = null;
 226                 }
 227
 228                 if (__pSoftkeyPressedIcon[i])
 229                 {
 230                         delete __pSoftkeyPressedIcon[i];
 231                         __pSoftkeyPressedIcon[i] = null;
 232                 }
 233         }
 234
 235         if (__ppOverlayerRegionImplArray != null)
 236         {
 237                 int maxCount = OverlayRegion::GetMaxCount();
 238
 239                 for (int i = 0; i < maxCount; i++)
 240                 {
 241                         if (__ppOverlayerRegionImplArray[i])
 242                         {
 243                                 OverlayRegion* _pOverlayRegion = __ppOverlayerRegionImplArray[i]->GetOverlayRegion();
 244                                 delete _pOverlayRegion;
 245                         }
 246                 }
 247
 248                 delete[] __ppOverlayerRegionImplArray;
 249         }
 250
 251         if (__pIndicator)
 252         {
 253                 delete __pIndicator;
 254                 __pIndicator = null;
 255         }
 256
 257         ClearLastResult();
 258 }
 259
 260 _Form*
 261 _Form::CreateFormN(void)
 262 {
 263         _Form* pForm = null;
 264
 265         pForm = new (std::nothrow) _Form;
 266         SysTryReturn(NID_UI_CTRL, pForm, null, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] Memory is insufficient.");
 267         SysTryCatch(NID_UI_CTRL, GetLastResult() == E_SUCCESS, , E_SYSTEM, "[E_SYSTEM] A system error occurred.");
 268
 269         pForm->AcquireHandle();
 270
 271         SetLastResult(E_SUCCESS);
 272
 273         return pForm;
 274
 275 CATCH:
 276         delete pForm;
 277
 278         return null;
 279 }
 280
 281 result
 282 _Form::SetPresenter(const _FormPresenter& formPresenter)
 283 {
 284         __pFormPresenter = const_cast <_FormPresenter*>(&formPresenter);
 285
 286         return E_SUCCESS;
 287 }
 288
 289 void
 290 _Form::OnDraw(void)
 291 {
 292         if (__pFormPresenter)
 293         {
 294                 __pFormPresenter->Draw();
 295         }
 296
 297         if (__formStyle & FORM_STYLE_SOFTKEY_0 || __formStyle & FORM_STYLE_SOFTKEY_1 || __formStyle & FORM_STYLE_OPTIONKEY)
 298         {
 299                 if (__pFooter)
 300                 {
 301                         UpdateSoftkey(__formStyle);
 302                 }
 303         }
 304         if(unlikely((_AccessibilityManager::IsActivated())))
 305         {
 306                 _AccessibilityManager::GetInstance()->RequestAutoReading(_ACCESSIBILITY_AUTO_READING_MODE_FIRST_ITEM);
 307         }
 308         return;
 309 }
 310
 311 void
 312 _Form::SetFormBackEventListener(_IFormBackEventListener* pFormBackEventListener)
 313 {
 314         SysTryReturnVoidResult(NID_UI_CTRL, __pFooter || __pHeader, E_INVALID_STATE, "[E_INVALID_STATE] Footer and Header aren't constructed.");
 315         __pFormBackEventListener = pFormBackEventListener;
 316         if (__pFooter)
 317         {
 318                 __pFooter->SetBackEventListener(*this, ID_BACK_BUTTON);
 319         }
 320         if (__pHeader)
 321         {
 322                 __pHeader->SetBackEventListener(*this, ID_BACK_BUTTON);
 323         }
 324
 325         SetLastResult(E_SUCCESS);
 326 }
 327
 328 unsigned long
 329 _Form::GetFormStyle(void) const
 330 {
 331         return __formStyle;
 332 }
 333
 334 _Toolbar*
 335 _Form::GetFooter(void) const
 336 {
 337         return __pFooter;
 338 }
 339
 340 _Toolbar*
 341 _Form::GetHeader(void) const
 342 {
 343         return __pHeader;
 344 }
 345
 346 _Tab*
 347 _Form::GetTab(void) const
 348 {
 349         return __pTab;
 350 }
 351
 352 _Indicator*
 353 _Form::GetIndicator(void) const
 354 {
 355         return __pIndicator;
 356 }
 357
 358 String
 359 _Form::GetTitleText(void) const
 360 {
 361         if (__pHeader && (__formStyle & FORM_STYLE_TITLE))
 362         {
 363                 return __pHeader->GetTitleText();
 364         }
 365         else
 366         {
 367                 return String(L"");
 368         }
 369 }
 370
 371 HorizontalAlignment
 372 _Form::GetTitleTextHorizontalAlignment(void) const
 373 {
 374         if (__pHeader && (__formStyle & FORM_STYLE_TITLE))
 375         {
 376                 return __pHeader->GetTitleTextHorizontalAlignment();
 377         }
 378         else
 379         {
 380                 SysLog(NID_UI_CTRL, "[E_SYSTEM] The title is not valid.");
 381                 return ALIGNMENT_LEFT;
 382         }
 383 }
 384
 385 OverlayRegion*
 386 _Form::GetOverlayRegionN(const Rectangle& rect, OverlayRegionType regionType)
 387 {
 388         _OverlayRegionImpl* pOverlayRegionImpl = null;
 389         OverlayRegion* pOverlayRegion = null;
 390         Color bgColor(0, 0, 0, 0);
 391         int idx = 0;
 392         int maxCount = 0;
 393         _OverlayPanel* pOverlayPanel = null;
 394         result r = E_SYSTEM;
 395         bool modified = false;
 396
 397         ClearLastResult();
 398
 399         maxCount = OverlayRegion::GetMaxCount();
 400         SysTryReturn(NID_UI_CTRL, maxCount > 0, null, E_SYSTEM, "[E_SYSTEM] maxCount [%d] is invalid", maxCount);
 401
 402         if (__ppOverlayerRegionImplArray == null)
 403         {
 404                 __ppOverlayerRegionImplArray = new (std::nothrow) _OverlayRegionImpl*[maxCount];
 405                 SysTryReturn(NID_UI_CTRL, __ppOverlayerRegionImplArray != null, null, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] Can not allocate memory for the OverlayRegionList.");
 406
 407                 for (int i = 0; i < maxCount; i++)
 408                 {
 409                         __ppOverlayerRegionImplArray[i] = null;
 410                 }
 411                 __overlayRegionCount = 0;
 412         }
 413
 414         Rectangle clientRect(GetClientBounds());
 415         Point overlayPosition(clientRect.x + rect.x, clientRect.y + rect.y);
 416         Rectangle overlayRect(overlayPosition.x, overlayPosition.y, rect.width, rect.height);
 417
 418         Rectangle userPhyRect = _CoordinateSystemUtils::Transform(rect);
 419         Rectangle devBounds = _CoordinateSystemUtils::Transform(overlayRect);
 420
 421         SysLog(NID_UI_CTRL, "rect [%d, %d, %d, %d] ", rect.x, rect.y, rect.width, rect.height);
 422         SysLog(NID_UI_CTRL, "userPhyRect [%d, %d, %d, %d] ", userPhyRect.x, userPhyRect.y, userPhyRect.width, userPhyRect.height);
 423         SysLog(NID_UI_CTRL, "overlayRect [%d, %d, %d, %d]", overlayPosition.x, overlayPosition.y, rect.width, rect.height);
 424         SysLog(NID_UI_CTRL, "devBounds [%d, %d, %d, %d]", devBounds.x, devBounds.y, devBounds.width, devBounds.height);
 425
 426         // 1. width , height unit check
 427         if (_OverlayRegionImpl::IsValidOverlayRect(overlayRect, devBounds, _CoordinateSystemUtils::Transform(clientRect), modified) != E_SUCCESS)
 428         {
 429                 SysTryReturn(NID_UI_CTRL, 0, null, E_INVALID_ARG, "[E_INVALID_ARG] IsValidOverlayRect is failed!");
 430         }
 431
 432         if (modified)
 433         {
 434                 SysLog(NID_UI_CTRL, "devBounds modified [%d, %d, %d, %d]", devBounds.x, devBounds.y, devBounds.width, devBounds.height);
 435         }
 436
 437         // 2. check for using OverlayPanel simutaneously
 438         for (idx = 0 ; idx < GetChildCount() ; idx++)
 439         {
 440                 pOverlayPanel = dynamic_cast <_OverlayPanel*>(GetChild(idx));
 441                 SysTryReturn(NID_UI_CTRL, pOverlayPanel == null, null, E_SYSTEM, "[E_SYSTEM] Using OverlayRegion mixed with OverlayPanel is not supported!");
 442         }
 443
 444         // 3. find the empty slot idx
 445         for (idx = 0; idx < maxCount; idx++)
 446         {
 447                 if (__ppOverlayerRegionImplArray[idx] == null)
 448                 {
 449                         break;
 450                 }
 451         }
 452
 453         SysTryReturn(NID_UI_CTRL, idx < maxCount, null, E_SYSTEM, "[E_SYSTEM] already used permitted maximum number of OverlayRegion!");
 454
 455         // 4. make OverlayRegion object
 456         pOverlayRegionImpl = new (std::nothrow) _OverlayRegionImpl();
 457         SysTryReturn(NID_UI_CTRL, pOverlayRegionImpl != null, null, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] failed to make the OverlayRegionImpl instance!");
 458
 459         FloatRectangle overlayRectF = _CoordinateSystemUtils::InverseTransform(_CoordinateSystemUtils::ConvertToFloat(devBounds));
 460         r = pOverlayRegionImpl->Construct(this, regionType, _CoordinateSystemUtils::ConvertToFloat(rect), overlayRectF, devBounds);
 461         if (r != E_SUCCESS)
 462         {
 463                 delete pOverlayRegionImpl;
 464                 SysTryReturn(NID_UI_CTRL, 0, null, r, "[%s] Propagating.", GetErrorMessage(r));
 465         }
 466
 467         pOverlayRegion = pOverlayRegionImpl->CreateOverlayRegionN();
 468         if (pOverlayRegion == null)
 469         {
 470                 delete pOverlayRegionImpl;
 471                 SysTryReturn(NID_UI_CTRL, 0, null, GetLastResult(), "[%s] Propagating.", GetErrorMessage(GetLastResult()));
 472         }
 473
 474         __ppOverlayerRegionImplArray[idx] = pOverlayRegionImpl;
 475         pOverlayRegionImpl->SetFormArrayIndex(idx);
 476
 477         __overlayRegionCount++;
 478
 479         SetLastResult(E_SUCCESS);
 480
 481         return pOverlayRegion;
 482 }
 483
 484 OverlayRegion*
 485 _Form::GetOverlayRegionN(const FloatRectangle& rect, OverlayRegionType regionType)
 486 {
 487         _OverlayRegionImpl* pOverlayRegionImpl = null;
 488         OverlayRegion* pOverlayRegion = null;
 489         Color bgColor(0, 0, 0, 0);
 490         int idx = 0;
 491         int maxCount = 0;
 492         _OverlayPanel* pOverlayPanel = null;
 493         result r = E_SYSTEM;
 494         bool modified = false;
 495
 496         ClearLastResult();
 497
 498         maxCount = OverlayRegion::GetMaxCount();
 499         SysTryReturn(NID_UI_CTRL, maxCount > 0, null, E_SYSTEM, "[E_SYSTEM] maxCount [%d] is invalid", maxCount);
 500
 501         if (__ppOverlayerRegionImplArray == null)
 502         {
 503                 __ppOverlayerRegionImplArray = new (std::nothrow) _OverlayRegionImpl*[maxCount];
 504                 SysTryReturn(NID_UI_CTRL, __ppOverlayerRegionImplArray != null, null, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] Can not allocate memory for the OverlayRegionList.");
 505
 506                 for (int i = 0; i < maxCount; i++)
 507                 {
 508                         __ppOverlayerRegionImplArray[i] = null;
 509                 }
 510                 __overlayRegionCount = 0;
 511         }
 512
 513         FloatRectangle clientRectF(GetClientBoundsF());
 514         FloatPoint overlayPositionF(clientRectF.x + rect.x, clientRectF.y + rect.y);
 515         FloatRectangle overlayRectF(overlayPositionF.x, overlayPositionF.y, rect.width, rect.height);
 516
 517         FloatRectangle devPhyBoundsF = _CoordinateSystemUtils::Transform(overlayRectF);
 518         Rectangle devPhyBounds = _CoordinateSystemUtils::ConvertToInteger(devPhyBoundsF);
 519
 520         //org user float
 521         SysLog(NID_UI_CTRL, "user rect [%.3f, %.3f, %.3f, %.3f] ", rect.x, rect.y, rect.width, rect.height);
 522         //adjustedlogical user float
 523         SysLog(NID_UI_CTRL, "overlayRectF [%.3f, %.3f, %.3f, %.3f]", overlayRectF.x, overlayRectF.y, overlayRectF.width, overlayRectF.height);
 524         //adjusted logical -> adjusted physical float
 525         SysLog(NID_UI_CTRL, "devPhyBoundsF [%.3f, %.3f, %.3f, %.3f]", devPhyBoundsF.x, devPhyBoundsF.y, devPhyBoundsF.width, devPhyBoundsF.height);
 526         //adjusted physical float -> physical integer
 527         SysLog(NID_UI_CTRL, "devPhyBounds [%d, %.3d, %.3d, %.3d]", devPhyBounds.x, devPhyBounds.y, devPhyBounds.width, devPhyBounds.height);
 528
 529         Rectangle overlayLgcRect = _CoordinateSystemUtils::ConvertToInteger(overlayRectF);
 530         Rectangle basePhyBounds = _CoordinateSystemUtils::ConvertToInteger(_CoordinateSystemUtils::Transform(clientRectF));
 531
 532         // 1. width , height unit check
 533         if (_OverlayRegionImpl::IsValidOverlayRect(overlayLgcRect, devPhyBounds, basePhyBounds, modified) != E_SUCCESS)
 534         {
 535                 SysTryReturn(NID_UI_CTRL, 0, null, E_INVALID_ARG, "[E_INVALID_ARG] IsValidOverlayRect is failed!");
 536         }
 537
 538         if (modified)
 539         {
 540                 SysLog(NID_UI_CTRL, "devBounds modified [%d, %d, %d, %d]", devPhyBounds.x, devPhyBounds.y, devPhyBounds.width, devPhyBounds.height);
 541         }
 542
 543         // 2. check for using OverlayPanel simutaneously
 544         for (idx = 0 ; idx < GetChildCount() ; idx++)
 545         {
 546                 pOverlayPanel = dynamic_cast <_OverlayPanel*>(GetChild(idx));
 547                 SysTryReturn(NID_UI_CTRL, pOverlayPanel == null, null, E_SYSTEM, "[E_SYSTEM] Using OverlayRegion mixed with OverlayPanel is not supported!");
 548         }
 549
 550         // 3. find the empty slot idx
 551         for (idx = 0; idx < maxCount; idx++)
 552         {
 553                 if (__ppOverlayerRegionImplArray[idx] == null)
 554                 {
 555                         break;
 556                 }
 557         }
 558
 559         SysTryReturn(NID_UI_CTRL, idx < maxCount, null, E_SYSTEM, "[E_SYSTEM] already used permitted maximum number of OverlayRegion!");
 560
 561         // 4. make OverlayRegion object
 562         pOverlayRegionImpl = new (std::nothrow) _OverlayRegionImpl();
 563         SysTryReturn(NID_UI_CTRL, pOverlayRegionImpl != null, null, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] failed to make the OverlayRegionImpl instance!");
 564
 565         overlayRectF = _CoordinateSystemUtils::InverseTransform(_CoordinateSystemUtils::ConvertToFloat(devPhyBounds));
 566         r = pOverlayRegionImpl->Construct(this, regionType, rect, overlayRectF, devPhyBounds);
 567         if (r != E_SUCCESS)
 568         {
 569                 delete pOverlayRegionImpl;
 570                 SysTryReturn(NID_UI_CTRL, 0, null, r, "[%s] Propagating.", GetErrorMessage(r));
 571         }
 572
 573         pOverlayRegion = pOverlayRegionImpl->CreateOverlayRegionN();
 574         if (pOverlayRegion == null)
 575         {
 576                 delete pOverlayRegionImpl;
 577                 SysTryReturn(NID_UI_CTRL, 0, null, GetLastResult(), "[%s] Propagating.", GetErrorMessage(GetLastResult()));
 578         }
 579
 580         __ppOverlayerRegionImplArray[idx] = pOverlayRegionImpl;
 581         pOverlayRegionImpl->SetFormArrayIndex(idx);
 582
 583         __overlayRegionCount++;
 584
 585         SetLastResult(E_SUCCESS);
 586
 587         return pOverlayRegion;
 588 }
 589
 590 int
 591 _Form::GetOverlayRegionCount(void) const
 592 {
 593         return __overlayRegionCount;
 594 }
 595
 596 void
 597 _Form::MoveOverlayRegion(bool top)
 598 {
 599         if (__ppOverlayerRegionImplArray == null)
 600         {
 601                 return;
 602         }
 603         for (int i = 0; i < OverlayRegion::GetMaxCount(); i++)
 604         {
 605                 if (__ppOverlayerRegionImplArray[i] != null)
 606                 {
 607                         if (top)
 608                         {
 609                                 __ppOverlayerRegionImplArray[i]->GoForeground();
 610                         }
 611                         else
 612                         {
 613                                 __ppOverlayerRegionImplArray[i]->GoBackground();
 614                         }
 615                 }
 616         }
 617 }
 618
 619 void
 620 _Form::CreateSoftkey(unsigned long formStyle)
 621 {
 622         Bitmap* pTempBitmap = null;
 623         FloatDimension softkeyDimension(0.0f, 0.0f);
 624         FloatDimension softkeyDisplayDimension(0.0f, 0.0f);
 625         FloatDimension optionkeyDimension(0.0f, 0.0f);
 626         float fontSize = 0.0f;
 627         float multilineFontSize = 0.0f;
 628         float leftSoftkeyLeftMargin = 0.0f;
 629         float rightSoftkeyLeftMargin = 0.0f;
 630         float softkeyTopMargin = 0.0f;
 631         Color softkeyNormalBackgroundColor;
 632         Color softkeyPressedBackgroundColor;
 633         Color softkeyNormalTextColor;
 634         Color softkeyPressedTextColor;
 635         Color softkeyNormalIconColor;
 636         Color softkeyPressedIconColor;
 637
 638         GET_DIMENSION_CONFIG(FOOTER::SOFTKEY_RECT, GetOrientation(), softkeyDimension);
 639         GET_DIMENSION_CONFIG(FOOTER::SOFTKEY_DISPLAY_RECT_WITH_TEXT, GetOrientation(), softkeyDisplayDimension);
 640         GET_DIMENSION_CONFIG(FOOTER::OPTIONKEY_RECT, GetOrientation(), optionkeyDimension);
 641         GET_SHAPE_CONFIG(FOOTER::SOFTKEY_TEXT_SIZE, GetOrientation(), fontSize);
 642         GET_SHAPE_CONFIG(FOOTER::SOFTKEY_MULTILINE_TEXT_SIZE, GetOrientation(), multilineFontSize);
 643         GET_SHAPE_CONFIG(FOOTER::SOFTKEY_0_LEFT_MARGIN, GetOrientation(), leftSoftkeyLeftMargin);
 644         GET_SHAPE_CONFIG(FOOTER::SOFTKEY_1_LEFT_MARGIN, GetOrientation(), rightSoftkeyLeftMargin);
 645         GET_SHAPE_CONFIG(FOOTER::SOFTKEY_TOP_MARGIN, GetOrientation(), softkeyTopMargin);
 646         GET_COLOR_CONFIG(FOOTER::SOFTKEY_BG_NORMAL, softkeyNormalBackgroundColor);
 647         GET_COLOR_CONFIG(FOOTER::SOFTKEY_BG_PRESSED, softkeyPressedBackgroundColor);
 648         GET_COLOR_CONFIG(FOOTER::SOFTKEY_TEXT_NORMAL, softkeyNormalTextColor);
 649         GET_COLOR_CONFIG(FOOTER::SOFTKEY_TEXT_PRESSED, softkeyPressedTextColor);
 650         GET_COLOR_CONFIG(FOOTER::SOFTKEY_ICON_NORMAL, softkeyNormalIconColor);
 651         GET_COLOR_CONFIG(FOOTER::SOFTKEY_ICON_PRESSED, softkeyPressedIconColor);
 652
 653         result r = E_SUCCESS;
 654
 655         if (__pFooter != null)
 656         {
 657                 __pFooter->SetStyle(TOOLBAR_SOFTKEY);
 658         }
 659
 660         if (formStyle & FORM_STYLE_SOFTKEY_0)
 661         {
 662                 r = GET_BITMAP_CONFIG_N(FOOTER::SOFTKEY_LEFT_BG_NORMAL, BITMAP_PIXEL_FORMAT_ARGB8888, pTempBitmap);
 663                 SysTryReturnVoidResult(NID_UI_CTRL, r == E_SUCCESS, r, "[%s] Propagating.", GetErrorMessage(r));
 664                 if (__pSoftkeyNormalBitmap[_SOFTKEY_0])
 665                 {
 666                         delete __pSoftkeyNormalBitmap[_SOFTKEY_0];
 667                         __pSoftkeyNormalBitmap[_SOFTKEY_0] = null;
 668                 }
 669                 __pSoftkeyNormalBitmap[_SOFTKEY_0] = _BitmapImpl::GetColorReplacedBitmapN(*pTempBitmap, Color::GetColor(COLOR_ID_MAGENTA), softkeyNormalBackgroundColor);
 670                 delete pTempBitmap;
 671
 672                 r = GET_BITMAP_CONFIG_N(FOOTER::SOFTKEY_LEFT_TEXT_BG_NORMAL, BITMAP_PIXEL_FORMAT_ARGB8888, pTempBitmap);
 673                 SysTryReturnVoidResult(NID_UI_CTRL, r == E_SUCCESS, r, "[%s] Propagating.", GetErrorMessage(r));
 674                 if (__pTextSoftkeyNormalBitmap[_SOFTKEY_0])
 675                 {
 676                         delete __pTextSoftkeyNormalBitmap[_SOFTKEY_0];
 677                         __pTextSoftkeyNormalBitmap[_SOFTKEY_0] = null;
 678                 }
 679                 __pTextSoftkeyNormalBitmap[_SOFTKEY_0] = _BitmapImpl::GetColorReplacedBitmapN(*pTempBitmap, Color::GetColor(COLOR_ID_MAGENTA), softkeyNormalBackgroundColor);
 680                 delete pTempBitmap;
 681
 682                 r = GET_BITMAP_CONFIG_N(FOOTER::SOFTKEY_LEFT_BG_PRESSED, BITMAP_PIXEL_FORMAT_ARGB8888, pTempBitmap);
 683                 SysTryReturnVoidResult(NID_UI_CTRL, r == E_SUCCESS, r, "[%s] Propagating.", GetErrorMessage(r));
 684                 if (__pSoftkeyPressedBitmap[_SOFTKEY_0])
 685                 {
 686                         delete __pSoftkeyPressedBitmap[_SOFTKEY_0];
 687                         __pSoftkeyPressedBitmap[_SOFTKEY_0] = null;
 688                 }
 689                 __pSoftkeyPressedBitmap[_SOFTKEY_0] = _BitmapImpl::GetColorReplacedBitmapN(*pTempBitmap, Color::GetColor(COLOR_ID_MAGENTA), softkeyPressedBackgroundColor);
 690                 delete pTempBitmap;
 691
 692                 r = GET_BITMAP_CONFIG_N(FOOTER::SOFTKEY_LEFT_TEXT_BG_PRESSED, BITMAP_PIXEL_FORMAT_ARGB8888, pTempBitmap);
 693                 SysTryReturnVoidResult(NID_UI_CTRL, r == E_SUCCESS, r, "[%s] Propagating.", GetErrorMessage(r));
 694                 if (__pTextSoftkeyPressedBitmap[_SOFTKEY_0])
 695                 {
 696                         delete __pTextSoftkeyPressedBitmap[_SOFTKEY_0];
 697                         __pTextSoftkeyPressedBitmap[_SOFTKEY_0] = null;
 698                 }
 699                 __pTextSoftkeyPressedBitmap[_SOFTKEY_0] = _BitmapImpl::GetColorReplacedBitmapN(*pTempBitmap, Color::GetColor(COLOR_ID_MAGENTA), softkeyPressedBackgroundColor);
 700                 delete pTempBitmap;
 701
 702                 r = GET_BITMAP_CONFIG_N(FOOTER::SOFTKEY_LEFT_BG_EFFECT_NORMAL, BITMAP_PIXEL_FORMAT_ARGB8888, pTempBitmap);
 703                 SysTryReturnVoidResult(NID_UI_CTRL, r == E_SUCCESS, r, "[%s] Propagating.", GetErrorMessage(r));
 704                 if (__pSoftkeyNormalEffectBitmap[_SOFTKEY_0])
 705                 {
 706                         delete __pSoftkeyNormalEffectBitmap[_SOFTKEY_0];
 707                         __pSoftkeyNormalEffectBitmap[_SOFTKEY_0] = null;
 708                 }
 709                 __pSoftkeyNormalEffectBitmap[_SOFTKEY_0] = _BitmapImpl::GetColorReplacedBitmapN(*pTempBitmap, Color::GetColor(COLOR_ID_MAGENTA), softkeyNormalBackgroundColor);
 710                 delete pTempBitmap;
 711
 712                 r = GET_BITMAP_CONFIG_N(FOOTER::SOFTKEY_LEFT_TEXT_BG_EFFECT_NORMAL, BITMAP_PIXEL_FORMAT_ARGB8888, pTempBitmap);
 713                 SysTryReturnVoidResult(NID_UI_CTRL, r == E_SUCCESS, r, "[%s] Propagating.", GetErrorMessage(r));
 714                 if (__pTextSoftkeyNormalEffectBitmap[_SOFTKEY_0])
 715                 {
 716                         delete __pTextSoftkeyNormalEffectBitmap[_SOFTKEY_0];
 717                         __pTextSoftkeyNormalEffectBitmap[_SOFTKEY_0] = null;
 718                 }
 719                 __pTextSoftkeyNormalEffectBitmap[_SOFTKEY_0] = _BitmapImpl::GetColorReplacedBitmapN(*pTempBitmap, Color::GetColor(COLOR_ID_MAGENTA), softkeyNormalBackgroundColor);
 720                 delete pTempBitmap;
 721
 722                 r = GET_BITMAP_CONFIG_N(FOOTER::SOFTKEY_LEFT_BG_EFFECT_PRESSED, BITMAP_PIXEL_FORMAT_ARGB8888, pTempBitmap);
 723                 SysTryReturnVoidResult(NID_UI_CTRL, r == E_SUCCESS, r, "[%s] Propagating.", GetErrorMessage(r));
 724                 if (__pSoftkeyPressedEffectBitmap[_SOFTKEY_0])
 725                 {
 726                         delete __pSoftkeyPressedEffectBitmap[_SOFTKEY_0];
 727                         __pSoftkeyPressedEffectBitmap[_SOFTKEY_0] = null;
 728                 }
 729                 __pSoftkeyPressedEffectBitmap[_SOFTKEY_0] = _BitmapImpl::GetColorReplacedBitmapN(*pTempBitmap, Color::GetColor(COLOR_ID_MAGENTA), softkeyPressedBackgroundColor);
 730                 delete pTempBitmap;
 731
 732                 r = GET_BITMAP_CONFIG_N(FOOTER::SOFTKEY_LEFT_TEXT_BG_EFFECT_PRESSED, BITMAP_PIXEL_FORMAT_ARGB8888, pTempBitmap);
 733                 SysTryReturnVoidResult(NID_UI_CTRL, r == E_SUCCESS, r, "[%s] Propagating.", GetErrorMessage(r));
 734                 if (__pTextSoftkeyPressedEffectBitmap[_SOFTKEY_0])
 735                 {
 736                         delete __pTextSoftkeyPressedEffectBitmap[_SOFTKEY_0];
 737                         __pTextSoftkeyPressedEffectBitmap[_SOFTKEY_0] = null;
 738                 }
 739                 __pTextSoftkeyPressedEffectBitmap[_SOFTKEY_0] = _BitmapImpl::GetColorReplacedBitmapN(*pTempBitmap, Color::GetColor(COLOR_ID_MAGENTA), softkeyPressedBackgroundColor);
 740                 delete pTempBitmap;
 741
 742                 r = GET_BITMAP_CONFIG_N(FOOTER::SOFTKEY_ICON_ADD_NORMAL, BITMAP_PIXEL_FORMAT_ARGB8888, pTempBitmap);
 743                 SysTryReturnVoidResult(NID_UI_CTRL, r == E_SUCCESS, r, "[%s] Propagating.", GetErrorMessage(r));
 744
 745                 if (__pSoftkeyNormalIcon[_SOFTKEY_0])
 746                 {
 747                         delete __pSoftkeyNormalIcon[_SOFTKEY_0];
 748                         __pSoftkeyNormalIcon[_SOFTKEY_0] = null;
 749                 }
 750                 __pSoftkeyNormalIcon[_SOFTKEY_0] = _BitmapImpl::GetColorReplacedBitmapN(*pTempBitmap, Color::GetColor(COLOR_ID_MAGENTA), softkeyNormalIconColor);
 751
 752                 if (__pSoftkeyPressedIcon[_SOFTKEY_0])
 753                 {
 754                         delete __pSoftkeyPressedIcon[_SOFTKEY_0];
 755                         __pSoftkeyPressedIcon[_SOFTKEY_0] = null;
 756                 }
 757                 __pSoftkeyPressedIcon[_SOFTKEY_0] = _BitmapImpl::GetColorReplacedBitmapN(*pTempBitmap, Color::GetColor(COLOR_ID_MAGENTA), softkeyPressedIconColor);
 758
 759                 delete pTempBitmap;
 760
 761                 _Button* pButton = _Button::CreateButtonN();
 762
 763                 if (pButton)
 764                 {
 765                         pButton->SetSize(softkeyDimension);
 766                         pButton->SetTextSize(fontSize);
 767                         pButton->SetMultilineTextSize(multilineFontSize);
 768                         pButton->SetUserDefinedTextArea(FloatRectangle(leftSoftkeyLeftMargin, softkeyTopMargin, softkeyDisplayDimension.width, softkeyDisplayDimension.height));
 769                         pButton->SetTextColor(_BUTTON_STATUS_NORMAL, softkeyNormalTextColor);
 770                         pButton->SetTextColor(_BUTTON_STATUS_PRESSED, softkeyPressedTextColor);
 771                         __pFooter->SetButton(LEFT_BUTTON, pButton);
 772                 }
 773         }
 774
 775         if (formStyle & FORM_STYLE_SOFTKEY_1)
 776         {
 777                 r = GET_BITMAP_CONFIG_N(FOOTER::SOFTKEY_RIGHT_BG_NORMAL, BITMAP_PIXEL_FORMAT_ARGB8888, pTempBitmap);
 778                 SysTryReturnVoidResult(NID_UI_CTRL, r == E_SUCCESS, r, "[%s] Propagating.", GetErrorMessage(r));
 779                 if (__pSoftkeyNormalBitmap[_SOFTKEY_1])
 780                 {
 781                         delete __pSoftkeyNormalBitmap[_SOFTKEY_1];
 782                         __pSoftkeyNormalBitmap[_SOFTKEY_1] = null;
 783                 }
 784                 __pSoftkeyNormalBitmap[_SOFTKEY_1] = _BitmapImpl::GetColorReplacedBitmapN(*pTempBitmap, Color::GetColor(COLOR_ID_MAGENTA), softkeyNormalBackgroundColor);
 785                 delete pTempBitmap;
 786
 787                 r = GET_BITMAP_CONFIG_N(FOOTER::SOFTKEY_RIGHT_TEXT_BG_NORMAL, BITMAP_PIXEL_FORMAT_ARGB8888, pTempBitmap);
 788                 SysTryReturnVoidResult(NID_UI_CTRL, r == E_SUCCESS, r, "[%s] Propagating.", GetErrorMessage(r));
 789                 if (__pTextSoftkeyNormalBitmap[_SOFTKEY_1])
 790                 {
 791                         delete __pTextSoftkeyNormalBitmap[_SOFTKEY_1];
 792                         __pTextSoftkeyNormalBitmap[_SOFTKEY_1] = null;
 793                 }
 794                 __pTextSoftkeyNormalBitmap[_SOFTKEY_1] = _BitmapImpl::GetColorReplacedBitmapN(*pTempBitmap, Color::GetColor(COLOR_ID_MAGENTA), softkeyNormalBackgroundColor);
 795                 delete pTempBitmap;
 796
 797                 r = GET_BITMAP_CONFIG_N(FOOTER::SOFTKEY_RIGHT_BG_PRESSED, BITMAP_PIXEL_FORMAT_ARGB8888, pTempBitmap);
 798                 SysTryReturnVoidResult(NID_UI_CTRL, r == E_SUCCESS, r, "[%s] Propagating.", GetErrorMessage(r));
 799                 if (__pSoftkeyPressedBitmap[_SOFTKEY_1])
 800                 {
 801                         delete __pSoftkeyPressedBitmap[_SOFTKEY_1];
 802                         __pSoftkeyPressedBitmap[_SOFTKEY_1] = null;
 803                 }
 804                 __pSoftkeyPressedBitmap[_SOFTKEY_1] = _BitmapImpl::GetColorReplacedBitmapN(*pTempBitmap, Color::GetColor(COLOR_ID_MAGENTA), softkeyPressedBackgroundColor);
 805                 delete pTempBitmap;
 806
 807                 r = GET_BITMAP_CONFIG_N(FOOTER::SOFTKEY_RIGHT_TEXT_BG_PRESSED, BITMAP_PIXEL_FORMAT_ARGB8888, pTempBitmap);
 808                 SysTryReturnVoidResult(NID_UI_CTRL, r == E_SUCCESS, r, "[%s] Propagating.", GetErrorMessage(r));
 809                 if (__pTextSoftkeyPressedBitmap[_SOFTKEY_1])
 810                 {
 811                         delete __pTextSoftkeyPressedBitmap[_SOFTKEY_1];
 812                         __pTextSoftkeyPressedBitmap[_SOFTKEY_1] = null;
 813                 }
 814                 __pTextSoftkeyPressedBitmap[_SOFTKEY_1] = _BitmapImpl::GetColorReplacedBitmapN(*pTempBitmap, Color::GetColor(COLOR_ID_MAGENTA), softkeyPressedBackgroundColor);
 815                 delete pTempBitmap;
 816
 817                 r = GET_BITMAP_CONFIG_N(FOOTER::SOFTKEY_RIGHT_BG_EFFECT_NORMAL, BITMAP_PIXEL_FORMAT_ARGB8888, pTempBitmap);
 818                 SysTryReturnVoidResult(NID_UI_CTRL, r == E_SUCCESS, r, "[%s] Propagating.", GetErrorMessage(r));
 819                 if (__pSoftkeyNormalEffectBitmap[_SOFTKEY_1])
 820                 {
 821                         delete __pSoftkeyNormalEffectBitmap[_SOFTKEY_1];
 822                         __pSoftkeyNormalEffectBitmap[_SOFTKEY_1] = null;
 823                 }
 824                 __pSoftkeyNormalEffectBitmap[_SOFTKEY_1] = _BitmapImpl::GetColorReplacedBitmapN(*pTempBitmap, Color::GetColor(COLOR_ID_MAGENTA), softkeyNormalBackgroundColor);
 825                 delete pTempBitmap;
 826
 827                 r = GET_BITMAP_CONFIG_N(FOOTER::SOFTKEY_RIGHT_TEXT_BG_EFFECT_NORMAL, BITMAP_PIXEL_FORMAT_ARGB8888, pTempBitmap);
 828                 SysTryReturnVoidResult(NID_UI_CTRL, r == E_SUCCESS, r, "[%s] Propagating.", GetErrorMessage(r));
 829                 if (__pTextSoftkeyNormalEffectBitmap[_SOFTKEY_1])
 830                 {
 831                         delete __pTextSoftkeyNormalEffectBitmap[_SOFTKEY_1];
 832                         __pTextSoftkeyNormalEffectBitmap[_SOFTKEY_1] = null;
 833                 }
 834                 __pTextSoftkeyNormalEffectBitmap[_SOFTKEY_1] = _BitmapImpl::GetColorReplacedBitmapN(*pTempBitmap, Color::GetColor(COLOR_ID_MAGENTA), softkeyNormalBackgroundColor);
 835                 delete pTempBitmap;
 836
 837                 r = GET_BITMAP_CONFIG_N(FOOTER::SOFTKEY_RIGHT_BG_EFFECT_PRESSED, BITMAP_PIXEL_FORMAT_ARGB8888, pTempBitmap);
 838                 SysTryReturnVoidResult(NID_UI_CTRL, r == E_SUCCESS, r, "[%s] Propagating.", GetErrorMessage(r));
 839                 if (__pSoftkeyPressedEffectBitmap[_SOFTKEY_1])
 840                 {
 841                         delete __pSoftkeyPressedEffectBitmap[_SOFTKEY_1];
 842                         __pSoftkeyPressedEffectBitmap[_SOFTKEY_1] = null;
 843                 }
 844                 __pSoftkeyPressedEffectBitmap[_SOFTKEY_1] = _BitmapImpl::GetColorReplacedBitmapN(*pTempBitmap, Color::GetColor(COLOR_ID_MAGENTA), softkeyPressedBackgroundColor);
 845                 delete pTempBitmap;
 846
 847                 r = GET_BITMAP_CONFIG_N(FOOTER::SOFTKEY_RIGHT_TEXT_BG_EFFECT_PRESSED, BITMAP_PIXEL_FORMAT_ARGB8888, pTempBitmap);
 848                 SysTryReturnVoidResult(NID_UI_CTRL, r == E_SUCCESS, r, "[%s] Propagating.", GetErrorMessage(r));
 849                 if (__pTextSoftkeyPressedEffectBitmap[_SOFTKEY_1])
 850                 {
 851                         delete __pTextSoftkeyPressedEffectBitmap[_SOFTKEY_1];
 852                         __pTextSoftkeyPressedEffectBitmap[_SOFTKEY_1] = null;
 853                 }
 854                 __pTextSoftkeyPressedEffectBitmap[_SOFTKEY_1] = _BitmapImpl::GetColorReplacedBitmapN(*pTempBitmap, Color::GetColor(COLOR_ID_MAGENTA), softkeyPressedBackgroundColor);
 855                 delete pTempBitmap;
 856
 857                 r = GET_BITMAP_CONFIG_N(FOOTER::SOFTKEY_ICON_ZOOM_NORMAL, BITMAP_PIXEL_FORMAT_ARGB8888, pTempBitmap);
 858                 SysTryReturnVoidResult(NID_UI_CTRL, r == E_SUCCESS, r, "[%s] Propagating.", GetErrorMessage(r));
 859
 860                 if (__pSoftkeyNormalIcon[_SOFTKEY_1])
 861                 {
 862                         delete __pSoftkeyNormalIcon[_SOFTKEY_1];
 863                         __pSoftkeyNormalIcon[_SOFTKEY_1] = null;
 864                 }
 865                 __pSoftkeyNormalIcon[_SOFTKEY_1] = _BitmapImpl::GetColorReplacedBitmapN(*pTempBitmap, Color::GetColor(COLOR_ID_MAGENTA), softkeyNormalIconColor);
 866
 867                 if (__pSoftkeyPressedIcon[_SOFTKEY_1])
 868                 {
 869                         delete __pSoftkeyPressedIcon[_SOFTKEY_1];
 870                         __pSoftkeyPressedIcon[_SOFTKEY_1] = null;
 871                 }
 872                 __pSoftkeyPressedIcon[_SOFTKEY_1] = _BitmapImpl::GetColorReplacedBitmapN(*pTempBitmap, Color::GetColor(COLOR_ID_MAGENTA), softkeyPressedIconColor);
 873
 874                 delete pTempBitmap;
 875
 876                 _Button* pButton = _Button::CreateButtonN();
 877                 if (pButton)
 878                 {
 879                         pButton->SetSize(softkeyDimension);
 880                         pButton->SetTextSize(fontSize);
 881                         pButton->SetMultilineTextSize(multilineFontSize);
 882                         pButton->SetUserDefinedTextArea(FloatRectangle(rightSoftkeyLeftMargin, softkeyTopMargin, softkeyDisplayDimension.width, softkeyDisplayDimension.height));
 883                         pButton->SetTextColor(_BUTTON_STATUS_NORMAL, softkeyNormalTextColor);
 884                         pButton->SetTextColor(_BUTTON_STATUS_PRESSED, softkeyPressedTextColor);
 885                         __pFooter->SetButton(RIGHT_BUTTON, pButton);
 886                 }
 887         }
 888
 889         if (formStyle & FORM_STYLE_OPTIONKEY)
 890         {
 891                 r = GET_BITMAP_CONFIG_N(FOOTER::OPTIONKEY_BG_NORMAL, BITMAP_PIXEL_FORMAT_ARGB8888, pTempBitmap);
 892                 SysTryReturnVoidResult(NID_UI_CTRL, r == E_SUCCESS, r, "[%s] Propagating.", GetErrorMessage(r));
 893                 if (__pSoftkeyNormalBitmap[SOFTKEY_COUNT])
 894                 {
 895                         delete __pSoftkeyNormalBitmap[SOFTKEY_COUNT];
 896                         __pSoftkeyNormalBitmap[SOFTKEY_COUNT] = null;
 897                 }
 898                 __pSoftkeyNormalBitmap[SOFTKEY_COUNT] = _BitmapImpl::GetColorReplacedBitmapN(*pTempBitmap, Color::GetColor(COLOR_ID_MAGENTA), softkeyNormalBackgroundColor);
 899                 delete pTempBitmap;
 900
 901                 r = GET_BITMAP_CONFIG_N(FOOTER::OPTIONKEY_BG_PRESSED, BITMAP_PIXEL_FORMAT_ARGB8888, pTempBitmap);
 902                 SysTryReturnVoidResult(NID_UI_CTRL, r == E_SUCCESS, r, "[%s] Propagating.", GetErrorMessage(r));
 903                 if (__pSoftkeyPressedBitmap[SOFTKEY_COUNT])
 904                 {
 905                         delete __pSoftkeyPressedBitmap[SOFTKEY_COUNT];
 906                         __pSoftkeyPressedBitmap[SOFTKEY_COUNT] = null;
 907                 }
 908                 __pSoftkeyPressedBitmap[SOFTKEY_COUNT] = _BitmapImpl::GetColorReplacedBitmapN(*pTempBitmap, Color::GetColor(COLOR_ID_MAGENTA), softkeyPressedBackgroundColor);
 909                 delete pTempBitmap;
 910
 911                 r = GET_BITMAP_CONFIG_N(FOOTER::OPTIONKEY_BG_EFFECT_NORMAL, BITMAP_PIXEL_FORMAT_ARGB8888, pTempBitmap);
 912                 SysTryReturnVoidResult(NID_UI_CTRL, r == E_SUCCESS, r, "[%s] Propagating.", GetErrorMessage(r));
 913                 if (__pSoftkeyNormalEffectBitmap[SOFTKEY_COUNT])
 914                 {
 915                         delete __pSoftkeyNormalEffectBitmap[SOFTKEY_COUNT];
 916                         __pSoftkeyNormalEffectBitmap[SOFTKEY_COUNT] = null;
 917                 }
 918                 __pSoftkeyNormalEffectBitmap[SOFTKEY_COUNT] = _BitmapImpl::GetColorReplacedBitmapN(*pTempBitmap, Color::GetColor(COLOR_ID_MAGENTA), softkeyNormalBackgroundColor);
 919                 delete pTempBitmap;
 920
 921                 r = GET_BITMAP_CONFIG_N(FOOTER::OPTIONKEY_BG_EFFECT_PRESSED, BITMAP_PIXEL_FORMAT_ARGB8888, pTempBitmap);
 922                 SysTryReturnVoidResult(NID_UI_CTRL, r == E_SUCCESS, r, "[%s] Propagating.", GetErrorMessage(r));
 923                 if (__pSoftkeyPressedEffectBitmap[SOFTKEY_COUNT])
 924                 {
 925                         delete __pSoftkeyPressedEffectBitmap[SOFTKEY_COUNT];
 926                         __pSoftkeyPressedEffectBitmap[SOFTKEY_COUNT] = null;
 927                 }
 928                 __pSoftkeyPressedEffectBitmap[SOFTKEY_COUNT] = _BitmapImpl::GetColorReplacedBitmapN(*pTempBitmap, Color::GetColor(COLOR_ID_MAGENTA), softkeyPressedBackgroundColor);
 929                 delete pTempBitmap;
 930
 931                 r = GET_BITMAP_CONFIG_N(FOOTER::OPTIONKEY_HANDLE_MORE_NORMAL, BITMAP_PIXEL_FORMAT_ARGB8888, pTempBitmap);
 932                 SysTryReturnVoidResult(NID_UI_CTRL, r == E_SUCCESS, r, "[%s] Propagating.", GetErrorMessage(r));
 933
 934                 if (__pSoftkeyNormalIcon[SOFTKEY_COUNT])
 935                 {
 936                         delete __pSoftkeyNormalIcon[SOFTKEY_COUNT];
 937                         __pSoftkeyNormalIcon[SOFTKEY_COUNT] = null;
 938                 }
 939                 __pSoftkeyNormalIcon[SOFTKEY_COUNT] = _BitmapImpl::GetColorReplacedBitmapN(*pTempBitmap, Color::GetColor(COLOR_ID_MAGENTA), softkeyNormalIconColor);
 940                 delete pTempBitmap;
 941
 942                 r = GET_BITMAP_CONFIG_N(FOOTER::OPTIONKEY_HANDLE_MORE_PRESSED, BITMAP_PIXEL_FORMAT_ARGB8888, pTempBitmap);
 943                 SysTryReturnVoidResult(NID_UI_CTRL, r == E_SUCCESS, r, "[%s] Propagating.", GetErrorMessage(r));
 944
 945                 if (__pSoftkeyPressedIcon[SOFTKEY_COUNT])
 946                 {
 947                         delete __pSoftkeyPressedIcon[SOFTKEY_COUNT];
 948                         __pSoftkeyPressedIcon[SOFTKEY_COUNT] = null;
 949                 }
 950                 __pSoftkeyPressedIcon[SOFTKEY_COUNT] = _BitmapImpl::GetColorReplacedBitmapN(*pTempBitmap, Color::GetColor(COLOR_ID_MAGENTA), softkeyPressedIconColor);
 951                 delete pTempBitmap;
 952
 953                 _Button* pButton = _Button::CreateButtonN();
 954                 if (pButton)
 955                 {
 956                         pButton->SetSize(optionkeyDimension);
 957                         pButton->SetTextColor(_BUTTON_STATUS_NORMAL, softkeyNormalTextColor);
 958                         pButton->SetTextColor(_BUTTON_STATUS_PRESSED, softkeyPressedTextColor);
 959                         __pFooter->SetButton(MIDDLE_BUTTON, pButton);
 960                 }
 961         }
 962 }
 963
 964 void
 965 _Form::UpdateSoftkey(unsigned long formStyle)
 966 {
 967         float softkeyIconGap = 3.0f;
 968
 969         if (__formStyle & FORM_STYLE_SOFTKEY_0)// && __updatedSoftkeyCount % 2 == 0)
 970         {
 971                 if (__pFooter->GetButton(LEFT_BUTTON))
 972                 {
 973                         __pFooter->GetButton(LEFT_BUTTON)->SetActionId(__actionId[_SOFTKEY_0]);
 974
 975                         if (__softkeyText[_SOFTKEY_0] != String())
 976                         {
 977                                 if (__pTextSoftkeyNormalBitmap[_SOFTKEY_0])
 978                                 {
 979                                         __pFooter->GetButton(LEFT_BUTTON)->SetBackgroundBitmap(_BUTTON_STATUS_NORMAL, *__pTextSoftkeyNormalBitmap[_SOFTKEY_0]);
 980                                 }
 981
 982                                 if (__pTextSoftkeyNormalEffectBitmap[_SOFTKEY_0])
 983                                 {
 984                                         __pFooter->GetButton(LEFT_BUTTON)->SetBackgroundEffectBitmap(_BUTTON_STATUS_NORMAL, *__pTextSoftkeyNormalEffectBitmap[_SOFTKEY_0]);
 985                                 }
 986
 987                                 if (__pTextSoftkeyPressedBitmap[_SOFTKEY_0])
 988                                 {
 989                                         __pFooter->GetButton(LEFT_BUTTON)->SetBackgroundBitmap(_BUTTON_STATUS_PRESSED, *__pTextSoftkeyPressedBitmap[_SOFTKEY_0]);
 990                                 }
 991
 992                                 if (__pTextSoftkeyPressedEffectBitmap[_SOFTKEY_0])
 993                                 {
 994                                         __pFooter->GetButton(LEFT_BUTTON)->SetBackgroundEffectBitmap(_BUTTON_STATUS_PRESSED, *__pTextSoftkeyPressedEffectBitmap[_SOFTKEY_0]);
 995                                 }
 996
 997                                 __pFooter->GetButton(LEFT_BUTTON)->SetText(__softkeyText[_SOFTKEY_0]);
 998
 999                                 __pFooter->RearrangeItems();
1000                         }
1001                         else
1002                         {
1003                                 if (__pSoftkeyNormalBitmap[_SOFTKEY_0])
1004                                 {
1005                                         __pFooter->GetButton(LEFT_BUTTON)->SetBackgroundBitmap(_BUTTON_STATUS_NORMAL, *__pSoftkeyNormalBitmap[_SOFTKEY_0]);
1006                                 }
1007
1008                                 if (__pSoftkeyNormalEffectBitmap[_SOFTKEY_0])
1009                                 {
1010                                         __pFooter->GetButton(LEFT_BUTTON)->SetBackgroundEffectBitmap(_BUTTON_STATUS_NORMAL, *__pSoftkeyNormalEffectBitmap[_SOFTKEY_0]);
1011                                 }
1012
1013                                 if (__pSoftkeyPressedBitmap[_SOFTKEY_0])
1014                                 {
1015                                         __pFooter->GetButton(LEFT_BUTTON)->SetBackgroundBitmap(_BUTTON_STATUS_PRESSED, *__pSoftkeyPressedBitmap[_SOFTKEY_0]);
1016                                 }
1017
1018                                 if (__pSoftkeyPressedEffectBitmap[_SOFTKEY_0])
1019                                 {
1020                                         __pFooter->GetButton(LEFT_BUTTON)->SetBackgroundEffectBitmap(_BUTTON_STATUS_PRESSED, *__pSoftkeyPressedEffectBitmap[_SOFTKEY_0]);
1021                                 }
1022
1023                                 if (__pSoftkeyNormalIcon[_SOFTKEY_0])
1024                                 {
1025                                         __pFooter->GetButton(LEFT_BUTTON)->SetBitmap(_BUTTON_STATUS_NORMAL,
1026                                                         FloatPoint((__pFooter->GetButton(LEFT_BUTTON)->GetSizeF().width - __pSoftkeyNormalIcon[_SOFTKEY_0]->GetWidthF()) / 2,
1027                                                                         (__pFooter->GetButton(LEFT_BUTTON)->GetSizeF().height - __pSoftkeyNormalIcon[_SOFTKEY_0]->GetHeightF()) / 2 + softkeyIconGap), *__pSoftkeyNormalIcon[_SOFTKEY_0]);
1028                                 }
1029
1030                                 if (__pSoftkeyPressedIcon[_SOFTKEY_0])
1031                                 {
1032                                         __pFooter->GetButton(LEFT_BUTTON)->SetBitmap(_BUTTON_STATUS_PRESSED,
1033                                                         FloatPoint((__pFooter->GetButton(LEFT_BUTTON)->GetSizeF().width - __pSoftkeyPressedIcon[_SOFTKEY_0]->GetWidthF()) / 2,
1034                                                                         (__pFooter->GetButton(LEFT_BUTTON)->GetSizeF().height - __pSoftkeyPressedIcon[_SOFTKEY_0]->GetHeightF()) / 2 + softkeyIconGap), *__pSoftkeyPressedIcon[_SOFTKEY_0]);
1035                                 }
1036                         }
1037                 }
1038         }
1039
1040         if (__formStyle & FORM_STYLE_SOFTKEY_1)// && __updatedSoftkeyCount % 2 == 0)
1041         {
1042                 if (__pFooter->GetButton(RIGHT_BUTTON))
1043                 {
1044                         __pFooter->GetButton(RIGHT_BUTTON)->SetActionId(__actionId[_SOFTKEY_1]);
1045
1046                         if (__softkeyText[_SOFTKEY_1] != String())
1047                         {
1048                                 if (__pTextSoftkeyNormalBitmap[_SOFTKEY_1])
1049                                 {
1050                                         __pFooter->GetButton(RIGHT_BUTTON)->SetBackgroundBitmap(_BUTTON_STATUS_NORMAL, *__pTextSoftkeyNormalBitmap[_SOFTKEY_1]);
1051                                 }
1052
1053                                 if (__pTextSoftkeyNormalEffectBitmap[_SOFTKEY_1])
1054                                 {
1055                                         __pFooter->GetButton(RIGHT_BUTTON)->SetBackgroundEffectBitmap(_BUTTON_STATUS_NORMAL, *__pTextSoftkeyNormalEffectBitmap[_SOFTKEY_1]);
1056                                 }
1057
1058                                 if (__pTextSoftkeyPressedBitmap[_SOFTKEY_1])
1059                                 {
1060                                         __pFooter->GetButton(RIGHT_BUTTON)->SetBackgroundBitmap(_BUTTON_STATUS_PRESSED, *__pTextSoftkeyPressedBitmap[_SOFTKEY_1]);
1061                                 }
1062
1063                                 if (__pTextSoftkeyPressedEffectBitmap[_SOFTKEY_1])
1064                                 {
1065                                         __pFooter->GetButton(RIGHT_BUTTON)->SetBackgroundEffectBitmap(_BUTTON_STATUS_PRESSED, *__pTextSoftkeyPressedEffectBitmap[_SOFTKEY_1]);
1066                                 }
1067
1068                                 __pFooter->GetButton(RIGHT_BUTTON)->SetText(__softkeyText[_SOFTKEY_1]);
1069
1070                                 __pFooter->RearrangeItems();
1071                         }
1072                         else
1073                         {
1074                                 if (__pSoftkeyNormalBitmap[_SOFTKEY_1])
1075                                 {
1076                                         __pFooter->GetButton(RIGHT_BUTTON)->SetBackgroundBitmap(_BUTTON_STATUS_NORMAL, *__pSoftkeyNormalBitmap[_SOFTKEY_1]);
1077                                 }
1078
1079                                 if (__pSoftkeyNormalEffectBitmap[_SOFTKEY_1])
1080                                 {
1081                                         __pFooter->GetButton(RIGHT_BUTTON)->SetBackgroundEffectBitmap(_BUTTON_STATUS_NORMAL, *__pSoftkeyNormalEffectBitmap[_SOFTKEY_1]);
1082                                 }
1083
1084                                 if (__pSoftkeyPressedBitmap[_SOFTKEY_1])
1085                                 {
1086                                         __pFooter->GetButton(RIGHT_BUTTON)->SetBackgroundBitmap(_BUTTON_STATUS_PRESSED, *__pSoftkeyPressedBitmap[_SOFTKEY_1]);
1087                                 }
1088
1089                                 if (__pSoftkeyPressedEffectBitmap[_SOFTKEY_1])
1090                                 {
1091                                         __pFooter->GetButton(RIGHT_BUTTON)->SetBackgroundEffectBitmap(_BUTTON_STATUS_PRESSED, *__pSoftkeyPressedEffectBitmap[_SOFTKEY_1]);
1092                                 }
1093
1094                                 if (__pSoftkeyNormalIcon[_SOFTKEY_1])
1095                                 {
1096                                         __pFooter->GetButton(RIGHT_BUTTON)->SetBitmap(_BUTTON_STATUS_NORMAL,
1097                                                         FloatPoint((__pFooter->GetButton(RIGHT_BUTTON)->GetSizeF().width - __pSoftkeyNormalIcon[_SOFTKEY_1]->GetWidthF()) / 2,
1098                                                                         (__pFooter->GetButton(RIGHT_BUTTON)->GetSizeF().height - __pSoftkeyNormalIcon[_SOFTKEY_1]->GetHeightF()) / 2 + softkeyIconGap), *__pSoftkeyNormalIcon[_SOFTKEY_1]);
1099                                 }
1100
1101                                 if (__pSoftkeyPressedIcon[_SOFTKEY_1])
1102                                 {
1103                                         __pFooter->GetButton(RIGHT_BUTTON)->SetBitmap(_BUTTON_STATUS_PRESSED,
1104                                                         FloatPoint((__pFooter->GetButton(RIGHT_BUTTON)->GetSizeF().width - __pSoftkeyPressedIcon[_SOFTKEY_1]->GetWidthF()) / 2,
1105                                                                         (__pFooter->GetButton(RIGHT_BUTTON)->GetSizeF().height - __pSoftkeyPressedIcon[_SOFTKEY_1]->GetHeightF()) / 2 + softkeyIconGap), *__pSoftkeyPressedIcon[_SOFTKEY_1]);
1106                                 }
1107                         }
1108                 }
1109         }
1110
1111         if (__formStyle & FORM_STYLE_OPTIONKEY)// && __updatedSoftkeyCount % 2 == 0)
1112         {
1113                 if (__pFooter->GetButton(MIDDLE_BUTTON))
1114                 {
1115                         __pFooter->GetButton(MIDDLE_BUTTON)->SetActionId(__actionId[SOFTKEY_COUNT]);
1116
1117                         if (__pSoftkeyNormalBitmap[SOFTKEY_COUNT])
1118                         {
1119                                 __pFooter->GetButton(MIDDLE_BUTTON)->SetBackgroundBitmap(_BUTTON_STATUS_NORMAL, *__pSoftkeyNormalBitmap[SOFTKEY_COUNT]);
1120                         }
1121
1122                         if (__pSoftkeyPressedBitmap[SOFTKEY_COUNT])
1123                         {
1124                                 __pFooter->GetButton(MIDDLE_BUTTON)->SetBackgroundBitmap(_BUTTON_STATUS_PRESSED, *__pSoftkeyPressedBitmap[SOFTKEY_COUNT]);
1125                         }
1126
1127                         if (__pSoftkeyNormalEffectBitmap[SOFTKEY_COUNT])
1128                         {
1129                                 __pFooter->GetButton(MIDDLE_BUTTON)->SetBackgroundEffectBitmap(_BUTTON_STATUS_NORMAL, *__pSoftkeyNormalEffectBitmap[SOFTKEY_COUNT]);
1130                         }
1131
1132                         if (__pSoftkeyPressedEffectBitmap[SOFTKEY_COUNT])
1133                         {
1134                                 __pFooter->GetButton(MIDDLE_BUTTON)->SetBackgroundEffectBitmap(_BUTTON_STATUS_PRESSED, *__pSoftkeyPressedEffectBitmap[SOFTKEY_COUNT]);
1135                         }
1136
1137                         if (__pSoftkeyNormalIcon[SOFTKEY_COUNT])
1138                         {
1139                                 __pFooter->GetButton(MIDDLE_BUTTON)->SetBitmap(_BUTTON_STATUS_NORMAL, FloatPoint(0.0f, 0.0f), *__pSoftkeyNormalIcon[SOFTKEY_COUNT]);
1140                         }
1141
1142                         if (__pSoftkeyPressedIcon[SOFTKEY_COUNT])
1143                         {
1144                                 __pFooter->GetButton(MIDDLE_BUTTON)->SetBitmap(_BUTTON_STATUS_PRESSED, FloatPoint(0.0f, 0.0f), *__pSoftkeyPressedIcon[SOFTKEY_COUNT]);
1145                         }
1146                 }
1147         }
1148
1149         //__updatedSoftkeyCount++;
1150 }
1151
1152 String
1153 _Form::GetDescription(void) const
1154 {
1155         String description = _Control::GetDescription();
1156
1157         String descriptionTemp(L"");
1158
1159         descriptionTemp.Format(LOG_LEN_MAX, L"_Form: style(%d) transparent(%d %d %d %d) deflated(%d) deflatedHeight(%d) overlayRegionCount(%d) softkeyCount(%d) updatedSoftkeyCount(%d)",
1160                 __formStyle, __transparentIndicator, __transparentHeader, __transparentFooter, __transparentTab, __deflated, __deflatedHeight,
1161                 __overlayRegionCount, __softkeyCount, __updatedSoftkeyCount);
1162
1163         description.Append(descriptionTemp);
1164
1165         return description;
1166 }
1167
1168 Canvas*
1169 _Form::GetClientAreaCanvasN(void) const
1170 {
1171         Canvas* pCanvas = GetCanvasN(GetClientBounds());
1172         if ((pCanvas == null) || (GetLastResult() != E_SUCCESS))
1173         {
1174                 SysLog(NID_UI_CTRL, "[%s] Propagated.", GetErrorMessage(GetLastResult()));
1175                 delete pCanvas;
1176                 return null;
1177         }
1178
1179         return pCanvas;
1180 }
1181
1182 int
1183 _Form::GetSoftkeyActionId(_Softkey softkey) const
1184 {
1185         if (CheckSoftkey(softkey) == false)
1186         {
1187                 return -1;
1188         }
1189
1190         return __actionId[softkey];
1191 }
1192
1193 int
1194 _Form::GetOptionkeyActionId(void) const
1195 {
1196         if (HasOptionkey() == false)
1197         {
1198                 return -1;
1199         }
1200
1201         return __actionId[SOFTKEY_COUNT];
1202 }
1203
1204 String
1205 _Form::GetSoftkeyText(_Softkey softkey) const
1206 {
1207         if (CheckSoftkey(softkey) == false)
1208         {
1209                 return String(L"");
1210         }
1211
1212         return __softkeyText[softkey];
1213 }
1214
1215 void
1216 _Form::SetFormStyle(unsigned long formStyle)
1217 {
1218         result r = E_SUCCESS;
1219
1220         __formStyle = formStyle;
1221
1222         if (!__pIndicator)
1223         {
1224                 __pIndicator = CreateIndicatorN();
1225                 SysTryReturnVoidResult(NID_UI_CTRL, __pIndicator != null, r, "[%s] Propagating.", GetErrorMessage(r));
1226
1227                 float indicatorwidth = GetClientBoundsF().width;
1228                 float indicatorheight = 0.0f;
1229
1230                 GET_SHAPE_CONFIG(FORM::INDICATOR_HEIGHT, GetOrientation(), indicatorheight);
1231
1232                 __pIndicator->SetBounds(FloatRectangle(0.0f, 0.0f, indicatorwidth, indicatorheight));
1233
1234                 r = GetLastResult();
1235                 SysTryReturnVoidResult(NID_UI_CTRL, r == E_SUCCESS, r, "[%s] Propagating.", GetErrorMessage(r));
1236         }
1237 }
1238
1239 result
1240 _Form::SetActionBarsTranslucent(unsigned long actionBars, bool translucent)
1241 {
1242         SysTryReturn(
1243                         NID_UI_CTRL,
1244                         ((actionBars & FORM_ACTION_BAR_INDICATOR) || (actionBars & FORM_ACTION_BAR_HEADER) ||
1245                                         (actionBars & FORM_ACTION_BAR_FOOTER) || (actionBars & FORM_ACTION_BAR_TAB)),
1246                                         E_INVALID_OPERATION, E_INVALID_OPERATION,
1247                                         ("[E_INVALID_OPERATION] The current state of the instance prohibits the execution of the specified operation."));
1248
1249         if ((!(__formStyle & FORM_STYLE_INDICATOR) && (actionBars & FORM_ACTION_BAR_INDICATOR))
1250                 || (!(__formStyle & FORM_STYLE_HEADER) && (actionBars & FORM_ACTION_BAR_HEADER))
1251                 || (!(__formStyle & FORM_STYLE_FOOTER) && (actionBars & FORM_ACTION_BAR_FOOTER))
1252                 || (!(__formStyle & FORM_STYLE_TEXT_TAB) && (actionBars & FORM_ACTION_BAR_TAB)))
1253         {
1254                 SysLog(NID_UI_CTRL,
1255                         "[E_INVALID_OPERATION] The current state of the instance prohibits the execution of the specified operation.");
1256                 return E_INVALID_OPERATION;
1257         }
1258
1259         result r = E_SUCCESS;
1260
1261         Color bgColor(0, 0, 0, 0);
1262         if (actionBars & FORM_ACTION_BAR_INDICATOR)
1263         {
1264                 if (translucent)
1265                 {
1266                         r = SetIndicatorOpacity(_INDICATOR_OPACITY_TRANSLUCENT);
1267                 }
1268                 else
1269                 {
1270                         r = SetIndicatorOpacity(_INDICATOR_OPACITY_OPAQUE);
1271                 }
1272                 SysTryReturn(NID_UI_CTRL, r == E_SUCCESS, r, r, "[%s] Propagating.", GetErrorMessage(r));
1273         }
1274
1275         if (actionBars & FORM_ACTION_BAR_HEADER)
1276         {
1277                 if (IsHeaderTranslucent() != translucent)
1278                 {
1279                         if (__pHeader)
1280                         {
1281                                 __pHeader->SetTransparent(translucent);
1282                                 __transparentHeader = translucent;
1283                         }
1284                 }
1285         }
1286
1287         if (IsHeaderVisible())
1288         {
1289                 if (IsIndicatorTranslucent() != IsHeaderTranslucent())
1290                 {
1291                         if (IsIndicatorTranslucent())
1292                         {
1293                                 FloatRectangle bounds(0.0f, 0.0f, GetClientBoundsF().width, __pHeader->GetBoundsF().height);
1294                                 SetHeaderBounds(bounds);
1295                         }
1296                         else
1297                         {
1298                                 FloatRectangle bounds(0.0f, GetIndicatorBoundsF().height, GetClientBoundsF().width, __pHeader->GetBoundsF().height);
1299                                 SetHeaderBounds(bounds);
1300                         }
1301                 }
1302                 else if (!IsIndicatorTranslucent() && !IsHeaderTranslucent())
1303                 {
1304                                 FloatRectangle bounds(0.0f, GetIndicatorBoundsF().height, GetClientBoundsF().width, __pHeader->GetBoundsF().height);
1305                                 SetHeaderBounds(bounds);
1306                 }
1307                 else
1308                 {
1309                         if (GetOrientation() == _CONTROL_ORIENTATION_PORTRAIT)
1310                         {
1311                                 FloatRectangle bounds(0.0f, GetIndicatorBoundsF().height, GetClientBoundsF().width, __pHeader->GetBoundsF().height);
1312                                 SetHeaderBounds(bounds);
1313                         }
1314                         else
1315                         {
1316                                 FloatRectangle bounds(0.0f, 0.0f, GetClientBoundsF().width, __pHeader->GetBoundsF().height);
1317                                 SetHeaderBounds(bounds);
1318                         }
1319                 }
1320         }
1321
1322         if (actionBars & FORM_ACTION_BAR_FOOTER)
1323         {
1324                 if (IsFooterTranslucent() != translucent)
1325                 {
1326                         if (__pFooter)
1327                         {
1328                                 __pFooter->SetTransparent(translucent);
1329                                 __transparentFooter = translucent;
1330                         }
1331                 }
1332         }
1333
1334         AdjustClientBounds();
1335
1336         return E_SUCCESS;
1337 }
1338
1339 result
1340 _Form::SetActionBarsVisible(unsigned long actionBars, bool visible)
1341 {
1342         SysTryReturn(
1343                 NID_UI_CTRL,
1344                 ((actionBars & FORM_ACTION_BAR_INDICATOR) || (actionBars & FORM_ACTION_BAR_HEADER) ||
1345                  (actionBars & FORM_ACTION_BAR_FOOTER)),
1346                 E_INVALID_OPERATION,
1347                 E_INVALID_OPERATION,
1348                 ("[E_INVALID_OPERATION] The current state of the instance prohibits the execution of the specified operation. "));
1349
1350         if ((!(__formStyle & FORM_STYLE_INDICATOR) && (actionBars & FORM_ACTION_BAR_INDICATOR))
1351                 || (!(__formStyle & FORM_STYLE_HEADER) && (actionBars & FORM_ACTION_BAR_HEADER))
1352                 || (!(__formStyle & FORM_STYLE_FOOTER) && (actionBars & FORM_ACTION_BAR_FOOTER)))
1353         {
1354                 SysLog(NID_UI_CTRL, "[E_INVALID_OPERATION] The current state of the instance prohibits the execution of the specified operation.");
1355                 return E_INVALID_OPERATION;
1356         }
1357
1358         FloatRectangle bounds = GetBoundsF();
1359         SetBounds(bounds);
1360
1361         if (actionBars & FORM_ACTION_BAR_INDICATOR)
1362         {
1363                 SetIndicatorShowState(visible);
1364         }
1365
1366         if (actionBars & FORM_ACTION_BAR_HEADER)
1367         {
1368                 if (IsHeaderVisible() != visible)
1369                 {
1370                         if (__pHeader)
1371                         {
1372                                 if (visible == true)
1373                                 {
1374                                         float adjHeight = 0.0f;
1375                                         if (IsIndicatorVisible())
1376                                         {
1377                                                 FloatRectangle indicatorBounds = GetIndicatorBoundsF();
1378                                                 adjHeight = indicatorBounds.height;
1379
1380                                                 if (IsIndicatorTranslucent())
1381                                                 {
1382                                                         if (!IsHeaderTranslucent())
1383                                                         {
1384                                                                 adjHeight = 0.0f;
1385                                                         }
1386                                                         else
1387                                                         {
1388                                                                 if (GetOrientation() == _CONTROL_ORIENTATION_LANDSCAPE)
1389                                                                 {
1390                                                                         adjHeight = 0.0f;
1391                                                                 }
1392                                                         }
1393                                                 }
1394                                         }
1395                                         FloatRectangle bounds = __pHeader->GetBoundsF();
1396                                         bounds.y = adjHeight;
1397
1398                                         SetHeaderBounds(bounds);
1399                                 }
1400                                 __pHeader->SetVisibleState(visible);
1401                         }
1402                 }
1403         }
1404
1405         if (actionBars & FORM_ACTION_BAR_FOOTER)
1406         {
1407                 if (__pFooter)
1408                 {
1409                         __pFooter->SetVisibleState(visible);
1410                 }
1411         }
1412
1413         AdjustClientBounds();
1414
1415         return E_SUCCESS;
1416 }
1417
1418 result
1419 _Form::SetTitleIcon(const Bitmap* pTitleBitmap)
1420 {
1421         SysTryReturn(NID_UI_CTRL, (__formStyle & FORM_STYLE_TITLE), E_INVALID_OPERATION,
1422                         E_INVALID_OPERATION, "[E_INVALID_OPERATION] This API is only for FORM_STYLE_TITLE.");
1423
1424         SysTryReturn(NID_UI_CTRL, __pHeader, E_INVALID_STATE, E_INVALID_STATE, "[E_INVALID_STATE] The title is not valid.");
1425
1426         result r = __pHeader->SetTitleIcon(*pTitleBitmap);
1427         SysTryReturn(NID_UI_CTRL, r == E_SUCCESS, r, r, "[%s] Propagating.", GetErrorMessage(r));
1428
1429         return r;
1430 }
1431
1432 result
1433 _Form::SetTitleText(const String& title, HorizontalAlignment alignment)
1434 {
1435         SysTryReturn(NID_UI_CTRL, (__formStyle & FORM_STYLE_TITLE), E_INVALID_OPERATION,
1436                                 E_INVALID_OPERATION, "[E_INVALID_OPERATION] This API is only for FORM_STYLE_TITLE.");
1437
1438         SysTryReturn(NID_UI_CTRL, __pHeader, E_INVALID_STATE, E_INVALID_STATE, "[E_INVALID_STATE] The title is not valid.");
1439
1440         result r = __pHeader->SetTitleText(title, alignment);
1441         SysTryReturn(NID_UI_CTRL, r == E_SUCCESS, r, r, "[%s] Propagating.", GetErrorMessage(r));
1442
1443         return r;
1444 }
1445
1446 result
1447 _Form::SetSoftkeyEnabled(_Softkey softkey, bool enable)
1448 {
1449         result r = E_SYSTEM;
1450
1451         if (CheckSoftkey(softkey) == false)
1452         {
1453                 return r;
1454         }
1455
1456         __enableSoftkey[softkey] = enable;
1457
1458         r = E_SUCCESS;
1459
1460         return r;
1461 }
1462
1463 result
1464 _Form::SetOptionkeyActionId(int actionId)
1465 {
1466         result r = E_SYSTEM;
1467
1468         if (HasOptionkey() == false)
1469         {
1470                 return r;
1471         }
1472
1473         __actionId[SOFTKEY_COUNT] = actionId;
1474
1475         r = E_SUCCESS;
1476
1477         return r;
1478 }
1479
1480 result
1481 _Form::SetSoftkeyActionId(_Softkey softkey, int actionId)
1482 {
1483         result r = E_SYSTEM;
1484
1485         if (CheckSoftkey(softkey) == false)
1486         {
1487                 return r;
1488         }
1489
1490         __actionId[softkey] = actionId;
1491
1492         r = E_SUCCESS;
1493
1494         return r;
1495 }
1496
1497 result
1498 _Form::SetSoftkeyText(_Softkey softkey, const String& text)
1499 {
1500         result r = E_SYSTEM;
1501
1502         if (CheckSoftkey(softkey) == false)
1503         {
1504                 return r;
1505         }
1506
1507         __softkeyText[softkey] = text;
1508
1509         r = E_SUCCESS;
1510
1511         return r;
1512 }
1513
1514 result
1515 _Form::SetSoftkeyIcon(_Softkey softkey, const Bitmap& normalBitmap, const Bitmap* pPressedBitmap)
1516 {
1517         result r = E_SYSTEM;
1518
1519         if (CheckSoftkey(softkey) == false)
1520         {
1521                 return r;
1522         }
1523
1524         float softkey_icon_size = 0.0f;
1525
1526         GET_SHAPE_CONFIG(FOOTER::SOFTKEY_ICON_SIZE, GetOrientation(), softkey_icon_size);
1527
1528         Bitmap* pClonedNormalBitmap = _BitmapImpl::CloneN(normalBitmap);
1529
1530         if (pClonedNormalBitmap)
1531         {
1532                 if (__pSoftkeyNormalIcon[softkey] != null)
1533                 {
1534                         delete __pSoftkeyNormalIcon[softkey];
1535                 }
1536
1537                 __pSoftkeyNormalIcon[softkey] = pClonedNormalBitmap;
1538
1539                 __pSoftkeyNormalIcon[softkey]->Scale(FloatDimension(softkey_icon_size, softkey_icon_size));
1540
1541                 r = E_SUCCESS;
1542         }
1543
1544         if (pPressedBitmap != null)
1545         {
1546                 Bitmap* pClonedPressedBitmap = _BitmapImpl::CloneN(*pPressedBitmap);
1547
1548                 if (pClonedPressedBitmap)
1549                 {
1550                         if (__pSoftkeyPressedIcon[softkey] != null)
1551                         {
1552                                 delete __pSoftkeyPressedIcon[softkey];
1553                         }
1554
1555                         __pSoftkeyPressedIcon[softkey] = pClonedPressedBitmap;
1556
1557                         __pSoftkeyPressedIcon[softkey]->Scale(FloatDimension(softkey_icon_size, softkey_icon_size));
1558
1559                         r = E_SUCCESS;
1560                 }
1561         }
1562
1563         return r;
1564 }
1565
1566 bool
1567 _Form::HasFooter(void) const
1568 {
1569         if (__pFooter)
1570         {
1571                 return true;
1572         }
1573         else
1574         {
1575                 return false;
1576         }
1577 }
1578
1579 bool
1580 _Form::HasHeader(void) const
1581 {
1582         if (__pHeader)
1583         {
1584                 return true;
1585         }
1586         else
1587         {
1588                 return false;
1589         }
1590 }
1591
1592 bool
1593 _Form::HasIndicator(void) const
1594 {
1595         if (__pIndicator && (GetFormStyle() & FORM_STYLE_INDICATOR))
1596         {
1597                 return true;
1598         }
1599         else
1600         {
1601                 return false;
1602         }
1603 }
1604
1605 bool
1606 _Form::HasTitle(void) const
1607 {
1608         if (__pHeader && (__formStyle & FORM_STYLE_TITLE))
1609         {
1610                 return true;
1611         }
1612         else
1613         {
1614                 return false;
1615         }
1616 }
1617
1618 bool
1619 _Form::HasTab(void) const
1620 {
1621         if ((__pTab && (__formStyle & FORM_STYLE_TEXT_TAB))
1622 || (__pTab && (__formStyle & FORM_STYLE_ICON_TAB)))
1623         {
1624                 return true;
1625         }
1626         else
1627         {
1628                 return false;
1629         }
1630 }
1631
1632 bool
1633 _Form::IsIndicatorVisible(void) const
1634 {
1635         _Control* pParent = GetParent();
1636         _Frame* pFrame = dynamic_cast<_Frame*>(pParent);
1637
1638         bool visible = true;
1639
1640         if (pFrame && IsAttachedToMainTree())
1641         {
1642                 visible = __pIndicator->GetIndicatorShowState();
1643                 SysTryReturn(NID_UI_CTRL, GetLastResult() == E_SUCCESS, false, GetLastResult(), "[%s] Propagating.", GetErrorMessage(GetLastResult()));
1644         }
1645         else
1646         {
1647                 visible = __indicatorShowState;
1648         }
1649
1650         return visible;
1651 }
1652
1653 bool
1654 _Form::IsHeaderVisible(void) const
1655 {
1656         if (__pHeader)
1657         {
1658                 return __pHeader->IsVisible();
1659         }
1660         else
1661         {
1662                 return false;
1663         }
1664 }
1665
1666 bool
1667 _Form::IsFooterVisible(void) const
1668 {
1669         if (__pFooter)
1670         {
1671                 return __pFooter->IsVisible();
1672         }
1673         else
1674         {
1675                 return false;
1676         }
1677 }
1678
1679 bool
1680 _Form::IsIndicatorTranslucent(void) const
1681 {
1682         _Control* pParent = GetParent();
1683         _Frame* pFrame = dynamic_cast<_Frame*>(pParent);
1684
1685         _IndicatorOpacity opacity = _INDICATOR_OPACITY_UNKNOWN;
1686
1687         bool transparent = false;
1688
1689         if (pFrame && IsAttachedToMainTree())
1690         {
1691                 FrameShowMode mode = pFrame->GetShowMode();
1692                 if (mode == FRAME_SHOW_MODE_FULL_SCREEN)
1693                 {
1694                         opacity = __pIndicator->GetIndicatorOpacity();
1695                         SysTryReturn(NID_UI_CTRL, GetLastResult() == E_SUCCESS, false, GetLastResult(), "[%s] Propagating.", GetErrorMessage(GetLastResult()));
1696
1697                         if (opacity == _INDICATOR_OPACITY_TRANSLUCENT)
1698                         {
1699                                 transparent = true;
1700                         }
1701                         else if (opacity == _INDICATOR_OPACITY_OPAQUE)
1702                         {
1703                                 transparent = false;
1704                         }
1705                 }
1706         }
1707         else
1708         {
1709                 transparent = __transparentIndicator;
1710         }
1711
1712         return transparent;
1713 }
1714
1715 bool
1716 _Form::IsHeaderTranslucent(void) const
1717 {
1718         return __transparentHeader;
1719 }
1720
1721 bool
1722 _Form::IsFooterTranslucent(void) const
1723 {
1724         return __transparentFooter;
1725 }
1726
1727 bool
1728 _Form::IsTabTranslucent(void) const
1729 {
1730         return __transparentTab;
1731 }
1732
1733 bool
1734 _Form::HasOptionkey(void) const
1735 {
1736         if (GetFormStyle() & FORM_STYLE_OPTIONKEY)
1737         {
1738                 return true;
1739         }
1740         else
1741         {
1742                 return false;
1743         }
1744 }
1745
1746 bool
1747 _Form::HasSoftkey(_Softkey softkey) const
1748 {
1749         unsigned long __formStyle = FORM_STYLE_NORMAL;
1750
1751         if (softkey == _SOFTKEY_0)
1752         {
1753                 __formStyle = FORM_STYLE_SOFTKEY_0;
1754         }
1755         else if (softkey == _SOFTKEY_1)
1756         {
1757                 __formStyle = FORM_STYLE_SOFTKEY_1;
1758         }
1759         else
1760         {
1761                 return false;
1762         }
1763
1764         if (GetFormStyle() & __formStyle)
1765         {
1766                 return true;
1767         }
1768         else
1769         {
1770                 return false;
1771         }
1772 }
1773
1774 bool
1775 _Form::IsSoftkeyEnabled(_Softkey softkey) const
1776 {
1777         if (CheckSoftkey(softkey) == false)
1778         {
1779                 return false;
1780         }
1781
1782         return __enableSoftkey[softkey];
1783 }
1784
1785 bool
1786 _Form::CheckSoftkey(_Softkey softkey) const
1787 {
1788         bool result = true;
1789
1790         if (HasSoftkey(softkey) == false)
1791         {
1792                 return false;
1793         }
1794
1795         if (softkey >= _SOFTKEY_COUNT)
1796         {
1797                 return false;
1798         }
1799
1800         return result;
1801 }
1802
1803 bool
1804 _Form::IsOrientationRoot(void) const
1805 {
1806         return true;
1807 }
1808
1809 Point
1810 _Form::TranslateToClientAreaPosition(const Point& position) const
1811 {
1812         Rectangle clientArea = GetClientBounds();
1813         return Point(position.x - clientArea.x, position.y - clientArea.y);
1814 }
1815
1816 FloatPoint
1817 _Form::TranslateToClientAreaPosition(const FloatPoint& position) const
1818 {
1819         FloatRectangle clientArea = GetClientBoundsF();
1820         return FloatPoint(position.x - clientArea.x, position.y - clientArea.y);
1821 }
1822
1823 Point
1824 _Form::TranslateFromClientAreaPosition(const Point& clientPosition) const
1825 {
1826         Rectangle clientArea = GetClientBounds();
1827         return Point(clientPosition.x + clientArea.x, clientPosition.y + clientArea.y);
1828 }
1829
1830 FloatPoint
1831 _Form::TranslateFromClientAreaPosition(const FloatPoint& clientPosition) const
1832 {
1833         FloatRectangle clientArea = GetClientBoundsF();
1834         return FloatPoint(clientPosition.x + clientArea.x, clientPosition.y + clientArea.y);
1835 }
1836
1837 bool
1838 _Form::DeflateClientRectHeight(int height)
1839 {
1840         if (    height > 0)
1841         {
1842                 __deflated = true;
1843         }
1844         else
1845         {
1846                 __deflated = false;
1847         }
1848
1849         __deflatedHeight = _CoordinateSystemUtils::ConvertToFloat(height);
1850
1851         AdjustClientBounds();
1852
1853         if (__pFooter)
1854         {
1855                 float adjHeight = 0.0f;
1856
1857                 if (!(__pFooter->GetVisibleState()) || IsFooterTranslucent())
1858                 {
1859                         adjHeight = GetToolbarHeightF(false);
1860                 }
1861
1862                 FloatRectangle bounds(0.0f, GetClientBoundsF().y + GetClientBoundsF().height-adjHeight,
1863                                                                                 GetClientBoundsF().width, GetToolbarHeightF(false));
1864                 SetFooterBounds(bounds);
1865         }
1866
1867         return true;
1868 }
1869
1870 bool
1871 _Form::DeflateClientRectHeight(float height)
1872 {
1873         if (    height > 0.0f)
1874         {
1875                 __deflated = true;
1876         }
1877         else
1878         {
1879                 __deflated = false;
1880         }
1881
1882         __deflatedHeight = height;
1883
1884         AdjustClientBounds();
1885
1886         if (__pFooter)
1887         {
1888                 float adjHeight = 0.0f;
1889
1890                 if (!(__pFooter->GetVisibleState()) || IsFooterTranslucent())
1891                 {
1892                         adjHeight = GetToolbarHeightF(false);
1893                 }
1894
1895                 FloatRectangle bounds(0.0f, GetClientBoundsF().y + GetClientBoundsF().height-adjHeight,
1896                                                                                 GetClientBoundsF().width, GetToolbarHeightF(false));
1897                 SetFooterBounds(bounds);
1898         }
1899
1900         return true;
1901 }
1902
1903 _Toolbar*
1904 _Form::CreateHeaderN(void)
1905 {
1906         _Toolbar* __pHeader = _Toolbar::CreateToolbarN(true);
1907         SysTryReturn(NID_UI_CTRL, __pHeader, null, GetLastResult(), "[%s] Propagating.", GetErrorMessage(GetLastResult()));
1908
1909         return __pHeader;
1910 }
1911
1912 _Toolbar*
1913 _Form::CreateFooterN(void)
1914 {
1915         _Toolbar* __pFooter = _Toolbar::CreateToolbarN(false);
1916         SysTryReturn(NID_UI_CTRL, __pFooter, null, GetLastResult(), "[%s] Propagating.", GetErrorMessage(GetLastResult()));
1917
1918         return __pFooter;
1919 }
1920
1921 _Tab*
1922 _Form::CreateTabN(void)
1923 {
1924         _Tab* __pTab = _Tab::CreateTabN();
1925         SysTryReturn(NID_UI_CTRL, __pTab, null, GetLastResult(), "[%s] Propagating.", GetErrorMessage(GetLastResult()));
1926
1927         return __pTab;
1928 }
1929
1930 _Indicator*
1931 _Form::CreateIndicatorN(void)
1932 {
1933         _Indicator* pIndicator = new (std::nothrow) _Indicator;
1934         SysTryReturn(NID_UI_CTRL, pIndicator, null, GetLastResult(), "[%s] Propagating.", GetErrorMessage(GetLastResult()));
1935
1936         return pIndicator;
1937 }
1938
1939 int
1940 _Form::GetToolbarHeight(bool header) const
1941 {
1942         int toolbarHeight = 0;
1943
1944         if (header && (__formStyle & FORM_STYLE_HEADER))
1945         {
1946                 if (__pHeader)
1947                 {
1948                         toolbarHeight = __pHeader->GetBounds().height;
1949                 }
1950         }
1951         else if (header && (__formStyle & FORM_STYLE_TITLE))
1952         {
1953                 GET_SHAPE_CONFIG(HEADER::HEIGHT, GetOrientation(), toolbarHeight);
1954         }
1955         else if (__formStyle & FORM_STYLE_SOFTKEY_0 || __formStyle & FORM_STYLE_SOFTKEY_1 || __formStyle & FORM_STYLE_OPTIONKEY)
1956         {
1957                 GET_SHAPE_CONFIG(FOOTER::SOFTKEY_HEIGHT, GetOrientation(), toolbarHeight);
1958         }
1959         else
1960         {
1961                 if (__pFooter)
1962                 {
1963                         toolbarHeight = __pFooter->GetBounds().height;
1964                 }
1965
1966                 //GET_SHAPE_CONFIG(L"FOOTER_HEIGHT", GetOrientation(), toolbarHeight);
1967         }
1968
1969         return toolbarHeight;
1970 }
1971
1972 float
1973 _Form::GetToolbarHeightF(bool header) const
1974 {
1975         FloatDimension toolbarSize(0.0f, 0.0f);
1976
1977         if (header && (__formStyle & FORM_STYLE_HEADER))
1978         {
1979                 if (__pHeader)
1980                 {
1981                         toolbarSize.height = __pHeader->GetBoundsF().height;
1982                 }
1983         }
1984         else if (header && (__formStyle & FORM_STYLE_TITLE))
1985         {
1986                 GET_SHAPE_CONFIG(HEADER::HEIGHT, GetOrientation(), toolbarSize.height);
1987         }
1988         else if (__formStyle & FORM_STYLE_SOFTKEY_0 || __formStyle & FORM_STYLE_SOFTKEY_1 || __formStyle & FORM_STYLE_OPTIONKEY)
1989         {
1990                 GET_SHAPE_CONFIG(FOOTER::SOFTKEY_HEIGHT, GetOrientation(), toolbarSize.height);
1991         }
1992         else
1993         {
1994                 if (__pFooter)
1995                 {
1996                         toolbarSize.height = __pFooter->GetBoundsF().height;
1997                 }
1998         }
1999
2000         toolbarSize = TranslateSize(toolbarSize);
2001
2002         return toolbarSize.height;
2003 }
2004
2005 int
2006 _Form::GetTabHeight(void) const
2007 {
2008         int height = 0;
2009
2010         if ((__formStyle & FORM_STYLE_TEXT_TAB) || (__formStyle & FORM_STYLE_ICON_TAB))
2011         {
2012                 GET_SHAPE_CONFIG(TAB::HEIGHT, GetOrientation(), height);
2013         }
2014
2015         return height;
2016 }
2017
2018 float
2019 _Form::GetTabHeightF(void) const
2020 {
2021         FloatDimension tabSize(0.0f, 0.0f);
2022
2023         if ((__formStyle & FORM_STYLE_TEXT_TAB) || (__formStyle & FORM_STYLE_ICON_TAB))
2024         {
2025                 GET_SHAPE_CONFIG(TAB::HEIGHT, GetOrientation(), tabSize.height);
2026         }
2027
2028         tabSize = TranslateSize(tabSize);
2029
2030         return tabSize.height;
2031 }
2032
2033 bool
2034 _Form::RemoveHeader(void)
2035 {
2036         result r = E_SUCCESS;
2037         if (__pHeader)
2038         {
2039                 if (__pHeader->GetParent())
2040                 {
2041                         r = DetachSystemChild(*__pHeader);
2042                         SysTryReturn(NID_UI_CTRL, r == E_SUCCESS, false, r, "[%s] Propagating.", GetErrorMessage(r));
2043                 }
2044                 __pHeader = null;
2045
2046                 AdjustClientBounds();
2047         }
2048         else
2049         {
2050                 return false;
2051         }
2052
2053         return true;
2054 }
2055
2056 bool
2057 _Form::RemoveFooter(void)
2058 {
2059         result r = E_SUCCESS;
2060         if (__pFooter)
2061         {
2062                 if (__pFooter->GetParent())
2063                 {
2064                         r = DetachSystemChild(*__pFooter);
2065                         SysTryReturn(NID_UI_CTRL, r == E_SUCCESS, false, r, "[%s] Propagating.", GetErrorMessage(r));
2066                 }
2067                 __pFooter = null;
2068
2069                 AdjustClientBounds();
2070         }
2071         else
2072         {
2073                 return false;
2074         }
2075
2076         return true;
2077 }
2078
2079 bool
2080 _Form::RemoveTab(void)
2081 {
2082         result r = E_SUCCESS;
2083         if (__pTab)
2084         {
2085                 if (__pFooter->GetParent())
2086                 {
2087                         r = DetachSystemChild(*__pTab);
2088                         SysTryReturn(NID_UI_CTRL, r == E_SUCCESS, false, r, "[%s] Propagating.", GetErrorMessage(r));
2089                 }
2090                 __pTab = null;
2091
2092                 AdjustClientBounds();
2093         }
2094         else
2095         {
2096                 return false;
2097         }
2098
2099         return true;
2100 }
2101
2102 bool
2103 _Form::RemoveIndicator(void)
2104 {
2105         result r = E_SUCCESS;
2106         if (__pIndicator)
2107         {
2108                 r = DetachSystemChild(*__pIndicator);
2109                 SysTryReturn(NID_UI_CTRL, r == E_SUCCESS, false, r, "[%s] Propagating.", GetErrorMessage(r));
2110                 __pIndicator = null;
2111         }
2112         else
2113         {
2114                 return false;
2115         }
2116
2117         return true;
2118 }
2119
2120 result
2121 _Form::SetHeaderBounds(Rectangle& bounds)
2122 {
2123         SysTryReturn(NID_UI_CTRL, __pHeader, E_INVALID_STATE, E_INVALID_STATE, "[E_INVALID_STATE] Header isn't constructed.");
2124
2125         bool movable = __pHeader->IsMovable();
2126         bool resizable = __pHeader->IsResizable();
2127
2128         __pHeader->SetMovable(true);
2129         __pHeader->SetResizable(true);
2130
2131         result r = E_SUCCESS;
2132         r = __pHeader->SetBounds(_CoordinateSystemUtils::ConvertToFloat(bounds));
2133         SysTryReturn(NID_UI_CTRL, r == E_SUCCESS, r, r, "[%s] Propagating.", GetErrorMessage(r));
2134
2135         __pHeader->SetMovable(movable);
2136         __pHeader->SetResizable(resizable);
2137
2138         AdjustClientBounds();
2139
2140         return r;
2141 }
2142
2143 result
2144 _Form::SetHeaderBounds(FloatRectangle& bounds)
2145 {
2146         SysTryReturn(NID_UI_CTRL, __pHeader, E_INVALID_STATE, E_INVALID_STATE, "[E_INVALID_STATE] Header isn't constructed.");
2147
2148         bool movable = __pHeader->IsMovable();
2149         bool resizable = __pHeader->IsResizable();
2150
2151         __pHeader->SetMovable(true);
2152         __pHeader->SetResizable(true);
2153
2154         result r = E_SUCCESS;
2155         r = __pHeader->SetBounds(bounds);
2156         SysTryReturn(NID_UI_CTRL, r == E_SUCCESS, r, r, "[%s] Propagating.", GetErrorMessage(r));
2157
2158         __pHeader->SetMovable(movable);
2159         __pHeader->SetResizable(resizable);
2160
2161         AdjustClientBounds();
2162
2163         return r;
2164 }
2165
2166 result
2167 _Form::SetFooterBounds(Rectangle& bounds)
2168 {
2169         SysTryReturn(NID_UI_CTRL, __pFooter, E_INVALID_STATE, E_INVALID_STATE, "[E_INVALID_STATE] Footer isn't constructed.");
2170
2171         bool movable = __pFooter->IsMovable();
2172         bool resizable = __pFooter->IsResizable();
2173
2174         __pFooter->SetMovable(true);
2175         __pFooter->SetResizable(true);
2176
2177         result r = E_SUCCESS;
2178         r = __pFooter->SetBounds(_CoordinateSystemUtils::ConvertToFloat(bounds));
2179         SysTryReturn(NID_UI_CTRL, r == E_SUCCESS, r, r, "[%s] Propagating.", GetErrorMessage(r));
2180
2181         __pFooter->SetMovable(movable);
2182         __pFooter->SetResizable(resizable);
2183
2184         AdjustClientBounds();
2185
2186         return r;
2187 }
2188
2189 result
2190 _Form::SetFooterBounds(FloatRectangle& bounds)
2191 {
2192         SysTryReturn(NID_UI_CTRL, __pFooter, E_INVALID_STATE, E_INVALID_STATE, "[E_INVALID_STATE] Footer isn't constructed.");
2193
2194         bool movable = __pFooter->IsMovable();
2195         bool resizable = __pFooter->IsResizable();
2196
2197         __pFooter->SetMovable(true);
2198         __pFooter->SetResizable(true);
2199
2200         result r = E_SUCCESS;
2201         r = __pFooter->SetBounds(bounds);
2202         SysTryReturn(NID_UI_CTRL, r == E_SUCCESS, r, r, "[%s] Propagating.", GetErrorMessage(r));
2203
2204         __pFooter->SetMovable(movable);
2205         __pFooter->SetResizable(resizable);
2206
2207         AdjustClientBounds();
2208
2209         return r;
2210 }
2211
2212 result
2213 _Form::SetTabBounds(Rectangle& bounds)
2214 {
2215         SysTryReturn(NID_UI_CTRL, __pTab, E_INVALID_STATE, E_INVALID_STATE, "[E_INVALID_STATE] Tab isn't constructed.");
2216
2217         bool movable = __pTab->IsMovable();
2218         bool resizable = __pTab->IsResizable();
2219
2220         __pTab->SetMovable(true);
2221         __pTab->SetResizable(true);
2222
2223         result r = E_SUCCESS;
2224         r = __pTab->SetBounds(_CoordinateSystemUtils::ConvertToFloat(bounds));
2225         SysTryReturn(NID_UI_CTRL, r == E_SUCCESS, r, r, "[%s] Propagating.", GetErrorMessage(r));
2226
2227         __pTab->SetMovable(movable);
2228         __pTab->SetResizable(resizable);
2229
2230         AdjustClientBounds();
2231
2232         return r;
2233 }
2234
2235 result
2236 _Form::SetTabBounds(FloatRectangle& bounds)
2237 {
2238         SysTryReturn(NID_UI_CTRL, __pTab, E_INVALID_STATE, E_INVALID_STATE, "[E_INVALID_STATE] Tab isn't constructed.");
2239
2240         bool movable = __pTab->IsMovable();
2241         bool resizable = __pTab->IsResizable();
2242
2243         __pTab->SetMovable(true);
2244         __pTab->SetResizable(true);
2245
2246         result r = E_SUCCESS;
2247         r = __pTab->SetBounds(bounds);
2248         SysTryReturn(NID_UI_CTRL, r == E_SUCCESS, r, r, "[%s] Propagating.", GetErrorMessage(r));
2249
2250         __pTab->SetMovable(movable);
2251         __pTab->SetResizable(resizable);
2252
2253         AdjustClientBounds();
2254
2255         return r;
2256 }
2257
2258 result
2259 _Form::AddActionEventListener(_IActionEventListener& listener)
2260 {
2261         if (__pActionEvent == null)
2262         {
2263                 __pActionEvent = _ActionEvent::CreateInstanceN(*this);
2264
2265                 SysTryReturn(NID_UI_CTRL, __pActionEvent, E_SYSTEM, E_SYSTEM, "[E_SYSTEM] System error occurred.")
2266         }
2267
2268         result r = __pActionEvent->AddListener(listener);
2269         SysTryReturn(NID_UI_CTRL, r == E_SUCCESS, r, r, "[%s] Propagating.", GetErrorMessage(r));
2270
2271         return E_SUCCESS;
2272 }
2273
2274 void
2275 _Form::AddOptionkeyActionListener(_IActionEventListener& listener)
2276 {
2277         if (HasOptionkey() == false)
2278         {
2279                 return ;
2280         }
2281 }
2282
2283 void
2284 _Form::AddSoftkeyActionListener(_Softkey softkey, _IActionEventListener& listener)
2285 {
2286         if (CheckSoftkey(softkey) == false)
2287         {
2288                 return ;
2289         }
2290 }
2291
2292 result
2293 _Form::RemoveActionEventListener(_IActionEventListener& listener)
2294 {
2295         SysTryReturn(NID_UI_CTRL, __pActionEvent, E_INVALID_STATE, E_INVALID_STATE, "[E_INVALID_STATE] This instance isn't constructed.")
2296         // Todo : check fail case of RemoveListener
2297         result r = __pActionEvent->RemoveListener(listener);
2298         SysTryReturn(NID_UI_CTRL, r == E_SUCCESS, r, r, "[%s] Propagating.", GetErrorMessage(r));
2299
2300         return E_SUCCESS;
2301 }
2302
2303 void
2304 _Form::RemoveOptionkeyActionListener(_IActionEventListener& listener)
2305 {
2306         if (HasOptionkey() == false)
2307         {
2308                 return ;
2309         }
2310 }
2311
2312 void
2313 _Form::RemoveSoftkeyActionListener(_Softkey softkey, _IActionEventListener& listener)
2314 {
2315         if (CheckSoftkey(softkey) == false)
2316         {
2317                 return ;
2318         }
2319 }
2320
2321 void
2322 _Form::OnActionPerformed(const _Control& source, int actionId)
2323 {
2324         switch (actionId)
2325         {
2326         case ID_BACK_BUTTON:
2327                 if (__keypadShowstate)
2328                 {
2329                         _SystemUtilImpl::GenerateKeyEvent(KEY_EVENT_TYPE_PRESSED, _KEY_STOP);
2330                         _SystemUtilImpl::GenerateKeyEvent(KEY_EVENT_TYPE_RELEASED, _KEY_STOP);
2331                 }
2332                 else
2333                 {
2334                         if (__pFormBackEventListener)
2335                         {
2336                                 __pFormBackEventListener->OnFormBackRequested(*this);
2337                         }
2338                 }
2339                 break;
2340
2341         default:
2342                 break;
2343         }
2344 }
2345
2346 void
2347 _Form::OnChildVisibleStateChanged(const _Control& child)
2348 {
2349         if (IsHeaderVisible())
2350         {
2351                 float adjHeight = 0.0f;
2352                 if (IsIndicatorVisible())
2353                 {
2354                         FloatRectangle indicatorBounds = GetIndicatorBoundsF();
2355                         adjHeight = indicatorBounds.height;
2356
2357                         if (IsIndicatorTranslucent())
2358                         {
2359                                 if (!IsHeaderTranslucent())
2360                                 {
2361                                         adjHeight = 0.0f;
2362                                 }
2363                                 else
2364                                 {
2365                                         if (GetOrientation() == _CONTROL_ORIENTATION_LANDSCAPE)
2366                                         {
2367                                                 adjHeight = 0.0f;
2368                                         }
2369                                 }
2370                         }
2371                 }
2372                 FloatRectangle bounds = __pHeader->GetBoundsF();
2373                 bounds.y = adjHeight;
2374                 SetHeaderBounds(bounds);
2375         }
2376
2377         AdjustClientBounds();
2378 }
2379
2380 Rectangle
2381 _Form::GetIndicatorBounds(void) const
2382 {
2383         _Control* pParent = GetParent();
2384         _Frame* pFrame = dynamic_cast<_Frame*>(pParent);
2385
2386         if (pFrame)
2387         {
2388                 FrameShowMode mode = pFrame->GetShowMode();
2389                 if (mode != FRAME_SHOW_MODE_FULL_SCREEN)
2390                 {
2391                         return Rectangle(0, 0, 0, 0);
2392                 }
2393         }
2394
2395         int indicatorwidth = GetClientBounds().width;
2396         int indicatorheight = 0;
2397
2398         if (GetOrientation() == _CONTROL_ORIENTATION_PORTRAIT)
2399         {
2400                 GET_SHAPE_CONFIG(FORM::INDICATOR_HEIGHT, GetOrientation(), indicatorheight);
2401         }
2402         else
2403         {
2404                 GET_SHAPE_CONFIG(FORM::INDICATOR_MINIMIZE_HEIGHT, GetOrientation(), indicatorheight);
2405         }
2406
2407         Rectangle rect (0, 0, indicatorwidth, indicatorheight);
2408
2409         SetLastResult(E_SUCCESS);
2410
2411         return rect;
2412 }
2413
2414 FloatRectangle
2415 _Form::GetIndicatorBoundsF(void) const
2416 {
2417         _Control* pParent = GetParent();
2418         _Frame* pFrame = dynamic_cast<_Frame*>(pParent);
2419
2420         if (pFrame)
2421         {
2422                 FrameShowMode mode = pFrame->GetShowMode();
2423                 if (mode != FRAME_SHOW_MODE_FULL_SCREEN)
2424                 {
2425                         return FloatRectangle(0.0f, 0.0f, 0.0f, 0.0f);
2426                 }
2427         }
2428
2429         float indicatorwidth = GetClientBoundsF().width;
2430         float indicatorheight = 0.0f;
2431
2432         if (GetOrientation() == _CONTROL_ORIENTATION_PORTRAIT)
2433         {
2434                 GET_SHAPE_CONFIG(FORM::INDICATOR_HEIGHT, GetOrientation(), indicatorheight);
2435         }
2436         else
2437         {
2438                 GET_SHAPE_CONFIG(FORM::INDICATOR_MINIMIZE_HEIGHT, GetOrientation(), indicatorheight);
2439         }
2440
2441         FloatRectangle rect (0.0f, 0.0f, indicatorwidth, indicatorheight);
2442
2443         SetLastResult(E_SUCCESS);
2444
2445         return rect;
2446 }
2447
2448 void
2449 _Form::SetHeader(_Toolbar* pToolbar)
2450 {
2451         __pHeader = pToolbar;
2452 }
2453
2454 void
2455 _Form::SetFooter(_Toolbar* pToolbar)
2456 {
2457         __pFooter = pToolbar;
2458 }
2459
2460 void
2461 _Form::SetTab(_Tab* pTab)
2462 {
2463         __pTab = pTab;
2464 }
2465
2466 void
2467 _Form::SetTabStyle(int style)
2468 {
2469         __pTab->SetStyle(style);
2470 }
2471
2472 result
2473 _Form::SetIndicatorShowState(bool state, bool hide)
2474 {
2475         result r = E_SUCCESS;
2476
2477         _EcoreEvas* pEcoreEvas = GetEcoreEvasMgr()->GetEcoreEvas();
2478         SysTryReturn(NID_UI_CTRL, pEcoreEvas, E_SYSTEM, E_SYSTEM, "[E_SYSTEM] Unable to get evas");
2479
2480         _Control* pParent = GetParent();
2481         if (!pParent)
2482         {
2483                 pParent = const_cast<_Control*>(pEcoreEvas->GetFrame());
2484         }
2485         _Frame* pFrame = dynamic_cast<_Frame*>(pParent);
2486
2487         if (pFrame && IsAttachedToMainTree())
2488         {
2489                 FrameShowMode mode = pFrame->GetShowMode();
2490                 if (mode == FRAME_SHOW_MODE_FULL_SCREEN)
2491                 {
2492                         r = __pIndicator->SetIndicatorShowState(state, hide);
2493                         SysTryReturn(NID_UI_CTRL, r == E_SUCCESS, r, r, "[%s] Propagating.", GetErrorMessage(r));
2494                 }
2495                 else
2496                 {
2497                         r = __pIndicator->SetIndicatorShowState(false);
2498                         return r;
2499                 }
2500         }
2501         else if (!pFrame && IsAttachedToMainTree())
2502         {
2503                 r = __pIndicator->SetIndicatorShowState(false, true);
2504         }
2505
2506         __indicatorShowState = state;
2507
2508         return r;
2509 }
2510
2511 result
2512 _Form::SetIndicatorOpacity(_IndicatorOpacity opacity)
2513 {
2514         result r = E_SUCCESS;
2515
2516         _Control* pParent = GetParent();
2517         _Frame* pFrame = dynamic_cast<_Frame*>(pParent);
2518
2519         if (pFrame && IsAttachedToMainTree())
2520         {
2521                 FrameShowMode mode = pFrame->GetShowMode();
2522                 if (mode == FRAME_SHOW_MODE_FULL_SCREEN)
2523                 {
2524                         r = __pIndicator->SetIndicatorOpacity(opacity);
2525                         SysTryReturn(NID_UI_CTRL, r == E_SUCCESS, r, r, "[%s] Propagating.", GetErrorMessage(r));
2526                 }
2527         }
2528
2529         if (opacity == _INDICATOR_OPACITY_TRANSLUCENT)
2530         {
2531                 __transparentIndicator = true;
2532         }
2533         else if (opacity == _INDICATOR_OPACITY_OPAQUE)
2534         {
2535                 __transparentIndicator = false;
2536         }
2537
2538         return r;
2539 }
2540
2541 result
2542 _Form::AddIndicatorObject(void)
2543 {
2544         result r = E_SUCCESS;
2545
2546         if (__pIndicator)
2547         {
2548                 r = __pIndicator->AddIndicatorObject(this);
2549         }
2550
2551         return r;
2552 }
2553
2554 result
2555 _Form::DeleteIndicatorObject(void)
2556 {
2557         result r = E_SUCCESS;
2558         if (__pIndicator)
2559         {
2560                 r = __pIndicator->DeleteIndicatorObject();
2561         }
2562
2563         return r;
2564 }
2565
2566 void
2567 _Form::SetKeypadShowState(bool state)
2568 {
2569         __keypadShowstate = state;
2570         if (state)
2571         {
2572                 if (__pHeader)
2573                 {
2574                         __pHeader->SetHideButton(true);
2575                 }
2576                 if (__pFooter)
2577                 {
2578                         __pFooter->SetHideButton(true);
2579                 }
2580         }
2581         else
2582         {
2583                 if (__pHeader)
2584                 {
2585                         __pHeader->SetHideButton(false);
2586                 }
2587                 if (__pFooter)
2588                 {
2589                         __pFooter->SetHideButton(false);
2590                 }
2591         }
2592
2593 }
2594
2595 result
2596 _Form::AttachedToMainTree(void)
2597 {
2598         _Frame* pFrame = dynamic_cast<_Frame*>(GetParent());
2599         if (pFrame != null)
2600         {
2601                 FrameShowMode mode = pFrame->GetShowMode();
2602                 if (mode != FRAME_SHOW_MODE_FULL_SCREEN)
2603                 {
2604                         SetBounds(FloatRectangle(0.0f, 0.0f, pFrame->GetBoundsF().width, pFrame->GetBoundsF().height));
2605                 }
2606         }
2607
2608         result r = E_SUCCESS;
2609
2610         if (FORM_STYLE_INDICATOR & GetFormStyle())
2611         {
2612                 AddIndicatorObject();
2613
2614                 if (__indicatorShowState != IsIndicatorVisible())
2615                 {
2616                                 SetIndicatorShowState(__indicatorShowState);
2617                 }
2618
2619                 if (__transparentIndicator != IsIndicatorTranslucent())
2620                 {
2621                         if (__transparentIndicator == true)
2622                         {
2623                                 SetIndicatorOpacity(_INDICATOR_OPACITY_TRANSLUCENT);
2624                         }
2625                         else
2626                         {
2627                                 SetIndicatorOpacity(_INDICATOR_OPACITY_OPAQUE);
2628                         }
2629                 }
2630
2631                 r = GetLastResult();
2632                 SysTryReturnResult(NID_UI_CTRL, r == E_SUCCESS, r, "[%s] Propagating.", GetErrorMessage(r));
2633         }
2634         else if (FORM_STYLE_INDICATOR_AUTO_HIDE & GetFormStyle())
2635         {
2636                 SetIndicatorShowState(__indicatorShowState, true);
2637         }
2638         else
2639         {
2640                 r = SetIndicatorShowState(false);
2641                 SysTryReturnResult(NID_UI_CTRL, r == E_SUCCESS, r, "[%s] Propagating.", GetErrorMessage(r));
2642         }
2643
2644         return r;
2645 }
2646
2647 result
2648 _Form::DetachingFromMainTree(void)
2649 {
2650         result r = E_SUCCESS;
2651         r = DeleteIndicatorObject();
2652         return r;
2653 }
2654
2655 result
2656 _Form::AdjustClientBounds(void)
2657 {
2658         result r = E_SUCCESS;
2659
2660         FloatDimension size = GetSizeF();
2661         FloatRectangle clientBounds(0.0f, 0.0f, size.width, size.height);
2662
2663         if (__deflated)
2664         {
2665                 clientBounds.height -= __deflatedHeight;
2666         }
2667
2668         FloatRectangle indicatorBounds = GetIndicatorBoundsF();
2669
2670         _Control* pParent = GetParent();
2671         _Frame* pFrame = dynamic_cast<_Frame*>(pParent);
2672         if (pFrame)
2673         {
2674                 FrameShowMode mode = pFrame->GetShowMode();
2675                 if (mode == FRAME_SHOW_MODE_FULL_SCREEN)
2676                 {
2677                         if (FORM_STYLE_INDICATOR & __formStyle)
2678                         {
2679                                 if (IsIndicatorVisible() && !IsIndicatorTranslucent())
2680                                 {
2681                                         clientBounds.y += indicatorBounds.height;
2682                                         clientBounds.height -= indicatorBounds.height;
2683                                 }
2684                         }
2685                 }
2686         }
2687         else
2688         {
2689                 if (FORM_STYLE_INDICATOR & __formStyle)
2690                 {
2691                         if (IsIndicatorVisible() && !IsIndicatorTranslucent())
2692                         {
2693                                 clientBounds.y += indicatorBounds.height;
2694                                 clientBounds.height -= indicatorBounds.height;
2695                         }
2696                 }
2697         }
2698
2699         if (__pHeader)
2700         {
2701                 if (__pHeader->GetVisibleState() && !IsHeaderTranslucent())
2702                 {
2703                         clientBounds.y += GetToolbarHeightF(true);
2704                         clientBounds.height -= GetToolbarHeightF(true);
2705                 }
2706         }
2707
2708         if (__pTab)
2709         {
2710                 if (__pTab->GetVisibleState()) //&& !IsHeaderTranslucent())
2711                 {
2712                         clientBounds.y += GetTabHeightF();
2713                         clientBounds.height -= GetTabHeightF();
2714                 }
2715         }
2716
2717         if (__pFooter)
2718         {
2719                 if (FORM_STYLE_FOOTER & __formStyle || FORM_STYLE_SOFTKEY_0 & __formStyle || FORM_STYLE_SOFTKEY_1 & __formStyle
2720                                 || FORM_STYLE_OPTIONKEY & __formStyle)
2721                 {
2722                         if (__pFooter->GetVisibleState() && !IsFooterTranslucent())
2723                         {
2724                                         clientBounds.height -= GetToolbarHeightF(false);
2725                         }
2726                 }
2727         }
2728
2729         SetClientBounds(clientBounds);
2730
2731         return r;
2732 }
2733
2734 void
2735 _Form::OnBoundsChanged(void)
2736 {
2737         FloatRectangle toolbarBounds;
2738         FloatRectangle indicatorFloatBounds(0.0f, 0.0f, 0.0f, 0.0f);
2739
2740         float indicatorheight = 0.0f;
2741
2742         GET_SHAPE_CONFIG(FORM::INDICATOR_HEIGHT, GetOrientation(), indicatorheight);
2743         if (__pIndicator)
2744         {
2745                         __pIndicator->SetBounds(FloatRectangle(0.0f, 0.0f, GetClientBoundsF().width, indicatorheight));
2746         }
2747         AdjustClientBounds();
2748
2749         if (HasHeader())
2750         {
2751                 if (IsIndicatorVisible())
2752                 {
2753                         indicatorFloatBounds = GetIndicatorBoundsF();
2754                         if (IsIndicatorTranslucent())
2755                         {
2756                                 if (!IsHeaderTranslucent())
2757                                 {
2758                                         indicatorFloatBounds.height = 0.0f;
2759                                 }
2760                                 else
2761                                 {
2762                                         if (GetOrientation() == _CONTROL_ORIENTATION_LANDSCAPE)
2763                                         {
2764                                                 indicatorFloatBounds.height = 0.0f;
2765                                         }
2766                                 }
2767                         }
2768                 }
2769
2770                 toolbarBounds = GetHeader()->GetBoundsF();
2771                 toolbarBounds.width = GetSizeF().width;
2772
2773                 FloatRectangle bounds(toolbarBounds.x, indicatorFloatBounds.height, toolbarBounds.width, toolbarBounds.height);
2774                 SetHeaderBounds(bounds);
2775         }
2776
2777         if (HasFooter())
2778         {
2779                 toolbarBounds = GetFooter()->GetBoundsF();
2780                 toolbarBounds.width = GetSizeF().width;
2781                 toolbarBounds.y = GetSizeF().height - toolbarBounds.height;
2782                 SetFooterBounds(toolbarBounds);
2783         }
2784
2785         if (HasTab())
2786         {
2787                 toolbarBounds = GetTab()->GetBoundsF();
2788                 toolbarBounds.width = GetSizeF().width;
2789                 SetTabBounds(toolbarBounds);
2790         }
2791
2792         AdjustClientBounds();
2793 }
2794
2795 FloatDimension
2796 _Form::TranslateSize(FloatDimension size ) const
2797 {
2798         FloatDimension returnSize(0.0f, 0.0f);
2799         returnSize = CoordinateSystem::AlignToDevice(size);
2800
2801         return returnSize;
2802 }
2803
2804 result
2805 _Form::SetNotificationTrayOpenEnabled(bool enable)
2806 {
2807         SysTryReturnResult(NID_UI_CTRL,         (__formStyle & FORM_STYLE_INDICATOR || __formStyle & FORM_STYLE_INDICATOR_AUTO_HIDE), E_INVALID_OPERATION, "[E_INVALID_OPERATION] The style of form is invalid.");
2808
2809         if (__pIndicator)
2810         {
2811                 __pIndicator->SetNotificationTrayOpenEnabled(enable);
2812         }
2813         return E_SUCCESS;
2814 }
2815
2816 bool
2817 _Form::IsNotificationTrayOpenEnabled(void) const
2818 {
2819         SysTryReturnResult(NID_UI_CTRL,         (__formStyle & FORM_STYLE_INDICATOR || __formStyle & FORM_STYLE_INDICATOR_AUTO_HIDE), E_INVALID_OPERATION, "[E_INVALID_OPERATION] The style of form is invalid.");
2820
2821         if (__pIndicator)
2822         {
2823                 __pIndicator->IsNotificationTrayOpenEnabled();
2824         }
2825         return true;
2826 }
2827
2828 IListT<_Control*>*
2829 _Form::GetFocusList(void) const
2830 {
2831         if(!__pFocusControlList)
2832         {
2833                 __pFocusControlList.reset(GetFocusListN());
2834                 __pFocusControlList->InsertAt(const_cast<_Form*>(this), 0);
2835         }
2836         return __pFocusControlList.get();
2837 }
2838
2839 void
2840 _Form::ResetFocusList(void)
2841 {
2842         if(__pFocusControlList)
2843         {
2844                 __pFocusControlList.reset();
2845         }
2846 }
2847
2848 void
2849 _Form::UpdateClientBounds(const FloatDimension& size, FloatRectangle& clientBounds)
2850 {
2851         clientBounds.width = size.width;
2852         clientBounds.height = size.height;
2853
2854         if (__deflated)
2855         {
2856                 clientBounds.height -= __deflatedHeight;
2857         }
2858
2859         FloatRectangle indicatorBounds = GetIndicatorBoundsF();
2860
2861         _Control* pParent = GetParent();
2862         _Frame* pFrame = dynamic_cast<_Frame*>(pParent);
2863         if (pFrame)
2864         {
2865                 FrameShowMode mode = pFrame->GetShowMode();
2866                 if (mode == FRAME_SHOW_MODE_FULL_SCREEN)
2867                 {
2868                         if (FORM_STYLE_INDICATOR & __formStyle)
2869                         {
2870                                 if (IsIndicatorVisible() && !IsIndicatorTranslucent())
2871                                 {
2872                                         clientBounds.y += indicatorBounds.height;
2873                                         clientBounds.height -= indicatorBounds.height;
2874                                 }
2875                         }
2876                 }
2877         }
2878         else
2879         {
2880                 if (FORM_STYLE_INDICATOR & __formStyle)
2881                 {
2882                         if (IsIndicatorVisible() && !IsIndicatorTranslucent())
2883                         {
2884                                 clientBounds.y += indicatorBounds.height;
2885                                 clientBounds.height -= indicatorBounds.height;
2886                         }
2887                 }
2888         }
2889
2890         if (__pHeader)
2891         {
2892                 if (__pHeader->GetVisibleState() && !IsHeaderTranslucent())
2893                 {
2894                         clientBounds.y += GetToolbarHeightF(true);
2895                         clientBounds.height -= GetToolbarHeightF(true);
2896                 }
2897         }
2898
2899         if (__pTab)
2900         {
2901                 if (__pTab->GetVisibleState()) //&& !IsHeaderTranslucent())
2902                 {
2903                         clientBounds.y += GetTabHeightF();
2904                         clientBounds.height -= GetTabHeightF();
2905                 }
2906         }
2907
2908         if (__pFooter)
2909         {
2910                 if (FORM_STYLE_FOOTER & __formStyle || FORM_STYLE_SOFTKEY_0 & __formStyle || FORM_STYLE_SOFTKEY_1 & __formStyle
2911                                 || FORM_STYLE_OPTIONKEY & __formStyle)
2912                 {
2913                         if (__pFooter->GetVisibleState() && !IsFooterTranslucent())
2914                         {
2915                                         clientBounds.height -= GetToolbarHeightF(false);
2916                         }
2917                 }
2918         }
2919 }
2920
2921 }}} // Tizen::Ui::Controls