2009-12-05 17:22:54 -08:00
|
|
|
#include "private.h"
|
|
|
|
|
|
|
|
typedef struct _Elm_Params_Slider
|
|
|
|
{
|
|
|
|
Elm_Params base;
|
2010-10-21 15:03:43 -07:00
|
|
|
const char *label;
|
2009-12-05 17:22:54 -08:00
|
|
|
Evas_Object *icon;
|
|
|
|
const char *indicator, *unit;
|
2009-12-08 18:37:20 -08:00
|
|
|
double min, max, value;
|
2013-02-14 13:21:05 -08:00
|
|
|
Evas_Coord span;
|
2010-03-25 13:17:34 -07:00
|
|
|
Eina_Bool min_exists:1;
|
|
|
|
Eina_Bool max_exists:1;
|
|
|
|
Eina_Bool value_exists:1;
|
|
|
|
Eina_Bool inverted:1;
|
|
|
|
Eina_Bool inverted_exists:1;
|
|
|
|
Eina_Bool span_exists:1;
|
|
|
|
Eina_Bool horizontal:1;
|
|
|
|
Eina_Bool horizontal_exists:1;
|
2009-12-05 17:22:54 -08:00
|
|
|
} Elm_Params_Slider;
|
|
|
|
|
|
|
|
static void
|
Port to new Edje EXTERNAL API goodies!
Now it is possible to change labels and lots of other parameters
directly through Edje's API.
BIG FAT NOTE: this is a convenience that comes with a reasonable
price. If you have hot paths, like loops, then avoid calling this
and use the object directly. This functions add a cost to check
edje, then find the part, then get the type, then get the
param_set/param_get methods, then calling it, then finding the
parameters using strcmp(), then checking the type and just then it
will call the actual method. So whenever possible, just call the
method directly.
Due the reasoning of the "big fat note" I'm adding this inside edje
externals only. The code would be almost the same to expose it in
Elementary.h as elm_widget_property_set/get, but then I know people
would misuse it... actually this kind of stuff could be easily ported
to Evas smart object, but then abuse and slowness will hunt us
foreveeeeer...
SVN revision: 47457
2010-03-25 11:10:25 -07:00
|
|
|
external_slider_state_set(void *data __UNUSED__, Evas_Object *obj, const void *from_params, const void *to_params, float pos __UNUSED__)
|
2009-12-05 17:22:54 -08:00
|
|
|
{
|
2010-03-25 13:17:34 -07:00
|
|
|
const Elm_Params_Slider *p;
|
2009-12-05 17:22:54 -08:00
|
|
|
|
2010-03-25 13:17:34 -07:00
|
|
|
if (to_params) p = to_params;
|
|
|
|
else if (from_params) p = from_params;
|
|
|
|
else return;
|
2009-12-05 17:22:54 -08:00
|
|
|
|
2010-10-21 15:03:43 -07:00
|
|
|
if (p->label)
|
2011-06-30 08:27:38 -07:00
|
|
|
elm_object_text_set(obj, p->label);
|
2010-03-25 13:17:34 -07:00
|
|
|
if (p->icon)
|
2011-11-17 13:02:31 -08:00
|
|
|
elm_object_part_content_set(obj, "icon", p->icon);
|
2010-03-25 13:17:34 -07:00
|
|
|
if (p->span_exists)
|
|
|
|
elm_slider_span_size_set(obj, p->span);
|
|
|
|
if ((p->min_exists) && (p->max_exists))
|
|
|
|
elm_slider_min_max_set(obj, p->min, p->max);
|
|
|
|
else if ((p->min_exists) || (p->max_exists))
|
2009-12-05 17:22:54 -08:00
|
|
|
{
|
2010-03-25 13:17:34 -07:00
|
|
|
double min, max;
|
|
|
|
elm_slider_min_max_get(obj, &min, &max);
|
|
|
|
if (p->min_exists)
|
|
|
|
elm_slider_min_max_set(obj, p->min, max);
|
|
|
|
else
|
|
|
|
elm_slider_min_max_set(obj, min, p->max);
|
2009-12-05 17:22:54 -08:00
|
|
|
}
|
2010-03-25 13:17:34 -07:00
|
|
|
if (p->value_exists)
|
|
|
|
elm_slider_value_set(obj, p->value);
|
|
|
|
if (p->inverted_exists)
|
2010-04-01 07:22:41 -07:00
|
|
|
elm_slider_inverted_set(obj, p->inverted);
|
2010-03-25 13:17:34 -07:00
|
|
|
if (p->horizontal_exists)
|
|
|
|
elm_slider_horizontal_set(obj, p->horizontal);
|
|
|
|
if (p->indicator)
|
|
|
|
elm_slider_indicator_format_set(obj, p->indicator);
|
|
|
|
if (p->unit)
|
|
|
|
elm_slider_unit_format_set(obj, p->unit);
|
2009-12-05 17:22:54 -08:00
|
|
|
}
|
|
|
|
|
Port to new Edje EXTERNAL API goodies!
Now it is possible to change labels and lots of other parameters
directly through Edje's API.
BIG FAT NOTE: this is a convenience that comes with a reasonable
price. If you have hot paths, like loops, then avoid calling this
and use the object directly. This functions add a cost to check
edje, then find the part, then get the type, then get the
param_set/param_get methods, then calling it, then finding the
parameters using strcmp(), then checking the type and just then it
will call the actual method. So whenever possible, just call the
method directly.
Due the reasoning of the "big fat note" I'm adding this inside edje
externals only. The code would be almost the same to expose it in
Elementary.h as elm_widget_property_set/get, but then I know people
would misuse it... actually this kind of stuff could be easily ported
to Evas smart object, but then abuse and slowness will hunt us
foreveeeeer...
SVN revision: 47457
2010-03-25 11:10:25 -07:00
|
|
|
static Eina_Bool
|
|
|
|
external_slider_param_set(void *data __UNUSED__, Evas_Object *obj, const Edje_External_Param *param)
|
|
|
|
{
|
|
|
|
if (!strcmp(param->name, "label"))
|
|
|
|
{
|
|
|
|
if (param->type == EDJE_EXTERNAL_PARAM_TYPE_STRING)
|
|
|
|
{
|
2011-06-30 08:27:38 -07:00
|
|
|
elm_object_text_set(obj, param->s);
|
Port to new Edje EXTERNAL API goodies!
Now it is possible to change labels and lots of other parameters
directly through Edje's API.
BIG FAT NOTE: this is a convenience that comes with a reasonable
price. If you have hot paths, like loops, then avoid calling this
and use the object directly. This functions add a cost to check
edje, then find the part, then get the type, then get the
param_set/param_get methods, then calling it, then finding the
parameters using strcmp(), then checking the type and just then it
will call the actual method. So whenever possible, just call the
method directly.
Due the reasoning of the "big fat note" I'm adding this inside edje
externals only. The code would be almost the same to expose it in
Elementary.h as elm_widget_property_set/get, but then I know people
would misuse it... actually this kind of stuff could be easily ported
to Evas smart object, but then abuse and slowness will hunt us
foreveeeeer...
SVN revision: 47457
2010-03-25 11:10:25 -07:00
|
|
|
return EINA_TRUE;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
else if (!strcmp(param->name, "icon"))
|
|
|
|
{
|
|
|
|
if (param->type == EDJE_EXTERNAL_PARAM_TYPE_STRING)
|
|
|
|
{
|
|
|
|
Evas_Object *icon = external_common_param_icon_get(obj, param);
|
2010-06-16 13:58:01 -07:00
|
|
|
if ((strcmp(param->s, "")) && (!icon)) return EINA_FALSE;
|
2011-11-17 13:02:31 -08:00
|
|
|
elm_object_part_content_set(obj, "icon", icon);
|
2010-06-16 13:58:01 -07:00
|
|
|
return EINA_TRUE;
|
Port to new Edje EXTERNAL API goodies!
Now it is possible to change labels and lots of other parameters
directly through Edje's API.
BIG FAT NOTE: this is a convenience that comes with a reasonable
price. If you have hot paths, like loops, then avoid calling this
and use the object directly. This functions add a cost to check
edje, then find the part, then get the type, then get the
param_set/param_get methods, then calling it, then finding the
parameters using strcmp(), then checking the type and just then it
will call the actual method. So whenever possible, just call the
method directly.
Due the reasoning of the "big fat note" I'm adding this inside edje
externals only. The code would be almost the same to expose it in
Elementary.h as elm_widget_property_set/get, but then I know people
would misuse it... actually this kind of stuff could be easily ported
to Evas smart object, but then abuse and slowness will hunt us
foreveeeeer...
SVN revision: 47457
2010-03-25 11:10:25 -07:00
|
|
|
}
|
|
|
|
}
|
|
|
|
else if (!strcmp(param->name, "min"))
|
|
|
|
{
|
|
|
|
if (param->type == EDJE_EXTERNAL_PARAM_TYPE_DOUBLE)
|
|
|
|
{
|
|
|
|
double min, max;
|
|
|
|
elm_slider_min_max_get(obj, &min, &max);
|
|
|
|
elm_slider_min_max_set(obj, param->d, max);
|
|
|
|
return EINA_TRUE;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
else if (!strcmp(param->name, "max"))
|
|
|
|
{
|
|
|
|
if (param->type == EDJE_EXTERNAL_PARAM_TYPE_DOUBLE)
|
|
|
|
{
|
|
|
|
double min, max;
|
|
|
|
elm_slider_min_max_get(obj, &min, &max);
|
|
|
|
elm_slider_min_max_set(obj, min, param->d);
|
|
|
|
return EINA_TRUE;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
else if (!strcmp(param->name, "value"))
|
|
|
|
{
|
|
|
|
if (param->type == EDJE_EXTERNAL_PARAM_TYPE_DOUBLE)
|
|
|
|
{
|
|
|
|
elm_slider_value_set(obj, param->d);
|
|
|
|
return EINA_TRUE;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
else if (!strcmp(param->name, "horizontal"))
|
|
|
|
{
|
|
|
|
if (param->type == EDJE_EXTERNAL_PARAM_TYPE_BOOL)
|
|
|
|
{
|
|
|
|
elm_slider_horizontal_set(obj, param->i);
|
|
|
|
return EINA_TRUE;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
else if (!strcmp(param->name, "inverted"))
|
|
|
|
{
|
|
|
|
if (param->type == EDJE_EXTERNAL_PARAM_TYPE_BOOL)
|
|
|
|
{
|
|
|
|
elm_slider_inverted_set(obj, param->i);
|
|
|
|
return EINA_TRUE;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
else if (!strcmp(param->name, "span"))
|
|
|
|
{
|
|
|
|
if (param->type == EDJE_EXTERNAL_PARAM_TYPE_INT)
|
|
|
|
{
|
|
|
|
elm_slider_span_size_set(obj, param->i);
|
|
|
|
return EINA_TRUE;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
else if (!strcmp(param->name, "unit format"))
|
|
|
|
{
|
|
|
|
if (param->type == EDJE_EXTERNAL_PARAM_TYPE_STRING)
|
|
|
|
{
|
|
|
|
elm_slider_unit_format_set(obj, param->s);
|
|
|
|
return EINA_TRUE;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
else if (!strcmp(param->name, "indicator format"))
|
|
|
|
{
|
|
|
|
if (param->type == EDJE_EXTERNAL_PARAM_TYPE_STRING)
|
|
|
|
{
|
|
|
|
elm_slider_indicator_format_set(obj, param->s);
|
|
|
|
return EINA_TRUE;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
ERR("unknown parameter '%s' of type '%s'",
|
|
|
|
param->name, edje_external_param_type_str(param->type));
|
|
|
|
|
|
|
|
return EINA_FALSE;
|
|
|
|
}
|
|
|
|
|
|
|
|
static Eina_Bool
|
|
|
|
external_slider_param_get(void *data __UNUSED__, const Evas_Object *obj, Edje_External_Param *param)
|
|
|
|
{
|
|
|
|
if (!strcmp(param->name, "label"))
|
|
|
|
{
|
|
|
|
if (param->type == EDJE_EXTERNAL_PARAM_TYPE_STRING)
|
|
|
|
{
|
2011-06-30 08:27:38 -07:00
|
|
|
param->s = elm_object_text_get(obj);
|
Port to new Edje EXTERNAL API goodies!
Now it is possible to change labels and lots of other parameters
directly through Edje's API.
BIG FAT NOTE: this is a convenience that comes with a reasonable
price. If you have hot paths, like loops, then avoid calling this
and use the object directly. This functions add a cost to check
edje, then find the part, then get the type, then get the
param_set/param_get methods, then calling it, then finding the
parameters using strcmp(), then checking the type and just then it
will call the actual method. So whenever possible, just call the
method directly.
Due the reasoning of the "big fat note" I'm adding this inside edje
externals only. The code would be almost the same to expose it in
Elementary.h as elm_widget_property_set/get, but then I know people
would misuse it... actually this kind of stuff could be easily ported
to Evas smart object, but then abuse and slowness will hunt us
foreveeeeer...
SVN revision: 47457
2010-03-25 11:10:25 -07:00
|
|
|
return EINA_TRUE;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
else if (!strcmp(param->name, "icon"))
|
|
|
|
{
|
|
|
|
/* not easy to get icon name back from live object */
|
|
|
|
return EINA_FALSE;
|
|
|
|
}
|
|
|
|
else if (!strcmp(param->name, "min"))
|
|
|
|
{
|
2013-02-16 03:24:05 -08:00
|
|
|
if (param->type == EDJE_EXTERNAL_PARAM_TYPE_DOUBLE)
|
Port to new Edje EXTERNAL API goodies!
Now it is possible to change labels and lots of other parameters
directly through Edje's API.
BIG FAT NOTE: this is a convenience that comes with a reasonable
price. If you have hot paths, like loops, then avoid calling this
and use the object directly. This functions add a cost to check
edje, then find the part, then get the type, then get the
param_set/param_get methods, then calling it, then finding the
parameters using strcmp(), then checking the type and just then it
will call the actual method. So whenever possible, just call the
method directly.
Due the reasoning of the "big fat note" I'm adding this inside edje
externals only. The code would be almost the same to expose it in
Elementary.h as elm_widget_property_set/get, but then I know people
would misuse it... actually this kind of stuff could be easily ported
to Evas smart object, but then abuse and slowness will hunt us
foreveeeeer...
SVN revision: 47457
2010-03-25 11:10:25 -07:00
|
|
|
{
|
|
|
|
double min, max;
|
|
|
|
elm_slider_min_max_get(obj, &min, &max);
|
|
|
|
param->d = min;
|
|
|
|
return EINA_TRUE;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
else if (!strcmp(param->name, "max"))
|
|
|
|
{
|
2013-02-16 03:24:05 -08:00
|
|
|
if (param->type == EDJE_EXTERNAL_PARAM_TYPE_DOUBLE)
|
Port to new Edje EXTERNAL API goodies!
Now it is possible to change labels and lots of other parameters
directly through Edje's API.
BIG FAT NOTE: this is a convenience that comes with a reasonable
price. If you have hot paths, like loops, then avoid calling this
and use the object directly. This functions add a cost to check
edje, then find the part, then get the type, then get the
param_set/param_get methods, then calling it, then finding the
parameters using strcmp(), then checking the type and just then it
will call the actual method. So whenever possible, just call the
method directly.
Due the reasoning of the "big fat note" I'm adding this inside edje
externals only. The code would be almost the same to expose it in
Elementary.h as elm_widget_property_set/get, but then I know people
would misuse it... actually this kind of stuff could be easily ported
to Evas smart object, but then abuse and slowness will hunt us
foreveeeeer...
SVN revision: 47457
2010-03-25 11:10:25 -07:00
|
|
|
{
|
|
|
|
double min, max;
|
|
|
|
elm_slider_min_max_get(obj, &min, &max);
|
|
|
|
param->d = max;
|
|
|
|
return EINA_TRUE;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
else if (!strcmp(param->name, "value"))
|
|
|
|
{
|
|
|
|
if (param->type == EDJE_EXTERNAL_PARAM_TYPE_DOUBLE)
|
|
|
|
{
|
|
|
|
param->d = elm_slider_value_get(obj);
|
|
|
|
return EINA_TRUE;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
else if (!strcmp(param->name, "horizontal"))
|
|
|
|
{
|
|
|
|
if (param->type == EDJE_EXTERNAL_PARAM_TYPE_BOOL)
|
|
|
|
{
|
|
|
|
param->i = elm_slider_horizontal_get(obj);
|
|
|
|
return EINA_TRUE;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
else if (!strcmp(param->name, "inverted"))
|
|
|
|
{
|
|
|
|
if (param->type == EDJE_EXTERNAL_PARAM_TYPE_BOOL)
|
|
|
|
{
|
|
|
|
param->i = elm_slider_inverted_get(obj);
|
|
|
|
return EINA_TRUE;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
else if (!strcmp(param->name, "span"))
|
|
|
|
{
|
|
|
|
if (param->type == EDJE_EXTERNAL_PARAM_TYPE_INT)
|
|
|
|
{
|
|
|
|
param->i = elm_slider_span_size_get(obj);
|
|
|
|
return EINA_TRUE;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
else if (!strcmp(param->name, "unit format"))
|
|
|
|
{
|
|
|
|
if (param->type == EDJE_EXTERNAL_PARAM_TYPE_STRING)
|
|
|
|
{
|
|
|
|
param->s = elm_slider_unit_format_get(obj);
|
|
|
|
return EINA_TRUE;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
else if (!strcmp(param->name, "indicator format"))
|
|
|
|
{
|
|
|
|
if (param->type == EDJE_EXTERNAL_PARAM_TYPE_STRING)
|
|
|
|
{
|
|
|
|
param->s = elm_slider_indicator_format_get(obj);
|
|
|
|
return EINA_TRUE;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
ERR("unknown parameter '%s' of type '%s'",
|
|
|
|
param->name, edje_external_param_type_str(param->type));
|
|
|
|
|
|
|
|
return EINA_FALSE;
|
|
|
|
}
|
|
|
|
|
2009-12-05 17:22:54 -08:00
|
|
|
static void *
|
Port to new Edje EXTERNAL API goodies!
Now it is possible to change labels and lots of other parameters
directly through Edje's API.
BIG FAT NOTE: this is a convenience that comes with a reasonable
price. If you have hot paths, like loops, then avoid calling this
and use the object directly. This functions add a cost to check
edje, then find the part, then get the type, then get the
param_set/param_get methods, then calling it, then finding the
parameters using strcmp(), then checking the type and just then it
will call the actual method. So whenever possible, just call the
method directly.
Due the reasoning of the "big fat note" I'm adding this inside edje
externals only. The code would be almost the same to expose it in
Elementary.h as elm_widget_property_set/get, but then I know people
would misuse it... actually this kind of stuff could be easily ported
to Evas smart object, but then abuse and slowness will hunt us
foreveeeeer...
SVN revision: 47457
2010-03-25 11:10:25 -07:00
|
|
|
external_slider_params_parse(void *data __UNUSED__, Evas_Object *obj __UNUSED__, const Eina_List *params)
|
2009-12-05 17:22:54 -08:00
|
|
|
{
|
|
|
|
Elm_Params_Slider *mem;
|
|
|
|
Edje_External_Param *param;
|
2009-12-08 20:37:48 -08:00
|
|
|
const Eina_List *l;
|
2009-12-05 17:22:54 -08:00
|
|
|
|
2010-10-21 15:03:43 -07:00
|
|
|
mem = calloc(1, sizeof(Elm_Params_Slider));
|
2009-12-05 17:22:54 -08:00
|
|
|
if (!mem)
|
|
|
|
return NULL;
|
|
|
|
|
|
|
|
external_common_icon_param_parse(&mem->icon, obj, params);
|
|
|
|
|
2009-12-08 20:37:48 -08:00
|
|
|
EINA_LIST_FOREACH(params, l, param)
|
|
|
|
{
|
|
|
|
if (!strcmp(param->name, "span"))
|
2010-04-01 07:22:41 -07:00
|
|
|
{
|
|
|
|
mem->span = param->i;
|
|
|
|
mem->span_exists = EINA_TRUE;
|
|
|
|
}
|
2009-12-08 20:37:48 -08:00
|
|
|
else if (!strcmp(param->name, "min"))
|
2010-04-01 07:22:41 -07:00
|
|
|
{
|
|
|
|
mem->min = param->d;
|
|
|
|
mem->min_exists = EINA_TRUE;
|
|
|
|
}
|
2009-12-08 20:37:48 -08:00
|
|
|
else if (!strcmp(param->name, "max"))
|
2010-04-01 07:22:41 -07:00
|
|
|
{
|
|
|
|
mem->max = param->d;
|
|
|
|
mem->max_exists = EINA_TRUE;
|
|
|
|
}
|
2009-12-08 20:37:48 -08:00
|
|
|
else if (!strcmp(param->name, "value"))
|
2010-04-01 07:22:41 -07:00
|
|
|
{
|
|
|
|
mem->value = param->d;
|
|
|
|
mem->value_exists = EINA_TRUE;
|
|
|
|
}
|
2009-12-08 20:37:48 -08:00
|
|
|
else if (!strcmp(param->name, "inverted"))
|
2010-04-01 07:22:41 -07:00
|
|
|
{
|
|
|
|
mem->inverted = param->i;
|
|
|
|
mem->inverted_exists = EINA_TRUE;
|
|
|
|
}
|
2009-12-08 20:37:48 -08:00
|
|
|
else if (!strcmp(param->name, "horizontal"))
|
2010-04-01 07:22:41 -07:00
|
|
|
{
|
|
|
|
mem->horizontal = param->i;
|
|
|
|
mem->horizontal_exists = EINA_TRUE;
|
|
|
|
}
|
2009-12-08 20:37:48 -08:00
|
|
|
else if (!strcmp(param->name, "unit format"))
|
|
|
|
mem->unit = eina_stringshare_add(param->s);
|
|
|
|
else if (!strcmp(param->name, "indicator format"))
|
|
|
|
mem->indicator = eina_stringshare_add(param->s);
|
2010-10-21 15:03:43 -07:00
|
|
|
else if (!strcmp(param->name, "label"))
|
|
|
|
mem->label = eina_stringshare_add(param->s);
|
2009-12-08 20:37:48 -08:00
|
|
|
}
|
2009-12-05 17:22:54 -08:00
|
|
|
|
|
|
|
return mem;
|
|
|
|
}
|
|
|
|
|
2010-08-01 10:29:20 -07:00
|
|
|
static Evas_Object *external_slider_content_get(void *data __UNUSED__,
|
2010-10-19 11:25:57 -07:00
|
|
|
const Evas_Object *obj __UNUSED__, const char *content __UNUSED__)
|
2010-08-01 10:29:20 -07:00
|
|
|
{
|
2010-10-20 05:40:36 -07:00
|
|
|
ERR("No content.");
|
2010-08-01 10:29:20 -07:00
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
2009-12-05 17:22:54 -08:00
|
|
|
static void
|
|
|
|
external_slider_params_free(void *params)
|
|
|
|
{
|
|
|
|
Elm_Params_Slider *mem = params;
|
|
|
|
|
|
|
|
if (mem->unit)
|
|
|
|
eina_stringshare_del(mem->unit);
|
|
|
|
if (mem->indicator)
|
|
|
|
eina_stringshare_del(mem->indicator);
|
2010-10-21 15:03:43 -07:00
|
|
|
if (mem->label)
|
|
|
|
eina_stringshare_del(mem->label);
|
|
|
|
free(params);
|
2009-12-05 17:22:54 -08:00
|
|
|
}
|
|
|
|
|
|
|
|
static Edje_External_Param_Info external_slider_params[] = {
|
|
|
|
DEFINE_EXTERNAL_COMMON_PARAMS,
|
2010-10-21 15:03:43 -07:00
|
|
|
EDJE_EXTERNAL_PARAM_INFO_STRING("label"),
|
2009-12-05 17:22:54 -08:00
|
|
|
EDJE_EXTERNAL_PARAM_INFO_STRING("icon"),
|
2009-12-08 21:22:38 -08:00
|
|
|
EDJE_EXTERNAL_PARAM_INFO_DOUBLE("min"),
|
|
|
|
EDJE_EXTERNAL_PARAM_INFO_DOUBLE_DEFAULT("max", 10.0),
|
|
|
|
EDJE_EXTERNAL_PARAM_INFO_DOUBLE("value"),
|
2009-12-08 22:53:37 -08:00
|
|
|
EDJE_EXTERNAL_PARAM_INFO_BOOL("horizontal"),
|
|
|
|
EDJE_EXTERNAL_PARAM_INFO_BOOL("inverted"),
|
2009-12-07 21:53:12 -08:00
|
|
|
EDJE_EXTERNAL_PARAM_INFO_INT("span"),
|
|
|
|
EDJE_EXTERNAL_PARAM_INFO_STRING_DEFAULT("unit format", "%1.2f"),
|
|
|
|
EDJE_EXTERNAL_PARAM_INFO_STRING_DEFAULT("indicator format", "%1.2f"),
|
2009-12-05 17:22:54 -08:00
|
|
|
EDJE_EXTERNAL_PARAM_INFO_SENTINEL
|
|
|
|
};
|
|
|
|
|
2010-01-22 12:07:47 -08:00
|
|
|
DEFINE_EXTERNAL_ICON_ADD(slider, "slider")
|
2009-12-05 17:22:54 -08:00
|
|
|
DEFINE_EXTERNAL_TYPE_SIMPLE(slider, "Slider")
|