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