src/ui/controls/FUiCtrl_EditTime.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_EditTime.cpp
  20  * @brief               This is the implementation file for the _EditTime class.
  21  */
  22
  23 #include <FSysSettingInfo.h>
  24 #include "FUi_CoordinateSystemUtils.h"
  25 #include "FUi_AccessibilityContainer.h"
  26 #include "FUi_AccessibilityElement.h"
  27 #include "FUi_ResourceManager.h"
  28 #include "FUiAnim_VisualElement.h"
  29 #include "FUiCtrl_EditTime.h"
  30 #include "FUiCtrl_EditTimePresenter.h"
  31 #include "FUiCtrl_Form.h"
  32 #include "FUiCtrl_Frame.h"
  33 #include "FUiCtrl_DateTimeUtils.h"
  34 #include "FUiCtrl_DateTimeDefine.h"
  35
  36 using namespace Tizen::Graphics;
  37 using namespace Tizen::Base::Runtime;
  38 using namespace Tizen::Base;
  39 using namespace Tizen::System;
  40
  41 namespace Tizen { namespace Ui { namespace Controls
  42 {
  43
  44 IMPLEMENT_PROPERTY(_EditTime);
  45
  46 _EditTime::_EditTime(void)
  47         : __pEditTimePresenter(null)
  48         , __pTimeChangeEvent(null)
  49         , __pDateTimeBar(null)
  50         , __absoluteBounds(FloatRectangle())
  51         , __previousSize(0.0f, 0.0f)
  52         , __title()
  53         , __pAccessibilityEditTimeElement(null)
  54         , __pAccessibilityHourElement(null)
  55         , __pAccessibilityMinuteElement(null)
  56         , __pAccessibilityAmPmElement(null)
  57         , __isCalledBoundsChanged(false)
  58         , __isXmlBoundsExist(false)
  59 {
  60 }
  61
  62 _EditTime::~_EditTime(void)
  63 {
  64         SettingInfo::RemoveSettingEventListener(*this);
  65
  66         delete __pDateTimeBar;
  67         __pDateTimeBar = null;
  68
  69         delete __pEditTimePresenter;
  70         __pEditTimePresenter = null;
  71
  72         if (__pTimeChangeEvent != null)
  73         {
  74                 delete __pTimeChangeEvent;
  75                 __pTimeChangeEvent = null;
  76         }
  77
  78         if (__pAccessibilityEditTimeElement)
  79         {
  80                 __pAccessibilityEditTimeElement->Activate(false);
  81                 __pAccessibilityEditTimeElement = null;
  82         }
  83         if (__pAccessibilityHourElement)
  84         {
  85                 __pAccessibilityHourElement->Activate(false);
  86                 __pAccessibilityHourElement = null;
  87         }
  88         if (__pAccessibilityMinuteElement)
  89         {
  90                 __pAccessibilityMinuteElement->Activate(false);
  91                 __pAccessibilityMinuteElement = null;
  92         }
  93         if (__pAccessibilityAmPmElement)
  94         {
  95                 __pAccessibilityAmPmElement->Activate(false);
  96                 __pAccessibilityAmPmElement = null;
  97         }
  98 }
  99
 100 _EditTime*
 101 _EditTime::CreateEditTimeN(const String& title)
 102 {
 103         result r = E_SUCCESS;
 104
 105         _AccessibilityContainer* pContainer = null;
 106
 107         _EditTime* pEditTime = new (std::nothrow) _EditTime;
 108         SysTryReturn(NID_UI_CTRL, pEditTime, null, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] Memory allocation failed.");
 109
 110         pEditTime->GetVisualElement()->SetSurfaceOpaque(false);
 111
 112         pEditTime->__pEditTimePresenter = _EditTimePresenter::CreateInstanceN(*pEditTime, title);
 113         r = GetLastResult();
 114         SysTryCatch(NID_UI_CTRL, pEditTime->__pEditTimePresenter, , r, "[%s] Propagating.", GetErrorMessage(r));
 115
 116         r = pEditTime->CreateDateTimeBar();
 117         SysTryCatch(NID_UI_CTRL, r == E_SUCCESS, , r, "[%s] Propagating.", GetErrorMessage(r));
 118
 119         pEditTime->__pEditTimePresenter->Initialize();
 120         r = GetLastResult();
 121         SysTryCatch(NID_UI_CTRL, pEditTime->__pEditTimePresenter, , r, "[%s] Propagating.", GetErrorMessage(r));
 122
 123         pEditTime->__pEditTimePresenter->SetCurrentTime();
 124
 125         if (title.IsEmpty() != true)
 126         {
 127                 pEditTime->__title = title;
 128         }
 129
 130         pContainer = pEditTime->GetAccessibilityContainer();
 131         if (pContainer)
 132         {
 133                 pContainer->Activate(true);
 134                 pEditTime->CreateAccessibilityElement();
 135         }
 136
 137         pEditTime->AcquireHandle();
 138
 139         return pEditTime;
 140
 141 CATCH:
 142         delete pEditTime;
 143         return null;
 144 }
 145
 146 result
 147 _EditTime::CreateDateTimeBar(void)
 148 {
 149         result r = E_SUCCESS;
 150
 151         __pDateTimeBar = _DateTimeBar::CreateDateTimeBarN(*this);
 152         r = GetLastResult();
 153         SysTryReturn(NID_UI_CTRL, (__pDateTimeBar != null), r, r, "[%s] Propagating.", GetErrorMessage(r));
 154
 155         r = __pDateTimeBar->AddActionEventListener(*this);
 156         SysTryCatch(NID_UI_CTRL, r == E_SUCCESS, , r, "[%s] Propagating.", GetErrorMessage(r));
 157
 158         r = __pDateTimeBar->AddDateTimeChangeEventListener(*this);
 159         SysTryCatch(NID_UI_CTRL, r == E_SUCCESS, , r, "[%s] Propagating.", GetErrorMessage(r));
 160
 161         r =  SettingInfo::AddSettingEventListener(*this);
 162         SysTryCatch(NID_UI_CTRL, r == E_SUCCESS, , r, "[%s] Propagating.", GetErrorMessage(r));
 163
 164         GET_SHAPE_CONFIG(EDITTIME::WIDTH, GetOrientation(), __previousSize.width);
 165         GET_SHAPE_CONFIG(EDITTIME::HEIGHT, GetOrientation(), __previousSize.height);
 166
 167         return r;
 168
 169 CATCH:
 170         delete __pDateTimeBar;
 171         return r;
 172 }
 173
 174 result
 175 _EditTime::AddTimeChangeEventListener(const _IDateTimeChangeEventListener& listener)
 176 {
 177         if (__pTimeChangeEvent == null)
 178         {
 179                 __pTimeChangeEvent = new (std::nothrow) _DateTimeChangeEvent(*this);
 180                 SysTryReturn(NID_UI_CTRL, (__pTimeChangeEvent != null), E_OUT_OF_MEMORY, E_OUT_OF_MEMORY,
 181                                 "[E_OUT_OF_MEMORY] Memory allocation failed.");
 182         }
 183
 184         result r = __pTimeChangeEvent->AddListener(listener);
 185         SysTryReturn(NID_UI_CTRL, r == E_SUCCESS, r, r, "[%s] Propagating.", GetErrorMessage(r));
 186
 187         return E_SUCCESS;
 188 }
 189
 190 result
 191 _EditTime::RemoveTimeChangeEventListener(const _IDateTimeChangeEventListener& listener)
 192 {
 193         result r = E_OBJ_NOT_FOUND;
 194
 195         if (__pTimeChangeEvent)
 196         {
 197                 r = __pTimeChangeEvent->RemoveListener(listener);
 198         }
 199
 200         SysTryReturn(NID_UI_CTRL, r == E_SUCCESS, r, r, "[%s] Propagating.", GetErrorMessage(r));
 201
 202         return E_SUCCESS;
 203 }
 204
 205 void
 206 _EditTime::SetTime(const DateTime& time)
 207 {
 208         SetProperty("time", Variant(time));
 209         return;
 210 }
 211
 212 result
 213 _EditTime::SetPropertyTime(const Variant& time)
 214 {
 215         SysTryReturn(NID_UI_CTRL, (__pEditTimePresenter != null), E_SYSTEM, E_SYSTEM,
 216                         "[E_SYSTEM] A system error has occurred. The _EditDatePresenter instance is null.");
 217
 218         __pEditTimePresenter->SetTime(time.ToDateTime());
 219
 220         UpdateAccessibilityElement();
 221         return E_SUCCESS;
 222 }
 223
 224 DateTime
 225 _EditTime::GetTime(void) const
 226 {
 227         Variant time = GetProperty("time");
 228
 229         return time.ToDateTime();
 230 }
 231
 232 Variant
 233 _EditTime::GetPropertyTime(void) const
 234 {
 235         DateTime time;
 236
 237         SysTryReturn(NID_UI_CTRL, (__pEditTimePresenter != null), Variant(), E_SYSTEM,
 238                         "[E_SYSTEM] A system error has occurred. The _EditDatePresenter instance is null.");
 239
 240         time = __pEditTimePresenter->GetTime();
 241
 242         return Variant(time);
 243 }
 244
 245 result
 246 _EditTime::SetHour(int hour)
 247 {
 248         result r = E_SUCCESS;
 249
 250         SetProperty("hour", Variant(hour));
 251
 252         r = GetLastResult();
 253
 254         return r;
 255 }
 256
 257 result
 258 _EditTime::SetPropertyHour(const Variant& hour)
 259 {
 260         SysTryReturn(NID_UI_CTRL, (__pEditTimePresenter != null), E_SYSTEM, E_SYSTEM,
 261                         "[E_SYSTEM] A system error has occurred. The _EditDatePresenter instance is null.");
 262
 263         result r = E_SUCCESS;
 264
 265         r = __pEditTimePresenter->SetHour(hour.ToInt());
 266         SysTryReturn(NID_UI_CTRL, (r == E_SUCCESS), r, r, "[%s] Propagating.", GetErrorMessage(r));
 267
 268         UpdateAccessibilityElement();
 269
 270         return r;
 271 }
 272
 273 int
 274 _EditTime::GetHour(void) const
 275 {
 276         Variant hour = GetProperty("hour");
 277
 278         return hour.ToInt();
 279 }
 280
 281 Variant
 282 _EditTime::GetPropertyHour(void) const
 283 {
 284         int hour = -1;
 285
 286         SysTryReturn(NID_UI_CTRL, (__pEditTimePresenter != null), Variant(), E_SYSTEM,
 287                         "[E_SYSTEM] A system error has occurred. The _EditDatePresenter instance is null.");
 288
 289         hour = __pEditTimePresenter->GetHour();
 290
 291         return Variant(hour);
 292 }
 293
 294 result
 295 _EditTime::SetMinute(int minute)
 296 {
 297         result r = E_SUCCESS;
 298
 299         SetProperty("minute", Variant(minute));
 300
 301         r = GetLastResult();
 302
 303         return r;
 304 }
 305
 306 result
 307 _EditTime::SetPropertyMinute(const Variant& minute)
 308 {
 309         SysTryReturn(NID_UI_CTRL, (__pEditTimePresenter != null), E_SYSTEM, E_SYSTEM,
 310                         "[E_SYSTEM] A system error has occurred. The _EditDatePresenter instance is null.");
 311
 312         result r = E_SUCCESS;
 313
 314         r = __pEditTimePresenter->SetMinute(minute.ToInt());
 315         SysTryReturn(NID_UI_CTRL, (r == E_SUCCESS), r, r, "[%s] Propagating.", GetErrorMessage(r));
 316
 317         UpdateAccessibilityElement();
 318
 319         return r;
 320 }
 321
 322 int
 323 _EditTime::GetMinute(void) const
 324 {
 325         Variant minute = GetProperty("minute");
 326
 327         return minute.ToInt();
 328 }
 329
 330 Variant
 331 _EditTime::GetPropertyMinute(void) const
 332 {
 333         int minute = -1;
 334
 335         SysTryReturn(NID_UI_CTRL, (__pEditTimePresenter != null), Variant(), E_SYSTEM,
 336                         "[E_SYSTEM] A system error has occurred. The _EditDatePresenter instance is null.");
 337
 338         minute = __pEditTimePresenter->GetMinute();
 339
 340         return Variant(minute);
 341 }
 342
 343 void
 344 _EditTime::SetCurrentTime(void)
 345 {
 346         SysTryReturnVoidResult(NID_UI_CTRL, (__pEditTimePresenter != null), E_SYSTEM,
 347                         "[E_SYSTEM] A system error has occurred. The _EditDatePresenter instance is null.");
 348
 349         __pEditTimePresenter->SetCurrentTime();
 350
 351         UpdateAccessibilityElement();
 352
 353         return;
 354 }
 355
 356 void
 357 _EditTime::SetTimePickerEnabled(bool enable)
 358 {
 359         SetProperty("timePickerEnabled", Variant(enable));
 360         return;
 361 }
 362
 363 result
 364 _EditTime::SetPropertyTimePickerEnabled(const Variant& enable)
 365 {
 366         SysTryReturn(NID_UI_CTRL, (__pEditTimePresenter != null), E_SYSTEM, E_SYSTEM,
 367                         "[E_SYSTEM] A system error has occurred. The _EditDatePresenter instance is null.");
 368
 369         __pEditTimePresenter->SetTimePickerEnabled(enable.ToBool());
 370
 371         return E_SUCCESS;
 372 }
 373
 374 bool
 375 _EditTime::IsTimePickerEnabled(void) const
 376 {
 377         Variant enable = GetProperty("timePickerEnabled");
 378
 379         return enable.ToBool();
 380 }
 381
 382 Variant
 383 _EditTime::GetPropertyTimePickerEnabled(void) const
 384 {
 385         bool enable = false;
 386
 387         SysTryReturn(NID_UI_CTRL, (__pEditTimePresenter != null), Variant(), E_SYSTEM,
 388                         "[E_SYSTEM] A system error has occurred. The _EditDatePresenter instance is null.");
 389
 390         enable = __pEditTimePresenter->IsTimePickerEnabled();
 391
 392         return Variant(enable);
 393 }
 394
 395 void
 396 _EditTime::Set24HourNotationEnabled(bool enable)
 397 {
 398         SysTryReturnVoidResult(NID_UI_CTRL, (__pEditTimePresenter != null), E_SYSTEM,
 399                         "[E_SYSTEM] A system error has occurred. The _EditDatePresenter instance is null.");
 400
 401         __pEditTimePresenter->Set24HourNotationEnabled(enable);
 402         return;
 403 }
 404
 405 bool
 406 _EditTime::Is24HourNotationEnabled(void) const
 407 {
 408         SysAssertf((__pEditTimePresenter != null), "The _EditDatePresenter instance is null.");
 409
 410         return __pEditTimePresenter->Is24HourNotationEnabled();
 411 }
 412
 413 result
 414 _EditTime::CalculateDateTimeBarPosition(void)
 415 {
 416         result r = E_SUCCESS;
 417
 418         float dateTimeBarHeight = 0.0f;
 419         float arrowHeight = 0.0f;
 420         float timeHeight = 0.0f;
 421         float timeBarMargin = 0.0f;
 422         float textHeight = 0.0f;
 423         float titleTimeMargin = 0.0f;
 424         float bottomPosition = 0.0f;
 425         float timeY = 0.0f;
 426
 427         FloatRectangle absoluteBounds;
 428         FloatRectangle frameBounds;
 429         FloatRectangle parentWindowBounds;
 430         FloatRectangle titleBounds;
 431
 432         _Frame* pFrame = dynamic_cast<_Frame*>(_ControlManager::GetInstance()->GetCurrentFrame());
 433         SysTryReturn(NID_UI_CTRL, (pFrame != null), E_SYSTEM, E_SYSTEM,
 434                         "[E_SYSTEM] A system error has occurred. Failed to get frame instance.");
 435
 436         frameBounds = pFrame->GetAbsoluteBoundsF();
 437         absoluteBounds = GetAbsoluteBoundsF();
 438         parentWindowBounds = GetParentWindowBounds();
 439         titleBounds = __pEditTimePresenter->GetTitleBounds();
 440
 441         GET_SHAPE_CONFIG(DATETIMEBAR::ITEM_HEIGHT, GetOrientation(), dateTimeBarHeight);
 442         GET_SHAPE_CONFIG(DATETIMEBAR::ARROW_HEIGHT, GetOrientation(), arrowHeight);
 443         GET_SHAPE_CONFIG(EDITTIME::TIME_HEIGHT, GetOrientation(), timeHeight);
 444         GET_SHAPE_CONFIG(EDITTIME::TIME_BAR_MARGIN, GetOrientation(), timeBarMargin);
 445         GET_SHAPE_CONFIG(EDITTIME::TITLE_HEIGHT, GetOrientation(), textHeight);
 446         GET_SHAPE_CONFIG(EDITTIME::TITLE_TIME_MARGIN, GetOrientation(), titleTimeMargin);
 447
 448         if (!__title.IsEmpty()) //with title
 449         {
 450                 timeY = titleBounds.y + textHeight + titleTimeMargin ;
 451         }
 452         else //without title
 453         {
 454                 timeY = (absoluteBounds.height - timeHeight) / 2.0f ;
 455         }
 456
 457         bottomPosition = absoluteBounds.y + timeY + timeHeight + timeBarMargin + arrowHeight + dateTimeBarHeight;
 458
 459         GetDateTimeBar()->SetParentWindowBounds(parentWindowBounds);
 460
 461         if (bottomPosition > frameBounds.y + parentWindowBounds.y + parentWindowBounds.height) //ALIGN_UP
 462         {
 463                 r = GetDateTimeBar()->SetPositionAndAlignment(FloatPoint(parentWindowBounds.x, absoluteBounds.y + timeY - timeBarMargin - arrowHeight), DATETIME_BAR_ALIGN_UP);
 464                 SysTryReturn(NID_UI_CTRL, r == E_SUCCESS, r, r, "[%s] Propagating.", GetErrorMessage(r));
 465         }
 466         else    //ALIGN_DOWN
 467         {
 468                 r = GetDateTimeBar()->SetPositionAndAlignment(FloatPoint(parentWindowBounds.x, absoluteBounds.y + timeY + timeHeight + timeBarMargin + arrowHeight), DATETIME_BAR_ALIGN_DOWN);
 469                 SysTryReturn(NID_UI_CTRL, r == E_SUCCESS, r, r, "[%s] Propagating.", GetErrorMessage(r));
 470         }
 471
 472         __absoluteBounds = absoluteBounds;
 473
 474         return r;
 475 }
 476
 477 void
 478 _EditTime::OnDraw(void)
 479 {
 480         if (GetDateTimeBar() != null && GetDateTimeBar()->IsActivated())
 481         {
 482                 CalculateDateTimeBarPosition();
 483         }
 484
 485         __pEditTimePresenter->Draw();
 486         if(likely((_AccessibilityManager::IsActivated())))
 487         {
 488                 UpdateAccessibilityElement();
 489         }
 490         return;
 491 }
 492
 493 void
 494 _EditTime::CreateAccessibilityElement(void)
 495 {
 496         _AccessibilityContainer* pContainer = GetAccessibilityContainer();
 497         FloatRectangle hourBounds = __pEditTimePresenter->GetDisplayAreaBoundsFromHoursStyle(DATETIME_ID_HOUR);
 498         FloatRectangle minuteBounds = __pEditTimePresenter->GetDisplayAreaBoundsFromHoursStyle(DATETIME_ID_MINUTE);
 499         FloatRectangle ampmBounds = __pEditTimePresenter->GetDisplayAreaBoundsFromHoursStyle(DATETIME_ID_AMPM);
 500
 501         pContainer->AddListener(*this);
 502         if (__pAccessibilityEditTimeElement == null)
 503         {
 504                 __pAccessibilityEditTimeElement = new _AccessibilityElement(true);
 505                 __pAccessibilityEditTimeElement->SetBounds(GetClientBounds());
 506                 __pAccessibilityEditTimeElement->SetTrait(ACCESSIBILITY_TRAITS_NONE);
 507                 __pAccessibilityEditTimeElement->SetName(L"EditTimeText");
 508                 pContainer->AddElement(*__pAccessibilityEditTimeElement);
 509         }
 510
 511         if (__pAccessibilityHourElement == null && __pAccessibilityMinuteElement == null)
 512         {
 513                 String hintText(L"Double tap to edit");
 514
 515                 __pAccessibilityHourElement = new _AccessibilityElement(true);
 516                 __pAccessibilityHourElement->SetBounds(hourBounds);
 517                 __pAccessibilityHourElement->SetTrait(ACCESSIBILITY_TRAITS_HOUR);
 518                 __pAccessibilityHourElement->SetHint(hintText);
 519                 pContainer->AddElement(*__pAccessibilityHourElement);
 520
 521                 __pAccessibilityMinuteElement = new _AccessibilityElement(true);
 522                 __pAccessibilityMinuteElement->SetBounds(minuteBounds);
 523                 __pAccessibilityMinuteElement->SetTrait(ACCESSIBILITY_TRAITS_MINUTE);
 524                 __pAccessibilityMinuteElement->SetHint(hintText);
 525                 pContainer->AddElement(*__pAccessibilityMinuteElement);
 526
 527                 if (Is24HourNotationEnabled() == false)
 528                 {
 529                         __pAccessibilityAmPmElement = new _AccessibilityElement(true);
 530                         __pAccessibilityAmPmElement->SetBounds(ampmBounds);
 531                         __pAccessibilityAmPmElement->SetTrait(ACCESSIBILITY_TRAITS_BUTTON);
 532                         pContainer->AddElement(*__pAccessibilityAmPmElement);
 533                 }
 534         }
 535 }
 536
 537 void
 538 _EditTime::OnBoundsChanged(void)
 539 {
 540         FloatDimension newSize = GetSizeF();
 541
 542         if (newSize.width != __previousSize.width || newSize.height != __previousSize.height)
 543         {
 544                 __isCalledBoundsChanged = true;
 545         }
 546
 547         __pEditTimePresenter->Initialize();
 548
 549         if (__pAccessibilityEditTimeElement)
 550         {
 551                 __pAccessibilityEditTimeElement->SetBounds(__pEditTimePresenter->GetTitleBounds());
 552         }
 553         if (__pAccessibilityHourElement)
 554         {
 555                 __pAccessibilityHourElement->SetBounds(__pEditTimePresenter->GetDisplayAreaBoundsFromHoursStyle(DATETIME_ID_HOUR));
 556         }
 557         if (__pAccessibilityMinuteElement)
 558         {
 559                 __pAccessibilityMinuteElement->SetBounds(__pEditTimePresenter->GetDisplayAreaBoundsFromHoursStyle(DATETIME_ID_MINUTE));
 560         }
 561         if (__pAccessibilityAmPmElement)
 562         {
 563                 __pAccessibilityAmPmElement->SetBounds(__pEditTimePresenter->GetDisplayAreaBoundsFromHoursStyle(DATETIME_ID_AMPM));
 564         }
 565
 566         return;
 567 }
 568
 569 void
 570 _EditTime::OnChangeLayout(_ControlOrientation orientation)
 571 {
 572         if (!__isCalledBoundsChanged && !__isXmlBoundsExist)
 573         {
 574                 FloatDimension dim;
 575
 576                 GET_SHAPE_CONFIG(EDITTIME::WIDTH, GetOrientation(), dim.width);
 577                 GET_SHAPE_CONFIG(EDITTIME::HEIGHT, GetOrientation(), dim.height);
 578
 579                 SetSize(dim);
 580         }
 581
 582         __pEditTimePresenter->Initialize();
 583         __pEditTimePresenter->SetLastSelectedId(DATETIME_ID_NONE);
 584
 585         if (GetDateTimeBar() != null)
 586         {
 587                 GetDateTimeBar()->SetVisibleState(false);
 588                 GetDateTimeBar()->Close();
 589         }
 590
 591         return;
 592 }
 593
 594 bool
 595 _EditTime::OnTouchPressed(const _Control& source, const _TouchInfo& touchinfo)
 596 {
 597         SetFocused(true);
 598
 599         FloatRectangle absoluteBounds = GetAbsoluteBoundsF();
 600         if (absoluteBounds.y != __absoluteBounds.y || absoluteBounds.height != __absoluteBounds.height)
 601         {
 602                 CalculateDateTimeBarPosition();
 603         }
 604
 605         return __pEditTimePresenter->OnTouchPressed(source, touchinfo);
 606 }
 607
 608 bool
 609 _EditTime::OnTouchReleased(const _Control& source, const _TouchInfo& touchinfo)
 610 {
 611         return __pEditTimePresenter->OnTouchReleased(source, touchinfo);
 612 }
 613
 614 bool
 615 _EditTime::OnTouchCanceled(const _Control& source, const _TouchInfo& touchinfo)
 616 {
 617         return __pEditTimePresenter->OnTouchCanceled(source, touchinfo);
 618 }
 619
 620 bool
 621 _EditTime::OnTouchMoved(const _Control& source, const _TouchInfo& touchinfo)
 622 {
 623         return __pEditTimePresenter->OnTouchMoved(source, touchinfo);
 624 }
 625
 626 void
 627 _EditTime::OnTouchMoveHandled(const _Control& control)
 628 {
 629         __pEditTimePresenter->OnTouchMoveHandled(control);
 630         return;
 631 }
 632
 633 result
 634 _EditTime::FireTimeChangeEvent(_DateTimeChangeStatus status)
 635 {
 636         SysTryReturn(NID_UI_CTRL, (__pTimeChangeEvent != null), E_SYSTEM, E_SYSTEM,
 637                         "[E_SYSTEM] A system error has occurred. The _DateTimeChangeEvent instance is null.");
 638
 639         _DateTimeChangeEventArg* pDateTimeEventArg = new (std::nothrow) _DateTimeChangeEventArg(status);
 640         SysTryReturn(NID_UI_CTRL, pDateTimeEventArg, E_OUT_OF_MEMORY, E_OUT_OF_MEMORY,
 641                         "[E_OUT_OF_MEMORY] Memory allocation failed.");
 642
 643         pDateTimeEventArg->SetTime(GetHour(), GetMinute());
 644
 645         __pTimeChangeEvent->Fire(*pDateTimeEventArg);
 646
 647         return E_SUCCESS;
 648 }
 649
 650 void
 651 _EditTime::OnDateTimeChanged(const _Control& source, int year, int month, int day, int hour, int minute)
 652 {
 653         __pEditTimePresenter->Animate();
 654         __pEditTimePresenter->SetLastSelectedId(DATETIME_ID_NONE);
 655         Invalidate();
 656         FireTimeChangeEvent(TIME_INTERNAL_CHANGE_SAVED);
 657         return;
 658 }
 659
 660 void
 661 _EditTime::OnDateTimeChangeCanceled(const _Control& source)
 662 {
 663         __pEditTimePresenter->SetLastSelectedId(DATETIME_ID_NONE);
 664         Invalidate();
 665         FireTimeChangeEvent(TIME_INTERNAL_CHANGE_CANCELED);
 666         return;
 667 }
 668
 669 void
 670 _EditTime::OnActionPerformed(const Ui::_Control& source, int actionId)
 671 {
 672         _DateTimeId boxId = __pEditTimePresenter->GetLastSelectedId();
 673
 674         if (boxId == DATETIME_ID_HOUR)
 675         {
 676                 bool amEnable = true;
 677                 amEnable = __pEditTimePresenter->GetAmEnabled();
 678
 679                 int hour = 0;
 680                 hour = actionId;
 681                 if (amEnable == false && Is24HourNotationEnabled() == false)
 682                 {
 683                         if (hour < DATETIME_HOUR_MAX_FOR_24NOTATION)
 684                         {
 685                                 hour += DATETIME_HOUR_MAX_FOR_24NOTATION;
 686                         }
 687                 }
 688                 else if (amEnable == true && Is24HourNotationEnabled() == false)
 689                 {
 690                         if (hour == DATETIME_HOUR_MAX_FOR_24NOTATION)
 691                         {
 692                                 hour = DATETIME_HOUR_MIN;
 693                         }
 694                 }
 695                 SetHour(hour);
 696         }
 697         else if (boxId == DATETIME_ID_MINUTE)
 698         {
 699                 SetMinute(actionId);
 700         }
 701
 702         Invalidate();
 703         return;
 704 }
 705
 706 _DateTimeBar*
 707 _EditTime::GetDateTimeBar(void) const
 708 {
 709         return __pDateTimeBar;
 710 }
 711
 712 void
 713 _EditTime::OnFontChanged(Font* pFont)
 714 {
 715         __pEditTimePresenter->OnFontChanged(pFont);
 716
 717         return;
 718 }
 719
 720 void
 721 _EditTime::OnFontInfoRequested(unsigned long& style, float& size)
 722 {
 723         __pEditTimePresenter->OnFontInfoRequested(style, size);
 724
 725         return;
 726 }
 727
 728 void
 729 _EditTime::OnSettingChanged(String& key)
 730 {
 731         if (key.Equals(L"http://tizen.org/setting/locale.time.format.24hour", false))
 732         {
 733                 __pEditTimePresenter->UpdateTimeFormat();
 734                 __pEditTimePresenter->SetLastSelectedId(DATETIME_ID_NONE);
 735
 736                 if (GetDateTimeBar() != null)
 737                 {
 738                         GetDateTimeBar()->SetVisibleState(false);
 739                         GetDateTimeBar()->Close();
 740                 }
 741
 742                 Invalidate();
 743         }
 744
 745         return;
 746 }
 747
 748 FloatRectangle
 749 _EditTime::GetParentWindowBounds(void) const
 750 {
 751         _Form* pForm = null;
 752         _Window* pwindow = null;
 753         _Control* pControlCore = GetParent();
 754
 755         FloatDimension dateTimeBarSize(0.0f, 0.0f);
 756
 757         GET_DIMENSION_CONFIG(DATETIMEBAR::DEFAULT_SIZE, GetOrientation(), dateTimeBarSize);
 758
 759         FloatRectangle parentWindowBounds(0.0f, 0.0f, dateTimeBarSize.width, dateTimeBarSize.height);
 760
 761         while (true)
 762         {
 763                 if (pControlCore == null)
 764                 {
 765                         SysLog(NID_UI_CTRL,"[E_SYSTEM] Parent window not found.");
 766
 767                         return parentWindowBounds;
 768                 }
 769
 770                 // If the parent is a Frame, then return the Form's bounds.
 771                 pForm = dynamic_cast<_Form*>(pControlCore);
 772                 if (pForm != null)
 773                 {
 774                         parentWindowBounds = pForm->GetBoundsF();
 775                         break;
 776                 }
 777
 778                 pwindow = dynamic_cast<_Window*>(pControlCore);
 779
 780                 if (pwindow != null)
 781                 {
 782                         parentWindowBounds = pwindow->GetBoundsF();
 783                         break;
 784                 }
 785
 786                 pControlCore = pControlCore->GetParent();
 787         }
 788
 789         return parentWindowBounds;
 790 }
 791
 792 void
 793 _EditTime::SetXmlBoundsExist(bool isXmlBoundsExist)
 794 {
 795         __isXmlBoundsExist = isXmlBoundsExist;
 796 }
 797
 798 void
 799 _EditTime::UpdateAccessibilityElement(void)
 800 {
 801         String string;
 802
 803         if (__pAccessibilityEditTimeElement == null && __pAccessibilityHourElement == null
 804                         && __pAccessibilityMinuteElement == null && __pAccessibilityAmPmElement == null)
 805         {
 806                 return;
 807         }
 808
 809         if (__title.IsEmpty() == false)
 810         {
 811                 string.Append(__title);
 812                 string.Append(L", ");
 813         }
 814
 815         String hourString;
 816         int hour =  GetHour();
 817         int maxHour = DATETIME_HOUR_MAX_FOR_24NOTATION;
 818
 819         if (Is24HourNotationEnabled() == false && (hour > maxHour))
 820         {
 821                 hourString.Format(10, L"%02d", hour - DATETIME_HOUR_MAX_FOR_24NOTATION);
 822         }
 823         else
 824         {
 825                 hourString.Format(10, L"%02d", hour);
 826         }
 827
 828         string.Append(hourString.GetPointer());
 829         string.Append(L":");
 830         string.Append(GetMinute());
 831         string.Append(L" ");
 832
 833         if (Is24HourNotationEnabled() == false)
 834         {
 835                 String hintAmPmText(L"Double tap to change to ");
 836
 837                 String amString;
 838                 String pmString;
 839                 _DateTimeUtils dateTimeUtils;
 840                 dateTimeUtils.GetAmPm(amString, AM_TYPE);
 841                 dateTimeUtils.GetAmPm(pmString, PM_TYPE);
 842
 843                 if (__pEditTimePresenter->GetAmEnabled() == true)
 844                 {
 845                         __pAccessibilityAmPmElement->SetLabel(amString);
 846                         hintAmPmText.Append(pmString.GetPointer());
 847                         string.Append(amString.GetPointer());
 848                 }
 849                 else
 850                 {
 851                         __pAccessibilityAmPmElement->SetLabel(pmString);
 852                         hintAmPmText.Append(amString.GetPointer());
 853                         string.Append(pmString.GetPointer());
 854                 }
 855
 856                 __pAccessibilityAmPmElement->SetHint(hintAmPmText);
 857         }
 858
 859         __pAccessibilityEditTimeElement->SetLabel(string);
 860
 861         __pAccessibilityHourElement->SetLabel(hourString);
 862
 863         string.Clear();
 864         string.Format(10, L"%02d", GetMinute());
 865         __pAccessibilityMinuteElement->SetLabel(string);
 866
 867         return;
 868 }
 869
 870 bool
 871 _EditTime::OnAccessibilityFocusMovedNext(const _AccessibilityContainer& control, const _AccessibilityElement& element)
 872 {
 873         return false;
 874 }
 875
 876 bool
 877 _EditTime::OnAccessibilityFocusMovedPrevious(const _AccessibilityContainer& control, const _AccessibilityElement& element)
 878 {
 879         return false;
 880 }
 881
 882 bool
 883 _EditTime::OnAccessibilityReadingElement(const _AccessibilityContainer& control, const _AccessibilityElement& element)
 884 {
 885         return false;
 886 }
 887
 888 bool
 889 _EditTime::OnAccessibilityReadedElement(const _AccessibilityContainer& control, const _AccessibilityElement& element)
 890 {
 891         return false;
 892 }
 893
 894
 895 bool
 896 _EditTime::OnAccessibilityFocusIn(const _AccessibilityContainer& control, const _AccessibilityElement& element)
 897 {
 898         return false;
 899 }
 900
 901 bool
 902 _EditTime::OnAccessibilityFocusOut(const _AccessibilityContainer& control, const _AccessibilityElement& element)
 903 {
 904         return false;
 905 }
 906
 907 bool
 908 _EditTime::OnAccessibilityActionPerformed(const _AccessibilityContainer& control, const _AccessibilityElement& element)
 909 {
 910         String amString;
 911         String pmString;
 912         String labelText;
 913
 914         labelText = element.GetLabel();
 915
 916         _DateTimeUtils dateTimeUtils;
 917         dateTimeUtils.GetAmPm(amString, AM_TYPE);
 918         dateTimeUtils.GetAmPm(pmString, PM_TYPE);
 919
 920         if (labelText == amString || labelText == pmString)
 921         {
 922                 labelText.Append(L" Selected");
 923                 _AccessibilityManager::GetInstance()->ReadContent(labelText);
 924         }
 925
 926         return true;
 927 }
 928
 929 bool
 930 _EditTime::OnAccessibilityValueIncreased(const _AccessibilityContainer&, const _AccessibilityElement&)
 931 {
 932         return false;
 933 }
 934
 935 bool
 936 _EditTime::OnAccessibilityValueDecreased(const _AccessibilityContainer&, const _AccessibilityElement&)
 937 {
 938         return false;
 939 }
 940
 941 }}} // Controls