src/lib/elm_datetime.c

   1 #ifdef HAVE_CONFIG_H
   2 # include "elementary_config.h"
   3 #endif
   4
   5 #define ELM_INTERFACE_ATSPI_ACCESSIBLE_PROTECTED
   6
   7 #include <Elementary.h>
   8 #include "elm_priv.h"
   9 #include "elm_widget_datetime.h"
  10
  11 #define MY_CLASS ELM_DATETIME_CLASS
  12
  13 #define MY_CLASS_NAME "Elm_Datetime"
  14 #define MY_CLASS_NAME_LEGACY "elm_datetime"
  15
  16 #ifdef HAVE_LOCALE_H
  17 # include <locale.h>
  18 #endif
  19
  20 #ifdef HAVE_LANGINFO_H
  21 # include <langinfo.h>
  22 #endif
  23
  24 #define MAX_SEPARATOR_LEN              6
  25 #define MIN_DAYS_IN_MONTH              28
  26 #define BUFFER_SIZE                    1024
  27
  28 /* interface between EDC & C code (field & signal names). values 0 to
  29  * ELM_DATETIME_TYPE_COUNT are in the valid range, and must get in the
  30  * place of "%d".
  31  */
  32 #define EDC_DATETIME_FOCUSIN_SIG_STR   "elm,action,focus"
  33 #define EDC_DATETIME_FOCUSOUT_SIG_STR  "elm,action,unfocus"
  34 #define EDC_PART_FIELD_STR             "field%d"
  35 #define EDC_PART_SEPARATOR_STR         "separator%d"
  36 #define EDC_PART_FIELD_ENABLE_SIG_STR  "field%d,enable"
  37 #define EDC_PART_FIELD_DISABLE_SIG_STR "field%d,disable"
  38
  39 /* struct tm does not define the fields in the order year, month,
  40  * date, hour, minute. values are reassigned to an array for easy
  41  * handling.
  42  */
  43 #define DATETIME_TM_ARRAY(intptr, tmptr) \
  44   int *intptr[] = {                      \
  45      &(tmptr)->tm_year,                  \
  46      &(tmptr)->tm_mon,                   \
  47      &(tmptr)->tm_mday,                  \
  48      &(tmptr)->tm_hour,                  \
  49      &(tmptr)->tm_min,                  \
  50      &(tmptr)->tm_sec}
  51
  52 // default limits for individual fields
  53 static Format_Map mapping[ELM_DATETIME_TYPE_COUNT] = {
  54    [ELM_DATETIME_YEAR] = { "Yy", -1, -1, "" },
  55    [ELM_DATETIME_MONTH] = { "mbBh", 0, 11, "" },
  56    [ELM_DATETIME_DATE] = { "de", 1, 31, "" },
  57    [ELM_DATETIME_HOUR] = { "IHkl", 0, 23, "" },
  58    [ELM_DATETIME_MINUTE] = { "M", 0, 59, ":" },
  59    [ELM_DATETIME_AMPM] = { "pP", 0, 1, "" }
  60 };
  61
  62 static const char *multifield_formats = "cxXrRTDF";
  63 static const char *ignore_separators = "()";
  64 static const char *ignore_extensions = "E0_-O^#";
  65 static Datetime_Mod_Api *dt_mod = NULL;
  66
  67 static const Evas_Smart_Cb_Description _smart_callbacks[] = {
  68    {SIG_WIDGET_LANG_CHANGED, ""}, /**< handled by elm_widget */
  69    {SIG_WIDGET_ACCESS_CHANGED, ""}, /**< handled by elm_widget */
  70    {SIG_LAYOUT_FOCUSED, ""}, /**< handled by elm_layout */
  71    {SIG_LAYOUT_UNFOCUSED, ""}, /**< handled by elm_layout */
  72    {NULL, NULL}
  73 };
  74
  75 static Datetime_Mod_Api *
  76 _dt_mod_init()
  77 {
  78    Elm_Module *mod = NULL;
  79
  80    if (!(mod = _elm_module_find_as("datetime/api"))) return NULL;
  81
  82    mod->api = malloc(sizeof(Datetime_Mod_Api));
  83    if (!mod->api) return NULL;
  84
  85    ((Datetime_Mod_Api *)(mod->api))->obj_hook =
  86      _elm_module_symbol_get(mod, "obj_hook");
  87    ((Datetime_Mod_Api *)(mod->api))->obj_unhook =
  88      _elm_module_symbol_get(mod, "obj_unhook");
  89    ((Datetime_Mod_Api *)(mod->api))->obj_hide =
  90      _elm_module_symbol_get(mod, "obj_hide");
  91    ((Datetime_Mod_Api *)(mod->api))->field_create =
  92      _elm_module_symbol_get(mod, "field_create");
  93    ((Datetime_Mod_Api *)(mod->api))->field_value_display =
  94      _elm_module_symbol_get(mod, "field_value_display");
  95    //TIZEN_ONLY(20151218): Support Mobile UX
  96    ((Datetime_Mod_Api *)(mod->api))->field_format_changed =
  97      _elm_module_symbol_get(mod, "field_format_changed");
  98    //
  99
 100    return mod->api;
 101 }
 102
 103 static void
 104 _field_list_display(Evas_Object *obj)
 105 {
 106    Datetime_Field *field;
 107    unsigned int idx = 0;
 108
 109    ELM_DATETIME_DATA_GET(obj, sd);
 110
 111    if (!dt_mod || !dt_mod->field_value_display) return;
 112
 113    for (idx = 0; idx < ELM_DATETIME_TYPE_COUNT; idx++)
 114      {
 115         field = sd->field_list + idx;
 116         if (field->fmt_exist && field->visible)
 117           dt_mod->field_value_display(sd->mod_data, field->item_obj);
 118      }
 119 }
 120
 121 // FIXME: provide nl_langinfo on Windows if possible
 122 // returns expanded format string for corresponding multi-field format character
 123 static char *
 124 _expanded_fmt_str_get(char ch)
 125 {
 126    char *exp_fmt = "";
 127    switch (ch)
 128      {
 129       case 'c':
 130 #if defined(HAVE_LANGINFO_H) || defined (HAVE_EVIL)
 131         exp_fmt = nl_langinfo(D_T_FMT);
 132 #else
 133         exp_fmt = "";
 134 #endif
 135         break;
 136
 137       case 'x':
 138 #if defined(HAVE_LANGINFO_H) || defined (HAVE_EVIL)
 139         exp_fmt = nl_langinfo(D_FMT);
 140 #else
 141         exp_fmt = "";
 142 #endif
 143         break;
 144
 145       case 'X':
 146 #if defined(HAVE_LANGINFO_H) || defined (HAVE_EVIL)
 147         exp_fmt = nl_langinfo(T_FMT);
 148 #else
 149         exp_fmt = "";
 150 #endif
 151         break;
 152
 153       case 'r':
 154 #if defined(HAVE_LANGINFO_H) || defined (HAVE_EVIL)
 155         exp_fmt = nl_langinfo(T_FMT_AMPM);
 156 #else
 157         exp_fmt = "";
 158 #endif
 159         break;
 160
 161       case 'R':
 162         exp_fmt = "%H:%M";
 163         break;
 164
 165       case 'T':
 166         exp_fmt = "%H:%M:%S";
 167         break;
 168
 169       case 'D':
 170         exp_fmt = "%m/%d/%y";
 171         break;
 172
 173       case 'F':
 174         exp_fmt = "%Y-%m-%d";
 175         break;
 176
 177       default:
 178         exp_fmt = "";
 179         break;
 180      }
 181
 182    return exp_fmt;
 183 }
 184
 185 static void
 186 _expand_format(char *dt_fmt)
 187 {
 188    char *ptr, *expanded_fmt, ch;
 189    unsigned int idx, len = 0;
 190    char buf[ELM_DATETIME_MAX_FORMAT_LEN] = {0, };
 191    Eina_Bool fmt_char, fmt_expanded;
 192
 193    do {
 194      idx = 0;
 195      fmt_char = EINA_FALSE;
 196      fmt_expanded = EINA_FALSE;
 197      ptr = dt_fmt;
 198      while ((ch = *ptr))
 199        {
 200           if ((fmt_char) && (strchr(multifield_formats, ch)))
 201             {
 202                /* replace the multi-field format characters with
 203                 * corresponding expanded format */
 204                expanded_fmt = _expanded_fmt_str_get(ch);
 205                len = strlen(expanded_fmt);
 206                if (len > 0) fmt_expanded = EINA_TRUE;
 207                buf[--idx] = 0;
 208                strncat(buf, expanded_fmt, len);
 209                idx += len;
 210             }
 211           else buf[idx++] = ch;
 212
 213           if (ch == '%') fmt_char = EINA_TRUE;
 214           else fmt_char = EINA_FALSE;
 215
 216           ptr++;
 217        }
 218
 219      buf[idx] = 0;
 220      strncpy(dt_fmt, buf, ELM_DATETIME_MAX_FORMAT_LEN);
 221    } while (fmt_expanded);
 222 }
 223
 224 static void
 225 _field_list_arrange(Evas_Object *obj)
 226 {
 227    Datetime_Field *field;
 228    char buf[BUFFER_SIZE];
 229    int idx;
 230    Eina_Bool freeze;
 231
 232    ELM_DATETIME_DATA_GET(obj, sd);
 233
 234    freeze = sd->freeze_sizing;
 235    sd->freeze_sizing = EINA_TRUE;
 236
 237    //////////////////////////////////////////////////////////////////////////////
 238    //TIZEN_ONLY(20150225): Open source datetime code doesn't consider dynamically
 239    //                      field sequence changing case.
 240    /*
 241    for (idx = 0; idx < ELM_DATETIME_TYPE_COUNT; idx++)
 242      {
 243         field = sd->field_list + idx;
 244         snprintf(buf, sizeof(buf), EDC_PART_FIELD_STR, field->location);
 245
 246         if (field->visible && field->fmt_exist)
 247           {
 248              elm_layout_content_unset(obj, buf);
 249              elm_layout_content_set(obj, buf, field->item_obj);
 250           }
 251         else
 252           evas_object_hide(elm_layout_content_unset(obj, buf));
 253      }
 254    */
 255    // remove all the content widget from the layout
 256    for (idx = 0; idx < ELM_DATETIME_TYPE_COUNT; idx++)
 257      {
 258         snprintf(buf, sizeof(buf), EDC_PART_FIELD_STR, idx);
 259         elm_layout_content_unset(obj, buf);
 260      }
 261    // set as content widget or hide it depending on location
 262    for (idx = 0; idx < ELM_DATETIME_TYPE_COUNT; idx++)
 263      {
 264         field = sd->field_list + idx;
 265         snprintf(buf, sizeof(buf), EDC_PART_FIELD_STR, field->location);
 266
 267         if (field->visible && field->fmt_exist)
 268           elm_layout_content_set(obj, buf, field->item_obj);
 269         else
 270           evas_object_hide(field->item_obj);
 271      }
 272    //////////////////////////////////////////////////////////////////////////////
 273
 274    sd->freeze_sizing = freeze;
 275
 276    elm_layout_sizing_eval(obj);
 277    _field_list_display(obj);
 278 }
 279
 280 static unsigned int
 281 _parse_format(Evas_Object *obj,
 282               char *fmt_ptr)
 283 {
 284    Eina_Bool fmt_parsing = EINA_FALSE, sep_parsing = EINA_FALSE,
 285              sep_lookup = EINA_FALSE;
 286    //TIZEN_ONLY(20151216) - swap format locations to support some locale.
 287    Eina_Bool location_swap = EINA_FALSE;
 288    //
 289    unsigned int len = 0, idx = 0, location = 0;
 290    char separator[MAX_SEPARATOR_LEN];
 291    Datetime_Field *field = NULL;
 292    char cur;
 293
 294    ELM_DATETIME_DATA_GET(obj, sd);
 295
 296    while ((cur = *fmt_ptr))
 297      {
 298         if (fmt_parsing)
 299           {
 300              if (strchr(ignore_extensions, cur))
 301                {
 302                   fmt_ptr++;
 303                   continue;
 304                }
 305              fmt_parsing = EINA_FALSE;
 306
 307              //TIZEN_ONLY(20151216) - swap format locations to support some locale.
 308              if (location == 0 &&
 309                  (strchr(mapping[ELM_DATETIME_HOUR].fmt_char, cur) ||
 310                   strchr(mapping[ELM_DATETIME_MINUTE].fmt_char, cur) ||
 311                   strchr(mapping[ELM_DATETIME_AMPM].fmt_char, cur)))
 312                location_swap = EINA_TRUE;
 313              //
 314              for (idx = 0; idx < ELM_DATETIME_TYPE_COUNT; idx++)
 315                {
 316                   if (strchr(mapping[idx].fmt_char, cur))
 317                     {
 318                        field = sd->field_list + idx;
 319                        /* ignore the fields already have or disabled
 320                         * valid formats, means already parsed &
 321                         * repeated, ignore. */
 322                        if (field->location != -1) break;
 323                        field->fmt[1] = cur;
 324                        field->fmt_exist = EINA_TRUE;
 325                        field->location = location++;
 326                        sep_lookup = EINA_TRUE;
 327                        len = 0;
 328                        break;
 329                     }
 330                }
 331           }
 332         if (cur == '%')
 333           {
 334              fmt_parsing = EINA_TRUE;
 335              sep_parsing = EINA_FALSE;
 336              // set the separator to previous field
 337              separator[len] = 0;
 338              if (field) eina_stringshare_replace(&field->separator, separator);
 339           }
 340         // ignore the set of chars (global, field specific) as field separators
 341         if (sep_parsing &&
 342             (len < MAX_SEPARATOR_LEN - 1) &&
 343             (field->type != ELM_DATETIME_AMPM) &&
 344             (!strchr(ignore_separators, cur)) &&
 345             (!strchr(mapping[idx].ignore_sep, cur)))
 346           separator[len++] = cur;
 347         if (sep_lookup) sep_parsing = EINA_TRUE;
 348         sep_lookup = EINA_FALSE;
 349         fmt_ptr++;
 350      }
 351
 352    //TIZEN_ONLY(20151216) - swap format locations to support some locale.
 353    if (location_swap)
 354      {
 355         int time_fmt_count;
 356
 357         time_fmt_count = location - ELM_DATETIME_HOUR;
 358         for (idx = 0; idx < ELM_DATETIME_TYPE_COUNT; idx++)
 359           {
 360              field = sd->field_list + idx;
 361              /* ignore the fields already disabled
 362               * valid formats, means already ignore. */
 363              if (field->location == -1) continue;
 364              if (idx < ELM_DATETIME_HOUR)
 365                field->location -= time_fmt_count;
 366              else
 367                field->location += ELM_DATETIME_HOUR;
 368           }
 369      }
 370    //
 371
 372    // return the number of valid fields parsed.
 373    return location;
 374 }
 375
 376 // TIZEN_ONLY(20151218): Support Mobile UX
 377 static void
 378 _notify_format_change(Evas_Object *obj)
 379 {
 380    Datetime_Field *field;
 381    unsigned int idx = 0;
 382
 383    ELM_DATETIME_DATA_GET(obj, sd);
 384
 385    if (!dt_mod || !dt_mod->field_format_changed) return;
 386
 387    for (idx = 0; idx < ELM_DATETIME_TYPE_COUNT; idx++)
 388      {
 389         field = sd->field_list + idx;
 390         if (field->item_obj)
 391           dt_mod->field_format_changed(sd->mod_data, field->item_obj);
 392      }
 393 }
 394 //
 395
 396 static void
 397 _reload_format(Evas_Object *obj)
 398 {
 399    unsigned int idx, field_count;
 400    Datetime_Field *field;
 401    char buf[BUFFER_SIZE];
 402    char *dt_fmt;
 403
 404    ELM_DATETIME_DATA_GET(obj, sd);
 405    ELM_WIDGET_DATA_GET_OR_RETURN(obj, wd);
 406
 407    // FIXME: provide nl_langinfo on Windows if possible
 408    // fetch the default format from Libc.
 409    if (!sd->user_format)
 410 #if defined(HAVE_LANGINFO_H) || defined (HAVE_EVIL)
 411      strncpy(sd->format, nl_langinfo(D_T_FMT), ELM_DATETIME_MAX_FORMAT_LEN);
 412 #else
 413      strncpy(sd->format, "", ELM_DATETIME_MAX_FORMAT_LEN);
 414 #endif
 415    sd->format[ELM_DATETIME_MAX_FORMAT_LEN - 1] = '\0';
 416
 417    dt_fmt = (char *)malloc(ELM_DATETIME_MAX_FORMAT_LEN);
 418    if (!dt_fmt) return;
 419
 420    strncpy(dt_fmt, sd->format, ELM_DATETIME_MAX_FORMAT_LEN);
 421
 422    _expand_format(dt_fmt);
 423
 424    // reset all the fields to disable state
 425    sd->enabled_field_count = 0;
 426    for (idx = 0; idx < ELM_DATETIME_TYPE_COUNT; idx++)
 427      {
 428         field = sd->field_list + idx;
 429         field->fmt_exist = EINA_FALSE;
 430         field->location = -1;
 431      }
 432
 433    field_count = _parse_format(obj, dt_fmt);
 434    free(dt_fmt);
 435
 436    for (idx = 0; idx < ELM_DATETIME_TYPE_COUNT; idx++)
 437      {
 438         field = sd->field_list + idx;
 439         if (field->fmt_exist && field->visible)
 440           sd->enabled_field_count++;
 441      }
 442
 443    // assign locations to disabled fields for uniform usage
 444    for (idx = 0; idx < ELM_DATETIME_TYPE_COUNT; idx++)
 445      {
 446         field = sd->field_list + idx;
 447         if (field->location == -1) field->location = field_count++;
 448
 449         if (field->fmt_exist && field->visible)
 450           {
 451              snprintf(buf, sizeof(buf), EDC_PART_FIELD_ENABLE_SIG_STR,
 452                       field->location);
 453              elm_layout_signal_emit(obj, buf, "elm");
 454           }
 455         else
 456           {
 457              snprintf(buf, sizeof(buf), EDC_PART_FIELD_DISABLE_SIG_STR,
 458                       field->location);
 459              elm_layout_signal_emit(obj, buf, "elm");
 460           }
 461         snprintf
 462           (buf, sizeof(buf), EDC_PART_SEPARATOR_STR, (field->location + 1));
 463         elm_layout_text_set(obj, buf, field->separator);
 464      }
 465
 466    edje_object_message_signal_process(wd->resize_obj);
 467    _field_list_arrange(obj);
 468
 469    //TIZEN_ONLY(20151218): Support Mobile UX
 470    _notify_format_change(obj);
 471    //
 472 }
 473
 474 EOLIAN static Eina_Bool
 475 _elm_datetime_elm_widget_translate(Eo *obj, Elm_Datetime_Data *sd)
 476 {
 477    if (!sd->user_format) _reload_format(obj);
 478    else _field_list_display(obj);
 479
 480    eo_do_super(obj, MY_CLASS, elm_obj_widget_translate());
 481
 482    return EINA_TRUE;
 483 }
 484
 485 static Eina_List *
 486 _datetime_items_get(const Evas_Object *obj)
 487 {
 488    Eina_List *items = NULL;
 489    Datetime_Field *field;
 490    unsigned int idx;
 491    //TIZEN_ONLY(20170818): Prevent Null pointer ref.
 492    Datetime_Field *sorted_fields[ELM_DATETIME_TYPE_COUNT] = {0};
 493    //Datetime_Field *sorted_fields[ELM_DATETIME_TYPE_COUNT];
 494    //
 495
 496    ELM_DATETIME_DATA_GET(obj, sd);
 497
 498    for (idx = 0; idx < ELM_DATETIME_TYPE_COUNT; idx++)
 499      {
 500         field = sd->field_list + idx;
 501         sorted_fields[field->location] = field;
 502      }
 503
 504    for (idx = 0; idx < ELM_DATETIME_TYPE_COUNT; idx++)
 505      {
 506         field = sorted_fields[idx];
 507         //TIZEN_ONLY(20170818): Prevent Null pointer ref.
 508         if (!field) continue;
 509         //
 510         if (field->fmt_exist && field->visible)
 511           items = eina_list_append(items, field->item_obj);
 512      }
 513
 514    // ACCESS
 515    if (_elm_config->access_mode == ELM_ACCESS_MODE_ON)
 516      items = eina_list_append(items, sd->access_obj);
 517
 518    return items;
 519 }
 520
 521 EOLIAN static Eina_Bool
 522 _elm_datetime_elm_widget_focus_next_manager_is(Eo *obj EINA_UNUSED, Elm_Datetime_Data *_pd EINA_UNUSED)
 523 {
 524    return EINA_TRUE;
 525 }
 526
 527 EOLIAN static Eina_Bool
 528 _elm_datetime_elm_widget_focus_next(Eo *obj, Elm_Datetime_Data *_pd EINA_UNUSED, Elm_Focus_Direction dir, Evas_Object **next, Elm_Object_Item **next_item)
 529 {
 530    const Eina_List *items;
 531    Eina_List *(*list_free)(Eina_List *list);
 532    void *(*list_data_get)(const Eina_List *list);
 533
 534    Eina_Bool int_ret;
 535
 536    if ((items = elm_widget_focus_custom_chain_get(obj)))
 537      {
 538         list_data_get = eina_list_data_get;
 539         list_free = NULL;
 540      }
 541    else
 542      {
 543         items = _datetime_items_get(obj);
 544         list_data_get = eina_list_data_get;
 545         list_free = eina_list_free;
 546         if (!items) return EINA_FALSE;
 547      }
 548
 549    int_ret = elm_widget_focus_list_next_get(obj, items, list_data_get, dir, next, next_item);
 550    if (list_free) list_free((Eina_List *)items);
 551
 552    return int_ret;
 553 }
 554
 555 EOLIAN static Eina_Bool
 556 _elm_datetime_elm_widget_on_focus(Eo *obj, Elm_Datetime_Data *sd, Elm_Object_Item *item EINA_UNUSED)
 557 {
 558    Eina_Bool int_ret = EINA_FALSE;
 559
 560    eo_do_super(obj, MY_CLASS, int_ret = elm_obj_widget_on_focus(NULL));
 561    if (!int_ret) return EINA_FALSE;
 562
 563    if (!elm_widget_focus_get(obj))
 564      {
 565         if ((dt_mod) && (dt_mod->obj_hide))
 566           dt_mod->obj_hide(sd->mod_data);
 567      }
 568
 569    return EINA_TRUE;
 570 }
 571
 572 EOLIAN static Eina_Bool
 573 _elm_datetime_elm_widget_disable(Eo *obj, Elm_Datetime_Data *sd)
 574 {
 575    Datetime_Field *field;
 576    unsigned int idx = 0;
 577    Eina_Bool int_ret = EINA_FALSE;
 578
 579    eo_do_super(obj, MY_CLASS, int_ret = elm_obj_widget_disable());
 580    if (!int_ret) return EINA_FALSE;
 581
 582    for (idx = 0; idx < ELM_DATETIME_TYPE_COUNT; idx++)
 583      {
 584         field = sd->field_list + idx;
 585         elm_object_disabled_set(field->item_obj, elm_object_disabled_get(obj));
 586      }
 587    return EINA_TRUE;
 588 }
 589
 590 EOLIAN static void
 591 _elm_datetime_elm_layout_sizing_eval(Eo *obj, Elm_Datetime_Data *sd)
 592 {
 593    Evas_Coord minw = -1, minh = -1;
 594
 595    if (sd->freeze_sizing) return;
 596
 597    ELM_WIDGET_DATA_GET_OR_RETURN(obj, wd);
 598
 599    if (sd->enabled_field_count)
 600      elm_coords_finger_size_adjust(sd->enabled_field_count, &minw, 1, &minh);
 601
 602    edje_object_size_min_restricted_calc
 603      (wd->resize_obj, &minw, &minh, minw, minh);
 604    evas_object_size_hint_min_set(obj, minw, minh);
 605    evas_object_size_hint_max_set(obj, -1, -1);
 606 }
 607
 608 EOLIAN static Elm_Theme_Apply
 609 _elm_datetime_elm_widget_theme_apply(Eo *obj, Elm_Datetime_Data *sd)
 610 {
 611    Elm_Theme_Apply int_ret = ELM_THEME_APPLY_FAILED;
 612
 613    Datetime_Field *field;
 614    char buf[BUFFER_SIZE];
 615    unsigned int idx;
 616
 617    ELM_WIDGET_DATA_GET_OR_RETURN(obj, wd, ELM_THEME_APPLY_FAILED);
 618
 619    eo_do_super(obj, MY_CLASS, int_ret = elm_obj_widget_theme_apply());
 620    if (!int_ret) return ELM_THEME_APPLY_FAILED;
 621
 622    if ((!dt_mod) || (!dt_mod->field_value_display)) return int_ret;
 623
 624    for (idx = 0; idx < ELM_DATETIME_TYPE_COUNT; idx++)
 625      {
 626         field = sd->field_list + idx;
 627         if (field->fmt_exist && field->visible)
 628           {
 629              snprintf(buf, sizeof(buf), EDC_PART_FIELD_ENABLE_SIG_STR,
 630                       field->location);
 631              elm_layout_signal_emit(obj, buf, "elm");
 632
 633              snprintf
 634                (buf, sizeof(buf), EDC_PART_SEPARATOR_STR, field->location);
 635              elm_layout_text_set(obj, buf, field->separator);
 636
 637              dt_mod->field_value_display(sd->mod_data, field->item_obj);
 638           }
 639         else
 640           {
 641              snprintf(buf, sizeof(buf), EDC_PART_FIELD_DISABLE_SIG_STR,
 642                       field->location);
 643              elm_layout_signal_emit(obj, buf, "elm");
 644           }
 645      }
 646
 647    edje_object_message_signal_process(wd->resize_obj);
 648    elm_layout_sizing_eval(obj);
 649
 650    return int_ret;
 651 }
 652
 653 //TIZEN_ONLY(20170807): Apply UI Mirroring for Tizen 4.0 UX
 654 EOLIAN static Eina_Bool
 655 _elm_datetime_elm_widget_mirrored_get(Eo *obj EINA_UNUSED, Elm_Datetime_Data *sd EINA_UNUSED)
 656 {
 657    return EINA_FALSE;
 658 }
 659
 660 EOLIAN static void
 661 _elm_datetime_elm_widget_mirrored_set(Eo *obj EINA_UNUSED, Elm_Datetime_Data *sd EINA_UNUSED, Eina_Bool mirrored EINA_UNUSED)
 662 {
 663    return;
 664 }
 665 //
 666
 667 static int
 668 _max_days_get(int year,
 669               int month)
 670 {
 671    struct tm time1;
 672    time_t t;
 673    int day;
 674
 675    t = time(NULL);
 676    localtime_r(&t, &time1);
 677    time1.tm_year = year;
 678    time1.tm_mon = month;
 679    for (day = MIN_DAYS_IN_MONTH; day <= mapping[ELM_DATETIME_DATE].def_max;
 680         day++)
 681      {
 682         time1.tm_mday = day;
 683         mktime(&time1);
 684         /* To restrict month wrapping because of summer time in some locales,
 685         * ignore day light saving mode in mktime(). */
 686         time1.tm_isdst = -1;
 687         if (time1.tm_mday == 1) break;
 688      }
 689    day--;
 690
 691    return day;
 692 }
 693
 694 static Eina_Bool
 695 _date_cmp(const struct tm *time1,
 696           const struct tm *time2)
 697 {
 698    unsigned int idx;
 699
 700    const DATETIME_TM_ARRAY(timearr1, time1);
 701    const DATETIME_TM_ARRAY(timearr2, time2);
 702
 703    for (idx = 0; idx < ELM_DATETIME_TYPE_COUNT; idx++)
 704      {
 705         if (*timearr1[idx] != *timearr2[idx])
 706           return EINA_FALSE;
 707      }
 708
 709    return EINA_TRUE;
 710 }
 711
 712 static Eina_Bool
 713 _field_cmp(Elm_Datetime_Field_Type field_type,
 714           struct tm *time1,
 715           struct tm *time2)
 716 {
 717    DATETIME_TM_ARRAY(timearr1, time1);
 718    DATETIME_TM_ARRAY(timearr2, time2);
 719
 720    if (*timearr1[field_type] != *timearr2[field_type])
 721      return EINA_FALSE;
 722    else
 723      return EINA_TRUE;
 724 }
 725
 726 // validates curr_time/min_limt/max_limit according to the newly set value
 727 static void
 728 _validate_datetime_limits(struct tm *time1,
 729                           struct tm *time2,
 730                           Eina_Bool swap)
 731 {
 732    struct tm *t1, *t2;
 733    unsigned int idx;
 734
 735    if (!time1 || !time2) return;
 736
 737    t1 = (swap) ? time2 : time1;
 738    t2 = (swap) ? time1 : time2;
 739
 740    DATETIME_TM_ARRAY(timearr1, time1);
 741    DATETIME_TM_ARRAY(timearr2, time2);
 742    for (idx = 0; idx < ELM_DATETIME_TYPE_COUNT - 1; idx++)
 743      {
 744         if (*timearr1[idx] < *timearr2[idx])
 745           {
 746              memcpy(t1, t2, sizeof(struct tm));
 747              break;
 748           }
 749         else if (*timearr1[idx] > *timearr2[idx])
 750           break;
 751      }
 752 }
 753
 754 static void
 755 _apply_field_limits(Evas_Object *obj)
 756 {
 757    Datetime_Field *field;
 758    unsigned int idx = 0;
 759    int val;
 760
 761    ELM_DATETIME_DATA_GET(obj, sd);
 762
 763    DATETIME_TM_ARRAY(timearr, &sd->curr_time);
 764    for (idx = 0; idx < ELM_DATETIME_TYPE_COUNT - 1; idx++)
 765      {
 766         field = sd->field_list + idx;
 767         val = *timearr[idx];
 768         if (val < field->min)
 769           *timearr[idx] = field->min;
 770         else if (val > field->max)
 771           *timearr[idx] = field->max;
 772      }
 773
 774    _field_list_display(obj);
 775 }
 776
 777 static void
 778 _apply_range_restrictions(struct tm *tim)
 779 {
 780    unsigned int idx;
 781    int val, min, max;
 782
 783    if (!tim) return;
 784
 785    DATETIME_TM_ARRAY(timearr, tim);
 786    for (idx = ELM_DATETIME_MONTH; idx < ELM_DATETIME_TYPE_COUNT - 1; idx++)
 787      {
 788         val = *timearr[idx];
 789         min = mapping[idx].def_min;
 790         max = mapping[idx].def_max;
 791         if (idx == ELM_DATETIME_DATE)
 792           max = _max_days_get(tim->tm_year, tim->tm_mon);
 793         if (val < min)
 794           *timearr[idx] = min;
 795         else if (val > max)
 796           *timearr[idx] = max;
 797      }
 798 }
 799
 800 static const char *
 801 _field_format_get(Evas_Object *obj,
 802                   Elm_Datetime_Field_Type field_type)
 803 {
 804    Datetime_Field *field;
 805
 806    if (field_type > ELM_DATETIME_AMPM) return NULL;
 807
 808    ELM_DATETIME_DATA_GET(obj, sd);
 809
 810    field = sd->field_list + field_type;
 811
 812    return field->fmt;
 813 }
 814
 815 static void
 816 _field_limit_get(Evas_Object *obj,
 817                  Elm_Datetime_Field_Type field_type,
 818                  int *range_min,
 819                  int *range_max)
 820 {
 821    int min, max, max_days;
 822    Datetime_Field *field;
 823    unsigned int idx;
 824
 825    if (field_type > ELM_DATETIME_MINUTE) return;
 826
 827    ELM_DATETIME_DATA_GET(obj, sd);
 828
 829    field = sd->field_list + field_type;
 830
 831    min = field->min;
 832    max = field->max;
 833
 834    DATETIME_TM_ARRAY(curr_timearr, &sd->curr_time);
 835    DATETIME_TM_ARRAY(min_timearr, &sd->min_limit);
 836    DATETIME_TM_ARRAY(max_timearr, &sd->max_limit);
 837
 838    for (idx = 0; idx < field->type; idx++)
 839      if (*curr_timearr[idx] > *min_timearr[idx]) break;
 840    if ((idx == field_type) && (min < *min_timearr[field_type]))
 841      min = *min_timearr[field_type];
 842    if (field_type == ELM_DATETIME_DATE)
 843      {
 844         max_days = _max_days_get(sd->curr_time.tm_year, sd->curr_time.tm_mon);
 845         if (max > max_days) max = max_days;
 846      }
 847    for (idx = 0; idx < field->type; idx++)
 848      if (*curr_timearr[idx] < *max_timearr[idx]) break;
 849    if ((idx == field_type) && (max > *max_timearr[field_type]))
 850      max = *max_timearr[field_type];
 851
 852    *range_min = min;
 853    *range_max = max;
 854 }
 855
 856 //TIZEN_ONLY(20151218): Support Mobile UX
 857 static Eina_Bool
 858 _field_location_get(Evas_Object *obj, Elm_Datetime_Field_Type field_type,
 859                     int *loc)
 860 {
 861    Datetime_Field *field;
 862
 863    ELM_DATETIME_DATA_GET(obj, sd);
 864
 865    field = sd->field_list + field_type;
 866    if (!field) return EINA_FALSE;
 867
 868    if (loc) *loc = field->location;
 869
 870    return (field->fmt_exist && field->visible);
 871 }
 872
 873 static Eina_List *
 874 _fields_sorted_get(Evas_Object *obj)
 875 {
 876    Eina_List *items = NULL;
 877    Datetime_Field *field;
 878    unsigned int idx;
 879    Datetime_Field *sorted_fields[ELM_DATETIME_TYPE_COUNT];
 880
 881    ELM_DATETIME_DATA_GET(obj, sd);
 882
 883    for (idx = 0; idx < ELM_DATETIME_TYPE_COUNT; idx++)
 884      {
 885         field = sd->field_list + idx;
 886         sorted_fields[field->location] = field;
 887      }
 888
 889    for (idx = 0; idx < ELM_DATETIME_TYPE_COUNT; idx++)
 890      {
 891         field = sorted_fields[idx];
 892         if (field->fmt_exist && field->visible)
 893           items = eina_list_append(items, field->item_obj);
 894      }
 895
 896    return items;
 897 }
 898 //
 899
 900 static void
 901 _field_list_init(Evas_Object *obj)
 902 {
 903    Datetime_Field *field;
 904    unsigned int idx;
 905    time_t t;
 906
 907    ELM_DATETIME_DATA_GET(obj, sd);
 908
 909    t = time(NULL);
 910    localtime_r(&t, &sd->curr_time);
 911
 912    mapping[ELM_DATETIME_YEAR].def_min = _elm_config->year_min;
 913    mapping[ELM_DATETIME_YEAR].def_max = _elm_config->year_max;
 914    for (idx = 0; idx < ELM_DATETIME_TYPE_COUNT; idx++)
 915      {
 916         field = sd->field_list + idx;
 917         field->type = ELM_DATETIME_YEAR + idx;
 918         field->fmt[0] = '%';
 919         field->fmt_exist = EINA_FALSE;
 920         field->visible = EINA_TRUE;
 921         field->min = mapping[idx].def_min;
 922         field->max = mapping[idx].def_max;
 923      }
 924    DATETIME_TM_ARRAY(min_timearr, &sd->min_limit);
 925    DATETIME_TM_ARRAY(max_timearr, &sd->max_limit);
 926    for (idx = 0; idx < ELM_DATETIME_TYPE_COUNT - 1; idx++)
 927      {
 928         *min_timearr[idx] = mapping[idx].def_min;
 929         *max_timearr[idx] = mapping[idx].def_max;
 930      }
 931 }
 932
 933 static char *
 934 _access_info_cb(void *data, Evas_Object *obj EINA_UNUSED)
 935 {
 936    char *ret;
 937    Eina_Strbuf *buf;
 938    buf = eina_strbuf_new();
 939
 940    ELM_DATETIME_DATA_GET(data, sd);
 941    eina_strbuf_append_printf(buf,
 942                              "%d year, %d month, %d date, %d hour, %d minute",
 943                              sd->curr_time.tm_year, sd->curr_time.tm_mon + 1,
 944                              sd->curr_time.tm_mday, sd->curr_time.tm_hour,
 945                              sd->curr_time.tm_min);
 946
 947    ret = eina_strbuf_string_steal(buf);
 948    eina_strbuf_free(buf);
 949    return ret;
 950 }
 951
 952 EOLIAN static void
 953 _elm_datetime_evas_object_smart_add(Eo *obj, Elm_Datetime_Data *priv)
 954 {
 955    Datetime_Field *field;
 956    int idx;
 957
 958    eo_do_super(obj, MY_CLASS, evas_obj_smart_add());
 959    elm_widget_sub_object_parent_add(obj);
 960
 961    /* TIZEN_ONLY(20180111): elm_widget_can_focus_set before module init for support TV UX */
 962    elm_widget_can_focus_set(obj, EINA_TRUE);
 963    //
 964
 965    // module - initialise module for datetime
 966    if (!dt_mod) dt_mod = _dt_mod_init();
 967    if (dt_mod)
 968      {
 969         if (dt_mod->obj_hook)
 970           {
 971              priv->mod_data = dt_mod->obj_hook(obj);
 972
 973              // update module data
 974              if (priv->mod_data)
 975                {
 976                   priv->mod_data->base = obj;
 977                   priv->mod_data->field_limit_get = _field_limit_get;
 978                   priv->mod_data->field_format_get = _field_format_get;
 979                   //TIZEN_ONLY(20151218): Support Mobile UX
 980                   priv->mod_data->field_location_get = _field_location_get;
 981                   priv->mod_data->fields_sorted_get = _fields_sorted_get;
 982                   //
 983                }
 984           }
 985
 986         if (dt_mod->field_create)
 987           {
 988              for (idx = 0; idx < ELM_DATETIME_TYPE_COUNT; idx++)
 989                {
 990                   field = priv->field_list + idx;
 991                   field->item_obj = dt_mod->field_create(priv->mod_data, idx);
 992                   /* TIZEN_ONLY(20161031): apply color_class parent-child relationship to all widgets */
 993                   _elm_widget_color_class_parent_set(field->item_obj, obj);
 994                   /* END */
 995                }
 996           }
 997      }
 998
 999    priv->freeze_sizing = EINA_TRUE;
1000    if (!elm_layout_theme_set(obj, "datetime", "base",
1001                              elm_widget_style_get(obj)))
1002      CRI("Failed to set layout!");
1003
1004    _field_list_init(obj);
1005    _reload_format(obj);
1006
1007    /* TIZEN_ONLY(20180111): elm_widget_can_focus_set before module init for support TV UX */
1008    //elm_widget_can_focus_set(obj, EINA_TRUE);
1009    //
1010
1011    priv->freeze_sizing = EINA_FALSE;
1012    elm_layout_sizing_eval(obj);
1013
1014    // ACCESS
1015    if (_elm_config->access_mode == ELM_ACCESS_MODE_ON)
1016      {
1017         Elm_Access_Info *ai;
1018
1019         priv->access_obj = _elm_access_edje_object_part_object_register
1020           (obj, elm_layout_edje_get(obj), "elm.access");
1021         if (!priv->access_obj)
1022           priv->access_obj = _elm_access_edje_object_part_object_register
1023           (obj, elm_layout_edje_get(obj), "access");
1024
1025         ai = _elm_access_info_get(priv->access_obj);
1026         _elm_access_text_set(ai, ELM_ACCESS_TYPE, "date time");
1027         _elm_access_callback_set(ai, ELM_ACCESS_INFO, _access_info_cb, obj);
1028      }
1029 }
1030
1031 EOLIAN static void
1032 _elm_datetime_evas_object_smart_del(Eo *obj, Elm_Datetime_Data *sd)
1033 {
1034    Datetime_Field *tmp;
1035    unsigned int idx;
1036
1037    for (idx = 0; idx < ELM_DATETIME_TYPE_COUNT; idx++)
1038      {
1039         tmp = sd->field_list + idx;
1040         evas_object_del(tmp->item_obj);
1041         eina_stringshare_del(tmp->separator);
1042      }
1043
1044    if ((dt_mod) && (dt_mod->obj_unhook))
1045      dt_mod->obj_unhook(sd->mod_data);  // module - unhook
1046
1047    eo_do_super(obj, MY_CLASS, evas_obj_smart_del());
1048 }
1049
1050 EAPI Evas_Object *
1051 elm_datetime_add(Evas_Object *parent)
1052 {
1053    EINA_SAFETY_ON_NULL_RETURN_VAL(parent, NULL);
1054    Evas_Object *obj = eo_add(MY_CLASS, parent);
1055    return obj;
1056 }
1057
1058 EOLIAN static Eo *
1059 _elm_datetime_eo_base_constructor(Eo *obj, Elm_Datetime_Data *_pd EINA_UNUSED)
1060 {
1061    obj = eo_do_super_ret(obj, MY_CLASS, obj, eo_constructor());
1062    eo_do(obj,
1063          evas_obj_type_set(MY_CLASS_NAME_LEGACY),
1064          evas_obj_smart_callbacks_descriptions_set(_smart_callbacks),
1065          elm_interface_atspi_accessible_role_set(ELM_ATSPI_ROLE_DATE_EDITOR));
1066
1067    return obj;
1068 }
1069
1070 EOLIAN static const char*
1071 _elm_datetime_format_get(Eo *obj EINA_UNUSED, Elm_Datetime_Data *sd)
1072 {
1073    return sd->format;
1074 }
1075
1076 EOLIAN static void
1077 _elm_datetime_format_set(Eo *obj, Elm_Datetime_Data *sd, const char *fmt)
1078 {
1079    if (fmt)
1080      {
1081         strncpy(sd->format, fmt, ELM_DATETIME_MAX_FORMAT_LEN);
1082         sd->format[ELM_DATETIME_MAX_FORMAT_LEN - 1] = '\0';
1083         sd->user_format = EINA_TRUE;
1084      }
1085    else sd->user_format = EINA_FALSE;
1086
1087    _reload_format(obj);
1088 }
1089
1090 EOLIAN static Eina_Bool
1091 _elm_datetime_field_visible_get(const Eo *obj EINA_UNUSED, Elm_Datetime_Data *sd, Elm_Datetime_Field_Type fieldtype)
1092 {
1093    Datetime_Field *field;
1094
1095    if (fieldtype > ELM_DATETIME_AMPM) return EINA_FALSE;
1096
1097    field = sd->field_list + fieldtype;
1098
1099    return field->visible;
1100 }
1101
1102 EOLIAN static void
1103 _elm_datetime_field_visible_set(Eo *obj, Elm_Datetime_Data *sd, Elm_Datetime_Field_Type fieldtype, Eina_Bool visible)
1104 {
1105    char buf[BUFFER_SIZE];
1106    Datetime_Field *field;
1107
1108    if (fieldtype > ELM_DATETIME_AMPM) return;
1109
1110    field = sd->field_list + fieldtype;
1111    visible = !!visible;
1112    if (field->visible == visible) return;
1113
1114    field->visible = visible;
1115
1116    sd->freeze_sizing = EINA_TRUE;
1117    if (visible)
1118      {
1119         sd->enabled_field_count++;
1120
1121         if (!field->fmt_exist) return;
1122
1123         snprintf(buf, sizeof(buf), EDC_PART_FIELD_ENABLE_SIG_STR,
1124                  field->location);
1125         elm_layout_signal_emit(obj, buf, "elm");
1126
1127         ELM_WIDGET_DATA_GET_OR_RETURN(obj, wd);
1128         edje_object_message_signal_process(wd->resize_obj);
1129
1130         snprintf(buf, sizeof(buf), EDC_PART_FIELD_STR, field->location);
1131         elm_layout_content_unset(obj, buf);
1132         elm_layout_content_set(obj, buf, field->item_obj);
1133      }
1134    else
1135      {
1136         sd->enabled_field_count--;
1137
1138         if (!field->fmt_exist) return;
1139
1140         snprintf(buf, sizeof(buf), EDC_PART_FIELD_DISABLE_SIG_STR,
1141                  field->location);
1142         elm_layout_signal_emit(obj, buf, "elm");
1143
1144         ELM_WIDGET_DATA_GET_OR_RETURN(obj, wd);
1145         edje_object_message_signal_process(wd->resize_obj);
1146
1147         snprintf(buf, sizeof(buf), EDC_PART_FIELD_STR, field->location);
1148         evas_object_hide(elm_layout_content_unset(obj, buf));
1149      }
1150    sd->freeze_sizing = EINA_FALSE;
1151
1152    elm_layout_sizing_eval(obj);
1153
1154    if (!visible) return;
1155    if (!dt_mod || !dt_mod->field_value_display) return;
1156
1157    dt_mod->field_value_display(sd->mod_data, field->item_obj);
1158 }
1159
1160 EOLIAN static void
1161 _elm_datetime_field_limit_get(const Eo *obj EINA_UNUSED, Elm_Datetime_Data *sd, Elm_Datetime_Field_Type fieldtype, int *min, int *max)
1162 {
1163    Datetime_Field *field;
1164
1165    if (fieldtype >= ELM_DATETIME_AMPM) return;
1166
1167    field = sd->field_list + fieldtype;
1168    if (min) *min = field->min;
1169    if (max) *max = field->max;
1170 }
1171
1172 EOLIAN static void
1173 _elm_datetime_field_limit_set(Eo *obj, Elm_Datetime_Data *sd, Elm_Datetime_Field_Type fieldtype, int min, int max)
1174 {
1175    Datetime_Field *field;
1176    struct tm old_time;
1177
1178    if (fieldtype >= ELM_DATETIME_AMPM) return;
1179
1180    if (min > max) return;
1181
1182    old_time = sd->curr_time;
1183    field = sd->field_list + fieldtype;
1184    if (((min >= mapping[fieldtype].def_min) &&
1185         (min <= mapping[fieldtype].def_max)) ||
1186        (field->type == ELM_DATETIME_YEAR))
1187      field->min = min;
1188    if (((max >= mapping[fieldtype].def_min) &&
1189         (max <= mapping[fieldtype].def_max)) ||
1190        (field->type == ELM_DATETIME_YEAR))
1191      field->max = max;
1192
1193    _apply_field_limits(obj);
1194
1195    if (!_field_cmp(fieldtype, &old_time, &sd->curr_time))
1196      eo_do(obj, eo_event_callback_call(ELM_DATETIME_EVENT_CHANGED, NULL));
1197
1198 }
1199
1200 EOLIAN static Eina_Bool
1201 _elm_datetime_value_get(const Eo *obj EINA_UNUSED, Elm_Datetime_Data *sd, struct tm *currtime)
1202 {
1203    EINA_SAFETY_ON_NULL_RETURN_VAL(currtime, EINA_FALSE);
1204
1205    *currtime = sd->curr_time;
1206    return EINA_TRUE;
1207 }
1208
1209 EOLIAN static Eina_Bool
1210 _elm_datetime_value_set(Eo *obj, Elm_Datetime_Data *sd, const struct tm *newtime)
1211 {
1212    EINA_SAFETY_ON_NULL_RETURN_VAL(newtime, EINA_FALSE);
1213
1214    if (_date_cmp(&sd->curr_time, newtime)) return EINA_TRUE;
1215    sd->curr_time = *newtime;
1216    // apply default field restrictions for curr_time
1217    _apply_range_restrictions(&sd->curr_time);
1218    // validate the curr_time according to the min_limt and max_limt
1219    _validate_datetime_limits(&sd->curr_time, &sd->min_limit, EINA_FALSE);
1220    _validate_datetime_limits(&sd->max_limit, &sd->curr_time, EINA_TRUE);
1221    _apply_field_limits(obj);
1222
1223    eo_do(obj, eo_event_callback_call(ELM_DATETIME_EVENT_CHANGED, NULL));
1224
1225    return EINA_TRUE;
1226 }
1227
1228 EOLIAN static Eina_Bool
1229 _elm_datetime_value_min_get(const Eo *obj EINA_UNUSED, Elm_Datetime_Data *sd, struct tm *mintime)
1230 {
1231    EINA_SAFETY_ON_NULL_RETURN_VAL(mintime, EINA_FALSE);
1232
1233    *mintime = sd->min_limit;
1234    return EINA_TRUE;
1235 }
1236
1237 EOLIAN static Eina_Bool
1238 _elm_datetime_value_min_set(Eo *obj, Elm_Datetime_Data *sd, const struct tm *mintime)
1239 {
1240    struct tm old_time;
1241
1242    EINA_SAFETY_ON_NULL_RETURN_VAL(mintime, EINA_FALSE);
1243
1244    if (_date_cmp(&sd->min_limit, mintime)) return EINA_TRUE;
1245    sd->min_limit = *mintime;
1246    old_time = sd->curr_time;
1247    // apply default field restrictions for min_limit
1248    _apply_range_restrictions(&sd->min_limit);
1249    // validate curr_time and max_limt according to the min_limit
1250    _validate_datetime_limits(&sd->max_limit, &sd->min_limit, EINA_FALSE);
1251    _validate_datetime_limits(&sd->curr_time, &sd->min_limit, EINA_FALSE);
1252    _apply_field_limits(obj);
1253
1254    if (!_date_cmp(&old_time, &sd->curr_time))
1255      eo_do(obj, eo_event_callback_call(ELM_DATETIME_EVENT_CHANGED, NULL));
1256
1257    return EINA_TRUE;
1258 }
1259
1260 EOLIAN static Eina_Bool
1261 _elm_datetime_value_max_get(const Eo *obj EINA_UNUSED, Elm_Datetime_Data *sd, struct tm *maxtime)
1262 {
1263    EINA_SAFETY_ON_NULL_RETURN_VAL(maxtime, EINA_FALSE);
1264
1265    *maxtime = sd->max_limit;
1266    return EINA_TRUE;
1267 }
1268
1269 EOLIAN static Eina_Bool
1270 _elm_datetime_value_max_set(Eo *obj, Elm_Datetime_Data *sd, const struct tm *maxtime)
1271 {
1272    struct tm old_time;
1273
1274    EINA_SAFETY_ON_NULL_RETURN_VAL(maxtime, EINA_FALSE);
1275
1276    if (_date_cmp(&sd->max_limit, maxtime)) return EINA_TRUE;
1277    sd->max_limit = *maxtime;
1278    old_time = sd->curr_time;
1279    // apply default field restrictions for max_limit
1280    _apply_range_restrictions(&sd->max_limit);
1281    // validate curr_time and min_limt according to the max_limit
1282    _validate_datetime_limits(&sd->max_limit, &sd->min_limit, EINA_TRUE);
1283    _validate_datetime_limits(&sd->max_limit, &sd->curr_time, EINA_TRUE);
1284    _apply_field_limits(obj);
1285
1286    if (!_date_cmp(&old_time, &sd->curr_time))
1287      eo_do(obj, eo_event_callback_call(ELM_DATETIME_EVENT_CHANGED, NULL));
1288
1289    return EINA_TRUE;
1290 }
1291
1292 EOLIAN static void
1293 _elm_datetime_class_constructor(Eo_Class *klass)
1294 {
1295    evas_smart_legacy_type_register(MY_CLASS_NAME_LEGACY, klass);
1296 }
1297
1298 #include "elm_datetime.eo.c"