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