src/lib/elm_datefield.c

   1 #include <Elementary.h>
   2 #include "elm_priv.h"
   3
   4 /**
   5  * @defgroup Datefield Datefield
   6  * @ingroup Elementary
   7  *
   8  * This is a date editfield. it is used to input date and time using keypad
   9  */
  10
  11 typedef struct _Widget_Data Widget_Data;
  12
  13 enum {
  14         DATE_YEAR,
  15         DATE_MON,
  16         DATE_DAY,
  17         DATE_MAX
  18 };
  19
  20 enum {
  21         TIME_HOUR,
  22         TIME_MIN,
  23         TIME_MAX
  24 };
  25
  26 enum {
  27         DATE_FORMAT_YYMMDD,
  28         DATE_FORMAT_YYDDMM,
  29         DATE_FORMAT_MMYYDD,
  30         DATE_FORMAT_MMDDYY,
  31         DATE_FORMAT_DDYYMM,
  32         DATE_FORMAT_DDMMYY,
  33         DATE_FORMAT_MAX
  34 };
  35
  36 #define YEAR_MAX_LENGTH 4
  37 #define MONTH_MAX_LENGTH        3
  38 #define DAY_MAX_LENGTH          2
  39 #define TIME_MAX_LENGTH 2
  40
  41 #define MONTH_MAXIMUM           12
  42 #define HOUR_24H_MAXIMUM        23
  43 #define HOUR_12H_MAXIMUM        12
  44 #define MIN_MAXIMUM             59
  45
  46 static char month_label[12][4] = {"Jan", "Feb", "Mar", "Apr", "May", "Jun", "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"};
  47
  48 struct _Widget_Data
  49 {
  50         Evas_Object *base;
  51         Evas_Object *date[DATE_MAX];
  52         Evas_Object *time[TIME_MAX];
  53         Ecore_Event_Handler *handler;
  54         Ecore_Idler *idler;
  55         int layout;
  56
  57         int year, month, day, hour, min;
  58         int y_max, m_max, d_max;
  59         int y_min, m_min, d_min;
  60         int date_format;
  61         Eina_Bool pm:1;
  62         Eina_Bool time_mode:1;
  63         Eina_Bool editing:1;
  64
  65         void (*func)(void *data, Evas_Object *obj, int value);
  66         void *func_data;
  67 };
  68
  69 static const char *widtype = NULL;
  70
  71 static void _del_hook(Evas_Object *obj);
  72 static void _theme_hook(Evas_Object *obj);
  73 static void _sizing_eval(Evas_Object *obj);
  74 static void _on_focus_hook(void *data, Evas_Object *obj);
  75
  76 static void _signal_rect_mouse_down(void *data, Evas_Object *obj, const char *emission, const char *source);
  77 static void _signal_ampm_mouse_down(void *data, Evas_Object *obj, const char *emission, const char *source);
  78 static void _signal_ampm_clicked(void *data, Evas_Object *obj, const char *emission, const char *source);
  79 static void _entry_focused_cb(void *data, Evas_Object *obj, void *event_info);
  80 static void _entry_unfocused_cb(void *data, Evas_Object *obj, void *event_info);
  81 static void _entry_key_up_cb(void *data, Evas *e , Evas_Object *obj , void *event_info);
  82 static Eina_Bool _imf_event_commit_cb(void *data, int type, void *event);
  83 static void _input_panel_event_callback(void *data, Ecore_IMF_Context *ctx, int value);
  84
  85 static void _date_entry_add(Evas_Object *obj);
  86 static void _time_entry_add(Evas_Object *obj);
  87 static void _date_update(Evas_Object *obj);
  88 static Eina_Bool _focus_idler_cb(void *obj);
  89 static void _entry_focus_move(Evas_Object *obj, Evas_Object *focus_obj);
  90 static Eina_Bool _check_input_done(Evas_Object *obj, Evas_Object *focus_obj, int strlen);
  91 static int _maximum_day_get(int year, int month);
  92 static int _check_date_boundary(Evas_Object *obj, int num, int flag);
  93
  94 static void
  95 _del_hook(Evas_Object *obj)
  96 {
  97         Widget_Data *wd = elm_widget_data_get(obj);
  98         if (!wd) return ;
  99
 100         ecore_event_handler_del(wd->handler);
 101
 102         free(wd);
 103 }
 104
 105 static void
 106 _on_focus_hook(void *data, Evas_Object *obj)
 107 {
 108         Widget_Data *wd = elm_widget_data_get(obj);
 109         if (!wd || !wd->base) return ;
 110
 111         if (elm_widget_focus_get(obj)) wd->idler = ecore_idler_add(_focus_idler_cb, obj);
 112 }
 113
 114 static void
 115 _theme_hook(Evas_Object *obj)
 116 {
 117         Widget_Data *wd = elm_widget_data_get(obj);
 118         int i;
 119         if (!wd || !wd->base) return;
 120
 121         if (wd->layout == ELM_DATEFIELD_LAYOUT_DATEANDTIME)
 122         {
 123                 _elm_theme_object_set(obj, wd->base, "datefield", "dateandtime", elm_widget_style_get(obj));
 124
 125                 for (i = 0; i < DATE_MAX; i++)
 126                         elm_object_style_set(wd->date[i], "datefield/hybrid");
 127                 for (i = 0; i < TIME_MAX; i++)
 128                         elm_object_style_set(wd->time[i], "datefield/hybrid");
 129         }
 130         else if (wd->layout == ELM_DATEFIELD_LAYOUT_DATE)
 131         {
 132                 _elm_theme_object_set(obj, wd->base, "datefield", "date", elm_widget_style_get(obj));
 133
 134                 for (i = 0; i < DATE_MAX; i++)
 135                         elm_object_style_set(wd->date[i], "datefield");
 136
 137                 for (i = 0; i < TIME_MAX; i++)
 138                         evas_object_hide(wd->time[i]);
 139         }
 140         else if (wd->layout == ELM_DATEFIELD_LAYOUT_TIME)
 141         {
 142                 _elm_theme_object_set(obj, wd->base, "datefield", "time", elm_widget_style_get(obj));
 143
 144                 for (i = 0; i < TIME_MAX; i++)
 145                         elm_object_style_set(wd->time[i], "datefield");
 146
 147                 for (i = 0; i < DATE_MAX; i++)
 148                         evas_object_hide(wd->date[i]);
 149         }
 150
 151         if (wd->layout == ELM_DATEFIELD_LAYOUT_DATEANDTIME || wd->layout == ELM_DATEFIELD_LAYOUT_DATE)
 152         {
 153                 edje_object_part_swallow(wd->base, "elm.swallow.date.year", wd->date[DATE_YEAR]);
 154                 edje_object_part_swallow(wd->base, "elm.swallow.date.month", wd->date[DATE_MON]);
 155                 edje_object_part_swallow(wd->base, "elm.swallow.date.day", wd->date[DATE_DAY]);
 156                 edje_object_part_text_set(wd->base, "elm.text.date.comma", ",");
 157         }
 158
 159         if (wd->layout == ELM_DATEFIELD_LAYOUT_DATEANDTIME || wd->layout == ELM_DATEFIELD_LAYOUT_TIME)
 160         {
 161                 edje_object_part_swallow(wd->base, "elm.swallow.time.hour", wd->time[TIME_HOUR]);
 162                 edje_object_part_swallow(wd->base, "elm.swallow.time.min", wd->time[TIME_MIN]);
 163                 edje_object_part_text_set(wd->base, "elm.text.colon", ":");
 164         }
 165
 166         edje_object_scale_set(wd->base, elm_widget_scale_get(obj) * _elm_config->scale);
 167
 168         _date_update(obj);
 169         _sizing_eval(obj);
 170 }
 171
 172 static void
 173 _sizing_eval(Evas_Object *obj)
 174 {
 175         Widget_Data *wd = elm_widget_data_get(obj);
 176         Evas_Coord minw = -1, minh = -1;
 177
 178         edje_object_size_min_calc(wd->base, &minw, &minh);
 179         evas_object_size_hint_min_set(obj, minw, minh);
 180         evas_object_size_hint_max_set(obj, -1, -1);
 181 }
 182
 183 static void
 184 _signal_ampm_mouse_down(void *data, Evas_Object *obj, const char *emission, const char *source)
 185 {
 186         Widget_Data *wd = elm_widget_data_get(data);
 187         Evas_Object *focus_obj;
 188
 189         if (!wd || !wd->base) return ;
 190
 191         focus_obj = elm_widget_focused_object_get(data);
 192         if (focus_obj) elm_object_unfocus(focus_obj);
 193 }
 194
 195 static void
 196 _signal_ampm_clicked(void *data, Evas_Object *obj, const char *emission, const char *source)
 197 {
 198         Widget_Data *wd = elm_widget_data_get(data);
 199         if (!wd || !wd->base) return ;
 200
 201         wd->pm = !wd->pm;
 202
 203         if (wd->pm)
 204         {
 205                 edje_object_part_text_set(wd->base, "elm.text.ampm", "PM");
 206                 wd->hour += HOUR_12H_MAXIMUM;
 207         }
 208         else
 209         {
 210                 edje_object_part_text_set(wd->base, "elm.text.ampm", "AM");
 211                 wd->hour -= HOUR_12H_MAXIMUM;
 212         }
 213 }
 214
 215 static void
 216 _signal_rect_mouse_down(void *data, Evas_Object *obj, const char *emission, const char *source)
 217 {
 218         Widget_Data *wd = elm_widget_data_get(data);
 219         if (!wd) return ;
 220
 221         if (!strcmp(source, "elm.rect.date.year.over"))
 222                 elm_object_focus(wd->date[DATE_YEAR]);
 223         else if (!strcmp(source, "elm.rect.date.month.over"))
 224                 elm_object_focus(wd->date[DATE_MON]);
 225         else if (!strcmp(source, "elm.rect.date.day.over"))
 226                 elm_object_focus(wd->date[DATE_DAY]);
 227         else if (!strcmp(source, "elm.rect.time.hour.over"))
 228                 elm_object_focus(wd->time[TIME_HOUR]);
 229         else if (!strcmp(source, "elm.rect.time.min.over"))
 230                 elm_object_focus(wd->time[TIME_MIN]);
 231         else if (!strcmp(source, "elm.rect.date.left.pad"))
 232         {
 233                 switch (wd->date_format)
 234                 {
 235                         case DATE_FORMAT_YYDDMM:
 236                         case DATE_FORMAT_YYMMDD:
 237                                 elm_object_focus(wd->date[DATE_YEAR]);
 238                                 break;
 239                         case DATE_FORMAT_MMDDYY:
 240                         case DATE_FORMAT_MMYYDD:
 241                                 elm_object_focus(wd->date[DATE_MON]);
 242                                 break;
 243                         case DATE_FORMAT_DDMMYY:
 244                         case DATE_FORMAT_DDYYMM:
 245                                 elm_object_focus(wd->date[DATE_DAY]);
 246                 }
 247         }
 248         else if (!strcmp(source, "elm.rect.date.right.pad"))
 249         {
 250                 switch (wd->date_format)
 251                 {
 252                         case DATE_FORMAT_MMDDYY:
 253                         case DATE_FORMAT_DDMMYY:
 254                                 elm_object_focus(wd->date[DATE_YEAR]);
 255                                 break;
 256                         case DATE_FORMAT_DDYYMM:
 257                         case DATE_FORMAT_YYDDMM:
 258                                 elm_object_focus(wd->date[DATE_MON]);
 259                                 break;
 260                         case DATE_FORMAT_YYMMDD:
 261                         case DATE_FORMAT_MMYYDD:
 262                                 elm_object_focus(wd->date[DATE_DAY]);
 263                 }
 264         }
 265 }
 266
 267 static Eina_Bool
 268 _focus_idler_cb(void *obj)
 269 {
 270         Widget_Data *wd = elm_widget_data_get(obj);
 271         Evas_Object *focus_obj;
 272
 273         focus_obj = elm_widget_focused_object_get(obj);
 274         if (focus_obj == obj)
 275         {
 276                 if (wd->layout == ELM_DATEFIELD_LAYOUT_TIME)
 277                         elm_object_focus(wd->time[TIME_HOUR]);
 278
 279                 else if (wd->layout == ELM_DATEFIELD_LAYOUT_DATEANDTIME || wd->layout == ELM_DATEFIELD_LAYOUT_DATE)
 280                 {
 281                         switch (wd->date_format)
 282                         {
 283                                 case DATE_FORMAT_YYDDMM:
 284                                 case DATE_FORMAT_YYMMDD:
 285                                         elm_object_focus(wd->date[DATE_YEAR]);
 286                                         break;
 287                                 case DATE_FORMAT_MMDDYY:
 288                                 case DATE_FORMAT_MMYYDD:
 289                                         elm_object_focus(wd->date[DATE_MON]);
 290                                         break;
 291                                 case DATE_FORMAT_DDMMYY:
 292                                 case DATE_FORMAT_DDYYMM:
 293                                         elm_object_focus(wd->date[DATE_DAY]);
 294                         }
 295                 }
 296         }
 297         wd->idler = NULL;
 298         return EINA_FALSE;
 299 }
 300
 301 static void
 302 _entry_focused_cb(void *data, Evas_Object *obj, void *event_info)
 303 {
 304         Widget_Data *wd = elm_widget_data_get(data);
 305         if (!wd || !wd->base) return;
 306
 307         if (wd->idler)
 308         {
 309                 ecore_idler_del(wd->idler);
 310                 wd->idler = NULL;
 311         }
 312
 313         if (obj == wd->date[DATE_YEAR])
 314                 edje_object_signal_emit(wd->base, "elm,state,year,focus,in", "elm");
 315         else if (obj == wd->date[DATE_MON])
 316                 edje_object_signal_emit(wd->base, "elm,state,month,focus,in", "elm");
 317         else if (obj == wd->date[DATE_DAY])
 318                 edje_object_signal_emit(wd->base, "elm,state,day,focus,in", "elm");
 319         else if (obj == wd->time[TIME_HOUR])
 320                 edje_object_signal_emit(wd->base, "elm,state,hour,focus,in", "elm");
 321         else if (obj == wd->time[TIME_MIN])
 322                 edje_object_signal_emit(wd->base, "elm,state,min,focus,in", "elm");
 323 }
 324
 325 static void
 326 _entry_unfocused_cb(void *data, Evas_Object *obj, void *event_info)
 327 {
 328         Widget_Data *wd = elm_widget_data_get(data);
 329         char str[YEAR_MAX_LENGTH+1] = {0,};
 330         int num = 0;
 331
 332         if (!wd || !wd->base) return;
 333         wd->editing = FALSE;
 334
 335         if (obj == wd->date[DATE_YEAR])
 336         {
 337                 if (strlen(elm_entry_entry_get(wd->date[DATE_YEAR]))) wd->year = atoi(elm_entry_entry_get(wd->date[DATE_YEAR]));
 338                 wd->year = _check_date_boundary(data, wd->year, DATE_YEAR);
 339                 sprintf(str, "%d", wd->year);
 340                 elm_entry_entry_set(wd->date[DATE_YEAR], str);
 341
 342                 //check month boundary
 343                 if(wd->month != (num = _check_date_boundary(data, wd->month, DATE_MON)))
 344                 {
 345                         wd->month = num;
 346                         elm_entry_entry_set(wd->date[DATE_MON], month_label[wd->month-1]);
 347                 }
 348                 //check day boundary
 349                 if (wd->day != (num = _check_date_boundary(data, wd->day, DATE_DAY)))
 350                 {
 351                         wd->day = num;
 352                         sprintf(str, "%d", wd->day);
 353                         elm_entry_entry_set(wd->date[DATE_DAY], str);
 354                 }
 355                 edje_object_signal_emit(wd->base, "elm,state,year,focus,out", "elm");
 356         }
 357         else if (obj == wd->date[DATE_MON])
 358         {
 359                 if(wd->month != (num = _check_date_boundary(data, wd->month, DATE_MON)))
 360                 {
 361                         wd->month = num;
 362                         elm_entry_entry_set(wd->date[DATE_MON], month_label[wd->month-1]);
 363                 }
 364                 //check day boundary
 365                 if (wd->day != (num = _check_date_boundary(data, wd->day, DATE_DAY)))
 366                 {
 367                         wd->day = num;
 368                         sprintf(str, "%d", wd->day);
 369                         elm_entry_entry_set(wd->date[DATE_DAY], str);
 370                 }
 371                 edje_object_signal_emit(wd->base, "elm,state,month,focus,out", "elm");
 372         }
 373         else if (obj == wd->date[DATE_DAY])
 374         {
 375                 if (strlen(elm_entry_entry_get(wd->date[DATE_DAY]))) wd->day = atoi(elm_entry_entry_get(wd->date[DATE_DAY]));
 376                 wd->day = _check_date_boundary(data, wd->day, DATE_DAY);
 377                 sprintf(str, "%d", wd->day);
 378                 elm_entry_entry_set(wd->date[DATE_DAY], str);
 379                 edje_object_signal_emit(wd->base, "elm,state,day,focus,out", "elm");
 380         }
 381         else if (obj == wd->time[TIME_HOUR])
 382         {
 383                 if (strlen(elm_entry_entry_get(wd->time[TIME_HOUR]))) num = atoi(elm_entry_entry_get(wd->time[TIME_HOUR]));
 384                 else num = wd->hour;
 385
 386                 if (!wd->time_mode) // 24 mode
 387                 {
 388                         if (num > HOUR_24H_MAXIMUM) num = HOUR_24H_MAXIMUM;
 389                         wd->hour = num;
 390                 }
 391                 else // 12 mode
 392                 {
 393                         if (num > HOUR_24H_MAXIMUM || num == 0)
 394                         {
 395                                 num = HOUR_12H_MAXIMUM;
 396                                 wd->pm = EINA_FALSE;
 397                         }
 398                         else if (num > HOUR_12H_MAXIMUM)
 399                         {
 400                                 num -= HOUR_12H_MAXIMUM;
 401                                 wd->pm = EINA_TRUE;
 402                         }
 403                         wd->hour = (wd->pm == EINA_TRUE)? num + HOUR_12H_MAXIMUM : num;
 404                         if((wd->hour % 12) == 0) wd->hour -= HOUR_12H_MAXIMUM;
 405
 406                         if (wd->pm) edje_object_part_text_set(wd->base, "elm.text.ampm", "PM");
 407                         else edje_object_part_text_set(wd->base, "elm.text.ampm", "AM");
 408                 }
 409                 sprintf(str, "%02d", num);
 410                 elm_entry_entry_set(wd->time[TIME_HOUR], str);
 411                 edje_object_signal_emit(wd->base, "elm,state,hour,focus,out", "elm");
 412         }
 413         else if (obj == wd->time[TIME_MIN])
 414         {
 415                 if (strlen(elm_entry_entry_get(wd->time[TIME_MIN]))) wd->min = atoi(elm_entry_entry_get(wd->time[TIME_MIN]));
 416                 if (wd->min > MIN_MAXIMUM) wd->min = MIN_MAXIMUM;
 417
 418                 sprintf(str, "%02d", wd->min);
 419                 elm_entry_entry_set(wd->time[TIME_MIN], str);
 420                 edje_object_signal_emit(wd->base, "elm,state,min,focus,out", "elm");
 421         }
 422         evas_object_smart_callback_call(data, "changed", NULL);
 423 }
 424
 425 static void
 426 _entry_focus_move(Evas_Object *obj, Evas_Object *focus_obj)
 427 {
 428         Widget_Data *wd = elm_widget_data_get(obj);
 429
 430         if (!wd) return;
 431
 432         if (focus_obj == wd->date[DATE_YEAR])
 433         {
 434                 switch (wd->date_format)
 435                 {
 436                         case DATE_FORMAT_DDMMYY:
 437                         case DATE_FORMAT_MMDDYY:
 438                                 if (wd->layout == ELM_DATEFIELD_LAYOUT_DATEANDTIME)
 439                                         elm_object_focus(wd->time[TIME_HOUR]);
 440                                 else if (wd->layout == ELM_DATEFIELD_LAYOUT_DATE)
 441                                         elm_object_unfocus(wd->date[DATE_YEAR]);
 442                                 break;
 443                         case DATE_FORMAT_DDYYMM:
 444                         case DATE_FORMAT_YYMMDD:
 445                                 elm_object_focus(wd->date[DATE_MON]);
 446                                 break;
 447                         case DATE_FORMAT_MMYYDD:
 448                         case DATE_FORMAT_YYDDMM:
 449                                 elm_object_focus(wd->date[DATE_DAY]);
 450                 }
 451         }
 452         else if (focus_obj == wd->date[DATE_MON])
 453         {
 454                 switch (wd->date_format)
 455                 {
 456                         case DATE_FORMAT_DDYYMM:
 457                         case DATE_FORMAT_YYDDMM:
 458                                 if (wd->layout == ELM_DATEFIELD_LAYOUT_DATEANDTIME)
 459                                         elm_object_focus(wd->time[TIME_HOUR]);
 460                                 else if (wd->layout == ELM_DATEFIELD_LAYOUT_DATE)
 461                                         elm_object_unfocus(wd->date[DATE_MON]);
 462                                 break;
 463                         case DATE_FORMAT_DDMMYY:
 464                         case DATE_FORMAT_MMYYDD:
 465                                 elm_object_focus(wd->date[DATE_YEAR]);
 466                                 break;
 467                         case DATE_FORMAT_MMDDYY:
 468                         case DATE_FORMAT_YYMMDD:
 469                                 elm_object_focus(wd->date[DATE_DAY]);
 470                 }
 471         }
 472         else if (focus_obj == wd->date[DATE_DAY])
 473         {
 474                 switch (wd->date_format)
 475                 {
 476                         case DATE_FORMAT_YYMMDD:
 477                         case DATE_FORMAT_MMYYDD:
 478                                 if (wd->layout == ELM_DATEFIELD_LAYOUT_DATEANDTIME)
 479                                         elm_object_focus(wd->time[TIME_HOUR]);
 480                                 else if (wd->layout == ELM_DATEFIELD_LAYOUT_DATE)
 481                                         elm_object_unfocus(wd->date[DATE_DAY]);
 482                                 break;
 483                         case DATE_FORMAT_DDYYMM:
 484                         case DATE_FORMAT_MMDDYY:
 485                                 elm_object_focus(wd->date[DATE_YEAR]);
 486                                 break;
 487                         case DATE_FORMAT_DDMMYY:
 488                         case DATE_FORMAT_YYDDMM:
 489                                 elm_object_focus(wd->date[DATE_MON]);
 490                 }
 491         }
 492         else if (focus_obj == wd->time[TIME_HOUR])
 493                 elm_object_focus(wd->time[TIME_MIN]);
 494         else if (focus_obj == wd->time[TIME_MIN])
 495                 elm_object_unfocus(wd->time[TIME_MIN]);
 496 }
 497
 498 static int
 499 _check_date_boundary(Evas_Object *obj, int num, int flag)
 500 {
 501         Widget_Data *wd = elm_widget_data_get(obj);
 502         if (flag == DATE_YEAR)
 503         {
 504                 if (num > wd->y_max) num = wd->y_max;
 505                 else if (num < wd->y_min) num = wd->y_min;
 506                 return num;
 507         }
 508
 509         else if (flag == DATE_MON)
 510         {
 511                 if (wd->year == wd->y_max && num > wd->m_max) num = wd->m_max;
 512                 else if (wd->year == wd->y_min && num < wd->m_min) num = wd->m_min;
 513                 else if (num > MONTH_MAXIMUM) num = MONTH_MAXIMUM;
 514                 else if (num <= 0) num = 1;
 515                 return num;
 516         }
 517
 518         else if (flag == DATE_DAY)
 519         {
 520                 int day_of_month = _maximum_day_get(wd->year, wd->month);
 521                 if (wd->year == wd->y_max && wd->month == wd->m_max && num > wd->d_max) num = wd->d_max;
 522                 else if (wd->year == wd->y_min && wd->month == wd->m_min && num < wd->d_min) num = wd->d_min;
 523                 else if (num > day_of_month) num = day_of_month;
 524                 else if (num <= 0) num = 1;
 525                 return num;
 526         }
 527         return num;
 528 }
 529
 530 static int
 531 _maximum_day_get(int year, int month)
 532 {
 533         int day_of_month = 0;
 534         if (year == 0 || month == 0) return 0;
 535
 536         switch (month) {
 537                 case 4:
 538                 case 6:
 539                 case 9:
 540                 case 11:
 541                         day_of_month = 30;
 542                         break;
 543                 case 2:
 544                         if ((!(year % 4) && (year % 100)) || !(year % 400))
 545                                 day_of_month = 29;
 546                         else
 547                                 day_of_month = 28;
 548                         break;
 549                 default:
 550                         day_of_month = 31;
 551                         break;
 552         }
 553
 554         return day_of_month;
 555 }
 556
 557 static Eina_Bool
 558 _check_input_done(Evas_Object *obj, Evas_Object *focus_obj, int strlen)
 559 {
 560         Widget_Data *wd = elm_widget_data_get(obj);
 561
 562         if (!wd) return EINA_FALSE;
 563
 564         if (focus_obj == wd->date[DATE_YEAR] && strlen == YEAR_MAX_LENGTH)
 565                 wd->editing = EINA_FALSE;
 566         else if (focus_obj == wd->date[DATE_MON] && strlen == MONTH_MAX_LENGTH)
 567                 wd->editing = EINA_FALSE;
 568         else if (focus_obj == wd->date[DATE_DAY])
 569         {
 570                 if (strlen == DAY_MAX_LENGTH || atoi(elm_entry_entry_get(focus_obj)) > 3)
 571                 wd->editing = EINA_FALSE;
 572         }
 573         else if (focus_obj == wd->time[TIME_HOUR])
 574         {
 575                 if (strlen == TIME_MAX_LENGTH || atoi(elm_entry_entry_get(focus_obj)) > 2)
 576                         wd->editing = EINA_FALSE;
 577         }
 578         else if (focus_obj == wd->time[TIME_MIN])
 579         {
 580                 if (strlen == TIME_MAX_LENGTH || atoi(elm_entry_entry_get(focus_obj)) > 5)
 581                 wd->editing = EINA_FALSE;
 582         }
 583         return !wd->editing;
 584 }
 585
 586 static void
 587 _entry_key_up_cb(void *data, Evas *e , Evas_Object *obj , void *event_info)
 588 {
 589         Evas_Event_Key_Up *ev = (Evas_Event_Key_Up *) event_info;
 590
 591         if (!strcmp(ev->keyname, "BackSpace"))
 592                 elm_entry_entry_set(obj, "");
 593 }
 594
 595 static Eina_Bool
 596 _imf_event_commit_cb(void *data, int type, void *event)
 597 {
 598         Widget_Data *wd = elm_widget_data_get(data);
 599         Ecore_IMF_Event_Commit *ev = (Ecore_IMF_Event_Commit *) event;
 600         Evas_Object *focus_obj;
 601         char str[YEAR_MAX_LENGTH+1] = {0,};
 602
 603         if (!wd) return ECORE_CALLBACK_PASS_ON;
 604         if (!elm_widget_focus_get(data)) return ECORE_CALLBACK_PASS_ON;
 605
 606         focus_obj = elm_widget_focused_object_get(data);
 607         if (!wd->editing)
 608         {
 609                 elm_entry_entry_set(focus_obj, "");
 610                 wd->editing = EINA_TRUE;
 611         }
 612
 613         if (focus_obj == wd->date[DATE_MON])
 614         {
 615                 wd->month = atoi(ev->str);
 616                 strcpy(str, month_label[wd->month-1]);
 617         }
 618         else
 619         {
 620                 strcpy(str, elm_entry_entry_get(focus_obj));
 621                 str[strlen(str)] = ev->str[0];
 622         }
 623         elm_entry_entry_set(focus_obj, str);
 624
 625         if (_check_input_done(data, focus_obj, strlen(str)))
 626                 _entry_focus_move(data, focus_obj);
 627
 628         return ECORE_CALLBACK_DONE;
 629 }
 630
 631 static void
 632 _input_panel_event_callback(void *data, Ecore_IMF_Context *ctx, int value)
 633 {
 634         Widget_Data *wd = elm_widget_data_get(data);
 635
 636         if (!wd) return;
 637
 638         if (wd->func)
 639                 wd->func(wd->func_data, data, value);
 640 }
 641
 642 static void
 643 _date_update(Evas_Object *obj)
 644 {
 645         Widget_Data *wd = elm_widget_data_get(obj);
 646         char str[YEAR_MAX_LENGTH+1];
 647
 648         if (!wd || !wd->base) return;
 649
 650         sprintf(str, "%d", wd->year);
 651         elm_entry_entry_set(wd->date[DATE_YEAR], str);
 652
 653         sprintf(str, "%s", month_label[wd->month-1]);
 654         elm_entry_entry_set(wd->date[DATE_MON], str);
 655
 656         sprintf(str, "%d", wd->day);
 657         elm_entry_entry_set(wd->date[DATE_DAY], str);
 658
 659         if (!wd->time_mode) //24 mode
 660                 sprintf(str, "%d", wd->hour);
 661         else
 662         {
 663                 if (wd->hour >= HOUR_12H_MAXIMUM)
 664                 {
 665                         wd->pm = EINA_TRUE;
 666                         edje_object_part_text_set(wd->base, "elm.text.ampm", "PM");
 667                 }
 668                 else
 669                 {
 670                         wd->pm = EINA_FALSE;
 671                         edje_object_part_text_set(wd->base, "elm.text.ampm", "AM");
 672                 }
 673
 674                 if (wd->hour > HOUR_12H_MAXIMUM)
 675                         sprintf(str, "%02d", wd->hour - HOUR_12H_MAXIMUM);
 676                 else if (wd->hour == 0)
 677                         sprintf(str, "%02d", HOUR_12H_MAXIMUM);
 678                 else
 679                         sprintf(str, "%02d", wd->hour);
 680         }
 681         elm_entry_entry_set(wd->time[TIME_HOUR], str);
 682
 683         sprintf(str, "%02d", wd->min);
 684         elm_entry_entry_set(wd->time[TIME_MIN], str);
 685 }
 686
 687 static void
 688 _date_entry_add(Evas_Object *obj)
 689 {
 690         Widget_Data *wd = elm_widget_data_get(obj);
 691         int i;
 692
 693         if (!wd) return;
 694
 695         for (i = 0; i < DATE_MAX; i++)
 696         {
 697                 wd->date[i] = elm_entry_add(obj);
 698                 elm_entry_single_line_set(wd->date[i], EINA_TRUE);
 699                 elm_entry_context_menu_disabled_set(wd->date[i], EINA_TRUE);
 700                 if (i == DATE_MON) elm_entry_input_panel_layout_set(wd->date[i], ELM_INPUT_PANEL_LAYOUT_MONTH);
 701                 else elm_entry_input_panel_layout_set(wd->date[i], ELM_INPUT_PANEL_LAYOUT_NUMBERONLY);
 702                 evas_object_size_hint_weight_set(wd->date[i], EVAS_HINT_EXPAND, EVAS_HINT_EXPAND);
 703                 evas_object_size_hint_align_set(wd->date[i], EVAS_HINT_FILL, EVAS_HINT_FILL);
 704                 evas_object_smart_callback_add(wd->date[i], "focused", _entry_focused_cb, obj);
 705                 evas_object_smart_callback_add(wd->date[i], "unfocused", _entry_unfocused_cb, obj);
 706                 evas_object_event_callback_add(wd->date[i], EVAS_CALLBACK_KEY_UP, _entry_key_up_cb, obj);
 707                 elm_widget_sub_object_add(obj, wd->date[i]);
 708         }
 709         elm_entry_maximum_bytes_set(wd->date[DATE_YEAR], YEAR_MAX_LENGTH);
 710         elm_entry_maximum_bytes_set(wd->date[DATE_MON], MONTH_MAX_LENGTH);
 711         elm_entry_maximum_bytes_set(wd->date[DATE_DAY], DAY_MAX_LENGTH);
 712 }
 713
 714 static void
 715 _time_entry_add(Evas_Object *obj)
 716 {
 717         Widget_Data *wd = elm_widget_data_get(obj);
 718         int i;
 719
 720         if (!wd) return;
 721
 722         for (i = 0; i < TIME_MAX; i++)
 723         {
 724                 wd->time[i] = elm_entry_add(obj);
 725                 elm_entry_single_line_set(wd->time[i], EINA_TRUE);
 726                 elm_entry_context_menu_disabled_set(wd->time[i], EINA_TRUE);
 727                 elm_entry_input_panel_layout_set(wd->time[i], ELM_INPUT_PANEL_LAYOUT_NUMBERONLY);
 728                 elm_entry_maximum_bytes_set(wd->time[i], TIME_MAX_LENGTH);
 729                 evas_object_size_hint_weight_set(wd->time[i], EVAS_HINT_EXPAND, EVAS_HINT_EXPAND);
 730                 evas_object_size_hint_align_set(wd->time[i], EVAS_HINT_FILL, EVAS_HINT_FILL);
 731                 evas_object_smart_callback_add(wd->time[i], "focused", _entry_focused_cb, obj);
 732                 evas_object_smart_callback_add(wd->time[i], "unfocused", _entry_unfocused_cb, obj);
 733                 evas_object_event_callback_add(wd->time[i], EVAS_CALLBACK_KEY_UP, _entry_key_up_cb, obj);
 734                 elm_widget_sub_object_add(obj, wd->time[i]);
 735         }
 736 }
 737
 738 /**
 739  * Add a new datefield object
 740  *
 741  * @param parent The parent object
 742  * @return The new object or NULL if it cannot be created
 743  *
 744  * @ingroup Datefield
 745  */
 746 EAPI Evas_Object *
 747 elm_datefield_add(Evas_Object *parent)
 748 {
 749         Evas_Object *obj;
 750         Evas *e;
 751         Widget_Data *wd;
 752
 753         e = evas_object_evas_get(parent);
 754         if (!e) return NULL;
 755         wd = ELM_NEW(Widget_Data);
 756         obj = elm_widget_add(e);
 757         ELM_SET_WIDTYPE(widtype, "datefield");
 758         elm_widget_type_set(obj, "datefield");
 759         elm_widget_sub_object_add(parent, obj);
 760         elm_widget_data_set(obj, wd);
 761         elm_widget_del_hook_set(obj, _del_hook);
 762         elm_widget_theme_hook_set(obj, _theme_hook);
 763         elm_widget_on_focus_hook_set( obj, _on_focus_hook, NULL );
 764         elm_widget_can_focus_set(obj, EINA_TRUE);
 765
 766         wd->base = edje_object_add(e);
 767         elm_widget_resize_object_set(obj, wd->base);
 768         edje_object_signal_callback_add(wd->base, "mouse,down,1", "elm.rect.date.left.pad", _signal_rect_mouse_down, obj);
 769         edje_object_signal_callback_add(wd->base, "mouse,down,1", "elm.rect.date.year.over", _signal_rect_mouse_down, obj);
 770         edje_object_signal_callback_add(wd->base, "mouse,down,1", "elm.rect.date.month.over", _signal_rect_mouse_down, obj);
 771         edje_object_signal_callback_add(wd->base, "mouse,down,1", "elm.rect.date.day.over", _signal_rect_mouse_down, obj);
 772         edje_object_signal_callback_add(wd->base, "mouse,down,1", "elm.rect.date.right.pad", _signal_rect_mouse_down, obj);
 773
 774         edje_object_signal_callback_add(wd->base, "mouse,down,1", "elm.rect.time.hour.over", _signal_rect_mouse_down, obj);
 775         edje_object_signal_callback_add(wd->base, "mouse,down,1", "elm.rect.time.min.over", _signal_rect_mouse_down, obj);
 776         edje_object_signal_callback_add(wd->base, "mouse,down,1", "elm.rect.time.ampm.over", _signal_ampm_mouse_down, obj);
 777         edje_object_signal_callback_add(wd->base, "mouse,clicked,1", "elm.rect.time.ampm.over", _signal_ampm_clicked, obj);
 778
 779         wd->handler =  ecore_event_handler_add(ECORE_IMF_EVENT_COMMIT, _imf_event_commit_cb, obj);
 780         _date_entry_add(obj);
 781         _time_entry_add(obj);
 782
 783         wd->y_min = 1900;
 784         wd->m_min = 1;
 785         wd->d_min = 1;
 786         wd->y_max = 2099;
 787         wd->m_max = 12;
 788         wd->d_max = 31;
 789         wd->year = wd->y_min;
 790         wd->month = 1;
 791         wd->day = 1;
 792
 793         wd->layout = ELM_DATEFIELD_LAYOUT_DATEANDTIME;
 794         wd->time_mode = EINA_TRUE;
 795         wd->date_format = DATE_FORMAT_MMDDYY;
 796
 797         _theme_hook(obj);
 798
 799         return obj;
 800 }
 801
 802 /**
 803  * set layout for the datefield
 804  *
 805  * @param obj The datefield object
 806  * @param layout set layout for date/time/dateandtime (default: ELM_DATEFIELD_LAYOUT_DATEANDTIME)
 807  *
 808  * @ingroup Datefield
 809  */
 810 EAPI void
 811 elm_datefield_layout_set(Evas_Object *obj, Elm_Datefield_Layout layout)
 812 {
 813         ELM_CHECK_WIDTYPE(obj, widtype);
 814         Widget_Data *wd = elm_widget_data_get(obj);
 815
 816         if (!wd) return;
 817         if (layout < ELM_DATEFIELD_LAYOUT_TIME ||layout > ELM_DATEFIELD_LAYOUT_DATEANDTIME) return;
 818
 819         if (wd->layout != layout)
 820         {
 821                 wd->layout = layout;
 822                 _theme_hook(obj);
 823         }
 824         return;
 825 }
 826
 827 /**
 828  * get layout of the datefield
 829  *
 830  * @param obj The datefield object
 831  * @return layout of the datefield
 832  *
 833  * @ingroup Datefield
 834  */
 835 EAPI Elm_Datefield_Layout
 836 elm_datefield_layout_get(const Evas_Object *obj)
 837 {
 838         ELM_CHECK_WIDTYPE(obj, widtype) 0;
 839         Widget_Data *wd = elm_widget_data_get(obj);
 840
 841         if (!wd) return 0;
 842
 843         return wd->layout;
 844 }
 845
 846 /**
 847  * Set selected date of the datefield
 848  *
 849  * @param obj The datefield object
 850  * @param year The year to set
 851  * @param month The month to set
 852  * @param day The day to set
 853  * @param hour The hours to set (24hour mode - 0~23)
 854  * @param min The minutes to set (0~59)
 855  *
 856  * @ingroup Datefield
 857  */
 858 EAPI void
 859 elm_datefield_date_set(Evas_Object *obj, int year, int month, int day, int hour, int min)
 860 {
 861         ELM_CHECK_WIDTYPE(obj, widtype);
 862         Widget_Data *wd = elm_widget_data_get(obj);
 863
 864         if (!wd) return;
 865
 866         wd->year = _check_date_boundary(obj, year, DATE_YEAR);
 867         wd->month = _check_date_boundary(obj, month, DATE_MON);
 868         wd->day = _check_date_boundary(obj, day, DATE_DAY);
 869
 870         if (hour > HOUR_24H_MAXIMUM) wd->hour = HOUR_24H_MAXIMUM;
 871         else if (hour < 0) wd->hour = 0;
 872         else wd->hour = hour;
 873
 874         if (min > MIN_MAXIMUM) wd->min = MIN_MAXIMUM;
 875         else if (min < 0) wd->min = 0;
 876         else wd->min = min;
 877
 878         _date_update(obj);
 879 }
 880
 881 /**
 882  * Get selected date of the datefield
 883  *
 884  * @param obj The datefield object
 885  * @param year The pointer to the variable get the selected year
 886  * @param month The pointer to the variable get the selected month
 887  * @param day The pointer to the variable get the selected day
 888  * @param hour The pointer to the variable get the selected hour (24hour mode)
 889  * @param hour The pointer to the variable get the selected min
 890  *
 891  * @ingroup Datefield
 892  */
 893 EAPI void
 894 elm_datefield_date_get(const Evas_Object *obj, int *year, int *month, int *day, int *hour, int *min)
 895 {
 896         ELM_CHECK_WIDTYPE(obj, widtype);
 897         Widget_Data *wd = elm_widget_data_get(obj);
 898
 899         if (!wd) return;
 900
 901         if (year)
 902                 *year = wd->year;
 903         if (month)
 904                 *month = wd->month;
 905         if (day)
 906                 *day = wd->day;
 907         if (hour)
 908                 *hour = wd->hour;
 909         if (min)
 910                 *min = wd->min;
 911 }
 912
 913 /**
 914  * Set upper boundary of the datefield
 915  *
 916  * @param obj The datefield object
 917  * @param year The year to set
 918  * @param month The month to set
 919  * @param day The day to set
 920  * @return TRUE/FALSE
 921  *
 922  * @ingroup Datefield
 923  */
 924 EAPI Eina_Bool
 925 elm_datefield_date_max_set(Evas_Object *obj, int year, int month, int day)
 926 {
 927         ELM_CHECK_WIDTYPE(obj, widtype) EINA_FALSE;
 928         Widget_Data *wd = elm_widget_data_get(obj);
 929         int day_of_month;
 930         Eina_Bool update = EINA_FALSE;
 931
 932         if (!wd) return EINA_FALSE;
 933         if (month < 1 || month > MONTH_MAXIMUM) return EINA_FALSE;
 934         day_of_month = _maximum_day_get(year, month);
 935         if (day < 1 || day > day_of_month) return EINA_FALSE;
 936
 937         wd->y_max = year;
 938         wd->m_max = month;
 939         wd->d_max = day;
 940
 941         if (wd->year > wd->y_max)
 942         {
 943                 wd->year = wd->y_max;
 944                 update = EINA_TRUE;
 945         }
 946         if (wd->year == wd->y_max && wd->month > wd->m_max)
 947         {
 948                 wd->month = wd->m_max;
 949                 update = EINA_TRUE;
 950         }
 951         if (wd->year == wd->y_max && wd->month == wd->m_max && wd->day > wd->d_max)
 952         {
 953                 wd->day = wd->d_max;
 954                 update = EINA_TRUE;
 955         }
 956
 957         if (update) _date_update(obj);
 958         return EINA_TRUE;
 959 }
 960
 961 /**
 962  * Get upper boundary of the datefield
 963  *
 964  * @param obj The datefield object
 965  * @param year The pointer to the variable get the maximum year
 966  * @param month The pointer to the variable get the maximum month
 967  * @param day The pointer to the variable get the maximum day
 968  *
 969  * @ingroup Datefield
 970  */
 971 EAPI void
 972 elm_datefield_date_max_get(const Evas_Object *obj, int *year, int *month, int *day)
 973 {
 974         ELM_CHECK_WIDTYPE(obj, widtype);
 975         Widget_Data *wd = elm_widget_data_get(obj);
 976
 977         if (!wd) return;
 978
 979         if (year)
 980                 *year = wd->y_max;
 981         if (month)
 982                 *month = wd->m_max;
 983         if (day)
 984                 *day = wd->d_max;
 985 }
 986
 987 /**
 988  * Set lower boundary of the datefield
 989  *
 990  * @param obj The datefield object
 991  * @param year The year to set
 992  * @param month The month to set
 993  * @param day The day to set
 994  * @return TRUE/FALSE
 995  *
 996  * @ingroup Datepicker
 997  */
 998 EAPI Eina_Bool
 999 elm_datefield_date_min_set(Evas_Object *obj, int year, int month, int day)
1000 {
1001         ELM_CHECK_WIDTYPE(obj, widtype) EINA_FALSE;
1002         Widget_Data *wd = elm_widget_data_get(obj);
1003         int day_of_month;
1004         Eina_Bool update = EINA_FALSE;
1005
1006         if (!wd) return EINA_FALSE;
1007         if (month < 1 || month > MONTH_MAXIMUM) return EINA_FALSE;
1008         day_of_month = _maximum_day_get(year, month);
1009         if (day < 1 || day > day_of_month) return EINA_FALSE;
1010
1011         wd->y_min = year;
1012         wd->m_min = month;
1013         wd->d_min = day;
1014
1015         if (wd->year < wd->y_min)
1016         {
1017                 wd->year = wd->y_min;
1018                 update = EINA_TRUE;
1019         }
1020         if (wd->year == wd->y_min && wd->month < wd->m_min)
1021         {
1022                 wd->month = wd->m_min;
1023                 update = EINA_TRUE;
1024         }
1025         if (wd->year == wd->y_min && wd->month == wd->m_min && wd->day < wd->d_min)
1026         {
1027                 wd->day = wd->d_min;
1028                 update = EINA_TRUE;
1029         }
1030
1031         if (update) _date_update(obj);
1032         return EINA_TRUE;
1033 }
1034
1035 /**
1036  * Get lower boundary of the datefield
1037  *
1038  * @param obj The datefield object
1039  * @param year The pointer to the variable get the maximum year
1040  * @param month The pointer to the variable get the maximum month
1041  * @param day The pointer to the variable get the maximum day
1042  *
1043  * @ingroup Datefield
1044  */
1045 EAPI void
1046 elm_datefield_date_min_get(const Evas_Object *obj, int *year, int *month, int *day)
1047 {
1048         ELM_CHECK_WIDTYPE(obj, widtype);
1049         Widget_Data *wd = elm_widget_data_get(obj);
1050
1051         if (!wd) return;
1052
1053         if (year)
1054                 *year = wd->y_min;
1055         if (month)
1056                 *month = wd->m_min;
1057         if (day)
1058                 *day = wd->d_min;
1059 }
1060
1061 /**
1062  * Set if the datefield show hours in military or am/pm mode
1063  *
1064  * @param obj The datefield object
1065  * @param mode option for the hours mode. If true, it is shown as 12h mode, if false, it is shown as 24h mode. Default value is true
1066  *
1067  * @ingroup Datefield
1068  */
1069 EAPI void
1070 elm_datefield_time_mode_set(Evas_Object *obj, Eina_Bool mode)
1071 {
1072         ELM_CHECK_WIDTYPE(obj, widtype);
1073         Widget_Data *wd = elm_widget_data_get(obj);
1074
1075         if (!wd) return;
1076
1077         if (wd->time_mode != mode)
1078         {
1079                 char str[YEAR_MAX_LENGTH+1];
1080
1081                 wd->time_mode = mode;
1082                 if (!wd->time_mode) edje_object_signal_emit(wd->base, "elm,state,mode,24h", "elm");
1083                 else edje_object_signal_emit(wd->base, "elm,state,mode,12h", "elm");
1084
1085                 if (!wd->time_mode) //24 mode
1086                         sprintf(str, "%d", wd->hour);
1087                 else
1088                 {
1089                         if (wd->hour >= HOUR_12H_MAXIMUM)
1090                         {
1091                                 wd->pm = EINA_TRUE;
1092                                 edje_object_part_text_set(wd->base, "elm.text.ampm", "PM");
1093                         }
1094                         else
1095                         {
1096                                 wd->pm = EINA_FALSE;
1097                                 edje_object_part_text_set(wd->base, "elm.text.ampm", "AM");
1098                         }
1099
1100                         if (wd->hour > HOUR_12H_MAXIMUM)
1101                                 sprintf(str, "%d", wd->hour - HOUR_12H_MAXIMUM);
1102                         else if (wd->hour == 0)
1103                                 sprintf(str, "%d", HOUR_12H_MAXIMUM);
1104                         else
1105                                 sprintf(str, "%d", wd->hour);
1106                 }
1107                 elm_entry_entry_set(wd->time[TIME_HOUR], str);
1108         }
1109 }
1110
1111 /**
1112  * get time mode of the datefield
1113  *
1114  * @param obj The datefield object
1115  * @return time mode (EINA_TRUE: 12hour mode / EINA_FALSE: 24hour mode)
1116  *
1117  * @ingroup Datefield
1118  */
1119 EAPI Eina_Bool
1120 elm_datefield_time_mode_get(const Evas_Object *obj)
1121 {
1122         ELM_CHECK_WIDTYPE(obj, widtype);
1123         Widget_Data *wd = elm_widget_data_get(obj);
1124
1125         if (!wd) return EINA_FALSE;
1126
1127         return wd->time_mode;
1128 }
1129
1130 /**
1131  * Set date format of datefield
1132  *
1133  * @param obj The datefield object
1134  * @param fmt The date format, ex) yymmdd. Default value is mmddyy.
1135  *
1136  * @ingroup Datefield
1137  */
1138 EAPI void
1139 elm_datefield_date_format_set(Evas_Object *obj, const char *fmt)
1140 {
1141         ELM_CHECK_WIDTYPE(obj, widtype);
1142         Widget_Data *wd = elm_widget_data_get(obj);
1143         char sig[32] = "elm,state,format,";
1144         int i = 0, j;
1145
1146         if (!wd || !fmt) return;
1147
1148         j = strlen(sig);
1149         while (j < 32) {
1150                 sig[j++] = tolower(fmt[i++]);
1151         }
1152
1153         edje_object_signal_emit(wd->base, sig, "elm");
1154
1155         if (strstr(sig, "yymmdd")) wd->date_format = DATE_FORMAT_YYMMDD;
1156         else if (strstr(sig, "yyddmm")) wd->date_format = DATE_FORMAT_YYDDMM;
1157         else if (strstr(sig, "mmyydd")) wd->date_format = DATE_FORMAT_MMYYDD;
1158         else if (strstr(sig, "mmddyy")) wd->date_format = DATE_FORMAT_MMDDYY;
1159         else if (strstr(sig, "ddyymm")) wd->date_format = DATE_FORMAT_DDYYMM;
1160         else if (strstr(sig, "ddmmyy")) wd->date_format = DATE_FORMAT_DDMMYY;
1161 }
1162
1163 /**
1164  * get date format of the datefield
1165  *
1166  * @param obj The datefield object
1167  * @return date format string. ex) yymmdd
1168  *
1169  * @ingroup Datefield
1170  */
1171 EAPI const char *
1172 elm_datefield_date_format_get(const Evas_Object *obj)
1173 {
1174         ELM_CHECK_WIDTYPE(obj, widtype);
1175         Widget_Data *wd = elm_widget_data_get(obj);
1176
1177         switch (wd->date_format)
1178         {
1179                 case DATE_FORMAT_YYMMDD: return "yymmdd";
1180                 case DATE_FORMAT_YYDDMM: return "yyddmm";
1181                 case DATE_FORMAT_MMYYDD: return "mmyydd";
1182                 case DATE_FORMAT_MMDDYY: return "mmddyy";
1183                 case DATE_FORMAT_DDYYMM: return "ddyymm";
1184                 case DATE_FORMAT_DDMMYY: return "ddmmyy";
1185         }
1186 }
1187
1188 /**
1189  * Add a callback function for input panel state
1190  *
1191  * @param obj The datefield object
1192  * @param func The function to be called when the event is triggered (value will be the Ecore_IMF_Input_Panel_State)
1193  * @param data The data pointer to be passed to @p func
1194  *
1195  * @ingroup Datefield
1196  */
1197 EAPI void
1198 elm_datefield_input_panel_state_callback_add(Evas_Object *obj, void (*pEventCallbackFunc) (void *data, Evas_Object *obj, int value), void *data)
1199 {
1200         ELM_CHECK_WIDTYPE(obj, widtype);
1201         Widget_Data *wd = elm_widget_data_get(obj);
1202         int i;
1203
1204         if (!wd) return;
1205
1206         if (wd->func && (wd->func != pEventCallbackFunc))
1207                 elm_datefield_input_panel_state_callback_del(obj, wd->func);
1208
1209         if (wd->func != pEventCallbackFunc)
1210         {
1211                 wd->func = pEventCallbackFunc;
1212                 wd->func_data = data;
1213
1214                 for (i = 0; i < DATE_MAX; i++)
1215                         ecore_imf_context_input_panel_event_callback_add(
1216                                 elm_entry_imf_context_get(wd->date[i]), ECORE_IMF_INPUT_PANEL_STATE_EVENT, _input_panel_event_callback, obj);
1217
1218                 for (i = 0; i < TIME_MAX; i++)
1219                         ecore_imf_context_input_panel_event_callback_add(
1220                                 elm_entry_imf_context_get(wd->time[i]), ECORE_IMF_INPUT_PANEL_STATE_EVENT, _input_panel_event_callback, obj);
1221         }
1222 }
1223
1224 /**
1225  * Delete a callback function for input panel state
1226  *
1227  * @param obj The datefield object
1228  * @param func The function to be called when the event is triggered
1229  *
1230  * @ingroup Datefield
1231  */
1232 EAPI void
1233 elm_datefield_input_panel_state_callback_del(Evas_Object *obj, void (*pEventCallbackFunc) (void *data, Evas_Object *obj, int value))
1234 {
1235         ELM_CHECK_WIDTYPE(obj, widtype);
1236         Widget_Data *wd = elm_widget_data_get(obj);
1237         int i;
1238
1239         if (!wd) return;
1240
1241         if (wd->func && wd->func == pEventCallbackFunc)
1242         {
1243                 for (i = 0; i < DATE_MAX; i++)
1244                         ecore_imf_context_input_panel_event_callback_del(
1245                                 elm_entry_imf_context_get(wd->date[i]), ECORE_IMF_INPUT_PANEL_STATE_EVENT, _input_panel_event_callback);
1246
1247                 for (i = 0; i < TIME_MAX; i++)
1248                         ecore_imf_context_input_panel_event_callback_del(
1249                                 elm_entry_imf_context_get(wd->time[i]), ECORE_IMF_INPUT_PANEL_STATE_EVENT, _input_panel_event_callback);
1250
1251                 wd->func = NULL;
1252                 wd->func_data = NULL;
1253         }
1254 }
1255