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