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         SetFocused(true);
 581
 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         Invalidate();
 637         FireTimeChangeEvent(TIME_INTERNAL_CHANGE_SAVED);
 638         return;
 639 }
 640
 641 void
 642 _EditTime::OnDateTimeChangeCanceled(const _Control& source)
 643 {
 644         Invalidate();
 645
 646         FireTimeChangeEvent(TIME_INTERNAL_CHANGE_CANCELED);
 647         return;
 648 }
 649
 650 void
 651 _EditTime::OnActionPerformed(const Ui::_Control& source, int actionId)
 652 {
 653         _DateTimeId boxId = __pEditTimePresenter->GetLastSelectedId();
 654
 655         if (boxId == DATETIME_ID_HOUR)
 656         {
 657                 bool amEnable = true;
 658                 amEnable = __pEditTimePresenter->GetAmEnabled();
 659
 660                 int hour = 0;
 661                 hour = actionId;
 662                 if (amEnable == false && Is24HourNotationEnabled() == false)
 663                 {
 664                         if (hour < DATETIME_HOUR_MAX_FOR_24NOTATION)
 665                         {
 666                                 hour += DATETIME_HOUR_MAX_FOR_24NOTATION;
 667                         }
 668                 }
 669                 else if (amEnable == true && Is24HourNotationEnabled() == false)
 670                 {
 671                         if (hour == DATETIME_HOUR_MAX_FOR_24NOTATION)
 672                         {
 673                                 hour = DATETIME_HOUR_MIN;
 674                         }
 675                 }
 676                 SetHour(hour);
 677         }
 678         else if (boxId == DATETIME_ID_MINUTE)
 679         {
 680                 SetMinute(actionId);
 681         }
 682
 683         Invalidate();
 684         return;
 685 }
 686
 687 _DateTimeBar*
 688 _EditTime::GetDateTimeBar(void) const
 689 {
 690         return __pDateTimeBar;
 691 }
 692
 693 void
 694 _EditTime::OnFontChanged(Font* pFont)
 695 {
 696         __pEditTimePresenter->OnFontChanged(pFont);
 697
 698         return;
 699 }
 700
 701 void
 702 _EditTime::OnFontInfoRequested(unsigned long& style, float& size)
 703 {
 704         __pEditTimePresenter->OnFontInfoRequested(style, size);
 705
 706         return;
 707 }
 708
 709 void
 710 _EditTime::OnSettingChanged(String& key)
 711 {
 712         if (key.Equals(L"http://tizen.org/setting/locale.time.format.24hour", false))
 713         {
 714                 __pEditTimePresenter->UpdateTimeFormat();
 715                 Invalidate();
 716         }
 717
 718         return;
 719 }
 720
 721 FloatRectangle
 722 _EditTime::GetParentWindowBounds(void) const
 723 {
 724         _Form* pForm = null;
 725         _Window* pwindow = null;
 726         _Control* pControlCore = GetParent();
 727
 728         FloatDimension dateTimeBarSize(0.0f, 0.0f);
 729
 730         GET_DIMENSION_CONFIG(DATETIMEBAR::DEFAULT_SIZE, GetOrientation(), dateTimeBarSize);
 731
 732         FloatRectangle parentWindowBounds(0.0f, 0.0f, dateTimeBarSize.width, dateTimeBarSize.height);
 733
 734         while (true)
 735         {
 736                 if (pControlCore == null)
 737                 {
 738                         SysLog(NID_UI_CTRL,"[E_SYSTEM] Parent window not found.");
 739
 740                         return parentWindowBounds;
 741                 }
 742
 743                 // If the parent is a Frame, then return the Form's bounds.
 744                 pForm = dynamic_cast<_Form*>(pControlCore);
 745                 if (pForm != null)
 746                 {
 747                         parentWindowBounds = pForm->GetBoundsF();
 748                         break;
 749                 }
 750
 751                 pwindow = dynamic_cast<_Window*>(pControlCore);
 752
 753                 if (pwindow != null)
 754                 {
 755                         parentWindowBounds = pwindow->GetBoundsF();
 756                         break;
 757                 }
 758
 759                 pControlCore = pControlCore->GetParent();
 760         }
 761
 762         return parentWindowBounds;
 763 }
 764
 765 void
 766 _EditTime::UpdateAccessibilityElement(void)
 767 {
 768         String string;
 769
 770         if (likely(!(_AccessibilityManager::IsActivated())))
 771         {
 772                 return;
 773         }
 774
 775         if (__pAccessibilityEditTimeElement == null && __pAccessibilityHourElement == null
 776                         && __pAccessibilityMinuteElement == null && __pAccessibilityAmPmElement == null)
 777         {
 778                 return;
 779         }
 780
 781         if (__title.IsEmpty() == false)
 782         {
 783                 string.Append(__title);
 784                 string.Append(L", ");
 785         }
 786
 787         String hourString;
 788         int hour =  GetHour();
 789         int maxHour = DATETIME_HOUR_MAX_FOR_24NOTATION;
 790
 791         if (Is24HourNotationEnabled() == false && (hour > maxHour))
 792         {
 793                 hourString.Format(10, L"%02d", hour - DATETIME_HOUR_MAX_FOR_24NOTATION);
 794         }
 795         else
 796         {
 797                 hourString.Format(10, L"%02d", hour);
 798         }
 799
 800         string.Append(hourString.GetPointer());
 801         string.Append(L":");
 802         string.Append(GetMinute());
 803         string.Append(L" ");
 804
 805         if (Is24HourNotationEnabled() == false)
 806         {
 807                 String hintAmPmText(L"Double tap to change to ");
 808                 String amString;
 809                 String pmString;
 810                 GET_STRING_CONFIG(IDS_COM_BODY_AM, amString);
 811                 GET_STRING_CONFIG(IDS_COM_POP_PM, pmString);
 812
 813                 if (__pEditTimePresenter->GetAmEnabled() == true)
 814                 {
 815                         __pAccessibilityAmPmElement->SetLabel(amString);
 816                         hintAmPmText.Append(pmString.GetPointer());
 817                         string.Append(amString.GetPointer());
 818                 }
 819                 else
 820                 {
 821                         __pAccessibilityAmPmElement->SetLabel(pmString);
 822                         hintAmPmText.Append(amString.GetPointer());
 823                         string.Append(pmString.GetPointer());
 824                 }
 825
 826                 __pAccessibilityAmPmElement->SetHint(hintAmPmText);
 827         }
 828
 829         __pAccessibilityEditTimeElement->SetLabel(string);
 830
 831         __pAccessibilityHourElement->SetLabel(hourString);
 832
 833         string.Clear();
 834         string.Format(10, L"%02d", GetMinute());
 835         __pAccessibilityMinuteElement->SetLabel(string);
 836
 837         return;
 838 }
 839
 840 bool
 841 _EditTime::OnAccessibilityFocusMovedNext(const _AccessibilityContainer& control, const _AccessibilityElement& element)
 842 {
 843         return false;
 844 }
 845
 846 bool
 847 _EditTime::OnAccessibilityFocusMovedPrevious(const _AccessibilityContainer& control, const _AccessibilityElement& element)
 848 {
 849         return false;
 850 }
 851
 852 bool
 853 _EditTime::OnAccessibilityReadingElement(const _AccessibilityContainer& control, const _AccessibilityElement& element)
 854 {
 855         return false;
 856 }
 857
 858 bool
 859 _EditTime::OnAccessibilityReadedElement(const _AccessibilityContainer& control, const _AccessibilityElement& element)
 860 {
 861         return false;
 862 }
 863
 864
 865 bool
 866 _EditTime::OnAccessibilityFocusIn(const _AccessibilityContainer& control, const _AccessibilityElement& element)
 867 {
 868         return false;
 869 }
 870
 871 bool
 872 _EditTime::OnAccessibilityFocusOut(const _AccessibilityContainer& control, const _AccessibilityElement& element)
 873 {
 874         return false;
 875 }
 876
 877 bool
 878 _EditTime::OnAccessibilityActionPerformed(const _AccessibilityContainer& control, const _AccessibilityElement& element)
 879 {
 880         String amString;
 881         String pmString;
 882         String labelText;
 883
 884         labelText = element.GetLabel();
 885
 886         GET_STRING_CONFIG(IDS_COM_BODY_AM, amString);
 887         GET_STRING_CONFIG(IDS_COM_POP_PM, pmString);
 888
 889         if (labelText == amString || labelText == pmString)
 890         {
 891                 labelText.Append(L" Selected");
 892                 _AccessibilityManager::GetInstance()->ReadContent(labelText);
 893         }
 894
 895         return true;
 896 }
 897
 898 bool
 899 _EditTime::OnAccessibilityValueIncreased(const _AccessibilityContainer&, const _AccessibilityElement&)
 900 {
 901         return false;
 902 }
 903
 904 bool
 905 _EditTime::OnAccessibilityValueDecreased(const _AccessibilityContainer&, const _AccessibilityElement&)
 906 {
 907         return false;
 908 }
 909
 910 }}} // Controls