← Back to branch summary

~ubuntu-branches/ubuntu/wily/wicd/wily

« back to all changes in this revision

Viewing changes to wicd/gui.py

  • Committer: Bazaar Package Importer
  • Author(s): David Paleino
  • Date: 2009-06-22 17:59:27 UTC
  • mfrom: (1.1.4 upstream)
  • Revision ID: james.westby@ubuntu.com-20090622175927-iax3alden0bmj6zg
Tags: 1.6.1-3
http://bugs.debian.org/534138
http://bugs.debian.org/532112
* debian/config, debian/templates updated:
  - only show users to add to netdev, skip those who are already
    members (Closes: #534138)
  - gracefully handle upgrades from previous broken versions, where
    debconf set a value of ${default} for wicd/users
    (Closes: #532112)

Show diffs side-by-side

added added

removed removed

Lines of Context:
wicd/gui.py
1
1
#!/usr/bin/python
2
2
 
3
 
""" Wicd GUI module.
 
3
""" gui -- The main wicd GUI module.
4
4
 
5
 
Module containg all the code (other than the tray icon) related to the 
6
 
Wicd user interface.
 
5
Module containing the code for the main wicd GUI.
7
6
 
8
7
"""
9
8
 
10
9
#
11
 
#   Copyright (C) 2007 - 2008 Adam Blackburn
12
 
#   Copyright (C) 2007 - 2008 Dan O'Reilly
 
10
#   Copyright (C) 2007-2009 Adam Blackburn
 
11
#   Copyright (C) 2007-2009 Dan O'Reilly
13
12
#
14
13
#   This program is free software; you can redistribute it and/or modify
15
14
#   it under the terms of the GNU General Public License Version 2 as
28
27
import sys
29
28
import time
30
29
import gobject
31
 
import dbus
32
 
import dbus.service
33
30
import pango
34
31
import gtk
35
32
import gtk.glade
 
33
from dbus import DBusException
36
34
 
37
 
import wicd.wpath as wpath
38
 
import wicd.misc as misc
 
35
from wicd import misc
 
36
from wicd import wpath
 
37
from wicd import dbusmanager
 
38
from wicd import prefs
 
39
from wicd import netentry
 
40
from wicd.misc import noneToString
 
41
from wicd.netentry import WiredNetworkEntry, WirelessNetworkEntry
 
42
from wicd.prefs import PreferencesDialog
 
43
from wicd.guiutil import error, LabelEntry
 
44
from wicd.translations import language
39
45
 
40
46
if __name__ == '__main__':
41
47
    wpath.chdir(__file__)
42
48
 
43
 
try:
44
 
    import pygtk
45
 
    pygtk.require("2.0")
46
 
except:
47
 
    pass
48
 
 
49
 
if getattr(dbus, 'version', (0, 0, 0)) < (0, 80, 0):
50
 
    import dbus.glib
51
 
else:
52
 
    from dbus.mainloop.glib import DBusGMainLoop
53
 
    DBusGMainLoop(set_as_default=True)
54
 
 
55
 
bus = dbus.SystemBus()
56
 
proxy_obj = daemon = wireless = wired = dbus_ifaces = config = None
57
 
 
58
 
_ = misc.get_gettext()
59
 
 
60
 
# Keep all the language strings in a dictionary
61
 
# by the english words.
62
 
# I'm not sure this is the best way to do it
63
 
# but it works and makes it easy for me :)
64
 
##########
65
 
# translations are done at
66
 
# http://wicd.net/translator
67
 
# please translate if you can!
68
 
##########
69
 
language = {}
70
 
language['connect'] = _("Connect")
71
 
language['ip'] = _("IP")
72
 
language['netmask'] = _("Netmask")
73
 
language['gateway'] = _('Gateway')
74
 
language['dns'] = _('DNS')
75
 
language['use_static_ip'] = _('Use Static IPs')
76
 
language['use_static_dns'] = _('Use Static DNS')
77
 
language['use_encryption'] = _('Use Encryption')
78
 
language['advanced_settings'] = _('Advanced Settings')
79
 
language['wired_network'] = _('Wired Network')
80
 
language['wired_network_instructions'] = _('To connect to a wired network, you'
81
 
' must create a network profile. To create a network profile, type a name that'
82
 
' describes this network, and press Add.')
83
 
language['automatic_connect'] = _('Automatically connect to this network')
84
 
language['secured'] = _('Secured')
85
 
language['unsecured'] = _('Unsecured')
86
 
language['channel'] = _('Channel')
87
 
language['preferences'] = _('Preferences')
88
 
language['wpa_supplicant_driver'] = _('WPA Supplicant Driver')
89
 
language['wireless_interface'] = _('Wireless Interface')
90
 
language['wired_interface'] = _('Wired Interface')
91
 
language['hidden_network'] = _('Hidden Network')
92
 
language['hidden_network_essid'] = _('Hidden Network ESSID')
93
 
language['connected_to_wireless'] = _('Connected to $A at $B (IP: $C)')
94
 
language['connected_to_wired'] = _('Connected to wired network (IP: $A)')
95
 
language['not_connected'] = _('Not connected')
96
 
language['no_wireless_networks_found'] = _('No wireless networks found.')
97
 
language['killswitch_enabled'] = _('Wireless Kill Switch Enabled')
98
 
language['key'] = _('Key')
99
 
language['username'] = _('Username')
100
 
language['password'] = _('Password')
101
 
language['anonymous_identity'] = _('Anonymous Identity')
102
 
language['identity'] = _('Identity')
103
 
language['authentication'] = _('Authentication')
104
 
language['path_to_pac_file'] = _('Path to PAC File')
105
 
language['select_a_network'] = _('Choose from the networks below:')
106
 
language['connecting'] = _('Connecting...')
107
 
language['wired_always_on'] = _('Always show wired interface')
108
 
language['auto_reconnect'] = _('Automatically reconnect on connection loss')
109
 
language['create_adhoc_network'] = _('Create an Ad-Hoc Network')
110
 
language['essid'] = _('ESSID')
111
 
language['use_wep_encryption'] = _('Use Encryption (WEP only)')
112
 
language['before_script'] = _('Run script before connect')
113
 
language['after_script'] = _('Run script after connect')
114
 
language['disconnect_script'] = _('Run disconnect script')
115
 
language['script_settings'] = _('Scripts')
116
 
language['use_ics'] = _('Activate Internet Connection Sharing')
117
 
language['madwifi_for_adhoc'] = _('Check if using madwifi/atheros drivers')
118
 
language['default_wired'] = _('Use as default profile (overwrites any previous default)')
119
 
language['use_debug_mode'] = _('Enable debug mode')
120
 
language['use_global_dns'] = _('Use global DNS servers')
121
 
language['use_default_profile'] = _('Use default profile on wired autoconnect')
122
 
language['show_wired_list'] = _('Prompt for profile on wired autoconnect')
123
 
language['use_last_used_profile'] = _('Use last used profile on wired autoconnect')
124
 
language['choose_wired_profile'] = _('Select or create a wired profile to connect with')
125
 
language['wired_network_found'] = _('Wired connection detected')
126
 
language['stop_showing_chooser'] = _('Stop Showing Autoconnect pop-up temporarily')
127
 
language['display_type_dialog'] = _('Use dBm to measure signal strength')
128
 
language['scripts'] = _('Scripts')
129
 
language['invalid_address'] = _('Invalid address in $A entry.')
130
 
language['global_settings'] = _('Use these settings for all networks sharing this essid')
131
 
language['encrypt_info_missing'] = _('Required encryption information is missing.')
132
 
language['enable_encryption'] = _('This network requires encryption to be enabled.')
133
 
language['wicd_auto_config'] = _('Automatic (recommended)')
134
 
language["gen_settings"] = _("General Settings")
135
 
language["ext_programs"] = _("External Programs")
136
 
language["dhcp_client"] = _("DHCP Client")
137
 
language["wired_detect"] = _("Wired Link Detection")
138
 
language["route_flush"] = _("Route Table Flushing")
139
 
language["no_global_dns"] = _("Global DNS is not enabled in preferences, so it can't be used for this network")
140
 
language['scripts_need_root'] = _('You must enter your password to configure scripts')
141
 
language['scripts_need_pass'] = _('You must enter your password to configure scripts')
142
 
language['no_sudo_prog'] = _("Could not find a graphical sudo program.  The script editor could not be launched." +
143
 
                             "  You'll have to edit scripts directly your configuration file.")
144
 
 
145
 
language['0'] = _('0')
146
 
language['1'] = _('1')
147
 
language['2'] = _('2')
148
 
language['3'] = _('3')
149
 
language['4'] = _('4')
150
 
language['5'] = _('5')
151
 
language['6'] = _('6')
152
 
language['7'] = _('7')
153
 
language['8'] = _('8')
154
 
language['9'] = _('9')
155
 
 
156
 
language['interface_down'] = _('Putting interface down...')
157
 
language['resetting_ip_address'] = _('Resetting IP address...')
158
 
language['interface_up'] = _('Putting interface up...')
159
 
language['setting_encryption_info'] = _('Setting encryption info')
160
 
language['removing_old_connection'] = _('Removing old connection...')
161
 
language['generating_psk'] = _('Generating PSK...')
162
 
language['generating_wpa_config'] = _('Generating WPA configuration file...')
163
 
language['flushing_routing_table'] = _('Flushing the routing table...')
164
 
language['configuring_interface'] = _('Configuring wireless interface...')
165
 
language['validating_authentication'] = _('Validating authentication...')
166
 
language['setting_broadcast_address'] = _('Setting broadcast address...')
167
 
language['setting_static_dns'] = _('Setting static DNS servers...')
168
 
language['setting_static_ip'] = _('Setting static IP addresses...')
169
 
language['running_dhcp'] = _('Obtaining IP address...')
170
 
language['dhcp_failed'] = _('Connection Failed: Unable to Get IP Address')
171
 
language['aborted'] = _('Connection Cancelled')
172
 
language['bad_pass'] = _('Connection Failed: Bad password')
173
 
language['done'] = _('Done connecting...')
174
 
 
175
 
def setup_dbus():
176
 
    global proxy_obj, daemon, wireless, wired, config, dbus_ifaces
177
 
    proxy_obj = bus.get_object("org.wicd.daemon", '/org/wicd/daemon')
178
 
    daemon = dbus.Interface(proxy_obj, 'org.wicd.daemon')
179
 
    wireless = dbus.Interface(proxy_obj, 'org.wicd.daemon.wireless')
180
 
    wired = dbus.Interface(proxy_obj, 'org.wicd.daemon.wired')
181
 
    config = dbus.Interface(proxy_obj, 'org.wicd.daemon.config')
182
 
    dbus_ifaces = {"daemon" : daemon, "wireless" : wireless, "wired" : wired, 
183
 
                   "config" : config}
184
 
 
185
 
########################################
186
 
##### GTK EXTENSION CLASSES
187
 
########################################
188
 
 
189
 
class LinkButton(gtk.EventBox):
190
 
    label = None
191
 
    def __init__(self, txt):
192
 
        gtk.EventBox.__init__(self)
193
 
        self.connect("realize", self.__setHandCursor) #set the hand cursor when the box is initalized
194
 
        label = gtk.Label()
195
 
        label.set_markup("[ <span color=\"blue\">" + txt + "</span> ]")
196
 
        label.set_alignment(0,.5)
197
 
        label.show()
198
 
        self.add(label)
199
 
        self.show_all()
200
 
 
201
 
    def __setHandCursor(self, widget):
202
 
        # We need this to set the cursor to a hand for the link labels.
203
 
        # I'm not entirely sure what it does :P
204
 
        hand = gtk.gdk.Cursor(gtk.gdk.HAND1)
205
 
        widget.window.set_cursor(hand)
206
 
 
207
 
class SmallLabel(gtk.Label):
208
 
    def __init__(self, text=''):
209
 
        gtk.Label.__init__(self, text)
210
 
        self.set_size_request(50, -1)
211
 
 
212
 
class LabelEntry(gtk.HBox):
213
 
    """ A label on the left with a textbox on the right and an optional checkbox for hiding the contents. """
214
 
 
215
 
    def __init__(self, text):
216
 
        gtk.HBox.__init__(self)
217
 
        self.show_contents_checkbox = gtk.CheckButton()
218
 
        self.show_contents_checkbox.set_active(True)
219
 
        self.show_contents_checkbox.set_no_show_all(True)
220
 
        self.entry = gtk.Entry()
221
 
        self.entry.set_size_request(200, -1)
222
 
        self.label = SmallLabel()
223
 
        self.label.set_text(text)
224
 
        self.label.set_size_request(170, -1)
225
 
        self.pack_start(self.label, fill=False, expand=False)
226
 
        self.pack_start(self.entry, fill=False, expand=False)
227
 
        self.pack_start(self.show_contents_checkbox,
228
 
                        fill=False, expand=False)
229
 
        self.label.show()
230
 
        self.entry.show()
231
 
 
232
 
        self.show_contents_checkbox.connect('toggled', self.toggle_visibility_checkbox)
233
 
        self.show()
234
 
 
235
 
        self.set_auto_hidden(False)
236
 
 
237
 
    def set_text(self, text):
238
 
        # For compatibility...
239
 
        self.entry.set_text(text)
240
 
 
241
 
    def get_text(self):
242
 
        return self.entry.get_text()
243
 
 
244
 
    def set_auto_hidden(self, value):
245
 
        self.auto_hide_text = value
246
 
        if value:
247
 
            self.hide_characters()
248
 
            self.entry.set_visibility(False)
249
 
            self.show_contents_checkbox.set_active(False)
250
 
            self.show_contents_checkbox.show()
251
 
        else:
252
 
            self.show_characters()
253
 
            self.entry.set_visibility(True)
254
 
            self.show_contents_checkbox.set_active(True)
255
 
            self.show_contents_checkbox.hide()
256
 
 
257
 
    def toggle_visibility_checkbox(self, widget=None, event=None):
258
 
        if self.show_contents_checkbox.get_active():
259
 
            self.show_characters()
260
 
        else:
261
 
            self.hide_characters()
262
 
 
263
 
    def show_characters(self, widget=None, event=None):
264
 
        # Show the characters in self.entry
265
 
        if self.auto_hide_text:
266
 
            self.entry.set_visibility(True)
267
 
 
268
 
    def hide_characters(self, widget=None, event=None):
269
 
        # Hide characters in self.entry
270
 
        if self.auto_hide_text:
271
 
            self.entry.set_visibility(False)
272
 
 
273
 
    def set_sensitive(self, value):
274
 
        gtk.HBox.set_sensitive(self, value)
275
 
        self.entry.set_sensitive(value)
276
 
        self.label.set_sensitive(value)
277
 
 
278
 
 
279
 
 
280
 
class GreyLabel(gtk.Label):
281
 
    """ Creates a grey gtk.Label. """
282
 
    def __init__(self):
283
 
        gtk.Label.__init__(self)
284
 
 
285
 
    def set_label(self, text):
286
 
        self.set_markup("<span color=\"#666666\"><i>" + text + "</i></span>")
287
 
        self.set_alignment(0, 0)
288
 
 
289
 
########################################
290
 
##### OTHER RANDOM FUNCTIONS
291
 
########################################
292
 
 
293
 
def noneToString(text):
294
 
    """ Converts a blank string to "None". """
295
 
    if text == "":
296
 
        return "None"
297
 
    else:
298
 
        return str(text)
299
 
 
300
 
def noneToBlankString(text):
301
 
    """ Converts NoneType or "None" to a blank string. """
302
 
    if text in (None, "None"):
303
 
        return ""
304
 
    else:
305
 
        return str(text)
306
 
 
307
 
def stringToNone(text):
308
 
    """ Performs opposite function of noneToString. """
309
 
    if text in ("", None, "None"):
310
 
        return None
311
 
    else:
312
 
        return str(text)
313
 
 
314
 
def stringToBoolean(text):
315
 
    """ Turns a string representation of a bool to a boolean if needed. """
316
 
    if text in ("True", "1"):
317
 
        return True
318
 
    if text in ("False", "0"):
319
 
        return False
320
 
    return text
321
 
 
322
 
def checkboxTextboxToggle(checkbox, textboxes):
323
 
    # Really bad practice, but checkbox == self
324
 
    for textbox in textboxes:
325
 
        textbox.set_sensitive(checkbox.get_active())
326
 
 
327
 
 
328
 
def error(parent, message): 
329
 
    """ Shows an error dialog """
330
 
    dialog = gtk.MessageDialog(parent, gtk.DIALOG_MODAL, gtk.MESSAGE_ERROR,
331
 
                               gtk.BUTTONS_OK)
332
 
    dialog.set_markup(message)
333
 
    dialog.run()
334
 
    dialog.destroy()
335
 
 
336
 
########################################
337
 
##### NETWORK LIST CLASSES
338
 
########################################
339
 
 
340
 
class AdvancedSettingsDialog(gtk.Dialog):
341
 
    def __init__(self):
342
 
        """ Build the base advanced settings dialog.
343
 
 
344
 
        This class isn't used by itself, instead it is used as a parent for
345
 
        the WiredSettingsDialog and WirelessSettingsDialog.
346
 
 
347
 
        """
348
 
        gtk.Dialog.__init__(self, title=language['advanced_settings'],
349
 
                            flags=gtk.DIALOG_MODAL, buttons=(gtk.STOCK_CANCEL,
350
 
                                                             gtk.RESPONSE_REJECT,
351
 
                                                             gtk.STOCK_OK,
352
 
                                                             gtk.RESPONSE_ACCEPT))
353
 
        # Set up the Advanced Settings Dialog.
354
 
        self.txt_ip = LabelEntry(language['ip'])
355
 
        self.txt_ip.entry.connect('focus-out-event', self.set_defaults)
356
 
        self.txt_netmask = LabelEntry(language['netmask'])
357
 
        self.txt_gateway = LabelEntry(language['gateway'])
358
 
        self.txt_dns_1 = LabelEntry(language['dns'] + ' ' + language['1'])
359
 
        self.txt_dns_2 = LabelEntry(language['dns'] + ' ' + language['2'])
360
 
        self.txt_dns_3 = LabelEntry(language['dns'] + ' ' + language['3'])
361
 
        self.chkbox_static_ip = gtk.CheckButton(language['use_static_ip'])
362
 
        self.chkbox_static_dns = gtk.CheckButton(language['use_static_dns'])
363
 
        self.chkbox_global_dns = gtk.CheckButton(language['use_global_dns'])
364
 
        self.hbox_dns = gtk.HBox(False, 0)
365
 
        self.hbox_dns.pack_start(self.chkbox_static_dns)
366
 
        self.hbox_dns.pack_start(self.chkbox_global_dns)
367
 
 
368
 
        self.vbox.pack_start(self.chkbox_static_ip, fill=False, expand=False)
369
 
        self.vbox.pack_start(self.txt_ip, fill=False, expand=False)
370
 
        self.vbox.pack_start(self.txt_netmask, fill=False, expand=False)
371
 
        self.vbox.pack_start(self.txt_gateway, fill=False, expand=False)
372
 
        self.vbox.pack_start(self.hbox_dns, fill=False, expand=False)
373
 
        self.vbox.pack_start(self.txt_dns_1, fill=False, expand=False)
374
 
        self.vbox.pack_start(self.txt_dns_2, fill=False, expand=False)
375
 
        self.vbox.pack_start(self.txt_dns_3, fill=False, expand=False)
376
 
 
377
 
        # Connect the events to the actions
378
 
        self.chkbox_static_ip.connect("toggled", self.toggle_ip_checkbox)
379
 
        self.chkbox_static_dns.connect("toggled", self.toggle_dns_checkbox)
380
 
        self.chkbox_global_dns.connect("toggled", self.toggle_global_dns_checkbox)
381
 
 
382
 
        # Start with all disabled, then they will be enabled later.
383
 
        self.chkbox_static_ip.set_active(False)
384
 
        self.chkbox_static_dns.set_active(False)
385
 
 
386
 
    def set_defaults(self, widget=None, event=None):
387
 
        """ Put some default values into entries to help the user out. """
388
 
        ipAddress = self.txt_ip.get_text()  # For easy typing :)
389
 
        netmask = self.txt_netmask
390
 
        gateway = self.txt_gateway
391
 
        ip_parts = misc.IsValidIP(ipAddress)
392
 
        if ip_parts:
393
 
            if stringToNone(gateway.get_text()) is None:  # Make sure the gateway box is blank
394
 
                # Fill it in with a .1 at the end
395
 
                gateway.set_text('.'.join(ip_parts[0:3]) + '.1')
396
 
 
397
 
            if stringToNone(netmask.get_text()) is None:  # Make sure the netmask is blank
398
 
                netmask.set_text('255.255.255.0')  # Fill in the most common one
399
 
        elif ipAddress != "":
400
 
            error(None, "Invalid IP Address Entered.")
401
 
 
402
 
    def reset_static_checkboxes(self):
403
 
        # Enable the right stuff
404
 
        if stringToNone(self.txt_ip.get_text()):
405
 
            self.chkbox_static_ip.set_active(True)
406
 
            self.chkbox_static_dns.set_active(True)
407
 
            self.chkbox_static_dns.set_sensitive(False)
408
 
        else:
409
 
            self.chkbox_static_ip.set_active(False)
410
 
            self.chkbox_static_dns.set_sensitive(True)
411
 
 
412
 
        if stringToNone(self.txt_dns_1.get_text()) or \
413
 
           self.chkbox_global_dns.get_active():
414
 
            self.chkbox_static_dns.set_active(True)
415
 
        else:
416
 
            self.chkbox_static_dns.set_active(False)
417
 
 
418
 
        # This will properly disable unused boxes.
419
 
        self.toggle_ip_checkbox()
420
 
        self.toggle_dns_checkbox()
421
 
        self.toggle_global_dns_checkbox()
422
 
 
423
 
    def toggle_ip_checkbox(self, widget=None):
424
 
        """Toggle entries/checkboxes based on the static IP checkbox. """
425
 
        # Should disable the static IP text boxes, and also enable the DNS
426
 
        # checkbox when disabled and disable when enabled.
427
 
        if self.chkbox_static_ip.get_active():
428
 
            self.chkbox_static_dns.set_active(True)
429
 
            self.chkbox_static_dns.set_sensitive(False)
430
 
        else:
431
 
            self.chkbox_static_dns.set_sensitive(True)
432
 
            # When this is used and only static DNS
433
 
            # is used, the static dns checkbox will be disabled
434
 
            # self.chkbox_static_dns.set_active(False)
435
 
 
436
 
        self.txt_ip.set_sensitive(self.chkbox_static_ip.get_active())
437
 
        self.txt_netmask.set_sensitive(self.chkbox_static_ip.get_active())
438
 
        self.txt_gateway.set_sensitive(self.chkbox_static_ip.get_active())
439
 
 
440
 
    def toggle_dns_checkbox(self, widget=None):
441
 
        """ Toggle entries and checkboxes based on the static dns checkbox. """
442
 
        # Should disable the static DNS boxes
443
 
        if self.chkbox_static_ip.get_active():
444
 
            self.chkbox_static_dns.set_active(True)
445
 
            self.chkbox_static_dns.set_sensitive(False)
446
 
 
447
 
        self.chkbox_global_dns.set_sensitive(self.chkbox_static_dns.
448
 
                                             get_active())
449
 
        if self.chkbox_static_dns.get_active():
450
 
            # If global dns is on, don't use local dns
451
 
            self.txt_dns_1.set_sensitive(not self.chkbox_global_dns.get_active())
452
 
            self.txt_dns_2.set_sensitive(not self.chkbox_global_dns.get_active())
453
 
            self.txt_dns_3.set_sensitive(not self.chkbox_global_dns.get_active())
454
 
        else:
455
 
            self.txt_dns_1.set_sensitive(False)
456
 
            self.txt_dns_2.set_sensitive(False)
457
 
            self.txt_dns_3.set_sensitive(False)
458
 
            self.chkbox_global_dns.set_active(False)
459
 
 
460
 
    def toggle_global_dns_checkbox(self, widget=None):
461
 
        """ Set the DNS entries' sensitivity based on the Global checkbox. """
462
 
        if daemon.GetUseGlobalDNS() and self.chkbox_static_dns.get_active():
463
 
            self.txt_dns_1.set_sensitive(not self.chkbox_global_dns.get_active())
464
 
            self.txt_dns_2.set_sensitive(not self.chkbox_global_dns.get_active())
465
 
            self.txt_dns_3.set_sensitive(not self.chkbox_global_dns.get_active())
466
 
        elif self.chkbox_global_dns.get_active():
467
 
            self.chkbox_global_dns.set_active(False)
468
 
            error(None, language['no_global_dns'])
469
 
 
470
 
    def destroy_called(self):
471
 
        """ Clean up everything. """
472
 
        super(AdvancedSettingsDialog, self).destroy()
473
 
        self.destroy()
474
 
        del self
475
 
 
476
 
 
477
 
class WiredSettingsDialog(AdvancedSettingsDialog):
478
 
    def __init__(self, name):
479
 
        """ Build the wired settings dialog. """
480
 
        AdvancedSettingsDialog.__init__(self)
481
 
        self.des = self.connect("destroy", self.destroy_called)
482
 
        self.prof_name = name
483
 
 
484
 
    def set_net_prop(self, option, value):
485
 
        """ Sets the given option to the given value for this network. """
486
 
        wired.SetWiredProperty(option, value)
487
 
 
488
 
    def set_values(self):
489
 
        """ Fill in the Gtk.Entry objects with the correct values. """
490
 
        self.txt_ip.set_text(self.format_entry("ip"))
491
 
        self.txt_netmask.set_text(self.format_entry("netmask"))
492
 
        self.txt_gateway.set_text(self.format_entry("gateway"))
493
 
 
494
 
        self.txt_dns_1.set_text(self.format_entry("dns1"))
495
 
        self.txt_dns_2.set_text(self.format_entry("dns2"))
496
 
        self.txt_dns_3.set_text(self.format_entry("dns3"))
497
 
        self.chkbox_global_dns.set_active(bool(wired.GetWiredProperty("use_global_dns")))
498
 
        self.reset_static_checkboxes()
499
 
 
500
 
        if bool(wired.GetWiredProperty('use_global_dns')):
501
 
            self.chkbox_global_dns.set_active(True)
502
 
            self.chkbox_static_dns.set_active(True)
503
 
 
504
 
        self.toggle_dns_checkbox()
505
 
        self.toggle_ip_checkbox()
506
 
 
507
 
    def format_entry(self, label):
508
 
        """ Helper method to fetch and format wired properties. """
509
 
        return noneToBlankString(wired.GetWiredProperty(label))
510
 
 
511
 
    def destroy_called(self):
512
 
        """ Clean up everything. """
513
 
        self.disconnect(self.des)
514
 
        super(WiredSettingsDialog, self).destroy_called()
515
 
        self.destroy()
516
 
        del self
517
 
 
518
 
 
519
 
class WirelessSettingsDialog(AdvancedSettingsDialog):
520
 
    def __init__(self, networkID):
521
 
        """ Build the wireless settings dialog. """
522
 
        AdvancedSettingsDialog.__init__(self)
523
 
        # Set up encryption stuff
524
 
        self.networkID = networkID
525
 
        self.combo_encryption = gtk.combo_box_new_text()
526
 
        self.chkbox_encryption = gtk.CheckButton(language['use_encryption'])
527
 
        self.chkbox_global_settings = gtk.CheckButton(language['global_settings'])
528
 
        # Make the vbox to hold the encryption stuff.
529
 
        self.vbox_encrypt_info = gtk.VBox(False, 0)        
530
 
        self.toggle_encryption()
531
 
        self.chkbox_encryption.set_active(False)
532
 
        self.combo_encryption.set_sensitive(False)
533
 
        self.encrypt_types = misc.LoadEncryptionMethods()
534
 
 
535
 
        # Build the encryption menu
536
 
        activeID = -1  # Set the menu to this item when we are done
537
 
        for x, enc_type in enumerate(self.encrypt_types):
538
 
            self.combo_encryption.append_text(enc_type[0])
539
 
            if enc_type[1] == wireless.GetWirelessProperty(networkID,
540
 
                                                           "enctype"):
541
 
                activeID = x
542
 
        self.combo_encryption.set_active(activeID)
543
 
        if activeID != -1:
544
 
            self.chkbox_encryption.set_active(True)
545
 
            self.combo_encryption.set_sensitive(True)
546
 
            self.vbox_encrypt_info.set_sensitive(True)
547
 
        else:
548
 
            self.combo_encryption.set_active(0)
549
 
        self.change_encrypt_method()
550
 
 
551
 
        self.vbox.pack_start(self.chkbox_global_settings, False, False)
552
 
        self.vbox.pack_start(self.chkbox_encryption, False, False)
553
 
        self.vbox.pack_start(self.combo_encryption, False, False)
554
 
        self.vbox.pack_start(self.vbox_encrypt_info, False, False)
555
 
 
556
 
        # Connect signals.
557
 
        self.chkbox_encryption.connect("toggled", self.toggle_encryption)
558
 
        self.combo_encryption.connect("changed", self.change_encrypt_method)
559
 
        self.des = self.connect("destroy", self.destroy_called)
560
 
 
561
 
    def destroy_called(self):
562
 
        """ Clean up everything. """
563
 
        self.disconnect(self.des)
564
 
        super(WirelessSettingsDialog, self).destroy_called()
565
 
        self.destroy()
566
 
        del self
567
 
 
568
 
    def set_net_prop(self, option, value):
569
 
        """ Sets the given option to the given value for this network. """
570
 
        wireless.SetWirelessProperty(self.networkID, option, value)
571
 
 
572
 
    def set_values(self):
573
 
        """ Set the various network settings to the right values. """
574
 
        networkID = self.networkID
575
 
        self.txt_ip.set_text(self.format_entry(networkID,"ip"))
576
 
        self.txt_netmask.set_text(self.format_entry(networkID,"netmask"))
577
 
        self.txt_gateway.set_text(self.format_entry(networkID,"gateway"))
578
 
 
579
 
        self.txt_dns_1.set_text(self.format_entry(networkID, "dns1"))
580
 
        self.txt_dns_2.set_text(self.format_entry(networkID, "dns2"))
581
 
        self.txt_dns_3.set_text(self.format_entry(networkID, "dns3"))
582
 
 
583
 
        self.reset_static_checkboxes()
584
 
        self.chkbox_encryption.set_active(bool(wireless.GetWirelessProperty(networkID,
585
 
                                                                            'encryption')))
586
 
        self.chkbox_global_settings.set_active(bool(wireless.GetWirelessProperty(networkID,
587
 
                                                                                 'use_settings_globally')))
588
 
 
589
 
 
590
 
        activeID = -1  # Set the menu to this item when we are done
591
 
        user_enctype = wireless.GetWirelessProperty(networkID, "enctype")
592
 
        for x, enc_type in enumerate(self.encrypt_types):
593
 
            if enc_type[1] == user_enctype:
594
 
                activeID = x
595
 
 
596
 
        self.combo_encryption.set_active(activeID)
597
 
        if activeID != -1:
598
 
            self.chkbox_encryption.set_active(True)
599
 
            self.combo_encryption.set_sensitive(True)
600
 
            self.vbox_encrypt_info.set_sensitive(True)
601
 
        else:
602
 
            self.combo_encryption.set_active(0)
603
 
        self.change_encrypt_method()
604
 
 
605
 
        if bool(wireless.GetWirelessProperty(networkID, 'use_global_dns')):
606
 
            self.chkbox_global_dns.set_active(True)
607
 
            self.chkbox_static_dns.set_active(True)
608
 
 
609
 
        self.toggle_encryption()
610
 
        self.toggle_dns_checkbox()
611
 
        self.toggle_ip_checkbox()
612
 
 
613
 
    def format_entry(self, networkid, label):
614
 
        """ Helper method for fetching/formatting wireless properties. """
615
 
        return noneToBlankString(wireless.GetWirelessProperty(networkid, label))
616
 
 
617
 
    def toggle_encryption(self, widget=None):
618
 
        """ Toggle the encryption combobox based on the encryption checkbox. """
619
 
        active = self.chkbox_encryption.get_active()
620
 
        self.vbox_encrypt_info.set_sensitive(active)
621
 
        self.combo_encryption.set_sensitive(active)
622
 
 
623
 
    def change_encrypt_method(self, widget=None):
624
 
        """ Load all the entries for a given encryption method. """
625
 
        for z in self.vbox_encrypt_info:
626
 
            z.destroy()  # Remove stuff in there already
627
 
        ID = self.combo_encryption.get_active()
628
 
        methods = misc.LoadEncryptionMethods()
629
 
        self.encryption_info = {}
630
 
 
631
 
        # If nothing is selected, select the first entry.
632
 
        if ID == -1:
633
 
            self.combo_encryption.set_active(0)
634
 
            ID = 0
635
 
 
636
 
        opts = methods[ID][2]
637
 
        for x in opts:
638
 
            box = None
639
 
            if language.has_key(opts[x][0]):
640
 
                box = LabelEntry(language[opts[x][0].lower().replace(' ','_')])
641
 
            else:
642
 
                box = LabelEntry(opts[x][0].replace('_',' '))
643
 
            box.set_auto_hidden(True)
644
 
            self.vbox_encrypt_info.pack_start(box)
645
 
            #add the data to any array, so that the information
646
 
            #can be easily accessed by giving the name of the wanted
647
 
            #data
648
 
            self.encryption_info[opts[x][1]] = box.entry
649
 
            box.entry.set_text(noneToBlankString(
650
 
                wireless.GetWirelessProperty(self.networkID, opts[x][1])))
651
 
        self.vbox_encrypt_info.show_all() 
652
 
 
653
 
 
654
 
class NetworkEntry(gtk.HBox):
655
 
    def __init__(self):
656
 
        """ Base network entry class.
657
 
 
658
 
        Provides gtk objects used by both the WiredNetworkEntry and
659
 
        WirelessNetworkEntry classes.
660
 
 
661
 
        """
662
 
        gtk.HBox.__init__(self, False, 2)
663
 
        self.expander = gtk.Expander()
664
 
        self.image = gtk.Image()
665
 
        self.pack_start(self.image, False, False)
666
 
 
667
 
        # Set up the Connect button
668
 
        self.connect_button = gtk.Button(stock=gtk.STOCK_CONNECT)
669
 
        self.connect_hbox = gtk.HBox(False, 2)
670
 
        self.connect_hbox.pack_start(self.connect_button, False, False)
671
 
        self.connect_hbox.show()
672
 
 
673
 
        # Set up the Disconnect button
674
 
        self.disconnect_button = gtk.Button(stock=gtk.STOCK_DISCONNECT)
675
 
        self.connect_hbox.pack_start(self.disconnect_button, False, False)
676
 
 
677
 
        # Set up the VBox that goes in the gtk.Expander
678
 
        self.expander_vbox = gtk.VBox(False, 1)
679
 
        self.expander_vbox.show()
680
 
        self.expander_vbox.pack_start(self.expander)
681
 
        self.expander_vbox.pack_start(self.connect_hbox, False, False)
682
 
        self.pack_end(self.expander_vbox)
683
 
 
684
 
        # Set up the advanced settings button
685
 
        self.advanced_button = gtk.Button()
686
 
        self.advanced_image = gtk.Image()
687
 
        self.advanced_image.set_from_stock(gtk.STOCK_EDIT, 4)
688
 
        self.advanced_image.set_padding(4, 0)
689
 
        self.advanced_button.set_alignment(.5, .5)
690
 
        self.advanced_button.set_label(language['advanced_settings'])
691
 
        self.advanced_button.set_image(self.advanced_image)
692
 
 
693
 
        # Set up the script settings button
694
 
        self.script_button = gtk.Button()
695
 
        self.script_image = gtk.Image()
696
 
        self.script_image.set_from_stock(gtk.STOCK_EXECUTE, 4)
697
 
        self.script_image.set_padding(4, 0)
698
 
        self.script_button.set_alignment(.5, .5)
699
 
        self.script_button.set_image(self.script_image)
700
 
        self.script_button.set_label(language['scripts'])
701
 
 
702
 
        self.settings_hbox = gtk.HBox(False, 3)
703
 
        self.settings_hbox.set_border_width(5)
704
 
        self.settings_hbox.pack_start(self.script_button, False, False)
705
 
        self.settings_hbox.pack_start(self.advanced_button, False, False)
706
 
 
707
 
        self.vbox_top = gtk.VBox(False, 0)
708
 
        self.vbox_top.pack_end(self.settings_hbox, False, False)
709
 
 
710
 
        aligner = gtk.Alignment(xscale=1.0)
711
 
        aligner.add(self.vbox_top)
712
 
        aligner.set_padding(0, 0, 15, 0)
713
 
        self.expander.add(aligner)
714
 
 
715
 
    def destroy_called(self, *args):
716
 
        """ Clean up everything. """
717
 
        super(NetworkEntry, self).destroy()
718
 
        self.destroy()
719
 
        del self
720
 
 
721
 
 
722
 
class WiredNetworkEntry(NetworkEntry):
723
 
    def __init__(self):
724
 
        """ Load the wired network entry. """
725
 
        NetworkEntry.__init__(self)
726
 
        # Center the picture and pad it a bit
727
 
        self.image.set_alignment(.5, 0)
728
 
        self.image.set_size_request(60, -1)
729
 
        # Perhaps we can reconsider this later with themeable icons...
730
 
        #self.image.set_from_icon_name("network-wired", 6)
731
 
        self.image.set_from_file(wpath.images + 'wired.png')
732
 
        self.image.show()
733
 
        self.expander.show()
734
 
        self.connect_button.show()
735
 
 
736
 
        self.expander.set_label(language['wired_network'])
737
 
        #self.reset_static_checkboxes()
738
 
        self.is_full_gui = True
739
 
 
740
 
        self.button_add = gtk.Button(stock=gtk.STOCK_ADD)
741
 
        self.button_delete = gtk.Button(stock=gtk.STOCK_DELETE)
742
 
        self.profile_help = gtk.Label(language['wired_network_instructions'])
743
 
        self.chkbox_default_profile = gtk.CheckButton(language['default_wired'])
744
 
 
745
 
        # Build the profile list.
746
 
        self.combo_profile_names = gtk.combo_box_entry_new_text()
747
 
        self.profile_list = config.GetWiredProfileList()
748
 
        if self.profile_list:
749
 
            for x in self.profile_list:
750
 
                self.combo_profile_names.append_text(x)
751
 
 
752
 
        # Format the profile help label.
753
 
        self.profile_help.set_justify(gtk.JUSTIFY_LEFT)
754
 
        self.profile_help.set_line_wrap(True)
755
 
 
756
 
        # Pack the various VBox objects.
757
 
        self.hbox_temp = gtk.HBox(False, 0)
758
 
        self.hbox_def = gtk.HBox(False, 0)
759
 
        self.vbox_top.pack_start(self.profile_help, True, True)
760
 
        self.vbox_top.pack_start(self.hbox_def)
761
 
        self.vbox_top.pack_start(self.hbox_temp)
762
 
        self.hbox_temp.pack_start(self.combo_profile_names, True, True)
763
 
        self.hbox_temp.pack_start(self.button_add, False, False)
764
 
        self.hbox_temp.pack_start(self.button_delete, False, False)
765
 
        self.hbox_def.pack_start(self.chkbox_default_profile, False, False)
766
 
 
767
 
        # Connect events
768
 
        self.button_add.connect("clicked", self.add_profile)
769
 
        self.button_delete.connect("clicked", self.remove_profile)
770
 
        self.chkbox_default_profile.connect("toggled",
771
 
                                            self.toggle_default_profile)
772
 
        self.combo_profile_names.connect("changed", self.change_profile)
773
 
        self.script_button.connect("button-press-event", self.edit_scripts)
774
 
 
775
 
        # Toggle the default profile checkbox to the correct state.
776
 
        if stringToBoolean(wired.GetWiredProperty("default")):
777
 
            self.chkbox_default_profile.set_active(True)
778
 
        else:
779
 
            self.chkbox_default_profile.set_active(False)
780
 
 
781
 
        # Show everything, but hide the profile help label.
782
 
        self.show_all()
783
 
        self.profile_help.hide()
784
 
        self.advanced_dialog = WiredSettingsDialog(self.combo_profile_names.get_active_text())
785
 
 
786
 
        # Display the default profile if it exists.
787
 
        if self.profile_list is not None:
788
 
            prof = config.GetDefaultWiredNetwork()
789
 
            if prof != None:  # Make sure the default profile gets displayed.
790
 
                i = 0
791
 
                while self.combo_profile_names.get_active_text() != prof:
792
 
                    self.combo_profile_names.set_active(i)
793
 
                    i += 1
794
 
            else:
795
 
                self.combo_profile_names.set_active(0)
796
 
            print "wired profiles found"
797
 
            self.expander.set_expanded(False)
798
 
        else:
799
 
            print "no wired profiles found"
800
 
            if not wired.GetAlwaysShowWiredInterface():
801
 
                self.expander.set_expanded(True)
802
 
            self.profile_help.show()        
803
 
        self.check_enable()
804
 
        self.wireddis = self.connect("destroy", self.destroy_called)
805
 
 
806
 
    def destroy_called(self, *args):
807
 
        """ Clean up everything. """
808
 
        self.disconnect(self.wireddis)
809
 
        self.advanced_dialog.destroy_called()
810
 
        del self.advanced_dialog
811
 
        super(WiredNetworkEntry, self).destroy_called()
812
 
        self.destroy()
813
 
        del self
814
 
 
815
 
    def edit_scripts(self, widget=None, event=None):
816
 
        """ Launch the script editting dialog. """
817
 
        profile = self.combo_profile_names.get_active_text()
818
 
        cmdend = [os.path.join(wpath.lib, "configscript.py"), profile, "wired"]
819
 
        if os.getuid() != 0:
820
 
            cmdbase = misc.get_sudo_cmd(language['scripts_need_pass'])
821
 
            if not cmdbase:
822
 
                error(None, language["no_sudo_prog"]) 
823
 
                return
824
 
            cmdbase.extend(cmdend)
825
 
            misc.LaunchAndWait(cmdbase)
826
 
        else:
827
 
            misc.LaunchAndWait(cmdend)
828
 
 
829
 
 
830
 
    def check_enable(self):
831
 
        """ Disable objects if the profile list is empty. """
832
 
        profile_list = config.GetWiredProfileList()
833
 
        if profile_list == None:
834
 
            self.button_delete.set_sensitive(False)
835
 
            self.connect_button.set_sensitive(False)
836
 
            self.advanced_button.set_sensitive(False)
837
 
            self.script_button.set_sensitive(False)
838
 
 
839
 
    def update_connect_button(self, state, apbssid=None):
840
 
        """ Update the connection/disconnect button for this entry. """
841
 
        if state == misc.WIRED:
842
 
            self.disconnect_button.show()
843
 
            self.connect_button.hide()
844
 
        else:
845
 
            self.disconnect_button.hide()
846
 
            self.connect_button.show()
847
 
 
848
 
    def add_profile(self, widget):
849
 
        """ Add a profile to the profile list. """
850
 
        print "adding profile"
851
 
        profile_name = self.combo_profile_names.get_active_text()
852
 
        profile_list = config.GetWiredProfileList()
853
 
        if profile_list:
854
 
            if profile_name in profile_list:
855
 
                return False
856
 
        if profile_name != "":
857
 
            self.profile_help.hide()
858
 
            config.CreateWiredNetworkProfile(profile_name, False)
859
 
            self.combo_profile_names.prepend_text(profile_name)
860
 
            self.combo_profile_names.set_active(0)
861
 
            self.advanced_dialog.prof_name = profile_name
862
 
            if self.is_full_gui:
863
 
                self.button_delete.set_sensitive(True)
864
 
                self.connect_button.set_sensitive(True)
865
 
                self.advanced_button.set_sensitive(True)
866
 
                self.script_button.set_sensitive(True)
867
 
 
868
 
    def remove_profile(self, widget):
869
 
        """ Remove a profile from the profile list. """
870
 
        print "removing profile"
871
 
        profile_name = self.combo_profile_names.get_active_text()
872
 
        config.DeleteWiredNetworkProfile(profile_name)
873
 
        self.combo_profile_names.remove_text(self.combo_profile_names.
874
 
                                             get_active())
875
 
        self.combo_profile_names.set_active(0)
876
 
        self.advanced_dialog.prof_name = self.combo_profile_names.get_active_text()
877
 
        if not config.GetWiredProfileList():
878
 
            self.profile_help.show()
879
 
            entry = self.combo_profile_names.child
880
 
            entry.set_text("")
881
 
            if self.is_full_gui:
882
 
                self.button_delete.set_sensitive(False)
883
 
                self.advanced_button.set_sensitive(False)
884
 
                self.script_button.set_sensitive(False)
885
 
                self.connect_button.set_sensitive(False)
886
 
        else:
887
 
            self.profile_help.hide()
888
 
 
889
 
    def toggle_default_profile(self, widget):
890
 
        """ Change the default profile. """
891
 
        if self.chkbox_default_profile.get_active():
892
 
            # Make sure there is only one default profile at a time
893
 
            config.UnsetWiredDefault()
894
 
        wired.SetWiredProperty("default",
895
 
                               self.chkbox_default_profile.get_active())
896
 
        config.SaveWiredNetworkProfile(self.combo_profile_names.get_active_text())
897
 
 
898
 
    def change_profile(self, widget):
899
 
        """ Called when a new profile is chosen from the list. """
900
 
        # Make sure the name doesn't change everytime someone types something
901
 
        if self.combo_profile_names.get_active() > -1:
902
 
            if not self.is_full_gui:
903
 
                return
904
 
 
905
 
            profile_name = self.combo_profile_names.get_active_text()
906
 
            config.ReadWiredNetworkProfile(profile_name)
907
 
 
908
 
            self.advanced_dialog.txt_ip.set_text(self.format_entry("ip"))
909
 
            self.advanced_dialog.txt_netmask.set_text(self.format_entry("netmask"))
910
 
            self.advanced_dialog.txt_gateway.set_text(self.format_entry("gateway"))
911
 
            self.advanced_dialog.txt_dns_1.set_text(self.format_entry("dns1"))
912
 
            self.advanced_dialog.txt_dns_2.set_text(self.format_entry("dns2"))
913
 
            self.advanced_dialog.txt_dns_3.set_text(self.format_entry("dns3"))
914
 
            self.advanced_dialog.prof_name = profile_name
915
 
 
916
 
            is_default = wired.GetWiredProperty("default")
917
 
            self.chkbox_default_profile.set_active(stringToBoolean(is_default))
918
 
 
919
 
    def format_entry(self, label):
920
 
        """ Help method for fetching/formatting wired properties. """
921
 
        return noneToBlankString(wired.GetWiredProperty(label))
922
 
 
923
 
 
924
 
class WirelessNetworkEntry(NetworkEntry):
925
 
    def __init__(self, networkID, iwconfig=""):
926
 
        """ Build the wireless network entry. """
927
 
        NetworkEntry.__init__(self)
928
 
 
929
 
        self.networkID = networkID
930
 
        self.image.set_padding(0, 0)
931
 
        self.image.set_alignment(.5, 0)
932
 
        self.image.set_size_request(60, -1)
933
 
        # Perhaps we can reconsider this later with themeable icons...
934
 
        self.image.set_from_icon_name("network-wired", 6)
935
 
        #self.image.set_from_file(wpath.images + 'wired.png')
936
 
        self.essid = noneToBlankString(wireless.GetWirelessProperty(networkID, 
937
 
                                                                    "essid"))
938
 
        # Make the combo box.
939
 
        self.lbl_strength = GreyLabel()
940
 
        self.lbl_encryption = GreyLabel()
941
 
        self.lbl_mac = GreyLabel()
942
 
        self.lbl_channel = GreyLabel()
943
 
        self.lbl_mode = GreyLabel()
944
 
        self.hbox_status = gtk.HBox(False, 5)
945
 
        self.chkbox_autoconnect = gtk.CheckButton(language['automatic_connect'])
946
 
 
947
 
        # Set the values of the network info labels.
948
 
        self.set_signal_strength(wireless.GetWirelessProperty(networkID, 
949
 
                                                              'quality'),
950
 
                                 wireless.GetWirelessProperty(networkID, 
951
 
                                                              'strength'))
952
 
        self.set_mac_address(wireless.GetWirelessProperty(networkID, 'bssid'))
953
 
        self.set_mode(wireless.GetWirelessProperty(networkID, 'mode'))
954
 
        self.set_channel(wireless.GetWirelessProperty(networkID, 'channel'))
955
 
        self.set_encryption(wireless.GetWirelessProperty(networkID,
956
 
                                                         'encryption'),
957
 
                            wireless.GetWirelessProperty(networkID, 
958
 
                                                         'encryption_method'))
959
 
 
960
 
        # The the expander label.
961
 
        self.expander.set_use_markup(True)
962
 
 
963
 
        self.expander.set_label(self._escape(self.essid) + "   " + 
964
 
                                self.lbl_strength.get_label() + "   " +
965
 
                                self.lbl_encryption.get_label() + "   " +
966
 
                                self.lbl_mac.get_label())
967
 
 
968
 
        # Pack the network status HBox.
969
 
        self.hbox_status.pack_start(self.lbl_strength, True, True)
970
 
        self.hbox_status.pack_start(self.lbl_encryption, True, True)
971
 
        self.hbox_status.pack_start(self.lbl_mac, True, True)
972
 
        self.hbox_status.pack_start(self.lbl_mode, True, True)
973
 
        self.hbox_status.pack_start(self.lbl_channel, True, True)
974
 
 
975
 
        # Add the wireless network specific parts to the NetworkEntry
976
 
        # VBox objects.
977
 
        self.vbox_top.pack_start(self.chkbox_autoconnect, False, False)
978
 
        self.vbox_top.pack_start(self.hbox_status, True, True)
979
 
 
980
 
        if stringToBoolean(self.format_entry(networkID, "automatic")):
981
 
            self.chkbox_autoconnect.set_active(True)
982
 
        else:
983
 
            self.chkbox_autoconnect.set_active(False)
984
 
 
985
 
        # Connect signals.
986
 
        self.chkbox_autoconnect.connect("toggled", self.update_autoconnect)
987
 
        self.script_button.connect("button-press-event", self.edit_scripts)       
988
 
 
989
 
        # Show everything
990
 
        self.show_all()
991
 
        self.advanced_dialog = WirelessSettingsDialog(networkID)
992
 
        self.wifides = self.connect("destroy", self.destroy_called)
993
 
 
994
 
    def _escape(self, val):
995
 
        return val.replace("&", "&amp;").replace("<", "&lt;").\
996
 
               replace(">","&gt;").replace("'", "&apos;").replace('"', "&quot;")
997
 
 
998
 
    def destroy_called(self, *args):
999
 
        """ Clean up everything. """
1000
 
        self.disconnect(self.wifides)
1001
 
        self.advanced_dialog.destroy_called()
1002
 
        del self.advanced_dialog
1003
 
        super(WirelessNetworkEntry, self).destroy_called()
1004
 
        self.destroy()
1005
 
        del self
1006
 
 
1007
 
    def set_signal_strength(self, strength, dbm_strength):
1008
 
        """ Set the signal strength displayed in the WirelessNetworkEntry. """
1009
 
        if strength is not None:
1010
 
            strength = int(strength)
1011
 
        else:
1012
 
            strength = -1
1013
 
        if dbm_strength is not None:
1014
 
            dbm_strength = int(dbm_strength)
1015
 
        else:
1016
 
            dbm_strength = -100
1017
 
        display_type = daemon.GetSignalDisplayType()
1018
 
        if daemon.GetWPADriver() == 'ralink legacy' or display_type == 1:
1019
 
            # Use the -xx dBm signal strength to display a signal icon
1020
 
            # I'm not sure how accurately the dBm strength is being
1021
 
            # "converted" to strength bars, so suggestions from people
1022
 
            # for a better way would be welcome.
1023
 
            if dbm_strength >= -60:
1024
 
                signal_img = 'signal-100.png'
1025
 
            elif dbm_strength >= -70:
1026
 
                signal_img = 'signal-75.png'
1027
 
            elif dbm_strength >= -80:
1028
 
                signal_img = 'signal-50.png'
1029
 
            else:
1030
 
                signal_img = 'signal-25.png'
1031
 
            ending = "dBm"
1032
 
            disp_strength = str(dbm_strength)
1033
 
        else:
1034
 
            # Uses normal link quality, should be fine in most cases
1035
 
            if strength > 75:
1036
 
                signal_img = 'signal-100.png'
1037
 
            elif strength > 50:
1038
 
                signal_img = 'signal-75.png'
1039
 
            elif strength > 25:
1040
 
                signal_img = 'signal-50.png'
1041
 
            else:
1042
 
                signal_img = 'signal-25.png'
1043
 
            ending = "%"
1044
 
            disp_strength = str(strength)
1045
 
 
1046
 
        self.image.set_from_file(wpath.images + signal_img)
1047
 
        self.lbl_strength.set_label(disp_strength + ending)
1048
 
 
1049
 
    def update_connect_button(self, state, apbssid):
1050
 
        """ Update the connection/disconnect button for this entry. """
1051
 
        if not apbssid:
1052
 
            apbssid = wireless.GetApBssid()
1053
 
        if state == misc.WIRELESS and \
1054
 
           apbssid == wireless.GetWirelessProperty(self.networkID, "bssid"):
1055
 
            self.disconnect_button.show()
1056
 
            self.connect_button.hide()
1057
 
        else:
1058
 
            self.disconnect_button.hide()
1059
 
            self.connect_button.show()
1060
 
 
1061
 
    def set_mac_address(self, address):
1062
 
        """ Set the MAC address for the WirelessNetworkEntry. """
1063
 
        self.lbl_mac.set_label(str(address))
1064
 
 
1065
 
    def set_encryption(self, on, ttype):
1066
 
        """ Set the encryption value for the WirelessNetworkEntry. """
1067
 
        if on and ttype:
1068
 
            self.lbl_encryption.set_label(str(ttype))
1069
 
        if on and not ttype: 
1070
 
            self.lbl_encryption.set_label(language['secured'])
1071
 
        if not on:
1072
 
            self.lbl_encryption.set_label(language['unsecured'])
1073
 
 
1074
 
    def set_channel(self, channel):
1075
 
        """ Set the channel value for the WirelessNetworkEntry. """
1076
 
        self.lbl_channel.set_label(language['channel'] + ' ' + str(channel))
1077
 
 
1078
 
    def set_mode(self, mode):
1079
 
        """ Set the mode value for the WirelessNetworkEntry. """
1080
 
        self.lbl_mode.set_label(str(mode))
1081
 
 
1082
 
    def format_entry(self, networkid, label):
1083
 
        """ Helper method for fetching/formatting wireless properties. """
1084
 
        return noneToBlankString(wireless.GetWirelessProperty(networkid, label))
1085
 
 
1086
 
    def edit_scripts(self, widget=None, event=None):
1087
 
        """ Launch the script editting dialog. """
1088
 
        cmdend = [os.path.join(wpath.lib, "configscript.py"), 
1089
 
                                str(self.networkID), "wireless"]
1090
 
        if os.getuid() != 0:
1091
 
            cmdbase = misc.get_sudo_cmd(language['scripts_need_pass'])
1092
 
            if not cmdbase:
1093
 
                error(None, language["no_sudo_prog"]) 
1094
 
                return
1095
 
            cmdbase.extend(cmdend)
1096
 
            misc.LaunchAndWait(cmdbase)
1097
 
        else:
1098
 
            misc.LaunchAndWait(cmdend)
1099
 
 
1100
 
    def update_autoconnect(self, widget=None):
1101
 
        """ Called when the autoconnect checkbox is toggled. """
1102
 
        wireless.SetWirelessProperty(self.networkID, "automatic",
1103
 
                                     noneToString(self.chkbox_autoconnect.
1104
 
                                                  get_active()))
1105
 
        config.SaveWirelessNetworkProperty(self.networkID, "automatic")
1106
 
 
1107
 
 
 
49
proxy_obj = daemon = wireless = wired = bus = None
 
50
DBUS_AVAIL = False
 
51
 
 
52
def setup_dbus(force=True):
 
53
    global bus, daemon, wireless, wired, DBUS_AVAIL
 
54
    try:
 
55
        dbusmanager.connect_to_dbus()
 
56
    except DBusException:
 
57
        if force:
 
58
            print "Can't connect to the daemon, trying to start it automatically..."
 
59
            if not misc.PromptToStartDaemon():
 
60
                print "Failed to find a graphical sudo program, cannot continue."
 
61
                return False
 
62
            try:
 
63
                dbusmanager.connect_to_dbus()
 
64
            except DBusException:
 
65
                error(None, "Could not connect to wicd's D-Bus interface.  " +
 
66
                      "Check the wicd log for error messages.")
 
67
                return False
 
68
        else:  
 
69
            return False
 
70
    prefs.setup_dbus()
 
71
    netentry.setup_dbus()
 
72
    bus = dbusmanager.get_bus()
 
73
    dbus_ifaces = dbusmanager.get_dbus_ifaces()
 
74
    daemon = dbus_ifaces['daemon']
 
75
    wireless = dbus_ifaces['wireless']
 
76
    wired = dbus_ifaces['wired']
 
77
    DBUS_AVAIL = True
 
78
    
 
79
    return True
 
80
 
 
81
def handle_no_dbus(from_tray=False):
 
82
    global DBUS_AVAIL
 
83
    DBUS_AVAIL = False
 
84
    if from_tray: return False
 
85
    print "Wicd daemon is shutting down!"
 
86
    error(None, language['lost_dbus'], block=False)
 
87
    return False
 
88
 
 
89
        
1108
90
class WiredProfileChooser:
1109
91
    """ Class for displaying the wired profile chooser. """
1110
92
    def __init__(self):
1149
131
        response = dialog.run()
1150
132
        if response == 1:
1151
133
            print 'reading profile ', wired_profiles.get_active_text()
1152
 
            config.ReadWiredNetworkProfile(wired_profiles.get_active_text())
 
134
            wired.ReadWiredNetworkProfile(wired_profiles.get_active_text())
1153
135
            wired.ConnectWired()
1154
136
        else:
1155
137
            if stoppopcheckbox.get_active():
1157
139
        dialog.destroy()
1158
140
 
1159
141
 
1160
 
class appGui:
 
142
class appGui(object):
1161
143
    """ The main wicd GUI class. """
1162
 
    def __init__(self, standalone=False):
 
144
    def __init__(self, standalone=False, tray=None):
1163
145
        """ Initializes everything needed for the GUI. """
1164
 
        gladefile = wpath.share + "wicd.glade"
1165
 
        self.windowname = "gtkbench"
 
146
        setup_dbus()
 
147
 
 
148
        self.tray = tray
 
149
 
 
150
        gladefile = os.path.join(wpath.share, "wicd.glade")
1166
151
        self.wTree = gtk.glade.XML(gladefile)
 
152
        self.window = self.wTree.get_widget("window1")
 
153
        self.window.set_icon_name("wicd-client")
 
154
        size = daemon.ReadWindowSize("main")
 
155
        width = size[0]
 
156
        height = size[1]
 
157
        if width > -1 and height > -1:
 
158
            self.window.resize(int(width), int(height))
 
159
        else:
 
160
            width = int(gtk.gdk.screen_width() / 2)
 
161
            if width > 530:
 
162
                width = 530
 
163
            self.window.resize(width, int(gtk.gdk.screen_height() / 1.7))
1167
164
 
1168
 
        dic = { "refresh_clicked" : self.refresh_networks, 
 
165
        dic = { "refresh_clicked" : self.refresh_clicked, 
1169
166
                "quit_clicked" : self.exit, 
1170
167
                "disconnect_clicked" : self.disconnect_all,
1171
168
                "main_exit" : self.exit, 
1172
169
                "cancel_clicked" : self.cancel_connect,
1173
 
                "connect_clicked" : self.connect_hidden,
 
170
                "hidden_clicked" : self.connect_hidden,
1174
171
                "preferences_clicked" : self.settings_dialog,
1175
172
                "about_clicked" : self.about_dialog,
1176
 
                "create_adhoc_network_button_button" : self.create_adhoc_network}
 
173
                "create_adhoc_clicked" : self.create_adhoc_network,
 
174
                }
1177
175
        self.wTree.signal_autoconnect(dic)
1178
176
 
1179
177
        # Set some strings in the GUI - they may be translated
1182
180
 
1183
181
        probar = self.wTree.get_widget("progressbar")
1184
182
        probar.set_text(language['connecting'])
1185
 
 
1186
 
        self.window = self.wTree.get_widget("window1")
 
183
        
1187
184
        self.network_list = self.wTree.get_widget("network_list_vbox")
1188
185
        self.status_area = self.wTree.get_widget("connecting_hbox")
1189
186
        self.status_bar = self.wTree.get_widget("statusbar")
 
187
        menu = self.wTree.get_widget("menu1")
1190
188
 
1191
189
        self.status_area.hide_all()
1192
190
 
1193
 
        # self.window.set_icon_from_file(wpath.etc + "wicd.png")
1194
 
        if os.path.exists(wpath.images + "wicd-client.png"):
1195
 
            self.window.set_icon_from_file(wpath.images + "wicd-client.png")
 
191
        if os.path.exists(os.path.join(wpath.images, "wicd.png")):
 
192
            self.window.set_icon_from_file(os.path.join(wpath.images, "wicd.png"))
1196
193
        self.statusID = None
1197
194
        self.first_dialog_load = True
1198
 
        self.vpn_connection_pipe = None
1199
195
        self.is_visible = True
1200
196
        self.pulse_active = False
 
197
        self.pref = None
1201
198
        self.standalone = standalone
1202
199
        self.wpadrivercombo = None
1203
200
        self.connecting = False
1204
 
        self.prev_state = False
1205
 
        self.refresh_networks(fresh=False)
1206
 
 
 
201
        self.refreshing = False
 
202
        self.prev_state = None
 
203
        self.update_cb = None
 
204
        self.network_list.set_sensitive(False)
 
205
        label = gtk.Label("%s..." % language['scanning'])
 
206
        self.network_list.pack_start(label)
 
207
        label.show()
 
208
        self.wait_for_events(0.2)
1207
209
        self.window.connect('delete_event', self.exit)
1208
210
        self.window.connect('key-release-event', self.key_event)
1209
 
 
1210
 
        size = config.ReadWindowSize("main")
1211
 
        width = size[0]
1212
 
        height = size[1]
1213
 
        if width > -1 and height > -1:
1214
 
            self.window.resize(int(width), int(height))
1215
 
 
1216
 
        try:
1217
 
            gobject.timeout_add_seconds(1, self.update_statusbar)
1218
 
        except:
1219
 
            gobject.timeout_add(1000, self.update_statusbar)
 
211
        daemon.SetGUIOpen(True)
 
212
        bus.add_signal_receiver(self.dbus_scan_finished, 'SendEndScanSignal',
 
213
                        'org.wicd.daemon.wireless')
 
214
        bus.add_signal_receiver(self.dbus_scan_started, 'SendStartScanSignal',
 
215
                        'org.wicd.daemon.wireless')
 
216
        bus.add_signal_receiver(self.update_connect_buttons, 'StatusChanged',
 
217
                        'org.wicd.daemon')
 
218
        bus.add_signal_receiver(self.handle_connection_results,
 
219
                                'ConnectResultsSent', 'org.wicd.daemon')
 
220
        bus.add_signal_receiver(lambda: setup_dbus(force=False), 
 
221
                                "DaemonStarting", "org.wicd.daemon")
 
222
        bus.add_signal_receiver(self._do_statusbar_update, 'StatusChanged',
 
223
                                'org.wicd.daemon')
 
224
        if standalone:
 
225
            bus.add_signal_receiver(handle_no_dbus, "DaemonClosing", 
 
226
                                    "org.wicd.daemon")
 
227
            
 
228
        self._do_statusbar_update(*daemon.GetConnectionStatus())
 
229
        self.wait_for_events(0.1)
 
230
        self.update_cb = misc.timeout_add(2, self.update_statusbar)
 
231
        self.refresh_clicked()
 
232
        
 
233
    def handle_connection_results(self, results):
 
234
        if results not in ['Success', 'aborted'] and self.is_visible:
 
235
            error(self.window, language[results], block=False)
1220
236
 
1221
237
    def create_adhoc_network(self, widget=None):
1222
238
        """ Shows a dialog that creates a new adhoc network. """
1223
239
        print "Starting the Ad-Hoc Network Creation Process..."
1224
240
        dialog = gtk.Dialog(title = language['create_adhoc_network'],
1225
241
                            flags = gtk.DIALOG_MODAL,
1226
 
                            buttons=(gtk.STOCK_OK, 1, gtk.STOCK_CANCEL, 2))
 
242
                            buttons=(gtk.STOCK_CANCEL, 2, gtk.STOCK_OK, 1))
1227
243
        dialog.set_has_separator(False)
1228
244
        dialog.set_size_request(400, -1)
1229
245
        self.chkbox_use_encryption = gtk.CheckButton(language['use_wep_encryption'])
1270
286
 
1271
287
    def disconnect_all(self, widget=None):
1272
288
        """ Disconnects from any active network. """
1273
 
        daemon.Disconnect()
 
289
        def handler(*args):
 
290
            gobject.idle_add(self.network_list.set_sensitive, True)
 
291
         
 
292
        self.network_list.set_sensitive(False)
 
293
        daemon.Disconnect(reply_handler=handler, error_handler=handler)
1274
294
 
1275
295
    def about_dialog(self, widget, event=None):
1276
296
        """ Displays an about dialog. """
1281
301
        dialog.set_website("http://wicd.sourceforge.net")
1282
302
        dialog.run()
1283
303
        dialog.destroy()
1284
 
 
 
304
        
1285
305
    def key_event (self, widget, event=None):
1286
306
        """ Handle key-release-events. """
1287
307
        if event.state & gtk.gdk.CONTROL_MASK and \
1288
308
           gtk.gdk.keyval_name(event.keyval) in ["w", "q"]:
1289
309
            self.exit()
1290
 
 
 
310
    
1291
311
    def settings_dialog(self, widget, event=None):
1292
312
        """ Displays a general settings dialog. """
1293
 
        dialog = self.wTree.get_widget("pref_dialog")
1294
 
        dialog.set_title(language['preferences'])
1295
 
        size = config.ReadWindowSize("pref")
1296
 
        width = size[0]
1297
 
        height = size[1]
1298
 
        if width > -1 and height > -1:
1299
 
            dialog.resize(int(width), int(height))
1300
 
        wiredcheckbox = self.wTree.get_widget("pref_always_check")
1301
 
        wiredcheckbox.set_label(language['wired_always_on'])
1302
 
        wiredcheckbox.set_active(wired.GetAlwaysShowWiredInterface())
1303
 
 
1304
 
        reconnectcheckbox = self.wTree.get_widget("pref_auto_check")
1305
 
        reconnectcheckbox.set_label(language['auto_reconnect'])
1306
 
        reconnectcheckbox.set_active(daemon.GetAutoReconnect())
1307
 
 
1308
 
        debugmodecheckbox = self.wTree.get_widget("pref_debug_check")
1309
 
        debugmodecheckbox.set_label(language['use_debug_mode'])
1310
 
        debugmodecheckbox.set_active(daemon.GetDebugMode())
1311
 
 
1312
 
        displaytypecheckbox = self.wTree.get_widget("pref_dbm_check")
1313
 
        displaytypecheckbox.set_label(language['display_type_dialog'])
1314
 
        displaytypecheckbox.set_active(daemon.GetSignalDisplayType())
1315
 
 
1316
 
        entryWiredAutoMethod = self.wTree.get_widget("pref_wired_auto_label")
1317
 
        entryWiredAutoMethod.set_label('Wired Autoconnect Setting:')
1318
 
        usedefaultradiobutton = self.wTree.get_widget("pref_use_def_radio")
1319
 
        usedefaultradiobutton.set_label(language['use_default_profile'])
1320
 
        showlistradiobutton = self.wTree.get_widget("pref_prompt_radio")
1321
 
        showlistradiobutton.set_label(language['show_wired_list'])
1322
 
        lastusedradiobutton = self.wTree.get_widget("pref_use_last_radio")
1323
 
        lastusedradiobutton.set_label(language['use_last_used_profile'])
1324
 
 
1325
 
        ## External Programs tab
1326
 
        self.wTree.get_widget("gen_settings_label").set_label(language["gen_settings"])
1327
 
        self.wTree.get_widget("ext_prog_label").set_label(language["ext_programs"])
1328
 
        self.wTree.get_widget("dhcp_client_label").set_label(language["dhcp_client"])
1329
 
        self.wTree.get_widget("wired_detect_label").set_label(language["wired_detect"])
1330
 
        self.wTree.get_widget("route_flush_label").set_label(language["route_flush"])
1331
 
 
1332
 
        # DHCP Clients
1333
 
        dhcpautoradio = self.wTree.get_widget("dhcp_auto_radio")
1334
 
        dhcpautoradio.set_label(language["wicd_auto_config"])
1335
 
        dhclientradio = self.wTree.get_widget("dhclient_radio")
1336
 
        pumpradio = self.wTree.get_widget("pump_radio")
1337
 
        dhcpcdradio = self.wTree.get_widget("dhcpcd_radio")
1338
 
        dhcp_list = [dhcpautoradio, dhclientradio, dhcpcdradio, pumpradio]
1339
 
 
1340
 
        dhcp_method = daemon.GetDHCPClient()
1341
 
        dhcp_list[dhcp_method].set_active(True)
1342
 
 
1343
 
        # Wired Link Detection Apps
1344
 
        linkautoradio = self.wTree.get_widget("link_auto_radio")
1345
 
        linkautoradio.set_label(language['wicd_auto_config'])
1346
 
        linkautoradio = self.wTree.get_widget("link_auto_radio")
1347
 
        ethtoolradio = self.wTree.get_widget("ethtool_radio")
1348
 
        miitoolradio = self.wTree.get_widget("miitool_radio")
1349
 
        wired_link_list = [linkautoradio, ethtoolradio, miitoolradio]
1350
 
        wired_link_method = daemon.GetLinkDetectionTool()
1351
 
        wired_link_list[wired_link_method].set_active(True)
1352
 
 
1353
 
        # Route Flushing Apps
1354
 
        flushautoradio = self.wTree.get_widget("flush_auto_radio")
1355
 
        flushautoradio.set_label(language['wicd_auto_config'])
1356
 
        ipflushradio = self.wTree.get_widget("ip_flush_radio")
1357
 
        routeflushradio = self.wTree.get_widget("route_flush_radio")
1358
 
        flush_list = [flushautoradio, ipflushradio, routeflushradio]
1359
 
        flush_method = daemon.GetFlushTool()
1360
 
        flush_list[flush_method].set_active(True)
1361
 
 
1362
 
        if wired.GetWiredAutoConnectMethod() == 1:
1363
 
            usedefaultradiobutton.set_active(True)
1364
 
        elif wired.GetWiredAutoConnectMethod() == 2:
1365
 
            showlistradiobutton.set_active(True)
1366
 
        elif wired.GetWiredAutoConnectMethod() == 3:
1367
 
            lastusedradiobutton.set_active(True)
1368
 
 
1369
 
        self.set_label("pref_driver_label", language['wpa_supplicant_driver'] +
1370
 
                       ':')
1371
 
 
1372
 
        # Hack to get the combo box we need, which you can't do with glade.
1373
 
        wpa_hbox = self.wTree.get_widget("hbox_wpa")
1374
 
        if not self.first_dialog_load:
1375
 
            wpa_hbox.remove(self.wpadrivercombo)
1376
 
        else:
1377
 
            self.first_dialog_load = False
1378
 
        self.wpadrivercombo = gtk.combo_box_new_text()
1379
 
        wpadrivercombo = self.wpadrivercombo  # Just to make my life easier
1380
 
        wpa_hbox.pack_end(wpadrivercombo)
1381
 
 
1382
 
        wpadrivers = ["wext", "hostap", "madwifi", "atmel", "ndiswrapper", 
1383
 
                      "ipw", "ralink legacy"]
1384
 
        found = False
1385
 
        def_driver = daemon.GetWPADriver()
1386
 
        for i, x in enumerate(wpadrivers):
1387
 
            if x == def_driver: #and not found:
1388
 
                found = True
1389
 
                user_driver_index = i
1390
 
            wpadrivercombo.append_text(x)
1391
 
 
1392
 
        # Set the active choice here.  Doing it before all the items are
1393
 
        # added the combobox causes the choice to be reset.
1394
 
        if found:
1395
 
            wpadrivercombo.set_active(user_driver_index)
1396
 
        else:
1397
 
            # Use wext as default, since normally it is the correct driver.
1398
 
            wpadrivercombo.set_active(0)
1399
 
 
1400
 
        self.set_label("pref_wifi_label", language['wireless_interface'] + ':')
1401
 
        self.set_label("pref_wired_label", language['wired_interface'] + ':')
1402
 
 
1403
 
        entryWirelessInterface = self.wTree.get_widget("pref_wifi_entry")
1404
 
        entryWirelessInterface.set_text(daemon.GetWirelessInterface())
1405
 
 
1406
 
        entryWiredInterface = self.wTree.get_widget("pref_wired_entry")
1407
 
        entryWiredInterface.set_text(daemon.GetWiredInterface())
1408
 
 
1409
 
        # Set up global DNS stuff
1410
 
        useGlobalDNSCheckbox = self.wTree.get_widget("pref_global_check")
1411
 
        useGlobalDNSCheckbox.set_label(language['use_global_dns'])
1412
 
 
1413
 
        dns1Entry = self.wTree.get_widget("pref_dns1_entry")
1414
 
        dns2Entry = self.wTree.get_widget("pref_dns2_entry")
1415
 
        dns3Entry = self.wTree.get_widget("pref_dns3_entry")
1416
 
        self.set_label("pref_dns1_label", language['dns'] + ' ' + language['1'])
1417
 
        self.set_label("pref_dns2_label", language['dns'] + ' ' + language['2'])
1418
 
        self.set_label("pref_dns3_label", language['dns'] + ' ' + language['3'])
1419
 
 
1420
 
        useGlobalDNSCheckbox.connect("toggled", checkboxTextboxToggle,
1421
 
                                     (dns1Entry, dns2Entry, dns3Entry))
1422
 
 
1423
 
        dns_addresses = daemon.GetGlobalDNSAddresses()
1424
 
        useGlobalDNSCheckbox.set_active(daemon.GetUseGlobalDNS())
1425
 
        dns1Entry.set_text(noneToBlankString(dns_addresses[0]))
1426
 
        dns2Entry.set_text(noneToBlankString(dns_addresses[1]))
1427
 
        dns3Entry.set_text(noneToBlankString(dns_addresses[2]))
1428
 
 
1429
 
        if not daemon.GetUseGlobalDNS():
1430
 
            dns1Entry.set_sensitive(False)
1431
 
            dns2Entry.set_sensitive(False)
1432
 
            dns3Entry.set_sensitive(False)
1433
 
 
1434
 
        # Bold/Align the Wired Autoconnect label.
1435
 
        entryWiredAutoMethod.set_alignment(0, 0)
1436
 
        atrlist = pango.AttrList()
1437
 
        atrlist.insert(pango.AttrWeight(pango.WEIGHT_BOLD, 0, 50))
1438
 
        entryWiredAutoMethod.set_attributes(atrlist)
1439
 
 
1440
 
        self.wTree.get_widget("notebook2").set_current_page(0)
1441
 
        dialog.show_all()
1442
 
 
1443
 
        invalid = True
1444
 
        response = -1
1445
 
        while invalid:
1446
 
            response = dialog.run()
1447
 
            invalid = False
1448
 
            if response == 1:
1449
 
                if useGlobalDNSCheckbox.get_active():
1450
 
                    if not misc.IsValidIP(dns1Entry.get_text()):
1451
 
                        invalid = True
1452
 
                    if dns3Entry.get_text() and \
1453
 
                       not misc.IsValidIP(dns2Entry.get_text()):
1454
 
                        invalid = True
1455
 
                    if dns3Entry.get_text() and \
1456
 
                       not misc.IsValidIP(dns3Entry.get_text()):
1457
 
                        invalid = True
1458
 
                else:
1459
 
                    for ent in [dns1Entry, dns2Entry, dns3Entry]:
1460
 
                        ent.set_text("")
1461
 
 
1462
 
                if invalid: error(dialog, "One or more of your global DNS servers are invalid.")
1463
 
 
1464
 
        if response == 1:
1465
 
            daemon.SetUseGlobalDNS(useGlobalDNSCheckbox.get_active())
1466
 
            daemon.SetGlobalDNS(dns1Entry.get_text(), dns2Entry.get_text(),
1467
 
                                dns3Entry.get_text())
1468
 
            daemon.SetWirelessInterface(entryWirelessInterface.get_text())
1469
 
            daemon.SetWiredInterface(entryWiredInterface.get_text())
1470
 
            daemon.SetWPADriver(wpadrivers[wpadrivercombo.get_active()])
1471
 
            wired.SetAlwaysShowWiredInterface(wiredcheckbox.get_active())
1472
 
            daemon.SetAutoReconnect(reconnectcheckbox.get_active())
1473
 
            daemon.SetDebugMode(debugmodecheckbox.get_active())
1474
 
            daemon.SetSignalDisplayType(int(displaytypecheckbox.get_active()))
1475
 
            if showlistradiobutton.get_active():
1476
 
                wired.SetWiredAutoConnectMethod(2)
1477
 
            elif lastusedradiobutton.get_active():
1478
 
                wired.SetWiredAutoConnectMethod(3)
1479
 
            else:
1480
 
                wired.SetWiredAutoConnectMethod(1)
1481
 
 
1482
 
            # External Programs Tab
1483
 
            if dhcpautoradio.get_active():
1484
 
                dhcp_client = misc.AUTO
1485
 
            elif dhclientradio.get_active():
1486
 
                dhcp_client = misc.DHCLIENT
1487
 
            elif dhcpcdradio.get_active():
1488
 
                dhcp_client = misc.DHCPCD
1489
 
            else:
1490
 
                dhcp_client = misc.PUMP
1491
 
            daemon.SetDHCPClient(dhcp_client)
1492
 
 
1493
 
            if linkautoradio.get_active():
1494
 
                link_tool = misc.AUTO
1495
 
            elif ethtoolradio.get_active():
1496
 
                link_tool = misc.ETHTOOL
1497
 
            else:
1498
 
                link_tool = misc.MIITOOL
1499
 
            daemon.SetLinkDetectionTool(link_tool)
1500
 
 
1501
 
            if flushautoradio.get_active():
1502
 
                flush_tool = misc.AUTO
1503
 
            elif ipflushradio.get_active():
1504
 
                flush_tool = misc.IP
1505
 
            else:
1506
 
                flush_tool = misc.ROUTE
1507
 
            daemon.SetFlushTool(flush_tool)
1508
 
 
1509
 
        dialog.hide()
1510
 
        [width, height] = dialog.get_size()
1511
 
        config.WriteWindowSize(width, height, "pref")
1512
 
 
1513
 
    def set_label(self, glade_str, label):
1514
 
        """ Sets the label for the given widget in wicd.glade. """
1515
 
        self.wTree.get_widget(glade_str).set_label(label)
 
313
        if not self.pref:
 
314
            self.pref = PreferencesDialog(self, self.wTree)
 
315
        else:
 
316
            self.pref.load_preferences_diag()
 
317
        if self.pref.run() == 1:
 
318
            self.pref.save_results()
 
319
        self.pref.hide()
1516
320
 
1517
321
    def connect_hidden(self, widget):
1518
322
        """ Prompts the user for a hidden network, then scans for it. """
1519
323
        dialog = gtk.Dialog(title=language['hidden_network'],
1520
324
                            flags=gtk.DIALOG_MODAL,
1521
 
                            buttons=(gtk.STOCK_ADD, 1, gtk.STOCK_CANCEL, 2))
 
325
                            buttons=(gtk.STOCK_CONNECT, 1, gtk.STOCK_CANCEL, 2))
1522
326
        dialog.set_has_separator(False)
1523
327
        lbl = gtk.Label(language['hidden_network_essid'])
1524
328
        textbox = gtk.Entry()
1550
354
        if not self.is_visible:
1551
355
            return True
1552
356
        try:
1553
 
            self.wTree.get_widget("progressbar").pulse()
 
357
            gobject.idle_add(self.wTree.get_widget("progressbar").pulse)
1554
358
        except:
1555
359
            pass
1556
360
        return True
1557
361
 
1558
362
    def update_statusbar(self):
1559
 
        """ Updates the status bar. """
1560
 
        if not self.is_visible:
1561
 
            return True
1562
 
 
1563
 
        wired_connecting = wired.CheckIfWiredConnecting()
1564
 
        wireless_connecting = wireless.CheckIfWirelessConnecting()
1565
 
        self.connecting = wired_connecting or wireless_connecting
1566
 
 
1567
 
        if self.connecting:
1568
 
            if not self.pulse_active:
1569
 
                self.pulse_active = True
1570
 
                gobject.timeout_add(100, self.pulse_progress_bar)
1571
 
                self.network_list.set_sensitive(False)
1572
 
                self.status_area.show_all()
1573
 
            if self.statusID:
1574
 
                self.status_bar.remove(1, self.statusID)
1575
 
            if wireless_connecting:
1576
 
                iwconfig = wireless.GetIwconfig()
1577
 
                self.set_status(wireless.GetCurrentNetwork(iwconfig) + ': ' +
1578
 
                                language[str(wireless.CheckWirelessConnectingMessage())])
1579
 
            if wired_connecting:
1580
 
                self.set_status(language['wired_network'] + ': ' + 
1581
 
                                language[str(wired.CheckWiredConnectingMessage())])
1582
 
            return True
1583
 
        else:
1584
 
            if self.pulse_active:
1585
 
                self.pulse_progress_bar()
1586
 
                self.pulse_active = False
1587
 
                self.network_list.set_sensitive(True)
1588
 
                self.status_area.hide_all()
1589
 
 
1590
 
            if self.statusID:
1591
 
                self.status_bar.remove(1, self.statusID)
1592
 
 
1593
 
            # Determine connection status.
1594
 
            if self.check_for_wired(wired.GetWiredIP()):
1595
 
                return True
1596
 
 
1597
 
            if self.check_for_wireless(wireless.GetIwconfig(),
1598
 
                                       wireless.GetWirelessIP()):
1599
 
                return True
1600
 
            self.set_status(language['not_connected'])
1601
 
            return True
1602
 
 
 
363
        """ Triggers a status update in wicd-monitor. """
 
364
        if not self.is_visible:
 
365
            return True
 
366
        
 
367
        daemon.UpdateState()
 
368
        if self.connecting:
 
369
            # If we're connecting, don't wait for the monitor to send
 
370
            # us a signal, since it won't until the connection is made.
 
371
            self._do_statusbar_update(*daemon.GetConnectionStatus())
 
372
        return True
 
373
    
 
374
    def _do_statusbar_update(self, state, info):
 
375
        if not self.is_visible:
 
376
            return True
 
377
        
 
378
        if state == misc.WIRED:
 
379
            return self.set_wired_state(info)
 
380
        elif state == misc.WIRELESS:
 
381
            return self.set_wireless_state(info)
 
382
        elif state == misc.CONNECTING:
 
383
            return self.set_connecting_state(info)
 
384
        elif state in (misc.SUSPENDED, misc.NOT_CONNECTED):
 
385
            return self.set_not_connected_state(info)
 
386
        return True
 
387
        
 
388
    def set_wired_state(self, info):
 
389
        if self.connecting:
 
390
            # Adjust our state from connecting->connected.
 
391
            self._set_not_connecting_state()
 
392
        self.set_status(language['connected_to_wired'].replace('$A', info[0]))
 
393
        return True
 
394
    
 
395
    def set_wireless_state(self, info):
 
396
        if self.connecting:
 
397
            # Adjust our state from connecting->connected.
 
398
            self._set_not_connecting_state()
 
399
        self.set_status(language['connected_to_wireless'].replace
 
400
                        ('$A', info[1]).replace
 
401
                        ('$B', daemon.FormatSignalForPrinting(info[2])).replace
 
402
                        ('$C', info[0]))
 
403
        return True
 
404
        
 
405
    def set_not_connected_state(self, info):
 
406
        if self.connecting:
 
407
            # Adjust our state from connecting->not-connected.
 
408
            self._set_not_connecting_state()
 
409
        self.set_status(language['not_connected'])
 
410
        return True
 
411
        
 
412
    def _set_not_connecting_state(self):
 
413
        if self.connecting:
 
414
            if self.update_cb:
 
415
                gobject.source_remove(self.update_cb)
 
416
            self.update_cb = misc.timeout_add(2, self.update_statusbar)
 
417
            self.connecting = False
 
418
        if self.pulse_active:
 
419
            self.pulse_active = False
 
420
            gobject.idle_add(self.network_list.set_sensitive, True)
 
421
            gobject.idle_add(self.status_area.hide_all)
 
422
        if self.statusID:
 
423
            gobject.idle_add(self.status_bar.remove, 1, self.statusID)
 
424
    
 
425
    def set_connecting_state(self, info):
 
426
        if not self.connecting:
 
427
            if self.update_cb:
 
428
                gobject.source_remove(self.update_cb)
 
429
            self.update_cb = misc.timeout_add(500, self.update_statusbar, 
 
430
                                              milli=True)
 
431
            self.connecting = True
 
432
        if not self.pulse_active:
 
433
            self.pulse_active = True
 
434
            misc.timeout_add(100, self.pulse_progress_bar, milli=True)
 
435
            gobject.idle_add(self.network_list.set_sensitive, False)
 
436
            gobject.idle_add(self.status_area.show_all)
 
437
        if self.statusID:
 
438
            gobject.idle_add(self.status_bar.remove, 1, self.statusID)
 
439
        if info[0] == "wireless":
 
440
            gobject.idle_add(self.set_status, str(info[1]) + ': ' +
 
441
                   language[str(wireless.CheckWirelessConnectingMessage())])
 
442
        elif info[0] == "wired":
 
443
            gobject.idle_add(self.set_status, language['wired_network'] + ': ' +
 
444
                         language[str(wired.CheckWiredConnectingMessage())])
 
445
        return True
 
446
        
1603
447
    def update_connect_buttons(self, state=None, x=None, force_check=False):
1604
 
        """ Updates the connect/disconnect buttons for each network entry. """
 
448
        """ Updates the connect/disconnect buttons for each network entry.
 
449
 
 
450
        If force_check is given, update the buttons even if the
 
451
        current network state is the same as the previous.
 
452
        
 
453
        """
 
454
        if not DBUS_AVAIL: return
1605
455
        if not state:
1606
456
            state, x = daemon.GetConnectionStatus()
1607
 
 
 
457
        
1608
458
        if self.prev_state != state or force_check:
1609
459
            apbssid = wireless.GetApBssid()
1610
460
            for entry in self.network_list:
1611
461
                if hasattr(entry, "update_connect_button"):
1612
462
                    entry.update_connect_button(state, apbssid)
1613
463
        self.prev_state = state
1614
 
 
1615
 
    def check_for_wired(self, wired_ip):
1616
 
        """ Determine if wired is active, and if yes, set the status. """
1617
 
        if wired_ip and wired.CheckPluggedIn():
1618
 
            self.set_status(language['connected_to_wired'].replace('$A',
1619
 
                                                                   wired_ip))
1620
 
            return True
1621
 
        else:
1622
 
            return False
1623
 
 
1624
 
    def check_for_wireless(self, iwconfig, wireless_ip):
1625
 
        """ Determine if wireless is active, and if yes, set the status. """
1626
 
        if not wireless_ip:
1627
 
            return False
1628
 
 
1629
 
        network = wireless.GetCurrentNetwork(iwconfig)
1630
 
        if not network:
1631
 
            return False
1632
 
 
1633
 
        network = str(network)
1634
 
        if daemon.GetSignalDisplayType() == 0:
1635
 
            strength = wireless.GetCurrentSignalStrength(iwconfig)
1636
 
        else:
1637
 
            strength = wireless.GetCurrentDBMStrength(iwconfig)
1638
 
 
1639
 
        if strength is None:
1640
 
            return False
1641
 
        strength = str(strength)            
1642
 
        ip = str(wireless_ip)
1643
 
        self.set_status(language['connected_to_wireless'].replace
1644
 
                        ('$A', network).replace
1645
 
                        ('$B', daemon.FormatSignalForPrinting(strength)).replace
1646
 
                        ('$C', wireless_ip))
1647
 
        return True
1648
 
 
 
464
    
1649
465
    def set_status(self, msg):
1650
466
        """ Sets the status bar message for the GUI. """
1651
467
        self.statusID = self.status_bar.push(1, msg)
1652
 
 
 
468
        
1653
469
    def dbus_scan_finished(self):
1654
470
        """ Calls for a non-fresh update of the gui window.
1655
 
 
1656
 
        This method is called after the daemon runs an automatic
1657
 
        rescan.
1658
 
 
 
471
        
 
472
        This method is called after a wireless scan is completed.
 
473
        
1659
474
        """
1660
 
        if not self.connecting:
1661
 
            self.refresh_networks(fresh=False)
1662
 
 
 
475
        if not DBUS_AVAIL: return
 
476
        gobject.idle_add(self.refresh_networks, None, False, None)
 
477
            
1663
478
    def dbus_scan_started(self):
 
479
        """ Called when a wireless scan starts. """
 
480
        if not DBUS_AVAIL: return
1664
481
        self.network_list.set_sensitive(False)
 
482
    
 
483
    def refresh_clicked(self, widget=None):
 
484
        """ Kick off an asynchronous wireless scan. """
 
485
        if not DBUS_AVAIL or self.connecting: return
 
486
        self.refreshing = True
 
487
        wireless.Scan(False)
1665
488
 
1666
489
    def refresh_networks(self, widget=None, fresh=True, hidden=None):
1667
490
        """ Refreshes the network list.
1668
 
 
 
491
        
1669
492
        If fresh=True, scans for wireless networks and displays the results.
1670
493
        If a ethernet connection is available, or the user has chosen to,
1671
494
        displays a Wired Network entry as well.
1672
495
        If hidden isn't None, will scan for networks after running
1673
496
        iwconfig <wireless interface> essid <hidden>.
1674
 
 
 
497
        
1675
498
        """
 
499
        if fresh:
 
500
            if hidden:
 
501
                wireless.SetHiddenNetworkESSID(noneToString(hidden))
 
502
            self.refresh_clicked()
 
503
            return
1676
504
        print "refreshing..."
1677
505
        self.network_list.set_sensitive(False)
1678
506
        self.wait_for_events()
1683
511
            z.destroy()
1684
512
            del z
1685
513
 
1686
 
        if wired.CheckPluggedIn() or wired.GetAlwaysShowWiredInterface():
 
514
        if wired.CheckPluggedIn() or daemon.GetAlwaysShowWiredInterface():
1687
515
            printLine = True  # In this case we print a separator.
1688
516
            wirednet = WiredNetworkEntry()
1689
517
            self.network_list.pack_start(wirednet, False, False)
1690
 
            wirednet.connect_button.connect("button-press-event", self.connect,
1691
 
                                            "wired", 0, wirednet)
1692
 
            wirednet.disconnect_button.connect("button-press-event", self.disconnect,
 
518
            wirednet.connect_button.connect("clicked", self.connect,
 
519
                                           "wired", 0, wirednet)
 
520
            wirednet.disconnect_button.connect("clicked", self.disconnect,
1693
521
                                               "wired", 0, wirednet)
1694
 
            wirednet.advanced_button.connect("button-press-event",
 
522
            wirednet.advanced_button.connect("clicked",
1695
523
                                             self.edit_advanced, "wired", 0, 
1696
524
                                             wirednet)
1697
 
        # Scan
1698
 
        if fresh:
1699
 
            # Even if it is None, it can still be passed.
1700
 
            wireless.SetHiddenNetworkESSID(noneToString(hidden))
1701
 
            wireless.Scan()
1702
525
 
1703
526
        num_networks = wireless.GetNumberOfNetworks()
1704
527
        instruct_label = self.wTree.get_widget("label_instructions")
1713
536
                else:
1714
537
                    printLine = True
1715
538
                tempnet = WirelessNetworkEntry(x)
1716
 
                print "=======",wireless.GetWirelessProperty(x, 'essid'),"========"
1717
 
                tempnet.show_all()
1718
539
                self.network_list.pack_start(tempnet, False, False)
1719
 
                tempnet.connect_button.connect("button-press-event",
 
540
                tempnet.connect_button.connect("clicked",
1720
541
                                               self.connect, "wireless", x,
1721
542
                                               tempnet)
1722
 
                tempnet.disconnect_button.connect("button-press-event",
 
543
                tempnet.disconnect_button.connect("clicked",
1723
544
                                                  self.disconnect, "wireless",
1724
545
                                                  x, tempnet)
1725
 
                tempnet.advanced_button.connect("button-press-event",
 
546
                tempnet.advanced_button.connect("clicked",
1726
547
                                                self.edit_advanced, "wireless",
1727
548
                                                x, tempnet)
1728
549
        else:
1735
556
            label.show()
1736
557
        self.update_connect_buttons(force_check=True)
1737
558
        self.network_list.set_sensitive(True)
 
559
        self.refreshing = False
1738
560
 
1739
561
    def save_settings(self, nettype, networkid, networkentry):
1740
562
        """ Verifies and saves the settings for the network entry. """
1741
563
        entry = networkentry.advanced_dialog
1742
 
        entlist = []
1743
 
 
 
564
        opt_entlist = []
 
565
        req_entlist = []
 
566
        
1744
567
        # First make sure all the Addresses entered are valid.
1745
568
        if entry.chkbox_static_ip.get_active():
1746
 
            entlist = [ent for ent in [entry.txt_ip, entry.txt_netmask,
1747
 
                                       entry.txt_gateway]]
1748
 
 
 
569
            req_entlist = [entry.txt_ip, entry.txt_netmask]
 
570
            opt_entlist = [entry.txt_gateway]
 
571
                
1749
572
        if entry.chkbox_static_dns.get_active() and \
1750
573
           not entry.chkbox_global_dns.get_active():
1751
 
            entlist.append(entry.txt_dns_1)
 
574
            req_entlist.append(entry.txt_dns_1)
1752
575
            # Only append additional dns entries if they're entered.
1753
576
            for ent in [entry.txt_dns_2, entry.txt_dns_3]:
1754
577
                if ent.get_text() != "":
1755
 
                    entlist.append(ent)
1756
 
 
1757
 
        for lblent in entlist:
 
578
                    opt_entlist.append(ent)
 
579
        
 
580
        # Required entries.
 
581
        for lblent in req_entlist:
1758
582
            if not misc.IsValidIP(lblent.get_text()):
1759
583
                error(self.window, language['invalid_address'].
1760
 
                      replace('$A', lblent.label.get_label()))
1761
 
                return False
1762
 
 
1763
 
        if entry.chkbox_global_dns.get_active() and \
1764
 
           not daemon.GetUseGlobalDNS():
1765
 
            error(self.window, language['no_global_dns'])
1766
 
            return False
 
584
                                    replace('$A', lblent.label.get_label()))
 
585
                return False
 
586
        
 
587
        # Optional entries, only check for validity if they're entered.
 
588
        for lblent in opt_entlist:
 
589
            if lblent.get_text() and not misc.IsValidIP(lblent.get_text()):
 
590
                error(self.window, language['invalid_address'].
 
591
                                    replace('$A', lblent.label.get_label()))
 
592
                return False
1767
593
 
1768
594
        # Now save the settings.
1769
595
        if nettype == "wireless":
1770
 
            if not self.save_wireless_settings(networkid, entry, networkentry):
 
596
            if not networkentry.save_wireless_settings(networkid):
1771
597
                return False
1772
598
 
1773
599
        elif nettype == "wired":
1774
 
            if not self.save_wired_settings(entry):
 
600
            if not networkentry.save_wired_settings():
1775
601
                return False
1776
 
 
1777
 
        return True
1778
 
 
1779
 
    def save_wired_settings(self, entry):
1780
 
        """ Saved wired network settings. """
1781
 
        if entry.chkbox_static_ip.get_active():
1782
 
            entry.set_net_prop("ip", noneToString(entry.txt_ip.get_text()))
1783
 
            entry.set_net_prop("netmask", noneToString(entry.txt_netmask.get_text()))
1784
 
            entry.set_net_prop("gateway", noneToString(entry.txt_gateway.get_text()))
1785
 
        else:
1786
 
            entry.set_net_prop("ip", '')
1787
 
            entry.set_net_prop("netmask", '')
1788
 
            entry.set_net_prop("gateway", '')
1789
 
 
1790
 
        if entry.chkbox_static_dns.get_active() and \
1791
 
           not entry.chkbox_global_dns.get_active():
1792
 
            entry.set_net_prop('use_static_dns', True)
1793
 
            entry.set_net_prop('use_global_dns', False)
1794
 
            entry.set_net_prop("dns1", noneToString(entry.txt_dns_1.get_text()))
1795
 
            entry.set_net_prop("dns2", noneToString(entry.txt_dns_2.get_text()))
1796
 
            entry.set_net_prop("dns3", noneToString(entry.txt_dns_3.get_text()))
1797
 
        elif entry.chkbox_static_dns.get_active() and \
1798
 
             entry.chkbox_global_dns.get_active():
1799
 
            entry.set_net_prop('use_static_dns', True)
1800
 
            entry.set_net_prop('use_global_dns', True)
1801
 
        else:
1802
 
            entry.set_net_prop('use_static_dns', False)
1803
 
            entry.set_net_prop('use_global_dns', False)
1804
 
            entry.set_net_prop("dns1", '')
1805
 
            entry.set_net_prop("dns2", '')
1806
 
            entry.set_net_prop("dns3", '')
1807
 
        config.SaveWiredNetworkProfile(entry.prof_name)
1808
 
        return True
1809
 
 
1810
 
    def save_wireless_settings(self, networkid, entry, netent):
1811
 
        """ Save wireless network settings. """
1812
 
        # Check encryption info
1813
 
        if entry.chkbox_encryption.get_active():
1814
 
            print "setting encryption info..."
1815
 
            encryption_info = entry.encryption_info
1816
 
            encrypt_methods = misc.LoadEncryptionMethods()
1817
 
            entry.set_net_prop("enctype",
1818
 
                               encrypt_methods[entry.combo_encryption.
1819
 
                                               get_active()][1])
1820
 
            for x in encryption_info:
1821
 
                if encryption_info[x].get_text() == "":
1822
 
                    error(self.window, language['encrypt_info_missing'])
1823
 
                    return False
1824
 
                entry.set_net_prop(x, noneToString(encryption_info[x].
1825
 
                                                   get_text()))
1826
 
        elif not entry.chkbox_encryption.get_active() and \
1827
 
             wireless.GetWirelessProperty(networkid, "encryption"):
1828
 
            error(self.window, language['enable_encryption'])
1829
 
            return False
1830
 
        else:
1831
 
            print 'encryption is ' + str(wireless.GetWirelessProperty(networkid, 
1832
 
                                                                      "encryption"))
1833
 
            print "no encryption specified..."
1834
 
            entry.set_net_prop("enctype", "None")
1835
 
 
1836
 
        entry.set_net_prop("automatic",
1837
 
                           noneToString(netent.chkbox_autoconnect.get_active()))
1838
 
        # Save IP info
1839
 
        if entry.chkbox_static_ip.get_active():
1840
 
            entry.set_net_prop("ip", noneToString(entry.txt_ip.get_text()))
1841
 
            entry.set_net_prop("netmask",
1842
 
                               noneToString(entry.txt_netmask.get_text()))
1843
 
            entry.set_net_prop("gateway",
1844
 
                               noneToString(entry.txt_gateway.get_text()))
1845
 
        else:
1846
 
            # Blank the values
1847
 
            entry.set_net_prop("ip", '')
1848
 
            entry.set_net_prop("netmask", '')
1849
 
            entry.set_net_prop("gateway", '')
1850
 
 
1851
 
        # Save DNS info
1852
 
        if entry.chkbox_static_dns.get_active() and \
1853
 
           not entry.chkbox_global_dns.get_active():
1854
 
            entry.set_net_prop('use_static_dns', True)
1855
 
            entry.set_net_prop('use_global_dns', False)
1856
 
            entry.set_net_prop('dns1', noneToString(entry.txt_dns_1.get_text()))
1857
 
            entry.set_net_prop('dns2', noneToString(entry.txt_dns_2.get_text()))
1858
 
            entry.set_net_prop('dns3', noneToString(entry.txt_dns_3.get_text()))
1859
 
        elif entry.chkbox_static_dns.get_active() and \
1860
 
             entry.chkbox_global_dns.get_active():
1861
 
            entry.set_net_prop('use_static_dns', True)
1862
 
            entry.set_net_prop('use_global_dns', True)
1863
 
        else:
1864
 
            entry.set_net_prop('use_static_dns', False) 
1865
 
            entry.set_net_prop('use_global_dns', False)
1866
 
            entry.set_net_prop('dns1', '')
1867
 
            entry.set_net_prop('dns2', '')
1868
 
            entry.set_net_prop('dns3', '')
1869
 
 
1870
 
        if entry.chkbox_global_settings.get_active():
1871
 
            entry.set_net_prop('use_settings_globally', True)
1872
 
        else:
1873
 
            entry.set_net_prop('use_settings_globally', False)
1874
 
            config.RemoveGlobalEssidEntry(networkid)
1875
 
 
1876
 
        config.SaveWirelessNetworkProfile(networkid)
1877
 
        return True
1878
 
 
1879
 
    def edit_advanced(self, widget, event, ttype, networkid, networkentry):
 
602
            
 
603
        return True
 
604
 
 
605
    def edit_advanced(self, widget, ttype, networkid, networkentry):
1880
606
        """ Display the advanced settings dialog.
1881
 
 
 
607
        
1882
608
        Displays the advanced settings dialog and saves any changes made.
1883
609
        If errors occur in the settings, an error message will be displayed
1884
610
        and the user won't be able to save the changes until the errors
1885
611
        are fixed.
1886
 
 
 
612
        
1887
613
        """
1888
614
        dialog = networkentry.advanced_dialog
1889
615
        dialog.set_values()
1892
618
            if self.run_settings_dialog(dialog, ttype, networkid, networkentry):
1893
619
                break
1894
620
        dialog.hide()
1895
 
 
 
621
        
1896
622
    def run_settings_dialog(self, dialog, nettype, networkid, networkentry):
1897
623
        """ Runs the settings dialog.
1898
 
 
 
624
        
1899
625
        Runs the settings dialog and returns True if settings are saved
1900
626
        successfully, and false otherwise.
1901
 
 
 
627
        
1902
628
        """
1903
629
        result = dialog.run()
1904
630
        if result == gtk.RESPONSE_ACCEPT:
1907
633
            else:
1908
634
                return False
1909
635
        return True
1910
 
 
 
636
    
1911
637
    def check_encryption_valid(self, networkid, entry):
1912
638
        """ Make sure that encryption settings are properly filled in. """
1913
639
        # Make sure no entries are left blank
1914
640
        if entry.chkbox_encryption.get_active():
1915
641
            encryption_info = entry.encryption_info
1916
 
            for x in encryption_info:
1917
 
                if encryption_info[x].get_text() == "":
1918
 
                    error(self.window, language['encrypt_info_missing'])
 
642
            for entry_info in encryption_info.itervalues():
 
643
                if entry_info[0].entry.get_text() == "" and \
 
644
                   entry_info[1] == 'required':
 
645
                    error(self.window, "%s (%s)" % (language['encrypt_info_missing'], 
 
646
                                             entry_info[0].label.get_label())
 
647
                          )
1919
648
                    return False
1920
649
        # Make sure the checkbox is checked when it should be
1921
650
        elif not entry.chkbox_encryption.get_active() and \
1924
653
            return False
1925
654
        return True
1926
655
 
1927
 
    def connect(self, widget, event, nettype, networkid, networkentry):
 
656
    def _wait_for_connect_thread_start(self):
 
657
        self.wTree.get_widget("progressbar").pulse()
 
658
        if not self._connect_thread_started:
 
659
            return True
 
660
        else:
 
661
            misc.timeout_add(2, self.update_statusbar)
 
662
            self.update_statusbar()
 
663
            return False
 
664
        
 
665
    def connect(self, widget, nettype, networkid, networkentry):
1928
666
        """ Initiates the connection process in the daemon. """
1929
 
        cancel_button = self.wTree.get_widget("cancel_button")
1930
 
        cancel_button.set_sensitive(True)
 
667
        def handler(*args):
 
668
            self._connect_thread_started = True
 
669
 
 
670
        def setup_interface_for_connection():
 
671
            cancel_button = self.wTree.get_widget("cancel_button")
 
672
            cancel_button.set_sensitive(True)
 
673
            self.network_list.set_sensitive(False)
 
674
            if self.statusID:
 
675
                gobject.idle_add(self.status_bar.remove, 1, self.statusID)
 
676
            gobject.idle_add(self.set_status, language["disconnecting_active"])
 
677
            gobject.idle_add(self.status_area.show_all)
 
678
            self.wait_for_events()
 
679
            self._connect_thread_started = False
 
680
 
1931
681
        if nettype == "wireless":
1932
682
            if not self.check_encryption_valid(networkid,
1933
683
                                               networkentry.advanced_dialog):
 
684
                self.edit_advanced(None, nettype, networkid, networkentry)
1934
685
                return False
1935
 
            wireless.ConnectWireless(networkid)
 
686
            setup_interface_for_connection()
 
687
            wireless.ConnectWireless(networkid, reply_handler=handler,
 
688
                                     error_handler=handler)
1936
689
        elif nettype == "wired":
1937
 
            wired.ConnectWired()
1938
 
        self.update_statusbar()
1939
 
 
1940
 
    def disconnect(self, widget, event, nettype, networkid, networkentry):
 
690
            setup_interface_for_connection()
 
691
            wired.ConnectWired(reply_handler=handler, error_handler=handler)
 
692
        
 
693
        gobject.source_remove(self.update_cb)
 
694
        misc.timeout_add(100, self._wait_for_connect_thread_start, milli=True)
 
695
        
 
696
    def disconnect(self, widget, nettype, networkid, networkentry):
1941
697
        """ Disconnects from the given network.
1942
 
 
 
698
        
1943
699
        Keyword arguments:
1944
700
        widget -- The disconnect button that was pressed.
1945
701
        event -- unused
1946
702
        nettype -- "wired" or "wireless", depending on the network entry type.
1947
703
        networkid -- unused
1948
704
        networkentry -- The NetworkEntry containing the disconnect button.
1949
 
 
 
705
        
1950
706
        """
 
707
        def handler(*args):
 
708
            gobject.idle_add(self.network_list.set_sensitive, True)
 
709
            
1951
710
        widget.hide()
1952
711
        networkentry.connect_button.show()
 
712
        daemon.SetForcedDisconnect(True)
 
713
        self.network_list.set_sensitive(False)
1953
714
        if nettype == "wired":
1954
 
            wired.DisconnectWired()
 
715
            wired.DisconnectWired(reply_handler=handler, error_handler=handler)
1955
716
        else:
1956
 
            wireless.DisconnectWireless()
1957
 
 
 
717
            wireless.DisconnectWireless(reply_handler=handler, 
 
718
                                        error_handler=handler)
 
719
        
1958
720
    def wait_for_events(self, amt=0):
1959
721
        """ Wait for any pending gtk events to finish before moving on. 
1960
722
 
1961
723
        Keyword arguments:
1962
724
        amt -- a number specifying the number of ms to wait before checking
1963
725
               for pending events.
1964
 
 
 
726
        
1965
727
        """
1966
728
        time.sleep(amt)
1967
729
        while gtk.events_pending():
1976
738
 
1977
739
        """
1978
740
        self.window.hide()
 
741
        gobject.source_remove(self.update_cb)
 
742
        bus.remove_signal_receiver(self._do_statusbar_update, 'StatusChanged',
 
743
                                   'org.wicd.daemon')
1979
744
        [width, height] = self.window.get_size()
1980
 
        config.WriteWindowSize(width, height, "main")
 
745
        try:
 
746
            daemon.WriteWindowSize(width, height, "main")
 
747
            daemon.SetGUIOpen(False)
 
748
        except DBusException:
 
749
            pass
1981
750
 
1982
751
        if self.standalone:
1983
 
            self.window.destroy()
1984
752
            sys.exit(0)
1985
753
 
1986
754
        self.is_visible = False
1987
 
        daemon.SetGUIOpen(False)
1988
 
        self.wait_for_events()
1989
755
        return True
1990
756
 
1991
757
    def show_win(self):
1992
758
        """ Brings the GUI out of the hidden state. 
1993
 
 
 
759
        
1994
760
        Method to show the wicd GUI, alert the daemon that it is open,
1995
761
        and refresh the network list.
1996
 
 
 
762
        
1997
763
        """
1998
764
        self.window.present()
1999
765
        self.wait_for_events()
2000
766
        self.is_visible = True
2001
767
        daemon.SetGUIOpen(True)
2002
768
        self.wait_for_events(0.1)
2003
 
        gobject.idle_add(self.refresh_networks)
 
769
        gobject.idle_add(self.refresh_clicked)
 
770
        self._do_statusbar_update(*daemon.GetConnectionStatus())
 
771
        bus.add_signal_receiver(self._do_statusbar_update, 'StatusChanged',
 
772
                                'org.wicd.daemon')
 
773
        self.update_cb = misc.timeout_add(2, self.update_statusbar)
2004
774
 
2005
 
setup_dbus()
2006
775
 
2007
776
if __name__ == '__main__':
 
777
    setup_dbus()
2008
778
    app = appGui(standalone=True)
2009
 
    bus.add_signal_receiver(app.dbus_scan_finished, 'SendEndScanSignal',
2010
 
                            'org.wicd.daemon')
2011
 
    bus.add_signal_receiver(app.dbus_scan_started, 'SendStartScanSignal',
2012
 
                            'org.wicd.daemon')
2013
 
    bus.add_signal_receiver(app.update_connect_buttons, 'StatusChanged',
2014
 
                            'org.wicd.daemon')
2015
 
    gtk.main()
 
779
    mainloop = gobject.MainLoop()
 
780
    mainloop.run()