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