jf_simon
/
enlightenment_my
forked from enlightenment/enlightenment
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

e gadgets - as per email to e-devbel - it's easier to fix old so rm new 

new gadget infra--
This commit is contained in:
Carsten Haitzler 2020-07-07 23:34:27 +01:00
parent 3bbab5a22f
commit 0b1c4100ef
123 changed files with 126 additions and 35758 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

24
meson_options.txt
View File

@ -163,10 +163,6 @@ option('polkit',
type: 'boolean',
value: true,
description: 'enable polkit module: (default=true)')
option('luncher',
type: 'boolean',
value: true,
description: 'enable luncher module: (default=true)')
option('mixer',
type: 'boolean',
value: true,
@ -191,10 +187,6 @@ option('pager',
type: 'boolean',
value: true,
description: 'enable pager module: (default=true)')
option('pager-plain',
type: 'boolean',
value: true,
description: 'enable pager_plain module: (default=true)')
option('quickaccess',
type: 'boolean',
value: true,
@ -211,10 +203,6 @@ option('syscon',
type: 'boolean',
value: true,
description: 'enable syscon module: (default=true)')
option('sysinfo',
type: 'boolean',
value: true,
description: 'enable sysinfo module: (default=true)')
option('systray',
type: 'boolean',
value: true,
@ -223,10 +211,6 @@ option('tasks',
type: 'boolean',
value: true,
description: 'enable tasks module: (default=true)')
option('teamwork',
type: 'boolean',
value: true,
description: 'enable teamwork module: (default=true)')
option('temperature',
type: 'boolean',
value: true,
@ -235,18 +219,10 @@ option('tiling',
type: 'boolean',
value: true,
description: 'enable tiling module: (default=true)')
option('time',
type: 'boolean',
value: true,
description: 'enable time module: (default=true)')
option('winlist',
type: 'boolean',
value: true,
description: 'enable winlist module: (default=true)')
option('wireless',
type: 'boolean',
value: true,
description: 'enable wireless module: (default=true)')
option('wizard',
type: 'boolean',
value: true,

1488
src/bin/e_bryce.c
View File

File diff suppressed because it is too large Load Diff

22
src/bin/e_bryce.h
View File

@ -1,22 +0,0 @@
#ifndef E_TYPEDEFS
#ifndef E_BRYCE_H
# define E_BRYCE_H
EINTERN void e_bryce_init(void);
EINTERN void e_bryce_shutdown(void);
E_API Evas_Object *e_bryce_add(Evas_Object *parent, const char *name, E_Gadget_Site_Orient orient, E_Gadget_Site_Anchor an);
E_API void e_bryce_orient(Evas_Object *bryce, E_Gadget_Site_Orient orient, E_Gadget_Site_Anchor an);
E_API Evas_Object *e_bryce_site_get(Evas_Object *bryce);
E_API Eina_Bool e_bryce_autosize_get(Evas_Object *bryce);
E_API void e_bryce_autosize_set(Evas_Object *bryce, Eina_Bool set);
E_API Eina_Bool e_bryce_autohide_get(Evas_Object *bryce);
E_API void e_bryce_autohide_set(Evas_Object *bryce, Eina_Bool set);
E_API Eina_Bool e_bryce_exists(Evas_Object *parent, Evas_Object *bryce, E_Gadget_Site_Orient orient, E_Gadget_Site_Anchor an);
E_API Eina_List *e_bryce_list(Evas_Object *parent);
E_API void e_bryce_style_set(Evas_Object *bryce, const char *style);
E_API Evas_Object *e_bryce_editor_add(Evas_Object *parent, Evas_Object *bryce);
E_API Evas_Object *e_bryce_edit(Evas_Object *bryce);
#endif
#endif

444
src/bin/e_bryce_editor.c
View File

@ -1,444 +0,0 @@
#include "e.h"
#define DEFAULT_AUTOSIZE EINA_TRUE
#define DEFAULT_AUTOHIDE EINA_FALSE
#define DEFAULT_LAYER E_LAYER_CLIENT_EDGE
typedef struct Bryce_Info
{
E_Gadget_Site_Anchor anchor;
E_Gadget_Site_Orient orient;
Eina_Stringshare *style;
Eina_Bool stack_under;
Eina_Bool autohide;
Eina_Bool autosize;
} Bryce_Info;
static void _editor_add_bottom(void *data, Evas_Object *obj, const char *sig, const char *src);
static void _editor_add_top(void *data, Evas_Object *obj, const char *sig, const char *src);
static void _editor_add_left(void *data, Evas_Object *obj, const char *sig, const char *src);
static void _editor_add_right(void *data, Evas_Object *obj, const char *sig, const char *src);
static void
setup_exists(Evas_Object *bryce, Evas_Object *editor, Evas_Object *parent, E_Gadget_Site_Anchor an)
{
if ((an != E_GADGET_SITE_ANCHOR_TOP) &&
e_bryce_exists(parent, bryce, E_GADGET_SITE_ORIENT_HORIZONTAL, E_GADGET_SITE_ANCHOR_BOTTOM | an))
elm_object_signal_emit(editor, "e,bryce,exists,bottom", "e");
if ((an != E_GADGET_SITE_ANCHOR_BOTTOM) &&
e_bryce_exists(parent, bryce, E_GADGET_SITE_ORIENT_HORIZONTAL, E_GADGET_SITE_ANCHOR_TOP | an))
elm_object_signal_emit(editor, "e,bryce,exists,top", "e");
if ((an != E_GADGET_SITE_ANCHOR_RIGHT) &&
e_bryce_exists(parent, bryce, E_GADGET_SITE_ORIENT_VERTICAL, E_GADGET_SITE_ANCHOR_LEFT | an))
elm_object_signal_emit(editor, "e,bryce,exists,left", "e");
if ((an != E_GADGET_SITE_ANCHOR_LEFT) &&
e_bryce_exists(parent, bryce, E_GADGET_SITE_ORIENT_VERTICAL, E_GADGET_SITE_ANCHOR_RIGHT | an))
elm_object_signal_emit(editor, "e,bryce,exists,right", "e");
}
static void
_editor_bryce_add(Evas_Object *obj)
{
Evas_Object *b, *site;
char buf[1024];
const char *loc = "", *loc2 = "";
Bryce_Info *bi;
E_Zone *zone;
E_Gadget_Site_Gravity gravity = E_GADGET_SITE_GRAVITY_CENTER;
bi = evas_object_data_get(obj, "__bryce_info");
b = evas_object_data_get(obj, "__bryce_editor_bryce");
if (bi->anchor & E_GADGET_SITE_ANCHOR_TOP)
loc = "top";
else if (bi->anchor & E_GADGET_SITE_ANCHOR_BOTTOM)
loc = "bottom";
else if (bi->anchor & E_GADGET_SITE_ANCHOR_LEFT)
loc = "left";
else if (bi->anchor & E_GADGET_SITE_ANCHOR_RIGHT)
loc = "right";
if (bi->anchor & E_GADGET_SITE_ANCHOR_RIGHT)
loc2 = "right";
else if (bi->anchor & E_GADGET_SITE_ANCHOR_LEFT)
loc2 = "left";
else if (bi->anchor & E_GADGET_SITE_ANCHOR_TOP)
loc2 = "top";
else if (bi->anchor & E_GADGET_SITE_ANCHOR_BOTTOM)
loc2 = "bottom";
zone = e_comp_object_util_zone_get(obj);
if (!zone) zone = e_zone_current_get();
snprintf(buf, sizeof(buf), "bryce_%s_%s_%d", loc, loc2, zone->num);
if (bi->orient == E_GADGET_SITE_ORIENT_HORIZONTAL)
{
if (bi->anchor & E_GADGET_SITE_ANCHOR_LEFT)
gravity = E_GADGET_SITE_GRAVITY_LEFT;
else if (bi->anchor & E_GADGET_SITE_ANCHOR_RIGHT)
gravity = E_GADGET_SITE_GRAVITY_RIGHT;
}
else
{
if (bi->anchor & E_GADGET_SITE_ANCHOR_TOP)
gravity = E_GADGET_SITE_GRAVITY_TOP;
else if (bi->anchor & E_GADGET_SITE_ANCHOR_BOTTOM)
gravity = E_GADGET_SITE_GRAVITY_BOTTOM;
}
if (b)
{
e_bryce_orient(b, bi->orient, bi->anchor);
site = e_bryce_site_get(b);
}
else
{
b = e_bryce_add(e_comp->elm, buf, bi->orient, bi->anchor);
site = e_bryce_site_get(b);
e_gadget_site_gadget_add(site, "Start", 0);
e_gadget_site_gadget_add(site, "Digital Clock", 0);
e_gadget_site_gadget_add(site, "Wireless", 0);
}
e_gadget_site_gravity_set(site, gravity);
e_bryce_style_set(b, bi->style);
e_bryce_autohide_set(b, bi->autohide);
e_bryce_autosize_set(b, bi->autosize);
evas_object_layer_set(b, bi->stack_under ? E_LAYER_DESKTOP_TOP : E_LAYER_CLIENT_ABOVE);
evas_object_del(obj);
}
static void
_editor_finish(void *data, Evas_Object *obj EINA_UNUSED, void *event_info EINA_UNUSED)
{
_editor_bryce_add(data);
}
static void
_editor_autosize(void *data, Evas_Object *obj EINA_UNUSED, void *event_info EINA_UNUSED)
{
Bryce_Info *bi = data;
bi->autosize = !bi->autosize;
}
static void
_editor_autohide(void *data, Evas_Object *obj EINA_UNUSED, void *event_info EINA_UNUSED)
{
Bryce_Info *bi = data;
bi->autohide = !bi->autohide;
}
static void
_editor_stacking(void *data, Evas_Object *obj EINA_UNUSED, void *event_info EINA_UNUSED)
{
Bryce_Info *bi = data;
bi->stack_under = !bi->stack_under;
}
static void
_editor_style_click(void *data, Evas *e EINA_UNUSED, Evas_Object *obj, void *event_info EINA_UNUSED)
{
const char *g;
char style[1024] = {0};
Bryce_Info *bi;
Evas_Object *ly, *box, *ck, *button, *bryce;
ly = elm_object_part_content_get(obj, "e.swallow.content");
elm_layout_file_get(ly, NULL, &g);
g += (sizeof("e/bryce/") - 1);
memcpy(style, g, MIN(sizeof(style) - 1, (size_t)(strchr(g, '/') - g)));
bryce = evas_object_data_get(data, "__bryce_editor_bryce");
bi = evas_object_data_get(data, "__bryce_info");
bi->style = eina_stringshare_add(style);
e_theme_edje_object_set(data, NULL, "e/bryce/editor/finish");
elm_object_part_text_set(data, "e.text", _("Finishing touches... (4/4)"));
box = elm_box_add(data);
elm_box_padding_set(box, 0, 20 * e_scale);
ck = elm_check_add(box);
elm_object_focus_allow_set(ck, 0);
E_ALIGN(ck, 0, 0.5);
evas_object_show(ck);
elm_object_text_set(ck, _("Automatically size based on contents"));
evas_object_smart_callback_add(ck, "changed", _editor_autosize, bi);
if (bryce)
{
bi->autosize = e_bryce_autosize_get(bryce);
elm_check_state_set(ck, bi->autosize);
}
elm_box_pack_end(box, ck);
ck = elm_check_add(box);
elm_object_focus_allow_set(ck, 0);
E_ALIGN(ck, 0, 0.5);
evas_object_show(ck);
elm_object_text_set(ck, _("Automatically hide"));
evas_object_smart_callback_add(ck, "changed", _editor_autohide, bi);
if (bryce)
{
bi->autohide = e_bryce_autohide_get(bryce);
elm_check_state_set(ck, bi->autohide);
}
elm_box_pack_end(box, ck);
ck = elm_check_add(box);
elm_object_focus_allow_set(ck, 0);
E_ALIGN(ck, 0, 0.5);
evas_object_show(ck);
elm_object_text_set(ck, _("Do not stack above windows"));
evas_object_smart_callback_add(ck, "changed", _editor_stacking, bi);
if (bryce)
{
bi->stack_under = evas_object_layer_get(bryce) == E_LAYER_DESKTOP_TOP;
elm_check_state_set(ck, bi->stack_under);
}
elm_box_pack_end(box, ck);
//ck = elm_check_add(box);
//elm_object_text_set(ck, _("Allow windows to overlap"));
//evas_object_smart_callback_add(ck, "changed", _editor_overlap, data);
//elm_box_pack_end(box, ck);
button = elm_button_add(data);
evas_object_show(button);
elm_object_text_set(button, _("Finish!"));
evas_object_smart_callback_add(button, "clicked", _editor_finish, data);
elm_box_pack_end(box, button);
elm_object_part_content_set(data, "e.swallow.content", box);
}
static void
_editor_style(Evas_Object *obj)
{
Eina_List *l;
Eina_Stringshare *style;
Evas_Object *box;
int w;
evas_object_geometry_get(obj, NULL, NULL, &w, NULL);
box = elm_box_add(obj);
e_theme_edje_object_set(obj, NULL, "e/bryce/editor/style");
elm_object_part_text_set(obj, "e.text", _("Choose style (3/4)"));
elm_box_homogeneous_set(box, 1);
elm_box_padding_set(box, 0, 20 * e_scale);
l = elm_theme_group_base_list(NULL, "e/bryce/");
EINA_LIST_FREE(l, style)
{
Evas_Object *ly, *bryce;
char buf[1024] = {0};
size_t len;
if (!eina_str_has_suffix(style, "/base"))
{
eina_stringshare_del(style);
continue;
}
ly = elm_layout_add(box);
e_theme_edje_object_set(ly, NULL, "e/bryce/editor/style/item");
bryce = edje_object_add(evas_object_evas_get(box));
elm_object_part_content_set(ly, "e.swallow.content", bryce);
len = strlen(style);
strncpy(buf, style + sizeof("e/bryce/") - 1,
MIN(sizeof(buf) - 1, len - (sizeof("e/bryce/") - 1) - (sizeof("/base") - 1)));
buf[0] = toupper(buf[0]);
elm_object_part_text_set(ly, "e.text", buf);
e_comp_object_util_del_list_append(ly, bryce);
e_theme_edje_object_set(bryce, NULL, style);
evas_object_size_hint_min_set(bryce, w * 2 / 3, 48 * e_scale);
evas_object_show(ly);
evas_object_event_callback_add(ly, EVAS_CALLBACK_MOUSE_DOWN, _editor_style_click, obj);
elm_box_pack_end(box, ly);
}
elm_object_part_content_set(obj, "e.swallow.content", box);
}
static void
_editor_info_del(void *data, Evas *e EINA_UNUSED, Evas_Object *obj EINA_UNUSED, void *event_info EINA_UNUSED)
{
Bryce_Info *bi = data;
eina_stringshare_del(bi->style);
free(bi);
}
static void
_editor_add(Evas_Object *obj, E_Gadget_Site_Orient orient, E_Gadget_Site_Anchor an)
{
char buf[1024];
Bryce_Info *bi;
bi = evas_object_data_get(obj, "__bryce_info");
if (bi)
{
bi->anchor |= an;
_editor_style(obj);
}
else
{
bi = E_NEW(Bryce_Info, 1);
bi->anchor = an;
bi->orient = orient;
evas_object_data_set(obj, "__bryce_info", bi);
evas_object_event_callback_add(obj, EVAS_CALLBACK_DEL, _editor_info_del, bi);
snprintf(buf, sizeof(buf), "e/bryce/editor/side/%s",
orient == E_GADGET_SITE_ORIENT_HORIZONTAL ? "horizontal" : "vertical");
e_theme_edje_object_set(obj, NULL, buf);
elm_object_part_text_set(obj, "e.text", _("Choose position (2/4)"));
if (an & E_GADGET_SITE_ANCHOR_BOTTOM)
elm_object_signal_emit(obj, "e,state,bottom", "e");
else if (an & E_GADGET_SITE_ANCHOR_RIGHT)
elm_object_signal_emit(obj, "e,state,right", "e");
setup_exists(evas_object_data_get(obj, "__bryce_editor_bryce"), obj,
evas_object_data_get(obj, "__bryce_editor_site"), an);
}
}
static void
_editor_add_bottom(void *data EINA_UNUSED, Evas_Object *obj, const char *sig EINA_UNUSED, const char *src EINA_UNUSED)
{
_editor_add(obj, E_GADGET_SITE_ORIENT_HORIZONTAL, E_GADGET_SITE_ANCHOR_BOTTOM);
}
static void
_editor_add_top(void *data EINA_UNUSED, Evas_Object *obj, const char *sig EINA_UNUSED, const char *src EINA_UNUSED)
{
_editor_add(obj, E_GADGET_SITE_ORIENT_HORIZONTAL, E_GADGET_SITE_ANCHOR_TOP);
}
static void
_editor_add_left(void *data EINA_UNUSED, Evas_Object *obj, const char *sig EINA_UNUSED, const char *src EINA_UNUSED)
{
_editor_add(obj, E_GADGET_SITE_ORIENT_VERTICAL, E_GADGET_SITE_ANCHOR_LEFT);
}
static void
_editor_add_center(void *data EINA_UNUSED, Evas_Object *obj, const char *sig EINA_UNUSED, const char *src EINA_UNUSED)
{
_editor_add(obj, E_GADGET_SITE_ORIENT_NONE, E_GADGET_SITE_ANCHOR_NONE);
}
static void
_editor_add_right(void *data EINA_UNUSED, Evas_Object *obj, const char *sig EINA_UNUSED, const char *src EINA_UNUSED)
{
_editor_add(obj, E_GADGET_SITE_ORIENT_VERTICAL, E_GADGET_SITE_ANCHOR_RIGHT);
}
static void
_editor_dismiss(void *data EINA_UNUSED, Evas_Object *obj, const char *sig EINA_UNUSED, const char *src EINA_UNUSED)
{
evas_object_del(obj);
}
E_API Evas_Object *
e_bryce_editor_add(Evas_Object *parent, Evas_Object *bryce)
{
Evas_Object *editor;
editor = elm_layout_add(parent);
evas_object_data_set(editor, "__bryce_editor_site", parent);
evas_object_data_set(editor, "__bryce_editor_bryce", bryce);
e_theme_edje_object_set(editor, NULL, "e/bryce/editor/side");
elm_object_part_text_set(editor, "e.text", _("Choose screen edge (1/4)"));
setup_exists(bryce, editor, parent, 0);
elm_object_signal_callback_add(editor, "e,action,dismiss", "e", _editor_dismiss, editor);
elm_object_signal_callback_add(editor, "e,bryce,add,bottom", "e", _editor_add_bottom, editor);
elm_object_signal_callback_add(editor, "e,bryce,add,top", "e", _editor_add_top, editor);
elm_object_signal_callback_add(editor, "e,bryce,add,left", "e", _editor_add_left, editor);
elm_object_signal_callback_add(editor, "e,bryce,add,right", "e", _editor_add_right, editor);
elm_object_signal_callback_add(editor, "e,bryce,add,center", "e", _editor_add_center, editor);
return editor;
}
static Ecore_Event_Handler *handler;
static void
_bryce_edit_key_location(Evas_Object *obj, Ecore_Event_Key *ev)
{
if (eina_streq(ev->key, "Up"))
_editor_add(obj, E_GADGET_SITE_ORIENT_HORIZONTAL, E_GADGET_SITE_ANCHOR_TOP);
else if (eina_streq(ev->key, "Down"))
_editor_add(obj, E_GADGET_SITE_ORIENT_HORIZONTAL, E_GADGET_SITE_ANCHOR_BOTTOM);
else if (eina_streq(ev->key, "Left"))
_editor_add(obj, E_GADGET_SITE_ORIENT_VERTICAL, E_GADGET_SITE_ANCHOR_LEFT);
else if (eina_streq(ev->key, "Right"))
_editor_add(obj, E_GADGET_SITE_ORIENT_VERTICAL, E_GADGET_SITE_ANCHOR_RIGHT);
}
static Eina_Bool
_bryce_edit_key_handler(void *data, int t EINA_UNUSED, Ecore_Event_Key *ev)
{
if (eina_streq(ev->key, "Escape"))
{
elm_layout_signal_emit(data, "e,action,dismiss", "e");
return ECORE_CALLBACK_RENEW;
}
if (evas_object_data_get(data, "__bryce_info"))
{
const char *grp;
edje_object_file_get(data, NULL, &grp);
if (!strncmp(grp, "e/bryce/editor/side/", sizeof("e/bryce/editor/side/") - 1))
_bryce_edit_key_location(data, ev);
else if (!strncmp(grp, "e/bryce/editor/style", sizeof("e/bryce/editor/style") - 1))
{
Evas_Object *bx, *o;
Eina_List *l;
int n;
bx = elm_object_part_content_get(data, "e.swallow.content");
l = elm_box_children_get(bx);
n = strtol(ev->key, NULL, 10);
if (n > 0)
{
o = eina_list_nth(l, n - 1);
if (o)
_editor_style_click(data, NULL, o, NULL);
}
eina_list_free(l);
}
else if (eina_streq(ev->key, "Return") || eina_streq(ev->key, "KP_Enter"))
_editor_bryce_add(data);
}
else
_bryce_edit_key_location(data, ev);
return ECORE_CALLBACK_RENEW;
}
static void
_bryce_edit_end(void *data, Evas *e EINA_UNUSED, Evas_Object *obj EINA_UNUSED, void *event_info EINA_UNUSED)
{
e_bindings_disabled_set(0);
e_comp_ungrab_input(1, 1);
evas_object_hide(data);
evas_object_del(data);
E_FREE_FUNC(handler, ecore_event_handler_del);
}
E_API Evas_Object *
e_bryce_edit(Evas_Object *bryce)
{
Evas_Object *editor, *comp_object;
E_Zone *zone;
int x, y, w, h;
zone = e_zone_current_get();
x = zone->x, y = zone->y, w = zone->w, h = zone->h;
e_bindings_disabled_set(1);
editor = e_bryce_editor_add(e_comp->elm, bryce);
evas_object_geometry_set(editor, x, y, w, h);
comp_object = e_comp_object_util_add(editor, E_COMP_OBJECT_TYPE_NONE);
evas_object_event_callback_add(editor, EVAS_CALLBACK_DEL, _bryce_edit_end, comp_object);
evas_object_layer_set(comp_object, E_LAYER_POPUP);
evas_object_show(comp_object);
e_comp_object_util_autoclose(comp_object, NULL, e_comp_object_util_autoclose_on_escape, NULL);
e_comp_grab_input(1, 1);
handler = ecore_event_handler_add(ECORE_EVENT_KEY_UP, (Ecore_Event_Handler_Cb)_bryce_edit_key_handler, editor);
return comp_object;
}

99
src/bin/e_config.c
View File

@ -59,37 +59,6 @@ typedef struct _E_Color_Class
int r3, g3, b3, a3;
} E_Color_Class;
static void
_e_config_binding_mouse_add(E_Binding_Context ctxt, int button, E_Binding_Modifier mod, int any_mod, const char *action, const char *params)
{
E_Config_Binding_Mouse *binding;
binding = calloc(1, sizeof(E_Config_Binding_Mouse));
binding->context = ctxt;
binding->button = button;
binding->modifiers = mod;
binding->any_mod = any_mod;
binding->action = eina_stringshare_add(action);
binding->params = eina_stringshare_add(params);
e_bindings->mouse_bindings = eina_list_append(e_bindings->mouse_bindings, binding);
}
static void
_e_config_binding_wheel_add(E_Binding_Context ctxt, int direction, int z, E_Binding_Modifier mod, int any_mod, const char *action, const char *params)
{
E_Config_Binding_Wheel *binding;
binding = calloc(1, sizeof(E_Config_Binding_Wheel));
binding->context = ctxt;
binding->direction = direction;
binding->z = z;
binding->modifiers = mod;
binding->any_mod = any_mod;
binding->action = eina_stringshare_add(action);
binding->params = eina_stringshare_add(params);
e_bindings->wheel_bindings = eina_list_append(e_bindings->wheel_bindings, binding);
}
static Eina_Bool
_e_config_cb_efreet_cache_update(void *data EINA_UNUSED, int type EINA_UNUSED, void *ev EINA_UNUSED)
{
@ -1384,53 +1353,8 @@ e_config_load(void)
}
CONFIG_VERSION_CHECK(20)
{
Eina_List *l;
E_Config_Binding_Mouse *ebm;
E_Config_Module *em, *module;
CONFIG_VERSION_UPDATE_INFO(20);
EINA_LIST_FOREACH(e_bindings->mouse_bindings, l, ebm)
{
if (eina_streq(ebm->action, "window_move"))
{
_e_config_binding_mouse_add(E_BINDING_CONTEXT_ANY, ebm->button, ebm->modifiers,
ebm->any_mod, "gadget_move", NULL);
}
else if (eina_streq(ebm->action, "window_resize"))
{
_e_config_binding_mouse_add(E_BINDING_CONTEXT_ANY, ebm->button, ebm->modifiers,
ebm->any_mod, "gadget_resize", NULL);
}
else if (eina_streq(ebm->action, "window_menu"))
{
_e_config_binding_mouse_add(E_BINDING_CONTEXT_ANY, ebm->button, ebm->modifiers,
ebm->any_mod, "gadget_menu", NULL);
_e_config_binding_mouse_add(E_BINDING_CONTEXT_ANY, ebm->button, ebm->modifiers,
ebm->any_mod, "bryce_menu", NULL);
}
}
_e_config_binding_wheel_add(E_BINDING_CONTEXT_ANY, 0, 1, E_BINDING_MODIFIER_CTRL, 0, "bryce_resize", NULL);
_e_config_binding_wheel_add(E_BINDING_CONTEXT_ANY, 0, -1, E_BINDING_MODIFIER_CTRL, 0, "bryce_resize", NULL);
EINA_LIST_FOREACH(e_config->modules, l, em)
{
if (!em->enabled) continue;
if (eina_streq(em->name, "connman"))
{
module = E_NEW(E_Config_Module, 1);
module->name = eina_stringshare_add("wireless");
module->enabled = 1;
e_config->modules = eina_list_append(e_config->modules, module);
}
else if (eina_streq(em->name, "clock"))
{
module = E_NEW(E_Config_Module, 1);
module->name = eina_stringshare_add("time");
module->enabled = 1;
e_config->modules = eina_list_append(e_config->modules, module);
}
}
e_config_save_queue();
}
CONFIG_VERSION_CHECK(21)
@ -1558,23 +1482,7 @@ e_config_load(void)
}
CONFIG_VERSION_CHECK(28)
{
Eina_List *l, *ll;
E_Config_Binding_Mouse *ebm;
CONFIG_VERSION_UPDATE_INFO(28);
EINA_LIST_FOREACH_SAFE(e_bindings->mouse_bindings, l, ll, ebm)
{
if ((eina_streq(ebm->action, "gadget_menu")) ||
(eina_streq(ebm->action, "bryce_menu")))
{
e_bindings->mouse_bindings =
eina_list_remove_list
(e_bindings->mouse_bindings, l);
eina_stringshare_del(ebm->action);
eina_stringshare_del(ebm->params);
free(ebm);
}
}
e_config_save_queue();
}
CONFIG_VERSION_CHECK(29)
@ -2423,16 +2331,11 @@ e_config_bindings_free(E_Config_Bindings *ecb)
static void
_e_config_save_cb(void *data EINA_UNUSED)
{
EINTERN void e_gadget_save(void);
EINTERN void e_bryce_save(void);
e_config_profile_save();
e_module_save_all();
elm_config_save();
e_config_domain_save("e", _e_config_edd, e_config);
e_config_domain_save("e_bindings", _e_config_binding_edd, e_bindings);
e_gadget_save();
e_bryce_save();
_e_config_save_defer = NULL;
}

3535
src/bin/e_gadget.c
View File

File diff suppressed because it is too large Load Diff

155
src/bin/e_gadget.h
View File

@ -1,155 +0,0 @@
#ifndef E_TYPEDEFS
#ifndef E_GADGET_H
# define E_GADGET_H
/** SMART CALLBACKS:
-------------------------------
* called by gadget site internals on gadget site object:
* have a gadget object as event_info
* {
"gadget_added"
- a new gadget was added to the gadget site by the user
"gadget_created"
- a gadget object was created on the site
"gadget_destroyed"
- a gadget object was destroyed on the site; all objects created by the
gadget infrastructure are now dead
- do not watch both this and EVAS_CALLBACK_DEL, as the ordering of these
callbacks is not consistent
"gadget_moved"
- a gadget is preparing to move from its current site
"gadget_removed"
- a gadget was removed from the gadget site by the user
- the gadget should remove its config when this is triggered
* }
* have NULL as event_info
* {
"gadget_site_anchor"
- the anchor of the gadget site changed
"gadget_site_gravity"
- the gravity of the gadget site changed
"gadget_site_locked"
- the gadget site's visibility has been locked (must be visible)
"gadget_site_unlocked"
- the gadget site's visibility has been unlocked (can be hidden)
* }
* have E_Menu as event_info
* {
"gadget_site_owner_menu"
- the owner (parent object) of the site should add any owner-specific items
in this callback (eg. settings)
"gadget_site_style_menu"
- the owner (parent object) of the site should add any style-specific items
in this callback (eg. plain, inset)
* }
* have Evas_Object as event_info
* {
"gadget_site_popup"
- a popup has been triggered from the site; the site must remain visible until
the passed popup object has been hidden
- event_info is the Evas_Object of the popup
* }
-------------------------------
-------------------------------
* called externally on gadget site
"gadget_site_dropped"
- called on a target site when a gadget site is dropped on it
- event_info is the dropped site
- all gadgets on the dropped site will be moved to the target site
"gadget_site_style"
- called on a target site when its owner has executed a style change
- event_info is NULL
- triggers restyling of all contained gadgets
-------------------------------
-------------------------------
* called by gadget internals on gadget object:
"gadget_menu"
- called on a gadget object when the "gadget_menu" action has been triggered
- event_info is an E_Menu object
- if a configure callback has been passed with e_gadget_configure_cb_set(),
a "Settings" item will be automatically added with this callback
"gadget_reparent"
- called on a gadget object when the gadget has been reparented
- parent object is event_info
- indicates that the gadget should watch this new object for EVAS_CALLBACK_RESIZE
- event_info will be NULL in the case that the reparenting removes the parent
-------------------------------
-------------------------------
* called externally by gadget on gadget object:
"gadget_popup"
- called on a gadget object by the gadget when the gadget creates a popup which
requires that the gadget remain visible for the lifetime of the popup
- event_info is the Evas_Object of the popup
*/
#include "e_gadget_types.h"
typedef Evas_Object *(*E_Gadget_Create_Cb)(Evas_Object *parent, int *id, E_Gadget_Site_Orient orient);
typedef Evas_Object *(*E_Gadget_External_Create_Cb)(Evas_Object *parent, const char *type, int *id, E_Gadget_Site_Orient orient);
typedef Evas_Object *(*E_Gadget_Configure_Cb)(Evas_Object *gadget);
typedef void (*E_Gadget_Menu_Populate_Cb)(Evas_Object *gadget, E_Menu *m);
typedef void (*E_Gadget_Context_Cb)(Evas_Object *site, Evas_Object *g, unsigned int timestamp);
typedef void (*E_Gadget_Wizard_End_Cb)(void *data, int id);
typedef Evas_Object *(*E_Gadget_Wizard_Cb)(E_Gadget_Wizard_End_Cb cb, void *data, Evas_Object *site);
typedef Evas_Object *(*E_Gadget_External_Wizard_Cb)(E_Gadget_Wizard_End_Cb cb, void *data, const char *type, Evas_Object *site);
typedef void (*E_Gadget_Style_Cb)(Evas_Object *owner, Eina_Stringshare *name, Evas_Object *g);
typedef char *(*E_Gadget_External_Name_Cb)(const char *type);
EINTERN void e_gadget_init(void);
EINTERN void e_gadget_shutdown(void);
EINTERN void e_gadget_site_rename(const char *name, const char *newname);
E_API Evas_Object *e_gadget_site_add(E_Gadget_Site_Orient orient, const char *name);
E_API Evas_Object *e_gadget_site_auto_add(E_Gadget_Site_Orient orient, const char *name);
E_API void e_gadget_site_del(Evas_Object *obj);
E_API E_Gadget_Site_Anchor e_gadget_site_anchor_get(Evas_Object *obj);
E_API void e_gadget_site_owner_setup(Evas_Object *obj, E_Gadget_Site_Anchor an, E_Gadget_Style_Cb cb, E_Gadget_Context_Cb context_cb, E_Gadget_Context_Cb context_cancel_cb);
E_API E_Gadget_Site_Orient e_gadget_site_orient_get(Evas_Object *obj);
E_API E_Gadget_Site_Gravity e_gadget_site_gravity_get(Evas_Object *obj);
E_API void e_gadget_site_gravity_set(Evas_Object *obj, E_Gadget_Site_Gravity gravity);
E_API void e_gadget_site_gadget_add(Evas_Object *obj, const char *type, Eina_Bool demo);
E_API void e_gadget_site_gadget_external_add(Evas_Object *obj, const char *domain, const char *type, Eina_Bool demo);
E_API Eina_List *e_gadget_site_gadgets_list(Evas_Object *obj);
E_API Eina_Bool e_gadget_site_is_desklock(Evas_Object *obj);
E_API void e_gadget_configure_cb_set(Evas_Object *g, E_Gadget_Configure_Cb cb);
E_API void e_gadget_configure(Evas_Object *g);
E_API void e_gadget_menu_populate_cb_set(Evas_Object *g, E_Gadget_Menu_Populate_Cb cb);
E_API void e_gadget_menu_populate(Evas_Object *g, E_Menu *m);
E_API Evas_Object *e_gadget_site_get(Evas_Object *g);
E_API Eina_Stringshare *e_gadget_type_get(Evas_Object *g);
E_API void e_gadget_type_add(const char *type, E_Gadget_Create_Cb callback, E_Gadget_Wizard_Cb wizard);
E_API void e_gadget_type_del(const char *type);
E_API void e_gadget_external_type_add(const char *domain, const char *type, E_Gadget_External_Create_Cb callback, E_Gadget_External_Wizard_Cb wizard);
E_API void e_gadget_external_type_del(const char *domain, const char *type);
E_API void e_gadget_external_type_name_cb_set(const char *domain, const char *type, E_Gadget_External_Name_Cb name);
E_API Eina_Iterator *e_gadget_type_iterator_get(void);
/* delete a gadget and its config */
E_API void e_gadget_del(Evas_Object *g);
/* drop region initially matches gadget size, resizes to match returned object's size
* handler is removed when returned object is deleted
*/
E_API Evas_Object *e_gadget_drop_handler_add(Evas_Object *g, void *data,
void (*enter_cb)(void *data, const char *type, void *event),
void (*move_cb)(void *data, const char *type, void *event),
void (*leave_cb)(void *data, const char *type, void *event),
void (*drop_cb)(void *data, const char *type, void *event),
const char **types, unsigned int num_types);
E_API Evas_Object *e_gadget_util_layout_style_init(Evas_Object *g, Evas_Object *style);
E_API void e_gadget_util_ctxpopup_place(Evas_Object *g, Evas_Object *ctx, Evas_Object *pos_obj);
E_API void e_gadget_util_allow_deny_ctxpopup(Evas_Object *g, const char *text, Evas_Smart_Cb allow_cb, Evas_Smart_Cb deny_cb, const void *data);
E_API Evas_Object *e_gadget_editor_add(Evas_Object *parent, Evas_Object *site);
E_API Evas_Object *e_gadget_site_edit(Evas_Object *site);
E_API void e_gadget_site_desklock_edit(void);
E_API void e_gadget_site_desktop_edit(Evas_Object *site);
#endif
#endif

354
src/bin/e_gadget_loader.c
View File

@ -1,354 +0,0 @@
#include "config.h"
#define EFL_BETA_API_SUPPORT
#include <Ecore_Wl2.h>
#include <Elementary.h>
#include <dlfcn.h>
#include "e-gadget-client-protocol.h"
#include "action_route-client-protocol.h"
#include <uuid.h>
static Ecore_Event_Handler *handler;
static Eina_Hash *wins;
static Eina_Hash *gadget_globals;
static Eina_Hash *ar_globals;
static Eina_Hash *display_actions;
static Eina_List *tooltips;
typedef struct Gadget_Action
{
Ecore_Wl2_Display *d;
Eina_Stringshare *action;
char handle[37];
Eina_List *requestors;
struct action_route_bind *ar_bind;
} Gadget_Action;
static inline Ecore_Wl2_Display *
win_display_get(Evas_Object *win)
{
Ecore_Wl2_Window *ww;
ww = elm_win_wl_window_get(win);
return ecore_wl2_window_display_get(ww);
}
static void
win_emit(Ecore_Wl2_Display *d, const char *sig, uint32_t val)
{
Evas_Object *win;
win = eina_list_data_get(eina_hash_find(wins, &d));
evas_object_smart_callback_call(win, sig, (uintptr_t*)(uintptr_t)val);
}
static void
_gadget_anchor(void *data, struct e_gadget *e_gadget EINA_UNUSED, uint32_t anchor)
{
win_emit(data, "gadget_site_anchor", anchor);
}
static void
_gadget_orient(void *data, struct e_gadget *e_gadget EINA_UNUSED, uint32_t orient)
{
win_emit(data, "gadget_site_orient", orient);
}
static void
_gadget_gravity(void *data, struct e_gadget *e_gadget EINA_UNUSED, uint32_t gravity)
{
win_emit(data, "gadget_site_gravity", gravity);
}
static void
_gadget_configure(void *data, struct e_gadget *e_gadget EINA_UNUSED)
{
Evas_Object *win;
win = eina_list_data_get(eina_hash_find(wins, &data));
evas_object_smart_callback_call(win, "gadget_configure", NULL);
}
static const struct e_gadget_listener _gadget_listener =
{
_gadget_anchor,
_gadget_orient,
_gadget_gravity,
_gadget_configure,
};
static void
_gadget_global_bind(Ecore_Wl2_Display *d, uint32_t id)
{
Eina_List *l;
Evas_Object *tt;
struct e_gadget *gadget_global = wl_registry_bind(ecore_wl2_display_registry_get(d), id, &e_gadget_interface, 1);
e_gadget_add_listener(gadget_global, &_gadget_listener, d);
eina_hash_add(gadget_globals, &d, gadget_global);
EINA_LIST_FOREACH(tooltips, l, tt)
e_gadget_set_tooltip(gadget_global, ecore_wl2_window_surface_get(elm_win_wl_window_get(tt)));
ecore_wl2_display_flush(d);
}
static void
_ar_global_bind(Ecore_Wl2_Display *d, uint32_t id)
{
struct action_route *ar_global = wl_registry_bind(ecore_wl2_display_registry_get(d), id, &action_route_interface, 1);
eina_hash_add(ar_globals, &d, ar_global);
ecore_wl2_display_flush(d);
}
static Eina_Bool
_global_added(void *d EINA_UNUSED, int t EINA_UNUSED, Ecore_Wl2_Event_Global *ev)
{
if (eina_streq(ev->interface, "e_gadget"))
_gadget_global_bind(ev->display, ev->id);
else if (eina_streq(ev->interface, "action_route"))
_ar_global_bind(ev->display, ev->id);
return ECORE_CALLBACK_RENEW;
}
static void
_gadget_init(Ecore_Wl2_Display *d)
{
Eina_Iterator *it;
Ecore_Wl2_Global *g;
if (wins)
{
if (eina_hash_find(gadget_globals, &d)) return;
}
else
{
gadget_globals = eina_hash_pointer_new(NULL);
ar_globals = eina_hash_pointer_new(NULL);
}
it = ecore_wl2_display_globals_get(d);
EINA_ITERATOR_FOREACH(it, g)
{
if (eina_streq(g->interface, "e_gadget"))
_gadget_global_bind(d, g->id);
else if (eina_streq(g->interface, "action_route"))
_ar_global_bind(d, g->id);
}
eina_iterator_free(it);
if (!handler)
handler = ecore_event_handler_add(ECORE_WL2_EVENT_GLOBAL_ADDED, (Ecore_Event_Handler_Cb)_global_added, NULL);
}
static void
_ar_bind_activate(void *data, Evas_Object *obj EINA_UNUSED, void *event_info)
{
const char *params = event_info;
Gadget_Action *ga = data;
if (params && (!params[0])) params = NULL;
action_route_bind_activate(ga->ar_bind, params);
ecore_wl2_display_flush(ga->d);
}
static void
_ar_bind_del(Gadget_Action *ga)
{
Evas_Object *r;
eina_stringshare_del(ga->action);
EINA_LIST_FREE(ga->requestors, r)
evas_object_smart_callback_del_full(r, ga->handle, _ar_bind_activate, ga);
free(ga);
}
static void
_ar_bind_end(void *data, struct action_route_bind *action_route_bind EINA_UNUSED)
{
Gadget_Action *ga = data;
Eina_List *l;
Evas_Object *r;
EINA_LIST_FOREACH(ga->requestors, l, r)
evas_object_smart_callback_call(r, "gadget_action_end", ga->handle);
}
static void
_ar_bind_status(void *data, struct action_route_bind *action_route_bind, uint32_t state)
{
uuid_t u;
Gadget_Action *ga = data;
Evas_Object *r;
if (state == ACTION_ROUTE_BIND_STATE_REJECTED)
{
Eina_Hash *h;
Eina_List *l;
h = eina_hash_find(display_actions, &ga->d);
EINA_LIST_FOREACH(ga->requestors, l, r)
{
if (ga->handle[0])
evas_object_smart_callback_call(r, "gadget_action_deleted", ga->handle);
else
evas_object_smart_callback_call(r, "gadget_action", NULL);
}
eina_hash_del_by_key(h, ga->action);
return;
}
uuid_generate(u);
uuid_unparse_lower(u, ga->handle);
ga->ar_bind = action_route_bind;
r = eina_list_data_get(ga->requestors);
evas_object_smart_callback_add(r, ga->handle, _ar_bind_activate, ga);
evas_object_smart_callback_call(r, "gadget_action", ga->handle);
}
static const struct action_route_bind_listener _ar_bind_interface =
{
_ar_bind_status,
_ar_bind_end
};
static void
uriopen_request(void *data, Evas_Object *obj EINA_UNUSED, void *event_info)
{
Ecore_Wl2_Display *d = data;
const char *uri = event_info;
struct e_gadget *gadget_global = eina_hash_find(gadget_globals, &d);
e_gadget_open_uri(gadget_global, uri);
ecore_wl2_display_flush(d);
}
static void
action_request(void *data, Evas_Object *obj, void *event_info)
{
Gadget_Action *ga;
const char *action = event_info;
Ecore_Wl2_Display *d = data;
void *ar_global;
struct action_route_bind *ar_bind;
Eina_Hash *h;
if ((!action) || (!action[0]))
{
evas_object_smart_callback_call(obj, "gadget_action", NULL);
return;
}
if (display_actions)
{
h = eina_hash_find(display_actions, &d);
if (h)
{
ga = eina_hash_find(h, action);
if (ga && (!eina_list_data_find(ga->requestors, obj)))
{
ga->requestors = eina_list_append(ga->requestors, obj);
evas_object_smart_callback_add(obj, ga->handle, _ar_bind_activate, ga);
}
evas_object_smart_callback_call(obj, "gadget_action", ga ? ga->handle : NULL);
return;
}
}
ar_global = eina_hash_find(ar_globals, &d);
if (!ar_global)
{
evas_object_smart_callback_call(obj, "gadget_action", NULL);
return;
}
ga = calloc(1, sizeof(Gadget_Action));
ga->d = d;
ga->requestors = eina_list_append(ga->requestors, obj);
ga->action = eina_stringshare_add(action);
if (!display_actions)
display_actions = eina_hash_string_superfast_new(NULL);
h = eina_hash_find(display_actions, &d);
if (!h)
{
h = eina_hash_pointer_new((Eina_Free_Cb)_ar_bind_del);
eina_hash_add(display_actions, &d, h);
}
ar_bind = action_route_bind_action(ar_global, action);
action_route_bind_add_listener(ar_bind, &_ar_bind_interface, ga);
wl_display_roundtrip(ecore_wl2_display_get(d));
}
static void
win_del(void *data EINA_UNUSED, Evas *e EINA_UNUSED, Evas_Object *obj, void *event_info EINA_UNUSED)
{
Ecore_Wl2_Display *d = win_display_get(obj);
eina_hash_list_remove(wins, &d, obj);
tooltips = eina_list_remove(tooltips, obj);
}
static void
_tooltip_resize(void *data EINA_UNUSED, Evas *e EINA_UNUSED, Evas_Object *obj, void *event_info EINA_UNUSED)
{
int w, h;
evas_object_geometry_get(obj, NULL, NULL, &w, &h);
evas_object_size_hint_aspect_set(obj, EVAS_ASPECT_CONTROL_BOTH, w, h);
}
static Evas_Object *
win_add(Evas_Object *win)
{
Ecore_Wl2_Display *d;
Eina_Bool first;
if (!win) return NULL;
d = win_display_get(win);
_gadget_init(d);
if (elm_win_type_get(win) == ELM_WIN_TOOLTIP)
{
tooltips = eina_list_append(tooltips, win);
evas_object_event_callback_add(win, EVAS_CALLBACK_RESIZE, _tooltip_resize, d);
if (eina_hash_population(gadget_globals))
{
struct e_gadget *gadget_global = eina_hash_find(gadget_globals, &d);
if (gadget_global)
e_gadget_set_tooltip(gadget_global, ecore_wl2_window_surface_get(elm_win_wl_window_get(win)));
}
}
if (!wins)
wins = eina_hash_pointer_new(NULL);
first = !eina_hash_find(wins, &d);
eina_hash_list_append(wins, &d, win);
if (first)
{
evas_object_smart_callback_add(win, "gadget_action_request", action_request, d);
evas_object_smart_callback_add(win, "gadget_open_uri", uriopen_request, d);
}
evas_object_event_callback_add(win, EVAS_CALLBACK_DEL, win_del, NULL);
elm_win_borderless_set(win, 1);
return win;
}
int
eina_init(void)
{
int (*_eina_init)(void) = dlsym(RTLD_NEXT, __func__);
if (wins) return _eina_init();
if (getenv("RUNNER_DEBUG")) raise(SIGSTOP);
return _eina_init();
}
Evas_Object *
elm_win_util_dialog_add(Evas_Object *parent, const char *name, const char *title)
{
Evas_Object *(*_elm_win_util_dialog_add)(Evas_Object *, const char *, const char *) = dlsym(RTLD_NEXT, __func__);
return win_add(_elm_win_util_dialog_add(parent, name, title));
}
Evas_Object *
elm_win_util_standard_add(const char *name, const char *title)
{
Evas_Object *(*_elm_win_util_standard_add)(const char *, const char *) = dlsym(RTLD_NEXT, __func__);
return win_add(_elm_win_util_standard_add(name, title));
}
Evas_Object *
elm_win_add(Evas_Object *parent, const char *name, Elm_Win_Type type)
{
Evas_Object *(*_elm_win_add)(Evas_Object *,const char*, Elm_Win_Type) = dlsym(RTLD_NEXT, __func__);
return win_add(_elm_win_add(parent, name, type));
}

1270
src/bin/e_gadget_runner.c
View File

File diff suppressed because it is too large Load Diff

30
src/bin/e_gadget_types.h
View File

@ -1,30 +0,0 @@
#ifndef E_GADGET_TYPES_H
# define E_GADGET_TYPES_H
typedef enum
{
E_GADGET_SITE_GRAVITY_NONE = 0,
E_GADGET_SITE_GRAVITY_LEFT,
E_GADGET_SITE_GRAVITY_RIGHT,
E_GADGET_SITE_GRAVITY_TOP,
E_GADGET_SITE_GRAVITY_BOTTOM,
E_GADGET_SITE_GRAVITY_CENTER,
} E_Gadget_Site_Gravity;
typedef enum
{
E_GADGET_SITE_ORIENT_NONE = 0,
E_GADGET_SITE_ORIENT_HORIZONTAL,
E_GADGET_SITE_ORIENT_VERTICAL,
} E_Gadget_Site_Orient;
typedef enum
{
E_GADGET_SITE_ANCHOR_NONE = 0,
E_GADGET_SITE_ANCHOR_LEFT = (1 << 0),
E_GADGET_SITE_ANCHOR_RIGHT = (1 << 1),
E_GADGET_SITE_ANCHOR_TOP = (1 << 2),
E_GADGET_SITE_ANCHOR_BOTTOM = (1 << 3),
} E_Gadget_Site_Anchor;
#endif

2
src/bin/e_includes.h
View File

@ -152,8 +152,6 @@
#include "e_utils.h"
#include "e_hints.h"
#include "e_comp_x_randr.h"
#include "e_gadget.h"
#include "e_bryce.h"
#ifdef HAVE_WAYLAND
# include "e_comp_wl.h"

22
src/bin/e_int_menus.c
View File

@ -93,18 +93,6 @@ _e_int_menus_wallpaper_cb()
e_configure_registry_call("appearance/wallpaper", NULL, NULL);
}
static void
_e_int_menus_bryce_cb()
{
e_bryce_edit(NULL);
}
static void
_e_int_menus_desktop_gadget_add_cb()
{
e_gadget_site_desktop_edit(e_comp->canvas->gadget_site);
}
#ifdef ISCOMFITOR
static void
_TEST_ADD(void *data, E_Dialog *dia EINA_UNUSED)
@ -366,16 +354,6 @@ e_int_menus_desktops_new(void)
e_util_menu_item_theme_icon_set(mi, "preferences-desktop-wallpaper");
e_menu_item_callback_set(mi, _e_int_menus_wallpaper_cb, NULL);
mi = e_menu_item_new(m);
e_menu_item_label_set(mi, _("Add Gadget Bar (EXPERIMENTAL)"));
e_util_menu_item_theme_icon_set(mi, "list-add");
e_menu_item_callback_set(mi, _e_int_menus_bryce_cb, NULL);
mi = e_menu_item_new(m);
e_menu_item_label_set(mi, _("Add Gadgets To Desktop"));
e_util_menu_item_theme_icon_set(mi, "list-add");
e_menu_item_callback_set(mi, _e_int_menus_desktop_gadget_add_cb, NULL);
mi = e_menu_item_new(m);
e_menu_item_separator_set(mi, 1);

13
src/bin/e_main.c
View File

@ -944,11 +944,6 @@ main(int argc, char **argv)
TS("E_Remember Init Done");
_e_main_shutdown_push(e_remember_shutdown);
TS("E_Gadget Init");
e_gadget_init();
TS("E_Gadget Init Done");
_e_main_shutdown_push((void*)e_gadget_shutdown);
TS("E_Gadcon Init");
if (!e_gadcon_init())
{
@ -1064,14 +1059,6 @@ main(int argc, char **argv)
_e_main_modules_load(safe_mode);
TS("Load Modules Done");
if (E_EFL_VERSION_MINIMUM(1, 17, 99))
{
TS("Bryce Init");
e_bryce_init();
TS("Bryce Init Done");
_e_main_shutdown_push((void*)e_bryce_shutdown);
}
TS("E_Shelf Init");
if (!e_shelf_init())
{

8
src/bin/generated/meson.build
View File

@ -4,7 +4,6 @@ protos = [
'../../protocol/www.xml',
'../../protocol/efl-aux-hints.xml',
'../../protocol/action_route.xml',
'../../protocol/e-gadget.xml',
'@0@/unstable/xdg-foreign/xdg-foreign-unstable-v1.xml'.format(dir_wayland_protocols),
'@0@/unstable/relative-pointer/relative-pointer-unstable-v1.xml'.format(dir_wayland_protocols),
'@0@/unstable/pointer-constraints/pointer-constraints-unstable-v1.xml'.format(dir_wayland_protocols),
@ -23,12 +22,5 @@ gadget_loader_protos = [
'../../protocol/e-gadget.xml',
]
gadget_loader_proto_files = []
foreach p: gadget_loader_protos
gadget_loader_proto_files += gen_scanner_client.process(p)
gadget_loader_proto_files += gen_scanner_impl.process(p)
endforeach
wayland_proto_c = proto_c
wayland_proto_h = proto_h

22
src/bin/meson.build
View File

@ -74,8 +74,6 @@ src = [
'e_backlight.c',
'e_bg.c',
'e_bindings.c',
'e_bryce.c',
'e_bryce_editor.c',
'e_client.c',
'e_client_volume.c',
'e_color.c',
@ -118,7 +116,6 @@ src = [
'e_font.c',
'e_gadcon.c',
'e_gadcon_popup.c',
'e_gadget.c',
'e_grabinput.c',
'e_grab_dialog.c',
'e_hints.c',
@ -248,7 +245,6 @@ hdr = [
'e_backlight.h',
'e_bg.h',
'e_bindings.h',
'e_bryce.h',
'e_client.h',
'e_client_volume.h',
'e_client.x',
@ -295,8 +291,6 @@ hdr = [
'e_font.h',
'e_gadcon.h',
'e_gadcon_popup.h',
'e_gadget.h',
'e_gadget_types.h',
'e_grabinput.h',
'e_grab_dialog.h',
'e.h',
@ -411,7 +405,6 @@ if config_h.has('HAVE_WAYLAND') == true
'e_comp_wl.c',
'e_comp_wl_extensions.c',
'e_comp_wl_extensions_tizen.c',
'e_gadget_runner.c',
wayland_proto_c,
wayland_proto_h
]
@ -559,20 +552,5 @@ executable('enlightenment_ckpasswd',
)
suid_exes += join_paths(dir_e_utils, 'enlightenment_ckpasswd')
if config_h.has('HAVE_WAYLAND') == true
shared_library('loader',
['e_gadget_loader.c', gadget_loader_proto_files],
name_prefix: '',
include_directories: include_directories('../..'),
dependencies: [
dep_dl,
dependency('uuid'),
dependency('elementary'),
dependency('ecore-wl2'),
dependency('wayland-client'),
cc.find_library('uuid')],
install_dir: join_paths([dir_lib, 'enlightenment/gadgets/', module_arch]),
install: true)
endif
subdir('e_fm')
subdir('system')

12
src/modules/backlight/e_mod_main.c
View File

@ -10,7 +10,6 @@
*/
#include "e.h"
#include "gadget/backlight.h"
/* gadcon requirements */
static E_Gadcon_Client *_gc_init(E_Gadcon *gc, const char *name, const char *id, const char *style);
@ -470,8 +469,6 @@ E_API E_Module_Api e_modapi =
E_API void *
e_modapi_init(E_Module *m)
{
e_modapi_gadget_init(m);
backlight_module = m;
e_gadcon_provider_register(&_gadcon_class);
E_LIST_HANDLER_APPEND(handlers, E_EVENT_BACKLIGHT_CHANGE, _backlight_cb_changed, NULL);
@ -487,10 +484,8 @@ e_modapi_init(E_Module *m)
}
E_API int
e_modapi_shutdown(E_Module *m)
e_modapi_shutdown(E_Module *m EINA_UNUSED)
{
e_modapi_gadget_shutdown(m);
if (act)
{
e_action_predef_name_del("Screen", "Backlight Controls");
@ -499,13 +494,12 @@ e_modapi_shutdown(E_Module *m)
}
E_FREE_LIST(handlers, ecore_event_handler_del);
e_gadcon_provider_unregister(&_gadcon_class);
backlight_module = NULL;
return 1;
}
E_API int
e_modapi_save(E_Module *m)
e_modapi_save(E_Module *m EINA_UNUSED)
{
e_modapi_gadget_save(m);
return 1;
}

302
src/modules/backlight/gadget/backlight.c
View File

@ -1,302 +0,0 @@
#include "backlight.h"
typedef struct _Instance Instance;
struct _Instance
{
Evas_Object *o_main;
Evas_Object *o_backlight, *o_table, *o_slider;
Evas_Object *popup, *box;
E_Gadget_Site_Orient orient;
double val;
};
static Eina_List *ginstances = NULL;
static E_Action *act = NULL;
static Eina_List *handlers;
static void
_backlight_gadget_update(Instance *inst)
{
Edje_Message_Float msg;
if (EINA_FLT_EQ(inst->val, -1.0))
msg.val = .75;
else
msg.val = inst->val;
if (msg.val < 0.0) msg.val = 0.0;
else if (msg.val > 1.0)
msg.val = 1.0;
edje_object_message_send(elm_layout_edje_get(inst->o_backlight), EDJE_MESSAGE_FLOAT, 0, &msg);
}
static void
_backlight_level_set(Instance *inst, double val, Eina_Bool set_slider)
{
if (val > 1.0) val = 1.0;
if (val < 0.0) val = 0.0;
inst->val = val;
if (set_slider)
elm_slider_value_set(inst->o_slider, inst->val * 100);
e_backlight_mode_set(e_comp_object_util_zone_get(inst->o_main), E_BACKLIGHT_MODE_NORMAL);
e_backlight_level_set(e_comp_object_util_zone_get(inst->o_main), inst->val, 0.0);
e_config->backlight.normal = inst->val;
e_config_save_queue();
}
static void
_slider_cb(void *data, Evas_Object *obj EINA_UNUSED, void *event_info EINA_UNUSED)
{
Instance *inst = data;
inst->val = elm_slider_value_get(inst->o_slider) / 100;
_backlight_level_set(inst, inst->val, EINA_FALSE);
}
static void
_backlight_popup_dismissed(void *data, Evas_Object *obj, void *event_info EINA_UNUSED)
{
Instance *inst = data;
E_FREE_FUNC(obj, evas_object_del);
inst->popup = NULL;
}
static void
_backlight_popup_deleted(void *data, Evas *e EINA_UNUSED, Evas_Object *obj EINA_UNUSED, void *event_info EINA_UNUSED)
{
Instance *inst = data;
inst->popup = NULL;
}
static void
_backlight_popup_new(Instance *inst)
{
Evas_Object *o;
if (inst->popup) return;
e_backlight_mode_set(e_comp_object_util_zone_get(inst->o_main), E_BACKLIGHT_MODE_NORMAL);
inst->val = e_backlight_level_get(e_comp_object_util_zone_get(inst->o_main));
_backlight_gadget_update(inst);
inst->popup = elm_ctxpopup_add(e_comp->elm);
elm_object_style_set(inst->popup, "noblock");
evas_object_smart_callback_add(inst->popup, "dismissed", _backlight_popup_dismissed, inst);
evas_object_event_callback_add(inst->popup, EVAS_CALLBACK_DEL, _backlight_popup_deleted, inst);
inst->box = elm_box_add(e_comp->elm);
elm_box_horizontal_set(inst->box, EINA_FALSE);
evas_object_size_hint_weight_set(inst->box, 0.0, 1.0);
evas_object_size_hint_align_set(inst->box, 0.0, 0.0);
elm_object_content_set(inst->popup, inst->box);
evas_object_show(inst->box);
o = elm_slider_add(inst->box);
elm_slider_horizontal_set(o, EINA_FALSE);
elm_slider_inverted_set(o, EINA_TRUE);
elm_slider_unit_format_set(o, "%.0f");
elm_slider_indicator_show_set(o, EINA_FALSE);
elm_slider_min_max_set(o, 1, 100.0);
elm_slider_step_set(o, 0.05);
elm_slider_span_size_set(o, 100);
elm_slider_value_set(o, inst->val * 100.0);
evas_object_smart_callback_add(o, "changed", _slider_cb, inst);
elm_box_pack_end(inst->box, o);
evas_object_show(o);
inst->o_slider = o;
e_gadget_util_ctxpopup_place(inst->o_main, inst->popup, inst->o_backlight);
evas_object_show(inst->popup);
}
static void
_backlight_cb_mouse_up(void *data, Evas *evas EINA_UNUSED, Evas_Object *obj EINA_UNUSED, void *event)
{
Instance *inst = data;
Evas_Event_Mouse_Up *ev = event;
if (ev->event_flags & EVAS_EVENT_FLAG_ON_HOLD) return;
if (ev->button == 1)
{
if (inst->popup) elm_ctxpopup_dismiss(inst->popup);
else _backlight_popup_new(inst);
}
}
static void
_backlight_cb_mouse_wheel(void *data, Evas *evas EINA_UNUSED, Evas_Object *obj EINA_UNUSED, void *event)
{
Evas_Event_Mouse_Wheel *ev = event;
Instance *inst = data;
inst->val = e_backlight_level_get(e_comp_object_util_zone_get(inst->o_main));
if (ev->z > 0)
_backlight_level_set(inst, inst->val - 0.1, EINA_TRUE);
else if (ev->z < 0)
_backlight_level_set(inst, inst->val + 0.1, EINA_TRUE);
}
static void
_e_mod_action_cb(E_Object *obj EINA_UNUSED,
const char *params)
{
Eina_List *l;
Instance *inst;
EINA_LIST_FOREACH(ginstances, l, inst)
{
if (params) _backlight_level_set(inst, inst->val + atof(params), EINA_TRUE);
}
}
static Eina_Bool
_backlight_cb_mod_init_end(void *d EINA_UNUSED, int type EINA_UNUSED, void *ev EINA_UNUSED)
{
Eina_List *l;
Instance *inst;
EINA_LIST_FOREACH(ginstances, l, inst)
{
inst->val = e_backlight_level_get(e_comp_object_util_zone_get(inst->o_main));
_backlight_gadget_update(inst);
}
return ECORE_CALLBACK_RENEW;
}
static Eina_Bool
_backlight_cb_changed(void *d EINA_UNUSED, int type EINA_UNUSED, void *ev EINA_UNUSED)
{
Eina_List *l;
Instance *inst;
EINA_LIST_FOREACH(ginstances, l, inst)
{
inst->val = e_backlight_level_get(e_comp_object_util_zone_get(inst->o_main));
_backlight_gadget_update(inst);
}
return ECORE_CALLBACK_RENEW;
}
static Evas_Object *
_backlight_gadget_configure(Evas_Object *g EINA_UNUSED)
{
if (e_configure_registry_exists("screen/power_management"))
{
e_configure_registry_call("screen/power_management", NULL, NULL);
}
return NULL;
}
static void
_backlight_resize_cb(void *data, Evas *e EINA_UNUSED, Evas_Object *obj EINA_UNUSED, void *event_data EINA_UNUSED)
{
Evas_Coord w, h;
Instance *inst = data;
edje_object_parts_extends_calc(elm_layout_edje_get(inst->o_backlight), 0, 0, &w, &h);
if (w < 1) w = 1;
if (h < 1) h = 1;
evas_object_size_hint_aspect_set(inst->o_main, EVAS_ASPECT_CONTROL_BOTH, w, h);
}
static void
_backlight_gadget_created_cb(void *data, Evas_Object *obj, void *event_info EINA_UNUSED)
{
Instance *inst = data;
if (inst->o_main)
{
e_gadget_configure_cb_set(inst->o_main, _backlight_gadget_configure);
inst->o_backlight = elm_layout_add(inst->o_main);
E_EXPAND(inst->o_backlight);
E_FILL(inst->o_backlight);
if (inst->orient == E_GADGET_SITE_ORIENT_VERTICAL)
e_theme_edje_object_set(inst->o_backlight,
"base/theme/gadget/backlight",
"e/gadget/backlight/main_vert");
else
e_theme_edje_object_set(inst->o_backlight,
"base/theme/gadget/backlight",
"e/gadget/backlight/main");
evas_object_event_callback_add(inst->o_backlight,
EVAS_CALLBACK_MOUSE_UP,
_backlight_cb_mouse_up,
inst);
evas_object_event_callback_add(inst->o_backlight,
EVAS_CALLBACK_MOUSE_WHEEL,
_backlight_cb_mouse_wheel,
inst);
evas_object_event_callback_add(inst->o_backlight,
EVAS_CALLBACK_RESIZE,
_backlight_resize_cb,
inst);
elm_box_pack_end(inst->o_main, inst->o_backlight);
evas_object_show(inst->o_backlight);
if (!EINA_FLT_EQ(inst->val, -1.0))
inst->val = e_backlight_level_get(e_comp_object_util_zone_get(inst->o_main));
_backlight_gadget_update(inst);
}
evas_object_smart_callback_del_full(obj, "gadget_created", _backlight_gadget_created_cb, data);
}
static void
backlight_del(void *data, Evas *e EINA_UNUSED, Evas_Object *obj EINA_UNUSED, void *event_info EINA_UNUSED)
{
Instance *inst = data;
if (inst->popup)
elm_ctxpopup_dismiss(inst->popup);
backlight_shutdown();
ginstances = eina_list_remove(ginstances, inst);
free(inst);
}
EINTERN Evas_Object *
backlight_gadget_create(Evas_Object *parent, int *id, E_Gadget_Site_Orient orient)
{
Instance *inst;
inst = E_NEW(Instance, 1);
inst->o_main = elm_box_add(parent);
inst->orient = orient;
if (*id != -1)
backlight_init();
else
inst->val = -1.0;
evas_object_smart_callback_add(parent, "gadget_created", _backlight_gadget_created_cb, inst);
if (*id != -1)
{
evas_object_event_callback_add(inst->o_main, EVAS_CALLBACK_DEL, backlight_del, inst);
ginstances = eina_list_append(ginstances, inst);
}
return inst->o_main;
}
EINTERN void
backlight_init(void)
{
E_LIST_HANDLER_APPEND(handlers, E_EVENT_BACKLIGHT_CHANGE, _backlight_cb_changed, NULL);
E_LIST_HANDLER_APPEND(handlers, E_EVENT_MODULE_INIT_END, _backlight_cb_mod_init_end, NULL);
act = e_action_add("backlight");
if (act)
{
act->func.go = _e_mod_action_cb;
e_action_predef_name_set(N_("Screen"), N_("Backlight Controls"), "backlight",
NULL, "syntax: brightness change(-1.0 - 1.0), example: -0.1", 1);
}
}
EINTERN void
backlight_shutdown(void)
{
if (act)
{
e_action_predef_name_del("Screen", "Backlight Controls");
e_action_del("backlight");
act = NULL;
}
E_FREE_LIST(handlers, ecore_event_handler_del);
}

14
src/modules/backlight/gadget/backlight.h
View File

@ -1,14 +0,0 @@
#ifndef BACKLIGHT_H
#define BACKLIGHT_H
#include "e.h"
EINTERN void *e_modapi_gadget_init(E_Module *m EINA_UNUSED);
EINTERN int e_modapi_gadget_shutdown(E_Module *m EINA_UNUSED);
EINTERN int e_modapi_gadget_save(E_Module *m EINA_UNUSED);
EINTERN Evas_Object *backlight_gadget_create(Evas_Object *parent, int *id EINA_UNUSED, E_Gadget_Site_Orient orient);
EINTERN void backlight_init(void);
EINTERN void backlight_shutdown(void);
#endif

22
src/modules/backlight/gadget/mod.c
View File

@ -1,22 +0,0 @@
#include "backlight.h"
EINTERN void *
e_modapi_gadget_init(E_Module *m)
{
e_gadget_type_add("Backlight", backlight_gadget_create, NULL);
return m;
}
EINTERN int
e_modapi_gadget_shutdown(E_Module *m EINA_UNUSED)
{
e_gadget_type_del("Backlight");
return 1;
}
EINTERN int
e_modapi_gadget_save(E_Module *m EINA_UNUSED)
{
return 1;
}

4
src/modules/backlight/meson.build
View File

@ -1,5 +1,3 @@
src = files(
'e_mod_main.c',
'gadget/backlight.c',
'gadget/mod.c'
'e_mod_main.c'
)

98
src/modules/bluez5/e_mod_main.c
View File

@ -33,96 +33,6 @@ _mod_icon_set(Evas_Object *base, Eina_Bool gadget)
/////////////////////////////////////////////////////////////////////////////
static void
_gad_popup_dismiss(void *data, Evas_Object *obj, void *event_info EINA_UNUSED)
{
Instance *inst = data;
E_FREE_FUNC(obj, evas_object_del);
inst->pop = NULL;
}
static void
_gad_popup_del(void *data, Evas *e EINA_UNUSED, Evas_Object *obj EINA_UNUSED, void *event_info EINA_UNUSED)
{
Instance *inst = data;
inst->pop = NULL;
}
static void
_gad_popup_do(Instance *inst)
{
Evas_Object *o;
if (inst->pop) return;
inst->pop = o = elm_ctxpopup_add(e_comp->elm);
elm_object_style_set(o, "noblock");
evas_object_smart_callback_add(o, "dismissed", _gad_popup_dismiss, inst);
evas_object_event_callback_add(o, EVAS_CALLBACK_DEL, _gad_popup_del, inst);
inst->popcontent = o = ebluez5_popup_content_add(e_comp->elm, inst);
elm_object_content_set(inst->pop, o);
evas_object_show(o);
e_gadget_util_ctxpopup_place(inst->o_bluez5, inst->pop, inst->o_bluez5);
evas_object_show(inst->pop);
}
static void
_gad_mouse_up(void *data, Evas *evas EINA_UNUSED,
Evas_Object *obj EINA_UNUSED, void *event)
{
Instance *inst = data;
Evas_Event_Mouse_Up *ev = event;
if (ev->event_flags & EVAS_EVENT_FLAG_ON_HOLD) return;
if (ev->button != 1) return;
if (!inst->pop) _gad_popup_do(inst);
else elm_ctxpopup_dismiss(inst->pop);
}
static void
_gad_del(void *data, Evas *e EINA_UNUSED, Evas_Object *obj EINA_UNUSED, void *event_info EINA_UNUSED)
{
Instance *inst = data;
instances = eina_list_remove(instances, inst);
E_FREE(inst);
}
/* XXX: fill in later when we have gotten this far
static Evas_Object *
_gad_config(Evas_Object *g EINA_UNUSED)
{
if (e_configure_registry_exists("extensions/bluez5"))
e_configure_registry_call("extensions/bluez5", NULL, NULL);
return NULL;
}
*/
static Evas_Object *
_gad_create(Evas_Object *parent, int *id, E_Gadget_Site_Orient orient)
{
Evas_Object *o;
Instance *inst = E_NEW(Instance, 1);
if (!inst) return NULL;
inst->id = *id;
inst->orient = orient;
inst->o_bluez5 = o = elm_layout_add(parent);
_mod_icon_set(o, EINA_TRUE);
evas_object_size_hint_aspect_set(o, EVAS_ASPECT_CONTROL_BOTH, 1, 1);
// XXX: fill in later when we have gotten this far
// e_gadget_configure_cb_set(o, _gad_config);
evas_object_event_callback_add(o, EVAS_CALLBACK_MOUSE_UP, _gad_mouse_up, inst);
if (*id != -1)
evas_object_event_callback_add(o, EVAS_CALLBACK_DEL, _gad_del, inst);
instances = eina_list_append(instances, inst);
return o;
}
/////////////////////////////////////////////////////////////////////////////
static void
_popup_del(Instance *inst)
{
@ -279,10 +189,6 @@ ebluez5_popups_show(void)
{
if (!inst->popup) _popup_new(inst);
}
else
{
if (!inst->pop) _gad_popup_do(inst);
}
}
}
@ -466,7 +372,6 @@ e_modapi_init(E_Module *m)
bz_init();
e_gadcon_provider_register(&_gc_class);
e_gadget_type_add("Bluetooth", _gad_create, NULL);
return m;
}
@ -494,9 +399,6 @@ e_modapi_shutdown(E_Module *m EINA_UNUSED)
bz_shutdown();
ebluze5_popup_shutdown();
e_gadget_type_del("Bluetooth");
e_gadcon_provider_unregister(&_gc_class);
E_CONFIG_DD_FREE(conf_edd);
E_CONFIG_DD_FREE(conf_adapter_edd);
return 1;

4
src/modules/bluez5/e_mod_main.h
View File

@ -12,11 +12,7 @@ struct _Instance
// e_gadcon info
E_Gadcon_Client *gcc;
E_Gadcon_Popup *popup;
// e_gadget info
Evas_Object *pop;
Evas_Object *popcontent;
int id;
E_Gadget_Site_Orient orient;
};
typedef struct _Config Config;

9
src/modules/conf_display/e_int_config_desklock.c
View File

@ -208,12 +208,6 @@ _free_data(E_Config_Dialog *cfd EINA_UNUSED, E_Config_Dialog_Data *cfdata)
free(cfdata);
}
static void
_cb_lockscreen_gadgets()
{
e_gadget_site_desklock_edit();
}
static Evas_Object *
_basic_create(E_Config_Dialog *cfd, Evas *evas, E_Config_Dialog_Data *cfdata)
{
@ -276,9 +270,6 @@ _basic_create(E_Config_Dialog *cfd, Evas *evas, E_Config_Dialog_Data *cfdata)
e_widget_disabled_set(cfdata->lock_cmd_entry,
(cfdata->desklock_auth_method != E_DESKLOCK_AUTH_METHOD_EXTERNAL));
e_widget_list_object_append(ol, of, 1, 1, 0.5);
ow = e_widget_button_add(evas, _("Configure Lockscreen Gadgets"), "configure", _cb_lockscreen_gadgets, NULL, NULL);
e_widget_list_object_append(ol, ow, 1, 1, 0.5);
e_widget_toolbook_page_append(otb, NULL, _("Locking"), ol,
1, 1, 1, 0, 0.0, 0.0);

2066
src/modules/luncher/bar.c
View File

File diff suppressed because it is too large Load Diff

572
src/modules/luncher/config.c
View File

@ -1,572 +0,0 @@
#include "luncher.h"
static void
_config_close(void *data EINA_UNUSED, Evas *e EINA_UNUSED, Evas_Object *obj EINA_UNUSED, void *event_info EINA_UNUSED)
{
luncher_config->list = NULL;
luncher_config->slist = NULL;
evas_object_del(luncher_config->config_dialog);
luncher_config->config_dialog = NULL;
e_config_save_queue();
}
static void
_config_show_general(void *data EINA_UNUSED, Evas_Object *obj EINA_UNUSED, void *event_info EINA_UNUSED)
{
evas_object_hide(luncher_config->contents);
evas_object_show(luncher_config->general);
}
static void
_config_show_contents(void *data EINA_UNUSED, Evas_Object *obj EINA_UNUSED, void *event_info EINA_UNUSED)
{
evas_object_hide(luncher_config->general);
evas_object_show(luncher_config->contents);
}
static void
_type_changed(void *data, Evas_Object *obj, void *event_info EINA_UNUSED)
{
Instance *inst = data;
int value = elm_radio_value_get(obj);
switch (value)
{
case 0:
inst->cfg->type = E_LUNCHER_MODULE_FULL;
break;
case 1:
inst->cfg->type = E_LUNCHER_MODULE_LAUNCH_ONLY;
break;
case 2:
inst->cfg->type = E_LUNCHER_MODULE_TASKS_ONLY;
break;
default:
inst->cfg->type = E_LUNCHER_MODULE_FULL;
}
e_config_save_queue();
bar_config_updated(inst);
}
static void
_check_changed(void *data, Evas_Object *obj, void *event_info EINA_UNUSED)
{
Instance *inst = data;
inst->cfg->hide_tooltips = elm_check_state_get(obj);
e_config_save_queue();
bar_config_updated(inst);
}
static void
_config_source_changed(void *data, Evas_Object *obj EINA_UNUSED, void *event_info EINA_UNUSED)
{
Instance *inst = data;
const char *dir = elm_object_item_text_get(elm_list_selected_item_get(luncher_config->list));
if (eina_streq(inst->cfg->dir, dir))
return;
if (inst->cfg->dir) eina_stringshare_del(inst->cfg->dir);
inst->cfg->dir = NULL;
inst->cfg->dir = eina_stringshare_ref(dir);
bar_reorder(inst);
}
static void
_config_populate_order_list(Evas_Object *list, Instance *inst)
{
Eina_List *dirs;
char buf[4096], *file;
size_t len;
Elm_Object_Item *it;
elm_list_clear(list);
len = e_user_dir_concat_static(buf, "applications/bar");
if (len + 2 >= sizeof(buf)) return;
dirs = ecore_file_ls(buf);
buf[len] = '/';
len++;
EINA_LIST_FREE(dirs, file)
{
if (file[0] == '.') continue;
if (eina_strlcpy(buf + len, file, sizeof(buf) - len) >= sizeof(buf) - len)
continue;
if (ecore_file_is_dir(buf))
{
it = elm_list_item_append(list, file, NULL, NULL, _config_source_changed, inst);
if ((inst->cfg->dir) && (eina_streq(inst->cfg->dir, file)))
elm_list_item_selected_set(it, EINA_TRUE);
}
free(file);
}
elm_list_go(list);
}
static void
_config_source_cancel(void *data)
{
Instance *inst = data;
config_luncher(e_zone_current_get(), inst, luncher_config->bar);
}
static void
_config_source_added(void *data, char *text)
{
Instance *inst = data;
char buf[4096];
char tmp[4096] = {0};
FILE *f;
size_t len;
len = e_user_dir_snprintf(buf, sizeof(buf), "applications/bar/%s", text);
if (len + sizeof("/.order") >= sizeof(buf)) return;
while (!ecore_file_exists(buf))
{
ecore_file_mkdir(buf);
memcpy(buf + len, "/.order", sizeof("/.order"));
e_user_dir_concat_static(tmp, "applications/bar/default/.order");
if (ecore_file_cp(tmp, buf)) break;
f = fopen(buf, "w");
if (!f) break;
/* Populate this .order file with some defaults */
snprintf(tmp, sizeof(tmp),
"terminology.desktop\n"
"sylpheed.desktop\n"
"firefox.desktop\n"
"openoffice.desktop\n"
"xchat.desktop\n"
"gimp.desktop\n");
fwrite(tmp, sizeof(char), strlen(tmp), f);
fclose(f);
break;
}
config_luncher(e_zone_current_get(), inst, luncher_config->bar);
}
static void
_config_source_deleted(void *data)
{
char buf[4096];
Instance *inst = data;
if (e_user_dir_snprintf(buf, sizeof(buf), "applications/bar/%s", inst->cfg->dir) >= sizeof(buf))
return;
if (ecore_file_is_dir(buf))
ecore_file_recursive_rm(buf);
e_object_del(E_OBJECT(inst->order));
config_luncher(e_zone_current_get(), inst, luncher_config->bar);
}
static void
_config_source_add(void *data, Evas_Object *obj EINA_UNUSED, void *event_data EINA_UNUSED)
{
Instance *inst = data;
evas_object_del(luncher_config->config_dialog);
e_entry_dialog_show(_("Create new Luncher source"), "enlightenment",
_("Enter a name for this new source:"), "", NULL, NULL,
_config_source_added, _config_source_cancel, inst);
}
static void
_config_source_del(void *data, Evas_Object *obj EINA_UNUSED, void *event_data EINA_UNUSED)
{
Instance *inst = data;
char buf[4096];
evas_object_del(luncher_config->config_dialog);
snprintf(buf, sizeof(buf), _("You requested to delete \"%s\".<ps/><ps/>"
"Are you sure you want to delete this bar source?"),
inst->cfg->dir);
e_confirm_dialog_show(_("Are you sure you want to delete this bar source?"),
"application-exit", buf, _("Delete"), _("Keep"),
_config_source_deleted, _config_source_cancel, inst, inst,
NULL, NULL);
}
static void
_config_contents(void *data, Evas_Object *obj, void *event_data EINA_UNUSED)
{
Instance *inst = data;
Evas_Object *popup = evas_object_data_get(obj, "popup");
if (e_configure_registry_exists("applications/ibar_applications"))
{
char path[4096];
e_user_dir_snprintf(path, sizeof(path), "applications/bar/%s/.order",
inst->cfg->dir);
e_configure_registry_call("internal/ibar_other", NULL, path);
evas_object_del(popup);
}
}
static void
_config_create_icon(void *data, Evas_Object *obj, void *event_data EINA_UNUSED)
{
Instance *inst = data;
Evas_Object *popup = evas_object_data_get(obj, "popup");
if (e_configure_registry_exists("applications/new_application"))
{
char path[4096];
e_user_dir_snprintf(path, sizeof(path), "applications/bar/%s/.order",
inst->cfg->dir);
e_configure_registry_call("applications/new_application", NULL, path);
evas_object_del(popup);
}
}
static void
_icon_theme_file_set(Evas_Object *img, const char *icon)
{
const char *path = NULL, *k = NULL;
char buf[4096];
int len = 0;
if (!icon)
path = NULL;
else if (strncmp(icon, "/", 1) && !ecore_file_exists(icon))
{
path = efreet_icon_path_find(e_config->icon_theme, icon, 48);
if (!path)
{
if (e_util_strcmp(e_config->icon_theme, "hicolor"))
path = efreet_icon_path_find("hicolor", icon, 48);
}
}
else if (ecore_file_exists(icon))
{
path = icon;
}
if (!path && icon)
{
snprintf(buf, sizeof(buf), "e/icons/%s", icon);
if (eina_list_count(e_theme_collection_items_find("base/theme/icons", buf)))
{
path = e_theme_edje_file_get("base/theme/icons", buf);
k = buf;
}
else
{
path = e_theme_edje_file_get("base/theme/icons", "e/icons/unknown");
k = "e/icons/unknown";
}
}
else if (!path && !icon)
{
path = e_theme_edje_file_get("base/theme/icons", "e/icons/unknown");
k = "e/icons/unknown";
}
if (path && icon)
{
len = strlen(icon);
if ((len > 4) && (!strcasecmp(icon + len - 4, ".edj")))
k = "icon";
}
elm_image_file_set(img, path, k);
}
static void
_update_preview_size(void *data, Evas_Object *obj, void *event_info EINA_UNUSED)
{
Instance *inst = data;
int value = elm_slider_value_get(obj);
inst->cfg->preview_size = value;
e_config_save_queue();
}
EINTERN Evas_Object *
config_luncher(E_Zone *zone, Instance *inst, Eina_Bool bar)
{
Evas_Object *popup, *tb, *lbl, *fr, *box, *list, *mlist;
Evas_Object *butbox, *sep, *hbox, *img, *but, *o, *group;
Evas_Object *slider, *check;
Elm_Object_Item *it;
luncher_config->bar = bar;
popup = elm_popup_add(e_comp->elm);
E_EXPAND(popup);
elm_popup_allow_events_set(popup, 1);
elm_popup_scrollable_set(popup, 1);
tb = elm_table_add(popup);
E_EXPAND(tb);
evas_object_size_hint_align_set(tb, EVAS_HINT_FILL, EVAS_HINT_FILL);
evas_object_show(tb);
elm_object_content_set(popup, tb);
lbl = elm_label_add(tb);
evas_object_size_hint_weight_set(lbl, EVAS_HINT_EXPAND, 0.0);
evas_object_size_hint_align_set(lbl, EVAS_HINT_FILL, EVAS_HINT_FILL);
elm_object_style_set(lbl, "marker");
evas_object_show(lbl);
elm_object_text_set(lbl, _("Luncher Configuration"));
elm_table_pack(tb, lbl, 0, 0, 2, 1);
mlist = elm_list_add(tb);
E_ALIGN(mlist, 0, EVAS_HINT_FILL);
E_WEIGHT(mlist, 0, EVAS_HINT_EXPAND);
elm_table_pack(tb, mlist, 0, 1, 1, 1);
elm_list_select_mode_set(mlist, ELM_OBJECT_SELECT_MODE_ALWAYS);
elm_scroller_content_min_limit(mlist, 1, 1);
it = elm_list_item_append(mlist, _("General"), NULL, NULL,
_config_show_general, inst);
elm_list_item_selected_set(it, 1);
it = elm_list_item_append(mlist, _("Contents"), NULL, NULL,
_config_show_contents, inst);
elm_list_go(mlist);
evas_object_show(mlist);
fr = elm_frame_add(tb);
elm_object_text_set(fr, _("General"));
E_EXPAND(fr);
evas_object_size_hint_align_set(fr, EVAS_HINT_FILL, EVAS_HINT_FILL);
elm_table_pack(tb, fr, 1, 1, 1, 1);
evas_object_show(fr);
luncher_config->general = fr;
box = elm_box_add(fr);
elm_box_horizontal_set(box, EINA_FALSE);
E_EXPAND(box);
evas_object_show(box);
lbl = elm_label_add(box);
elm_object_text_set(lbl, _("Luncher Type:"));
E_ALIGN(lbl, 0.5, 0.5);
E_WEIGHT(lbl, EVAS_HINT_EXPAND, 0);
elm_box_pack_end(box, lbl);
evas_object_show(lbl);
o = elm_radio_add(box);
elm_radio_state_value_set(o, 0);
E_ALIGN(o, 0.0, 0.0);
E_WEIGHT(o, EVAS_HINT_EXPAND, 0);
elm_object_text_set(o, _("Launcher and Taskbar"));
elm_box_pack_end(box, o);
evas_object_smart_callback_add(o, "changed", _type_changed, inst);
evas_object_show(o);
group = o;
o = elm_radio_add(box);
elm_radio_state_value_set(o, 1);
elm_radio_group_add(o, group);
E_ALIGN(o, 0.0, 0.0);
E_WEIGHT(o, EVAS_HINT_EXPAND, 0);
elm_object_text_set(o, _("Launcher Only"));
elm_box_pack_end(box, o);
evas_object_smart_callback_add(o, "changed", _type_changed, inst);
evas_object_show(o);
o = elm_radio_add(box);
elm_radio_state_value_set(o, 2);
elm_radio_group_add(o, group);
E_ALIGN(o, 0.0, 0.0);
E_WEIGHT(o, EVAS_HINT_EXPAND, 0);
elm_object_text_set(o, _("Taskbar Only"));
elm_box_pack_end(box, o);
evas_object_smart_callback_add(o, "changed", _type_changed, inst);
evas_object_show(o);
switch(inst->cfg->type)
{
case E_LUNCHER_MODULE_FULL:
elm_radio_value_set(group, 0);
break;
case E_LUNCHER_MODULE_LAUNCH_ONLY:
elm_radio_value_set(group, 1);
break;
case E_LUNCHER_MODULE_TASKS_ONLY:
elm_radio_value_set(group, 2);
break;
default:
elm_radio_value_set(group, 0);
}
o = elm_separator_add(box);
elm_separator_horizontal_set(o, EINA_TRUE);
E_EXPAND(o);
E_FILL(o);
elm_box_pack_end(box, o);
evas_object_show(o);
lbl = elm_label_add(box);
elm_object_text_set(lbl, _("Tooltips:"));
E_ALIGN(lbl, 0.5, 0.5);
E_WEIGHT(lbl, EVAS_HINT_EXPAND, 0);
elm_box_pack_end(box, lbl);
evas_object_show(lbl);
check = elm_check_add(box);
elm_object_text_set(check, _("Hide tooltips"));
elm_check_state_set(check, inst->cfg->hide_tooltips);
E_ALIGN(check, 0.0, 0.0);
E_WEIGHT(check, EVAS_HINT_EXPAND, 0);
evas_object_smart_callback_add(check, "changed", _check_changed, inst);
elm_box_pack_end(box, check);
evas_object_show(check);
o = elm_separator_add(box);
elm_separator_horizontal_set(o, EINA_TRUE);
E_EXPAND(o);
E_FILL(o);
elm_box_pack_end(box, o);
evas_object_show(o);
lbl = elm_label_add(box);
elm_object_text_set(lbl, _("Preview Size:"));
E_ALIGN(lbl, 0.5, 0.5);
E_WEIGHT(lbl, EVAS_HINT_EXPAND, 0);
elm_box_pack_end(box, lbl);
evas_object_show(lbl);
slider = elm_slider_add(box);
elm_slider_unit_format_set(slider, "%1.0f");
elm_slider_indicator_format_set(slider, "%1.0f");
elm_slider_min_max_set(slider, 1, 256);
elm_slider_value_set(slider, inst->cfg->preview_size);
elm_slider_step_set(slider, 1 / 256.0);
elm_slider_span_size_set(slider, 256);
E_ALIGN(slider, 0.0, 0.0);
E_WEIGHT(slider, EVAS_HINT_EXPAND, 0);
evas_object_smart_callback_add(slider, "delay,changed", _update_preview_size, inst);
elm_box_pack_end(box, slider);
evas_object_show(slider);
elm_object_content_set(fr, box);
fr = elm_frame_add(tb);
elm_object_text_set(fr, _("Contents"));
E_EXPAND(fr);
evas_object_size_hint_align_set(fr, EVAS_HINT_FILL, EVAS_HINT_FILL);
elm_table_pack(tb, fr, 1, 1, 1, 1);
evas_object_show(fr);
luncher_config->contents = fr;
box = elm_box_add(fr);
elm_box_horizontal_set(box, EINA_FALSE);
E_EXPAND(box);
evas_object_size_hint_align_set(box, EVAS_HINT_FILL, EVAS_HINT_FILL);
evas_object_show(box);
hbox = elm_box_add(box);
elm_box_horizontal_set(hbox, EINA_TRUE);
elm_box_homogeneous_set(hbox, EINA_FALSE);
evas_object_size_hint_expand_set(hbox, 0.0, EVAS_HINT_EXPAND);
evas_object_size_hint_align_set(hbox, EVAS_HINT_FILL, EVAS_HINT_FILL);
elm_box_pack_end(box, hbox);
evas_object_show(hbox);
list = elm_list_add(hbox);
E_ALIGN(list, EVAS_HINT_FILL, EVAS_HINT_FILL);
E_WEIGHT(list, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND);
elm_box_pack_end(hbox, list);
elm_list_select_mode_set(list, ELM_OBJECT_SELECT_MODE_ALWAYS);
elm_scroller_content_min_limit(list, 1, 1);
evas_object_show(list);
luncher_config->list = list;
_config_populate_order_list(list, inst);
butbox = elm_box_add(hbox);
elm_box_horizontal_set(butbox, EINA_FALSE);
E_EXPAND(butbox);
evas_object_size_hint_align_set(butbox, EVAS_HINT_FILL, EVAS_HINT_FILL);
elm_box_pack_end(hbox, butbox);
evas_object_show(butbox);
sep = elm_separator_add(box);
elm_separator_horizontal_set(sep, EINA_TRUE);
elm_box_pack_end(box, sep);
evas_object_show(sep);
img = elm_icon_add(butbox);
evas_object_size_hint_aspect_set(img, EVAS_ASPECT_CONTROL_VERTICAL, 1, 1);
_icon_theme_file_set(img, "list-add");
evas_object_show(img);
but = elm_button_add(butbox);
elm_object_part_content_set(but, "icon", img);
elm_object_text_set(but, _("Add"));
E_EXPAND(but);
evas_object_size_hint_align_set(but, EVAS_HINT_FILL, EVAS_HINT_FILL);
evas_object_data_set(but, "popup", popup);
evas_object_smart_callback_add(but, "clicked", _config_source_add, inst);
elm_box_pack_end(butbox, but);
evas_object_show(but);
img = elm_icon_add(butbox);
evas_object_size_hint_aspect_set(img, EVAS_ASPECT_CONTROL_VERTICAL, 1, 1);
_icon_theme_file_set(img, "list-remove");
evas_object_show(img);
but = elm_button_add(butbox);
elm_object_part_content_set(but, "icon", img);
elm_object_text_set(but, _("Delete"));
E_EXPAND(but);
evas_object_size_hint_align_set(but, EVAS_HINT_FILL, EVAS_HINT_FILL);
evas_object_data_set(but, "popup", popup);
evas_object_smart_callback_add(but, "clicked", _config_source_del, inst);
elm_box_pack_end(butbox, but);
evas_object_show(but);
hbox = elm_box_add(box);
elm_box_horizontal_set(hbox, EINA_TRUE);
elm_box_homogeneous_set(hbox, EINA_TRUE);
E_EXPAND(box);
evas_object_size_hint_align_set(hbox, EVAS_HINT_FILL, EVAS_HINT_FILL);
elm_box_pack_end(box, hbox);
evas_object_show(hbox);
img = elm_icon_add(hbox);
evas_object_size_hint_aspect_set(img, EVAS_ASPECT_CONTROL_VERTICAL, 1, 1);
_icon_theme_file_set(img, "document-new");
evas_object_show(img);
but = elm_button_add(hbox);
elm_object_part_content_set(but, "icon", img);
elm_object_text_set(but, _("Create New Icon"));
E_EXPAND(but);
evas_object_size_hint_align_set(but, EVAS_HINT_FILL, EVAS_HINT_FILL);
evas_object_data_set(but, "popup", popup);
evas_object_smart_callback_add(but, "clicked", _config_create_icon, inst);
elm_box_pack_end(hbox, but);
evas_object_show(but);
img = elm_icon_add(hbox);
evas_object_size_hint_aspect_set(img, EVAS_ASPECT_CONTROL_VERTICAL, 1, 1);
_icon_theme_file_set(img, "list-add");
evas_object_show(img);
but = elm_button_add(hbox);
elm_object_part_content_set(but, "icon", img);
elm_object_text_set(but, _("Contents"));
E_EXPAND(but);
evas_object_size_hint_align_set(but, EVAS_HINT_FILL, EVAS_HINT_FILL);
evas_object_data_set(but, "popup", popup);
evas_object_smart_callback_add(but, "clicked", _config_contents, inst);
elm_box_pack_end(hbox, but);
evas_object_show(but);
elm_object_content_set(fr, box);
_config_show_general(NULL, NULL, NULL);
popup = e_comp_object_util_add(popup, E_COMP_OBJECT_TYPE_NONE);
evas_object_layer_set(popup, E_LAYER_POPUP);
evas_object_resize(popup, zone->w / 4, zone->h / 3);
e_comp_object_util_center_on_zone(popup, zone);
evas_object_show(popup);
e_comp_object_util_autoclose(popup, NULL, e_comp_object_util_autoclose_on_escape, NULL);
evas_object_event_callback_add(popup, EVAS_CALLBACK_DEL, _config_close, NULL);
return luncher_config->config_dialog = popup;
}

BIN
src/modules/luncher/e-module-luncher.edj
View File

Binary file not shown.

754
src/modules/luncher/grid.c
View File

@ -1,754 +0,0 @@
#include "luncher.h"
static Eina_List *handlers;
static Elm_Gengrid_Item_Class _grid_icon_class;
static void _grid_resize_job(void *data);
static void
_grid_aspect(Instance *inst)
{
Evas_Coord w, h, square, size;
if (!eina_list_count(inst->icons))
return;
evas_object_geometry_get(inst->o_main, 0, 0, &w, &h);
size = 0;
if ((w + h) > 1)
{
square = w + h;
size = floor((square / eina_list_count(inst->icons)));
}
inst->size = size;
elm_gengrid_item_size_set(inst->o_icon_con, size, size);
}
static Eina_Bool
_grid_check_modifiers(Evas_Modifier *modifiers)
{
if ((evas_key_modifier_is_set(modifiers, "Alt")) ||
(evas_key_modifier_is_set(modifiers, "Control")) ||
(evas_key_modifier_is_set(modifiers, "Shift")))
return EINA_TRUE;
return EINA_FALSE;
}
static Evas_Object *
_grid_gadget_configure(Evas_Object *g)
{
if (!luncher_config) return NULL;
if (luncher_config->config_dialog) return NULL;
Instance *inst = evas_object_data_get(g, "instance");
return config_luncher(e_zone_current_get(), inst, EINA_TRUE);
}
static void
_grid_instance_watch(void *data, E_Exec_Instance *ex EINA_UNUSED, E_Exec_Watch_Type type)
{
Icon *ic = data;
switch (type)
{
case E_EXEC_WATCH_STARTED:
if (ic->starting) elm_layout_signal_emit(ic->o_layout, "e,state,started", "e");
ic->starting = EINA_FALSE;
break;
default:
break;
}
}
static void
_grid_icon_del(Instance *inst, Icon *ic)
{
inst->icons = eina_list_remove(inst->icons, ic);
evas_object_del(ic->o_icon);
evas_object_del(ic->o_layout);
if (ic->desktop)
efreet_desktop_unref(ic->desktop);
eina_stringshare_del(ic->icon);
eina_stringshare_del(ic->key);
if (ic->exec)
e_exec_instance_watcher_del(ic->exec, _grid_instance_watch, ic);
ic->exec = NULL;
_grid_aspect(inst);
E_FREE(ic);
}
static void
_grid_icon_drag_done(E_Drag *drag, int dropped)
{
Instance *inst = e_object_data_get(E_OBJECT(drag));
efreet_desktop_unref(drag->data);
if (!inst) return;
evas_object_smart_callback_call(e_gadget_site_get(inst->o_main), "gadget_site_unlocked", NULL);
if (!dropped)
grid_recalculate(inst);
}
static void
_grid_icon_mouse_move(void *data, Evas *e EINA_UNUSED, Evas_Object *obj EINA_UNUSED, void *event_data)
{
Icon *ic = data;
Evas_Event_Mouse_Move *ev = event_data;
int dx, dy;
if (ev->event_flags & EVAS_EVENT_FLAG_ON_HOLD) return;
if (_grid_check_modifiers(ev->modifiers)) return;
if (!ic->drag.start) return;
dx = ev->cur.output.x - ic->drag.x;
dy = ev->cur.output.y - ic->drag.y;
if (((dx * dx) + (dy * dy)) >
(e_config->drag_resist * e_config->drag_resist))
{
E_Drag *d;
Evas_Object *o;
Evas_Coord x, y, w, h;
unsigned int size;
const char *drag_types[] = { "enlightenment/desktop" };
ic->drag.dnd = 1;
ic->drag.start = 0;
evas_object_geometry_get(ic->o_icon, &x, &y, &w, &h);
d = e_drag_new(x, y, drag_types, 1,
ic->desktop, -1, NULL, _grid_icon_drag_done);
d->button_mask = evas_pointer_button_down_mask_get(e_comp->evas);
efreet_desktop_ref(ic->desktop);
size = MAX(w, h);
o = e_util_desktop_icon_add(ic->desktop, size, e_drag_evas_get(d));
e_drag_object_set(d, o);
e_drag_resize(d, w, h);
e_drag_start(d, ic->drag.x, ic->drag.y);
e_object_data_set(E_OBJECT(d), ic->inst);
if (ic->in_order)
e_order_remove(ic->inst->order, ic->desktop);
}
}
static Eina_Bool
_grid_drag_timer(void *data)
{
Icon *ic = data;
ic->drag_timer = NULL;
ic->drag.start = 1;
evas_object_smart_callback_call(e_gadget_site_get(ic->inst->o_main), "gadget_site_locked", NULL);
return EINA_FALSE;
}
static void
_grid_icon_mouse_down(void *data, Evas *e EINA_UNUSED, Evas_Object *obj EINA_UNUSED, void *event_data)
{
Icon *ic = data;
Evas_Event_Mouse_Up *ev = event_data;
if (ev->event_flags & EVAS_EVENT_FLAG_ON_HOLD)
{
if (ev->button == 1)
{
ic->drag.start = 0;
ic->drag.dnd = 0;
E_FREE_FUNC(ic->mouse_in_timer, ecore_timer_del);
E_FREE_FUNC(ic->mouse_out_timer, ecore_timer_del);
E_FREE_FUNC(ic->drag_timer, ecore_timer_del);
}
return;
}
if (_grid_check_modifiers(ev->modifiers)) return;
if (ev->button == 1)
{
ic->drag.x = ev->output.x;
ic->drag.y = ev->output.y;
E_FREE_FUNC(ic->drag_timer, ecore_timer_del);
ic->drag_timer = ecore_timer_loop_add(.35, _grid_drag_timer, ic);
}
}
static void
_grid_icon_mouse_up(void *data, Evas *e EINA_UNUSED, Evas_Object *obj EINA_UNUSED, void *event_data)
{
Icon *ic = data;
Evas_Event_Mouse_Up *ev = event_data;
if (ev->event_flags & EVAS_EVENT_FLAG_ON_HOLD) return;
if (_grid_check_modifiers(ev->modifiers)) return;
if (ev->button == 1)
{
E_FREE_FUNC(ic->drag_timer, ecore_timer_del);
if (ic->drag.dnd)
{
ic->drag.start = 0;
ic->drag.dnd = 0;
return;
}
}
if (ev->button == 1 && ic->desktop)
{
if (ic->desktop->type == EFREET_DESKTOP_TYPE_APPLICATION)
{
E_Exec_Instance *ex;
ex = e_exec(e_zone_current_get(), ic->desktop, NULL, NULL, "luncher");
ic->exec = ex;
e_exec_instance_watcher_add(ex, _grid_instance_watch, ic);
if (!ic->starting) elm_layout_signal_emit(ic->o_layout, "e,state,starting", "e");
ic->starting = EINA_TRUE;
}
else if (ic->desktop->type == EFREET_DESKTOP_TYPE_LINK)
{
if (!strncasecmp(ic->desktop->url, "file:", 5))
{
E_Action *act;
act = e_action_find("fileman");
if (act)
act->func.go(NULL, ic->desktop->url + 5);
}
}
}
}
static void
_grid_icon_mouse_in(void *data, Evas *e EINA_UNUSED, Evas_Object *obj, void *event_data)
{
Icon *ic = data;
Evas_Event_Mouse_In *ev = event_data;
if (ev->event_flags & EVAS_EVENT_FLAG_ON_HOLD) return;
if (_grid_check_modifiers(ev->modifiers)) return;
evas_object_raise(ic->o_layout);
if (!ic->inst->cfg->hide_tooltips)
elm_object_tooltip_show(obj);
ic->active = EINA_TRUE;
elm_layout_signal_emit(ic->o_layout, "e,state,focused", "e");
}
static void
_grid_icon_mouse_out(void *data, Evas *e EINA_UNUSED, Evas_Object *obj, void *event_data EINA_UNUSED)
{
Icon *ic = data;
if (!ic->inst->cfg->hide_tooltips)
elm_object_tooltip_hide(obj);
elm_layout_signal_emit(ic->o_layout, "e,state,unfocused", "e");
}
static Evas_Object *
_gengrid_icon_get(void *data, Evas_Object *obj EINA_UNUSED, const char *part)
{
Icon *ic = data;
if (strcmp(part, "elm.swallow.icon"))
return NULL;
return ic->o_layout;
}
static void
_grid_icon_file_set(Icon *ic, Efreet_Desktop *desktop)
{
const char *path = NULL, *k = NULL;
char buf[4096];
if (desktop)
{
if (!desktop->icon)
path = NULL;
else if (strncmp(desktop->icon, "/", 1) && !ecore_file_exists(desktop->icon))
{
path = efreet_icon_path_find(e_config->icon_theme, desktop->icon, ic->inst->size);
if (!path)
{
if (e_util_strcmp(e_config->icon_theme, "hicolor"))
path = efreet_icon_path_find("hicolor", desktop->icon, ic->inst->size);
}
}
else if (ecore_file_exists(desktop->icon))
{
path = desktop->icon;
}
if (!path && desktop->icon)
{
snprintf(buf, sizeof(buf), "e/icons/%s", desktop->icon);
if (eina_list_count(e_theme_collection_items_find("base/theme/icons", buf)))
{
path = e_theme_edje_file_get("base/theme/icons", buf);
k = buf;
}
else
{
path = e_theme_edje_file_get("base/theme/icons", "e/icons/unknown");
k = "e/icons/unknown";
}
}
else if (!path && !desktop->icon)
{
path = e_theme_edje_file_get("base/theme/icons", "e/icons/unknown");
k = "e/icons/unknown";
}
}
else if (ic->icon)
{
if (strncmp(ic->icon, "/", 1) && !ecore_file_exists(ic->icon))
{
path = efreet_icon_path_find(e_config->icon_theme, ic->icon, ic->inst->size);
if (!path)
{
if (e_util_strcmp(e_config->icon_theme, "hicolor"))
path = efreet_icon_path_find("hicolor", ic->icon, ic->inst->size);
}
}
else if (ecore_file_exists(ic->icon))
{
path = ic->icon;
k = ic->key;
}
if (!path)
{
path = e_theme_edje_file_get("base/theme/icons", "e/icons/unknown");
k = "e/icons/unknown";
}
}
else
{
path = e_theme_edje_file_get("base/theme/icons", "e/icons/unknown");
k = "e/icons/unknown";
}
elm_image_file_set(ic->o_icon, path, k);
}
static Icon *
_grid_icon_add(Instance *inst, Efreet_Desktop *desktop)
{
Icon *ic;
ic = E_NEW(Icon, 1);
efreet_desktop_ref(desktop);
ic->desktop = desktop;
ic->inst = inst;
ic->preview = NULL;
ic->preview_box = NULL;
ic->mouse_in_timer = NULL;
ic->mouse_out_timer = NULL;
ic->active = EINA_FALSE;
ic->starting = EINA_FALSE;
ic->exec = NULL;
ic->o_layout = elm_layout_add(inst->o_icon_con);
e_theme_edje_object_set(ic->o_layout, "e/gadget/luncher/icon",
"e/gadget/luncher/icon");
E_FILL(ic->o_layout);
evas_object_show(ic->o_layout);
ic->o_icon = elm_icon_add(ic->o_layout);
E_EXPAND(ic->o_icon);
_grid_icon_file_set(ic, desktop);
if (!inst->cfg->hide_tooltips)
{
elm_object_tooltip_text_set(ic->o_icon, desktop->name);
elm_object_tooltip_orient_set(ic->o_icon, ELM_TOOLTIP_ORIENT_CENTER);
elm_object_tooltip_style_set(ic->o_icon, "luncher");
}
evas_object_size_hint_aspect_set(ic->o_icon, EVAS_ASPECT_CONTROL_BOTH, 1, 1);
elm_layout_content_set(ic->o_layout, "e.swallow.icon", ic->o_icon);
evas_object_event_callback_add(ic->o_icon, EVAS_CALLBACK_MOUSE_UP,
_grid_icon_mouse_up, ic);
evas_object_event_callback_priority_add(ic->o_icon, EVAS_CALLBACK_MOUSE_DOWN, 0,
_grid_icon_mouse_down, ic);
evas_object_event_callback_add(ic->o_icon, EVAS_CALLBACK_MOUSE_MOVE,
_grid_icon_mouse_move, ic);
evas_object_event_callback_add(ic->o_icon, EVAS_CALLBACK_MOUSE_IN,
_grid_icon_mouse_in, ic);
evas_object_event_callback_add(ic->o_icon, EVAS_CALLBACK_MOUSE_OUT,
_grid_icon_mouse_out, ic);
evas_object_show(ic->o_icon);
elm_layout_sizing_eval(ic->o_layout);
elm_gengrid_item_append(inst->o_icon_con, &_grid_icon_class, ic, NULL, NULL);
_grid_aspect(inst);
return ic;
}
static void
_grid_empty(Instance *inst)
{
if (inst->icons)
{
elm_gengrid_clear(inst->o_icon_con);
while (inst->icons)
_grid_icon_del(inst, eina_list_data_get(inst->icons));
inst->icons = NULL;
}
}
static void
_grid_fill(Instance *inst)
{
Icon *ic;
if (inst->order)
{
Efreet_Desktop *desktop;
Eina_List *list;
EINA_LIST_FOREACH(inst->order->desktops, list, desktop)
{
ic = _grid_icon_add(inst, desktop);
ic->in_order = EINA_TRUE;
inst->icons = eina_list_append(inst->icons, ic);
}
}
}
static void
_grid_resize_job(void *data)
{
Instance *inst = data;
Eina_List *l;
Icon *ic;
if (inst)
{
elm_layout_sizing_eval(inst->o_main);
_grid_aspect(inst);
EINA_LIST_FOREACH(inst->icons, l, ic)
_grid_icon_file_set(ic, ic->desktop);
inst->resize_job = NULL;
}
}
static Eina_Bool
_grid_cb_update_icons(EINA_UNUSED void *data, EINA_UNUSED int ev_type, EINA_UNUSED void *ev)
{
Instance *inst = NULL;
Eina_List *l = NULL;
EINA_LIST_FOREACH(luncher_instances, l, inst)
{
if (inst->bar) continue;
if (inst->resize_job) return ECORE_CALLBACK_RENEW;
inst->resize_job = ecore_job_add(_grid_resize_job, inst);
}
return ECORE_CALLBACK_PASS_ON;
}
static void
_grid_resize(void *data, Evas *e EINA_UNUSED, Evas_Object *obj EINA_UNUSED, void *event_data EINA_UNUSED)
{
Instance *inst = data;
if (inst->resize_job) return;
inst->resize_job = ecore_job_add(_grid_resize_job, inst);
}
static void
_grid_removed_cb(void *data, Evas_Object *obj EINA_UNUSED, void *event_data)
{
Instance *inst = data;
char buf[4096];
if (inst->o_main != event_data) return;
if (e_user_dir_snprintf(buf, sizeof(buf), "applications/bar/%s", inst->cfg->dir) >= sizeof(buf))
return;
luncher_config->items = eina_list_remove(luncher_config->items, inst->cfg);
eina_stringshare_del(inst->cfg->dir);
E_FREE(inst->cfg);
}
static void
_grid_del(void *data, Evas *e EINA_UNUSED, Evas_Object *obj, void *event_data EINA_UNUSED)
{
Instance *inst = data;
evas_object_smart_callback_del_full(e_gadget_site_get(obj), "gadget_removed", _grid_removed_cb, inst);
e_object_del(E_OBJECT(inst->order));
E_FREE_FUNC(inst->drop_handler, evas_object_del);
luncher_instances = eina_list_remove(luncher_instances, inst);
free(inst);
}
static void
_grid_drop_drop(void *data, const char *type, void *event_data)
{
Instance *inst = data;
E_Event_Dnd_Drop *ev = event_data;
Efreet_Desktop *desktop = NULL;
Eina_List *l = NULL;
Icon *ic = NULL;
evas_object_del(inst->place_holder);
inst->place_holder = NULL;
if (!strcmp(type, "enlightenment/desktop"))
desktop = ev->data;
else if (!strcmp(type, "enlightenment/border"))
{
E_Client *ec;
ec = ev->data;
desktop = ec->desktop;
if (!desktop)
{
desktop = e_desktop_client_create(ec);
efreet_desktop_save(desktop);
e_desktop_edit(desktop);
}
}
else if (!strcmp(type, "text/uri-list"))
l = ev->data;
ic = inst->drop_before;
if (ic)
{
if (desktop)
e_order_prepend_relative(inst->order, desktop, ic->desktop);
else
e_order_files_prepend_relative(inst->order, l, ic->desktop);
}
else
{
if (desktop)
e_order_append(inst->order, desktop);
else
e_order_files_append(inst->order, l);
}
}
static void
_grid_drop_leave(void *data, const char *type EINA_UNUSED, void *event_data EINA_UNUSED)
{
Instance *inst = data;
inst->inside = EINA_FALSE;
evas_object_del(inst->place_holder);
inst->place_holder = NULL;
}
static void
_grid_drop_move(void *data, const char *type EINA_UNUSED, void *event_data)
{
Instance *inst = data;
E_Event_Dnd_Move *ev = event_data;
Evas_Coord x = ev->x, y = ev->y;
Eina_List *l;
Icon *ic;
if (!inst->inside)
return;
EINA_LIST_FOREACH(inst->icons, l, ic)
{
Evas_Coord dx, dy, dw, dh;
if (!ic->in_order) continue;
evas_object_geometry_get(ic->o_layout, &dx, &dy, &dw, &dh);
if (E_INSIDE(x, y, dx, dy, dw, dh))
inst->drop_before = ic;
}
if (inst->drop_before)
elm_gengrid_item_insert_before(inst->o_icon_con, &_grid_icon_class, inst->place_holder, inst->drop_before->o_layout, NULL, NULL);
}
static void
_grid_drop_enter(void *data, const char *type EINA_UNUSED, void *event_data EINA_UNUSED)
{
Instance *inst = data;
inst->inside = EINA_TRUE;
inst->place_holder = evas_object_rectangle_add(evas_object_evas_get(inst->o_icon_con));
evas_object_color_set(inst->place_holder, 0, 0, 0, 0);
evas_object_size_hint_min_set(inst->place_holder, inst->size, inst->size);
evas_object_size_hint_max_set(inst->place_holder, inst->size, inst->size);
evas_object_show(inst->place_holder);
}
static void
_grid_anchor_changed_cb(void *data, Evas_Object *obj EINA_UNUSED, void *event_info EINA_UNUSED)
{
Instance *inst = data;
if (inst && inst->o_icon_con)
{
grid_recalculate(inst);
}
}
static void
_grid_order_update(void *data, E_Order *eo EINA_UNUSED)
{
Instance *inst = data;
if (inst && inst->o_icon_con)
{
grid_recalculate(inst);
}
}
static void
_grid_created_cb(void *data, Evas_Object *obj, void *event_data EINA_UNUSED)
{
Instance *inst = data;
char buf[4096];
const char *drop[] = { "enlightenment/desktop", "enlightenment/border", "text/uri-list" };
inst->o_icon_con = elm_gengrid_add(inst->o_main);
elm_object_style_set(inst->o_icon_con, "no_inset_shadow");
elm_gengrid_align_set(inst->o_icon_con, 0.5, 0.5);
elm_gengrid_select_mode_set(inst->o_icon_con, ELM_OBJECT_SELECT_MODE_NONE);
E_FILL(inst->o_icon_con);
elm_layout_content_set(inst->o_main, "e.swallow.grid", inst->o_icon_con);
evas_object_show(inst->o_icon_con);
evas_object_data_set(inst->o_main, "instance", inst);
evas_object_data_set(inst->o_icon_con, "instance", inst);
e_gadget_configure_cb_set(inst->o_main, _grid_gadget_configure);
evas_object_smart_callback_del_full(obj, "gadget_created", _grid_created_cb, data);
if (!inst->cfg->dir)
inst->cfg->dir = eina_stringshare_add("default");
if (inst->cfg->dir[0] != '/')
e_user_dir_snprintf(buf, sizeof(buf), "applications/bar/%s/.order",
inst->cfg->dir);
else
eina_strlcpy(buf, inst->cfg->dir, sizeof(buf));
inst->order = e_order_new(buf);
e_order_update_callback_set(inst->order, _grid_order_update, inst);
_grid_fill(inst);
inst->drop_handler =
e_gadget_drop_handler_add(inst->o_main, inst,
_grid_drop_enter, _grid_drop_move,
_grid_drop_leave, _grid_drop_drop,
drop, 3);
elm_layout_content_set(inst->o_main, "e.swallow.drop", inst->drop_handler);
evas_object_show(inst->drop_handler);
evas_object_event_callback_add(inst->o_main, EVAS_CALLBACK_RESIZE, _grid_resize, inst);
_grid_aspect(inst);
}
static Config_Item *
_conf_item_get(int *id)
{
Config_Item *ci;
Eina_List *l;
if (*id > 0)
{
EINA_LIST_FOREACH(luncher_config->items, l, ci)
if (*id == ci->id) return ci;
}
ci = E_NEW(Config_Item, 1);
if (*id != -1)
ci->id = eina_list_count(luncher_config->items)+1;
else
ci->id = -1;
ci->dir = eina_stringshare_add("default");
luncher_config->items = eina_list_append(luncher_config->items, ci);
return ci;
}
static void
_grid_recalculate_job(void *data)
{
Instance *inst = data;
if (inst)
{
if (inst->o_icon_con)
{
_grid_empty(inst);
_grid_fill(inst);
}
inst->recalc_job = NULL;
}
}
EINTERN void
grid_recalculate(Instance *inst)
{
E_FREE_FUNC(inst->recalc_job, ecore_job_del);
inst->recalc_job = ecore_job_add(_grid_recalculate_job, inst);
}
EINTERN void
grid_reorder(Instance *inst)
{
char buf[4096];
if (inst)
{
E_FREE_FUNC(inst->recalc_job, ecore_job_del);
_grid_empty(inst);
if (!inst->cfg->dir)
inst->cfg->dir = eina_stringshare_add("default");
if (inst->cfg->dir[0] != '/')
e_user_dir_snprintf(buf, sizeof(buf), "applications/bar/%s/.order",
inst->cfg->dir);
else
eina_strlcpy(buf, inst->cfg->dir, sizeof(buf));
e_object_del(E_OBJECT(inst->order));
inst->order = e_order_new(buf);
e_order_update_callback_set(inst->order, _grid_order_update, inst);
_grid_fill(inst);
}
}
EINTERN Evas_Object *
grid_create(Evas_Object *parent, int *id, E_Gadget_Site_Orient orient)
{
Instance *inst;
if (orient) return NULL;
if (e_gadget_site_is_desklock(parent)) return NULL;
inst = E_NEW(Instance, 1);
inst->size = 0;
inst->resize_job = NULL;
inst->cfg = _conf_item_get(id);
*id = inst->cfg->id;
inst->inside = EINA_FALSE;
inst->bar = EINA_FALSE;
if (!inst->cfg->preview_size)
inst->cfg->preview_size = 64;
_grid_icon_class.item_style = "luncher";
_grid_icon_class.func.text_get = NULL;
_grid_icon_class.func.content_get = _gengrid_icon_get;
_grid_icon_class.func.state_get = NULL;
_grid_icon_class.func.del = NULL;
inst->o_main = elm_layout_add(parent);
e_theme_edje_object_set(inst->o_main, "e/gadget/luncher/grid",
"e/gadget/luncher/grid");
evas_object_event_callback_add(inst->o_main, EVAS_CALLBACK_DEL, _grid_del, inst);
evas_object_smart_callback_add(parent, "gadget_created", _grid_created_cb, inst);
evas_object_smart_callback_add(parent, "gadget_site_anchor", _grid_anchor_changed_cb, inst);
evas_object_smart_callback_add(parent, "gadget_removed", _grid_removed_cb, inst);
evas_object_show(inst->o_main);
E_LIST_HANDLER_APPEND(handlers, E_EVENT_CONFIG_ICON_THEME,
_grid_cb_update_icons, NULL);
E_LIST_HANDLER_APPEND(handlers, EFREET_EVENT_ICON_CACHE_UPDATE,
_grid_cb_update_icons, NULL);
if (inst->cfg->id < 0) return inst->o_main;
luncher_instances = eina_list_append(luncher_instances, inst);
return inst->o_main;
}

114
src/modules/luncher/luncher.h
View File

@ -1,114 +0,0 @@
#ifndef LUNCHER_H
#define LUNCHER_H
#include "e.h"
E_API extern E_Module_Api e_modapi;
E_API void *e_modapi_init (E_Module *m);
E_API int e_modapi_shutdown (E_Module *m);
E_API int e_modapi_save (E_Module *m);
typedef struct _Config Config;
typedef struct _Config_Item Config_Item;
typedef struct _Instance Instance;
typedef struct _Icon Icon;
typedef enum _Luncher_Type Luncher_Type;
enum _Luncher_Type
{
E_LUNCHER_MODULE_FULL = 0,
E_LUNCHER_MODULE_LAUNCH_ONLY,
E_LUNCHER_MODULE_TASKS_ONLY
};
struct _Config
{
Eina_List *items;
E_Module *module;
Evas_Object *config_dialog;
Evas_Object *slist;
Evas_Object *list;
Evas_Object *general;
Evas_Object *contents;
Eina_Bool bar;
};
struct _Config_Item
{
int id;
int version;
int preview_size;
int hide_tooltips;
Eina_Stringshare *dir;
Luncher_Type type;
};
struct _Instance
{
Evas_Object *o_main;
Evas_Object *o_icon_con;
Evas_Object *drop_handler;
Evas_Object *place_holder;
Evas_Object *current_preview;
E_Order *order;
Eina_List *icons;
Eina_Hash *icons_desktop_hash;
Eina_Hash *icons_clients_hash;
Evas_Coord size;
Ecore_Job *resize_job;
Ecore_Job *recalc_job;
E_Comp_Object_Mover *iconify_provider;
Eina_Bool main_del;
Eina_Bool bar;
Eina_Bool inside;
Eina_Bool current_preview_menu;
Config_Item *cfg;
Icon *drop_before;
};
struct _Icon
{
Instance *inst;
Evas_Object *o_layout;
Evas_Object *o_icon;
Evas_Object *preview;
Evas_Object *preview_box;
Evas_Object *preview_scroller;
Evas_Object *client_menu;
E_Exec_Instance *exec;
Efreet_Desktop *desktop;
Eina_List *execs;
Eina_List *clients;
Eina_List *client_cbs;
Ecore_Timer *mouse_in_timer;
Ecore_Timer *mouse_out_timer;
Ecore_Timer *drag_timer;
Eina_Stringshare *icon;
Eina_Stringshare *key;
Eina_Bool in_order;
Eina_Bool active;
Eina_Bool starting;
Eina_Bool preview_dismissed;
struct
{
unsigned char start E_BITFIELD;
unsigned char dnd E_BITFIELD;
int x, y;
} drag;
};
EINTERN Evas_Object *config_luncher(E_Zone *zone, Instance *inst, Eina_Bool bar);
EINTERN Evas_Object *bar_create(Evas_Object *parent, int *id, E_Gadget_Site_Orient orient);
EINTERN void bar_reorder(Instance *inst);
EINTERN void bar_recalculate(Instance *inst);
EINTERN void bar_config_updated(Instance *inst);
EINTERN Evas_Object *grid_create(Evas_Object *parent, int *id, E_Gadget_Site_Orient orient);
EINTERN void grid_reorder(Instance *inst);
EINTERN void grid_recalculate(Instance *inst);
EINTERN extern Config *luncher_config;
EINTERN extern Eina_List *luncher_instances;
#endif

7
src/modules/luncher/meson.build
View File

@ -1,7 +0,0 @@
src = files(
'mod.c',
'bar.c',
'config.c',
'grid.c',
'luncher.h'
)

108
src/modules/luncher/mod.c
View File

@ -1,108 +0,0 @@
#include "luncher.h"
#define CONFIG_VERSION 2
static E_Config_DD *conf_edd = NULL;
static E_Config_DD *conf_item_edd = NULL;
Eina_List *luncher_instances = NULL;
Config *luncher_config = NULL;
EINTERN void
luncher_init(void)
{
Eina_List *l;
Config_Item *ci;
conf_item_edd = E_CONFIG_DD_NEW("Luncher_Config_Item", Config_Item);
#undef T
#undef D
#define T Config_Item
#define D conf_item_edd
E_CONFIG_VAL(D, T, id, INT);
E_CONFIG_VAL(D, T, version, INT);
E_CONFIG_VAL(D, T, preview_size, INT);
E_CONFIG_VAL(D, T, dir, STR);
E_CONFIG_VAL(D, T, type, INT);
E_CONFIG_VAL(D, T, hide_tooltips, INT);
conf_edd = E_CONFIG_DD_NEW("Luncher_Config", Config);
#undef T
#undef D
#define T Config
#define D conf_edd
E_CONFIG_LIST(D, T, items, conf_item_edd);
luncher_config = e_config_domain_load("module.luncher", conf_edd);
if (!luncher_config)
{
luncher_config = E_NEW(Config, 1);
ci = E_NEW(Config_Item, 1);
ci->id = 0;
ci->version = CONFIG_VERSION;
ci->preview_size = 64;
ci->dir = eina_stringshare_add("default");
ci->type = E_LUNCHER_MODULE_FULL;
ci->hide_tooltips = 0;
luncher_config->items = eina_list_append(luncher_config->items, ci);
}
EINA_LIST_FOREACH(luncher_config->items, l, ci)
{
if (ci->version < CONFIG_VERSION)
{
ci->version = CONFIG_VERSION;
ci->type = E_LUNCHER_MODULE_FULL;
}
}
e_gadget_type_add("Luncher Bar", bar_create, NULL);
e_gadget_type_add("Luncher Grid", grid_create, NULL);
}
EINTERN void
luncher_shutdown(void)
{
if (luncher_config)
{
Config_Item *ci;
EINA_LIST_FREE(luncher_config->items, ci)
{
eina_stringshare_del(ci->dir);
free(ci);
}
E_FREE(luncher_config);
}
E_CONFIG_DD_FREE(conf_edd);
E_CONFIG_DD_FREE(conf_item_edd);
e_gadget_type_del("Luncher Bar");
e_gadget_type_del("Luncher Grid");
}
E_API E_Module_Api e_modapi =
{
E_MODULE_API_VERSION,
"Luncher"
};
E_API void *
e_modapi_init(E_Module *m)
{
luncher_init();
luncher_config->module = m;
return m;
}
E_API int
e_modapi_shutdown(E_Module *m EINA_UNUSED)
{
luncher_shutdown();
return 1;
}
E_API int
e_modapi_save(E_Module *m EINA_UNUSED)
{
e_config_domain_save("module.luncher", conf_edd, luncher_config);
return 1;
}

36
src/modules/luncher/module.desktop
View File

@ -1,36 +0,0 @@
[Desktop Entry]
Type=Link
Name=Luncher
Name[ca]=Luncher
Name[cs]=Lišta spouštěčů
Name[de]=Luncher
Name[eo]=Breto Luncher
Name[fi]=Luncher
Name[fr]=Luncher
Name[gl]=Luncher
Name[ja]=Luncher
Name[ms]=Luncher
Name[pl]=Luncher
Name[ru]=Luncher
Name[sr]=И-трака
Name[tr]=Luncher
Comment=Iconic application launcher.
Comment[ca]=Barra d'icones per a executar aplicacions.
Comment[cs]=Lišta se spouštěči.
Comment[de]=Symbolbasierter Anwendungsstarter.
Comment[el]=Εικονικός εκκινητής εφαρμογών.
Comment[eo]=Lanĉilo de piktograma aplikaĵo.
Comment[es]=Lanzador de aplicaciones con íconos.
Comment[fi]=Ikoninen sovelluskäynnistin.
Comment[fr]=Barre d'icones permettant de lancer des applications.
Comment[gl]=Unha barra de iconas para iniciar aplicativos.
Comment[hu]=Ikonokkal bővíthető alkalmazásindító modul.
Comment[it]=Una barra di icone per il lancio di applicazioni.
Comment[ja]=Iconic アプリケーションランチャー
Comment[ms]=Pelancar aplikasi ikonik
Comment[pt]=Barra para iniciar aplicações
Comment[ru]=Панель для запуска приложений, представленных в виде значков.
Comment[sr]=Трака иконица покретача програма.
Comment[tr]=Uygulama başlatıcı.
Icon=e-module-luncher
X-Enlightenment-ModuleType=utils

5
src/modules/meson.build
View File

@ -44,16 +44,11 @@ mods = [
'xkbswitch',
'tiling',
'packagekit',
'wireless',
'time',
'luncher',
'teamwork',
'vkbd',
# modules have a custom binary as well
'battery',
'cpufreq',
'clock',
'sysinfo',
# custyom sub modules and custom data
'wizard',
# also standard modules, just with only a desktop file using a generic icon

3
src/modules/mixer/gadget/backend.c → src/modules/mixer/backend.c
View File

@ -3,8 +3,7 @@
#include "emix.h"
#include "e_mod_main.h"
#include "e_mod_config.h"
#include "gadget/mixer.h"
#include "gadget/backend.h"
#include "backend.h"
#define VOLUME_STEP 5

0
src/modules/mixer/gadget/backend.h → src/modules/mixer/backend.h
View File

15
src/modules/mixer/e_mod_main.c
View File

@ -3,8 +3,8 @@
#include "emix.h"
#include "e_mod_main.h"
#include "e_mod_config.h"
#include "gadget/mixer.h"
#include "gadget/backend.h"
#include "mixer.h"
#include "backend.h"
EINTERN int _e_emix_log_domain;
@ -444,7 +444,7 @@ _gc_id_new(const E_Gadcon_Client_Class *client_class EINA_UNUSED)
}
E_API void *
e_modapi_init(E_Module *m)
e_modapi_init(E_Module *m EINA_UNUSED)
{
char buf[4096];
@ -466,8 +466,6 @@ e_modapi_init(E_Module *m)
E_LIST_HANDLER_APPEND(_handlers, E_EVENT_MIXER_SINKS_CHANGED,
_mixer_sinks_changed, NULL);
e_modapi_gadget_init(m);
e_configure_registry_category_add("extensions", 90, _("Extensions"), NULL,
"preferences-extensions");
e_configure_registry_item_add("extensions/emix", 30, _("Mixer"), NULL,
@ -480,7 +478,7 @@ e_modapi_init(E_Module *m)
}
E_API int
e_modapi_shutdown(E_Module *m)
e_modapi_shutdown(E_Module *m EINA_UNUSED)
{
e_gadcon_provider_unregister((const E_Gadcon_Client_Class *)&_gadcon_class);
@ -491,16 +489,13 @@ e_modapi_shutdown(E_Module *m)
E_FREE(mixer_context);
}
e_modapi_gadget_shutdown(m);
backend_shutdown();
return 1;
}
E_API int
e_modapi_save(E_Module *m)
e_modapi_save(E_Module *m EINA_UNUSED)
{
e_modapi_gadget_save(m);
emix_config_save();
return 1;
}

423
src/modules/mixer/gadget/mixer.c
View File

@ -1,423 +0,0 @@
#include "mixer.h"
#include "backend.h"
typedef struct _Context Context;
struct _Context
{
char *theme;
E_Module *module;
Eina_List *instances;
E_Menu *menu;
unsigned int notification_id;
};
typedef struct _Instance Instance;
struct _Instance
{
int id;
Evas_Object *o_main;
Evas_Object *o_mixer;
Evas_Object *popup;
Evas_Object *list;
Evas_Object *slider;
Evas_Object *check;
E_Gadget_Site_Orient orient;
};
static Context *gmixer_context = NULL;
static Eina_List *_handlers = NULL;
static void
_mixer_popup_update(Instance *inst, int mute, int vol)
{
elm_check_state_set(inst->check, !!mute);
elm_slider_value_set(inst->slider, vol);
}
static void
_mixer_gadget_update(void)
{
Edje_Message_Int_Set *msg;
Instance *inst;
Eina_List *l;
const Eina_List *ll;
Elm_Object_Item *it;
EINA_LIST_FOREACH(gmixer_context->instances, l, inst)
{
msg = alloca(sizeof(Edje_Message_Int_Set) + (2 * sizeof(int)));
msg->count = 3;
if (!backend_sink_default_get())
{
msg->val[0] = EINA_FALSE;
msg->val[1] = 0;
msg->val[2] = 0;
if (inst->popup)
elm_ctxpopup_dismiss(inst->popup);
}
else
{
msg->val[0] = backend_mute_get();
msg->val[1] = backend_volume_get();
msg->val[2] = msg->val[1];
if (inst->popup)
_mixer_popup_update(inst, msg->val[0], msg->val[1]);
}
edje_object_message_send(elm_layout_edje_get(inst->o_mixer), EDJE_MESSAGE_INT_SET, 0, msg);
elm_layout_signal_emit(inst->o_mixer, "e,action,volume,change", "e");
if (inst->list)
{
EINA_LIST_FOREACH(elm_list_items_get(inst->list), ll, it)
{
if (backend_sink_default_get() == elm_object_item_data_get(it))
elm_list_item_selected_set(it, EINA_TRUE);
}
}
}
}
static Eina_Bool
_mixer_backend_changed(void *data EINA_UNUSED, int type EINA_UNUSED, void *event EINA_UNUSED)
{
_mixer_gadget_update();
return ECORE_CALLBACK_PASS_ON;
}
static void
_emixer_exec_cb(void *data, Evas_Object *obj EINA_UNUSED, void *event_info EINA_UNUSED)
{
Instance *inst = data;
elm_ctxpopup_dismiss(inst->popup);
backend_emixer_exec();
}
static void
_check_changed_cb(void *data EINA_UNUSED, Evas_Object *obj,
void *event EINA_UNUSED)
{
backend_mute_set(elm_check_state_get(obj));
}
static void
_slider_changed_cb(void *data EINA_UNUSED, Evas_Object *obj,
void *event EINA_UNUSED)
{
int val;
val = (int)elm_slider_value_get(obj);
backend_volume_set(val);
}
static void
_sink_selected_cb(void *data, Evas_Object *obj EINA_UNUSED, void *event_info EINA_UNUSED)
{
Emix_Sink *s = data;
backend_sink_default_set(s);
}
static void
_mixer_popup_dismissed(void *data, Evas_Object *obj, void *event_info EINA_UNUSED)
{
Instance *inst = data;
E_FREE_FUNC(obj, evas_object_del);
inst->popup = NULL;
}
static void
_mixer_popup_deleted(void *data, Evas *e EINA_UNUSED, Evas_Object *obj EINA_UNUSED, void *event_info EINA_UNUSED)
{
Instance *inst = data;
inst->popup = NULL;
inst->list = NULL;
inst->slider = NULL;
inst->check = NULL;
}
static Eina_Bool
_mixer_sinks_changed(void *data EINA_UNUSED, int type EINA_UNUSED, void *event EINA_UNUSED)
{
Eina_List *l, *ll;
Instance *inst;
EINA_LIST_FOREACH(gmixer_context->instances, l, inst)
{
if (inst->list)
{
Elm_Object_Item *default_it = NULL;
Emix_Sink *s;
elm_list_clear(inst->list);
EINA_LIST_FOREACH((Eina_List *)emix_sinks_get(), ll, s)
{
Elm_Object_Item *it;
it = elm_list_item_append(inst->list, s->name, NULL, NULL,
_sink_selected_cb, s);
if (backend_sink_default_get() == s)
default_it = it;
}
elm_list_go(inst->list);
if (default_it)
elm_list_item_selected_set(default_it, EINA_TRUE);
}
}
return ECORE_CALLBACK_PASS_ON;
}
static void
_popup_new(Instance *inst)
{
Evas_Object *button, *list, *slider, *bx;
Emix_Sink *s;
Eina_List *l;
Elm_Object_Item *default_it = NULL;
inst->popup = elm_ctxpopup_add(e_comp->elm);
elm_object_style_set(inst->popup, "noblock");
evas_object_smart_callback_add(inst->popup, "dismissed", _mixer_popup_dismissed, inst);
evas_object_event_callback_add(inst->popup, EVAS_CALLBACK_DEL, _mixer_popup_deleted, inst);
list = elm_box_add(e_comp->elm);
elm_object_content_set(inst->popup, list);
inst->list = elm_list_add(e_comp->elm);
elm_list_mode_set(inst->list, ELM_LIST_COMPRESS);
evas_object_size_hint_align_set(inst->list, EVAS_HINT_FILL, EVAS_HINT_FILL);
evas_object_size_hint_weight_set(inst->list, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND);
evas_object_show(inst->list);
EINA_LIST_FOREACH((Eina_List *)emix_sinks_get(), l, s)
{
Elm_Object_Item *it;
it = elm_list_item_append(inst->list, s->name, NULL, NULL, _sink_selected_cb, s);
if (backend_sink_default_get() == s)
default_it = it;
}
elm_list_go(inst->list);
elm_box_pack_end(list, inst->list);
bx = elm_box_add(e_comp->elm);
elm_box_horizontal_set(bx, EINA_TRUE);
evas_object_size_hint_weight_set(bx, EVAS_HINT_EXPAND, 0.0);
evas_object_size_hint_align_set(bx, EVAS_HINT_FILL, 0.0);
elm_box_pack_end(list, bx);
evas_object_show(bx);
slider = elm_slider_add(e_comp->elm);
inst->slider = slider;
elm_slider_span_size_set(slider, 128 * elm_config_scale_get());
elm_slider_unit_format_set(slider, "%1.0f");
elm_slider_indicator_format_set(slider, "%1.0f");
evas_object_size_hint_align_set(slider, EVAS_HINT_FILL, EVAS_HINT_FILL);
evas_object_size_hint_weight_set(slider, EVAS_HINT_EXPAND, 0.0);
evas_object_show(slider);
elm_slider_min_max_set(slider, 0.0, emix_max_volume_get());
evas_object_smart_callback_add(slider, "changed", _slider_changed_cb, NULL);
elm_slider_value_set(slider, backend_volume_get());
elm_box_pack_end(bx, slider);
evas_object_show(slider);
inst->check = elm_check_add(e_comp->elm);
evas_object_size_hint_align_set(inst->check, 0.5, EVAS_HINT_FILL);
elm_object_text_set(inst->check, _("Mute"));
elm_check_state_set(inst->check, backend_mute_get());
evas_object_smart_callback_add(inst->check, "changed", _check_changed_cb,
NULL);
elm_box_pack_end(bx, inst->check);
evas_object_show(inst->check);
button = elm_button_add(e_comp->elm);
evas_object_size_hint_align_set(button, EVAS_HINT_FILL, EVAS_HINT_FILL);
evas_object_size_hint_weight_set(button, EVAS_HINT_EXPAND, 0.0);
elm_object_text_set(button, _("Mixer"));
evas_object_smart_callback_add(button, "clicked", _emixer_exec_cb, inst);
elm_box_pack_end(list, button);
evas_object_show(button);
evas_object_size_hint_min_set(list, 208, 208);
e_gadget_util_ctxpopup_place(inst->o_main, inst->popup, inst->o_mixer);
evas_object_show(inst->popup);
if (default_it)
elm_list_item_selected_set(default_it, EINA_TRUE);
}
static void
_mouse_up_cb(void *data, Evas *evas EINA_UNUSED,
Evas_Object *obj EINA_UNUSED, void *event)
{
Instance *inst = data;
Evas_Event_Mouse_Up *ev = event;
if (ev->event_flags & EVAS_EVENT_FLAG_ON_HOLD) return;
if (ev->button == 1)
{
if (inst->popup)
{
elm_ctxpopup_dismiss(inst->popup);
return;
}
_popup_new(inst);
}
else if (ev->button == 2)
{
backend_mute_set(!backend_mute_get());
}
}
static void
_mouse_wheel_cb(void *data EINA_UNUSED, Evas *evas EINA_UNUSED,
Evas_Object *obj EINA_UNUSED, void *event)
{
Evas_Event_Mouse_Wheel *ev = event;
if (ev->z > 0)
backend_volume_decrease();
else if (ev->z < 0)
backend_volume_increase();
}
static Evas_Object *
_mixer_gadget_configure(Evas_Object *g EINA_UNUSED)
{
if (e_configure_registry_exists("extensions/emix"))
{
e_configure_registry_call("extensions/emix", NULL, NULL);
}
return NULL;
}
static void
_mixer_resize_cb(void *data, Evas *e EINA_UNUSED, Evas_Object *obj EINA_UNUSED, void *event_data EINA_UNUSED)
{
Evas_Coord w, h;
Instance *inst = data;
edje_object_parts_extends_calc(elm_layout_edje_get(inst->o_mixer), 0, 0, &w, &h);
if (w < 1) w = 1;
if (h < 1) h = 1;
evas_object_size_hint_aspect_set(inst->o_main, EVAS_ASPECT_CONTROL_BOTH, w, h);
}
static void
_mixer_gadget_created_cb(void *data, Evas_Object *obj, void *event_info EINA_UNUSED)
{
Instance *inst = data;
if (inst->o_main)
{
e_gadget_configure_cb_set(inst->o_main, _mixer_gadget_configure);
inst->o_mixer = elm_layout_add(inst->o_main);
E_EXPAND(inst->o_mixer);
E_FILL(inst->o_mixer);
if (inst->orient == E_GADGET_SITE_ORIENT_VERTICAL)
e_theme_edje_object_set(inst->o_mixer,
"base/theme/gadget/mixer",
"e/gadget/mixer/main_vert");
else
e_theme_edje_object_set(inst->o_mixer,
"base/theme/gadget/mixer",
"e/gadget/mixer/main");
evas_object_event_callback_add(inst->o_mixer, EVAS_CALLBACK_MOUSE_UP,
_mouse_up_cb, inst);
evas_object_event_callback_add(inst->o_mixer, EVAS_CALLBACK_MOUSE_WHEEL,
_mouse_wheel_cb, inst);
evas_object_event_callback_add(inst->o_mixer, EVAS_CALLBACK_RESIZE,
_mixer_resize_cb, inst);
elm_box_pack_end(inst->o_main, inst->o_mixer);
evas_object_show(inst->o_mixer);
if (inst->id != -1)
gmixer_context->instances = eina_list_append(gmixer_context->instances, inst);
if (inst->id == -1)
{
Edje_Message_Int_Set *msg;
msg = alloca(sizeof(Edje_Message_Int_Set) + (2 * sizeof(int)));
msg->count = 3;
msg->val[0] = EINA_FALSE;
msg->val[1] = 60;
msg->val[2] = 60;
edje_object_message_send(elm_layout_edje_get(inst->o_mixer), EDJE_MESSAGE_INT_SET, 0, msg);
elm_layout_signal_emit(inst->o_mixer, "e,action,volume,change", "e");
}
else
_mixer_gadget_update();
}
evas_object_smart_callback_del_full(obj, "gadget_created", _mixer_gadget_created_cb, data);
}
static void
mixer_del(void *data, Evas *e EINA_UNUSED, Evas_Object *obj EINA_UNUSED, void *event_info EINA_UNUSED)
{
Instance *inst = data;
gmixer_context->instances = eina_list_remove(gmixer_context->instances, inst);
free(inst);
}
EINTERN Evas_Object *
mixer_gadget_create(Evas_Object *parent, int *id, E_Gadget_Site_Orient orient)
{
Instance *inst;
if (*id != -1)
{
if (!mixer_init())
return NULL;
}
inst = E_NEW(Instance, 1);
inst->o_main = elm_box_add(parent);
inst->orient = orient;
inst->id = *id;
evas_object_show(inst->o_main);
evas_object_smart_callback_add(parent, "gadget_created", _mixer_gadget_created_cb, inst);
if (*id != -1)
evas_object_event_callback_add(inst->o_main, EVAS_CALLBACK_DEL, mixer_del, inst);
return inst->o_main;
}
EINTERN Eina_Bool
mixer_init(void)
{
char buf[4096];
if (!gmixer_context)
{
gmixer_context = E_NEW(Context, 1);
snprintf(buf, sizeof(buf), "%s/mixer.edj",
e_module_dir_get(gmixer_context->module));
gmixer_context->theme = strdup(buf);
E_LIST_HANDLER_APPEND(_handlers, E_EVENT_MIXER_BACKEND_CHANGED,
_mixer_backend_changed, NULL);
E_LIST_HANDLER_APPEND(_handlers, E_EVENT_MIXER_SINKS_CHANGED,
_mixer_sinks_changed, NULL);
}
return EINA_TRUE;
}
EINTERN void
mixer_shutdown(void)
{
E_FREE_LIST(_handlers, ecore_event_handler_del);
if (gmixer_context)
{
free(gmixer_context->theme);
E_FREE(gmixer_context);
}
}

30
src/modules/mixer/gadget/mixer.h
View File

@ -1,30 +0,0 @@
#ifndef MIXER_H
#define MIXER_H
#include "e.h"
#include <Eina.h>
#include "emix.h"
#include "../e_mod_config.h"
EINTERN void *e_modapi_gadget_init(E_Module *m);
EINTERN int e_modapi_gadget_shutdown(E_Module *m);
EINTERN int e_modapi_gadget_save(E_Module *m);
EINTERN extern int _e_gemix_log_domain;
#undef DBG
#undef INF
#undef WRN
#undef ERR
#undef CRIT
#define DBG(...) EINA_LOG_DOM_DBG(_e_gemix_log_domain, __VA_ARGS__)
#define INF(...) EINA_LOG_DOM_INF(_e_gemix_log_domain, __VA_ARGS__)
#define WRN(...) EINA_LOG_DOM_WARN(_e_gemix_log_domain, __VA_ARGS__)
#define ERR(...) EINA_LOG_DOM_ERR(_e_gemix_log_domain, __VA_ARGS__)
#define CRIT(...) EINA_LOG_DOM_CRIT(_e_gemix_log_domain, __VA_ARGS__)
EINTERN Eina_Bool mixer_init(void);
EINTERN void mixer_shutdown(void);
EINTERN Evas_Object *mixer_gadget_create(Evas_Object *parent, int *id EINA_UNUSED, E_Gadget_Site_Orient orient EINA_UNUSED);
#endif

36
src/modules/mixer/gadget/mod.c
View File

@ -1,36 +0,0 @@
#include "mixer.h"
#include "backend.h"
EINTERN int _e_gemix_log_domain;
EINTERN void *
e_modapi_gadget_init(E_Module *m)
{
if (!backend_init()) return NULL;
_e_gemix_log_domain = eina_log_domain_register("mixer_gadget", EINA_COLOR_RED);
e_gadget_type_add("Mixer", mixer_gadget_create, NULL);
return m;
}
EINTERN int
e_modapi_gadget_shutdown(E_Module *m EINA_UNUSED)
{
mixer_shutdown();
e_gadget_type_del("Mixer");
backend_shutdown();
return 1;
}
EINTERN int
e_modapi_gadget_save(E_Module *m EINA_UNUSED)
{
emix_config_save();
return 1;
}

6
src/modules/mixer/meson.build
View File

@ -3,10 +3,8 @@ src = files(
'e_mod_config.c',
'e_mod_config.h',
'e_mod_main.h',
'gadget/mixer.h',
'gadget/mixer.c',
'gadget/mod.c',
'gadget/backend.c'
'backend.c',
'backend.h'
)
mixer_lib = files(

9
src/modules/mixer/mixer.h Normal file
View File

@ -0,0 +1,9 @@
#ifndef MIXER_H
#define MIXER_H
#include "e.h"
#include <Eina.h>
#include "emix.h"
#include "../e_mod_config.h"
#endif

136
src/modules/packagekit/e_mod_main.c
View File

@ -26,7 +26,7 @@ _mouse_down_cb(void *data, Evas *evas EINA_UNUSED, Evas_Object *obj EINA_UNUSED,
if (inst->popup)
packagekit_popup_del(inst);
else
packagekit_popup_new(inst, EINA_TRUE);
packagekit_popup_new(inst);
}
else if (ev->button == 2)
{
@ -76,133 +76,6 @@ _refresh_timer_cb(void *data)
return ECORE_CALLBACK_RENEW;
}
/* Gadget Api Functions */
static void
_gadget_mouse_up_cb(void *data, Evas *evas EINA_UNUSED, Evas_Object *obj EINA_UNUSED, void *event)
{
E_PackageKit_Instance *inst = data;
E_PackageKit_Module_Context *ctxt = packagekit_mod->data;
Evas_Event_Mouse_Up *ev = event;
if (ev->event_flags & EVAS_EVENT_FLAG_ON_HOLD) return;
ev->event_flags |= EVAS_EVENT_FLAG_ON_HOLD;
if (ev->button == 1)
{
if (inst->ctxpopup)
packagekit_popup_del(inst);
else
packagekit_popup_new(inst, EINA_FALSE);
}
else if (ev->button == 2)
{
packagekit_create_transaction_and_exec(ctxt, packagekit_get_updates);
}
}
static void
_gadget_del_cb(void *data, Evas *evas EINA_UNUSED, Evas_Object *obj EINA_UNUSED, void *event EINA_UNUSED)
{
E_PackageKit_Instance *inst = data;
E_PackageKit_Module_Context *ctxt = packagekit_mod->data;
if (inst->ctxpopup) packagekit_popup_del(inst);
ctxt->instances = eina_list_remove(ctxt->instances, inst);
free(inst);
}
static Evas_Object *
_gadget_configure_cb(Evas_Object *gadget)
{
E_PackageKit_Instance *inst = evas_object_data_get(gadget, "pkit-inst");
return packagekit_config_show(inst->ctxt);
}
static void
_gadget_menu1_cb(void *data, E_Menu *m EINA_UNUSED, E_Menu_Item *mi EINA_UNUSED)
{
E_PackageKit_Module_Context *ctxt = data;
e_exec(e_zone_current_get(), NULL,
ctxt->config->manager_command,
NULL, NULL);
}
static void
_gadget_menu2_cb(void *data, E_Menu *m EINA_UNUSED, E_Menu_Item *mi EINA_UNUSED)
{
E_PackageKit_Module_Context *ctxt = data;
packagekit_create_transaction_and_exec(ctxt, packagekit_refresh_cache);
}
static void
_gadget_menu_populate_cb(Evas_Object *gadget, E_Menu *m)
{
E_PackageKit_Instance *inst = evas_object_data_get(gadget, "pkit-inst");
E_Menu_Item *mi;
mi = e_menu_item_new(m);
e_menu_item_separator_set(mi, 1);
mi = e_menu_item_new(m);
e_menu_item_label_set(mi, _("Refresh package list"));
e_util_menu_item_theme_icon_set(mi, "view-refresh");
e_menu_item_callback_set(mi, _gadget_menu2_cb, inst->ctxt);
if (inst->ctxt->config->manager_command && inst->ctxt->config->manager_command[0])
{
mi = e_menu_item_new(m);
e_menu_item_label_set(mi, _("Run the package manager"));
e_util_menu_item_theme_icon_set(mi, "preferences-applications");
e_menu_item_callback_set(mi, _gadget_menu1_cb, inst->ctxt);
}
}
static void
_gadget_created_cb(void *data, Evas_Object *obj, void *event_data EINA_UNUSED)
{
E_PackageKit_Instance *inst = data;
evas_object_smart_callback_del_full(obj, "gadget_created",
_gadget_created_cb, data);
evas_object_event_callback_add(inst->gadget, EVAS_CALLBACK_MOUSE_UP,
_gadget_mouse_up_cb, inst);
e_gadget_configure_cb_set(inst->gadget, _gadget_configure_cb);
e_gadget_menu_populate_cb_set(inst->gadget, _gadget_menu_populate_cb);
packagekit_icon_update(inst->ctxt, EINA_FALSE);
}
EINTERN Evas_Object *
_gadget_create_cb(Evas_Object *parent, int *id, E_Gadget_Site_Orient orient EINA_UNUSED)
{
E_PackageKit_Instance *inst;
E_PackageKit_Module_Context *ctxt = packagekit_mod->data;
inst = E_NEW(E_PackageKit_Instance, 1);
inst->ctxt = ctxt;
inst->gadget = edje_object_add(evas_object_evas_get(parent));
e_theme_edje_object_set(inst->gadget, "base/theme/modules/packagekit",
"e/modules/packagekit/main");
evas_object_event_callback_add(inst->gadget, EVAS_CALLBACK_DEL,
_gadget_del_cb, inst);
evas_object_data_set(inst->gadget, "pkit-inst", inst);
ctxt->instances = eina_list_append(ctxt->instances, inst);
if (*id >= 0)
{ // normal mode
evas_object_smart_callback_add(parent, "gadget_created",
_gadget_created_cb, inst);
}
else
{ // demo mode
edje_object_signal_emit(inst->gadget, "packagekit,state,updated", "e");
}
return inst->gadget;
}
/* Gadcon Api Functions */
static E_Gadcon_Client *
_gc_init(E_Gadcon *gc, const char *name, const char *id, const char *style)
@ -315,10 +188,6 @@ e_modapi_init(E_Module *m)
ctxt->module = m;
packagekit_mod = m;
// add the gadget to the new E gadgets system
// TODO should this name be translated? also on type_del??
e_gadget_type_add("PackageKit", _gadget_create_cb, NULL);
// add the gadget to the old E gadcon system
e_gadcon_provider_register(&_gc_class);
@ -341,9 +210,6 @@ e_modapi_shutdown(E_Module *m)
E_FREE(ctxt->config);
E_CONFIG_DD_FREE(ctxt->conf_edd);
// remove the gadget from the new E gadgets system
e_gadget_type_del("PackageKit");
// remove the gadget from the old E gadcon system
e_gadcon_provider_unregister(&_gc_class);

46
src/modules/packagekit/e_mod_packagekit.c
View File

@ -2,7 +2,6 @@
#include "e_mod_main.h"
#include "e_mod_packagekit.h"
/* GUI */
void
packagekit_icon_update(E_PackageKit_Module_Context *ctxt,
@ -432,34 +431,14 @@ _genlist_selunsel_cb(void *data, Evas_Object *obj EINA_UNUSED,
packagekit_popup_update(data, EINA_FALSE);
}
static void
_ctxpopup_dismissed(void *data, Evas_Object *obj, void *info EINA_UNUSED)
{
E_PackageKit_Instance *inst = data;
evas_object_del(obj);
inst->ctxpopup = NULL;
}
void
packagekit_popup_new(E_PackageKit_Instance *inst, Eina_Bool is_gadcon)
packagekit_popup_new(E_PackageKit_Instance *inst)
{
Evas_Object *table, *bt, *ic, *lb, *li, *pb, *fr, *bx, *size_rect;
const char *p;
if (is_gadcon)
{
inst->popup = e_gadcon_popup_new(inst->gcc, EINA_FALSE);
table = elm_table_add(e_comp->elm);
}
else
{
inst->ctxpopup = elm_ctxpopup_add(e_comp->elm);
elm_object_style_set(inst->ctxpopup, "noblock");
evas_object_smart_callback_add(inst->ctxpopup, "dismissed",
_ctxpopup_dismissed, inst);
table = elm_table_add(inst->ctxpopup);
}
inst->popup = e_gadcon_popup_new(inst->gcc, EINA_FALSE);
table = elm_table_add(e_comp->elm);
evas_object_show(table);
// horiz box for title and buttons
@ -573,19 +552,10 @@ packagekit_popup_new(E_PackageKit_Instance *inst, Eina_Bool is_gadcon)
}
// setup and show the popup
if (is_gadcon)
{
e_gadcon_popup_content_set(inst->popup, table);
e_object_data_set(E_OBJECT(inst->popup), inst);
E_OBJECT_DEL_SET(inst->popup, _popup_del_cb);
e_gadcon_popup_show(inst->popup);
}
else
{
elm_object_content_set(inst->ctxpopup, table);
e_gadget_util_ctxpopup_place(inst->gadget, inst->ctxpopup, NULL);
evas_object_show(inst->ctxpopup);
}
e_gadcon_popup_content_set(inst->popup, table);
e_object_data_set(E_OBJECT(inst->popup), inst);
E_OBJECT_DEL_SET(inst->popup, _popup_del_cb);
e_gadcon_popup_show(inst->popup);
// update the popup state and contents
packagekit_popup_update(inst, EINA_TRUE);
@ -596,8 +566,6 @@ packagekit_popup_del(E_PackageKit_Instance *inst)
{
if (inst->popup)
E_FREE_FUNC(inst->popup, e_object_del);
if (inst->ctxpopup)
elm_ctxpopup_dismiss(inst->ctxpopup);
inst->popup_genlist = inst->popup_title_entry = NULL;
inst->popup_progressbar = inst->popup_progressbar_frame = NULL;

3
src/modules/packagekit/e_mod_packagekit.h
View File

@ -79,7 +79,6 @@ typedef struct _E_PackageKit_Instance
E_Gadcon_Client *gcc;
Evas_Object *gadget;
E_Gadcon_Popup *popup;
Evas_Object *ctxpopup;
Evas_Object *popup_title_entry;
Evas_Object *popup_error_label;
Evas_Object *popup_install_button;
@ -113,7 +112,7 @@ void packagekit_get_updates(E_PackageKit_Module_Context *ctxt, const char *
void packagekit_refresh_cache(E_PackageKit_Module_Context *ctxt, const char *transaction);
void packagekit_update_packages(E_PackageKit_Module_Context *ctxt, const char *transaction);
void packagekit_icon_update(E_PackageKit_Module_Context *ctxt, Eina_Bool working);
void packagekit_popup_new(E_PackageKit_Instance *inst, Eina_Bool is_gadcon);
void packagekit_popup_new(E_PackageKit_Instance *inst);
void packagekit_popup_del(E_PackageKit_Instance *inst);
void packagekit_popup_update(E_PackageKit_Instance *inst, Eina_Bool rebuild_list);

2
src/modules/pager/e_mod_config.c
View File

@ -152,7 +152,6 @@ _basic_apply(E_Config_Dialog *cfd EINA_UNUSED, E_Config_Dialog_Data *cfdata)
pager_config->show_desk_names = cfdata->show_desk_names;
pager_config->popup_urgent = cfdata->popup.urgent_show;
_pager_cb_config_updated();
_pager_cb_config_gadget_updated(EINA_FALSE);
e_config_save_queue();
return 1;
}
@ -300,7 +299,6 @@ _adv_apply(E_Config_Dialog *cfd EINA_UNUSED, E_Config_Dialog_Data *cfdata)
pager_config->btn_noplace = cfdata->btn.noplace;
pager_config->btn_desk = cfdata->btn.desk;
_pager_cb_config_updated();
_pager_cb_config_gadget_updated(EINA_FALSE);
e_config_save_queue();
return 1;
}

72
src/modules/pager/e_mod_main.c
View File

@ -170,10 +170,12 @@ static int hold_mod = 0;
static E_Desk *current_desk = NULL;
static Eina_List *pagers = NULL;
static double _pager_start_time = 0.0;
static E_Config_DD *conf_edd = NULL;
EINTERN E_Module *module;
EINTERN E_Config_Dialog *config_dialog;
EINTERN Eina_List *instances, *shandlers;
EINTERN Config *pager_config;
static Pager_Win *
_pager_desk_window_find(Pager_Desk *pd, E_Client *client)
@ -2086,12 +2088,69 @@ E_API E_Module_Api e_modapi =
};
E_API void *
e_modapi_init(E_Module *m)
e_modapi_init(E_Module *m EINA_UNUSED)
{
E_Module *p;
_pager_start_time = ecore_time_get();
e_modapi_gadget_init(m);
conf_edd = E_CONFIG_DD_NEW("Pager_Config", Config);
#undef T
#undef D
#define T Config
#define D conf_edd
E_CONFIG_VAL(D, T, popup, UINT);
E_CONFIG_VAL(D, T, popup_speed, DOUBLE);
E_CONFIG_VAL(D, T, popup_urgent, UINT);
E_CONFIG_VAL(D, T, popup_urgent_stick, UINT);
E_CONFIG_VAL(D, T, popup_urgent_speed, DOUBLE);
E_CONFIG_VAL(D, T, show_desk_names, UINT);
E_CONFIG_VAL(D, T, popup_height, INT);
E_CONFIG_VAL(D, T, popup_act_height, INT);
E_CONFIG_VAL(D, T, drag_resist, UINT);
E_CONFIG_VAL(D, T, btn_drag, UCHAR);
E_CONFIG_VAL(D, T, btn_noplace, UCHAR);
E_CONFIG_VAL(D, T, btn_desk, UCHAR);
E_CONFIG_VAL(D, T, flip_desk, UCHAR);
E_CONFIG_VAL(D, T, plain, UCHAR);
E_CONFIG_VAL(D, T, permanent_plain, UCHAR);
pager_config = e_config_domain_load("module.pager", conf_edd);
if (!pager_config)
{
pager_config = E_NEW(Config, 1);
pager_config->popup = 1;
pager_config->popup_speed = 1.0;
pager_config->popup_urgent = 0;
pager_config->popup_urgent_stick = 0;
pager_config->popup_urgent_speed = 1.5;
pager_config->show_desk_names = 0;
pager_config->popup_height = 60;
pager_config->popup_act_height = 60;
pager_config->drag_resist = 3;
pager_config->btn_drag = 1;
pager_config->btn_noplace = 2;
pager_config->btn_desk = 2;
pager_config->flip_desk = 0;
pager_config->plain = 0;
pager_config->permanent_plain = 0;
}
E_CONFIG_LIMIT(pager_config->popup, 0, 1);
E_CONFIG_LIMIT(pager_config->popup_speed, 0.1, 10.0);
E_CONFIG_LIMIT(pager_config->popup_urgent, 0, 1);
E_CONFIG_LIMIT(pager_config->popup_urgent_stick, 0, 1);
E_CONFIG_LIMIT(pager_config->popup_urgent_speed, 0.1, 10.0);
E_CONFIG_LIMIT(pager_config->show_desk_names, 0, 1);
E_CONFIG_LIMIT(pager_config->popup_height, 20, 200);
E_CONFIG_LIMIT(pager_config->popup_act_height, 20, 200);
E_CONFIG_LIMIT(pager_config->drag_resist, 0, 50);
E_CONFIG_LIMIT(pager_config->flip_desk, 0, 1);
E_CONFIG_LIMIT(pager_config->btn_drag, 0, 32);
E_CONFIG_LIMIT(pager_config->btn_noplace, 0, 32);
E_CONFIG_LIMIT(pager_config->btn_desk, 0, 32);
E_CONFIG_LIMIT(pager_config->plain, 0, 1);
E_CONFIG_LIMIT(pager_config->permanent_plain, 0, 1);
p = e_module_find("pager_plain");
if (p && p->enabled)
{
@ -2141,9 +2200,8 @@ e_modapi_init(E_Module *m)
}
E_API int
e_modapi_shutdown(E_Module *m)
e_modapi_shutdown(E_Module *m EINA_UNUSED)
{
e_modapi_gadget_shutdown(m);
e_gadcon_provider_unregister(&_gadcon_class);
if (config_dialog)
@ -2160,13 +2218,15 @@ e_modapi_shutdown(E_Module *m)
e_action_predef_name_del("Pager", "Popup Desk Next");
e_action_predef_name_del("Pager", "Popup Desk Previous");
module = NULL;
return 1;
}
E_API int
e_modapi_save(E_Module *m)
e_modapi_save(E_Module *m EINA_UNUSED)
{
e_modapi_gadget_save(m);
e_config_domain_save("module.pager", conf_edd, pager_config);
return 1;
}

25
src/modules/pager/e_mod_main.h
View File

@ -1,8 +1,27 @@
#ifndef E_MOD_MAIN_H
#define E_MOD_MAIN_H
#include "gadget/pager.h"
typedef struct _Config_Item Config_Item;
typedef struct _Config Config;
struct _Config
{
unsigned int popup;
double popup_speed;
unsigned int popup_urgent;
unsigned int popup_urgent_stick;
unsigned int popup_urgent_focus;
double popup_urgent_speed;
unsigned int show_desk_names;
int popup_act_height;
int popup_height;
unsigned int drag_resist;
unsigned int btn_drag;
unsigned int btn_noplace;
unsigned int btn_desk;
unsigned int flip_desk;
unsigned int plain;
unsigned int permanent_plain;
};
#define PAGER_RESIZE_NONE 0
#define PAGER_RESIZE_HORZ 1
@ -21,6 +40,10 @@ E_API void *e_modapi_init(E_Module *m);
E_API int e_modapi_shutdown(E_Module *m);
E_API int e_modapi_save(E_Module *m);
EINTERN void _pager_cb_config_updated(void);
EINTERN extern Config *pager_config;
EINTERN void _config_pager_module(Config_Item *ci);
extern E_Module *module;

685
src/modules/pager/gadget/config.c
View File

@ -1,685 +0,0 @@
#include "pager.h"
#define BUTTON_DRAG 0
#define BUTTON_NOPLACE 1
#define BUTTON_DESK 2
typedef struct _Config_Objects Config_Objects;
struct _Config_Objects
{
Evas_Object *general_page;
Evas_Object *popup_page;
Evas_Object *urgent_page;
Evas_Object *style_page;
Evas_Object *o_popup;
Evas_Object *o_popup_speed;
Evas_Object *o_popup_urgent;
Evas_Object *o_popup_urgent_stick;
Evas_Object *o_popup_urgent_focus;
Evas_Object *o_popup_urgent_speed;
Evas_Object *o_show_desk_names;
Evas_Object *o_popup_act_height;
Evas_Object *o_popup_height;
Evas_Object *o_btn_drag;
Evas_Object *o_btn_noplace;
Evas_Object *o_btn_desk;
Evas_Object *o_btn_virtual;
Evas_Object *o_flip_desk;
Evas_Object *o_permanent;
Evas_Object *o_plain;
E_Grab_Dialog *grab_dia;
int grab_btn;
int w, h;
};
Config_Objects *pager_gadget_config_objects = NULL;
static void
_config_close(void *data EINA_UNUSED, Evas *e EINA_UNUSED, Evas_Object *obj EINA_UNUSED, void *event_info EINA_UNUSED)
{
cfg_dialog = NULL;
E_FREE(pager_gadget_config_objects);
}
static void
_config_show_general(void *data EINA_UNUSED, Evas_Object *obj EINA_UNUSED, void *event_info EINA_UNUSED)
{
evas_object_hide(pager_gadget_config_objects->popup_page);
evas_object_hide(pager_gadget_config_objects->urgent_page);
evas_object_hide(pager_gadget_config_objects->style_page);
evas_object_show(pager_gadget_config_objects->general_page);
}
static void
_config_show_popup(void *data EINA_UNUSED, Evas_Object *obj EINA_UNUSED, void *event_info EINA_UNUSED)
{
evas_object_hide(pager_gadget_config_objects->general_page);
evas_object_hide(pager_gadget_config_objects->urgent_page);
evas_object_hide(pager_gadget_config_objects->style_page);
evas_object_show(pager_gadget_config_objects->popup_page);
}
static void
_config_show_urgent(void *data EINA_UNUSED, Evas_Object *obj EINA_UNUSED, void *event_info EINA_UNUSED)
{
evas_object_hide(pager_gadget_config_objects->general_page);
evas_object_hide(pager_gadget_config_objects->popup_page);
evas_object_hide(pager_gadget_config_objects->style_page);
evas_object_show(pager_gadget_config_objects->urgent_page);
}
static void
_config_show_style(void *data EINA_UNUSED, Evas_Object *obj EINA_UNUSED, void *event_info EINA_UNUSED)
{
evas_object_hide(pager_gadget_config_objects->general_page);
evas_object_hide(pager_gadget_config_objects->popup_page);
evas_object_hide(pager_gadget_config_objects->urgent_page);
evas_object_show(pager_gadget_config_objects->style_page);
}
static void
_config_value_changed(void *data EINA_UNUSED, Evas_Object *obj EINA_UNUSED, void *event_data EINA_UNUSED)
{
Eina_Bool val, changed = EINA_FALSE;
pager_config->popup =
elm_check_state_get(pager_gadget_config_objects->o_popup);
pager_config->popup_speed =
elm_slider_value_get(pager_gadget_config_objects->o_popup_speed);
pager_config->flip_desk =
elm_check_state_get(pager_gadget_config_objects->o_flip_desk);
pager_config->popup_urgent =
elm_check_state_get(pager_gadget_config_objects->o_popup_urgent);
pager_config->popup_urgent_stick =
elm_check_state_get(pager_gadget_config_objects->o_popup_urgent_stick);
pager_config->popup_urgent_focus =
elm_check_state_get(pager_gadget_config_objects->o_popup_urgent_focus);
pager_config->popup_urgent_speed =
elm_slider_value_get(pager_gadget_config_objects->o_popup_urgent_speed);
pager_config->show_desk_names =
elm_check_state_get(pager_gadget_config_objects->o_show_desk_names);
pager_config->popup_height =
elm_slider_value_get(pager_gadget_config_objects->o_popup_height);
pager_config->popup_act_height =
elm_slider_value_get(pager_gadget_config_objects->o_popup_act_height);
val = elm_check_state_get(pager_gadget_config_objects->o_permanent);
if (val != pager_config->permanent_plain)
changed = EINA_TRUE;
pager_config->permanent_plain = val;
val = elm_check_state_get(pager_gadget_config_objects->o_plain);
if (val != pager_config->plain)
changed = EINA_TRUE;
pager_config->plain = val;
_pager_cb_config_gadget_updated(changed);
_pager_cb_config_updated();
e_config_save_queue();
elm_object_disabled_set(pager_gadget_config_objects->o_popup_speed,
!pager_config->popup);
elm_object_disabled_set(pager_gadget_config_objects->o_popup_act_height,
!pager_config->popup);
elm_object_disabled_set(pager_gadget_config_objects->o_popup_height,
!pager_config->popup);
elm_object_disabled_set(pager_gadget_config_objects->o_popup_urgent_stick,
!pager_config->popup_urgent);
elm_object_disabled_set(pager_gadget_config_objects->o_popup_urgent_focus,
!pager_config->popup_urgent);
elm_object_disabled_set(pager_gadget_config_objects->o_popup_urgent_speed,
!pager_config->popup_urgent);
}
static void
_config_update_btn(Evas_Object *button, const int mouse_button)
{
char lbl[256];
char *icon = NULL;
Evas_Object *ic = NULL;
switch (mouse_button)
{
case 0:
snprintf(lbl, sizeof(lbl), _("Click to set"));
break;
case 1:
if (e_config->mouse_hand == E_MOUSE_HAND_RIGHT)
{
snprintf(lbl, sizeof(lbl), _("Left button"));
icon = "preferences-desktop-mouse-left";
}
else if (e_config->mouse_hand == E_MOUSE_HAND_LEFT)
{
snprintf(lbl, sizeof(lbl), _("Right button"));
icon = "preferences-desktop-mouse-right";
}
else
{
snprintf(lbl, sizeof(lbl), _("Button %i"), mouse_button);
icon = "preferences-desktop-mouse-extra";
}
break;
case 2:
snprintf(lbl, sizeof(lbl), _("Middle button"));
icon = "preferences-desktop-mouse-middle";
break;
case 3:
if (e_config->mouse_hand == E_MOUSE_HAND_RIGHT)
{
snprintf(lbl, sizeof(lbl), _("Right button"));
icon = "preferences-desktop-mouse-right";
}
else if (e_config->mouse_hand == E_MOUSE_HAND_LEFT)
{
snprintf(lbl, sizeof(lbl), _("Left button"));
icon = "preferences-desktop-mouse-left";
}
else
{
snprintf(lbl, sizeof(lbl), _("Button %i"), mouse_button);
icon = "preferences-desktop-mouse-extra";
}
break;
default:
snprintf(lbl, sizeof(lbl), _("Button %i"), mouse_button);
icon = "preferences-desktop-mouse-extra";
break;
}
elm_object_text_set(button, lbl);
if (icon)
{
ic = elm_icon_add(button);
elm_icon_standard_set(ic, icon);
evas_object_size_hint_aspect_set(ic, EVAS_ASPECT_CONTROL_BOTH, 1, 1);
}
elm_object_part_content_set(button, "icon", ic);
}
static void
_config_update_btns(void)
{
#if 0
_config_update_btn(pager_gadget_config_objects->o_btn_drag, pager_config->btn_drag);
#endif
_config_update_btn(pager_gadget_config_objects->o_btn_noplace, pager_config->btn_noplace);
_config_update_btn(pager_gadget_config_objects->o_btn_desk, pager_config->btn_desk);
}
static void
_config_grab_window_del(void *data EINA_UNUSED)
{
evas_object_show(cfg_dialog);
_config_update_btns();
}
static Eina_Bool
_config_grab_cb_mouse_down(void *data EINA_UNUSED, int type EINA_UNUSED, void *event)
{
Ecore_Event_Mouse_Button *ev;
ev = event;
if (ev->buttons == 3)
{
e_util_dialog_show(_("Attention"),
_("You cannot use the right mouse button in the<ps/>"
"gadget for this as it is already taken by internal<ps/>"
"code for context menus.<ps/>"
"This button only works in the popup."));
}
else
{
if (ev->buttons == pager_config->btn_drag)
pager_config->btn_drag = 0;
else if (ev->buttons == pager_config->btn_noplace)
pager_config->btn_noplace = 0;
else if (ev->buttons == pager_config->btn_desk)
pager_config->btn_desk = 0;
if (pager_gadget_config_objects->grab_btn == 1)
pager_config->btn_drag = ev->buttons;
else if (pager_gadget_config_objects->grab_btn == 2)
pager_config->btn_noplace = ev->buttons;
else
pager_config->btn_desk = ev->buttons;
}
e_object_del(E_OBJECT(pager_gadget_config_objects->grab_dia));
return ECORE_CALLBACK_PASS_ON;
}
static Eina_Bool
_config_grab_cb_key_down(void *data EINA_UNUSED, int type EINA_UNUSED, void *event)
{
Ecore_Event_Key *ev;
ev = event;
if (!strcmp(ev->key, "Delete"))
{
if (pager_gadget_config_objects->grab_btn == 1)
pager_config->btn_drag = 0;
else if (pager_gadget_config_objects->grab_btn == 2)
pager_config->btn_noplace = 0;
else
pager_config->btn_desk = 0;
}
e_object_del(E_OBJECT(pager_gadget_config_objects->grab_dia));
return ECORE_CALLBACK_PASS_ON;
}
static void
_config_grab_window_show(void *data, Evas_Object *obj EINA_UNUSED, void *event_info EINA_UNUSED)
{
evas_object_hide(cfg_dialog);
pager_gadget_config_objects->grab_btn = 0;
if ((long)data == BUTTON_DRAG)
pager_gadget_config_objects->grab_btn = 1;
else if ((long)data == BUTTON_NOPLACE)
pager_gadget_config_objects->grab_btn = 2;
pager_gadget_config_objects->grab_dia = e_grab_dialog_show(NULL, EINA_TRUE,
_config_grab_cb_key_down, _config_grab_cb_mouse_down, NULL, NULL);
e_object_del_attach_func_set(E_OBJECT(pager_gadget_config_objects->grab_dia), _config_grab_window_del);
}
static void
_config_virtual_desks_show(void *data EINA_UNUSED, Evas_Object *obj EINA_UNUSED, void *event_info EINA_UNUSED)
{
evas_object_del(cfg_dialog);
e_configure_registry_call("screen/virtual_desktops", NULL, NULL);
}
static Evas_Object *
_config_create_pages(Evas_Object *parent)
{
Evas_Object *m, *tb, *ow, *fr;
int row = 5;
m = elm_table_add(parent);
E_EXPAND(m);
evas_object_show(m);
/* General Page */
fr = elm_frame_add(m);
elm_object_text_set(fr, _("General"));
E_EXPAND(fr);
E_FILL(fr);
evas_object_show(fr);
tb = elm_table_add(m);
E_EXPAND(tb);
elm_object_content_set(fr, tb);
evas_object_show(tb);
ow = elm_button_add(tb);
elm_object_text_set(ow, _("Configure virtual deskstops"));
evas_object_smart_callback_add(ow, "clicked",
_config_virtual_desks_show, NULL);
elm_table_pack(tb, ow, 0, 0, 1, 1);
E_ALIGN(ow, EVAS_HINT_FILL, EVAS_HINT_FILL);
E_WEIGHT(ow, EVAS_HINT_EXPAND, 0);
evas_object_show(ow);
pager_gadget_config_objects->o_btn_virtual = ow;
row++;
ow = elm_check_add(tb);
elm_object_text_set(ow, _("Flip desktop on mouse wheel"));
evas_object_size_hint_align_set(ow, 0.0, EVAS_HINT_FILL);
elm_check_state_set(ow, pager_config->flip_desk);
elm_table_pack(tb, ow, 0, 1, 1, 1);
E_ALIGN(ow, EVAS_HINT_FILL, EVAS_HINT_FILL);
E_WEIGHT(ow, EVAS_HINT_EXPAND, 0);
evas_object_smart_callback_add(ow, "changed",
_config_value_changed, NULL);
evas_object_show(ow);
pager_gadget_config_objects->o_flip_desk = ow;
ow = elm_check_add(tb);
elm_object_text_set(ow, _("Always show desktop names"));
evas_object_size_hint_align_set(ow, 0.0, EVAS_HINT_FILL);
elm_check_state_set(ow, pager_config->show_desk_names);
elm_table_pack(tb, ow, 0, 2, 1, 1);
E_ALIGN(ow, EVAS_HINT_FILL, EVAS_HINT_FILL);
E_WEIGHT(ow, EVAS_HINT_EXPAND, 0);
evas_object_smart_callback_add(ow, "changed",
_config_value_changed, NULL);
evas_object_show(ow);
pager_gadget_config_objects->o_show_desk_names = ow;
#if 0
ow = elm_label_add(m);
elm_object_text_set(ow, _("Select and Slide button"));
elm_table_pack(tb, ow, 0, row, 1, 1);
E_ALIGN(ow, 0.0, 0.0);
E_WEIGHT(ow, EVAS_HINT_EXPAND, 0);
evas_object_show(ow);
row++;
ow = elm_button_add(tb);
elm_object_text_set(ow, _("Click to set"));
evas_object_smart_callback_add(ow, "clicked",
_config_grab_window_show, (void *)BUTTON_DRAG);
elm_table_pack(tb, ow, 0, row, 1, 1);
E_ALIGN(ow, EVAS_HINT_FILL, EVAS_HINT_FILL);
E_WEIGHT(ow, EVAS_HINT_EXPAND, 0);
evas_object_show(ow);
pager_gadget_config_objects->o_btn_drag = ow;
row++;
#endif
ow = elm_label_add(m);
elm_object_text_set(ow, _("Drag and Drop button"));
elm_table_pack(tb, ow, 0, row, 1, 1);
E_ALIGN(ow, 0.0, 0.0);
E_WEIGHT(ow, EVAS_HINT_EXPAND, 0);
evas_object_show(ow);
row++;
ow = elm_button_add(tb);
elm_object_text_set(ow, _("Click to set"));
evas_object_smart_callback_add(ow, "clicked",
_config_grab_window_show, (void *)BUTTON_NOPLACE);
elm_table_pack(tb, ow, 0, row, 1, 1);
E_ALIGN(ow, EVAS_HINT_FILL, EVAS_HINT_FILL);
E_WEIGHT(ow, EVAS_HINT_EXPAND, 0);
evas_object_show(ow);
pager_gadget_config_objects->o_btn_noplace = ow;
row++;
ow = elm_label_add(m);
elm_object_text_set(ow, _("Drag whole desktop"));
elm_table_pack(tb, ow, 0, row, 1, 1);
E_ALIGN(ow, 0.0, 0.0);
E_WEIGHT(ow, EVAS_HINT_EXPAND, 0);
evas_object_show(ow);
row++;
ow = elm_button_add(tb);
elm_object_text_set(ow, _("Click to set"));
evas_object_smart_callback_add(ow, "clicked",
_config_grab_window_show, (void *)BUTTON_DESK);
elm_table_pack(tb, ow, 0, row, 1, 1);
E_ALIGN(ow, EVAS_HINT_FILL, EVAS_HINT_FILL);
E_WEIGHT(ow, EVAS_HINT_EXPAND, 0);
evas_object_show(ow);
pager_gadget_config_objects->o_btn_desk = ow;
_config_update_btns();
elm_table_pack(m, fr, 0, 0, 1, 1);
pager_gadget_config_objects->general_page = fr;
/* Popup Page */
fr = elm_frame_add(m);
elm_object_text_set(fr, _("Popup"));
E_EXPAND(fr);
E_FILL(fr);
evas_object_show(fr);
tb = elm_table_add(fr);
E_EXPAND(tb);
elm_object_content_set(fr, tb);
evas_object_show(tb);
ow = elm_check_add(tb);
elm_object_text_set(ow, _("Show popup on desktop change"));
evas_object_size_hint_align_set(ow, 0.0, EVAS_HINT_FILL);
elm_check_state_set(ow, pager_config->popup);
elm_table_pack(tb, ow, 0, 0, 1, 1);
E_ALIGN(ow, EVAS_HINT_FILL, EVAS_HINT_FILL);
E_WEIGHT(ow, EVAS_HINT_EXPAND, 0);
evas_object_smart_callback_add(ow, "changed",
_config_value_changed, NULL);
evas_object_show(ow);
pager_gadget_config_objects->o_popup = ow;
ow = elm_label_add(m);
elm_object_text_set(ow, _("Popup pager height"));
elm_object_disabled_set(ow, !pager_config->popup);
elm_table_pack(tb, ow, 0, 1, 1, 1);
E_ALIGN(ow, 0.0, 0.0);
E_WEIGHT(ow, EVAS_HINT_EXPAND, 0);
evas_object_show(ow);
ow = elm_slider_add(tb);
elm_object_disabled_set(ow, !pager_config->popup);
elm_slider_min_max_set(ow, 20, 200);
elm_slider_step_set(ow, 0.0555);
elm_slider_value_set(ow, pager_config->popup_height);
elm_slider_unit_format_set(ow, _("%.0f pixels"));
elm_slider_indicator_format_set(ow, _("%.0f"));
elm_table_pack(tb, ow, 0, 2, 1, 1);
E_ALIGN(ow, EVAS_HINT_FILL, EVAS_HINT_FILL);
E_WEIGHT(ow, EVAS_HINT_EXPAND, 0);
evas_object_smart_callback_add(ow, "delay,changed",
_config_value_changed, NULL);
evas_object_show(ow);
pager_gadget_config_objects->o_popup_height = ow;
ow = elm_label_add(m);
elm_object_text_set(ow, _("Popup duration"));
elm_object_disabled_set(ow, !pager_config->popup);
elm_table_pack(tb, ow, 0, 3, 1, 1);
E_ALIGN(ow, 0.0, 0.0);
E_WEIGHT(ow, EVAS_HINT_EXPAND, 0);
evas_object_show(ow);
ow = elm_slider_add(tb);
elm_object_disabled_set(ow, !pager_config->popup);
elm_slider_min_max_set(ow, 0.1, 10);
elm_slider_step_set(ow, 0.01);
elm_slider_value_set(ow, pager_config->popup_speed);
elm_slider_unit_format_set(ow, _("%1.1f seconds"));
elm_slider_indicator_format_set(ow, _("%.1f"));
elm_table_pack(tb, ow, 0, 4, 1, 1);
E_ALIGN(ow, EVAS_HINT_FILL, EVAS_HINT_FILL);
E_WEIGHT(ow, EVAS_HINT_EXPAND, 0);
evas_object_smart_callback_add(ow, "delay,changed",
_config_value_changed, NULL);
evas_object_show(ow);
pager_gadget_config_objects->o_popup_speed = ow;
ow = elm_label_add(m);
elm_object_text_set(ow, _("Pager action popup height"));
elm_object_disabled_set(ow, !pager_config->popup);
elm_table_pack(tb, ow, 0, 5, 1, 1);
E_ALIGN(ow, 0.0, 0.0);
E_WEIGHT(ow, EVAS_HINT_EXPAND, 0);
evas_object_show(ow);
ow = elm_slider_add(tb);
elm_object_disabled_set(ow, !pager_config->popup);
elm_slider_min_max_set(ow, 20, 200);
elm_slider_step_set(ow, 0.0555);
elm_slider_value_set(ow, pager_config->popup_act_height);
elm_slider_unit_format_set(ow, _("%.0f pixels"));
elm_slider_indicator_format_set(ow, _("%.0f"));
elm_table_pack(tb, ow, 0, 6, 1, 1);
E_ALIGN(ow, EVAS_HINT_FILL, EVAS_HINT_FILL);
E_WEIGHT(ow, EVAS_HINT_EXPAND, 0);
evas_object_smart_callback_add(ow, "delay,changed",
_config_value_changed, NULL);
evas_object_show(ow);
pager_gadget_config_objects->o_popup_act_height = ow;
elm_table_pack(m, fr, 0, 0, 1, 1);
pager_gadget_config_objects->popup_page = fr;
/* Urgent Page */
fr = elm_frame_add(m);
elm_object_text_set(fr, _("Urgent"));
E_EXPAND(fr);
E_FILL(fr);
evas_object_show(fr);
tb = elm_table_add(fr);
E_EXPAND(tb);
elm_object_content_set(fr, tb);
evas_object_show(tb);
ow = elm_check_add(tb);
elm_object_text_set(ow, _("Show popup for urgent window"));
evas_object_size_hint_align_set(ow, 0.0, EVAS_HINT_FILL);
elm_check_state_set(ow, pager_config->popup_urgent);
elm_table_pack(tb, ow, 0, 0, 1, 1);
E_ALIGN(ow, EVAS_HINT_FILL, EVAS_HINT_FILL);
E_WEIGHT(ow, EVAS_HINT_EXPAND, 0);
evas_object_smart_callback_add(ow, "changed",
_config_value_changed, NULL);
evas_object_show(ow);
pager_gadget_config_objects->o_popup_urgent = ow;
ow = elm_check_add(tb);
elm_object_disabled_set(ow, !pager_config->popup_urgent);
elm_object_text_set(ow, _("Urgent popup sticks on screen"));
evas_object_size_hint_align_set(ow, 0.0, EVAS_HINT_FILL);
elm_check_state_set(ow, pager_config->popup_urgent_stick);
elm_table_pack(tb, ow, 0, 1, 1, 1);
E_ALIGN(ow, EVAS_HINT_FILL, EVAS_HINT_FILL);
E_WEIGHT(ow, EVAS_HINT_EXPAND, 0);
evas_object_smart_callback_add(ow, "changed",
_config_value_changed, NULL);
evas_object_show(ow);
pager_gadget_config_objects->o_popup_urgent_stick = ow;
ow = elm_check_add(tb);
elm_object_disabled_set(ow, !pager_config->popup_urgent);
elm_object_text_set(ow, _("Show popup for focused windows"));
evas_object_size_hint_align_set(ow, 0.0, EVAS_HINT_FILL);
elm_check_state_set(ow, pager_config->popup_urgent_focus);
elm_table_pack(tb, ow, 0, 2, 1, 1);
E_ALIGN(ow, EVAS_HINT_FILL, EVAS_HINT_FILL);
E_WEIGHT(ow, EVAS_HINT_EXPAND, 0);
evas_object_smart_callback_add(ow, "changed",
_config_value_changed, NULL);
evas_object_show(ow);
pager_gadget_config_objects->o_popup_urgent_focus = ow;
ow = elm_label_add(m);
elm_object_text_set(ow, _("Urgent Popup Duration"));
elm_object_disabled_set(ow, !pager_config->popup_urgent);
elm_table_pack(tb, ow, 0, 3, 1, 1);
E_ALIGN(ow, 0.0, 0.0);
E_WEIGHT(ow, EVAS_HINT_EXPAND, 0);
evas_object_show(ow);
ow = elm_slider_add(tb);
elm_object_disabled_set(ow, !pager_config->popup_urgent);
elm_slider_min_max_set(ow, 0.1, 10);
elm_slider_step_set(ow, 0.01);
elm_slider_value_set(ow, pager_config->popup_urgent_speed);
elm_slider_unit_format_set(ow, _("%1.1f seconds"));
elm_slider_indicator_format_set(ow, _("%.1f"));
elm_table_pack(tb, ow, 0, 4, 1, 1);
E_ALIGN(ow, EVAS_HINT_FILL, EVAS_HINT_FILL);
E_WEIGHT(ow, EVAS_HINT_EXPAND, 0);
evas_object_smart_callback_add(ow, "delay,changed",
_config_value_changed, NULL);
evas_object_show(ow);
pager_gadget_config_objects->o_popup_urgent_speed = ow;
elm_table_pack(m, fr, 0, 0, 1, 1);
pager_gadget_config_objects->urgent_page = fr;
/* Style Page */
fr = elm_frame_add(m);
elm_object_text_set(fr, _("Style"));
E_EXPAND(fr);
E_FILL(fr);
evas_object_show(fr);
tb = elm_table_add(m);
E_EXPAND(tb);
elm_object_content_set(fr, tb);
evas_object_show(tb);
ow = elm_check_add(tb);
elm_object_text_set(ow, _("Always Use Plain Style"));
evas_object_size_hint_align_set(ow, 0.0, EVAS_HINT_FILL);
elm_check_state_set(ow, pager_config->permanent_plain);
elm_table_pack(tb, ow, 0, 0, 1, 1);
E_ALIGN(ow, EVAS_HINT_FILL, EVAS_HINT_FILL);
E_WEIGHT(ow, EVAS_HINT_EXPAND, 0);
evas_object_smart_callback_add(ow, "changed",
_config_value_changed, NULL);
evas_object_show(ow);
pager_gadget_config_objects->o_permanent = ow;
ow = elm_check_add(tb);
elm_object_text_set(ow, _("Switch to Plain Style When Saving Power"));
evas_object_size_hint_align_set(ow, 0.0, EVAS_HINT_FILL);
elm_check_state_set(ow, pager_config->plain);
elm_table_pack(tb, ow, 0, 1, 1, 1);
E_ALIGN(ow, EVAS_HINT_FILL, EVAS_HINT_FILL);
E_WEIGHT(ow, EVAS_HINT_EXPAND, 0);
evas_object_smart_callback_add(ow, "changed",
_config_value_changed, NULL);
evas_object_show(ow);
pager_gadget_config_objects->o_plain = ow;
elm_table_pack(m, fr, 0, 0, 1, 1);
pager_gadget_config_objects->style_page = fr;
return m;
}
EINTERN Evas_Object *
config_pager(E_Zone *zone)
{
Evas_Object *popup, *tb, *lbl, *list;
Elm_Object_Item *it;
pager_gadget_config_objects = E_NEW(Config_Objects, 1);
pager_gadget_config_objects->w = 0;
pager_gadget_config_objects->h = 0;
popup = elm_popup_add(e_comp->elm);
E_EXPAND(popup);
elm_popup_allow_events_set(popup, 1);
elm_popup_scrollable_set(popup, 1);
tb = elm_table_add(popup);
E_EXPAND(tb);
evas_object_show(tb);
elm_object_content_set(popup, tb);
lbl = elm_label_add(tb);
elm_object_style_set(lbl, "marker");
evas_object_show(lbl);
elm_object_text_set(lbl, _("Pager Configuration"));
elm_table_pack(tb, lbl, 0, 0, 2, 1);
list = elm_list_add(tb);
E_ALIGN(list, 0, EVAS_HINT_FILL);
E_WEIGHT(list, 0, EVAS_HINT_EXPAND);
elm_table_pack(tb, list, 0, 1, 1, 1);
elm_list_select_mode_set(list, ELM_OBJECT_SELECT_MODE_ALWAYS);
elm_scroller_content_min_limit(list, 1, 1);
it = elm_list_item_append(list, _("General"), NULL, NULL,
_config_show_general, NULL);
elm_list_item_selected_set(it, 1);
it = elm_list_item_append(list, _("Popup"), NULL, NULL,
_config_show_popup, NULL);
it = elm_list_item_append(list, _("Urgent"), NULL, NULL,
_config_show_urgent, NULL);
it = elm_list_item_append(list, _("Style"), NULL, NULL,
_config_show_style, NULL);
elm_list_go(list);
evas_object_show(list);
elm_table_pack(tb,
_config_create_pages(tb), 1, 1, 1, 1);
_config_show_general(NULL, NULL, NULL);
popup = e_comp_object_util_add(popup, E_COMP_OBJECT_TYPE_NONE);
evas_object_layer_set(popup, E_LAYER_POPUP);
evas_object_resize(popup, zone->w / 4, zone->h / 3);
e_comp_object_util_center_on_zone(popup, zone);
evas_object_show(popup);
e_comp_object_util_autoclose(popup, NULL, e_comp_object_util_autoclose_on_escape, NULL);
evas_object_event_callback_add(popup, EVAS_CALLBACK_DEL, _config_close, NULL);
return cfg_dialog = popup;
}

108
src/modules/pager/gadget/mod.c
View File

@ -1,108 +0,0 @@
#include "pager.h"
static E_Config_DD *conf_edd = NULL;
EINTERN Config *pager_config;
EINTERN Evas_Object *cfg_dialog;
EINTERN Eina_List *ginstances, *ghandlers, *phandlers;
EINTERN void *
e_modapi_gadget_init(E_Module *m)
{
conf_edd = E_CONFIG_DD_NEW("Pager_Config", Config);
#undef T
#undef D
#define T Config
#define D conf_edd
E_CONFIG_VAL(D, T, popup, UINT);
E_CONFIG_VAL(D, T, popup_speed, DOUBLE);
E_CONFIG_VAL(D, T, popup_urgent, UINT);
E_CONFIG_VAL(D, T, popup_urgent_stick, UINT);
E_CONFIG_VAL(D, T, popup_urgent_speed, DOUBLE);
E_CONFIG_VAL(D, T, show_desk_names, UINT);
E_CONFIG_VAL(D, T, popup_height, INT);
E_CONFIG_VAL(D, T, popup_act_height, INT);
E_CONFIG_VAL(D, T, drag_resist, UINT);
E_CONFIG_VAL(D, T, btn_drag, UCHAR);
E_CONFIG_VAL(D, T, btn_noplace, UCHAR);
E_CONFIG_VAL(D, T, btn_desk, UCHAR);
E_CONFIG_VAL(D, T, flip_desk, UCHAR);
E_CONFIG_VAL(D, T, plain, UCHAR);
E_CONFIG_VAL(D, T, permanent_plain, UCHAR);
pager_config = e_config_domain_load("module.pager", conf_edd);
if (!pager_config)
{
pager_config = E_NEW(Config, 1);
pager_config->popup = 1;
pager_config->popup_speed = 1.0;
pager_config->popup_urgent = 0;
pager_config->popup_urgent_stick = 0;
pager_config->popup_urgent_speed = 1.5;
pager_config->show_desk_names = 0;
pager_config->popup_height = 60;
pager_config->popup_act_height = 60;
pager_config->drag_resist = 3;
pager_config->btn_drag = 1;
pager_config->btn_noplace = 2;
pager_config->btn_desk = 2;
pager_config->flip_desk = 0;
pager_config->plain = 0;
pager_config->permanent_plain = 0;
}
E_CONFIG_LIMIT(pager_config->popup, 0, 1);
E_CONFIG_LIMIT(pager_config->popup_speed, 0.1, 10.0);
E_CONFIG_LIMIT(pager_config->popup_urgent, 0, 1);
E_CONFIG_LIMIT(pager_config->popup_urgent_stick, 0, 1);
E_CONFIG_LIMIT(pager_config->popup_urgent_speed, 0.1, 10.0);
E_CONFIG_LIMIT(pager_config->show_desk_names, 0, 1);
E_CONFIG_LIMIT(pager_config->popup_height, 20, 200);
E_CONFIG_LIMIT(pager_config->popup_act_height, 20, 200);
E_CONFIG_LIMIT(pager_config->drag_resist, 0, 50);
E_CONFIG_LIMIT(pager_config->flip_desk, 0, 1);
E_CONFIG_LIMIT(pager_config->btn_drag, 0, 32);
E_CONFIG_LIMIT(pager_config->btn_noplace, 0, 32);
E_CONFIG_LIMIT(pager_config->btn_desk, 0, 32);
E_CONFIG_LIMIT(pager_config->plain, 0, 1);
E_CONFIG_LIMIT(pager_config->permanent_plain, 0, 1);
pager_init();
e_gadget_type_add("Pager", pager_create, NULL);
return m;
}
EINTERN int
e_modapi_gadget_shutdown(E_Module *m EINA_UNUSED)
{
if (cfg_dialog)
e_object_del(E_OBJECT(cfg_dialog));
if (pager_config && ghandlers)
E_FREE_LIST(ghandlers, ecore_event_handler_del);
e_action_del("pager_gadget_show");
e_action_del("pager_gadget_switch");
e_action_predef_name_del("Pager Gadget", "Show Pager Popup");
e_action_predef_name_del("Pager Gadget", "Popup Desk Right");
e_action_predef_name_del("Pager Gadget", "Popup Desk Left");
e_action_predef_name_del("Pager Gadget", "Popup Desk Up");
e_action_predef_name_del("Pager Gadget", "Popup Desk Down");
e_action_predef_name_del("Pager Gadget", "Popup Desk Next");
e_action_predef_name_del("Pager Gadget", "Popup Desk Previous");
e_gadget_type_del("Pager");
E_FREE(pager_config);
E_CONFIG_DD_FREE(conf_edd);
return 1;
}
EINTERN int
e_modapi_gadget_save(E_Module *m EINA_UNUSED)
{
e_config_domain_save("module.pager", conf_edd, pager_config);
return 1;
}

2991
src/modules/pager/gadget/pager.c
View File

File diff suppressed because it is too large Load Diff

51
src/modules/pager/gadget/pager.h
View File

@ -1,51 +0,0 @@
#ifndef PAGER_H
#define PAGER_H
#include "e.h"
EINTERN void *e_modapi_gadget_init(E_Module *m);
EINTERN int e_modapi_gadget_shutdown(E_Module *m);
EINTERN int e_modapi_gadget_save(E_Module *m);
typedef struct _Config Config;
struct _Config
{
unsigned int popup;
double popup_speed;
unsigned int popup_urgent;
unsigned int popup_urgent_stick;
unsigned int popup_urgent_focus;
double popup_urgent_speed;
unsigned int show_desk_names;
int popup_act_height;
int popup_height;
unsigned int drag_resist;
unsigned int btn_drag;
unsigned int btn_noplace;
unsigned int btn_desk;
unsigned int flip_desk;
unsigned int plain;
unsigned int permanent_plain;
};
EINTERN Evas_Object *pager_create(Evas_Object *parent, int *id, E_Gadget_Site_Orient orient);
EINTERN Evas_Object *config_pager(E_Zone *zone);
EINTERN void pager_init(void);
EINTERN void _pager_cb_config_gadget_updated(Eina_Bool style_changed);
EINTERN void _pager_cb_config_updated(void);
EINTERN extern Config *pager_config;
EINTERN extern Evas_Object *cfg_dialog;
EINTERN extern Eina_List *ginstances, *ghandlers, *phandlers;
/**
* @addtogroup Optional_Gadgets
* @{
*
* @defgroup Module_Pager Virtual Desktop Pager
*
* Shows the grid of virtual desktops and allows changing between
* them.
*
* @}
*/
#endif

6
src/modules/pager/meson.build
View File

@ -1,9 +1,5 @@
src = files(
'e_mod_main.c',
'e_mod_config.c',
'e_mod_main.h',
'gadget/mod.c',
'gadget/pager.h',
'gadget/pager.c',
'gadget/config.c'
'e_mod_main.h'
)

4
src/modules/start/e_mod_main.c
View File

@ -320,11 +320,8 @@ E_API E_Module_Api e_modapi =
E_API void *
e_modapi_init(E_Module *m)
{
EINTERN Evas_Object *start_create(Evas_Object *parent, int *id, E_Gadget_Site_Orient orient);
start_module = m;
e_gadcon_provider_register(&_gadcon_class);
e_gadget_type_add("Start", start_create, NULL);
return m;
}
@ -333,7 +330,6 @@ e_modapi_shutdown(E_Module *m EINA_UNUSED)
{
start_module = NULL;
e_gadcon_provider_unregister(&_gadcon_class);
e_gadget_type_del("Start");
return 1;
}

3
src/modules/start/meson.build
View File

@ -1,4 +1,3 @@
src = files(
'e_mod_main.c',
'start.c'
'e_mod_main.c'
)

227
src/modules/start/start.c
View File

@ -1,227 +0,0 @@
#include "e.h"
/* actual module specifics */
typedef struct _Instance Instance;
struct _Instance
{
Evas_Object *site;
Evas_Object *o_button;
E_Menu *main_menu;
};
static void
do_orient(Instance *inst, E_Gadget_Site_Orient orient, E_Gadget_Site_Anchor anchor)
{
char buf[4096];
const char *s = "float";
if (anchor & E_GADGET_SITE_ANCHOR_LEFT)
{
if (anchor & E_GADGET_SITE_ANCHOR_TOP)
{
switch (orient)
{
case E_GADGET_SITE_ORIENT_HORIZONTAL:
s = "top_left";
break;
case E_GADGET_SITE_ORIENT_VERTICAL:
s = "left_top";
break;
case E_GADGET_SITE_ORIENT_NONE:
s = "left_top";
break;
}
}
else if (anchor & E_GADGET_SITE_ANCHOR_BOTTOM)
{
switch (orient)
{
case E_GADGET_SITE_ORIENT_HORIZONTAL:
s = "bottom_left";
break;
case E_GADGET_SITE_ORIENT_VERTICAL:
s = "left_bottom";
break;
case E_GADGET_SITE_ORIENT_NONE:
s = "left_bottom";
break;
}
}
else
s = "left";
}
else if (anchor & E_GADGET_SITE_ANCHOR_RIGHT)
{
if (anchor & E_GADGET_SITE_ANCHOR_TOP)
{
switch (orient)
{
case E_GADGET_SITE_ORIENT_HORIZONTAL:
s = "top_right";
break;
case E_GADGET_SITE_ORIENT_VERTICAL:
s = "right_top";
break;
case E_GADGET_SITE_ORIENT_NONE:
s = "right_top";
break;
}
}
else if (anchor & E_GADGET_SITE_ANCHOR_BOTTOM)
{
switch (orient)
{
case E_GADGET_SITE_ORIENT_HORIZONTAL:
s = "bottom_right";
break;
case E_GADGET_SITE_ORIENT_VERTICAL:
s = "right_bottom";
break;
case E_GADGET_SITE_ORIENT_NONE:
s = "right_bottom";
break;
}
}
else
s = "right";
}
else if (anchor & E_GADGET_SITE_ANCHOR_TOP)
s = "top";
else if (anchor & E_GADGET_SITE_ANCHOR_BOTTOM)
s = "bottom";
else
{
switch (orient)
{
case E_GADGET_SITE_ORIENT_HORIZONTAL:
s = "horizontal";
break;
case E_GADGET_SITE_ORIENT_VERTICAL:
s = "vertical";
break;
default: break;
}
}
snprintf(buf, sizeof(buf), "e,state,orientation,%s", s);
elm_layout_signal_emit(inst->o_button, buf, "e");
}
static void
_menu_cb_post(void *data, E_Menu *m)
{
Instance *inst = data;
Eina_Bool fin;
if (stopping || (!inst->main_menu)) return;
fin = m == inst->main_menu;
e_object_del(E_OBJECT(m));
if (!fin) return;
elm_layout_signal_emit(inst->o_button, "e,state,unfocused", "e");
inst->main_menu = NULL;
}
static void
_button_cb_mouse_up(void *data, Evas *e EINA_UNUSED, Evas_Object *obj EINA_UNUSED, void *event_info)
{
Instance *inst = data;
Evas_Event_Mouse_Up *ev = event_info;
Evas_Coord x, y, w, h;
E_Gadget_Site_Anchor an;
int dir = E_MENU_POP_DIRECTION_AUTO;
if (ev->button != 1) return;
if (ev->event_flags & EVAS_EVENT_FLAG_ON_HOLD) return;
evas_object_geometry_get(inst->o_button, &x, &y, &w, &h);
if (!inst->main_menu)
inst->main_menu = e_int_menus_main_new();
if (!inst->main_menu) return;
e_menu_post_deactivate_callback_set(inst->main_menu,
_menu_cb_post, inst);
an = e_gadget_site_anchor_get(e_gadget_site_get(inst->o_button));
switch (e_gadget_site_orient_get(e_gadget_site_get(inst->o_button)))
{
case E_GADGET_SITE_ORIENT_HORIZONTAL:
if (an & E_GADGET_SITE_ANCHOR_TOP)
dir = E_MENU_POP_DIRECTION_DOWN;
else if (an & E_GADGET_SITE_ANCHOR_BOTTOM)
dir = E_MENU_POP_DIRECTION_UP;
break;
case E_GADGET_SITE_ORIENT_VERTICAL:
if (an & E_GADGET_SITE_ANCHOR_LEFT)
dir = E_MENU_POP_DIRECTION_RIGHT;
else if (an & E_GADGET_SITE_ANCHOR_RIGHT)
dir = E_MENU_POP_DIRECTION_LEFT;
break;
default: break;
}
e_menu_activate_mouse(inst->main_menu,
e_zone_current_get(),
x, y, w, h, dir, ev->timestamp);
evas_object_smart_callback_call(inst->o_button, "gadget_popup",
inst->main_menu->container_object);
elm_layout_signal_emit(inst->o_button, "e,state,focused", "e");
ev->event_flags |= EVAS_EVENT_FLAG_ON_HOLD;
}
static void
_anchor_change(void *data, Evas_Object *obj, void *event_info EINA_UNUSED)
{
Instance *inst = data;
do_orient(inst, e_gadget_site_orient_get(obj), e_gadget_site_anchor_get(obj));
}
static void
start_del(void *data, Evas *e EINA_UNUSED, Evas_Object *obj EINA_UNUSED, void *event_info EINA_UNUSED)
{
Instance *inst = data;
if (inst->main_menu)
{
e_menu_post_deactivate_callback_set(inst->main_menu, NULL, NULL);
e_object_del(E_OBJECT(inst->main_menu));
}
evas_object_smart_callback_del_full(inst->site, "gadget_site_anchor", _anchor_change, inst);
free(inst);
}
static void
_gadget_created(void *data, Evas_Object *obj, void *event_info)
{
Instance *inst = data;
if (event_info != inst->o_button) return;
do_orient(inst, e_gadget_site_orient_get(obj), e_gadget_site_anchor_get(obj));
evas_object_smart_callback_del_full(obj, "gadget_created", _gadget_created, inst);
}
EINTERN Evas_Object *
start_create(Evas_Object *parent, int *id, E_Gadget_Site_Orient orient)
{
Evas_Object *o;
Instance *inst;
if (e_gadget_site_is_desklock(parent)) return NULL;
if (*id == 0) *id = 1;
inst = E_NEW(Instance, 1);
inst->site = parent;
o = elm_layout_add(parent);
e_theme_edje_object_set(o, NULL, "e/gadget/start/main");
elm_layout_signal_emit(o, "e,state,unfocused", "e");
inst->o_button = o;
evas_object_size_hint_aspect_set(o, EVAS_ASPECT_CONTROL_BOTH, 1, 1);
evas_object_event_callback_add(o, EVAS_CALLBACK_MOUSE_UP,
_button_cb_mouse_up, inst);
evas_object_event_callback_add(o, EVAS_CALLBACK_DEL, start_del, inst);
evas_object_smart_callback_add(parent, "gadget_site_anchor", _anchor_change, inst);
evas_object_smart_callback_add(parent, "gadget_created", _gadget_created, inst);
do_orient(inst, orient, e_gadget_site_anchor_get(parent));
return o;
}

759
src/modules/sysinfo/batman/batman.c
View File

@ -1,759 +0,0 @@
#include "batman.h"
EINTERN Eina_Bool upower;
EINTERN Eina_List *batman_device_batteries;
EINTERN Eina_List *batman_device_ac_adapters;
EINTERN double batman_init_time;
static Eina_Bool _batman_cb_warning_popup_timeout(void *data);
static void _batman_cb_warning_popup_hide(void *data, Evas *e, Evas_Object *obj, void *event);
static void _batman_warning_popup_destroy(Instance *inst);
static void _batman_warning_popup(Instance *inst, int time, double percent);
Eina_List *
_batman_battery_find(const char *udi)
{
Eina_List *l;
Battery *bat;
Eina_List *batteries = NULL;
EINA_LIST_FOREACH(batman_device_batteries, l, bat)
{ /* these are always stringshared */
if (udi == bat->udi) batteries = eina_list_append(batteries, bat);
}
return batteries;
}
Eina_List *
_batman_ac_adapter_find(const char *udi)
{
Eina_List *l;
Ac_Adapter *ac;
Eina_List *adapters = NULL;
EINA_LIST_FOREACH(batman_device_ac_adapters, l, ac)
{ /* these are always stringshared */
if (udi == ac->udi) adapters = eina_list_append(adapters, ac);
}
return adapters;
}
static void
_batman_face_level_set(Evas_Object *battery, double level)
{
Edje_Message_Float msg;
if (level < 0.0) level = 0.0;
else if (level > 1.0)
level = 1.0;
msg.val = level;
edje_object_message_send(elm_layout_edje_get(battery), EDJE_MESSAGE_FLOAT, 1, &msg);
}
static void
_batman_popup_dismissed(void *data, Evas_Object *obj, void *event_info EINA_UNUSED)
{
Instance *inst = data;
E_FREE_FUNC(obj, evas_object_del);
inst->cfg->batman.popup = NULL;
}
static void
_batman_popup_deleted(void *data, Evas *e EINA_UNUSED, Evas_Object *obj EINA_UNUSED, void *event_info EINA_UNUSED)
{
Instance *inst = data;
inst->cfg->batman.popup = NULL;
}
static Evas_Object *
_batman_popup_create(Instance *inst)
{
Evas_Object *popup, *box, *pbar, *label;
Battery *bat;
Eina_List *l;
char buf[128], buf2[128 + 100];
int hrs = 0, mins = 0;
Eina_List *udis = NULL;
hrs = (inst->cfg->batman.time_left / 3600);
mins = ((inst->cfg->batman.time_left) / 60 - (hrs * 60));
if (mins < 0) mins = 0;
popup = elm_ctxpopup_add(e_comp->elm);
elm_object_style_set(popup, "noblock");
evas_object_smart_callback_add(popup, "dismissed",
_batman_popup_dismissed, inst);
evas_object_event_callback_add(popup, EVAS_CALLBACK_DEL,
_batman_popup_deleted, inst);
box = elm_box_add(popup);
elm_box_horizontal_set(box, EINA_FALSE);
E_EXPAND(box); E_FILL(box);
elm_object_content_set(popup, box);
evas_object_show(box);
label = elm_label_add(box);
E_EXPAND(label); E_ALIGN(label, 0.5, 0.5);
elm_object_text_set(label, buf);
elm_box_pack_end(box, label);
evas_object_show(label);
if (eina_list_count(batman_device_batteries) == 0)
snprintf(buf, sizeof(buf), _("No Battery Found"));
else if (inst->cfg->batman.have_power && (inst->cfg->batman.full < 99))
snprintf(buf, sizeof(buf), _("Battery Charging"));
else if (inst->cfg->batman.full >= 99)
snprintf(buf, sizeof(buf), _("Battery Fully Charged"));
else
snprintf(buf, sizeof(buf), _("Time Remaining: %i:%02i"), hrs, mins);
snprintf(buf2, sizeof(buf2), "<big><b>%s</b></big>", buf);
elm_object_text_set(label, buf2);
EINA_LIST_FOREACH(batman_device_batteries, l, bat)
{
if (!eina_list_count(udis) || !eina_list_data_find(udis, bat->udi))
{
udis = eina_list_append(udis, bat->udi);
if (bat->vendor && bat->vendor[0] && bat->model && bat->model[0])
{
label = elm_label_add(box);
E_EXPAND(label); E_ALIGN(label, 0.5, 0.5);
snprintf(buf, sizeof(buf), "%s (%s)", bat->vendor, bat->model);
elm_object_text_set(label, buf);
elm_box_pack_end(box, label);
evas_object_show(label);
}
pbar = elm_progressbar_add(box);
E_EXPAND(pbar); E_FILL(pbar);
elm_progressbar_span_size_set(pbar, 200 * e_scale);
elm_progressbar_value_set(pbar, bat->percent / 100);
elm_box_pack_end(box, pbar);
evas_object_show(pbar);
}
}
if (eina_list_count(udis))
eina_list_free(udis);
e_gadget_util_ctxpopup_place(inst->o_main, popup,
inst->cfg->batman.o_gadget);
evas_object_show(popup);
return popup;
}
static Evas_Object *
_batman_configure_cb(Evas_Object *g)
{
Instance *inst = evas_object_data_get(g, "Instance");
if (!sysinfo_config) return NULL;
if (inst->cfg->batman.popup) return NULL;
return batman_configure(inst);
}
static void
_batman_mouse_up_cb(void *data, Evas *e EINA_UNUSED, Evas_Object *obj EINA_UNUSED, void *event_data)
{
Evas_Event_Mouse_Up *ev = event_data;
Instance *inst = data;
if (ev->event_flags & EVAS_EVENT_FLAG_ON_HOLD) return;
if (ev->button == 1)
{
if (inst->cfg->batman.popup)
elm_ctxpopup_dismiss(inst->cfg->batman.popup);
else
inst->cfg->batman.popup = _batman_popup_create(inst);
}
}
static Eina_Bool
_powersave_cb_config_update(void *data, int type EINA_UNUSED, void *event EINA_UNUSED)
{
Instance *inst = data;
if (!inst->cfg->batman.have_battery)
e_powersave_mode_set(E_POWERSAVE_MODE_LOW);
else
{
if (inst->cfg->batman.have_power)
e_powersave_mode_set(E_POWERSAVE_MODE_LOW);
else if (inst->cfg->batman.full > 95)
e_powersave_mode_set(E_POWERSAVE_MODE_MEDIUM);
else if (inst->cfg->batman.full > 30)
e_powersave_mode_set(E_POWERSAVE_MODE_HIGH);
else
e_powersave_mode_set(E_POWERSAVE_MODE_EXTREME);
}
return ECORE_CALLBACK_RENEW;
}
void
_batman_update(Instance *inst, int full, int time_left, Eina_Bool have_battery, Eina_Bool have_power)
{
static double debounce_time = 0.0;
if (!inst) return;
if (!inst->cfg) return;
if (inst->cfg->esm != E_SYSINFO_MODULE_BATMAN && inst->cfg->esm != E_SYSINFO_MODULE_SYSINFO) return;
if (have_power != inst->cfg->batman.have_power)
{
if (have_power && (full < 100))
elm_layout_signal_emit(inst->cfg->batman.o_gadget,
"e,state,charging",
"e");
else
{
elm_layout_signal_emit(inst->cfg->batman.o_gadget,
"e,state,discharging",
"e");
if (inst->popup_battery)
elm_layout_signal_emit(inst->popup_battery,
"e,state,discharging", "e");
}
}
if (have_battery)
{
if (inst->cfg->batman.full != full)
{
double val;
if (full >= 100) val = 1.0;
else val = (double)full / 100.0;
_batman_face_level_set(inst->cfg->batman.o_gadget, val);
if (inst->popup_battery)
_batman_face_level_set(inst->popup_battery, val);
}
}
else
{
_batman_face_level_set(inst->cfg->batman.o_gadget, 0.0);
}
if (have_battery &&
(!have_power) &&
(full < 100) &&
(
(
(time_left > 0) &&
inst->cfg->batman.alert &&
((time_left / 60) <= inst->cfg->batman.alert)
) ||
(
inst->cfg->batman.alert_p &&
(full <= inst->cfg->batman.alert_p)
)
)
)
{
double t;
printf("-------------------------------------- bat warn .. why below\n");
printf("have_battery = %i\n", (int)have_battery);
printf("have_power = %i\n", (int)have_power);
printf("full = %i\n", (int)full);
printf("time_left = %i\n", (int)time_left);
printf("inst->cfg->batman.alert = %i\n", (int)inst->cfg->batman.alert);
printf("inst->cfg->batman.alert_p = %i\n", (int)inst->cfg->batman.alert_p);
t = ecore_time_get();
if ((t - debounce_time) > 30.0)
{
printf("t-debounce = %3.3f\n", (t - debounce_time));
debounce_time = t;
if ((t - batman_init_time) > 5.0)
_batman_warning_popup(inst, time_left, (double)full / 100.0);
}
}
else if (have_power || ((time_left / 60) > inst->cfg->batman.alert))
_batman_warning_popup_destroy(inst);
if ((have_battery) && (!have_power) && (full >= 0) &&
(inst->cfg->batman.suspend_below > 0) &&
(full < inst->cfg->batman.suspend_below))
{
if (inst->cfg->batman.suspend_method == SUSPEND)
e_sys_action_do(E_SYS_SUSPEND, NULL);
else if (inst->cfg->batman.suspend_method == HIBERNATE)
e_sys_action_do(E_SYS_HIBERNATE, NULL);
else if (inst->cfg->batman.suspend_method == SHUTDOWN)
e_sys_action_do(E_SYS_HALT, NULL);
}
inst->cfg->batman.full = full;
inst->cfg->batman.time_left = time_left;
inst->cfg->batman.have_battery = have_battery;
inst->cfg->batman.have_power = have_power;
if (!have_battery)
e_powersave_mode_set(E_POWERSAVE_MODE_LOW);
else
{
if (have_power)
e_powersave_mode_set(E_POWERSAVE_MODE_LOW);
else if (full > 95)
e_powersave_mode_set(E_POWERSAVE_MODE_MEDIUM);
else if (full > 30)
e_powersave_mode_set(E_POWERSAVE_MODE_HIGH);
else
e_powersave_mode_set(E_POWERSAVE_MODE_EXTREME);
}
}
void
_batman_device_update(Instance *inst)
{
Eina_List *l;
Battery *bat;
Ac_Adapter *ac;
int full = -1;
int time_left = -1;
int have_battery = 0;
int have_power = 0;
int charging = 0;
int batnum = 0;
int acnum = 0;
EINA_LIST_FOREACH(batman_device_ac_adapters, l, ac)
{
if (ac->present)
{
acnum++;
have_power = 1;
}
}
EINA_LIST_FOREACH(batman_device_batteries, l, bat)
{
if (!bat->got_prop)
continue;
have_battery = 1;
batnum++;
if (bat->charging == 1) have_power = 1;
if (full == -1) full = 0;
if (bat->percent >= 0)
full += bat->percent;
else if (bat->last_full_charge > 0)
full += (bat->current_charge * 100) / bat->last_full_charge;
else if (bat->design_charge > 0)
full += (bat->current_charge * 100) / bat->design_charge;
if (bat->time_left > 0)
{
if (time_left < 0) time_left = bat->time_left;
else time_left += bat->time_left;
}
charging += bat->charging;
}
if ((batman_device_batteries) && (batnum == 0))
return; /* not ready yet, no properties received for any battery */
if (batnum > 0) full /= batnum;
if ((full == 100) && have_power)
{
time_left = -1;
}
if (time_left < 1) time_left = -1;
_batman_update(inst, full, time_left, have_battery, have_power);
}
static Eina_Bool
_screensaver_on(void *data)
{
#if defined(HAVE_EEZE) || defined(__OpenBSD__) || defined(__DragonFly__) || defined(__FreeBSD__) || defined(__NetBSD__)
Instance *inst = data;
#else
(void)data;
#endif
#if defined(HAVE_EEZE)
_batman_udev_stop(inst);
#elif defined(__OpenBSD__) || defined(__DragonFly__) || defined(__FreeBSD__) || defined(__NetBSD__)
_batman_sysctl_stop(inst);
#elif defined(upower)
_batman_upower_stop();
#else
_batman_fallback_stop();
#endif
return ECORE_CALLBACK_RENEW;
}
static Eina_Bool
_screensaver_off(void *data)
{
Instance *inst = data;
_batman_config_updated(inst);
return ECORE_CALLBACK_RENEW;
}
void
_batman_config_updated(Instance *inst)
{
int ok = 0;
if (!inst->cfg) return;
if (inst->cfg->id == -1)
{
_batman_face_level_set(inst->cfg->batman.o_gadget, 1.0);
return;
}
if ((inst->cfg->batman.force_mode == UNKNOWN) ||
(inst->cfg->batman.force_mode == SUBSYSTEM))
{
#if defined(HAVE_EEZE)
ok = _batman_udev_start(inst);
#elif defined(__OpenBSD__) || defined(__DragonFly__) || defined(__FreeBSD__) || defined(__NetBSD__)
ok = _batman_sysctl_start(inst);
#else
ok = _batman_upower_start(inst);
if (ok)
upower = EINA_TRUE;
#endif
}
if (ok) return;
if ((inst->cfg->batman.force_mode == UNKNOWN) ||
(inst->cfg->batman.force_mode == NOSUBSYSTEM))
{
ok = _batman_fallback_start(inst);
}
}
static void
_warning_popup_dismissed(void *data, Evas_Object *obj EINA_UNUSED, void *event_info EINA_UNUSED)
{
Instance *inst = data;
E_FREE_FUNC(inst->popup_battery, evas_object_del);
E_FREE_FUNC(inst->warning, evas_object_del);
}
static Eina_Bool
_batman_cb_warning_popup_timeout(void *data)
{
Instance *inst;
inst = data;
elm_ctxpopup_dismiss(inst->warning);
inst->cfg->batman.alert_timer = NULL;
return ECORE_CALLBACK_CANCEL;
}
static void
_batman_cb_warning_popup_hide(void *data, Evas *e EINA_UNUSED, Evas_Object *obj EINA_UNUSED, void *event EINA_UNUSED)
{
Instance *inst = NULL;
inst = (Instance *)data;
if ((!inst) || (!inst->warning)) return;
evas_object_hide(inst->warning);
}
static void
_batman_warning_popup_destroy(Instance *inst)
{
if (inst->cfg->batman.alert_timer)
{
ecore_timer_del(inst->cfg->batman.alert_timer);
inst->cfg->batman.alert_timer = NULL;
}
if (!inst->warning) return;
elm_ctxpopup_dismiss(inst->warning);
}
static void
_batman_warning_popup_cb(void *data, unsigned int id)
{
Instance *inst = data;
inst->notification_id = id;
}
static void
_batman_warning_popup(Instance *inst, int t, double percent)
{
Evas_Object *popup_bg = NULL;
int x, y, w, h;
char buf[4096];
int hrs = 0, mins = 0;
if ((!inst) || (inst->warning)) return;
hrs = (t / 3600);
mins = ((t) / 60 - (hrs * 60));
if (mins < 0) mins = 0;
snprintf(buf, 4096, _("AC power is recommended. %i:%02i Remaining"), hrs, mins);
if (inst->cfg->batman.desktop_notifications)
{
E_Notification_Notify n;
memset(&n, 0, sizeof(E_Notification_Notify));
n.app_name = _("Battery");
n.replaces_id = 0;
n.icon.icon = "battery-low";
n.summary = _("Your battery is low!");
n.body = buf;
n.timeout = inst->cfg->batman.alert_timeout * 1000;
e_notification_client_send(&n, _batman_warning_popup_cb, inst);
return;
}
inst->warning = elm_ctxpopup_add(e_comp->elm);
elm_object_style_set(inst->warning, "noblock");
evas_object_smart_callback_add(inst->warning, "dismissed", _warning_popup_dismissed, inst);
if (!inst->warning) return;
popup_bg = elm_layout_add(inst->warning);
inst->popup_battery = elm_layout_add(popup_bg);
if ((!popup_bg) || (!inst->popup_battery))
{
elm_ctxpopup_dismiss(inst->warning);
inst->warning = NULL;
return;
}
e_theme_edje_object_set(popup_bg, "base/theme/gadget/batman/popup",
"e/gadget/batman/popup");
e_theme_edje_object_set(inst->popup_battery, "base/theme/gadget/batman",
"e/gadget/batman/main");
if (edje_object_part_exists(elm_layout_edje_get(popup_bg), "e.swallow.batman"))
elm_layout_content_set(popup_bg, "e.swallow.batman", inst->popup_battery);
else
elm_layout_content_set(popup_bg, "battery", inst->popup_battery);
elm_layout_text_set(popup_bg, "e.text.title",
_("Your battery is low!"));
elm_layout_text_set(popup_bg, "e.text.label", buf);
evas_object_show(inst->popup_battery);
evas_object_show(popup_bg);
elm_object_content_set(inst->warning, popup_bg);
e_gadget_util_ctxpopup_place(inst->o_main, inst->warning, inst->cfg->batman.o_gadget);
evas_object_layer_set(inst->warning, E_LAYER_POPUP);
evas_object_show(inst->warning);
evas_object_geometry_get(inst->warning, &x, &y, &w, &h);
evas_object_event_callback_add(inst->warning, EVAS_CALLBACK_MOUSE_UP,
_batman_cb_warning_popup_hide, inst);
_batman_face_level_set(inst->popup_battery, percent);
edje_object_signal_emit(inst->popup_battery, "e,state,discharging", "e");
if ((inst->cfg->batman.alert_timeout > 0) &&
(!inst->cfg->batman.alert_timer))
{
inst->cfg->batman.alert_timer =
ecore_timer_loop_add(inst->cfg->batman.alert_timeout,
_batman_cb_warning_popup_timeout, inst);
}
}
static void
_batman_resize_cb(void *data, Evas *e EINA_UNUSED, Evas_Object *obj EINA_UNUSED, void *event_data EINA_UNUSED)
{
Evas_Coord w, h;
Instance *inst = data;
edje_object_parts_extends_calc(elm_layout_edje_get(inst->cfg->batman.o_gadget), 0, 0, &w, &h);
if (w < 1) w = 1;
if (h < 1) h = 1;
if (inst->cfg->esm == E_SYSINFO_MODULE_BATMAN)
evas_object_size_hint_aspect_set(inst->o_main, EVAS_ASPECT_CONTROL_BOTH, w, h);
else
evas_object_size_hint_aspect_set(inst->cfg->batman.o_gadget, EVAS_ASPECT_CONTROL_BOTH, w, h);
}
static void
_batman_removed_cb(void *data, Evas_Object *obj EINA_UNUSED, void *event_data)
{
Instance *inst = data;
Ecore_Event_Handler *handler;
if (inst->o_main != event_data) return;
if (inst->cfg->batman.popup)
E_FREE_FUNC(inst->cfg->batman.popup, evas_object_del);
if (inst->cfg->batman.configure)
E_FREE_FUNC(inst->cfg->batman.configure, evas_object_del);
EINA_LIST_FREE(inst->cfg->batman.handlers, handler)
ecore_event_handler_del(handler);
#if defined(HAVE_EEZE)
_batman_udev_stop(inst);
#elif defined(__OpenBSD__) || defined(__DragonFly__) || defined(__FreeBSD__) || defined(__NetBSD__)
_batman_sysctl_stop(inst);
#elif defined(upower)
_batman_upower_stop();
#else
_batman_fallback_stop();
#endif
evas_object_event_callback_del_full(inst->o_main, EVAS_CALLBACK_DEL, sysinfo_batman_remove, data);
evas_object_smart_callback_del_full(e_gadget_site_get(inst->o_main), "gadget_removed",
_batman_removed_cb, inst);
sysinfo_config->items = eina_list_remove(sysinfo_config->items, inst->cfg);
if (inst->cfg->id >= 0)
sysinfo_instances = eina_list_remove(sysinfo_instances, inst);
E_FREE(inst->cfg);
E_FREE(inst);
}
void
sysinfo_batman_remove(void *data, Evas *e EINA_UNUSED, Evas_Object *obj EINA_UNUSED, void *event_data EINA_UNUSED)
{
Instance *inst = data;
Ecore_Event_Handler *handler;
if (inst->cfg->batman.popup)
E_FREE_FUNC(inst->cfg->batman.popup, evas_object_del);
if (inst->cfg->batman.configure)
E_FREE_FUNC(inst->cfg->batman.configure, evas_object_del);
EINA_LIST_FREE(inst->cfg->batman.handlers, handler)
ecore_event_handler_del(handler);
#if defined(HAVE_EEZE)
_batman_udev_stop(inst);
#elif defined(__OpenBSD__) || defined(__DragonFly__) || defined(__FreeBSD__) || defined(__NetBSD__)
_batman_sysctl_stop(inst);
#elif defined(upower)
(void)inst;
_batman_upower_stop();
#else
(void)inst;
_batman_fallback_stop();
#endif
}
static void
_batman_created_cb(void *data, Evas_Object *obj, void *event_data EINA_UNUSED)
{
Instance *inst = data;
E_Gadget_Site_Orient orient = e_gadget_site_orient_get(e_gadget_site_get(inst->o_main));
e_gadget_configure_cb_set(inst->o_main, _batman_configure_cb);
inst->cfg->batman.full = -2;
inst->cfg->batman.time_left = -2;
inst->cfg->batman.have_battery = -2;
inst->cfg->batman.have_power = -2;
inst->cfg->batman.o_gadget = elm_layout_add(inst->o_main);
if (orient == E_GADGET_SITE_ORIENT_VERTICAL)
e_theme_edje_object_set(inst->cfg->batman.o_gadget,
"base/theme/gadget/batman",
"e/gadget/batman/main_vert");
else
e_theme_edje_object_set(inst->cfg->batman.o_gadget, "base/theme/gadget/batman",
"e/gadget/batman/main");
E_EXPAND(inst->cfg->batman.o_gadget);
E_FILL(inst->cfg->batman.o_gadget);
elm_box_pack_end(inst->o_main, inst->cfg->batman.o_gadget);
evas_object_event_callback_add(inst->cfg->batman.o_gadget,
EVAS_CALLBACK_MOUSE_UP,
_batman_mouse_up_cb, inst);
evas_object_event_callback_add(inst->cfg->batman.o_gadget, EVAS_CALLBACK_RESIZE, _batman_resize_cb, inst);
evas_object_show(inst->cfg->batman.o_gadget);
evas_object_smart_callback_del_full(obj, "gadget_created", _batman_created_cb, data);
E_LIST_HANDLER_APPEND(inst->cfg->batman.handlers, E_EVENT_SCREENSAVER_ON, _screensaver_on, inst);
E_LIST_HANDLER_APPEND(inst->cfg->batman.handlers, E_EVENT_SCREENSAVER_OFF, _screensaver_off, inst);
E_LIST_HANDLER_APPEND(inst->cfg->batman.handlers, E_EVENT_POWERSAVE_CONFIG_UPDATE,
_powersave_cb_config_update, inst);
_batman_config_updated(inst);
}
Evas_Object *
sysinfo_batman_create(Evas_Object *parent, Instance *inst)
{
inst->cfg->batman.full = -2;
inst->cfg->batman.time_left = -2;
inst->cfg->batman.have_battery = -2;
inst->cfg->batman.have_power = -2;
inst->cfg->batman.o_gadget = elm_layout_add(parent);
e_theme_edje_object_set(inst->cfg->batman.o_gadget, "base/theme/gadget/batman",
"e/gadget/batman/main");
E_EXPAND(inst->cfg->batman.o_gadget);
E_FILL(inst->cfg->batman.o_gadget);
evas_object_event_callback_add(inst->cfg->batman.o_gadget,
EVAS_CALLBACK_MOUSE_UP,
_batman_mouse_up_cb, inst);
evas_object_event_callback_add(inst->cfg->batman.o_gadget, EVAS_CALLBACK_RESIZE, _batman_resize_cb, inst);
evas_object_show(inst->cfg->batman.o_gadget);
E_LIST_HANDLER_APPEND(inst->cfg->batman.handlers, E_EVENT_SCREENSAVER_ON, _screensaver_on, inst);
E_LIST_HANDLER_APPEND(inst->cfg->batman.handlers, E_EVENT_SCREENSAVER_OFF, _screensaver_off, inst);
E_LIST_HANDLER_APPEND(inst->cfg->batman.handlers, E_EVENT_POWERSAVE_CONFIG_UPDATE,
_powersave_cb_config_update, inst);
_batman_config_updated(inst);
return inst->cfg->batman.o_gadget;
}
static Config_Item *
_conf_item_get(int *id)
{
Config_Item *ci;
Eina_List *l;
if (*id > 0)
{
EINA_LIST_FOREACH(sysinfo_config->items, l, ci)
if (*id == ci->id && ci->esm == E_SYSINFO_MODULE_BATMAN) return ci;
}
ci = E_NEW(Config_Item, 1);
if (*id != -1)
ci->id = eina_list_count(sysinfo_config->items) + 1;
else
ci->id = -1;
ci->esm = E_SYSINFO_MODULE_BATMAN;
ci->batman.poll_interval = 512;
ci->batman.alert = 30;
ci->batman.alert_p = 10;
ci->batman.alert_timeout = 0;
ci->batman.suspend_below = 0;
ci->batman.force_mode = 0;
ci->batman.full = -2;
ci->batman.time_left = -2;
ci->batman.have_battery = -2;
ci->batman.have_power = -2;
#if defined(HAVE_EEZE) || defined(__OpenBSD__) || defined(__NetBSD__)
ci->batman.fuzzy = 0;
#endif
ci->batman.desktop_notifications = 0;
ci->batman.configure = NULL;
sysinfo_config->items = eina_list_append(sysinfo_config->items, ci);
return ci;
}
Evas_Object *
batman_create(Evas_Object *parent, int *id, E_Gadget_Site_Orient orient EINA_UNUSED)
{
Instance *inst;
inst = E_NEW(Instance, 1);
inst->cfg = _conf_item_get(id);
*id = inst->cfg->id;
inst->o_main = elm_box_add(parent);
evas_object_data_set(inst->o_main, "Instance", inst);
evas_object_smart_callback_add(parent, "gadget_created", _batman_created_cb, inst);
evas_object_smart_callback_add(parent, "gadget_removed", _batman_removed_cb, inst);
evas_object_event_callback_add(inst->o_main, EVAS_CALLBACK_DEL, sysinfo_batman_remove, inst);
evas_object_show(inst->o_main);
if (inst->cfg->id < 0) return inst->o_main;
sysinfo_instances =
eina_list_append(sysinfo_instances, inst);
return inst->o_main;
}

114
src/modules/sysinfo/batman/batman.h
View File

@ -1,114 +0,0 @@
#ifndef BATMAN_H
#define BATMAN_H
#include "../sysinfo.h"
#define CHECK_NONE 0
#define CHECK_ACPI 1
#define CHECK_APM 2
#define CHECK_PMU 3
#define CHECK_SYS_ACPI 4
#define UNKNOWN 0
#define NOSUBSYSTEM 1
#define SUBSYSTEM 2
#define SUSPEND 0
#define HIBERNATE 1
#define SHUTDOWN 2
#define POPUP_DEBOUNCE_CYCLES 2
typedef struct _Battery Battery;
typedef struct _Ac_Adapter Ac_Adapter;
typedef struct _Batman_Config Batman_Config;
struct _Battery
{
Instance *inst;
const char *udi;
#if defined(HAVE_EEZE) || defined(__OpenBSD__) || defined(__DragonFly__) || defined(__FreeBSD__) || defined(__NetBSD__)
Ecore_Poller *poll;
#endif
Eina_Bool present E_BITFIELD;
Eina_Bool charging E_BITFIELD;
#if defined(HAVE_EEZE) || defined(__OpenBSD__) || defined(__DragonFly__) || defined(__FreeBSD__) || defined(__NetBSD__)
double last_update;
double percent;
double current_charge;
double design_charge;
double last_full_charge;
double charge_rate;
double time_full;
double time_left;
#else
int percent;
int current_charge;
int design_charge;
int last_full_charge;
int charge_rate;
int time_full;
int time_left;
const char *type;
const char *charge_units;
#endif
const char *technology;
const char *model;
const char *vendor;
Eina_Bool got_prop E_BITFIELD;
Eldbus_Proxy *proxy;
int * mib;
};
struct _Ac_Adapter
{
Instance *inst;
const char *udi;
Eina_Bool present E_BITFIELD;
const char *product;
Eldbus_Proxy *proxy;
int * mib;
};
struct _Batman_Config
{
Instance *inst;
Evas_Object *alert_check;
Evas_Object *alert_desktop;
Evas_Object *alert_time;
Evas_Object *alert_percent;
Evas_Object *alert_timeout;
Evas_Object *general_page;
Evas_Object *alert_page;
Evas_Object *power_page;
};
EINTERN Eina_List *_batman_battery_find(const char *udi);
EINTERN Eina_List *_batman_ac_adapter_find(const char *udi);
EINTERN void _batman_update(Instance *inst, int full, int time_left, Eina_Bool have_battery, Eina_Bool have_power);
EINTERN void _batman_device_update(Instance *inst);
/* in batman_fallback.c */
EINTERN int _batman_fallback_start(Instance *inst);
EINTERN void _batman_fallback_stop(void);
/* end batman_fallback.c */
#if defined(HAVE_EEZE)
/* in batman_udev.c */
EINTERN int _batman_udev_start(Instance *inst);
EINTERN void _batman_udev_stop(Instance *inst);
/* end batman_udev.c */
#elif !defined(__OpenBSD__) && !defined(__DragonFly__) && !defined(__FreeBSD__) && !defined(__NetBSD__)
/* in batman_upower.c */
EINTERN int _batman_upower_start(Instance *inst);
EINTERN void _batman_upower_stop(void);
/* end batman_upower.c */
#else
/* in batman_sysctl.c */
EINTERN int _batman_sysctl_start(Instance *inst);
EINTERN void _batman_sysctl_stop(Instance *inst);
/* end batman_sysctl.c */
#endif
EINTERN Evas_Object *batman_configure(Instance *inst);
EINTERN void _batman_config_updated(Instance *inst);
#endif

611
src/modules/sysinfo/batman/batman_config.c
View File

@ -1,611 +0,0 @@
#include "batman.h"
static void
_config_close(void *data, Evas *e EINA_UNUSED, Evas_Object *obj EINA_UNUSED, void *event_info EINA_UNUSED)
{
Batman_Config *bc = data;
Instance *inst = bc->inst;
E_FREE_FUNC(inst->cfg->batman.configure, evas_object_del);
E_FREE(bc);
e_config_save_queue();
}
static void
_config_show_general(void *data, Evas_Object *obj EINA_UNUSED, void *event_info EINA_UNUSED)
{
Batman_Config *bc = data;
evas_object_hide(bc->power_page);
evas_object_hide(bc->alert_page);
evas_object_show(bc->general_page);
}
static void
_config_show_alert(void *data, Evas_Object *obj EINA_UNUSED, void *event_info EINA_UNUSED)
{
Batman_Config *bc = data;
evas_object_hide(bc->general_page);
evas_object_hide(bc->power_page);
evas_object_show(bc->alert_page);
}
static void
_config_show_power(void *data, Evas_Object *obj EINA_UNUSED, void *event_info EINA_UNUSED)
{
Batman_Config *bc = data;
evas_object_hide(bc->general_page);
evas_object_hide(bc->alert_page);
evas_object_show(bc->power_page);
}
static void
_update_suspend_percent(void *data, Evas_Object *obj, void *event_info EINA_UNUSED)
{
Batman_Config *bc = data;
Instance *inst = bc->inst;
int value = elm_slider_value_get(obj);
inst->cfg->batman.suspend_below = value;
e_config_save_queue();
_batman_config_updated(inst);
}
static void
_update_alert_time(void *data, Evas_Object *obj EINA_UNUSED, void *event_info EINA_UNUSED)
{
Batman_Config *bc = data;
Instance *inst = bc->inst;
int value = elm_slider_value_get(bc->alert_time);
inst->cfg->batman.alert = value;
e_config_save_queue();
_batman_config_updated(inst);
}
static void
_update_alert_percent(void *data, Evas_Object *obj EINA_UNUSED, void *event_info EINA_UNUSED)
{
Batman_Config *bc = data;
Instance *inst = bc->inst;
int value = elm_slider_value_get(bc->alert_percent);
inst->cfg->batman.alert_p = value;
e_config_save_queue();
_batman_config_updated(inst);
}
static void
_update_alert_timeout(void *data, Evas_Object *obj EINA_UNUSED, void *event_info EINA_UNUSED)
{
Batman_Config *bc = data;
Instance *inst = bc->inst;
int value = elm_slider_value_get(bc->alert_timeout);
inst->cfg->batman.alert_timeout = value;
e_config_save_queue();
_batman_config_updated(inst);
}
static void
_check_desktop_changed(void *data, Evas_Object *obj EINA_UNUSED, void *event_info EINA_UNUSED)
{
Batman_Config *bc = data;
Instance *inst = bc->inst;
inst->cfg->batman.desktop_notifications = elm_check_state_get(bc->alert_desktop);
e_config_save_queue();
_batman_config_updated(inst);
}
static void
_check_changed(void *data, Evas_Object *obj EINA_UNUSED, void *event_info EINA_UNUSED)
{
Batman_Config *bc = data;
Instance *inst = bc->inst;
if (!elm_check_state_get(bc->alert_check))
{
elm_object_disabled_set(bc->alert_time, EINA_TRUE);
elm_object_disabled_set(bc->alert_percent, EINA_TRUE);
elm_object_disabled_set(bc->alert_desktop, EINA_TRUE);
elm_object_disabled_set(bc->alert_timeout, EINA_TRUE);
elm_slider_value_set(bc->alert_time, 0);
elm_slider_value_set(bc->alert_percent, 0);
_update_alert_time(bc, NULL, NULL);
_update_alert_percent(bc, NULL, NULL);
}
else
{
elm_object_disabled_set(bc->alert_time, EINA_FALSE);
elm_object_disabled_set(bc->alert_percent, EINA_FALSE);
elm_object_disabled_set(bc->alert_desktop, EINA_FALSE);
elm_object_disabled_set(bc->alert_timeout, EINA_FALSE);
}
e_config_save_queue();
_batman_config_updated(inst);
}
static void
_suspend_changed(void *data, Evas_Object *obj, void *event_info EINA_UNUSED)
{
Batman_Config *bc = data;
Instance *inst = bc->inst;
int value = elm_radio_value_get(obj);
switch (value)
{
case 0:
inst->cfg->batman.suspend_method = SUSPEND;
break;
case 1:
inst->cfg->batman.suspend_method = HIBERNATE;
break;
case 2:
inst->cfg->batman.suspend_method = SHUTDOWN;
break;
default:
inst->cfg->batman.suspend_method = SUSPEND;
}
e_config_save_queue();
_batman_config_updated(inst);
}
static void
_poll_changed(void *data, Evas_Object *obj, void *event_info EINA_UNUSED)
{
Batman_Config *bc = data;
Instance *inst = bc->inst;
int value = elm_radio_value_get(obj);
switch (value)
{
case 0:
inst->cfg->batman.poll_interval = 4;
break;
case 1:
inst->cfg->batman.poll_interval = 8;
break;
case 2:
inst->cfg->batman.poll_interval = 32;
break;
case 3:
inst->cfg->batman.poll_interval = 64;
break;
case 4:
inst->cfg->batman.poll_interval = 256;
break;
default:
inst->cfg->batman.poll_interval = 32;
}
e_config_save_queue();
_batman_config_updated(inst);
}
static void
_power_management_cb(void *data, Evas_Object *obj EINA_UNUSED, void *event_data EINA_UNUSED)
{
Evas_Object *popup = data;
evas_object_del(popup);
e_configure_registry_call("advanced/powermanagement", NULL, NULL);
}
static void
_icon_theme_file_set(Evas_Object *img, const char *icon)
{
const char *path = NULL, *k = NULL;
char buf[4096];
int len = 0;
if (!icon)
path = NULL;
else if (strncmp(icon, "/", 1) && !ecore_file_exists(icon))
{
path = efreet_icon_path_find(e_config->icon_theme, icon, 48);
if (!path)
{
if (e_util_strcmp(e_config->icon_theme, "hicolor"))
path = efreet_icon_path_find("hicolor", icon, 48);
}
}
else if (ecore_file_exists(icon))
{
path = icon;
}
if (!path && icon)
{
snprintf(buf, sizeof(buf), "e/icons/%s", icon);
if (eina_list_count(e_theme_collection_items_find("base/theme/icons", buf)))
{
path = e_theme_edje_file_get("base/theme/icons", buf);
k = buf;
}
else
{
path = e_theme_edje_file_get("base/theme/icons", "e/icons/unknown");
k = "e/icons/unknown";
}
}
else if (!path && !icon)
{
path = e_theme_edje_file_get("base/theme/icons", "e/icons/unknown");
k = "e/icons/unknown";
}
if (path && icon)
{
len = strlen(icon);
if ((len > 4) && (!strcasecmp(icon + len - 4, ".edj")))
k = "icon";
}
elm_image_file_set(img, path, k);
}
Evas_Object *
batman_configure(Instance *inst)
{
Evas_Object *popup, *tb, *list, *frame, *box, *o, *group, *groupy, *lbl;
Evas_Object *slider, *check, *but, *img;
Elm_Object_Item *it;
Eina_Bool show_alert;
E_Zone *zone = e_zone_current_get();
Batman_Config *bc = E_NEW(Batman_Config, 1);
bc->inst = inst;
if (inst->cfg->batman.alert > 0 || inst->cfg->batman.alert_p > 0)
show_alert = EINA_TRUE;
else
show_alert = EINA_FALSE;
popup = elm_popup_add(e_comp->elm);
E_EXPAND(popup);
elm_popup_allow_events_set(popup, 1);
elm_popup_scrollable_set(popup, 1);
tb = elm_table_add(popup);
E_EXPAND(tb);
evas_object_show(tb);
elm_object_content_set(popup, tb);
lbl = elm_label_add(tb);
evas_object_size_hint_weight_set(lbl, EVAS_HINT_EXPAND, 0.0);
evas_object_size_hint_align_set(lbl, EVAS_HINT_FILL, EVAS_HINT_FILL);
elm_object_style_set(lbl, "marker");
elm_object_text_set(lbl, _("Batman Configuration"));
elm_table_pack(tb, lbl, 0, 0, 2, 1);
evas_object_show(lbl);
list = elm_list_add(tb);
E_ALIGN(list, 0, EVAS_HINT_FILL);
E_WEIGHT(list, 0, EVAS_HINT_EXPAND);
elm_table_pack(tb, list, 0, 1, 1, 1);
elm_list_select_mode_set(list, ELM_OBJECT_SELECT_MODE_ALWAYS);
elm_scroller_content_min_limit(list, 1, 1);
it = elm_list_item_append(list, _("General"), NULL, NULL,
_config_show_general, bc);
elm_list_item_selected_set(it, 1);
it = elm_list_item_append(list, _("Alert"), NULL, NULL,
_config_show_alert, bc);
it = elm_list_item_append(list, _("Power"), NULL, NULL,
_config_show_power, bc);
elm_list_go(list);
evas_object_show(list);
frame = elm_frame_add(tb);
elm_object_text_set(frame, _("General"));
E_EXPAND(frame);
E_FILL(frame);
elm_table_pack(tb, frame, 1, 1, 1, 1);
evas_object_show(frame);
bc->general_page = frame;
box = elm_box_add(frame);
elm_box_horizontal_set(box, EINA_FALSE);
E_EXPAND(box);
evas_object_show(box);
lbl = elm_label_add(box);
elm_object_text_set(lbl, _("Update Poll Interval:"));
E_ALIGN(lbl, 0.0, 0.0);
E_WEIGHT(lbl, EVAS_HINT_EXPAND, 0);
elm_box_pack_end(box, lbl);
evas_object_show(lbl);
o = elm_radio_add(box);
elm_radio_state_value_set(o, 0);
E_ALIGN(o, 0.0, 0.0);
E_WEIGHT(o, EVAS_HINT_EXPAND, 0);
elm_object_text_set(o, _("Fast (4 ticks)"));
elm_box_pack_end(box, o);
evas_object_smart_callback_add(o, "changed", _poll_changed, bc);
evas_object_show(o);
group = o;
o = elm_radio_add(box);
elm_radio_state_value_set(o, 1);
elm_radio_group_add(o, group);
E_ALIGN(o, 0.0, 0.0);
E_WEIGHT(o, EVAS_HINT_EXPAND, 0);
elm_object_text_set(o, _("Medium (8 ticks)"));
elm_box_pack_end(box, o);
evas_object_smart_callback_add(o, "changed", _poll_changed, bc);
evas_object_show(o);
o = elm_radio_add(box);
elm_radio_state_value_set(o, 2);
elm_radio_group_add(o, group);
E_ALIGN(o, 0.0, 0.0);
E_WEIGHT(o, EVAS_HINT_EXPAND, 0);
elm_object_text_set(o, _("Normal (32 ticks)"));
elm_box_pack_end(box, o);
evas_object_smart_callback_add(o, "changed", _poll_changed, bc);
evas_object_show(o);
o = elm_radio_add(box);
elm_radio_state_value_set(o, 3);
elm_radio_group_add(o, group);
E_ALIGN(o, 0.0, 0.0);
E_WEIGHT(o, EVAS_HINT_EXPAND, 0);
elm_object_text_set(o, _("Slow (64 ticks)"));
elm_box_pack_end(box, o);
evas_object_smart_callback_add(o, "changed", _poll_changed, bc);
evas_object_show(o);
o = elm_radio_add(box);
elm_radio_state_value_set(o, 4);
elm_radio_group_add(o, group);
E_ALIGN(o, 0.0, 0.0);
E_WEIGHT(o, EVAS_HINT_EXPAND, 0);
elm_object_text_set(o, _("Very Slow (256 ticks)"));
elm_box_pack_end(box, o);
evas_object_smart_callback_add(o, "changed", _poll_changed, bc);
evas_object_show(o);
switch (inst->cfg->batman.poll_interval)
{
case 4:
elm_radio_value_set(group, 0);
break;
case 8:
elm_radio_value_set(group, 1);
break;
case 32:
elm_radio_value_set(group, 2);
break;
case 64:
elm_radio_value_set(group, 3);
break;
case 256:
elm_radio_value_set(group, 4);
break;
default:
elm_radio_value_set(group, 2);
}
elm_object_content_set(frame, box);
frame = elm_frame_add(tb);
elm_object_text_set(frame, _("Alert"));
E_EXPAND(frame);
E_FILL(frame);
elm_table_pack(tb, frame, 1, 1, 1, 1);
evas_object_show(frame);
bc->alert_page = frame;
box = elm_box_add(frame);
elm_box_horizontal_set(box, EINA_FALSE);
E_EXPAND(box);
evas_object_show(box);
check = elm_check_add(box);
elm_object_text_set(check, _("Show low battery alert"));
elm_check_state_set(check, show_alert);
E_ALIGN(check, 0.0, 0.0);
E_WEIGHT(check, EVAS_HINT_EXPAND, 0);
evas_object_smart_callback_add(check, "changed", _check_changed, bc);
elm_box_pack_end(box, check);
evas_object_show(check);
bc->alert_check = check;
check = elm_check_add(box);
elm_object_text_set(check, _("Show alert as a desktop notification"));
elm_check_state_set(check, inst->cfg->batman.desktop_notifications);
E_ALIGN(check, 0.0, 0.0);
E_WEIGHT(check, EVAS_HINT_EXPAND, 0);
evas_object_smart_callback_add(check, "changed", _check_desktop_changed, bc);
elm_object_disabled_set(check, !show_alert);
elm_box_pack_end(box, check);
evas_object_show(check);
bc->alert_desktop = check;
lbl = elm_label_add(box);
elm_object_text_set(lbl, _("Alert when time left is at:"));
E_ALIGN(lbl, 0.0, 0.0);
E_WEIGHT(lbl, EVAS_HINT_EXPAND, 0);
elm_box_pack_end(box, lbl);
evas_object_show(lbl);
slider = elm_slider_add(box);
elm_slider_unit_format_set(slider, "%1.0f min");
elm_slider_indicator_format_set(slider, "%1.0f min");
elm_slider_min_max_set(slider, 0, 60);
elm_slider_value_set(slider, inst->cfg->batman.alert);
elm_slider_step_set(slider, 0.01);
elm_slider_span_size_set(slider, 100);
E_ALIGN(slider, 0.0, 0.0);
E_WEIGHT(slider, EVAS_HINT_EXPAND, 0);
evas_object_smart_callback_add(slider, "delay,changed", _update_alert_time, bc);
elm_object_disabled_set(slider, !show_alert);
elm_box_pack_end(box, slider);
evas_object_show(slider);
bc->alert_time = slider;
lbl = elm_label_add(box);
elm_object_text_set(lbl, _("Alert when percent left is at:"));
E_ALIGN(lbl, 0.0, 0.0);
E_WEIGHT(lbl, EVAS_HINT_EXPAND, 0);
elm_box_pack_end(box, lbl);
evas_object_show(lbl);
slider = elm_slider_add(box);
elm_slider_unit_format_set(slider, "%1.0f %%");
elm_slider_indicator_format_set(slider, "%1.0f %%");
elm_slider_min_max_set(slider, 0, 100);
elm_slider_value_set(slider, inst->cfg->batman.alert_p);
elm_slider_step_set(slider, 0.01);
elm_slider_span_size_set(slider, 100);
E_ALIGN(slider, 0.0, 0.0);
E_WEIGHT(slider, EVAS_HINT_EXPAND, 0);
evas_object_smart_callback_add(slider, "delay,changed", _update_alert_percent, bc);
elm_object_disabled_set(slider, !show_alert);
elm_box_pack_end(box, slider);
evas_object_show(slider);
bc->alert_percent = slider;
lbl = elm_label_add(box);
elm_object_text_set(lbl, _("Alert timeout:"));
E_ALIGN(lbl, 0.0, 0.0);
E_WEIGHT(lbl, EVAS_HINT_EXPAND, 0);
elm_box_pack_end(box, lbl);
evas_object_show(lbl);
slider = elm_slider_add(box);
elm_slider_unit_format_set(slider, "%1.0f s");
elm_slider_indicator_format_set(slider, "%1.0f s");
elm_slider_min_max_set(slider, 1, 300);
elm_slider_value_set(slider, inst->cfg->batman.alert_timeout);
elm_slider_step_set(slider, 0.01);
elm_slider_span_size_set(slider, 100);
E_ALIGN(slider, 0.0, 0.0);
E_WEIGHT(slider, EVAS_HINT_EXPAND, 0);
evas_object_smart_callback_add(slider, "delay,changed", _update_alert_timeout, bc);
elm_box_pack_end(box, slider);
evas_object_show(slider);
bc->alert_timeout = slider;
elm_object_content_set(frame, box);
frame = elm_frame_add(tb);
elm_object_text_set(frame, _("Power Management"));
E_EXPAND(frame);
E_FILL(frame);
elm_table_pack(tb, frame, 1, 1, 1, 1);
evas_object_show(frame);
bc->power_page = frame;
box = elm_box_add(frame);
elm_box_horizontal_set(box, EINA_FALSE);
E_EXPAND(box);
evas_object_show(box);
o = elm_radio_add(box);
elm_radio_state_value_set(o, 0);
E_ALIGN(o, 0.0, 0.0);
E_WEIGHT(o, EVAS_HINT_EXPAND, 0);
elm_object_text_set(o, _("Suspend when below:"));
elm_box_pack_end(box, o);
evas_object_smart_callback_add(o, "changed", _suspend_changed, bc);
evas_object_show(o);
groupy = o;
o = elm_radio_add(box);
elm_radio_state_value_set(o, 1);
elm_radio_group_add(o, groupy);
E_ALIGN(o, 0.0, 0.0);
E_WEIGHT(o, EVAS_HINT_EXPAND, 0);
elm_object_text_set(o, _("Hibernate when below:"));
elm_box_pack_end(box, o);
evas_object_smart_callback_add(o, "changed", _suspend_changed, bc);
evas_object_show(o);
o = elm_radio_add(box);
elm_radio_state_value_set(o, 2);
elm_radio_group_add(o, groupy);
E_ALIGN(o, 0.0, 0.0);
E_WEIGHT(o, EVAS_HINT_EXPAND, 0);
elm_object_text_set(o, _("Shutdown when below:"));
elm_box_pack_end(box, o);
evas_object_smart_callback_add(o, "changed", _suspend_changed, bc);
evas_object_show(o);
switch (inst->cfg->batman.suspend_method)
{
case SUSPEND:
elm_radio_value_set(groupy, 0);
break;
case HIBERNATE:
elm_radio_value_set(groupy, 1);
break;
case SHUTDOWN:
elm_radio_value_set(groupy, 2);
break;
default:
elm_radio_value_set(groupy, 0);
}
slider = elm_slider_add(box);
elm_slider_unit_format_set(slider, "%1.0f %%");
elm_slider_indicator_format_set(slider, "%1.0f %%");
elm_slider_min_max_set(slider, 0, 100);
elm_slider_value_set(slider, inst->cfg->batman.suspend_below);
elm_slider_step_set(slider, 0.05);
elm_slider_span_size_set(slider, 100);
E_ALIGN(slider, 0.0, 0.0);
E_WEIGHT(slider, EVAS_HINT_EXPAND, 0);
evas_object_smart_callback_add(slider, "delay,changed", _update_suspend_percent, bc);
elm_box_pack_end(box, slider);
evas_object_show(slider);
img = elm_icon_add(box);
evas_object_size_hint_aspect_set(img, EVAS_ASPECT_CONTROL_VERTICAL, 1, 1);
_icon_theme_file_set(img, "preferences-system-power-management");
evas_object_show(img);
but = elm_button_add(box);
elm_object_part_content_set(but, "icon", img);
elm_object_text_set(but, _("Power Management Timing"));
E_ALIGN(but, 0.0, 0.0);
E_WEIGHT(but, EVAS_HINT_EXPAND, 0);
E_FILL(but);
evas_object_data_set(but, "popup", popup);
evas_object_smart_callback_add(but, "clicked", _power_management_cb, popup);
elm_box_pack_end(box, but);
evas_object_show(but);
elm_object_content_set(frame, box);
_config_show_general(bc, NULL, NULL);
popup = e_comp_object_util_add(popup, E_COMP_OBJECT_TYPE_NONE);
evas_object_layer_set(popup, E_LAYER_POPUP);
evas_object_resize(popup, zone->w / 4, zone->h / 3);
e_comp_object_util_center_on_zone(popup, zone);
evas_object_show(popup);
e_comp_object_util_autoclose(popup, NULL, e_comp_object_util_autoclose_on_escape, NULL);
evas_object_event_callback_add(popup, EVAS_CALLBACK_DEL, _config_close, bc);
return inst->cfg->batman.configure = popup;
}

1291
src/modules/sysinfo/batman/batman_fallback.c
View File

File diff suppressed because it is too large Load Diff

398
src/modules/sysinfo/batman/batman_sysctl.c
View File

@ -1,398 +0,0 @@
#include "batman.h"
#include <sys/types.h>
#include <sys/sysctl.h>
#if defined(__FreeBSD__) || defined(__DragonFly__)
# include <dev/acpica/acpiio.h>
# include <sys/ioctl.h>
#endif
#if defined(__OpenBSD__) || defined(__NetBSD__)
# include <sys/param.h>
# include <sys/sensors.h>
#endif
EINTERN extern Eina_List *batman_device_batteries;
EINTERN extern Eina_List *batman_device_ac_adapters;
#if defined(__OpenBSD__) || defined(__NetBSD__) || defined(__FreeBSD__) || defined(__DragonFly__)
static Eina_Bool _batman_sysctl_battery_update_poll(void *data);
static int _batman_sysctl_battery_update(Instance *inst);
#endif
int
_batman_sysctl_start(Instance *inst)
{
#if defined(__OpenBSD__) || defined(__NetBSD__)
int mib[] = {CTL_HW, HW_SENSORS, 0, 0, 0};
int devn, i = 0;
struct sensordev snsrdev;
size_t sdlen = sizeof(struct sensordev);
char name[256];
if (eina_list_count(batman_device_batteries) != 0)
{
_batman_sysctl_battery_update(inst);
return 1;
}
for (devn = 0;; devn++)
{
mib[2] = devn;
if (sysctl(mib, 3, &snsrdev, &sdlen, NULL, 0) == -1)
{
if (errno == ENXIO)
continue;
if (errno == ENOENT)
break;
}
snprintf(name, sizeof(name), "acpibat%d", i);
if (!strcmp(name, snsrdev.xname))
{
Battery *bat = E_NEW(Battery, 1);
if (!bat)
return 0;
bat->inst = inst;
bat->udi = eina_stringshare_add(name),
bat->mib = malloc(sizeof(int) * 5);
if (!bat->mib) return 0;
bat->mib[0] = mib[0];
bat->mib[1] = mib[1];
bat->mib[2] = mib[2];
bat->technology = eina_stringshare_add("Unknown");
bat->model = eina_stringshare_add("Unknown");
bat->last_update = ecore_time_get();
bat->vendor = eina_stringshare_add("Unknown");
bat->poll = ecore_poller_add(ECORE_POLLER_CORE,
inst->cfg->batman.poll_interval,
_batman_sysctl_battery_update_poll, inst);
batman_device_batteries = eina_list_append(batman_device_batteries, bat);
++i;
}
if (!strcmp("acpiac0", snsrdev.xname))
{
Ac_Adapter *ac = E_NEW(Ac_Adapter, 1);
if (!ac) return 0;
ac->inst = inst;
ac->udi = eina_stringshare_add("acpiac0");
ac->mib = malloc(sizeof(int) * 5);
if (!ac->mib) return 0;
ac->mib[0] = mib[0];
ac->mib[1] = mib[1];
ac->mib[2] = mib[2];
batman_device_ac_adapters = eina_list_append(batman_device_ac_adapters, ac);
}
}
#elif defined(__FreeBSD__) || defined(__DragonFly__)
size_t len;
int i, count, fd;
union acpi_battery_ioctl_arg battio;
if (eina_list_count(batman_device_batteries) != 0)
{
_batman_sysctl_battery_update(inst);
return 1;
}
if ((fd = open("/dev/acpi", O_RDONLY)) == -1)
return 0;
if (ioctl(fd, ACPIIO_BATT_GET_UNITS, &count) == -1)
{
close(fd);
return 0;
}
for (i = 0; i < count; i++)
{
battio.unit = i;
if (ioctl(fd, ACPIIO_BATT_GET_BIF, &battio) != -1)
{
Battery *bat = E_NEW(Battery, 1);
if (!bat) return 0;
bat->inst = inst;
bat->last_update = ecore_time_get();
bat->last_full_charge = battio.bif.lfcap;
bat->model = eina_stringshare_add(battio.bif.model);
bat->vendor = eina_stringshare_add(battio.bif.oeminfo);
bat->technology = eina_stringshare_add(battio.bif.type);
bat->poll = ecore_poller_add(ECORE_POLLER_CORE,
inst->cfg->batman.poll_interval,
_batman_sysctl_battery_update_poll, inst);
batman_device_batteries = eina_list_append(batman_device_batteries, bat);
}
}
close(fd);
if ((sysctlbyname("hw.acpi.acline", NULL, &len, NULL, 0)) != -1)
{
Ac_Adapter *ac = E_NEW(Ac_Adapter, 1);
if (!ac)
return 0;
ac->inst = inst;
ac->mib = malloc(sizeof(int) * 3);
if (!ac->mib) return 0;
len = sizeof(ac->mib);
sysctlnametomib("hw.acpi.acline", ac->mib, &len);
ac->udi = eina_stringshare_add("hw.acpi.acline");
batman_device_ac_adapters = eina_list_append(batman_device_ac_adapters, ac);
}
#endif
_batman_sysctl_battery_update(inst);
return 1;
}
void
_batman_sysctl_stop(Instance *inst)
{
Instance *child;
Eina_List *l;
Battery *bat;
Ac_Adapter *ac;
int bat_num = 0;
/* This is a dummy battery we return here. */
if (inst->cfg->batman.have_battery != 1)
{
return;
}
/* If this is NOT the last batman gadget then we return before
* freeing everything. This is NOT optimal but is allows us to have
* many gadgets and share the same data between multiple batman
* gadget instances. The instance will be deleted.
*/
EINA_LIST_FOREACH(sysinfo_instances, l, child)
{
if (inst->cfg->esm == E_SYSINFO_MODULE_BATMAN ||
inst->cfg->esm == E_SYSINFO_MODULE_SYSINFO)
{
if (child != inst)
{
bat_num++;
}
}
}
/* This is not the last batman gadget. */
if (bat_num > 0) return;
/* We have no batman or sysinfo gadgets remaining. We can safely
remove these batteries and adapters. */
EINA_LIST_FREE(batman_device_ac_adapters, ac)
{
E_FREE_FUNC(ac->udi, eina_stringshare_del);
E_FREE(ac->mib);
E_FREE(ac);
}
EINA_LIST_FREE(batman_device_batteries, bat)
{
E_FREE_FUNC(bat->udi, eina_stringshare_del);
E_FREE_FUNC(bat->technology, eina_stringshare_del);
E_FREE_FUNC(bat->model, eina_stringshare_del);
E_FREE_FUNC(bat->vendor, eina_stringshare_del);
E_FREE_FUNC(bat->poll, ecore_poller_del);
E_FREE(bat->mib);
E_FREE(bat);
}
}
#if defined(__OpenBSD__) || defined(__NetBSD__) || defined(__FreeBSD__) || defined(__DragonFly__)
static Eina_Bool
_batman_sysctl_battery_update_poll(void *data EINA_UNUSED)
{
Eina_List *l;
Instance *inst;
/* We need to ensure we update both batman and sysinfo instances. */
EINA_LIST_FOREACH(sysinfo_instances, l, inst)
{
if (inst->cfg->esm == E_SYSINFO_MODULE_BATMAN ||
inst->cfg->esm == E_SYSINFO_MODULE_SYSINFO)
_batman_sysctl_battery_update(inst);
}
return EINA_TRUE;
}
#endif
static int
_batman_sysctl_battery_update(Instance *inst)
{
Battery *bat;
Ac_Adapter *ac;
Eina_List *l;
#if defined(__OpenBSD__) || defined(__NetBSD__)
double _time, charge;
struct sensor s;
size_t slen = sizeof(struct sensor);
#elif defined(__FreeBSD__) || defined(__DragonFly__)
union acpi_battery_ioctl_arg battio;
size_t len;
int value, fd, i = 0;
#endif
EINA_LIST_FOREACH(batman_device_batteries, l, bat)
{
/* update the poller interval */
ecore_poller_poller_interval_set(bat->poll,
inst->cfg->batman.poll_interval);
#if defined(__OpenBSD__) || defined(__NetBSD__)
/* last full capacity */
bat->mib[3] = 7;
bat->mib[4] = 0;
if (sysctl(bat->mib, 5, &s, &slen, NULL, 0) != -1)
{
bat->last_full_charge = (double)s.value;
}
/* remaining capacity */
bat->mib[3] = 7;
bat->mib[4] = 3;
if (sysctl(bat->mib, 5, &s, &slen, NULL, 0) != -1)
{
charge = (double)s.value;
}
/* This is a workaround because there's an ACPI bug */
if ((EINA_FLT_EQ(charge, 0.0)) || (EINA_FLT_EQ(bat->last_full_charge, 0.0)))
{
/* last full capacity */
bat->mib[3] = 8;
bat->mib[4] = 0;
if (sysctl(bat->mib, 5, &s, &slen, NULL, 0) != -1)
{
bat->last_full_charge = (double)s.value;
if (bat->last_full_charge < 0) return EINA_TRUE;
}
/* remaining capacity */
bat->mib[3] = 8;
bat->mib[4] = 3;
if (sysctl(bat->mib, 5, &s, &slen, NULL, 0) != -1)
{
charge = (double)s.value;
}
}
bat->got_prop = 1;
_time = ecore_time_get();
if ((bat->got_prop) && (!EINA_FLT_EQ(charge, bat->current_charge)))
bat->charge_rate = ((charge - bat->current_charge) / (_time - bat->last_update));
bat->last_update = _time;
bat->current_charge = charge;
bat->percent = 100 * (bat->current_charge / bat->last_full_charge);
if (bat->current_charge >= bat->last_full_charge)
bat->percent = 100;
if (bat->got_prop)
{
if (bat->charge_rate > 0)
{
if (inst->cfg->batman.fuzzy && (++inst->cfg->batman.fuzzcount <= 10) && (bat->time_full > 0))
bat->time_full = (((bat->last_full_charge - bat->current_charge) / bat->charge_rate) + bat->time_full) / 2;
else
bat->time_full = (bat->last_full_charge - bat->current_charge) / bat->charge_rate;
bat->time_left = -1;
}
else
{
if (inst->cfg->batman.fuzzy && (inst->cfg->batman.fuzzcount <= 10) && (bat->time_left > 0))
bat->time_left = (((0 - bat->current_charge) / bat->charge_rate) + bat->time_left) / 2;
else
bat->time_left = (0 - bat->current_charge) / bat->charge_rate;
bat->time_full = -1;
}
}
else
{
bat->time_full = -1;
bat->time_left = -1;
}
/* battery state 1: discharge, 2: charge */
bat->mib[3] = 10;
bat->mib[4] = 0;
if (sysctl(bat->mib, 5, &s, &slen, NULL, 0) == -1)
{
if (s.value == 2)
bat->charging = 1;
else
bat->charging = 0;
}
_batman_device_update(bat->inst);
#elif defined(__FreeBSD__) || defined(__DragonFly__)
if ((fd = open("/dev/acpi", O_RDONLY)) != -1)
{
battio.unit = i;
if (ioctl(fd, ACPIIO_BATT_GET_BATTINFO, &battio) != -1)
{
bat->got_prop = 1;
bat->percent = battio.battinfo.cap;
if (battio.battinfo.state & ACPI_BATT_STAT_CHARGING)
bat->charging = EINA_TRUE;
else
bat->charging = EINA_FALSE;
bat->time_left = battio.battinfo.min * 60;
if (bat->charge_rate > 0)
{
bat->time_full = (bat->last_full_charge - bat->current_charge) / bat->charge_rate;
}
}
else
{
bat->time_full = bat->time_left = -1;
}
close(fd);
}
_batman_device_update(inst);
i++;
#endif
}
EINA_LIST_FOREACH(batman_device_ac_adapters, l, ac)
{
#if defined(__OpenBSD__) || defined(__NetBSD__)
/* AC State */
ac->mib[3] = 9;
ac->mib[4] = 0;
if (sysctl(ac->mib, 5, &s, &slen, NULL, 0) != -1)
{
if (s.value)
ac->present = 1;
else
ac->present = 0;
}
#elif defined(__FreeBSD__) || defined(__DragonFly__)
len = sizeof(value);
if ((sysctl(ac->mib, 3, &value, &len, NULL, 0)) != -1)
{
ac->present = value;
}
#endif
}
return EINA_TRUE;
}

393
src/modules/sysinfo/batman/batman_udev.c
View File

@ -1,393 +0,0 @@
#include "batman.h"
static void _batman_udev_event_battery(const char *syspath, Eeze_Udev_Event event, void *data, Eeze_Udev_Watch *watch);
static void _batman_udev_event_ac(const char *syspath, Eeze_Udev_Event event, void *data, Eeze_Udev_Watch *watch);
static void _batman_udev_battery_add(const char *syspath, Instance *inst);
static void _batman_udev_ac_add(const char *syspath, Instance *inst);
static void _batman_udev_battery_del(const char *syspath, Instance *inst);
static void _batman_udev_ac_del(const char *syspath, Instance *inst);
static Eina_Bool _batman_udev_battery_update_poll(void *data);
static void _batman_udev_battery_update(const char *syspath, Battery *bat, Instance *inst);
static void _batman_udev_ac_update(const char *syspath, Ac_Adapter *ac, Instance *inst);
EINTERN extern Eina_List *batman_device_batteries;
EINTERN extern Eina_List *batman_device_ac_adapters;
EINTERN extern double batman_init_time;
int
_batman_udev_start(Instance *inst)
{
Eina_List *devices;
const char *dev;
devices = eeze_udev_find_by_type(EEZE_UDEV_TYPE_POWER_BAT, NULL);
EINA_LIST_FREE(devices, dev)
_batman_udev_battery_add(dev, inst);
devices = eeze_udev_find_by_type(EEZE_UDEV_TYPE_POWER_AC, NULL);
EINA_LIST_FREE(devices, dev)
_batman_udev_ac_add(dev, inst);
if (!inst->cfg->batman.batwatch)
inst->cfg->batman.batwatch = eeze_udev_watch_add(EEZE_UDEV_TYPE_POWER_BAT, EEZE_UDEV_EVENT_NONE, _batman_udev_event_battery, inst);
if (!inst->cfg->batman.acwatch)
inst->cfg->batman.acwatch = eeze_udev_watch_add(EEZE_UDEV_TYPE_POWER_AC, EEZE_UDEV_EVENT_NONE, _batman_udev_event_ac, inst);
batman_init_time = ecore_time_get();
return 1;
}
void
_batman_udev_stop(Instance *inst)
{
Ac_Adapter *ac;
Battery *bat;
Eina_List *l;
Instance *child;
int bat_num = 0;
/* This is a dummy battery we return here. */
if (inst->cfg->batman.have_battery != 1)
{
return;
}
if (inst->cfg->batman.batwatch)
E_FREE_FUNC(inst->cfg->batman.batwatch, eeze_udev_watch_del);
if (inst->cfg->batman.acwatch)
E_FREE_FUNC(inst->cfg->batman.acwatch, eeze_udev_watch_del);
/* If this is NOT the last batman gadget then we return before
* freeing everything. This is NOT optimal but is allows us to have
* many gadgets and share the same data between multiple batman
* gadget instances. The instance will be deleted.
*/
EINA_LIST_FOREACH(sysinfo_instances, l, child)
{
if (inst->cfg->esm == E_SYSINFO_MODULE_BATMAN ||
inst->cfg->esm == E_SYSINFO_MODULE_SYSINFO)
{
if (child != inst)
{
bat_num++;
}
}
}
/* This is not the last batman gadget. */
if (bat_num > 0) return;
/* We have no batman or sysinfo gadgets remaining. We can safely
remove these batteries and adapters. */
EINA_LIST_FREE(batman_device_ac_adapters, ac)
{
E_FREE(ac);
}
EINA_LIST_FREE(batman_device_batteries, bat)
{
eina_stringshare_del(bat->udi);
eina_stringshare_del(bat->technology);
eina_stringshare_del(bat->model);
eina_stringshare_del(bat->vendor);
E_FREE_FUNC(bat->poll, ecore_poller_del);
E_FREE(bat);
}
}
static void
_batman_udev_event_battery(const char *syspath, Eeze_Udev_Event event, void *data, Eeze_Udev_Watch *watch EINA_UNUSED)
{
Instance *inst = data;
if ((event & EEZE_UDEV_EVENT_ADD) ||
(event & EEZE_UDEV_EVENT_ONLINE))
_batman_udev_battery_add(syspath, inst);
else if ((event & EEZE_UDEV_EVENT_REMOVE) ||
(event & EEZE_UDEV_EVENT_OFFLINE))
_batman_udev_battery_del(syspath, inst);
else /* must be change */
_batman_udev_battery_update(syspath, NULL, inst);
}
static void
_batman_udev_event_ac(const char *syspath, Eeze_Udev_Event event, void *data, Eeze_Udev_Watch *watch EINA_UNUSED)
{
Instance *inst = data;
if ((event & EEZE_UDEV_EVENT_ADD) ||
(event & EEZE_UDEV_EVENT_ONLINE))
_batman_udev_ac_add(syspath, inst);
else if ((event & EEZE_UDEV_EVENT_REMOVE) ||
(event & EEZE_UDEV_EVENT_OFFLINE))
_batman_udev_ac_del(syspath, inst);
else /* must be change */
_batman_udev_ac_update(syspath, NULL, inst);
}
static void
_batman_udev_battery_add(const char *syspath, Instance *inst)
{
Battery *bat;
Eina_List *batteries = _batman_battery_find(syspath), *l;
Eina_Bool exists = EINA_FALSE;
if (eina_list_count(batteries))
{
EINA_LIST_FOREACH(batteries, l, bat)
{
if (inst == bat->inst)
{
_batman_udev_battery_update(NULL, bat, inst);
exists = EINA_TRUE;
}
}
if (exists)
{
eina_stringshare_del(syspath);
eina_list_free(batteries);
return;
}
}
if (!(bat = E_NEW(Battery, 1)))
{
eina_stringshare_del(syspath);
return;
}
bat->inst = inst;
bat->last_update = ecore_time_get();
bat->udi = eina_stringshare_add(syspath);
bat->poll = ecore_poller_add(ECORE_POLLER_CORE,
bat->inst->cfg->batman.poll_interval,
_batman_udev_battery_update_poll, bat);
batman_device_batteries = eina_list_append(batman_device_batteries, bat);
_batman_udev_battery_update(syspath, bat, inst);
}
static void
_batman_udev_ac_add(const char *syspath, Instance *inst)
{
Ac_Adapter *ac;
Eina_List *adapters = _batman_ac_adapter_find(syspath), *l;
Eina_Bool exists = EINA_FALSE;
if (eina_list_count(adapters))
{
EINA_LIST_FOREACH(adapters, l, ac)
{
if (inst == ac->inst)
{
_batman_udev_ac_update(NULL, ac, inst);
exists = EINA_TRUE;
}
}
if (exists)
{
eina_stringshare_del(syspath);
eina_list_free(adapters);
return;
}
}
if (!(ac = E_NEW(Ac_Adapter, 1)))
{
eina_stringshare_del(syspath);
return;
}
ac->inst = inst;
ac->udi = eina_stringshare_add(syspath);
batman_device_ac_adapters = eina_list_append(batman_device_ac_adapters, ac);
_batman_udev_ac_update(syspath, ac, inst);
}
static void
_batman_udev_battery_del(const char *syspath, Instance *inst)
{
Battery *bat;
Eina_List *batteries = _batman_battery_find(syspath), *l;
if (!eina_list_count(batteries))
{
eina_stringshare_del(syspath);
return;
}
EINA_LIST_FOREACH(batman_device_batteries, l, bat)
{
if ((inst == bat->inst) && (eina_streq(bat->udi, syspath)))
{
batman_device_batteries = eina_list_remove_list(batman_device_batteries, l);
eina_stringshare_del(bat->udi);
eina_stringshare_del(bat->technology);
eina_stringshare_del(bat->model);
eina_stringshare_del(bat->vendor);
E_FREE_FUNC(bat->poll, ecore_poller_del);
E_FREE(bat);
}
}
eina_stringshare_del(syspath);
eina_list_free(batteries);
}
static void
_batman_udev_ac_del(const char *syspath, Instance *inst)
{
Ac_Adapter *ac;
Eina_List *adapters = _batman_ac_adapter_find(syspath), *l;
if (!eina_list_count(adapters))
{
eina_stringshare_del(syspath);
return;
}
EINA_LIST_FOREACH(batman_device_ac_adapters, l, ac)
{
if (inst == ac->inst)
{
batman_device_ac_adapters = eina_list_remove_list(batman_device_ac_adapters, l);
eina_stringshare_del(ac->udi);
E_FREE(ac);
}
}
eina_stringshare_del(syspath);
eina_list_free(adapters);
}
static Eina_Bool
_batman_udev_battery_update_poll(void *data)
{
Battery *bat = data;
_batman_udev_battery_update(NULL, bat, bat->inst);
return EINA_TRUE;
}
#define GET_NUM(TYPE, VALUE, PROP) \
do \
{ \
test = eeze_udev_syspath_get_property(TYPE->udi, #PROP); \
if (test) \
{ \
TYPE->VALUE = strtod(test, NULL); \
eina_stringshare_del(test); \
} \
} \
while (0)
#define GET_STR(TYPE, VALUE, PROP) TYPE->VALUE = eeze_udev_syspath_get_property(TYPE->udi, #PROP)
static void
_batman_udev_battery_update(const char *syspath, Battery *bat, Instance *inst)
{
const char *test;
double t, charge;
if (!bat)
{
_batman_udev_battery_add(syspath, inst);
return;
}
/* update the poller interval */
ecore_poller_poller_interval_set(bat->poll, bat->inst->cfg->batman.poll_interval);
GET_NUM(bat, present, POWER_SUPPLY_PRESENT);
if (!bat->got_prop) /* only need to get these once */
{
GET_STR(bat, technology, POWER_SUPPLY_TECHNOLOGY);
GET_STR(bat, model, POWER_SUPPLY_MODEL_NAME);
GET_STR(bat, vendor, POWER_SUPPLY_MANUFACTURER);
GET_NUM(bat, design_charge, POWER_SUPPLY_ENERGY_FULL_DESIGN);
if (eina_dbl_exact(bat->design_charge, 0))
GET_NUM(bat, design_charge, POWER_SUPPLY_CHARGE_FULL_DESIGN);
}
GET_NUM(bat, last_full_charge, POWER_SUPPLY_ENERGY_FULL);
if (eina_dbl_exact(bat->last_full_charge, 0))
GET_NUM(bat, last_full_charge, POWER_SUPPLY_CHARGE_FULL);
test = eeze_udev_syspath_get_property(bat->udi, "POWER_SUPPLY_ENERGY_NOW");
if (!test)
test = eeze_udev_syspath_get_property(bat->udi, "POWER_SUPPLY_CHARGE_NOW");
if (test)
{
double charge_rate = 0;
charge = strtod(test, NULL);
eina_stringshare_del(test);
t = ecore_time_get();
if ((bat->got_prop) && (!eina_dbl_exact(charge, bat->current_charge)) && (!eina_dbl_exact(bat->current_charge, 0)))
charge_rate = ((charge - bat->current_charge) / (t - bat->last_update));
if ((!eina_dbl_exact(charge_rate, 0)) || eina_dbl_exact(bat->last_update, 0) || eina_dbl_exact(bat->current_charge, 0))
{
bat->last_update = t;
bat->current_charge = charge;
bat->charge_rate = charge_rate;
}
bat->percent = 100 * (bat->current_charge / bat->last_full_charge);
if (bat->got_prop)
{
if (bat->charge_rate > 0)
{
if (bat->inst->cfg->batman.fuzzy && (++bat->inst->cfg->batman.fuzzcount <= 10) && (bat->time_full > 0))
bat->time_full = (((bat->last_full_charge - bat->current_charge) / bat->charge_rate) + bat->time_full) / 2;
else
bat->time_full = (bat->last_full_charge - bat->current_charge) / bat->charge_rate;
bat->time_left = -1;
}
else
{
if (bat->inst->cfg->batman.fuzzy && (bat->inst->cfg->batman.fuzzcount <= 10) && (bat->time_left > 0))
bat->time_left = (((0 - bat->current_charge) / bat->charge_rate) + bat->time_left) / 2;
else
bat->time_left = (0 - bat->current_charge) / bat->charge_rate;
bat->time_full = -1;
}
}
else
{
bat->time_full = -1;
bat->time_left = -1;
}
}
if (bat->inst->cfg->batman.fuzzcount > 10) bat->inst->cfg->batman.fuzzcount = 0;
test = eeze_udev_syspath_get_property(bat->udi, "POWER_SUPPLY_STATUS");
if (test)
{
if (!strcmp(test, "Charging"))
bat->charging = 1;
else if ((!strcmp(test, "Unknown")) && (bat->charge_rate > 0))
bat->charging = 1;
else if ((!strcmp(test, "Unknown")) && (bat->charge_rate <= 0) && (bat->last_full_charge <= 0))
{
_batman_udev_battery_del(syspath, inst);
eina_stringshare_del(test);
return;
}
else
bat->charging = 0;
eina_stringshare_del(test);
}
else
bat->charging = 0;
if (bat->got_prop)
_batman_device_update(bat->inst);
bat->got_prop = 1;
}
static void
_batman_udev_ac_update(const char *syspath, Ac_Adapter *ac, Instance *inst)
{
const char *test;
if (!ac)
{
_batman_udev_ac_add(syspath, inst);
return;
}
GET_NUM(ac, present, POWER_SUPPLY_ONLINE);
/* yes, it's really that simple. */
_batman_device_update(inst);
}

419
src/modules/sysinfo/batman/batman_upower.c
View File

@ -1,419 +0,0 @@
#include "batman.h"
#define BUS "org.freedesktop.UPower"
#define PATH "/org/freedesktop/UPower"
#define IFACE "org.freedesktop.UPower"
# define IFACE_DEVICE "org.freedesktop.UPower.Device"
# define IFACE_PROPERTIES "org.freedesktop.DBus.Properties"
EINTERN extern Eina_List *batman_device_batteries;
EINTERN extern Eina_List *batman_device_ac_adapters;
EINTERN extern double batman_init_time;
static Eldbus_Connection *conn;
static Eldbus_Proxy *upower_proxy;
static Eldbus_Proxy *upower_proxy_bat;
static Eldbus_Proxy *upower_proxy_ac;
typedef struct _Upower_Data Upower_Data;
struct _Upower_Data
{
Eldbus_Proxy *proxy;
Instance *inst;
};
static void
_battery_free(Battery *bat)
{
Eldbus_Object *obj = eldbus_proxy_object_get(bat->proxy);
eldbus_proxy_unref(bat->proxy);
eldbus_object_unref(obj);
batman_device_batteries = eina_list_remove(batman_device_batteries, bat);
eina_stringshare_del(bat->udi);
if (bat->model)
eina_stringshare_del(bat->model);
if (bat->vendor)
eina_stringshare_del(bat->vendor);
E_FREE(bat);
}
static void
_ac_free(Ac_Adapter *ac)
{
Eldbus_Object *obj = eldbus_proxy_object_get(ac->proxy);
eldbus_proxy_unref(ac->proxy);
eldbus_object_unref(obj);
batman_device_ac_adapters = eina_list_remove(batman_device_ac_adapters, ac);
eina_stringshare_del(ac->udi);
E_FREE(ac);
}
static void
_ac_get_all_cb(void *data, const Eldbus_Message *msg, Eldbus_Pending *pending EINA_UNUSED)
{
Ac_Adapter *ac = data;
Eldbus_Message_Iter *array, *dict, *variant;
if (!eldbus_message_arguments_get(msg, "a{sv}", &array))
return;
while (eldbus_message_iter_get_and_next(array, 'e', &dict))
{
const char *key;
if (!eldbus_message_iter_arguments_get(dict, "sv", &key, &variant))
continue;
if (!strcmp(key, "Online"))
{
Eina_Bool b;
eldbus_message_iter_arguments_get(variant, "b", &b);
ac->present = b;
break;
}
}
_batman_device_update(ac->inst);
}
static void
_ac_changed_cb(void *data, const Eldbus_Message *msg EINA_UNUSED)
{
Ac_Adapter *ac = data;
eldbus_proxy_property_get_all(ac->proxy, _ac_get_all_cb, ac);
}
static void
_process_ac(Eldbus_Proxy *proxy, Instance *inst)
{
Ac_Adapter *ac;
ac = E_NEW(Ac_Adapter, 1);
if (!ac) goto error;
ac->inst = inst;
ac->proxy = proxy;
ac->udi = eina_stringshare_add(eldbus_object_path_get(eldbus_proxy_object_get(proxy)));
eldbus_proxy_property_get_all(proxy, _ac_get_all_cb, ac);
eldbus_proxy_signal_handler_add(upower_proxy_ac, "PropertiesChanged", _ac_changed_cb, ac);
batman_device_ac_adapters = eina_list_append(batman_device_ac_adapters, ac);
return;
error:
eldbus_object_unref(eldbus_proxy_object_get(proxy));
eldbus_proxy_unref(proxy);
return;
}
static const char *bat_techologies[] = {
"Unknown",
"Lithium ion",
"Lithium polymer",
"Lithium iron phosphate",
"Lead acid",
"Nickel cadmium",
"Nickel metal hydride"
};
static void
_bat_get_all_cb(void *data, const Eldbus_Message *msg, Eldbus_Pending *pending EINA_UNUSED)
{
Battery *bat = data;
Eldbus_Message_Iter *array, *dict, *variant;
bat->got_prop = EINA_TRUE;
if (!eldbus_message_arguments_get(msg, "a{sv}", &array))
return;
while (eldbus_message_iter_get_and_next(array, 'e', &dict))
{
const char *key;
union
{
Eina_Bool b;
int64_t i64;
unsigned u;
double d;
const char *s;
} val;
if (!eldbus_message_iter_arguments_get(dict, "sv", &key, &variant))
continue;
if (!strcmp(key, "IsPresent"))
{
eldbus_message_iter_arguments_get(variant, "b", &val.b);
bat->present = val.b;
}
else if (!strcmp(key, "TimeToEmpty"))
{
eldbus_message_iter_arguments_get(variant, "x", &val.i64);
bat->time_left = (int)val.i64;
if (bat->time_left > 0)
bat->charging = EINA_FALSE;
else
bat->charging = EINA_TRUE;
}
else if (!strcmp(key, "Percentage"))
{
eldbus_message_iter_arguments_get(variant, "d", &val.d);
bat->percent = (int)val.d;
}
else if (!strcmp(key, "Energy"))
{
eldbus_message_iter_arguments_get(variant, "d", &val.d);
bat->current_charge = (int)val.d;
}
else if (!strcmp(key, "EnergyFullDesign"))
{
eldbus_message_iter_arguments_get(variant, "d", &val.d);
bat->design_charge = (int)val.d;
}
else if (!strcmp(key, "EnergyFull"))
{
eldbus_message_iter_arguments_get(variant, "d", &val.d);
bat->last_full_charge = (int)val.d;
}
else if (!strcmp(key, "TimeToFull"))
{
eldbus_message_iter_arguments_get(variant, "x", &val.i64);
bat->time_full = (int)val.i64;
}
else if (!strcmp(key, "Technology"))
{
eldbus_message_iter_arguments_get(variant, "u", &val.u);
if (val.u > EINA_C_ARRAY_LENGTH(bat_techologies))
val.u = 0;
bat->technology = bat_techologies[val.u];
}
else if (!strcmp(key, "Model"))
{
if (!eldbus_message_iter_arguments_get(variant, "s", &val.s))
continue;
eina_stringshare_replace(&bat->model, val.s);
}
else if (!strcmp(key, "Vendor"))
{
if (!eldbus_message_iter_arguments_get(variant, "s", &val.s))
continue;
if (bat->vendor)
eina_stringshare_del(bat->vendor);
bat->vendor = eina_stringshare_add(val.s);
}
}
_batman_device_update(bat->inst);
}
static void
_bat_changed_cb(void *data, const Eldbus_Message *msg EINA_UNUSED)
{
Battery *bat = data;
eldbus_proxy_property_get_all(bat->proxy, _bat_get_all_cb, bat);
}
static void
_process_battery(Eldbus_Proxy *proxy, Instance *inst)
{
Battery *bat;
bat = E_NEW(Battery, 1);
if (!bat)
{
eldbus_object_unref(eldbus_proxy_object_get(proxy));
eldbus_proxy_unref(proxy);
return;
}
bat->inst = inst;
bat->proxy = proxy;
bat->udi = eina_stringshare_add(eldbus_object_path_get(eldbus_proxy_object_get(proxy)));
eldbus_proxy_property_get_all(proxy, _bat_get_all_cb, bat);
eldbus_proxy_signal_handler_add(upower_proxy_bat, "PropertiesChanged", _bat_changed_cb, bat);
batman_device_batteries = eina_list_append(batman_device_batteries, bat);
_batman_device_update(bat->inst);
}
static void
_device_type_cb(void *data, const Eldbus_Message *msg, Eldbus_Pending *pending)
{
Upower_Data *ud = data;
Eldbus_Message_Iter *variant;
Eldbus_Object *obj;
unsigned int type;
const char *path = eldbus_pending_path_get (pending);
if (!eldbus_message_arguments_get(msg, "v", &variant))
goto error;
eldbus_message_iter_arguments_get(variant, "u", &type);
if (type == 1)
{
obj = eldbus_object_get(conn, BUS, path);
EINA_SAFETY_ON_FALSE_RETURN(obj);
upower_proxy_ac = eldbus_proxy_get(obj, IFACE_PROPERTIES);
_process_ac(ud->proxy, ud->inst);
}
else if (type == 2)
{
obj = eldbus_object_get(conn, BUS, path);
EINA_SAFETY_ON_FALSE_RETURN(obj);
upower_proxy_bat = eldbus_proxy_get(obj, IFACE_PROPERTIES);
_process_battery(ud->proxy, ud->inst);
}
else
goto error;
E_FREE(ud);
return;
error:
obj = eldbus_proxy_object_get(ud->proxy);
eldbus_proxy_unref(ud->proxy);
eldbus_object_unref(obj);
E_FREE(ud);
return;
}
static void
_process_enumerate_path(const char *path, Instance *inst)
{
Eldbus_Object *obj;
Eldbus_Proxy *proxy;
Upower_Data *ud;
obj = eldbus_object_get(conn, BUS, path);
EINA_SAFETY_ON_FALSE_RETURN(obj);
proxy = eldbus_proxy_get(obj, IFACE_DEVICE);
ud = E_NEW(Upower_Data, 1);
if (!ud)
{
eldbus_object_unref(eldbus_proxy_object_get(proxy));
eldbus_proxy_unref(proxy);
return;
}
ud->proxy = proxy;
ud->inst = inst;
eldbus_proxy_property_get(proxy, "Type", _device_type_cb, ud);
}
static void
_enumerate_cb(void *data, const Eldbus_Message *msg, Eldbus_Pending *pending EINA_UNUSED)
{
Instance *inst = data;
const char *path;
Eldbus_Message_Iter *array;
if (!eldbus_message_arguments_get(msg, "ao", &array))
return;
while (eldbus_message_iter_get_and_next(array, 'o', &path))
_process_enumerate_path(path, inst);
}
static void
_device_added_cb(void *data, const Eldbus_Message *msg)
{
const char *path;
Instance *inst = data;
if (!eldbus_message_arguments_get(msg, "o", &path))
return;
_process_enumerate_path(path, inst);
}
static void
_device_removed_cb(void *data, const Eldbus_Message *msg)
{
Battery *bat;
Ac_Adapter *ac;
const char *path;
Instance *inst = data;
Eina_List *batteries, *adapters, *l;
Eina_Bool exists = EINA_FALSE;
if (!eldbus_message_arguments_get(msg, "o", &path))
return;
batteries = _batman_battery_find(path);
if (eina_list_count(batteries))
{
EINA_LIST_FOREACH(batteries, l, bat)
{
if (inst == bat->inst)
{
inst = bat->inst;
_battery_free(bat);
_batman_device_update(inst);
exists = EINA_TRUE;
}
}
if (exists)
{
eina_list_free(batteries);
return;
}
}
exists = EINA_FALSE;
adapters = _batman_ac_adapter_find(path);
if (eina_list_count(adapters))
{
EINA_LIST_FOREACH(adapters, l, ac)
{
if (ac->inst == inst)
{
inst = ac->inst;
_ac_free(ac);
_batman_device_update(inst);
exists = EINA_TRUE;
}
}
eina_list_free(adapters);
}
}
int
_batman_upower_start(Instance *inst)
{
Eldbus_Object *obj;
conn = eldbus_connection_get(ELDBUS_CONNECTION_TYPE_SYSTEM);
EINA_SAFETY_ON_NULL_RETURN_VAL(conn, 0);
obj = eldbus_object_get(conn, BUS, PATH);
EINA_SAFETY_ON_NULL_GOTO(obj, obj_error);
upower_proxy = eldbus_proxy_get(obj, IFACE);
EINA_SAFETY_ON_NULL_GOTO(upower_proxy, proxy_error);
eldbus_proxy_signal_handler_add(upower_proxy, "DeviceAdded", _device_added_cb, inst);
eldbus_proxy_signal_handler_add(upower_proxy, "DeviceRemoved", _device_removed_cb, inst);
eldbus_proxy_call(upower_proxy, "EnumerateDevices", _enumerate_cb, inst, -1, "");
return 1;
proxy_error:
eldbus_object_unref(obj);
obj_error:
eldbus_connection_unref(conn);
return 0;
}
void
_batman_upower_stop(void)
{
Eina_List *list, *list2;
Battery *bat;
Ac_Adapter *ac;
Eldbus_Object *obj;
EINA_LIST_FOREACH_SAFE(batman_device_batteries, list, list2, bat)
E_FREE_FUNC(bat, _battery_free);
EINA_LIST_FOREACH_SAFE(batman_device_ac_adapters, list, list2, ac)
E_FREE_FUNC(ac, _ac_free);
obj = eldbus_proxy_object_get(upower_proxy);
E_FREE_FUNC(upower_proxy, eldbus_proxy_unref);
E_FREE_FUNC(obj, eldbus_object_unref);
obj = eldbus_proxy_object_get(upower_proxy_ac);
E_FREE_FUNC(upower_proxy_ac, eldbus_proxy_unref);
E_FREE_FUNC(obj, eldbus_object_unref);
obj = eldbus_proxy_object_get(upower_proxy_bat);
E_FREE_FUNC(upower_proxy_bat, eldbus_proxy_unref);
E_FREE_FUNC(obj, eldbus_object_unref);
E_FREE_FUNC(conn, eldbus_connection_unref);
}

1168
src/modules/sysinfo/cpuclock/cpuclock.c
View File

File diff suppressed because it is too large Load Diff

33
src/modules/sysinfo/cpuclock/cpuclock.h
View File

@ -1,33 +0,0 @@
#ifndef CPUCLOCK_H
#define CPUCLOCK_H
#include "../sysinfo.h"
typedef struct _Cpuclock_Config Cpuclock_Config;
struct _Cpuclock_Config
{
Instance *inst;
Evas_Object *max;
Evas_Object *min;
Evas_Object *general;
Evas_Object *policy;
Evas_Object *saving;
Evas_Object *freq;
Evas_Object *ps;
Eina_List *powersaves;
Eina_Bool frequencies;
Eina_Bool pstate;
};
EINTERN Evas_Object *cpuclock_configure(Instance *inst);
EINTERN void _cpuclock_config_updated(Instance *inst);
EINTERN void _cpuclock_set_governor(const char *governor);
EINTERN void _cpuclock_set_frequency(int frequency);
EINTERN void _cpuclock_set_pstate(int min, int max, int turbo);
#if defined(__OpenBSD__) || defined(__FreeBSD__)
EINTERN int _cpuclock_sysctl_frequency(int new_perf);
#endif
#endif

633
src/modules/sysinfo/cpuclock/cpuclock_config.c
View File

@ -1,633 +0,0 @@
#include "cpuclock.h"
static void
_config_close(void *data, Evas *e EINA_UNUSED, Evas_Object *obj EINA_UNUSED, void *event_info EINA_UNUSED)
{
Cpuclock_Config *cc = data;
Instance *inst = cc->inst;
E_FREE_FUNC(inst->cfg->cpuclock.configure, evas_object_del);
E_FREE_FUNC(cc->powersaves, eina_list_free);
E_FREE(cc);
e_config_save_queue();
}
static void
_config_show_general(void *data, Evas_Object *obj EINA_UNUSED, void *event_info EINA_UNUSED)
{
Cpuclock_Config *cc = data;
evas_object_hide(cc->policy);
evas_object_hide(cc->saving);
if (cc->pstate)
evas_object_hide(cc->ps);
if (cc->frequencies)
evas_object_hide(cc->freq);
evas_object_show(cc->general);
}
static void
_config_show_policy(void *data, Evas_Object *obj EINA_UNUSED, void *event_info EINA_UNUSED)
{
Cpuclock_Config *cc = data;
evas_object_hide(cc->general);
evas_object_hide(cc->saving);
if (cc->pstate)
evas_object_hide(cc->ps);
if (cc->frequencies)
evas_object_hide(cc->freq);
evas_object_show(cc->policy);
}
static void
_config_show_saving(void *data, Evas_Object *obj EINA_UNUSED, void *event_info EINA_UNUSED)
{
Cpuclock_Config *cc = data;
evas_object_hide(cc->general);
evas_object_hide(cc->policy);
if (cc->pstate)
evas_object_hide(cc->ps);
if (cc->frequencies)
evas_object_hide(cc->freq);
evas_object_show(cc->saving);
}
static void
_config_show_frequencies(void *data, Evas_Object *obj EINA_UNUSED, void *event_info EINA_UNUSED)
{
Cpuclock_Config *cc = data;
evas_object_hide(cc->general);
evas_object_hide(cc->policy);
evas_object_hide(cc->saving);
if (cc->pstate)
evas_object_hide(cc->ps);
evas_object_show(cc->freq);
}
static void
_config_show_pstate(void *data, Evas_Object *obj EINA_UNUSED, void *event_info EINA_UNUSED)
{
Cpuclock_Config *cc = data;
evas_object_hide(cc->general);
evas_object_hide(cc->policy);
evas_object_hide(cc->saving);
if (cc->frequencies)
evas_object_hide(cc->freq);
evas_object_show(cc->ps);
}
static void
_update_max_power(void *data, Evas_Object *obj EINA_UNUSED, void *event_info EINA_UNUSED)
{
Cpuclock_Config *cc = data;
Instance *inst = cc->inst;
int value = elm_slider_value_get(cc->max);
inst->cfg->cpuclock.pstate_max = value;
_cpuclock_set_pstate(inst->cfg->cpuclock.pstate_min - 1,
inst->cfg->cpuclock.pstate_max - 1, inst->cfg->cpuclock.status->pstate_turbo);
e_config_save_queue();
_cpuclock_config_updated(inst);
}
static void
_update_min_power(void *data, Evas_Object *obj EINA_UNUSED, void *event_info EINA_UNUSED)
{
Cpuclock_Config *cc = data;
Instance *inst = cc->inst;
int value = elm_slider_value_get(cc->min);
inst->cfg->cpuclock.pstate_min = value;
_cpuclock_set_pstate(inst->cfg->cpuclock.pstate_min - 1,
inst->cfg->cpuclock.pstate_max - 1, inst->cfg->cpuclock.status->pstate_turbo);
e_config_save_queue();
_cpuclock_config_updated(inst);
}
static void
_auto_powersave(void *data, Evas_Object *obj, void *event_info EINA_UNUSED)
{
Cpuclock_Config *cc = data;
Instance *inst = cc->inst;
Eina_List *l = NULL;
Evas_Object *o = NULL;
inst->cfg->cpuclock.auto_powersave = elm_check_state_get(obj);
EINA_LIST_FOREACH(cc->powersaves, l, o)
elm_object_disabled_set(o, inst->cfg->cpuclock.auto_powersave);
e_config_save_queue();
_cpuclock_config_updated(inst);
}
static void
_restore_governor(void *data, Evas_Object *obj, void *event_info EINA_UNUSED)
{
Cpuclock_Config *cc = data;
Instance *inst = cc->inst;
inst->cfg->cpuclock.restore_governor = elm_check_state_get(obj);
if ((!inst->cfg->cpuclock.governor) ||
(strcmp(inst->cfg->cpuclock.status->cur_governor, inst->cfg->cpuclock.governor)))
{
eina_stringshare_replace(&inst->cfg->cpuclock.governor, inst->cfg->cpuclock.status->cur_governor);
}
e_config_save_queue();
_cpuclock_config_updated(inst);
}
static void
_frequency_changed(void *data EINA_UNUSED, Evas_Object *obj, void *event_info EINA_UNUSED)
{
const char *value = elm_object_text_get(obj);
int frequency = atol(value);
#if defined(__FreeBSD__) || defined(__DragonFly__) || defined(__OpenBSD__)
frequency = (int) evas_object_data_get(obj, "frequency");
#endif
if (frequency > 0)
_cpuclock_set_frequency(frequency);
}
static void
_powersave_changed(void *data, Evas_Object *obj, void *event_info EINA_UNUSED)
{
Cpuclock_Config *cc = data;
Instance *inst = cc->inst;
const char *value = evas_object_data_get(obj, "governor");
if (value)
eina_stringshare_replace(&inst->cfg->cpuclock.powersave_governor, value);
e_config_save_queue();
_cpuclock_config_updated(inst);
}
static void
_governor_changed(void *data, Evas_Object *obj, void *event_info EINA_UNUSED)
{
Cpuclock_Config *cc = data;
Instance *inst = cc->inst;
const char *value = evas_object_data_get(obj, "governor");
if (value)
{
eina_stringshare_replace(&inst->cfg->cpuclock.governor, value);
_cpuclock_set_governor(inst->cfg->cpuclock.governor);
}
e_config_save_queue();
_cpuclock_config_updated(inst);
}
static void
_poll_changed(void *data, Evas_Object *obj, void *event_info EINA_UNUSED)
{
Cpuclock_Config *cc = data;
Instance *inst = cc->inst;
int value = elm_radio_value_get(obj);
switch (value)
{
case 0:
inst->cfg->cpuclock.poll_interval = 4;
break;
case 1:
inst->cfg->cpuclock.poll_interval = 8;
break;
case 2:
inst->cfg->cpuclock.poll_interval = 32;
break;
case 3:
inst->cfg->cpuclock.poll_interval = 64;
break;
case 4:
inst->cfg->cpuclock.poll_interval = 256;
break;
default:
inst->cfg->cpuclock.poll_interval = 32;
}
e_config_save_queue();
_cpuclock_config_updated(inst);
}
Evas_Object *
cpuclock_configure(Instance *inst)
{
Evas_Object *popup, *tb, *frame, *box, *o, *group, *lbl, *slider, *list, *check;
Evas_Object *groupg = NULL, *groups = NULL, *groupf = NULL;
Elm_Object_Item *it;
E_Zone *zone = e_zone_current_get();
Eina_List *l = NULL;
Cpuclock_Config *cc = E_NEW(Cpuclock_Config, 1);
int i = 0, value = 0;
cc->inst = inst;
cc->powersaves = NULL;
cc->frequencies = EINA_FALSE;
cc->pstate = EINA_FALSE;
if ((inst->cfg->cpuclock.status->frequencies) &&
(inst->cfg->cpuclock.status->can_set_frequency) &&
(!inst->cfg->cpuclock.status->pstate))
{
cc->frequencies = EINA_TRUE;
}
if ((inst->cfg->cpuclock.status) && (inst->cfg->cpuclock.status->pstate))
{
cc->pstate = EINA_TRUE;
}
popup = elm_popup_add(e_comp->elm);
E_EXPAND(popup);
elm_popup_allow_events_set(popup, 1);
elm_popup_scrollable_set(popup, 1);
tb = elm_table_add(popup);
E_EXPAND(tb);
evas_object_show(tb);
elm_object_content_set(popup, tb);
lbl = elm_label_add(tb);
evas_object_size_hint_weight_set(lbl, EVAS_HINT_EXPAND, 0.0);
evas_object_size_hint_align_set(lbl, EVAS_HINT_FILL, EVAS_HINT_FILL);
elm_object_style_set(lbl, "marker");
elm_object_text_set(lbl, _("CpuClock Configuration"));
elm_table_pack(tb, lbl, 0, 0, 2, 1);
evas_object_show(lbl);
list = elm_list_add(tb);
E_ALIGN(list, 0, EVAS_HINT_FILL);
E_WEIGHT(list, 0, EVAS_HINT_EXPAND);
elm_table_pack(tb, list, 0, 1, 1, 1);
elm_list_select_mode_set(list, ELM_OBJECT_SELECT_MODE_ALWAYS);
elm_scroller_content_min_limit(list, 1, 1);
it = elm_list_item_append(list, _("General"), NULL, NULL,
_config_show_general, cc);
elm_list_item_selected_set(it, 1);
it = elm_list_item_append(list, _("Power Policy"), NULL, NULL,
_config_show_policy, cc);
it = elm_list_item_append(list, _("Power Saving"), NULL, NULL,
_config_show_saving, cc);
if (cc->pstate)
it = elm_list_item_append(list, _("Power State"), NULL, NULL,
_config_show_pstate, cc);
if (cc->frequencies)
it = elm_list_item_append(list, _("Frequencies"), NULL, NULL,
_config_show_frequencies, cc);
elm_list_go(list);
evas_object_show(list);
frame = elm_frame_add(tb);
elm_object_text_set(frame, _("General"));
E_EXPAND(frame);
E_FILL(frame);
elm_table_pack(tb, frame, 1, 1, 1, 1);
evas_object_show(frame);
cc->general = frame;
box = elm_box_add(frame);
elm_box_horizontal_set(box, EINA_FALSE);
E_EXPAND(box);
evas_object_show(box);
lbl = elm_label_add(tb);
E_ALIGN(lbl, 0.0, 0.0);
E_WEIGHT(lbl, EVAS_HINT_EXPAND, 0);
elm_object_text_set(lbl, _("Update Poll Interval"));
elm_box_pack_end(box, lbl);
evas_object_show(lbl);
o = elm_radio_add(box);
elm_radio_state_value_set(o, 0);
E_ALIGN(o, 0.0, 0.0);
E_WEIGHT(o, EVAS_HINT_EXPAND, 0);
elm_object_text_set(o, _("Fast (4 ticks)"));
elm_box_pack_end(box, o);
evas_object_smart_callback_add(o, "changed", _poll_changed, cc);
evas_object_show(o);
group = o;
o = elm_radio_add(box);
elm_radio_state_value_set(o, 1);
elm_radio_group_add(o, group);
E_ALIGN(o, 0.0, 0.0);
E_WEIGHT(o, EVAS_HINT_EXPAND, 0);
elm_object_text_set(o, _("Medium (8 ticks)"));
elm_box_pack_end(box, o);
evas_object_smart_callback_add(o, "changed", _poll_changed, cc);
evas_object_show(o);
o = elm_radio_add(box);
elm_radio_state_value_set(o, 2);
elm_radio_group_add(o, group);
E_ALIGN(o, 0.0, 0.0);
E_WEIGHT(o, EVAS_HINT_EXPAND, 0);
elm_object_text_set(o, _("Normal (32 ticks)"));
elm_box_pack_end(box, o);
evas_object_smart_callback_add(o, "changed", _poll_changed, cc);
evas_object_show(o);
o = elm_radio_add(box);
elm_radio_state_value_set(o, 3);
elm_radio_group_add(o, group);
E_ALIGN(o, 0.0, 0.0);
E_WEIGHT(o, EVAS_HINT_EXPAND, 0);
elm_object_text_set(o, _("Slow (64 ticks)"));
elm_box_pack_end(box, o);
evas_object_smart_callback_add(o, "changed", _poll_changed, cc);
evas_object_show(o);
o = elm_radio_add(box);
elm_radio_state_value_set(o, 4);
elm_radio_group_add(o, group);
E_ALIGN(o, 0.0, 0.0);
E_WEIGHT(o, EVAS_HINT_EXPAND, 0);
elm_object_text_set(o, _("Very Slow (256 ticks)"));
elm_box_pack_end(box, o);
evas_object_smart_callback_add(o, "changed", _poll_changed, cc);
evas_object_show(o);
switch (inst->cfg->cpuclock.poll_interval)
{
case 4:
elm_radio_value_set(group, 0);
break;
case 8:
elm_radio_value_set(group, 1);
break;
case 32:
elm_radio_value_set(group, 2);
break;
case 64:
elm_radio_value_set(group, 3);
break;
case 256:
elm_radio_value_set(group, 4);
break;
default:
elm_radio_value_set(group, 2);
}
elm_object_content_set(frame, box);
frame = elm_frame_add(tb);
elm_object_text_set(frame, _("Power Policy"));
E_EXPAND(frame);
E_FILL(frame);
elm_table_pack(tb, frame, 1, 1, 1, 1);
evas_object_show(frame);
cc->policy = frame;
box = elm_box_add(frame);
elm_box_horizontal_set(box, EINA_FALSE);
E_EXPAND(box);
evas_object_show(box);
i = 0;
for (l = inst->cfg->cpuclock.status->governors; l; l = l->next)
{
o = elm_radio_add(box);
elm_radio_state_value_set(o, i);
E_ALIGN(o, 0.0, 0.0);
E_WEIGHT(o, EVAS_HINT_EXPAND, 0);
if (!strcmp(l->data, "ondemand"))
elm_object_text_set(o, _("Automatic"));
else if (!strcmp(l->data, "conservative"))
elm_object_text_set(o, _("Lower Power Automatic"));
else if (!strcmp(l->data, "interactive"))
elm_object_text_set(o, _("Automatic Interactive"));
else if (!strcmp(l->data, "powersave"))
elm_object_text_set(o, _("Minimum Speed"));
else if (!strcmp(l->data, "performance"))
elm_object_text_set(o, _("Maximum Speed"));
else
elm_object_text_set(o, l->data);
evas_object_data_set(o, "governor", strdup(l->data));
elm_box_pack_end(box, o);
evas_object_smart_callback_add(o, "changed", _governor_changed, cc);
evas_object_show(o);
if (!strcmp(inst->cfg->cpuclock.status->cur_governor, l->data))
value = i;
if (!groupg)
groupg = o;
else
elm_radio_group_add(o, groupg);
i++;
}
if (groupg)
elm_radio_value_set(groupg, value);
check = elm_check_add(box);
elm_object_text_set(check, _("Restore CPU Power Policy"));
elm_check_state_set(check, inst->cfg->cpuclock.restore_governor);
E_ALIGN(check, 0.0, 0.0);
E_WEIGHT(check, EVAS_HINT_EXPAND, 0);
evas_object_smart_callback_add(check, "changed", _restore_governor, cc);
elm_box_pack_end(box, check);
evas_object_show(check);
elm_object_content_set(frame, box);
frame = elm_frame_add(tb);
elm_object_text_set(frame, _("Power Saving"));
E_EXPAND(frame);
E_FILL(frame);
elm_table_pack(tb, frame, 1, 1, 1, 1);
evas_object_show(frame);
cc->saving = frame;
box = elm_box_add(frame);
elm_box_horizontal_set(box, EINA_FALSE);
E_EXPAND(box);
evas_object_show(box);
check = elm_check_add(box);
elm_object_text_set(check, _("Automatic Powersaving"));
elm_check_state_set(check, inst->cfg->cpuclock.auto_powersave);
E_ALIGN(check, 0.0, 0.0);
E_WEIGHT(check, EVAS_HINT_EXPAND, 0);
evas_object_smart_callback_add(check, "changed", _auto_powersave, cc);
elm_box_pack_end(box, check);
evas_object_show(check);
i = 0;
for (l = inst->cfg->cpuclock.status->governors; l; l = l->next)
{
o = elm_radio_add(box);
elm_radio_state_value_set(o, i);
E_ALIGN(o, 0.0, 0.0);
E_WEIGHT(o, EVAS_HINT_EXPAND, 0);
if (!strcmp(l->data, "ondemand"))
elm_object_text_set(o, _("Automatic"));
else if (!strcmp(l->data, "conservative"))
elm_object_text_set(o, _("Lower Power Automatic"));
else if (!strcmp(l->data, "interactive"))
elm_object_text_set(o, _("Automatic Interactive"));
else if (!strcmp(l->data, "powersave"))
elm_object_text_set(o, _("Minimum Speed"));
else if (!strcmp(l->data, "performance"))
elm_object_text_set(o, _("Maximum Speed"));
else
elm_object_text_set(o, l->data);
elm_object_disabled_set(o, inst->cfg->cpuclock.auto_powersave);
evas_object_data_set(o, "governor", strdup(l->data));
elm_box_pack_end(box, o);
evas_object_smart_callback_add(o, "changed", _powersave_changed, cc);
evas_object_show(o);
cc->powersaves = eina_list_append(cc->powersaves, o);
if (inst->cfg->cpuclock.powersave_governor && !strcmp(inst->cfg->cpuclock.powersave_governor, l->data))
value = i;
if (!groups)
groups = o;
else
elm_radio_group_add(o, groups);
i++;
}
if (groups)
elm_radio_value_set(groups, value);
elm_object_content_set(frame, box);
if (cc->pstate)
{
frame = elm_frame_add(tb);
elm_object_text_set(frame, _("Power State"));
E_EXPAND(frame);
E_FILL(frame);
elm_table_pack(tb, frame, 1, 1, 1, 1);
evas_object_show(frame);
cc->ps = frame;
box = elm_box_add(frame);
elm_box_horizontal_set(box, EINA_FALSE);
E_EXPAND(box);
evas_object_show(box);
slider = elm_slider_add(box);
elm_object_text_set(slider, _("Maximum Power State:"));
elm_slider_unit_format_set(slider, "%3.0f");
elm_slider_indicator_format_set(slider, "%3.0f");
elm_slider_min_max_set(slider, 2, 100);
elm_slider_value_set(slider, inst->cfg->cpuclock.pstate_max);
elm_slider_step_set(slider, 1);
elm_slider_span_size_set(slider, 100);
evas_object_size_hint_align_set(slider, EVAS_HINT_FILL, 0.5);
evas_object_size_hint_weight_set(slider, EVAS_HINT_EXPAND, 0.0);
evas_object_smart_callback_add(slider, "delay,changed", _update_max_power, cc);
elm_box_pack_end(box, slider);
evas_object_show(slider);
cc->max = slider;
slider = elm_slider_add(box);
elm_object_text_set(slider, _("Minimum Power State:"));
elm_slider_unit_format_set(slider, "%3.0f");
elm_slider_indicator_format_set(slider, "%3.0f");
elm_slider_min_max_set(slider, 0, 100);
elm_slider_value_set(slider, inst->cfg->cpuclock.pstate_min);
elm_slider_step_set(slider, 1);
elm_slider_span_size_set(slider, 100);
evas_object_size_hint_align_set(slider, EVAS_HINT_FILL, 0.5);
evas_object_size_hint_weight_set(slider, EVAS_HINT_EXPAND, 0.0);
evas_object_smart_callback_add(slider, "delay,changed", _update_min_power, cc);
elm_box_pack_end(box, slider);
evas_object_show(slider);
cc->min = slider;
elm_object_content_set(frame, box);
}
if (cc->frequencies)
{
frame = elm_frame_add(tb);
elm_object_text_set(frame, _("Frequencies"));
E_EXPAND(frame);
E_FILL(frame);
elm_table_pack(tb, frame, 1, 1, 1, 1);
evas_object_show(frame);
cc->freq = frame;
box = elm_box_add(frame);
elm_box_horizontal_set(box, EINA_FALSE);
E_EXPAND(box);
evas_object_show(box);
i = 0;
for (l = inst->cfg->cpuclock.status->frequencies; l; l = l->next)
{
char buf[4096];
int frequency;
frequency = (long)l->data;
o = elm_radio_add(box);
elm_radio_state_value_set(o, i);
E_ALIGN(o, 0.0, 0.0);
E_WEIGHT(o, EVAS_HINT_EXPAND, 0);
#if defined(__OpenBSD__)
snprintf(buf, sizeof(buf), "%i %%", frequency);
#else
if (frequency < 1000000)
snprintf(buf, sizeof(buf), _("%i MHz"), frequency / 1000);
else
snprintf(buf, sizeof(buf), _("%'.1f GHz"),
frequency / 1000000.);
#endif
elm_object_text_set(o, buf);
evas_object_data_set(o, "frequency", (void *) (long) frequency);
elm_box_pack_end(box, o);
evas_object_smart_callback_add(o, "changed", _frequency_changed, cc);
evas_object_show(o);
#if defined(__OpenBSD__)
if (inst->cfg->cpuclock.status->cur_percent == frequency)
value = i;
#else
if (inst->cfg->cpuclock.status->cur_frequency == frequency)
value = i;
#endif
if (!groupf)
groupf = o;
else
elm_radio_group_add(o, groupf);
i++;
}
if (groupf)
elm_radio_value_set(groupf, value);
elm_object_content_set(frame, box);
evas_object_hide(cc->freq);
}
if (cc->pstate)
evas_object_hide(cc->ps);
evas_object_hide(cc->policy);
evas_object_hide(cc->saving);
evas_object_show(cc->general);
popup = e_comp_object_util_add(popup, E_COMP_OBJECT_TYPE_NONE);
evas_object_layer_set(popup, E_LAYER_POPUP);
evas_object_resize(popup, zone->w / 4, zone->h / 3);
e_comp_object_util_center_on_zone(popup, zone);
evas_object_show(popup);
e_comp_object_util_autoclose(popup, NULL, e_comp_object_util_autoclose_on_escape, NULL);
evas_object_event_callback_add(popup, EVAS_CALLBACK_DEL, _config_close, cc);
return inst->cfg->cpuclock.configure = popup;
}

502
src/modules/sysinfo/cpumonitor/cpumonitor.c
View File

@ -1,502 +0,0 @@
#include "cpumonitor.h"
typedef struct _Thread_Config Thread_Config;
struct _Thread_Config
{
int interval;
int num_cores;
int percent;
unsigned long total;
unsigned long idle;
Instance *inst;
E_Powersave_Sleeper *sleeper;
Eina_List *cores;
};
static void
_cpumonitor_face_update(Thread_Config *thc)
{
Eina_List *l;
CPU_Core *core;
EINA_LIST_FOREACH(thc->cores, l, core)
{
Edje_Message_Int_Set *usage_msg;
usage_msg = malloc(sizeof(Edje_Message_Int_Set) + 1 * sizeof(int));
EINA_SAFETY_ON_NULL_RETURN(usage_msg);
usage_msg->count = 1;
usage_msg->val[0] = core->percent;
edje_object_message_send(elm_layout_edje_get(core->layout), EDJE_MESSAGE_INT_SET, 1,
usage_msg);
E_FREE(usage_msg);
}
if (thc->inst->cfg->cpumonitor.popup)
{
elm_progressbar_value_set(thc->inst->cfg->cpumonitor.popup_pbar,
(float)thc->percent / 100);
}
}
static Evas_Object *
_cpumonitor_configure_cb(Evas_Object *g)
{
Instance *inst = evas_object_data_get(g, "Instance");
if (!sysinfo_config) return NULL;
return cpumonitor_configure(inst);
}
static void
_cpumonitor_popup_dismissed(void *data, Evas_Object *obj, void *event_info EINA_UNUSED)
{
Instance *inst = data;
E_FREE_FUNC(obj, evas_object_del);
inst->cfg->cpumonitor.popup = NULL;
}
static void
_cpumonitor_popup_deleted(void *data, Evas *e EINA_UNUSED, Evas_Object *obj EINA_UNUSED, void *event_info EINA_UNUSED)
{
Instance *inst = data;
inst->cfg->cpumonitor.popup = NULL;
}
static void
_cpumonitor_mouse_up_cb(void *data, Evas *e EINA_UNUSED, Evas_Object *obj EINA_UNUSED, void *event_data)
{
Evas_Object *popup, *box, *pbar, *label;
Evas_Event_Mouse_Up *ev = event_data;
Instance *inst = data;
char text[256];
if (ev->event_flags & EVAS_EVENT_FLAG_ON_HOLD) return;
if (ev->button == 1)
{
if (inst->cfg->cpumonitor.popup)
{
elm_ctxpopup_dismiss(inst->cfg->cpumonitor.popup);
return;
}
popup = elm_ctxpopup_add(e_comp->elm);
elm_object_style_set(popup, "noblock");
evas_object_smart_callback_add(popup, "dismissed", _cpumonitor_popup_dismissed, inst);
evas_object_event_callback_add(popup, EVAS_CALLBACK_DEL, _cpumonitor_popup_deleted, inst);
box = elm_box_add(popup);
E_EXPAND(box); E_FILL(box);
elm_object_content_set(popup, box);
evas_object_show(box);
snprintf(text, sizeof(text), "<big><b>%s</b></big>", _("Total CPU Usage"));
label = elm_label_add(box);
E_EXPAND(label); E_ALIGN(label, 0.5, 0.5);
elm_object_text_set(label, text);
elm_box_pack_end(box, label);
evas_object_show(label);
pbar = elm_progressbar_add(box);
E_EXPAND(pbar); E_FILL(pbar);
elm_progressbar_span_size_set(pbar, 200 * e_scale);
elm_progressbar_value_set(pbar, (float)inst->cfg->cpumonitor.percent / 100);
elm_box_pack_end(box, pbar);
evas_object_show(pbar);
inst->cfg->cpumonitor.popup_pbar = pbar;
e_gadget_util_ctxpopup_place(inst->o_main, popup,
inst->cfg->cpumonitor.o_gadget);
evas_object_show(popup);
inst->cfg->cpumonitor.popup = popup;
}
}
static void
_cpumonitor_resize_cb(void *data, Evas *e EINA_UNUSED, Evas_Object *obj, void *event_data EINA_UNUSED)
{
Evas_Coord w = 1, h = 1, sw, sh;
Instance *inst = data;
int num_cores = inst->cfg->cpumonitor.cores;
if (!num_cores || !inst->o_main) return;
edje_object_parts_extends_calc(elm_layout_edje_get(obj), 0, 0, &w, &h);
evas_object_event_callback_del_full(obj, EVAS_CALLBACK_RESIZE, _cpumonitor_resize_cb, inst);
if (inst->cfg->esm == E_SYSINFO_MODULE_CPUMONITOR)
{
evas_object_geometry_get(inst->o_main, 0, 0, &sw, &sh);
}
else
{
sw = w;
sh = h;
}
if (e_gadget_site_orient_get(e_gadget_site_get(inst->o_main)) == E_GADGET_SITE_ORIENT_VERTICAL)
{
w = sw;
h *= num_cores;
}
else
{
w *= num_cores;
h = sh;
}
if (w < 1) w = 1;
if (h < 1) h = 1;
evas_object_size_hint_aspect_set(inst->cfg->cpumonitor.o_gadget_box, EVAS_ASPECT_CONTROL_BOTH, w, h);
if (inst->cfg->esm == E_SYSINFO_MODULE_CPUMONITOR)
evas_object_size_hint_aspect_set(inst->o_main, EVAS_ASPECT_CONTROL_BOTH, w, h);
}
static void
_cpumonitor_cb_usage_check_main(void *data, Ecore_Thread *th)
{
Thread_Config *thc = data;
for (;; )
{
if (ecore_thread_check(th)) break;
#if defined(__FreeBSD__) || defined(__DragonFly__) || defined(__OpenBSD__)
_cpumonitor_sysctl_getusage(&thc->total, &thc->idle, &thc->percent, thc->cores);
#else
_cpumonitor_proc_getusage(&thc->total, &thc->idle, &thc->percent, thc->cores);
#endif
ecore_thread_feedback(th, NULL);
if (ecore_thread_check(th)) break;
e_powersave_sleeper_sleep(thc->sleeper, thc->interval);
if (ecore_thread_check(th)) break;
}
}
static void
_cpumonitor_cb_usage_check_notify(void *data,
Ecore_Thread *th EINA_UNUSED,
void *msg EINA_UNUSED)
{
Thread_Config *thc = data;
if (!thc->inst || !thc->inst->cfg) return;
if (thc->inst->cfg->esm != E_SYSINFO_MODULE_CPUMONITOR && thc->inst->cfg->esm != E_SYSINFO_MODULE_SYSINFO) return;
thc->inst->cfg->cpumonitor.percent = thc->percent;
_cpumonitor_face_update(thc);
}
static void
_cpumonitor_cb_usage_check_end(void *data, Ecore_Thread *th EINA_UNUSED)
{
Thread_Config *thc = data;
CPU_Core *core;
e_powersave_sleeper_free(thc->sleeper);
EINA_LIST_FREE(thc->cores, core)
E_FREE(core);
E_FREE(thc);
}
Evas_Object *
_cpumonitor_add_layout(Instance *inst)
{
Evas_Object *layout;
int orient = e_gadget_site_orient_get(e_gadget_site_get(inst->o_main));
layout = elm_layout_add(inst->cfg->cpumonitor.o_gadget_box);
edje_object_update_hints_set(elm_layout_edje_get(layout), EINA_TRUE);
if (orient == E_GADGET_SITE_ORIENT_VERTICAL)
e_theme_edje_object_set(layout, "base/theme/gadget/cpumonitor",
"e/gadget/cpumonitor/core/main_vert");
else
e_theme_edje_object_set(layout, "base/theme/gadget/cpumonitor",
"e/gadget/cpumonitor/core/main");
E_EXPAND(layout);
E_FILL(layout);
elm_box_pack_end(inst->cfg->cpumonitor.o_gadget_box, layout);
evas_object_show(layout);
return layout;
}
static void
_cpumonitor_del_layouts(Instance *inst)
{
elm_box_clear(inst->cfg->cpumonitor.o_gadget_box);
}
static Eina_Bool
_screensaver_on(void *data)
{
Instance *inst = data;
if (!ecore_thread_check(inst->cfg->cpumonitor.usage_check_thread))
{
_cpumonitor_del_layouts(inst);
ecore_thread_cancel(inst->cfg->cpumonitor.usage_check_thread);
inst->cfg->cpumonitor.usage_check_thread = NULL;
}
return ECORE_CALLBACK_RENEW;
}
static Eina_Bool
_screensaver_off(void *data)
{
Instance *inst = data;
_cpumonitor_config_updated(inst);
return ECORE_CALLBACK_RENEW;
}
void
_cpumonitor_config_updated(Instance *inst)
{
Thread_Config *thc;
CPU_Core *core;
int i = 0;
if (inst->cfg->id == -1)
{
int percent = 15;
thc = E_NEW(Thread_Config, 1);
if (thc)
{
thc->inst = inst;
thc->total = 0;
thc->idle = 0;
thc->percent = 60;
thc->num_cores = 4;
inst->cfg->cpumonitor.cores = thc->num_cores;
for (i = 0; i < 4; i++)
{
core = E_NEW(CPU_Core, 1);
core->layout = _cpumonitor_add_layout(inst);
if (i == 0)
evas_object_event_callback_add(core->layout, EVAS_CALLBACK_RESIZE, _cpumonitor_resize_cb, inst);
core->percent = percent;
core->total = 0;
core->idle = 0;
thc->cores = eina_list_append(thc->cores, core);
percent += 15;
}
_cpumonitor_face_update(thc);
EINA_LIST_FREE(thc->cores, core)
E_FREE(core);
E_FREE(thc);
}
return;
}
if (!ecore_thread_check(inst->cfg->cpumonitor.usage_check_thread))
{
_cpumonitor_del_layouts(inst);
ecore_thread_cancel(inst->cfg->cpumonitor.usage_check_thread);
inst->cfg->cpumonitor.usage_check_thread = NULL;
}
thc = E_NEW(Thread_Config, 1);
if (thc)
{
thc->inst = inst;
thc->total = 0;
thc->idle = 0;
thc->percent = 0;
thc->interval = inst->cfg->cpumonitor.poll_interval;
thc->sleeper = e_powersave_sleeper_new();
#if defined(__FreeBSD__) || defined(__DragonFly__) || defined(__OpenBSD__)
thc->num_cores = _cpumonitor_sysctl_getcores();
#else
thc->num_cores = _cpumonitor_proc_getcores();
#endif
inst->cfg->cpumonitor.cores = thc->num_cores;
for (i = 0; i < thc->num_cores; i++)
{
core = E_NEW(CPU_Core, 1);
core->layout = _cpumonitor_add_layout(inst);
if (i == 0)
evas_object_event_callback_add(core->layout, EVAS_CALLBACK_RESIZE, _cpumonitor_resize_cb, inst);
core->percent = 0;
core->total = 0;
core->idle = 0;
thc->cores = eina_list_append(thc->cores, core);
}
inst->cfg->cpumonitor.usage_check_thread =
ecore_thread_feedback_run(_cpumonitor_cb_usage_check_main,
_cpumonitor_cb_usage_check_notify,
_cpumonitor_cb_usage_check_end,
_cpumonitor_cb_usage_check_end, thc, EINA_TRUE);
}
e_config_save_queue();
}
static void
_cpumonitor_removed_cb(void *data, Evas_Object *obj EINA_UNUSED, void *event_data)
{
Instance *inst = data;
Ecore_Event_Handler *handler;
if (inst->o_main != event_data) return;
if (inst->cfg->cpumonitor.popup)
E_FREE_FUNC(inst->cfg->cpumonitor.popup, evas_object_del);
if (inst->cfg->cpumonitor.configure)
E_FREE_FUNC(inst->cfg->cpumonitor.configure, evas_object_del);
EINA_LIST_FREE(inst->cfg->cpumonitor.handlers, handler)
ecore_event_handler_del(handler);
evas_object_smart_callback_del_full(e_gadget_site_get(inst->o_main), "gadget_removed",
_cpumonitor_removed_cb, inst);
evas_object_event_callback_del_full(inst->o_main, EVAS_CALLBACK_DEL, sysinfo_cpumonitor_remove, data);
if (!ecore_thread_check(inst->cfg->cpumonitor.usage_check_thread))
{
_cpumonitor_del_layouts(inst);
ecore_thread_cancel(inst->cfg->cpumonitor.usage_check_thread);
inst->cfg->cpumonitor.usage_check_thread = NULL;
}
sysinfo_config->items = eina_list_remove(sysinfo_config->items, inst->cfg);
if (inst->cfg->id >= 0)
sysinfo_instances = eina_list_remove(sysinfo_instances, inst);
E_FREE(inst->cfg);
E_FREE(inst);
}
void
sysinfo_cpumonitor_remove(void *data, Evas *e EINA_UNUSED, Evas_Object *obj EINA_UNUSED, void *event_data EINA_UNUSED)
{
Instance *inst = data;
Ecore_Event_Handler *handler;
if (inst->cfg->cpumonitor.popup)
E_FREE_FUNC(inst->cfg->cpumonitor.popup, evas_object_del);
if (inst->cfg->cpumonitor.configure)
E_FREE_FUNC(inst->cfg->cpumonitor.configure, evas_object_del);
EINA_LIST_FREE(inst->cfg->cpumonitor.handlers, handler)
ecore_event_handler_del(handler);
if (!ecore_thread_check(inst->cfg->cpumonitor.usage_check_thread))
{
_cpumonitor_del_layouts(inst);
ecore_thread_cancel(inst->cfg->cpumonitor.usage_check_thread);
inst->cfg->cpumonitor.usage_check_thread = NULL;
}
}
static void
_cpumonitor_created_cb(void *data, Evas_Object *obj, void *event_data EINA_UNUSED)
{
Instance *inst = data;
int orient = e_gadget_site_orient_get(e_gadget_site_get(inst->o_main));
e_gadget_configure_cb_set(inst->o_main, _cpumonitor_configure_cb);
inst->cfg->cpumonitor.o_gadget = elm_layout_add(inst->o_main);
if (orient == E_GADGET_SITE_ORIENT_VERTICAL)
e_theme_edje_object_set(inst->cfg->cpumonitor.o_gadget,
"base/theme/gadget/cpumonitor",
"e/gadget/cpumonitor/main_vert");
else
e_theme_edje_object_set(inst->cfg->cpumonitor.o_gadget,
"base/theme/gadget/cpumonitor",
"e/gadget/cpumonitor/main");
E_EXPAND(inst->cfg->cpumonitor.o_gadget);
E_FILL(inst->cfg->cpumonitor.o_gadget);
elm_box_pack_end(inst->o_main, inst->cfg->cpumonitor.o_gadget);
evas_object_event_callback_add(inst->cfg->cpumonitor.o_gadget, EVAS_CALLBACK_MOUSE_UP,
_cpumonitor_mouse_up_cb, inst);
evas_object_show(inst->cfg->cpumonitor.o_gadget);
inst->cfg->cpumonitor.o_gadget_box = elm_box_add(inst->cfg->cpumonitor.o_gadget);
elm_box_homogeneous_set(inst->cfg->cpumonitor.o_gadget_box, EINA_TRUE);
if (orient == E_GADGET_SITE_ORIENT_VERTICAL)
elm_box_horizontal_set(inst->cfg->cpumonitor.o_gadget_box, EINA_FALSE);
else
elm_box_horizontal_set(inst->cfg->cpumonitor.o_gadget_box, EINA_TRUE);
E_EXPAND(inst->cfg->cpumonitor.o_gadget_box);
E_FILL(inst->cfg->cpumonitor.o_gadget_box);
elm_layout_content_set(inst->cfg->cpumonitor.o_gadget, "e.swallow.content", inst->cfg->cpumonitor.o_gadget_box);
evas_object_show(inst->cfg->cpumonitor.o_gadget_box);
evas_object_smart_callback_del_full(obj, "gadget_created", _cpumonitor_created_cb, data);
E_LIST_HANDLER_APPEND(inst->cfg->cpumonitor.handlers, E_EVENT_SCREENSAVER_ON, _screensaver_on, inst);
E_LIST_HANDLER_APPEND(inst->cfg->cpumonitor.handlers, E_EVENT_SCREENSAVER_OFF, _screensaver_off, inst);
_cpumonitor_config_updated(inst);
}
Evas_Object *
sysinfo_cpumonitor_create(Evas_Object *parent, Instance *inst)
{
inst->cfg->cpumonitor.percent = 0;
inst->cfg->cpumonitor.popup = NULL;
inst->cfg->cpumonitor.configure = NULL;
inst->cfg->cpumonitor.o_gadget = elm_layout_add(parent);
e_theme_edje_object_set(inst->cfg->cpumonitor.o_gadget,
"base/theme/gadget/cpumonitor",
"e/gadget/cpumonitor/main");
E_EXPAND(inst->cfg->cpumonitor.o_gadget);
E_FILL(inst->cfg->cpumonitor.o_gadget);
evas_object_event_callback_add(inst->cfg->cpumonitor.o_gadget, EVAS_CALLBACK_MOUSE_UP,
_cpumonitor_mouse_up_cb, inst);
evas_object_show(inst->cfg->cpumonitor.o_gadget);
inst->cfg->cpumonitor.o_gadget_box = elm_box_add(inst->cfg->cpumonitor.o_gadget);
elm_box_homogeneous_set(inst->cfg->cpumonitor.o_gadget_box, EINA_TRUE);
elm_box_horizontal_set(inst->cfg->cpumonitor.o_gadget_box, EINA_TRUE);
E_EXPAND(inst->cfg->cpumonitor.o_gadget_box);
E_FILL(inst->cfg->cpumonitor.o_gadget_box);
elm_layout_content_set(inst->cfg->cpumonitor.o_gadget, "e.swallow.content", inst->cfg->cpumonitor.o_gadget_box);
evas_object_show(inst->cfg->cpumonitor.o_gadget_box);
E_LIST_HANDLER_APPEND(inst->cfg->cpumonitor.handlers, E_EVENT_SCREENSAVER_ON, _screensaver_on, inst);
E_LIST_HANDLER_APPEND(inst->cfg->cpumonitor.handlers, E_EVENT_SCREENSAVER_OFF, _screensaver_off, inst);
_cpumonitor_config_updated(inst);
return inst->cfg->cpumonitor.o_gadget;
}
static Config_Item *
_conf_item_get(int *id)
{
Config_Item *ci;
Eina_List *l;
if (*id > 0)
{
EINA_LIST_FOREACH(sysinfo_config->items, l, ci)
if (*id == ci->id && ci->esm == E_SYSINFO_MODULE_CPUMONITOR) return ci;
}
ci = E_NEW(Config_Item, 1);
if (*id != -1)
ci->id = eina_list_count(sysinfo_config->items) + 1;
else
ci->id = -1;
ci->esm = E_SYSINFO_MODULE_CPUMONITOR;
ci->cpumonitor.poll_interval = 32;
ci->cpumonitor.popup = NULL;
ci->cpumonitor.configure = NULL;
sysinfo_config->items = eina_list_append(sysinfo_config->items, ci);
return ci;
}
Evas_Object *
cpumonitor_create(Evas_Object *parent, int *id, E_Gadget_Site_Orient orient EINA_UNUSED)
{
Instance *inst;
inst = E_NEW(Instance, 1);
inst->cfg = _conf_item_get(id);
*id = inst->cfg->id;
inst->cfg->cpumonitor.popup = NULL;
inst->cfg->cpumonitor.configure = NULL;
inst->o_main = elm_box_add(parent);
evas_object_data_set(inst->o_main, "Instance", inst);
evas_object_smart_callback_add(parent, "gadget_created", _cpumonitor_created_cb, inst);
evas_object_smart_callback_add(parent, "gadget_removed", _cpumonitor_removed_cb, inst);
evas_object_event_callback_add(inst->o_main, EVAS_CALLBACK_DEL, sysinfo_cpumonitor_remove, inst);
evas_object_show(inst->o_main);
if (inst->cfg->id < 0) return inst->o_main;
sysinfo_instances =
eina_list_append(sysinfo_instances, inst);
return inst->o_main;
}

12
src/modules/sysinfo/cpumonitor/cpumonitor.h
View File

@ -1,12 +0,0 @@
#ifndef CPUMONITOR_H
#define CPUMONITOR_H
#include "../sysinfo.h"
EINTERN void _cpumonitor_config_updated(Instance *inst);
EINTERN int _cpumonitor_proc_getcores(void);
EINTERN void _cpumonitor_proc_getusage(unsigned long *prev_total, unsigned long *prev_idle, int *prev_precent, Eina_List *cores);
EINTERN int _cpumonitor_sysctl_getcores(void);
EINTERN void _cpumonitor_sysctl_getusage(unsigned long *prev_total, unsigned long *prev_idle, int *prev_precent, Eina_List *cores);
EINTERN Evas_Object *cpumonitor_configure(Instance *inst);
#endif

171
src/modules/sysinfo/cpumonitor/cpumonitor_config.c
View File

@ -1,171 +0,0 @@
#include "cpumonitor.h"
static void
_config_close(void *data, Evas *e EINA_UNUSED, Evas_Object *obj EINA_UNUSED, void *event_info EINA_UNUSED)
{
Instance *inst = data;
E_FREE_FUNC(inst->cfg->cpumonitor.configure, evas_object_del);
e_config_save_queue();
}
static void
_config_changed(void *data, Evas_Object *obj, void *event_info EINA_UNUSED)
{
Instance *inst = data;
int value = elm_radio_value_get(obj);
switch (value)
{
case 0:
inst->cfg->cpumonitor.poll_interval = 4;
break;
case 1:
inst->cfg->cpumonitor.poll_interval = 8;
break;
case 2:
inst->cfg->cpumonitor.poll_interval = 32;
break;
case 3:
inst->cfg->cpumonitor.poll_interval = 64;
break;
case 4:
inst->cfg->cpumonitor.poll_interval = 256;
break;
default:
inst->cfg->cpumonitor.poll_interval = 32;
}
e_config_save_queue();
_cpumonitor_config_updated(inst);
}
Evas_Object *
cpumonitor_configure(Instance *inst)
{
Evas_Object *popup, *frame, *box, *o, *group, *lbl;
E_Zone *zone = e_zone_current_get();
popup = elm_popup_add(e_comp->elm);
E_EXPAND(popup);
elm_popup_allow_events_set(popup, 1);
elm_popup_scrollable_set(popup, 1);
box = elm_box_add(popup);
elm_box_horizontal_set(box, EINA_FALSE);
E_EXPAND(box);
E_FILL(box);
evas_object_show(box);
elm_object_content_set(popup, box);
lbl = elm_label_add(box);
evas_object_size_hint_weight_set(lbl, EVAS_HINT_EXPAND, 0.0);
evas_object_size_hint_align_set(lbl, EVAS_HINT_FILL, EVAS_HINT_FILL);
elm_object_style_set(lbl, "marker");
elm_object_text_set(lbl, _("CpuMonitor Configuration"));
elm_box_pack_end(box, lbl);
evas_object_show(lbl);
frame = elm_frame_add(box);
elm_object_text_set(frame, _("Update Poll Interval"));
E_EXPAND(frame);
E_FILL(frame);
elm_box_pack_end(box, frame);
evas_object_show(frame);
box = elm_box_add(popup);
elm_box_horizontal_set(box, EINA_FALSE);
E_EXPAND(box);
evas_object_show(box);
o = elm_radio_add(box);
elm_radio_state_value_set(o, 0);
E_EXPAND(o);
E_ALIGN(o, 0, 0);
elm_object_text_set(o, _("Fast (4 ticks)"));
elm_box_pack_end(box, o);
evas_object_smart_callback_add(o, "changed", _config_changed, inst);
evas_object_show(o);
group = o;
o = elm_radio_add(box);
elm_radio_state_value_set(o, 1);
elm_radio_group_add(o, group);
E_EXPAND(o);
E_ALIGN(o, 0, 0);
elm_object_text_set(o, _("Medium (8 ticks)"));
elm_box_pack_end(box, o);
evas_object_smart_callback_add(o, "changed", _config_changed, inst);
evas_object_show(o);
o = elm_radio_add(box);
elm_radio_state_value_set(o, 2);
elm_radio_group_add(o, group);
E_EXPAND(o);
E_ALIGN(o, 0, 0);
elm_object_text_set(o, _("Normal (32 ticks)"));
elm_box_pack_end(box, o);
evas_object_smart_callback_add(o, "changed", _config_changed, inst);
evas_object_show(o);
o = elm_radio_add(box);
elm_radio_state_value_set(o, 3);
elm_radio_group_add(o, group);
E_ALIGN(o, 0, 0);
elm_object_text_set(o, _("Slow (64 ticks)"));
elm_box_pack_end(box, o);
evas_object_smart_callback_add(o, "changed", _config_changed, inst);
evas_object_show(o);
o = elm_radio_add(box);
elm_radio_state_value_set(o, 4);
elm_radio_group_add(o, group);
E_EXPAND(o);
E_ALIGN(o, 0, 0);
elm_object_text_set(o, _("Very Slow (256 ticks)"));
elm_box_pack_end(box, o);
evas_object_smart_callback_add(o, "changed", _config_changed, inst);
evas_object_show(o);
switch (inst->cfg->cpumonitor.poll_interval)
{
case 4:
elm_radio_value_set(group, 0);
break;
case 8:
elm_radio_value_set(group, 1);
break;
case 32:
elm_radio_value_set(group, 2);
break;
case 64:
elm_radio_value_set(group, 3);
break;
case 256:
elm_radio_value_set(group, 4);
break;
default:
elm_radio_value_set(group, 2);
}
elm_object_content_set(frame, box);
popup = e_comp_object_util_add(popup, E_COMP_OBJECT_TYPE_NONE);
evas_object_layer_set(popup, E_LAYER_POPUP);
evas_object_resize(popup, zone->w / 4, zone->h / 3);
e_comp_object_util_center_on_zone(popup, zone);
evas_object_show(popup);
e_comp_object_util_autoclose(popup, NULL, e_comp_object_util_autoclose_on_escape, NULL);
evas_object_event_callback_add(popup, EVAS_CALLBACK_DEL, _config_close, inst);
return inst->cfg->cpumonitor.configure = popup;
}

114
src/modules/sysinfo/cpumonitor/cpumonitor_proc.c
View File

@ -1,114 +0,0 @@
#include "cpumonitor.h"
int
_cpumonitor_proc_getcores(void)
{
char buf[4096], *tok;
FILE *f;
int cores = 0, i = 0;
f = fopen("/proc/stat", "r");
if (f)
{
while (fgets(buf, sizeof(buf), f))
{
if (i > 0)
{
tok = strtok(buf, " ");
if (!strncmp(tok, "cpu", 3))
cores++;
else
break;
}
i++;
}
fclose(f);
}
return cores;
}
void
_cpumonitor_proc_getusage(unsigned long *prev_total,
unsigned long *prev_idle,
int *prev_percent,
Eina_List *cores)
{
int k = 0, j = 0;
char buf[4096];
FILE *f;
CPU_Core *core;
f = fopen("/proc/stat", "r");
if (f)
{
while (fgets(buf, sizeof(buf), f))
{
if (k == 0)
{
unsigned long total = 0, idle = 0, use = 0, total_change = 0, idle_change = 0;
int percent = 0;
char *line, *tok;
int i = 0;
line = strchr(buf, ' ') + 1;
tok = strtok(line, " ");
while (tok)
{
use = atol(tok);
total += use;
i++;
if (i == 4)
idle = use;
tok = strtok(NULL, " ");
}
total_change = total - *prev_total;
idle_change = idle - *prev_idle;
if (total_change != 0)
percent = 100 * (1 - ((float)idle_change / (float)total_change));
if (percent > 100) percent = 100;
else if (percent < 0)
percent = 0;
*prev_total = total;
*prev_idle = idle;
*prev_percent = percent;
}
if (k > 0)
{
unsigned long total = 0, idle = 0, use = 0, total_change = 0, idle_change = 0;
int percent = 0;
if (!strncmp(buf, "cpu", 3))
{
char *line, *tok;
int i = 0;
line = strchr(buf, ' ');
tok = strtok(line, " ");
while (tok)
{
use = atol(tok);
total += use;
i++;
if (i == 4)
idle = use;
tok = strtok(NULL, " ");
}
}
else break;
core = eina_list_nth(cores, j);
total_change = total - core->total;
idle_change = idle - core->idle;
if (total_change != 0)
percent = 100 * (1 - ((float)idle_change / (float)total_change));
if (percent > 100) percent = 100;
else if (percent < 0)
percent = 0;
core->percent = percent;
core->total = total;
core->idle = idle;
j++;
}
k++;
}
fclose(f);
}
}

125
src/modules/sysinfo/cpumonitor/cpumonitor_sysctl.c
View File

@ -1,125 +0,0 @@
#include "cpumonitor.h"
#if defined(__FreeBSD__) || defined (__DragonFly__)
# include <sys/types.h>
# include <sys/sysctl.h>
# define CPU_STATES 5
#endif
#if defined(__OpenBSD__)
# include <sys/sched.h>
# include <sys/sysctl.h>
# define CPU_STATES 6
#endif
int
_cpumonitor_sysctl_getcores(void)
{
int cores = 0;
#if defined(__FreeBSD__) || defined(__DragonFly__) || defined(__OpenBSD__)
size_t len;
int mib[2] = { CTL_HW, HW_NCPU };
len = sizeof(cores);
if (sysctl(mib, 2, &cores, &len, NULL, 0) < 0) return 0;
#endif
return cores;
}
void
_cpumonitor_sysctl_getusage(unsigned long *prev_total, unsigned long *prev_idle, int *prev_percent, Eina_List *cores)
{
CPU_Core *core;
size_t size;
unsigned long percent_all = 0, total_all = 0, idle_all = 0;
int i, j;
#if defined(__FreeBSD__) || defined(__DragonFly__)
int ncpu = _cpumonitor_sysctl_getcores();
if (!ncpu) return;
size = sizeof(unsigned long) * (CPU_STATES * ncpu);
unsigned long cpu_times[ncpu][CPU_STATES];
if (sysctlbyname("kern.cp_times", cpu_times, &size, NULL, 0) < 0)
return;
for (i = 0; i < ncpu; i++)
{
unsigned long *cpu = cpu_times[i];
double total = 0;
for (j = 0; j < CPU_STATES; j++)
total += cpu[j];
core = eina_list_nth(cores, i);
int diff_total = total - core->total;
int diff_idle = cpu[4] - core->idle;
if (diff_total == 0) diff_total = 1;
double ratio = diff_total / 100.0;
unsigned long used = diff_total - diff_idle;
int percent = used / ratio;
if (percent > 100)
percent = 100;
else if (percent < 0)
percent = 0;
core->percent = percent;
core->total = total;
core->idle = cpu[4];
percent_all += (int)percent;
total_all += total;
idle_all += core->idle;
}
*prev_total = total_all / ncpu;
*prev_idle = idle_all / ncpu;
*prev_percent = (int)(percent_all / ncpu);
#elif defined(__OpenBSD__)
int ncpu = _cpumonitor_sysctl_getcores();
struct cpustats cpu_times[CPU_STATES];
memset(&cpu_times, 0, CPU_STATES * sizeof(struct cpustats));
if (!ncpu) return;
for (i = 0; i < ncpu; i++)
{
unsigned long total = 0, idle;
int diff_total, diff_idle;
int cpu_time_mib[] = { CTL_KERN, KERN_CPUSTATS, 0 };
size = sizeof(struct cpustats);
cpu_time_mib[2] = i;
if (sysctl(cpu_time_mib, 3, &cpu_times[i], &size, NULL, 0) < 0)
return;
for (j = 0; j < CPU_STATES; j++)
total += cpu_times[i].cs_time[j];
idle = cpu_times[i].cs_time[CP_IDLE];
core = eina_list_nth(cores, i);
diff_total = total - core->total;
diff_idle = idle - core->idle;
core->total = total;
core->idle = idle;
if (diff_total == 0) diff_total = 1;
double ratio = diff_total / 100;
unsigned long used = diff_total - diff_idle;
int percent = used / ratio;
core->percent = percent;
percent_all += (int)percent;
total_all += total;
idle_all += core->idle;
*prev_total = (total_all / ncpu);
*prev_idle = (idle_all / ncpu);
*prev_percent = (percent_all / ncpu) + (percent_all % ncpu);
}
#endif
}

BIN
src/modules/sysinfo/e-module-sysinfo.edj
View File

Binary file not shown.

586
src/modules/sysinfo/memusage/memusage.c
View File

@ -1,586 +0,0 @@
#include "memusage.h"
typedef struct _Thread_Config Thread_Config;
struct _Thread_Config
{
int interval;
Instance *inst;
int mem_percent;
int swp_percent;
unsigned long mem_total;
unsigned long mem_used;
unsigned long mem_cached;
unsigned long mem_buffers;
unsigned long mem_shared;
unsigned long swp_total;
unsigned long swp_used;
E_Powersave_Sleeper *sleeper;
};
static void
_memusage_popup_update(Instance *inst)
{
Evas_Object *pbar;
int val_mb, val_perc;
char buf[128];
if (!inst->cfg->memusage.popup)
return;
if (inst->cfg->memusage.mem_total)
{
pbar = evas_object_data_get(inst->cfg->memusage.popup, "mem_used_pbar");
val_mb = inst->cfg->memusage.mem_used / 1024;
val_perc = 100 * ((float)inst->cfg->memusage.mem_used /
(float)inst->cfg->memusage.mem_total);
snprintf(buf, sizeof(buf), "%d MB (%d %%%%)", val_mb, val_perc);
elm_progressbar_unit_format_set(pbar, buf);
elm_progressbar_value_set(pbar, (float)val_perc / 100);
pbar = evas_object_data_get(inst->cfg->memusage.popup, "mem_buffers_pbar");
val_mb = inst->cfg->memusage.mem_buffers / 1024;
val_perc = 100 * ((float)inst->cfg->memusage.mem_buffers /
(float)inst->cfg->memusage.mem_total);
snprintf(buf, sizeof(buf), "%d MB (%d %%%%)", val_mb, val_perc);
elm_progressbar_unit_format_set(pbar, buf);
elm_progressbar_value_set(pbar, (float)val_perc / 100);
pbar = evas_object_data_get(inst->cfg->memusage.popup, "mem_cached_pbar");
val_mb = inst->cfg->memusage.mem_cached / 1024;
val_perc = 100 * ((float)inst->cfg->memusage.mem_cached /
(float)inst->cfg->memusage.mem_total);
snprintf(buf, sizeof(buf), "%d MB (%d %%%%)", val_mb, val_perc);
elm_progressbar_unit_format_set(pbar, buf);
elm_progressbar_value_set(pbar, (float)val_perc / 100);
pbar = evas_object_data_get(inst->cfg->memusage.popup, "mem_shared_pbar");
val_mb = inst->cfg->memusage.mem_shared / 1024;
val_perc = 100 * ((float)inst->cfg->memusage.mem_shared /
(float)inst->cfg->memusage.mem_total);
snprintf(buf, sizeof(buf), "%d MB (%d %%%%)", val_mb, val_perc);
elm_progressbar_unit_format_set(pbar, buf);
elm_progressbar_value_set(pbar, (float)val_perc / 100);
}
if (inst->cfg->memusage.swp_total)
{
pbar = evas_object_data_get(inst->cfg->memusage.popup, "swap_pbar");
val_mb = inst->cfg->memusage.swp_used / 1024;
val_perc = 100 * ((float)inst->cfg->memusage.swp_used /
(float)inst->cfg->memusage.swp_total);
snprintf(buf, sizeof(buf), "%d MB (%d %%%%)", val_mb, val_perc);
elm_progressbar_unit_format_set(pbar, buf);
elm_progressbar_value_set(pbar, (float)val_perc / 100);
}
}
static void
_memusage_face_update(Instance *inst)
{
Edje_Message_Int_Set *msg;
msg = malloc(sizeof(Edje_Message_Int_Set) + 9 * sizeof(int));
EINA_SAFETY_ON_NULL_RETURN(msg);
msg->count = 2;
msg->val[0] = inst->cfg->memusage.mem_percent;
msg->val[1] = inst->cfg->memusage.swp_percent;
msg->val[2] = inst->cfg->memusage.mem_total;
msg->val[3] = inst->cfg->memusage.mem_used;
msg->val[4] = inst->cfg->memusage.mem_cached;
msg->val[5] = inst->cfg->memusage.mem_buffers;
msg->val[6] = inst->cfg->memusage.mem_shared;
msg->val[7] = inst->cfg->memusage.swp_total;
msg->val[8] = inst->cfg->memusage.swp_used;
edje_object_message_send(elm_layout_edje_get(inst->cfg->memusage.o_gadget),
EDJE_MESSAGE_INT_SET, 1, msg);
E_FREE(msg);
if (inst->cfg->memusage.popup)
_memusage_popup_update(inst);
}
static Evas_Object *
_memusage_configure_cb(Evas_Object *g)
{
Instance *inst = evas_object_data_get(g, "Instance");
if (!sysinfo_config) return NULL;
return memusage_configure(inst);
}
static void
_memusage_popup_dismissed(void *data, Evas_Object *obj, void *event_info EINA_UNUSED)
{
Instance *inst = data;
E_FREE_FUNC(obj, evas_object_del);
inst->cfg->memusage.popup = NULL;
}
static void
_memusage_popup_deleted(void *data, Evas *e EINA_UNUSED, Evas_Object *obj EINA_UNUSED, void *event_info EINA_UNUSED)
{
Instance *inst = data;
inst->cfg->memusage.popup = NULL;
}
static Evas_Object *
_memusage_popup_create(Instance *inst)
{
Evas_Object *popup, *table, *label, *pbar;
char buf[128], buf2[128 + 100];
popup = elm_ctxpopup_add(e_comp->elm);
elm_object_style_set(popup, "noblock");
evas_object_smart_callback_add(popup, "dismissed",
_memusage_popup_dismissed, inst);
evas_object_event_callback_add(popup, EVAS_CALLBACK_DEL,
_memusage_popup_deleted, inst);
table = elm_table_add(popup);
E_EXPAND(table);
E_FILL(table);
elm_object_content_set(popup, table);
evas_object_show(table);
snprintf(buf, sizeof(buf), _("Memory Usage (Available %ld MB)"),
inst->cfg->memusage.mem_total / 1024);
snprintf(buf2, sizeof(buf2), "<big><b>%s</b></big>", buf);
label = elm_label_add(table);
E_EXPAND(label); E_ALIGN(label, 0.5, 0.5);
elm_object_text_set(label, buf2);
elm_table_pack(table, label, 0, 0, 2, 1);
evas_object_show(label);
label = elm_label_add(table);
E_ALIGN(label, 0.0, 0.5);
elm_object_text_set(label, _("Used"));
elm_table_pack(table, label, 0, 1, 1, 1);
evas_object_show(label);
pbar = elm_progressbar_add(table);
E_EXPAND(pbar);
E_FILL(pbar);
elm_progressbar_span_size_set(pbar, 200 * e_scale);
elm_table_pack(table, pbar, 1, 1, 1, 1);
evas_object_show(pbar);
evas_object_data_set(popup, "mem_used_pbar", pbar);
label = elm_label_add(table);
E_ALIGN(label, 0.0, 0.5);
elm_object_text_set(label, _("Buffers"));
elm_table_pack(table, label, 0, 2, 1, 1);
evas_object_show(label);
pbar = elm_progressbar_add(table);
E_EXPAND(pbar);
E_FILL(pbar);
elm_progressbar_span_size_set(pbar, 200 * e_scale);
elm_table_pack(table, pbar, 1, 2, 1, 1);
evas_object_show(pbar);
evas_object_data_set(popup, "mem_buffers_pbar", pbar);
label = elm_label_add(table);
E_ALIGN(label, 0.0, 0.5);
elm_object_text_set(label, _("Cached"));
elm_table_pack(table, label, 0, 3, 1, 1);
evas_object_show(label);
pbar = elm_progressbar_add(table);
E_EXPAND(pbar);
E_FILL(pbar);
elm_progressbar_span_size_set(pbar, 200 * e_scale);
elm_table_pack(table, pbar, 1, 3, 1, 1);
evas_object_show(pbar);
evas_object_data_set(popup, "mem_cached_pbar", pbar);
label = elm_label_add(table);
E_ALIGN(label, 0.0, 0.5);
elm_object_text_set(label, _("Shared"));
elm_table_pack(table, label, 0, 4, 1, 1);
evas_object_show(label);
pbar = elm_progressbar_add(table);
E_EXPAND(pbar);
E_FILL(pbar);
elm_progressbar_span_size_set(pbar, 200 * e_scale);
elm_table_pack(table, pbar, 1, 4, 1, 1);
evas_object_show(pbar);
evas_object_data_set(popup, "mem_shared_pbar", pbar);
snprintf(buf, sizeof(buf), _("Swap Usage (Available %ld MB)"),
inst->cfg->memusage.swp_total / 1024);
snprintf(buf2, sizeof(buf2), "<big><b>%s</b></big>", buf);
label = elm_label_add(table);
E_EXPAND(label);
E_ALIGN(label, 0.5, 0.5);
elm_object_text_set(label, buf2);
elm_table_pack(table, label, 0, 5, 2, 1);
evas_object_show(label);
pbar = elm_progressbar_add(table);
E_EXPAND(pbar);
E_FILL(pbar);
elm_table_pack(table, pbar, 0, 6, 2, 1);
evas_object_show(pbar);
evas_object_data_set(popup, "swap_pbar", pbar);
// place and show the popup
e_gadget_util_ctxpopup_place(inst->o_main, popup,
inst->cfg->memusage.o_gadget);
evas_object_show(popup);
return popup;
}
static void
_memusage_mouse_up_cb(void *data, Evas *e EINA_UNUSED, Evas_Object *obj EINA_UNUSED, void *event_data)
{
Evas_Event_Mouse_Up *ev = event_data;
Instance *inst = data;
if (ev->event_flags & EVAS_EVENT_FLAG_ON_HOLD) return;
if (ev->button == 1)
{
if (inst->cfg->memusage.popup)
elm_ctxpopup_dismiss(inst->cfg->memusage.popup);
else
{
inst->cfg->memusage.popup = _memusage_popup_create(inst);
_memusage_popup_update(inst);
}
}
}
static void
_memusage_resize_cb(void *data, Evas *e EINA_UNUSED, Evas_Object *obj EINA_UNUSED, void *event_data EINA_UNUSED)
{
Evas_Coord w, h;
Instance *inst = data;
edje_object_parts_extends_calc(elm_layout_edje_get(inst->cfg->memusage.o_gadget),
0, 0, &w, &h);
if (w < 1) w = 1;
if (h < 1) h = 1;
if (inst->cfg->esm == E_SYSINFO_MODULE_MEMUSAGE)
evas_object_size_hint_aspect_set(inst->o_main,
EVAS_ASPECT_CONTROL_BOTH, w, h);
else
evas_object_size_hint_aspect_set(inst->cfg->memusage.o_gadget,
EVAS_ASPECT_CONTROL_BOTH, w, h);
}
static void
_memusage_cb_usage_check_main(void *data, Ecore_Thread *th)
{
Thread_Config *thc = data;
for (;; )
{
if (ecore_thread_check(th)) break;
#if defined(__OpenBSD__) || defined(__FreeBSD__) || defined(__DragonFly__)
_memusage_sysctl_getusage(&thc->mem_total, &thc->mem_used,
&thc->mem_cached, &thc->mem_buffers, &thc->mem_shared,
&thc->swp_total, &thc->swp_used);
#else
_memusage_proc_getusage(&thc->mem_total, &thc->mem_used,
&thc->mem_cached, &thc->mem_buffers, &thc->mem_shared,
&thc->swp_total, &thc->swp_used);
#endif
if (thc->mem_total > 0)
thc->mem_percent = 100 * ((float)thc->mem_used / (float)thc->mem_total);
if (thc->swp_total > 0)
thc->swp_percent = 100 * ((float)thc->swp_used / (float)thc->swp_total);
ecore_thread_feedback(th, NULL);
if (ecore_thread_check(th)) break;
e_powersave_sleeper_sleep(thc->sleeper, thc->interval);
if (ecore_thread_check(th)) break;
}
}
static void
_memusage_cb_usage_check_end(void *data, Ecore_Thread *th EINA_UNUSED)
{
Thread_Config *thc = data;
e_powersave_sleeper_free(thc->sleeper);
E_FREE(thc);
}
static void
_memusage_cb_usage_check_notify(void *data,
Ecore_Thread *th EINA_UNUSED,
void *msg EINA_UNUSED)
{
Thread_Config *thc = data;
if (!thc->inst->cfg) return;
if (thc->inst->cfg->esm != E_SYSINFO_MODULE_MEMUSAGE &&
thc->inst->cfg->esm != E_SYSINFO_MODULE_SYSINFO) return;
thc->inst->cfg->memusage.mem_percent = thc->mem_percent;
thc->inst->cfg->memusage.swp_percent = thc->swp_percent;
thc->inst->cfg->memusage.mem_total = thc->mem_total;
thc->inst->cfg->memusage.mem_used = thc->mem_used;
thc->inst->cfg->memusage.mem_cached = thc->mem_cached;
thc->inst->cfg->memusage.mem_buffers = thc->mem_buffers;
thc->inst->cfg->memusage.mem_shared = thc->mem_shared;
thc->inst->cfg->memusage.swp_total = thc->swp_total;
thc->inst->cfg->memusage.swp_used = thc->swp_used;
_memusage_face_update(thc->inst);
}
static Eina_Bool
_screensaver_on(void *data)
{
Instance *inst = data;
if (inst->cfg->memusage.usage_check_thread)
{
ecore_thread_cancel(inst->cfg->memusage.usage_check_thread);
inst->cfg->memusage.usage_check_thread = NULL;
}
return ECORE_CALLBACK_RENEW;
}
static Eina_Bool
_screensaver_off(void *data)
{
Instance *inst = data;
_memusage_config_updated(inst);
return ECORE_CALLBACK_RENEW;
}
void
_memusage_config_updated(Instance *inst)
{
Thread_Config *thc;
if (inst->cfg->id == -1)
{
inst->cfg->memusage.mem_percent = 75;
inst->cfg->memusage.swp_percent = 30;
_memusage_face_update(inst);
return;
}
if (inst->cfg->memusage.usage_check_thread)
{
ecore_thread_cancel(inst->cfg->memusage.usage_check_thread);
inst->cfg->memusage.usage_check_thread = NULL;
}
thc = E_NEW(Thread_Config, 1);
if (thc)
{
thc->inst = inst;
thc->sleeper = e_powersave_sleeper_new();
thc->interval = inst->cfg->memusage.poll_interval;
thc->mem_percent = 0;
thc->swp_percent = 0;
inst->cfg->memusage.usage_check_thread =
ecore_thread_feedback_run(_memusage_cb_usage_check_main,
_memusage_cb_usage_check_notify,
_memusage_cb_usage_check_end,
_memusage_cb_usage_check_end, thc, EINA_TRUE);
}
e_config_save_queue();
}
static void
_memusage_removed_cb(void *data, Evas_Object *obj EINA_UNUSED, void *event_data)
{
Instance *inst = data;
Ecore_Event_Handler *handler;
if (inst->o_main != event_data) return;
if (inst->cfg->memusage.popup)
E_FREE_FUNC(inst->cfg->memusage.popup, evas_object_del);
if (inst->cfg->memusage.configure)
E_FREE_FUNC(inst->cfg->memusage.configure, evas_object_del);
evas_object_smart_callback_del_full(e_gadget_site_get(inst->o_main), "gadget_removed",
_memusage_removed_cb, inst);
evas_object_event_callback_del_full(inst->o_main, EVAS_CALLBACK_DEL,
sysinfo_memusage_remove, data);
EINA_LIST_FREE(inst->cfg->memusage.handlers, handler)
ecore_event_handler_del(handler);
if (inst->cfg->memusage.usage_check_thread)
{
ecore_thread_cancel(inst->cfg->memusage.usage_check_thread);
inst->cfg->memusage.usage_check_thread = NULL;
}
sysinfo_config->items = eina_list_remove(sysinfo_config->items, inst->cfg);
if (inst->cfg->id >= 0)
sysinfo_instances = eina_list_remove(sysinfo_instances, inst);
E_FREE(inst->cfg);
E_FREE(inst);
}
void
sysinfo_memusage_remove(void *data, Evas *e EINA_UNUSED, Evas_Object *obj EINA_UNUSED, void *event_data EINA_UNUSED)
{
Instance *inst = data;
Ecore_Event_Handler *handler;
if (inst->cfg->memusage.popup)
E_FREE_FUNC(inst->cfg->memusage.popup, evas_object_del);
if (inst->cfg->memusage.configure)
E_FREE_FUNC(inst->cfg->memusage.configure, evas_object_del);
if (inst->cfg->memusage.usage_check_thread)
{
ecore_thread_cancel(inst->cfg->memusage.usage_check_thread);
inst->cfg->memusage.usage_check_thread = NULL;
}
EINA_LIST_FREE(inst->cfg->memusage.handlers, handler)
ecore_event_handler_del(handler);
}
static void
_memusage_created_cb(void *data, Evas_Object *obj, void *event_data EINA_UNUSED)
{
Instance *inst = data;
int orient = e_gadget_site_orient_get(e_gadget_site_get(inst->o_main));
e_gadget_configure_cb_set(inst->o_main, _memusage_configure_cb);
inst->cfg->memusage.o_gadget = elm_layout_add(inst->o_main);
if (orient == E_GADGET_SITE_ORIENT_VERTICAL)
e_theme_edje_object_set(inst->cfg->memusage.o_gadget,
"base/theme/gadget/memusage",
"e/gadget/memusage/main_vert");
else
e_theme_edje_object_set(inst->cfg->memusage.o_gadget,
"base/theme/gadget/memusage",
"e/gadget/memusage/main");
E_EXPAND(inst->cfg->memusage.o_gadget);
E_FILL(inst->cfg->memusage.o_gadget);
elm_box_pack_end(inst->o_main, inst->cfg->memusage.o_gadget);
evas_object_event_callback_add(inst->cfg->memusage.o_gadget,
EVAS_CALLBACK_MOUSE_UP,
_memusage_mouse_up_cb, inst);
evas_object_event_callback_add(inst->cfg->memusage.o_gadget,
EVAS_CALLBACK_RESIZE,
_memusage_resize_cb, inst);
evas_object_show(inst->cfg->memusage.o_gadget);
evas_object_smart_callback_del_full(obj, "gadget_created",
_memusage_created_cb, data);
E_LIST_HANDLER_APPEND(inst->cfg->memusage.handlers, E_EVENT_SCREENSAVER_ON, _screensaver_on, inst);
E_LIST_HANDLER_APPEND(inst->cfg->memusage.handlers, E_EVENT_SCREENSAVER_OFF, _screensaver_off, inst);
_memusage_config_updated(inst);
}
Evas_Object *
sysinfo_memusage_create(Evas_Object *parent, Instance *inst)
{
inst->cfg->memusage.mem_percent = 0;
inst->cfg->memusage.swp_percent = 0;
inst->cfg->memusage.mem_total = 0;
inst->cfg->memusage.mem_used = 0;
inst->cfg->memusage.mem_cached = 0;
inst->cfg->memusage.mem_buffers = 0;
inst->cfg->memusage.mem_shared = 0;
inst->cfg->memusage.swp_total = 0;
inst->cfg->memusage.swp_used = 0;
inst->cfg->memusage.popup = NULL;
inst->cfg->memusage.configure = NULL;
inst->cfg->memusage.o_gadget = elm_layout_add(parent);
e_theme_edje_object_set(inst->cfg->memusage.o_gadget,
"base/theme/gadget/memusage",
"e/gadget/memusage/main");
E_EXPAND(inst->cfg->memusage.o_gadget);
E_FILL(inst->cfg->memusage.o_gadget);
evas_object_event_callback_add(inst->cfg->memusage.o_gadget,
EVAS_CALLBACK_MOUSE_UP,
_memusage_mouse_up_cb, inst);
evas_object_event_callback_add(inst->cfg->memusage.o_gadget,
EVAS_CALLBACK_RESIZE,
_memusage_resize_cb, inst);
evas_object_show(inst->cfg->memusage.o_gadget);
E_LIST_HANDLER_APPEND(inst->cfg->memusage.handlers, E_EVENT_SCREENSAVER_ON, _screensaver_on, inst);
E_LIST_HANDLER_APPEND(inst->cfg->memusage.handlers, E_EVENT_SCREENSAVER_OFF, _screensaver_off, inst);
_memusage_config_updated(inst);
return inst->cfg->memusage.o_gadget;
}
static Config_Item *
_conf_item_get(int *id)
{
Config_Item *ci;
Eina_List *l;
if (*id > 0)
{
EINA_LIST_FOREACH(sysinfo_config->items, l, ci)
if (*id == ci->id && ci->esm == E_SYSINFO_MODULE_MEMUSAGE) return ci;
}
ci = E_NEW(Config_Item, 1);
if (*id != -1)
ci->id = eina_list_count(sysinfo_config->items) + 1;
else
ci->id = -1;
ci->esm = E_SYSINFO_MODULE_MEMUSAGE;
ci->memusage.poll_interval = 32;
ci->memusage.mem_percent = 0;
ci->memusage.swp_percent = 0;
ci->memusage.mem_total = 0;
ci->memusage.mem_used = 0;
ci->memusage.mem_cached = 0;
ci->memusage.mem_buffers = 0;
ci->memusage.mem_shared = 0;
ci->memusage.swp_total = 0;
ci->memusage.swp_used = 0;
ci->memusage.popup = NULL;
ci->memusage.configure = NULL;
sysinfo_config->items = eina_list_append(sysinfo_config->items, ci);
return ci;
}
Evas_Object *
memusage_create(Evas_Object *parent, int *id, E_Gadget_Site_Orient orient EINA_UNUSED)
{
Instance *inst;
inst = E_NEW(Instance, 1);
inst->cfg = _conf_item_get(id);
*id = inst->cfg->id;
inst->cfg->memusage.mem_percent = 0;
inst->cfg->memusage.swp_percent = 0;
inst->cfg->memusage.mem_total = 0;
inst->cfg->memusage.mem_used = 0;
inst->cfg->memusage.mem_cached = 0;
inst->cfg->memusage.mem_buffers = 0;
inst->cfg->memusage.mem_shared = 0;
inst->cfg->memusage.swp_total = 0;
inst->cfg->memusage.swp_used = 0;
inst->cfg->memusage.popup = NULL;
inst->cfg->memusage.configure = NULL;
inst->o_main = elm_box_add(parent);
evas_object_data_set(inst->o_main, "Instance", inst);
evas_object_smart_callback_add(parent, "gadget_created",
_memusage_created_cb, inst);
evas_object_smart_callback_add(parent, "gadget_removed",
_memusage_removed_cb, inst);
evas_object_event_callback_add(inst->o_main, EVAS_CALLBACK_DEL,
sysinfo_memusage_remove, inst);
evas_object_show(inst->o_main);
if (inst->cfg->id < 0) return inst->o_main;
sysinfo_instances = eina_list_append(sysinfo_instances, inst);
return inst->o_main;
}

25
src/modules/sysinfo/memusage/memusage.h
View File

@ -1,25 +0,0 @@
#ifndef MEMUSAGE_H
#define MEMUSAGE_H
#include "../sysinfo.h"
EINTERN void _memusage_config_updated(Instance *inst);
EINTERN Evas_Object *memusage_configure(Instance *inst);
EINTERN void _memusage_proc_getusage(unsigned long *mem_total,
unsigned long *mem_used,
unsigned long *mem_cached,
unsigned long *mem_buffers,
unsigned long *mem_shared,
unsigned long *swp_total,
unsigned long *swp_used);
EINTERN void _memusage_sysctl_getusage(unsigned long *mem_total,
unsigned long *mem_used,
unsigned long *mem_cached,
unsigned long *mem_buffers,
unsigned long *mem_shared,
unsigned long *swp_total,
unsigned long *swp_used);
#endif

171
src/modules/sysinfo/memusage/memusage_config.c
View File

@ -1,171 +0,0 @@
#include "memusage.h"
static void
_config_close(void *data, Evas *e EINA_UNUSED, Evas_Object *obj EINA_UNUSED, void *event_info EINA_UNUSED)
{
Instance *inst = data;
E_FREE_FUNC(inst->cfg->memusage.configure, evas_object_del);
e_config_save_queue();
}
static void
_config_changed(void *data, Evas_Object *obj, void *event_info EINA_UNUSED)
{
Instance *inst = data;
int value = elm_radio_value_get(obj);
switch (value)
{
case 0:
inst->cfg->memusage.poll_interval = 4;
break;
case 1:
inst->cfg->memusage.poll_interval = 8;
break;
case 2:
inst->cfg->memusage.poll_interval = 32;
break;
case 3:
inst->cfg->memusage.poll_interval = 64;
break;
case 4:
inst->cfg->memusage.poll_interval = 256;
break;
default:
inst->cfg->memusage.poll_interval = 32;
}
e_config_save_queue();
_memusage_config_updated(inst);
}
Evas_Object *
memusage_configure(Instance *inst)
{
Evas_Object *popup, *frame, *box, *o, *group, *lbl;
E_Zone *zone = e_zone_current_get();
popup = elm_popup_add(e_comp->elm);
E_EXPAND(popup);
elm_popup_allow_events_set(popup, 1);
elm_popup_scrollable_set(popup, 1);
box = elm_box_add(popup);
elm_box_horizontal_set(box, EINA_FALSE);
E_EXPAND(box);
E_FILL(box);
evas_object_show(box);
elm_object_content_set(popup, box);
lbl = elm_label_add(box);
evas_object_size_hint_weight_set(lbl, EVAS_HINT_EXPAND, 0.0);
evas_object_size_hint_align_set(lbl, EVAS_HINT_FILL, EVAS_HINT_FILL);
elm_object_style_set(lbl, "marker");
elm_object_text_set(lbl, _("MemUsage Configuration"));
elm_box_pack_end(box, lbl);
evas_object_show(lbl);
frame = elm_frame_add(box);
elm_object_text_set(frame, _("Update Poll Interval"));
E_EXPAND(frame);
E_FILL(frame);
elm_box_pack_end(box, frame);
evas_object_show(frame);
box = elm_box_add(popup);
elm_box_horizontal_set(box, EINA_FALSE);
E_EXPAND(box);
evas_object_show(box);
o = elm_radio_add(box);
elm_radio_state_value_set(o, 0);
E_EXPAND(o);
E_ALIGN(o, 0, 0);
elm_object_text_set(o, _("Fast (4 ticks)"));
elm_box_pack_end(box, o);
evas_object_smart_callback_add(o, "changed", _config_changed, inst);
evas_object_show(o);
group = o;
o = elm_radio_add(box);
elm_radio_state_value_set(o, 1);
elm_radio_group_add(o, group);
E_EXPAND(o);
E_ALIGN(o, 0, 0);
elm_object_text_set(o, _("Medium (8 ticks)"));
elm_box_pack_end(box, o);
evas_object_smart_callback_add(o, "changed", _config_changed, inst);
evas_object_show(o);
o = elm_radio_add(box);
elm_radio_state_value_set(o, 2);
elm_radio_group_add(o, group);
E_EXPAND(o);
E_ALIGN(o, 0, 0);
elm_object_text_set(o, _("Normal (32 ticks)"));
elm_box_pack_end(box, o);
evas_object_smart_callback_add(o, "changed", _config_changed, inst);
evas_object_show(o);
o = elm_radio_add(box);
elm_radio_state_value_set(o, 3);
elm_radio_group_add(o, group);
E_ALIGN(o, 0, 0);
elm_object_text_set(o, _("Slow (64 ticks)"));
elm_box_pack_end(box, o);
evas_object_smart_callback_add(o, "changed", _config_changed, inst);
evas_object_show(o);
o = elm_radio_add(box);
elm_radio_state_value_set(o, 4);
elm_radio_group_add(o, group);
E_EXPAND(o);
E_ALIGN(o, 0, 0);
elm_object_text_set(o, _("Very Slow (256 ticks)"));
elm_box_pack_end(box, o);
evas_object_smart_callback_add(o, "changed", _config_changed, inst);
evas_object_show(o);
switch (inst->cfg->memusage.poll_interval)
{
case 4:
elm_radio_value_set(group, 0);
break;
case 8:
elm_radio_value_set(group, 1);
break;
case 32:
elm_radio_value_set(group, 2);
break;
case 64:
elm_radio_value_set(group, 3);
break;
case 256:
elm_radio_value_set(group, 4);
break;
default:
elm_radio_value_set(group, 2);
}
elm_object_content_set(frame, box);
popup = e_comp_object_util_add(popup, E_COMP_OBJECT_TYPE_NONE);
evas_object_layer_set(popup, E_LAYER_POPUP);
evas_object_resize(popup, zone->w / 4, zone->h / 3);
e_comp_object_util_center_on_zone(popup, zone);
evas_object_show(popup);
e_comp_object_util_autoclose(popup, NULL, e_comp_object_util_autoclose_on_escape, NULL);
evas_object_event_callback_add(popup, EVAS_CALLBACK_DEL, _config_close, inst);
return inst->cfg->memusage.configure = popup;
}

98
src/modules/sysinfo/memusage/memusage_proc.c
View File

@ -1,98 +0,0 @@
#include "memusage.h"
unsigned long
_line_parse(const char *line)
{
char *p, *tok;
p = strchr(line, ':') + 1;
while (isspace(*p))
p++;
tok = strtok(p, " ");
return atol(tok);
}
void
_memusage_proc_getusage(unsigned long *mem_total,
unsigned long *mem_used,
unsigned long *mem_cached,
unsigned long *mem_buffers,
unsigned long *mem_shared,
unsigned long *swp_total,
unsigned long *swp_used)
{
char line[256];
int found = 0;
unsigned long tmp_swp_total = 0;
unsigned long tmp_swp_free = 0;
unsigned long tmp_mem_free = 0;
unsigned long tmp_mem_cached = 0;
unsigned long tmp_mem_slab = 0;
FILE *f;
*mem_total = 0;
*mem_used = 0;
*mem_cached = 0;
*mem_buffers = 0;
*mem_shared = 0;
*swp_total = 0;
*swp_used = 0;
f = fopen("/proc/meminfo", "r");
if (!f) return;
while (fgets(line, sizeof(line), f) != NULL)
{
if (!strncmp("MemTotal:", line, 9))
{
*mem_total = _line_parse(line);
found++;
}
else if (!strncmp("MemFree:", line, 8))
{
tmp_mem_free = _line_parse(line);
found++;
}
else if (!strncmp("Cached:", line, 7))
{
tmp_mem_cached = _line_parse(line);
found++;
}
else if (!strncmp("Slab:", line, 5))
{
tmp_mem_slab = _line_parse(line);
found++;
}
else if (!strncmp("Buffers:", line, 8))
{
*mem_buffers = _line_parse(line);
found++;
}
else if (!strncmp("Shmem:", line, 6))
{
*mem_shared = _line_parse(line);
found++;
}
else if (!strncmp("SwapTotal:", line, 10))
{
tmp_swp_total = _line_parse(line);
found++;
}
else if (!strncmp("SwapFree:", line, 9))
{
tmp_swp_free = _line_parse(line);
found++;
}
if (found >= 8)
break;
}
fclose(f);
*mem_cached = tmp_mem_cached + tmp_mem_slab;
*mem_used = *mem_total - tmp_mem_free - *mem_cached - *mem_buffers;
*swp_total = tmp_swp_total;
*swp_used = tmp_swp_total - tmp_swp_free;
}

172
src/modules/sysinfo/memusage/memusage_sysctl.c
View File

@ -1,172 +0,0 @@
#include "memusage.h"
#if defined(__FreeBSD__) || defined(__DragonFly__)
# include <sys/types.h>
# include <sys/sysctl.h>
# include <vm/vm_param.h>
#endif
#if defined(__OpenBSD__)
# include <sys/param.h>
# include <sys/sysctl.h>
# include <sys/swap.h>
# include <sys/mount.h>
#endif
#if defined(__FreeBSD__) || defined(__DragonFly__)
static long int
_sysctlfromname(const char *name, void *mib, int depth, size_t *len)
{
long int result;
if (sysctlnametomib(name, mib, len) < 0) return -1;
*len = sizeof(result);
if (sysctl(mib, depth, &result, len, NULL, 0) < 0) return -1;
return result;
}
#endif
void
_memsize_bytes_to_kb(unsigned long *bytes)
{
*bytes = (unsigned int)*bytes >> 10;
}
void
_memusage_sysctl_getusage(unsigned long *mem_total,
unsigned long *mem_used,
unsigned long *mem_cached,
unsigned long *mem_buffers,
unsigned long *mem_shared,
unsigned long *swp_total,
unsigned long *swp_used)
{
size_t len;
int i = 0;
*mem_total = *mem_used = *mem_cached = *mem_buffers = *mem_shared = 0;
*swp_total = *swp_used = 0;
#if defined(__FreeBSD__) || defined(__DragonFly__)
size_t miblen;
int total_pages = 0, free_pages = 0, inactive_pages = 0;
long int result = 0;
int page_size = getpagesize();
int *mib = malloc(sizeof(int) * 4);
if (mib == NULL) return;
mib[0] = CTL_HW; mib[1] = HW_PHYSMEM;
len = sizeof(*mem_total);
if (sysctl(mib, 2, mem_total, &len, NULL, 0) == -1)
return;
*mem_total /= 1024;
total_pages = _sysctlfromname("vm.stats.vm.v_page_count", mib, 4, &len);
if (total_pages < 0) return;
free_pages = _sysctlfromname("vm.stats.vm.v_free_count", mib, 4, &len);
if (free_pages < 0) return;
inactive_pages = _sysctlfromname("vm.stats.vm.v_inactive_count", mib, 4, &len);
if (inactive_pages < 0) return;
*mem_used = (total_pages - free_pages - inactive_pages) * page_size;
_memsize_bytes_to_kb(mem_used);
result = _sysctlfromname("vfs.bufspace", mib, 2, &len);
if (result < 0) return;
*mem_buffers = (result);
_memsize_bytes_to_kb(mem_buffers);
result = _sysctlfromname("vm.stats.vm.v_active_count", mib, 4, &len);
if (result < 0) return;
*mem_cached = (result * page_size);
_memsize_bytes_to_kb(mem_cached);
result = _sysctlfromname("vm.stats.vm.v_cache_count", mib, 4, &len);
if (result < 0) return;
*mem_shared = (result * page_size);
_memsize_bytes_to_kb(mem_shared);
result = _sysctlfromname("vm.swap_total", mib, 2, &len);
if (result < 0) return;
*swp_total = (result / 1024);
miblen = 3;
if (sysctlnametomib("vm.swap_info", mib, &miblen) == -1) return;
struct xswdev xsw;
// previous mib is important for this one...
for (i = 0; ; i++)
{
mib[miblen] = i;
len = sizeof(xsw);
if (sysctl(mib, miblen + 1, &xsw, &len, NULL, 0) == -1) break;
*swp_used += (unsigned long)xsw.xsw_used * page_size;
}
*swp_used >>= 10;
E_FREE(mib);
#elif defined(__OpenBSD__)
static int mib[] = { CTL_HW, HW_PHYSMEM64 };
static int bcstats_mib[] = { CTL_VFS, VFS_GENERIC, VFS_BCACHESTAT };
struct bcachestats bcstats;
static int uvmexp_mib[] = { CTL_VM, VM_UVMEXP };
struct uvmexp uvmexp;
int nswap, rnswap;
struct swapent *swdev = NULL;
len = sizeof(*mem_total);
if (sysctl(mib, 2, mem_total, &len, NULL, 0) == -1)
return;
len = sizeof(uvmexp);
if (sysctl(uvmexp_mib, 2, &uvmexp, &len, NULL, 0) == -1)
return;
len = sizeof(bcstats);
if (sysctl(bcstats_mib, 3, &bcstats, &len, NULL, 0) == -1)
return;
// Don't fail if there's not swap!
nswap = swapctl(SWAP_NSWAP, 0, 0);
if (nswap == 0) goto swap_out;
swdev = calloc(nswap, sizeof(*swdev));
if (swdev == NULL) goto swap_out;
rnswap = swapctl(SWAP_STATS, swdev, nswap);
if (rnswap == -1) goto swap_out;
for (i = 0; i < nswap; i++) // nswap; i++)
{
if (swdev[i].se_flags & SWF_ENABLE)
{
*swp_used += (swdev[i].se_inuse / (1024 / DEV_BSIZE));
*swp_total += (swdev[i].se_nblks / (1024 / DEV_BSIZE));
}
}
swap_out:
if (swdev) E_FREE(swdev);
*mem_total /= 1024;
*mem_cached = (uvmexp.pagesize * bcstats.numbufpages);
_memsize_bytes_to_kb(mem_cached);
*mem_used = (uvmexp.active * uvmexp.pagesize);
_memsize_bytes_to_kb(mem_used);
*mem_buffers = (uvmexp.pagesize * (uvmexp.npages - uvmexp.free));
_memsize_bytes_to_kb(mem_buffers);
*mem_shared = (uvmexp.pagesize * uvmexp.wired);
_memsize_bytes_to_kb(mem_shared);
#endif
}

44
src/modules/sysinfo/meson.build
View File

@ -1,44 +0,0 @@
src = files(
'mod.c',
'sysinfo.c',
'sysinfo.h',
'batman/batman.h',
'batman/batman.c',
'batman/batman_fallback.c',
'batman/batman_config.c',
'thermal/thermal.h',
'thermal/thermal.c',
'thermal/thermal_config.c',
'thermal/thermal_fallback.c',
'cpuclock/cpuclock.h',
'cpuclock/cpuclock.c',
'cpuclock/cpuclock_config.c',
'cpumonitor/cpumonitor.h',
'cpumonitor/cpumonitor.c',
'cpumonitor/cpumonitor_config.c',
'cpumonitor/cpumonitor_proc.c',
'memusage/memusage.h',
'memusage/memusage.c',
'memusage/memusage_config.c',
'memusage/memusage_proc.c',
'netstatus/netstatus.h',
'netstatus/netstatus.c',
'netstatus/netstatus_config.c',
'netstatus/netstatus_proc.c'
)
if config_h.has('HAVE_EEZE') == true
src += files(
'batman/batman_udev.c',
'thermal/thermal_udev.c')
elif host_machine.system().contains('bsd') == true
src += files(
'batman/batman_sysctl.c',
'thermal/thermal_sysctl.c',
'netstatus/netstatus_sysctl.c',
'cpumonitor/cpumonitor_sysctl.c',
'memusage/memusage_sysctl.c')
else
src += files(
'batman/batman_upower.c',
'thermal/thermal_sysctl.c')
endif

222
src/modules/sysinfo/mod.c
View File

@ -1,222 +0,0 @@
#include "sysinfo.h"
#define CONFIG_VERSION 2
static E_Config_DD *conf_edd = NULL;
static E_Config_DD *conf_item_edd = NULL;
Eina_List *sysinfo_instances = NULL;
Config *sysinfo_config = NULL;
EINTERN void
sysinfo_init(void)
{
Eina_List *l;
Config_Item *ci;
conf_item_edd = E_CONFIG_DD_NEW("Sysinfo_Config_Item", Config_Item);
#undef T
#undef D
#define T Config_Item
#define D conf_item_edd
E_CONFIG_VAL(D, T, id, INT);
E_CONFIG_VAL(D, T, version, INT);
E_CONFIG_VAL(D, T, esm, INT);
E_CONFIG_VAL(D, T, batman.poll_interval, INT);
E_CONFIG_VAL(D, T, batman.alert, INT);
E_CONFIG_VAL(D, T, batman.alert_p, INT);
E_CONFIG_VAL(D, T, batman.alert_timeout, INT);
E_CONFIG_VAL(D, T, batman.suspend_below, INT);
E_CONFIG_VAL(D, T, batman.suspend_method, INT);
E_CONFIG_VAL(D, T, batman.force_mode, INT);
#if defined(HAVE_EEZE) || defined(__OpenBSD__) || defined(__NetBSD__)
E_CONFIG_VAL(D, T, batman.fuzzy, INT);
#endif
E_CONFIG_VAL(D, T, batman.desktop_notifications, INT);
E_CONFIG_VAL(D, T, thermal.poll_interval, INT);
E_CONFIG_VAL(D, T, thermal.low, INT);
E_CONFIG_VAL(D, T, thermal.high, INT);
E_CONFIG_VAL(D, T, thermal.sensor_type, INT);
E_CONFIG_VAL(D, T, thermal.sensor_name, STR);
E_CONFIG_VAL(D, T, thermal.units, INT);
E_CONFIG_VAL(D, T, cpuclock.poll_interval, INT);
E_CONFIG_VAL(D, T, cpuclock.restore_governor, INT);
E_CONFIG_VAL(D, T, cpuclock.auto_powersave, INT);
E_CONFIG_VAL(D, T, cpuclock.powersave_governor, STR);
E_CONFIG_VAL(D, T, cpuclock.governor, STR);
E_CONFIG_VAL(D, T, cpuclock.pstate_min, INT);
E_CONFIG_VAL(D, T, cpuclock.pstate_max, INT);
E_CONFIG_VAL(D, T, cpumonitor.poll_interval, INT);
E_CONFIG_VAL(D, T, memusage.poll_interval, INT);
E_CONFIG_VAL(D, T, netstatus.poll_interval, INT);
E_CONFIG_VAL(D, T, netstatus.automax, INT);
E_CONFIG_VAL(D, T, netstatus.inmax, INT);
E_CONFIG_VAL(D, T, netstatus.outmax, INT);
E_CONFIG_VAL(D, T, netstatus.receive_units, INT);
E_CONFIG_VAL(D, T, netstatus.send_units, INT);
conf_edd = E_CONFIG_DD_NEW("Sysinfo_Config", Config);
#undef T
#undef D
#define T Config
#define D conf_edd
E_CONFIG_LIST(D, T, items, conf_item_edd);
sysinfo_config = e_config_domain_load("module.sysinfo", conf_edd);
if (!sysinfo_config)
{
sysinfo_config = E_NEW(Config, 1);
ci = E_NEW(Config_Item, 1);
ci->id = 0;
ci->version = CONFIG_VERSION;
ci->esm = E_SYSINFO_MODULE_NONE;
ci->batman.poll_interval = 512;
ci->batman.alert = 30;
ci->batman.alert_p = 10;
ci->batman.alert_timeout = 0;
ci->batman.suspend_below = 0;
ci->batman.suspend_method = 0;
ci->batman.force_mode = 0;
ci->batman.full = -2;
ci->batman.time_left = -2;
ci->batman.have_battery = -2;
ci->batman.have_power = -2;
#if defined(HAVE_EEZE) || defined(__OpenBSD__) || defined(__NetBSD__)
ci->batman.fuzzy = 0;
#endif
ci->batman.desktop_notifications = 0;
ci->batman.popup = NULL;
ci->batman.configure = NULL;
ci->batman.done = EINA_FALSE;
ci->thermal.poll_interval = 128;
ci->thermal.low = 30;
ci->thermal.high = 80;
ci->thermal.sensor_type = SENSOR_TYPE_NONE;
ci->thermal.sensor_name = NULL;
ci->thermal.temp = -900;
ci->thermal.units = CELSIUS;
ci->thermal.popup = NULL;
ci->thermal.configure = NULL;
ci->cpuclock.poll_interval = 32;
ci->cpuclock.restore_governor = 0;
ci->cpuclock.auto_powersave = 1;
ci->cpuclock.powersave_governor = NULL;
ci->cpuclock.governor = NULL;
ci->cpuclock.pstate_min = 1;
ci->cpuclock.pstate_max = 101;
ci->cpuclock.popup = NULL;
ci->cpuclock.configure = NULL;
ci->cpumonitor.poll_interval = 32;
ci->cpumonitor.percent = 0;
ci->cpumonitor.popup = NULL;
ci->cpumonitor.configure = NULL;
ci->memusage.poll_interval = 32;
ci->memusage.mem_percent = 0;
ci->memusage.swp_percent = 0;
ci->memusage.popup = NULL;
ci->memusage.configure = NULL;
ci->netstatus.poll_interval = 32;
ci->netstatus.automax = EINA_TRUE;
ci->netstatus.inmax = 0;
ci->netstatus.outmax = 0;
ci->netstatus.receive_units = NETSTATUS_UNIT_BYTES;
ci->netstatus.send_units = NETSTATUS_UNIT_BYTES;
ci->netstatus.instring = NULL;
ci->netstatus.outstring = NULL;
ci->netstatus.popup = NULL;
ci->netstatus.configure = NULL;
E_CONFIG_LIMIT(ci->batman.poll_interval, 4, 4096);
E_CONFIG_LIMIT(ci->batman.alert, 0, 60);
E_CONFIG_LIMIT(ci->batman.alert_p, 0, 100);
E_CONFIG_LIMIT(ci->batman.alert_timeout, 0, 300);
E_CONFIG_LIMIT(ci->batman.suspend_below, 0, 50);
E_CONFIG_LIMIT(ci->batman.force_mode, 0, 2);
E_CONFIG_LIMIT(ci->batman.desktop_notifications, 0, 1);
E_CONFIG_LIMIT(ci->thermal.poll_interval, 1, 1024);
E_CONFIG_LIMIT(ci->thermal.low, 0, 100);
E_CONFIG_LIMIT(ci->thermal.high, 0, 220);
E_CONFIG_LIMIT(ci->thermal.units, CELSIUS, FAHRENHEIT);
E_CONFIG_LIMIT(ci->cpuclock.poll_interval, 1, 1024);
E_CONFIG_LIMIT(ci->cpumonitor.poll_interval, 1, 1024);
E_CONFIG_LIMIT(ci->memusage.poll_interval, 1, 1024);
E_CONFIG_LIMIT(ci->netstatus.poll_interval, 1, 1024);
sysinfo_config->items = eina_list_append(sysinfo_config->items, ci);
}
EINA_LIST_FOREACH(sysinfo_config->items, l, ci)
{
if (ci->esm == E_SYSINFO_MODULE_NETSTATUS || ci->esm == E_SYSINFO_MODULE_SYSINFO)
{
if (ci->version < CONFIG_VERSION)
{
ci->version = CONFIG_VERSION;
ci->netstatus.automax = EINA_TRUE;
ci->netstatus.receive_units = NETSTATUS_UNIT_BYTES;
ci->netstatus.send_units = NETSTATUS_UNIT_BYTES;
}
}
}
e_gadget_type_add("Batman", batman_create, NULL);
e_gadget_type_add("Thermal", thermal_create, NULL);
e_gadget_type_add("CpuClock", cpuclock_create, NULL);
e_gadget_type_add("CpuMonitor", cpumonitor_create, NULL);
e_gadget_type_add("MemUsage", memusage_create, NULL);
e_gadget_type_add("NetStatus", netstatus_create, NULL);
e_gadget_type_add("SysInfo", sysinfo_create, NULL);
}
EINTERN void
sysinfo_shutdown(void)
{
if (sysinfo_config)
{
Config_Item *ci;
EINA_LIST_FREE(sysinfo_config->items, ci)
{
E_FREE(ci);
}
E_FREE(sysinfo_config);
}
E_CONFIG_DD_FREE(conf_edd);
E_CONFIG_DD_FREE(conf_item_edd);
e_gadget_type_del("Batman");
e_gadget_type_del("Thermal");
e_gadget_type_del("CpuClock");
e_gadget_type_del("CpuMonitor");
e_gadget_type_del("MemUsage");
e_gadget_type_del("NetStatus");
e_gadget_type_del("SysInfo");
}
E_API E_Module_Api e_modapi =
{
E_MODULE_API_VERSION,
"Sysinfo"
};
E_API void *
e_modapi_init(E_Module *m)
{
sysinfo_init();
sysinfo_config->module = m;
return m;
}
E_API int
e_modapi_shutdown(E_Module *m EINA_UNUSED)
{
sysinfo_shutdown();
return 1;
}
E_API int
e_modapi_save(E_Module *m EINA_UNUSED)
{
e_config_domain_save("module.sysinfo", conf_edd, sysinfo_config);
return 1;
}

8
src/modules/sysinfo/module.desktop
View File

@ -1,8 +0,0 @@
[Desktop Entry]
Type=Link
Name=Sysinfo
Comment=A gadget to visualize your system info
Comment[fr]=Un gadget pour visualer les infos système
Comment[it]=Un gadget per visualizzare informazioni sul sistema
Icon=e-module-sysinfo
X-Enlightenment-ModuleType=system

509
src/modules/sysinfo/netstatus/netstatus.c
View File

@ -1,509 +0,0 @@
#include "netstatus.h"
typedef struct _Thread_Config Thread_Config;
struct _Thread_Config
{
int interval;
Instance *inst;
Eina_Bool automax;
time_t checktime;
int inpercent;
unsigned long in;
unsigned long incurrent;
unsigned long inmax;
Eina_Stringshare *instring;
int outpercent;
unsigned long out;
unsigned long outcurrent;
unsigned long outmax;
Eina_Stringshare *outstring;
E_Powersave_Sleeper *sleeper;
};
static void
_netstatus_face_update(Thread_Config *thc)
{
Edje_Message_Int_Set *msg;
msg = malloc(sizeof(Edje_Message_Int_Set) + 6 * sizeof(int));
EINA_SAFETY_ON_NULL_RETURN(msg);
msg->count = 6;
msg->val[0] = thc->incurrent;
msg->val[1] = thc->inpercent;
msg->val[2] = thc->inmax;
msg->val[3] = thc->outcurrent;
msg->val[4] = thc->outpercent;
msg->val[5] = thc->outmax;
edje_object_message_send(elm_layout_edje_get(thc->inst->cfg->netstatus.o_gadget),
EDJE_MESSAGE_INT_SET, 1, msg);
E_FREE(msg);
if (thc->inst->cfg->netstatus.popup)
{
char buf[4096];
snprintf(buf, sizeof(buf), "%s (%d %%%%)",
thc->inst->cfg->netstatus.instring,
thc->inst->cfg->netstatus.inpercent);
elm_progressbar_unit_format_set(thc->inst->cfg->netstatus.popup_inpbar, buf);
elm_progressbar_value_set(thc->inst->cfg->netstatus.popup_inpbar,
(float)thc->inst->cfg->netstatus.inpercent / 100);
memset(buf, 0x00, sizeof(buf));
snprintf(buf, sizeof(buf), "%s (%d %%%%)",
thc->inst->cfg->netstatus.outstring,
thc->inst->cfg->netstatus.outpercent);
elm_progressbar_unit_format_set(thc->inst->cfg->netstatus.popup_outpbar, buf);
elm_progressbar_value_set(thc->inst->cfg->netstatus.popup_outpbar,
(float)thc->inst->cfg->netstatus.outpercent / 100);
}
}
static Evas_Object *
_netstatus_configure_cb(Evas_Object *g)
{
Instance *inst = evas_object_data_get(g, "Instance");
if (!sysinfo_config) return NULL;
return netstatus_configure(inst);
}
static void
_netstatus_popup_dismissed(void *data, Evas_Object *obj, void *event_info EINA_UNUSED)
{
Instance *inst = data;
E_FREE_FUNC(obj, evas_object_del);
inst->cfg->netstatus.popup = NULL;
}
static void
_netstatus_popup_deleted(void *data, Evas *e EINA_UNUSED, Evas_Object *obj EINA_UNUSED, void *event_info EINA_UNUSED)
{
Instance *inst = data;
inst->cfg->netstatus.popup = NULL;
}
static void
_netstatus_mouse_up_cb(void *data, Evas *e EINA_UNUSED, Evas_Object *obj EINA_UNUSED, void *event_data)
{
Evas_Object *label, *popup, *table, *pbar;
Evas_Event_Mouse_Up *ev = event_data;
Instance *inst = data;
char text[4096], buf[4096];
if (ev->event_flags & EVAS_EVENT_FLAG_ON_HOLD) return;
if (ev->button == 1)
{
if (inst->cfg->netstatus.popup)
{
elm_ctxpopup_dismiss(inst->cfg->netstatus.popup);
return;
}
popup = elm_ctxpopup_add(e_comp->elm);
elm_object_style_set(popup, "noblock");
evas_object_smart_callback_add(popup, "dismissed", _netstatus_popup_dismissed, inst);
evas_object_event_callback_add(popup, EVAS_CALLBACK_DEL, _netstatus_popup_deleted, inst);
table = elm_table_add(popup);
E_EXPAND(table);
E_FILL(table);
elm_object_content_set(popup, table);
evas_object_show(table);
snprintf(text, sizeof(text), "<big><b>%s</b></big>", _("Network Throughput"));
label = elm_label_add(table);
E_EXPAND(label); E_ALIGN(label, 0.5, 0.5);
elm_object_text_set(label, text);
elm_table_pack(table, label, 0, 0, 2, 1);
evas_object_show(label);
label = elm_label_add(table);
E_ALIGN(label, 0.0, 0.5);
elm_object_text_set(label, _("Receiving"));
elm_table_pack(table, label, 0, 1, 1, 1);
evas_object_show(label);
snprintf(buf, sizeof(buf), "%s (%d %%%%)",
inst->cfg->netstatus.instring,
inst->cfg->netstatus.inpercent);
pbar = elm_progressbar_add(table);
E_EXPAND(pbar);
E_FILL(pbar);
elm_progressbar_span_size_set(pbar, 200 * e_scale);
elm_progressbar_unit_format_set(pbar, buf);
elm_progressbar_value_set(pbar, (float)inst->cfg->netstatus.inpercent / 100);
elm_table_pack(table, pbar, 1, 1, 1, 1);
evas_object_show(pbar);
inst->cfg->netstatus.popup_inpbar = pbar;
label = elm_label_add(table);
E_ALIGN(label, 0.0, 0.5);
elm_object_text_set(label, _("Sending"));
elm_table_pack(table, label, 0, 2, 1, 1);
evas_object_show(label);
memset(buf, 0x00, sizeof(buf));
snprintf(buf, sizeof(buf), "%s (%d %%%%)",
inst->cfg->netstatus.outstring,
inst->cfg->netstatus.outpercent);
pbar = elm_progressbar_add(table);
E_EXPAND(pbar);
E_FILL(pbar);
elm_progressbar_span_size_set(pbar, 200 * e_scale);
elm_progressbar_unit_format_set(pbar, buf);
elm_progressbar_value_set(pbar, (float)inst->cfg->netstatus.outpercent / 100);
elm_table_pack(table, pbar, 1, 2, 1, 1);
evas_object_show(pbar);
inst->cfg->netstatus.popup_outpbar = pbar;
e_gadget_util_ctxpopup_place(inst->o_main, popup,
inst->cfg->netstatus.o_gadget);
evas_object_show(popup);
inst->cfg->netstatus.popup = popup;
}
}
static void
_netstatus_resize_cb(void *data, Evas *e EINA_UNUSED, Evas_Object *obj EINA_UNUSED, void *event_data EINA_UNUSED)
{
Evas_Coord w, h;
Instance *inst = data;
edje_object_parts_extends_calc(elm_layout_edje_get(inst->cfg->netstatus.o_gadget), 0, 0, &w, &h);
if (w < 1) w = 1;
if (h < 1) h = 1;
if (inst->cfg->esm == E_SYSINFO_MODULE_NETSTATUS)
evas_object_size_hint_aspect_set(inst->o_main, EVAS_ASPECT_CONTROL_BOTH, w, h);
else
evas_object_size_hint_aspect_set(inst->cfg->netstatus.o_gadget, EVAS_ASPECT_CONTROL_BOTH, w, h);
}
static void
_netstatus_cb_usage_check_main(void *data, Ecore_Thread *th)
{
Thread_Config *thc = data;
for (;; )
{
char rin[4096], rout[4096];
if (ecore_thread_check(th)) break;
#if defined(__FreeBSD__) || defined(__DragonFly__) || defined(__OpenBSD__)
_netstatus_sysctl_getstatus(thc->automax, &thc->checktime, &thc->in, &thc->incurrent,
&thc->inmax, &thc->inpercent, &thc->out, &thc->outcurrent, &thc->outmax,
&thc->outpercent);
#else
_netstatus_proc_getstatus(thc->automax, &thc->checktime, &thc->in, &thc->incurrent,
&thc->inmax, &thc->inpercent, &thc->out, &thc->outcurrent, &thc->outmax,
&thc->outpercent);
#endif
if (!thc->incurrent)
{
snprintf(rin, sizeof(rin), "0 B/s");
}
else
{
if (thc->incurrent > 1048576)
snprintf(rin, sizeof(rin), "%.2f MB/s", ((float)thc->incurrent / 1048576));
else if ((thc->incurrent > 1024) && (thc->incurrent < 1048576))
snprintf(rin, sizeof(rin), "%lu KB/s", (thc->incurrent / 1024));
else
snprintf(rin, sizeof(rin), "%lu B/s", thc->incurrent);
}
eina_stringshare_replace(&thc->instring, rin);
if (!thc->outcurrent)
{
snprintf(rout, sizeof(rout), "0 B/s");
}
else
{
if (thc->outcurrent > 1048576)
snprintf(rout, sizeof(rout), "%.2f MB/s", ((float)thc->outcurrent / 1048576));
else if ((thc->outcurrent > 1024) && (thc->outcurrent < 1048576))
snprintf(rout, sizeof(rout), "%lu KB/s", (thc->outcurrent / 1024));
else
snprintf(rout, sizeof(rout), "%lu B/s", thc->outcurrent);
}
eina_stringshare_replace(&thc->outstring, rout);
ecore_thread_feedback(th, NULL);
if (ecore_thread_check(th)) break;
e_powersave_sleeper_sleep(thc->sleeper, thc->interval);
if (ecore_thread_check(th)) break;
}
}
static void
_netstatus_cb_usage_check_notify(void *data,
Ecore_Thread *th EINA_UNUSED,
void *msg EINA_UNUSED)
{
Thread_Config *thc = data;
if (!thc->inst->cfg) return;
if (thc->inst->cfg->esm != E_SYSINFO_MODULE_NETSTATUS && thc->inst->cfg->esm != E_SYSINFO_MODULE_SYSINFO) return;
eina_stringshare_replace(&thc->inst->cfg->netstatus.instring, thc->instring);
eina_stringshare_replace(&thc->inst->cfg->netstatus.outstring, thc->outstring);
thc->inst->cfg->netstatus.inpercent = thc->inpercent;
thc->inst->cfg->netstatus.outpercent = thc->outpercent;
_netstatus_face_update(thc);
}
static void
_netstatus_cb_usage_check_end(void *data, Ecore_Thread *th EINA_UNUSED)
{
Thread_Config *thc = data;
e_powersave_sleeper_free(thc->sleeper);
E_FREE_FUNC(thc->instring, eina_stringshare_del);
E_FREE_FUNC(thc->outstring, eina_stringshare_del);
E_FREE(thc);
}
static Eina_Bool
_screensaver_on(void *data)
{
Instance *inst = data;
if (inst->cfg->netstatus.usage_check_thread)
{
ecore_thread_cancel(inst->cfg->netstatus.usage_check_thread);
inst->cfg->netstatus.usage_check_thread = NULL;
}
return ECORE_CALLBACK_RENEW;
}
static Eina_Bool
_screensaver_off(void *data)
{
Instance *inst = data;
_netstatus_config_updated(inst);
return ECORE_CALLBACK_RENEW;
}
void
_netstatus_config_updated(Instance *inst)
{
Thread_Config *thc;
if (inst->cfg->id == -1)
{
thc = E_NEW(Thread_Config, 1);
if (thc)
{
thc->inst = inst;
thc->inpercent = 75;
thc->outpercent = 30;
_netstatus_face_update(thc);
E_FREE(thc);
}
return;
}
if (inst->cfg->netstatus.usage_check_thread)
{
ecore_thread_cancel(inst->cfg->netstatus.usage_check_thread);
inst->cfg->netstatus.usage_check_thread = NULL;
}
thc = E_NEW(Thread_Config, 1);
if (thc)
{
thc->inst = inst;
thc->sleeper = e_powersave_sleeper_new();
thc->interval = inst->cfg->netstatus.poll_interval;
thc->in = 0;
thc->inmax = inst->cfg->netstatus.inmax;
thc->incurrent = 0;
thc->inpercent = 0;
thc->instring = NULL;
thc->out = 0;
thc->outmax = inst->cfg->netstatus.outmax;
thc->outcurrent = 0;
thc->outpercent = 0;
thc->outstring = NULL;
thc->automax = inst->cfg->netstatus.automax;
inst->cfg->netstatus.usage_check_thread =
ecore_thread_feedback_run(_netstatus_cb_usage_check_main,
_netstatus_cb_usage_check_notify,
_netstatus_cb_usage_check_end,
_netstatus_cb_usage_check_end, thc, EINA_TRUE);
}
e_config_save_queue();
}
static void
_netstatus_removed_cb(void *data, Evas_Object *obj EINA_UNUSED, void *event_data)
{
Instance *inst = data;
Ecore_Event_Handler *handler;
if (inst->o_main != event_data) return;
if (inst->cfg->netstatus.popup)
E_FREE_FUNC(inst->cfg->netstatus.popup, evas_object_del);
if (inst->cfg->netstatus.configure)
E_FREE_FUNC(inst->cfg->netstatus.configure, evas_object_del);
evas_object_smart_callback_del_full(e_gadget_site_get(inst->o_main), "gadget_removed",
_netstatus_removed_cb, inst);
evas_object_event_callback_del_full(inst->o_main, EVAS_CALLBACK_DEL, sysinfo_netstatus_remove, data);
EINA_LIST_FREE(inst->cfg->netstatus.handlers, handler)
ecore_event_handler_del(handler);
if (inst->cfg->netstatus.usage_check_thread)
{
ecore_thread_cancel(inst->cfg->netstatus.usage_check_thread);
inst->cfg->netstatus.usage_check_thread = NULL;
}
E_FREE_FUNC(inst->cfg->netstatus.instring, eina_stringshare_del);
E_FREE_FUNC(inst->cfg->netstatus.outstring, eina_stringshare_del);
sysinfo_config->items = eina_list_remove(sysinfo_config->items, inst->cfg);
if (inst->cfg->id >= 0)
sysinfo_instances = eina_list_remove(sysinfo_instances, inst);
E_FREE(inst->cfg);
E_FREE(inst);
}
void
sysinfo_netstatus_remove(void *data, Evas *e EINA_UNUSED, Evas_Object *obj EINA_UNUSED, void *event_data EINA_UNUSED)
{
Instance *inst = data;
Ecore_Event_Handler *handler;
if (inst->cfg->netstatus.popup)
E_FREE_FUNC(inst->cfg->netstatus.popup, evas_object_del);
if (inst->cfg->netstatus.configure)
E_FREE_FUNC(inst->cfg->netstatus.configure, evas_object_del);
EINA_LIST_FREE(inst->cfg->netstatus.handlers, handler)
ecore_event_handler_del(handler);
if (inst->cfg->netstatus.usage_check_thread)
{
ecore_thread_cancel(inst->cfg->netstatus.usage_check_thread);
inst->cfg->netstatus.usage_check_thread = NULL;
return;
}
E_FREE_FUNC(inst->cfg->netstatus.instring, eina_stringshare_del);
E_FREE_FUNC(inst->cfg->netstatus.outstring, eina_stringshare_del);
}
static void
_netstatus_created_cb(void *data, Evas_Object *obj, void *event_data EINA_UNUSED)
{
Instance *inst = data;
E_Gadget_Site_Orient orient = e_gadget_site_orient_get(e_gadget_site_get(inst->o_main));
e_gadget_configure_cb_set(inst->o_main, _netstatus_configure_cb);
inst->cfg->netstatus.popup = NULL;
inst->cfg->netstatus.instring = NULL;
inst->cfg->netstatus.outstring = NULL;
inst->cfg->netstatus.inpercent = 0;
inst->cfg->netstatus.outpercent = 0;
inst->cfg->netstatus.o_gadget = elm_layout_add(inst->o_main);
if (orient == E_GADGET_SITE_ORIENT_VERTICAL)
e_theme_edje_object_set(inst->cfg->netstatus.o_gadget,
"base/theme/gadget/netstatus",
"e/gadget/netstatus/main_vert");
else
e_theme_edje_object_set(inst->cfg->netstatus.o_gadget, "base/theme/gadget/netstatus",
"e/gadget/netstatus/main");
E_EXPAND(inst->cfg->netstatus.o_gadget);
E_FILL(inst->cfg->netstatus.o_gadget);
elm_box_pack_end(inst->o_main, inst->cfg->netstatus.o_gadget);
evas_object_event_callback_add(inst->cfg->netstatus.o_gadget, EVAS_CALLBACK_MOUSE_UP, _netstatus_mouse_up_cb, inst);
evas_object_event_callback_add(inst->cfg->netstatus.o_gadget, EVAS_CALLBACK_RESIZE, _netstatus_resize_cb, inst);
evas_object_show(inst->cfg->netstatus.o_gadget);
evas_object_smart_callback_del_full(obj, "gadget_created", _netstatus_created_cb, data);
E_LIST_HANDLER_APPEND(inst->cfg->netstatus.handlers, E_EVENT_SCREENSAVER_ON, _screensaver_on, inst);
E_LIST_HANDLER_APPEND(inst->cfg->netstatus.handlers, E_EVENT_SCREENSAVER_OFF, _screensaver_off, inst);
_netstatus_config_updated(inst);
}
Evas_Object *
sysinfo_netstatus_create(Evas_Object *parent, Instance *inst)
{
inst->cfg->netstatus.popup = NULL;
inst->cfg->netstatus.instring = NULL;
inst->cfg->netstatus.outstring = NULL;
inst->cfg->netstatus.inpercent = 0;
inst->cfg->netstatus.outpercent = 0;
inst->cfg->netstatus.o_gadget = elm_layout_add(parent);
e_theme_edje_object_set(inst->cfg->netstatus.o_gadget, "base/theme/gadget/netstatus",
"e/gadget/netstatus/main");
E_EXPAND(inst->cfg->netstatus.o_gadget);
E_FILL(inst->cfg->netstatus.o_gadget);
evas_object_event_callback_add(inst->cfg->netstatus.o_gadget, EVAS_CALLBACK_MOUSE_UP, _netstatus_mouse_up_cb, inst);
evas_object_event_callback_add(inst->cfg->netstatus.o_gadget, EVAS_CALLBACK_RESIZE, _netstatus_resize_cb, inst);
evas_object_show(inst->cfg->netstatus.o_gadget);
E_LIST_HANDLER_APPEND(inst->cfg->netstatus.handlers, E_EVENT_SCREENSAVER_ON, _screensaver_on, inst);
E_LIST_HANDLER_APPEND(inst->cfg->netstatus.handlers, E_EVENT_SCREENSAVER_OFF, _screensaver_off, inst);
_netstatus_config_updated(inst);
return inst->cfg->netstatus.o_gadget;
}
static Config_Item *
_conf_item_get(int *id)
{
Config_Item *ci;
Eina_List *l;
if (*id > 0)
{
EINA_LIST_FOREACH(sysinfo_config->items, l, ci)
if (*id == ci->id && ci->esm == E_SYSINFO_MODULE_NETSTATUS) return ci;
}
ci = E_NEW(Config_Item, 1);
if (*id != -1)
ci->id = eina_list_count(sysinfo_config->items) + 1;
else
ci->id = -1;
ci->esm = E_SYSINFO_MODULE_NETSTATUS;
ci->netstatus.poll_interval = 32;
ci->netstatus.automax = EINA_TRUE;
ci->netstatus.receive_units = NETSTATUS_UNIT_BYTES;
ci->netstatus.send_units = NETSTATUS_UNIT_BYTES;
ci->netstatus.instring = NULL;
ci->netstatus.outstring = NULL;
ci->netstatus.popup = NULL;
ci->netstatus.configure = NULL;
sysinfo_config->items = eina_list_append(sysinfo_config->items, ci);
return ci;
}
Evas_Object *
netstatus_create(Evas_Object *parent, int *id, E_Gadget_Site_Orient orient EINA_UNUSED)
{
Instance *inst;
inst = E_NEW(Instance, 1);
inst->cfg = _conf_item_get(id);
*id = inst->cfg->id;
inst->cfg->netstatus.instring = NULL;
inst->cfg->netstatus.outstring = NULL;
inst->cfg->netstatus.popup = NULL;
inst->o_main = elm_box_add(parent);
evas_object_data_set(inst->o_main, "Instance", inst);
evas_object_smart_callback_add(parent, "gadget_created", _netstatus_created_cb, inst);
evas_object_smart_callback_add(parent, "gadget_removed", _netstatus_removed_cb, inst);
evas_object_event_callback_add(inst->o_main, EVAS_CALLBACK_DEL, sysinfo_netstatus_remove, inst);
evas_object_show(inst->o_main);
if (inst->cfg->id < 0) return inst->o_main;
sysinfo_instances =
eina_list_append(sysinfo_instances, inst);
return inst->o_main;
}

29
src/modules/sysinfo/netstatus/netstatus.h
View File

@ -1,29 +0,0 @@
#ifndef NETSTATUS_H
#define NETSTATUS_H
#include "../sysinfo.h"
typedef struct _Netstatus_Config Netstatus_Config;
struct _Netstatus_Config
{
Instance *inst;
Evas_Object *transfer_check;
Evas_Object *receive_max;
Evas_Object *receive_units;
Evas_Object *send_max;
Evas_Object *send_units;
int receive_unit_adjust;
int send_unit_adjust;
};
EINTERN void _netstatus_config_updated(Instance *inst);
EINTERN void _netstatus_proc_getstatus(Eina_Bool automax, time_t *last_checked,
unsigned long *prev_in, unsigned long *prev_incurrent, unsigned long *prev_inmax,
int *prev_inpercent, unsigned long *prev_out, unsigned long *prev_outcurrent,
unsigned long *prev_outmax, int *prev_outpercent);
EINTERN void _netstatus_sysctl_getstatus(Eina_Bool automax, time_t *last_checked,
unsigned long *prev_in, unsigned long *prev_incurrent, unsigned long *prev_inmax,
int *prev_inpercent, unsigned long *prev_out, unsigned long *prev_outcurrent,
unsigned long *prev_outmax, int *prev_outpercent);
EINTERN Evas_Object *netstatus_configure(Instance *inst);
#endif

419
src/modules/sysinfo/netstatus/netstatus_config.c
View File

@ -1,419 +0,0 @@
#include "netstatus.h"
static void
_config_close(void *data, Evas *e EINA_UNUSED, Evas_Object *obj EINA_UNUSED, void *event_info EINA_UNUSED)
{
Netstatus_Config *nc = data;
Instance *inst = nc->inst;
E_FREE_FUNC(inst->cfg->netstatus.configure, evas_object_del);
E_FREE(nc);
e_config_save_queue();
}
static void
_poll_changed(void *data, Evas_Object *obj, void *event_info EINA_UNUSED)
{
Netstatus_Config *nc = data;
Instance *inst = nc->inst;
int value = elm_radio_value_get(obj);
switch (value)
{
case 0:
inst->cfg->netstatus.poll_interval = 4;
break;
case 1:
inst->cfg->netstatus.poll_interval = 8;
break;
case 2:
inst->cfg->netstatus.poll_interval = 32;
break;
case 3:
inst->cfg->netstatus.poll_interval = 64;
break;
case 4:
inst->cfg->netstatus.poll_interval = 256;
break;
default:
inst->cfg->netstatus.poll_interval = 32;
}
e_config_save_queue();
_netstatus_config_updated(inst);
}
static void
_update_receive_maximums(void *data, Evas_Object *obj EINA_UNUSED, void *event_info EINA_UNUSED)
{
Netstatus_Config *nc = data;
Instance *inst = nc->inst;
int value = elm_slider_value_get(nc->receive_max);
inst->cfg->netstatus.inmax = value * nc->receive_unit_adjust;
e_config_save_queue();
_netstatus_config_updated(inst);
}
static void
_update_send_maximums(void *data, Evas_Object *obj EINA_UNUSED, void *event_info EINA_UNUSED)
{
Netstatus_Config *nc = data;
Instance *inst = nc->inst;
int value = elm_slider_value_get(nc->send_max);
inst->cfg->netstatus.outmax = value * nc->send_unit_adjust;
e_config_save_queue();
_netstatus_config_updated(inst);
}
static void
_receive_hover_changed(void *data, Evas_Object *obj EINA_UNUSED, void *event_info)
{
Netstatus_Config *nc = data;
Instance *inst = nc->inst;
const char *txt = elm_object_item_text_get(event_info);
if (!strcmp(txt, _("Bytes")))
{
inst->cfg->netstatus.receive_units = NETSTATUS_UNIT_BYTES;
nc->receive_unit_adjust = 1;
}
if (!strcmp(txt, _("KB")))
{
inst->cfg->netstatus.receive_units = NETSTATUS_UNIT_KB;
nc->receive_unit_adjust = 1024;
}
if (!strcmp(txt, _("MB")))
{
inst->cfg->netstatus.receive_units = NETSTATUS_UNIT_MB;
nc->receive_unit_adjust = 2048;
}
if (!strcmp(txt, _("GB")))
{
inst->cfg->netstatus.receive_units = NETSTATUS_UNIT_GB;
nc->receive_unit_adjust = 3072;
}
_update_receive_maximums(nc, NULL, NULL);
}
static void
_send_hover_changed(void *data, Evas_Object *obj EINA_UNUSED, void *event_info)
{
Netstatus_Config *nc = data;
Instance *inst = nc->inst;
const char *txt = elm_object_item_text_get(event_info);
if (!strcmp(txt, _("Bytes")))
{
inst->cfg->netstatus.send_units = NETSTATUS_UNIT_BYTES;
nc->send_unit_adjust = 1;
}
if (!strcmp(txt, _("KB")))
{
inst->cfg->netstatus.send_units = NETSTATUS_UNIT_KB;
nc->send_unit_adjust = 1024;
}
if (!strcmp(txt, _("MB")))
{
inst->cfg->netstatus.send_units = NETSTATUS_UNIT_MB;
nc->send_unit_adjust = 2048;
}
if (!strcmp(txt, _("GB")))
{
inst->cfg->netstatus.send_units = NETSTATUS_UNIT_GB;
nc->send_unit_adjust = 3072;
}
_update_send_maximums(nc, NULL, NULL);
}
static void
_check_changed(void *data, Evas_Object *obj EINA_UNUSED, void *event_info EINA_UNUSED)
{
Netstatus_Config *nc = data;
Instance *inst = nc->inst;
if (elm_check_state_get(nc->transfer_check))
{
elm_object_disabled_set(nc->receive_max, EINA_TRUE);
elm_object_disabled_set(nc->receive_units, EINA_TRUE);
elm_object_disabled_set(nc->send_max, EINA_TRUE);
elm_object_disabled_set(nc->send_units, EINA_TRUE);
inst->cfg->netstatus.automax = EINA_TRUE;
}
else
{
elm_object_disabled_set(nc->receive_max, EINA_FALSE);
elm_object_disabled_set(nc->receive_units, EINA_FALSE);
elm_object_disabled_set(nc->send_max, EINA_FALSE);
elm_object_disabled_set(nc->send_units, EINA_FALSE);
inst->cfg->netstatus.automax = EINA_FALSE;
_update_receive_maximums(nc, NULL, NULL);
_update_send_maximums(nc, NULL, NULL);
}
}
Evas_Object *
netstatus_configure(Instance *inst)
{
Evas_Object *popup, *frame, *main_box, *box, *o, *group, *lbl;
Evas_Object *hover, *slider, *check;
E_Zone *zone = e_zone_current_get();
Netstatus_Config *nc = E_NEW(Netstatus_Config, 1);
nc->inst = inst;
popup = elm_popup_add(e_comp->elm);
E_EXPAND(popup);
elm_popup_allow_events_set(popup, 1);
elm_popup_scrollable_set(popup, 1);
main_box = elm_box_add(popup);
elm_box_horizontal_set(main_box, EINA_FALSE);
E_EXPAND(main_box);
E_FILL(main_box);
evas_object_show(main_box);
elm_object_content_set(popup, main_box);
lbl = elm_label_add(main_box);
evas_object_size_hint_weight_set(lbl, EVAS_HINT_EXPAND, 0.0);
evas_object_size_hint_align_set(lbl, EVAS_HINT_FILL, EVAS_HINT_FILL);
elm_object_style_set(lbl, "marker");
elm_object_text_set(lbl, _("NetStatus Configuration"));
elm_box_pack_end(main_box, lbl);
evas_object_show(lbl);
frame = elm_frame_add(main_box);
elm_object_text_set(frame, _("Update Poll Interval"));
E_EXPAND(frame);
E_FILL(frame);
elm_box_pack_end(main_box, frame);
evas_object_show(frame);
box = elm_box_add(frame);
elm_box_horizontal_set(box, EINA_FALSE);
E_EXPAND(box);
evas_object_show(box);
o = elm_radio_add(box);
elm_radio_state_value_set(o, 0);
E_EXPAND(o);
E_ALIGN(o, 0, 0);
elm_object_text_set(o, _("Fast (4 ticks)"));
elm_box_pack_end(box, o);
evas_object_smart_callback_add(o, "changed", _poll_changed, nc);
evas_object_show(o);
group = o;
o = elm_radio_add(box);
elm_radio_state_value_set(o, 1);
elm_radio_group_add(o, group);
E_EXPAND(o);
E_ALIGN(o, 0, 0);
elm_object_text_set(o, _("Medium (8 ticks)"));
elm_box_pack_end(box, o);
evas_object_smart_callback_add(o, "changed", _poll_changed, nc);
evas_object_show(o);
o = elm_radio_add(box);
elm_radio_state_value_set(o, 2);
elm_radio_group_add(o, group);
E_EXPAND(o);
E_ALIGN(o, 0, 0);
elm_object_text_set(o, _("Normal (32 ticks)"));
elm_box_pack_end(box, o);
evas_object_smart_callback_add(o, "changed", _poll_changed, nc);
evas_object_show(o);
o = elm_radio_add(box);
elm_radio_state_value_set(o, 3);
elm_radio_group_add(o, group);
E_ALIGN(o, 0, 0);
elm_object_text_set(o, _("Slow (64 ticks)"));
elm_box_pack_end(box, o);
evas_object_smart_callback_add(o, "changed", _poll_changed, nc);
evas_object_show(o);
o = elm_radio_add(box);
elm_radio_state_value_set(o, 4);
elm_radio_group_add(o, group);
E_EXPAND(o);
E_ALIGN(o, 0, 0);
elm_object_text_set(o, _("Very Slow (256 ticks)"));
elm_box_pack_end(box, o);
evas_object_smart_callback_add(o, "changed", _poll_changed, nc);
evas_object_show(o);
switch (inst->cfg->netstatus.poll_interval)
{
case 4:
elm_radio_value_set(group, 0);
break;
case 8:
elm_radio_value_set(group, 1);
break;
case 32:
elm_radio_value_set(group, 2);
break;
case 64:
elm_radio_value_set(group, 3);
break;
case 256:
elm_radio_value_set(group, 4);
break;
default:
elm_radio_value_set(group, 2);
}
elm_object_content_set(frame, box);
frame = elm_frame_add(main_box);
elm_object_text_set(frame, _("Maximum Throughput"));
E_EXPAND(frame);
E_FILL(frame);
elm_box_pack_end(main_box, frame);
evas_object_show(frame);
box = elm_box_add(frame);
elm_box_horizontal_set(box, EINA_FALSE);
E_EXPAND(box);
evas_object_show(box);
check = elm_check_add(box);
elm_object_text_set(check, _("Use Automatic Maximums"));
elm_check_state_set(check, inst->cfg->netstatus.automax);
evas_object_size_hint_align_set(check, EVAS_HINT_FILL, 0.5);
evas_object_size_hint_weight_set(check, EVAS_HINT_EXPAND, 0.0);
evas_object_smart_callback_add(check, "changed", _check_changed, nc);
elm_box_pack_end(box, check);
evas_object_show(check);
nc->transfer_check = check;
slider = elm_slider_add(box);
elm_object_text_set(slider, _("Receive:"));
elm_slider_unit_format_set(slider, "%1.0f");
elm_slider_indicator_format_set(slider, "%1.0f");
elm_slider_min_max_set(slider, 0, 1000);
elm_slider_value_set(slider, inst->cfg->netstatus.inmax);
elm_slider_step_set(slider, 0.05);
elm_slider_span_size_set(slider, 100);
evas_object_size_hint_align_set(slider, EVAS_HINT_FILL, 0.5);
evas_object_size_hint_weight_set(slider, EVAS_HINT_EXPAND, 0.0);
evas_object_smart_callback_add(slider, "delay,changed", _update_receive_maximums, nc);
if (inst->cfg->netstatus.automax) elm_object_disabled_set(slider, EINA_TRUE);
elm_box_pack_end(box, slider);
evas_object_show(slider);
nc->receive_max = slider;
hover = elm_hoversel_add(box);
elm_hoversel_auto_update_set(hover, EINA_TRUE);
elm_hoversel_hover_parent_set(hover, popup);
elm_hoversel_item_add(hover, _("Bytes"), NULL, ELM_ICON_NONE, NULL, NULL);
if (inst->cfg->netstatus.receive_units == NETSTATUS_UNIT_BYTES)
{
elm_object_text_set(hover, _("Bytes"));
nc->receive_unit_adjust = 1;
}
elm_hoversel_item_add(hover, _("KB"), NULL, ELM_ICON_NONE, NULL, NULL);
if (inst->cfg->netstatus.receive_units == NETSTATUS_UNIT_KB)
{
elm_object_text_set(hover, _("KB"));
nc->receive_unit_adjust = 1024;
}
elm_hoversel_item_add(hover, _("MB"), NULL, ELM_ICON_NONE, NULL, NULL);
if (inst->cfg->netstatus.receive_units == NETSTATUS_UNIT_MB)
{
elm_object_text_set(hover, _("MB"));
nc->receive_unit_adjust = 2048;
}
elm_hoversel_item_add(hover, _("GB"), NULL, ELM_ICON_NONE, NULL, NULL);
if (inst->cfg->netstatus.receive_units == NETSTATUS_UNIT_GB)
{
elm_object_text_set(hover, _("GB"));
nc->receive_unit_adjust = 3072;
}
evas_object_size_hint_align_set(hover, EVAS_HINT_FILL, 0.5);
evas_object_size_hint_weight_set(hover, EVAS_HINT_EXPAND, 0.0);
if (inst->cfg->netstatus.automax) elm_object_disabled_set(hover, EINA_TRUE);
evas_object_smart_callback_add(hover, "selected", _receive_hover_changed, nc);
elm_box_pack_end(box, hover);
evas_object_show(hover);
nc->receive_units = hover;
elm_slider_value_set(nc->receive_max, ceil((double)inst->cfg->netstatus.inmax / (double)nc->receive_unit_adjust));
slider = elm_slider_add(box);
elm_object_text_set(slider, _("Send:"));
elm_slider_unit_format_set(slider, "%1.0f");
elm_slider_indicator_format_set(slider, "%1.0f");
elm_slider_min_max_set(slider, 0, 1000);
elm_slider_value_set(slider, inst->cfg->netstatus.outmax);
elm_slider_step_set(slider, 0.05);
elm_slider_span_size_set(slider, 100);
evas_object_size_hint_align_set(slider, EVAS_HINT_FILL, 0.5);
evas_object_size_hint_weight_set(slider, EVAS_HINT_EXPAND, 0.0);
evas_object_smart_callback_add(slider, "delay,changed", _update_send_maximums, nc);
if (inst->cfg->netstatus.automax) elm_object_disabled_set(slider, EINA_TRUE);
elm_box_pack_end(box, slider);
evas_object_show(slider);
nc->send_max = slider;
hover = elm_hoversel_add(box);
elm_hoversel_auto_update_set(hover, EINA_TRUE);
elm_hoversel_hover_parent_set(hover, popup);
elm_hoversel_item_add(hover, _("Bytes"), NULL, ELM_ICON_NONE, NULL, nc);
if (inst->cfg->netstatus.send_units == NETSTATUS_UNIT_BYTES)
{
elm_object_text_set(hover, _("Bytes"));
nc->send_unit_adjust = 1;
}
elm_hoversel_item_add(hover, _("KB"), NULL, ELM_ICON_NONE, NULL, nc);
if (inst->cfg->netstatus.send_units == NETSTATUS_UNIT_KB)
{
elm_object_text_set(hover, _("KB"));
nc->send_unit_adjust = 1024;
}
elm_hoversel_item_add(hover, _("MB"), NULL, ELM_ICON_NONE, NULL, nc);
if (inst->cfg->netstatus.send_units == NETSTATUS_UNIT_MB)
{
elm_object_text_set(hover, _("MB"));
nc->send_unit_adjust = 2048;
}
elm_hoversel_item_add(hover, _("GB"), NULL, ELM_ICON_NONE, NULL, nc);
if (inst->cfg->netstatus.send_units == NETSTATUS_UNIT_GB)
{
elm_object_text_set(hover, _("GB"));
nc->send_unit_adjust = 3072;
}
evas_object_size_hint_align_set(hover, EVAS_HINT_FILL, 0.5);
evas_object_size_hint_weight_set(hover, EVAS_HINT_EXPAND, 0.0);
if (inst->cfg->netstatus.automax) elm_object_disabled_set(hover, EINA_TRUE);
evas_object_smart_callback_add(hover, "selected", _send_hover_changed, nc);
elm_box_pack_end(box, hover);
evas_object_show(hover);
nc->send_units = hover;
elm_slider_value_set(nc->send_max, ceil((double)inst->cfg->netstatus.outmax / (double)nc->send_unit_adjust));
elm_object_content_set(frame, box);
popup = e_comp_object_util_add(popup, E_COMP_OBJECT_TYPE_NONE);
evas_object_layer_set(popup, E_LAYER_POPUP);
evas_object_resize(popup, zone->w / 4, zone->h / 3);
e_comp_object_util_center_on_zone(popup, zone);
evas_object_show(popup);
e_comp_object_util_autoclose(popup, NULL, e_comp_object_util_autoclose_on_escape, NULL);
evas_object_event_callback_add(popup, EVAS_CALLBACK_DEL, _config_close, nc);
return inst->cfg->netstatus.configure = popup;
}

93
src/modules/sysinfo/netstatus/netstatus_proc.c
View File

@ -1,93 +0,0 @@
#include "netstatus.h"
void
_netstatus_proc_getstatus(Eina_Bool automax,
time_t *last_checked,
unsigned long *prev_in,
unsigned long *prev_incurrent,
unsigned long *prev_inmax,
int *prev_inpercent,
unsigned long *prev_out,
unsigned long *prev_outcurrent,
unsigned long *prev_outmax,
int *prev_outpercent)
{
unsigned long in, out, dummy, tot_in = 0, tot_out = 0;
unsigned long diffin, diffout;
int percent = 0;
char buf[4096], dummys[64];
FILE *f;
time_t current = time(NULL);
time_t diff = 0;
if (!*last_checked)
*last_checked = current;
if ((current - *last_checked) < 1)
return;
else
diff = current - *last_checked;
f = fopen("/proc/net/dev", "r");
if (f)
{
while (fgets(buf, sizeof(buf), f) != NULL)
{
if (sscanf(buf, "%s %lu %lu %lu %lu %lu %lu %lu %lu %lu %lu %lu %lu "
"%lu %lu %lu %lu\n", dummys, &in, &dummy, &dummy,
&dummy, &dummy, &dummy, &dummy, &dummy, &out, &dummy,
&dummy, &dummy, &dummy, &dummy, &dummy, &dummy) < 17)
continue;
tot_in += in;
tot_out += out;
}
fclose(f);
}
diffin = tot_in - *prev_in;
if (diff > 1)
diffin /= diff;
if (!*prev_in)
*prev_in = tot_in;
else
{
*prev_in = tot_in;
if (automax)
{
if (diffin > *prev_inmax)
*prev_inmax = diffin;
}
*prev_incurrent = diffin;
if (*prev_inmax > 0)
percent = 100 * ((float)*prev_incurrent / (float)*prev_inmax);
if (percent > 100) percent = 100;
else if (percent < 0)
percent = 0;
*prev_inpercent = percent;
}
percent = 0;
diffout = tot_out - *prev_out;
if (diff > 1)
diffout /= diff;
if (!*prev_out)
*prev_out = tot_out;
else
{
*prev_out = tot_out;
if (automax)
{
if (diffout > *prev_outmax)
*prev_outmax = diffout;
}
*prev_outcurrent = diffout;
if (*prev_outcurrent > 0)
percent = 100 * ((float)*prev_outcurrent / (float)*prev_outmax);
if (percent > 100) percent = 100;
else if (percent < 0)
percent = 0;
*prev_outpercent = percent;
}
*last_checked = current;
}

188
src/modules/sysinfo/netstatus/netstatus_sysctl.c
View File

@ -1,188 +0,0 @@
#include "netstatus.h"
#if defined(__FreeBSD__) || defined(__DragonFly__)
# include <sys/socket.h>
# include <sys/sysctl.h>
# include <net/if.h>
# include <net/if_mib.h>
#endif
#if defined(__OpenBSD__)
# include <sys/types.h>
# include <sys/socket.h>
# include <sys/sysctl.h>
# include <sys/sockio.h>
# include <sys/ioctl.h>
# include <net/if.h>
# include <net/if_types.h>
# include <ifaddrs.h>
#endif
#if defined(__FreeBSD__) || defined(__DragonFly__)
static int
get_ifmib_general(int row, struct ifmibdata *data)
{
int mib[6];
size_t len;
mib[0] = CTL_NET;
mib[1] = PF_LINK;
mib[2] = NETLINK_GENERIC;
mib[3] = IFMIB_IFDATA;
mib[4] = row;
mib[5] = IFDATA_GENERAL;
len = sizeof(*data);
return sysctl(mib, 6, data, &len, NULL, 0);
}
static void
_freebsd_generic_network_status(unsigned long int *in, unsigned long int *out)
{
struct ifmibdata *ifmd;
size_t len;
int i, count;
len = sizeof(count);
if (sysctlbyname("net.link.generic.system.ifcount", &count, &len, NULL, 0) < 0)
return;
ifmd = malloc(sizeof(struct ifmibdata));
if (!ifmd)
return;
for (i = 1; i <= count; i++)
{
get_ifmib_general(i, ifmd);
*in += ifmd->ifmd_data.ifi_ibytes;
*out += ifmd->ifmd_data.ifi_obytes;
}
free(ifmd);
}
#endif
#if defined(__OpenBSD__)
static void
_openbsd_generic_network_status(unsigned long int *in, unsigned long int *out)
{
struct ifaddrs *interfaces, *ifa;
if (getifaddrs(&interfaces) < 0)
return;
int sock = socket(AF_INET, SOCK_STREAM, 0);
if (sock < 0)
return;
for (ifa = interfaces; ifa; ifa = ifa->ifa_next)
{
struct ifreq ifreq;
struct if_data if_data;
ifreq.ifr_data = (void *)&if_data;
strncpy(ifreq.ifr_name, ifa->ifa_name, IFNAMSIZ - 1);
if (ioctl(sock, SIOCGIFDATA, &ifreq) < 0)
return;
struct if_data *const ifi = &if_data;
if (ifi->ifi_type == IFT_ETHER || ifi->ifi_type == IFT_IEEE80211)
{
if (ifi->ifi_ibytes)
*in += ifi->ifi_ibytes;
else
*in += 0;
if (ifi->ifi_obytes)
*out += ifi->ifi_obytes;
else
*out += 0;
}
}
close(sock);
}
#endif
void
_netstatus_sysctl_getstatus(Eina_Bool automax,
time_t *last_checked,
unsigned long *prev_in,
unsigned long *prev_incurrent,
unsigned long *prev_inmax,
int *prev_inpercent,
unsigned long *prev_out,
unsigned long *prev_outcurrent,
unsigned long *prev_outmax,
int *prev_outpercent)
{
unsigned long tot_out = 0, tot_in = 0, diffin, diffout;
int percent = 0;
unsigned long int incoming = 0, outgoing = 0;
time_t current = time(NULL);
time_t diff = 0;
#if defined(__OpenBSD__)
_openbsd_generic_network_status(&incoming, &outgoing);
#elif defined(__FreeBSD__) || defined(__DragonFly__)
_freebsd_generic_network_status(&incoming, &outgoing);
#endif
if (!*last_checked)
*last_checked = current;
if ((current - *last_checked) < 1)
return;
else
diff = current - *last_checked;
tot_in = incoming;
tot_out = outgoing;
diffin = tot_in - *prev_in;
if (diff > 1)
diffin /= diff;
if (!*prev_in)
*prev_in = tot_in;
else
{
*prev_in = tot_in;
if (automax)
{
if (diffin > *prev_inmax)
*prev_inmax = diffin;
}
*prev_incurrent = diffin;
if (*prev_inmax > 0)
percent = 100 * ((float)*prev_incurrent / (float)*prev_inmax);
if (percent > 100) percent = 100;
else if (percent < 0)
percent = 0;
*prev_inpercent = percent;
}
percent = 0;
diffout = tot_out - *prev_out;
if (diff > 1)
diffout /= diff;
if (!*prev_out)
*prev_out = tot_out;
else
{
*prev_out = tot_out;
if (automax)
{
if (diffout > *prev_outmax)
*prev_outmax = diffout;
}
*prev_outcurrent = diffout;
if (*prev_outcurrent > 0)
percent = 100 * ((float)*prev_outcurrent / (float)*prev_outmax);
if (percent > 100) percent = 100;
else if (percent < 0)
percent = 0;
*prev_outpercent = percent;
}
*last_checked = current;
}

176
src/modules/sysinfo/sysinfo.c
View File

@ -1,176 +0,0 @@
#include "sysinfo.h"
static void _sysinfo_deleted_cb(void *data, Evas *e EINA_UNUSED, Evas_Object *obj EINA_UNUSED, void *event_data EINA_UNUSED);
static void
_sysinfo_removed_cb(void *data, Evas_Object *obj EINA_UNUSED, void *event_data)
{
Instance *inst = data;
if (!inst) return;
if (inst->o_main != event_data) return;
sysinfo_batman_remove(inst, NULL, NULL, NULL);
sysinfo_thermal_remove(inst, NULL, NULL, NULL);
sysinfo_cpuclock_remove(inst, NULL, NULL, NULL);
sysinfo_cpumonitor_remove(inst, NULL, NULL, NULL);
sysinfo_memusage_remove(inst, NULL, NULL, NULL);
sysinfo_netstatus_remove(inst, NULL, NULL, NULL);
evas_object_smart_callback_del_full(e_gadget_site_get(obj), "gadget_removed", _sysinfo_removed_cb, inst);
evas_object_event_callback_del_full(inst->o_main, EVAS_CALLBACK_DEL, _sysinfo_deleted_cb, data);
if (inst->cfg)
{
sysinfo_config->items = eina_list_remove(sysinfo_config->items, inst->cfg);
if (inst->cfg->id >= 0)
sysinfo_instances = eina_list_remove(sysinfo_instances, inst);
E_FREE(inst->cfg);
E_FREE(inst);
}
}
static void
_sysinfo_deleted_cb(void *data, Evas *e EINA_UNUSED, Evas_Object *obj EINA_UNUSED, void *event_data EINA_UNUSED)
{
Instance *inst = data;
sysinfo_batman_remove(inst, NULL, NULL, NULL);
sysinfo_thermal_remove(inst, NULL, NULL, NULL);
sysinfo_cpuclock_remove(inst, NULL, NULL, NULL);
sysinfo_cpumonitor_remove(inst, NULL, NULL, NULL);
sysinfo_memusage_remove(inst, NULL, NULL, NULL);
sysinfo_netstatus_remove(inst, NULL, NULL, NULL);
}
static void
_sysinfo_created_cb(void *data, Evas_Object *obj, void *event_data EINA_UNUSED)
{
Instance *inst = data;
inst->o_table = elm_table_add(inst->o_main);
elm_table_homogeneous_set(inst->o_table, EINA_FALSE);
E_EXPAND(inst->o_table);
elm_object_content_set(inst->o_main, inst->o_table);
evas_object_show(inst->o_table);
inst->cfg->sysinfo.o_batman = sysinfo_batman_create(inst->o_table, inst);
elm_table_pack(inst->o_table, inst->cfg->sysinfo.o_batman, 0, 0, 1, 1);
inst->cfg->sysinfo.o_cpuclock = sysinfo_cpuclock_create(inst->o_table, inst);
elm_table_pack(inst->o_table, inst->cfg->sysinfo.o_cpuclock, 1, 0, 1, 1);
inst->cfg->sysinfo.o_cpumonitor = sysinfo_cpumonitor_create(inst->o_table, inst);
elm_table_pack(inst->o_table, inst->cfg->sysinfo.o_cpumonitor, 0, 1, 1, 1);
inst->cfg->sysinfo.o_memusage = sysinfo_memusage_create(inst->o_table, inst);
elm_table_pack(inst->o_table, inst->cfg->sysinfo.o_memusage, 1, 1, 1, 1);
inst->cfg->sysinfo.o_thermal = sysinfo_thermal_create(inst->o_table, inst);
elm_table_pack(inst->o_table, inst->cfg->sysinfo.o_thermal, 0, 2, 1, 1);
inst->cfg->sysinfo.o_netstatus = sysinfo_netstatus_create(inst->o_table, inst);
elm_table_pack(inst->o_table, inst->cfg->sysinfo.o_netstatus, 1, 2, 1, 1);
evas_object_smart_callback_del_full(obj, "gadget_created", _sysinfo_created_cb, data);
}
static Config_Item *
_conf_item_get(int *id)
{
Config_Item *ci;
Eina_List *l;
if (*id > 0)
{
EINA_LIST_FOREACH(sysinfo_config->items, l, ci)
if (*id == ci->id && ci->esm == E_SYSINFO_MODULE_SYSINFO) return ci;
}
ci = E_NEW(Config_Item, 1);
if (*id != -1)
ci->id = eina_list_count(sysinfo_config->items) + 1;
else
ci->id = -1;
ci->esm = E_SYSINFO_MODULE_SYSINFO;
ci->batman.poll_interval = 512;
ci->batman.alert = 30;
ci->batman.alert_p = 10;
ci->batman.alert_timeout = 0;
ci->batman.suspend_below = 0;
ci->batman.force_mode = 0;
ci->batman.full = -2;
ci->batman.time_left = -2;
ci->batman.have_battery = -2;
ci->batman.have_power = -2;
#if defined(HAVE_EEZE) || defined(__OpenBSD__) || defined(__NetBSD__)
ci->batman.fuzzy = 0;
#endif
ci->batman.desktop_notifications = 0;
ci->batman.popup = NULL;
ci->batman.configure = NULL;
ci->thermal.poll_interval = 128;
ci->thermal.low = 30;
ci->thermal.high = 80;
ci->thermal.sensor_type = SENSOR_TYPE_NONE;
ci->thermal.sensor_name = NULL;
ci->thermal.units = CELSIUS;
ci->thermal.popup = NULL;
ci->thermal.configure = NULL;
ci->cpuclock.poll_interval = 32;
ci->cpuclock.restore_governor = 0;
ci->cpuclock.auto_powersave = 1;
ci->cpuclock.powersave_governor = NULL;
ci->cpuclock.governor = NULL;
ci->cpuclock.pstate_min = 1;
ci->cpuclock.pstate_max = 101;
ci->cpuclock.popup = NULL;
ci->cpuclock.configure = NULL;
ci->cpumonitor.poll_interval = 32;
ci->cpumonitor.percent = 0;
ci->cpumonitor.popup = NULL;
ci->cpumonitor.configure = NULL;
ci->memusage.poll_interval = 32;
ci->memusage.mem_percent = 0;
ci->memusage.swp_percent = 0;
ci->memusage.popup = NULL;
ci->memusage.configure = NULL;
ci->netstatus.poll_interval = 32;
ci->netstatus.instring = NULL;
ci->netstatus.outstring = NULL;
ci->netstatus.popup = NULL;
ci->netstatus.configure = NULL;
ci->netstatus.automax = EINA_TRUE;
ci->netstatus.inmax = 0;
ci->netstatus.outmax = 0;
ci->netstatus.receive_units = NETSTATUS_UNIT_BYTES;
ci->netstatus.send_units = NETSTATUS_UNIT_BYTES;
sysinfo_config->items = eina_list_append(sysinfo_config->items, ci);
return ci;
}
Evas_Object *
sysinfo_create(Evas_Object *parent, int *id, E_Gadget_Site_Orient orient)
{
Instance *inst;
if (orient) return NULL;
inst = E_NEW(Instance, 1);
inst->cfg = _conf_item_get(id);
*id = inst->cfg->id;
inst->o_main = elm_scroller_add(parent);
elm_object_style_set(inst->o_main, "no_inset_shadow");
E_EXPAND(inst->o_main);
evas_object_event_callback_add(inst->o_main, EVAS_CALLBACK_DEL, _sysinfo_deleted_cb, inst);
evas_object_show(inst->o_main);
evas_object_smart_callback_add(parent, "gadget_created", _sysinfo_created_cb, inst);
evas_object_smart_callback_add(parent, "gadget_removed", _sysinfo_removed_cb, inst);
if (inst->cfg->id < 0) return inst->o_main;
sysinfo_instances =
eina_list_append(sysinfo_instances, inst);
return inst->o_main;
}

302
src/modules/sysinfo/sysinfo.h
View File

@ -1,302 +0,0 @@
#ifndef SYSINFO_H
#define SYSINFO_H
#include "e.h"
#if defined(HAVE_EEZE)
# include <Eeze.h>
#else
# include <Eldbus.h>
#endif
E_API extern E_Module_Api e_modapi;
E_API void *e_modapi_init (E_Module *m);
E_API int e_modapi_shutdown (E_Module *m);
E_API int e_modapi_save (E_Module *m);
typedef enum _E_Sysinfo_Module E_Sysinfo_Module;
enum _E_Sysinfo_Module
{
E_SYSINFO_MODULE_NONE = 0,
E_SYSINFO_MODULE_BATMAN ,
E_SYSINFO_MODULE_THERMAL,
E_SYSINFO_MODULE_CPUCLOCK,
E_SYSINFO_MODULE_CPUMONITOR,
E_SYSINFO_MODULE_MEMUSAGE,
E_SYSINFO_MODULE_NETSTATUS,
E_SYSINFO_MODULE_SYSINFO
};
typedef enum _Netstatus_Unit Netstatus_Unit;
enum _Netstatus_Unit
{
NETSTATUS_UNIT_BYTES = 0,
NETSTATUS_UNIT_KB,
NETSTATUS_UNIT_MB,
NETSTATUS_UNIT_GB
};
typedef enum _Sensor_Type
{
SENSOR_TYPE_NONE,
#if defined(__FreeBSD__) || defined(__OpenBSD__) || defined(__DragonFly__)
SENSOR_TYPE_FREEBSD,
SENSOR_TYPE_OPENBSD,
#else
SENSOR_TYPE_OMNIBOOK,
SENSOR_TYPE_LINUX_MACMINI,
SENSOR_TYPE_LINUX_I2C,
SENSOR_TYPE_LINUX_ACPI,
SENSOR_TYPE_LINUX_PCI,
SENSOR_TYPE_LINUX_PBOOK,
SENSOR_TYPE_LINUX_INTELCORETEMP,
SENSOR_TYPE_LINUX_THINKPAD,
SENSOR_TYPE_LINUX_SYS
#endif
} Sensor_Type;
typedef enum _Unit
{
CELSIUS,
FAHRENHEIT
} Unit;
typedef struct _Tempthread Tempthread;
typedef struct _Cpu_Status Cpu_Status;
typedef struct _CPU_Core CPU_Core;
typedef struct _Config Config;
typedef struct _Config_Item Config_Item;
typedef struct _Instance Instance;
struct _Tempthread
{
Instance *inst;
int poll_interval;
Sensor_Type sensor_type;
const char *sensor_name;
const char *sensor_path;
void *extn;
E_Powersave_Sleeper *sleeper;
#if defined(HAVE_EEZE)
Eina_List *tempdevs;
#endif
Eina_Bool initted E_BITFIELD;
};
struct _Cpu_Status
{
Eina_List *frequencies;
Eina_List *governors;
int cur_frequency;
#if defined(__FreeBSD__) || defined(__DragonFly__) || defined(__OpenBSD__)
int cur_percent;
#endif
int cur_min_frequency;
int cur_max_frequency;
int can_set_frequency;
int pstate_min;
int pstate_max;
char *cur_governor;
const char *orig_governor;
unsigned char active;
unsigned char pstate;
unsigned char pstate_turbo;
};
struct _CPU_Core
{
int percent;
long total;
long idle;
Evas_Object *layout;
};
struct _Config
{
Eina_List *items;
E_Module *module;
Evas_Object *config_dialog;
};
struct _Config_Item
{
int id;
int version;
E_Sysinfo_Module esm;
struct
{
Evas_Object *o_gadget;
Evas_Object *popup;
Evas_Object *configure;
/* saved * loaded config values */
int poll_interval;
int alert; /* Alert on minutes remaining */
int alert_p; /* Alert on percentage remaining */
int alert_timeout; /* Popup dismissal timeout */
int suspend_below; /* Suspend if battery drops below this level */
int suspend_method; /* Method used to suspend the machine */
int force_mode; /* force use of batget or hal */
/* just config state */
Ecore_Timer *alert_timer;
int full;
int time_left;
int have_battery;
int have_power;
int desktop_notifications;
Eina_List *handlers;
Eina_Bool done;
#if defined(HAVE_EEZE)
Eeze_Udev_Watch *acwatch;
Eeze_Udev_Watch *batwatch;
#endif
#if defined(HAVE_EEZE) || defined(__OpenBSD__) || defined(__NetBSD__)
Eina_Bool fuzzy;
int fuzzcount;
#endif
} batman;
struct
{
Evas_Object *o_gadget;
Evas_Object *configure;
Evas_Object *popup;
Evas_Object *popup_pbar;
int poll_interval;
int low, high;
int sensor_type;
int temp;
int percent;
const char *sensor_name;
Unit units;
#if defined(HAVE_EEZE)
Ecore_Poller *poller;
Tempthread *tth;
#endif
Ecore_Thread *th;
Eina_Bool have_temp E_BITFIELD;
Eina_List *handlers;
Eina_Bool defer;
Eina_Bool done;
} thermal;
struct
{
Evas_Object *o_gadget;
Evas_Object *popup;
Evas_Object *popup_pbar;
Evas_Object *configure;
int poll_interval;
int restore_governor;
int auto_powersave;
int percent;
int tot_min_frequency;
int tot_max_frequency;
const char *powersave_governor;
const char *governor;
int pstate_min;
int pstate_max;
Cpu_Status *status;
Ecore_Thread *frequency_check_thread;
Eina_List *handlers;
} cpuclock;
struct
{
Evas_Object *o_gadget;
Evas_Object *o_gadget_box;
Evas_Object *event;
Evas_Object *popup;
Evas_Object *popup_pbar;
Evas_Object *configure;
int poll_interval;
int percent;
int cores;
Ecore_Thread *usage_check_thread;
Eina_List *handlers;
} cpumonitor;
struct
{
Evas_Object *o_gadget;
Evas_Object *popup;
Evas_Object *configure;
int poll_interval;
int mem_percent;
int swp_percent;
unsigned long mem_total;
unsigned long mem_used;
unsigned long mem_cached;
unsigned long mem_buffers;
unsigned long mem_shared;
unsigned long swp_total;
unsigned long swp_used;
Ecore_Thread *usage_check_thread;
Eina_List *handlers;
} memusage;
struct
{
Evas_Object *o_gadget;
Evas_Object *popup;
Evas_Object *popup_inpbar;
Evas_Object *popup_outpbar;
Evas_Object *configure;
Eina_Bool automax;
Netstatus_Unit receive_units;
Netstatus_Unit send_units;
int poll_interval;
int inpercent;
int outpercent;
unsigned long inmax;
unsigned long outmax;
Ecore_Thread *usage_check_thread;
Eina_List *handlers;
Eina_Stringshare *instring;
Eina_Stringshare *outstring;
} netstatus;
struct {
Evas_Object *o_batman;
Evas_Object *o_thermal;
Evas_Object *o_cpuclock;
Evas_Object *o_cpumonitor;
Evas_Object *o_memusage;
Evas_Object *o_netstatus;
} sysinfo;
};
struct _Instance
{
Evas_Object *o_main;
Evas_Object *o_table;
Evas_Object *popup_battery;
Evas_Object *warning;
Config_Item *cfg;
unsigned int notification_id;
};
EINTERN Evas_Object *config_sysinfo(E_Zone *zone, Instance *inst, E_Sysinfo_Module esm);
EINTERN Evas_Object *batman_create(Evas_Object *parent, int *id, E_Gadget_Site_Orient orient);
EINTERN Evas_Object *thermal_create(Evas_Object *parent, int *id, E_Gadget_Site_Orient orient);
EINTERN Evas_Object *cpuclock_create(Evas_Object *parent, int *id, E_Gadget_Site_Orient orient);
EINTERN Evas_Object *cpumonitor_create(Evas_Object *parent, int *id, E_Gadget_Site_Orient orient);
EINTERN Evas_Object *memusage_create(Evas_Object *parent, int *id, E_Gadget_Site_Orient orient);
EINTERN Evas_Object *netstatus_create(Evas_Object *parent, int *id, E_Gadget_Site_Orient orient);
EINTERN Evas_Object *sysinfo_create(Evas_Object *parent, int *id, E_Gadget_Site_Orient orient);
EINTERN Evas_Object *config_sysinfo(E_Zone *zone, Instance *inst, E_Sysinfo_Module esm);
EINTERN Evas_Object *sysinfo_batman_create(Evas_Object *parent, Instance *inst);
EINTERN Evas_Object *sysinfo_thermal_create(Evas_Object *parent, Instance *inst);
EINTERN Evas_Object *sysinfo_cpuclock_create(Evas_Object *parent, Instance *inst);
EINTERN Evas_Object *sysinfo_cpumonitor_create(Evas_Object *parent, Instance *inst);
EINTERN Evas_Object *sysinfo_memusage_create(Evas_Object *parent, Instance *inst);
EINTERN Evas_Object *sysinfo_netstatus_create(Evas_Object *parent, Instance *inst);
EINTERN void sysinfo_batman_remove(void *data, Evas *e EINA_UNUSED, Evas_Object *obj EINA_UNUSED, void *event_data EINA_UNUSED);
EINTERN void sysinfo_thermal_remove(void *data, Evas *e EINA_UNUSED, Evas_Object *obj EINA_UNUSED, void *event_data EINA_UNUSED);
EINTERN void sysinfo_cpuclock_remove(void *data, Evas *e EINA_UNUSED, Evas_Object *obj EINA_UNUSED, void *event_data EINA_UNUSED);
EINTERN void sysinfo_cpumonitor_remove(void *data, Evas *e EINA_UNUSED, Evas_Object *obj EINA_UNUSED, void *event_data EINA_UNUSED);
EINTERN void sysinfo_memusage_remove(void *data, Evas *e EINA_UNUSED, Evas_Object *obj EINA_UNUSED, void *event_data EINA_UNUSED);
EINTERN void sysinfo_netstatus_remove(void *data, Evas *e EINA_UNUSED, Evas_Object *obj EINA_UNUSED, void *event_data EINA_UNUSED);
EINTERN extern Config *sysinfo_config;
EINTERN extern Eina_List *sysinfo_instances;
#endif

509
src/modules/sysinfo/thermal/thermal.c
View File

@ -1,509 +0,0 @@
#include "thermal.h"
static void
_thermal_thread_free(Tempthread *tth)
{
#if defined(HAVE_EEZE)
const char *s;
#endif
if (!tth) return;
eina_stringshare_del(tth->sensor_name);
eina_stringshare_del(tth->sensor_path);
#if defined(HAVE_EEZE)
EINA_LIST_FREE(tth->tempdevs, s)
eina_stringshare_del(s);
#endif
e_powersave_sleeper_free(tth->sleeper);
E_FREE(tth->extn);
E_FREE(tth);
}
static void
_thermal_face_level_set(Instance *inst, double level)
{
Edje_Message_Float msg;
if (level < 0.0) level = 0.0;
else if (level > 1.0)
level = 1.0;
inst->cfg->thermal.percent = level * 100;
msg.val = level;
edje_object_message_send(elm_layout_edje_get(inst->cfg->thermal.o_gadget), EDJE_MESSAGE_FLOAT, 1, &msg);
}
static void
_thermal_apply(Instance *inst, int temp)
{
if (inst->cfg->thermal.temp == temp) return;
inst->cfg->thermal.temp = temp;
if (temp != -999)
{
if (inst->cfg->thermal.units == FAHRENHEIT) temp = (temp * 9.0 / 5.0) + 32;
if (!inst->cfg->thermal.have_temp)
{
/* enable therm object */
elm_layout_signal_emit(inst->cfg->thermal.o_gadget, "e,state,known", "");
inst->cfg->thermal.have_temp = EINA_TRUE;
}
_thermal_face_level_set(inst,
(double)(temp - inst->cfg->thermal.low) /
(double)(inst->cfg->thermal.high - inst->cfg->thermal.low));
}
else
{
if (inst->cfg->thermal.have_temp)
{
/* disable therm object */
elm_layout_signal_emit(inst->cfg->thermal.o_gadget, "e,state,unknown", "");
_thermal_face_level_set(inst, 0.5);
inst->cfg->thermal.have_temp = EINA_FALSE;
}
}
if (inst->cfg->thermal.popup)
{
char buf[4096];
if (inst->cfg->thermal.units == FAHRENHEIT)
snprintf(buf, sizeof(buf), "%d F (%d %%%%)",
(int)((inst->cfg->thermal.temp * 9.0 / 5.0) + 32),
inst->cfg->thermal.percent);
else
snprintf(buf, sizeof(buf), "%d C (%d %%%%)",
(int)inst->cfg->thermal.temp,
inst->cfg->thermal.percent);
elm_progressbar_unit_format_set(inst->cfg->thermal.popup_pbar, buf);
elm_progressbar_value_set(inst->cfg->thermal.popup_pbar,
(float)inst->cfg->thermal.percent / 100);
}
}
#if defined(HAVE_EEZE)
static Eina_Bool
_thermal_udev_poll(void *data)
{
Tempthread *tth = data;
int temp = thermal_udev_get(tth);
_thermal_apply(tth->inst, temp);
return EINA_TRUE;
}
#endif
#if defined(__FreeBSD__) || defined(__OpenBSD__) || defined(__DragonFly__)
static void
_thermal_check_sysctl(void *data, Ecore_Thread *th)
{
Tempthread *tth = data;
int ptemp = -500, temp;
for (;; )
{
if (ecore_thread_check(th)) break;
temp = thermal_sysctl_get(tth);
if (ptemp != temp) ecore_thread_feedback(th, (void *)((long)temp));
ptemp = temp;
e_powersave_sleeper_sleep(tth->sleeper, tth->poll_interval);
if (ecore_thread_check(th)) break;
}
}
#endif
#if !defined(HAVE_EEZE) && !defined(__FreeBSD__) && !defined(__OpenBSD__) && !defined(__DragonFly__)
static void
_thermal_check_fallback(void *data, Ecore_Thread *th)
{
Tempthread *tth = data;
int ptemp = -500, temp;
for (;; )
{
if (ecore_thread_check(th)) break;
temp = thermal_fallback_get(tth);
if (ptemp != temp) ecore_thread_feedback(th, (void *)((long)temp));
ptemp = temp;
e_powersave_sleeper_sleep(tth->sleeper, tth->poll_interval);
if (ecore_thread_check(th)) break;
}
}
#endif
#if !defined(HAVE_EEZE)
static void
_thermal_check_notify(void *data, Ecore_Thread *th, void *msg)
{
Tempthread *tth = data;
int temp = (int)((long)msg);
if (th != tth->inst->cfg->thermal.th) return;
_thermal_apply(tth->inst, temp);
}
static void
_thermal_check_done(void *data, Ecore_Thread *th EINA_UNUSED)
{
Tempthread *tth = data;
_thermal_thread_free(tth);
}
#endif
static Evas_Object *
_thermal_configure_cb(Evas_Object *g)
{
Instance *inst = evas_object_data_get(g, "Instance");
if (!sysinfo_config) return NULL;
return thermal_configure(inst);
}
static void
_thermal_popup_dismissed(void *data, Evas_Object *obj, void *event_info EINA_UNUSED)
{
Instance *inst = data;
E_FREE_FUNC(obj, evas_object_del);
inst->cfg->thermal.popup = NULL;
inst->cfg->thermal.popup_pbar = NULL;
}
static void
_thermal_popup_deleted(void *data, Evas *e EINA_UNUSED, Evas_Object *obj EINA_UNUSED, void *event_info EINA_UNUSED)
{
Instance *inst = data;
inst->cfg->thermal.popup = NULL;
}
static Evas_Object *
_thermal_popup_create(Instance *inst)
{
Evas_Object *popup, *table, *label, *pbar;
char text[4096], buf[100];
popup = elm_ctxpopup_add(e_comp->elm);
elm_object_style_set(popup, "noblock");
evas_object_smart_callback_add(popup, "dismissed",
_thermal_popup_dismissed, inst);
evas_object_event_callback_add(popup, EVAS_CALLBACK_DEL,
_thermal_popup_deleted, inst);
table = elm_table_add(popup);
E_EXPAND(table);
E_FILL(table);
elm_object_content_set(popup, table);
evas_object_show(table);
snprintf(text, sizeof(text), "<big><b>%s</b></big>", _("Temperature"));
label = elm_label_add(table);
E_EXPAND(label); E_ALIGN(label, 0.5, 0.5);
elm_object_text_set(label, text);
elm_table_pack(table, label, 0, 0, 2, 1);
evas_object_show(label);
if (inst->cfg->thermal.units == FAHRENHEIT)
snprintf(buf, sizeof(buf), "%d F (%d %%%%)",
(int)((inst->cfg->thermal.temp * 9.0 / 5.0) + 32),
inst->cfg->thermal.percent);
else
snprintf(buf, sizeof(buf), "%d C (%d %%%%)",
(int)inst->cfg->thermal.temp,
inst->cfg->thermal.percent);
pbar = elm_progressbar_add(table);
E_EXPAND(pbar); E_FILL(pbar);
elm_progressbar_span_size_set(pbar, 200 * e_scale);
elm_progressbar_unit_format_set(pbar, buf);
elm_progressbar_value_set(pbar, (float)inst->cfg->thermal.percent / 100);
elm_table_pack(table, pbar, 0, 1, 2, 1);
evas_object_show(pbar);
inst->cfg->thermal.popup_pbar = pbar;
e_gadget_util_ctxpopup_place(inst->o_main, popup,
inst->cfg->thermal.o_gadget);
evas_object_show(popup);
return popup;
}
static void
_thermal_mouse_up_cb(void *data, Evas *e EINA_UNUSED, Evas_Object *obj EINA_UNUSED, void *event_data)
{
Evas_Event_Mouse_Up *ev = event_data;
Instance *inst = data;
if (ev->event_flags & EVAS_EVENT_FLAG_ON_HOLD) return;
if (ev->button == 1)
{
if (inst->cfg->thermal.popup)
elm_ctxpopup_dismiss(inst->cfg->thermal.popup);
else
inst->cfg->thermal.popup = _thermal_popup_create(inst);
}
}
static Eina_Bool
_screensaver_on(void *data)
{
Instance *inst = data;
if (inst->cfg->thermal.th)
{
ecore_thread_cancel(inst->cfg->thermal.th);
inst->cfg->thermal.th = NULL;
}
return ECORE_CALLBACK_RENEW;
}
static Eina_Bool
_screensaver_off(void *data)
{
Instance *inst = data;
_thermal_config_updated(inst);
return ECORE_CALLBACK_RENEW;
}
void
_thermal_config_updated(Instance *inst)
{
Tempthread *tth;
if (inst->cfg->id == -1)
{
_thermal_face_level_set(inst, .60);
return;
}
if (inst->cfg->thermal.th) ecore_thread_cancel(inst->cfg->thermal.th);
tth = calloc(1, sizeof(Tempthread));
tth->poll_interval = inst->cfg->thermal.poll_interval;
tth->sensor_type = inst->cfg->thermal.sensor_type;
tth->inst = inst;
tth->sleeper = e_powersave_sleeper_new();
if (inst->cfg->thermal.sensor_name)
tth->sensor_name = eina_stringshare_add(inst->cfg->thermal.sensor_name);
#if defined(HAVE_EEZE)
_thermal_udev_poll(tth);
inst->cfg->thermal.poller = ecore_poller_add(ECORE_POLLER_CORE, inst->cfg->thermal.poll_interval,
_thermal_udev_poll, tth);
inst->cfg->thermal.tth = tth;
#elif defined(__FreeBSD__) || defined(__OpenBSD__) || defined(__DragonFly__)
inst->cfg->thermal.th = ecore_thread_feedback_run(_thermal_check_sysctl,
_thermal_check_notify,
_thermal_check_done,
_thermal_check_done,
tth, EINA_TRUE);
#else
inst->cfg->thermal.th = ecore_thread_feedback_run(_thermal_check_fallback,
_thermal_check_notify,
_thermal_check_done,
_thermal_check_done,
tth, EINA_TRUE);
#endif
}
static void
_thermal_face_shutdown(Instance *inst)
{
#if defined(HAVE_EEZE)
if (inst->cfg->thermal.poller)
{
E_FREE_FUNC(inst->cfg->thermal.poller, ecore_poller_del);
_thermal_thread_free(inst->cfg->thermal.tth);
}
#endif
if (inst->cfg->thermal.sensor_name) eina_stringshare_del(inst->cfg->thermal.sensor_name);
}
static void
_thermal_resize_cb(void *data, Evas *e EINA_UNUSED, Evas_Object *obj EINA_UNUSED, void *event_data EINA_UNUSED)
{
Evas_Coord w, h;
Instance *inst = data;
edje_object_parts_extends_calc(elm_layout_edje_get(inst->cfg->thermal.o_gadget), 0, 0, &w, &h);
if (w < 1) w = 1;
if (h < 1) h = 1;
if (inst->cfg->esm == E_SYSINFO_MODULE_THERMAL)
evas_object_size_hint_aspect_set(inst->o_main, EVAS_ASPECT_CONTROL_BOTH, w, h);
else
evas_object_size_hint_aspect_set(inst->cfg->thermal.o_gadget, EVAS_ASPECT_CONTROL_BOTH, w, h);
}
static void
_thermal_removed_cb(void *data, Evas_Object *obj EINA_UNUSED, void *event_data)
{
Instance *inst = data;
Ecore_Event_Handler *handler;
if (inst->o_main != event_data) return;
if (inst->cfg->thermal.popup_pbar)
E_FREE_FUNC(inst->cfg->thermal.popup_pbar, evas_object_del);
if (inst->cfg->thermal.popup)
E_FREE_FUNC(inst->cfg->thermal.popup, evas_object_del);
if (inst->cfg->thermal.configure)
E_FREE_FUNC(inst->cfg->thermal.configure, evas_object_del);
EINA_LIST_FREE(inst->cfg->thermal.handlers, handler)
ecore_event_handler_del(handler);
evas_object_event_callback_del_full(inst->o_main, EVAS_CALLBACK_DEL, sysinfo_thermal_remove, data);
evas_object_smart_callback_del_full(e_gadget_site_get(inst->o_main), "gadget_removed",
_thermal_removed_cb, inst);
if (inst->cfg->thermal.th)
{
ecore_thread_cancel(inst->cfg->thermal.th);
inst->cfg->thermal.th = NULL;
}
_thermal_face_shutdown(inst);
sysinfo_config->items = eina_list_remove(sysinfo_config->items, inst->cfg);
if (inst->cfg->id >= 0)
sysinfo_instances = eina_list_remove(sysinfo_instances, inst);
E_FREE(inst->cfg);
E_FREE(inst);
}
void
sysinfo_thermal_remove(void *data, Evas *e EINA_UNUSED, Evas_Object *obj EINA_UNUSED, void *event_data EINA_UNUSED)
{
Instance *inst = data;
Ecore_Event_Handler *handler;
if (inst->cfg->thermal.popup_pbar)
E_FREE_FUNC(inst->cfg->thermal.popup_pbar, evas_object_del);
if (inst->cfg->thermal.popup)
E_FREE_FUNC(inst->cfg->thermal.popup, evas_object_del);
if (inst->cfg->thermal.configure)
E_FREE_FUNC(inst->cfg->thermal.configure, evas_object_del);
EINA_LIST_FREE(inst->cfg->thermal.handlers, handler)
ecore_event_handler_del(handler);
if (inst->cfg->thermal.th)
{
ecore_thread_cancel(inst->cfg->thermal.th);
inst->cfg->thermal.th = NULL;
}
_thermal_face_shutdown(inst);
}
static void
_thermal_created_cb(void *data, Evas_Object *obj, void *event_data EINA_UNUSED)
{
Instance *inst = data;
E_Gadget_Site_Orient orient = e_gadget_site_orient_get(e_gadget_site_get(inst->o_main));
e_gadget_configure_cb_set(inst->o_main, _thermal_configure_cb);
inst->cfg->thermal.temp = 900;
inst->cfg->thermal.percent = 0;
inst->cfg->thermal.have_temp = EINA_FALSE;
inst->cfg->thermal.o_gadget = elm_layout_add(inst->o_main);
if (orient == E_GADGET_SITE_ORIENT_VERTICAL)
e_theme_edje_object_set(inst->cfg->thermal.o_gadget,
"base/theme/gadget/thermal",
"e/gadget/thermal/main_vert");
else
e_theme_edje_object_set(inst->cfg->thermal.o_gadget, "base/theme/gadget/thermal",
"e/gadget/thermal/main");
E_EXPAND(inst->cfg->thermal.o_gadget);
E_FILL(inst->cfg->thermal.o_gadget);
elm_box_pack_end(inst->o_main, inst->cfg->thermal.o_gadget);
evas_object_event_callback_add(inst->cfg->thermal.o_gadget,
EVAS_CALLBACK_MOUSE_UP,
_thermal_mouse_up_cb, inst);
evas_object_event_callback_add(inst->cfg->thermal.o_gadget, EVAS_CALLBACK_RESIZE, _thermal_resize_cb, inst);
evas_object_show(inst->cfg->thermal.o_gadget);
evas_object_smart_callback_del_full(obj, "gadget_created", _thermal_created_cb, data);
E_LIST_HANDLER_APPEND(inst->cfg->thermal.handlers, E_EVENT_SCREENSAVER_ON, _screensaver_on, inst);
E_LIST_HANDLER_APPEND(inst->cfg->thermal.handlers, E_EVENT_SCREENSAVER_OFF, _screensaver_off, inst);
_thermal_config_updated(inst);
}
Evas_Object *
sysinfo_thermal_create(Evas_Object *parent, Instance *inst)
{
inst->cfg->thermal.temp = 900;
inst->cfg->thermal.percent = 0;
inst->cfg->thermal.have_temp = EINA_FALSE;
inst->cfg->thermal.o_gadget = elm_layout_add(parent);
e_theme_edje_object_set(inst->cfg->thermal.o_gadget, "base/theme/gadget/thermal",
"e/gadget/thermal/main");
E_EXPAND(inst->cfg->thermal.o_gadget);
E_FILL(inst->cfg->thermal.o_gadget);
evas_object_event_callback_add(inst->cfg->thermal.o_gadget,
EVAS_CALLBACK_MOUSE_UP,
_thermal_mouse_up_cb, inst);
evas_object_event_callback_add(inst->cfg->thermal.o_gadget, EVAS_CALLBACK_RESIZE, _thermal_resize_cb, inst);
evas_object_show(inst->cfg->thermal.o_gadget);
E_LIST_HANDLER_APPEND(inst->cfg->thermal.handlers, E_EVENT_SCREENSAVER_ON, _screensaver_on, inst);
E_LIST_HANDLER_APPEND(inst->cfg->thermal.handlers, E_EVENT_SCREENSAVER_OFF, _screensaver_off, inst);
_thermal_config_updated(inst);
return inst->cfg->thermal.o_gadget;
}
static Config_Item *
_conf_item_get(int *id)
{
Config_Item *ci;
Eina_List *l;
if (*id > 0)
{
EINA_LIST_FOREACH(sysinfo_config->items, l, ci)
if (*id == ci->id && ci->esm == E_SYSINFO_MODULE_THERMAL) return ci;
}
ci = E_NEW(Config_Item, 1);
if (*id != -1)
ci->id = eina_list_count(sysinfo_config->items) + 1;
else
ci->id = -1;
ci->esm = E_SYSINFO_MODULE_THERMAL;
ci->thermal.poll_interval = 128;
ci->thermal.low = 30;
ci->thermal.high = 80;
ci->thermal.sensor_type = SENSOR_TYPE_NONE;
ci->thermal.sensor_name = NULL;
ci->thermal.units = CELSIUS;
ci->thermal.configure = NULL;
sysinfo_config->items = eina_list_append(sysinfo_config->items, ci);
return ci;
}
Evas_Object *
thermal_create(Evas_Object *parent, int *id, E_Gadget_Site_Orient orient EINA_UNUSED)
{
Instance *inst;
inst = E_NEW(Instance, 1);
inst->cfg = _conf_item_get(id);
*id = inst->cfg->id;
inst->o_main = elm_box_add(parent);
evas_object_data_set(inst->o_main, "Instance", inst);
evas_object_smart_callback_add(parent, "gadget_created", _thermal_created_cb, inst);
evas_object_smart_callback_add(parent, "gadget_removed", _thermal_removed_cb, inst);
evas_object_event_callback_add(inst->o_main, EVAS_CALLBACK_DEL, sysinfo_thermal_remove, inst);
evas_object_show(inst->o_main);
if (inst->cfg->id < 0) return inst->o_main;
sysinfo_instances =
eina_list_append(sysinfo_instances, inst);
return inst->o_main;
}

28
src/modules/sysinfo/thermal/thermal.h
View File

@ -1,28 +0,0 @@
#ifndef THERMAL_H
#define THERMAL_H
#include "../sysinfo.h"
typedef struct _Thermal_Config Thermal_Config;
struct _Thermal_Config
{
Instance *inst;
Evas_Object *high;
Evas_Object *low;
};
#if defined(HAVE_EEZE)
EINTERN int thermal_udev_get(Tempthread *tth);
#endif
#if defined(__OpenBSD__) || defined(__DragonFly__) || defined(__FreeBSD__)
EINTERN int thermal_sysctl_get(Tempthread *tth);
#endif
EINTERN Evas_Object *thermal_configure(Instance *inst);
EINTERN int thermal_fallback_get(Tempthread *tth);
EINTERN void _thermal_config_updated(Instance *inst);
#endif

369
src/modules/sysinfo/thermal/thermal_config.c
View File

@ -1,369 +0,0 @@
#include "thermal.h"
#define FAR_2_CEL(x) ((x - 32) / 9.0) * 5.0
#define CEL_2_FAR(x) (x * 9.0 / 5.0) + 32
static void
_config_close(void *data, Evas *e EINA_UNUSED, Evas_Object *obj EINA_UNUSED, void *event_info EINA_UNUSED)
{
Thermal_Config *tc = data;
Instance *inst = tc->inst;
E_FREE_FUNC(inst->cfg->thermal.configure, evas_object_del);
E_FREE(tc);
e_config_save_queue();
}
static void
_update_high_temperature(void *data, Evas_Object *obj EINA_UNUSED, void *event_info EINA_UNUSED)
{
Thermal_Config *tc = data;
Instance *inst = tc->inst;
int value = (int)elm_slider_value_get(tc->high);
inst->cfg->thermal.high = value;
e_config_save_queue();
_thermal_config_updated(inst);
}
static void
_update_low_temperature(void *data, Evas_Object *obj EINA_UNUSED, void *event_info EINA_UNUSED)
{
Thermal_Config *tc = data;
Instance *inst = tc->inst;
int value = (int)elm_slider_value_get(tc->low);
inst->cfg->thermal.low = value;
e_config_save_queue();
_thermal_config_updated(inst);
}
static void
_units_changed(void *data, Evas_Object *obj, void *event_info EINA_UNUSED)
{
Thermal_Config *tc = data;
Instance *inst = tc->inst;
int value = elm_radio_value_get(obj), val;
switch (value)
{
case 0:
inst->cfg->thermal.units = CELSIUS;
break;
case 1:
inst->cfg->thermal.units = FAHRENHEIT;
break;
default:
inst->cfg->thermal.units = CELSIUS;
}
if (inst->cfg->thermal.units == FAHRENHEIT)
{
elm_slider_min_max_set(tc->low, 0, 200);
elm_slider_min_max_set(tc->high, 0, 230);
val = (int)elm_slider_value_get(tc->low);
elm_slider_value_set(tc->low, ceil(CEL_2_FAR(val)));
val = (int)elm_slider_value_get(tc->high);
elm_slider_value_set(tc->high, ceil(CEL_2_FAR(val)));
elm_slider_unit_format_set(tc->high, "%1.0f F");
elm_slider_indicator_format_set(tc->high, "%1.0f F");
elm_slider_unit_format_set(tc->low, "%1.0f F");
elm_slider_indicator_format_set(tc->low, "%1.0f F");
}
else
{
val = (int)elm_slider_value_get(tc->low);
elm_slider_value_set(tc->low, ceil(FAR_2_CEL(val)));
val = (int)elm_slider_value_get(tc->high);
elm_slider_value_set(tc->high, ceil(FAR_2_CEL(val)));
elm_slider_unit_format_set(tc->low, "%1.0f C");
elm_slider_indicator_format_set(tc->low, "%1.0f C");
elm_slider_unit_format_set(tc->high, "%1.0f C");
elm_slider_indicator_format_set(tc->high, "%1.0f C");
elm_slider_min_max_set(tc->low, 0, 95);
elm_slider_min_max_set(tc->high, 0, 110);
}
val = (int)elm_slider_value_get(tc->high);
inst->cfg->thermal.high = val;
val = (int)elm_slider_value_get(tc->low);
inst->cfg->thermal.low = val;
e_config_save_queue();
_thermal_config_updated(inst);
}
static void
_poll_changed(void *data, Evas_Object *obj, void *event_info EINA_UNUSED)
{
Thermal_Config *tc = data;
Instance *inst = tc->inst;
int value = elm_radio_value_get(obj);
switch (value)
{
case 0:
inst->cfg->thermal.poll_interval = 4;
break;
case 1:
inst->cfg->thermal.poll_interval = 8;
break;
case 2:
inst->cfg->thermal.poll_interval = 32;
break;
case 3:
inst->cfg->thermal.poll_interval = 64;
break;
case 4:
inst->cfg->thermal.poll_interval = 256;
break;
default:
inst->cfg->thermal.poll_interval = 32;
}
e_config_save_queue();
_thermal_config_updated(inst);
}
Evas_Object *
thermal_configure(Instance *inst)
{
Evas_Object *popup, *tb, *frame, *box, *o, *group, *groupu, *lbl, *slider;
E_Zone *zone = e_zone_current_get();
Thermal_Config *tc = E_NEW(Thermal_Config, 1);
tc->inst = inst;
popup = elm_popup_add(e_comp->elm);
E_EXPAND(popup);
elm_popup_allow_events_set(popup, 1);
elm_popup_scrollable_set(popup, 1);
tb = elm_table_add(popup);
E_EXPAND(tb);
evas_object_show(tb);
elm_object_content_set(popup, tb);
lbl = elm_label_add(tb);
evas_object_size_hint_weight_set(lbl, EVAS_HINT_EXPAND, 0.0);
evas_object_size_hint_align_set(lbl, EVAS_HINT_FILL, EVAS_HINT_FILL);
elm_object_style_set(lbl, "marker");
elm_object_text_set(lbl, _("Thermal Configuration"));
elm_table_pack(tb, lbl, 0, 0, 1, 1);
evas_object_show(lbl);
frame = elm_frame_add(tb);
elm_object_text_set(frame, _("Temperature Units"));
E_EXPAND(frame);
E_FILL(frame);
elm_table_pack(tb, frame, 0, 1, 1, 1);
evas_object_show(frame);
box = elm_box_add(frame);
elm_box_horizontal_set(box, EINA_FALSE);
E_EXPAND(box);
evas_object_show(box);
o = elm_radio_add(box);
elm_radio_state_value_set(o, 0);
E_ALIGN(o, 0.0, 0.0);
E_WEIGHT(o, EVAS_HINT_EXPAND, 0);
elm_object_text_set(o, _("Celsius"));
elm_box_pack_end(box, o);
evas_object_smart_callback_add(o, "changed", _units_changed, tc);
evas_object_show(o);
groupu = o;
o = elm_radio_add(box);
elm_radio_state_value_set(o, 1);
elm_radio_group_add(o, groupu);
E_ALIGN(o, 0.0, 0.0);
E_WEIGHT(o, EVAS_HINT_EXPAND, 0);
elm_object_text_set(o, _("Fahrenheit"));
elm_box_pack_end(box, o);
evas_object_smart_callback_add(o, "changed", _units_changed, tc);
evas_object_show(o);
switch (inst->cfg->thermal.units)
{
case CELSIUS:
elm_radio_value_set(groupu, 0);
break;
case FAHRENHEIT:
elm_radio_value_set(groupu, 1);
break;
default:
elm_radio_value_set(groupu, 0);
}
elm_object_content_set(frame, box);
frame = elm_frame_add(tb);
elm_object_text_set(frame, _("Update Poll Interval"));
E_EXPAND(frame);
E_FILL(frame);
elm_table_pack(tb, frame, 0, 2, 1, 1);
evas_object_show(frame);
box = elm_box_add(frame);
elm_box_horizontal_set(box, EINA_FALSE);
E_EXPAND(box);
evas_object_show(box);
o = elm_radio_add(box);
elm_radio_state_value_set(o, 0);
E_ALIGN(o, 0.0, 0.0);
E_WEIGHT(o, EVAS_HINT_EXPAND, 0);
elm_object_text_set(o, _("Fast (4 ticks)"));
elm_box_pack_end(box, o);
evas_object_smart_callback_add(o, "changed", _poll_changed, tc);
evas_object_show(o);
group = o;
o = elm_radio_add(box);
elm_radio_state_value_set(o, 1);
elm_radio_group_add(o, group);
E_ALIGN(o, 0.0, 0.0);
E_WEIGHT(o, EVAS_HINT_EXPAND, 0);
elm_object_text_set(o, _("Medium (8 ticks)"));
elm_box_pack_end(box, o);
evas_object_smart_callback_add(o, "changed", _poll_changed, tc);
evas_object_show(o);
o = elm_radio_add(box);
elm_radio_state_value_set(o, 2);
elm_radio_group_add(o, group);
E_ALIGN(o, 0.0, 0.0);
E_WEIGHT(o, EVAS_HINT_EXPAND, 0);
elm_object_text_set(o, _("Normal (32 ticks)"));
elm_box_pack_end(box, o);
evas_object_smart_callback_add(o, "changed", _poll_changed, tc);
evas_object_show(o);
o = elm_radio_add(box);
elm_radio_state_value_set(o, 3);
elm_radio_group_add(o, group);
E_ALIGN(o, 0.0, 0.0);
E_WEIGHT(o, EVAS_HINT_EXPAND, 0);
elm_object_text_set(o, _("Slow (64 ticks)"));
elm_box_pack_end(box, o);
evas_object_smart_callback_add(o, "changed", _poll_changed, tc);
evas_object_show(o);
o = elm_radio_add(box);
elm_radio_state_value_set(o, 4);
elm_radio_group_add(o, group);
E_ALIGN(o, 0.0, 0.0);
E_WEIGHT(o, EVAS_HINT_EXPAND, 0);
elm_object_text_set(o, _("Very Slow (256 ticks)"));
elm_box_pack_end(box, o);
evas_object_smart_callback_add(o, "changed", _poll_changed, tc);
evas_object_show(o);
switch (inst->cfg->thermal.poll_interval)
{
case 4:
elm_radio_value_set(group, 0);
break;
case 8:
elm_radio_value_set(group, 1);
break;
case 32:
elm_radio_value_set(group, 2);
break;
case 64:
elm_radio_value_set(group, 3);
break;
case 256:
elm_radio_value_set(group, 4);
break;
default:
elm_radio_value_set(group, 2);
}
elm_object_content_set(frame, box);
frame = elm_frame_add(tb);
elm_object_text_set(frame, _("Temperature Limits"));
E_EXPAND(frame);
E_FILL(frame);
elm_table_pack(tb, frame, 0, 3, 1, 1);
evas_object_show(frame);
box = elm_box_add(frame);
elm_box_horizontal_set(box, EINA_FALSE);
E_EXPAND(box);
evas_object_show(box);
slider = elm_slider_add(box);
elm_object_text_set(slider, _("High Temperature:"));
if (inst->cfg->thermal.units == FAHRENHEIT)
{
elm_slider_unit_format_set(slider, "%1.0f F");
elm_slider_indicator_format_set(slider, "%1.0f F");
elm_slider_min_max_set(slider, 0, 230);
}
else
{
elm_slider_unit_format_set(slider, "%1.0f C");
elm_slider_indicator_format_set(slider, "%1.0f C");
elm_slider_min_max_set(slider, 0, 110);
}
elm_slider_value_set(slider, inst->cfg->thermal.high);
elm_slider_step_set(slider, 0.05);
elm_slider_span_size_set(slider, 150);
evas_object_size_hint_align_set(slider, EVAS_HINT_FILL, 0.5);
evas_object_size_hint_weight_set(slider, EVAS_HINT_EXPAND, 0.0);
evas_object_smart_callback_add(slider, "delay,changed", _update_high_temperature, tc);
elm_box_pack_end(box, slider);
evas_object_show(slider);
tc->high = slider;
slider = elm_slider_add(box);
elm_object_text_set(slider, _("Low Temperature:"));
if (inst->cfg->thermal.units == FAHRENHEIT)
{
elm_slider_unit_format_set(slider, "%1.0f F");
elm_slider_indicator_format_set(slider, "%1.0f F");
elm_slider_min_max_set(slider, 0, 200);
}
else
{
elm_slider_unit_format_set(slider, "%1.0f C");
elm_slider_indicator_format_set(slider, "%1.0f C");
elm_slider_min_max_set(slider, 0, 95);
}
elm_slider_value_set(slider, inst->cfg->thermal.low);
elm_slider_step_set(slider, 0.05);
elm_slider_span_size_set(slider, 150);
evas_object_size_hint_align_set(slider, EVAS_HINT_FILL, 0.5);
evas_object_size_hint_weight_set(slider, EVAS_HINT_EXPAND, 0.0);
evas_object_smart_callback_add(slider, "delay,changed", _update_low_temperature, tc);
elm_box_pack_end(box, slider);
evas_object_show(slider);
tc->low = slider;
elm_object_content_set(frame, box);
popup = e_comp_object_util_add(popup, E_COMP_OBJECT_TYPE_NONE);
evas_object_layer_set(popup, E_LAYER_POPUP);
evas_object_resize(popup, zone->w / 4, zone->h / 3);
e_comp_object_util_center_on_zone(popup, zone);
evas_object_show(popup);
e_comp_object_util_autoclose(popup, NULL, e_comp_object_util_autoclose_on_escape, NULL);
evas_object_event_callback_add(popup, EVAS_CALLBACK_DEL, _config_close, tc);
return inst->cfg->thermal.configure = popup;
}

435
src/modules/sysinfo/thermal/thermal_fallback.c
View File

@ -1,435 +0,0 @@
#if defined(__linux__)
#include "thermal.h"
typedef struct
{
int dummy;
} Extn;
Eina_List *
temperature_get_bus_files(const char *bus)
{
Eina_List *result;
Eina_List *therms;
char path[PATH_MAX + 3];
char busdir[PATH_MAX];
char *name;
result = NULL;
snprintf(busdir, sizeof(busdir), "/sys/bus/%s/devices", bus);
/* Look through all the devices for the given bus. */
therms = ecore_file_ls(busdir);
EINA_LIST_FREE(therms, name)
{
Eina_List *files;
char *file;
/* Search each device for temp*_input, these should be
* temperature devices. */
snprintf(path, sizeof(path), "%s/%s", busdir, name);
files = ecore_file_ls(path);
EINA_LIST_FREE(files, file)
{
if ((!strncmp("temp", file, 4)) &&
(!strcmp("_input", &file[strlen(file) - 6])))
{
char *f;
snprintf(path, sizeof(path),
"%s/%s/%s", busdir, name, file);
f = strdup(path);
if (f) result = eina_list_append(result, f);
}
E_FREE(file);
}
E_FREE(name);
}
return result;
}
static void
init(Tempthread *tth)
{
Eina_List *therms;
char path[512];
Extn *extn;
if (tth->initted) return;
tth->initted = EINA_TRUE;
extn = calloc(1, sizeof(Extn));
tth->extn = extn;
if ((!tth->sensor_type) ||
((!tth->sensor_name) ||
(tth->sensor_name[0] == 0)))
{
eina_stringshare_del(tth->sensor_name);
tth->sensor_name = NULL;
eina_stringshare_del(tth->sensor_path);
tth->sensor_path = NULL;
therms = ecore_file_ls("/proc/acpi/thermal_zone");
if (therms)
{
char *name;
name = eina_list_data_get(therms);
tth->sensor_type = SENSOR_TYPE_LINUX_ACPI;
tth->sensor_name = eina_stringshare_add(name);
eina_list_free(therms);
}
else
{
eina_list_free(therms);
therms = ecore_file_ls("/sys/class/thermal");
if (therms)
{
char *name;
Eina_List *l;
EINA_LIST_FOREACH(therms, l, name)
{
if (!strncmp(name, "thermal", 7))
{
tth->sensor_type = SENSOR_TYPE_LINUX_SYS;
tth->sensor_name = eina_stringshare_add(name);
eina_list_free(therms);
therms = NULL;
break;
}
}
if (therms) eina_list_free(therms);
}
if (therms)
{
if (ecore_file_exists("/proc/omnibook/temperature"))
{
tth->sensor_type = SENSOR_TYPE_OMNIBOOK;
tth->sensor_name = eina_stringshare_add("dummy");
}
else if (ecore_file_exists("/sys/devices/temperatures/sensor1_temperature"))
{
tth->sensor_type = SENSOR_TYPE_LINUX_PBOOK;
tth->sensor_name = eina_stringshare_add("dummy");
}
else if (ecore_file_exists("/sys/devices/temperatures/cpu_temperature"))
{
tth->sensor_type = SENSOR_TYPE_LINUX_MACMINI;
tth->sensor_name = eina_stringshare_add("dummy");
}
else if (ecore_file_exists("/sys/devices/platform/coretemp.0/temp1_input"))
{
tth->sensor_type = SENSOR_TYPE_LINUX_INTELCORETEMP;
tth->sensor_name = eina_stringshare_add("dummy");
}
else if (ecore_file_exists("/sys/devices/platform/thinkpad_hwmon/temp1_input"))
{
tth->sensor_type = SENSOR_TYPE_LINUX_THINKPAD;
tth->sensor_name = eina_stringshare_add("dummy");
}
else
{
// try the i2c bus
therms = temperature_get_bus_files("i2c");
if (therms)
{
char *name;
if ((name = eina_list_data_get(therms)))
{
if (ecore_file_exists(name))
{
int len;
snprintf(path, sizeof(path),
"%s", ecore_file_file_get(name));
len = strlen(path);
if (len > 6) path[len - 6] = '\0';
tth->sensor_type = SENSOR_TYPE_LINUX_I2C;
tth->sensor_path = eina_stringshare_add(name);
tth->sensor_name = eina_stringshare_add(path);
}
}
eina_list_free(therms);
}
if (!tth->sensor_path)
{
// try the pci bus
therms = temperature_get_bus_files("pci");
if (therms)
{
char *name;
if ((name = eina_list_data_get(therms)))
{
if (ecore_file_exists(name))
{
int len;
snprintf(path, sizeof(path),
"%s", ecore_file_file_get(name));
len = strlen(path);
if (len > 6) path[len - 6] = '\0';
tth->sensor_type = SENSOR_TYPE_LINUX_PCI;
tth->sensor_path = eina_stringshare_add(name);
eina_stringshare_del(tth->sensor_name);
tth->sensor_name = eina_stringshare_add(path);
}
}
eina_list_free(therms);
}
}
}
}
}
}
if ((tth->sensor_type) && (tth->sensor_name) && (!tth->sensor_path))
{
char *name;
switch (tth->sensor_type)
{
case SENSOR_TYPE_NONE:
break;
case SENSOR_TYPE_OMNIBOOK:
tth->sensor_path = eina_stringshare_add("/proc/omnibook/temperature");
break;
case SENSOR_TYPE_LINUX_MACMINI:
tth->sensor_path = eina_stringshare_add("/sys/devices/temperatures/cpu_temperature");
break;
case SENSOR_TYPE_LINUX_PBOOK:
tth->sensor_path = eina_stringshare_add("/sys/devices/temperatures/sensor1_temperature");
break;
case SENSOR_TYPE_LINUX_INTELCORETEMP:
tth->sensor_path = eina_stringshare_add("/sys/devices/platform/coretemp.0/temp1_input");
break;
case SENSOR_TYPE_LINUX_THINKPAD:
tth->sensor_path = eina_stringshare_add("/sys/devices/platform/thinkpad_hwmon/temp1_input");
break;
case SENSOR_TYPE_LINUX_I2C:
therms = ecore_file_ls("/sys/bus/i2c/devices");
EINA_LIST_FREE(therms, name)
{
snprintf(path, sizeof(path),
"/sys/bus/i2c/devices/%s/%s_input",
name, tth->sensor_name);
if (ecore_file_exists(path))
{
tth->sensor_path = eina_stringshare_add(path);
/* We really only care about the first
* one for the default. */
break;
}
E_FREE(name);
}
break;
case SENSOR_TYPE_LINUX_PCI:
therms = ecore_file_ls("/sys/bus/pci/devices");
EINA_LIST_FREE(therms, name)
{
snprintf(path, sizeof(path),
"/sys/bus/pci/devices/%s/%s_input",
name, tth->sensor_name);
if (ecore_file_exists(path))
{
tth->sensor_path = eina_stringshare_add(path);
/* We really only care about the first
* one for the default. */
break;
}
E_FREE(name);
}
break;
case SENSOR_TYPE_LINUX_ACPI:
snprintf(path, sizeof(path),
"/proc/acpi/thermal_zone/%s/temperature",
tth->sensor_name);
tth->sensor_path = eina_stringshare_add(path);
break;
case SENSOR_TYPE_LINUX_SYS:
snprintf(path, sizeof(path),
"/sys/class/thermal/%s/temp", tth->sensor_name);
tth->sensor_path = eina_stringshare_add(path);
break;
default:
break;
}
}
}
static int
check(Tempthread *tth)
{
FILE *f = NULL;
int ret = 0;
int temp = 0;
char buf[512];
/* TODO: Make standard parser. Seems to be two types of temperature string:
* - Somename: <temp> C
* - <temp>
*/
switch (tth->sensor_type)
{
case SENSOR_TYPE_NONE:
/* TODO: Slow down poller? */
break;
case SENSOR_TYPE_OMNIBOOK:
f = fopen(tth->sensor_path, "r");
if (f)
{
char dummy[4096];
if (fgets(buf, sizeof(buf), f) == NULL) goto error;
fclose(f);
f = NULL;
if (sscanf(buf, "%s %s %i", dummy, dummy, &temp) == 3)
ret = 1;
else
goto error;
}
else
goto error;
break;
case SENSOR_TYPE_LINUX_MACMINI:
case SENSOR_TYPE_LINUX_PBOOK:
f = fopen(tth->sensor_path, "rb");
if (f)
{
if (fgets(buf, sizeof(buf), f) == NULL) goto error;
fclose(f);
f = NULL;
if (sscanf(buf, "%i", &temp) == 1)
ret = 1;
else
goto error;
}
else
goto error;
break;
case SENSOR_TYPE_LINUX_INTELCORETEMP:
case SENSOR_TYPE_LINUX_I2C:
case SENSOR_TYPE_LINUX_THINKPAD:
f = fopen(tth->sensor_path, "r");
if (f)
{
if (fgets(buf, sizeof(buf), f) == NULL) goto error;
fclose(f);
f = NULL;
/* actually read the temp */
if (sscanf(buf, "%i", &temp) == 1)
ret = 1;
else
goto error;
/* Hack for temp */
temp = temp / 1000;
}
else
goto error;
break;
case SENSOR_TYPE_LINUX_PCI:
f = fopen(tth->sensor_path, "r");
if (f)
{
if (fgets(buf, sizeof(buf), f) == NULL) goto error;
fclose(f);
f = NULL;
/* actually read the temp */
if (sscanf(buf, "%i", &temp) == 1)
ret = 1;
else
goto error;
/* Hack for temp */
temp = temp / 1000;
}
else
goto error;
break;
case SENSOR_TYPE_LINUX_ACPI:
f = fopen(tth->sensor_path, "r");
if (f)
{
char *p, *q;
if (fgets(buf, sizeof(buf), f) == NULL) goto error;
fclose(f);
f = NULL;
p = strchr(buf, ':');
if (p)
{
p++;
while (*p == ' ')
p++;
q = strchr(p, ' ');
if (q) *q = 0;
temp = atoi(p);
ret = 1;
}
else
goto error;
}
else
goto error;
break;
case SENSOR_TYPE_LINUX_SYS:
f = fopen(tth->sensor_path, "r");
if (f)
{
if (fgets(buf, sizeof(buf), f) == NULL) goto error;
fclose(f);
f = NULL;
temp = atoi(buf);
temp /= 1000;
ret = 1;
}
else
goto error;
break;
default:
break;
}
if (ret) return temp;
return -999;
error:
if (f) fclose(f);
tth->sensor_type = SENSOR_TYPE_NONE;
eina_stringshare_del(tth->sensor_name);
tth->sensor_name = NULL;
eina_stringshare_del(tth->sensor_path);
tth->sensor_path = NULL;
return -999;
}
int
thermal_fallback_get(Tempthread *tth)
{
int temp;
init(tth);
temp = check(tth);
return temp;
}
#endif

212
src/modules/sysinfo/thermal/thermal_sysctl.c
View File

@ -1,212 +0,0 @@
#include "thermal.h"
#if defined(__FreeBSD__) || defined(__DragonFly__)
# include <sys/types.h>
# include <sys/sysctl.h>
# include <errno.h>
#endif
#if defined(__OpenBSD__)
# include <sys/param.h>
# include <sys/sysctl.h>
# include <sys/sensors.h>
# include <errno.h>
# include <err.h>
#endif
#if defined(__FreeBSD__) || defined(__DragonFly__) || defined(__OpenBSD__)
typedef struct
{
int mib[CTL_MAXNAME];
#if defined(__FreeBSD__) || defined(__DragonFly__)
unsigned int miblen;
#endif
int dummy;
} Extn;
#if defined(__FreeBSD__) || defined(__DragonFly__)
static const char *sources[] =
{
"hw.acpi.thermal.tz0.temperature",
"dev.cpu.0.temperature",
"dev.aibs.0.temp.0",
"dev.lm75.0.temperature",
NULL
};
#endif
#if defined(__OpenBSD__)
static struct sensor snsr;
static size_t slen = sizeof(snsr);
#endif
static void
init(Tempthread *tth)
{
#if defined(__OpenBSD__)
int dev, numt;
struct sensordev snsrdev;
size_t sdlen = sizeof(snsrdev);
#endif
#if defined(__FreeBSD__) || defined(__DragonFly__)
unsigned i;
size_t len;
int rc;
#endif
Extn *extn;
if (tth->initted) return;
tth->initted = EINA_TRUE;
extn = calloc(1, sizeof(Extn));
tth->extn = extn;
if ((!tth->sensor_type) ||
((!tth->sensor_name) ||
(tth->sensor_name[0] == 0)))
{
eina_stringshare_del(tth->sensor_name);
tth->sensor_name = NULL;
eina_stringshare_del(tth->sensor_path);
tth->sensor_path = NULL;
#if defined(__FreeBSD__) || defined(__DragonFly__)
for (i = 0; sources[i]; i++)
{
rc = sysctlbyname(sources[i], NULL, NULL, NULL, 0);
if (rc == 0)
{
tth->sensor_type = SENSOR_TYPE_FREEBSD;
tth->sensor_name = eina_stringshare_add(sources[i]);
break;
}
}
#elif defined(__OpenBSD__)
extn->mib[0] = CTL_HW;
extn->mib[1] = HW_SENSORS;
for (dev = 0;; dev++)
{
extn->mib[2] = dev;
if (sysctl(extn->mib, 3, &snsrdev, &sdlen, NULL, 0) == -1)
{
if (errno == ENOENT) /* no further sensors */
break;
else
continue;
}
if (strcmp(snsrdev.xname, "cpu0") == 0)
{
tth->sensor_type = SENSOR_TYPE_OPENBSD;
tth->sensor_name = eina_stringshare_add("cpu0");
break;
}
else if (strcmp(snsrdev.xname, "km0") == 0)
{
tth->sensor_type = SENSOR_TYPE_OPENBSD;
tth->sensor_name = eina_stringshare_add("km0");
break;
}
}
#endif
}
if ((tth->sensor_type) && (tth->sensor_name) && (!tth->sensor_path))
{
if (tth->sensor_type == SENSOR_TYPE_FREEBSD)
{
#if defined(__FreeBSD__) || defined(__DragonFly__)
len = sizeof(extn->mib) / sizeof(extn->mib[0]);
rc = sysctlnametomib(tth->sensor_name, extn->mib, &len);
if (rc == 0)
{
extn->miblen = len;
tth->sensor_path = eina_stringshare_add(tth->sensor_name);
}
#endif
}
else if (tth->sensor_type == SENSOR_TYPE_OPENBSD)
{
#if defined(__OpenBSD__)
for (numt = 0; numt < snsrdev.maxnumt[SENSOR_TEMP]; numt++)
{
extn->mib[4] = numt;
slen = sizeof(snsr);
if (sysctl(extn->mib, 5, &snsr, &slen, NULL, 0) == -1)
continue;
if (slen > 0 && (snsr.flags & SENSOR_FINVALID) == 0)
{
break;
}
}
#endif
}
}
}
static int
check(Tempthread *tth)
{
int ret = 0;
int temp = 0;
#if defined(__FreeBSD__) || defined(__DragonFly__)
size_t len;
size_t ftemp = 0;
#endif
#if defined(__FreeBSD__) || defined(__DragonFly__) || defined(__OpenBSD__)
Extn *extn = tth->extn;
#endif
/* TODO: Make standard parser. Seems to be two types of temperature string:
* - Somename: <temp> C
* - <temp>
*/
if (tth->sensor_type == SENSOR_TYPE_FREEBSD)
{
#if defined(__FreeBSD__) || defined(__DragonFly__)
len = sizeof(ftemp);
if (sysctl(extn->mib, extn->miblen, &ftemp, &len, NULL, 0) == 0)
{
temp = (ftemp - 2732) / 10;
ret = 1;
}
else
goto error;
#endif
}
else if (tth->sensor_type == SENSOR_TYPE_OPENBSD)
{
#if defined(__OpenBSD__)
if (sysctl(extn->mib, 5, &snsr, &slen, NULL, 0) != -1)
{
temp = (snsr.value - 273150000) / 1000000.0;
ret = 1;
}
else
goto error;
#endif
}
if (ret) return temp;
return -999;
error:
tth->sensor_type = SENSOR_TYPE_NONE;
eina_stringshare_del(tth->sensor_name);
tth->sensor_name = NULL;
eina_stringshare_del(tth->sensor_path);
tth->sensor_path = NULL;
return -999;
}
int
thermal_sysctl_get(Tempthread *tth)
{
int temp;
init(tth);
temp = check(tth);
return temp;
}
#endif

51
src/modules/sysinfo/thermal/thermal_udev.c
View File

@ -1,51 +0,0 @@
#include "thermal.h"
int
thermal_udev_get(Tempthread *tth)
{
Eina_List *l;
double cur, temp;
char *syspath;
const char *test;
char buf[256];
int x, y, cpus = 0;
temp = -999;
if (!tth->tempdevs)
tth->tempdevs =
eeze_udev_find_by_type(EEZE_UDEV_TYPE_IS_IT_HOT_OR_IS_IT_COLD_SENSOR,
NULL);
if (tth->tempdevs)
{
temp = 0;
EINA_LIST_FOREACH(tth->tempdevs, l, syspath)
{
for (x = 1, y = 0; x < 15; x++)
{
if (y >= 2) break;
sprintf(buf, "temp%d_input", x);
if ((test = eeze_udev_syspath_get_sysattr(syspath, buf)))
{
y = 0;
cur = atoi(test);
if (cur > 0)
{
/* udev reports temp in (celsius * 1000) */
temp += (cur / 1000);
cpus++;
}
}
/* keep checking for sensors until 2 in a row don't exist */
else y++;
}
}
if (cpus > 0)
{
temp /= (double)cpus;
return temp;
}
}
return -999;
}

BIN
src/modules/teamwork/e-module-teamwork.edj
View File

Binary file not shown.

182
src/modules/teamwork/e_mod_config.c
View File

@ -1,182 +0,0 @@
#include "e_mod_main.h"
struct _E_Config_Dialog_Data
{
int disable_media_fetch;
int disable_video;
double allowed_media_size;
double allowed_media_fetch_size;
double allowed_media_age;
double mouse_out_delay;
double popup_size;
double popup_opacity;
};
static void *
_create_data(E_Config_Dialog *cfd EINA_UNUSED)
{
E_Config_Dialog_Data *cfdata;
cfdata = E_NEW(E_Config_Dialog_Data, 1);
#define SET(X) \
cfdata->X = tw_config->X
SET(disable_media_fetch);
SET(disable_video);
SET(allowed_media_size);
SET(allowed_media_fetch_size);
SET(allowed_media_age);
SET(mouse_out_delay);
SET(popup_size);
SET(popup_opacity);
#undef SET
return cfdata;
}
static void
_free_data(E_Config_Dialog *cfd EINA_UNUSED, E_Config_Dialog_Data *cfdata)
{
tw_mod->cfd = NULL;
free(cfdata);
}
static int
_basic_check_changed(E_Config_Dialog *cfd EINA_UNUSED, E_Config_Dialog_Data *cfdata)
{
#define CHECK(X) \
if (cfdata->X != tw_config->X) return 1
CHECK(disable_media_fetch);
CHECK(disable_video);
if (lround(cfdata->allowed_media_age) != tw_config->allowed_media_age) return 1;
if (lround(cfdata->allowed_media_size) != tw_config->allowed_media_size) return 1;
if (lround(cfdata->allowed_media_fetch_size) != tw_config->allowed_media_fetch_size) return 1;
if (fabs(cfdata->mouse_out_delay - tw_config->mouse_out_delay) > 0.45) return 1;
if (fabs(cfdata->popup_size - tw_config->popup_size) > 0.9) return 1;
if (fabs(cfdata->popup_opacity - tw_config->popup_opacity) > 0.9) return 1;
#undef CHECK
return 0;
}
static Evas_Object *
_basic_create_widgets(E_Config_Dialog *cfd EINA_UNUSED,
Evas *evas,
E_Config_Dialog_Data *cfdata)
{
Evas_Object *ob, *ol, *otb, *tab, *oc;
tab = e_widget_table_add(e_win_evas_win_get(evas), 0);
otb = e_widget_toolbook_add(evas, 48 * e_scale, 48 * e_scale);
///////////////////////////////////////////
ol = e_widget_list_add(evas, 0, 0);
ob = e_widget_check_add(evas, _("Disable remote media fetching"), &cfdata->disable_media_fetch);
e_widget_list_object_append(ol, ob, 1, 0, 0.5);
oc = e_widget_label_add(evas, _("Maximum media size to fetch"));
e_widget_list_object_append(ol, oc, 1, 1, 0.5);
oc = e_widget_slider_add(evas, 1, 0, _("%2.0f MiB"), 1, 50, 1, 0, &cfdata->allowed_media_fetch_size, NULL, 150);
e_widget_list_object_append(ol, oc, 1, 1, 0.5);
e_widget_check_widget_disable_on_checked_add(ob, oc);
oc = e_widget_label_add(evas, _("Maximum media cache size in RAM"));
e_widget_list_object_append(ol, oc, 1, 1, 0.5);
oc = e_widget_slider_add(evas, 1, 0, _("%4.0f MiB"), 0, 1024, 16, 0, &cfdata->allowed_media_size, NULL, 150);
e_widget_list_object_append(ol, oc, 1, 1, 0.5);
e_widget_check_widget_disable_on_checked_add(ob, oc);
oc = e_widget_label_add(evas, _("Maximum media cache age on disk"));
e_widget_list_object_append(ol, oc, 1, 1, 0.5);
oc = e_widget_slider_add(evas, 1, 0, _("%3.0f Days"), -1, 180, 1, 0, &cfdata->allowed_media_age, NULL, 150);
e_widget_list_object_append(ol, oc, 1, 1, 0.5);
e_widget_check_widget_disable_on_checked_add(ob, oc);
e_widget_toolbook_page_append(otb, NULL, _("Cache"), ol, 1, 1, 1, 1, 0.5, 0.5);
///////////////////////////////////////////
ol = e_widget_list_add(evas, 0, 0);
ob = e_widget_check_add(evas, _("Disable video previews"), &cfdata->disable_video);
e_widget_list_object_append(ol, ob, 1, 0, 0.5);
oc = e_widget_label_add(evas, _("Mouse-out hide delay"));
e_widget_list_object_append(ol, oc, 1, 1, 0.5);
oc = e_widget_slider_add(evas, 1, 0, _("%1.1f seconds"), 0, 5, 0.5, 0, &cfdata->mouse_out_delay, NULL, 150);
e_widget_list_object_append(ol, oc, 1, 1, 0.5);
e_widget_check_widget_disable_on_checked_add(ob, oc);
oc = e_widget_label_add(evas, _("Maximum size (Percentage of screens size)"));
e_widget_list_object_append(ol, oc, 1, 1, 0.5);
oc = e_widget_slider_add(evas, 1, 0, _("%3.0f"), 10, 100, 1, 0, &cfdata->popup_size, NULL, 150);
e_widget_list_object_append(ol, oc, 1, 1, 0.5);
e_widget_check_widget_disable_on_checked_add(ob, oc);
oc = e_widget_label_add(evas, _("Opacity"));
e_widget_list_object_append(ol, oc, 1, 1, 0.5);
oc = e_widget_slider_add(evas, 1, 0, _("%3.0f"), 10, 100, 1, 0, &cfdata->popup_opacity, NULL, 150);
e_widget_list_object_append(ol, oc, 1, 1, 0.5);
e_widget_check_widget_disable_on_checked_add(ob, oc);
e_widget_toolbook_page_append(otb, NULL, _("Popups"), ol, 1, 1, 1, 1, 0.5, 0.5);
e_widget_toolbook_page_show(otb, 0);
e_widget_table_object_append(tab, otb, 0, 0, 1, 1, 1, 1, 1, 1);
return tab;
}
static int
_basic_apply_data(E_Config_Dialog *cfd EINA_UNUSED,
E_Config_Dialog_Data *cfdata)
{
#define SET(X) tw_config->X = cfdata->X
SET(disable_media_fetch);
SET(disable_video);
SET(allowed_media_size);
SET(allowed_media_fetch_size);
SET(allowed_media_age);
SET(mouse_out_delay);
SET(popup_size);
if (fabs(cfdata->popup_opacity - tw_config->popup_opacity) > 0.9)
{
SET(popup_opacity);
tw_popup_opacity_set();
}
e_config_save_queue();
return 1;
}
EINTERN E_Config_Dialog *
e_int_config_teamwork_module(Evas_Object *parent EINA_UNUSED, const char *params EINA_UNUSED)
{
E_Config_Dialog *cfd;
E_Config_Dialog_View *v;
char buf[4096];
if (tw_mod->cfd) return NULL;
snprintf(buf, sizeof(buf), "%s/e-module-teamwork.edj", e_module_dir_get(tw_mod->module));
v = E_NEW(E_Config_Dialog_View, 1);
v->create_cfdata = _create_data;
v->free_cfdata = _free_data;
v->basic.apply_cfdata = _basic_apply_data;
v->basic.create_widgets = _basic_create_widgets;
v->basic.check_changed = _basic_check_changed;
cfd = e_config_dialog_new(NULL, _("Teamwork Settings"),
"E", "applications/teamwork", buf, 32, v, tw_mod);
tw_mod->cfd = cfd;
return cfd;
}

181
src/modules/teamwork/e_mod_main.c
View File

@ -1,181 +0,0 @@
#include "e_mod_main.h"
EINTERN int _e_teamwork_log_dom = -1;
EINTERN Mod *tw_mod = NULL;
EINTERN Teamwork_Config *tw_config = NULL;
E_API E_Module_Api e_modapi = {E_MODULE_API_VERSION, "Teamwork"};
static E_Config_DD *conf_edd = NULL;
static E_Action *e_tw_toggle = NULL;
static const char _act_toggle[] = "tw_toggle";
static const char _e_tw_name[] = N_("Teamwork");
static const char _lbl_toggle[] = N_("Toggle Popup Visibility");
static const char *
_sha1_to_string(const unsigned char *hashout)
{
const char hextab[] = { '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'a', 'b', 'c', 'd', 'e', 'f' };
char sha1[41] = {0};
unsigned int i = 0;
for (i = 0; i < 20; i++)
{
sha1[2 * i] = hextab[(hashout[i] >> 4) & 0x0f];
sha1[2 * i + 1] = hextab[hashout[i] & 0x0f];
}
return eina_stringshare_add(sha1);
}
const char *
sha1_encode(const Eina_Binbuf *data)
{
unsigned char hashout[20];
emile_binbuf_sha1(data, hashout);
return _sha1_to_string(hashout);
}
//////////////////////////////
static Teamwork_Config *
e_tw_config_new(void)
{
Teamwork_Config *cf;
cf = E_NEW(Teamwork_Config, 1);
cf->config_version = MOD_CONFIG_FILE_VERSION;
cf->allowed_media_size = 10; // 10 megabytes
cf->allowed_media_fetch_size = 5; // 5 megabytes
cf->allowed_media_age = 3; // 3 days
cf->mouse_out_delay = 0.0; // hide instantly
cf->popup_size = 60.0; // 60% screen size
cf->popup_opacity = 90.0; // 90% opacity
return cf;
}
static E_Config_DD *
e_tw_config_dd_new(void)
{
conf_edd = E_CONFIG_DD_NEW("Teamwork_Config", Teamwork_Config);
#undef T
#undef D
#define T Teamwork_Config
#define D conf_edd
E_CONFIG_VAL(D, T, config_version, UINT);
E_CONFIG_VAL(D, T, disable_media_fetch, UCHAR);
E_CONFIG_VAL(D, T, disable_video, UCHAR);
E_CONFIG_VAL(D, T, allowed_media_size, LL);
E_CONFIG_VAL(D, T, allowed_media_fetch_size, LL);
E_CONFIG_VAL(D, T, allowed_media_age, INT);
E_CONFIG_VAL(D, T, mouse_out_delay, DOUBLE);
E_CONFIG_VAL(D, T, popup_size, DOUBLE);
E_CONFIG_VAL(D, T, popup_opacity, DOUBLE);
return conf_edd;
}
//////////////////////////////
static void
e_tw_act_toggle_cb(E_Object *obj EINA_UNUSED, const char *params)
{
if (tw_mod->pop)
{
if (tw_mod->sticky)
tw_hide(NULL);
tw_mod->sticky = !tw_mod->sticky;
return;
}
if (params && params[0])
{
tw_uri_show(params);
tw_mod->sticky = 1;
}
}
//////////////////////////////
static void
_e_modapi_shutdown(void)
{
e_tw_shutdown();
E_CONFIG_DD_FREE(conf_edd);
eina_log_domain_unregister(_e_teamwork_log_dom);
_e_teamwork_log_dom = -1;
e_configure_registry_item_del("applications/teamwork");
e_configure_registry_category_del("applications");
e_action_predef_name_del(_e_tw_name, _lbl_toggle);
e_action_del(_act_toggle);
e_tw_toggle = NULL;
E_FREE(tw_config);
E_FREE(tw_mod);
}
E_API void *
e_modapi_init(E_Module *m)
{
char buf[PATH_MAX];
snprintf(buf, sizeof(buf), "%s/e-module-teamwork.edj", e_module_dir_get(m));
e_configure_registry_category_add("applications", 20, _("Apps"), NULL,
"preferences-applications");
e_configure_registry_item_add("applications/teamwork", 1, _("Teamwork"), NULL,
buf, e_int_config_teamwork_module);
tw_mod = E_NEW(Mod, 1);
tw_mod->module = m;
m->data = tw_mod;
conf_edd = e_tw_config_dd_new();
tw_config = e_config_domain_load("module.teamwork", conf_edd);
if (tw_config)
{
if (!e_util_module_config_check(_("Teamwork"), tw_config->config_version, MOD_CONFIG_FILE_VERSION))
E_FREE_FUNC(tw_config, free);
}
if (tw_config)
{
/* sanity checks */
tw_config->mouse_out_delay = E_CLAMP(tw_config->mouse_out_delay, 0.0, 5.0);
tw_config->popup_size = E_CLAMP(tw_config->popup_size, 10.0, 100.0);
tw_config->popup_opacity = E_CLAMP(tw_config->popup_opacity, 10.0, 100.0);
tw_config->allowed_media_fetch_size = E_CLAMP(tw_config->allowed_media_fetch_size, 1, 50);
}
else
tw_config = e_tw_config_new();
tw_config->config_version = MOD_CONFIG_FILE_VERSION;
_e_teamwork_log_dom = eina_log_domain_register("teamwork", EINA_COLOR_ORANGE);
eina_log_domain_level_set("teamwork", EINA_LOG_LEVEL_DBG);
if (!e_tw_init())
{
_e_modapi_shutdown();
return NULL;
}
e_tw_toggle = e_action_add(_act_toggle);
e_tw_toggle->func.go = e_tw_act_toggle_cb;
e_action_predef_name_set(_e_tw_name, _lbl_toggle, _act_toggle, NULL, NULL, 1);
return m;
}
E_API int
e_modapi_shutdown(E_Module *m EINA_UNUSED)
{
_e_modapi_shutdown();
return 1;
}
E_API int
e_modapi_save(E_Module *m EINA_UNUSED)
{
e_config_domain_save("module.teamwork", conf_edd, tw_config);
return 1;
}

99
src/modules/teamwork/e_mod_main.h
View File

@ -1,99 +0,0 @@
#ifndef E_MOD_MAIN_H
#define E_MOD_MAIN_H
/* We want emil_binbuf_sha1 which is beta API */
#define EFL_BETA_API_SUPPORT
#include "e.h"
/**
* https://phab.enlightenment.org/w/teamwork_api/
*/
/* Increment for Major Changes */
#define MOD_CONFIG_FILE_EPOCH 1
/* Increment for Minor Changes (ie: user doesn't need a new config) */
#define MOD_CONFIG_FILE_GENERATION 0
#define MOD_CONFIG_FILE_VERSION ((MOD_CONFIG_FILE_EPOCH * 1000000) + MOD_CONFIG_FILE_GENERATION)
typedef struct Teamwork_Config
{
unsigned int config_version;
Eina_Bool disable_media_fetch;
Eina_Bool disable_video;
long long int allowed_media_size;
long long int allowed_media_fetch_size;
int allowed_media_age;
double mouse_out_delay;
double popup_size;
double popup_opacity;
} Teamwork_Config;
typedef struct Mod
{
E_Module *module;
E_Config_Dialog *cfd;
size_t media_size;
Eina_Inlist *media_list;
Eina_Hash *media;
Evas_Object *pop;
Eina_Bool sticky E_BITFIELD;
Eina_Bool force E_BITFIELD;
Eina_Bool hidden E_BITFIELD;
} Mod;
extern Teamwork_Config *tw_config;
extern Mod *tw_mod;
extern int _e_teamwork_log_dom;
EINTERN const char *sha1_encode(const Eina_Binbuf *data);
EINTERN int e_tw_init(void);
EINTERN void e_tw_shutdown(void);
EINTERN Eina_Bool tw_hide(void *d EINA_UNUSED);
EINTERN void tw_popup_opacity_set(void);
EINTERN void tw_uri_show(const char *uri);
EINTERN void tw_link_detect(E_Client *ec, const char *uri);
EINTERN void tw_link_show(E_Client *ec, const char *uri, int x, int y);
EINTERN void tw_link_hide(E_Client *ec, const char *uri);
EINTERN void tw_link_open(E_Client *ec, const char *uri);
typedef void (*Teamwork_Signal_Cb)(E_Client *, const char *);
typedef void (*Teamwork_Signal_Progress_Cb)(E_Client *, const char *, uint32_t);
extern Teamwork_Signal_Cb tw_signal_link_complete[E_PIXMAP_TYPE_NONE];
extern Teamwork_Signal_Cb tw_signal_link_invalid[E_PIXMAP_TYPE_NONE];
extern Teamwork_Signal_Progress_Cb tw_signal_link_progress[E_PIXMAP_TYPE_NONE];
extern Teamwork_Signal_Cb tw_signal_link_downloading[E_PIXMAP_TYPE_NONE];
EINTERN E_Config_Dialog *e_int_config_teamwork_module(Evas_Object *parent, const char *params EINA_UNUSED);
E_API int e_modapi_shutdown(E_Module *m EINA_UNUSED);
#ifdef HAVE_WAYLAND
EINTERN Eina_Bool wl_tw_init(void);
EINTERN void wl_tw_shutdown(void);
#endif
#ifndef HAVE_WAYLAND_ONLY
EINTERN Eina_Bool x11_tw_init(void);
EINTERN void x11_tw_shutdown(void);
#endif
#define E_TW_VERSION 2
#undef DBG
#undef INF
#undef WRN
#undef ERR
#undef CRIT
#define DBG(...) EINA_LOG_DOM_DBG(_e_teamwork_log_dom, __VA_ARGS__)
#define INF(...) EINA_LOG_DOM_INFO(_e_teamwork_log_dom, __VA_ARGS__)
#define WRN(...) EINA_LOG_DOM_WARN(_e_teamwork_log_dom, __VA_ARGS__)
#define ERR(...) EINA_LOG_DOM_ERR(_e_teamwork_log_dom, __VA_ARGS__)
#define CRIT(...) EINA_LOG_DOM_CRIT(_e_teamwork_log_dom, __VA_ARGS__)
#endif

1297
src/modules/teamwork/e_mod_tw.c
View File

File diff suppressed because it is too large Load Diff

17
src/modules/teamwork/meson.build
View File

@ -1,17 +0,0 @@
deps = [dependency('emile')]
src = files(
'e_mod_main.c',
'e_mod_config.c',
'e_mod_tw.c',
'wl.c',
'x11.c',
'e_mod_main.h'
)
if config_h.has('HAVE_WAYLAND') == true
src += files(
'wl_teamwork.c',
'wl_teamwork.h'
)
endif

24
src/modules/teamwork/module.desktop
View File

@ -1,24 +0,0 @@
[Desktop Entry]
Type=Link
Name=Teamwork
Name[ca]=Treball en equip
Name[fi]=Tiimityö
Name[gl]=Traballo en equipo
Name[ms]=Teamwork
Name[pl]=Praca zespołowa
Name[ru]=Командная работа
Name[sr]=Тимски рад
Name[tr]=Takı Çalışması
Comment=Enlightenment Is A Team Player
Comment[ca]=Enlightenment és un jugador d'equip
Comment[de]=Enlightenment ist ein Mannschaftsspieler
Comment[eo]=Enlightenment estas skipa ludanto
Comment[fi]=Enlightenment on tiimipelaaja
Comment[fr]=Enlightenment joue en équipe
Comment[it]=Enlightenment è giocatore in un team
Comment[ms]=Enlightenment Adalah Pemain Pasukan
Comment[ru]=Enlightenment — командный игрок
Comment[sr]=Просвећење је тимски играч
Comment[tr]=Enlightenment bir takım oyunu
Icon=e-module-teamwork
X-Enlightenment-ModuleType=core

138
src/modules/teamwork/wl.c
View File

@ -1,138 +0,0 @@
#define E_COMP_WL
#include "e_mod_main.h"
#ifdef HAVE_WAYLAND
#include "wl_teamwork.h"
static struct wl_resource *tw_resource;
static struct wl_global *tw_global;
static void
tw_preload_uri(struct wl_client *client EINA_UNUSED, struct wl_resource *resource EINA_UNUSED,
struct wl_resource *surface, const char *uri)
{
E_Client *ec;
ec = wl_resource_get_user_data(surface);
if (ec)
tw_link_detect(ec, uri);
}
static void
tw_activate_uri(struct wl_client *client EINA_UNUSED, struct wl_resource *resource EINA_UNUSED,
struct wl_resource *surface, const char *uri, wl_fixed_t x, wl_fixed_t y)
{
E_Client *ec;
ec = wl_resource_get_user_data(surface);
if (ec)
tw_link_show(ec, uri, wl_fixed_to_int(x), wl_fixed_to_int(y));
}
static void
tw_deactivate_uri(struct wl_client *client EINA_UNUSED, struct wl_resource *resource EINA_UNUSED,
struct wl_resource *surface, const char *uri)
{
E_Client *ec;
ec = wl_resource_get_user_data(surface);
if (ec)
tw_link_hide(ec, uri);
}
static void
tw_open_uri(struct wl_client *client EINA_UNUSED, struct wl_resource *resource EINA_UNUSED,
struct wl_resource *surface, const char *uri)
{
E_Client *ec;
ec = wl_resource_get_user_data(surface);
if (ec)
tw_link_open(ec, uri);
}
static const struct zwp_teamwork_interface tw_interface =
{
tw_preload_uri,
tw_activate_uri,
tw_deactivate_uri,
tw_open_uri,
};
static void
wl_tw_cb_unbind(struct wl_resource *resource EINA_UNUSED)
{
tw_resource = NULL;
}
static void
wl_tw_cb_bind(struct wl_client *client, void *data EINA_UNUSED, uint32_t version EINA_UNUSED, uint32_t id)
{
struct wl_resource *res;
if (!(res = wl_resource_create(client, &zwp_teamwork_interface, E_TW_VERSION, id)))
{
ERR("Could not create zwp_teamwork_interface interface");
wl_client_post_no_memory(client);
return;
}
tw_resource = res;
wl_resource_set_implementation(res, &tw_interface, NULL, wl_tw_cb_unbind);
}
static void
wl_tw_link_complete(E_Client *ec, const char *uri)
{
if (e_object_is_del(E_OBJECT(ec))) return;
zwp_teamwork_send_completed_uri(tw_resource, ec->comp_data->surface, uri, 1);
}
static void
wl_tw_link_invalid(E_Client *ec, const char *uri)
{
if (e_object_is_del(E_OBJECT(ec))) return;
zwp_teamwork_send_completed_uri(tw_resource, ec->comp_data->surface, uri, 0);
}
static void
wl_tw_link_progress(E_Client *ec, const char *uri, uint32_t pct)
{
if (e_object_is_del(E_OBJECT(ec))) return;
zwp_teamwork_send_fetch_info(tw_resource, ec->comp_data->surface, uri, pct);
}
static void
wl_tw_link_downloading(E_Client *ec, const char *uri)
{
if (e_object_is_del(E_OBJECT(ec))) return;
zwp_teamwork_send_fetching_uri(tw_resource, ec->comp_data->surface, uri);
}
EINTERN Eina_Bool
wl_tw_init(void)
{
tw_global = wl_global_create(e_comp_wl->wl.disp, &zwp_teamwork_interface, E_TW_VERSION,
NULL, wl_tw_cb_bind);
if (!tw_global)
{
ERR("Could not add zwp_teamwork to wayland globals");
return EINA_FALSE;
}
tw_signal_link_complete[E_PIXMAP_TYPE_WL] = wl_tw_link_complete;
tw_signal_link_invalid[E_PIXMAP_TYPE_WL] = wl_tw_link_invalid;
tw_signal_link_progress[E_PIXMAP_TYPE_WL] = wl_tw_link_progress;
tw_signal_link_downloading[E_PIXMAP_TYPE_WL] = wl_tw_link_downloading;
return EINA_TRUE;
}
EINTERN void
wl_tw_shutdown(void)
{
E_FREE_FUNC(tw_resource, wl_resource_destroy);
E_FREE_FUNC(tw_global, wl_global_destroy);
tw_signal_link_complete[E_PIXMAP_TYPE_WL] = NULL;
tw_signal_link_invalid[E_PIXMAP_TYPE_WL] = NULL;
tw_signal_link_progress[E_PIXMAP_TYPE_WL] = NULL;
tw_signal_link_downloading[E_PIXMAP_TYPE_WL] = NULL;
}
#endif

46
src/modules/teamwork/wl_teamwork.c
View File

@ -1,46 +0,0 @@
#include <stdlib.h>
#include <stdint.h>
#include "wayland-util.h"
extern const struct wl_interface wl_surface_interface;
static const struct wl_interface *types[] = {
&wl_surface_interface,
NULL,
&wl_surface_interface,
NULL,
NULL,
NULL,
&wl_surface_interface,
NULL,
&wl_surface_interface,
NULL,
&wl_surface_interface,
NULL,
&wl_surface_interface,
NULL,
NULL,
&wl_surface_interface,
NULL,
NULL,
};
static const struct wl_message zwp_teamwork_requests[] = {
{ "preload_uri", "os", types + 0 },
{ "activate_uri", "osff", types + 2 },
{ "deactivate_uri", "os", types + 6 },
{ "open_uri", "os", types + 8 },
};
static const struct wl_message zwp_teamwork_events[] = {
{ "fetching_uri", "os", types + 10 },
{ "completed_uri", "osi", types + 12 },
{ "fetch_info", "osu", types + 15 },
};
WL_EXPORT const struct wl_interface zwp_teamwork_interface = {
"zwp_teamwork", 2,
4, zwp_teamwork_requests,
3, zwp_teamwork_events,
};

Some files were not shown because too many files have changed in this diff Show More