src/ui/controls/FUiCtrl_EditTimePresenter.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 /**
  19  * @file                FUiCtrl_EditTimePresenter.cpp
  20  * @brief               This is the implementation file for the _EditTimePresenter class.
  21  */
  22
  23 #include <FSysSettingInfo.h>
  24 #include <FGrpColor.h>
  25 #include <FUiAnimAnimationTransaction.h>
  26 #include <FUiAnimVisualElementPropertyAnimation.h>
  27 #include <FGrp_BitmapImpl.h>
  28 #include <FGrp_TextTextObject.h>
  29 #include <FGrp_TextTextSimple.h>
  30 #include <FGrp_FontImpl.h>
  31 #include "FUi_CoordinateSystemUtils.h"
  32 #include "FUi_ResourceManager.h"
  33 #include "FUiAnim_VisualElement.h"
  34 #include "FUiCtrl_EditTimePresenter.h"
  35 #include "FUiCtrl_EditTime.h"
  36 #include "FUiCtrl_DateTimeModel.h"
  37 #include "FUiCtrl_DateTimeUtils.h"
  38
  39
  40 using namespace Tizen::Graphics;
  41 using namespace Tizen::Base;
  42 using namespace Tizen::Graphics::_Text;
  43 using namespace Tizen::Ui::Animations;
  44 using namespace Tizen::System;
  45
  46 namespace Tizen { namespace Ui { namespace Controls
  47 {
  48 _EditTimePresenter::_EditTimePresenter(const String& title)
  49         : __pEditDateTimeModel(null)
  50         , __pEditTime(null)
  51         , __bounds(FloatRectangle())
  52         , __titleBounds(FloatRectangle())
  53         , __ampmString(String())
  54         , __hourString(String())
  55         , __minuteString(String())
  56         , __title(title)
  57         , __24hours(false)
  58         , __is24hoursSet(false)
  59         , __amEnable(true)
  60         , __timePickerEnabled(true)
  61         , __selectedId(DATETIME_ID_NONE)
  62         , __lastSelectedId(DATETIME_ID_NONE)
  63         , __focusId(DATETIME_ID_NONE)
  64         , __touchMoveHandled(false)
  65         , __pAmPmBgNormalColorReplacementBitmap(null)
  66         , __pAmPmBgDisabledColorReplacementBitmap(null)
  67         , __pAmPmBgPressedColorReplacementBitmap(null)
  68         , __pAmPmBgHighlightedColorReplacementBitmap(null)
  69         , __pAmPmBgEffectNomralBitmap(null)
  70         , __pAmPmBgEffectPressedBitmap(null)
  71         , __pAmPmBgEffectDisabledBitmap(null)
  72         , __pColonColorReplacementBitmap(null)
  73         , __pColonDisabledColorReplacementBitmap(null)
  74         , __pContentBgNormalColorReplacementBitmap(null)
  75         , __pContentBgDisabledColorReplacementBitmap(null)
  76         , __pContentBgPressedColorReplacementBitmap(null)
  77         , __pContentBgHighlightedColorReplacementBitmap(null)
  78         , __pContentBgEffectNormalBitmap(null)
  79         , __pContentBgEffectPressedBitmap(null)
  80         , __pContentBgEffectDisabledBitmap(null)
  81         , __pContentProvider(null)
  82         , __textObject()
  83         , __pFont(null)
  84         , __titleObject()
  85         , __amPmTextSize(0.0f)
  86         , __titleFontSize(0.0f)
  87         , __timeFontSize(0.0f)
  88         , __isAnimating(false)
  89         , __isEditTimeInitialized(false)
  90         , __isEnterKeyPressed(false)
  91         , __isFocused(false)
  92         , __transactionId(0)
  93 {
  94 }
  95
  96 _EditTimePresenter::~_EditTimePresenter(void)
  97 {
  98         __textObject.RemoveAll();
  99         __titleObject.RemoveAll();
 100
 101         delete __pEditDateTimeModel;
 102         __pEditDateTimeModel = null;
 103
 104         delete __pAmPmBgNormalColorReplacementBitmap;
 105         __pAmPmBgNormalColorReplacementBitmap = null;
 106
 107         delete __pAmPmBgDisabledColorReplacementBitmap;
 108         __pAmPmBgDisabledColorReplacementBitmap = null;
 109
 110         delete __pAmPmBgPressedColorReplacementBitmap;
 111         __pAmPmBgPressedColorReplacementBitmap = null;
 112
 113         delete __pAmPmBgHighlightedColorReplacementBitmap;
 114         __pAmPmBgHighlightedColorReplacementBitmap = null;
 115
 116         delete __pAmPmBgEffectNomralBitmap;
 117         __pAmPmBgEffectNomralBitmap = null;
 118
 119         delete __pAmPmBgEffectPressedBitmap;
 120         __pAmPmBgEffectPressedBitmap = null;
 121
 122         delete __pAmPmBgEffectDisabledBitmap;
 123         __pAmPmBgEffectDisabledBitmap = null;
 124
 125         delete __pColonColorReplacementBitmap;
 126         __pColonColorReplacementBitmap = null;
 127
 128         delete __pColonDisabledColorReplacementBitmap;
 129         __pColonDisabledColorReplacementBitmap = null;
 130
 131         delete __pContentBgNormalColorReplacementBitmap;
 132         __pContentBgNormalColorReplacementBitmap = null;
 133
 134         delete __pContentBgDisabledColorReplacementBitmap;
 135         __pContentBgDisabledColorReplacementBitmap = null;
 136
 137         delete __pContentBgPressedColorReplacementBitmap;
 138         __pContentBgPressedColorReplacementBitmap = null;
 139
 140         delete __pContentBgHighlightedColorReplacementBitmap;
 141         __pContentBgHighlightedColorReplacementBitmap = null;
 142
 143         delete __pContentBgEffectNormalBitmap;
 144         __pContentBgEffectNormalBitmap = null;
 145
 146         delete __pContentBgEffectPressedBitmap;
 147         __pContentBgEffectPressedBitmap = null;
 148
 149         delete __pContentBgEffectDisabledBitmap;
 150         __pContentBgEffectDisabledBitmap = null;
 151
 152         if (__transactionId != 0)
 153         {
 154                 AnimationTransaction::Stop(__transactionId);
 155         }
 156
 157         if (__pContentProvider != null)
 158         {
 159                 __pEditTime->GetVisualElement()->DetachChild(__pContentProvider);
 160                 __pContentProvider->Destroy();
 161                 __pContentProvider = null;
 162         }
 163 }
 164
 165 _EditTimePresenter*
 166 _EditTimePresenter::CreateInstanceN(const _EditTime& editTime, const String& title)
 167 {
 168         _EditTimePresenter* pEditTimePresenter = new (std::nothrow) _EditTimePresenter(title);
 169         SysTryReturn(NID_UI_CTRL, pEditTimePresenter, null, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] Memory allocation failed.");
 170
 171         pEditTimePresenter->__pEditTime = const_cast <_EditTime*>(&editTime);
 172
 173         pEditTimePresenter->__pEditDateTimeModel = new (std::nothrow) _DateTimeModel;
 174         SysTryCatch(NID_UI_CTRL, pEditTimePresenter->__pEditDateTimeModel, , E_OUT_OF_MEMORY,
 175                         "[E_OUT_OF_MEMORY] Memory allocation failed.");
 176
 177         return pEditTimePresenter;
 178
 179 CATCH:
 180         delete pEditTimePresenter;
 181         return null;
 182 }
 183
 184 DateTime
 185 _EditTimePresenter::GetTime(void) const
 186 {
 187         DateTime time;
 188         time.SetValue(DATETIME_YEAR_MIN, DATETIME_MONTH_MIN, DATETIME_DAY_MIN, GetHour(), GetMinute(), 0);
 189
 190         return time;
 191 }
 192
 193 int
 194 _EditTimePresenter::GetHour(void) const
 195 {
 196         return __pEditDateTimeModel->GetHour();
 197 }
 198
 199 int
 200 _EditTimePresenter::GetMinute(void) const
 201 {
 202         return __pEditDateTimeModel->GetMinute();
 203 }
 204
 205 void
 206 _EditTimePresenter::SetTime(const DateTime& time)
 207 {
 208         __pEditDateTimeModel->SetDateTime(time);
 209 }
 210
 211 void
 212 _EditTimePresenter::SetCurrentTime(void)
 213 {
 214         __pEditDateTimeModel->SetCurrentDateTime();
 215         return;
 216 }
 217
 218 result
 219 _EditTimePresenter::SetHour(int hour)
 220 {
 221         return __pEditDateTimeModel->SetHour(hour);
 222 }
 223
 224 result
 225 _EditTimePresenter::SetMinute(int minute)
 226 {
 227         return __pEditDateTimeModel->SetMinute(minute);
 228 }
 229
 230 void
 231 _EditTimePresenter::SetTimePickerEnabled(bool enable)
 232 {
 233         __timePickerEnabled = enable;
 234         return;
 235 }
 236
 237 bool
 238 _EditTimePresenter::IsTimePickerEnabled(void) const
 239 {
 240         return __timePickerEnabled;
 241 }
 242
 243 void
 244 _EditTimePresenter::Set24HourNotationEnabled(bool enable)
 245 {
 246         __24hours = enable;
 247         __is24hoursSet = true;
 248         return;
 249 }
 250
 251 bool
 252 _EditTimePresenter::Is24HourNotationEnabled(void) const
 253 {
 254         return __24hours;
 255 }
 256
 257 void
 258 _EditTimePresenter::SetTimeConversion(void)
 259 {
 260         int hour = GetHour();
 261         int minute = GetMinute();
 262
 263         if (!__24hours)
 264         {
 265                 int max = DATETIME_HOUR_MAX_FOR_24NOTATION;
 266
 267                 if (hour > max)
 268                 {
 269                         __hourString.Format(10, L"%02d", hour - max);
 270                 }
 271                 else if (hour == DATETIME_HOUR_MIN)
 272                 {
 273                         __hourString.Format(10, L"%02d", hour + DATETIME_HOUR_MAX_FOR_24NOTATION);
 274                 }
 275                 else
 276                 {
 277                         __hourString.Format(10, L"%02d", hour);
 278                 }
 279
 280                 __minuteString.Format(10, L"%02d", minute);
 281         }
 282         else
 283         {
 284                 __hourString.Format(10, L"%02d", hour);
 285                 __minuteString.Format(10, L"%02d", minute);
 286         }
 287
 288         return;
 289 }
 290
 291 void
 292 _EditTimePresenter::SetAmEnabled(bool amEnable)
 293 {
 294         String textAm;
 295         String textPm;
 296
 297         _DateTimeUtils dateTimeUtils;
 298         dateTimeUtils.GetAmPm(textAm, AM_TYPE);
 299         dateTimeUtils.GetAmPm(textPm, PM_TYPE);
 300
 301         __amEnable = amEnable;
 302         int hour = GetHour();
 303
 304         if (__amEnable)
 305         {
 306                 __ampmString = textAm;
 307                 if (hour >= DATETIME_HOUR_MAX_FOR_24NOTATION)
 308                 {
 309                         SetHour(hour - DATETIME_HOUR_MAX_FOR_24NOTATION);
 310                 }
 311         }
 312         else
 313         {
 314                 __ampmString = textPm;
 315                 if (hour < DATETIME_HOUR_MAX_FOR_24NOTATION)
 316                 {
 317                         SetHour(hour + DATETIME_HOUR_MAX_FOR_24NOTATION);
 318                 }
 319         }
 320
 321         return;
 322 }
 323
 324 bool
 325 _EditTimePresenter::GetAmEnabled(void) const
 326 {
 327         return __amEnable;
 328 }
 329
 330 FloatRectangle
 331 _EditTimePresenter::GetDisplayAreaBoundsFromHoursStyle(_DateTimeId displayBoxId) const
 332 {
 333         SysTryReturn(NID_UI_CTRL, displayBoxId >= DATETIME_ID_HOUR && displayBoxId <= DATETIME_ID_AMPM, FloatRectangle(),
 334                         E_OUT_OF_RANGE, "[E_OUT_OF_RANGE] displayBoxId is out of range.");
 335
 336         FloatRectangle bounds(0.0f, 0.0f, 0.0f, 0.0f);
 337
 338         float editTimeHeight = 0.0f;
 339         float colonWidth = 0.0f;
 340         float timeAmPmMargin = 0.0f;
 341         float colonMargin = 0.0f;
 342         float timeElementWidth = 0.0f;
 343         float amPmHeight = 0.0f;
 344         float timeHeight = 0.0f;
 345         float titleTimeMargin = 0.0f;
 346         float leftMargin = 0.0f;
 347
 348         GET_SHAPE_CONFIG(EDITTIME::HEIGHT, __pEditTime->GetOrientation(), editTimeHeight);
 349         GET_SHAPE_CONFIG(EDITTIME::COLON_WIDTH, __pEditTime->GetOrientation(), colonWidth);
 350         GET_SHAPE_CONFIG(EDITTIME::TIME_AMPM_MARGIN, __pEditTime->GetOrientation(), timeAmPmMargin);
 351         GET_SHAPE_CONFIG(EDITTIME::COLON_MARGIN, __pEditTime->GetOrientation(), colonMargin);
 352         GET_SHAPE_CONFIG(EDITTIME::AMPM_HEIGHT, __pEditTime->GetOrientation(), amPmHeight);
 353         GET_SHAPE_CONFIG(EDITTIME::TITLE_TIME_MARGIN, __pEditTime->GetOrientation(), titleTimeMargin);
 354         GET_SHAPE_CONFIG(EDITTIME::TIME_HEIGHT, __pEditTime->GetOrientation(), timeHeight);
 355
 356         GET_SHAPE_CONFIG(EDITTIME::TIME_TEXT_LEFT_MARGIN, __pEditTime->GetOrientation(), leftMargin);
 357
 358         if (__pEditTime->GetBoundsF().height > editTimeHeight)
 359         {
 360                 editTimeHeight = __pEditTime->GetBoundsF().height;
 361         }
 362
 363         bounds.y = (editTimeHeight - timeHeight) / 2.0f;
 364
 365         if (!__title.IsEmpty())
 366         {
 367                 if (displayBoxId == DATETIME_ID_AMPM)
 368                 {
 369                         bounds.y = __titleBounds.y + __titleBounds.height;
 370                 }
 371                 else
 372                 {
 373                         bounds.y = __titleBounds.y + __titleBounds.height + titleTimeMargin;
 374                 }
 375         }
 376
 377         bounds.x = leftMargin;
 378         bounds.height = timeHeight;
 379
 380         timeElementWidth = GetTimeElementWidth();
 381
 382         if (displayBoxId == DATETIME_ID_HOUR)
 383         {
 384                 bounds.width = timeElementWidth;
 385         }
 386         else if (displayBoxId == DATETIME_ID_MINUTE)
 387         {
 388                 bounds.x = bounds.x + timeElementWidth + colonWidth + (2.0f * colonMargin);
 389                 bounds.width = timeElementWidth;
 390         }
 391         else if (displayBoxId == DATETIME_ID_AMPM)
 392         {
 393                 bounds.x = leftMargin + (2.0f * timeElementWidth) + colonWidth + (2.0f * colonMargin) + timeAmPmMargin;
 394
 395                 if (__title.IsEmpty())
 396                 {
 397                         bounds.y = (editTimeHeight - amPmHeight) / 2.0f;
 398                 }
 399
 400                 GET_SHAPE_CONFIG(EDITTIME::AMPM_WIDTH, __pEditTime->GetOrientation(), bounds.width);
 401                 bounds.height = amPmHeight;
 402         }
 403
 404         return bounds;
 405 }
 406
 407 float
 408 _EditTimePresenter::GetTextWidth(_DateTimeId boxId) const
 409 {
 410         result r = E_SUCCESS;
 411         FloatDimension dim;
 412         TextObject dateObject;
 413         String hourString;
 414         String minuteString;
 415
 416         hourString.Format(10, L"%02d", GetHour());
 417         minuteString.Format(10, L"%02d", GetMinute());
 418
 419         r = dateObject.Construct();
 420         SysTryReturn(NID_UI_CTRL, (r == E_SUCCESS), r, r, "[%s] Propagating.", GetErrorMessage(r));
 421
 422         TextSimple* pSimpleText = null;
 423
 424         if (boxId == DATETIME_ID_HOUR)
 425         {
 426                 pSimpleText = new (std::nothrow)TextSimple((const_cast <wchar_t*>(hourString.GetPointer())), hourString.GetLength(), TEXT_ELEMENT_SOURCE_TYPE_EXTERNAL);
 427         }
 428         else if (boxId == DATETIME_ID_MINUTE)
 429         {
 430                 pSimpleText = new (std::nothrow)TextSimple((const_cast <wchar_t*>(minuteString.GetPointer())), minuteString.GetLength(), TEXT_ELEMENT_SOURCE_TYPE_EXTERNAL);
 431         }
 432
 433         SysTryReturn(NID_UI_CTRL, (pSimpleText != null), dim.width, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] Memory allocation failed.");
 434
 435         (_FontImpl::GetInstance(*__pFont))->SetSize(__timeFontSize);
 436
 437         pSimpleText->SetTextShadowEnabled(true);
 438         pSimpleText->SetTextShadowOffset(FloatPoint(0.0f, -1.0f));
 439
 440         dateObject.AppendElement(*pSimpleText);
 441         dateObject.SetFont(__pFont, 0, dateObject.GetTextLength());
 442         dim = dateObject.GetTextExtentF(0, dateObject.GetTextLength());
 443
 444         dateObject.RemoveAll();
 445         return dim.width;
 446 }
 447
 448 void
 449 _EditTimePresenter::SetTitleBounds(void)
 450 {
 451         GET_SHAPE_CONFIG(EDITTIME::TITLE_TEXT_LEFT_MARGIN, __pEditTime->GetOrientation(), __titleBounds.x);
 452         GET_SHAPE_CONFIG(EDITTIME::TITLE_HEIGHT, __pEditTime->GetOrientation(), __titleBounds.height);
 453
 454         __titleBounds.width = __pEditTime->GetBoundsF().width - __titleBounds.x;
 455         return;
 456 }
 457
 458 FloatRectangle
 459 _EditTimePresenter::GetTitleBounds(void) const
 460 {
 461         return __titleBounds;
 462 }
 463
 464 result
 465 _EditTimePresenter::LoadResource(void)
 466 {
 467         result r = E_SUCCESS;
 468
 469         Color buttonNormalBgColor;
 470         Color buttonDisabledBgColor;
 471         Color buttonPressedColor;
 472         Color buttonHighlightedColor;
 473         Color contentNormalBgColor;
 474         Color contentDisabledBgColor;
 475         Color contentPressedColor;
 476         Color contentHighlightedColor;
 477         Color colonTextColor;
 478         Color colonTextDisabledColor;
 479
 480
 481         GET_COLOR_CONFIG(EDITTIME::BUTTON_BG_NORMAL, buttonNormalBgColor);
 482         GET_COLOR_CONFIG(EDITTIME::BUTTON_BG_PRESSED, buttonPressedColor);
 483         GET_COLOR_CONFIG(EDITTIME::BUTTON_BG_DISABLED, buttonDisabledBgColor);
 484         GET_COLOR_CONFIG(EDITTIME::BUTTON_BG_HIGHLIGHTED, buttonHighlightedColor);
 485
 486         GET_COLOR_CONFIG(EDITTIME::CONTENT_BG_NORMAL, contentNormalBgColor);
 487         GET_COLOR_CONFIG(EDITTIME::CONTENT_BG_DISABLED, contentDisabledBgColor);
 488         GET_COLOR_CONFIG(EDITTIME::CONTENT_BG_PRESSED, contentPressedColor);
 489         GET_COLOR_CONFIG(EDITTIME::CONTENT_BG_HIGHLIGHTED, contentHighlightedColor);
 490
 491         GET_COLOR_CONFIG(EDITTIME::TEXT_NORMAL, colonTextColor);
 492         GET_COLOR_CONFIG(EDITTIME::TEXT_DISABLED, colonTextDisabledColor);
 493
 494         GET_SHAPE_CONFIG(EDITTIME::AMPM_FONT_SIZE, __pEditTime->GetOrientation(), __amPmTextSize);
 495
 496         r = GET_REPLACED_BITMAP_CONFIG_N(EDITTIME::COLON_BG_NORMAL, BITMAP_PIXEL_FORMAT_ARGB8888, colonTextColor, __pColonColorReplacementBitmap);
 497         SysTryReturnResult(NID_UI_CTRL, (r == E_SUCCESS), r, "[%s] Propagating.", GetErrorMessage(r));
 498
 499         r = GET_REPLACED_BITMAP_CONFIG_N(EDITTIME::COLON_BG_NORMAL, BITMAP_PIXEL_FORMAT_ARGB8888, colonTextDisabledColor, __pColonDisabledColorReplacementBitmap);
 500         SysTryCatch(NID_UI_CTRL, (r == E_SUCCESS), , r, "[%s] Propagating.", GetErrorMessage(r));
 501
 502
 503         r = GET_REPLACED_BITMAP_CONFIG_N(EDITTIME::BUTTON_BG_NORMAL, BITMAP_PIXEL_FORMAT_ARGB8888, buttonNormalBgColor, __pAmPmBgNormalColorReplacementBitmap);
 504         SysTryCatch(NID_UI_CTRL, (r == E_SUCCESS), , r, "[%s] Propagating.", GetErrorMessage(r));
 505
 506         r = GET_REPLACED_BITMAP_CONFIG_N(EDITTIME::BUTTON_BG_DISABLED, BITMAP_PIXEL_FORMAT_ARGB8888, buttonDisabledBgColor, __pAmPmBgDisabledColorReplacementBitmap);
 507         SysTryCatch(NID_UI_CTRL, (r == E_SUCCESS), , r, "[%s] Propagating.", GetErrorMessage(r));
 508
 509         r = GET_REPLACED_BITMAP_CONFIG_N(EDITTIME::BUTTON_BG_PRESSED, BITMAP_PIXEL_FORMAT_ARGB8888, buttonPressedColor, __pAmPmBgPressedColorReplacementBitmap);
 510         SysTryCatch(NID_UI_CTRL, (r == E_SUCCESS), , r, "[%s] Propagating.", GetErrorMessage(r));
 511
 512         r = GET_REPLACED_BITMAP_CONFIG_N(EDITTIME::BUTTON_BG_HIGHLIGHTED, BITMAP_PIXEL_FORMAT_ARGB8888, buttonHighlightedColor, __pAmPmBgHighlightedColorReplacementBitmap);
 513         SysTryCatch(NID_UI_CTRL, (r == E_SUCCESS), , r, "[%s] Propagating.", GetErrorMessage(r));
 514
 515         r = GET_REPLACED_BITMAP_CONFIG_N(EDITTIME::CONTENT_BG_NORMAL, BITMAP_PIXEL_FORMAT_ARGB8888, contentNormalBgColor, __pContentBgNormalColorReplacementBitmap);
 516         SysTryCatch(NID_UI_CTRL, (r == E_SUCCESS), , r, "[%s] Propagating.", GetErrorMessage(r));
 517
 518         r = GET_REPLACED_BITMAP_CONFIG_N(EDITTIME::CONTENT_BG_PRESSED, BITMAP_PIXEL_FORMAT_ARGB8888, contentPressedColor, __pContentBgPressedColorReplacementBitmap);
 519         SysTryCatch(NID_UI_CTRL, (r == E_SUCCESS), , r, "[%s] Propagating.", GetErrorMessage(r));
 520
 521         r = GET_REPLACED_BITMAP_CONFIG_N(EDITTIME::CONTENT_BG_DISABLED, BITMAP_PIXEL_FORMAT_ARGB8888, contentDisabledBgColor, __pContentBgDisabledColorReplacementBitmap);
 522         SysTryCatch(NID_UI_CTRL, (r == E_SUCCESS), , r, "[%s] Propagating.", GetErrorMessage(r));
 523
 524         r = GET_REPLACED_BITMAP_CONFIG_N(EDITTIME::CONTENT_BG_HIGHLIGHTED, BITMAP_PIXEL_FORMAT_ARGB8888, contentHighlightedColor, __pContentBgHighlightedColorReplacementBitmap);
 525         SysTryCatch(NID_UI_CTRL, (r == E_SUCCESS), , r, "[%s] Propagating.", GetErrorMessage(r));
 526
 527         r = GET_BITMAP_CONFIG_N(EDITTIME::BUTTON_BG_EFFECT_NORMAL, BITMAP_PIXEL_FORMAT_ARGB8888, __pAmPmBgEffectNomralBitmap);
 528         SysTryCatch(NID_UI_CTRL, (r == E_SUCCESS), , r, "[%s] Propagating.", GetErrorMessage(r));
 529
 530         r = GET_BITMAP_CONFIG_N(EDITTIME::BUTTON_BG_EFFECT_PRESSED, BITMAP_PIXEL_FORMAT_ARGB8888, __pAmPmBgEffectPressedBitmap);
 531         SysTryCatch(NID_UI_CTRL, (r == E_SUCCESS), , r, "[%s] Propagating.", GetErrorMessage(r));
 532
 533         r = GET_BITMAP_CONFIG_N(EDITTIME::BUTTON_BG_EFFECT_DISABLED, BITMAP_PIXEL_FORMAT_ARGB8888, __pAmPmBgEffectDisabledBitmap);
 534         SysTryCatch(NID_UI_CTRL, (r == E_SUCCESS), , r, "[%s] Propagating.", GetErrorMessage(r));
 535
 536         r = GET_BITMAP_CONFIG_N(EDITTIME::CONTENT_BG_EFFECT_NORMAL, BITMAP_PIXEL_FORMAT_ARGB8888, __pContentBgEffectNormalBitmap);
 537         SysTryCatch(NID_UI_CTRL, (r == E_SUCCESS), , r, "[%s] Propagating.", GetErrorMessage(r));
 538
 539         r = GET_BITMAP_CONFIG_N(EDITTIME::CONTENT_BG_EFFECT_PRESSED, BITMAP_PIXEL_FORMAT_ARGB8888, __pContentBgEffectPressedBitmap);
 540         SysTryCatch(NID_UI_CTRL, (r == E_SUCCESS), , r, "[%s] Propagating.", GetErrorMessage(r));
 541
 542         r = GET_BITMAP_CONFIG_N(EDITTIME::CONTENT_BG_EFFECT_DISABLED, BITMAP_PIXEL_FORMAT_ARGB8888, __pContentBgEffectDisabledBitmap);
 543         SysTryCatch(NID_UI_CTRL, (r == E_SUCCESS), , r, "[%s] Propagating.", GetErrorMessage(r));
 544
 545         return r;
 546
 547 CATCH:
 548
 549         delete __pColonColorReplacementBitmap;
 550         __pColonColorReplacementBitmap = null;
 551
 552         delete __pColonDisabledColorReplacementBitmap;
 553         __pColonDisabledColorReplacementBitmap = null;
 554
 555         delete __pAmPmBgNormalColorReplacementBitmap;
 556         __pAmPmBgNormalColorReplacementBitmap = null;
 557
 558         delete __pAmPmBgPressedColorReplacementBitmap;
 559         __pAmPmBgPressedColorReplacementBitmap = null;
 560
 561         delete __pAmPmBgDisabledColorReplacementBitmap;
 562         __pAmPmBgDisabledColorReplacementBitmap = null;
 563
 564         delete __pAmPmBgHighlightedColorReplacementBitmap;
 565         __pAmPmBgHighlightedColorReplacementBitmap = null;
 566
 567         delete __pContentBgNormalColorReplacementBitmap;
 568         __pContentBgNormalColorReplacementBitmap = null;
 569
 570         delete __pContentBgPressedColorReplacementBitmap;
 571         __pContentBgPressedColorReplacementBitmap = null;
 572
 573         delete __pContentBgDisabledColorReplacementBitmap;
 574         __pContentBgDisabledColorReplacementBitmap = null;
 575
 576         delete __pContentBgHighlightedColorReplacementBitmap;
 577         __pContentBgHighlightedColorReplacementBitmap = null;
 578
 579         delete __pAmPmBgEffectNomralBitmap;
 580         __pAmPmBgEffectNomralBitmap = null;
 581
 582         delete __pAmPmBgEffectPressedBitmap;
 583         __pAmPmBgEffectPressedBitmap = null;
 584
 585         delete __pAmPmBgEffectDisabledBitmap;
 586         __pAmPmBgEffectDisabledBitmap = null;
 587
 588         delete __pContentBgEffectNormalBitmap;
 589         __pContentBgEffectNormalBitmap = null;
 590
 591         delete __pContentBgEffectPressedBitmap;
 592         __pContentBgEffectPressedBitmap = null;
 593
 594         delete __pContentBgEffectDisabledBitmap;
 595         __pContentBgEffectDisabledBitmap = null;
 596
 597         delete __pColonColorReplacementBitmap;
 598         __pColonColorReplacementBitmap = null;
 599
 600         delete __pColonDisabledColorReplacementBitmap;
 601         __pColonDisabledColorReplacementBitmap = null;
 602
 603         return r;
 604 }
 605
 606 result
 607 _EditTimePresenter::DrawResourceBitmap(Canvas& canvas, const FloatRectangle& bounds, Bitmap* pBitmap, bool isCustomBitmap)
 608 {
 609         result r = E_SUCCESS;
 610
 611         if (pBitmap == null)
 612         {
 613                 return r;
 614         }
 615
 616         if (_BitmapImpl::CheckNinePatchedBitmapStrictly(*pBitmap))
 617         {
 618                 r = canvas.DrawNinePatchedBitmap(bounds, *pBitmap);
 619                 SysTryReturn(NID_UI_CTRL, (r == E_SUCCESS), r, r, "[%s] Propagating.", GetErrorMessage(r));
 620         }
 621         else
 622         {
 623                 if (isCustomBitmap)
 624                 {
 625                         Canvas *pContentCanvas = __pEditTime->GetCanvasN(bounds);
 626                         SysTryReturnResult(NID_UI_CTRL, (pContentCanvas != null), GetLastResult(), "[%s] Propagating.", GetErrorMessage(GetLastResult()));
 627
 628                         FloatPoint position;
 629
 630                         position.x = (bounds.width - pBitmap->GetWidthF()) / 2;
 631                         position.y = (bounds.height - pBitmap->GetHeightF()) / 2;
 632                         r = pContentCanvas->DrawBitmap(position, *pBitmap);
 633                         delete pContentCanvas;
 634                 }
 635                 else
 636                 {
 637                         r = canvas.DrawBitmap(FloatPoint(bounds.x, bounds.y), *pBitmap);
 638                 }
 639
 640                 SysTryReturn(NID_UI_CTRL, (r == E_SUCCESS), r, r, "[%s] Propagating.", GetErrorMessage(r));
 641         }
 642
 643         return r;
 644 }
 645
 646 float
 647 _EditTimePresenter::GetTimeElementWidth(void) const
 648 {
 649         FloatRectangle bounds;
 650         FloatDimension minSize;
 651         bounds = __pEditTime->GetBoundsF();
 652
 653         float timeElementWidth = 0.0f;
 654         float timeElementMinWidth = 0.0f;
 655         float editTimeWidth = 0.0f;
 656
 657         GET_SHAPE_CONFIG(EDITTIME::HOUR_MINUTE_WIDTH, __pEditTime->GetOrientation(), timeElementWidth);
 658         GET_SHAPE_CONFIG(EDITTIME::HOUR_MINUTE_MIN_WIDTH, __pEditTime->GetOrientation(), timeElementMinWidth);
 659         GET_SHAPE_CONFIG(EDITTIME::WIDTH, __pEditTime->GetOrientation(), editTimeWidth);
 660
 661         GET_DIMENSION_CONFIG(EDITTIME::MIN_SIZE, __pEditTime->GetOrientation(), minSize);
 662
 663         if (bounds.width >= editTimeWidth)
 664         {
 665                 return timeElementWidth;
 666         }
 667
 668         if (bounds.width <= minSize.width)
 669         {
 670                 timeElementWidth = timeElementMinWidth;
 671         }
 672         else if (bounds.width < editTimeWidth && bounds.width > minSize.width)
 673         {
 674                 timeElementWidth = timeElementWidth -
 675                                 ((timeElementWidth - timeElementMinWidth) / (editTimeWidth - minSize.width)) * (editTimeWidth - bounds.width);
 676         }
 677
 678         return timeElementWidth;
 679 }
 680
 681 result
 682 _EditTimePresenter::InitializeTitleObject(void)
 683 {
 684         result r = E_SUCCESS;
 685
 686         Color titleNormalColor;
 687
 688         GET_COLOR_CONFIG(EDITTIME::TITLE_TEXT_NORMAL, titleNormalColor);
 689
 690         r = __titleObject.Construct();
 691         SysTryReturn(NID_UI_CTRL, (r == E_SUCCESS), r, r, "[%s] Propagating.", GetErrorMessage(r));
 692
 693         TextSimple* pSimpleText = null;
 694
 695         pSimpleText = new (std::nothrow)TextSimple((const_cast <wchar_t*>(__title.GetPointer())), __title.GetLength(), TEXT_ELEMENT_SOURCE_TYPE_EXTERNAL);
 696         SysTryReturn(NID_UI_CTRL, (pSimpleText != null), E_OUT_OF_MEMORY, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] Memory allocation failed.");
 697
 698         __titleObject.AppendElement(*pSimpleText);
 699
 700         __titleObject.SetForegroundColor(titleNormalColor, 0, __titleObject.GetTextLength());
 701         __titleObject.SetFont(__pFont, 0, __titleObject.GetTextLength());
 702         __titleObject.SetAlignment(TEXT_OBJECT_ALIGNMENT_LEFT | TEXT_OBJECT_ALIGNMENT_MIDDLE);
 703         __titleObject.SetWrap(TEXT_OBJECT_WRAP_TYPE_NONE);
 704         __titleObject.SetAction(TEXT_OBJECT_ACTION_TYPE_ABBREV);
 705         __titleObject.SetTextObjectEllipsisType(TEXT_OBJECT_ELLIPSIS_TYPE_TAIL);
 706
 707         return r;
 708 }
 709
 710 result
 711 _EditTimePresenter::InitializeTextObject(void)
 712 {
 713         result r = E_SUCCESS;
 714
 715         r = __textObject.Construct();
 716         SysTryReturn(NID_UI_CTRL, (r == E_SUCCESS), r, r, "[%s] Propagating.", GetErrorMessage(r));
 717
 718         TextSimple* pSimpleText = new (std::nothrow)TextSimple(null, 0, TEXT_ELEMENT_SOURCE_TYPE_EXTERNAL);
 719         SysTryReturn(NID_UI_CTRL, (pSimpleText != null), E_OUT_OF_MEMORY, E_OUT_OF_MEMORY,
 720                         "[E_OUT_OF_MEMORY] Memory allocation failed.");
 721
 722         pSimpleText->SetTextShadowEnabled(true);
 723         pSimpleText->SetTextShadowOffset(FloatPoint(0.0f, -1.0f));
 724
 725         __textObject.AppendElement(*pSimpleText);
 726
 727         __textObject.SetFont(__pFont, 0, __textObject.GetTextLength());
 728         __textObject.SetAlignment(TEXT_OBJECT_ALIGNMENT_CENTER | TEXT_OBJECT_ALIGNMENT_MIDDLE);
 729         __textObject.SetWrap(TEXT_OBJECT_WRAP_TYPE_NONE);
 730         __textObject.SetAction(TEXT_OBJECT_ACTION_TYPE_ABBREV);
 731
 732         return r;
 733 }
 734
 735 result
 736 _EditTimePresenter::Draw(void)
 737 {
 738         result r = E_SUCCESS;
 739
 740         if (__isAnimating)
 741         {
 742                 return E_SUCCESS;
 743         }
 744
 745         Canvas* pCanvas = __pEditTime->GetCanvasN();
 746         r = GetLastResult();
 747         SysTryReturnResult(NID_UI_CTRL, (pCanvas != null), r, "Failed to get canvas.");
 748
 749         FloatRectangle colonBounds(0.0f, 0.0f, 0.0f, 0.0f);
 750
 751         float colonMargin = 0.0f;
 752
 753         Dimension textArea;
 754
 755         pCanvas->SetBackgroundColor(Color(0, 0, 0, 0));
 756         pCanvas->Clear();
 757
 758         FloatRectangle hourBounds(0.0f, 0.0f, 0.0f, 0.0f);
 759         FloatRectangle minuteBounds(0.0f, 0.0f, 0.0f, 0.0f);
 760         FloatRectangle ampmBounds(0.0f, 0.0f, 0.0f, 0.0f);
 761         bool isCustomBitmap = false;
 762         Bitmap* pReplacementBitmap = null;
 763         Bitmap* pEffectBitmap = null;
 764
 765         hourBounds = GetDisplayAreaBoundsFromHoursStyle(DATETIME_ID_HOUR);
 766         minuteBounds = GetDisplayAreaBoundsFromHoursStyle(DATETIME_ID_MINUTE);
 767
 768         if (!__24hours)
 769         {
 770                 ampmBounds = GetDisplayAreaBoundsFromHoursStyle(DATETIME_ID_AMPM);
 771
 772                 if (!__pEditTime->IsEnabled())
 773                 {
 774                         isCustomBitmap = IS_CUSTOM_BITMAP(EDITTIME::BUTTON_BG_DISABLED);
 775                         pReplacementBitmap = __pAmPmBgDisabledColorReplacementBitmap;
 776                         pEffectBitmap = __pAmPmBgEffectDisabledBitmap;
 777                 }
 778                 else if (__selectedId != DATETIME_ID_AMPM)
 779                 {
 780                         isCustomBitmap = IS_CUSTOM_BITMAP(EDITTIME::BUTTON_BG_NORMAL);
 781                         pReplacementBitmap = __pAmPmBgNormalColorReplacementBitmap;
 782                         pEffectBitmap = __pAmPmBgEffectNomralBitmap;
 783                 }
 784                 else
 785                 {
 786                         isCustomBitmap = IS_CUSTOM_BITMAP(EDITTIME::BUTTON_BG_PRESSED);
 787                         pReplacementBitmap = __pAmPmBgPressedColorReplacementBitmap;
 788                         pEffectBitmap = __pAmPmBgEffectPressedBitmap;
 789                 }
 790         }
 791
 792         if (GetHour() >= DATETIME_HOUR_MAX_FOR_24NOTATION)
 793         {
 794                 SetAmEnabled(false);
 795         }
 796         else
 797         {
 798                 SetAmEnabled(true);
 799         }
 800
 801         SetTimeConversion();
 802
 803         GET_SHAPE_CONFIG(EDITTIME::COLON_WIDTH, __pEditTime->GetOrientation(), colonBounds.width);
 804         GET_SHAPE_CONFIG(EDITTIME::COLON_MARGIN, __pEditTime->GetOrientation(), colonMargin);
 805         GET_SHAPE_CONFIG(EDITTIME::AMPM_HEIGHT, __pEditTime->GetOrientation(), colonBounds.height);
 806
 807         colonBounds.x = hourBounds.x + hourBounds.width + colonMargin;
 808         colonBounds.y = hourBounds.y + (hourBounds.height - colonBounds.height) / 2.0f;
 809
 810         if (!__title.IsEmpty())
 811         {
 812                 r = DrawTitle(*pCanvas);
 813                 SysTryCatch(NID_UI_CTRL, r == E_SUCCESS, , r, "[%s] Propagating.", GetErrorMessage(r));
 814         }
 815
 816         r = DrawText(*pCanvas, hourBounds, __hourString, DATETIME_ID_HOUR);
 817         SysTryCatch(NID_UI_CTRL, r == E_SUCCESS, , r, "[%s] Propagating.", GetErrorMessage(r));
 818
 819         r = DrawText(*pCanvas, minuteBounds, __minuteString, DATETIME_ID_MINUTE);
 820         SysTryCatch(NID_UI_CTRL, r == E_SUCCESS, , r, "[%s] Propagating.", GetErrorMessage(r));
 821
 822         r = DrawColon(*pCanvas, colonBounds);
 823         SysTryCatch(NID_UI_CTRL, r == E_SUCCESS, , r, "[%s] Propagating.", GetErrorMessage(r));
 824
 825         if (!__24hours)
 826         {
 827                 r = DrawResourceBitmap(*pCanvas, ampmBounds, pReplacementBitmap, isCustomBitmap);
 828                 SysTryCatch(NID_UI_CTRL, (r == E_SUCCESS), , r, "[%s] Propagating.", GetErrorMessage(r));
 829
 830                 if (!isCustomBitmap)
 831                 {
 832                         r = DrawResourceBitmap(*pCanvas, ampmBounds, pEffectBitmap);
 833                         SysTryCatch(NID_UI_CTRL, (r == E_SUCCESS), , r, "[%s] Propagating.", GetErrorMessage(r));
 834                 }
 835
 836                 r = DrawText(*pCanvas, ampmBounds, __ampmString, DATETIME_ID_AMPM, __amPmTextSize);
 837                 SysTryCatch(NID_UI_CTRL, r == E_SUCCESS, , r, "[%s] Propagating.", GetErrorMessage(r));
 838         }
 839
 840 CATCH:
 841         delete pCanvas;
 842         return r;
 843 }
 844
 845 result
 846 _EditTimePresenter::DrawFocus(void)
 847 {
 848         FloatRectangle bounds(0.0f, 0.0f, 0.0f, 0.0f);
 849
 850         Canvas* pContentCanvas = null;
 851         Canvas* pCanvas = __pEditTime->GetCanvasN();
 852         SysTryReturnResult(NID_UI_CTRL, (pCanvas != null), GetLastResult(), "[%s] Propagating.", GetErrorMessage(GetLastResult()));
 853
 854         if (__focusId == DATETIME_ID_HOUR)
 855         {
 856                 bounds = GetDisplayAreaBoundsFromHoursStyle(DATETIME_ID_HOUR);
 857         }
 858         else if (__focusId == DATETIME_ID_MINUTE)
 859         {
 860                 bounds = GetDisplayAreaBoundsFromHoursStyle(DATETIME_ID_MINUTE);
 861         }
 862         else if (__focusId == DATETIME_ID_AMPM)
 863         {
 864                 bounds = GetDisplayAreaBoundsFromHoursStyle(DATETIME_ID_AMPM);
 865         }
 866         result r = E_SUCCESS;
 867
 868         if (_BitmapImpl::CheckNinePatchedBitmapStrictly(*__pContentBgHighlightedColorReplacementBitmap))
 869         {
 870                 r = pCanvas->DrawNinePatchedBitmap(bounds, *__pContentBgHighlightedColorReplacementBitmap);
 871                 SysTryCatch(NID_UI_CTRL, (r == E_SUCCESS), , r, "[%s] Propagating.", GetErrorMessage(r));
 872         }
 873         else
 874         {
 875                 pContentCanvas = __pEditTime->GetCanvasN(bounds);
 876                 SysTryCatch(NID_UI_CTRL, (pContentCanvas != null), , GetLastResult(), "[%s] Propagating.", GetErrorMessage(GetLastResult()));
 877
 878                 bounds.x = (bounds.width - __pContentBgHighlightedColorReplacementBitmap->GetWidthF()) / 2;
 879                 bounds.y = (bounds.height - __pContentBgHighlightedColorReplacementBitmap->GetHeightF()) / 2;
 880
 881                 r = pContentCanvas->DrawBitmap(FloatPoint(bounds.x, bounds.y), *__pContentBgHighlightedColorReplacementBitmap);
 882                 SysTryCatch(NID_UI_CTRL, (r == E_SUCCESS), , r, "[%s] Propagating.", GetErrorMessage(r));
 883                 delete pContentCanvas;
 884         }
 885
 886         delete pCanvas;
 887         return r;
 888
 889 CATCH:
 890         delete pCanvas;
 891         delete pContentCanvas;
 892         return r;
 893 }
 894
 895 result
 896 _EditTimePresenter::DrawColon(Canvas& canvas, const FloatRectangle& bounds)
 897 {
 898         result r = E_SUCCESS;
 899
 900         if (!__pEditTime->IsEnabled())
 901         {
 902                 r = DrawResourceBitmap(canvas, bounds, __pColonDisabledColorReplacementBitmap);
 903         }
 904         else
 905         {
 906                 r = DrawResourceBitmap(canvas, bounds, __pColonColorReplacementBitmap);
 907         }
 908
 909         return r;
 910 }
 911
 912 result
 913 _EditTimePresenter::DrawTitle(Canvas& canvas)
 914 {
 915         if (!__pEditTime->IsEnabled())
 916         {
 917                 Color titleDisabledColor;
 918                 GET_COLOR_CONFIG(EDITTIME::TITLE_TEXT_DISABLED, titleDisabledColor);
 919                 __titleObject.SetForegroundColor(titleDisabledColor, 0, __titleObject.GetTextLength());
 920         }
 921
 922         (_FontImpl::GetInstance(*__pFont))->SetSize(__titleFontSize);
 923         (_FontImpl::GetInstance(*__pFont))->SetStyle(FONT_STYLE_BOLD);
 924         __titleObject.SetFont(__pFont, 0, __titleObject.GetTextLength());
 925
 926         __titleObject.Draw(*_CanvasImpl::GetInstance(canvas));
 927
 928         return E_SUCCESS;
 929 }
 930
 931 result
 932 _EditTimePresenter::DrawContentBitmap(Canvas& canvas, const FloatRectangle& bounds, _DateTimeId boxId)
 933 {
 934         result r = E_SUCCESS;
 935
 936         bool isCustomBitmap = false;
 937         Bitmap* pReplacementBitmap = null;
 938         Bitmap* pEffectBitmap = null;
 939
 940         if (!__pEditTime->IsEnabled())
 941         {
 942                 isCustomBitmap = IS_CUSTOM_BITMAP(EDITTIME::CONTENT_BG_DISABLED);
 943                 pReplacementBitmap = __pContentBgDisabledColorReplacementBitmap;
 944                 pEffectBitmap = __pContentBgEffectDisabledBitmap;
 945         }
 946         else if (GetLastSelectedId() != boxId)
 947         {
 948                 isCustomBitmap = IS_CUSTOM_BITMAP(EDITTIME::CONTENT_BG_NORMAL);
 949                 pReplacementBitmap = __pContentBgNormalColorReplacementBitmap;
 950                 pEffectBitmap = __pContentBgEffectNormalBitmap;
 951         }
 952         else
 953         {
 954                 isCustomBitmap = IS_CUSTOM_BITMAP(EDITTIME::CONTENT_BG_PRESSED);
 955                 pReplacementBitmap = __pContentBgPressedColorReplacementBitmap;
 956                 pEffectBitmap = __pContentBgEffectPressedBitmap;
 957         }
 958
 959         r = DrawResourceBitmap(canvas, bounds, pReplacementBitmap, isCustomBitmap);
 960         SysTryReturn(NID_UI_CTRL, (r == E_SUCCESS), r, r, "[%s] Propagating.", GetErrorMessage(r));
 961
 962         if (!isCustomBitmap)
 963         {
 964                 r = DrawResourceBitmap(canvas, bounds, pEffectBitmap);
 965                 SysTryReturn(NID_UI_CTRL, (r == E_SUCCESS), r, r, "[%s] Propagating.", GetErrorMessage(r));
 966         }
 967
 968         return r;
 969 }
 970
 971 result
 972 _EditTimePresenter::DrawText(Canvas& canvas, const FloatRectangle& bounds, const String& text, _DateTimeId boxId, float textSize)
 973 {
 974         result r = E_SUCCESS;
 975
 976         Color textColor;
 977         (_FontImpl::GetInstance(*__pFont))->SetStyle(FONT_STYLE_PLAIN);
 978
 979         if (!__pEditTime->IsEnabled())
 980         {
 981                 if (boxId == DATETIME_ID_AMPM)
 982                 {
 983                         GET_COLOR_CONFIG(EDITTIME::BUTTON_TEXT_DISABLED, textColor);
 984                 }
 985                 else
 986                 {
 987                         GET_COLOR_CONFIG(EDITTIME::TEXT_DISABLED, textColor);
 988                 }
 989         }
 990         else
 991         {
 992                 GET_COLOR_CONFIG(EDITTIME::TEXT_NORMAL, textColor);
 993
 994                 if (boxId == DATETIME_ID_AMPM)
 995                 {
 996                         if (boxId == __selectedId)
 997                         {
 998                                 GET_COLOR_CONFIG(EDITTIME::BUTTON_TEXT_PRESSED, textColor);
 999                         }
1000                         else
1001                         {
1002                                 GET_COLOR_CONFIG(EDITTIME::BUTTON_TEXT_NORMAL, textColor);
1003                         }
1004                 }
1005
1006                 else if (boxId > -1 && boxId == GetLastSelectedId())
1007                 {
1008                         GET_COLOR_CONFIG(EDITTIME::TEXT_PRESSED, textColor);
1009                         (_FontImpl::GetInstance(*__pFont))->SetStyle(FONT_STYLE_BOLD);
1010                 }
1011         }
1012
1013         if (boxId != DATETIME_ID_AMPM)
1014         {
1015                 DrawContentBitmap(canvas, bounds, boxId);
1016         }
1017
1018         FloatRectangle drawAreaBounds(0.0f, 0.0f, 0.0f, 0.0f);
1019         drawAreaBounds = bounds;
1020
1021         TextSimple* pSimpleText = null;
1022         pSimpleText = new (std::nothrow)TextSimple((const_cast <wchar_t*>(text.GetPointer())), text.GetLength(), TEXT_ELEMENT_SOURCE_TYPE_EXTERNAL);
1023         SysTryReturn(NID_UI_CTRL, (pSimpleText != null), E_OUT_OF_MEMORY, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] Memory allocation failed.");
1024
1025         __textObject.RemoveAll();
1026
1027         (_FontImpl::GetInstance(*__pFont))->SetSize(__timeFontSize);
1028
1029         pSimpleText->SetTextShadowEnabled(true);
1030         pSimpleText->SetTextShadowOffset(FloatPoint(0.0f, -1.0f));
1031
1032         __textObject.AppendElement(*pSimpleText);
1033
1034         if (boxId == DATETIME_ID_AMPM)
1035         {
1036                 (_FontImpl::GetInstance(*__pFont))->SetSize(textSize);
1037         }
1038         if (__isFocused && __focusId == boxId)
1039         {
1040                 if (boxId == DATETIME_ID_AMPM)
1041                 {
1042                         GET_COLOR_CONFIG(EDITTIME::BUTTON_TEXT_HIGHLIGHTED, textColor);
1043                 }
1044                 else
1045                 {
1046                         GET_COLOR_CONFIG(EDITTIME::TEXT_HIGHLIGHTED, textColor);
1047                 }
1048
1049                 DrawFocus();
1050         }
1051
1052         __textObject.SetFont(__pFont, 0, __textObject.GetTextLength());
1053
1054         __textObject.SetForegroundColor(textColor, 0, __textObject.GetTextLength());
1055         __textObject.SetBounds(drawAreaBounds);
1056         __textObject.Draw(*_CanvasImpl::GetInstance(canvas));
1057
1058         return r;
1059 }
1060
1061 _DateTimeId
1062 _EditTimePresenter::GetBoxIdFromPosition(const FloatPoint& point) const
1063 {
1064         _DateTimeId displayBoxId = DATETIME_ID_NONE;
1065
1066         FloatRectangle ampmBounds(0.0f, 0.0f, 0.0f, 0.0f);
1067         FloatRectangle hoursBounds(0.0f, 0.0f, 0.0f, 0.0f);
1068         FloatRectangle minutesBounds(0.0f, 0.0f, 0.0f, 0.0f);
1069
1070         if (!__24hours)
1071         {
1072                 ampmBounds = GetDisplayAreaBoundsFromHoursStyle(DATETIME_ID_AMPM);
1073         }
1074
1075         hoursBounds = GetDisplayAreaBoundsFromHoursStyle(DATETIME_ID_HOUR);
1076         minutesBounds = GetDisplayAreaBoundsFromHoursStyle(DATETIME_ID_MINUTE);
1077
1078         if (point.y < hoursBounds.y || point.y > hoursBounds.y + hoursBounds.height)
1079         {
1080                 return displayBoxId;
1081         }
1082
1083         if (hoursBounds.Contains(point))
1084         {
1085                 displayBoxId = DATETIME_ID_HOUR;
1086         }
1087         else if (minutesBounds.Contains(point))
1088         {
1089                 displayBoxId = DATETIME_ID_MINUTE;
1090         }
1091         else if (ampmBounds.Contains(point))
1092         {
1093                 displayBoxId = DATETIME_ID_AMPM;
1094         }
1095
1096         return displayBoxId;
1097 }
1098
1099 void
1100 _EditTimePresenter::SetLastSelectedId(_DateTimeId boxId)
1101 {
1102         __lastSelectedId = boxId;
1103         return;
1104 }
1105
1106 _DateTimeId
1107 _EditTimePresenter::GetLastSelectedId(void) const
1108 {
1109         return __lastSelectedId;
1110 }
1111
1112 void
1113 _EditTimePresenter::SetFocusedElement()
1114 {
1115         if (__isEnterKeyPressed)
1116         {
1117                 __isEnterKeyPressed = false;
1118
1119                 if (__pEditTime->IsFocusModeStateEnabled())
1120                 {
1121                         __isFocused = true;
1122                 }
1123         }
1124         if (__focusId == DATETIME_ID_NONE || __focusId == DATETIME_ID_AMPM)
1125         {
1126                 __focusId = DATETIME_ID_HOUR;
1127         }
1128
1129         return;
1130 }
1131
1132 void
1133 _EditTimePresenter::SetFocusState(bool isFocused)
1134 {
1135         __isFocused = isFocused;
1136         return;
1137 }
1138
1139 bool
1140 _EditTimePresenter::OnFocusLost(const _Control &source)
1141 {
1142         if (!__isEnterKeyPressed || __focusId == DATETIME_ID_AMPM)
1143         {
1144                 __focusId = DATETIME_ID_NONE;
1145                 __selectedId = DATETIME_ID_NONE;
1146         }
1147         __isFocused = false;
1148         __pEditTime->Invalidate();
1149         return true;
1150 }
1151
1152 void
1153 _EditTimePresenter::OnFocusModeStateChanged(void)
1154 {
1155         __isFocused = false;
1156         __focusId = DATETIME_ID_NONE;
1157         __isEnterKeyPressed = false;
1158         __selectedId = DATETIME_ID_NONE;
1159         __pEditTime->Invalidate();
1160         return;
1161 }
1162
1163 bool
1164 _EditTimePresenter::OnKeyPressed(const _Control& source, const _KeyInfo& keyInfo)
1165 {
1166         if (!__isFocused)
1167         {
1168                 return false;
1169         }
1170         _KeyCode keyCode = keyInfo.GetKeyCode();
1171
1172         switch (keyCode)
1173         {
1174                 case _KEY_RIGHT:
1175                 {
1176                         __isEnterKeyPressed = false;
1177                         if (__focusId == DATETIME_ID_HOUR)
1178                         {
1179                                 __focusId = DATETIME_ID_MINUTE;
1180                         }
1181                         else if (__focusId == DATETIME_ID_MINUTE)
1182                         {
1183                                 if (!Is24HourNotationEnabled())
1184                                 {
1185                                         __focusId = DATETIME_ID_AMPM;
1186                                 }
1187                         }
1188                         else if (__focusId == DATETIME_ID_AMPM)
1189                         {
1190                                 return false;
1191                         }
1192
1193                         __pEditTime->Invalidate();
1194                         break;
1195                 }
1196                 case _KEY_LEFT:
1197                 {
1198                         __isEnterKeyPressed = false;
1199                         if (__focusId == DATETIME_ID_MINUTE)
1200                         {
1201                                 __focusId = DATETIME_ID_HOUR;
1202                         }
1203                         else if (__focusId == DATETIME_ID_AMPM)
1204                         {
1205                                 __focusId = DATETIME_ID_MINUTE;
1206                         }
1207                         else if (__focusId == DATETIME_ID_HOUR)
1208                         {
1209                                 return false;
1210                         }
1211                         __pEditTime->Invalidate();
1212                         break;
1213                 }
1214                 case _KEY_ENTER:
1215                 {
1216                         if (__focusId == DATETIME_ID_AMPM)
1217                         {
1218                                 __selectedId = DATETIME_ID_AMPM;
1219                                 __pEditTime->Invalidate();
1220                         }
1221                         else
1222                         {
1223                                 return false;
1224                         }
1225                         break;
1226                 }
1227
1228                 default:
1229                 {
1230                         return false;
1231                 }
1232         }
1233         return true;
1234 }
1235
1236 bool
1237 _EditTimePresenter::OnKeyReleased(const _Control& source, const _KeyCode& keyCode)
1238 {
1239         if (!__isFocused)
1240         {
1241                 return false;
1242         }
1243
1244         if (__isAnimating)
1245         {
1246                 VisualElement* pEditTimeElement = __pEditTime->GetVisualElement();
1247                 result r = GetLastResult();
1248                 SysTryReturn(NID_UI_CTRL, (pEditTimeElement != null), false, r, "[%s] Propagating.", GetErrorMessage(r));
1249                 pEditTimeElement->RemoveAllAnimations();
1250         }
1251
1252         int minValue = -1;
1253         int maxValue = -1;
1254         int displayValue = -1;
1255
1256         _DateTimeId boxId = DATETIME_ID_HOUR;
1257
1258         switch (keyCode)
1259         {
1260                 case _KEY_ENTER:
1261                 {
1262                         __isEnterKeyPressed = true;
1263                         if (__focusId == DATETIME_ID_HOUR)
1264                         {
1265                                 boxId = DATETIME_ID_HOUR;
1266                                 if (__pEditTime->GetDateTimeBar() != null)
1267                                 {
1268                                         if (!Is24HourNotationEnabled())
1269                                         {
1270                                                 if (GetHour() == 0)
1271                                                 {
1272                                                         minValue = DATETIME_HOUR_MIN + 1;
1273                                                         maxValue = DATETIME_HOUR_MAX_FOR_24NOTATION;
1274                                                         displayValue = DATETIME_HOUR_MAX_FOR_24NOTATION;
1275                                                 }
1276                                                 else if (GetHour() > DATETIME_HOUR_MAX_FOR_24NOTATION)
1277                                                 {
1278                                                         minValue = DATETIME_HOUR_MIN + 1;
1279                                                         maxValue = DATETIME_HOUR_MAX_FOR_24NOTATION;
1280                                                         displayValue = __pEditTime->GetHour() - DATETIME_HOUR_MAX_FOR_24NOTATION;
1281                                                 }
1282                                                 else
1283                                                 {
1284                                                         minValue = DATETIME_HOUR_MIN + 1;
1285                                                         maxValue = DATETIME_HOUR_MAX_FOR_24NOTATION;
1286                                                         displayValue = __pEditTime->GetHour();
1287                                                 }
1288                                         }
1289                                         else
1290                                         {
1291                                                 minValue = DATETIME_HOUR_MIN;
1292                                                 maxValue = DATETIME_HOUR_MAX;
1293                                                 displayValue = __pEditTime->GetHour();
1294                                         }
1295
1296                                         if (__pEditTime->GetDateTimeBar()->GetItemCount() > 0)
1297                                         {
1298                                                 __pEditTime->GetDateTimeBar()->RemoveAllItems();
1299                                         }
1300                                 }
1301                         }
1302                         else if (__focusId == DATETIME_ID_MINUTE)
1303                         {
1304                                 if (__pEditTime->GetDateTimeBar() != null)
1305                                 {
1306                                         minValue = DATETIME_MINUTE_MIN;
1307                                         maxValue = DATETIME_MINUTE_MAX;
1308                                         displayValue = __pEditTime->GetMinute();
1309
1310                                         if (__pEditTime->GetDateTimeBar()->GetItemCount() > 0)
1311                                         {
1312                                                 __pEditTime->GetDateTimeBar()->RemoveAllItems();
1313                                         }
1314                                 }
1315                                 boxId = DATETIME_ID_MINUTE;
1316                         }
1317                         else if (__focusId == DATETIME_ID_AMPM)
1318                         {
1319                                 SetAmEnabled(!GetAmEnabled());
1320                                 __pEditTime->FireTimeChangeEvent(TIME_INTERNAL_CHANGE_SAVED);
1321                                 boxId = DATETIME_ID_AMPM;
1322                                 __selectedId = DATETIME_ID_NONE;
1323
1324                                 __pEditTime->Invalidate();
1325                         }
1326
1327                         if ((__pEditTime->GetDateTimeBar() != null) && (boxId != DATETIME_ID_AMPM))
1328                         {
1329                                 FloatRectangle absoluteBounds = __pEditTime->GetAbsoluteBoundsF();
1330
1331                                 FloatRectangle bounds(0.0f, 0.0f, 0.0f, 0.0f);
1332                                 bounds = GetDisplayAreaBoundsFromHoursStyle(boxId);
1333                                 bounds.x += absoluteBounds.x;
1334
1335                                 __pEditTime->GetDateTimeBar()->SetInitialValue(minValue, maxValue, displayValue, boxId);
1336                                 __pEditTime->GetDateTimeBar()->CalculateArrowBounds(bounds);
1337                                 __pEditTime->GetDateTimeBar()->SetVisibleState(true);
1338                                 __pEditTime->GetDateTimeBar()->Open();
1339                                 UpdateLastSelectedValue(boxId, false);
1340                         }
1341                         break;
1342                 }
1343
1344                 default:
1345                 {
1346                         return false;
1347                 }
1348         }
1349         return true;
1350 }
1351
1352 bool
1353 _EditTimePresenter::OnTouchPressed(const _Control& source, const _TouchInfo& touchinfo)
1354 {
1355         SysTryReturn(NID_UI_CTRL, IsTimePickerEnabled() == true, true, E_SYSTEM, "[E_SYSTEM] A system error has occurred. EditTime instance is disabled.");
1356
1357         if (&source != __pEditTime)
1358         {
1359                 return false;
1360         }
1361
1362         __touchMoveHandled = false;
1363
1364         FloatRectangle hourBounds(0.0f, 0.0f, 0.0f, 0.0f);
1365         FloatRectangle minuteBounds(0.0f, 0.0f, 0.0f, 0.0f);
1366         FloatRectangle ampmBounds(0.0f, 0.0f, 0.0f, 0.0f);
1367
1368         hourBounds = GetDisplayAreaBoundsFromHoursStyle(DATETIME_ID_HOUR);
1369         minuteBounds = GetDisplayAreaBoundsFromHoursStyle(DATETIME_ID_MINUTE);
1370
1371         if (!__24hours)
1372         {
1373                 ampmBounds = GetDisplayAreaBoundsFromHoursStyle(DATETIME_ID_AMPM);
1374         }
1375
1376         FloatPoint point = touchinfo.GetCurrentPosition();
1377
1378         _DateTimeId boxId = GetBoxIdFromPosition(point);
1379
1380         int minValue = -1;
1381         int maxValue = -1;
1382         int displayValue = -1;
1383
1384         if (boxId == DATETIME_ID_HOUR)
1385         {
1386                 if (__pEditTime->GetDateTimeBar() != null)
1387                 {
1388                         if (!__24hours)
1389                         {
1390                                 if (GetHour() == 0)
1391                                 {
1392                                         minValue = DATETIME_HOUR_MIN + 1;
1393                                         maxValue = DATETIME_HOUR_MAX_FOR_24NOTATION;
1394                                         displayValue = DATETIME_HOUR_MAX_FOR_24NOTATION;
1395                                 }
1396                                 else if (GetHour() > DATETIME_HOUR_MAX_FOR_24NOTATION)
1397                                 {
1398                                         minValue = DATETIME_HOUR_MIN + 1;
1399                                         maxValue = DATETIME_HOUR_MAX_FOR_24NOTATION;
1400                                         displayValue = GetHour() - DATETIME_HOUR_MAX_FOR_24NOTATION;
1401                                 }
1402                                 else
1403                                 {
1404                                         minValue = DATETIME_HOUR_MIN + 1;
1405                                         maxValue = DATETIME_HOUR_MAX_FOR_24NOTATION;
1406                                         displayValue = GetHour();
1407                                 }
1408                         }
1409                         else
1410                         {
1411                                 minValue = DATETIME_HOUR_MIN;
1412                                 maxValue = DATETIME_HOUR_MAX;
1413                                 displayValue = GetHour();
1414                         }
1415
1416                         if (__pEditTime->GetDateTimeBar()->GetItemCount() > 0)
1417                         {
1418                                 __pEditTime->GetDateTimeBar()->RemoveAllItems();
1419                         }
1420
1421                         __pEditTime->GetDateTimeBar()->SetInitialValue(minValue, maxValue, displayValue, boxId);
1422                 }
1423
1424                 __bounds = hourBounds;
1425         }
1426         else if (boxId == DATETIME_ID_MINUTE)
1427         {
1428                 if (__pEditTime->GetDateTimeBar() != null)
1429                 {
1430                         minValue = DATETIME_MINUTE_MIN;
1431                         maxValue = DATETIME_MINUTE_MAX;
1432                         displayValue = GetMinute();
1433
1434                         if (__pEditTime->GetDateTimeBar()->GetItemCount() > 0)
1435                         {
1436                                 __pEditTime->GetDateTimeBar()->RemoveAllItems();
1437                         }
1438
1439                         __pEditTime->GetDateTimeBar()->SetInitialValue(minValue, maxValue, displayValue, boxId);
1440                 }
1441
1442                 __bounds = minuteBounds;
1443         }
1444         else if (boxId == DATETIME_ID_AMPM)
1445         {
1446                 __selectedId = boxId;
1447                 __bounds = ampmBounds;
1448                 Draw();
1449         }
1450         else
1451         {
1452                 __selectedId = DATETIME_ID_NONE;
1453                 return false;
1454         }
1455
1456         __selectedId = boxId;
1457
1458         return true;
1459 }
1460
1461 bool
1462 _EditTimePresenter::OnTouchReleased(const _Control& source, const _TouchInfo& touchinfo)
1463 {
1464         SysTryReturn(NID_UI_CTRL, IsTimePickerEnabled() == true, true, E_SYSTEM, "[E_SYSTEM] A system error has occurred. EditTime instance is disabled.");
1465
1466         if (&source != __pEditTime)
1467         {
1468                 return false;
1469         }
1470
1471         FloatRectangle bounds = __pEditTime->GetBoundsF();
1472
1473         FloatPoint startPoint(0.0f, 0.0f);
1474
1475         float titleHeight = 0;
1476         GET_SHAPE_CONFIG(EDITTIME::TITLE_HEIGHT, __pEditTime->GetOrientation(), titleHeight);
1477
1478         __bounds = FloatRectangle(0.0f, titleHeight, bounds.width, bounds.height);
1479
1480         FloatPoint point = touchinfo.GetCurrentPosition();
1481
1482         _DateTimeId boxId = GetBoxIdFromPosition(point);
1483
1484         if ((boxId == GetLastSelectedId() && boxId != DATETIME_ID_AMPM) || boxId != __selectedId || boxId == DATETIME_ID_NONE)
1485         {
1486                 if (__pEditTime->GetDateTimeBar() != null && __pEditTime->GetDateTimeBar()->IsActivated())
1487                 {
1488                         __pEditTime->GetDateTimeBar()->CloseDateTimeBar();
1489                 }
1490
1491                 __selectedId = DATETIME_ID_NONE;
1492                 SetLastSelectedId(__selectedId);
1493
1494                 Draw();
1495
1496                 return true;
1497         }
1498         UpdateLastSelectedValue(__selectedId, true);
1499         if (GetLastSelectedId() == DATETIME_ID_AMPM)
1500         {
1501                 return true;
1502         }
1503
1504         Draw();
1505
1506         if ((__pEditTime->GetDateTimeBar() != null) && (boxId != DATETIME_ID_AMPM) && (GetLastSelectedId() != DATETIME_ID_NONE))
1507         {
1508                 __pEditTime->SetFocused(true);
1509
1510                 FloatRectangle bounds(0.0f, 0.0f, 0.0f, 0.0f);
1511                 bounds = GetDisplayAreaBoundsFromHoursStyle(GetLastSelectedId());
1512                 FloatRectangle absoluteBounds(0.0f, 0.0f, 0.0f, 0.0f);
1513                 absoluteBounds = __pEditTime->GetAbsoluteBoundsF();
1514                 bounds.x += absoluteBounds.x;
1515
1516                 __pEditTime->GetDateTimeBar()->CalculateArrowBounds(bounds);
1517
1518                 if (__pEditTime->GetDateTimeBar()->IsActivated())
1519                 {
1520                         __pEditTime->GetDateTimeBar()->RemoveAllAnimations();
1521                         __pEditTime->GetDateTimeBar()->Close();
1522                         __pEditTime->GetDateTimeBar()->SetVisibleState(true);
1523                         __pEditTime->GetDateTimeBar()->Open();
1524                 }
1525                 else
1526                 {
1527                         __pEditTime->GetDateTimeBar()->SetVisibleState(true);
1528                         __pEditTime->GetDateTimeBar()->Open();
1529                 }
1530         }
1531
1532         __selectedId = DATETIME_ID_NONE;
1533         return true;
1534 }
1535
1536 void
1537 _EditTimePresenter::UpdateLastSelectedValue(_DateTimeId boxId, bool isTouchPressed)
1538 {
1539         __selectedId = boxId;
1540         SetLastSelectedId(boxId);
1541
1542         __lastSelectedValue = "";
1543
1544         if (GetLastSelectedId() == DATETIME_ID_HOUR)
1545         {
1546                 int hours = GetHour();
1547
1548                 if (!Is24HourNotationEnabled())
1549                 {
1550                         hours = hours % 12;
1551
1552                         if (hours == DATETIME_HOUR_MIN)
1553                         {
1554                                 hours = hours + DATETIME_HOUR_MAX_FOR_24NOTATION;
1555                         }
1556                 }
1557                 __lastSelectedValue.Format(10, L"%02d", hours);
1558                 if (isTouchPressed)
1559                 {
1560                         PLAY_FEEDBACK(_RESOURCE_FEEDBACK_PATTERN_TAP, __pEditTime);
1561                 }
1562         }
1563         else if (GetLastSelectedId() == DATETIME_ID_MINUTE)
1564         {
1565                 __lastSelectedValue.Format(10, L"%02d", GetMinute());
1566                 if (isTouchPressed)
1567                 {
1568                         PLAY_FEEDBACK(_RESOURCE_FEEDBACK_PATTERN_TAP, __pEditTime);
1569                 }
1570         }
1571         else if (GetLastSelectedId() == DATETIME_ID_AMPM)
1572         {
1573                 SetAmEnabled(!GetAmEnabled());
1574                 __pEditTime->FireTimeChangeEvent(TIME_INTERNAL_CHANGE_SAVED);
1575                 if (isTouchPressed)
1576                 {
1577                         __pEditTime->UpdateAccessibilityElement();
1578                         PLAY_FEEDBACK(_RESOURCE_FEEDBACK_PATTERN_TAP, __pEditTime);
1579                 }
1580                 __selectedId = DATETIME_ID_NONE;
1581
1582                 if (__pEditTime->GetDateTimeBar() != null && __pEditTime->GetDateTimeBar()->IsActivated())
1583                 {
1584                         __pEditTime->GetDateTimeBar()->SetVisibleState(false);
1585                         __pEditTime->GetDateTimeBar()->Close();
1586                 }
1587         }
1588
1589         __selectedId = DATETIME_ID_NONE;
1590         __pEditTime->Invalidate();
1591         return;
1592 }
1593
1594 bool
1595 _EditTimePresenter::OnTouchCanceled(const _Control& source, const _TouchInfo& touchinfo)
1596 {
1597         if (&source != __pEditTime)
1598         {
1599                 return false;
1600         }
1601
1602         __selectedId = DATETIME_ID_NONE;
1603
1604         return true;
1605 }
1606
1607 bool
1608 _EditTimePresenter::OnTouchMoved(const _Control& source, const _TouchInfo& touchinfo)
1609 {
1610         if (&source != __pEditTime)
1611         {
1612                 return false;
1613         }
1614
1615         if (__pEditTime->GetDateTimeBar() != null && __pEditTime->GetDateTimeBar()->IsActivated())
1616         {
1617                 return true;
1618         }
1619
1620         return false;
1621 }
1622
1623 void
1624 _EditTimePresenter::OnTouchMoveHandled(const _Control& control)
1625 {
1626         __touchMoveHandled = true;
1627         __selectedId = DATETIME_ID_NONE;
1628
1629         return;
1630 }
1631
1632 void
1633 _EditTimePresenter::OnFontChanged(Font* pFont)
1634 {
1635         __pFont = pFont;
1636
1637         if (__pEditTime->GetDateTimeBar() != null)
1638         {
1639                 __pEditTime->GetDateTimeBar()->SetFont(*pFont);
1640         }
1641
1642         return;
1643 }
1644
1645 void
1646 _EditTimePresenter::OnFontInfoRequested(unsigned long& style, float& size)
1647 {
1648         style = FONT_STYLE_PLAIN;
1649         size = __timeFontSize;
1650
1651         return;
1652 }
1653
1654 result
1655 _EditTimePresenter::Initialize(void)
1656 {
1657         result r = E_SUCCESS;
1658
1659         float titleTimeMargin = 0;
1660         float timeHeight = 0;
1661         float editTimeHeight = 0;
1662
1663         GET_SHAPE_CONFIG(EDITTIME::TEXT_FONT_SIZE, __pEditTime->GetOrientation(), __titleFontSize);
1664         GET_SHAPE_CONFIG(EDITTIME::TIME_FONT_SIZE, __pEditTime->GetOrientation(), __timeFontSize);
1665         GET_SHAPE_CONFIG(EDITTIME::TITLE_TIME_MARGIN, __pEditTime->GetOrientation(), titleTimeMargin);
1666         GET_SHAPE_CONFIG(EDITTIME::TIME_HEIGHT, __pEditTime->GetOrientation(), timeHeight);
1667         GET_SHAPE_CONFIG(EDITTIME::HEIGHT, __pEditTime->GetOrientation(), editTimeHeight);
1668
1669         if (__pEditTime->GetBoundsF().height > editTimeHeight)
1670         {
1671                 editTimeHeight = __pEditTime->GetBoundsF().height;
1672         }
1673
1674         if (!__title.IsEmpty())
1675         {
1676                 SetTitleBounds();
1677                 if (!__isEditTimeInitialized)
1678                 {
1679                         r = InitializeTitleObject();
1680                         SysTryReturn(NID_UI_CTRL, (r == E_SUCCESS), r, r, "[%s] Propagating.", GetErrorMessage(r));
1681                 }
1682
1683                 __titleBounds.y = (editTimeHeight - (__titleBounds.height + titleTimeMargin + timeHeight)) / 2.0f;
1684                 __titleObject.SetBounds(__titleBounds);
1685         }
1686
1687         __pFont = __pEditTime->GetFallbackFont();
1688         r = GetLastResult();
1689         SysTryReturn(NID_UI_CTRL, __pFont != null, r, r, "[%s] Propagating.", GetErrorMessage(r));
1690
1691         if (!__isEditTimeInitialized)
1692         {
1693                 r = LoadResource();
1694                 SysTryReturn(NID_UI_CTRL, r == E_SUCCESS, r, r, "[%s] Propagating.", GetErrorMessage(r));
1695
1696                 r = InitializeTextObject();
1697                 SysTryReturn(NID_UI_CTRL, (r == E_SUCCESS), r, r, "[%s] Propagating.", GetErrorMessage(r));
1698         }
1699
1700         __isEditTimeInitialized = true;
1701
1702         UpdateTimeFormat();
1703         return r;
1704 }
1705
1706 void
1707 _EditTimePresenter::UpdateTimeFormat(void)
1708 {
1709         if (!__is24hoursSet)
1710         {
1711                 String key(L"http://tizen.org/setting/locale.time.format.24hour");
1712                 SettingInfo::GetValue(key , __24hours);
1713         }
1714
1715         return;
1716 }
1717
1718 void
1719 _EditTimePresenter::Animate(void)
1720 {
1721         SysTryReturnVoidResult(NID_UI_CTRL, !__isAnimating, E_SUCCESS, "Rolling animation is in progress.");
1722         SysAssertf((__pFont != null), "Font instance must not be null.");
1723
1724         (_FontImpl::GetInstance(*__pFont))->SetSize(__timeFontSize);
1725
1726         result r = E_SUCCESS;
1727         FloatRectangle rect;
1728         String hourString;
1729         String minuteString;
1730         String newValue;
1731         TextSimple* pOldSimpleText = null;
1732         TextSimple* pNewSimpleText = null;
1733         bool isCustomBitmap = false;
1734
1735         _DateTimeUtils dateTimeUtils;
1736         int hours = GetHour();
1737         if (!Is24HourNotationEnabled())
1738         {
1739                 hours = hours % 12;
1740
1741                 if (hours == DATETIME_HOUR_MIN)
1742                 {
1743                         hours = hours + DATETIME_HOUR_MAX_FOR_24NOTATION;
1744                 }
1745         }
1746         hourString.Format(10, L"%02d", hours);
1747         minuteString.Format(10, L"%02d", GetMinute());
1748
1749         if (GetLastSelectedId() == DATETIME_ID_HOUR)
1750         {
1751                 SysTryReturnVoidResult(NID_UI_CTRL, (__lastSelectedValue.Equals(hourString) == false), E_SUCCESS, "[E_SUCCESS] Hour string matched.");
1752
1753                 newValue = hourString;
1754                 rect = GetDisplayAreaBoundsFromHoursStyle(DATETIME_ID_HOUR);
1755         }
1756         else if (GetLastSelectedId() == DATETIME_ID_MINUTE)
1757         {
1758                 SysTryReturnVoidResult(NID_UI_CTRL, (__lastSelectedValue.Equals(minuteString) == false), E_SUCCESS, "[E_SUCCESS] Minute string matched.");
1759
1760                 newValue = minuteString;
1761                 rect = GetDisplayAreaBoundsFromHoursStyle(DATETIME_ID_MINUTE);
1762         }
1763
1764         FloatDimension newTextDim;
1765         FloatDimension oldTextDim;
1766         FloatPoint textPoint;
1767         VisualElement* pNewVisualElement = null;
1768         VisualElement* pOldVisualElement = null;
1769         VisualElement* pEditTimeElement = null;
1770         VisualElementPropertyAnimation* pNewBoundsAnimation = null;
1771         VisualElementPropertyAnimation* pOldBoundsAnimation = null;
1772         Canvas* pCanvas = null;
1773         Canvas* pContentCanvas = null;
1774         Color contentBgColor;
1775         Color textNormalColor;
1776         Color textPressedColor;
1777         float contentTextMargin;
1778
1779         GET_COLOR_CONFIG(EDITTIME::CONTENT_BG_PRESSED, contentBgColor);
1780         GET_COLOR_CONFIG(EDITTIME::TEXT_PRESSED, textPressedColor);
1781         GET_SHAPE_CONFIG(EDITDATE::CONTENT_TEXT_MARGIN, __pEditTime->GetOrientation(), contentTextMargin);
1782
1783         __pFont->GetTextExtent(newValue, newValue.GetLength(), newTextDim);
1784         __pFont->GetTextExtent(__lastSelectedValue, __lastSelectedValue.GetLength(), oldTextDim);
1785
1786         if (newTextDim.width > oldTextDim.width)
1787         {
1788                 textPoint.x = (rect.width - newTextDim.width) / 2.0f;
1789         }
1790         else
1791         {
1792                 textPoint.x = (rect.width - oldTextDim.width) / 2.0f;
1793         }
1794
1795         SysTryReturnVoidResult(NID_UI_CTRL, (rect.x + textPoint.x < __pEditTime->GetBounds().width), E_SUCCESS, "Rolling animation cann't be played.");
1796
1797         __isAnimating = true;
1798
1799         __pContentProvider = new (std::nothrow) VisualElement();
1800         SysTryReturnVoidResult(NID_UI_CTRL, (__pContentProvider != null), E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] Memory allocation failed.");
1801
1802         r = __pContentProvider->Construct();
1803         SysTryCatch(NID_UI_CTRL, (r == E_SUCCESS), , r, "[%s] Propagating.", GetErrorMessage(r));
1804
1805         __pContentProvider->SetShowState(true);
1806         __pContentProvider->SetClipChildrenEnabled(true);
1807         __pContentProvider->SetImplicitAnimationEnabled(false);
1808
1809         pEditTimeElement = __pEditTime->GetVisualElement();
1810         r = GetLastResult();
1811         SysTryCatch(NID_UI_CTRL, (pEditTimeElement != null), , r, "[%s] Propagating.", GetErrorMessage(r));
1812
1813         pNewVisualElement = new (std::nothrow) VisualElement();
1814         SysTryCatch(NID_UI_CTRL, (pNewVisualElement != null), , E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] Memory allocation failed.");
1815
1816         r = pNewVisualElement->Construct();
1817         if (r != E_SUCCESS)
1818         {
1819                 pNewVisualElement->Destroy();
1820                 pNewVisualElement = null;
1821         }
1822         SysTryCatch(NID_UI_CTRL, (r == E_SUCCESS), , r, "[%s] Propagating.", GetErrorMessage(r));
1823
1824         pNewVisualElement->SetShowState(true);
1825
1826         pOldVisualElement = new (std::nothrow) VisualElement();
1827         if (pOldVisualElement == null)
1828         {
1829                 pNewVisualElement->Destroy();
1830                 pNewVisualElement = null;
1831         }
1832         SysTryCatch(NID_UI_CTRL, (pOldVisualElement != null), , E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] Memory allocation failed.");
1833
1834         r = pOldVisualElement->Construct();
1835         if (r != E_SUCCESS)
1836         {
1837                 pNewVisualElement->Destroy();
1838                 pOldVisualElement->Destroy();
1839                 pNewVisualElement = null;
1840                 pOldVisualElement = null;
1841         }
1842         SysTryCatch(NID_UI_CTRL, (r == E_SUCCESS), , r, "[%s] Propagating.", GetErrorMessage(r));
1843
1844         pOldVisualElement->SetShowState(true);
1845
1846         __pContentProvider->SetBounds(FloatRectangle((rect.x + contentTextMargin), (rect.y + (contentTextMargin * 2.0f)), (rect.width - (contentTextMargin * 2.0f)), (rect.height - (contentTextMargin * 4.0f))));
1847
1848         pNewVisualElement->SetBounds(FloatRectangle(0, 0, __pContentProvider->GetBounds().width, __pContentProvider->GetBounds().height));
1849         pOldVisualElement->SetBounds(FloatRectangle(0, 0, __pContentProvider->GetBounds().width, __pContentProvider->GetBounds().height));
1850
1851         pContentCanvas = pEditTimeElement->GetCanvasN(__pContentProvider->GetBounds());
1852         r = GetLastResult();
1853         SysTryCatch(NID_UI_CTRL, (pContentCanvas != null), , r, "[%s] Propagating.", GetErrorMessage(r));
1854         pContentCanvas->SetBackgroundColor(Color(0, 0, 0, 0));
1855         pContentCanvas->Clear();
1856
1857         pCanvas = pEditTimeElement->GetCanvasN(rect);
1858         r = GetLastResult();
1859         SysTryCatch(NID_UI_CTRL, (pCanvas != null), , r, "[%s] Propagating.", GetErrorMessage(r));
1860         pCanvas->SetBackgroundColor(Color(0, 0, 0, 0));
1861         pCanvas->Clear();
1862         rect.x = 0.0f;
1863         rect.y = 0.0f;
1864         isCustomBitmap = IS_CUSTOM_BITMAP(EDITTIME::CONTENT_BG_PRESSED);
1865         r = DrawResourceBitmap(*pCanvas, rect, __pContentBgPressedColorReplacementBitmap, isCustomBitmap);
1866
1867         if (!isCustomBitmap)
1868         {
1869                 result res = DrawResourceBitmap(*pCanvas, rect, __pContentBgEffectPressedBitmap);
1870
1871                 if (res != E_SUCCESS)
1872                 {
1873                         SysLog(NID_UI_CTRL, "[%s] Propagating.", GetErrorMessage(res));
1874                 }
1875         }
1876
1877         delete pCanvas;
1878         pCanvas = null;
1879
1880         if (r != E_SUCCESS)
1881         {
1882                 pContentCanvas->SetBackgroundColor(contentBgColor);
1883                 pContentCanvas->Clear();
1884         }
1885
1886         delete pContentCanvas;
1887         pContentCanvas = null;
1888
1889         pEditTimeElement->AttachChild(*__pContentProvider);
1890
1891         __pContentProvider->AttachChild(*pOldVisualElement);
1892         __pContentProvider->AttachChild(*pNewVisualElement);
1893
1894         pNewBoundsAnimation = new (std::nothrow) VisualElementPropertyAnimation();
1895         SysTryCatch(NID_UI_CTRL, (pNewBoundsAnimation != null), , E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] Memory allocation failed.");
1896
1897         pNewBoundsAnimation->SetDuration(300);
1898         pNewBoundsAnimation->SetPropertyName("bounds.position");
1899         pNewBoundsAnimation->SetStartValue(Variant(FloatPoint(pNewVisualElement->GetBounds().x, oldTextDim.height)));
1900         pNewBoundsAnimation->SetEndValue(Variant(FloatPoint(pNewVisualElement->GetBounds().x, 0.0f)));
1901
1902         pOldBoundsAnimation = new (std::nothrow) VisualElementPropertyAnimation();
1903         SysTryCatch(NID_UI_CTRL, (pOldBoundsAnimation != null), , E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] Memory allocation failed.");
1904
1905         pOldBoundsAnimation->SetDuration(300);
1906         pOldBoundsAnimation->SetPropertyName("bounds.position");
1907         pOldBoundsAnimation->SetStartValue(Variant(FloatPoint(pOldVisualElement->GetBounds().x, 0.0f)));
1908         pOldBoundsAnimation->SetEndValue(Variant(FloatPoint(pOldVisualElement->GetBounds().x, oldTextDim.height * -1.0f)));
1909
1910         pOldSimpleText = new (std::nothrow)TextSimple((const_cast <wchar_t*>(__lastSelectedValue.GetPointer())), __lastSelectedValue.GetLength(), TEXT_ELEMENT_SOURCE_TYPE_EXTERNAL);
1911         SysTryCatch(NID_UI_CTRL, (pOldSimpleText != null), , E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] Memory allocation failed.");
1912
1913         pOldSimpleText->SetTextShadowEnabled(true);
1914         pOldSimpleText->SetTextShadowOffset(FloatPoint(0.0f, -1.0f));
1915
1916         pCanvas = pOldVisualElement->GetCanvasN();
1917         r = GetLastResult();
1918         SysTryCatch(NID_UI_CTRL, (pCanvas != null), , r, "[%s] Propagating.", GetErrorMessage(r));
1919
1920         pCanvas->SetBackgroundColor(Color(0, 0, 0, 0));
1921         pCanvas->Clear();
1922         pCanvas->SetForegroundColor(textPressedColor);
1923
1924         (_FontImpl::GetInstance(*__pFont))->SetSize(__timeFontSize);
1925         (_FontImpl::GetInstance(*__pFont))->SetStyle(FONT_STYLE_PLAIN);
1926         __textObject.RemoveAll();
1927         __textObject.AppendElement(*pOldSimpleText);
1928
1929         __textObject.SetFont(__pFont, 0, __textObject.GetTextLength());
1930         __textObject.SetForegroundColor(textPressedColor, 0, __textObject.GetTextLength());
1931         __textObject.SetBounds(FloatRectangle(0, 0, pCanvas->GetBounds().width, pCanvas->GetBounds().height));
1932         __textObject.Draw(*_CanvasImpl::GetInstance(*pCanvas));
1933
1934         delete pCanvas;
1935         pCanvas = null;
1936
1937         pNewSimpleText = new (std::nothrow)TextSimple((const_cast <wchar_t*>(newValue.GetPointer())), newValue.GetLength(), TEXT_ELEMENT_SOURCE_TYPE_EXTERNAL);
1938         SysTryCatch(NID_UI_CTRL, (pNewSimpleText != null), , E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] Memory allocation failed.");
1939
1940         pNewSimpleText->SetTextShadowEnabled(true);
1941         pNewSimpleText->SetTextShadowOffset(FloatPoint(0.0f, -1.0f));
1942
1943         pCanvas = pNewVisualElement->GetCanvasN();
1944         r = GetLastResult();
1945         SysTryCatch(NID_UI_CTRL, (pCanvas != null), , r, "[%s] Propagating.", GetErrorMessage(r));
1946
1947         pCanvas->SetBackgroundColor(Color(0, 0, 0, 0));
1948         pCanvas->Clear();
1949         pCanvas->SetForegroundColor(textPressedColor);
1950
1951         (_FontImpl::GetInstance(*__pFont))->SetSize(__timeFontSize);
1952         (_FontImpl::GetInstance(*__pFont))->SetStyle(FONT_STYLE_PLAIN);
1953         __textObject.RemoveAll();
1954         __textObject.AppendElement(*pNewSimpleText);
1955
1956         __textObject.SetFont(__pFont, 0, __textObject.GetTextLength());
1957         __textObject.SetForegroundColor(textPressedColor, 0, __textObject.GetTextLength());
1958         __textObject.SetBounds(FloatRectangle(0, 0, pCanvas->GetBounds().width, pCanvas->GetBounds().height));
1959         __textObject.Draw(*_CanvasImpl::GetInstance(*pCanvas));
1960
1961         delete pCanvas;
1962         pCanvas = null;
1963
1964         pOldVisualElement->SetImplicitAnimationEnabled(false);
1965         pNewVisualElement->SetImplicitAnimationEnabled(false);
1966
1967         AnimationTransaction::Begin(__transactionId);
1968         pOldVisualElement->AddAnimation(*pOldBoundsAnimation);
1969         pNewVisualElement->AddAnimation(*pNewBoundsAnimation);
1970         AnimationTransaction::SetCurrentTransactionEventListener(__pEditTime);
1971         AnimationTransaction::Commit();
1972
1973         delete pOldBoundsAnimation;
1974         delete pNewBoundsAnimation;
1975
1976         return;
1977
1978 CATCH:
1979         __isAnimating = false;
1980         __pContentProvider->Destroy();
1981         __pContentProvider = null;
1982
1983         delete pNewBoundsAnimation;
1984         pNewBoundsAnimation = null;
1985
1986         delete pOldBoundsAnimation;
1987         pOldBoundsAnimation = null;
1988
1989         delete pOldSimpleText;
1990         pOldSimpleText = null;
1991
1992         delete pNewSimpleText;
1993         pNewSimpleText = null;
1994
1995         delete pContentCanvas;
1996         pContentCanvas = null;
1997
1998         return;
1999 }
2000
2001 void
2002 _EditTimePresenter::EndTransaction(void)
2003 {
2004         result r = E_SUCCESS;
2005
2006         __isAnimating = false;
2007         VisualElement* pEditTimeElement = __pEditTime->GetVisualElement();
2008         r = GetLastResult();
2009         SysTryReturnVoidResult(NID_UI_CTRL, (pEditTimeElement != null), r, "[%s] Propagating.", GetErrorMessage(r));
2010
2011         if (__pContentProvider != null)
2012         {
2013                 pEditTimeElement->DetachChild(*__pContentProvider);
2014                 __pContentProvider->Destroy();
2015                 __pContentProvider = null;
2016
2017         }
2018
2019         Draw();
2020         __transactionId = 0;
2021         return;
2022 }
2023 }}} // Tizen::Ui::Controls