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         , __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                 GetDateTimeBar()->SetVisibleState(false);
 570                 GetDateTimeBar()->Close();
 571         }
 572
 573         return;
 574 }
 575
 576 bool
 577 _EditTime::OnTouchPressed(const _Control& source, const _TouchInfo& touchinfo)
 578 {
 579         SetFocused(true);
 580
 581         FloatRectangle absoluteBounds = GetAbsoluteBoundsF();
 582         if (absoluteBounds.y != __absoluteBounds.y || absoluteBounds.height != __absoluteBounds.height)
 583         {
 584                 CalculateDateTimeBarPosition();
 585         }
 586
 587         return __pEditTimePresenter->OnTouchPressed(source, touchinfo);
 588 }
 589
 590 bool
 591 _EditTime::OnTouchReleased(const _Control& source, const _TouchInfo& touchinfo)
 592 {
 593         return __pEditTimePresenter->OnTouchReleased(source, touchinfo);
 594 }
 595
 596 bool
 597 _EditTime::OnTouchCanceled(const _Control& source, const _TouchInfo& touchinfo)
 598 {
 599         return __pEditTimePresenter->OnTouchCanceled(source, touchinfo);
 600 }
 601
 602 bool
 603 _EditTime::OnTouchMoved(const _Control& source, const _TouchInfo& touchinfo)
 604 {
 605         return __pEditTimePresenter->OnTouchMoved(source, touchinfo);
 606 }
 607
 608 void
 609 _EditTime::OnTouchMoveHandled(const _Control& control)
 610 {
 611         __pEditTimePresenter->OnTouchMoveHandled(control);
 612         return;
 613 }
 614
 615 result
 616 _EditTime::FireTimeChangeEvent(_DateTimeChangeStatus status)
 617 {
 618         SysTryReturn(NID_UI_CTRL, (__pTimeChangeEvent != null), E_SYSTEM, E_SYSTEM,
 619                         "[E_SYSTEM] A system error has occurred. The _DateTimeChangeEvent instance is null.");
 620
 621         _DateTimeChangeEventArg* pDateTimeEventArg = new (std::nothrow) _DateTimeChangeEventArg(status);
 622         SysTryReturn(NID_UI_CTRL, pDateTimeEventArg, E_OUT_OF_MEMORY, E_OUT_OF_MEMORY,
 623                         "[E_OUT_OF_MEMORY] Memory allocation failed.");
 624
 625         pDateTimeEventArg->SetTime(GetHour(), GetMinute());
 626
 627         __pTimeChangeEvent->Fire(*pDateTimeEventArg);
 628
 629         return E_SUCCESS;
 630 }
 631
 632 void
 633 _EditTime::OnDateTimeChanged(const _Control& source, int year, int month, int day, int hour, int minute)
 634 {
 635         __pEditTimePresenter->Animate();
 636         __pEditTimePresenter->SetLastSelectedId(DATETIME_ID_NONE);
 637         Invalidate();
 638         FireTimeChangeEvent(TIME_INTERNAL_CHANGE_SAVED);
 639         return;
 640 }
 641
 642 void
 643 _EditTime::OnDateTimeChangeCanceled(const _Control& source)
 644 {
 645         __pEditTimePresenter->SetLastSelectedId(DATETIME_ID_NONE);
 646         Invalidate();
 647         FireTimeChangeEvent(TIME_INTERNAL_CHANGE_CANCELED);
 648         return;
 649 }
 650
 651 void
 652 _EditTime::OnActionPerformed(const Ui::_Control& source, int actionId)
 653 {
 654         _DateTimeId boxId = __pEditTimePresenter->GetLastSelectedId();
 655
 656         if (boxId == DATETIME_ID_HOUR)
 657         {
 658                 bool amEnable = true;
 659                 amEnable = __pEditTimePresenter->GetAmEnabled();
 660
 661                 int hour = 0;
 662                 hour = actionId;
 663                 if (amEnable == false && Is24HourNotationEnabled() == false)
 664                 {
 665                         if (hour < DATETIME_HOUR_MAX_FOR_24NOTATION)
 666                         {
 667                                 hour += DATETIME_HOUR_MAX_FOR_24NOTATION;
 668                         }
 669                 }
 670                 else if (amEnable == true && Is24HourNotationEnabled() == false)
 671                 {
 672                         if (hour == DATETIME_HOUR_MAX_FOR_24NOTATION)
 673                         {
 674                                 hour = DATETIME_HOUR_MIN;
 675                         }
 676                 }
 677                 SetHour(hour);
 678         }
 679         else if (boxId == DATETIME_ID_MINUTE)
 680         {
 681                 SetMinute(actionId);
 682         }
 683
 684         Invalidate();
 685         return;
 686 }
 687
 688 _DateTimeBar*
 689 _EditTime::GetDateTimeBar(void) const
 690 {
 691         return __pDateTimeBar;
 692 }
 693
 694 void
 695 _EditTime::OnFontChanged(Font* pFont)
 696 {
 697         __pEditTimePresenter->OnFontChanged(pFont);
 698
 699         return;
 700 }
 701
 702 void
 703 _EditTime::OnFontInfoRequested(unsigned long& style, float& size)
 704 {
 705         __pEditTimePresenter->OnFontInfoRequested(style, size);
 706
 707         return;
 708 }
 709
 710 void
 711 _EditTime::OnSettingChanged(String& key)
 712 {
 713         if (key.Equals(L"http://tizen.org/setting/locale.time.format.24hour", false))
 714         {
 715                 __pEditTimePresenter->UpdateTimeFormat();
 716                 __pEditTimePresenter->SetLastSelectedId(DATETIME_ID_NONE);
 717
 718                 if (GetDateTimeBar() != null)
 719                 {
 720                         GetDateTimeBar()->SetVisibleState(false);
 721                         GetDateTimeBar()->Close();
 722                 }
 723
 724                 Invalidate();
 725         }
 726
 727         return;
 728 }
 729
 730 FloatRectangle
 731 _EditTime::GetParentWindowBounds(void) const
 732 {
 733         _Form* pForm = null;
 734         _Window* pwindow = null;
 735         _Control* pControlCore = GetParent();
 736
 737         FloatDimension dateTimeBarSize(0.0f, 0.0f);
 738
 739         GET_DIMENSION_CONFIG(DATETIMEBAR::DEFAULT_SIZE, GetOrientation(), dateTimeBarSize);
 740
 741         FloatRectangle parentWindowBounds(0.0f, 0.0f, dateTimeBarSize.width, dateTimeBarSize.height);
 742
 743         while (true)
 744         {
 745                 if (pControlCore == null)
 746                 {
 747                         SysLog(NID_UI_CTRL,"[E_SYSTEM] Parent window not found.");
 748
 749                         return parentWindowBounds;
 750                 }
 751
 752                 // If the parent is a Frame, then return the Form's bounds.
 753                 pForm = dynamic_cast<_Form*>(pControlCore);
 754                 if (pForm != null)
 755                 {
 756                         parentWindowBounds = pForm->GetBoundsF();
 757                         break;
 758                 }
 759
 760                 pwindow = dynamic_cast<_Window*>(pControlCore);
 761
 762                 if (pwindow != null)
 763                 {
 764                         parentWindowBounds = pwindow->GetBoundsF();
 765                         break;
 766                 }
 767
 768                 pControlCore = pControlCore->GetParent();
 769         }
 770
 771         return parentWindowBounds;
 772 }
 773
 774 void
 775 _EditTime::UpdateAccessibilityElement(void)
 776 {
 777         String string;
 778
 779         if (likely(!(_AccessibilityManager::IsActivated())))
 780         {
 781                 return;
 782         }
 783
 784         if (__pAccessibilityEditTimeElement == null && __pAccessibilityHourElement == null
 785                         && __pAccessibilityMinuteElement == null && __pAccessibilityAmPmElement == null)
 786         {
 787                 return;
 788         }
 789
 790         if (__title.IsEmpty() == false)
 791         {
 792                 string.Append(__title);
 793                 string.Append(L", ");
 794         }
 795
 796         String hourString;
 797         int hour =  GetHour();
 798         int maxHour = DATETIME_HOUR_MAX_FOR_24NOTATION;
 799
 800         if (Is24HourNotationEnabled() == false && (hour > maxHour))
 801         {
 802                 hourString.Format(10, L"%02d", hour - DATETIME_HOUR_MAX_FOR_24NOTATION);
 803         }
 804         else
 805         {
 806                 hourString.Format(10, L"%02d", hour);
 807         }
 808
 809         string.Append(hourString.GetPointer());
 810         string.Append(L":");
 811         string.Append(GetMinute());
 812         string.Append(L" ");
 813
 814         if (Is24HourNotationEnabled() == false)
 815         {
 816                 String hintAmPmText(L"Double tap to change to ");
 817
 818                 String amString;
 819                 String pmString;
 820                 _DateTimeUtils dateTimeUtils;
 821                 dateTimeUtils.GetAmPm(amString, AM_TYPE);
 822                 dateTimeUtils.GetAmPm(pmString, PM_TYPE);
 823
 824                 if (__pEditTimePresenter->GetAmEnabled() == true)
 825                 {
 826                         __pAccessibilityAmPmElement->SetLabel(amString);
 827                         hintAmPmText.Append(pmString.GetPointer());
 828                         string.Append(amString.GetPointer());
 829                 }
 830                 else
 831                 {
 832                         __pAccessibilityAmPmElement->SetLabel(pmString);
 833                         hintAmPmText.Append(amString.GetPointer());
 834                         string.Append(pmString.GetPointer());
 835                 }
 836
 837                 __pAccessibilityAmPmElement->SetHint(hintAmPmText);
 838         }
 839
 840         __pAccessibilityEditTimeElement->SetLabel(string);
 841
 842         __pAccessibilityHourElement->SetLabel(hourString);
 843
 844         string.Clear();
 845         string.Format(10, L"%02d", GetMinute());
 846         __pAccessibilityMinuteElement->SetLabel(string);
 847
 848         return;
 849 }
 850
 851 bool
 852 _EditTime::OnAccessibilityFocusMovedNext(const _AccessibilityContainer& control, const _AccessibilityElement& element)
 853 {
 854         return false;
 855 }
 856
 857 bool
 858 _EditTime::OnAccessibilityFocusMovedPrevious(const _AccessibilityContainer& control, const _AccessibilityElement& element)
 859 {
 860         return false;
 861 }
 862
 863 bool
 864 _EditTime::OnAccessibilityReadingElement(const _AccessibilityContainer& control, const _AccessibilityElement& element)
 865 {
 866         return false;
 867 }
 868
 869 bool
 870 _EditTime::OnAccessibilityReadedElement(const _AccessibilityContainer& control, const _AccessibilityElement& element)
 871 {
 872         return false;
 873 }
 874
 875
 876 bool
 877 _EditTime::OnAccessibilityFocusIn(const _AccessibilityContainer& control, const _AccessibilityElement& element)
 878 {
 879         return false;
 880 }
 881
 882 bool
 883 _EditTime::OnAccessibilityFocusOut(const _AccessibilityContainer& control, const _AccessibilityElement& element)
 884 {
 885         return false;
 886 }
 887
 888 bool
 889 _EditTime::OnAccessibilityActionPerformed(const _AccessibilityContainer& control, const _AccessibilityElement& element)
 890 {
 891         String amString;
 892         String pmString;
 893         String labelText;
 894
 895         labelText = element.GetLabel();
 896
 897         _DateTimeUtils dateTimeUtils;
 898         dateTimeUtils.GetAmPm(amString, AM_TYPE);
 899         dateTimeUtils.GetAmPm(pmString, PM_TYPE);
 900
 901         if (labelText == amString || labelText == pmString)
 902         {
 903                 labelText.Append(L" Selected");
 904                 _AccessibilityManager::GetInstance()->ReadContent(labelText);
 905         }
 906
 907         return true;
 908 }
 909
 910 bool
 911 _EditTime::OnAccessibilityValueIncreased(const _AccessibilityContainer&, const _AccessibilityElement&)
 912 {
 913         return false;
 914 }
 915
 916 bool
 917 _EditTime::OnAccessibilityValueDecreased(const _AccessibilityContainer&, const _AccessibilityElement&)
 918 {
 919         return false;
 920 }
 921
 922 }}} // Controls