src/lib/elm_clock.c

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