2013-04-25 22:13:00 -07:00
|
|
|
#ifdef HAVE_CONFIG_H
|
|
|
|
# include "elementary_config.h"
|
|
|
|
#endif
|
|
|
|
|
2009-09-03 05:36:39 -07:00
|
|
|
#include <Elementary.h>
|
2012-08-01 14:03:58 -07:00
|
|
|
//#include <ctype.h>
|
2013-04-25 22:13:00 -07:00
|
|
|
|
2009-09-03 05:36:39 -07:00
|
|
|
#include "elm_priv.h"
|
2012-08-01 14:03:58 -07:00
|
|
|
#include "elm_widget_spinner.h"
|
2009-09-03 05:36:39 -07:00
|
|
|
|
2012-11-26 02:59:00 -08:00
|
|
|
#include "Eo.h"
|
|
|
|
|
2012-11-25 22:32:53 -08:00
|
|
|
EAPI Eo_Op ELM_OBJ_SPINNER_BASE_ID = EO_NOOP;
|
|
|
|
|
|
|
|
#define MY_CLASS ELM_OBJ_SPINNER_CLASS
|
|
|
|
|
|
|
|
#define MY_CLASS_NAME "elm_spinner"
|
2009-09-03 05:36:39 -07:00
|
|
|
|
2011-04-21 17:42:32 -07:00
|
|
|
static const char SIG_CHANGED[] = "changed";
|
|
|
|
static const char SIG_DELAY_CHANGED[] = "delay,changed";
|
2013-04-23 05:00:50 -07:00
|
|
|
static const char SIG_LANG_CHANGED[] = "language,changed";
|
|
|
|
|
2012-05-14 14:52:06 -07:00
|
|
|
static const Evas_Smart_Cb_Description _smart_callbacks[] = {
|
2011-04-21 17:42:32 -07:00
|
|
|
{SIG_CHANGED, ""},
|
|
|
|
{SIG_DELAY_CHANGED, ""},
|
2013-04-23 05:00:50 -07:00
|
|
|
{SIG_LANG_CHANGED, ""},
|
elm: added more "focused" and "unfocused" documentations.
genlist, hover, index, list, map, photocam, progressbar, radio, scroller, slider, slideshow, spinner, toolbar, win.
2013-06-09 22:12:51 -07:00
|
|
|
{"focused", ""}, /**< handled by elm_widget */
|
|
|
|
{"unfocused", ""}, /**< handled by elm_widget */
|
2011-04-21 17:42:32 -07:00
|
|
|
{NULL, NULL}
|
|
|
|
};
|
|
|
|
|
2013-04-23 05:00:50 -07:00
|
|
|
static void
|
|
|
|
_elm_spinner_smart_translate(Eo *obj, void *_pd EINA_UNUSED, va_list *list)
|
|
|
|
{
|
|
|
|
Eina_Bool *ret = va_arg(*list, Eina_Bool *);
|
|
|
|
evas_object_smart_callback_call(obj, SIG_LANG_CHANGED, NULL);
|
|
|
|
if (ret) *ret = EINA_TRUE;
|
|
|
|
}
|
|
|
|
|
2009-09-03 05:36:39 -07:00
|
|
|
static void
|
2012-05-14 14:52:06 -07:00
|
|
|
_entry_show(Elm_Spinner_Smart_Data *sd)
|
2010-01-27 12:16:43 -08:00
|
|
|
{
|
|
|
|
char buf[32], fmt[32] = "%0.f";
|
|
|
|
|
|
|
|
/* try to construct just the format from given label
|
|
|
|
* completely ignoring pre/post words
|
|
|
|
*/
|
2012-05-14 14:52:06 -07:00
|
|
|
if (sd->label)
|
2010-01-27 12:16:43 -08:00
|
|
|
{
|
2012-05-14 14:52:06 -07:00
|
|
|
const char *start = strchr(sd->label, '%');
|
2010-01-27 12:16:43 -08:00
|
|
|
while (start)
|
|
|
|
{
|
2011-04-01 04:24:15 -07:00
|
|
|
/* handle %% */
|
|
|
|
if (start[1] != '%')
|
|
|
|
break;
|
|
|
|
else
|
|
|
|
start = strchr(start + 2, '%');
|
2010-01-27 12:16:43 -08:00
|
|
|
}
|
|
|
|
|
|
|
|
if (start)
|
|
|
|
{
|
2011-04-01 04:24:15 -07:00
|
|
|
const char *itr, *end = NULL;
|
|
|
|
for (itr = start + 1; *itr != '\0'; itr++)
|
|
|
|
{
|
|
|
|
/* allowing '%d' is quite dangerous, remove it? */
|
|
|
|
if ((*itr == 'd') || (*itr == 'f'))
|
|
|
|
{
|
|
|
|
end = itr + 1;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if ((end) && ((size_t)(end - start + 1) < sizeof(fmt)))
|
|
|
|
{
|
|
|
|
memcpy(fmt, start, end - start);
|
|
|
|
fmt[end - start] = '\0';
|
|
|
|
}
|
2010-01-27 12:16:43 -08:00
|
|
|
}
|
|
|
|
}
|
2012-05-14 14:52:06 -07:00
|
|
|
snprintf(buf, sizeof(buf), fmt, sd->val);
|
|
|
|
elm_object_text_set(sd->ent, buf);
|
2010-01-27 12:16:43 -08:00
|
|
|
}
|
|
|
|
|
2009-09-03 05:36:39 -07:00
|
|
|
static void
|
2012-05-14 14:52:06 -07:00
|
|
|
_label_write(Evas_Object *obj)
|
2009-09-03 05:36:39 -07:00
|
|
|
{
|
2010-04-17 17:31:07 -07:00
|
|
|
Eina_List *l;
|
2009-09-03 05:36:39 -07:00
|
|
|
char buf[1024];
|
2012-05-14 14:52:06 -07:00
|
|
|
Elm_Spinner_Special_Value *sv;
|
|
|
|
|
|
|
|
ELM_SPINNER_DATA_GET(obj, sd);
|
2012-03-28 02:02:22 -07:00
|
|
|
|
2012-10-01 00:36:27 -07:00
|
|
|
EINA_LIST_FOREACH(sd->special_values, l, sv)
|
2010-10-07 00:44:50 -07:00
|
|
|
{
|
2012-05-14 14:52:06 -07:00
|
|
|
if (sv->value == sd->val)
|
2010-10-07 00:44:50 -07:00
|
|
|
{
|
|
|
|
snprintf(buf, sizeof(buf), "%s", sv->label);
|
|
|
|
goto apply;
|
|
|
|
}
|
|
|
|
}
|
2012-05-14 14:52:06 -07:00
|
|
|
if (sd->label)
|
|
|
|
snprintf(buf, sizeof(buf), sd->label, sd->val);
|
2009-09-03 05:36:39 -07:00
|
|
|
else
|
2012-05-14 14:52:06 -07:00
|
|
|
snprintf(buf, sizeof(buf), "%.0f", sd->val);
|
2010-04-17 17:31:07 -07:00
|
|
|
|
|
|
|
apply:
|
2012-05-14 14:52:06 -07:00
|
|
|
elm_layout_text_set(obj, "elm.text", buf);
|
|
|
|
if (sd->entry_visible) _entry_show(sd);
|
2009-09-03 05:36:39 -07:00
|
|
|
}
|
|
|
|
|
2011-04-01 04:24:15 -07:00
|
|
|
static Eina_Bool
|
2012-05-14 14:52:06 -07:00
|
|
|
_delay_change(void *data)
|
2009-09-03 05:36:39 -07:00
|
|
|
{
|
2012-05-14 14:52:06 -07:00
|
|
|
ELM_SPINNER_DATA_GET(data, sd);
|
2012-03-28 02:02:22 -07:00
|
|
|
|
2012-05-14 14:52:06 -07:00
|
|
|
sd->delay = NULL;
|
|
|
|
evas_object_smart_callback_call(data, SIG_DELAY_CHANGED, NULL);
|
2012-02-15 04:32:02 -08:00
|
|
|
|
2012-05-14 14:52:06 -07:00
|
|
|
return ECORE_CALLBACK_CANCEL;
|
|
|
|
}
|
2012-02-15 04:32:02 -08:00
|
|
|
|
2012-05-14 14:52:06 -07:00
|
|
|
static Eina_Bool
|
|
|
|
_value_set(Evas_Object *obj,
|
|
|
|
double new_val)
|
|
|
|
{
|
|
|
|
ELM_SPINNER_DATA_GET(obj, sd);
|
|
|
|
|
|
|
|
if (sd->round > 0)
|
|
|
|
new_val = sd->val_base +
|
|
|
|
(double)((((int)(new_val - sd->val_base)) / sd->round) * sd->round);
|
|
|
|
|
|
|
|
if (sd->wrap)
|
2009-09-03 05:36:39 -07:00
|
|
|
{
|
elementary: fix spinner wrap
It's weird, but looks like wrap mode of the spinner is broken at least
since the move of elm to trunk.
The current code:
if (sd->wrap)
{
while (new_val < sd->val_min)
new_val = sd->val_max + new_val + 1 - sd->val_min;
while (new_val > sd->val_max)
new_val = sd->val_min + new_val - sd->val_max - 1;
}
doesn't seems correct. Since even the documented example would fails:
* E.g.:
* @li min value = 10
* @li max value = 50
* @li step value = 20
* @li displayed value = 20
*
* When the user decrement value (using left or bottom arrow), it will
* displays @c 40, because max - (min - (displayed - step)) is
* @c 50 - (@c 10 - (@c 20 - @c 20)) = @c 40.
With the current code the value will be 41.
It also could lead to values above min, like happens on the first spinner test,
when you could go to -50.5 because new value will become:
250 + (-50.5) + 1 - (-50) in the first while() and later since these value
is bigger then 250, would go back to -50.5 ...
So, a reasonable algorithm would be
if (sd->wrap)
{
if (new_val < sd->val_min)
new_val = sd->val_max + new_val - sd->val_min;
else if (new_val > sd->val_max)
new_val = sd->val_min + new_val - sd->val_max;
}
But it doesn't works fine for cases like the months spinners test, when you
have min = 1, max = 12, step = 1 and each option should be displayed with
wrap. This algorithm would wraps from 1 to 11, so would skip December...
So, I think just going to the max value when min is reached is the better
choice.
if (sd->wrap)
{
if (new_val < sd->val_min)
new_val = sd->val_max;
else if (new_val > sd->val_max)
new_val = sd->val_min;
}
SVN revision: 77278
2012-10-01 13:44:19 -07:00
|
|
|
if (new_val < sd->val_min)
|
|
|
|
new_val = sd->val_max;
|
|
|
|
else if (new_val > sd->val_max)
|
|
|
|
new_val = sd->val_min;
|
2009-09-03 05:36:39 -07:00
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
2012-05-14 14:52:06 -07:00
|
|
|
if (new_val < sd->val_min)
|
|
|
|
new_val = sd->val_min;
|
|
|
|
else if (new_val > sd->val_max)
|
|
|
|
new_val = sd->val_max;
|
2009-09-03 05:36:39 -07:00
|
|
|
}
|
|
|
|
|
2012-05-14 14:52:06 -07:00
|
|
|
if (new_val == sd->val) return EINA_FALSE;
|
|
|
|
sd->val = new_val;
|
2009-09-03 05:36:39 -07:00
|
|
|
|
2011-04-21 17:42:32 -07:00
|
|
|
evas_object_smart_callback_call(obj, SIG_CHANGED, NULL);
|
2013-05-29 05:07:24 -07:00
|
|
|
if (sd->delay) ecore_timer_del(sd->delay);
|
2012-05-14 14:52:06 -07:00
|
|
|
sd->delay = ecore_timer_add(0.2, _delay_change, obj);
|
2009-09-03 05:36:39 -07:00
|
|
|
|
2010-06-05 06:12:45 -07:00
|
|
|
return EINA_TRUE;
|
2009-09-03 05:36:39 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
_val_set(Evas_Object *obj)
|
|
|
|
{
|
2009-10-20 14:02:37 -07:00
|
|
|
double pos = 0.0;
|
2012-05-14 14:52:06 -07:00
|
|
|
|
|
|
|
ELM_SPINNER_DATA_GET(obj, sd);
|
2013-04-24 04:41:37 -07:00
|
|
|
Elm_Widget_Smart_Data *wd = eo_data_scope_get(obj, ELM_OBJ_WIDGET_CLASS);
|
2012-05-14 14:52:06 -07:00
|
|
|
|
|
|
|
if (sd->val_max > sd->val_min)
|
|
|
|
pos = ((sd->val - sd->val_min) / (sd->val_max - sd->val_min));
|
2009-09-03 05:36:39 -07:00
|
|
|
if (pos < 0.0) pos = 0.0;
|
2012-05-14 14:52:06 -07:00
|
|
|
else if (pos > 1.0)
|
|
|
|
pos = 1.0;
|
|
|
|
edje_object_part_drag_value_set
|
2012-11-25 22:32:53 -08:00
|
|
|
(wd->resize_obj, "elm.dragable.slider", pos, pos);
|
2009-09-03 05:36:39 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
2012-05-14 14:52:06 -07:00
|
|
|
_drag_cb(void *data,
|
|
|
|
Evas_Object *_obj __UNUSED__,
|
|
|
|
const char *emission __UNUSED__,
|
|
|
|
const char *source __UNUSED__)
|
2009-09-03 05:36:39 -07:00
|
|
|
{
|
2013-03-02 07:40:07 -08:00
|
|
|
double pos = 0.0, delta;
|
2012-05-14 14:52:06 -07:00
|
|
|
Evas_Object *obj = data;
|
2013-03-02 06:37:51 -08:00
|
|
|
Eina_Bool ret = EINA_FALSE;
|
2012-05-14 14:52:06 -07:00
|
|
|
|
|
|
|
ELM_SPINNER_DATA_GET(obj, sd);
|
2013-04-24 04:41:37 -07:00
|
|
|
Elm_Widget_Smart_Data *wd = eo_data_scope_get(obj, ELM_OBJ_WIDGET_CLASS);
|
2012-05-14 14:52:06 -07:00
|
|
|
|
|
|
|
if (sd->entry_visible) return;
|
2013-03-02 06:37:51 -08:00
|
|
|
eo_do((Eo *)wd->resize_obj,
|
|
|
|
edje_obj_part_drag_value_get("elm.dragable.slider", &pos, NULL, &ret));
|
2012-02-15 04:32:02 -08:00
|
|
|
|
2013-03-02 07:40:07 -08:00
|
|
|
delta = pos * sd->step * _elm_config->scale;
|
2011-02-08 04:08:28 -08:00
|
|
|
/* If we are on rtl mode, change the delta to be negative on such changes */
|
2012-02-15 04:32:02 -08:00
|
|
|
if (elm_widget_mirrored_get(obj)) delta *= -1;
|
2013-03-02 06:50:35 -08:00
|
|
|
if (_value_set(data, sd->drag_start_val + delta)) _label_write(data);
|
2012-05-14 14:52:06 -07:00
|
|
|
sd->dragging = 1;
|
2009-09-03 05:36:39 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
2012-05-14 14:52:06 -07:00
|
|
|
_drag_start_cb(void *data,
|
|
|
|
Evas_Object *obj __UNUSED__,
|
|
|
|
const char *emission __UNUSED__,
|
|
|
|
const char *source __UNUSED__)
|
2009-09-03 05:36:39 -07:00
|
|
|
{
|
2012-05-14 14:52:06 -07:00
|
|
|
ELM_SPINNER_DATA_GET(data, sd);
|
|
|
|
|
2013-03-02 06:50:35 -08:00
|
|
|
sd->drag_start_val = sd->val;
|
2009-09-03 05:36:39 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
2012-05-14 14:52:06 -07:00
|
|
|
_drag_stop_cb(void *data,
|
|
|
|
Evas_Object *obj __UNUSED__,
|
|
|
|
const char *emission __UNUSED__,
|
|
|
|
const char *source __UNUSED__)
|
2009-09-03 05:36:39 -07:00
|
|
|
{
|
2012-05-14 14:52:06 -07:00
|
|
|
ELM_SPINNER_DATA_GET(data, sd);
|
2013-04-24 04:41:37 -07:00
|
|
|
Elm_Widget_Smart_Data *wd = eo_data_scope_get(data, ELM_OBJ_WIDGET_CLASS);
|
2012-05-14 14:52:06 -07:00
|
|
|
|
2013-03-02 06:50:35 -08:00
|
|
|
sd->drag_start_val = 0;
|
2012-05-14 14:52:06 -07:00
|
|
|
edje_object_part_drag_value_set
|
2012-11-25 22:32:53 -08:00
|
|
|
(wd->resize_obj, "elm.dragable.slider", 0.0, 0.0);
|
2009-09-03 05:36:39 -07:00
|
|
|
}
|
|
|
|
|
2009-09-04 11:16:59 -07:00
|
|
|
static void
|
2012-05-14 14:52:06 -07:00
|
|
|
_entry_hide(Evas_Object *obj)
|
2009-09-04 11:16:59 -07:00
|
|
|
{
|
2012-05-14 14:52:06 -07:00
|
|
|
ELM_SPINNER_DATA_GET(obj, sd);
|
|
|
|
|
|
|
|
elm_layout_signal_emit(obj, "elm,state,inactive", "elm");
|
|
|
|
sd->entry_visible = EINA_FALSE;
|
2009-09-04 11:16:59 -07:00
|
|
|
}
|
|
|
|
|
2009-09-11 10:41:29 -07:00
|
|
|
static void
|
|
|
|
_reset_value(Evas_Object *obj)
|
|
|
|
{
|
2012-05-14 14:52:06 -07:00
|
|
|
ELM_SPINNER_DATA_GET(obj, sd);
|
|
|
|
|
|
|
|
_entry_hide(obj);
|
|
|
|
elm_spinner_value_set(obj, sd->orig_val);
|
2009-09-11 10:41:29 -07:00
|
|
|
}
|
|
|
|
|
2009-09-04 11:16:59 -07:00
|
|
|
static void
|
2012-05-14 14:52:06 -07:00
|
|
|
_entry_value_apply(Evas_Object *obj)
|
2009-09-04 11:16:59 -07:00
|
|
|
{
|
2010-01-27 11:34:45 -08:00
|
|
|
const char *str;
|
2009-09-04 11:16:59 -07:00
|
|
|
double val;
|
2012-05-14 14:52:06 -07:00
|
|
|
char *end;
|
|
|
|
|
|
|
|
ELM_SPINNER_DATA_GET(obj, sd);
|
2011-04-01 04:24:15 -07:00
|
|
|
|
2012-08-07 11:49:39 -07:00
|
|
|
if (!sd->entry_visible) return;
|
|
|
|
|
2012-05-14 14:52:06 -07:00
|
|
|
_entry_hide(obj);
|
|
|
|
str = elm_object_text_get(sd->ent);
|
2010-01-27 11:34:45 -08:00
|
|
|
if (!str) return;
|
|
|
|
val = strtod(str, &end);
|
|
|
|
if ((*end != '\0') && (!isspace(*end))) return;
|
2009-09-04 11:16:59 -07:00
|
|
|
elm_spinner_value_set(obj, val);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
2012-05-14 14:52:06 -07:00
|
|
|
_entry_toggle_cb(void *data,
|
|
|
|
Evas_Object *obj __UNUSED__,
|
|
|
|
const char *emission __UNUSED__,
|
|
|
|
const char *source __UNUSED__)
|
2009-09-04 11:16:59 -07:00
|
|
|
{
|
2012-05-14 14:52:06 -07:00
|
|
|
ELM_SPINNER_DATA_GET(data, sd);
|
|
|
|
|
|
|
|
if (sd->dragging)
|
2009-09-04 11:16:59 -07:00
|
|
|
{
|
2012-05-14 14:52:06 -07:00
|
|
|
sd->dragging = 0;
|
2009-09-04 11:16:59 -07:00
|
|
|
return;
|
|
|
|
}
|
2009-10-20 14:02:37 -07:00
|
|
|
if (elm_widget_disabled_get(data)) return;
|
2012-05-14 14:52:06 -07:00
|
|
|
if (!sd->editable) return;
|
|
|
|
if (sd->entry_visible) _entry_value_apply(data);
|
2009-09-04 11:16:59 -07:00
|
|
|
else
|
|
|
|
{
|
2012-05-14 14:52:06 -07:00
|
|
|
sd->orig_val = sd->val;
|
|
|
|
elm_layout_signal_emit(data, "elm,state,active", "elm");
|
|
|
|
_entry_show(sd);
|
|
|
|
elm_entry_select_all(sd->ent);
|
|
|
|
elm_widget_focus_set(sd->ent, 1);
|
|
|
|
sd->entry_visible = EINA_TRUE;
|
2009-09-04 11:16:59 -07:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2010-06-25 02:58:14 -07:00
|
|
|
static Eina_Bool
|
2009-09-03 05:36:39 -07:00
|
|
|
_spin_value(void *data)
|
|
|
|
{
|
2012-05-14 14:52:06 -07:00
|
|
|
ELM_SPINNER_DATA_GET(data, sd);
|
2012-07-28 06:29:50 -07:00
|
|
|
double real_speed = sd->spin_speed;
|
2012-05-14 14:52:06 -07:00
|
|
|
|
2012-07-28 06:29:50 -07:00
|
|
|
/* Sanity check: our step size should be at least as large as our rounding value */
|
|
|
|
if ((sd->spin_speed != 0.0) && (abs(sd->spin_speed) < sd->round))
|
|
|
|
{
|
|
|
|
WRN("The spinning step is smaller than the rounding value, please check your code");
|
|
|
|
real_speed = sd->spin_speed > 0 ? sd->round : -sd->round;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (_value_set(data, sd->val + real_speed)) _label_write(data);
|
2012-05-14 14:52:06 -07:00
|
|
|
sd->interval = sd->interval / 1.05;
|
|
|
|
ecore_timer_interval_set(sd->spin, sd->interval);
|
|
|
|
|
2009-09-04 11:10:18 -07:00
|
|
|
return ECORE_CALLBACK_RENEW;
|
2009-09-03 05:36:39 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
2009-09-11 10:41:29 -07:00
|
|
|
_val_inc_start(Evas_Object *obj)
|
2009-09-03 05:36:39 -07:00
|
|
|
{
|
2012-05-14 14:52:06 -07:00
|
|
|
ELM_SPINNER_DATA_GET(obj, sd);
|
|
|
|
|
|
|
|
sd->interval = sd->first_interval;
|
|
|
|
sd->spin_speed = sd->step;
|
2013-05-29 05:07:24 -07:00
|
|
|
if (sd->spin) ecore_timer_del(sd->spin);
|
2012-05-14 14:52:06 -07:00
|
|
|
sd->spin = ecore_timer_add(sd->interval, _spin_value, obj);
|
2009-09-11 10:41:29 -07:00
|
|
|
_spin_value(obj);
|
2009-09-03 05:36:39 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
2009-09-11 10:41:29 -07:00
|
|
|
_val_inc_stop(Evas_Object *obj)
|
2009-09-03 05:36:39 -07:00
|
|
|
{
|
2012-05-14 14:52:06 -07:00
|
|
|
ELM_SPINNER_DATA_GET(obj, sd);
|
|
|
|
|
|
|
|
sd->interval = sd->first_interval;
|
|
|
|
sd->spin_speed = 0;
|
2013-05-29 05:07:24 -07:00
|
|
|
ELM_SAFE_FREE(sd->spin, ecore_timer_del);
|
2009-09-03 05:36:39 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
2009-09-11 10:41:29 -07:00
|
|
|
_val_dec_start(Evas_Object *obj)
|
2009-09-03 05:36:39 -07:00
|
|
|
{
|
2012-05-14 14:52:06 -07:00
|
|
|
ELM_SPINNER_DATA_GET(obj, sd);
|
|
|
|
|
|
|
|
sd->interval = sd->first_interval;
|
|
|
|
sd->spin_speed = -sd->step;
|
2013-05-29 05:07:24 -07:00
|
|
|
if (sd->spin) ecore_timer_del(sd->spin);
|
2012-05-14 14:52:06 -07:00
|
|
|
sd->spin = ecore_timer_add(sd->interval, _spin_value, obj);
|
2009-09-11 10:41:29 -07:00
|
|
|
_spin_value(obj);
|
2009-09-03 05:36:39 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
2009-09-11 10:41:29 -07:00
|
|
|
_val_dec_stop(Evas_Object *obj)
|
2009-09-03 05:36:39 -07:00
|
|
|
{
|
2012-05-14 14:52:06 -07:00
|
|
|
ELM_SPINNER_DATA_GET(obj, sd);
|
|
|
|
|
|
|
|
sd->interval = sd->first_interval;
|
|
|
|
sd->spin_speed = 0;
|
2013-05-29 05:07:24 -07:00
|
|
|
ELM_SAFE_FREE(sd->spin, ecore_timer_del);
|
2009-09-03 05:36:39 -07:00
|
|
|
}
|
|
|
|
|
2009-09-11 10:41:29 -07:00
|
|
|
static void
|
2012-05-14 14:52:06 -07:00
|
|
|
_button_inc_start_cb(void *data,
|
|
|
|
Evas_Object *obj __UNUSED__,
|
|
|
|
const char *emission __UNUSED__,
|
|
|
|
const char *source __UNUSED__)
|
2009-09-11 10:41:29 -07:00
|
|
|
{
|
2012-05-14 14:52:06 -07:00
|
|
|
ELM_SPINNER_DATA_GET(data, sd);
|
|
|
|
|
|
|
|
if (sd->entry_visible)
|
2009-09-11 10:41:29 -07:00
|
|
|
{
|
|
|
|
_reset_value(data);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
_val_inc_start(data);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
2012-05-14 14:52:06 -07:00
|
|
|
_button_inc_stop_cb(void *data,
|
|
|
|
Evas_Object *obj __UNUSED__,
|
|
|
|
const char *emission __UNUSED__,
|
|
|
|
const char *source __UNUSED__)
|
2009-09-11 10:41:29 -07:00
|
|
|
{
|
|
|
|
_val_inc_stop(data);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
2012-05-14 14:52:06 -07:00
|
|
|
_button_dec_start_cb(void *data,
|
|
|
|
Evas_Object *obj __UNUSED__,
|
|
|
|
const char *emission __UNUSED__,
|
|
|
|
const char *source __UNUSED__)
|
2009-09-11 10:41:29 -07:00
|
|
|
{
|
2012-05-14 14:52:06 -07:00
|
|
|
ELM_SPINNER_DATA_GET(data, sd);
|
|
|
|
|
|
|
|
if (sd->entry_visible)
|
2009-09-11 10:41:29 -07:00
|
|
|
{
|
|
|
|
_reset_value(data);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
_val_dec_start(data);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
2012-05-14 14:52:06 -07:00
|
|
|
_button_dec_stop_cb(void *data,
|
|
|
|
Evas_Object *obj __UNUSED__,
|
|
|
|
const char *emission __UNUSED__,
|
|
|
|
const char *source __UNUSED__)
|
2009-09-11 10:41:29 -07:00
|
|
|
{
|
|
|
|
_val_dec_stop(data);
|
|
|
|
}
|
|
|
|
|
2009-09-03 05:36:39 -07:00
|
|
|
static void
|
2012-05-14 14:52:06 -07:00
|
|
|
_entry_activated_cb(void *data,
|
|
|
|
Evas_Object *obj __UNUSED__,
|
|
|
|
void *event_info __UNUSED__)
|
2009-09-03 05:36:39 -07:00
|
|
|
{
|
2012-05-14 14:52:06 -07:00
|
|
|
ELM_SPINNER_DATA_GET(data, sd);
|
|
|
|
|
|
|
|
_entry_value_apply(data);
|
2011-04-21 17:42:32 -07:00
|
|
|
evas_object_smart_callback_call(data, SIG_CHANGED, NULL);
|
2013-05-29 05:07:24 -07:00
|
|
|
if (sd->delay) ecore_timer_del(sd->delay);
|
2012-05-14 14:52:06 -07:00
|
|
|
sd->delay = ecore_timer_add(0.2, _delay_change, data);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
2012-11-25 22:32:53 -08:00
|
|
|
_elm_spinner_smart_sizing_eval(Eo *obj, void *_pd EINA_UNUSED, va_list *list EINA_UNUSED)
|
2012-05-14 14:52:06 -07:00
|
|
|
{
|
|
|
|
Evas_Coord minw = -1, minh = -1;
|
|
|
|
|
2013-04-24 04:41:37 -07:00
|
|
|
Elm_Widget_Smart_Data *wd = eo_data_scope_get(obj, ELM_OBJ_WIDGET_CLASS);
|
2012-05-14 14:52:06 -07:00
|
|
|
|
|
|
|
elm_coords_finger_size_adjust(1, &minw, 1, &minh);
|
|
|
|
edje_object_size_min_restricted_calc
|
2012-11-25 22:32:53 -08:00
|
|
|
(wd->resize_obj, &minw, &minh, minw, minh);
|
2012-05-14 14:52:06 -07:00
|
|
|
elm_coords_finger_size_adjust(1, &minw, 1, &minh);
|
|
|
|
evas_object_size_hint_min_set(obj, minw, minh);
|
|
|
|
evas_object_size_hint_max_set(obj, -1, -1);
|
2009-09-03 05:36:39 -07:00
|
|
|
}
|
|
|
|
|
2012-11-25 22:32:53 -08:00
|
|
|
static void
|
|
|
|
_elm_spinner_smart_event(Eo *obj, void *_pd EINA_UNUSED, va_list *list)
|
2009-09-11 10:41:29 -07:00
|
|
|
{
|
2012-11-25 22:32:53 -08:00
|
|
|
|
|
|
|
Evas_Object *src = va_arg(*list, Evas_Object *);
|
|
|
|
(void) src;
|
|
|
|
Evas_Callback_Type type = va_arg(*list, Evas_Callback_Type);
|
|
|
|
void *event_info = va_arg(*list, void *);
|
|
|
|
Eina_Bool *ret = va_arg(*list, Eina_Bool *);
|
|
|
|
if (ret) *ret = EINA_FALSE;
|
2013-09-13 10:52:52 -07:00
|
|
|
Eina_Bool horz = !!strcmp(elm_widget_style_get(obj), "vertical");
|
2012-11-25 22:32:53 -08:00
|
|
|
|
|
|
|
if (elm_widget_disabled_get(obj)) return;
|
2010-09-27 14:13:41 -07:00
|
|
|
if (type == EVAS_CALLBACK_KEY_DOWN)
|
|
|
|
{
|
|
|
|
Evas_Event_Key_Down *ev = event_info;
|
2012-05-14 14:52:06 -07:00
|
|
|
|
2012-11-25 22:32:53 -08:00
|
|
|
if (ev->event_flags & EVAS_EVENT_FLAG_ON_HOLD) return;
|
2013-09-13 10:52:52 -07:00
|
|
|
else if (
|
|
|
|
( (!strcmp(ev->key, "Left") ||
|
|
|
|
((!strcmp(ev->key, "KP_Left")) && (!ev->string)))
|
|
|
|
&& horz )
|
|
|
|
||
|
|
|
|
( (!strcmp(ev->key, "Down") ||
|
|
|
|
((!strcmp(ev->key, "KP_Down")) && (!ev->string)))
|
|
|
|
&& !horz )
|
|
|
|
)
|
2010-09-27 14:13:41 -07:00
|
|
|
{
|
|
|
|
_val_dec_start(obj);
|
2012-05-14 14:52:06 -07:00
|
|
|
elm_layout_signal_emit(obj, "elm,left,anim,activate", "elm");
|
2010-09-27 14:13:41 -07:00
|
|
|
ev->event_flags |= EVAS_EVENT_FLAG_ON_HOLD;
|
2012-11-25 22:32:53 -08:00
|
|
|
if (ret) *ret = EINA_TRUE;
|
|
|
|
return;
|
2010-09-27 14:13:41 -07:00
|
|
|
}
|
2013-09-13 10:52:52 -07:00
|
|
|
else if (
|
|
|
|
( (!strcmp(ev->key, "Right") ||
|
|
|
|
((!strcmp(ev->key, "KP_Right")) && (!ev->string)))
|
|
|
|
&& horz )
|
|
|
|
||
|
|
|
|
( (!strcmp(ev->key, "Up") ||
|
|
|
|
((!strcmp(ev->key, "KP_Up")) && (!ev->string)))
|
|
|
|
&& !horz )
|
|
|
|
)
|
2010-09-27 14:13:41 -07:00
|
|
|
{
|
|
|
|
_val_inc_start(obj);
|
2012-05-14 14:52:06 -07:00
|
|
|
elm_layout_signal_emit(obj, "elm,right,anim,activate", "elm");
|
2010-09-27 14:13:41 -07:00
|
|
|
ev->event_flags |= EVAS_EVENT_FLAG_ON_HOLD;
|
2012-11-25 22:32:53 -08:00
|
|
|
if (ret) *ret = EINA_TRUE;
|
|
|
|
return;
|
2010-09-27 14:13:41 -07:00
|
|
|
}
|
|
|
|
}
|
|
|
|
else if (type == EVAS_CALLBACK_KEY_UP)
|
|
|
|
{
|
|
|
|
Evas_Event_Key_Down *ev = event_info;
|
2012-05-14 14:52:06 -07:00
|
|
|
|
2012-11-25 22:32:53 -08:00
|
|
|
if (ev->event_flags & EVAS_EVENT_FLAG_ON_HOLD) return;
|
2013-07-30 23:14:09 -07:00
|
|
|
if (!strcmp(ev->key, "Right") ||
|
|
|
|
((!strcmp(ev->key, "KP_Right")) && (!ev->string)) ||
|
|
|
|
!strcmp(ev->key, "Up") ||
|
|
|
|
((!strcmp(ev->key, "KP_Up")) && (!ev->string)))
|
2010-09-27 14:13:41 -07:00
|
|
|
_val_inc_stop(obj);
|
2013-07-30 23:14:09 -07:00
|
|
|
else if (!strcmp(ev->key, "Left") ||
|
|
|
|
((!strcmp(ev->key, "KP_Left")) && (!ev->string)) ||
|
|
|
|
!strcmp(ev->key, "Down") ||
|
|
|
|
((!strcmp(ev->key, "KP_Down")) && (!ev->string)))
|
2010-09-27 14:13:41 -07:00
|
|
|
_val_dec_stop(obj);
|
2012-11-25 22:32:53 -08:00
|
|
|
else return;
|
2012-05-14 14:52:06 -07:00
|
|
|
|
2010-09-27 14:13:41 -07:00
|
|
|
ev->event_flags |= EVAS_EVENT_FLAG_ON_HOLD;
|
2012-05-14 14:52:06 -07:00
|
|
|
|
2012-11-25 22:32:53 -08:00
|
|
|
if (ret) *ret = EINA_TRUE;
|
|
|
|
return;
|
2010-09-27 14:13:41 -07:00
|
|
|
}
|
2009-09-11 10:41:29 -07:00
|
|
|
}
|
|
|
|
|
2012-11-25 22:32:53 -08:00
|
|
|
static void
|
|
|
|
_elm_spinner_smart_on_focus(Eo *obj, void *_pd EINA_UNUSED, va_list *list)
|
2012-08-03 00:27:02 -07:00
|
|
|
{
|
2012-11-25 22:32:53 -08:00
|
|
|
Eina_Bool *ret = va_arg(*list, Eina_Bool *);
|
|
|
|
if (ret) *ret = EINA_FALSE;
|
|
|
|
Eina_Bool int_ret;
|
2013-08-06 02:13:10 -07:00
|
|
|
Elm_Spinner_Smart_Data *sd = _pd;
|
2012-11-25 22:32:53 -08:00
|
|
|
|
2013-03-18 09:07:38 -07:00
|
|
|
eo_do_super(obj, MY_CLASS, elm_wdg_on_focus(&int_ret));
|
2012-11-25 22:32:53 -08:00
|
|
|
if (!int_ret) return;
|
2012-08-03 00:27:02 -07:00
|
|
|
|
2012-08-03 09:43:26 -07:00
|
|
|
if (!elm_widget_focus_get(obj))
|
2013-08-06 02:13:10 -07:00
|
|
|
{
|
|
|
|
if (sd->delay)
|
|
|
|
{
|
|
|
|
ecore_timer_del(sd->delay);
|
|
|
|
sd->delay = NULL;
|
|
|
|
}
|
|
|
|
if (sd->spin)
|
|
|
|
{
|
|
|
|
ecore_timer_del(sd->spin);
|
|
|
|
sd->spin = NULL;
|
|
|
|
}
|
|
|
|
_entry_value_apply(obj);
|
|
|
|
}
|
2012-08-03 09:43:26 -07:00
|
|
|
|
2012-11-25 22:32:53 -08:00
|
|
|
if (ret) *ret = EINA_TRUE;
|
2012-08-03 00:27:02 -07:00
|
|
|
}
|
|
|
|
|
2012-08-21 03:08:56 -07:00
|
|
|
static char *
|
2012-12-23 06:50:56 -08:00
|
|
|
_access_info_cb(void *data, Evas_Object *obj)
|
2012-08-21 03:08:56 -07:00
|
|
|
{
|
|
|
|
Evas_Object *spinner;
|
|
|
|
const char *txt = elm_widget_access_info_get(obj);
|
|
|
|
|
2012-11-25 22:32:53 -08:00
|
|
|
spinner = data;
|
2012-08-21 03:08:56 -07:00
|
|
|
if (!txt) txt = elm_layout_text_get(spinner, "elm.text");
|
|
|
|
if (txt) return strdup(txt);
|
|
|
|
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
static char *
|
2012-12-23 06:50:56 -08:00
|
|
|
_access_state_cb(void *data, Evas_Object *obj __UNUSED__)
|
2012-08-21 03:08:56 -07:00
|
|
|
{
|
2012-11-25 22:32:53 -08:00
|
|
|
if (elm_widget_disabled_get(data))
|
2012-08-21 03:08:56 -07:00
|
|
|
return strdup(E_("State: Disabled"));
|
|
|
|
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
2012-11-26 02:59:00 -08:00
|
|
|
_access_activate_cb(void *data,
|
|
|
|
Evas_Object *part_obj,
|
2013-01-03 01:31:33 -08:00
|
|
|
Elm_Object_Item *item __UNUSED__)
|
2012-11-26 02:59:00 -08:00
|
|
|
{
|
|
|
|
char *text;
|
|
|
|
Eina_Strbuf *buf;
|
|
|
|
Evas_Object *eo, *inc_btn;
|
|
|
|
const char* increment_part;
|
|
|
|
|
|
|
|
if (!strcmp(elm_widget_style_get(data), "vertical"))
|
|
|
|
increment_part = "up_bt";
|
|
|
|
else
|
|
|
|
increment_part = "right_bt";
|
|
|
|
|
|
|
|
eo = elm_layout_edje_get(data);
|
|
|
|
inc_btn = (Evas_Object *)edje_object_part_object_get(eo, increment_part);
|
|
|
|
|
|
|
|
if (part_obj != inc_btn)
|
|
|
|
{
|
|
|
|
_val_dec_start(data);
|
|
|
|
elm_layout_signal_emit(data, "elm,left,anim,activate", "elm");
|
|
|
|
_val_dec_stop(data);
|
|
|
|
text = "decremented";
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
_val_inc_start(data);
|
|
|
|
elm_layout_signal_emit(data, "elm,right,anim,activate", "elm");
|
|
|
|
_val_inc_stop(data);
|
|
|
|
text = "incremented";
|
|
|
|
}
|
|
|
|
|
|
|
|
buf = eina_strbuf_new();
|
|
|
|
|
|
|
|
eina_strbuf_append_printf(buf, "%s, %s", text,
|
|
|
|
elm_layout_text_get(data, "elm.text"));
|
|
|
|
|
|
|
|
text = eina_strbuf_string_steal(buf);
|
|
|
|
eina_strbuf_free(buf);
|
|
|
|
|
|
|
|
_elm_access_say(text);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
_access_spinner_register(Evas_Object *obj, Eina_Bool is_access)
|
2012-08-21 03:08:56 -07:00
|
|
|
{
|
2012-11-26 02:59:00 -08:00
|
|
|
Evas_Object *ao;
|
2012-08-21 03:08:56 -07:00
|
|
|
Elm_Access_Info *ai;
|
|
|
|
const char* increment_part;
|
|
|
|
const char* decrement_part;
|
|
|
|
|
|
|
|
if (!strcmp(elm_widget_style_get(obj), "vertical"))
|
|
|
|
{
|
|
|
|
increment_part = "up_bt";
|
|
|
|
decrement_part = "down_bt";
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
increment_part = "right_bt";
|
|
|
|
decrement_part = "left_bt";
|
|
|
|
}
|
|
|
|
|
2012-11-26 02:59:00 -08:00
|
|
|
if (!is_access)
|
|
|
|
{
|
|
|
|
/* unregister increment button, decrement button and spinner label */
|
|
|
|
_elm_access_edje_object_part_object_unregister
|
|
|
|
(obj, elm_layout_edje_get(obj), increment_part);
|
|
|
|
|
|
|
|
_elm_access_edje_object_part_object_unregister
|
|
|
|
(obj, elm_layout_edje_get(obj), decrement_part);
|
|
|
|
|
|
|
|
_elm_access_edje_object_part_object_unregister
|
2013-09-06 19:56:11 -07:00
|
|
|
(obj, elm_layout_edje_get(obj), "access.text");
|
2012-11-26 02:59:00 -08:00
|
|
|
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* register increment button */
|
|
|
|
ao = _elm_access_edje_object_part_object_register
|
|
|
|
(obj, elm_layout_edje_get(obj), increment_part);
|
2012-10-10 17:35:00 -07:00
|
|
|
|
2013-07-30 20:53:04 -07:00
|
|
|
ai = _elm_access_info_get(ao);
|
2012-11-26 02:59:00 -08:00
|
|
|
_elm_access_text_set(ai, ELM_ACCESS_TYPE,
|
|
|
|
E_("spinner increment button"));
|
|
|
|
_elm_access_activate_callback_set(ai, _access_activate_cb, obj);
|
2012-08-21 03:08:56 -07:00
|
|
|
|
2012-11-26 02:59:00 -08:00
|
|
|
/* register decrement button */
|
|
|
|
ao = _elm_access_edje_object_part_object_register
|
|
|
|
(obj, elm_layout_edje_get(obj), decrement_part);
|
2012-08-21 03:08:56 -07:00
|
|
|
|
2013-07-30 20:53:04 -07:00
|
|
|
ai = _elm_access_info_get(ao);
|
2012-11-26 02:59:00 -08:00
|
|
|
_elm_access_text_set(ai, ELM_ACCESS_TYPE,
|
|
|
|
E_("spinner decrement button"));
|
|
|
|
_elm_access_activate_callback_set(ai, _access_activate_cb, obj);
|
2012-08-21 03:08:56 -07:00
|
|
|
|
2012-11-26 02:59:00 -08:00
|
|
|
/* register spinner label */
|
|
|
|
ao = _elm_access_edje_object_part_object_register
|
2013-09-06 19:56:11 -07:00
|
|
|
(obj, elm_layout_edje_get(obj), "access.text");
|
2012-08-21 03:08:56 -07:00
|
|
|
|
2013-07-30 20:53:04 -07:00
|
|
|
ai = _elm_access_info_get(ao);
|
2012-08-21 03:08:56 -07:00
|
|
|
_elm_access_text_set(ai, ELM_ACCESS_TYPE, E_("spinner"));
|
2012-11-25 22:32:53 -08:00
|
|
|
_elm_access_callback_set(ai, ELM_ACCESS_INFO, _access_info_cb, obj);
|
|
|
|
_elm_access_callback_set(ai, ELM_ACCESS_STATE, _access_state_cb, obj);
|
2012-08-21 03:08:56 -07:00
|
|
|
}
|
|
|
|
|
2012-05-14 14:52:06 -07:00
|
|
|
static void
|
2012-11-25 22:32:53 -08:00
|
|
|
_elm_spinner_smart_add(Eo *obj, void *_pd, va_list *list EINA_UNUSED)
|
2012-05-14 14:52:06 -07:00
|
|
|
{
|
2012-11-25 22:32:53 -08:00
|
|
|
Elm_Spinner_Smart_Data *priv = _pd;
|
2013-04-24 04:41:37 -07:00
|
|
|
Elm_Widget_Smart_Data *wd = eo_data_scope_get(obj, ELM_OBJ_WIDGET_CLASS);
|
2012-05-14 14:52:06 -07:00
|
|
|
|
2013-03-18 09:07:38 -07:00
|
|
|
eo_do_super(obj, MY_CLASS, evas_obj_smart_add());
|
2012-05-14 14:52:06 -07:00
|
|
|
|
2013-08-26 22:19:19 -07:00
|
|
|
elm_widget_sub_object_add(eo_parent_get(obj), obj);
|
|
|
|
|
2012-05-14 14:52:06 -07:00
|
|
|
priv->val_max = 100.0;
|
|
|
|
priv->step = 1.0;
|
|
|
|
priv->first_interval = 0.85;
|
|
|
|
|
2013-03-01 18:04:31 -08:00
|
|
|
if (!elm_layout_theme_set(obj, "spinner", "base",
|
|
|
|
elm_widget_style_get(obj)))
|
|
|
|
CRITICAL("Failed to set layout!");
|
|
|
|
|
2012-05-14 14:52:06 -07:00
|
|
|
elm_layout_signal_callback_add(obj, "drag", "*", _drag_cb, obj);
|
|
|
|
elm_layout_signal_callback_add(obj, "drag,start", "*", _drag_start_cb, obj);
|
|
|
|
elm_layout_signal_callback_add(obj, "drag,stop", "*", _drag_stop_cb, obj);
|
|
|
|
elm_layout_signal_callback_add(obj, "drag,step", "*", _drag_stop_cb, obj);
|
|
|
|
elm_layout_signal_callback_add(obj, "drag,page", "*", _drag_stop_cb, obj);
|
|
|
|
|
|
|
|
elm_layout_signal_callback_add
|
|
|
|
(obj, "elm,action,increment,start", "*", _button_inc_start_cb, obj);
|
|
|
|
elm_layout_signal_callback_add
|
|
|
|
(obj, "elm,action,increment,stop", "*", _button_inc_stop_cb, obj);
|
|
|
|
elm_layout_signal_callback_add
|
|
|
|
(obj, "elm,action,decrement,start", "*", _button_dec_start_cb, obj);
|
|
|
|
elm_layout_signal_callback_add
|
|
|
|
(obj, "elm,action,decrement,stop", "*", _button_dec_stop_cb, obj);
|
|
|
|
|
|
|
|
edje_object_part_drag_value_set
|
2012-11-25 22:32:53 -08:00
|
|
|
(wd->resize_obj, "elm.dragable.slider", 0.0, 0.0);
|
2012-05-14 14:52:06 -07:00
|
|
|
|
|
|
|
priv->ent = elm_entry_add(obj);
|
|
|
|
elm_entry_single_line_set(priv->ent, EINA_TRUE);
|
|
|
|
evas_object_smart_callback_add
|
|
|
|
(priv->ent, "activated", _entry_activated_cb, obj);
|
|
|
|
|
|
|
|
elm_layout_content_set(obj, "elm.swallow.entry", priv->ent);
|
|
|
|
elm_layout_signal_callback_add
|
|
|
|
(obj, "elm,action,entry,toggle", "*", _entry_toggle_cb, obj);
|
|
|
|
|
|
|
|
_label_write(obj);
|
|
|
|
elm_widget_can_focus_set(obj, EINA_TRUE);
|
|
|
|
|
|
|
|
elm_layout_sizing_eval(obj);
|
2012-08-21 03:08:56 -07:00
|
|
|
|
2012-11-26 02:59:00 -08:00
|
|
|
/* access */
|
|
|
|
if (_elm_config->access_mode)
|
|
|
|
_access_spinner_register(obj, EINA_TRUE);
|
2012-05-14 14:52:06 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
2012-11-25 22:32:53 -08:00
|
|
|
_elm_spinner_smart_del(Eo *obj, void *_pd, va_list *list EINA_UNUSED)
|
2012-05-14 14:52:06 -07:00
|
|
|
{
|
|
|
|
Elm_Spinner_Special_Value *sv;
|
|
|
|
|
2012-11-25 22:32:53 -08:00
|
|
|
Elm_Spinner_Smart_Data *sd = _pd;
|
2012-05-14 14:52:06 -07:00
|
|
|
|
2013-05-29 05:07:24 -07:00
|
|
|
if (sd->label) eina_stringshare_del(sd->label);
|
|
|
|
if (sd->delay) ecore_timer_del(sd->delay);
|
|
|
|
if (sd->spin) ecore_timer_del(sd->spin);
|
2013-05-22 23:54:49 -07:00
|
|
|
|
2012-05-14 14:52:06 -07:00
|
|
|
if (sd->special_values)
|
|
|
|
{
|
2013-03-08 20:23:42 -08:00
|
|
|
EINA_LIST_FREE(sd->special_values, sv)
|
2012-05-14 14:52:06 -07:00
|
|
|
{
|
|
|
|
eina_stringshare_del(sv->label);
|
|
|
|
free(sv);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2013-03-18 09:07:38 -07:00
|
|
|
eo_do_super(obj, MY_CLASS, evas_obj_smart_del());
|
2012-05-14 14:52:06 -07:00
|
|
|
}
|
|
|
|
|
2012-11-25 22:32:53 -08:00
|
|
|
static void
|
|
|
|
_elm_spinner_smart_theme(Eo *obj, void *_pd EINA_UNUSED, va_list *list)
|
2012-08-21 03:08:56 -07:00
|
|
|
{
|
2012-11-25 22:32:53 -08:00
|
|
|
Eina_Bool *ret = va_arg(*list, Eina_Bool *);
|
|
|
|
Eina_Bool int_ret;
|
|
|
|
|
|
|
|
int_ret = elm_layout_theme_set(obj, "spinner", "base",
|
2012-08-21 03:08:56 -07:00
|
|
|
elm_widget_style_get(obj));
|
2012-11-25 22:32:53 -08:00
|
|
|
if (ret) *ret = int_ret;
|
2012-08-21 03:08:56 -07:00
|
|
|
|
2013-03-01 18:04:31 -08:00
|
|
|
if (!int_ret) CRITICAL("Failed to set layout!");
|
|
|
|
|
2012-11-26 02:59:00 -08:00
|
|
|
if (_elm_config->access_mode)
|
|
|
|
_access_spinner_register(obj, EINA_TRUE);
|
2012-11-25 22:32:53 -08:00
|
|
|
}
|
2012-08-21 03:08:56 -07:00
|
|
|
|
2012-11-25 22:32:53 -08:00
|
|
|
static Eina_Bool _elm_spinner_smart_focus_next_enable = EINA_FALSE;
|
|
|
|
|
|
|
|
static void
|
|
|
|
_elm_spinner_smart_focus_next_manager_is(Eo *obj EINA_UNUSED, void *_pd EINA_UNUSED, va_list *list)
|
|
|
|
{
|
|
|
|
Eina_Bool *ret = va_arg(*list, Eina_Bool *);
|
|
|
|
*ret = _elm_spinner_smart_focus_next_enable;
|
2012-08-21 03:08:56 -07:00
|
|
|
}
|
|
|
|
|
2012-11-25 22:32:53 -08:00
|
|
|
static void
|
|
|
|
_elm_spinner_smart_focus_direction_manager_is(Eo *obj EINA_UNUSED, void *_pd EINA_UNUSED, va_list *list)
|
|
|
|
{
|
|
|
|
Eina_Bool *ret = va_arg(*list, Eina_Bool *);
|
|
|
|
*ret = EINA_FALSE;
|
|
|
|
}
|
|
|
|
|
2012-11-26 02:59:00 -08:00
|
|
|
static Evas_Object *
|
|
|
|
_access_object_get(const Evas_Object *obj, const char* part)
|
|
|
|
{
|
|
|
|
Evas_Object *eo, *po, *ao;
|
|
|
|
|
|
|
|
eo = elm_layout_edje_get(obj);
|
|
|
|
|
|
|
|
po = (Evas_Object *)edje_object_part_object_get(eo, part);
|
|
|
|
ao = evas_object_data_get(po, "_part_access_obj");
|
|
|
|
|
|
|
|
return ao;
|
|
|
|
}
|
|
|
|
|
2012-11-25 22:32:53 -08:00
|
|
|
static void
|
2012-11-26 02:59:00 -08:00
|
|
|
_elm_spinner_smart_focus_next(Eo *obj, void *_pd EINA_UNUSED, va_list *list)
|
2012-08-21 03:08:56 -07:00
|
|
|
{
|
2012-11-26 02:59:00 -08:00
|
|
|
Evas_Object *ao;
|
2012-11-25 22:32:53 -08:00
|
|
|
Elm_Focus_Direction dir = va_arg(*list, Elm_Focus_Direction);
|
|
|
|
Evas_Object **next = va_arg(*list, Evas_Object **);
|
|
|
|
Eina_Bool *ret = va_arg(*list, Eina_Bool *);
|
|
|
|
if (ret) *ret = EINA_FALSE;
|
|
|
|
Eina_Bool int_ret;
|
|
|
|
|
2012-08-21 03:08:56 -07:00
|
|
|
Eina_List *items = NULL;
|
2012-11-26 02:59:00 -08:00
|
|
|
const char* increment_part;
|
|
|
|
const char* decrement_part;
|
2012-08-21 03:08:56 -07:00
|
|
|
|
2012-11-25 22:32:53 -08:00
|
|
|
ELM_SPINNER_CHECK(obj);
|
2012-08-21 03:08:56 -07:00
|
|
|
|
2012-11-26 02:59:00 -08:00
|
|
|
if (!strcmp(elm_widget_style_get(obj), "vertical"))
|
|
|
|
{
|
|
|
|
increment_part = "up_bt";
|
|
|
|
decrement_part = "down_bt";
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
increment_part = "right_bt";
|
|
|
|
decrement_part = "left_bt";
|
|
|
|
}
|
|
|
|
|
2013-09-06 19:56:11 -07:00
|
|
|
ao = _access_object_get(obj, "access.text");
|
2012-11-26 02:59:00 -08:00
|
|
|
items = eina_list_append(items, ao);
|
|
|
|
|
|
|
|
ao = _access_object_get(obj, decrement_part);
|
|
|
|
items = eina_list_append(items, ao);
|
|
|
|
|
|
|
|
ao = _access_object_get(obj, increment_part);
|
|
|
|
items = eina_list_append(items, ao);
|
2012-08-21 03:08:56 -07:00
|
|
|
|
2012-11-25 22:32:53 -08:00
|
|
|
int_ret = elm_widget_focus_list_next_get
|
2012-08-21 03:08:56 -07:00
|
|
|
(obj, items, eina_list_data_get, dir, next);
|
2012-11-25 22:32:53 -08:00
|
|
|
if (ret) *ret = int_ret;
|
2012-08-21 03:08:56 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
2012-11-25 22:32:53 -08:00
|
|
|
_elm_spinner_smart_access(Eo *obj, void *_pd EINA_UNUSED, va_list *list)
|
2012-08-21 03:08:56 -07:00
|
|
|
{
|
|
|
|
ELM_SPINNER_CHECK(obj);
|
2012-10-10 17:35:00 -07:00
|
|
|
|
2012-11-25 22:32:53 -08:00
|
|
|
_elm_spinner_smart_focus_next_enable = va_arg(*list, int);
|
2012-11-26 02:59:00 -08:00
|
|
|
_access_spinner_register(obj, _elm_spinner_smart_focus_next_enable);
|
2012-08-21 03:08:56 -07:00
|
|
|
}
|
|
|
|
|
2009-09-03 05:36:39 -07:00
|
|
|
EAPI Evas_Object *
|
|
|
|
elm_spinner_add(Evas_Object *parent)
|
|
|
|
{
|
2012-05-14 14:52:06 -07:00
|
|
|
EINA_SAFETY_ON_NULL_RETURN_VAL(parent, NULL);
|
2012-11-25 22:32:53 -08:00
|
|
|
Evas_Object *obj = eo_add(MY_CLASS, parent);
|
|
|
|
eo_unref(obj);
|
|
|
|
return obj;
|
|
|
|
}
|
2012-05-14 14:52:06 -07:00
|
|
|
|
2012-11-25 22:32:53 -08:00
|
|
|
static void
|
|
|
|
_constructor(Eo *obj, void *_pd EINA_UNUSED, va_list *list EINA_UNUSED)
|
|
|
|
{
|
2013-03-18 09:07:38 -07:00
|
|
|
eo_do_super(obj, MY_CLASS, eo_constructor());
|
2012-11-25 22:32:53 -08:00
|
|
|
eo_do(obj,
|
|
|
|
evas_obj_type_set(MY_CLASS_NAME),
|
|
|
|
evas_obj_smart_callbacks_descriptions_set(_smart_callbacks, NULL));
|
2009-09-03 05:36:39 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
EAPI void
|
2012-05-14 14:52:06 -07:00
|
|
|
elm_spinner_label_format_set(Evas_Object *obj,
|
|
|
|
const char *fmt)
|
2009-09-03 05:36:39 -07:00
|
|
|
{
|
2012-05-14 14:52:06 -07:00
|
|
|
ELM_SPINNER_CHECK(obj);
|
2012-11-25 22:32:53 -08:00
|
|
|
eo_do(obj, elm_obj_spinner_label_format_set(fmt));
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
_elm_spinner_label_format_set(Eo *obj, void *_pd, va_list *list)
|
|
|
|
{
|
|
|
|
const char *fmt = va_arg(*list, const char *);
|
|
|
|
Elm_Spinner_Smart_Data *sd = _pd;
|
2012-05-14 14:52:06 -07:00
|
|
|
|
|
|
|
eina_stringshare_replace(&sd->label, fmt);
|
|
|
|
_label_write(obj);
|
|
|
|
elm_layout_sizing_eval(obj);
|
2009-09-03 05:36:39 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
EAPI const char *
|
2010-03-23 20:06:00 -07:00
|
|
|
elm_spinner_label_format_get(const Evas_Object *obj)
|
2009-09-03 05:36:39 -07:00
|
|
|
{
|
2012-05-14 14:52:06 -07:00
|
|
|
ELM_SPINNER_CHECK(obj) NULL;
|
2012-11-25 22:32:53 -08:00
|
|
|
const char *ret;
|
|
|
|
eo_do((Eo *) obj, elm_obj_spinner_label_format_get(&ret));
|
|
|
|
return ret;
|
|
|
|
}
|
2012-05-14 14:52:06 -07:00
|
|
|
|
2012-11-25 22:32:53 -08:00
|
|
|
static void
|
|
|
|
_elm_spinner_label_format_get(Eo *obj EINA_UNUSED, void *_pd, va_list *list)
|
|
|
|
{
|
|
|
|
const char **ret = va_arg(*list, const char **);
|
|
|
|
Elm_Spinner_Smart_Data *sd = _pd;
|
|
|
|
*ret = sd->label;
|
2009-09-03 05:36:39 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
EAPI void
|
2012-05-14 14:52:06 -07:00
|
|
|
elm_spinner_min_max_set(Evas_Object *obj,
|
|
|
|
double min,
|
|
|
|
double max)
|
|
|
|
{
|
|
|
|
ELM_SPINNER_CHECK(obj);
|
2012-11-25 22:32:53 -08:00
|
|
|
eo_do(obj, elm_obj_spinner_min_max_set(min, max));
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
_elm_spinner_min_max_set(Eo *obj, void *_pd, va_list *list)
|
|
|
|
{
|
|
|
|
double min = va_arg(*list, double);
|
|
|
|
double max = va_arg(*list, double);
|
|
|
|
Elm_Spinner_Smart_Data *sd = _pd;
|
2012-05-14 14:52:06 -07:00
|
|
|
|
|
|
|
if ((sd->val_min == min) && (sd->val_max == max)) return;
|
|
|
|
sd->val_min = min;
|
|
|
|
sd->val_max = max;
|
|
|
|
if (sd->val < sd->val_min) sd->val = sd->val_min;
|
|
|
|
if (sd->val > sd->val_max) sd->val = sd->val_max;
|
2009-09-03 05:36:39 -07:00
|
|
|
_val_set(obj);
|
2012-05-14 14:52:06 -07:00
|
|
|
_label_write(obj);
|
2009-09-03 05:36:39 -07:00
|
|
|
}
|
|
|
|
|
2010-04-01 07:22:32 -07:00
|
|
|
EAPI void
|
2012-05-14 14:52:06 -07:00
|
|
|
elm_spinner_min_max_get(const Evas_Object *obj,
|
|
|
|
double *min,
|
|
|
|
double *max)
|
2010-04-01 07:22:32 -07:00
|
|
|
{
|
|
|
|
if (min) *min = 0.0;
|
|
|
|
if (max) *max = 0.0;
|
2012-05-14 14:52:06 -07:00
|
|
|
|
|
|
|
ELM_SPINNER_CHECK(obj);
|
2012-11-25 22:32:53 -08:00
|
|
|
eo_do((Eo *) obj, elm_obj_spinner_min_max_get(min, max));
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
_elm_spinner_min_max_get(Eo *obj EINA_UNUSED, void *_pd, va_list *list)
|
|
|
|
{
|
|
|
|
double *min = va_arg(*list, double *);
|
|
|
|
double *max = va_arg(*list, double *);
|
|
|
|
|
|
|
|
Elm_Spinner_Smart_Data *sd = _pd;
|
2012-05-14 14:52:06 -07:00
|
|
|
|
|
|
|
if (min) *min = sd->val_min;
|
|
|
|
if (max) *max = sd->val_max;
|
2010-04-01 07:22:32 -07:00
|
|
|
}
|
|
|
|
|
2009-09-03 05:36:39 -07:00
|
|
|
EAPI void
|
2012-05-14 14:52:06 -07:00
|
|
|
elm_spinner_step_set(Evas_Object *obj,
|
|
|
|
double step)
|
2009-09-03 05:36:39 -07:00
|
|
|
{
|
2012-05-14 14:52:06 -07:00
|
|
|
ELM_SPINNER_CHECK(obj);
|
2012-11-25 22:32:53 -08:00
|
|
|
eo_do(obj, elm_obj_spinner_step_set(step));
|
|
|
|
}
|
2012-05-14 14:52:06 -07:00
|
|
|
|
2012-11-25 22:32:53 -08:00
|
|
|
static void
|
|
|
|
_elm_spinner_step_set(Eo *obj EINA_UNUSED, void *_pd, va_list *list)
|
|
|
|
{
|
|
|
|
double step = va_arg(*list, double);
|
|
|
|
Elm_Spinner_Smart_Data *sd = _pd;
|
2012-05-14 14:52:06 -07:00
|
|
|
sd->step = step;
|
2009-09-03 05:36:39 -07:00
|
|
|
}
|
|
|
|
|
2010-04-01 07:22:32 -07:00
|
|
|
EAPI double
|
|
|
|
elm_spinner_step_get(const Evas_Object *obj)
|
|
|
|
{
|
2012-05-14 14:52:06 -07:00
|
|
|
ELM_SPINNER_CHECK(obj) 0.0;
|
2012-11-25 22:32:53 -08:00
|
|
|
double ret;
|
|
|
|
eo_do((Eo *) obj, elm_obj_spinner_step_get(&ret));
|
|
|
|
return ret;
|
|
|
|
}
|
2012-05-14 14:52:06 -07:00
|
|
|
|
2012-11-25 22:32:53 -08:00
|
|
|
static void
|
|
|
|
_elm_spinner_step_get(Eo *obj EINA_UNUSED, void *_pd, va_list *list)
|
|
|
|
{
|
|
|
|
double *ret = va_arg(*list, double *);
|
|
|
|
Elm_Spinner_Smart_Data *sd = _pd;
|
|
|
|
*ret = sd->step;
|
2010-04-01 07:22:32 -07:00
|
|
|
}
|
2011-07-26 10:27:05 -07:00
|
|
|
|
2009-09-03 05:36:39 -07:00
|
|
|
EAPI void
|
2012-05-14 14:52:06 -07:00
|
|
|
elm_spinner_value_set(Evas_Object *obj,
|
|
|
|
double val)
|
|
|
|
{
|
|
|
|
ELM_SPINNER_CHECK(obj);
|
2012-11-25 22:32:53 -08:00
|
|
|
eo_do(obj, elm_obj_spinner_value_set(val));
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
_elm_spinner_value_set(Eo *obj, void *_pd, va_list *list)
|
|
|
|
{
|
|
|
|
double val = va_arg(*list, double);
|
|
|
|
Elm_Spinner_Smart_Data *sd = _pd;
|
2012-05-14 14:52:06 -07:00
|
|
|
|
|
|
|
if (sd->val == val) return;
|
|
|
|
sd->val = val;
|
|
|
|
if (sd->val < sd->val_min) sd->val = sd->val_min;
|
|
|
|
if (sd->val > sd->val_max) sd->val = sd->val_max;
|
2009-09-03 05:36:39 -07:00
|
|
|
_val_set(obj);
|
2012-05-14 14:52:06 -07:00
|
|
|
_label_write(obj);
|
2009-09-03 05:36:39 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
EAPI double
|
|
|
|
elm_spinner_value_get(const Evas_Object *obj)
|
|
|
|
{
|
2012-05-14 14:52:06 -07:00
|
|
|
ELM_SPINNER_CHECK(obj) 0.0;
|
2012-11-25 22:32:53 -08:00
|
|
|
double ret;
|
|
|
|
eo_do((Eo *) obj, elm_obj_spinner_value_get(&ret));
|
|
|
|
return ret;
|
|
|
|
}
|
2012-05-14 14:52:06 -07:00
|
|
|
|
2012-11-25 22:32:53 -08:00
|
|
|
static void
|
|
|
|
_elm_spinner_value_get(Eo *obj EINA_UNUSED, void *_pd, va_list *list)
|
|
|
|
{
|
|
|
|
double *ret = va_arg(*list, double *);
|
|
|
|
Elm_Spinner_Smart_Data *sd = _pd;
|
|
|
|
*ret = sd->val;
|
2009-09-03 05:36:39 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
EAPI void
|
2012-05-14 14:52:06 -07:00
|
|
|
elm_spinner_wrap_set(Evas_Object *obj,
|
|
|
|
Eina_Bool wrap)
|
2009-09-03 05:36:39 -07:00
|
|
|
{
|
2012-05-14 14:52:06 -07:00
|
|
|
ELM_SPINNER_CHECK(obj);
|
2012-11-25 22:32:53 -08:00
|
|
|
eo_do(obj, elm_obj_spinner_wrap_set(wrap));
|
|
|
|
}
|
2012-05-14 14:52:06 -07:00
|
|
|
|
2012-11-25 22:32:53 -08:00
|
|
|
static void
|
|
|
|
_elm_spinner_wrap_set(Eo *obj EINA_UNUSED, void *_pd, va_list *list)
|
|
|
|
{
|
|
|
|
Eina_Bool wrap = va_arg(*list, int);
|
|
|
|
Elm_Spinner_Smart_Data *sd = _pd;
|
2012-05-14 14:52:06 -07:00
|
|
|
sd->wrap = wrap;
|
2009-09-03 05:36:39 -07:00
|
|
|
}
|
2010-04-01 07:22:32 -07:00
|
|
|
|
|
|
|
EAPI Eina_Bool
|
|
|
|
elm_spinner_wrap_get(const Evas_Object *obj)
|
|
|
|
{
|
2012-05-14 14:52:06 -07:00
|
|
|
ELM_SPINNER_CHECK(obj) EINA_FALSE;
|
2012-11-25 22:32:53 -08:00
|
|
|
Eina_Bool ret;
|
|
|
|
eo_do((Eo *) obj, elm_obj_spinner_wrap_get(&ret));
|
|
|
|
return ret;
|
|
|
|
}
|
2012-05-14 14:52:06 -07:00
|
|
|
|
2012-11-25 22:32:53 -08:00
|
|
|
static void
|
|
|
|
_elm_spinner_wrap_get(Eo *obj EINA_UNUSED, void *_pd, va_list *list)
|
|
|
|
{
|
|
|
|
Eina_Bool *ret = va_arg(*list, Eina_Bool *);
|
|
|
|
Elm_Spinner_Smart_Data *sd = _pd;
|
|
|
|
*ret = sd->wrap;
|
2010-04-01 07:22:32 -07:00
|
|
|
}
|
2010-04-17 17:31:07 -07:00
|
|
|
|
|
|
|
EAPI void
|
2012-05-14 14:52:06 -07:00
|
|
|
elm_spinner_special_value_add(Evas_Object *obj,
|
|
|
|
double value,
|
|
|
|
const char *label)
|
2010-04-17 17:31:07 -07:00
|
|
|
{
|
2012-11-25 22:32:53 -08:00
|
|
|
ELM_SPINNER_CHECK(obj);
|
|
|
|
eo_do(obj, elm_obj_spinner_special_value_add(value, label));
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
_elm_spinner_special_value_add(Eo *obj, void *_pd, va_list *list)
|
|
|
|
{
|
|
|
|
double value = va_arg(*list, double);
|
|
|
|
const char *label = va_arg(*list, const char *);
|
2011-04-01 04:24:15 -07:00
|
|
|
Elm_Spinner_Special_Value *sv;
|
2012-10-08 15:39:05 -07:00
|
|
|
Eina_List *l;
|
2012-11-25 22:32:53 -08:00
|
|
|
Elm_Spinner_Smart_Data *sd = _pd;
|
2010-04-17 17:31:07 -07:00
|
|
|
|
2012-10-08 15:39:05 -07:00
|
|
|
EINA_LIST_FOREACH(sd->special_values, l, sv)
|
|
|
|
{
|
|
|
|
if (sv->value != value)
|
|
|
|
continue;
|
|
|
|
|
|
|
|
eina_stringshare_replace(&sv->label, label);
|
|
|
|
_label_write(obj);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2011-04-01 04:24:15 -07:00
|
|
|
sv = calloc(1, sizeof(*sv));
|
|
|
|
if (!sv) return;
|
|
|
|
sv->value = value;
|
|
|
|
sv->label = eina_stringshare_add(label);
|
2010-04-17 17:31:07 -07:00
|
|
|
|
2012-05-14 14:52:06 -07:00
|
|
|
sd->special_values = eina_list_append(sd->special_values, sv);
|
|
|
|
_label_write(obj);
|
2010-04-17 17:31:07 -07:00
|
|
|
}
|
|
|
|
|
2012-10-08 15:39:15 -07:00
|
|
|
EAPI void
|
|
|
|
elm_spinner_special_value_del(Evas_Object *obj,
|
|
|
|
double value)
|
|
|
|
{
|
|
|
|
Elm_Spinner_Special_Value *sv;
|
|
|
|
Eina_List *l;
|
|
|
|
|
|
|
|
ELM_SPINNER_CHECK(obj);
|
|
|
|
ELM_SPINNER_DATA_GET(obj, sd);
|
|
|
|
|
|
|
|
EINA_LIST_FOREACH(sd->special_values, l, sv)
|
|
|
|
{
|
|
|
|
if (sv->value != value)
|
|
|
|
continue;
|
|
|
|
|
2012-10-09 01:49:06 -07:00
|
|
|
sd->special_values = eina_list_remove_list(sd->special_values, l);
|
2012-10-08 15:39:15 -07:00
|
|
|
eina_stringshare_del(sv->label);
|
|
|
|
free(sv);
|
|
|
|
_label_write(obj);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
EAPI const char *
|
|
|
|
elm_spinner_special_value_get(Evas_Object *obj,
|
|
|
|
double value)
|
|
|
|
{
|
|
|
|
Elm_Spinner_Special_Value *sv;
|
|
|
|
Eina_List *l;
|
|
|
|
|
|
|
|
ELM_SPINNER_CHECK(obj) NULL;
|
|
|
|
ELM_SPINNER_DATA_GET(obj, sd);
|
|
|
|
|
|
|
|
EINA_LIST_FOREACH(sd->special_values, l, sv)
|
|
|
|
{
|
|
|
|
if (sv->value == value)
|
|
|
|
return sv->label;
|
|
|
|
}
|
|
|
|
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
2010-04-17 17:31:07 -07:00
|
|
|
EAPI void
|
2012-05-14 14:52:06 -07:00
|
|
|
elm_spinner_editable_set(Evas_Object *obj,
|
|
|
|
Eina_Bool editable)
|
2010-04-17 17:31:07 -07:00
|
|
|
{
|
2012-05-14 14:52:06 -07:00
|
|
|
ELM_SPINNER_CHECK(obj);
|
2012-11-25 22:32:53 -08:00
|
|
|
eo_do(obj, elm_obj_spinner_editable_set(editable));
|
|
|
|
}
|
2012-05-14 14:52:06 -07:00
|
|
|
|
2012-11-25 22:32:53 -08:00
|
|
|
static void
|
|
|
|
_elm_spinner_editable_set(Eo *obj EINA_UNUSED, void *_pd, va_list *list)
|
|
|
|
{
|
|
|
|
Eina_Bool editable = va_arg(*list, int);
|
|
|
|
Elm_Spinner_Smart_Data *sd = _pd;
|
2012-05-14 14:52:06 -07:00
|
|
|
sd->editable = editable;
|
2010-04-17 17:31:07 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
EAPI Eina_Bool
|
|
|
|
elm_spinner_editable_get(const Evas_Object *obj)
|
|
|
|
{
|
2012-05-14 14:52:06 -07:00
|
|
|
ELM_SPINNER_CHECK(obj) EINA_FALSE;
|
2012-11-25 22:32:53 -08:00
|
|
|
Eina_Bool ret;
|
|
|
|
eo_do((Eo *) obj, elm_obj_spinner_editable_get(&ret));
|
|
|
|
return ret;
|
|
|
|
}
|
2012-05-14 14:52:06 -07:00
|
|
|
|
2012-11-25 22:32:53 -08:00
|
|
|
static void
|
|
|
|
_elm_spinner_editable_get(Eo *obj EINA_UNUSED, void *_pd, va_list *list)
|
|
|
|
{
|
|
|
|
Eina_Bool *ret = va_arg(*list, Eina_Bool *);
|
|
|
|
Elm_Spinner_Smart_Data *sd = _pd;
|
|
|
|
*ret = sd->editable;
|
2010-04-17 17:31:07 -07:00
|
|
|
}
|
2010-07-20 14:38:17 -07:00
|
|
|
|
|
|
|
EAPI void
|
2012-05-14 14:52:06 -07:00
|
|
|
elm_spinner_interval_set(Evas_Object *obj,
|
|
|
|
double interval)
|
2010-07-20 14:38:17 -07:00
|
|
|
{
|
2012-05-14 14:52:06 -07:00
|
|
|
ELM_SPINNER_CHECK(obj);
|
2012-11-25 22:32:53 -08:00
|
|
|
eo_do(obj, elm_obj_spinner_interval_set(interval));
|
|
|
|
}
|
2012-05-14 14:52:06 -07:00
|
|
|
|
2012-11-25 22:32:53 -08:00
|
|
|
static void
|
|
|
|
_elm_spinner_interval_set(Eo *obj EINA_UNUSED, void *_pd, va_list *list)
|
|
|
|
{
|
|
|
|
double interval = va_arg(*list, double);
|
|
|
|
Elm_Spinner_Smart_Data *sd = _pd;
|
2012-05-14 14:52:06 -07:00
|
|
|
sd->first_interval = interval;
|
2010-07-20 14:38:17 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
EAPI double
|
|
|
|
elm_spinner_interval_get(const Evas_Object *obj)
|
|
|
|
{
|
2012-05-14 14:52:06 -07:00
|
|
|
ELM_SPINNER_CHECK(obj) 0.0;
|
2012-11-25 22:32:53 -08:00
|
|
|
double ret;
|
|
|
|
eo_do((Eo *) obj, elm_obj_spinner_interval_get(&ret));
|
|
|
|
return ret;
|
|
|
|
}
|
2012-05-14 14:52:06 -07:00
|
|
|
|
2012-11-25 22:32:53 -08:00
|
|
|
static void
|
|
|
|
_elm_spinner_interval_get(Eo *obj EINA_UNUSED, void *_pd, va_list *list)
|
|
|
|
{
|
|
|
|
double *ret = va_arg(*list, double *);
|
|
|
|
Elm_Spinner_Smart_Data *sd = _pd;
|
|
|
|
*ret = sd->first_interval;
|
2010-07-20 14:38:17 -07:00
|
|
|
}
|
2012-02-15 04:32:02 -08:00
|
|
|
|
|
|
|
EAPI void
|
2012-05-14 14:52:06 -07:00
|
|
|
elm_spinner_base_set(Evas_Object *obj,
|
|
|
|
double base)
|
2012-02-15 04:32:02 -08:00
|
|
|
{
|
2012-05-14 14:52:06 -07:00
|
|
|
ELM_SPINNER_CHECK(obj);
|
2012-11-25 22:32:53 -08:00
|
|
|
eo_do(obj, elm_obj_spinner_base_set(base));
|
|
|
|
}
|
2012-05-14 14:52:06 -07:00
|
|
|
|
2012-11-25 22:32:53 -08:00
|
|
|
static void
|
|
|
|
_elm_spinner_base_set(Eo *obj EINA_UNUSED, void *_pd, va_list *list)
|
|
|
|
{
|
|
|
|
double base = va_arg(*list, double);
|
|
|
|
Elm_Spinner_Smart_Data *sd = _pd;
|
2012-05-14 14:52:06 -07:00
|
|
|
sd->val_base = base;
|
2012-02-15 04:32:02 -08:00
|
|
|
}
|
|
|
|
|
|
|
|
EAPI double
|
|
|
|
elm_spinner_base_get(const Evas_Object *obj)
|
|
|
|
{
|
2012-05-14 14:52:06 -07:00
|
|
|
ELM_SPINNER_CHECK(obj) 0.0;
|
2012-11-25 22:32:53 -08:00
|
|
|
double ret;
|
|
|
|
eo_do((Eo *) obj, elm_obj_spinner_base_get(&ret));
|
|
|
|
return ret;
|
|
|
|
}
|
2012-05-14 14:52:06 -07:00
|
|
|
|
2012-11-25 22:32:53 -08:00
|
|
|
static void
|
|
|
|
_elm_spinner_base_get(Eo *obj EINA_UNUSED, void *_pd, va_list *list)
|
|
|
|
{
|
|
|
|
double *ret = va_arg(*list, double *);
|
|
|
|
Elm_Spinner_Smart_Data *sd = _pd;
|
|
|
|
*ret = sd->val_base;
|
2012-02-15 04:32:02 -08:00
|
|
|
}
|
|
|
|
|
|
|
|
EAPI void
|
2012-05-14 14:52:06 -07:00
|
|
|
elm_spinner_round_set(Evas_Object *obj,
|
|
|
|
int rnd)
|
2012-02-15 04:32:02 -08:00
|
|
|
{
|
2012-05-14 14:52:06 -07:00
|
|
|
ELM_SPINNER_CHECK(obj);
|
2012-11-25 22:32:53 -08:00
|
|
|
eo_do(obj, elm_obj_spinner_round_set(rnd));
|
|
|
|
}
|
2012-05-14 14:52:06 -07:00
|
|
|
|
2012-11-25 22:32:53 -08:00
|
|
|
static void
|
|
|
|
_elm_spinner_round_set(Eo *obj EINA_UNUSED, void *_pd, va_list *list)
|
|
|
|
{
|
|
|
|
int rnd = va_arg(*list, int);
|
|
|
|
Elm_Spinner_Smart_Data *sd = _pd;
|
2012-05-14 14:52:06 -07:00
|
|
|
sd->round = rnd;
|
2012-02-15 04:32:02 -08:00
|
|
|
}
|
|
|
|
|
|
|
|
EAPI int
|
|
|
|
elm_spinner_round_get(const Evas_Object *obj)
|
|
|
|
{
|
2012-05-14 14:52:06 -07:00
|
|
|
ELM_SPINNER_CHECK(obj) 0;
|
2012-11-25 22:32:53 -08:00
|
|
|
int ret;
|
|
|
|
eo_do((Eo *) obj, elm_obj_spinner_round_get(&ret));
|
|
|
|
return ret;
|
|
|
|
}
|
2012-05-14 14:52:06 -07:00
|
|
|
|
2012-11-25 22:32:53 -08:00
|
|
|
static void
|
|
|
|
_elm_spinner_round_get(Eo *obj EINA_UNUSED, void *_pd, va_list *list)
|
|
|
|
{
|
|
|
|
int *ret = va_arg(*list, int *);
|
|
|
|
Elm_Spinner_Smart_Data *sd = _pd;
|
|
|
|
*ret = sd->round;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
_class_constructor(Eo_Class *klass)
|
|
|
|
{
|
|
|
|
const Eo_Op_Func_Description func_desc[] = {
|
|
|
|
EO_OP_FUNC(EO_BASE_ID(EO_BASE_SUB_ID_CONSTRUCTOR), _constructor),
|
|
|
|
|
|
|
|
EO_OP_FUNC(EVAS_OBJ_SMART_ID(EVAS_OBJ_SMART_SUB_ID_ADD), _elm_spinner_smart_add),
|
|
|
|
EO_OP_FUNC(EVAS_OBJ_SMART_ID(EVAS_OBJ_SMART_SUB_ID_DEL), _elm_spinner_smart_del),
|
|
|
|
|
|
|
|
EO_OP_FUNC(ELM_WIDGET_ID(ELM_WIDGET_SUB_ID_THEME), _elm_spinner_smart_theme),
|
2013-04-23 05:00:50 -07:00
|
|
|
EO_OP_FUNC(ELM_WIDGET_ID(ELM_WIDGET_SUB_ID_TRANSLATE), _elm_spinner_smart_translate),
|
2012-11-25 22:32:53 -08:00
|
|
|
EO_OP_FUNC(ELM_WIDGET_ID(ELM_WIDGET_SUB_ID_ON_FOCUS), _elm_spinner_smart_on_focus),
|
|
|
|
EO_OP_FUNC(ELM_WIDGET_ID(ELM_WIDGET_SUB_ID_EVENT), _elm_spinner_smart_event),
|
|
|
|
EO_OP_FUNC(ELM_WIDGET_ID(ELM_WIDGET_SUB_ID_FOCUS_NEXT_MANAGER_IS), _elm_spinner_smart_focus_next_manager_is),
|
|
|
|
EO_OP_FUNC(ELM_WIDGET_ID(ELM_WIDGET_SUB_ID_FOCUS_NEXT), _elm_spinner_smart_focus_next),
|
|
|
|
EO_OP_FUNC(ELM_WIDGET_ID(ELM_WIDGET_SUB_ID_FOCUS_DIRECTION_MANAGER_IS), _elm_spinner_smart_focus_direction_manager_is),
|
|
|
|
EO_OP_FUNC(ELM_WIDGET_ID(ELM_WIDGET_SUB_ID_ACCESS), _elm_spinner_smart_access),
|
|
|
|
|
|
|
|
EO_OP_FUNC(ELM_OBJ_LAYOUT_ID(ELM_OBJ_LAYOUT_SUB_ID_SIZING_EVAL), _elm_spinner_smart_sizing_eval),
|
|
|
|
|
|
|
|
EO_OP_FUNC(ELM_OBJ_SPINNER_ID(ELM_OBJ_SPINNER_SUB_ID_LABEL_FORMAT_SET), _elm_spinner_label_format_set),
|
|
|
|
EO_OP_FUNC(ELM_OBJ_SPINNER_ID(ELM_OBJ_SPINNER_SUB_ID_LABEL_FORMAT_GET), _elm_spinner_label_format_get),
|
|
|
|
EO_OP_FUNC(ELM_OBJ_SPINNER_ID(ELM_OBJ_SPINNER_SUB_ID_MIN_MAX_SET), _elm_spinner_min_max_set),
|
|
|
|
EO_OP_FUNC(ELM_OBJ_SPINNER_ID(ELM_OBJ_SPINNER_SUB_ID_MIN_MAX_GET), _elm_spinner_min_max_get),
|
|
|
|
EO_OP_FUNC(ELM_OBJ_SPINNER_ID(ELM_OBJ_SPINNER_SUB_ID_STEP_SET), _elm_spinner_step_set),
|
|
|
|
EO_OP_FUNC(ELM_OBJ_SPINNER_ID(ELM_OBJ_SPINNER_SUB_ID_STEP_GET), _elm_spinner_step_get),
|
|
|
|
EO_OP_FUNC(ELM_OBJ_SPINNER_ID(ELM_OBJ_SPINNER_SUB_ID_VALUE_SET), _elm_spinner_value_set),
|
|
|
|
EO_OP_FUNC(ELM_OBJ_SPINNER_ID(ELM_OBJ_SPINNER_SUB_ID_VALUE_GET), _elm_spinner_value_get),
|
|
|
|
EO_OP_FUNC(ELM_OBJ_SPINNER_ID(ELM_OBJ_SPINNER_SUB_ID_WRAP_SET), _elm_spinner_wrap_set),
|
|
|
|
EO_OP_FUNC(ELM_OBJ_SPINNER_ID(ELM_OBJ_SPINNER_SUB_ID_WRAP_GET), _elm_spinner_wrap_get),
|
|
|
|
EO_OP_FUNC(ELM_OBJ_SPINNER_ID(ELM_OBJ_SPINNER_SUB_ID_SPECIAL_VALUE_ADD), _elm_spinner_special_value_add),
|
|
|
|
EO_OP_FUNC(ELM_OBJ_SPINNER_ID(ELM_OBJ_SPINNER_SUB_ID_EDITABLE_SET), _elm_spinner_editable_set),
|
|
|
|
EO_OP_FUNC(ELM_OBJ_SPINNER_ID(ELM_OBJ_SPINNER_SUB_ID_EDITABLE_GET), _elm_spinner_editable_get),
|
|
|
|
EO_OP_FUNC(ELM_OBJ_SPINNER_ID(ELM_OBJ_SPINNER_SUB_ID_INTERVAL_SET), _elm_spinner_interval_set),
|
|
|
|
EO_OP_FUNC(ELM_OBJ_SPINNER_ID(ELM_OBJ_SPINNER_SUB_ID_INTERVAL_GET), _elm_spinner_interval_get),
|
|
|
|
EO_OP_FUNC(ELM_OBJ_SPINNER_ID(ELM_OBJ_SPINNER_SUB_ID_BASE_SET), _elm_spinner_base_set),
|
|
|
|
EO_OP_FUNC(ELM_OBJ_SPINNER_ID(ELM_OBJ_SPINNER_SUB_ID_BASE_GET), _elm_spinner_base_get),
|
|
|
|
EO_OP_FUNC(ELM_OBJ_SPINNER_ID(ELM_OBJ_SPINNER_SUB_ID_ROUND_SET), _elm_spinner_round_set),
|
|
|
|
EO_OP_FUNC(ELM_OBJ_SPINNER_ID(ELM_OBJ_SPINNER_SUB_ID_ROUND_GET), _elm_spinner_round_get),
|
|
|
|
EO_OP_FUNC_SENTINEL
|
|
|
|
};
|
|
|
|
eo_class_funcs_set(klass, func_desc);
|
|
|
|
|
2013-02-09 23:52:31 -08:00
|
|
|
evas_smart_legacy_type_register(MY_CLASS_NAME, klass);
|
|
|
|
|
2012-11-26 02:59:00 -08:00
|
|
|
if (_elm_config->access_mode)
|
2012-11-25 22:32:53 -08:00
|
|
|
_elm_spinner_smart_focus_next_enable = EINA_TRUE;
|
2012-02-15 04:32:02 -08:00
|
|
|
}
|
2012-11-25 22:32:53 -08:00
|
|
|
static const Eo_Op_Description op_desc[] = {
|
|
|
|
EO_OP_DESCRIPTION(ELM_OBJ_SPINNER_SUB_ID_LABEL_FORMAT_SET, "Set the format string of the displayed label."),
|
|
|
|
EO_OP_DESCRIPTION(ELM_OBJ_SPINNER_SUB_ID_LABEL_FORMAT_GET, "Get the label format of the spinner."),
|
|
|
|
EO_OP_DESCRIPTION(ELM_OBJ_SPINNER_SUB_ID_MIN_MAX_SET, "Set the minimum and maximum values for the spinner."),
|
|
|
|
EO_OP_DESCRIPTION(ELM_OBJ_SPINNER_SUB_ID_MIN_MAX_GET, "Get the minimum and maximum values of the spinner."),
|
|
|
|
EO_OP_DESCRIPTION(ELM_OBJ_SPINNER_SUB_ID_STEP_SET, "Set the step used to increment or decrement the spinner value."),
|
|
|
|
EO_OP_DESCRIPTION(ELM_OBJ_SPINNER_SUB_ID_STEP_GET, "Get the step used to increment or decrement the spinner value."),
|
|
|
|
EO_OP_DESCRIPTION(ELM_OBJ_SPINNER_SUB_ID_VALUE_SET, "Set the value the spinner displays."),
|
|
|
|
EO_OP_DESCRIPTION(ELM_OBJ_SPINNER_SUB_ID_VALUE_GET, "Get the value displayed by the spinner."),
|
|
|
|
EO_OP_DESCRIPTION(ELM_OBJ_SPINNER_SUB_ID_WRAP_SET, "Set whether the spinner should wrap when it reaches its minimum or maximum value."),
|
|
|
|
EO_OP_DESCRIPTION(ELM_OBJ_SPINNER_SUB_ID_WRAP_GET, "Get whether the spinner should wrap when it reaches its minimum or maximum value."),
|
|
|
|
EO_OP_DESCRIPTION(ELM_OBJ_SPINNER_SUB_ID_SPECIAL_VALUE_ADD, "Set a special string to display in the place of the numerical value."),
|
|
|
|
EO_OP_DESCRIPTION(ELM_OBJ_SPINNER_SUB_ID_EDITABLE_SET, "Set whether the spinner can be directly edited by the user or not."),
|
|
|
|
EO_OP_DESCRIPTION(ELM_OBJ_SPINNER_SUB_ID_EDITABLE_GET, "Get whether the spinner can be directly edited by the user or not."),
|
|
|
|
EO_OP_DESCRIPTION(ELM_OBJ_SPINNER_SUB_ID_INTERVAL_SET, "Set the interval on time updates for an user mouse button hold on spinner widgets' arrows."),
|
|
|
|
EO_OP_DESCRIPTION(ELM_OBJ_SPINNER_SUB_ID_INTERVAL_GET, "Get the interval on time updates for an user mouse button hold on spinner widgets' arrows."),
|
|
|
|
EO_OP_DESCRIPTION(ELM_OBJ_SPINNER_SUB_ID_BASE_SET, "Set the base for rounding."),
|
|
|
|
EO_OP_DESCRIPTION(ELM_OBJ_SPINNER_SUB_ID_BASE_GET, "Get the base for rounding."),
|
|
|
|
EO_OP_DESCRIPTION(ELM_OBJ_SPINNER_SUB_ID_ROUND_SET, "Set the round value for rounding."),
|
|
|
|
EO_OP_DESCRIPTION(ELM_OBJ_SPINNER_SUB_ID_ROUND_GET, "Get the round value for rounding."),
|
|
|
|
EO_OP_DESCRIPTION_SENTINEL
|
|
|
|
};
|
|
|
|
static const Eo_Class_Description class_desc = {
|
|
|
|
EO_VERSION,
|
|
|
|
MY_CLASS_NAME,
|
|
|
|
EO_CLASS_TYPE_REGULAR,
|
|
|
|
EO_CLASS_DESCRIPTION_OPS(&ELM_OBJ_SPINNER_BASE_ID, op_desc, ELM_OBJ_SPINNER_SUB_ID_LAST),
|
|
|
|
NULL,
|
|
|
|
sizeof(Elm_Spinner_Smart_Data),
|
|
|
|
_class_constructor,
|
|
|
|
NULL
|
|
|
|
};
|
|
|
|
EO_DEFINE_CLASS(elm_obj_spinner_class_get, &class_desc, ELM_OBJ_LAYOUT_CLASS, NULL);
|