src/ui/controls/FUiCtrl_EditTime.cpp

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