enlightenment
/
enlightenment-module-desksanity
7
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

wifi

This commit is contained in:
Mike Blumenkrantz 2016-02-12 18:53:03 -05:00
parent cd3855c28c
commit d3b055925b
11 changed files with 471 additions and 203 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

BIN
edc/lock_insecure.png Normal file
View File

Binary file not shown.
Side by Side

After

Width:  |  Height:  |  Size: 7.8 KiB

BIN
edc/lock_locked.png Normal file
View File

Binary file not shown.
Side by Side

After

Width:  |  Height:  |  Size: 6.9 KiB

BIN
edc/wifi_shadow.png Normal file
View File

Binary file not shown.
Side by Side

After

Width:  |  Height:  |  Size: 3.8 KiB

84
edc/wireless.edc
View File

@ -1,6 +1,7 @@
group { name: "e/modules/wireless/wifi"; nomouse;
images.image: "slot_horiz_top.png" COMP;
images.image: "slot_horiz_bottom.png" COMP;
images.image: "wifi_shadow.png" COMP;
images.image: "wifi_base.png" COMP;
images.image: "wifi_sig_1.png" COMP;
images.image: "wifi_sig_2.png" COMP;
@ -10,6 +11,8 @@ group { name: "e/modules/wireless/wifi"; nomouse;
images.image: "hole_tiny.png" COMP;
images.image: "led_tiny_orange.png" COMP;
images.image: "led_tiny_green.png" COMP;
images.image: "lock_locked.png" COMP;
images.image: "lock_insecure.png" COMP;
script {
public message(Msg_Type:type, id, ...) {
@ -95,6 +98,16 @@ group { name: "e/modules/wireless/wifi"; nomouse;
}
}
///////////////////////
part { name: "wifi_shadow";
clip_to: "clip_wifi";
description { state: "default" 0.0;
aspect: (160/144) (160/144); aspect_preference: BOTH;
align: 0.5 1.0;
rel2.relative: 1.0 0.5;
rel2.to_y: "slot";
image.normal: "wifi_shadow.png";
}
}
part { name: "wifi_base";
clip_to: "clip_wifi";
description { state: "default" 0.0;
@ -159,6 +172,24 @@ group { name: "e/modules/wireless/wifi"; nomouse;
visible: 1;
}
}
part { name: "lock";
clip_to: "clip_wifi";
description { state: "default" 0.0; hid;
aspect: (160/144) (160/144); aspect_preference: BOTH;
align: 0.5 1.0;
rel2.relative: 1.0 0.5;
rel2.to_y: "slot";
image.normal: "lock_locked.png";
link.base: "e,state,unsecured" "e";
}
desc { "insecure"; inherit; vis;
image.normal: "lock_insecure.png";
link.base: "e,state,insecure" "e";
}
desc { "secure"; inherit; vis;
link.base: "e,state,secure" "e";
}
}
//////////////////////////
part { name: "slot";
description { state: "default" 0.0;
@ -504,56 +535,3 @@ group { name: "e/modules/wireless/bluetooth"; nomouse;
}
}
}
group { name: "e/modules/wireless/end";
images.image: "glow_lock_locked.png" COMP;
images.image: "glow_lock_unlocked.png" COMP;
images.image: "glow_lock_double.png" COMP;
parts {
part { name: "base"; mouse_events: 0;
description { state: "default" 0.0;
image.normal: "glow_lock_locked.png";
max: 16 16;
aspect: 1.0 1.0; aspect_preference: BOTH;
visible: 0;
}
description { state: "none" 0.0;
inherit: "default" 0.0;
image.normal: "glow_lock_unlocked.png";
visible: 1;
}
description { state: "wep" 0.0;
inherit: "default" 0.0;
image.normal: "glow_lock_locked.png";
visible: 1;
}
description { state: "psk" 0.0;
inherit: "default" 0.0;
image.normal: "glow_lock_double.png";
visible: 1;
}
}
}
programs {
program {
signal: "e,security,off"; source: "e";
action: STATE_SET "default" 0.0;
target: "base";
}
program {
signal: "e,security,none"; source: "e";
action: STATE_SET "none" 0.0;
target: "base";
}
program {
signal: "e,security,wep"; source: "e";
action: STATE_SET "wep" 0.0;
target: "base";
}
program {
signal: "e,security,psk"; source: "e";
action: STATE_SET "psk" 0.0;
target: "base";
}
}
}

26
src/gadgets/bryce.c
View File

@ -62,6 +62,14 @@ static E_Action *menu_act;
b = evas_object_data_get((obj), "__bryce"); \
if (!b) abort()
static void
_bryce_obstacle_del(void *obs)
{
Bryce *b = e_object_data_get(obs);
b->zone_obstacles = eina_list_remove(b->zone_obstacles, obs);
}
static void
_bryce_autohide_end(void *data, Efx_Map_Data *e EINA_UNUSED, Evas_Object *obj EINA_UNUSED)
{
@ -218,12 +226,12 @@ _bryce_autosize(Bryce *b)
elm_object_content_set(b->scroller, b->site);
}
evas_object_size_hint_min_get(b->site, &sw, &sh);
evas_object_size_hint_min_get(b->layout, &lw, &lh);
edje_object_size_min_calc(elm_layout_edje_get(b->layout), &lw, &lh);
_bryce_position(b, lw + sw, lh + sh, &x, &y);
if (b->orient == Z_GADGET_SITE_ORIENT_HORIZONTAL)
w = MIN(lw + sw, maxw), h = b->size * e_scale;
w = MIN(MAX(lw + sw, b->size * e_scale), maxw), h = b->size * e_scale;
else if (b->orient == Z_GADGET_SITE_ORIENT_VERTICAL)
w = b->size * e_scale, h = MIN(lh + sh, maxh);
w = b->size * e_scale, h = MIN(MAX(lh + sh, b->size * e_scale), maxh);
efx_resize(b->bryce, EFX_EFFECT_SPEED_LINEAR, EFX_POINT(x, y), w, h, 0.1, NULL, NULL);
b->size_changed = 0;
}
@ -418,9 +426,15 @@ _bryce_moveresize(void *data, Evas *e EINA_UNUSED, Evas_Object *obj, void *event
e_zone_obstacle_modify(obs, &(Eina_Rectangle){b->x, b->y, w, h}, vertical);
}
else
b->zone_obstacles = eina_list_append(b->zone_obstacles,
e_zone_obstacle_add(e_comp_object_util_zone_get(obj), NULL,
&(Eina_Rectangle){b->x, b->y, w, h}, vertical));
{
void *obs;
obs = e_zone_obstacle_add(e_comp_object_util_zone_get(obj), NULL,
&(Eina_Rectangle){b->x, b->y, w, h}, vertical);
e_object_data_set(obs, b);
E_OBJECT_DEL_SET(obs, _bryce_obstacle_del);
b->zone_obstacles = eina_list_append(b->zone_obstacles, obs);
}
}
else
{

10
src/gadgets/core.c
View File

@ -165,6 +165,14 @@ _gadget_reparent(Z_Gadget_Site *zgs, Z_Gadget_Config *zgc)
}
}
static void
_gadget_popup(void *data, Evas_Object *obj EINA_UNUSED, void *event_info)
{
Z_Gadget_Site *zgs = data;
evas_object_smart_callback_call(zgs->layout, "gadget_popup", event_info);
}
static void
_gadget_del(void *data, Evas *e EINA_UNUSED, Evas_Object *obj EINA_UNUSED, void *event_info EINA_UNUSED)
{
@ -211,6 +219,7 @@ _gadget_object_create(Z_Gadget_Config *zgc)
zgc->e_obj_inherit = E_OBJECT_ALLOC(E_Object, Z_GADGET_TYPE, _gadget_object_free);
e_object_data_set(zgc->e_obj_inherit, g);
zgc->gadget = zgc->display = g;
evas_object_smart_callback_add(g, "gadget_popup", _gadget_popup, zgc->site);
evas_object_data_set(g, "__z_gadget", zgc);
if (zgc->site->style_cb)
zgc->site->style_cb(zgc->site->layout, zgc->style.name, g);
@ -856,6 +865,7 @@ _gadget_menu_remove(void *data, E_Menu *m EINA_UNUSED, E_Menu_Item *mi EINA_UNUS
evas_object_smart_callback_call(zgc->site->layout, "gadget_removed", zgc->display);
zgc->site->gadgets = eina_list_remove(zgc->site->gadgets, zgc);
evas_object_smart_need_recalculate_set(zgc->site->layout, 1);
_gadget_free(zgc);
e_config_save_queue();
}

2
src/gadgets/demo.c
View File

@ -7,6 +7,7 @@ EINTERN Evas_Object *start_create(Evas_Object *parent, int *id EINA_UNUSED, Z_Ga
EINTERN void clock_init(void);
EINTERN void clock_shutdown(void);
EINTERN void ibar_init(void);
EINTERN void wireless_init(void);
static Eina_List *handlers;
static Evas_Object *rect;
@ -160,6 +161,7 @@ gadget_demo(void)
z_gadget_type_add("Start", start_create);
clock_init();
ibar_init();
wireless_init();
z_gadget_init();
z_bryce_init();

239
src/gadgets/wireless/connman.c
View File

@ -46,21 +46,38 @@ typedef struct
const char *path;
Eldbus_Proxy *proxy;
/* Private */
struct
{
Eldbus_Pending *connect;
Eldbus_Pending *disconnect;
Eldbus_Pending *remov;
void *data;
} pending;
Eldbus_Signal_Handler *handler;
/* Properties */
Eina_Stringshare *name;
Eina_Array *security;
Wireless_Network_Security security;
Connman_State state;
Connman_Service_Type type;
uint8_t strength;
/* Private */
struct
{
Eldbus_Pending *connect;
Eldbus_Pending *disconnect;
Eldbus_Pending *remov;
void *data;
} pending;
unsigned int method;
Eina_Stringshare *address;
Eina_Stringshare *gateway;
union
{
struct
{
Eina_Stringshare *netmask;
} v4;
struct
{
Eina_Stringshare *prefixlength;
Wireless_Network_IPv6_Privacy privacy;
} v6;
} ip;
Eina_Bool ipv6 : 1;
} Connman_Service;
typedef struct Connman_Field
@ -85,20 +102,81 @@ static Eina_Inlist *connman_services;
static unsigned int connman_services_count;
static Eldbus_Service_Interface *agent_iface;
static Connman_State connman_state;
static Connman_Service *connman_current_service;
static Eina_Bool connman_offline;
static Eina_Bool connman_powered;
/* connman -> wireless */
static Eina_Hash *connman_services_map;
static Wireless_Network_State
_connman_wifi_state_convert(Connman_State state)
{
Wireless_Network_State wifi_state;
switch (state)
{
case CONNMAN_STATE_ASSOCIATION:
case CONNMAN_STATE_CONFIGURATION:
wifi_state = WIRELESS_NETWORK_STATE_CONFIGURING;
break;
case CONNMAN_STATE_READY:
wifi_state = WIRELESS_NETWORK_STATE_CONNECTED;
break;
case CONNMAN_STATE_ONLINE:
wifi_state = WIRELESS_NETWORK_STATE_ONLINE;
break;
case CONNMAN_STATE_FAILURE:
wifi_state = WIRELESS_NETWORK_STATE_FAILURE;
break;
case CONNMAN_STATE_NONE:
case CONNMAN_STATE_OFFLINE:
case CONNMAN_STATE_IDLE:
case CONNMAN_STATE_DISCONNECT:
default:
wifi_state = WIRELESS_NETWORK_STATE_NONE;
}
return wifi_state;
}
static Wireless_Connection *
_connman_service_convert(Connman_Service *cs)
{
Wireless_Connection *wn;
wn = E_NEW(Wireless_Connection, 1);
memcpy(wn, &cs->name, sizeof(Wireless_Connection));
wn->state = _connman_wifi_state_convert(cs->state);
return wn;
}
static void
connman_update_current_network(Connman_Service *cs)
{
connman_current_service = cs;
if (eina_hash_population(connman_services_map))
wireless_wifi_current_network_set(eina_hash_find(connman_services_map, &cs));
}
static void
connman_update_networks(void)
{
Eina_Array *arr;
Connman_Service *cs;
Wireless_Connection *wn;
eina_hash_free_buckets(connman_services_map);
arr = eina_array_new(connman_services_count);
EINA_INLIST_FOREACH(connman_services, cs)
eina_array_push(arr, &cs->name);
{
wn = _connman_service_convert(cs);
eina_hash_add(connman_services_map, &cs, wn);
eina_array_push(arr, wn);
}
arr = wireless_wifi_networks_set(arr);
if (connman_current_service)
connman_update_current_network(connman_current_service);
if (!arr) return;
eina_array_free(arr);
}
@ -108,38 +186,6 @@ connman_update_airplane_mode(Eina_Bool offline)
wireless_airplane_mode_set(offline);
}
static void
connman_update_state(Connman_State state)
{
Wifi_State wifi_state;
if (connman_state == state) return;
connman_state = state;
switch (connman_state)
{
case CONNMAN_STATE_ASSOCIATION:
case CONNMAN_STATE_CONFIGURATION:
wifi_state = WIFI_NETWORK_STATE_CONFIGURING;
break;
case CONNMAN_STATE_READY:
wifi_state = WIFI_NETWORK_STATE_CONNECTED;
break;
case CONNMAN_STATE_ONLINE:
wifi_state = WIFI_NETWORK_STATE_ONLINE;
break;
case CONNMAN_STATE_FAILURE:
wifi_state = WIFI_NETWORK_STATE_FAILURE;
break;
case CONNMAN_STATE_NONE:
case CONNMAN_STATE_OFFLINE:
case CONNMAN_STATE_IDLE:
case CONNMAN_STATE_DISCONNECT:
default:
wifi_state = WIFI_NETWORK_STATE_NONE;
}
wireless_wifi_state_set(wifi_state);
}
static Connman_State
str_to_state(const char *s)
{
@ -169,28 +215,27 @@ str_to_type(const char *s)
{
if (!strcmp(s, "ethernet"))
return CONNMAN_SERVICE_TYPE_ETHERNET;
else if (!strcmp(s, "wifi"))
if (!strcmp(s, "wifi"))
return CONNMAN_SERVICE_TYPE_WIFI;
else if (!strcmp(s, "bluetooth"))
if (!strcmp(s, "bluetooth"))
return CONNMAN_SERVICE_TYPE_BLUETOOTH;
else if (!strcmp(s, "cellular"))
if (!strcmp(s, "cellular"))
return CONNMAN_SERVICE_TYPE_CELLULAR;
DBG("Unknown type %s", s);
return CONNMAN_SERVICE_TYPE_NONE;
}
static void
_connman_service_security_array_clean(Connman_Service *cs)
static Wireless_Network_Security
str_to_security(const char *s)
{
const char *item;
Eina_Array_Iterator itr;
unsigned int i;
EINA_ARRAY_ITER_NEXT(cs->security, i, item, itr)
eina_stringshare_del(item);
eina_array_clean(cs->security);
if (!strcmp(s, "none")) return WIRELESS_NETWORK_SECURITY_NONE;
if (!strcmp(s, "wep")) return WIRELESS_NETWORK_SECURITY_WEP;
if (!strcmp(s, "psk")) return WIRELESS_NETWORK_SECURITY_PSK;
if (!strcmp(s, "ieee8021x")) return WIRELESS_NETWORK_SECURITY_IEEE8021X;
if (!strcmp(s, "wps")) return WIRELESS_NETWORK_SECURITY_WPS;
CRI("UNKNOWN TYPE %s", s);
return WIRELESS_NETWORK_SECURITY_NONE;
}
static void
@ -215,12 +260,18 @@ _connman_service_free(Connman_Service *cs)
eldbus_pending_cancel(cs->pending.remov);
free(cs->pending.data);
}
eina_stringshare_del(cs->address);
eina_stringshare_del(cs->gateway);
if (cs->ipv6)
eina_stringshare_del(cs->ip.v6.prefixlength);
else
eina_stringshare_del(cs->ip.v4.netmask);
eina_stringshare_del(cs->name);
_connman_service_security_array_clean(cs);
eina_array_free(cs->security);
eina_stringshare_del(cs->path);
eldbus_signal_handler_del(cs->handler);
obj = eldbus_proxy_object_get(cs->proxy);
DBG("service free %p || proxy %p", cs, cs->proxy);
eldbus_proxy_unref(cs->proxy);
eldbus_object_unref(obj);
@ -271,20 +322,55 @@ _connman_service_parse_prop_changed(Connman_Service *cs, const char *prop_name,
else if (!strcmp(prop_name, "Security"))
{
const char *s;
Eldbus_Message_Iter *itr_array;
DBG("Old security count: %d",
cs->security ? eina_array_count(cs->security) : 0);
if (cs->security)
_connman_service_security_array_clean(cs);
else
cs->security = eina_array_new(5);
while (eldbus_message_iter_get_and_next(value, 's', &s))
DBG("Old security: %u", cs->security);
cs->security = WIRELESS_NETWORK_SECURITY_NONE;
EINA_SAFETY_ON_FALSE_RETURN(eldbus_message_iter_arguments_get(value, "as",
&itr_array));
while (eldbus_message_iter_get_and_next(itr_array, 's', &s))
cs->security |= str_to_security(s);
DBG("New security %u", cs->security);
}
else if (!strcmp(prop_name, "IPv4"))
{
Eldbus_Message_Iter *array, *dict;
EINA_SAFETY_ON_FALSE_RETURN(eldbus_message_iter_arguments_get(value, "a{sv}", &array));
while (eldbus_message_iter_get_and_next(array, 'e', &dict))
{
eina_array_push(cs->security, eina_stringshare_add(s));
DBG("Push %s", s);
Eldbus_Message_Iter *var;
const char *name, *val;
EINA_SAFETY_ON_FALSE_RETURN(eldbus_message_iter_arguments_get(dict, "sv", &name, &var));
if (!strcmp(name, "Method"))
{
cs->method = WIRELESS_NETWORK_IPV4_METHOD_OFF;
EINA_SAFETY_ON_FALSE_RETURN(eldbus_message_iter_arguments_get(var, "s", &val));
if (!strcmp(val, "off"))
cs->method = WIRELESS_NETWORK_IPV4_METHOD_OFF;
else if (!strcmp(val, "dhcp"))
cs->method = WIRELESS_NETWORK_IPV4_METHOD_DHCP;
else if (!strcmp(val, "manual"))
cs->method = WIRELESS_NETWORK_IPV4_METHOD_MANUAL;
}
else if (!strcmp(name, "Address"))
{
EINA_SAFETY_ON_FALSE_RETURN(eldbus_message_iter_arguments_get(var, "s", &val));
eina_stringshare_replace(&cs->address, val);
}
else if (!strcmp(name, "Netmask"))
{
EINA_SAFETY_ON_FALSE_RETURN(eldbus_message_iter_arguments_get(var, "s", &val));
eina_stringshare_replace(&cs->ip.v4.netmask, val);
}
else if (!strcmp(name, "Gateway"))
{
EINA_SAFETY_ON_FALSE_RETURN(eldbus_message_iter_arguments_get(var, "s", &val));
eina_stringshare_replace(&cs->gateway, val);
}
}
DBG("New security count: %d", eina_array_count(cs->security));
}
}
@ -301,6 +387,8 @@ _connman_service_prop_dict_changed(Connman_Service *cs, Eldbus_Message_Iter *pro
if (eldbus_message_iter_arguments_get(dict, "sv", &name, &var))
_connman_service_parse_prop_changed(cs, name, var);
}
if (cs->state == CONNMAN_STATE_ONLINE)
connman_update_current_network(cs);
}
static void
@ -312,6 +400,8 @@ _connman_service_property(void *data, const Eldbus_Message *msg)
if (eldbus_message_arguments_get(msg, "sv", &name, &var))
_connman_service_parse_prop_changed(cs, name, var);
if (cs->state == CONNMAN_STATE_ONLINE)
connman_update_current_network(cs);
}
static void
@ -325,13 +415,13 @@ _connman_service_new(const char *path, Eldbus_Message_Iter *props)
obj = eldbus_object_get(dbus_conn, CONNMAN_BUS_NAME, path);
cs->proxy = eldbus_proxy_get(obj, CONNMAN_SERVICE_IFACE);
eldbus_proxy_signal_handler_add(cs->proxy, "PropertyChanged",
cs->handler = eldbus_proxy_signal_handler_add(cs->proxy, "PropertyChanged",
_connman_service_property, cs);
_connman_service_prop_dict_changed(cs, props);
connman_services = eina_inlist_append(connman_services, EINA_INLIST_GET(cs));
connman_services_count++;
DBG("Added service: %p %s", cs, path);
DBG("Added service: %p %s || proxy %p", cs, path, cs->proxy);
}
static void
@ -374,7 +464,7 @@ _connman_manager_parse_prop_changed(const char *name, Eldbus_Message_Iter *value
if (!eldbus_message_iter_arguments_get(value, "s", &state))
return EINA_FALSE;
DBG("New state: %s", state);
connman_update_state(str_to_state(state));
//connman_update_state(str_to_state(state));
}
else if (!strcmp(name, "OfflineMode"))
{
@ -765,6 +855,7 @@ _connman_end(void)
{
Eldbus_Object *obj;
if (!proxy_manager) return;
eldbus_proxy_call(proxy_manager, "UnregisterAgent", NULL, NULL, -1, "o", CONNMAN_AGENT_PATH);
while (connman_services)
@ -799,6 +890,7 @@ EINTERN void
connman_init(void)
{
if (_connman_log_dom > -1) return;
connman_services_map = eina_hash_pointer_new(free);
eldbus_name_owner_changed_callback_add(dbus_conn, CONNMAN_BUS_NAME,
_connman_name_owner_changed,
NULL, EINA_TRUE);
@ -809,6 +901,7 @@ EINTERN void
connman_shutdown(void)
{
E_FREE_FUNC(agent_iface, eldbus_service_object_unregister);
E_FREE_FUNC(connman_services_map, eina_hash_free);
_connman_end();
eldbus_name_owner_changed_callback_del(dbus_conn, CONNMAN_BUS_NAME, _connman_name_owner_changed, NULL);
eina_log_domain_unregister(_connman_log_dom);

9
src/gadgets/wireless/mod.c
View File

@ -1,5 +1,11 @@
#include "e.h"
EINTERN void wireless_gadget_init(void);
EINTERN void wireless_gadget_shutdown(void);
EINTERN void connman_init(void);
EINTERN void connman_shutdown(void);
EINTERN Eldbus_Connection *dbus_conn;
EINTERN void
@ -7,10 +13,13 @@ wireless_init(void)
{
dbus_conn = eldbus_connection_get(ELDBUS_CONNECTION_TYPE_SYSTEM);
connman_init();
wireless_gadget_init();
}
EINTERN void
wireless_shutdown(void)
{
wireless_gadget_shutdown();
connman_shutdown();
E_FREE_FUNC(dbus_conn, eldbus_connection_unref);
}

220
src/gadgets/wireless/wireless.c
View File

@ -9,37 +9,50 @@ typedef struct Instance
Eina_Hash *popup_items;
} Instance;
static Wifi_State wifi_state;
static Wireless_Network_State wifi_network_state;
static Eina_Array *wifi_networks;
static Wifi_Network *wifi_current;
static Wireless_Connection *wifi_current;
static Eina_Bool wifi_enabled;
static Eina_List *instances;
static void
_wifi_icon_init(Evas_Object *icon, Wifi_Network *wn)
_wifi_icon_init(Evas_Object *icon, Wireless_Connection *wn)
{
Edje_Message_Int_Set *msg;
int state = 0, strength = 0;
if (wn)
{
state = wn->state;
strength = wn->strength;
}
msg = alloca(sizeof(Edje_Message_Int_Set) + sizeof(int));
msg->count = 2;
msg->val[0] = wn->state;
msg->val[1] = wn->strength;
msg->val[0] = state;
msg->val[1] = strength;
edje_object_message_send(elm_layout_edje_get(icon), EDJE_MESSAGE_INT_SET, 1, msg);
}
static void
_wifi_state_update(Evas_Object *g)
{
switch (wifi_state)
if (!wn)
{
case WIFI_STATE_NONE: break;
case WIFI_STATE_ETHERNET:
elm_object_signal_emit(g, "e,state,ethernet", "e");
elm_object_signal_emit(icon, "e,state,disconnected", "e");
return;
}
switch (wn->type)
{
case WIRELESS_SERVICE_TYPE_ETHERNET:
elm_object_signal_emit(icon, "e,state,ethernet", "e");
break;
case WIFI_STATE_WIFI:
elm_object_signal_emit(g, "e,state,wifi", "e");
case WIRELESS_SERVICE_TYPE_WIFI:
elm_object_signal_emit(icon, "e,state,wifi", "e");
if (wn->security > WIRELESS_NETWORK_SECURITY_WEP)
elm_object_signal_emit(icon, "e,state,secure", "e");
else if (wn->security == WIRELESS_NETWORK_SECURITY_WEP)
elm_object_signal_emit(icon, "e,state,insecure", "e");
else if (!wn->security)
elm_object_signal_emit(icon, "e,state,unsecured", "e");
break;
default: break;
}
}
@ -53,7 +66,7 @@ static void
_wifi_popup_list_populate(Instance *inst)
{
Eina_Iterator *it;
Wifi_Network *wn;
Wireless_Connection *wn;
it = eina_array_iterator_new(wifi_networks);
EINA_ITERATOR_FOREACH(it, wn)
@ -61,6 +74,7 @@ _wifi_popup_list_populate(Instance *inst)
Evas_Object *icon;
Elm_Object_Item *item;
if (wn->type != WIRELESS_SERVICE_TYPE_WIFI) continue;
icon = elm_layout_add(inst->popup_list);
e_theme_edje_object_set(icon, NULL, "e/modules/wireless/wifi");
_wifi_icon_init(icon, wn);
@ -76,12 +90,6 @@ _wifi_popup_wifi_toggle(void *data, Evas_Object *obj EINA_UNUSED, void *event_in
Instance *inst = data;
}
static void
_wifi_popup_dismissed(void *data EINA_UNUSED, Evas_Object *obj, void *event_info EINA_UNUSED)
{
evas_object_del(obj);
}
static void
_wifi_popup_del(void *data, Evas *e EINA_UNUSED, Evas_Object *obj EINA_UNUSED, void *event_info EINA_UNUSED)
{
@ -91,6 +99,12 @@ _wifi_popup_del(void *data, Evas *e EINA_UNUSED, Evas_Object *obj EINA_UNUSED, v
inst->popup = NULL;
}
static Eina_Bool
_wifi_popup_key()
{
return EINA_TRUE;
}
static void
_wifi_mouse_down(void *data, Evas *e EINA_UNUSED, Evas_Object *obj EINA_UNUSED, void *event_info)
{
@ -99,23 +113,32 @@ _wifi_mouse_down(void *data, Evas *e EINA_UNUSED, Evas_Object *obj EINA_UNUSED,
Evas_Object *ctx, *box, *list, *toggle;
if (ev->button != 1) return;
if (inst->popup)
{
evas_object_hide(inst->popup);
evas_object_del(inst->popup);
return;
}
inst->popup_items = eina_hash_pointer_new(NULL);
inst->popup = ctx = elm_ctxpopup_add(e_comp->elm);
elm_object_style_set(inst->popup, "noblock");
evas_object_smart_callback_add(inst->popup, "dismissed", _wifi_popup_dismissed, inst);
evas_object_event_callback_add(inst->popup, EVAS_CALLBACK_DEL, _wifi_popup_del, inst);
ctx = elm_ctxpopup_add(e_comp->elm);
elm_object_style_set(ctx, "noblock");
box = elm_box_add(ctx);
E_EXPAND(box);
E_FILL(box);
inst->popup_list = list = elm_list_add(ctx);
elm_list_mode_set(list, ELM_LIST_COMPRESS);
elm_scroller_content_min_limit(list, 0, 1);
evas_object_size_hint_max_set(list, -1, e_comp_object_util_zone_get(inst->box)-> h / 3);
E_EXPAND(list);
E_FILL(list);
_wifi_popup_list_populate(inst);
elm_list_go(list);
evas_object_show(list);
elm_box_pack_end(box, list);
toggle = elm_check_add(ctx);
evas_object_show(toggle);
elm_object_style_set(toggle, "toggle");
elm_object_text_set(toggle, "Wifi State");
elm_object_part_text_set(toggle, "on", "On");
@ -125,7 +148,77 @@ _wifi_mouse_down(void *data, Evas *e EINA_UNUSED, Evas_Object *obj EINA_UNUSED,
elm_box_pack_end(box, toggle);
elm_object_content_set(ctx, box);
z_gadget_util_ctxpopup_place(inst->box, ctx);
evas_object_show(ctx);
evas_object_smart_callback_call(inst->box, "gadget_popup", ctx);
inst->popup = e_comp_object_util_add(ctx, E_COMP_OBJECT_TYPE_NONE);
evas_object_layer_set(inst->popup, evas_object_layer_get(inst->popup) + 1);
e_comp_object_util_autoclose(inst->popup, NULL, _wifi_popup_key, NULL);
evas_object_show(inst->popup);
evas_object_event_callback_add(inst->popup, EVAS_CALLBACK_DEL, _wifi_popup_del, inst);
}
static void
_wifi_tooltip_row(Evas_Object *tb, const char *label, const char *value, int row)
{
Evas_Object *lbl;
lbl = elm_label_add(tb);
evas_object_show(lbl);
E_ALIGN(lbl, 0, 0.5);
elm_object_text_set(lbl, label);
elm_table_pack(tb, lbl, 0, row, 1, 1);
lbl = elm_label_add(tb);
evas_object_show(lbl);
E_ALIGN(lbl, 0, 0.5);
elm_object_text_set(lbl, value);
elm_table_pack(tb, lbl, 1, row, 1, 1);
}
static Evas_Object *
_wifi_tooltip(void *data, Evas_Object *obj EINA_UNUSED, Evas_Object *tooltip)
{
Instance *inst = data;
Evas_Object *tb;
int row = 0;
const char *val;
char buf[1024];
if (!wifi_current) return NULL;
tb = elm_table_add(tooltip);
elm_table_padding_set(tb, 5, 1);
_wifi_tooltip_row(tb, "Name:", wifi_current->name, row++);
val = "Disabled";
if (wifi_current->ipv6)
{
if (wifi_current->method == WIRELESS_NETWORK_IPV6_METHOD_MANUAL)
val = "Manual";
else if (wifi_current->method == WIRELESS_NETWORK_IPV6_METHOD_AUTO)
val = "Auto";
else if (wifi_current->method == WIRELESS_NETWORK_IPV6_METHOD_6TO4)
val = "6to4";
}
else
{
if (wifi_current->method == WIRELESS_NETWORK_IPV4_METHOD_MANUAL)
val = "Manual";
else if (wifi_current->method == WIRELESS_NETWORK_IPV4_METHOD_DHCP)
val = "DHCP";
}
_wifi_tooltip_row(tb, "Method:", val, row++);
if (wifi_current->type == WIRELESS_SERVICE_TYPE_WIFI)
{
snprintf(buf, sizeof(buf), "%u%%", wifi_current->strength);
_wifi_tooltip_row(tb, "Signal:", buf, row++);
}
if ((wifi_current->state == WIRELESS_NETWORK_STATE_CONNECTED) ||
(wifi_current->state == WIRELESS_NETWORK_STATE_ONLINE))
{
_wifi_tooltip_row(tb, "Address:", wifi_current->address, row++);
}
return tb;
}
static void
@ -134,6 +227,7 @@ wireless_del(void *data, Evas *e EINA_UNUSED, Evas_Object *obj EINA_UNUSED, void
Instance *inst = data;
instances = eina_list_remove(instances, inst);
evas_object_hide(inst->popup);
evas_object_del(inst->popup);
free(inst);
}
@ -153,7 +247,10 @@ wireless_create(Evas_Object *parent, int *id, Z_Gadget_Site_Orient orient)
E_EXPAND(g);
E_FILL(g);
e_theme_edje_object_set(g, NULL, "e/modules/wireless/wifi");
evas_object_show(g);
elm_box_pack_end(inst->box, g);
evas_object_show(inst->box);
elm_object_tooltip_content_cb_set(g, _wifi_tooltip, inst, NULL);
evas_object_size_hint_aspect_set(inst->box, EVAS_ASPECT_CONTROL_BOTH, 1, 1);
evas_object_event_callback_add(inst->box, EVAS_CALLBACK_DEL, wireless_del, inst);
@ -161,54 +258,69 @@ wireless_create(Evas_Object *parent, int *id, Z_Gadget_Site_Orient orient)
if (*id < 0)
elm_object_signal_emit(g, "e,state,wifi", "e");
else
{
_wifi_state_update(g);
if (wifi_current)
_wifi_icon_init(g, wifi_current);
}
else if (wifi_current)
_wifi_icon_init(g, wifi_current);
instances = eina_list_append(instances, inst);
return inst->box;
}
static void
wireless_init(void)
EINTERN void
wireless_gadget_init(void)
{
z_gadget_type_add("Wireless", wireless_create);
}
EINTERN void
wireless_wifi_state_set(Wifi_State state)
wireless_gadget_shutdown(void)
{
Eina_List *l;
Instance *inst;
if (wifi_state == state) return;
wifi_state = state;
EINA_LIST_FOREACH(instances, l, inst)
_wifi_state_update(inst->wifi);
z_gadget_type_del("Wireless");
}
EINTERN void
wireless_wifi_current_network_set(Wifi_Network *wn)
wireless_wifi_network_state_set(Wireless_Network_State state)
{
Eina_List *l;
Instance *inst;
if (wifi_network_state == state) return;
wifi_network_state = state;
//EINA_LIST_FOREACH(instances, l, inst)
//_wifi_network_state_update(inst->wifi);
}
EINTERN void
wireless_wifi_current_network_set(Wireless_Connection *wn)
{
Eina_List *l;
Instance *inst;
Wireless_Connection *prev;
prev = wifi_current;
wifi_current = wn;
EINA_LIST_FOREACH(instances, l, inst)
if (inst->popup)
{
Elm_Object_Item *it;
Evas_Object *icon;
{
if (inst->popup)
{
Elm_Object_Item *it;
Evas_Object *icon;
it = eina_hash_find(inst->popup_items, &wn);
icon = elm_object_item_content_get(it);
_wifi_icon_init(icon, wn);
}
if (wn)
{
it = eina_hash_find(inst->popup_items, &wn);
icon = elm_object_item_content_get(it);
_wifi_icon_init(icon, wn);
}
if (prev)
{
it = eina_hash_find(inst->popup_items, &prev);
icon = elm_object_item_content_get(it);
_wifi_icon_init(icon, prev);
}
}
_wifi_icon_init(inst->wifi, wn);
}
}
EINTERN Eina_Array *

84
src/gadgets/wireless/wireless.h
View File

@ -4,34 +4,84 @@
#include "e.h"
#include "gadget.h"
typedef enum Wifi_State
typedef enum
{
WIFI_STATE_NONE,
WIFI_STATE_ETHERNET,
WIFI_STATE_WIFI,
} Wifi_State;
WIRELESS_SERVICE_TYPE_NONE = -1,
WIRELESS_SERVICE_TYPE_ETHERNET,
WIRELESS_SERVICE_TYPE_WIFI,
WIRELESS_SERVICE_TYPE_BLUETOOTH,
WIRELESS_SERVICE_TYPE_CELLULAR,
} Wireless_Service_Type;
typedef enum
{
WIFI_NETWORK_STATE_NONE,
WIFI_NETWORK_STATE_CONFIGURING,
WIFI_NETWORK_STATE_CONNECTED,
WIFI_NETWORK_STATE_ONLINE,
WIFI_NETWORK_STATE_FAILURE,
} Wifi_Network_State;
WIRELESS_NETWORK_STATE_NONE,
WIRELESS_NETWORK_STATE_CONFIGURING,
WIRELESS_NETWORK_STATE_CONNECTED,
WIRELESS_NETWORK_STATE_ONLINE,
WIRELESS_NETWORK_STATE_FAILURE,
} Wireless_Network_State;
typedef struct Wifi_Network
typedef enum
{
WIRELESS_NETWORK_SECURITY_NONE = 0,
WIRELESS_NETWORK_SECURITY_WEP = (1 << 0),
WIRELESS_NETWORK_SECURITY_PSK = (1 << 1),
WIRELESS_NETWORK_SECURITY_IEEE8021X = (1 << 2),
WIRELESS_NETWORK_SECURITY_WPS = (1 << 3),
} Wireless_Network_Security;
typedef enum
{
WIRELESS_NETWORK_IPV4_METHOD_OFF,
WIRELESS_NETWORK_IPV4_METHOD_MANUAL,
WIRELESS_NETWORK_IPV4_METHOD_DHCP,
} Wireless_Network_IPv4_Method;
typedef enum
{
WIRELESS_NETWORK_IPV6_METHOD_OFF,
WIRELESS_NETWORK_IPV6_METHOD_MANUAL,
WIRELESS_NETWORK_IPV6_METHOD_AUTO,
WIRELESS_NETWORK_IPV6_METHOD_6TO4,
} Wireless_Network_IPv6_Method;
typedef enum
{
WIRELESS_NETWORK_IPV6_PRIVACY_DISABLED,
WIRELESS_NETWORK_IPV6_PRIVACY_ENABLED,
WIRELESS_NETWORK_IPV6_PRIVACY_PREFERRED,
} Wireless_Network_IPv6_Privacy;
typedef struct Wireless_Connection
{
Eina_Stringshare *name;
Eina_Array *security;
Wifi_Network_State state;
Wireless_Network_Security security;
Wireless_Network_State state;
Wireless_Service_Type type;
uint8_t strength;
} Wifi_Network;
unsigned int method;
Eina_Stringshare *address;
Eina_Stringshare *gateway;
union
{
struct
{
Eina_Stringshare *netmask;
} v4;
struct
{
Eina_Stringshare *prefixlength;
Wireless_Network_IPv6_Privacy privacy;
} v6;
} ip;
Eina_Bool ipv6 : 1;
} Wireless_Connection;
extern Eldbus_Connection *dbus_conn;
EINTERN void wireless_wifi_state_set(Wifi_State state);
EINTERN void wireless_wifi_current_network_set(Wifi_Network *wn);
EINTERN void wireless_wifi_network_state_set(Wireless_Network_State state);
EINTERN void wireless_wifi_current_network_set(Wireless_Connection *wn);
EINTERN Eina_Array *wireless_wifi_networks_set(Eina_Array *networks);
EINTERN void wireless_airplane_mode_set(Eina_Bool enabled);