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 Flora License, Version 1.0 (the License);
   6 // you may not use this file except in compliance with the License.
   7 // You may obtain a copy of the License at
   8 //
   9 //     http://floralicense.org/license/
  10 //
  11 // Unless required by applicable law or agreed to in writing, software
  12 // distributed under the License is distributed on an AS IS BASIS,
  13 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  14 // See the License for the specific language governing permissions and
  15 // limitations under the License.
  16 //
  17
  18 /**
  19  * @file                FUiCtrl_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         if (__pPublicDateChangeEvent)
  52         {
  53                 delete __pPublicDateChangeEvent;
  54                 __pPublicDateChangeEvent = null;
  55         }
  56
  57         ClearLastResult();
  58 }
  59
  60 _EditDateImpl*
  61 _EditDateImpl::GetInstance(EditDate& editDate)
  62 {
  63         return static_cast<_EditDateImpl*>(editDate._pControlImpl);
  64 }
  65
  66 const _EditDateImpl*
  67 _EditDateImpl::GetInstance(const EditDate& editDate)
  68 {
  69         return static_cast<const _EditDateImpl*>(editDate._pControlImpl);
  70 }
  71
  72 _EditDateImpl*
  73 _EditDateImpl::CreateEditDateImplN(EditDate* pControl, const Point& point, const String& title)
  74 {
  75         return CreateEditDateImplFN(pControl, _CoordinateSystemUtils::ConvertToFloat(point), title);
  76 }
  77
  78 _EditDateImpl*
  79 _EditDateImpl::CreateEditDateImplFN(EditDate* pControl, const FloatPoint& point, const String& title)
  80 {
  81         result r = E_SUCCESS;
  82         FloatDimension dim;
  83
  84         _EditDate* pCore = _EditDate::CreateEditDateN(title);
  85         SysTryReturn(NID_UI_CTRL, pCore, null, E_SYSTEM, "[%s] Propagating.", GetErrorMessage(GetLastResult()));
  86
  87         _EditDateImpl* pImpl = new (std::nothrow) _EditDateImpl(pControl, pCore);
  88
  89         r = CheckConstruction(pCore, pImpl);
  90         SysTryReturn(NID_UI_CTRL, r == E_SUCCESS, null, r, "[%s] Propagating.", GetErrorMessage(r));
  91
  92         r = pCore->AddDateChangeEventListener(*pImpl);
  93         SysTryCatch(NID_UI_CTRL, r == E_SUCCESS, , r, "[%s] Propagating.", GetErrorMessage(r));
  94
  95         GET_SHAPE_CONFIG(EDITDATE::WIDTH, pCore->GetOrientation(), dim.width);
  96         GET_SHAPE_CONFIG(EDITDATE::HEIGHT, pCore->GetOrientation(), dim.height);
  97
  98         r = pImpl->InitializeBoundsPropertiesF(GET_SIZE_INFO(EditDate), FloatRectangle(point.x, point.y, dim.width, dim.height), pCore->GetOrientation());
  99
 100         ClearLastResult();
 101
 102         return pImpl;
 103
 104 CATCH:
 105         delete pImpl;
 106         return null;
 107 }
 108
 109 const char*
 110 _EditDateImpl::GetPublicClassName(void) const
 111 {
 112         return "Tizen::Ui::Controls::EditDate";
 113 }
 114
 115 const EditDate&
 116 _EditDateImpl::GetPublic(void) const
 117 {
 118         return static_cast <const EditDate&>(_ControlImpl::GetPublic());
 119 }
 120
 121 EditDate&
 122 _EditDateImpl::GetPublic(void)
 123 {
 124         return static_cast <EditDate&>(_ControlImpl::GetPublic());
 125 }
 126
 127 const _EditDate&
 128 _EditDateImpl::GetCore(void) const
 129 {
 130         return static_cast <const _EditDate&>(_ControlImpl::GetCore());
 131 }
 132
 133 _EditDate&
 134 _EditDateImpl::GetCore(void)
 135 {
 136         return static_cast <_EditDate&>(_ControlImpl::GetCore());
 137 }
 138
 139 result
 140 _EditDateImpl::OnAttachedToMainTree(void)
 141 {
 142         return _ControlImpl::OnAttachedToMainTree();
 143 }
 144
 145 result
 146 _EditDateImpl::AddDateChangeEventListener(IDateChangeEventListener& listener)
 147 {
 148         ClearLastResult();
 149
 150         if (__pPublicDateChangeEvent == null)
 151         {
 152                 __pPublicDateChangeEvent = new (std::nothrow) _PublicDateTimeChangeEvent(GetPublic());
 153
 154                 SysTryReturn(NID_UI_CTRL, __pPublicDateChangeEvent,
 155                                         E_OUT_OF_MEMORY, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] Memory allocation failed.");
 156         }
 157
 158         result r = __pPublicDateChangeEvent->AddListener(listener);
 159         SysTryReturnResult(NID_UI_CTRL, r != E_OBJ_ALREADY_EXIST, E_SYSTEM, "The IDateChangeEventListener instance already exists.");
 160
 161         return r;
 162 }
 163
 164 result
 165 _EditDateImpl::RemoveDateChangeEventListener(IDateChangeEventListener& listener)
 166 {
 167         ClearLastResult();
 168
 169         result r = E_OBJ_NOT_FOUND;
 170
 171         if (__pPublicDateChangeEvent)
 172         {
 173                 r = __pPublicDateChangeEvent->RemoveListener(listener);
 174         }
 175
 176         SysTryReturnResult(NID_UI_CTRL, r != E_OBJ_NOT_FOUND, E_SYSTEM, "IDateChangeEventListener instance is not found.");
 177
 178         return r;
 179 }
 180
 181 DateTime
 182 _EditDateImpl::GetDate(void) const
 183 {
 184         ClearLastResult();
 185
 186         Variant date = GetCore().GetPropertyDate();
 187
 188         return date.ToDateTime();
 189 }
 190
 191 int
 192 _EditDateImpl::GetDay(void) const
 193 {
 194         ClearLastResult();
 195
 196         Variant day = GetCore().GetPropertyDay();
 197
 198         return day.ToInt();
 199 }
 200
 201 int
 202 _EditDateImpl::GetMonth(void) const
 203 {
 204         ClearLastResult();
 205
 206         Variant month = GetCore().GetPropertyMonth();
 207
 208         return month.ToInt();
 209 }
 210
 211 int
 212 _EditDateImpl::GetYear(void) const
 213 {
 214         ClearLastResult();
 215
 216         Variant year = GetCore().GetPropertyYear();
 217
 218         return year.ToInt();
 219 }
 220
 221 void
 222 _EditDateImpl::SetDate(const DateTime& date)
 223 {
 224         result r = ValidateYear(date.GetYear());
 225         SysTryReturnVoidResult(NID_UI_CTRL, r == E_SUCCESS, r, "[E_INVALID_ARG] Invalid argument is used. year (%d)", date.GetYear());
 226
 227         GetCore().SetPropertyDate(Variant(date));
 228         return;
 229 }
 230
 231 void
 232 _EditDateImpl::SetCurrentDate(void)
 233 {
 234         ClearLastResult();
 235
 236         GetCore().SetCurrentDate();
 237         return;
 238 }
 239
 240 result
 241 _EditDateImpl::SetYear(int year)
 242 {
 243         result r = ValidateYear(year);
 244         SysTryReturn(NID_UI_CTRL, r == E_SUCCESS, r, r,
 245                         "[E_INVALID_ARG] Invalid argument is used. year (%d).", year);
 246
 247         r = GetCore().SetPropertyYear(Variant(year));
 248         SysTryLog(NID_UI_CTRL, r == E_SUCCESS, "[%s] Propagating.", GetErrorMessage(r));
 249
 250         return r;
 251 }
 252
 253 result
 254 _EditDateImpl::ValidateYear(int year)
 255 {
 256         ClearLastResult();
 257         SysTryReturn(NID_UI_CTRL, (year >= DATETIME_YEAR_MIN && year <= DATETIME_YEAR_MAX), E_INVALID_ARG, E_INVALID_ARG,
 258                         "[E_INVALID_ARG] Invalid argument is used. year (%d).", year);
 259
 260         int minYear = -1;
 261         int maxYear = -1;
 262
 263         GetYearRange(minYear,maxYear);
 264
 265         SysTryReturn(NID_UI_CTRL, (year >= minYear && year <= maxYear), E_INVALID_ARG, E_INVALID_ARG,
 266                         "[E_INVALID_ARG] Invalid argument is used. year (%d).", year);
 267
 268         return E_SUCCESS;
 269 }
 270
 271 result
 272 _EditDateImpl::SetMonth(int month)
 273 {
 274         ClearLastResult();
 275         SysTryReturn(NID_UI_CTRL, (month >= DATETIME_MONTH_MIN && month <= DATETIME_MONTH_MAX), E_INVALID_ARG, E_INVALID_ARG,
 276                         "[E_INVALID_ARG] Invalid argument is used. month (%d).", month);
 277
 278         result r = GetCore().SetPropertyMonth(Variant(month));
 279
 280         SysTryLog(NID_UI_CTRL, r == E_SUCCESS, "[%s] Propagating.", GetErrorMessage(r));
 281
 282         return r;
 283 }
 284
 285 result
 286 _EditDateImpl::SetDay(int day)
 287 {
 288         ClearLastResult();
 289         SysTryReturn(NID_UI_CTRL, (day >= DATETIME_DAY_MIN && day <= DATETIME_DAY_MAX), E_INVALID_ARG, E_INVALID_ARG,
 290                         "[E_INVALID_ARG] Invalid argument is used. day (%d).", day);
 291
 292         int maxValue = -1;
 293         _DateTimeUtils dateTimeUtils;
 294         maxValue = dateTimeUtils.CalculateMaxDay(GetYear(), GetMonth());
 295
 296         SysTryReturn(NID_UI_CTRL, (day <= maxValue), E_INVALID_ARG, E_INVALID_ARG,
 297                         "[E_INVALID_ARG] Invalid argument is used. day (%d), month (%d)", day, GetMonth());
 298
 299         result r = GetCore().SetPropertyDay(Variant(day));
 300         SysTryLog(NID_UI_CTRL, r == E_SUCCESS, "[%s] Propagating.", GetErrorMessage(r));
 301
 302         return r;
 303 }
 304
 305 void
 306 _EditDateImpl::SetDatePickerEnabled(bool enable)
 307 {
 308         ClearLastResult();
 309
 310         GetCore().SetPropertyDatePickerEnabled(Variant(enable));
 311         return;
 312 }
 313
 314 bool
 315 _EditDateImpl::IsDatePickerEnabled(void) const
 316 {
 317         ClearLastResult();
 318
 319         Variant enable = GetCore().GetPropertyDatePickerEnabled();
 320
 321         return enable.ToBool();
 322 }
 323
 324 result
 325 _EditDateImpl::SetYearRange(int minYear, int maxYear)
 326 {
 327         ClearLastResult();
 328
 329         result r = E_SUCCESS;
 330
 331         SysTryReturn(NID_UI_CTRL, (maxYear >= DATETIME_YEAR_MIN && maxYear <= DATETIME_YEAR_MAX), E_INVALID_ARG, E_INVALID_ARG,
 332                         "[E_INVALID_ARG] maxYear (%d) must be greater than or equal to %d and less than or equal to %d.",
 333                         maxYear, DATETIME_YEAR_MIN, DATETIME_YEAR_MAX);
 334
 335         SysTryReturn(NID_UI_CTRL, (minYear >= DATETIME_YEAR_MIN && minYear <= DATETIME_YEAR_MAX), E_INVALID_ARG, E_INVALID_ARG,
 336                         "[E_INVALID_ARG] minYear (%d) must be greater than or equal to %d and less than or equal to %d.",
 337                         minYear, DATETIME_YEAR_MIN, DATETIME_YEAR_MAX);
 338
 339         SysTryReturn(NID_UI_CTRL, (maxYear >= minYear), E_INVALID_ARG, E_INVALID_ARG,
 340                         "[E_INVALID_ARG] maxYear (%d) must be greater than or equal to minYear (%d).", maxYear, minYear);
 341
 342         Variant oldMinYear = GetCore().GetPropertyMinYearRange();
 343
 344         r = GetCore().SetPropertyMinYearRange(Variant(minYear));
 345         SysTryReturn(NID_UI_CTRL, r == E_SUCCESS, r, r, "[%s] Propagating.", GetErrorMessage(r));
 346
 347         r = GetCore().SetPropertyMaxYearRange(Variant(maxYear));
 348         if (r != E_SUCCESS)
 349         {
 350                 GetCore().SetPropertyMinYearRange(oldMinYear);
 351                 SysLogException(NID_UI_CTRL, r, "[%s] Propagating", GetErrorMessage(r));
 352         }
 353
 354         return r;
 355 }
 356
 357 result
 358 _EditDateImpl::GetYearRange(int& minYear, int& maxYear) const
 359 {
 360         ClearLastResult();
 361
 362         Variant tempMinYear = GetCore().GetPropertyMinYearRange();
 363         Variant tempMaxYear = GetCore().GetPropertyMaxYearRange();
 364
 365         minYear = tempMinYear.ToInt();
 366         maxYear = tempMaxYear.ToInt();
 367
 368         return GetLastResult();
 369 }
 370
 371 void
 372 _EditDateImpl::OnDateTimeChanged(const _Control& source, int year, int month, int day, int hour, int minute)
 373 {
 374         ClearLastResult();
 375
 376         if (__pPublicDateChangeEvent == null)
 377         {
 378                 return;
 379         }
 380
 381         _PublicDateTimeChangeEventArg* pEventArg = new (std::nothrow) _PublicDateTimeChangeEventArg(DATE_PUBLIC_CHANGE_SAVED);
 382         SysTryReturnVoidResult(NID_UI_CTRL, pEventArg != null, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] Memory allocation failed.");
 383
 384         pEventArg->SetDate(year, month, day);
 385         pEventArg->SetTime(hour, minute);
 386         __pPublicDateChangeEvent->Fire(*pEventArg);
 387
 388         return;
 389 }
 390
 391 void
 392 _EditDateImpl::OnDateTimeChangeCanceled(const _Control& source)
 393 {
 394         ClearLastResult();
 395
 396         if (__pPublicDateChangeEvent == null)
 397         {
 398                 return;
 399         }
 400
 401         _PublicDateTimeChangeEventArg* pEventArg = new (std::nothrow) _PublicDateTimeChangeEventArg(DATE_PUBLIC_CHANGE_CANCELED);
 402         SysTryReturnVoidResult(NID_UI_CTRL, pEventArg != null, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] Memory allocation failed.");
 403
 404         __pPublicDateChangeEvent->Fire(*pEventArg);
 405
 406         return;
 407 }
 408
 409 class _EditDateMaker
 410         : public _UiBuilderControlMaker
 411 {
 412 public:
 413         _EditDateMaker(_UiBuilder* uibuilder)
 414                 : _UiBuilderControlMaker(uibuilder){}
 415         virtual ~_EditDateMaker(void){}
 416         static _UiBuilderControlMaker* GetInstance(_UiBuilder* pUiBuilder)
 417         {
 418                 _EditDateMaker* pEditDateMaker = new (std::nothrow) _EditDateMaker(pUiBuilder);
 419                 return pEditDateMaker;
 420         }
 421
 422 protected:
 423         virtual Control* Make(_UiBuilderControl* pControl)
 424         {
 425                 result r = E_SUCCESS;
 426                 FloatPoint point;
 427                 FloatRectangle rect;
 428                 Tizen::Base::String elementStringOne;
 429                 Tizen::Base::String elementStringTwo;
 430                 bool titleEnable = false;
 431
 432                 _UiBuilderControlLayout* pControlProperty = null;
 433                 EditDate* pEditDate = null;
 434
 435                 int tempMin = 0;
 436                 int tempMax = 0;
 437                 int temp = 0;
 438
 439                 GetProperty(pControl, &pControlProperty);
 440                 if (pControlProperty == null)
 441                 {
 442                         return null;
 443                 }
 444
 445                 rect = pControlProperty->GetRectF();
 446                 point.x = rect.x;
 447                 point.y = rect.y;
 448                 if (pControl->GetElement(L"titleText", elementStringOne))
 449                 {
 450                         titleEnable = true;
 451                 }
 452                 pEditDate = new (std::nothrow) EditDate;
 453                 if (pEditDate == null)
 454                 {
 455                         return null;
 456                 }
 457
 458                 if (titleEnable)
 459                 {
 460                         r = pEditDate->Construct(point, elementStringOne);
 461                 }
 462                 else
 463                 {
 464                         r = pEditDate->Construct(point);
 465                 }
 466
 467                 if (r != E_SUCCESS)
 468                 {
 469                         delete pEditDate;
 470                         pEditDate = null;
 471                         return null;
 472                 }
 473
 474                 if (pControl->GetElement(L"minYearRange", elementStringOne) && pControl->GetElement(L"maxYearRange", elementStringTwo))
 475                 {
 476                         Base::Integer::Parse(elementStringOne, tempMin);
 477                         Base::Integer::Parse(elementStringTwo, tempMax);
 478
 479                         if (tempMin > tempMax)
 480                         {
 481                                 temp = tempMin;
 482                                 tempMin = tempMax;
 483                                 tempMax = tempMin;
 484                         }
 485
 486                         r = pEditDate->SetYearRange(tempMin, tempMax);
 487                 }
 488
 489                 if (pControl->GetElement(L"accessibilityHint", elementStringOne))
 490                 {
 491                         AccessibilityContainer* pContainer = pEditDate->GetAccessibilityContainer();
 492                         if (pContainer)
 493                         {
 494                                 AccessibilityElement* pElement = pContainer->GetElement("EditDateText");
 495                                 if (pElement)
 496                                 {
 497                                         pElement->SetHint(elementStringOne);
 498                                 }
 499                         }
 500                 }
 501
 502                 return pEditDate;
 503         }
 504 }; // _EditDateMaker
 505
 506 _EditDateRegister::_EditDateRegister(void)
 507 {
 508         _UiBuilderControlTableManager* pUiBuilderControlTableManager = _UiBuilderControlTableManager::GetInstance();
 509         pUiBuilderControlTableManager->RegisterControl(L"EditDate", _EditDateMaker::GetInstance);
 510 }
 511
 512 _EditDateRegister::~_EditDateRegister(void)
 513 {
 514         _UiBuilderControlTableManager* pUiBuilderControlTableManager = _UiBuilderControlTableManager::GetInstance();
 515         pUiBuilderControlTableManager->UnregisterControl(L"EditDate");
 516 }
 517 static _EditDateRegister EditDateRegisterToUiBuilder;
 518 }}} // Tizen::Ui::Controls