diff options
Diffstat (limited to 'meta/recipes-connectivity/connman')
12 files changed, 3679 insertions, 70 deletions
diff --git a/meta/recipes-connectivity/connman/files/connman b/meta/recipes-connectivity/connman/connman-0.56/connman index f8154f68f..f8154f68f 100755 --- a/meta/recipes-connectivity/connman/files/connman +++ b/meta/recipes-connectivity/connman/connman-0.56/connman diff --git a/meta/recipes-connectivity/connman/files/dbusperms.patch b/meta/recipes-connectivity/connman/connman-0.56/dbusperms.patch index 100af0367..100af0367 100644 --- a/meta/recipes-connectivity/connman/files/dbusperms.patch +++ b/meta/recipes-connectivity/connman/connman-0.56/dbusperms.patch diff --git a/meta/recipes-connectivity/connman/connman-gnome/connman-applet.desktop b/meta/recipes-connectivity/connman/connman-gnome/connman-applet.desktop new file mode 100644 index 000000000..83d96ee67 --- /dev/null +++ b/meta/recipes-connectivity/connman/connman-gnome/connman-applet.desktop @@ -0,0 +1,10 @@ +[Desktop Entry] +Encoding=UTF-8 +Name=Connection Manager +Comment=Connection Manager applet +Icon=stock_internet +Exec=connman-applet +Terminal=false +Type=Application +Categories=Network;GTK; + diff --git a/meta/recipes-connectivity/connman/connman-gnome/connman-gnome.patch b/meta/recipes-connectivity/connman/connman-gnome/connman-gnome.patch new file mode 100644 index 000000000..52b105e47 --- /dev/null +++ b/meta/recipes-connectivity/connman/connman-gnome/connman-gnome.patch @@ -0,0 +1,3612 @@ +connman-gnome: Change the code to fit recent connman + +The recent connman changes from "device" based to "service" based. +Therefore most of the interaction protocol between connman and +connman-gnome has changed. This commit uses the new dbus interface +to interact with connman. With this change, connman-gnome could +do wired and wireless interface configurations with latest connman. + +Besides, some UI is re-designed to be more neat and friendly to +end user. + +Signed-off-by: Dongxiao Xu <dongxiao.xu@intel.com> + +diff --git a/applet/main.c b/applet/main.c +index 2a9b36e..1243a41 100644 +--- a/applet/main.c ++++ b/applet/main.c +@@ -108,138 +108,8 @@ static void toggled_callback(GtkWidget *button, gpointer user_data) + gtk_entry_set_visibility(GTK_ENTRY(entry), mode); + } + +-static void passphrase_dialog(const char *path, const char *name) +-{ +- GtkWidget *dialog; +- GtkWidget *button; +- GtkWidget *image; +- GtkWidget *label; +- GtkWidget *entry; +- GtkWidget *table; +- GtkWidget *vbox; +- +- dialog = gtk_dialog_new(); +- gtk_window_set_title(GTK_WINDOW(dialog), _("Enter passphrase")); +- gtk_window_set_resizable(GTK_WINDOW(dialog), FALSE); +- gtk_window_set_position(GTK_WINDOW(dialog), GTK_WIN_POS_CENTER); +- gtk_window_set_keep_above(GTK_WINDOW(dialog), TRUE); +- gtk_window_set_urgency_hint(GTK_WINDOW(dialog), TRUE); +- gtk_dialog_set_has_separator(GTK_DIALOG(dialog), FALSE); +- +- button = gtk_dialog_add_button(GTK_DIALOG(dialog), +- GTK_STOCK_CANCEL, GTK_RESPONSE_REJECT); +- button = gtk_dialog_add_button(GTK_DIALOG(dialog), +- GTK_STOCK_OK, GTK_RESPONSE_ACCEPT); +- gtk_widget_grab_default(button); +- +- table = gtk_table_new(5, 2, FALSE); +- gtk_table_set_row_spacings(GTK_TABLE(table), 4); +- gtk_table_set_col_spacings(GTK_TABLE(table), 20); +- gtk_container_set_border_width(GTK_CONTAINER(table), 12); +- gtk_container_add(GTK_CONTAINER(GTK_DIALOG(dialog)->vbox), table); +- image = gtk_image_new_from_icon_name(GTK_STOCK_DIALOG_AUTHENTICATION, +- GTK_ICON_SIZE_DIALOG); +- gtk_misc_set_alignment(GTK_MISC(image), 0.0, 0.0); +- gtk_table_attach(GTK_TABLE(table), image, 0, 1, 0, 5, +- GTK_SHRINK, GTK_FILL, 0, 0); +- vbox = gtk_vbox_new(FALSE, 6); +- +- label = gtk_label_new(_("Network requires input of a passphrase:")); +- gtk_misc_set_alignment(GTK_MISC(label), 0.0, 0.0); +- gtk_container_add(GTK_CONTAINER(vbox), label); +- gtk_table_attach(GTK_TABLE(table), vbox, 1, 2, 0, 1, +- GTK_EXPAND | GTK_FILL, GTK_SHRINK, 0, 0); +- +- entry = gtk_entry_new(); +- gtk_entry_set_max_length(GTK_ENTRY(entry), 120); +- gtk_entry_set_width_chars(GTK_ENTRY(entry), 20); +- gtk_entry_set_visibility(GTK_ENTRY(entry), FALSE); +- gtk_entry_set_activates_default(GTK_ENTRY(entry), TRUE); +- gtk_container_add(GTK_CONTAINER(vbox), entry); +- +- button = gtk_check_button_new_with_label(_("Show input")); +- gtk_container_add(GTK_CONTAINER(vbox), button); +- +- g_signal_connect(G_OBJECT(button), "toggled", +- G_CALLBACK(toggled_callback), entry); +- +- button = gtk_check_button_new_with_label(_("Remember network")); +- gtk_container_add(GTK_CONTAINER(vbox), button); +- +- gtk_widget_show_all(dialog); +- +- if (gtk_dialog_run(GTK_DIALOG(dialog)) == GTK_RESPONSE_ACCEPT) { +- const gchar *passphrase; +- gboolean remember; +- +- passphrase = gtk_entry_get_text(GTK_ENTRY(entry)); +- remember = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(button)); +- +- connman_client_set_passphrase(client, path, passphrase); +- connman_client_set_remember(client, path, remember); +- +- status_prepare(); +- connman_client_connect(client, path); +- } +- +- gtk_widget_destroy(dialog); +-} +- +-static void activate_callback(GtkWidget *item, gpointer user_data) +-{ +- const gchar *path = user_data; +- guint security; +- gchar *passphrase; +- +- security = connman_client_get_security(client, path); +- if (security == CONNMAN_SECURITY_UNKNOWN) +- return; +- +- if (security == CONNMAN_SECURITY_NONE) { +- status_prepare(); +- connman_client_connect(client, path); +- return; +- } +- +- passphrase = connman_client_get_passphrase(client, path); +- if (passphrase != NULL) { +- g_free(passphrase); +- +- status_prepare(); +- connman_client_connect(client, path); +- return; +- } +- +- passphrase_dialog(path, NULL); +-} +- +-static void disconnect_callback(GtkWidget *item, gpointer user_data) +-{ +- connman_client_disconnect(client, NULL); +-} +- +-static GtkWidget *create_popupmenu(void) +-{ +- GtkWidget *menu; +- GtkWidget *item; +- +- menu = gtk_menu_new(); +- +- item = gtk_image_menu_item_new_from_stock(GTK_STOCK_PREFERENCES, NULL); +- g_signal_connect(item, "activate", G_CALLBACK(settings_callback), NULL); +- gtk_widget_show(item); +- gtk_menu_shell_append(GTK_MENU_SHELL(menu), item); +- +- item = gtk_image_menu_item_new_from_stock(GTK_STOCK_ABOUT, NULL); +- g_signal_connect(item, "activate", G_CALLBACK(about_callback), NULL); +- gtk_widget_show(item); +- gtk_menu_shell_append(GTK_MENU_SHELL(menu), item); +- +- return menu; +-} +- + static GtkWidget *append_menuitem(GtkMenu *menu, const char *ssid, +- guint security, guint strength) ++ gchar *security, guint strength) + { + GtkWidget *item; + GtkWidget *hbox; +@@ -263,7 +133,7 @@ static GtkWidget *append_menuitem(GtkMenu *menu, const char *ssid, + image = gtk_image_new_from_stock(GTK_STOCK_DIALOG_AUTHENTICATION, + GTK_ICON_SIZE_MENU); + gtk_misc_set_alignment(GTK_MISC(image), 1.0, 0.5); +- if (security != CONNMAN_SECURITY_NONE) { ++ if (security && g_str_equal(security, "none") != TRUE) { + gtk_box_pack_start(GTK_BOX(hbox), image, FALSE, FALSE, 0); + gtk_widget_show(image); + } +@@ -281,96 +151,21 @@ static GtkWidget *append_menuitem(GtkMenu *menu, const char *ssid, + return item; + } + +-static void enumerate_networks(GtkMenu *menu, +- GtkTreeModel *model, GtkTreeIter *parent) +-{ +- GtkTreeIter iter; +- gboolean cont; +- +- cont = gtk_tree_model_iter_children(model, &iter, parent); +- +- while (cont == TRUE) { +- GtkWidget *item; +- DBusGProxy *proxy; +- guint strength, security; +- gchar *name, *path; +- gboolean inrange, connected; +- +- gtk_tree_model_get(model, &iter, +- CONNMAN_COLUMN_PROXY, &proxy, +- CONNMAN_COLUMN_NAME, &name, +- CONNMAN_COLUMN_INRANGE, &inrange, +- CONNMAN_COLUMN_ENABLED, &connected, +- CONNMAN_COLUMN_STRENGTH, &strength, +- CONNMAN_COLUMN_SECURITY, &security, -1); +- +- if (connected == TRUE || inrange == TRUE) { +- item = append_menuitem(menu, name, security, strength); +- gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(item), +- connected); +- +- path = g_strdup(dbus_g_proxy_get_path(proxy)); +- g_signal_connect(item, "activate", +- G_CALLBACK(activate_callback), path); +- } +- +- g_free(name); +- +- cont = gtk_tree_model_iter_next(model, &iter); +- } +-} +- + static gboolean menu_callback(GtkMenu *menu) + { +- GtkTreeModel *model; +- GtkTreeIter parent; + GtkWidget *item; +- gboolean cont; +- +- connman_client_propose_scan(client, NULL); +- +- model = connman_client_get_device_network_model(client); +- +- cont = gtk_tree_model_get_iter_first(model, &parent); +- +- while (cont == TRUE) { +- guint type; +- gchar *name; +- +- gtk_tree_model_get(model, &parent, +- CONNMAN_COLUMN_TYPE, &type, +- CONNMAN_COLUMN_NAME, &name, -1); +- +- switch (type) { +- case CONNMAN_TYPE_WIFI: +- case CONNMAN_TYPE_WIMAX: +- enumerate_networks(menu, model, &parent); +- break; +- default: +- break; +- } +- +- g_free(name); +- +- cont = gtk_tree_model_iter_next(model, &parent); +- } +- +- g_object_unref(model); + + item = gtk_separator_menu_item_new(); + gtk_widget_show(item); + gtk_menu_shell_append(GTK_MENU_SHELL(menu), item); + +- item = gtk_menu_item_new_with_label(_("Disconnect Network")); +- g_signal_connect(item, "activate", +- G_CALLBACK(disconnect_callback), NULL); ++ item = gtk_image_menu_item_new_from_stock(GTK_STOCK_PREFERENCES, NULL); ++ g_signal_connect(item, "activate", G_CALLBACK(settings_callback), NULL); + gtk_widget_show(item); + gtk_menu_shell_append(GTK_MENU_SHELL(menu), item); + +- item = gtk_menu_item_new_with_label(_("Join Other Network...")); +- gtk_widget_set_sensitive(item, FALSE); +- //g_signal_connect(item, "activate", +- // G_CALLBACK(join_callback), NULL); ++ item = gtk_image_menu_item_new_from_stock(GTK_STOCK_ABOUT, NULL); ++ g_signal_connect(item, "activate", G_CALLBACK(about_callback), NULL); + gtk_widget_show(item); + gtk_menu_shell_append(GTK_MENU_SHELL(menu), item); + +@@ -387,16 +182,17 @@ static void update_status(GtkTreeModel *model) + cont = gtk_tree_model_get_iter_first(model, &iter); + + while (cont == TRUE) { +- gboolean enabled; ++ gchar *state; + + gtk_tree_model_get(model, &iter, + CONNMAN_COLUMN_TYPE, &type, + CONNMAN_COLUMN_STRENGTH, &strength, +- CONNMAN_COLUMN_ENABLED, &enabled, -1); ++ CONNMAN_COLUMN_STATE, &state, -1); + + online = TRUE; + +- if (enabled == TRUE) ++ if ((type == CONNMAN_TYPE_ETHERNET && (g_str_equal(state, "idle") || g_str_equal(state, "online"))) || ++ (type == CONNMAN_TYPE_WIFI && (g_str_equal(state, "ready") || g_str_equal(state, "online")))) + break; + + cont = gtk_tree_model_iter_next(model, &iter); +@@ -453,7 +249,7 @@ int main(int argc, char *argv[]) + + g_set_application_name(_("Connection Manager")); + +- status_init(menu_callback, create_popupmenu()); ++ status_init(menu_callback); + + client = connman_client_new(); + model = connman_client_get_connection_model(client); +diff --git a/applet/status.c b/applet/status.c +index ef11bcc..13ec752 100644 +--- a/applet/status.c ++++ b/applet/status.c +@@ -170,19 +170,6 @@ static void activate_callback(GObject *object, gpointer user_data) + GTK_STATUS_ICON(object), 1, activate_time); + } + +-static void popup_callback(GObject *object, guint button, +- guint activate_time, gpointer user_data) +-{ +- GtkMenu *menu = user_data; +- +- if (menu == NULL) +- return; +- +- gtk_menu_popup(menu, NULL, NULL, +- gtk_status_icon_position_menu, +- GTK_STATUS_ICON(object), button, activate_time); +-} +- + static GtkIconTheme *icontheme; + static IconAnimation *animation; + static GdkPixbuf *pixbuf_notifier; +@@ -190,7 +177,7 @@ static GdkPixbuf *pixbuf_none; + static GdkPixbuf *pixbuf_wired; + static GdkPixbuf *pixbuf_signal[5]; + +-int status_init(StatusCallback activate, GtkWidget *popup) ++int status_init(StatusCallback activate) + { + GdkScreen *screen; + +@@ -219,9 +206,6 @@ int status_init(StatusCallback activate, GtkWidget *popup) + g_signal_connect(statusicon, "activate", + G_CALLBACK(activate_callback), activate); + +- g_signal_connect(statusicon, "popup-menu", +- G_CALLBACK(popup_callback), popup); +- + return 0; + } + +@@ -292,8 +276,6 @@ void status_config(void) + + static void set_ready(gint signal) + { +- int index; +- + available = TRUE; + + if (signal < 0) { +@@ -302,12 +284,7 @@ static void set_ready(gint signal) + return; + } + +- if (signal == 0) +- index = 0; +- else +- index = 3; +- +- gtk_status_icon_set_from_pixbuf(statusicon, pixbuf_signal[index]); ++ gtk_status_icon_set_from_pixbuf(statusicon, pixbuf_signal[4]); + gtk_status_icon_set_tooltip(statusicon, NULL); + } + +diff --git a/applet/status.h b/applet/status.h +index 772a7b2..8a3c83c 100644 +--- a/applet/status.h ++++ b/applet/status.h +@@ -21,7 +21,7 @@ + + typedef gboolean (* StatusCallback) (GtkMenu *menu); + +-int status_init(StatusCallback activate, GtkWidget *popup); ++int status_init(StatusCallback activate); + void status_cleanup(void); + + void status_unavailable(void); +diff --git a/common/Makefile.am b/common/Makefile.am +index ff3a996..8d74a46 100644 +--- a/common/Makefile.am ++++ b/common/Makefile.am +@@ -5,13 +5,6 @@ libcommon_a_SOURCES = connman-dbus.c connman-dbus.h \ + connman-client.h connman-client.c \ + instance.h instance.c + +-noinst_PROGRAMS = connman-demo test-client +- +-connman_demo_SOURCES = demo.c +-connman_demo_LDADD = libcommon.a @GTK_LIBS@ @DBUS_LIBS@ +- +-test_client_LDADD = libcommon.a @GTK_LIBS@ @DBUS_LIBS@ +- + BUILT_SOURCES = marshal.h marshal.c \ + connman-dbus-glue.h \ + instance-glue.h +diff --git a/common/connman-client.c b/common/connman-client.c +index aad0a22..96f9388 100644 +--- a/common/connman-client.c ++++ b/common/connman-client.c +@@ -98,10 +98,9 @@ static void connman_client_init(ConnmanClient *client) + + priv->store = gtk_tree_store_new(_CONNMAN_NUM_COLUMNS, G_TYPE_OBJECT, + G_TYPE_STRING, G_TYPE_STRING, G_TYPE_UINT, +- G_TYPE_BOOLEAN, G_TYPE_BOOLEAN, G_TYPE_BOOLEAN, +- G_TYPE_UINT, G_TYPE_UINT, G_TYPE_STRING, +- G_TYPE_STRING, G_TYPE_STRING, G_TYPE_UINT, +- G_TYPE_STRING); ++ G_TYPE_STRING, G_TYPE_UINT, G_TYPE_STRING, ++ G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING, ++ G_TYPE_STRING, G_TYPE_STRING); + + g_object_set_data(G_OBJECT(priv->store), + "State", g_strdup("unavailable")); +@@ -197,7 +196,7 @@ static gboolean device_filter(GtkTreeModel *model, + if (proxy == NULL) + return FALSE; + +- active = g_str_equal(CONNMAN_DEVICE_INTERFACE, ++ active = g_str_equal(CONNMAN_SERVICE_INTERFACE, + dbus_g_proxy_get_interface(proxy)); + + g_object_unref(proxy); +@@ -231,10 +230,10 @@ static gboolean device_network_filter(GtkTreeModel *model, + if (proxy == NULL) + return FALSE; + +- active = g_str_equal(CONNMAN_DEVICE_INTERFACE, ++ active = g_str_equal(CONNMAN_SERVICE_INTERFACE, + dbus_g_proxy_get_interface(proxy)); + if (active == FALSE) +- active = g_str_equal(CONNMAN_NETWORK_INTERFACE, ++ active = g_str_equal(CONNMAN_SERVICE_INTERFACE, + dbus_g_proxy_get_interface(proxy)); + + g_object_unref(proxy); +@@ -277,7 +276,7 @@ GtkTreeModel *connman_client_get_network_model(ConnmanClient *client, + gtk_tree_model_get(GTK_TREE_MODEL(priv->store), &iter, + CONNMAN_COLUMN_PROXY, &proxy, -1); + +- if (g_str_equal(CONNMAN_DEVICE_INTERFACE, ++ if (g_str_equal(CONNMAN_SERVICE_INTERFACE, + dbus_g_proxy_get_interface(proxy)) == TRUE) + found = g_str_has_prefix(dbus_g_proxy_get_path(proxy), + device); +@@ -314,7 +313,7 @@ static gboolean connection_filter(GtkTreeModel *model, + if (proxy == NULL) + return FALSE; + +- active = g_str_equal(CONNMAN_CONNECTION_INTERFACE, ++ active = g_str_equal(CONNMAN_SERVICE_INTERFACE, + dbus_g_proxy_get_interface(proxy)); + + g_object_unref(proxy); +@@ -337,12 +336,19 @@ GtkTreeModel *connman_client_get_connection_model(ConnmanClient *client) + return model; + } + +-void connman_client_set_policy(ConnmanClient *client, const gchar *device, +- const gchar *policy) ++void connman_client_set_ipv4(ConnmanClient *client, const gchar *device, ++ struct ipv4_config *ipv4_config) + { + ConnmanClientPrivate *priv = CONNMAN_CLIENT_GET_PRIVATE(client); + DBusGProxy *proxy; + GValue value = { 0 }; ++ gboolean ret; ++ GHashTable *ipv4 = g_hash_table_new(g_str_hash, g_str_equal); ++ ++ g_hash_table_insert(ipv4, "Method", (gpointer)ipv4_config->method); ++ g_hash_table_insert(ipv4, "Address", (gpointer)ipv4_config->address); ++ g_hash_table_insert(ipv4, "Netmask", (gpointer)ipv4_config->netmask); ++ g_hash_table_insert(ipv4, "Gateway", (gpointer)ipv4_config->gateway); + + DBG("client %p", client); + +@@ -353,10 +359,10 @@ void connman_client_set_policy(ConnmanClient *client, const gchar *device, + if (proxy == NULL) + return; + +- g_value_init(&value, G_TYPE_STRING); +- g_value_set_string(&value, policy); ++ g_value_init(&value, DBUS_TYPE_G_STRING_STRING_HASHTABLE); ++ g_value_set_boxed(&value, ipv4); + +- connman_set_property(proxy, "Policy", &value, NULL); ++ ret = connman_set_property(proxy, "IPv4.Configuration", &value, NULL); + + g_object_unref(proxy); + } +@@ -389,26 +395,22 @@ static gboolean device_scan(GtkTreeModel *model, GtkTreePath *path, + GtkTreeIter *iter, gpointer user_data) + { + DBusGProxy *proxy; +- gboolean enabled; + + gtk_tree_model_get(model, iter, CONNMAN_COLUMN_PROXY, &proxy, +- CONNMAN_COLUMN_ENABLED, &enabled, -1); ++ -1); + + if (proxy == NULL) + return FALSE; + + if (g_str_equal(dbus_g_proxy_get_interface(proxy), +- CONNMAN_DEVICE_INTERFACE) == FALSE) +- return FALSE; +- +- if (enabled == FALSE) ++ CONNMAN_SERVICE_INTERFACE) == FALSE) + return FALSE; + + connman_propose_scan(proxy, NULL); + + g_object_unref(proxy); + +- return FALSE; ++ return TRUE; + } + + void connman_client_propose_scan(ConnmanClient *client, const gchar *device) +@@ -437,46 +439,85 @@ static gboolean network_disconnect(GtkTreeModel *model, GtkTreePath *path, + GtkTreeIter *iter, gpointer user_data) + { + DBusGProxy *proxy; +- gboolean enabled; ++ gchar *name; ++ guint type; + + gtk_tree_model_get(model, iter, CONNMAN_COLUMN_PROXY, &proxy, +- CONNMAN_COLUMN_ENABLED, &enabled, -1); ++ CONNMAN_COLUMN_NAME, &name, ++ CONNMAN_COLUMN_TYPE, &type, ++ -1); + + if (proxy == NULL) +- return FALSE; ++ return TRUE; + + if (g_str_equal(dbus_g_proxy_get_interface(proxy), +- CONNMAN_NETWORK_INTERFACE) == FALSE) +- return FALSE; ++ CONNMAN_SERVICE_INTERFACE) == FALSE) ++ return TRUE; + +- if (enabled == TRUE) ++ if (type == CONNMAN_TYPE_WIFI) + connman_disconnect(proxy, NULL); + + g_object_unref(proxy); + +- return enabled; ++ return FALSE; + } + +-void connman_client_connect(ConnmanClient *client, const gchar *network) ++gboolean connman_client_connect(ConnmanClient *client, const gchar *network) + { + ConnmanClientPrivate *priv = CONNMAN_CLIENT_GET_PRIVATE(client); + DBusGProxy *proxy; ++ gboolean ret = FALSE; + + DBG("client %p", client); ++ DBG("network %s", network); + + if (network == NULL) +- return; ++ goto done; + + gtk_tree_model_foreach(GTK_TREE_MODEL(priv->store), + network_disconnect, NULL); + + proxy = connman_dbus_get_proxy(priv->store, network); + if (proxy == NULL) +- return; ++ goto done; + +- connman_connect(proxy, NULL); ++ ret = connman_connect(proxy, NULL); + + g_object_unref(proxy); ++ ++done: ++ return ret; ++} ++ ++void connman_client_connect_async(ConnmanClient *client, const gchar *network, ++ connman_connect_reply callback, gpointer userdata) ++{ ++ ConnmanClientPrivate *priv = CONNMAN_CLIENT_GET_PRIVATE(client); ++ DBusGProxy *proxy; ++ ++ DBG("client %p", client); ++ DBG("network %s", network); ++ ++ if (network == NULL) ++ goto done; ++ ++ gtk_tree_model_foreach(GTK_TREE_MODEL(priv->store), ++ network_disconnect, NULL); ++ ++ proxy = connman_dbus_get_proxy(priv->store, network); ++ if (proxy == NULL) ++ goto done; ++ ++ /* Set an unusually long timeout because the Connect ++ * method doesn't return until there has been either ++ * success or an error. ++ */ ++ dbus_g_proxy_set_default_timeout(proxy, 120000); ++ connman_connect_async(proxy, callback, userdata); ++ dbus_g_proxy_set_default_timeout(proxy, -1); ++ ++done: ++ return; + } + + static void connman_client_disconnect_all(ConnmanClient *client) +@@ -487,32 +528,37 @@ static void connman_client_disconnect_all(ConnmanClient *client) + network_disconnect, NULL); + } + +-void connman_client_disconnect(ConnmanClient *client, const gchar *network) ++gboolean connman_client_disconnect(ConnmanClient *client, const gchar *network) + { + ConnmanClientPrivate *priv = CONNMAN_CLIENT_GET_PRIVATE(client); + DBusGProxy *proxy; ++ gboolean ret = FALSE; + + DBG("client %p", client); + + if (network == NULL) { ++ ret = TRUE; + connman_client_disconnect_all(client); +- return; ++ goto done; + } + + proxy = connman_dbus_get_proxy(priv->store, network); + if (proxy == NULL) +- return; ++ goto done; + +- connman_disconnect(proxy, NULL); ++ ret = connman_disconnect(proxy, NULL); + + g_object_unref(proxy); ++ ++done: ++ return ret; + } + +-guint connman_client_get_security(ConnmanClient *client, const gchar *network) ++gchar *connman_client_get_security(ConnmanClient *client, const gchar *network) + { + ConnmanClientPrivate *priv = CONNMAN_CLIENT_GET_PRIVATE(client); + GtkTreeIter iter; +- guint security; ++ gchar *security; + + DBG("client %p", client); + +@@ -548,56 +594,37 @@ gchar *connman_client_get_passphrase(ConnmanClient *client, const gchar *network + return passphrase; + } + +-void connman_client_set_passphrase(ConnmanClient *client, const gchar *network, ++gboolean connman_client_set_passphrase(ConnmanClient *client, const gchar *network, + const gchar *passphrase) + { + ConnmanClientPrivate *priv = CONNMAN_CLIENT_GET_PRIVATE(client); + DBusGProxy *proxy; + GValue value = { 0 }; ++ gboolean ret = FALSE; + + DBG("client %p", client); ++ DBG("network %p", network); + + if (network == NULL) +- return; ++ goto done; + + proxy = connman_dbus_get_proxy(priv->store, network); + if (proxy == NULL) +- return; ++ goto done; + ++ DBG("passphrase %s", passphrase); + g_value_init(&value, G_TYPE_STRING); + g_value_set_string(&value, passphrase); + +- connman_set_property(proxy, "WiFi.Passphrase", &value, NULL); +- +- g_value_unset(&value); +- +- g_object_unref(proxy); +-} +- +-void connman_client_set_remember(ConnmanClient *client, const gchar *network, +- gboolean remember) +-{ +- ConnmanClientPrivate *priv = CONNMAN_CLIENT_GET_PRIVATE(client); +- DBusGProxy *proxy; +- GValue value = { 0 }; +- +- DBG("client %p", client); +- +- if (network == NULL) +- return; +- +- proxy = connman_dbus_get_proxy(priv->store, network); +- if (proxy == NULL) +- return; +- +- g_value_init(&value, G_TYPE_BOOLEAN); +- g_value_set_boolean(&value, remember); +- +- connman_set_property(proxy, "Remember", &value, NULL); ++ ret = connman_set_property(proxy, "Passphrase", &value, NULL); ++ DBG("passphrase setting succeeded? %d", ret); ++ DBG("false is ? %d", FALSE); + + g_value_unset(&value); + + g_object_unref(proxy); ++done: ++ return ret; + } + + void connman_client_set_callback(ConnmanClient *client, +diff --git a/common/connman-client.h b/common/connman-client.h +index f30dae4..f3ac1d3 100644 +--- a/common/connman-client.h ++++ b/common/connman-client.h +@@ -23,6 +23,7 @@ + #define __CONNMAN_CLIENT_H + + #include <gtk/gtk.h> ++#include "connman-dbus-glue.h" + + G_BEGIN_DECLS + +@@ -49,6 +50,13 @@ struct _ConnmanClientClass { + GObjectClass parent_class; + }; + ++struct ipv4_config { ++ const gchar *method; ++ const gchar *address; ++ const gchar *netmask; ++ const gchar *gateway; ++}; ++ + GType connman_client_get_type(void); + + ConnmanClient *connman_client_new(void); +@@ -60,18 +68,20 @@ GtkTreeModel *connman_client_get_network_model(ConnmanClient *client, + const gchar *device); + GtkTreeModel *connman_client_get_connection_model(ConnmanClient *client); + +-void connman_client_set_policy(ConnmanClient *client, const gchar *device, +- const gchar *policy); + void connman_client_set_powered(ConnmanClient *client, const gchar *device, + gboolean powered); + void connman_client_propose_scan(ConnmanClient *client, const gchar *device); + +-void connman_client_connect(ConnmanClient *client, const gchar *network); +-void connman_client_disconnect(ConnmanClient *client, const gchar *network); ++gboolean connman_client_connect(ConnmanClient *client, const gchar *network); ++ ++void connman_client_connect_async(ConnmanClient *client, const gchar *network, ++ connman_connect_reply callback, gpointer userdata); + +-guint connman_client_get_security(ConnmanClient *client, const gchar *network); ++gboolean connman_client_disconnect(ConnmanClient *client, const gchar *network); ++ ++gchar *connman_client_get_security(ConnmanClient *client, const gchar *network); + gchar *connman_client_get_passphrase(ConnmanClient *client, const gchar *network); +-void connman_client_set_passphrase(ConnmanClient *client, const gchar *network, ++gboolean connman_client_set_passphrase(ConnmanClient *client, const gchar *network, + const gchar *passphrase); + void connman_client_set_remember(ConnmanClient *client, const gchar *network, + gboolean remember); +@@ -81,22 +91,27 @@ typedef void (* ConnmanClientCallback) (const char *status, void *user_data); + void connman_client_set_callback(ConnmanClient *client, + ConnmanClientCallback callback, gpointer user_data); + ++void connman_client_set_ipv4(ConnmanClient *client, const gchar *device, ++ struct ipv4_config *ipv4_config); ++ ++gboolean connman_dbus_get_iter(GtkTreeStore *store, const gchar *path, ++ GtkTreeIter *iter); + enum { + CONNMAN_COLUMN_PROXY, /* G_TYPE_OBJECT */ ++ CONNMAN_COLUMN_STATE, /* G_TYPE_STRING */ + CONNMAN_COLUMN_NAME, /* G_TYPE_STRING */ +- CONNMAN_COLUMN_ICON, /* G_TYPE_STRING */ + CONNMAN_COLUMN_TYPE, /* G_TYPE_UINT */ +- CONNMAN_COLUMN_ENABLED, /* G_TYPE_BOOLEAN */ +- CONNMAN_COLUMN_INRANGE, /* G_TYPE_BOOLEAN */ +- CONNMAN_COLUMN_REMEMBER, /* G_TYPE_BOOLEAN */ ++ CONNMAN_COLUMN_ICON, /* G_TYPE_STRING */ + CONNMAN_COLUMN_STRENGTH, /* G_TYPE_UINT */ +- CONNMAN_COLUMN_SECURITY, /* G_TYPE_UINT */ ++ CONNMAN_COLUMN_SECURITY, /* G_TYPE_STRING */ + CONNMAN_COLUMN_PASSPHRASE, /* G_TYPE_STRING */ +- CONNMAN_COLUMN_NETWORK, +- CONNMAN_COLUMN_ADDRESS, +- CONNMAN_COLUMN_POLICY, +- CONNMAN_COLUMN_DEVICE, +- _CONNMAN_NUM_COLUMNS ++ ++ CONNMAN_COLUMN_METHOD, /* G_TYPE_STRING */ ++ CONNMAN_COLUMN_ADDRESS, /* G_TYPE_STRING */ ++ CONNMAN_COLUMN_NETMASK, /* G_TYPE_STRING */ ++ CONNMAN_COLUMN_GATEWAY, /* G_TYPE_STRING */ ++ _CONNMAN_NUM_COLUMNS, ++ + }; + + enum { +@@ -108,10 +123,7 @@ enum { + }; + + enum { +- CONNMAN_POLICY_UNKNOWN, +- CONNMAN_POLICY_IGNORE, +- CONNMAN_POLICY_OFF, +- CONNMAN_POLICY_AUTO, ++ CONNMAN_POLICY_DHCP, + CONNMAN_POLICY_MANUAL, + }; + +diff --git a/common/connman-dbus.c b/common/connman-dbus.c +index 9eba7ae..83f4e57 100644 +--- a/common/connman-dbus.c ++++ b/common/connman-dbus.c +@@ -159,20 +159,22 @@ static gint compare_path(gconstpointer a, gconstpointer b) + return g_strcmp0(a, b); + } + ++static gint compare_list(gchar *path_a, gchar *path_b, gpointer user_data) ++{ ++ return g_strcmp0(path_a, path_b); ++} ++ ++ + static void property_update(GtkTreeStore *store, const GValue *value, + const char *key, connman_get_properties_reply callback) + { +- GSList *list, *link, *old_list, *new_list = NULL; ++ GSList *list, *link, *old_list, *new_list = NULL, *sorted_list = NULL; + const char *iface; + + DBG("store %p key %s", store, key); + +- if (g_str_equal(key, "Connections") == TRUE) +- iface = CONNMAN_CONNECTION_INTERFACE; +- else if (g_str_equal(key, "Devices") == TRUE) +- iface = CONNMAN_DEVICE_INTERFACE; +- else +- iface = CONNMAN_NETWORK_INTERFACE; ++ if (g_str_equal(key, "Services") == TRUE) ++ iface = CONNMAN_SERVICE_INTERFACE; + + old_list = g_object_get_data(G_OBJECT(store), key); + +@@ -180,7 +182,11 @@ static void property_update(GtkTreeStore *store, const GValue *value, + + g_object_set_data(G_OBJECT(store), key, new_list); + +- for (list = new_list; list; list = list->next) { ++ sorted_list = g_slist_sort_with_data(new_list, ++ (GCompareDataFunc)compare_list, store); ++ g_object_set_data(G_OBJECT(store), "Services", sorted_list); ++ ++ for (list = sorted_list; list; list = list->next) { + gchar *path = list->data; + DBusGProxy *proxy; + +@@ -205,25 +211,12 @@ static void property_update(GtkTreeStore *store, const GValue *value, + for (list = old_list; list; list = list->next) { + gchar *path = list->data; + GtkTreeIter iter; +- gchar *device = NULL; + + DBG("old path %s", path); + +- if (get_iter_from_path(store, &iter, path) == TRUE) { +- if (g_str_equal(key, "Connections") == TRUE) +- gtk_tree_model_get(GTK_TREE_MODEL(store), &iter, +- CONNMAN_COLUMN_DEVICE, &device, -1); +- ++ if (get_iter_from_path(store, &iter, path) == TRUE) + gtk_tree_store_remove(store, &iter); +- } + +- if (get_iter_from_path(store, &iter, device) == TRUE) { +- gtk_tree_store_set(store, &iter, +- CONNMAN_COLUMN_INRANGE, FALSE, +- CONNMAN_COLUMN_ADDRESS, NULL, -1); +- } +- +- g_free(device); + g_free(path); + } + +@@ -263,48 +256,19 @@ static const gchar *type2icon(guint type) + return NULL; + } + +-static guint get_policy(const GValue *value) +-{ +- const char *policy = value ? g_value_get_string(value) : NULL; +- +- if (policy == NULL) +- return CONNMAN_POLICY_UNKNOWN; +- else if (g_str_equal(policy, "ignore") == TRUE) +- return CONNMAN_POLICY_IGNORE; +- else if (g_str_equal(policy, "off") == TRUE) +- return CONNMAN_POLICY_OFF; +- else if (g_str_equal(policy, "auto") == TRUE) +- return CONNMAN_POLICY_AUTO; +- else if (g_str_equal(policy, "manual") == TRUE) +- return CONNMAN_POLICY_MANUAL; +- +- return CONNMAN_POLICY_UNKNOWN; +-} +- +-static guint get_security(const GValue *value) +-{ +- const char *security = value ? g_value_get_string(value) : NULL; +- +- if (security == NULL) +- return CONNMAN_SECURITY_UNKNOWN; +- else if (g_str_equal(security, "none") == TRUE) +- return CONNMAN_SECURITY_NONE; +- else if (g_str_equal(security, "wep") == TRUE) +- return CONNMAN_SECURITY_WEP; +- else if (g_str_equal(security, "wpa") == TRUE) +- return CONNMAN_SECURITY_WPA; +- else if (g_str_equal(security, "wpa2") == TRUE) +- return CONNMAN_SECURITY_WPA2; +- +- return CONNMAN_SECURITY_UNKNOWN; +-} +- +-static void network_changed(DBusGProxy *proxy, const char *property, ++static void service_changed(DBusGProxy *proxy, const char *property, + GValue *value, gpointer user_data) + { + GtkTreeStore *store = user_data; + const char *path = dbus_g_proxy_get_path(proxy); + GtkTreeIter iter; ++ GHashTable *ipv4; ++ const gchar *method, *addr, *netmask, *gateway; ++ GValue *ipv4_method, *ipv4_address, *ipv4_netmask, *ipv4_gateway; ++ ++ const gchar *state, *icon, *name, *security, *passphrase; ++ guint strength, type; ++ + + DBG("store %p proxy %p property %s", store, proxy, property); + +@@ -314,141 +278,92 @@ static void network_changed(DBusGProxy *proxy, const char *property, + if (get_iter_from_path(store, &iter, path) == FALSE) + return; + +- if (g_str_equal(property, "Connected") == TRUE) { +- gboolean connected = g_value_get_boolean(value); +- gtk_tree_store_set(store, &iter, +- CONNMAN_COLUMN_ENABLED, connected, -1); +- } else if (g_str_equal(property, "Available") == TRUE) { +- gboolean inrange = g_value_get_boolean(value); +- gtk_tree_store_set(store, &iter, +- CONNMAN_COLUMN_INRANGE, inrange, -1); +- } else if (g_str_equal(property, "Remember") == TRUE) { +- gboolean remember = g_value_get_boolean(value); +- gtk_tree_store_set(store, &iter, +- CONNMAN_COLUMN_REMEMBER, remember, -1); +- } else if (g_str_equal(property, "Strength") == TRUE) { +- guint strength = g_value_get_uchar(value); +- gtk_tree_store_set(store, &iter, +- CONNMAN_COLUMN_STRENGTH, strength, -1); +- } +-} +- +-static void network_properties(DBusGProxy *proxy, GHashTable *hash, +- GError *error, gpointer user_data) +-{ +- GtkTreeStore *store = user_data; +- GValue *value; +- const gchar *device, *name, *secret; +- gboolean connected, inrange, remember; +- guint strength, security; +- GtkTreeIter iter, parent; +- +- DBG("store %p proxy %p hash %p", store, proxy, hash); +- +- if (error != NULL || hash == NULL) +- goto done; +- +- value = g_hash_table_lookup(hash, "Device"); +- device = value ? g_value_get_boxed(value) : NULL; ++ if (g_str_equal(property, "IPv4") == TRUE) { + +- value = g_hash_table_lookup(hash, "Name"); +- name = value ? g_value_get_string(value) : NULL; +- +- value = g_hash_table_lookup(hash, "Connected"); +- connected = value ? g_value_get_boolean(value) : FALSE; ++ ipv4 = g_value_get_boxed (value); ++ if (!ipv4) ++ return; + +- value = g_hash_table_lookup(hash, "Available"); +- inrange = value ? g_value_get_boolean(value) : FALSE; ++ ipv4_method = g_hash_table_lookup (ipv4, "Method"); ++ method = ipv4_method ? g_value_get_string(ipv4_method) : NULL; + +- value = g_hash_table_lookup(hash, "Remember"); +- remember = value ? g_value_get_boolean(value) : FALSE; ++ ipv4_address = g_hash_table_lookup (ipv4, "Address"); ++ addr = ipv4_address ? g_value_get_string(ipv4_address) : NULL; + +- value = g_hash_table_lookup(hash, "Strength"); +- strength = value ? g_value_get_uchar(value) : 0; ++ ipv4_netmask = g_hash_table_lookup (ipv4, "Netmask"); ++ netmask = ipv4_netmask ? g_value_get_string(ipv4_netmask) : NULL; + +- value = g_hash_table_lookup(hash, "WiFi.Security"); +- security = get_security(value); ++ ipv4_gateway = g_hash_table_lookup (ipv4, "Gateway"); ++ gateway = ipv4_gateway ? g_value_get_string(ipv4_gateway) : NULL; + +- value = g_hash_table_lookup(hash, "WiFi.Passphrase"); +- secret = value ? g_value_get_string(value) : NULL; +- +- DBG("name %s strength %d", name, strength); +- +- if (get_iter_from_path(store, &parent, device) == FALSE) +- return; +- +- if (get_iter_from_proxy(store, &iter, proxy) == FALSE) { +- gtk_tree_store_insert_with_values(store, &iter, &parent, -1, +- CONNMAN_COLUMN_PROXY, proxy, ++ gtk_tree_store_set(store, &iter, ++ CONNMAN_COLUMN_METHOD, method, ++ CONNMAN_COLUMN_ADDRESS, addr, ++ CONNMAN_COLUMN_NETMASK, netmask, ++ CONNMAN_COLUMN_GATEWAY, gateway, ++ -1); ++ ++ } else if (g_str_equal(property, "State") == TRUE) { ++ state = value ? g_value_get_string(value) : NULL; ++ gtk_tree_store_set(store, &iter, ++ CONNMAN_COLUMN_STATE, state, ++ -1); ++ } else if (g_str_equal(property, "Name") == TRUE) { ++ name = value ? g_value_get_string(value) : NULL; ++ gtk_tree_store_set(store, &iter, + CONNMAN_COLUMN_NAME, name, +- CONNMAN_COLUMN_ENABLED, connected, +- CONNMAN_COLUMN_INRANGE, inrange, +- CONNMAN_COLUMN_REMEMBER, remember, +- CONNMAN_COLUMN_STRENGTH, strength, ++ -1); ++ } else if (g_str_equal(property, "Type") == TRUE) { ++ type = get_type(value); ++ icon = type2icon(type); ++ gtk_tree_store_set(store, &iter, ++ CONNMAN_COLUMN_TYPE, type, ++ CONNMAN_COLUMN_ICON, icon, ++ -1); ++ } else if (g_str_equal(property, "Security") == TRUE) { ++ security = value ? g_value_get_string(value) : NULL; ++ gtk_tree_store_set(store, &iter, + CONNMAN_COLUMN_SECURITY, security, +- CONNMAN_COLUMN_PASSPHRASE, secret, -1); +- +- dbus_g_proxy_add_signal(proxy, "PropertyChanged", +- G_TYPE_STRING, G_TYPE_VALUE, G_TYPE_INVALID); +- dbus_g_proxy_connect_signal(proxy, "PropertyChanged", +- G_CALLBACK(network_changed), store, NULL); +- } else ++ -1); ++ } else if (g_str_equal(property, "PassPhrase") == TRUE) { ++ passphrase = value ? g_value_get_string(value) : NULL; ++ gtk_tree_store_set(store, &iter, ++ CONNMAN_COLUMN_PASSPHRASE, passphrase, ++ -1); ++ } else if (g_str_equal(property, "Strength") == TRUE) { ++ strength = value ? g_value_get_uchar(value) : 0; + gtk_tree_store_set(store, &iter, +- CONNMAN_COLUMN_NAME, name, +- CONNMAN_COLUMN_ENABLED, connected, +- CONNMAN_COLUMN_INRANGE, inrange, +- CONNMAN_COLUMN_REMEMBER, remember, + CONNMAN_COLUMN_STRENGTH, strength, +- CONNMAN_COLUMN_SECURITY, security, +- CONNMAN_COLUMN_PASSPHRASE, secret, -1); +- +-done: +- g_object_unref(proxy); ++ -1); ++ } + } + +-static void device_changed(DBusGProxy *proxy, const char *property, +- GValue *value, gpointer user_data) ++static void service_properties(DBusGProxy *proxy, GHashTable *hash, ++ GError *error, gpointer user_data) + { + GtkTreeStore *store = user_data; + const char *path = dbus_g_proxy_get_path(proxy); +- GtkTreeIter iter; + +- DBG("store %p proxy %p property %s", store, proxy, property); ++ const gchar *state, *icon, *name, *security, *passphrase; ++ guint strength, type; + +- if (property == NULL || value == NULL) +- return; +- +- if (get_iter_from_path(store, &iter, path) == FALSE) +- return; ++ GHashTable *ipv4; ++ GValue *ipv4_method, *ipv4_address, *ipv4_netmask, *ipv4_gateway; ++ const gchar *method, *addr, *netmask, *gateway; + +- if (g_str_equal(property, "Policy") == TRUE) { +- guint policy = get_policy(value); +- gtk_tree_store_set(store, &iter, +- CONNMAN_COLUMN_POLICY, policy, -1); +- } else if (g_str_equal(property, "Powered") == TRUE) { +- gboolean powered = g_value_get_boolean(value); +- gtk_tree_store_set(store, &iter, +- CONNMAN_COLUMN_ENABLED, powered, -1); +- } else if (g_str_equal(property, "Networks") == TRUE) +- property_update(store, value, path, network_properties); +-} ++ GtkTreeIter iter; + +-static void device_properties(DBusGProxy *proxy, GHashTable *hash, +- GError *error, gpointer user_data) +-{ +- GtkTreeStore *store = user_data; +- const char *path = dbus_g_proxy_get_path(proxy); + GValue *value; +- const gchar *name, *icon; +- guint type, policy; +- gboolean powered; +- GtkTreeIter iter; + + DBG("store %p proxy %p hash %p", store, proxy, hash); ++ DBG("path %s", path); + + if (error != NULL || hash == NULL) + goto done; + ++ value = g_hash_table_lookup(hash, "State"); ++ state = value ? g_value_get_string(value) : NULL; ++ + value = g_hash_table_lookup(hash, "Name"); + name = value ? g_value_get_string(value) : NULL; + +@@ -456,129 +371,69 @@ static void device_properties(DBusGProxy *proxy, GHashTable *hash, + type = get_type(value); + icon = type2icon(type); + +- value = g_hash_table_lookup(hash, "Policy"); +- policy = get_policy(value); +- +- value = g_hash_table_lookup(hash, "Powered"); +- powered = value ? g_value_get_boolean(value) : FALSE; +- +- DBG("name %s type %d icon %s", name, type, icon); ++ value = g_hash_table_lookup(hash, "Security"); ++ security = value ? g_value_get_string(value) : NULL; + +- if (get_iter_from_proxy(store, &iter, proxy) == FALSE) { +- gtk_tree_store_insert_with_values(store, &iter, NULL, -1, +- CONNMAN_COLUMN_PROXY, proxy, +- CONNMAN_COLUMN_NAME, name, +- CONNMAN_COLUMN_ICON, icon, +- CONNMAN_COLUMN_TYPE, type, +- CONNMAN_COLUMN_ENABLED, powered, +- CONNMAN_COLUMN_POLICY, policy, -1); +- +- dbus_g_proxy_add_signal(proxy, "PropertyChanged", +- G_TYPE_STRING, G_TYPE_VALUE, G_TYPE_INVALID); +- dbus_g_proxy_connect_signal(proxy, "PropertyChanged", +- G_CALLBACK(device_changed), store, NULL); +- } else +- gtk_tree_store_set(store, &iter, +- CONNMAN_COLUMN_NAME, name, +- CONNMAN_COLUMN_ICON, icon, +- CONNMAN_COLUMN_TYPE, type, +- CONNMAN_COLUMN_ENABLED, powered, +- CONNMAN_COLUMN_POLICY, policy, -1); +- +- value = g_hash_table_lookup(hash, "Networks"); +- if (value != NULL) +- property_update(store, value, path, network_properties); +- +-done: +- g_object_unref(proxy); +-} +- +-static void connection_changed(DBusGProxy *proxy, const char *property, +- GValue *value, gpointer user_data) +-{ +- GtkTreeStore *store = user_data; +- const char *path = dbus_g_proxy_get_path(proxy); +- GtkTreeIter iter; +- +- DBG("store %p proxy %p property %s", store, proxy, property); +- +- if (property == NULL || value == NULL) +- return; ++ value = g_hash_table_lookup(hash, "PassPhrase"); ++ passphrase = value ? g_value_get_string(value) : NULL; + +- if (get_iter_from_path(store, &iter, path) == FALSE) +- return; +- +- if (g_str_equal(property, "Default") == TRUE) { +- gboolean enabled = g_value_get_boolean(value); +- gtk_tree_store_set(store, &iter, +- CONNMAN_COLUMN_ENABLED, enabled, -1); +- } else if (g_str_equal(property, "Strength") == TRUE) { +- guint strength = g_value_get_uchar(value); +- gtk_tree_store_set(store, &iter, +- CONNMAN_COLUMN_STRENGTH, strength, -1); +- } +-} +- +-static void connection_properties(DBusGProxy *proxy, GHashTable *hash, +- GError *error, gpointer user_data) +-{ +- GtkTreeStore *store = user_data; +- GValue *value; +- guint type, strength; +- gboolean enabled; +- const char *device, *address; +- GtkTreeIter iter; ++ value = g_hash_table_lookup(hash, "Strength"); ++ strength = value ? g_value_get_uchar(value) : 0; + +- DBG("store %p proxy %p hash %p", store, proxy, hash); ++ value = g_hash_table_lookup(hash, "IPv4.Configuration"); ++ ipv4 = g_value_get_boxed (value); + +- if (error != NULL || hash == NULL) ++ if (!ipv4) + goto done; + +- value = g_hash_table_lookup(hash, "Type"); +- type = get_type(value); ++ ipv4_method = g_hash_table_lookup (ipv4, "Method"); ++ method = ipv4_method ? g_value_get_string(ipv4_method) : NULL; + +- value = g_hash_table_lookup(hash, "Strength"); +- strength = value ? g_value_get_uchar(value) : 0; ++ ipv4_address = g_hash_table_lookup (ipv4, "Address"); ++ addr = ipv4_address ? g_value_get_string(ipv4_address) : NULL; + +- value = g_hash_table_lookup(hash, "Default"); +- enabled = value ? g_value_get_boolean(value) : FALSE; ++ ipv4_netmask = g_hash_table_lookup (ipv4, "Netmask"); ++ netmask = ipv4_netmask ? g_value_get_string(ipv4_netmask) : NULL; + +- value = g_hash_table_lookup(hash, "IPv4.Address"); +- address = value ? g_value_get_string(value) : NULL; ++ ipv4_gateway = g_hash_table_lookup (ipv4, "Gateway"); ++ gateway = ipv4_gateway ? g_value_get_string(ipv4_gateway) : NULL; + +- DBG("type %d address %s", type, address); ++ DBG("name %s type %d icon %s state %s", name, type, icon, state); + + if (get_iter_from_proxy(store, &iter, proxy) == FALSE) { + gtk_tree_store_insert_with_values(store, &iter, NULL, -1, + CONNMAN_COLUMN_PROXY, proxy, ++ CONNMAN_COLUMN_NAME, name, ++ CONNMAN_COLUMN_ICON, icon, + CONNMAN_COLUMN_TYPE, type, +- CONNMAN_COLUMN_ENABLED, enabled, ++ CONNMAN_COLUMN_STATE, state, ++ CONNMAN_COLUMN_SECURITY, security, ++ CONNMAN_COLUMN_PASSPHRASE, passphrase, + CONNMAN_COLUMN_STRENGTH, strength, +- CONNMAN_COLUMN_ADDRESS, address, -1); ++ CONNMAN_COLUMN_METHOD, method, ++ CONNMAN_COLUMN_ADDRESS, addr, ++ CONNMAN_COLUMN_NETMASK, netmask, ++ CONNMAN_COLUMN_GATEWAY, gateway, ++ -1); + + dbus_g_proxy_add_signal(proxy, "PropertyChanged", + G_TYPE_STRING, G_TYPE_VALUE, G_TYPE_INVALID); + dbus_g_proxy_connect_signal(proxy, "PropertyChanged", +- G_CALLBACK(connection_changed), store, NULL); ++ G_CALLBACK(service_changed), store, NULL); + } else + gtk_tree_store_set(store, &iter, ++ CONNMAN_COLUMN_NAME, name, ++ CONNMAN_COLUMN_ICON, icon, + CONNMAN_COLUMN_TYPE, type, +- CONNMAN_COLUMN_ENABLED, enabled, +- CONNMAN_COLUMN_STRENGTH, strength, -1); +- +- value = g_hash_table_lookup(hash, "Device"); +- device = value ? g_value_get_boxed(value) : NULL; +- +- DBG("device %s", device); +- +- gtk_tree_store_set(store, &iter, CONNMAN_COLUMN_DEVICE, device, -1); +- +- if (get_iter_from_path(store, &iter, device) == TRUE) { +- gtk_tree_store_set(store, &iter, +- CONNMAN_COLUMN_DEVICE, device, +- CONNMAN_COLUMN_INRANGE, TRUE, +- CONNMAN_COLUMN_ADDRESS, address, -1); +- } ++ CONNMAN_COLUMN_STATE, state, ++ CONNMAN_COLUMN_SECURITY, security, ++ CONNMAN_COLUMN_PASSPHRASE, passphrase, ++ CONNMAN_COLUMN_STRENGTH, strength, ++ CONNMAN_COLUMN_METHOD, method, ++ CONNMAN_COLUMN_ADDRESS, addr, ++ CONNMAN_COLUMN_NETMASK, netmask, ++ CONNMAN_COLUMN_GATEWAY, gateway, ++ -1); + + done: + g_object_unref(proxy); +@@ -594,25 +449,8 @@ static void manager_changed(DBusGProxy *proxy, const char *property, + if (property == NULL || value == NULL) + return; + +- if (g_str_equal(property, "State") == TRUE) { +- ConnmanClientCallback callback; +- gpointer userdata; +- gchar *state; +- +- state = g_object_get_data(G_OBJECT(store), "State"); +- g_free(state); +- +- state = g_value_dup_string(value); +- g_object_set_data(G_OBJECT(store), "State", state); +- +- callback = g_object_get_data(G_OBJECT(store), "callback"); +- userdata = g_object_get_data(G_OBJECT(store), "userdata"); +- if (callback) +- callback(state, userdata); +- } else if (g_str_equal(property, "Connections") == TRUE) { +- property_update(store, value, property, connection_properties); +- } else if (g_str_equal(property, "Devices") == TRUE) { +- property_update(store, value, property, device_properties); ++ if (g_str_equal(property, "Services") == TRUE) { ++ property_update(store, value, property, service_properties); + } + } + +@@ -620,31 +458,16 @@ static void manager_properties(DBusGProxy *proxy, GHashTable *hash, + GError *error, gpointer user_data) + { + GtkTreeStore *store = user_data; +- ConnmanClientCallback callback; + GValue *value; +- gchar *state; + + DBG("store %p proxy %p hash %p", store, proxy, hash); + + if (error != NULL || hash == NULL) + return; + +- value = g_hash_table_lookup(hash, "State"); +- state = value ? g_value_dup_string(value) : NULL; +- g_object_set_data(G_OBJECT(store), "State", state); +- +- callback = g_object_get_data(G_OBJECT(store), "callback"); +- if (callback) +- callback(state, NULL); +- +- value = g_hash_table_lookup(hash, "Devices"); +- if (value != NULL) +- property_update(store, value, "Devices", device_properties); +- +- value = g_hash_table_lookup(hash, "Connections"); ++ value = g_hash_table_lookup(hash, "Services"); + if (value != NULL) +- property_update(store, value, +- "Connections", connection_properties); ++ property_update(store, value, "Services", service_properties); + } + + DBusGProxy *connman_dbus_create_manager(DBusGConnection *conn, +diff --git a/common/connman-dbus.h b/common/connman-dbus.h +index a9fa51c..47179da 100644 +--- a/common/connman-dbus.h ++++ b/common/connman-dbus.h +@@ -30,10 +30,10 @@ + #define CONNMAN_MANAGER_INTERFACE CONNMAN_SERVICE ".Manager" + #define CONNMAN_MANAGER_PATH "/" + +-#define CONNMAN_PROFILE_INTERFACE CONNMAN_SERVICE ".Profile" +-#define CONNMAN_DEVICE_INTERFACE CONNMAN_SERVICE ".Device" +-#define CONNMAN_NETWORK_INTERFACE CONNMAN_SERVICE ".Network" +-#define CONNMAN_CONNECTION_INTERFACE CONNMAN_SERVICE ".Connection" ++//#define CONNMAN_PROFILE_INTERFACE CONNMAN_SERVICE ".Profile" ++#define CONNMAN_SERVICE_INTERFACE CONNMAN_SERVICE ".Service" ++//#define CONNMAN_NETWORK_INTERFACE CONNMAN_SERVICE ".Network" ++//#define CONNMAN_CONNECTION_INTERFACE CONNMAN_SERVICE ".Connection" + + DBusGProxy *connman_dbus_create_manager(DBusGConnection *connection, + GtkTreeStore *store); +diff --git a/common/demo.c b/common/demo.c +deleted file mode 100644 +index 5e3924f..0000000 +--- a/common/demo.c ++++ /dev/null +@@ -1,465 +0,0 @@ +-/* +- * +- * Connection Manager +- * +- * Copyright (C) 2008 Intel Corporation. All rights reserved. +- * +- * This program is free software; you can redistribute it and/or modify +- * it under the terms of the GNU General Public License version 2 as +- * published by the Free Software Foundation. +- * +- * This program is distributed in the hope that it will be useful, +- * but WITHOUT ANY WARRANTY; without even the implied warranty of +- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +- * GNU General Public License for more details. +- * +- * You should have received a copy of the GNU General Public License +- * along with this program; if not, write to the Free Software +- * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA +- * +- */ +- +-#ifdef HAVE_CONFIG_H +-#include <config.h> +-#endif +- +-#include <dbus/dbus-glib.h> +-#include <gtk/gtk.h> +- +-#include "connman-client.h" +- +-static gboolean option_fullscreen = FALSE; +-static ConnmanClient *client; +- +-static GtkWidget *tree_networks = NULL; +-static GtkWidget *button_enabled = NULL; +-static GtkWidget *button_refresh = NULL; +-static GtkWidget *button_connect = NULL; +-static GtkWidget *label_status = NULL; +-static GtkTreeSelection *selection = NULL; +- +-static void status_callback(const char *status, void *user_data) +-{ +- gchar *markup; +- +- if (label_status == NULL) +- return; +- +- markup = g_strdup_printf("System is %s", status); +- gtk_label_set_markup(GTK_LABEL(label_status), markup); +- g_free(markup); +-} +- +-static GtkWidget *create_label(const gchar *str) +-{ +- GtkWidget *label; +- gchar *tmp; +- +- label = gtk_label_new(NULL); +- gtk_label_set_justify(GTK_LABEL(label), GTK_JUSTIFY_LEFT); +- gtk_misc_set_alignment(GTK_MISC(label), 0.0, 0.0); +- +- tmp = g_strdup_printf("<b>%s</b>", str); +- gtk_label_set_markup(GTK_LABEL(label), tmp); +- g_free(tmp); +- +- return label; +-} +- +-static void changed_callback(GtkComboBox *combo, gpointer user_data) +-{ +- GtkTreeModel *model = gtk_combo_box_get_model(combo); +- GtkTreeIter iter; +- DBusGProxy *proxy; +- gchar *path; +- gboolean enabled; +- +- if (gtk_combo_box_get_active_iter(combo, &iter) == FALSE) +- return; +- +- path = g_object_get_data(G_OBJECT(button_enabled), "device"); +- g_free(path); +- +- gtk_tree_model_get(model, &iter, CONNMAN_COLUMN_PROXY, &proxy, +- CONNMAN_COLUMN_ENABLED, &enabled, -1); +- +- path = g_strdup(dbus_g_proxy_get_path(proxy)); +- g_object_set_data(G_OBJECT(button_enabled), "device", path); +- +- g_object_unref(proxy); +- +- gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(button_enabled), +- enabled); +- +- gtk_widget_set_sensitive(button_refresh, enabled); +- +- model = connman_client_get_network_model(client, path); +- gtk_tree_view_set_model(GTK_TREE_VIEW(tree_networks), model); +- g_object_unref(model); +-} +- +-static void toggled_callback(GtkToggleButton *button, gpointer user_data) +-{ +- gchar *path; +- gboolean active; +- +- path = g_object_get_data(G_OBJECT(button), "device"); +- if (path == NULL) +- return; +- +- active = gtk_toggle_button_get_active(button); +- +- connman_client_set_powered(client, path, active); +- +- gtk_widget_set_sensitive(button_refresh, active); +-} +- +-static void refresh_callback(GtkButton *button, gpointer user_data) +-{ +- gchar *path; +- +- path = g_object_get_data(G_OBJECT(button_enabled), "device"); +- if (path == NULL) +- return; +- +- connman_client_propose_scan(client, path); +-} +- +-static void connect_callback(GtkButton *button, gpointer user_data) +-{ +- GtkTreeModel *model; +- GtkTreeIter iter; +- DBusGProxy *proxy; +- const gchar *path; +- gboolean enabled; +- +- if (gtk_tree_selection_get_selected(selection, &model, &iter) == FALSE) +- return; +- +- gtk_tree_model_get(model, &iter, CONNMAN_COLUMN_PROXY, &proxy, +- CONNMAN_COLUMN_ENABLED, &enabled, -1); +- +- path = dbus_g_proxy_get_path(proxy); +- +- if (enabled == FALSE) +- connman_client_connect(client, path); +- else +- connman_client_disconnect(client, path); +- +- g_object_unref(proxy); +- +- if (enabled == FALSE) +- g_object_set(button_connect, +- "label", GTK_STOCK_DISCONNECT, NULL); +- else +- g_object_set(button_connect, +- "label", GTK_STOCK_CONNECT, NULL); +-} +- +-static GtkWidget *create_left(void) +-{ +- GtkWidget *mainbox; +- GtkWidget *vbox; +- GtkWidget *hbox; +- GtkWidget *label; +- GtkWidget *combo; +- GtkWidget *button; +- GtkTreeModel *model; +- GtkCellRenderer *renderer; +- +- mainbox = gtk_vbox_new(FALSE, 24); +- gtk_container_set_border_width(GTK_CONTAINER(mainbox), 8); +- +- vbox = gtk_vbox_new(FALSE, 6); +- gtk_box_pack_start(GTK_BOX(mainbox), vbox, FALSE, FALSE, 0); +- +- label = create_label("Device"); +- gtk_box_pack_start(GTK_BOX(vbox), label, FALSE, FALSE, 0); +- +- combo = gtk_combo_box_new(); +- gtk_box_pack_start(GTK_BOX(vbox), combo, FALSE, FALSE, 0); +- g_signal_connect(G_OBJECT(combo), "changed", +- G_CALLBACK(changed_callback), NULL); +- +- gtk_cell_layout_clear(GTK_CELL_LAYOUT(combo)); +- +- renderer = gtk_cell_renderer_text_new(); +- gtk_cell_layout_pack_start(GTK_CELL_LAYOUT(combo), renderer, TRUE); +- gtk_cell_layout_set_attributes(GTK_CELL_LAYOUT(combo), renderer, +- "text", CONNMAN_COLUMN_NAME, NULL); +- +- button = gtk_check_button_new_with_label("Enabled"); +- gtk_box_pack_end(GTK_BOX(vbox), button, FALSE, FALSE, 0); +- g_signal_connect(G_OBJECT(button), "toggled", +- G_CALLBACK(toggled_callback), NULL); +- +- button_enabled = button; +- +- vbox = gtk_vbox_new(FALSE, 6); +- gtk_box_pack_start(GTK_BOX(mainbox), vbox, TRUE, TRUE, 0); +- +- label = create_label("Status"); +- gtk_box_pack_start(GTK_BOX(vbox), label, FALSE, FALSE, 0); +- +- label = gtk_label_new(NULL); +- gtk_label_set_justify(GTK_LABEL(label), GTK_JUSTIFY_LEFT); +- gtk_misc_set_alignment(GTK_MISC(label), 0.0, 0.0); +- gtk_box_pack_start(GTK_BOX(vbox), label, TRUE, TRUE, 0); +- +- label_status = label; +- +- vbox = gtk_vbox_new(FALSE, 6); +- gtk_box_pack_start(GTK_BOX(mainbox), vbox, FALSE, FALSE, 0); +- +- hbox = gtk_hbox_new(FALSE, 12); +- gtk_box_set_homogeneous(GTK_BOX(hbox), TRUE); +- gtk_box_pack_start(GTK_BOX(vbox), hbox, TRUE, TRUE, 0); +- +- button = gtk_button_new_from_stock(GTK_STOCK_REFRESH); +- gtk_box_pack_start(GTK_BOX(hbox), button, TRUE, TRUE, 0); +- gtk_widget_set_sensitive(button, FALSE); +- g_signal_connect(G_OBJECT(button), "clicked", +- G_CALLBACK(refresh_callback), NULL); +- +- button_refresh = button; +- +- button = gtk_button_new_from_stock(GTK_STOCK_DISCONNECT); +- gtk_box_pack_end(GTK_BOX(hbox), button, TRUE, TRUE, 0); +- gtk_widget_set_sensitive(button, FALSE); +- g_signal_connect(G_OBJECT(button), "clicked", +- G_CALLBACK(connect_callback), NULL); +- +- button_connect = button; +- +- model = connman_client_get_device_model(client); +- gtk_combo_box_set_model(GTK_COMBO_BOX(combo), model); +- g_object_unref(model); +- +- gtk_combo_box_set_active(GTK_COMBO_BOX(combo), 0); +- +- return mainbox; +-} +- +-static void select_callback(GtkTreeSelection *selection, gpointer user_data) +-{ +- GtkTreeModel *model; +- GtkTreeIter iter; +- gboolean selected, enabled; +- +- selected = gtk_tree_selection_get_selected(selection, &model, &iter); +- +- if (selected == TRUE) { +- gtk_tree_model_get(model, &iter, +- CONNMAN_COLUMN_ENABLED, &enabled, -1); +- +- if (enabled == TRUE) +- g_object_set(button_connect, +- "label", GTK_STOCK_DISCONNECT, NULL); +- else +- g_object_set(button_connect, +- "label", GTK_STOCK_CONNECT, NULL); +- } +- +- gtk_widget_set_sensitive(button_connect, selected); +-} +- +-static void status_to_icon(GtkTreeViewColumn *column, GtkCellRenderer *cell, +- GtkTreeModel *model, GtkTreeIter *iter, gpointer data) +-{ +- gboolean enabled; +- +- gtk_tree_model_get(model, iter, CONNMAN_COLUMN_ENABLED, &enabled, -1); +- +- if (enabled == TRUE) +- g_object_set(cell, "icon-name", GTK_STOCK_ABOUT, NULL); +- +- g_object_set(cell, "visible", enabled, NULL); +-} +- +-static void security_to_icon(GtkTreeViewColumn *column, GtkCellRenderer *cell, +- GtkTreeModel *model, GtkTreeIter *iter, gpointer data) +-{ +- guint security; +- +- gtk_tree_model_get(model, iter, CONNMAN_COLUMN_SECURITY, &security, -1); +- +- if (security == CONNMAN_SECURITY_NONE) +- g_object_set(cell, "icon-name", NULL, NULL); +- else +- g_object_set(cell, "icon-name", +- GTK_STOCK_DIALOG_AUTHENTICATION, NULL); +-} +- +-static GtkWidget *create_right(void) +-{ +- GtkWidget *mainbox; +- GtkWidget *vbox; +- GtkWidget *label; +- GtkWidget *scrolled; +- GtkWidget *tree; +- GtkTreeViewColumn *column; +- GtkCellRenderer *renderer; +- +- mainbox = gtk_vbox_new(FALSE, 24); +- gtk_container_set_border_width(GTK_CONTAINER(mainbox), 8); +- +- vbox = gtk_vbox_new(FALSE, 6); +- gtk_box_pack_start(GTK_BOX(mainbox), vbox, TRUE, TRUE, 0); +- +- label = create_label("Networks"); +- gtk_box_pack_start(GTK_BOX(vbox), label, FALSE, FALSE, 0); +- +- scrolled = gtk_scrolled_window_new(NULL, NULL); +- gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scrolled), +- GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC); +- gtk_scrolled_window_set_shadow_type(GTK_SCROLLED_WINDOW(scrolled), +- GTK_SHADOW_OUT); +- gtk_container_add(GTK_CONTAINER(vbox), scrolled); +- +- tree = gtk_tree_view_new(); +- gtk_tree_view_set_headers_visible(GTK_TREE_VIEW(tree), FALSE); +- gtk_tree_view_set_show_expanders(GTK_TREE_VIEW(tree), FALSE); +- gtk_tree_view_set_rules_hint(GTK_TREE_VIEW(tree), TRUE); +- gtk_container_add(GTK_CONTAINER(scrolled), tree); +- +- gtk_tree_view_insert_column_with_data_func(GTK_TREE_VIEW(tree), 0, +- NULL, gtk_cell_renderer_pixbuf_new(), +- status_to_icon, NULL, NULL); +- column = gtk_tree_view_get_column(GTK_TREE_VIEW(tree), 0); +- gtk_tree_view_column_set_min_width(column, 24); +- +- column = gtk_tree_view_column_new(); +- gtk_tree_view_column_set_expand(GTK_TREE_VIEW_COLUMN(column), TRUE); +- gtk_tree_view_append_column(GTK_TREE_VIEW(tree), column); +- +- renderer = gtk_cell_renderer_text_new(); +- gtk_tree_view_column_pack_start(column, renderer, TRUE); +- gtk_tree_view_column_add_attribute(column, renderer, +- "text", CONNMAN_COLUMN_NAME); +- +- renderer = gtk_cell_renderer_pixbuf_new(); +- gtk_tree_view_column_pack_end(column, renderer, FALSE); +- gtk_tree_view_column_set_cell_data_func(column, renderer, +- security_to_icon, NULL, NULL); +- +- tree_networks = tree; +- +- selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(tree)); +- gtk_tree_selection_set_mode(selection, GTK_SELECTION_SINGLE); +- g_signal_connect(G_OBJECT(selection), "changed", +- G_CALLBACK(select_callback), NULL); +- +- return mainbox; +-} +- +-static gboolean delete_callback(GtkWidget *window, GdkEvent *event, +- gpointer user_data) +-{ +- gtk_widget_destroy(window); +- +- gtk_main_quit(); +- +- return FALSE; +-} +- +-static void close_callback(GtkWidget *button, gpointer user_data) +-{ +- GtkWidget *window = user_data; +- +- gtk_widget_destroy(window); +- +- gtk_main_quit(); +-} +- +-static GtkWidget *create_window(void) +-{ +- GtkWidget *window; +- GtkWidget *vbox; +- GtkWidget *hbox; +- GtkWidget *notebook; +- GtkWidget *buttonbox; +- GtkWidget *button; +- GtkWidget *widget; +- +- window = gtk_window_new(GTK_WINDOW_TOPLEVEL); +- gtk_window_set_position(GTK_WINDOW(window), GTK_WIN_POS_CENTER); +- gtk_window_set_default_size(GTK_WINDOW(window), 580, 360); +- g_signal_connect(G_OBJECT(window), "delete-event", +- G_CALLBACK(delete_callback), NULL); +- +- vbox = gtk_vbox_new(FALSE, 12); +- gtk_container_set_border_width(GTK_CONTAINER(vbox), 12); +- gtk_container_add(GTK_CONTAINER(window), vbox); +- +- notebook = gtk_notebook_new(); +- gtk_notebook_set_show_tabs(GTK_NOTEBOOK(notebook), FALSE); +- gtk_box_pack_start(GTK_BOX(vbox), notebook, TRUE, TRUE, 0); +- +- buttonbox = gtk_hbutton_box_new(); +- gtk_button_box_set_layout(GTK_BUTTON_BOX(buttonbox), GTK_BUTTONBOX_END); +- gtk_box_pack_start(GTK_BOX(vbox), buttonbox, FALSE, FALSE, 0); +- +- button = gtk_button_new_from_stock(GTK_STOCK_CLOSE); +- gtk_container_add(GTK_CONTAINER(buttonbox), button); +- g_signal_connect(G_OBJECT(button), "clicked", +- G_CALLBACK(close_callback), window); +- +- hbox = gtk_hbox_new(FALSE, 0); +- gtk_container_set_border_width(GTK_CONTAINER(hbox), 8); +- +- widget = create_right(); +- gtk_widget_set_size_request(widget, 280, -1); +- gtk_box_pack_end(GTK_BOX(hbox), widget, TRUE, TRUE, 0); +- +- widget = create_left(); +- gtk_widget_set_size_request(widget, 260, -1); +- gtk_box_pack_start(GTK_BOX(hbox), widget, FALSE, TRUE, 0); +- +- gtk_notebook_append_page(GTK_NOTEBOOK(notebook), hbox, NULL); +- +- return window; +-} +- +-static GOptionEntry options[] = { +- { "fullscreen", 'f', 0, G_OPTION_ARG_NONE, &option_fullscreen, +- "Start up in fullscreen mode" }, +- { NULL }, +-}; +- +-int main(int argc, char *argv[]) +-{ +- GError *error = NULL; +- GtkWidget *window; +- +- if (gtk_init_with_args(&argc, &argv, NULL, +- options, NULL, &error) == FALSE) { +- if (error != NULL) { +- g_printerr("%s\n", error->message); +- g_error_free(error); +- } else +- g_printerr("An unknown error occurred\n"); +- +- gtk_exit(1); +- } +- +- g_set_application_name("Connection Manager Demo"); +- +- gtk_window_set_default_icon_name("network-wireless"); +- +- client = connman_client_new(); +- +- window = create_window(); +- +- connman_client_set_callback(client, status_callback, NULL); +- +- if (option_fullscreen == TRUE) +- gtk_window_fullscreen(GTK_WINDOW(window)); +- +- gtk_widget_show_all(window); +- +- gtk_main(); +- +- g_object_unref(client); +- +- return 0; +-} +diff --git a/common/test-client.c b/common/test-client.c +deleted file mode 100644 +index a78823f..0000000 +--- a/common/test-client.c ++++ /dev/null +@@ -1,227 +0,0 @@ +-/* +- * +- * Connection Manager +- * +- * Copyright (C) 2008 Intel Corporation. All rights reserved. +- * +- * This program is free software; you can redistribute it and/or modify +- * it under the terms of the GNU General Public License version 2 as +- * published by the Free Software Foundation. +- * +- * This program is distributed in the hope that it will be useful, +- * but WITHOUT ANY WARRANTY; without even the implied warranty of +- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +- * GNU General Public License for more details. +- * +- * You should have received a copy of the GNU General Public License +- * along with this program; if not, write to the Free Software +- * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA +- * +- */ +- +-#ifdef HAVE_CONFIG_H +-#include <config.h> +-#endif +- +-#include <dbus/dbus-glib.h> +-#include <gtk/gtk.h> +- +-#include "connman-client.h" +- +-static ConnmanClient *client; +- +-static void proxy_to_text(GtkTreeViewColumn *column, GtkCellRenderer *cell, +- GtkTreeModel *model, GtkTreeIter *iter, gpointer data) +-{ +- DBusGProxy *proxy; +- gchar *markup; +- +- gtk_tree_model_get(model, iter, CONNMAN_COLUMN_PROXY, &proxy, -1); +- +- markup = g_strdup_printf("<b>%s</b>\n" +- "<span size=\"xx-small\">%s\n\n</span>", +- dbus_g_proxy_get_interface(proxy), +- dbus_g_proxy_get_path(proxy)); +- g_object_set(cell, "markup", markup, NULL); +- g_free(markup); +- +- g_object_unref(proxy); +-} +- +-static void name_to_text(GtkTreeViewColumn *column, GtkCellRenderer *cell, +- GtkTreeModel *model, GtkTreeIter *iter, gpointer data) +-{ +- gchar *name, *icon; +- guint type; +- gchar *markup; +- +- gtk_tree_model_get(model, iter, CONNMAN_COLUMN_NAME, &name, +- CONNMAN_COLUMN_ICON, &icon, +- CONNMAN_COLUMN_TYPE, &type, -1); +- +- markup = g_strdup_printf("Name: %s\nIcon: %s\nType: %d", +- name, icon, type); +- g_object_set(cell, "markup", markup, NULL); +- g_free(markup); +- +- g_free(icon); +- g_free(name); +-} +- +-static void status_to_text(GtkTreeViewColumn *column, GtkCellRenderer *cell, +- GtkTreeModel *model, GtkTreeIter *iter, gpointer data) +-{ +- gboolean enabled, inrange, remember; +- gchar *markup; +- +- gtk_tree_model_get(model, iter, CONNMAN_COLUMN_ENABLED, &enabled, +- CONNMAN_COLUMN_INRANGE, &inrange, +- CONNMAN_COLUMN_REMEMBER, &remember, -1); +- +- markup = g_strdup_printf("Enabled: %d\n" +- "InRange: %d\nRemember: %d", +- enabled, inrange, remember); +- g_object_set(cell, "markup", markup, NULL); +- g_free(markup); +-} +- +-static void network_to_text(GtkTreeViewColumn *column, GtkCellRenderer *cell, +- GtkTreeModel *model, GtkTreeIter *iter, gpointer data) +-{ +- guint strength, security; +- gchar *secret; +- gchar *markup; +- +- gtk_tree_model_get(model, iter, CONNMAN_COLUMN_STRENGTH, &strength, +- CONNMAN_COLUMN_SECURITY, &security, +- CONNMAN_COLUMN_PASSPHRASE, &secret, -1); +- +- markup = g_strdup_printf("Strength: %d\nSecurity: %d\nSecret: %s", +- strength, security, secret); +- g_object_set(cell, "markup", markup, NULL); +- g_free(markup); +- +- g_free(secret); +-} +- +-static GtkWidget *create_tree(void) +-{ +- GtkWidget *tree; +- GtkTreeModel *model; +- GtkTreeSelection *selection; +- +- tree = gtk_tree_view_new(); +- gtk_tree_view_set_headers_visible(GTK_TREE_VIEW(tree), TRUE); +- gtk_tree_view_set_rules_hint(GTK_TREE_VIEW(tree), TRUE); +- +- gtk_tree_view_insert_column_with_data_func(GTK_TREE_VIEW(tree), -1, +- "Proxy", gtk_cell_renderer_text_new(), +- proxy_to_text, NULL, NULL); +- +- gtk_tree_view_insert_column_with_data_func(GTK_TREE_VIEW(tree), -1, +- "Name", gtk_cell_renderer_text_new(), +- name_to_text, NULL, NULL); +- +- gtk_tree_view_insert_column_with_data_func(GTK_TREE_VIEW(tree), -1, +- "Status", gtk_cell_renderer_text_new(), +- status_to_text, NULL, NULL); +- +- gtk_tree_view_insert_column_with_data_func(GTK_TREE_VIEW(tree), -1, +- "Network", gtk_cell_renderer_text_new(), +- network_to_text, NULL, NULL); +- +- model = connman_client_get_model(client); +- gtk_tree_view_set_model(GTK_TREE_VIEW(tree), model); +- g_object_unref(model); +- +- selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(tree)); +- gtk_tree_selection_set_mode(selection, GTK_SELECTION_SINGLE); +- +- gtk_tree_view_expand_all(GTK_TREE_VIEW(tree)); +- +- return tree; +-} +- +-static gboolean delete_callback(GtkWidget *window, GdkEvent *event, +- gpointer user_data) +-{ +- gtk_widget_destroy(window); +- +- gtk_main_quit(); +- +- return FALSE; +-} +- +-static void close_callback(GtkWidget *button, gpointer user_data) +-{ +- GtkWidget *window = user_data; +- +- gtk_widget_destroy(window); +- +- gtk_main_quit(); +-} +- +-static GtkWidget *create_window(void) +-{ +- GtkWidget *window; +- GtkWidget *mainbox; +- GtkWidget *tree; +- GtkWidget *scrolled; +- GtkWidget *buttonbox; +- GtkWidget *button; +- GtkTreeSelection *selection; +- +- tree = create_tree(); +- selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(tree)); +- +- window = gtk_window_new(GTK_WINDOW_TOPLEVEL); +- gtk_window_set_title(GTK_WINDOW(window), "Client Test"); +- gtk_window_set_position(GTK_WINDOW(window), GTK_WIN_POS_CENTER); +- gtk_window_set_default_size(GTK_WINDOW(window), 800, 600); +- g_signal_connect(G_OBJECT(window), "delete-event", +- G_CALLBACK(delete_callback), NULL); +- +- mainbox = gtk_vbox_new(FALSE, 12); +- gtk_container_set_border_width(GTK_CONTAINER(mainbox), 12); +- gtk_container_add(GTK_CONTAINER(window), mainbox); +- +- scrolled = gtk_scrolled_window_new(NULL, NULL); +- gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scrolled), +- GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC); +- gtk_scrolled_window_set_shadow_type(GTK_SCROLLED_WINDOW(scrolled), +- GTK_SHADOW_OUT); +- gtk_box_pack_start(GTK_BOX(mainbox), scrolled, TRUE, TRUE, 0); +- +- buttonbox = gtk_hbutton_box_new(); +- gtk_button_box_set_layout(GTK_BUTTON_BOX(buttonbox), +- GTK_BUTTONBOX_END); +- gtk_box_pack_end(GTK_BOX(mainbox), buttonbox, FALSE, FALSE, 0); +- +- button = gtk_button_new_from_stock(GTK_STOCK_CLOSE); +- gtk_container_add(GTK_CONTAINER(buttonbox), button); +- g_signal_connect(G_OBJECT(button), "clicked", +- G_CALLBACK(close_callback), window); +- +- gtk_container_add(GTK_CONTAINER(scrolled), tree); +- +- gtk_widget_show_all(window); +- +- return window; +-} +- +-int main(int argc, char *argv[]) +-{ +- gtk_init(&argc, &argv); +- +- client = connman_client_new(); +- +- gtk_window_set_default_icon_name("network-wireless"); +- +- create_window(); +- +- gtk_main(); +- +- g_object_unref(client); +- +- return 0; +-} +diff --git a/properties/Makefile.am b/properties/Makefile.am +index ad2fd35..3a47ccf 100644 +--- a/properties/Makefile.am ++++ b/properties/Makefile.am +@@ -1,8 +1,7 @@ + + bin_PROGRAMS = connman-properties + +-connman_properties_SOURCES = main.c advanced.h advanced.c \ +- ethernet.c wifi.c ++connman_properties_SOURCES = main.c advanced.h ethernet.c wifi.c + + connman_properties_LDADD = $(top_builddir)/common/libcommon.a \ + @GTK_LIBS@ @DBUS_LIBS@ +diff --git a/properties/advanced.c b/properties/advanced.c +deleted file mode 100644 +index 1eb1c3d..0000000 +--- a/properties/advanced.c ++++ /dev/null +@@ -1,314 +0,0 @@ +-/* +- * +- * Connection Manager +- * +- * Copyright (C) 2008 Intel Corporation. All rights reserved. +- * +- * This program is free software; you can redistribute it and/or modify +- * it under the terms of the GNU General Public License version 2 as +- * published by the Free Software Foundation. +- * +- * This program is distributed in the hope that it will be useful, +- * but WITHOUT ANY WARRANTY; without even the implied warranty of +- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +- * GNU General Public License for more details. +- * +- * You should have received a copy of the GNU General Public License +- * along with this program; if not, write to the Free Software +- * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA +- * +- */ +- +-#ifdef HAVE_CONFIG_H +-#include <config.h> +-#endif +- +-#include <dbus/dbus-glib.h> +-#include <glib/gi18n.h> +- +-#include "connman-client.h" +- +-#include "advanced.h" +- +-gboolean separator_function(GtkTreeModel *model, +- GtkTreeIter *iter, gpointer user_data) +-{ +- gchar *text; +- gboolean result = FALSE; +- +- gtk_tree_model_get(model, iter, 0, &text, -1); +- +- if (text && *text == '\0') +- result = TRUE; +- +- g_free(text); +- +- return result; +-} +- +-static void activate_callback(GtkWidget *button, gpointer user_data) +-{ +-} +- +-static void changed_callback(GtkWidget *editable, gpointer user_data) +-{ +-} +- +-static void add_network(GtkWidget *mainbox, struct config_data *data) +-{ +- GtkWidget *table; +- GtkWidget *label; +- GtkWidget *entry; +- GtkWidget *combo; +- GtkWidget *button; +- +- table = gtk_table_new(3, 5, TRUE); +- gtk_table_set_row_spacings(GTK_TABLE(table), 2); +- gtk_table_set_col_spacings(GTK_TABLE(table), 8); +- gtk_box_pack_start(GTK_BOX(mainbox), table, FALSE, FALSE, 0); +- +- label = gtk_label_new(_("Network Name:")); +- gtk_label_set_justify(GTK_LABEL(label), GTK_JUSTIFY_RIGHT); +- gtk_misc_set_alignment(GTK_MISC(label), 1.0, 0.5); +- gtk_table_attach_defaults(GTK_TABLE(table), label, 0, 1, 0, 1); +- +- combo = gtk_combo_box_entry_new_text(); +- gtk_combo_box_append_text(GTK_COMBO_BOX(combo), "Guest"); +- gtk_combo_box_append_text(GTK_COMBO_BOX(combo), ""); +- gtk_combo_box_append_text(GTK_COMBO_BOX(combo), "Off"); +- gtk_combo_box_set_row_separator_func(GTK_COMBO_BOX(combo), +- separator_function, NULL, NULL); +- gtk_table_attach_defaults(GTK_TABLE(table), combo, 1, 3, 0, 1); +- //data->network.name = combo; +- +- label = gtk_label_new(_("Passphrase:")); +- gtk_label_set_justify(GTK_LABEL(label), GTK_JUSTIFY_RIGHT); +- gtk_misc_set_alignment(GTK_MISC(label), 1.0, 0.5); +- gtk_table_attach_defaults(GTK_TABLE(table), label, 0, 1, 1, 2); +- +- entry = gtk_entry_new(); +- gtk_entry_set_visibility(GTK_ENTRY(entry), FALSE); +- gtk_table_attach_defaults(GTK_TABLE(table), entry, 1, 3, 1, 2); +- //data->network.passphrase = entry; +- +- button = gtk_button_new_with_label(_("Activate")); +- gtk_widget_set_sensitive(button, FALSE); +- gtk_table_attach_defaults(GTK_TABLE(table), button, 1, 2, 2, 3); +- //data->network.activate = button; +- +- g_signal_connect(G_OBJECT(combo), "changed", +- G_CALLBACK(changed_callback), data); +- +- g_signal_connect(G_OBJECT(button), "clicked", +- G_CALLBACK(activate_callback), data); +-} +- +-static void set_widgets(struct config_data *data, gboolean label, +- gboolean value, gboolean entry) +-{ +- int i; +- +- for (i = 0; i < 3; i++) { +- if (label == TRUE) +- gtk_widget_show(data->ipv4.label[i]); +- else +- gtk_widget_hide(data->ipv4.label[i]); +- +- if (value == TRUE) +- gtk_widget_show(data->ipv4.value[i]); +- else +- gtk_widget_hide(data->ipv4.value[i]); +- +- if (entry == TRUE) +- gtk_widget_show(data->ipv4.entry[i]); +- else +- gtk_widget_hide(data->ipv4.entry[i]); +- } +-} +- +-static void config_callback(GtkWidget *widget, gpointer user_data) +-{ +- gint active; +- +- active = gtk_combo_box_get_active(GTK_COMBO_BOX(widget)); +-} +- +-static void add_config(GtkWidget *mainbox, struct config_data *data) +-{ +- GtkWidget *table; +- GtkWidget *label; +- GtkWidget *entry; +- GtkWidget *combo; +- +- table = gtk_table_new(5, 5, TRUE); +- gtk_table_set_row_spacings(GTK_TABLE(table), 2); +- gtk_table_set_col_spacings(GTK_TABLE(table), 8); +- gtk_box_pack_start(GTK_BOX(mainbox), table, FALSE, FALSE, 0); +- +- label = gtk_label_new(_("Configure IPv4:")); +- gtk_label_set_justify(GTK_LABEL(label), GTK_JUSTIFY_RIGHT); +- gtk_misc_set_alignment(GTK_MISC(label), 1.0, 0.5); +- gtk_table_attach_defaults(GTK_TABLE(table), label, 0, 1, 0, 1); +- +- combo = gtk_combo_box_new_text(); +- gtk_combo_box_append_text(GTK_COMBO_BOX(combo), "Using DHCP"); +- gtk_combo_box_append_text(GTK_COMBO_BOX(combo), "Manually"); +- gtk_combo_box_append_text(GTK_COMBO_BOX(combo), ""); +- gtk_combo_box_append_text(GTK_COMBO_BOX(combo), "Off"); +- gtk_combo_box_set_row_separator_func(GTK_COMBO_BOX(combo), +- separator_function, NULL, NULL); +- gtk_table_attach_defaults(GTK_TABLE(table), combo, 1, 3, 0, 1); +- data->ipv4.config = combo; +- +- label = gtk_label_new(_("IP Address:")); +- gtk_label_set_justify(GTK_LABEL(label), GTK_JUSTIFY_RIGHT); +- gtk_misc_set_alignment(GTK_MISC(label), 1.0, 0.5); +- gtk_widget_set_no_show_all(label, TRUE); +- gtk_table_attach_defaults(GTK_TABLE(table), label, 0, 1, 1, 2); +- data->ipv4.label[0] = label; +- +- label = gtk_label_new(NULL); +- gtk_label_set_selectable(GTK_LABEL(label), TRUE); +- gtk_label_set_justify(GTK_LABEL(label), GTK_JUSTIFY_LEFT); +- gtk_misc_set_alignment(GTK_MISC(label), 0.0, 0.5); +- gtk_widget_set_no_show_all(label, TRUE); +- gtk_table_attach_defaults(GTK_TABLE(table), label, 1, 3, 1, 2); +- data->ipv4.value[0] = label; +- +- entry = gtk_entry_new(); +- gtk_widget_set_no_show_all(entry, TRUE); +- gtk_table_attach_defaults(GTK_TABLE(table), entry, 1, 3, 1, 2); +- data->ipv4.entry[0] = entry; +- +- label = gtk_label_new(_("Subnet Mask:")); +- gtk_label_set_justify(GTK_LABEL(label), GTK_JUSTIFY_RIGHT); +- gtk_misc_set_alignment(GTK_MISC(label), 1.0, 0.5); +- gtk_widget_set_no_show_all(label, TRUE); +- gtk_table_attach_defaults(GTK_TABLE(table), label, 0, 1, 2, 3); +- data->ipv4.label[1] = label; +- +- label = gtk_label_new(NULL); +- gtk_label_set_selectable(GTK_LABEL(label), TRUE); +- gtk_label_set_justify(GTK_LABEL(label), GTK_JUSTIFY_LEFT); +- gtk_misc_set_alignment(GTK_MISC(label), 0.0, 0.5); +- gtk_widget_set_no_show_all(label, TRUE); +- gtk_table_attach_defaults(GTK_TABLE(table), label, 1, 3, 2, 3); +- data->ipv4.value[1] = label; +- +- entry = gtk_entry_new(); +- gtk_widget_set_no_show_all(entry, TRUE); +- gtk_table_attach_defaults(GTK_TABLE(table), entry, 1, 3, 2, 3); +- data->ipv4.entry[1] = entry; +- +- label = gtk_label_new(_("Router:")); +- gtk_label_set_justify(GTK_LABEL(label), GTK_JUSTIFY_RIGHT); +- gtk_misc_set_alignment(GTK_MISC(label), 1.0, 0.5); +- gtk_widget_set_no_show_all(label, TRUE); +- gtk_table_attach_defaults(GTK_TABLE(table), label, 0, 1, 3, 4); +- data->ipv4.label[2] = label; +- +- label = gtk_label_new(NULL); +- gtk_label_set_selectable(GTK_LABEL(label), TRUE); +- gtk_label_set_justify(GTK_LABEL(label), GTK_JUSTIFY_LEFT); +- gtk_misc_set_alignment(GTK_MISC(label), 0.0, 0.5); +- gtk_widget_set_no_show_all(label, TRUE); +- gtk_table_attach_defaults(GTK_TABLE(table), label, 1, 3, 3, 4); +- data->ipv4.value[2] = label; +- +- entry = gtk_entry_new(); +- gtk_widget_set_no_show_all(entry, TRUE); +- gtk_table_attach_defaults(GTK_TABLE(table), entry, 1, 3, 3, 4); +- data->ipv4.entry[2] = entry; +- +- gtk_combo_box_set_active(GTK_COMBO_BOX(combo), 0); +- set_widgets(data, TRUE, TRUE, FALSE); +- +- g_signal_connect(G_OBJECT(combo), "changed", +- G_CALLBACK(config_callback), data); +-} +- +-static void delete_callback(GtkWidget *window, GdkEvent *event, +- gpointer user_data) +-{ +- gtk_widget_hide(window); +-} +- +-static void close_callback(GtkWidget *button, gpointer user_data) +-{ +- GtkWidget *window = user_data; +- +- gtk_widget_hide(window); +-} +- +-void create_advanced_dialog(struct config_data *data, guint type) +-{ +- GtkWidget *dialog; +- GtkWidget *vbox; +- GtkWidget *notebook; +- GtkWidget *buttonbox; +- GtkWidget *button; +- GtkWidget *widget; +- +- dialog = gtk_window_new(GTK_WINDOW_TOPLEVEL); +- gtk_window_set_modal(GTK_WINDOW(dialog), TRUE); +- gtk_window_set_transient_for(GTK_WINDOW(dialog), +- GTK_WINDOW(data->window)); +- gtk_window_set_title(GTK_WINDOW(dialog), _("Advanced Settings")); +- gtk_window_set_position(GTK_WINDOW(dialog), +- GTK_WIN_POS_CENTER_ON_PARENT); +- gtk_window_set_default_size(GTK_WINDOW(dialog), 460, 320); +- g_signal_connect(G_OBJECT(dialog), "delete-event", +- G_CALLBACK(delete_callback), NULL); +- +- vbox = gtk_vbox_new(FALSE, 12); +- gtk_container_set_border_width(GTK_CONTAINER(vbox), 12); +- gtk_container_add(GTK_CONTAINER(dialog), vbox); +- +- notebook = gtk_notebook_new(); +- gtk_box_pack_start(GTK_BOX(vbox), notebook, TRUE, TRUE, 0); +- +- buttonbox = gtk_hbutton_box_new(); +- gtk_button_box_set_layout(GTK_BUTTON_BOX(buttonbox), GTK_BUTTONBOX_END); +- gtk_box_set_spacing(GTK_BOX(buttonbox), 6); +- gtk_box_pack_start(GTK_BOX(vbox), buttonbox, FALSE, FALSE, 0); +- +- button = gtk_button_new_from_stock(GTK_STOCK_CANCEL); +- gtk_container_add(GTK_CONTAINER(buttonbox), button); +- g_signal_connect(G_OBJECT(button), "clicked", +- G_CALLBACK(close_callback), dialog); +- +- button = gtk_button_new_from_stock(GTK_STOCK_OK); +- gtk_container_add(GTK_CONTAINER(buttonbox), button); +- g_signal_connect(G_OBJECT(button), "clicked", +- G_CALLBACK(close_callback), dialog); +- +- if (type == CONNMAN_TYPE_WIFI) { +- widget = gtk_vbox_new(FALSE, 24); +- gtk_container_set_border_width(GTK_CONTAINER(widget), 24); +- gtk_notebook_append_page(GTK_NOTEBOOK(notebook), widget, NULL); +- gtk_notebook_set_tab_label_text(GTK_NOTEBOOK(notebook), +- widget, _("Wireless")); +- add_network(widget, data); +- } +- +- widget = gtk_vbox_new(FALSE, 24); +- gtk_container_set_border_width(GTK_CONTAINER(widget), 24); +- gtk_notebook_append_page(GTK_NOTEBOOK(notebook), widget, NULL); +- gtk_notebook_set_tab_label_text(GTK_NOTEBOOK(notebook), +- widget, _("TCP/IP")); +- add_config(widget, data); +- +- widget = gtk_label_new(NULL); +- gtk_notebook_append_page(GTK_NOTEBOOK(notebook), widget, NULL); +- gtk_notebook_set_tab_label_text(GTK_NOTEBOOK(notebook), +- widget, _("DNS")); +- +- if (type == CONNMAN_TYPE_ETHERNET) { +- widget = gtk_label_new(NULL); +- gtk_notebook_append_page(GTK_NOTEBOOK(notebook), widget, NULL); +- gtk_notebook_set_tab_label_text(GTK_NOTEBOOK(notebook), +- widget, _("Ethernet")); +- } +- +- data->dialog = dialog; +-} +diff --git a/properties/advanced.h b/properties/advanced.h +index f85f10d..a180b98 100644 +--- a/properties/advanced.h ++++ b/properties/advanced.h +@@ -23,6 +23,7 @@ struct config_data { + ConnmanClient *client; + + GtkWidget *widget; ++ GtkWidget *table; + GtkWidget *title; + GtkWidget *label; + GtkWidget *button; +@@ -45,15 +46,26 @@ struct config_data { + GtkWidget *value[3]; + GtkWidget *entry[3]; + } ipv4; ++ ++ struct ipv4_config ipv4_config; ++ ++ struct { ++ GtkWidget *name; ++ GtkWidget *security; ++ GtkWidget *strength; ++ GtkWidget *passphrase; ++ GtkWidget *connect_info; ++ GtkWidget *connect; ++ GtkWidget *disconnect; ++ } wifi; ++ ++ gboolean connecting; + }; + + void create_advanced_dialog(struct config_data *data, guint type); + +-void add_ethernet_policy(GtkWidget *mainbox, struct config_data *data); +-void update_ethernet_policy(struct config_data *data, guint policy); ++void add_ethernet_policy(GtkWidget *mainbox, GtkTreeIter *iter, struct config_data *data); ++void update_ethernet_ipv4(struct config_data *data, guint policy); + +-void add_wifi_policy(GtkWidget *mainbox, struct config_data *data); ++void add_wifi_policy(GtkWidget *mainbox, GtkTreeIter *iter, struct config_data *data); + void update_wifi_policy(struct config_data *data, guint policy); +- +-gboolean separator_function(GtkTreeModel *model, +- GtkTreeIter *iter, gpointer user_data); +diff --git a/properties/ethernet.c b/properties/ethernet.c +index d5c948d..1901ee6 100644 +--- a/properties/ethernet.c ++++ b/properties/ethernet.c +@@ -23,6 +23,7 @@ + #include <config.h> + #endif + ++#include <dbus/dbus-glib.h> + #include <glib/gi18n.h> + #include <gtk/gtk.h> + +@@ -30,93 +31,167 @@ + + #include "advanced.h" + ++static gboolean separator_function(GtkTreeModel *model, ++ GtkTreeIter *iter, gpointer user_data) ++{ ++ gchar *text; ++ gboolean result = FALSE; ++ ++ gtk_tree_model_get(model, iter, 0, &text, -1); ++ ++ if (text && *text == '\0') ++ result = TRUE; ++ ++ g_free(text); ++ ++ return result; ++} ++ + static void changed_callback(GtkWidget *editable, gpointer user_data) + { + struct config_data *data = user_data; + gint active; + + active = gtk_combo_box_get_active(GTK_COMBO_BOX(data->policy.config)); ++ update_ethernet_ipv4(data, active); ++} + +- switch (active) { +- case 0: +- connman_client_set_policy(data->client, data->device, "auto"); +- update_ethernet_policy(data, CONNMAN_POLICY_AUTO); +- break; +- case 1: +- connman_client_set_policy(data->client, data->device, "ignore"); +- update_ethernet_policy(data, CONNMAN_POLICY_IGNORE); +- break; +- case 3: +- connman_client_set_policy(data->client, data->device, "off"); +- update_ethernet_policy(data, CONNMAN_POLICY_OFF); +- break; +- } ++static void apply_callback(GtkWidget *editable, gpointer user_data) ++{ ++ struct config_data *data = user_data; ++ gint active; ++ ++ active = gtk_combo_box_get_active(GTK_COMBO_BOX(data->policy.config)); ++ data->ipv4_config.method = active ? "manual" : "dhcp"; ++ data->ipv4_config.address = active ? gtk_entry_get_text(GTK_ENTRY(data->ipv4.entry[0])) : NULL; ++ data->ipv4_config.netmask = active ? gtk_entry_get_text(GTK_ENTRY(data->ipv4.entry[1])) : NULL; ++ data->ipv4_config.gateway = active ? gtk_entry_get_text(GTK_ENTRY(data->ipv4.entry[2])) : NULL; ++ ++ connman_client_set_ipv4(data->client, data->device, &data->ipv4_config); + } + +-void add_ethernet_policy(GtkWidget *mainbox, struct config_data *data) ++void add_ethernet_policy(GtkWidget *mainbox, GtkTreeIter *iter, struct config_data *data) + { + GtkWidget *vbox; + GtkWidget *table; + GtkWidget *label; + GtkWidget *combo; +- +- vbox = gtk_vbox_new(FALSE, 0); ++ GtkWidget *entry; ++ GtkWidget *button; ++ ++ struct ipv4_config ipv4_config = { ++ .method = NULL, ++ .address = NULL, ++ .netmask = NULL, ++ .gateway = NULL, ++ }; ++ ++ gtk_tree_model_get(data->model, iter, ++ CONNMAN_COLUMN_METHOD, &ipv4_config.method, ++ CONNMAN_COLUMN_ADDRESS, &ipv4_config.address, ++ CONNMAN_COLUMN_NETMASK, &ipv4_config.netmask, ++ CONNMAN_COLUMN_GATEWAY, &ipv4_config.gateway, ++ -1); ++ ++ vbox = gtk_vbox_new(TRUE, 0); + gtk_container_set_border_width(GTK_CONTAINER(vbox), 24); + gtk_box_pack_start(GTK_BOX(mainbox), vbox, FALSE, FALSE, 0); + +- table = gtk_table_new(2, 4, FALSE); +- gtk_table_set_row_spacings(GTK_TABLE(table), 8); +- gtk_table_set_col_spacings(GTK_TABLE(table), 8); ++ table = gtk_table_new(5, 5, TRUE); ++ gtk_table_set_row_spacings(GTK_TABLE(table), 10); ++ gtk_table_set_col_spacings(GTK_TABLE(table), 10); + gtk_box_pack_start(GTK_BOX(vbox), table, FALSE, FALSE, 0); + + label = gtk_label_new(_("Configuration:")); +- gtk_label_set_justify(GTK_LABEL(label), GTK_JUSTIFY_RIGHT); +- gtk_misc_set_alignment(GTK_MISC(label), 1.0, 0.5); +- gtk_table_attach_defaults(GTK_TABLE(table), label, 0, 1, 0, 1); ++ gtk_table_attach_defaults(GTK_TABLE(table), label, 1, 2, 0, 1); + + combo = gtk_combo_box_new_text(); +- gtk_combo_box_append_text(GTK_COMBO_BOX(combo), "Automatically"); +- gtk_combo_box_append_text(GTK_COMBO_BOX(combo), "Ignore Interface"); +- gtk_combo_box_append_text(GTK_COMBO_BOX(combo), ""); +- gtk_combo_box_append_text(GTK_COMBO_BOX(combo), "Off"); ++ gtk_combo_box_append_text(GTK_COMBO_BOX(combo), "DHCP"); ++ gtk_combo_box_append_text(GTK_COMBO_BOX(combo), "Manual"); + gtk_combo_box_set_row_separator_func(GTK_COMBO_BOX(combo), +- separator_function, NULL, NULL); +- gtk_table_attach_defaults(GTK_TABLE(table), combo, 1, 4, 0, 1); ++ separator_function, NULL, NULL); ++ ++ gtk_table_attach_defaults(GTK_TABLE(table), combo, 2, 4, 0, 1); + data->policy.config = combo; + +- label = gtk_label_new(NULL); +- gtk_label_set_line_wrap(GTK_LABEL(label), TRUE); +- gtk_label_set_justify(GTK_LABEL(label), GTK_JUSTIFY_LEFT); +- gtk_misc_set_alignment(GTK_MISC(label), 0.0, 0.0); +- gtk_table_attach_defaults(GTK_TABLE(table), label, 1, 4, 1, 2); +- gtk_widget_set_size_request(label, 180, -1); +- data->policy.label = label; ++ label = gtk_label_new(_("IP address:")); ++ gtk_table_attach_defaults(GTK_TABLE(table), label, 1, 2, 1, 2); ++ data->ipv4.label[0] = label; ++ ++ entry = gtk_entry_new(); ++ gtk_entry_set_max_length (GTK_ENTRY (entry), 15); ++ if (ipv4_config.address) ++ gtk_entry_set_text(GTK_ENTRY(entry), ipv4_config.address); ++ gtk_table_attach_defaults(GTK_TABLE(table), entry, 2, 4, 1, 2); ++ data->ipv4.entry[0] = entry; ++ ++ label = gtk_label_new(_("Netmask:")); ++ gtk_table_attach_defaults(GTK_TABLE(table), label, 1, 2, 2, 3); ++ data->ipv4.label[1] = label; ++ ++ entry = gtk_entry_new(); ++ gtk_entry_set_max_length (GTK_ENTRY (entry), 15); ++ if (ipv4_config.netmask) ++ gtk_entry_set_text(GTK_ENTRY(entry), ipv4_config.netmask); ++ gtk_table_attach_defaults(GTK_TABLE(table), entry, 2, 4, 2, 3); ++ data->ipv4.entry[1] = entry; ++ ++ label = gtk_label_new(_("Gateway:")); ++ gtk_table_attach_defaults(GTK_TABLE(table), label, 1, 2, 3, 4); ++ data->ipv4.label[2] = label; ++ ++ entry = gtk_entry_new(); ++ gtk_entry_set_max_length (GTK_ENTRY (entry), 15); ++ if (ipv4_config.gateway) ++ gtk_entry_set_text(GTK_ENTRY(entry), ipv4_config.gateway); ++ gtk_table_attach_defaults(GTK_TABLE(table), entry, 2, 4, 3, 4); ++ data->ipv4.entry[2] = entry; ++ ++ data->ipv4_config = ipv4_config; ++ ++ button = gtk_button_new_with_label(_("Apply")); ++ gtk_table_attach_defaults(GTK_TABLE(table), button, 3, 4, 4, 5); ++ g_signal_connect(G_OBJECT(button), "clicked", ++ G_CALLBACK(apply_callback), data); ++ ++ data->button = button; ++ ++ if (g_str_equal(ipv4_config.method, "dhcp") == TRUE) ++ update_ethernet_ipv4(data, CONNMAN_POLICY_DHCP); ++ else ++ update_ethernet_ipv4(data, CONNMAN_POLICY_MANUAL); + + g_signal_connect(G_OBJECT(combo), "changed", +- G_CALLBACK(changed_callback), data); ++ G_CALLBACK(changed_callback), data); + } + +-void update_ethernet_policy(struct config_data *data, guint policy) ++void update_ethernet_ipv4(struct config_data *data, guint policy) + { + GtkWidget *combo = data->policy.config; +- gchar *info = NULL; ++ GtkWidget *entry[3]; ++ int i; ++ ++ for (i = 0; i < 3; i++) ++ entry[i] = data->ipv4.entry[i]; + + g_signal_handlers_block_by_func(G_OBJECT(combo), +- G_CALLBACK(changed_callback), data); ++ G_CALLBACK(changed_callback), data); + + switch (policy) { +- case CONNMAN_POLICY_OFF: +- gtk_combo_box_set_active(GTK_COMBO_BOX(combo), 3); ++ case CONNMAN_POLICY_DHCP: ++ gtk_combo_box_set_active(GTK_COMBO_BOX(combo), 0); ++ for (i = 0; i < 3; i++) { ++ gtk_entry_set_editable(GTK_ENTRY(entry[i]), 0); ++ gtk_widget_set_sensitive(entry[i], 0); ++ gtk_entry_set_text(GTK_ENTRY(entry[i]), _("")); ++ } + break; +- case CONNMAN_POLICY_IGNORE: ++ case CONNMAN_POLICY_MANUAL: + gtk_combo_box_set_active(GTK_COMBO_BOX(combo), 1); +- info = g_strdup_printf(_("Ignore the interface and don't " +- "make any attempts for configuration.")); +- break; +- case CONNMAN_POLICY_AUTO: +- gtk_combo_box_set_active(GTK_COMBO_BOX(combo), 0); +- info = g_strdup_printf(_("Detect carrier and then " +- "automatically configure the interface.")); ++ for (i = 0; i < 3; i++) { ++ gtk_entry_set_editable(GTK_ENTRY(entry[i]), 1); ++ gtk_widget_set_sensitive(entry[i], 1); ++ } + break; + default: + gtk_combo_box_set_active(GTK_COMBO_BOX(combo), -1); +@@ -124,9 +199,5 @@ void update_ethernet_policy(struct config_data *data, guint policy) + } + + g_signal_handlers_unblock_by_func(G_OBJECT(combo), +- G_CALLBACK(changed_callback), data); +- +- gtk_label_set_markup(GTK_LABEL(data->policy.label), info); +- +- g_free(info); ++ G_CALLBACK(changed_callback), data); + } +diff --git a/properties/main.c b/properties/main.c +index 01439e6..3701f16 100644 +--- a/properties/main.c ++++ b/properties/main.c +@@ -33,102 +33,54 @@ + static ConnmanClient *client; + static GtkWidget *interface_notebook; + +-static void update_status(struct config_data *data, +- guint type, gboolean inrange, guint policy, +- const gchar *network, const gchar *address) ++static void get_state_realtime(GtkTreeModel *model, GtkTreePath *path, ++ GtkTreeIter *iter, gpointer user_data) + { +- const char *str; +- gchar *markup, *info = NULL; +- +- switch (type) { +- case CONNMAN_TYPE_ETHERNET: +- if (inrange == TRUE) { +- str = N_("Connected"); +- info = g_strdup_printf(_("%s is currently active " +- "and has the IP address %s."), +- N_("Ethernet"), address); ++ struct config_data *data = user_data; ++ guint type, strength; ++ const gchar *name = NULL, *_name = NULL, *state = NULL; ++ ++ if (data->wifi.name) ++ _name = gtk_label_get_text(GTK_LABEL(data->wifi.name)); ++ ++ gtk_tree_model_get(model, iter, CONNMAN_COLUMN_STRENGTH, &strength, ++ CONNMAN_COLUMN_STATE, &state, ++ CONNMAN_COLUMN_NAME, &name, ++ CONNMAN_COLUMN_TYPE, &type, ++ -1); ++ ++ if (name && _name && g_str_equal(name, _name) == TRUE && data->connecting) { ++ if (g_str_equal(state, "failure") == TRUE) { ++ gtk_label_set_text(GTK_LABEL(data->wifi.connect_info), ++ _("connection failed")); ++ gtk_widget_show(data->wifi.connect_info); ++ gtk_widget_show(data->wifi.connect); ++ gtk_widget_hide(data->wifi.disconnect); ++ data->connecting = 0; ++ } else if (g_str_equal(state, "idle") == TRUE) { ++ gtk_widget_hide(data->wifi.connect_info); ++ gtk_widget_show(data->wifi.connect); ++ gtk_widget_hide(data->wifi.disconnect); ++ data->connecting = 0; + } else { +- str = N_("Cable Unplugged"); +- info = g_strdup_printf(_("The cable for %s is " +- "not plugged in."), N_("Ethernet")); ++ gtk_widget_hide(data->wifi.connect_info); ++ gtk_widget_hide(data->wifi.connect); ++ gtk_widget_show(data->wifi.disconnect); + } +- break; +- +- case CONNMAN_TYPE_WIFI: +- if (inrange == TRUE) { +- str = N_("Connected"); +- info = g_strdup_printf(_("%s is currently active " +- "and has the IP address %s."), +- N_("Wireless"), address); +- } else +- str = N_("Not Connected"); +- break; +- +- default: +- if (inrange == TRUE) +- str = N_("Connected"); +- else +- str = N_("Not Connected"); +- break; + } +- +- markup = g_strdup_printf("<b>%s</b>", str); +- gtk_label_set_markup(GTK_LABEL(data->title), markup); +- g_free(markup); +- +- gtk_label_set_markup(GTK_LABEL(data->label), info); +- +- g_free(info); +- +- switch (type) { +- case CONNMAN_TYPE_ETHERNET: +- update_ethernet_policy(data, policy); +- break; +- case CONNMAN_TYPE_WIFI: +- update_wifi_policy(data, policy); +- break; +- default: +- break; +- } +-} +- +-static void update_config(struct config_data *data) +-{ +- GtkTreeIter iter; +- guint type; +- gchar *network; +- +- if (gtk_tree_model_get_iter_from_string(data->model, +- &iter, data->index) == FALSE) +- return; +- +- gtk_tree_model_get(data->model, &iter, +- CONNMAN_COLUMN_TYPE, &type, +- CONNMAN_COLUMN_NAME, &network, -1); +- +- g_free(network); +-} +- +-static void advanced_callback(GtkWidget *button, gpointer user_data) +-{ +- struct config_data *data = user_data; +- +- gtk_widget_show_all(data->dialog); + } + + static struct config_data *create_config(GtkTreeModel *model, +- GtkTreeIter *iter, gpointer user_data) ++ GtkTreeIter *iter, gpointer user_data) + { + GtkWidget *mainbox; + GtkWidget *label; + GtkWidget *hbox; +- GtkWidget *button; + struct config_data *data; + DBusGProxy *proxy; +- guint type, policy; +- gboolean inrange; +- gchar *markup, *vendor = NULL, *product = NULL; +- gchar *network = NULL, *address = NULL; ++ guint type; ++ gchar *vendor = NULL, *product = NULL; ++ gchar *address = NULL, *state = NULL; + + data = g_try_new0(struct config_data, 1); + if (data == NULL) +@@ -137,14 +89,16 @@ static struct config_data *create_config(GtkTreeModel *model, + data->client = client; + + gtk_tree_model_get(model, iter, +- CONNMAN_COLUMN_PROXY, &proxy, +- CONNMAN_COLUMN_TYPE, &type, +- CONNMAN_COLUMN_INRANGE, &inrange, +- CONNMAN_COLUMN_NETWORK, &network, +- CONNMAN_COLUMN_ADDRESS, &address, +- CONNMAN_COLUMN_POLICY, &policy, -1); ++ CONNMAN_COLUMN_PROXY, &proxy, ++ CONNMAN_COLUMN_TYPE, &type, ++ CONNMAN_COLUMN_ADDRESS, &address, ++ CONNMAN_COLUMN_STATE, &state, ++ -1); + + data->device = g_strdup(dbus_g_proxy_get_path(proxy)); ++ data->model = model; ++ data->index = gtk_tree_model_get_string_from_iter(model, iter); ++ + g_object_unref(proxy); + + mainbox = gtk_vbox_new(FALSE, 6); +@@ -163,12 +117,14 @@ static struct config_data *create_config(GtkTreeModel *model, + gtk_box_pack_start(GTK_BOX(mainbox), label, FALSE, FALSE, 0); + data->label = label; + ++ data->window = user_data; ++ + switch (type) { + case CONNMAN_TYPE_ETHERNET: +- add_ethernet_policy(mainbox, data); ++ add_ethernet_policy(mainbox, iter, data); + break; + case CONNMAN_TYPE_WIFI: +- add_wifi_policy(mainbox, data); ++ add_wifi_policy(mainbox, iter, data); + break; + default: + break; +@@ -183,32 +139,12 @@ static struct config_data *create_config(GtkTreeModel *model, + gtk_misc_set_alignment(GTK_MISC(label), 0.0, 1.0); + gtk_box_pack_start(GTK_BOX(hbox), label, TRUE, TRUE, 0); + +- markup = g_strdup_printf("%s\n<small>%s</small>", +- vendor ? vendor : "", product ? product : ""); +- gtk_label_set_markup(GTK_LABEL(label), markup); +- g_free(markup); +- +- if (0) { +- button = gtk_button_new_with_label(_("Advanced...")); +- gtk_box_pack_start(GTK_BOX(hbox), button, FALSE, FALSE, 0); +- g_signal_connect(G_OBJECT(button), "clicked", +- G_CALLBACK(advanced_callback), data); +- data->button = button; +- } +- +- data->window = user_data; +- create_advanced_dialog(data, type); +- +- update_status(data, type, inrange, policy, network, address); +- +- g_free(network); + g_free(address); + +- data->model = model; +- data->index = gtk_tree_model_get_string_from_iter(model, iter); +- + gtk_widget_show_all(mainbox); + ++ g_signal_connect(G_OBJECT(model), "row-changed", ++ G_CALLBACK(get_state_realtime), data); + g_free(product); + g_free(vendor); + +@@ -230,67 +166,56 @@ static void select_callback(GtkTreeSelection *selection, gpointer user_data) + return; + } + +- if (data == NULL) { +- data = create_config(model, &iter, user_data); +- if (data == NULL) +- return; +- +- page = gtk_notebook_append_page(GTK_NOTEBOOK(notebook), +- data->widget, NULL); +- } else { +- update_config(data); +- +- page = gtk_notebook_page_num(GTK_NOTEBOOK(notebook), +- data->widget); +- } ++ data = create_config(model, &iter, user_data); ++ if (data == NULL) ++ return; + ++ page = gtk_notebook_append_page(GTK_NOTEBOOK(notebook), ++ data->widget, NULL); + gtk_notebook_set_current_page(GTK_NOTEBOOK(notebook), page); + + gtk_widget_show(notebook); + } + +-static void row_changed(GtkTreeModel *model, GtkTreePath *path, +- GtkTreeIter *iter, gpointer user_data) +-{ +- guint type; +- gboolean powered, inrange; +- +- gtk_tree_model_get(model, iter, CONNMAN_COLUMN_TYPE, &type, +- CONNMAN_COLUMN_ENABLED, &powered, +- CONNMAN_COLUMN_INRANGE, &inrange, -1); +-} +- +-static void state_to_icon(GtkTreeViewColumn *column, GtkCellRenderer *cell, +- GtkTreeModel *model, GtkTreeIter *iter, gpointer data) ++static void strength_to_icon(GtkTreeViewColumn *column, GtkCellRenderer *cell, ++ GtkTreeModel *model, GtkTreeIter *iter, gpointer data) + { +- gboolean inrange; +- +- gtk_tree_model_get(model, iter, CONNMAN_COLUMN_INRANGE, &inrange, -1); +- +- if (inrange == TRUE) +- g_object_set(cell, "icon-name", GTK_STOCK_YES, NULL); +- else +- g_object_set(cell, "icon-name", NULL, NULL); ++ GdkPixbuf *pix; ++ guint strength, type; ++ gchar *name; ++ ++ gtk_tree_model_get(model, iter, CONNMAN_COLUMN_STRENGTH, &strength, ++ CONNMAN_COLUMN_TYPE, &type, ++ -1); ++ ++ if (type == CONNMAN_TYPE_WIFI) { ++ name = (gchar *)g_strdup_printf("%s/connman-signal-0%d.png", ++ ICONDIR, (strength-1)/20+1); ++ pix = gdk_pixbuf_new_from_file(name, NULL); ++ g_object_set(cell, "pixbuf", pix, NULL); ++ } else ++ g_object_set(cell, "pixbuf", NULL, NULL); + } + +-static void type_to_text(GtkTreeViewColumn *column, GtkCellRenderer *cell, +- GtkTreeModel *model, GtkTreeIter *iter, gpointer data) ++static void device_to_text(GtkTreeViewColumn *column, GtkCellRenderer *cell, ++ GtkTreeModel *model, GtkTreeIter *iter, gpointer data) + { + guint type; +- gboolean powered, inrange; +- gchar *markup; +- const char *title, *info; ++ gchar *markup, *name, *state; ++ const char *title; + + gtk_tree_model_get(model, iter, CONNMAN_COLUMN_TYPE, &type, +- CONNMAN_COLUMN_ENABLED, &powered, +- CONNMAN_COLUMN_INRANGE, &inrange, -1); ++ CONNMAN_COLUMN_NAME, &name, ++ CONNMAN_COLUMN_STATE, &state, ++ -1); + + switch (type) { + case CONNMAN_TYPE_ETHERNET: + title = N_("Ethernet"); + break; + case CONNMAN_TYPE_WIFI: +- title = N_("Wireless"); ++ /* Show the AP name */ ++ title = N_(name); + break; + case CONNMAN_TYPE_WIMAX: + title = N_("WiMAX"); +@@ -303,21 +228,27 @@ static void type_to_text(GtkTreeViewColumn *column, GtkCellRenderer *cell, + break; + } + +- if (powered == TRUE) { +- if (inrange == TRUE) +- info = N_("Connected"); ++ /* Set wifi connection status. */ ++ if (type == CONNMAN_TYPE_WIFI) { ++ if (g_str_equal(state, "association") == TRUE) ++ state = "associating..."; ++ else if (g_str_equal(state, "configuration") == TRUE) ++ state = "configurating..."; ++ else if (g_str_equal(state, "ready") == TRUE || ++ g_str_equal(state, "online") == TRUE) ++ state = "connnected"; + else +- info = N_("Not Connected"); ++ state = ""; ++ markup = g_strdup_printf("<b>%s</b>\n%s\n", title, state); + } else +- info = N_("Disabled"); ++ markup = g_strdup_printf("<b>%s</b>\n", title); + +- markup = g_strdup_printf("<b>%s</b>\n<small>%s</small>", title, info); + g_object_set(cell, "markup", markup, NULL); + g_free(markup); + } + + static void type_to_icon(GtkTreeViewColumn *column, GtkCellRenderer *cell, +- GtkTreeModel *model, GtkTreeIter *iter, gpointer data) ++ GtkTreeModel *model, GtkTreeIter *iter, gpointer data) + { + guint type; + +@@ -326,16 +257,16 @@ static void type_to_icon(GtkTreeViewColumn *column, GtkCellRenderer *cell, + switch (type) { + case CONNMAN_TYPE_ETHERNET: + g_object_set(cell, "icon-name", "network-wired", +- "stock-size", 5, NULL); ++ "stock-size", 5, NULL); + break; + case CONNMAN_TYPE_WIFI: + case CONNMAN_TYPE_WIMAX: + g_object_set(cell, "icon-name", "network-wireless", +- "stock-size", 5, NULL); ++ "stock-size", 5, NULL); + break; + case CONNMAN_TYPE_BLUETOOTH: + g_object_set(cell, "icon-name", "bluetooth", +- "stock-size", 5, NULL); ++ "stock-size", 5, NULL); + break; + default: + g_object_set(cell, "icon-name", NULL, NULL); +@@ -362,9 +293,9 @@ static GtkWidget *create_interfaces(GtkWidget *window) + + scrolled = gtk_scrolled_window_new(NULL, NULL); + gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scrolled), +- GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC); ++ GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC); + gtk_scrolled_window_set_shadow_type(GTK_SCROLLED_WINDOW(scrolled), +- GTK_SHADOW_OUT); ++ GTK_SHADOW_OUT); + gtk_box_pack_start(GTK_BOX(hbox), scrolled, FALSE, TRUE, 0); + + tree = gtk_tree_view_new(); +@@ -381,21 +312,19 @@ static GtkWidget *create_interfaces(GtkWidget *window) + gtk_tree_view_append_column(GTK_TREE_VIEW(tree), column); + + renderer = gtk_cell_renderer_pixbuf_new(); +- gtk_cell_renderer_set_fixed_size(renderer, 20, 45); + gtk_tree_view_column_pack_start(column, renderer, FALSE); + gtk_tree_view_column_set_cell_data_func(column, renderer, +- state_to_icon, NULL, NULL); +- +- renderer = gtk_cell_renderer_text_new(); +- gtk_tree_view_column_pack_start(column, renderer, TRUE); +- gtk_tree_view_column_set_cell_data_func(column, renderer, +- type_to_text, NULL, NULL); ++ strength_to_icon, NULL, NULL); + + renderer = gtk_cell_renderer_pixbuf_new(); +- gtk_tree_view_column_pack_end(column, renderer, FALSE); ++ gtk_tree_view_column_pack_start(column, renderer, FALSE); + gtk_tree_view_column_set_cell_data_func(column, renderer, +- type_to_icon, NULL, NULL); ++ type_to_icon, NULL, NULL); + ++ renderer = gtk_cell_renderer_text_new(); ++ gtk_tree_view_column_pack_start(column, renderer, FALSE); ++ gtk_tree_view_column_set_cell_data_func(column, renderer, ++ device_to_text, NULL, NULL); + + interface_notebook = gtk_notebook_new(); + gtk_notebook_set_show_tabs(GTK_NOTEBOOK(interface_notebook), FALSE); +@@ -410,16 +339,13 @@ static GtkWidget *create_interfaces(GtkWidget *window) + selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(tree)); + gtk_tree_selection_set_mode(selection, GTK_SELECTION_SINGLE); + g_signal_connect(G_OBJECT(selection), "changed", +- G_CALLBACK(select_callback), window); +- +- g_signal_connect(G_OBJECT(model), "row-changed", +- G_CALLBACK(row_changed), selection); ++ G_CALLBACK(select_callback), window); + + return mainbox; + } + + static gboolean delete_callback(GtkWidget *window, GdkEvent *event, +- gpointer user_data) ++ gpointer user_data) + { + gtk_widget_destroy(window); + +@@ -451,7 +377,7 @@ static GtkWidget *create_window(void) + gtk_window_set_position(GTK_WINDOW(window), GTK_WIN_POS_CENTER); + gtk_window_set_default_size(GTK_WINDOW(window), 580, 380); + g_signal_connect(G_OBJECT(window), "delete-event", +- G_CALLBACK(delete_callback), NULL); ++ G_CALLBACK(delete_callback), NULL); + + vbox = gtk_vbox_new(FALSE, 12); + gtk_container_set_border_width(GTK_CONTAINER(vbox), 12); +@@ -467,12 +393,12 @@ static GtkWidget *create_window(void) + button = gtk_button_new_from_stock(GTK_STOCK_CLOSE); + gtk_container_add(GTK_CONTAINER(buttonbox), button); + g_signal_connect(G_OBJECT(button), "clicked", +- G_CALLBACK(close_callback), window); ++ G_CALLBACK(close_callback), window); + + widget = create_interfaces(window); + gtk_notebook_prepend_page(GTK_NOTEBOOK(notebook), widget, NULL); + gtk_notebook_set_tab_label_text(GTK_NOTEBOOK(notebook), +- widget, _("Devices")); ++ widget, _("Services")); + + gtk_widget_show_all(window); + +diff --git a/properties/wifi.c b/properties/wifi.c +index 320dce4..3d3cee8 100644 +--- a/properties/wifi.c ++++ b/properties/wifi.c +@@ -23,6 +23,7 @@ + #include <config.h> + #endif + ++#include <dbus/dbus-glib.h> + #include <glib/gi18n.h> + #include <gtk/gtk.h> + +@@ -30,6 +31,24 @@ + + #include "advanced.h" + ++static void update_wifi_ipv4(struct config_data *data, guint policy); ++ ++static gboolean separator_function(GtkTreeModel *model, ++ GtkTreeIter *iter, gpointer user_data) ++{ ++ gchar *text; ++ gboolean result = FALSE; ++ ++ gtk_tree_model_get(model, iter, 0, &text, -1); ++ ++ if (text && *text == '\0') ++ result = TRUE; ++ ++ g_free(text); ++ ++ return result; ++} ++ + static void changed_callback(GtkWidget *editable, gpointer user_data) + { + struct config_data *data = user_data; +@@ -37,98 +56,310 @@ static void changed_callback(GtkWidget *editable, gpointer user_data) + + active = gtk_combo_box_get_active(GTK_COMBO_BOX(data->policy.config)); + +- switch (active) { +- case 0: +- connman_client_set_policy(data->client, data->device, "auto"); +- update_wifi_policy(data, CONNMAN_POLICY_AUTO); +- break; +- case 1: +- connman_client_set_policy(data->client, data->device, "manual"); +- update_wifi_policy(data, CONNMAN_POLICY_MANUAL); +- break; +- case 3: +- connman_client_set_policy(data->client, data->device, "off"); +- update_wifi_policy(data, CONNMAN_POLICY_OFF); +- break; ++ update_wifi_ipv4(data, active); ++} ++ ++static void connect_reply_cb(DBusGProxy *proxy, GError *error, ++ gpointer user_data) ++{ ++ struct config_data *data = user_data; ++ if (error) ++ { ++ gtk_label_set_text(GTK_LABEL(data->wifi.connect_info), ++ _("connection failed")); ++ gtk_widget_show(data->wifi.connect_info); ++ gtk_widget_show(data->wifi.connect); ++ gtk_widget_hide(data->wifi.disconnect); ++ data->connecting = 0; ++ g_error_free(error); ++ } ++} ++ ++static void connect_callback(GtkWidget *editable, gpointer user_data) ++{ ++ struct config_data *data = user_data; ++ ++ const gchar *passphrase; ++ ++ gboolean ret; ++ gint active; ++ ++ gtk_widget_hide(data->wifi.connect); ++ gtk_widget_show(data->wifi.disconnect); ++ ++ data->connecting = 1; ++ ++ if (data->wifi.passphrase) { ++ passphrase = gtk_entry_get_text(GTK_ENTRY(data->wifi.passphrase)); ++ ret = connman_client_set_passphrase(data->client, data->device, ++ passphrase); ++ } ++ ++ connman_client_connect_async(data->client, data->device, connect_reply_cb, data); ++ ++ active = gtk_combo_box_get_active(GTK_COMBO_BOX(data->policy.config)); ++ data->ipv4_config.method = active ? "manual" : "dhcp"; ++ data->ipv4_config.address = active ? gtk_entry_get_text(GTK_ENTRY(data->ipv4.entry[0])) : NULL; ++ data->ipv4_config.netmask = active ? gtk_entry_get_text(GTK_ENTRY(data->ipv4.entry[1])) : NULL; ++ data->ipv4_config.gateway = active ? gtk_entry_get_text(GTK_ENTRY(data->ipv4.entry[2])) : NULL; ++ ++ connman_client_set_ipv4(data->client, data->device, &data->ipv4_config); ++ ++} ++ ++static void disconnect_callback(GtkWidget *editable, gpointer user_data) ++{ ++ struct config_data *data = user_data; ++ gboolean ret; ++ ++ data->connecting = 0; ++ ++ ret = connman_client_disconnect(data->client, data->device); ++ if (ret == TRUE) { ++ gtk_widget_show(data->wifi.connect); ++ gtk_widget_hide(data->wifi.disconnect); + } + } + +-void add_wifi_policy(GtkWidget *mainbox, struct config_data *data) ++static void wifi_ipconfig(GtkWidget *table, struct config_data *data, GtkTreeIter *iter) + { + GtkWidget *vbox; +- GtkWidget *table; ++ GtkWidget *dialog; ++ GtkWidget *entry; + GtkWidget *label; + GtkWidget *combo; ++ GtkWidget *buttonbox; ++ GtkWidget *button; ++ DBusGProxy *proxy; + +- vbox = gtk_vbox_new(FALSE, 0); +- gtk_container_set_border_width(GTK_CONTAINER(vbox), 24); +- gtk_box_pack_start(GTK_BOX(mainbox), vbox, FALSE, FALSE, 0); ++ struct ipv4_config ipv4_config = { ++ .method = NULL, ++ .address = NULL, ++ .netmask = NULL, ++ .gateway = NULL, ++ }; + +- table = gtk_table_new(2, 4, FALSE); +- gtk_table_set_row_spacings(GTK_TABLE(table), 8); +- gtk_table_set_col_spacings(GTK_TABLE(table), 8); +- gtk_box_pack_start(GTK_BOX(vbox), table, FALSE, FALSE, 0); ++ gtk_tree_model_get(data->model, iter, ++ CONNMAN_COLUMN_PROXY, &proxy, ++ CONNMAN_COLUMN_METHOD, &ipv4_config.method, ++ CONNMAN_COLUMN_ADDRESS, &ipv4_config.address, ++ CONNMAN_COLUMN_NETMASK, &ipv4_config.netmask, ++ CONNMAN_COLUMN_GATEWAY, &ipv4_config.gateway, ++ -1); + +-#if 0 +- label = gtk_label_new(_("Network Name:")); +- gtk_label_set_justify(GTK_LABEL(label), GTK_JUSTIFY_RIGHT); +- gtk_misc_set_alignment(GTK_MISC(label), 1.0, 0.5); +- gtk_table_attach_defaults(GTK_TABLE(table), label, 0, 1, 0, 1); ++ label = gtk_label_new(_("Configuration:")); ++ gtk_table_attach_defaults(GTK_TABLE(table), label, 1, 2, 3, 4); ++// gtk_label_set_justify(GTK_LABEL(label), GTK_JUSTIFY_LEFT); ++// gtk_misc_set_alignment(GTK_MISC(label), 0.0, 0.0); ++ data->ipv4.label[0] = label; + + combo = gtk_combo_box_new_text(); +- gtk_combo_box_append_text(GTK_COMBO_BOX(combo), "Guest"); +- gtk_combo_box_append_text(GTK_COMBO_BOX(combo), ""); +- gtk_combo_box_append_text(GTK_COMBO_BOX(combo), "Off"); ++ gtk_combo_box_append_text(GTK_COMBO_BOX(combo), "DHCP"); ++ gtk_combo_box_append_text(GTK_COMBO_BOX(combo), "Manual"); + gtk_combo_box_set_row_separator_func(GTK_COMBO_BOX(combo), +- separator_function, NULL, NULL); +- gtk_table_attach_defaults(GTK_TABLE(table), combo, 1, 4, 0, 1); ++ separator_function, NULL, NULL); ++ ++ gtk_table_attach_defaults(GTK_TABLE(table), combo, 2, 4, 3, 4); + data->policy.config = combo; +-#endif + +- label = gtk_label_new(_("Configuration:")); +- gtk_label_set_justify(GTK_LABEL(label), GTK_JUSTIFY_RIGHT); +- gtk_misc_set_alignment(GTK_MISC(label), 1.0, 0.5); +- gtk_table_attach_defaults(GTK_TABLE(table), label, 0, 1, 0, 1); ++ label = gtk_label_new(_("IP address:")); ++ gtk_table_attach_defaults(GTK_TABLE(table), label, 1, 2, 4, 5); ++// gtk_label_set_justify(GTK_LABEL(label), GTK_JUSTIFY_LEFT); ++// gtk_misc_set_alignment(GTK_MISC(label), 0.0, 0.0); ++ data->ipv4.label[0] = label; + +- combo = gtk_combo_box_new_text(); +- gtk_combo_box_append_text(GTK_COMBO_BOX(combo), "Automatically"); +- gtk_combo_box_append_text(GTK_COMBO_BOX(combo), "Manually"); +- gtk_combo_box_append_text(GTK_COMBO_BOX(combo), ""); +- gtk_combo_box_append_text(GTK_COMBO_BOX(combo), "Off"); +- gtk_combo_box_set_row_separator_func(GTK_COMBO_BOX(combo), +- separator_function, NULL, NULL); +- gtk_table_attach_defaults(GTK_TABLE(table), combo, 1, 4, 0, 1); +- data->policy.config = combo; ++ entry = gtk_entry_new(); ++ gtk_entry_set_max_length (GTK_ENTRY (entry), 15); ++ if (ipv4_config.address) ++ gtk_entry_set_text(GTK_ENTRY(entry), ipv4_config.address); ++ gtk_table_attach_defaults(GTK_TABLE(table), entry, 2, 4, 4, 5); ++ data->ipv4.entry[0] = entry; ++ ++ label = gtk_label_new(_("Netmask:")); ++ gtk_table_attach_defaults(GTK_TABLE(table), label, 1, 2, 5, 6); ++// gtk_label_set_justify(GTK_LABEL(label), GTK_JUSTIFY_LEFT); ++// gtk_misc_set_alignment(GTK_MISC(label), 0.0, 0.0); ++ data->ipv4.label[1] = label; + +- label = gtk_label_new(NULL); +- gtk_label_set_line_wrap(GTK_LABEL(label), TRUE); ++ entry = gtk_entry_new(); ++ gtk_entry_set_max_length (GTK_ENTRY (entry), 15); ++ if (ipv4_config.netmask) ++ gtk_entry_set_text(GTK_ENTRY(entry), ipv4_config.netmask); ++ gtk_table_attach_defaults(GTK_TABLE(table), entry, 2, 4, 5, 6); ++ data->ipv4.entry[1] = entry; ++ ++ label = gtk_label_new(_("Gateway:")); ++ gtk_table_attach_defaults(GTK_TABLE(table), label, 1, 2, 6, 7); ++// gtk_label_set_justify(GTK_LABEL(label), GTK_JUSTIFY_LEFT); ++// gtk_misc_set_alignment(GTK_MISC(label), 0.0, 0.0); ++ data->ipv4.label[2] = label; ++ ++ entry = gtk_entry_new(); ++ gtk_entry_set_max_length (GTK_ENTRY (entry), 15); ++ if (ipv4_config.gateway) ++ gtk_entry_set_text(GTK_ENTRY(entry), ipv4_config.gateway); ++ gtk_table_attach_defaults(GTK_TABLE(table), entry, 2, 4, 6, 7); ++ data->ipv4.entry[2] = entry; ++ ++ data->ipv4_config = ipv4_config; ++ ++ if (g_str_equal(ipv4_config.method, "dhcp") == TRUE) ++ update_wifi_ipv4(data, CONNMAN_POLICY_DHCP); ++ else ++ update_wifi_ipv4(data, CONNMAN_POLICY_MANUAL); ++ ++ g_signal_connect(G_OBJECT(combo), "changed", ++ G_CALLBACK(changed_callback), data); ++} ++ ++static void toggled_callback(GtkWidget *button, gpointer user_data) ++{ ++ GtkWidget *entry = user_data; ++ gboolean mode; ++ ++ mode = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(button)); ++ ++ gtk_entry_set_visibility(GTK_ENTRY(entry), mode); ++} ++ ++void add_wifi_policy(GtkWidget *mainbox, GtkTreeIter *iter, struct config_data *data) ++{ ++ GtkWidget *vbox; ++ GtkWidget *table; ++ GtkWidget *label; ++ GtkWidget *entry; ++ GtkWidget *button; ++ ++ const gchar *name, *security, *icon, *state; ++ guint strength; ++ ++ gtk_tree_model_get(data->model, iter, ++ CONNMAN_COLUMN_NAME, &name, ++ CONNMAN_COLUMN_SECURITY, &security, ++ CONNMAN_COLUMN_ICON, &icon, ++ CONNMAN_COLUMN_STATE, &state, ++ CONNMAN_COLUMN_STRENGTH, &strength, ++ -1); ++ ++ vbox = gtk_vbox_new(TRUE, 0); ++ gtk_container_set_border_width(GTK_CONTAINER(vbox), 24); ++ gtk_box_pack_start(GTK_BOX(mainbox), vbox, FALSE, FALSE, 0); ++ ++ table = gtk_table_new(10, 5, TRUE); ++ gtk_box_pack_start(GTK_BOX(vbox), table, FALSE, FALSE, 0); ++ data->table = table; ++ ++ label = gtk_label_new(_("Access Point:")); ++ gtk_table_attach_defaults(GTK_TABLE(table), label, 1, 2, 0, 1); ++// gtk_label_set_justify(GTK_LABEL(label), GTK_JUSTIFY_LEFT); ++// gtk_misc_set_alignment(GTK_MISC(label), 0.0, 0.0); ++ ++ label = gtk_label_new(_(name)); ++ gtk_table_attach_defaults(GTK_TABLE(table), label, 2, 4, 0, 1); ++ gtk_label_set_justify(GTK_LABEL(label), GTK_JUSTIFY_LEFT); ++ gtk_misc_set_alignment(GTK_MISC(label), 0.0, 0.5); ++ data->wifi.name = label; ++ ++ label = gtk_label_new(_("Security:")); ++ gtk_table_attach_defaults(GTK_TABLE(table), label, 1, 2, 1, 2); ++// gtk_label_set_justify(GTK_LABEL(label), GTK_JUSTIFY_LEFT); ++// gtk_misc_set_alignment(GTK_MISC(label), 0.0, 0.0); ++ ++ label = gtk_label_new(_(security)); ++ gtk_table_attach_defaults(GTK_TABLE(table), label, 2, 4, 1, 2); + gtk_label_set_justify(GTK_LABEL(label), GTK_JUSTIFY_LEFT); ++ gtk_misc_set_alignment(GTK_MISC(label), 0.0, 0.5); ++ data->wifi.security = label; ++ ++ label = gtk_label_new(_("Passphrase:")); ++ gtk_table_attach_defaults(GTK_TABLE(table), label, 1, 2, 2, 3); ++// gtk_label_set_justify(GTK_LABEL(label), GTK_JUSTIFY_LEFT); ++// gtk_misc_set_alignment(GTK_MISC(label), 0.0, 0.0); ++ ++ ++ if (g_str_equal(security, "none") != TRUE && ++ g_str_equal(security, "unknown") != TRUE) { ++ entry = gtk_entry_new(); ++ gtk_entry_set_max_length (GTK_ENTRY (entry), 64); ++ gtk_table_attach_defaults(GTK_TABLE(table), entry, 2, 4, 2, 3); ++ gtk_entry_set_visibility(GTK_ENTRY(entry), 0); ++ data->wifi.passphrase = entry; ++ ++ button = gtk_check_button_new_with_label(_("Show input")); ++ gtk_table_attach_defaults(GTK_TABLE(table), button, 4, 5, 2, 3); ++ ++ g_signal_connect(G_OBJECT(button), "toggled", ++ G_CALLBACK(toggled_callback), entry); ++ ++ ++ } else { ++ label = gtk_label_new(_("none")); ++ gtk_table_attach_defaults(GTK_TABLE(table), label, 2, 4, 2, 3); ++ gtk_label_set_justify(GTK_LABEL(label), GTK_JUSTIFY_LEFT); ++ gtk_misc_set_alignment(GTK_MISC(label), 0.0, 0.5); ++ data->wifi.passphrase = NULL; ++ } ++ ++ label = gtk_label_new(_("")); ++ gtk_table_attach_defaults(GTK_TABLE(table), label, 2, 3, 8, 9); + gtk_misc_set_alignment(GTK_MISC(label), 0.0, 0.0); +- gtk_table_attach_defaults(GTK_TABLE(table), label, 1, 4, 1, 2); +- gtk_widget_set_size_request(label, 180, -1); +- data->policy.label = label; ++ gtk_widget_hide(label); ++ data->wifi.connect_info = label; ++ ++ button = gtk_button_new_with_label(_("Connect")); ++ gtk_table_attach_defaults(GTK_TABLE(table), button, 3, 4, 8, 9); ++ g_signal_connect(G_OBJECT(button), "clicked", ++ G_CALLBACK(connect_callback), data); ++ gtk_widget_set_no_show_all(button, TRUE); ++ data->wifi.connect = button; ++ ++ button = gtk_button_new_with_label(_("Disconnect")); ++ gtk_table_attach_defaults(GTK_TABLE(table), button, 3, 4, 8, 9); ++ g_signal_connect(G_OBJECT(button), "clicked", ++ G_CALLBACK(disconnect_callback), data); ++ data->wifi.disconnect = button; ++ gtk_widget_set_no_show_all(button, TRUE); ++ ++ if (g_str_equal(state, "failure") == TRUE ++ || g_str_equal(state, "idle") == TRUE) { ++ gtk_widget_show(data->wifi.connect); ++ gtk_widget_hide(data->wifi.disconnect); ++ } else { ++ gtk_widget_hide(data->wifi.connect); ++ gtk_widget_show(data->wifi.disconnect); ++ } ++ ++ wifi_ipconfig(table, data, iter); + +- g_signal_connect(G_OBJECT(combo), "changed", +- G_CALLBACK(changed_callback), data); + } + +-void update_wifi_policy(struct config_data *data, guint policy) ++void update_wifi_ipv4(struct config_data *data, guint policy) + { + GtkWidget *combo = data->policy.config; ++ GtkWidget *entry[3]; + gchar *info = NULL; ++ int i; ++ ++ for (i = 0; i < 3; i++) ++ entry[i] = data->ipv4.entry[i]; + + g_signal_handlers_block_by_func(G_OBJECT(combo), +- G_CALLBACK(changed_callback), data); ++ G_CALLBACK(changed_callback), data); + + switch (policy) { +- case CONNMAN_POLICY_OFF: +- gtk_combo_box_set_active(GTK_COMBO_BOX(combo), 3); ++ case CONNMAN_POLICY_DHCP: ++ gtk_combo_box_set_active(GTK_COMBO_BOX(combo), 0); ++ for (i = 0; i < 3; i++) { ++ gtk_entry_set_editable(GTK_ENTRY(entry[i]), 0); ++ gtk_widget_set_sensitive(entry[i], 0); ++ } + break; + case CONNMAN_POLICY_MANUAL: + gtk_combo_box_set_active(GTK_COMBO_BOX(combo), 1); +- break; +- case CONNMAN_POLICY_AUTO: +- gtk_combo_box_set_active(GTK_COMBO_BOX(combo), 0); ++ for (i = 0; i < 3; i++) { ++ gtk_entry_set_editable(GTK_ENTRY(entry[i]), 1); ++ gtk_widget_set_sensitive(entry[i], 1); ++ } + break; + default: + gtk_combo_box_set_active(GTK_COMBO_BOX(combo), -1); +@@ -136,9 +367,7 @@ void update_wifi_policy(struct config_data *data, guint policy) + } + + g_signal_handlers_unblock_by_func(G_OBJECT(combo), +- G_CALLBACK(changed_callback), data); +- +- gtk_label_set_markup(GTK_LABEL(data->policy.label), info); ++ G_CALLBACK(changed_callback), data); + + g_free(info); + } diff --git a/meta/recipes-connectivity/connman/connman-gnome_0.5.bb b/meta/recipes-connectivity/connman/connman-gnome_0.5.bb new file mode 100644 index 000000000..6958ee57b --- /dev/null +++ b/meta/recipes-connectivity/connman/connman-gnome_0.5.bb @@ -0,0 +1,22 @@ +DESCRIPTION = "gtk frontend for connman" +HOMEPAGE = "http://connman.net/" +SECTION = "libs/network" +LICENSE = "GPLv2 & LGPLv2.1" +LIC_FILES_CHKSUM = "file://COPYING;md5=eb723b61539feef013de476e68b5c50a \ + file://properties/main.c;beginline=1;endline=20;md5=50c77c81871308b033ab7a1504626afb \ + file://common/connman-dbus.c;beginline=1;endline=20;md5=de6b485c0e717a0236402d220187717a" +DEPENDS = "gtk+ dbus" +PR = "r0" + +RRECOMMENDS_${PN} = "python python-dbus connman connman-plugin-ethernet connman-plugin-loopback connman-plugin-udhcp connman-plugin-wifi connman-plugin-fake connman-plugin-bluetooth connman-plugin-dnsproxy" + +SRC_URI = "http://www.kernel.org/pub/linux/network/connman/connman-gnome-${PV}.tar.gz \ + file://connman-gnome.patch \ + file://connman-applet.desktop" + +inherit autotools gtk-icon-cache + +do_install_append() { + install -d ${D}${datadir}/applications/ + install ${WORKDIR}/connman-applet.desktop ${D}${datadir}/applications/ +} diff --git a/meta/recipes-connectivity/connman/connman-gnome_git.bb b/meta/recipes-connectivity/connman/connman-gnome_git.bb deleted file mode 100644 index 440ba285c..000000000 --- a/meta/recipes-connectivity/connman/connman-gnome_git.bb +++ /dev/null @@ -1,9 +0,0 @@ - -SRC_URI = "git://git.kernel.org/pub/scm/network/connman/connman-gnome.git;protocol=git" -DEPENDS = "gtk+" -PV = "0.1+git${SRCPV}" -PR = "r0" - -S = "${WORKDIR}/git" - -inherit autotools diff --git a/meta/recipes-connectivity/connman/connman.inc b/meta/recipes-connectivity/connman/connman.inc index 9a623d7f4..c842d3cbf 100644 --- a/meta/recipes-connectivity/connman/connman.inc +++ b/meta/recipes-connectivity/connman/connman.inc @@ -1,17 +1,13 @@ -HOMEPAGE = "http://www.moblin.org/projects/projects_connman.php" -SUMMARY = "Moblin Connection Manager" -LICENSE = "GPL" +DESCRIPTION = "The ConnMan project provides a daemon for managing \ +internet connections within embedded devices running the Linux operating system" +HOMEPAGE = "http://connman.net/" +BUGTRACKER = "http://bugs.meego.com/buglist.cgi?quicksearch=connman" +LICENSE = "GPLv2" +LIC_FILES_CHKSUM = "file://COPYING;md5=12f884d2ae1ff87c09e5b7ccc2c4ca7e \ + file://src/main.c;beginline=1;endline=20;md5=4b55b550fa6b33cc2055ef30dd262b3e" DEPENDS = "libgdbus dbus glib-2.0 hal" -RDEPENDS_${PN} = "dhcp-client wpa-supplicant resolvconf" - -EXTRA_OECONF += " \ - --enable-ethernet=builtin --enable-wifi=builtin --enable-dhclient=builtin \ - --enable-bluetooth=builtin --enable-udev --enable-loopback=builtin \ - --enable-dnsproxy=builtin --enable-threads --enable-resolvconf=builtin \ - --enable-client --enable-fake --with-dhclient=/sbin/dhclient \ - --enable-test \ - ac_cv_path_WPASUPPLICANT=/usr/sbin/wpa_supplicant" +RDEPENDS_${PN} = "wpa-supplicant resolvconf" INITSCRIPT_NAME = "connman" INITSCRIPT_PARAMS = "start 05 5 2 . stop 22 0 1 6 ." @@ -39,5 +35,5 @@ FILES_${PN}-dbg += "${libdir}/connman/plugins/.debug \ python populate_packages_prepend() { plugin_dir = bb.data.expand('${libdir}/connman/plugins/', d) plugin_name = bb.data.expand('${PN}-plugin-%s', d) - do_split_packages(d, plugin_dir, '^lib(.*).so$', plugin_name, '${PN} plugin for %s', extra_depends='' ) -}
\ No newline at end of file + do_split_packages(d, plugin_dir, '^(.*).so$', plugin_name, '${PN} plugin for %s', extra_depends='' ) +} diff --git a/meta/recipes-connectivity/connman/connman_0.48.bb b/meta/recipes-connectivity/connman/connman_0.48.bb deleted file mode 100644 index 269f98721..000000000 --- a/meta/recipes-connectivity/connman/connman_0.48.bb +++ /dev/null @@ -1,7 +0,0 @@ -require connman.inc -PR = "r0" - -SRC_URI = "http://www.kernel.org/pub/linux/network/connman/${P}.tar.bz2 \ - file://dbusperms.patch \ - file://connman " - diff --git a/meta/recipes-connectivity/connman/connman_0.56.bb b/meta/recipes-connectivity/connman/connman_0.56.bb new file mode 100644 index 000000000..24ae536a7 --- /dev/null +++ b/meta/recipes-connectivity/connman/connman_0.56.bb @@ -0,0 +1,25 @@ +require connman.inc +PR = "r0" + +EXTRA_OECONF += "\ + ac_cv_path_WPASUPPLICANT=/usr/sbin/wpa_supplicant \ + --disable-gtk-doc \ + --enable-debug \ + --enable-threads \ + --enable-loopback \ + --enable-ethernet \ + --enable-wifi \ + --enable-bluetooth \ + --enable-dnsproxy \ + --disable-dhclient \ + --enable-test \ + --disable-udev \ + --disable-polkit \ + --enable-client \ + --enable-fake \ + --prefix=/usr --sysconfdir=/etc --localstatedir=/var" + +SRC_URI = "\ + http://www.kernel.org/pub/linux/network/connman/connman-${PV}.tar.gz \ + file://connman \ +" diff --git a/meta/recipes-connectivity/connman/files/connman-install-tests-d52de88aff4771283b2ebee4f48a7af15862d0ae.patch b/meta/recipes-connectivity/connman/files/connman-install-tests-d52de88aff4771283b2ebee4f48a7af15862d0ae.patch deleted file mode 100644 index 57df7196e..000000000 --- a/meta/recipes-connectivity/connman/files/connman-install-tests-d52de88aff4771283b2ebee4f48a7af15862d0ae.patch +++ /dev/null @@ -1,13 +0,0 @@ -Index: git/test/Makefile.am -=================================================================== ---- git.orig/test/Makefile.am 2009-05-21 12:07:39.000000000 +0100 -+++ git/test/Makefile.am 2009-05-21 17:29:33.000000000 +0100 -@@ -1,5 +1,7 @@ - --EXTRA_DIST = get-state list-profiles list-services \ -+testdir = $(pkgdatadir)/tests -+ -+test_SCRIPTS = get-state list-profiles list-services \ - list-connections select-connection \ - list-devices enable-device disable-device start-scanning \ - list-networks select-network disable-network create-network \ diff --git a/meta/recipes-connectivity/connman/files/connman-install-tests.patch b/meta/recipes-connectivity/connman/files/connman-install-tests.patch deleted file mode 100644 index 0ea3758f2..000000000 --- a/meta/recipes-connectivity/connman/files/connman-install-tests.patch +++ /dev/null @@ -1,15 +0,0 @@ -Index: git/Makefile.am -=================================================================== ---- git.orig/Makefile.am 2009-08-24 15:56:33.000000000 +0100 -+++ git/Makefile.am 2009-08-24 16:02:38.000000000 +0100 -@@ -115,7 +115,9 @@ - tools_wifi_scan_LDADD = @GLIB_LIBS@ @NETLINK_LIBS@ - endif - --EXTRA_DIST += test/get-state test/list-profiles test/list-services \ -+testdir = $(pkgdatadir)/tests -+ -+test_SCRIPTS = test/get-state test/list-profiles test/list-services \ - test/connect-service test/list-connections \ - test/select-connection test/list-devices test/enable-device \ - test/disable-device test/start-scanning test/list-networks \ diff --git a/meta/recipes-connectivity/connman/files/udevfix.patch b/meta/recipes-connectivity/connman/files/udevfix.patch deleted file mode 100644 index 803bec528..000000000 --- a/meta/recipes-connectivity/connman/files/udevfix.patch +++ /dev/null @@ -1,12 +0,0 @@ -Index: git/src/connman.rules -=================================================================== ---- git.orig/src/connman.rules 2009-05-25 14:24:53.000000000 +0100 -+++ git/src/connman.rules 2009-05-25 14:25:16.000000000 +0100 -@@ -3,6 +3,7 @@ - - SUBSYSTEM=="net", KERNEL=="eth*", ENV{CONNMAN_TYPE}="ethernet" - SUBSYSTEM=="net", KERNEL=="wlan*", ENV{CONNMAN_TYPE}="wifi" -+SUBSYSTEM=="net", KERNEL=="ra0", ENV{CONNMAN_TYPE}="wifi" - - SUBSYSTEM=="net", DRIVERS=="hso", ENV{CONNMAN_TYPE}="hso" - |