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