src/ui/controls/FUiCtrl_EditTimeImpl.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_EditTimeImpl.cpp
  20  * @brief               This is the implementation file for the _EditTimeImpl class.
  21  */
  22
  23 #include <FBaseInternalTypes.h>
  24 #include <FBaseSysLog.h>
  25 #include <FApp_AppInfo.h>
  26 #include "FUi_UiBuilder.h"
  27 #include "FUi_ResourceManager.h"
  28 #include "FUi_ResourceSizeInfo.h"
  29 #include "FUiCtrl_EditTimeImpl.h"
  30 #include "FUiCtrl_DateTimeDefine.h"
  31
  32 using namespace Tizen::Graphics;
  33 using namespace Tizen::Base::Runtime;
  34 using namespace Tizen::Base;
  35 using namespace Tizen::App;
  36
  37 namespace Tizen { namespace Ui { namespace Controls
  38 {
  39 _EditTimeImpl::EditTimeSizeInfo::EditTimeSizeInfo(void)
  40         : __isTitle(false)
  41 {
  42 }
  43
  44 void
  45 _EditTimeImpl::EditTimeSizeInfo::SetTitleStyle(bool titleStyle)
  46 {
  47         __isTitle = titleStyle;
  48         return;
  49 }
  50
  51 Dimension
  52 _EditTimeImpl::EditTimeSizeInfo::GetDefaultMinimumSize(_ControlOrientation orientation) const
  53 {
  54         result r = E_SUCCESS;
  55         Tizen::Graphics::Dimension dimension(0, 0);
  56
  57         r = GET_DIMENSION_CONFIG(EDITTIME::DEFAULT_SIZE, orientation, dimension);
  58
  59         SysTryReturn(NID_UI, r == E_SUCCESS, dimension, r, "[%s] Propagating.", GetErrorMessage(r));
  60         return dimension;
  61 }
  62
  63 Dimension
  64 _EditTimeImpl::EditTimeSizeInfo::GetDefaultMaximumSize(_ControlOrientation orientation) const
  65 {
  66         result r = E_SUCCESS;
  67         Tizen::Graphics::Dimension dimension(0, 0);
  68
  69         r = GET_DIMENSION_CONFIG(EDITTIME::DEFAULT_SIZE, orientation, dimension);
  70
  71         SysTryReturn(NID_UI, r == E_SUCCESS, dimension, r, "[%s] Propagating.", GetErrorMessage(r));
  72         return dimension;
  73 }
  74
  75 _EditTimeImpl::_EditTimeImpl(EditTime* pPublic, _EditTime* pCore)
  76         : _ControlImpl(pPublic, pCore)
  77         , __pPublicTimeChangeEvent(null)
  78 {
  79         ClearLastResult();
  80 }
  81
  82 _EditTimeImpl::~_EditTimeImpl(void)
  83 {
  84         if (__pPublicTimeChangeEvent)
  85         {
  86                 delete __pPublicTimeChangeEvent;
  87                 __pPublicTimeChangeEvent = null;
  88         }
  89
  90         ClearLastResult();
  91 }
  92
  93 _EditTimeImpl*
  94 _EditTimeImpl::GetInstance(EditTime& editTime)
  95 {
  96         return static_cast<_EditTimeImpl*> (editTime._pControlImpl);
  97 }
  98
  99 const _EditTimeImpl*
 100 _EditTimeImpl::GetInstance(const EditTime& editTime)
 101 {
 102         return static_cast<const _EditTimeImpl*> (editTime._pControlImpl);
 103 }
 104
 105
 106 _EditTimeImpl*
 107 _EditTimeImpl::CreateEditTimeImplN(EditTime* pControl, const Point& point, const String& title)
 108 {
 109         result r = E_SUCCESS;
 110         Rectangle defaultSize;
 111         bool isTitle = false;
 112
 113         _EditTime* pCore = _EditTime::CreateEditTimeN(title);
 114         SysTryReturn(NID_UI_CTRL, pCore, null, E_SYSTEM, "[%s] Propagating.", GetErrorMessage(GetLastResult()));
 115
 116         _EditTimeImpl* pImpl = new (std::nothrow) _EditTimeImpl(pControl, pCore);
 117
 118         r = CheckConstruction(pCore, pImpl);
 119         SysTryReturn(NID_UI_CTRL, r == E_SUCCESS, null, r, "[%s] Propagating.", GetErrorMessage(r));
 120
 121         r = pCore->AddTimeChangeEventListener(*pImpl);
 122         SysTryCatch(NID_UI_CTRL, r == E_SUCCESS, , r, "[%s] Propagating.", GetErrorMessage(r));
 123
 124         GET_SHAPE_CONFIG(EDITTIME::WIDTH, pCore->GetOrientation(), defaultSize.width);
 125
 126         GET_SHAPE_CONFIG(EDITTIME::HEIGHT, pCore->GetOrientation(), defaultSize.height);
 127
 128
 129         defaultSize.x = point.x;
 130         defaultSize.y = point.y;
 131
 132         r = pImpl->InitializeBoundsProperties(FUNC_SIZE_INFO(EditTime)(isTitle), defaultSize, pCore->GetOrientation());
 133         SysTryCatch(NID_UI_CTRL, r == E_SUCCESS, , r, "[%s] Propagating.", GetErrorMessage(r));
 134
 135         ClearLastResult();
 136
 137         return pImpl;
 138
 139 CATCH:
 140         delete pImpl;
 141         return null;
 142 }
 143
 144 const char*
 145 _EditTimeImpl::GetPublicClassName(void) const
 146 {
 147         return "Tizen::Ui::Controls::EditTime";
 148 }
 149
 150 const EditTime&
 151 _EditTimeImpl::GetPublic(void) const
 152 {
 153         return static_cast <const EditTime&>(_ControlImpl::GetPublic());
 154 }
 155
 156 EditTime&
 157 _EditTimeImpl::GetPublic(void)
 158 {
 159         return static_cast <EditTime&>(_ControlImpl::GetPublic());
 160 }
 161
 162 const _EditTime&
 163 _EditTimeImpl::GetCore(void) const
 164 {
 165         return static_cast <const _EditTime&>(_ControlImpl::GetCore());
 166 }
 167
 168 _EditTime&
 169 _EditTimeImpl::GetCore(void)
 170 {
 171         return static_cast <_EditTime&>(_ControlImpl::GetCore());
 172 }
 173
 174 result
 175 _EditTimeImpl::AddTimeChangeEventListener(ITimeChangeEventListener& listener)
 176 {
 177         ClearLastResult();
 178
 179         if (__pPublicTimeChangeEvent == null)
 180         {
 181                 __pPublicTimeChangeEvent = new (std::nothrow) _PublicDateTimeChangeEvent(GetPublic());
 182
 183                 SysTryReturn(NID_UI_CTRL, __pPublicTimeChangeEvent,
 184                                         E_OUT_OF_MEMORY, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] Memory allocation failed.");
 185         }
 186
 187         result r = __pPublicTimeChangeEvent->AddListener(listener);
 188         SysTryReturnResult(NID_UI_CTRL, r != E_OBJ_ALREADY_EXIST, E_SYSTEM, "The ITimeChangeEventListener instance already exists.");
 189
 190         return r;
 191 }
 192
 193 result
 194 _EditTimeImpl::RemoveTimeChangeEventListener(ITimeChangeEventListener& listener)
 195 {
 196         ClearLastResult();
 197
 198         result r = E_OBJ_NOT_FOUND;
 199
 200         if (__pPublicTimeChangeEvent)
 201         {
 202                 r = __pPublicTimeChangeEvent->RemoveListener(listener);
 203         }
 204
 205         SysTryReturnResult(NID_UI_CTRL, r != E_OBJ_NOT_FOUND, E_SYSTEM, "ITimeChangeEventListener instance is not found.");
 206
 207         return r;
 208 }
 209
 210 DateTime
 211 _EditTimeImpl::GetTime(void) const
 212 {
 213         ClearLastResult();
 214
 215         Variant time = GetCore().GetPropertyTime();
 216
 217         return time.ToDateTime();
 218 }
 219
 220 int
 221 _EditTimeImpl::GetHour(void) const
 222 {
 223         ClearLastResult();
 224
 225         Variant hour = GetCore().GetPropertyHour();
 226
 227         return hour.ToInt();
 228 }
 229
 230 int
 231 _EditTimeImpl::GetMinute(void) const
 232 {
 233         ClearLastResult();
 234
 235         Variant minute = GetCore().GetPropertyMinute();
 236
 237         return minute.ToInt();
 238 }
 239
 240 void
 241 _EditTimeImpl::SetTime(const DateTime& time)
 242 {
 243         ClearLastResult();
 244
 245         GetCore().SetPropertyTime(Variant(time));
 246         return;
 247 }
 248
 249 void
 250 _EditTimeImpl::SetCurrentTime(void)
 251 {
 252         ClearLastResult();
 253
 254         GetCore().SetCurrentTime();
 255         return;
 256 }
 257
 258 result
 259 _EditTimeImpl::SetHour(int hour)
 260 {
 261         ClearLastResult();
 262         SysTryReturn(NID_UI_CTRL, (hour >= DATETIME_HOUR_MIN && hour <= DATETIME_HOUR_MAX), E_INVALID_ARG, E_INVALID_ARG,
 263                         "[E_INVALID_ARG] Invalid argument is used. hour (%d).", hour);
 264
 265         result r = GetCore().SetPropertyHour(Variant(hour));
 266         SysTryLog(NID_UI_CTRL, r == E_SUCCESS, "[%s] Propagating.", GetErrorMessage(r));
 267
 268         return r;
 269 }
 270
 271 result
 272 _EditTimeImpl::SetMinute(int minute)
 273 {
 274         ClearLastResult();
 275         SysTryReturn(NID_UI_CTRL, (minute >= DATETIME_MINUTE_MIN && minute <= DATETIME_MINUTE_MAX), E_INVALID_ARG, E_INVALID_ARG,
 276                         "[E_INVALID_ARG] Invalid argument is used. minute (%d).", minute);
 277
 278         result r = GetCore().SetPropertyMinute(Variant(minute));
 279         SysTryLog(NID_UI_CTRL, r == E_SUCCESS, "[%s] Propagating.", GetErrorMessage(r));
 280
 281         return r;
 282 }
 283
 284 void
 285 _EditTimeImpl::SetTimePickerEnabled(bool enable)
 286 {
 287         ClearLastResult();
 288
 289         GetCore().SetPropertyTimePickerEnabled(Variant(enable));
 290         return;
 291 }
 292
 293 bool
 294 _EditTimeImpl::IsTimePickerEnabled(void) const
 295 {
 296         ClearLastResult();
 297
 298         Variant enable = GetCore().GetPropertyTimePickerEnabled();
 299
 300         return enable.ToBool();
 301 }
 302
 303 void
 304 _EditTimeImpl::Set24HourNotationEnabled(bool enable)
 305 {
 306         ClearLastResult();
 307
 308         GetCore().Set24HourNotationEnabled(enable);
 309         return;
 310 }
 311
 312 void
 313 _EditTimeImpl::OnDateTimeChanged(const _Control& source, int year, int month, int day, int hour, int minute)
 314 {
 315         ClearLastResult();
 316
 317         if (__pPublicTimeChangeEvent == null)
 318         {
 319                 return;
 320         }
 321
 322         _PublicDateTimeChangeEventArg* pEventArg = new (std::nothrow) _PublicDateTimeChangeEventArg(TIME_PUBLIC_CHANGE_SAVED);
 323         SysTryReturnVoidResult(NID_UI_CTRL, pEventArg != null, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] Memory allocation failed.");
 324
 325         pEventArg->SetDate(year, month, day);
 326         pEventArg->SetTime(hour, minute);
 327         __pPublicTimeChangeEvent->Fire(*pEventArg);
 328
 329         return;
 330 }
 331
 332 void
 333 _EditTimeImpl::OnDateTimeChangeCanceled(const _Control& source)
 334 {
 335         ClearLastResult();
 336
 337         if (__pPublicTimeChangeEvent == null)
 338         {
 339                 return;
 340         }
 341
 342         _PublicDateTimeChangeEventArg* pEventArg = new (std::nothrow) _PublicDateTimeChangeEventArg(TIME_PUBLIC_CHANGE_CANCELED);
 343         SysTryReturnVoidResult(NID_UI_CTRL, pEventArg != null, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] Memory allocation failed.");
 344
 345         __pPublicTimeChangeEvent->Fire(*pEventArg);
 346
 347         return;
 348 }
 349
 350 class _EditTimeMaker
 351         : public _UiBuilderControlMaker
 352 {
 353 public:
 354         _EditTimeMaker(_UiBuilder* uibuilder)
 355                 : _UiBuilderControlMaker(uibuilder){}
 356         virtual ~_EditTimeMaker(void){}
 357         static _UiBuilderControlMaker* GetInstance(_UiBuilder* pUiBuilder)
 358         {
 359                 _EditTimeMaker* pEditTimeMaker = new (std::nothrow) _EditTimeMaker(pUiBuilder);
 360                 return pEditTimeMaker;
 361         }
 362
 363 protected:
 364         virtual Control* Make(_UiBuilderControl* pControl)
 365         {
 366                 result r = E_SUCCESS;
 367
 368                 _UiBuilderControlLayout* pControlProperty = null;
 369                 EditTime* pEditTime = null;
 370
 371                 Point point;
 372                 Tizen::Base::String elementString;
 373                 bool titleEnable = false;
 374                 bool hourNotationEnable = false;
 375                 Rectangle rect;
 376
 377                 GetProperty(pControl, &pControlProperty);
 378                 if (pControlProperty == null)
 379                 {
 380                         return null;
 381                 }
 382
 383                 rect = pControlProperty->GetRect();
 384                 point.x = rect.x;
 385                 point.y = rect.y;
 386
 387                 if (pControl->GetElement(L"titleText", elementString))
 388                 {
 389                         titleEnable = true;
 390                 }
 391
 392                 pEditTime = new (std::nothrow) EditTime;
 393                 if (pEditTime == null)
 394                 {
 395                         return null;
 396                 }
 397
 398                 if (titleEnable)
 399                 {
 400                         r = pEditTime->Construct(point, elementString);
 401                 }
 402                 else
 403                 {
 404                         r = pEditTime->Construct(point);
 405                 }
 406
 407                 if (r != E_SUCCESS)
 408                 {
 409                         delete pEditTime;
 410                         pEditTime = null;
 411                         return null;
 412                 }
 413
 414                 if (pControl->GetElement(L"b24HourNotationEnabled", elementString))
 415                 {
 416                         if (elementString.Equals(L"true", false))
 417                         {
 418                                 hourNotationEnable = true;
 419                                 pEditTime->Set24HourNotationEnabled(hourNotationEnable);
 420                         }
 421                 }
 422
 423                 return pEditTime;
 424         }
 425
 426 }; // _EditTimeMaker
 427
 428 _EditTimeRegister::_EditTimeRegister(void)
 429 {
 430         _UiBuilderControlTableManager* pUiBuilderControlTableManager = _UiBuilderControlTableManager::GetInstance();
 431         pUiBuilderControlTableManager->RegisterControl(L"EditTime", _EditTimeMaker::GetInstance);
 432 }
 433
 434 _EditTimeRegister::~_EditTimeRegister(void)
 435 {
 436         _UiBuilderControlTableManager* pUiBuilderControlTableManager = _UiBuilderControlTableManager::GetInstance();
 437         pUiBuilderControlTableManager->UnregisterControl(L"EditTime");
 438 }
 439 static _EditTimeRegister EditTimeRegisterToUiBuilder;
 440 }}} // Tizen::Ui::Controls