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