src/ui/controls/FUiCtrl_EditDateImpl.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_EditDateImpl.cpp
  20  * @brief               This is the implementation file for the _EditDateImpl class.
  21  */
  22
  23 #include <FBaseSysLog.h>
  24 #include <FUiAccessibilityContainer.h>
  25 #include <FUiAccessibilityElement.h>
  26 #include "FUi_CoordinateSystemUtils.h"
  27 #include "FUi_UiBuilder.h"
  28 #include "FUi_ResourceManager.h"
  29 #include "FUi_ResourceSizeInfo.h"
  30 #include "FUiCtrl_EditDateImpl.h"
  31 #include "FUiCtrl_DateTimeDefine.h"
  32 #include "FUiCtrl_DateTimeUtils.h"
  33
  34 using namespace Tizen::Graphics;
  35 using namespace Tizen::Base;
  36 using namespace Tizen::Base::Runtime;
  37 using namespace Tizen::Ui;
  38
  39 namespace Tizen { namespace Ui { namespace Controls
  40 {
  41
  42 _EditDateImpl::_EditDateImpl(EditDate* pPublic, _EditDate* pCore)
  43         : _ControlImpl(pPublic, pCore)
  44         , __pPublicDateChangeEvent(null)
  45 {
  46         ClearLastResult();
  47 }
  48
  49 _EditDateImpl::~_EditDateImpl(void)
  50 {
  51         delete __pPublicDateChangeEvent;
  52         __pPublicDateChangeEvent = null;
  53
  54         ClearLastResult();
  55 }
  56
  57 _EditDateImpl*
  58 _EditDateImpl::GetInstance(EditDate& editDate)
  59 {
  60         return static_cast<_EditDateImpl*>(editDate._pControlImpl);
  61 }
  62
  63 const _EditDateImpl*
  64 _EditDateImpl::GetInstance(const EditDate& editDate)
  65 {
  66         return static_cast<const _EditDateImpl*>(editDate._pControlImpl);
  67 }
  68
  69 _EditDateImpl*
  70 _EditDateImpl::CreateEditDateImplN(EditDate* pControl, const Point& point, const String& title)
  71 {
  72         return CreateEditDateImplFN(pControl, _CoordinateSystemUtils::ConvertToFloat(point), title);
  73 }
  74
  75 _EditDateImpl*
  76 _EditDateImpl::CreateEditDateImplFN(EditDate* pControl, const FloatPoint& point, const String& title)
  77 {
  78         result r = E_SUCCESS;
  79         FloatDimension dim;
  80
  81         _EditDate* pCore = _EditDate::CreateEditDateN(title);
  82         SysTryReturn(NID_UI_CTRL, pCore, null, E_SYSTEM, "[%s] Propagating.", GetErrorMessage(GetLastResult()));
  83
  84         _EditDateImpl* pImpl = new (std::nothrow) _EditDateImpl(pControl, pCore);
  85
  86         r = CheckConstruction(pCore, pImpl);
  87         SysTryReturn(NID_UI_CTRL, r == E_SUCCESS, null, r, "[%s] Propagating.", GetErrorMessage(r));
  88
  89         r = pCore->AddDateChangeEventListener(*pImpl);
  90         SysTryCatch(NID_UI_CTRL, r == E_SUCCESS, , r, "[%s] Propagating.", GetErrorMessage(r));
  91
  92         GET_SHAPE_CONFIG(EDITDATE::WIDTH, pCore->GetOrientation(), dim.width);
  93         GET_SHAPE_CONFIG(EDITDATE::HEIGHT, pCore->GetOrientation(), dim.height);
  94
  95         r = pImpl->InitializeBoundsPropertiesF(GET_SIZE_INFO(EditDate), FloatRectangle(point.x, point.y, dim.width, dim.height), pCore->GetOrientation());
  96
  97         ClearLastResult();
  98
  99         return pImpl;
 100
 101 CATCH:
 102         delete pImpl;
 103         return null;
 104 }
 105
 106 const char*
 107 _EditDateImpl::GetPublicClassName(void) const
 108 {
 109         return "Tizen::Ui::Controls::EditDate";
 110 }
 111
 112 const EditDate&
 113 _EditDateImpl::GetPublic(void) const
 114 {
 115         return static_cast <const EditDate&>(_ControlImpl::GetPublic());
 116 }
 117
 118 EditDate&
 119 _EditDateImpl::GetPublic(void)
 120 {
 121         return static_cast <EditDate&>(_ControlImpl::GetPublic());
 122 }
 123
 124 const _EditDate&
 125 _EditDateImpl::GetCore(void) const
 126 {
 127         return static_cast <const _EditDate&>(_ControlImpl::GetCore());
 128 }
 129
 130 _EditDate&
 131 _EditDateImpl::GetCore(void)
 132 {
 133         return static_cast <_EditDate&>(_ControlImpl::GetCore());
 134 }
 135
 136 result
 137 _EditDateImpl::OnAttachedToMainTree(void)
 138 {
 139         return _ControlImpl::OnAttachedToMainTree();
 140 }
 141
 142 result
 143 _EditDateImpl::AddDateChangeEventListener(IDateChangeEventListener& listener)
 144 {
 145         ClearLastResult();
 146
 147         if (__pPublicDateChangeEvent == null)
 148         {
 149                 __pPublicDateChangeEvent = new (std::nothrow) _PublicDateTimeChangeEvent(GetPublic());
 150
 151                 SysTryReturn(NID_UI_CTRL, __pPublicDateChangeEvent,
 152                                         E_OUT_OF_MEMORY, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] Memory allocation failed.");
 153         }
 154
 155         result r = __pPublicDateChangeEvent->AddListener(listener);
 156         SysTryReturnResult(NID_UI_CTRL, r != E_OBJ_ALREADY_EXIST, E_SYSTEM, "The IDateChangeEventListener instance already exists.");
 157
 158         return r;
 159 }
 160
 161 result
 162 _EditDateImpl::RemoveDateChangeEventListener(IDateChangeEventListener& listener)
 163 {
 164         ClearLastResult();
 165
 166         result r = E_OBJ_NOT_FOUND;
 167
 168         if (__pPublicDateChangeEvent != null)
 169         {
 170                 r = __pPublicDateChangeEvent->RemoveListener(listener);
 171         }
 172
 173         SysTryReturnResult(NID_UI_CTRL, r != E_OBJ_NOT_FOUND, E_SYSTEM, "IDateChangeEventListener instance is not found.");
 174
 175         return r;
 176 }
 177
 178 DateTime
 179 _EditDateImpl::GetDate(void) const
 180 {
 181         ClearLastResult();
 182
 183         Variant date = GetCore().GetPropertyDate();
 184
 185         return date.ToDateTime();
 186 }
 187
 188 int
 189 _EditDateImpl::GetDay(void) const
 190 {
 191         ClearLastResult();
 192
 193         Variant day = GetCore().GetPropertyDay();
 194
 195         return day.ToInt();
 196 }
 197
 198 int
 199 _EditDateImpl::GetMonth(void) const
 200 {
 201         ClearLastResult();
 202
 203         Variant month = GetCore().GetPropertyMonth();
 204
 205         return month.ToInt();
 206 }
 207
 208 int
 209 _EditDateImpl::GetYear(void) const
 210 {
 211         ClearLastResult();
 212
 213         Variant year = GetCore().GetPropertyYear();
 214
 215         return year.ToInt();
 216 }
 217
 218 void
 219 _EditDateImpl::SetDate(const DateTime& date)
 220 {
 221         ClearLastResult();
 222         SysTryReturnVoidResult(NID_UI_CTRL, (date.GetYear() >= DATETIME_YEAR_MIN && date.GetYear() <= DATETIME_YEAR_MAX), E_INVALID_ARG,
 223                         "[E_INVALID_ARG] Invalid argument is used. year (%d).", date.GetYear());
 224
 225         int minYear = -1;
 226         int maxYear = -1;
 227
 228         GetYearRange(minYear, maxYear);
 229
 230         DateTime dateTime;
 231
 232         if (date.GetYear() < minYear)
 233         {
 234                 dateTime.SetValue(minYear, date.GetMonth(), date.GetDay(), date.GetHour(), date.GetMinute(), date.GetSecond());
 235         }
 236         else if (date.GetYear() > maxYear)
 237         {
 238                 dateTime.SetValue(maxYear, date.GetMonth(), date.GetDay(), date.GetHour(), date.GetMinute(), date.GetSecond());
 239         }
 240         else
 241         {
 242                 dateTime.SetValue(date);
 243         }
 244
 245         GetCore().SetPropertyDate(Variant(dateTime));
 246         return;
 247 }
 248
 249 void
 250 _EditDateImpl::SetCurrentDate(void)
 251 {
 252         ClearLastResult();
 253
 254         GetCore().SetCurrentDate();
 255         return;
 256 }
 257
 258 result
 259 _EditDateImpl::SetYear(int year)
 260 {
 261         result r = ValidateYear(year);
 262         SysTryReturn(NID_UI_CTRL, r == E_SUCCESS, r, r,
 263                         "[E_INVALID_ARG] Invalid argument is used. year (%d).", year);
 264
 265         r = GetCore().SetPropertyYear(Variant(year));
 266         SysTryLog(NID_UI_CTRL, r == E_SUCCESS, "[%s] Propagating.", GetErrorMessage(r));
 267
 268         return r;
 269 }
 270
 271 result
 272 _EditDateImpl::ValidateYear(int year)
 273 {
 274         ClearLastResult();
 275         SysTryReturn(NID_UI_CTRL, (year >= DATETIME_YEAR_MIN && year <= DATETIME_YEAR_MAX), E_INVALID_ARG, E_INVALID_ARG,
 276                         "[E_INVALID_ARG] Invalid argument is used. year (%d).", year);
 277
 278         int minYear = -1;
 279         int maxYear = -1;
 280
 281         GetYearRange(minYear,maxYear);
 282
 283         SysTryReturn(NID_UI_CTRL, (year >= minYear && year <= maxYear), E_INVALID_ARG, E_INVALID_ARG,
 284                         "[E_INVALID_ARG] Invalid argument is used. year (%d).", year);
 285
 286         return E_SUCCESS;
 287 }
 288
 289 result
 290 _EditDateImpl::SetMonth(int month)
 291 {
 292         ClearLastResult();
 293         SysTryReturn(NID_UI_CTRL, (month >= DATETIME_MONTH_MIN && month <= DATETIME_MONTH_MAX), E_INVALID_ARG, E_INVALID_ARG,
 294                         "[E_INVALID_ARG] Invalid argument is used. month (%d).", month);
 295
 296         result r = GetCore().SetPropertyMonth(Variant(month));
 297
 298         SysTryLog(NID_UI_CTRL, r == E_SUCCESS, "[%s] Propagating.", GetErrorMessage(r));
 299
 300         return r;
 301 }
 302
 303 result
 304 _EditDateImpl::SetDay(int day)
 305 {
 306         ClearLastResult();
 307         SysTryReturn(NID_UI_CTRL, (day >= DATETIME_DAY_MIN && day <= DATETIME_DAY_MAX), E_INVALID_ARG, E_INVALID_ARG,
 308                         "[E_INVALID_ARG] Invalid argument is used. day (%d).", day);
 309
 310         int maxValue = -1;
 311         _DateTimeUtils dateTimeUtils;
 312         maxValue = dateTimeUtils.CalculateMaxDay(GetYear(), GetMonth());
 313
 314         SysTryReturn(NID_UI_CTRL, (day <= maxValue), E_INVALID_ARG, E_INVALID_ARG,
 315                         "[E_INVALID_ARG] Invalid argument is used. day (%d), month (%d)", day, GetMonth());
 316
 317         result r = GetCore().SetPropertyDay(Variant(day));
 318         SysTryLog(NID_UI_CTRL, r == E_SUCCESS, "[%s] Propagating.", GetErrorMessage(r));
 319
 320         return r;
 321 }
 322
 323 void
 324 _EditDateImpl::SetDatePickerEnabled(bool enable)
 325 {
 326         ClearLastResult();
 327
 328         GetCore().SetPropertyDatePickerEnabled(Variant(enable));
 329         return;
 330 }
 331
 332 bool
 333 _EditDateImpl::IsDatePickerEnabled(void) const
 334 {
 335         ClearLastResult();
 336
 337         Variant enable = GetCore().GetPropertyDatePickerEnabled();
 338
 339         return enable.ToBool();
 340 }
 341
 342 result
 343 _EditDateImpl::SetYearRange(int minYear, int maxYear)
 344 {
 345         ClearLastResult();
 346
 347         result r = E_SUCCESS;
 348
 349         SysTryReturn(NID_UI_CTRL, (maxYear >= DATETIME_YEAR_MIN && maxYear <= DATETIME_YEAR_MAX), E_INVALID_ARG, E_INVALID_ARG,
 350                         "[E_INVALID_ARG] maxYear (%d) must be greater than or equal to %d and less than or equal to %d.",
 351                         maxYear, DATETIME_YEAR_MIN, DATETIME_YEAR_MAX);
 352
 353         SysTryReturn(NID_UI_CTRL, (minYear >= DATETIME_YEAR_MIN && minYear <= DATETIME_YEAR_MAX), E_INVALID_ARG, E_INVALID_ARG,
 354                         "[E_INVALID_ARG] minYear (%d) must be greater than or equal to %d and less than or equal to %d.",
 355                         minYear, DATETIME_YEAR_MIN, DATETIME_YEAR_MAX);
 356
 357         SysTryReturn(NID_UI_CTRL, (maxYear >= minYear), E_INVALID_ARG, E_INVALID_ARG,
 358                         "[E_INVALID_ARG] maxYear (%d) must be greater than or equal to minYear (%d).", maxYear, minYear);
 359
 360         Variant oldMinYear = GetCore().GetPropertyMinYearRange();
 361
 362         r = GetCore().SetPropertyMinYearRange(Variant(minYear));
 363         SysTryReturn(NID_UI_CTRL, r == E_SUCCESS, r, r, "[%s] Propagating.", GetErrorMessage(r));
 364
 365         r = GetCore().SetPropertyMaxYearRange(Variant(maxYear));
 366         if (r != E_SUCCESS)
 367         {
 368                 GetCore().SetPropertyMinYearRange(oldMinYear);
 369                 SysLogException(NID_UI_CTRL, r, "[%s] Propagating", GetErrorMessage(r));
 370         }
 371
 372         return r;
 373 }
 374
 375 result
 376 _EditDateImpl::GetYearRange(int& minYear, int& maxYear) const
 377 {
 378         ClearLastResult();
 379
 380         Variant tempMinYear = GetCore().GetPropertyMinYearRange();
 381         Variant tempMaxYear = GetCore().GetPropertyMaxYearRange();
 382
 383         minYear = tempMinYear.ToInt();
 384         maxYear = tempMaxYear.ToInt();
 385
 386         return GetLastResult();
 387 }
 388
 389 void
 390 _EditDateImpl::OnDateTimeChanged(const _Control& source, int year, int month, int day, int hour, int minute)
 391 {
 392         ClearLastResult();
 393
 394         if (__pPublicDateChangeEvent == null)
 395         {
 396                 return;
 397         }
 398
 399         _PublicDateTimeChangeEventArg* pEventArg = new (std::nothrow) _PublicDateTimeChangeEventArg(DATE_PUBLIC_CHANGE_SAVED);
 400         SysTryReturnVoidResult(NID_UI_CTRL, pEventArg != null, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] Memory allocation failed.");
 401
 402         pEventArg->SetDate(year, month, day);
 403         pEventArg->SetTime(hour, minute);
 404         __pPublicDateChangeEvent->Fire(*pEventArg);
 405
 406         return;
 407 }
 408
 409 void
 410 _EditDateImpl::OnDateTimeChangeCanceled(const _Control& source)
 411 {
 412         ClearLastResult();
 413
 414         if (__pPublicDateChangeEvent == null)
 415         {
 416                 return;
 417         }
 418
 419         _PublicDateTimeChangeEventArg* pEventArg = new (std::nothrow) _PublicDateTimeChangeEventArg(DATE_PUBLIC_CHANGE_CANCELED);
 420         SysTryReturnVoidResult(NID_UI_CTRL, pEventArg != null, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] Memory allocation failed.");
 421
 422         __pPublicDateChangeEvent->Fire(*pEventArg);
 423
 424         return;
 425 }
 426
 427 bool
 428 _EditDateImpl::IsXmlBoundsExist(void)
 429 {
 430         FloatRectangle builderBounds;
 431         _ControlOrientation controlOrientation = _CONTROL_ORIENTATION_PORTRAIT;
 432         bool exist = GetBuilderBoundsF(controlOrientation, builderBounds);
 433         if(!exist)
 434         {
 435                 return false;
 436         }
 437
 438         controlOrientation = GetCore().GetOrientation();
 439
 440         if (controlOrientation == _CONTROL_ORIENTATION_LANDSCAPE)
 441         {
 442                 exist = GetBuilderBoundsF(controlOrientation, builderBounds);
 443         }
 444
 445         if(!exist)
 446         {
 447                 return false;
 448         }
 449
 450         return true;
 451 }
 452
 453 void
 454 _EditDateImpl::OnChangeLayout(_ControlOrientation orientation)
 455 {
 456         GetCore().SetXmlBoundsExist(IsXmlBoundsExist());
 457
 458         return _ControlImpl::OnChangeLayout(orientation);
 459 }
 460
 461 class _EditDateMaker
 462         : public _UiBuilderControlMaker
 463 {
 464 public:
 465         _EditDateMaker(_UiBuilder* uibuilder)
 466                 : _UiBuilderControlMaker(uibuilder){}
 467         virtual ~_EditDateMaker(void){}
 468         static _UiBuilderControlMaker* GetInstance(_UiBuilder* pUiBuilder)
 469         {
 470                 _EditDateMaker* pEditDateMaker = new (std::nothrow) _EditDateMaker(pUiBuilder);
 471                 return pEditDateMaker;
 472         }
 473
 474 protected:
 475         virtual Control* Make(_UiBuilderControl* pControl)
 476         {
 477                 result r = E_SUCCESS;
 478                 FloatPoint point;
 479                 FloatRectangle rect;
 480                 Tizen::Base::String elementStringOne;
 481                 Tizen::Base::String elementStringTwo;
 482                 bool titleEnable = false;
 483
 484                 _UiBuilderControlLayout* pControlProperty = null;
 485                 EditDate* pEditDate = null;
 486
 487                 int tempMin = 0;
 488                 int tempMax = 0;
 489                 int temp = 0;
 490
 491                 GetProperty(pControl, &pControlProperty);
 492                 if (pControlProperty == null)
 493                 {
 494                         return null;
 495                 }
 496
 497                 rect = pControlProperty->GetRectF();
 498                 point.x = rect.x;
 499                 point.y = rect.y;
 500                 if (pControl->GetElement(L"titleText", elementStringOne))
 501                 {
 502                         titleEnable = true;
 503                 }
 504                 pEditDate = new (std::nothrow) EditDate;
 505                 if (pEditDate == null)
 506                 {
 507                         return null;
 508                 }
 509
 510                 if (titleEnable)
 511                 {
 512                         r = pEditDate->Construct(point, elementStringOne);
 513                 }
 514                 else
 515                 {
 516                         r = pEditDate->Construct(point);
 517                 }
 518
 519                 if (r != E_SUCCESS)
 520                 {
 521                         delete pEditDate;
 522                         pEditDate = null;
 523                         return null;
 524                 }
 525
 526                 if (pControl->GetElement(L"minYearRange", elementStringOne) && pControl->GetElement(L"maxYearRange", elementStringTwo))
 527                 {
 528                         Base::Integer::Parse(elementStringOne, tempMin);
 529                         Base::Integer::Parse(elementStringTwo, tempMax);
 530
 531                         if (tempMin > tempMax)
 532                         {
 533                                 temp = tempMin;
 534                                 tempMin = tempMax;
 535                                 tempMax = tempMin;
 536                         }
 537
 538                         r = pEditDate->SetYearRange(tempMin, tempMax);
 539                 }
 540
 541                 if (pControl->GetElement(L"accessibilityHint", elementStringOne))
 542                 {
 543                         AccessibilityContainer* pContainer = pEditDate->GetAccessibilityContainer();
 544                         if (pContainer != null)
 545                         {
 546                                 AccessibilityElement* pElement = pContainer->GetElement("EditDateText");
 547                                 if (pElement != null)
 548                                 {
 549                                         pElement->SetHint(elementStringOne);
 550                                 }
 551                         }
 552                 }
 553
 554                 return pEditDate;
 555         }
 556 }; // _EditDateMaker
 557
 558 _EditDateRegister::_EditDateRegister(void)
 559 {
 560         _UiBuilderControlTableManager* pUiBuilderControlTableManager = _UiBuilderControlTableManager::GetInstance();
 561         pUiBuilderControlTableManager->RegisterControl(L"EditDate", _EditDateMaker::GetInstance);
 562 }
 563
 564 _EditDateRegister::~_EditDateRegister(void)
 565 {
 566         _UiBuilderControlTableManager* pUiBuilderControlTableManager = _UiBuilderControlTableManager::GetInstance();
 567         pUiBuilderControlTableManager->UnregisterControl(L"EditDate");
 568 }
 569 static _EditDateRegister EditDateRegisterToUiBuilder;
 570 }}} // Tizen::Ui::Controls