src/lib/elm_spinner.c

   1 #include <Elementary.h>
   2 #include "elm_priv.h"
   3 #include <ctype.h>
   4
   5 typedef struct _Widget_Data Widget_Data;
   6 typedef struct _Elm_Spinner_Special_Value Elm_Spinner_Special_Value;
   7
   8 struct _Widget_Data
   9 {
  10    Evas_Object *spinner, *ent;
  11    const char *label;
  12    double val, val_min, val_max, orig_val, step, base;
  13    double drag_start_pos, spin_speed, interval, first_interval;
  14    int round;
  15    Ecore_Timer *delay, *spin;
  16    Eina_List *special_values;
  17    Eina_Bool wrap : 1;
  18    Eina_Bool entry_visible : 1;
  19    Eina_Bool dragging : 1;
  20    Eina_Bool editable : 1;
  21 };
  22
  23 struct _Elm_Spinner_Special_Value
  24 {
  25    double value;
  26    const char *label;
  27 };
  28
  29 static const char *widtype = NULL;
  30 static void _del_hook(Evas_Object *obj);
  31 static void _disable_hook(Evas_Object *obj);
  32 static void _write_label(Evas_Object *obj);
  33 static void _sizing_eval(Evas_Object *obj);
  34 //static void _changed_size_hints(void *data, Evas *e, Evas_Object *obj, void *event_info);
  35 static Eina_Bool _value_set(Evas_Object *obj, double delta);
  36 static void _on_focus_hook(void *data, Evas_Object *obj);
  37 static Eina_Bool _event_hook(Evas_Object *obj, Evas_Object *src,
  38                              Evas_Callback_Type type, void *event_info);
  39
  40 static void _mirrored_set(Evas_Object *obj, Eina_Bool rtl);
  41
  42 static const char SIG_CHANGED[] = "changed";
  43 static const char SIG_DELAY_CHANGED[] = "delay,changed";
  44
  45 static const Evas_Smart_Cb_Description _signals[] = {
  46    {SIG_CHANGED, ""},
  47    {SIG_DELAY_CHANGED, ""},
  48    {NULL, NULL}
  49 };
  50
  51 static void
  52 _del_hook(Evas_Object *obj)
  53 {
  54    Elm_Spinner_Special_Value *sv;
  55    Widget_Data *wd = elm_widget_data_get(obj);
  56    if (!wd) return;
  57    if (wd->label) eina_stringshare_del(wd->label);
  58    if (wd->delay) ecore_timer_del(wd->delay);
  59    if (wd->spin) ecore_timer_del(wd->spin);
  60    if (wd->special_values)
  61      {
  62         EINA_LIST_FREE(wd->special_values, sv)
  63           {
  64              eina_stringshare_del(sv->label);
  65              free(sv);
  66           }
  67      }
  68    free(wd);
  69 }
  70
  71 static void
  72 _disable_hook(Evas_Object *obj)
  73 {
  74    Widget_Data *wd = elm_widget_data_get(obj);
  75    if (!wd) return;
  76    if (elm_widget_disabled_get(obj))
  77       edje_object_signal_emit(wd->spinner, "elm,state,disabled", "elm");
  78    else
  79       edje_object_signal_emit(wd->spinner, "elm,state,enabled", "elm");
  80 }
  81
  82 static void
  83 _signal_emit_hook(Evas_Object *obj, const char *emission, const char *source)
  84 {
  85    Widget_Data *wd = elm_widget_data_get(obj);
  86    if (!wd) return;
  87    edje_object_signal_emit(wd->spinner, emission, source);
  88 }
  89
  90 static void
  91 _signal_callback_add_hook(Evas_Object *obj, const char *emission, const char *source, Edje_Signal_Cb func_cb, void *data)
  92 {
  93    Widget_Data *wd = elm_widget_data_get(obj);
  94    if (!wd) return;
  95    edje_object_signal_callback_add(wd->spinner, emission,
  96                                    source, func_cb, data);
  97 }
  98
  99 static void
 100 _signal_callback_del_hook(Evas_Object *obj, const char *emission, const char *source, Edje_Signal_Cb func_cb, void *data)
 101 {
 102    Widget_Data *wd = elm_widget_data_get(obj);
 103    edje_object_signal_callback_del_full(wd->spinner, emission, source,
 104                                         func_cb, data);
 105 }
 106
 107 static void
 108 _mirrored_set(Evas_Object *obj, Eina_Bool rtl)
 109 {
 110    Widget_Data *wd = elm_widget_data_get(obj);
 111    if (!wd) return;
 112    edje_object_mirrored_set(wd->spinner, rtl);
 113 }
 114
 115 static void
 116 _theme_hook(Evas_Object *obj)
 117 {
 118    Widget_Data *wd = elm_widget_data_get(obj);
 119    if (!wd) return;
 120    _elm_widget_mirrored_reload(obj);
 121    _mirrored_set(obj, elm_widget_mirrored_get(obj));
 122    _elm_theme_object_set(obj, wd->spinner, "spinner", "base", elm_widget_style_get(obj));
 123    edje_object_part_swallow(wd->spinner, "elm.swallow.entry", wd->ent);
 124    _write_label(obj);
 125    if (elm_widget_focus_get(obj))
 126       edje_object_signal_emit(wd->spinner, "elm,action,focus", "elm");
 127    else
 128       edje_object_signal_emit(wd->spinner, "elm,action,unfocus", "elm");
 129    if (elm_widget_disabled_get(obj))
 130       edje_object_signal_emit(wd->spinner, "elm,state,disabled", "elm");
 131    edje_object_message_signal_process(wd->spinner);
 132    edje_object_scale_set(wd->spinner, elm_widget_scale_get(obj) * _elm_config->scale);
 133    _sizing_eval(obj);
 134 }
 135
 136 static void
 137 _on_focus_hook(void *data __UNUSED__, Evas_Object *obj)
 138 {
 139    Widget_Data *wd = elm_widget_data_get(obj);
 140    if (!wd) return;
 141    if (elm_widget_focus_get(obj))
 142      {
 143         edje_object_signal_emit(wd->spinner, "elm,action,focus", "elm");
 144         evas_object_focus_set(wd->spinner, EINA_TRUE);
 145      }
 146    else
 147      {
 148         edje_object_signal_emit(wd->spinner, "elm,action,unfocus", "elm");
 149         evas_object_focus_set(wd->spinner, EINA_FALSE);
 150      }
 151 }
 152
 153 static Eina_Bool
 154 _delay_change(void *data)
 155 {
 156    Widget_Data *wd = elm_widget_data_get(data);
 157    if (!wd) return ECORE_CALLBACK_CANCEL;
 158    wd->delay = NULL;
 159    evas_object_smart_callback_call(data, SIG_DELAY_CHANGED, NULL);
 160    return ECORE_CALLBACK_CANCEL;
 161 }
 162
 163 static void
 164 _entry_show(Widget_Data *wd)
 165 {
 166    char buf[32], fmt[32] = "%0.f";
 167
 168    /* try to construct just the format from given label
 169     * completely ignoring pre/post words
 170     */
 171    if (wd->label)
 172      {
 173         const char *start = strchr(wd->label, '%');
 174         while (start)
 175           {
 176              /* handle %% */
 177              if (start[1] != '%')
 178                break;
 179              else
 180                start = strchr(start + 2, '%');
 181           }
 182
 183         if (start)
 184           {
 185              const char *itr, *end = NULL;
 186              for (itr = start + 1; *itr != '\0'; itr++)
 187                {
 188                   /* allowing '%d' is quite dangerous, remove it? */
 189                   if ((*itr == 'd') || (*itr == 'f'))
 190                     {
 191                        end = itr + 1;
 192                        break;
 193                     }
 194                }
 195
 196              if ((end) && ((size_t)(end - start + 1) < sizeof(fmt)))
 197                {
 198                   memcpy(fmt, start, end - start);
 199                   fmt[end - start] = '\0';
 200                }
 201           }
 202      }
 203    snprintf(buf, sizeof(buf), fmt, wd->val);
 204    elm_object_text_set(wd->ent, buf);
 205 }
 206
 207 static void
 208 _write_label(Evas_Object *obj)
 209 {
 210    Eina_List *l;
 211    Elm_Spinner_Special_Value *sv;
 212    Widget_Data *wd = elm_widget_data_get(obj);
 213    char buf[1024];
 214
 215    if (!wd) return;
 216    EINA_LIST_FOREACH(wd->special_values, l, sv)
 217      {
 218         if (sv->value == wd->val)
 219           {
 220              snprintf(buf, sizeof(buf), "%s", sv->label);
 221              goto apply;
 222           }
 223      }
 224    if (wd->label)
 225      snprintf(buf, sizeof(buf), wd->label, wd->val);
 226    else
 227      snprintf(buf, sizeof(buf), "%.0f", wd->val);
 228
 229 apply:
 230    edje_object_part_text_escaped_set(wd->spinner, "elm.text", buf);
 231    if (wd->entry_visible) _entry_show(wd);
 232 }
 233
 234 static Eina_Bool
 235 _value_set(Evas_Object *obj, double new_val)
 236 {
 237    Widget_Data *wd = elm_widget_data_get(obj);
 238
 239    if (!wd) return EINA_FALSE;
 240
 241    if (wd->round > 0)
 242      new_val = wd->base +
 243      (double)((((int)(new_val - wd->base)) / wd->round) * wd->round);
 244
 245    if (wd->wrap)
 246      {
 247         while (new_val < wd->val_min)
 248           new_val = wd->val_max + new_val + 1 - wd->val_min;
 249         while (new_val > wd->val_max)
 250           new_val = wd->val_min + new_val - wd->val_max - 1;
 251      }
 252    else
 253      {
 254         if (new_val < wd->val_min)
 255           new_val = wd->val_min;
 256         else if (new_val > wd->val_max)
 257           new_val = wd->val_max;
 258      }
 259
 260    if (new_val == wd->val) return EINA_FALSE;
 261    wd->val = new_val;
 262
 263    evas_object_smart_callback_call(obj, SIG_CHANGED, NULL);
 264    if (wd->delay) ecore_timer_del(wd->delay);
 265    wd->delay = ecore_timer_add(0.2, _delay_change, obj);
 266
 267    return EINA_TRUE;
 268 }
 269
 270 static void
 271 _sizing_eval(Evas_Object *obj)
 272 {
 273    Widget_Data *wd = elm_widget_data_get(obj);
 274    Evas_Coord minw = -1, minh = -1;
 275    if (!wd) return;
 276    elm_coords_finger_size_adjust(1, &minw, 1, &minh);
 277    edje_object_size_min_restricted_calc(wd->spinner, &minw, &minh, minw, minh);
 278    elm_coords_finger_size_adjust(1, &minw, 1, &minh);
 279    evas_object_size_hint_min_set(obj, minw, minh);
 280    evas_object_size_hint_max_set(obj, -1, -1);
 281 }
 282
 283 /*
 284    static void
 285    _changed_size_hints(void *data, Evas *e, Evas_Object *obj, void *event_info)
 286    {
 287    _sizing_eval(data);
 288    }
 289  */
 290
 291 static void
 292 _val_set(Evas_Object *obj)
 293 {
 294    Widget_Data *wd = elm_widget_data_get(obj);
 295    double pos = 0.0;
 296    if (!wd) return;
 297    if (wd->val_max > wd->val_min)
 298      pos = ((wd->val - wd->val_min) / (wd->val_max - wd->val_min));
 299    if (pos < 0.0) pos = 0.0;
 300    else if (pos > 1.0) pos = 1.0;
 301    edje_object_part_drag_value_set(wd->spinner, "elm.dragable.slider",
 302                                    pos, pos);
 303 }
 304
 305 static void
 306 _drag(void *data, Evas_Object *_obj __UNUSED__, const char *emission __UNUSED__, const char *source __UNUSED__)
 307 {
 308    Evas_Object *obj = data;
 309    Widget_Data *wd = elm_widget_data_get(obj);
 310    double pos = 0.0, offset, delta;
 311    if (!wd) return;
 312    if (wd->entry_visible) return;
 313    edje_object_part_drag_value_get(wd->spinner, "elm.dragable.slider",
 314                                    &pos, NULL);
 315
 316    offset = wd->step * _elm_config->scale;
 317    delta = (pos - wd->drag_start_pos) * offset;
 318    /* If we are on rtl mode, change the delta to be negative on such changes */
 319    if (elm_widget_mirrored_get(obj)) delta *= -1;
 320    if (_value_set(data, wd->drag_start_pos + delta)) _write_label(data);
 321    wd->dragging = 1;
 322 }
 323
 324 static void
 325 _drag_start(void *data, Evas_Object *obj __UNUSED__, const char *emission __UNUSED__, const char *source __UNUSED__)
 326 {
 327    Widget_Data *wd = elm_widget_data_get(data);
 328    double pos;
 329    if (!wd) return;
 330    edje_object_part_drag_value_get(wd->spinner, "elm.dragable.slider",
 331                                    &pos, NULL);
 332    wd->drag_start_pos = pos;
 333 }
 334
 335 static void
 336 _drag_stop(void *data, Evas_Object *obj __UNUSED__, const char *emission __UNUSED__, const char *source __UNUSED__)
 337 {
 338    Widget_Data *wd = elm_widget_data_get(data);
 339    if (!wd) return;
 340    wd->drag_start_pos = 0;
 341    edje_object_part_drag_value_set(wd->spinner, "elm.dragable.slider", 0.0, 0.0);
 342 }
 343
 344 static void
 345 _hide_entry(Evas_Object *obj)
 346 {
 347    Widget_Data *wd = elm_widget_data_get(obj);
 348    if (!wd) return;
 349    edje_object_signal_emit(wd->spinner, "elm,state,inactive", "elm");
 350    wd->entry_visible = 0;
 351 }
 352
 353 static void
 354 _reset_value(Evas_Object *obj)
 355 {
 356    Widget_Data *wd = elm_widget_data_get(obj);
 357    if (!wd) return;
 358    _hide_entry(obj);
 359    elm_spinner_value_set(obj, wd->orig_val);
 360 }
 361
 362 static void
 363 _apply_entry_value(Evas_Object *obj)
 364 {
 365    Widget_Data *wd = elm_widget_data_get(obj);
 366    const char *str;
 367    char *end;
 368    double val;
 369
 370    if (!wd) return;
 371    _hide_entry(obj);
 372    str = elm_object_text_get(wd->ent);
 373    if (!str) return;
 374    val = strtod(str, &end);
 375    if ((*end != '\0') && (!isspace(*end))) return;
 376    elm_spinner_value_set(obj, val);
 377 }
 378
 379 static void
 380 _toggle_entry(void *data, Evas_Object *obj __UNUSED__, const char *emission __UNUSED__, const char *source __UNUSED__)
 381 {
 382    Widget_Data *wd = elm_widget_data_get(data);
 383    if (!wd) return;
 384    if (wd->dragging)
 385      {
 386         wd->dragging = 0;
 387         return;
 388      }
 389    if (elm_widget_disabled_get(data)) return;
 390    if (!wd->editable) return;
 391    if (wd->entry_visible) _apply_entry_value(data);
 392    else
 393      {
 394         wd->orig_val = wd->val;
 395         edje_object_signal_emit(wd->spinner, "elm,state,active", "elm");
 396         _entry_show(wd);
 397         elm_entry_select_all(wd->ent);
 398         elm_widget_focus_set(wd->ent, 1);
 399         wd->entry_visible = 1;
 400      }
 401 }
 402
 403 static Eina_Bool
 404 _spin_value(void *data)
 405 {
 406    Widget_Data *wd = elm_widget_data_get(data);
 407    if (!wd) return ECORE_CALLBACK_CANCEL;
 408    if (_value_set(data, wd->val + wd->spin_speed)) _write_label(data);
 409    wd->interval = wd->interval / 1.05;
 410    ecore_timer_interval_set(wd->spin, wd->interval);
 411    return ECORE_CALLBACK_RENEW;
 412 }
 413
 414 static void
 415 _val_inc_start(Evas_Object *obj)
 416 {
 417    Widget_Data *wd = elm_widget_data_get(obj);
 418    if (!wd) return;
 419    wd->interval = wd->first_interval;
 420    wd->spin_speed = wd->step;
 421    if (wd->spin) ecore_timer_del(wd->spin);
 422    wd->spin = ecore_timer_add(wd->interval, _spin_value, obj);
 423    _spin_value(obj);
 424 }
 425
 426 static void
 427 _val_inc_stop(Evas_Object *obj)
 428 {
 429    Widget_Data *wd = elm_widget_data_get(obj);
 430    if (!wd) return;
 431    wd->interval = wd->first_interval;
 432    wd->spin_speed = 0;
 433    if (wd->spin) ecore_timer_del(wd->spin);
 434    wd->spin = NULL;
 435 }
 436
 437 static void
 438 _val_dec_start(Evas_Object *obj)
 439 {
 440    Widget_Data *wd = elm_widget_data_get(obj);
 441    if (!wd) return;
 442    wd->interval = wd->first_interval;
 443    wd->spin_speed = -wd->step;
 444    if (wd->spin) ecore_timer_del(wd->spin);
 445    wd->spin = ecore_timer_add(wd->interval, _spin_value, obj);
 446    _spin_value(obj);
 447 }
 448
 449 static void
 450 _val_dec_stop(Evas_Object *obj)
 451 {
 452    Widget_Data *wd = elm_widget_data_get(obj);
 453    if (!wd) return;
 454    wd->interval = wd->first_interval;
 455    wd->spin_speed = 0;
 456    if (wd->spin) ecore_timer_del(wd->spin);
 457    wd->spin = NULL;
 458 }
 459
 460 static void
 461 _button_inc_start(void *data, Evas_Object *obj __UNUSED__, const char *emission __UNUSED__, const char *source __UNUSED__)
 462 {
 463    Widget_Data *wd = elm_widget_data_get(data);
 464    if (!wd) return;
 465    if (wd->entry_visible)
 466      {
 467         _reset_value(data);
 468         return;
 469      }
 470    _val_inc_start(data);
 471 }
 472
 473 static void
 474 _button_inc_stop(void *data, Evas_Object *obj __UNUSED__, const char *emission __UNUSED__, const char *source __UNUSED__)
 475 {
 476    Widget_Data *wd = elm_widget_data_get(data);
 477    if (!wd) return;
 478    _val_inc_stop(data);
 479 }
 480
 481 static void
 482 _button_dec_start(void *data, Evas_Object *obj __UNUSED__, const char *emission __UNUSED__, const char *source __UNUSED__)
 483 {
 484    Widget_Data *wd = elm_widget_data_get(data);
 485    if (!wd) return;
 486    if (wd->entry_visible)
 487      {
 488         _reset_value(data);
 489         return;
 490      }
 491    _val_dec_start(data);
 492 }
 493
 494 static void
 495 _button_dec_stop(void *data, Evas_Object *obj __UNUSED__, const char *emission __UNUSED__, const char *source __UNUSED__)
 496 {
 497    Widget_Data *wd = elm_widget_data_get(data);
 498    if (!wd) return;
 499    _val_dec_stop(data);
 500 }
 501
 502 static void
 503 _entry_activated(void *data, Evas_Object *obj __UNUSED__, void *event_info __UNUSED__)
 504 {
 505    Widget_Data *wd = elm_widget_data_get(data);
 506    if (!wd) return;
 507    _apply_entry_value(data);
 508    evas_object_smart_callback_call(data, SIG_CHANGED, NULL);
 509    if (wd->delay) ecore_timer_del(wd->delay);
 510    wd->delay = ecore_timer_add(0.2, _delay_change, data);
 511 }
 512
 513 static Eina_Bool
 514 _event_hook(Evas_Object *obj, Evas_Object *src __UNUSED__, Evas_Callback_Type type, void *event_info)
 515 {
 516    Widget_Data *wd = elm_widget_data_get(obj);
 517    if (!wd) return EINA_FALSE;
 518    if (elm_widget_disabled_get(obj)) return EINA_FALSE;
 519    if (type == EVAS_CALLBACK_KEY_DOWN)
 520      {
 521         Evas_Event_Key_Down *ev = event_info;
 522         if (ev->event_flags & EVAS_EVENT_FLAG_ON_HOLD) return EINA_FALSE;
 523         else if (!strcmp(ev->keyname, "Left") ||
 524                  ((!strcmp(ev->keyname, "KP_Left")) && (!ev->string)) ||
 525                  !strcmp(ev->keyname, "Down") ||
 526                  ((!strcmp(ev->keyname, "KP_Down")) && (!ev->string)))
 527           {
 528              _val_dec_start(obj);
 529              edje_object_signal_emit(wd->spinner, "elm,left,anim,activate", "elm");
 530              ev->event_flags |= EVAS_EVENT_FLAG_ON_HOLD;
 531              return EINA_TRUE;
 532           }
 533         else if (!strcmp(ev->keyname, "Right") ||
 534                  ((!strcmp(ev->keyname, "KP_Right")) && (!ev->string)) ||
 535                  !strcmp(ev->keyname, "Up") ||
 536                  ((!strcmp(ev->keyname, "KP_Up")) && (!ev->string)))
 537           {
 538              _val_inc_start(obj);
 539              edje_object_signal_emit(wd->spinner, "elm,right,anim,activate", "elm");
 540              ev->event_flags |= EVAS_EVENT_FLAG_ON_HOLD;
 541              return EINA_TRUE;
 542           }
 543      }
 544    else if (type == EVAS_CALLBACK_KEY_UP)
 545      {
 546         Evas_Event_Key_Down *ev = event_info;
 547         if (ev->event_flags & EVAS_EVENT_FLAG_ON_HOLD) return EINA_FALSE;
 548         if (!strcmp(ev->keyname, "Right") ||
 549             ((!strcmp(ev->keyname, "KP_Right")) && (!ev->string)) ||
 550             !strcmp(ev->keyname, "Up") ||
 551             ((!strcmp(ev->keyname, "KP_Up")) && (!ev->string)))
 552           _val_inc_stop(obj);
 553         else if (!strcmp(ev->keyname, "Left") ||
 554                  ((!strcmp(ev->keyname, "KP_Left")) && (!ev->string)) ||
 555                  !strcmp(ev->keyname, "Down") ||
 556                  ((!strcmp(ev->keyname, "KP_Down")) && (!ev->string)))
 557           _val_dec_stop(obj);
 558         else  return EINA_FALSE;
 559         ev->event_flags |= EVAS_EVENT_FLAG_ON_HOLD;
 560         return EINA_TRUE;
 561      }
 562    return EINA_FALSE;
 563 }
 564
 565 EAPI Evas_Object *
 566 elm_spinner_add(Evas_Object *parent)
 567 {
 568    Evas_Object *obj;
 569    Evas *e;
 570    Widget_Data *wd;
 571
 572    ELM_WIDGET_STANDARD_SETUP(wd, Widget_Data, parent, e, obj, NULL);
 573
 574    ELM_SET_WIDTYPE(widtype, "spinner");
 575    elm_widget_type_set(obj, "spinner");
 576    elm_widget_sub_object_add(parent, obj);
 577    elm_widget_on_focus_hook_set(obj, _on_focus_hook, NULL);
 578    elm_widget_data_set(obj, wd);
 579    elm_widget_del_hook_set(obj, _del_hook);
 580    elm_widget_on_focus_hook_set(obj, _on_focus_hook, NULL);
 581    elm_widget_theme_hook_set(obj, _theme_hook);
 582    elm_widget_disable_hook_set(obj, _disable_hook);
 583    elm_widget_signal_emit_hook_set(obj, _signal_emit_hook);
 584    elm_widget_signal_callback_add_hook_set(obj, _signal_callback_add_hook);
 585    elm_widget_signal_callback_del_hook_set(obj, _signal_callback_del_hook);
 586    elm_widget_can_focus_set(obj, EINA_TRUE);
 587    elm_widget_event_hook_set(obj, _event_hook);
 588
 589    wd->val = 0.0;
 590    wd->val_min = 0.0;
 591    wd->val_max = 100.0;
 592    wd->wrap = 0;
 593    wd->step = 1.0;
 594    wd->first_interval = 0.85;
 595    wd->entry_visible = 0;
 596    wd->editable = EINA_TRUE;
 597
 598    wd->spinner = edje_object_add(e);
 599    _elm_theme_object_set(obj, wd->spinner, "spinner", "base", "default");
 600    elm_widget_resize_object_set(obj, wd->spinner);
 601    edje_object_signal_callback_add(wd->spinner, "drag", "*", _drag, obj);
 602    edje_object_signal_callback_add(wd->spinner, "drag,start", "*",
 603                                    _drag_start, obj);
 604    edje_object_signal_callback_add(wd->spinner, "drag,stop", "*",
 605                                    _drag_stop, obj);
 606    edje_object_signal_callback_add(wd->spinner, "drag,step", "*",
 607                                    _drag_stop, obj);
 608    edje_object_signal_callback_add(wd->spinner, "drag,page", "*",
 609                                    _drag_stop, obj);
 610
 611    edje_object_signal_callback_add(wd->spinner, "elm,action,increment,start",
 612                                    "*", _button_inc_start, obj);
 613    edje_object_signal_callback_add(wd->spinner, "elm,action,increment,stop",
 614                                    "*", _button_inc_stop, obj);
 615    edje_object_signal_callback_add(wd->spinner, "elm,action,decrement,start",
 616                                    "*", _button_dec_start, obj);
 617    edje_object_signal_callback_add(wd->spinner, "elm,action,decrement,stop",
 618                                    "*", _button_dec_stop, obj);
 619    edje_object_part_drag_value_set(wd->spinner, "elm.dragable.slider",
 620                                    0.0, 0.0);
 621
 622    wd->ent = elm_entry_add(obj);
 623    elm_entry_single_line_set(wd->ent, 1);
 624    evas_object_smart_callback_add(wd->ent, "activated", _entry_activated, obj);
 625    edje_object_part_swallow(wd->spinner, "elm.swallow.entry", wd->ent);
 626    edje_object_signal_callback_add(wd->spinner, "elm,action,entry,toggle",
 627                                    "*", _toggle_entry, obj);
 628
 629    evas_object_smart_callbacks_descriptions_set(obj, _signals);
 630
 631    _mirrored_set(obj, elm_widget_mirrored_get(obj));
 632    _write_label(obj);
 633    _sizing_eval(obj);
 634    return obj;
 635 }
 636
 637 EAPI void
 638 elm_spinner_label_format_set(Evas_Object *obj, const char *fmt)
 639 {
 640    ELM_CHECK_WIDTYPE(obj, widtype);
 641    Widget_Data *wd = elm_widget_data_get(obj);
 642    if (!wd) return;
 643    eina_stringshare_replace(&wd->label, fmt);
 644    _write_label(obj);
 645    _sizing_eval(obj);
 646 }
 647
 648 EAPI const char *
 649 elm_spinner_label_format_get(const Evas_Object *obj)
 650 {
 651    ELM_CHECK_WIDTYPE(obj, widtype) NULL;
 652    Widget_Data *wd = elm_widget_data_get(obj);
 653    if (!wd) return NULL;
 654    return wd->label;
 655 }
 656
 657 EAPI void
 658 elm_spinner_min_max_set(Evas_Object *obj, double min, double max)
 659 {
 660    ELM_CHECK_WIDTYPE(obj, widtype);
 661    Widget_Data *wd = elm_widget_data_get(obj);
 662    if (!wd) return;
 663    if ((wd->val_min == min) && (wd->val_max == max)) return;
 664    wd->val_min = min;
 665    wd->val_max = max;
 666    if (wd->val < wd->val_min) wd->val = wd->val_min;
 667    if (wd->val > wd->val_max) wd->val = wd->val_max;
 668    _val_set(obj);
 669    _write_label(obj);
 670 }
 671
 672 EAPI void
 673 elm_spinner_min_max_get(const Evas_Object *obj, double *min, double *max)
 674 {
 675    if (min) *min = 0.0;
 676    if (max) *max = 0.0;
 677    ELM_CHECK_WIDTYPE(obj, widtype);
 678    Widget_Data *wd = elm_widget_data_get(obj);
 679    if (!wd) return;
 680    if (min) *min = wd->val_min;
 681    if (max) *max = wd->val_max;
 682 }
 683
 684 EAPI void
 685 elm_spinner_step_set(Evas_Object *obj, double step)
 686 {
 687    ELM_CHECK_WIDTYPE(obj, widtype);
 688    Widget_Data *wd = elm_widget_data_get(obj);
 689    if (!wd) return;
 690    wd->step = step;
 691 }
 692
 693 EAPI double
 694 elm_spinner_step_get(const Evas_Object *obj)
 695 {
 696    ELM_CHECK_WIDTYPE(obj, widtype) 0.0;
 697    Widget_Data *wd = elm_widget_data_get(obj);
 698    if (!wd) return 0.0;
 699    return wd->step;
 700 }
 701
 702 EAPI void
 703 elm_spinner_value_set(Evas_Object *obj, double val)
 704 {
 705    ELM_CHECK_WIDTYPE(obj, widtype);
 706    Widget_Data *wd = elm_widget_data_get(obj);
 707    if (!wd) return;
 708    if (wd->val == val) return;
 709    wd->val = val;
 710    if (wd->val < wd->val_min) wd->val = wd->val_min;
 711    if (wd->val > wd->val_max) wd->val = wd->val_max;
 712    _val_set(obj);
 713    _write_label(obj);
 714 }
 715
 716 EAPI double
 717 elm_spinner_value_get(const Evas_Object *obj)
 718 {
 719    ELM_CHECK_WIDTYPE(obj, widtype) 0.0;
 720    Widget_Data *wd = elm_widget_data_get(obj);
 721    if (!wd) return 0.0;
 722    return wd->val;
 723 }
 724
 725 EAPI void
 726 elm_spinner_wrap_set(Evas_Object *obj, Eina_Bool wrap)
 727 {
 728    ELM_CHECK_WIDTYPE(obj, widtype);
 729    Widget_Data *wd = elm_widget_data_get(obj);
 730    if (!wd) return;
 731    wd->wrap = wrap;
 732 }
 733
 734 EAPI Eina_Bool
 735 elm_spinner_wrap_get(const Evas_Object *obj)
 736 {
 737    ELM_CHECK_WIDTYPE(obj, widtype) EINA_FALSE;
 738    Widget_Data *wd = elm_widget_data_get(obj);
 739    if (!wd) return EINA_FALSE;
 740    return wd->wrap;
 741 }
 742
 743 EAPI void
 744 elm_spinner_special_value_add(Evas_Object *obj, double value, const char *label)
 745 {
 746    Elm_Spinner_Special_Value *sv;
 747    ELM_CHECK_WIDTYPE(obj, widtype);
 748    Widget_Data *wd = elm_widget_data_get(obj);
 749    if (!wd) return;
 750
 751    sv = calloc(1, sizeof(*sv));
 752    if (!sv) return;
 753    sv->value = value;
 754    sv->label = eina_stringshare_add(label);
 755
 756    wd->special_values = eina_list_append(wd->special_values, sv);
 757    _write_label(obj);
 758 }
 759
 760 EAPI void
 761 elm_spinner_editable_set(Evas_Object *obj, Eina_Bool editable)
 762 {
 763    ELM_CHECK_WIDTYPE(obj, widtype);
 764    Widget_Data *wd = elm_widget_data_get(obj);
 765    if (!wd) return;
 766    wd->editable = editable;
 767 }
 768
 769 EAPI Eina_Bool
 770 elm_spinner_editable_get(const Evas_Object *obj)
 771 {
 772    ELM_CHECK_WIDTYPE(obj, widtype) EINA_FALSE;
 773    Widget_Data *wd = elm_widget_data_get(obj);
 774    if (!wd) return EINA_FALSE;
 775    return wd->editable;
 776 }
 777
 778 EAPI void
 779 elm_spinner_interval_set(Evas_Object *obj, double interval)
 780 {
 781    ELM_CHECK_WIDTYPE(obj, widtype);
 782    Widget_Data *wd = elm_widget_data_get(obj);
 783    if (!wd) return;
 784    wd->first_interval = interval;
 785 }
 786
 787 EAPI double
 788 elm_spinner_interval_get(const Evas_Object *obj)
 789 {
 790    ELM_CHECK_WIDTYPE(obj, widtype) 0.0;
 791    Widget_Data *wd = elm_widget_data_get(obj);
 792    if (!wd) return 0.0;
 793    return wd->first_interval;
 794 }
 795
 796 EAPI void
 797 elm_spinner_base_set(Evas_Object *obj, double base)
 798 {
 799    ELM_CHECK_WIDTYPE(obj, widtype);
 800    Widget_Data *wd = elm_widget_data_get(obj);
 801    if (!wd) return;
 802    wd->base = base;
 803 }
 804
 805 EAPI double
 806 elm_spinner_base_get(const Evas_Object *obj)
 807 {
 808    ELM_CHECK_WIDTYPE(obj, widtype) 0.0;
 809    Widget_Data *wd = elm_widget_data_get(obj);
 810    if (!wd) return 0.0;
 811    return wd->base;
 812 }
 813
 814 EAPI void
 815 elm_spinner_round_set(Evas_Object *obj, int rnd)
 816 {
 817    ELM_CHECK_WIDTYPE(obj, widtype);
 818    Widget_Data *wd = elm_widget_data_get(obj);
 819    if (!wd) return;
 820    wd->round = rnd;
 821 }
 822
 823 EAPI int
 824 elm_spinner_round_get(const Evas_Object *obj)
 825 {
 826    ELM_CHECK_WIDTYPE(obj, widtype) 0;
 827    Widget_Data *wd = elm_widget_data_get(obj);
 828    if (!wd) return 0;
 829    return wd->round;
 830 }