src/lib/elm_clock.c

   1 #include <Elementary.h>
   2 #include "elm_priv.h"
   3
   4 /**
   5  * @defgroup Clock Clock
   6  * @ingroup Elementary
   7  *
   8  * It's a widget to show clock with animation. The update of time is
   9  * shown in an animation like the flip of a sheet.
  10  *
  11  */
  12
  13 typedef struct _Widget_Data Widget_Data;
  14
  15 struct _Widget_Data
  16 {
  17    Evas_Object *clk;
  18    double interval, first_interval;
  19    Eina_Bool seconds : 1;
  20    Eina_Bool am_pm : 1;
  21    Eina_Bool edit : 1;
  22    Elm_Clock_Digedit digedit;
  23    int hrs, min, sec, timediff;
  24    Evas_Object *digit[6];
  25    Evas_Object *ampm;
  26    Evas_Object *sel_obj;
  27    Ecore_Timer *ticker, *spin;
  28    struct
  29      {
  30         int hrs, min, sec;
  31         char ampm;
  32         Eina_Bool seconds : 1;
  33         Eina_Bool am_pm : 1;
  34         Eina_Bool edit : 1;
  35         Elm_Clock_Digedit digedit;
  36      } cur;
  37 };
  38
  39 static const char *widtype = NULL;
  40 static void _del_hook(Evas_Object *obj);
  41 static void _theme_hook(Evas_Object *obj);
  42 static void _on_focus_hook(void *data, Evas_Object *obj);
  43 static Eina_Bool _ticker(void *data);
  44 static Eina_Bool _signal_clock_val_up(void *data);
  45 static Eina_Bool _signal_clock_val_down(void *data);
  46 static void _time_update(Evas_Object *obj);
  47
  48 static void
  49 _del_hook(Evas_Object *obj)
  50 {
  51    Widget_Data *wd = elm_widget_data_get(obj);
  52    if (!wd) return;
  53    int i;
  54    for (i = 0; i < 6; i++)
  55      {
  56         if (wd->digit[i]) evas_object_del(wd->digit[i]);
  57      }
  58    if (wd->ampm) evas_object_del(wd->ampm);
  59    if (wd->ticker) ecore_timer_del(wd->ticker);
  60    if (wd->spin) ecore_timer_del(wd->spin);
  61    free(wd);
  62 }
  63
  64 static void
  65 _theme_hook(Evas_Object *obj)
  66 {
  67    Widget_Data *wd = elm_widget_data_get(obj);
  68    if (!wd) return;
  69    if (elm_widget_focus_get(obj))
  70      edje_object_signal_emit(wd->clk, "elm,action,focus", "elm");
  71    else
  72      edje_object_signal_emit(wd->clk, "elm,action,unfocus", "elm");
  73    wd->cur.am_pm = !wd->cur.am_pm; /* hack - force update */
  74    _time_update(obj);
  75 }
  76
  77 static void
  78 _on_focus_hook(void *data __UNUSED__, Evas_Object *obj)
  79 {
  80    Widget_Data *wd = elm_widget_data_get(obj);
  81    if (!wd) return;
  82    if (elm_widget_focus_get(obj))
  83      {
  84        edje_object_signal_emit(wd->clk, "elm,action,focus", "elm");
  85        evas_object_focus_set(wd->clk, EINA_TRUE);
  86      }
  87    else
  88      {
  89        edje_object_signal_emit(wd->clk, "elm,action,unfocus", "elm");
  90        evas_object_focus_set(wd->clk, EINA_FALSE);
  91      }
  92 }
  93
  94 static void
  95 _signal_emit_hook(Evas_Object *obj, const char *emission, const char *source)
  96 {
  97    Widget_Data *wd = elm_widget_data_get(obj);
  98    int i;
  99    if (!wd) return;
 100    edje_object_signal_emit(wd->clk, emission, source);
 101    for (i = 0; i < 6; i++)
 102      {
 103         if (wd->digit[i])
 104           edje_object_signal_emit(wd->digit[i], emission, source);
 105      }
 106 }
 107
 108 static void
 109 _signal_callback_add_hook(Evas_Object *obj, const char *emission, const char *source, void (*func_cb) (void *data, Evas_Object *o, const char *emission, const char *source), void *data)
 110 {
 111    Widget_Data *wd = elm_widget_data_get(obj);
 112    int i;
 113    if (!wd) return;
 114    edje_object_signal_callback_add(wd->clk, emission, source, func_cb, data);
 115    for (i = 0; i < 6; i++)
 116      {
 117         if (wd->digit[i])
 118           edje_object_signal_callback_add(wd->digit[i], emission, source,
 119                 func_cb, data);
 120      }
 121 }
 122
 123 static void
 124 _signal_callback_del_hook(Evas_Object *obj, const char *emission, const char *source, void (*func_cb) (void *data, Evas_Object *o, const char *emission, const char *source), void *data)
 125 {
 126    Widget_Data *wd = elm_widget_data_get(obj);
 127    int i;
 128    for (i = 0; i < 6; i++)
 129      {
 130         edje_object_signal_callback_del_full(wd->digit[i], emission, source,
 131                                              func_cb, data);
 132      }
 133    edje_object_signal_callback_del_full(wd->clk, emission, source, func_cb,
 134                                         data);
 135 }
 136
 137 static void
 138 _timediff_set(Widget_Data *wd)
 139 {
 140    struct timeval timev;
 141    struct tm *tm;
 142    time_t tt;
 143    gettimeofday(&timev, NULL);
 144    tt = (time_t)(timev.tv_sec);
 145    tzset();
 146    tm = localtime(&tt);
 147    wd->timediff = (((wd->hrs - tm->tm_hour) * 60 +
 148             wd->min - tm->tm_min) * 60) + wd->sec - tm->tm_sec;
 149 }
 150
 151 static Eina_Bool
 152 _ticker(void *data)
 153 {
 154    Widget_Data *wd = elm_widget_data_get(data);
 155    double t;
 156    struct timeval timev;
 157    struct tm *tm;
 158    time_t tt;
 159    if (!wd) return ECORE_CALLBACK_CANCEL;
 160    gettimeofday(&timev, NULL);
 161    t = ((double)(1000000 - timev.tv_usec)) / 1000000.0;
 162    wd->ticker = ecore_timer_add(t, _ticker, data);
 163    if (!wd->edit)
 164      {
 165         tt = (time_t)(timev.tv_sec) + wd->timediff;
 166         tzset();
 167         tm = localtime(&tt);
 168         if (tm)
 169           {
 170              wd->hrs = tm->tm_hour;
 171              wd->min = tm->tm_min;
 172              wd->sec = tm->tm_sec;
 173              _time_update(data);
 174           }
 175      }
 176    return ECORE_CALLBACK_CANCEL;
 177 }
 178
 179 static Eina_Bool
 180 _signal_clock_val_up(void *data)
 181 {
 182    Widget_Data *wd = elm_widget_data_get(data);
 183    if (!wd) goto clock_val_up_exit_on_error;
 184    if (!wd->edit) goto clock_val_up_cancel;
 185    if (!wd->sel_obj) goto clock_val_up_cancel;
 186    if (wd->sel_obj == wd->digit[0])
 187      {
 188         wd->hrs = wd->hrs + 10;
 189         if (wd->hrs >= 24) wd->hrs -= 24;
 190      }
 191    if (wd->sel_obj == wd->digit[1])
 192      {
 193         wd->hrs = wd->hrs + 1;
 194         if (wd->hrs >= 24) wd->hrs -= 24;
 195      }
 196    if (wd->sel_obj == wd->digit[2])
 197      {
 198         wd->min = wd->min + 10;
 199         if (wd->min >= 60) wd->min -= 60;
 200      }
 201    if (wd->sel_obj == wd->digit[3])
 202      {
 203         wd->min = wd->min + 1;
 204         if (wd->min >= 60) wd->min -= 60;
 205      }
 206    if (wd->sel_obj == wd->digit[4])
 207      {
 208         wd->sec = wd->sec + 10;
 209         if (wd->sec >= 60) wd->sec -= 60;
 210      }
 211    if (wd->sel_obj == wd->digit[5])
 212      {
 213         wd->sec = wd->sec + 1;
 214         if (wd->sec >= 60) wd->sec -= 60;
 215      }
 216    if (wd->sel_obj == wd->ampm)
 217      {
 218         wd->hrs = wd->hrs + 12;
 219         if (wd->hrs > 23) wd->hrs -= 24;
 220      }
 221    wd->interval = wd->interval / 1.05;
 222    ecore_timer_interval_set(wd->spin, wd->interval);
 223    _time_update(data);
 224    evas_object_smart_callback_call(data, "changed", NULL);
 225    return ECORE_CALLBACK_RENEW;
 226 clock_val_up_cancel:
 227    wd->spin = NULL;
 228 clock_val_up_exit_on_error:
 229    return ECORE_CALLBACK_CANCEL;
 230 }
 231
 232 static Eina_Bool
 233 _signal_clock_val_down(void *data)
 234 {
 235    Widget_Data *wd = elm_widget_data_get(data);
 236    if (!wd) goto clock_val_down_exit_on_error;
 237    if (!wd->edit) goto clock_val_down_cancel;
 238    if (!wd->sel_obj) goto clock_val_down_cancel;
 239    if (wd->sel_obj == wd->digit[0])
 240      {
 241         wd->hrs = wd->hrs - 10;
 242         if (wd->hrs < 0) wd->hrs += 24;
 243      }
 244    if (wd->sel_obj == wd->digit[1])
 245      {
 246         wd->hrs = wd->hrs - 1;
 247         if (wd->hrs < 0) wd->hrs += 24;
 248      }
 249    if (wd->sel_obj == wd->digit[2])
 250      {
 251         wd->min = wd->min - 10;
 252         if (wd->min < 0) wd->min += 60;
 253      }
 254    if (wd->sel_obj == wd->digit[3])
 255      {
 256         wd->min = wd->min - 1;
 257         if (wd->min < 0) wd->min += 60;
 258      }
 259    if (wd->sel_obj == wd->digit[4])
 260      {
 261         wd->sec = wd->sec - 10;
 262         if (wd->sec < 0) wd->sec += 60;
 263      }
 264    if (wd->sel_obj == wd->digit[5])
 265      {
 266         wd->sec = wd->sec - 1;
 267         if (wd->sec < 0) wd->sec += 60;
 268      }
 269    if (wd->sel_obj == wd->ampm)
 270      {
 271         wd->hrs = wd->hrs - 12;
 272         if (wd->hrs < 0) wd->hrs += 24;
 273      }
 274    wd->interval = wd->interval / 1.05;
 275    ecore_timer_interval_set(wd->spin, wd->interval);
 276    _time_update(data);
 277    evas_object_smart_callback_call(data, "changed", NULL);
 278    return ECORE_CALLBACK_RENEW;
 279 clock_val_down_cancel:
 280    wd->spin = NULL;
 281 clock_val_down_exit_on_error:
 282    return ECORE_CALLBACK_CANCEL;
 283 }
 284
 285 static void
 286 _signal_clock_val_up_start(void *data, Evas_Object *obj, const char *emission __UNUSED__, const char *source __UNUSED__)
 287 {
 288    Widget_Data *wd = elm_widget_data_get(data);
 289    if (!wd) return;
 290    wd->interval = wd->first_interval;
 291    wd->sel_obj = obj;
 292    if (wd->spin) ecore_timer_del(wd->spin);
 293    wd->spin = ecore_timer_add(wd->interval, _signal_clock_val_up, data);
 294    _signal_clock_val_up(data);
 295 }
 296
 297 static void
 298 _signal_clock_val_down_start(void *data, Evas_Object *obj, const char *emission __UNUSED__, const char *source __UNUSED__)
 299 {
 300    Widget_Data *wd = elm_widget_data_get(data);
 301    if (!wd) return;
 302    wd->interval = wd->first_interval;
 303    wd->sel_obj = obj;
 304    if (wd->spin) ecore_timer_del(wd->spin);
 305    wd->spin = ecore_timer_add(wd->interval, _signal_clock_val_down, data);
 306    _signal_clock_val_down(data);
 307 }
 308
 309 static void
 310 _signal_clock_val_change_stop(void *data, Evas_Object *obj __UNUSED__, const char *emission __UNUSED__, const char *source __UNUSED__)
 311 {
 312    Widget_Data *wd = elm_widget_data_get(data);
 313    if (!wd) return;
 314    if (wd->spin) ecore_timer_del(wd->spin);
 315    wd->spin = NULL;
 316    wd->sel_obj = NULL;
 317 }
 318
 319 static void
 320 _time_update(Evas_Object *obj)
 321 {
 322    Widget_Data *wd = elm_widget_data_get(obj);
 323    Edje_Message_Int msg;
 324    int ampm = 0;
 325    const char *style = elm_widget_style_get(obj);
 326    if (!wd) return;
 327    if ((wd->cur.seconds != wd->seconds) || (wd->cur.am_pm != wd->am_pm) ||
 328        (wd->cur.edit != wd->edit) || (wd->cur.digedit != wd->digedit))
 329      {
 330         int i;
 331         Evas_Coord mw, mh;
 332
 333         for (i = 0; i < 6; i++)
 334           {
 335              if (wd->digit[i])
 336                {
 337                   evas_object_del(wd->digit[i]);
 338                   wd->digit[i] = NULL;
 339                }
 340           }
 341         if (wd->ampm)
 342           {
 343              evas_object_del(wd->ampm);
 344              wd->ampm = NULL;
 345           }
 346
 347         if ((wd->seconds) && (wd->am_pm))
 348           _elm_theme_object_set(obj, wd->clk, "clock", "base-all", style);
 349         else if (wd->seconds)
 350           _elm_theme_object_set(obj, wd->clk, "clock", "base-seconds", style);
 351         else if (wd->am_pm)
 352           _elm_theme_object_set(obj, wd->clk, "clock", "base-am_pm", style);
 353         else
 354           _elm_theme_object_set(obj, wd->clk, "clock", "base", style);
 355         edje_object_scale_set(wd->clk, elm_widget_scale_get(obj) *
 356                               _elm_config->scale);
 357
 358         for (i = 0; i < 6; i++)
 359           {
 360              char buf[16];
 361
 362              if ((!wd->seconds) && (i >= 4)) break;
 363              wd->digit[i] = edje_object_add(evas_object_evas_get(wd->clk));
 364              _elm_theme_object_set(obj, wd->digit[i], "clock", "flipdigit", style);
 365              edje_object_scale_set(wd->digit[i], elm_widget_scale_get(obj) *
 366                                    _elm_config->scale);
 367              if ((wd->edit) && (wd->digedit & (1 << i)))
 368                edje_object_signal_emit(wd->digit[i], "elm,state,edit,on", "elm");
 369              edje_object_signal_callback_add(wd->digit[i], "elm,action,up,start",
 370                                              "", _signal_clock_val_up_start, obj);
 371              edje_object_signal_callback_add(wd->digit[i], "elm,action,up,stop",
 372                                              "", _signal_clock_val_change_stop, obj);
 373              edje_object_signal_callback_add(wd->digit[i], "elm,action,down,start",
 374                                              "", _signal_clock_val_down_start, obj);
 375              edje_object_signal_callback_add(wd->digit[i], "elm,action,down,stop",
 376                                              "", _signal_clock_val_change_stop, obj);
 377              mw = mh = -1;
 378              elm_coords_finger_size_adjust(1, &mw, 2, &mh);
 379              edje_object_size_min_restricted_calc(wd->digit[i], &mw, &mh, mw, mh);
 380              elm_coords_finger_size_adjust(1, &mw, 2, &mh);
 381              edje_extern_object_min_size_set(wd->digit[i], mw, mh);
 382              snprintf(buf, sizeof(buf), "d%i", i);
 383              edje_object_part_swallow(wd->clk , buf, wd->digit[i]);
 384              evas_object_show(wd->digit[i]);
 385           }
 386         if (wd->am_pm)
 387           {
 388              wd->ampm = edje_object_add(evas_object_evas_get(wd->clk));
 389              _elm_theme_object_set(obj, wd->ampm, "clock", "flipampm", style);
 390              edje_object_scale_set(wd->ampm, elm_widget_scale_get(obj) *
 391                                    _elm_config->scale);
 392              if (wd->edit)
 393                edje_object_signal_emit(wd->ampm, "elm,state,edit,on", "elm");
 394              edje_object_signal_callback_add(wd->ampm, "elm,action,up,start",
 395                                              "", _signal_clock_val_up_start, obj);
 396              edje_object_signal_callback_add(wd->ampm, "elm,action,up,stop",
 397                                              "", _signal_clock_val_change_stop, obj);
 398              edje_object_signal_callback_add(wd->ampm, "elm,action,down,start",
 399                                              "", _signal_clock_val_down_start, obj);
 400              edje_object_signal_callback_add(wd->ampm, "elm,action,down,stop",
 401                                              "", _signal_clock_val_change_stop, obj);
 402              mw = mh = -1;
 403              elm_coords_finger_size_adjust(1, &mw, 2, &mh);
 404              edje_object_size_min_restricted_calc(wd->ampm, &mw, &mh, mw, mh);
 405              elm_coords_finger_size_adjust(1, &mw, 2, &mh);
 406              edje_extern_object_min_size_set(wd->ampm, mw, mh);
 407              edje_object_part_swallow(wd->clk , "ampm", wd->ampm);
 408              evas_object_show(wd->ampm);
 409           }
 410
 411         edje_object_size_min_calc(wd->clk, &mw, &mh);
 412         evas_object_size_hint_min_set(obj, mw, mh);
 413
 414         wd->cur.hrs = 0;
 415         wd->cur.min = 0;
 416         wd->cur.sec = 0;
 417         wd->cur.ampm = -1;
 418         wd->cur.seconds = wd->seconds;
 419         wd->cur.am_pm = wd->am_pm;
 420         wd->cur.edit = wd->edit;
 421         wd->cur.digedit = wd->digedit;
 422      }
 423    if (wd->hrs != wd->cur.hrs)
 424      {
 425         int hrs;
 426         int d1, d2, dc1, dc2;
 427
 428         hrs = wd->hrs;
 429         if (wd->am_pm)
 430           {
 431              if (hrs >= 12)
 432                {
 433                   if (hrs > 12) hrs -= 12;
 434                   ampm = 1;
 435                }
 436              else if (!hrs) hrs = 12;
 437           }
 438         d1 = hrs / 10;
 439         d2 = hrs % 10;
 440         dc1 = wd->cur.hrs / 10;
 441         dc2 = wd->cur.hrs % 10;
 442         if (d1 != dc1)
 443           {
 444              msg.val = d1;
 445              edje_object_message_send(wd->digit[0], EDJE_MESSAGE_INT, 1, &msg);
 446           }
 447         if (d2 != dc2)
 448           {
 449              msg.val = d2;
 450              edje_object_message_send(wd->digit[1], EDJE_MESSAGE_INT, 1, &msg);
 451           }
 452         wd->cur.hrs = hrs;
 453      }
 454    if (wd->min != wd->cur.min)
 455      {
 456         int d1, d2, dc1, dc2;
 457
 458         d1 = wd->min / 10;
 459         d2 = wd->min % 10;
 460         dc1 = wd->cur.min / 10;
 461         dc2 = wd->cur.min % 10;
 462         if (d1 != dc1)
 463           {
 464              msg.val = d1;
 465              edje_object_message_send(wd->digit[2], EDJE_MESSAGE_INT, 1, &msg);
 466           }
 467         if (d2 != dc2)
 468           {
 469              msg.val = d2;
 470              edje_object_message_send(wd->digit[3], EDJE_MESSAGE_INT, 1, &msg);
 471           }
 472         wd->cur.min = wd->min;
 473      }
 474    if (wd->seconds)
 475      {
 476         if (wd->sec != wd->cur.sec)
 477           {
 478              int d1, d2, dc1, dc2;
 479
 480              d1 = wd->sec / 10;
 481              d2 = wd->sec % 10;
 482              dc1 = wd->cur.sec / 10;
 483              dc2 = wd->cur.sec % 10;
 484              if (d1 != dc1)
 485                {
 486                   msg.val = d1;
 487                   edje_object_message_send(wd->digit[4], EDJE_MESSAGE_INT, 1, &msg);
 488                }
 489              if (d2 != dc2)
 490                {
 491                   msg.val = d2;
 492                   edje_object_message_send(wd->digit[5], EDJE_MESSAGE_INT, 1, &msg);
 493                }
 494              wd->cur.sec = wd->sec;
 495           }
 496      }
 497    else
 498      wd->cur.sec = -1;
 499
 500    if (wd->am_pm)
 501      {
 502         if (wd->hrs >= 12) ampm = 1;
 503         if (ampm != wd->cur.ampm)
 504           {
 505              if (wd->cur.ampm != ampm)
 506                {
 507                   msg.val = ampm;
 508                   edje_object_message_send(wd->ampm, EDJE_MESSAGE_INT, 1, &msg);
 509                }
 510              wd->cur.ampm = ampm;
 511           }
 512      }
 513    else
 514      wd->cur.ampm = -1;
 515 }
 516
 517 /**
 518  * Add a new clock to the parent
 519  *
 520  * @param parent The parent object
 521  *
 522  * This function inserts a clock widget on a given canvas to show a
 523  * animated clock.
 524  *
 525  * @ingroup Clock
 526  */
 527 EAPI Evas_Object *
 528 elm_clock_add(Evas_Object *parent)
 529 {
 530    Evas_Object *obj;
 531    Evas *e;
 532    Widget_Data *wd;
 533
 534    EINA_SAFETY_ON_NULL_RETURN_VAL(parent, NULL);
 535
 536    wd = ELM_NEW(Widget_Data);
 537    e = evas_object_evas_get(parent);
 538    if (!e) return NULL;
 539    obj = elm_widget_add(e);
 540    ELM_SET_WIDTYPE(widtype, "clock");
 541    elm_widget_type_set(obj, "clock");
 542    elm_widget_sub_object_add(parent, obj);
 543    elm_widget_data_set(obj, wd);
 544    elm_widget_del_hook_set(obj, _del_hook);
 545    elm_widget_theme_hook_set(obj, _theme_hook);
 546    elm_widget_on_focus_hook_set(obj, _on_focus_hook, NULL);
 547    elm_widget_signal_emit_hook_set(obj, _signal_emit_hook);
 548    elm_widget_signal_callback_add_hook_set(obj, _signal_callback_add_hook);
 549    elm_widget_signal_callback_del_hook_set(obj, _signal_callback_del_hook);
 550    elm_widget_can_focus_set(obj, EINA_TRUE);
 551
 552    wd->clk = edje_object_add(e);
 553    elm_widget_resize_object_set(obj, wd->clk);
 554
 555    wd->cur.ampm = -1;
 556    wd->cur.seconds = EINA_TRUE;
 557    wd->cur.am_pm = EINA_TRUE;
 558    wd->cur.edit = EINA_TRUE;
 559    wd->cur.digedit = ELM_CLOCK_NONE;
 560    wd->first_interval = 0.85;
 561    wd->timediff = 0;
 562
 563    _time_update(obj);
 564    _ticker(obj);
 565
 566    return obj;
 567 }
 568
 569 /**
 570  * Set the clock time
 571  *
 572  * @param obj The clock object
 573  * @param hrs The hours to set
 574  * @param min The minutes to set
 575  * @param sec The secondes to set
 576  *
 577  * This function updates the time that is showed by the clock widget
 578  *
 579  * @ingroup Clock
 580  */
 581 EAPI void
 582 elm_clock_time_set(Evas_Object *obj, int hrs, int min, int sec)
 583 {
 584    ELM_CHECK_WIDTYPE(obj, widtype);
 585    Widget_Data *wd = elm_widget_data_get(obj);
 586    if (!wd) return;
 587    wd->hrs = hrs;
 588    wd->min = min;
 589    wd->sec = sec;
 590    _timediff_set(wd);
 591    _time_update(obj);
 592 }
 593
 594 /**
 595  * Get clock time
 596  *
 597  * @param obj The clock object
 598  * @param hrs Pointer to the variable to get the hour of this clock
 599  * object
 600  * @param min Pointer to the variable to get the minute of this clock
 601  * object
 602  * @param sec Pointer to the variable to get the second of this clock
 603  * object
 604  *
 605  * This function gets the time set of the clock widget and returns it
 606  * on the variables passed as the arguments to function
 607  *
 608  * @ingroup Clock
 609  */
 610 EAPI void
 611 elm_clock_time_get(const Evas_Object *obj, int *hrs, int *min, int *sec)
 612 {
 613    ELM_CHECK_WIDTYPE(obj, widtype);
 614    Widget_Data *wd = elm_widget_data_get(obj);
 615    if (!wd) return;
 616    if (hrs) *hrs = wd->hrs;
 617    if (min) *min = wd->min;
 618    if (sec) *sec = wd->sec;
 619 }
 620
 621 /**
 622  * Set if the clock settings can be edited
 623  *
 624  * @param obj The clock object
 625  * @param edit Bool option for edited (1 = yes, 0 = no)
 626  *
 627  * This function sets if the clock settings can be edited or not.
 628  * By default or if digit_edit option was previously set to ELM_CLOCK_NONE,
 629  * all digits are editable. To choose what digits to make editable
 630  * use elm_clock_digit_edit_set().
 631  *
 632  * @ingroup Clock
 633  */
 634 EAPI void
 635 elm_clock_edit_set(Evas_Object *obj, Eina_Bool edit)
 636 {
 637    ELM_CHECK_WIDTYPE(obj, widtype);
 638    Widget_Data *wd = elm_widget_data_get(obj);
 639    if (!wd) return;
 640    wd->edit = edit;
 641    if (!edit)
 642      _timediff_set(wd);
 643    if ((edit) && (wd->digedit == ELM_CLOCK_NONE))
 644      elm_clock_digit_edit_set(obj, ELM_CLOCK_ALL);
 645    else
 646      _time_update(obj);
 647 }
 648
 649 /**
 650  * Get if the clock settings can be edited
 651  *
 652  * @param obj The clock object
 653  * @return Bool option for edited (1 = yes, 0 = no)
 654  *
 655  * This function gets if the clock settings can be edited or not.
 656  *
 657  * @ingroup Clock
 658  */
 659 EAPI Eina_Bool
 660 elm_clock_edit_get(const Evas_Object *obj)
 661 {
 662    ELM_CHECK_WIDTYPE(obj, widtype) EINA_FALSE;
 663    Widget_Data *wd = elm_widget_data_get(obj);
 664    if (!wd) return EINA_FALSE;
 665    return wd->edit;
 666 }
 667
 668 /**
 669  * Set what digits of the clock are editable
 670  *
 671  * @param obj The clock object
 672  * @param digedit Bit mask indicating the digits to edit
 673  *
 674  * If the digedit param is ELM_CLOCK_NONE, editing will be disabled.
 675  *
 676  * @ingroup Clock
 677  */
 678 EAPI void
 679 elm_clock_digit_edit_set(Evas_Object *obj, Elm_Clock_Digedit digedit)
 680 {
 681    ELM_CHECK_WIDTYPE(obj, widtype);
 682    Widget_Data *wd = elm_widget_data_get(obj);
 683    if (!wd) return;
 684    wd->digedit = digedit;
 685    if (digedit == ELM_CLOCK_NONE)
 686      elm_clock_edit_set(obj, EINA_FALSE);
 687    else
 688      _time_update(obj);
 689 }
 690
 691 /**
 692  * Get what digits of the clock are editable
 693  *
 694  * @param obj The clock object
 695  * @return Bit mask indicating the digits.
 696  *
 697  * @ingroup Clock
 698  */
 699 EAPI Elm_Clock_Digedit
 700 elm_clock_digit_edit_get(const Evas_Object *obj)
 701 {
 702    ELM_CHECK_WIDTYPE(obj, widtype) 0;
 703    Widget_Data *wd = elm_widget_data_get(obj);
 704    if (!wd) return 0;
 705    return wd->digedit;
 706 }
 707
 708 /**
 709  * Set if the clock shows hours in military or am/pm mode
 710  *
 711  * @param obj The clock object
 712  * @param am_pm Bool option for the hours mode
 713  * (1 = am/pm, 0 = military)
 714  *
 715  * This function sets the clock to show hours in military or am/pm
 716  * mode. Some countries like Brazil the military mode (00-24h-format)
 717  * is used in opposition to the USA where the am/pm mode is more
 718  * common used.
 719  *
 720  * @ingroup Clock
 721  */
 722 EAPI void
 723 elm_clock_show_am_pm_set(Evas_Object *obj, Eina_Bool am_pm)
 724 {
 725    ELM_CHECK_WIDTYPE(obj, widtype);
 726    Widget_Data *wd = elm_widget_data_get(obj);
 727    if (!wd) return;
 728    wd->am_pm = am_pm;
 729    _time_update(obj);
 730 }
 731
 732 /**
 733  * Get if the clock shows hours in military or am/pm mode
 734  *
 735  * @param obj The clock object
 736  * @return Bool option for the hours mode
 737  * (1 = am/pm, 0 = military)
 738  *
 739  * This function gets if the clock show hours in military or am/pm
 740  * mode. Some countries like Brazil the military mode (00-24h-format)
 741  * is used in opposition to the USA where the am/pm mode is more
 742  * common used.
 743  *
 744  * @ingroup Clock
 745  */
 746 EAPI Eina_Bool
 747 elm_clock_show_am_pm_get(const Evas_Object *obj)
 748 {
 749    ELM_CHECK_WIDTYPE(obj, widtype) EINA_FALSE;
 750    Widget_Data *wd = elm_widget_data_get(obj);
 751    if (!wd) return EINA_FALSE;
 752    return wd->am_pm;
 753 }
 754
 755 /**
 756  * Set if the clock shows hour with the seconds
 757  *
 758  * @param obj The clock object
 759  * @param seconds Bool option for the show seconds
 760  * (1 = show seconds, 0 = not show seconds)
 761  *
 762  * This function sets the clock to show or not to show the elapsed
 763  * seconds.
 764  *
 765  * @ingroup Clock
 766  */
 767 EAPI void
 768 elm_clock_show_seconds_set(Evas_Object *obj, Eina_Bool seconds)
 769 {
 770    ELM_CHECK_WIDTYPE(obj, widtype);
 771    Widget_Data *wd = elm_widget_data_get(obj);
 772    if (!wd) return;
 773    wd->seconds = seconds;
 774    _time_update(obj);
 775 }
 776
 777 /**
 778  * Get if the clock shows hour with the seconds
 779  *
 780  * @param obj The clock object
 781  * @return Bool option for the show seconds
 782  * (1 = show seconds, 0 = not show seconds)
 783  *
 784  * This function gets if the clock show or not show the elapsed
 785  * seconds.
 786  *
 787  * @ingroup Clock
 788  */
 789 EAPI Eina_Bool
 790 elm_clock_show_seconds_get(const Evas_Object *obj)
 791 {
 792    ELM_CHECK_WIDTYPE(obj, widtype) EINA_FALSE;
 793    Widget_Data *wd = elm_widget_data_get(obj);
 794    if (!wd) return EINA_FALSE;
 795    return wd->seconds;
 796 }
 797
 798 /**
 799  * Set the interval for the clock
 800  *
 801  * @param obj The clock object
 802  * @param interval The interval value in seconds
 803  *
 804  * The interval value is decreased while the user increments or decrements
 805  * the clock value. The next interval value is the previous interval / 1.05,
 806  * so it speed up a bit. Default value is 0.85 seconds.
 807  *
 808  * @ingroup Clock
 809  */
 810 EAPI void
 811 elm_clock_interval_set(Evas_Object *obj, double interval)
 812 {
 813    ELM_CHECK_WIDTYPE(obj, widtype);
 814    Widget_Data *wd = elm_widget_data_get(obj);
 815    if (!wd) return;
 816    wd->first_interval = interval;
 817 }
 818
 819 /**
 820  * Get the interval of the clock
 821  *
 822  * @param obj The clock object
 823  * @return The value of the first interval in seconds
 824  *
 825  * The interval value is decreased while the user increments or decrements
 826  * the clock value. The next interval value is the previous interval / 1.05,
 827  * so it speed up a bit. Default value is 0.85 seconds.
 828  *
 829  * @ingroup Clock
 830  */
 831 EAPI double
 832 elm_clock_interval_get(const Evas_Object *obj)
 833 {
 834    ELM_CHECK_WIDTYPE(obj, widtype) 0.0;
 835    Widget_Data *wd = elm_widget_data_get(obj);
 836    if (!wd) return 0.0;
 837    return wd->first_interval;
 838 }