2011-04-22 06:20:06 -07:00
|
|
|
#include <assert.h>
|
|
|
|
|
2009-02-09 03:23:59 -08:00
|
|
|
#include <Elementary.h>
|
2010-09-27 11:18:37 -07:00
|
|
|
#include <Elementary_Cursor.h>
|
2009-02-09 03:23:59 -08:00
|
|
|
#include "elm_priv.h"
|
|
|
|
|
2010-12-07 11:18:14 -08:00
|
|
|
#define SWIPE_MOVES 12
|
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
|
2010-10-15 04:24:46 -07:00
|
|
|
|
2009-02-09 03:23:59 -08:00
|
|
|
typedef struct _Widget_Data Widget_Data;
|
2010-12-07 11:18:14 -08:00
|
|
|
typedef struct _Item_Block Item_Block;
|
|
|
|
typedef struct _Pan Pan;
|
|
|
|
typedef struct _Item_Cache Item_Cache;
|
2009-02-09 03:23:59 -08:00
|
|
|
|
|
|
|
struct _Widget_Data
|
|
|
|
{
|
2010-12-07 11:18:14 -08:00
|
|
|
Evas_Object *obj, *scr, *pan_smart;
|
|
|
|
Eina_Inlist *items, *blocks;
|
2011-01-05 21:13:11 -08:00
|
|
|
Eina_List *group_items;
|
2010-12-07 11:18:14 -08:00
|
|
|
Pan *pan;
|
2011-06-01 20:10:11 -07:00
|
|
|
Evas_Coord pan_x, pan_y, old_pan_y, w, h, minw, minh, realminw, prev_viewport_w;
|
2010-12-07 11:18:14 -08:00
|
|
|
Ecore_Job *calc_job, *update_job;
|
2011-04-27 03:17:26 -07:00
|
|
|
Ecore_Idle_Enterer *queue_idle_enterer;
|
|
|
|
Ecore_Idler *must_recalc_idler;
|
2010-12-07 11:18:14 -08:00
|
|
|
Eina_List *queue, *selected;
|
2011-06-14 02:18:54 -07:00
|
|
|
Elm_Genlist_Item *show_item, *last_selected_item, *anchor_item, *mode_item, *reorder_it, *reorder_rel, *expanded_item;
|
2010-12-07 11:18:14 -08:00
|
|
|
Eina_Inlist *item_cache;
|
2011-06-01 20:10:11 -07:00
|
|
|
Evas_Coord anchor_y, reorder_start_y;
|
2010-12-07 11:18:14 -08:00
|
|
|
Elm_List_Mode mode;
|
2011-04-21 05:05:02 -07:00
|
|
|
Ecore_Timer *multi_timer, *scr_hold_timer;
|
2011-06-03 18:52:08 -07:00
|
|
|
Ecore_Animator *reorder_move_animator;
|
2011-04-21 05:05:02 -07:00
|
|
|
const char *mode_type;
|
2011-06-01 20:10:11 -07:00
|
|
|
unsigned int start_time;
|
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
|
|
|
Evas_Coord prev_x, prev_y, prev_mx, prev_my;
|
|
|
|
Evas_Coord cur_x, cur_y, cur_mx, cur_my;
|
|
|
|
Eina_Bool mouse_down : 1;
|
|
|
|
Eina_Bool multi_down : 1;
|
|
|
|
Eina_Bool multi_timeout : 1;
|
|
|
|
Eina_Bool multitouched : 1;
|
2010-12-07 11:18:14 -08:00
|
|
|
Eina_Bool on_hold : 1;
|
|
|
|
Eina_Bool multi : 1;
|
|
|
|
Eina_Bool always_select : 1;
|
|
|
|
Eina_Bool longpressed : 1;
|
|
|
|
Eina_Bool wasselected : 1;
|
|
|
|
Eina_Bool no_select : 1;
|
|
|
|
Eina_Bool bring_in : 1;
|
|
|
|
Eina_Bool compress : 1;
|
|
|
|
Eina_Bool height_for_width : 1;
|
|
|
|
Eina_Bool homogeneous : 1;
|
|
|
|
Eina_Bool clear_me : 1;
|
|
|
|
Eina_Bool swipe : 1;
|
2011-06-01 20:10:11 -07:00
|
|
|
Eina_Bool reorder_mode : 1;
|
|
|
|
Eina_Bool reorder_pan_move : 1;
|
2011-06-14 02:18:54 -07:00
|
|
|
Eina_Bool auto_scroll_enabled : 1;
|
2010-12-07 11:18:14 -08:00
|
|
|
struct
|
|
|
|
{
|
|
|
|
Evas_Coord x, y;
|
2010-10-15 04:24:46 -07:00
|
|
|
} history[SWIPE_MOVES];
|
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
|
|
|
int multi_device;
|
2010-12-07 11:18:14 -08:00
|
|
|
int item_cache_count;
|
|
|
|
int item_cache_max;
|
|
|
|
int movements;
|
|
|
|
int walking;
|
|
|
|
int item_width;
|
|
|
|
int item_height;
|
2011-03-29 02:28:09 -07:00
|
|
|
int group_item_width;
|
|
|
|
int group_item_height;
|
2010-12-07 11:18:14 -08:00
|
|
|
int max_items_per_block;
|
|
|
|
double longpress_timeout;
|
2009-02-09 03:23:59 -08:00
|
|
|
};
|
|
|
|
|
2009-02-10 03:57:47 -08:00
|
|
|
struct _Item_Block
|
|
|
|
{
|
2009-02-25 08:22:29 -08:00
|
|
|
EINA_INLIST;
|
2010-12-07 11:18:14 -08:00
|
|
|
int count;
|
|
|
|
int num;
|
2011-06-01 20:10:11 -07:00
|
|
|
int reorder_offset;
|
2009-02-11 03:49:43 -08:00
|
|
|
Widget_Data *wd;
|
2010-12-07 11:18:14 -08:00
|
|
|
Eina_List *items;
|
|
|
|
Evas_Coord x, y, w, h, minw, minh;
|
|
|
|
Eina_Bool want_unrealize : 1;
|
|
|
|
Eina_Bool realized : 1;
|
|
|
|
Eina_Bool changed : 1;
|
|
|
|
Eina_Bool updateme : 1;
|
|
|
|
Eina_Bool showme : 1;
|
|
|
|
Eina_Bool must_recalc : 1;
|
2009-02-10 03:57:47 -08:00
|
|
|
};
|
|
|
|
|
2009-02-25 07:54:26 -08:00
|
|
|
struct _Elm_Genlist_Item
|
2009-02-10 03:57:47 -08:00
|
|
|
{
|
2010-12-07 11:18:14 -08:00
|
|
|
Elm_Widget_Item base;
|
2009-02-25 08:22:29 -08:00
|
|
|
EINA_INLIST;
|
2010-12-07 11:18:14 -08:00
|
|
|
Widget_Data *wd;
|
|
|
|
Item_Block *block;
|
|
|
|
Eina_List *items;
|
|
|
|
Evas_Coord x, y, w, h, minw, minh;
|
2009-02-10 03:57:47 -08:00
|
|
|
const Elm_Genlist_Item_Class *itc;
|
2010-12-07 11:18:14 -08:00
|
|
|
Elm_Genlist_Item *parent;
|
2011-01-05 21:13:11 -08:00
|
|
|
Elm_Genlist_Item *group_item;
|
2010-12-07 11:18:14 -08:00
|
|
|
Elm_Genlist_Item_Flags flags;
|
|
|
|
struct
|
2011-04-01 09:33:58 -07:00
|
|
|
{
|
|
|
|
Evas_Smart_Cb func;
|
|
|
|
const void *data;
|
|
|
|
} func;
|
2009-09-26 11:24:06 -07:00
|
|
|
|
2011-04-01 09:33:58 -07:00
|
|
|
Evas_Object *spacer;
|
|
|
|
Eina_List *labels, *icons, *states, *icon_objs;
|
2011-04-21 04:47:36 -07:00
|
|
|
Eina_List *mode_labels, *mode_icons, *mode_states, *mode_icon_objs;
|
2011-04-01 09:33:58 -07:00
|
|
|
Ecore_Timer *long_timer;
|
|
|
|
Ecore_Timer *swipe_timer;
|
|
|
|
Evas_Coord dx, dy;
|
2011-06-28 00:13:28 -07:00
|
|
|
Evas_Coord scrl_x, scrl_y, old_scrl_y;
|
2009-09-23 15:56:47 -07:00
|
|
|
|
2011-04-01 09:33:58 -07:00
|
|
|
Elm_Genlist_Item *rel;
|
2011-04-21 04:47:36 -07:00
|
|
|
Evas_Object *mode_view;
|
2010-09-27 11:18:37 -07:00
|
|
|
|
2010-12-07 11:18:14 -08:00
|
|
|
struct
|
2011-04-01 09:33:58 -07:00
|
|
|
{
|
|
|
|
const void *data;
|
|
|
|
Elm_Tooltip_Item_Content_Cb content_cb;
|
|
|
|
Evas_Smart_Cb del_cb;
|
|
|
|
const char *style;
|
2011-07-27 19:22:37 -07:00
|
|
|
Eina_Bool free_size : 1;
|
2011-04-01 09:33:58 -07:00
|
|
|
} tooltip;
|
|
|
|
|
|
|
|
const char *mouse_cursor;
|
|
|
|
|
|
|
|
int relcount;
|
|
|
|
int walking;
|
|
|
|
int expanded_depth;
|
|
|
|
int order_num_in;
|
|
|
|
|
|
|
|
Eina_Bool before : 1;
|
|
|
|
|
|
|
|
Eina_Bool want_unrealize : 1;
|
|
|
|
Eina_Bool want_realize : 1;
|
|
|
|
Eina_Bool realized : 1;
|
|
|
|
Eina_Bool selected : 1;
|
|
|
|
Eina_Bool highlighted : 1;
|
|
|
|
Eina_Bool expanded : 1;
|
|
|
|
Eina_Bool disabled : 1;
|
|
|
|
Eina_Bool display_only : 1;
|
|
|
|
Eina_Bool mincalcd : 1;
|
|
|
|
Eina_Bool queued : 1;
|
|
|
|
Eina_Bool showme : 1;
|
|
|
|
Eina_Bool delete_me : 1;
|
|
|
|
Eina_Bool down : 1;
|
|
|
|
Eina_Bool dragging : 1;
|
|
|
|
Eina_Bool updateme : 1;
|
|
|
|
Eina_Bool nocache : 1;
|
2011-04-22 02:56:22 -07:00
|
|
|
Eina_Bool stacking_even : 1;
|
|
|
|
Eina_Bool nostacking : 1;
|
2011-06-01 20:10:11 -07:00
|
|
|
Eina_Bool move_effect_enabled : 1;
|
2009-02-11 03:49:43 -08:00
|
|
|
};
|
|
|
|
|
2010-11-05 23:02:22 -07:00
|
|
|
struct _Item_Cache
|
|
|
|
{
|
2010-12-07 11:18:14 -08:00
|
|
|
EINA_INLIST;
|
|
|
|
|
|
|
|
Evas_Object *base_view, *spacer;
|
|
|
|
|
|
|
|
const char *item_style; // it->itc->item_style
|
|
|
|
Eina_Bool tree : 1; // it->flags & ELM_GENLIST_ITEM_SUBITEMS
|
|
|
|
Eina_Bool compress : 1; // it->wd->compress
|
|
|
|
|
|
|
|
Eina_Bool selected : 1; // it->selected
|
|
|
|
Eina_Bool disabled : 1; // it->disabled
|
|
|
|
Eina_Bool expanded : 1; // it->expanded
|
2010-11-05 23:02:22 -07:00
|
|
|
};
|
|
|
|
|
2010-12-07 11:18:14 -08:00
|
|
|
#define ELM_GENLIST_ITEM_FROM_INLIST(item) \
|
2011-04-01 09:33:58 -07:00
|
|
|
((item) ? EINA_INLIST_CONTAINER_GET(item, Elm_Genlist_Item) : NULL)
|
2010-09-09 18:04:19 -07:00
|
|
|
|
2009-03-12 22:50:38 -07:00
|
|
|
struct _Pan
|
|
|
|
{
|
2009-02-11 03:49:43 -08:00
|
|
|
Evas_Object_Smart_Clipped_Data __clipped_data;
|
2010-12-07 11:18:14 -08:00
|
|
|
Widget_Data *wd;
|
|
|
|
Ecore_Job *resize_job;
|
2009-02-10 03:57:47 -08:00
|
|
|
};
|
|
|
|
|
2010-03-08 22:15:39 -08:00
|
|
|
static const char *widtype = NULL;
|
2010-12-07 11:18:14 -08:00
|
|
|
static void _item_cache_zero(Widget_Data *wd);
|
|
|
|
static void _del_hook(Evas_Object *obj);
|
2011-03-22 00:54:24 -07:00
|
|
|
static void _mirrored_set(Evas_Object *obj,
|
|
|
|
Eina_Bool rtl);
|
2010-12-07 11:18:14 -08:00
|
|
|
static void _theme_hook(Evas_Object *obj);
|
2011-03-22 00:54:24 -07:00
|
|
|
static void _show_region_hook(void *data,
|
|
|
|
Evas_Object *obj);
|
2010-12-07 11:18:14 -08:00
|
|
|
static void _sizing_eval(Evas_Object *obj);
|
2011-07-14 00:22:04 -07:00
|
|
|
static void _item_realize(Elm_Genlist_Item *it,
|
|
|
|
int in,
|
|
|
|
Eina_Bool calc);
|
2011-06-03 18:52:08 -07:00
|
|
|
static void _item_unrealize(Elm_Genlist_Item *it,
|
|
|
|
Eina_Bool calc);
|
2010-12-07 11:18:14 -08:00
|
|
|
static void _item_block_unrealize(Item_Block *itb);
|
|
|
|
static void _calc_job(void *data);
|
|
|
|
static void _on_focus_hook(void *data,
|
|
|
|
Evas_Object *obj);
|
2010-10-05 12:09:55 -07:00
|
|
|
static Eina_Bool _item_multi_select_up(Widget_Data *wd);
|
|
|
|
static Eina_Bool _item_multi_select_down(Widget_Data *wd);
|
|
|
|
static Eina_Bool _item_single_select_up(Widget_Data *wd);
|
|
|
|
static Eina_Bool _item_single_select_down(Widget_Data *wd);
|
2010-12-07 11:18:14 -08:00
|
|
|
static Eina_Bool _event_hook(Evas_Object *obj,
|
|
|
|
Evas_Object *src,
|
|
|
|
Evas_Callback_Type type,
|
|
|
|
void *event_info);
|
2011-04-06 17:58:29 -07:00
|
|
|
static void _signal_emit_hook(Evas_Object *obj,
|
|
|
|
const char *emission,
|
|
|
|
const char *source);
|
2010-10-27 07:38:54 -07:00
|
|
|
static Eina_Bool _deselect_all_items(Widget_Data *wd);
|
2010-12-07 11:18:14 -08:00
|
|
|
static void _pan_calculate(Evas_Object *obj);
|
2011-06-03 18:52:08 -07:00
|
|
|
static void _item_position(Elm_Genlist_Item *it,
|
|
|
|
Evas_Object *obj,
|
|
|
|
Evas_Coord it_x,
|
|
|
|
Evas_Coord it_y);
|
2011-04-21 04:47:36 -07:00
|
|
|
static void _mode_item_realize(Elm_Genlist_Item *it);
|
|
|
|
static void _mode_item_unrealize(Elm_Genlist_Item *it);
|
|
|
|
static void _item_mode_set(Elm_Genlist_Item *it);
|
|
|
|
static void _item_mode_unset(Widget_Data *wd);
|
2011-06-01 20:10:11 -07:00
|
|
|
static void _group_items_recalc(void *data);
|
2011-06-03 18:52:08 -07:00
|
|
|
static void _item_move_after(Elm_Genlist_Item *it,
|
|
|
|
Elm_Genlist_Item *after);
|
|
|
|
static void _item_move_before(Elm_Genlist_Item *it,
|
|
|
|
Elm_Genlist_Item *before);
|
2011-06-14 02:18:54 -07:00
|
|
|
static void _item_auto_scroll(Widget_Data *wd);
|
2009-07-06 23:46:51 -07:00
|
|
|
|
2010-03-09 22:46:28 -08:00
|
|
|
static Evas_Smart_Class _pan_sc = EVAS_SMART_CLASS_INIT_VERSION;
|
2009-02-11 03:49:43 -08:00
|
|
|
|
2011-07-25 18:49:24 -07:00
|
|
|
static const char SIG_ACTIVATED[] = "activated";
|
2011-05-06 17:30:39 -07:00
|
|
|
static const char SIG_CLICKED_DOUBLE[] = "clicked,double";
|
|
|
|
static const char SIG_SELECTED[] = "selected";
|
|
|
|
static const char SIG_UNSELECTED[] = "unselected";
|
|
|
|
static const char SIG_EXPANDED[] = "expanded";
|
|
|
|
static const char SIG_CONTRACTED[] = "contracted";
|
|
|
|
static const char SIG_EXPAND_REQUEST[] = "expand,request";
|
|
|
|
static const char SIG_CONTRACT_REQUEST[] = "contract,request";
|
|
|
|
static const char SIG_REALIZED[] = "realized";
|
|
|
|
static const char SIG_UNREALIZED[] = "unrealized";
|
|
|
|
static const char SIG_DRAG_START_UP[] = "drag,start,up";
|
|
|
|
static const char SIG_DRAG_START_DOWN[] = "drag,start,down";
|
|
|
|
static const char SIG_DRAG_START_LEFT[] = "drag,start,left";
|
|
|
|
static const char SIG_DRAG_START_RIGHT[] = "drag,start,right";
|
|
|
|
static const char SIG_DRAG_STOP[] = "drag,stop";
|
|
|
|
static const char SIG_DRAG[] = "drag";
|
|
|
|
static const char SIG_LONGPRESSED[] = "longpressed";
|
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 const char SIG_SCROLL_ANIM_START[] = "scroll,anim,start";
|
|
|
|
static const char SIG_SCROLL_ANIM_STOP[] = "scroll,anim,stop";
|
|
|
|
static const char SIG_SCROLL_DRAG_START[] = "scroll,drag,start";
|
|
|
|
static const char SIG_SCROLL_DRAG_STOP[] = "scroll,drag,stop";
|
2011-05-06 17:30:39 -07:00
|
|
|
static const char SIG_SCROLL_EDGE_TOP[] = "scroll,edge,top";
|
|
|
|
static const char SIG_SCROLL_EDGE_BOTTOM[] = "scroll,edge,bottom";
|
|
|
|
static const char SIG_SCROLL_EDGE_LEFT[] = "scroll,edge,left";
|
|
|
|
static const char SIG_SCROLL_EDGE_RIGHT[] = "scroll,edge,right";
|
|
|
|
static const char SIG_MULTI_SWIPE_LEFT[] = "multi,swipe,left";
|
|
|
|
static const char SIG_MULTI_SWIPE_RIGHT[] = "multi,swipe,right";
|
|
|
|
static const char SIG_MULTI_SWIPE_UP[] = "multi,swipe,up";
|
|
|
|
static const char SIG_MULTI_SWIPE_DOWN[] = "multi,swipe,down";
|
|
|
|
static const char SIG_MULTI_PINCH_OUT[] = "multi,pinch,out";
|
|
|
|
static const char SIG_MULTI_PINCH_IN[] = "multi,pinch,in";
|
|
|
|
static const char SIG_SWIPE[] = "swipe";
|
|
|
|
|
|
|
|
static const Evas_Smart_Cb_Description _signals[] = {
|
|
|
|
{SIG_CLICKED_DOUBLE, ""},
|
2011-07-25 18:49:24 -07:00
|
|
|
{SIG_ACTIVATED, ""},
|
2011-05-06 17:30:39 -07:00
|
|
|
{SIG_SELECTED, ""},
|
|
|
|
{SIG_UNSELECTED, ""},
|
|
|
|
{SIG_EXPANDED, ""},
|
|
|
|
{SIG_CONTRACTED, ""},
|
|
|
|
{SIG_EXPAND_REQUEST, ""},
|
|
|
|
{SIG_CONTRACT_REQUEST, ""},
|
|
|
|
{SIG_REALIZED, ""},
|
|
|
|
{SIG_UNREALIZED, ""},
|
|
|
|
{SIG_DRAG_START_UP, ""},
|
|
|
|
{SIG_DRAG_START_DOWN, ""},
|
|
|
|
{SIG_DRAG_START_LEFT, ""},
|
|
|
|
{SIG_DRAG_START_RIGHT, ""},
|
|
|
|
{SIG_DRAG_STOP, ""},
|
|
|
|
{SIG_DRAG, ""},
|
|
|
|
{SIG_LONGPRESSED, ""},
|
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
|
|
|
{SIG_SCROLL_ANIM_START, ""},
|
|
|
|
{SIG_SCROLL_ANIM_STOP, ""},
|
|
|
|
{SIG_SCROLL_DRAG_START, ""},
|
|
|
|
{SIG_SCROLL_DRAG_STOP, ""},
|
2011-05-06 17:30:39 -07:00
|
|
|
{SIG_SCROLL_EDGE_TOP, ""},
|
|
|
|
{SIG_SCROLL_EDGE_BOTTOM, ""},
|
|
|
|
{SIG_SCROLL_EDGE_LEFT, ""},
|
|
|
|
{SIG_SCROLL_EDGE_RIGHT, ""},
|
|
|
|
{SIG_MULTI_SWIPE_LEFT, ""},
|
|
|
|
{SIG_MULTI_SWIPE_RIGHT, ""},
|
|
|
|
{SIG_MULTI_SWIPE_UP, ""},
|
|
|
|
{SIG_MULTI_SWIPE_DOWN, ""},
|
|
|
|
{SIG_MULTI_PINCH_OUT, ""},
|
|
|
|
{SIG_MULTI_PINCH_IN, ""},
|
|
|
|
{SIG_SWIPE, ""},
|
|
|
|
{NULL, NULL}
|
|
|
|
};
|
|
|
|
|
2011-05-25 07:58:39 -07:00
|
|
|
static Eina_Compare_Cb _elm_genlist_item_compare_cb;
|
2011-06-25 16:20:22 -07:00
|
|
|
static Eina_Compare_Cb _elm_genlist_item_compare_data_cb;
|
2011-05-25 07:58:39 -07:00
|
|
|
|
2010-10-01 12:03:12 -07:00
|
|
|
static Eina_Bool
|
2010-12-07 11:18:14 -08:00
|
|
|
_event_hook(Evas_Object *obj,
|
2011-04-01 09:33:58 -07:00
|
|
|
Evas_Object *src __UNUSED__,
|
2010-12-07 11:18:14 -08:00
|
|
|
Evas_Callback_Type type,
|
|
|
|
void *event_info)
|
2010-10-01 12:03:12 -07:00
|
|
|
{
|
|
|
|
if (type != EVAS_CALLBACK_KEY_DOWN) return EINA_FALSE;
|
|
|
|
Evas_Event_Key_Down *ev = event_info;
|
|
|
|
Widget_Data *wd = elm_widget_data_get(obj);
|
|
|
|
if (!wd) return EINA_FALSE;
|
2010-10-27 07:38:57 -07:00
|
|
|
if (!wd->items) return EINA_FALSE;
|
2010-10-01 12:03:12 -07:00
|
|
|
if (ev->event_flags & EVAS_EVENT_FLAG_ON_HOLD) return EINA_FALSE;
|
|
|
|
if (elm_widget_disabled_get(obj)) return EINA_FALSE;
|
|
|
|
|
|
|
|
Elm_Genlist_Item *it = NULL;
|
|
|
|
Evas_Coord x = 0;
|
|
|
|
Evas_Coord y = 0;
|
|
|
|
Evas_Coord step_x = 0;
|
|
|
|
Evas_Coord step_y = 0;
|
|
|
|
Evas_Coord v_w = 0;
|
|
|
|
Evas_Coord v_h = 0;
|
|
|
|
Evas_Coord page_x = 0;
|
|
|
|
Evas_Coord page_y = 0;
|
|
|
|
|
|
|
|
elm_smart_scroller_child_pos_get(wd->scr, &x, &y);
|
|
|
|
elm_smart_scroller_step_size_get(wd->scr, &step_x, &step_y);
|
|
|
|
elm_smart_scroller_page_size_get(wd->scr, &page_x, &page_y);
|
|
|
|
elm_smart_scroller_child_viewport_size_get(wd->scr, &v_w, &v_h);
|
|
|
|
|
2010-10-22 14:41:22 -07:00
|
|
|
if ((!strcmp(ev->keyname, "Left")) || (!strcmp(ev->keyname, "KP_Left")))
|
2010-10-01 12:03:12 -07:00
|
|
|
{
|
|
|
|
x -= step_x;
|
|
|
|
}
|
2010-12-07 11:18:14 -08:00
|
|
|
else if ((!strcmp(ev->keyname, "Right")) ||
|
|
|
|
(!strcmp(ev->keyname, "KP_Right")))
|
2010-10-01 12:03:12 -07:00
|
|
|
{
|
|
|
|
x += step_x;
|
|
|
|
}
|
2010-12-07 11:18:14 -08:00
|
|
|
else if ((!strcmp(ev->keyname, "Up")) || (!strcmp(ev->keyname, "KP_Up")))
|
2010-10-01 12:03:12 -07:00
|
|
|
{
|
2010-10-22 14:41:22 -07:00
|
|
|
if (((evas_key_modifier_is_set(ev->modifiers, "Shift")) &&
|
2010-12-07 11:18:14 -08:00
|
|
|
(_item_multi_select_up(wd)))
|
2010-10-22 14:41:22 -07:00
|
|
|
|| (_item_single_select_up(wd)))
|
2010-10-05 12:09:55 -07:00
|
|
|
{
|
|
|
|
ev->event_flags |= EVAS_EVENT_FLAG_ON_HOLD;
|
|
|
|
return EINA_TRUE;
|
|
|
|
}
|
|
|
|
else
|
|
|
|
y -= step_y;
|
2010-10-01 12:03:12 -07:00
|
|
|
}
|
2010-10-22 14:41:22 -07:00
|
|
|
else if ((!strcmp(ev->keyname, "Down")) || (!strcmp(ev->keyname, "KP_Down")))
|
2010-10-01 12:03:12 -07:00
|
|
|
{
|
2010-10-22 14:41:22 -07:00
|
|
|
if (((evas_key_modifier_is_set(ev->modifiers, "Shift")) &&
|
2010-12-07 11:18:14 -08:00
|
|
|
(_item_multi_select_down(wd)))
|
2010-10-22 14:41:22 -07:00
|
|
|
|| (_item_single_select_down(wd)))
|
2010-10-05 12:09:55 -07:00
|
|
|
{
|
|
|
|
ev->event_flags |= EVAS_EVENT_FLAG_ON_HOLD;
|
|
|
|
return EINA_TRUE;
|
|
|
|
}
|
|
|
|
else
|
|
|
|
y += step_y;
|
2010-10-01 12:03:12 -07:00
|
|
|
}
|
2010-11-29 05:56:33 -08:00
|
|
|
else if ((!strcmp(ev->keyname, "Home")) ||
|
|
|
|
(!strcmp(ev->keyname, "KP_Home")))
|
2010-10-01 12:03:12 -07:00
|
|
|
{
|
|
|
|
it = elm_genlist_first_item_get(obj);
|
|
|
|
elm_genlist_item_bring_in(it);
|
|
|
|
ev->event_flags |= EVAS_EVENT_FLAG_ON_HOLD;
|
|
|
|
return EINA_TRUE;
|
|
|
|
}
|
2010-11-29 05:56:33 -08:00
|
|
|
else if ((!strcmp(ev->keyname, "End")) ||
|
|
|
|
(!strcmp(ev->keyname, "KP_End")))
|
2010-10-01 12:03:12 -07:00
|
|
|
{
|
|
|
|
it = elm_genlist_last_item_get(obj);
|
|
|
|
elm_genlist_item_bring_in(it);
|
|
|
|
ev->event_flags |= EVAS_EVENT_FLAG_ON_HOLD;
|
|
|
|
return EINA_TRUE;
|
|
|
|
}
|
2010-11-29 05:56:33 -08:00
|
|
|
else if ((!strcmp(ev->keyname, "Prior")) ||
|
|
|
|
(!strcmp(ev->keyname, "KP_Prior")))
|
2010-10-01 12:03:12 -07:00
|
|
|
{
|
|
|
|
if (page_y < 0)
|
|
|
|
y -= -(page_y * v_h) / 100;
|
|
|
|
else
|
|
|
|
y -= page_y;
|
|
|
|
}
|
2010-11-29 05:56:33 -08:00
|
|
|
else if ((!strcmp(ev->keyname, "Next")) ||
|
|
|
|
(!strcmp(ev->keyname, "KP_Next")))
|
2010-10-01 12:03:12 -07:00
|
|
|
{
|
|
|
|
if (page_y < 0)
|
|
|
|
y += -(page_y * v_h) / 100;
|
|
|
|
else
|
|
|
|
y += page_y;
|
|
|
|
}
|
2011-06-01 22:40:30 -07:00
|
|
|
else if (((!strcmp(ev->keyname, "Return")) ||
|
2010-11-29 05:56:33 -08:00
|
|
|
(!strcmp(ev->keyname, "KP_Enter")) ||
|
|
|
|
(!strcmp(ev->keyname, "space")))
|
2010-10-22 14:41:22 -07:00
|
|
|
&& (!wd->multi) && (wd->selected))
|
2010-10-05 12:10:11 -07:00
|
|
|
{
|
2011-04-22 02:56:22 -07:00
|
|
|
it = elm_genlist_selected_item_get(obj);
|
2010-10-05 12:10:11 -07:00
|
|
|
elm_genlist_item_expanded_set(it,
|
|
|
|
!elm_genlist_item_expanded_get(it));
|
2011-07-25 18:49:24 -07:00
|
|
|
evas_object_smart_callback_call(it->base.widget, SIG_ACTIVATED, it);
|
2010-10-05 12:10:11 -07:00
|
|
|
}
|
2010-10-27 07:38:54 -07:00
|
|
|
else if (!strcmp(ev->keyname, "Escape"))
|
|
|
|
{
|
2010-12-07 11:18:14 -08:00
|
|
|
if (!_deselect_all_items(wd)) return EINA_FALSE;
|
|
|
|
ev->event_flags |= EVAS_EVENT_FLAG_ON_HOLD;
|
|
|
|
return EINA_TRUE;
|
2010-10-27 07:38:54 -07:00
|
|
|
}
|
2010-10-01 12:03:12 -07:00
|
|
|
else return EINA_FALSE;
|
|
|
|
|
|
|
|
ev->event_flags |= EVAS_EVENT_FLAG_ON_HOLD;
|
|
|
|
elm_smart_scroller_child_pos_set(wd->scr, x, y);
|
|
|
|
return EINA_TRUE;
|
|
|
|
}
|
|
|
|
|
2010-10-27 07:38:54 -07:00
|
|
|
static Eina_Bool
|
|
|
|
_deselect_all_items(Widget_Data *wd)
|
|
|
|
{
|
|
|
|
if (!wd->selected) return EINA_FALSE;
|
2011-06-01 22:40:30 -07:00
|
|
|
while (wd->selected)
|
2010-10-27 07:38:54 -07:00
|
|
|
elm_genlist_item_selected_set(wd->selected->data, EINA_FALSE);
|
|
|
|
|
|
|
|
return EINA_TRUE;
|
|
|
|
}
|
|
|
|
|
2010-10-05 12:09:55 -07:00
|
|
|
static Eina_Bool
|
|
|
|
_item_multi_select_up(Widget_Data *wd)
|
|
|
|
{
|
|
|
|
if (!wd->selected) return EINA_FALSE;
|
|
|
|
if (!wd->multi) return EINA_FALSE;
|
|
|
|
|
|
|
|
Elm_Genlist_Item *prev = elm_genlist_item_prev_get(wd->last_selected_item);
|
|
|
|
if (!prev) return EINA_TRUE;
|
|
|
|
|
|
|
|
if (elm_genlist_item_selected_get(prev))
|
|
|
|
{
|
|
|
|
elm_genlist_item_selected_set(wd->last_selected_item, EINA_FALSE);
|
|
|
|
wd->last_selected_item = prev;
|
|
|
|
elm_genlist_item_show(wd->last_selected_item);
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
elm_genlist_item_selected_set(prev, EINA_TRUE);
|
|
|
|
elm_genlist_item_show(prev);
|
|
|
|
}
|
|
|
|
return EINA_TRUE;
|
|
|
|
}
|
|
|
|
|
|
|
|
static Eina_Bool
|
|
|
|
_item_multi_select_down(Widget_Data *wd)
|
|
|
|
{
|
|
|
|
if (!wd->selected) return EINA_FALSE;
|
|
|
|
if (!wd->multi) return EINA_FALSE;
|
|
|
|
|
|
|
|
Elm_Genlist_Item *next = elm_genlist_item_next_get(wd->last_selected_item);
|
|
|
|
if (!next) return EINA_TRUE;
|
|
|
|
|
|
|
|
if (elm_genlist_item_selected_get(next))
|
|
|
|
{
|
|
|
|
elm_genlist_item_selected_set(wd->last_selected_item, EINA_FALSE);
|
|
|
|
wd->last_selected_item = next;
|
|
|
|
elm_genlist_item_show(wd->last_selected_item);
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
elm_genlist_item_selected_set(next, EINA_TRUE);
|
|
|
|
elm_genlist_item_show(next);
|
|
|
|
}
|
|
|
|
return EINA_TRUE;
|
|
|
|
}
|
|
|
|
|
|
|
|
static Eina_Bool
|
|
|
|
_item_single_select_up(Widget_Data *wd)
|
|
|
|
{
|
2010-10-27 07:38:57 -07:00
|
|
|
Elm_Genlist_Item *prev;
|
|
|
|
if (!wd->selected)
|
|
|
|
{
|
|
|
|
prev = ELM_GENLIST_ITEM_FROM_INLIST(wd->items->last);
|
|
|
|
while ((prev) && (prev->delete_me))
|
|
|
|
prev = ELM_GENLIST_ITEM_FROM_INLIST(EINA_INLIST_GET(prev)->prev);
|
|
|
|
}
|
|
|
|
else prev = elm_genlist_item_prev_get(wd->last_selected_item);
|
|
|
|
|
2010-10-05 12:09:55 -07:00
|
|
|
if (!prev) return EINA_FALSE;
|
|
|
|
|
2010-10-27 07:38:54 -07:00
|
|
|
_deselect_all_items(wd);
|
2010-10-05 12:09:55 -07:00
|
|
|
|
|
|
|
elm_genlist_item_selected_set(prev, EINA_TRUE);
|
|
|
|
elm_genlist_item_show(prev);
|
|
|
|
return EINA_TRUE;
|
|
|
|
}
|
|
|
|
|
|
|
|
static Eina_Bool
|
|
|
|
_item_single_select_down(Widget_Data *wd)
|
|
|
|
{
|
2010-10-27 07:38:57 -07:00
|
|
|
Elm_Genlist_Item *next;
|
|
|
|
if (!wd->selected)
|
|
|
|
{
|
|
|
|
next = ELM_GENLIST_ITEM_FROM_INLIST(wd->items);
|
|
|
|
while ((next) && (next->delete_me))
|
|
|
|
next = ELM_GENLIST_ITEM_FROM_INLIST(EINA_INLIST_GET(next)->next);
|
|
|
|
}
|
|
|
|
else next = elm_genlist_item_next_get(wd->last_selected_item);
|
|
|
|
|
2010-10-05 12:09:55 -07:00
|
|
|
if (!next) return EINA_FALSE;
|
|
|
|
|
2010-10-27 07:38:54 -07:00
|
|
|
_deselect_all_items(wd);
|
2010-10-05 12:09:55 -07:00
|
|
|
|
|
|
|
elm_genlist_item_selected_set(next, EINA_TRUE);
|
|
|
|
elm_genlist_item_show(next);
|
|
|
|
return EINA_TRUE;
|
|
|
|
}
|
|
|
|
|
2010-10-01 12:03:12 -07:00
|
|
|
static void
|
2011-04-01 09:33:58 -07:00
|
|
|
_on_focus_hook(void *data __UNUSED__,
|
2010-12-07 11:18:14 -08:00
|
|
|
Evas_Object *obj)
|
2010-10-01 12:03:12 -07:00
|
|
|
{
|
|
|
|
Widget_Data *wd = elm_widget_data_get(obj);
|
|
|
|
if (!wd) return;
|
|
|
|
if (elm_widget_focus_get(obj))
|
|
|
|
{
|
2011-06-14 22:30:23 -07:00
|
|
|
elm_object_signal_emit(wd->obj, "elm,action,focus", "elm");
|
2010-10-01 12:03:12 -07:00
|
|
|
evas_object_focus_set(wd->obj, EINA_TRUE);
|
2010-10-22 14:41:22 -07:00
|
|
|
if ((wd->selected) && (!wd->last_selected_item))
|
2010-10-05 12:09:55 -07:00
|
|
|
wd->last_selected_item = eina_list_data_get(wd->selected);
|
2010-10-01 12:03:12 -07:00
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
2011-06-14 22:30:23 -07:00
|
|
|
elm_object_signal_emit(wd->obj, "elm,action,unfocus", "elm");
|
2010-10-01 12:03:12 -07:00
|
|
|
evas_object_focus_set(wd->obj, EINA_FALSE);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2009-02-09 03:23:59 -08:00
|
|
|
static void
|
|
|
|
_del_hook(Evas_Object *obj)
|
|
|
|
{
|
|
|
|
Widget_Data *wd = elm_widget_data_get(obj);
|
2010-03-09 06:42:41 -08:00
|
|
|
if (!wd) return;
|
2010-11-05 23:02:22 -07:00
|
|
|
_item_cache_zero(wd);
|
2009-09-11 06:43:02 -07:00
|
|
|
if (wd->calc_job) ecore_job_del(wd->calc_job);
|
2009-09-13 19:53:03 -07:00
|
|
|
if (wd->update_job) ecore_job_del(wd->update_job);
|
2011-04-27 03:17:26 -07:00
|
|
|
if (wd->queue_idle_enterer) ecore_idle_enterer_del(wd->queue_idle_enterer);
|
2010-11-20 00:43:43 -08:00
|
|
|
if (wd->must_recalc_idler) ecore_idler_del(wd->must_recalc_idler);
|
2011-01-08 07:12:15 -08:00
|
|
|
if (wd->multi_timer) ecore_timer_del(wd->multi_timer);
|
2011-04-21 04:47:36 -07:00
|
|
|
if (wd->mode_type) eina_stringshare_del(wd->mode_type);
|
|
|
|
if (wd->scr_hold_timer) ecore_timer_del(wd->scr_hold_timer);
|
2009-02-09 03:23:59 -08:00
|
|
|
free(wd);
|
|
|
|
}
|
|
|
|
|
2009-11-13 14:22:05 -08:00
|
|
|
static void
|
|
|
|
_del_pre_hook(Evas_Object *obj)
|
|
|
|
{
|
|
|
|
Widget_Data *wd = elm_widget_data_get(obj);
|
2010-03-09 06:42:41 -08:00
|
|
|
if (!wd) return;
|
2009-11-13 14:22:05 -08:00
|
|
|
evas_object_del(wd->pan_smart);
|
|
|
|
wd->pan_smart = NULL;
|
|
|
|
elm_genlist_clear(obj);
|
|
|
|
}
|
|
|
|
|
2011-02-08 04:08:28 -08:00
|
|
|
static void
|
2011-03-22 00:54:24 -07:00
|
|
|
_mirrored_set(Evas_Object *obj,
|
|
|
|
Eina_Bool rtl)
|
2011-02-08 04:08:28 -08:00
|
|
|
{
|
|
|
|
Widget_Data *wd = elm_widget_data_get(obj);
|
|
|
|
if (!wd) return;
|
|
|
|
_item_cache_zero(wd);
|
|
|
|
elm_smart_scroller_mirrored_set(wd->scr, rtl);
|
|
|
|
}
|
|
|
|
|
2009-02-09 03:23:59 -08:00
|
|
|
static void
|
|
|
|
_theme_hook(Evas_Object *obj)
|
|
|
|
{
|
|
|
|
Widget_Data *wd = elm_widget_data_get(obj);
|
2009-02-25 08:22:29 -08:00
|
|
|
Item_Block *itb;
|
2010-03-09 06:42:41 -08:00
|
|
|
if (!wd) return;
|
2011-05-27 03:30:56 -07:00
|
|
|
evas_event_freeze(evas_object_evas_get(wd->obj));
|
2010-11-05 23:02:22 -07:00
|
|
|
_item_cache_zero(wd);
|
2011-02-09 08:14:02 -08:00
|
|
|
_elm_widget_mirrored_reload(obj);
|
2011-02-08 04:08:28 -08:00
|
|
|
_mirrored_set(obj, elm_widget_mirrored_get(obj));
|
2010-12-07 11:18:14 -08:00
|
|
|
elm_smart_scroller_object_theme_set(obj, wd->scr, "genlist", "base",
|
|
|
|
elm_widget_style_get(obj));
|
2011-04-19 06:40:25 -07:00
|
|
|
edje_object_scale_set(wd->scr, elm_widget_scale_get(obj) * _elm_config->scale);
|
2010-10-24 16:48:35 -07:00
|
|
|
wd->item_width = wd->item_height = 0;
|
2011-03-29 02:28:09 -07:00
|
|
|
wd->group_item_width = wd->group_item_height = 0;
|
2010-10-24 16:48:35 -07:00
|
|
|
wd->minw = wd->minh = wd->realminw = 0;
|
2009-02-25 08:22:29 -08:00
|
|
|
EINA_INLIST_FOREACH(wd->blocks, itb)
|
2011-03-22 00:54:24 -07:00
|
|
|
{
|
|
|
|
Eina_List *l;
|
|
|
|
Elm_Genlist_Item *it;
|
2010-10-15 04:51:15 -07:00
|
|
|
|
2011-03-22 00:54:24 -07:00
|
|
|
if (itb->realized) _item_block_unrealize(itb);
|
|
|
|
EINA_LIST_FOREACH(itb->items, l, it)
|
2011-04-01 09:33:58 -07:00
|
|
|
it->mincalcd = EINA_FALSE;
|
2009-02-25 08:22:29 -08:00
|
|
|
|
2011-03-22 00:54:24 -07:00
|
|
|
itb->changed = EINA_TRUE;
|
|
|
|
}
|
2009-02-18 05:13:10 -08:00
|
|
|
if (wd->calc_job) ecore_job_del(wd->calc_job);
|
|
|
|
wd->calc_job = ecore_job_add(_calc_job, wd);
|
2009-02-09 03:23:59 -08:00
|
|
|
_sizing_eval(obj);
|
2011-05-27 03:30:56 -07:00
|
|
|
evas_event_thaw(evas_object_evas_get(wd->obj));
|
|
|
|
evas_event_thaw_eval(evas_object_evas_get(wd->obj));
|
2009-02-09 03:23:59 -08:00
|
|
|
}
|
|
|
|
|
2011-02-13 02:28:55 -08:00
|
|
|
static void
|
2011-03-22 00:54:24 -07:00
|
|
|
_show_region_hook(void *data,
|
|
|
|
Evas_Object *obj)
|
2011-02-13 02:28:55 -08:00
|
|
|
{
|
2009-02-09 03:23:59 -08:00
|
|
|
Widget_Data *wd = elm_widget_data_get(data);
|
|
|
|
Evas_Coord x, y, w, h;
|
2010-03-09 06:42:41 -08:00
|
|
|
if (!wd) return;
|
2009-02-09 03:23:59 -08:00
|
|
|
elm_widget_show_region_get(obj, &x, &y, &w, &h);
|
2011-02-13 02:28:55 -08:00
|
|
|
//x & y are screen coordinates, Add with pan coordinates
|
|
|
|
x += wd->pan_x;
|
|
|
|
y += wd->pan_y;
|
2009-02-09 03:23:59 -08:00
|
|
|
elm_smart_scroller_child_region_show(wd->scr, x, y, w, h);
|
2011-02-13 02:28:55 -08:00
|
|
|
}
|
2009-02-09 03:23:59 -08:00
|
|
|
|
|
|
|
static void
|
|
|
|
_sizing_eval(Evas_Object *obj)
|
|
|
|
{
|
|
|
|
Widget_Data *wd = elm_widget_data_get(obj);
|
2009-03-12 22:50:38 -07:00
|
|
|
Evas_Coord minw = -1, minh = -1, maxw = -1, maxh = -1;
|
2010-03-09 06:42:41 -08:00
|
|
|
if (!wd) return;
|
2009-03-12 22:50:38 -07:00
|
|
|
evas_object_size_hint_min_get(wd->scr, &minw, &minh);
|
|
|
|
evas_object_size_hint_max_get(wd->scr, &maxw, &maxh);
|
|
|
|
minh = -1;
|
2010-11-20 00:43:43 -08:00
|
|
|
if (wd->height_for_width)
|
|
|
|
{
|
2010-12-07 11:18:14 -08:00
|
|
|
Evas_Coord vw, vh;
|
|
|
|
|
|
|
|
elm_smart_scroller_child_viewport_size_get(wd->scr, &vw, &vh);
|
|
|
|
if ((vw != 0) && (vw != wd->prev_viewport_w))
|
|
|
|
{
|
|
|
|
Item_Block *itb;
|
|
|
|
|
|
|
|
wd->prev_viewport_w = vw;
|
|
|
|
EINA_INLIST_FOREACH(wd->blocks, itb)
|
2011-03-22 00:54:24 -07:00
|
|
|
{
|
|
|
|
itb->must_recalc = EINA_TRUE;
|
|
|
|
}
|
2010-12-07 11:18:14 -08:00
|
|
|
if (wd->calc_job) ecore_job_del(wd->calc_job);
|
|
|
|
wd->calc_job = ecore_job_add(_calc_job, wd);
|
|
|
|
}
|
2010-11-20 00:43:43 -08:00
|
|
|
}
|
2010-09-28 01:46:08 -07:00
|
|
|
if (wd->mode == ELM_LIST_LIMIT)
|
2010-05-07 06:21:45 -07:00
|
|
|
{
|
2010-12-07 11:18:14 -08:00
|
|
|
Evas_Coord vmw, vmh, vw, vh;
|
2010-10-15 04:51:15 -07:00
|
|
|
|
2010-09-28 01:46:08 -07:00
|
|
|
minw = wd->realminw;
|
2010-05-07 06:21:45 -07:00
|
|
|
maxw = -1;
|
|
|
|
elm_smart_scroller_child_viewport_size_get(wd->scr, &vw, &vh);
|
|
|
|
if ((minw > 0) && (vw < minw)) vw = minw;
|
2010-12-07 11:18:14 -08:00
|
|
|
else if ((maxw > 0) && (vw > maxw))
|
|
|
|
vw = maxw;
|
2010-09-28 01:46:08 -07:00
|
|
|
edje_object_size_min_calc
|
2011-04-01 09:33:58 -07:00
|
|
|
(elm_smart_scroller_edje_object_get(wd->scr), &vmw, &vmh);
|
2010-05-07 06:21:45 -07:00
|
|
|
minw = vmw + minw;
|
|
|
|
}
|
2010-09-28 01:46:08 -07:00
|
|
|
else
|
|
|
|
{
|
2010-12-07 11:18:14 -08:00
|
|
|
Evas_Coord vmw, vmh;
|
2010-10-15 04:51:15 -07:00
|
|
|
|
2010-09-28 01:46:08 -07:00
|
|
|
edje_object_size_min_calc
|
2011-04-01 09:33:58 -07:00
|
|
|
(elm_smart_scroller_edje_object_get(wd->scr), &vmw, &vmh);
|
2010-09-28 01:46:08 -07:00
|
|
|
minw = vmw;
|
|
|
|
minh = vmh;
|
|
|
|
}
|
2009-03-12 22:50:38 -07:00
|
|
|
evas_object_size_hint_min_set(obj, minw, minh);
|
|
|
|
evas_object_size_hint_max_set(obj, maxw, maxh);
|
2009-02-09 03:23:59 -08:00
|
|
|
}
|
|
|
|
|
2011-04-06 07:46:39 -07:00
|
|
|
static void
|
2011-04-06 17:58:29 -07:00
|
|
|
_signal_emit_hook(Evas_Object *obj,
|
|
|
|
const char *emission,
|
|
|
|
const char *source)
|
2011-04-06 07:46:39 -07:00
|
|
|
{
|
|
|
|
Widget_Data *wd = elm_widget_data_get(obj);
|
|
|
|
edje_object_signal_emit(elm_smart_scroller_edje_object_get(wd->scr),
|
|
|
|
emission, source);
|
|
|
|
}
|
|
|
|
|
2009-02-16 23:50:35 -08:00
|
|
|
static void
|
2011-03-10 11:59:10 -08:00
|
|
|
_item_highlight(Elm_Genlist_Item *it)
|
2009-02-16 23:50:35 -08:00
|
|
|
{
|
2009-05-12 03:16:49 -07:00
|
|
|
const char *selectraise;
|
2011-04-21 04:47:36 -07:00
|
|
|
if ((it->wd->no_select) || (it->delete_me) || (it->highlighted) ||
|
|
|
|
(it->disabled) || (it->display_only) || (it->mode_view))
|
|
|
|
return;
|
2010-09-09 19:05:45 -07:00
|
|
|
edje_object_signal_emit(it->base.view, "elm,state,selected", "elm");
|
|
|
|
selectraise = edje_object_data_get(it->base.view, "selectraise");
|
2009-05-12 03:16:49 -07:00
|
|
|
if ((selectraise) && (!strcmp(selectraise, "on")))
|
2011-01-05 21:13:11 -08:00
|
|
|
{
|
|
|
|
evas_object_raise(it->base.view);
|
|
|
|
if ((it->group_item) && (it->group_item->realized))
|
2011-03-22 00:54:24 -07:00
|
|
|
evas_object_raise(it->group_item->base.view);
|
2011-01-05 21:13:11 -08:00
|
|
|
}
|
2011-03-10 11:59:10 -08:00
|
|
|
it->highlighted = EINA_TRUE;
|
2009-02-16 23:50:35 -08:00
|
|
|
}
|
|
|
|
|
2011-05-24 04:41:00 -07:00
|
|
|
static void
|
|
|
|
_item_unhighlight(Elm_Genlist_Item *it)
|
|
|
|
{
|
|
|
|
const char *stacking, *selectraise;
|
|
|
|
if ((it->delete_me) || (!it->highlighted)) return;
|
|
|
|
edje_object_signal_emit(it->base.view, "elm,state,unselected", "elm");
|
|
|
|
stacking = edje_object_data_get(it->base.view, "stacking");
|
|
|
|
selectraise = edje_object_data_get(it->base.view, "selectraise");
|
|
|
|
if (!it->nostacking)
|
|
|
|
{
|
|
|
|
if ((it->order_num_in & 0x1) ^ it->stacking_even) evas_object_lower(it->base.view);
|
|
|
|
else evas_object_raise(it->base.view);
|
|
|
|
}
|
|
|
|
it->highlighted = EINA_FALSE;
|
|
|
|
}
|
|
|
|
|
2010-03-02 00:47:40 -08:00
|
|
|
static void
|
|
|
|
_item_block_del(Elm_Genlist_Item *it)
|
|
|
|
{
|
|
|
|
Eina_Inlist *il;
|
|
|
|
Item_Block *itb = it->block;
|
|
|
|
|
|
|
|
itb->items = eina_list_remove(itb->items, it);
|
|
|
|
itb->count--;
|
|
|
|
itb->changed = EINA_TRUE;
|
|
|
|
if (it->wd->calc_job) ecore_job_del(it->wd->calc_job);
|
|
|
|
it->wd->calc_job = ecore_job_add(_calc_job, it->wd);
|
|
|
|
if (itb->count < 1)
|
|
|
|
{
|
2010-10-15 04:51:15 -07:00
|
|
|
il = EINA_INLIST_GET(itb);
|
|
|
|
Item_Block *itbn = (Item_Block *)(il->next);
|
|
|
|
if (it->parent)
|
2010-11-20 00:43:43 -08:00
|
|
|
it->parent->items = eina_list_remove(it->parent->items, it);
|
2010-10-15 04:51:15 -07:00
|
|
|
else
|
2010-11-20 00:43:43 -08:00
|
|
|
it->wd->blocks = eina_inlist_remove(it->wd->blocks, il);
|
2010-10-15 04:51:15 -07:00
|
|
|
free(itb);
|
|
|
|
if (itbn) itbn->changed = EINA_TRUE;
|
2010-03-02 00:47:40 -08:00
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
2011-06-01 20:10:11 -07:00
|
|
|
if (itb->count < itb->wd->max_items_per_block/2)
|
2010-10-15 04:51:15 -07:00
|
|
|
{
|
|
|
|
il = EINA_INLIST_GET(itb);
|
|
|
|
Item_Block *itbp = (Item_Block *)(il->prev);
|
|
|
|
Item_Block *itbn = (Item_Block *)(il->next);
|
2011-06-01 20:10:11 -07:00
|
|
|
if ((itbp) && ((itbp->count + itb->count) < itb->wd->max_items_per_block + itb->wd->max_items_per_block/2))
|
2010-10-15 04:51:15 -07:00
|
|
|
{
|
|
|
|
Elm_Genlist_Item *it2;
|
|
|
|
|
|
|
|
EINA_LIST_FREE(itb->items, it2)
|
|
|
|
{
|
|
|
|
it2->block = itbp;
|
|
|
|
itbp->items = eina_list_append(itbp->items, it2);
|
|
|
|
itbp->count++;
|
|
|
|
itbp->changed = EINA_TRUE;
|
|
|
|
}
|
2010-12-07 11:18:14 -08:00
|
|
|
it->wd->blocks = eina_inlist_remove(it->wd->blocks,
|
|
|
|
EINA_INLIST_GET(itb));
|
2010-10-15 04:51:15 -07:00
|
|
|
free(itb);
|
|
|
|
}
|
2011-06-01 20:10:11 -07:00
|
|
|
else if ((itbn) && ((itbn->count + itb->count) < itb->wd->max_items_per_block + itb->wd->max_items_per_block/2))
|
2010-10-15 04:51:15 -07:00
|
|
|
{
|
|
|
|
while (itb->items)
|
|
|
|
{
|
|
|
|
Eina_List *last = eina_list_last(itb->items);
|
|
|
|
Elm_Genlist_Item *it2 = last->data;
|
|
|
|
|
|
|
|
it2->block = itbn;
|
|
|
|
itb->items = eina_list_remove_list(itb->items, last);
|
|
|
|
itbn->items = eina_list_prepend(itbn->items, it2);
|
|
|
|
itbn->count++;
|
|
|
|
itbn->changed = EINA_TRUE;
|
|
|
|
}
|
|
|
|
it->wd->blocks =
|
2011-04-01 09:33:58 -07:00
|
|
|
eina_inlist_remove(it->wd->blocks, EINA_INLIST_GET(itb));
|
2010-10-15 04:51:15 -07:00
|
|
|
free(itb);
|
|
|
|
}
|
|
|
|
}
|
2010-03-02 00:47:40 -08:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
_item_del(Elm_Genlist_Item *it)
|
|
|
|
{
|
2011-05-27 03:30:56 -07:00
|
|
|
Evas_Object *tob = it->wd->obj;
|
2011-05-29 19:31:21 -07:00
|
|
|
|
2011-05-27 03:30:56 -07:00
|
|
|
evas_event_freeze(evas_object_evas_get(tob));
|
2010-09-09 19:05:45 -07:00
|
|
|
elm_widget_item_pre_notify_del(it);
|
2010-03-02 00:47:40 -08:00
|
|
|
elm_genlist_item_subitems_clear(it);
|
2010-07-28 01:35:34 -07:00
|
|
|
it->wd->walking -= it->walking;
|
2010-03-02 00:47:40 -08:00
|
|
|
if (it->wd->show_item == it) it->wd->show_item = NULL;
|
|
|
|
if (it->selected) it->wd->selected = eina_list_remove(it->wd->selected, it);
|
2011-04-14 04:41:07 -07:00
|
|
|
if (it->realized) _item_unrealize(it, EINA_FALSE);
|
2010-03-02 00:47:40 -08:00
|
|
|
if (it->block) _item_block_del(it);
|
2010-09-17 09:21:34 -07:00
|
|
|
if ((!it->delete_me) && (it->itc->func.del))
|
|
|
|
it->itc->func.del((void *)it->base.data, it->base.widget);
|
2010-03-02 00:47:40 -08:00
|
|
|
it->delete_me = EINA_TRUE;
|
|
|
|
if (it->queued)
|
|
|
|
it->wd->queue = eina_list_remove(it->wd->queue, it);
|
2010-11-24 23:07:39 -08:00
|
|
|
if (it->wd->anchor_item == it)
|
|
|
|
{
|
2011-01-31 02:17:40 -08:00
|
|
|
it->wd->anchor_item = ELM_GENLIST_ITEM_FROM_INLIST(EINA_INLIST_GET(it)->next);
|
2010-11-24 23:07:39 -08:00
|
|
|
if (!it->wd->anchor_item)
|
2011-01-31 02:17:40 -08:00
|
|
|
it->wd->anchor_item = ELM_GENLIST_ITEM_FROM_INLIST(EINA_INLIST_GET(it)->prev);
|
2010-11-24 23:07:39 -08:00
|
|
|
}
|
2010-03-02 00:47:40 -08:00
|
|
|
it->wd->items = eina_inlist_remove(it->wd->items, EINA_INLIST_GET(it));
|
|
|
|
if (it->parent)
|
|
|
|
it->parent->items = eina_list_remove(it->parent->items, it);
|
2011-01-06 20:58:37 -08:00
|
|
|
if (it->flags & ELM_GENLIST_ITEM_GROUP)
|
|
|
|
it->wd->group_items = eina_list_remove(it->wd->group_items, it);
|
2010-03-29 22:22:34 -07:00
|
|
|
if (it->long_timer) ecore_timer_del(it->long_timer);
|
2010-10-15 04:24:46 -07:00
|
|
|
if (it->swipe_timer) ecore_timer_del(it->swipe_timer);
|
2010-09-27 11:18:37 -07:00
|
|
|
|
|
|
|
if (it->tooltip.del_cb)
|
|
|
|
it->tooltip.del_cb((void *)it->tooltip.data, it->base.widget, it);
|
2010-12-07 11:18:14 -08:00
|
|
|
|
2011-05-27 03:30:56 -07:00
|
|
|
evas_event_thaw(evas_object_evas_get(tob));
|
|
|
|
evas_event_thaw_eval(evas_object_evas_get(tob));
|
|
|
|
|
2010-09-09 19:05:45 -07:00
|
|
|
elm_widget_item_del(it);
|
2010-03-02 00:47:40 -08:00
|
|
|
}
|
|
|
|
|
2009-02-16 23:50:35 -08:00
|
|
|
static void
|
2009-02-25 07:54:26 -08:00
|
|
|
_item_select(Elm_Genlist_Item *it)
|
2009-02-16 23:50:35 -08:00
|
|
|
{
|
2011-08-24 14:03:37 -07:00
|
|
|
Evas_Object *parent = it->base.widget;
|
|
|
|
|
2011-04-21 04:47:36 -07:00
|
|
|
if ((it->wd->no_select) || (it->delete_me) || (it->mode_view)) return;
|
2009-04-23 01:51:07 -07:00
|
|
|
if (it->selected)
|
|
|
|
{
|
2010-10-15 04:51:15 -07:00
|
|
|
if (it->wd->always_select) goto call;
|
|
|
|
return;
|
2009-04-23 01:51:07 -07:00
|
|
|
}
|
2009-06-17 08:35:19 -07:00
|
|
|
it->selected = EINA_TRUE;
|
2009-02-16 23:50:35 -08:00
|
|
|
it->wd->selected = eina_list_append(it->wd->selected, it);
|
2010-12-07 11:18:14 -08:00
|
|
|
call:
|
2011-08-24 14:03:37 -07:00
|
|
|
evas_object_ref(parent);
|
2010-03-02 00:47:40 -08:00
|
|
|
it->walking++;
|
2010-07-28 01:35:34 -07:00
|
|
|
it->wd->walking++;
|
2011-08-24 14:03:37 -07:00
|
|
|
if (it->func.func) it->func.func((void *)it->func.data, parent, it);
|
2010-03-02 00:47:40 -08:00
|
|
|
if (!it->delete_me)
|
2011-08-24 14:03:37 -07:00
|
|
|
evas_object_smart_callback_call(parent, SIG_SELECTED, it);
|
2010-03-02 00:47:40 -08:00
|
|
|
it->walking--;
|
2010-07-28 01:35:34 -07:00
|
|
|
it->wd->walking--;
|
2010-10-22 14:41:27 -07:00
|
|
|
if ((it->wd->clear_me) && (!it->wd->walking))
|
2011-08-24 14:03:37 -07:00
|
|
|
{
|
|
|
|
elm_genlist_clear(parent);
|
|
|
|
goto end;
|
|
|
|
}
|
2010-07-28 01:35:34 -07:00
|
|
|
else
|
2010-03-02 00:47:40 -08:00
|
|
|
{
|
2010-10-22 14:41:27 -07:00
|
|
|
if ((!it->walking) && (it->delete_me))
|
2010-07-28 01:35:34 -07:00
|
|
|
{
|
2010-10-22 14:41:27 -07:00
|
|
|
if (!it->relcount) _item_del(it);
|
2011-08-24 14:03:37 -07:00
|
|
|
goto end;
|
2010-07-28 01:35:34 -07:00
|
|
|
}
|
2010-03-02 00:47:40 -08:00
|
|
|
}
|
2010-10-05 12:09:55 -07:00
|
|
|
it->wd->last_selected_item = it;
|
2011-08-24 14:03:37 -07:00
|
|
|
|
|
|
|
end:
|
|
|
|
evas_object_unref(parent);
|
2009-02-16 23:50:35 -08:00
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
2009-02-25 07:54:26 -08:00
|
|
|
_item_unselect(Elm_Genlist_Item *it)
|
2009-02-16 23:50:35 -08:00
|
|
|
{
|
2011-05-24 04:41:00 -07:00
|
|
|
if ((it->delete_me) || (!it->selected)) return;
|
|
|
|
it->selected = EINA_FALSE;
|
|
|
|
it->wd->selected = eina_list_remove(it->wd->selected, it);
|
|
|
|
evas_object_smart_callback_call(it->base.widget, SIG_UNSELECTED, it);
|
2009-05-12 03:16:49 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
2010-12-07 11:18:14 -08:00
|
|
|
_mouse_move(void *data,
|
2011-04-01 09:33:58 -07:00
|
|
|
Evas *evas __UNUSED__,
|
2010-12-07 11:18:14 -08:00
|
|
|
Evas_Object *obj,
|
|
|
|
void *event_info)
|
2009-05-12 03:16:49 -07:00
|
|
|
{
|
|
|
|
Elm_Genlist_Item *it = data;
|
|
|
|
Evas_Event_Mouse_Move *ev = event_info;
|
2009-09-07 23:20:32 -07:00
|
|
|
Evas_Coord minw = 0, minh = 0, x, y, dx, dy, adx, ady;
|
2011-06-01 20:10:11 -07:00
|
|
|
Evas_Coord ox, oy, ow, oh, it_scrl_y, y_pos;
|
2009-09-26 11:24:06 -07:00
|
|
|
|
2009-05-12 03:16:49 -07:00
|
|
|
if (ev->event_flags & EVAS_EVENT_FLAG_ON_HOLD)
|
|
|
|
{
|
2010-10-15 04:51:15 -07:00
|
|
|
if (!it->wd->on_hold)
|
|
|
|
{
|
|
|
|
it->wd->on_hold = EINA_TRUE;
|
2010-08-05 11:17:05 -07:00
|
|
|
if (!it->wd->wasselected)
|
2011-05-24 04:41:00 -07:00
|
|
|
{
|
|
|
|
_item_unhighlight(it);
|
|
|
|
_item_unselect(it);
|
|
|
|
}
|
2010-10-15 04:51:15 -07:00
|
|
|
}
|
2009-05-12 03:16:49 -07:00
|
|
|
}
|
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
|
|
|
if (it->wd->multitouched)
|
|
|
|
{
|
|
|
|
it->wd->cur_x = ev->cur.canvas.x;
|
|
|
|
it->wd->cur_y = ev->cur.canvas.y;
|
|
|
|
return;
|
|
|
|
}
|
2010-02-25 22:30:17 -08:00
|
|
|
if ((it->dragging) && (it->down))
|
2010-01-18 22:54:27 -08:00
|
|
|
{
|
2010-10-15 04:24:46 -07:00
|
|
|
if (it->wd->movements == SWIPE_MOVES) it->wd->swipe = EINA_TRUE;
|
|
|
|
else
|
|
|
|
{
|
|
|
|
it->wd->history[it->wd->movements].x = ev->cur.canvas.x;
|
|
|
|
it->wd->history[it->wd->movements].y = ev->cur.canvas.y;
|
2010-12-07 11:18:14 -08:00
|
|
|
if (abs((it->wd->history[it->wd->movements].x -
|
|
|
|
it->wd->history[0].x)) > 40)
|
2010-10-15 04:24:46 -07:00
|
|
|
it->wd->swipe = EINA_TRUE;
|
|
|
|
else
|
|
|
|
it->wd->movements++;
|
|
|
|
}
|
2010-01-18 22:54:27 -08:00
|
|
|
if (it->long_timer)
|
|
|
|
{
|
|
|
|
ecore_timer_del(it->long_timer);
|
|
|
|
it->long_timer = NULL;
|
|
|
|
}
|
2011-05-06 17:30:39 -07:00
|
|
|
evas_object_smart_callback_call(it->base.widget, SIG_DRAG, it);
|
2010-01-18 22:54:27 -08:00
|
|
|
return;
|
|
|
|
}
|
2010-12-07 11:18:14 -08:00
|
|
|
if ((!it->down) /* || (it->wd->on_hold)*/ || (it->wd->longpressed))
|
2009-09-07 23:22:11 -07:00
|
|
|
{
|
2010-01-18 22:54:27 -08:00
|
|
|
if (it->long_timer)
|
|
|
|
{
|
|
|
|
ecore_timer_del(it->long_timer);
|
|
|
|
it->long_timer = NULL;
|
|
|
|
}
|
2011-06-01 20:10:11 -07:00
|
|
|
if ((it->wd->reorder_mode) && (it->wd->reorder_it))
|
|
|
|
{
|
|
|
|
evas_object_geometry_get(it->wd->pan_smart, &ox, &oy, &ow, &oh);
|
|
|
|
it_scrl_y = ev->cur.canvas.y - it->wd->reorder_it->dy;
|
|
|
|
|
|
|
|
if (!it->wd->reorder_start_y)
|
|
|
|
it->wd->reorder_start_y = it->block->y + it->y;
|
|
|
|
|
|
|
|
if (it_scrl_y < oy) y_pos = oy;
|
|
|
|
else if (it_scrl_y + it->wd->reorder_it->h > oy+oh)
|
|
|
|
y_pos = oy + oh - it->wd->reorder_it->h;
|
|
|
|
else y_pos = it_scrl_y;
|
|
|
|
|
|
|
|
_item_position(it, it->base.view, it->scrl_x, y_pos);
|
|
|
|
|
|
|
|
if (it->wd->calc_job) ecore_job_del(it->wd->calc_job);
|
|
|
|
it->wd->calc_job = ecore_job_add(_calc_job, it->wd);
|
|
|
|
}
|
2009-09-07 23:22:11 -07:00
|
|
|
return;
|
|
|
|
}
|
2010-02-04 00:06:41 -08:00
|
|
|
if (!it->display_only)
|
|
|
|
elm_coords_finger_size_adjust(1, &minw, 1, &minh);
|
2009-09-07 23:20:32 -07:00
|
|
|
evas_object_geometry_get(obj, &x, &y, NULL, NULL);
|
|
|
|
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;
|
|
|
|
if ((adx > minw) || (ady > minh))
|
|
|
|
{
|
2010-12-20 09:03:12 -08:00
|
|
|
it->dragging = EINA_TRUE;
|
2009-09-07 23:20:32 -07:00
|
|
|
if (it->long_timer)
|
|
|
|
{
|
|
|
|
ecore_timer_del(it->long_timer);
|
|
|
|
it->long_timer = NULL;
|
|
|
|
}
|
|
|
|
if (!it->wd->wasselected)
|
2011-05-24 04:41:00 -07:00
|
|
|
{
|
|
|
|
_item_unhighlight(it);
|
|
|
|
_item_unselect(it);
|
|
|
|
}
|
2009-09-07 23:20:32 -07:00
|
|
|
if (dy < 0)
|
|
|
|
{
|
|
|
|
if (ady > adx)
|
2010-12-07 11:18:14 -08:00
|
|
|
evas_object_smart_callback_call(it->base.widget,
|
2011-05-06 17:30:39 -07:00
|
|
|
SIG_DRAG_START_UP, it);
|
2009-09-07 23:20:32 -07:00
|
|
|
else
|
|
|
|
{
|
|
|
|
if (dx < 0)
|
2010-12-07 11:18:14 -08:00
|
|
|
evas_object_smart_callback_call(it->base.widget,
|
2011-05-06 17:30:39 -07:00
|
|
|
SIG_DRAG_START_LEFT, it);
|
2009-09-07 23:20:32 -07:00
|
|
|
else
|
2010-12-07 11:18:14 -08:00
|
|
|
evas_object_smart_callback_call(it->base.widget,
|
2011-05-06 17:30:39 -07:00
|
|
|
SIG_DRAG_START_RIGHT, it);
|
2009-09-07 23:20:32 -07:00
|
|
|
}
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
if (ady > adx)
|
2010-12-07 11:18:14 -08:00
|
|
|
evas_object_smart_callback_call(it->base.widget,
|
2011-05-06 17:30:39 -07:00
|
|
|
SIG_DRAG_START_DOWN, it);
|
2009-09-07 23:20:32 -07:00
|
|
|
else
|
|
|
|
{
|
|
|
|
if (dx < 0)
|
2010-12-07 11:18:14 -08:00
|
|
|
evas_object_smart_callback_call(it->base.widget,
|
2011-05-06 17:30:39 -07:00
|
|
|
SIG_DRAG_START_LEFT, it);
|
2009-09-07 23:20:32 -07:00
|
|
|
else
|
2010-12-07 11:18:14 -08:00
|
|
|
evas_object_smart_callback_call(it->base.widget,
|
2011-05-06 17:30:39 -07:00
|
|
|
SIG_DRAG_START_RIGHT, it);
|
2009-09-07 23:20:32 -07:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
2009-05-12 03:16:49 -07:00
|
|
|
}
|
|
|
|
|
2010-06-25 02:58:14 -07:00
|
|
|
static Eina_Bool
|
2009-09-01 03:42:52 -07:00
|
|
|
_long_press(void *data)
|
|
|
|
{
|
2011-06-01 20:10:11 -07:00
|
|
|
Elm_Genlist_Item *it = data, *it_tmp;
|
|
|
|
Eina_List *list, *l;
|
2009-09-26 11:24:06 -07:00
|
|
|
|
2009-09-01 03:42:52 -07:00
|
|
|
it->long_timer = NULL;
|
2010-12-07 11:18:14 -08:00
|
|
|
if ((it->disabled) || (it->dragging) || (it->display_only))
|
|
|
|
return ECORE_CALLBACK_CANCEL;
|
2009-09-01 03:42:52 -07:00
|
|
|
it->wd->longpressed = EINA_TRUE;
|
2011-05-06 17:30:39 -07:00
|
|
|
evas_object_smart_callback_call(it->base.widget, SIG_LONGPRESSED, it);
|
2011-06-01 20:10:11 -07:00
|
|
|
if ((it->wd->reorder_mode) && (it->flags != ELM_GENLIST_ITEM_GROUP))
|
|
|
|
{
|
|
|
|
it->wd->reorder_it = it;
|
|
|
|
it->wd->reorder_start_y = 0;
|
|
|
|
|
|
|
|
evas_object_raise(it->base.view);
|
|
|
|
elm_smart_scroller_hold_set(it->wd->scr, EINA_TRUE);
|
|
|
|
|
|
|
|
list = elm_genlist_realized_items_get(it->wd->obj);
|
|
|
|
EINA_LIST_FOREACH(list, l, it_tmp)
|
|
|
|
{
|
|
|
|
if (it != it_tmp) _item_unselect(it_tmp);
|
|
|
|
}
|
|
|
|
if (elm_genlist_item_expanded_get(it))
|
|
|
|
{
|
|
|
|
elm_genlist_item_expanded_set(it, EINA_FALSE);
|
|
|
|
return ECORE_CALLBACK_RENEW;
|
|
|
|
}
|
2011-06-06 17:46:22 -07:00
|
|
|
edje_object_signal_emit(it->base.view, "elm,state,reorder,enabled", "elm");
|
2011-06-01 20:10:11 -07:00
|
|
|
}
|
2010-06-25 02:58:14 -07:00
|
|
|
return ECORE_CALLBACK_CANCEL;
|
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
|
|
|
|
_swipe(Elm_Genlist_Item *it)
|
|
|
|
{
|
|
|
|
int i, sum = 0;
|
|
|
|
|
|
|
|
if (!it) return;
|
2011-02-21 08:38:24 -08:00
|
|
|
if ((it->display_only) || (it->disabled)) return;
|
2010-10-15 04:24:46 -07:00
|
|
|
it->wd->swipe = EINA_FALSE;
|
|
|
|
for (i = 0; i < it->wd->movements; i++)
|
|
|
|
{
|
|
|
|
sum += it->wd->history[i].x;
|
|
|
|
if (abs(it->wd->history[0].y - it->wd->history[i].y) > 10) return;
|
|
|
|
}
|
|
|
|
|
|
|
|
sum /= it->wd->movements;
|
|
|
|
if (abs(sum - it->wd->history[0].x) <= 10) return;
|
2011-05-06 17:30:39 -07:00
|
|
|
evas_object_smart_callback_call(it->base.widget, SIG_SWIPE, it);
|
2010-10-15 04:24:46 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
static Eina_Bool
|
|
|
|
_swipe_cancel(void *data)
|
|
|
|
{
|
|
|
|
Elm_Genlist_Item *it = data;
|
|
|
|
|
|
|
|
if (!it) return ECORE_CALLBACK_CANCEL;
|
|
|
|
it->wd->swipe = EINA_FALSE;
|
|
|
|
it->wd->movements = 0;
|
|
|
|
return ECORE_CALLBACK_RENEW;
|
|
|
|
}
|
|
|
|
|
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 Eina_Bool
|
|
|
|
_multi_cancel(void *data)
|
|
|
|
{
|
2011-01-12 04:58:26 -08:00
|
|
|
Widget_Data *wd = data;
|
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
|
|
|
|
2011-01-12 04:58:26 -08:00
|
|
|
if (!wd) return ECORE_CALLBACK_CANCEL;
|
|
|
|
wd->multi_timeout = EINA_TRUE;
|
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
|
|
|
return ECORE_CALLBACK_RENEW;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
_multi_touch_gesture_eval(void *data)
|
|
|
|
{
|
|
|
|
Elm_Genlist_Item *it = data;
|
|
|
|
|
|
|
|
it->wd->multitouched = EINA_FALSE;
|
|
|
|
if (it->wd->multi_timer)
|
|
|
|
{
|
|
|
|
ecore_timer_del(it->wd->multi_timer);
|
|
|
|
it->wd->multi_timer = NULL;
|
|
|
|
}
|
|
|
|
if (it->wd->multi_timeout)
|
|
|
|
{
|
2011-03-22 00:54:24 -07:00
|
|
|
it->wd->multi_timeout = EINA_FALSE;
|
|
|
|
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
|
|
|
}
|
|
|
|
|
|
|
|
Evas_Coord minw = 0, minh = 0;
|
|
|
|
Evas_Coord off_x, off_y, off_mx, off_my;
|
|
|
|
|
|
|
|
elm_coords_finger_size_adjust(1, &minw, 1, &minh);
|
|
|
|
off_x = abs(it->wd->cur_x - it->wd->prev_x);
|
|
|
|
off_y = abs(it->wd->cur_y - it->wd->prev_y);
|
|
|
|
off_mx = abs(it->wd->cur_mx - it->wd->prev_mx);
|
|
|
|
off_my = abs(it->wd->cur_my - it->wd->prev_my);
|
|
|
|
|
|
|
|
if (((off_x > minw) || (off_y > minh)) && ((off_mx > minw) || (off_my > minh)))
|
|
|
|
{
|
|
|
|
if ((off_x + off_mx) > (off_y + off_my))
|
|
|
|
{
|
|
|
|
if ((it->wd->cur_x > it->wd->prev_x) && (it->wd->cur_mx > it->wd->prev_mx))
|
|
|
|
evas_object_smart_callback_call(it->base.widget,
|
2011-05-06 17:30:39 -07:00
|
|
|
SIG_MULTI_SWIPE_RIGHT, 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
|
|
|
else if ((it->wd->cur_x < it->wd->prev_x) && (it->wd->cur_mx < it->wd->prev_mx))
|
|
|
|
evas_object_smart_callback_call(it->base.widget,
|
2011-05-06 17:30:39 -07:00
|
|
|
SIG_MULTI_SWIPE_LEFT, 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
|
|
|
else if (abs(it->wd->cur_x - it->wd->cur_mx) > abs(it->wd->prev_x - it->wd->prev_mx))
|
|
|
|
evas_object_smart_callback_call(it->base.widget,
|
2011-05-06 17:30:39 -07:00
|
|
|
SIG_MULTI_PINCH_OUT, 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
|
|
|
else
|
|
|
|
evas_object_smart_callback_call(it->base.widget,
|
2011-05-06 17:30:39 -07:00
|
|
|
SIG_MULTI_PINCH_IN, 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
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
if ((it->wd->cur_y > it->wd->prev_y) && (it->wd->cur_my > it->wd->prev_my))
|
|
|
|
evas_object_smart_callback_call(it->base.widget,
|
2011-05-06 17:30:39 -07:00
|
|
|
SIG_MULTI_SWIPE_DOWN, 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
|
|
|
else if ((it->wd->cur_y < it->wd->prev_y) && (it->wd->cur_my < it->wd->prev_my))
|
|
|
|
evas_object_smart_callback_call(it->base.widget,
|
2011-05-06 17:30:39 -07:00
|
|
|
SIG_MULTI_SWIPE_UP, 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
|
|
|
else if (abs(it->wd->cur_y - it->wd->cur_my) > abs(it->wd->prev_y - it->wd->prev_my))
|
|
|
|
evas_object_smart_callback_call(it->base.widget,
|
2011-05-06 17:30:39 -07:00
|
|
|
SIG_MULTI_PINCH_OUT, 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
|
|
|
else
|
|
|
|
evas_object_smart_callback_call(it->base.widget,
|
2011-05-06 17:30:39 -07:00
|
|
|
SIG_MULTI_PINCH_IN, 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
|
|
|
}
|
|
|
|
}
|
2011-03-22 00:54:24 -07:00
|
|
|
it->wd->multi_timeout = EINA_FALSE;
|
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
|
2011-04-01 09:33:58 -07:00
|
|
|
_multi_down(void *data,
|
|
|
|
Evas *evas __UNUSED__,
|
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
|
|
|
Evas_Object *obj __UNUSED__,
|
2011-04-01 09:33:58 -07:00
|
|
|
void *event_info)
|
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
|
|
|
{
|
|
|
|
Elm_Genlist_Item *it = data;
|
|
|
|
Evas_Event_Multi_Down *ev = event_info;
|
|
|
|
|
|
|
|
if ((it->wd->multi_device != 0) || (it->wd->multitouched) || (it->wd->multi_timeout)) return;
|
|
|
|
it->wd->multi_device = ev->device;
|
|
|
|
it->wd->multi_down = EINA_TRUE;
|
|
|
|
it->wd->multitouched = EINA_TRUE;
|
|
|
|
it->wd->prev_mx = ev->canvas.x;
|
|
|
|
it->wd->prev_my = ev->canvas.y;
|
2011-05-24 04:41:00 -07:00
|
|
|
if (!it->wd->wasselected)
|
|
|
|
{
|
|
|
|
_item_unhighlight(it);
|
|
|
|
_item_unselect(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
|
|
|
it->wd->wasselected = EINA_FALSE;
|
|
|
|
it->wd->longpressed = EINA_FALSE;
|
|
|
|
if (it->long_timer)
|
|
|
|
{
|
|
|
|
ecore_timer_del(it->long_timer);
|
|
|
|
it->long_timer = NULL;
|
|
|
|
}
|
|
|
|
if (it->dragging)
|
|
|
|
{
|
|
|
|
it->dragging = EINA_FALSE;
|
2011-05-06 17:30:39 -07:00
|
|
|
evas_object_smart_callback_call(it->base.widget, SIG_DRAG_STOP, 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
|
|
|
}
|
|
|
|
if (it->swipe_timer)
|
|
|
|
{
|
|
|
|
ecore_timer_del(it->swipe_timer);
|
|
|
|
it->swipe_timer = NULL;
|
|
|
|
}
|
|
|
|
if (it->wd->on_hold)
|
|
|
|
{
|
|
|
|
it->wd->swipe = EINA_FALSE;
|
|
|
|
it->wd->movements = 0;
|
|
|
|
it->wd->on_hold = EINA_FALSE;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
2011-04-01 09:33:58 -07:00
|
|
|
_multi_up(void *data,
|
|
|
|
Evas *evas __UNUSED__,
|
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
|
|
|
Evas_Object *obj __UNUSED__,
|
2011-04-01 09:33:58 -07:00
|
|
|
void *event_info)
|
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
|
|
|
{
|
|
|
|
Elm_Genlist_Item *it = data;
|
|
|
|
Evas_Event_Multi_Up *ev = event_info;
|
|
|
|
|
|
|
|
if (it->wd->multi_device != ev->device) return;
|
|
|
|
it->wd->multi_device = 0;
|
|
|
|
it->wd->multi_down = EINA_FALSE;
|
|
|
|
if (it->wd->mouse_down) return;
|
|
|
|
_multi_touch_gesture_eval(data);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
2011-04-01 09:33:58 -07:00
|
|
|
_multi_move(void *data,
|
|
|
|
Evas *evas __UNUSED__,
|
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
|
|
|
Evas_Object *obj __UNUSED__,
|
2011-04-01 09:33:58 -07:00
|
|
|
void *event_info)
|
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
|
|
|
{
|
|
|
|
Elm_Genlist_Item *it = data;
|
|
|
|
Evas_Event_Multi_Move *ev = event_info;
|
|
|
|
|
|
|
|
if (it->wd->multi_device != ev->device) return;
|
|
|
|
it->wd->cur_mx = ev->cur.canvas.x;
|
|
|
|
it->wd->cur_my = ev->cur.canvas.y;
|
|
|
|
}
|
|
|
|
|
2009-05-12 03:16:49 -07:00
|
|
|
static void
|
2010-12-07 11:18:14 -08:00
|
|
|
_mouse_down(void *data,
|
2011-04-01 09:33:58 -07:00
|
|
|
Evas *evas __UNUSED__,
|
2010-12-07 11:18:14 -08:00
|
|
|
Evas_Object *obj,
|
|
|
|
void *event_info)
|
2009-05-12 03:16:49 -07:00
|
|
|
{
|
|
|
|
Elm_Genlist_Item *it = data;
|
|
|
|
Evas_Event_Mouse_Down *ev = event_info;
|
2009-09-07 23:20:32 -07:00
|
|
|
Evas_Coord x, y;
|
2009-09-26 11:24:06 -07:00
|
|
|
|
2009-09-01 03:42:52 -07:00
|
|
|
if (ev->button != 1) return;
|
2010-11-08 22:07:07 -08:00
|
|
|
if (ev->event_flags & EVAS_EVENT_FLAG_ON_HOLD)
|
2010-12-07 11:18:14 -08:00
|
|
|
{
|
|
|
|
it->wd->on_hold = EINA_TRUE;
|
|
|
|
}
|
2010-07-27 16:36:27 -07:00
|
|
|
|
2010-12-20 09:03:12 -08:00
|
|
|
it->down = EINA_TRUE;
|
|
|
|
it->dragging = EINA_FALSE;
|
2009-09-07 23:20:32 -07:00
|
|
|
evas_object_geometry_get(obj, &x, &y, NULL, NULL);
|
|
|
|
it->dx = ev->canvas.x - x;
|
|
|
|
it->dy = ev->canvas.y - y;
|
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
|
|
|
it->wd->mouse_down = EINA_TRUE;
|
|
|
|
if (!it->wd->multitouched)
|
|
|
|
{
|
|
|
|
it->wd->prev_x = ev->canvas.x;
|
|
|
|
it->wd->prev_y = ev->canvas.y;
|
|
|
|
it->wd->multi_timeout = EINA_FALSE;
|
|
|
|
if (it->wd->multi_timer) ecore_timer_del(it->wd->multi_timer);
|
2011-01-12 04:58:26 -08:00
|
|
|
it->wd->multi_timer = ecore_timer_add(1, _multi_cancel, it->wd);
|
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
|
|
|
}
|
2010-02-25 22:30:17 -08:00
|
|
|
it->wd->longpressed = EINA_FALSE;
|
2009-06-17 08:35:19 -07:00
|
|
|
if (ev->event_flags & EVAS_EVENT_FLAG_ON_HOLD) it->wd->on_hold = EINA_TRUE;
|
|
|
|
else it->wd->on_hold = EINA_FALSE;
|
2010-11-08 22:07:07 -08:00
|
|
|
if (it->wd->on_hold) return;
|
2009-09-01 03:42:52 -07:00
|
|
|
it->wd->wasselected = it->selected;
|
2011-03-10 11:59:10 -08:00
|
|
|
_item_highlight(it);
|
2009-05-12 03:16:49 -07:00
|
|
|
if (ev->flags & EVAS_BUTTON_DOUBLE_CLICK)
|
2011-03-22 00:54:24 -07:00
|
|
|
if ((!it->disabled) && (!it->display_only))
|
2011-07-25 18:49:24 -07:00
|
|
|
{
|
|
|
|
evas_object_smart_callback_call(it->base.widget, SIG_CLICKED_DOUBLE, it);
|
|
|
|
evas_object_smart_callback_call(it->base.widget, SIG_ACTIVATED, it);
|
|
|
|
}
|
2009-09-01 03:42:52 -07:00
|
|
|
if (it->long_timer) ecore_timer_del(it->long_timer);
|
2010-10-15 04:24:46 -07:00
|
|
|
if (it->swipe_timer) ecore_timer_del(it->swipe_timer);
|
|
|
|
it->swipe_timer = ecore_timer_add(0.4, _swipe_cancel, it);
|
2010-03-29 22:42:56 -07:00
|
|
|
if (it->realized)
|
2010-12-07 11:18:14 -08:00
|
|
|
it->long_timer = ecore_timer_add(it->wd->longpress_timeout, _long_press,
|
|
|
|
it);
|
2010-03-29 22:42:56 -07:00
|
|
|
else
|
|
|
|
it->long_timer = NULL;
|
2010-10-15 04:24:46 -07:00
|
|
|
it->wd->swipe = EINA_FALSE;
|
|
|
|
it->wd->movements = 0;
|
2009-02-16 23:50:35 -08:00
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
2011-04-01 09:33:58 -07:00
|
|
|
_mouse_up(void *data,
|
|
|
|
Evas *evas __UNUSED__,
|
2010-12-07 11:18:14 -08:00
|
|
|
Evas_Object *obj __UNUSED__,
|
2011-04-01 09:33:58 -07:00
|
|
|
void *event_info)
|
2009-02-16 23:50:35 -08:00
|
|
|
{
|
2009-02-25 07:54:26 -08:00
|
|
|
Elm_Genlist_Item *it = data;
|
2009-02-16 23:50:35 -08:00
|
|
|
Evas_Event_Mouse_Up *ev = event_info;
|
2010-06-05 06:12:45 -07:00
|
|
|
Eina_Bool dragged = EINA_FALSE;
|
2009-09-26 11:24:06 -07:00
|
|
|
|
2009-09-01 03:42:52 -07:00
|
|
|
if (ev->button != 1) return;
|
2010-12-20 09:03:12 -08:00
|
|
|
it->down = EINA_FALSE;
|
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
|
|
|
it->wd->mouse_down = EINA_FALSE;
|
|
|
|
if (it->wd->multitouched)
|
|
|
|
{
|
2011-05-24 20:01:51 -07:00
|
|
|
if ((!it->wd->multi) && (!it->selected) && (it->highlighted)) _item_unhighlight(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
|
|
|
if (it->wd->multi_down) return;
|
|
|
|
_multi_touch_gesture_eval(data);
|
|
|
|
return;
|
|
|
|
}
|
2009-06-17 08:35:19 -07:00
|
|
|
if (ev->event_flags & EVAS_EVENT_FLAG_ON_HOLD) it->wd->on_hold = EINA_TRUE;
|
|
|
|
else it->wd->on_hold = EINA_FALSE;
|
2009-09-01 03:42:52 -07:00
|
|
|
if (it->long_timer)
|
|
|
|
{
|
|
|
|
ecore_timer_del(it->long_timer);
|
|
|
|
it->long_timer = NULL;
|
|
|
|
}
|
2009-09-07 23:20:32 -07:00
|
|
|
if (it->dragging)
|
|
|
|
{
|
2010-12-20 09:03:12 -08:00
|
|
|
it->dragging = EINA_FALSE;
|
2011-05-06 17:30:39 -07:00
|
|
|
evas_object_smart_callback_call(it->base.widget, SIG_DRAG_STOP, it);
|
2009-09-07 23:35:14 -07:00
|
|
|
dragged = 1;
|
2009-09-07 23:20:32 -07:00
|
|
|
}
|
2010-10-15 04:24:46 -07:00
|
|
|
if (it->swipe_timer)
|
|
|
|
{
|
|
|
|
ecore_timer_del(it->swipe_timer);
|
|
|
|
it->swipe_timer = 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
|
|
|
if (it->wd->multi_timer)
|
|
|
|
{
|
|
|
|
ecore_timer_del(it->wd->multi_timer);
|
|
|
|
it->wd->multi_timer = NULL;
|
|
|
|
it->wd->multi_timeout = EINA_FALSE;
|
|
|
|
}
|
2009-02-16 23:50:35 -08:00
|
|
|
if (it->wd->on_hold)
|
|
|
|
{
|
2010-10-15 04:24:46 -07:00
|
|
|
if (it->wd->swipe) _swipe(data);
|
2010-03-24 01:54:59 -07:00
|
|
|
it->wd->longpressed = EINA_FALSE;
|
2010-10-15 04:51:15 -07:00
|
|
|
it->wd->on_hold = EINA_FALSE;
|
|
|
|
return;
|
2009-02-16 23:50:35 -08:00
|
|
|
}
|
2011-06-01 20:10:11 -07:00
|
|
|
if ((it->wd->reorder_mode) && (it->wd->reorder_it))
|
|
|
|
{
|
|
|
|
Evas_Coord it_scrl_y = ev->canvas.y - it->wd->reorder_it->dy;
|
|
|
|
|
|
|
|
if (it->wd->reorder_rel)
|
|
|
|
{
|
|
|
|
if (it->wd->reorder_it->parent == it->wd->reorder_rel->parent)
|
|
|
|
{
|
|
|
|
if (it_scrl_y <= it->wd->reorder_rel->scrl_y)
|
|
|
|
_item_move_before(it->wd->reorder_it, it->wd->reorder_rel);
|
|
|
|
else
|
|
|
|
_item_move_after(it->wd->reorder_it, it->wd->reorder_rel);
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
if (it->wd->calc_job) ecore_job_del(it->wd->calc_job);
|
|
|
|
it->wd->calc_job = ecore_job_add(_calc_job, it->wd);
|
|
|
|
}
|
|
|
|
}
|
2011-06-06 17:46:22 -07:00
|
|
|
edje_object_signal_emit(it->base.view, "elm,state,reorder,disabled", "elm");
|
2011-06-01 20:10:11 -07:00
|
|
|
it->wd->reorder_it = it->wd->reorder_rel = NULL;
|
|
|
|
elm_smart_scroller_hold_set(it->wd->scr, EINA_FALSE);
|
|
|
|
}
|
2009-09-01 03:42:52 -07:00
|
|
|
if (it->wd->longpressed)
|
|
|
|
{
|
|
|
|
it->wd->longpressed = EINA_FALSE;
|
|
|
|
if (!it->wd->wasselected)
|
2011-05-24 04:41:00 -07:00
|
|
|
{
|
|
|
|
_item_unhighlight(it);
|
|
|
|
_item_unselect(it);
|
|
|
|
}
|
2010-12-20 09:03:12 -08:00
|
|
|
it->wd->wasselected = EINA_FALSE;
|
2009-09-01 03:42:52 -07:00
|
|
|
return;
|
|
|
|
}
|
2010-03-26 21:17:01 -07:00
|
|
|
if (dragged)
|
|
|
|
{
|
|
|
|
if (it->want_unrealize)
|
|
|
|
{
|
2011-04-14 04:41:07 -07:00
|
|
|
_item_unrealize(it, EINA_FALSE);
|
2010-03-26 21:17:01 -07:00
|
|
|
if (it->block->want_unrealize)
|
|
|
|
_item_block_unrealize(it->block);
|
|
|
|
}
|
|
|
|
}
|
2010-10-15 01:36:57 -07:00
|
|
|
if ((it->disabled) || (dragged) || (it->display_only)) return;
|
2010-11-08 22:07:07 -08:00
|
|
|
if (ev->event_flags & EVAS_EVENT_FLAG_ON_HOLD) return;
|
2009-02-16 23:50:35 -08:00
|
|
|
if (it->wd->multi)
|
|
|
|
{
|
2010-10-15 04:51:15 -07:00
|
|
|
if (!it->selected)
|
|
|
|
{
|
2011-03-10 11:59:10 -08:00
|
|
|
_item_highlight(it);
|
2010-10-15 04:51:15 -07:00
|
|
|
_item_select(it);
|
|
|
|
}
|
2011-05-24 04:41:00 -07:00
|
|
|
else
|
|
|
|
{
|
|
|
|
_item_unhighlight(it);
|
|
|
|
_item_unselect(it);
|
|
|
|
}
|
2009-02-16 23:50:35 -08:00
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
2010-10-15 04:51:15 -07:00
|
|
|
if (!it->selected)
|
|
|
|
{
|
|
|
|
Widget_Data *wd = it->wd;
|
2010-03-09 06:42:41 -08:00
|
|
|
if (wd)
|
|
|
|
{
|
2011-05-24 04:41:00 -07:00
|
|
|
while (wd->selected)
|
|
|
|
{
|
|
|
|
_item_unhighlight(wd->selected->data);
|
|
|
|
_item_unselect(wd->selected->data);
|
|
|
|
}
|
2010-03-09 06:42:41 -08:00
|
|
|
}
|
2010-10-15 04:51:15 -07:00
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
const Eina_List *l, *l_next;
|
|
|
|
Elm_Genlist_Item *it2;
|
|
|
|
|
|
|
|
EINA_LIST_FOREACH_SAFE(it->wd->selected, l, l_next, it2)
|
2011-05-24 04:41:00 -07:00
|
|
|
if (it2 != it)
|
|
|
|
{
|
|
|
|
_item_unhighlight(it2);
|
|
|
|
_item_unselect(it2);
|
|
|
|
}
|
2011-03-10 11:59:10 -08:00
|
|
|
//_item_highlight(it);
|
2010-10-15 04:51:15 -07:00
|
|
|
//_item_select(it);
|
|
|
|
}
|
2011-03-10 11:59:10 -08:00
|
|
|
_item_highlight(it);
|
2009-09-26 11:24:06 -07:00
|
|
|
_item_select(it);
|
2009-02-16 23:50:35 -08:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2009-03-12 22:50:38 -07:00
|
|
|
static void
|
2011-04-01 09:33:58 -07:00
|
|
|
_signal_expand_toggle(void *data,
|
|
|
|
Evas_Object *obj __UNUSED__,
|
|
|
|
const char *emission __UNUSED__,
|
|
|
|
const char *source __UNUSED__)
|
2009-03-12 22:50:38 -07:00
|
|
|
{
|
|
|
|
Elm_Genlist_Item *it = data;
|
2009-09-26 11:24:06 -07:00
|
|
|
|
2009-03-12 22:50:38 -07:00
|
|
|
if (it->expanded)
|
2011-05-06 17:30:39 -07:00
|
|
|
evas_object_smart_callback_call(it->base.widget, SIG_CONTRACT_REQUEST, it);
|
2009-03-12 22:50:38 -07:00
|
|
|
else
|
2011-05-06 17:30:39 -07:00
|
|
|
evas_object_smart_callback_call(it->base.widget, SIG_EXPAND_REQUEST, it);
|
2009-03-12 22:50:38 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
2011-04-01 09:33:58 -07:00
|
|
|
_signal_expand(void *data,
|
|
|
|
Evas_Object *obj __UNUSED__,
|
|
|
|
const char *emission __UNUSED__,
|
|
|
|
const char *source __UNUSED__)
|
2009-03-12 22:50:38 -07:00
|
|
|
{
|
|
|
|
Elm_Genlist_Item *it = data;
|
2009-09-26 11:24:06 -07:00
|
|
|
|
2009-03-12 22:50:38 -07:00
|
|
|
if (!it->expanded)
|
2011-05-06 17:30:39 -07:00
|
|
|
evas_object_smart_callback_call(it->base.widget, SIG_EXPAND_REQUEST, it);
|
2009-03-12 22:50:38 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
2011-04-01 09:33:58 -07:00
|
|
|
_signal_contract(void *data,
|
|
|
|
Evas_Object *obj __UNUSED__,
|
|
|
|
const char *emission __UNUSED__,
|
|
|
|
const char *source __UNUSED__)
|
2009-03-12 22:50:38 -07:00
|
|
|
{
|
|
|
|
Elm_Genlist_Item *it = data;
|
2009-09-26 11:24:06 -07:00
|
|
|
|
2009-03-12 22:50:38 -07:00
|
|
|
if (it->expanded)
|
2011-05-06 17:30:39 -07:00
|
|
|
evas_object_smart_callback_call(it->base.widget, SIG_CONTRACT_REQUEST, it);
|
2009-03-12 22:50:38 -07:00
|
|
|
}
|
|
|
|
|
2011-04-21 04:47:36 -07:00
|
|
|
static Eina_Bool
|
|
|
|
_scr_hold_timer_cb(void *data)
|
|
|
|
{
|
|
|
|
if (!data) return ECORE_CALLBACK_CANCEL;
|
|
|
|
Widget_Data *wd = data;
|
|
|
|
elm_smart_scroller_hold_set(wd->scr, EINA_FALSE);
|
|
|
|
wd->scr_hold_timer = NULL;
|
|
|
|
return ECORE_CALLBACK_CANCEL;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
_mode_finished_signal_cb(void *data,
|
|
|
|
Evas_Object *obj,
|
|
|
|
const char *emission __UNUSED__,
|
|
|
|
const char *source __UNUSED__)
|
|
|
|
{
|
|
|
|
if (!data) return;
|
|
|
|
if (!obj) return;
|
|
|
|
Elm_Genlist_Item *it = data;
|
|
|
|
if ((it->delete_me) || (!it->realized) || (!it->mode_view)) return;
|
|
|
|
char buf[1024];
|
2011-06-01 06:15:08 -07:00
|
|
|
Evas *te = evas_object_evas_get(obj);
|
2011-05-29 19:31:21 -07:00
|
|
|
|
2011-06-01 06:15:08 -07:00
|
|
|
evas_event_freeze(te);
|
2011-04-21 04:47:36 -07:00
|
|
|
it->nocache = EINA_FALSE;
|
|
|
|
_mode_item_unrealize(it);
|
|
|
|
snprintf(buf, sizeof(buf), "elm,state,%s,passive,finished", it->wd->mode_type);
|
|
|
|
edje_object_signal_callback_del_full(obj, buf, "elm", _mode_finished_signal_cb, it);
|
2011-06-01 06:15:08 -07:00
|
|
|
evas_event_thaw(te);
|
|
|
|
evas_event_thaw_eval(te);
|
2011-04-21 04:47:36 -07:00
|
|
|
}
|
|
|
|
|
2010-11-05 23:02:22 -07:00
|
|
|
static void
|
|
|
|
_item_cache_clean(Widget_Data *wd)
|
|
|
|
{
|
2011-05-27 03:30:56 -07:00
|
|
|
evas_event_freeze(evas_object_evas_get(wd->obj));
|
2010-12-07 11:18:14 -08:00
|
|
|
while ((wd->item_cache) && (wd->item_cache_count > wd->item_cache_max))
|
|
|
|
{
|
|
|
|
Item_Cache *itc;
|
|
|
|
|
|
|
|
itc = EINA_INLIST_CONTAINER_GET(wd->item_cache->last, Item_Cache);
|
|
|
|
wd->item_cache = eina_inlist_remove(wd->item_cache,
|
|
|
|
wd->item_cache->last);
|
|
|
|
wd->item_cache_count--;
|
|
|
|
if (itc->spacer) evas_object_del(itc->spacer);
|
|
|
|
if (itc->base_view) evas_object_del(itc->base_view);
|
|
|
|
if (itc->item_style) eina_stringshare_del(itc->item_style);
|
|
|
|
free(itc);
|
|
|
|
}
|
2011-05-27 03:30:56 -07:00
|
|
|
evas_event_thaw(evas_object_evas_get(wd->obj));
|
|
|
|
evas_event_thaw_eval(evas_object_evas_get(wd->obj));
|
2010-11-05 23:02:22 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
_item_cache_zero(Widget_Data *wd)
|
|
|
|
{
|
2010-12-07 11:18:14 -08:00
|
|
|
int pmax = wd->item_cache_max;
|
|
|
|
wd->item_cache_max = 0;
|
|
|
|
_item_cache_clean(wd);
|
|
|
|
wd->item_cache_max = pmax;
|
2010-11-05 23:02:22 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
_item_cache_add(Elm_Genlist_Item *it)
|
|
|
|
{
|
2010-12-07 11:18:14 -08:00
|
|
|
Item_Cache *itc;
|
|
|
|
|
2011-05-27 03:30:56 -07:00
|
|
|
evas_event_freeze(evas_object_evas_get(it->wd->obj));
|
2010-12-07 11:18:14 -08:00
|
|
|
if (it->wd->item_cache_max <= 0)
|
|
|
|
{
|
|
|
|
evas_object_del(it->base.view);
|
|
|
|
it->base.view = NULL;
|
|
|
|
evas_object_del(it->spacer);
|
|
|
|
it->spacer = NULL;
|
2011-05-27 03:30:56 -07:00
|
|
|
evas_event_thaw(evas_object_evas_get(it->wd->obj));
|
|
|
|
evas_event_thaw_eval(evas_object_evas_get(it->wd->obj));
|
2010-12-07 11:18:14 -08:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
it->wd->item_cache_count++;
|
|
|
|
itc = calloc(1, sizeof(Item_Cache));
|
|
|
|
it->wd->item_cache = eina_inlist_prepend(it->wd->item_cache,
|
|
|
|
EINA_INLIST_GET(itc));
|
|
|
|
itc->spacer = it->spacer;
|
|
|
|
it->spacer = NULL;
|
|
|
|
itc->base_view = it->base.view;
|
|
|
|
it->base.view = NULL;
|
|
|
|
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->flags & ELM_GENLIST_ITEM_SUBITEMS) itc->tree = 1;
|
|
|
|
itc->compress = (it->wd->compress);
|
|
|
|
itc->selected = it->selected;
|
|
|
|
itc->disabled = it->disabled;
|
|
|
|
itc->expanded = it->expanded;
|
|
|
|
if (it->long_timer)
|
|
|
|
{
|
|
|
|
ecore_timer_del(it->long_timer);
|
|
|
|
it->long_timer = NULL;
|
|
|
|
}
|
|
|
|
if (it->swipe_timer)
|
|
|
|
{
|
|
|
|
ecore_timer_del(it->swipe_timer);
|
|
|
|
it->swipe_timer = NULL;
|
|
|
|
}
|
|
|
|
// FIXME: other callbacks?
|
|
|
|
edje_object_signal_callback_del_full(itc->base_view,
|
|
|
|
"elm,action,expand,toggle",
|
|
|
|
"elm", _signal_expand_toggle, it);
|
|
|
|
edje_object_signal_callback_del_full(itc->base_view, "elm,action,expand",
|
|
|
|
"elm",
|
|
|
|
_signal_expand, it);
|
|
|
|
edje_object_signal_callback_del_full(itc->base_view, "elm,action,contract",
|
|
|
|
"elm", _signal_contract, it);
|
|
|
|
evas_object_event_callback_del_full(itc->base_view, EVAS_CALLBACK_MOUSE_DOWN,
|
|
|
|
_mouse_down, it);
|
|
|
|
evas_object_event_callback_del_full(itc->base_view, EVAS_CALLBACK_MOUSE_UP,
|
|
|
|
_mouse_up, it);
|
|
|
|
evas_object_event_callback_del_full(itc->base_view, EVAS_CALLBACK_MOUSE_MOVE,
|
|
|
|
_mouse_move, 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
|
|
|
evas_object_event_callback_del_full(itc->base_view, EVAS_CALLBACK_MULTI_DOWN,
|
|
|
|
_multi_down, it);
|
|
|
|
evas_object_event_callback_del_full(itc->base_view, EVAS_CALLBACK_MULTI_UP,
|
|
|
|
_multi_up, it);
|
|
|
|
evas_object_event_callback_del_full(itc->base_view, EVAS_CALLBACK_MULTI_MOVE,
|
|
|
|
_multi_move, it);
|
2010-12-07 11:18:14 -08:00
|
|
|
_item_cache_clean(it->wd);
|
2011-05-27 03:30:56 -07:00
|
|
|
evas_event_thaw(evas_object_evas_get(it->wd->obj));
|
|
|
|
evas_event_thaw_eval(evas_object_evas_get(it->wd->obj));
|
2010-11-05 23:02:22 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
static Item_Cache *
|
|
|
|
_item_cache_find(Elm_Genlist_Item *it)
|
|
|
|
{
|
2010-12-07 11:18:14 -08:00
|
|
|
Item_Cache *itc;
|
2011-04-22 02:56:22 -07:00
|
|
|
Eina_Bool tree = 0;
|
2010-12-07 11:18:14 -08:00
|
|
|
|
|
|
|
if (it->flags & ELM_GENLIST_ITEM_SUBITEMS) tree = 1;
|
|
|
|
EINA_INLIST_FOREACH(it->wd->item_cache, itc)
|
2011-03-22 00:54:24 -07:00
|
|
|
{
|
|
|
|
if ((itc->selected) || (itc->disabled) || (itc->expanded))
|
|
|
|
continue;
|
|
|
|
if ((itc->tree == tree) &&
|
|
|
|
(itc->compress == it->wd->compress) &&
|
|
|
|
(!strcmp(it->itc->item_style, itc->item_style)))
|
|
|
|
{
|
|
|
|
it->wd->item_cache = eina_inlist_remove(it->wd->item_cache,
|
|
|
|
EINA_INLIST_GET(itc));
|
|
|
|
it->wd->item_cache_count--;
|
|
|
|
return itc;
|
|
|
|
}
|
|
|
|
}
|
2010-12-07 11:18:14 -08:00
|
|
|
return NULL;
|
2010-11-05 23:02:22 -07:00
|
|
|
}
|
|
|
|
|
2011-04-22 02:56:22 -07:00
|
|
|
static void
|
|
|
|
_elm_genlist_item_odd_even_update(Elm_Genlist_Item *it)
|
|
|
|
{
|
|
|
|
if (!it->nostacking)
|
|
|
|
{
|
2011-04-22 05:22:57 -07:00
|
|
|
if ((it->order_num_in & 0x1) ^ it->stacking_even)
|
|
|
|
evas_object_lower(it->base.view);
|
|
|
|
else
|
|
|
|
evas_object_raise(it->base.view);
|
2011-04-22 02:56:22 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
if (it->order_num_in & 0x1)
|
|
|
|
edje_object_signal_emit(it->base.view, "elm,state,odd", "elm");
|
|
|
|
else
|
|
|
|
edje_object_signal_emit(it->base.view, "elm,state,even", "elm");
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
_elm_genlist_item_state_update(Elm_Genlist_Item *it, Item_Cache *itc)
|
|
|
|
{
|
2011-04-22 05:22:57 -07:00
|
|
|
if (itc)
|
|
|
|
{
|
|
|
|
if (it->selected != itc->selected)
|
|
|
|
{
|
|
|
|
if (it->selected)
|
|
|
|
edje_object_signal_emit(it->base.view,
|
|
|
|
"elm,state,selected", "elm");
|
|
|
|
}
|
|
|
|
if (it->disabled != itc->disabled)
|
|
|
|
{
|
|
|
|
if (it->disabled)
|
|
|
|
edje_object_signal_emit(it->base.view,
|
|
|
|
"elm,state,disabled", "elm");
|
|
|
|
}
|
|
|
|
if (it->expanded != itc->expanded)
|
|
|
|
{
|
|
|
|
if (it->expanded)
|
|
|
|
edje_object_signal_emit(it->base.view,
|
|
|
|
"elm,state,expanded", "elm");
|
|
|
|
}
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
if (it->selected)
|
|
|
|
edje_object_signal_emit(it->base.view,
|
|
|
|
"elm,state,selected", "elm");
|
|
|
|
if (it->disabled)
|
|
|
|
edje_object_signal_emit(it->base.view,
|
|
|
|
"elm,state,disabled", "elm");
|
|
|
|
if (it->expanded)
|
|
|
|
edje_object_signal_emit(it->base.view,
|
|
|
|
"elm,state,expanded", "elm");
|
|
|
|
}
|
2011-04-22 02:56:22 -07:00
|
|
|
}
|
|
|
|
|
2010-11-05 23:02:22 -07:00
|
|
|
static void
|
|
|
|
_item_cache_free(Item_Cache *itc)
|
|
|
|
{
|
2010-12-07 11:18:14 -08:00
|
|
|
if (itc->spacer) evas_object_del(itc->spacer);
|
|
|
|
if (itc->base_view) evas_object_del(itc->base_view);
|
|
|
|
if (itc->item_style) eina_stringshare_del(itc->item_style);
|
|
|
|
free(itc);
|
2010-11-05 23:02:22 -07:00
|
|
|
}
|
|
|
|
|
2011-08-10 16:51:20 -07:00
|
|
|
static const char *
|
|
|
|
_item_label_hook(Elm_Genlist_Item *it, const char *part)
|
|
|
|
{
|
|
|
|
if (!it->itc->func.label_get) return NULL;
|
|
|
|
return edje_object_part_text_get(it->base.view, part);
|
|
|
|
}
|
|
|
|
|
2011-04-22 02:56:49 -07:00
|
|
|
static void
|
|
|
|
_item_label_realize(Elm_Genlist_Item *it,
|
2011-04-22 05:22:57 -07:00
|
|
|
Evas_Object *target,
|
2011-04-22 06:20:06 -07:00
|
|
|
Eina_List **source)
|
2011-04-22 02:56:49 -07:00
|
|
|
{
|
|
|
|
if (it->itc->func.label_get)
|
|
|
|
{
|
|
|
|
const Eina_List *l;
|
|
|
|
const char *key;
|
|
|
|
|
2011-04-22 06:20:06 -07:00
|
|
|
*source = elm_widget_stringlist_get(edje_object_data_get(target, "labels"));
|
|
|
|
EINA_LIST_FOREACH(*source, l, key)
|
2011-04-22 02:56:49 -07:00
|
|
|
{
|
|
|
|
char *s = it->itc->func.label_get
|
|
|
|
((void *)it->base.data, it->base.widget, key);
|
|
|
|
|
|
|
|
if (s)
|
|
|
|
{
|
|
|
|
edje_object_part_text_set(target, key, s);
|
|
|
|
free(s);
|
|
|
|
}
|
2011-04-22 05:22:57 -07:00
|
|
|
else
|
|
|
|
{
|
|
|
|
edje_object_part_text_set(target, key, "");
|
|
|
|
}
|
2011-04-22 02:56:49 -07:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
static Eina_List *
|
|
|
|
_item_icon_realize(Elm_Genlist_Item *it,
|
2011-04-22 05:22:57 -07:00
|
|
|
Evas_Object *target,
|
2011-04-22 06:20:06 -07:00
|
|
|
Eina_List **source)
|
2011-04-22 02:56:49 -07:00
|
|
|
{
|
|
|
|
Eina_List *res = NULL;
|
|
|
|
|
|
|
|
if (it->itc->func.icon_get)
|
|
|
|
{
|
|
|
|
const Eina_List *l;
|
|
|
|
const char *key;
|
|
|
|
|
2011-04-22 06:20:06 -07:00
|
|
|
*source = elm_widget_stringlist_get(edje_object_data_get(target, "icons"));
|
|
|
|
EINA_LIST_FOREACH(*source, l, key)
|
2011-04-22 02:56:49 -07:00
|
|
|
{
|
|
|
|
Evas_Object *ic = it->itc->func.icon_get
|
|
|
|
((void *)it->base.data, it->base.widget, key);
|
|
|
|
|
|
|
|
if (ic)
|
|
|
|
{
|
2011-04-22 05:22:57 -07:00
|
|
|
res = eina_list_append(res, ic);
|
2011-04-22 06:20:06 -07:00
|
|
|
edje_object_part_swallow(target, key, ic);
|
2011-04-22 02:56:49 -07:00
|
|
|
evas_object_show(ic);
|
|
|
|
elm_widget_sub_object_add(it->base.widget, ic);
|
2011-05-05 19:07:00 -07:00
|
|
|
if (it->disabled)
|
|
|
|
elm_widget_disabled_set(ic, EINA_TRUE);
|
2011-04-22 02:56:49 -07:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return res;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
_item_state_realize(Elm_Genlist_Item *it,
|
2011-04-22 05:22:57 -07:00
|
|
|
Evas_Object *target,
|
2011-04-22 06:20:06 -07:00
|
|
|
Eina_List **source)
|
2011-04-22 02:56:49 -07:00
|
|
|
{
|
|
|
|
if (it->itc->func.state_get)
|
|
|
|
{
|
|
|
|
const Eina_List *l;
|
|
|
|
const char *key;
|
2011-04-22 05:22:57 -07:00
|
|
|
char buf[4096];
|
2011-04-22 02:56:49 -07:00
|
|
|
|
2011-04-22 06:20:06 -07:00
|
|
|
*source = elm_widget_stringlist_get(edje_object_data_get(target, "states"));
|
|
|
|
EINA_LIST_FOREACH(*source, l, key)
|
2011-04-22 02:56:49 -07:00
|
|
|
{
|
|
|
|
Eina_Bool on = it->itc->func.state_get
|
|
|
|
((void *)it->base.data, it->base.widget, key);
|
|
|
|
|
|
|
|
if (on)
|
|
|
|
{
|
|
|
|
snprintf(buf, sizeof(buf), "elm,state,%s,active", key);
|
|
|
|
edje_object_signal_emit(target, buf, "elm");
|
|
|
|
}
|
2011-04-22 05:22:57 -07:00
|
|
|
else
|
|
|
|
{
|
|
|
|
snprintf(buf, sizeof(buf), "elm,state,%s,passive", key);
|
|
|
|
edje_object_signal_emit(target, buf, "elm");
|
|
|
|
}
|
2011-04-22 02:56:49 -07:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2009-02-11 03:49:43 -08:00
|
|
|
static void
|
2011-03-22 00:54:24 -07:00
|
|
|
_item_realize(Elm_Genlist_Item *it,
|
|
|
|
int in,
|
|
|
|
Eina_Bool calc)
|
2009-02-11 03:49:43 -08:00
|
|
|
{
|
2009-03-14 11:03:19 -07:00
|
|
|
Elm_Genlist_Item *it2;
|
|
|
|
const char *treesize;
|
2009-02-12 05:39:43 -08:00
|
|
|
char buf[1024];
|
2009-03-14 11:03:19 -07:00
|
|
|
int depth, tsize = 20;
|
2011-01-31 02:33:22 -08:00
|
|
|
Item_Cache *itc = NULL;
|
2010-12-07 11:18:14 -08:00
|
|
|
|
2011-05-27 03:30:56 -07:00
|
|
|
if (it->delete_me) return;
|
2011-06-08 09:56:50 -07:00
|
|
|
//evas_event_freeze(evas_object_evas_get(it->wd->obj));
|
2011-04-22 02:56:22 -07:00
|
|
|
if (it->realized)
|
|
|
|
{
|
2011-04-22 05:22:57 -07:00
|
|
|
if (it->order_num_in != in)
|
|
|
|
{
|
|
|
|
it->order_num_in = in;
|
|
|
|
_elm_genlist_item_odd_even_update(it);
|
|
|
|
_elm_genlist_item_state_update(it, NULL);
|
|
|
|
}
|
2011-06-08 09:56:50 -07:00
|
|
|
//evas_event_thaw(evas_object_evas_get(it->wd->obj));
|
|
|
|
//evas_event_thaw_eval(evas_object_evas_get(it->wd->obj));
|
2011-04-22 05:22:57 -07:00
|
|
|
return;
|
2011-04-22 02:56:22 -07:00
|
|
|
}
|
2010-11-05 23:02:22 -07:00
|
|
|
it->order_num_in = in;
|
|
|
|
|
2011-01-31 02:33:22 -08:00
|
|
|
if (it->nocache)
|
2011-03-22 00:54:24 -07:00
|
|
|
it->nocache = EINA_FALSE;
|
2011-01-31 02:33:22 -08:00
|
|
|
else
|
2011-03-22 00:54:24 -07:00
|
|
|
itc = _item_cache_find(it);
|
2010-11-05 23:02:22 -07:00
|
|
|
if (itc)
|
|
|
|
{
|
|
|
|
it->base.view = itc->base_view;
|
|
|
|
itc->base_view = NULL;
|
|
|
|
it->spacer = itc->spacer;
|
|
|
|
itc->spacer = NULL;
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
2011-04-22 02:56:22 -07:00
|
|
|
const char *stacking_even;
|
2011-04-22 05:22:57 -07:00
|
|
|
const char *stacking;
|
2011-04-22 02:56:22 -07:00
|
|
|
|
2010-12-07 11:18:14 -08:00
|
|
|
it->base.view = edje_object_add(evas_object_evas_get(it->base.widget));
|
|
|
|
edje_object_scale_set(it->base.view,
|
|
|
|
elm_widget_scale_get(it->base.widget) *
|
|
|
|
_elm_config->scale);
|
|
|
|
evas_object_smart_member_add(it->base.view, it->wd->pan_smart);
|
|
|
|
elm_widget_sub_object_add(it->base.widget, it->base.view);
|
|
|
|
|
|
|
|
if (it->flags & ELM_GENLIST_ITEM_SUBITEMS)
|
|
|
|
strncpy(buf, "tree", sizeof(buf));
|
|
|
|
else strncpy(buf, "item", sizeof(buf));
|
|
|
|
if (it->wd->compress)
|
|
|
|
strncat(buf, "_compress", sizeof(buf) - strlen(buf));
|
|
|
|
|
|
|
|
strncat(buf, "/", sizeof(buf) - strlen(buf));
|
|
|
|
strncat(buf, it->itc->item_style, sizeof(buf) - strlen(buf));
|
|
|
|
|
|
|
|
_elm_theme_object_set(it->base.widget, it->base.view, "genlist", buf,
|
|
|
|
elm_widget_style_get(it->base.widget));
|
2011-04-22 02:56:22 -07:00
|
|
|
|
2011-04-22 05:22:57 -07:00
|
|
|
stacking_even = edje_object_data_get(it->base.view, "stacking_even");
|
|
|
|
if (!stacking_even) stacking_even = "above";
|
|
|
|
it->stacking_even = !!strcmp("above", stacking_even);
|
2011-04-22 02:56:22 -07:00
|
|
|
|
2011-04-22 05:22:57 -07:00
|
|
|
stacking = edje_object_data_get(it->base.view, "stacking");
|
|
|
|
if (!stacking) stacking = "yes";
|
|
|
|
it->nostacking = !!strcmp("yes", stacking);
|
2011-04-22 02:56:22 -07:00
|
|
|
|
2011-03-22 00:54:24 -07:00
|
|
|
edje_object_mirrored_set(it->base.view,
|
|
|
|
elm_widget_mirrored_get(it->base.widget));
|
2010-12-07 11:18:14 -08:00
|
|
|
it->spacer =
|
2011-04-01 09:33:58 -07:00
|
|
|
evas_object_rectangle_add(evas_object_evas_get(it->base.widget));
|
2010-12-07 11:18:14 -08:00
|
|
|
evas_object_color_set(it->spacer, 0, 0, 0, 0);
|
|
|
|
elm_widget_sub_object_add(it->base.widget, it->spacer);
|
2010-11-05 23:02:22 -07:00
|
|
|
}
|
2011-04-22 02:56:22 -07:00
|
|
|
|
|
|
|
_elm_genlist_item_odd_even_update(it);
|
|
|
|
|
2011-01-05 21:13:11 -08:00
|
|
|
for (it2 = it, depth = 0; it2->parent; it2 = it2->parent)
|
|
|
|
{
|
|
|
|
if (it2->parent->flags != ELM_GENLIST_ITEM_GROUP) depth += 1;
|
|
|
|
}
|
2010-10-06 23:45:36 -07:00
|
|
|
it->expanded_depth = depth;
|
2010-09-09 19:05:45 -07:00
|
|
|
treesize = edje_object_data_get(it->base.view, "treesize");
|
2009-03-14 11:03:19 -07:00
|
|
|
if (treesize) tsize = atoi(treesize);
|
2009-09-23 15:56:47 -07:00
|
|
|
evas_object_size_hint_min_set(it->spacer,
|
2009-09-04 08:39:30 -07:00
|
|
|
(depth * tsize) * _elm_config->scale, 1);
|
2010-09-09 19:05:45 -07:00
|
|
|
edje_object_part_swallow(it->base.view, "elm.swallow.pad", it->spacer);
|
2009-02-12 05:39:43 -08:00
|
|
|
if (!calc)
|
|
|
|
{
|
2010-12-07 11:18:14 -08:00
|
|
|
edje_object_signal_callback_add(it->base.view,
|
|
|
|
"elm,action,expand,toggle",
|
2009-09-04 08:39:30 -07:00
|
|
|
"elm", _signal_expand_toggle, it);
|
2010-12-07 11:18:14 -08:00
|
|
|
edje_object_signal_callback_add(it->base.view, "elm,action,expand",
|
|
|
|
"elm", _signal_expand, it);
|
2010-10-15 04:51:15 -07:00
|
|
|
edje_object_signal_callback_add(it->base.view, "elm,action,contract",
|
2009-09-04 08:39:30 -07:00
|
|
|
"elm", _signal_contract, it);
|
2010-10-15 04:51:15 -07:00
|
|
|
evas_object_event_callback_add(it->base.view, EVAS_CALLBACK_MOUSE_DOWN,
|
|
|
|
_mouse_down, it);
|
|
|
|
evas_object_event_callback_add(it->base.view, EVAS_CALLBACK_MOUSE_UP,
|
|
|
|
_mouse_up, it);
|
|
|
|
evas_object_event_callback_add(it->base.view, EVAS_CALLBACK_MOUSE_MOVE,
|
|
|
|
_mouse_move, 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
|
|
|
evas_object_event_callback_add(it->base.view, EVAS_CALLBACK_MULTI_DOWN,
|
|
|
|
_multi_down, it);
|
|
|
|
evas_object_event_callback_add(it->base.view, EVAS_CALLBACK_MULTI_UP,
|
|
|
|
_multi_up, it);
|
|
|
|
evas_object_event_callback_add(it->base.view, EVAS_CALLBACK_MULTI_MOVE,
|
|
|
|
_multi_move, it);
|
2011-04-22 02:56:22 -07:00
|
|
|
|
2011-04-22 05:22:57 -07:00
|
|
|
_elm_genlist_item_state_update(it, itc);
|
2009-02-11 03:49:43 -08:00
|
|
|
}
|
2009-07-06 23:46:51 -07:00
|
|
|
|
2011-06-03 18:52:08 -07:00
|
|
|
if ((calc) && (it->wd->homogeneous) &&
|
|
|
|
((it->wd->item_width) ||
|
|
|
|
((it->wd->item_width) && (it->wd->group_item_width))))
|
2009-02-11 03:49:43 -08:00
|
|
|
{
|
2010-10-15 04:51:15 -07:00
|
|
|
/* homogenous genlist shortcut */
|
2011-03-29 05:43:03 -07:00
|
|
|
if (!it->mincalcd)
|
|
|
|
{
|
|
|
|
if (it->flags & ELM_GENLIST_ITEM_GROUP)
|
|
|
|
{
|
|
|
|
it->w = it->minw = it->wd->group_item_width;
|
|
|
|
it->h = it->minh = it->wd->group_item_height;
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
it->w = it->minw = it->wd->item_width;
|
|
|
|
it->h = it->minh = it->wd->item_height;
|
|
|
|
}
|
|
|
|
it->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
|
|
|
{
|
2011-04-26 19:42:50 -07:00
|
|
|
/* FIXME: If you see that assert, please notify us and we
|
2011-04-22 05:22:57 -07:00
|
|
|
will clean our mess */
|
2011-04-22 06:20:06 -07:00
|
|
|
assert(eina_list_count(it->icon_objs) == 0);
|
2010-10-15 04:51:15 -07:00
|
|
|
|
2011-04-22 06:20:06 -07:00
|
|
|
_item_label_realize(it, it->base.view, &it->labels);
|
|
|
|
it->icon_objs = _item_icon_realize(it, it->base.view, &it->icons);
|
|
|
|
_item_state_realize(it, it->base.view, &it->states);
|
2010-10-15 04:51:15 -07:00
|
|
|
|
|
|
|
if (!it->mincalcd)
|
|
|
|
{
|
|
|
|
Evas_Coord mw = -1, mh = -1;
|
2010-10-07 12:57:20 -07:00
|
|
|
|
2010-02-04 00:06:41 -08:00
|
|
|
if (!it->display_only)
|
2010-12-07 11:18:14 -08:00
|
|
|
elm_coords_finger_size_adjust(1, &mw, 1, &mh);
|
2010-11-20 00:43:43 -08:00
|
|
|
if (it->wd->height_for_width) mw = it->wd->prev_viewport_w;
|
2010-12-07 11:18:14 -08:00
|
|
|
edje_object_size_min_restricted_calc(it->base.view, &mw, &mh, mw,
|
|
|
|
mh);
|
2010-02-04 00:06:41 -08:00
|
|
|
if (!it->display_only)
|
2010-12-07 11:18:14 -08:00
|
|
|
elm_coords_finger_size_adjust(1, &mw, 1, &mh);
|
2010-10-15 04:51:15 -07:00
|
|
|
it->w = it->minw = mw;
|
|
|
|
it->h = it->minh = mh;
|
|
|
|
it->mincalcd = EINA_TRUE;
|
2010-01-23 01:07:20 -08:00
|
|
|
|
2011-03-29 02:28:09 -07:00
|
|
|
if ((!it->wd->group_item_width) && (it->flags == ELM_GENLIST_ITEM_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
|
|
|
{
|
|
|
|
it->wd->group_item_width = mw;
|
|
|
|
it->wd->group_item_height = mh;
|
|
|
|
}
|
2011-03-29 02:28:09 -07:00
|
|
|
else if ((!it->wd->item_width) && (it->flags == ELM_GENLIST_ITEM_NONE))
|
2010-10-15 04:51:15 -07:00
|
|
|
{
|
|
|
|
it->wd->item_width = mw;
|
|
|
|
it->wd->item_height = mh;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
if (!calc) evas_object_show(it->base.view);
|
2009-02-11 03:49:43 -08:00
|
|
|
}
|
2010-09-27 11:18:37 -07:00
|
|
|
|
|
|
|
if (it->tooltip.content_cb)
|
|
|
|
{
|
2010-10-15 04:51:15 -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);
|
2011-07-27 19:22:37 -07:00
|
|
|
elm_widget_item_tooltip_size_restrict_disable(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
|
|
|
|
|
|
|
if (itc) _item_cache_free(itc);
|
2011-06-08 09:56:50 -07:00
|
|
|
//evas_event_thaw(evas_object_evas_get(it->wd->obj));
|
|
|
|
//evas_event_thaw_eval(evas_object_evas_get(it->wd->obj));
|
2011-06-03 18:52:08 -07:00
|
|
|
if (!calc)
|
|
|
|
evas_object_smart_callback_call(it->base.widget, SIG_REALIZED, it);
|
2011-07-05 10:17:14 -07:00
|
|
|
edje_object_message_signal_process(it->base.view);
|
2009-02-11 03:49:43 -08:00
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
2011-06-03 18:52:08 -07:00
|
|
|
_item_unrealize(Elm_Genlist_Item *it,
|
|
|
|
Eina_Bool calc)
|
2009-02-11 03:49:43 -08:00
|
|
|
{
|
2009-05-11 06:10:19 -07:00
|
|
|
Evas_Object *icon;
|
2009-07-06 23:46:51 -07:00
|
|
|
|
2009-02-11 03:49:43 -08:00
|
|
|
if (!it->realized) return;
|
2011-06-01 20:10:11 -07:00
|
|
|
if (it->wd->reorder_it == it) return;
|
2011-05-27 03:30:56 -07:00
|
|
|
evas_event_freeze(evas_object_evas_get(it->wd->obj));
|
2011-06-03 18:52:08 -07:00
|
|
|
if (!calc)
|
|
|
|
evas_object_smart_callback_call(it->base.widget, SIG_UNREALIZED, it);
|
2010-03-25 20:17:05 -07:00
|
|
|
if (it->long_timer)
|
|
|
|
{
|
2010-10-15 04:51:15 -07:00
|
|
|
ecore_timer_del(it->long_timer);
|
|
|
|
it->long_timer = NULL;
|
2010-03-25 20:17:05 -07:00
|
|
|
}
|
2011-01-31 02:33:22 -08:00
|
|
|
if (it->nocache)
|
|
|
|
{
|
|
|
|
evas_object_del(it->base.view);
|
|
|
|
it->base.view = NULL;
|
|
|
|
evas_object_del(it->spacer);
|
|
|
|
it->spacer = NULL;
|
|
|
|
}
|
|
|
|
else
|
2011-02-08 04:08:28 -08:00
|
|
|
{
|
2011-06-03 18:52:08 -07:00
|
|
|
edje_object_mirrored_set(it->base.view,
|
|
|
|
elm_widget_mirrored_get(it->base.widget));
|
|
|
|
edje_object_scale_set(it->base.view,
|
|
|
|
elm_widget_scale_get(it->base.widget)
|
|
|
|
* _elm_config->scale);
|
2011-02-08 04:08:28 -08:00
|
|
|
_item_cache_add(it);
|
|
|
|
}
|
2010-09-13 00:56:23 -07:00
|
|
|
elm_widget_stringlist_free(it->labels);
|
2009-02-12 05:39:43 -08:00
|
|
|
it->labels = NULL;
|
2010-09-13 00:56:23 -07:00
|
|
|
elm_widget_stringlist_free(it->icons);
|
2009-02-12 05:39:43 -08:00
|
|
|
it->icons = NULL;
|
2010-09-13 00:56:23 -07:00
|
|
|
elm_widget_stringlist_free(it->states);
|
2009-02-25 12:18:38 -08:00
|
|
|
|
2010-12-07 11:18:14 -08:00
|
|
|
EINA_LIST_FREE(it->icon_objs, icon)
|
2011-04-01 09:33:58 -07:00
|
|
|
evas_object_del(icon);
|
2009-02-25 12:18:38 -08:00
|
|
|
|
2011-04-21 04:47:36 -07:00
|
|
|
_mode_item_unrealize(it);
|
2009-02-12 05:39:43 -08:00
|
|
|
it->states = NULL;
|
2009-06-17 08:35:19 -07:00
|
|
|
it->realized = EINA_FALSE;
|
2010-03-26 21:17:01 -07:00
|
|
|
it->want_unrealize = EINA_FALSE;
|
2011-05-27 03:30:56 -07:00
|
|
|
evas_event_thaw(evas_object_evas_get(it->wd->obj));
|
|
|
|
evas_event_thaw_eval(evas_object_evas_get(it->wd->obj));
|
2009-02-11 03:49:43 -08:00
|
|
|
}
|
|
|
|
|
2011-03-18 07:29:48 -07:00
|
|
|
static Eina_Bool
|
2010-12-07 11:18:14 -08:00
|
|
|
_item_block_recalc(Item_Block *itb,
|
|
|
|
int in,
|
2011-06-08 03:58:00 -07:00
|
|
|
Eina_Bool qadd)
|
2009-02-11 03:49:43 -08:00
|
|
|
{
|
2009-02-25 11:50:45 -08:00
|
|
|
const Eina_List *l;
|
|
|
|
Elm_Genlist_Item *it;
|
2009-02-11 03:49:43 -08:00
|
|
|
Evas_Coord minw = 0, minh = 0;
|
2010-12-20 09:03:12 -08:00
|
|
|
Eina_Bool showme = EINA_FALSE, changed = EINA_FALSE;
|
2009-02-17 20:18:25 -08:00
|
|
|
Evas_Coord y = 0;
|
2009-02-25 11:50:45 -08:00
|
|
|
|
2011-06-08 09:56:50 -07:00
|
|
|
//evas_event_freeze(evas_object_evas_get(itb->wd->obj));
|
2010-01-23 01:07:20 -08:00
|
|
|
itb->num = in;
|
2009-02-25 11:50:45 -08:00
|
|
|
EINA_LIST_FOREACH(itb->items, l, it)
|
2009-02-11 03:49:43 -08:00
|
|
|
{
|
2010-10-15 04:51:15 -07:00
|
|
|
if (it->delete_me) continue;
|
|
|
|
showme |= it->showme;
|
|
|
|
if (!itb->realized)
|
|
|
|
{
|
2010-01-23 01:07:20 -08:00
|
|
|
if (qadd)
|
|
|
|
{
|
2010-12-20 09:03:12 -08:00
|
|
|
if (!it->mincalcd) changed = EINA_TRUE;
|
2010-01-23 01:07:20 -08:00
|
|
|
if (changed)
|
|
|
|
{
|
2011-03-18 08:02:49 -07:00
|
|
|
_item_realize(it, in, EINA_TRUE);
|
2011-04-14 04:41:07 -07:00
|
|
|
_item_unrealize(it, EINA_TRUE);
|
2010-01-23 01:07:20 -08:00
|
|
|
}
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
2011-03-18 08:02:49 -07:00
|
|
|
_item_realize(it, in, EINA_TRUE);
|
2011-04-14 04:41:07 -07:00
|
|
|
_item_unrealize(it, EINA_TRUE);
|
2010-01-23 01:07:20 -08:00
|
|
|
}
|
2010-10-15 04:51:15 -07:00
|
|
|
}
|
|
|
|
else
|
2011-03-18 08:02:49 -07:00
|
|
|
_item_realize(it, in, EINA_FALSE);
|
2010-10-15 04:51:15 -07:00
|
|
|
minh += it->minh;
|
|
|
|
if (minw < it->minw) minw = it->minw;
|
|
|
|
in++;
|
|
|
|
it->x = 0;
|
|
|
|
it->y = y;
|
|
|
|
y += it->h;
|
2009-02-11 03:49:43 -08:00
|
|
|
}
|
|
|
|
itb->minw = minw;
|
|
|
|
itb->minh = minh;
|
2009-06-17 08:35:19 -07:00
|
|
|
itb->changed = EINA_FALSE;
|
2011-06-08 09:56:50 -07:00
|
|
|
//evas_event_thaw(evas_object_evas_get(itb->wd->obj));
|
|
|
|
//evas_event_thaw_eval(evas_object_evas_get(itb->wd->obj));
|
2009-02-17 06:39:08 -08:00
|
|
|
return showme;
|
2009-02-11 03:49:43 -08:00
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
2011-06-08 03:48:20 -07:00
|
|
|
_item_block_realize(Item_Block *itb)
|
2009-02-11 03:49:43 -08:00
|
|
|
{
|
|
|
|
if (itb->realized) return;
|
2009-06-17 08:35:19 -07:00
|
|
|
itb->realized = EINA_TRUE;
|
2010-03-26 21:17:01 -07:00
|
|
|
itb->want_unrealize = EINA_FALSE;
|
2009-02-11 03:49:43 -08:00
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
_item_block_unrealize(Item_Block *itb)
|
|
|
|
{
|
2009-02-25 11:50:45 -08:00
|
|
|
const Eina_List *l;
|
|
|
|
Elm_Genlist_Item *it;
|
2010-12-20 09:03:12 -08:00
|
|
|
Eina_Bool dragging = EINA_FALSE;
|
2009-02-25 11:50:45 -08:00
|
|
|
|
2009-02-11 03:49:43 -08:00
|
|
|
if (!itb->realized) return;
|
2011-05-27 03:30:56 -07:00
|
|
|
evas_event_freeze(evas_object_evas_get(itb->wd->obj));
|
2009-02-25 11:50:45 -08:00
|
|
|
EINA_LIST_FOREACH(itb->items, l, it)
|
2009-10-07 07:02:55 -07:00
|
|
|
{
|
2011-01-05 21:13:11 -08:00
|
|
|
if (it->flags != ELM_GENLIST_ITEM_GROUP)
|
2009-10-07 07:02:55 -07:00
|
|
|
{
|
2011-01-05 21:13:11 -08:00
|
|
|
if (it->dragging)
|
|
|
|
{
|
|
|
|
dragging = EINA_TRUE;
|
|
|
|
it->want_unrealize = EINA_TRUE;
|
|
|
|
}
|
|
|
|
else
|
2011-04-14 04:41:07 -07:00
|
|
|
_item_unrealize(it, EINA_FALSE);
|
2009-10-07 07:02:55 -07:00
|
|
|
}
|
|
|
|
}
|
|
|
|
if (!dragging)
|
2010-03-26 21:17:01 -07:00
|
|
|
{
|
|
|
|
itb->realized = EINA_FALSE;
|
|
|
|
itb->want_unrealize = EINA_TRUE;
|
|
|
|
}
|
|
|
|
else
|
|
|
|
itb->want_unrealize = EINA_FALSE;
|
2011-05-27 03:30:56 -07:00
|
|
|
evas_event_thaw(evas_object_evas_get(itb->wd->obj));
|
|
|
|
evas_event_thaw_eval(evas_object_evas_get(itb->wd->obj));
|
2009-02-11 03:49:43 -08:00
|
|
|
}
|
|
|
|
|
2011-06-01 20:10:11 -07:00
|
|
|
static int
|
|
|
|
_get_space_for_reorder_item(Elm_Genlist_Item *it)
|
|
|
|
{
|
|
|
|
Evas_Coord rox, roy, row, roh, oy, oh;
|
|
|
|
Eina_Bool top = EINA_FALSE;
|
|
|
|
Elm_Genlist_Item *reorder_it = it->wd->reorder_it;
|
|
|
|
if (!reorder_it) return 0;
|
2011-06-01 21:24:58 -07:00
|
|
|
|
2011-06-01 20:10:11 -07:00
|
|
|
evas_object_geometry_get(it->wd->pan_smart, NULL, &oy, NULL, &oh);
|
|
|
|
evas_object_geometry_get(it->wd->reorder_it->base.view, &rox, &roy, &row, &roh);
|
2011-06-01 21:24:58 -07:00
|
|
|
|
|
|
|
if ((it->wd->reorder_start_y < it->block->y) &&
|
2011-06-01 20:10:11 -07:00
|
|
|
(roy - oy + (roh / 2) >= it->block->y - it->wd->pan_y))
|
|
|
|
{
|
|
|
|
it->block->reorder_offset = it->wd->reorder_it->h * -1;
|
|
|
|
if (it->block->count == 1)
|
|
|
|
it->wd->reorder_rel = it;
|
|
|
|
}
|
2011-06-01 21:24:58 -07:00
|
|
|
else if ((it->wd->reorder_start_y >= it->block->y) &&
|
2011-06-01 20:10:11 -07:00
|
|
|
(roy - oy + (roh / 2) <= it->block->y - it->wd->pan_y))
|
|
|
|
{
|
|
|
|
it->block->reorder_offset = it->wd->reorder_it->h;
|
|
|
|
}
|
|
|
|
else
|
2011-06-23 02:51:03 -07:00
|
|
|
it->block->reorder_offset = 0;
|
2011-06-01 21:24:58 -07:00
|
|
|
|
2011-06-01 20:10:11 -07:00
|
|
|
it->scrl_y += it->block->reorder_offset;
|
2011-06-01 21:24:58 -07:00
|
|
|
|
2011-06-01 20:10:11 -07:00
|
|
|
top = (ELM_RECTS_INTERSECT(it->scrl_x, it->scrl_y, it->w, it->h,
|
|
|
|
rox, roy + (roh / 2), row, 1));
|
|
|
|
if (top)
|
|
|
|
{
|
|
|
|
it->wd->reorder_rel = it;
|
|
|
|
it->scrl_y += it->wd->reorder_it->h;
|
|
|
|
return it->wd->reorder_it->h;
|
|
|
|
}
|
|
|
|
else
|
2011-06-23 02:51:03 -07:00
|
|
|
return 0;
|
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
|
|
|
{
|
|
|
|
Elm_Genlist_Item *it = data;
|
|
|
|
Eina_Bool down = EINA_FALSE;
|
2011-06-08 03:58:00 -07:00
|
|
|
double t;
|
2011-06-01 20:10:11 -07:00
|
|
|
int y, dy = it->h / 10 * _elm_config->scale, diff;
|
2011-06-01 21:24:58 -07:00
|
|
|
|
2011-06-01 20:10:11 -07:00
|
|
|
t = ((0.0 > (t = ecore_loop_time_get()-it->wd->start_time)) ? 0.0 : t);
|
2011-06-01 21:24:58 -07:00
|
|
|
|
2011-06-08 03:58:00 -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-06-01 20:10:11 -07:00
|
|
|
diff = abs(it->old_scrl_y - it->scrl_y);
|
|
|
|
if (diff > it->h) y = diff / 2;
|
2011-06-01 21:24:58 -07:00
|
|
|
|
2011-06-01 20:10:11 -07:00
|
|
|
if (it->old_scrl_y < it->scrl_y)
|
|
|
|
{
|
|
|
|
it->old_scrl_y += y;
|
|
|
|
down = EINA_TRUE;
|
|
|
|
}
|
|
|
|
else if (it->old_scrl_y > it->scrl_y)
|
|
|
|
{
|
|
|
|
it->old_scrl_y -= y;
|
|
|
|
down = EINA_FALSE;
|
|
|
|
}
|
|
|
|
_item_position(it, it->base.view, it->scrl_x, it->old_scrl_y);
|
|
|
|
_group_items_recalc(it->wd);
|
2011-06-01 21:24:58 -07:00
|
|
|
|
2011-06-01 20:10:11 -07:00
|
|
|
if ((it->wd->reorder_pan_move) ||
|
2011-06-01 21:24:58 -07:00
|
|
|
(down && it->old_scrl_y >= it->scrl_y) ||
|
2011-06-01 20:10:11 -07:00
|
|
|
(!down && it->old_scrl_y <= it->scrl_y))
|
|
|
|
{
|
|
|
|
it->old_scrl_y = it->scrl_y;
|
|
|
|
it->move_effect_enabled = EINA_FALSE;
|
2011-06-03 18:52:08 -07:00
|
|
|
it->wd->reorder_move_animator = NULL;
|
2011-06-01 20:10:11 -07:00
|
|
|
return ECORE_CALLBACK_CANCEL;
|
|
|
|
}
|
|
|
|
return ECORE_CALLBACK_RENEW;
|
|
|
|
}
|
|
|
|
|
2011-04-21 04:47:36 -07:00
|
|
|
static void
|
2011-06-03 18:52:08 -07:00
|
|
|
_item_position(Elm_Genlist_Item *it,
|
|
|
|
Evas_Object *view,
|
|
|
|
Evas_Coord it_x,
|
|
|
|
Evas_Coord it_y)
|
2011-04-21 04:47:36 -07:00
|
|
|
{
|
|
|
|
if (!it) return;
|
|
|
|
if (!view) return;
|
|
|
|
|
2011-05-27 03:30:56 -07:00
|
|
|
evas_event_freeze(evas_object_evas_get(it->wd->obj));
|
2011-04-21 04:47:36 -07:00
|
|
|
evas_object_resize(view, it->w, it->h);
|
2011-06-01 20:10:11 -07:00
|
|
|
evas_object_move(view, it_x, it_y);
|
2011-04-21 04:47:36 -07:00
|
|
|
evas_object_show(view);
|
2011-05-27 03:30:56 -07:00
|
|
|
evas_event_thaw(evas_object_evas_get(it->wd->obj));
|
|
|
|
evas_event_thaw_eval(evas_object_evas_get(it->wd->obj));
|
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,
|
|
|
|
int in)
|
2009-02-11 03:49:43 -08:00
|
|
|
{
|
2009-02-25 11:50:45 -08:00
|
|
|
const Eina_List *l;
|
|
|
|
Elm_Genlist_Item *it;
|
2011-01-05 21:13:11 -08:00
|
|
|
Elm_Genlist_Item *git;
|
2010-01-16 04:35:31 -08:00
|
|
|
Evas_Coord y = 0, ox, oy, ow, oh, cvx, cvy, cvw, cvh;
|
2009-05-11 06:10:19 -07:00
|
|
|
int vis;
|
2009-07-06 23:46:51 -07:00
|
|
|
|
2011-05-27 03:30:56 -07:00
|
|
|
evas_event_freeze(evas_object_evas_get(itb->wd->obj));
|
2009-05-11 06:10:19 -07:00
|
|
|
evas_object_geometry_get(itb->wd->pan_smart, &ox, &oy, &ow, &oh);
|
2010-12-07 11:18:14 -08:00
|
|
|
evas_output_viewport_get(evas_object_evas_get(itb->wd->obj), &cvx, &cvy,
|
|
|
|
&cvw, &cvh);
|
2009-02-25 11:50:45 -08:00
|
|
|
EINA_LIST_FOREACH(itb->items, l, it)
|
2009-02-11 03:49:43 -08:00
|
|
|
{
|
2010-10-15 04:51:15 -07:00
|
|
|
if (it->delete_me) continue;
|
2011-06-01 20:10:11 -07:00
|
|
|
else if (it->wd->reorder_it == it) continue;
|
2010-10-15 04:51:15 -07:00
|
|
|
it->x = 0;
|
|
|
|
it->y = y;
|
|
|
|
it->w = itb->w;
|
2011-01-05 21:13:11 -08:00
|
|
|
it->scrl_x = itb->x + it->x - it->wd->pan_x + ox;
|
|
|
|
it->scrl_y = itb->y + it->y - it->wd->pan_y + oy;
|
|
|
|
|
2011-01-31 00:30:11 -08:00
|
|
|
vis = (ELM_RECTS_INTERSECT(it->scrl_x, it->scrl_y, it->w, it->h,
|
|
|
|
cvx, cvy, cvw, cvh));
|
2011-01-05 21:13:11 -08:00
|
|
|
if (it->flags != ELM_GENLIST_ITEM_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
|
|
|
{
|
2011-01-05 21:13:11 -08:00
|
|
|
if (vis)
|
|
|
|
{
|
2011-06-01 20:10:11 -07:00
|
|
|
if (it->wd->reorder_mode)
|
|
|
|
y += _get_space_for_reorder_item(it);
|
2011-01-05 21:13:11 -08:00
|
|
|
git = it->group_item;
|
|
|
|
if (git)
|
|
|
|
{
|
|
|
|
if (git->scrl_y < oy)
|
2011-03-22 00:54:24 -07:00
|
|
|
git->scrl_y = oy;
|
2011-01-05 21:13:11 -08:00
|
|
|
if ((git->scrl_y + git->h) > (it->scrl_y + it->h))
|
2011-03-22 00:54:24 -07:00
|
|
|
git->scrl_y = (it->scrl_y + it->h) - git->h;
|
2011-01-05 21:13:11 -08:00
|
|
|
git->want_realize = EINA_TRUE;
|
|
|
|
}
|
2011-06-01 20:10:11 -07:00
|
|
|
if ((it->wd->reorder_it) && (it->old_scrl_y != it->scrl_y))
|
|
|
|
{
|
|
|
|
if (!it->move_effect_enabled)
|
|
|
|
{
|
|
|
|
it->move_effect_enabled = EINA_TRUE;
|
2011-06-03 18:52:08 -07:00
|
|
|
it->wd->reorder_move_animator =
|
|
|
|
ecore_animator_add(
|
|
|
|
_reorder_move_animator_cb, it);
|
2011-06-01 20:10:11 -07:00
|
|
|
}
|
|
|
|
}
|
|
|
|
if (!it->move_effect_enabled)
|
2011-06-08 19:54:04 -07:00
|
|
|
{
|
2011-08-03 00:16:20 -07:00
|
|
|
if (it->mode_view)
|
|
|
|
_item_position(it, it->mode_view, it->scrl_x,
|
|
|
|
it->scrl_y);
|
|
|
|
else
|
|
|
|
_item_position(it, it->base.view, it->scrl_x,
|
|
|
|
it->scrl_y);
|
2011-06-08 19:54:04 -07:00
|
|
|
it->old_scrl_y = it->scrl_y;
|
|
|
|
}
|
2011-01-05 21:13:11 -08:00
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
2011-04-14 04:41:07 -07:00
|
|
|
if (!it->dragging) _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-03-22 00:54:24 -07:00
|
|
|
if (vis) it->want_realize = EINA_TRUE;
|
2011-01-31 00:30:11 -08:00
|
|
|
}
|
2010-10-15 04:51:15 -07:00
|
|
|
y += it->h;
|
2011-01-05 21:13:11 -08:00
|
|
|
}
|
2011-05-27 03:30:56 -07:00
|
|
|
evas_event_thaw(evas_object_evas_get(itb->wd->obj));
|
|
|
|
evas_event_thaw_eval(evas_object_evas_get(itb->wd->obj));
|
2011-01-05 21:13:11 -08:00
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
_group_items_recalc(void *data)
|
|
|
|
{
|
|
|
|
Widget_Data *wd = data;
|
|
|
|
Eina_List *l;
|
|
|
|
Elm_Genlist_Item *git;
|
|
|
|
|
2011-05-27 03:30:56 -07:00
|
|
|
evas_event_freeze(evas_object_evas_get(wd->obj));
|
2011-01-05 21:13:11 -08:00
|
|
|
EINA_LIST_FOREACH(wd->group_items, l, git)
|
|
|
|
{
|
2011-03-18 07:29:48 -07:00
|
|
|
if (git->want_realize)
|
2011-01-05 21:13:11 -08:00
|
|
|
{
|
|
|
|
if (!git->realized)
|
2011-03-22 00:54:24 -07:00
|
|
|
_item_realize(git, 0, EINA_FALSE);
|
2011-01-05 21:13:11 -08:00
|
|
|
evas_object_resize(git->base.view, wd->minw, git->h);
|
|
|
|
evas_object_move(git->base.view, git->scrl_x, git->scrl_y);
|
|
|
|
evas_object_show(git->base.view);
|
|
|
|
evas_object_raise(git->base.view);
|
|
|
|
}
|
|
|
|
else if (!git->want_realize && git->realized)
|
|
|
|
{
|
2011-03-18 07:29:48 -07:00
|
|
|
if (!git->dragging)
|
2011-04-14 04:41:07 -07:00
|
|
|
_item_unrealize(git, EINA_FALSE);
|
2011-01-05 21:13:11 -08:00
|
|
|
}
|
2009-02-11 03:49:43 -08:00
|
|
|
}
|
2011-05-27 03:30:56 -07:00
|
|
|
evas_event_thaw(evas_object_evas_get(wd->obj));
|
|
|
|
evas_event_thaw_eval(evas_object_evas_get(wd->obj));
|
2009-02-11 03:49:43 -08:00
|
|
|
}
|
|
|
|
|
2010-11-20 00:43:43 -08:00
|
|
|
static Eina_Bool
|
|
|
|
_must_recalc_idler(void *data)
|
|
|
|
{
|
2010-12-07 11:18:14 -08:00
|
|
|
Widget_Data *wd = data;
|
|
|
|
if (wd->calc_job) ecore_job_del(wd->calc_job);
|
|
|
|
wd->calc_job = ecore_job_add(_calc_job, wd);
|
|
|
|
wd->must_recalc_idler = NULL;
|
|
|
|
return ECORE_CALLBACK_CANCEL;
|
2010-11-20 00:43:43 -08:00
|
|
|
}
|
|
|
|
|
2009-02-10 03:57:47 -08:00
|
|
|
static void
|
2009-02-12 05:39:43 -08:00
|
|
|
_calc_job(void *data)
|
2009-02-10 03:57:47 -08:00
|
|
|
{
|
2009-02-12 05:39:43 -08:00
|
|
|
Widget_Data *wd = data;
|
2011-06-03 18:52:08 -07:00
|
|
|
Item_Block *itb, *chb = NULL;
|
2010-10-07 12:57:20 -07:00
|
|
|
Evas_Coord minw = -1, minh = 0, y = 0, ow;
|
2011-06-03 18:52:08 -07:00
|
|
|
int in = 0;
|
2010-11-20 00:43:43 -08:00
|
|
|
double t0, t;
|
2011-06-03 18:52:08 -07:00
|
|
|
Eina_Bool minw_change = EINA_FALSE, changed = EINA_FALSE;
|
2010-11-20 00:43:43 -08:00
|
|
|
Eina_Bool did_must_recalc = EINA_FALSE;
|
2010-03-09 06:42:41 -08:00
|
|
|
if (!wd) return;
|
2010-10-07 12:57:20 -07:00
|
|
|
|
2010-11-20 00:43:43 -08:00
|
|
|
t0 = ecore_time_get();
|
2010-10-07 12:57:20 -07:00
|
|
|
evas_object_geometry_get(wd->pan_smart, NULL, NULL, &ow, &wd->h);
|
|
|
|
if (wd->w != ow)
|
2011-05-24 03:51:26 -07:00
|
|
|
wd->w = ow;
|
2010-10-07 12:57:20 -07:00
|
|
|
|
2011-05-27 03:30:56 -07:00
|
|
|
evas_event_freeze(evas_object_evas_get(wd->obj));
|
2009-02-25 08:22:29 -08:00
|
|
|
EINA_INLIST_FOREACH(wd->blocks, itb)
|
2011-03-22 00:54:24 -07:00
|
|
|
{
|
|
|
|
Eina_Bool showme = EINA_FALSE;
|
|
|
|
|
|
|
|
itb->num = in;
|
|
|
|
showme = itb->showme;
|
|
|
|
itb->showme = EINA_FALSE;
|
|
|
|
if (chb)
|
|
|
|
{
|
|
|
|
if (itb->realized) _item_block_unrealize(itb);
|
|
|
|
}
|
|
|
|
if ((itb->changed) || (changed) ||
|
|
|
|
((itb->must_recalc) && (!did_must_recalc)))
|
|
|
|
{
|
|
|
|
if ((changed) || (itb->must_recalc))
|
|
|
|
{
|
|
|
|
Eina_List *l;
|
|
|
|
Elm_Genlist_Item *it;
|
|
|
|
EINA_LIST_FOREACH(itb->items, l, it)
|
2011-04-01 09:33:58 -07:00
|
|
|
if (it->mincalcd) it->mincalcd = EINA_FALSE;
|
2011-03-22 00:54:24 -07:00
|
|
|
itb->changed = EINA_TRUE;
|
|
|
|
if (itb->must_recalc) did_must_recalc = EINA_TRUE;
|
|
|
|
itb->must_recalc = EINA_FALSE;
|
|
|
|
}
|
|
|
|
if (itb->realized) _item_block_unrealize(itb);
|
2011-06-08 03:58:00 -07:00
|
|
|
showme = _item_block_recalc(itb, in, EINA_FALSE);
|
2011-03-22 00:54:24 -07:00
|
|
|
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;
|
2011-06-03 18:52:08 -07:00
|
|
|
minw_change = EINA_TRUE;
|
2011-03-22 00:54:24 -07:00
|
|
|
}
|
|
|
|
itb->w = minw;
|
|
|
|
itb->h = itb->minh;
|
|
|
|
y += itb->h;
|
|
|
|
in += itb->count;
|
2011-04-12 18:48:11 -07:00
|
|
|
if ((showme) && (wd->show_item) && (!wd->show_item->queued))
|
2011-03-22 00:54:24 -07:00
|
|
|
{
|
|
|
|
wd->show_item->showme = EINA_FALSE;
|
|
|
|
if (wd->bring_in)
|
|
|
|
elm_smart_scroller_region_bring_in(wd->scr,
|
2010-12-07 11:18:14 -08:00
|
|
|
wd->show_item->x +
|
|
|
|
wd->show_item->block->x,
|
|
|
|
wd->show_item->y +
|
|
|
|
wd->show_item->block->y,
|
2009-09-10 02:25:11 -07:00
|
|
|
wd->show_item->block->w,
|
|
|
|
wd->show_item->h);
|
2011-03-22 00:54:24 -07:00
|
|
|
else
|
|
|
|
elm_smart_scroller_child_region_show(wd->scr,
|
|
|
|
wd->show_item->x +
|
|
|
|
wd->show_item->block->x,
|
|
|
|
wd->show_item->y +
|
|
|
|
wd->show_item->block->y,
|
|
|
|
wd->show_item->block->w,
|
|
|
|
wd->show_item->h);
|
|
|
|
wd->show_item = NULL;
|
|
|
|
}
|
|
|
|
}
|
2009-02-17 20:18:25 -08:00
|
|
|
if (minw_change)
|
|
|
|
{
|
2010-10-15 04:51:15 -07:00
|
|
|
EINA_INLIST_FOREACH(wd->blocks, itb)
|
2011-03-22 00:54:24 -07:00
|
|
|
{
|
|
|
|
itb->minw = minw;
|
|
|
|
itb->w = itb->minw;
|
|
|
|
}
|
2009-02-17 20:18:25 -08:00
|
|
|
}
|
2009-02-25 08:22:29 -08:00
|
|
|
if ((chb) && (EINA_INLIST_GET(chb)->next))
|
2009-02-17 20:18:25 -08:00
|
|
|
{
|
2010-10-15 04:51:15 -07:00
|
|
|
EINA_INLIST_FOREACH(EINA_INLIST_GET(chb)->next, itb)
|
2011-03-22 00:54:24 -07:00
|
|
|
{
|
|
|
|
if (itb->realized) _item_block_unrealize(itb);
|
|
|
|
}
|
2009-02-11 03:49:43 -08:00
|
|
|
}
|
2010-09-28 01:46:08 -07:00
|
|
|
wd->realminw = minw;
|
2010-10-07 12:57:20 -07:00
|
|
|
if (minw < wd->w) minw = wd->w;
|
2009-02-12 05:39:43 -08:00
|
|
|
if ((minw != wd->minw) || (minh != wd->minh))
|
2009-02-11 03:49:43 -08:00
|
|
|
{
|
2010-10-15 04:51:15 -07:00
|
|
|
wd->minw = minw;
|
|
|
|
wd->minh = minh;
|
|
|
|
evas_object_smart_callback_call(wd->pan_smart, "changed", NULL);
|
|
|
|
_sizing_eval(wd->obj);
|
2011-06-14 02:18:54 -07:00
|
|
|
if ((wd->anchor_item) && (wd->anchor_item->block) && (!wd->auto_scroll_enabled))
|
2010-11-20 00:43:43 -08:00
|
|
|
{
|
2010-12-07 11:18:14 -08:00
|
|
|
Elm_Genlist_Item *it;
|
|
|
|
Evas_Coord it_y;
|
|
|
|
|
|
|
|
it = wd->anchor_item;
|
|
|
|
it_y = wd->anchor_y;
|
|
|
|
elm_smart_scroller_child_pos_set(wd->scr, wd->pan_x,
|
|
|
|
it->block->y + it->y + it_y);
|
|
|
|
wd->anchor_item = it;
|
|
|
|
wd->anchor_y = it_y;
|
2010-11-20 00:43:43 -08:00
|
|
|
}
|
2009-02-11 03:49:43 -08:00
|
|
|
}
|
2010-12-07 11:18:14 -08:00
|
|
|
t = ecore_time_get();
|
|
|
|
if (did_must_recalc)
|
|
|
|
{
|
|
|
|
if (!wd->must_recalc_idler)
|
|
|
|
wd->must_recalc_idler = ecore_idler_add(_must_recalc_idler, wd);
|
|
|
|
}
|
2009-02-12 05:39:43 -08:00
|
|
|
wd->calc_job = NULL;
|
|
|
|
evas_object_smart_changed(wd->pan_smart);
|
2011-05-27 03:30:56 -07:00
|
|
|
evas_event_thaw(evas_object_evas_get(wd->obj));
|
|
|
|
evas_event_thaw_eval(evas_object_evas_get(wd->obj));
|
2009-02-12 05:39:43 -08:00
|
|
|
}
|
|
|
|
|
2009-09-13 19:53:03 -07:00
|
|
|
static void
|
|
|
|
_update_job(void *data)
|
|
|
|
{
|
|
|
|
Widget_Data *wd = data;
|
2010-03-09 06:42:41 -08:00
|
|
|
Eina_List *l2;
|
2009-09-13 19:53:03 -07:00
|
|
|
Item_Block *itb;
|
2011-06-03 18:52:08 -07:00
|
|
|
int num, num0;
|
|
|
|
Eina_Bool position = EINA_FALSE, recalc = EINA_FALSE;
|
2010-03-09 06:42:41 -08:00
|
|
|
if (!wd) return;
|
2009-09-13 19:53:03 -07:00
|
|
|
wd->update_job = NULL;
|
|
|
|
num = 0;
|
2011-05-29 19:31:21 -07:00
|
|
|
|
2011-05-27 03:30:56 -07:00
|
|
|
evas_event_freeze(evas_object_evas_get(wd->obj));
|
2009-09-13 19:53:03 -07:00
|
|
|
EINA_INLIST_FOREACH(wd->blocks, itb)
|
2011-03-22 00:54:24 -07:00
|
|
|
{
|
|
|
|
Evas_Coord itminw, itminh;
|
|
|
|
Elm_Genlist_Item *it;
|
|
|
|
|
|
|
|
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;
|
2011-03-22 00:54:24 -07:00
|
|
|
EINA_LIST_FOREACH(itb->items, l2, it)
|
|
|
|
{
|
|
|
|
if (it->updateme)
|
|
|
|
{
|
2011-03-24 21:27:47 -07:00
|
|
|
itminw = it->minw;
|
|
|
|
itminh = it->minh;
|
2011-03-22 00:54:24 -07:00
|
|
|
|
|
|
|
it->updateme = EINA_FALSE;
|
|
|
|
if (it->realized)
|
|
|
|
{
|
2011-04-14 04:41:07 -07:00
|
|
|
_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-04-14 04:41:07 -07:00
|
|
|
_item_unrealize(it, EINA_TRUE);
|
2011-03-22 00:54:24 -07:00
|
|
|
}
|
|
|
|
if ((it->minw != itminw) || (it->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)
|
|
|
|
{
|
2010-10-15 04:51:15 -07:00
|
|
|
if (wd->calc_job) ecore_job_del(wd->calc_job);
|
|
|
|
wd->calc_job = ecore_job_add(_calc_job, wd);
|
2009-09-13 19:53:03 -07:00
|
|
|
}
|
2011-05-27 03:30:56 -07:00
|
|
|
evas_event_thaw(evas_object_evas_get(wd->obj));
|
|
|
|
evas_event_thaw_eval(evas_object_evas_get(wd->obj));
|
2009-09-13 19:53:03 -07:00
|
|
|
}
|
|
|
|
|
2009-02-12 05:39:43 -08:00
|
|
|
static void
|
2010-12-07 11:18:14 -08:00
|
|
|
_pan_set(Evas_Object *obj,
|
|
|
|
Evas_Coord x,
|
|
|
|
Evas_Coord y)
|
2009-02-12 05:39:43 -08:00
|
|
|
{
|
2010-12-07 11:18:14 -08:00
|
|
|
Pan *sd = evas_object_smart_data_get(obj);
|
|
|
|
Item_Block *itb;
|
|
|
|
|
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
|
|
|
// Evas_Coord ow, oh;
|
|
|
|
// evas_object_geometry_get(obj, NULL, NULL, &ow, &oh);
|
|
|
|
// ow = sd->wd->minw - ow;
|
|
|
|
// if (ow < 0) ow = 0;
|
|
|
|
// oh = sd->wd->minh - oh;
|
|
|
|
// if (oh < 0) oh = 0;
|
|
|
|
// if (x < 0) x = 0;
|
|
|
|
// if (y < 0) y = 0;
|
|
|
|
// if (x > ow) x = ow;
|
|
|
|
// if (y > oh) y = oh;
|
2010-12-07 11:18:14 -08:00
|
|
|
if ((x == sd->wd->pan_x) && (y == sd->wd->pan_y)) return;
|
|
|
|
sd->wd->pan_x = x;
|
|
|
|
sd->wd->pan_y = y;
|
|
|
|
|
|
|
|
EINA_INLIST_FOREACH(sd->wd->blocks, itb)
|
2011-03-22 00:54:24 -07:00
|
|
|
{
|
|
|
|
if ((itb->y + itb->h) > y)
|
|
|
|
{
|
|
|
|
Elm_Genlist_Item *it;
|
|
|
|
Eina_List *l2;
|
|
|
|
|
|
|
|
EINA_LIST_FOREACH(itb->items, l2, it)
|
|
|
|
{
|
|
|
|
if ((itb->y + it->y) >= y)
|
|
|
|
{
|
|
|
|
sd->wd->anchor_item = it;
|
|
|
|
sd->wd->anchor_y = -(itb->y + it->y - y);
|
|
|
|
goto done;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
2010-11-20 00:43:43 -08:00
|
|
|
done:
|
2011-06-03 18:52:08 -07:00
|
|
|
if (!sd->wd->reorder_move_animator) evas_object_smart_changed(obj);
|
2009-02-12 05:39:43 -08:00
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
2010-12-07 11:18:14 -08:00
|
|
|
_pan_get(Evas_Object *obj,
|
|
|
|
Evas_Coord *x,
|
|
|
|
Evas_Coord *y)
|
2009-02-12 05:39:43 -08:00
|
|
|
{
|
|
|
|
Pan *sd = evas_object_smart_data_get(obj);
|
2009-09-26 11:24:06 -07:00
|
|
|
|
2009-02-12 05:39:43 -08:00
|
|
|
if (x) *x = sd->wd->pan_x;
|
|
|
|
if (y) *y = sd->wd->pan_y;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
2010-12-07 11:18:14 -08:00
|
|
|
_pan_max_get(Evas_Object *obj,
|
|
|
|
Evas_Coord *x,
|
|
|
|
Evas_Coord *y)
|
2009-07-06 23:46:51 -07:00
|
|
|
{
|
2009-02-12 05:39:43 -08:00
|
|
|
Pan *sd = evas_object_smart_data_get(obj);
|
|
|
|
Evas_Coord ow, oh;
|
2009-09-26 11:24:06 -07:00
|
|
|
|
2009-02-12 05:39:43 -08:00
|
|
|
evas_object_geometry_get(obj, NULL, NULL, &ow, &oh);
|
|
|
|
ow = sd->wd->minw - ow;
|
|
|
|
if (ow < 0) ow = 0;
|
|
|
|
oh = sd->wd->minh - oh;
|
|
|
|
if (oh < 0) oh = 0;
|
2009-07-06 23:46:51 -07:00
|
|
|
if (x) *x = ow;
|
|
|
|
if (y) *y = oh;
|
2009-02-12 05:39:43 -08:00
|
|
|
}
|
|
|
|
|
2010-11-23 12:20:41 -08:00
|
|
|
static void
|
2010-12-07 11:18:14 -08:00
|
|
|
_pan_min_get(Evas_Object *obj __UNUSED__,
|
2011-04-01 09:33:58 -07:00
|
|
|
Evas_Coord *x,
|
|
|
|
Evas_Coord *y)
|
2010-11-23 12:20:41 -08:00
|
|
|
{
|
|
|
|
if (x) *x = 0;
|
|
|
|
if (y) *y = 0;
|
|
|
|
}
|
|
|
|
|
2009-02-12 05:39:43 -08:00
|
|
|
static void
|
2010-12-07 11:18:14 -08:00
|
|
|
_pan_child_size_get(Evas_Object *obj,
|
|
|
|
Evas_Coord *w,
|
|
|
|
Evas_Coord *h)
|
2009-02-12 05:39:43 -08:00
|
|
|
{
|
|
|
|
Pan *sd = evas_object_smart_data_get(obj);
|
2009-09-26 11:24:06 -07:00
|
|
|
|
2009-02-12 05:39:43 -08:00
|
|
|
if (w) *w = sd->wd->minw;
|
|
|
|
if (h) *h = sd->wd->minh;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
_pan_add(Evas_Object *obj)
|
|
|
|
{
|
|
|
|
Pan *sd;
|
|
|
|
Evas_Object_Smart_Clipped_Data *cd;
|
|
|
|
|
|
|
|
_pan_sc.add(obj);
|
|
|
|
cd = evas_object_smart_data_get(obj);
|
2009-10-13 10:11:00 -07:00
|
|
|
sd = ELM_NEW(Pan);
|
2009-02-12 05:39:43 -08:00
|
|
|
if (!sd) return;
|
|
|
|
sd->__clipped_data = *cd;
|
|
|
|
free(cd);
|
|
|
|
evas_object_smart_data_set(obj, sd);
|
|
|
|
}
|
2009-07-06 23:46:51 -07:00
|
|
|
|
2009-02-12 05:39:43 -08:00
|
|
|
static void
|
|
|
|
_pan_del(Evas_Object *obj)
|
|
|
|
{
|
|
|
|
Pan *sd = evas_object_smart_data_get(obj);
|
2009-09-26 11:24:06 -07:00
|
|
|
|
2009-02-12 05:39:43 -08:00
|
|
|
if (!sd) return;
|
2010-11-20 00:43:43 -08:00
|
|
|
if (sd->resize_job)
|
|
|
|
{
|
2010-12-07 11:18:14 -08:00
|
|
|
ecore_job_del(sd->resize_job);
|
|
|
|
sd->resize_job = NULL;
|
2010-11-20 00:43:43 -08:00
|
|
|
}
|
2009-02-12 05:39:43 -08:00
|
|
|
_pan_sc.del(obj);
|
|
|
|
}
|
|
|
|
|
2010-11-20 00:43:43 -08:00
|
|
|
static void
|
|
|
|
_pan_resize_job(void *data)
|
|
|
|
{
|
2010-12-07 11:18:14 -08:00
|
|
|
Pan *sd = data;
|
|
|
|
_sizing_eval(sd->wd->obj);
|
|
|
|
sd->resize_job = NULL;
|
2010-11-20 00:43:43 -08:00
|
|
|
}
|
|
|
|
|
2009-02-12 05:39:43 -08:00
|
|
|
static void
|
2010-12-07 11:18:14 -08:00
|
|
|
_pan_resize(Evas_Object *obj,
|
|
|
|
Evas_Coord w,
|
|
|
|
Evas_Coord h)
|
2009-02-12 05:39:43 -08:00
|
|
|
{
|
|
|
|
Pan *sd = evas_object_smart_data_get(obj);
|
|
|
|
Evas_Coord ow, oh;
|
2009-09-26 11:24:06 -07:00
|
|
|
|
2009-02-12 05:39:43 -08:00
|
|
|
evas_object_geometry_get(obj, NULL, NULL, &ow, &oh);
|
|
|
|
if ((ow == w) && (oh == h)) return;
|
2010-11-20 00:43:43 -08:00
|
|
|
if ((sd->wd->height_for_width) && (ow != w))
|
2010-12-07 11:18:14 -08:00
|
|
|
{
|
|
|
|
if (sd->resize_job) ecore_job_del(sd->resize_job);
|
|
|
|
sd->resize_job = ecore_job_add(_pan_resize_job, sd);
|
|
|
|
}
|
2009-02-12 05:39:43 -08:00
|
|
|
if (sd->wd->calc_job) ecore_job_del(sd->wd->calc_job);
|
|
|
|
sd->wd->calc_job = ecore_job_add(_calc_job, sd->wd);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
_pan_calculate(Evas_Object *obj)
|
|
|
|
{
|
|
|
|
Pan *sd = evas_object_smart_data_get(obj);
|
2009-02-25 08:22:29 -08:00
|
|
|
Item_Block *itb;
|
2010-01-16 04:35:31 -08:00
|
|
|
Evas_Coord ox, oy, ow, oh, cvx, cvy, cvw, cvh;
|
2009-09-26 11:24:06 -07:00
|
|
|
int in = 0;
|
2011-01-05 21:13:11 -08:00
|
|
|
Elm_Genlist_Item *git;
|
|
|
|
Eina_List *l;
|
2009-02-12 05:39:43 -08:00
|
|
|
|
2011-05-27 03:30:56 -07:00
|
|
|
evas_event_freeze(evas_object_evas_get(obj));
|
2010-01-16 04:35:31 -08:00
|
|
|
evas_object_geometry_get(obj, &ox, &oy, &ow, &oh);
|
|
|
|
evas_output_viewport_get(evas_object_evas_get(obj), &cvx, &cvy, &cvw, &cvh);
|
2011-01-05 21:13:11 -08:00
|
|
|
EINA_LIST_FOREACH(sd->wd->group_items, l, git)
|
|
|
|
{
|
|
|
|
git->want_realize = EINA_FALSE;
|
|
|
|
}
|
2009-02-25 08:22:29 -08:00
|
|
|
EINA_INLIST_FOREACH(sd->wd->blocks, itb)
|
2011-03-22 00:54:24 -07:00
|
|
|
{
|
|
|
|
itb->w = sd->wd->minw;
|
|
|
|
if (ELM_RECTS_INTERSECT(itb->x - sd->wd->pan_x + ox,
|
|
|
|
itb->y - sd->wd->pan_y + oy,
|
|
|
|
itb->w, itb->h,
|
|
|
|
cvx, cvy, cvw, cvh))
|
|
|
|
{
|
|
|
|
if ((!itb->realized) || (itb->changed))
|
2011-06-08 03:48:20 -07:00
|
|
|
_item_block_realize(itb);
|
2011-03-22 00:54:24 -07:00
|
|
|
_item_block_position(itb, in);
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
if (itb->realized) _item_block_unrealize(itb);
|
|
|
|
}
|
|
|
|
in += itb->count;
|
|
|
|
}
|
2011-06-01 20:10:11 -07:00
|
|
|
if ((!sd->wd->reorder_it) || (sd->wd->reorder_pan_move))
|
|
|
|
_group_items_recalc(sd->wd);
|
|
|
|
if ((sd->wd->reorder_mode) && (sd->wd->reorder_it))
|
|
|
|
{
|
|
|
|
if (sd->wd->pan_y != sd->wd->old_pan_y)
|
|
|
|
sd->wd->reorder_pan_move = EINA_TRUE;
|
|
|
|
else sd->wd->reorder_pan_move = EINA_FALSE;
|
|
|
|
evas_object_raise(sd->wd->reorder_it->base.view);
|
|
|
|
sd->wd->old_pan_y = sd->wd->pan_y;
|
|
|
|
sd->wd->start_time = ecore_loop_time_get();
|
|
|
|
}
|
2011-06-14 02:18:54 -07:00
|
|
|
_item_auto_scroll(sd->wd);
|
2011-05-27 03:30:56 -07:00
|
|
|
evas_event_thaw(evas_object_evas_get(obj));
|
|
|
|
evas_event_thaw_eval(evas_object_evas_get(obj));
|
2009-02-10 03:57:47 -08:00
|
|
|
}
|
2009-07-06 23:46:51 -07:00
|
|
|
|
2010-01-24 19:53:36 -08:00
|
|
|
static void
|
2010-12-07 11:18:14 -08:00
|
|
|
_pan_move(Evas_Object *obj,
|
2011-04-01 09:33:58 -07:00
|
|
|
Evas_Coord x __UNUSED__,
|
|
|
|
Evas_Coord y __UNUSED__)
|
2010-01-24 19:53:36 -08:00
|
|
|
{
|
|
|
|
Pan *sd = evas_object_smart_data_get(obj);
|
|
|
|
|
|
|
|
if (sd->wd->calc_job) ecore_job_del(sd->wd->calc_job);
|
|
|
|
sd->wd->calc_job = ecore_job_add(_calc_job, sd->wd);
|
|
|
|
}
|
|
|
|
|
2009-09-07 23:20:32 -07:00
|
|
|
static void
|
2011-04-01 09:33:58 -07:00
|
|
|
_hold_on(void *data __UNUSED__,
|
|
|
|
Evas_Object *obj,
|
|
|
|
void *event_info __UNUSED__)
|
2009-09-07 23:20:32 -07:00
|
|
|
{
|
|
|
|
Widget_Data *wd = elm_widget_data_get(obj);
|
|
|
|
if (!wd) return;
|
|
|
|
elm_smart_scroller_hold_set(wd->scr, 1);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
2011-04-01 09:33:58 -07:00
|
|
|
_hold_off(void *data __UNUSED__,
|
|
|
|
Evas_Object *obj,
|
|
|
|
void *event_info __UNUSED__)
|
2009-09-07 23:20:32 -07:00
|
|
|
{
|
|
|
|
Widget_Data *wd = elm_widget_data_get(obj);
|
|
|
|
if (!wd) return;
|
|
|
|
elm_smart_scroller_hold_set(wd->scr, 0);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
2011-04-01 09:33:58 -07:00
|
|
|
_freeze_on(void *data __UNUSED__,
|
|
|
|
Evas_Object *obj,
|
|
|
|
void *event_info __UNUSED__)
|
2009-09-07 23:20:32 -07:00
|
|
|
{
|
|
|
|
Widget_Data *wd = elm_widget_data_get(obj);
|
|
|
|
if (!wd) return;
|
|
|
|
elm_smart_scroller_freeze_set(wd->scr, 1);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
2011-04-01 09:33:58 -07:00
|
|
|
_freeze_off(void *data __UNUSED__,
|
|
|
|
Evas_Object *obj,
|
|
|
|
void *event_info __UNUSED__)
|
2009-09-07 23:20:32 -07:00
|
|
|
{
|
|
|
|
Widget_Data *wd = elm_widget_data_get(obj);
|
|
|
|
if (!wd) return;
|
|
|
|
elm_smart_scroller_freeze_set(wd->scr, 0);
|
|
|
|
}
|
|
|
|
|
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
|
|
|
|
_scr_anim_start(void *data,
|
|
|
|
Evas_Object *obj __UNUSED__,
|
|
|
|
void *event_info __UNUSED__)
|
|
|
|
{
|
|
|
|
evas_object_smart_callback_call(data, SIG_SCROLL_ANIM_START, NULL);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
_scr_anim_stop(void *data,
|
|
|
|
Evas_Object *obj __UNUSED__,
|
|
|
|
void *event_info __UNUSED__)
|
|
|
|
{
|
|
|
|
evas_object_smart_callback_call(data, SIG_SCROLL_ANIM_STOP, NULL);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
_scr_drag_start(void *data,
|
|
|
|
Evas_Object *obj __UNUSED__,
|
|
|
|
void *event_info __UNUSED__)
|
|
|
|
{
|
|
|
|
evas_object_smart_callback_call(data, SIG_SCROLL_DRAG_START, NULL);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
_scr_drag_stop(void *data,
|
|
|
|
Evas_Object *obj __UNUSED__,
|
|
|
|
void *event_info __UNUSED__)
|
|
|
|
{
|
|
|
|
evas_object_smart_callback_call(data, SIG_SCROLL_DRAG_STOP, 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
|
2011-04-01 09:33:58 -07:00
|
|
|
_scroll_edge_left(void *data,
|
2010-12-07 11:18:14 -08:00
|
|
|
Evas_Object *scr __UNUSED__,
|
2011-04-01 09:33:58 -07:00
|
|
|
void *event_info __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
|
|
|
{
|
|
|
|
Evas_Object *obj = data;
|
2011-05-06 17:30:39 -07:00
|
|
|
evas_object_smart_callback_call(obj, SIG_SCROLL_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
|
2011-04-01 09:33:58 -07:00
|
|
|
_scroll_edge_right(void *data,
|
2010-12-07 11:18:14 -08:00
|
|
|
Evas_Object *scr __UNUSED__,
|
2011-04-01 09:33:58 -07:00
|
|
|
void *event_info __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
|
|
|
{
|
|
|
|
Evas_Object *obj = data;
|
2011-05-06 17:30:39 -07:00
|
|
|
evas_object_smart_callback_call(obj, SIG_SCROLL_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
|
2011-04-01 09:33:58 -07:00
|
|
|
_scroll_edge_top(void *data,
|
2010-12-07 11:18:14 -08:00
|
|
|
Evas_Object *scr __UNUSED__,
|
2011-04-01 09:33:58 -07:00
|
|
|
void *event_info __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
|
|
|
{
|
|
|
|
Evas_Object *obj = data;
|
2011-05-06 17:30:39 -07:00
|
|
|
evas_object_smart_callback_call(obj, SIG_SCROLL_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
|
2011-04-01 09:33:58 -07:00
|
|
|
_scroll_edge_bottom(void *data,
|
2010-12-07 11:18:14 -08:00
|
|
|
Evas_Object *scr __UNUSED__,
|
2011-04-01 09:33:58 -07:00
|
|
|
void *event_info __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
|
|
|
{
|
|
|
|
Evas_Object *obj = data;
|
2011-05-06 17:30:39 -07:00
|
|
|
evas_object_smart_callback_call(obj, SIG_SCROLL_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
|
|
|
}
|
|
|
|
|
2011-04-21 04:47:36 -07:00
|
|
|
static void
|
|
|
|
_mode_item_realize(Elm_Genlist_Item *it)
|
|
|
|
{
|
|
|
|
char buf[1024];
|
|
|
|
|
|
|
|
if ((it->mode_view) || (it->delete_me)) return;
|
|
|
|
|
2011-05-27 03:30:56 -07:00
|
|
|
evas_event_freeze(evas_object_evas_get(it->wd->obj));
|
2011-04-21 04:47:36 -07:00
|
|
|
it->mode_view = edje_object_add(evas_object_evas_get(it->base.widget));
|
|
|
|
edje_object_scale_set(it->mode_view,
|
|
|
|
elm_widget_scale_get(it->base.widget) *
|
|
|
|
_elm_config->scale);
|
|
|
|
evas_object_smart_member_add(it->mode_view, it->wd->pan_smart);
|
|
|
|
elm_widget_sub_object_add(it->base.widget, it->mode_view);
|
|
|
|
|
|
|
|
strncpy(buf, "item", sizeof(buf));
|
|
|
|
if (it->wd->compress)
|
|
|
|
strncat(buf, "_compress", sizeof(buf) - strlen(buf));
|
|
|
|
|
|
|
|
if (it->order_num_in & 0x1) strncat(buf, "_odd", sizeof(buf) - strlen(buf));
|
|
|
|
strncat(buf, "/", sizeof(buf) - strlen(buf));
|
|
|
|
strncat(buf, it->itc->mode_item_style, sizeof(buf) - strlen(buf));
|
|
|
|
|
|
|
|
_elm_theme_object_set(it->base.widget, it->mode_view, "genlist", buf,
|
|
|
|
elm_widget_style_get(it->base.widget));
|
|
|
|
edje_object_mirrored_set(it->mode_view,
|
|
|
|
elm_widget_mirrored_get(it->base.widget));
|
|
|
|
|
|
|
|
/* signal callback add */
|
|
|
|
evas_object_event_callback_add(it->mode_view, EVAS_CALLBACK_MOUSE_DOWN,
|
|
|
|
_mouse_down, it);
|
|
|
|
evas_object_event_callback_add(it->mode_view, EVAS_CALLBACK_MOUSE_UP,
|
|
|
|
_mouse_up, it);
|
|
|
|
evas_object_event_callback_add(it->mode_view, EVAS_CALLBACK_MOUSE_MOVE,
|
|
|
|
_mouse_move, it);
|
|
|
|
|
|
|
|
/* label_get, icon_get, state_get */
|
2011-04-22 02:56:49 -07:00
|
|
|
/* FIXME: If you see that assert, please notify us and we
|
|
|
|
will clean our mess */
|
2011-04-22 06:20:06 -07:00
|
|
|
assert(eina_list_count(it->mode_icon_objs) == 0);
|
2011-04-21 04:47:36 -07:00
|
|
|
|
2011-04-22 06:20:06 -07:00
|
|
|
_item_label_realize(it, it->mode_view, &it->mode_labels);
|
|
|
|
it->mode_icon_objs = _item_icon_realize(it,
|
|
|
|
it->mode_view,
|
|
|
|
&it->mode_icons);
|
|
|
|
_item_state_realize(it, it->mode_view, &it->mode_states);
|
2011-04-21 04:47:36 -07:00
|
|
|
|
|
|
|
edje_object_part_swallow(it->mode_view,
|
|
|
|
edje_object_data_get(it->mode_view, "mode_part"),
|
|
|
|
it->base.view);
|
|
|
|
|
|
|
|
it->want_unrealize = EINA_FALSE;
|
2011-05-27 03:30:56 -07:00
|
|
|
evas_event_thaw(evas_object_evas_get(it->wd->obj));
|
|
|
|
evas_event_thaw_eval(evas_object_evas_get(it->wd->obj));
|
2011-04-21 04:47:36 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
_mode_item_unrealize(Elm_Genlist_Item *it)
|
|
|
|
{
|
|
|
|
Widget_Data *wd = it->wd;
|
|
|
|
Evas_Object *icon;
|
|
|
|
if (!it->mode_view) return;
|
|
|
|
|
2011-05-27 03:30:56 -07:00
|
|
|
evas_event_freeze(evas_object_evas_get(it->wd->obj));
|
2011-04-21 04:47:36 -07:00
|
|
|
elm_widget_stringlist_free(it->mode_labels);
|
|
|
|
it->mode_labels = NULL;
|
|
|
|
elm_widget_stringlist_free(it->mode_icons);
|
|
|
|
it->mode_icons = NULL;
|
|
|
|
elm_widget_stringlist_free(it->mode_states);
|
|
|
|
|
|
|
|
EINA_LIST_FREE(it->mode_icon_objs, icon)
|
|
|
|
evas_object_del(icon);
|
|
|
|
|
|
|
|
edje_object_part_unswallow(it->mode_view, it->base.view);
|
|
|
|
evas_object_smart_member_add(it->base.view, wd->pan_smart);
|
|
|
|
evas_object_del(it->mode_view);
|
|
|
|
it->mode_view = NULL;
|
|
|
|
|
|
|
|
if (wd->mode_item == it)
|
|
|
|
wd->mode_item = NULL;
|
2011-05-27 03:30:56 -07:00
|
|
|
evas_event_thaw(evas_object_evas_get(it->wd->obj));
|
|
|
|
evas_event_thaw_eval(evas_object_evas_get(it->wd->obj));
|
2011-04-21 04:47:36 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
_item_mode_set(Elm_Genlist_Item *it)
|
|
|
|
{
|
|
|
|
if (!it) return;
|
|
|
|
Widget_Data *wd = it->wd;
|
|
|
|
if (!wd) return;
|
|
|
|
char buf[1024];
|
|
|
|
|
|
|
|
wd->mode_item = it;
|
|
|
|
it->nocache = EINA_TRUE;
|
|
|
|
|
|
|
|
if (wd->scr_hold_timer)
|
|
|
|
{
|
|
|
|
ecore_timer_del(wd->scr_hold_timer);
|
|
|
|
wd->scr_hold_timer = NULL;
|
|
|
|
}
|
|
|
|
elm_smart_scroller_hold_set(wd->scr, EINA_TRUE);
|
|
|
|
wd->scr_hold_timer = ecore_timer_add(0.1, _scr_hold_timer_cb, wd);
|
|
|
|
|
2011-05-27 03:30:56 -07:00
|
|
|
evas_event_freeze(evas_object_evas_get(it->wd->obj));
|
2011-04-21 04:47:36 -07:00
|
|
|
_mode_item_realize(it);
|
2011-06-01 20:10:11 -07:00
|
|
|
_item_position(it, it->mode_view, it->scrl_x, it->scrl_y);
|
2011-05-27 03:30:56 -07:00
|
|
|
evas_event_thaw(evas_object_evas_get(it->wd->obj));
|
|
|
|
evas_event_thaw_eval(evas_object_evas_get(it->wd->obj));
|
2011-04-21 04:47:36 -07:00
|
|
|
|
|
|
|
snprintf(buf, sizeof(buf), "elm,state,%s,active", wd->mode_type);
|
|
|
|
edje_object_signal_emit(it->mode_view, buf, "elm");
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
_item_mode_unset(Widget_Data *wd)
|
|
|
|
{
|
|
|
|
if (!wd) return;
|
|
|
|
if (!wd->mode_item) return;
|
|
|
|
char buf[1024], buf2[1024];
|
|
|
|
Elm_Genlist_Item *it;
|
|
|
|
|
|
|
|
it = wd->mode_item;
|
|
|
|
it->nocache = EINA_TRUE;
|
|
|
|
|
|
|
|
snprintf(buf, sizeof(buf), "elm,state,%s,passive", wd->mode_type);
|
|
|
|
snprintf(buf2, sizeof(buf2), "elm,state,%s,passive,finished", wd->mode_type);
|
|
|
|
|
|
|
|
edje_object_signal_emit(it->mode_view, buf, "elm");
|
|
|
|
edje_object_signal_callback_add(it->mode_view, buf2, "elm", _mode_finished_signal_cb, it);
|
|
|
|
|
|
|
|
wd->mode_item = NULL;
|
|
|
|
}
|
|
|
|
|
2011-06-14 02:18:54 -07:00
|
|
|
static void
|
|
|
|
_item_auto_scroll(Widget_Data *wd)
|
|
|
|
{
|
|
|
|
if (!wd) return;
|
|
|
|
Elm_Genlist_Item *it;
|
|
|
|
Eina_List *l;
|
|
|
|
Evas_Coord ox, oy, ow, oh;
|
|
|
|
|
|
|
|
if ((wd->expanded_item) && (wd->auto_scroll_enabled))
|
|
|
|
{
|
|
|
|
evas_object_geometry_get(wd->obj, &ox, &oy, &ow, &oh);
|
|
|
|
if (wd->expanded_item->scrl_y > (oh + oy) / 2)
|
|
|
|
{
|
|
|
|
EINA_LIST_FOREACH(wd->expanded_item->items, l, it)
|
|
|
|
elm_genlist_item_bring_in(it);
|
|
|
|
}
|
|
|
|
wd->auto_scroll_enabled = EINA_FALSE;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2009-02-09 03:23:59 -08:00
|
|
|
EAPI Evas_Object *
|
|
|
|
elm_genlist_add(Evas_Object *parent)
|
|
|
|
{
|
|
|
|
Evas_Object *obj;
|
|
|
|
Evas *e;
|
|
|
|
Widget_Data *wd;
|
2009-03-12 22:50:38 -07:00
|
|
|
Evas_Coord minw, minh;
|
2009-02-10 03:57:47 -08:00
|
|
|
static Evas_Smart *smart = NULL;
|
2009-07-06 23:46:51 -07:00
|
|
|
|
2010-09-14 20:11:30 -07:00
|
|
|
if (!smart)
|
|
|
|
{
|
2010-10-15 04:51:15 -07:00
|
|
|
static Evas_Smart_Class sc;
|
2010-09-14 20:11:30 -07:00
|
|
|
|
2010-10-15 04:51:15 -07:00
|
|
|
evas_object_smart_clipped_smart_set(&_pan_sc);
|
|
|
|
sc = _pan_sc;
|
|
|
|
sc.name = "elm_genlist_pan";
|
|
|
|
sc.version = EVAS_SMART_CLASS_VERSION;
|
|
|
|
sc.add = _pan_add;
|
|
|
|
sc.del = _pan_del;
|
|
|
|
sc.resize = _pan_resize;
|
|
|
|
sc.move = _pan_move;
|
|
|
|
sc.calculate = _pan_calculate;
|
|
|
|
if (!(smart = evas_smart_class_new(&sc))) return NULL;
|
2010-09-14 20:11:30 -07:00
|
|
|
}
|
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
|
|
|
|
2011-03-31 23:08:02 -07:00
|
|
|
ELM_WIDGET_STANDARD_SETUP(wd, Widget_Data, parent, e, obj, NULL);
|
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
|
|
|
|
2010-03-08 22:15:39 -08:00
|
|
|
ELM_SET_WIDTYPE(widtype, "genlist");
|
2009-05-13 05:21:52 -07:00
|
|
|
elm_widget_type_set(obj, "genlist");
|
|
|
|
elm_widget_sub_object_add(parent, obj);
|
2010-10-01 12:03:12 -07:00
|
|
|
elm_widget_on_focus_hook_set(obj, _on_focus_hook, NULL);
|
2011-04-06 07:46:39 -07:00
|
|
|
elm_widget_signal_emit_hook_set(obj, _signal_emit_hook);
|
2009-02-09 03:23:59 -08:00
|
|
|
elm_widget_data_set(obj, wd);
|
|
|
|
elm_widget_del_hook_set(obj, _del_hook);
|
2009-11-13 14:22:05 -08:00
|
|
|
elm_widget_del_pre_hook_set(obj, _del_pre_hook);
|
2009-02-09 03:23:59 -08:00
|
|
|
elm_widget_theme_hook_set(obj, _theme_hook);
|
2010-09-29 05:22:30 -07:00
|
|
|
elm_widget_can_focus_set(obj, EINA_TRUE);
|
2010-10-01 12:03:12 -07:00
|
|
|
elm_widget_event_hook_set(obj, _event_hook);
|
2011-02-13 02:28:55 -08:00
|
|
|
elm_widget_on_show_region_hook_set(obj, _show_region_hook, obj);
|
2009-07-06 23:46:51 -07:00
|
|
|
|
2009-02-09 03:23:59 -08:00
|
|
|
wd->scr = elm_smart_scroller_add(e);
|
2010-05-07 06:24:29 -07:00
|
|
|
elm_smart_scroller_widget_set(wd->scr, obj);
|
2010-11-22 07:24:58 -08:00
|
|
|
elm_smart_scroller_object_theme_set(obj, wd->scr, "genlist", "base",
|
|
|
|
elm_widget_style_get(obj));
|
2010-10-21 12:57:43 -07:00
|
|
|
elm_smart_scroller_bounce_allow_set(wd->scr, EINA_FALSE,
|
|
|
|
_elm_config->thumbscroll_bounce_enable);
|
2010-11-22 07:24:58 -08:00
|
|
|
elm_widget_resize_object_set(obj, wd->scr);
|
2009-07-06 23:46:51 -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
|
|
|
evas_object_smart_callback_add(wd->scr, "animate,start", _scr_anim_start, obj);
|
|
|
|
evas_object_smart_callback_add(wd->scr, "animate,stop", _scr_anim_stop, obj);
|
|
|
|
evas_object_smart_callback_add(wd->scr, "drag,start", _scr_drag_start, obj);
|
|
|
|
evas_object_smart_callback_add(wd->scr, "drag,stop", _scr_drag_stop, obj);
|
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
|
|
|
evas_object_smart_callback_add(wd->scr, "edge,left", _scroll_edge_left, obj);
|
2010-12-07 11:18:14 -08:00
|
|
|
evas_object_smart_callback_add(wd->scr, "edge,right", _scroll_edge_right,
|
|
|
|
obj);
|
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
|
|
|
evas_object_smart_callback_add(wd->scr, "edge,top", _scroll_edge_top, obj);
|
2010-12-07 11:18:14 -08:00
|
|
|
evas_object_smart_callback_add(wd->scr, "edge,bottom", _scroll_edge_bottom,
|
|
|
|
obj);
|
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
|
|
|
|
2009-02-12 05:39:43 -08:00
|
|
|
wd->obj = obj;
|
2009-03-12 22:50:38 -07:00
|
|
|
wd->mode = ELM_LIST_SCROLL;
|
2010-11-17 09:15:28 -08:00
|
|
|
wd->max_items_per_block = MAX_ITEMS_PER_BLOCK;
|
2010-11-05 23:02:22 -07:00
|
|
|
wd->item_cache_max = wd->max_items_per_block * 2;
|
2010-12-06 21:04:45 -08:00
|
|
|
wd->longpress_timeout = _elm_config->longpress_timeout;
|
2009-07-06 23:46:51 -07:00
|
|
|
|
2009-09-07 23:20:32 -07:00
|
|
|
evas_object_smart_callback_add(obj, "scroll-hold-on", _hold_on, obj);
|
|
|
|
evas_object_smart_callback_add(obj, "scroll-hold-off", _hold_off, obj);
|
|
|
|
evas_object_smart_callback_add(obj, "scroll-freeze-on", _freeze_on, obj);
|
|
|
|
evas_object_smart_callback_add(obj, "scroll-freeze-off", _freeze_off, obj);
|
2009-09-23 15:56:47 -07:00
|
|
|
|
2010-09-14 20:11:30 -07:00
|
|
|
wd->pan_smart = evas_object_smart_add(e, smart);
|
|
|
|
wd->pan = evas_object_smart_data_get(wd->pan_smart);
|
|
|
|
wd->pan->wd = wd;
|
2009-07-06 23:46:51 -07:00
|
|
|
|
2009-02-10 03:57:47 -08:00
|
|
|
elm_smart_scroller_extern_pan_set(wd->scr, wd->pan_smart,
|
2010-11-23 12:20:41 -08:00
|
|
|
_pan_set, _pan_get, _pan_max_get,
|
|
|
|
_pan_min_get, _pan_child_size_get);
|
2009-02-10 03:57:47 -08:00
|
|
|
|
2009-09-23 15:56:47 -07:00
|
|
|
edje_object_size_min_calc(elm_smart_scroller_edje_object_get(wd->scr),
|
2009-09-04 08:39:30 -07:00
|
|
|
&minw, &minh);
|
2009-02-09 03:23:59 -08:00
|
|
|
evas_object_size_hint_min_set(obj, minw, minh);
|
2009-07-06 23:46:51 -07:00
|
|
|
|
2011-05-06 17:30:39 -07:00
|
|
|
evas_object_smart_callbacks_descriptions_set(obj, _signals);
|
|
|
|
|
2011-02-08 04:08:28 -08:00
|
|
|
_mirrored_set(obj, elm_widget_mirrored_get(obj));
|
2009-02-09 03:23:59 -08:00
|
|
|
_sizing_eval(obj);
|
|
|
|
return obj;
|
|
|
|
}
|
|
|
|
|
2009-02-25 07:54:26 -08:00
|
|
|
static Elm_Genlist_Item *
|
2010-12-07 11:18:14 -08:00
|
|
|
_item_new(Widget_Data *wd,
|
|
|
|
const Elm_Genlist_Item_Class *itc,
|
|
|
|
const void *data,
|
|
|
|
Elm_Genlist_Item *parent,
|
|
|
|
Elm_Genlist_Item_Flags flags,
|
|
|
|
Evas_Smart_Cb func,
|
|
|
|
const void *func_data)
|
2009-02-10 03:57:47 -08:00
|
|
|
{
|
2009-02-25 07:54:26 -08:00
|
|
|
Elm_Genlist_Item *it;
|
2009-07-06 23:46:51 -07:00
|
|
|
|
2010-09-09 19:05:45 -07:00
|
|
|
it = elm_widget_item_new(wd->obj, Elm_Genlist_Item);
|
2009-02-10 03:57:47 -08:00
|
|
|
if (!it) return NULL;
|
2009-02-12 05:39:43 -08:00
|
|
|
it->wd = wd;
|
2009-02-10 03:57:47 -08:00
|
|
|
it->itc = itc;
|
2010-09-09 19:05:45 -07:00
|
|
|
it->base.data = data;
|
2009-02-10 03:57:47 -08:00
|
|
|
it->parent = parent;
|
|
|
|
it->flags = flags;
|
|
|
|
it->func.func = func;
|
|
|
|
it->func.data = func_data;
|
2010-09-27 11:18:37 -07:00
|
|
|
it->mouse_cursor = NULL;
|
2010-10-06 23:45:36 -07:00
|
|
|
it->expanded_depth = 0;
|
2011-08-10 16:51:20 -07:00
|
|
|
elm_widget_item_text_get_hook_set(it, _item_label_hook);
|
2011-08-01 23:50:34 -07:00
|
|
|
|
|
|
|
if (it->parent)
|
|
|
|
{
|
|
|
|
if (it->parent->flags & ELM_GENLIST_ITEM_GROUP)
|
|
|
|
it->group_item = parent;
|
|
|
|
else if (it->parent->group_item)
|
|
|
|
it->group_item = it->parent->group_item;
|
|
|
|
}
|
2009-02-10 03:57:47 -08:00
|
|
|
return it;
|
|
|
|
}
|
|
|
|
|
2009-02-11 03:49:43 -08:00
|
|
|
static void
|
2010-12-07 11:18:14 -08:00
|
|
|
_item_block_add(Widget_Data *wd,
|
|
|
|
Elm_Genlist_Item *it)
|
2009-02-11 03:49:43 -08:00
|
|
|
{
|
2009-02-24 05:08:21 -08:00
|
|
|
Item_Block *itb = NULL;
|
2009-02-18 04:41:45 -08:00
|
|
|
|
2009-02-18 20:37:06 -08:00
|
|
|
if (!it->rel)
|
2009-02-11 03:49:43 -08:00
|
|
|
{
|
2010-10-15 04:51:15 -07:00
|
|
|
newblock:
|
|
|
|
if (it->rel)
|
|
|
|
{
|
|
|
|
itb = calloc(1, sizeof(Item_Block));
|
|
|
|
if (!itb) return;
|
|
|
|
itb->wd = wd;
|
|
|
|
if (!it->rel->block)
|
|
|
|
{
|
2010-12-07 11:18:14 -08:00
|
|
|
wd->blocks =
|
2011-04-01 09:33:58 -07:00
|
|
|
eina_inlist_append(wd->blocks, EINA_INLIST_GET(itb));
|
2010-10-15 04:51:15 -07:00
|
|
|
itb->items = eina_list_append(itb->items, it);
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
if (it->before)
|
|
|
|
{
|
2010-12-07 11:18:14 -08:00
|
|
|
wd->blocks = eina_inlist_prepend_relative
|
2011-04-01 09:33:58 -07:00
|
|
|
(wd->blocks, EINA_INLIST_GET(itb),
|
2010-12-07 11:18:14 -08:00
|
|
|
EINA_INLIST_GET(it->rel->block));
|
|
|
|
itb->items =
|
2011-04-01 09:33:58 -07:00
|
|
|
eina_list_prepend_relative(itb->items, it, it->rel);
|
2010-10-15 04:51:15 -07:00
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
2010-12-07 11:18:14 -08:00
|
|
|
wd->blocks = eina_inlist_append_relative
|
2011-04-01 09:33:58 -07:00
|
|
|
(wd->blocks, EINA_INLIST_GET(itb),
|
2010-12-07 11:18:14 -08:00
|
|
|
EINA_INLIST_GET(it->rel->block));
|
|
|
|
itb->items =
|
2011-04-01 09:33:58 -07:00
|
|
|
eina_list_append_relative(itb->items, it, it->rel);
|
2010-10-15 04:51:15 -07:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
if (it->before)
|
|
|
|
{
|
|
|
|
if (wd->blocks)
|
|
|
|
{
|
|
|
|
itb = (Item_Block *)(wd->blocks);
|
|
|
|
if (itb->count >= wd->max_items_per_block)
|
|
|
|
{
|
|
|
|
itb = calloc(1, sizeof(Item_Block));
|
|
|
|
if (!itb) return;
|
|
|
|
itb->wd = wd;
|
2010-12-07 11:18:14 -08:00
|
|
|
wd->blocks =
|
2011-04-01 09:33:58 -07:00
|
|
|
eina_inlist_prepend(wd->blocks,
|
|
|
|
EINA_INLIST_GET(itb));
|
2010-10-15 04:51:15 -07:00
|
|
|
}
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
itb = calloc(1, sizeof(Item_Block));
|
|
|
|
if (!itb) return;
|
|
|
|
itb->wd = wd;
|
2010-12-07 11:18:14 -08:00
|
|
|
wd->blocks =
|
2011-04-01 09:33:58 -07:00
|
|
|
eina_inlist_prepend(wd->blocks, EINA_INLIST_GET(itb));
|
2010-10-15 04:51:15 -07:00
|
|
|
}
|
|
|
|
itb->items = eina_list_prepend(itb->items, it);
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
if (wd->blocks)
|
|
|
|
{
|
|
|
|
itb = (Item_Block *)(wd->blocks->last);
|
|
|
|
if (itb->count >= wd->max_items_per_block)
|
|
|
|
{
|
|
|
|
itb = calloc(1, sizeof(Item_Block));
|
|
|
|
if (!itb) return;
|
|
|
|
itb->wd = wd;
|
2010-12-07 11:18:14 -08:00
|
|
|
wd->blocks =
|
2011-04-01 09:33:58 -07:00
|
|
|
eina_inlist_append(wd->blocks,
|
|
|
|
EINA_INLIST_GET(itb));
|
2010-10-15 04:51:15 -07:00
|
|
|
}
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
itb = calloc(1, sizeof(Item_Block));
|
|
|
|
if (!itb) return;
|
|
|
|
itb->wd = wd;
|
2010-12-07 11:18:14 -08:00
|
|
|
wd->blocks =
|
2011-04-01 09:33:58 -07:00
|
|
|
eina_inlist_append(wd->blocks, EINA_INLIST_GET(itb));
|
2010-10-15 04:51:15 -07:00
|
|
|
}
|
|
|
|
itb->items = eina_list_append(itb->items, it);
|
|
|
|
}
|
|
|
|
}
|
2009-02-11 03:49:43 -08:00
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
2010-10-15 04:51:15 -07:00
|
|
|
itb = it->rel->block;
|
|
|
|
if (!itb) goto newblock;
|
|
|
|
if (it->before)
|
2010-12-07 11:18:14 -08:00
|
|
|
itb->items = eina_list_prepend_relative(itb->items, it, it->rel);
|
2010-10-15 04:51:15 -07:00
|
|
|
else
|
2010-12-07 11:18:14 -08:00
|
|
|
itb->items = eina_list_append_relative(itb->items, it, it->rel);
|
2009-02-11 03:49:43 -08:00
|
|
|
}
|
|
|
|
itb->count++;
|
2009-06-17 08:35:19 -07:00
|
|
|
itb->changed = EINA_TRUE;
|
2009-02-11 03:49:43 -08:00
|
|
|
it->block = itb;
|
2009-02-12 05:39:43 -08:00
|
|
|
if (itb->wd->calc_job) ecore_job_del(itb->wd->calc_job);
|
|
|
|
itb->wd->calc_job = ecore_job_add(_calc_job, itb->wd);
|
2009-02-18 20:37:06 -08:00
|
|
|
if (it->rel)
|
|
|
|
{
|
2010-10-15 04:51:15 -07:00
|
|
|
it->rel->relcount--;
|
2010-10-22 14:41:27 -07:00
|
|
|
if ((it->rel->delete_me) && (!it->rel->relcount))
|
2010-12-07 11:18:14 -08:00
|
|
|
_item_del(it->rel);
|
2010-10-15 04:51:15 -07:00
|
|
|
it->rel = NULL;
|
2009-02-18 20:37:06 -08:00
|
|
|
}
|
2010-01-23 01:07:20 -08:00
|
|
|
if (itb->count > itb->wd->max_items_per_block)
|
2009-09-22 22:48:59 -07:00
|
|
|
{
|
|
|
|
int newc;
|
|
|
|
Item_Block *itb2;
|
|
|
|
Elm_Genlist_Item *it2;
|
2009-09-23 15:56:47 -07:00
|
|
|
|
2009-09-22 22:48:59 -07:00
|
|
|
newc = itb->count / 2;
|
|
|
|
itb2 = calloc(1, sizeof(Item_Block));
|
|
|
|
if (!itb2) return;
|
|
|
|
itb2->wd = wd;
|
2010-12-07 11:18:14 -08:00
|
|
|
wd->blocks =
|
2011-04-01 09:33:58 -07:00
|
|
|
eina_inlist_append_relative(wd->blocks, EINA_INLIST_GET(itb2),
|
|
|
|
EINA_INLIST_GET(itb));
|
2009-09-22 22:48:59 -07:00
|
|
|
itb2->changed = EINA_TRUE;
|
|
|
|
while ((itb->count > newc) && (itb->items))
|
|
|
|
{
|
|
|
|
Eina_List *l;
|
2009-09-23 15:56:47 -07:00
|
|
|
|
2009-09-22 22:48:59 -07:00
|
|
|
l = eina_list_last(itb->items);
|
|
|
|
it2 = l->data;
|
|
|
|
itb->items = eina_list_remove_list(itb->items, l);
|
|
|
|
itb->count--;
|
2009-09-23 15:56:47 -07:00
|
|
|
|
2009-09-22 22:48:59 -07:00
|
|
|
itb2->items = eina_list_prepend(itb2->items, it2);
|
|
|
|
it2->block = itb2;
|
|
|
|
itb2->count++;
|
|
|
|
}
|
|
|
|
}
|
2009-02-12 05:39:43 -08:00
|
|
|
}
|
|
|
|
|
|
|
|
static int
|
2011-05-23 05:19:42 -07:00
|
|
|
_queue_process(Widget_Data *wd)
|
2009-02-12 05:39:43 -08:00
|
|
|
{
|
2010-12-20 09:03:12 -08:00
|
|
|
int n;
|
|
|
|
Eina_Bool showme = EINA_FALSE;
|
2010-01-23 01:07:20 -08:00
|
|
|
double t0, t;
|
2009-02-18 20:37:06 -08:00
|
|
|
|
2010-01-23 01:07:20 -08:00
|
|
|
t0 = ecore_time_get();
|
2011-06-08 09:56:50 -07:00
|
|
|
//evas_event_freeze(evas_object_evas_get(wd->obj));
|
2010-01-23 01:07:20 -08:00
|
|
|
for (n = 0; (wd->queue) && (n < 128); n++)
|
2009-02-12 05:39:43 -08:00
|
|
|
{
|
2010-10-15 04:51:15 -07:00
|
|
|
Elm_Genlist_Item *it;
|
2009-07-06 23:46:51 -07:00
|
|
|
|
2010-10-15 04:51:15 -07:00
|
|
|
it = wd->queue->data;
|
|
|
|
wd->queue = eina_list_remove_list(wd->queue, wd->queue);
|
|
|
|
it->queued = EINA_FALSE;
|
|
|
|
_item_block_add(wd, it);
|
2010-01-22 04:02:39 -08:00
|
|
|
t = ecore_time_get();
|
2010-01-23 01:07:20 -08:00
|
|
|
if (it->block->changed)
|
|
|
|
{
|
2011-06-08 03:58:00 -07:00
|
|
|
showme = _item_block_recalc(it->block, it->block->num, EINA_TRUE);
|
2010-01-23 01:07:20 -08:00
|
|
|
it->block->changed = 0;
|
|
|
|
}
|
2010-12-20 09:03:12 -08:00
|
|
|
if (showme) it->block->showme = EINA_TRUE;
|
2010-02-04 22:14:50 -08:00
|
|
|
if (eina_inlist_count(wd->blocks) > 1)
|
|
|
|
{
|
|
|
|
if ((t - t0) > (ecore_animator_frametime_get())) break;
|
|
|
|
}
|
2010-01-23 01:07:20 -08:00
|
|
|
}
|
2011-06-08 09:56:50 -07:00
|
|
|
//evas_event_thaw(evas_object_evas_get(wd->obj));
|
|
|
|
//evas_event_thaw_eval(evas_object_evas_get(wd->obj));
|
2010-03-28 19:27:26 -07:00
|
|
|
return n;
|
|
|
|
}
|
|
|
|
|
2010-06-25 02:58:14 -07:00
|
|
|
static Eina_Bool
|
2011-04-27 03:17:26 -07:00
|
|
|
_idle_process(void *data, Eina_Bool *wakeup)
|
2010-03-28 19:27:26 -07:00
|
|
|
{
|
|
|
|
Widget_Data *wd = data;
|
2010-10-15 04:51:15 -07:00
|
|
|
|
2010-12-07 11:18:14 -08:00
|
|
|
//xxx
|
|
|
|
//static double q_start = 0.0;
|
|
|
|
//if (q_start == 0.0) q_start = ecore_time_get();
|
|
|
|
//xxx
|
2011-05-23 05:19:42 -07:00
|
|
|
if (_queue_process(wd) > 0) *wakeup = EINA_TRUE;
|
2009-02-12 05:39:43 -08:00
|
|
|
if (!wd->queue)
|
|
|
|
{
|
2010-12-07 11:18:14 -08:00
|
|
|
//xxx
|
|
|
|
//printf("PROCESS TIME: %3.3f\n", ecore_time_get() - q_start);
|
|
|
|
//xxx
|
2011-03-29 18:35:15 -07:00
|
|
|
return ECORE_CALLBACK_CANCEL;
|
2009-02-12 05:39:43 -08:00
|
|
|
}
|
2010-06-25 02:58:14 -07:00
|
|
|
return ECORE_CALLBACK_RENEW;
|
2009-02-12 05:39:43 -08:00
|
|
|
}
|
|
|
|
|
2011-04-27 03:17:26 -07:00
|
|
|
static Eina_Bool
|
|
|
|
_item_idle_enterer(void *data)
|
|
|
|
{
|
|
|
|
Widget_Data *wd = data;
|
|
|
|
Eina_Bool wakeup = EINA_FALSE;
|
|
|
|
Eina_Bool ok = _idle_process(data, &wakeup);
|
2011-05-07 01:37:47 -07:00
|
|
|
|
2011-04-27 03:17:26 -07:00
|
|
|
if (wakeup)
|
|
|
|
{
|
|
|
|
// wake up mainloop
|
|
|
|
if (wd->calc_job) ecore_job_del(wd->calc_job);
|
|
|
|
wd->calc_job = ecore_job_add(_calc_job, wd);
|
|
|
|
}
|
2011-05-07 01:37:47 -07:00
|
|
|
if (ok == ECORE_CALLBACK_CANCEL) wd->queue_idle_enterer = NULL;
|
2011-04-27 03:17:26 -07:00
|
|
|
return ok;
|
|
|
|
}
|
|
|
|
|
2009-02-12 05:39:43 -08:00
|
|
|
static void
|
2010-12-07 11:18:14 -08:00
|
|
|
_item_queue(Widget_Data *wd,
|
|
|
|
Elm_Genlist_Item *it)
|
2009-02-12 05:39:43 -08:00
|
|
|
{
|
|
|
|
if (it->queued) return;
|
2009-06-17 08:35:19 -07:00
|
|
|
it->queued = EINA_TRUE;
|
2009-02-12 05:39:43 -08:00
|
|
|
wd->queue = eina_list_append(wd->queue, it);
|
2011-06-01 06:13:56 -07:00
|
|
|
// 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(wd->obj));
|
2010-03-24 03:00:50 -07:00
|
|
|
while ((wd->queue) && ((!wd->blocks) || (!wd->blocks->next)))
|
|
|
|
{
|
2011-04-27 03:17:26 -07:00
|
|
|
if (wd->queue_idle_enterer)
|
2010-03-24 03:00:50 -07:00
|
|
|
{
|
2011-04-27 03:17:26 -07:00
|
|
|
ecore_idle_enterer_del(wd->queue_idle_enterer);
|
|
|
|
wd->queue_idle_enterer = NULL;
|
2010-03-24 03:00:50 -07:00
|
|
|
}
|
2011-05-23 05:19:42 -07:00
|
|
|
_queue_process(wd);
|
2010-03-24 03:00:50 -07:00
|
|
|
}
|
2011-06-01 06:13:56 -07:00
|
|
|
// evas_event_thaw(evas_object_evas_get(wd->obj));
|
|
|
|
// evas_event_thaw_eval(evas_object_evas_get(wd->obj));
|
2011-05-07 01:37:47 -07:00
|
|
|
if (!wd->queue_idle_enterer)
|
2011-06-08 03:58:00 -07:00
|
|
|
wd->queue_idle_enterer = ecore_idle_enterer_add(_item_idle_enterer, wd);
|
2009-02-11 03:49:43 -08:00
|
|
|
}
|
|
|
|
|
2011-06-25 16:20:22 -07:00
|
|
|
static int
|
|
|
|
_elm_genlist_item_compare_data(const void *data, const void *data1)
|
|
|
|
{
|
|
|
|
const Elm_Genlist_Item *item = data;
|
|
|
|
const Elm_Genlist_Item *item1 = data1;
|
|
|
|
|
|
|
|
return _elm_genlist_item_compare_data_cb(item->base.data, item1->base.data);
|
|
|
|
}
|
|
|
|
|
2011-05-25 07:58:39 -07:00
|
|
|
static int
|
|
|
|
_elm_genlist_item_compare(const void *data, const void *data1)
|
|
|
|
{
|
2011-07-28 09:43:15 -07:00
|
|
|
const Elm_Genlist_Item *item, *item1;
|
2011-05-25 07:58:39 -07:00
|
|
|
item = ELM_GENLIST_ITEM_FROM_INLIST(data);
|
|
|
|
item1 = ELM_GENLIST_ITEM_FROM_INLIST(data1);
|
2011-06-25 16:20:22 -07:00
|
|
|
return _elm_genlist_item_compare_cb(item, item1);
|
2011-05-25 07:58:39 -07:00
|
|
|
}
|
|
|
|
|
2011-07-28 09:43:15 -07:00
|
|
|
static int
|
|
|
|
_elm_genlist_item_list_compare(const void *data, const void *data1)
|
|
|
|
{
|
|
|
|
const Elm_Genlist_Item *item = data;
|
|
|
|
const Elm_Genlist_Item *item1 = data1;
|
|
|
|
return _elm_genlist_item_compare_cb(item, item1);
|
|
|
|
}
|
|
|
|
|
2011-06-01 20:10:11 -07:00
|
|
|
static void
|
|
|
|
_item_move_after(Elm_Genlist_Item *it, Elm_Genlist_Item *after)
|
|
|
|
{
|
|
|
|
if (!it) return;
|
|
|
|
if (!after) return;
|
|
|
|
|
|
|
|
it->wd->items = eina_inlist_remove(it->wd->items, EINA_INLIST_GET(it));
|
|
|
|
_item_block_del(it);
|
|
|
|
|
|
|
|
it->wd->items = eina_inlist_append_relative(it->wd->items, EINA_INLIST_GET(it), EINA_INLIST_GET(after));
|
|
|
|
it->rel = after;
|
|
|
|
it->rel->relcount++;
|
|
|
|
it->before = EINA_FALSE;
|
|
|
|
if (after->group_item) it->group_item = after->group_item;
|
|
|
|
_item_queue(it->wd, it);
|
|
|
|
|
2011-06-26 20:06:33 -07:00
|
|
|
// TODO: change this to smart callback
|
2011-06-01 20:10:11 -07:00
|
|
|
if (it->itc->func.moved)
|
|
|
|
it->itc->func.moved(it->base.widget, it, after, EINA_TRUE);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
_item_move_before(Elm_Genlist_Item *it, Elm_Genlist_Item *before)
|
|
|
|
{
|
|
|
|
if (!it) return;
|
|
|
|
if (!before) return;
|
|
|
|
|
|
|
|
it->wd->items = eina_inlist_remove(it->wd->items, EINA_INLIST_GET(it));
|
|
|
|
_item_block_del(it);
|
|
|
|
it->wd->items = eina_inlist_prepend_relative(it->wd->items, EINA_INLIST_GET(it), EINA_INLIST_GET(before));
|
|
|
|
it->rel = before;
|
|
|
|
it->rel->relcount++;
|
|
|
|
it->before = EINA_TRUE;
|
|
|
|
if (before->group_item) it->group_item = before->group_item;
|
|
|
|
_item_queue(it->wd, it);
|
|
|
|
|
2011-06-26 20:06:33 -07:00
|
|
|
// TODO: change this to smart callback
|
2011-06-01 20:10:11 -07:00
|
|
|
if (it->itc->func.moved)
|
|
|
|
it->itc->func.moved(it->base.widget, it, before, EINA_FALSE);
|
|
|
|
}
|
|
|
|
|
2009-02-09 03:23:59 -08:00
|
|
|
EAPI Elm_Genlist_Item *
|
2010-12-07 11:18:14 -08:00
|
|
|
elm_genlist_item_append(Evas_Object *obj,
|
|
|
|
const Elm_Genlist_Item_Class *itc,
|
|
|
|
const void *data,
|
|
|
|
Elm_Genlist_Item *parent,
|
|
|
|
Elm_Genlist_Item_Flags flags,
|
|
|
|
Evas_Smart_Cb func,
|
|
|
|
const void *func_data)
|
2009-02-09 03:23:59 -08:00
|
|
|
{
|
2010-03-09 06:42:41 -08:00
|
|
|
ELM_CHECK_WIDTYPE(obj, widtype) NULL;
|
2009-02-09 03:23:59 -08:00
|
|
|
Widget_Data *wd = elm_widget_data_get(obj);
|
2011-02-13 05:16:59 -08:00
|
|
|
if (!wd) return NULL;
|
2010-12-07 11:18:14 -08:00
|
|
|
Elm_Genlist_Item *it = _item_new(wd, itc, data, parent, flags, func,
|
|
|
|
func_data);
|
2009-02-10 03:57:47 -08:00
|
|
|
if (!it) return NULL;
|
2009-02-12 05:39:43 -08:00
|
|
|
if (!it->parent)
|
2009-03-12 22:50:38 -07:00
|
|
|
{
|
2011-01-05 21:13:11 -08:00
|
|
|
if (flags & ELM_GENLIST_ITEM_GROUP)
|
2011-03-18 07:29:48 -07:00
|
|
|
wd->group_items = eina_list_append(wd->group_items, it);
|
2010-10-15 04:51:15 -07:00
|
|
|
wd->items = eina_inlist_append(wd->items, EINA_INLIST_GET(it));
|
|
|
|
it->rel = NULL;
|
2009-03-12 22:50:38 -07:00
|
|
|
}
|
2009-02-11 03:49:43 -08:00
|
|
|
else
|
|
|
|
{
|
2010-10-15 04:51:15 -07:00
|
|
|
Elm_Genlist_Item *it2 = NULL;
|
|
|
|
Eina_List *ll = eina_list_last(it->parent->items);
|
|
|
|
if (ll) it2 = ll->data;
|
|
|
|
it->parent->items = eina_list_append(it->parent->items, it);
|
|
|
|
if (!it2) it2 = it->parent;
|
2010-12-07 11:18:14 -08:00
|
|
|
wd->items =
|
2011-06-23 02:51:03 -07:00
|
|
|
eina_inlist_append_relative(wd->items, EINA_INLIST_GET(it),
|
|
|
|
EINA_INLIST_GET(it2));
|
2010-10-15 04:51:15 -07:00
|
|
|
it->rel = it2;
|
|
|
|
it->rel->relcount++;
|
2009-02-11 03:49:43 -08:00
|
|
|
}
|
2010-12-20 09:03:12 -08:00
|
|
|
it->before = EINA_FALSE;
|
2009-02-12 05:39:43 -08:00
|
|
|
_item_queue(wd, it);
|
2009-02-25 07:54:26 -08:00
|
|
|
return it;
|
2009-02-10 03:57:47 -08:00
|
|
|
}
|
|
|
|
|
|
|
|
EAPI Elm_Genlist_Item *
|
2010-12-07 11:18:14 -08:00
|
|
|
elm_genlist_item_prepend(Evas_Object *obj,
|
|
|
|
const Elm_Genlist_Item_Class *itc,
|
|
|
|
const void *data,
|
|
|
|
Elm_Genlist_Item *parent,
|
|
|
|
Elm_Genlist_Item_Flags flags,
|
|
|
|
Evas_Smart_Cb func,
|
|
|
|
const void *func_data)
|
2009-02-10 03:57:47 -08:00
|
|
|
{
|
2010-03-09 06:42:41 -08:00
|
|
|
ELM_CHECK_WIDTYPE(obj, widtype) NULL;
|
2009-02-18 04:41:45 -08:00
|
|
|
Widget_Data *wd = elm_widget_data_get(obj);
|
2011-02-13 05:16:59 -08:00
|
|
|
if (!wd) return NULL;
|
2010-12-07 11:18:14 -08:00
|
|
|
Elm_Genlist_Item *it = _item_new(wd, itc, data, parent, flags, func,
|
|
|
|
func_data);
|
2009-02-18 04:41:45 -08:00
|
|
|
if (!it) return NULL;
|
|
|
|
if (!it->parent)
|
2011-01-04 21:59:30 -08:00
|
|
|
{
|
2011-01-05 21:13:11 -08:00
|
|
|
if (flags & ELM_GENLIST_ITEM_GROUP)
|
2011-03-22 00:54:24 -07:00
|
|
|
wd->group_items = eina_list_prepend(wd->group_items, it);
|
2011-01-04 21:59:30 -08:00
|
|
|
wd->items = eina_inlist_prepend(wd->items, EINA_INLIST_GET(it));
|
|
|
|
it->rel = NULL;
|
|
|
|
}
|
2009-02-18 04:41:45 -08:00
|
|
|
else
|
|
|
|
{
|
2011-01-04 21:59:30 -08:00
|
|
|
Elm_Genlist_Item *it2 = NULL;
|
|
|
|
Eina_List *ll = it->parent->items;
|
|
|
|
if (ll) it2 = ll->data;
|
|
|
|
it->parent->items = eina_list_prepend(it->parent->items, it);
|
|
|
|
if (!it2) it2 = it->parent;
|
|
|
|
wd->items =
|
2011-04-01 09:33:58 -07:00
|
|
|
eina_inlist_prepend_relative(wd->items, EINA_INLIST_GET(it),
|
|
|
|
EINA_INLIST_GET(it2));
|
2011-01-04 21:59:30 -08:00
|
|
|
it->rel = it2;
|
|
|
|
it->rel->relcount++;
|
2009-02-18 04:41:45 -08:00
|
|
|
}
|
2010-12-20 09:03:12 -08:00
|
|
|
it->before = EINA_TRUE;
|
2009-02-18 04:41:45 -08:00
|
|
|
_item_queue(wd, it);
|
2009-02-25 07:54:26 -08:00
|
|
|
return it;
|
2009-02-10 03:57:47 -08:00
|
|
|
}
|
|
|
|
|
2011-08-01 23:59:45 -07:00
|
|
|
EAPI Elm_Genlist_Item *
|
|
|
|
elm_genlist_item_insert_after(Evas_Object *obj,
|
|
|
|
const Elm_Genlist_Item_Class *itc,
|
|
|
|
const void *data,
|
|
|
|
Elm_Genlist_Item *parent,
|
|
|
|
Elm_Genlist_Item *after,
|
|
|
|
Elm_Genlist_Item_Flags flags,
|
|
|
|
Evas_Smart_Cb func,
|
|
|
|
const void *func_data)
|
|
|
|
{
|
|
|
|
ELM_CHECK_WIDTYPE(obj, widtype) NULL;
|
|
|
|
EINA_SAFETY_ON_NULL_RETURN_VAL(after, NULL);
|
|
|
|
Widget_Data *wd = elm_widget_data_get(obj);
|
|
|
|
if (!wd) return NULL;
|
|
|
|
Elm_Genlist_Item *it = _item_new(wd, itc, data, parent, flags, func,
|
|
|
|
func_data);
|
|
|
|
if (!it) return NULL;
|
|
|
|
/* It makes no sense to insert after in an empty list with after != NULL, something really bad is happening in your app. */
|
|
|
|
EINA_SAFETY_ON_NULL_RETURN_VAL(wd->items, NULL);
|
|
|
|
|
|
|
|
if (!it->parent)
|
|
|
|
{
|
|
|
|
if ((flags & ELM_GENLIST_ITEM_GROUP) &&
|
|
|
|
(after->flags & ELM_GENLIST_ITEM_GROUP))
|
2011-08-20 22:27:19 -07:00
|
|
|
{
|
|
|
|
Elm_Genlist_Item *it2 = NULL;
|
|
|
|
Eina_List *ll = eina_list_last(after->items);
|
|
|
|
if (ll) it2 = ll->data;
|
|
|
|
else it2 = after;
|
|
|
|
|
|
|
|
wd->items =
|
|
|
|
eina_inlist_append_relative(wd->items, EINA_INLIST_GET(it),
|
|
|
|
EINA_INLIST_GET(it2));
|
|
|
|
it->rel = it2;
|
|
|
|
wd->group_items = eina_list_append_relative(wd->group_items, it,
|
|
|
|
after);
|
|
|
|
}
|
2011-08-01 23:59:45 -07:00
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
it->parent->items = eina_list_append_relative(it->parent->items, it,
|
|
|
|
after);
|
2011-08-20 22:27:19 -07:00
|
|
|
wd->items = eina_inlist_append_relative(wd->items, EINA_INLIST_GET(it),
|
|
|
|
EINA_INLIST_GET(after));
|
|
|
|
it->rel = after;
|
2011-08-01 23:59:45 -07:00
|
|
|
}
|
|
|
|
it->rel->relcount++;
|
|
|
|
it->before = EINA_FALSE;
|
|
|
|
_item_queue(wd, it);
|
|
|
|
return it;
|
|
|
|
}
|
|
|
|
|
2009-02-10 03:57:47 -08:00
|
|
|
EAPI Elm_Genlist_Item *
|
2010-12-07 11:18:14 -08:00
|
|
|
elm_genlist_item_insert_before(Evas_Object *obj,
|
|
|
|
const Elm_Genlist_Item_Class *itc,
|
|
|
|
const void *data,
|
2011-01-04 22:03:43 -08:00
|
|
|
Elm_Genlist_Item *parent,
|
2010-12-07 11:18:14 -08:00
|
|
|
Elm_Genlist_Item *before,
|
|
|
|
Elm_Genlist_Item_Flags flags,
|
|
|
|
Evas_Smart_Cb func,
|
|
|
|
const void *func_data)
|
2009-02-10 03:57:47 -08:00
|
|
|
{
|
2010-03-09 06:42:41 -08:00
|
|
|
ELM_CHECK_WIDTYPE(obj, widtype) NULL;
|
2010-10-10 19:09:36 -07:00
|
|
|
EINA_SAFETY_ON_NULL_RETURN_VAL(before, NULL);
|
2009-02-18 04:41:45 -08:00
|
|
|
Widget_Data *wd = elm_widget_data_get(obj);
|
2011-02-13 05:16:59 -08:00
|
|
|
if (!wd) return NULL;
|
2011-01-04 22:03:43 -08:00
|
|
|
Elm_Genlist_Item *it = _item_new(wd, itc, data, parent, flags, func,
|
2010-12-07 11:18:14 -08:00
|
|
|
func_data);
|
2009-02-18 04:41:45 -08:00
|
|
|
if (!it) return NULL;
|
2011-08-01 23:54:10 -07:00
|
|
|
/* It makes no sense to insert before in an empty list with before != NULL, something really bad is happening in your app. */
|
|
|
|
EINA_SAFETY_ON_NULL_RETURN_VAL(wd->items, NULL);
|
|
|
|
|
2011-08-01 23:50:34 -07:00
|
|
|
if (!it->parent)
|
|
|
|
{
|
|
|
|
if ((flags & ELM_GENLIST_ITEM_GROUP) &&
|
|
|
|
(before->flags & ELM_GENLIST_ITEM_GROUP))
|
|
|
|
wd->group_items = eina_list_prepend_relative(wd->group_items, it,
|
|
|
|
before);
|
|
|
|
}
|
|
|
|
else
|
2009-02-18 04:41:45 -08:00
|
|
|
{
|
2011-01-04 22:03:43 -08:00
|
|
|
it->parent->items = eina_list_prepend_relative(it->parent->items, it,
|
|
|
|
before);
|
2009-02-18 04:41:45 -08:00
|
|
|
}
|
2011-01-04 22:03:43 -08:00
|
|
|
wd->items = eina_inlist_prepend_relative(wd->items, EINA_INLIST_GET(it),
|
|
|
|
EINA_INLIST_GET(before));
|
2009-02-25 07:54:26 -08:00
|
|
|
it->rel = before;
|
2009-02-18 20:37:06 -08:00
|
|
|
it->rel->relcount++;
|
2010-12-20 09:03:12 -08:00
|
|
|
it->before = EINA_TRUE;
|
2009-02-18 04:41:45 -08:00
|
|
|
_item_queue(wd, it);
|
2009-02-25 07:54:26 -08:00
|
|
|
return it;
|
2009-02-10 03:57:47 -08:00
|
|
|
}
|
|
|
|
|
2011-05-25 07:58:39 -07:00
|
|
|
EAPI Elm_Genlist_Item *
|
2011-06-25 16:20:22 -07:00
|
|
|
elm_genlist_item_direct_sorted_insert(Evas_Object *obj,
|
|
|
|
const Elm_Genlist_Item_Class *itc,
|
|
|
|
const void *data,
|
|
|
|
Elm_Genlist_Item *parent,
|
|
|
|
Elm_Genlist_Item_Flags flags,
|
|
|
|
Eina_Compare_Cb comp,
|
|
|
|
Evas_Smart_Cb func,
|
|
|
|
const void *func_data)
|
2011-05-25 07:58:39 -07:00
|
|
|
{
|
|
|
|
ELM_CHECK_WIDTYPE(obj, widtype) NULL;
|
|
|
|
Widget_Data *wd = elm_widget_data_get(obj);
|
|
|
|
if (!wd) return NULL;
|
2011-07-28 09:43:15 -07:00
|
|
|
Elm_Genlist_Item *rel = NULL;
|
2011-05-25 07:58:39 -07:00
|
|
|
Elm_Genlist_Item *it = _item_new(wd, itc, data, parent, flags, func,
|
|
|
|
func_data);
|
|
|
|
if (!it) return NULL;
|
|
|
|
|
|
|
|
_elm_genlist_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;
|
|
|
|
|
|
|
|
l = eina_list_search_sorted_near_list(it->parent->items,
|
|
|
|
_elm_genlist_item_list_compare, it,
|
|
|
|
&cmp_result);
|
|
|
|
if (l)
|
|
|
|
rel = eina_list_data_get(l);
|
|
|
|
else
|
|
|
|
rel = it->parent;
|
|
|
|
|
2011-07-29 09:07:10 -07:00
|
|
|
if (cmp_result >= 0)
|
2011-07-28 09:43:15 -07:00
|
|
|
{
|
|
|
|
it->parent->items = eina_list_prepend_relative_list(it->parent->items, it, l);
|
|
|
|
wd->items = eina_inlist_prepend_relative(wd->items, EINA_INLIST_GET(it), EINA_INLIST_GET(rel));
|
|
|
|
it->before = EINA_FALSE;
|
|
|
|
}
|
|
|
|
else if (cmp_result < 0)
|
|
|
|
{
|
|
|
|
it->parent->items = eina_list_append_relative_list(it->parent->items, it, l);
|
|
|
|
wd->items = eina_inlist_append_relative(wd->items, EINA_INLIST_GET(it), EINA_INLIST_GET(rel));
|
|
|
|
it->before = EINA_TRUE;
|
|
|
|
}
|
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
|
|
|
{
|
2011-07-28 09:43:15 -07:00
|
|
|
if (flags & ELM_GENLIST_ITEM_GROUP)
|
|
|
|
wd->group_items = eina_list_append(wd->group_items, it);
|
|
|
|
|
|
|
|
wd->items = eina_inlist_sorted_insert(wd->items, EINA_INLIST_GET(it),
|
|
|
|
_elm_genlist_item_compare);
|
|
|
|
|
|
|
|
if (EINA_INLIST_GET(it)->next)
|
|
|
|
{
|
|
|
|
rel = ELM_GENLIST_ITEM_FROM_INLIST(EINA_INLIST_GET(it)->next);
|
|
|
|
it->before = EINA_TRUE;
|
|
|
|
}
|
|
|
|
else if (EINA_INLIST_GET(it)->prev)
|
|
|
|
{
|
|
|
|
rel = ELM_GENLIST_ITEM_FROM_INLIST(EINA_INLIST_GET(it)->prev);
|
|
|
|
it->before = EINA_FALSE;
|
|
|
|
}
|
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-07-28 09:43:15 -07:00
|
|
|
it->rel = rel;
|
2011-05-25 07:58:39 -07:00
|
|
|
it->rel->relcount++;
|
|
|
|
}
|
2011-07-28 09:43:15 -07:00
|
|
|
|
2011-05-25 07:58:39 -07:00
|
|
|
_item_queue(wd, it);
|
|
|
|
|
|
|
|
return it;
|
|
|
|
}
|
|
|
|
|
2011-06-25 16:20:22 -07:00
|
|
|
EAPI Elm_Genlist_Item *
|
|
|
|
elm_genlist_item_sorted_insert(Evas_Object *obj,
|
|
|
|
const Elm_Genlist_Item_Class *itc,
|
|
|
|
const void *data,
|
|
|
|
Elm_Genlist_Item *parent,
|
|
|
|
Elm_Genlist_Item_Flags flags,
|
|
|
|
Eina_Compare_Cb comp,
|
|
|
|
Evas_Smart_Cb func,
|
|
|
|
const void *func_data)
|
|
|
|
{
|
|
|
|
_elm_genlist_item_compare_data_cb = comp;
|
|
|
|
|
|
|
|
return elm_genlist_item_direct_sorted_insert(obj, itc, data, parent, flags,
|
|
|
|
_elm_genlist_item_compare_data, func, func_data);
|
|
|
|
}
|
|
|
|
|
2009-02-17 20:27:49 -08:00
|
|
|
EAPI void
|
|
|
|
elm_genlist_clear(Evas_Object *obj)
|
|
|
|
{
|
2010-03-08 22:15:39 -08:00
|
|
|
ELM_CHECK_WIDTYPE(obj, widtype);
|
2009-02-17 20:27:49 -08:00
|
|
|
Widget_Data *wd = elm_widget_data_get(obj);
|
2010-03-09 06:42:41 -08:00
|
|
|
if (!wd) return;
|
2010-07-28 01:35:34 -07:00
|
|
|
if (wd->walking > 0)
|
|
|
|
{
|
2010-10-15 04:51:15 -07:00
|
|
|
Elm_Genlist_Item *it;
|
|
|
|
|
2010-12-20 09:03:12 -08:00
|
|
|
wd->clear_me = EINA_TRUE;
|
2010-07-28 01:35:34 -07:00
|
|
|
EINA_INLIST_FOREACH(wd->items, it)
|
2011-03-22 00:54:24 -07:00
|
|
|
{
|
|
|
|
it->delete_me = EINA_TRUE;
|
|
|
|
}
|
2010-10-15 04:51:15 -07:00
|
|
|
return;
|
2010-07-28 01:35:34 -07:00
|
|
|
}
|
2011-05-27 03:30:56 -07:00
|
|
|
evas_event_freeze(evas_object_evas_get(wd->obj));
|
2009-02-17 20:27:49 -08:00
|
|
|
while (wd->items)
|
|
|
|
{
|
2010-10-15 04:51:15 -07:00
|
|
|
Elm_Genlist_Item *it = ELM_GENLIST_ITEM_FROM_INLIST(wd->items);
|
2009-09-26 11:24:06 -07:00
|
|
|
|
2010-12-07 11:18:14 -08:00
|
|
|
if (wd->anchor_item == it)
|
|
|
|
{
|
2011-02-02 00:37:33 -08:00
|
|
|
wd->anchor_item = ELM_GENLIST_ITEM_FROM_INLIST(EINA_INLIST_GET(it)->next);
|
2010-12-07 11:18:14 -08:00
|
|
|
if (!wd->anchor_item)
|
|
|
|
wd->anchor_item =
|
2011-04-01 09:33:58 -07:00
|
|
|
ELM_GENLIST_ITEM_FROM_INLIST(EINA_INLIST_GET(it)->prev);
|
2010-12-07 11:18:14 -08:00
|
|
|
}
|
2010-10-15 04:51:15 -07:00
|
|
|
wd->items = eina_inlist_remove(wd->items, wd->items);
|
2011-01-06 20:58:37 -08:00
|
|
|
if (it->flags & ELM_GENLIST_ITEM_GROUP)
|
|
|
|
it->wd->group_items = eina_list_remove(it->wd->group_items, it);
|
2010-09-09 19:05:45 -07:00
|
|
|
elm_widget_item_pre_notify_del(it);
|
2011-04-14 04:41:07 -07:00
|
|
|
if (it->realized) _item_unrealize(it, EINA_FALSE);
|
2011-03-18 07:29:48 -07:00
|
|
|
if (((wd->clear_me) || (!it->delete_me)) && (it->itc->func.del))
|
2010-12-07 11:18:14 -08:00
|
|
|
it->itc->func.del((void *)it->base.data, it->base.widget);
|
2010-10-15 04:51:15 -07:00
|
|
|
if (it->long_timer) ecore_timer_del(it->long_timer);
|
2010-10-18 19:23:58 -07:00
|
|
|
if (it->swipe_timer) ecore_timer_del(it->swipe_timer);
|
2010-09-09 19:05:45 -07:00
|
|
|
elm_widget_item_del(it);
|
2009-02-17 20:27:49 -08:00
|
|
|
}
|
2011-02-27 03:11:05 -08:00
|
|
|
wd->clear_me = EINA_FALSE;
|
2010-11-24 23:07:39 -08:00
|
|
|
wd->anchor_item = NULL;
|
2009-02-17 20:27:49 -08:00
|
|
|
while (wd->blocks)
|
|
|
|
{
|
2010-10-15 04:51:15 -07:00
|
|
|
Item_Block *itb = (Item_Block *)(wd->blocks);
|
2009-09-26 11:24:06 -07:00
|
|
|
|
2010-10-15 04:51:15 -07:00
|
|
|
wd->blocks = eina_inlist_remove(wd->blocks, wd->blocks);
|
|
|
|
if (itb->items) eina_list_free(itb->items);
|
|
|
|
free(itb);
|
2009-02-17 20:27:49 -08:00
|
|
|
}
|
|
|
|
if (wd->calc_job)
|
|
|
|
{
|
2010-10-15 04:51:15 -07:00
|
|
|
ecore_job_del(wd->calc_job);
|
|
|
|
wd->calc_job = NULL;
|
2009-02-17 20:27:49 -08:00
|
|
|
}
|
2011-04-27 03:17:26 -07:00
|
|
|
if (wd->queue_idle_enterer)
|
2009-02-17 20:27:49 -08:00
|
|
|
{
|
2011-04-27 03:17:26 -07:00
|
|
|
ecore_idle_enterer_del(wd->queue_idle_enterer);
|
|
|
|
wd->queue_idle_enterer = NULL;
|
2009-02-17 20:27:49 -08:00
|
|
|
}
|
2010-11-20 00:43:43 -08:00
|
|
|
if (wd->must_recalc_idler)
|
|
|
|
{
|
|
|
|
ecore_idler_del(wd->must_recalc_idler);
|
|
|
|
wd->must_recalc_idler = NULL;
|
|
|
|
}
|
2009-02-17 20:27:49 -08:00
|
|
|
if (wd->queue)
|
|
|
|
{
|
2010-10-15 04:51:15 -07:00
|
|
|
eina_list_free(wd->queue);
|
|
|
|
wd->queue = NULL;
|
2009-02-17 20:27:49 -08:00
|
|
|
}
|
|
|
|
if (wd->selected)
|
|
|
|
{
|
2010-10-15 04:51:15 -07:00
|
|
|
eina_list_free(wd->selected);
|
|
|
|
wd->selected = NULL;
|
2009-02-17 20:27:49 -08:00
|
|
|
}
|
2011-06-03 18:52:08 -07:00
|
|
|
if (wd->reorder_move_animator)
|
2011-06-01 20:10:11 -07:00
|
|
|
{
|
2011-06-03 18:52:08 -07:00
|
|
|
ecore_animator_del(wd->reorder_move_animator);
|
|
|
|
wd->reorder_move_animator = NULL;
|
2011-06-01 20:10:11 -07:00
|
|
|
}
|
2009-02-17 20:27:49 -08:00
|
|
|
wd->show_item = NULL;
|
|
|
|
wd->pan_x = 0;
|
|
|
|
wd->pan_y = 0;
|
2011-06-01 20:10:11 -07:00
|
|
|
wd->old_pan_y = 0;
|
2009-02-17 20:27:49 -08:00
|
|
|
wd->minw = 0;
|
|
|
|
wd->minh = 0;
|
2010-09-09 17:28:47 -07:00
|
|
|
if (wd->pan_smart)
|
|
|
|
{
|
|
|
|
evas_object_size_hint_min_set(wd->pan_smart, wd->minw, wd->minh);
|
|
|
|
evas_object_smart_callback_call(wd->pan_smart, "changed", NULL);
|
|
|
|
}
|
2009-03-12 22:50:38 -07:00
|
|
|
_sizing_eval(obj);
|
2011-05-27 03:30:56 -07:00
|
|
|
evas_event_thaw(evas_object_evas_get(wd->obj));
|
|
|
|
evas_event_thaw_eval(evas_object_evas_get(wd->obj));
|
2009-02-17 20:27:49 -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,
|
|
|
|
Eina_Bool multi)
|
2009-02-10 03:57:47 -08:00
|
|
|
{
|
2010-03-08 22:15:39 -08:00
|
|
|
ELM_CHECK_WIDTYPE(obj, widtype);
|
2009-02-16 23:50:35 -08:00
|
|
|
Widget_Data *wd = elm_widget_data_get(obj);
|
2010-03-09 06:42:41 -08:00
|
|
|
if (!wd) return;
|
2009-02-16 23:50:35 -08:00
|
|
|
wd->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)
|
|
|
|
{
|
|
|
|
ELM_CHECK_WIDTYPE(obj, widtype) EINA_FALSE;
|
|
|
|
Widget_Data *wd = elm_widget_data_get(obj);
|
|
|
|
if (!wd) return EINA_FALSE;
|
|
|
|
return wd->multi;
|
|
|
|
}
|
|
|
|
|
2009-02-25 07:54:26 -08:00
|
|
|
EAPI Elm_Genlist_Item *
|
|
|
|
elm_genlist_selected_item_get(const Evas_Object *obj)
|
2009-02-10 03:57:47 -08:00
|
|
|
{
|
2010-03-09 06:42:41 -08:00
|
|
|
ELM_CHECK_WIDTYPE(obj, widtype) NULL;
|
2009-02-16 23:50:35 -08:00
|
|
|
Widget_Data *wd = elm_widget_data_get(obj);
|
2010-03-09 06:42:41 -08:00
|
|
|
if (!wd) return NULL;
|
2009-02-16 23:50:35 -08:00
|
|
|
if (wd->selected) return wd->selected->data;
|
|
|
|
return 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
|
|
|
{
|
2010-03-09 06:42:41 -08:00
|
|
|
ELM_CHECK_WIDTYPE(obj, widtype) NULL;
|
2009-02-16 23:50:35 -08:00
|
|
|
Widget_Data *wd = elm_widget_data_get(obj);
|
2010-03-09 06:42:41 -08:00
|
|
|
if (!wd) return NULL;
|
2009-02-16 23:50:35 -08:00
|
|
|
return wd->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)
|
|
|
|
{
|
2010-03-09 06:42:41 -08:00
|
|
|
ELM_CHECK_WIDTYPE(obj, widtype) NULL;
|
2010-01-24 21:54:31 -08:00
|
|
|
Widget_Data *wd = elm_widget_data_get(obj);
|
|
|
|
Eina_List *list = NULL;
|
|
|
|
Item_Block *itb;
|
2010-06-05 06:12:45 -07:00
|
|
|
Eina_Bool done = EINA_FALSE;
|
2010-03-09 06:42:41 -08:00
|
|
|
if (!wd) return NULL;
|
2010-01-24 21:54:31 -08:00
|
|
|
EINA_INLIST_FOREACH(wd->blocks, itb)
|
2011-03-22 00:54:24 -07:00
|
|
|
{
|
|
|
|
if (itb->realized)
|
|
|
|
{
|
|
|
|
Eina_List *l;
|
|
|
|
Elm_Genlist_Item *it;
|
|
|
|
|
|
|
|
done = 1;
|
|
|
|
EINA_LIST_FOREACH(itb->items, l, it)
|
|
|
|
{
|
|
|
|
if (it->realized) list = eina_list_append(list, it);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
if (done) break;
|
|
|
|
}
|
|
|
|
}
|
2010-01-24 21:54:31 -08:00
|
|
|
return list;
|
|
|
|
}
|
|
|
|
|
2009-09-22 20:22:07 -07:00
|
|
|
EAPI Elm_Genlist_Item *
|
2010-12-07 11:18:14 -08:00
|
|
|
elm_genlist_at_xy_item_get(const Evas_Object *obj,
|
|
|
|
Evas_Coord x,
|
|
|
|
Evas_Coord y,
|
|
|
|
int *posret)
|
2009-09-22 20:22:07 -07:00
|
|
|
{
|
2010-03-09 06:42:41 -08:00
|
|
|
ELM_CHECK_WIDTYPE(obj, widtype) NULL;
|
2009-09-22 20:22:07 -07:00
|
|
|
Widget_Data *wd = elm_widget_data_get(obj);
|
|
|
|
Evas_Coord ox, oy, ow, oh;
|
|
|
|
Item_Block *itb;
|
|
|
|
Evas_Coord lasty;
|
2010-03-09 06:42:41 -08:00
|
|
|
if (!wd) return NULL;
|
2009-09-22 20:22:07 -07:00
|
|
|
evas_object_geometry_get(wd->pan_smart, &ox, &oy, &ow, &oh);
|
|
|
|
lasty = oy;
|
|
|
|
EINA_INLIST_FOREACH(wd->blocks, itb)
|
2011-03-22 00:54:24 -07:00
|
|
|
{
|
|
|
|
Eina_List *l;
|
|
|
|
Elm_Genlist_Item *it;
|
|
|
|
|
|
|
|
if (!ELM_RECTS_INTERSECT(ox + itb->x - itb->wd->pan_x,
|
|
|
|
oy + itb->y - itb->wd->pan_y,
|
|
|
|
itb->w, itb->h, x, y, 1, 1))
|
|
|
|
continue;
|
|
|
|
EINA_LIST_FOREACH(itb->items, l, it)
|
|
|
|
{
|
|
|
|
Evas_Coord itx, ity;
|
|
|
|
|
|
|
|
itx = ox + itb->x + it->x - itb->wd->pan_x;
|
|
|
|
ity = oy + itb->y + it->y - itb->wd->pan_y;
|
|
|
|
if (ELM_RECTS_INTERSECT(itx, ity, it->w, it->h, x, y, 1, 1))
|
|
|
|
{
|
|
|
|
if (posret)
|
|
|
|
{
|
|
|
|
if (y <= (ity + (it->h / 4))) *posret = -1;
|
|
|
|
else if (y >= (ity + it->h - (it->h / 4)))
|
|
|
|
*posret = 1;
|
|
|
|
else *posret = 0;
|
|
|
|
}
|
|
|
|
return it;
|
|
|
|
}
|
|
|
|
lasty = ity + it->h;
|
|
|
|
}
|
|
|
|
}
|
2009-09-22 20:22:07 -07:00
|
|
|
if (posret)
|
|
|
|
{
|
|
|
|
if (y > lasty) *posret = 1;
|
|
|
|
else *posret = -1;
|
|
|
|
}
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
2009-02-25 07:54:26 -08:00
|
|
|
EAPI Elm_Genlist_Item *
|
|
|
|
elm_genlist_first_item_get(const Evas_Object *obj)
|
2009-02-10 03:57:47 -08:00
|
|
|
{
|
2010-03-09 06:42:41 -08:00
|
|
|
ELM_CHECK_WIDTYPE(obj, widtype) NULL;
|
2009-02-16 23:50:35 -08:00
|
|
|
Widget_Data *wd = elm_widget_data_get(obj);
|
2010-03-09 06:42:41 -08:00
|
|
|
if (!wd) return NULL;
|
2009-09-26 11:24:06 -07:00
|
|
|
if (!wd->items) return NULL;
|
2010-09-09 18:04:19 -07:00
|
|
|
Elm_Genlist_Item *it = ELM_GENLIST_ITEM_FROM_INLIST(wd->items);
|
2009-02-25 07:54:26 -08:00
|
|
|
while ((it) && (it->delete_me))
|
2010-12-07 11:18:14 -08:00
|
|
|
it = ELM_GENLIST_ITEM_FROM_INLIST(EINA_INLIST_GET(it)->next);
|
2009-02-25 07:54:26 -08:00
|
|
|
return it;
|
2009-02-16 23:50:35 -08:00
|
|
|
}
|
|
|
|
|
2009-02-25 07:54:26 -08:00
|
|
|
EAPI Elm_Genlist_Item *
|
|
|
|
elm_genlist_last_item_get(const Evas_Object *obj)
|
2009-02-16 23:50:35 -08:00
|
|
|
{
|
2010-03-09 06:42:41 -08:00
|
|
|
ELM_CHECK_WIDTYPE(obj, widtype) NULL;
|
2009-02-16 23:50:35 -08:00
|
|
|
Widget_Data *wd = elm_widget_data_get(obj);
|
2011-01-31 00:30:11 -08:00
|
|
|
if (!wd) return NULL;
|
2009-02-16 23:50:35 -08:00
|
|
|
if (!wd->items) return NULL;
|
2010-09-09 18:04:19 -07:00
|
|
|
Elm_Genlist_Item *it = ELM_GENLIST_ITEM_FROM_INLIST(wd->items->last);
|
2009-02-25 07:54:26 -08:00
|
|
|
while ((it) && (it->delete_me))
|
2010-12-07 11:18:14 -08:00
|
|
|
it = ELM_GENLIST_ITEM_FROM_INLIST(EINA_INLIST_GET(it)->prev);
|
2009-02-25 07:54:26 -08:00
|
|
|
return it;
|
2009-02-16 23:50:35 -08:00
|
|
|
}
|
|
|
|
|
2009-02-25 07:54:26 -08:00
|
|
|
EAPI Elm_Genlist_Item *
|
|
|
|
elm_genlist_item_next_get(const Elm_Genlist_Item *it)
|
2009-02-16 23:50:35 -08:00
|
|
|
{
|
2010-11-02 04:27:07 -07:00
|
|
|
ELM_WIDGET_ITEM_WIDTYPE_CHECK_OR_RETURN(it, NULL);
|
2009-02-18 20:37:06 -08:00
|
|
|
while (it)
|
|
|
|
{
|
2010-10-15 04:51:15 -07:00
|
|
|
it = ELM_GENLIST_ITEM_FROM_INLIST(EINA_INLIST_GET(it)->next);
|
|
|
|
if ((it) && (!it->delete_me)) break;
|
2009-02-18 20:37:06 -08:00
|
|
|
}
|
|
|
|
return (Elm_Genlist_Item *)it;
|
2009-02-16 23:50:35 -08:00
|
|
|
}
|
|
|
|
|
2009-02-25 07:54:26 -08:00
|
|
|
EAPI Elm_Genlist_Item *
|
|
|
|
elm_genlist_item_prev_get(const Elm_Genlist_Item *it)
|
2009-02-16 23:50:35 -08:00
|
|
|
{
|
2010-11-02 04:27:07 -07:00
|
|
|
ELM_WIDGET_ITEM_WIDTYPE_CHECK_OR_RETURN(it, NULL);
|
2009-02-18 20:37:06 -08:00
|
|
|
while (it)
|
|
|
|
{
|
2010-10-15 04:51:15 -07:00
|
|
|
it = ELM_GENLIST_ITEM_FROM_INLIST(EINA_INLIST_GET(it)->prev);
|
|
|
|
if ((it) && (!it->delete_me)) break;
|
2009-02-18 20:37:06 -08:00
|
|
|
}
|
|
|
|
return (Elm_Genlist_Item *)it;
|
2009-02-10 03:57:47 -08:00
|
|
|
}
|
|
|
|
|
2009-03-12 22:50:38 -07:00
|
|
|
EAPI Evas_Object *
|
|
|
|
elm_genlist_item_genlist_get(const Elm_Genlist_Item *it)
|
|
|
|
{
|
2010-11-02 04:27:07 -07:00
|
|
|
ELM_WIDGET_ITEM_WIDTYPE_CHECK_OR_RETURN(it, NULL);
|
2010-09-09 19:05:45 -07:00
|
|
|
return it->base.widget;
|
2009-03-12 22:50:38 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
EAPI Elm_Genlist_Item *
|
|
|
|
elm_genlist_item_parent_get(const Elm_Genlist_Item *it)
|
|
|
|
{
|
2010-11-02 04:27:07 -07:00
|
|
|
ELM_WIDGET_ITEM_WIDTYPE_CHECK_OR_RETURN(it, NULL);
|
2009-03-12 22:50:38 -07:00
|
|
|
return it->parent;
|
|
|
|
}
|
|
|
|
|
|
|
|
EAPI void
|
|
|
|
elm_genlist_item_subitems_clear(Elm_Genlist_Item *it)
|
|
|
|
{
|
2010-11-02 04:27:07 -07:00
|
|
|
ELM_WIDGET_ITEM_WIDTYPE_CHECK_OR_RETURN(it);
|
2009-03-12 22:50:38 -07:00
|
|
|
Eina_List *tl = NULL, *l;
|
|
|
|
Elm_Genlist_Item *it2;
|
2009-07-06 23:46:51 -07:00
|
|
|
|
2009-03-12 22:50:38 -07:00
|
|
|
EINA_LIST_FOREACH(it->items, l, it2)
|
2011-04-01 09:33:58 -07:00
|
|
|
tl = eina_list_append(tl, it2);
|
2009-03-12 22:50:38 -07:00
|
|
|
EINA_LIST_FREE(tl, it2)
|
2011-04-01 09:33:58 -07:00
|
|
|
elm_genlist_item_del(it2);
|
2009-03-12 22:50:38 -07:00
|
|
|
}
|
|
|
|
|
2009-02-10 03:57:47 -08:00
|
|
|
EAPI void
|
2010-12-07 11:18:14 -08:00
|
|
|
elm_genlist_item_selected_set(Elm_Genlist_Item *it,
|
|
|
|
Eina_Bool selected)
|
2009-02-10 03:57:47 -08:00
|
|
|
{
|
2010-11-02 04:27:07 -07:00
|
|
|
ELM_WIDGET_ITEM_WIDTYPE_CHECK_OR_RETURN(it);
|
2010-09-09 19:05:45 -07:00
|
|
|
Widget_Data *wd = elm_widget_data_get(it->base.widget);
|
2010-03-09 06:42:41 -08:00
|
|
|
if (!wd) return;
|
2011-05-05 19:59:49 -07:00
|
|
|
if ((it->delete_me) || (it->disabled)) return;
|
2009-02-25 07:54:26 -08:00
|
|
|
selected = !!selected;
|
|
|
|
if (it->selected == selected) return;
|
|
|
|
|
2009-02-16 23:50:35 -08:00
|
|
|
if (selected)
|
|
|
|
{
|
2010-10-15 04:51:15 -07:00
|
|
|
if (!wd->multi)
|
|
|
|
{
|
|
|
|
while (wd->selected)
|
2011-05-24 04:41:00 -07:00
|
|
|
{
|
|
|
|
_item_unhighlight(wd->selected->data);
|
|
|
|
_item_unselect(wd->selected->data);
|
|
|
|
}
|
2010-10-15 04:51:15 -07:00
|
|
|
}
|
2011-03-10 11:59:10 -08:00
|
|
|
_item_highlight(it);
|
2010-10-15 04:51:15 -07:00
|
|
|
_item_select(it);
|
2009-02-16 23:50:35 -08:00
|
|
|
}
|
2009-02-25 07:54:26 -08:00
|
|
|
else
|
2011-05-24 04:41:00 -07:00
|
|
|
{
|
|
|
|
_item_unhighlight(it);
|
|
|
|
_item_unselect(it);
|
|
|
|
}
|
2009-02-10 03:57:47 -08:00
|
|
|
}
|
|
|
|
|
2009-06-17 08:35:19 -07:00
|
|
|
EAPI Eina_Bool
|
2009-02-25 07:54:26 -08:00
|
|
|
elm_genlist_item_selected_get(const Elm_Genlist_Item *it)
|
2009-02-17 20:51:22 -08:00
|
|
|
{
|
2010-11-02 04:27:07 -07:00
|
|
|
ELM_WIDGET_ITEM_WIDTYPE_CHECK_OR_RETURN(it, EINA_FALSE);
|
2009-02-17 20:51:22 -08:00
|
|
|
return it->selected;
|
|
|
|
}
|
|
|
|
|
2009-02-10 03:57:47 -08:00
|
|
|
EAPI void
|
2010-12-07 11:18:14 -08:00
|
|
|
elm_genlist_item_expanded_set(Elm_Genlist_Item *it,
|
|
|
|
Eina_Bool expanded)
|
2009-02-10 03:57:47 -08:00
|
|
|
{
|
2010-11-02 04:27:07 -07:00
|
|
|
ELM_WIDGET_ITEM_WIDTYPE_CHECK_OR_RETURN(it);
|
2009-03-12 22:50:38 -07:00
|
|
|
if (it->expanded == expanded) return;
|
|
|
|
it->expanded = expanded;
|
2011-06-14 02:18:54 -07:00
|
|
|
it->wd->expanded_item = it;
|
2009-03-12 22:50:38 -07:00
|
|
|
if (it->expanded)
|
|
|
|
{
|
2010-10-15 04:51:15 -07:00
|
|
|
if (it->realized)
|
2010-12-07 11:18:14 -08:00
|
|
|
edje_object_signal_emit(it->base.view, "elm,state,expanded", "elm");
|
2011-05-06 17:30:39 -07:00
|
|
|
evas_object_smart_callback_call(it->base.widget, SIG_EXPANDED, it);
|
2011-06-14 02:18:54 -07:00
|
|
|
it->wd->auto_scroll_enabled = EINA_TRUE;
|
2009-03-12 22:50:38 -07:00
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
2010-10-15 04:51:15 -07:00
|
|
|
if (it->realized)
|
2010-12-07 11:18:14 -08:00
|
|
|
edje_object_signal_emit(it->base.view, "elm,state,contracted", "elm");
|
2011-05-06 17:30:39 -07:00
|
|
|
evas_object_smart_callback_call(it->base.widget, SIG_CONTRACTED, it);
|
2011-06-14 02:18:54 -07:00
|
|
|
it->wd->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
|
2009-03-12 22:50:38 -07:00
|
|
|
elm_genlist_item_expanded_get(const Elm_Genlist_Item *it)
|
2009-02-17 20:51:22 -08:00
|
|
|
{
|
2010-11-02 04:27:07 -07:00
|
|
|
ELM_WIDGET_ITEM_WIDTYPE_CHECK_OR_RETURN(it, EINA_FALSE);
|
2009-03-12 22:50:38 -07:00
|
|
|
return it->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
|
2010-10-25 07:34:22 -07:00
|
|
|
elm_genlist_item_expanded_depth_get(const Elm_Genlist_Item *it)
|
2010-10-06 23:45:36 -07:00
|
|
|
{
|
2010-11-02 04:27:07 -07:00
|
|
|
ELM_WIDGET_ITEM_WIDTYPE_CHECK_OR_RETURN(it, 0);
|
2010-10-06 23:45:36 -07:00
|
|
|
return it->expanded_depth;
|
|
|
|
}
|
|
|
|
|
2009-02-10 03:57:47 -08:00
|
|
|
EAPI void
|
2010-12-07 11:18:14 -08:00
|
|
|
elm_genlist_item_disabled_set(Elm_Genlist_Item *it,
|
|
|
|
Eina_Bool disabled)
|
2009-02-10 03:57:47 -08:00
|
|
|
{
|
2010-11-02 04:27:07 -07:00
|
|
|
ELM_WIDGET_ITEM_WIDTYPE_CHECK_OR_RETURN(it);
|
2011-05-05 19:07:00 -07:00
|
|
|
Eina_List *l;
|
|
|
|
Evas_Object *obj;
|
2009-02-17 20:51:22 -08:00
|
|
|
if (it->disabled == disabled) return;
|
2009-02-18 20:37:06 -08:00
|
|
|
if (it->delete_me) return;
|
2011-04-27 09:06:11 -07:00
|
|
|
it->disabled = !!disabled;
|
2011-05-05 19:07:00 -07:00
|
|
|
if (it->selected)
|
|
|
|
elm_genlist_item_selected_set(it, EINA_FALSE);
|
2009-02-17 20:51:22 -08:00
|
|
|
if (it->realized)
|
|
|
|
{
|
2010-10-15 04:51:15 -07:00
|
|
|
if (it->disabled)
|
2010-12-07 11:18:14 -08:00
|
|
|
edje_object_signal_emit(it->base.view, "elm,state,disabled", "elm");
|
2010-10-15 04:51:15 -07:00
|
|
|
else
|
2010-12-07 11:18:14 -08:00
|
|
|
edje_object_signal_emit(it->base.view, "elm,state,enabled", "elm");
|
2011-05-05 19:07:00 -07:00
|
|
|
EINA_LIST_FOREACH(it->icon_objs, l, obj)
|
|
|
|
elm_widget_disabled_set(obj, disabled);
|
2009-02-17 20:51:22 -08:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2009-06-17 08:35:19 -07:00
|
|
|
EAPI Eina_Bool
|
2009-02-25 07:54:26 -08:00
|
|
|
elm_genlist_item_disabled_get(const Elm_Genlist_Item *it)
|
2009-02-17 20:51:22 -08:00
|
|
|
{
|
2010-11-02 04:27:07 -07:00
|
|
|
ELM_WIDGET_ITEM_WIDTYPE_CHECK_OR_RETURN(it, EINA_FALSE);
|
2009-06-17 08:35:19 -07:00
|
|
|
if (it->delete_me) return EINA_FALSE;
|
2009-02-17 20:51:22 -08:00
|
|
|
return it->disabled;
|
2009-02-10 03:57:47 -08:00
|
|
|
}
|
|
|
|
|
2010-02-04 00:06:41 -08:00
|
|
|
EAPI void
|
2010-12-07 11:18:14 -08:00
|
|
|
elm_genlist_item_display_only_set(Elm_Genlist_Item *it,
|
|
|
|
Eina_Bool display_only)
|
2010-02-04 00:06:41 -08:00
|
|
|
{
|
2010-11-02 04:27:07 -07:00
|
|
|
ELM_WIDGET_ITEM_WIDTYPE_CHECK_OR_RETURN(it);
|
2010-02-04 00:06:41 -08:00
|
|
|
if (it->display_only == display_only) return;
|
|
|
|
if (it->delete_me) return;
|
|
|
|
it->display_only = display_only;
|
|
|
|
it->mincalcd = EINA_FALSE;
|
|
|
|
it->updateme = EINA_TRUE;
|
2011-02-21 08:08:23 -08:00
|
|
|
if (it->block) it->block->updateme = EINA_TRUE;
|
2010-02-04 00:06:41 -08:00
|
|
|
if (it->wd->update_job) ecore_job_del(it->wd->update_job);
|
|
|
|
it->wd->update_job = ecore_job_add(_update_job, it->wd);
|
|
|
|
}
|
|
|
|
|
|
|
|
EAPI Eina_Bool
|
|
|
|
elm_genlist_item_display_only_get(const Elm_Genlist_Item *it)
|
|
|
|
{
|
2010-11-02 04:27:07 -07:00
|
|
|
ELM_WIDGET_ITEM_WIDTYPE_CHECK_OR_RETURN(it, EINA_FALSE);
|
2010-02-04 00:06:41 -08:00
|
|
|
if (it->delete_me) return EINA_FALSE;
|
|
|
|
return it->display_only;
|
|
|
|
}
|
|
|
|
|
2009-02-10 03:57:47 -08:00
|
|
|
EAPI void
|
2009-02-25 07:54:26 -08:00
|
|
|
elm_genlist_item_show(Elm_Genlist_Item *it)
|
2009-02-10 03:57:47 -08:00
|
|
|
{
|
2010-11-02 04:27:07 -07:00
|
|
|
ELM_WIDGET_ITEM_WIDTYPE_CHECK_OR_RETURN(it);
|
2011-01-05 21:13:11 -08:00
|
|
|
Evas_Coord gith = 0;
|
2009-02-18 20:37:06 -08:00
|
|
|
if (it->delete_me) return;
|
2009-02-17 06:39:08 -08:00
|
|
|
if ((it->queued) || (!it->mincalcd))
|
|
|
|
{
|
2010-10-15 04:51:15 -07:00
|
|
|
it->wd->show_item = it;
|
2010-12-20 09:03:12 -08:00
|
|
|
it->wd->bring_in = EINA_TRUE;
|
2010-10-15 04:51:15 -07:00
|
|
|
it->showme = EINA_TRUE;
|
|
|
|
return;
|
2009-02-17 06:39:08 -08:00
|
|
|
}
|
|
|
|
if (it->wd->show_item)
|
|
|
|
{
|
2010-10-15 04:51:15 -07:00
|
|
|
it->wd->show_item->showme = EINA_FALSE;
|
|
|
|
it->wd->show_item = NULL;
|
2009-02-17 06:39:08 -08:00
|
|
|
}
|
2011-01-05 21:13:11 -08:00
|
|
|
if ((it->group_item) && (it->wd->pan_y > (it->y + it->block->y)))
|
2011-03-22 00:54:24 -07:00
|
|
|
gith = it->group_item->h;
|
2009-02-17 20:18:25 -08:00
|
|
|
elm_smart_scroller_child_region_show(it->wd->scr,
|
2010-10-15 04:51:15 -07:00
|
|
|
it->x + it->block->x,
|
2011-01-06 00:58:28 -08:00
|
|
|
it->y + it->block->y - gith,
|
2010-10-15 04:51:15 -07:00
|
|
|
it->block->w, it->h);
|
2009-02-10 03:57:47 -08:00
|
|
|
}
|
|
|
|
|
2009-09-10 02:25:11 -07:00
|
|
|
EAPI void
|
|
|
|
elm_genlist_item_bring_in(Elm_Genlist_Item *it)
|
|
|
|
{
|
2010-11-02 04:27:07 -07:00
|
|
|
ELM_WIDGET_ITEM_WIDTYPE_CHECK_OR_RETURN(it);
|
2011-03-18 07:29:48 -07:00
|
|
|
Evas_Coord gith = 0;
|
2009-09-10 02:25:11 -07:00
|
|
|
if (it->delete_me) return;
|
|
|
|
if ((it->queued) || (!it->mincalcd))
|
|
|
|
{
|
2010-10-15 04:51:15 -07:00
|
|
|
it->wd->show_item = it;
|
2010-12-20 09:03:12 -08:00
|
|
|
it->wd->bring_in = EINA_TRUE;
|
2010-10-15 04:51:15 -07:00
|
|
|
it->showme = EINA_TRUE;
|
|
|
|
return;
|
2009-09-10 02:25:11 -07:00
|
|
|
}
|
|
|
|
if (it->wd->show_item)
|
|
|
|
{
|
2010-10-15 04:51:15 -07:00
|
|
|
it->wd->show_item->showme = EINA_FALSE;
|
|
|
|
it->wd->show_item = NULL;
|
2009-09-10 02:25:11 -07:00
|
|
|
}
|
2011-01-05 21:13:11 -08:00
|
|
|
if ((it->group_item) && (it->wd->pan_y > (it->y + it->block->y)))
|
2011-03-22 00:54:24 -07:00
|
|
|
gith = it->group_item->h;
|
2009-09-10 02:25:11 -07:00
|
|
|
elm_smart_scroller_region_bring_in(it->wd->scr,
|
|
|
|
it->x + it->block->x,
|
2011-01-05 21:13:11 -08:00
|
|
|
it->y + it->block->y - gith,
|
2009-09-10 02:25:11 -07:00
|
|
|
it->block->w, it->h);
|
|
|
|
}
|
|
|
|
|
|
|
|
EAPI void
|
|
|
|
elm_genlist_item_top_show(Elm_Genlist_Item *it)
|
|
|
|
{
|
2010-11-02 04:27:07 -07:00
|
|
|
ELM_WIDGET_ITEM_WIDTYPE_CHECK_OR_RETURN(it);
|
2009-09-10 02:25:11 -07:00
|
|
|
Evas_Coord ow, oh;
|
2011-01-05 21:13:11 -08:00
|
|
|
Evas_Coord gith = 0;
|
2009-09-26 11:24:06 -07:00
|
|
|
|
2009-09-10 02:25:11 -07:00
|
|
|
if (it->delete_me) return;
|
|
|
|
if ((it->queued) || (!it->mincalcd))
|
|
|
|
{
|
2010-10-15 04:51:15 -07:00
|
|
|
it->wd->show_item = it;
|
2010-12-20 09:03:12 -08:00
|
|
|
it->wd->bring_in = EINA_TRUE;
|
2010-10-15 04:51:15 -07:00
|
|
|
it->showme = EINA_TRUE;
|
|
|
|
return;
|
2009-09-10 02:25:11 -07:00
|
|
|
}
|
|
|
|
if (it->wd->show_item)
|
|
|
|
{
|
2010-10-15 04:51:15 -07:00
|
|
|
it->wd->show_item->showme = EINA_FALSE;
|
|
|
|
it->wd->show_item = NULL;
|
2009-09-10 02:25:11 -07:00
|
|
|
}
|
|
|
|
evas_object_geometry_get(it->wd->pan_smart, NULL, NULL, &ow, &oh);
|
2011-01-05 21:13:11 -08:00
|
|
|
if (it->group_item) gith = it->group_item->h;
|
2009-09-10 02:25:11 -07:00
|
|
|
elm_smart_scroller_child_region_show(it->wd->scr,
|
2010-10-15 04:51:15 -07:00
|
|
|
it->x + it->block->x,
|
2011-01-05 21:13:11 -08:00
|
|
|
it->y + it->block->y - gith,
|
2010-10-15 04:51:15 -07:00
|
|
|
it->block->w, oh);
|
2009-09-10 02:25:11 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
EAPI void
|
|
|
|
elm_genlist_item_top_bring_in(Elm_Genlist_Item *it)
|
|
|
|
{
|
2010-11-02 04:27:07 -07:00
|
|
|
ELM_WIDGET_ITEM_WIDTYPE_CHECK_OR_RETURN(it);
|
2009-09-10 02:25:11 -07:00
|
|
|
Evas_Coord ow, oh;
|
2011-01-05 21:13:11 -08:00
|
|
|
Evas_Coord gith = 0;
|
2009-09-26 11:24:06 -07:00
|
|
|
|
2009-09-10 02:25:11 -07:00
|
|
|
if (it->delete_me) return;
|
|
|
|
if ((it->queued) || (!it->mincalcd))
|
|
|
|
{
|
2010-10-15 04:51:15 -07:00
|
|
|
it->wd->show_item = it;
|
2010-12-20 09:03:12 -08:00
|
|
|
it->wd->bring_in = EINA_TRUE;
|
2010-10-15 04:51:15 -07:00
|
|
|
it->showme = EINA_TRUE;
|
|
|
|
return;
|
2009-09-10 02:25:11 -07:00
|
|
|
}
|
|
|
|
if (it->wd->show_item)
|
|
|
|
{
|
2010-10-15 04:51:15 -07:00
|
|
|
it->wd->show_item->showme = EINA_FALSE;
|
|
|
|
it->wd->show_item = NULL;
|
2009-09-10 02:25:11 -07:00
|
|
|
}
|
|
|
|
evas_object_geometry_get(it->wd->pan_smart, NULL, NULL, &ow, &oh);
|
2011-01-05 21:13:11 -08:00
|
|
|
if (it->group_item) gith = it->group_item->h;
|
2009-09-10 02:25:11 -07:00
|
|
|
elm_smart_scroller_region_bring_in(it->wd->scr,
|
|
|
|
it->x + it->block->x,
|
2011-01-05 21:13:11 -08:00
|
|
|
it->y + it->block->y - gith,
|
2009-09-10 02:25:11 -07:00
|
|
|
it->block->w, oh);
|
|
|
|
}
|
|
|
|
|
2009-10-14 14:57:46 -07:00
|
|
|
EAPI void
|
|
|
|
elm_genlist_item_middle_show(Elm_Genlist_Item *it)
|
|
|
|
{
|
2010-11-02 04:27:07 -07:00
|
|
|
ELM_WIDGET_ITEM_WIDTYPE_CHECK_OR_RETURN(it);
|
2009-10-14 14:57:46 -07:00
|
|
|
Evas_Coord ow, oh;
|
|
|
|
|
|
|
|
if (it->delete_me) return;
|
|
|
|
if ((it->queued) || (!it->mincalcd))
|
|
|
|
{
|
2010-10-15 04:51:15 -07:00
|
|
|
it->wd->show_item = it;
|
2010-12-20 09:03:12 -08:00
|
|
|
it->wd->bring_in = EINA_TRUE;
|
2010-10-15 04:51:15 -07:00
|
|
|
it->showme = EINA_TRUE;
|
|
|
|
return;
|
2009-10-14 14:57:46 -07:00
|
|
|
}
|
|
|
|
if (it->wd->show_item)
|
|
|
|
{
|
2010-10-15 04:51:15 -07:00
|
|
|
it->wd->show_item->showme = EINA_FALSE;
|
|
|
|
it->wd->show_item = NULL;
|
2009-10-14 14:57:46 -07:00
|
|
|
}
|
|
|
|
evas_object_geometry_get(it->wd->pan_smart, NULL, NULL, &ow, &oh);
|
|
|
|
elm_smart_scroller_child_region_show(it->wd->scr,
|
2010-10-15 04:51:15 -07:00
|
|
|
it->x + it->block->x,
|
2010-12-07 11:18:14 -08:00
|
|
|
it->y + it->block->y - oh / 2 +
|
|
|
|
it->h / 2, it->block->w, oh);
|
2009-10-14 14:57:46 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
EAPI void
|
|
|
|
elm_genlist_item_middle_bring_in(Elm_Genlist_Item *it)
|
|
|
|
{
|
2010-11-02 04:27:07 -07:00
|
|
|
ELM_WIDGET_ITEM_WIDTYPE_CHECK_OR_RETURN(it);
|
2009-10-14 14:57:46 -07:00
|
|
|
Evas_Coord ow, oh;
|
|
|
|
|
|
|
|
if (it->delete_me) return;
|
|
|
|
if ((it->queued) || (!it->mincalcd))
|
|
|
|
{
|
2010-10-15 04:51:15 -07:00
|
|
|
it->wd->show_item = it;
|
2010-12-20 09:03:12 -08:00
|
|
|
it->wd->bring_in = EINA_TRUE;
|
2010-10-15 04:51:15 -07:00
|
|
|
it->showme = EINA_TRUE;
|
|
|
|
return;
|
2009-10-14 14:57:46 -07:00
|
|
|
}
|
|
|
|
if (it->wd->show_item)
|
|
|
|
{
|
2010-10-15 04:51:15 -07:00
|
|
|
it->wd->show_item->showme = EINA_FALSE;
|
|
|
|
it->wd->show_item = NULL;
|
2009-10-14 14:57:46 -07:00
|
|
|
}
|
|
|
|
evas_object_geometry_get(it->wd->pan_smart, NULL, NULL, &ow, &oh);
|
|
|
|
elm_smart_scroller_region_bring_in(it->wd->scr,
|
|
|
|
it->x + it->block->x,
|
2010-12-07 11:18:14 -08:00
|
|
|
it->y + it->block->y - oh / 2 + it->h / 2,
|
2009-10-14 14:57:46 -07:00
|
|
|
it->block->w, oh);
|
|
|
|
}
|
|
|
|
|
2009-02-10 03:57:47 -08:00
|
|
|
EAPI void
|
2009-02-25 07:54:26 -08:00
|
|
|
elm_genlist_item_del(Elm_Genlist_Item *it)
|
2009-02-10 03:57:47 -08:00
|
|
|
{
|
2010-11-02 04:27:07 -07:00
|
|
|
ELM_WIDGET_ITEM_WIDTYPE_CHECK_OR_RETURN(it);
|
2010-03-02 00:47:40 -08:00
|
|
|
if ((it->relcount > 0) || (it->walking > 0))
|
2009-02-18 20:37:06 -08:00
|
|
|
{
|
2010-09-09 19:05:45 -07:00
|
|
|
elm_widget_item_pre_notify_del(it);
|
2010-10-15 04:51:15 -07:00
|
|
|
elm_genlist_item_subitems_clear(it);
|
|
|
|
it->delete_me = EINA_TRUE;
|
|
|
|
if (it->wd->show_item == it) it->wd->show_item = NULL;
|
2010-12-07 11:18:14 -08:00
|
|
|
if (it->selected)
|
|
|
|
it->wd->selected = eina_list_remove(it->wd->selected,
|
|
|
|
it);
|
2010-10-15 04:51:15 -07:00
|
|
|
if (it->block)
|
|
|
|
{
|
2011-04-14 04:41:07 -07:00
|
|
|
if (it->realized) _item_unrealize(it, EINA_FALSE);
|
2010-10-15 04:51:15 -07:00
|
|
|
it->block->changed = EINA_TRUE;
|
|
|
|
if (it->wd->calc_job) ecore_job_del(it->wd->calc_job);
|
|
|
|
it->wd->calc_job = ecore_job_add(_calc_job, it->wd);
|
|
|
|
}
|
|
|
|
if (it->itc->func.del)
|
2010-12-07 11:18:14 -08:00
|
|
|
it->itc->func.del((void *)it->base.data, it->base.widget);
|
2010-10-15 04:51:15 -07:00
|
|
|
return;
|
2009-02-18 20:37:06 -08:00
|
|
|
}
|
2009-02-16 23:50:35 -08:00
|
|
|
_item_del(it);
|
2009-02-10 03:57:47 -08:00
|
|
|
}
|
|
|
|
|
2009-08-15 11:20:28 -07:00
|
|
|
EAPI void
|
2010-12-07 11:18:14 -08:00
|
|
|
elm_genlist_item_data_set(Elm_Genlist_Item *it,
|
|
|
|
const void *data)
|
2009-08-15 11:20:28 -07:00
|
|
|
{
|
2010-11-02 04:27:07 -07:00
|
|
|
ELM_WIDGET_ITEM_WIDTYPE_CHECK_OR_RETURN(it);
|
2010-09-09 19:05:45 -07:00
|
|
|
elm_widget_item_data_set(it, data);
|
2009-02-14 18:53:56 -08:00
|
|
|
}
|
|
|
|
|
2010-09-17 09:34:11 -07:00
|
|
|
EAPI void *
|
2010-04-06 07:01:04 -07:00
|
|
|
elm_genlist_item_data_get(const Elm_Genlist_Item *it)
|
|
|
|
{
|
2010-11-02 04:27:07 -07:00
|
|
|
ELM_WIDGET_ITEM_WIDTYPE_CHECK_OR_RETURN(it, NULL);
|
2010-09-09 19:05:45 -07:00
|
|
|
return elm_widget_item_data_get(it);
|
2010-04-06 07:01:04 -07:00
|
|
|
}
|
|
|
|
|
2010-11-06 00:05:00 -07:00
|
|
|
EAPI void
|
|
|
|
elm_genlist_item_icons_orphan(Elm_Genlist_Item *it)
|
|
|
|
{
|
|
|
|
Evas_Object *icon;
|
|
|
|
ELM_WIDGET_ITEM_WIDTYPE_CHECK_OR_RETURN(it);
|
|
|
|
EINA_LIST_FREE(it->icon_objs, icon)
|
|
|
|
{
|
|
|
|
elm_widget_sub_object_del(it->base.widget, icon);
|
|
|
|
evas_object_smart_member_del(icon);
|
|
|
|
evas_object_hide(icon);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2009-09-07 19:09:13 -07:00
|
|
|
EAPI const Evas_Object *
|
|
|
|
elm_genlist_item_object_get(const Elm_Genlist_Item *it)
|
|
|
|
{
|
2010-11-02 04:27:07 -07:00
|
|
|
ELM_WIDGET_ITEM_WIDTYPE_CHECK_OR_RETURN(it, NULL);
|
2010-09-09 19:05:45 -07:00
|
|
|
return it->base.view;
|
2009-09-07 19:09:13 -07:00
|
|
|
}
|
|
|
|
|
2009-02-14 18:53:56 -08:00
|
|
|
EAPI void
|
2009-02-25 07:54:26 -08:00
|
|
|
elm_genlist_item_update(Elm_Genlist_Item *it)
|
2009-02-14 18:53:56 -08:00
|
|
|
{
|
2010-11-02 04:27:07 -07:00
|
|
|
ELM_WIDGET_ITEM_WIDTYPE_CHECK_OR_RETURN(it);
|
2009-02-18 05:42:56 -08:00
|
|
|
if (!it->block) return;
|
2009-02-18 20:37:06 -08:00
|
|
|
if (it->delete_me) return;
|
2009-06-17 08:35:19 -07:00
|
|
|
it->mincalcd = EINA_FALSE;
|
2009-09-13 19:53:03 -07:00
|
|
|
it->updateme = EINA_TRUE;
|
|
|
|
it->block->updateme = EINA_TRUE;
|
|
|
|
if (it->wd->update_job) ecore_job_del(it->wd->update_job);
|
|
|
|
it->wd->update_job = ecore_job_add(_update_job, it->wd);
|
2009-03-12 22:50:38 -07:00
|
|
|
}
|
|
|
|
|
2010-11-17 09:15:28 -08:00
|
|
|
EAPI void
|
2010-12-07 11:18:14 -08:00
|
|
|
elm_genlist_item_item_class_update(Elm_Genlist_Item *it,
|
|
|
|
const Elm_Genlist_Item_Class *itc)
|
2010-11-17 09:15:28 -08:00
|
|
|
{
|
|
|
|
ELM_WIDGET_ITEM_WIDTYPE_CHECK_OR_RETURN(it);
|
|
|
|
if (!it->block) return;
|
2010-12-03 06:08:33 -08:00
|
|
|
EINA_SAFETY_ON_NULL_RETURN(itc);
|
2010-11-17 09:15:28 -08:00
|
|
|
if (it->delete_me) return;
|
|
|
|
it->itc = itc;
|
2011-01-31 02:33:22 -08:00
|
|
|
it->nocache = EINA_TRUE;
|
2010-11-17 09:15:28 -08:00
|
|
|
elm_genlist_item_update(it);
|
|
|
|
}
|
|
|
|
|
2011-06-25 16:20:22 -07:00
|
|
|
EAPI const Elm_Genlist_Item_Class *
|
|
|
|
elm_genlist_item_item_class_get(const Elm_Genlist_Item *it)
|
|
|
|
{
|
|
|
|
ELM_WIDGET_ITEM_WIDTYPE_CHECK_OR_RETURN(it, NULL);
|
|
|
|
if (it->delete_me) return NULL;
|
|
|
|
return it->itc;
|
|
|
|
}
|
|
|
|
|
2010-09-27 11:18:37 -07:00
|
|
|
static Evas_Object *
|
2010-12-07 11:18:14 -08:00
|
|
|
_elm_genlist_item_label_create(void *data,
|
2011-07-26 02:38:23 -07:00
|
|
|
Evas_Object *obj __UNUSED__,
|
|
|
|
Evas_Object *tooltip,
|
2011-04-01 09:33:58 -07:00
|
|
|
void *item __UNUSED__)
|
2010-09-27 11:18:37 -07:00
|
|
|
{
|
2011-07-26 02:38:23 -07:00
|
|
|
Evas_Object *label = elm_label_add(tooltip);
|
2010-09-27 11:18:37 -07:00
|
|
|
if (!label)
|
|
|
|
return NULL;
|
|
|
|
elm_object_style_set(label, "tooltip");
|
2011-06-28 23:41:31 -07:00
|
|
|
elm_object_text_set(label, data);
|
2010-09-27 11:18:37 -07:00
|
|
|
return label;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
2011-04-01 09:33:58 -07:00
|
|
|
_elm_genlist_item_label_del_cb(void *data,
|
2010-12-07 11:18:14 -08:00
|
|
|
Evas_Object *obj __UNUSED__,
|
2011-04-01 09:33:58 -07:00
|
|
|
void *event_info __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
|
2010-12-07 11:18:14 -08:00
|
|
|
elm_genlist_item_tooltip_text_set(Elm_Genlist_Item *item,
|
|
|
|
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
|
|
|
{
|
2010-11-02 04:27:07 -07:00
|
|
|
ELM_WIDGET_ITEM_WIDTYPE_CHECK_OR_RETURN(item);
|
2010-09-27 11:18:37 -07:00
|
|
|
text = eina_stringshare_add(text);
|
2010-12-07 11:18:14 -08:00
|
|
|
elm_genlist_item_tooltip_content_cb_set(item, _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
|
2010-12-07 11:18:14 -08:00
|
|
|
elm_genlist_item_tooltip_content_cb_set(Elm_Genlist_Item *item,
|
|
|
|
Elm_Tooltip_Item_Content_Cb func,
|
|
|
|
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
|
|
|
{
|
2010-11-02 04:27:07 -07:00
|
|
|
ELM_WIDGET_ITEM_WIDTYPE_CHECK_OR_GOTO(item, error);
|
2010-09-27 11:18:37 -07:00
|
|
|
|
|
|
|
if ((item->tooltip.content_cb == func) && (item->tooltip.data == data))
|
|
|
|
return;
|
|
|
|
|
|
|
|
if (item->tooltip.del_cb)
|
2010-12-07 11:18:14 -08:00
|
|
|
item->tooltip.del_cb((void *)item->tooltip.data,
|
|
|
|
item->base.widget, item);
|
2010-09-27 11:18:37 -07:00
|
|
|
|
|
|
|
item->tooltip.content_cb = func;
|
|
|
|
item->tooltip.data = data;
|
|
|
|
item->tooltip.del_cb = del_cb;
|
|
|
|
|
|
|
|
if (item->base.view)
|
|
|
|
{
|
2010-10-15 04:51:15 -07:00
|
|
|
elm_widget_item_tooltip_content_cb_set(item,
|
|
|
|
item->tooltip.content_cb,
|
|
|
|
item->tooltip.data, NULL);
|
|
|
|
elm_widget_item_tooltip_style_set(item, item->tooltip.style);
|
2011-07-27 19:22:37 -07:00
|
|
|
elm_widget_item_tooltip_size_restrict_disable(item, item->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
|
|
|
|
elm_genlist_item_tooltip_unset(Elm_Genlist_Item *item)
|
|
|
|
{
|
2010-11-02 04:27:07 -07:00
|
|
|
ELM_WIDGET_ITEM_WIDTYPE_CHECK_OR_RETURN(item);
|
2010-10-22 14:41:22 -07:00
|
|
|
if ((item->base.view) && (item->tooltip.content_cb))
|
2010-09-27 11:18:37 -07:00
|
|
|
elm_widget_item_tooltip_unset(item);
|
|
|
|
|
|
|
|
if (item->tooltip.del_cb)
|
|
|
|
item->tooltip.del_cb((void *)item->tooltip.data, item->base.widget, item);
|
|
|
|
item->tooltip.del_cb = NULL;
|
|
|
|
item->tooltip.content_cb = NULL;
|
|
|
|
item->tooltip.data = NULL;
|
2011-07-27 19:22:37 -07:00
|
|
|
item->tooltip.free_size = EINA_FALSE;
|
2010-09-27 11:18:37 -07:00
|
|
|
if (item->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
|
2010-12-07 11:18:14 -08:00
|
|
|
elm_genlist_item_tooltip_style_set(Elm_Genlist_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
|
|
|
{
|
2010-11-02 04:27:07 -07:00
|
|
|
ELM_WIDGET_ITEM_WIDTYPE_CHECK_OR_RETURN(item);
|
2010-09-27 11:18:37 -07:00
|
|
|
eina_stringshare_replace(&item->tooltip.style, style);
|
|
|
|
if (item->base.view) elm_widget_item_tooltip_style_set(item, 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 *
|
|
|
|
elm_genlist_item_tooltip_style_get(const Elm_Genlist_Item *item)
|
|
|
|
{
|
2010-11-02 04:27:07 -07:00
|
|
|
ELM_WIDGET_ITEM_WIDTYPE_CHECK_OR_RETURN(item, NULL);
|
2010-09-27 11:18:37 -07:00
|
|
|
return item->tooltip.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
|
|
|
}
|
|
|
|
|
2011-07-26 02:38:23 -07:00
|
|
|
EAPI Eina_Bool
|
|
|
|
elm_genlist_item_tooltip_size_restrict_disable(Elm_Genlist_Item *item, Eina_Bool disable)
|
|
|
|
{
|
|
|
|
ELM_WIDGET_ITEM_WIDTYPE_CHECK_OR_RETURN(item, EINA_FALSE);
|
2011-07-27 19:22:37 -07:00
|
|
|
item->tooltip.free_size = disable;
|
|
|
|
if (item->base.view) return elm_widget_item_tooltip_size_restrict_disable(item, disable);
|
|
|
|
return EINA_TRUE;
|
2011-07-26 02:38:23 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
EAPI Eina_Bool
|
|
|
|
elm_genlist_item_tooltip_size_restrict_disabled_get(const Elm_Genlist_Item *item)
|
|
|
|
{
|
|
|
|
ELM_WIDGET_ITEM_WIDTYPE_CHECK_OR_RETURN(item, EINA_FALSE);
|
2011-07-27 19:22:37 -07:00
|
|
|
return item->tooltip.free_size;
|
2011-07-26 02:38:23 -07:00
|
|
|
}
|
|
|
|
|
2010-09-17 11:24:10 -07:00
|
|
|
EAPI void
|
2010-12-07 11:18:14 -08:00
|
|
|
elm_genlist_item_cursor_set(Elm_Genlist_Item *item,
|
|
|
|
const char *cursor)
|
2010-09-17 11:24:10 -07:00
|
|
|
{
|
2010-11-02 04:27:07 -07:00
|
|
|
ELM_WIDGET_ITEM_WIDTYPE_CHECK_OR_RETURN(item);
|
2010-09-27 11:18:37 -07:00
|
|
|
eina_stringshare_replace(&item->mouse_cursor, cursor);
|
|
|
|
if (item->base.view) elm_widget_item_cursor_set(item, cursor);
|
2010-09-17 11:24:10 -07:00
|
|
|
}
|
|
|
|
|
2010-11-04 17:46:54 -07:00
|
|
|
EAPI const char *
|
|
|
|
elm_genlist_item_cursor_get(const Elm_Genlist_Item *item)
|
|
|
|
{
|
|
|
|
ELM_WIDGET_ITEM_WIDTYPE_CHECK_OR_RETURN(item, NULL);
|
|
|
|
return elm_widget_item_cursor_get(item);
|
|
|
|
}
|
|
|
|
|
2010-09-17 11:24:10 -07:00
|
|
|
EAPI void
|
|
|
|
elm_genlist_item_cursor_unset(Elm_Genlist_Item *item)
|
|
|
|
{
|
2010-11-02 04:27:07 -07:00
|
|
|
ELM_WIDGET_ITEM_WIDTYPE_CHECK_OR_RETURN(item);
|
2010-09-27 11:18:37 -07:00
|
|
|
if (!item->mouse_cursor)
|
|
|
|
return;
|
|
|
|
|
|
|
|
if (item->base.view)
|
|
|
|
elm_widget_item_cursor_unset(item);
|
|
|
|
|
|
|
|
eina_stringshare_del(item->mouse_cursor);
|
|
|
|
item->mouse_cursor = NULL;
|
2010-09-17 11:24:10 -07:00
|
|
|
}
|
|
|
|
|
2010-09-25 15:01:19 -07:00
|
|
|
EAPI void
|
2010-12-07 11:18:14 -08:00
|
|
|
elm_genlist_item_cursor_style_set(Elm_Genlist_Item *item,
|
|
|
|
const char *style)
|
2010-09-25 15:01:19 -07:00
|
|
|
{
|
2010-11-02 04:27:07 -07:00
|
|
|
ELM_WIDGET_ITEM_WIDTYPE_CHECK_OR_RETURN(item);
|
2010-09-25 15:01:19 -07:00
|
|
|
elm_widget_item_cursor_style_set(item, style);
|
|
|
|
}
|
|
|
|
|
|
|
|
EAPI const char *
|
|
|
|
elm_genlist_item_cursor_style_get(const Elm_Genlist_Item *item)
|
|
|
|
{
|
2010-11-02 04:27:07 -07:00
|
|
|
ELM_WIDGET_ITEM_WIDTYPE_CHECK_OR_RETURN(item, NULL);
|
2010-09-25 15:01:19 -07:00
|
|
|
return elm_widget_item_cursor_style_get(item);
|
|
|
|
}
|
|
|
|
|
2010-09-25 15:03:37 -07:00
|
|
|
EAPI void
|
2010-12-07 11:18:14 -08:00
|
|
|
elm_genlist_item_cursor_engine_only_set(Elm_Genlist_Item *item,
|
|
|
|
Eina_Bool engine_only)
|
2010-09-25 15:03:37 -07:00
|
|
|
{
|
2010-11-02 04:27:07 -07:00
|
|
|
ELM_WIDGET_ITEM_WIDTYPE_CHECK_OR_RETURN(item);
|
2010-09-25 15:03:37 -07:00
|
|
|
elm_widget_item_cursor_engine_only_set(item, engine_only);
|
|
|
|
}
|
|
|
|
|
|
|
|
EAPI Eina_Bool
|
|
|
|
elm_genlist_item_cursor_engine_only_get(const Elm_Genlist_Item *item)
|
|
|
|
{
|
2010-11-02 04:27:07 -07:00
|
|
|
ELM_WIDGET_ITEM_WIDTYPE_CHECK_OR_RETURN(item, EINA_FALSE);
|
2010-09-25 15:03:37 -07:00
|
|
|
return elm_widget_item_cursor_engine_only_get(item);
|
|
|
|
}
|
|
|
|
|
2009-03-12 22:50:38 -07:00
|
|
|
EAPI void
|
2011-08-04 18:21:56 -07:00
|
|
|
elm_genlist_horizontal_set(Evas_Object *obj,
|
2010-12-07 11:18:14 -08:00
|
|
|
Elm_List_Mode mode)
|
2009-03-12 22:50:38 -07:00
|
|
|
{
|
2010-03-08 22:15:39 -08:00
|
|
|
ELM_CHECK_WIDTYPE(obj, widtype);
|
2009-03-12 22:50:38 -07:00
|
|
|
Widget_Data *wd = elm_widget_data_get(obj);
|
2010-03-09 06:42:41 -08:00
|
|
|
if (!wd) return;
|
2009-03-12 22:50:38 -07:00
|
|
|
if (wd->mode == mode) return;
|
|
|
|
wd->mode = mode;
|
2010-05-07 06:21:45 -07:00
|
|
|
_sizing_eval(obj);
|
2009-02-14 18:53:56 -08:00
|
|
|
}
|
2009-04-23 01:51:07 -07:00
|
|
|
|
2011-08-04 18:21:56 -07:00
|
|
|
EAPI void
|
|
|
|
elm_genlist_horizontal_mode_set(Evas_Object *obj,
|
|
|
|
Elm_List_Mode mode)
|
|
|
|
{
|
|
|
|
elm_genlist_horizontal_set(obj, mode);
|
|
|
|
}
|
|
|
|
|
2010-04-06 07:01:04 -07:00
|
|
|
EAPI Elm_List_Mode
|
2011-08-04 18:21:56 -07:00
|
|
|
elm_genlist_horizontal_get(const Evas_Object *obj)
|
2010-04-06 07:01:04 -07:00
|
|
|
{
|
2010-04-07 14:30:54 -07:00
|
|
|
ELM_CHECK_WIDTYPE(obj, widtype) ELM_LIST_LAST;
|
2010-04-06 07:01:04 -07:00
|
|
|
Widget_Data *wd = elm_widget_data_get(obj);
|
2010-04-07 14:30:54 -07:00
|
|
|
if (!wd) return ELM_LIST_LAST;
|
2010-04-06 07:01:04 -07:00
|
|
|
return wd->mode;
|
|
|
|
}
|
|
|
|
|
2011-08-04 18:21:56 -07:00
|
|
|
EAPI Elm_List_Mode
|
|
|
|
elm_genlist_horizontal_mode_get(const Evas_Object *obj)
|
|
|
|
{
|
|
|
|
return elm_genlist_horizontal_get(obj);
|
|
|
|
}
|
|
|
|
|
2009-04-23 01:51:07 -07:00
|
|
|
EAPI void
|
2010-12-07 11:18:14 -08:00
|
|
|
elm_genlist_always_select_mode_set(Evas_Object *obj,
|
|
|
|
Eina_Bool always_select)
|
2009-04-23 01:51:07 -07:00
|
|
|
{
|
2010-03-08 22:15:39 -08:00
|
|
|
ELM_CHECK_WIDTYPE(obj, widtype);
|
2009-04-23 01:51:07 -07:00
|
|
|
Widget_Data *wd = elm_widget_data_get(obj);
|
2010-03-09 06:42:41 -08:00
|
|
|
if (!wd) return;
|
2009-04-23 01:51:07 -07:00
|
|
|
wd->always_select = always_select;
|
|
|
|
}
|
|
|
|
|
2010-04-06 07:01:04 -07:00
|
|
|
EAPI Eina_Bool
|
|
|
|
elm_genlist_always_select_mode_get(const Evas_Object *obj)
|
|
|
|
{
|
|
|
|
ELM_CHECK_WIDTYPE(obj, widtype) EINA_FALSE;
|
|
|
|
Widget_Data *wd = elm_widget_data_get(obj);
|
|
|
|
if (!wd) return EINA_FALSE;
|
|
|
|
return wd->always_select;
|
|
|
|
}
|
|
|
|
|
2009-04-23 01:51:07 -07:00
|
|
|
EAPI void
|
2010-12-07 11:18:14 -08:00
|
|
|
elm_genlist_no_select_mode_set(Evas_Object *obj,
|
|
|
|
Eina_Bool no_select)
|
2009-04-23 01:51:07 -07:00
|
|
|
{
|
2010-03-08 22:15:39 -08:00
|
|
|
ELM_CHECK_WIDTYPE(obj, widtype);
|
2009-04-23 01:51:07 -07:00
|
|
|
Widget_Data *wd = elm_widget_data_get(obj);
|
2010-03-09 06:42:41 -08:00
|
|
|
if (!wd) return;
|
2009-04-23 01:51:07 -07:00
|
|
|
wd->no_select = no_select;
|
|
|
|
}
|
2009-11-17 19:09:04 -08:00
|
|
|
|
2010-04-06 07:01:04 -07:00
|
|
|
EAPI Eina_Bool
|
|
|
|
elm_genlist_no_select_mode_get(const Evas_Object *obj)
|
|
|
|
{
|
|
|
|
ELM_CHECK_WIDTYPE(obj, widtype) EINA_FALSE;
|
|
|
|
Widget_Data *wd = elm_widget_data_get(obj);
|
|
|
|
if (!wd) return EINA_FALSE;
|
|
|
|
return wd->no_select;
|
|
|
|
}
|
|
|
|
|
2009-11-17 19:09:04 -08:00
|
|
|
EAPI void
|
2010-12-07 11:18:14 -08:00
|
|
|
elm_genlist_compress_mode_set(Evas_Object *obj,
|
|
|
|
Eina_Bool compress)
|
2009-11-17 19:09:04 -08:00
|
|
|
{
|
2010-03-08 22:15:39 -08:00
|
|
|
ELM_CHECK_WIDTYPE(obj, widtype);
|
2009-11-17 19:09:04 -08:00
|
|
|
Widget_Data *wd = elm_widget_data_get(obj);
|
2010-03-09 06:42:41 -08:00
|
|
|
if (!wd) return;
|
2009-11-17 19:09:04 -08:00
|
|
|
wd->compress = compress;
|
2011-05-12 23:10:13 -07:00
|
|
|
if (!compress) elm_genlist_homogeneous_set(obj, EINA_FALSE);
|
2009-11-17 19:09:04 -08:00
|
|
|
}
|
2009-12-11 00:12:58 -08:00
|
|
|
|
2010-04-06 07:01:04 -07:00
|
|
|
EAPI Eina_Bool
|
|
|
|
elm_genlist_compress_mode_get(const Evas_Object *obj)
|
|
|
|
{
|
|
|
|
ELM_CHECK_WIDTYPE(obj, widtype) EINA_FALSE;
|
|
|
|
Widget_Data *wd = elm_widget_data_get(obj);
|
|
|
|
if (!wd) return EINA_FALSE;
|
|
|
|
return wd->compress;
|
|
|
|
}
|
|
|
|
|
2010-10-07 12:57:20 -07:00
|
|
|
EAPI void
|
2010-12-07 11:18:14 -08:00
|
|
|
elm_genlist_height_for_width_mode_set(Evas_Object *obj,
|
|
|
|
Eina_Bool height_for_width)
|
2010-10-07 12:57:20 -07:00
|
|
|
{
|
|
|
|
ELM_CHECK_WIDTYPE(obj, widtype);
|
|
|
|
Widget_Data *wd = elm_widget_data_get(obj);
|
|
|
|
if (!wd) return;
|
|
|
|
wd->height_for_width = !!height_for_width;
|
|
|
|
if (wd->height_for_width)
|
|
|
|
{
|
|
|
|
elm_genlist_homogeneous_set(obj, EINA_FALSE);
|
|
|
|
elm_genlist_compress_mode_set(obj, EINA_TRUE);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
EAPI Eina_Bool
|
|
|
|
elm_genlist_height_for_width_mode_get(const Evas_Object *obj)
|
|
|
|
{
|
|
|
|
ELM_CHECK_WIDTYPE(obj, widtype) EINA_FALSE;
|
|
|
|
Widget_Data *wd = elm_widget_data_get(obj);
|
|
|
|
if (!wd) return EINA_FALSE;
|
|
|
|
return wd->height_for_width;
|
|
|
|
}
|
|
|
|
|
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,
|
|
|
|
Eina_Bool h_bounce,
|
|
|
|
Eina_Bool v_bounce)
|
2009-12-11 00:12:58 -08:00
|
|
|
{
|
2010-03-08 22:15:39 -08:00
|
|
|
ELM_CHECK_WIDTYPE(obj, widtype);
|
2009-12-11 00:12:58 -08:00
|
|
|
Widget_Data *wd = elm_widget_data_get(obj);
|
2010-03-09 06:42:41 -08:00
|
|
|
if (!wd) return;
|
2009-12-11 00:12:58 -08:00
|
|
|
elm_smart_scroller_bounce_allow_set(wd->scr, h_bounce, v_bounce);
|
|
|
|
}
|
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,
|
|
|
|
Eina_Bool *h_bounce,
|
|
|
|
Eina_Bool *v_bounce)
|
2010-04-06 07:01:04 -07:00
|
|
|
{
|
|
|
|
ELM_CHECK_WIDTYPE(obj, widtype);
|
|
|
|
Widget_Data *wd = elm_widget_data_get(obj);
|
|
|
|
if (!wd) return;
|
2011-07-22 10:15:33 -07:00
|
|
|
elm_smart_scroller_bounce_allow_get(wd->scr, h_bounce, 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,
|
|
|
|
Eina_Bool homogeneous)
|
2010-01-23 01:07:20 -08:00
|
|
|
{
|
2010-03-08 22:15:39 -08:00
|
|
|
ELM_CHECK_WIDTYPE(obj, widtype);
|
2010-01-23 01:07:20 -08:00
|
|
|
Widget_Data *wd = elm_widget_data_get(obj);
|
2010-03-09 06:42:41 -08:00
|
|
|
if (!wd) return;
|
2010-04-06 07:01:04 -07:00
|
|
|
if (homogeneous) elm_genlist_compress_mode_set(obj, EINA_TRUE);
|
2010-01-23 01:07:20 -08:00
|
|
|
wd->homogeneous = homogeneous;
|
|
|
|
}
|
|
|
|
|
2010-04-06 07:01:04 -07:00
|
|
|
EAPI Eina_Bool
|
|
|
|
elm_genlist_homogeneous_get(const Evas_Object *obj)
|
|
|
|
{
|
|
|
|
ELM_CHECK_WIDTYPE(obj, widtype) EINA_FALSE;
|
|
|
|
Widget_Data *wd = elm_widget_data_get(obj);
|
|
|
|
if (!wd) return EINA_FALSE;
|
|
|
|
return wd->homogeneous;
|
|
|
|
}
|
|
|
|
|
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,
|
|
|
|
int n)
|
2010-01-23 01:07:20 -08:00
|
|
|
{
|
2010-03-08 22:15:39 -08:00
|
|
|
ELM_CHECK_WIDTYPE(obj, widtype);
|
2010-01-23 01:07:20 -08:00
|
|
|
Widget_Data *wd = elm_widget_data_get(obj);
|
2010-03-09 06:42:41 -08:00
|
|
|
if (!wd) return;
|
2010-01-23 01:07:20 -08:00
|
|
|
wd->max_items_per_block = n;
|
2010-11-05 23:02:22 -07:00
|
|
|
wd->item_cache_max = wd->max_items_per_block * 2;
|
|
|
|
_item_cache_clean(wd);
|
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)
|
|
|
|
{
|
|
|
|
ELM_CHECK_WIDTYPE(obj, widtype) 0;
|
|
|
|
Widget_Data *wd = elm_widget_data_get(obj);
|
|
|
|
if (!wd) return 0;
|
|
|
|
return wd->max_items_per_block;
|
|
|
|
}
|
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,
|
|
|
|
double timeout)
|
2010-07-27 16:36:27 -07:00
|
|
|
{
|
2010-07-27 20:29:48 -07:00
|
|
|
ELM_CHECK_WIDTYPE(obj, widtype);
|
2010-07-27 16:36:27 -07:00
|
|
|
Widget_Data *wd = elm_widget_data_get(obj);
|
2010-07-27 20:29:48 -07:00
|
|
|
if (!wd) return;
|
2010-07-27 16:36:27 -07:00
|
|
|
wd->longpress_timeout = timeout;
|
|
|
|
}
|
|
|
|
|
|
|
|
EAPI double
|
|
|
|
elm_genlist_longpress_timeout_get(const Evas_Object *obj)
|
|
|
|
{
|
|
|
|
ELM_CHECK_WIDTYPE(obj, widtype) 0;
|
|
|
|
Widget_Data *wd = elm_widget_data_get(obj);
|
|
|
|
if (!wd) return 0;
|
|
|
|
return wd->longpress_timeout;
|
|
|
|
}
|
2010-11-22 07:24:58 -08:00
|
|
|
|
|
|
|
EAPI void
|
2010-12-07 11:18:14 -08:00
|
|
|
elm_genlist_scroller_policy_set(Evas_Object *obj,
|
|
|
|
Elm_Scroller_Policy policy_h,
|
|
|
|
Elm_Scroller_Policy policy_v)
|
2010-11-22 07:24:58 -08:00
|
|
|
{
|
|
|
|
ELM_CHECK_WIDTYPE(obj, widtype);
|
|
|
|
Widget_Data *wd = elm_widget_data_get(obj);
|
|
|
|
if (!wd) return;
|
|
|
|
if ((policy_h >= ELM_SCROLLER_POLICY_LAST) ||
|
|
|
|
(policy_v >= ELM_SCROLLER_POLICY_LAST))
|
|
|
|
return;
|
|
|
|
if (wd->scr)
|
|
|
|
elm_smart_scroller_policy_set(wd->scr, policy_h, policy_v);
|
|
|
|
}
|
|
|
|
|
|
|
|
EAPI void
|
2010-12-07 11:18:14 -08:00
|
|
|
elm_genlist_scroller_policy_get(const Evas_Object *obj,
|
|
|
|
Elm_Scroller_Policy *policy_h,
|
|
|
|
Elm_Scroller_Policy *policy_v)
|
2010-11-22 07:24:58 -08:00
|
|
|
{
|
|
|
|
ELM_CHECK_WIDTYPE(obj, widtype);
|
|
|
|
Widget_Data *wd = elm_widget_data_get(obj);
|
|
|
|
Elm_Smart_Scroller_Policy s_policy_h, s_policy_v;
|
|
|
|
if ((!wd) || (!wd->scr)) return;
|
|
|
|
elm_smart_scroller_policy_get(wd->scr, &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)
|
2011-04-06 21:35:08 -07:00
|
|
|
{
|
|
|
|
ELM_CHECK_WIDTYPE(obj, widtype);
|
|
|
|
|
|
|
|
Eina_List *list, *l;
|
|
|
|
Elm_Genlist_Item *it;
|
|
|
|
|
|
|
|
list = elm_genlist_realized_items_get(obj);
|
|
|
|
EINA_LIST_FOREACH(list, l, it)
|
|
|
|
elm_genlist_item_update(it);
|
|
|
|
}
|
2011-04-21 04:47:36 -07:00
|
|
|
|
|
|
|
EAPI void
|
|
|
|
elm_genlist_item_mode_set(Elm_Genlist_Item *it,
|
|
|
|
const char *mode_type,
|
|
|
|
Eina_Bool mode_set)
|
|
|
|
{
|
|
|
|
ELM_WIDGET_ITEM_WIDTYPE_CHECK_OR_RETURN(it);
|
|
|
|
Widget_Data *wd = it->wd;
|
|
|
|
Eina_List *l;
|
|
|
|
Elm_Genlist_Item *it2;
|
|
|
|
|
|
|
|
if (!wd) return;
|
|
|
|
if (!mode_type) return;
|
2011-05-05 19:59:49 -07:00
|
|
|
if ((it->delete_me) || (it->disabled)) return;
|
2011-04-21 04:47:36 -07:00
|
|
|
|
|
|
|
if ((wd->mode_item == it) &&
|
|
|
|
(!strcmp(mode_type, wd->mode_type)) &&
|
|
|
|
(mode_set))
|
|
|
|
return;
|
|
|
|
if (!it->itc->mode_item_style) return;
|
|
|
|
|
|
|
|
if (wd->multi)
|
|
|
|
{
|
|
|
|
EINA_LIST_FOREACH(wd->selected, l, it2)
|
|
|
|
if (it2->realized)
|
|
|
|
elm_genlist_item_selected_set(it2, EINA_FALSE);
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
it2 = elm_genlist_selected_item_get(wd->obj);
|
|
|
|
if ((it2) && (it2->realized))
|
|
|
|
elm_genlist_item_selected_set(it2, EINA_FALSE);
|
|
|
|
}
|
|
|
|
|
|
|
|
if (((wd->mode_type) && (strcmp(mode_type, wd->mode_type))) ||
|
|
|
|
(mode_set) ||
|
|
|
|
((it == wd->mode_item) && (!mode_set)))
|
|
|
|
_item_mode_unset(wd);
|
|
|
|
|
|
|
|
eina_stringshare_replace(&wd->mode_type, mode_type);
|
|
|
|
if (mode_set) _item_mode_set(it);
|
|
|
|
}
|
|
|
|
|
|
|
|
EAPI const char *
|
|
|
|
elm_genlist_mode_get(const Evas_Object *obj)
|
|
|
|
{
|
|
|
|
ELM_CHECK_WIDTYPE(obj, widtype) NULL;
|
|
|
|
Widget_Data *wd = elm_widget_data_get(obj);
|
|
|
|
if (!wd) return NULL;
|
|
|
|
return wd->mode_type;
|
|
|
|
}
|
|
|
|
|
|
|
|
EAPI const Elm_Genlist_Item *
|
|
|
|
elm_genlist_mode_item_get(const Evas_Object *obj)
|
|
|
|
{
|
|
|
|
ELM_CHECK_WIDTYPE(obj, widtype) NULL;
|
|
|
|
Widget_Data *wd = elm_widget_data_get(obj);
|
|
|
|
if (!wd) return NULL;
|
|
|
|
return wd->mode_item;
|
|
|
|
}
|
2011-06-01 20:10:11 -07:00
|
|
|
|
|
|
|
EAPI void
|
|
|
|
elm_genlist_reorder_mode_set(Evas_Object *obj,
|
|
|
|
Eina_Bool reorder_mode)
|
|
|
|
{
|
|
|
|
ELM_CHECK_WIDTYPE(obj, widtype);
|
|
|
|
Widget_Data *wd = elm_widget_data_get(obj);
|
|
|
|
if (!wd) return;
|
|
|
|
wd->reorder_mode = reorder_mode;
|
|
|
|
}
|
|
|
|
|
|
|
|
EAPI Eina_Bool
|
|
|
|
elm_genlist_reorder_mode_get(const Evas_Object *obj)
|
|
|
|
{
|
|
|
|
ELM_CHECK_WIDTYPE(obj, widtype) EINA_FALSE;
|
|
|
|
Widget_Data *wd = elm_widget_data_get(obj);
|
|
|
|
if (!wd) return EINA_FALSE;
|
|
|
|
return wd->reorder_mode;
|
|
|
|
}
|