2013-04-25 22:13:00 -07:00
|
|
|
#ifdef HAVE_CONFIG_H
|
|
|
|
# include "elementary_config.h"
|
|
|
|
#endif
|
|
|
|
|
2011-11-29 06:03:14 -08:00
|
|
|
#include <fnmatch.h>
|
2013-04-25 22:13:00 -07:00
|
|
|
|
2009-02-09 03:23:59 -08:00
|
|
|
#include <Elementary.h>
|
2010-09-27 11:18:37 -07:00
|
|
|
#include <Elementary_Cursor.h>
|
2013-04-25 22:13:00 -07:00
|
|
|
|
2009-02-09 03:23:59 -08:00
|
|
|
#include "elm_priv.h"
|
2012-07-31 15:06:06 -07:00
|
|
|
#include "elm_widget_genlist.h"
|
2012-11-25 22:32:53 -08:00
|
|
|
#include "elm_interface_scrollable.h"
|
|
|
|
|
|
|
|
EAPI Eo_Op ELM_OBJ_GENLIST_PAN_BASE_ID = EO_NOOP;
|
|
|
|
|
|
|
|
#define MY_PAN_CLASS ELM_OBJ_GENLIST_PAN_CLASS
|
|
|
|
|
2013-11-07 06:29:38 -08:00
|
|
|
#define MY_PAN_CLASS_NAME "Elm_Genlist_Pan"
|
|
|
|
#define MY_PAN_CLASS_NAME_LEGACY "elm_genlist_pan"
|
2012-11-25 22:32:53 -08:00
|
|
|
|
|
|
|
EAPI Eo_Op ELM_OBJ_GENLIST_BASE_ID = EO_NOOP;
|
|
|
|
|
|
|
|
#define MY_CLASS ELM_OBJ_GENLIST_CLASS
|
|
|
|
|
2013-11-07 03:44:22 -08:00
|
|
|
#define MY_CLASS_NAME "Elm_Genlist"
|
|
|
|
#define MY_CLASS_NAME_LEGACY "elm_genlist"
|
2009-02-09 03:23:59 -08:00
|
|
|
|
2012-03-05 21:02:36 -08:00
|
|
|
// internally allocated
|
2012-07-16 14:56:30 -07:00
|
|
|
#define CLASS_ALLOCATED 0x3a70f11f
|
2012-03-05 21:02:36 -08:00
|
|
|
|
2010-11-17 09:15:28 -08:00
|
|
|
#define MAX_ITEMS_PER_BLOCK 32
|
2011-06-01 20:10:11 -07:00
|
|
|
#define REORDER_EFFECT_TIME 0.5
|
2013-03-26 10:33:01 -07:00
|
|
|
#define MULTI_DOWN_TIME 1.0
|
|
|
|
#define SWIPE_TIME 0.4
|
|
|
|
#define SCR_HOLD_TIME 0.1
|
2010-10-15 04:24:46 -07:00
|
|
|
|
2013-05-07 03:41:15 -07:00
|
|
|
#define ERR_ABORT(_msg) \
|
|
|
|
do { \
|
|
|
|
ERR(_msg); \
|
|
|
|
if (getenv("ELM_ERROR_ABORT")) abort(); \
|
|
|
|
} while (0)
|
2012-07-16 14:56:30 -07:00
|
|
|
|
2013-07-14 19:13:24 -07:00
|
|
|
#define ELM_PRIV_GENLIST_SIGNALS(cmd) \
|
|
|
|
cmd(SIG_ACTIVATED, "activated", "") \
|
|
|
|
cmd(SIG_CLICKED_DOUBLE, "clicked,double", "") \
|
|
|
|
cmd(SIG_SELECTED, "selected", "") \
|
|
|
|
cmd(SIG_UNSELECTED, "unselected", "") \
|
|
|
|
cmd(SIG_EXPANDED, "expanded", "") \
|
|
|
|
cmd(SIG_CONTRACTED, "contracted", "") \
|
|
|
|
cmd(SIG_EXPAND_REQUEST, "expand,request", "") \
|
|
|
|
cmd(SIG_CONTRACT_REQUEST, "contract,request", "") \
|
|
|
|
cmd(SIG_REALIZED, "realized", "") \
|
|
|
|
cmd(SIG_UNREALIZED, "unrealized", "") \
|
|
|
|
cmd(SIG_DRAG_START_UP, "drag,start,up", "") \
|
|
|
|
cmd(SIG_DRAG_START_DOWN, "drag,start,down", "") \
|
|
|
|
cmd(SIG_DRAG_START_LEFT, "drag,start,left", "") \
|
|
|
|
cmd(SIG_DRAG_START_RIGHT, "drag,start,right", "") \
|
|
|
|
cmd(SIG_DRAG_STOP, "drag,stop", "") \
|
|
|
|
cmd(SIG_DRAG, "drag", "") \
|
|
|
|
cmd(SIG_LONGPRESSED, "longpressed", "") \
|
|
|
|
cmd(SIG_SCROLL_ANIM_START, "scroll,anim,start", "") \
|
|
|
|
cmd(SIG_SCROLL_ANIM_STOP, "scroll,anim,stop", "") \
|
|
|
|
cmd(SIG_SCROLL_DRAG_START, "scroll,drag,start", "") \
|
|
|
|
cmd(SIG_SCROLL_DRAG_STOP, "scroll,drag,stop", "") \
|
|
|
|
cmd(SIG_EDGE_TOP, "edge,top", "") \
|
|
|
|
cmd(SIG_EDGE_BOTTOM, "edge,bottom", "") \
|
|
|
|
cmd(SIG_EDGE_LEFT, "edge,left", "") \
|
|
|
|
cmd(SIG_EDGE_RIGHT, "edge,right", "") \
|
|
|
|
cmd(SIG_VBAR_DRAG, "vbar,drag", "") \
|
|
|
|
cmd(SIG_VBAR_PRESS, "vbar,press", "") \
|
|
|
|
cmd(SIG_VBAR_UNPRESS, "vbar,unpress", "") \
|
|
|
|
cmd(SIG_HBAR_DRAG, "hbar,drag", "") \
|
|
|
|
cmd(SIG_HBAR_PRESS, "hbar,press", "") \
|
|
|
|
cmd(SIG_HBAR_UNPRESS, "hbar,unpress", "") \
|
|
|
|
cmd(SIG_MULTI_SWIPE_LEFT, "multi,swipe,left", "") \
|
|
|
|
cmd(SIG_MULTI_SWIPE_RIGHT, "multi,swipe,right", "") \
|
|
|
|
cmd(SIG_MULTI_SWIPE_UP, "multi,swipe,up", "") \
|
|
|
|
cmd(SIG_MULTI_SWIPE_DOWN, "multi,swipe,down", "") \
|
|
|
|
cmd(SIG_MULTI_PINCH_OUT, "multi,pinch,out", "") \
|
|
|
|
cmd(SIG_MULTI_PINCH_IN, "multi,pinch,in", "") \
|
|
|
|
cmd(SIG_SWIPE, "swipe", "") \
|
|
|
|
cmd(SIG_MOVED, "moved", "") \
|
|
|
|
cmd(SIG_MOVED_AFTER, "moved,after", "") \
|
|
|
|
cmd(SIG_MOVED_BEFORE, "moved,before", "") \
|
|
|
|
cmd(SIG_INDEX_UPDATE, "index,update", "") \
|
|
|
|
cmd(SIG_TREE_EFFECT_FINISHED , "tree,effect,finished", "") \
|
|
|
|
cmd(SIG_HIGHLIGHTED, "highlighted", "") \
|
|
|
|
cmd(SIG_UNHIGHLIGHTED, "unhighlighted", "") \
|
2014-03-08 08:04:34 -08:00
|
|
|
cmd(SIG_ITEM_FOCUSED, "item,focused", "") \
|
|
|
|
cmd(SIG_ITEM_UNFOCUSED, "item,unfocused", "") \
|
2013-07-14 19:13:24 -07:00
|
|
|
cmd(SIG_PRESSED, "pressed", "") \
|
|
|
|
cmd(SIG_RELEASED, "released", "")
|
|
|
|
|
|
|
|
ELM_PRIV_GENLIST_SIGNALS(ELM_PRIV_STATIC_VARIABLE_DECLARE);
|
2011-05-06 17:30:39 -07:00
|
|
|
|
2012-07-16 14:56:30 -07:00
|
|
|
static const Evas_Smart_Cb_Description _smart_callbacks[] = {
|
2013-07-14 19:13:24 -07:00
|
|
|
ELM_PRIV_GENLIST_SIGNALS(ELM_PRIV_SMART_CALLBACKS_DESC)
|
2014-01-23 02:30:34 -08:00
|
|
|
{SIG_WIDGET_LANG_CHANGED, ""}, /**< handled by elm_widget */
|
2014-02-07 21:05:06 -08:00
|
|
|
{SIG_WIDGET_ACCESS_CHANGED, ""}, /**< handled by elm_widget */
|
2014-02-05 23:18:57 -08:00
|
|
|
{SIG_LAYOUT_FOCUSED, ""}, /**< handled by elm_layout */
|
|
|
|
{SIG_LAYOUT_UNFOCUSED, ""}, /**< handled by elm_layout */
|
2014-03-08 08:04:34 -08:00
|
|
|
{SIG_ITEM_FOCUSED, ""},
|
|
|
|
{SIG_ITEM_UNFOCUSED, ""},
|
2013-03-20 09:39:51 -07:00
|
|
|
|
2011-05-06 17:30:39 -07:00
|
|
|
{NULL, NULL}
|
|
|
|
};
|
2013-07-14 19:13:24 -07:00
|
|
|
#undef ELM_PRIV_GENLIST_SIGNALS
|
2011-05-06 17:30:39 -07:00
|
|
|
|
2012-07-16 14:56:30 -07:00
|
|
|
static void _calc_job(void *);
|
|
|
|
static Eina_Bool _item_block_recalc(Item_Block *, int, Eina_Bool);
|
|
|
|
static void _item_mouse_callbacks_add(Elm_Gen_Item *, Evas_Object *);
|
|
|
|
static void _item_mouse_callbacks_del(Elm_Gen_Item *, Evas_Object *);
|
2014-01-06 06:30:02 -08:00
|
|
|
static void _access_activate_cb(void *data EINA_UNUSED,
|
|
|
|
Evas_Object *part_obj EINA_UNUSED,
|
2013-01-03 01:31:33 -08:00
|
|
|
Elm_Object_Item *item);
|
2013-11-29 02:18:00 -08:00
|
|
|
static void _decorate_item_set(Elm_Gen_Item *);
|
2012-07-16 14:56:30 -07:00
|
|
|
|
|
|
|
static void
|
2012-11-25 22:32:53 -08:00
|
|
|
_elm_genlist_pan_smart_pos_set(Eo *obj, void *_pd, va_list *list)
|
2010-10-01 12:03:12 -07:00
|
|
|
{
|
2012-11-25 22:32:53 -08:00
|
|
|
Evas_Coord x = va_arg(*list, Evas_Coord);
|
|
|
|
Evas_Coord y = va_arg(*list, Evas_Coord);
|
2012-07-16 14:56:30 -07:00
|
|
|
Item_Block *itb;
|
2010-10-01 12:03:12 -07:00
|
|
|
|
2012-11-25 22:32:53 -08:00
|
|
|
Elm_Genlist_Pan_Smart_Data *psd = _pd;
|
2014-03-08 11:09:22 -08:00
|
|
|
Elm_Genlist_Smart_Data *sd = psd->wsd;
|
2010-10-01 12:03:12 -07:00
|
|
|
|
2014-03-08 11:09:22 -08:00
|
|
|
if ((x == sd->pan_x) && (y == sd->pan_y)) return;
|
|
|
|
sd->pan_x = x;
|
|
|
|
sd->pan_y = y;
|
2010-10-01 12:03:12 -07:00
|
|
|
|
2014-03-08 11:09:22 -08:00
|
|
|
EINA_INLIST_FOREACH(sd->blocks, itb)
|
2010-10-01 12:03:12 -07:00
|
|
|
{
|
2012-07-16 14:56:30 -07:00
|
|
|
if ((itb->y + itb->h) > y)
|
2010-10-05 12:09:55 -07:00
|
|
|
{
|
2012-07-16 14:56:30 -07:00
|
|
|
Elm_Gen_Item *it;
|
|
|
|
Eina_List *l2;
|
|
|
|
|
2012-10-01 00:36:27 -07:00
|
|
|
EINA_LIST_FOREACH(itb->items, l2, it)
|
2012-07-16 14:56:30 -07:00
|
|
|
{
|
|
|
|
if ((itb->y + it->y) >= y)
|
|
|
|
{
|
2014-03-08 11:09:22 -08:00
|
|
|
sd->anchor_item = it;
|
|
|
|
sd->anchor_y = -(itb->y + it->y - y);
|
2012-07-16 14:56:30 -07:00
|
|
|
goto done;
|
|
|
|
}
|
|
|
|
}
|
2010-10-05 12:09:55 -07:00
|
|
|
}
|
2010-10-01 12:03:12 -07:00
|
|
|
}
|
2012-07-16 14:56:30 -07:00
|
|
|
done:
|
2014-03-08 11:09:22 -08:00
|
|
|
if (!sd->reorder_move_animator) evas_object_smart_changed(obj);
|
2010-10-01 12:03:12 -07:00
|
|
|
}
|
|
|
|
|
2012-07-16 14:56:30 -07:00
|
|
|
static void
|
2012-11-25 22:32:53 -08:00
|
|
|
_elm_genlist_pan_smart_pos_get(Eo *obj EINA_UNUSED, void *_pd, va_list *list)
|
2010-10-27 07:38:54 -07:00
|
|
|
{
|
2012-11-25 22:32:53 -08:00
|
|
|
Evas_Coord *x = va_arg(*list, Evas_Coord *);
|
|
|
|
Evas_Coord *y = va_arg(*list, Evas_Coord *);
|
|
|
|
Elm_Genlist_Pan_Smart_Data *psd = _pd;
|
2010-10-27 07:38:54 -07:00
|
|
|
|
2012-07-16 14:56:30 -07:00
|
|
|
if (x) *x = psd->wsd->pan_x;
|
|
|
|
if (y) *y = psd->wsd->pan_y;
|
2010-10-27 07:38:54 -07:00
|
|
|
}
|
|
|
|
|
2012-07-16 14:56:30 -07:00
|
|
|
static void
|
2012-11-25 22:32:53 -08:00
|
|
|
_elm_genlist_pan_smart_pos_max_get(Eo *obj, void *_pd, va_list *list)
|
2010-10-05 12:09:55 -07:00
|
|
|
{
|
2012-07-16 14:56:30 -07:00
|
|
|
Evas_Coord ow, oh;
|
2012-11-25 22:32:53 -08:00
|
|
|
Evas_Coord *x = va_arg(*list, Evas_Coord *);
|
|
|
|
Evas_Coord *y = va_arg(*list, Evas_Coord *);
|
2010-10-05 12:09:55 -07:00
|
|
|
|
2012-11-25 22:32:53 -08:00
|
|
|
Elm_Genlist_Pan_Smart_Data *psd = _pd;
|
2010-10-05 12:09:55 -07:00
|
|
|
|
2012-07-16 14:56:30 -07:00
|
|
|
evas_object_geometry_get(obj, NULL, NULL, &ow, &oh);
|
|
|
|
ow = psd->wsd->minw - ow;
|
|
|
|
if (ow < 0) ow = 0;
|
|
|
|
oh = psd->wsd->minh - oh;
|
|
|
|
if (oh < 0) oh = 0;
|
|
|
|
if (x) *x = ow;
|
|
|
|
if (y) *y = oh;
|
2010-10-05 12:09:55 -07:00
|
|
|
}
|
|
|
|
|
2012-07-16 14:56:30 -07:00
|
|
|
static void
|
2012-11-25 22:32:53 -08:00
|
|
|
_elm_genlist_pan_smart_pos_min_get(Eo *obj EINA_UNUSED, void *_pd EINA_UNUSED, va_list *list)
|
2010-10-05 12:09:55 -07:00
|
|
|
{
|
2012-11-25 22:32:53 -08:00
|
|
|
Evas_Coord *x = va_arg(*list, Evas_Coord *);
|
|
|
|
Evas_Coord *y = va_arg(*list, Evas_Coord *);
|
2012-07-16 14:56:30 -07:00
|
|
|
if (x) *x = 0;
|
|
|
|
if (y) *y = 0;
|
2010-10-05 12:09:55 -07:00
|
|
|
}
|
|
|
|
|
2012-07-16 14:56:30 -07:00
|
|
|
static void
|
2012-11-25 22:32:53 -08:00
|
|
|
_elm_genlist_pan_smart_content_size_get(Eo *obj EINA_UNUSED, void *_pd, va_list *list)
|
2010-10-05 12:09:55 -07:00
|
|
|
{
|
2012-11-25 22:32:53 -08:00
|
|
|
Evas_Coord *w = va_arg(*list, Evas_Coord *);
|
|
|
|
Evas_Coord *h = va_arg(*list, Evas_Coord *);
|
|
|
|
Elm_Genlist_Pan_Smart_Data *psd = _pd;
|
2010-10-05 12:09:55 -07:00
|
|
|
|
2012-07-16 14:56:30 -07:00
|
|
|
if (w) *w = psd->wsd->minw;
|
|
|
|
if (h) *h = psd->wsd->minh;
|
2010-10-05 12:09:55 -07:00
|
|
|
}
|
|
|
|
|
2012-07-16 14:56:30 -07:00
|
|
|
static void
|
2012-11-25 22:32:53 -08:00
|
|
|
_elm_genlist_pan_smart_del(Eo *obj, void *_pd, va_list *list EINA_UNUSED)
|
2010-10-05 12:09:55 -07:00
|
|
|
{
|
2012-11-25 22:32:53 -08:00
|
|
|
Elm_Genlist_Pan_Smart_Data *psd = _pd;
|
2012-07-16 14:56:30 -07:00
|
|
|
|
2014-01-21 06:16:41 -08:00
|
|
|
ecore_job_del(psd->resize_job);
|
2010-10-01 12:03:12 -07:00
|
|
|
|
2013-03-19 03:48:36 -07:00
|
|
|
eo_do_super(obj, MY_PAN_CLASS, evas_obj_smart_del());
|
2009-02-09 03:23:59 -08:00
|
|
|
}
|
|
|
|
|
2009-11-13 14:22:05 -08:00
|
|
|
static void
|
2012-11-25 22:32:53 -08:00
|
|
|
_elm_genlist_pan_smart_move(Eo *obj, void *_pd, va_list *list)
|
2009-11-13 14:22:05 -08:00
|
|
|
{
|
2012-11-25 22:32:53 -08:00
|
|
|
Elm_Genlist_Pan_Smart_Data *psd = _pd;
|
|
|
|
va_arg(*list, Evas_Coord);
|
|
|
|
va_arg(*list, Evas_Coord);
|
2009-11-13 14:22:05 -08:00
|
|
|
|
2012-07-16 14:56:30 -07:00
|
|
|
psd->wsd->pan_changed = EINA_TRUE;
|
|
|
|
evas_object_smart_changed(obj);
|
2013-05-29 04:54:11 -07:00
|
|
|
ELM_SAFE_FREE(psd->wsd->calc_job, ecore_job_del);
|
2011-02-08 04:08:28 -08:00
|
|
|
}
|
|
|
|
|
2009-02-09 03:23:59 -08:00
|
|
|
static void
|
2012-07-16 14:56:30 -07:00
|
|
|
_elm_genlist_pan_smart_resize_job(void *data)
|
2009-02-09 03:23:59 -08:00
|
|
|
{
|
2013-04-24 04:41:37 -07:00
|
|
|
ELM_GENLIST_PAN_DATA_GET(data, psd);
|
2010-10-15 04:51:15 -07:00
|
|
|
|
2012-11-25 22:32:53 -08:00
|
|
|
elm_layout_sizing_eval(psd->wobj);
|
2012-07-16 14:56:30 -07:00
|
|
|
psd->resize_job = NULL;
|
2009-02-09 03:23:59 -08:00
|
|
|
}
|
|
|
|
|
2011-02-13 02:28:55 -08:00
|
|
|
static void
|
2012-11-25 22:32:53 -08:00
|
|
|
_elm_genlist_pan_smart_resize(Eo *obj, void *_pd, va_list *list)
|
2011-02-13 02:28:55 -08:00
|
|
|
{
|
2012-07-16 14:56:30 -07:00
|
|
|
Evas_Coord ow, oh;
|
2012-11-25 22:32:53 -08:00
|
|
|
Evas_Coord w = va_arg(*list, Evas_Coord);
|
|
|
|
Evas_Coord h = va_arg(*list, Evas_Coord);
|
2009-02-09 03:23:59 -08:00
|
|
|
|
2012-11-25 22:32:53 -08:00
|
|
|
Elm_Genlist_Pan_Smart_Data *psd = _pd;
|
2014-03-08 11:09:22 -08:00
|
|
|
Elm_Genlist_Smart_Data *sd = psd->wsd;
|
2012-07-16 14:56:30 -07:00
|
|
|
|
|
|
|
evas_object_geometry_get(obj, NULL, NULL, &ow, &oh);
|
|
|
|
if ((ow == w) && (oh == h)) return;
|
2014-03-08 11:09:22 -08:00
|
|
|
if ((sd->mode == ELM_LIST_COMPRESS) && (ow != w))
|
2012-07-16 14:56:30 -07:00
|
|
|
{
|
|
|
|
/* fix me later */
|
2014-01-21 06:16:41 -08:00
|
|
|
ecore_job_del(psd->resize_job);
|
2012-07-16 14:56:30 -07:00
|
|
|
psd->resize_job =
|
2013-04-24 04:41:37 -07:00
|
|
|
ecore_job_add(_elm_genlist_pan_smart_resize_job, obj);
|
2012-07-16 14:56:30 -07:00
|
|
|
}
|
2014-03-08 11:09:22 -08:00
|
|
|
sd->pan_changed = EINA_TRUE;
|
2012-07-16 14:56:30 -07:00
|
|
|
evas_object_smart_changed(obj);
|
2014-03-08 11:09:22 -08:00
|
|
|
ecore_job_del(sd->calc_job);
|
2013-05-02 10:12:52 -07:00
|
|
|
// if the width changed we may have to resize content if scrollbar went
|
|
|
|
// away or appeared to queue a job to deal with it. it should settle in
|
2012-08-03 05:49:37 -07:00
|
|
|
// the end to a steady-state
|
|
|
|
if (ow != w)
|
2014-03-08 11:09:22 -08:00
|
|
|
sd->calc_job = ecore_job_add(_calc_job, psd->wobj);
|
2012-08-03 05:49:37 -07:00
|
|
|
else
|
2014-03-08 11:09:22 -08:00
|
|
|
sd->calc_job = NULL;
|
2011-10-19 07:17:14 -07:00
|
|
|
}
|
|
|
|
|
2009-02-09 03:23:59 -08:00
|
|
|
static void
|
2012-07-16 14:56:30 -07:00
|
|
|
_item_scroll(Elm_Genlist_Smart_Data *sd)
|
2009-02-09 03:23:59 -08:00
|
|
|
{
|
2012-07-16 14:56:30 -07:00
|
|
|
Evas_Coord gith = 0;
|
|
|
|
Elm_Gen_Item *it = NULL;
|
|
|
|
Evas_Coord ow, oh, dx = 0, dy = 0, dw = 0, dh = 0;
|
2012-03-15 04:18:17 -07:00
|
|
|
|
2012-07-16 14:56:30 -07:00
|
|
|
if (!sd->show_item) return;
|
2012-03-15 04:18:17 -07:00
|
|
|
|
2012-07-16 14:56:30 -07:00
|
|
|
evas_object_geometry_get(sd->pan_obj, NULL, NULL, &ow, &oh);
|
|
|
|
it = sd->show_item;
|
|
|
|
dx = it->x + it->item->block->x;
|
|
|
|
dy = it->y + it->item->block->y;
|
|
|
|
dw = it->item->block->w;
|
|
|
|
dh = oh;
|
2012-03-15 04:18:17 -07:00
|
|
|
|
2012-07-16 14:56:30 -07:00
|
|
|
switch (sd->scroll_to_type)
|
2010-11-20 00:43:43 -08:00
|
|
|
{
|
2012-07-16 14:56:30 -07:00
|
|
|
case ELM_GENLIST_ITEM_SCROLLTO_TOP:
|
|
|
|
if (it->item->group_item) gith = it->item->group_item->item->h;
|
|
|
|
dy -= gith;
|
|
|
|
break;
|
2010-12-07 11:18:14 -08:00
|
|
|
|
2012-07-16 14:56:30 -07:00
|
|
|
case ELM_GENLIST_ITEM_SCROLLTO_MIDDLE:
|
|
|
|
dy += ((it->item->h / 2) - (oh / 2));
|
|
|
|
break;
|
2010-12-07 11:18:14 -08:00
|
|
|
|
2012-07-16 14:56:30 -07:00
|
|
|
case ELM_GENLIST_ITEM_SCROLLTO_IN:
|
|
|
|
default:
|
|
|
|
if ((sd->expanded_item) &&
|
|
|
|
((sd->show_item->y + sd->show_item->item->block->y
|
|
|
|
+ sd->show_item->item->h) -
|
|
|
|
(sd->expanded_item->y + sd->expanded_item->item->block->y) > oh))
|
|
|
|
{
|
|
|
|
it = sd->expanded_item;
|
|
|
|
if (it->item->group_item) gith = it->item->group_item->item->h;
|
|
|
|
dx = it->x + it->item->block->x;
|
|
|
|
dy = it->y + it->item->block->y - gith;
|
|
|
|
dw = it->item->block->w;
|
2010-12-07 11:18:14 -08:00
|
|
|
}
|
2012-07-16 14:56:30 -07:00
|
|
|
else
|
|
|
|
{
|
|
|
|
if ((it->item->group_item) &&
|
|
|
|
(sd->pan_y > (it->y + it->item->block->y)))
|
|
|
|
gith = it->item->group_item->item->h;
|
|
|
|
dy -= gith;
|
|
|
|
dh = it->item->h;
|
|
|
|
}
|
|
|
|
break;
|
2010-05-07 06:21:45 -07:00
|
|
|
}
|
2012-07-16 14:56:30 -07:00
|
|
|
if (sd->bring_in)
|
2014-03-17 04:44:40 -07:00
|
|
|
eo_do(sd->obj, elm_interface_scrollable_region_bring_in(dx, dy, dw, dh));
|
2010-09-28 01:46:08 -07:00
|
|
|
else
|
2014-03-17 04:44:40 -07:00
|
|
|
eo_do(sd->obj, elm_interface_scrollable_content_region_show
|
2012-11-25 22:32:53 -08:00
|
|
|
(dx, dy, dw, dh));
|
2012-03-15 04:18:17 -07:00
|
|
|
|
2012-07-16 14:56:30 -07:00
|
|
|
it->item->show_me = EINA_FALSE;
|
|
|
|
sd->show_item = NULL;
|
|
|
|
sd->auto_scroll_enabled = EINA_FALSE;
|
|
|
|
sd->check_scroll = EINA_FALSE;
|
2009-02-09 03:23:59 -08:00
|
|
|
}
|
|
|
|
|
2011-04-06 07:46:39 -07:00
|
|
|
static void
|
2012-07-16 14:56:30 -07:00
|
|
|
_elm_genlist_item_unrealize(Elm_Gen_Item *it,
|
|
|
|
Eina_Bool calc)
|
2011-04-06 07:46:39 -07:00
|
|
|
{
|
2012-07-16 14:56:30 -07:00
|
|
|
Evas_Object *content;
|
2012-07-25 22:50:31 -07:00
|
|
|
Eina_List *l;
|
|
|
|
const char *part;
|
2011-04-06 07:46:39 -07:00
|
|
|
|
2012-07-16 14:56:30 -07:00
|
|
|
if (!it->realized) return;
|
|
|
|
if (GL_IT(it)->wsd->reorder_it == it) return;
|
2009-02-16 23:50:35 -08:00
|
|
|
|
2012-07-16 14:56:30 -07:00
|
|
|
evas_event_freeze(evas_object_evas_get(WIDGET(it)));
|
|
|
|
if (!calc)
|
|
|
|
evas_object_smart_callback_call(WIDGET(it), SIG_UNREALIZED, it);
|
2013-05-29 04:54:11 -07:00
|
|
|
ELM_SAFE_FREE(it->long_timer, ecore_timer_del);
|
2011-12-26 06:30:21 -08:00
|
|
|
|
2012-07-25 22:50:31 -07:00
|
|
|
EINA_LIST_FOREACH(it->texts, l, part)
|
|
|
|
edje_object_part_text_set(VIEW(it), part, NULL);
|
|
|
|
|
2013-05-29 04:54:11 -07:00
|
|
|
ELM_SAFE_FREE(it->texts, elm_widget_stringlist_free);
|
|
|
|
ELM_SAFE_FREE(it->contents, elm_widget_stringlist_free);
|
|
|
|
ELM_SAFE_FREE(it->states, elm_widget_stringlist_free);
|
2013-05-21 10:24:02 -07:00
|
|
|
|
2013-03-08 20:23:42 -08:00
|
|
|
EINA_LIST_FREE(it->content_objs, content)
|
2012-07-16 14:56:30 -07:00
|
|
|
evas_object_del(content);
|
2011-12-26 06:30:21 -08:00
|
|
|
|
2013-05-29 04:54:11 -07:00
|
|
|
ELM_SAFE_FREE(it->item_focus_chain, eina_list_free);
|
2013-02-20 02:00:49 -08:00
|
|
|
|
2013-09-13 00:20:40 -07:00
|
|
|
elm_widget_item_track_cancel(it);
|
|
|
|
|
2012-07-16 14:56:30 -07:00
|
|
|
it->unrealize_cb(it);
|
2011-12-26 06:30:21 -08:00
|
|
|
|
2012-07-16 14:56:30 -07:00
|
|
|
it->realized = EINA_FALSE;
|
|
|
|
it->want_unrealize = EINA_FALSE;
|
2013-09-12 22:19:41 -07:00
|
|
|
|
2012-07-16 14:56:30 -07:00
|
|
|
evas_event_thaw(evas_object_evas_get(WIDGET(it)));
|
|
|
|
evas_event_thaw_eval(evas_object_evas_get(WIDGET(it)));
|
2011-12-26 06:30:21 -08:00
|
|
|
}
|
|
|
|
|
2012-05-29 02:04:16 -07:00
|
|
|
static void
|
2012-07-16 14:56:30 -07:00
|
|
|
_item_block_unrealize(Item_Block *itb)
|
2012-05-29 02:04:16 -07:00
|
|
|
{
|
2012-07-16 14:56:30 -07:00
|
|
|
Elm_Gen_Item *it;
|
|
|
|
const Eina_List *l;
|
|
|
|
Eina_Bool dragging = EINA_FALSE;
|
2012-05-29 02:04:16 -07:00
|
|
|
|
2012-07-16 14:56:30 -07:00
|
|
|
if (!itb->realized) return;
|
2012-11-25 22:32:53 -08:00
|
|
|
evas_event_freeze(evas_object_evas_get((itb->sd)->obj));
|
2010-03-02 00:47:40 -08:00
|
|
|
|
2012-10-01 00:36:27 -07:00
|
|
|
EINA_LIST_FOREACH(itb->items, l, it)
|
2010-03-02 00:47:40 -08:00
|
|
|
{
|
2012-07-16 14:56:30 -07:00
|
|
|
if (itb->must_recalc || !it->group)
|
2010-10-15 04:51:15 -07:00
|
|
|
{
|
2012-07-16 14:56:30 -07:00
|
|
|
if (it->dragging)
|
2010-10-15 04:51:15 -07:00
|
|
|
{
|
2012-07-16 14:56:30 -07:00
|
|
|
dragging = EINA_TRUE;
|
|
|
|
it->want_unrealize = EINA_TRUE;
|
2010-10-15 04:51:15 -07:00
|
|
|
}
|
2012-07-16 14:56:30 -07:00
|
|
|
else
|
|
|
|
_elm_genlist_item_unrealize(it, EINA_FALSE);
|
2010-10-15 04:51:15 -07:00
|
|
|
}
|
2010-03-02 00:47:40 -08:00
|
|
|
}
|
2012-07-16 14:56:30 -07:00
|
|
|
if (!dragging)
|
2012-05-09 23:30:49 -07:00
|
|
|
{
|
2012-07-16 14:56:30 -07:00
|
|
|
itb->realized = EINA_FALSE;
|
|
|
|
itb->want_unrealize = EINA_TRUE;
|
2012-05-09 23:30:49 -07:00
|
|
|
}
|
2012-07-16 14:56:30 -07:00
|
|
|
else
|
|
|
|
itb->want_unrealize = EINA_FALSE;
|
2012-11-25 22:32:53 -08:00
|
|
|
evas_event_thaw(evas_object_evas_get((itb->sd)->obj));
|
|
|
|
evas_event_thaw_eval(evas_object_evas_get((itb->sd)->obj));
|
2010-03-02 00:47:40 -08:00
|
|
|
}
|
|
|
|
|
2012-07-16 14:56:30 -07:00
|
|
|
static Eina_Bool
|
|
|
|
_must_recalc_idler(void *data)
|
2012-03-07 04:15:36 -08:00
|
|
|
{
|
2013-04-24 04:41:37 -07:00
|
|
|
ELM_GENLIST_DATA_GET(data, sd);
|
2012-03-07 04:15:36 -08:00
|
|
|
|
2014-01-21 06:16:41 -08:00
|
|
|
ecore_job_del(sd->calc_job);
|
2013-04-24 04:41:37 -07:00
|
|
|
sd->calc_job = ecore_job_add(_calc_job, data);
|
2012-07-16 14:56:30 -07:00
|
|
|
sd->must_recalc_idler = NULL;
|
|
|
|
return ECORE_CALLBACK_CANCEL;
|
2012-03-07 04:15:36 -08:00
|
|
|
}
|
|
|
|
|
2010-03-02 00:47:40 -08:00
|
|
|
static void
|
2012-07-16 14:56:30 -07:00
|
|
|
_calc_job(void *data)
|
2010-03-02 00:47:40 -08:00
|
|
|
{
|
2012-07-16 14:56:30 -07:00
|
|
|
int in = 0;
|
|
|
|
Item_Block *itb, *chb = NULL;
|
|
|
|
Evas_Coord pan_w = 0, pan_h = 0;
|
2013-04-24 04:41:37 -07:00
|
|
|
ELM_GENLIST_DATA_GET(data, sd);
|
2012-07-16 14:56:30 -07:00
|
|
|
Eina_Bool minw_change = EINA_FALSE;
|
|
|
|
Eina_Bool did_must_recalc = EINA_FALSE;
|
2012-08-15 02:52:26 -07:00
|
|
|
Evas_Coord minw = -1, minh = 0, y = 0, ow, dy = 0, vw = 0;
|
2011-05-29 19:31:21 -07:00
|
|
|
|
2012-07-16 14:56:30 -07:00
|
|
|
evas_object_geometry_get(sd->pan_obj, NULL, NULL, &ow, &sd->h);
|
2012-08-15 02:52:26 -07:00
|
|
|
if (sd->mode == ELM_LIST_COMPRESS)
|
2014-03-17 04:44:40 -07:00
|
|
|
eo_do(sd->obj, elm_interface_scrollable_content_viewport_size_get
|
2012-11-25 22:32:53 -08:00
|
|
|
(&vw, NULL));
|
2012-08-15 02:52:26 -07:00
|
|
|
|
2012-08-03 05:49:37 -07:00
|
|
|
if (sd->w != ow) sd->w = ow;
|
2012-07-16 14:56:30 -07:00
|
|
|
|
2012-11-25 22:32:53 -08:00
|
|
|
evas_event_freeze(evas_object_evas_get(sd->obj));
|
2012-10-01 00:36:27 -07:00
|
|
|
EINA_INLIST_FOREACH(sd->blocks, itb)
|
2010-11-24 23:07:39 -08:00
|
|
|
{
|
2012-07-16 14:56:30 -07:00
|
|
|
Eina_Bool show_me = EINA_FALSE;
|
|
|
|
|
|
|
|
itb->num = in;
|
|
|
|
show_me = itb->show_me;
|
|
|
|
itb->show_me = EINA_FALSE;
|
|
|
|
if (chb)
|
|
|
|
{
|
|
|
|
if (itb->realized) _item_block_unrealize(itb);
|
|
|
|
}
|
|
|
|
if ((itb->changed) || ((itb->must_recalc) && (!did_must_recalc)))
|
|
|
|
{
|
|
|
|
if (itb->must_recalc)
|
|
|
|
{
|
|
|
|
Eina_List *l;
|
|
|
|
Elm_Gen_Item *it;
|
|
|
|
|
2012-10-01 00:36:27 -07:00
|
|
|
EINA_LIST_FOREACH(itb->items, l, it)
|
2012-07-16 14:56:30 -07:00
|
|
|
if (it->item->mincalcd) it->item->mincalcd = EINA_FALSE;
|
|
|
|
itb->changed = EINA_TRUE;
|
|
|
|
if (itb->must_recalc) did_must_recalc = EINA_TRUE;
|
|
|
|
if (itb->realized) _item_block_unrealize(itb);
|
|
|
|
itb->must_recalc = EINA_FALSE;
|
|
|
|
}
|
|
|
|
show_me = _item_block_recalc(itb, in, EINA_FALSE);
|
|
|
|
chb = itb;
|
|
|
|
}
|
|
|
|
itb->y = y;
|
|
|
|
itb->x = 0;
|
|
|
|
minh += itb->minh;
|
|
|
|
if (minw == -1) minw = itb->minw;
|
|
|
|
else if ((!itb->must_recalc) && (minw < itb->minw))
|
|
|
|
{
|
|
|
|
minw = itb->minw;
|
|
|
|
minw_change = EINA_TRUE;
|
|
|
|
}
|
2012-08-15 02:52:26 -07:00
|
|
|
if ((sd->mode == ELM_LIST_COMPRESS) && (minw > vw))
|
2012-07-16 14:56:30 -07:00
|
|
|
{
|
|
|
|
minw = vw;
|
|
|
|
minw_change = EINA_TRUE;
|
|
|
|
}
|
|
|
|
itb->w = minw;
|
|
|
|
itb->h = itb->minh;
|
|
|
|
y += itb->h;
|
|
|
|
in += itb->count;
|
|
|
|
if ((show_me) && (sd->show_item) && (!sd->show_item->item->queued))
|
|
|
|
sd->check_scroll = EINA_TRUE;
|
2010-11-24 23:07:39 -08:00
|
|
|
}
|
2012-07-16 14:56:30 -07:00
|
|
|
if (minw_change)
|
2012-04-20 03:50:42 -07:00
|
|
|
{
|
2012-08-14 03:13:19 -07:00
|
|
|
EINA_INLIST_FOREACH(sd->blocks, itb)
|
2012-04-20 03:50:42 -07:00
|
|
|
{
|
2012-07-16 14:56:30 -07:00
|
|
|
itb->minw = minw;
|
|
|
|
itb->w = itb->minw;
|
2012-04-20 03:50:42 -07:00
|
|
|
}
|
|
|
|
}
|
2012-07-16 14:56:30 -07:00
|
|
|
if ((chb) && (EINA_INLIST_GET(chb)->next))
|
2012-03-30 02:22:49 -07:00
|
|
|
{
|
2012-10-01 00:36:27 -07:00
|
|
|
EINA_INLIST_FOREACH(EINA_INLIST_GET(chb)->next, itb)
|
2012-07-16 14:56:30 -07:00
|
|
|
{
|
|
|
|
if (itb->realized) _item_block_unrealize(itb);
|
|
|
|
}
|
2012-03-30 02:22:49 -07:00
|
|
|
}
|
2012-07-16 14:56:30 -07:00
|
|
|
sd->realminw = minw;
|
|
|
|
if (minw < sd->w) minw = sd->w;
|
|
|
|
if ((minw != sd->minw) || (minh != sd->minh))
|
2009-04-23 01:51:07 -07:00
|
|
|
{
|
2012-07-16 14:56:30 -07:00
|
|
|
sd->minw = minw;
|
|
|
|
sd->minh = minh;
|
|
|
|
evas_object_smart_callback_call(sd->pan_obj, "changed", NULL);
|
2012-11-25 22:32:53 -08:00
|
|
|
elm_layout_sizing_eval(sd->obj);
|
2012-10-15 02:10:05 -07:00
|
|
|
if (sd->reorder_it)
|
|
|
|
{
|
|
|
|
Elm_Gen_Item *it;
|
|
|
|
it = sd->reorder_it;
|
|
|
|
it->item->w = minw;
|
|
|
|
}
|
2012-07-16 14:56:30 -07:00
|
|
|
if ((sd->anchor_item) && (sd->anchor_item->item->block)
|
|
|
|
&& (!sd->auto_scroll_enabled))
|
|
|
|
{
|
|
|
|
Elm_Gen_Item *it;
|
|
|
|
Evas_Coord it_y;
|
|
|
|
|
|
|
|
it = sd->anchor_item;
|
|
|
|
it_y = sd->anchor_y;
|
2014-03-17 04:44:40 -07:00
|
|
|
eo_do(sd->obj, elm_interface_scrollable_content_pos_set
|
2012-11-25 22:32:53 -08:00
|
|
|
(sd->pan_x, it->item->block->y
|
2013-02-27 22:18:51 -08:00
|
|
|
+ it->y + it_y, EINA_TRUE));
|
2012-07-16 14:56:30 -07:00
|
|
|
sd->anchor_item = it;
|
|
|
|
sd->anchor_y = it_y;
|
|
|
|
}
|
2009-04-23 01:51:07 -07:00
|
|
|
}
|
2012-07-16 14:56:30 -07:00
|
|
|
if (did_must_recalc)
|
2011-10-21 15:55:45 -07:00
|
|
|
{
|
2012-07-16 14:56:30 -07:00
|
|
|
if (!sd->must_recalc_idler)
|
2013-04-24 04:41:37 -07:00
|
|
|
sd->must_recalc_idler = ecore_idler_add(_must_recalc_idler, data);
|
2011-08-24 14:03:37 -07:00
|
|
|
}
|
2012-07-16 14:56:30 -07:00
|
|
|
if (sd->check_scroll)
|
2010-03-02 00:47:40 -08:00
|
|
|
{
|
2012-11-25 22:32:53 -08:00
|
|
|
eo_do(sd->pan_obj, elm_obj_pan_content_size_get(&pan_w, &pan_h));
|
2012-07-16 14:56:30 -07:00
|
|
|
if (EINA_INLIST_GET(sd->show_item) == sd->items->last)
|
|
|
|
sd->scroll_to_type = ELM_GENLIST_ITEM_SCROLLTO_IN;
|
|
|
|
|
|
|
|
switch (sd->scroll_to_type)
|
|
|
|
{
|
|
|
|
case ELM_GENLIST_ITEM_SCROLLTO_TOP:
|
|
|
|
dy = sd->h;
|
|
|
|
break;
|
|
|
|
|
|
|
|
case ELM_GENLIST_ITEM_SCROLLTO_MIDDLE:
|
|
|
|
dy = sd->h / 2;
|
|
|
|
break;
|
|
|
|
|
|
|
|
case ELM_GENLIST_ITEM_SCROLLTO_IN:
|
|
|
|
default:
|
|
|
|
dy = 0;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
if ((sd->show_item) && (sd->show_item->item->block))
|
|
|
|
{
|
|
|
|
if ((pan_w > (sd->show_item->x + sd->show_item->item->block->x))
|
|
|
|
&& (pan_h > (sd->show_item->y + sd->show_item->item->block->y
|
|
|
|
+ dy)))
|
|
|
|
{
|
|
|
|
_item_scroll(sd);
|
|
|
|
}
|
|
|
|
}
|
2010-03-02 00:47:40 -08:00
|
|
|
}
|
2009-02-16 23:50:35 -08:00
|
|
|
|
2012-07-16 14:56:30 -07:00
|
|
|
sd->calc_job = NULL;
|
|
|
|
evas_object_smart_changed(sd->pan_obj);
|
2012-11-25 22:32:53 -08:00
|
|
|
evas_event_thaw(evas_object_evas_get(sd->obj));
|
|
|
|
evas_event_thaw_eval(evas_object_evas_get(sd->obj));
|
2009-05-12 03:16:49 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
2012-11-25 22:32:53 -08:00
|
|
|
_elm_genlist_smart_sizing_eval(Eo *obj, void *_pd, va_list *list EINA_UNUSED)
|
2009-05-12 03:16:49 -07:00
|
|
|
{
|
2012-07-16 14:56:30 -07:00
|
|
|
Evas_Coord minw = -1, minh = -1, maxw = -1, maxh = -1;
|
|
|
|
Evas_Coord vmw = 0, vmh = 0;
|
2009-09-26 11:24:06 -07:00
|
|
|
|
2012-11-25 22:32:53 -08:00
|
|
|
Elm_Genlist_Smart_Data *sd = _pd;
|
2013-10-05 01:14:25 -07:00
|
|
|
ELM_WIDGET_DATA_GET_OR_RETURN(obj, wd);
|
2012-07-16 14:56:30 -07:00
|
|
|
|
|
|
|
if (sd->on_sub_del) return;;
|
|
|
|
|
2012-08-12 16:56:37 -07:00
|
|
|
evas_object_size_hint_min_get(obj, &minw, NULL);
|
2012-07-16 14:56:30 -07:00
|
|
|
evas_object_size_hint_max_get(obj, &maxw, &maxh);
|
|
|
|
|
2012-11-25 22:32:53 -08:00
|
|
|
edje_object_size_min_calc(wd->resize_obj, &vmw, &vmh);
|
2012-07-16 14:56:30 -07:00
|
|
|
|
|
|
|
if (sd->mode == ELM_LIST_COMPRESS)
|
2009-05-12 03:16:49 -07:00
|
|
|
{
|
2012-12-24 01:47:11 -08:00
|
|
|
Evas_Coord vw = 0, vh = 0;
|
2012-07-16 14:56:30 -07:00
|
|
|
|
2014-03-17 04:44:40 -07:00
|
|
|
eo_do(obj, elm_interface_scrollable_content_viewport_size_get(&vw, &vh));
|
2012-07-16 14:56:30 -07:00
|
|
|
if ((vw != 0) && (vw != sd->prev_viewport_w))
|
2010-10-15 04:51:15 -07:00
|
|
|
{
|
2012-07-16 14:56:30 -07:00
|
|
|
Item_Block *itb;
|
|
|
|
|
|
|
|
sd->prev_viewport_w = vw;
|
|
|
|
|
2012-10-01 00:36:27 -07:00
|
|
|
EINA_INLIST_FOREACH(sd->blocks, itb)
|
2011-05-24 04:41:00 -07:00
|
|
|
{
|
2012-07-16 14:56:30 -07:00
|
|
|
itb->must_recalc = EINA_TRUE;
|
2011-05-24 04:41:00 -07:00
|
|
|
}
|
2014-01-21 06:16:41 -08:00
|
|
|
ecore_job_del(sd->calc_job);
|
2013-04-24 04:41:37 -07:00
|
|
|
sd->calc_job = ecore_job_add(_calc_job, obj);
|
2010-10-15 04:51:15 -07:00
|
|
|
}
|
2012-07-16 14:56:30 -07:00
|
|
|
minw = vmw;
|
2012-08-09 05:12:29 -07:00
|
|
|
minh = vmh;
|
2012-07-16 14:56:30 -07:00
|
|
|
}
|
|
|
|
else if (sd->mode == ELM_LIST_LIMIT)
|
From: Jeonghyun Yun <jh0506.yun@samsung.com>
Subject: [E-devel] [Patch] elm_genlist multi-touch smart callbacks
added
I added 6 multi-touch smart callbacks in elm_genlist, please refer to
below.
"multi,sweep,left" - Genlist has been multi-touch swept left.
"multi,sweep,right" - Genlist has been multi-touch swept right.
"multi,sweep,top" - Genlist has been multi-touch swept top.
"multi,sweep,bottom" - Genlist has been multi-touch swept bottom.
"multi,pinch,out" - Genlist has been multi-touch pinched out.
"multi,pinch,in" - Genlist has been multi-touch pinched in.
I think these smart callbacks are very useful for elm_genlist
multi-touch
effect.
If this patch have any issue, please let me know.
SVN revision: 55878
2011-01-05 02:28:23 -08:00
|
|
|
{
|
2012-07-16 14:56:30 -07:00
|
|
|
maxw = -1;
|
|
|
|
minw = vmw + sd->realminw;
|
From: Jeonghyun Yun <jh0506.yun@samsung.com>
Subject: [E-devel] [Patch] elm_genlist multi-touch smart callbacks
added
I added 6 multi-touch smart callbacks in elm_genlist, please refer to
below.
"multi,sweep,left" - Genlist has been multi-touch swept left.
"multi,sweep,right" - Genlist has been multi-touch swept right.
"multi,sweep,top" - Genlist has been multi-touch swept top.
"multi,sweep,bottom" - Genlist has been multi-touch swept bottom.
"multi,pinch,out" - Genlist has been multi-touch pinched out.
"multi,pinch,in" - Genlist has been multi-touch pinched in.
I think these smart callbacks are very useful for elm_genlist
multi-touch
effect.
If this patch have any issue, please let me know.
SVN revision: 55878
2011-01-05 02:28:23 -08:00
|
|
|
}
|
2012-07-16 14:56:30 -07:00
|
|
|
else
|
2010-01-18 22:54:27 -08:00
|
|
|
{
|
2012-07-16 14:56:30 -07:00
|
|
|
minw = vmw;
|
2012-08-09 05:12:29 -07:00
|
|
|
minh = vmh;
|
2010-01-18 22:54:27 -08:00
|
|
|
}
|
2012-07-16 14:56:30 -07:00
|
|
|
|
|
|
|
evas_object_size_hint_min_set(obj, minw, minh);
|
|
|
|
evas_object_size_hint_max_set(obj, maxw, maxh);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
_item_contract_emit(Elm_Gen_Item *it)
|
|
|
|
{
|
|
|
|
Elm_Gen_Item *it2;
|
|
|
|
Eina_List *l;
|
|
|
|
|
2013-10-05 05:35:27 -07:00
|
|
|
edje_object_signal_emit(VIEW(it), "elm,state,contract_flip", ""); // XXX: for compat
|
|
|
|
edje_object_signal_emit(VIEW(it), "elm,state,contract_flip", "elm");
|
2012-07-16 14:56:30 -07:00
|
|
|
it->item->tree_effect_finished = EINA_FALSE;
|
|
|
|
|
2012-10-01 00:36:27 -07:00
|
|
|
EINA_LIST_FOREACH(it->item->items, l, it2)
|
2012-07-16 14:56:30 -07:00
|
|
|
if (it2) _item_contract_emit(it2);
|
|
|
|
}
|
|
|
|
|
|
|
|
static int
|
|
|
|
_item_tree_effect_before(Elm_Gen_Item *it)
|
|
|
|
{
|
|
|
|
Elm_Gen_Item *it2;
|
|
|
|
Eina_List *l;
|
2013-05-02 11:13:36 -07:00
|
|
|
ELM_GENLIST_DATA_GET_FROM_ITEM(it, sd);
|
2012-07-16 14:56:30 -07:00
|
|
|
|
2012-10-01 00:36:27 -07:00
|
|
|
EINA_LIST_FOREACH(it->item->items, l, it2)
|
2009-09-07 23:22:11 -07:00
|
|
|
{
|
2012-07-16 14:56:30 -07:00
|
|
|
if (it2->parent && (it == it2->parent))
|
2010-01-18 22:54:27 -08:00
|
|
|
{
|
2012-07-16 14:56:30 -07:00
|
|
|
if (!it2->realized)
|
|
|
|
it2->item->tree_effect_hide_me = EINA_TRUE;
|
2013-05-02 11:13:36 -07:00
|
|
|
if (sd->move_effect_mode ==
|
2012-07-16 14:56:30 -07:00
|
|
|
ELM_GENLIST_TREE_EFFECT_EXPAND)
|
2013-10-05 05:35:27 -07:00
|
|
|
{
|
|
|
|
edje_object_signal_emit(VIEW(it2), "elm,state,hide", ""); // XXX: for compat
|
|
|
|
edje_object_signal_emit(VIEW(it2), "elm,state,hide", "elm");
|
|
|
|
}
|
2013-05-02 11:13:36 -07:00
|
|
|
else if (sd->move_effect_mode ==
|
2012-07-16 14:56:30 -07:00
|
|
|
ELM_GENLIST_TREE_EFFECT_CONTRACT)
|
|
|
|
_item_contract_emit(it2);
|
2010-01-18 22:54:27 -08:00
|
|
|
}
|
2012-07-16 14:56:30 -07:00
|
|
|
}
|
|
|
|
return ECORE_CALLBACK_CANCEL;
|
|
|
|
}
|
2011-06-01 20:10:11 -07:00
|
|
|
|
2012-07-16 14:56:30 -07:00
|
|
|
static void
|
|
|
|
_item_position(Elm_Gen_Item *it,
|
|
|
|
Evas_Object *view,
|
|
|
|
Evas_Coord it_x,
|
|
|
|
Evas_Coord it_y)
|
|
|
|
{
|
|
|
|
if (!it) return;
|
|
|
|
if (!view) return;
|
2013-05-02 11:13:36 -07:00
|
|
|
ELM_GENLIST_DATA_GET_FROM_ITEM(it, sd);
|
2011-06-01 20:10:11 -07:00
|
|
|
|
2012-07-16 14:56:30 -07:00
|
|
|
evas_event_freeze
|
2013-05-02 11:13:36 -07:00
|
|
|
(evas_object_evas_get(sd->obj));
|
2012-07-16 14:56:30 -07:00
|
|
|
evas_object_resize(view, it->item->w, it->item->h);
|
|
|
|
evas_object_move(view, it_x, it_y);
|
|
|
|
evas_object_show(view);
|
2013-05-02 11:13:36 -07:00
|
|
|
evas_event_thaw(evas_object_evas_get(sd->obj));
|
2012-07-16 14:56:30 -07:00
|
|
|
evas_event_thaw_eval
|
2013-05-02 11:13:36 -07:00
|
|
|
(evas_object_evas_get(sd->obj));
|
2012-07-16 14:56:30 -07:00
|
|
|
}
|
2011-06-01 20:10:11 -07:00
|
|
|
|
2012-07-16 14:56:30 -07:00
|
|
|
static void
|
|
|
|
_item_tree_effect(Elm_Genlist_Smart_Data *sd,
|
|
|
|
int y)
|
|
|
|
{
|
|
|
|
Elm_Gen_Item *it = NULL, *expanded_next_it;
|
2011-06-01 20:10:11 -07:00
|
|
|
|
2012-07-16 14:56:30 -07:00
|
|
|
expanded_next_it = sd->expanded_next_item;
|
|
|
|
|
|
|
|
if (sd->move_effect_mode == ELM_GENLIST_TREE_EFFECT_EXPAND)
|
2009-09-07 23:20:32 -07:00
|
|
|
{
|
2012-07-16 14:56:30 -07:00
|
|
|
it = (Elm_Gen_Item *)elm_genlist_item_prev_get
|
|
|
|
((Elm_Object_Item *)expanded_next_it);
|
|
|
|
while (it)
|
2009-09-07 23:20:32 -07:00
|
|
|
{
|
2012-07-16 14:56:30 -07:00
|
|
|
if (it->item->expanded_depth <=
|
|
|
|
expanded_next_it->item->expanded_depth) break;
|
|
|
|
if (it->item->scrl_y &&
|
|
|
|
(it->item->scrl_y <= expanded_next_it->item->old_scrl_y + y)
|
|
|
|
&& (it->item->expanded_depth >
|
|
|
|
expanded_next_it->item->expanded_depth))
|
2009-09-07 23:20:32 -07:00
|
|
|
{
|
2012-07-16 14:56:30 -07:00
|
|
|
if (!it->item->tree_effect_finished)
|
|
|
|
{
|
2013-10-05 05:35:27 -07:00
|
|
|
edje_object_signal_emit(VIEW(it), "flip_item", ""); // XXX: for compat
|
|
|
|
edje_object_signal_emit(VIEW(it), "elm,action,flip_item", "elm");
|
2012-07-16 14:56:30 -07:00
|
|
|
_item_position
|
|
|
|
(it, VIEW(it), it->item->scrl_x, it->item->scrl_y);
|
|
|
|
it->item->tree_effect_finished = EINA_TRUE;
|
|
|
|
}
|
2009-09-07 23:20:32 -07:00
|
|
|
}
|
2012-07-16 14:56:30 -07:00
|
|
|
it = (Elm_Gen_Item *)elm_genlist_item_prev_get
|
|
|
|
((Elm_Object_Item *)it);
|
2009-09-07 23:20:32 -07:00
|
|
|
}
|
2012-07-16 14:56:30 -07:00
|
|
|
}
|
|
|
|
else if (sd->move_effect_mode == ELM_GENLIST_TREE_EFFECT_CONTRACT)
|
|
|
|
{
|
|
|
|
it = (Elm_Gen_Item *)elm_genlist_item_prev_get
|
|
|
|
((Elm_Object_Item *)expanded_next_it);
|
|
|
|
while (it)
|
2009-09-07 23:20:32 -07:00
|
|
|
{
|
2012-07-16 14:56:30 -07:00
|
|
|
if ((it->item->scrl_y > expanded_next_it->item->old_scrl_y + y) &&
|
|
|
|
(it->item->expanded_depth >
|
|
|
|
expanded_next_it->item->expanded_depth))
|
2009-09-07 23:20:32 -07:00
|
|
|
{
|
2012-07-16 14:56:30 -07:00
|
|
|
if (!it->item->tree_effect_finished)
|
|
|
|
{
|
2013-10-05 05:35:27 -07:00
|
|
|
edje_object_signal_emit(VIEW(it), "elm,state,hide", ""); // XXX: for compat
|
|
|
|
edje_object_signal_emit(VIEW(it), "elm,state,hide", "elm");
|
2012-07-16 14:56:30 -07:00
|
|
|
it->item->tree_effect_finished = EINA_TRUE;
|
|
|
|
}
|
2009-09-07 23:20:32 -07:00
|
|
|
}
|
2012-07-16 14:56:30 -07:00
|
|
|
else
|
|
|
|
break;
|
|
|
|
it = (Elm_Gen_Item *)elm_genlist_item_prev_get
|
|
|
|
((Elm_Object_Item *)it);
|
2009-09-07 23:20:32 -07:00
|
|
|
}
|
|
|
|
}
|
2009-05-12 03:16:49 -07:00
|
|
|
}
|
|
|
|
|
2012-07-16 14:56:30 -07:00
|
|
|
static void
|
|
|
|
_item_sub_items_clear(Elm_Gen_Item *it)
|
2009-09-01 03:42:52 -07:00
|
|
|
{
|
2012-07-16 14:56:30 -07:00
|
|
|
Eina_List *tl = NULL, *l;
|
|
|
|
Elm_Object_Item *it2;
|
2009-09-26 11:24:06 -07:00
|
|
|
|
2012-07-16 14:56:30 -07:00
|
|
|
ELM_GENLIST_ITEM_CHECK_OR_RETURN(it);
|
2011-06-01 20:10:11 -07:00
|
|
|
|
2012-10-01 00:36:27 -07:00
|
|
|
EINA_LIST_FOREACH(it->item->items, l, it2)
|
2012-07-16 14:56:30 -07:00
|
|
|
tl = eina_list_append(tl, it2);
|
2013-03-08 20:23:42 -08:00
|
|
|
EINA_LIST_FREE(tl, it2)
|
2012-07-16 14:56:30 -07:00
|
|
|
elm_object_item_del(it2);
|
|
|
|
}
|
2011-06-01 20:10:11 -07:00
|
|
|
|
2012-07-16 14:56:30 -07:00
|
|
|
static void
|
|
|
|
_item_auto_scroll(Elm_Genlist_Smart_Data *sd)
|
|
|
|
{
|
|
|
|
Elm_Gen_Item *tmp_item = NULL;
|
|
|
|
|
|
|
|
if ((sd->expanded_item) && (sd->auto_scroll_enabled))
|
|
|
|
{
|
|
|
|
tmp_item = eina_list_data_get
|
|
|
|
(eina_list_last(sd->expanded_item->item->items));
|
|
|
|
if (!tmp_item) return;
|
|
|
|
sd->show_item = tmp_item;
|
|
|
|
sd->bring_in = EINA_TRUE;
|
|
|
|
sd->scroll_to_type = ELM_GENLIST_ITEM_SCROLLTO_IN;
|
|
|
|
if ((sd->show_item->item->queued) || (!sd->show_item->item->mincalcd))
|
2011-06-01 20:10:11 -07:00
|
|
|
{
|
2012-07-16 14:56:30 -07:00
|
|
|
sd->show_item->item->show_me = EINA_TRUE;
|
|
|
|
sd->auto_scroll_enabled = EINA_FALSE;
|
2011-06-01 20:10:11 -07:00
|
|
|
}
|
2012-07-16 14:56:30 -07:00
|
|
|
else
|
|
|
|
_item_scroll(sd);
|
2011-06-01 20:10:11 -07:00
|
|
|
}
|
2009-09-23 15:56:47 -07:00
|
|
|
}
|
2009-09-01 03:42:52 -07:00
|
|
|
|
2010-10-15 04:24:46 -07:00
|
|
|
static void
|
2012-07-16 14:56:30 -07:00
|
|
|
_item_tree_effect_finish(Elm_Genlist_Smart_Data *sd)
|
2010-10-15 04:24:46 -07:00
|
|
|
{
|
2012-07-16 14:56:30 -07:00
|
|
|
Elm_Gen_Item *it = NULL;
|
|
|
|
const Eina_List *l;
|
2010-10-15 04:24:46 -07:00
|
|
|
|
2012-07-16 14:56:30 -07:00
|
|
|
if (sd->tree_effect_animator)
|
2010-10-15 04:24:46 -07:00
|
|
|
{
|
2012-07-16 14:56:30 -07:00
|
|
|
if (sd->move_effect_mode == ELM_GENLIST_TREE_EFFECT_CONTRACT)
|
|
|
|
_item_sub_items_clear(sd->expanded_item);
|
2010-10-15 04:24:46 -07:00
|
|
|
|
2012-10-01 00:36:27 -07:00
|
|
|
EINA_LIST_FOREACH(sd->expanded_item->item->items, l, it)
|
2012-07-16 14:56:30 -07:00
|
|
|
{
|
|
|
|
it->item->tree_effect_finished = EINA_TRUE;
|
|
|
|
it->item->old_scrl_y = it->item->scrl_y;
|
|
|
|
if (GL_IT(it)->wsd->move_effect_mode ==
|
|
|
|
ELM_GENLIST_TREE_EFFECT_EXPAND)
|
2013-10-05 05:35:27 -07:00
|
|
|
{
|
|
|
|
edje_object_signal_emit(VIEW(it), "elm,state,show", ""); // XXX: for compat
|
|
|
|
edje_object_signal_emit(VIEW(it), "elm,state,show", "elm");
|
|
|
|
}
|
2012-07-16 14:56:30 -07:00
|
|
|
}
|
|
|
|
}
|
2010-10-15 04:24:46 -07:00
|
|
|
|
2012-07-16 14:56:30 -07:00
|
|
|
_item_auto_scroll(sd);
|
2014-03-08 11:46:24 -08:00
|
|
|
evas_object_lower(sd->event_block_rect);
|
|
|
|
evas_object_hide(sd->event_block_rect);
|
2012-07-16 14:56:30 -07:00
|
|
|
sd->move_effect_mode = ELM_GENLIST_TREE_EFFECT_NONE;
|
2014-01-21 17:47:33 -08:00
|
|
|
sd->move_items = eina_list_free(sd->move_items);
|
2010-10-15 04:24:46 -07:00
|
|
|
|
2012-07-16 14:56:30 -07:00
|
|
|
evas_object_smart_callback_call(sd->pan_obj, "changed", NULL);
|
|
|
|
evas_object_smart_callback_call
|
2012-11-25 22:32:53 -08:00
|
|
|
(sd->obj, SIG_TREE_EFFECT_FINISHED, NULL);
|
2012-07-16 14:56:30 -07:00
|
|
|
evas_object_smart_changed(sd->pan_obj);
|
From: Jeonghyun Yun <jh0506.yun@samsung.com>
Subject: [E-devel] [Patch] elm_genlist multi-touch smart callbacks
added
I added 6 multi-touch smart callbacks in elm_genlist, please refer to
below.
"multi,sweep,left" - Genlist has been multi-touch swept left.
"multi,sweep,right" - Genlist has been multi-touch swept right.
"multi,sweep,top" - Genlist has been multi-touch swept top.
"multi,sweep,bottom" - Genlist has been multi-touch swept bottom.
"multi,pinch,out" - Genlist has been multi-touch pinched out.
"multi,pinch,in" - Genlist has been multi-touch pinched in.
I think these smart callbacks are very useful for elm_genlist
multi-touch
effect.
If this patch have any issue, please let me know.
SVN revision: 55878
2011-01-05 02:28:23 -08:00
|
|
|
|
2012-07-16 14:56:30 -07:00
|
|
|
sd->tree_effect_animator = NULL;
|
From: Jeonghyun Yun <jh0506.yun@samsung.com>
Subject: [E-devel] [Patch] elm_genlist multi-touch smart callbacks
added
I added 6 multi-touch smart callbacks in elm_genlist, please refer to
below.
"multi,sweep,left" - Genlist has been multi-touch swept left.
"multi,sweep,right" - Genlist has been multi-touch swept right.
"multi,sweep,top" - Genlist has been multi-touch swept top.
"multi,sweep,bottom" - Genlist has been multi-touch swept bottom.
"multi,pinch,out" - Genlist has been multi-touch pinched out.
"multi,pinch,in" - Genlist has been multi-touch pinched in.
I think these smart callbacks are very useful for elm_genlist
multi-touch
effect.
If this patch have any issue, please let me know.
SVN revision: 55878
2011-01-05 02:28:23 -08:00
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
2013-08-22 11:13:04 -07:00
|
|
|
_elm_genlist_item_position_state_update(Elm_Gen_Item *it)
|
From: Jeonghyun Yun <jh0506.yun@samsung.com>
Subject: [E-devel] [Patch] elm_genlist multi-touch smart callbacks
added
I added 6 multi-touch smart callbacks in elm_genlist, please refer to
below.
"multi,sweep,left" - Genlist has been multi-touch swept left.
"multi,sweep,right" - Genlist has been multi-touch swept right.
"multi,sweep,top" - Genlist has been multi-touch swept top.
"multi,sweep,bottom" - Genlist has been multi-touch swept bottom.
"multi,pinch,out" - Genlist has been multi-touch pinched out.
"multi,pinch,in" - Genlist has been multi-touch pinched in.
I think these smart callbacks are very useful for elm_genlist
multi-touch
effect.
If this patch have any issue, please let me know.
SVN revision: 55878
2011-01-05 02:28:23 -08:00
|
|
|
{
|
genlist: implement list position signals.
Genlist will now emit the following signals to item view related to
their position in the whole list:
- elm,state,list,first: first item of the whole list
- elm,state,list,last: last item of the whole list
- elm,state,list,middle: any item that is not first or last.
- elm,state,list,single: when the item is the only element of list.
And the following related to a group (considering its given 'parent'):
- elm,state,group,first: first item of the group
- elm,state,group,last: last item of the group
- elm,state,group,middle: any item that is not first or last.
- elm,state,group,single: when the item is the only element of group.
Unlike odd/even the signals have an extra namespace "list" or "group"
to avoid conflicts with applications that may have declared these
signals themselves for other purposes.
With this patch one can implement easily something like this:
https://developer.apple.com/library/ios/documentation/userexperience/conceptual/tableview_iphone/Art/tv_grouped_style.jpg
2013-08-22 13:00:26 -07:00
|
|
|
unsigned idx = it->item->order_num_in;
|
|
|
|
|
2013-06-22 23:17:39 -07:00
|
|
|
ELM_GENLIST_DATA_GET_FROM_ITEM(it, sd);
|
2013-09-30 03:21:31 -07:00
|
|
|
|
2012-07-16 14:56:30 -07:00
|
|
|
if (!it->item->nostacking)
|
From: Jeonghyun Yun <jh0506.yun@samsung.com>
Subject: [E-devel] [Patch] elm_genlist multi-touch smart callbacks
added
I added 6 multi-touch smart callbacks in elm_genlist, please refer to
below.
"multi,sweep,left" - Genlist has been multi-touch swept left.
"multi,sweep,right" - Genlist has been multi-touch swept right.
"multi,sweep,top" - Genlist has been multi-touch swept top.
"multi,sweep,bottom" - Genlist has been multi-touch swept bottom.
"multi,pinch,out" - Genlist has been multi-touch pinched out.
"multi,pinch,in" - Genlist has been multi-touch pinched in.
I think these smart callbacks are very useful for elm_genlist
multi-touch
effect.
If this patch have any issue, please let me know.
SVN revision: 55878
2011-01-05 02:28:23 -08:00
|
|
|
{
|
genlist: implement list position signals.
Genlist will now emit the following signals to item view related to
their position in the whole list:
- elm,state,list,first: first item of the whole list
- elm,state,list,last: last item of the whole list
- elm,state,list,middle: any item that is not first or last.
- elm,state,list,single: when the item is the only element of list.
And the following related to a group (considering its given 'parent'):
- elm,state,group,first: first item of the group
- elm,state,group,last: last item of the group
- elm,state,group,middle: any item that is not first or last.
- elm,state,group,single: when the item is the only element of group.
Unlike odd/even the signals have an extra namespace "list" or "group"
to avoid conflicts with applications that may have declared these
signals themselves for other purposes.
With this patch one can implement easily something like this:
https://developer.apple.com/library/ios/documentation/userexperience/conceptual/tableview_iphone/Art/tv_grouped_style.jpg
2013-08-22 13:00:26 -07:00
|
|
|
if ((idx & 0x1) ^ it->item->stacking_even)
|
From: Jeonghyun Yun <jh0506.yun@samsung.com>
Subject: [E-devel] [Patch] elm_genlist multi-touch smart callbacks
added
I added 6 multi-touch smart callbacks in elm_genlist, please refer to
below.
"multi,sweep,left" - Genlist has been multi-touch swept left.
"multi,sweep,right" - Genlist has been multi-touch swept right.
"multi,sweep,top" - Genlist has been multi-touch swept top.
"multi,sweep,bottom" - Genlist has been multi-touch swept bottom.
"multi,pinch,out" - Genlist has been multi-touch pinched out.
"multi,pinch,in" - Genlist has been multi-touch pinched in.
I think these smart callbacks are very useful for elm_genlist
multi-touch
effect.
If this patch have any issue, please let me know.
SVN revision: 55878
2011-01-05 02:28:23 -08:00
|
|
|
{
|
2013-06-22 23:17:39 -07:00
|
|
|
if (it->deco_all_view) evas_object_stack_below(it->deco_all_view, sd->stack[0]);
|
|
|
|
else evas_object_stack_below(VIEW(it), sd->stack[0]);
|
From: Jeonghyun Yun <jh0506.yun@samsung.com>
Subject: [E-devel] [Patch] elm_genlist multi-touch smart callbacks
added
I added 6 multi-touch smart callbacks in elm_genlist, please refer to
below.
"multi,sweep,left" - Genlist has been multi-touch swept left.
"multi,sweep,right" - Genlist has been multi-touch swept right.
"multi,sweep,top" - Genlist has been multi-touch swept top.
"multi,sweep,bottom" - Genlist has been multi-touch swept bottom.
"multi,pinch,out" - Genlist has been multi-touch pinched out.
"multi,pinch,in" - Genlist has been multi-touch pinched in.
I think these smart callbacks are very useful for elm_genlist
multi-touch
effect.
If this patch have any issue, please let me know.
SVN revision: 55878
2011-01-05 02:28:23 -08:00
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
2013-06-22 23:17:39 -07:00
|
|
|
if (it->deco_all_view) evas_object_stack_above(it->deco_all_view, sd->stack[0]);
|
|
|
|
else evas_object_stack_above(VIEW(it), sd->stack[0]);
|
From: Jeonghyun Yun <jh0506.yun@samsung.com>
Subject: [E-devel] [Patch] elm_genlist multi-touch smart callbacks
added
I added 6 multi-touch smart callbacks in elm_genlist, please refer to
below.
"multi,sweep,left" - Genlist has been multi-touch swept left.
"multi,sweep,right" - Genlist has been multi-touch swept right.
"multi,sweep,top" - Genlist has been multi-touch swept top.
"multi,sweep,bottom" - Genlist has been multi-touch swept bottom.
"multi,pinch,out" - Genlist has been multi-touch pinched out.
"multi,pinch,in" - Genlist has been multi-touch pinched in.
I think these smart callbacks are very useful for elm_genlist
multi-touch
effect.
If this patch have any issue, please let me know.
SVN revision: 55878
2011-01-05 02:28:23 -08:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
genlist: implement list position signals.
Genlist will now emit the following signals to item view related to
their position in the whole list:
- elm,state,list,first: first item of the whole list
- elm,state,list,last: last item of the whole list
- elm,state,list,middle: any item that is not first or last.
- elm,state,list,single: when the item is the only element of list.
And the following related to a group (considering its given 'parent'):
- elm,state,group,first: first item of the group
- elm,state,group,last: last item of the group
- elm,state,group,middle: any item that is not first or last.
- elm,state,group,single: when the item is the only element of group.
Unlike odd/even the signals have an extra namespace "list" or "group"
to avoid conflicts with applications that may have declared these
signals themselves for other purposes.
With this patch one can implement easily something like this:
https://developer.apple.com/library/ios/documentation/userexperience/conceptual/tableview_iphone/Art/tv_grouped_style.jpg
2013-08-22 13:00:26 -07:00
|
|
|
if (idx & 0x1)
|
From: Jeonghyun Yun <jh0506.yun@samsung.com>
Subject: [E-devel] [Patch] elm_genlist multi-touch smart callbacks
added
I added 6 multi-touch smart callbacks in elm_genlist, please refer to
below.
"multi,sweep,left" - Genlist has been multi-touch swept left.
"multi,sweep,right" - Genlist has been multi-touch swept right.
"multi,sweep,top" - Genlist has been multi-touch swept top.
"multi,sweep,bottom" - Genlist has been multi-touch swept bottom.
"multi,pinch,out" - Genlist has been multi-touch pinched out.
"multi,pinch,in" - Genlist has been multi-touch pinched in.
I think these smart callbacks are very useful for elm_genlist
multi-touch
effect.
If this patch have any issue, please let me know.
SVN revision: 55878
2011-01-05 02:28:23 -08:00
|
|
|
{
|
2012-07-16 14:56:30 -07:00
|
|
|
edje_object_signal_emit(VIEW(it), "elm,state,odd", "elm");
|
|
|
|
if (it->deco_all_view)
|
|
|
|
edje_object_signal_emit(it->deco_all_view, "elm,state,odd", "elm");
|
From: Jeonghyun Yun <jh0506.yun@samsung.com>
Subject: [E-devel] [Patch] elm_genlist multi-touch smart callbacks
added
I added 6 multi-touch smart callbacks in elm_genlist, please refer to
below.
"multi,sweep,left" - Genlist has been multi-touch swept left.
"multi,sweep,right" - Genlist has been multi-touch swept right.
"multi,sweep,top" - Genlist has been multi-touch swept top.
"multi,sweep,bottom" - Genlist has been multi-touch swept bottom.
"multi,pinch,out" - Genlist has been multi-touch pinched out.
"multi,pinch,in" - Genlist has been multi-touch pinched in.
I think these smart callbacks are very useful for elm_genlist
multi-touch
effect.
If this patch have any issue, please let me know.
SVN revision: 55878
2011-01-05 02:28:23 -08:00
|
|
|
}
|
2012-07-16 14:56:30 -07:00
|
|
|
else
|
From: Jeonghyun Yun <jh0506.yun@samsung.com>
Subject: [E-devel] [Patch] elm_genlist multi-touch smart callbacks
added
I added 6 multi-touch smart callbacks in elm_genlist, please refer to
below.
"multi,sweep,left" - Genlist has been multi-touch swept left.
"multi,sweep,right" - Genlist has been multi-touch swept right.
"multi,sweep,top" - Genlist has been multi-touch swept top.
"multi,sweep,bottom" - Genlist has been multi-touch swept bottom.
"multi,pinch,out" - Genlist has been multi-touch pinched out.
"multi,pinch,in" - Genlist has been multi-touch pinched in.
I think these smart callbacks are very useful for elm_genlist
multi-touch
effect.
If this patch have any issue, please let me know.
SVN revision: 55878
2011-01-05 02:28:23 -08:00
|
|
|
{
|
2012-07-16 14:56:30 -07:00
|
|
|
edje_object_signal_emit(VIEW(it), "elm,state,even", "elm");
|
|
|
|
if (it->deco_all_view)
|
|
|
|
edje_object_signal_emit(it->deco_all_view, "elm,state,even", "elm");
|
From: Jeonghyun Yun <jh0506.yun@samsung.com>
Subject: [E-devel] [Patch] elm_genlist multi-touch smart callbacks
added
I added 6 multi-touch smart callbacks in elm_genlist, please refer to
below.
"multi,sweep,left" - Genlist has been multi-touch swept left.
"multi,sweep,right" - Genlist has been multi-touch swept right.
"multi,sweep,top" - Genlist has been multi-touch swept top.
"multi,sweep,bottom" - Genlist has been multi-touch swept bottom.
"multi,pinch,out" - Genlist has been multi-touch pinched out.
"multi,pinch,in" - Genlist has been multi-touch pinched in.
I think these smart callbacks are very useful for elm_genlist
multi-touch
effect.
If this patch have any issue, please let me know.
SVN revision: 55878
2011-01-05 02:28:23 -08:00
|
|
|
}
|
genlist: implement list position signals.
Genlist will now emit the following signals to item view related to
their position in the whole list:
- elm,state,list,first: first item of the whole list
- elm,state,list,last: last item of the whole list
- elm,state,list,middle: any item that is not first or last.
- elm,state,list,single: when the item is the only element of list.
And the following related to a group (considering its given 'parent'):
- elm,state,group,first: first item of the group
- elm,state,group,last: last item of the group
- elm,state,group,middle: any item that is not first or last.
- elm,state,group,single: when the item is the only element of group.
Unlike odd/even the signals have an extra namespace "list" or "group"
to avoid conflicts with applications that may have declared these
signals themselves for other purposes.
With this patch one can implement easily something like this:
https://developer.apple.com/library/ios/documentation/userexperience/conceptual/tableview_iphone/Art/tv_grouped_style.jpg
2013-08-22 13:00:26 -07:00
|
|
|
|
|
|
|
if (sd->item_count == 1)
|
|
|
|
{
|
|
|
|
edje_object_signal_emit(VIEW(it), "elm,state,list,single", "elm");
|
|
|
|
if (it->deco_all_view)
|
|
|
|
edje_object_signal_emit(it->deco_all_view, "elm,state,list,single", "elm");
|
|
|
|
}
|
|
|
|
else if (idx == 0)
|
|
|
|
{
|
|
|
|
edje_object_signal_emit(VIEW(it), "elm,state,list,first", "elm");
|
|
|
|
if (it->deco_all_view)
|
|
|
|
edje_object_signal_emit(it->deco_all_view, "elm,state,list,first", "elm");
|
|
|
|
}
|
|
|
|
else if (idx == sd->item_count - 1)
|
|
|
|
{
|
|
|
|
edje_object_signal_emit(VIEW(it), "elm,state,list,last", "elm");
|
|
|
|
if (it->deco_all_view)
|
|
|
|
edje_object_signal_emit(it->deco_all_view, "elm,state,list,last", "elm");
|
|
|
|
}
|
|
|
|
else if (idx > 0)
|
|
|
|
{
|
|
|
|
edje_object_signal_emit(VIEW(it), "elm,state,list,middle", "elm");
|
|
|
|
if (it->deco_all_view)
|
|
|
|
edje_object_signal_emit(it->deco_all_view, "elm,state,list,middle", "elm");
|
|
|
|
}
|
|
|
|
|
|
|
|
if (it->parent)
|
|
|
|
{
|
|
|
|
unsigned first_idx = it->parent->item->order_num_in + 1;
|
|
|
|
unsigned count = eina_list_count(it->parent->item->items);
|
|
|
|
|
|
|
|
if (count == 1)
|
|
|
|
{
|
|
|
|
edje_object_signal_emit(VIEW(it), "elm,state,group,single", "elm");
|
|
|
|
if (it->deco_all_view)
|
|
|
|
edje_object_signal_emit(it->deco_all_view, "elm,state,group,single", "elm");
|
|
|
|
}
|
|
|
|
else if (idx == first_idx)
|
|
|
|
{
|
|
|
|
edje_object_signal_emit(VIEW(it), "elm,state,group,first", "elm");
|
|
|
|
if (it->deco_all_view)
|
|
|
|
edje_object_signal_emit(it->deco_all_view, "elm,state,group,first", "elm");
|
|
|
|
}
|
|
|
|
else if (it == eina_list_data_get(eina_list_last(it->parent->item->items)))
|
|
|
|
{
|
|
|
|
edje_object_signal_emit(VIEW(it), "elm,state,group,last", "elm");
|
|
|
|
if (it->deco_all_view)
|
|
|
|
edje_object_signal_emit(it->deco_all_view, "elm,state,group,last", "elm");
|
|
|
|
}
|
|
|
|
else if (idx > first_idx)
|
|
|
|
{
|
|
|
|
edje_object_signal_emit(VIEW(it), "elm,state,group,middle", "elm");
|
|
|
|
if (it->deco_all_view)
|
|
|
|
edje_object_signal_emit(it->deco_all_view, "elm,state,group,middle", "elm");
|
|
|
|
}
|
|
|
|
}
|
From: Jeonghyun Yun <jh0506.yun@samsung.com>
Subject: [E-devel] [Patch] elm_genlist multi-touch smart callbacks
added
I added 6 multi-touch smart callbacks in elm_genlist, please refer to
below.
"multi,sweep,left" - Genlist has been multi-touch swept left.
"multi,sweep,right" - Genlist has been multi-touch swept right.
"multi,sweep,top" - Genlist has been multi-touch swept top.
"multi,sweep,bottom" - Genlist has been multi-touch swept bottom.
"multi,pinch,out" - Genlist has been multi-touch pinched out.
"multi,pinch,in" - Genlist has been multi-touch pinched in.
I think these smart callbacks are very useful for elm_genlist
multi-touch
effect.
If this patch have any issue, please let me know.
SVN revision: 55878
2011-01-05 02:28:23 -08:00
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
2012-07-16 14:56:30 -07:00
|
|
|
_item_order_update(const Eina_Inlist *l,
|
|
|
|
int start)
|
From: Jeonghyun Yun <jh0506.yun@samsung.com>
Subject: [E-devel] [Patch] elm_genlist multi-touch smart callbacks
added
I added 6 multi-touch smart callbacks in elm_genlist, please refer to
below.
"multi,sweep,left" - Genlist has been multi-touch swept left.
"multi,sweep,right" - Genlist has been multi-touch swept right.
"multi,sweep,top" - Genlist has been multi-touch swept top.
"multi,sweep,bottom" - Genlist has been multi-touch swept bottom.
"multi,pinch,out" - Genlist has been multi-touch pinched out.
"multi,pinch,in" - Genlist has been multi-touch pinched in.
I think these smart callbacks are very useful for elm_genlist
multi-touch
effect.
If this patch have any issue, please let me know.
SVN revision: 55878
2011-01-05 02:28:23 -08:00
|
|
|
{
|
2012-07-16 14:56:30 -07:00
|
|
|
Elm_Gen_Item *it, *it2;
|
From: Jeonghyun Yun <jh0506.yun@samsung.com>
Subject: [E-devel] [Patch] elm_genlist multi-touch smart callbacks
added
I added 6 multi-touch smart callbacks in elm_genlist, please refer to
below.
"multi,sweep,left" - Genlist has been multi-touch swept left.
"multi,sweep,right" - Genlist has been multi-touch swept right.
"multi,sweep,top" - Genlist has been multi-touch swept top.
"multi,sweep,bottom" - Genlist has been multi-touch swept bottom.
"multi,pinch,out" - Genlist has been multi-touch pinched out.
"multi,pinch,in" - Genlist has been multi-touch pinched in.
I think these smart callbacks are very useful for elm_genlist
multi-touch
effect.
If this patch have any issue, please let me know.
SVN revision: 55878
2011-01-05 02:28:23 -08:00
|
|
|
|
genlist: implement list position signals.
Genlist will now emit the following signals to item view related to
their position in the whole list:
- elm,state,list,first: first item of the whole list
- elm,state,list,last: last item of the whole list
- elm,state,list,middle: any item that is not first or last.
- elm,state,list,single: when the item is the only element of list.
And the following related to a group (considering its given 'parent'):
- elm,state,group,first: first item of the group
- elm,state,group,last: last item of the group
- elm,state,group,middle: any item that is not first or last.
- elm,state,group,single: when the item is the only element of group.
Unlike odd/even the signals have an extra namespace "list" or "group"
to avoid conflicts with applications that may have declared these
signals themselves for other purposes.
With this patch one can implement easily something like this:
https://developer.apple.com/library/ios/documentation/userexperience/conceptual/tableview_iphone/Art/tv_grouped_style.jpg
2013-08-22 13:00:26 -07:00
|
|
|
/*
|
|
|
|
* always update position state of previous item, it may have been
|
|
|
|
* marked as "single" if it was the only element at the time, or
|
|
|
|
* "middle", "first" or "last" in the case of insert into different
|
|
|
|
* positions.
|
|
|
|
*/
|
|
|
|
if ((l->prev) && (start > 0))
|
|
|
|
{
|
|
|
|
it = ELM_GEN_ITEM_FROM_INLIST(l->prev);
|
|
|
|
it->item->order_num_in = start - 1;
|
|
|
|
_elm_genlist_item_position_state_update(it);
|
|
|
|
}
|
|
|
|
|
2012-07-16 14:56:30 -07:00
|
|
|
for (it = ELM_GEN_ITEM_FROM_INLIST(l); l; l = l->next,
|
|
|
|
it = ELM_GEN_ITEM_FROM_INLIST(l))
|
|
|
|
{
|
|
|
|
it->item->order_num_in = start++;
|
2013-08-22 11:13:04 -07:00
|
|
|
_elm_genlist_item_position_state_update(it);
|
2012-07-16 14:56:30 -07:00
|
|
|
it2 = ELM_GEN_ITEM_FROM_INLIST(l->next);
|
|
|
|
if (it2 && (it->item->order_num_in != it2->item->order_num_in))
|
|
|
|
return;
|
|
|
|
}
|
From: Jeonghyun Yun <jh0506.yun@samsung.com>
Subject: [E-devel] [Patch] elm_genlist multi-touch smart callbacks
added
I added 6 multi-touch smart callbacks in elm_genlist, please refer to
below.
"multi,sweep,left" - Genlist has been multi-touch swept left.
"multi,sweep,right" - Genlist has been multi-touch swept right.
"multi,sweep,top" - Genlist has been multi-touch swept top.
"multi,sweep,bottom" - Genlist has been multi-touch swept bottom.
"multi,pinch,out" - Genlist has been multi-touch pinched out.
"multi,pinch,in" - Genlist has been multi-touch pinched in.
I think these smart callbacks are very useful for elm_genlist
multi-touch
effect.
If this patch have any issue, please let me know.
SVN revision: 55878
2011-01-05 02:28:23 -08:00
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
2012-07-16 14:56:30 -07:00
|
|
|
_elm_genlist_item_state_update(Elm_Gen_Item *it,
|
|
|
|
Item_Cache *itc)
|
From: Jeonghyun Yun <jh0506.yun@samsung.com>
Subject: [E-devel] [Patch] elm_genlist multi-touch smart callbacks
added
I added 6 multi-touch smart callbacks in elm_genlist, please refer to
below.
"multi,sweep,left" - Genlist has been multi-touch swept left.
"multi,sweep,right" - Genlist has been multi-touch swept right.
"multi,sweep,top" - Genlist has been multi-touch swept top.
"multi,sweep,bottom" - Genlist has been multi-touch swept bottom.
"multi,pinch,out" - Genlist has been multi-touch pinched out.
"multi,pinch,in" - Genlist has been multi-touch pinched in.
I think these smart callbacks are very useful for elm_genlist
multi-touch
effect.
If this patch have any issue, please let me know.
SVN revision: 55878
2011-01-05 02:28:23 -08:00
|
|
|
{
|
2012-07-16 14:56:30 -07:00
|
|
|
if (itc)
|
2011-06-01 20:10:11 -07:00
|
|
|
{
|
2012-07-16 14:56:30 -07:00
|
|
|
if (it->selected != itc->selected)
|
2011-09-05 05:16:36 -07:00
|
|
|
{
|
2012-07-16 14:56:30 -07:00
|
|
|
if (it->selected)
|
|
|
|
{
|
|
|
|
edje_object_signal_emit
|
|
|
|
(VIEW(it), "elm,state,selected", "elm");
|
|
|
|
if (it->deco_all_view)
|
|
|
|
edje_object_signal_emit
|
|
|
|
(it->deco_all_view, "elm,state,selected", "elm");
|
|
|
|
}
|
2011-06-01 20:10:11 -07:00
|
|
|
}
|
2012-07-16 14:56:30 -07:00
|
|
|
if (elm_widget_item_disabled_get(it) != itc->disabled)
|
2011-05-24 04:41:00 -07:00
|
|
|
{
|
2012-07-16 14:56:30 -07:00
|
|
|
if (elm_widget_item_disabled_get(it))
|
|
|
|
edje_object_signal_emit(VIEW(it), "elm,state,disabled", "elm");
|
|
|
|
if (it->deco_all_view)
|
|
|
|
edje_object_signal_emit
|
|
|
|
(it->deco_all_view, "elm,state,disabled", "elm");
|
2011-05-24 04:41:00 -07:00
|
|
|
}
|
2012-07-16 14:56:30 -07:00
|
|
|
if (it->item->expanded != itc->expanded)
|
2010-03-26 21:17:01 -07:00
|
|
|
{
|
2012-07-16 14:56:30 -07:00
|
|
|
if (it->item->expanded)
|
|
|
|
edje_object_signal_emit(VIEW(it), "elm,state,expanded", "elm");
|
|
|
|
if (it->deco_all_view)
|
|
|
|
edje_object_signal_emit
|
|
|
|
(it->deco_all_view, "elm,state,expanded", "elm");
|
2010-03-26 21:17:01 -07:00
|
|
|
}
|
|
|
|
}
|
2012-07-16 14:56:30 -07:00
|
|
|
else
|
2009-02-16 23:50:35 -08:00
|
|
|
{
|
2012-07-16 14:56:30 -07:00
|
|
|
if (it->selected)
|
2011-05-24 04:41:00 -07:00
|
|
|
{
|
2012-07-16 14:56:30 -07:00
|
|
|
edje_object_signal_emit(VIEW(it), "elm,state,selected", "elm");
|
|
|
|
if (it->deco_all_view)
|
|
|
|
edje_object_signal_emit
|
|
|
|
(it->deco_all_view, "elm,state,selected", "elm");
|
2011-05-24 04:41:00 -07:00
|
|
|
}
|
2012-07-16 14:56:30 -07:00
|
|
|
if (elm_widget_item_disabled_get(it))
|
2010-10-15 04:51:15 -07:00
|
|
|
{
|
2012-07-16 14:56:30 -07:00
|
|
|
edje_object_signal_emit(VIEW(it), "elm,state,disabled", "elm");
|
|
|
|
if (it->deco_all_view)
|
|
|
|
edje_object_signal_emit
|
|
|
|
(it->deco_all_view, "elm,state,disabled", "elm");
|
2010-10-15 04:51:15 -07:00
|
|
|
}
|
2012-07-16 14:56:30 -07:00
|
|
|
if (it->item->expanded)
|
2010-10-15 04:51:15 -07:00
|
|
|
{
|
2012-07-16 14:56:30 -07:00
|
|
|
edje_object_signal_emit(VIEW(it), "elm,state,expanded", "elm");
|
|
|
|
if (it->deco_all_view)
|
|
|
|
edje_object_signal_emit
|
|
|
|
(it->deco_all_view, "elm,state,expanded", "elm");
|
2010-10-15 04:51:15 -07:00
|
|
|
}
|
2009-02-16 23:50:35 -08:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2012-03-20 00:58:42 -07:00
|
|
|
static void
|
2012-07-16 14:56:30 -07:00
|
|
|
_elm_genlist_item_index_update(Elm_Gen_Item *it)
|
|
|
|
{
|
|
|
|
if (it->position_update || it->item->block->position_update)
|
|
|
|
{
|
|
|
|
evas_object_smart_callback_call(WIDGET(it), SIG_INDEX_UPDATE, it);
|
|
|
|
it->position_update = EINA_FALSE;
|
|
|
|
}
|
2012-03-20 00:58:42 -07:00
|
|
|
}
|
|
|
|
|
2009-03-12 22:50:38 -07:00
|
|
|
static void
|
2012-07-16 14:56:30 -07:00
|
|
|
_item_text_realize(Elm_Gen_Item *it,
|
|
|
|
Evas_Object *target,
|
|
|
|
Eina_List **source,
|
|
|
|
const char *parts)
|
2009-03-12 22:50:38 -07:00
|
|
|
{
|
2012-07-16 14:56:30 -07:00
|
|
|
if (it->itc->func.text_get)
|
|
|
|
{
|
|
|
|
const Eina_List *l;
|
|
|
|
const char *key;
|
2009-09-26 11:24:06 -07:00
|
|
|
|
2012-07-16 14:56:30 -07:00
|
|
|
if (!(*source))
|
|
|
|
*source = elm_widget_stringlist_get
|
|
|
|
(edje_object_data_get(target, "texts"));
|
2012-10-01 00:36:27 -07:00
|
|
|
EINA_LIST_FOREACH(*source, l, key)
|
2012-07-16 14:56:30 -07:00
|
|
|
{
|
|
|
|
if (parts && fnmatch(parts, key, FNM_PERIOD))
|
|
|
|
continue;
|
2009-03-12 22:50:38 -07:00
|
|
|
|
2012-07-16 14:56:30 -07:00
|
|
|
char *s = it->itc->func.text_get
|
|
|
|
((void *)it->base.data, WIDGET(it), key);
|
2009-09-26 11:24:06 -07:00
|
|
|
|
2012-07-16 14:56:30 -07:00
|
|
|
if (s)
|
|
|
|
{
|
|
|
|
edje_object_part_text_escaped_set(target, key, s);
|
|
|
|
free(s);
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
edje_object_part_text_set(target, key, "");
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
2009-03-12 22:50:38 -07:00
|
|
|
}
|
|
|
|
|
2012-07-16 14:56:30 -07:00
|
|
|
static Eina_List *
|
|
|
|
_item_mode_content_realize(Elm_Gen_Item *it,
|
|
|
|
Evas_Object *target,
|
|
|
|
Eina_List **source,
|
|
|
|
const char *parts,
|
|
|
|
Eina_List **contents_list)
|
2009-03-12 22:50:38 -07:00
|
|
|
{
|
2012-07-16 14:56:30 -07:00
|
|
|
Eina_List *res = *contents_list;
|
2009-09-26 11:24:06 -07:00
|
|
|
|
2012-07-16 14:56:30 -07:00
|
|
|
if (it->itc->func.content_get)
|
|
|
|
{
|
|
|
|
const Eina_List *l;
|
|
|
|
const char *key;
|
|
|
|
Evas_Object *ic;
|
2009-03-12 22:50:38 -07:00
|
|
|
|
2012-10-01 00:36:27 -07:00
|
|
|
EINA_LIST_FOREACH(*source, l, key)
|
2012-07-16 14:56:30 -07:00
|
|
|
{
|
|
|
|
if (parts && fnmatch(parts, key, FNM_PERIOD))
|
|
|
|
continue;
|
2011-04-21 04:47:36 -07:00
|
|
|
|
2012-07-16 14:56:30 -07:00
|
|
|
ic = it->itc->func.content_get
|
|
|
|
((void *)it->base.data, WIDGET(it), key);
|
2011-05-29 19:31:21 -07:00
|
|
|
|
2012-07-16 14:56:30 -07:00
|
|
|
if (ic)
|
|
|
|
{
|
|
|
|
res = eina_list_append(res, ic);
|
|
|
|
edje_object_part_swallow(target, key, ic);
|
|
|
|
evas_object_show(ic);
|
|
|
|
elm_widget_sub_object_add(WIDGET(it), ic);
|
|
|
|
if (elm_widget_item_disabled_get(it))
|
|
|
|
elm_widget_disabled_set(ic, EINA_TRUE);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return res;
|
2011-04-21 04:47:36 -07:00
|
|
|
}
|
|
|
|
|
2010-11-05 23:02:22 -07:00
|
|
|
static void
|
2012-07-16 14:56:30 -07:00
|
|
|
_item_state_realize(Elm_Gen_Item *it,
|
|
|
|
Evas_Object *target,
|
|
|
|
Eina_List **source,
|
|
|
|
const char *parts)
|
2010-11-05 23:02:22 -07:00
|
|
|
{
|
2012-07-16 14:56:30 -07:00
|
|
|
if (it->itc->func.state_get)
|
2010-12-07 11:18:14 -08:00
|
|
|
{
|
2012-07-16 14:56:30 -07:00
|
|
|
const Eina_List *l;
|
|
|
|
const char *key;
|
|
|
|
char buf[4096];
|
2010-12-07 11:18:14 -08:00
|
|
|
|
2012-07-16 14:56:30 -07:00
|
|
|
if (!(*source))
|
|
|
|
*source = elm_widget_stringlist_get
|
|
|
|
(edje_object_data_get(target, "states"));
|
2012-10-01 00:36:27 -07:00
|
|
|
EINA_LIST_FOREACH(*source, l, key)
|
2012-07-16 14:56:30 -07:00
|
|
|
{
|
|
|
|
if (parts && fnmatch(parts, key, FNM_PERIOD))
|
|
|
|
continue;
|
|
|
|
|
|
|
|
Eina_Bool on = it->itc->func.state_get
|
|
|
|
((void *)it->base.data, WIDGET(it), key);
|
|
|
|
|
|
|
|
if (on)
|
|
|
|
{
|
|
|
|
snprintf(buf, sizeof(buf), "elm,state,%s,active", key);
|
|
|
|
edje_object_signal_emit(target, buf, "elm");
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
snprintf(buf, sizeof(buf), "elm,state,%s,passive", key);
|
|
|
|
edje_object_signal_emit(target, buf, "elm");
|
|
|
|
}
|
|
|
|
}
|
2013-05-16 15:28:17 -07:00
|
|
|
edje_object_message_signal_process(target);
|
2010-12-07 11:18:14 -08:00
|
|
|
}
|
2010-11-05 23:02:22 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
2012-07-16 14:56:30 -07:00
|
|
|
_decorate_all_item_position(Elm_Gen_Item *it,
|
|
|
|
int itx,
|
|
|
|
int ity)
|
2010-11-05 23:02:22 -07:00
|
|
|
{
|
2012-07-16 14:56:30 -07:00
|
|
|
if ((!it) || (!GL_IT(it)->wsd->decorate_all_mode)) return;
|
|
|
|
evas_object_resize(it->deco_all_view, it->item->w, it->item->h);
|
|
|
|
evas_object_move(it->deco_all_view, itx, ity);
|
2010-11-05 23:02:22 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
2012-07-16 14:56:30 -07:00
|
|
|
_decorate_all_item_realize(Elm_Gen_Item *it,
|
|
|
|
Eina_Bool effect_on)
|
2010-11-05 23:02:22 -07:00
|
|
|
{
|
2012-07-16 14:56:30 -07:00
|
|
|
char buf[1024];
|
|
|
|
const char *stacking;
|
|
|
|
const char *stacking_even;
|
2010-12-07 11:18:14 -08:00
|
|
|
|
2013-05-02 11:13:36 -07:00
|
|
|
if (!it) return;
|
|
|
|
ELM_GENLIST_DATA_GET_FROM_ITEM(it, sd);
|
|
|
|
|
|
|
|
if ((it->item->decorate_all_item_realized) ||
|
|
|
|
(it->generation < sd->generation))
|
2012-07-16 14:56:30 -07:00
|
|
|
return;
|
2010-12-07 11:18:14 -08:00
|
|
|
|
2012-07-16 14:56:30 -07:00
|
|
|
it->deco_all_view = edje_object_add(evas_object_evas_get(WIDGET(it)));
|
|
|
|
edje_object_scale_set(it->deco_all_view, elm_widget_scale_get(WIDGET(it)) *
|
|
|
|
elm_config_scale_get());
|
2013-05-02 11:13:36 -07:00
|
|
|
evas_object_smart_member_add(it->deco_all_view, sd->pan_obj);
|
2012-07-16 14:56:30 -07:00
|
|
|
elm_widget_sub_object_add(WIDGET(it), it->deco_all_view);
|
|
|
|
|
|
|
|
if (it->item->type & ELM_GENLIST_ITEM_TREE)
|
|
|
|
strncpy(buf, "tree", sizeof(buf));
|
|
|
|
else strncpy(buf, "item", sizeof(buf));
|
2013-05-02 11:13:36 -07:00
|
|
|
if (sd->mode == ELM_LIST_COMPRESS)
|
2013-03-21 06:34:15 -07:00
|
|
|
strncat(buf, "_compress", sizeof(buf) - strlen(buf) - 1);
|
2012-07-16 14:56:30 -07:00
|
|
|
|
2013-03-21 06:34:15 -07:00
|
|
|
strncat(buf, "/", sizeof(buf) - strlen(buf) - 1);
|
|
|
|
strncat(buf, it->itc->decorate_all_item_style, sizeof(buf) - strlen(buf) - 1);
|
2012-07-16 14:56:30 -07:00
|
|
|
|
|
|
|
elm_widget_theme_object_set(WIDGET(it), it->deco_all_view, "genlist", buf,
|
|
|
|
elm_widget_style_get(WIDGET(it)));
|
|
|
|
|
|
|
|
stacking_even = edje_object_data_get(VIEW(it), "stacking_even");
|
|
|
|
if (!stacking_even) stacking_even = "above";
|
|
|
|
it->item->stacking_even = !!strcmp("above", stacking_even);
|
|
|
|
|
|
|
|
stacking = edje_object_data_get(VIEW(it), "stacking");
|
|
|
|
if (!stacking) stacking = "yes";
|
|
|
|
it->item->nostacking = !!strcmp("yes", stacking);
|
|
|
|
|
|
|
|
edje_object_mirrored_set
|
|
|
|
(it->deco_all_view, elm_widget_mirrored_get(WIDGET(it)));
|
|
|
|
|
2013-08-22 11:13:04 -07:00
|
|
|
_elm_genlist_item_position_state_update(it);
|
2012-07-16 14:56:30 -07:00
|
|
|
_elm_genlist_item_state_update(it, NULL);
|
|
|
|
|
|
|
|
if (effect_on)
|
|
|
|
edje_object_signal_emit
|
|
|
|
(it->deco_all_view, "elm,state,decorate,enabled,effect", "elm");
|
|
|
|
else
|
|
|
|
edje_object_signal_emit
|
|
|
|
(it->deco_all_view, "elm,state,decorate,enabled", "elm");
|
|
|
|
|
|
|
|
_item_mouse_callbacks_del(it, VIEW(it));
|
|
|
|
_item_mouse_callbacks_add(it, it->deco_all_view);
|
|
|
|
|
|
|
|
_item_text_realize(it, it->deco_all_view, &it->item->deco_all_texts, NULL);
|
|
|
|
if (it->flipped)
|
|
|
|
edje_object_signal_emit
|
|
|
|
(it->deco_all_view, "elm,state,flip,enabled", "elm");
|
|
|
|
if (!it->item->deco_all_contents)
|
|
|
|
it->item->deco_all_contents = elm_widget_stringlist_get
|
|
|
|
(edje_object_data_get(it->deco_all_view, "contents"));
|
|
|
|
it->item->deco_all_content_objs =
|
|
|
|
_item_mode_content_realize(it, it->deco_all_view,
|
|
|
|
&it->item->deco_all_contents, NULL,
|
|
|
|
&it->item->deco_all_content_objs);
|
|
|
|
_item_state_realize
|
|
|
|
(it, it->deco_all_view, &it->item->deco_all_states, NULL);
|
|
|
|
edje_object_part_swallow
|
|
|
|
(it->deco_all_view, "elm.swallow.decorate.content", VIEW(it));
|
|
|
|
|
|
|
|
_decorate_all_item_position(it, it->item->scrl_x, it->item->scrl_y);
|
|
|
|
evas_object_show(it->deco_all_view);
|
|
|
|
|
|
|
|
if (it->selected)
|
|
|
|
edje_object_signal_emit(it->deco_all_view, "elm,state,selected", "elm");
|
|
|
|
|
|
|
|
it->item->decorate_all_item_realized = EINA_TRUE;
|
|
|
|
it->want_unrealize = EINA_FALSE;
|
|
|
|
}
|
|
|
|
|
2013-01-25 23:11:32 -08:00
|
|
|
//-- tree expand/contract signal handle routine --//
|
2011-12-26 06:30:21 -08:00
|
|
|
static void
|
2012-07-16 14:56:30 -07:00
|
|
|
_expand_toggle_signal_cb(void *data,
|
2014-01-06 06:30:02 -08:00
|
|
|
Evas_Object *obj EINA_UNUSED,
|
|
|
|
const char *emission EINA_UNUSED,
|
|
|
|
const char *source EINA_UNUSED)
|
2011-12-26 06:30:21 -08:00
|
|
|
{
|
2012-07-16 14:56:30 -07:00
|
|
|
Elm_Gen_Item *it = data;
|
|
|
|
|
|
|
|
if (it->item->expanded)
|
|
|
|
evas_object_smart_callback_call(WIDGET(it), SIG_CONTRACT_REQUEST, it);
|
|
|
|
else
|
|
|
|
evas_object_smart_callback_call(WIDGET(it), SIG_EXPAND_REQUEST, it);
|
2011-12-26 06:30:21 -08:00
|
|
|
}
|
|
|
|
|
2011-04-22 02:56:22 -07:00
|
|
|
static void
|
2012-07-16 14:56:30 -07:00
|
|
|
_expand_signal_cb(void *data,
|
2014-01-06 06:30:02 -08:00
|
|
|
Evas_Object *obj EINA_UNUSED,
|
|
|
|
const char *emission EINA_UNUSED,
|
|
|
|
const char *source EINA_UNUSED)
|
2011-04-22 02:56:22 -07:00
|
|
|
{
|
2012-07-16 14:56:30 -07:00
|
|
|
Elm_Gen_Item *it = data;
|
2011-04-22 02:56:22 -07:00
|
|
|
|
2012-07-16 14:56:30 -07:00
|
|
|
if (!it->item->expanded)
|
|
|
|
evas_object_smart_callback_call(WIDGET(it), SIG_EXPAND_REQUEST, it);
|
2011-04-22 02:56:22 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
2012-07-16 14:56:30 -07:00
|
|
|
_contract_signal_cb(void *data,
|
2014-01-06 06:30:02 -08:00
|
|
|
Evas_Object *obj EINA_UNUSED,
|
|
|
|
const char *emission EINA_UNUSED,
|
|
|
|
const char *source EINA_UNUSED)
|
2011-04-22 02:56:22 -07:00
|
|
|
{
|
2012-07-16 14:56:30 -07:00
|
|
|
Elm_Gen_Item *it = data;
|
|
|
|
|
|
|
|
if (it->item->expanded)
|
|
|
|
evas_object_smart_callback_call(WIDGET(it), SIG_CONTRACT_REQUEST, it);
|
2011-04-22 02:56:22 -07:00
|
|
|
}
|
|
|
|
|
2013-01-25 23:11:32 -08:00
|
|
|
//-- item cache handle routine --//
|
|
|
|
// clean up item cache by removing overflowed caches
|
|
|
|
static void
|
|
|
|
_item_cache_clean(Elm_Genlist_Smart_Data *sd)
|
|
|
|
{
|
|
|
|
evas_event_freeze(evas_object_evas_get(sd->obj));
|
|
|
|
|
|
|
|
while ((sd->item_cache) && (sd->item_cache_count > sd->item_cache_max))
|
|
|
|
{
|
|
|
|
Item_Cache *itc;
|
|
|
|
|
|
|
|
itc = EINA_INLIST_CONTAINER_GET(sd->item_cache->last, Item_Cache);
|
|
|
|
sd->item_cache = eina_inlist_remove
|
|
|
|
(sd->item_cache, sd->item_cache->last);
|
|
|
|
sd->item_cache_count--;
|
2014-01-21 17:12:44 -08:00
|
|
|
evas_object_del(itc->spacer);
|
|
|
|
evas_object_del(itc->base_view);
|
2013-01-25 23:11:32 -08:00
|
|
|
eina_stringshare_del(itc->item_style);
|
|
|
|
free(itc);
|
|
|
|
}
|
|
|
|
evas_event_thaw(evas_object_evas_get(sd->obj));
|
|
|
|
evas_event_thaw_eval(evas_object_evas_get(sd->obj));
|
|
|
|
}
|
|
|
|
|
|
|
|
// free one item cache
|
|
|
|
static void
|
|
|
|
_item_cache_free(Item_Cache *itc)
|
|
|
|
{
|
2014-01-21 17:12:44 -08:00
|
|
|
evas_object_del(itc->spacer);
|
|
|
|
evas_object_del(itc->base_view);
|
2013-01-25 23:11:32 -08:00
|
|
|
eina_stringshare_del(itc->item_style);
|
|
|
|
free(itc);
|
|
|
|
}
|
|
|
|
|
|
|
|
// empty all item caches
|
|
|
|
static void
|
|
|
|
_item_cache_zero(Elm_Genlist_Smart_Data *sd)
|
|
|
|
{
|
|
|
|
int pmax = sd->item_cache_max;
|
|
|
|
|
|
|
|
sd->item_cache_max = 0;
|
|
|
|
_item_cache_clean(sd);
|
|
|
|
sd->item_cache_max = pmax;
|
|
|
|
}
|
|
|
|
|
|
|
|
// add an item to item cache
|
|
|
|
static void
|
|
|
|
_item_cache_add(Elm_Gen_Item *it)
|
|
|
|
{
|
|
|
|
Item_Cache *itc;
|
2013-05-02 11:13:36 -07:00
|
|
|
ELM_GENLIST_DATA_GET_FROM_ITEM(it, sd);
|
|
|
|
Evas_Object *obj = sd->obj;
|
2013-01-25 23:11:32 -08:00
|
|
|
|
|
|
|
evas_event_freeze(evas_object_evas_get(obj));
|
2013-05-02 11:13:36 -07:00
|
|
|
if (sd->item_cache_max <= 0)
|
2013-01-25 23:11:32 -08:00
|
|
|
{
|
2014-01-21 17:38:55 -08:00
|
|
|
ELM_SAFE_FREE(VIEW(it), evas_object_del);
|
2013-09-05 21:00:42 -07:00
|
|
|
ELM_SAFE_FREE(it->spacer, evas_object_del);
|
|
|
|
|
2013-01-25 23:11:32 -08:00
|
|
|
evas_event_thaw(evas_object_evas_get(obj));
|
|
|
|
evas_event_thaw_eval(evas_object_evas_get(obj));
|
|
|
|
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2013-05-02 11:13:36 -07:00
|
|
|
sd->item_cache_count++;
|
2013-01-25 23:11:32 -08:00
|
|
|
itc = calloc(1, sizeof(Item_Cache));
|
|
|
|
if (!itc)
|
|
|
|
{
|
|
|
|
evas_event_thaw(evas_object_evas_get(obj));
|
|
|
|
evas_event_thaw_eval(evas_object_evas_get(obj));
|
|
|
|
return;
|
|
|
|
}
|
2013-05-02 11:13:36 -07:00
|
|
|
sd->item_cache =
|
|
|
|
eina_inlist_prepend(sd->item_cache, EINA_INLIST_GET(itc));
|
2013-01-25 23:11:32 -08:00
|
|
|
itc->spacer = it->spacer;
|
|
|
|
it->spacer = NULL;
|
|
|
|
itc->base_view = VIEW(it);
|
|
|
|
|
|
|
|
VIEW(it) = NULL;
|
|
|
|
edje_object_signal_emit(itc->base_view, "elm,state,unselected", "elm");
|
|
|
|
evas_object_hide(itc->base_view);
|
|
|
|
evas_object_move(itc->base_view, -9999, -9999);
|
|
|
|
itc->item_style = eina_stringshare_add(it->itc->item_style);
|
|
|
|
if (it->item->type & ELM_GENLIST_ITEM_TREE) itc->tree = 1;
|
|
|
|
itc->selected = it->selected;
|
|
|
|
itc->disabled = elm_widget_item_disabled_get(it);
|
|
|
|
itc->expanded = it->item->expanded;
|
2013-05-29 04:54:11 -07:00
|
|
|
ELM_SAFE_FREE(it->long_timer, ecore_timer_del);
|
|
|
|
ELM_SAFE_FREE(it->item->swipe_timer, ecore_timer_del);
|
2013-05-21 10:24:02 -07:00
|
|
|
|
2013-01-25 23:11:32 -08:00
|
|
|
// FIXME: other callbacks?
|
|
|
|
edje_object_signal_callback_del_full
|
|
|
|
(itc->base_view, "elm,action,expand,toggle", "elm",
|
|
|
|
_expand_toggle_signal_cb, it);
|
|
|
|
edje_object_signal_callback_del_full
|
|
|
|
(itc->base_view, "elm,action,expand", "elm", _expand_signal_cb, it);
|
|
|
|
edje_object_signal_callback_del_full
|
|
|
|
(itc->base_view, "elm,action,contract", "elm", _contract_signal_cb, it);
|
|
|
|
_item_mouse_callbacks_del(it, itc->base_view);
|
2013-05-02 11:13:36 -07:00
|
|
|
_item_cache_clean(sd);
|
2013-01-25 23:11:32 -08:00
|
|
|
|
|
|
|
evas_event_thaw(evas_object_evas_get(obj));
|
|
|
|
evas_event_thaw_eval(evas_object_evas_get(obj));
|
|
|
|
}
|
|
|
|
|
|
|
|
// find an item from item cache and remove it from the cache
|
|
|
|
static Item_Cache *
|
|
|
|
_item_cache_find(Elm_Gen_Item *it)
|
|
|
|
{
|
|
|
|
Item_Cache *itc = NULL;
|
|
|
|
Eina_Inlist *l;
|
|
|
|
Eina_Bool tree = 0;
|
2013-05-02 11:13:36 -07:00
|
|
|
ELM_GENLIST_DATA_GET_FROM_ITEM(it, sd);
|
2013-01-25 23:11:32 -08:00
|
|
|
|
|
|
|
if (it->item->type & ELM_GENLIST_ITEM_TREE) tree = 1;
|
2013-05-02 11:13:36 -07:00
|
|
|
EINA_INLIST_FOREACH_SAFE(sd->item_cache, l, itc)
|
2013-01-25 23:11:32 -08:00
|
|
|
{
|
|
|
|
if ((itc->selected) || (itc->disabled) || (itc->expanded))
|
|
|
|
continue;
|
|
|
|
|
|
|
|
if ((itc->tree == tree) &&
|
|
|
|
(((!it->itc->item_style) && (!itc->item_style)) ||
|
|
|
|
(it->itc->item_style && itc->item_style &&
|
|
|
|
(!strcmp(it->itc->item_style, itc->item_style)))))
|
|
|
|
{
|
2013-05-02 11:13:36 -07:00
|
|
|
sd->item_cache =
|
|
|
|
eina_inlist_remove (sd->item_cache, EINA_INLIST_GET(itc));
|
|
|
|
sd->item_cache_count--;
|
2013-01-25 23:11:32 -08:00
|
|
|
|
|
|
|
return itc;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
2012-07-16 14:56:30 -07:00
|
|
|
static Eina_List *
|
|
|
|
_item_content_realize(Elm_Gen_Item *it,
|
|
|
|
Evas_Object *target,
|
|
|
|
Eina_List **source,
|
|
|
|
const char *parts)
|
2012-04-06 00:10:20 -07:00
|
|
|
{
|
2012-07-16 14:56:30 -07:00
|
|
|
Eina_List *res = it->content_objs;
|
2012-04-06 00:10:20 -07:00
|
|
|
|
|
|
|
if (it->itc->func.content_get)
|
|
|
|
{
|
|
|
|
const Eina_List *l;
|
|
|
|
const char *key;
|
2012-07-16 14:56:30 -07:00
|
|
|
Evas_Object *ic = NULL;
|
|
|
|
|
|
|
|
if (!(*source))
|
|
|
|
*source = elm_widget_stringlist_get
|
|
|
|
(edje_object_data_get(target, "contents"));
|
2012-04-06 00:10:20 -07:00
|
|
|
|
2012-10-01 00:36:27 -07:00
|
|
|
EINA_LIST_FOREACH(*source, l, key)
|
2012-04-06 00:10:20 -07:00
|
|
|
{
|
|
|
|
if (parts && fnmatch(parts, key, FNM_PERIOD))
|
|
|
|
continue;
|
|
|
|
|
2012-07-16 14:56:30 -07:00
|
|
|
if (it->itc->func.content_get)
|
|
|
|
ic = it->itc->func.content_get
|
|
|
|
((void *)it->base.data, WIDGET(it), key);
|
2012-04-06 00:10:20 -07:00
|
|
|
if (ic)
|
|
|
|
{
|
|
|
|
res = eina_list_append(res, ic);
|
|
|
|
edje_object_part_swallow(target, key, ic);
|
|
|
|
evas_object_show(ic);
|
|
|
|
elm_widget_sub_object_add(WIDGET(it), ic);
|
2012-05-30 01:09:09 -07:00
|
|
|
if (elm_widget_item_disabled_get(it))
|
|
|
|
elm_widget_disabled_set(ic, EINA_TRUE);
|
2012-04-06 00:10:20 -07:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return res;
|
|
|
|
}
|
|
|
|
|
2012-08-18 06:52:03 -07:00
|
|
|
static char *
|
2014-01-06 06:30:02 -08:00
|
|
|
_access_info_cb(void *data, Evas_Object *obj EINA_UNUSED)
|
2012-08-18 06:52:03 -07:00
|
|
|
{
|
2013-01-18 23:31:42 -08:00
|
|
|
char *ret;
|
|
|
|
Eina_Strbuf *buf;
|
|
|
|
|
2012-08-18 06:52:03 -07:00
|
|
|
Elm_Gen_Item *it = (Elm_Gen_Item *)data;
|
|
|
|
ELM_GENLIST_ITEM_CHECK_OR_RETURN(it, NULL);
|
|
|
|
|
2013-01-18 23:31:42 -08:00
|
|
|
buf = eina_strbuf_new();
|
|
|
|
|
2012-08-18 06:52:03 -07:00
|
|
|
if (it->itc->func.text_get)
|
|
|
|
{
|
|
|
|
const Eina_List *l;
|
|
|
|
const char *key;
|
|
|
|
|
|
|
|
if (!(it->texts)) it->texts =
|
|
|
|
elm_widget_stringlist_get(edje_object_data_get(VIEW(it), "texts"));
|
|
|
|
|
|
|
|
EINA_LIST_FOREACH(it->texts, l, key)
|
|
|
|
{
|
|
|
|
char *s = it->itc->func.text_get
|
|
|
|
((void *)it->base.data, WIDGET(it), key);
|
2013-01-18 23:31:42 -08:00
|
|
|
|
|
|
|
if (s)
|
|
|
|
{
|
|
|
|
if (eina_strbuf_length_get(buf) > 0) eina_strbuf_append(buf, ", ");
|
|
|
|
eina_strbuf_append(buf, s);
|
|
|
|
free(s);
|
|
|
|
}
|
2012-08-18 06:52:03 -07:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2013-01-18 23:31:42 -08:00
|
|
|
ret = eina_strbuf_string_steal(buf);
|
|
|
|
eina_strbuf_free(buf);
|
|
|
|
return ret;
|
2012-08-18 06:52:03 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
static char *
|
2014-01-06 06:30:02 -08:00
|
|
|
_access_state_cb(void *data, Evas_Object *obj EINA_UNUSED)
|
2012-08-18 06:52:03 -07:00
|
|
|
{
|
|
|
|
Elm_Gen_Item *it = (Elm_Gen_Item *)data;
|
|
|
|
ELM_GENLIST_ITEM_CHECK_OR_RETURN(it, NULL);
|
|
|
|
|
|
|
|
if (it->base.disabled)
|
|
|
|
return strdup(E_("State: Disabled"));
|
|
|
|
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
_access_on_highlight_cb(void *data)
|
|
|
|
{
|
|
|
|
Evas_Coord x, y, w, h;
|
|
|
|
Evas_Coord sx, sy, sw, sh;
|
|
|
|
Elm_Gen_Item *it = (Elm_Gen_Item *)data;
|
|
|
|
ELM_GENLIST_ITEM_CHECK_OR_RETURN(it);
|
|
|
|
|
|
|
|
evas_object_geometry_get(it->base.view, &x, &y, &w, &h);
|
|
|
|
// XXX There would be a reason.
|
|
|
|
if ((w == 0) && (h == 0)) return;
|
|
|
|
|
2012-11-25 22:32:53 -08:00
|
|
|
evas_object_geometry_get(it->base.widget, &sx, &sy, &sw, &sh);
|
2012-08-18 06:52:03 -07:00
|
|
|
if ((x < sx) || (y < sy) || ((x + w) > (sx + sw)) || ((y + h) > (sy + sh)))
|
|
|
|
elm_genlist_item_bring_in((Elm_Object_Item *)it,
|
|
|
|
ELM_GENLIST_ITEM_SCROLLTO_IN);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
_access_widget_item_register(Elm_Gen_Item *it)
|
|
|
|
{
|
|
|
|
Elm_Access_Info *ai;
|
|
|
|
|
|
|
|
_elm_access_widget_item_register((Elm_Widget_Item *)it);
|
|
|
|
|
2013-07-30 20:53:04 -07:00
|
|
|
ai = _elm_access_info_get(it->base.access_obj);
|
2012-08-18 06:52:03 -07:00
|
|
|
|
|
|
|
_elm_access_callback_set(ai, ELM_ACCESS_INFO, _access_info_cb, it);
|
|
|
|
_elm_access_callback_set(ai, ELM_ACCESS_STATE, _access_state_cb, it);
|
|
|
|
_elm_access_on_highlight_hook_set(ai, _access_on_highlight_cb, it);
|
2012-11-16 01:17:56 -08:00
|
|
|
_elm_access_activate_callback_set(ai, _access_activate_cb, it);
|
2012-08-18 06:52:03 -07:00
|
|
|
}
|
|
|
|
|
2012-07-16 14:56:30 -07:00
|
|
|
static void
|
|
|
|
_item_realize(Elm_Gen_Item *it,
|
|
|
|
int in,
|
|
|
|
Eina_Bool calc)
|
2012-04-06 00:10:20 -07:00
|
|
|
{
|
2012-10-22 07:34:43 -07:00
|
|
|
Item_Cache *itc = NULL;
|
2012-07-16 14:56:30 -07:00
|
|
|
const char *treesize;
|
|
|
|
char buf[1024];
|
|
|
|
int tsize = 20;
|
2013-05-02 11:13:36 -07:00
|
|
|
ELM_GENLIST_DATA_GET_FROM_ITEM(it, sd);
|
2012-04-06 00:10:20 -07:00
|
|
|
|
2013-05-02 11:13:36 -07:00
|
|
|
if (it->generation < sd->generation) return;
|
2012-07-16 14:56:30 -07:00
|
|
|
if (it->realized)
|
2012-04-06 00:10:20 -07:00
|
|
|
{
|
2012-07-16 14:56:30 -07:00
|
|
|
if (it->item->order_num_in != in)
|
2012-04-06 00:10:20 -07:00
|
|
|
{
|
2012-07-16 14:56:30 -07:00
|
|
|
_item_order_update(EINA_INLIST_GET(it), in);
|
|
|
|
_elm_genlist_item_state_update(it, NULL);
|
|
|
|
_elm_genlist_item_index_update(it);
|
2012-04-06 00:10:20 -07:00
|
|
|
}
|
2012-07-16 14:56:30 -07:00
|
|
|
return;
|
2012-04-06 00:10:20 -07:00
|
|
|
}
|
2012-07-16 14:56:30 -07:00
|
|
|
it->item->order_num_in = in;
|
2012-04-06 00:10:20 -07:00
|
|
|
|
2012-10-22 07:34:43 -07:00
|
|
|
if (it->item->nocache_once)
|
|
|
|
it->item->nocache_once = EINA_FALSE;
|
|
|
|
else if (!it->item->nocache)
|
|
|
|
itc = _item_cache_find(it);
|
2013-05-02 11:13:36 -07:00
|
|
|
if (itc && (!sd->tree_effect_enabled))
|
2012-10-22 07:34:43 -07:00
|
|
|
{
|
|
|
|
VIEW(it) = itc->base_view;
|
|
|
|
itc->base_view = NULL;
|
|
|
|
it->spacer = itc->spacer;
|
|
|
|
itc->spacer = NULL;
|
|
|
|
}
|
|
|
|
else
|
2012-07-16 14:56:30 -07:00
|
|
|
{
|
|
|
|
const char *stacking_even;
|
|
|
|
const char *stacking;
|
2011-04-22 02:56:49 -07:00
|
|
|
|
2012-07-16 14:56:30 -07:00
|
|
|
VIEW(it) = edje_object_add(evas_object_evas_get(WIDGET(it)));
|
|
|
|
edje_object_scale_set(VIEW(it),
|
|
|
|
elm_widget_scale_get(WIDGET(it)) *
|
|
|
|
elm_config_scale_get());
|
2013-05-02 11:13:36 -07:00
|
|
|
evas_object_smart_member_add(VIEW(it), sd->pan_obj);
|
2012-07-16 14:56:30 -07:00
|
|
|
elm_widget_sub_object_add(WIDGET(it), VIEW(it));
|
2011-11-29 06:03:14 -08:00
|
|
|
|
2012-07-16 14:56:30 -07:00
|
|
|
if (it->item->type & ELM_GENLIST_ITEM_TREE)
|
|
|
|
snprintf(buf, sizeof(buf), "tree%s/%s",
|
2013-05-02 11:13:36 -07:00
|
|
|
sd->mode == ELM_LIST_COMPRESS ? "_compress" :
|
2012-07-16 14:56:30 -07:00
|
|
|
"", it->itc->item_style ? : "default");
|
|
|
|
else
|
|
|
|
snprintf(buf, sizeof(buf), "item%s/%s",
|
2013-05-02 11:13:36 -07:00
|
|
|
sd->mode == ELM_LIST_COMPRESS ? "_compress" :
|
2012-07-16 14:56:30 -07:00
|
|
|
"", it->itc->item_style ? : "default");
|
2011-04-22 02:56:49 -07:00
|
|
|
|
2014-01-08 02:07:07 -08:00
|
|
|
if (!elm_widget_theme_object_set(WIDGET(it), VIEW(it),
|
|
|
|
"genlist", buf,
|
|
|
|
elm_widget_style_get(WIDGET(it))))
|
|
|
|
{
|
|
|
|
ERR("%s is not a valid genlist item style. "
|
|
|
|
"Automatically falls back into default style.",
|
|
|
|
it->itc->item_style);
|
|
|
|
elm_widget_theme_object_set
|
|
|
|
(WIDGET(it), VIEW(it), "genlist", "item/default", "default");
|
|
|
|
}
|
|
|
|
|
2011-04-22 02:56:22 -07:00
|
|
|
|
2011-10-20 18:08:01 -07:00
|
|
|
stacking_even = edje_object_data_get(VIEW(it), "stacking_even");
|
2011-04-22 05:22:57 -07:00
|
|
|
if (!stacking_even) stacking_even = "above";
|
2011-10-21 01:52:03 -07:00
|
|
|
it->item->stacking_even = !!strcmp("above", stacking_even);
|
2011-04-22 02:56:22 -07:00
|
|
|
|
2011-10-20 18:08:01 -07:00
|
|
|
stacking = edje_object_data_get(VIEW(it), "stacking");
|
2011-04-22 05:22:57 -07:00
|
|
|
if (!stacking) stacking = "yes";
|
2011-10-21 01:52:03 -07:00
|
|
|
it->item->nostacking = !!strcmp("yes", stacking);
|
2011-04-22 02:56:22 -07:00
|
|
|
|
2012-07-16 14:56:30 -07:00
|
|
|
edje_object_mirrored_set
|
|
|
|
(VIEW(it), elm_widget_mirrored_get(WIDGET(it)));
|
2010-11-05 23:02:22 -07:00
|
|
|
}
|
2011-04-22 02:56:22 -07:00
|
|
|
|
2013-01-10 04:00:05 -08:00
|
|
|
/* access */
|
|
|
|
if (_elm_config->access_mode) _access_widget_item_register(it);
|
2012-08-18 06:52:03 -07:00
|
|
|
|
2012-05-30 02:14:45 -07:00
|
|
|
_item_order_update(EINA_INLIST_GET(it), in);
|
2011-04-22 02:56:22 -07:00
|
|
|
|
2013-03-14 03:13:06 -07:00
|
|
|
if (!(it->deco_all_view) && (it->item->type != ELM_GENLIST_ITEM_GROUP))
|
|
|
|
{
|
2013-05-02 11:13:36 -07:00
|
|
|
if (sd->reorder_mode)
|
2013-03-14 03:13:06 -07:00
|
|
|
edje_object_signal_emit
|
|
|
|
(VIEW(it), "elm,state,reorder,mode_set", "elm");
|
|
|
|
else
|
|
|
|
edje_object_signal_emit
|
|
|
|
(VIEW(it), "elm,state,reorder,mode_unset", "elm");
|
|
|
|
}
|
2011-10-20 18:08:01 -07:00
|
|
|
treesize = edje_object_data_get(VIEW(it), "treesize");
|
2009-03-14 11:03:19 -07:00
|
|
|
if (treesize) tsize = atoi(treesize);
|
2013-09-05 21:08:21 -07:00
|
|
|
|
|
|
|
if (edje_object_part_exists(VIEW(it), "elm.swallow.pad"))
|
2012-03-19 22:44:18 -07:00
|
|
|
{
|
2013-09-05 21:08:21 -07:00
|
|
|
if (!it->spacer && treesize)
|
|
|
|
{
|
|
|
|
it->spacer =
|
|
|
|
evas_object_rectangle_add(evas_object_evas_get(WIDGET(it)));
|
|
|
|
evas_object_color_set(it->spacer, 0, 0, 0, 0);
|
|
|
|
elm_widget_sub_object_add(WIDGET(it), it->spacer);
|
|
|
|
}
|
|
|
|
|
2012-07-16 14:56:30 -07:00
|
|
|
evas_object_size_hint_min_set
|
2013-09-05 21:08:21 -07:00
|
|
|
(it->spacer, (it->item->expanded_depth * tsize) *
|
|
|
|
elm_config_scale_get(), 1);
|
2012-03-19 22:44:18 -07:00
|
|
|
edje_object_part_swallow(VIEW(it), "elm.swallow.pad", it->spacer);
|
|
|
|
}
|
2013-09-05 21:08:21 -07:00
|
|
|
else
|
|
|
|
{
|
|
|
|
ELM_SAFE_FREE(it->spacer, evas_object_del);
|
|
|
|
}
|
|
|
|
|
2009-02-12 05:39:43 -08:00
|
|
|
if (!calc)
|
|
|
|
{
|
2012-07-16 14:56:30 -07:00
|
|
|
edje_object_signal_callback_add
|
|
|
|
(VIEW(it), "elm,action,expand,toggle", "elm",
|
|
|
|
_expand_toggle_signal_cb, it);
|
|
|
|
edje_object_signal_callback_add
|
|
|
|
(VIEW(it), "elm,action,expand", "elm", _expand_signal_cb, it);
|
|
|
|
edje_object_signal_callback_add
|
|
|
|
(VIEW(it), "elm,action,contract", "elm", _contract_signal_cb, it);
|
2012-03-20 00:58:42 -07:00
|
|
|
_item_mouse_callbacks_add(it, VIEW(it));
|
2011-04-22 02:56:22 -07:00
|
|
|
|
2013-05-02 11:13:36 -07:00
|
|
|
if ((sd->decorate_all_mode) && (!it->deco_all_view) &&
|
2012-06-21 01:36:21 -07:00
|
|
|
(it->item->type != ELM_GENLIST_ITEM_GROUP) &&
|
2012-06-18 02:54:00 -07:00
|
|
|
(it->itc->decorate_all_item_style))
|
2012-04-03 02:56:49 -07:00
|
|
|
_decorate_all_item_realize(it, EINA_FALSE);
|
2012-10-22 07:34:43 -07:00
|
|
|
|
|
|
|
_elm_genlist_item_state_update(it, itc);
|
2011-12-26 06:30:21 -08:00
|
|
|
_elm_genlist_item_index_update(it);
|
2009-02-11 03:49:43 -08:00
|
|
|
}
|
2009-07-06 23:46:51 -07:00
|
|
|
|
2013-11-21 18:06:37 -08:00
|
|
|
/* homogeneous genlist shortcut */
|
2013-05-02 11:13:36 -07:00
|
|
|
if ((calc) && (sd->homogeneous) && (!it->item->mincalcd) &&
|
|
|
|
((it->group && sd->group_item_width) ||
|
|
|
|
(!it->group && sd->item_width)))
|
2009-02-11 03:49:43 -08:00
|
|
|
{
|
2012-06-26 20:23:52 -07:00
|
|
|
if (it->group)
|
2011-03-29 05:43:03 -07:00
|
|
|
{
|
2013-05-02 11:13:36 -07:00
|
|
|
it->item->w = it->item->minw = sd->group_item_width;
|
|
|
|
it->item->h = it->item->minh = sd->group_item_height;
|
2011-03-29 05:43:03 -07:00
|
|
|
}
|
2012-06-26 20:23:52 -07:00
|
|
|
else
|
|
|
|
{
|
2013-05-02 11:13:36 -07:00
|
|
|
it->item->w = it->item->minw = sd->item_width;
|
|
|
|
it->item->h = it->item->minh = sd->item_height;
|
2012-06-26 20:23:52 -07:00
|
|
|
}
|
|
|
|
it->item->mincalcd = EINA_TRUE;
|
2009-02-11 03:49:43 -08:00
|
|
|
}
|
2010-01-23 01:07:20 -08:00
|
|
|
else
|
2009-02-14 18:53:56 -08:00
|
|
|
{
|
2012-07-16 14:56:30 -07:00
|
|
|
if (eina_list_count(it->content_objs) != 0)
|
|
|
|
ERR_ABORT("If you see this error, please notify us and we"
|
|
|
|
"will fix it");
|
2010-10-15 04:51:15 -07:00
|
|
|
|
2011-12-15 07:24:17 -08:00
|
|
|
_item_text_realize(it, VIEW(it), &it->texts, NULL);
|
2012-07-16 14:56:30 -07:00
|
|
|
it->content_objs =
|
|
|
|
_item_content_realize(it, VIEW(it), &it->contents, NULL);
|
2013-12-16 10:34:59 -08:00
|
|
|
if (it->has_contents != (!!it->content_objs))
|
|
|
|
it->item->mincalcd = EINA_FALSE;
|
|
|
|
it->has_contents = !!it->content_objs;
|
2011-11-29 06:03:14 -08:00
|
|
|
_item_state_realize(it, VIEW(it), &it->states, NULL);
|
elm genlist: Added elm_genlist_item_flip_get/set APIs. Patch by
Hyoyoung Chang <hyoyoung@gmail.com>
On Wed, Feb 29, 2012 at 9:17 PM, Hyoyoung Chang <hyoyoung@gmail.com>
wrote:
> Dear all.
>
> I made a patch to introduce new genlist item mode.
> Two public apis are added.
> +EAPI void elm_genlist_item_flip_set(Elm_Object_Item *it, Eina_Bool
flip);
> +EAPI Eina_Bool elm_genlist_item_flip_get(Elm_Object_Item *it);
>
> It provides on-the-flying item change. It works like that a new item
> added on existed item.
> In elementary test, you can test it.
> It's useful at adding widgets or show buttons in genlist item.
>
> Thanks.
On Mon, Mar 5, 2012 at 5:56 PM, Hyoyoung Chang <hyoyoung@gmail.com>
wrote:
> Hello, I modifed fliP_set api to use ecore_job.
> It resolved version of mouse_{move, up} bugs.
>
SVN revision: 68727
2012-03-05 07:03:12 -08:00
|
|
|
if (it->flipped)
|
|
|
|
{
|
2012-07-16 14:56:30 -07:00
|
|
|
edje_object_signal_emit
|
|
|
|
(VIEW(it), "elm,state,flip,enabled", "elm");
|
2012-04-06 00:10:29 -07:00
|
|
|
if (!(it->item->flip_contents))
|
2012-07-16 14:56:30 -07:00
|
|
|
it->item->flip_contents = elm_widget_stringlist_get
|
|
|
|
(edje_object_data_get(VIEW(it), "flips"));
|
|
|
|
it->item->flip_content_objs = _item_mode_content_realize
|
|
|
|
(it, VIEW(it), &it->item->flip_contents, NULL,
|
|
|
|
&it->item->flip_content_objs);
|
elm genlist: Added elm_genlist_item_flip_get/set APIs. Patch by
Hyoyoung Chang <hyoyoung@gmail.com>
On Wed, Feb 29, 2012 at 9:17 PM, Hyoyoung Chang <hyoyoung@gmail.com>
wrote:
> Dear all.
>
> I made a patch to introduce new genlist item mode.
> Two public apis are added.
> +EAPI void elm_genlist_item_flip_set(Elm_Object_Item *it, Eina_Bool
flip);
> +EAPI Eina_Bool elm_genlist_item_flip_get(Elm_Object_Item *it);
>
> It provides on-the-flying item change. It works like that a new item
> added on existed item.
> In elementary test, you can test it.
> It's useful at adding widgets or show buttons in genlist item.
>
> Thanks.
On Mon, Mar 5, 2012 at 5:56 PM, Hyoyoung Chang <hyoyoung@gmail.com>
wrote:
> Hello, I modifed fliP_set api to use ecore_job.
> It resolved version of mouse_{move, up} bugs.
>
SVN revision: 68727
2012-03-05 07:03:12 -08:00
|
|
|
}
|
2010-10-15 04:51:15 -07:00
|
|
|
|
2013-01-18 21:09:34 -08:00
|
|
|
/* access: unregister item which have no text and content */
|
|
|
|
if (_elm_config->access_mode && !it->texts && !it->contents)
|
|
|
|
_elm_access_widget_item_unregister((Elm_Widget_Item *)it);
|
|
|
|
|
2011-10-21 01:52:03 -07:00
|
|
|
if (!it->item->mincalcd)
|
2010-10-15 04:51:15 -07:00
|
|
|
{
|
|
|
|
Evas_Coord mw = -1, mh = -1;
|
2010-10-07 12:57:20 -07:00
|
|
|
|
2012-03-07 08:22:58 -08:00
|
|
|
if (it->select_mode != ELM_OBJECT_SELECT_MODE_DISPLAY_ONLY)
|
2010-12-07 11:18:14 -08:00
|
|
|
elm_coords_finger_size_adjust(1, &mw, 1, &mh);
|
2013-05-02 11:13:36 -07:00
|
|
|
if (sd->mode == ELM_LIST_COMPRESS)
|
|
|
|
mw = sd->prev_viewport_w;
|
2012-07-16 14:56:30 -07:00
|
|
|
edje_object_size_min_restricted_calc(VIEW(it), &mw, &mh, mw, mh);
|
2012-03-07 08:22:58 -08:00
|
|
|
if (it->select_mode != ELM_OBJECT_SELECT_MODE_DISPLAY_ONLY)
|
2010-12-07 11:18:14 -08:00
|
|
|
elm_coords_finger_size_adjust(1, &mw, 1, &mh);
|
2011-10-21 01:52:03 -07:00
|
|
|
it->item->w = it->item->minw = mw;
|
|
|
|
it->item->h = it->item->minh = mh;
|
|
|
|
it->item->mincalcd = EINA_TRUE;
|
2010-01-23 01:07:20 -08:00
|
|
|
|
2013-05-02 11:13:36 -07:00
|
|
|
if ((!sd->group_item_width) && (it->group))
|
elementary - entry, genlist, gengrid, image, icon, hover, frame, diskselector, index, layout, label, conform, flip, flipselector - removed white spaces
SVN revision: 58252
2011-04-01 04:32:33 -07:00
|
|
|
{
|
2013-05-02 11:13:36 -07:00
|
|
|
sd->group_item_width = mw;
|
|
|
|
sd->group_item_height = mh;
|
elementary - entry, genlist, gengrid, image, icon, hover, frame, diskselector, index, layout, label, conform, flip, flipselector - removed white spaces
SVN revision: 58252
2011-04-01 04:32:33 -07:00
|
|
|
}
|
2013-05-02 11:13:36 -07:00
|
|
|
else if ((!sd->item_width) &&
|
2012-07-16 14:56:30 -07:00
|
|
|
(it->item->type == ELM_GENLIST_ITEM_NONE))
|
2010-10-15 04:51:15 -07:00
|
|
|
{
|
2013-05-02 11:13:36 -07:00
|
|
|
sd->item_width = mw;
|
|
|
|
sd->item_height = mh;
|
2010-10-15 04:51:15 -07:00
|
|
|
}
|
|
|
|
}
|
2011-10-20 18:08:01 -07:00
|
|
|
if (!calc) evas_object_show(VIEW(it));
|
2009-02-11 03:49:43 -08:00
|
|
|
}
|
2010-09-27 11:18:37 -07:00
|
|
|
|
|
|
|
if (it->tooltip.content_cb)
|
|
|
|
{
|
2012-07-16 14:56:30 -07:00
|
|
|
elm_widget_item_tooltip_content_cb_set
|
|
|
|
(it, it->tooltip.content_cb, it->tooltip.data, NULL);
|
2010-10-15 04:51:15 -07:00
|
|
|
elm_widget_item_tooltip_style_set(it, it->tooltip.style);
|
2011-12-05 09:14:07 -08:00
|
|
|
elm_widget_item_tooltip_window_mode_set(it, it->tooltip.free_size);
|
2010-09-27 11:18:37 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
if (it->mouse_cursor)
|
|
|
|
elm_widget_item_cursor_set(it, it->mouse_cursor);
|
|
|
|
|
2009-06-17 08:35:19 -07:00
|
|
|
it->realized = EINA_TRUE;
|
2010-03-26 21:17:01 -07:00
|
|
|
it->want_unrealize = EINA_FALSE;
|
2010-11-05 23:02:22 -07:00
|
|
|
|
2012-10-22 07:34:43 -07:00
|
|
|
if (itc) _item_cache_free(itc);
|
2011-06-03 18:52:08 -07:00
|
|
|
if (!calc)
|
2012-03-23 00:47:03 -07:00
|
|
|
{
|
2012-07-16 14:56:30 -07:00
|
|
|
if (it->item->tree_effect_hide_me)
|
2012-03-23 00:47:03 -07:00
|
|
|
{
|
2013-05-02 11:13:36 -07:00
|
|
|
if (sd->move_effect_mode
|
2012-07-16 14:56:30 -07:00
|
|
|
!= ELM_GENLIST_TREE_EFFECT_NONE)
|
2013-10-05 05:35:27 -07:00
|
|
|
{
|
|
|
|
edje_object_signal_emit(VIEW(it), "elm,state,hide", ""); // XXX: for compat
|
|
|
|
edje_object_signal_emit(VIEW(it), "elm,state,hide", "elm");
|
|
|
|
}
|
2012-07-16 14:56:30 -07:00
|
|
|
it->item->tree_effect_hide_me = EINA_FALSE;
|
2012-03-23 00:47:03 -07:00
|
|
|
}
|
2013-02-20 02:00:49 -08:00
|
|
|
|
|
|
|
if (it->item->type == ELM_GENLIST_ITEM_NONE)
|
|
|
|
{
|
|
|
|
Evas_Object* eobj;
|
|
|
|
Eina_List* l;
|
|
|
|
EINA_LIST_FOREACH(it->content_objs, l, eobj)
|
|
|
|
if (elm_object_focus_allow_get(eobj))
|
|
|
|
it->item_focus_chain = eina_list_append
|
|
|
|
(it->item_focus_chain, eobj);
|
|
|
|
|
|
|
|
}
|
|
|
|
|
2012-03-23 00:47:03 -07:00
|
|
|
evas_object_smart_callback_call(WIDGET(it), SIG_REALIZED, it);
|
|
|
|
}
|
2012-02-22 23:39:10 -08:00
|
|
|
|
2013-05-02 11:13:36 -07:00
|
|
|
if ((!calc) && (sd->decorate_all_mode) &&
|
2012-07-16 14:56:30 -07:00
|
|
|
(it->item->type != ELM_GENLIST_ITEM_GROUP))
|
2012-02-22 23:39:10 -08:00
|
|
|
{
|
2012-03-09 04:00:28 -08:00
|
|
|
if (it->itc->decorate_all_item_style)
|
2012-02-22 23:39:10 -08:00
|
|
|
{
|
2012-06-18 02:54:00 -07:00
|
|
|
if (!it->deco_all_view)
|
|
|
|
_decorate_all_item_realize(it, EINA_FALSE);
|
2012-04-06 00:10:26 -07:00
|
|
|
edje_object_message_signal_process(it->deco_all_view);
|
2012-02-22 23:39:10 -08:00
|
|
|
}
|
|
|
|
}
|
2013-12-02 02:43:46 -08:00
|
|
|
|
2013-11-29 02:18:00 -08:00
|
|
|
if (it->decorate_it_set) _decorate_item_set(it);
|
2013-12-02 02:43:46 -08:00
|
|
|
|
2014-03-08 08:04:34 -08:00
|
|
|
if (!calc)
|
|
|
|
_elm_widget_item_highlight_in_theme(WIDGET(it), (Elm_Object_Item *)it);
|
|
|
|
|
2011-10-20 18:08:01 -07:00
|
|
|
edje_object_message_signal_process(VIEW(it));
|
2009-02-11 03:49:43 -08:00
|
|
|
}
|
|
|
|
|
2012-07-16 14:56:30 -07:00
|
|
|
static Eina_Bool
|
|
|
|
_tree_effect_animator_cb(void *data)
|
2009-02-11 03:49:43 -08:00
|
|
|
{
|
2012-07-16 14:56:30 -07:00
|
|
|
int in = 0;
|
|
|
|
const Eina_List *l;
|
|
|
|
int y = 0, dy = 0, dh = 0;
|
|
|
|
double effect_duration = 0.3, t;
|
2013-04-24 04:41:37 -07:00
|
|
|
ELM_GENLIST_DATA_GET(data, sd);
|
2012-07-16 14:56:30 -07:00
|
|
|
Eina_Bool end = EINA_FALSE, vis = EINA_TRUE;
|
|
|
|
Evas_Coord ox, oy, ow, oh, cvx, cvy, cvw, cvh;
|
|
|
|
Elm_Gen_Item *it = NULL, *it2, *expanded_next_it;
|
2012-04-20 01:44:48 -07:00
|
|
|
|
2012-07-16 14:56:30 -07:00
|
|
|
t = ((0.0 > (t = ecore_time_get() - sd->start_time)) ? 0.0 : t);
|
|
|
|
evas_object_geometry_get(sd->pan_obj, &ox, &oy, &ow, &oh);
|
|
|
|
evas_output_viewport_get
|
|
|
|
(evas_object_evas_get(sd->pan_obj), &cvx, &cvy, &cvw, &cvh);
|
|
|
|
if (t > effect_duration) end = EINA_TRUE;
|
|
|
|
|
|
|
|
// Below while statement is needed, when the genlist is resized.
|
|
|
|
it2 = sd->expanded_item;
|
|
|
|
while (it2 && vis)
|
2011-02-08 04:08:28 -08:00
|
|
|
{
|
2012-07-16 14:56:30 -07:00
|
|
|
evas_object_move(VIEW(it2), it2->item->scrl_x, it2->item->scrl_y);
|
|
|
|
vis = (ELM_RECTS_INTERSECT(it2->item->scrl_x, it2->item->scrl_y,
|
|
|
|
it2->item->w, it2->item->h, cvx, cvy, cvw,
|
|
|
|
cvh));
|
|
|
|
it2 =
|
|
|
|
(Elm_Gen_Item *)elm_genlist_item_prev_get((Elm_Object_Item *)it2);
|
2011-02-08 04:08:28 -08:00
|
|
|
}
|
2009-02-25 12:18:38 -08:00
|
|
|
|
2012-07-16 14:56:30 -07:00
|
|
|
if (sd->expanded_next_item)
|
2009-02-11 03:49:43 -08:00
|
|
|
{
|
2012-07-16 14:56:30 -07:00
|
|
|
expanded_next_it = sd->expanded_next_item;
|
|
|
|
|
|
|
|
/* move items */
|
2012-10-01 00:36:27 -07:00
|
|
|
EINA_LIST_FOREACH(sd->move_items, l, it)
|
2010-10-15 04:51:15 -07:00
|
|
|
{
|
2012-07-16 14:56:30 -07:00
|
|
|
if (sd->move_effect_mode == ELM_GENLIST_TREE_EFFECT_EXPAND)
|
2010-01-23 01:07:20 -08:00
|
|
|
{
|
2012-07-16 14:56:30 -07:00
|
|
|
expanded_next_it->item->old_scrl_y =
|
|
|
|
sd->expanded_item->item->old_scrl_y
|
|
|
|
+ sd->expanded_item->item->h;
|
|
|
|
if (expanded_next_it->item->scrl_y <=
|
|
|
|
expanded_next_it->item->old_scrl_y) /* did not
|
|
|
|
* calculate
|
|
|
|
* next item
|
|
|
|
* position */
|
|
|
|
expanded_next_it->item->scrl_y = cvy + cvh;
|
|
|
|
|
|
|
|
dy = ((expanded_next_it->item->scrl_y >= (cvy + cvh)) ?
|
|
|
|
cvy + cvh : expanded_next_it->item->scrl_y) -
|
|
|
|
expanded_next_it->item->old_scrl_y;
|
2010-01-23 01:07:20 -08:00
|
|
|
}
|
2012-07-16 14:56:30 -07:00
|
|
|
else if (sd->move_effect_mode == ELM_GENLIST_TREE_EFFECT_CONTRACT)
|
2010-01-23 01:07:20 -08:00
|
|
|
{
|
2012-07-16 14:56:30 -07:00
|
|
|
if (expanded_next_it->item->scrl_y >
|
|
|
|
expanded_next_it->item->old_scrl_y) /* did not
|
|
|
|
* calculate
|
|
|
|
* next item
|
|
|
|
* position */
|
|
|
|
expanded_next_it->item->old_scrl_y = cvy + cvh;
|
|
|
|
|
|
|
|
if (expanded_next_it->item->old_scrl_y > (cvy + cvh))
|
2012-05-15 22:28:40 -07:00
|
|
|
{
|
2012-07-16 14:56:30 -07:00
|
|
|
dy = (sd->expanded_item->item->scrl_y +
|
|
|
|
sd->expanded_item->item->h) - cvy + cvh;
|
|
|
|
expanded_next_it->item->old_scrl_y = cvy + cvh;
|
2012-05-15 22:28:40 -07:00
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
2012-07-16 14:56:30 -07:00
|
|
|
dy = (sd->expanded_item->item->scrl_y +
|
|
|
|
sd->expanded_item->item->h) -
|
|
|
|
expanded_next_it->item->old_scrl_y;
|
2012-05-15 22:28:40 -07:00
|
|
|
}
|
2010-01-23 01:07:20 -08:00
|
|
|
}
|
2009-02-11 03:49:43 -08:00
|
|
|
|
2012-07-16 14:56:30 -07:00
|
|
|
if (t <= effect_duration)
|
|
|
|
{
|
|
|
|
y = ((1 - (1 - (t / effect_duration)) *
|
|
|
|
(1 - (t / effect_duration))) * dy);
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
end = EINA_TRUE;
|
|
|
|
y = dy;
|
|
|
|
}
|
2009-02-11 03:49:43 -08:00
|
|
|
|
2012-07-16 14:56:30 -07:00
|
|
|
if (!it->realized && !it->item->queued)
|
|
|
|
_item_realize(it, in, 0);
|
|
|
|
in++;
|
2009-02-25 11:50:45 -08:00
|
|
|
|
2012-07-16 14:56:30 -07:00
|
|
|
if (it != expanded_next_it)
|
2011-01-05 21:13:11 -08:00
|
|
|
{
|
2012-07-16 14:56:30 -07:00
|
|
|
it->item->old_scrl_y =
|
|
|
|
expanded_next_it->item->old_scrl_y +
|
|
|
|
expanded_next_it->item->h + dh;
|
|
|
|
|
|
|
|
dh += it->item->h;
|
2011-01-05 21:13:11 -08:00
|
|
|
}
|
2012-07-16 14:56:30 -07:00
|
|
|
|
|
|
|
if ((it->item->old_scrl_y + y) < (cvy + cvh))
|
|
|
|
_item_position(it, VIEW(it), it->item->scrl_x,
|
|
|
|
it->item->old_scrl_y + y);
|
2009-10-07 07:02:55 -07:00
|
|
|
}
|
2012-07-16 14:56:30 -07:00
|
|
|
/* tree effect */
|
|
|
|
_item_tree_effect(sd, y);
|
2010-03-26 21:17:01 -07:00
|
|
|
}
|
|
|
|
else
|
2012-07-16 14:56:30 -07:00
|
|
|
{
|
|
|
|
int expanded_item_num = 0;
|
|
|
|
int num = 0;
|
2009-02-11 03:49:43 -08:00
|
|
|
|
2012-07-16 14:56:30 -07:00
|
|
|
if (sd->expanded_item)
|
|
|
|
it = (Elm_Gen_Item *)elm_genlist_item_next_get
|
|
|
|
((Elm_Object_Item *)sd->expanded_item);
|
2011-06-01 21:24:58 -07:00
|
|
|
|
2012-07-16 14:56:30 -07:00
|
|
|
it2 = it;
|
|
|
|
while (it2)
|
|
|
|
{
|
|
|
|
expanded_item_num++;
|
|
|
|
it2 = (Elm_Gen_Item *)elm_genlist_item_next_get
|
|
|
|
((Elm_Object_Item *)it2);
|
|
|
|
}
|
2011-06-01 21:24:58 -07:00
|
|
|
|
2012-07-16 14:56:30 -07:00
|
|
|
while (it)
|
|
|
|
{
|
|
|
|
num++;
|
|
|
|
if (sd->expanded_item->item->expanded_depth >=
|
|
|
|
it->item->expanded_depth) break;
|
|
|
|
if (sd->move_effect_mode == ELM_GENLIST_TREE_EFFECT_EXPAND)
|
|
|
|
{
|
|
|
|
if (!it->item->tree_effect_finished)
|
|
|
|
{
|
|
|
|
if (t >= (((num - 1) * effect_duration) /
|
|
|
|
expanded_item_num))
|
|
|
|
{
|
2013-10-05 05:35:27 -07:00
|
|
|
edje_object_signal_emit(VIEW(it), "flip_item", ""); // XXX: for compat
|
|
|
|
edje_object_signal_emit(VIEW(it), "elm,action,flip_item", "elm");
|
2012-07-16 14:56:30 -07:00
|
|
|
_item_position(it, VIEW(it), it->item->scrl_x,
|
|
|
|
it->item->scrl_y);
|
|
|
|
it->item->tree_effect_finished = EINA_TRUE;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
it = (Elm_Gen_Item *)elm_genlist_item_next_get
|
|
|
|
((Elm_Object_Item *)it);
|
|
|
|
}
|
2011-06-01 20:10:11 -07:00
|
|
|
}
|
2012-07-16 14:56:30 -07:00
|
|
|
|
|
|
|
if (end)
|
2011-06-01 20:10:11 -07:00
|
|
|
{
|
2012-07-16 14:56:30 -07:00
|
|
|
_item_tree_effect_finish(sd);
|
|
|
|
return ECORE_CALLBACK_CANCEL;
|
2011-06-01 20:10:11 -07:00
|
|
|
}
|
2011-06-01 21:24:58 -07:00
|
|
|
|
2012-07-16 14:56:30 -07:00
|
|
|
return ECORE_CALLBACK_RENEW;
|
|
|
|
}
|
2011-06-01 21:24:58 -07:00
|
|
|
|
2012-07-16 14:56:30 -07:00
|
|
|
static void
|
|
|
|
_group_items_recalc(void *data)
|
|
|
|
{
|
|
|
|
Eina_List *l;
|
|
|
|
Elm_Gen_Item *git;
|
|
|
|
Elm_Genlist_Smart_Data *sd = data;
|
|
|
|
|
2012-11-25 22:32:53 -08:00
|
|
|
evas_event_freeze(evas_object_evas_get(sd->obj));
|
2012-10-01 00:36:27 -07:00
|
|
|
EINA_LIST_FOREACH(sd->group_items, l, git)
|
2011-06-01 20:10:11 -07:00
|
|
|
{
|
2012-07-16 14:56:30 -07:00
|
|
|
if (git->item->want_realize)
|
|
|
|
{
|
|
|
|
if (!git->realized) _item_realize(git, 0, EINA_FALSE);
|
|
|
|
evas_object_resize(VIEW(git), sd->minw, git->item->h);
|
|
|
|
evas_object_move(VIEW(git), git->item->scrl_x, git->item->scrl_y);
|
2013-06-22 23:17:39 -07:00
|
|
|
evas_object_stack_above(VIEW(git), sd->stack[1]);
|
2012-07-16 14:56:30 -07:00
|
|
|
evas_object_show(VIEW(git));
|
|
|
|
}
|
|
|
|
else if (!git->item->want_realize && git->realized)
|
|
|
|
{
|
|
|
|
if (!git->dragging)
|
|
|
|
_elm_genlist_item_unrealize(git, EINA_FALSE);
|
|
|
|
}
|
2011-06-01 20:10:11 -07:00
|
|
|
}
|
2012-11-25 22:32:53 -08:00
|
|
|
evas_event_thaw(evas_object_evas_get(sd->obj));
|
|
|
|
evas_event_thaw_eval(evas_object_evas_get(sd->obj));
|
2011-06-01 20:10:11 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
static Eina_Bool
|
2011-06-03 18:52:08 -07:00
|
|
|
_reorder_move_animator_cb(void *data)
|
2011-06-01 20:10:11 -07:00
|
|
|
{
|
2012-07-16 14:56:30 -07:00
|
|
|
double t;
|
2011-10-21 01:52:03 -07:00
|
|
|
Elm_Gen_Item *it = data;
|
2011-06-01 20:10:11 -07:00
|
|
|
Eina_Bool down = EINA_FALSE;
|
2013-05-02 11:13:36 -07:00
|
|
|
ELM_GENLIST_DATA_GET_FROM_ITEM(it, sd);
|
2012-07-16 14:56:30 -07:00
|
|
|
int y, dy = it->item->h / 10 * elm_config_scale_get(), diff;
|
2011-06-01 21:24:58 -07:00
|
|
|
|
2012-07-16 14:56:30 -07:00
|
|
|
t = ((0.0 > (t = ecore_loop_time_get()
|
2013-05-02 11:13:36 -07:00
|
|
|
- sd->start_time)) ? 0.0 : t);
|
2011-06-01 21:24:58 -07:00
|
|
|
|
2012-07-16 14:56:30 -07:00
|
|
|
if (t <= REORDER_EFFECT_TIME)
|
|
|
|
y = (1 * sin((t / REORDER_EFFECT_TIME) * (M_PI / 2)) * dy);
|
2011-06-01 20:10:11 -07:00
|
|
|
else y = dy;
|
2011-06-01 21:24:58 -07:00
|
|
|
|
2011-10-21 01:52:03 -07:00
|
|
|
diff = abs(it->item->old_scrl_y - it->item->scrl_y);
|
2012-09-02 23:20:47 -07:00
|
|
|
if (diff < dy) y = diff;
|
|
|
|
else if (diff > it->item->h) y = diff / 2;
|
2011-06-01 21:24:58 -07:00
|
|
|
|
2011-10-21 01:52:03 -07:00
|
|
|
if (it->item->old_scrl_y < it->item->scrl_y)
|
2011-06-01 20:10:11 -07:00
|
|
|
{
|
2011-10-21 01:52:03 -07:00
|
|
|
it->item->old_scrl_y += y;
|
2011-06-01 20:10:11 -07:00
|
|
|
down = EINA_TRUE;
|
|
|
|
}
|
2011-10-21 01:52:03 -07:00
|
|
|
else if (it->item->old_scrl_y > it->item->scrl_y)
|
2011-06-01 20:10:11 -07:00
|
|
|
{
|
2011-10-21 01:52:03 -07:00
|
|
|
it->item->old_scrl_y -= y;
|
2011-06-01 20:10:11 -07:00
|
|
|
down = EINA_FALSE;
|
|
|
|
}
|
2012-02-22 23:39:10 -08:00
|
|
|
|
2012-04-06 00:10:26 -07:00
|
|
|
if (it->deco_all_view)
|
2012-07-16 14:56:30 -07:00
|
|
|
_item_position
|
|
|
|
(it, it->deco_all_view, it->item->scrl_x, it->item->old_scrl_y);
|
2012-02-22 23:39:10 -08:00
|
|
|
else
|
|
|
|
_item_position(it, VIEW(it), it->item->scrl_x, it->item->old_scrl_y);
|
2013-05-02 11:13:36 -07:00
|
|
|
_group_items_recalc(sd);
|
2011-06-01 21:24:58 -07:00
|
|
|
|
2013-05-02 11:13:36 -07:00
|
|
|
if ((sd->reorder_pan_move) ||
|
2011-10-21 01:52:03 -07:00
|
|
|
(down && it->item->old_scrl_y >= it->item->scrl_y) ||
|
|
|
|
(!down && it->item->old_scrl_y <= it->item->scrl_y))
|
2011-06-01 20:10:11 -07:00
|
|
|
{
|
2011-10-21 01:52:03 -07:00
|
|
|
it->item->old_scrl_y = it->item->scrl_y;
|
|
|
|
it->item->move_effect_enabled = EINA_FALSE;
|
2013-05-02 11:13:36 -07:00
|
|
|
sd->reorder_move_animator = NULL;
|
2011-06-01 20:10:11 -07:00
|
|
|
return ECORE_CALLBACK_CANCEL;
|
|
|
|
}
|
2012-07-16 14:56:30 -07:00
|
|
|
|
2011-06-01 20:10:11 -07:00
|
|
|
return ECORE_CALLBACK_RENEW;
|
|
|
|
}
|
|
|
|
|
2012-07-16 14:56:30 -07:00
|
|
|
static int
|
|
|
|
_reorder_item_space_get(Elm_Gen_Item *it)
|
2011-04-21 04:47:36 -07:00
|
|
|
{
|
2013-05-02 11:13:36 -07:00
|
|
|
ELM_GENLIST_DATA_GET_FROM_ITEM(it, sd);
|
|
|
|
Elm_Gen_Item *reorder_it = sd->reorder_it;
|
2012-07-16 14:56:30 -07:00
|
|
|
Evas_Coord rox, roy, row, roh, oy, oh;
|
|
|
|
Eina_Bool top = EINA_FALSE;
|
2011-04-21 04:47:36 -07:00
|
|
|
|
2012-07-16 14:56:30 -07:00
|
|
|
if (!reorder_it) return 0;
|
|
|
|
|
2013-05-02 11:13:36 -07:00
|
|
|
evas_object_geometry_get(sd->pan_obj, NULL, &oy, NULL, &oh);
|
2012-07-16 14:56:30 -07:00
|
|
|
evas_object_geometry_get
|
2013-05-02 11:13:36 -07:00
|
|
|
(sd->VIEW(reorder_it), &rox, &roy, &row, &roh);
|
2012-07-16 14:56:30 -07:00
|
|
|
|
2013-05-02 11:13:36 -07:00
|
|
|
if ((sd->reorder_start_y < it->item->block->y) &&
|
|
|
|
(roy - oy + (roh / 2) >= it->item->block->y - sd->pan_y))
|
2012-07-16 14:56:30 -07:00
|
|
|
{
|
|
|
|
it->item->block->reorder_offset =
|
2013-05-02 11:13:36 -07:00
|
|
|
sd->reorder_it->item->h * -1;
|
2012-07-16 14:56:30 -07:00
|
|
|
if (it->item->block->count == 1)
|
2013-05-02 11:13:36 -07:00
|
|
|
sd->reorder_rel = it;
|
2012-07-16 14:56:30 -07:00
|
|
|
}
|
2013-05-02 11:13:36 -07:00
|
|
|
else if ((sd->reorder_start_y >= it->item->block->y) &&
|
|
|
|
(roy - oy + (roh / 2) <= it->item->block->y - sd->pan_y))
|
2012-07-16 14:56:30 -07:00
|
|
|
{
|
2013-05-02 11:13:36 -07:00
|
|
|
it->item->block->reorder_offset = sd->reorder_it->item->h;
|
2012-07-16 14:56:30 -07:00
|
|
|
}
|
|
|
|
else
|
|
|
|
it->item->block->reorder_offset = 0;
|
|
|
|
|
|
|
|
it->item->scrl_y += it->item->block->reorder_offset;
|
|
|
|
|
|
|
|
top = (ELM_RECTS_INTERSECT
|
|
|
|
(it->item->scrl_x, it->item->scrl_y, it->item->w, it->item->h,
|
|
|
|
rox, roy + (roh / 2), row, 1));
|
|
|
|
if (top)
|
|
|
|
{
|
2013-05-02 11:13:36 -07:00
|
|
|
sd->reorder_rel = it;
|
|
|
|
it->item->scrl_y += sd->reorder_it->item->h;
|
|
|
|
return sd->reorder_it->item->h;
|
2012-07-16 14:56:30 -07:00
|
|
|
}
|
|
|
|
else
|
|
|
|
return 0;
|
2011-04-21 04:47:36 -07:00
|
|
|
}
|
|
|
|
|
2009-02-11 03:49:43 -08:00
|
|
|
static void
|
2010-12-07 11:18:14 -08:00
|
|
|
_item_block_position(Item_Block *itb,
|
2012-07-16 14:56:30 -07:00
|
|
|
int in)
|
2009-02-11 03:49:43 -08:00
|
|
|
{
|
2011-10-21 01:52:03 -07:00
|
|
|
Elm_Gen_Item *it;
|
|
|
|
Elm_Gen_Item *git;
|
2012-07-16 14:56:30 -07:00
|
|
|
const Eina_List *l;
|
2011-11-29 00:54:19 -08:00
|
|
|
Eina_Bool vis = EINA_FALSE;
|
2012-07-16 14:56:30 -07:00
|
|
|
Evas_Coord y = 0, ox, oy, ow, oh, cvx, cvy, cvw, cvh;
|
2013-05-02 11:13:36 -07:00
|
|
|
Elm_Genlist_Smart_Data *sd = NULL;
|
2009-07-06 23:46:51 -07:00
|
|
|
|
2012-11-25 22:32:53 -08:00
|
|
|
evas_event_freeze(evas_object_evas_get((itb->sd)->obj));
|
2012-07-16 14:56:30 -07:00
|
|
|
evas_object_geometry_get(itb->sd->pan_obj, &ox, &oy, &ow, &oh);
|
|
|
|
evas_output_viewport_get
|
2012-11-25 22:32:53 -08:00
|
|
|
(evas_object_evas_get((itb->sd)->obj),
|
2012-07-16 14:56:30 -07:00
|
|
|
&cvx, &cvy, &cvw, &cvh);
|
|
|
|
|
2012-10-01 00:36:27 -07:00
|
|
|
EINA_LIST_FOREACH(itb->items, l, it)
|
2009-02-11 03:49:43 -08:00
|
|
|
{
|
2013-05-02 11:13:36 -07:00
|
|
|
sd = GL_IT(it)->wsd;
|
|
|
|
if (it->generation < sd->generation) continue;
|
|
|
|
else if (sd->reorder_it == it)
|
2012-07-16 14:56:30 -07:00
|
|
|
continue;
|
|
|
|
|
2010-10-15 04:51:15 -07:00
|
|
|
it->x = 0;
|
|
|
|
it->y = y;
|
2011-10-21 01:52:03 -07:00
|
|
|
it->item->w = itb->w;
|
2013-05-02 11:13:36 -07:00
|
|
|
it->item->scrl_x = itb->x + it->x - sd->pan_x + ox;
|
|
|
|
it->item->scrl_y = itb->y + it->y - sd->pan_y + oy;
|
2011-01-05 21:13:11 -08:00
|
|
|
|
2012-07-16 14:56:30 -07:00
|
|
|
vis = (ELM_RECTS_INTERSECT
|
|
|
|
(it->item->scrl_x, it->item->scrl_y, it->item->w, it->item->h,
|
|
|
|
cvx, cvy, cvw, cvh));
|
2011-10-23 20:40:54 -07:00
|
|
|
if (!it->group)
|
2010-10-15 04:51:15 -07:00
|
|
|
{
|
2011-01-05 21:13:11 -08:00
|
|
|
if ((itb->realized) && (!it->realized))
|
2010-10-15 04:51:15 -07:00
|
|
|
{
|
2011-03-18 08:02:49 -07:00
|
|
|
if (vis) _item_realize(it, in, EINA_FALSE);
|
2010-10-15 04:51:15 -07:00
|
|
|
}
|
2011-01-05 21:13:11 -08:00
|
|
|
if (it->realized)
|
2009-10-07 07:02:55 -07:00
|
|
|
{
|
2012-03-05 17:10:46 -08:00
|
|
|
if (vis || it->dragging)
|
2011-01-05 21:13:11 -08:00
|
|
|
{
|
2013-05-02 11:13:36 -07:00
|
|
|
if (sd->reorder_mode)
|
2012-07-16 14:56:30 -07:00
|
|
|
y += _reorder_item_space_get(it);
|
2011-10-21 01:52:03 -07:00
|
|
|
git = it->item->group_item;
|
2011-01-05 21:13:11 -08:00
|
|
|
if (git)
|
|
|
|
{
|
2011-10-21 01:52:03 -07:00
|
|
|
if (git->item->scrl_y < oy)
|
|
|
|
git->item->scrl_y = oy;
|
2012-07-16 14:56:30 -07:00
|
|
|
if ((git->item->scrl_y + git->item->h) >
|
|
|
|
(it->item->scrl_y + it->item->h))
|
|
|
|
git->item->scrl_y = (it->item->scrl_y +
|
|
|
|
it->item->h) - git->item->h;
|
2012-06-17 10:20:23 -07:00
|
|
|
git->item->scrl_x = it->item->scrl_x;
|
2011-10-21 01:52:03 -07:00
|
|
|
git->item->want_realize = EINA_TRUE;
|
2011-01-05 21:13:11 -08:00
|
|
|
}
|
2013-05-02 11:13:36 -07:00
|
|
|
if ((sd->reorder_it) &&
|
2012-07-16 14:56:30 -07:00
|
|
|
(it->item->old_scrl_y != it->item->scrl_y))
|
2011-06-01 20:10:11 -07:00
|
|
|
{
|
2011-10-21 01:52:03 -07:00
|
|
|
if (!it->item->move_effect_enabled)
|
2011-06-01 20:10:11 -07:00
|
|
|
{
|
2011-10-21 01:52:03 -07:00
|
|
|
it->item->move_effect_enabled = EINA_TRUE;
|
2013-05-02 11:13:36 -07:00
|
|
|
sd->reorder_move_animator =
|
2012-07-16 14:56:30 -07:00
|
|
|
ecore_animator_add(
|
|
|
|
_reorder_move_animator_cb, it);
|
2011-06-01 20:10:11 -07:00
|
|
|
}
|
|
|
|
}
|
2011-10-21 01:52:03 -07:00
|
|
|
if (!it->item->move_effect_enabled)
|
2011-06-08 19:54:04 -07:00
|
|
|
{
|
2013-05-02 11:13:36 -07:00
|
|
|
if ((sd->decorate_all_mode) &&
|
2012-07-16 14:56:30 -07:00
|
|
|
(it->itc->decorate_all_item_style))
|
|
|
|
_decorate_all_item_position
|
|
|
|
(it, it->item->scrl_x, it->item->scrl_y);
|
2011-08-03 00:16:20 -07:00
|
|
|
else
|
2012-02-22 23:39:10 -08:00
|
|
|
{
|
2013-05-02 11:13:36 -07:00
|
|
|
if (!sd->tree_effect_enabled ||
|
|
|
|
(sd->move_effect_mode ==
|
2012-07-16 14:56:30 -07:00
|
|
|
ELM_GENLIST_TREE_EFFECT_NONE) ||
|
2013-05-02 11:13:36 -07:00
|
|
|
((sd->move_effect_mode !=
|
2012-07-16 14:56:30 -07:00
|
|
|
ELM_GENLIST_TREE_EFFECT_NONE) &&
|
|
|
|
(it->item->old_scrl_y ==
|
|
|
|
it->item->scrl_y)))
|
2012-03-23 00:47:03 -07:00
|
|
|
{
|
2012-04-03 02:56:44 -07:00
|
|
|
if (it->item->deco_it_view)
|
2012-07-16 14:56:30 -07:00
|
|
|
_item_position
|
|
|
|
(it, it->item->deco_it_view,
|
|
|
|
it->item->scrl_x,
|
|
|
|
it->item->scrl_y);
|
2012-03-23 00:47:03 -07:00
|
|
|
else
|
2012-07-16 14:56:30 -07:00
|
|
|
_item_position
|
|
|
|
(it, VIEW(it), it->item->scrl_x,
|
|
|
|
it->item->scrl_y);
|
2012-03-23 00:47:03 -07:00
|
|
|
}
|
2012-02-22 23:39:10 -08:00
|
|
|
}
|
2011-10-21 01:52:03 -07:00
|
|
|
it->item->old_scrl_y = it->item->scrl_y;
|
2011-06-08 19:54:04 -07:00
|
|
|
}
|
2011-01-05 21:13:11 -08:00
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
2013-05-02 11:13:36 -07:00
|
|
|
if (!sd->tree_effect_animator)
|
2012-03-07 04:15:36 -08:00
|
|
|
_elm_genlist_item_unrealize(it, EINA_FALSE);
|
2011-01-05 21:13:11 -08:00
|
|
|
}
|
2009-10-07 07:02:55 -07:00
|
|
|
}
|
2011-01-05 21:13:11 -08:00
|
|
|
in++;
|
2010-10-15 04:51:15 -07:00
|
|
|
}
|
2011-01-31 00:30:11 -08:00
|
|
|
else
|
|
|
|
{
|
2011-10-21 01:52:03 -07:00
|
|
|
if (vis) it->item->want_realize = EINA_TRUE;
|
2011-01-31 00:30:11 -08:00
|
|
|
}
|
2011-10-21 01:52:03 -07:00
|
|
|
y += it->item->h;
|
2011-01-05 21:13:11 -08:00
|
|
|
}
|
2012-11-25 22:32:53 -08:00
|
|
|
evas_event_thaw(evas_object_evas_get((itb->sd)->obj));
|
|
|
|
evas_event_thaw_eval(evas_object_evas_get((itb->sd)->obj));
|
2011-01-05 21:13:11 -08:00
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
2012-07-16 14:56:30 -07:00
|
|
|
_item_block_realize(Item_Block *itb)
|
2011-01-05 21:13:11 -08:00
|
|
|
{
|
2012-07-16 14:56:30 -07:00
|
|
|
if (itb->realized) return;
|
|
|
|
|
|
|
|
itb->realized = EINA_TRUE;
|
|
|
|
itb->want_unrealize = EINA_FALSE;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
2012-11-25 22:32:53 -08:00
|
|
|
_elm_genlist_pan_smart_calculate(Eo *obj EINA_UNUSED, void *_pd, va_list *list EINA_UNUSED)
|
2012-07-16 14:56:30 -07:00
|
|
|
{
|
|
|
|
Evas_Coord ox, oy, ow, oh, cvx, cvy, cvw, cvh;
|
2012-10-01 01:55:46 -07:00
|
|
|
Evas_Coord vx = 0, vy = 0, vw = 0, vh = 0;
|
2011-10-21 01:52:03 -07:00
|
|
|
Elm_Gen_Item *git;
|
2012-07-16 14:56:30 -07:00
|
|
|
Item_Block *itb;
|
|
|
|
Eina_List *l;
|
|
|
|
int in = 0;
|
2011-01-05 21:13:11 -08:00
|
|
|
|
2012-11-25 22:32:53 -08:00
|
|
|
Elm_Genlist_Pan_Smart_Data *psd = _pd;
|
2014-03-08 11:09:22 -08:00
|
|
|
Elm_Genlist_Smart_Data *sd = psd->wsd;
|
2012-07-16 14:56:30 -07:00
|
|
|
|
|
|
|
evas_event_freeze(evas_object_evas_get(obj));
|
|
|
|
|
2014-03-08 11:09:22 -08:00
|
|
|
if (sd->pan_changed)
|
2011-01-05 21:13:11 -08:00
|
|
|
{
|
2014-03-08 11:09:22 -08:00
|
|
|
ecore_job_del(sd->calc_job);
|
|
|
|
sd->calc_job = NULL;
|
|
|
|
_calc_job(sd->obj);
|
|
|
|
sd->pan_changed = EINA_FALSE;
|
2012-07-16 14:56:30 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
evas_object_geometry_get(obj, &ox, &oy, &ow, &oh);
|
|
|
|
evas_output_viewport_get(evas_object_evas_get(obj), &cvx, &cvy, &cvw, &cvh);
|
2014-03-08 11:09:22 -08:00
|
|
|
EINA_LIST_FOREACH(sd->group_items, l, git)
|
2012-07-16 14:56:30 -07:00
|
|
|
{
|
|
|
|
git->item->want_realize = EINA_FALSE;
|
|
|
|
}
|
|
|
|
|
2014-03-08 11:09:22 -08:00
|
|
|
if (sd->tree_effect_enabled &&
|
|
|
|
(sd->move_effect_mode != ELM_GENLIST_TREE_EFFECT_NONE))
|
2012-07-16 14:56:30 -07:00
|
|
|
{
|
2014-03-08 11:09:22 -08:00
|
|
|
if (!sd->tree_effect_animator)
|
2011-01-05 21:13:11 -08:00
|
|
|
{
|
2014-03-08 11:09:22 -08:00
|
|
|
_item_tree_effect_before(sd->expanded_item);
|
2014-03-08 11:46:24 -08:00
|
|
|
evas_object_raise(sd->event_block_rect);
|
|
|
|
evas_object_stack_below(sd->event_block_rect, sd->stack[1]);
|
|
|
|
evas_object_show(sd->event_block_rect);
|
2014-03-08 11:09:22 -08:00
|
|
|
sd->start_time = ecore_time_get();
|
|
|
|
sd->tree_effect_animator =
|
|
|
|
ecore_animator_add(_tree_effect_animator_cb, sd->obj);
|
2011-01-05 21:13:11 -08:00
|
|
|
}
|
2012-07-16 14:56:30 -07:00
|
|
|
}
|
|
|
|
|
2014-03-08 11:09:22 -08:00
|
|
|
EINA_INLIST_FOREACH(sd->blocks, itb)
|
2012-07-16 14:56:30 -07:00
|
|
|
{
|
2014-03-08 11:09:22 -08:00
|
|
|
itb->w = sd->minw;
|
|
|
|
if (ELM_RECTS_INTERSECT(itb->x - sd->pan_x + ox,
|
|
|
|
itb->y - sd->pan_y + oy,
|
2012-07-16 14:56:30 -07:00
|
|
|
itb->w, itb->h,
|
|
|
|
cvx, cvy, cvw, cvh))
|
2011-01-05 21:13:11 -08:00
|
|
|
{
|
2012-07-16 14:56:30 -07:00
|
|
|
if ((!itb->realized) || (itb->changed))
|
|
|
|
_item_block_realize(itb);
|
|
|
|
_item_block_position(itb, in);
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
if (itb->realized) _item_block_unrealize(itb);
|
2011-01-05 21:13:11 -08:00
|
|
|
}
|
2012-07-16 14:56:30 -07:00
|
|
|
in += itb->count;
|
|
|
|
}
|
2014-03-08 11:09:22 -08:00
|
|
|
if ((!sd->reorder_it) || (sd->reorder_pan_move))
|
|
|
|
_group_items_recalc(sd);
|
|
|
|
if ((sd->reorder_mode) && (sd->reorder_it))
|
2012-07-16 14:56:30 -07:00
|
|
|
{
|
2014-03-08 11:09:22 -08:00
|
|
|
if (sd->pan_y != sd->reorder_old_pan_y)
|
|
|
|
sd->reorder_pan_move = EINA_TRUE;
|
|
|
|
else sd->reorder_pan_move = EINA_FALSE;
|
2012-07-16 14:56:30 -07:00
|
|
|
|
2014-03-08 11:09:22 -08:00
|
|
|
evas_object_raise(sd->VIEW(reorder_it));
|
|
|
|
evas_object_stack_below(sd->VIEW(reorder_it), sd->stack[1]);
|
|
|
|
sd->reorder_old_pan_y = sd->pan_y;
|
|
|
|
sd->start_time = ecore_loop_time_get();
|
2009-02-11 03:49:43 -08:00
|
|
|
}
|
2012-07-16 14:56:30 -07:00
|
|
|
|
2014-03-08 11:09:22 -08:00
|
|
|
if (!sd->tree_effect_enabled ||
|
|
|
|
(sd->move_effect_mode == ELM_GENLIST_TREE_EFFECT_NONE))
|
|
|
|
_item_auto_scroll(sd);
|
2012-07-16 14:56:30 -07:00
|
|
|
|
2014-03-08 11:09:22 -08:00
|
|
|
eo_do((sd)->obj,
|
2014-03-17 04:44:40 -07:00
|
|
|
elm_interface_scrollable_content_pos_get(&vx, &vy),
|
|
|
|
elm_interface_scrollable_content_viewport_size_get(&vw, &vh));
|
2012-10-01 01:55:46 -07:00
|
|
|
|
2014-03-08 11:09:22 -08:00
|
|
|
if (sd->reorder_fast == 1)
|
2014-03-17 04:44:40 -07:00
|
|
|
eo_do((sd)->obj, elm_interface_scrollable_content_region_show(vx, vy - 10, vw, vh));
|
2014-03-08 11:09:22 -08:00
|
|
|
else if (sd->reorder_fast == -1)
|
2014-03-17 04:44:40 -07:00
|
|
|
eo_do((sd)->obj, elm_interface_scrollable_content_region_show(vx, vy + 10, vw, vh));
|
2012-10-01 01:55:46 -07:00
|
|
|
|
2014-03-08 11:09:22 -08:00
|
|
|
if (sd->focused_item)
|
2014-03-08 08:04:34 -08:00
|
|
|
_elm_widget_focus_highlight_start(psd->wobj);
|
|
|
|
|
2012-07-16 14:56:30 -07:00
|
|
|
evas_event_thaw(evas_object_evas_get(obj));
|
|
|
|
evas_event_thaw_eval(evas_object_evas_get(obj));
|
2009-02-11 03:49:43 -08:00
|
|
|
}
|
|
|
|
|
2013-04-24 04:41:37 -07:00
|
|
|
static void
|
|
|
|
_elm_genlist_pan_destructor(Eo *obj, void *_pd, va_list *list EINA_UNUSED)
|
|
|
|
{
|
|
|
|
Elm_Genlist_Pan_Smart_Data *psd = _pd;
|
|
|
|
eo_data_unref(psd->wobj, psd->wsd);
|
|
|
|
eo_do_super(obj, MY_PAN_CLASS, eo_destructor());
|
|
|
|
}
|
|
|
|
|
2012-07-16 14:56:30 -07:00
|
|
|
static void
|
2012-11-25 22:32:53 -08:00
|
|
|
_genlist_pan_class_constructor(Eo_Class *klass)
|
|
|
|
{
|
|
|
|
const Eo_Op_Func_Description func_desc[] = {
|
2013-04-24 04:41:37 -07:00
|
|
|
EO_OP_FUNC(EO_BASE_ID(EO_BASE_SUB_ID_DESTRUCTOR), _elm_genlist_pan_destructor),
|
|
|
|
|
2012-11-25 22:32:53 -08:00
|
|
|
EO_OP_FUNC(EVAS_OBJ_SMART_ID(EVAS_OBJ_SMART_SUB_ID_DEL), _elm_genlist_pan_smart_del),
|
|
|
|
EO_OP_FUNC(EVAS_OBJ_SMART_ID(EVAS_OBJ_SMART_SUB_ID_RESIZE), _elm_genlist_pan_smart_resize),
|
|
|
|
EO_OP_FUNC(EVAS_OBJ_SMART_ID(EVAS_OBJ_SMART_SUB_ID_MOVE), _elm_genlist_pan_smart_move),
|
|
|
|
EO_OP_FUNC(EVAS_OBJ_SMART_ID(EVAS_OBJ_SMART_SUB_ID_CALCULATE), _elm_genlist_pan_smart_calculate),
|
|
|
|
EO_OP_FUNC(ELM_OBJ_PAN_ID(ELM_OBJ_PAN_SUB_ID_POS_SET), _elm_genlist_pan_smart_pos_set),
|
|
|
|
EO_OP_FUNC(ELM_OBJ_PAN_ID(ELM_OBJ_PAN_SUB_ID_POS_GET), _elm_genlist_pan_smart_pos_get),
|
|
|
|
EO_OP_FUNC(ELM_OBJ_PAN_ID(ELM_OBJ_PAN_SUB_ID_POS_MAX_GET), _elm_genlist_pan_smart_pos_max_get),
|
|
|
|
EO_OP_FUNC(ELM_OBJ_PAN_ID(ELM_OBJ_PAN_SUB_ID_POS_MIN_GET), _elm_genlist_pan_smart_pos_min_get),
|
|
|
|
EO_OP_FUNC(ELM_OBJ_PAN_ID(ELM_OBJ_PAN_SUB_ID_CONTENT_SIZE_GET), _elm_genlist_pan_smart_content_size_get),
|
|
|
|
EO_OP_FUNC_SENTINEL
|
|
|
|
};
|
|
|
|
eo_class_funcs_set(klass, func_desc);
|
2013-02-09 23:52:31 -08:00
|
|
|
|
2013-11-07 06:29:38 -08:00
|
|
|
evas_smart_legacy_type_register(MY_PAN_CLASS_NAME_LEGACY, klass);
|
2012-11-25 22:32:53 -08:00
|
|
|
}
|
|
|
|
|
|
|
|
static const Eo_Class_Description _genlist_pan_class_desc = {
|
|
|
|
EO_VERSION,
|
|
|
|
MY_PAN_CLASS_NAME,
|
|
|
|
EO_CLASS_TYPE_REGULAR,
|
|
|
|
EO_CLASS_DESCRIPTION_OPS(NULL, NULL, 0),
|
|
|
|
NULL,
|
|
|
|
sizeof(Elm_Genlist_Pan_Smart_Data),
|
|
|
|
_genlist_pan_class_constructor,
|
|
|
|
NULL
|
|
|
|
};
|
2012-07-16 14:56:30 -07:00
|
|
|
|
2012-11-25 22:32:53 -08:00
|
|
|
EO_DEFINE_CLASS(elm_obj_genlist_pan_class_get, &_genlist_pan_class_desc, ELM_OBJ_PAN_CLASS, NULL);
|
2010-11-20 00:43:43 -08:00
|
|
|
|
2012-07-16 14:56:30 -07:00
|
|
|
static Eina_Bool
|
|
|
|
_item_multi_select_up(Elm_Genlist_Smart_Data *sd)
|
2011-12-23 20:20:18 -08:00
|
|
|
{
|
2012-07-16 14:56:30 -07:00
|
|
|
Elm_Object_Item *prev;
|
2011-12-23 20:20:18 -08:00
|
|
|
|
2012-07-16 14:56:30 -07:00
|
|
|
if (!sd->selected) return EINA_FALSE;
|
|
|
|
if (!sd->multi) return EINA_FALSE;
|
|
|
|
|
|
|
|
prev = elm_genlist_item_prev_get(sd->last_selected_item);
|
2014-03-23 08:49:06 -07:00
|
|
|
while (prev)
|
|
|
|
{
|
|
|
|
if ((((Elm_Gen_Item*)prev)->generation == sd->generation) &&
|
|
|
|
(!elm_object_item_disabled_get(prev)))
|
|
|
|
break;
|
|
|
|
prev = (Elm_Object_Item *)ELM_GEN_ITEM_FROM_INLIST(
|
|
|
|
EINA_INLIST_GET((Elm_Gen_Item *)prev)->prev);
|
|
|
|
}
|
2012-07-16 14:56:30 -07:00
|
|
|
if (!prev) return EINA_TRUE;
|
|
|
|
|
|
|
|
if (elm_genlist_item_selected_get(prev))
|
2011-12-23 20:20:18 -08:00
|
|
|
{
|
2012-07-16 14:56:30 -07:00
|
|
|
elm_genlist_item_selected_set(sd->last_selected_item, EINA_FALSE);
|
|
|
|
sd->last_selected_item = prev;
|
|
|
|
}
|
2011-12-23 20:20:18 -08:00
|
|
|
else
|
2012-07-16 14:56:30 -07:00
|
|
|
{
|
|
|
|
elm_genlist_item_selected_set(prev, EINA_TRUE);
|
|
|
|
elm_genlist_item_show(prev, ELM_GENLIST_ITEM_SCROLLTO_IN);
|
|
|
|
}
|
|
|
|
return EINA_TRUE;
|
2011-12-23 20:20:18 -08:00
|
|
|
}
|
|
|
|
|
2012-07-16 14:56:30 -07:00
|
|
|
static Eina_Bool
|
|
|
|
_item_multi_select_down(Elm_Genlist_Smart_Data *sd)
|
2009-02-10 03:57:47 -08:00
|
|
|
{
|
2012-07-16 14:56:30 -07:00
|
|
|
Elm_Object_Item *next;
|
2010-10-07 12:57:20 -07:00
|
|
|
|
2012-07-16 14:56:30 -07:00
|
|
|
if (!sd->selected) return EINA_FALSE;
|
|
|
|
if (!sd->multi) return EINA_FALSE;
|
2012-02-13 00:50:18 -08:00
|
|
|
|
2012-07-16 14:56:30 -07:00
|
|
|
next = elm_genlist_item_next_get(sd->last_selected_item);
|
2014-03-23 08:49:06 -07:00
|
|
|
while ((next))
|
|
|
|
{
|
|
|
|
if ((((Elm_Gen_Item *)next)->generation == sd->generation) &&
|
|
|
|
(!elm_object_item_disabled_get(next)))
|
|
|
|
break;
|
|
|
|
next = (Elm_Object_Item *)ELM_GEN_ITEM_FROM_INLIST(
|
|
|
|
EINA_INLIST_GET((Elm_Gen_Item *)next)->next);
|
|
|
|
}
|
2012-07-16 14:56:30 -07:00
|
|
|
if (!next) return EINA_TRUE;
|
2010-10-07 12:57:20 -07:00
|
|
|
|
2012-07-16 14:56:30 -07:00
|
|
|
if (elm_genlist_item_selected_get(next))
|
|
|
|
{
|
|
|
|
elm_genlist_item_selected_set(sd->last_selected_item, EINA_FALSE);
|
|
|
|
sd->last_selected_item = next;
|
|
|
|
}
|
|
|
|
else
|
2011-03-22 00:54:24 -07:00
|
|
|
{
|
2012-07-16 14:56:30 -07:00
|
|
|
elm_genlist_item_selected_set(next, EINA_TRUE);
|
|
|
|
elm_genlist_item_show(next, ELM_GENLIST_ITEM_SCROLLTO_IN);
|
|
|
|
}
|
2011-03-22 00:54:24 -07:00
|
|
|
|
2012-07-16 14:56:30 -07:00
|
|
|
return EINA_TRUE;
|
|
|
|
}
|
|
|
|
|
|
|
|
static Eina_Bool
|
|
|
|
_all_items_deselect(Elm_Genlist_Smart_Data *sd)
|
|
|
|
{
|
|
|
|
if (!sd->selected) return EINA_FALSE;
|
|
|
|
|
2014-03-23 07:37:47 -07:00
|
|
|
sd->deselecting = eina_list_clone(sd->selected);
|
|
|
|
while (sd->deselecting)
|
|
|
|
{
|
|
|
|
Elm_Object_Item *it = eina_list_data_get(sd->deselecting);
|
|
|
|
|
|
|
|
sd->deselecting = eina_list_remove_list(sd->deselecting, sd->deselecting);
|
|
|
|
elm_genlist_item_selected_set(it, EINA_FALSE);
|
|
|
|
}
|
2012-07-16 14:56:30 -07:00
|
|
|
|
|
|
|
return EINA_TRUE;
|
|
|
|
}
|
|
|
|
|
|
|
|
static Eina_Bool
|
|
|
|
_item_single_select_up(Elm_Genlist_Smart_Data *sd)
|
|
|
|
{
|
2014-03-23 08:49:06 -07:00
|
|
|
Elm_Gen_Item *prev = NULL;
|
2012-07-16 14:56:30 -07:00
|
|
|
|
|
|
|
if (!sd->selected)
|
2014-03-23 08:49:06 -07:00
|
|
|
prev = ELM_GEN_ITEM_FROM_INLIST(sd->items->last);
|
2012-07-16 14:56:30 -07:00
|
|
|
else
|
|
|
|
prev = (Elm_Gen_Item *)elm_genlist_item_prev_get
|
2014-03-23 08:49:06 -07:00
|
|
|
(sd->last_selected_item);
|
|
|
|
|
|
|
|
while (prev)
|
|
|
|
{
|
|
|
|
if ((prev->generation == sd->generation) &&
|
|
|
|
(!elm_object_item_disabled_get((Elm_Object_Item *)prev)))
|
|
|
|
break;
|
|
|
|
prev = ELM_GEN_ITEM_FROM_INLIST(EINA_INLIST_GET(prev)->prev);
|
|
|
|
}
|
2012-07-16 14:56:30 -07:00
|
|
|
|
|
|
|
if (!prev) return EINA_FALSE;
|
|
|
|
|
|
|
|
_all_items_deselect(sd);
|
|
|
|
|
|
|
|
elm_genlist_item_selected_set((Elm_Object_Item *)prev, EINA_TRUE);
|
|
|
|
return EINA_TRUE;
|
|
|
|
}
|
|
|
|
|
|
|
|
static Eina_Bool
|
|
|
|
_item_single_select_down(Elm_Genlist_Smart_Data *sd)
|
|
|
|
{
|
2014-03-23 08:49:06 -07:00
|
|
|
Elm_Gen_Item *next = NULL;
|
2012-07-16 14:56:30 -07:00
|
|
|
|
|
|
|
if (!sd->selected)
|
2014-03-23 08:49:06 -07:00
|
|
|
next = ELM_GEN_ITEM_FROM_INLIST(sd->items);
|
|
|
|
else
|
2012-07-16 14:56:30 -07:00
|
|
|
{
|
2014-03-23 08:49:06 -07:00
|
|
|
next = (Elm_Gen_Item *)elm_genlist_item_next_get
|
|
|
|
(sd->last_selected_item);
|
|
|
|
}
|
|
|
|
|
|
|
|
while ((next))
|
|
|
|
{
|
|
|
|
if ((next->generation == sd->generation) &&
|
|
|
|
(!elm_object_item_disabled_get((Elm_Object_Item *)next)))
|
|
|
|
break;
|
|
|
|
next = ELM_GEN_ITEM_FROM_INLIST(EINA_INLIST_GET(next)->next);
|
2012-07-16 14:56:30 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
if (!next) return EINA_FALSE;
|
|
|
|
|
|
|
|
_all_items_deselect(sd);
|
|
|
|
|
|
|
|
elm_genlist_item_selected_set((Elm_Object_Item *)next, EINA_TRUE);
|
2014-03-08 08:04:34 -08:00
|
|
|
|
|
|
|
return EINA_TRUE;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
_elm_genlist_item_focused(Elm_Gen_Item *it)
|
|
|
|
{
|
|
|
|
Evas_Object *obj = WIDGET(it);
|
2014-03-23 07:29:16 -07:00
|
|
|
ELM_GENLIST_DATA_GET(obj, sd);
|
2014-03-08 08:04:34 -08:00
|
|
|
const char *focus_raise;
|
|
|
|
|
|
|
|
if (it->generation < sd->generation)
|
|
|
|
return;
|
|
|
|
|
|
|
|
if ((sd->select_mode == ELM_OBJECT_SELECT_MODE_DISPLAY_ONLY) ||
|
|
|
|
(it->select_mode == ELM_OBJECT_SELECT_MODE_DISPLAY_ONLY) ||
|
|
|
|
(it == (Elm_Gen_Item *)sd->focused_item) ||
|
|
|
|
(elm_widget_item_disabled_get(it)))
|
|
|
|
return;
|
|
|
|
|
2014-03-22 02:38:00 -07:00
|
|
|
elm_genlist_item_show((Elm_Object_Item *)it, ELM_GENLIST_ITEM_SCROLLTO_IN);
|
2014-03-08 08:04:34 -08:00
|
|
|
sd->focused_item = (Elm_Object_Item *)it;
|
|
|
|
|
|
|
|
if (elm_widget_focus_highlight_enabled_get(obj))
|
|
|
|
{
|
|
|
|
edje_object_signal_emit
|
|
|
|
(VIEW(it), "elm,state,focused", "elm");
|
|
|
|
}
|
|
|
|
|
|
|
|
focus_raise = edje_object_data_get(VIEW(it), "focusraise");
|
|
|
|
if ((focus_raise) && (!strcmp(focus_raise, "on")))
|
|
|
|
evas_object_raise(VIEW(it));
|
2014-03-23 07:29:16 -07:00
|
|
|
evas_object_smart_callback_call(obj, SIG_ITEM_FOCUSED, it);
|
2014-03-08 08:04:34 -08:00
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
_elm_genlist_item_unfocused(Elm_Gen_Item *it)
|
|
|
|
{
|
2014-03-23 07:29:16 -07:00
|
|
|
Evas_Object *obj = WIDGET(it);
|
|
|
|
ELM_GENLIST_DATA_GET(obj, sd);
|
2014-03-08 08:04:34 -08:00
|
|
|
|
|
|
|
if (it->generation < sd->generation)
|
|
|
|
return;
|
|
|
|
|
|
|
|
if ((sd->select_mode == ELM_OBJECT_SELECT_MODE_DISPLAY_ONLY) ||
|
2014-03-08 09:48:29 -08:00
|
|
|
(it->select_mode == ELM_OBJECT_SELECT_MODE_DISPLAY_ONLY))
|
2014-03-08 08:04:34 -08:00
|
|
|
return;
|
|
|
|
|
|
|
|
if ((!sd->focused_item) ||
|
|
|
|
(it != (Elm_Gen_Item *)sd->focused_item))
|
|
|
|
return;
|
|
|
|
|
|
|
|
sd->prev_focused_item = (Elm_Object_Item *)it;
|
|
|
|
|
2014-03-23 07:29:16 -07:00
|
|
|
if (elm_widget_focus_highlight_enabled_get(obj))
|
|
|
|
edje_object_signal_emit
|
|
|
|
(VIEW(sd->focused_item), "elm,state,unfocused", "elm");
|
2014-03-08 08:04:34 -08:00
|
|
|
|
|
|
|
sd->focused_item = NULL;
|
2014-03-23 07:29:16 -07:00
|
|
|
evas_object_smart_callback_call(obj, SIG_ITEM_UNFOCUSED, it);
|
2014-03-08 08:04:34 -08:00
|
|
|
}
|
|
|
|
|
2014-03-22 07:28:19 -07:00
|
|
|
/* NOTE: this code will be used later when the item selection on key press
|
|
|
|
becomes optional. So do not remove this.
|
2014-03-08 08:04:34 -08:00
|
|
|
static Eina_Bool
|
|
|
|
_item_focused_next(Evas_Object *obj, Elm_Focus_Direction dir)
|
|
|
|
{
|
|
|
|
ELM_GENLIST_DATA_GET(obj, sd);
|
|
|
|
Elm_Gen_Item *next;
|
|
|
|
Elm_Object_Item *first_item;
|
|
|
|
Elm_Object_Item *last_item;
|
|
|
|
|
|
|
|
if (!sd->focused_item)
|
|
|
|
{
|
|
|
|
if (dir == ELM_FOCUS_UP)
|
|
|
|
next = ELM_GEN_ITEM_FROM_INLIST(sd->items->last);
|
|
|
|
else if (dir == ELM_FOCUS_DOWN)
|
|
|
|
next = ELM_GEN_ITEM_FROM_INLIST(sd->items);
|
|
|
|
else
|
|
|
|
return EINA_FALSE;
|
|
|
|
|
|
|
|
while ((next) &&
|
|
|
|
(next->generation < sd->generation) &&
|
|
|
|
(!elm_widget_item_disabled_get(next)))
|
|
|
|
next = ELM_GEN_ITEM_FROM_INLIST(EINA_INLIST_GET(next)->next);
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
if (dir == ELM_FOCUS_UP)
|
|
|
|
{
|
|
|
|
first_item = elm_genlist_first_item_get(WIDGET(sd->focused_item));
|
|
|
|
if (first_item == sd->focused_item) return EINA_FALSE;
|
|
|
|
next = (Elm_Gen_Item *)elm_genlist_item_prev_get(sd->focused_item);
|
|
|
|
|
|
|
|
while (elm_widget_item_disabled_get(next))
|
|
|
|
next = (Elm_Gen_Item *)elm_genlist_item_prev_get((Elm_Object_Item *)next);
|
|
|
|
}
|
|
|
|
else if (dir == ELM_FOCUS_DOWN)
|
|
|
|
{
|
|
|
|
last_item = elm_genlist_last_item_get(WIDGET(sd->focused_item));
|
|
|
|
if (last_item == sd->focused_item) return EINA_FALSE;
|
|
|
|
next = (Elm_Gen_Item *)elm_genlist_item_next_get(sd->focused_item);
|
|
|
|
|
|
|
|
while (elm_widget_item_disabled_get(next))
|
|
|
|
next = (Elm_Gen_Item *)elm_genlist_item_next_get((Elm_Object_Item *)next);
|
|
|
|
}
|
|
|
|
else
|
|
|
|
return EINA_FALSE;
|
|
|
|
|
|
|
|
if (!next) return EINA_FALSE;
|
|
|
|
}
|
|
|
|
|
|
|
|
elm_object_item_focus_set((Elm_Object_Item *)next, EINA_TRUE);
|
2012-07-16 14:56:30 -07:00
|
|
|
|
|
|
|
return EINA_TRUE;
|
|
|
|
}
|
2014-03-22 07:28:19 -07:00
|
|
|
*/
|
2012-07-16 14:56:30 -07:00
|
|
|
|
2013-02-20 02:00:49 -08:00
|
|
|
static void
|
2014-03-07 10:27:09 -08:00
|
|
|
_elm_genlist_item_content_focus_set(Elm_Gen_Item *it, Elm_Focus_Direction dir)
|
2013-02-20 02:00:49 -08:00
|
|
|
{
|
|
|
|
Evas_Object *focused_obj = NULL;
|
|
|
|
Eina_List *l;
|
|
|
|
if (!it) return;
|
|
|
|
|
|
|
|
if (!GL_IT(it)->wsd->focus_on_selection_enabled) return;
|
|
|
|
|
|
|
|
if (!it->item_focus_chain)
|
|
|
|
{
|
|
|
|
elm_object_focus_set(VIEW(it), EINA_TRUE);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
EINA_LIST_FOREACH(it->item_focus_chain, l, focused_obj)
|
|
|
|
if (elm_object_focus_get(focused_obj)) break;
|
|
|
|
|
|
|
|
if (focused_obj && (dir != ELM_FOCUS_PREVIOUS))
|
|
|
|
{
|
|
|
|
Evas_Object *nextfocus;
|
|
|
|
if (elm_widget_focus_next_get(focused_obj, dir, &nextfocus))
|
|
|
|
{
|
|
|
|
elm_object_focus_set(nextfocus, EINA_TRUE);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!l) l = it->item_focus_chain;
|
|
|
|
|
|
|
|
if (dir == ELM_FOCUS_RIGHT)
|
|
|
|
{
|
|
|
|
l = eina_list_next(l);
|
|
|
|
if (!l) l = it->item_focus_chain;
|
|
|
|
}
|
|
|
|
else if (dir == ELM_FOCUS_LEFT)
|
|
|
|
{
|
|
|
|
l = eina_list_prev(l);
|
|
|
|
if (!l) l = eina_list_last(it->item_focus_chain);
|
|
|
|
}
|
|
|
|
|
|
|
|
elm_object_focus_set(eina_list_data_get(l), EINA_TRUE);
|
|
|
|
}
|
|
|
|
|
2012-11-25 22:32:53 -08:00
|
|
|
static void
|
|
|
|
_elm_genlist_smart_event(Eo *obj, void *_pd, va_list *list)
|
2012-07-16 14:56:30 -07:00
|
|
|
{
|
2012-11-25 22:32:53 -08:00
|
|
|
Evas_Object *src = va_arg(*list, Evas_Object *);
|
|
|
|
Evas_Callback_Type type = va_arg(*list, Evas_Callback_Type);
|
2013-10-28 07:06:14 -07:00
|
|
|
Evas_Event_Key_Down *ev = va_arg(*list, void *);
|
2012-11-25 22:32:53 -08:00
|
|
|
Eina_Bool *ret = va_arg(*list, Eina_Bool *);
|
2013-10-28 07:06:14 -07:00
|
|
|
Elm_Genlist_Smart_Data *sd = _pd;
|
|
|
|
|
2012-11-25 22:32:53 -08:00
|
|
|
if (ret) *ret = EINA_FALSE;
|
2013-10-28 07:06:14 -07:00
|
|
|
(void) src;
|
2012-11-25 22:32:53 -08:00
|
|
|
|
2012-07-16 14:56:30 -07:00
|
|
|
Evas_Coord x = 0;
|
|
|
|
Evas_Coord y = 0;
|
|
|
|
Evas_Coord v_w = 0;
|
|
|
|
Evas_Coord v_h = 0;
|
|
|
|
Evas_Coord step_x = 0;
|
|
|
|
Evas_Coord step_y = 0;
|
|
|
|
Evas_Coord page_x = 0;
|
|
|
|
Evas_Coord page_y = 0;
|
|
|
|
Elm_Object_Item *it = NULL;
|
|
|
|
Evas_Coord pan_max_x = 0, pan_max_y = 0;
|
2014-03-22 07:28:19 -07:00
|
|
|
Eina_Bool sel_ret = EINA_FALSE;
|
2012-07-16 14:56:30 -07:00
|
|
|
|
2013-10-28 07:06:14 -07:00
|
|
|
if (elm_widget_disabled_get(obj)) return;
|
2012-11-25 22:32:53 -08:00
|
|
|
if (type != EVAS_CALLBACK_KEY_DOWN) return;
|
|
|
|
if (ev->event_flags & EVAS_EVENT_FLAG_ON_HOLD) return;
|
2013-10-28 07:06:14 -07:00
|
|
|
if (!sd->items) return;
|
2012-07-16 14:56:30 -07:00
|
|
|
|
2012-11-25 22:32:53 -08:00
|
|
|
eo_do(obj,
|
2014-03-17 04:44:40 -07:00
|
|
|
elm_interface_scrollable_content_pos_get(&x, &y),
|
|
|
|
elm_interface_scrollable_step_size_get(&step_x, &step_y),
|
|
|
|
elm_interface_scrollable_page_size_get(&page_x, &page_y),
|
|
|
|
elm_interface_scrollable_content_viewport_size_get(&v_w, &v_h));
|
2012-07-16 14:56:30 -07:00
|
|
|
|
2013-07-30 23:14:09 -07:00
|
|
|
if ((!strcmp(ev->key, "Left")) ||
|
|
|
|
((!strcmp(ev->key, "KP_Left")) && (!ev->string)))
|
2012-07-16 14:56:30 -07:00
|
|
|
{
|
|
|
|
x -= step_x;
|
2013-02-20 02:00:49 -08:00
|
|
|
|
|
|
|
Elm_Gen_Item *gt = (Elm_Gen_Item*)elm_genlist_selected_item_get(obj);
|
2014-03-07 10:27:09 -08:00
|
|
|
_elm_genlist_item_content_focus_set(gt, ELM_FOCUS_LEFT);
|
2014-03-08 08:04:34 -08:00
|
|
|
|
|
|
|
if (ret) *ret = EINA_FALSE;
|
|
|
|
|
|
|
|
return;
|
2012-07-16 14:56:30 -07:00
|
|
|
}
|
2013-07-30 23:14:09 -07:00
|
|
|
else if ((!strcmp(ev->key, "Right")) ||
|
|
|
|
((!strcmp(ev->key, "KP_Right")) && (!ev->string)))
|
2012-07-16 14:56:30 -07:00
|
|
|
{
|
|
|
|
x += step_x;
|
2013-02-20 02:00:49 -08:00
|
|
|
|
|
|
|
Elm_Gen_Item *gt = (Elm_Gen_Item*)elm_genlist_selected_item_get(obj);
|
2014-03-07 10:27:09 -08:00
|
|
|
_elm_genlist_item_content_focus_set(gt, ELM_FOCUS_RIGHT);
|
2014-03-08 08:04:34 -08:00
|
|
|
|
|
|
|
if (ret) *ret = EINA_FALSE;
|
|
|
|
|
|
|
|
return;
|
2012-07-16 14:56:30 -07:00
|
|
|
}
|
2013-07-30 23:14:09 -07:00
|
|
|
else if ((!strcmp(ev->key, "Up")) ||
|
|
|
|
((!strcmp(ev->key, "KP_Up")) && (!ev->string)))
|
2012-07-16 14:56:30 -07:00
|
|
|
{
|
2014-03-22 07:28:19 -07:00
|
|
|
if (evas_key_modifier_is_set(ev->modifiers, "Shift"))
|
|
|
|
sel_ret = _item_multi_select_up(sd);
|
|
|
|
if (!sel_ret)
|
|
|
|
sel_ret = _item_single_select_up(sd);
|
2014-03-08 08:04:34 -08:00
|
|
|
|
2014-03-22 07:28:19 -07:00
|
|
|
if (sel_ret)
|
2014-03-08 08:04:34 -08:00
|
|
|
{
|
|
|
|
ev->event_flags |= EVAS_EVENT_FLAG_ON_HOLD;
|
|
|
|
if (ret) *ret = EINA_TRUE;
|
2014-03-22 07:28:19 -07:00
|
|
|
return;
|
2014-03-08 08:04:34 -08:00
|
|
|
}
|
|
|
|
|
2014-03-22 07:28:19 -07:00
|
|
|
if (ret) *ret = EINA_FALSE;
|
2014-03-08 08:04:34 -08:00
|
|
|
return;
|
2012-07-16 14:56:30 -07:00
|
|
|
}
|
2013-07-30 23:14:09 -07:00
|
|
|
else if ((!strcmp(ev->key, "Down")) ||
|
|
|
|
((!strcmp(ev->key, "KP_Down")) && (!ev->string)))
|
2012-07-16 14:56:30 -07:00
|
|
|
{
|
2014-03-22 07:28:19 -07:00
|
|
|
if (evas_key_modifier_is_set(ev->modifiers, "Shift"))
|
|
|
|
sel_ret = _item_multi_select_down(sd);
|
|
|
|
if (!sel_ret)
|
|
|
|
sel_ret = _item_single_select_down(sd);
|
2014-03-08 08:04:34 -08:00
|
|
|
|
2014-03-22 07:28:19 -07:00
|
|
|
if (sel_ret)
|
2014-03-08 08:04:34 -08:00
|
|
|
{
|
|
|
|
ev->event_flags |= EVAS_EVENT_FLAG_ON_HOLD;
|
|
|
|
if (ret) *ret = EINA_TRUE;
|
2014-03-22 07:28:19 -07:00
|
|
|
return;
|
2014-03-08 08:04:34 -08:00
|
|
|
}
|
|
|
|
|
2014-03-22 07:28:19 -07:00
|
|
|
if (ret) *ret = EINA_FALSE;
|
2014-03-08 08:04:34 -08:00
|
|
|
return;
|
2012-07-16 14:56:30 -07:00
|
|
|
}
|
2013-07-30 23:14:09 -07:00
|
|
|
else if ((!strcmp(ev->key, "Home")) ||
|
|
|
|
((!strcmp(ev->key, "KP_Home")) && (!ev->string)))
|
2012-07-16 14:56:30 -07:00
|
|
|
{
|
|
|
|
it = elm_genlist_first_item_get(obj);
|
2014-03-18 03:14:39 -07:00
|
|
|
if (it)
|
|
|
|
{
|
|
|
|
elm_genlist_item_selected_set(it, EINA_TRUE);
|
|
|
|
ev->event_flags |= EVAS_EVENT_FLAG_ON_HOLD;
|
|
|
|
if (ret) *ret = EINA_TRUE;
|
|
|
|
return;
|
|
|
|
}
|
2012-07-16 14:56:30 -07:00
|
|
|
}
|
2013-07-30 23:14:09 -07:00
|
|
|
else if ((!strcmp(ev->key, "End")) ||
|
|
|
|
((!strcmp(ev->key, "KP_End")) && (!ev->string)))
|
2012-07-16 14:56:30 -07:00
|
|
|
{
|
|
|
|
it = elm_genlist_last_item_get(obj);
|
2014-03-18 03:14:39 -07:00
|
|
|
if (it)
|
|
|
|
{
|
|
|
|
elm_genlist_item_selected_set(it, EINA_TRUE);
|
|
|
|
ev->event_flags |= EVAS_EVENT_FLAG_ON_HOLD;
|
|
|
|
if (ret) *ret = EINA_TRUE;
|
|
|
|
return;
|
|
|
|
}
|
2012-07-16 14:56:30 -07:00
|
|
|
}
|
2013-07-30 23:14:09 -07:00
|
|
|
else if ((!strcmp(ev->key, "Prior")) ||
|
|
|
|
((!strcmp(ev->key, "KP_Prior")) && (!ev->string)))
|
2012-07-16 14:56:30 -07:00
|
|
|
{
|
|
|
|
if (page_y < 0)
|
|
|
|
y -= -(page_y * v_h) / 100;
|
|
|
|
else
|
|
|
|
y -= page_y;
|
|
|
|
}
|
2013-07-30 23:14:09 -07:00
|
|
|
else if ((!strcmp(ev->key, "Next")) ||
|
|
|
|
((!strcmp(ev->key, "KP_Next")) && (!ev->string)))
|
2012-07-16 14:56:30 -07:00
|
|
|
{
|
|
|
|
if (page_y < 0)
|
|
|
|
y += -(page_y * v_h) / 100;
|
|
|
|
else
|
|
|
|
y += page_y;
|
|
|
|
}
|
2013-07-30 23:14:09 -07:00
|
|
|
else if (!strcmp(ev->key, "Escape"))
|
2012-07-16 14:56:30 -07:00
|
|
|
{
|
2012-11-25 22:32:53 -08:00
|
|
|
if (!_all_items_deselect(sd)) return;
|
2012-07-16 14:56:30 -07:00
|
|
|
ev->event_flags |= EVAS_EVENT_FLAG_ON_HOLD;
|
2012-11-25 22:32:53 -08:00
|
|
|
if (ret) *ret = EINA_TRUE;
|
|
|
|
return;
|
2012-07-16 14:56:30 -07:00
|
|
|
}
|
2013-07-30 23:14:09 -07:00
|
|
|
else if (((!strcmp(ev->key, "Return")) ||
|
|
|
|
(!strcmp(ev->key, "KP_Enter")) ||
|
|
|
|
(!strcmp(ev->key, "space")))
|
2012-07-16 14:56:30 -07:00
|
|
|
&& (!sd->multi) && (sd->selected))
|
|
|
|
{
|
|
|
|
it = elm_genlist_selected_item_get(obj);
|
|
|
|
elm_genlist_item_expanded_set(it, !elm_genlist_item_expanded_get(it));
|
|
|
|
evas_object_smart_callback_call(WIDGET(it), SIG_ACTIVATED, it);
|
|
|
|
}
|
2012-11-25 22:32:53 -08:00
|
|
|
else return;
|
2012-07-16 14:56:30 -07:00
|
|
|
|
|
|
|
ev->event_flags |= EVAS_EVENT_FLAG_ON_HOLD;
|
2012-11-25 22:32:53 -08:00
|
|
|
eo_do(sd->pan_obj, elm_obj_pan_pos_max_get(&pan_max_x, &pan_max_y));
|
2012-07-16 14:56:30 -07:00
|
|
|
if (x < 0) x = 0;
|
|
|
|
if (x > pan_max_x) x = pan_max_x;
|
|
|
|
if (y < 0) y = 0;
|
|
|
|
if (y > pan_max_y) y = pan_max_y;
|
|
|
|
|
2014-03-17 04:44:40 -07:00
|
|
|
eo_do(obj, elm_interface_scrollable_content_pos_set(x, y, EINA_TRUE));
|
2012-07-16 14:56:30 -07:00
|
|
|
|
2012-11-25 22:32:53 -08:00
|
|
|
if (ret) *ret = EINA_TRUE;
|
2012-07-16 14:56:30 -07:00
|
|
|
}
|
|
|
|
|
2012-11-25 22:32:53 -08:00
|
|
|
/* This function disables the specific code of the layout sub object add.
|
|
|
|
* Only the widget sub_object_add is called.
|
|
|
|
*/
|
|
|
|
static void
|
|
|
|
_elm_genlist_smart_layout_sub_object_add_enable(Eo *obj EINA_UNUSED, void *_pd EINA_UNUSED, va_list *list)
|
2012-07-16 14:56:30 -07:00
|
|
|
{
|
2012-11-25 22:32:53 -08:00
|
|
|
Eina_Bool *enable = va_arg(*list, Eina_Bool *);
|
|
|
|
*enable = EINA_FALSE;
|
|
|
|
}
|
2012-07-16 14:56:30 -07:00
|
|
|
|
2012-11-25 22:32:53 -08:00
|
|
|
static void
|
|
|
|
_elm_genlist_smart_sub_object_add(Eo *obj, void *_pd EINA_UNUSED, va_list *list)
|
|
|
|
{
|
|
|
|
Evas_Object *sobj = va_arg(*list, Evas_Object *);
|
|
|
|
Eina_Bool *ret = va_arg(*list, Eina_Bool *);
|
|
|
|
if (ret) *ret = EINA_FALSE;
|
|
|
|
Eina_Bool int_ret = EINA_FALSE;
|
2012-07-16 14:56:30 -07:00
|
|
|
|
|
|
|
/* skipping layout's code, which registers size hint changing
|
|
|
|
* callback on sub objects. this is here because items'
|
|
|
|
* content_get() routines may change hints on the objects after
|
|
|
|
* creation, thus issuing TOO MANY sizing_eval()'s here. they are
|
|
|
|
* not needed at here anyway, so let's skip listening to those
|
|
|
|
* hints changes */
|
2014-03-14 02:13:29 -07:00
|
|
|
eo_do_super(obj, MY_CLASS, elm_obj_widget_sub_object_add(sobj, &int_ret));
|
2012-11-25 22:32:53 -08:00
|
|
|
if (!int_ret) return;
|
2012-07-16 14:56:30 -07:00
|
|
|
|
2012-11-25 22:32:53 -08:00
|
|
|
if (ret) *ret = EINA_TRUE;
|
2012-07-16 14:56:30 -07:00
|
|
|
}
|
|
|
|
|
2012-11-25 22:32:53 -08:00
|
|
|
static void
|
|
|
|
_elm_genlist_smart_sub_object_del(Eo *obj, void *_pd, va_list *list)
|
2012-07-16 14:56:30 -07:00
|
|
|
{
|
2012-11-25 22:32:53 -08:00
|
|
|
Evas_Object *sobj = va_arg(*list, Evas_Object *);
|
|
|
|
Eina_Bool *ret = va_arg(*list, Eina_Bool *);
|
|
|
|
if (ret) *ret = EINA_FALSE;
|
|
|
|
Eina_Bool int_ret = EINA_FALSE;
|
|
|
|
|
|
|
|
Elm_Genlist_Smart_Data *sd = _pd;
|
2012-07-16 14:56:30 -07:00
|
|
|
|
|
|
|
/* XXX: hack -- also skipping sizing recalculation on
|
|
|
|
* sub-object-del. genlist's crazy code paths (like groups and
|
|
|
|
* such) seem to issue a whole lot of deletions and Evas bitches
|
|
|
|
* about too many recalculations */
|
|
|
|
sd->on_sub_del = EINA_TRUE;
|
|
|
|
|
2014-03-14 02:13:29 -07:00
|
|
|
eo_do_super(obj, MY_CLASS, elm_obj_widget_sub_object_del(sobj, &int_ret));
|
2012-11-25 22:32:53 -08:00
|
|
|
if (!int_ret) return;
|
2012-07-16 14:56:30 -07:00
|
|
|
|
|
|
|
sd->on_sub_del = EINA_FALSE;
|
|
|
|
|
2012-11-25 22:32:53 -08:00
|
|
|
if (ret) *ret = EINA_TRUE;
|
2012-07-16 14:56:30 -07:00
|
|
|
}
|
|
|
|
|
2014-03-18 08:48:07 -07:00
|
|
|
/*
|
|
|
|
* This function searches the nearest visible item based on the given item.
|
2014-03-23 01:58:34 -07:00
|
|
|
* If the given item is in the genlist viewport, this returns the given item.
|
|
|
|
* Or this searches the realized items and checks the nearest fully visible item
|
2014-03-18 08:48:07 -07:00
|
|
|
* according to the given item's position.
|
|
|
|
*/
|
|
|
|
static Elm_Object_Item *
|
|
|
|
_elm_genlist_nearest_visible_item_get(Evas_Object *obj, Elm_Object_Item *it)
|
|
|
|
{
|
|
|
|
Evas_Coord vx = 0, vy = 0, vw = 0, vh = 0; // genlist viewport geometry
|
|
|
|
Evas_Coord ix = 0, iy = 0, iw = 0, ih = 0; // given item geometry
|
|
|
|
Evas_Coord cx = 0, cy = 0, cw = 0, ch = 0; // candidate item geometry
|
|
|
|
Eina_List *item_list = NULL, *l = NULL;
|
|
|
|
Elm_Object_Item *item = NULL;
|
|
|
|
ELM_GENLIST_DATA_GET(obj, sd);
|
2014-03-23 10:07:41 -07:00
|
|
|
Eina_Bool search_next = EINA_FALSE;
|
2014-03-18 08:48:07 -07:00
|
|
|
|
|
|
|
if (!it) return NULL;
|
|
|
|
|
|
|
|
evas_object_geometry_get(sd->pan_obj, &vx, &vy, &vw, &vh);
|
|
|
|
evas_object_geometry_get(VIEW(it), &ix, &iy, &iw, &ih); // FIXME: check if the item is realized or not
|
|
|
|
|
2014-03-23 10:07:41 -07:00
|
|
|
item_list = elm_genlist_realized_items_get(obj);
|
|
|
|
|
2014-03-18 08:48:07 -07:00
|
|
|
if (ELM_RECTS_INCLUDE(vx, vy, vw, vh, ix, iy, iw, ih))
|
2014-03-23 10:07:41 -07:00
|
|
|
{
|
|
|
|
if (!elm_object_item_disabled_get(it))
|
|
|
|
return it;
|
|
|
|
else
|
|
|
|
search_next = EINA_TRUE;
|
|
|
|
}
|
2014-03-18 08:48:07 -07:00
|
|
|
|
2014-03-23 10:07:41 -07:00
|
|
|
if ((iy < vy) || search_next)
|
2014-03-18 08:48:07 -07:00
|
|
|
{
|
|
|
|
EINA_LIST_FOREACH(item_list, l, item)
|
|
|
|
{
|
|
|
|
evas_object_geometry_get(VIEW(item), &cx, &cy, &cw, &ch);
|
2014-03-23 10:07:41 -07:00
|
|
|
if (ELM_RECTS_INCLUDE(vx, vy, vw, vh, cx, cy, cw, ch) &&
|
|
|
|
!elm_object_item_disabled_get(item))
|
2014-03-18 08:48:07 -07:00
|
|
|
return item;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
EINA_LIST_REVERSE_FOREACH(item_list, l, item)
|
|
|
|
{
|
|
|
|
evas_object_geometry_get(VIEW(item), &cx, &cy, &cw, &ch);
|
2014-03-23 10:07:41 -07:00
|
|
|
if (ELM_RECTS_INCLUDE(vx, vy, vw, vh, cx, cy, cw, ch) &&
|
|
|
|
!elm_object_item_disabled_get(item))
|
2014-03-18 08:48:07 -07:00
|
|
|
return item;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
2012-11-25 22:32:53 -08:00
|
|
|
static void
|
|
|
|
_elm_genlist_smart_on_focus(Eo *obj, void *_pd EINA_UNUSED, va_list *list)
|
2012-07-16 14:56:30 -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 = EINA_FALSE;
|
|
|
|
Elm_Genlist_Smart_Data *sd = _pd;
|
2014-03-08 08:04:34 -08:00
|
|
|
Elm_Object_Item *it = NULL;
|
2014-03-22 07:28:19 -07:00
|
|
|
Eina_Bool is_sel = EINA_FALSE;
|
2012-07-16 14:56:30 -07:00
|
|
|
|
2014-03-14 02:13:29 -07:00
|
|
|
eo_do_super(obj, MY_CLASS, elm_obj_widget_on_focus(&int_ret));
|
2012-11-25 22:32:53 -08:00
|
|
|
if (!int_ret) return;
|
2012-07-16 14:56:30 -07:00
|
|
|
|
|
|
|
if (elm_widget_focus_get(obj) && (sd->items) && (sd->selected) &&
|
|
|
|
(!sd->last_selected_item))
|
|
|
|
sd->last_selected_item = eina_list_data_get(sd->selected);
|
|
|
|
|
2014-03-23 00:48:10 -07:00
|
|
|
if (elm_widget_focus_get(obj) && !sd->mouse_down)
|
2014-03-08 08:04:34 -08:00
|
|
|
{
|
2014-03-18 08:48:07 -07:00
|
|
|
if (sd->last_focused_item)
|
|
|
|
it = sd->last_focused_item;
|
|
|
|
else if (sd->last_selected_item)
|
|
|
|
it = sd->last_selected_item;
|
2014-03-23 00:48:10 -07:00
|
|
|
else
|
2014-03-22 07:28:19 -07:00
|
|
|
{
|
|
|
|
it = elm_genlist_first_item_get(obj);
|
|
|
|
is_sel = EINA_TRUE;
|
|
|
|
}
|
2014-03-18 08:48:07 -07:00
|
|
|
|
|
|
|
if (it)
|
|
|
|
{
|
|
|
|
it = _elm_genlist_nearest_visible_item_get(obj, it);
|
|
|
|
if (it)
|
2014-03-22 07:28:19 -07:00
|
|
|
{
|
|
|
|
if (is_sel)
|
|
|
|
elm_genlist_item_selected_set(it, EINA_TRUE);
|
|
|
|
else
|
|
|
|
elm_object_item_focus_set(it, EINA_TRUE);
|
2014-03-23 05:32:05 -07:00
|
|
|
_elm_widget_focus_highlight_start(obj);
|
2014-03-22 07:28:19 -07:00
|
|
|
}
|
2014-03-18 08:48:07 -07:00
|
|
|
}
|
2014-03-08 08:04:34 -08:00
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
if (sd->focused_item)
|
|
|
|
{
|
|
|
|
sd->prev_focused_item = sd->focused_item;
|
|
|
|
sd->last_focused_item = sd->focused_item;
|
|
|
|
_elm_genlist_item_unfocused((Elm_Gen_Item *)sd->focused_item);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2012-11-25 22:32:53 -08:00
|
|
|
if (ret) *ret = EINA_TRUE;
|
2012-07-16 14:56:30 -07:00
|
|
|
}
|
|
|
|
|
2012-11-25 22:32:53 -08:00
|
|
|
static Eina_Bool _elm_genlist_smart_focus_next_enable = EINA_FALSE;
|
|
|
|
|
|
|
|
static void
|
|
|
|
_elm_genlist_smart_focus_next_manager_is(Eo *obj EINA_UNUSED, void *_pd EINA_UNUSED, va_list *list)
|
2012-08-18 06:52:03 -07:00
|
|
|
{
|
2012-11-25 22:32:53 -08:00
|
|
|
Eina_Bool *ret = va_arg(*list, Eina_Bool *);
|
2013-12-31 21:11:50 -08:00
|
|
|
if (ret) *ret = _elm_genlist_smart_focus_next_enable;
|
2012-11-25 22:32:53 -08:00
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
_elm_genlist_smart_focus_direction_manager_is(Eo *obj EINA_UNUSED, void *_pd EINA_UNUSED, va_list *list)
|
|
|
|
{
|
|
|
|
Eina_Bool *ret = va_arg(*list, Eina_Bool *);
|
2013-12-31 21:11:50 -08:00
|
|
|
if (ret) *ret = EINA_FALSE;
|
2012-11-25 22:32:53 -08:00
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
_elm_genlist_smart_focus_next(Eo *obj, void *_pd EINA_UNUSED, va_list *list)
|
|
|
|
{
|
|
|
|
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 = EINA_FALSE;
|
|
|
|
|
2012-10-23 18:06:05 -07:00
|
|
|
Evas_Coord x, y, w, h;
|
|
|
|
Evas_Coord sx, sy, sw, sh;
|
2012-08-18 06:52:03 -07:00
|
|
|
Item_Block *itb;
|
|
|
|
Eina_List *items = NULL;
|
|
|
|
Eina_Bool done = EINA_FALSE;
|
|
|
|
|
2012-11-25 22:32:53 -08:00
|
|
|
Elm_Genlist_Smart_Data *sd = _pd;
|
2012-08-18 06:52:03 -07:00
|
|
|
|
2012-11-25 22:32:53 -08:00
|
|
|
evas_object_geometry_get(sd->obj, &sx, &sy, &sw, &sh);
|
2012-10-23 18:06:05 -07:00
|
|
|
|
2012-08-18 06:52:03 -07:00
|
|
|
EINA_INLIST_FOREACH(sd->blocks, itb)
|
|
|
|
{
|
|
|
|
if (itb->realized)
|
|
|
|
{
|
|
|
|
Eina_List *l;
|
|
|
|
Elm_Gen_Item *it;
|
|
|
|
|
|
|
|
done = EINA_TRUE;
|
|
|
|
EINA_LIST_FOREACH(itb->items, l, it)
|
|
|
|
{
|
|
|
|
if (it->realized)
|
2012-10-23 18:06:05 -07:00
|
|
|
{
|
|
|
|
evas_object_geometry_get(it->base.view, &x, &y, &w, &h);
|
|
|
|
|
|
|
|
/* check item which displays more than half of its size */
|
2013-05-03 04:01:58 -07:00
|
|
|
if (it->base.access_obj &&
|
|
|
|
ELM_RECTS_INTERSECT
|
2012-10-23 19:01:58 -07:00
|
|
|
(x + (w / 2), y + (h / 2), 0, 0, sx, sy, sw, sh))
|
2012-10-23 18:06:05 -07:00
|
|
|
items = eina_list_append(items, it->base.access_obj);
|
2013-02-07 05:01:34 -08:00
|
|
|
|
|
|
|
if (!it->base.access_order) continue;
|
|
|
|
|
|
|
|
Eina_List *subl;
|
|
|
|
Evas_Object *subo;
|
|
|
|
EINA_LIST_FOREACH(it->base.access_order, subl, subo)
|
|
|
|
items = eina_list_append(items, subo);
|
2012-10-23 18:06:05 -07:00
|
|
|
}
|
2012-08-18 06:52:03 -07:00
|
|
|
}
|
|
|
|
}
|
|
|
|
else if (done) break;
|
|
|
|
}
|
|
|
|
|
2012-11-25 22:32:53 -08:00
|
|
|
int_ret = elm_widget_focus_list_next_get
|
2012-08-18 06:52:03 -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-18 06:52:03 -07:00
|
|
|
}
|
|
|
|
|
2012-07-16 14:56:30 -07:00
|
|
|
static void
|
|
|
|
_mirrored_set(Evas_Object *obj,
|
|
|
|
Eina_Bool rtl)
|
|
|
|
{
|
|
|
|
ELM_GENLIST_DATA_GET(obj, sd);
|
|
|
|
|
2012-10-22 07:34:43 -07:00
|
|
|
_item_cache_zero(sd);
|
2014-03-17 04:44:40 -07:00
|
|
|
eo_do(obj, elm_interface_scrollable_mirrored_set(rtl));
|
2012-07-16 14:56:30 -07:00
|
|
|
}
|
|
|
|
|
2012-11-25 22:32:53 -08:00
|
|
|
static void
|
2013-04-24 04:41:37 -07:00
|
|
|
_elm_genlist_smart_theme(Eo *obj, void *_pd, va_list *list)
|
2012-07-16 14:56:30 -07:00
|
|
|
{
|
|
|
|
Item_Block *itb;
|
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 = EINA_FALSE;
|
2014-03-08 08:04:34 -08:00
|
|
|
Eina_List *l;
|
|
|
|
Elm_Gen_Item *it;
|
2012-11-25 22:32:53 -08:00
|
|
|
Elm_Genlist_Smart_Data *sd = _pd;
|
2012-07-16 14:56:30 -07:00
|
|
|
|
2014-03-14 02:13:29 -07:00
|
|
|
eo_do_super(obj, MY_CLASS, elm_obj_widget_theme_apply(&int_ret));
|
2012-11-25 22:32:53 -08:00
|
|
|
if (!int_ret) return;
|
2012-07-16 14:56:30 -07:00
|
|
|
|
2013-04-24 04:41:37 -07:00
|
|
|
evas_event_freeze(evas_object_evas_get(obj));
|
2012-10-22 07:34:43 -07:00
|
|
|
_item_cache_zero(sd);
|
2012-07-16 14:56:30 -07:00
|
|
|
_mirrored_set(obj, elm_widget_mirrored_get(obj));
|
|
|
|
|
|
|
|
sd->item_width = sd->item_height = 0;
|
|
|
|
sd->group_item_width = sd->group_item_height = 0;
|
|
|
|
sd->minw = sd->minh = sd->realminw = 0;
|
2014-03-08 08:04:34 -08:00
|
|
|
|
2012-10-01 00:36:27 -07:00
|
|
|
EINA_INLIST_FOREACH(sd->blocks, itb)
|
2012-07-16 14:56:30 -07:00
|
|
|
{
|
|
|
|
if (itb->realized) _item_block_unrealize(itb);
|
2012-10-01 00:36:27 -07:00
|
|
|
EINA_LIST_FOREACH(itb->items, l, it)
|
2012-07-16 14:56:30 -07:00
|
|
|
it->item->mincalcd = EINA_FALSE;
|
|
|
|
|
|
|
|
itb->changed = EINA_TRUE;
|
|
|
|
}
|
2014-01-21 06:16:41 -08:00
|
|
|
ecore_job_del(sd->calc_job);
|
2013-04-24 04:41:37 -07:00
|
|
|
sd->calc_job = ecore_job_add(_calc_job, obj);
|
2012-07-16 14:56:30 -07:00
|
|
|
elm_layout_sizing_eval(obj);
|
2013-04-24 04:41:37 -07:00
|
|
|
evas_event_thaw(evas_object_evas_get(obj));
|
|
|
|
evas_event_thaw_eval(evas_object_evas_get(obj));
|
2012-07-16 14:56:30 -07:00
|
|
|
|
2012-11-25 22:32:53 -08:00
|
|
|
if (ret) *ret = EINA_TRUE;
|
2012-07-16 14:56:30 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
/* FIXME: take off later. maybe this show region coords belong in the
|
|
|
|
* interface (new api functions, set/get)? */
|
|
|
|
static void
|
2013-01-10 06:06:46 -08:00
|
|
|
_show_region_hook(void *data EINA_UNUSED,
|
2012-07-16 14:56:30 -07:00
|
|
|
Evas_Object *obj)
|
|
|
|
{
|
|
|
|
Evas_Coord x, y, w, h;
|
|
|
|
|
2013-01-10 06:06:46 -08:00
|
|
|
ELM_GENLIST_DATA_GET_OR_RETURN(obj, sd);
|
2012-07-16 14:56:30 -07:00
|
|
|
|
|
|
|
elm_widget_show_region_get(obj, &x, &y, &w, &h);
|
|
|
|
//x & y are screen coordinates, Add with pan coordinates
|
|
|
|
x += sd->pan_x;
|
|
|
|
y += sd->pan_y;
|
2014-03-17 04:44:40 -07:00
|
|
|
eo_do(obj, elm_interface_scrollable_content_region_show(x, y, w, h));
|
2012-07-16 14:56:30 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
_item_highlight(Elm_Gen_Item *it)
|
|
|
|
{
|
|
|
|
const char *selectraise;
|
2013-05-02 11:13:36 -07:00
|
|
|
ELM_GENLIST_DATA_GET_FROM_ITEM(it, sd);
|
2012-07-16 14:56:30 -07:00
|
|
|
|
2013-05-02 11:13:36 -07:00
|
|
|
if ((sd->select_mode == ELM_OBJECT_SELECT_MODE_NONE) ||
|
|
|
|
(!sd->highlight) ||
|
|
|
|
(it->generation < sd->generation) ||
|
2012-07-16 14:56:30 -07:00
|
|
|
(it->highlighted) || elm_widget_item_disabled_get(it) ||
|
|
|
|
(it->select_mode == ELM_OBJECT_SELECT_MODE_NONE) ||
|
|
|
|
(it->item->deco_it_view) ||
|
|
|
|
(it->select_mode == ELM_OBJECT_SELECT_MODE_DISPLAY_ONLY))
|
|
|
|
return;
|
|
|
|
|
|
|
|
edje_object_signal_emit(VIEW(it), "elm,state,selected", "elm");
|
|
|
|
if (it->deco_all_view)
|
|
|
|
edje_object_signal_emit(it->deco_all_view, "elm,state,selected", "elm");
|
2013-01-14 02:12:50 -08:00
|
|
|
evas_object_smart_callback_call(WIDGET(it), SIG_HIGHLIGHTED, it);
|
2012-07-16 14:56:30 -07:00
|
|
|
|
|
|
|
selectraise = edje_object_data_get(VIEW(it), "selectraise");
|
|
|
|
if ((selectraise) && (!strcmp(selectraise, "on")))
|
|
|
|
{
|
2013-06-22 23:17:39 -07:00
|
|
|
if (it->deco_all_view) evas_object_stack_below(it->deco_all_view, sd->stack[1]);
|
|
|
|
else evas_object_stack_below(VIEW(it), sd->stack[1]);
|
2012-07-16 14:56:30 -07:00
|
|
|
if ((it->item->group_item) && (it->item->group_item->realized))
|
2013-06-22 23:17:39 -07:00
|
|
|
evas_object_stack_above(it->item->VIEW(group_item), sd->stack[1]);
|
2012-07-16 14:56:30 -07:00
|
|
|
}
|
|
|
|
it->highlighted = EINA_TRUE;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
_item_unhighlight(Elm_Gen_Item *it)
|
|
|
|
{
|
2013-06-22 23:17:39 -07:00
|
|
|
ELM_GENLIST_DATA_GET_FROM_ITEM(it, sd);
|
2013-09-30 03:21:31 -07:00
|
|
|
|
2013-04-17 09:30:34 -07:00
|
|
|
if ((it->generation < GL_IT(it)->wsd->generation) || (!it->highlighted))
|
2012-07-16 14:56:30 -07:00
|
|
|
return;
|
|
|
|
|
|
|
|
edje_object_signal_emit(VIEW(it), "elm,state,unselected", "elm");
|
2013-01-14 02:12:50 -08:00
|
|
|
evas_object_smart_callback_call(WIDGET(it), SIG_UNHIGHLIGHTED, it);
|
2012-07-16 14:56:30 -07:00
|
|
|
if (it->deco_all_view)
|
|
|
|
edje_object_signal_emit
|
|
|
|
(it->deco_all_view, "elm,state,unselected", "elm");
|
|
|
|
|
|
|
|
if (!it->item->nostacking)
|
|
|
|
{
|
|
|
|
if ((it->item->order_num_in & 0x1) ^ it->item->stacking_even)
|
|
|
|
{
|
2013-06-22 23:17:39 -07:00
|
|
|
if (it->deco_all_view) evas_object_stack_below(it->deco_all_view, sd->stack[0]);
|
|
|
|
else evas_object_stack_below(VIEW(it), sd->stack[0]);
|
2012-07-16 14:56:30 -07:00
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
2013-06-22 23:17:39 -07:00
|
|
|
if (it->deco_all_view) evas_object_stack_above(it->deco_all_view, sd->stack[0]);
|
|
|
|
else evas_object_stack_above(VIEW(it), sd->stack[0]);
|
2012-07-16 14:56:30 -07:00
|
|
|
}
|
|
|
|
}
|
|
|
|
it->highlighted = EINA_FALSE;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
_item_block_position_update(Eina_Inlist *list,
|
|
|
|
int idx)
|
|
|
|
{
|
|
|
|
Item_Block *tmp;
|
|
|
|
|
2012-10-01 00:36:27 -07:00
|
|
|
EINA_INLIST_FOREACH(list, tmp)
|
2012-07-16 14:56:30 -07:00
|
|
|
{
|
|
|
|
tmp->position = idx++;
|
|
|
|
tmp->position_update = EINA_TRUE;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
_item_position_update(Eina_List *list,
|
|
|
|
int idx)
|
|
|
|
{
|
|
|
|
Elm_Gen_Item *it;
|
|
|
|
Eina_List *l;
|
|
|
|
|
2012-10-01 00:36:27 -07:00
|
|
|
EINA_LIST_FOREACH(list, l, it)
|
2012-07-16 14:56:30 -07:00
|
|
|
{
|
|
|
|
it->position = idx++;
|
|
|
|
it->position_update = EINA_TRUE;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
_item_block_merge(Item_Block *left,
|
|
|
|
Item_Block *right)
|
|
|
|
{
|
|
|
|
Eina_List *l;
|
|
|
|
Elm_Gen_Item *it2;
|
|
|
|
|
2012-10-01 00:36:27 -07:00
|
|
|
EINA_LIST_FOREACH(right->items, l, it2)
|
2012-07-16 14:56:30 -07:00
|
|
|
{
|
|
|
|
it2->item->block = left;
|
|
|
|
left->count++;
|
|
|
|
left->changed = EINA_TRUE;
|
|
|
|
}
|
|
|
|
left->items = eina_list_merge(left->items, right->items);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
_item_block_del(Elm_Gen_Item *it)
|
|
|
|
{
|
|
|
|
Eina_Inlist *il;
|
|
|
|
Item_Block *itb = it->item->block;
|
|
|
|
Eina_Bool block_changed = EINA_FALSE;
|
2013-05-02 11:13:36 -07:00
|
|
|
ELM_GENLIST_DATA_GET_FROM_ITEM(it, sd);
|
2012-07-16 14:56:30 -07:00
|
|
|
|
|
|
|
itb->items = eina_list_remove(itb->items, it);
|
|
|
|
itb->count--;
|
|
|
|
itb->changed = EINA_TRUE;
|
2014-01-21 06:16:41 -08:00
|
|
|
ecore_job_del(sd->calc_job);
|
2013-05-02 11:13:36 -07:00
|
|
|
sd->calc_job = ecore_job_add(_calc_job, sd->obj);
|
2012-07-16 14:56:30 -07:00
|
|
|
if (itb->count < 1)
|
|
|
|
{
|
|
|
|
Item_Block *itbn;
|
|
|
|
|
|
|
|
il = EINA_INLIST_GET(itb);
|
|
|
|
itbn = (Item_Block *)(il->next);
|
|
|
|
if (it->parent)
|
|
|
|
it->parent->item->items =
|
|
|
|
eina_list_remove(it->parent->item->items, it);
|
|
|
|
else
|
|
|
|
{
|
|
|
|
_item_block_position_update(il->next, itb->position);
|
2013-05-02 11:13:36 -07:00
|
|
|
sd->blocks = eina_inlist_remove(sd->blocks, il);
|
2012-07-16 14:56:30 -07:00
|
|
|
}
|
|
|
|
free(itb);
|
|
|
|
if (itbn) itbn->changed = EINA_TRUE;
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
2013-05-02 11:13:36 -07:00
|
|
|
if (itb->count < (sd->max_items_per_block / 2))
|
2012-07-16 14:56:30 -07:00
|
|
|
{
|
|
|
|
Item_Block *itbp;
|
|
|
|
Item_Block *itbn;
|
|
|
|
|
|
|
|
il = EINA_INLIST_GET(itb);
|
|
|
|
itbp = (Item_Block *)(il->prev);
|
|
|
|
itbn = (Item_Block *)(il->next);
|
|
|
|
|
|
|
|
/* merge block with previous */
|
|
|
|
if ((itbp) &&
|
|
|
|
((itbp->count + itb->count) <
|
2013-05-02 11:13:36 -07:00
|
|
|
(sd->max_items_per_block +
|
|
|
|
(sd->max_items_per_block / 2))))
|
2012-07-16 14:56:30 -07:00
|
|
|
{
|
|
|
|
_item_block_merge(itbp, itb);
|
|
|
|
_item_block_position_update
|
|
|
|
(EINA_INLIST_GET(itb)->next, itb->position);
|
2013-05-02 11:13:36 -07:00
|
|
|
sd->blocks = eina_inlist_remove
|
|
|
|
(sd->blocks, EINA_INLIST_GET(itb));
|
2012-07-16 14:56:30 -07:00
|
|
|
free(itb);
|
|
|
|
block_changed = EINA_TRUE;
|
|
|
|
}
|
|
|
|
/* merge block with next */
|
|
|
|
else if ((itbn) &&
|
|
|
|
((itbn->count + itb->count) <
|
2013-05-02 11:13:36 -07:00
|
|
|
(sd->max_items_per_block +
|
|
|
|
(sd->max_items_per_block / 2))))
|
2012-07-16 14:56:30 -07:00
|
|
|
{
|
|
|
|
_item_block_merge(itb, itbn);
|
|
|
|
_item_block_position_update
|
|
|
|
(EINA_INLIST_GET(itbn)->next, itbn->position);
|
2013-05-02 11:13:36 -07:00
|
|
|
sd->blocks =
|
|
|
|
eina_inlist_remove(sd->blocks, EINA_INLIST_GET(itbn));
|
2012-07-16 14:56:30 -07:00
|
|
|
free(itbn);
|
|
|
|
block_changed = EINA_TRUE;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if (block_changed)
|
|
|
|
{
|
2013-05-02 11:13:36 -07:00
|
|
|
sd->pan_changed = EINA_TRUE;
|
|
|
|
evas_object_smart_changed(sd->pan_obj);
|
2014-01-21 06:16:41 -08:00
|
|
|
ecore_job_del(sd->calc_job);
|
2013-05-02 11:13:36 -07:00
|
|
|
sd->calc_job = NULL;
|
2012-07-16 14:56:30 -07:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
_decorate_all_item_unrealize(Elm_Gen_Item *it)
|
|
|
|
{
|
|
|
|
Evas_Object *icon;
|
|
|
|
|
|
|
|
if ((!it) || (!it->item->decorate_all_item_realized)) return;
|
|
|
|
|
|
|
|
edje_object_part_unswallow(it->deco_all_view, VIEW(it));
|
|
|
|
evas_object_smart_member_add(VIEW(it), GL_IT(it)->wsd->pan_obj);
|
|
|
|
elm_widget_sub_object_add(WIDGET(it), VIEW(it));
|
2013-08-22 11:13:04 -07:00
|
|
|
_elm_genlist_item_position_state_update(it);
|
2012-07-16 14:56:30 -07:00
|
|
|
_elm_genlist_item_state_update(it, NULL);
|
|
|
|
|
2013-03-14 03:13:06 -07:00
|
|
|
if (it->item->wsd->reorder_mode)
|
|
|
|
{
|
|
|
|
edje_object_signal_emit
|
|
|
|
(VIEW(it), "elm,state,reorder,mode_set", "elm");
|
|
|
|
edje_object_signal_emit
|
|
|
|
(it->deco_all_view, "elm,state,reorder,mode_unset", "elm");
|
|
|
|
}
|
|
|
|
|
2013-09-05 21:00:42 -07:00
|
|
|
ELM_SAFE_FREE(it->deco_all_view, evas_object_del);
|
|
|
|
ELM_SAFE_FREE(it->item->deco_all_texts, elm_widget_stringlist_free);
|
|
|
|
ELM_SAFE_FREE(it->item->deco_all_contents, elm_widget_stringlist_free);
|
|
|
|
ELM_SAFE_FREE(it->item->deco_all_states, elm_widget_stringlist_free);
|
|
|
|
|
2013-03-08 20:23:42 -08:00
|
|
|
EINA_LIST_FREE(it->item->deco_all_content_objs, icon)
|
2012-07-16 14:56:30 -07:00
|
|
|
evas_object_del(icon);
|
|
|
|
edje_object_message_signal_process(it->deco_all_view);
|
|
|
|
_item_mouse_callbacks_del(it, it->deco_all_view);
|
|
|
|
_item_mouse_callbacks_add(it, VIEW(it));
|
|
|
|
|
|
|
|
it->item->decorate_all_item_realized = EINA_FALSE;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
_elm_genlist_item_del_not_serious(Elm_Gen_Item *it)
|
|
|
|
{
|
2013-05-02 11:13:36 -07:00
|
|
|
ELM_GENLIST_DATA_GET_FROM_ITEM(it, sd);
|
|
|
|
|
2012-07-16 14:56:30 -07:00
|
|
|
elm_widget_item_pre_notify_del(it);
|
2013-05-02 11:13:36 -07:00
|
|
|
it->generation = sd->generation - 1; /* This means that
|
2013-04-17 09:30:34 -07:00
|
|
|
* the item is
|
|
|
|
* deleted */
|
|
|
|
|
|
|
|
if (it->walking > 0) return;
|
2012-07-16 14:56:30 -07:00
|
|
|
|
|
|
|
if (it->selected)
|
2014-03-23 07:37:47 -07:00
|
|
|
{
|
|
|
|
sd->selected = eina_list_remove(sd->selected, it);
|
|
|
|
if (sd->deselecting)
|
|
|
|
sd->deselecting = eina_list_remove(sd->deselecting, it);
|
|
|
|
}
|
2014-03-08 09:55:35 -08:00
|
|
|
if (sd->last_focused_item == (Elm_Object_Item *)it)
|
|
|
|
sd->last_focused_item = NULL;
|
|
|
|
if (sd->focused_item == (Elm_Object_Item *)it)
|
|
|
|
sd->focused_item = NULL;
|
2014-03-15 10:35:10 -07:00
|
|
|
if (sd->prev_focused_item == (Elm_Object_Item *)it)
|
|
|
|
sd->prev_focused_item = NULL;
|
2014-03-08 09:55:35 -08:00
|
|
|
if (sd->last_selected_item == (Elm_Object_Item *)it)
|
|
|
|
sd->last_selected_item = NULL;
|
2012-07-16 14:56:30 -07:00
|
|
|
|
|
|
|
if (it->itc->func.del)
|
|
|
|
it->itc->func.del((void *)it->base.data, WIDGET(it));
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
_elm_genlist_item_del_serious(Elm_Gen_Item *it)
|
|
|
|
{
|
2013-05-02 11:13:36 -07:00
|
|
|
ELM_GENLIST_DATA_GET_FROM_ITEM(it, sd);
|
|
|
|
|
2012-07-16 14:56:30 -07:00
|
|
|
_elm_genlist_item_del_not_serious(it);
|
|
|
|
|
2013-05-02 11:13:36 -07:00
|
|
|
sd->items = eina_inlist_remove(sd->items, EINA_INLIST_GET(it));
|
2012-07-16 14:56:30 -07:00
|
|
|
if (it->tooltip.del_cb)
|
|
|
|
it->tooltip.del_cb((void *)it->tooltip.data, WIDGET(it), it);
|
2013-05-02 11:13:36 -07:00
|
|
|
sd->walking -= it->walking;
|
2013-05-29 04:54:11 -07:00
|
|
|
ELM_SAFE_FREE(it->long_timer, ecore_timer_del);
|
2012-07-16 14:56:30 -07:00
|
|
|
if (it->group)
|
2013-05-02 11:13:36 -07:00
|
|
|
sd->group_items = eina_list_remove(sd->group_items, it);
|
2012-07-16 14:56:30 -07:00
|
|
|
|
2013-09-05 21:00:42 -07:00
|
|
|
ELM_SAFE_FREE(sd->state, eina_inlist_sorted_state_free);
|
2014-01-21 06:16:41 -08:00
|
|
|
ecore_job_del(sd->calc_job);
|
2013-05-02 11:13:36 -07:00
|
|
|
sd->calc_job = ecore_job_add(_calc_job, sd->obj);
|
2012-07-16 14:56:30 -07:00
|
|
|
|
2013-05-02 11:13:36 -07:00
|
|
|
sd->item_count--;
|
2012-07-16 14:56:30 -07:00
|
|
|
|
2013-05-29 04:54:11 -07:00
|
|
|
ELM_SAFE_FREE(it->item, free);
|
2012-07-16 14:56:30 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
_item_del(Elm_Gen_Item *it)
|
|
|
|
{
|
|
|
|
Evas_Object *obj = WIDGET(it);
|
2013-05-02 11:13:36 -07:00
|
|
|
ELM_GENLIST_DATA_GET_FROM_ITEM(it, sd);
|
2012-07-16 14:56:30 -07:00
|
|
|
|
|
|
|
evas_event_freeze(evas_object_evas_get(obj));
|
2013-09-09 00:12:45 -07:00
|
|
|
|
|
|
|
// FIXME: relative will be better to be fixed. it is too harsh.
|
|
|
|
if (it->item->rel)
|
|
|
|
it->item->rel->item->rel_revs =
|
|
|
|
eina_list_remove(it->item->rel->item->rel_revs, it);
|
|
|
|
if (it->item->rel_revs)
|
|
|
|
{
|
|
|
|
Elm_Gen_Item *tmp;
|
|
|
|
EINA_LIST_FREE(it->item->rel_revs, tmp) tmp->item->rel = NULL;
|
|
|
|
}
|
2012-07-16 14:56:30 -07:00
|
|
|
elm_genlist_item_subitems_clear((Elm_Object_Item *)it);
|
|
|
|
if (sd->show_item == it) sd->show_item = NULL;
|
|
|
|
if (it->realized) _elm_genlist_item_unrealize(it, EINA_FALSE);
|
|
|
|
if (it->item->decorate_all_item_realized) _decorate_all_item_unrealize(it);
|
|
|
|
if (it->item->block) _item_block_del(it);
|
|
|
|
if (it->item->queued)
|
|
|
|
sd->queue = eina_list_remove(sd->queue, it);
|
|
|
|
if (sd->anchor_item == it)
|
|
|
|
{
|
|
|
|
sd->anchor_item = ELM_GEN_ITEM_FROM_INLIST(EINA_INLIST_GET(it)->next);
|
|
|
|
if (!sd->anchor_item)
|
|
|
|
sd->anchor_item =
|
|
|
|
ELM_GEN_ITEM_FROM_INLIST(EINA_INLIST_GET(it)->prev);
|
|
|
|
}
|
|
|
|
if (sd->expanded_item == it)
|
|
|
|
{
|
|
|
|
if (sd->tree_effect_animator)
|
|
|
|
{
|
|
|
|
_item_tree_effect_finish(sd);
|
2013-05-29 04:54:11 -07:00
|
|
|
ELM_SAFE_FREE(sd->tree_effect_animator, ecore_animator_del);
|
2012-07-16 14:56:30 -07:00
|
|
|
}
|
|
|
|
sd->expanded_item = NULL;
|
|
|
|
sd->move_effect_mode = ELM_GENLIST_TREE_EFFECT_NONE;
|
|
|
|
}
|
|
|
|
if (sd->expanded_next_item == it) sd->expanded_next_item = NULL;
|
|
|
|
if (sd->move_items) sd->move_items = eina_list_remove(sd->move_items, it);
|
|
|
|
if (it->parent)
|
|
|
|
it->parent->item->items = eina_list_remove(it->parent->item->items, it);
|
2013-05-29 04:54:11 -07:00
|
|
|
ELM_SAFE_FREE(it->item->swipe_timer, ecore_timer_del);
|
2012-07-16 14:56:30 -07:00
|
|
|
_elm_genlist_item_del_serious(it);
|
|
|
|
elm_genlist_item_class_unref((Elm_Genlist_Item_Class *)it->itc);
|
|
|
|
evas_event_thaw(evas_object_evas_get(obj));
|
|
|
|
evas_event_thaw_eval(evas_object_evas_get(obj));
|
2013-11-27 23:36:55 -08:00
|
|
|
if (!sd->queue) _item_scroll(sd);
|
2012-07-16 14:56:30 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
_item_unselect(Elm_Gen_Item *it)
|
|
|
|
{
|
2013-05-02 11:13:36 -07:00
|
|
|
ELM_GENLIST_DATA_GET_FROM_ITEM(it, sd);
|
|
|
|
|
|
|
|
if ((it->generation < sd->generation)) return;
|
2014-03-22 03:10:27 -07:00
|
|
|
it->unhighlight_cb(it); /* unhighlight the item first */
|
2012-11-16 06:26:12 -08:00
|
|
|
if (!it->selected) return; /* then check whether the item is selected */
|
2012-07-16 14:56:30 -07:00
|
|
|
|
2013-02-20 02:00:49 -08:00
|
|
|
if (GL_IT(it)->wsd->focus_on_selection_enabled)
|
|
|
|
{
|
|
|
|
Evas_Object* eobj;
|
|
|
|
Eina_List* l;
|
|
|
|
EINA_LIST_FOREACH(it->item_focus_chain, l, eobj)
|
|
|
|
elm_object_focus_set(eobj, EINA_FALSE);
|
|
|
|
}
|
|
|
|
|
2012-07-16 14:56:30 -07:00
|
|
|
it->selected = EINA_FALSE;
|
2013-05-02 11:13:36 -07:00
|
|
|
sd->selected = eina_list_remove(sd->selected, it);
|
2012-07-16 14:56:30 -07:00
|
|
|
evas_object_smart_callback_call(WIDGET(it), SIG_UNSELECTED, it);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
_item_mouse_move_cb(void *data,
|
2014-01-06 06:30:02 -08:00
|
|
|
Evas *evas EINA_UNUSED,
|
2012-07-16 14:56:30 -07:00
|
|
|
Evas_Object *obj,
|
|
|
|
void *event_info)
|
|
|
|
{
|
|
|
|
Elm_Gen_Item *it = data;
|
|
|
|
Evas_Event_Mouse_Move *ev = event_info;
|
|
|
|
Evas_Coord ox, oy, ow, oh, it_scrl_y, y_pos;
|
2013-07-02 03:33:00 -07:00
|
|
|
Evas_Coord minw = 0, minh = 0, x, y, w, h, dx, dy, adx, ady;
|
2013-05-02 11:13:36 -07:00
|
|
|
ELM_GENLIST_DATA_GET_FROM_ITEM(it, sd);
|
2012-07-16 14:56:30 -07:00
|
|
|
|
|
|
|
if (ev->event_flags & EVAS_EVENT_FLAG_ON_HOLD)
|
|
|
|
{
|
|
|
|
if (!sd->on_hold)
|
|
|
|
{
|
|
|
|
sd->on_hold = EINA_TRUE;
|
|
|
|
if ((!sd->wasselected) && (!it->flipped))
|
2014-03-22 03:10:27 -07:00
|
|
|
it->unsel_cb(it);
|
2012-07-16 14:56:30 -07:00
|
|
|
}
|
|
|
|
}
|
|
|
|
if (sd->multi_touched)
|
|
|
|
{
|
|
|
|
sd->cur_x = ev->cur.canvas.x;
|
|
|
|
sd->cur_y = ev->cur.canvas.y;
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
if ((it->dragging) && (it->down))
|
|
|
|
{
|
|
|
|
if (sd->movements == SWIPE_MOVES)
|
|
|
|
sd->swipe = EINA_TRUE;
|
|
|
|
else
|
|
|
|
{
|
|
|
|
sd->history[sd->movements].x = ev->cur.canvas.x;
|
|
|
|
sd->history[sd->movements].y = ev->cur.canvas.y;
|
|
|
|
if (abs((sd->history[sd->movements].x -
|
|
|
|
sd->history[0].x)) > 40)
|
|
|
|
sd->swipe = EINA_TRUE;
|
|
|
|
else
|
|
|
|
sd->movements++;
|
|
|
|
}
|
2013-05-29 04:54:11 -07:00
|
|
|
ELM_SAFE_FREE(it->long_timer, ecore_timer_del);
|
2012-07-16 14:56:30 -07:00
|
|
|
evas_object_smart_callback_call(WIDGET(it), SIG_DRAG, it);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
if ((!it->down) || (sd->longpressed))
|
|
|
|
{
|
2013-05-29 04:54:11 -07:00
|
|
|
ELM_SAFE_FREE(it->long_timer, ecore_timer_del);
|
2012-07-16 14:56:30 -07:00
|
|
|
if ((sd->reorder_mode) && (sd->reorder_it))
|
|
|
|
{
|
|
|
|
evas_object_geometry_get(sd->pan_obj, &ox, &oy, &ow, &oh);
|
2012-10-01 01:55:46 -07:00
|
|
|
|
|
|
|
if (ev->cur.canvas.y < (oy + (sd->reorder_it->item->h / 2)))
|
|
|
|
sd->reorder_fast = 1;
|
|
|
|
else if (ev->cur.canvas.y > (oy + oh - (sd->reorder_it->item->h / 2)))
|
|
|
|
sd->reorder_fast = -1;
|
|
|
|
else sd->reorder_fast = 0;
|
|
|
|
|
2012-07-16 14:56:30 -07:00
|
|
|
it_scrl_y = ev->cur.canvas.y - sd->reorder_it->dy;
|
|
|
|
|
|
|
|
if (!sd->reorder_start_y)
|
|
|
|
sd->reorder_start_y = it->item->block->y + it->y;
|
|
|
|
|
|
|
|
if (it_scrl_y < oy)
|
|
|
|
y_pos = oy;
|
|
|
|
else if (it_scrl_y + sd->reorder_it->item->h > oy + oh)
|
|
|
|
y_pos = oy + oh - sd->reorder_it->item->h;
|
|
|
|
else
|
|
|
|
y_pos = it_scrl_y;
|
|
|
|
|
|
|
|
if (it->deco_all_view)
|
|
|
|
_item_position(it, it->deco_all_view, it->item->scrl_x, y_pos);
|
|
|
|
else
|
|
|
|
_item_position(it, VIEW(it), it->item->scrl_x, y_pos);
|
|
|
|
|
2014-01-21 06:16:41 -08:00
|
|
|
ecore_job_del(sd->calc_job);
|
2013-04-24 04:41:37 -07:00
|
|
|
sd->calc_job = ecore_job_add(_calc_job, sd->obj);
|
2012-07-16 14:56:30 -07:00
|
|
|
}
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
if (it->select_mode != ELM_OBJECT_SELECT_MODE_DISPLAY_ONLY)
|
|
|
|
elm_coords_finger_size_adjust(1, &minw, 1, &minh);
|
|
|
|
|
2013-07-02 03:33:00 -07:00
|
|
|
evas_object_geometry_get(obj, &x, &y, &w, &h);
|
2012-07-16 14:56:30 -07:00
|
|
|
x = ev->cur.canvas.x - x;
|
|
|
|
y = ev->cur.canvas.y - y;
|
|
|
|
dx = x - it->dx;
|
|
|
|
adx = dx;
|
|
|
|
if (adx < 0) adx = -dx;
|
|
|
|
|
|
|
|
dy = y - it->dy;
|
|
|
|
ady = dy;
|
|
|
|
if (ady < 0) ady = -dy;
|
|
|
|
|
|
|
|
minw /= 2;
|
|
|
|
minh /= 2;
|
2013-09-30 03:21:31 -07:00
|
|
|
|
2013-07-02 03:33:00 -07:00
|
|
|
// gah! annoying drag detection - leave this alone
|
|
|
|
if (h < w)
|
|
|
|
{
|
|
|
|
if (minw < h) minw = h;
|
|
|
|
if (minh < h) minh = h;
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
if (minw < w) minw = w;
|
|
|
|
if (minh < w) minh = w;
|
|
|
|
}
|
|
|
|
if (minw < 5) minw = 5;
|
|
|
|
if (minh < 5) minh = 5;
|
2013-09-30 03:21:31 -07:00
|
|
|
|
2012-07-16 14:56:30 -07:00
|
|
|
if ((adx > minw) || (ady > minh))
|
|
|
|
{
|
|
|
|
it->dragging = EINA_TRUE;
|
2013-05-29 04:54:11 -07:00
|
|
|
ELM_SAFE_FREE(it->long_timer, ecore_timer_del);
|
2012-07-16 14:56:30 -07:00
|
|
|
if (!sd->wasselected)
|
2014-03-22 03:10:27 -07:00
|
|
|
it->unsel_cb(it);
|
2012-07-16 14:56:30 -07:00
|
|
|
if (dy < 0)
|
|
|
|
{
|
|
|
|
if (ady > adx)
|
|
|
|
evas_object_smart_callback_call
|
|
|
|
(WIDGET(it), SIG_DRAG_START_UP, it);
|
|
|
|
else
|
|
|
|
{
|
|
|
|
if (dx < 0)
|
|
|
|
evas_object_smart_callback_call
|
|
|
|
(WIDGET(it), SIG_DRAG_START_LEFT, it);
|
|
|
|
else
|
|
|
|
evas_object_smart_callback_call
|
|
|
|
(WIDGET(it), SIG_DRAG_START_RIGHT, it);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
if (ady > adx)
|
|
|
|
evas_object_smart_callback_call
|
|
|
|
(WIDGET(it), SIG_DRAG_START_DOWN, it);
|
|
|
|
else
|
|
|
|
{
|
|
|
|
if (dx < 0)
|
|
|
|
evas_object_smart_callback_call
|
|
|
|
(WIDGET(it), SIG_DRAG_START_LEFT, it);
|
|
|
|
else
|
|
|
|
evas_object_smart_callback_call
|
|
|
|
(WIDGET(it), SIG_DRAG_START_RIGHT, it);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
static Eina_Bool
|
|
|
|
_long_press_cb(void *data)
|
|
|
|
{
|
|
|
|
Elm_Gen_Item *it = data, *it_tmp;
|
2013-03-13 04:25:12 -07:00
|
|
|
Eina_List *list;
|
2013-05-02 11:13:36 -07:00
|
|
|
ELM_GENLIST_DATA_GET_FROM_ITEM(it, sd);
|
2012-07-16 14:56:30 -07:00
|
|
|
|
|
|
|
it->long_timer = NULL;
|
|
|
|
if (elm_widget_item_disabled_get(it) || (it->dragging) ||
|
|
|
|
(it->select_mode == ELM_OBJECT_SELECT_MODE_DISPLAY_ONLY))
|
|
|
|
return ECORE_CALLBACK_CANCEL;
|
|
|
|
|
2013-05-02 11:13:36 -07:00
|
|
|
sd->longpressed = EINA_TRUE;
|
2012-07-16 14:56:30 -07:00
|
|
|
evas_object_smart_callback_call(WIDGET(it), SIG_LONGPRESSED, it);
|
2013-05-02 11:13:36 -07:00
|
|
|
if ((sd->reorder_mode) && (!it->group))
|
2012-07-16 14:56:30 -07:00
|
|
|
{
|
2013-05-02 11:13:36 -07:00
|
|
|
sd->reorder_it = it;
|
|
|
|
sd->reorder_start_y = 0;
|
2012-07-16 14:56:30 -07:00
|
|
|
if (it->deco_all_view)
|
2013-06-22 23:17:39 -07:00
|
|
|
evas_object_stack_below(it->deco_all_view, sd->stack[1]);
|
2012-07-16 14:56:30 -07:00
|
|
|
else
|
2013-06-22 23:17:39 -07:00
|
|
|
evas_object_stack_below(VIEW(it), sd->stack[1]);
|
2012-07-16 14:56:30 -07:00
|
|
|
|
2014-03-17 04:44:40 -07:00
|
|
|
eo_do(sd->obj, elm_interface_scrollable_hold_set(EINA_TRUE));
|
|
|
|
eo_do(sd->obj, elm_interface_scrollable_bounce_allow_set
|
2012-11-25 22:32:53 -08:00
|
|
|
(EINA_FALSE, EINA_FALSE));
|
2012-07-16 14:56:30 -07:00
|
|
|
|
|
|
|
list = elm_genlist_realized_items_get
|
2013-05-02 11:13:36 -07:00
|
|
|
((sd)->obj);
|
2013-03-13 04:25:12 -07:00
|
|
|
EINA_LIST_FREE(list, it_tmp)
|
2014-03-22 03:10:27 -07:00
|
|
|
if (it != it_tmp) it->unsel_cb(it_tmp);
|
2013-03-13 04:25:12 -07:00
|
|
|
|
2012-07-16 14:56:30 -07:00
|
|
|
if (elm_genlist_item_expanded_get((Elm_Object_Item *)it))
|
|
|
|
{
|
|
|
|
elm_genlist_item_expanded_set((Elm_Object_Item *)it, EINA_FALSE);
|
|
|
|
return ECORE_CALLBACK_RENEW;
|
|
|
|
}
|
|
|
|
|
2013-05-02 11:13:36 -07:00
|
|
|
if (!sd->decorate_all_mode)
|
2012-07-16 14:56:30 -07:00
|
|
|
edje_object_signal_emit
|
|
|
|
(VIEW(it), "elm,state,reorder,enabled", "elm");
|
|
|
|
}
|
|
|
|
|
|
|
|
return ECORE_CALLBACK_CANCEL;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
_swipe_do(Elm_Gen_Item *it)
|
|
|
|
{
|
|
|
|
int i, sum = 0;
|
2013-05-02 11:13:36 -07:00
|
|
|
ELM_GENLIST_DATA_GET_FROM_ITEM(it, sd);
|
2012-07-16 14:56:30 -07:00
|
|
|
|
|
|
|
if ((it->select_mode == ELM_OBJECT_SELECT_MODE_DISPLAY_ONLY) ||
|
|
|
|
elm_widget_item_disabled_get(it)) return;
|
|
|
|
|
2013-05-02 11:13:36 -07:00
|
|
|
sd->swipe = EINA_FALSE;
|
|
|
|
for (i = 0; i < sd->movements; i++)
|
2012-07-16 14:56:30 -07:00
|
|
|
{
|
2013-05-02 11:13:36 -07:00
|
|
|
sum += sd->history[i].x;
|
|
|
|
if (abs(sd->history[0].y - sd->history[i].y) > 10)
|
|
|
|
return;
|
2012-07-16 14:56:30 -07:00
|
|
|
}
|
|
|
|
|
2013-05-02 11:13:36 -07:00
|
|
|
sum /= sd->movements;
|
|
|
|
if (abs(sum - sd->history[0].x) <= 10) return;
|
2012-07-16 14:56:30 -07:00
|
|
|
evas_object_smart_callback_call(WIDGET(it), SIG_SWIPE, it);
|
|
|
|
}
|
|
|
|
|
|
|
|
static Eina_Bool
|
|
|
|
_swipe_cancel(void *data)
|
|
|
|
{
|
|
|
|
Elm_Gen_Item *it = data;
|
|
|
|
if (!it) return ECORE_CALLBACK_CANCEL;
|
2013-05-02 11:13:36 -07:00
|
|
|
ELM_GENLIST_DATA_GET_FROM_ITEM(it, sd);
|
|
|
|
|
|
|
|
sd->swipe = EINA_FALSE;
|
|
|
|
sd->movements = 0;
|
2012-07-16 14:56:30 -07:00
|
|
|
|
|
|
|
return ECORE_CALLBACK_RENEW;
|
|
|
|
}
|
|
|
|
|
|
|
|
static Eina_Bool
|
|
|
|
_multi_cancel(void *data)
|
|
|
|
{
|
2013-04-24 04:41:37 -07:00
|
|
|
ELM_GENLIST_DATA_GET(data, sd);
|
2012-07-16 14:56:30 -07:00
|
|
|
|
|
|
|
if (!sd) return ECORE_CALLBACK_CANCEL;
|
|
|
|
sd->multi_timeout = EINA_TRUE;
|
|
|
|
|
|
|
|
return ECORE_CALLBACK_RENEW;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
2013-07-05 21:00:39 -07:00
|
|
|
_multi_touch_gesture_eval(Elm_Gen_Item *it)
|
2012-07-16 14:56:30 -07:00
|
|
|
{
|
|
|
|
Evas_Coord minw = 0, minh = 0;
|
|
|
|
Evas_Coord off_x, off_y, off_mx, off_my;
|
2013-05-02 11:13:36 -07:00
|
|
|
ELM_GENLIST_DATA_GET_FROM_ITEM(it, sd);
|
2012-07-16 14:56:30 -07:00
|
|
|
|
2013-05-02 11:13:36 -07:00
|
|
|
sd->multi_touched = EINA_FALSE;
|
2013-05-29 04:54:11 -07:00
|
|
|
ELM_SAFE_FREE(sd->multi_timer, ecore_timer_del);
|
2013-05-02 11:13:36 -07:00
|
|
|
if (sd->multi_timeout)
|
2012-07-16 14:56:30 -07:00
|
|
|
{
|
2013-05-02 11:13:36 -07:00
|
|
|
sd->multi_timeout = EINA_FALSE;
|
2012-07-16 14:56:30 -07:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
elm_coords_finger_size_adjust(1, &minw, 1, &minh);
|
2013-05-02 11:13:36 -07:00
|
|
|
off_x = abs(sd->cur_x - sd->prev_x);
|
|
|
|
off_y = abs(sd->cur_y - sd->prev_y);
|
|
|
|
off_mx = abs(sd->cur_mx - sd->prev_mx);
|
|
|
|
off_my = abs(sd->cur_my - sd->prev_my);
|
2012-07-16 14:56:30 -07:00
|
|
|
|
|
|
|
if (((off_x > minw) || (off_y > minh)) && ((off_mx > minw)
|
|
|
|
|| (off_my > minh)))
|
|
|
|
{
|
|
|
|
if ((off_x + off_mx) > (off_y + off_my))
|
|
|
|
{
|
2013-05-02 11:13:36 -07:00
|
|
|
if ((sd->cur_x > sd->prev_x) && (sd->cur_mx > sd->prev_mx))
|
2012-07-16 14:56:30 -07:00
|
|
|
evas_object_smart_callback_call
|
|
|
|
(WIDGET(it), SIG_MULTI_SWIPE_RIGHT, it);
|
2013-05-02 11:13:36 -07:00
|
|
|
else if ((sd->cur_x < sd->prev_x) && (sd->cur_mx < sd->prev_mx))
|
2012-07-16 14:56:30 -07:00
|
|
|
evas_object_smart_callback_call
|
|
|
|
(WIDGET(it), SIG_MULTI_SWIPE_LEFT, it);
|
2013-05-02 11:13:36 -07:00
|
|
|
else if (abs(sd->cur_x - sd->cur_mx) >
|
|
|
|
abs(sd->prev_x - sd->prev_mx))
|
2012-07-16 14:56:30 -07:00
|
|
|
evas_object_smart_callback_call
|
|
|
|
(WIDGET(it), SIG_MULTI_PINCH_OUT, it);
|
|
|
|
else
|
|
|
|
evas_object_smart_callback_call
|
|
|
|
(WIDGET(it), SIG_MULTI_PINCH_IN, it);
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
2013-05-02 11:13:36 -07:00
|
|
|
if ((sd->cur_y > sd->prev_y) && (sd->cur_my > sd->prev_my))
|
2012-07-16 14:56:30 -07:00
|
|
|
evas_object_smart_callback_call
|
|
|
|
(WIDGET(it), SIG_MULTI_SWIPE_DOWN, it);
|
2013-05-02 11:13:36 -07:00
|
|
|
else if ((sd->cur_y < sd->prev_y) && (sd->cur_my < sd->prev_my))
|
2012-07-16 14:56:30 -07:00
|
|
|
evas_object_smart_callback_call
|
|
|
|
(WIDGET(it), SIG_MULTI_SWIPE_UP, it);
|
2013-05-02 11:13:36 -07:00
|
|
|
else if (abs(sd->cur_y - sd->cur_my) >
|
|
|
|
abs(sd->prev_y - sd->prev_my))
|
2012-07-16 14:56:30 -07:00
|
|
|
evas_object_smart_callback_call
|
|
|
|
(WIDGET(it), SIG_MULTI_PINCH_OUT, it);
|
|
|
|
else
|
|
|
|
evas_object_smart_callback_call
|
|
|
|
(WIDGET(it), SIG_MULTI_PINCH_IN, it);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2013-05-02 11:13:36 -07:00
|
|
|
sd->multi_timeout = EINA_FALSE;
|
2012-07-16 14:56:30 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
_item_multi_down_cb(void *data,
|
2014-01-06 06:30:02 -08:00
|
|
|
Evas *evas EINA_UNUSED,
|
|
|
|
Evas_Object *obj EINA_UNUSED,
|
2012-07-16 14:56:30 -07:00
|
|
|
void *event_info)
|
|
|
|
{
|
|
|
|
Elm_Gen_Item *it = data;
|
|
|
|
Evas_Event_Multi_Down *ev = event_info;
|
2013-05-02 11:13:36 -07:00
|
|
|
ELM_GENLIST_DATA_GET_FROM_ITEM(it, sd);
|
2012-07-16 14:56:30 -07:00
|
|
|
|
2013-05-02 11:13:36 -07:00
|
|
|
if ((sd->multi_device != 0) || (sd->multi_touched)
|
|
|
|
|| (sd->multi_timeout))
|
2012-07-16 14:56:30 -07:00
|
|
|
return;
|
|
|
|
|
2013-05-02 11:13:36 -07:00
|
|
|
sd->multi_device = ev->device;
|
|
|
|
sd->multi_down = EINA_TRUE;
|
|
|
|
sd->multi_touched = EINA_TRUE;
|
|
|
|
sd->prev_mx = ev->canvas.x;
|
|
|
|
sd->prev_my = ev->canvas.y;
|
|
|
|
if (!sd->wasselected)
|
2014-03-22 03:10:27 -07:00
|
|
|
it->unsel_cb(it);
|
2013-05-02 11:13:36 -07:00
|
|
|
sd->wasselected = EINA_FALSE;
|
|
|
|
sd->longpressed = EINA_FALSE;
|
2013-05-29 04:54:11 -07:00
|
|
|
ELM_SAFE_FREE(it->long_timer, ecore_timer_del);
|
2012-07-16 14:56:30 -07:00
|
|
|
if (it->dragging)
|
|
|
|
{
|
|
|
|
it->dragging = EINA_FALSE;
|
|
|
|
evas_object_smart_callback_call(WIDGET(it), SIG_DRAG_STOP, it);
|
|
|
|
}
|
2013-05-29 04:54:11 -07:00
|
|
|
ELM_SAFE_FREE(it->item->swipe_timer, ecore_timer_del);
|
2013-05-02 11:13:36 -07:00
|
|
|
if (sd->on_hold)
|
2012-07-16 14:56:30 -07:00
|
|
|
{
|
2013-05-02 11:13:36 -07:00
|
|
|
sd->swipe = EINA_FALSE;
|
|
|
|
sd->movements = 0;
|
|
|
|
sd->on_hold = EINA_FALSE;
|
2012-07-16 14:56:30 -07:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
_item_multi_up_cb(void *data,
|
2014-01-06 06:30:02 -08:00
|
|
|
Evas *evas EINA_UNUSED,
|
|
|
|
Evas_Object *obj EINA_UNUSED,
|
2012-07-16 14:56:30 -07:00
|
|
|
void *event_info)
|
|
|
|
{
|
|
|
|
Elm_Gen_Item *it = data;
|
|
|
|
Evas_Event_Multi_Up *ev = event_info;
|
2013-05-02 11:13:36 -07:00
|
|
|
ELM_GENLIST_DATA_GET_FROM_ITEM(it, sd);
|
2012-07-16 14:56:30 -07:00
|
|
|
|
2013-05-02 11:13:36 -07:00
|
|
|
if (sd->multi_device != ev->device) return;
|
|
|
|
sd->multi_device = 0;
|
|
|
|
sd->multi_down = EINA_FALSE;
|
|
|
|
if (sd->mouse_down) return;
|
2012-07-16 14:56:30 -07:00
|
|
|
_multi_touch_gesture_eval(data);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
_item_multi_move_cb(void *data,
|
2014-01-06 06:30:02 -08:00
|
|
|
Evas *evas EINA_UNUSED,
|
|
|
|
Evas_Object *obj EINA_UNUSED,
|
2012-07-16 14:56:30 -07:00
|
|
|
void *event_info)
|
|
|
|
{
|
|
|
|
Elm_Gen_Item *it = data;
|
|
|
|
Evas_Event_Multi_Move *ev = event_info;
|
2013-05-02 11:13:36 -07:00
|
|
|
ELM_GENLIST_DATA_GET_FROM_ITEM(it, sd);
|
2012-07-16 14:56:30 -07:00
|
|
|
|
2013-05-02 11:13:36 -07:00
|
|
|
if (sd->multi_device != ev->device) return;
|
|
|
|
sd->cur_mx = ev->cur.canvas.x;
|
|
|
|
sd->cur_my = ev->cur.canvas.y;
|
2012-07-16 14:56:30 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
_item_mouse_down_cb(void *data,
|
2014-01-06 06:30:02 -08:00
|
|
|
Evas *evas EINA_UNUSED,
|
2012-07-16 14:56:30 -07:00
|
|
|
Evas_Object *obj,
|
|
|
|
void *event_info)
|
|
|
|
{
|
|
|
|
Evas_Event_Mouse_Down *ev = event_info;
|
|
|
|
Elm_Gen_Item *it = data;
|
|
|
|
Evas_Coord x, y;
|
2013-05-02 11:13:36 -07:00
|
|
|
ELM_GENLIST_DATA_GET_FROM_ITEM(it, sd);
|
2012-07-16 14:56:30 -07:00
|
|
|
|
|
|
|
if (ev->button != 1) return;
|
|
|
|
if (ev->event_flags & EVAS_EVENT_FLAG_ON_HOLD)
|
|
|
|
{
|
|
|
|
sd->on_hold = EINA_TRUE;
|
|
|
|
}
|
|
|
|
|
|
|
|
it->down = EINA_TRUE;
|
|
|
|
it->dragging = EINA_FALSE;
|
|
|
|
evas_object_geometry_get(obj, &x, &y, NULL, NULL);
|
|
|
|
it->dx = ev->canvas.x - x;
|
|
|
|
it->dy = ev->canvas.y - y;
|
|
|
|
sd->mouse_down = EINA_TRUE;
|
|
|
|
if (!sd->multi_touched)
|
|
|
|
{
|
|
|
|
sd->prev_x = ev->canvas.x;
|
|
|
|
sd->prev_y = ev->canvas.y;
|
|
|
|
sd->multi_timeout = EINA_FALSE;
|
2014-01-21 06:16:41 -08:00
|
|
|
ecore_timer_del(sd->multi_timer);
|
2013-04-24 04:41:37 -07:00
|
|
|
sd->multi_timer = ecore_timer_add(MULTI_DOWN_TIME, _multi_cancel, sd->obj);
|
2012-07-16 14:56:30 -07:00
|
|
|
}
|
|
|
|
sd->longpressed = EINA_FALSE;
|
|
|
|
if (ev->event_flags & EVAS_EVENT_FLAG_ON_HOLD) sd->on_hold = EINA_TRUE;
|
|
|
|
else sd->on_hold = EINA_FALSE;
|
|
|
|
if (sd->on_hold) return;
|
|
|
|
sd->wasselected = it->selected;
|
2014-03-22 03:10:27 -07:00
|
|
|
it->highlight_cb(it);
|
2012-07-16 14:56:30 -07:00
|
|
|
if (ev->flags & EVAS_BUTTON_DOUBLE_CLICK)
|
|
|
|
if ((!elm_widget_item_disabled_get(it)) &&
|
|
|
|
(it->select_mode != ELM_OBJECT_SELECT_MODE_DISPLAY_ONLY))
|
|
|
|
{
|
|
|
|
evas_object_smart_callback_call(WIDGET(it), SIG_CLICKED_DOUBLE, it);
|
|
|
|
evas_object_smart_callback_call(WIDGET(it), SIG_ACTIVATED, it);
|
|
|
|
}
|
2013-03-20 09:39:51 -07:00
|
|
|
evas_object_smart_callback_call(WIDGET(it), SIG_PRESSED, it);
|
2014-01-21 06:16:41 -08:00
|
|
|
ecore_timer_del(it->item->swipe_timer);
|
2013-03-26 10:33:01 -07:00
|
|
|
it->item->swipe_timer = ecore_timer_add(SWIPE_TIME, _swipe_cancel, it);
|
2013-05-29 04:54:11 -07:00
|
|
|
ELM_SAFE_FREE(it->long_timer, ecore_timer_del);
|
2012-07-16 14:56:30 -07:00
|
|
|
if (it->realized)
|
|
|
|
it->long_timer = ecore_timer_add
|
|
|
|
(sd->longpress_timeout, _long_press_cb, it);
|
|
|
|
else
|
|
|
|
it->long_timer = NULL;
|
|
|
|
sd->swipe = EINA_FALSE;
|
|
|
|
sd->movements = 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static Item_Block *
|
|
|
|
_item_block_new(Elm_Genlist_Smart_Data *sd,
|
|
|
|
Eina_Bool prepend)
|
|
|
|
{
|
|
|
|
Item_Block *itb;
|
|
|
|
|
|
|
|
itb = calloc(1, sizeof(Item_Block));
|
|
|
|
if (!itb) return NULL;
|
|
|
|
itb->sd = sd;
|
|
|
|
if (prepend)
|
|
|
|
{
|
|
|
|
sd->blocks = eina_inlist_prepend(sd->blocks, EINA_INLIST_GET(itb));
|
|
|
|
_item_block_position_update(sd->blocks, 0);
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
sd->blocks = eina_inlist_append(sd->blocks, EINA_INLIST_GET(itb));
|
|
|
|
itb->position_update = EINA_TRUE;
|
|
|
|
if (sd->blocks != EINA_INLIST_GET(itb))
|
|
|
|
{
|
|
|
|
itb->position =
|
|
|
|
((Item_Block *)(EINA_INLIST_GET(itb)->prev))->position + 1;
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
itb->position = 0;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return itb;
|
|
|
|
}
|
|
|
|
|
2013-03-29 07:03:29 -07:00
|
|
|
/**
|
|
|
|
* @internal
|
|
|
|
*
|
|
|
|
* This function adds an item to a block's item list. This may or may not
|
|
|
|
* rearrange existing blocks and create a new block.
|
|
|
|
*
|
|
|
|
*/
|
2012-07-16 14:56:30 -07:00
|
|
|
static Eina_Bool
|
|
|
|
_item_block_add(Elm_Genlist_Smart_Data *sd,
|
|
|
|
Elm_Gen_Item *it)
|
|
|
|
{
|
|
|
|
Item_Block *itb = NULL;
|
|
|
|
|
2013-03-29 07:03:29 -07:00
|
|
|
// when a new item does not depend on another item
|
2012-07-16 14:56:30 -07:00
|
|
|
if (!it->item->rel)
|
|
|
|
{
|
|
|
|
newblock:
|
|
|
|
if (it->item->rel)
|
|
|
|
{
|
|
|
|
itb = calloc(1, sizeof(Item_Block));
|
|
|
|
if (!itb) return EINA_FALSE;
|
|
|
|
itb->sd = sd;
|
|
|
|
if (!it->item->rel->item->block)
|
|
|
|
{
|
|
|
|
sd->blocks =
|
|
|
|
eina_inlist_append(sd->blocks, EINA_INLIST_GET(itb));
|
|
|
|
itb->items = eina_list_append(itb->items, it);
|
|
|
|
itb->position_update = EINA_TRUE;
|
|
|
|
it->position = eina_list_count(itb->items);
|
|
|
|
it->position_update = EINA_TRUE;
|
|
|
|
|
|
|
|
if (sd->blocks != EINA_INLIST_GET(itb))
|
|
|
|
{
|
|
|
|
itb->position =
|
|
|
|
((Item_Block *)
|
|
|
|
(EINA_INLIST_GET(itb)->prev))->position + 1;
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
itb->position = 0;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
Eina_List *tmp;
|
|
|
|
|
|
|
|
tmp = eina_list_data_find_list(itb->items, it->item->rel);
|
|
|
|
if (it->item->before)
|
|
|
|
{
|
|
|
|
sd->blocks = eina_inlist_prepend_relative
|
|
|
|
(sd->blocks, EINA_INLIST_GET(itb),
|
|
|
|
EINA_INLIST_GET(it->item->rel->item->block));
|
|
|
|
itb->items =
|
|
|
|
eina_list_prepend_relative_list(itb->items, it, tmp);
|
|
|
|
|
|
|
|
/* Update index from where we prepended */
|
|
|
|
_item_position_update
|
|
|
|
(eina_list_prev(tmp), it->item->rel->position);
|
|
|
|
_item_block_position_update
|
|
|
|
(EINA_INLIST_GET(itb),
|
|
|
|
it->item->rel->item->block->position);
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
sd->blocks = eina_inlist_append_relative
|
|
|
|
(sd->blocks, EINA_INLIST_GET(itb),
|
|
|
|
EINA_INLIST_GET(it->item->rel->item->block));
|
|
|
|
itb->items =
|
|
|
|
eina_list_append_relative_list(itb->items, it, tmp);
|
|
|
|
|
|
|
|
/* Update block index from where we appended */
|
|
|
|
_item_position_update
|
|
|
|
(eina_list_next(tmp), it->item->rel->position + 1);
|
|
|
|
_item_block_position_update
|
|
|
|
(EINA_INLIST_GET(itb),
|
|
|
|
it->item->rel->item->block->position + 1);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
2013-03-29 07:03:29 -07:00
|
|
|
// item move_before, prepend, insert_before, sorted_insert with before
|
2012-07-16 14:56:30 -07:00
|
|
|
if (it->item->before)
|
|
|
|
{
|
|
|
|
if (sd->blocks)
|
|
|
|
{
|
|
|
|
itb = (Item_Block *)(sd->blocks);
|
|
|
|
if (itb->count >= sd->max_items_per_block)
|
|
|
|
{
|
|
|
|
itb = _item_block_new(sd, EINA_TRUE);
|
|
|
|
if (!itb) return EINA_FALSE;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
itb = _item_block_new(sd, EINA_TRUE);
|
|
|
|
if (!itb) return EINA_FALSE;
|
|
|
|
}
|
|
|
|
itb->items = eina_list_prepend(itb->items, it);
|
|
|
|
|
|
|
|
_item_position_update(itb->items, 0);
|
|
|
|
}
|
2013-03-29 07:03:29 -07:00
|
|
|
// item move_after, append, insert_after, sorted_insert without before
|
2012-07-16 14:56:30 -07:00
|
|
|
else
|
|
|
|
{
|
|
|
|
if (sd->blocks)
|
|
|
|
{
|
|
|
|
itb = (Item_Block *)(sd->blocks->last);
|
|
|
|
if (itb->count >= sd->max_items_per_block)
|
|
|
|
{
|
|
|
|
itb = _item_block_new(sd, EINA_FALSE);
|
|
|
|
if (!itb) return EINA_FALSE;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
itb = _item_block_new(sd, EINA_FALSE);
|
|
|
|
if (!itb) return EINA_FALSE;
|
|
|
|
}
|
|
|
|
itb->items = eina_list_append(itb->items, it);
|
|
|
|
it->position = eina_list_count(itb->items);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
2013-03-29 07:03:29 -07:00
|
|
|
// when a new item depends on another item
|
2012-07-16 14:56:30 -07:00
|
|
|
else
|
|
|
|
{
|
|
|
|
Eina_List *tmp;
|
|
|
|
|
|
|
|
if (it->item->rel->item->queued)
|
|
|
|
{
|
|
|
|
/* NOTE: for a strange reason eina_list and eina_inlist
|
|
|
|
don't have the same property on sorted insertion
|
|
|
|
order, so the queue is not always ordered like the
|
|
|
|
item list. This lead to issue where we depend on an
|
|
|
|
item that is not yet created. As a quick work around,
|
|
|
|
we reschedule the calc of the item and stop reordering
|
|
|
|
the list to prevent any nasty issue to show up here.
|
|
|
|
*/
|
|
|
|
sd->queue = eina_list_append(sd->queue, it);
|
|
|
|
sd->requeued = EINA_TRUE;
|
|
|
|
it->item->queued = EINA_TRUE;
|
|
|
|
|
|
|
|
return EINA_FALSE;
|
|
|
|
}
|
|
|
|
itb = it->item->rel->item->block;
|
|
|
|
if (!itb) goto newblock;
|
|
|
|
tmp = eina_list_data_find_list(itb->items, it->item->rel);
|
|
|
|
if (it->item->before)
|
|
|
|
{
|
|
|
|
itb->items = eina_list_prepend_relative_list(itb->items, it, tmp);
|
|
|
|
_item_position_update
|
|
|
|
(eina_list_prev(tmp), it->item->rel->position);
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
itb->items = eina_list_append_relative_list(itb->items, it, tmp);
|
|
|
|
_item_position_update
|
|
|
|
(eina_list_next(tmp), it->item->rel->position + 1);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
itb->count++;
|
|
|
|
itb->changed = EINA_TRUE;
|
|
|
|
it->item->block = itb;
|
2014-01-21 06:16:41 -08:00
|
|
|
ecore_job_del(itb->sd->calc_job);
|
2013-04-24 04:41:37 -07:00
|
|
|
itb->sd->calc_job = ecore_job_add(_calc_job, itb->sd->obj);
|
2012-07-16 14:56:30 -07:00
|
|
|
|
|
|
|
if (itb->count > itb->sd->max_items_per_block)
|
|
|
|
{
|
|
|
|
int newc;
|
|
|
|
Item_Block *itb2;
|
|
|
|
Elm_Gen_Item *it2;
|
|
|
|
Eina_Bool done = EINA_FALSE;
|
|
|
|
|
|
|
|
newc = itb->count / 2;
|
|
|
|
|
|
|
|
if (EINA_INLIST_GET(itb)->prev)
|
|
|
|
{
|
|
|
|
Item_Block *itbp = (Item_Block *)(EINA_INLIST_GET(itb)->prev);
|
|
|
|
|
|
|
|
if (itbp->count + newc < sd->max_items_per_block / 2)
|
|
|
|
{
|
|
|
|
/* moving items to previous block */
|
|
|
|
while ((itb->count > newc) && (itb->items))
|
|
|
|
{
|
|
|
|
it2 = eina_list_data_get(itb->items);
|
|
|
|
itb->items = eina_list_remove_list
|
|
|
|
(itb->items, itb->items);
|
|
|
|
itb->count--;
|
|
|
|
|
|
|
|
itbp->items = eina_list_append(itbp->items, it2);
|
|
|
|
it2->item->block = itbp;
|
|
|
|
itbp->count++;
|
|
|
|
}
|
|
|
|
|
|
|
|
done = EINA_TRUE;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!done && EINA_INLIST_GET(itb)->next)
|
|
|
|
{
|
|
|
|
Item_Block *itbn = (Item_Block *)(EINA_INLIST_GET(itb)->next);
|
|
|
|
|
|
|
|
if (itbn->count + newc < sd->max_items_per_block / 2)
|
|
|
|
{
|
|
|
|
/* moving items to next block */
|
|
|
|
while ((itb->count > newc) && (itb->items))
|
|
|
|
{
|
|
|
|
Eina_List *l;
|
|
|
|
|
|
|
|
l = eina_list_last(itb->items);
|
|
|
|
it2 = eina_list_data_get(l);
|
|
|
|
itb->items = eina_list_remove_list(itb->items, l);
|
|
|
|
itb->count--;
|
|
|
|
|
|
|
|
itbn->items = eina_list_prepend(itbn->items, it2);
|
|
|
|
it2->item->block = itbn;
|
|
|
|
itbn->count++;
|
|
|
|
}
|
|
|
|
|
|
|
|
done = EINA_TRUE;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!done)
|
|
|
|
{
|
|
|
|
/* moving items to new block */
|
|
|
|
itb2 = calloc(1, sizeof(Item_Block));
|
|
|
|
if (!itb2) return EINA_FALSE;
|
|
|
|
itb2->sd = sd;
|
|
|
|
sd->blocks =
|
|
|
|
eina_inlist_append_relative(sd->blocks, EINA_INLIST_GET(itb2),
|
|
|
|
EINA_INLIST_GET(itb));
|
|
|
|
itb2->changed = EINA_TRUE;
|
|
|
|
while ((itb->count > newc) && (itb->items))
|
|
|
|
{
|
2011-03-22 00:54:24 -07:00
|
|
|
Eina_List *l;
|
2012-07-16 14:56:30 -07:00
|
|
|
|
|
|
|
l = eina_list_last(itb->items);
|
|
|
|
it2 = l->data;
|
|
|
|
itb->items = eina_list_remove_list(itb->items, l);
|
|
|
|
itb->count--;
|
|
|
|
|
|
|
|
itb2->items = eina_list_prepend(itb2->items, it2);
|
|
|
|
it2->item->block = itb2;
|
|
|
|
itb2->count++;
|
2011-03-22 00:54:24 -07:00
|
|
|
}
|
|
|
|
}
|
2012-07-16 14:56:30 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
return EINA_TRUE;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int
|
|
|
|
_item_process(Elm_Genlist_Smart_Data *sd,
|
|
|
|
Elm_Gen_Item *it)
|
|
|
|
{
|
|
|
|
if (!_item_block_add(sd, it)) return 1;
|
|
|
|
if (!sd->blocks)
|
|
|
|
_item_block_realize(it->item->block);
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
_item_process_post(Elm_Genlist_Smart_Data *sd,
|
|
|
|
Elm_Gen_Item *it,
|
|
|
|
Eina_Bool qadd)
|
|
|
|
{
|
|
|
|
Eina_Bool show_me = EINA_FALSE;
|
|
|
|
|
|
|
|
if (it->item->block->changed)
|
|
|
|
{
|
|
|
|
show_me = _item_block_recalc
|
|
|
|
(it->item->block, it->item->block->num, qadd);
|
|
|
|
it->item->block->changed = 0;
|
|
|
|
if (sd->pan_changed)
|
2011-03-22 00:54:24 -07:00
|
|
|
{
|
2013-09-05 21:00:42 -07:00
|
|
|
ELM_SAFE_FREE(sd->calc_job, ecore_job_del);
|
2013-04-24 04:41:37 -07:00
|
|
|
_calc_job(sd->obj);
|
2012-07-16 14:56:30 -07:00
|
|
|
sd->pan_changed = EINA_FALSE;
|
2011-03-22 00:54:24 -07:00
|
|
|
}
|
2012-07-16 14:56:30 -07:00
|
|
|
}
|
|
|
|
if (show_me) it->item->block->show_me = EINA_TRUE;
|
|
|
|
|
|
|
|
/* when prepending, move the scroller along with the first selected
|
|
|
|
* item to create the illusion that we're watching the selected
|
|
|
|
* item this prevents the selected item being scrolled off the
|
|
|
|
* viewport
|
|
|
|
*/
|
|
|
|
if (sd->selected && it->item->before)
|
|
|
|
{
|
|
|
|
int y, h;
|
|
|
|
Elm_Gen_Item *it2;
|
|
|
|
|
|
|
|
it2 = sd->selected->data;
|
2012-08-28 02:53:35 -07:00
|
|
|
if (!it2->item->block) return;
|
2014-03-17 04:44:40 -07:00
|
|
|
eo_do(sd->obj, elm_interface_scrollable_content_pos_get(NULL, &y));
|
2012-07-16 14:56:30 -07:00
|
|
|
evas_object_geometry_get(sd->pan_obj, NULL, NULL, NULL, &h);
|
|
|
|
if ((it->y + it->item->block->y > y + h) ||
|
|
|
|
(it->y + it->item->block->y + it->item->h < y))
|
|
|
|
/* offscreen, just update */
|
2014-03-17 04:44:40 -07:00
|
|
|
eo_do(sd->obj, elm_interface_scrollable_content_region_show
|
2012-11-25 22:32:53 -08:00
|
|
|
(it2->x + it2->item->block->x, y,
|
|
|
|
it2->item->block->w, h));
|
2012-07-16 14:56:30 -07:00
|
|
|
else
|
2014-03-17 04:44:40 -07:00
|
|
|
eo_do(sd->obj, elm_interface_scrollable_content_region_show
|
2012-11-25 22:32:53 -08:00
|
|
|
(it->x + it->item->block->x,
|
|
|
|
y + it->item->h, it->item->block->w, h));
|
2012-07-16 14:56:30 -07:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
static int
|
|
|
|
_queue_process(Elm_Genlist_Smart_Data *sd)
|
|
|
|
{
|
|
|
|
int n;
|
|
|
|
double t0, t;
|
|
|
|
|
2013-11-18 22:10:03 -08:00
|
|
|
t0 = ecore_time_get();
|
2012-07-16 14:56:30 -07:00
|
|
|
for (n = 0; (sd->queue) && (n < 128); n++)
|
|
|
|
{
|
|
|
|
Elm_Gen_Item *it;
|
|
|
|
|
|
|
|
it = eina_list_data_get(sd->queue);
|
|
|
|
sd->queue = eina_list_remove_list(sd->queue, sd->queue);
|
|
|
|
it->item->queued = EINA_FALSE;
|
|
|
|
if (_item_process(sd, it)) continue;
|
|
|
|
t = ecore_time_get();
|
|
|
|
_item_process_post(sd, it, EINA_TRUE);
|
|
|
|
/* same as eina_inlist_count > 1 */
|
|
|
|
if (sd->blocks && sd->blocks->next)
|
|
|
|
{
|
|
|
|
if ((t - t0) > (ecore_animator_frametime_get())) break;
|
|
|
|
}
|
|
|
|
}
|
2013-11-27 23:36:55 -08:00
|
|
|
if (!sd->queue) _item_scroll(sd);
|
2012-07-16 14:56:30 -07:00
|
|
|
return n;
|
|
|
|
}
|
|
|
|
|
|
|
|
static Eina_Bool
|
|
|
|
_idle_process(void *data,
|
|
|
|
Eina_Bool *wakeup)
|
|
|
|
{
|
|
|
|
Elm_Genlist_Smart_Data *sd = data;
|
|
|
|
|
|
|
|
if (_queue_process(sd) > 0) *wakeup = EINA_TRUE;
|
|
|
|
if (!sd->queue)
|
|
|
|
{
|
|
|
|
return ECORE_CALLBACK_CANCEL;
|
|
|
|
}
|
|
|
|
return ECORE_CALLBACK_RENEW;
|
|
|
|
}
|
|
|
|
|
|
|
|
static Eina_Bool
|
|
|
|
_item_idle_enterer(void *data)
|
|
|
|
{
|
|
|
|
Eina_Bool wakeup = EINA_FALSE;
|
2013-04-24 04:41:37 -07:00
|
|
|
ELM_GENLIST_DATA_GET(data, sd);
|
|
|
|
Eina_Bool ok = _idle_process(sd, &wakeup);
|
2012-07-16 14:56:30 -07:00
|
|
|
|
|
|
|
if (wakeup)
|
|
|
|
{
|
|
|
|
// wake up mainloop
|
2014-01-21 06:16:41 -08:00
|
|
|
ecore_job_del(sd->calc_job);
|
2013-04-24 04:41:37 -07:00
|
|
|
sd->calc_job = ecore_job_add(_calc_job, data);
|
2012-07-16 14:56:30 -07:00
|
|
|
}
|
2012-10-10 04:03:44 -07:00
|
|
|
if (ok == ECORE_CALLBACK_CANCEL) sd->queue_idle_enterer = NULL;
|
2012-07-16 14:56:30 -07:00
|
|
|
|
|
|
|
return ok;
|
|
|
|
}
|
|
|
|
|
2013-12-05 23:08:09 -08:00
|
|
|
static void
|
|
|
|
_requeue_idle_enterer(Elm_Genlist_Smart_Data *sd)
|
|
|
|
{
|
2014-01-21 16:55:58 -08:00
|
|
|
ecore_idle_enterer_del(sd->queue_idle_enterer);
|
2013-12-05 23:08:09 -08:00
|
|
|
sd->queue_idle_enterer = ecore_idle_enterer_add(_item_idle_enterer, sd->obj);
|
|
|
|
}
|
|
|
|
|
2012-07-16 14:56:30 -07:00
|
|
|
static void
|
|
|
|
_item_queue(Elm_Genlist_Smart_Data *sd,
|
|
|
|
Elm_Gen_Item *it,
|
|
|
|
Eina_Compare_Cb cb)
|
|
|
|
{
|
2013-12-05 23:08:09 -08:00
|
|
|
Evas_Coord w = 0;
|
|
|
|
|
2012-07-16 14:56:30 -07:00
|
|
|
if (it->item->queued) return;
|
|
|
|
it->item->queued = EINA_TRUE;
|
|
|
|
if (cb && !sd->requeued)
|
|
|
|
sd->queue = eina_list_sorted_insert(sd->queue, cb, it);
|
|
|
|
else
|
|
|
|
sd->queue = eina_list_append(sd->queue, it);
|
|
|
|
// FIXME: why does a freeze then thaw here cause some genlist
|
|
|
|
// elm_genlist_item_append() to be much much slower?
|
|
|
|
// evas_event_freeze(evas_object_evas_get(sd->obj));
|
|
|
|
while ((sd->queue) && ((!sd->blocks) || (!sd->blocks->next)))
|
|
|
|
{
|
2013-09-05 21:00:42 -07:00
|
|
|
ELM_SAFE_FREE(sd->queue_idle_enterer, ecore_idle_enterer_del);
|
2012-07-16 14:56:30 -07:00
|
|
|
_queue_process(sd);
|
|
|
|
}
|
|
|
|
while ((sd->queue) && (sd->blocks) &&
|
|
|
|
(sd->homogeneous) && (sd->mode == ELM_LIST_COMPRESS))
|
|
|
|
{
|
2013-09-05 21:00:42 -07:00
|
|
|
ELM_SAFE_FREE(sd->queue_idle_enterer, ecore_idle_enterer_del);
|
2012-07-16 14:56:30 -07:00
|
|
|
_queue_process(sd);
|
|
|
|
}
|
|
|
|
|
|
|
|
// evas_event_thaw(evas_object_evas_get(sd->obj));
|
|
|
|
// evas_event_thaw_eval(evas_object_evas_get(sd->obj));
|
2013-12-05 23:08:09 -08:00
|
|
|
evas_object_geometry_get(sd->obj, NULL, NULL, &w, NULL);
|
|
|
|
if (w > 0) _requeue_idle_enterer(sd);
|
2012-07-16 14:56:30 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
/* If the application wants to know the relative item, use
|
|
|
|
* elm_genlist_item_prev_get(it)*/
|
|
|
|
static void
|
|
|
|
_item_move_after(Elm_Gen_Item *it,
|
|
|
|
Elm_Gen_Item *after)
|
|
|
|
{
|
|
|
|
if (!it) return;
|
|
|
|
if (!after) return;
|
2012-10-23 08:13:09 -07:00
|
|
|
if (it == after) return;
|
2013-05-02 11:13:36 -07:00
|
|
|
ELM_GENLIST_DATA_GET_FROM_ITEM(it, sd);
|
2012-07-16 14:56:30 -07:00
|
|
|
|
2013-05-02 11:13:36 -07:00
|
|
|
sd->items =
|
|
|
|
eina_inlist_remove(sd->items, EINA_INLIST_GET(it));
|
2012-10-26 03:27:13 -07:00
|
|
|
if (it->item->block) _item_block_del(it);
|
2012-07-16 14:56:30 -07:00
|
|
|
|
2013-05-02 11:13:36 -07:00
|
|
|
sd->items = eina_inlist_append_relative
|
|
|
|
(sd->items, EINA_INLIST_GET(it), EINA_INLIST_GET(after));
|
2013-09-09 00:12:45 -07:00
|
|
|
if (it->item->rel)
|
|
|
|
it->item->rel->item->rel_revs =
|
|
|
|
eina_list_remove(it->item->rel->item->rel_revs, it);
|
2012-07-16 14:56:30 -07:00
|
|
|
it->item->rel = after;
|
2013-03-29 06:23:38 -07:00
|
|
|
after->item->rel_revs = eina_list_append(after->item->rel_revs, it);
|
2012-07-16 14:56:30 -07:00
|
|
|
it->item->before = EINA_FALSE;
|
|
|
|
if (after->item->group_item) it->item->group_item = after->item->group_item;
|
2013-05-02 11:13:36 -07:00
|
|
|
_item_queue(sd, it, NULL);
|
2012-07-16 14:56:30 -07:00
|
|
|
|
|
|
|
evas_object_smart_callback_call(WIDGET(it), SIG_MOVED_AFTER, it);
|
|
|
|
}
|
|
|
|
|
2012-11-16 01:17:56 -08:00
|
|
|
static void
|
2014-01-06 06:30:02 -08:00
|
|
|
_access_activate_cb(void *data EINA_UNUSED,
|
|
|
|
Evas_Object *part_obj EINA_UNUSED,
|
2013-01-03 01:31:33 -08:00
|
|
|
Elm_Object_Item *item)
|
2012-11-16 01:17:56 -08:00
|
|
|
{
|
2013-05-02 11:13:36 -07:00
|
|
|
Elm_Gen_Item *it = (Elm_Gen_Item *)item;
|
2012-11-16 01:17:56 -08:00
|
|
|
if (!it) return;
|
|
|
|
|
2013-05-02 11:13:36 -07:00
|
|
|
ELM_GENLIST_DATA_GET_FROM_ITEM(it, sd);
|
2012-11-16 01:17:56 -08:00
|
|
|
if (!sd) return;
|
|
|
|
|
|
|
|
if (sd->multi)
|
|
|
|
{
|
|
|
|
if (!it->selected)
|
|
|
|
{
|
2014-03-22 03:10:27 -07:00
|
|
|
it->highlight_cb(it);
|
2012-11-16 01:17:56 -08:00
|
|
|
it->sel_cb(it);
|
|
|
|
}
|
|
|
|
else
|
2014-03-22 03:10:27 -07:00
|
|
|
it->unsel_cb(it);
|
2012-11-16 01:17:56 -08:00
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
if (!it->selected)
|
|
|
|
{
|
|
|
|
while (sd->selected)
|
2014-03-22 03:10:27 -07:00
|
|
|
it->unsel_cb(sd->selected->data);
|
2012-11-16 01:17:56 -08:00
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
const Eina_List *l, *l_next;
|
|
|
|
Elm_Gen_Item *it2;
|
|
|
|
|
|
|
|
EINA_LIST_FOREACH_SAFE(sd->selected, l, l_next, it2)
|
2013-03-26 10:46:35 -07:00
|
|
|
{
|
|
|
|
if (it2 != it)
|
2014-03-22 03:10:27 -07:00
|
|
|
it->unsel_cb(it2);
|
2013-03-26 10:46:35 -07:00
|
|
|
}
|
2012-11-16 01:17:56 -08:00
|
|
|
}
|
2014-03-22 03:10:27 -07:00
|
|
|
it->highlight_cb(it);
|
2012-11-16 01:17:56 -08:00
|
|
|
it->sel_cb(it);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2012-07-16 14:56:30 -07:00
|
|
|
/* If the application wants to know the relative item, use
|
|
|
|
* elm_genlist_item_next_get(it)*/
|
|
|
|
static void
|
|
|
|
_item_move_before(Elm_Gen_Item *it,
|
|
|
|
Elm_Gen_Item *before)
|
|
|
|
{
|
|
|
|
if (!it) return;
|
|
|
|
if (!before) return;
|
2012-10-23 08:13:09 -07:00
|
|
|
if (it == before) return;
|
2013-05-02 11:13:36 -07:00
|
|
|
ELM_GENLIST_DATA_GET_FROM_ITEM(it, sd);
|
2012-07-16 14:56:30 -07:00
|
|
|
|
2013-05-02 11:13:36 -07:00
|
|
|
sd->items =
|
|
|
|
eina_inlist_remove(sd->items, EINA_INLIST_GET(it));
|
2012-10-26 03:27:13 -07:00
|
|
|
if (it->item->block) _item_block_del(it);
|
2013-05-02 11:13:36 -07:00
|
|
|
sd->items = eina_inlist_prepend_relative
|
|
|
|
(sd->items, EINA_INLIST_GET(it), EINA_INLIST_GET(before));
|
2013-09-09 00:12:45 -07:00
|
|
|
if (it->item->rel)
|
|
|
|
it->item->rel->item->rel_revs =
|
|
|
|
eina_list_remove(it->item->rel->item->rel_revs, it);
|
2012-07-16 14:56:30 -07:00
|
|
|
it->item->rel = before;
|
2013-03-29 06:23:38 -07:00
|
|
|
before->item->rel_revs = eina_list_append(before->item->rel_revs, it);
|
2012-07-16 14:56:30 -07:00
|
|
|
it->item->before = EINA_TRUE;
|
|
|
|
if (before->item->group_item)
|
|
|
|
it->item->group_item = before->item->group_item;
|
2013-05-02 11:13:36 -07:00
|
|
|
_item_queue(sd, it, NULL);
|
2012-07-16 14:56:30 -07:00
|
|
|
|
|
|
|
evas_object_smart_callback_call(WIDGET(it), SIG_MOVED_BEFORE, it);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
_item_mouse_up_cb(void *data,
|
2014-01-06 06:30:02 -08:00
|
|
|
Evas *evas EINA_UNUSED,
|
|
|
|
Evas_Object *obj EINA_UNUSED,
|
2012-07-16 14:56:30 -07:00
|
|
|
void *event_info)
|
|
|
|
{
|
|
|
|
Evas_Event_Mouse_Up *ev = event_info;
|
|
|
|
Eina_Bool dragged = EINA_FALSE;
|
|
|
|
Elm_Gen_Item *it = data;
|
|
|
|
|
|
|
|
if (ev->button != 1) return;
|
|
|
|
it->down = EINA_FALSE;
|
2013-05-02 11:13:36 -07:00
|
|
|
ELM_GENLIST_DATA_GET_FROM_ITEM(it, sd);
|
2012-07-16 14:56:30 -07:00
|
|
|
|
|
|
|
sd->mouse_down = EINA_FALSE;
|
2013-03-20 09:39:51 -07:00
|
|
|
evas_object_smart_callback_call(WIDGET(it), SIG_RELEASED, it);
|
2012-07-16 14:56:30 -07:00
|
|
|
if (sd->multi_touched)
|
|
|
|
{
|
|
|
|
if ((!sd->multi) && (!it->selected) && (it->highlighted))
|
2014-03-22 03:10:27 -07:00
|
|
|
it->unhighlight_cb(it);
|
2012-07-16 14:56:30 -07:00
|
|
|
if (sd->multi_down) return;
|
2013-07-05 21:00:39 -07:00
|
|
|
_multi_touch_gesture_eval(it);
|
2012-07-16 14:56:30 -07:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
if (ev->event_flags & EVAS_EVENT_FLAG_ON_HOLD)
|
|
|
|
sd->on_hold = EINA_TRUE;
|
|
|
|
else sd->on_hold = EINA_FALSE;
|
2013-05-29 04:54:11 -07:00
|
|
|
ELM_SAFE_FREE(it->long_timer, ecore_timer_del);
|
2012-07-16 14:56:30 -07:00
|
|
|
if (it->dragging)
|
|
|
|
{
|
|
|
|
it->dragging = EINA_FALSE;
|
|
|
|
evas_object_smart_callback_call(WIDGET(it), SIG_DRAG_STOP, it);
|
|
|
|
dragged = 1;
|
|
|
|
}
|
2013-05-29 04:54:11 -07:00
|
|
|
ELM_SAFE_FREE(it->item->swipe_timer, ecore_timer_del);
|
2012-07-16 14:56:30 -07:00
|
|
|
if (sd->multi_timer)
|
|
|
|
{
|
2013-05-29 04:54:11 -07:00
|
|
|
ELM_SAFE_FREE(sd->multi_timer, ecore_timer_del);
|
2012-07-16 14:56:30 -07:00
|
|
|
sd->multi_timeout = EINA_FALSE;
|
|
|
|
}
|
|
|
|
if (sd->on_hold)
|
|
|
|
{
|
2013-07-05 21:00:39 -07:00
|
|
|
if (sd->swipe) _swipe_do(it);
|
2012-07-16 14:56:30 -07:00
|
|
|
sd->longpressed = EINA_FALSE;
|
|
|
|
sd->on_hold = EINA_FALSE;
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
if ((sd->reorder_mode) && (sd->reorder_it))
|
|
|
|
{
|
|
|
|
Evas_Coord it_scrl_y = ev->canvas.y - sd->reorder_it->dy;
|
2012-10-01 01:55:46 -07:00
|
|
|
sd->reorder_fast = 0;
|
2012-07-16 14:56:30 -07:00
|
|
|
|
|
|
|
if (sd->reorder_rel &&
|
|
|
|
(sd->reorder_it->parent == sd->reorder_rel->parent))
|
|
|
|
{
|
|
|
|
if (it_scrl_y <= sd->reorder_rel->item->scrl_y)
|
|
|
|
_item_move_before(sd->reorder_it, sd->reorder_rel);
|
|
|
|
else
|
|
|
|
_item_move_after(sd->reorder_it, sd->reorder_rel);
|
|
|
|
evas_object_smart_callback_call(WIDGET(it), SIG_MOVED, it);
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
2014-01-21 06:16:41 -08:00
|
|
|
ecore_job_del(sd->calc_job);
|
2013-04-24 04:41:37 -07:00
|
|
|
sd->calc_job = ecore_job_add(_calc_job, sd->obj);
|
2012-07-16 14:56:30 -07:00
|
|
|
}
|
|
|
|
edje_object_signal_emit(VIEW(it), "elm,state,reorder,disabled", "elm");
|
|
|
|
sd->reorder_it = sd->reorder_rel = NULL;
|
2014-03-17 04:44:40 -07:00
|
|
|
eo_do(sd->obj, elm_interface_scrollable_hold_set(EINA_FALSE));
|
|
|
|
eo_do(sd->obj, elm_interface_scrollable_bounce_allow_set
|
2012-11-25 22:32:53 -08:00
|
|
|
(sd->h_bounce, sd->v_bounce));
|
2012-07-16 14:56:30 -07:00
|
|
|
}
|
|
|
|
if (sd->longpressed)
|
|
|
|
{
|
|
|
|
sd->longpressed = EINA_FALSE;
|
|
|
|
if ((!sd->wasselected) && (!it->flipped))
|
2014-03-22 03:10:27 -07:00
|
|
|
it->unsel_cb(it);
|
2012-07-16 14:56:30 -07:00
|
|
|
sd->wasselected = EINA_FALSE;
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
if (dragged)
|
|
|
|
{
|
|
|
|
if (it->want_unrealize)
|
|
|
|
{
|
|
|
|
_elm_genlist_item_unrealize(it, EINA_FALSE);
|
|
|
|
if (it->item->block->want_unrealize)
|
|
|
|
_item_block_unrealize(it->item->block);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
if (elm_widget_item_disabled_get(it) || (dragged) ||
|
|
|
|
(it->select_mode == ELM_OBJECT_SELECT_MODE_DISPLAY_ONLY))
|
|
|
|
return;
|
|
|
|
|
|
|
|
if (ev->event_flags & EVAS_EVENT_FLAG_ON_HOLD) return;
|
2014-03-08 09:48:29 -08:00
|
|
|
|
2014-03-08 08:04:34 -08:00
|
|
|
if (sd->focused_item != (Elm_Object_Item *)it)
|
|
|
|
elm_object_item_focus_set((Elm_Object_Item *)it, EINA_TRUE);
|
|
|
|
|
2013-11-02 04:50:59 -07:00
|
|
|
if (sd->multi &&
|
2013-11-03 06:58:57 -08:00
|
|
|
((sd->multi_select_mode != ELM_OBJECT_MULTI_SELECT_MODE_WITH_CONTROL) ||
|
2013-11-02 04:50:59 -07:00
|
|
|
(evas_key_modifier_is_set(ev->modifiers, "Control"))))
|
2012-07-16 14:56:30 -07:00
|
|
|
{
|
|
|
|
if (!it->selected)
|
|
|
|
{
|
2014-03-22 03:10:27 -07:00
|
|
|
it->highlight_cb(it);
|
2012-07-16 14:56:30 -07:00
|
|
|
it->sel_cb(it);
|
|
|
|
}
|
|
|
|
else
|
2014-03-22 03:10:27 -07:00
|
|
|
it->unsel_cb(it);
|
2012-07-16 14:56:30 -07:00
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
if (!it->selected)
|
|
|
|
{
|
|
|
|
while (sd->selected)
|
2014-03-22 03:10:27 -07:00
|
|
|
it->unsel_cb(sd->selected->data);
|
2012-07-16 14:56:30 -07:00
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
const Eina_List *l, *l_next;
|
|
|
|
Elm_Gen_Item *it2;
|
|
|
|
|
2012-10-01 00:36:27 -07:00
|
|
|
EINA_LIST_FOREACH_SAFE(sd->selected, l, l_next, it2)
|
2013-03-26 10:46:35 -07:00
|
|
|
{
|
|
|
|
if (it2 != it)
|
2014-03-22 03:10:27 -07:00
|
|
|
it->unsel_cb(it2);
|
2013-03-26 10:46:35 -07:00
|
|
|
}
|
2012-07-16 14:56:30 -07:00
|
|
|
}
|
2014-03-22 03:10:27 -07:00
|
|
|
it->highlight_cb(it);
|
2012-07-16 14:56:30 -07:00
|
|
|
it->sel_cb(it);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
_item_mouse_callbacks_add(Elm_Gen_Item *it,
|
|
|
|
Evas_Object *view)
|
|
|
|
{
|
|
|
|
evas_object_event_callback_add
|
|
|
|
(view, EVAS_CALLBACK_MOUSE_DOWN, _item_mouse_down_cb, it);
|
|
|
|
evas_object_event_callback_add
|
|
|
|
(view, EVAS_CALLBACK_MOUSE_UP, _item_mouse_up_cb, it);
|
|
|
|
evas_object_event_callback_add
|
|
|
|
(view, EVAS_CALLBACK_MOUSE_MOVE, _item_mouse_move_cb, it);
|
|
|
|
evas_object_event_callback_add
|
|
|
|
(view, EVAS_CALLBACK_MULTI_DOWN, _item_multi_down_cb, it);
|
|
|
|
evas_object_event_callback_add
|
|
|
|
(view, EVAS_CALLBACK_MULTI_UP, _item_multi_up_cb, it);
|
|
|
|
evas_object_event_callback_add
|
|
|
|
(view, EVAS_CALLBACK_MULTI_MOVE, _item_multi_move_cb, it);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
_item_mouse_callbacks_del(Elm_Gen_Item *it,
|
|
|
|
Evas_Object *view)
|
|
|
|
{
|
|
|
|
evas_object_event_callback_del_full
|
|
|
|
(view, EVAS_CALLBACK_MOUSE_DOWN, _item_mouse_down_cb, it);
|
|
|
|
evas_object_event_callback_del_full
|
|
|
|
(view, EVAS_CALLBACK_MOUSE_UP, _item_mouse_up_cb, it);
|
|
|
|
evas_object_event_callback_del_full
|
|
|
|
(view, EVAS_CALLBACK_MOUSE_MOVE, _item_mouse_move_cb, it);
|
|
|
|
evas_object_event_callback_del_full
|
|
|
|
(view, EVAS_CALLBACK_MULTI_DOWN, _item_multi_down_cb, it);
|
|
|
|
evas_object_event_callback_del_full
|
|
|
|
(view, EVAS_CALLBACK_MULTI_UP, _item_multi_up_cb, it);
|
|
|
|
evas_object_event_callback_del_full
|
|
|
|
(view, EVAS_CALLBACK_MULTI_MOVE, _item_multi_move_cb, it);
|
|
|
|
}
|
|
|
|
|
|
|
|
static Eina_Bool
|
|
|
|
_scroll_hold_timer_cb(void *data)
|
|
|
|
{
|
2013-04-24 04:41:37 -07:00
|
|
|
ELM_GENLIST_DATA_GET(data, sd);
|
2012-07-16 14:56:30 -07:00
|
|
|
|
|
|
|
if (!data) return ECORE_CALLBACK_CANCEL;
|
|
|
|
|
2014-03-17 04:44:40 -07:00
|
|
|
eo_do(sd->obj, elm_interface_scrollable_hold_set(EINA_FALSE));
|
2012-07-16 14:56:30 -07:00
|
|
|
sd->scr_hold_timer = NULL;
|
|
|
|
|
|
|
|
return ECORE_CALLBACK_CANCEL;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
_decorate_item_unrealize(Elm_Gen_Item *it)
|
|
|
|
{
|
2013-05-02 11:13:36 -07:00
|
|
|
ELM_GENLIST_DATA_GET_FROM_ITEM(it, sd);
|
2012-11-25 22:32:53 -08:00
|
|
|
Evas_Object *content, *obj = sd->obj;
|
2012-07-16 14:56:30 -07:00
|
|
|
|
|
|
|
if (!it->item->deco_it_view) return;
|
|
|
|
|
|
|
|
evas_event_freeze(evas_object_evas_get(obj));
|
2013-09-05 21:00:42 -07:00
|
|
|
ELM_SAFE_FREE(it->item->deco_it_texts, elm_widget_stringlist_free);
|
|
|
|
ELM_SAFE_FREE(it->item->deco_it_contents, elm_widget_stringlist_free);
|
|
|
|
ELM_SAFE_FREE(it->item->deco_it_states, elm_widget_stringlist_free);
|
2012-07-16 14:56:30 -07:00
|
|
|
|
2013-03-08 20:23:42 -08:00
|
|
|
EINA_LIST_FREE(it->item->deco_it_content_objs, content)
|
2012-07-16 14:56:30 -07:00
|
|
|
evas_object_del(content);
|
|
|
|
|
|
|
|
edje_object_part_unswallow(it->item->deco_it_view, VIEW(it));
|
|
|
|
evas_object_smart_member_add(VIEW(it), sd->pan_obj);
|
2013-09-05 21:00:42 -07:00
|
|
|
ELM_SAFE_FREE(it->item->deco_it_view, evas_object_del);
|
2012-07-16 14:56:30 -07:00
|
|
|
|
|
|
|
if (sd->mode_item == it)
|
|
|
|
sd->mode_item = NULL;
|
|
|
|
evas_event_thaw(evas_object_evas_get(obj));
|
|
|
|
evas_event_thaw_eval(evas_object_evas_get(obj));
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
_decorate_item_finished_signal_cb(void *data,
|
|
|
|
Evas_Object *obj,
|
2014-01-06 06:30:02 -08:00
|
|
|
const char *emission EINA_UNUSED,
|
|
|
|
const char *source EINA_UNUSED)
|
2012-07-16 14:56:30 -07:00
|
|
|
{
|
|
|
|
Elm_Gen_Item *it = data;
|
|
|
|
char buf[1024];
|
|
|
|
Evas *te;
|
|
|
|
|
2013-05-02 11:13:36 -07:00
|
|
|
if (!it || !obj) return;
|
|
|
|
ELM_GENLIST_DATA_GET_FROM_ITEM(it, sd);
|
2012-07-16 14:56:30 -07:00
|
|
|
|
|
|
|
te = evas_object_evas_get(obj);
|
|
|
|
|
2013-05-02 11:13:36 -07:00
|
|
|
if ((it->generation < sd->generation) || (!it->realized)
|
2013-04-17 09:30:34 -07:00
|
|
|
|| (!it->item->deco_it_view)) return;
|
2012-07-16 14:56:30 -07:00
|
|
|
|
|
|
|
evas_event_freeze(te);
|
|
|
|
it->item->nocache_once = EINA_FALSE;
|
|
|
|
_decorate_item_unrealize(it);
|
|
|
|
if (it->item->group_item)
|
2013-06-22 23:17:39 -07:00
|
|
|
evas_object_stack_above(it->item->VIEW(group_item), sd->stack[1]);
|
2012-07-16 14:56:30 -07:00
|
|
|
|
|
|
|
snprintf(buf, sizeof(buf), "elm,state,%s,passive,finished",
|
2013-05-02 11:13:36 -07:00
|
|
|
sd->decorate_it_type);
|
2012-07-16 14:56:30 -07:00
|
|
|
edje_object_signal_callback_del_full
|
|
|
|
(obj, buf, "elm", _decorate_item_finished_signal_cb, it);
|
|
|
|
evas_event_thaw(te);
|
|
|
|
evas_event_thaw_eval(te);
|
|
|
|
}
|
|
|
|
|
|
|
|
static Eina_List *
|
|
|
|
_item_mode_content_unrealize(Elm_Gen_Item *it,
|
|
|
|
Evas_Object *target,
|
|
|
|
Eina_List **source,
|
|
|
|
const char *parts,
|
|
|
|
Eina_List **contents_list)
|
|
|
|
{
|
|
|
|
Eina_List *res = *contents_list;
|
|
|
|
|
|
|
|
if (it->itc->func.content_get)
|
2009-02-17 20:18:25 -08:00
|
|
|
{
|
2012-07-16 14:56:30 -07:00
|
|
|
const Eina_List *l;
|
|
|
|
const char *key;
|
|
|
|
Evas_Object *ic = NULL;
|
|
|
|
|
2012-10-01 00:36:27 -07:00
|
|
|
EINA_LIST_FOREACH(*source, l, key)
|
2011-03-22 00:54:24 -07:00
|
|
|
{
|
2012-07-16 14:56:30 -07:00
|
|
|
if (parts && fnmatch(parts, key, FNM_PERIOD))
|
|
|
|
continue;
|
|
|
|
|
|
|
|
ic = edje_object_part_swallow_get(target, key);
|
|
|
|
if (ic)
|
|
|
|
{
|
|
|
|
res = eina_list_remove(res, ic);
|
|
|
|
edje_object_part_unswallow(target, ic);
|
|
|
|
evas_object_del(ic);
|
|
|
|
}
|
2011-03-22 00:54:24 -07:00
|
|
|
}
|
2009-02-17 20:18:25 -08:00
|
|
|
}
|
2012-07-16 14:56:30 -07:00
|
|
|
|
|
|
|
return res;
|
|
|
|
}
|
|
|
|
|
|
|
|
static Eina_List *
|
|
|
|
_item_content_unrealize(Elm_Gen_Item *it,
|
|
|
|
Evas_Object *target,
|
|
|
|
Eina_List **source,
|
|
|
|
const char *parts)
|
|
|
|
{
|
|
|
|
Eina_List *res = it->content_objs;
|
|
|
|
|
|
|
|
if (it->itc->func.content_get)
|
2009-02-17 20:18:25 -08:00
|
|
|
{
|
2012-07-16 14:56:30 -07:00
|
|
|
const Eina_List *l;
|
|
|
|
const char *key;
|
|
|
|
Evas_Object *ic = NULL;
|
|
|
|
|
2012-10-01 00:36:27 -07:00
|
|
|
EINA_LIST_FOREACH(*source, l, key)
|
2011-03-22 00:54:24 -07:00
|
|
|
{
|
2012-07-16 14:56:30 -07:00
|
|
|
if (parts && fnmatch(parts, key, FNM_PERIOD))
|
|
|
|
continue;
|
|
|
|
|
|
|
|
ic = edje_object_part_swallow_get(target, key);
|
|
|
|
if (ic)
|
|
|
|
{
|
|
|
|
res = eina_list_remove(res, ic);
|
|
|
|
edje_object_part_unswallow(target, ic);
|
|
|
|
evas_object_del(ic);
|
|
|
|
}
|
2011-03-22 00:54:24 -07:00
|
|
|
}
|
2009-02-11 03:49:43 -08:00
|
|
|
}
|
2012-07-16 14:56:30 -07:00
|
|
|
|
|
|
|
return res;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
_item_unrealize_cb(Elm_Gen_Item *it)
|
|
|
|
{
|
|
|
|
Evas_Object *content;
|
|
|
|
elm_widget_stringlist_free(it->item->flip_contents);
|
|
|
|
it->item->flip_contents = NULL;
|
2013-03-08 20:23:42 -08:00
|
|
|
EINA_LIST_FREE(it->item->flip_content_objs, content)
|
2012-07-16 14:56:30 -07:00
|
|
|
evas_object_del(content);
|
|
|
|
|
2012-11-19 05:08:54 -08:00
|
|
|
/* access */
|
|
|
|
if (_elm_config->access_mode == ELM_ACCESS_MODE_ON)
|
|
|
|
_elm_access_widget_item_unregister((Elm_Widget_Item *)it);
|
|
|
|
|
2012-07-25 22:50:21 -07:00
|
|
|
// unswallow VIEW(it) first then manipulate VIEW(it)
|
|
|
|
_decorate_item_unrealize(it);
|
|
|
|
if (GL_IT(it)->wsd->decorate_all_mode) _decorate_all_item_unrealize(it);
|
|
|
|
|
2012-10-22 07:34:43 -07:00
|
|
|
if (it->item->nocache_once || it->item->nocache)
|
|
|
|
{
|
2014-01-21 17:38:55 -08:00
|
|
|
ELM_SAFE_FREE(VIEW(it), evas_object_del);
|
2013-09-05 21:00:42 -07:00
|
|
|
ELM_SAFE_FREE(it->spacer, evas_object_del);
|
2012-10-22 07:34:43 -07:00
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
edje_object_mirrored_set(VIEW(it),
|
|
|
|
elm_widget_mirrored_get(WIDGET(it)));
|
|
|
|
edje_object_scale_set(VIEW(it),
|
|
|
|
elm_widget_scale_get(WIDGET(it))
|
|
|
|
* elm_config_scale_get());
|
|
|
|
_item_cache_add(it);
|
|
|
|
}
|
|
|
|
|
|
|
|
it->states = NULL;
|
|
|
|
it->realized = EINA_FALSE;
|
|
|
|
it->want_unrealize = EINA_FALSE;
|
2012-07-16 14:56:30 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
static Eina_Bool
|
|
|
|
_item_block_recalc(Item_Block *itb,
|
|
|
|
int in,
|
|
|
|
Eina_Bool qadd)
|
|
|
|
{
|
|
|
|
const Eina_List *l;
|
|
|
|
Elm_Gen_Item *it;
|
|
|
|
Evas_Coord minw = 0, minh = 0;
|
|
|
|
Eina_Bool show_me = EINA_FALSE, changed = EINA_FALSE;
|
|
|
|
Evas_Coord y = 0;
|
2013-05-02 11:13:36 -07:00
|
|
|
Elm_Genlist_Smart_Data *sd = NULL;
|
2012-07-16 14:56:30 -07:00
|
|
|
|
|
|
|
itb->num = in;
|
2012-10-01 00:36:27 -07:00
|
|
|
EINA_LIST_FOREACH(itb->items, l, it)
|
2011-12-23 20:20:18 -08:00
|
|
|
{
|
2013-05-02 11:13:36 -07:00
|
|
|
sd = GL_IT(it)->wsd;
|
|
|
|
if (it->generation < sd->generation) continue;
|
2012-07-16 14:56:30 -07:00
|
|
|
show_me |= it->item->show_me;
|
|
|
|
if (!itb->realized)
|
2011-12-23 20:20:18 -08:00
|
|
|
{
|
2014-02-25 14:37:56 -08:00
|
|
|
if (qadd || (itb->sd->homogeneous &&
|
|
|
|
((it->group && (!itb->sd->group_item_height)) ||
|
|
|
|
((!it->group) && (!itb->sd->item_height)))))
|
2012-07-16 14:56:30 -07:00
|
|
|
{
|
|
|
|
if (!it->item->mincalcd) changed = EINA_TRUE;
|
|
|
|
if (changed)
|
|
|
|
{
|
2013-09-30 20:54:28 -07:00
|
|
|
Eina_Bool doit = EINA_TRUE;
|
2013-12-02 02:43:46 -08:00
|
|
|
|
2013-09-30 20:54:28 -07:00
|
|
|
if (itb->sd->homogeneous)
|
|
|
|
{
|
|
|
|
if ((it->group) && (itb->sd->group_item_height == 0))
|
|
|
|
doit = EINA_TRUE;
|
|
|
|
else if (itb->sd->item_height == 0)
|
|
|
|
doit = EINA_TRUE;
|
|
|
|
else
|
|
|
|
doit = EINA_FALSE;
|
|
|
|
}
|
|
|
|
if (doit)
|
|
|
|
{
|
|
|
|
_item_realize(it, in, EINA_TRUE);
|
|
|
|
_elm_genlist_item_unrealize(it, EINA_TRUE);
|
|
|
|
}
|
2013-10-03 23:00:26 -07:00
|
|
|
else
|
|
|
|
{
|
|
|
|
if (it->group)
|
|
|
|
{
|
|
|
|
it->item->w = it->item->minw =
|
|
|
|
sd->group_item_width;
|
|
|
|
it->item->h = it->item->minh =
|
|
|
|
sd->group_item_height;
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
it->item->w = it->item->minw =
|
|
|
|
sd->item_width;
|
|
|
|
it->item->h = it->item->minh =
|
|
|
|
sd->item_height;
|
|
|
|
}
|
|
|
|
it->item->mincalcd = EINA_TRUE;
|
|
|
|
}
|
2012-07-16 14:56:30 -07:00
|
|
|
}
|
|
|
|
}
|
|
|
|
else
|
2012-03-14 21:03:10 -07:00
|
|
|
{
|
2012-07-16 14:56:30 -07:00
|
|
|
if ((itb->sd->homogeneous) &&
|
|
|
|
(itb->sd->mode == ELM_LIST_COMPRESS))
|
|
|
|
{
|
|
|
|
if (it->group)
|
|
|
|
{
|
|
|
|
it->item->w = it->item->minw =
|
2013-05-02 11:13:36 -07:00
|
|
|
sd->group_item_width;
|
2012-07-16 14:56:30 -07:00
|
|
|
it->item->h = it->item->minh =
|
2013-05-02 11:13:36 -07:00
|
|
|
sd->group_item_height;
|
2012-07-16 14:56:30 -07:00
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
it->item->w = it->item->minw =
|
2013-05-02 11:13:36 -07:00
|
|
|
sd->item_width;
|
2012-07-16 14:56:30 -07:00
|
|
|
it->item->h = it->item->minh =
|
2013-05-02 11:13:36 -07:00
|
|
|
sd->item_height;
|
2012-07-16 14:56:30 -07:00
|
|
|
}
|
2013-10-03 23:00:26 -07:00
|
|
|
it->item->mincalcd = EINA_TRUE;
|
2012-07-16 14:56:30 -07:00
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
_item_realize(it, in, EINA_TRUE);
|
|
|
|
_elm_genlist_item_unrealize(it, EINA_TRUE);
|
|
|
|
}
|
2012-03-14 21:03:10 -07:00
|
|
|
}
|
2011-12-23 20:20:18 -08:00
|
|
|
}
|
2012-07-16 14:56:30 -07:00
|
|
|
else
|
|
|
|
{
|
|
|
|
if (!it->item->mincalcd) changed = EINA_TRUE;
|
|
|
|
_item_realize(it, in, EINA_FALSE);
|
|
|
|
}
|
|
|
|
minh += it->item->minh;
|
|
|
|
if (minw < it->item->minw) minw = it->item->minw;
|
|
|
|
in++;
|
|
|
|
it->x = 0;
|
|
|
|
it->y = y;
|
|
|
|
y += it->item->h;
|
2011-12-23 20:20:18 -08:00
|
|
|
}
|
2012-07-16 14:56:30 -07:00
|
|
|
if (changed) itb->sd->pan_changed = changed;
|
|
|
|
itb->minw = minw;
|
|
|
|
itb->minh = minh;
|
|
|
|
itb->changed = EINA_FALSE;
|
|
|
|
itb->position_update = EINA_FALSE;
|
|
|
|
|
|
|
|
return show_me;
|
2009-02-12 05:39:43 -08:00
|
|
|
}
|
|
|
|
|
2009-09-13 19:53:03 -07:00
|
|
|
static void
|
|
|
|
_update_job(void *data)
|
|
|
|
{
|
2012-07-16 14:56:30 -07:00
|
|
|
Eina_Bool position = EINA_FALSE, recalc = EINA_FALSE;
|
2013-04-24 04:41:37 -07:00
|
|
|
ELM_GENLIST_DATA_GET(data, sd);
|
2009-09-13 19:53:03 -07:00
|
|
|
Item_Block *itb;
|
2012-07-16 14:56:30 -07:00
|
|
|
Eina_List *l2;
|
2011-06-03 18:52:08 -07:00
|
|
|
int num, num0;
|
2012-07-16 14:56:30 -07:00
|
|
|
|
|
|
|
sd->update_job = NULL;
|
2009-09-13 19:53:03 -07:00
|
|
|
num = 0;
|
2011-05-29 19:31:21 -07:00
|
|
|
|
2012-11-25 22:32:53 -08:00
|
|
|
evas_event_freeze(evas_object_evas_get(sd->obj));
|
2012-10-01 00:36:27 -07:00
|
|
|
EINA_INLIST_FOREACH(sd->blocks, itb)
|
2011-03-22 00:54:24 -07:00
|
|
|
{
|
|
|
|
Evas_Coord itminw, itminh;
|
2011-10-21 01:52:03 -07:00
|
|
|
Elm_Gen_Item *it;
|
2011-03-22 00:54:24 -07:00
|
|
|
|
|
|
|
if (!itb->updateme)
|
|
|
|
{
|
|
|
|
num += itb->count;
|
|
|
|
if (position)
|
|
|
|
_item_block_position(itb, num);
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
num0 = num;
|
2011-06-03 18:52:08 -07:00
|
|
|
recalc = EINA_FALSE;
|
2012-10-01 00:36:27 -07:00
|
|
|
EINA_LIST_FOREACH(itb->items, l2, it)
|
2011-03-22 00:54:24 -07:00
|
|
|
{
|
2011-10-21 01:52:03 -07:00
|
|
|
if (it->item->updateme)
|
2011-03-22 00:54:24 -07:00
|
|
|
{
|
2011-10-21 01:52:03 -07:00
|
|
|
itminw = it->item->minw;
|
|
|
|
itminh = it->item->minh;
|
2011-03-22 00:54:24 -07:00
|
|
|
|
2011-10-21 01:52:03 -07:00
|
|
|
it->item->updateme = EINA_FALSE;
|
2011-03-22 00:54:24 -07:00
|
|
|
if (it->realized)
|
|
|
|
{
|
2011-11-30 09:31:01 -08:00
|
|
|
_elm_genlist_item_unrealize(it, EINA_FALSE);
|
2011-03-22 00:54:24 -07:00
|
|
|
_item_realize(it, num, EINA_FALSE);
|
2011-06-03 18:52:08 -07:00
|
|
|
position = EINA_TRUE;
|
2011-03-22 00:54:24 -07:00
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
_item_realize(it, num, EINA_TRUE);
|
2011-11-30 09:31:01 -08:00
|
|
|
_elm_genlist_item_unrealize(it, EINA_TRUE);
|
2011-03-22 00:54:24 -07:00
|
|
|
}
|
2011-10-21 01:52:03 -07:00
|
|
|
if ((it->item->minw != itminw) || (it->item->minh != itminh))
|
2011-06-03 18:52:08 -07:00
|
|
|
recalc = EINA_TRUE;
|
2011-03-22 00:54:24 -07:00
|
|
|
}
|
|
|
|
num++;
|
|
|
|
}
|
|
|
|
itb->updateme = EINA_FALSE;
|
|
|
|
if (recalc)
|
|
|
|
{
|
2011-06-03 18:52:08 -07:00
|
|
|
position = EINA_TRUE;
|
2011-03-22 00:54:24 -07:00
|
|
|
itb->changed = EINA_TRUE;
|
2011-06-08 03:58:00 -07:00
|
|
|
_item_block_recalc(itb, num0, EINA_FALSE);
|
2011-03-22 00:54:24 -07:00
|
|
|
_item_block_position(itb, num0);
|
|
|
|
}
|
|
|
|
}
|
2009-09-13 19:53:03 -07:00
|
|
|
if (position)
|
|
|
|
{
|
2014-01-21 06:16:41 -08:00
|
|
|
ecore_job_del(sd->calc_job);
|
2013-04-24 04:41:37 -07:00
|
|
|
sd->calc_job = ecore_job_add(_calc_job, sd->obj);
|
2011-06-01 20:10:11 -07:00
|
|
|
}
|
2012-11-25 22:32:53 -08:00
|
|
|
evas_event_thaw(evas_object_evas_get(sd->obj));
|
|
|
|
evas_event_thaw_eval(evas_object_evas_get(sd->obj));
|
2009-09-07 23:20:32 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
2012-07-16 14:56:30 -07:00
|
|
|
_scroll_animate_start_cb(Evas_Object *obj,
|
2014-01-06 06:30:02 -08:00
|
|
|
void *data EINA_UNUSED)
|
2009-09-07 23:20:32 -07:00
|
|
|
{
|
2012-07-16 14:56:30 -07:00
|
|
|
evas_object_smart_callback_call(obj, SIG_SCROLL_ANIM_START, NULL);
|
2009-09-07 23:20:32 -07:00
|
|
|
}
|
|
|
|
|
elm genlist: Added "scroll,anim,start", "scroll,anim,stop",
"scroll,drag,start", "scroll,drag,stop" smart callbacks to genlist.
elm gengrid: Added "scroll,anim,start", "scroll,anim,stop" smart
callbacks to genlist.
SVN revision: 62710
2011-08-22 21:02:26 -07:00
|
|
|
static void
|
2012-07-16 14:56:30 -07:00
|
|
|
_scroll_animate_stop_cb(Evas_Object *obj,
|
2014-01-06 06:30:02 -08:00
|
|
|
void *data EINA_UNUSED)
|
elm genlist: Added "scroll,anim,start", "scroll,anim,stop",
"scroll,drag,start", "scroll,drag,stop" smart callbacks to genlist.
elm gengrid: Added "scroll,anim,start", "scroll,anim,stop" smart
callbacks to genlist.
SVN revision: 62710
2011-08-22 21:02:26 -07:00
|
|
|
{
|
2012-07-16 14:56:30 -07:00
|
|
|
evas_object_smart_callback_call(obj, SIG_SCROLL_ANIM_STOP, NULL);
|
elm genlist: Added "scroll,anim,start", "scroll,anim,stop",
"scroll,drag,start", "scroll,drag,stop" smart callbacks to genlist.
elm gengrid: Added "scroll,anim,start", "scroll,anim,stop" smart
callbacks to genlist.
SVN revision: 62710
2011-08-22 21:02:26 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
2012-07-16 14:56:30 -07:00
|
|
|
_scroll_drag_start_cb(Evas_Object *obj,
|
2014-01-06 06:30:02 -08:00
|
|
|
void *data EINA_UNUSED)
|
elm genlist: Added "scroll,anim,start", "scroll,anim,stop",
"scroll,drag,start", "scroll,drag,stop" smart callbacks to genlist.
elm gengrid: Added "scroll,anim,start", "scroll,anim,stop" smart
callbacks to genlist.
SVN revision: 62710
2011-08-22 21:02:26 -07:00
|
|
|
{
|
2012-07-16 14:56:30 -07:00
|
|
|
evas_object_smart_callback_call(obj, SIG_SCROLL_DRAG_START, NULL);
|
elm genlist: Added "scroll,anim,start", "scroll,anim,stop",
"scroll,drag,start", "scroll,drag,stop" smart callbacks to genlist.
elm gengrid: Added "scroll,anim,start", "scroll,anim,stop" smart
callbacks to genlist.
SVN revision: 62710
2011-08-22 21:02:26 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
2012-07-16 14:56:30 -07:00
|
|
|
_scroll_drag_stop_cb(Evas_Object *obj,
|
2014-01-06 06:30:02 -08:00
|
|
|
void *data EINA_UNUSED)
|
elm genlist: Added "scroll,anim,start", "scroll,anim,stop",
"scroll,drag,start", "scroll,drag,stop" smart callbacks to genlist.
elm gengrid: Added "scroll,anim,start", "scroll,anim,stop" smart
callbacks to genlist.
SVN revision: 62710
2011-08-22 21:02:26 -07:00
|
|
|
{
|
2012-07-16 14:56:30 -07:00
|
|
|
evas_object_smart_callback_call(obj, SIG_SCROLL_DRAG_STOP, NULL);
|
elm genlist: Added "scroll,anim,start", "scroll,anim,stop",
"scroll,drag,start", "scroll,drag,stop" smart callbacks to genlist.
elm gengrid: Added "scroll,anim,start", "scroll,anim,stop" smart
callbacks to genlist.
SVN revision: 62710
2011-08-22 21:02:26 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
2012-07-16 14:56:30 -07:00
|
|
|
_edge_left_cb(Evas_Object *obj,
|
2014-01-06 06:30:02 -08:00
|
|
|
void *data EINA_UNUSED)
|
elm genlist: Added "scroll,anim,start", "scroll,anim,stop",
"scroll,drag,start", "scroll,drag,stop" smart callbacks to genlist.
elm gengrid: Added "scroll,anim,start", "scroll,anim,stop" smart
callbacks to genlist.
SVN revision: 62710
2011-08-22 21:02:26 -07:00
|
|
|
{
|
2011-10-20 09:42:42 -07:00
|
|
|
evas_object_smart_callback_call(obj, SIG_EDGE_LEFT, NULL);
|
This small patch allows to get a smart callback when the scrollers in an
elm_list or in an elm_genlist fire the edge,{top,bottom,left,right}
signals, backporting them to the list object.
The new smart callbacks called are:
· "scroll,edge,top" - the list is scrolled until the top edge
· "scroll,edge,bottom" - the list is scrolled until the bottom edge
· "scroll,edge,left" - the list is scrolled until the left edge
· "scroll,edge,right" - the list is scrolled until the right edge
SVN revision: 3
SVN revision: 54393
2010-11-09 18:48:59 -08:00
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
2012-07-16 14:56:30 -07:00
|
|
|
_edge_right_cb(Evas_Object *obj,
|
2014-01-06 06:30:02 -08:00
|
|
|
void *data EINA_UNUSED)
|
This small patch allows to get a smart callback when the scrollers in an
elm_list or in an elm_genlist fire the edge,{top,bottom,left,right}
signals, backporting them to the list object.
The new smart callbacks called are:
· "scroll,edge,top" - the list is scrolled until the top edge
· "scroll,edge,bottom" - the list is scrolled until the bottom edge
· "scroll,edge,left" - the list is scrolled until the left edge
· "scroll,edge,right" - the list is scrolled until the right edge
SVN revision: 3
SVN revision: 54393
2010-11-09 18:48:59 -08:00
|
|
|
{
|
2011-10-20 09:42:42 -07:00
|
|
|
evas_object_smart_callback_call(obj, SIG_EDGE_RIGHT, NULL);
|
This small patch allows to get a smart callback when the scrollers in an
elm_list or in an elm_genlist fire the edge,{top,bottom,left,right}
signals, backporting them to the list object.
The new smart callbacks called are:
· "scroll,edge,top" - the list is scrolled until the top edge
· "scroll,edge,bottom" - the list is scrolled until the bottom edge
· "scroll,edge,left" - the list is scrolled until the left edge
· "scroll,edge,right" - the list is scrolled until the right edge
SVN revision: 3
SVN revision: 54393
2010-11-09 18:48:59 -08:00
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
2012-07-16 14:56:30 -07:00
|
|
|
_edge_top_cb(Evas_Object *obj,
|
2014-01-06 06:30:02 -08:00
|
|
|
void *data EINA_UNUSED)
|
This small patch allows to get a smart callback when the scrollers in an
elm_list or in an elm_genlist fire the edge,{top,bottom,left,right}
signals, backporting them to the list object.
The new smart callbacks called are:
· "scroll,edge,top" - the list is scrolled until the top edge
· "scroll,edge,bottom" - the list is scrolled until the bottom edge
· "scroll,edge,left" - the list is scrolled until the left edge
· "scroll,edge,right" - the list is scrolled until the right edge
SVN revision: 3
SVN revision: 54393
2010-11-09 18:48:59 -08:00
|
|
|
{
|
2011-10-20 09:42:42 -07:00
|
|
|
evas_object_smart_callback_call(obj, SIG_EDGE_TOP, NULL);
|
This small patch allows to get a smart callback when the scrollers in an
elm_list or in an elm_genlist fire the edge,{top,bottom,left,right}
signals, backporting them to the list object.
The new smart callbacks called are:
· "scroll,edge,top" - the list is scrolled until the top edge
· "scroll,edge,bottom" - the list is scrolled until the bottom edge
· "scroll,edge,left" - the list is scrolled until the left edge
· "scroll,edge,right" - the list is scrolled until the right edge
SVN revision: 3
SVN revision: 54393
2010-11-09 18:48:59 -08:00
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
2012-07-16 14:56:30 -07:00
|
|
|
_edge_bottom_cb(Evas_Object *obj,
|
2014-01-06 06:30:02 -08:00
|
|
|
void *data EINA_UNUSED)
|
This small patch allows to get a smart callback when the scrollers in an
elm_list or in an elm_genlist fire the edge,{top,bottom,left,right}
signals, backporting them to the list object.
The new smart callbacks called are:
· "scroll,edge,top" - the list is scrolled until the top edge
· "scroll,edge,bottom" - the list is scrolled until the bottom edge
· "scroll,edge,left" - the list is scrolled until the left edge
· "scroll,edge,right" - the list is scrolled until the right edge
SVN revision: 3
SVN revision: 54393
2010-11-09 18:48:59 -08:00
|
|
|
{
|
2011-10-20 09:42:42 -07:00
|
|
|
evas_object_smart_callback_call(obj, SIG_EDGE_BOTTOM, NULL);
|
This small patch allows to get a smart callback when the scrollers in an
elm_list or in an elm_genlist fire the edge,{top,bottom,left,right}
signals, backporting them to the list object.
The new smart callbacks called are:
· "scroll,edge,top" - the list is scrolled until the top edge
· "scroll,edge,bottom" - the list is scrolled until the bottom edge
· "scroll,edge,left" - the list is scrolled until the left edge
· "scroll,edge,right" - the list is scrolled until the right edge
SVN revision: 3
SVN revision: 54393
2010-11-09 18:48:59 -08:00
|
|
|
}
|
|
|
|
|
Add smart callback signals of a scroller. "vbar,drag", "vbar,press", "vbar,unpress", "hbar,drag", "hbar,press", "hbar,unpress".
SVN revision: 83703
2013-02-06 22:13:31 -08:00
|
|
|
static void
|
|
|
|
_vbar_drag_cb(Evas_Object *obj,
|
2014-01-06 06:30:02 -08:00
|
|
|
void *data EINA_UNUSED)
|
Add smart callback signals of a scroller. "vbar,drag", "vbar,press", "vbar,unpress", "hbar,drag", "hbar,press", "hbar,unpress".
SVN revision: 83703
2013-02-06 22:13:31 -08:00
|
|
|
{
|
|
|
|
evas_object_smart_callback_call(obj, SIG_VBAR_DRAG, NULL);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
_vbar_press_cb(Evas_Object *obj,
|
2014-01-06 06:30:02 -08:00
|
|
|
void *data EINA_UNUSED)
|
Add smart callback signals of a scroller. "vbar,drag", "vbar,press", "vbar,unpress", "hbar,drag", "hbar,press", "hbar,unpress".
SVN revision: 83703
2013-02-06 22:13:31 -08:00
|
|
|
{
|
|
|
|
evas_object_smart_callback_call(obj, SIG_VBAR_PRESS, NULL);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
_vbar_unpress_cb(Evas_Object *obj,
|
2014-01-06 06:30:02 -08:00
|
|
|
void *data EINA_UNUSED)
|
Add smart callback signals of a scroller. "vbar,drag", "vbar,press", "vbar,unpress", "hbar,drag", "hbar,press", "hbar,unpress".
SVN revision: 83703
2013-02-06 22:13:31 -08:00
|
|
|
{
|
|
|
|
evas_object_smart_callback_call(obj, SIG_VBAR_UNPRESS, NULL);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
_hbar_drag_cb(Evas_Object *obj,
|
2014-01-06 06:30:02 -08:00
|
|
|
void *data EINA_UNUSED)
|
Add smart callback signals of a scroller. "vbar,drag", "vbar,press", "vbar,unpress", "hbar,drag", "hbar,press", "hbar,unpress".
SVN revision: 83703
2013-02-06 22:13:31 -08:00
|
|
|
{
|
|
|
|
evas_object_smart_callback_call(obj, SIG_HBAR_DRAG, NULL);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
_hbar_press_cb(Evas_Object *obj,
|
2014-01-06 06:30:02 -08:00
|
|
|
void *data EINA_UNUSED)
|
Add smart callback signals of a scroller. "vbar,drag", "vbar,press", "vbar,unpress", "hbar,drag", "hbar,press", "hbar,unpress".
SVN revision: 83703
2013-02-06 22:13:31 -08:00
|
|
|
{
|
|
|
|
evas_object_smart_callback_call(obj, SIG_HBAR_PRESS, NULL);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
_hbar_unpress_cb(Evas_Object *obj,
|
2014-01-06 06:30:02 -08:00
|
|
|
void *data EINA_UNUSED)
|
Add smart callback signals of a scroller. "vbar,drag", "vbar,press", "vbar,unpress", "hbar,drag", "hbar,press", "hbar,unpress".
SVN revision: 83703
2013-02-06 22:13:31 -08:00
|
|
|
{
|
|
|
|
evas_object_smart_callback_call(obj, SIG_HBAR_UNPRESS, NULL);
|
|
|
|
}
|
|
|
|
|
2011-04-21 04:47:36 -07:00
|
|
|
static void
|
2012-04-03 02:56:53 -07:00
|
|
|
_decorate_item_realize(Elm_Gen_Item *it)
|
2011-04-21 04:47:36 -07:00
|
|
|
{
|
|
|
|
char buf[1024];
|
2013-05-02 11:13:36 -07:00
|
|
|
ELM_GENLIST_DATA_GET_FROM_ITEM(it, sd);
|
|
|
|
Evas_Object *obj = sd->obj;
|
2011-04-21 04:47:36 -07:00
|
|
|
|
2013-04-17 09:30:34 -07:00
|
|
|
if ((it->item->deco_it_view) || (it->generation <
|
2013-05-02 11:13:36 -07:00
|
|
|
sd->generation)) return;
|
2011-10-21 01:52:03 -07:00
|
|
|
|
2012-07-16 14:56:30 -07:00
|
|
|
evas_event_freeze(evas_object_evas_get(obj));
|
2012-04-03 02:56:44 -07:00
|
|
|
it->item->deco_it_view = edje_object_add(evas_object_evas_get(WIDGET(it)));
|
2012-07-16 14:56:30 -07:00
|
|
|
edje_object_scale_set
|
|
|
|
(it->item->deco_it_view, elm_widget_scale_get(WIDGET(it)) *
|
|
|
|
elm_config_scale_get());
|
|
|
|
evas_object_smart_member_add
|
2013-05-02 11:13:36 -07:00
|
|
|
(it->item->deco_it_view, sd->pan_obj);
|
2012-04-03 02:56:44 -07:00
|
|
|
elm_widget_sub_object_add(WIDGET(it), it->item->deco_it_view);
|
2011-10-21 01:52:03 -07:00
|
|
|
|
2011-10-20 20:31:26 -07:00
|
|
|
strncpy(buf, "item", sizeof(buf));
|
2013-05-02 11:13:36 -07:00
|
|
|
if (sd->mode == ELM_LIST_COMPRESS)
|
2013-03-21 06:34:15 -07:00
|
|
|
strncat(buf, "_compress", sizeof(buf) - strlen(buf) - 1);
|
2011-10-20 20:31:26 -07:00
|
|
|
|
2012-07-16 14:56:30 -07:00
|
|
|
if (it->item->order_num_in & 0x1)
|
2013-03-21 06:34:15 -07:00
|
|
|
strncat(buf, "_odd", sizeof(buf) - strlen(buf) - 1);
|
|
|
|
strncat(buf, "/", sizeof(buf) - strlen(buf) - 1);
|
|
|
|
strncat(buf, it->itc->decorate_item_style, sizeof(buf) - strlen(buf) - 1);
|
2011-10-20 20:31:26 -07:00
|
|
|
|
2014-01-08 02:07:07 -08:00
|
|
|
if (!elm_widget_theme_object_set
|
|
|
|
(WIDGET(it), it->item->deco_it_view, "genlist", buf,
|
|
|
|
elm_widget_style_get(WIDGET(it))))
|
|
|
|
{
|
|
|
|
|
|
|
|
ERR("%s is not a valid genlist item style. "
|
|
|
|
"Automatically falls back into default style.",
|
|
|
|
it->itc->decorate_item_style);
|
|
|
|
elm_widget_theme_object_set
|
|
|
|
(WIDGET(it), it->item->deco_it_view,
|
|
|
|
"genlist", "item/default", "default");
|
|
|
|
}
|
2012-07-16 14:56:30 -07:00
|
|
|
edje_object_mirrored_set
|
2014-01-08 02:07:07 -08:00
|
|
|
(it->item->deco_it_view, elm_widget_mirrored_get(WIDGET(it)));
|
2011-04-21 04:47:36 -07:00
|
|
|
|
|
|
|
/* signal callback add */
|
2012-07-16 14:56:30 -07:00
|
|
|
evas_object_event_callback_add
|
|
|
|
(it->item->deco_it_view, EVAS_CALLBACK_MOUSE_DOWN, _item_mouse_down_cb,
|
|
|
|
it);
|
|
|
|
evas_object_event_callback_add
|
|
|
|
(it->item->deco_it_view, EVAS_CALLBACK_MOUSE_UP, _item_mouse_up_cb, it);
|
|
|
|
evas_object_event_callback_add
|
|
|
|
(it->item->deco_it_view, EVAS_CALLBACK_MOUSE_MOVE, _item_mouse_move_cb,
|
|
|
|
it);
|
|
|
|
|
|
|
|
if (eina_list_count(it->item->deco_it_content_objs) != 0)
|
|
|
|
ERR_ABORT("If you see this error, please notify us and we"
|
|
|
|
"will fix it");
|
2011-04-21 04:47:36 -07:00
|
|
|
|
2012-05-23 21:59:52 -07:00
|
|
|
/* text_get, content_get, state_get */
|
2012-07-16 14:56:30 -07:00
|
|
|
_item_text_realize
|
|
|
|
(it, it->item->deco_it_view, &it->item->deco_it_texts, NULL);
|
2012-04-06 00:10:29 -07:00
|
|
|
if (!it->item->deco_it_contents)
|
|
|
|
it->item->deco_it_contents =
|
2012-07-16 14:56:30 -07:00
|
|
|
elm_widget_stringlist_get
|
|
|
|
(edje_object_data_get(it->item->deco_it_view, "contents"));
|
2012-04-01 19:37:05 -07:00
|
|
|
it->item->deco_it_content_objs =
|
2012-07-16 14:56:30 -07:00
|
|
|
_item_mode_content_realize
|
|
|
|
(it, it->item->deco_it_view, &it->item->deco_it_contents, NULL,
|
|
|
|
&it->item->deco_it_content_objs);
|
|
|
|
_item_state_realize
|
|
|
|
(it, it->item->deco_it_view, &it->item->deco_it_states, NULL);
|
|
|
|
edje_object_part_swallow
|
|
|
|
(it->item->deco_it_view,
|
|
|
|
edje_object_data_get(it->item->deco_it_view, "mode_part"), VIEW(it));
|
2011-04-21 04:47:36 -07:00
|
|
|
|
2012-02-22 23:39:10 -08:00
|
|
|
it->want_unrealize = EINA_FALSE;
|
2012-07-16 14:56:30 -07:00
|
|
|
evas_event_thaw(evas_object_evas_get(obj));
|
|
|
|
evas_event_thaw_eval(evas_object_evas_get(obj));
|
2012-02-22 23:39:10 -08:00
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
2012-07-16 14:56:30 -07:00
|
|
|
_decorate_item_set(Elm_Gen_Item *it)
|
2012-02-22 23:39:10 -08:00
|
|
|
{
|
2012-07-16 14:56:30 -07:00
|
|
|
char buf[1024];
|
2012-02-22 23:39:10 -08:00
|
|
|
|
2012-07-16 14:56:30 -07:00
|
|
|
if (!it) return;
|
2012-02-22 23:39:10 -08:00
|
|
|
|
2013-05-02 11:13:36 -07:00
|
|
|
ELM_GENLIST_DATA_GET_FROM_ITEM(it, sd);
|
2012-02-22 23:39:10 -08:00
|
|
|
|
2012-07-16 14:56:30 -07:00
|
|
|
sd->mode_item = it;
|
|
|
|
it->item->nocache_once = EINA_TRUE;
|
2011-06-14 02:18:54 -07:00
|
|
|
|
2013-05-29 04:54:11 -07:00
|
|
|
ELM_SAFE_FREE(sd->scr_hold_timer, ecore_timer_del);
|
2014-03-17 04:44:40 -07:00
|
|
|
eo_do(sd->obj, elm_interface_scrollable_hold_set(EINA_TRUE));
|
2013-04-24 04:41:37 -07:00
|
|
|
sd->scr_hold_timer = ecore_timer_add(SCR_HOLD_TIME, _scroll_hold_timer_cb, sd->obj);
|
2012-07-16 14:56:30 -07:00
|
|
|
|
2012-11-25 22:32:53 -08:00
|
|
|
evas_event_freeze(evas_object_evas_get(sd->obj));
|
2012-07-16 14:56:30 -07:00
|
|
|
_decorate_item_realize(it);
|
|
|
|
if (it->item->group_item)
|
2013-06-22 23:17:39 -07:00
|
|
|
evas_object_stack_above(it->item->VIEW(group_item), sd->stack[1]);
|
2012-07-16 14:56:30 -07:00
|
|
|
_item_position
|
|
|
|
(it, it->item->deco_it_view, it->item->scrl_x, it->item->scrl_y);
|
2012-11-25 22:32:53 -08:00
|
|
|
evas_event_thaw(evas_object_evas_get(sd->obj));
|
|
|
|
evas_event_thaw_eval(evas_object_evas_get(sd->obj));
|
2012-07-16 14:56:30 -07:00
|
|
|
|
|
|
|
snprintf(buf, sizeof(buf), "elm,state,%s,active", sd->decorate_it_type);
|
|
|
|
edje_object_signal_emit(it->item->deco_it_view, buf, "elm");
|
2011-06-14 02:18:54 -07:00
|
|
|
}
|
|
|
|
|
2012-07-16 14:56:30 -07:00
|
|
|
static void
|
|
|
|
_decorate_item_unset(Elm_Genlist_Smart_Data *sd)
|
2009-02-09 03:23:59 -08:00
|
|
|
{
|
2012-07-16 14:56:30 -07:00
|
|
|
char buf[1024], buf2[1024];
|
|
|
|
Elm_Gen_Item *it;
|
2009-07-06 23:46:51 -07:00
|
|
|
|
2012-07-16 14:56:30 -07:00
|
|
|
if (!sd->mode_item) return;
|
2011-05-06 17:30:39 -07:00
|
|
|
|
2012-07-16 14:56:30 -07:00
|
|
|
it = sd->mode_item;
|
|
|
|
it->item->nocache_once = EINA_TRUE;
|
|
|
|
|
|
|
|
snprintf(buf, sizeof(buf), "elm,state,%s,passive", sd->decorate_it_type);
|
|
|
|
snprintf(buf2, sizeof(buf2), "elm,state,%s,passive,finished",
|
|
|
|
sd->decorate_it_type);
|
|
|
|
edje_object_signal_emit(it->item->deco_it_view, buf, "elm");
|
|
|
|
edje_object_signal_callback_add
|
|
|
|
(it->item->deco_it_view, buf2, "elm", _decorate_item_finished_signal_cb,
|
|
|
|
it);
|
|
|
|
sd->mode_item = NULL;
|
2009-02-09 03:23:59 -08:00
|
|
|
}
|
|
|
|
|
2012-07-16 14:56:30 -07:00
|
|
|
static void
|
2012-11-25 22:32:53 -08:00
|
|
|
_elm_genlist_smart_add(Eo *obj, void *_pd, va_list *list EINA_UNUSED)
|
2011-11-30 09:13:57 -08:00
|
|
|
{
|
2012-11-25 22:32:53 -08:00
|
|
|
Elm_Genlist_Smart_Data *priv = _pd;
|
2013-10-05 01:14:25 -07:00
|
|
|
ELM_WIDGET_DATA_GET_OR_RETURN(obj, wd);
|
2013-09-24 21:33:39 -07:00
|
|
|
Elm_Genlist_Pan_Smart_Data *pan_data;
|
|
|
|
Evas_Coord minw, minh;
|
|
|
|
int i;
|
2012-03-30 00:28:04 -07:00
|
|
|
|
2013-03-18 09:07:38 -07:00
|
|
|
eo_do_super(obj, MY_CLASS, evas_obj_smart_add());
|
2013-09-24 21:33:39 -07:00
|
|
|
elm_widget_sub_object_parent_add(obj);
|
2013-08-26 08:29:45 -07:00
|
|
|
|
2012-07-16 14:56:30 -07:00
|
|
|
priv->hit_rect = evas_object_rectangle_add(evas_object_evas_get(obj));
|
|
|
|
evas_object_smart_member_add(priv->hit_rect, obj);
|
|
|
|
elm_widget_sub_object_add(obj, priv->hit_rect);
|
|
|
|
|
2012-07-18 14:03:39 -07:00
|
|
|
/* common scroller hit rectangle setup */
|
2012-07-16 14:56:30 -07:00
|
|
|
evas_object_color_set(priv->hit_rect, 0, 0, 0, 0);
|
|
|
|
evas_object_show(priv->hit_rect);
|
|
|
|
evas_object_repeat_events_set(priv->hit_rect, EINA_TRUE);
|
2012-07-18 14:03:39 -07:00
|
|
|
|
|
|
|
elm_widget_can_focus_set(obj, EINA_TRUE);
|
2013-01-10 06:06:46 -08:00
|
|
|
elm_widget_on_show_region_hook_set(obj, _show_region_hook, NULL);
|
2012-07-18 14:03:39 -07:00
|
|
|
|
2013-04-17 09:30:34 -07:00
|
|
|
priv->generation = 1;
|
|
|
|
|
2013-03-01 18:04:31 -08:00
|
|
|
if (!elm_layout_theme_set
|
|
|
|
(obj, "genlist", "base", elm_widget_style_get(obj)))
|
2013-12-25 20:03:55 -08:00
|
|
|
CRI("Failed to set layout!");
|
2012-07-18 14:03:39 -07:00
|
|
|
|
2014-03-17 04:44:40 -07:00
|
|
|
eo_do(obj, elm_interface_scrollable_objects_set(wd->resize_obj, priv->hit_rect));
|
2012-07-18 14:03:39 -07:00
|
|
|
|
2014-03-17 04:44:40 -07:00
|
|
|
eo_do(obj, elm_interface_scrollable_bounce_allow_set
|
2012-11-25 22:32:53 -08:00
|
|
|
(EINA_FALSE, _elm_config->thumbscroll_bounce_enable));
|
2012-07-18 14:03:39 -07:00
|
|
|
priv->v_bounce = _elm_config->thumbscroll_bounce_enable;
|
|
|
|
|
2012-11-25 22:32:53 -08:00
|
|
|
eo_do(obj,
|
2014-03-17 04:44:40 -07:00
|
|
|
elm_interface_scrollable_animate_start_cb_set(_scroll_animate_start_cb),
|
|
|
|
elm_interface_scrollable_animate_stop_cb_set(_scroll_animate_stop_cb),
|
|
|
|
elm_interface_scrollable_drag_start_cb_set(_scroll_drag_start_cb),
|
|
|
|
elm_interface_scrollable_drag_stop_cb_set(_scroll_drag_stop_cb),
|
|
|
|
elm_interface_scrollable_edge_left_cb_set(_edge_left_cb),
|
|
|
|
elm_interface_scrollable_edge_right_cb_set(_edge_right_cb),
|
|
|
|
elm_interface_scrollable_edge_top_cb_set(_edge_top_cb),
|
|
|
|
elm_interface_scrollable_edge_bottom_cb_set(_edge_bottom_cb),
|
|
|
|
elm_interface_scrollable_vbar_drag_cb_set(_vbar_drag_cb),
|
|
|
|
elm_interface_scrollable_vbar_press_cb_set(_vbar_press_cb),
|
|
|
|
elm_interface_scrollable_vbar_unpress_cb_set(_vbar_unpress_cb),
|
|
|
|
elm_interface_scrollable_hbar_drag_cb_set(_hbar_drag_cb),
|
|
|
|
elm_interface_scrollable_hbar_press_cb_set(_hbar_press_cb),
|
|
|
|
elm_interface_scrollable_hbar_unpress_cb_set(_hbar_unpress_cb));
|
2012-07-18 14:03:39 -07:00
|
|
|
|
|
|
|
priv->mode = ELM_LIST_SCROLL;
|
|
|
|
priv->max_items_per_block = MAX_ITEMS_PER_BLOCK;
|
|
|
|
priv->item_cache_max = priv->max_items_per_block * 2;
|
|
|
|
priv->longpress_timeout = _elm_config->longpress_timeout;
|
|
|
|
priv->highlight = EINA_TRUE;
|
|
|
|
|
2012-11-25 22:32:53 -08:00
|
|
|
priv->pan_obj = eo_add(MY_PAN_CLASS, evas_object_evas_get(obj));
|
2013-04-24 04:41:37 -07:00
|
|
|
pan_data = eo_data_scope_get(priv->pan_obj, MY_PAN_CLASS);
|
|
|
|
eo_data_ref(obj, NULL);
|
2012-11-25 22:32:53 -08:00
|
|
|
pan_data->wobj = obj;
|
2012-07-18 14:03:39 -07:00
|
|
|
pan_data->wsd = priv;
|
|
|
|
|
2013-06-22 23:17:39 -07:00
|
|
|
for (i = 0; i < 2; i++)
|
|
|
|
{
|
|
|
|
priv->stack[i] = evas_object_rectangle_add(evas_object_evas_get(obj));
|
|
|
|
evas_object_smart_member_add(priv->stack[i], priv->pan_obj);
|
|
|
|
}
|
2013-09-30 03:21:31 -07:00
|
|
|
|
2014-03-17 04:44:40 -07:00
|
|
|
eo_do(obj, elm_interface_scrollable_extern_pan_set(priv->pan_obj));
|
2012-07-18 14:03:39 -07:00
|
|
|
|
2012-11-25 22:32:53 -08:00
|
|
|
edje_object_size_min_calc(wd->resize_obj, &minw, &minh);
|
2012-07-18 14:03:39 -07:00
|
|
|
evas_object_size_hint_min_set(obj, minw, minh);
|
|
|
|
|
|
|
|
_mirrored_set(obj, elm_widget_mirrored_get(obj));
|
|
|
|
|
|
|
|
elm_layout_sizing_eval(obj);
|
2011-11-30 09:13:57 -08:00
|
|
|
}
|
|
|
|
|
2012-07-16 14:56:30 -07:00
|
|
|
static void
|
2012-11-25 22:32:53 -08:00
|
|
|
_elm_genlist_smart_del(Eo *obj, void *_pd, va_list *list EINA_UNUSED)
|
2011-11-30 09:13:57 -08:00
|
|
|
{
|
2012-11-25 22:32:53 -08:00
|
|
|
Elm_Genlist_Smart_Data *sd = _pd;
|
2013-06-22 23:17:39 -07:00
|
|
|
int i;
|
2012-07-16 14:56:30 -07:00
|
|
|
|
|
|
|
if (sd->decorate_all_mode)
|
2012-11-25 22:32:53 -08:00
|
|
|
elm_genlist_decorate_mode_set(sd->obj, EINA_FALSE);
|
2012-12-29 05:45:17 -08:00
|
|
|
sd->queue = eina_list_free(sd->queue);
|
2012-07-16 14:56:30 -07:00
|
|
|
elm_genlist_clear(obj);
|
2013-06-22 23:17:39 -07:00
|
|
|
for (i = 0; i < 2; i++)
|
2014-01-21 17:38:55 -08:00
|
|
|
ELM_SAFE_FREE(sd->stack[i], evas_object_del);
|
2012-11-25 22:32:53 -08:00
|
|
|
eo_unref(sd->pan_obj);
|
2013-09-05 21:00:42 -07:00
|
|
|
ELM_SAFE_FREE(sd->pan_obj, evas_object_del);
|
2012-07-16 14:56:30 -07:00
|
|
|
|
2012-10-22 07:34:43 -07:00
|
|
|
_item_cache_zero(sd);
|
2014-01-21 06:16:41 -08:00
|
|
|
ecore_job_del(sd->calc_job);
|
|
|
|
ecore_job_del(sd->update_job);
|
|
|
|
ecore_idle_enterer_del(sd->queue_idle_enterer);
|
|
|
|
ecore_idler_del(sd->must_recalc_idler);
|
|
|
|
ecore_timer_del(sd->multi_timer);
|
|
|
|
ecore_timer_del(sd->scr_hold_timer);
|
|
|
|
eina_stringshare_del(sd->decorate_it_type);
|
|
|
|
ecore_animator_del(sd->tree_effect_animator);
|
2012-07-16 14:56:30 -07:00
|
|
|
|
2013-03-18 09:07:38 -07:00
|
|
|
eo_do_super(obj, MY_CLASS, evas_obj_smart_del());
|
2011-11-30 09:13:57 -08:00
|
|
|
}
|
|
|
|
|
2012-07-16 14:56:30 -07:00
|
|
|
static void
|
2012-11-25 22:32:53 -08:00
|
|
|
_elm_genlist_smart_move(Eo *obj, void *_pd, va_list *list)
|
2011-11-30 09:13:57 -08:00
|
|
|
{
|
2012-11-25 22:32:53 -08:00
|
|
|
Evas_Coord x = va_arg(*list, Evas_Coord);
|
|
|
|
Evas_Coord y = va_arg(*list, Evas_Coord);
|
|
|
|
Elm_Genlist_Smart_Data *sd = _pd;
|
2012-07-16 14:56:30 -07:00
|
|
|
|
2013-03-18 09:07:38 -07:00
|
|
|
eo_do_super(obj, MY_CLASS, evas_obj_smart_move(x, y));
|
2012-07-16 14:56:30 -07:00
|
|
|
|
|
|
|
evas_object_move(sd->hit_rect, x, y);
|
2011-11-30 09:13:57 -08:00
|
|
|
}
|
|
|
|
|
2012-01-26 23:36:36 -08:00
|
|
|
static void
|
2012-11-25 22:32:53 -08:00
|
|
|
_elm_genlist_smart_resize(Eo *obj, void *_pd, va_list *list)
|
2012-01-26 23:36:36 -08:00
|
|
|
{
|
2012-11-25 22:32:53 -08:00
|
|
|
Evas_Coord w = va_arg(*list, Evas_Coord);
|
|
|
|
Evas_Coord h = va_arg(*list, Evas_Coord);
|
|
|
|
Elm_Genlist_Smart_Data *sd = _pd;
|
2012-01-26 23:36:36 -08:00
|
|
|
|
2013-03-18 09:07:38 -07:00
|
|
|
eo_do_super(obj, MY_CLASS, evas_obj_smart_resize(w, h));
|
2012-01-26 23:36:36 -08:00
|
|
|
|
2012-07-16 14:56:30 -07:00
|
|
|
evas_object_resize(sd->hit_rect, w, h);
|
2013-12-05 23:08:09 -08:00
|
|
|
if ((sd->queue) && (!sd->queue_idle_enterer) && (w > 0))
|
|
|
|
_requeue_idle_enterer(sd);
|
2012-01-26 23:36:36 -08:00
|
|
|
}
|
|
|
|
|
2012-07-16 14:56:30 -07:00
|
|
|
static void
|
2012-11-25 22:32:53 -08:00
|
|
|
_elm_genlist_smart_member_add(Eo *obj, void *_pd, va_list *list)
|
2012-01-27 03:59:22 -08:00
|
|
|
{
|
2012-11-25 22:32:53 -08:00
|
|
|
Evas_Object *member = va_arg(*list, Evas_Object *);
|
|
|
|
Elm_Genlist_Smart_Data *sd = _pd;
|
2012-01-27 03:59:22 -08:00
|
|
|
|
2013-03-18 09:07:38 -07:00
|
|
|
eo_do_super(obj, MY_CLASS, evas_obj_smart_member_add(member));
|
2012-07-16 14:56:30 -07:00
|
|
|
|
|
|
|
if (sd->hit_rect)
|
|
|
|
evas_object_raise(sd->hit_rect);
|
2012-01-27 03:59:22 -08:00
|
|
|
}
|
|
|
|
|
2012-08-18 06:52:03 -07:00
|
|
|
static void
|
2012-11-19 05:08:54 -08:00
|
|
|
_access_obj_process(Elm_Genlist_Smart_Data *sd, Eina_Bool is_access)
|
2012-08-18 06:52:03 -07:00
|
|
|
{
|
|
|
|
Item_Block *itb;
|
|
|
|
Eina_Bool done = EINA_FALSE;
|
2012-10-01 01:55:46 -07:00
|
|
|
|
2012-08-18 06:52:03 -07:00
|
|
|
EINA_INLIST_FOREACH(sd->blocks, itb)
|
|
|
|
{
|
|
|
|
if (itb->realized)
|
|
|
|
{
|
|
|
|
Eina_List *l;
|
|
|
|
Elm_Gen_Item *it;
|
2012-10-01 01:55:46 -07:00
|
|
|
|
2012-08-18 06:52:03 -07:00
|
|
|
done = EINA_TRUE;
|
|
|
|
EINA_LIST_FOREACH(itb->items, l, it)
|
|
|
|
{
|
|
|
|
if (!it->realized) continue;
|
|
|
|
if (is_access) _access_widget_item_register(it);
|
|
|
|
else
|
|
|
|
_elm_access_widget_item_unregister((Elm_Widget_Item *)it);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
else if (done) break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
2012-11-25 22:32:53 -08:00
|
|
|
_elm_genlist_smart_access(Eo *obj EINA_UNUSED, void *_pd, va_list *list)
|
2012-07-31 15:06:06 -07:00
|
|
|
{
|
2012-11-25 22:32:53 -08:00
|
|
|
Elm_Genlist_Smart_Data *sd = _pd;
|
|
|
|
_elm_genlist_smart_focus_next_enable = va_arg(*list, int);
|
|
|
|
_access_obj_process(sd, _elm_genlist_smart_focus_next_enable);
|
2012-07-31 15:06:06 -07:00
|
|
|
}
|
|
|
|
|
2012-07-16 14:56:30 -07:00
|
|
|
EAPI Evas_Object *
|
|
|
|
elm_genlist_add(Evas_Object *parent)
|
2011-11-30 09:13:57 -08:00
|
|
|
{
|
2012-07-16 14:56:30 -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-03-09 08:27:03 -08:00
|
|
|
|
2012-11-25 22:32:53 -08:00
|
|
|
static void
|
|
|
|
_constructor(Eo *obj, void *_pd, va_list *list EINA_UNUSED)
|
|
|
|
{
|
|
|
|
Elm_Genlist_Smart_Data *sd = _pd;
|
|
|
|
sd->obj = obj;
|
2011-11-30 09:13:57 -08:00
|
|
|
|
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,
|
2013-11-07 03:44:22 -08:00
|
|
|
evas_obj_type_set(MY_CLASS_NAME_LEGACY),
|
2012-11-25 22:32:53 -08:00
|
|
|
evas_obj_smart_callbacks_descriptions_set(_smart_callbacks, NULL));
|
2012-07-16 14:56:30 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
_clear(Elm_Genlist_Smart_Data *sd)
|
|
|
|
{
|
|
|
|
sd->anchor_item = NULL;
|
2013-05-29 04:54:11 -07:00
|
|
|
ELM_SAFE_FREE(sd->queue_idle_enterer, ecore_idle_enterer_del);
|
|
|
|
ELM_SAFE_FREE(sd->must_recalc_idler, ecore_idler_del);
|
|
|
|
ELM_SAFE_FREE(sd->queue, eina_list_free);
|
|
|
|
ELM_SAFE_FREE(sd->reorder_move_animator, ecore_animator_del);
|
2012-07-16 14:56:30 -07:00
|
|
|
sd->show_item = NULL;
|
|
|
|
sd->reorder_old_pan_y = 0;
|
|
|
|
}
|
2009-09-23 15:56:47 -07:00
|
|
|
|
2012-07-16 14:56:30 -07:00
|
|
|
static void
|
2013-04-17 09:30:34 -07:00
|
|
|
_elm_genlist_clear(Evas_Object *obj,
|
|
|
|
Eina_Bool standby)
|
2012-07-16 14:56:30 -07:00
|
|
|
{
|
2013-04-17 09:30:34 -07:00
|
|
|
Eina_Inlist *next, *l;
|
2011-12-05 08:43:29 -08:00
|
|
|
|
2012-07-16 14:56:30 -07:00
|
|
|
ELM_GENLIST_DATA_GET(obj, sd);
|
2009-09-23 15:56:47 -07:00
|
|
|
|
2013-04-17 09:30:34 -07:00
|
|
|
if (!standby) sd->generation++;
|
|
|
|
|
2013-09-05 21:00:42 -07:00
|
|
|
ELM_SAFE_FREE(sd->state, eina_inlist_sorted_state_free);
|
2011-12-05 08:43:29 -08:00
|
|
|
|
2013-04-17 09:30:34 -07:00
|
|
|
if (sd->walking > 0)
|
|
|
|
{
|
|
|
|
sd->clear_me = EINA_TRUE;
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2012-11-25 22:32:53 -08:00
|
|
|
evas_event_freeze(evas_object_evas_get(sd->obj));
|
2013-04-17 09:30:34 -07:00
|
|
|
for (l = sd->items, next = l ? l->next : NULL;
|
|
|
|
l;
|
|
|
|
l = next, next = next ? next->next : NULL)
|
2012-07-16 14:56:30 -07:00
|
|
|
{
|
2013-04-17 09:30:34 -07:00
|
|
|
Elm_Gen_Item *it = ELM_GEN_ITEM_FROM_INLIST(l);
|
|
|
|
|
|
|
|
if (it->generation < sd->generation)
|
|
|
|
{
|
|
|
|
Elm_Gen_Item *itn = NULL;
|
|
|
|
|
|
|
|
if (next) itn = ELM_GEN_ITEM_FROM_INLIST(next);
|
|
|
|
if (itn) itn->walking++; /* prevent early death of subitem */
|
|
|
|
it->del_cb(it);
|
|
|
|
elm_widget_item_free(it);
|
|
|
|
if (itn) itn->walking--;
|
|
|
|
}
|
2012-07-16 14:56:30 -07:00
|
|
|
}
|
2013-04-17 09:30:34 -07:00
|
|
|
sd->clear_me = EINA_FALSE;
|
2012-07-16 14:56:30 -07:00
|
|
|
sd->pan_changed = EINA_TRUE;
|
2012-12-28 01:51:40 -08:00
|
|
|
if (!sd->queue)
|
2012-07-16 14:56:30 -07:00
|
|
|
{
|
2013-09-05 21:00:42 -07:00
|
|
|
ELM_SAFE_FREE(sd->calc_job, ecore_job_del);
|
2012-12-28 01:51:40 -08:00
|
|
|
_clear(sd);
|
2012-07-16 14:56:30 -07:00
|
|
|
}
|
|
|
|
sd->pan_x = 0;
|
|
|
|
sd->pan_y = 0;
|
|
|
|
sd->minw = 0;
|
|
|
|
sd->minh = 0;
|
2011-12-05 08:43:29 -08:00
|
|
|
|
2014-03-08 11:46:24 -08:00
|
|
|
ELM_SAFE_FREE(sd->event_block_rect, evas_object_del);
|
2011-12-05 08:43:29 -08:00
|
|
|
|
2012-07-16 14:56:30 -07:00
|
|
|
if (sd->pan_obj)
|
|
|
|
{
|
|
|
|
evas_object_size_hint_min_set(sd->pan_obj, sd->minw, sd->minh);
|
|
|
|
evas_object_smart_callback_call(sd->pan_obj, "changed", NULL);
|
|
|
|
}
|
2012-11-25 22:32:53 -08:00
|
|
|
elm_layout_sizing_eval(sd->obj);
|
2014-03-17 04:44:40 -07:00
|
|
|
eo_do(obj, elm_interface_scrollable_content_region_show(0, 0, 0, 0));
|
2012-11-25 22:32:53 -08:00
|
|
|
evas_event_thaw(evas_object_evas_get(sd->obj));
|
|
|
|
evas_event_thaw_eval(evas_object_evas_get(sd->obj));
|
2012-07-16 14:56:30 -07:00
|
|
|
}
|
2011-12-05 08:43:29 -08:00
|
|
|
|
2012-07-16 14:56:30 -07:00
|
|
|
static void
|
|
|
|
_item_select(Elm_Gen_Item *it)
|
|
|
|
{
|
|
|
|
Evas_Object *obj = WIDGET(it);
|
2013-05-02 11:13:36 -07:00
|
|
|
ELM_GENLIST_DATA_GET_FROM_ITEM(it, sd);
|
2011-12-05 08:43:29 -08:00
|
|
|
|
2013-05-02 11:13:36 -07:00
|
|
|
if ((it->generation < sd->generation) ||
|
2013-04-17 09:30:34 -07:00
|
|
|
(it->decorate_it_set) ||
|
2012-07-16 14:56:30 -07:00
|
|
|
(it->select_mode == ELM_OBJECT_SELECT_MODE_NONE) ||
|
2013-05-02 11:13:36 -07:00
|
|
|
(sd->select_mode == ELM_OBJECT_SELECT_MODE_NONE))
|
2012-07-16 14:56:30 -07:00
|
|
|
return;
|
2011-12-05 08:43:29 -08:00
|
|
|
|
2012-07-16 14:56:30 -07:00
|
|
|
if (!it->selected)
|
|
|
|
{
|
|
|
|
it->selected = EINA_TRUE;
|
2013-05-02 11:13:36 -07:00
|
|
|
sd->selected =
|
|
|
|
eina_list_append(sd->selected, it);
|
2012-07-16 14:56:30 -07:00
|
|
|
}
|
2013-05-02 11:13:36 -07:00
|
|
|
else if (sd->select_mode != ELM_OBJECT_SELECT_MODE_ALWAYS)
|
2012-07-16 14:56:30 -07:00
|
|
|
return;
|
2011-12-05 08:43:29 -08:00
|
|
|
|
2012-07-16 14:56:30 -07:00
|
|
|
evas_object_ref(obj);
|
2013-04-17 09:30:34 -07:00
|
|
|
it->walking++;
|
2013-05-02 11:13:36 -07:00
|
|
|
sd->walking++;
|
2012-07-16 14:56:30 -07:00
|
|
|
if (it->func.func) it->func.func((void *)it->func.data, WIDGET(it), it);
|
2013-05-02 11:13:36 -07:00
|
|
|
if (it->generation == sd->generation)
|
2014-03-22 07:28:19 -07:00
|
|
|
{
|
|
|
|
evas_object_smart_callback_call(WIDGET(it), SIG_SELECTED, it);
|
|
|
|
elm_object_item_focus_set((Elm_Object_Item *)it, EINA_TRUE);
|
|
|
|
_elm_genlist_item_content_focus_set(it, ELM_FOCUS_PREVIOUS);
|
|
|
|
}
|
2013-02-20 02:00:49 -08:00
|
|
|
|
2013-04-17 09:30:34 -07:00
|
|
|
it->walking--;
|
2013-05-02 11:13:36 -07:00
|
|
|
sd->walking--;
|
|
|
|
if ((sd->clear_me) && (!sd->walking))
|
2013-04-17 09:30:34 -07:00
|
|
|
_elm_genlist_clear(WIDGET(it), EINA_TRUE);
|
|
|
|
else
|
|
|
|
{
|
2013-05-02 11:13:36 -07:00
|
|
|
if ((!it->walking) && (it->generation < sd->generation))
|
2013-04-17 09:30:34 -07:00
|
|
|
{
|
|
|
|
it->del_cb(it);
|
|
|
|
elm_widget_item_free(it);
|
|
|
|
}
|
|
|
|
else
|
2013-05-02 11:13:36 -07:00
|
|
|
sd->last_selected_item = (Elm_Object_Item *)it;
|
2013-04-17 09:30:34 -07:00
|
|
|
}
|
2012-07-16 14:56:30 -07:00
|
|
|
evas_object_unref(obj);
|
|
|
|
}
|
2011-12-05 08:43:29 -08:00
|
|
|
|
2012-07-16 14:56:30 -07:00
|
|
|
static Evas_Object *
|
|
|
|
_item_content_get_hook(Elm_Gen_Item *it,
|
|
|
|
const char *part)
|
|
|
|
{
|
2013-02-25 20:42:28 -08:00
|
|
|
Evas_Object *ret = NULL;
|
|
|
|
if (it->deco_all_view)
|
|
|
|
ret = edje_object_part_swallow_get(it->deco_all_view, part);
|
|
|
|
else if (it->decorate_it_set)
|
|
|
|
ret = edje_object_part_swallow_get(it->item->deco_it_view, part);
|
|
|
|
if (!ret)
|
2013-11-30 01:28:47 -08:00
|
|
|
{
|
|
|
|
if (part)
|
|
|
|
ret = edje_object_part_swallow_get(VIEW(it), part);
|
|
|
|
else
|
|
|
|
ret = edje_object_part_swallow_get(VIEW(it), "elm.swallow.icon");
|
|
|
|
}
|
2013-02-25 20:42:28 -08:00
|
|
|
return ret;
|
2009-02-12 05:39:43 -08:00
|
|
|
}
|
|
|
|
|
2012-07-16 14:56:30 -07:00
|
|
|
static const char *
|
|
|
|
_item_text_get_hook(Elm_Gen_Item *it,
|
|
|
|
const char *part)
|
2012-05-15 22:28:40 -07:00
|
|
|
{
|
2012-07-16 14:56:30 -07:00
|
|
|
if (!it->itc->func.text_get) return NULL;
|
2013-02-25 20:42:28 -08:00
|
|
|
const char *ret = NULL;
|
|
|
|
if (it->deco_all_view)
|
|
|
|
ret = edje_object_part_text_get(it->deco_all_view, part);
|
|
|
|
else if (it->decorate_it_set)
|
|
|
|
ret = edje_object_part_text_get(it->item->deco_it_view, part);
|
|
|
|
if (!ret)
|
2013-11-30 01:28:47 -08:00
|
|
|
{
|
|
|
|
if (part)
|
|
|
|
ret = edje_object_part_text_get(VIEW(it), part);
|
|
|
|
else
|
|
|
|
ret = edje_object_part_text_get(VIEW(it), "elm.text");
|
|
|
|
}
|
2013-02-25 20:42:28 -08:00
|
|
|
return ret;
|
2012-05-15 22:28:40 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
2012-07-16 14:56:30 -07:00
|
|
|
_item_disable_hook(Elm_Object_Item *item)
|
2012-05-15 22:28:40 -07:00
|
|
|
{
|
2012-07-16 14:56:30 -07:00
|
|
|
Eina_List *l;
|
|
|
|
Evas_Object *obj;
|
|
|
|
Elm_Gen_Item *it = (Elm_Gen_Item *)item;
|
2012-05-23 21:59:52 -07:00
|
|
|
|
2013-04-17 09:30:34 -07:00
|
|
|
if (it->generation < GL_IT(it)->wsd->generation) return;
|
|
|
|
|
2012-07-16 14:56:30 -07:00
|
|
|
if (it->selected)
|
|
|
|
elm_genlist_item_selected_set(item, EINA_FALSE);
|
|
|
|
|
|
|
|
if (it->realized)
|
2012-05-15 22:28:40 -07:00
|
|
|
{
|
2012-07-16 14:56:30 -07:00
|
|
|
if (elm_widget_item_disabled_get(it))
|
2012-05-15 22:28:40 -07:00
|
|
|
{
|
2012-07-16 14:56:30 -07:00
|
|
|
edje_object_signal_emit(VIEW(it), "elm,state,disabled", "elm");
|
|
|
|
if (it->deco_all_view)
|
|
|
|
edje_object_signal_emit
|
|
|
|
(it->deco_all_view, "elm,state,disabled", "elm");
|
2012-05-15 22:28:40 -07:00
|
|
|
}
|
2012-05-30 03:44:59 -07:00
|
|
|
else
|
2012-07-16 14:56:30 -07:00
|
|
|
{
|
|
|
|
edje_object_signal_emit(VIEW(it), "elm,state,enabled", "elm");
|
|
|
|
if (it->deco_all_view)
|
|
|
|
edje_object_signal_emit
|
|
|
|
(it->deco_all_view, "elm,state,enabled", "elm");
|
|
|
|
}
|
2012-10-01 00:36:27 -07:00
|
|
|
EINA_LIST_FOREACH(it->content_objs, l, obj)
|
2012-07-16 14:56:30 -07:00
|
|
|
elm_widget_disabled_set(obj, elm_widget_item_disabled_get(it));
|
2012-05-29 03:25:55 -07:00
|
|
|
}
|
2012-05-15 22:28:40 -07:00
|
|
|
}
|
|
|
|
|
2012-07-16 14:56:30 -07:00
|
|
|
static Eina_Bool
|
|
|
|
_item_del_pre_hook(Elm_Object_Item *item)
|
2009-02-12 05:39:43 -08:00
|
|
|
{
|
2012-07-16 14:56:30 -07:00
|
|
|
Elm_Gen_Item *it = (Elm_Gen_Item *)item;
|
2013-05-02 11:13:36 -07:00
|
|
|
ELM_GENLIST_DATA_GET_FROM_ITEM(it, sd);
|
2009-02-18 20:37:06 -08:00
|
|
|
|
2013-04-17 09:30:34 -07:00
|
|
|
if (it->walking > 0)
|
2009-02-12 05:39:43 -08:00
|
|
|
{
|
2013-04-17 09:30:34 -07:00
|
|
|
// FIXME: relative will be better to be fixed. it is too harsh.
|
|
|
|
if (it->item->rel)
|
2013-11-28 14:42:16 -08:00
|
|
|
{
|
|
|
|
it->item->rel->item->rel_revs =
|
|
|
|
eina_list_remove(it->item->rel->item->rel_revs, it);
|
|
|
|
it->item->rel = NULL;
|
|
|
|
}
|
2013-04-17 09:30:34 -07:00
|
|
|
if (it->item->rel_revs)
|
|
|
|
{
|
|
|
|
Elm_Gen_Item *tmp;
|
|
|
|
EINA_LIST_FREE(it->item->rel_revs, tmp) tmp->item->rel = NULL;
|
|
|
|
}
|
|
|
|
elm_genlist_item_subitems_clear(item);
|
2013-05-02 11:13:36 -07:00
|
|
|
if (sd->show_item == it)
|
|
|
|
sd->show_item = NULL;
|
2013-04-17 09:30:34 -07:00
|
|
|
|
|
|
|
_elm_genlist_item_del_not_serious(it);
|
|
|
|
if (it->item->block)
|
|
|
|
{
|
|
|
|
if (it->realized) _elm_genlist_item_unrealize(it, EINA_FALSE);
|
|
|
|
it->item->block->changed = EINA_TRUE;
|
2014-01-21 06:16:41 -08:00
|
|
|
ecore_job_del(sd->calc_job);
|
2013-05-02 11:13:36 -07:00
|
|
|
sd->calc_job = ecore_job_add(_calc_job, sd->obj);
|
2013-04-17 09:30:34 -07:00
|
|
|
}
|
|
|
|
if (it->parent)
|
|
|
|
{
|
|
|
|
it->parent->item->items =
|
|
|
|
eina_list_remove(it->parent->item->items, it);
|
|
|
|
it->parent = NULL;
|
|
|
|
}
|
|
|
|
return EINA_FALSE;
|
2010-01-23 01:07:20 -08:00
|
|
|
}
|
2012-07-16 14:56:30 -07:00
|
|
|
|
|
|
|
_item_del(it);
|
|
|
|
return EINA_TRUE;
|
2010-03-28 19:27:26 -07:00
|
|
|
}
|
|
|
|
|
2012-07-16 14:56:30 -07:00
|
|
|
static void
|
|
|
|
_item_signal_emit_hook(Elm_Object_Item *it,
|
|
|
|
const char *emission,
|
|
|
|
const char *source)
|
2010-03-28 19:27:26 -07:00
|
|
|
{
|
2012-07-16 14:56:30 -07:00
|
|
|
edje_object_signal_emit(VIEW(it), emission, source);
|
2009-02-12 05:39:43 -08:00
|
|
|
}
|
|
|
|
|
2014-03-08 08:04:34 -08:00
|
|
|
static void
|
|
|
|
_item_focus_set_hook(Elm_Object_Item *it, Eina_Bool focused)
|
|
|
|
{
|
|
|
|
ELM_GENLIST_ITEM_CHECK_OR_RETURN(it);
|
|
|
|
Evas_Object *obj = WIDGET(it);
|
|
|
|
ELM_GENLIST_DATA_GET(obj, sd);
|
|
|
|
|
|
|
|
if (focused)
|
|
|
|
{
|
|
|
|
if (!elm_object_focus_get(obj))
|
|
|
|
elm_object_focus_set(obj, EINA_TRUE);
|
|
|
|
|
|
|
|
if (it != sd->focused_item)
|
|
|
|
{
|
|
|
|
if (sd->focused_item)
|
|
|
|
_elm_genlist_item_unfocused((Elm_Gen_Item *)sd->focused_item);
|
|
|
|
_elm_genlist_item_focused((Elm_Gen_Item *)it);
|
|
|
|
_elm_widget_focus_highlight_start(obj);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
else
|
|
|
|
_elm_genlist_item_unfocused((Elm_Gen_Item *)it);
|
|
|
|
}
|
|
|
|
|
|
|
|
static Eina_Bool
|
|
|
|
_item_focus_get_hook(Elm_Object_Item *it)
|
|
|
|
{
|
|
|
|
ELM_GENLIST_ITEM_CHECK_OR_RETURN(it, EINA_FALSE);
|
|
|
|
Evas_Object *obj = WIDGET(it);
|
|
|
|
ELM_GENLIST_DATA_GET(obj, sd);
|
|
|
|
|
|
|
|
if (it == sd->focused_item)
|
|
|
|
return EINA_TRUE;
|
|
|
|
|
|
|
|
return EINA_FALSE;
|
|
|
|
}
|
|
|
|
|
2012-07-16 14:56:30 -07:00
|
|
|
static Elm_Gen_Item *
|
|
|
|
_elm_genlist_item_new(Elm_Genlist_Smart_Data *sd,
|
2012-11-16 06:26:07 -08:00
|
|
|
const Elm_Genlist_Item_Class *itc,
|
2012-07-16 14:56:30 -07:00
|
|
|
const void *data,
|
|
|
|
Elm_Gen_Item *parent,
|
2012-11-16 06:26:07 -08:00
|
|
|
Elm_Genlist_Item_Type type,
|
2012-07-16 14:56:30 -07:00
|
|
|
Evas_Smart_Cb func,
|
|
|
|
const void *func_data)
|
2011-04-27 03:17:26 -07:00
|
|
|
{
|
2012-11-16 06:26:07 -08:00
|
|
|
Elm_Gen_Item *it, *it2;
|
|
|
|
int depth = 0;
|
2011-05-07 01:37:47 -07:00
|
|
|
|
2012-07-16 14:56:30 -07:00
|
|
|
if (!itc) return NULL;
|
|
|
|
|
2012-11-25 22:32:53 -08:00
|
|
|
it = elm_widget_item_new(sd->obj, Elm_Gen_Item);
|
2012-07-16 14:56:30 -07:00
|
|
|
if (!it) return NULL;
|
|
|
|
|
2013-04-17 09:30:34 -07:00
|
|
|
it->generation = sd->generation;
|
2012-07-16 14:56:30 -07:00
|
|
|
it->itc = itc;
|
|
|
|
elm_genlist_item_class_ref((Elm_Genlist_Item_Class *)itc);
|
2012-11-16 06:26:04 -08:00
|
|
|
|
2012-07-16 14:56:30 -07:00
|
|
|
it->base.data = data;
|
|
|
|
it->parent = parent;
|
|
|
|
it->func.func = func;
|
|
|
|
it->func.data = func_data;
|
2012-11-16 06:26:04 -08:00
|
|
|
|
2012-07-16 14:56:30 -07:00
|
|
|
elm_widget_item_content_get_hook_set(it, _item_content_get_hook);
|
|
|
|
elm_widget_item_text_get_hook_set(it, _item_text_get_hook);
|
|
|
|
elm_widget_item_disable_hook_set(it, _item_disable_hook);
|
|
|
|
elm_widget_item_del_pre_hook_set(it, _item_del_pre_hook);
|
|
|
|
elm_widget_item_signal_emit_hook_set(it, _item_signal_emit_hook);
|
2014-03-08 08:04:34 -08:00
|
|
|
elm_widget_item_focus_set_hook_set(it, _item_focus_set_hook);
|
|
|
|
elm_widget_item_focus_get_hook_set(it, _item_focus_get_hook);
|
2012-07-16 14:56:30 -07:00
|
|
|
|
|
|
|
it->del_cb = (Ecore_Cb)_item_del;
|
|
|
|
it->highlight_cb = (Ecore_Cb)_item_highlight;
|
|
|
|
it->unhighlight_cb = (Ecore_Cb)_item_unhighlight;
|
2012-11-16 06:26:04 -08:00
|
|
|
it->sel_cb = (Ecore_Cb)_item_select;
|
|
|
|
it->unsel_cb = (Ecore_Cb)_item_unselect;
|
2012-07-16 14:56:30 -07:00
|
|
|
it->unrealize_cb = (Ecore_Cb)_item_unrealize_cb;
|
|
|
|
|
2012-11-16 06:26:07 -08:00
|
|
|
GL_IT(it) = ELM_NEW(Elm_Gen_Item_Type);
|
|
|
|
GL_IT(it)->wsd = sd;
|
|
|
|
GL_IT(it)->type = type;
|
|
|
|
if (type & ELM_GENLIST_ITEM_GROUP) it->group++;
|
|
|
|
|
2012-07-16 14:56:30 -07:00
|
|
|
if (it->parent)
|
2010-03-24 03:00:50 -07:00
|
|
|
{
|
2012-07-16 14:56:30 -07:00
|
|
|
if (it->parent->group)
|
2012-11-16 06:26:07 -08:00
|
|
|
GL_IT(it)->group_item = parent;
|
|
|
|
else if (GL_IT(it->parent)->group_item)
|
|
|
|
GL_IT(it)->group_item = GL_IT(it->parent)->group_item;
|
2010-03-24 03:00:50 -07:00
|
|
|
}
|
2012-07-16 14:56:30 -07:00
|
|
|
for (it2 = it, depth = 0; it2->parent; it2 = it2->parent)
|
2012-06-18 02:54:00 -07:00
|
|
|
{
|
2012-07-16 14:56:30 -07:00
|
|
|
if (!it2->parent->group) depth += 1;
|
2012-06-18 02:54:00 -07:00
|
|
|
}
|
2012-11-16 06:26:07 -08:00
|
|
|
GL_IT(it)->expanded_depth = depth;
|
2012-07-16 14:56:30 -07:00
|
|
|
sd->item_count++;
|
2012-06-21 01:36:21 -07:00
|
|
|
|
2012-07-16 14:56:30 -07:00
|
|
|
return it;
|
2009-02-11 03:49:43 -08:00
|
|
|
}
|
|
|
|
|
2011-05-25 07:58:39 -07:00
|
|
|
static int
|
2012-07-16 14:56:30 -07:00
|
|
|
_elm_genlist_item_compare(const void *data,
|
|
|
|
const void *data1)
|
2011-05-25 07:58:39 -07:00
|
|
|
{
|
2011-10-21 01:52:03 -07:00
|
|
|
const Elm_Gen_Item *it, *item1;
|
2012-07-16 14:56:30 -07:00
|
|
|
|
2011-10-21 15:55:45 -07:00
|
|
|
it = ELM_GEN_ITEM_FROM_INLIST(data);
|
|
|
|
item1 = ELM_GEN_ITEM_FROM_INLIST(data1);
|
2012-07-16 14:56:30 -07:00
|
|
|
return GL_IT(it)->wsd->item_compare_cb(it, item1);
|
2011-05-25 07:58:39 -07:00
|
|
|
}
|
|
|
|
|
2011-07-28 09:43:15 -07:00
|
|
|
static int
|
2012-07-16 14:56:30 -07:00
|
|
|
_elm_genlist_item_list_compare(const void *data,
|
|
|
|
const void *data1)
|
2011-07-28 09:43:15 -07:00
|
|
|
{
|
2011-10-21 01:52:03 -07:00
|
|
|
const Elm_Gen_Item *it = data;
|
|
|
|
const Elm_Gen_Item *item1 = data1;
|
2011-06-01 20:10:11 -07:00
|
|
|
|
2012-07-16 14:56:30 -07:00
|
|
|
return GL_IT(it)->wsd->item_compare_cb(it, item1);
|
2011-06-01 20:10:11 -07:00
|
|
|
}
|
|
|
|
|
2012-02-21 15:59:25 -08:00
|
|
|
EAPI unsigned int
|
2012-02-21 19:22:10 -08:00
|
|
|
elm_genlist_items_count(const Evas_Object *obj)
|
2012-02-21 15:59:25 -08:00
|
|
|
{
|
2012-07-16 14:56:30 -07:00
|
|
|
ELM_GENLIST_CHECK(obj) 0;
|
2012-11-25 22:32:53 -08:00
|
|
|
unsigned int ret = 0;
|
|
|
|
eo_do((Eo *) obj, elm_obj_genlist_items_count(&ret));
|
|
|
|
return ret;
|
|
|
|
}
|
2012-07-16 14:56:30 -07:00
|
|
|
|
2012-11-25 22:32:53 -08:00
|
|
|
static void
|
|
|
|
_items_count(Eo *obj EINA_UNUSED, void *_pd, va_list *list)
|
|
|
|
{
|
|
|
|
unsigned int *ret = va_arg(*list, unsigned int *);
|
|
|
|
Elm_Genlist_Smart_Data *sd = _pd;
|
|
|
|
|
2013-12-31 21:11:50 -08:00
|
|
|
if (ret) *ret = sd->item_count;
|
2012-02-21 15:59:25 -08:00
|
|
|
}
|
|
|
|
|
2012-01-19 21:18:31 -08:00
|
|
|
EAPI Elm_Object_Item *
|
2012-07-16 14:56:30 -07:00
|
|
|
elm_genlist_item_append(Evas_Object *obj,
|
2010-12-07 11:18:14 -08:00
|
|
|
const Elm_Genlist_Item_Class *itc,
|
2012-07-16 14:56:30 -07:00
|
|
|
const void *data,
|
|
|
|
Elm_Object_Item *parent,
|
|
|
|
Elm_Genlist_Item_Type type,
|
|
|
|
Evas_Smart_Cb func,
|
|
|
|
const void *func_data)
|
2012-11-25 22:32:53 -08:00
|
|
|
{
|
|
|
|
ELM_GENLIST_CHECK(obj) NULL;
|
|
|
|
Elm_Object_Item *ret = NULL;
|
|
|
|
eo_do(obj, elm_obj_genlist_item_append(itc, data, parent, type, func, func_data, &ret));
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2014-02-15 12:23:18 -08:00
|
|
|
static Eina_List *
|
|
|
|
_list_last_recursive(Eina_List *list)
|
|
|
|
{
|
|
|
|
Eina_List *ll, *ll2;
|
|
|
|
Elm_Gen_Item *it2;
|
|
|
|
|
|
|
|
ll = eina_list_last(list);
|
|
|
|
if (!ll) return NULL;
|
|
|
|
|
|
|
|
it2 = ll->data;
|
|
|
|
|
|
|
|
if (it2->item->items)
|
|
|
|
{
|
|
|
|
ll2 = _list_last_recursive(it2->item->items);
|
|
|
|
if (ll2)
|
|
|
|
{
|
|
|
|
return ll2;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return ll;
|
|
|
|
}
|
|
|
|
|
2012-11-25 22:32:53 -08:00
|
|
|
static void
|
|
|
|
_item_append(Eo *obj EINA_UNUSED, void *_pd, va_list *list)
|
2012-07-16 14:56:30 -07:00
|
|
|
{
|
|
|
|
Elm_Gen_Item *it;
|
|
|
|
|
2012-11-25 22:32:53 -08:00
|
|
|
const Elm_Genlist_Item_Class *itc = va_arg(*list, const Elm_Genlist_Item_Class *);
|
|
|
|
const void *data = va_arg(*list, const void *);
|
|
|
|
Elm_Object_Item *parent = va_arg(*list, Elm_Object_Item *);
|
|
|
|
Elm_Genlist_Item_Type type = va_arg(*list, Elm_Genlist_Item_Type);
|
|
|
|
Evas_Smart_Cb func = va_arg(*list, Evas_Smart_Cb);
|
|
|
|
const void *func_data = va_arg(*list, const void *);
|
|
|
|
Elm_Object_Item **ret = va_arg(*list, Elm_Object_Item **);
|
|
|
|
Elm_Genlist_Smart_Data *sd = _pd;
|
2013-12-31 21:11:50 -08:00
|
|
|
if (ret) *ret = NULL;
|
2012-07-16 14:56:30 -07:00
|
|
|
|
2012-11-16 06:26:07 -08:00
|
|
|
it = _elm_genlist_item_new
|
2012-07-16 14:56:30 -07:00
|
|
|
(sd, itc, data, (Elm_Gen_Item *)parent, type, func, func_data);
|
2012-11-25 22:32:53 -08:00
|
|
|
if (!it) return;
|
2012-07-16 14:56:30 -07:00
|
|
|
|
2009-02-12 05:39:43 -08:00
|
|
|
if (!it->parent)
|
2009-03-12 22:50:38 -07:00
|
|
|
{
|
2011-10-23 20:40:54 -07:00
|
|
|
if (it->group)
|
2012-07-16 14:56:30 -07:00
|
|
|
sd->group_items = eina_list_append(sd->group_items, it);
|
|
|
|
sd->items = eina_inlist_append(sd->items, EINA_INLIST_GET(it));
|
2011-10-21 01:52:03 -07:00
|
|
|
it->item->rel = NULL;
|
2009-03-12 22:50:38 -07:00
|
|
|
}
|
2009-02-11 03:49:43 -08:00
|
|
|
else
|
|
|
|
{
|
2011-10-21 01:52:03 -07:00
|
|
|
Elm_Gen_Item *it2 = NULL;
|
2014-02-15 12:23:18 -08:00
|
|
|
Eina_List *ll = _list_last_recursive(it->parent->item->items);
|
2012-07-16 14:56:30 -07:00
|
|
|
|
2010-10-15 04:51:15 -07:00
|
|
|
if (ll) it2 = ll->data;
|
2012-07-16 14:56:30 -07:00
|
|
|
it->parent->item->items =
|
|
|
|
eina_list_append(it->parent->item->items, it);
|
2010-10-15 04:51:15 -07:00
|
|
|
if (!it2) it2 = it->parent;
|
2012-07-16 14:56:30 -07:00
|
|
|
sd->items = eina_inlist_append_relative
|
|
|
|
(sd->items, EINA_INLIST_GET(it), EINA_INLIST_GET(it2));
|
2011-10-21 01:52:03 -07:00
|
|
|
it->item->rel = it2;
|
2013-03-29 06:23:38 -07:00
|
|
|
it2->item->rel_revs = eina_list_append(it2->item->rel_revs, it);
|
2009-02-11 03:49:43 -08:00
|
|
|
}
|
2011-10-21 01:52:03 -07:00
|
|
|
it->item->before = EINA_FALSE;
|
2012-07-16 14:56:30 -07:00
|
|
|
_item_queue(sd, it, NULL);
|
|
|
|
|
2013-12-31 21:11:50 -08:00
|
|
|
if (ret) *ret = (Elm_Object_Item *)it;
|
2009-02-10 03:57:47 -08:00
|
|
|
}
|
|
|
|
|
2012-01-19 21:18:31 -08:00
|
|
|
EAPI Elm_Object_Item *
|
2012-07-16 14:56:30 -07:00
|
|
|
elm_genlist_item_prepend(Evas_Object *obj,
|
2010-12-07 11:18:14 -08:00
|
|
|
const Elm_Genlist_Item_Class *itc,
|
2012-07-16 14:56:30 -07:00
|
|
|
const void *data,
|
|
|
|
Elm_Object_Item *parent,
|
|
|
|
Elm_Genlist_Item_Type type,
|
|
|
|
Evas_Smart_Cb func,
|
|
|
|
const void *func_data)
|
2012-11-25 22:32:53 -08:00
|
|
|
{
|
|
|
|
ELM_GENLIST_CHECK(obj) NULL;
|
|
|
|
Elm_Object_Item *ret = NULL;
|
|
|
|
eo_do(obj, elm_obj_genlist_item_prepend(itc, data, parent, type, func, func_data, &ret));
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
_item_prepend(Eo *obj EINA_UNUSED, void *_pd, va_list *list)
|
2012-07-16 14:56:30 -07:00
|
|
|
{
|
|
|
|
Elm_Gen_Item *it;
|
|
|
|
|
2012-11-25 22:32:53 -08:00
|
|
|
const Elm_Genlist_Item_Class *itc = va_arg(*list, const Elm_Genlist_Item_Class *);
|
|
|
|
const void *data = va_arg(*list, const void *);
|
|
|
|
Elm_Object_Item *parent = va_arg(*list, Elm_Object_Item *);
|
|
|
|
Elm_Genlist_Item_Type type = va_arg(*list, Elm_Genlist_Item_Type);
|
|
|
|
Evas_Smart_Cb func = va_arg(*list, Evas_Smart_Cb);
|
|
|
|
const void *func_data = va_arg(*list, const void *);
|
|
|
|
Elm_Object_Item **ret = va_arg(*list, Elm_Object_Item **);
|
|
|
|
Elm_Genlist_Smart_Data *sd = _pd;
|
2013-12-31 21:11:50 -08:00
|
|
|
if (ret) *ret = NULL;
|
2012-11-25 22:32:53 -08:00
|
|
|
|
2012-11-16 06:26:07 -08:00
|
|
|
it = _elm_genlist_item_new
|
2012-07-16 14:56:30 -07:00
|
|
|
(sd, itc, data, (Elm_Gen_Item *)parent, type, func, func_data);
|
2012-11-25 22:32:53 -08:00
|
|
|
if (!it) return;
|
2012-07-16 14:56:30 -07:00
|
|
|
|
2009-02-18 04:41:45 -08:00
|
|
|
if (!it->parent)
|
2011-01-04 21:59:30 -08:00
|
|
|
{
|
2011-10-23 20:40:54 -07:00
|
|
|
if (it->group)
|
2012-07-16 14:56:30 -07:00
|
|
|
sd->group_items = eina_list_prepend(sd->group_items, it);
|
|
|
|
sd->items = eina_inlist_prepend(sd->items, EINA_INLIST_GET(it));
|
2011-10-21 01:52:03 -07:00
|
|
|
it->item->rel = NULL;
|
2011-01-04 21:59:30 -08:00
|
|
|
}
|
2009-02-18 04:41:45 -08:00
|
|
|
else
|
|
|
|
{
|
2011-10-21 01:52:03 -07:00
|
|
|
Elm_Gen_Item *it2 = NULL;
|
|
|
|
Eina_List *ll = it->parent->item->items;
|
2012-07-16 14:56:30 -07:00
|
|
|
|
2011-01-04 21:59:30 -08:00
|
|
|
if (ll) it2 = ll->data;
|
2012-07-16 14:56:30 -07:00
|
|
|
it->parent->item->items =
|
|
|
|
eina_list_prepend(it->parent->item->items, it);
|
2011-01-04 21:59:30 -08:00
|
|
|
if (!it2) it2 = it->parent;
|
2012-07-16 14:56:30 -07:00
|
|
|
sd->items = eina_inlist_prepend_relative
|
|
|
|
(sd->items, EINA_INLIST_GET(it), EINA_INLIST_GET(it2));
|
2011-10-21 01:52:03 -07:00
|
|
|
it->item->rel = it2;
|
2013-03-29 06:23:38 -07:00
|
|
|
it2->item->rel_revs = eina_list_append(it2->item->rel_revs, it);
|
2009-02-18 04:41:45 -08:00
|
|
|
}
|
2011-10-21 01:52:03 -07:00
|
|
|
it->item->before = EINA_TRUE;
|
2012-07-16 14:56:30 -07:00
|
|
|
_item_queue(sd, it, NULL);
|
|
|
|
|
2013-12-31 21:11:50 -08:00
|
|
|
if (ret) *ret = (Elm_Object_Item *)it;
|
2009-02-10 03:57:47 -08:00
|
|
|
}
|
|
|
|
|
2012-01-19 21:18:31 -08:00
|
|
|
EAPI Elm_Object_Item *
|
2012-07-16 14:56:30 -07:00
|
|
|
elm_genlist_item_insert_after(Evas_Object *obj,
|
2011-08-01 23:59:45 -07:00
|
|
|
const Elm_Genlist_Item_Class *itc,
|
2012-07-16 14:56:30 -07:00
|
|
|
const void *data,
|
|
|
|
Elm_Object_Item *parent,
|
|
|
|
Elm_Object_Item *after_it,
|
|
|
|
Elm_Genlist_Item_Type type,
|
|
|
|
Evas_Smart_Cb func,
|
|
|
|
const void *func_data)
|
|
|
|
{
|
2012-11-25 22:32:53 -08:00
|
|
|
ELM_GENLIST_CHECK(obj) NULL;
|
|
|
|
Elm_Object_Item *ret = NULL;
|
|
|
|
eo_do(obj, elm_obj_genlist_item_insert_after(itc, data, parent, after_it, type, func, func_data, &ret));
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
_item_insert_after(Eo *obj EINA_UNUSED, void *_pd, va_list *list)
|
|
|
|
{
|
|
|
|
const Elm_Genlist_Item_Class *itc = va_arg(*list, const Elm_Genlist_Item_Class *);
|
|
|
|
const void *data = va_arg(*list, const void *);
|
|
|
|
Elm_Object_Item *parent = va_arg(*list, Elm_Object_Item *);
|
|
|
|
Elm_Object_Item *after_it = va_arg(*list, Elm_Object_Item *);
|
|
|
|
Elm_Genlist_Item_Type type = va_arg(*list, Elm_Genlist_Item_Type);
|
|
|
|
Evas_Smart_Cb func = va_arg(*list, Evas_Smart_Cb);
|
|
|
|
const void *func_data = va_arg(*list, const void *);
|
|
|
|
Elm_Object_Item **ret = va_arg(*list, Elm_Object_Item **);
|
|
|
|
|
2012-07-16 14:56:30 -07:00
|
|
|
Elm_Gen_Item *after = (Elm_Gen_Item *)after_it;
|
|
|
|
Elm_Gen_Item *it;
|
|
|
|
|
2013-12-31 21:11:50 -08:00
|
|
|
if (ret) *ret = NULL;
|
2012-11-25 22:32:53 -08:00
|
|
|
|
|
|
|
ELM_GENLIST_ITEM_CHECK(after_it);
|
|
|
|
Elm_Genlist_Smart_Data *sd = _pd;
|
2012-07-16 14:56:30 -07:00
|
|
|
|
|
|
|
/* It makes no sense to insert after in an empty list with after !=
|
|
|
|
* NULL, something really bad is happening in your app. */
|
2012-11-25 22:32:53 -08:00
|
|
|
EINA_SAFETY_ON_NULL_RETURN(sd->items);
|
2012-07-16 14:56:30 -07:00
|
|
|
|
2012-11-16 06:26:07 -08:00
|
|
|
it = _elm_genlist_item_new
|
2012-07-16 14:56:30 -07:00
|
|
|
(sd, itc, data, (Elm_Gen_Item *)parent, type, func, func_data);
|
2012-11-25 22:32:53 -08:00
|
|
|
if (!it) return;
|
2012-07-16 14:56:30 -07:00
|
|
|
|
2011-08-01 23:59:45 -07:00
|
|
|
if (!it->parent)
|
|
|
|
{
|
2012-07-16 14:56:30 -07:00
|
|
|
if ((it->group) && (after->group))
|
|
|
|
sd->group_items = eina_list_append_relative
|
|
|
|
(sd->group_items, it, after);
|
2011-08-01 23:59:45 -07:00
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
2012-01-19 21:18:31 -08:00
|
|
|
it->parent->item->items =
|
2012-07-16 14:56:30 -07:00
|
|
|
eina_list_append_relative(it->parent->item->items, it, after);
|
2011-08-01 23:59:45 -07:00
|
|
|
}
|
2012-07-16 14:56:30 -07:00
|
|
|
sd->items = eina_inlist_append_relative
|
|
|
|
(sd->items, EINA_INLIST_GET(it), EINA_INLIST_GET(after));
|
|
|
|
|
|
|
|
it->item->rel = after;
|
2013-03-29 06:23:38 -07:00
|
|
|
after->item->rel_revs = eina_list_append(after->item->rel_revs, it);
|
2011-10-21 01:52:03 -07:00
|
|
|
it->item->before = EINA_FALSE;
|
2012-07-16 14:56:30 -07:00
|
|
|
_item_queue(sd, it, NULL);
|
|
|
|
|
2013-12-31 21:11:50 -08:00
|
|
|
if (ret) *ret = (Elm_Object_Item *)it;
|
2011-08-01 23:59:45 -07:00
|
|
|
}
|
|
|
|
|
2012-01-19 21:18:31 -08:00
|
|
|
EAPI Elm_Object_Item *
|
2012-07-16 14:56:30 -07:00
|
|
|
elm_genlist_item_insert_before(Evas_Object *obj,
|
2010-12-07 11:18:14 -08:00
|
|
|
const Elm_Genlist_Item_Class *itc,
|
2012-07-16 14:56:30 -07:00
|
|
|
const void *data,
|
|
|
|
Elm_Object_Item *parent,
|
|
|
|
Elm_Object_Item *before_it,
|
|
|
|
Elm_Genlist_Item_Type type,
|
|
|
|
Evas_Smart_Cb func,
|
|
|
|
const void *func_data)
|
|
|
|
{
|
2012-11-25 22:32:53 -08:00
|
|
|
ELM_GENLIST_CHECK(obj) NULL;
|
|
|
|
Elm_Object_Item *ret = NULL;
|
|
|
|
eo_do(obj, elm_obj_genlist_item_insert_before(itc, data, parent, before_it, type, func, func_data, &ret));
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
_item_insert_before(Eo *obj EINA_UNUSED, void *_pd, va_list *list)
|
|
|
|
{
|
|
|
|
const Elm_Genlist_Item_Class *itc = va_arg(*list, const Elm_Genlist_Item_Class *);
|
|
|
|
const void *data = va_arg(*list, const void *);
|
|
|
|
Elm_Object_Item *parent = va_arg(*list, Elm_Object_Item *);
|
|
|
|
Elm_Object_Item *before_it = va_arg(*list, Elm_Object_Item *);
|
|
|
|
Elm_Genlist_Item_Type type = va_arg(*list, Elm_Genlist_Item_Type);
|
|
|
|
Evas_Smart_Cb func = va_arg(*list, Evas_Smart_Cb);
|
|
|
|
const void *func_data = va_arg(*list, const void *);
|
|
|
|
Elm_Object_Item **ret = va_arg(*list, Elm_Object_Item **);
|
2012-07-16 14:56:30 -07:00
|
|
|
Elm_Gen_Item *before = (Elm_Gen_Item *)before_it;
|
|
|
|
Elm_Gen_Item *it;
|
|
|
|
|
2013-12-31 21:11:50 -08:00
|
|
|
if (ret) *ret = NULL;
|
2012-11-25 22:32:53 -08:00
|
|
|
|
|
|
|
ELM_GENLIST_ITEM_CHECK(before_it);
|
|
|
|
Elm_Genlist_Smart_Data *sd = _pd;
|
2012-07-16 14:56:30 -07:00
|
|
|
|
|
|
|
/* It makes no sense to insert before in an empty list with before
|
|
|
|
* != NULL, something really bad is happening in your app. */
|
2012-11-25 22:32:53 -08:00
|
|
|
EINA_SAFETY_ON_NULL_RETURN(sd->items);
|
2012-07-16 14:56:30 -07:00
|
|
|
|
2012-11-16 06:26:07 -08:00
|
|
|
it = _elm_genlist_item_new
|
2012-07-16 14:56:30 -07:00
|
|
|
(sd, itc, data, (Elm_Gen_Item *)parent, type, func, func_data);
|
2012-11-25 22:32:53 -08:00
|
|
|
if (!it) return;
|
2012-07-16 14:56:30 -07:00
|
|
|
|
2011-08-01 23:50:34 -07:00
|
|
|
if (!it->parent)
|
|
|
|
{
|
2012-07-16 14:56:30 -07:00
|
|
|
if (it->group && before->group)
|
|
|
|
sd->group_items =
|
|
|
|
eina_list_prepend_relative(sd->group_items, it, before);
|
2011-08-01 23:50:34 -07:00
|
|
|
}
|
|
|
|
else
|
2009-02-18 04:41:45 -08:00
|
|
|
{
|
2012-01-19 21:18:31 -08:00
|
|
|
it->parent->item->items =
|
2012-07-16 14:56:30 -07:00
|
|
|
eina_list_prepend_relative(it->parent->item->items, it, before);
|
2009-02-18 04:41:45 -08:00
|
|
|
}
|
2012-07-16 14:56:30 -07:00
|
|
|
sd->items = eina_inlist_prepend_relative
|
|
|
|
(sd->items, EINA_INLIST_GET(it), EINA_INLIST_GET(before));
|
|
|
|
|
|
|
|
it->item->rel = before;
|
2011-10-21 01:52:03 -07:00
|
|
|
it->item->before = EINA_TRUE;
|
2012-07-16 14:56:30 -07:00
|
|
|
_item_queue(sd, it, NULL);
|
|
|
|
|
2013-12-31 21:11:50 -08:00
|
|
|
if (ret) *ret = (Elm_Object_Item *)it;
|
2009-02-10 03:57:47 -08:00
|
|
|
}
|
|
|
|
|
2012-01-19 21:18:31 -08:00
|
|
|
EAPI Elm_Object_Item *
|
2012-07-16 14:56:30 -07:00
|
|
|
elm_genlist_item_sorted_insert(Evas_Object *obj,
|
2012-02-27 23:17:00 -08:00
|
|
|
const Elm_Genlist_Item_Class *itc,
|
2012-07-16 14:56:30 -07:00
|
|
|
const void *data,
|
|
|
|
Elm_Object_Item *parent,
|
|
|
|
Elm_Genlist_Item_Type type,
|
|
|
|
Eina_Compare_Cb comp,
|
|
|
|
Evas_Smart_Cb func,
|
|
|
|
const void *func_data)
|
2012-11-25 22:32:53 -08:00
|
|
|
{
|
|
|
|
ELM_GENLIST_CHECK(obj) NULL;
|
|
|
|
Elm_Object_Item *ret = NULL;
|
|
|
|
eo_do(obj, elm_obj_genlist_item_sorted_insert(itc, data, parent, type, comp, func, func_data, &ret));
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
_item_sorted_insert(Eo *obj EINA_UNUSED, void *_pd, va_list *list)
|
2012-07-16 14:56:30 -07:00
|
|
|
{
|
2011-10-21 01:52:03 -07:00
|
|
|
Elm_Gen_Item *rel = NULL;
|
2012-07-16 14:56:30 -07:00
|
|
|
Elm_Gen_Item *it;
|
|
|
|
|
2012-11-25 22:32:53 -08:00
|
|
|
const Elm_Genlist_Item_Class *itc = va_arg(*list, const Elm_Genlist_Item_Class *);
|
|
|
|
const void *data = va_arg(*list, const void *);
|
|
|
|
Elm_Object_Item *parent = va_arg(*list, Elm_Object_Item *);
|
|
|
|
Elm_Genlist_Item_Type type = va_arg(*list, Elm_Genlist_Item_Type);
|
|
|
|
Eina_Compare_Cb comp = va_arg(*list, Eina_Compare_Cb);
|
|
|
|
Evas_Smart_Cb func = va_arg(*list, Evas_Smart_Cb);
|
|
|
|
const void *func_data = va_arg(*list, const void *);
|
|
|
|
Elm_Object_Item **ret = va_arg(*list, Elm_Object_Item **);
|
2013-12-31 21:11:50 -08:00
|
|
|
if (ret) *ret = NULL;
|
2012-11-25 22:32:53 -08:00
|
|
|
|
|
|
|
Elm_Genlist_Smart_Data *sd = _pd;
|
2012-07-16 14:56:30 -07:00
|
|
|
|
2012-11-16 06:26:07 -08:00
|
|
|
it = _elm_genlist_item_new
|
2012-07-16 14:56:30 -07:00
|
|
|
(sd, itc, data, (Elm_Gen_Item *)parent, type, func, func_data);
|
2012-11-25 22:32:53 -08:00
|
|
|
if (!it) return;
|
2011-05-25 07:58:39 -07:00
|
|
|
|
2012-07-16 14:56:30 -07:00
|
|
|
sd->item_compare_cb = comp;
|
2011-06-25 16:20:22 -07:00
|
|
|
|
2011-05-25 07:58:39 -07:00
|
|
|
if (it->parent)
|
|
|
|
{
|
2011-07-28 09:43:15 -07:00
|
|
|
Eina_List *l;
|
|
|
|
int cmp_result;
|
|
|
|
|
2012-07-16 14:56:30 -07:00
|
|
|
l = eina_list_search_sorted_near_list
|
|
|
|
(it->parent->item->items, _elm_genlist_item_list_compare, it,
|
|
|
|
&cmp_result);
|
|
|
|
|
2011-07-28 09:43:15 -07:00
|
|
|
if (l)
|
2014-02-19 02:30:10 -08:00
|
|
|
{
|
|
|
|
rel = eina_list_data_get(l);
|
2011-07-28 09:43:15 -07:00
|
|
|
|
2014-02-19 02:30:10 -08:00
|
|
|
if (cmp_result >= 0)
|
|
|
|
{
|
|
|
|
it->parent->item->items = eina_list_prepend_relative_list
|
|
|
|
(it->parent->item->items, it, l);
|
|
|
|
sd->items = eina_inlist_prepend_relative
|
|
|
|
(sd->items, EINA_INLIST_GET(it), EINA_INLIST_GET(rel));
|
|
|
|
it->item->before = EINA_TRUE;
|
|
|
|
}
|
|
|
|
else if (cmp_result < 0)
|
|
|
|
{
|
|
|
|
it->parent->item->items = eina_list_append_relative_list
|
|
|
|
(it->parent->item->items, it, l);
|
|
|
|
sd->items = eina_inlist_append_relative
|
|
|
|
(sd->items, EINA_INLIST_GET(it), EINA_INLIST_GET(rel));
|
|
|
|
it->item->before = EINA_FALSE;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
else
|
2011-07-28 09:43:15 -07:00
|
|
|
{
|
2014-02-19 02:30:10 -08:00
|
|
|
rel = it->parent;
|
|
|
|
|
2014-03-01 07:51:59 -08:00
|
|
|
// ignoring the comparison
|
2014-02-22 04:39:46 -08:00
|
|
|
it->parent->item->items = eina_list_prepend_relative_list
|
2012-07-16 14:56:30 -07:00
|
|
|
(it->parent->item->items, it, l);
|
2014-02-22 04:39:46 -08:00
|
|
|
sd->items = eina_inlist_prepend_relative
|
2012-07-16 14:56:30 -07:00
|
|
|
(sd->items, EINA_INLIST_GET(it), EINA_INLIST_GET(rel));
|
2011-10-21 01:52:03 -07:00
|
|
|
it->item->before = EINA_FALSE;
|
2011-07-28 09:43:15 -07:00
|
|
|
}
|
2011-05-25 07:58:39 -07:00
|
|
|
}
|
2011-07-28 09:43:15 -07:00
|
|
|
else
|
2011-05-25 07:58:39 -07:00
|
|
|
{
|
2012-07-16 14:56:30 -07:00
|
|
|
if (!sd->state)
|
2011-09-05 13:31:51 -07:00
|
|
|
{
|
2012-07-16 14:56:30 -07:00
|
|
|
sd->state = eina_inlist_sorted_state_new();
|
|
|
|
eina_inlist_sorted_state_init(sd->state, sd->items);
|
|
|
|
sd->requeued = EINA_FALSE;
|
2011-09-05 13:31:51 -07:00
|
|
|
}
|
|
|
|
|
2011-10-23 20:40:54 -07:00
|
|
|
if (it->group)
|
2012-07-16 14:56:30 -07:00
|
|
|
sd->group_items = eina_list_append(sd->group_items, it);
|
2011-07-28 09:43:15 -07:00
|
|
|
|
2012-07-16 14:56:30 -07:00
|
|
|
sd->items = eina_inlist_sorted_state_insert
|
|
|
|
(sd->items, EINA_INLIST_GET(it), _elm_genlist_item_compare,
|
|
|
|
sd->state);
|
2011-07-28 09:43:15 -07:00
|
|
|
|
|
|
|
if (EINA_INLIST_GET(it)->next)
|
|
|
|
{
|
2011-10-21 15:55:45 -07:00
|
|
|
rel = ELM_GEN_ITEM_FROM_INLIST(EINA_INLIST_GET(it)->next);
|
2011-10-21 01:52:03 -07:00
|
|
|
it->item->before = EINA_TRUE;
|
2011-07-28 09:43:15 -07:00
|
|
|
}
|
|
|
|
else if (EINA_INLIST_GET(it)->prev)
|
|
|
|
{
|
2011-10-21 15:55:45 -07:00
|
|
|
rel = ELM_GEN_ITEM_FROM_INLIST(EINA_INLIST_GET(it)->prev);
|
2011-10-21 01:52:03 -07:00
|
|
|
it->item->before = EINA_FALSE;
|
2011-07-28 09:43:15 -07:00
|
|
|
}
|
2011-05-25 07:58:39 -07:00
|
|
|
}
|
2011-07-28 09:43:15 -07:00
|
|
|
|
|
|
|
if (rel)
|
2011-05-25 07:58:39 -07:00
|
|
|
{
|
2011-10-21 01:52:03 -07:00
|
|
|
it->item->rel = rel;
|
2013-03-29 06:23:38 -07:00
|
|
|
rel->item->rel_revs = eina_list_append(rel->item->rel_revs, it);
|
2011-05-25 07:58:39 -07:00
|
|
|
}
|
2011-07-28 09:43:15 -07:00
|
|
|
|
2012-07-16 14:56:30 -07:00
|
|
|
_item_queue(sd, it, _elm_genlist_item_list_compare);
|
2011-05-25 07:58:39 -07:00
|
|
|
|
2013-12-31 21:11:50 -08:00
|
|
|
if (ret) *ret = (Elm_Object_Item *)it;
|
2011-05-25 07:58:39 -07:00
|
|
|
}
|
|
|
|
|
2011-12-02 05:43:02 -08:00
|
|
|
EAPI void
|
|
|
|
elm_genlist_clear(Evas_Object *obj)
|
|
|
|
{
|
2012-07-16 14:56:30 -07:00
|
|
|
ELM_GENLIST_CHECK(obj);
|
2012-11-25 22:32:53 -08:00
|
|
|
eo_do(obj, elm_obj_genlist_clear());
|
|
|
|
}
|
2012-07-16 14:56:30 -07:00
|
|
|
|
2012-11-25 22:32:53 -08:00
|
|
|
static void
|
|
|
|
_clear_eo(Eo *obj, void *_pd EINA_UNUSED, va_list *list EINA_UNUSED)
|
|
|
|
{
|
2013-04-17 09:30:34 -07:00
|
|
|
_elm_genlist_clear(obj, EINA_FALSE);
|
2011-12-02 05:43:02 -08:00
|
|
|
}
|
|
|
|
|
2009-02-10 03:57:47 -08:00
|
|
|
EAPI void
|
2010-12-07 11:18:14 -08:00
|
|
|
elm_genlist_multi_select_set(Evas_Object *obj,
|
2012-07-16 14:56:30 -07:00
|
|
|
Eina_Bool multi)
|
2009-02-10 03:57:47 -08:00
|
|
|
{
|
2012-07-16 14:56:30 -07:00
|
|
|
ELM_GENLIST_CHECK(obj);
|
2012-11-25 22:32:53 -08:00
|
|
|
eo_do(obj, elm_obj_genlist_multi_select_set(multi));
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
_multi_select_set(Eo *obj EINA_UNUSED, void *_pd, va_list *list)
|
|
|
|
{
|
|
|
|
Eina_Bool multi = va_arg(*list, int);
|
|
|
|
Elm_Genlist_Smart_Data *sd = _pd;
|
2012-07-16 14:56:30 -07:00
|
|
|
|
|
|
|
sd->multi = !!multi;
|
2009-02-10 03:57:47 -08:00
|
|
|
}
|
|
|
|
|
2010-04-06 07:01:04 -07:00
|
|
|
EAPI Eina_Bool
|
|
|
|
elm_genlist_multi_select_get(const Evas_Object *obj)
|
|
|
|
{
|
2012-07-16 14:56:30 -07:00
|
|
|
ELM_GENLIST_CHECK(obj) EINA_FALSE;
|
2012-11-25 22:32:53 -08:00
|
|
|
Eina_Bool ret = EINA_FALSE;
|
|
|
|
eo_do((Eo *) obj, elm_obj_genlist_multi_select_get(&ret));
|
|
|
|
return ret;
|
|
|
|
}
|
2012-07-16 14:56:30 -07:00
|
|
|
|
2012-11-25 22:32:53 -08:00
|
|
|
static void
|
|
|
|
_multi_select_get(Eo *obj EINA_UNUSED, void *_pd, va_list *list)
|
|
|
|
{
|
|
|
|
Eina_Bool *ret = va_arg(*list, Eina_Bool *);
|
|
|
|
Elm_Genlist_Smart_Data *sd = _pd;
|
|
|
|
|
2013-12-31 21:11:50 -08:00
|
|
|
if (ret) *ret = sd->multi;
|
2010-04-06 07:01:04 -07:00
|
|
|
}
|
|
|
|
|
2013-11-03 06:58:57 -08:00
|
|
|
EAPI void
|
|
|
|
elm_genlist_multi_select_mode_set(Evas_Object *obj,
|
|
|
|
Elm_Object_Multi_Select_Mode mode)
|
|
|
|
{
|
|
|
|
ELM_GENLIST_CHECK(obj);
|
2013-11-03 08:15:58 -08:00
|
|
|
eo_do(obj, elm_obj_genlist_multi_select_mode_set(mode));
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
_multi_select_mode_set(Eo *obj EINA_UNUSED, void *_pd, va_list *list)
|
|
|
|
{
|
|
|
|
Elm_Object_Multi_Select_Mode mode = va_arg(*list, Elm_Object_Multi_Select_Mode);
|
|
|
|
Elm_Genlist_Smart_Data *sd = _pd;
|
|
|
|
|
|
|
|
if (mode >= ELM_OBJECT_MULTI_SELECT_MODE_MAX)
|
|
|
|
return;
|
2013-11-03 06:58:57 -08:00
|
|
|
|
2013-11-03 08:15:58 -08:00
|
|
|
if (sd->multi_select_mode != mode)
|
|
|
|
sd->multi_select_mode = mode;
|
2013-11-03 06:58:57 -08:00
|
|
|
}
|
|
|
|
|
|
|
|
EAPI Elm_Object_Multi_Select_Mode
|
|
|
|
elm_genlist_multi_select_mode_get(const Evas_Object *obj)
|
|
|
|
{
|
|
|
|
ELM_GENLIST_CHECK(obj) ELM_OBJECT_MULTI_SELECT_MODE_MAX;
|
2013-11-03 08:15:58 -08:00
|
|
|
Elm_Object_Multi_Select_Mode ret = ELM_OBJECT_MULTI_SELECT_MODE_MAX;
|
|
|
|
eo_do((Eo *)obj, elm_obj_genlist_multi_select_mode_get(&ret));
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
_multi_select_mode_get(Eo *obj EINA_UNUSED, void *_pd, va_list *list)
|
|
|
|
{
|
|
|
|
Elm_Object_Multi_Select_Mode *ret = va_arg(*list, Elm_Object_Multi_Select_Mode *);
|
|
|
|
Elm_Genlist_Smart_Data *sd = _pd;
|
2013-11-03 06:58:57 -08:00
|
|
|
|
2013-12-31 21:11:50 -08:00
|
|
|
if (ret) *ret = sd->multi_select_mode;
|
2013-11-03 06:58:57 -08:00
|
|
|
}
|
|
|
|
|
2012-01-19 21:18:31 -08:00
|
|
|
EAPI Elm_Object_Item *
|
2009-02-25 07:54:26 -08:00
|
|
|
elm_genlist_selected_item_get(const Evas_Object *obj)
|
2009-02-10 03:57:47 -08:00
|
|
|
{
|
2012-07-16 14:56:30 -07:00
|
|
|
ELM_GENLIST_CHECK(obj) NULL;
|
2012-11-25 22:32:53 -08:00
|
|
|
Elm_Object_Item *ret = NULL;
|
|
|
|
eo_do((Eo *) obj, elm_obj_genlist_selected_item_get(&ret));
|
|
|
|
return ret;
|
|
|
|
}
|
2012-07-16 14:56:30 -07:00
|
|
|
|
2012-11-25 22:32:53 -08:00
|
|
|
static void
|
|
|
|
_selected_item_get(Eo *obj EINA_UNUSED, void *_pd, va_list *list)
|
|
|
|
{
|
|
|
|
Elm_Object_Item **ret = va_arg(*list, Elm_Object_Item **);
|
|
|
|
Elm_Genlist_Smart_Data *sd = _pd;
|
2012-07-16 14:56:30 -07:00
|
|
|
|
2012-11-25 22:32:53 -08:00
|
|
|
if (sd->selected)
|
|
|
|
*ret = sd->selected->data;
|
|
|
|
else
|
|
|
|
*ret = NULL;
|
2009-02-10 03:57:47 -08:00
|
|
|
}
|
|
|
|
|
|
|
|
EAPI const Eina_List *
|
2009-02-25 07:54:26 -08:00
|
|
|
elm_genlist_selected_items_get(const Evas_Object *obj)
|
2009-02-10 03:57:47 -08:00
|
|
|
{
|
2012-07-16 14:56:30 -07:00
|
|
|
ELM_GENLIST_CHECK(obj) NULL;
|
2012-11-25 22:32:53 -08:00
|
|
|
const Eina_List *ret = NULL;
|
|
|
|
eo_do((Eo *) obj, elm_obj_genlist_selected_items_get(&ret));
|
|
|
|
return ret;
|
|
|
|
}
|
2012-07-16 14:56:30 -07:00
|
|
|
|
2012-11-25 22:32:53 -08:00
|
|
|
static void
|
|
|
|
_selected_items_get(Eo *obj EINA_UNUSED, void *_pd, va_list *list)
|
|
|
|
{
|
|
|
|
const Eina_List **ret = va_arg(*list, const Eina_List **);
|
|
|
|
Elm_Genlist_Smart_Data *sd = _pd;
|
|
|
|
|
2013-12-31 21:11:50 -08:00
|
|
|
if (ret) *ret = sd->selected;
|
2009-02-10 03:57:47 -08:00
|
|
|
}
|
|
|
|
|
2010-01-24 21:54:31 -08:00
|
|
|
EAPI Eina_List *
|
|
|
|
elm_genlist_realized_items_get(const Evas_Object *obj)
|
2012-11-25 22:32:53 -08:00
|
|
|
{
|
|
|
|
ELM_GENLIST_CHECK(obj) NULL;
|
|
|
|
Eina_List *ret = NULL;
|
|
|
|
eo_do((Eo *) obj, elm_obj_genlist_realized_items_get(&ret));
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
_realized_items_get(Eo *obj EINA_UNUSED, void *_pd, va_list *list)
|
2010-01-24 21:54:31 -08:00
|
|
|
{
|
|
|
|
Item_Block *itb;
|
2010-06-05 06:12:45 -07:00
|
|
|
Eina_Bool done = EINA_FALSE;
|
2012-07-16 14:56:30 -07:00
|
|
|
|
2012-11-25 22:32:53 -08:00
|
|
|
Eina_List **ret = va_arg(*list, Eina_List **);
|
|
|
|
Elm_Genlist_Smart_Data *sd = _pd;
|
2014-01-10 04:05:00 -08:00
|
|
|
if (!ret) return;
|
|
|
|
|
|
|
|
*ret = NULL;
|
2012-07-16 14:56:30 -07:00
|
|
|
|
2012-10-01 00:36:27 -07:00
|
|
|
EINA_INLIST_FOREACH(sd->blocks, itb)
|
2011-03-22 00:54:24 -07:00
|
|
|
{
|
|
|
|
if (itb->realized)
|
|
|
|
{
|
|
|
|
Eina_List *l;
|
2011-10-21 01:52:03 -07:00
|
|
|
Elm_Gen_Item *it;
|
2011-03-22 00:54:24 -07:00
|
|
|
|
2012-02-27 21:26:49 -08:00
|
|
|
done = EINA_TRUE;
|
2012-10-01 00:36:27 -07:00
|
|
|
EINA_LIST_FOREACH(itb->items, l, it)
|
2011-03-22 00:54:24 -07:00
|
|
|
{
|
2014-01-10 04:05:00 -08:00
|
|
|
if (it->realized) *ret = eina_list_append(*ret, it);
|
2011-03-22 00:54:24 -07:00
|
|
|
}
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
if (done) break;
|
|
|
|
}
|
|
|
|
}
|
2010-01-24 21:54:31 -08:00
|
|
|
}
|
|
|
|
|
2012-01-19 21:18:31 -08:00
|
|
|
EAPI Elm_Object_Item *
|
2010-12-07 11:18:14 -08:00
|
|
|
elm_genlist_at_xy_item_get(const Evas_Object *obj,
|
2012-07-16 14:56:30 -07:00
|
|
|
Evas_Coord x,
|
|
|
|
Evas_Coord y,
|
|
|
|
int *posret)
|
2012-11-25 22:32:53 -08:00
|
|
|
{
|
|
|
|
ELM_GENLIST_CHECK(obj) NULL;
|
|
|
|
Elm_Object_Item *ret = NULL;
|
|
|
|
eo_do((Eo *) obj, elm_obj_genlist_at_xy_item_get(x, y, posret, &ret));
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
_at_xy_item_get(Eo *obj EINA_UNUSED, void *_pd, va_list *list)
|
2009-09-22 20:22:07 -07:00
|
|
|
{
|
|
|
|
Evas_Coord ox, oy, ow, oh;
|
|
|
|
Evas_Coord lasty;
|
2012-07-16 14:56:30 -07:00
|
|
|
Item_Block *itb;
|
|
|
|
|
2012-11-25 22:32:53 -08:00
|
|
|
Evas_Coord x = va_arg(*list, Evas_Coord);
|
|
|
|
Evas_Coord y = va_arg(*list, Evas_Coord);
|
|
|
|
int *posret = va_arg(*list, int *);
|
|
|
|
Elm_Object_Item **ret = va_arg(*list, Elm_Object_Item **);
|
|
|
|
Elm_Genlist_Smart_Data *sd = _pd;
|
2012-07-16 14:56:30 -07:00
|
|
|
|
|
|
|
evas_object_geometry_get(sd->pan_obj, &ox, &oy, &ow, &oh);
|
2009-09-22 20:22:07 -07:00
|
|
|
lasty = oy;
|
2012-10-01 00:36:27 -07:00
|
|
|
EINA_INLIST_FOREACH(sd->blocks, itb)
|
2011-03-22 00:54:24 -07:00
|
|
|
{
|
|
|
|
Eina_List *l;
|
2011-10-21 01:52:03 -07:00
|
|
|
Elm_Gen_Item *it;
|
2011-03-22 00:54:24 -07:00
|
|
|
|
2012-07-16 14:56:30 -07:00
|
|
|
if (!ELM_RECTS_INTERSECT(ox + itb->x - itb->sd->pan_x,
|
|
|
|
oy + itb->y - itb->sd->pan_y,
|
2011-03-22 00:54:24 -07:00
|
|
|
itb->w, itb->h, x, y, 1, 1))
|
|
|
|
continue;
|
2012-10-01 00:36:27 -07:00
|
|
|
EINA_LIST_FOREACH(itb->items, l, it)
|
2011-03-22 00:54:24 -07:00
|
|
|
{
|
|
|
|
Evas_Coord itx, ity;
|
|
|
|
|
2012-07-16 14:56:30 -07:00
|
|
|
itx = ox + itb->x + it->x - itb->sd->pan_x;
|
|
|
|
ity = oy + itb->y + it->y - itb->sd->pan_y;
|
|
|
|
if (ELM_RECTS_INTERSECT
|
|
|
|
(itx, ity, it->item->w, it->item->h, x, y, 1, 1))
|
2011-03-22 00:54:24 -07:00
|
|
|
{
|
|
|
|
if (posret)
|
|
|
|
{
|
2011-10-21 01:52:03 -07:00
|
|
|
if (y <= (ity + (it->item->h / 4))) *posret = -1;
|
|
|
|
else if (y >= (ity + it->item->h - (it->item->h / 4)))
|
2011-03-22 00:54:24 -07:00
|
|
|
*posret = 1;
|
|
|
|
else *posret = 0;
|
|
|
|
}
|
2012-07-16 14:56:30 -07:00
|
|
|
|
2012-11-25 22:32:53 -08:00
|
|
|
*ret = (Elm_Object_Item *)it;
|
|
|
|
return;
|
2011-03-22 00:54:24 -07:00
|
|
|
}
|
2011-10-21 01:52:03 -07:00
|
|
|
lasty = ity + it->item->h;
|
2011-03-22 00:54:24 -07:00
|
|
|
}
|
|
|
|
}
|
2009-09-22 20:22:07 -07:00
|
|
|
if (posret)
|
|
|
|
{
|
|
|
|
if (y > lasty) *posret = 1;
|
|
|
|
else *posret = -1;
|
|
|
|
}
|
2012-07-16 14:56:30 -07:00
|
|
|
|
2013-12-31 21:11:50 -08:00
|
|
|
if (ret) *ret = NULL;
|
2009-09-22 20:22:07 -07:00
|
|
|
}
|
|
|
|
|
2012-01-19 21:18:31 -08:00
|
|
|
EAPI Elm_Object_Item *
|
2009-02-25 07:54:26 -08:00
|
|
|
elm_genlist_first_item_get(const Evas_Object *obj)
|
2012-11-25 22:32:53 -08:00
|
|
|
{
|
|
|
|
ELM_GENLIST_CHECK(obj) NULL;
|
|
|
|
Elm_Object_Item *ret = NULL;
|
|
|
|
eo_do((Eo *) obj, elm_obj_genlist_first_item_get(&ret));
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
_first_item_get(Eo *obj EINA_UNUSED, void *_pd, va_list *list)
|
2009-02-10 03:57:47 -08:00
|
|
|
{
|
2012-07-16 14:56:30 -07:00
|
|
|
Elm_Gen_Item *it;
|
|
|
|
|
2012-11-25 22:32:53 -08:00
|
|
|
Elm_Object_Item **ret = va_arg(*list, Elm_Object_Item **);
|
|
|
|
Elm_Genlist_Smart_Data *sd = _pd;
|
2013-12-31 21:11:50 -08:00
|
|
|
if (ret) *ret = NULL;
|
2012-07-16 14:56:30 -07:00
|
|
|
|
2012-11-25 22:32:53 -08:00
|
|
|
if (!sd->items) return;
|
2012-07-16 14:56:30 -07:00
|
|
|
|
|
|
|
it = ELM_GEN_ITEM_FROM_INLIST(sd->items);
|
2013-04-17 09:30:34 -07:00
|
|
|
while ((it) && (it->generation < sd->generation))
|
2011-11-30 09:13:57 -08:00
|
|
|
it = ELM_GEN_ITEM_FROM_INLIST(EINA_INLIST_GET(it)->next);
|
2012-07-16 14:56:30 -07:00
|
|
|
|
2013-12-31 21:11:50 -08:00
|
|
|
if (ret) *ret = (Elm_Object_Item *)it;
|
2009-02-16 23:50:35 -08:00
|
|
|
}
|
|
|
|
|
2012-01-19 21:18:31 -08:00
|
|
|
EAPI Elm_Object_Item *
|
2009-02-25 07:54:26 -08:00
|
|
|
elm_genlist_last_item_get(const Evas_Object *obj)
|
2012-11-25 22:32:53 -08:00
|
|
|
{
|
|
|
|
ELM_GENLIST_CHECK(obj) NULL;
|
|
|
|
Elm_Object_Item *ret = NULL;
|
|
|
|
eo_do((Eo *) obj, elm_obj_genlist_last_item_get(&ret));
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
_last_item_get(Eo *obj EINA_UNUSED, void *_pd, va_list *list)
|
2009-02-16 23:50:35 -08:00
|
|
|
{
|
2012-07-16 14:56:30 -07:00
|
|
|
Elm_Gen_Item *it;
|
|
|
|
|
2012-11-25 22:32:53 -08:00
|
|
|
Elm_Object_Item **ret = va_arg(*list, Elm_Object_Item **);
|
2013-12-31 21:11:50 -08:00
|
|
|
if (ret) *ret = NULL;
|
2012-07-16 14:56:30 -07:00
|
|
|
|
2012-11-25 22:32:53 -08:00
|
|
|
Elm_Genlist_Smart_Data *sd = _pd;
|
|
|
|
|
|
|
|
if (!sd->items) return;
|
2012-07-16 14:56:30 -07:00
|
|
|
|
|
|
|
it = ELM_GEN_ITEM_FROM_INLIST(sd->items->last);
|
2013-04-17 09:30:34 -07:00
|
|
|
while ((it) && (it->generation < sd->generation))
|
2011-11-30 09:13:57 -08:00
|
|
|
it = ELM_GEN_ITEM_FROM_INLIST(EINA_INLIST_GET(it)->prev);
|
2012-07-16 14:56:30 -07:00
|
|
|
|
2013-12-31 21:11:50 -08:00
|
|
|
if (ret) *ret = (Elm_Object_Item *)it;
|
2009-02-16 23:50:35 -08:00
|
|
|
}
|
|
|
|
|
2012-01-19 21:18:31 -08:00
|
|
|
EAPI Elm_Object_Item *
|
2012-07-16 14:56:30 -07:00
|
|
|
elm_genlist_item_next_get(const Elm_Object_Item *item)
|
2009-02-16 23:50:35 -08:00
|
|
|
{
|
2012-11-25 22:32:53 -08:00
|
|
|
Elm_Gen_Item *it = NULL;
|
2012-07-16 14:56:30 -07:00
|
|
|
|
|
|
|
ELM_GENLIST_ITEM_CHECK_OR_RETURN(item, NULL);
|
|
|
|
|
|
|
|
it = (Elm_Gen_Item *)item;
|
|
|
|
while (it)
|
2011-11-30 09:13:57 -08:00
|
|
|
{
|
2012-07-16 14:56:30 -07:00
|
|
|
it = ELM_GEN_ITEM_FROM_INLIST(EINA_INLIST_GET(it)->next);
|
2013-04-17 09:30:34 -07:00
|
|
|
if ((it) && (it->generation == GL_IT(it)->wsd->generation)) break;
|
2011-11-30 09:13:57 -08:00
|
|
|
}
|
2012-07-16 14:56:30 -07:00
|
|
|
|
|
|
|
return (Elm_Object_Item *)it;
|
2009-02-16 23:50:35 -08:00
|
|
|
}
|
|
|
|
|
2012-01-19 21:18:31 -08:00
|
|
|
EAPI Elm_Object_Item *
|
2012-07-16 14:56:30 -07:00
|
|
|
elm_genlist_item_prev_get(const Elm_Object_Item *item)
|
2009-02-16 23:50:35 -08:00
|
|
|
{
|
2012-11-25 22:32:53 -08:00
|
|
|
Elm_Gen_Item *it = NULL;
|
2012-07-16 14:56:30 -07:00
|
|
|
|
|
|
|
ELM_GENLIST_ITEM_CHECK_OR_RETURN(item, NULL);
|
|
|
|
|
|
|
|
it = (Elm_Gen_Item *)item;
|
|
|
|
while (it)
|
2011-11-30 09:13:57 -08:00
|
|
|
{
|
2012-07-16 14:56:30 -07:00
|
|
|
it = ELM_GEN_ITEM_FROM_INLIST(EINA_INLIST_GET(it)->prev);
|
2013-04-17 09:30:34 -07:00
|
|
|
if ((it) && (it->generation == GL_IT(it)->wsd->generation)) break;
|
2011-11-30 09:13:57 -08:00
|
|
|
}
|
2012-07-16 14:56:30 -07:00
|
|
|
|
|
|
|
return (Elm_Object_Item *)it;
|
2009-02-10 03:57:47 -08:00
|
|
|
}
|
|
|
|
|
2012-01-19 21:18:31 -08:00
|
|
|
EAPI Elm_Object_Item *
|
|
|
|
elm_genlist_item_parent_get(const Elm_Object_Item *it)
|
2009-03-12 22:50:38 -07:00
|
|
|
{
|
2012-07-16 14:56:30 -07:00
|
|
|
ELM_GENLIST_ITEM_CHECK_OR_RETURN(it, NULL);
|
|
|
|
|
|
|
|
return (Elm_Object_Item *)((Elm_Gen_Item *)it)->parent;
|
2009-03-12 22:50:38 -07:00
|
|
|
}
|
|
|
|
|
2014-02-07 22:14:36 -08:00
|
|
|
EAPI unsigned int
|
|
|
|
elm_genlist_item_subitems_count(const Elm_Object_Item *it)
|
|
|
|
{
|
|
|
|
Elm_Gen_Item *item = (Elm_Gen_Item *)it;
|
|
|
|
ELM_GENLIST_ITEM_CHECK_OR_RETURN(it, 0);
|
|
|
|
|
|
|
|
return eina_list_count(item->item->items);
|
|
|
|
}
|
|
|
|
|
2014-02-08 13:02:27 -08:00
|
|
|
EAPI const Eina_List *
|
|
|
|
elm_genlist_item_subitems_get(const Elm_Object_Item *it)
|
|
|
|
{
|
|
|
|
Elm_Gen_Item *item = (Elm_Gen_Item *)it;
|
|
|
|
ELM_GENLIST_ITEM_CHECK_OR_RETURN(it, NULL);
|
|
|
|
|
|
|
|
return item->item->items;
|
|
|
|
}
|
|
|
|
|
2009-03-12 22:50:38 -07:00
|
|
|
EAPI void
|
2012-07-16 14:56:30 -07:00
|
|
|
elm_genlist_item_subitems_clear(Elm_Object_Item *item)
|
2009-03-12 22:50:38 -07:00
|
|
|
{
|
2012-07-16 14:56:30 -07:00
|
|
|
Elm_Gen_Item *it = (Elm_Gen_Item *)item;
|
2009-07-06 23:46:51 -07:00
|
|
|
|
2012-07-16 14:56:30 -07:00
|
|
|
ELM_GENLIST_ITEM_CHECK_OR_RETURN(item);
|
|
|
|
ELM_GENLIST_DATA_GET(WIDGET(it), sd);
|
|
|
|
|
|
|
|
if (!sd->tree_effect_enabled || !sd->move_effect_mode)
|
|
|
|
_item_sub_items_clear(it);
|
2012-03-07 04:15:36 -08:00
|
|
|
else
|
|
|
|
{
|
2012-07-16 14:56:30 -07:00
|
|
|
if (!sd->tree_effect_animator)
|
2012-03-07 04:15:36 -08:00
|
|
|
{
|
2012-07-16 14:56:30 -07:00
|
|
|
sd->expanded_item = it;
|
|
|
|
_item_tree_effect_before(it);
|
2014-03-08 11:46:24 -08:00
|
|
|
evas_object_stack_below(sd->event_block_rect, sd->stack[1]);
|
|
|
|
evas_object_show(sd->event_block_rect);
|
2012-07-16 14:56:30 -07:00
|
|
|
sd->start_time = ecore_time_get();
|
|
|
|
sd->tree_effect_animator =
|
2013-04-24 04:41:37 -07:00
|
|
|
ecore_animator_add(_tree_effect_animator_cb, sd->obj);
|
2012-03-07 04:15:36 -08:00
|
|
|
}
|
|
|
|
else
|
2012-07-16 14:56:30 -07:00
|
|
|
_item_sub_items_clear(it);
|
2012-03-07 04:15:36 -08:00
|
|
|
}
|
2009-03-12 22:50:38 -07:00
|
|
|
}
|
|
|
|
|
2009-02-10 03:57:47 -08:00
|
|
|
EAPI void
|
2012-07-16 14:56:30 -07:00
|
|
|
elm_genlist_item_selected_set(Elm_Object_Item *item,
|
2012-01-19 21:18:31 -08:00
|
|
|
Eina_Bool selected)
|
2009-02-10 03:57:47 -08:00
|
|
|
{
|
2012-07-16 14:56:30 -07:00
|
|
|
Elm_Gen_Item *it = (Elm_Gen_Item *)item;
|
|
|
|
ELM_GENLIST_ITEM_CHECK_OR_RETURN(item);
|
2013-05-02 11:13:36 -07:00
|
|
|
ELM_GENLIST_DATA_GET_FROM_ITEM(it, sd);
|
2012-07-16 14:56:30 -07:00
|
|
|
|
2013-04-17 09:30:34 -07:00
|
|
|
if ((it->generation < sd->generation) || elm_widget_item_disabled_get(it))
|
2012-01-26 23:36:36 -08:00
|
|
|
return;
|
2011-11-30 09:13:57 -08:00
|
|
|
selected = !!selected;
|
2012-07-16 14:56:30 -07:00
|
|
|
if (it->selected == selected) return;
|
2011-11-30 09:13:57 -08:00
|
|
|
|
|
|
|
if (selected)
|
|
|
|
{
|
2012-07-16 14:56:30 -07:00
|
|
|
if (!sd->multi)
|
2011-11-30 09:13:57 -08:00
|
|
|
{
|
2012-07-16 14:56:30 -07:00
|
|
|
while (sd->selected)
|
2011-11-30 09:13:57 -08:00
|
|
|
{
|
2012-07-16 14:56:30 -07:00
|
|
|
if (it->unhighlight_cb)
|
|
|
|
it->unhighlight_cb(sd->selected->data);
|
|
|
|
it->unsel_cb(sd->selected->data);
|
2011-11-30 09:13:57 -08:00
|
|
|
}
|
|
|
|
}
|
2012-07-16 14:56:30 -07:00
|
|
|
it->highlight_cb(it);
|
2014-03-22 03:10:27 -07:00
|
|
|
it->sel_cb(it);
|
2012-07-16 14:56:30 -07:00
|
|
|
|
2011-11-30 09:13:57 -08:00
|
|
|
return;
|
|
|
|
}
|
2012-07-16 14:56:30 -07:00
|
|
|
if (it->unhighlight_cb) it->unhighlight_cb(it);
|
|
|
|
it->unsel_cb(it);
|
2009-02-10 03:57:47 -08:00
|
|
|
}
|
|
|
|
|
2009-06-17 08:35:19 -07:00
|
|
|
EAPI Eina_Bool
|
2012-01-19 21:18:31 -08:00
|
|
|
elm_genlist_item_selected_get(const Elm_Object_Item *it)
|
2009-02-17 20:51:22 -08:00
|
|
|
{
|
2012-07-16 14:56:30 -07:00
|
|
|
ELM_GENLIST_ITEM_CHECK_OR_RETURN(it, EINA_FALSE);
|
|
|
|
|
2012-03-05 07:14:36 -08:00
|
|
|
return ((Elm_Gen_Item *)it)->selected;
|
2009-02-17 20:51:22 -08:00
|
|
|
}
|
|
|
|
|
2012-07-16 14:56:30 -07:00
|
|
|
static Elm_Gen_Item *
|
2012-03-07 04:15:36 -08:00
|
|
|
_elm_genlist_expanded_next_item_get(Elm_Gen_Item *it)
|
|
|
|
{
|
|
|
|
Elm_Gen_Item *it2;
|
2012-07-16 14:56:30 -07:00
|
|
|
|
2012-03-07 04:15:36 -08:00
|
|
|
if (it->item->expanded)
|
|
|
|
{
|
2012-07-16 14:56:30 -07:00
|
|
|
it2 = (Elm_Gen_Item *)elm_genlist_item_next_get((Elm_Object_Item *)it);
|
2012-03-07 04:15:36 -08:00
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
2012-07-16 14:56:30 -07:00
|
|
|
it2 = (Elm_Gen_Item *)elm_genlist_item_next_get((Elm_Object_Item *)it);
|
2012-03-07 04:15:36 -08:00
|
|
|
while (it2)
|
|
|
|
{
|
|
|
|
if (it->item->expanded_depth >= it2->item->expanded_depth) break;
|
2012-07-16 14:56:30 -07:00
|
|
|
it2 = (Elm_Gen_Item *)
|
|
|
|
elm_genlist_item_next_get((Elm_Object_Item *)it2);
|
2012-03-07 04:15:36 -08:00
|
|
|
}
|
|
|
|
}
|
|
|
|
return it2;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
_elm_genlist_move_items_set(Elm_Gen_Item *it)
|
|
|
|
{
|
2012-04-20 07:31:51 -07:00
|
|
|
Eina_List *l, *ll;
|
2012-03-07 04:15:36 -08:00
|
|
|
Elm_Gen_Item *it2 = NULL;
|
|
|
|
Evas_Coord ox, oy, ow, oh, dh = 0;
|
2013-05-02 11:13:36 -07:00
|
|
|
ELM_GENLIST_DATA_GET_FROM_ITEM(it, sd);
|
2012-03-07 04:15:36 -08:00
|
|
|
|
2013-05-02 11:13:36 -07:00
|
|
|
sd->expanded_next_item =
|
2012-07-16 14:56:30 -07:00
|
|
|
_elm_genlist_expanded_next_item_get(it);
|
2012-03-07 04:15:36 -08:00
|
|
|
|
|
|
|
if (it->item->expanded)
|
|
|
|
{
|
2013-05-02 11:13:36 -07:00
|
|
|
sd->move_items = elm_genlist_realized_items_get((sd)->obj);
|
2012-07-16 14:56:30 -07:00
|
|
|
|
2013-05-02 11:13:36 -07:00
|
|
|
EINA_LIST_FOREACH_SAFE(sd->move_items, l, ll, it2)
|
2012-03-07 04:15:36 -08:00
|
|
|
{
|
2013-05-02 11:13:36 -07:00
|
|
|
if (it2 == sd->expanded_next_item) break;
|
|
|
|
sd->move_items = eina_list_remove(sd->move_items, it2);
|
2012-03-07 04:15:36 -08:00
|
|
|
}
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
2013-05-02 11:13:36 -07:00
|
|
|
evas_object_geometry_get(sd->pan_obj, &ox, &oy, &ow, &oh);
|
|
|
|
it2 = sd->expanded_next_item;
|
2012-07-16 14:56:30 -07:00
|
|
|
|
2012-03-07 04:15:36 -08:00
|
|
|
while (it2 && (dh < oy + oh))
|
|
|
|
{
|
|
|
|
dh += it2->item->h;
|
2013-05-02 11:13:36 -07:00
|
|
|
sd->move_items = eina_list_append(sd->move_items, it2);
|
2012-07-16 14:56:30 -07:00
|
|
|
it2 = (Elm_Gen_Item *)
|
|
|
|
elm_genlist_item_next_get((Elm_Object_Item *)it2);
|
2012-03-07 04:15:36 -08:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2014-03-08 11:46:24 -08:00
|
|
|
static void
|
|
|
|
_event_block_rect_update(const Evas_Object *obj)
|
2012-07-16 14:56:30 -07:00
|
|
|
{
|
|
|
|
Evas_Coord ox, oy, ow, oh;
|
|
|
|
|
2014-03-08 11:46:24 -08:00
|
|
|
ELM_GENLIST_CHECK(obj);
|
2012-07-16 14:56:30 -07:00
|
|
|
ELM_GENLIST_DATA_GET(obj, sd);
|
|
|
|
|
2014-03-08 11:46:24 -08:00
|
|
|
if (!sd->event_block_rect)
|
|
|
|
{
|
|
|
|
sd->event_block_rect = evas_object_rectangle_add(
|
|
|
|
evas_object_evas_get(sd->obj));
|
|
|
|
}
|
2012-07-16 14:56:30 -07:00
|
|
|
|
2014-03-08 11:46:24 -08:00
|
|
|
evas_object_geometry_get(sd->pan_obj, &ox, &oy, &ow, &oh);
|
|
|
|
evas_object_color_set(sd->event_block_rect, 0, 0, 0, 0);
|
|
|
|
evas_object_resize(sd->event_block_rect, ow, oh);
|
|
|
|
evas_object_move(sd->event_block_rect, ox, oy);
|
2012-07-16 14:56:30 -07:00
|
|
|
}
|
|
|
|
|
2009-02-10 03:57:47 -08:00
|
|
|
EAPI void
|
2012-07-16 14:56:30 -07:00
|
|
|
elm_genlist_item_expanded_set(Elm_Object_Item *item,
|
|
|
|
Eina_Bool expanded)
|
2009-02-10 03:57:47 -08:00
|
|
|
{
|
2012-07-16 14:56:30 -07:00
|
|
|
Elm_Gen_Item *it = (Elm_Gen_Item *)item;
|
|
|
|
|
|
|
|
ELM_GENLIST_ITEM_CHECK_OR_RETURN(item);
|
2013-05-02 11:13:36 -07:00
|
|
|
ELM_GENLIST_DATA_GET_FROM_ITEM(it, sd);
|
2012-07-16 14:56:30 -07:00
|
|
|
|
2012-02-27 21:26:49 -08:00
|
|
|
expanded = !!expanded;
|
2012-07-16 14:56:30 -07:00
|
|
|
if (it->item->expanded == expanded) return;
|
|
|
|
if (it->item->type != ELM_GENLIST_ITEM_TREE) return;
|
|
|
|
it->item->expanded = expanded;
|
2013-05-02 11:13:36 -07:00
|
|
|
sd->expanded_item = it;
|
2012-07-16 14:56:30 -07:00
|
|
|
_elm_genlist_move_items_set(it);
|
2012-03-07 04:15:36 -08:00
|
|
|
|
2014-03-08 11:46:24 -08:00
|
|
|
if (sd->tree_effect_enabled)
|
|
|
|
_event_block_rect_update(WIDGET(it));
|
2012-03-07 04:15:36 -08:00
|
|
|
|
2012-07-16 14:56:30 -07:00
|
|
|
if (it->item->expanded)
|
2009-03-12 22:50:38 -07:00
|
|
|
{
|
2013-05-02 11:13:36 -07:00
|
|
|
sd->move_effect_mode = ELM_GENLIST_TREE_EFFECT_EXPAND;
|
2012-07-16 14:56:30 -07:00
|
|
|
if (it->realized)
|
|
|
|
edje_object_signal_emit(VIEW(it), "elm,state,expanded", "elm");
|
|
|
|
evas_object_smart_callback_call(WIDGET(it), SIG_EXPANDED, it);
|
2013-05-02 11:13:36 -07:00
|
|
|
sd->auto_scroll_enabled = EINA_TRUE;
|
2009-03-12 22:50:38 -07:00
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
2013-05-02 11:13:36 -07:00
|
|
|
sd->move_effect_mode = ELM_GENLIST_TREE_EFFECT_CONTRACT;
|
2012-07-16 14:56:30 -07:00
|
|
|
if (it->realized)
|
|
|
|
edje_object_signal_emit(VIEW(it), "elm,state,contracted", "elm");
|
|
|
|
evas_object_smart_callback_call(WIDGET(it), SIG_CONTRACTED, it);
|
2013-05-02 11:13:36 -07:00
|
|
|
sd->auto_scroll_enabled = EINA_FALSE;
|
2009-03-12 22:50:38 -07:00
|
|
|
}
|
2009-02-10 03:57:47 -08:00
|
|
|
}
|
|
|
|
|
2009-06-17 08:35:19 -07:00
|
|
|
EAPI Eina_Bool
|
2012-01-19 21:18:31 -08:00
|
|
|
elm_genlist_item_expanded_get(const Elm_Object_Item *it)
|
2009-02-17 20:51:22 -08:00
|
|
|
{
|
2012-07-16 14:56:30 -07:00
|
|
|
ELM_GENLIST_ITEM_CHECK_OR_RETURN(it, EINA_FALSE);
|
|
|
|
|
2012-03-05 07:14:36 -08:00
|
|
|
return ((Elm_Gen_Item *)it)->item->expanded;
|
2009-02-17 20:51:22 -08:00
|
|
|
}
|
2009-07-06 23:46:51 -07:00
|
|
|
|
2010-10-06 23:45:36 -07:00
|
|
|
EAPI int
|
2012-01-19 21:18:31 -08:00
|
|
|
elm_genlist_item_expanded_depth_get(const Elm_Object_Item *it)
|
2010-10-06 23:45:36 -07:00
|
|
|
{
|
2012-07-16 14:56:30 -07:00
|
|
|
ELM_GENLIST_ITEM_CHECK_OR_RETURN(it, 0);
|
|
|
|
|
2012-03-05 07:14:36 -08:00
|
|
|
return ((Elm_Gen_Item *)it)->item->expanded_depth;
|
2010-10-06 23:45:36 -07:00
|
|
|
}
|
|
|
|
|
2012-03-08 02:58:29 -08:00
|
|
|
static Eina_Bool
|
2012-07-16 14:56:30 -07:00
|
|
|
_elm_genlist_item_coordinates_calc(Elm_Object_Item *item,
|
|
|
|
Elm_Genlist_Item_Scrollto_Type type,
|
|
|
|
Eina_Bool bring_in,
|
|
|
|
Evas_Coord *x,
|
|
|
|
Evas_Coord *y,
|
|
|
|
Evas_Coord *w,
|
|
|
|
Evas_Coord *h)
|
|
|
|
{
|
|
|
|
Elm_Gen_Item *it = (Elm_Gen_Item *)item;
|
2011-01-05 21:13:11 -08:00
|
|
|
Evas_Coord gith = 0;
|
2013-05-02 11:13:36 -07:00
|
|
|
ELM_GENLIST_DATA_GET_FROM_ITEM(it, sd);
|
2012-07-16 14:56:30 -07:00
|
|
|
|
2013-05-02 11:13:36 -07:00
|
|
|
if (it->generation < sd->generation) return EINA_FALSE;
|
2013-11-27 23:36:55 -08:00
|
|
|
if ((sd->queue) ||
|
|
|
|
(!((sd->homogeneous) &&
|
|
|
|
(sd->mode == ELM_LIST_COMPRESS))))
|
2012-05-23 21:44:44 -07:00
|
|
|
{
|
2013-11-27 23:36:55 -08:00
|
|
|
if ((it->item->queued) || (!it->item->mincalcd) || (sd->queue))
|
2012-05-23 21:44:44 -07:00
|
|
|
{
|
2013-05-02 11:13:36 -07:00
|
|
|
sd->show_item = it;
|
|
|
|
sd->bring_in = bring_in;
|
|
|
|
sd->scroll_to_type = type;
|
2012-07-16 14:56:30 -07:00
|
|
|
it->item->show_me = EINA_TRUE;
|
2012-05-23 21:44:44 -07:00
|
|
|
return EINA_FALSE;
|
|
|
|
}
|
2009-02-17 06:39:08 -08:00
|
|
|
}
|
2013-05-02 11:13:36 -07:00
|
|
|
if (sd->show_item)
|
2009-02-17 06:39:08 -08:00
|
|
|
{
|
2013-05-02 11:13:36 -07:00
|
|
|
sd->show_item->item->show_me = EINA_FALSE;
|
|
|
|
sd->show_item = NULL;
|
2009-02-17 06:39:08 -08:00
|
|
|
}
|
2012-03-07 00:29:32 -08:00
|
|
|
|
2013-05-02 11:13:36 -07:00
|
|
|
evas_object_geometry_get(sd->pan_obj, NULL, NULL, w, h);
|
2012-03-22 02:34:57 -07:00
|
|
|
switch (type)
|
2012-03-07 00:29:32 -08:00
|
|
|
{
|
2012-03-19 20:19:13 -07:00
|
|
|
case ELM_GENLIST_ITEM_SCROLLTO_IN:
|
2012-07-16 14:56:30 -07:00
|
|
|
if ((it->item->group_item) &&
|
2013-05-02 11:13:36 -07:00
|
|
|
(sd->pan_y > (it->y + it->item->block->y)))
|
2012-07-16 14:56:30 -07:00
|
|
|
gith = it->item->group_item->item->h;
|
|
|
|
*h = it->item->h;
|
|
|
|
*y = it->y + it->item->block->y - gith;
|
|
|
|
break;
|
|
|
|
|
2012-03-19 20:19:13 -07:00
|
|
|
case ELM_GENLIST_ITEM_SCROLLTO_TOP:
|
2012-07-16 14:56:30 -07:00
|
|
|
if (it->item->group_item) gith = it->item->group_item->item->h;
|
|
|
|
*y = it->y + it->item->block->y - gith;
|
|
|
|
break;
|
|
|
|
|
2012-03-19 20:19:13 -07:00
|
|
|
case ELM_GENLIST_ITEM_SCROLLTO_MIDDLE:
|
2012-07-16 14:56:30 -07:00
|
|
|
*y = it->y + it->item->block->y - (*h / 2) + (it->item->h / 2);
|
|
|
|
break;
|
|
|
|
|
2012-03-19 20:19:13 -07:00
|
|
|
default:
|
2012-07-16 14:56:30 -07:00
|
|
|
return EINA_FALSE;
|
2012-03-07 00:29:32 -08:00
|
|
|
}
|
|
|
|
|
2012-07-16 14:56:30 -07:00
|
|
|
*x = it->x + it->item->block->x;
|
|
|
|
*w = it->item->block->w;
|
|
|
|
|
2012-03-07 00:29:32 -08:00
|
|
|
return EINA_TRUE;
|
2009-02-10 03:57:47 -08:00
|
|
|
}
|
|
|
|
|
2011-11-25 12:27:27 -08:00
|
|
|
EAPI void
|
2012-07-16 14:56:30 -07:00
|
|
|
elm_genlist_item_promote(Elm_Object_Item *item)
|
2011-11-25 12:27:27 -08:00
|
|
|
{
|
2012-07-16 14:56:30 -07:00
|
|
|
Elm_Gen_Item *it = (Elm_Gen_Item *)item;
|
|
|
|
|
|
|
|
ELM_GENLIST_ITEM_CHECK_OR_RETURN(item);
|
|
|
|
|
2013-04-17 09:30:34 -07:00
|
|
|
if (it->generation < GL_IT(it)->wsd->generation) return;
|
2012-07-16 14:56:30 -07:00
|
|
|
_item_move_before
|
|
|
|
(it, (Elm_Gen_Item *)elm_genlist_first_item_get(WIDGET(it)));
|
2011-11-25 12:27:27 -08:00
|
|
|
}
|
|
|
|
|
|
|
|
EAPI void
|
2012-07-16 14:56:30 -07:00
|
|
|
elm_genlist_item_demote(Elm_Object_Item *item)
|
2011-11-25 12:27:27 -08:00
|
|
|
{
|
2012-07-16 14:56:30 -07:00
|
|
|
Elm_Gen_Item *it = (Elm_Gen_Item *)item;
|
|
|
|
|
|
|
|
ELM_GENLIST_ITEM_CHECK_OR_RETURN(item);
|
2013-04-17 09:30:34 -07:00
|
|
|
if (it->generation < GL_IT(it)->wsd->generation) return;
|
2012-07-16 14:56:30 -07:00
|
|
|
_item_move_after(it, (Elm_Gen_Item *)elm_genlist_last_item_get(WIDGET(it)));
|
2011-11-25 12:27:27 -08:00
|
|
|
}
|
|
|
|
|
2009-09-10 02:25:11 -07:00
|
|
|
EAPI void
|
2012-07-16 14:56:30 -07:00
|
|
|
elm_genlist_item_show(Elm_Object_Item *item,
|
|
|
|
Elm_Genlist_Item_Scrollto_Type type)
|
2009-09-10 02:25:11 -07:00
|
|
|
{
|
2012-03-07 00:29:28 -08:00
|
|
|
Evas_Coord x, y, w, h;
|
|
|
|
|
2012-07-16 14:56:30 -07:00
|
|
|
ELM_GENLIST_ITEM_CHECK_OR_RETURN(item);
|
|
|
|
|
|
|
|
if (_elm_genlist_item_coordinates_calc
|
|
|
|
(item, type, EINA_FALSE, &x, &y, &w, &h))
|
2014-03-17 04:44:40 -07:00
|
|
|
eo_do(WIDGET(item), elm_interface_scrollable_content_region_show
|
2012-11-25 22:32:53 -08:00
|
|
|
(x, y, w, h));
|
2009-09-10 02:25:11 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
EAPI void
|
2012-07-16 14:56:30 -07:00
|
|
|
elm_genlist_item_bring_in(Elm_Object_Item *item,
|
|
|
|
Elm_Genlist_Item_Scrollto_Type type)
|
2009-09-10 02:25:11 -07:00
|
|
|
{
|
2012-03-07 00:29:32 -08:00
|
|
|
Evas_Coord x, y, w, h;
|
2009-09-26 11:24:06 -07:00
|
|
|
|
2012-07-16 14:56:30 -07:00
|
|
|
ELM_GENLIST_ITEM_CHECK_OR_RETURN(item);
|
|
|
|
|
|
|
|
if (_elm_genlist_item_coordinates_calc
|
|
|
|
(item, type, EINA_TRUE, &x, &y, &w, &h))
|
2014-03-17 04:44:40 -07:00
|
|
|
eo_do(WIDGET(item), elm_interface_scrollable_region_bring_in(x, y, w, h));
|
2009-09-10 02:25:11 -07:00
|
|
|
}
|
|
|
|
|
2012-03-05 17:29:42 -08:00
|
|
|
EAPI void
|
2012-07-16 14:56:30 -07:00
|
|
|
elm_genlist_item_all_contents_unset(Elm_Object_Item *it,
|
|
|
|
Eina_List **l)
|
2011-10-23 19:10:35 -07:00
|
|
|
{
|
|
|
|
Evas_Object *content;
|
2012-07-16 14:56:30 -07:00
|
|
|
|
|
|
|
ELM_GENLIST_ITEM_CHECK_OR_RETURN(it);
|
|
|
|
|
2013-03-08 20:23:42 -08:00
|
|
|
EINA_LIST_FREE(((Elm_Gen_Item *)it)->content_objs, content)
|
2010-11-06 00:05:00 -07:00
|
|
|
{
|
2011-10-23 19:10:35 -07:00
|
|
|
elm_widget_sub_object_del(WIDGET(it), content);
|
|
|
|
evas_object_smart_member_del(content);
|
|
|
|
evas_object_hide(content);
|
2012-03-22 02:34:57 -07:00
|
|
|
if (l) *l = eina_list_append(*l, content);
|
2010-11-06 00:05:00 -07:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2009-02-14 18:53:56 -08:00
|
|
|
EAPI void
|
2012-07-16 14:56:30 -07:00
|
|
|
elm_genlist_item_update(Elm_Object_Item *item)
|
2009-02-14 18:53:56 -08:00
|
|
|
{
|
2012-07-16 14:56:30 -07:00
|
|
|
Elm_Gen_Item *it = (Elm_Gen_Item *)item;
|
2012-01-19 21:18:31 -08:00
|
|
|
|
2012-07-16 14:56:30 -07:00
|
|
|
ELM_GENLIST_ITEM_CHECK_OR_RETURN(item);
|
2013-05-02 11:13:36 -07:00
|
|
|
ELM_GENLIST_DATA_GET_FROM_ITEM(it, sd);
|
2012-07-16 14:56:30 -07:00
|
|
|
|
|
|
|
if (!it->item->block) return;
|
2013-05-02 11:13:36 -07:00
|
|
|
if (it->generation < sd->generation) return;
|
2012-07-16 14:56:30 -07:00
|
|
|
it->item->mincalcd = EINA_FALSE;
|
|
|
|
it->item->updateme = EINA_TRUE;
|
|
|
|
it->item->block->updateme = EINA_TRUE;
|
2014-01-21 06:16:41 -08:00
|
|
|
ecore_job_del(sd->update_job);
|
2013-05-02 11:13:36 -07:00
|
|
|
sd->update_job = ecore_job_add(_update_job, sd->obj);
|
2009-03-12 22:50:38 -07:00
|
|
|
}
|
|
|
|
|
2011-11-29 06:03:14 -08:00
|
|
|
EAPI void
|
2012-07-16 14:56:30 -07:00
|
|
|
elm_genlist_item_fields_update(Elm_Object_Item *item,
|
|
|
|
const char *parts,
|
2012-03-05 16:49:28 -08:00
|
|
|
Elm_Genlist_Item_Field_Type itf)
|
2011-11-29 06:03:14 -08:00
|
|
|
{
|
2012-07-16 14:56:30 -07:00
|
|
|
Elm_Gen_Item *it = (Elm_Gen_Item *)item;
|
|
|
|
|
|
|
|
ELM_GENLIST_ITEM_CHECK_OR_RETURN(item);
|
2012-01-19 21:18:31 -08:00
|
|
|
|
2012-07-16 14:56:30 -07:00
|
|
|
if (!it->item->block) return;
|
2013-04-17 09:30:34 -07:00
|
|
|
if (it->generation < GL_IT(it)->wsd->generation) return;
|
2011-11-29 06:03:14 -08:00
|
|
|
|
2012-02-28 22:52:05 -08:00
|
|
|
if ((!itf) || (itf & ELM_GENLIST_ITEM_FIELD_TEXT))
|
2012-06-18 02:54:00 -07:00
|
|
|
{
|
2012-07-16 14:56:30 -07:00
|
|
|
_item_text_realize(it, VIEW(it), &it->texts, parts);
|
2012-06-18 02:54:00 -07:00
|
|
|
}
|
2011-11-29 06:03:14 -08:00
|
|
|
if ((!itf) || (itf & ELM_GENLIST_ITEM_FIELD_CONTENT))
|
|
|
|
{
|
2012-07-16 14:56:30 -07:00
|
|
|
it->content_objs = _item_content_unrealize(it, VIEW(it),
|
|
|
|
&it->contents, parts);
|
|
|
|
it->content_objs = _item_content_realize(it, VIEW(it),
|
|
|
|
&it->contents, parts);
|
2013-12-16 10:34:59 -08:00
|
|
|
if (it->has_contents != (!!it->content_objs))
|
|
|
|
it->item->mincalcd = EINA_FALSE;
|
|
|
|
it->has_contents = !!it->content_objs;
|
2013-02-20 02:00:49 -08:00
|
|
|
if (it->item->type == ELM_GENLIST_ITEM_NONE)
|
|
|
|
{
|
|
|
|
Evas_Object* eobj;
|
|
|
|
Eina_List* l;
|
2014-01-21 17:47:33 -08:00
|
|
|
it->item_focus_chain = eina_list_free(it->item_focus_chain);
|
2013-02-20 02:00:49 -08:00
|
|
|
EINA_LIST_FOREACH(it->content_objs, l, eobj)
|
|
|
|
if (elm_object_focus_allow_get(eobj))
|
|
|
|
it->item_focus_chain = eina_list_append(it->item_focus_chain, eobj);
|
|
|
|
}
|
|
|
|
|
2012-07-16 14:56:30 -07:00
|
|
|
if (it->flipped)
|
|
|
|
{
|
|
|
|
it->item->flip_content_objs =
|
|
|
|
_item_mode_content_unrealize(it, VIEW(it),
|
|
|
|
&it->item->flip_contents, parts,
|
|
|
|
&it->item->flip_content_objs);
|
|
|
|
it->item->flip_content_objs =
|
|
|
|
_item_mode_content_realize(it, VIEW(it),
|
|
|
|
&it->item->flip_contents, parts,
|
|
|
|
&it->item->flip_content_objs);
|
|
|
|
}
|
|
|
|
if (it->item->deco_it_view)
|
|
|
|
{
|
|
|
|
it->item->deco_it_content_objs =
|
|
|
|
_item_mode_content_unrealize(it, it->item->deco_it_view,
|
|
|
|
&it->item->deco_it_contents, parts,
|
|
|
|
&it->item->deco_it_content_objs);
|
|
|
|
it->item->deco_it_content_objs =
|
|
|
|
_item_mode_content_realize(it, it->item->deco_it_view,
|
|
|
|
&it->item->deco_it_contents, parts,
|
|
|
|
&it->item->deco_it_content_objs);
|
|
|
|
}
|
|
|
|
if (GL_IT(it)->wsd->decorate_all_mode)
|
|
|
|
{
|
|
|
|
it->item->deco_all_content_objs =
|
|
|
|
_item_mode_content_unrealize
|
|
|
|
(it, it->deco_all_view, &it->item->deco_all_contents, parts,
|
|
|
|
&it->item->deco_all_content_objs);
|
|
|
|
it->item->deco_all_content_objs =
|
|
|
|
_item_mode_content_realize(it, it->deco_all_view,
|
|
|
|
&it->item->deco_all_contents, parts,
|
|
|
|
&it->item->deco_all_content_objs);
|
2012-04-06 00:10:20 -07:00
|
|
|
}
|
2011-11-29 06:03:14 -08:00
|
|
|
}
|
2012-07-16 14:56:30 -07:00
|
|
|
|
2011-11-29 06:03:14 -08:00
|
|
|
if ((!itf) || (itf & ELM_GENLIST_ITEM_FIELD_STATE))
|
2012-07-16 14:56:30 -07:00
|
|
|
_item_state_realize(it, VIEW(it), &it->states, parts);
|
2013-12-16 10:34:59 -08:00
|
|
|
if (!it->item->mincalcd)
|
|
|
|
elm_genlist_item_update(item);
|
2011-11-29 06:03:14 -08:00
|
|
|
}
|
|
|
|
|
2010-11-17 09:15:28 -08:00
|
|
|
EAPI void
|
2012-07-16 14:56:30 -07:00
|
|
|
elm_genlist_item_item_class_update(Elm_Object_Item *item,
|
2010-12-07 11:18:14 -08:00
|
|
|
const Elm_Genlist_Item_Class *itc)
|
2010-11-17 09:15:28 -08:00
|
|
|
{
|
2012-07-16 14:56:30 -07:00
|
|
|
Elm_Gen_Item *it = (Elm_Gen_Item *)item;
|
2012-01-19 21:18:31 -08:00
|
|
|
|
2012-07-16 14:56:30 -07:00
|
|
|
ELM_GENLIST_ITEM_CHECK_OR_RETURN(item);
|
|
|
|
|
|
|
|
if (!it->item->block) return;
|
2010-12-03 06:08:33 -08:00
|
|
|
EINA_SAFETY_ON_NULL_RETURN(itc);
|
2013-04-17 09:30:34 -07:00
|
|
|
if (it->generation < GL_IT(it)->wsd->generation) return;
|
2012-07-16 14:56:30 -07:00
|
|
|
it->itc = itc;
|
|
|
|
it->item->nocache_once = EINA_TRUE;
|
2012-04-06 00:10:29 -07:00
|
|
|
|
2013-09-05 21:00:42 -07:00
|
|
|
ELM_SAFE_FREE(it->texts, elm_widget_stringlist_free);
|
|
|
|
ELM_SAFE_FREE(it->contents, elm_widget_stringlist_free);
|
|
|
|
ELM_SAFE_FREE(it->states, elm_widget_stringlist_free);
|
2012-04-06 00:10:29 -07:00
|
|
|
|
2012-07-16 14:56:30 -07:00
|
|
|
if (it->flipped)
|
2012-04-06 00:10:29 -07:00
|
|
|
{
|
2012-07-16 14:56:30 -07:00
|
|
|
elm_widget_stringlist_free(it->item->flip_contents);
|
|
|
|
it->item->flip_contents = NULL;
|
2012-04-06 00:10:29 -07:00
|
|
|
}
|
2012-07-16 14:56:30 -07:00
|
|
|
if (it->item->deco_it_view)
|
2012-04-06 00:10:29 -07:00
|
|
|
{
|
2012-07-16 14:56:30 -07:00
|
|
|
elm_widget_stringlist_free(it->item->deco_it_texts);
|
|
|
|
it->item->deco_it_texts = NULL;
|
|
|
|
elm_widget_stringlist_free(it->item->deco_it_contents);
|
|
|
|
it->item->deco_it_contents = NULL;
|
2012-04-06 00:10:29 -07:00
|
|
|
}
|
2012-07-16 14:56:30 -07:00
|
|
|
if (GL_IT(it)->wsd->decorate_all_mode)
|
2012-04-06 00:10:29 -07:00
|
|
|
{
|
2012-07-16 14:56:30 -07:00
|
|
|
elm_widget_stringlist_free(it->item->deco_all_texts);
|
|
|
|
it->item->deco_all_texts = NULL;
|
|
|
|
elm_widget_stringlist_free(it->item->deco_all_contents);
|
|
|
|
it->item->deco_all_contents = NULL;
|
2012-04-06 00:10:29 -07:00
|
|
|
}
|
|
|
|
|
2012-07-16 14:56:30 -07:00
|
|
|
elm_genlist_item_update(item);
|
2010-11-17 09:15:28 -08:00
|
|
|
}
|
|
|
|
|
2011-06-25 16:20:22 -07:00
|
|
|
EAPI const Elm_Genlist_Item_Class *
|
2012-07-16 14:56:30 -07:00
|
|
|
elm_genlist_item_item_class_get(const Elm_Object_Item *item)
|
2011-06-25 16:20:22 -07:00
|
|
|
{
|
2012-07-16 14:56:30 -07:00
|
|
|
Elm_Gen_Item *it = (Elm_Gen_Item *)item;
|
|
|
|
|
|
|
|
ELM_GENLIST_ITEM_CHECK_OR_RETURN(item, NULL);
|
2013-04-17 09:30:34 -07:00
|
|
|
if (it->generation < GL_IT(it)->wsd->generation) return NULL;
|
2012-07-16 14:56:30 -07:00
|
|
|
|
|
|
|
return it->itc;
|
2011-06-25 16:20:22 -07:00
|
|
|
}
|
|
|
|
|
2010-09-27 11:18:37 -07:00
|
|
|
static Evas_Object *
|
2012-07-16 14:56:30 -07:00
|
|
|
_elm_genlist_item_label_create(void *data,
|
2014-01-06 06:30:02 -08:00
|
|
|
Evas_Object *obj EINA_UNUSED,
|
2011-07-26 02:38:23 -07:00
|
|
|
Evas_Object *tooltip,
|
2014-01-06 06:30:02 -08:00
|
|
|
void *it EINA_UNUSED)
|
2010-09-27 11:18:37 -07:00
|
|
|
{
|
2011-07-26 02:38:23 -07:00
|
|
|
Evas_Object *label = elm_label_add(tooltip);
|
2012-07-16 14:56:30 -07:00
|
|
|
|
2010-09-27 11:18:37 -07:00
|
|
|
if (!label)
|
|
|
|
return NULL;
|
2012-07-16 14:56:30 -07:00
|
|
|
|
2010-09-27 11:18:37 -07:00
|
|
|
elm_object_style_set(label, "tooltip");
|
2011-06-28 23:41:31 -07:00
|
|
|
elm_object_text_set(label, data);
|
2012-07-16 14:56:30 -07:00
|
|
|
|
2010-09-27 11:18:37 -07:00
|
|
|
return label;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
2012-07-16 14:56:30 -07:00
|
|
|
_elm_genlist_item_label_del_cb(void *data,
|
2014-01-06 06:30:02 -08:00
|
|
|
Evas_Object *obj EINA_UNUSED,
|
|
|
|
void *event_info EINA_UNUSED)
|
2010-09-27 11:18:37 -07:00
|
|
|
{
|
|
|
|
eina_stringshare_del(data);
|
|
|
|
}
|
|
|
|
|
Tooltips: split owner/eventarea, allow subitems to have indepentent tooltips.
Now owner widget (elm_widget) is just used to listen for theme changes
and create/destroy the tooltip data. The actual mouse events operates
on all Evas_Object and is the one where tooltip data is actually
stored.
The public API is basically the same, just the event_info is now NULL
to avoid confusion.
The internal API introduces elm_object_sub_tooltip_content_cb_set()
and as the first parameter the eventarea. While this may be confusing,
as the second parameter is the actual elementary object, it is the one
that all other calls receive, like elm_object_tooltip_hide() or
elm_object_tooltip_unset(), thus it does make sense to have such order.
Also internal API, elm_widget_item_tooltip_* functions were
added. They are a variation of the widget API to handle its items, as
such the func() gets one more parameter: item, and the del_cb() gets
the item as event_info (that's why the public widget version got
event_info always NULL, to not confuse with this one!)
Widgets with items that makes sense to have tooltips got extra API:
* toolbar
* list
* gengrid
* genlist
SVN revision: 52173
2010-09-12 14:05:13 -07:00
|
|
|
EAPI void
|
2012-01-19 21:18:31 -08:00
|
|
|
elm_genlist_item_tooltip_text_set(Elm_Object_Item *it,
|
2012-07-16 14:56:30 -07:00
|
|
|
const char *text)
|
Tooltips: split owner/eventarea, allow subitems to have indepentent tooltips.
Now owner widget (elm_widget) is just used to listen for theme changes
and create/destroy the tooltip data. The actual mouse events operates
on all Evas_Object and is the one where tooltip data is actually
stored.
The public API is basically the same, just the event_info is now NULL
to avoid confusion.
The internal API introduces elm_object_sub_tooltip_content_cb_set()
and as the first parameter the eventarea. While this may be confusing,
as the second parameter is the actual elementary object, it is the one
that all other calls receive, like elm_object_tooltip_hide() or
elm_object_tooltip_unset(), thus it does make sense to have such order.
Also internal API, elm_widget_item_tooltip_* functions were
added. They are a variation of the widget API to handle its items, as
such the func() gets one more parameter: item, and the del_cb() gets
the item as event_info (that's why the public widget version got
event_info always NULL, to not confuse with this one!)
Widgets with items that makes sense to have tooltips got extra API:
* toolbar
* list
* gengrid
* genlist
SVN revision: 52173
2010-09-12 14:05:13 -07:00
|
|
|
{
|
2012-07-16 14:56:30 -07:00
|
|
|
ELM_GENLIST_ITEM_CHECK_OR_RETURN(it);
|
|
|
|
|
2010-09-27 11:18:37 -07:00
|
|
|
text = eina_stringshare_add(text);
|
2012-07-16 14:56:30 -07:00
|
|
|
elm_genlist_item_tooltip_content_cb_set
|
|
|
|
(it, _elm_genlist_item_label_create, text,
|
|
|
|
_elm_genlist_item_label_del_cb);
|
Tooltips: split owner/eventarea, allow subitems to have indepentent tooltips.
Now owner widget (elm_widget) is just used to listen for theme changes
and create/destroy the tooltip data. The actual mouse events operates
on all Evas_Object and is the one where tooltip data is actually
stored.
The public API is basically the same, just the event_info is now NULL
to avoid confusion.
The internal API introduces elm_object_sub_tooltip_content_cb_set()
and as the first parameter the eventarea. While this may be confusing,
as the second parameter is the actual elementary object, it is the one
that all other calls receive, like elm_object_tooltip_hide() or
elm_object_tooltip_unset(), thus it does make sense to have such order.
Also internal API, elm_widget_item_tooltip_* functions were
added. They are a variation of the widget API to handle its items, as
such the func() gets one more parameter: item, and the del_cb() gets
the item as event_info (that's why the public widget version got
event_info always NULL, to not confuse with this one!)
Widgets with items that makes sense to have tooltips got extra API:
* toolbar
* list
* gengrid
* genlist
SVN revision: 52173
2010-09-12 14:05:13 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
EAPI void
|
2012-07-16 14:56:30 -07:00
|
|
|
elm_genlist_item_tooltip_content_cb_set(Elm_Object_Item *item,
|
2010-12-07 11:18:14 -08:00
|
|
|
Elm_Tooltip_Item_Content_Cb func,
|
2012-07-16 14:56:30 -07:00
|
|
|
const void *data,
|
|
|
|
Evas_Smart_Cb del_cb)
|
Tooltips: split owner/eventarea, allow subitems to have indepentent tooltips.
Now owner widget (elm_widget) is just used to listen for theme changes
and create/destroy the tooltip data. The actual mouse events operates
on all Evas_Object and is the one where tooltip data is actually
stored.
The public API is basically the same, just the event_info is now NULL
to avoid confusion.
The internal API introduces elm_object_sub_tooltip_content_cb_set()
and as the first parameter the eventarea. While this may be confusing,
as the second parameter is the actual elementary object, it is the one
that all other calls receive, like elm_object_tooltip_hide() or
elm_object_tooltip_unset(), thus it does make sense to have such order.
Also internal API, elm_widget_item_tooltip_* functions were
added. They are a variation of the widget API to handle its items, as
such the func() gets one more parameter: item, and the del_cb() gets
the item as event_info (that's why the public widget version got
event_info always NULL, to not confuse with this one!)
Widgets with items that makes sense to have tooltips got extra API:
* toolbar
* list
* gengrid
* genlist
SVN revision: 52173
2010-09-12 14:05:13 -07:00
|
|
|
{
|
2012-07-16 14:56:30 -07:00
|
|
|
Elm_Gen_Item *it = (Elm_Gen_Item *)item;
|
|
|
|
|
|
|
|
ELM_GENLIST_ITEM_CHECK_OR_GOTO(item, error);
|
2010-09-27 11:18:37 -07:00
|
|
|
|
2012-07-16 14:56:30 -07:00
|
|
|
if ((it->tooltip.content_cb == func) && (it->tooltip.data == data))
|
2010-09-27 11:18:37 -07:00
|
|
|
return;
|
|
|
|
|
2012-07-16 14:56:30 -07:00
|
|
|
if (it->tooltip.del_cb)
|
|
|
|
it->tooltip.del_cb((void *)it->tooltip.data, WIDGET(it), it);
|
2010-09-27 11:18:37 -07:00
|
|
|
|
2012-07-16 14:56:30 -07:00
|
|
|
it->tooltip.content_cb = func;
|
|
|
|
it->tooltip.data = data;
|
|
|
|
it->tooltip.del_cb = del_cb;
|
2010-09-27 11:18:37 -07:00
|
|
|
|
2012-07-16 14:56:30 -07:00
|
|
|
if (VIEW(it))
|
2010-09-27 11:18:37 -07:00
|
|
|
{
|
2012-07-16 14:56:30 -07:00
|
|
|
elm_widget_item_tooltip_content_cb_set
|
|
|
|
(it, it->tooltip.content_cb, it->tooltip.data, NULL);
|
|
|
|
elm_widget_item_tooltip_style_set(it, it->tooltip.style);
|
|
|
|
elm_widget_item_tooltip_window_mode_set(it, it->tooltip.free_size);
|
2010-09-27 11:18:37 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
return;
|
|
|
|
|
2010-12-07 11:18:14 -08:00
|
|
|
error:
|
2010-09-27 11:18:37 -07:00
|
|
|
if (del_cb) del_cb((void *)data, NULL, NULL);
|
Tooltips: split owner/eventarea, allow subitems to have indepentent tooltips.
Now owner widget (elm_widget) is just used to listen for theme changes
and create/destroy the tooltip data. The actual mouse events operates
on all Evas_Object and is the one where tooltip data is actually
stored.
The public API is basically the same, just the event_info is now NULL
to avoid confusion.
The internal API introduces elm_object_sub_tooltip_content_cb_set()
and as the first parameter the eventarea. While this may be confusing,
as the second parameter is the actual elementary object, it is the one
that all other calls receive, like elm_object_tooltip_hide() or
elm_object_tooltip_unset(), thus it does make sense to have such order.
Also internal API, elm_widget_item_tooltip_* functions were
added. They are a variation of the widget API to handle its items, as
such the func() gets one more parameter: item, and the del_cb() gets
the item as event_info (that's why the public widget version got
event_info always NULL, to not confuse with this one!)
Widgets with items that makes sense to have tooltips got extra API:
* toolbar
* list
* gengrid
* genlist
SVN revision: 52173
2010-09-12 14:05:13 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
EAPI void
|
2012-07-16 14:56:30 -07:00
|
|
|
elm_genlist_item_tooltip_unset(Elm_Object_Item *item)
|
2012-01-19 21:18:31 -08:00
|
|
|
{
|
2012-07-16 14:56:30 -07:00
|
|
|
Elm_Gen_Item *it = (Elm_Gen_Item *)item;
|
2012-01-19 21:18:31 -08:00
|
|
|
|
2012-07-16 14:56:30 -07:00
|
|
|
ELM_GENLIST_ITEM_CHECK_OR_RETURN(item);
|
2012-01-19 21:18:31 -08:00
|
|
|
|
2012-07-16 14:56:30 -07:00
|
|
|
if ((VIEW(it)) && (it->tooltip.content_cb))
|
|
|
|
elm_widget_item_tooltip_unset(it);
|
|
|
|
|
|
|
|
if (it->tooltip.del_cb)
|
|
|
|
it->tooltip.del_cb((void *)it->tooltip.data, WIDGET(it), it);
|
|
|
|
it->tooltip.del_cb = NULL;
|
|
|
|
it->tooltip.content_cb = NULL;
|
|
|
|
it->tooltip.data = NULL;
|
|
|
|
it->tooltip.free_size = EINA_FALSE;
|
|
|
|
if (it->tooltip.style)
|
|
|
|
elm_genlist_item_tooltip_style_set(item, NULL);
|
Tooltips: split owner/eventarea, allow subitems to have indepentent tooltips.
Now owner widget (elm_widget) is just used to listen for theme changes
and create/destroy the tooltip data. The actual mouse events operates
on all Evas_Object and is the one where tooltip data is actually
stored.
The public API is basically the same, just the event_info is now NULL
to avoid confusion.
The internal API introduces elm_object_sub_tooltip_content_cb_set()
and as the first parameter the eventarea. While this may be confusing,
as the second parameter is the actual elementary object, it is the one
that all other calls receive, like elm_object_tooltip_hide() or
elm_object_tooltip_unset(), thus it does make sense to have such order.
Also internal API, elm_widget_item_tooltip_* functions were
added. They are a variation of the widget API to handle its items, as
such the func() gets one more parameter: item, and the del_cb() gets
the item as event_info (that's why the public widget version got
event_info always NULL, to not confuse with this one!)
Widgets with items that makes sense to have tooltips got extra API:
* toolbar
* list
* gengrid
* genlist
SVN revision: 52173
2010-09-12 14:05:13 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
EAPI void
|
2012-07-16 14:56:30 -07:00
|
|
|
elm_genlist_item_tooltip_style_set(Elm_Object_Item *item,
|
|
|
|
const char *style)
|
Tooltips: split owner/eventarea, allow subitems to have indepentent tooltips.
Now owner widget (elm_widget) is just used to listen for theme changes
and create/destroy the tooltip data. The actual mouse events operates
on all Evas_Object and is the one where tooltip data is actually
stored.
The public API is basically the same, just the event_info is now NULL
to avoid confusion.
The internal API introduces elm_object_sub_tooltip_content_cb_set()
and as the first parameter the eventarea. While this may be confusing,
as the second parameter is the actual elementary object, it is the one
that all other calls receive, like elm_object_tooltip_hide() or
elm_object_tooltip_unset(), thus it does make sense to have such order.
Also internal API, elm_widget_item_tooltip_* functions were
added. They are a variation of the widget API to handle its items, as
such the func() gets one more parameter: item, and the del_cb() gets
the item as event_info (that's why the public widget version got
event_info always NULL, to not confuse with this one!)
Widgets with items that makes sense to have tooltips got extra API:
* toolbar
* list
* gengrid
* genlist
SVN revision: 52173
2010-09-12 14:05:13 -07:00
|
|
|
{
|
2012-07-16 14:56:30 -07:00
|
|
|
Elm_Gen_Item *it = (Elm_Gen_Item *)item;
|
|
|
|
|
|
|
|
ELM_GENLIST_ITEM_CHECK_OR_RETURN(item);
|
2012-01-19 21:18:31 -08:00
|
|
|
|
2012-07-16 14:56:30 -07:00
|
|
|
eina_stringshare_replace(&it->tooltip.style, style);
|
|
|
|
if (VIEW(it)) elm_widget_item_tooltip_style_set(it, style);
|
Tooltips: split owner/eventarea, allow subitems to have indepentent tooltips.
Now owner widget (elm_widget) is just used to listen for theme changes
and create/destroy the tooltip data. The actual mouse events operates
on all Evas_Object and is the one where tooltip data is actually
stored.
The public API is basically the same, just the event_info is now NULL
to avoid confusion.
The internal API introduces elm_object_sub_tooltip_content_cb_set()
and as the first parameter the eventarea. While this may be confusing,
as the second parameter is the actual elementary object, it is the one
that all other calls receive, like elm_object_tooltip_hide() or
elm_object_tooltip_unset(), thus it does make sense to have such order.
Also internal API, elm_widget_item_tooltip_* functions were
added. They are a variation of the widget API to handle its items, as
such the func() gets one more parameter: item, and the del_cb() gets
the item as event_info (that's why the public widget version got
event_info always NULL, to not confuse with this one!)
Widgets with items that makes sense to have tooltips got extra API:
* toolbar
* list
* gengrid
* genlist
SVN revision: 52173
2010-09-12 14:05:13 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
EAPI const char *
|
2012-01-19 21:18:31 -08:00
|
|
|
elm_genlist_item_tooltip_style_get(const Elm_Object_Item *it)
|
Tooltips: split owner/eventarea, allow subitems to have indepentent tooltips.
Now owner widget (elm_widget) is just used to listen for theme changes
and create/destroy the tooltip data. The actual mouse events operates
on all Evas_Object and is the one where tooltip data is actually
stored.
The public API is basically the same, just the event_info is now NULL
to avoid confusion.
The internal API introduces elm_object_sub_tooltip_content_cb_set()
and as the first parameter the eventarea. While this may be confusing,
as the second parameter is the actual elementary object, it is the one
that all other calls receive, like elm_object_tooltip_hide() or
elm_object_tooltip_unset(), thus it does make sense to have such order.
Also internal API, elm_widget_item_tooltip_* functions were
added. They are a variation of the widget API to handle its items, as
such the func() gets one more parameter: item, and the del_cb() gets
the item as event_info (that's why the public widget version got
event_info always NULL, to not confuse with this one!)
Widgets with items that makes sense to have tooltips got extra API:
* toolbar
* list
* gengrid
* genlist
SVN revision: 52173
2010-09-12 14:05:13 -07:00
|
|
|
{
|
2012-01-19 21:18:31 -08:00
|
|
|
return elm_object_item_tooltip_style_get(it);
|
Tooltips: split owner/eventarea, allow subitems to have indepentent tooltips.
Now owner widget (elm_widget) is just used to listen for theme changes
and create/destroy the tooltip data. The actual mouse events operates
on all Evas_Object and is the one where tooltip data is actually
stored.
The public API is basically the same, just the event_info is now NULL
to avoid confusion.
The internal API introduces elm_object_sub_tooltip_content_cb_set()
and as the first parameter the eventarea. While this may be confusing,
as the second parameter is the actual elementary object, it is the one
that all other calls receive, like elm_object_tooltip_hide() or
elm_object_tooltip_unset(), thus it does make sense to have such order.
Also internal API, elm_widget_item_tooltip_* functions were
added. They are a variation of the widget API to handle its items, as
such the func() gets one more parameter: item, and the del_cb() gets
the item as event_info (that's why the public widget version got
event_info always NULL, to not confuse with this one!)
Widgets with items that makes sense to have tooltips got extra API:
* toolbar
* list
* gengrid
* genlist
SVN revision: 52173
2010-09-12 14:05:13 -07:00
|
|
|
}
|
|
|
|
|
2011-07-26 02:38:23 -07:00
|
|
|
EAPI Eina_Bool
|
2012-07-16 14:56:30 -07:00
|
|
|
elm_genlist_item_tooltip_window_mode_set(Elm_Object_Item *item,
|
|
|
|
Eina_Bool disable)
|
2011-07-26 02:38:23 -07:00
|
|
|
{
|
2012-07-16 14:56:30 -07:00
|
|
|
Elm_Gen_Item *it = (Elm_Gen_Item *)item;
|
|
|
|
|
|
|
|
ELM_GENLIST_ITEM_CHECK_OR_RETURN(item, EINA_FALSE);
|
|
|
|
|
|
|
|
it->tooltip.free_size = disable;
|
|
|
|
if (VIEW(it)) return elm_widget_item_tooltip_window_mode_set(it, disable);
|
2012-01-19 21:18:31 -08:00
|
|
|
|
2011-07-27 19:22:37 -07:00
|
|
|
return EINA_TRUE;
|
2011-07-26 02:38:23 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
EAPI Eina_Bool
|
2012-01-19 21:18:31 -08:00
|
|
|
elm_genlist_item_tooltip_window_mode_get(const Elm_Object_Item *it)
|
2011-07-26 02:38:23 -07:00
|
|
|
{
|
2012-01-19 21:18:31 -08:00
|
|
|
return elm_object_tooltip_window_mode_get(VIEW(it));
|
2011-07-26 02:38:23 -07:00
|
|
|
}
|
|
|
|
|
2010-09-17 11:24:10 -07:00
|
|
|
EAPI void
|
2012-07-16 14:56:30 -07:00
|
|
|
elm_genlist_item_cursor_set(Elm_Object_Item *item,
|
|
|
|
const char *cursor)
|
2010-09-17 11:24:10 -07:00
|
|
|
{
|
2012-07-16 14:56:30 -07:00
|
|
|
Elm_Gen_Item *it = (Elm_Gen_Item *)item;
|
|
|
|
|
|
|
|
ELM_GENLIST_ITEM_CHECK_OR_RETURN(item);
|
|
|
|
eina_stringshare_replace(&it->mouse_cursor, cursor);
|
|
|
|
if (VIEW(it)) elm_widget_item_cursor_set(it, cursor);
|
2010-09-17 11:24:10 -07:00
|
|
|
}
|
|
|
|
|
2010-11-04 17:46:54 -07:00
|
|
|
EAPI const char *
|
2012-01-19 21:18:31 -08:00
|
|
|
elm_genlist_item_cursor_get(const Elm_Object_Item *it)
|
2010-11-04 17:46:54 -07:00
|
|
|
{
|
2011-10-20 14:41:24 -07:00
|
|
|
return elm_widget_item_cursor_get(it);
|
2010-11-04 17:46:54 -07:00
|
|
|
}
|
|
|
|
|
2010-09-17 11:24:10 -07:00
|
|
|
EAPI void
|
2012-07-16 14:56:30 -07:00
|
|
|
elm_genlist_item_cursor_unset(Elm_Object_Item *item)
|
2010-09-17 11:24:10 -07:00
|
|
|
{
|
2012-07-16 14:56:30 -07:00
|
|
|
Elm_Gen_Item *it = (Elm_Gen_Item *)item;
|
|
|
|
|
|
|
|
ELM_GENLIST_ITEM_CHECK_OR_RETURN(item);
|
2012-01-19 21:18:31 -08:00
|
|
|
|
2012-07-16 14:56:30 -07:00
|
|
|
if (!it->mouse_cursor) return;
|
2010-09-27 11:18:37 -07:00
|
|
|
|
2012-07-16 14:56:30 -07:00
|
|
|
if (VIEW(it)) elm_widget_item_cursor_unset(it);
|
2010-09-27 11:18:37 -07:00
|
|
|
|
2013-09-05 21:00:42 -07:00
|
|
|
ELM_SAFE_FREE(it->mouse_cursor, eina_stringshare_del);
|
2010-09-17 11:24:10 -07:00
|
|
|
}
|
|
|
|
|
2010-09-25 15:01:19 -07:00
|
|
|
EAPI void
|
2012-04-25 06:31:37 -07:00
|
|
|
elm_genlist_item_cursor_style_set(Elm_Object_Item *it,
|
2012-07-16 14:56:30 -07:00
|
|
|
const char *style)
|
2010-09-25 15:01:19 -07:00
|
|
|
{
|
2011-10-20 14:41:24 -07:00
|
|
|
elm_widget_item_cursor_style_set(it, style);
|
2010-09-25 15:01:19 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
EAPI const char *
|
2012-01-19 21:18:31 -08:00
|
|
|
elm_genlist_item_cursor_style_get(const Elm_Object_Item *it)
|
2010-09-25 15:01:19 -07:00
|
|
|
{
|
2011-10-20 14:41:24 -07:00
|
|
|
return elm_widget_item_cursor_style_get(it);
|
2010-09-25 15:01:19 -07:00
|
|
|
}
|
|
|
|
|
2010-09-25 15:03:37 -07:00
|
|
|
EAPI void
|
2012-01-19 21:18:31 -08:00
|
|
|
elm_genlist_item_cursor_engine_only_set(Elm_Object_Item *it,
|
2012-07-16 14:56:30 -07:00
|
|
|
Eina_Bool engine_only)
|
2010-09-25 15:03:37 -07:00
|
|
|
{
|
2011-10-20 14:41:24 -07:00
|
|
|
elm_widget_item_cursor_engine_only_set(it, engine_only);
|
2010-09-25 15:03:37 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
EAPI Eina_Bool
|
2012-01-19 21:18:31 -08:00
|
|
|
elm_genlist_item_cursor_engine_only_get(const Elm_Object_Item *it)
|
2010-09-25 15:03:37 -07:00
|
|
|
{
|
2011-10-20 14:41:24 -07:00
|
|
|
return elm_widget_item_cursor_engine_only_get(it);
|
2010-09-25 15:03:37 -07:00
|
|
|
}
|
|
|
|
|
2011-12-26 06:30:21 -08:00
|
|
|
EAPI int
|
2012-07-16 14:56:30 -07:00
|
|
|
elm_genlist_item_index_get(const Elm_Object_Item *item)
|
2011-12-26 06:30:21 -08:00
|
|
|
{
|
2012-07-16 14:56:30 -07:00
|
|
|
Elm_Gen_Item *it = (Elm_Gen_Item *)item;
|
2012-01-19 21:18:31 -08:00
|
|
|
|
2012-07-16 14:56:30 -07:00
|
|
|
ELM_GENLIST_ITEM_CHECK_OR_RETURN(item, -1);
|
|
|
|
|
|
|
|
if (it->item->block)
|
|
|
|
return it->position + (it->item->block->position *
|
|
|
|
GL_IT(it)->wsd->max_items_per_block);
|
2011-12-26 06:30:21 -08:00
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
2009-03-12 22:50:38 -07:00
|
|
|
EAPI void
|
2012-07-16 14:56:30 -07:00
|
|
|
elm_genlist_mode_set(Evas_Object *obj,
|
2012-02-24 00:53:01 -08:00
|
|
|
Elm_List_Mode mode)
|
2009-03-12 22:50:38 -07:00
|
|
|
{
|
2012-07-16 14:56:30 -07:00
|
|
|
ELM_GENLIST_CHECK(obj);
|
2012-11-25 22:32:53 -08:00
|
|
|
eo_do(obj, elm_obj_genlist_mode_set(mode));
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
_mode_set(Eo *obj, void *_pd, va_list *list)
|
|
|
|
{
|
|
|
|
Elm_List_Mode mode = va_arg(*list, Elm_List_Mode);
|
|
|
|
Elm_Genlist_Smart_Data *sd = _pd;
|
2009-04-23 01:51:07 -07:00
|
|
|
|
2012-07-16 14:56:30 -07:00
|
|
|
if (sd->mode == mode) return;
|
|
|
|
sd->mode = mode;
|
|
|
|
elm_layout_sizing_eval(obj);
|
|
|
|
}
|
2011-08-04 18:21:56 -07:00
|
|
|
|
2010-04-06 07:01:04 -07:00
|
|
|
EAPI Elm_List_Mode
|
2012-01-24 07:15:43 -08:00
|
|
|
elm_genlist_mode_get(const Evas_Object *obj)
|
2010-04-06 07:01:04 -07:00
|
|
|
{
|
2012-07-16 14:56:30 -07:00
|
|
|
ELM_GENLIST_CHECK(obj) ELM_LIST_LAST;
|
2012-11-25 22:32:53 -08:00
|
|
|
Elm_List_Mode ret = ELM_LIST_LAST;
|
|
|
|
eo_do((Eo *) obj, elm_obj_genlist_mode_get(&ret));
|
|
|
|
return ret;
|
|
|
|
}
|
2012-07-16 14:56:30 -07:00
|
|
|
|
2012-11-25 22:32:53 -08:00
|
|
|
static void
|
|
|
|
_mode_get(Eo *obj EINA_UNUSED, void *_pd, va_list *list)
|
|
|
|
{
|
|
|
|
Elm_List_Mode *ret = va_arg(*list, Elm_List_Mode *);
|
|
|
|
Elm_Genlist_Smart_Data *sd = _pd;
|
|
|
|
|
2013-12-31 21:11:50 -08:00
|
|
|
if (ret) *ret = sd->mode;
|
2010-04-06 07:01:04 -07:00
|
|
|
}
|
|
|
|
|
2009-12-11 00:12:58 -08:00
|
|
|
EAPI void
|
2010-12-07 11:18:14 -08:00
|
|
|
elm_genlist_bounce_set(Evas_Object *obj,
|
2012-07-16 14:56:30 -07:00
|
|
|
Eina_Bool h_bounce,
|
|
|
|
Eina_Bool v_bounce)
|
2009-12-11 00:12:58 -08:00
|
|
|
{
|
2012-07-16 14:56:30 -07:00
|
|
|
ELM_GENLIST_CHECK(obj);
|
2014-03-17 04:44:40 -07:00
|
|
|
eo_do(obj, elm_interface_scrollable_bounce_allow_set(h_bounce, v_bounce));
|
2012-11-25 22:32:53 -08:00
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
_bounce_set(Eo *obj, void *_pd, va_list *list)
|
|
|
|
{
|
|
|
|
Eina_Bool h_bounce = va_arg(*list, int);
|
|
|
|
Eina_Bool v_bounce = va_arg(*list, int);
|
|
|
|
Elm_Genlist_Smart_Data *sd = _pd;
|
2012-07-16 14:56:30 -07:00
|
|
|
|
|
|
|
sd->h_bounce = !!h_bounce;
|
|
|
|
sd->v_bounce = !!v_bounce;
|
2014-03-17 04:44:40 -07:00
|
|
|
eo_do_super(obj, MY_CLASS, elm_interface_scrollable_bounce_allow_set
|
2012-11-25 22:32:53 -08:00
|
|
|
(sd->h_bounce, sd->v_bounce));
|
2009-12-11 00:12:58 -08:00
|
|
|
}
|
2010-01-23 01:07:20 -08:00
|
|
|
|
2010-04-06 07:01:04 -07:00
|
|
|
EAPI void
|
2010-12-07 11:18:14 -08:00
|
|
|
elm_genlist_bounce_get(const Evas_Object *obj,
|
2012-07-16 14:56:30 -07:00
|
|
|
Eina_Bool *h_bounce,
|
|
|
|
Eina_Bool *v_bounce)
|
2010-04-06 07:01:04 -07:00
|
|
|
{
|
2012-07-16 14:56:30 -07:00
|
|
|
ELM_GENLIST_CHECK(obj);
|
2014-03-17 04:44:40 -07:00
|
|
|
eo_do((Eo *) obj, elm_interface_scrollable_bounce_allow_get
|
2012-11-25 22:32:53 -08:00
|
|
|
(h_bounce, v_bounce));
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
_bounce_get(Eo *obj EINA_UNUSED, void *_pd, va_list *list)
|
|
|
|
{
|
|
|
|
Eina_Bool *h_bounce = va_arg(*list, Eina_Bool *);
|
|
|
|
Eina_Bool *v_bounce = va_arg(*list, Eina_Bool *);
|
|
|
|
Elm_Genlist_Smart_Data *sd = _pd;
|
2012-07-16 14:56:30 -07:00
|
|
|
|
|
|
|
if (h_bounce) *h_bounce = sd->h_bounce;
|
|
|
|
if (v_bounce) *v_bounce = sd->v_bounce;
|
2010-04-06 07:01:04 -07:00
|
|
|
}
|
|
|
|
|
2010-01-23 01:07:20 -08:00
|
|
|
EAPI void
|
2010-12-07 11:18:14 -08:00
|
|
|
elm_genlist_homogeneous_set(Evas_Object *obj,
|
2012-07-16 14:56:30 -07:00
|
|
|
Eina_Bool homogeneous)
|
2010-01-23 01:07:20 -08:00
|
|
|
{
|
2012-07-16 14:56:30 -07:00
|
|
|
ELM_GENLIST_CHECK(obj);
|
2012-11-25 22:32:53 -08:00
|
|
|
eo_do(obj, elm_obj_genlist_homogeneous_set(homogeneous));
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
_homogeneous_set(Eo *obj EINA_UNUSED, void *_pd, va_list *list)
|
|
|
|
{
|
|
|
|
Eina_Bool homogeneous = va_arg(*list, int);
|
|
|
|
Elm_Genlist_Smart_Data *sd = _pd;
|
2012-07-16 14:56:30 -07:00
|
|
|
|
|
|
|
sd->homogeneous = !!homogeneous;
|
2010-01-23 01:07:20 -08:00
|
|
|
}
|
|
|
|
|
2010-04-06 07:01:04 -07:00
|
|
|
EAPI Eina_Bool
|
|
|
|
elm_genlist_homogeneous_get(const Evas_Object *obj)
|
|
|
|
{
|
2012-07-16 14:56:30 -07:00
|
|
|
ELM_GENLIST_CHECK(obj) EINA_FALSE;
|
2012-11-25 22:32:53 -08:00
|
|
|
Eina_Bool ret = EINA_FALSE;
|
|
|
|
eo_do((Eo *) obj, elm_obj_genlist_homogeneous_get(&ret));
|
|
|
|
return ret;
|
|
|
|
}
|
2012-07-16 14:56:30 -07:00
|
|
|
|
2012-11-25 22:32:53 -08:00
|
|
|
static void
|
|
|
|
_homogeneous_get(Eo *obj EINA_UNUSED, void *_pd, va_list *list)
|
|
|
|
{
|
|
|
|
Eina_Bool *ret = va_arg(*list, Eina_Bool *);
|
|
|
|
Elm_Genlist_Smart_Data *sd = _pd;
|
|
|
|
|
2013-12-31 21:11:50 -08:00
|
|
|
if (ret) *ret = sd->homogeneous;
|
2010-04-06 07:01:04 -07:00
|
|
|
}
|
|
|
|
|
2010-01-23 01:07:20 -08:00
|
|
|
EAPI void
|
2010-12-07 11:18:14 -08:00
|
|
|
elm_genlist_block_count_set(Evas_Object *obj,
|
2012-07-16 14:56:30 -07:00
|
|
|
int count)
|
2010-01-23 01:07:20 -08:00
|
|
|
{
|
2012-07-16 14:56:30 -07:00
|
|
|
ELM_GENLIST_CHECK(obj);
|
2012-11-25 22:32:53 -08:00
|
|
|
eo_do(obj, elm_obj_genlist_block_count_set(count));
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
_block_count_set(Eo *obj EINA_UNUSED, void *_pd, va_list *list)
|
|
|
|
{
|
|
|
|
int count = va_arg(*list, int);
|
|
|
|
Elm_Genlist_Smart_Data *sd = _pd;
|
2012-05-29 21:57:29 -07:00
|
|
|
EINA_SAFETY_ON_TRUE_RETURN(count < 1);
|
|
|
|
|
2012-07-16 14:56:30 -07:00
|
|
|
sd->max_items_per_block = count;
|
|
|
|
sd->item_cache_max = sd->max_items_per_block * 2;
|
2012-10-22 07:34:43 -07:00
|
|
|
_item_cache_clean(sd);
|
2010-01-23 01:07:20 -08:00
|
|
|
}
|
|
|
|
|
2010-04-06 07:01:04 -07:00
|
|
|
EAPI int
|
|
|
|
elm_genlist_block_count_get(const Evas_Object *obj)
|
|
|
|
{
|
2012-07-16 14:56:30 -07:00
|
|
|
ELM_GENLIST_CHECK(obj) 0;
|
2012-11-25 22:32:53 -08:00
|
|
|
int ret = 0;
|
|
|
|
eo_do((Eo *) obj, elm_obj_genlist_block_count_get(&ret));
|
|
|
|
return ret;
|
|
|
|
}
|
2012-07-16 14:56:30 -07:00
|
|
|
|
2012-11-25 22:32:53 -08:00
|
|
|
static void
|
|
|
|
_block_count_get(Eo *obj EINA_UNUSED, void *_pd, va_list *list)
|
|
|
|
{
|
|
|
|
int *ret = va_arg(*list, int *);
|
|
|
|
Elm_Genlist_Smart_Data *sd = _pd;
|
|
|
|
|
2013-12-31 21:11:50 -08:00
|
|
|
if (ret) *ret = sd->max_items_per_block;
|
2010-04-06 07:01:04 -07:00
|
|
|
}
|
2010-07-27 16:36:27 -07:00
|
|
|
|
|
|
|
EAPI void
|
2010-12-07 11:18:14 -08:00
|
|
|
elm_genlist_longpress_timeout_set(Evas_Object *obj,
|
2012-07-16 14:56:30 -07:00
|
|
|
double timeout)
|
2010-07-27 16:36:27 -07:00
|
|
|
{
|
2012-07-16 14:56:30 -07:00
|
|
|
ELM_GENLIST_CHECK(obj);
|
2012-11-25 22:32:53 -08:00
|
|
|
eo_do(obj, elm_obj_genlist_longpress_timeout_set(timeout));
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
_longpress_timeout_set(Eo *obj EINA_UNUSED, void *_pd, va_list *list)
|
|
|
|
{
|
|
|
|
double timeout = va_arg(*list, double);
|
|
|
|
Elm_Genlist_Smart_Data *sd = _pd;
|
2012-07-16 14:56:30 -07:00
|
|
|
|
|
|
|
sd->longpress_timeout = timeout;
|
2010-07-27 16:36:27 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
EAPI double
|
|
|
|
elm_genlist_longpress_timeout_get(const Evas_Object *obj)
|
|
|
|
{
|
2012-07-16 14:56:30 -07:00
|
|
|
ELM_GENLIST_CHECK(obj) 0;
|
2012-11-25 22:32:53 -08:00
|
|
|
double ret = 0;
|
|
|
|
eo_do((Eo *) obj, elm_obj_genlist_longpress_timeout_get(&ret));
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
_longpress_timeout_get(Eo *obj EINA_UNUSED, void *_pd, va_list *list)
|
|
|
|
{
|
|
|
|
double *ret = va_arg(*list, double *);
|
|
|
|
Elm_Genlist_Smart_Data *sd = _pd;
|
2012-07-16 14:56:30 -07:00
|
|
|
|
2013-12-31 21:11:50 -08:00
|
|
|
if (ret) *ret = sd->longpress_timeout;
|
2010-07-27 16:36:27 -07:00
|
|
|
}
|
2010-11-22 07:24:58 -08:00
|
|
|
|
|
|
|
EAPI void
|
2012-07-16 14:56:30 -07:00
|
|
|
elm_genlist_scroller_policy_set(Evas_Object *obj,
|
2010-12-07 11:18:14 -08:00
|
|
|
Elm_Scroller_Policy policy_h,
|
|
|
|
Elm_Scroller_Policy policy_v)
|
2010-11-22 07:24:58 -08:00
|
|
|
{
|
2012-07-16 14:56:30 -07:00
|
|
|
ELM_GENLIST_CHECK(obj);
|
2014-03-17 04:44:40 -07:00
|
|
|
eo_do(obj, elm_interface_scrollable_policy_set(policy_h, policy_v));
|
2012-11-25 22:32:53 -08:00
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
_scroller_policy_set(Eo *obj, void *_pd EINA_UNUSED, va_list *list)
|
|
|
|
{
|
|
|
|
Elm_Scroller_Policy policy_h = va_arg(*list, Elm_Scroller_Policy);
|
|
|
|
Elm_Scroller_Policy policy_v = va_arg(*list, Elm_Scroller_Policy);
|
2012-07-16 14:56:30 -07:00
|
|
|
|
2010-11-22 07:24:58 -08:00
|
|
|
if ((policy_h >= ELM_SCROLLER_POLICY_LAST) ||
|
|
|
|
(policy_v >= ELM_SCROLLER_POLICY_LAST))
|
|
|
|
return;
|
2012-07-16 14:56:30 -07:00
|
|
|
|
2014-03-17 04:44:40 -07:00
|
|
|
eo_do_super(obj, MY_CLASS, elm_interface_scrollable_policy_set(policy_h, policy_v));
|
2010-11-22 07:24:58 -08:00
|
|
|
}
|
|
|
|
|
|
|
|
EAPI void
|
2012-07-16 14:56:30 -07:00
|
|
|
elm_genlist_scroller_policy_get(const Evas_Object *obj,
|
2010-12-07 11:18:14 -08:00
|
|
|
Elm_Scroller_Policy *policy_h,
|
|
|
|
Elm_Scroller_Policy *policy_v)
|
2012-11-25 22:32:53 -08:00
|
|
|
{
|
|
|
|
ELM_GENLIST_CHECK(obj);
|
2014-03-17 04:44:40 -07:00
|
|
|
eo_do((Eo *) obj, elm_interface_scrollable_policy_get(policy_h, policy_v));
|
2012-11-25 22:32:53 -08:00
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
_scroller_policy_get(Eo *obj, void *_pd EINA_UNUSED, va_list *list)
|
2010-11-22 07:24:58 -08:00
|
|
|
{
|
2012-07-16 14:56:30 -07:00
|
|
|
Elm_Scroller_Policy s_policy_h, s_policy_v;
|
|
|
|
|
2012-11-25 22:32:53 -08:00
|
|
|
Elm_Scroller_Policy *policy_h = va_arg(*list, Elm_Scroller_Policy *);
|
|
|
|
Elm_Scroller_Policy *policy_v = va_arg(*list, Elm_Scroller_Policy *);
|
2012-07-16 14:56:30 -07:00
|
|
|
|
2014-03-17 04:44:40 -07:00
|
|
|
eo_do_super((Eo *)obj, MY_CLASS, elm_interface_scrollable_policy_get
|
2012-11-25 22:32:53 -08:00
|
|
|
(&s_policy_h, &s_policy_v));
|
2010-12-07 11:18:14 -08:00
|
|
|
if (policy_h) *policy_h = (Elm_Scroller_Policy)s_policy_h;
|
|
|
|
if (policy_v) *policy_v = (Elm_Scroller_Policy)s_policy_v;
|
2010-11-22 07:24:58 -08:00
|
|
|
}
|
2011-03-22 00:54:24 -07:00
|
|
|
|
2011-04-06 21:35:08 -07:00
|
|
|
EAPI void
|
2011-04-07 09:16:01 -07:00
|
|
|
elm_genlist_realized_items_update(Evas_Object *obj)
|
2012-11-25 22:32:53 -08:00
|
|
|
{
|
|
|
|
ELM_GENLIST_CHECK(obj);
|
|
|
|
eo_do(obj, elm_obj_genlist_realized_items_update());
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
_realized_items_update(Eo *obj, void *_pd EINA_UNUSED, va_list *list_unused EINA_UNUSED)
|
2011-04-06 21:35:08 -07:00
|
|
|
{
|
2013-03-13 04:25:12 -07:00
|
|
|
Eina_List *list;
|
2012-01-19 21:18:31 -08:00
|
|
|
Elm_Object_Item *it;
|
2011-04-06 21:35:08 -07:00
|
|
|
|
|
|
|
list = elm_genlist_realized_items_get(obj);
|
2013-03-13 04:25:12 -07:00
|
|
|
EINA_LIST_FREE(list, it)
|
2011-04-06 21:35:08 -07:00
|
|
|
elm_genlist_item_update(it);
|
|
|
|
}
|
2011-04-21 04:47:36 -07:00
|
|
|
|
|
|
|
EAPI void
|
2012-07-16 14:56:30 -07:00
|
|
|
elm_genlist_item_decorate_mode_set(Elm_Object_Item *item,
|
|
|
|
const char *decorate_it_type,
|
|
|
|
Eina_Bool decorate_it_set)
|
2011-04-21 04:47:36 -07:00
|
|
|
{
|
2012-07-16 14:56:30 -07:00
|
|
|
Elm_Gen_Item *it = (Elm_Gen_Item *)item;
|
|
|
|
Elm_Genlist_Smart_Data *sd;
|
2012-01-19 21:18:31 -08:00
|
|
|
Elm_Object_Item *it2;
|
2012-07-16 14:56:30 -07:00
|
|
|
Eina_List *l;
|
|
|
|
|
|
|
|
ELM_GENLIST_ITEM_CHECK_OR_RETURN(item);
|
|
|
|
sd = GL_IT(it)->wsd;
|
2011-04-21 04:47:36 -07:00
|
|
|
|
2012-04-03 02:56:53 -07:00
|
|
|
if (!decorate_it_type) return;
|
2013-04-17 09:30:34 -07:00
|
|
|
if ((it->generation < sd->generation) ||
|
|
|
|
elm_widget_item_disabled_get(it)) return;
|
2012-07-16 14:56:30 -07:00
|
|
|
if (sd->decorate_all_mode) return;
|
2011-04-21 04:47:36 -07:00
|
|
|
|
2012-07-16 14:56:30 -07:00
|
|
|
if ((sd->mode_item == it) &&
|
|
|
|
(!strcmp(decorate_it_type, sd->decorate_it_type)) &&
|
2012-04-03 02:56:53 -07:00
|
|
|
(decorate_it_set))
|
2012-07-16 14:56:30 -07:00
|
|
|
return;
|
|
|
|
if (!it->itc->decorate_item_style) return;
|
|
|
|
it->decorate_it_set = decorate_it_set;
|
2011-04-21 04:47:36 -07:00
|
|
|
|
2012-07-16 14:56:30 -07:00
|
|
|
if (sd->multi)
|
2011-04-21 04:47:36 -07:00
|
|
|
{
|
2012-10-01 00:36:27 -07:00
|
|
|
EINA_LIST_FOREACH(sd->selected, l, it2)
|
2012-03-05 07:14:36 -08:00
|
|
|
if (((Elm_Gen_Item *)it2)->realized)
|
2011-11-29 16:59:19 -08:00
|
|
|
elm_genlist_item_selected_set(it2, EINA_FALSE);
|
2011-04-21 04:47:36 -07:00
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
2012-11-25 22:32:53 -08:00
|
|
|
it2 = elm_genlist_selected_item_get(sd->obj);
|
2012-03-05 07:14:36 -08:00
|
|
|
if ((it2) && (((Elm_Gen_Item *)it2)->realized))
|
2011-11-29 16:59:19 -08:00
|
|
|
elm_genlist_item_selected_set(it2, EINA_FALSE);
|
2011-04-21 04:47:36 -07:00
|
|
|
}
|
|
|
|
|
2012-07-16 14:56:30 -07:00
|
|
|
if (((sd->decorate_it_type)
|
|
|
|
&& (strcmp(decorate_it_type, sd->decorate_it_type))) ||
|
|
|
|
(decorate_it_set) || ((it == sd->mode_item) && (!decorate_it_set)))
|
|
|
|
_decorate_item_unset(sd);
|
2011-04-21 04:47:36 -07:00
|
|
|
|
2012-07-16 14:56:30 -07:00
|
|
|
eina_stringshare_replace(&sd->decorate_it_type, decorate_it_type);
|
|
|
|
if (decorate_it_set) _decorate_item_set(it);
|
2011-04-21 04:47:36 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
EAPI const char *
|
2012-07-16 14:56:30 -07:00
|
|
|
elm_genlist_item_decorate_mode_get(const Elm_Object_Item *item)
|
2011-04-21 04:47:36 -07:00
|
|
|
{
|
2012-07-16 14:56:30 -07:00
|
|
|
Elm_Gen_Item *i = (Elm_Gen_Item *)item;
|
|
|
|
|
|
|
|
ELM_GENLIST_ITEM_CHECK_OR_RETURN(item, NULL);
|
|
|
|
return GL_IT(i)->wsd->decorate_it_type;
|
2011-04-21 04:47:36 -07:00
|
|
|
}
|
|
|
|
|
2012-06-16 03:12:15 -07:00
|
|
|
EAPI Elm_Object_Item *
|
2012-03-07 08:19:25 -08:00
|
|
|
elm_genlist_decorated_item_get(const Evas_Object *obj)
|
2011-04-21 04:47:36 -07:00
|
|
|
{
|
2012-07-16 14:56:30 -07:00
|
|
|
ELM_GENLIST_CHECK(obj) NULL;
|
2012-11-25 22:32:53 -08:00
|
|
|
Elm_Object_Item *ret = NULL;
|
|
|
|
eo_do((Eo *) obj, elm_obj_genlist_decorated_item_get(&ret));
|
|
|
|
return ret;
|
|
|
|
}
|
2012-07-16 14:56:30 -07:00
|
|
|
|
2012-11-25 22:32:53 -08:00
|
|
|
static void
|
|
|
|
_decorated_item_get(Eo *obj EINA_UNUSED, void *_pd, va_list *list)
|
|
|
|
{
|
|
|
|
Elm_Object_Item **ret = va_arg(*list, Elm_Object_Item **);
|
|
|
|
Elm_Genlist_Smart_Data *sd = _pd;
|
|
|
|
|
2013-12-31 21:11:50 -08:00
|
|
|
if (ret) *ret = (Elm_Object_Item *)sd->mode_item;
|
2011-04-21 04:47:36 -07:00
|
|
|
}
|
2011-06-01 20:10:11 -07:00
|
|
|
|
2012-02-22 23:39:10 -08:00
|
|
|
EAPI Eina_Bool
|
2012-03-07 08:56:21 -08:00
|
|
|
elm_genlist_decorate_mode_get(const Evas_Object *obj)
|
2012-02-22 23:39:10 -08:00
|
|
|
{
|
2012-07-16 14:56:30 -07:00
|
|
|
ELM_GENLIST_CHECK(obj) EINA_FALSE;
|
2012-11-25 22:32:53 -08:00
|
|
|
Eina_Bool ret = EINA_FALSE;
|
|
|
|
eo_do((Eo *) obj, elm_obj_genlist_decorate_mode_get(&ret));
|
|
|
|
return ret;
|
|
|
|
}
|
2012-02-22 23:39:10 -08:00
|
|
|
|
2012-11-25 22:32:53 -08:00
|
|
|
static void
|
|
|
|
_decorate_mode_get(Eo *obj EINA_UNUSED, void *_pd, va_list *list)
|
|
|
|
{
|
|
|
|
Eina_Bool *ret = va_arg(*list, Eina_Bool *);
|
|
|
|
Elm_Genlist_Smart_Data *sd = _pd;
|
|
|
|
|
2013-12-31 21:11:50 -08:00
|
|
|
if (ret) *ret = sd->decorate_all_mode;
|
2012-02-22 23:39:10 -08:00
|
|
|
}
|
|
|
|
|
|
|
|
EAPI void
|
2012-07-16 14:56:30 -07:00
|
|
|
elm_genlist_decorate_mode_set(Evas_Object *obj,
|
|
|
|
Eina_Bool decorated)
|
2012-11-25 22:32:53 -08:00
|
|
|
{
|
|
|
|
ELM_GENLIST_CHECK(obj);
|
|
|
|
eo_do(obj, elm_obj_genlist_decorate_mode_set(decorated));
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
_decorate_mode_set(Eo *obj, void *_pd, va_list *valist)
|
2012-02-22 23:39:10 -08:00
|
|
|
{
|
|
|
|
Elm_Gen_Item *it;
|
2013-03-13 04:25:12 -07:00
|
|
|
Eina_List *list;
|
2012-06-15 00:58:08 -07:00
|
|
|
Elm_Object_Item *deco_it;
|
2012-02-22 23:39:10 -08:00
|
|
|
|
2012-11-25 22:32:53 -08:00
|
|
|
Eina_Bool decorated = va_arg(*valist, int);
|
|
|
|
Elm_Genlist_Smart_Data *sd = _pd;
|
2012-07-16 14:56:30 -07:00
|
|
|
|
2012-03-07 08:56:21 -08:00
|
|
|
decorated = !!decorated;
|
2012-07-16 14:56:30 -07:00
|
|
|
if (sd->decorate_all_mode == decorated) return;
|
|
|
|
sd->decorate_all_mode = decorated;
|
2012-02-22 23:39:10 -08:00
|
|
|
|
2013-05-29 04:54:11 -07:00
|
|
|
ELM_SAFE_FREE(sd->tree_effect_animator, ecore_animator_del);
|
2012-07-16 14:56:30 -07:00
|
|
|
sd->move_effect_mode = ELM_GENLIST_TREE_EFFECT_NONE;
|
2012-06-21 03:56:15 -07:00
|
|
|
|
2012-02-22 23:39:10 -08:00
|
|
|
list = elm_genlist_realized_items_get(obj);
|
2012-07-16 14:56:30 -07:00
|
|
|
if (!sd->decorate_all_mode)
|
2012-01-14 14:28:45 -08:00
|
|
|
{
|
2013-03-13 04:25:12 -07:00
|
|
|
EINA_LIST_FREE(list, it)
|
2012-07-16 14:56:30 -07:00
|
|
|
{
|
|
|
|
if (it->item->type != ELM_GENLIST_ITEM_GROUP)
|
|
|
|
_decorate_all_item_unrealize(it);
|
|
|
|
}
|
2012-10-22 07:34:43 -07:00
|
|
|
_item_cache_zero(sd);
|
2012-01-14 14:28:45 -08:00
|
|
|
}
|
2012-07-16 14:56:30 -07:00
|
|
|
else
|
|
|
|
{
|
|
|
|
// unset decorated item
|
|
|
|
deco_it = (Elm_Object_Item *)elm_genlist_decorated_item_get(obj);
|
|
|
|
if (deco_it)
|
|
|
|
{
|
|
|
|
elm_genlist_item_decorate_mode_set
|
|
|
|
(deco_it, elm_genlist_item_decorate_mode_get
|
|
|
|
(deco_it), EINA_FALSE);
|
|
|
|
_decorate_item_finished_signal_cb(deco_it, obj, NULL, NULL);
|
|
|
|
}
|
2012-01-26 02:01:48 -08:00
|
|
|
|
2013-03-13 04:25:12 -07:00
|
|
|
EINA_LIST_FREE(list, it)
|
2012-07-16 14:56:30 -07:00
|
|
|
{
|
|
|
|
if (it->item->type != ELM_GENLIST_ITEM_GROUP)
|
|
|
|
{
|
|
|
|
if (it->itc->decorate_all_item_style)
|
|
|
|
_decorate_all_item_realize(it, EINA_TRUE);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
2013-03-13 04:25:12 -07:00
|
|
|
|
2014-01-21 06:16:41 -08:00
|
|
|
ecore_job_del(sd->calc_job);
|
2013-04-24 04:41:37 -07:00
|
|
|
sd->calc_job = ecore_job_add(_calc_job, sd->obj);
|
2011-11-30 09:31:01 -08:00
|
|
|
}
|
2012-03-07 04:15:36 -08:00
|
|
|
|
|
|
|
EAPI void
|
2012-07-16 14:56:30 -07:00
|
|
|
elm_genlist_reorder_mode_set(Evas_Object *obj,
|
|
|
|
Eina_Bool reorder_mode)
|
2012-03-07 04:15:36 -08:00
|
|
|
{
|
2012-07-16 14:56:30 -07:00
|
|
|
ELM_GENLIST_CHECK(obj);
|
2012-11-25 22:32:53 -08:00
|
|
|
eo_do(obj, elm_obj_genlist_reorder_mode_set(reorder_mode));
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
_reorder_mode_set(Eo *obj EINA_UNUSED, void *_pd, va_list *list)
|
|
|
|
{
|
2013-03-14 03:13:06 -07:00
|
|
|
Eina_List *realized;
|
|
|
|
Elm_Gen_Item *it;
|
2012-11-25 22:32:53 -08:00
|
|
|
Eina_Bool reorder_mode = va_arg(*list, int);
|
|
|
|
Elm_Genlist_Smart_Data *sd = _pd;
|
2012-07-16 14:56:30 -07:00
|
|
|
|
2013-03-14 03:13:06 -07:00
|
|
|
if (sd->reorder_mode == !!reorder_mode) return;
|
2012-07-16 14:56:30 -07:00
|
|
|
sd->reorder_mode = !!reorder_mode;
|
2013-03-14 03:13:06 -07:00
|
|
|
realized = elm_genlist_realized_items_get(obj);
|
|
|
|
EINA_LIST_FREE(realized, it)
|
|
|
|
{
|
|
|
|
if (it->item->type != ELM_GENLIST_ITEM_GROUP)
|
|
|
|
{
|
|
|
|
Evas_Object *view;
|
|
|
|
if (it->deco_all_view) view = it->deco_all_view;
|
|
|
|
else view = VIEW(it);
|
|
|
|
|
|
|
|
if (sd->reorder_mode)
|
|
|
|
edje_object_signal_emit
|
|
|
|
(view, "elm,state,reorder,mode_set", "elm");
|
|
|
|
else
|
|
|
|
edje_object_signal_emit
|
|
|
|
(view, "elm,state,reorder,mode_unset", "elm");
|
|
|
|
}
|
|
|
|
}
|
2012-03-07 04:15:36 -08:00
|
|
|
}
|
|
|
|
|
|
|
|
EAPI Eina_Bool
|
2012-07-16 14:56:30 -07:00
|
|
|
elm_genlist_reorder_mode_get(const Evas_Object *obj)
|
2012-03-07 04:15:36 -08:00
|
|
|
{
|
2012-07-16 14:56:30 -07:00
|
|
|
ELM_GENLIST_CHECK(obj) EINA_FALSE;
|
2012-11-25 22:32:53 -08:00
|
|
|
Eina_Bool ret = EINA_FALSE;
|
|
|
|
eo_do((Eo *) obj, elm_obj_genlist_reorder_mode_get(&ret));
|
|
|
|
return ret;
|
|
|
|
}
|
2012-07-16 14:56:30 -07:00
|
|
|
|
2012-11-25 22:32:53 -08:00
|
|
|
static void
|
|
|
|
_reorder_mode_get(Eo *obj EINA_UNUSED, void *_pd, va_list *list)
|
|
|
|
{
|
|
|
|
Eina_Bool *ret = va_arg(*list, Eina_Bool *);
|
|
|
|
Elm_Genlist_Smart_Data *sd = _pd;
|
|
|
|
|
2013-12-31 21:11:50 -08:00
|
|
|
if (ret) *ret = sd->reorder_mode;
|
2012-03-07 04:15:36 -08:00
|
|
|
}
|
|
|
|
|
2012-07-16 14:56:30 -07:00
|
|
|
EAPI Elm_Genlist_Item_Type
|
|
|
|
elm_genlist_item_type_get(const Elm_Object_Item *item)
|
2012-03-07 04:15:36 -08:00
|
|
|
{
|
2012-07-16 14:56:30 -07:00
|
|
|
Elm_Gen_Item *it = (Elm_Gen_Item *)item;
|
2012-03-07 04:15:36 -08:00
|
|
|
|
2012-07-16 14:56:30 -07:00
|
|
|
ELM_GENLIST_ITEM_CHECK_OR_RETURN(item, ELM_GENLIST_ITEM_MAX);
|
2012-03-07 04:15:36 -08:00
|
|
|
|
2012-07-16 14:56:30 -07:00
|
|
|
return it->item->type;
|
2012-03-07 04:15:36 -08:00
|
|
|
}
|
|
|
|
|
2012-07-16 14:56:30 -07:00
|
|
|
EAPI Elm_Genlist_Item_Class *
|
|
|
|
elm_genlist_item_class_new(void)
|
2012-03-07 04:15:36 -08:00
|
|
|
{
|
2012-10-22 07:34:43 -07:00
|
|
|
Elm_Genlist_Item_Class *itc;
|
|
|
|
|
|
|
|
itc = calloc(1, sizeof(Elm_Genlist_Item_Class));
|
|
|
|
if (!itc)
|
|
|
|
return NULL;
|
2012-03-07 04:15:36 -08:00
|
|
|
|
2012-07-16 14:56:30 -07:00
|
|
|
itc->version = CLASS_ALLOCATED;
|
|
|
|
itc->refcount = 1;
|
|
|
|
itc->delete_me = EINA_FALSE;
|
|
|
|
|
|
|
|
return itc;
|
2012-03-07 04:15:36 -08:00
|
|
|
}
|
|
|
|
|
2012-07-16 14:56:30 -07:00
|
|
|
EAPI void
|
|
|
|
elm_genlist_item_class_free(Elm_Genlist_Item_Class *itc)
|
2012-03-07 04:15:36 -08:00
|
|
|
{
|
2012-07-16 14:56:30 -07:00
|
|
|
if (itc && (itc->version == CLASS_ALLOCATED))
|
2012-03-07 04:15:36 -08:00
|
|
|
{
|
2012-07-16 14:56:30 -07:00
|
|
|
if (!itc->delete_me) itc->delete_me = EINA_TRUE;
|
|
|
|
if (itc->refcount > 0) elm_genlist_item_class_unref(itc);
|
|
|
|
else
|
2012-03-07 04:15:36 -08:00
|
|
|
{
|
2012-07-16 14:56:30 -07:00
|
|
|
itc->version = 0;
|
|
|
|
free(itc);
|
2012-03-07 04:15:36 -08:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2012-07-16 14:56:30 -07:00
|
|
|
EAPI void
|
|
|
|
elm_genlist_item_class_ref(Elm_Genlist_Item_Class *itc)
|
2012-03-07 04:15:36 -08:00
|
|
|
{
|
2012-07-16 14:56:30 -07:00
|
|
|
if (itc && (itc->version == CLASS_ALLOCATED))
|
2012-03-07 04:15:36 -08:00
|
|
|
{
|
2012-07-16 14:56:30 -07:00
|
|
|
itc->refcount++;
|
|
|
|
if (itc->refcount == 0) itc->refcount--;
|
2012-03-07 04:15:36 -08:00
|
|
|
}
|
2012-07-16 14:56:30 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
EAPI void
|
|
|
|
elm_genlist_item_class_unref(Elm_Genlist_Item_Class *itc)
|
|
|
|
{
|
|
|
|
if (itc && (itc->version == CLASS_ALLOCATED))
|
2012-03-07 04:15:36 -08:00
|
|
|
{
|
2012-07-16 14:56:30 -07:00
|
|
|
if (itc->refcount > 0) itc->refcount--;
|
|
|
|
if (itc->delete_me && (!itc->refcount))
|
|
|
|
elm_genlist_item_class_free(itc);
|
2012-03-07 04:15:36 -08:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
2012-07-16 14:56:30 -07:00
|
|
|
_flip_job(void *data)
|
2012-03-07 04:15:36 -08:00
|
|
|
{
|
2012-07-16 14:56:30 -07:00
|
|
|
Elm_Gen_Item *it = (Elm_Gen_Item *)data;
|
2013-05-02 11:13:36 -07:00
|
|
|
ELM_GENLIST_DATA_GET_FROM_ITEM(it, sd);
|
2012-03-07 04:15:36 -08:00
|
|
|
|
2014-03-22 03:10:27 -07:00
|
|
|
it->unsel_cb(it);
|
2012-07-16 14:56:30 -07:00
|
|
|
_elm_genlist_item_unrealize(it, EINA_FALSE);
|
2012-03-07 04:15:36 -08:00
|
|
|
|
2012-07-16 14:56:30 -07:00
|
|
|
it->flipped = EINA_TRUE;
|
|
|
|
it->item->nocache = EINA_TRUE;
|
2014-01-21 06:16:41 -08:00
|
|
|
ecore_job_del(sd->calc_job);
|
2013-05-02 11:13:36 -07:00
|
|
|
sd->calc_job = ecore_job_add(_calc_job, sd->obj);
|
2012-03-07 04:15:36 -08:00
|
|
|
}
|
|
|
|
|
2012-07-16 14:56:30 -07:00
|
|
|
EAPI void
|
|
|
|
elm_genlist_item_flip_set(Elm_Object_Item *item,
|
|
|
|
Eina_Bool flip)
|
2012-03-07 04:15:36 -08:00
|
|
|
{
|
2012-07-16 14:56:30 -07:00
|
|
|
Elm_Gen_Item *it = (Elm_Gen_Item *)item;
|
2012-03-07 04:15:36 -08:00
|
|
|
|
2012-07-16 14:56:30 -07:00
|
|
|
ELM_GENLIST_ITEM_CHECK_OR_RETURN(item);
|
2012-03-07 04:15:36 -08:00
|
|
|
|
2012-07-16 14:56:30 -07:00
|
|
|
flip = !!flip;
|
|
|
|
if (it->flipped == flip) return;
|
|
|
|
|
|
|
|
if (flip)
|
2012-03-07 04:15:36 -08:00
|
|
|
{
|
2012-07-16 14:56:30 -07:00
|
|
|
ecore_job_add(_flip_job, it);
|
2012-03-07 04:15:36 -08:00
|
|
|
}
|
2012-07-16 14:56:30 -07:00
|
|
|
else
|
2012-03-07 04:15:36 -08:00
|
|
|
{
|
2012-07-16 14:56:30 -07:00
|
|
|
it->flipped = flip;
|
2012-10-22 07:34:43 -07:00
|
|
|
_item_cache_zero(GL_IT(it)->wsd);
|
2012-07-16 14:56:30 -07:00
|
|
|
elm_genlist_item_update(item);
|
|
|
|
it->item->nocache = EINA_FALSE;
|
|
|
|
}
|
|
|
|
}
|
2012-03-07 04:15:36 -08:00
|
|
|
|
2012-07-16 14:56:30 -07:00
|
|
|
EAPI Eina_Bool
|
|
|
|
elm_genlist_item_flip_get(const Elm_Object_Item *item)
|
|
|
|
{
|
|
|
|
Elm_Gen_Item *it = (Elm_Gen_Item *)item;
|
2012-03-07 04:15:36 -08:00
|
|
|
|
2012-07-16 14:56:30 -07:00
|
|
|
ELM_GENLIST_ITEM_CHECK_OR_RETURN(item, EINA_FALSE);
|
2012-03-07 04:15:36 -08:00
|
|
|
|
2012-07-16 14:56:30 -07:00
|
|
|
return it->flipped;
|
|
|
|
}
|
2012-03-07 04:15:36 -08:00
|
|
|
|
2012-07-16 14:56:30 -07:00
|
|
|
EAPI void
|
|
|
|
elm_genlist_select_mode_set(Evas_Object *obj,
|
|
|
|
Elm_Object_Select_Mode mode)
|
|
|
|
{
|
|
|
|
ELM_GENLIST_CHECK(obj);
|
2012-11-25 22:32:53 -08:00
|
|
|
eo_do(obj, elm_obj_genlist_select_mode_set(mode));
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
_select_mode_set(Eo *obj EINA_UNUSED, void *_pd, va_list *list)
|
|
|
|
{
|
|
|
|
Elm_Object_Select_Mode mode = va_arg(*list, Elm_Object_Select_Mode);
|
|
|
|
Elm_Genlist_Smart_Data *sd = _pd;
|
2012-03-07 04:15:36 -08:00
|
|
|
|
2012-07-16 14:56:30 -07:00
|
|
|
if (mode >= ELM_OBJECT_SELECT_MODE_MAX)
|
|
|
|
return;
|
2012-03-07 04:15:36 -08:00
|
|
|
|
2012-07-16 14:56:30 -07:00
|
|
|
if (sd->select_mode != mode)
|
|
|
|
sd->select_mode = mode;
|
|
|
|
}
|
2012-03-07 04:15:36 -08:00
|
|
|
|
2012-07-16 14:56:30 -07:00
|
|
|
EAPI Elm_Object_Select_Mode
|
|
|
|
elm_genlist_select_mode_get(const Evas_Object *obj)
|
|
|
|
{
|
|
|
|
ELM_GENLIST_CHECK(obj) ELM_OBJECT_SELECT_MODE_MAX;
|
2012-11-25 22:32:53 -08:00
|
|
|
Elm_Object_Select_Mode ret = ELM_OBJECT_SELECT_MODE_MAX;
|
|
|
|
eo_do((Eo *) obj, elm_obj_genlist_select_mode_get(&ret));
|
|
|
|
return ret;
|
|
|
|
}
|
2012-03-07 04:15:36 -08:00
|
|
|
|
2012-11-25 22:32:53 -08:00
|
|
|
static void
|
|
|
|
_select_mode_get(Eo *obj EINA_UNUSED, void *_pd, va_list *list)
|
|
|
|
{
|
|
|
|
Elm_Object_Select_Mode *ret = va_arg(*list, Elm_Object_Select_Mode *);
|
|
|
|
Elm_Genlist_Smart_Data *sd = _pd;
|
|
|
|
|
2013-12-31 21:11:50 -08:00
|
|
|
if (ret) *ret = sd->select_mode;
|
2012-07-16 14:56:30 -07:00
|
|
|
}
|
2012-03-07 04:15:36 -08:00
|
|
|
|
2012-07-16 14:56:30 -07:00
|
|
|
EAPI void
|
|
|
|
elm_genlist_highlight_mode_set(Evas_Object *obj,
|
|
|
|
Eina_Bool highlight)
|
|
|
|
{
|
|
|
|
ELM_GENLIST_CHECK(obj);
|
2012-11-25 22:32:53 -08:00
|
|
|
eo_do(obj, elm_obj_genlist_highlight_mode_set(highlight));
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
_highlight_mode_set(Eo *obj EINA_UNUSED, void *_pd, va_list *list)
|
|
|
|
{
|
|
|
|
Eina_Bool highlight = va_arg(*list, int);
|
|
|
|
Elm_Genlist_Smart_Data *sd = _pd;
|
2012-03-07 04:15:36 -08:00
|
|
|
|
2012-07-16 14:56:30 -07:00
|
|
|
sd->highlight = !!highlight;
|
|
|
|
}
|
|
|
|
|
|
|
|
EAPI Eina_Bool
|
|
|
|
elm_genlist_highlight_mode_get(const Evas_Object *obj)
|
|
|
|
{
|
|
|
|
ELM_GENLIST_CHECK(obj) EINA_FALSE;
|
2012-11-25 22:32:53 -08:00
|
|
|
Eina_Bool ret = EINA_FALSE;
|
|
|
|
eo_do((Eo *) obj, elm_obj_genlist_highlight_mode_get(&ret));
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
_highlight_mode_get(Eo *obj EINA_UNUSED, void *_pd, va_list *list)
|
|
|
|
{
|
|
|
|
Eina_Bool *ret = va_arg(*list, Eina_Bool *);
|
|
|
|
Elm_Genlist_Smart_Data *sd = _pd;
|
2012-07-16 14:56:30 -07:00
|
|
|
|
2013-12-31 21:11:50 -08:00
|
|
|
if (ret) *ret = sd->highlight;
|
2012-07-16 14:56:30 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
EAPI void
|
|
|
|
elm_genlist_item_select_mode_set(Elm_Object_Item *item,
|
|
|
|
Elm_Object_Select_Mode mode)
|
|
|
|
{
|
|
|
|
Elm_Gen_Item *it = (Elm_Gen_Item *)item;
|
|
|
|
|
|
|
|
ELM_GENLIST_ITEM_CHECK_OR_RETURN(item);
|
2013-05-02 11:13:36 -07:00
|
|
|
ELM_GENLIST_DATA_GET_FROM_ITEM(it, sd);
|
|
|
|
|
|
|
|
if (it->generation < sd->generation) return;
|
2012-07-16 14:56:30 -07:00
|
|
|
if (mode >= ELM_OBJECT_SELECT_MODE_MAX)
|
|
|
|
return;
|
|
|
|
if (it->select_mode != mode)
|
|
|
|
it->select_mode = mode;
|
|
|
|
|
|
|
|
if (it->select_mode == ELM_OBJECT_SELECT_MODE_DISPLAY_ONLY)
|
|
|
|
{
|
|
|
|
it->item->mincalcd = EINA_FALSE;
|
|
|
|
it->item->updateme = EINA_TRUE;
|
|
|
|
if (it->item->block) it->item->block->updateme = EINA_TRUE;
|
2014-01-21 06:16:41 -08:00
|
|
|
ecore_job_del(sd->update_job);
|
2013-05-02 11:13:36 -07:00
|
|
|
sd->update_job = ecore_job_add(_update_job, sd->obj);
|
2012-07-16 14:56:30 -07:00
|
|
|
|
|
|
|
// reset homogeneous item size
|
2013-05-02 11:13:36 -07:00
|
|
|
if (sd->homogeneous)
|
2012-03-07 04:15:36 -08:00
|
|
|
{
|
2012-07-16 14:56:30 -07:00
|
|
|
if (it->group)
|
2013-05-02 11:13:36 -07:00
|
|
|
sd->group_item_width = sd->group_item_height = 0;
|
2012-07-16 14:56:30 -07:00
|
|
|
else
|
2013-05-02 11:13:36 -07:00
|
|
|
sd->item_width = sd->item_height = 0;
|
2012-03-07 04:15:36 -08:00
|
|
|
}
|
|
|
|
}
|
2012-07-16 14:56:30 -07:00
|
|
|
}
|
2012-03-07 04:15:36 -08:00
|
|
|
|
2012-07-16 14:56:30 -07:00
|
|
|
EAPI Elm_Object_Select_Mode
|
|
|
|
elm_genlist_item_select_mode_get(const Elm_Object_Item *item)
|
|
|
|
{
|
|
|
|
Elm_Gen_Item *it = (Elm_Gen_Item *)item;
|
|
|
|
ELM_GENLIST_ITEM_CHECK_OR_RETURN(item, ELM_OBJECT_SELECT_MODE_MAX);
|
|
|
|
|
|
|
|
return it->select_mode;
|
|
|
|
}
|
|
|
|
|
|
|
|
EAPI void
|
|
|
|
elm_genlist_tree_effect_enabled_set(Evas_Object *obj,
|
|
|
|
Eina_Bool enabled)
|
|
|
|
{
|
|
|
|
ELM_GENLIST_CHECK(obj);
|
2012-11-25 22:32:53 -08:00
|
|
|
eo_do(obj, elm_obj_genlist_tree_effect_enabled_set(enabled));
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
_tree_effect_enabled_set(Eo *obj EINA_UNUSED, void *_pd, va_list *list)
|
|
|
|
{
|
|
|
|
Eina_Bool enabled = va_arg(*list, int);
|
|
|
|
Elm_Genlist_Smart_Data *sd = _pd;
|
2012-07-16 14:56:30 -07:00
|
|
|
|
|
|
|
sd->tree_effect_enabled = !!enabled;
|
|
|
|
}
|
|
|
|
|
|
|
|
EAPI Eina_Bool
|
|
|
|
elm_genlist_tree_effect_enabled_get(const Evas_Object *obj)
|
|
|
|
{
|
|
|
|
ELM_GENLIST_CHECK(obj) EINA_FALSE;
|
2012-11-25 22:32:53 -08:00
|
|
|
Eina_Bool ret = EINA_FALSE;
|
|
|
|
eo_do((Eo *) obj, elm_obj_genlist_tree_effect_enabled_get(&ret));
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
_tree_effect_enabled_get(Eo *obj EINA_UNUSED, void *_pd, va_list *list)
|
|
|
|
{
|
|
|
|
Eina_Bool *ret = va_arg(*list, Eina_Bool *);
|
|
|
|
Elm_Genlist_Smart_Data *sd = _pd;
|
2012-07-16 14:56:30 -07:00
|
|
|
|
2013-12-31 21:11:50 -08:00
|
|
|
if (ret) *ret = sd->tree_effect_enabled;
|
2012-03-07 04:15:36 -08:00
|
|
|
}
|
2012-07-16 14:56:30 -07:00
|
|
|
|
2013-02-20 02:00:49 -08:00
|
|
|
EAPI void
|
|
|
|
elm_genlist_focus_on_selection_set(Evas_Object *obj,
|
|
|
|
Eina_Bool enabled)
|
|
|
|
{
|
|
|
|
ELM_GENLIST_CHECK(obj);
|
|
|
|
eo_do(obj, elm_obj_genlist_focus_on_selection_set(enabled));
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
_focus_on_selection_set(Eo *obj EINA_UNUSED, void *_pd, va_list *list)
|
|
|
|
{
|
|
|
|
Eina_Bool enabled = va_arg(*list, int);
|
|
|
|
Elm_Genlist_Smart_Data *sd = _pd;
|
|
|
|
sd->focus_on_selection_enabled = !!enabled;
|
|
|
|
}
|
|
|
|
|
|
|
|
EAPI Eina_Bool
|
|
|
|
elm_genlist_focus_on_selection_get(const Evas_Object *obj)
|
|
|
|
{
|
|
|
|
ELM_GENLIST_CHECK(obj) EINA_FALSE;
|
|
|
|
Eina_Bool ret = EINA_FALSE;
|
|
|
|
eo_do((Eo *) obj, elm_obj_genlist_focus_on_selection_get(&ret));
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
_focus_on_selection_get(Eo *obj EINA_UNUSED, void *_pd, va_list *list)
|
|
|
|
{
|
|
|
|
Eina_Bool *ret = va_arg(*list, Eina_Bool *);
|
|
|
|
Elm_Genlist_Smart_Data *sd = _pd;
|
2013-12-31 21:11:50 -08:00
|
|
|
if (ret) *ret = sd->focus_on_selection_enabled;
|
2013-02-20 02:00:49 -08:00
|
|
|
}
|
|
|
|
|
2012-11-14 07:46:14 -08:00
|
|
|
EAPI Elm_Object_Item *
|
|
|
|
elm_genlist_nth_item_get(const Evas_Object *obj, unsigned int nth)
|
|
|
|
{
|
|
|
|
Elm_Gen_Item *it = NULL;
|
|
|
|
Eina_Accessor *a;
|
|
|
|
void *data;
|
|
|
|
|
|
|
|
ELM_GENLIST_CHECK(obj) NULL;
|
|
|
|
ELM_GENLIST_DATA_GET(obj, sd);
|
|
|
|
|
|
|
|
if (!sd->items) return NULL;
|
|
|
|
|
|
|
|
a = eina_inlist_accessor_new(sd->items);
|
|
|
|
if (!a) return NULL;
|
|
|
|
if (eina_accessor_data_get(a, nth, &data))
|
|
|
|
it = ELM_GEN_ITEM_FROM_INLIST(data);
|
|
|
|
eina_accessor_free(a);
|
|
|
|
return (Elm_Object_Item *)it;
|
|
|
|
}
|
|
|
|
|
2014-03-08 08:04:34 -08:00
|
|
|
static void
|
|
|
|
_elm_genlist_focus_highlight_geometry_get(Eo *obj EINA_UNUSED, void *_pd, va_list *list)
|
|
|
|
{
|
|
|
|
Evas_Coord *x = va_arg(*list, Evas_Coord *);
|
|
|
|
Evas_Coord *y = va_arg(*list, Evas_Coord *);
|
|
|
|
Evas_Coord *w = va_arg(*list, Evas_Coord *);
|
|
|
|
Evas_Coord *h = va_arg(*list, Evas_Coord *);
|
2014-03-17 23:07:14 -07:00
|
|
|
Eina_Bool is_next = va_arg(*list, int);
|
2014-03-09 03:36:17 -07:00
|
|
|
Evas_Coord ox, oy, oh, item_x = 0, item_y = 0, item_w = 0, item_h = 0;
|
2014-03-08 08:04:34 -08:00
|
|
|
|
|
|
|
Elm_Genlist_Smart_Data *sd = _pd;
|
2014-03-09 03:36:17 -07:00
|
|
|
evas_object_geometry_get(obj, &ox, &oy, NULL, &oh);
|
2014-03-08 08:04:34 -08:00
|
|
|
|
2014-03-17 23:07:14 -07:00
|
|
|
if (is_next)
|
2014-03-08 08:04:34 -08:00
|
|
|
{
|
|
|
|
if (sd->focused_item)
|
|
|
|
{
|
|
|
|
evas_object_geometry_get(VIEW(sd->focused_item), &item_x, &item_y, &item_w, &item_h);
|
|
|
|
elm_widget_focus_highlight_focus_part_geometry_get(VIEW(sd->focused_item), &item_x, &item_y, &item_w, &item_h);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
if (sd->prev_focused_item)
|
|
|
|
{
|
|
|
|
evas_object_geometry_get(VIEW(sd->prev_focused_item), &item_x, &item_y, &item_w, &item_h);
|
|
|
|
elm_widget_focus_highlight_focus_part_geometry_get(VIEW(sd->prev_focused_item), &item_x, &item_y, &item_w, &item_h);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if (item_y < oy)
|
|
|
|
{
|
|
|
|
*x = ox;
|
|
|
|
*y = oy;
|
|
|
|
*w = item_w;
|
|
|
|
*h = item_h;
|
|
|
|
}
|
|
|
|
else if (item_y > (oy + oh - item_h))
|
|
|
|
{
|
|
|
|
*x = ox;
|
|
|
|
*y = oy + oh - item_h;
|
|
|
|
*w = item_w;
|
|
|
|
*h = item_h;
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
*x = item_x;
|
|
|
|
*y = item_y;
|
|
|
|
*w = item_w;
|
|
|
|
*h = item_h;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
_elm_genlist_focused_item_get(Eo *obj EINA_UNUSED, void *_pd, va_list *list)
|
|
|
|
{
|
|
|
|
Elm_Object_Item **ret = va_arg(*list, Elm_Object_Item **);
|
|
|
|
Elm_Genlist_Smart_Data *sd = _pd;
|
|
|
|
|
|
|
|
if (ret) *ret = sd->focused_item;
|
|
|
|
}
|
|
|
|
|
2012-11-25 22:32:53 -08:00
|
|
|
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_MEMBER_ADD), _elm_genlist_smart_member_add),
|
|
|
|
EO_OP_FUNC(EVAS_OBJ_SMART_ID(EVAS_OBJ_SMART_SUB_ID_ADD), _elm_genlist_smart_add),
|
|
|
|
EO_OP_FUNC(EVAS_OBJ_SMART_ID(EVAS_OBJ_SMART_SUB_ID_DEL), _elm_genlist_smart_del),
|
|
|
|
EO_OP_FUNC(EVAS_OBJ_SMART_ID(EVAS_OBJ_SMART_SUB_ID_RESIZE), _elm_genlist_smart_resize),
|
|
|
|
EO_OP_FUNC(EVAS_OBJ_SMART_ID(EVAS_OBJ_SMART_SUB_ID_MOVE), _elm_genlist_smart_move),
|
|
|
|
|
2014-03-14 02:13:29 -07:00
|
|
|
EO_OP_FUNC(ELM_OBJ_WIDGET_ID(ELM_OBJ_WIDGET_SUB_ID_THEME_APPLY), _elm_genlist_smart_theme),
|
|
|
|
EO_OP_FUNC(ELM_OBJ_WIDGET_ID(ELM_OBJ_WIDGET_SUB_ID_EVENT), _elm_genlist_smart_event),
|
|
|
|
EO_OP_FUNC(ELM_OBJ_WIDGET_ID(ELM_OBJ_WIDGET_SUB_ID_ON_FOCUS), _elm_genlist_smart_on_focus),
|
|
|
|
EO_OP_FUNC(ELM_OBJ_WIDGET_ID(ELM_OBJ_WIDGET_SUB_ID_SUB_OBJECT_ADD), _elm_genlist_smart_sub_object_add),
|
|
|
|
EO_OP_FUNC(ELM_OBJ_WIDGET_ID(ELM_OBJ_WIDGET_SUB_ID_SUB_OBJECT_DEL), _elm_genlist_smart_sub_object_del),
|
|
|
|
EO_OP_FUNC(ELM_OBJ_WIDGET_ID(ELM_OBJ_WIDGET_SUB_ID_FOCUS_NEXT_MANAGER_IS), _elm_genlist_smart_focus_next_manager_is),
|
|
|
|
EO_OP_FUNC(ELM_OBJ_WIDGET_ID(ELM_OBJ_WIDGET_SUB_ID_FOCUS_DIRECTION_MANAGER_IS), _elm_genlist_smart_focus_direction_manager_is),
|
|
|
|
EO_OP_FUNC(ELM_OBJ_WIDGET_ID(ELM_OBJ_WIDGET_SUB_ID_FOCUS_NEXT), _elm_genlist_smart_focus_next),
|
|
|
|
EO_OP_FUNC(ELM_OBJ_WIDGET_ID(ELM_OBJ_WIDGET_SUB_ID_FOCUS_HIGHLIGHT_GEOMETRY_GET), _elm_genlist_focus_highlight_geometry_get),
|
|
|
|
EO_OP_FUNC(ELM_OBJ_WIDGET_ID(ELM_OBJ_WIDGET_SUB_ID_FOCUSED_ITEM_GET), _elm_genlist_focused_item_get),
|
|
|
|
EO_OP_FUNC(ELM_OBJ_WIDGET_ID(ELM_OBJ_WIDGET_SUB_ID_ACCESS), _elm_genlist_smart_access),
|
2012-11-25 22:32:53 -08:00
|
|
|
|
|
|
|
EO_OP_FUNC(ELM_OBJ_LAYOUT_ID(ELM_OBJ_LAYOUT_SUB_ID_SIZING_EVAL), _elm_genlist_smart_sizing_eval),
|
|
|
|
EO_OP_FUNC(ELM_OBJ_LAYOUT_ID(ELM_OBJ_LAYOUT_SUB_ID_SUB_OBJECT_ADD_ENABLE), _elm_genlist_smart_layout_sub_object_add_enable),
|
|
|
|
|
2014-03-17 04:44:40 -07:00
|
|
|
EO_OP_FUNC(ELM_INTERFACE_SCROLLABLE_ID(ELM_INTERFACE_SCROLLABLE_SUB_ID_BOUNCE_ALLOW_SET), _bounce_set),
|
|
|
|
EO_OP_FUNC(ELM_INTERFACE_SCROLLABLE_ID(ELM_INTERFACE_SCROLLABLE_SUB_ID_BOUNCE_ALLOW_GET), _bounce_get),
|
|
|
|
EO_OP_FUNC(ELM_INTERFACE_SCROLLABLE_ID(ELM_INTERFACE_SCROLLABLE_SUB_ID_POLICY_SET), _scroller_policy_set),
|
|
|
|
EO_OP_FUNC(ELM_INTERFACE_SCROLLABLE_ID(ELM_INTERFACE_SCROLLABLE_SUB_ID_POLICY_GET), _scroller_policy_get),
|
2012-11-25 22:32:53 -08:00
|
|
|
|
|
|
|
EO_OP_FUNC(ELM_OBJ_GENLIST_ID(ELM_OBJ_GENLIST_SUB_ID_ITEMS_COUNT), _items_count),
|
|
|
|
EO_OP_FUNC(ELM_OBJ_GENLIST_ID(ELM_OBJ_GENLIST_SUB_ID_ITEM_APPEND), _item_append),
|
|
|
|
EO_OP_FUNC(ELM_OBJ_GENLIST_ID(ELM_OBJ_GENLIST_SUB_ID_ITEM_PREPEND), _item_prepend),
|
|
|
|
EO_OP_FUNC(ELM_OBJ_GENLIST_ID(ELM_OBJ_GENLIST_SUB_ID_ITEM_INSERT_AFTER), _item_insert_after),
|
|
|
|
EO_OP_FUNC(ELM_OBJ_GENLIST_ID(ELM_OBJ_GENLIST_SUB_ID_ITEM_INSERT_BEFORE), _item_insert_before),
|
|
|
|
EO_OP_FUNC(ELM_OBJ_GENLIST_ID(ELM_OBJ_GENLIST_SUB_ID_ITEM_SORTED_INSERT), _item_sorted_insert),
|
|
|
|
EO_OP_FUNC(ELM_OBJ_GENLIST_ID(ELM_OBJ_GENLIST_SUB_ID_CLEAR), _clear_eo),
|
|
|
|
EO_OP_FUNC(ELM_OBJ_GENLIST_ID(ELM_OBJ_GENLIST_SUB_ID_MULTI_SELECT_SET), _multi_select_set),
|
|
|
|
EO_OP_FUNC(ELM_OBJ_GENLIST_ID(ELM_OBJ_GENLIST_SUB_ID_MULTI_SELECT_GET), _multi_select_get),
|
2013-11-03 08:15:58 -08:00
|
|
|
EO_OP_FUNC(ELM_OBJ_GENLIST_ID(ELM_OBJ_GENLIST_SUB_ID_MULTI_SELECT_MODE_SET), _multi_select_mode_set),
|
|
|
|
EO_OP_FUNC(ELM_OBJ_GENLIST_ID(ELM_OBJ_GENLIST_SUB_ID_MULTI_SELECT_MODE_GET), _multi_select_mode_get),
|
2012-11-25 22:32:53 -08:00
|
|
|
EO_OP_FUNC(ELM_OBJ_GENLIST_ID(ELM_OBJ_GENLIST_SUB_ID_SELECTED_ITEM_GET), _selected_item_get),
|
|
|
|
EO_OP_FUNC(ELM_OBJ_GENLIST_ID(ELM_OBJ_GENLIST_SUB_ID_SELECTED_ITEMS_GET), _selected_items_get),
|
|
|
|
EO_OP_FUNC(ELM_OBJ_GENLIST_ID(ELM_OBJ_GENLIST_SUB_ID_REALIZED_ITEMS_GET), _realized_items_get),
|
|
|
|
EO_OP_FUNC(ELM_OBJ_GENLIST_ID(ELM_OBJ_GENLIST_SUB_ID_AT_XY_ITEM_GET), _at_xy_item_get),
|
|
|
|
EO_OP_FUNC(ELM_OBJ_GENLIST_ID(ELM_OBJ_GENLIST_SUB_ID_FIRST_ITEM_GET), _first_item_get),
|
|
|
|
EO_OP_FUNC(ELM_OBJ_GENLIST_ID(ELM_OBJ_GENLIST_SUB_ID_LAST_ITEM_GET), _last_item_get),
|
|
|
|
EO_OP_FUNC(ELM_OBJ_GENLIST_ID(ELM_OBJ_GENLIST_SUB_ID_MODE_SET), _mode_set),
|
|
|
|
EO_OP_FUNC(ELM_OBJ_GENLIST_ID(ELM_OBJ_GENLIST_SUB_ID_MODE_GET), _mode_get),
|
|
|
|
EO_OP_FUNC(ELM_OBJ_GENLIST_ID(ELM_OBJ_GENLIST_SUB_ID_HOMOGENEOUS_SET), _homogeneous_set),
|
|
|
|
EO_OP_FUNC(ELM_OBJ_GENLIST_ID(ELM_OBJ_GENLIST_SUB_ID_HOMOGENEOUS_GET), _homogeneous_get),
|
|
|
|
EO_OP_FUNC(ELM_OBJ_GENLIST_ID(ELM_OBJ_GENLIST_SUB_ID_BLOCK_COUNT_SET), _block_count_set),
|
|
|
|
EO_OP_FUNC(ELM_OBJ_GENLIST_ID(ELM_OBJ_GENLIST_SUB_ID_BLOCK_COUNT_GET), _block_count_get),
|
|
|
|
EO_OP_FUNC(ELM_OBJ_GENLIST_ID(ELM_OBJ_GENLIST_SUB_ID_LONGPRESS_TIMEOUT_SET), _longpress_timeout_set),
|
|
|
|
EO_OP_FUNC(ELM_OBJ_GENLIST_ID(ELM_OBJ_GENLIST_SUB_ID_LONGPRESS_TIMEOUT_GET), _longpress_timeout_get),
|
|
|
|
EO_OP_FUNC(ELM_OBJ_GENLIST_ID(ELM_OBJ_GENLIST_SUB_ID_REALIZED_ITEMS_UPDATE), _realized_items_update),
|
|
|
|
EO_OP_FUNC(ELM_OBJ_GENLIST_ID(ELM_OBJ_GENLIST_SUB_ID_DECORATED_ITEM_GET), _decorated_item_get),
|
|
|
|
EO_OP_FUNC(ELM_OBJ_GENLIST_ID(ELM_OBJ_GENLIST_SUB_ID_DECORATE_MODE_GET), _decorate_mode_get),
|
|
|
|
EO_OP_FUNC(ELM_OBJ_GENLIST_ID(ELM_OBJ_GENLIST_SUB_ID_DECORATE_MODE_SET), _decorate_mode_set),
|
|
|
|
EO_OP_FUNC(ELM_OBJ_GENLIST_ID(ELM_OBJ_GENLIST_SUB_ID_REORDER_MODE_SET), _reorder_mode_set),
|
|
|
|
EO_OP_FUNC(ELM_OBJ_GENLIST_ID(ELM_OBJ_GENLIST_SUB_ID_REORDER_MODE_GET), _reorder_mode_get),
|
|
|
|
EO_OP_FUNC(ELM_OBJ_GENLIST_ID(ELM_OBJ_GENLIST_SUB_ID_SELECT_MODE_SET), _select_mode_set),
|
|
|
|
EO_OP_FUNC(ELM_OBJ_GENLIST_ID(ELM_OBJ_GENLIST_SUB_ID_SELECT_MODE_GET), _select_mode_get),
|
|
|
|
EO_OP_FUNC(ELM_OBJ_GENLIST_ID(ELM_OBJ_GENLIST_SUB_ID_HIGHLIGHT_MODE_SET), _highlight_mode_set),
|
|
|
|
EO_OP_FUNC(ELM_OBJ_GENLIST_ID(ELM_OBJ_GENLIST_SUB_ID_HIGHLIGHT_MODE_GET), _highlight_mode_get),
|
|
|
|
EO_OP_FUNC(ELM_OBJ_GENLIST_ID(ELM_OBJ_GENLIST_SUB_ID_TREE_EFFECT_ENABLED_SET), _tree_effect_enabled_set),
|
|
|
|
EO_OP_FUNC(ELM_OBJ_GENLIST_ID(ELM_OBJ_GENLIST_SUB_ID_TREE_EFFECT_ENABLED_GET), _tree_effect_enabled_get),
|
2013-02-20 02:00:49 -08:00
|
|
|
EO_OP_FUNC(ELM_OBJ_GENLIST_ID(ELM_OBJ_GENLIST_SUB_ID_FOCUS_ON_SELECTION_SET), _focus_on_selection_set),
|
|
|
|
EO_OP_FUNC(ELM_OBJ_GENLIST_ID(ELM_OBJ_GENLIST_SUB_ID_FOCUS_ON_SELECTION_GET), _focus_on_selection_get),
|
2012-11-25 22:32:53 -08:00
|
|
|
EO_OP_FUNC_SENTINEL
|
|
|
|
};
|
|
|
|
eo_class_funcs_set(klass, func_desc);
|
2013-02-07 04:24:59 -08:00
|
|
|
|
|
|
|
if (_elm_config->access_mode)
|
|
|
|
_elm_genlist_smart_focus_next_enable = EINA_TRUE;
|
2013-02-09 23:52:31 -08:00
|
|
|
|
2013-11-07 03:44:22 -08:00
|
|
|
evas_smart_legacy_type_register(MY_CLASS_NAME_LEGACY, klass);
|
2012-11-25 22:32:53 -08:00
|
|
|
}
|
|
|
|
|
|
|
|
static const Eo_Op_Description op_desc[] = {
|
|
|
|
EO_OP_DESCRIPTION(ELM_OBJ_GENLIST_SUB_ID_ITEMS_COUNT, "Return how many items are currently in a list."),
|
|
|
|
EO_OP_DESCRIPTION(ELM_OBJ_GENLIST_SUB_ID_ITEM_APPEND, "Append a new item in a given genlist widget."),
|
|
|
|
EO_OP_DESCRIPTION(ELM_OBJ_GENLIST_SUB_ID_ITEM_PREPEND, "Prepend a new item in a given genlist widget."),
|
|
|
|
EO_OP_DESCRIPTION(ELM_OBJ_GENLIST_SUB_ID_ITEM_INSERT_AFTER, "Insert an item after another in a genlist widget."),
|
|
|
|
EO_OP_DESCRIPTION(ELM_OBJ_GENLIST_SUB_ID_ITEM_INSERT_BEFORE, "Insert an item before another in a genlist widget."),
|
|
|
|
EO_OP_DESCRIPTION(ELM_OBJ_GENLIST_SUB_ID_ITEM_SORTED_INSERT, "Insert a new item into the sorted genlist object."),
|
|
|
|
EO_OP_DESCRIPTION(ELM_OBJ_GENLIST_SUB_ID_CLEAR, "Remove all items from a given genlist widget."),
|
|
|
|
EO_OP_DESCRIPTION(ELM_OBJ_GENLIST_SUB_ID_MULTI_SELECT_SET, "Enable or disable multi-selection in the genlist."),
|
2013-08-21 13:23:44 -07:00
|
|
|
EO_OP_DESCRIPTION(ELM_OBJ_GENLIST_SUB_ID_MULTI_SELECT_GET, "Get if multi-selection in genlist is enabled or disabled."),
|
2013-11-03 08:15:58 -08:00
|
|
|
EO_OP_DESCRIPTION(ELM_OBJ_GENLIST_SUB_ID_MULTI_SELECT_MODE_SET, "Set the genlist multi select mode."),
|
|
|
|
EO_OP_DESCRIPTION(ELM_OBJ_GENLIST_SUB_ID_MULTI_SELECT_MODE_GET, "Get the genlist multi select mode."),
|
2012-11-25 22:32:53 -08:00
|
|
|
EO_OP_DESCRIPTION(ELM_OBJ_GENLIST_SUB_ID_SELECTED_ITEM_GET, "Get the selected item in the genlist."),
|
|
|
|
EO_OP_DESCRIPTION(ELM_OBJ_GENLIST_SUB_ID_SELECTED_ITEMS_GET, "Get a list of selected items in the genlist."),
|
|
|
|
EO_OP_DESCRIPTION(ELM_OBJ_GENLIST_SUB_ID_REALIZED_ITEMS_GET, "Get a list of realized items in genlist."),
|
|
|
|
EO_OP_DESCRIPTION(ELM_OBJ_GENLIST_SUB_ID_AT_XY_ITEM_GET, "Get the item that is at the x, y canvas coords."),
|
|
|
|
EO_OP_DESCRIPTION(ELM_OBJ_GENLIST_SUB_ID_FIRST_ITEM_GET, "Get the first item in the genlist."),
|
|
|
|
EO_OP_DESCRIPTION(ELM_OBJ_GENLIST_SUB_ID_LAST_ITEM_GET, "Get the last item in the genlist."),
|
|
|
|
EO_OP_DESCRIPTION(ELM_OBJ_GENLIST_SUB_ID_MODE_SET, "This sets the horizontal stretching mode."),
|
2013-08-21 13:23:44 -07:00
|
|
|
EO_OP_DESCRIPTION(ELM_OBJ_GENLIST_SUB_ID_MODE_GET, "Get the horizontal stretching mode."),
|
2012-11-25 22:32:53 -08:00
|
|
|
EO_OP_DESCRIPTION(ELM_OBJ_GENLIST_SUB_ID_HOMOGENEOUS_SET, "Enable/disable homogeneous mode."),
|
|
|
|
EO_OP_DESCRIPTION(ELM_OBJ_GENLIST_SUB_ID_HOMOGENEOUS_GET, "Get whether the homogeneous mode is enabled."),
|
|
|
|
EO_OP_DESCRIPTION(ELM_OBJ_GENLIST_SUB_ID_BLOCK_COUNT_SET, "Set the maximum number of items within an item block."),
|
|
|
|
EO_OP_DESCRIPTION(ELM_OBJ_GENLIST_SUB_ID_BLOCK_COUNT_GET, "Get the maximum number of items within an item block."),
|
|
|
|
EO_OP_DESCRIPTION(ELM_OBJ_GENLIST_SUB_ID_LONGPRESS_TIMEOUT_SET, "Set the timeout in seconds for the longpress event."),
|
|
|
|
EO_OP_DESCRIPTION(ELM_OBJ_GENLIST_SUB_ID_LONGPRESS_TIMEOUT_GET, "Get the timeout in seconds for the longpress event."),
|
|
|
|
EO_OP_DESCRIPTION(ELM_OBJ_GENLIST_SUB_ID_REALIZED_ITEMS_UPDATE, "Update the contents of all realized items."),
|
|
|
|
EO_OP_DESCRIPTION(ELM_OBJ_GENLIST_SUB_ID_DECORATED_ITEM_GET, "Get active genlist mode item."),
|
|
|
|
EO_OP_DESCRIPTION(ELM_OBJ_GENLIST_SUB_ID_DECORATE_MODE_GET, "Get Genlist decorate mode."),
|
|
|
|
EO_OP_DESCRIPTION(ELM_OBJ_GENLIST_SUB_ID_DECORATE_MODE_SET, "Set Genlist decorate mode."),
|
|
|
|
EO_OP_DESCRIPTION(ELM_OBJ_GENLIST_SUB_ID_REORDER_MODE_SET, "Set reorder mode."),
|
|
|
|
EO_OP_DESCRIPTION(ELM_OBJ_GENLIST_SUB_ID_REORDER_MODE_GET, "Get the reorder mode."),
|
|
|
|
EO_OP_DESCRIPTION(ELM_OBJ_GENLIST_SUB_ID_SELECT_MODE_SET, "Set the genlist select mode."),
|
|
|
|
EO_OP_DESCRIPTION(ELM_OBJ_GENLIST_SUB_ID_SELECT_MODE_GET, "Get the genlist select mode."),
|
|
|
|
EO_OP_DESCRIPTION(ELM_OBJ_GENLIST_SUB_ID_HIGHLIGHT_MODE_SET, "Set whether the genlist items' should be highlighted when item selected."),
|
|
|
|
EO_OP_DESCRIPTION(ELM_OBJ_GENLIST_SUB_ID_HIGHLIGHT_MODE_GET, "Get whether the genlist items' should be highlighted when item selected."),
|
|
|
|
EO_OP_DESCRIPTION(ELM_OBJ_GENLIST_SUB_ID_TREE_EFFECT_ENABLED_SET, "Set Genlist tree effect."),
|
|
|
|
EO_OP_DESCRIPTION(ELM_OBJ_GENLIST_SUB_ID_TREE_EFFECT_ENABLED_GET, "Get Genlist tree effect."),
|
2013-02-20 02:00:49 -08:00
|
|
|
EO_OP_DESCRIPTION(ELM_OBJ_GENLIST_SUB_ID_FOCUS_ON_SELECTION_SET, "Set focus upon item's selection mode."),
|
|
|
|
EO_OP_DESCRIPTION(ELM_OBJ_GENLIST_SUB_ID_FOCUS_ON_SELECTION_GET, "Get focus upon item's selection mode."),
|
2012-11-25 22:32:53 -08:00
|
|
|
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_GENLIST_BASE_ID, op_desc, ELM_OBJ_GENLIST_SUB_ID_LAST),
|
|
|
|
NULL,
|
|
|
|
sizeof(Elm_Genlist_Smart_Data),
|
|
|
|
_class_constructor,
|
|
|
|
NULL
|
|
|
|
};
|
|
|
|
|
2014-03-17 04:44:40 -07:00
|
|
|
EO_DEFINE_CLASS(elm_obj_genlist_class_get, &class_desc, ELM_OBJ_LAYOUT_CLASS, ELM_INTERFACE_SCROLLABLE_CLASS, EVAS_SMART_CLICKABLE_INTERFACE, NULL);
|