wearable/src/lib/elm_datetime.c

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