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         , __focusId(DATETIME_ID_NONE)
  62         , __touchMoveHandled(false)
  63         , __pAmPmBgNormalColorReplacementBitmap(null)
  64         , __pAmPmBgDisabledColorReplacementBitmap(null)
  65         , __pAmPmBgPressedColorReplacementBitmap(null)
  66         , __pAmPmBgHighlightedColorReplacementBitmap(null)
  67         , __pAmPmBgEffectNomralBitmap(null)
  68         , __pAmPmBgEffectPressedBitmap(null)
  69         , __pAmPmBgEffectDisabledBitmap(null)
  70         , __pColonColorReplacementBitmap(null)
  71         , __pColonDisabledColorReplacementBitmap(null)
  72         , __pContentBgNormalColorReplacementBitmap(null)
  73         , __pContentBgDisabledColorReplacementBitmap(null)
  74         , __pContentBgPressedColorReplacementBitmap(null)
  75         , __pContentBgHighlightedColorReplacementBitmap(null)
  76         , __pContentBgEffectNormalBitmap(null)
  77         , __pContentBgEffectPressedBitmap(null)
  78         , __pContentBgEffectDisabledBitmap(null)
  79         , __pContentProvider(null)
  80         , __textObject()
  81         , __pFont(null)
  82         , __titleObject()
  83         , __amPmTextSize(0.0f)
  84         , __titleFontSize(0.0f)
  85         , __timeFontSize(0.0f)
  86         , __isAnimating(false)
  87         , __isEditTimeInitialized(false)
  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 > editTimeHeight)
 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 CATCH:
 865         delete pCanvas;
 866         return r;
 867 }
 868
 869 result
 870 _EditTimePresenter::DrawFocus(void)
 871 {
 872         FloatRectangle bounds(0.0f, 0.0f, 0.0f, 0.0f);
 873
 874         Canvas* pCanvas = __pEditTime->GetCanvasN();
 875         SysTryReturnResult(NID_UI_CTRL, (pCanvas != null), E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] Unable to create canvas.");
 876
 877         if (__focusId == DATETIME_ID_HOUR)
 878         {
 879                 bounds = GetDisplayAreaBoundsFromHoursStyle(DATETIME_ID_HOUR);
 880         }
 881         else if (__focusId == DATETIME_ID_MINUTE)
 882         {
 883                 bounds = GetDisplayAreaBoundsFromHoursStyle(DATETIME_ID_MINUTE);
 884         }
 885         else if (__focusId == DATETIME_ID_AMPM)
 886         {
 887                 bounds = GetDisplayAreaBoundsFromHoursStyle(DATETIME_ID_AMPM);
 888         }
 889         result r = E_SUCCESS;
 890
 891         if (_BitmapImpl::CheckNinePatchedBitmapStrictly(*__pContentBgHighlightedColorReplacementBitmap))
 892         {
 893                 r = pCanvas->DrawNinePatchedBitmap(bounds, *__pContentBgHighlightedColorReplacementBitmap);
 894                 SysTryCatch(NID_UI_CTRL, (r == E_SUCCESS), , r, "[%s] Propagating.", GetErrorMessage(r));
 895         }
 896         else
 897         {
 898                 r = pCanvas->DrawBitmap(bounds, *__pContentBgHighlightedColorReplacementBitmap);
 899                 SysTryCatch(NID_UI_CTRL, (r == E_SUCCESS), , r, "[%s] Propagating.", GetErrorMessage(r));
 900         }
 901
 902         delete pCanvas;
 903         return r;
 904
 905 CATCH:
 906         delete pCanvas;
 907         return r;
 908 }
 909
 910 result
 911 _EditTimePresenter::DrawColon(Canvas& canvas, const FloatRectangle& bounds)
 912 {
 913         result r = E_SUCCESS;
 914
 915         if (!__pEditTime->IsEnabled())
 916         {
 917                 r = DrawResourceBitmap(canvas, bounds, __pColonDisabledColorReplacementBitmap);
 918         }
 919         else
 920         {
 921                 r = DrawResourceBitmap(canvas, bounds, __pColonColorReplacementBitmap);
 922         }
 923
 924         return r;
 925 }
 926
 927 result
 928 _EditTimePresenter::DrawTitle(Canvas& canvas)
 929 {
 930         if (!__pEditTime->IsEnabled())
 931         {
 932                 Color titleDisabledColor;
 933                 GET_COLOR_CONFIG(EDITTIME::TITLE_TEXT_DISABLED, titleDisabledColor);
 934                 __titleObject.SetForegroundColor(titleDisabledColor, 0, __titleObject.GetTextLength());
 935         }
 936
 937         (_FontImpl::GetInstance(*__pFont))->SetSize(__titleFontSize);
 938         (_FontImpl::GetInstance(*__pFont))->SetStyle(FONT_STYLE_BOLD);
 939         __titleObject.SetFont(__pFont, 0, __titleObject.GetTextLength());
 940
 941         __titleObject.Draw(*_CanvasImpl::GetInstance(canvas));
 942
 943         return E_SUCCESS;
 944 }
 945
 946 result
 947 _EditTimePresenter::DrawContentBitmap(Canvas& canvas, const FloatRectangle& bounds, _DateTimeId boxId)
 948 {
 949         result r = E_SUCCESS;
 950
 951         bool isCustomBitmap = false;
 952         Bitmap* pReplacementBitmap = null;
 953         Bitmap* pEffectBitmap = null;
 954
 955         if (!__pEditTime->IsEnabled())
 956         {
 957                 isCustomBitmap = IS_CUSTOM_BITMAP(EDITTIME::CONTENT_BG_DISABLED);
 958                 pReplacementBitmap = __pContentBgDisabledColorReplacementBitmap;
 959                 pEffectBitmap = __pContentBgEffectDisabledBitmap;
 960         }
 961         else if (__selectedId != boxId)
 962         {
 963                 if (__pEditTime->GetDateTimeBar() != null && __pEditTime->GetDateTimeBar()->IsActivated() &&
 964                                 (GetLastSelectedId() == boxId))
 965                 {
 966                         isCustomBitmap = IS_CUSTOM_BITMAP(EDITTIME::CONTENT_BG_PRESSED);
 967                         pReplacementBitmap = __pContentBgPressedColorReplacementBitmap;
 968                         pEffectBitmap = __pContentBgEffectPressedBitmap;
 969                 }
 970                 else
 971                 {
 972                         isCustomBitmap = IS_CUSTOM_BITMAP(EDITTIME::CONTENT_BG_NORMAL);
 973                         pReplacementBitmap = __pContentBgNormalColorReplacementBitmap;
 974                         pEffectBitmap = __pContentBgEffectNormalBitmap;
 975                 }
 976         }
 977         else
 978         {
 979                 isCustomBitmap = IS_CUSTOM_BITMAP(EDITTIME::CONTENT_BG_PRESSED);
 980                 pReplacementBitmap = __pContentBgPressedColorReplacementBitmap;
 981                 pEffectBitmap = __pContentBgEffectPressedBitmap;
 982         }
 983
 984         r = DrawResourceBitmap(canvas, bounds, pReplacementBitmap);
 985         SysTryReturn(NID_UI_CTRL, (r == E_SUCCESS), r, r, "[%s] Propagating.", GetErrorMessage(r));
 986
 987         if (!isCustomBitmap)
 988         {
 989                 r = DrawResourceBitmap(canvas, bounds, pEffectBitmap);
 990                 SysTryReturn(NID_UI_CTRL, (r == E_SUCCESS), r, r, "[%s] Propagating.", GetErrorMessage(r));
 991         }
 992
 993         return r;
 994 }
 995
 996 result
 997 _EditTimePresenter::DrawText(Canvas& canvas, const FloatRectangle& bounds, const String& text, _DateTimeId boxId, float textSize)
 998 {
 999         result r = E_SUCCESS;
1000
1001         Color textColor;
1002         (_FontImpl::GetInstance(*__pFont))->SetStyle(FONT_STYLE_PLAIN);
1003
1004         if (!__pEditTime->IsEnabled())
1005         {
1006                 if (boxId == DATETIME_ID_AMPM)
1007                 {
1008                         GET_COLOR_CONFIG(EDITTIME::BUTTON_TEXT_DISABLED, textColor);
1009                 }
1010                 else
1011                 {
1012                         GET_COLOR_CONFIG(EDITTIME::TEXT_DISABLED, textColor);
1013                 }
1014         }
1015         else
1016         {
1017                 GET_COLOR_CONFIG(EDITTIME::TEXT_NORMAL, textColor);
1018
1019                 if (__pEditTime->GetDateTimeBar() != null && __pEditTime->GetDateTimeBar()->IsActivated() &&
1020                                 (GetLastSelectedId() == boxId))
1021                 {
1022                         GET_COLOR_CONFIG(EDITTIME::TEXT_PRESSED, textColor);
1023                         (_FontImpl::GetInstance(*__pFont))->SetStyle(FONT_STYLE_BOLD);
1024                 }
1025
1026                 if (boxId == DATETIME_ID_AMPM)
1027                 {
1028                         GET_COLOR_CONFIG(EDITTIME::BUTTON_TEXT_NORMAL, textColor);
1029                 }
1030
1031                 if (boxId > -1 && boxId == __selectedId)
1032                 {
1033                         if (boxId == DATETIME_ID_AMPM)
1034                         {
1035                                 GET_COLOR_CONFIG(EDITTIME::BUTTON_TEXT_PRESSED, textColor);
1036                         }
1037                         else
1038                         {
1039                                 GET_COLOR_CONFIG(EDITTIME::TEXT_PRESSED, textColor);
1040                                 (_FontImpl::GetInstance(*__pFont))->SetStyle(FONT_STYLE_BOLD);
1041                         }
1042                 }
1043         }
1044
1045         if (boxId != DATETIME_ID_AMPM)
1046         {
1047                 DrawContentBitmap(canvas, bounds, boxId);
1048         }
1049
1050         FloatRectangle drawAreaBounds(0.0f, 0.0f, 0.0f, 0.0f);
1051         drawAreaBounds = bounds;
1052
1053         TextSimple* pSimpleText = null;
1054         pSimpleText = new (std::nothrow)TextSimple((const_cast <wchar_t*>(text.GetPointer())), text.GetLength(), TEXT_ELEMENT_SOURCE_TYPE_EXTERNAL);
1055         SysTryReturn(NID_UI_CTRL, (pSimpleText != null), E_OUT_OF_MEMORY, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] Memory allocation failed.");
1056
1057         __textObject.RemoveAll();
1058
1059         (_FontImpl::GetInstance(*__pFont))->SetSize(__timeFontSize);
1060         __textObject.AppendElement(*pSimpleText);
1061
1062         if (boxId == DATETIME_ID_AMPM)
1063         {
1064                 (_FontImpl::GetInstance(*__pFont))->SetSize(textSize);
1065         }
1066         if (__isFocused && __focusId == boxId)
1067         {
1068                 if (boxId == DATETIME_ID_AMPM)
1069                 {
1070                         GET_COLOR_CONFIG(EDITTIME::BUTTON_TEXT_HIGHLIGHTED, textColor);
1071                 }
1072                 else
1073                 {
1074                         GET_COLOR_CONFIG(EDITTIME::TEXT_HIGHLIGHTED, textColor);
1075                 }
1076
1077                 DrawFocus();
1078         }
1079
1080         __textObject.SetFont(__pFont, 0, __textObject.GetTextLength());
1081
1082         __textObject.SetForegroundColor(textColor, 0, __textObject.GetTextLength());
1083         __textObject.SetBounds(drawAreaBounds);
1084         __textObject.Draw(*_CanvasImpl::GetInstance(canvas));
1085
1086         return r;
1087 }
1088
1089 _DateTimeId
1090 _EditTimePresenter::GetBoxIdFromPosition(const FloatPoint& point) const
1091 {
1092         _DateTimeId displayBoxId = DATETIME_ID_NONE;
1093
1094         FloatRectangle ampmBounds(0.0f, 0.0f, 0.0f, 0.0f);
1095         FloatRectangle hoursBounds(0.0f, 0.0f, 0.0f, 0.0f);
1096         FloatRectangle minutesBounds(0.0f, 0.0f, 0.0f, 0.0f);
1097
1098         if (__24hours == false)
1099         {
1100                 ampmBounds = GetDisplayAreaBoundsFromHoursStyle(DATETIME_ID_AMPM);
1101         }
1102
1103         hoursBounds = GetDisplayAreaBoundsFromHoursStyle(DATETIME_ID_HOUR);
1104         minutesBounds = GetDisplayAreaBoundsFromHoursStyle(DATETIME_ID_MINUTE);
1105
1106         if (point.y < hoursBounds.y || point.y > hoursBounds.y + hoursBounds.height)
1107         {
1108                 return displayBoxId;
1109         }
1110
1111         if (hoursBounds.Contains(point) == true)
1112         {
1113                 displayBoxId = DATETIME_ID_HOUR;
1114         }
1115         else if (minutesBounds.Contains(point) == true)
1116         {
1117                 displayBoxId = DATETIME_ID_MINUTE;
1118         }
1119         else if (ampmBounds.Contains(point) == true)
1120         {
1121                 displayBoxId = DATETIME_ID_AMPM;
1122         }
1123
1124         return displayBoxId;
1125 }
1126
1127 void
1128 _EditTimePresenter::SetLastSelectedId(_DateTimeId boxId)
1129 {
1130         __lastSelectedId = boxId;
1131         return;
1132 }
1133
1134 _DateTimeId
1135 _EditTimePresenter::GetLastSelectedId(void) const
1136 {
1137         return __lastSelectedId;
1138 }
1139
1140 void
1141 _EditTimePresenter::SetFocusedElement()
1142 {
1143         if (__isEnterKeyPressed)
1144         {
1145                 __isEnterKeyPressed = false;
1146                 __isFocused = true;
1147         }
1148         if (__focusId == DATETIME_ID_NONE || __focusId == DATETIME_ID_AMPM)
1149         {
1150                 __focusId = DATETIME_ID_HOUR;
1151         }
1152
1153         return;
1154 }
1155
1156 void
1157 _EditTimePresenter::SetFocusState(bool isFocused)
1158 {
1159         __isFocused = isFocused;
1160         return;
1161 }
1162
1163 bool
1164 _EditTimePresenter::OnFocusLost(const _Control &source)
1165 {
1166         if (!__isEnterKeyPressed || __focusId == DATETIME_ID_AMPM)
1167         {
1168                 __focusId = DATETIME_ID_NONE;
1169         }
1170         __isFocused = false;
1171         __pEditTime->Invalidate();
1172         return true;
1173 }
1174
1175 void
1176 _EditTimePresenter::OnFocusModeStateChanged(void)
1177 {
1178         __isFocused = false;
1179         __focusId = DATETIME_ID_NONE;
1180         __pEditTime->Invalidate();
1181         return;
1182 }
1183
1184 bool
1185 _EditTimePresenter::OnKeyPressed(const _Control& source, const _KeyInfo& keyInfo)
1186 {
1187         if (!__isFocused)
1188         {
1189                 return false;
1190         }
1191         _KeyCode keyCode = keyInfo.GetKeyCode();
1192
1193         switch (keyCode)
1194         {
1195                 case _KEY_RIGHT:
1196                 {
1197                         __isEnterKeyPressed = false;
1198                         if (__focusId == DATETIME_ID_HOUR)
1199                         {
1200                                 __focusId = DATETIME_ID_MINUTE;
1201                         }
1202                         else if (__focusId == DATETIME_ID_MINUTE)
1203                         {
1204                                 if (!Is24HourNotationEnabled())
1205                                 {
1206                                         __focusId = DATETIME_ID_AMPM;
1207                                 }
1208                         }
1209                         else if (__focusId == DATETIME_ID_AMPM)
1210                         {
1211                                 return false;
1212                         }
1213
1214                         __pEditTime->Invalidate();
1215                         break;
1216                 }
1217                 case _KEY_LEFT:
1218                 {
1219                         __isEnterKeyPressed = false;
1220                         if (__focusId == DATETIME_ID_MINUTE)
1221                         {
1222                                 __focusId = DATETIME_ID_HOUR;
1223                         }
1224                         else if (__focusId == DATETIME_ID_AMPM)
1225                         {
1226                                 __focusId = DATETIME_ID_MINUTE;
1227                         }
1228                         else if (__focusId == DATETIME_ID_HOUR)
1229                         {
1230                                 return false;
1231                         }
1232                         __pEditTime->Invalidate();
1233                         break;
1234                 }
1235
1236                 default:
1237                 {
1238                         return false;
1239                 }
1240         }
1241         return true;
1242 }
1243
1244 bool
1245 _EditTimePresenter::OnKeyReleased(const _Control& source, const _KeyInfo& keyInfo)
1246 {
1247         if (!__isFocused)
1248         {
1249                 return false;
1250         }
1251         _KeyCode keyCode = keyInfo.GetKeyCode();
1252
1253         if (__isAnimating)
1254         {
1255                 VisualElement *pEditTimeElement = __pEditTime->GetVisualElement();
1256                 result r = GetLastResult();
1257                 SysTryReturn(NID_UI_CTRL, (pEditTimeElement != null), false, r, "[%s] Propagating.", GetErrorMessage(r));
1258                 pEditTimeElement->RemoveAllAnimations();
1259         }
1260
1261         int minValue = -1;
1262         int maxValue = -1;
1263         int displayValue = -1;
1264
1265         _DateTimeId boxId = DATETIME_ID_HOUR;
1266
1267         switch (keyCode)
1268         {
1269                 case _KEY_ENTER:
1270                 {
1271                         __isEnterKeyPressed = true;
1272                         if (__focusId == DATETIME_ID_HOUR)
1273                         {
1274                                 boxId = DATETIME_ID_HOUR;
1275                                 if (__pEditTime->GetDateTimeBar() != null)
1276                                 {
1277                                         if (!Is24HourNotationEnabled())
1278                                         {
1279                                                 if (GetHour() == 0)
1280                                                 {
1281                                                         minValue = DATETIME_HOUR_MIN + 1;
1282                                                         maxValue = DATETIME_HOUR_MAX_FOR_24NOTATION;
1283                                                         displayValue = DATETIME_HOUR_MAX_FOR_24NOTATION;
1284                                                 }
1285                                                 else if (GetHour() > DATETIME_HOUR_MAX_FOR_24NOTATION)
1286                                                 {
1287                                                         minValue = DATETIME_HOUR_MIN + 1;
1288                                                         maxValue = DATETIME_HOUR_MAX_FOR_24NOTATION;
1289                                                         displayValue = __pEditTime->GetHour() - DATETIME_HOUR_MAX_FOR_24NOTATION;
1290                                                 }
1291                                                 else
1292                                                 {
1293                                                         minValue = DATETIME_HOUR_MIN + 1;
1294                                                         maxValue = DATETIME_HOUR_MAX_FOR_24NOTATION;
1295                                                         displayValue = __pEditTime->GetHour();
1296                                                 }
1297                                         }
1298                                         else
1299                                         {
1300                                                 minValue = DATETIME_HOUR_MIN;
1301                                                 maxValue = DATETIME_HOUR_MAX;
1302                                                 displayValue = __pEditTime->GetHour();
1303                                         }
1304
1305                                         if (__pEditTime->GetDateTimeBar()->GetItemCount() > 0)
1306                                         {
1307                                                 __pEditTime->GetDateTimeBar()->RemoveAllItems();
1308                                         }
1309                                 }
1310                         }
1311                         else if (__focusId == DATETIME_ID_MINUTE)
1312                         {
1313                                 if (__pEditTime->GetDateTimeBar() != null)
1314                                 {
1315                                         minValue = DATETIME_MINUTE_MIN;
1316                                         maxValue = DATETIME_MINUTE_MAX;
1317                                         displayValue = __pEditTime->GetMinute();
1318
1319                                         if (__pEditTime->GetDateTimeBar()->GetItemCount() > 0)
1320                                         {
1321                                                 __pEditTime->GetDateTimeBar()->RemoveAllItems();
1322                                         }
1323                                 }
1324                                 boxId = DATETIME_ID_MINUTE;
1325                         }
1326                         else if (__focusId == DATETIME_ID_AMPM)
1327                         {
1328                                 SetAmEnabled(!GetAmEnabled());
1329                                 __pEditTime->FireTimeChangeEvent(TIME_INTERNAL_CHANGE_SAVED);
1330                                 boxId = DATETIME_ID_AMPM;
1331
1332                                 __pEditTime->Invalidate();
1333                         }
1334
1335                         if ((__pEditTime->GetDateTimeBar() != null) && (boxId != DATETIME_ID_AMPM))
1336                         {
1337                                 FloatRectangle absoluteBounds = __pEditTime->GetAbsoluteBoundsF();
1338
1339                                 FloatRectangle bounds(0.0f, 0.0f, 0.0f, 0.0f);
1340                                 bounds = GetDisplayAreaBoundsFromHoursStyle(boxId);
1341                                 bounds.x += absoluteBounds.x;
1342
1343                                 __pEditTime->GetDateTimeBar()->SetInitialValue(minValue, maxValue, displayValue, boxId);
1344                                 __pEditTime->GetDateTimeBar()->CalculateArrowBounds(bounds);
1345                                 __pEditTime->GetDateTimeBar()->SetVisibleState(true);
1346                                 __pEditTime->GetDateTimeBar()->Open();
1347                                 UpdateLastSelectedValue(boxId, false);
1348                         }
1349                         break;
1350                 }
1351
1352                 default:
1353                 {
1354                         return false;
1355                 }
1356         }
1357         return true;
1358 }
1359
1360 bool
1361 _EditTimePresenter::OnTouchPressed(const _Control& source, const _TouchInfo& touchinfo)
1362 {
1363         SysTryReturn(NID_UI_CTRL, IsTimePickerEnabled() == true, true, E_SYSTEM, "[E_SYSTEM] A system error has occurred. EditTime instance is disabled.");
1364
1365         if (&source != __pEditTime)
1366         {
1367                 return false;
1368         }
1369
1370         __touchMoveHandled = false;
1371
1372         FloatRectangle hourBounds(0.0f, 0.0f, 0.0f, 0.0f);
1373         FloatRectangle minuteBounds(0.0f, 0.0f, 0.0f, 0.0f);
1374         FloatRectangle ampmBounds(0.0f, 0.0f, 0.0f, 0.0f);
1375
1376         hourBounds = GetDisplayAreaBoundsFromHoursStyle(DATETIME_ID_HOUR);
1377         minuteBounds = GetDisplayAreaBoundsFromHoursStyle(DATETIME_ID_MINUTE);
1378
1379         if (__24hours == false)
1380         {
1381                 ampmBounds = GetDisplayAreaBoundsFromHoursStyle(DATETIME_ID_AMPM);
1382         }
1383
1384         FloatPoint point = touchinfo.GetCurrentPosition();
1385
1386         _DateTimeId boxId = GetBoxIdFromPosition(point);
1387
1388         int minValue = -1;
1389         int maxValue = -1;
1390         int displayValue = -1;
1391
1392         if (boxId == DATETIME_ID_HOUR)
1393         {
1394                 if (__pEditTime->GetDateTimeBar() != null)
1395                 {
1396                         if (__24hours == false)
1397                         {
1398                                 if (GetHour() == 0)
1399                                 {
1400                                         minValue = DATETIME_HOUR_MIN + 1;
1401                                         maxValue = DATETIME_HOUR_MAX_FOR_24NOTATION;
1402                                         displayValue = DATETIME_HOUR_MAX_FOR_24NOTATION;
1403                                 }
1404                                 else if (GetHour() > DATETIME_HOUR_MAX_FOR_24NOTATION)
1405                                 {
1406                                         minValue = DATETIME_HOUR_MIN + 1;
1407                                         maxValue = DATETIME_HOUR_MAX_FOR_24NOTATION;
1408                                         displayValue = GetHour() - DATETIME_HOUR_MAX_FOR_24NOTATION;
1409                                 }
1410                                 else
1411                                 {
1412                                         minValue = DATETIME_HOUR_MIN + 1;
1413                                         maxValue = DATETIME_HOUR_MAX_FOR_24NOTATION;
1414                                         displayValue = GetHour();
1415                                 }
1416                         }
1417                         else
1418                         {
1419                                 minValue = DATETIME_HOUR_MIN;
1420                                 maxValue = DATETIME_HOUR_MAX;
1421                                 displayValue = GetHour();
1422                         }
1423
1424                         if (__pEditTime->GetDateTimeBar()->GetItemCount() > 0)
1425                         {
1426                                 __pEditTime->GetDateTimeBar()->RemoveAllItems();
1427                         }
1428
1429                         __pEditTime->GetDateTimeBar()->SetInitialValue(minValue, maxValue, displayValue, boxId);
1430                 }
1431
1432                 __bounds = hourBounds;
1433         }
1434         else if (boxId == DATETIME_ID_MINUTE)
1435         {
1436                 if (__pEditTime->GetDateTimeBar() != null)
1437                 {
1438                         minValue = DATETIME_MINUTE_MIN;
1439                         maxValue = DATETIME_MINUTE_MAX;
1440                         displayValue = GetMinute();
1441
1442                         if (__pEditTime->GetDateTimeBar()->GetItemCount() > 0)
1443                         {
1444                                 __pEditTime->GetDateTimeBar()->RemoveAllItems();
1445                         }
1446
1447                         __pEditTime->GetDateTimeBar()->SetInitialValue(minValue, maxValue, displayValue, boxId);
1448                 }
1449
1450                 __bounds = minuteBounds;
1451         }
1452         else if (boxId == DATETIME_ID_AMPM)
1453         {
1454                 __selectedId = boxId;
1455                 __bounds = ampmBounds;
1456                 Draw();
1457         }
1458         else
1459         {
1460                 __selectedId = DATETIME_ID_NONE;
1461                 return false;
1462         }
1463
1464         __selectedId = boxId;
1465
1466         return true;
1467 }
1468
1469 bool
1470 _EditTimePresenter::OnTouchReleased(const _Control& source, const _TouchInfo& touchinfo)
1471 {
1472         SysTryReturn(NID_UI_CTRL, IsTimePickerEnabled() == true, true, E_SYSTEM, "[E_SYSTEM] A system error has occurred. EditTime instance is disabled.");
1473
1474         if (&source != __pEditTime)
1475         {
1476                 return false;
1477         }
1478
1479         FloatRectangle bounds = __pEditTime->GetBoundsF();
1480
1481         FloatPoint startPoint(0.0f, 0.0f);
1482
1483         float titleHeight = 0;
1484         GET_SHAPE_CONFIG(EDITTIME::TITLE_HEIGHT, __pEditTime->GetOrientation(), titleHeight);
1485
1486         __bounds = FloatRectangle(0.0f, titleHeight, bounds.width, bounds.height);
1487
1488         FloatPoint point = touchinfo.GetCurrentPosition();
1489
1490         _DateTimeId boxId = GetBoxIdFromPosition(point);
1491
1492         if ((boxId == GetLastSelectedId() && boxId != DATETIME_ID_AMPM) || boxId != __selectedId || boxId == DATETIME_ID_NONE)
1493         {
1494                 if (__pEditTime->GetDateTimeBar() != null && __pEditTime->GetDateTimeBar()->IsActivated())
1495                 {
1496                         __pEditTime->GetDateTimeBar()->CloseDateTimeBar();
1497                 }
1498
1499                 __selectedId = DATETIME_ID_NONE;
1500                 SetLastSelectedId(__selectedId);
1501
1502                 Draw();
1503
1504                 return true;
1505         }
1506         UpdateLastSelectedValue(__selectedId, true);
1507         if (GetLastSelectedId() == DATETIME_ID_AMPM)
1508         {
1509                 return true;
1510         }
1511
1512         Draw();
1513
1514         if ((__pEditTime->GetDateTimeBar() != null) && (boxId != DATETIME_ID_AMPM) && (GetLastSelectedId() != DATETIME_ID_NONE))
1515         {
1516                 __pEditTime->SetFocused(true);
1517
1518                 FloatRectangle bounds(0.0f, 0.0f, 0.0f, 0.0f);
1519                 bounds = GetDisplayAreaBoundsFromHoursStyle(GetLastSelectedId());
1520                 FloatRectangle absoluteBounds(0.0f, 0.0f, 0.0f, 0.0f);
1521                 absoluteBounds = __pEditTime->GetAbsoluteBoundsF();
1522                 bounds.x += absoluteBounds.x;
1523
1524                 __pEditTime->GetDateTimeBar()->CalculateArrowBounds(bounds);
1525
1526                 if (__pEditTime->GetDateTimeBar()->IsActivated())
1527                 {
1528                         __pEditTime->GetDateTimeBar()->Close();
1529                         __pEditTime->GetDateTimeBar()->Open();
1530                 }
1531                 else
1532                 {
1533                         __pEditTime->GetDateTimeBar()->SetVisibleState(true);
1534                         __pEditTime->GetDateTimeBar()->Open();
1535                 }
1536         }
1537
1538         __selectedId = DATETIME_ID_NONE;
1539         return true;
1540 }
1541
1542 void
1543 _EditTimePresenter::UpdateLastSelectedValue(_DateTimeId boxId, bool isTouchPressed)
1544 {
1545         __selectedId = boxId;
1546         SetLastSelectedId(boxId);
1547
1548         __lastSelectedValue = "";
1549
1550         if (GetLastSelectedId() == DATETIME_ID_HOUR)
1551         {
1552                 int hours = GetHour();
1553
1554                 if (!Is24HourNotationEnabled())
1555                 {
1556                         hours = hours % 12;
1557
1558                         if (hours == DATETIME_HOUR_MIN)
1559                         {
1560                                 hours = hours + DATETIME_HOUR_MAX_FOR_24NOTATION;
1561                         }
1562                 }
1563                 __lastSelectedValue.Format(10, L"%02d", hours);
1564                 if (isTouchPressed)
1565                 {
1566                         PLAY_FEEDBACK(_RESOURCE_FEEDBACK_PATTERN_TAP, __pEditTime);
1567                 }
1568         }
1569         else if (GetLastSelectedId() == DATETIME_ID_MINUTE)
1570         {
1571                 __lastSelectedValue.Format(10, L"%02d", GetMinute());
1572                 if (isTouchPressed)
1573                 {
1574                         PLAY_FEEDBACK(_RESOURCE_FEEDBACK_PATTERN_TAP, __pEditTime);
1575                 }
1576         }
1577         else if (GetLastSelectedId() == DATETIME_ID_AMPM)
1578         {
1579                 SetAmEnabled(!GetAmEnabled());
1580                 __pEditTime->FireTimeChangeEvent(TIME_INTERNAL_CHANGE_SAVED);
1581                 if (isTouchPressed)
1582                 {
1583                         __pEditTime->UpdateAccessibilityElement();
1584                         PLAY_FEEDBACK(_RESOURCE_FEEDBACK_PATTERN_TAP, __pEditTime);
1585                 }
1586                 __selectedId = DATETIME_ID_NONE;
1587
1588                 if (__pEditTime->GetDateTimeBar() != null && __pEditTime->GetDateTimeBar()->IsActivated())
1589                 {
1590                         __pEditTime->GetDateTimeBar()->SetVisibleState(false);
1591                         __pEditTime->GetDateTimeBar()->Close();
1592                 }
1593         }
1594
1595         __selectedId = DATETIME_ID_NONE;
1596         __pEditTime->Invalidate();
1597         return;
1598 }
1599
1600 bool
1601 _EditTimePresenter::OnTouchCanceled(const _Control& source, const _TouchInfo& touchinfo)
1602 {
1603         if (&source != __pEditTime)
1604         {
1605                 return false;
1606         }
1607
1608         __selectedId = DATETIME_ID_NONE;
1609
1610         return true;
1611 }
1612
1613 bool
1614 _EditTimePresenter::OnTouchMoved(const _Control& source, const _TouchInfo& touchinfo)
1615 {
1616         if (&source != __pEditTime)
1617         {
1618                 return false;
1619         }
1620
1621         if (__pEditTime->GetDateTimeBar() != null && __pEditTime->GetDateTimeBar()->IsActivated())
1622         {
1623                 return true;
1624         }
1625
1626         return false;
1627 }
1628
1629 void
1630 _EditTimePresenter::OnTouchMoveHandled(const _Control& control)
1631 {
1632         __touchMoveHandled = true;
1633         __selectedId = DATETIME_ID_NONE;
1634
1635         return;
1636 }
1637
1638 void
1639 _EditTimePresenter::OnFontChanged(Font* pFont)
1640 {
1641         __pFont = pFont;
1642
1643         if (__pEditTime->GetDateTimeBar() != null)
1644         {
1645                 __pEditTime->GetDateTimeBar()->SetFont(*pFont);
1646         }
1647
1648         return;
1649 }
1650
1651 void
1652 _EditTimePresenter::OnFontInfoRequested(unsigned long& style, float& size)
1653 {
1654         style = FONT_STYLE_PLAIN;
1655         size = __timeFontSize;
1656
1657         return;
1658 }
1659
1660 result
1661 _EditTimePresenter::Initialize(void)
1662 {
1663         result r = E_SUCCESS;
1664
1665         float titleTimeMargin = 0;
1666         float timeHeight = 0;
1667         float editTimeHeight = 0;
1668
1669         GET_SHAPE_CONFIG(EDITTIME::TEXT_FONT_SIZE, __pEditTime->GetOrientation(), __titleFontSize);
1670         GET_SHAPE_CONFIG(EDITTIME::TIME_FONT_SIZE, __pEditTime->GetOrientation(), __timeFontSize);
1671         GET_SHAPE_CONFIG(EDITTIME::TITLE_TIME_MARGIN, __pEditTime->GetOrientation(), titleTimeMargin);
1672         GET_SHAPE_CONFIG(EDITTIME::TIME_HEIGHT, __pEditTime->GetOrientation(), timeHeight);
1673         GET_SHAPE_CONFIG(EDITTIME::HEIGHT, __pEditTime->GetOrientation(), editTimeHeight);
1674
1675         if (__pEditTime->GetBoundsF().height > editTimeHeight)
1676         {
1677                 editTimeHeight = __pEditTime->GetBoundsF().height;
1678         }
1679
1680         if (__title.IsEmpty() == false)
1681         {
1682                 SetTitleBounds();
1683                 if (!__isEditTimeInitialized)
1684                 {
1685                         r = InitializeTitleObject();
1686                         SysTryReturn(NID_UI_CTRL, (r == E_SUCCESS), r, r, "[%s] Propagating.", GetErrorMessage(r));
1687                 }
1688
1689                 __titleBounds.y = (editTimeHeight - (__titleBounds.height + titleTimeMargin + timeHeight)) / 2.0f;
1690                 __titleObject.SetBounds(__titleBounds);
1691         }
1692
1693         __pFont = __pEditTime->GetFallbackFont();
1694         r = GetLastResult();
1695         SysTryReturn(NID_UI_CTRL, __pFont != null, r, r, "[%s] Propagating.", GetErrorMessage(r));
1696
1697         if (!__isEditTimeInitialized)
1698         {
1699                 r = LoadResource();
1700                 SysTryReturn(NID_UI_CTRL, r == E_SUCCESS, r, r, "[%s] Propagating.", GetErrorMessage(r));
1701
1702                 r = InitializeTextObject();
1703                 SysTryReturn(NID_UI_CTRL, (r == E_SUCCESS), r, r, "[%s] Propagating.", GetErrorMessage(r));
1704         }
1705
1706         __isEditTimeInitialized = true;
1707
1708         UpdateTimeFormat();
1709         return r;
1710 }
1711
1712 void
1713 _EditTimePresenter::UpdateTimeFormat(void)
1714 {
1715         if (!__is24hoursSet)
1716         {
1717                 String key(L"http://tizen.org/setting/locale.time.format.24hour");
1718                 SettingInfo::GetValue(key , __24hours);
1719         }
1720
1721         return;
1722 }
1723
1724 void
1725 _EditTimePresenter::Animate(void)
1726 {
1727         SysTryReturnVoidResult(NID_UI_CTRL, !__isAnimating, E_SUCCESS, "Rolling animation is in progress.");
1728         SysAssertf((__pFont != null), "Font instance must not be null.");
1729
1730         (_FontImpl::GetInstance(*__pFont))->SetSize(__timeFontSize);
1731
1732         result r = E_SUCCESS;
1733         FloatRectangle rect;
1734         String hourString;
1735         String minuteString;
1736         String newValue;
1737         TextSimple* pOldSimpleText = null;
1738         TextSimple* pNewSimpleText = null;
1739         bool isCustomBitmap = false;
1740
1741         _DateTimeUtils dateTimeUtils;
1742         int hours = GetHour();
1743         if (!Is24HourNotationEnabled())
1744         {
1745                 hours = hours % 12;
1746
1747                 if (hours == DATETIME_HOUR_MIN)
1748                 {
1749                         hours = hours + DATETIME_HOUR_MAX_FOR_24NOTATION;
1750                 }
1751         }
1752         hourString.Format(10, L"%02d", hours);
1753         minuteString.Format(10, L"%02d", GetMinute());
1754
1755         if (GetLastSelectedId() == DATETIME_ID_HOUR)
1756         {
1757                 SysTryReturnVoidResult(NID_UI_CTRL, (__lastSelectedValue.Equals(hourString) == false), E_SUCCESS, "[E_SUCCESS] Hour string matched.");
1758
1759                 newValue = hourString;
1760                 rect = GetDisplayAreaBoundsFromHoursStyle(DATETIME_ID_HOUR);
1761         }
1762         else if (GetLastSelectedId() == DATETIME_ID_MINUTE)
1763         {
1764                 SysTryReturnVoidResult(NID_UI_CTRL, (__lastSelectedValue.Equals(minuteString) == false), E_SUCCESS, "[E_SUCCESS] Minute string matched.");
1765
1766                 newValue = minuteString;
1767                 rect = GetDisplayAreaBoundsFromHoursStyle(DATETIME_ID_MINUTE);
1768         }
1769
1770         FloatDimension newTextDim;
1771         FloatDimension oldTextDim;
1772         FloatPoint textPoint;
1773         VisualElement* pNewVisualElement = null;
1774         VisualElement* pOldVisualElement = null;
1775         VisualElement* pEditTimeElement = null;
1776         VisualElementPropertyAnimation* pNewBoundsAnimation = null;
1777         VisualElementPropertyAnimation* pOldBoundsAnimation = null;
1778         Canvas *pCanvas = null;
1779         Canvas *pContentCanvas = null;
1780         Color contentBgColor;
1781         Color textNormalColor;
1782         Color textPressedColor;
1783         float contentTextMargin;
1784
1785         GET_COLOR_CONFIG(EDITTIME::CONTENT_BG_PRESSED, contentBgColor);
1786         GET_COLOR_CONFIG(EDITTIME::TEXT_PRESSED, textPressedColor);
1787         GET_SHAPE_CONFIG(EDITDATE::CONTENT_TEXT_MARGIN, __pEditTime->GetOrientation(), contentTextMargin);
1788
1789         __pFont->GetTextExtent(newValue, newValue.GetLength(), newTextDim);
1790         __pFont->GetTextExtent(__lastSelectedValue, __lastSelectedValue.GetLength(), oldTextDim);
1791
1792         if (newTextDim.width > oldTextDim.width)
1793         {
1794                 textPoint.x = (rect.width - newTextDim.width) / 2.0f;
1795         }
1796         else
1797         {
1798                 textPoint.x = (rect.width - oldTextDim.width) / 2.0f;
1799         }
1800
1801         SysTryReturnVoidResult(NID_UI_CTRL, (rect.x + textPoint.x < __pEditTime->GetBounds().width), E_SUCCESS, "Rolling animation cann't be played.");
1802
1803         __isAnimating = true;
1804
1805         __pContentProvider = new (std::nothrow) VisualElement();
1806         SysTryReturnVoidResult(NID_UI_CTRL, (__pContentProvider != null), E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] Memory allocation failed.");
1807
1808         r = __pContentProvider->Construct();
1809         SysTryCatch(NID_UI_CTRL, (r == E_SUCCESS), , r, "[%s] Propagating.", GetErrorMessage(r));
1810
1811         __pContentProvider->SetShowState(true);
1812         __pContentProvider->SetClipChildrenEnabled(true);
1813         __pContentProvider->SetImplicitAnimationEnabled(false);
1814
1815         pEditTimeElement = __pEditTime->GetVisualElement();
1816         r = GetLastResult();
1817         SysTryCatch(NID_UI_CTRL, (pEditTimeElement != null), , r, "[%s] Propagating.", GetErrorMessage(r));
1818
1819         pNewVisualElement = new (std::nothrow) VisualElement();
1820         SysTryCatch(NID_UI_CTRL, (pNewVisualElement != null), , E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] Memory allocation failed.");
1821
1822         r = pNewVisualElement->Construct();
1823         if (r != E_SUCCESS)
1824         {
1825                 pNewVisualElement->Destroy();
1826                 pNewVisualElement = null;
1827         }
1828         SysTryCatch(NID_UI_CTRL, (r == E_SUCCESS), , r, "[%s] Propagating.", GetErrorMessage(r));
1829
1830         pNewVisualElement->SetShowState(true);
1831
1832         pOldVisualElement = new (std::nothrow) VisualElement();
1833         if (pOldVisualElement == null)
1834         {
1835                 pNewVisualElement->Destroy();
1836                 pNewVisualElement = null;
1837         }
1838         SysTryCatch(NID_UI_CTRL, (pOldVisualElement != null), , E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] Memory allocation failed.");
1839
1840         r = pOldVisualElement->Construct();
1841         if (r != E_SUCCESS)
1842         {
1843                 pNewVisualElement->Destroy();
1844                 pOldVisualElement->Destroy();
1845                 pNewVisualElement = null;
1846                 pOldVisualElement = null;
1847         }
1848         SysTryCatch(NID_UI_CTRL, (r == E_SUCCESS), , r, "[%s] Propagating.", GetErrorMessage(r));
1849
1850         pOldVisualElement->SetShowState(true);
1851
1852         __pContentProvider->SetBounds(FloatRectangle((rect.x + contentTextMargin), (rect.y + (contentTextMargin * 2.0f)), (rect.width - (contentTextMargin * 2.0f)), (rect.height - (contentTextMargin * 4.0f))));
1853
1854         pNewVisualElement->SetBounds(FloatRectangle(0, 0, __pContentProvider->GetBounds().width, __pContentProvider->GetBounds().height));
1855         pOldVisualElement->SetBounds(FloatRectangle(0, 0, __pContentProvider->GetBounds().width, __pContentProvider->GetBounds().height));
1856
1857         pContentCanvas = pEditTimeElement->GetCanvasN(__pContentProvider->GetBounds());
1858         r = GetLastResult();
1859         SysTryCatch(NID_UI_CTRL, (pContentCanvas != null), , r, "[%s] Propagating.", GetErrorMessage(r));
1860         pContentCanvas->SetBackgroundColor(Color(0, 0, 0, 0));
1861         pContentCanvas->Clear();
1862
1863         pCanvas = pEditTimeElement->GetCanvasN(rect);
1864         r = GetLastResult();
1865         SysTryCatch(NID_UI_CTRL, (pCanvas != null), , r, "[%s] Propagating.", GetErrorMessage(r));
1866         pCanvas->SetBackgroundColor(Color(0, 0, 0, 0));
1867         pCanvas->Clear();
1868         rect.x = 0.0f;
1869         rect.y = 0.0f;
1870         r = DrawResourceBitmap(*pCanvas, rect, __pContentBgPressedColorReplacementBitmap);
1871         isCustomBitmap = IS_CUSTOM_BITMAP(EDITTIME::CONTENT_BG_PRESSED);
1872
1873         if (!isCustomBitmap)
1874         {
1875                 result res = DrawResourceBitmap(*pCanvas, rect, __pContentBgEffectPressedBitmap);
1876
1877                 if (res != E_SUCCESS)
1878                 {
1879                         SysLog(NID_UI_CTRL, "[%s] Propagating.", GetErrorMessage(res));
1880                 }
1881         }
1882
1883         delete pCanvas;
1884         pCanvas = null;
1885
1886         if (r != E_SUCCESS)
1887         {
1888                 pContentCanvas->SetBackgroundColor(contentBgColor);
1889                 pContentCanvas->Clear();
1890         }
1891
1892         delete pContentCanvas;
1893         pContentCanvas = null;
1894
1895         pEditTimeElement->AttachChild(*__pContentProvider);
1896
1897         __pContentProvider->AttachChild(*pOldVisualElement);
1898         __pContentProvider->AttachChild(*pNewVisualElement);
1899
1900         pNewBoundsAnimation = new (std::nothrow) VisualElementPropertyAnimation();
1901         SysTryCatch(NID_UI_CTRL, (pNewBoundsAnimation != null), , E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] Memory allocation failed.");
1902
1903         pNewBoundsAnimation->SetDuration(300);
1904         pNewBoundsAnimation->SetPropertyName("bounds.position");
1905         pNewBoundsAnimation->SetStartValue(Variant(FloatPoint(pNewVisualElement->GetBounds().x, oldTextDim.height)));
1906         pNewBoundsAnimation->SetEndValue(Variant(FloatPoint(pNewVisualElement->GetBounds().x, 0.0f)));
1907         pNewBoundsAnimation->SetVisualElementAnimationStatusEventListener(this);
1908
1909         pOldBoundsAnimation = new (std::nothrow) VisualElementPropertyAnimation();
1910         SysTryCatch(NID_UI_CTRL, (pOldBoundsAnimation != null), , E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] Memory allocation failed.");
1911
1912         pOldBoundsAnimation->SetDuration(300);
1913         pOldBoundsAnimation->SetPropertyName("bounds.position");
1914         pOldBoundsAnimation->SetStartValue(Variant(FloatPoint(pOldVisualElement->GetBounds().x, 0.0f)));
1915         pOldBoundsAnimation->SetEndValue(Variant(FloatPoint(pOldVisualElement->GetBounds().x, oldTextDim.height * -1.0f)));
1916         pOldBoundsAnimation->SetVisualElementAnimationStatusEventListener(this);
1917
1918         pOldSimpleText = new (std::nothrow)TextSimple((const_cast <wchar_t*>(__lastSelectedValue.GetPointer())), __lastSelectedValue.GetLength(), TEXT_ELEMENT_SOURCE_TYPE_EXTERNAL);
1919         SysTryCatch(NID_UI_CTRL, (pOldSimpleText != null), , E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] Memory allocation failed.");
1920
1921         pCanvas = pOldVisualElement->GetCanvasN();
1922         r = GetLastResult();
1923         SysTryCatch(NID_UI_CTRL, (pCanvas != null), , r, "[%s] Propagating.", GetErrorMessage(r));
1924
1925         pCanvas->SetBackgroundColor(Color(0, 0, 0, 0));
1926         pCanvas->Clear();
1927         pCanvas->SetForegroundColor(textPressedColor);
1928
1929         (_FontImpl::GetInstance(*__pFont))->SetSize(__timeFontSize);
1930         (_FontImpl::GetInstance(*__pFont))->SetStyle(FONT_STYLE_PLAIN);
1931         __textObject.RemoveAll();
1932         __textObject.AppendElement(*pOldSimpleText);
1933
1934         __textObject.SetFont(__pFont, 0, __textObject.GetTextLength());
1935         __textObject.SetForegroundColor(textPressedColor, 0, __textObject.GetTextLength());
1936         __textObject.SetBounds(FloatRectangle(0, 0, pCanvas->GetBounds().width, pCanvas->GetBounds().height));
1937         __textObject.Draw(*_CanvasImpl::GetInstance(*pCanvas));
1938
1939         delete pCanvas;
1940         pCanvas = null;
1941
1942         pNewSimpleText = new (std::nothrow)TextSimple((const_cast <wchar_t*>(newValue.GetPointer())), newValue.GetLength(), TEXT_ELEMENT_SOURCE_TYPE_EXTERNAL);
1943         SysTryCatch(NID_UI_CTRL, (pNewSimpleText != null), , E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] Memory allocation failed.");
1944
1945         pCanvas = pNewVisualElement->GetCanvasN();
1946         r = GetLastResult();
1947         SysTryCatch(NID_UI_CTRL, (pCanvas != null), , r, "[%s] Propagating.", GetErrorMessage(r));
1948
1949         pCanvas->SetBackgroundColor(Color(0, 0, 0, 0));
1950         pCanvas->Clear();
1951         pCanvas->SetForegroundColor(textPressedColor);
1952
1953         (_FontImpl::GetInstance(*__pFont))->SetSize(__timeFontSize);
1954         (_FontImpl::GetInstance(*__pFont))->SetStyle(FONT_STYLE_PLAIN);
1955         __textObject.RemoveAll();
1956         __textObject.AppendElement(*pNewSimpleText);
1957
1958         __textObject.SetFont(__pFont, 0, __textObject.GetTextLength());
1959         __textObject.SetForegroundColor(textPressedColor, 0, __textObject.GetTextLength());
1960         __textObject.SetBounds(FloatRectangle(0, 0, pCanvas->GetBounds().width, pCanvas->GetBounds().height));
1961         __textObject.Draw(*_CanvasImpl::GetInstance(*pCanvas));
1962
1963         delete pCanvas;
1964         pCanvas = null;
1965
1966         pOldVisualElement->SetImplicitAnimationEnabled(false);
1967         pOldVisualElement->AddAnimation(*pOldBoundsAnimation);
1968
1969         pNewVisualElement->SetImplicitAnimationEnabled(false);
1970         pNewVisualElement->AddAnimation(*pNewBoundsAnimation);
1971
1972         delete pOldBoundsAnimation;
1973         delete pNewBoundsAnimation;
1974
1975         return;
1976
1977 CATCH:
1978         __isAnimating = false;
1979         __pContentProvider->Destroy();
1980         __pContentProvider = null;
1981
1982         delete pNewBoundsAnimation;
1983         pNewBoundsAnimation = null;
1984
1985         delete pOldBoundsAnimation;
1986         pOldBoundsAnimation = null;
1987
1988         delete pOldSimpleText;
1989         pOldSimpleText = null;
1990
1991         delete pNewSimpleText;
1992         pNewSimpleText = null;
1993
1994         delete pContentCanvas;
1995         pContentCanvas = null;
1996
1997         return;
1998 }
1999
2000 void
2001 _EditTimePresenter::OnVisualElementAnimationFinished (const VisualElementAnimation &animation, const String &keyName, VisualElement &target, bool completedNormally)
2002 {
2003         result r = E_SUCCESS;
2004         __isAnimating = false;
2005
2006         VisualElement* pEditTimeElement = __pEditTime->GetVisualElement();
2007         r = GetLastResult();
2008         SysTryReturnVoidResult(NID_UI_CTRL, (pEditTimeElement != null), r, "[%s] Propagating.", GetErrorMessage(r));
2009
2010         pEditTimeElement->DetachChild(*__pContentProvider);
2011         __pContentProvider->Destroy();
2012         __pContentProvider = null;
2013
2014         Draw();
2015         return;
2016 }
2017
2018 }}} // Tizen::Ui::Controls