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