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                 delete pTempBitmap;
 763
 764                 r = GET_BITMAP_CONFIG_N(FOOTER::SOFTKEY_ICON_ADD_DISABLED, BITMAP_PIXEL_FORMAT_ARGB8888, pTempBitmap);
 765                 SysTryReturnVoidResult(NID_UI_CTRL, r == E_SUCCESS, r, "[%s] Propagating.", GetErrorMessage(r));
 766
 767                 if (__pSoftkeyDisabledIcon[_SOFTKEY_0])
 768                 {
 769                         delete __pSoftkeyDisabledIcon[_SOFTKEY_0];
 770                         __pSoftkeyDisabledIcon[_SOFTKEY_0] = null;
 771                 }
 772                 __pSoftkeyDisabledIcon[_SOFTKEY_0] = _BitmapImpl::GetColorReplacedBitmapN(*pTempBitmap, Color::GetColor(COLOR_ID_MAGENTA), softkeyDisabledIconColor);
 773                 delete pTempBitmap;
 774
 775                 r = GET_BITMAP_CONFIG_N(FOOTER::SOFTKEY_ICON_ADD_PRESSED, BITMAP_PIXEL_FORMAT_ARGB8888, pTempBitmap);
 776                 SysTryReturnVoidResult(NID_UI_CTRL, r == E_SUCCESS, r, "[%s] Propagating.", GetErrorMessage(r));
 777
 778                 if (__pSoftkeyPressedIcon[_SOFTKEY_0])
 779                 {
 780                         delete __pSoftkeyPressedIcon[_SOFTKEY_0];
 781                         __pSoftkeyPressedIcon[_SOFTKEY_0] = null;
 782                 }
 783                 __pSoftkeyPressedIcon[_SOFTKEY_0] = _BitmapImpl::GetColorReplacedBitmapN(*pTempBitmap, Color::GetColor(COLOR_ID_MAGENTA), softkeyPressedIconColor);
 784                 delete pTempBitmap;
 785
 786                 r = GET_BITMAP_CONFIG_N(FOOTER::SOFTKEY_ICON_ADD_HIGHLIGHTED, BITMAP_PIXEL_FORMAT_ARGB8888, pTempBitmap);
 787                 SysTryReturnVoidResult(NID_UI_CTRL, r == E_SUCCESS, r, "[%s] Propagating.", GetErrorMessage(r));
 788
 789                 if (__pSoftkeyHighlightedIcon[_SOFTKEY_0])
 790                 {
 791                         delete __pSoftkeyHighlightedIcon[_SOFTKEY_0];
 792                         __pSoftkeyHighlightedIcon[_SOFTKEY_0] = null;
 793                 }
 794                 __pSoftkeyHighlightedIcon[_SOFTKEY_0] = _BitmapImpl::GetColorReplacedBitmapN(*pTempBitmap, Color::GetColor(COLOR_ID_MAGENTA), softkeyHighlightedIconColor);
 795                 delete pTempBitmap;
 796
 797                 _Button* pButton = _Button::CreateButtonN();
 798
 799                 if (pButton)
 800                 {
 801                         pButton->SetSize(softkeyDimension);
 802                         pButton->SetTextSize(fontSize);
 803                         pButton->SetMultilineTextSize(multilineFontSize);
 804                         pButton->SetUserDefinedTextArea(FloatRectangle(leftSoftkeyLeftMargin, softkeyTopMargin, softkeyDisplayDimension.width, softkeyDisplayDimension.height));
 805                         pButton->SetTextColor(_BUTTON_STATUS_NORMAL, softkeyNormalTextColor);
 806                         pButton->SetTextColor(_BUTTON_STATUS_DISABLED, softkeyDisabledTextColor);
 807                         pButton->SetTextColor(_BUTTON_STATUS_PRESSED, softkeyPressedTextColor);
 808                         pButton->SetTextColor(_BUTTON_STATUS_HIGHLIGHTED, softkeyHighlightedTextColor);
 809                         __pFooter->SetButton(LEFT_BUTTON, pButton);
 810                 }
 811         }
 812
 813         if (formStyle & FORM_STYLE_SOFTKEY_1)
 814         {
 815                 r = GET_BITMAP_CONFIG_N(FOOTER::SOFTKEY_RIGHT_BG_NORMAL, BITMAP_PIXEL_FORMAT_ARGB8888, pTempBitmap);
 816                 SysTryReturnVoidResult(NID_UI_CTRL, r == E_SUCCESS, r, "[%s] Propagating.", GetErrorMessage(r));
 817                 if (__pSoftkeyNormalBitmap[_SOFTKEY_1])
 818                 {
 819                         delete __pSoftkeyNormalBitmap[_SOFTKEY_1];
 820                         __pSoftkeyNormalBitmap[_SOFTKEY_1] = null;
 821                 }
 822                 __pSoftkeyNormalBitmap[_SOFTKEY_1] = _BitmapImpl::GetColorReplacedBitmapN(*pTempBitmap, Color::GetColor(COLOR_ID_MAGENTA), softkeyNormalBackgroundColor);
 823                 delete pTempBitmap;
 824
 825                 r = GET_BITMAP_CONFIG_N(FOOTER::SOFTKEY_RIGHT_BG_DISABLED, BITMAP_PIXEL_FORMAT_ARGB8888, pTempBitmap);
 826                 SysTryReturnVoidResult(NID_UI_CTRL, r == E_SUCCESS, r, "[%s] Propagating.", GetErrorMessage(r));
 827                 if (__pSoftkeyDisabledBitmap[_SOFTKEY_1])
 828                 {
 829                         delete __pSoftkeyDisabledBitmap[_SOFTKEY_1];
 830                         __pSoftkeyDisabledBitmap[_SOFTKEY_1] = null;
 831                 }
 832                 __pSoftkeyDisabledBitmap[_SOFTKEY_1] = _BitmapImpl::GetColorReplacedBitmapN(*pTempBitmap, Color::GetColor(COLOR_ID_MAGENTA), softkeyDisabledBackgroundColor);
 833                 delete pTempBitmap;
 834
 835                 r = GET_BITMAP_CONFIG_N(FOOTER::SOFTKEY_RIGHT_BG_PRESSED, BITMAP_PIXEL_FORMAT_ARGB8888, pTempBitmap);
 836                 SysTryReturnVoidResult(NID_UI_CTRL, r == E_SUCCESS, r, "[%s] Propagating.", GetErrorMessage(r));
 837                 if (__pSoftkeyPressedBitmap[_SOFTKEY_1])
 838                 {
 839                         delete __pSoftkeyPressedBitmap[_SOFTKEY_1];
 840                         __pSoftkeyPressedBitmap[_SOFTKEY_1] = null;
 841                 }
 842                 __pSoftkeyPressedBitmap[_SOFTKEY_1] = _BitmapImpl::GetColorReplacedBitmapN(*pTempBitmap, Color::GetColor(COLOR_ID_MAGENTA), softkeyPressedBackgroundColor);
 843                 delete pTempBitmap;
 844
 845                 r = GET_BITMAP_CONFIG_N(FOOTER::SOFTKEY_RIGHT_BG_HIGHLIGHTED, BITMAP_PIXEL_FORMAT_ARGB8888, pTempBitmap);
 846                 SysTryReturnVoidResult(NID_UI_CTRL, r == E_SUCCESS, r, "[%s] Propagating.", GetErrorMessage(r));
 847                 if (__pSoftkeyHighlightedBitmap[_SOFTKEY_1])
 848                 {
 849                         delete __pSoftkeyHighlightedBitmap[_SOFTKEY_1];
 850                         __pSoftkeyHighlightedBitmap[_SOFTKEY_1] = null;
 851                 }
 852                 __pSoftkeyHighlightedBitmap[_SOFTKEY_1] = _BitmapImpl::GetColorReplacedBitmapN(*pTempBitmap, Color::GetColor(COLOR_ID_MAGENTA), softkeyHighlightedBackgroundColor);
 853                 delete pTempBitmap;
 854
 855                 r = GET_BITMAP_CONFIG_N(FOOTER::SOFTKEY_RIGHT_TEXT_BG_NORMAL, BITMAP_PIXEL_FORMAT_ARGB8888, pTempBitmap);
 856                 SysTryReturnVoidResult(NID_UI_CTRL, r == E_SUCCESS, r, "[%s] Propagating.", GetErrorMessage(r));
 857                 if (__pTextSoftkeyNormalBitmap[_SOFTKEY_1])
 858                 {
 859                         delete __pTextSoftkeyNormalBitmap[_SOFTKEY_1];
 860                         __pTextSoftkeyNormalBitmap[_SOFTKEY_1] = null;
 861                 }
 862                 __pTextSoftkeyNormalBitmap[_SOFTKEY_1] = _BitmapImpl::GetColorReplacedBitmapN(*pTempBitmap, Color::GetColor(COLOR_ID_MAGENTA), softkeyNormalBackgroundColor);
 863                 delete pTempBitmap;
 864
 865                 r = GET_BITMAP_CONFIG_N(FOOTER::SOFTKEY_RIGHT_TEXT_BG_DISABLED, BITMAP_PIXEL_FORMAT_ARGB8888, pTempBitmap);
 866                 SysTryReturnVoidResult(NID_UI_CTRL, r == E_SUCCESS, r, "[%s] Propagating.", GetErrorMessage(r));
 867                 if (__pTextSoftkeyDisabledBitmap[_SOFTKEY_1])
 868                 {
 869                         delete __pTextSoftkeyDisabledBitmap[_SOFTKEY_1];
 870                         __pTextSoftkeyDisabledBitmap[_SOFTKEY_1] = null;
 871                 }
 872                 __pTextSoftkeyDisabledBitmap[_SOFTKEY_1] = _BitmapImpl::GetColorReplacedBitmapN(*pTempBitmap, Color::GetColor(COLOR_ID_MAGENTA), softkeyDisabledBackgroundColor);
 873                 delete pTempBitmap;
 874
 875                 r = GET_BITMAP_CONFIG_N(FOOTER::SOFTKEY_RIGHT_TEXT_BG_PRESSED, BITMAP_PIXEL_FORMAT_ARGB8888, pTempBitmap);
 876                 SysTryReturnVoidResult(NID_UI_CTRL, r == E_SUCCESS, r, "[%s] Propagating.", GetErrorMessage(r));
 877                 if (__pTextSoftkeyPressedBitmap[_SOFTKEY_1])
 878                 {
 879                         delete __pTextSoftkeyPressedBitmap[_SOFTKEY_1];
 880                         __pTextSoftkeyPressedBitmap[_SOFTKEY_1] = null;
 881                 }
 882                 __pTextSoftkeyPressedBitmap[_SOFTKEY_1] = _BitmapImpl::GetColorReplacedBitmapN(*pTempBitmap, Color::GetColor(COLOR_ID_MAGENTA), softkeyPressedBackgroundColor);
 883                 delete pTempBitmap;
 884
 885                 r = GET_BITMAP_CONFIG_N(FOOTER::SOFTKEY_RIGHT_TEXT_BG_HIGHLIGHTED, BITMAP_PIXEL_FORMAT_ARGB8888, pTempBitmap);
 886                 SysTryReturnVoidResult(NID_UI_CTRL, r == E_SUCCESS, r, "[%s] Propagating.", GetErrorMessage(r));
 887                 if (__pTextSoftkeyHighlightedBitmap[_SOFTKEY_1])
 888                 {
 889                         delete __pTextSoftkeyHighlightedBitmap[_SOFTKEY_1];
 890                         __pTextSoftkeyHighlightedBitmap[_SOFTKEY_1] = null;
 891                 }
 892                 __pTextSoftkeyHighlightedBitmap[_SOFTKEY_1] = _BitmapImpl::GetColorReplacedBitmapN(*pTempBitmap, Color::GetColor(COLOR_ID_MAGENTA), softkeyHighlightedBackgroundColor);
 893                 delete pTempBitmap;
 894
 895                 r = GET_BITMAP_CONFIG_N(FOOTER::SOFTKEY_RIGHT_BG_EFFECT_NORMAL, BITMAP_PIXEL_FORMAT_ARGB8888, pTempBitmap);
 896                 SysTryReturnVoidResult(NID_UI_CTRL, r == E_SUCCESS, r, "[%s] Propagating.", GetErrorMessage(r));
 897                 if (__pSoftkeyNormalEffectBitmap[_SOFTKEY_1])
 898                 {
 899                         delete __pSoftkeyNormalEffectBitmap[_SOFTKEY_1];
 900                         __pSoftkeyNormalEffectBitmap[_SOFTKEY_1] = null;
 901                 }
 902                 __pSoftkeyNormalEffectBitmap[_SOFTKEY_1] = _BitmapImpl::GetColorReplacedBitmapN(*pTempBitmap, Color::GetColor(COLOR_ID_MAGENTA), softkeyNormalBackgroundColor);
 903                 delete pTempBitmap;
 904
 905                 r = GET_BITMAP_CONFIG_N(FOOTER::SOFTKEY_RIGHT_TEXT_BG_EFFECT_NORMAL, BITMAP_PIXEL_FORMAT_ARGB8888, pTempBitmap);
 906                 SysTryReturnVoidResult(NID_UI_CTRL, r == E_SUCCESS, r, "[%s] Propagating.", GetErrorMessage(r));
 907                 if (__pTextSoftkeyNormalEffectBitmap[_SOFTKEY_1])
 908                 {
 909                         delete __pTextSoftkeyNormalEffectBitmap[_SOFTKEY_1];
 910                         __pTextSoftkeyNormalEffectBitmap[_SOFTKEY_1] = null;
 911                 }
 912                 __pTextSoftkeyNormalEffectBitmap[_SOFTKEY_1] = _BitmapImpl::GetColorReplacedBitmapN(*pTempBitmap, Color::GetColor(COLOR_ID_MAGENTA), softkeyNormalBackgroundColor);
 913                 delete pTempBitmap;
 914
 915                 r = GET_BITMAP_CONFIG_N(FOOTER::SOFTKEY_RIGHT_BG_EFFECT_PRESSED, BITMAP_PIXEL_FORMAT_ARGB8888, pTempBitmap);
 916                 SysTryReturnVoidResult(NID_UI_CTRL, r == E_SUCCESS, r, "[%s] Propagating.", GetErrorMessage(r));
 917                 if (__pSoftkeyPressedEffectBitmap[_SOFTKEY_1])
 918                 {
 919                         delete __pSoftkeyPressedEffectBitmap[_SOFTKEY_1];
 920                         __pSoftkeyPressedEffectBitmap[_SOFTKEY_1] = null;
 921                 }
 922                 __pSoftkeyPressedEffectBitmap[_SOFTKEY_1] = _BitmapImpl::GetColorReplacedBitmapN(*pTempBitmap, Color::GetColor(COLOR_ID_MAGENTA), softkeyPressedBackgroundColor);
 923                 delete pTempBitmap;
 924
 925                 r = GET_BITMAP_CONFIG_N(FOOTER::SOFTKEY_RIGHT_TEXT_BG_EFFECT_PRESSED, BITMAP_PIXEL_FORMAT_ARGB8888, pTempBitmap);
 926                 SysTryReturnVoidResult(NID_UI_CTRL, r == E_SUCCESS, r, "[%s] Propagating.", GetErrorMessage(r));
 927                 if (__pTextSoftkeyPressedEffectBitmap[_SOFTKEY_1])
 928                 {
 929                         delete __pTextSoftkeyPressedEffectBitmap[_SOFTKEY_1];
 930                         __pTextSoftkeyPressedEffectBitmap[_SOFTKEY_1] = null;
 931                 }
 932                 __pTextSoftkeyPressedEffectBitmap[_SOFTKEY_1] = _BitmapImpl::GetColorReplacedBitmapN(*pTempBitmap, Color::GetColor(COLOR_ID_MAGENTA), softkeyPressedBackgroundColor);
 933                 delete pTempBitmap;
 934
 935
 936                 r = GET_BITMAP_CONFIG_N(FOOTER::SOFTKEY_ICON_ZOOM_NORMAL, BITMAP_PIXEL_FORMAT_ARGB8888, pTempBitmap);
 937                 SysTryReturnVoidResult(NID_UI_CTRL, r == E_SUCCESS, r, "[%s] Propagating.", GetErrorMessage(r));
 938
 939                 if (__pSoftkeyNormalIcon[_SOFTKEY_1])
 940                 {
 941                         delete __pSoftkeyNormalIcon[_SOFTKEY_1];
 942                         __pSoftkeyNormalIcon[_SOFTKEY_1] = null;
 943                 }
 944                 __pSoftkeyNormalIcon[_SOFTKEY_1] = _BitmapImpl::GetColorReplacedBitmapN(*pTempBitmap, Color::GetColor(COLOR_ID_MAGENTA), softkeyNormalIconColor);
 945                 delete pTempBitmap;
 946
 947                 r = GET_BITMAP_CONFIG_N(FOOTER::SOFTKEY_ICON_ZOOM_DISABLED, BITMAP_PIXEL_FORMAT_ARGB8888, pTempBitmap);
 948                 SysTryReturnVoidResult(NID_UI_CTRL, r == E_SUCCESS, r, "[%s] Propagating.", GetErrorMessage(r));
 949
 950                 if (__pSoftkeyDisabledIcon[_SOFTKEY_1])
 951                 {
 952                         delete __pSoftkeyDisabledIcon[_SOFTKEY_1];
 953                         __pSoftkeyDisabledIcon[_SOFTKEY_1] = null;
 954                 }
 955                 __pSoftkeyDisabledIcon[_SOFTKEY_1] = _BitmapImpl::GetColorReplacedBitmapN(*pTempBitmap, Color::GetColor(COLOR_ID_MAGENTA), softkeyDisabledIconColor);
 956                 delete pTempBitmap;
 957
 958                 r = GET_BITMAP_CONFIG_N(FOOTER::SOFTKEY_ICON_ZOOM_PRESSED, BITMAP_PIXEL_FORMAT_ARGB8888, pTempBitmap);
 959                 SysTryReturnVoidResult(NID_UI_CTRL, r == E_SUCCESS, r, "[%s] Propagating.", GetErrorMessage(r));
 960
 961                 if (__pSoftkeyPressedIcon[_SOFTKEY_1])
 962                 {
 963                         delete __pSoftkeyPressedIcon[_SOFTKEY_1];
 964                         __pSoftkeyPressedIcon[_SOFTKEY_1] = null;
 965                 }
 966                 __pSoftkeyPressedIcon[_SOFTKEY_1] = _BitmapImpl::GetColorReplacedBitmapN(*pTempBitmap, Color::GetColor(COLOR_ID_MAGENTA), softkeyPressedIconColor);
 967                 delete pTempBitmap;
 968
 969                 r = GET_BITMAP_CONFIG_N(FOOTER::SOFTKEY_ICON_ZOOM_HIGHLIGHTED, BITMAP_PIXEL_FORMAT_ARGB8888, pTempBitmap);
 970                 SysTryReturnVoidResult(NID_UI_CTRL, r == E_SUCCESS, r, "[%s] Propagating.", GetErrorMessage(r));
 971
 972                 if (__pSoftkeyHighlightedIcon[_SOFTKEY_1])
 973                 {
 974                         delete __pSoftkeyHighlightedIcon[_SOFTKEY_1];
 975                         __pSoftkeyHighlightedIcon[_SOFTKEY_1] = null;
 976                 }
 977                 __pSoftkeyHighlightedIcon[_SOFTKEY_1] = _BitmapImpl::GetColorReplacedBitmapN(*pTempBitmap, Color::GetColor(COLOR_ID_MAGENTA), softkeyHighlightedIconColor);
 978                 delete pTempBitmap;
 979
 980                 _Button* pButton = _Button::CreateButtonN();
 981                 if (pButton)
 982                 {
 983                         pButton->SetSize(softkeyDimension);
 984                         pButton->SetTextSize(fontSize);
 985                         pButton->SetMultilineTextSize(multilineFontSize);
 986                         pButton->SetUserDefinedTextArea(FloatRectangle(rightSoftkeyLeftMargin, softkeyTopMargin, softkeyDisplayDimension.width, softkeyDisplayDimension.height));
 987                         pButton->SetTextColor(_BUTTON_STATUS_NORMAL, softkeyNormalTextColor);
 988                         pButton->SetTextColor(_BUTTON_STATUS_DISABLED, softkeyDisabledTextColor);
 989                         pButton->SetTextColor(_BUTTON_STATUS_PRESSED, softkeyPressedTextColor);
 990                         pButton->SetTextColor(_BUTTON_STATUS_HIGHLIGHTED, softkeyHighlightedTextColor);
 991                         __pFooter->SetButton(RIGHT_BUTTON, pButton);
 992                 }
 993         }
 994
 995         if (formStyle & FORM_STYLE_OPTIONKEY)
 996         {
 997                 r = GET_BITMAP_CONFIG_N(FOOTER::OPTIONKEY_BG_NORMAL, BITMAP_PIXEL_FORMAT_ARGB8888, pTempBitmap);
 998                 SysTryReturnVoidResult(NID_UI_CTRL, r == E_SUCCESS, r, "[%s] Propagating.", GetErrorMessage(r));
 999                 if (__pSoftkeyNormalBitmap[SOFTKEY_COUNT])
1000                 {
1001                         delete __pSoftkeyNormalBitmap[SOFTKEY_COUNT];
1002                         __pSoftkeyNormalBitmap[SOFTKEY_COUNT] = null;
1003                 }
1004                 __pSoftkeyNormalBitmap[SOFTKEY_COUNT] = _BitmapImpl::GetColorReplacedBitmapN(*pTempBitmap, Color::GetColor(COLOR_ID_MAGENTA), softkeyNormalBackgroundColor);
1005                 delete pTempBitmap;
1006
1007                 r = GET_BITMAP_CONFIG_N(FOOTER::OPTIONKEY_BG_DISABLED, BITMAP_PIXEL_FORMAT_ARGB8888, pTempBitmap);
1008                 SysTryReturnVoidResult(NID_UI_CTRL, r == E_SUCCESS, r, "[%s] Propagating.", GetErrorMessage(r));
1009                 if (__pSoftkeyDisabledBitmap[SOFTKEY_COUNT])
1010                 {
1011                         delete __pSoftkeyDisabledBitmap[SOFTKEY_COUNT];
1012                         __pSoftkeyDisabledBitmap[SOFTKEY_COUNT] = null;
1013                 }
1014                 __pSoftkeyDisabledBitmap[SOFTKEY_COUNT] = _BitmapImpl::GetColorReplacedBitmapN(*pTempBitmap, Color::GetColor(COLOR_ID_MAGENTA), softkeyDisabledBackgroundColor);
1015                 delete pTempBitmap;
1016
1017                 r = GET_BITMAP_CONFIG_N(FOOTER::OPTIONKEY_BG_PRESSED, BITMAP_PIXEL_FORMAT_ARGB8888, pTempBitmap);
1018                 SysTryReturnVoidResult(NID_UI_CTRL, r == E_SUCCESS, r, "[%s] Propagating.", GetErrorMessage(r));
1019                 if (__pSoftkeyPressedBitmap[SOFTKEY_COUNT])
1020                 {
1021                         delete __pSoftkeyPressedBitmap[SOFTKEY_COUNT];
1022                         __pSoftkeyPressedBitmap[SOFTKEY_COUNT] = null;
1023                 }
1024                 __pSoftkeyPressedBitmap[SOFTKEY_COUNT] = _BitmapImpl::GetColorReplacedBitmapN(*pTempBitmap, Color::GetColor(COLOR_ID_MAGENTA), softkeyPressedBackgroundColor);
1025                 delete pTempBitmap;
1026
1027                 r = GET_BITMAP_CONFIG_N(FOOTER::OPTIONKEY_BG_HIGHLIGHTED, BITMAP_PIXEL_FORMAT_ARGB8888, pTempBitmap);
1028                 SysTryReturnVoidResult(NID_UI_CTRL, r == E_SUCCESS, r, "[%s] Propagating.", GetErrorMessage(r));
1029                 if (__pSoftkeyHighlightedBitmap[SOFTKEY_COUNT])
1030                 {
1031                         delete __pSoftkeyHighlightedBitmap[SOFTKEY_COUNT];
1032                         __pSoftkeyHighlightedBitmap[SOFTKEY_COUNT] = null;
1033                 }
1034                 __pSoftkeyHighlightedBitmap[SOFTKEY_COUNT] = _BitmapImpl::GetColorReplacedBitmapN(*pTempBitmap, Color::GetColor(COLOR_ID_MAGENTA), softkeyHighlightedBackgroundColor);
1035                 delete pTempBitmap;
1036
1037                 r = GET_BITMAP_CONFIG_N(FOOTER::OPTIONKEY_BG_EFFECT_NORMAL, BITMAP_PIXEL_FORMAT_ARGB8888, pTempBitmap);
1038                 SysTryReturnVoidResult(NID_UI_CTRL, r == E_SUCCESS, r, "[%s] Propagating.", GetErrorMessage(r));
1039                 if (__pSoftkeyNormalEffectBitmap[SOFTKEY_COUNT])
1040                 {
1041                         delete __pSoftkeyNormalEffectBitmap[SOFTKEY_COUNT];
1042                         __pSoftkeyNormalEffectBitmap[SOFTKEY_COUNT] = null;
1043                 }
1044                 __pSoftkeyNormalEffectBitmap[SOFTKEY_COUNT] = _BitmapImpl::GetColorReplacedBitmapN(*pTempBitmap, Color::GetColor(COLOR_ID_MAGENTA), softkeyNormalBackgroundColor);
1045                 delete pTempBitmap;
1046
1047                 r = GET_BITMAP_CONFIG_N(FOOTER::OPTIONKEY_BG_EFFECT_PRESSED, BITMAP_PIXEL_FORMAT_ARGB8888, pTempBitmap);
1048                 SysTryReturnVoidResult(NID_UI_CTRL, r == E_SUCCESS, r, "[%s] Propagating.", GetErrorMessage(r));
1049                 if (__pSoftkeyPressedEffectBitmap[SOFTKEY_COUNT])
1050                 {
1051                         delete __pSoftkeyPressedEffectBitmap[SOFTKEY_COUNT];
1052                         __pSoftkeyPressedEffectBitmap[SOFTKEY_COUNT] = null;
1053                 }
1054                 __pSoftkeyPressedEffectBitmap[SOFTKEY_COUNT] = _BitmapImpl::GetColorReplacedBitmapN(*pTempBitmap, Color::GetColor(COLOR_ID_MAGENTA), softkeyPressedBackgroundColor);
1055                 delete pTempBitmap;
1056
1057                 r = GET_BITMAP_CONFIG_N(FOOTER::OPTIONKEY_HANDLE_MORE_NORMAL, BITMAP_PIXEL_FORMAT_ARGB8888, pTempBitmap);
1058                 SysTryReturnVoidResult(NID_UI_CTRL, r == E_SUCCESS, r, "[%s] Propagating.", GetErrorMessage(r));
1059
1060                 if (__pSoftkeyNormalIcon[SOFTKEY_COUNT])
1061                 {
1062                         delete __pSoftkeyNormalIcon[SOFTKEY_COUNT];
1063                         __pSoftkeyNormalIcon[SOFTKEY_COUNT] = null;
1064                 }
1065                 __pSoftkeyNormalIcon[SOFTKEY_COUNT] = _BitmapImpl::GetColorReplacedBitmapN(*pTempBitmap, Color::GetColor(COLOR_ID_MAGENTA), softkeyNormalIconColor);
1066                 delete pTempBitmap;
1067
1068                 r = GET_BITMAP_CONFIG_N(FOOTER::OPTIONKEY_HANDLE_MORE_DISABLED, BITMAP_PIXEL_FORMAT_ARGB8888, pTempBitmap);
1069                 SysTryReturnVoidResult(NID_UI_CTRL, r == E_SUCCESS, r, "[%s] Propagating.", GetErrorMessage(r));
1070
1071                 if (__pSoftkeyDisabledIcon[SOFTKEY_COUNT])
1072                 {
1073                         delete __pSoftkeyDisabledIcon[SOFTKEY_COUNT];
1074                         __pSoftkeyDisabledIcon[SOFTKEY_COUNT] = null;
1075                 }
1076                 __pSoftkeyDisabledIcon[SOFTKEY_COUNT] = _BitmapImpl::GetColorReplacedBitmapN(*pTempBitmap, Color::GetColor(COLOR_ID_MAGENTA), softkeyDisabledIconColor);
1077                 delete pTempBitmap;
1078
1079                 r = GET_BITMAP_CONFIG_N(FOOTER::OPTIONKEY_HANDLE_MORE_PRESSED, BITMAP_PIXEL_FORMAT_ARGB8888, pTempBitmap);
1080                 SysTryReturnVoidResult(NID_UI_CTRL, r == E_SUCCESS, r, "[%s] Propagating.", GetErrorMessage(r));
1081
1082                 if (__pSoftkeyPressedIcon[SOFTKEY_COUNT])
1083                 {
1084                         delete __pSoftkeyPressedIcon[SOFTKEY_COUNT];
1085                         __pSoftkeyPressedIcon[SOFTKEY_COUNT] = null;
1086                 }
1087                 __pSoftkeyPressedIcon[SOFTKEY_COUNT] = _BitmapImpl::GetColorReplacedBitmapN(*pTempBitmap, Color::GetColor(COLOR_ID_MAGENTA), softkeyPressedIconColor);
1088                 delete pTempBitmap;
1089
1090                 r = GET_BITMAP_CONFIG_N(FOOTER::OPTIONKEY_HANDLE_MORE_HIGHLIGHTED, BITMAP_PIXEL_FORMAT_ARGB8888, pTempBitmap);
1091                 SysTryReturnVoidResult(NID_UI_CTRL, r == E_SUCCESS, r, "[%s] Propagating.", GetErrorMessage(r));
1092
1093                 if (__pSoftkeyHighlightedIcon[SOFTKEY_COUNT])
1094                 {
1095                         delete __pSoftkeyHighlightedIcon[SOFTKEY_COUNT];
1096                         __pSoftkeyHighlightedIcon[SOFTKEY_COUNT] = null;
1097                 }
1098                 __pSoftkeyHighlightedIcon[SOFTKEY_COUNT] = _BitmapImpl::GetColorReplacedBitmapN(*pTempBitmap, Color::GetColor(COLOR_ID_MAGENTA), softkeyHighlightedIconColor);
1099                 delete pTempBitmap;
1100
1101                 _Button* pButton = _Button::CreateButtonN();
1102                 if (pButton)
1103                 {
1104                         pButton->SetSize(optionkeyDimension);
1105                         pButton->SetTextColor(_BUTTON_STATUS_NORMAL, softkeyNormalTextColor);
1106                         pButton->SetTextColor(_BUTTON_STATUS_DISABLED, softkeyDisabledTextColor);
1107                         pButton->SetTextColor(_BUTTON_STATUS_PRESSED, softkeyPressedTextColor);
1108                         pButton->SetTextColor(_BUTTON_STATUS_HIGHLIGHTED, softkeyHighlightedTextColor);
1109                         __pFooter->SetButton(MIDDLE_BUTTON, pButton);
1110                 }
1111         }
1112 }
1113
1114 void
1115 _Form::UpdateSoftkey(unsigned long formStyle)
1116 {
1117         float softkeyIconGap = 3.0f;
1118
1119         if (__formStyle & FORM_STYLE_SOFTKEY_0)// && __updatedSoftkeyCount % 2 == 0)
1120         {
1121                 if (__pFooter->GetButton(LEFT_BUTTON))
1122                 {
1123                         __pFooter->GetButton(LEFT_BUTTON)->SetActionId(__actionId[_SOFTKEY_0]);
1124
1125                         if (__softkeyText[_SOFTKEY_0] != String())
1126                         {
1127                                 if (__pTextSoftkeyNormalBitmap[_SOFTKEY_0])
1128                                 {
1129                                         __pFooter->GetButton(LEFT_BUTTON)->SetBackgroundBitmap(_BUTTON_STATUS_NORMAL, *__pTextSoftkeyNormalBitmap[_SOFTKEY_0]);
1130                                 }
1131
1132                                 if (__pTextSoftkeyDisabledBitmap[_SOFTKEY_0])
1133                                 {
1134                                         __pFooter->GetButton(LEFT_BUTTON)->SetBackgroundBitmap(_BUTTON_STATUS_DISABLED, *__pTextSoftkeyDisabledBitmap[_SOFTKEY_0]);
1135                                 }
1136
1137                                 if (__pTextSoftkeyPressedBitmap[_SOFTKEY_0])
1138                                 {
1139                                         __pFooter->GetButton(LEFT_BUTTON)->SetBackgroundBitmap(_BUTTON_STATUS_PRESSED, *__pTextSoftkeyPressedBitmap[_SOFTKEY_0]);
1140                                 }
1141
1142                                 if (__pTextSoftkeyHighlightedBitmap[_SOFTKEY_0])
1143                                 {
1144                                         __pFooter->GetButton(LEFT_BUTTON)->SetBackgroundBitmap(_BUTTON_STATUS_HIGHLIGHTED, *__pTextSoftkeyHighlightedBitmap[_SOFTKEY_0]);
1145                                 }
1146
1147                                 if (__pTextSoftkeyNormalEffectBitmap[_SOFTKEY_0])
1148                                 {
1149                                         __pFooter->GetButton(LEFT_BUTTON)->SetBackgroundEffectBitmap(_BUTTON_STATUS_NORMAL, *__pTextSoftkeyNormalEffectBitmap[_SOFTKEY_0]);
1150                                 }
1151
1152                                 if (__pTextSoftkeyPressedEffectBitmap[_SOFTKEY_0])
1153                                 {
1154                                         __pFooter->GetButton(LEFT_BUTTON)->SetBackgroundEffectBitmap(_BUTTON_STATUS_PRESSED, *__pTextSoftkeyPressedEffectBitmap[_SOFTKEY_0]);
1155                                 }
1156
1157                                 __pFooter->GetButton(LEFT_BUTTON)->SetText(__softkeyText[_SOFTKEY_0]);
1158
1159                                 __pFooter->RearrangeItems();
1160                         }
1161                         else
1162                         {
1163                                 if (__pSoftkeyNormalBitmap[_SOFTKEY_0])
1164                                 {
1165                                         __pFooter->GetButton(LEFT_BUTTON)->SetBackgroundBitmap(_BUTTON_STATUS_NORMAL, *__pSoftkeyNormalBitmap[_SOFTKEY_0]);
1166                                 }
1167
1168                                 if (__pSoftkeyDisabledBitmap[_SOFTKEY_0])
1169                                 {
1170                                         __pFooter->GetButton(LEFT_BUTTON)->SetBackgroundBitmap(_BUTTON_STATUS_DISABLED, *__pSoftkeyDisabledBitmap[_SOFTKEY_0]);
1171                                 }
1172
1173                                 if (__pSoftkeyPressedBitmap[_SOFTKEY_0])
1174                                 {
1175                                         __pFooter->GetButton(LEFT_BUTTON)->SetBackgroundBitmap(_BUTTON_STATUS_PRESSED, *__pSoftkeyPressedBitmap[_SOFTKEY_0]);
1176                                 }
1177
1178                                 if (__pSoftkeyHighlightedBitmap[_SOFTKEY_0])
1179                                 {
1180                                         __pFooter->GetButton(LEFT_BUTTON)->SetBackgroundBitmap(_BUTTON_STATUS_HIGHLIGHTED, *__pSoftkeyHighlightedBitmap[_SOFTKEY_0]);
1181                                 }
1182
1183                                 if (__pSoftkeyNormalEffectBitmap[_SOFTKEY_0])
1184                                 {
1185                                         __pFooter->GetButton(LEFT_BUTTON)->SetBackgroundEffectBitmap(_BUTTON_STATUS_NORMAL, *__pSoftkeyNormalEffectBitmap[_SOFTKEY_0]);
1186                                 }
1187
1188                                 if (__pSoftkeyPressedEffectBitmap[_SOFTKEY_0])
1189                                 {
1190                                         __pFooter->GetButton(LEFT_BUTTON)->SetBackgroundEffectBitmap(_BUTTON_STATUS_PRESSED, *__pSoftkeyPressedEffectBitmap[_SOFTKEY_0]);
1191                                 }
1192
1193                                 if (__pSoftkeyNormalIcon[_SOFTKEY_0])
1194                                 {
1195                                         __pFooter->GetButton(LEFT_BUTTON)->SetBitmap(_BUTTON_STATUS_NORMAL,
1196                                                         FloatPoint((__pFooter->GetButton(LEFT_BUTTON)->GetSizeF().width - __pSoftkeyNormalIcon[_SOFTKEY_0]->GetWidthF()) / 2,
1197                                                                         (__pFooter->GetButton(LEFT_BUTTON)->GetSizeF().height - __pSoftkeyNormalIcon[_SOFTKEY_0]->GetHeightF()) / 2 + softkeyIconGap), *__pSoftkeyNormalIcon[_SOFTKEY_0]);
1198                                 }
1199
1200                                 if (__pSoftkeyDisabledIcon[_SOFTKEY_0])
1201                                 {
1202                                         __pFooter->GetButton(LEFT_BUTTON)->SetBitmap(_BUTTON_STATUS_DISABLED,
1203                                                         FloatPoint((__pFooter->GetButton(LEFT_BUTTON)->GetSizeF().width - __pSoftkeyDisabledIcon[_SOFTKEY_0]->GetWidthF()) / 2,
1204                                                                         (__pFooter->GetButton(LEFT_BUTTON)->GetSizeF().height - __pSoftkeyDisabledIcon[_SOFTKEY_0]->GetHeightF()) / 2 + softkeyIconGap), *__pSoftkeyDisabledIcon[_SOFTKEY_0]);
1205                                 }
1206
1207                                 if (__pSoftkeyPressedIcon[_SOFTKEY_0])
1208                                 {
1209                                         __pFooter->GetButton(LEFT_BUTTON)->SetBitmap(_BUTTON_STATUS_PRESSED,
1210                                                         FloatPoint((__pFooter->GetButton(LEFT_BUTTON)->GetSizeF().width - __pSoftkeyPressedIcon[_SOFTKEY_0]->GetWidthF()) / 2,
1211                                                                         (__pFooter->GetButton(LEFT_BUTTON)->GetSizeF().height - __pSoftkeyPressedIcon[_SOFTKEY_0]->GetHeightF()) / 2 + softkeyIconGap), *__pSoftkeyPressedIcon[_SOFTKEY_0]);
1212                                 }
1213
1214                                 if (__pSoftkeyHighlightedIcon[_SOFTKEY_0])
1215                                 {
1216                                         __pFooter->GetButton(LEFT_BUTTON)->SetBitmap(_BUTTON_STATUS_HIGHLIGHTED,
1217                                                         FloatPoint((__pFooter->GetButton(LEFT_BUTTON)->GetSizeF().width - __pSoftkeyHighlightedIcon[_SOFTKEY_0]->GetWidthF()) / 2,
1218                                                                         (__pFooter->GetButton(LEFT_BUTTON)->GetSizeF().height - __pSoftkeyHighlightedIcon[_SOFTKEY_0]->GetHeightF()) / 2 + softkeyIconGap), *__pSoftkeyHighlightedIcon[_SOFTKEY_0]);
1219                                 }
1220                         }
1221                 }
1222         }
1223
1224         if (__formStyle & FORM_STYLE_SOFTKEY_1)// && __updatedSoftkeyCount % 2 == 0)
1225         {
1226                 if (__pFooter->GetButton(RIGHT_BUTTON))
1227                 {
1228                         __pFooter->GetButton(RIGHT_BUTTON)->SetActionId(__actionId[_SOFTKEY_1]);
1229
1230                         if (__softkeyText[_SOFTKEY_1] != String())
1231                         {
1232                                 if (__pTextSoftkeyNormalBitmap[_SOFTKEY_1])
1233                                 {
1234                                         __pFooter->GetButton(RIGHT_BUTTON)->SetBackgroundBitmap(_BUTTON_STATUS_NORMAL, *__pTextSoftkeyNormalBitmap[_SOFTKEY_1]);
1235                                 }
1236
1237                                 if (__pTextSoftkeyDisabledBitmap[_SOFTKEY_1])
1238                                 {
1239                                         __pFooter->GetButton(RIGHT_BUTTON)->SetBackgroundBitmap(_BUTTON_STATUS_DISABLED, *__pTextSoftkeyDisabledBitmap[_SOFTKEY_1]);
1240                                 }
1241
1242                                 if (__pTextSoftkeyPressedBitmap[_SOFTKEY_1])
1243                                 {
1244                                         __pFooter->GetButton(RIGHT_BUTTON)->SetBackgroundBitmap(_BUTTON_STATUS_PRESSED, *__pTextSoftkeyPressedBitmap[_SOFTKEY_1]);
1245                                 }
1246
1247                                 if (__pTextSoftkeyHighlightedBitmap[_SOFTKEY_1])
1248                                 {
1249                                         __pFooter->GetButton(RIGHT_BUTTON)->SetBackgroundBitmap(_BUTTON_STATUS_HIGHLIGHTED, *__pTextSoftkeyHighlightedBitmap[_SOFTKEY_1]);
1250                                 }
1251
1252                                 if (__pTextSoftkeyNormalEffectBitmap[_SOFTKEY_1])
1253                                 {
1254                                         __pFooter->GetButton(RIGHT_BUTTON)->SetBackgroundEffectBitmap(_BUTTON_STATUS_NORMAL, *__pTextSoftkeyNormalEffectBitmap[_SOFTKEY_1]);
1255                                 }
1256
1257                                 if (__pTextSoftkeyPressedEffectBitmap[_SOFTKEY_1])
1258                                 {
1259                                         __pFooter->GetButton(RIGHT_BUTTON)->SetBackgroundEffectBitmap(_BUTTON_STATUS_PRESSED, *__pTextSoftkeyPressedEffectBitmap[_SOFTKEY_1]);
1260                                 }
1261
1262                                 __pFooter->GetButton(RIGHT_BUTTON)->SetText(__softkeyText[_SOFTKEY_1]);
1263
1264                                 __pFooter->RearrangeItems();
1265                         }
1266                         else
1267                         {
1268                                 if (__pSoftkeyNormalBitmap[_SOFTKEY_1])
1269                                 {
1270                                         __pFooter->GetButton(RIGHT_BUTTON)->SetBackgroundBitmap(_BUTTON_STATUS_NORMAL, *__pSoftkeyNormalBitmap[_SOFTKEY_1]);
1271                                 }
1272
1273                                 if (__pSoftkeyDisabledBitmap[_SOFTKEY_1])
1274                                 {
1275                                         __pFooter->GetButton(RIGHT_BUTTON)->SetBackgroundBitmap(_BUTTON_STATUS_DISABLED, *__pSoftkeyDisabledBitmap[_SOFTKEY_1]);
1276                                 }
1277
1278                                 if (__pSoftkeyPressedBitmap[_SOFTKEY_1])
1279                                 {
1280                                         __pFooter->GetButton(RIGHT_BUTTON)->SetBackgroundBitmap(_BUTTON_STATUS_PRESSED, *__pSoftkeyPressedBitmap[_SOFTKEY_1]);
1281                                 }
1282
1283                                 if (__pSoftkeyHighlightedBitmap[_SOFTKEY_1])
1284                                 {
1285                                         __pFooter->GetButton(RIGHT_BUTTON)->SetBackgroundBitmap(_BUTTON_STATUS_HIGHLIGHTED, *__pSoftkeyHighlightedBitmap[_SOFTKEY_1]);
1286                                 }
1287
1288                                 if (__pSoftkeyNormalEffectBitmap[_SOFTKEY_1])
1289                                 {
1290                                         __pFooter->GetButton(RIGHT_BUTTON)->SetBackgroundEffectBitmap(_BUTTON_STATUS_NORMAL, *__pSoftkeyNormalEffectBitmap[_SOFTKEY_1]);
1291                                 }
1292
1293                                 if (__pSoftkeyPressedEffectBitmap[_SOFTKEY_1])
1294                                 {
1295                                         __pFooter->GetButton(RIGHT_BUTTON)->SetBackgroundEffectBitmap(_BUTTON_STATUS_PRESSED, *__pSoftkeyPressedEffectBitmap[_SOFTKEY_1]);
1296                                 }
1297
1298                                 if (__pSoftkeyNormalIcon[_SOFTKEY_1])
1299                                 {
1300                                         __pFooter->GetButton(RIGHT_BUTTON)->SetBitmap(_BUTTON_STATUS_NORMAL,
1301                                                         FloatPoint((__pFooter->GetButton(RIGHT_BUTTON)->GetSizeF().width - __pSoftkeyNormalIcon[_SOFTKEY_1]->GetWidthF()) / 2,
1302                                                                         (__pFooter->GetButton(RIGHT_BUTTON)->GetSizeF().height - __pSoftkeyNormalIcon[_SOFTKEY_1]->GetHeightF()) / 2 + softkeyIconGap), *__pSoftkeyNormalIcon[_SOFTKEY_1]);
1303                                 }
1304
1305                                 if (__pSoftkeyDisabledIcon[_SOFTKEY_1])
1306                                 {
1307                                         __pFooter->GetButton(RIGHT_BUTTON)->SetBitmap(_BUTTON_STATUS_DISABLED,
1308                                                         FloatPoint((__pFooter->GetButton(RIGHT_BUTTON)->GetSizeF().width - __pSoftkeyDisabledIcon[_SOFTKEY_1]->GetWidthF()) / 2,
1309                                                                         (__pFooter->GetButton(RIGHT_BUTTON)->GetSizeF().height - __pSoftkeyDisabledIcon[_SOFTKEY_1]->GetHeightF()) / 2 + softkeyIconGap), *__pSoftkeyDisabledIcon[_SOFTKEY_1]);
1310                                 }
1311
1312                                 if (__pSoftkeyPressedIcon[_SOFTKEY_1])
1313                                 {
1314                                         __pFooter->GetButton(RIGHT_BUTTON)->SetBitmap(_BUTTON_STATUS_PRESSED,
1315                                                         FloatPoint((__pFooter->GetButton(RIGHT_BUTTON)->GetSizeF().width - __pSoftkeyPressedIcon[_SOFTKEY_1]->GetWidthF()) / 2,
1316                                                                         (__pFooter->GetButton(RIGHT_BUTTON)->GetSizeF().height - __pSoftkeyPressedIcon[_SOFTKEY_1]->GetHeightF()) / 2 + softkeyIconGap), *__pSoftkeyPressedIcon[_SOFTKEY_1]);
1317                                 }
1318
1319                                 if (__pSoftkeyHighlightedIcon[_SOFTKEY_1])
1320                                 {
1321                                         __pFooter->GetButton(RIGHT_BUTTON)->SetBitmap(_BUTTON_STATUS_HIGHLIGHTED,
1322                                                         FloatPoint((__pFooter->GetButton(RIGHT_BUTTON)->GetSizeF().width - __pSoftkeyHighlightedIcon[_SOFTKEY_1]->GetWidthF()) / 2,
1323                                                                         (__pFooter->GetButton(RIGHT_BUTTON)->GetSizeF().height - __pSoftkeyHighlightedIcon[_SOFTKEY_1]->GetHeightF()) / 2 + softkeyIconGap), *__pSoftkeyHighlightedIcon[_SOFTKEY_1]);
1324                                 }
1325                         }
1326                 }
1327         }
1328
1329         if (__formStyle & FORM_STYLE_OPTIONKEY)
1330         {
1331                 if (__pFooter->GetButton(MIDDLE_BUTTON))
1332                 {
1333                         __pFooter->GetButton(MIDDLE_BUTTON)->SetActionId(__actionId[SOFTKEY_COUNT]);
1334
1335                         if (__pSoftkeyNormalBitmap[SOFTKEY_COUNT])
1336                         {
1337                                 __pFooter->GetButton(MIDDLE_BUTTON)->SetBackgroundBitmap(_BUTTON_STATUS_NORMAL, *__pSoftkeyNormalBitmap[SOFTKEY_COUNT]);
1338                         }
1339
1340                         if (__pSoftkeyDisabledBitmap[SOFTKEY_COUNT])
1341                         {
1342                                 __pFooter->GetButton(MIDDLE_BUTTON)->SetBackgroundBitmap(_BUTTON_STATUS_DISABLED, *__pSoftkeyDisabledBitmap[SOFTKEY_COUNT]);
1343                         }
1344
1345                         if (__pSoftkeyPressedBitmap[SOFTKEY_COUNT])
1346                         {
1347                                 __pFooter->GetButton(MIDDLE_BUTTON)->SetBackgroundBitmap(_BUTTON_STATUS_PRESSED, *__pSoftkeyPressedBitmap[SOFTKEY_COUNT]);
1348                         }
1349
1350                         if (__pSoftkeyHighlightedBitmap[SOFTKEY_COUNT])
1351                         {
1352                                 __pFooter->GetButton(MIDDLE_BUTTON)->SetBackgroundBitmap(_BUTTON_STATUS_HIGHLIGHTED, *__pSoftkeyHighlightedBitmap[SOFTKEY_COUNT]);
1353                         }
1354
1355                         if (__pSoftkeyNormalEffectBitmap[SOFTKEY_COUNT])
1356                         {
1357                                 __pFooter->GetButton(MIDDLE_BUTTON)->SetBackgroundEffectBitmap(_BUTTON_STATUS_NORMAL, *__pSoftkeyNormalEffectBitmap[SOFTKEY_COUNT]);
1358                         }
1359
1360                         if (__pSoftkeyPressedEffectBitmap[SOFTKEY_COUNT])
1361                         {
1362                                 __pFooter->GetButton(MIDDLE_BUTTON)->SetBackgroundEffectBitmap(_BUTTON_STATUS_PRESSED, *__pSoftkeyPressedEffectBitmap[SOFTKEY_COUNT]);
1363                         }
1364
1365                         if (__pSoftkeyNormalIcon[SOFTKEY_COUNT])
1366                         {
1367                                 __pFooter->GetButton(MIDDLE_BUTTON)->SetBitmap(_BUTTON_STATUS_NORMAL, FloatPoint(0.0f, 0.0f), *__pSoftkeyNormalIcon[SOFTKEY_COUNT]);
1368                         }
1369
1370                         if (__pSoftkeyDisabledIcon[SOFTKEY_COUNT])
1371                         {
1372                                 __pFooter->GetButton(MIDDLE_BUTTON)->SetBitmap(_BUTTON_STATUS_DISABLED, FloatPoint(0.0f, 0.0f), *__pSoftkeyDisabledIcon[SOFTKEY_COUNT]);
1373                         }
1374
1375                         if (__pSoftkeyPressedIcon[SOFTKEY_COUNT])
1376                         {
1377                                 __pFooter->GetButton(MIDDLE_BUTTON)->SetBitmap(_BUTTON_STATUS_PRESSED, FloatPoint(0.0f, 0.0f), *__pSoftkeyPressedIcon[SOFTKEY_COUNT]);
1378                         }
1379
1380                         if (__pSoftkeyHighlightedIcon[SOFTKEY_COUNT])
1381                         {
1382                                 __pFooter->GetButton(MIDDLE_BUTTON)->SetBitmap(_BUTTON_STATUS_HIGHLIGHTED, FloatPoint(0.0f, 0.0f), *__pSoftkeyHighlightedIcon[SOFTKEY_COUNT]);
1383                         }
1384                 }
1385         }
1386 }
1387
1388 String
1389 _Form::GetDescription(void) const
1390 {
1391         String description = _Control::GetDescription();
1392
1393         String descriptionTemp(L"");
1394
1395         descriptionTemp.Format(LOG_LEN_MAX, L"_Form: style(%d) transparent(%d %d %d %d) deflated(%d) deflatedHeight(%d) overlayRegionCount(%d) softkeyCount(%d) updatedSoftkeyCount(%d)",
1396                 __formStyle, __transparentIndicator, __transparentHeader, __transparentFooter, __transparentTab, __deflated, __deflatedHeight,
1397                 __overlayRegionCount, __softkeyCount, __updatedSoftkeyCount);
1398
1399         description.Append(descriptionTemp);
1400
1401         return description;
1402 }
1403
1404 Canvas*
1405 _Form::GetClientAreaCanvasN(void) const
1406 {
1407         Canvas* pCanvas = GetCanvasN(GetClientBounds());
1408         if ((pCanvas == null) || (GetLastResult() != E_SUCCESS))
1409         {
1410                 SysLog(NID_UI_CTRL, "[%s] Propagated.", GetErrorMessage(GetLastResult()));
1411                 delete pCanvas;
1412                 return null;
1413         }
1414
1415         return pCanvas;
1416 }
1417
1418 int
1419 _Form::GetSoftkeyActionId(_Softkey softkey) const
1420 {
1421         if (CheckSoftkey(softkey) == false)
1422         {
1423                 return -1;
1424         }
1425
1426         return __actionId[softkey];
1427 }
1428
1429 int
1430 _Form::GetOptionkeyActionId(void) const
1431 {
1432         if (HasOptionkey() == false)
1433         {
1434                 return -1;
1435         }
1436
1437         return __actionId[SOFTKEY_COUNT];
1438 }
1439
1440 String
1441 _Form::GetSoftkeyText(_Softkey softkey) const
1442 {
1443         if (CheckSoftkey(softkey) == false)
1444         {
1445                 return String(L"");
1446         }
1447
1448         return __softkeyText[softkey];
1449 }
1450
1451 void
1452 _Form::SetFormStyle(unsigned long formStyle)
1453 {
1454         result r = E_SUCCESS;
1455
1456         __formStyle = formStyle;
1457
1458         if (!__pIndicator)
1459         {
1460                 __pIndicator = CreateIndicatorN();
1461                 SysTryReturnVoidResult(NID_UI_CTRL, __pIndicator != null, r, "[%s] Propagating.", GetErrorMessage(r));
1462
1463                 float indicatorwidth = GetClientBoundsF().width;
1464                 float indicatorheight = 0.0f;
1465
1466                 GET_SHAPE_CONFIG(FORM::INDICATOR_HEIGHT, GetOrientation(), indicatorheight);
1467
1468                 __pIndicator->SetBounds(FloatRectangle(0.0f, 0.0f, indicatorwidth, indicatorheight));
1469                 r = GetVisualElement()->AttachChild(*__pIndicator);
1470                 SysTryReturnVoidResult(NID_UI_CTRL, r == E_SUCCESS, r, "[%s] Propagating.", GetErrorMessage(r));
1471
1472                 _VisualElementImpl* pImpl = _VisualElementImpl::GetInstance(*__pIndicator);
1473
1474                 result r = pImpl->SetZOrderGroup(_ControlVisualElement::Z_ORDER_GROUP_CONTROL + 4);
1475
1476                 r = GetLastResult();
1477                 SysTryReturnVoidResult(NID_UI_CTRL, r == E_SUCCESS, r, "[%s] Propagating.", GetErrorMessage(r));
1478         }
1479 }
1480
1481 result
1482 _Form::SetActionBarsTranslucent(unsigned long actionBars, bool translucent)
1483 {
1484         SysTryReturn(
1485                         NID_UI_CTRL,
1486                         ((actionBars & FORM_ACTION_BAR_INDICATOR) || (actionBars & FORM_ACTION_BAR_HEADER) ||
1487                                         (actionBars & FORM_ACTION_BAR_FOOTER) || (actionBars & FORM_ACTION_BAR_TAB)),
1488                                         E_INVALID_OPERATION, E_INVALID_OPERATION,
1489                                         ("[E_INVALID_OPERATION] The current state of the instance prohibits the execution of the specified operation."));
1490
1491         if ((!(__formStyle & FORM_STYLE_INDICATOR) && (actionBars & FORM_ACTION_BAR_INDICATOR))
1492                 || (!(__formStyle & FORM_STYLE_HEADER) && (actionBars & FORM_ACTION_BAR_HEADER))
1493                 || (!(__formStyle & FORM_STYLE_FOOTER) && (actionBars & FORM_ACTION_BAR_FOOTER))
1494                 || (!(__formStyle & FORM_STYLE_TEXT_TAB) && (actionBars & FORM_ACTION_BAR_TAB)))
1495         {
1496                 SysLog(NID_UI_CTRL,
1497                         "[E_INVALID_OPERATION] The current state of the instance prohibits the execution of the specified operation.");
1498                 return E_INVALID_OPERATION;
1499         }
1500
1501         result r = E_SUCCESS;
1502
1503         Color bgColor(0, 0, 0, 0);
1504         if (actionBars & FORM_ACTION_BAR_INDICATOR)
1505         {
1506                 if (translucent)
1507                 {
1508                         r = SetIndicatorOpacity(_INDICATOR_OPACITY_TRANSLUCENT);
1509                 }
1510                 else
1511                 {
1512                         r = SetIndicatorOpacity(_INDICATOR_OPACITY_OPAQUE);
1513                 }
1514                 SysTryReturn(NID_UI_CTRL, r == E_SUCCESS, r, r, "[%s] Propagating.", GetErrorMessage(r));
1515         }
1516
1517         if (actionBars & FORM_ACTION_BAR_HEADER)
1518         {
1519                 if (IsHeaderTranslucent() != translucent)
1520                 {
1521                         if (__pHeader)
1522                         {
1523                                 __pHeader->SetTransparent(translucent);
1524                                 __transparentHeader = translucent;
1525                         }
1526                 }
1527         }
1528
1529         if (IsHeaderVisible())
1530         {
1531                 if (IsIndicatorTranslucent() != IsHeaderTranslucent())
1532                 {
1533                         if (IsIndicatorTranslucent())
1534                         {
1535                                 FloatRectangle bounds(0.0f, 0.0f, GetClientBoundsF().width, __pHeader->GetBoundsF().height);
1536                                 SetHeaderBounds(bounds);
1537                         }
1538                         else
1539                         {
1540                                 FloatRectangle bounds(0.0f, GetIndicatorBoundsF().height, GetClientBoundsF().width, __pHeader->GetBoundsF().height);
1541                                 SetHeaderBounds(bounds);
1542                         }
1543                 }
1544                 else if (!IsIndicatorTranslucent() && !IsHeaderTranslucent())
1545                 {
1546                                 FloatRectangle bounds(0.0f, GetIndicatorBoundsF().height, GetClientBoundsF().width, __pHeader->GetBoundsF().height);
1547                                 SetHeaderBounds(bounds);
1548                 }
1549                 else
1550                 {
1551                         if (GetOrientation() == _CONTROL_ORIENTATION_PORTRAIT)
1552                         {
1553                                 FloatRectangle bounds(0.0f, GetIndicatorBoundsF().height, GetClientBoundsF().width, __pHeader->GetBoundsF().height);
1554                                 SetHeaderBounds(bounds);
1555                         }
1556                         else
1557                         {
1558                                 FloatRectangle bounds(0.0f, 0.0f, GetClientBoundsF().width, __pHeader->GetBoundsF().height);
1559                                 SetHeaderBounds(bounds);
1560                         }
1561                 }
1562         }
1563
1564         if (actionBars & FORM_ACTION_BAR_FOOTER)
1565         {
1566                 if (IsFooterTranslucent() != translucent)
1567                 {
1568                         if (__pFooter)
1569                         {
1570                                 __pFooter->SetTransparent(translucent);
1571                                 __transparentFooter = translucent;
1572                         }
1573                 }
1574         }
1575
1576         AdjustClientBounds();
1577
1578         return E_SUCCESS;
1579 }
1580
1581 result
1582 _Form::SetActionBarsVisible(unsigned long actionBars, bool visible)
1583 {
1584         SysTryReturn(
1585                 NID_UI_CTRL,
1586                 ((actionBars & FORM_ACTION_BAR_INDICATOR) || (actionBars & FORM_ACTION_BAR_HEADER) ||
1587                  (actionBars & FORM_ACTION_BAR_FOOTER)),
1588                 E_INVALID_OPERATION,
1589                 E_INVALID_OPERATION,
1590                 ("[E_INVALID_OPERATION] The current state of the instance prohibits the execution of the specified operation. "));
1591
1592         if ((!(__formStyle & FORM_STYLE_INDICATOR) && (actionBars & FORM_ACTION_BAR_INDICATOR))
1593                 || (!(__formStyle & FORM_STYLE_HEADER) && (actionBars & FORM_ACTION_BAR_HEADER))
1594                 || (!(__formStyle & FORM_STYLE_FOOTER) && (actionBars & FORM_ACTION_BAR_FOOTER)))
1595         {
1596                 SysLog(NID_UI_CTRL, "[E_INVALID_OPERATION] The current state of the instance prohibits the execution of the specified operation.");
1597                 return E_INVALID_OPERATION;
1598         }
1599
1600         if ((actionBars & FORM_ACTION_BAR_INDICATOR))
1601         {
1602                 if (GetOrientation() == _CONTROL_ORIENTATION_PORTRAIT)
1603                 {
1604                         if (!(__formStyle & FORM_STYLE_INDICATOR))
1605                         {
1606                                 SysLog(NID_UI_CTRL,
1607                                         "[E_INVALID_OPERATION] The current state of the instance prohibits the execution of the specified operation.");
1608                                 return E_INVALID_OPERATION;
1609                         }
1610                 }
1611                 else
1612                 {
1613                         SysLog(NID_UI_CTRL,
1614                                 "[E_INVALID_OPERATION] The current state of the instance prohibits the execution of the specified operation.");
1615                         return E_INVALID_OPERATION;
1616                 }
1617         }
1618
1619         FloatRectangle bounds = GetBoundsF();
1620         SetBounds(bounds);
1621
1622         if (actionBars & FORM_ACTION_BAR_INDICATOR)
1623         {
1624                 SetIndicatorShowState(visible);
1625         }
1626
1627         if (actionBars & FORM_ACTION_BAR_HEADER)
1628         {
1629                 if (IsHeaderVisible() != visible)
1630                 {
1631                         if (__pHeader)
1632                         {
1633                                 if (visible == true)
1634                                 {
1635                                         float adjHeight = 0.0f;
1636                                         if (IsIndicatorVisible())
1637                                         {
1638                                                 FloatRectangle indicatorBounds = GetIndicatorBoundsF();
1639                                                 adjHeight = indicatorBounds.height;
1640
1641                                                 if (IsIndicatorTranslucent())
1642                                                 {
1643                                                         if (!IsHeaderTranslucent())
1644                                                         {
1645                                                                 adjHeight = 0.0f;
1646                                                         }
1647                                                         else
1648                                                         {
1649                                                                 if (GetOrientation() == _CONTROL_ORIENTATION_LANDSCAPE)
1650                                                                 {
1651                                                                         adjHeight = 0.0f;
1652                                                                 }
1653                                                         }
1654                                                 }
1655                                         }
1656                                         FloatRectangle bounds = __pHeader->GetBoundsF();
1657                                         bounds.y = adjHeight;
1658
1659                                         SetHeaderBounds(bounds);
1660                                 }
1661                                 __pHeader->SetVisibleState(visible);
1662                         }
1663                 }
1664         }
1665
1666         if (actionBars & FORM_ACTION_BAR_FOOTER)
1667         {
1668                 if (__pFooter)
1669                 {
1670                         __pFooter->SetVisibleState(visible);
1671                 }
1672         }
1673
1674         AdjustClientBounds();
1675
1676         return E_SUCCESS;
1677 }
1678
1679 result
1680 _Form::SetTitleIcon(const Bitmap* pTitleBitmap)
1681 {
1682         SysTryReturn(NID_UI_CTRL, (__formStyle & FORM_STYLE_TITLE), E_INVALID_OPERATION,
1683                         E_INVALID_OPERATION, "[E_INVALID_OPERATION] This API is only for FORM_STYLE_TITLE.");
1684
1685         SysTryReturn(NID_UI_CTRL, __pHeader, E_INVALID_STATE, E_INVALID_STATE, "[E_INVALID_STATE] The title is not valid.");
1686
1687         result r = __pHeader->SetTitleIcon(*pTitleBitmap);
1688         SysTryReturn(NID_UI_CTRL, r == E_SUCCESS, r, r, "[%s] Propagating.", GetErrorMessage(r));
1689
1690         return r;
1691 }
1692
1693 result
1694 _Form::SetTitleText(const String& title, HorizontalAlignment alignment)
1695 {
1696         SysTryReturn(NID_UI_CTRL, (__formStyle & FORM_STYLE_TITLE), E_INVALID_OPERATION,
1697                                 E_INVALID_OPERATION, "[E_INVALID_OPERATION] This API is only for FORM_STYLE_TITLE.");
1698
1699         SysTryReturn(NID_UI_CTRL, __pHeader, E_INVALID_STATE, E_INVALID_STATE, "[E_INVALID_STATE] The title is not valid.");
1700
1701         result r = __pHeader->SetTitleText(title, alignment);
1702         SysTryReturn(NID_UI_CTRL, r == E_SUCCESS, r, r, "[%s] Propagating.", GetErrorMessage(r));
1703
1704         return r;
1705 }
1706
1707 result
1708 _Form::SetSoftkeyEnabled(_Softkey softkey, bool enable)
1709 {
1710         result r = E_SYSTEM;
1711
1712         if (CheckSoftkey(softkey) == false)
1713         {
1714                 return r;
1715         }
1716
1717         __enableSoftkey[softkey] = enable;
1718
1719         r = E_SUCCESS;
1720
1721         return r;
1722 }
1723
1724 result
1725 _Form::SetOptionkeyActionId(int actionId)
1726 {
1727         result r = E_SYSTEM;
1728
1729         if (HasOptionkey() == false)
1730         {
1731                 return r;
1732         }
1733
1734         __actionId[SOFTKEY_COUNT] = actionId;
1735
1736         r = E_SUCCESS;
1737
1738         return r;
1739 }
1740
1741 result
1742 _Form::SetSoftkeyActionId(_Softkey softkey, int actionId)
1743 {
1744         result r = E_SYSTEM;
1745
1746         if (CheckSoftkey(softkey) == false)
1747         {
1748                 return r;
1749         }
1750
1751         __actionId[softkey] = actionId;
1752
1753         r = E_SUCCESS;
1754
1755         return r;
1756 }
1757
1758 result
1759 _Form::SetSoftkeyText(_Softkey softkey, const String& text)
1760 {
1761         result r = E_SYSTEM;
1762
1763         if (CheckSoftkey(softkey) == false)
1764         {
1765                 return r;
1766         }
1767
1768         __softkeyText[softkey] = text;
1769
1770         r = E_SUCCESS;
1771
1772         return r;
1773 }
1774
1775 result
1776 _Form::SetSoftkeyIcon(_Softkey softkey, const Bitmap& normalBitmap, const Bitmap* pPressedBitmap)
1777 {
1778         result r = E_SYSTEM;
1779
1780         if (CheckSoftkey(softkey) == false)
1781         {
1782                 return r;
1783         }
1784
1785         float softkey_icon_size = 0.0f;
1786
1787         GET_SHAPE_CONFIG(FOOTER::SOFTKEY_ICON_SIZE, GetOrientation(), softkey_icon_size);
1788
1789         Bitmap* pClonedNormalBitmap = _BitmapImpl::CloneN(normalBitmap);
1790
1791         if (pClonedNormalBitmap)
1792         {
1793                 if (__pSoftkeyNormalIcon[softkey] != null)
1794                 {
1795                         delete __pSoftkeyNormalIcon[softkey];
1796                 }
1797
1798                 __pSoftkeyNormalIcon[softkey] = pClonedNormalBitmap;
1799
1800                 __pSoftkeyNormalIcon[softkey]->Scale(FloatDimension(softkey_icon_size, softkey_icon_size));
1801
1802                 r = E_SUCCESS;
1803         }
1804
1805         if (pPressedBitmap != null)
1806         {
1807                 Bitmap* pClonedPressedBitmap = _BitmapImpl::CloneN(*pPressedBitmap);
1808
1809                 if (pClonedPressedBitmap)
1810                 {
1811                         if (__pSoftkeyPressedIcon[softkey] != null)
1812                         {
1813                                 delete __pSoftkeyPressedIcon[softkey];
1814                         }
1815
1816                         __pSoftkeyPressedIcon[softkey] = pClonedPressedBitmap;
1817
1818                         __pSoftkeyPressedIcon[softkey]->Scale(FloatDimension(softkey_icon_size, softkey_icon_size));
1819
1820                         r = E_SUCCESS;
1821                 }
1822         }
1823
1824         return r;
1825 }
1826
1827 bool
1828 _Form::HasFooter(void) const
1829 {
1830         if (__pFooter)
1831         {
1832                 return true;
1833         }
1834         else
1835         {
1836                 return false;
1837         }
1838 }
1839
1840 bool
1841 _Form::HasHeader(void) const
1842 {
1843         if (__pHeader)
1844         {
1845                 return true;
1846         }
1847         else
1848         {
1849                 return false;
1850         }
1851 }
1852
1853 bool
1854 _Form::HasIndicator(void) const
1855 {
1856
1857         if (__pIndicator)
1858         {
1859                 if (GetOrientation() == _CONTROL_ORIENTATION_PORTRAIT)
1860                 {
1861                         if ((GetFormStyle() & FORM_STYLE_INDICATOR) || (GetFormStyle() & FORM_STYLE_INDICATOR_AUTO_HIDE))
1862                         {
1863                                 return true;
1864                         }
1865                         else
1866                         {
1867                                 return false;
1868                         }
1869                 }
1870                 else
1871                 {
1872                         if (GetFormStyle() & FORM_STYLE_LANDSCAPE_INDICATOR_AUTO_HIDE)
1873                         {
1874                                 return true;
1875                         }
1876                         else
1877                         {
1878                                 return false;
1879                         }
1880                 }
1881         }
1882         else
1883         {
1884                 return false;
1885         }
1886 }
1887
1888 bool
1889 _Form::HasTitle(void) const
1890 {
1891         if (__pHeader && (__formStyle & FORM_STYLE_TITLE))
1892         {
1893                 return true;
1894         }
1895         else
1896         {
1897                 return false;
1898         }
1899 }
1900
1901 bool
1902 _Form::HasTab(void) const
1903 {
1904         if ((__pTab && (__formStyle & FORM_STYLE_TEXT_TAB))
1905 || (__pTab && (__formStyle & FORM_STYLE_ICON_TAB)))
1906         {
1907                 return true;
1908         }
1909         else
1910         {
1911                 return false;
1912         }
1913 }
1914
1915 bool
1916 _Form::IsIndicatorVisible(void) const
1917 {
1918         _Control* pParent = GetParent();
1919         _Frame* pFrame = dynamic_cast<_Frame*>(pParent);
1920
1921         bool visible = true;
1922
1923         if (pFrame && IsAttachedToMainTree())
1924         {
1925                 visible = __pIndicator->GetIndicatorShowState();
1926                 SysTryReturn(NID_UI_CTRL, GetLastResult() == E_SUCCESS, false, GetLastResult(), "[%s] Propagating.", GetErrorMessage(GetLastResult()));
1927         }
1928         else
1929         {
1930                 visible = __indicatorShowState;
1931         }
1932
1933         return visible;
1934 }
1935
1936 bool
1937 _Form::IsHeaderVisible(void) const
1938 {
1939         if (__pHeader)
1940         {
1941                 return __pHeader->IsVisible();
1942         }
1943         else
1944         {
1945                 return false;
1946         }
1947 }
1948
1949 bool
1950 _Form::IsFooterVisible(void) const
1951 {
1952         if (__pFooter)
1953         {
1954                 return __pFooter->IsVisible();
1955         }
1956         else
1957         {
1958                 return false;
1959         }
1960 }
1961
1962 bool
1963 _Form::IsIndicatorTranslucent(void) const
1964 {
1965         _Control* pParent = GetParent();
1966         _Frame* pFrame = dynamic_cast<_Frame*>(pParent);
1967
1968         _IndicatorOpacity opacity = _INDICATOR_OPACITY_UNKNOWN;
1969
1970         bool transparent = false;
1971
1972         if (pFrame && IsAttachedToMainTree())
1973         {
1974                 FrameShowMode mode = pFrame->GetShowMode();
1975                 if (mode != FRAME_SHOW_MODE_FULL_SCREEN)
1976                 {
1977                         if (mode == FRAME_SHOW_MODE_MINIMIZED)
1978                         {
1979                                 if (pFrame->GetShowMode(false) != FRAME_SHOW_MODE_FULL_SCREEN)
1980                                 {
1981                                         return transparent;
1982                                 }
1983                         }
1984                 }
1985                 opacity = __pIndicator->GetIndicatorOpacity();
1986                 SysTryReturn(NID_UI_CTRL, GetLastResult() == E_SUCCESS, false, GetLastResult(), "[%s] Propagating.", GetErrorMessage(GetLastResult()));
1987
1988                 if (opacity == _INDICATOR_OPACITY_TRANSLUCENT)
1989                 {
1990                         transparent = true;
1991                 }
1992                 else if (opacity == _INDICATOR_OPACITY_OPAQUE)
1993                 {
1994                         transparent = false;
1995                 }
1996                 else
1997                 {
1998                         transparent = true;
1999                 }
2000         }
2001         else
2002         {
2003                 transparent = __transparentIndicator;
2004         }
2005
2006         return transparent;
2007 }
2008
2009 bool
2010 _Form::IsIndicatorAutoHide(void) const
2011 {
2012         _Control* pParent = GetParent();
2013         _Frame* pFrame = dynamic_cast<_Frame*>(pParent);
2014
2015         bool autohide = false;
2016
2017         if (pFrame && IsAttachedToMainTree())
2018         {
2019                 autohide = __pIndicator->GetIndicatorAutoHide();
2020         }
2021
2022         return autohide;
2023 }
2024
2025 bool
2026 _Form::IsHeaderTranslucent(void) const
2027 {
2028         return __transparentHeader;
2029 }
2030
2031 bool
2032 _Form::IsFooterTranslucent(void) const
2033 {
2034         return __transparentFooter;
2035 }
2036
2037 bool
2038 _Form::IsTabTranslucent(void) const
2039 {
2040         return __transparentTab;
2041 }
2042
2043 bool
2044 _Form::HasOptionkey(void) const
2045 {
2046         if (GetFormStyle() & FORM_STYLE_OPTIONKEY)
2047         {
2048                 return true;
2049         }
2050         else
2051         {
2052                 return false;
2053         }
2054 }
2055
2056 bool
2057 _Form::HasSoftkey(_Softkey softkey) const
2058 {
2059         unsigned long __formStyle = FORM_STYLE_NORMAL;
2060
2061         if (softkey == _SOFTKEY_0)
2062         {
2063                 __formStyle = FORM_STYLE_SOFTKEY_0;
2064         }
2065         else if (softkey == _SOFTKEY_1)
2066         {
2067                 __formStyle = FORM_STYLE_SOFTKEY_1;
2068         }
2069         else
2070         {
2071                 return false;
2072         }
2073
2074         if (GetFormStyle() & __formStyle)
2075         {
2076                 return true;
2077         }
2078         else
2079         {
2080                 return false;
2081         }
2082 }
2083
2084 bool
2085 _Form::IsSoftkeyEnabled(_Softkey softkey) const
2086 {
2087         if (CheckSoftkey(softkey) == false)
2088         {
2089                 return false;
2090         }
2091
2092         return __enableSoftkey[softkey];
2093 }
2094
2095 bool
2096 _Form::CheckSoftkey(_Softkey softkey) const
2097 {
2098         bool result = true;
2099
2100         if (HasSoftkey(softkey) == false)
2101         {
2102                 return false;
2103         }
2104
2105         if (softkey >= _SOFTKEY_COUNT)
2106         {
2107                 return false;
2108         }
2109
2110         return result;
2111 }
2112
2113 bool
2114 _Form::IsOrientationRoot(void) const
2115 {
2116         return true;
2117 }
2118
2119 Point
2120 _Form::TranslateToClientAreaPosition(const Point& position) const
2121 {
2122         Rectangle clientArea = GetClientBounds();
2123         return Point(position.x - clientArea.x, position.y - clientArea.y);
2124 }
2125
2126 FloatPoint
2127 _Form::TranslateToClientAreaPosition(const FloatPoint& position) const
2128 {
2129         FloatRectangle clientArea = GetClientBoundsF();
2130         return FloatPoint(position.x - clientArea.x, position.y - clientArea.y);
2131 }
2132
2133 Point
2134 _Form::TranslateFromClientAreaPosition(const Point& clientPosition) const
2135 {
2136         Rectangle clientArea = GetClientBounds();
2137         return Point(clientPosition.x + clientArea.x, clientPosition.y + clientArea.y);
2138 }
2139
2140 FloatPoint
2141 _Form::TranslateFromClientAreaPosition(const FloatPoint& clientPosition) const
2142 {
2143         FloatRectangle clientArea = GetClientBoundsF();
2144         return FloatPoint(clientPosition.x + clientArea.x, clientPosition.y + clientArea.y);
2145 }
2146
2147 bool
2148 _Form::IsDeflated(void)
2149 {
2150         if (__deflated)
2151         {
2152                 return true;
2153         }
2154         else
2155         {
2156                 return false;
2157         }
2158 }
2159
2160 bool
2161 _Form::DeflateClientRectHeight(int height)
2162 {
2163         if (    height > 0)
2164         {
2165                 __deflated = true;
2166         }
2167         else
2168         {
2169                 __deflated = false;
2170         }
2171
2172         __deflatedHeight = _CoordinateSystemUtils::ConvertToFloat(height);
2173
2174         AdjustClientBounds();
2175
2176         if (__pFooter)
2177         {
2178                 float adjHeight = 0.0f;
2179
2180                 if (!(__pFooter->GetVisibleState()) || IsFooterTranslucent())
2181                 {
2182                         adjHeight = GetToolbarHeightF(false);
2183                 }
2184
2185                 FloatRectangle bounds(0.0f, GetClientBoundsF().y + GetClientBoundsF().height-adjHeight,
2186                                                                                 GetClientBoundsF().width, GetToolbarHeightF(false));
2187                 SetFooterBounds(bounds);
2188         }
2189
2190         return true;
2191 }
2192
2193 bool
2194 _Form::DeflateClientRectHeight(float height)
2195 {
2196         if (    height > 0.0f)
2197         {
2198                 __deflated = true;
2199         }
2200         else
2201         {
2202                 __deflated = false;
2203         }
2204
2205         __deflatedHeight = height;
2206
2207         AdjustClientBounds();
2208
2209         if (__pFooter)
2210         {
2211                 float adjHeight = 0.0f;
2212
2213                 if (!(__pFooter->GetVisibleState()) || IsFooterTranslucent())
2214                 {
2215                         adjHeight = GetToolbarHeightF(false);
2216                 }
2217
2218                 FloatRectangle bounds(0.0f, GetClientBoundsF().y + GetClientBoundsF().height-adjHeight,
2219                                                                                 GetClientBoundsF().width, GetToolbarHeightF(false));
2220                 SetFooterBounds(bounds);
2221         }
2222
2223         return true;
2224 }
2225
2226 _Toolbar*
2227 _Form::CreateHeaderN(void)
2228 {
2229         _Toolbar* __pHeader = _Toolbar::CreateToolbarN(true);
2230         SysTryReturn(NID_UI_CTRL, __pHeader, null, GetLastResult(), "[%s] Propagating.", GetErrorMessage(GetLastResult()));
2231
2232         return __pHeader;
2233 }
2234
2235 _Toolbar*
2236 _Form::CreateFooterN(void)
2237 {
2238         _Toolbar* __pFooter = _Toolbar::CreateToolbarN(false);
2239         SysTryReturn(NID_UI_CTRL, __pFooter, null, GetLastResult(), "[%s] Propagating.", GetErrorMessage(GetLastResult()));
2240
2241         return __pFooter;
2242 }
2243
2244 _Tab*
2245 _Form::CreateTabN(void)
2246 {
2247         _Tab* __pTab = _Tab::CreateTabN();
2248         SysTryReturn(NID_UI_CTRL, __pTab, null, GetLastResult(), "[%s] Propagating.", GetErrorMessage(GetLastResult()));
2249
2250         return __pTab;
2251 }
2252
2253 _Indicator*
2254 _Form::CreateIndicatorN(void)
2255 {
2256         _Indicator* pIndicator = _Indicator::CreateIndicator();
2257         SysTryReturn(NID_UI_CTRL, pIndicator, null, GetLastResult(), "[%s] Propagating.", GetErrorMessage(GetLastResult()));
2258
2259         return pIndicator;
2260 }
2261
2262 int
2263 _Form::GetToolbarHeight(bool header) const
2264 {
2265         int toolbarHeight = 0;
2266
2267         if (header && (__formStyle & FORM_STYLE_HEADER))
2268         {
2269                 if (__pHeader)
2270                 {
2271                         toolbarHeight = __pHeader->GetBounds().height;
2272                 }
2273         }
2274         else if (header && (__formStyle & FORM_STYLE_TITLE))
2275         {
2276                 GET_SHAPE_CONFIG(HEADER::HEIGHT, GetOrientation(), toolbarHeight);
2277         }
2278         else if (__formStyle & FORM_STYLE_SOFTKEY_0 || __formStyle & FORM_STYLE_SOFTKEY_1 || __formStyle & FORM_STYLE_OPTIONKEY)
2279         {
2280                 GET_SHAPE_CONFIG(FOOTER::SOFTKEY_HEIGHT, GetOrientation(), toolbarHeight);
2281         }
2282         else
2283         {
2284                 if (__pFooter)
2285                 {
2286                         toolbarHeight = __pFooter->GetBounds().height;
2287                 }
2288
2289                 //GET_SHAPE_CONFIG(L"FOOTER_HEIGHT", GetOrientation(), toolbarHeight);
2290         }
2291
2292         return toolbarHeight;
2293 }
2294
2295 float
2296 _Form::GetToolbarHeightF(bool header) const
2297 {
2298         FloatDimension toolbarSize(0.0f, 0.0f);
2299
2300         if (header && (__formStyle & FORM_STYLE_HEADER))
2301         {
2302                 if (__pHeader)
2303                 {
2304                         toolbarSize.height = __pHeader->GetBoundsF().height;
2305                 }
2306         }
2307         else if (header && (__formStyle & FORM_STYLE_TITLE))
2308         {
2309                 GET_SHAPE_CONFIG(HEADER::HEIGHT, GetOrientation(), toolbarSize.height);
2310         }
2311         else if (__formStyle & FORM_STYLE_SOFTKEY_0 || __formStyle & FORM_STYLE_SOFTKEY_1 || __formStyle & FORM_STYLE_OPTIONKEY)
2312         {
2313                 GET_SHAPE_CONFIG(FOOTER::SOFTKEY_HEIGHT, GetOrientation(), toolbarSize.height);
2314         }
2315         else
2316         {
2317                 if (__pFooter)
2318                 {
2319                         toolbarSize.height = __pFooter->GetBoundsF().height;
2320                 }
2321         }
2322
2323         toolbarSize = TranslateSize(toolbarSize);
2324
2325         return toolbarSize.height;
2326 }
2327
2328 int
2329 _Form::GetTabHeight(void) const
2330 {
2331         int height = 0;
2332
2333         if ((__formStyle & FORM_STYLE_TEXT_TAB) || (__formStyle & FORM_STYLE_ICON_TAB))
2334         {
2335                 GET_SHAPE_CONFIG(TAB::HEIGHT, GetOrientation(), height);
2336         }
2337
2338         return height;
2339 }
2340
2341 float
2342 _Form::GetTabHeightF(void) const
2343 {
2344         FloatDimension tabSize(0.0f, 0.0f);
2345
2346         if ((__formStyle & FORM_STYLE_TEXT_TAB) || (__formStyle & FORM_STYLE_ICON_TAB))
2347         {
2348                 GET_SHAPE_CONFIG(TAB::HEIGHT, GetOrientation(), tabSize.height);
2349         }
2350
2351         tabSize = TranslateSize(tabSize);
2352
2353         return tabSize.height;
2354 }
2355
2356 bool
2357 _Form::RemoveHeader(void)
2358 {
2359         result r = E_SUCCESS;
2360         if (__pHeader)
2361         {
2362                 if (__pHeader->GetParent())
2363                 {
2364                         r = DetachSystemChild(*__pHeader);
2365                         SysTryReturn(NID_UI_CTRL, r == E_SUCCESS, false, r, "[%s] Propagating.", GetErrorMessage(r));
2366                 }
2367                 __pHeader = null;
2368
2369                 AdjustClientBounds();
2370         }
2371         else
2372         {
2373                 return false;
2374         }
2375
2376         return true;
2377 }
2378
2379 bool
2380 _Form::RemoveFooter(void)
2381 {
2382         result r = E_SUCCESS;
2383         if (__pFooter)
2384         {
2385                 if (__pFooter->GetParent())
2386                 {
2387                         r = DetachSystemChild(*__pFooter);
2388                         SysTryReturn(NID_UI_CTRL, r == E_SUCCESS, false, r, "[%s] Propagating.", GetErrorMessage(r));
2389                 }
2390                 __pFooter = null;
2391
2392                 AdjustClientBounds();
2393         }
2394         else
2395         {
2396                 return false;
2397         }
2398
2399         return true;
2400 }
2401
2402 bool
2403 _Form::RemoveTab(void)
2404 {
2405         result r = E_SUCCESS;
2406         if (__pTab)
2407         {
2408                 if (__pTab->GetParent())
2409                 {
2410                         r = DetachSystemChild(*__pTab);
2411                         SysTryReturn(NID_UI_CTRL, r == E_SUCCESS, false, r, "[%s] Propagating.", GetErrorMessage(r));
2412                 }
2413                 __pTab = null;
2414
2415                 AdjustClientBounds();
2416         }
2417         else
2418         {
2419                 return false;
2420         }
2421
2422         return true;
2423 }
2424
2425 bool
2426 _Form::RemoveIndicator(void)
2427 {
2428         result r = E_SUCCESS;
2429         if (__pIndicator)
2430         {
2431                 r = GetVisualElement()->DetachChild(*__pIndicator);
2432                 SysTryReturn(NID_UI_CTRL, r == E_SUCCESS, false, r, "[%s] Propagating.", GetErrorMessage(r));
2433                 __pIndicator = null;
2434         }
2435         else
2436         {
2437                 return false;
2438         }
2439
2440         return true;
2441 }
2442
2443 result
2444 _Form::SetHeaderBounds(Rectangle& bounds)
2445 {
2446         SysTryReturn(NID_UI_CTRL, __pHeader, E_INVALID_STATE, E_INVALID_STATE, "[E_INVALID_STATE] Header isn't constructed.");
2447
2448         bool movable = __pHeader->IsMovable();
2449         bool resizable = __pHeader->IsResizable();
2450
2451         __pHeader->SetMovable(true);
2452         __pHeader->SetResizable(true);
2453
2454         result r = E_SUCCESS;
2455         r = __pHeader->SetBounds(_CoordinateSystemUtils::ConvertToFloat(bounds));
2456         SysTryReturn(NID_UI_CTRL, r == E_SUCCESS, r, r, "[%s] Propagating.", GetErrorMessage(r));
2457
2458         __pHeader->SetMovable(movable);
2459         __pHeader->SetResizable(resizable);
2460
2461         AdjustClientBounds();
2462
2463         return r;
2464 }
2465
2466 result
2467 _Form::SetHeaderBounds(FloatRectangle& bounds)
2468 {
2469         SysTryReturn(NID_UI_CTRL, __pHeader, E_INVALID_STATE, E_INVALID_STATE, "[E_INVALID_STATE] Header isn't constructed.");
2470
2471         bool movable = __pHeader->IsMovable();
2472         bool resizable = __pHeader->IsResizable();
2473
2474         __pHeader->SetMovable(true);
2475         __pHeader->SetResizable(true);
2476
2477         result r = E_SUCCESS;
2478         r = __pHeader->SetBounds(bounds);
2479         SysTryReturn(NID_UI_CTRL, r == E_SUCCESS, r, r, "[%s] Propagating.", GetErrorMessage(r));
2480
2481         __pHeader->SetMovable(movable);
2482         __pHeader->SetResizable(resizable);
2483
2484         AdjustClientBounds();
2485
2486         return r;
2487 }
2488
2489 result
2490 _Form::SetFooterBounds(Rectangle& bounds)
2491 {
2492         SysTryReturn(NID_UI_CTRL, __pFooter, E_INVALID_STATE, E_INVALID_STATE, "[E_INVALID_STATE] Footer isn't constructed.");
2493
2494         bool movable = __pFooter->IsMovable();
2495         bool resizable = __pFooter->IsResizable();
2496
2497         __pFooter->SetMovable(true);
2498         __pFooter->SetResizable(true);
2499
2500         result r = E_SUCCESS;
2501         r = __pFooter->SetBounds(_CoordinateSystemUtils::ConvertToFloat(bounds));
2502         SysTryReturn(NID_UI_CTRL, r == E_SUCCESS, r, r, "[%s] Propagating.", GetErrorMessage(r));
2503
2504         __pFooter->SetMovable(movable);
2505         __pFooter->SetResizable(resizable);
2506
2507         AdjustClientBounds();
2508
2509         return r;
2510 }
2511
2512 bool
2513 _Form::OnMousePressed(const _Control& source, const _MouseInfo& mouseinfo)
2514 {
2515         return false;
2516 }
2517
2518 bool
2519 _Form::OnMouseReleased(const _Control& source, const _MouseInfo& mouseinfo)
2520 {
2521         _Toolbar* pToolbar = GetFooter();
2522         if (pToolbar == null)
2523         {
2524                 return null;
2525         }
2526
2527         return true;
2528 }
2529
2530 bool
2531 _Form::OnKeyPressed(const _Control& source, const _KeyInfo& keyInfo)
2532 {
2533         return false;
2534 }
2535
2536 bool
2537 _Form::OnKeyReleased(const _Control& source, const _KeyInfo& keyInfo)
2538 {
2539         if (keyInfo.GetKeyCode() == _KEY_ESC || keyInfo.GetKeyCode() == _KEY_BACK)
2540         {
2541 //              _Toolbar* pToolbar = GetFooter();
2542 //              if (pToolbar == null)
2543 //              {
2544 //                      return null;
2545 //              }
2546
2547 //              if (pToolbar->IsButtonSet(BACK_BUTTON))
2548 //              {
2549                         {
2550                                 void* pData = GetUserData();
2551                                 if (pData)
2552                                 {
2553                                         _FormImpl* pDataImpl = static_cast<_FormImpl*>(pData);
2554                                         pDataImpl->OnFormBackRequested(*this);
2555                                 }
2556                         }
2557 //              }
2558 //              {
2559 //                      void* pData = GetUserData();
2560 //                      if (pData)
2561 //                      {
2562 //                              _FormImpl* pDataImpl = static_cast<_FormImpl*>(pData);
2563 //                              pDataImpl->OnFormBackButtonRequested(*this);
2564 //                      }
2565 //              }
2566
2567
2568                 return false;
2569         }
2570         if (keyInfo.GetKeyCode() == _KEY_CONTEXT_MENU || keyInfo.GetKeyCode() == _KEY_MENU)
2571         {
2572 //              _Toolbar* pToolbar = GetFooter();
2573 //              if (pToolbar == null)
2574 //              {
2575 //                      return null;
2576 //              }
2577
2578                 {
2579                         void* pData = GetUserData();
2580                         if (pData)
2581                         {
2582                                 _FormImpl* pDataImpl = static_cast<_FormImpl*>(pData);
2583                                 pDataImpl->OnFormMenuRequested(*this);
2584                         }
2585                 }
2586
2587                 return false;
2588         }
2589
2590         return false;
2591 }
2592
2593 result
2594 _Form::SetFooterBounds(FloatRectangle& bounds)
2595 {
2596         SysTryReturn(NID_UI_CTRL, __pFooter, E_INVALID_STATE, E_INVALID_STATE, "[E_INVALID_STATE] Footer isn't constructed.");
2597
2598         bool movable = __pFooter->IsMovable();
2599         bool resizable = __pFooter->IsResizable();
2600
2601         __pFooter->SetMovable(true);
2602         __pFooter->SetResizable(true);
2603
2604         result r = E_SUCCESS;
2605         r = __pFooter->SetBounds(bounds);
2606         SysTryReturn(NID_UI_CTRL, r == E_SUCCESS, r, r, "[%s] Propagating.", GetErrorMessage(r));
2607
2608         __pFooter->SetMovable(movable);
2609         __pFooter->SetResizable(resizable);
2610
2611         AdjustClientBounds();
2612
2613         return r;
2614 }
2615
2616 result
2617 _Form::SetTabBounds(Rectangle& bounds)
2618 {
2619         SysTryReturn(NID_UI_CTRL, __pTab, E_INVALID_STATE, E_INVALID_STATE, "[E_INVALID_STATE] Tab isn't constructed.");
2620
2621         bool movable = __pTab->IsMovable();
2622         bool resizable = __pTab->IsResizable();
2623
2624         __pTab->SetMovable(true);
2625         __pTab->SetResizable(true);
2626
2627         result r = E_SUCCESS;
2628         r = __pTab->SetBounds(_CoordinateSystemUtils::ConvertToFloat(bounds));
2629         SysTryReturn(NID_UI_CTRL, r == E_SUCCESS, r, r, "[%s] Propagating.", GetErrorMessage(r));
2630
2631         __pTab->SetMovable(movable);
2632         __pTab->SetResizable(resizable);
2633
2634         AdjustClientBounds();
2635
2636         return r;
2637 }
2638
2639 result
2640 _Form::SetTabBounds(FloatRectangle& bounds)
2641 {
2642         SysTryReturn(NID_UI_CTRL, __pTab, E_INVALID_STATE, E_INVALID_STATE, "[E_INVALID_STATE] Tab isn't constructed.");
2643
2644         bool movable = __pTab->IsMovable();
2645         bool resizable = __pTab->IsResizable();
2646
2647         __pTab->SetMovable(true);
2648         __pTab->SetResizable(true);
2649
2650         result r = E_SUCCESS;
2651         r = __pTab->SetBounds(bounds);
2652         SysTryReturn(NID_UI_CTRL, r == E_SUCCESS, r, r, "[%s] Propagating.", GetErrorMessage(r));
2653
2654         __pTab->SetMovable(movable);
2655         __pTab->SetResizable(resizable);
2656
2657         AdjustClientBounds();
2658
2659         return r;
2660 }
2661
2662 result
2663 _Form::AddActionEventListener(_IActionEventListener& listener)
2664 {
2665         if (__pActionEvent == null)
2666         {
2667                 __pActionEvent = _ActionEvent::CreateInstanceN(*this);
2668
2669                 SysTryReturn(NID_UI_CTRL, __pActionEvent, E_SYSTEM, E_SYSTEM, "[E_SYSTEM] System error occurred.")
2670         }
2671
2672         result r = __pActionEvent->AddListener(listener);
2673         SysTryReturn(NID_UI_CTRL, r == E_SUCCESS, r, r, "[%s] Propagating.", GetErrorMessage(r));
2674
2675         return E_SUCCESS;
2676 }
2677
2678 void
2679 _Form::AddOptionkeyActionListener(_IActionEventListener& listener)
2680 {
2681         if (HasOptionkey() == false)
2682         {
2683                 return ;
2684         }
2685 }
2686
2687 void
2688 _Form::AddSoftkeyActionListener(_Softkey softkey, _IActionEventListener& listener)
2689 {
2690         if (CheckSoftkey(softkey) == false)
2691         {
2692                 return ;
2693         }
2694 }
2695
2696 result
2697 _Form::RemoveActionEventListener(_IActionEventListener& listener)
2698 {
2699         SysTryReturn(NID_UI_CTRL, __pActionEvent, E_INVALID_STATE, E_INVALID_STATE, "[E_INVALID_STATE] This instance isn't constructed.")
2700         // Todo : check fail case of RemoveListener
2701         result r = __pActionEvent->RemoveListener(listener);
2702         SysTryReturn(NID_UI_CTRL, r == E_SUCCESS, r, r, "[%s] Propagating.", GetErrorMessage(r));
2703
2704         return E_SUCCESS;
2705 }
2706
2707 void
2708 _Form::RemoveOptionkeyActionListener(_IActionEventListener& listener)
2709 {
2710         if (HasOptionkey() == false)
2711         {
2712                 return ;
2713         }
2714 }
2715
2716 void
2717 _Form::RemoveSoftkeyActionListener(_Softkey softkey, _IActionEventListener& listener)
2718 {
2719         if (CheckSoftkey(softkey) == false)
2720         {
2721                 return ;
2722         }
2723 }
2724
2725 void
2726 _Form::OnActionPerformed(const _Control& source, int actionId)
2727 {
2728         switch (actionId)
2729         {
2730         case ID_BACK_BUTTON:
2731                 if (!__keypadShowstate && !__clipboardShowstate)
2732                 {
2733                         if (__pFormBackEventListener)
2734                         {
2735                                 __pFormBackEventListener->OnFormBackRequested(*this);
2736                         }
2737                 }
2738                 else
2739                 {
2740                         if (__keypadShowstate)
2741                         {
2742                                 if (!__alreadyStopKeySent)
2743                                 {
2744                                         _SystemUtilImpl::GenerateKeyEvent(KEY_EVENT_TYPE_PRESSED, _KEY_BACK);
2745                                         _SystemUtilImpl::GenerateKeyEvent(KEY_EVENT_TYPE_RELEASED, _KEY_BACK);
2746                                         __alreadyStopKeySent = true;
2747                                 }
2748                         }
2749
2750                         if (__clipboardShowstate)
2751                         {
2752                                 _SystemUtilImpl::SendKeyStopMessage();
2753                         }
2754                 }
2755                 break;
2756         case ID_MENU_BUTTON :
2757                 if (__pFormMenuEventListener)
2758                 {
2759                         __pFormMenuEventListener->OnFormMenuRequested(*this);
2760                 }
2761                 break;
2762
2763         default:
2764                 break;
2765         }
2766 }
2767
2768 void
2769 _Form::OnChildVisibleStateChanged(const _Control& child)
2770 {
2771         if (IsHeaderVisible())
2772         {
2773                 float adjHeight = 0.0f;
2774                 if (IsIndicatorVisible())
2775                 {
2776                         FloatRectangle indicatorBounds = GetIndicatorBoundsF();
2777                         adjHeight = indicatorBounds.height;
2778
2779                         if (IsIndicatorTranslucent())
2780                         {
2781                                 if (!IsHeaderTranslucent())
2782                                 {
2783                                         adjHeight = 0.0f;
2784                                 }
2785                                 else
2786                                 {
2787                                         if (GetOrientation() == _CONTROL_ORIENTATION_LANDSCAPE)
2788                                         {
2789                                                 adjHeight = 0.0f;
2790                                         }
2791                                         else
2792                                         {
2793                                                 if (FORM_STYLE_INDICATOR_AUTO_HIDE & GetFormStyle())
2794                                                 {
2795                                                         adjHeight = 0.0f;
2796                                                 }
2797                                         }
2798                                 }
2799                         }
2800                 }
2801                 FloatRectangle bounds = __pHeader->GetBoundsF();
2802                 bounds.y = adjHeight;
2803                 SetHeaderBounds(bounds);
2804         }
2805
2806         AdjustClientBounds();
2807 }
2808
2809 Rectangle
2810 _Form::GetIndicatorBounds(void) const
2811 {
2812         _Control* pParent = GetParent();
2813         _Frame* pFrame = dynamic_cast<_Frame*>(pParent);
2814
2815         if (pFrame)
2816         {
2817                 FrameShowMode mode = pFrame->GetShowMode();
2818                 if (mode != FRAME_SHOW_MODE_FULL_SCREEN)
2819                 {
2820                         if (mode == FRAME_SHOW_MODE_MINIMIZED)
2821                         {
2822                                 if (pFrame->GetShowMode(false) != FRAME_SHOW_MODE_FULL_SCREEN)
2823                                 {
2824                                         return Rectangle(0, 0, 0, 0);
2825                                 }
2826                         }
2827                 }
2828         }
2829
2830         int indicatorwidth = GetClientBounds().width;
2831         int indicatorheight = 0;
2832
2833         if (GetOrientation() == _CONTROL_ORIENTATION_PORTRAIT)
2834         {
2835                 GET_SHAPE_CONFIG(FORM::INDICATOR_HEIGHT, GetOrientation(), indicatorheight);
2836         }
2837         else
2838         {
2839                 if (FORM_STYLE_LANDSCAPE_INDICATOR_AUTO_HIDE & GetFormStyle())
2840                 {
2841                         GET_SHAPE_CONFIG(FORM::INDICATOR_MINIMIZE_HEIGHT, GetOrientation(), indicatorheight);
2842                 }
2843         }
2844
2845         Rectangle rect (0, 0, indicatorwidth, indicatorheight);
2846
2847         SetLastResult(E_SUCCESS);
2848
2849         return rect;
2850 }
2851
2852 FloatRectangle
2853 _Form::GetIndicatorBoundsF(void) const
2854 {
2855         _Control* pParent = GetParent();
2856         _Frame* pFrame = dynamic_cast<_Frame*>(pParent);
2857
2858         if (pFrame)
2859         {
2860                 FrameShowMode mode = pFrame->GetShowMode();
2861                 if (mode != FRAME_SHOW_MODE_FULL_SCREEN)
2862                 {
2863                         if (mode == FRAME_SHOW_MODE_MINIMIZED)
2864                         {
2865                                 if (pFrame->GetShowMode(false) != FRAME_SHOW_MODE_FULL_SCREEN)
2866                                 {
2867                                         return FloatRectangle(0.0f, 0.0f, 0.0f, 0.0f);
2868                                 }
2869                         }
2870                 }
2871         }
2872
2873         float indicatorwidth = GetClientBoundsF().width;
2874         float indicatorheight = 0.0f;
2875
2876         if (GetOrientation() == _CONTROL_ORIENTATION_PORTRAIT)
2877         {
2878                 GET_SHAPE_CONFIG(FORM::INDICATOR_HEIGHT, GetOrientation(), indicatorheight);
2879         }
2880         else
2881         {
2882                 if (FORM_STYLE_LANDSCAPE_INDICATOR_AUTO_HIDE & GetFormStyle())
2883                 {
2884                         GET_SHAPE_CONFIG(FORM::INDICATOR_MINIMIZE_HEIGHT, GetOrientation(), indicatorheight);
2885                 }
2886         }
2887
2888         FloatRectangle rect (0.0f, 0.0f, indicatorwidth, indicatorheight);
2889
2890         SetLastResult(E_SUCCESS);
2891
2892         return rect;
2893 }
2894
2895 void
2896 _Form::SetHeader(_Toolbar* pToolbar)
2897 {
2898         __pHeader = pToolbar;
2899 }
2900
2901 void
2902 _Form::SetFooter(_Toolbar* pToolbar)
2903 {
2904         __pFooter = pToolbar;
2905 }
2906
2907 void
2908 _Form::SetTab(_Tab* pTab)
2909 {
2910         __pTab = pTab;
2911 }
2912
2913 void
2914 _Form::SetTabStyle(int style)
2915 {
2916         __pTab->SetStyle(style);
2917 }
2918
2919 result
2920 _Form::SetIndicatorShowState(bool state)
2921 {
2922         result r = E_SUCCESS;
2923
2924         _EcoreEvas* pEcoreEvas = GetEcoreEvasMgr()->GetEcoreEvas();
2925         SysTryReturn(NID_UI_CTRL, pEcoreEvas, E_SYSTEM, E_SYSTEM, "[E_SYSTEM] Unable to get evas");
2926
2927         _Control* pParent = GetParent();
2928         if (!pParent)
2929         {
2930                 pParent = const_cast<_Control*>(pEcoreEvas->GetFrame());
2931         }
2932         _Frame* pFrame = dynamic_cast<_Frame*>(pParent);
2933
2934         if (pFrame && IsAttachedToMainTree())
2935         {
2936                 FrameShowMode mode = pFrame->GetShowMode();
2937                 if (mode != FRAME_SHOW_MODE_FULL_SCREEN)
2938                 {
2939                         if (mode == FRAME_SHOW_MODE_MINIMIZED)
2940                         {
2941                                 if (pFrame->GetShowMode(false) == FRAME_SHOW_MODE_FULL_SCREEN)
2942                                 {
2943                                         r = __pIndicator->SetIndicatorShowState(state);
2944                                         SysTryReturn(NID_UI_CTRL, r == E_SUCCESS, r, r, "[%s] Propagating.", GetErrorMessage(r));
2945                                 }
2946                         }
2947                         else
2948                         {
2949                                 r = __pIndicator->SetIndicatorShowState(false);
2950                                 return r;
2951                         }
2952                 }
2953                 else if (mode == FRAME_SHOW_MODE_FULL_SCREEN)
2954                 {
2955                         r = __pIndicator->SetIndicatorShowState(state);
2956                         SysTryReturn(NID_UI_CTRL, r == E_SUCCESS, r, r, "[%s] Propagating.", GetErrorMessage(r));
2957                 }
2958         }
2959         else if (!pFrame && IsAttachedToMainTree())
2960         {
2961                 __pIndicator->SetShowState(false);
2962         }
2963
2964         __indicatorShowState = state;
2965
2966         return r;
2967 }
2968
2969 void
2970 _Form::SetIndicatorAutoHide(bool portrait, bool landscape)
2971 {
2972         result r = E_SUCCESS;
2973
2974         _Control* pParent = GetParent();
2975         _Frame* pFrame = dynamic_cast<_Frame*>(pParent);
2976
2977         if (pFrame && IsAttachedToMainTree())
2978         {
2979                 FrameShowMode mode = pFrame->GetShowMode();
2980                 if (mode != FRAME_SHOW_MODE_FULL_SCREEN)
2981                 {
2982                         if (mode == FRAME_SHOW_MODE_MINIMIZED)
2983                         {
2984                                 if (pFrame->GetShowMode(false) == FRAME_SHOW_MODE_FULL_SCREEN)
2985                                 {
2986                                         __pIndicator->SetIndicatorAutoHide(portrait, landscape);
2987                                         r = GetLastResult();
2988                                         SysTryReturnVoidResult(NID_UI_CTRL, r == E_SUCCESS, r, "[%s] Propagating.", GetErrorMessage(r));
2989                                 }
2990                         }
2991                 }
2992                 else if (mode == FRAME_SHOW_MODE_FULL_SCREEN)
2993                 {
2994                         __pIndicator->SetIndicatorAutoHide(portrait, landscape);
2995                         r = GetLastResult();
2996                         SysTryReturnVoidResult(NID_UI_CTRL, r == E_SUCCESS, r, "[%s] Propagating.", GetErrorMessage(r));
2997                 }
2998         }
2999 }
3000
3001 result
3002 _Form::SetIndicatorOpacity(_IndicatorOpacity opacity)
3003 {
3004         result r = E_SUCCESS;
3005
3006         _Control* pParent = GetParent();
3007         _Frame* pFrame = dynamic_cast<_Frame*>(pParent);
3008
3009         if (pFrame && IsAttachedToMainTree())
3010         {
3011                 FrameShowMode mode = pFrame->GetShowMode();
3012
3013                 if (mode != FRAME_SHOW_MODE_FULL_SCREEN)
3014                 {
3015                         if (mode == FRAME_SHOW_MODE_MINIMIZED)
3016                         {
3017                                 if (pFrame->GetShowMode(false) == FRAME_SHOW_MODE_FULL_SCREEN)
3018                                 {
3019                                         r = __pIndicator->SetIndicatorOpacity(opacity);
3020                                         SysTryReturn(NID_UI_CTRL, r == E_SUCCESS, r, r, "[%s] Propagating.", GetErrorMessage(r));
3021                                 }
3022                         }
3023                 }
3024                 else if (mode == FRAME_SHOW_MODE_FULL_SCREEN)
3025                 {
3026                         r = __pIndicator->SetIndicatorOpacity(opacity);
3027                         SysTryReturn(NID_UI_CTRL, r == E_SUCCESS, r, r, "[%s] Propagating.", GetErrorMessage(r));
3028                 }
3029         }
3030
3031         if (opacity == _INDICATOR_OPACITY_TRANSLUCENT)
3032         {
3033                 __transparentIndicator = true;
3034         }
3035         else if (opacity == _INDICATOR_OPACITY_OPAQUE)
3036         {
3037                 __transparentIndicator = false;
3038         }
3039
3040         return r;
3041 }
3042
3043 result
3044 _Form::AddIndicatorObject(void)
3045 {
3046         result r = E_SUCCESS;
3047
3048         if (__pIndicator)
3049         {
3050                 r = __pIndicator->AddIndicatorObject(this, GetRootWindow());
3051         }
3052
3053         return r;
3054 }
3055
3056 result
3057 _Form::DeleteIndicatorObject(void)
3058 {
3059         result r = E_SUCCESS;
3060         if (__pIndicator)
3061         {
3062                 r = __pIndicator->DeleteIndicatorObject();
3063         }
3064
3065         return r;
3066 }
3067
3068 void
3069 _Form::SetKeypadShowState(bool state)
3070 {
3071         __keypadShowstate = state;
3072
3073         if (!state)
3074         {
3075                 __alreadyStopKeySent = false;
3076         }
3077
3078         if (__clipboardShowstate)
3079         {
3080                 return;
3081         }
3082 }
3083
3084 void
3085 _Form::SetClipboardShowState(bool state)
3086 {
3087         __clipboardShowstate = state;
3088
3089         if (__keypadShowstate)
3090         {
3091                 return;
3092         }
3093 }
3094
3095 result
3096 _Form::AttachedToMainTree(void)
3097 {
3098         _Frame* pFrame = dynamic_cast<_Frame*>(GetParent());
3099         if (pFrame != null)
3100         {
3101                 FrameShowMode mode = pFrame->GetShowMode();
3102                 if (mode != FRAME_SHOW_MODE_FULL_SCREEN)
3103                 {
3104                         SetBounds(FloatRectangle(0.0f, 0.0f, pFrame->GetBoundsF().width, pFrame->GetBoundsF().height));
3105                 }
3106         }
3107
3108         result r = E_SUCCESS;
3109
3110         if (FORM_STYLE_INDICATOR & GetFormStyle())
3111         {
3112                 __pIndicator->OnAttachedToMainTree();
3113                 AddIndicatorObject();
3114
3115                 if (__transparentIndicator != IsIndicatorTranslucent())
3116                 {
3117                         if (__transparentIndicator == true)
3118                         {
3119                                 SetIndicatorOpacity(_INDICATOR_OPACITY_TRANSLUCENT);
3120                         }
3121                         else
3122                         {
3123                                 SetIndicatorOpacity(_INDICATOR_OPACITY_OPAQUE);
3124                         }
3125                 }
3126
3127                 if (__indicatorShowState != IsIndicatorVisible())
3128                 {
3129                         SetIndicatorShowState(__indicatorShowState);
3130                 }
3131
3132                 if (FORM_STYLE_LANDSCAPE_INDICATOR_AUTO_HIDE & GetFormStyle())
3133                 {
3134                         SetIndicatorAutoHide(false, true);
3135                 }
3136                 else
3137                 {
3138                         SetIndicatorAutoHide(false, false);
3139                 }
3140                 r = GetLastResult();
3141                 SysTryReturnResult(NID_UI_CTRL, r == E_SUCCESS, r, "[%s] Propagating.", GetErrorMessage(r));
3142         }
3143         else
3144         {
3145                 if ((FORM_STYLE_INDICATOR_AUTO_HIDE & GetFormStyle()) && (FORM_STYLE_LANDSCAPE_INDICATOR_AUTO_HIDE & GetFormStyle()))
3146                 {
3147                         AddIndicatorObject();
3148                         SetIndicatorShowState(__indicatorShowState);
3149                         SetIndicatorAutoHide(true, true);
3150                 }
3151                 else
3152                 {
3153                         if (FORM_STYLE_INDICATOR_AUTO_HIDE & GetFormStyle())
3154                         {
3155                                 AddIndicatorObject();
3156                                 if (GetOrientation() == _CONTROL_ORIENTATION_PORTRAIT)
3157                                 {
3158                                         SetIndicatorShowState(__indicatorShowState);
3159                                 }
3160                                 else
3161                                 {
3162                                         SetIndicatorShowState(false);
3163                                 }
3164                                 SetIndicatorAutoHide(true, false);
3165
3166                         }
3167                         else if(FORM_STYLE_LANDSCAPE_INDICATOR_AUTO_HIDE & GetFormStyle())
3168                         {
3169                                 AddIndicatorObject();
3170                                 if (GetOrientation() == _CONTROL_ORIENTATION_PORTRAIT)
3171                                 {
3172                                         SetIndicatorShowState(false);
3173                                 }
3174                                 else
3175                                 {
3176                                         SetIndicatorShowState(__indicatorShowState);
3177                                 }
3178                                 SetIndicatorAutoHide(false, true);
3179                         }
3180                         else
3181                         {
3182                                 __pIndicator->SetWindow(GetRootWindow());
3183                                 r = SetIndicatorShowState(false);
3184                                 SetIndicatorAutoHide(false, false);
3185                                 SysTryReturnResult(NID_UI_CTRL, r == E_SUCCESS, r, "[%s] Propagating.", GetErrorMessage(r));
3186                         }
3187                 }
3188         }
3189
3190         AdjustClientBounds();
3191
3192         return r;
3193 }
3194
3195 result
3196 _Form::DetachingFromMainTree(void)
3197 {
3198         result r = E_SUCCESS;
3199         r = DeleteIndicatorObject();
3200         return r;
3201 }
3202
3203 result
3204 _Form::AdjustClientBounds(void)
3205 {
3206         result r = E_SUCCESS;
3207
3208         FloatDimension size = GetSizeF();
3209         FloatRectangle clientBounds(0.0f, 0.0f, size.width, size.height);
3210
3211         if (__deflated)
3212         {
3213                 clientBounds.height -= __deflatedHeight;
3214         }
3215
3216         FloatRectangle indicatorBounds = GetIndicatorBoundsF();
3217
3218         _Control* pParent = GetParent();
3219         _Frame* pFrame = dynamic_cast<_Frame*>(pParent);
3220         if (pFrame)
3221         {
3222                 FrameShowMode mode = pFrame->GetShowMode();
3223
3224                 if (mode != FRAME_SHOW_MODE_FULL_SCREEN)
3225                 {
3226                         if (mode == FRAME_SHOW_MODE_MINIMIZED)
3227                         {
3228                                 if (pFrame->GetShowMode(false) == FRAME_SHOW_MODE_FULL_SCREEN)
3229                                 {
3230                                         if (FORM_STYLE_INDICATOR & __formStyle)
3231                                         {
3232                                                 if (IsIndicatorVisible() && !IsIndicatorTranslucent())
3233                                                 {
3234                                                         clientBounds.y += indicatorBounds.height;
3235                                                         clientBounds.height -= indicatorBounds.height;
3236                                                 }
3237                                         }
3238                                 }
3239                         }
3240                 }
3241                 else
3242                 {
3243                         if (FORM_STYLE_INDICATOR & __formStyle)
3244                         {
3245                                 if (IsIndicatorVisible() && !IsIndicatorTranslucent())
3246                                 {
3247                                         clientBounds.y += indicatorBounds.height;
3248                                         clientBounds.height -= indicatorBounds.height;
3249                                 }
3250                         }
3251                 }
3252         }
3253         else
3254         {
3255                 if (FORM_STYLE_INDICATOR & __formStyle)
3256                 {
3257                         if (IsIndicatorVisible() && !IsIndicatorTranslucent())
3258                         {
3259                                 clientBounds.y += indicatorBounds.height;
3260                                 clientBounds.height -= indicatorBounds.height;
3261                         }
3262                 }
3263         }
3264
3265         if (__pHeader)
3266         {
3267                 if (__pHeader->GetVisibleState() && !IsHeaderTranslucent())
3268                 {
3269                         clientBounds.y += GetToolbarHeightF(true);
3270                         clientBounds.height -= GetToolbarHeightF(true);
3271                 }
3272         }
3273
3274         if (__pTab)
3275         {
3276                 if (__pTab->GetVisibleState()) //&& !IsHeaderTranslucent())
3277                 {
3278                         clientBounds.y += GetTabHeightF();
3279                         clientBounds.height -= GetTabHeightF();
3280                 }
3281         }
3282
3283         if (__pFooter)
3284         {
3285                 if (FORM_STYLE_FOOTER & __formStyle || FORM_STYLE_SOFTKEY_0 & __formStyle || FORM_STYLE_SOFTKEY_1 & __formStyle
3286                                 || FORM_STYLE_OPTIONKEY & __formStyle)
3287                 {
3288                         if (__pFooter->GetVisibleState() && !IsFooterTranslucent())
3289                         {
3290                                         clientBounds.height -= GetToolbarHeightF(false);
3291                         }
3292                 }
3293         }
3294
3295         SetClientBounds(clientBounds);
3296
3297         return r;
3298 }
3299
3300 void
3301 _Form::OnBoundsChanged(void)
3302 {
3303         FloatRectangle toolbarBounds;
3304         FloatRectangle indicatorFloatBounds(0.0f, 0.0f, 0.0f, 0.0f);
3305
3306         float indicatorheight = 0.0f;
3307
3308         if (GetOrientation() == _CONTROL_ORIENTATION_PORTRAIT)
3309         {
3310                 GET_SHAPE_CONFIG(FORM::INDICATOR_HEIGHT, GetOrientation(), indicatorheight);
3311         }
3312         else
3313         {
3314                 if (FORM_STYLE_LANDSCAPE_INDICATOR_AUTO_HIDE & GetFormStyle())
3315                 {
3316                         GET_SHAPE_CONFIG(FORM::INDICATOR_HEIGHT, GetOrientation(), indicatorheight);
3317                 }
3318         }
3319
3320         if (__pIndicator)
3321         {
3322                         __pIndicator->SetBounds(FloatRectangle(0.0f, 0.0f, GetClientBoundsF().width, indicatorheight));
3323         }
3324         AdjustClientBounds();
3325
3326         if (HasHeader())
3327         {
3328                 if (IsIndicatorVisible())
3329                 {
3330                         indicatorFloatBounds = GetIndicatorBoundsF();
3331                         if (IsIndicatorTranslucent())
3332                         {
3333                                 if (!IsHeaderTranslucent())
3334                                 {
3335                                         indicatorFloatBounds.height = 0.0f;
3336                                 }
3337                                 else
3338                                 {
3339                                         if (GetOrientation() == _CONTROL_ORIENTATION_LANDSCAPE)
3340                                         {
3341                                                 indicatorFloatBounds.height = 0.0f;
3342                                         }
3343                                 }
3344                         }
3345                 }
3346
3347                 toolbarBounds = GetHeader()->GetBoundsF();
3348                 toolbarBounds.width = GetSizeF().width;
3349
3350                 FloatRectangle bounds(toolbarBounds.x, indicatorFloatBounds.height, toolbarBounds.width, toolbarBounds.height);
3351                 SetHeaderBounds(bounds);
3352         }
3353
3354         if (HasFooter())
3355         {
3356                 toolbarBounds = GetFooter()->GetBoundsF();
3357                 toolbarBounds.width = GetSizeF().width;
3358                 toolbarBounds.y = GetSizeF().height - toolbarBounds.height;
3359                 SetFooterBounds(toolbarBounds);
3360         }
3361
3362         if (HasTab())
3363         {
3364                 toolbarBounds = GetTab()->GetBoundsF();
3365                 toolbarBounds.width = GetSizeF().width;
3366                 SetTabBounds(toolbarBounds);
3367         }
3368
3369         AdjustClientBounds();
3370 }
3371
3372 FloatDimension
3373 _Form::TranslateSize(FloatDimension size ) const
3374 {
3375         FloatDimension returnSize(0.0f, 0.0f);
3376         returnSize = CoordinateSystem::AlignToDevice(size);
3377
3378         return returnSize;
3379 }
3380
3381 result
3382 _Form::SetNotificationTrayOpenEnabled(bool enable)
3383 {
3384         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.");
3385
3386         if (__pIndicator)
3387         {
3388                 __pIndicator->SetNotificationTrayOpenEnabled(enable);
3389         }
3390         return E_SUCCESS;
3391 }
3392
3393 bool
3394 _Form::IsNotificationTrayOpenEnabled(void) const
3395 {
3396         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.");
3397
3398         if (__pIndicator)
3399         {
3400                 __pIndicator->IsNotificationTrayOpenEnabled();
3401         }
3402         return true;
3403 }
3404
3405 IListT<_Control*>*
3406 _Form::GetFocusList(void) const
3407 {
3408         if(!__pFocusControlList)
3409         {
3410                 __pFocusControlList.reset(GetFocusListN());
3411                 __pFocusControlList->InsertAt(const_cast<_Form*>(this), 0);
3412         }
3413         return __pFocusControlList.get();
3414 }
3415
3416 void
3417 _Form::SetFocusControl(const _Control* pControl)
3418 {
3419         __pFocusControl = const_cast<_Control*>(pControl);
3420 }
3421
3422 _Control*
3423 _Form::GetFocusControl(void) const
3424 {
3425         return __pFocusControl;
3426 }
3427
3428 void
3429 _Form::ResetFocusList(void)
3430 {
3431         if(__pFocusControlList)
3432         {
3433                 __pFocusControlList.reset();
3434         }
3435 }
3436
3437 void
3438 _Form::UpdateClientBounds(const FloatDimension& size, FloatRectangle& clientBounds)
3439 {
3440         clientBounds.width = size.width;
3441         clientBounds.height = size.height;
3442
3443         if (__deflated)
3444         {
3445                 clientBounds.height -= __deflatedHeight;
3446         }
3447
3448         FloatRectangle indicatorBounds = GetIndicatorBoundsF();
3449
3450         _Control* pParent = GetParent();
3451         _Frame* pFrame = dynamic_cast<_Frame*>(pParent);
3452         if (pFrame)
3453         {
3454                 FrameShowMode mode = pFrame->GetShowMode();
3455
3456                 if (mode != FRAME_SHOW_MODE_FULL_SCREEN)
3457                 {
3458                         if (mode == FRAME_SHOW_MODE_MINIMIZED)
3459                         {
3460                                 if (pFrame->GetShowMode(false) == FRAME_SHOW_MODE_FULL_SCREEN)
3461                                 {
3462                                         if (FORM_STYLE_INDICATOR & __formStyle)
3463                                         {
3464                                                 if (IsIndicatorVisible() && !IsIndicatorTranslucent())
3465                                                 {
3466                                                         clientBounds.y += indicatorBounds.height;
3467                                                         clientBounds.height -= indicatorBounds.height;
3468                                                 }
3469                                         }
3470                                 }
3471                         }
3472                 }
3473                 else
3474                 {
3475                         if (FORM_STYLE_INDICATOR & __formStyle)
3476                         {
3477                                 if (IsIndicatorVisible() && !IsIndicatorTranslucent())
3478                                 {
3479                                         clientBounds.y += indicatorBounds.height;
3480                                         clientBounds.height -= indicatorBounds.height;
3481                                 }
3482                         }
3483                 }
3484         }
3485         else
3486         {
3487                 if (FORM_STYLE_INDICATOR & __formStyle)
3488                 {
3489                         if (IsIndicatorVisible() && !IsIndicatorTranslucent())
3490                         {
3491                                 clientBounds.y += indicatorBounds.height;
3492                                 clientBounds.height -= indicatorBounds.height;
3493                         }
3494                 }
3495         }
3496
3497         if (__pHeader)
3498         {
3499                 if (__pHeader->GetVisibleState() && !IsHeaderTranslucent())
3500                 {
3501                         clientBounds.y += GetToolbarHeightF(true);
3502                         clientBounds.height -= GetToolbarHeightF(true);
3503                 }
3504         }
3505
3506         if (__pTab)
3507         {
3508                 if (__pTab->GetVisibleState()) //&& !IsHeaderTranslucent())
3509                 {
3510                         clientBounds.y += GetTabHeightF();
3511                         clientBounds.height -= GetTabHeightF();
3512                 }
3513         }
3514
3515         if (__pFooter)
3516         {
3517                 if (FORM_STYLE_FOOTER & __formStyle || FORM_STYLE_SOFTKEY_0 & __formStyle || FORM_STYLE_SOFTKEY_1 & __formStyle
3518                                 || FORM_STYLE_OPTIONKEY & __formStyle)
3519                 {
3520                         if (__pFooter->GetVisibleState() && !IsFooterTranslucent())
3521                         {
3522                                         clientBounds.height -= GetToolbarHeightF(false);
3523                         }
3524                 }
3525         }
3526 }
3527
3528 void
3529 _Form::OnVisibleStateChanged(void)
3530 {
3531         if (GetVisibleState())
3532         {
3533                 if (FORM_STYLE_INDICATOR & GetFormStyle())
3534                 {
3535                         if (GetOrientation() == _CONTROL_ORIENTATION_LANDSCAPE)
3536                         {
3537                                 if (FORM_STYLE_LANDSCAPE_INDICATOR_AUTO_HIDE & GetFormStyle())
3538                                 {
3539                                         SetIndicatorShowState(true);
3540                                         SetIndicatorAutoHide(false, true);
3541                                 }
3542                                 else
3543                                 {
3544                                         SetIndicatorShowState(false);
3545                                         SetIndicatorAutoHide(false, false);
3546                                 }
3547                         }
3548                         else
3549                         {
3550
3551                                 if (FORM_STYLE_LANDSCAPE_INDICATOR_AUTO_HIDE & GetFormStyle())
3552                                 {
3553                                         SetIndicatorAutoHide(false, true);
3554                                 }
3555                                 else
3556                                 {
3557                                         SetIndicatorAutoHide(false, false);
3558                                 }
3559                                 SetIndicatorShowState(__indicatorShowState);
3560                         }
3561                 }
3562                 else
3563                 {
3564                         if ((FORM_STYLE_INDICATOR_AUTO_HIDE & GetFormStyle()) && (FORM_STYLE_LANDSCAPE_INDICATOR_AUTO_HIDE & GetFormStyle()))
3565                         {
3566                                 SetIndicatorShowState(__indicatorShowState);
3567                                 SetIndicatorAutoHide(true, true);
3568                         }
3569                         else
3570                         {
3571                                 if (FORM_STYLE_INDICATOR_AUTO_HIDE & GetFormStyle())
3572                                 {
3573                                         if (GetOrientation() == _CONTROL_ORIENTATION_PORTRAIT)
3574                                         {
3575                                                 SetIndicatorShowState(true);
3576                                         }
3577                                         else
3578                                         {
3579                                                 SetIndicatorShowState(false);
3580                                         }
3581                                         SetIndicatorAutoHide(true, false);
3582
3583                                 }
3584                                 else if(FORM_STYLE_LANDSCAPE_INDICATOR_AUTO_HIDE & GetFormStyle())
3585                                 {
3586                                         if (GetOrientation() == _CONTROL_ORIENTATION_PORTRAIT)
3587                                         {
3588                                                 SetIndicatorShowState(false);
3589                                         }
3590                                         else
3591                                         {
3592                                                 SetIndicatorShowState(__indicatorShowState);
3593                                         }
3594                                         SetIndicatorAutoHide(false, true);
3595                                 }
3596                                 else
3597                                 {
3598                                         SetIndicatorShowState(false);
3599                                         SetIndicatorAutoHide(false, false);
3600                                 }
3601                         }
3602                 }
3603         }
3604         AdjustClientBounds();
3605 }
3606
3607 void
3608 _Form::SetFormOrientationStatusEventListener(_IFormOrientationStatusEventListener* pFormOrientationstatusEventListener)
3609 {
3610         __pFormOrientationstatusEventListener = pFormOrientationstatusEventListener;
3611 }
3612
3613 Tizen::Ui::OrientationStatus
3614 _Form::GetFormOrientationStatus(void) const
3615 {
3616         if (__pFormOrientationstatusEventListener)
3617         {
3618                 return __pFormOrientationstatusEventListener->OnFormOrientationStatusRequested();
3619         }
3620
3621         return ORIENTATION_STATUS_PORTRAIT;
3622 }
3623
3624 _Control*
3625 _Form::GetFocusTraversalControl(void) const
3626 {
3627         return __pFocusTraversalControl;
3628 }
3629 void
3630 _Form::SetFocusTraversalControl(_Control* pControl)
3631 {
3632         __pFocusTraversalControl = pControl;
3633 }
3634
3635 void
3636 _Form::OnFormActivated(void)
3637 {
3638         AddIndicatorObject();
3639 }
3640
3641
3642 }}} // Tizen::Ui::Controls