src/lib/elm_datetime.c

   1 #include <Elementary.h>
   2 #include "elm_priv.h"
   3
   4 #ifdef HAVE_LOCALE_H
   5 # include <locale.h>
   6 #endif
   7
   8 #ifdef HAVE_LANGINFO_H
   9 # include <langinfo.h>
  10 #endif
  11
  12 typedef struct _Widget_Data Widget_Data;
  13 typedef struct _Datetime_Field Datetime_Field;
  14 typedef struct _Datetime_Mod_Api Datetime_Mod_Api;
  15 typedef struct _Format_Map Format_Map;
  16
  17 #define DATETIME_TYPE_COUNT         6
  18 #define MAX_FORMAT_LEN              64
  19 #define MAX_SEPARATOR_LEN           6
  20 #define MAX_FIELD_FORMAT_LEN        3
  21 #define MIN_DAYS_IN_MONTH           28
  22 #define BUFFER_SIZE                 1024
  23
  24 // interface between EDC & C code. Field names & signal names.
  25 // values 0 to DATETIME_TYPE_COUNT are valid range, can be substituted for %d.
  26 #define EDC_DATETIME_ENABLE_SIG_STR          "elm,state,enabled"
  27 #define EDC_DATETIME_DISABLE_SIG_STR         "elm,state,disabled"
  28 #define EDC_DATETIME_FOCUSIN_SIG_STR         "elm,action,focus"
  29 #define EDC_DATETIME_FOCUSOUT_SIG_STR        "elm,action,unfocus"
  30 #define EDC_PART_FIELD_STR                   "field%d"
  31 #define EDC_PART_SEPARATOR_STR               "separator%d"
  32 #define EDC_PART_FIELD_ENABLE_SIG_STR        "field%d,enable"
  33 #define EDC_PART_FIELD_DISABLE_SIG_STR       "field%d,disable"
  34
  35 // struct tm  does not define the fields in the order from year, month, date, hour, minute.
  36 // values are reassigned to an array for easy handling.
  37 #define DATETIME_TM_ARRAY(intptr, tmptr) int *intptr[] = {&(tmptr)->tm_year, \
  38            &(tmptr)->tm_mon, &(tmptr)->tm_mday, &(tmptr)->tm_hour, &(tmptr)->tm_min}
  39
  40 struct _Datetime_Field
  41 {
  42    Evas_Object *item_obj;
  43    char fmt[MAX_FIELD_FORMAT_LEN];
  44    Elm_Datetime_Field_Type type;
  45    const char *separator;
  46    int location;          // location of the field as per the current format
  47    int min, max;
  48    Eina_Bool fmt_exist:1;  // whether field format is present or not
  49    Eina_Bool visible:1;    // whether field can be visible or not
  50 };
  51
  52 struct _Datetime_Mod_Api
  53 {
  54    Elm_Datetime_Module_Data *(*obj_hook) (Evas_Object *obj);
  55    void (*obj_unhook) (Elm_Datetime_Module_Data *module_data);
  56    Evas_Object *(*field_create) (Elm_Datetime_Module_Data *module_data,
  57                                      Elm_Datetime_Field_Type field_type);
  58    void (*field_value_display) (Elm_Datetime_Module_Data *module_data,
  59                                     Evas_Object *obj);
  60 };
  61
  62 struct _Widget_Data
  63 {
  64    Evas_Object *base;
  65    Datetime_Field field_list[DATETIME_TYPE_COUNT]; // fixed set of fields.
  66    struct tm curr_time, min_limit, max_limit;
  67    Elm_Datetime_Module_Data *mod_data;
  68    char format[MAX_FORMAT_LEN];
  69    Eina_Bool user_format:1; // whether user set format or default format.
  70 };
  71
  72 struct _Format_Map
  73 {
  74    char *fmt_char;
  75    int def_min;
  76    int def_max;
  77    char *ignore_sep;
  78 };
  79
  80 // default limits for individual fields
  81 static Format_Map mapping[DATETIME_TYPE_COUNT] = {
  82    [ELM_DATETIME_YEAR]   =  { "Yy",  -1,  -1, "" },
  83    [ELM_DATETIME_MONTH]  =  { "mbBh", 0,  11, "" },
  84    [ELM_DATETIME_DATE]   =  { "de",   1,  31, "" },
  85    [ELM_DATETIME_HOUR]   =  { "IHkl", 0,  23, "" },
  86    [ELM_DATETIME_MINUTE] =  { "M",    0,  59, ":" },
  87    [ELM_DATETIME_AMPM]   =  { "pP",   0,   1, "" }
  88 };
  89
  90 static const char *multifield_formats = "cxXrRTDF";
  91 static const char *ignore_separators = "()";
  92
  93 static Datetime_Mod_Api *dt_mod = NULL;
  94 static const char *widtype = NULL;
  95
  96 static void _del_hook(Evas_Object *obj);
  97 static void _disable_hook(Evas_Object *obj);
  98 static void _translate_hook(Evas_Object *obj);
  99 static void _on_focus_hook(void *data __UNUSED__, Evas_Object *obj);
 100 static void _mirrored_set(Evas_Object *obj, Eina_Bool rtl);
 101 static void _sizing_eval(Evas_Object *obj);
 102 static void _theme_hook(Evas_Object *obj);
 103 static void _validate_datetime_limits(struct tm *time1, struct tm *time2, Eina_Bool swap);
 104 static void _apply_field_limits(Evas_Object *obj);
 105 static void _apply_range_restrictions(Evas_Object *obj, struct tm *time);
 106 static const char *_field_format_get(Evas_Object * obj, Elm_Datetime_Field_Type field_type);
 107 static void _field_limit_get(Evas_Object * obj, Elm_Datetime_Field_Type field_type,
 108                              int *range_min, int *range_max);
 109 static void _reload_format(Evas_Object *obj);
 110 static void _field_list_display(Evas_Object *obj);
 111 static void _field_list_arrange(Evas_Object *obj);
 112 static void _field_list_init(Evas_Object *obj);
 113
 114 static const char SIG_CHANGED[] = "changed";
 115 static const char SIG_LANGUAGE_CHANGED[] = "language,changed";
 116 static const Evas_Smart_Cb_Description _signals[] = {
 117        {SIG_CHANGED, ""},
 118        {SIG_LANGUAGE_CHANGED, ""},
 119        {NULL, NULL}
 120 };
 121
 122 static Datetime_Mod_Api *
 123 _dt_mod_init()
 124 {
 125    Elm_Module *mod = NULL;
 126    if (!(mod = _elm_module_find_as("datetime/api"))) return NULL;
 127
 128    mod->api = malloc(sizeof(Datetime_Mod_Api));
 129    if (!mod->api) return NULL;
 130
 131    ((Datetime_Mod_Api *)(mod->api))->obj_hook            =   _elm_module_symbol_get(mod, "obj_hook");
 132    ((Datetime_Mod_Api *)(mod->api))->obj_unhook          =   _elm_module_symbol_get(mod, "obj_unhook");
 133    ((Datetime_Mod_Api *)(mod->api))->field_create        =   _elm_module_symbol_get(mod, "field_create");
 134    ((Datetime_Mod_Api *)(mod->api))->field_value_display =   _elm_module_symbol_get(mod, "field_value_display");
 135
 136    return mod->api;
 137 }
 138
 139 static void
 140 _del_hook(Evas_Object *obj)
 141 {
 142    Widget_Data *wd;
 143    Datetime_Field *tmp;
 144    unsigned int idx;
 145
 146    wd = elm_widget_data_get(obj);
 147    if (!wd) return;
 148
 149    for (idx = 0; idx < DATETIME_TYPE_COUNT; idx++)
 150      {
 151         tmp = wd->field_list + idx;
 152         evas_object_del(tmp->item_obj);
 153         eina_stringshare_del(tmp->separator);
 154      }
 155
 156    if ((dt_mod) && (dt_mod->obj_unhook))
 157      dt_mod->obj_unhook(wd->mod_data); // module - unhook
 158
 159    free(wd);
 160 }
 161
 162 static void
 163 _disable_hook(Evas_Object *obj)
 164 {
 165    Widget_Data *wd;
 166
 167    wd = elm_widget_data_get(obj);
 168    if (!wd || !wd->base) return;
 169    if (elm_widget_disabled_get(obj))
 170      edje_object_signal_emit(wd->base, EDC_DATETIME_DISABLE_SIG_STR, "elm");
 171    else
 172      edje_object_signal_emit(wd->base, EDC_DATETIME_ENABLE_SIG_STR, "elm");
 173 }
 174
 175 static void
 176 _translate_hook(Evas_Object *obj)
 177 {
 178    Widget_Data *wd;
 179    wd = elm_widget_data_get(obj);
 180    if (!wd) return;
 181
 182    if (!wd->user_format) _reload_format(obj);
 183    else _field_list_display(obj);
 184    evas_object_smart_callback_call(obj, SIG_LANGUAGE_CHANGED, NULL);
 185 }
 186
 187 static void
 188 _on_focus_hook(void *data __UNUSED__, Evas_Object *obj)
 189 {
 190    Widget_Data *wd;
 191
 192    wd = elm_widget_data_get(obj);
 193    if (!wd) return;
 194
 195    if (elm_widget_focus_get(obj))
 196      edje_object_signal_emit(wd->base, EDC_DATETIME_FOCUSIN_SIG_STR, "elm");
 197    else
 198      edje_object_signal_emit(wd->base, EDC_DATETIME_FOCUSOUT_SIG_STR, "elm");
 199 }
 200
 201 static Eina_List *
 202 _datetime_items_get(const Evas_Object *obj)
 203 {
 204    Widget_Data *wd;
 205    Eina_List *items = NULL;
 206    Datetime_Field *field;
 207    int loc, count = 0;
 208    unsigned int idx;
 209
 210    wd = elm_widget_data_get(obj);
 211    if (!wd) return NULL;
 212
 213    for (idx = 0; idx < DATETIME_TYPE_COUNT; idx++)
 214      {
 215         field = wd->field_list + idx;
 216         if (field->fmt_exist && field->visible) count++;
 217      }
 218    for (loc = 0; loc < count; loc++)
 219      {
 220         for (idx = 0; idx < DATETIME_TYPE_COUNT; idx++)
 221           {
 222              field = wd->field_list + idx;
 223              if (field->location == loc)
 224                items = eina_list_append(items, field->item_obj);
 225           }
 226      }
 227
 228    return items;
 229 }
 230
 231 static Eina_Bool
 232 _elm_datetime_focus_next_hook(const Evas_Object *obj, Elm_Focus_Direction dir, Evas_Object **next)
 233 {
 234    Widget_Data *wd;
 235    const Eina_List *items;
 236    void *(*list_data_get) (const Eina_List *list);
 237    Eina_List *(*list_free) (Eina_List *list);
 238    Eina_Bool ret;
 239
 240    wd = elm_widget_data_get(obj);
 241    if (!wd) return EINA_FALSE;
 242
 243    if ((items = elm_widget_focus_custom_chain_get(obj)))
 244      {
 245         list_data_get = eina_list_data_get;
 246         list_free = NULL;
 247      }
 248    else
 249      {
 250         items = _datetime_items_get(obj);
 251         list_data_get = eina_list_data_get;
 252         list_free = eina_list_free;
 253         if (!items) return EINA_FALSE;
 254      }
 255
 256    ret = elm_widget_focus_list_next_get(obj, items, list_data_get, dir, next);
 257    if (list_free) list_free((Eina_List *)items);
 258
 259    return ret;
 260 }
 261
 262 static void
 263 _mirrored_set(Evas_Object *obj, Eina_Bool rtl)
 264 {
 265    Widget_Data *wd;
 266
 267    wd = elm_widget_data_get(obj);
 268    if (!wd) return;
 269
 270    edje_object_mirrored_set(wd->base, rtl);
 271 }
 272
 273 static void
 274 _sizing_eval(Evas_Object *obj)
 275 {
 276    Widget_Data *wd;
 277    Datetime_Field *field;
 278    Evas_Coord minw = -1, minh = -1;
 279    unsigned int idx, field_count = 0;
 280
 281    wd = elm_widget_data_get(obj);
 282    if (!wd || !wd->base) return;
 283    for (idx = 0; idx < DATETIME_TYPE_COUNT; idx++)
 284      {
 285         field = wd->field_list + idx;
 286         if ((field->visible) && (field->fmt_exist)) field_count ++;
 287      }
 288    if (field_count)
 289      elm_coords_finger_size_adjust(field_count, &minw, 1, &minh);
 290    edje_object_size_min_restricted_calc(wd->base, &minw, &minh, minw, minh);
 291    evas_object_size_hint_min_set(obj, minw, minh);
 292    evas_object_size_hint_max_set(obj, -1, -1);
 293 }
 294
 295 static void
 296 _theme_hook(Evas_Object *obj)
 297 {
 298    Widget_Data *wd;
 299    Datetime_Field *field;
 300    char buf[BUFFER_SIZE];
 301    unsigned int idx;
 302
 303    wd = elm_widget_data_get(obj);
 304    if (!wd || !wd->base) return;
 305
 306    _elm_theme_object_set(obj, wd->base, "datetime", "base",
 307                          elm_widget_style_get(obj));
 308    _elm_widget_mirrored_reload(obj);
 309    _mirrored_set(obj, elm_widget_mirrored_get(obj));
 310
 311    edje_object_scale_set(wd->base, elm_widget_scale_get(obj) * _elm_config->scale);
 312
 313    if (elm_widget_disabled_get(obj))
 314      edje_object_signal_emit(wd->base, EDC_DATETIME_DISABLE_SIG_STR,"elm");
 315    else
 316      edje_object_signal_emit(wd->base, EDC_DATETIME_ENABLE_SIG_STR, "elm");
 317
 318    if ((!dt_mod) || (!dt_mod->field_value_display)) return;
 319
 320    for (idx = 0; idx < DATETIME_TYPE_COUNT; idx++)
 321      {
 322         field = wd->field_list + idx;
 323         if (field->fmt_exist && field->visible)
 324           {
 325              snprintf(buf, sizeof(buf), EDC_PART_FIELD_ENABLE_SIG_STR, field->location);
 326              edje_object_signal_emit(wd->base, buf, "elm");
 327              snprintf(buf, sizeof(buf), EDC_PART_SEPARATOR_STR, field->location);
 328              edje_object_part_text_set(wd->base, buf, field->separator);
 329              dt_mod->field_value_display(wd->mod_data, field->item_obj);
 330           }
 331         else
 332           {
 333              snprintf(buf, sizeof(buf),EDC_PART_FIELD_DISABLE_SIG_STR, field->location);
 334              edje_object_signal_emit(wd->base, buf, "elm");
 335           }
 336      }
 337    edje_object_message_signal_process(wd->base);
 338    _sizing_eval(obj);
 339 }
 340
 341 static int
 342 _max_days_get(int year, int month)
 343 {
 344    struct tm time1;
 345    time_t t;
 346    int day;
 347
 348    t = time(NULL);
 349    localtime_r(&t, &time1);
 350    time1.tm_year = year;
 351    time1.tm_mon = month;
 352    for (day = MIN_DAYS_IN_MONTH; day <= mapping[ELM_DATETIME_DATE].def_max; day++)
 353      {
 354         time1.tm_mday = day;
 355         mktime(&time1);
 356         if (time1.tm_mday == 1) break;
 357      }
 358    day --;
 359    return day;
 360 }
 361
 362 static Eina_Bool
 363 _date_cmp(struct tm *time1, struct tm *time2)
 364 {
 365    unsigned int idx;
 366    DATETIME_TM_ARRAY(timearr1, time1);
 367    DATETIME_TM_ARRAY(timearr2, time2);
 368
 369    for (idx = 0; idx < DATETIME_TYPE_COUNT - 1; idx++)
 370      {
 371         if (*timearr1[idx] != *timearr2[idx])
 372           return EINA_FALSE;
 373      }
 374    return EINA_TRUE;
 375 }
 376
 377 // validates curr_time/min_limt/max_limit according to the newly set value
 378 static void
 379 _validate_datetime_limits(struct tm *time1, struct tm *time2, Eina_Bool swap)
 380 {
 381    struct tm *t1, *t2;
 382    unsigned int idx;
 383    if (!time1 || !time2) return;
 384
 385    t1 = (swap) ? time2 : time1;
 386    t2 = (swap) ? time1 : time2;
 387
 388    DATETIME_TM_ARRAY(timearr1, time1);
 389    DATETIME_TM_ARRAY(timearr2, time2);
 390    for (idx = 0; idx < DATETIME_TYPE_COUNT - 1; idx++)
 391      {
 392        if (*timearr1[idx] < *timearr2[idx])
 393          {
 394             memcpy(t1, t2, sizeof(struct tm));
 395             break;
 396          }
 397        else if (*timearr1[idx] > *timearr2[idx])
 398          break;
 399      }
 400 }
 401
 402 static void
 403 _apply_field_limits(Evas_Object *obj)
 404 {
 405    Widget_Data *wd;
 406    Datetime_Field *field;
 407    int val;
 408    unsigned int idx = 0;
 409
 410    wd = elm_widget_data_get(obj);
 411    if (!wd) return;
 412
 413    DATETIME_TM_ARRAY(timearr, &wd->curr_time);
 414    for (idx = 0; idx < DATETIME_TYPE_COUNT - 1; idx++)
 415      {
 416         field = wd->field_list + idx;
 417         val = *timearr[idx];
 418         if (val < field->min)
 419           *timearr[idx] = field->min;
 420         else if (val > field->max)
 421           *timearr[idx] = field->max;
 422      }
 423    _field_list_display(obj);
 424 }
 425
 426 static void
 427 _apply_range_restrictions(Evas_Object *obj, struct tm *tim)
 428 {
 429    Widget_Data *wd;
 430    unsigned int idx;
 431    int val, min, max;
 432
 433    wd = elm_widget_data_get(obj);
 434    if (!wd || !tim) return;
 435
 436    DATETIME_TM_ARRAY(timearr, tim);
 437    for (idx = ELM_DATETIME_MONTH; idx < DATETIME_TYPE_COUNT - 1; idx++)
 438      {
 439         val = *timearr[idx];
 440         min = mapping[idx].def_min;
 441         max = mapping[idx].def_max;
 442         if (idx == ELM_DATETIME_DATE)
 443           max = _max_days_get(tim->tm_year, tim->tm_mon);
 444         if (val < min)
 445           *timearr[idx] = min;
 446         else if (val > max)
 447           *timearr[idx] = max;
 448      }
 449 }
 450
 451 static const char *
 452 _field_format_get(Evas_Object * obj, Elm_Datetime_Field_Type field_type)
 453 {
 454    Widget_Data *wd;
 455    Datetime_Field *field;
 456
 457    wd = elm_widget_data_get(obj);
 458    if (!wd) return NULL;
 459
 460    field = wd->field_list + field_type;
 461    if (!field) return NULL;
 462
 463    return field->fmt;
 464 }
 465
 466 static void
 467 _field_limit_get(Evas_Object * obj, Elm_Datetime_Field_Type field_type, int *range_min, int *range_max)
 468 {
 469    Widget_Data *wd;
 470    Datetime_Field *field;
 471    int min, max, max_days;
 472    unsigned int idx;
 473
 474    wd = elm_widget_data_get(obj);
 475    if (!wd) return;
 476
 477    field = wd->field_list + field_type;
 478    if (!field) return;
 479
 480    min = field->min;
 481    max = field->max;
 482
 483    DATETIME_TM_ARRAY(curr_timearr, &wd->curr_time);
 484    DATETIME_TM_ARRAY(min_timearr, &wd->min_limit);
 485    DATETIME_TM_ARRAY(max_timearr, &wd->max_limit);
 486
 487    for (idx = 0; idx < field->type; idx++)
 488      if (*curr_timearr[idx] > *min_timearr[idx]) break;
 489    if ((idx == field_type) && (min < *min_timearr[field_type]))
 490      min = *min_timearr[field_type];
 491    if (field_type == ELM_DATETIME_DATE)
 492      {
 493         max_days = _max_days_get(wd->curr_time.tm_year, wd->curr_time.tm_mon);
 494         if (max > max_days) max = max_days;
 495      }
 496    for (idx = 0; idx < field->type; idx++)
 497      if (*curr_timearr[idx] < *max_timearr[idx]) break;
 498    if ((idx == field_type) && (max > *max_timearr[field_type]))
 499      max = *max_timearr[field_type];
 500
 501    *range_min = min;
 502    *range_max = max;
 503 }
 504
 505 static void
 506 _field_list_display(Evas_Object *obj)
 507 {
 508    Widget_Data *wd;
 509    Datetime_Field *field;
 510    unsigned int idx= 0;
 511
 512    wd = elm_widget_data_get(obj);
 513    if (!wd) return;
 514
 515    for (idx = 0; idx < DATETIME_TYPE_COUNT; idx++)
 516      {
 517         field = wd->field_list + idx;
 518         if (field->fmt_exist && field->visible)
 519           {
 520              if ((dt_mod) && (dt_mod->field_value_display))
 521                dt_mod->field_value_display(wd->mod_data, field->item_obj);
 522           }
 523      }
 524 }
 525
 526 static void
 527 _field_list_arrange(Evas_Object *obj)
 528 {
 529    Widget_Data *wd;
 530    Datetime_Field *field;
 531    char buf[BUFFER_SIZE];
 532    int idx;
 533
 534    wd = elm_widget_data_get(obj);
 535    if (!wd) return;
 536
 537    for (idx = 0; idx < DATETIME_TYPE_COUNT; idx++)
 538      {
 539         field = wd->field_list + idx;
 540         edje_object_part_unswallow(wd->base, field->item_obj);
 541      }
 542    for (idx = 0; idx < DATETIME_TYPE_COUNT; idx++)
 543      {
 544         field = wd->field_list + idx;
 545         if (field->visible && field->fmt_exist)
 546           {
 547              snprintf(buf, sizeof(buf), EDC_PART_FIELD_STR, field->location);
 548              edje_object_part_swallow(wd->base, buf, field->item_obj);
 549           }
 550         else evas_object_hide(field->item_obj);
 551      }
 552    _sizing_eval(obj);
 553    _field_list_display(obj);
 554 }
 555
 556 // FIXME: provide nl_langinfo on Windows if possible
 557 // returns expanded format string for corresponding multi-field format character
 558 static char *
 559 _expanded_fmt_str_get(char ch)
 560 {
 561    char *exp_fmt = "";
 562    switch (ch)
 563      {
 564       case 'c':
 565 #ifdef HAVE_LANGINFO_H
 566          exp_fmt = nl_langinfo(D_T_FMT);
 567 #else
 568          exp_fmt = "";
 569 #endif
 570          break;
 571       case 'x':
 572 #ifdef HAVE_LANGINFO_H
 573          exp_fmt = nl_langinfo(D_FMT);
 574 #else
 575          exp_fmt = "";
 576 #endif
 577          break;
 578       case 'X':
 579 #ifdef HAVE_LANGINFO_H
 580          exp_fmt = nl_langinfo(T_FMT);
 581 #else
 582          exp_fmt = "";
 583 #endif
 584          break;
 585       case 'r':
 586 #ifdef HAVE_LANGINFO_H
 587          exp_fmt = nl_langinfo(T_FMT_AMPM);
 588 #else
 589          exp_fmt = "";
 590 #endif
 591          break;
 592       case 'R':
 593          exp_fmt =  "%H:%M";
 594          break;
 595       case 'T':
 596          exp_fmt =  "%H:%M:%S";
 597          break;
 598       case 'D':
 599          exp_fmt =  "%m/%d/%y";
 600          break;
 601       case 'F':
 602          exp_fmt =  "%Y-%m-%d";
 603          break;
 604       default:
 605          exp_fmt =  "";
 606          break;
 607      }
 608    return exp_fmt;
 609 }
 610
 611 static void
 612 _expand_format(char * dt_fmt)
 613 {
 614    char *ptr, *expanded_fmt, ch;
 615    char buf[MAX_FORMAT_LEN] = {0,};
 616    unsigned int idx = 0, len = 0;
 617    Eina_Bool fmt_char = EINA_FALSE;
 618
 619    ptr = dt_fmt;
 620    while ((ch = *ptr))
 621      {
 622         if ((fmt_char) && (strchr(multifield_formats, ch)))
 623           {
 624              // replace the multi-field format characters with corresponding expanded format
 625              expanded_fmt = _expanded_fmt_str_get(ch);
 626              len = strlen(expanded_fmt);
 627              buf[--idx] = 0;
 628              strncat(buf, expanded_fmt, len);
 629              idx += len;
 630           }
 631         else buf[idx++] = ch;
 632         if (ch == '%') fmt_char = EINA_TRUE;
 633         else fmt_char = EINA_FALSE;
 634         ptr++;
 635      }
 636    buf[idx] = 0;
 637    strncpy(dt_fmt, buf, MAX_FORMAT_LEN);
 638 }
 639
 640 static unsigned int
 641 _parse_format(Evas_Object *obj, char *fmt_ptr)
 642 {
 643    Widget_Data *wd;
 644    Datetime_Field *field = NULL;
 645    unsigned int len = 0, idx, location = 0;
 646    char separator[MAX_SEPARATOR_LEN];
 647    char cur;
 648    Eina_Bool fmt_parsing = EINA_FALSE, sep_parsing = EINA_FALSE,
 649              sep_lookup = EINA_FALSE;
 650
 651    wd = elm_widget_data_get(obj);
 652
 653    while ((cur = *fmt_ptr))
 654      {
 655         if (fmt_parsing)
 656           {
 657              fmt_parsing = EINA_FALSE;
 658              for (idx = 0; idx < DATETIME_TYPE_COUNT; idx++)
 659                {
 660                   if (strchr(mapping[idx].fmt_char, cur))
 661                     {
 662                        field = wd->field_list + idx;
 663                        // ignore the fields already have or disabled
 664                        // valid formats, means already parsed & repeated, ignore.
 665                        if (!field->visible || field->location != -1) break;
 666                        field->fmt[1] = cur;
 667                        field->fmt_exist = EINA_TRUE;
 668                        field->location = location++;
 669                        sep_lookup = EINA_TRUE;
 670                        len = 0;
 671                        break;
 672                     }
 673                }
 674           }
 675         if (cur == '%')
 676           {
 677              fmt_parsing = EINA_TRUE;
 678              sep_parsing = EINA_FALSE;
 679              // set the separator to previous field
 680              separator[len] = 0;
 681              if (field) eina_stringshare_replace(&field->separator, separator);
 682           }
 683
 684         // ignore the set of chars (global, field specific).
 685         if (sep_parsing && (len < MAX_SEPARATOR_LEN - 1) &&
 686             (field->type != ELM_DATETIME_AMPM) && (!strchr(ignore_separators, cur)) &&
 687             (!strchr(mapping[idx].ignore_sep, cur)))
 688            separator[len++] = cur;
 689         if (sep_lookup) sep_parsing = EINA_TRUE;
 690         sep_lookup = EINA_FALSE;
 691         fmt_ptr++;
 692    }
 693    // return the number of valid fields parsed.
 694    return location;
 695 }
 696
 697 static void
 698 _reload_format(Evas_Object *obj)
 699 {
 700    Widget_Data *wd;
 701    Datetime_Field *field;
 702    char buf[BUFFER_SIZE];
 703    unsigned int idx, field_count;
 704    char *dt_fmt;
 705
 706    wd = elm_widget_data_get(obj);
 707    if (!wd) return;
 708
 709    // FIXME: provide nl_langinfo on Windows if possible
 710    // fetch the default format from Libc.
 711    if (!wd->user_format)
 712 #ifdef HAVE_LANGINFO_H
 713      strncpy(wd->format, nl_langinfo(D_T_FMT), MAX_FORMAT_LEN);
 714 #else
 715      strncpy(wd->format, "", MAX_FORMAT_LEN);
 716 #endif
 717
 718    dt_fmt = (char *)malloc(MAX_FORMAT_LEN);
 719    strncpy(dt_fmt, wd->format, MAX_FORMAT_LEN);
 720
 721    _expand_format(dt_fmt);
 722
 723    // reset all the fields to disable state
 724    for (idx = 0; idx < DATETIME_TYPE_COUNT; idx++)
 725      {
 726         field = wd->field_list + idx;
 727         field->fmt_exist = EINA_FALSE;
 728         field->location = -1;
 729      }
 730
 731    field_count = _parse_format(obj, dt_fmt);
 732    free(dt_fmt);
 733
 734    // assign locations to disabled fields for uniform usage
 735    for (idx = 0; idx < DATETIME_TYPE_COUNT; idx++)
 736      {
 737         field = wd->field_list + idx;
 738         if (field->location == -1) field->location = field_count++;
 739
 740         if (field->fmt_exist && field->visible)
 741           {
 742              snprintf(buf, sizeof(buf), EDC_PART_FIELD_ENABLE_SIG_STR,
 743                       field->location);
 744              edje_object_signal_emit(wd->base, buf, "elm");
 745           }
 746         else
 747           {
 748              snprintf(buf, sizeof(buf),EDC_PART_FIELD_DISABLE_SIG_STR,
 749                       field->location);
 750              edje_object_signal_emit(wd->base, buf, "elm");
 751           }
 752         snprintf(buf, sizeof(buf), EDC_PART_SEPARATOR_STR, (field->location + 1));
 753         edje_object_part_text_set(wd->base, buf, field->separator);
 754      }
 755    edje_object_message_signal_process(wd->base);
 756    _field_list_arrange(obj);
 757 }
 758
 759 static void
 760 _field_list_init(Evas_Object *obj)
 761 {
 762    Widget_Data *wd;
 763    Datetime_Field *field;
 764    unsigned int idx;
 765    time_t t;
 766
 767    wd = elm_widget_data_get(obj);
 768    if (!wd) return;
 769
 770    t = time(NULL);
 771    localtime_r(&t, &wd->curr_time);
 772
 773    mapping[ELM_DATETIME_YEAR].def_min = _elm_config->year_min;
 774    mapping[ELM_DATETIME_YEAR].def_max = _elm_config->year_max;
 775    for (idx = 0; idx < DATETIME_TYPE_COUNT; idx++)
 776      {
 777         field = wd->field_list + idx;
 778         field->type = ELM_DATETIME_YEAR + idx;
 779         field->fmt[0] = '%';
 780         field->fmt_exist = EINA_FALSE;
 781         field->visible  = EINA_TRUE;
 782         field->min = mapping[idx].def_min;
 783         field->max = mapping[idx].def_max;
 784      }
 785    DATETIME_TM_ARRAY(min_timearr, &wd->min_limit);
 786    DATETIME_TM_ARRAY(max_timearr, &wd->max_limit);
 787    for (idx = 0; idx < DATETIME_TYPE_COUNT-1; idx++)
 788      {
 789         *min_timearr[idx] = mapping[idx].def_min;
 790         *max_timearr[idx] = mapping[idx].def_max;
 791      }
 792 }
 793
 794 EAPI Evas_Object *
 795 elm_datetime_add(Evas_Object *parent)
 796 {
 797    Evas_Object *obj;
 798    Evas *e;
 799    Widget_Data *wd;
 800    Datetime_Field *field;
 801    int idx;
 802
 803    ELM_WIDGET_STANDARD_SETUP(wd, Widget_Data, parent, e, obj, NULL);
 804
 805    ELM_SET_WIDTYPE(widtype, "datetime");
 806    elm_widget_type_set(obj, widtype);
 807    elm_widget_sub_object_add(parent, obj);
 808    elm_widget_data_set(obj, wd);
 809    elm_widget_del_hook_set(obj, _del_hook);
 810    elm_widget_theme_hook_set(obj, _theme_hook);
 811    elm_widget_translate_hook_set(obj, _translate_hook);
 812    elm_widget_on_focus_hook_set(obj, _on_focus_hook, NULL);
 813    elm_widget_disable_hook_set(obj, _disable_hook);
 814    elm_widget_can_focus_set(obj, EINA_TRUE);
 815    elm_widget_focus_next_hook_set(obj, _elm_datetime_focus_next_hook);
 816
 817    wd->base = edje_object_add(e);
 818    elm_widget_resize_object_set(obj, wd->base);
 819    _elm_theme_object_set(obj, wd->base, "datetime", "base", "default");
 820    evas_object_smart_callbacks_descriptions_set(obj, _signals);
 821
 822    // module - initialise module for datetime
 823    if (!dt_mod) dt_mod = _dt_mod_init();
 824    if ((dt_mod) && (dt_mod->obj_hook))
 825      wd->mod_data = dt_mod->obj_hook(obj);
 826    // update module data
 827    if (wd->mod_data)
 828      {
 829         wd->mod_data->base = obj;
 830         wd->mod_data->field_limit_get = _field_limit_get;
 831         wd->mod_data->field_format_get = _field_format_get;
 832      }
 833
 834    _field_list_init(obj);
 835    _reload_format(obj);
 836
 837    if ((dt_mod)&&(dt_mod->field_create))
 838      {
 839         for (idx = 0; idx < DATETIME_TYPE_COUNT; idx++)
 840           {
 841              field = wd->field_list + idx;
 842              field->item_obj = dt_mod->field_create(wd->mod_data, idx);
 843           }
 844      }
 845    _field_list_arrange(obj);
 846    _mirrored_set(obj, elm_widget_mirrored_get(obj));
 847
 848    return obj;
 849 }
 850
 851 EAPI const char *
 852 elm_datetime_format_get(const Evas_Object *obj)
 853 {
 854    ELM_CHECK_WIDTYPE(obj, widtype) NULL;
 855    Widget_Data *wd;
 856
 857    wd = elm_widget_data_get(obj);
 858    if (!wd) return NULL;
 859
 860    return wd->format;
 861 }
 862
 863 EAPI void
 864 elm_datetime_format_set(Evas_Object *obj, const char *fmt)
 865 {
 866    ELM_CHECK_WIDTYPE(obj, widtype);
 867    Widget_Data *wd;
 868
 869    wd = elm_widget_data_get(obj);
 870    if (!wd) return;
 871
 872    if (fmt)
 873      {
 874         strncpy(wd->format, fmt, MAX_FORMAT_LEN);
 875         wd->user_format = EINA_TRUE;
 876      }
 877    else
 878      wd->user_format = EINA_FALSE;
 879
 880    _reload_format(obj);
 881 }
 882
 883 EAPI Eina_Bool
 884 elm_datetime_field_visible_get(const Evas_Object *obj, Elm_Datetime_Field_Type
 885                                fieldtype)
 886 {
 887    ELM_CHECK_WIDTYPE(obj, widtype) EINA_FALSE;
 888    Widget_Data *wd;
 889    Datetime_Field *field;
 890
 891    wd = elm_widget_data_get(obj);
 892    if (!wd || (fieldtype > ELM_DATETIME_AMPM)) return EINA_FALSE;
 893
 894    field = wd->field_list + fieldtype;
 895    return field->visible;
 896 }
 897
 898 EAPI void
 899 elm_datetime_field_visible_set(Evas_Object *obj, Elm_Datetime_Field_Type fieldtype,
 900                               Eina_Bool visible)
 901 {
 902    ELM_CHECK_WIDTYPE(obj, widtype);
 903    Widget_Data *wd;
 904    Datetime_Field *field;
 905
 906    wd = elm_widget_data_get(obj);
 907    if (!wd || (fieldtype > ELM_DATETIME_AMPM)) return;
 908
 909    field = wd->field_list + fieldtype;
 910    if (field->visible == visible) return;
 911
 912    field->visible = visible;
 913    _reload_format(obj);
 914 }
 915
 916 EAPI void
 917 elm_datetime_field_limit_get(const Evas_Object *obj, Elm_Datetime_Field_Type fieldtype,
 918                              int *min, int *max)
 919 {
 920    ELM_CHECK_WIDTYPE(obj, widtype);
 921    Widget_Data *wd;
 922    Datetime_Field *field;
 923
 924    wd = elm_widget_data_get(obj);
 925    if (!wd || (fieldtype >= ELM_DATETIME_AMPM)) return;
 926
 927    field = wd->field_list + fieldtype;
 928    if (min) *min = field->min;
 929    if (max) *max = field->max;
 930 }
 931
 932 EAPI void
 933 elm_datetime_field_limit_set(Evas_Object *obj, Elm_Datetime_Field_Type fieldtype,
 934                              int min, int max)
 935 {
 936    ELM_CHECK_WIDTYPE(obj, widtype);
 937    Widget_Data *wd;
 938    Datetime_Field *field;
 939
 940    wd = elm_widget_data_get(obj);
 941    if (!wd || (fieldtype >= ELM_DATETIME_AMPM)) return;
 942
 943    if (min > max) return;
 944
 945    field = wd->field_list + fieldtype;
 946    if ((min > mapping[fieldtype].def_min && min < mapping[fieldtype].def_max)
 947         || (field->type == ELM_DATETIME_YEAR))
 948      field->min = min;
 949    if ((max > mapping[fieldtype].def_min && max < mapping[fieldtype].def_max)
 950         || (field->type == ELM_DATETIME_YEAR))
 951      field->max = max;
 952
 953    _apply_field_limits(obj);
 954 }
 955
 956 EAPI Eina_Bool
 957 elm_datetime_value_get(const Evas_Object *obj, struct tm *currtime)
 958 {
 959    ELM_CHECK_WIDTYPE(obj, widtype) EINA_FALSE;
 960    EINA_SAFETY_ON_NULL_RETURN_VAL(currtime, EINA_FALSE);
 961    Widget_Data *wd;
 962
 963    wd = elm_widget_data_get(obj);
 964    if (!wd) return EINA_FALSE;
 965
 966    *currtime = wd->curr_time;
 967    return EINA_TRUE;
 968 }
 969
 970 EAPI Eina_Bool
 971 elm_datetime_value_set(Evas_Object *obj, const struct tm *newtime)
 972 {
 973    ELM_CHECK_WIDTYPE(obj, widtype) EINA_FALSE;
 974    EINA_SAFETY_ON_NULL_RETURN_VAL(newtime, EINA_FALSE);
 975    Widget_Data *wd;
 976    struct tm old_time;
 977
 978    wd = elm_widget_data_get(obj);
 979    if (!wd) return EINA_FALSE;
 980
 981    old_time = wd->curr_time;
 982    wd->curr_time = *newtime;
 983    // apply default field restrictions for curr_time
 984    _apply_range_restrictions(obj, &wd->curr_time);
 985    // validate the curr_time according to the min_limt and max_limt
 986    _validate_datetime_limits(&wd->curr_time, &wd->min_limit, EINA_FALSE);
 987    _validate_datetime_limits(&wd->max_limit, &wd->curr_time, EINA_TRUE);
 988    _apply_field_limits(obj);
 989
 990    if (!_date_cmp(&old_time, &wd->curr_time))
 991      evas_object_smart_callback_call(obj, SIG_CHANGED, NULL);
 992
 993    return EINA_TRUE;
 994 }
 995
 996 EAPI Eina_Bool
 997 elm_datetime_value_min_get(const Evas_Object *obj, struct tm *mintime)
 998 {
 999    ELM_CHECK_WIDTYPE(obj, widtype) EINA_FALSE;
1000    EINA_SAFETY_ON_NULL_RETURN_VAL(mintime, EINA_FALSE);
1001    Widget_Data *wd;
1002
1003    wd = elm_widget_data_get(obj);
1004    if (!wd) return EINA_FALSE;
1005
1006    *mintime = wd->min_limit;
1007    return EINA_TRUE;
1008 }
1009
1010 EAPI Eina_Bool
1011 elm_datetime_value_min_set(Evas_Object *obj, const struct tm *mintime)
1012 {
1013    ELM_CHECK_WIDTYPE(obj, widtype) EINA_FALSE;
1014    EINA_SAFETY_ON_NULL_RETURN_VAL(mintime, EINA_FALSE);
1015    Widget_Data *wd;
1016    struct tm old_time;
1017
1018    wd = elm_widget_data_get(obj);
1019    if (!wd) return EINA_FALSE;
1020
1021    wd->min_limit = *mintime;
1022    old_time = wd->curr_time;
1023    // apply default field restrictions for min_limit
1024    _apply_range_restrictions(obj, &wd->min_limit);
1025    // validate curr_time and max_limt according to the min_limit
1026    _validate_datetime_limits(&wd->max_limit, &wd->min_limit, EINA_FALSE);
1027    _validate_datetime_limits(&wd->curr_time, &wd->min_limit, EINA_FALSE);
1028    _apply_field_limits(obj);
1029
1030    if (!_date_cmp(&old_time, &wd->curr_time))
1031      evas_object_smart_callback_call(obj, SIG_CHANGED, NULL);
1032
1033    return EINA_TRUE;
1034 }
1035
1036 EAPI Eina_Bool
1037 elm_datetime_value_max_get(const Evas_Object *obj, struct tm *maxtime)
1038 {
1039    ELM_CHECK_WIDTYPE(obj, widtype) EINA_FALSE;
1040    EINA_SAFETY_ON_NULL_RETURN_VAL(maxtime, EINA_FALSE);
1041    Widget_Data *wd;
1042
1043    wd = elm_widget_data_get(obj);
1044    if (!wd) return EINA_FALSE;
1045
1046    *maxtime = wd->max_limit;
1047    return EINA_TRUE;
1048 }
1049
1050 EAPI Eina_Bool
1051 elm_datetime_value_max_set(Evas_Object *obj, const struct tm *maxtime)
1052 {
1053    ELM_CHECK_WIDTYPE(obj, widtype) EINA_FALSE;
1054    EINA_SAFETY_ON_NULL_RETURN_VAL(maxtime, EINA_FALSE);
1055    Widget_Data *wd;
1056    struct tm old_time;
1057
1058    wd = elm_widget_data_get(obj);
1059    if (!wd) return EINA_FALSE;
1060
1061    wd->max_limit = *maxtime;
1062    old_time = wd->curr_time;
1063    // apply default field restrictions for max_limit
1064    _apply_range_restrictions(obj, &wd->max_limit);
1065    // validate curr_time and min_limt according to the max_limit
1066    _validate_datetime_limits(&wd->max_limit, &wd->min_limit, EINA_TRUE);
1067    _validate_datetime_limits(&wd->max_limit, &wd->curr_time, EINA_TRUE);
1068    _apply_field_limits(obj);
1069
1070    if (!_date_cmp(&old_time, &wd->curr_time))
1071      evas_object_smart_callback_call(obj, SIG_CHANGED, NULL);
1072
1073    return EINA_TRUE;
1074 }