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