← Back to branch summary

~ubuntu-branches/ubuntu/natty/indicator-network/natty

« back to all changes in this revision

Viewing changes to src/settings/frontend/widgets/device-boxes/wireless.c

  • Committer: Bazaar Package Importer
  • Author(s): Ken VanDine
  • Date: 2011-01-14 08:48:34 UTC
  • mfrom: (1.1.13 upstream)
  • Revision ID: james.westby@ubuntu.com-20110114084834-pef97n8rvdzy2xco
Tags: 0.3.3-0ubuntu1
https://launchpad.net/bugs/701143
* New upstream release
  - Port the network indicator to the new dbusmenu (LP: #701143)
* debian/control
  - dropped build depends for libdbus-glib-1-dev
  - bumped build depends for dbusmenu to >= 0.3.91

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/settings/frontend/widgets/device-boxes/wireless.c
 
1
/* wireless.c generated by valac 0.10.0, the Vala compiler
 
2
 * generated from wireless.vala, do not modify */
 
3
 
 
4
/*
 
5
 * indicator-network - user interface for connman
 
6
 * Copyright 2010-2011 Canonical Ltd.
 
7
 *
 
8
 * Authors:
 
9
 * Andrew Higginson
 
10
 *
 
11
 * This program is free software: you can redistribute it and/or modify it
 
12
 * under the terms of the GNU General Public License version 3, as published
 
13
 * by the Free Software Foundation.
 
14
 *
 
15
 * This program is distributed in the hope that it will be useful, but
 
16
 * WITHOUT ANY WARRANTY; without even the implied warranties of
 
17
 * MERCHANTABILITY, SATISFACTORY QUALITY, or FITNESS FOR A PARTICULAR
 
18
 * PURPOSE.  See the GNU General Public License for more details.
 
19
 *
 
20
 * You should have received a copy of the GNU General Public License along
 
21
 * with this program.  If not, see <http://www.gnu.org/licenses/>.
 
22
 */
 
23
 
 
24
#include <glib.h>
 
25
#include <glib-object.h>
 
26
#include <gtk/gtk.h>
 
27
#include <stdlib.h>
 
28
#include <string.h>
 
29
#include <float.h>
 
30
#include <math.h>
 
31
 
 
32
 
 
33
#define TYPE_DEVICE_BOX (device_box_get_type ())
 
34
#define DEVICE_BOX(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), TYPE_DEVICE_BOX, DeviceBox))
 
35
#define DEVICE_BOX_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), TYPE_DEVICE_BOX, DeviceBoxClass))
 
36
#define IS_DEVICE_BOX(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), TYPE_DEVICE_BOX))
 
37
#define IS_DEVICE_BOX_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), TYPE_DEVICE_BOX))
 
38
#define DEVICE_BOX_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), TYPE_DEVICE_BOX, DeviceBoxClass))
 
39
 
 
40
typedef struct _DeviceBox DeviceBox;
 
41
typedef struct _DeviceBoxClass DeviceBoxClass;
 
42
typedef struct _DeviceBoxPrivate DeviceBoxPrivate;
 
43
 
 
44
#define TYPE_WIRELESS_BOX (wireless_box_get_type ())
 
45
#define WIRELESS_BOX(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), TYPE_WIRELESS_BOX, WirelessBox))
 
46
#define WIRELESS_BOX_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), TYPE_WIRELESS_BOX, WirelessBoxClass))
 
47
#define IS_WIRELESS_BOX(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), TYPE_WIRELESS_BOX))
 
48
#define IS_WIRELESS_BOX_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), TYPE_WIRELESS_BOX))
 
49
#define WIRELESS_BOX_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), TYPE_WIRELESS_BOX, WirelessBoxClass))
 
50
 
 
51
typedef struct _WirelessBox WirelessBox;
 
52
typedef struct _WirelessBoxClass WirelessBoxClass;
 
53
typedef struct _WirelessBoxPrivate WirelessBoxPrivate;
 
54
 
 
55
#define TYPE_DEVICE (device_get_type ())
 
56
#define DEVICE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), TYPE_DEVICE, Device))
 
57
#define DEVICE_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), TYPE_DEVICE, DeviceClass))
 
58
#define IS_DEVICE(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), TYPE_DEVICE))
 
59
#define IS_DEVICE_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), TYPE_DEVICE))
 
60
#define DEVICE_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), TYPE_DEVICE, DeviceClass))
 
61
 
 
62
typedef struct _Device Device;
 
63
typedef struct _DeviceClass DeviceClass;
 
64
 
 
65
#define TYPE_INFO_BOX (info_box_get_type ())
 
66
#define INFO_BOX(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), TYPE_INFO_BOX, InfoBox))
 
67
#define INFO_BOX_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), TYPE_INFO_BOX, InfoBoxClass))
 
68
#define IS_INFO_BOX(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), TYPE_INFO_BOX))
 
69
#define IS_INFO_BOX_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), TYPE_INFO_BOX))
 
70
#define INFO_BOX_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), TYPE_INFO_BOX, InfoBoxClass))
 
71
 
 
72
typedef struct _InfoBox InfoBox;
 
73
typedef struct _InfoBoxClass InfoBoxClass;
 
74
 
 
75
#define TYPE_TOGGLE_SWITCH (toggle_switch_get_type ())
 
76
#define TOGGLE_SWITCH(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), TYPE_TOGGLE_SWITCH, ToggleSwitch))
 
77
#define TOGGLE_SWITCH_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), TYPE_TOGGLE_SWITCH, ToggleSwitchClass))
 
78
#define IS_TOGGLE_SWITCH(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), TYPE_TOGGLE_SWITCH))
 
79
#define IS_TOGGLE_SWITCH_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), TYPE_TOGGLE_SWITCH))
 
80
#define TOGGLE_SWITCH_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), TYPE_TOGGLE_SWITCH, ToggleSwitchClass))
 
81
 
 
82
typedef struct _ToggleSwitch ToggleSwitch;
 
83
typedef struct _ToggleSwitchClass ToggleSwitchClass;
 
84
 
 
85
#define TYPE_WIRELESS_CONNECTION_VIEW (wireless_connection_view_get_type ())
 
86
#define WIRELESS_CONNECTION_VIEW(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), TYPE_WIRELESS_CONNECTION_VIEW, WirelessConnectionView))
 
87
#define WIRELESS_CONNECTION_VIEW_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), TYPE_WIRELESS_CONNECTION_VIEW, WirelessConnectionViewClass))
 
88
#define IS_WIRELESS_CONNECTION_VIEW(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), TYPE_WIRELESS_CONNECTION_VIEW))
 
89
#define IS_WIRELESS_CONNECTION_VIEW_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), TYPE_WIRELESS_CONNECTION_VIEW))
 
90
#define WIRELESS_CONNECTION_VIEW_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), TYPE_WIRELESS_CONNECTION_VIEW, WirelessConnectionViewClass))
 
91
 
 
92
typedef struct _WirelessConnectionView WirelessConnectionView;
 
93
typedef struct _WirelessConnectionViewClass WirelessConnectionViewClass;
 
94
#define _g_free0(var) (var = (g_free (var), NULL))
 
95
#define _g_object_unref0(var) ((var == NULL) ? NULL : (var = (g_object_unref (var), NULL)))
 
96
 
 
97
#define TYPE_WIRELESS_CONNECTION_STORE (wireless_connection_store_get_type ())
 
98
#define WIRELESS_CONNECTION_STORE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), TYPE_WIRELESS_CONNECTION_STORE, WirelessConnectionStore))
 
99
#define WIRELESS_CONNECTION_STORE_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), TYPE_WIRELESS_CONNECTION_STORE, WirelessConnectionStoreClass))
 
100
#define IS_WIRELESS_CONNECTION_STORE(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), TYPE_WIRELESS_CONNECTION_STORE))
 
101
#define IS_WIRELESS_CONNECTION_STORE_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), TYPE_WIRELESS_CONNECTION_STORE))
 
102
#define WIRELESS_CONNECTION_STORE_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), TYPE_WIRELESS_CONNECTION_STORE, WirelessConnectionStoreClass))
 
103
 
 
104
typedef struct _WirelessConnectionStore WirelessConnectionStore;
 
105
typedef struct _WirelessConnectionStoreClass WirelessConnectionStoreClass;
 
106
 
 
107
#define TYPE_WIFI_CONNECTION (wifi_connection_get_type ())
 
108
#define WIFI_CONNECTION(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), TYPE_WIFI_CONNECTION, WifiConnection))
 
109
#define WIFI_CONNECTION_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), TYPE_WIFI_CONNECTION, WifiConnectionClass))
 
110
#define IS_WIFI_CONNECTION(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), TYPE_WIFI_CONNECTION))
 
111
#define IS_WIFI_CONNECTION_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), TYPE_WIFI_CONNECTION))
 
112
#define WIFI_CONNECTION_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), TYPE_WIFI_CONNECTION, WifiConnectionClass))
 
113
 
 
114
typedef struct _WifiConnection WifiConnection;
 
115
typedef struct _WifiConnectionClass WifiConnectionClass;
 
116
 
 
117
#define TYPE_DEVICE_STATE (device_state_get_type ())
 
118
 
 
119
#define TYPE_EDIT_CONNECTION_DIALOG (edit_connection_dialog_get_type ())
 
120
#define EDIT_CONNECTION_DIALOG(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), TYPE_EDIT_CONNECTION_DIALOG, EditConnectionDialog))
 
121
#define EDIT_CONNECTION_DIALOG_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), TYPE_EDIT_CONNECTION_DIALOG, EditConnectionDialogClass))
 
122
#define IS_EDIT_CONNECTION_DIALOG(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), TYPE_EDIT_CONNECTION_DIALOG))
 
123
#define IS_EDIT_CONNECTION_DIALOG_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), TYPE_EDIT_CONNECTION_DIALOG))
 
124
#define EDIT_CONNECTION_DIALOG_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), TYPE_EDIT_CONNECTION_DIALOG, EditConnectionDialogClass))
 
125
 
 
126
typedef struct _EditConnectionDialog EditConnectionDialog;
 
127
typedef struct _EditConnectionDialogClass EditConnectionDialogClass;
 
128
 
 
129
struct _DeviceBox {
 
130
        GtkVBox parent_instance;
 
131
        DeviceBoxPrivate * priv;
 
132
};
 
133
 
 
134
struct _DeviceBoxClass {
 
135
        GtkVBoxClass parent_class;
 
136
        void (*on_device_state_changed) (DeviceBox* self, GParamSpec* p);
 
137
};
 
138
 
 
139
struct _WirelessBox {
 
140
        DeviceBox parent_instance;
 
141
        WirelessBoxPrivate * priv;
 
142
};
 
143
 
 
144
struct _WirelessBoxClass {
 
145
        DeviceBoxClass parent_class;
 
146
};
 
147
 
 
148
struct _WirelessBoxPrivate {
 
149
        char* datadir;
 
150
        Device* device;
 
151
        InfoBox* infobox;
 
152
        ToggleSwitch* toggleswitch;
 
153
        GtkLabel* label_status;
 
154
        GtkBuilder* builder;
 
155
        WirelessConnectionView* treeview_connections;
 
156
        GtkVBox* vbox_connections;
 
157
        GtkButton* button_connect;
 
158
        GtkButton* button_forget;
 
159
        GtkButton* button_edit;
 
160
        GtkScrolledWindow* scrolledwindow_connections;
 
161
};
 
162
 
 
163
typedef enum  {
 
164
        DEVICE_STATE_OFF,
 
165
        DEVICE_STATE_OFFLINE,
 
166
        DEVICE_STATE_CONNECTED,
 
167
        DEVICE_STATE_ONLINE
 
168
} DeviceState;
 
169
 
 
170
 
 
171
static gpointer wireless_box_parent_class = NULL;
 
172
 
 
173
GType device_box_get_type (void) G_GNUC_CONST;
 
174
GType wireless_box_get_type (void) G_GNUC_CONST;
 
175
GType device_get_type (void) G_GNUC_CONST;
 
176
GType info_box_get_type (void) G_GNUC_CONST;
 
177
GType toggle_switch_get_type (void) G_GNUC_CONST;
 
178
GType wireless_connection_view_get_type (void) G_GNUC_CONST;
 
179
#define WIRELESS_BOX_GET_PRIVATE(o) (G_TYPE_INSTANCE_GET_PRIVATE ((o), TYPE_WIRELESS_BOX, WirelessBoxPrivate))
 
180
enum  {
 
181
        WIRELESS_BOX_DUMMY_PROPERTY
 
182
};
 
183
WirelessBox* wireless_box_new (Device* device, const char* datadir);
 
184
WirelessBox* wireless_box_construct (GType object_type, Device* device, const char* datadir);
 
185
DeviceBox* device_box_construct (GType object_type);
 
186
void device_box_on_device_state_changed (DeviceBox* self, GParamSpec* p);
 
187
static void _device_box_on_device_state_changed_g_object_notify (GObject* _sender, GParamSpec* pspec, gpointer self);
 
188
InfoBox* info_box_new (gboolean homogeneous, gint spacing);
 
189
InfoBox* info_box_construct (GType object_type, gboolean homogeneous, gint spacing);
 
190
ToggleSwitch* toggle_switch_new (void);
 
191
ToggleSwitch* toggle_switch_construct (GType object_type);
 
192
static void wireless_box_on_toggleswitch_toggled (WirelessBox* self);
 
193
static void _wireless_box_on_toggleswitch_toggled_toggle_switch_toggled (ToggleSwitch* _sender, gpointer self);
 
194
GtkBuilder* utils_gui_new_builder (const char* path);
 
195
static void wireless_box_get_widgets (WirelessBox* self);
 
196
static void wireless_box_connect_signals (WirelessBox* self);
 
197
WirelessConnectionStore* wireless_connection_store_new (void);
 
198
WirelessConnectionStore* wireless_connection_store_construct (GType object_type);
 
199
GType wireless_connection_store_get_type (void) G_GNUC_CONST;
 
200
WirelessConnectionView* wireless_connection_view_new (WirelessConnectionStore* store, GtkWidget* style_widget);
 
201
WirelessConnectionView* wireless_connection_view_construct (GType object_type, WirelessConnectionStore* store, GtkWidget* style_widget);
 
202
static void wireless_box_on_treeview_connections_selection_changed (WirelessBox* self);
 
203
static void _wireless_box_on_treeview_connections_selection_changed_gtk_tree_selection_changed (GtkTreeSelection* _sender, gpointer self);
 
204
GType wifi_connection_get_type (void) G_GNUC_CONST;
 
205
WifiConnection** get_remembered_wireless_connections (Device* device, int* result_length1);
 
206
static void wireless_box_add_connection (WirelessBox* self, WifiConnection* connection);
 
207
GType device_state_get_type (void) G_GNUC_CONST;
 
208
static void wireless_box_update_widget_states (WirelessBox* self, DeviceState state);
 
209
DeviceState device_get_state (Device* self);
 
210
static void wireless_box_on_button_connect_clicked (WirelessBox* self);
 
211
static void _wireless_box_on_button_connect_clicked_gtk_button_clicked (GtkButton* _sender, gpointer self);
 
212
static void wireless_box_on_button_edit_clicked (WirelessBox* self);
 
213
static void _wireless_box_on_button_edit_clicked_gtk_button_clicked (GtkButton* _sender, gpointer self);
 
214
void toggle_switch_set_active (ToggleSwitch* self, gboolean active);
 
215
const char* wifi_connection_get_name (WifiConnection* self);
 
216
double wifi_connection_get_signal (WifiConnection* self);
 
217
const char* wifi_connection_get_last_used (WifiConnection* self);
 
218
void wireless_connection_store_add_connection (WirelessConnectionStore* self, WifiConnection* obj, const char* network, double signal, const char* last_used);
 
219
static void wireless_box_real_on_device_state_changed (DeviceBox* base, GParamSpec* p);
 
220
gboolean toggle_switch_get_active (ToggleSwitch* self);
 
221
void device_set_state (Device* self, DeviceState value);
 
222
WifiConnection* wireless_connection_view_get_selected_connection (WirelessConnectionView* self);
 
223
void wifi_connection_connect_ (WifiConnection* self, const char* key);
 
224
EditConnectionDialog* edit_connection_dialog_new (WifiConnection* connection, const char* datadir);
 
225
EditConnectionDialog* edit_connection_dialog_construct (GType object_type, WifiConnection* connection, const char* datadir);
 
226
GType edit_connection_dialog_get_type (void) G_GNUC_CONST;
 
227
gint edit_connection_dialog_run (EditConnectionDialog* self);
 
228
static void wireless_box_finalize (GObject* obj);
 
229
static void _vala_array_destroy (gpointer array, gint array_length, GDestroyNotify destroy_func);
 
230
static void _vala_array_free (gpointer array, gint array_length, GDestroyNotify destroy_func);
 
231
 
 
232
 
 
233
 
 
234
static gpointer _g_object_ref0 (gpointer self) {
 
235
        return self ? g_object_ref (self) : NULL;
 
236
}
 
237
 
 
238
 
 
239
static void _device_box_on_device_state_changed_g_object_notify (GObject* _sender, GParamSpec* pspec, gpointer self) {
 
240
        device_box_on_device_state_changed (self, pspec);
 
241
}
 
242
 
 
243
 
 
244
static void _wireless_box_on_toggleswitch_toggled_toggle_switch_toggled (ToggleSwitch* _sender, gpointer self) {
 
245
        wireless_box_on_toggleswitch_toggled (self);
 
246
}
 
247
 
 
248
 
 
249
static void _wireless_box_on_treeview_connections_selection_changed_gtk_tree_selection_changed (GtkTreeSelection* _sender, gpointer self) {
 
250
        wireless_box_on_treeview_connections_selection_changed (self);
 
251
}
 
252
 
 
253
 
 
254
WirelessBox* wireless_box_construct (GType object_type, Device* device, const char* datadir) {
 
255
        WirelessBox * self;
 
256
        char* _tmp0_;
 
257
        Device* _tmp1_;
 
258
        InfoBox* _tmp2_;
 
259
        ToggleSwitch* _tmp3_;
 
260
        GtkLabel* _tmp4_;
 
261
        char* _tmp5_;
 
262
        GtkBuilder* _tmp6_;
 
263
        WirelessConnectionStore* connection_store;
 
264
        WirelessConnectionView* _tmp7_;
 
265
        gint connections_length1;
 
266
        gint _connections_size_;
 
267
        WifiConnection** _tmp9_;
 
268
        gint _tmp8_;
 
269
        WifiConnection** connections;
 
270
        g_return_val_if_fail (device != NULL, NULL);
 
271
        g_return_val_if_fail (datadir != NULL, NULL);
 
272
        self = (WirelessBox*) device_box_construct (object_type);
 
273
        gtk_box_set_spacing ((GtkBox*) self, 12);
 
274
        self->priv->datadir = (_tmp0_ = g_strdup (datadir), _g_free0 (self->priv->datadir), _tmp0_);
 
275
        self->priv->device = (_tmp1_ = _g_object_ref0 (device), _g_object_unref0 (self->priv->device), _tmp1_);
 
276
        g_signal_connect_object ((GObject*) self->priv->device, "notify::state", (GCallback) _device_box_on_device_state_changed_g_object_notify, (DeviceBox*) self, 0);
 
277
        self->priv->infobox = (_tmp2_ = g_object_ref_sink (info_box_new (FALSE, 12)), _g_object_unref0 (self->priv->infobox), _tmp2_);
 
278
        self->priv->toggleswitch = (_tmp3_ = g_object_ref_sink (toggle_switch_new ()), _g_object_unref0 (self->priv->toggleswitch), _tmp3_);
 
279
        self->priv->label_status = (_tmp4_ = g_object_ref_sink ((GtkLabel*) gtk_label_new (NULL)), _g_object_unref0 (self->priv->label_status), _tmp4_);
 
280
        gtk_misc_set_alignment ((GtkMisc*) self->priv->label_status, (float) 0, 0.5f);
 
281
        gtk_container_set_border_width ((GtkContainer*) self->priv->infobox, (guint) 10);
 
282
        gtk_box_pack_start ((GtkBox*) self->priv->infobox, (GtkWidget*) self->priv->label_status, TRUE, TRUE, 0);
 
283
        gtk_box_pack_start ((GtkBox*) self->priv->infobox, (GtkWidget*) self->priv->toggleswitch, FALSE, TRUE, 0);
 
284
        gtk_box_pack_start ((GtkBox*) self, (GtkWidget*) self->priv->infobox, FALSE, FALSE, 0);
 
285
        g_signal_connect_object (self->priv->toggleswitch, "toggled", (GCallback) _wireless_box_on_toggleswitch_toggled_toggle_switch_toggled, self, 0);
 
286
        self->priv->builder = (_tmp6_ = utils_gui_new_builder (_tmp5_ = g_strconcat (datadir, "ui/wireless_box.ui", NULL)), _g_object_unref0 (self->priv->builder), _tmp6_);
 
287
        _g_free0 (_tmp5_);
 
288
        wireless_box_get_widgets (self);
 
289
        wireless_box_connect_signals (self);
 
290
        gtk_box_pack_start ((GtkBox*) self, (GtkWidget*) self->priv->vbox_connections, TRUE, TRUE, 0);
 
291
        connection_store = wireless_connection_store_new ();
 
292
        self->priv->treeview_connections = (_tmp7_ = g_object_ref_sink (wireless_connection_view_new (connection_store, (GtkWidget*) self->priv->button_connect)), _g_object_unref0 (self->priv->treeview_connections), _tmp7_);
 
293
        gtk_container_add ((GtkContainer*) self->priv->scrolledwindow_connections, (GtkWidget*) self->priv->treeview_connections);
 
294
        g_signal_connect_object (gtk_tree_view_get_selection ((GtkTreeView*) self->priv->treeview_connections), "changed", (GCallback) _wireless_box_on_treeview_connections_selection_changed_gtk_tree_selection_changed, self, 0);
 
295
        connections = (_tmp9_ = get_remembered_wireless_connections (device, &_tmp8_), connections_length1 = _tmp8_, _connections_size_ = connections_length1, _tmp9_);
 
296
        {
 
297
                WifiConnection** connection_collection;
 
298
                int connection_collection_length1;
 
299
                int connection_it;
 
300
                connection_collection = connections;
 
301
                connection_collection_length1 = connections_length1;
 
302
                for (connection_it = 0; connection_it < connections_length1; connection_it = connection_it + 1) {
 
303
                        WifiConnection* connection;
 
304
                        connection = _g_object_ref0 (connection_collection[connection_it]);
 
305
                        {
 
306
                                wireless_box_add_connection (self, connection);
 
307
                                _g_object_unref0 (connection);
 
308
                        }
 
309
                }
 
310
        }
 
311
        wireless_box_update_widget_states (self, device_get_state (self->priv->device));
 
312
        wireless_box_on_treeview_connections_selection_changed (self);
 
313
        connections = (_vala_array_free (connections, connections_length1, (GDestroyNotify) g_object_unref), NULL);
 
314
        _g_object_unref0 (connection_store);
 
315
        return self;
 
316
}
 
317
 
 
318
 
 
319
WirelessBox* wireless_box_new (Device* device, const char* datadir) {
 
320
        return wireless_box_construct (TYPE_WIRELESS_BOX, device, datadir);
 
321
}
 
322
 
 
323
 
 
324
static void wireless_box_get_widgets (WirelessBox* self) {
 
325
        GObject* _tmp0_;
 
326
        GtkVBox* _tmp1_;
 
327
        GObject* _tmp2_;
 
328
        GtkButton* _tmp3_;
 
329
        GObject* _tmp4_;
 
330
        GtkButton* _tmp5_;
 
331
        GObject* _tmp6_;
 
332
        GtkButton* _tmp7_;
 
333
        GObject* _tmp8_;
 
334
        GtkScrolledWindow* _tmp9_;
 
335
        g_return_if_fail (self != NULL);
 
336
        self->priv->vbox_connections = (_tmp1_ = _g_object_ref0 ((_tmp0_ = gtk_builder_get_object (self->priv->builder, "vbox_connections"), GTK_IS_VBOX (_tmp0_) ? ((GtkVBox*) _tmp0_) : NULL)), _g_object_unref0 (self->priv->vbox_connections), _tmp1_);
 
337
        self->priv->button_connect = (_tmp3_ = _g_object_ref0 ((_tmp2_ = gtk_builder_get_object (self->priv->builder, "button_connect"), GTK_IS_BUTTON (_tmp2_) ? ((GtkButton*) _tmp2_) : NULL)), _g_object_unref0 (self->priv->button_connect), _tmp3_);
 
338
        self->priv->button_forget = (_tmp5_ = _g_object_ref0 ((_tmp4_ = gtk_builder_get_object (self->priv->builder, "button_forget"), GTK_IS_BUTTON (_tmp4_) ? ((GtkButton*) _tmp4_) : NULL)), _g_object_unref0 (self->priv->button_forget), _tmp5_);
 
339
        self->priv->button_edit = (_tmp7_ = _g_object_ref0 ((_tmp6_ = gtk_builder_get_object (self->priv->builder, "button_edit"), GTK_IS_BUTTON (_tmp6_) ? ((GtkButton*) _tmp6_) : NULL)), _g_object_unref0 (self->priv->button_edit), _tmp7_);
 
340
        self->priv->scrolledwindow_connections = (_tmp9_ = _g_object_ref0 ((_tmp8_ = gtk_builder_get_object (self->priv->builder, "scrolledwindow_connections"), GTK_IS_SCROLLED_WINDOW (_tmp8_) ? ((GtkScrolledWindow*) _tmp8_) : NULL)), _g_object_unref0 (self->priv->scrolledwindow_connections), _tmp9_);
 
341
}
 
342
 
 
343
 
 
344
static void _wireless_box_on_button_connect_clicked_gtk_button_clicked (GtkButton* _sender, gpointer self) {
 
345
        wireless_box_on_button_connect_clicked (self);
 
346
}
 
347
 
 
348
 
 
349
static void _wireless_box_on_button_edit_clicked_gtk_button_clicked (GtkButton* _sender, gpointer self) {
 
350
        wireless_box_on_button_edit_clicked (self);
 
351
}
 
352
 
 
353
 
 
354
static void wireless_box_connect_signals (WirelessBox* self) {
 
355
        g_return_if_fail (self != NULL);
 
356
        g_signal_connect_object (self->priv->button_connect, "clicked", (GCallback) _wireless_box_on_button_connect_clicked_gtk_button_clicked, self, 0);
 
357
        g_signal_connect_object (self->priv->button_edit, "clicked", (GCallback) _wireless_box_on_button_edit_clicked_gtk_button_clicked, self, 0);
 
358
}
 
359
 
 
360
 
 
361
static void wireless_box_update_widget_states (WirelessBox* self, DeviceState state) {
 
362
        gboolean device_editable;
 
363
        gboolean settings_editable;
 
364
        gboolean toggleswitch_state;
 
365
        char* status_text;
 
366
        g_return_if_fail (self != NULL);
 
367
        device_editable = FALSE;
 
368
        settings_editable = FALSE;
 
369
        toggleswitch_state = FALSE;
 
370
        status_text = g_strdup ("");
 
371
        switch (state) {
 
372
                case DEVICE_STATE_CONNECTED:
 
373
                {
 
374
                        char* _tmp0_;
 
375
                        device_editable = TRUE;
 
376
                        settings_editable = TRUE;
 
377
                        toggleswitch_state = TRUE;
 
378
                        status_text = (_tmp0_ = g_strdup ("Wi-fi is on but not connected to the Internet."), _g_free0 (status_text), _tmp0_);
 
379
                        break;
 
380
                }
 
381
                case DEVICE_STATE_ONLINE:
 
382
                {
 
383
                        char* _tmp1_;
 
384
                        device_editable = TRUE;
 
385
                        settings_editable = TRUE;
 
386
                        toggleswitch_state = TRUE;
 
387
                        status_text = (_tmp1_ = g_strdup ("Wi-fi is on and connected to the Internet."), _g_free0 (status_text), _tmp1_);
 
388
                        break;
 
389
                }
 
390
                case DEVICE_STATE_OFF:
 
391
                {
 
392
                        char* _tmp2_;
 
393
                        device_editable = FALSE;
 
394
                        settings_editable = FALSE;
 
395
                        toggleswitch_state = FALSE;
 
396
                        status_text = (_tmp2_ = g_strdup ("The Wi-fi device is powered off."), _g_free0 (status_text), _tmp2_);
 
397
                        break;
 
398
                }
 
399
                case DEVICE_STATE_OFFLINE:
 
400
                {
 
401
                        char* _tmp3_;
 
402
                        device_editable = TRUE;
 
403
                        settings_editable = FALSE;
 
404
                        toggleswitch_state = FALSE;
 
405
                        status_text = (_tmp3_ = g_strdup ("Wi-fi is offline."), _g_free0 (status_text), _tmp3_);
 
406
                        break;
 
407
                }
 
408
        }
 
409
        gtk_widget_set_sensitive ((GtkWidget*) self->priv->vbox_connections, settings_editable);
 
410
        gtk_widget_set_sensitive ((GtkWidget*) self->priv->toggleswitch, device_editable);
 
411
        toggle_switch_set_active (self->priv->toggleswitch, toggleswitch_state);
 
412
        gtk_label_set_text (self->priv->label_status, status_text);
 
413
        _g_free0 (status_text);
 
414
}
 
415
 
 
416
 
 
417
static void wireless_box_add_connection (WirelessBox* self, WifiConnection* connection) {
 
418
        char* name;
 
419
        double signal;
 
420
        char* last_used;
 
421
        GtkTreeModel* _tmp0_;
 
422
        WirelessConnectionStore* liststore;
 
423
        g_return_if_fail (self != NULL);
 
424
        g_return_if_fail (connection != NULL);
 
425
        name = g_strdup (wifi_connection_get_name (connection));
 
426
        signal = wifi_connection_get_signal (connection);
 
427
        last_used = g_strdup (wifi_connection_get_last_used (connection));
 
428
        liststore = _g_object_ref0 ((_tmp0_ = gtk_tree_view_get_model ((GtkTreeView*) self->priv->treeview_connections), IS_WIRELESS_CONNECTION_STORE (_tmp0_) ? ((WirelessConnectionStore*) _tmp0_) : NULL));
 
429
        wireless_connection_store_add_connection (liststore, connection, name, signal, last_used);
 
430
        _g_object_unref0 (liststore);
 
431
        _g_free0 (last_used);
 
432
        _g_free0 (name);
 
433
}
 
434
 
 
435
 
 
436
static void wireless_box_real_on_device_state_changed (DeviceBox* base, GParamSpec* p) {
 
437
        WirelessBox * self;
 
438
        self = (WirelessBox*) base;
 
439
        g_return_if_fail (p != NULL);
 
440
        wireless_box_update_widget_states (self, device_get_state (self->priv->device));
 
441
}
 
442
 
 
443
 
 
444
static void wireless_box_on_toggleswitch_toggled (WirelessBox* self) {
 
445
        g_return_if_fail (self != NULL);
 
446
        if (toggle_switch_get_active (self->priv->toggleswitch)) {
 
447
                device_set_state (self->priv->device, DEVICE_STATE_CONNECTED);
 
448
        } else {
 
449
                device_set_state (self->priv->device, DEVICE_STATE_OFFLINE);
 
450
        }
 
451
}
 
452
 
 
453
 
 
454
static void wireless_box_on_button_connect_clicked (WirelessBox* self) {
 
455
        WifiConnection* connection;
 
456
        g_return_if_fail (self != NULL);
 
457
        connection = wireless_connection_view_get_selected_connection (self->priv->treeview_connections);
 
458
        wifi_connection_connect_ (connection, "password");
 
459
        _g_object_unref0 (connection);
 
460
}
 
461
 
 
462
 
 
463
static void wireless_box_on_button_edit_clicked (WirelessBox* self) {
 
464
        WifiConnection* connection;
 
465
        EditConnectionDialog* dialog;
 
466
        g_return_if_fail (self != NULL);
 
467
        connection = wireless_connection_view_get_selected_connection (self->priv->treeview_connections);
 
468
        dialog = edit_connection_dialog_new (connection, self->priv->datadir);
 
469
        edit_connection_dialog_run (dialog);
 
470
        _g_object_unref0 (dialog);
 
471
        _g_object_unref0 (connection);
 
472
}
 
473
 
 
474
 
 
475
static void wireless_box_on_treeview_connections_selection_changed (WirelessBox* self) {
 
476
        WifiConnection* _tmp0_;
 
477
        gboolean _tmp1_;
 
478
        gboolean path_is_selected;
 
479
        g_return_if_fail (self != NULL);
 
480
        path_is_selected = (_tmp1_ = (_tmp0_ = wireless_connection_view_get_selected_connection (self->priv->treeview_connections)) != NULL, _g_object_unref0 (_tmp0_), _tmp1_);
 
481
        gtk_widget_set_sensitive ((GtkWidget*) self->priv->button_connect, path_is_selected);
 
482
        gtk_widget_set_sensitive ((GtkWidget*) self->priv->button_forget, path_is_selected);
 
483
        gtk_widget_set_sensitive ((GtkWidget*) self->priv->button_edit, path_is_selected);
 
484
}
 
485
 
 
486
 
 
487
static void wireless_box_class_init (WirelessBoxClass * klass) {
 
488
        wireless_box_parent_class = g_type_class_peek_parent (klass);
 
489
        g_type_class_add_private (klass, sizeof (WirelessBoxPrivate));
 
490
        DEVICE_BOX_CLASS (klass)->on_device_state_changed = wireless_box_real_on_device_state_changed;
 
491
        G_OBJECT_CLASS (klass)->finalize = wireless_box_finalize;
 
492
}
 
493
 
 
494
 
 
495
static void wireless_box_instance_init (WirelessBox * self) {
 
496
        self->priv = WIRELESS_BOX_GET_PRIVATE (self);
 
497
}
 
498
 
 
499
 
 
500
static void wireless_box_finalize (GObject* obj) {
 
501
        WirelessBox * self;
 
502
        self = WIRELESS_BOX (obj);
 
503
        _g_free0 (self->priv->datadir);
 
504
        _g_object_unref0 (self->priv->device);
 
505
        _g_object_unref0 (self->priv->infobox);
 
506
        _g_object_unref0 (self->priv->toggleswitch);
 
507
        _g_object_unref0 (self->priv->label_status);
 
508
        _g_object_unref0 (self->priv->builder);
 
509
        _g_object_unref0 (self->priv->treeview_connections);
 
510
        _g_object_unref0 (self->priv->vbox_connections);
 
511
        _g_object_unref0 (self->priv->button_connect);
 
512
        _g_object_unref0 (self->priv->button_forget);
 
513
        _g_object_unref0 (self->priv->button_edit);
 
514
        _g_object_unref0 (self->priv->scrolledwindow_connections);
 
515
        G_OBJECT_CLASS (wireless_box_parent_class)->finalize (obj);
 
516
}
 
517
 
 
518
 
 
519
GType wireless_box_get_type (void) {
 
520
        static volatile gsize wireless_box_type_id__volatile = 0;
 
521
        if (g_once_init_enter (&wireless_box_type_id__volatile)) {
 
522
                static const GTypeInfo g_define_type_info = { sizeof (WirelessBoxClass), (GBaseInitFunc) NULL, (GBaseFinalizeFunc) NULL, (GClassInitFunc) wireless_box_class_init, (GClassFinalizeFunc) NULL, NULL, sizeof (WirelessBox), 0, (GInstanceInitFunc) wireless_box_instance_init, NULL };
 
523
                GType wireless_box_type_id;
 
524
                wireless_box_type_id = g_type_register_static (TYPE_DEVICE_BOX, "WirelessBox", &g_define_type_info, 0);
 
525
                g_once_init_leave (&wireless_box_type_id__volatile, wireless_box_type_id);
 
526
        }
 
527
        return wireless_box_type_id__volatile;
 
528
}
 
529
 
 
530
 
 
531
static void _vala_array_destroy (gpointer array, gint array_length, GDestroyNotify destroy_func) {
 
532
        if ((array != NULL) && (destroy_func != NULL)) {
 
533
                int i;
 
534
                for (i = 0; i < array_length; i = i + 1) {
 
535
                        if (((gpointer*) array)[i] != NULL) {
 
536
                                destroy_func (((gpointer*) array)[i]);
 
537
                        }
 
538
                }
 
539
        }
 
540
}
 
541
 
 
542
 
 
543
static void _vala_array_free (gpointer array, gint array_length, GDestroyNotify destroy_func) {
 
544
        _vala_array_destroy (array, array_length, destroy_func);
 
545
        g_free (array);
 
546
}
 
547
 
 
548
 
 
549
 
 
550