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