GNOME.org
 

[gnome-bluetooth] Tidy up the moblin panel by switching to using a GtkNotebook

commit cb90b37e3e931aac092e3429d17a2c7d2d2186a2
Author: Joshua Lock <josh linux intel com>
Date:   Fri Oct 2 16:56:44 2009 +0100

    Tidy up the moblin panel by switching to using a GtkNotebook
    
    Previously the moblin panel had many widgets as member variables and called
    show/hide a lot to change the UI. This was both messy and wrong, this
    commit switched the panel to using a GtkNotebook with a separate page for
    each state of the UI.
    
    https://bugzilla.gnome.org/show_bug.cgi?id=597130

 moblin/moblin-panel.c |  674 +++++++++++++++++++++++++++++--------------------
 1 files changed, 402 insertions(+), 272 deletions(-)
---
diff --git a/moblin/moblin-panel.c b/moblin/moblin-panel.c
index e3eba6d..057a24d 100644
--- a/moblin/moblin-panel.c
+++ b/moblin/moblin-panel.c
@@ -32,6 +32,7 @@
 #include <nbtk/nbtk-gtk.h>
 
 #include "bluetooth-client.h"
+#include "bluetooth-client-private.h"
 #include "bluetooth-chooser.h"
 #include "bluetooth-chooser-private.h"
 #include "bluetooth-killswitch.h"
@@ -56,30 +57,39 @@ struct _MoblinPanelPrivate
 	BluetoothKillswitch *killswitch;
 	BluetoothAgent *agent;
 
-	GtkWidget *device_list_frame;
-	GtkWidget *chooser;
 	GtkWidget *power_switch;
-	GtkWidget *power_label;
-	GtkWidget *filter;
-	GtkWidget *action_button;
-	GtkWidget *scan_label;
+	GtkWidget *notebook;
 	GtkTreeModel *chooser_model;
+
 	gboolean target_ssp;
 	gchar *pincode;
 	gboolean automatic_pincode;
 };
 
-static void set_scanning_view (GtkButton *button, gpointer   user_data);
-static void send_file_button_clicked_cb (GtkButton *button, gpointer   user_data);
-static void pin_options_button_clicked_cb (GtkButton *button, gpointer   user_data);
+#define CONNECT_TIMEOUT 3.0
+#define AGENT_PATH "/org/bluez/agent/wizard"
+
+typedef struct {
+	char *path;
+	GTimer *timer;
+	MoblinPanel *self;
+} ConnectData;
+
+enum {
+	PROPS_PAGE,
+	ADD_PAGE,
+	SETUP_PAGE,
+	MESSAGE_PAGE
+} MoblinPages;
 
 static void
 power_switch_toggled_cb (NbtkGtkLightSwitch *light_switch,
                          gpointer            user_data)
 {
+	g_assert (MOBLIN_IS_PANEL (user_data));
 	MoblinPanelPrivate *priv = MOBLIN_PANEL_GET_PRIVATE(user_data);
 
-	if (nbtk_gtk_light_switch_get_active (NBTK_GTK_LIGHT_SWITCH (light_switch))) {
+	if (nbtk_gtk_light_switch_get_active (NBTK_GTK_LIGHT_SWITCH (priv->power_switch))) {
 		bluetooth_killswitch_set_state (priv->killswitch, KILLSWITCH_STATE_UNBLOCKED);
 	} else {
 		bluetooth_killswitch_set_state (priv->killswitch, KILLSWITCH_STATE_SOFT_BLOCKED);
@@ -91,13 +101,9 @@ killswitch_state_changed_cb (BluetoothKillswitch *killswitch,
                              KillswitchState      state,
                              gpointer             user_data)
 {
-	MoblinPanel        *self = user_data;
-	MoblinPanelPrivate *priv = MOBLIN_PANEL_GET_PRIVATE (self);
-
-	g_signal_handlers_disconnect_by_func (priv->power_switch, power_switch_toggled_cb,
-                                        NULL);
+	MoblinPanelPrivate *priv = MOBLIN_PANEL_GET_PRIVATE (user_data);
 
-	g_return_if_fail (self != NULL);
+	g_signal_handlers_block_by_func (priv->power_switch, power_switch_toggled_cb, user_data);
 
 	if (state == KILLSWITCH_STATE_SOFT_BLOCKED) {
 		nbtk_gtk_light_switch_set_active (NBTK_GTK_LIGHT_SWITCH (priv->power_switch),
@@ -112,18 +118,17 @@ killswitch_state_changed_cb (BluetoothKillswitch *killswitch,
 		g_assert_not_reached ();
 	}
 
-	g_signal_connect (priv->power_switch, "switch-flipped", 
-			G_CALLBACK (power_switch_toggled_cb), self);
+	g_signal_handlers_unblock_by_func (priv->power_switch, power_switch_toggled_cb, user_data);
 }
 
 static void
 selected_device_changed_cb (BluetoothChooser *chooser, const char *address, gpointer data)
 {
-	MoblinPanel *self = MOBLIN_PANEL (data);
-	MoblinPanelPrivate *priv = MOBLIN_PANEL_GET_PRIVATE (self);
+	GtkWidget *send_button = GTK_WIDGET (data);
+
 	if (!address) {
-		gtk_widget_set_sensitive (priv->action_button, FALSE);	} else {
-		gtk_widget_set_sensitive (priv->action_button, TRUE);
+		gtk_widget_set_sensitive (send_button, FALSE);	} else {
+		gtk_widget_set_sensitive (send_button, TRUE);
 	}
 }
 
@@ -142,101 +147,17 @@ set_frame_title (GtkFrame *frame, gchar *title)
 }
 
 static void
-set_default_view (GtkButton *button, gpointer user_data)
-{
-	MoblinPanelPrivate *priv = MOBLIN_PANEL_GET_PRIVATE (user_data);
-
-	set_frame_title (GTK_FRAME (priv->device_list_frame), _("Devices"));
-
-	bluetooth_chooser_stop_discovery (BLUETOOTH_CHOOSER (priv->chooser));
-	g_object_set (priv->chooser, "show-searching", FALSE, "device-category-filter",
-	                BLUETOOTH_CATEGORY_PAIRED_OR_TRUSTED, NULL);
-
-	g_signal_handlers_disconnect_by_func (button, set_default_view, user_data);
-	gtk_button_set_label (button, _("Add a new device"));
-	g_signal_connect (button, "clicked", G_CALLBACK (set_scanning_view), user_data);
-	gtk_widget_show (priv->power_switch);
-	gtk_widget_show (priv->power_label);
-
-	g_signal_handlers_disconnect_by_func (priv->action_button, pin_options_button_clicked_cb,
-					      NULL);
-	gtk_button_set_label (GTK_BUTTON (priv->action_button), _("Send file from your computer"));
-	gtk_widget_show (priv->action_button);
-	g_signal_connect (priv->action_button, "clicked", G_CALLBACK (send_file_button_clicked_cb),
-                    NULL);
-	gtk_widget_hide (priv->scan_label);
-	g_signal_connect (priv->chooser, "selected-device-changed",
-			G_CALLBACK (selected_device_changed_cb), MOBLIN_PANEL (user_data));
-
-	gtk_widget_hide (priv->filter);
-}
-
-static void
-set_scanning_view (GtkButton *button, gpointer   user_data)
-{
-	MoblinPanelPrivate *priv = MOBLIN_PANEL_GET_PRIVATE (user_data);
-
-	set_frame_title (GTK_FRAME (priv->device_list_frame), _("Add a new Bluetooth device"));
-
-	g_object_set (priv->chooser, "show-searching", TRUE, "device-category-filter",
-                BLUETOOTH_CATEGORY_NOT_PAIRED_OR_TRUSTED, NULL);
-
-	g_signal_handlers_disconnect_by_func (button, set_scanning_view, user_data);
-        gtk_button_set_label (button, _("Back to devices"));
-	g_signal_connect (button, "clicked", G_CALLBACK (set_default_view),
-			  user_data);
-
-	bluetooth_chooser_start_discovery (BLUETOOTH_CHOOSER (priv->chooser));
-	gtk_widget_hide (priv->power_switch);
-	gtk_widget_hide (priv->power_label);
-
-	g_signal_handlers_disconnect_by_func (priv->action_button,
-					      send_file_button_clicked_cb, NULL);
-        g_signal_handlers_disconnect_by_func (priv->chooser, selected_device_changed_cb,
-					      MOBLIN_PANEL (user_data));
-	gtk_button_set_label (GTK_BUTTON (priv->action_button), _("PIN options"));
-	gtk_widget_show (priv->action_button);
-	g_signal_connect (priv->action_button, "clicked",
-                    G_CALLBACK (pin_options_button_clicked_cb), NULL);
-	gtk_widget_show (priv->scan_label);
-
-	gtk_widget_show (priv->filter);
-}
-
-#if 0
-static void
-set_pairing_view (MoblinPanel *self)
-{
-	MoblinPanelPrivate *priv = MOBLIN_PANEL_GET_PRIVATE (self);
-
-	set_frame_title (GTK_FRAME (priv->device_list_frame), _("Device setup"));
-
-	gtk_widget_hide (priv->chooser);
-
-	g_signal_handlers_disconnect_by_func (priv->action_button,
-					      send_file_button_clicked_cb, NULL);
-	g_signal_handlers_disconnect_by_func (priv->chooser, selected_device_changed_cb,
-					      self);
-	gtk_widget_hide (priv->action_button);
-
-	gtk_widget_hide (priv->scan_label);
-
-	gtk_widget_hide (priv->filter);
-}
-#endif
-static void
 send_file_button_clicked_cb (GtkButton *button,
                              gpointer   user_data)
 {
-	MoblinPanel *self = MOBLIN_PANEL (user_data);
-	MoblinPanelPrivate *priv = MOBLIN_PANEL_GET_PRIVATE (self);
+	BluetoothChooser *chooser = BLUETOOTH_CHOOSER (user_data);
 	GPtrArray *a;
 	GError *err = NULL;
 	guint i;
 	const char *address, *name;
 
-	address = bluetooth_chooser_get_selected_device (BLUETOOTH_CHOOSER (priv->chooser));
-	name = bluetooth_chooser_get_selected_device_name (BLUETOOTH_CHOOSER (priv->chooser));
+	address = bluetooth_chooser_get_selected_device (chooser);
+	name = bluetooth_chooser_get_selected_device_name (chooser);
 
 	a = g_ptr_array_new ();
 	g_ptr_array_add (a, "bluetooth-sendto");
@@ -276,14 +197,14 @@ pin_options_button_clicked_cb (GtkButton *button,
 static void
 remove_clicked_cb (GtkCellRenderer *cell, gchar *path, gpointer user_data)
 {
-	MoblinPanelPrivate *priv = MOBLIN_PANEL_GET_PRIVATE (user_data);
+	BluetoothChooser *chooser = BLUETOOTH_CHOOSER (user_data);
 	GtkTreeView *view;
 	gchar *address = NULL;
 	GtkTreeSelection *selection;
 	GtkTreeIter iter;
 	GtkTreePath *tree_path;
 
-	view = GTK_TREE_VIEW (bluetooth_chooser_get_treeview (BLUETOOTH_CHOOSER (priv->chooser)));
+	view = GTK_TREE_VIEW (bluetooth_chooser_get_treeview (chooser));
 
 	/* Set selection */
 	tree_path = gtk_tree_path_new_from_string (path);
@@ -294,17 +215,10 @@ remove_clicked_cb (GtkCellRenderer *cell, gchar *path, gpointer user_data)
 	if (gtk_tree_selection_get_selected (selection, NULL, &iter) == FALSE)
 		return;
 
-	if (bluetooth_chooser_remove_selected_device (BLUETOOTH_CHOOSER (priv->chooser)) != FALSE)
+	if (bluetooth_chooser_remove_selected_device (chooser) != FALSE)
 		bluetooth_plugin_manager_device_deleted (address);
 }
-
 #if 0
-static void
-set_pin_view (MoblinPanel *self)
-{
-	g_debug ("Show PIN");
-}
-
 static gboolean
 pincode_callback (DBusGMethodInvocation *context,
 		  DBusGProxy *device,
@@ -314,70 +228,117 @@ pincode_callback (DBusGMethodInvocation *context,
 	MoblinPanelPrivate *priv = MOBLIN_PANEL_GET_PRIVATE (self);
 	priv->target_ssp = FALSE;
 	if (priv->automatic_pincode == FALSE)
-		set_pin_view (self);
+		gtk_notebook_set_current_page (GTK_NOTEBOOK (priv->notebook), SETUP_PAGE);
 	dbus_g_method_return (context, priv->pincode);
 	return TRUE;
 }
 #endif
 static void
-activity_clicked (GtkCellRenderer *renderer, const gchar *path, gpointer user_data)
+browse_clicked (GtkCellRenderer *renderer, const gchar *path, gpointer user_data)
 {
 	MoblinPanelPrivate *priv = MOBLIN_PANEL_GET_PRIVATE (user_data);
 	GtkTreeIter iter;
-	DBusGProxy *proxy = NULL;
 	char *address = NULL;
-	char *name = NULL;
+	char *cmd = NULL;
 	GtkTreePath *tree_path;
+
 	tree_path = gtk_tree_path_new_from_string (path);
 	gtk_tree_model_get_iter (priv->chooser_model, &iter, tree_path);
-	gtk_tree_model_get (priv->chooser_model, &iter, BLUETOOTH_COLUMN_PROXY, &proxy,
-			   BLUETOOTH_COLUMN_ADDRESS, &address,
-			   BLUETOOTH_COLUMN_NAME, &name, -1);
-			   
-	if (address == NULL || name == NULL || proxy == NULL) {
-		g_object_unref (proxy);
+	gtk_tree_model_get (priv->chooser_model, &iter, BLUETOOTH_COLUMN_ADDRESS, &address, -1);
+
+	if (address == NULL) {
+		cmd = g_strdup_printf ("%s --no-default-window \"obex://[%s]\"",
+				       "nautilus", address);
+		if (!g_spawn_command_line_async (cmd, NULL))
+			g_printerr("Couldn't execute command: %s\n", cmd);
 		g_free (address);
-		g_free (name);
-		return;
+		g_free (cmd);
 	}
-	g_debug ("Activity clicked on %s", address);
-	g_free (address);
-	g_free (name);
-	g_object_unref (proxy);
+	g_debug ("Browse clicked on %s", address);
+}
+#if 0
+static void
+connect_callback (BluetoothClient *client, gboolean success, gpointer user_data)
+{
+	ConnectData *data = (ConnectData *)user_data;
+	MoblinPanelPrivate *priv = MOBLIN_PANEL_GET_PRIVATE (data->self);
+
+/*	if (success == FALSE && g_timer_elapsed (data->timer, NULL) < CONNECT_TIMEOUT) {
+		if (bluetooth_client_connect_service (client, data->path, connect_callback, data) != FALSE) {
+			return;
+		}
+	}
+
+	if (success == FALSE)
+		g_message ("Failed to connect to device %s", data->path);
+
+	set_failure_view (MOBLIN_PANEL (data->self));
+	gtk_notebook_set_current_page (GTK_NOTEBOOK (priv->notebook), MESSAGE_PAGE);
+
+	g_timer_destroy (data->timer);
+	g_free (data->path);
+	g_free (data);*/
 }
 
 static void
-connect_clicked (GtkCellRenderer *renderer, const gchar *path, gpointer user_data)
+create_callback (BluetoothClient *client, const gchar *path, const GError *error, gpointer user_data)
 {
-	MoblinPanelPrivate *priv = MOBLIN_PANEL_GET_PRIVATE (user_data);
-	GtkTreeIter iter;
-	DBusGProxy *proxy = NULL;
-	char *address = NULL;
-	char *name = NULL;
-	GtkTreePath *tree_path;
-	tree_path = gtk_tree_path_new_from_string (path);
-	gtk_tree_model_get_iter (priv->chooser_model, &iter, tree_path);
-	gtk_tree_model_get (priv->chooser_model, &iter, BLUETOOTH_COLUMN_PROXY, &proxy,
-			   BLUETOOTH_COLUMN_ADDRESS, &address,
-			   BLUETOOTH_COLUMN_NAME, &name, -1);
+	MoblinPanel *self = MOBLIN_PANEL (user_data);
+	MoblinPanelPrivate *priv = MOBLIN_PANEL_GET_PRIVATE (self);
+	ConnectData *data;
 
-	if (address == NULL || name == NULL || proxy == NULL) {
-		g_object_unref (proxy);
-		g_free (address);
-		g_free (name);
+/*	if (path == NULL) {
+		gtk_notebook_set_current_page (GTK_NOTEBOOK (priv->notebook), MESSAGE_PAGE);
 		return;
 	}
-	g_debug ("Connect clicked on %s", address);
-
-	/*bluetooth_agent_set_pincode_func (priv->agent, pincode_callback, self);
-	bluetooth_agent_set_display_func (priv->agent, display_callback, self);
-	bluetooth_agent_set_cancel_func (priv->agent, cancel_callback, self);
-	bluetooth_agent_set_confirm_func (priv->agent, confirm_callback, self);
-	bluetooth_agent_setup (priv->agent, bluetooth_path);
-	set_pairing_view (self);*/
-	g_free (address);
-	g_free (name);
-	g_object_unref (proxy);
+	bluetooth_client_set_trusted (priv->client, path, TRUE);
+
+	data = g_new0 (ConnectData, 1);
+	data->path = g_strdup (path);
+	data->timer = g_timer_new ();
+
+	if (bluetooth_client_connect_service (client, path, connect_callback, data) == FALSE) {
+		g_timer_destroy (data->timer);
+		g_free (data->path);
+		g_free (data);
+	}*/
+
+	gtk_notebook_set_current_page (GTK_NOTEBOOK (priv->notebook), PROPS_PAGE);
+}
+#endif
+static void
+pair_clicked (GtkCellRenderer *renderer, const gchar *path, gpointer user_data)
+{
+	/*MoblinPanelPrivate *priv = MOBLIN_PANEL_GET_PRIVATE (user_data);
+	const gchar *agent_path = AGENT_PATH;
+
+	gchar *pin_ret = NULL;
+
+	pin_ret = get_pincode_for_device (target_type, target_address, target_name, NULL);
+	if (pin_ret != NULL && g_str_equal (pin_ret, "NULL"))
+		path = NULL;
+
+	g_object_ref (priv->agent);
+	bluetooth_client_create_device (priv->client, target_address, agent_path,
+					create_callback, user_data);*/
+	g_debug ("Pair clicked");
+}
+
+static void
+connect_clicked (GtkCellRenderer *renderer, const gchar *path, gpointer user_data)
+{
+	/*MoblinPanelPrivate *priv = MOBLIN_PANEL_GET_PRIVATE (user_data);
+
+	gchar *pin_ret = NULL;
+
+	pin_ret = get_pincode_for_device (target_type, target_address, target_name, NULL);
+	if (pin_ret != NULL && g_str_equal (pin_ret, "NULL"))
+		path = NULL;
+
+	g_object_ref (priv->agent);
+	bluetooth_client_create_device (priv->client, target_address, agent_path,
+					create_callback, user_data);*/
+	g_debug ("Connect clicked");
 }
 
 static void
@@ -395,15 +356,15 @@ remove_to_icon (GtkTreeViewColumn *column, GtkCellRenderer *cell,
 }
 
 static void
-activity_to_text (GtkTreeViewColumn *column, GtkCellRenderer *cell,
+pair_to_text (GtkTreeViewColumn *column, GtkCellRenderer *cell,
 		GtkTreeModel *model, GtkTreeIter *iter, gpointer data)
 {
 	gboolean paired, trusted;
 	gtk_tree_model_get (model, iter, BLUETOOTH_COLUMN_PAIRED, &paired,
 			BLUETOOTH_COLUMN_TRUSTED, &trusted, -1);
 
-	if (paired || trusted) {
-		g_object_set (cell, "markup", _("Activity"), NULL);
+	if (!paired && !trusted) {
+		g_object_set (cell, "markup", _("Pair"), NULL);
 	}
 }
 
@@ -411,91 +372,210 @@ static void
 connect_to_text (GtkTreeViewColumn *column, GtkCellRenderer *cell,
 		GtkTreeModel *model, GtkTreeIter *iter, gpointer data)
 {
-	gboolean paired, trusted;
+	gboolean paired, trusted, connected;
 	gtk_tree_model_get (model, iter, BLUETOOTH_COLUMN_PAIRED, &paired,
+			BLUETOOTH_COLUMN_CONNECTED, &connected,
 			BLUETOOTH_COLUMN_TRUSTED, &trusted, -1);
 
-	if (paired || trusted) {
+	if ((paired || trusted) && !connected) {
 		g_object_set (cell, "markup", _("Connect"), NULL);
 	}
 }
 
 static void
-moblin_panel_dispose (GObject *object)
+browse_to_text (GtkTreeViewColumn *column, GtkCellRenderer *cell,
+		GtkTreeModel *model, GtkTreeIter *iter, gpointer data)
 {
-	MoblinPanelPrivate *priv = MOBLIN_PANEL_GET_PRIVATE (object);
-
-	bluetooth_plugin_manager_cleanup ();
+	gboolean *connected;
+	guint type;
+	gtk_tree_model_get (model, iter, BLUETOOTH_COLUMN_CONNECTED, &connected,
+			BLUETOOTH_COLUMN_TYPE, &type, -1);
+
+	if (connected &&
+	(type == BLUETOOTH_TYPE_PHONE || type == BLUETOOTH_TYPE_COMPUTER || type == BLUETOOTH_TYPE_CAMERA)) {
+		g_object_set (cell, "markup", _("Browse"), NULL);
+	}
+}
 
-	g_object_unref (priv->agent);
 
-	G_OBJECT_CLASS (moblin_panel_parent_class)->dispose (object);
+static void
+set_scanning_view (GtkButton *button, MoblinPanel *self)
+{
+	MoblinPanelPrivate *priv = MOBLIN_PANEL_GET_PRIVATE (self);
+	gtk_notebook_set_current_page (GTK_NOTEBOOK (priv->notebook), ADD_PAGE);
 }
 
 static void
-moblin_panel_class_init (MoblinPanelClass *klass)
+set_properties_view (GtkButton *button, MoblinPanel *self)
 {
-	GObjectClass *obj_class = G_OBJECT_CLASS (klass);
-	g_type_class_add_private (klass, sizeof (MoblinPanelPrivate));
-	obj_class->dispose = moblin_panel_dispose;
+	MoblinPanelPrivate *priv = MOBLIN_PANEL_GET_PRIVATE (self);
+	gtk_notebook_set_current_page (GTK_NOTEBOOK (priv->notebook), PROPS_PAGE);
 }
 
-static void
-moblin_panel_init (MoblinPanel *self)
+#if 0
+static GtkWidget *
+create_message_page (MoblinPanel *self)
 {
 	MoblinPanelPrivate *priv;
-	GtkWidget *add_new_button;
-	GtkWidget *frame_title;
+	GtkWidget *label;
+
+	label = gtk_label_new ("Zing");
+
+	return label;
+}
+
+static GtkWidget *
+create_setup_page (MoblinPanel *self)
+{
+	MoblinPanelPrivate *priv;
+	GtkWidget *label;
+
+	label = gtk_label_new ("Zing");
+	return label;
+}
+#endif
+
+static GtkWidget *
+create_add_page (MoblinPanel *self)
+{
+	MoblinPanelPrivate *priv;
+	GtkWidget *page;
 	GtkWidget *vbox, *hbox;
-	gchar *scan_text = NULL;
-	KillswitchState switch_state;
+	GtkWidget *chooser, *filter;
+	GtkWidget *frame_title;
+	GtkWidget *frame;
+	GtkWidget *back_button;
+	GtkWidget *pin_button;
+	GtkWidget *tree_view;
 	GtkTreeViewColumn *type_column;
 	GtkCellRenderer *cell;
 
 	priv = MOBLIN_PANEL_GET_PRIVATE (self);
-	priv->target_ssp = FALSE;
-	priv->pincode = FALSE;
-	priv->automatic_pincode = FALSE;
 
-	priv->killswitch = bluetooth_killswitch_new ();
-	if (bluetooth_killswitch_has_killswitches (priv->killswitch) == FALSE) {
-		g_object_unref (priv->killswitch);
-		priv->killswitch = NULL;
-	} else {
-		g_signal_connect  (priv->killswitch, "state-changed",
-                       G_CALLBACK (killswitch_state_changed_cb), self);
-	}
-	priv->agent = bluetooth_agent_new ();
-	bluetooth_plugin_manager_init ();
+	page = gtk_hbox_new (FALSE, 0);
+	gtk_widget_show (page);
 
-	/* set up the box */
-	gtk_box_set_homogeneous (GTK_BOX (self), FALSE);
-	gtk_box_set_spacing (GTK_BOX (self), 4);
+	/* Add child widgetry */
+	vbox = gtk_vbox_new (FALSE, 4);
+	gtk_widget_show (vbox);
+	gtk_box_pack_start (GTK_BOX (page), vbox, TRUE, TRUE, 4);
+
+	frame = nbtk_gtk_frame_new ();
+	frame_title = gtk_label_new ("");
+	gtk_frame_set_label_widget (GTK_FRAME (frame), frame_title);
+	set_frame_title (GTK_FRAME (frame), _("Devices"));
+
+	/* Device list */
+	chooser = g_object_new (BLUETOOTH_TYPE_CHOOSER,
+				"has-internal-device-filter", FALSE,
+				"show-device-category", FALSE,
+				"show-searching", TRUE,
+				"device-category-filter", BLUETOOTH_CATEGORY_NOT_PAIRED_OR_TRUSTED,
+				NULL);
+	tree_view = bluetooth_chooser_get_treeview (BLUETOOTH_CHOOSER (chooser));
+	g_object_set (tree_view, "enable-grid-lines", TRUE, "headers-visible", FALSE, NULL);
+	//"grid-line-width", 2, "horizontal-separator", 6, "vertical-separator", 6,
+	bluetooth_chooser_start_discovery (BLUETOOTH_CHOOSER (chooser));
+	type_column = bluetooth_chooser_get_type_column (BLUETOOTH_CHOOSER (chooser));
+	/* Add the pair button */
+	cell = mux_cell_renderer_text_new ();
+	gtk_tree_view_column_pack_start (type_column, cell, FALSE);
+
+	gtk_tree_view_column_set_cell_data_func (type_column, cell,
+						 pair_to_text, self, NULL);
+	g_signal_connect (cell, "activated", G_CALLBACK (pair_clicked), self);
+
+	gtk_widget_show (chooser);
+	gtk_container_add (GTK_CONTAINER (frame), chooser);
+	gtk_widget_show (frame);
+	gtk_box_pack_start (GTK_BOX (vbox), frame, FALSE, FALSE, 4);
+
+	/* Back button */
+	back_button = gtk_button_new_with_label (_("Back to devices"));
+	gtk_widget_show (back_button);
+	g_signal_connect (back_button, "clicked",
+			G_CALLBACK (set_properties_view), self);
+	gtk_box_pack_start (GTK_BOX (vbox), back_button, FALSE, FALSE, 4);
+
+	/* Right column */
+	vbox = gtk_vbox_new (FALSE, 4);
+	gtk_widget_show (vbox);
+	gtk_box_pack_start (GTK_BOX (page), vbox, FALSE, FALSE, 4);
+
+	hbox = gtk_hbox_new (FALSE, 4);
+	gtk_widget_show (hbox);
+	gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, FALSE, 4);
+
+	/* Filter combo */
+	filter = bluetooth_filter_widget_new ();
+	gtk_widget_show (filter);
+	bluetooth_filter_widget_set_title (BLUETOOTH_FILTER_WIDGET (filter), _("Only show:"));
+	bluetooth_filter_widget_bind_filter (BLUETOOTH_FILTER_WIDGET (filter),
+					     BLUETOOTH_CHOOSER (chooser));
+	gtk_box_pack_start (GTK_BOX (vbox), filter, FALSE, FALSE, 4);
+
+	/* Button for PIN options file */
+	pin_button = gtk_button_new_with_label (_("PIN options"));
+	gtk_widget_show (pin_button);
+	g_signal_connect (pin_button, "clicked",
+                    G_CALLBACK (pin_options_button_clicked_cb), chooser);
+	gtk_box_pack_start (GTK_BOX (vbox), pin_button, FALSE, FALSE, 4);
+
+	return page;
+}
+
+static GtkWidget *
+create_properties_page (MoblinPanel *self)
+{
+	MoblinPanelPrivate *priv;
+	GtkWidget *page;
+	GtkWidget *frame_title;
+	GtkWidget *chooser;
+	GtkWidget *vbox, *hbox;
+	GtkWidget *frame;
+	GtkWidget *send_button, *add_new_button;
+	GtkWidget *power_label;
+	GtkTreeViewColumn *type_column;
+	GtkCellRenderer *cell;
+	KillswitchState switch_state;
+	GtkWidget *tree_view;
 
+	priv = MOBLIN_PANEL_GET_PRIVATE (self);
+
+	page = gtk_hbox_new (FALSE, 0);
+	gtk_widget_show (page);
 	/* Add child widgetry */
 	vbox = gtk_vbox_new (FALSE, 4);
 	gtk_widget_show (vbox);
-	gtk_box_pack_start (GTK_BOX (self), vbox, TRUE, TRUE, 4);
+	gtk_box_pack_start (GTK_BOX (page), vbox, TRUE, TRUE, 4);
 
-	priv->device_list_frame = nbtk_gtk_frame_new ();
+	frame = nbtk_gtk_frame_new ();
 	frame_title = gtk_label_new ("");
-	gtk_frame_set_label_widget (GTK_FRAME (priv->device_list_frame), frame_title);
-	set_frame_title (GTK_FRAME (priv->device_list_frame), _("Devices"));
+	gtk_frame_set_label_widget (GTK_FRAME (frame), frame_title);
+	set_frame_title (GTK_FRAME (frame), _("Devices"));
 
 	/* Device list */
-	priv->chooser = g_object_new (BLUETOOTH_TYPE_CHOOSER,
-				      "has-internal-device-filter", FALSE,
-				      "show-device-category", FALSE,
-				      NULL);
-	priv->chooser_model = bluetooth_chooser_get_model (BLUETOOTH_CHOOSER (priv->chooser));
-	type_column = bluetooth_chooser_get_type_column (BLUETOOTH_CHOOSER (priv->chooser));
-	/* Add the activity button */
+	chooser = g_object_new (BLUETOOTH_TYPE_CHOOSER,
+			        "has-internal-device-filter", FALSE,
+				"show-device-category", FALSE,
+				"show-searching", FALSE,
+				"device-category-filter", BLUETOOTH_CATEGORY_PAIRED_OR_TRUSTED,
+				NULL);
+	type_column = bluetooth_chooser_get_type_column (BLUETOOTH_CHOOSER (chooser));
+	if (!priv->chooser_model)
+		priv->chooser_model = bluetooth_chooser_get_model (BLUETOOTH_CHOOSER (chooser));
+
+	tree_view = bluetooth_chooser_get_treeview (BLUETOOTH_CHOOSER (chooser));
+	g_object_set (tree_view, "enable-grid-lines", TRUE, "headers-visible", FALSE, NULL);
+	//"grid-line-width", 2, "horizontal-separator", 6, "vertical-separator", 6, zebra
+
+	/* Add the browse button */
 	cell = mux_cell_renderer_text_new ();
 	gtk_tree_view_column_pack_start (type_column, cell, FALSE);
 
 	gtk_tree_view_column_set_cell_data_func (type_column, cell,
-						 activity_to_text, self, NULL);
-	g_signal_connect (cell, "activated", G_CALLBACK (activity_clicked), self);
+						 browse_to_text, self, NULL);
+	g_signal_connect (cell, "activated", G_CALLBACK (browse_clicked), self);
 
 	/* Add the connect button */
 	cell = mux_cell_renderer_text_new ();
@@ -509,15 +589,12 @@ moblin_panel_init (MoblinPanel *self)
 	gtk_tree_view_column_pack_end (type_column, cell, FALSE);
 	gtk_tree_view_column_set_cell_data_func (type_column, cell,
 						remove_to_icon, self, NULL);
-	g_signal_connect (cell, "activated", G_CALLBACK (remove_clicked_cb), self);
-	g_signal_connect (priv->chooser, "selected-device-changed",
-			G_CALLBACK (selected_device_changed_cb), self);
+	g_signal_connect (cell, "activated", G_CALLBACK (remove_clicked_cb), chooser);
 
-	gtk_widget_show (priv->chooser);
-	gtk_container_add (GTK_CONTAINER (priv->device_list_frame), priv->chooser);
-	gtk_widget_show (priv->device_list_frame);
-	gtk_box_pack_start (GTK_BOX (vbox), priv->device_list_frame,
-                      FALSE, FALSE, 4);
+	gtk_widget_show (chooser);
+	gtk_container_add (GTK_CONTAINER (frame), chooser);
+	gtk_widget_show (frame);
+	gtk_box_pack_start (GTK_BOX (vbox), frame, FALSE, FALSE, 4);
 
 	/* Add new button */
 	add_new_button = gtk_button_new_with_label (_("Add a new device"));
@@ -527,76 +604,129 @@ moblin_panel_init (MoblinPanel *self)
 	gtk_box_pack_start (GTK_BOX (vbox), add_new_button, FALSE, FALSE, 4);
 
 	/* Right column */
-	//group = gtk_size_group_new (GTK_SIZE_GROUP_HORIZONTAL);
 	vbox = gtk_vbox_new (FALSE, 4);
 	gtk_widget_show (vbox);
-	gtk_box_pack_start (GTK_BOX (self), vbox, FALSE, FALSE, 4);
+	gtk_box_pack_start (GTK_BOX (page), vbox, FALSE, FALSE, 4);
 
 	hbox = gtk_hbox_new (FALSE, 4);
 	gtk_widget_show (hbox);
-	//gtk_size_group_add_widget (group, hbox);
 	gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, FALSE, 4);
 
 	/* Power switch */
-	priv->power_label = gtk_label_new (_("Turn Bluetooth"));
-	gtk_widget_show (priv->power_label);
-	gtk_box_pack_start (GTK_BOX (hbox), priv->power_label, FALSE, FALSE, 4);
+	power_label = gtk_label_new (_("Turn Bluetooth"));
+	gtk_widget_show (power_label);
+	gtk_box_pack_start (GTK_BOX (hbox), power_label, FALSE, FALSE, 4);
 
 	priv->power_switch = nbtk_gtk_light_switch_new ();
 	if (priv->killswitch != NULL) {
-		switch_state = bluetooth_killswitch_get_state (priv->killswitch);
-
-		switch (switch_state) {
-			case KILLSWITCH_STATE_UNBLOCKED:
-				nbtk_gtk_light_switch_set_active
-					(NBTK_GTK_LIGHT_SWITCH (priv->power_switch),
-					 TRUE);
-			break;
-			case KILLSWITCH_STATE_SOFT_BLOCKED:
-				nbtk_gtk_light_switch_set_active
-					(NBTK_GTK_LIGHT_SWITCH (priv->power_switch),
-						FALSE);
-			break;
-			case KILLSWITCH_STATE_HARD_BLOCKED:
-			default:
-				gtk_widget_set_sensitive (priv->power_switch, FALSE);
-			break;
+		if (bluetooth_killswitch_has_killswitches (priv->killswitch) == FALSE) {
+			g_object_unref (priv->killswitch);
+			priv->killswitch = NULL;
+			gtk_widget_set_sensitive (priv->power_switch, FALSE);
+		} else {
+			switch_state = bluetooth_killswitch_get_state (priv->killswitch);
+
+			switch (switch_state) {
+				case KILLSWITCH_STATE_UNBLOCKED:
+					nbtk_gtk_light_switch_set_active
+						(NBTK_GTK_LIGHT_SWITCH (priv->power_switch),
+						 TRUE);
+				break;
+				case KILLSWITCH_STATE_SOFT_BLOCKED:
+					nbtk_gtk_light_switch_set_active
+						(NBTK_GTK_LIGHT_SWITCH (priv->power_switch),
+							FALSE);
+				break;
+				case KILLSWITCH_STATE_HARD_BLOCKED:
+				default:
+					gtk_widget_set_sensitive (priv->power_switch, FALSE);
+				break;
+			}
+
+			g_signal_connect  (priv->killswitch, "state-changed",
+				G_CALLBACK (killswitch_state_changed_cb), self);
+			g_signal_connect (priv->power_switch, "switch-flipped",
+				G_CALLBACK (power_switch_toggled_cb), self);
 		}
 	} else {
 		gtk_widget_set_sensitive (priv->power_switch, FALSE);
 	}
 	gtk_widget_show (priv->power_switch);
-	g_signal_connect (priv->power_switch, "switch-flipped",
-                    G_CALLBACK (power_switch_toggled_cb), self);
 	gtk_box_pack_start (GTK_BOX (hbox), priv->power_switch, FALSE, FALSE, 4);
 
-	/* Filter combo */
-	priv->filter = bluetooth_filter_widget_new ();
-	bluetooth_filter_widget_set_title (BLUETOOTH_FILTER_WIDGET (priv->filter), _("Only show:"));
-	bluetooth_filter_widget_bind_filter (BLUETOOTH_FILTER_WIDGET (priv->filter),
-					     BLUETOOTH_CHOOSER (priv->chooser));
-	gtk_box_pack_start (GTK_BOX (vbox), priv->filter, FALSE, FALSE, 4);
-
-	/* Button for Send file/PIN options */
-	priv->action_button = gtk_button_new_with_label (_("Send file from your computer"));
-	gtk_widget_show (priv->action_button);
-	//gtk_size_group_add_widget (group, priv->action_button);
-	g_signal_connect (priv->action_button, "clicked",
-                    G_CALLBACK (send_file_button_clicked_cb), self);
-	gtk_box_pack_start (GTK_BOX (vbox), priv->action_button, FALSE, FALSE, 4);
-
-	/* Scanning "help" label */
-	scan_text = g_strdup (_("Searching for devices.\n\n"
-				"Please make sure they're nearby and in 'discoverable' or "
-	                        "'visible' mode. Check your devices manual if you have "
-	                        "problems."));
-	priv->scan_label = gtk_label_new (scan_text);
-	//gtk_size_group_add_widget (group, priv->scan_label);
-	gtk_label_set_line_wrap (GTK_LABEL (priv->scan_label), TRUE);
-	g_free (scan_text);
-	gtk_box_pack_start (GTK_BOX (vbox), priv->scan_label, FALSE, FALSE, 4);
-
-	//g_object_unref (group);
+	/* Button for Send file */
+	send_button = gtk_button_new_with_label (_("Send file from your computer"));
+	gtk_widget_show (send_button);
+	g_signal_connect (send_button, "clicked",
+                    G_CALLBACK (send_file_button_clicked_cb), chooser);
+	g_signal_connect (chooser, "selected-device-changed",
+			G_CALLBACK (selected_device_changed_cb), send_button);
+	gtk_box_pack_start (GTK_BOX (vbox), send_button, FALSE, FALSE, 4);
+
+	return page;
+}
+
+static void
+moblin_panel_init (MoblinPanel *self)
+{
+	MoblinPanelPrivate *priv;
+	GtkWidget *properties_page, *add_page; //, *setup_page, *message_page;
+
+	priv = MOBLIN_PANEL_GET_PRIVATE (self);
+	priv->target_ssp = FALSE;
+	priv->pincode = FALSE;
+	priv->automatic_pincode = FALSE;
+
+	priv->killswitch = bluetooth_killswitch_new ();
+
+	priv->agent = bluetooth_agent_new ();
+	bluetooth_plugin_manager_init ();
+
+	gtk_box_set_homogeneous (GTK_BOX (self), FALSE);
+	gtk_box_set_spacing (GTK_BOX (self), 4);
+
+	priv->notebook = gtk_notebook_new ();
+	gtk_notebook_set_show_tabs (GTK_NOTEBOOK (priv->notebook), FALSE);
+
+	properties_page = create_properties_page (self);
+	gtk_widget_show (properties_page);
+	gtk_notebook_append_page (GTK_NOTEBOOK (priv->notebook), properties_page, NULL);
+
+	add_page = create_add_page (self);
+	gtk_widget_show (add_page);
+	gtk_notebook_append_page (GTK_NOTEBOOK (priv->notebook), add_page, NULL);
+#if 0
+	setup_page = create_setup_page (self);
+	gtk_widget_show (setup_page);
+	gtk_notebook_append_page (GTK_NOTEBOOK (priv->notebook), setup_page, NULL);
+
+	message_page = create_message_page (self);
+	gtk_widget_show (message_page);
+	gtk_notebook_append_page (GTK_NOTEBOOK (priv->notebook), setup_page, NULL);
+#endif
+	gtk_notebook_set_current_page (GTK_NOTEBOOK (priv->notebook), PROPS_PAGE);
+	gtk_widget_show (priv->notebook);
+	gtk_container_add (GTK_CONTAINER (self), priv->notebook);
+}
+
+static void
+moblin_panel_dispose (GObject *object)
+{
+	//MoblinPanelPrivate *priv = MOBLIN_PANEL_GET_PRIVATE (object);
+
+	bluetooth_plugin_manager_cleanup ();
+
+	//g_object_unref (priv->agent);
+
+	G_OBJECT_CLASS (moblin_panel_parent_class)->dispose (object);
+}
+
+static void
+moblin_panel_class_init (MoblinPanelClass *klass)
+{
+	GObjectClass *obj_class = G_OBJECT_CLASS (klass);
+	g_type_class_add_private (klass, sizeof (MoblinPanelPrivate));
+	obj_class->dispose = moblin_panel_dispose;
 }
 
 /**
[Date Prev][Date Next]   [Thread Prev][Thread Next]   [Thread Index] [Date Index] [Author Index]