2008-12-18 05:38:58 -08:00
|
|
|
#include <Elementary.h>
|
|
|
|
#include "elm_priv.h"
|
|
|
|
|
2010-04-12 01:12:02 -07:00
|
|
|
/**
|
|
|
|
* @defgroup Toolbar Toolbar
|
|
|
|
*
|
|
|
|
* A toolbar is a widget that displays a list of buttons inside
|
|
|
|
* a box. It is scrollable, and only one item can be selected at a time.
|
|
|
|
*/
|
|
|
|
|
2008-12-18 05:38:58 -08:00
|
|
|
typedef struct _Widget_Data Widget_Data;
|
|
|
|
|
|
|
|
struct _Widget_Data
|
|
|
|
{
|
|
|
|
Evas_Object *scr, *bx;
|
[Elementary] Implement priority in Elm_Toolbar.
Toolbars can now be scrollable, non-scrollable, or hide icons selectively
according to a priority. This changed the API slightly, thus
elm_toolbar_scrollable_set(obj, 1)
Should be
elm_toolbar_mode_expand_set(obj, ELM_TOOLBAR_EXPAND_SCROLL)
Values for non-scrollable and scrollable remain the same, so if constants
aren't being used, just the function name should be changed.
The new mode, ELM_TOOLBAR_EXPAND_MENU, will create a menu of items when the
space isn't large enough to hold all the items. Which items will be kept on
the toolbar or which items will be added to the menu is controlled by the
priority of each item: higher ones will be kept if possible, lower ones will
be tratored on the first opportunity.
SVN revision: 53406
2010-10-14 08:27:25 -07:00
|
|
|
Evas_Object *menu_parent;
|
2008-12-18 05:38:58 -08:00
|
|
|
Eina_List *items;
|
[Elementary] Implement priority in Elm_Toolbar.
Toolbars can now be scrollable, non-scrollable, or hide icons selectively
according to a priority. This changed the API slightly, thus
elm_toolbar_scrollable_set(obj, 1)
Should be
elm_toolbar_mode_expand_set(obj, ELM_TOOLBAR_EXPAND_SCROLL)
Values for non-scrollable and scrollable remain the same, so if constants
aren't being used, just the function name should be changed.
The new mode, ELM_TOOLBAR_EXPAND_MENU, will create a menu of items when the
space isn't large enough to hold all the items. Which items will be kept on
the toolbar or which items will be added to the menu is controlled by the
priority of each item: higher ones will be kept if possible, lower ones will
be tratored on the first opportunity.
SVN revision: 53406
2010-10-14 08:27:25 -07:00
|
|
|
Elm_Toolbar_Item *more_item;
|
|
|
|
Elm_Toolbar_Shrink_Mode shrink_mode;
|
2008-12-18 05:38:58 -08:00
|
|
|
int icon_size;
|
2009-10-06 13:14:46 -07:00
|
|
|
double align;
|
[Elementary] Implement priority in Elm_Toolbar.
Toolbars can now be scrollable, non-scrollable, or hide icons selectively
according to a priority. This changed the API slightly, thus
elm_toolbar_scrollable_set(obj, 1)
Should be
elm_toolbar_mode_expand_set(obj, ELM_TOOLBAR_EXPAND_SCROLL)
Values for non-scrollable and scrollable remain the same, so if constants
aren't being used, just the function name should be changed.
The new mode, ELM_TOOLBAR_EXPAND_MENU, will create a menu of items when the
space isn't large enough to hold all the items. Which items will be kept on
the toolbar or which items will be added to the menu is controlled by the
priority of each item: higher ones will be kept if possible, lower ones will
be tratored on the first opportunity.
SVN revision: 53406
2010-10-14 08:27:25 -07:00
|
|
|
Eina_Bool homogeneous : 1;
|
2008-12-18 05:38:58 -08:00
|
|
|
};
|
|
|
|
|
2009-02-25 07:54:26 -08:00
|
|
|
struct _Elm_Toolbar_Item
|
2008-12-18 05:38:58 -08:00
|
|
|
{
|
2010-09-09 19:05:45 -07:00
|
|
|
Elm_Widget_Item base;
|
2008-12-18 05:38:58 -08:00
|
|
|
const char *label;
|
2010-10-14 08:27:31 -07:00
|
|
|
const char *icon_str;
|
2008-12-18 05:38:58 -08:00
|
|
|
Evas_Object *icon;
|
[Elementary] Implement priority in Elm_Toolbar.
Toolbars can now be scrollable, non-scrollable, or hide icons selectively
according to a priority. This changed the API slightly, thus
elm_toolbar_scrollable_set(obj, 1)
Should be
elm_toolbar_mode_expand_set(obj, ELM_TOOLBAR_EXPAND_SCROLL)
Values for non-scrollable and scrollable remain the same, so if constants
aren't being used, just the function name should be changed.
The new mode, ELM_TOOLBAR_EXPAND_MENU, will create a menu of items when the
space isn't large enough to hold all the items. Which items will be kept on
the toolbar or which items will be added to the menu is controlled by the
priority of each item: higher ones will be kept if possible, lower ones will
be tratored on the first opportunity.
SVN revision: 53406
2010-10-14 08:27:25 -07:00
|
|
|
Evas_Object *o_menu;
|
2010-03-16 08:31:38 -07:00
|
|
|
Evas_Smart_Cb func;
|
[Elementary] Implement priority in Elm_Toolbar.
Toolbars can now be scrollable, non-scrollable, or hide icons selectively
according to a priority. This changed the API slightly, thus
elm_toolbar_scrollable_set(obj, 1)
Should be
elm_toolbar_mode_expand_set(obj, ELM_TOOLBAR_EXPAND_SCROLL)
Values for non-scrollable and scrollable remain the same, so if constants
aren't being used, just the function name should be changed.
The new mode, ELM_TOOLBAR_EXPAND_MENU, will create a menu of items when the
space isn't large enough to hold all the items. Which items will be kept on
the toolbar or which items will be added to the menu is controlled by the
priority of each item: higher ones will be kept if possible, lower ones will
be tratored on the first opportunity.
SVN revision: 53406
2010-10-14 08:27:25 -07:00
|
|
|
struct {
|
|
|
|
int priority;
|
|
|
|
Eina_Bool visible : 1;
|
|
|
|
} prio;
|
2009-06-17 08:35:19 -07:00
|
|
|
Eina_Bool selected : 1;
|
2009-08-25 15:46:19 -07:00
|
|
|
Eina_Bool disabled : 1;
|
2009-08-30 09:54:15 -07:00
|
|
|
Eina_Bool separator : 1;
|
2010-08-04 12:20:52 -07:00
|
|
|
Eina_Bool menu : 1;
|
2008-12-18 05:38:58 -08:00
|
|
|
};
|
|
|
|
|
2010-03-08 22:15:39 -08:00
|
|
|
static const char *widtype = NULL;
|
2009-08-25 15:46:19 -07:00
|
|
|
static void _item_show(Elm_Toolbar_Item *it);
|
|
|
|
static void _item_select(Elm_Toolbar_Item *it);
|
|
|
|
static void _item_disable(Elm_Toolbar_Item *it, Eina_Bool disabled);
|
2009-11-14 17:52:40 -08:00
|
|
|
static void _del_pre_hook(Evas_Object *obj);
|
2008-12-18 05:38:58 -08:00
|
|
|
static void _del_hook(Evas_Object *obj);
|
|
|
|
static void _theme_hook(Evas_Object *obj);
|
|
|
|
static void _sizing_eval(Evas_Object *obj);
|
2009-11-14 17:52:40 -08:00
|
|
|
static void _resize(void *data, Evas *e, Evas_Object *obj, void *event_info);
|
2009-10-06 08:08:41 -07:00
|
|
|
static void _menu_move_resize(void *data, Evas *e, Evas_Object *obj, void *event_info);
|
2009-10-11 06:37:01 -07:00
|
|
|
static void _menu_hide(void *data, Evas *e, Evas_Object *obj, void *event_info);
|
2009-11-14 17:52:40 -08:00
|
|
|
static void _layout(Evas_Object *o, Evas_Object_Box_Data *priv, void *data);
|
2009-10-06 08:08:41 -07:00
|
|
|
|
2010-10-14 08:27:31 -07:00
|
|
|
static Eina_Bool
|
|
|
|
_item_icon_set(Evas_Object *icon_obj, const char *type, const char *icon)
|
|
|
|
{
|
|
|
|
char icon_str[512];
|
|
|
|
|
|
|
|
if (!type || !*type) goto end;
|
2010-10-14 15:21:43 -07:00
|
|
|
if (!icon || !*icon) return EINA_FALSE;
|
2010-10-14 09:50:05 -07:00
|
|
|
if (snprintf(icon_str, sizeof(icon_str), "%s%s", type, icon) > 0
|
2010-10-14 08:27:31 -07:00
|
|
|
&& elm_icon_standard_set(icon_obj, icon_str))
|
|
|
|
return EINA_TRUE;
|
|
|
|
end:
|
|
|
|
if (elm_icon_standard_set(icon_obj, icon))
|
|
|
|
return EINA_TRUE;
|
|
|
|
WRN("couldn't find icon definition for '%s'", icon);
|
|
|
|
return EINA_FALSE;
|
|
|
|
}
|
|
|
|
|
2008-12-18 05:38:58 -08:00
|
|
|
static void
|
2009-02-25 07:54:26 -08:00
|
|
|
_item_show(Elm_Toolbar_Item *it)
|
2008-12-18 05:38:58 -08:00
|
|
|
{
|
2010-09-09 19:05:45 -07:00
|
|
|
Widget_Data *wd = elm_widget_data_get(it->base.widget);
|
2008-12-18 05:38:58 -08:00
|
|
|
Evas_Coord x, y, w, h, bx, by;
|
2009-07-06 23:46:51 -07:00
|
|
|
|
2009-08-26 07:29:18 -07:00
|
|
|
if (!wd) return;
|
2008-12-18 05:38:58 -08:00
|
|
|
evas_object_geometry_get(wd->bx, &bx, &by, NULL, NULL);
|
2010-09-09 19:05:45 -07:00
|
|
|
evas_object_geometry_get(it->base.view, &x, &y, &w, &h);
|
2008-12-18 05:38:58 -08:00
|
|
|
elm_smart_scroller_child_region_show(wd->scr, x - bx, y - by, w, h);
|
|
|
|
}
|
|
|
|
|
2008-12-18 20:26:24 -08:00
|
|
|
static void
|
2009-02-25 07:54:26 -08:00
|
|
|
_item_select(Elm_Toolbar_Item *it)
|
2008-12-18 20:26:24 -08:00
|
|
|
{
|
2009-02-25 07:54:26 -08:00
|
|
|
Elm_Toolbar_Item *it2;
|
2010-09-09 19:05:45 -07:00
|
|
|
Widget_Data *wd = elm_widget_data_get(it->base.widget);
|
2010-03-09 03:42:53 -08:00
|
|
|
Evas_Object *obj2;
|
2009-02-25 11:50:45 -08:00
|
|
|
const Eina_List *l;
|
2009-08-25 15:46:19 -07:00
|
|
|
|
2009-08-26 07:29:18 -07:00
|
|
|
if (!wd) return;
|
2009-08-30 09:54:15 -07:00
|
|
|
if ((it->selected) || (it->disabled) || (it->separator)) return;
|
2009-02-25 11:50:45 -08:00
|
|
|
EINA_LIST_FOREACH(wd->items, l, it2)
|
2008-12-18 20:26:24 -08:00
|
|
|
{
|
2009-07-06 23:46:51 -07:00
|
|
|
if (it2->selected)
|
|
|
|
{
|
|
|
|
it2->selected = EINA_FALSE;
|
2010-09-09 19:05:45 -07:00
|
|
|
edje_object_signal_emit
|
|
|
|
(it2->base.view, "elm,state,unselected", "elm");
|
2009-07-06 23:46:51 -07:00
|
|
|
break;
|
|
|
|
}
|
2008-12-18 20:26:24 -08:00
|
|
|
}
|
2009-06-17 08:35:19 -07:00
|
|
|
it->selected = EINA_TRUE;
|
2010-09-09 19:05:45 -07:00
|
|
|
edje_object_signal_emit(it->base.view, "elm,state,selected", "elm");
|
2008-12-18 20:26:24 -08:00
|
|
|
_item_show(it);
|
2010-09-09 19:05:45 -07:00
|
|
|
obj2 = it->base.widget;
|
2009-10-06 08:08:41 -07:00
|
|
|
if(it->menu)
|
2009-10-18 10:20:18 -07:00
|
|
|
{
|
|
|
|
evas_object_show(it->o_menu);
|
2010-09-09 19:05:45 -07:00
|
|
|
evas_object_event_callback_add(it->base.view, EVAS_CALLBACK_RESIZE,
|
2009-10-18 10:20:18 -07:00
|
|
|
_menu_move_resize, it);
|
2010-09-09 19:05:45 -07:00
|
|
|
evas_object_event_callback_add(it->base.view, EVAS_CALLBACK_MOVE,
|
2009-10-18 10:20:18 -07:00
|
|
|
_menu_move_resize, it);
|
2009-10-07 10:11:41 -07:00
|
|
|
|
2009-10-18 10:20:18 -07:00
|
|
|
_menu_move_resize(it, NULL, NULL, NULL);
|
|
|
|
}
|
2010-09-09 19:05:45 -07:00
|
|
|
if (it->func) it->func((void *)(it->base.data), it->base.widget, it);
|
2009-01-07 13:08:36 -08:00
|
|
|
evas_object_smart_callback_call(obj2, "clicked", it);
|
2008-12-18 20:26:24 -08:00
|
|
|
}
|
|
|
|
|
2009-10-06 08:08:41 -07:00
|
|
|
static void
|
2010-03-09 09:51:30 -08:00
|
|
|
_menu_hide(void *data, Evas *e __UNUSED__, Evas_Object *obj __UNUSED__, void *event_info __UNUSED__)
|
2009-10-06 08:08:41 -07:00
|
|
|
{
|
2009-10-18 10:20:18 -07:00
|
|
|
Elm_Toolbar_Item *it = data;
|
2010-09-09 19:05:45 -07:00
|
|
|
elm_toolbar_item_unselect_all(it->base.widget);
|
2009-10-06 08:08:41 -07:00
|
|
|
}
|
|
|
|
|
2009-11-13 14:22:05 -08:00
|
|
|
static void
|
2010-03-09 09:51:30 -08:00
|
|
|
_menu_del(void *data, Evas *e __UNUSED__, Evas_Object *obj, void *event_info __UNUSED__)
|
2009-11-13 14:22:05 -08:00
|
|
|
{
|
|
|
|
// avoid hide being emitted during object deletion
|
|
|
|
evas_object_event_callback_del_full
|
|
|
|
(obj, EVAS_CALLBACK_HIDE, _menu_hide, data);
|
|
|
|
}
|
|
|
|
|
2009-10-06 08:08:41 -07:00
|
|
|
static void
|
2010-03-09 09:51:30 -08:00
|
|
|
_menu_move_resize(void *data, Evas *e __UNUSED__, Evas_Object *obj __UNUSED__, void *event_info __UNUSED__)
|
2009-10-06 13:14:46 -07:00
|
|
|
{
|
2009-10-22 15:10:23 -07:00
|
|
|
Elm_Toolbar_Item *it = data;
|
|
|
|
Evas_Coord x,y,w,h;
|
2010-09-09 19:05:45 -07:00
|
|
|
Widget_Data *wd = elm_widget_data_get(it->base.widget);
|
2009-10-18 10:20:18 -07:00
|
|
|
|
2009-11-09 18:03:52 -08:00
|
|
|
if ((!wd) || (!wd->menu_parent)) return;
|
2010-09-09 19:05:45 -07:00
|
|
|
evas_object_geometry_get(it->base.view, &x, &y, &w, &h);
|
2009-10-22 15:10:23 -07:00
|
|
|
elm_menu_move(it->o_menu, x, y+h);
|
2009-10-06 08:08:41 -07:00
|
|
|
}
|
|
|
|
|
2009-10-06 13:14:46 -07:00
|
|
|
static void
|
2009-08-25 15:46:19 -07:00
|
|
|
_item_disable(Elm_Toolbar_Item *it, Eina_Bool disabled)
|
|
|
|
{
|
2010-09-09 19:05:45 -07:00
|
|
|
Widget_Data *wd = elm_widget_data_get(it->base.widget);
|
2009-08-25 15:46:19 -07:00
|
|
|
|
2009-08-26 07:29:18 -07:00
|
|
|
if (!wd) return;
|
2009-08-25 15:46:19 -07:00
|
|
|
if (it->disabled == disabled) return;
|
|
|
|
it->disabled = disabled;
|
2009-10-06 13:14:46 -07:00
|
|
|
if (it->disabled)
|
2010-09-09 19:05:45 -07:00
|
|
|
edje_object_signal_emit(it->base.view, "elm,state,disabled", "elm");
|
2009-08-25 15:46:19 -07:00
|
|
|
else
|
2010-09-09 19:05:45 -07:00
|
|
|
edje_object_signal_emit(it->base.view, "elm,state,enabled", "elm");
|
2009-08-25 15:46:19 -07:00
|
|
|
}
|
|
|
|
|
2009-10-18 10:20:18 -07:00
|
|
|
static void
|
2009-10-15 13:48:00 -07:00
|
|
|
_del_pre_hook(Evas_Object *obj)
|
|
|
|
{
|
|
|
|
Widget_Data *wd = elm_widget_data_get(obj);
|
|
|
|
Elm_Toolbar_Item *it;
|
|
|
|
|
|
|
|
if (!wd) return;
|
|
|
|
EINA_LIST_FREE(wd->items, it)
|
2009-11-13 14:22:05 -08:00
|
|
|
{
|
2010-09-09 19:05:45 -07:00
|
|
|
elm_widget_item_pre_notify_del(it);
|
2009-11-13 14:22:05 -08:00
|
|
|
eina_stringshare_del(it->label);
|
|
|
|
if (it->icon) evas_object_del(it->icon);
|
|
|
|
if ((!wd->menu_parent) && (it->o_menu)) evas_object_del(it->o_menu);
|
2010-09-09 19:05:45 -07:00
|
|
|
elm_widget_item_del(it);
|
2009-11-13 14:22:05 -08:00
|
|
|
}
|
2009-10-15 13:48:00 -07:00
|
|
|
}
|
|
|
|
|
2008-12-18 05:38:58 -08:00
|
|
|
static void
|
|
|
|
_del_hook(Evas_Object *obj)
|
|
|
|
{
|
|
|
|
Widget_Data *wd = elm_widget_data_get(obj);
|
2009-08-25 15:46:19 -07:00
|
|
|
|
2009-08-26 07:29:18 -07:00
|
|
|
if (!wd) return;
|
2008-12-18 05:38:58 -08:00
|
|
|
free(wd);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
_theme_hook(Evas_Object *obj)
|
|
|
|
{
|
2008-12-18 20:26:24 -08:00
|
|
|
Widget_Data *wd = elm_widget_data_get(obj);
|
2009-02-25 11:50:45 -08:00
|
|
|
const Eina_List *l;
|
2009-02-25 07:54:26 -08:00
|
|
|
Elm_Toolbar_Item *it;
|
2009-04-22 21:03:27 -07:00
|
|
|
const char *style = elm_widget_style_get(obj);
|
2010-05-11 18:03:46 -07:00
|
|
|
double scale = 0;
|
2009-04-22 21:03:27 -07:00
|
|
|
|
2009-08-26 07:29:18 -07:00
|
|
|
if (!wd) return;
|
2010-05-11 18:03:46 -07:00
|
|
|
elm_smart_scroller_object_theme_set(obj, wd->scr, "toolbar", "base", elm_widget_style_get(obj));
|
2009-08-30 09:54:15 -07:00
|
|
|
scale = (elm_widget_scale_get(obj) * _elm_config->scale);
|
2010-03-22 21:46:53 -07:00
|
|
|
// edje_object_scale_set(wd->scr, scale);
|
2009-02-25 11:50:45 -08:00
|
|
|
EINA_LIST_FOREACH(wd->items, l, it)
|
2008-12-18 20:26:24 -08:00
|
|
|
{
|
2010-09-09 19:05:45 -07:00
|
|
|
Evas_Object *view = it->base.view;
|
2009-08-30 09:54:15 -07:00
|
|
|
Evas_Coord mw, mh;
|
|
|
|
|
2010-09-09 19:05:45 -07:00
|
|
|
edje_object_scale_set(view, scale);
|
2009-10-06 13:14:46 -07:00
|
|
|
if (!it->separator)
|
2009-08-30 09:54:15 -07:00
|
|
|
{
|
2009-10-06 13:14:46 -07:00
|
|
|
if (it->selected)
|
2010-09-09 19:05:45 -07:00
|
|
|
edje_object_signal_emit(view, "elm,state,selected", "elm");
|
2009-08-30 09:54:15 -07:00
|
|
|
if (it->disabled)
|
2010-09-09 19:05:45 -07:00
|
|
|
edje_object_signal_emit(view, "elm,state,disabled", "elm");
|
|
|
|
_elm_theme_object_set(obj, view, "toolbar", "item", style);
|
2009-08-30 09:54:15 -07:00
|
|
|
if (it->icon)
|
|
|
|
{
|
|
|
|
int ms = 0;
|
|
|
|
|
|
|
|
ms = ((double)wd->icon_size * _elm_config->scale);
|
2009-10-11 06:37:01 -07:00
|
|
|
evas_object_size_hint_min_set(it->icon, ms, ms);
|
|
|
|
evas_object_size_hint_max_set(it->icon, ms, ms);
|
2010-09-09 19:05:45 -07:00
|
|
|
edje_object_part_swallow(view, "elm.swallow.icon",
|
2009-08-30 09:54:15 -07:00
|
|
|
it->icon);
|
|
|
|
}
|
2010-09-09 19:05:45 -07:00
|
|
|
edje_object_part_text_set(view, "elm.text", it->label);
|
2009-08-30 09:54:15 -07:00
|
|
|
}
|
2009-10-06 13:14:46 -07:00
|
|
|
else
|
2010-09-09 19:05:45 -07:00
|
|
|
_elm_theme_object_set(obj, view, "toolbar", "separator", style);
|
2009-10-18 10:20:18 -07:00
|
|
|
|
2009-07-06 23:46:51 -07:00
|
|
|
mw = mh = -1;
|
2009-10-18 10:20:18 -07:00
|
|
|
if (!it->separator)
|
2009-10-11 06:37:01 -07:00
|
|
|
elm_coords_finger_size_adjust(1, &mw, 1, &mh);
|
2010-09-09 19:05:45 -07:00
|
|
|
edje_object_size_min_restricted_calc(view, &mw, &mh, mw, mh);
|
2009-10-18 10:20:18 -07:00
|
|
|
if (!it->separator)
|
2009-10-11 06:37:01 -07:00
|
|
|
elm_coords_finger_size_adjust(1, &mw, 1, &mh);
|
2010-09-09 19:05:45 -07:00
|
|
|
evas_object_size_hint_min_set(view, mw, mh);
|
2008-12-18 20:26:24 -08:00
|
|
|
}
|
2008-12-18 05:38:58 -08:00
|
|
|
_sizing_eval(obj);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
_sizing_eval(Evas_Object *obj)
|
|
|
|
{
|
|
|
|
Widget_Data *wd = elm_widget_data_get(obj);
|
2009-11-09 18:03:52 -08:00
|
|
|
Evas_Coord minw = -1, minh = -1;
|
2008-12-18 05:38:58 -08:00
|
|
|
Evas_Coord vw = 0, vh = 0;
|
2009-09-30 04:26:26 -07:00
|
|
|
Evas_Coord w, h;
|
2008-12-18 05:38:58 -08:00
|
|
|
|
2009-08-26 07:29:18 -07:00
|
|
|
if (!wd) return;
|
2009-10-02 12:22:40 -07:00
|
|
|
evas_object_smart_calculate(wd->bx);
|
2009-10-06 13:14:46 -07:00
|
|
|
edje_object_size_min_calc(elm_smart_scroller_edje_object_get(wd->scr),
|
2009-08-30 09:33:03 -07:00
|
|
|
&minw, &minh);
|
2009-09-30 04:26:26 -07:00
|
|
|
evas_object_geometry_get(obj, NULL, NULL, &w, &h);
|
2009-10-18 10:20:18 -07:00
|
|
|
if (w < minw) w = minw;
|
|
|
|
if (h < minh) h = minh;
|
2009-09-30 04:26:26 -07:00
|
|
|
|
|
|
|
evas_object_resize(wd->scr, w, h);
|
|
|
|
|
2008-12-18 05:38:58 -08:00
|
|
|
evas_object_size_hint_min_get(wd->bx, &minw, &minh);
|
2009-10-18 10:20:18 -07:00
|
|
|
if (w > minw) minw = w;
|
2008-12-18 05:38:58 -08:00
|
|
|
evas_object_resize(wd->bx, minw, minh);
|
|
|
|
elm_smart_scroller_child_viewport_size_get(wd->scr, &vw, &vh);
|
[Elementary] Implement priority in Elm_Toolbar.
Toolbars can now be scrollable, non-scrollable, or hide icons selectively
according to a priority. This changed the API slightly, thus
elm_toolbar_scrollable_set(obj, 1)
Should be
elm_toolbar_mode_expand_set(obj, ELM_TOOLBAR_EXPAND_SCROLL)
Values for non-scrollable and scrollable remain the same, so if constants
aren't being used, just the function name should be changed.
The new mode, ELM_TOOLBAR_EXPAND_MENU, will create a menu of items when the
space isn't large enough to hold all the items. Which items will be kept on
the toolbar or which items will be added to the menu is controlled by the
priority of each item: higher ones will be kept if possible, lower ones will
be tratored on the first opportunity.
SVN revision: 53406
2010-10-14 08:27:25 -07:00
|
|
|
switch (wd->shrink_mode)
|
|
|
|
{
|
|
|
|
case ELM_TOOLBAR_SHRINK_MENU: /* fallthrough */
|
|
|
|
case ELM_TOOLBAR_SHRINK_SCROLL: minw = w - vw; break;
|
|
|
|
case ELM_TOOLBAR_SHRINK_NONE: minw = minw + (w - vw); break;
|
|
|
|
}
|
2009-11-09 18:03:52 -08:00
|
|
|
minh = minh + (h - vh);
|
2008-12-18 05:38:58 -08:00
|
|
|
evas_object_size_hint_min_set(obj, minw, minh);
|
2009-11-09 18:03:52 -08:00
|
|
|
evas_object_size_hint_max_set(obj, -1, -1);
|
2008-12-18 05:38:58 -08:00
|
|
|
}
|
|
|
|
|
[Elementary] Implement priority in Elm_Toolbar.
Toolbars can now be scrollable, non-scrollable, or hide icons selectively
according to a priority. This changed the API slightly, thus
elm_toolbar_scrollable_set(obj, 1)
Should be
elm_toolbar_mode_expand_set(obj, ELM_TOOLBAR_EXPAND_SCROLL)
Values for non-scrollable and scrollable remain the same, so if constants
aren't being used, just the function name should be changed.
The new mode, ELM_TOOLBAR_EXPAND_MENU, will create a menu of items when the
space isn't large enough to hold all the items. Which items will be kept on
the toolbar or which items will be added to the menu is controlled by the
priority of each item: higher ones will be kept if possible, lower ones will
be tratored on the first opportunity.
SVN revision: 53406
2010-10-14 08:27:25 -07:00
|
|
|
static void
|
|
|
|
_item_menu_create(Widget_Data *wd, Elm_Toolbar_Item *item)
|
|
|
|
{
|
|
|
|
item->o_menu = elm_menu_add(item->base.view);
|
|
|
|
if (wd->menu_parent)
|
|
|
|
elm_menu_parent_set(item->o_menu, wd->menu_parent);
|
|
|
|
evas_object_event_callback_add(item->o_menu, EVAS_CALLBACK_HIDE,
|
|
|
|
_menu_hide, item);
|
|
|
|
evas_object_event_callback_add(item->o_menu, EVAS_CALLBACK_DEL,
|
|
|
|
_menu_del, item);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
_item_menu_destroy(Elm_Toolbar_Item *item)
|
|
|
|
{
|
|
|
|
if (item->o_menu)
|
|
|
|
{
|
|
|
|
evas_object_del(item->o_menu);
|
|
|
|
item->o_menu = NULL;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
static int
|
|
|
|
_toolbar_item_prio_compare_cb(const void *i1, const void *i2)
|
|
|
|
{
|
|
|
|
const Elm_Toolbar_Item *eti1 = i1;
|
|
|
|
const Elm_Toolbar_Item *eti2 = i2;
|
|
|
|
|
|
|
|
if (!eti2) return 1;
|
|
|
|
if (!eti1) return -1;
|
|
|
|
|
|
|
|
return eti2->prio.priority - eti1->prio.priority;
|
|
|
|
}
|
|
|
|
|
2008-12-18 05:38:58 -08:00
|
|
|
static void
|
2010-03-09 09:51:30 -08:00
|
|
|
_resize(void *data, Evas *e __UNUSED__, Evas_Object *obj __UNUSED__, void *event_info __UNUSED__)
|
2008-12-18 05:38:58 -08:00
|
|
|
{
|
|
|
|
Widget_Data *wd = elm_widget_data_get(data);
|
2010-03-09 03:42:53 -08:00
|
|
|
Evas_Coord mw, mh, vw, vh, w, h;
|
2009-02-25 11:50:45 -08:00
|
|
|
const Eina_List *l;
|
2009-02-25 07:54:26 -08:00
|
|
|
Elm_Toolbar_Item *it;
|
2009-07-06 23:46:51 -07:00
|
|
|
|
2009-08-26 07:29:18 -07:00
|
|
|
if (!wd) return;
|
2008-12-18 05:38:58 -08:00
|
|
|
elm_smart_scroller_child_viewport_size_get(wd->scr, &vw, &vh);
|
|
|
|
evas_object_size_hint_min_get(wd->bx, &mw, &mh);
|
|
|
|
evas_object_geometry_get(wd->bx, NULL, NULL, &w, &h);
|
|
|
|
if (vw >= mw)
|
|
|
|
{
|
2009-07-06 23:46:51 -07:00
|
|
|
if (w != vw) evas_object_resize(wd->bx, vw, h);
|
2008-12-18 05:38:58 -08:00
|
|
|
}
|
[Elementary] Implement priority in Elm_Toolbar.
Toolbars can now be scrollable, non-scrollable, or hide icons selectively
according to a priority. This changed the API slightly, thus
elm_toolbar_scrollable_set(obj, 1)
Should be
elm_toolbar_mode_expand_set(obj, ELM_TOOLBAR_EXPAND_SCROLL)
Values for non-scrollable and scrollable remain the same, so if constants
aren't being used, just the function name should be changed.
The new mode, ELM_TOOLBAR_EXPAND_MENU, will create a menu of items when the
space isn't large enough to hold all the items. Which items will be kept on
the toolbar or which items will be added to the menu is controlled by the
priority of each item: higher ones will be kept if possible, lower ones will
be tratored on the first opportunity.
SVN revision: 53406
2010-10-14 08:27:25 -07:00
|
|
|
|
|
|
|
if (wd->shrink_mode == ELM_TOOLBAR_SHRINK_MENU)
|
2008-12-18 05:38:58 -08:00
|
|
|
{
|
[Elementary] Implement priority in Elm_Toolbar.
Toolbars can now be scrollable, non-scrollable, or hide icons selectively
according to a priority. This changed the API slightly, thus
elm_toolbar_scrollable_set(obj, 1)
Should be
elm_toolbar_mode_expand_set(obj, ELM_TOOLBAR_EXPAND_SCROLL)
Values for non-scrollable and scrollable remain the same, so if constants
aren't being used, just the function name should be changed.
The new mode, ELM_TOOLBAR_EXPAND_MENU, will create a menu of items when the
space isn't large enough to hold all the items. Which items will be kept on
the toolbar or which items will be added to the menu is controlled by the
priority of each item: higher ones will be kept if possible, lower ones will
be tratored on the first opportunity.
SVN revision: 53406
2010-10-14 08:27:25 -07:00
|
|
|
Evas_Coord iw = 0;
|
|
|
|
Eina_List *sorted = eina_list_sort(eina_list_clone(wd->items), 0,
|
|
|
|
_toolbar_item_prio_compare_cb);
|
|
|
|
EINA_LIST_FREE(sorted, it)
|
|
|
|
{
|
|
|
|
Evas_Coord ciw;
|
|
|
|
|
|
|
|
evas_object_geometry_get(it->base.view, NULL, NULL, &ciw, NULL);
|
|
|
|
iw += ciw;
|
|
|
|
it->prio.visible = (iw <= vw);
|
|
|
|
}
|
|
|
|
|
|
|
|
/* All items are removed from the box object, since removing individual items won't trigger
|
|
|
|
a resize. Items are be readded below. */
|
|
|
|
evas_object_box_remove_all(wd->bx, EINA_FALSE);
|
|
|
|
if (iw > vw)
|
|
|
|
{
|
|
|
|
Evas_Object *menu;
|
|
|
|
|
|
|
|
_item_menu_destroy(wd->more_item);
|
|
|
|
_item_menu_create(wd, wd->more_item);
|
|
|
|
menu = elm_toolbar_item_menu_get(wd->more_item);
|
|
|
|
|
|
|
|
EINA_LIST_FOREACH(wd->items, l, it)
|
|
|
|
{
|
|
|
|
if (wd->more_item == it) continue;
|
|
|
|
if (!it->prio.visible)
|
|
|
|
{
|
|
|
|
if (it->separator)
|
|
|
|
elm_menu_item_separator_add(menu, NULL);
|
|
|
|
else
|
|
|
|
{
|
2010-10-14 08:27:31 -07:00
|
|
|
Elm_Menu_Item *item;
|
2010-10-20 14:30:00 -07:00
|
|
|
item = elm_menu_item_add(menu, NULL, it->icon_str, it->label,
|
2010-10-14 08:27:31 -07:00
|
|
|
it->func, it->base.data);
|
[Elementary] Implement priority in Elm_Toolbar.
Toolbars can now be scrollable, non-scrollable, or hide icons selectively
according to a priority. This changed the API slightly, thus
elm_toolbar_scrollable_set(obj, 1)
Should be
elm_toolbar_mode_expand_set(obj, ELM_TOOLBAR_EXPAND_SCROLL)
Values for non-scrollable and scrollable remain the same, so if constants
aren't being used, just the function name should be changed.
The new mode, ELM_TOOLBAR_EXPAND_MENU, will create a menu of items when the
space isn't large enough to hold all the items. Which items will be kept on
the toolbar or which items will be added to the menu is controlled by the
priority of each item: higher ones will be kept if possible, lower ones will
be tratored on the first opportunity.
SVN revision: 53406
2010-10-14 08:27:25 -07:00
|
|
|
elm_menu_item_disabled_set(item, it->disabled);
|
2010-10-20 14:30:03 -07:00
|
|
|
if (it->o_menu) elm_menu_clone(it->o_menu, menu, item);
|
[Elementary] Implement priority in Elm_Toolbar.
Toolbars can now be scrollable, non-scrollable, or hide icons selectively
according to a priority. This changed the API slightly, thus
elm_toolbar_scrollable_set(obj, 1)
Should be
elm_toolbar_mode_expand_set(obj, ELM_TOOLBAR_EXPAND_SCROLL)
Values for non-scrollable and scrollable remain the same, so if constants
aren't being used, just the function name should be changed.
The new mode, ELM_TOOLBAR_EXPAND_MENU, will create a menu of items when the
space isn't large enough to hold all the items. Which items will be kept on
the toolbar or which items will be added to the menu is controlled by the
priority of each item: higher ones will be kept if possible, lower ones will
be tratored on the first opportunity.
SVN revision: 53406
2010-10-14 08:27:25 -07:00
|
|
|
}
|
|
|
|
evas_object_hide(it->base.view);
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
evas_object_box_append(wd->bx, it->base.view);
|
|
|
|
evas_object_show(it->base.view);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
evas_object_box_append(wd->bx, wd->more_item->base.view);
|
|
|
|
evas_object_show(wd->more_item->base.view);
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
/* All items are visible, show them all (except for the "More" button, of course). */
|
|
|
|
EINA_LIST_FOREACH(wd->items, l, it)
|
|
|
|
{
|
|
|
|
if (it == wd->more_item)
|
|
|
|
evas_object_hide(it->base.view);
|
|
|
|
else
|
|
|
|
{
|
|
|
|
evas_object_show(it->base.view);
|
|
|
|
evas_object_box_append(wd->bx, it->base.view);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
EINA_LIST_FOREACH(wd->items, l, it)
|
|
|
|
{
|
|
|
|
if (it->selected)
|
|
|
|
{
|
|
|
|
_item_show(it);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
2008-12-18 05:38:58 -08:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
2010-03-09 09:51:30 -08:00
|
|
|
_select(void *data, Evas_Object *obj __UNUSED__, const char *emission __UNUSED__, const char *source __UNUSED__)
|
2008-12-18 05:38:58 -08:00
|
|
|
{
|
2008-12-18 20:26:24 -08:00
|
|
|
_item_select(data);
|
2008-12-18 05:38:58 -08:00
|
|
|
}
|
|
|
|
|
2009-10-02 12:22:40 -07:00
|
|
|
static void
|
|
|
|
_layout(Evas_Object *o, Evas_Object_Box_Data *priv, void *data)
|
|
|
|
{
|
|
|
|
Widget_Data *wd = data;
|
2010-03-09 03:42:53 -08:00
|
|
|
if (!wd) return;
|
2009-10-02 12:22:40 -07:00
|
|
|
_els_box_layout(o, priv, 1, wd->homogeneous);
|
|
|
|
}
|
|
|
|
|
2010-04-12 01:12:02 -07:00
|
|
|
/**
|
|
|
|
* Add a toolbar object to @p parent.
|
|
|
|
*
|
|
|
|
* @param parent The parent object
|
|
|
|
*
|
|
|
|
* @return The created object, or NULL on failure
|
|
|
|
*
|
|
|
|
* @ingroup Toolbar
|
|
|
|
*/
|
2008-12-18 05:38:58 -08:00
|
|
|
EAPI Evas_Object *
|
|
|
|
elm_toolbar_add(Evas_Object *parent)
|
|
|
|
{
|
|
|
|
Evas_Object *obj;
|
|
|
|
Evas *e;
|
|
|
|
Widget_Data *wd;
|
2009-07-06 23:46:51 -07:00
|
|
|
|
2008-12-18 05:38:58 -08:00
|
|
|
wd = ELM_NEW(Widget_Data);
|
|
|
|
e = evas_object_evas_get(parent);
|
|
|
|
obj = elm_widget_add(e);
|
2010-03-08 22:15:39 -08:00
|
|
|
ELM_SET_WIDTYPE(widtype, "toolbar");
|
2009-05-13 05:21:52 -07:00
|
|
|
elm_widget_type_set(obj, "toolbar");
|
|
|
|
elm_widget_sub_object_add(parent, obj);
|
2008-12-18 05:38:58 -08:00
|
|
|
elm_widget_data_set(obj, wd);
|
2009-10-15 13:48:00 -07:00
|
|
|
elm_widget_del_pre_hook_set(obj, _del_pre_hook);
|
2008-12-18 05:38:58 -08:00
|
|
|
elm_widget_del_hook_set(obj, _del_hook);
|
|
|
|
elm_widget_theme_hook_set(obj, _theme_hook);
|
2010-09-27 21:28:14 -07:00
|
|
|
elm_widget_can_focus_set(obj, EINA_FALSE);
|
2009-07-06 23:46:51 -07:00
|
|
|
|
[Elementary] Implement priority in Elm_Toolbar.
Toolbars can now be scrollable, non-scrollable, or hide icons selectively
according to a priority. This changed the API slightly, thus
elm_toolbar_scrollable_set(obj, 1)
Should be
elm_toolbar_mode_expand_set(obj, ELM_TOOLBAR_EXPAND_SCROLL)
Values for non-scrollable and scrollable remain the same, so if constants
aren't being used, just the function name should be changed.
The new mode, ELM_TOOLBAR_EXPAND_MENU, will create a menu of items when the
space isn't large enough to hold all the items. Which items will be kept on
the toolbar or which items will be added to the menu is controlled by the
priority of each item: higher ones will be kept if possible, lower ones will
be tratored on the first opportunity.
SVN revision: 53406
2010-10-14 08:27:25 -07:00
|
|
|
wd->more_item = NULL;
|
2008-12-18 05:38:58 -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-05-11 18:03:46 -07:00
|
|
|
elm_smart_scroller_object_theme_set(obj, wd->scr, "toolbar", "base", "default");
|
2010-10-21 12:57:43 -07:00
|
|
|
elm_smart_scroller_bounce_allow_set(wd->scr,
|
|
|
|
_elm_config->thumbscroll_bounce_enable,
|
|
|
|
EINA_FALSE);
|
2008-12-18 05:38:58 -08:00
|
|
|
elm_widget_resize_object_set(obj, wd->scr);
|
2009-07-06 23:46:51 -07:00
|
|
|
elm_smart_scroller_policy_set(wd->scr,
|
|
|
|
ELM_SMART_SCROLLER_POLICY_AUTO,
|
|
|
|
ELM_SMART_SCROLLER_POLICY_OFF);
|
|
|
|
|
2010-10-21 11:59:45 -07:00
|
|
|
wd->icon_size = _elm_config->icon_size;
|
2009-10-02 12:22:40 -07:00
|
|
|
wd->homogeneous = EINA_TRUE;
|
2009-10-06 13:14:46 -07:00
|
|
|
wd->align = 0.5;
|
2009-10-22 15:10:23 -07:00
|
|
|
|
2009-10-02 12:22:40 -07:00
|
|
|
wd->bx = evas_object_box_add(e);
|
2009-10-06 13:14:46 -07:00
|
|
|
evas_object_size_hint_align_set(wd->bx, wd->align, 0.5);
|
2009-10-02 12:22:40 -07:00
|
|
|
evas_object_box_layout_set(wd->bx, _layout, wd, NULL);
|
2008-12-18 05:38:58 -08:00
|
|
|
elm_widget_sub_object_add(obj, wd->bx);
|
|
|
|
elm_smart_scroller_child_set(wd->scr, wd->bx);
|
|
|
|
evas_object_show(wd->bx);
|
|
|
|
|
2010-10-21 12:24:43 -07:00
|
|
|
elm_toolbar_mode_shrink_set(obj, _elm_config->toolbar_shrink_mode);
|
2009-08-30 09:33:03 -07:00
|
|
|
evas_object_event_callback_add(wd->scr, EVAS_CALLBACK_RESIZE, _resize, obj);
|
2009-07-06 23:46:51 -07:00
|
|
|
|
2008-12-18 05:38:58 -08:00
|
|
|
_sizing_eval(obj);
|
|
|
|
return obj;
|
|
|
|
}
|
|
|
|
|
2010-04-12 01:12:02 -07:00
|
|
|
/**
|
|
|
|
* Set the icon size (in pixels) for the toolbar.
|
|
|
|
*
|
|
|
|
* @param obj The toolbar object
|
|
|
|
* @param icon_size The icon size in pixels
|
|
|
|
*
|
|
|
|
* @ingroup Toolbar
|
|
|
|
*/
|
2009-10-06 13:14:46 -07:00
|
|
|
EAPI void
|
|
|
|
elm_toolbar_icon_size_set(Evas_Object *obj, int icon_size)
|
2009-08-25 17:30:55 -07:00
|
|
|
{
|
2010-03-08 22:15:39 -08:00
|
|
|
ELM_CHECK_WIDTYPE(obj, widtype);
|
2009-08-25 17:30:55 -07:00
|
|
|
Widget_Data *wd = elm_widget_data_get(obj);
|
2009-08-26 07:29:18 -07:00
|
|
|
if (!wd) return;
|
2009-08-25 17:47:31 -07:00
|
|
|
if (icon_size > 48) return;
|
|
|
|
if (wd->icon_size == icon_size) return;
|
2009-08-25 17:30:55 -07:00
|
|
|
wd->icon_size = icon_size;
|
|
|
|
_theme_hook(obj);
|
|
|
|
}
|
|
|
|
|
2010-04-12 01:12:02 -07:00
|
|
|
/**
|
|
|
|
* Get the icon size (in pixels) for the toolbar.
|
|
|
|
*
|
|
|
|
* @param obj The toolbar object
|
|
|
|
* @return The icon size in pixels
|
|
|
|
*
|
|
|
|
* @ingroup Toolbar
|
|
|
|
*/
|
2009-10-06 13:14:46 -07:00
|
|
|
EAPI int
|
2010-03-23 20:06:00 -07:00
|
|
|
elm_toolbar_icon_size_get(const Evas_Object *obj)
|
2009-08-25 17:47:31 -07:00
|
|
|
{
|
2010-03-09 03:42:53 -08:00
|
|
|
ELM_CHECK_WIDTYPE(obj, widtype) 0;
|
2009-08-25 17:47:31 -07:00
|
|
|
Widget_Data *wd = elm_widget_data_get(obj);
|
2009-08-26 07:29:18 -07:00
|
|
|
if (!wd) return 0;
|
2009-08-25 17:47:31 -07:00
|
|
|
return wd->icon_size;
|
|
|
|
}
|
|
|
|
|
2010-04-12 01:12:02 -07:00
|
|
|
/**
|
|
|
|
* Add an item to the toolbar.
|
|
|
|
*
|
|
|
|
* @param obj The toolbar object
|
2010-10-14 08:27:31 -07:00
|
|
|
* @param icon The icon string
|
2010-04-12 01:12:02 -07:00
|
|
|
* @param label The label of the item
|
|
|
|
* @param func The function to call when the item is clicked
|
|
|
|
* @param data The data to associate with the item
|
|
|
|
*
|
|
|
|
* @return The toolbar item, or NULL upon failure
|
|
|
|
*
|
|
|
|
* @ingroup Toolbar
|
|
|
|
*/
|
2008-12-18 05:38:58 -08:00
|
|
|
EAPI Elm_Toolbar_Item *
|
2010-10-14 08:27:31 -07:00
|
|
|
elm_toolbar_item_add(Evas_Object *obj, const char *icon, const char *label, Evas_Smart_Cb func, const void *data)
|
2008-12-18 05:38:58 -08:00
|
|
|
{
|
2010-03-09 03:42:53 -08:00
|
|
|
ELM_CHECK_WIDTYPE(obj, widtype) NULL;
|
2008-12-18 05:38:58 -08:00
|
|
|
Widget_Data *wd = elm_widget_data_get(obj);
|
2010-10-14 08:27:31 -07:00
|
|
|
Evas_Object *icon_obj;
|
2008-12-18 05:38:58 -08:00
|
|
|
Evas_Coord mw, mh;
|
2009-08-26 07:34:55 -07:00
|
|
|
Elm_Toolbar_Item *it;
|
2009-08-25 15:46:19 -07:00
|
|
|
|
2010-10-15 06:36:44 -07:00
|
|
|
if (!wd) return NULL;
|
2010-10-14 08:27:31 -07:00
|
|
|
icon_obj = elm_icon_add(obj);
|
|
|
|
if (!icon_obj) return NULL;
|
2010-09-09 19:05:45 -07:00
|
|
|
it = elm_widget_item_new(obj, Elm_Toolbar_Item);
|
2010-10-15 06:36:44 -07:00
|
|
|
if (!it)
|
|
|
|
{
|
|
|
|
evas_object_del(icon_obj);
|
|
|
|
return NULL;
|
|
|
|
}
|
2008-12-18 05:38:58 -08:00
|
|
|
wd->items = eina_list_append(wd->items, it);
|
|
|
|
it->label = eina_stringshare_add(label);
|
[Elementary] Implement priority in Elm_Toolbar.
Toolbars can now be scrollable, non-scrollable, or hide icons selectively
according to a priority. This changed the API slightly, thus
elm_toolbar_scrollable_set(obj, 1)
Should be
elm_toolbar_mode_expand_set(obj, ELM_TOOLBAR_EXPAND_SCROLL)
Values for non-scrollable and scrollable remain the same, so if constants
aren't being used, just the function name should be changed.
The new mode, ELM_TOOLBAR_EXPAND_MENU, will create a menu of items when the
space isn't large enough to hold all the items. Which items will be kept on
the toolbar or which items will be added to the menu is controlled by the
priority of each item: higher ones will be kept if possible, lower ones will
be tratored on the first opportunity.
SVN revision: 53406
2010-10-14 08:27:25 -07:00
|
|
|
it->prio.visible = 1;
|
|
|
|
it->prio.priority = 0;
|
2008-12-18 05:38:58 -08:00
|
|
|
it->func = func;
|
2009-08-30 09:54:15 -07:00
|
|
|
it->separator = EINA_FALSE;
|
2010-09-09 19:05:45 -07:00
|
|
|
it->base.data = data;
|
|
|
|
it->base.view = edje_object_add(evas_object_evas_get(obj));
|
2010-10-14 08:27:31 -07:00
|
|
|
if (_item_icon_set(icon_obj, "toolbar/", icon))
|
|
|
|
{
|
|
|
|
it->icon = icon_obj;
|
|
|
|
it->icon_str = eina_stringshare_add(icon);
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
it->icon = NULL;
|
|
|
|
it->icon_str = NULL;
|
|
|
|
evas_object_del(icon_obj);
|
|
|
|
}
|
|
|
|
|
2010-10-15 06:36:44 -07:00
|
|
|
_elm_theme_object_set(obj, it->base.view, "toolbar", "item",
|
|
|
|
elm_widget_style_get(obj));
|
2010-09-09 19:05:45 -07:00
|
|
|
edje_object_signal_callback_add(it->base.view, "elm,action,click", "elm",
|
2009-07-06 23:46:51 -07:00
|
|
|
_select, it);
|
2010-09-09 19:05:45 -07:00
|
|
|
elm_widget_sub_object_add(obj, it->base.view);
|
2008-12-18 20:26:24 -08:00
|
|
|
if (it->icon)
|
2008-12-18 05:38:58 -08:00
|
|
|
{
|
2009-08-30 09:33:03 -07:00
|
|
|
int ms = 0;
|
|
|
|
|
|
|
|
ms = ((double)wd->icon_size * _elm_config->scale);
|
2009-10-11 06:37:01 -07:00
|
|
|
evas_object_size_hint_min_set(it->icon, ms, ms);
|
|
|
|
evas_object_size_hint_max_set(it->icon, ms, ms);
|
2010-09-09 19:05:45 -07:00
|
|
|
edje_object_part_swallow(it->base.view, "elm.swallow.icon", it->icon);
|
2009-07-06 23:46:51 -07:00
|
|
|
evas_object_show(it->icon);
|
|
|
|
elm_widget_sub_object_add(obj, it->icon);
|
2008-12-18 05:38:58 -08:00
|
|
|
}
|
2010-09-09 19:05:45 -07:00
|
|
|
edje_object_part_text_set(it->base.view, "elm.text", it->label);
|
2009-02-11 03:49:43 -08:00
|
|
|
mw = mh = -1;
|
|
|
|
elm_coords_finger_size_adjust(1, &mw, 1, &mh);
|
2010-09-09 19:05:45 -07:00
|
|
|
edje_object_size_min_restricted_calc(it->base.view, &mw, &mh, mw, mh);
|
2009-02-11 03:49:43 -08:00
|
|
|
elm_coords_finger_size_adjust(1, &mw, 1, &mh);
|
2010-09-09 19:05:45 -07:00
|
|
|
evas_object_size_hint_weight_set(it->base.view, -1.0, EVAS_HINT_EXPAND);
|
|
|
|
evas_object_size_hint_align_set(it->base.view, 0.5, EVAS_HINT_FILL);
|
|
|
|
evas_object_size_hint_min_set(it->base.view, mw, mh);
|
|
|
|
evas_object_box_append(wd->bx, it->base.view);
|
|
|
|
evas_object_show(it->base.view);
|
2008-12-18 05:38:58 -08:00
|
|
|
_sizing_eval(obj);
|
2009-02-25 07:54:26 -08:00
|
|
|
return it;
|
2008-12-18 05:38:58 -08:00
|
|
|
}
|
|
|
|
|
[Elementary] Implement priority in Elm_Toolbar.
Toolbars can now be scrollable, non-scrollable, or hide icons selectively
according to a priority. This changed the API slightly, thus
elm_toolbar_scrollable_set(obj, 1)
Should be
elm_toolbar_mode_expand_set(obj, ELM_TOOLBAR_EXPAND_SCROLL)
Values for non-scrollable and scrollable remain the same, so if constants
aren't being used, just the function name should be changed.
The new mode, ELM_TOOLBAR_EXPAND_MENU, will create a menu of items when the
space isn't large enough to hold all the items. Which items will be kept on
the toolbar or which items will be added to the menu is controlled by the
priority of each item: higher ones will be kept if possible, lower ones will
be tratored on the first opportunity.
SVN revision: 53406
2010-10-14 08:27:25 -07:00
|
|
|
/**
|
|
|
|
* Sets the priority of a toolbar item. This is used only when the toolbar expand mode
|
|
|
|
* is set to ELM_TOOLBAR_SHRINK_MENU: when space is at a premium, items with low priority
|
|
|
|
* will be removed from the toolbar and added to a dynamically-created menu, while items
|
|
|
|
* with higher priority will remain on the toolbar, with the same order they were added.
|
|
|
|
*
|
|
|
|
* @param item The toolbar item.
|
|
|
|
* @param priority The item priority. The default is zero.
|
|
|
|
*
|
|
|
|
* @ingroup Toolbar
|
|
|
|
*/
|
|
|
|
EAPI void
|
|
|
|
elm_toolbar_item_priority_set(Elm_Toolbar_Item *item, int priority)
|
|
|
|
{
|
|
|
|
if (!item) return;
|
|
|
|
if (item->prio.priority == priority) return;
|
|
|
|
item->prio.priority = priority;
|
|
|
|
_resize(item->base.widget, NULL, NULL, NULL);
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Gets the priority of a toolbar item.
|
|
|
|
*
|
|
|
|
* @param item The toolbar item.
|
|
|
|
* @return The item priority, or 0 if an error occurred.
|
|
|
|
*
|
|
|
|
* @ingroup Toolbar
|
|
|
|
*/
|
|
|
|
EAPI int
|
|
|
|
elm_toolbar_item_priority_get(Elm_Toolbar_Item *item)
|
|
|
|
{
|
|
|
|
if (!item) return 0;
|
|
|
|
return item->prio.priority;
|
|
|
|
}
|
|
|
|
|
2010-04-12 01:12:02 -07:00
|
|
|
/**
|
|
|
|
* Get the icon associated with @p item.
|
|
|
|
*
|
|
|
|
* @param item The toolbar item
|
|
|
|
* @return The icon object
|
|
|
|
*
|
|
|
|
* @ingroup Toolbar
|
|
|
|
*/
|
2009-08-12 15:37:48 -07:00
|
|
|
EAPI Evas_Object *
|
|
|
|
elm_toolbar_item_icon_get(Elm_Toolbar_Item *item)
|
|
|
|
{
|
|
|
|
if (!item) return NULL;
|
|
|
|
return item->icon;
|
|
|
|
}
|
|
|
|
|
2010-10-14 15:21:40 -07:00
|
|
|
/**
|
|
|
|
* Get the icon name associated with @p item.
|
|
|
|
*
|
|
|
|
* @param item The toolbar item
|
|
|
|
* @return The icon name
|
|
|
|
*
|
|
|
|
* @ingroup Toolbar
|
|
|
|
*/
|
|
|
|
EAPI const char *
|
|
|
|
elm_toolbar_item_icon_name_get(Elm_Toolbar_Item *item)
|
|
|
|
{
|
|
|
|
if (!item) return NULL;
|
|
|
|
return item->icon_str;
|
|
|
|
}
|
|
|
|
|
2010-04-12 01:12:02 -07:00
|
|
|
/**
|
|
|
|
* Get the label associated with @p item.
|
|
|
|
*
|
|
|
|
* @param item The toolbar item
|
|
|
|
* @return The label
|
|
|
|
*
|
|
|
|
* @ingroup Toolbar
|
|
|
|
*/
|
2009-08-12 15:37:48 -07:00
|
|
|
EAPI const char *
|
2010-03-31 09:38:37 -07:00
|
|
|
elm_toolbar_item_label_get(const Elm_Toolbar_Item *item)
|
2009-08-12 15:37:48 -07:00
|
|
|
{
|
|
|
|
if (!item) return NULL;
|
|
|
|
return item->label;
|
|
|
|
}
|
|
|
|
|
2010-04-12 01:12:02 -07:00
|
|
|
/**
|
|
|
|
* Get the selected state of @p item.
|
|
|
|
*
|
|
|
|
* @param item The toolbar item
|
|
|
|
* @return If true, the item is selected
|
|
|
|
*
|
|
|
|
* @ingroup Toolbar
|
|
|
|
*/
|
2010-03-31 09:38:37 -07:00
|
|
|
EAPI Eina_Bool
|
|
|
|
elm_toolbar_item_selected_get(const Elm_Toolbar_Item *item)
|
|
|
|
{
|
|
|
|
if (!item) return EINA_FALSE;
|
|
|
|
return item->selected;
|
|
|
|
}
|
|
|
|
|
2010-04-12 01:12:02 -07:00
|
|
|
/**
|
|
|
|
* Set the label associated with @p item.
|
|
|
|
*
|
|
|
|
* @param item The toolbar item
|
|
|
|
* @param label The label of @p item
|
|
|
|
*
|
|
|
|
* @ingroup Toolbar
|
|
|
|
*/
|
2009-10-06 13:14:46 -07:00
|
|
|
EAPI void
|
|
|
|
elm_toolbar_item_label_set(Elm_Toolbar_Item *item, const char *label)
|
2009-08-25 16:47:08 -07:00
|
|
|
{
|
2009-11-09 18:03:52 -08:00
|
|
|
Evas_Coord mw = -1, mh = -1;
|
|
|
|
|
2009-08-25 16:47:08 -07:00
|
|
|
if (!item) return;
|
2010-03-13 13:01:26 -08:00
|
|
|
eina_stringshare_replace(&item->label, label);
|
2010-09-09 19:05:45 -07:00
|
|
|
edje_object_part_text_set(item->base.view, "elm.text", item->label);
|
2009-10-30 07:10:41 -07:00
|
|
|
|
|
|
|
elm_coords_finger_size_adjust(1, &mw, 1, &mh);
|
2010-09-09 19:05:45 -07:00
|
|
|
edje_object_size_min_restricted_calc(item->base.view, &mw, &mh, mw, mh);
|
2009-10-30 07:10:41 -07:00
|
|
|
elm_coords_finger_size_adjust(1, &mw, 1, &mh);
|
2010-09-09 19:05:45 -07:00
|
|
|
evas_object_size_hint_weight_set(item->base.view, -1.0, EVAS_HINT_EXPAND);
|
|
|
|
evas_object_size_hint_align_set(item->base.view, 0.5, EVAS_HINT_FILL);
|
|
|
|
evas_object_size_hint_min_set(item->base.view, mw, mh);
|
2009-08-25 16:47:08 -07:00
|
|
|
}
|
|
|
|
|
2010-04-12 01:12:02 -07:00
|
|
|
|
|
|
|
/**
|
|
|
|
* Delete a toolbar item.
|
|
|
|
*
|
|
|
|
* @param it The toolbar item
|
|
|
|
*
|
|
|
|
* @ingroup Toolbar
|
|
|
|
*/
|
2008-12-18 05:38:58 -08:00
|
|
|
EAPI void
|
2009-02-25 07:54:26 -08:00
|
|
|
elm_toolbar_item_del(Elm_Toolbar_Item *it)
|
2008-12-18 05:38:58 -08:00
|
|
|
{
|
2010-10-15 06:41:56 -07:00
|
|
|
Widget_Data *wd;
|
|
|
|
Evas_Object *obj2;
|
2009-08-25 15:46:19 -07:00
|
|
|
|
2010-10-15 06:41:56 -07:00
|
|
|
if ((!it) || (!it->base.widget)) return;
|
|
|
|
wd = elm_widget_data_get(it->base.widget);
|
|
|
|
if (!wd) return;
|
|
|
|
obj2 = it->base.widget;
|
2010-09-09 19:05:45 -07:00
|
|
|
elm_widget_item_pre_notify_del(it);
|
2008-12-18 20:26:24 -08:00
|
|
|
wd->items = eina_list_remove(wd->items, it);
|
|
|
|
eina_stringshare_del(it->label);
|
2010-10-14 08:27:31 -07:00
|
|
|
eina_stringshare_del(it->icon_str);
|
2008-12-18 20:26:24 -08:00
|
|
|
if (it->icon) evas_object_del(it->icon);
|
2010-09-09 19:05:45 -07:00
|
|
|
elm_widget_item_del(it);
|
2008-12-18 20:26:24 -08:00
|
|
|
_theme_hook(obj2);
|
2008-12-18 05:38:58 -08:00
|
|
|
}
|
|
|
|
|
2009-11-21 08:21:35 -08:00
|
|
|
/**
|
|
|
|
* Set the function called when a toolbar item is freed.
|
|
|
|
*
|
|
|
|
* @param it The item to set the callback on
|
|
|
|
* @param func The function called
|
|
|
|
*
|
2010-01-17 02:33:22 -08:00
|
|
|
* @ingroup Toolbar
|
2009-11-21 08:21:35 -08:00
|
|
|
*/
|
|
|
|
EAPI void
|
2010-03-16 08:31:38 -07:00
|
|
|
elm_toolbar_item_del_cb_set(Elm_Toolbar_Item *it, Evas_Smart_Cb func)
|
2009-11-21 08:21:35 -08:00
|
|
|
{
|
2010-09-09 19:05:45 -07:00
|
|
|
elm_widget_item_del_cb_set(it, func);
|
2009-11-21 08:21:35 -08:00
|
|
|
}
|
|
|
|
|
2010-04-12 01:12:02 -07:00
|
|
|
/**
|
|
|
|
* Select the toolbar item @p item.
|
|
|
|
*
|
|
|
|
* @param item The toolbar item
|
|
|
|
*
|
|
|
|
* @ingroup Toolbar
|
|
|
|
*/
|
2008-12-18 05:38:58 -08:00
|
|
|
EAPI void
|
|
|
|
elm_toolbar_item_select(Elm_Toolbar_Item *item)
|
|
|
|
{
|
2009-08-30 09:33:03 -07:00
|
|
|
if (!item) return;
|
2008-12-18 20:26:24 -08:00
|
|
|
_item_select(item);
|
2008-12-18 05:38:58 -08:00
|
|
|
}
|
|
|
|
|
2010-04-12 01:12:02 -07:00
|
|
|
/**
|
|
|
|
* Get the disabled state of @p item.
|
|
|
|
*
|
|
|
|
* @param item The toolbar item
|
|
|
|
* @return If true, the item is disabled
|
|
|
|
*
|
|
|
|
* @ingroup Toolbar
|
|
|
|
*/
|
2009-10-06 13:14:46 -07:00
|
|
|
EAPI Eina_Bool
|
|
|
|
elm_toolbar_item_disabled_get(Elm_Toolbar_Item *item)
|
2009-08-25 15:46:19 -07:00
|
|
|
{
|
|
|
|
if (!item) return EINA_FALSE;
|
|
|
|
return item->disabled;
|
|
|
|
}
|
|
|
|
|
2010-04-12 01:12:02 -07:00
|
|
|
/**
|
|
|
|
* Set the disabled state of @p item.
|
|
|
|
*
|
|
|
|
* @param item The toolbar item
|
|
|
|
* @param disabled If true, the item is disabled
|
|
|
|
*
|
|
|
|
* @ingroup Toolbar
|
|
|
|
*/
|
2009-10-06 13:14:46 -07:00
|
|
|
EAPI void
|
|
|
|
elm_toolbar_item_disabled_set(Elm_Toolbar_Item *item, Eina_Bool disabled)
|
2009-08-25 15:46:19 -07:00
|
|
|
{
|
2009-08-25 17:49:38 -07:00
|
|
|
if (!item) return;
|
2009-08-25 15:46:19 -07:00
|
|
|
_item_disable(item, disabled);
|
|
|
|
}
|
|
|
|
|
2010-04-12 01:12:02 -07:00
|
|
|
/**
|
|
|
|
* Get the separator state of @p item.
|
|
|
|
*
|
|
|
|
* @param item The toolbar item
|
|
|
|
* @param separator If true, the item is a separator
|
|
|
|
*
|
|
|
|
* @ingroup Toolbar
|
|
|
|
*/
|
2009-10-06 13:14:46 -07:00
|
|
|
EAPI void
|
|
|
|
elm_toolbar_item_separator_set(Elm_Toolbar_Item *item, Eina_Bool separator)
|
2009-08-30 09:54:15 -07:00
|
|
|
{
|
|
|
|
if (!item) return;
|
|
|
|
if (item->separator == separator) return;
|
|
|
|
item->separator = separator;
|
2010-09-09 19:05:45 -07:00
|
|
|
_theme_hook(item->base.view);
|
2009-08-30 09:54:15 -07:00
|
|
|
}
|
|
|
|
|
2010-04-12 01:12:02 -07:00
|
|
|
/**
|
|
|
|
* Set the separator state of @p item.
|
|
|
|
*
|
|
|
|
* @param item The toolbar item
|
|
|
|
* @return If true, the item is a separator
|
|
|
|
*
|
|
|
|
* @ingroup Toolbar
|
|
|
|
*/
|
2009-10-06 13:14:46 -07:00
|
|
|
EAPI Eina_Bool
|
|
|
|
elm_toolbar_item_separator_get(Elm_Toolbar_Item *item)
|
2009-08-30 09:54:15 -07:00
|
|
|
{
|
|
|
|
if (!item) return EINA_FALSE;
|
|
|
|
return item->separator;
|
|
|
|
}
|
|
|
|
|
2010-04-12 01:12:02 -07:00
|
|
|
/**
|
[Elementary] Implement priority in Elm_Toolbar.
Toolbars can now be scrollable, non-scrollable, or hide icons selectively
according to a priority. This changed the API slightly, thus
elm_toolbar_scrollable_set(obj, 1)
Should be
elm_toolbar_mode_expand_set(obj, ELM_TOOLBAR_EXPAND_SCROLL)
Values for non-scrollable and scrollable remain the same, so if constants
aren't being used, just the function name should be changed.
The new mode, ELM_TOOLBAR_EXPAND_MENU, will create a menu of items when the
space isn't large enough to hold all the items. Which items will be kept on
the toolbar or which items will be added to the menu is controlled by the
priority of each item: higher ones will be kept if possible, lower ones will
be tratored on the first opportunity.
SVN revision: 53406
2010-10-14 08:27:25 -07:00
|
|
|
* Set the expand state of toolbar @p obj.
|
2010-04-12 01:12:02 -07:00
|
|
|
*
|
|
|
|
* @param obj The toolbar object
|
[Elementary] Implement priority in Elm_Toolbar.
Toolbars can now be scrollable, non-scrollable, or hide icons selectively
according to a priority. This changed the API slightly, thus
elm_toolbar_scrollable_set(obj, 1)
Should be
elm_toolbar_mode_expand_set(obj, ELM_TOOLBAR_EXPAND_SCROLL)
Values for non-scrollable and scrollable remain the same, so if constants
aren't being used, just the function name should be changed.
The new mode, ELM_TOOLBAR_EXPAND_MENU, will create a menu of items when the
space isn't large enough to hold all the items. Which items will be kept on
the toolbar or which items will be added to the menu is controlled by the
priority of each item: higher ones will be kept if possible, lower ones will
be tratored on the first opportunity.
SVN revision: 53406
2010-10-14 08:27:25 -07:00
|
|
|
* @param shrink_mode The toolbar won't scroll if ELM_TOOLBAR_SHRINK_NONE,
|
|
|
|
* will scroll if ELM_TOOLBAR_SHRINK_SCROLL, and will create a button to
|
|
|
|
* pop up excess elements with ELM_TOOLBAR_SHRINK_MENU.
|
2010-04-12 01:12:02 -07:00
|
|
|
*
|
|
|
|
* @ingroup Toolbar
|
|
|
|
*/
|
2008-12-18 05:38:58 -08:00
|
|
|
EAPI void
|
[Elementary] Implement priority in Elm_Toolbar.
Toolbars can now be scrollable, non-scrollable, or hide icons selectively
according to a priority. This changed the API slightly, thus
elm_toolbar_scrollable_set(obj, 1)
Should be
elm_toolbar_mode_expand_set(obj, ELM_TOOLBAR_EXPAND_SCROLL)
Values for non-scrollable and scrollable remain the same, so if constants
aren't being used, just the function name should be changed.
The new mode, ELM_TOOLBAR_EXPAND_MENU, will create a menu of items when the
space isn't large enough to hold all the items. Which items will be kept on
the toolbar or which items will be added to the menu is controlled by the
priority of each item: higher ones will be kept if possible, lower ones will
be tratored on the first opportunity.
SVN revision: 53406
2010-10-14 08:27:25 -07:00
|
|
|
elm_toolbar_mode_shrink_set(Evas_Object *obj, Elm_Toolbar_Shrink_Mode shrink_mode)
|
2008-12-18 05:38:58 -08:00
|
|
|
{
|
2010-03-08 22:15:39 -08:00
|
|
|
ELM_CHECK_WIDTYPE(obj, widtype);
|
2008-12-18 05:38:58 -08:00
|
|
|
Widget_Data *wd = elm_widget_data_get(obj);
|
2010-10-21 12:57:43 -07:00
|
|
|
Eina_Bool bounce;
|
2009-08-25 15:46:19 -07:00
|
|
|
|
2009-08-26 07:29:18 -07:00
|
|
|
if (!wd) return;
|
[Elementary] Implement priority in Elm_Toolbar.
Toolbars can now be scrollable, non-scrollable, or hide icons selectively
according to a priority. This changed the API slightly, thus
elm_toolbar_scrollable_set(obj, 1)
Should be
elm_toolbar_mode_expand_set(obj, ELM_TOOLBAR_EXPAND_SCROLL)
Values for non-scrollable and scrollable remain the same, so if constants
aren't being used, just the function name should be changed.
The new mode, ELM_TOOLBAR_EXPAND_MENU, will create a menu of items when the
space isn't large enough to hold all the items. Which items will be kept on
the toolbar or which items will be added to the menu is controlled by the
priority of each item: higher ones will be kept if possible, lower ones will
be tratored on the first opportunity.
SVN revision: 53406
2010-10-14 08:27:25 -07:00
|
|
|
wd->shrink_mode = shrink_mode;
|
2010-10-21 12:57:43 -07:00
|
|
|
bounce = _elm_config->thumbscroll_bounce_enable &&
|
|
|
|
(shrink_mode == ELM_TOOLBAR_SHRINK_SCROLL);
|
|
|
|
elm_smart_scroller_bounce_allow_set(wd->scr, bounce, EINA_FALSE);
|
[Elementary] Implement priority in Elm_Toolbar.
Toolbars can now be scrollable, non-scrollable, or hide icons selectively
according to a priority. This changed the API slightly, thus
elm_toolbar_scrollable_set(obj, 1)
Should be
elm_toolbar_mode_expand_set(obj, ELM_TOOLBAR_EXPAND_SCROLL)
Values for non-scrollable and scrollable remain the same, so if constants
aren't being used, just the function name should be changed.
The new mode, ELM_TOOLBAR_EXPAND_MENU, will create a menu of items when the
space isn't large enough to hold all the items. Which items will be kept on
the toolbar or which items will be added to the menu is controlled by the
priority of each item: higher ones will be kept if possible, lower ones will
be tratored on the first opportunity.
SVN revision: 53406
2010-10-14 08:27:25 -07:00
|
|
|
|
|
|
|
if (wd->more_item)
|
|
|
|
{
|
|
|
|
elm_toolbar_item_del(wd->more_item);
|
|
|
|
wd->more_item = NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (shrink_mode == ELM_TOOLBAR_SHRINK_MENU)
|
|
|
|
{
|
|
|
|
elm_smart_scroller_policy_set(wd->scr, ELM_SMART_SCROLLER_POLICY_OFF, ELM_SMART_SCROLLER_POLICY_OFF);
|
|
|
|
|
2010-10-14 08:27:31 -07:00
|
|
|
wd->more_item = elm_toolbar_item_add(obj, "more_menu", "More", NULL, NULL);
|
[Elementary] Implement priority in Elm_Toolbar.
Toolbars can now be scrollable, non-scrollable, or hide icons selectively
according to a priority. This changed the API slightly, thus
elm_toolbar_scrollable_set(obj, 1)
Should be
elm_toolbar_mode_expand_set(obj, ELM_TOOLBAR_EXPAND_SCROLL)
Values for non-scrollable and scrollable remain the same, so if constants
aren't being used, just the function name should be changed.
The new mode, ELM_TOOLBAR_EXPAND_MENU, will create a menu of items when the
space isn't large enough to hold all the items. Which items will be kept on
the toolbar or which items will be added to the menu is controlled by the
priority of each item: higher ones will be kept if possible, lower ones will
be tratored on the first opportunity.
SVN revision: 53406
2010-10-14 08:27:25 -07:00
|
|
|
elm_toolbar_item_priority_set(wd->more_item, INT_MAX);
|
|
|
|
}
|
|
|
|
else
|
|
|
|
elm_smart_scroller_policy_set(wd->scr, ELM_SMART_SCROLLER_POLICY_AUTO, ELM_SMART_SCROLLER_POLICY_OFF);
|
2008-12-18 05:38:58 -08:00
|
|
|
_sizing_eval(obj);
|
|
|
|
}
|
2009-09-30 03:53:08 -07:00
|
|
|
|
2010-04-26 22:43:54 -07:00
|
|
|
/**
|
[Elementary] Implement priority in Elm_Toolbar.
Toolbars can now be scrollable, non-scrollable, or hide icons selectively
according to a priority. This changed the API slightly, thus
elm_toolbar_scrollable_set(obj, 1)
Should be
elm_toolbar_mode_expand_set(obj, ELM_TOOLBAR_EXPAND_SCROLL)
Values for non-scrollable and scrollable remain the same, so if constants
aren't being used, just the function name should be changed.
The new mode, ELM_TOOLBAR_EXPAND_MENU, will create a menu of items when the
space isn't large enough to hold all the items. Which items will be kept on
the toolbar or which items will be added to the menu is controlled by the
priority of each item: higher ones will be kept if possible, lower ones will
be tratored on the first opportunity.
SVN revision: 53406
2010-10-14 08:27:25 -07:00
|
|
|
* Get the expand mode of toolbar @p obj.
|
2010-04-26 22:43:54 -07:00
|
|
|
*
|
|
|
|
* @param obj The toolbar object
|
[Elementary] Implement priority in Elm_Toolbar.
Toolbars can now be scrollable, non-scrollable, or hide icons selectively
according to a priority. This changed the API slightly, thus
elm_toolbar_scrollable_set(obj, 1)
Should be
elm_toolbar_mode_expand_set(obj, ELM_TOOLBAR_EXPAND_SCROLL)
Values for non-scrollable and scrollable remain the same, so if constants
aren't being used, just the function name should be changed.
The new mode, ELM_TOOLBAR_EXPAND_MENU, will create a menu of items when the
space isn't large enough to hold all the items. Which items will be kept on
the toolbar or which items will be added to the menu is controlled by the
priority of each item: higher ones will be kept if possible, lower ones will
be tratored on the first opportunity.
SVN revision: 53406
2010-10-14 08:27:25 -07:00
|
|
|
* @return See elm_toolbar_mode_shrink_set.
|
2010-04-26 22:43:54 -07:00
|
|
|
*
|
|
|
|
* @ingroup Toolbar
|
|
|
|
*/
|
[Elementary] Implement priority in Elm_Toolbar.
Toolbars can now be scrollable, non-scrollable, or hide icons selectively
according to a priority. This changed the API slightly, thus
elm_toolbar_scrollable_set(obj, 1)
Should be
elm_toolbar_mode_expand_set(obj, ELM_TOOLBAR_EXPAND_SCROLL)
Values for non-scrollable and scrollable remain the same, so if constants
aren't being used, just the function name should be changed.
The new mode, ELM_TOOLBAR_EXPAND_MENU, will create a menu of items when the
space isn't large enough to hold all the items. Which items will be kept on
the toolbar or which items will be added to the menu is controlled by the
priority of each item: higher ones will be kept if possible, lower ones will
be tratored on the first opportunity.
SVN revision: 53406
2010-10-14 08:27:25 -07:00
|
|
|
EAPI Elm_Toolbar_Shrink_Mode
|
|
|
|
elm_toolbar_mode_shrink_get(Evas_Object *obj)
|
2010-04-26 22:43:54 -07:00
|
|
|
{
|
[Elementary] Implement priority in Elm_Toolbar.
Toolbars can now be scrollable, non-scrollable, or hide icons selectively
according to a priority. This changed the API slightly, thus
elm_toolbar_scrollable_set(obj, 1)
Should be
elm_toolbar_mode_expand_set(obj, ELM_TOOLBAR_EXPAND_SCROLL)
Values for non-scrollable and scrollable remain the same, so if constants
aren't being used, just the function name should be changed.
The new mode, ELM_TOOLBAR_EXPAND_MENU, will create a menu of items when the
space isn't large enough to hold all the items. Which items will be kept on
the toolbar or which items will be added to the menu is controlled by the
priority of each item: higher ones will be kept if possible, lower ones will
be tratored on the first opportunity.
SVN revision: 53406
2010-10-14 08:27:25 -07:00
|
|
|
ELM_CHECK_WIDTYPE(obj, widtype) ELM_TOOLBAR_SHRINK_NONE;
|
2010-04-26 22:43:54 -07:00
|
|
|
Widget_Data *wd = elm_widget_data_get(obj);
|
|
|
|
|
[Elementary] Implement priority in Elm_Toolbar.
Toolbars can now be scrollable, non-scrollable, or hide icons selectively
according to a priority. This changed the API slightly, thus
elm_toolbar_scrollable_set(obj, 1)
Should be
elm_toolbar_mode_expand_set(obj, ELM_TOOLBAR_EXPAND_SCROLL)
Values for non-scrollable and scrollable remain the same, so if constants
aren't being used, just the function name should be changed.
The new mode, ELM_TOOLBAR_EXPAND_MENU, will create a menu of items when the
space isn't large enough to hold all the items. Which items will be kept on
the toolbar or which items will be added to the menu is controlled by the
priority of each item: higher ones will be kept if possible, lower ones will
be tratored on the first opportunity.
SVN revision: 53406
2010-10-14 08:27:25 -07:00
|
|
|
if (!wd) return ELM_TOOLBAR_SHRINK_NONE;
|
|
|
|
return wd->shrink_mode;
|
2010-04-26 22:43:54 -07:00
|
|
|
}
|
|
|
|
|
2010-04-12 01:12:02 -07:00
|
|
|
/**
|
|
|
|
* Set the homogenous mode of toolbar @p obj.
|
|
|
|
*
|
|
|
|
* @param obj The toolbar object
|
|
|
|
* @param homogenous If true, the toolbar items will be uniform in size
|
|
|
|
*
|
|
|
|
* @ingroup Toolbar
|
|
|
|
*/
|
2009-09-30 03:53:08 -07:00
|
|
|
EAPI void
|
|
|
|
elm_toolbar_homogenous_set(Evas_Object *obj, Eina_Bool homogenous)
|
|
|
|
{
|
2010-03-08 22:15:39 -08:00
|
|
|
ELM_CHECK_WIDTYPE(obj, widtype);
|
2009-09-30 03:53:08 -07:00
|
|
|
Widget_Data *wd = elm_widget_data_get(obj);
|
|
|
|
|
|
|
|
if (!wd) return;
|
2009-10-02 12:22:40 -07:00
|
|
|
wd->homogeneous = !!homogenous;
|
|
|
|
evas_object_smart_calculate(wd->bx);
|
2009-09-30 03:53:08 -07:00
|
|
|
}
|
|
|
|
|
2010-04-26 22:43:54 -07:00
|
|
|
/**
|
|
|
|
* Get the homogenous mode of toolbar @p obj.
|
|
|
|
*
|
|
|
|
* @param obj The toolbar object
|
|
|
|
* @return If true, the toolbar items are uniform in size
|
|
|
|
*
|
|
|
|
* @ingroup Toolbar
|
|
|
|
*/
|
|
|
|
EAPI Eina_Bool
|
|
|
|
elm_toolbar_homogenous_get(Evas_Object *obj)
|
|
|
|
{
|
2010-06-05 06:12:45 -07:00
|
|
|
ELM_CHECK_WIDTYPE(obj, widtype) EINA_FALSE;
|
2010-04-26 22:43:54 -07:00
|
|
|
Widget_Data *wd = elm_widget_data_get(obj);
|
|
|
|
|
2010-06-05 06:12:45 -07:00
|
|
|
if (!wd) return EINA_FALSE;
|
2010-04-26 22:43:54 -07:00
|
|
|
return wd->homogeneous;
|
|
|
|
}
|
|
|
|
|
2010-04-12 01:12:02 -07:00
|
|
|
/**
|
|
|
|
* Set the parent object of the toolbar menu
|
|
|
|
*
|
|
|
|
* @param obj The toolbar object
|
|
|
|
* @param parent The parent of the menu object
|
|
|
|
*
|
|
|
|
* @ingroup Toolbar
|
|
|
|
*/
|
2009-10-06 13:14:46 -07:00
|
|
|
EAPI void
|
2009-10-06 08:08:41 -07:00
|
|
|
elm_toolbar_menu_parent_set(Evas_Object *obj, Evas_Object *parent)
|
|
|
|
{
|
2009-10-18 10:20:18 -07:00
|
|
|
Eina_List *l;
|
|
|
|
Elm_Toolbar_Item *it;
|
2010-03-08 22:15:39 -08:00
|
|
|
ELM_CHECK_WIDTYPE(obj, widtype);
|
2009-10-18 10:20:18 -07:00
|
|
|
Widget_Data *wd = elm_widget_data_get(obj);
|
2009-10-07 10:11:41 -07:00
|
|
|
|
2009-10-18 10:20:18 -07:00
|
|
|
if ((!wd) || (!parent)) return;
|
|
|
|
wd->menu_parent = parent;
|
|
|
|
EINA_LIST_FOREACH(wd->items, l, it)
|
|
|
|
{
|
2009-10-11 06:37:01 -07:00
|
|
|
if (it->o_menu)
|
2009-10-18 10:20:18 -07:00
|
|
|
elm_menu_parent_set(it->o_menu, wd->menu_parent);
|
|
|
|
}
|
2009-10-06 08:08:41 -07:00
|
|
|
}
|
|
|
|
|
2010-04-26 22:43:54 -07:00
|
|
|
/**
|
|
|
|
* Get the parent object of the toolbar menu
|
|
|
|
*
|
|
|
|
* @param obj The toolbar object
|
|
|
|
* @return The parent of the menu object
|
|
|
|
*
|
|
|
|
* @ingroup Toolbar
|
|
|
|
*/
|
|
|
|
EAPI Evas_Object *
|
2010-10-14 11:18:34 -07:00
|
|
|
elm_toolbar_menu_parent_get(const Evas_Object *obj)
|
2010-04-26 22:43:54 -07:00
|
|
|
{
|
|
|
|
ELM_CHECK_WIDTYPE(obj, widtype) NULL;
|
|
|
|
Widget_Data *wd = elm_widget_data_get(obj);
|
|
|
|
|
2010-10-14 11:18:34 -07:00
|
|
|
if (!wd) return NULL;
|
2010-04-26 22:43:54 -07:00
|
|
|
return wd->menu_parent;
|
|
|
|
}
|
|
|
|
|
2010-04-12 01:12:02 -07:00
|
|
|
/**
|
|
|
|
* Unselect all of the items in the toolbar.
|
|
|
|
*
|
|
|
|
* @param obj The toolbar object
|
|
|
|
*
|
|
|
|
* @ingroup Toolbar
|
|
|
|
*/
|
2009-10-06 13:14:46 -07:00
|
|
|
EAPI void
|
2009-10-06 11:18:21 -07:00
|
|
|
elm_toolbar_item_unselect_all(Evas_Object *obj)
|
|
|
|
{
|
2009-10-18 10:20:18 -07:00
|
|
|
Eina_List *l;
|
|
|
|
Elm_Toolbar_Item *it;
|
2010-03-08 22:15:39 -08:00
|
|
|
ELM_CHECK_WIDTYPE(obj, widtype);
|
2009-10-18 10:20:18 -07:00
|
|
|
Widget_Data *wd = elm_widget_data_get(obj);
|
|
|
|
|
|
|
|
if (!wd) return;
|
|
|
|
EINA_LIST_FOREACH(wd->items, l, it)
|
|
|
|
{
|
2009-10-06 11:18:21 -07:00
|
|
|
if (it->selected)
|
2009-10-18 10:20:18 -07:00
|
|
|
{
|
|
|
|
it->selected = EINA_FALSE;
|
2010-09-09 19:05:45 -07:00
|
|
|
edje_object_signal_emit
|
|
|
|
(it->base.view, "elm,state,unselected", "elm");
|
2009-10-18 10:20:18 -07:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
2009-10-06 11:18:21 -07:00
|
|
|
}
|
2009-10-06 08:08:41 -07:00
|
|
|
|
2010-05-27 02:01:41 -07:00
|
|
|
/**
|
|
|
|
* Unselect the specified toolbar item.
|
|
|
|
*
|
|
|
|
* @param item The toolbar item
|
|
|
|
*
|
|
|
|
* @ingroup Toolbar
|
|
|
|
*/
|
|
|
|
EAPI void
|
|
|
|
elm_toolbar_item_unselect(Elm_Toolbar_Item *item)
|
|
|
|
{
|
|
|
|
if ((!item) || (!item->selected)) return;
|
|
|
|
item->selected = EINA_FALSE;
|
2010-09-09 19:05:45 -07:00
|
|
|
edje_object_signal_emit(item->base.view, "elm,state,unselected", "elm");
|
2010-05-27 02:01:41 -07:00
|
|
|
}
|
|
|
|
|
2009-10-06 13:14:46 -07:00
|
|
|
/**
|
2010-04-12 01:12:02 -07:00
|
|
|
* Set the alignment of the items.
|
2009-10-06 13:14:46 -07:00
|
|
|
*
|
|
|
|
* @param obj The toolbar object
|
2009-10-22 15:10:23 -07:00
|
|
|
* @param align The new alignment. (left) 0.0 ... 1.0 (right)
|
2010-04-12 01:12:02 -07:00
|
|
|
*
|
|
|
|
* @ingroup Toolbar
|
2009-10-06 13:14:46 -07:00
|
|
|
*/
|
|
|
|
EAPI void
|
|
|
|
elm_toolbar_align_set(Evas_Object *obj, double align)
|
|
|
|
{
|
2010-03-08 22:15:39 -08:00
|
|
|
ELM_CHECK_WIDTYPE(obj, widtype);
|
2009-10-18 10:20:18 -07:00
|
|
|
Widget_Data *wd = elm_widget_data_get(obj);
|
2009-10-06 13:14:46 -07:00
|
|
|
|
2009-10-18 10:20:18 -07:00
|
|
|
if (!wd) return;
|
2010-03-09 03:42:53 -08:00
|
|
|
if (wd->align != align)
|
2009-10-18 10:20:18 -07:00
|
|
|
evas_object_size_hint_align_set(wd->bx, align, 0.5);
|
2010-03-09 03:42:53 -08:00
|
|
|
wd->align = align;
|
2009-10-06 13:14:46 -07:00
|
|
|
}
|
|
|
|
|
2010-04-12 01:12:02 -07:00
|
|
|
/**
|
|
|
|
* Get the alignment of the items.
|
|
|
|
*
|
|
|
|
* @param obj The toolbar object
|
|
|
|
* @return The alignment. (left) 0.0 ... 1.0 (right)
|
|
|
|
*
|
|
|
|
* @ingroup Toolbar
|
|
|
|
*/
|
2010-03-30 13:42:01 -07:00
|
|
|
EAPI double
|
|
|
|
elm_toolbar_align_get(const Evas_Object *obj)
|
|
|
|
{
|
|
|
|
ELM_CHECK_WIDTYPE(obj, widtype) 0.0;
|
|
|
|
Widget_Data *wd = elm_widget_data_get(obj);
|
|
|
|
|
|
|
|
if (!wd) return 0.0;
|
|
|
|
return wd->align;
|
|
|
|
}
|
|
|
|
|
2010-04-12 01:12:02 -07:00
|
|
|
/**
|
|
|
|
* Set whether the toolbar item opens a menu.
|
|
|
|
*
|
|
|
|
* @param item The toolbar item
|
|
|
|
* @param menu If true, @p item will open a menu when selected
|
|
|
|
*
|
|
|
|
* @ingroup Toolbar
|
|
|
|
*/
|
2009-10-06 13:14:46 -07:00
|
|
|
EAPI void
|
|
|
|
elm_toolbar_item_menu_set(Elm_Toolbar_Item *item, Eina_Bool menu)
|
2009-10-06 08:08:41 -07:00
|
|
|
{
|
2010-09-09 19:05:45 -07:00
|
|
|
Widget_Data *wd = elm_widget_data_get(item->base.widget);
|
2009-10-18 10:20:18 -07:00
|
|
|
|
|
|
|
if ((!wd) || (!item)) return;
|
2009-10-06 08:08:41 -07:00
|
|
|
if (item->menu == menu) return;
|
|
|
|
item->menu = menu;
|
[Elementary] Implement priority in Elm_Toolbar.
Toolbars can now be scrollable, non-scrollable, or hide icons selectively
according to a priority. This changed the API slightly, thus
elm_toolbar_scrollable_set(obj, 1)
Should be
elm_toolbar_mode_expand_set(obj, ELM_TOOLBAR_EXPAND_SCROLL)
Values for non-scrollable and scrollable remain the same, so if constants
aren't being used, just the function name should be changed.
The new mode, ELM_TOOLBAR_EXPAND_MENU, will create a menu of items when the
space isn't large enough to hold all the items. Which items will be kept on
the toolbar or which items will be added to the menu is controlled by the
priority of each item: higher ones will be kept if possible, lower ones will
be tratored on the first opportunity.
SVN revision: 53406
2010-10-14 08:27:25 -07:00
|
|
|
if (menu) _item_menu_create(wd, item);
|
|
|
|
else _item_menu_destroy(item);
|
2009-10-06 08:08:41 -07:00
|
|
|
}
|
|
|
|
|
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
|
|
|
/**
|
|
|
|
* Set the text to be shown in the toolbar item.
|
|
|
|
*
|
|
|
|
* @param item Target item
|
|
|
|
* @param text The text to set in the content
|
|
|
|
*
|
|
|
|
* Setup the text as tooltip to object. The item can have only one tooltip,
|
|
|
|
* so any previous tooltip data is removed.
|
|
|
|
*
|
|
|
|
* @ingroup Toolbar
|
|
|
|
*/
|
|
|
|
EAPI void
|
|
|
|
elm_toolbar_item_tooltip_text_set(Elm_Toolbar_Item *item, const char *text)
|
|
|
|
{
|
|
|
|
elm_widget_item_tooltip_text_set(item, text);
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Set the content to be shown in the tooltip item
|
|
|
|
*
|
|
|
|
* Setup the tooltip to item. The item can have only one tooltip,
|
|
|
|
* so any previous tooltip data is removed. @p func(with @p data) will
|
|
|
|
* be called every time that need show the tooltip and it should
|
|
|
|
* return a valid Evas_Object. This object is then managed fully by
|
|
|
|
* tooltip system and is deleted when the tooltip is gone.
|
|
|
|
*
|
|
|
|
* @param item the toolbar item being attached a tooltip.
|
|
|
|
* @param func the function used to create the tooltip contents.
|
|
|
|
* @param data what to provide to @a func as callback data/context.
|
|
|
|
* @param del_cb called when data is not needed anymore, either when
|
|
|
|
* another callback replaces @func, the tooltip is unset with
|
|
|
|
* elm_toolbar_item_tooltip_unset() or the owner @a item
|
|
|
|
* dies. This callback receives as the first parameter the
|
|
|
|
* given @a data, and @c event_info is the item.
|
|
|
|
*
|
|
|
|
* @ingroup Toolbar
|
|
|
|
*/
|
|
|
|
EAPI void
|
|
|
|
elm_toolbar_item_tooltip_content_cb_set(Elm_Toolbar_Item *item, Elm_Tooltip_Item_Content_Cb func, const void *data, Evas_Smart_Cb del_cb)
|
|
|
|
{
|
|
|
|
elm_widget_item_tooltip_content_cb_set(item, func, data, del_cb);
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Unset tooltip from item
|
|
|
|
*
|
|
|
|
* @param item toolbar item to remove previously set tooltip.
|
|
|
|
*
|
|
|
|
* Remove tooltip from item. The callback provided as del_cb to
|
|
|
|
* elm_toolbar_item_tooltip_content_cb_set() will be called to notify
|
|
|
|
* it is not used anymore.
|
|
|
|
*
|
|
|
|
* @see elm_toolbar_item_tooltip_content_cb_set()
|
|
|
|
*
|
|
|
|
* @ingroup Toolbar
|
|
|
|
*/
|
|
|
|
EAPI void
|
|
|
|
elm_toolbar_item_tooltip_unset(Elm_Toolbar_Item *item)
|
|
|
|
{
|
|
|
|
elm_widget_item_tooltip_unset(item);
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Sets a different style for this item tooltip.
|
|
|
|
*
|
|
|
|
* @note before you set a style you should define a tooltip with
|
|
|
|
* elm_toolbar_item_tooltip_content_cb_set() or
|
|
|
|
* elm_toolbar_item_tooltip_text_set()
|
|
|
|
*
|
|
|
|
* @param item toolbar item with tooltip already set.
|
|
|
|
* @param style the theme style to use (default, transparent, ...)
|
|
|
|
*
|
|
|
|
* @ingroup Toolbar
|
|
|
|
*/
|
|
|
|
EAPI void
|
|
|
|
elm_toolbar_item_tooltip_style_set(Elm_Toolbar_Item *item, const char *style)
|
|
|
|
{
|
|
|
|
elm_widget_item_tooltip_style_set(item, style);
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Get the style for this item tooltip.
|
|
|
|
*
|
|
|
|
* @param item toolbar item with tooltip already set.
|
|
|
|
* @return style the theme style in use, defaults to "default". If the
|
|
|
|
* object does not have a tooltip set, then NULL is returned.
|
|
|
|
*
|
|
|
|
* @ingroup Toolbar
|
|
|
|
*/
|
|
|
|
EAPI const char *
|
|
|
|
elm_toolbar_item_tooltip_style_get(const Elm_Toolbar_Item *item)
|
|
|
|
{
|
|
|
|
return elm_widget_item_tooltip_style_get(item);
|
|
|
|
}
|
2010-04-12 01:12:02 -07:00
|
|
|
|
2010-09-17 11:24:10 -07:00
|
|
|
/**
|
|
|
|
* Set the cursor to be shown when mouse is over the toolbar item
|
|
|
|
*
|
|
|
|
* @param item Target item
|
|
|
|
* @param cursor the cursor name to be used.
|
|
|
|
*
|
|
|
|
* @see elm_object_cursor_set()
|
|
|
|
* @ingroup Toolbar
|
|
|
|
*/
|
|
|
|
EAPI void
|
|
|
|
elm_toolbar_item_cursor_set(Elm_Toolbar_Item *item, const char *cursor)
|
|
|
|
{
|
|
|
|
elm_widget_item_cursor_set(item, cursor);
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Unset the cursor to be shown when mouse is over the toolbar item
|
|
|
|
*
|
|
|
|
* @param item Target item
|
|
|
|
*
|
|
|
|
* @see elm_object_cursor_unset()
|
|
|
|
* @ingroup Toolbar
|
|
|
|
*/
|
|
|
|
EAPI void
|
|
|
|
elm_toolbar_item_cursor_unset(Elm_Toolbar_Item *item)
|
|
|
|
{
|
|
|
|
elm_widget_item_cursor_unset(item);
|
|
|
|
}
|
|
|
|
|
2010-09-25 15:01:19 -07:00
|
|
|
/**
|
|
|
|
* Sets a different style for this item cursor.
|
|
|
|
*
|
|
|
|
* @note before you set a style you should define a cursor with
|
|
|
|
* elm_toolbar_item_cursor_set()
|
|
|
|
*
|
|
|
|
* @param item toolbar item with cursor already set.
|
|
|
|
* @param style the theme style to use (default, transparent, ...)
|
|
|
|
*
|
|
|
|
* @ingroup Toolbar
|
|
|
|
*/
|
|
|
|
EAPI void
|
|
|
|
elm_toolbar_item_cursor_style_set(Elm_Toolbar_Item *item, const char *style)
|
|
|
|
{
|
|
|
|
elm_widget_item_cursor_style_set(item, style);
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Get the style for this item cursor.
|
|
|
|
*
|
|
|
|
* @param item toolbar item with cursor already set.
|
|
|
|
* @return style the theme style in use, defaults to "default". If the
|
|
|
|
* object does not have a cursor set, then NULL is returned.
|
|
|
|
*
|
|
|
|
* @ingroup Toolbar
|
|
|
|
*/
|
|
|
|
EAPI const char *
|
|
|
|
elm_toolbar_item_cursor_style_get(const Elm_Toolbar_Item *item)
|
|
|
|
{
|
|
|
|
return elm_widget_item_cursor_style_get(item);
|
|
|
|
}
|
|
|
|
|
2010-09-25 15:03:37 -07:00
|
|
|
/**
|
|
|
|
* Set if the cursor set should be searched on the theme or should use
|
|
|
|
* the provided by the engine, only.
|
|
|
|
*
|
|
|
|
* @note before you set if should look on theme you should define a cursor
|
|
|
|
* with elm_object_cursor_set(). By default it will only look for cursors
|
|
|
|
* provided by the engine.
|
|
|
|
*
|
|
|
|
* @param item widget item with cursor already set.
|
|
|
|
* @param engine_only boolean to define it cursors should be looked only
|
|
|
|
* between the provided by the engine or searched on widget's theme as well.
|
|
|
|
*
|
|
|
|
* @ingroup Toolbar
|
|
|
|
*/
|
|
|
|
EAPI void
|
|
|
|
elm_toolbar_item_cursor_engine_only_set(Elm_Toolbar_Item *item, Eina_Bool engine_only)
|
|
|
|
{
|
|
|
|
elm_widget_item_cursor_engine_only_set(item, engine_only);
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Get the cursor engine only usage for this item cursor.
|
|
|
|
*
|
|
|
|
* @param item widget item with cursor already set.
|
|
|
|
* @return engine_only boolean to define it cursors should be looked only
|
|
|
|
* between the provided by the engine or searched on widget's theme as well. If
|
|
|
|
* the object does not have a cursor set, then EINA_FALSE is returned.
|
|
|
|
*
|
|
|
|
* @ingroup Toolbar
|
|
|
|
*/
|
|
|
|
EAPI Eina_Bool
|
|
|
|
elm_toolbar_item_cursor_engine_only_get(const Elm_Toolbar_Item *item)
|
|
|
|
{
|
|
|
|
return elm_widget_item_cursor_engine_only_get(item);
|
|
|
|
}
|
|
|
|
|
2010-04-12 01:12:02 -07:00
|
|
|
/**
|
|
|
|
* Get whether the toolbar item opens a menu.
|
|
|
|
*
|
|
|
|
* @param item The toolbar item
|
|
|
|
* @return If true, @p item opens a menu when selected
|
|
|
|
*
|
|
|
|
* @ingroup Toolbar
|
|
|
|
*/
|
2009-10-18 10:20:18 -07:00
|
|
|
EAPI Evas_Object *
|
2009-10-11 06:37:01 -07:00
|
|
|
elm_toolbar_item_menu_get(Elm_Toolbar_Item *item)
|
2009-10-06 08:08:41 -07:00
|
|
|
{
|
2010-02-11 08:13:41 -08:00
|
|
|
if (!item) return NULL;
|
2010-09-09 19:05:45 -07:00
|
|
|
Widget_Data *wd = elm_widget_data_get(item->base.widget);
|
2010-02-11 08:13:41 -08:00
|
|
|
if (!wd) return NULL;
|
2009-10-11 06:37:01 -07:00
|
|
|
elm_toolbar_item_menu_set(item, 1);
|
|
|
|
return item->o_menu;
|
2009-10-06 08:08:41 -07:00
|
|
|
}
|
2010-04-26 22:43:54 -07:00
|
|
|
|
|
|
|
/**
|
|
|
|
* Return a list of all toolbar items.
|
|
|
|
*
|
|
|
|
* @param obj The toolbar object
|
|
|
|
*
|
|
|
|
* @return An Eina_List* of the toolbar items in @p obj
|
|
|
|
*
|
|
|
|
* @ingroup Toolbar
|
|
|
|
*/
|
|
|
|
EAPI Eina_List *
|
|
|
|
elm_toolbar_item_get_all(Evas_Object *obj)
|
|
|
|
{
|
|
|
|
ELM_CHECK_WIDTYPE(obj, widtype) NULL;
|
|
|
|
Widget_Data *wd = elm_widget_data_get(obj);
|
|
|
|
if (!wd) return NULL;
|
|
|
|
|
|
|
|
return wd->items;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Return the first toolbar item in the list of toolbar items.
|
|
|
|
*
|
|
|
|
* @param obj The toolbar object
|
|
|
|
*
|
|
|
|
* @return The first toolbar item, or NULL on failure
|
|
|
|
*
|
|
|
|
* @ingroup Toolbar
|
|
|
|
*/
|
|
|
|
EAPI Elm_Toolbar_Item *
|
|
|
|
elm_toolbar_item_get_first(Evas_Object *obj)
|
|
|
|
{
|
|
|
|
Elm_Toolbar_Item *it;
|
|
|
|
ELM_CHECK_WIDTYPE(obj, widtype) NULL;
|
|
|
|
Widget_Data *wd = elm_widget_data_get(obj);
|
|
|
|
if (!wd) return NULL;
|
|
|
|
if (!(it = eina_list_data_get(wd->items))) return NULL;
|
|
|
|
|
|
|
|
return it;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Return the last toolbar item in the list of toolbar items.
|
|
|
|
*
|
|
|
|
* @param obj The toolbar object
|
|
|
|
*
|
|
|
|
* @return The last toolbar item, or NULL on failure
|
|
|
|
*
|
|
|
|
* @ingroup Toolbar
|
|
|
|
*/
|
|
|
|
EAPI Elm_Toolbar_Item *
|
|
|
|
elm_toolbar_item_get_last(Evas_Object *obj)
|
|
|
|
{
|
2010-05-27 02:01:41 -07:00
|
|
|
Eina_List *last;
|
2010-04-26 22:43:54 -07:00
|
|
|
Elm_Toolbar_Item *it;
|
|
|
|
ELM_CHECK_WIDTYPE(obj, widtype) NULL;
|
|
|
|
Widget_Data *wd = elm_widget_data_get(obj);
|
|
|
|
if (!wd) return NULL;
|
|
|
|
if (!(last = eina_list_last(wd->items))) return NULL;
|
|
|
|
it = eina_list_data_get(last);
|
|
|
|
|
|
|
|
return it;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Return the next toolbar item (relative to the currently selected
|
|
|
|
* toolbar item) in the list of toolbar items.
|
|
|
|
*
|
|
|
|
* @param obj The toolbar object
|
|
|
|
*
|
|
|
|
* @return The next toolbar item, or NULL on failure
|
|
|
|
*
|
|
|
|
* @ingroup Toolbar
|
|
|
|
*/
|
|
|
|
EAPI Elm_Toolbar_Item *
|
|
|
|
elm_toolbar_item_get_next(Evas_Object *obj)
|
|
|
|
{
|
|
|
|
Eina_List *l, *l2;
|
|
|
|
Elm_Toolbar_Item *it, *next;
|
|
|
|
ELM_CHECK_WIDTYPE(obj, widtype) NULL;
|
|
|
|
Widget_Data *wd = elm_widget_data_get(obj);
|
|
|
|
|
|
|
|
if (!wd) return NULL;
|
|
|
|
EINA_LIST_FOREACH_SAFE(wd->items, l, l2, it)
|
|
|
|
{
|
|
|
|
if (it->selected)
|
|
|
|
{
|
|
|
|
if (!(next = eina_list_data_get(l2))) return NULL;
|
|
|
|
return next;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Selects the next non-disabled, non-separator toolbar item in the list
|
|
|
|
* of toolbar items.
|
|
|
|
*
|
|
|
|
* @param obj The toolbar object
|
|
|
|
*
|
|
|
|
* @return The newly selected toolbar item, or NULL on failure
|
|
|
|
*
|
|
|
|
* @ingroup Toolbar
|
|
|
|
*/
|
|
|
|
EAPI Elm_Toolbar_Item *
|
|
|
|
elm_toolbar_item_select_next(Evas_Object *obj)
|
|
|
|
{
|
|
|
|
Eina_List *l, *l2;
|
|
|
|
Elm_Toolbar_Item *it, *next;
|
|
|
|
ELM_CHECK_WIDTYPE(obj, widtype) NULL;
|
|
|
|
Widget_Data *wd = elm_widget_data_get(obj);
|
|
|
|
|
|
|
|
if (!wd) return NULL;
|
|
|
|
EINA_LIST_FOREACH(wd->items, l, it)
|
|
|
|
{
|
|
|
|
if (it->selected)
|
|
|
|
{
|
|
|
|
EINA_LIST_FOREACH(l, l2, next)
|
|
|
|
if ((!next->disabled) && (next->separator))
|
|
|
|
{
|
|
|
|
_item_select(next);
|
|
|
|
return next;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Selects the first non-disabled, non-separator toolbar item in the list
|
|
|
|
* of toolbar items.
|
|
|
|
*
|
|
|
|
* @param obj The toolbar object
|
|
|
|
*
|
|
|
|
* @return The newly selected toolbar item, or NULL on failure
|
|
|
|
*
|
|
|
|
* @ingroup Toolbar
|
|
|
|
*/
|
|
|
|
EAPI Elm_Toolbar_Item *
|
|
|
|
elm_toolbar_item_select_first(Evas_Object *obj)
|
|
|
|
{
|
|
|
|
Eina_List *l;
|
|
|
|
Elm_Toolbar_Item *it;
|
|
|
|
ELM_CHECK_WIDTYPE(obj, widtype) NULL;
|
|
|
|
Widget_Data *wd = elm_widget_data_get(obj);
|
|
|
|
if (!wd) return NULL;
|
|
|
|
EINA_LIST_FOREACH(wd->items, l, it)
|
|
|
|
{
|
|
|
|
if ((!it->disabled) && (!it->separator))
|
|
|
|
{
|
|
|
|
_item_select(it);
|
|
|
|
return it;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Selects the last non-disabled, non-separator toolbar item in the list
|
|
|
|
* of toolbar items.
|
|
|
|
*
|
|
|
|
* @param obj The toolbar object
|
|
|
|
*
|
|
|
|
* @return The newly selected toolbar item, or NULL on failure
|
|
|
|
*
|
|
|
|
* @ingroup Toolbar
|
|
|
|
*/
|
|
|
|
EAPI Elm_Toolbar_Item *
|
|
|
|
elm_toolbar_item_select_last(Evas_Object *obj)
|
|
|
|
{
|
|
|
|
Eina_List *l;
|
|
|
|
Elm_Toolbar_Item *it;
|
|
|
|
ELM_CHECK_WIDTYPE(obj, widtype) NULL;
|
|
|
|
Widget_Data *wd = elm_widget_data_get(obj);
|
|
|
|
if (!wd) return NULL;
|
|
|
|
EINA_LIST_REVERSE_FOREACH(wd->items, l, it)
|
|
|
|
{
|
|
|
|
if ((!it->disabled) && (!it->separator))
|
|
|
|
{
|
|
|
|
_item_select(it);
|
|
|
|
return it;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Returns a pointer to a toolbar item by its label
|
|
|
|
*
|
|
|
|
* @param obj The toolbar object
|
|
|
|
* @param label The label of the item to find
|
|
|
|
*
|
|
|
|
* @return The pointer to the toolbar item matching @p label
|
|
|
|
* Returns NULL on failure.
|
|
|
|
*
|
|
|
|
* @ingroup Toolbar
|
|
|
|
*/
|
|
|
|
EAPI Elm_Toolbar_Item *
|
|
|
|
elm_toolbar_item_find_by_label(Evas_Object *obj, const char *label)
|
|
|
|
{
|
|
|
|
Eina_List *l;
|
|
|
|
Elm_Toolbar_Item *it;
|
|
|
|
ELM_CHECK_WIDTYPE(obj, widtype) NULL;
|
|
|
|
Widget_Data *wd = elm_widget_data_get(obj);
|
|
|
|
|
|
|
|
if (!wd) return NULL;
|
|
|
|
EINA_LIST_FOREACH(wd->items, l, it)
|
|
|
|
{
|
|
|
|
if (!strcmp(it->label, label)) return it;
|
|
|
|
}
|
|
|
|
|
|
|
|
return NULL;
|
|
|
|
}
|