# # Copyright (C) 2007 Adam Blackburn # Copyright (C) 2007 Dan O'Reilly # # This program is free software; you can redistribute it and/or modify # it under the terms of the GNU General Public License Version 2 as # published by the Free Software Foundation. # # This program is distributed in the hope that it will be useful, # but WITHOUT ANY WARRANTY; without even the implied warranty of # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the # GNU General Public License for more details. # # You should have received a copy of the GNU General Public License # along with this program. If not, see . # import gtk import os import misc import wpath import dbusmanager from misc import noneToString, stringToNone, noneToBlankString, to_bool from guiutil import error, SmallLabel, LabelEntry, GreyLabel, LeftAlignedLabel, string_input from translations import language # These get set when a NetworkEntry is instantiated. daemon = None wired = None wireless = None def setup_dbus(): global daemon, wireless, wired daemon = dbusmanager.get_interface('daemon') wireless = dbusmanager.get_interface('wireless') wired = dbusmanager.get_interface('wired') class AdvancedSettingsDialog(gtk.Dialog): def __init__(self): """ Build the base advanced settings dialog. This class isn't used by itself, instead it is used as a parent for the WiredSettingsDialog and WirelessSettingsDialog. """ gtk.Dialog.__init__(self, title=language['properties'], flags=gtk.DIALOG_MODAL, buttons=(gtk.STOCK_CANCEL, gtk.RESPONSE_REJECT, gtk.STOCK_OK, gtk.RESPONSE_ACCEPT)) # Set up the Advanced Settings Dialog. self.txt_ip = LabelEntry(language['ip']) self.txt_ip.entry.connect('focus-out-event', self.set_defaults) self.txt_netmask = LabelEntry(language['netmask']) self.txt_gateway = LabelEntry(language['gateway']) self.txt_search_dom = LabelEntry(language['search_domain']) self.txt_domain = LabelEntry(language['dns_domain']) self.txt_dns_1 = LabelEntry(language['dns'] + ' 1') self.txt_dns_2 = LabelEntry(language['dns'] + ' 2') self.txt_dns_3 = LabelEntry(language['dns'] + ' 3') self.chkbox_static_ip = gtk.CheckButton(language['use_static_ip']) self.chkbox_static_dns = gtk.CheckButton(language['use_static_dns']) self.chkbox_global_dns = gtk.CheckButton(language['use_global_dns']) self.hbox_dns = gtk.HBox(False, 0) self.hbox_dns.pack_start(self.chkbox_static_dns) self.hbox_dns.pack_start(self.chkbox_global_dns) # Set up the script settings button self.script_button = gtk.Button() script_image = gtk.Image() script_image.set_from_stock(gtk.STOCK_EXECUTE, 4) script_image.set_padding(4, 0) #self.script_button.set_alignment(.5, .5) self.script_button.set_image(script_image) self.script_button.set_label(language['scripts']) self.button_hbox = gtk.HBox(False, 2) self.button_hbox.pack_start(self.script_button, fill=False, expand=False) self.button_hbox.show() assert(isinstance(self.vbox, gtk.VBox)) self.vbox.pack_start(self.chkbox_static_ip, fill=False, expand=False) self.vbox.pack_start(self.txt_ip, fill=False, expand=False) self.vbox.pack_start(self.txt_netmask, fill=False, expand=False) self.vbox.pack_start(self.txt_gateway, fill=False, expand=False) self.vbox.pack_start(self.hbox_dns, fill=False, expand=False) self.vbox.pack_start(self.txt_domain, fill=False, expand=False) self.vbox.pack_start(self.txt_search_dom, fill=False, expand=False) self.vbox.pack_start(self.txt_dns_1, fill=False, expand=False) self.vbox.pack_start(self.txt_dns_2, fill=False, expand=False) self.vbox.pack_start(self.txt_dns_3, fill=False, expand=False) self.vbox.pack_end(self.button_hbox, fill=False, expand=False, padding=5) # Connect the events to the actions self.chkbox_static_ip.connect("toggled", self.toggle_ip_checkbox) self.chkbox_static_dns.connect("toggled", self.toggle_dns_checkbox) self.chkbox_global_dns.connect("toggled", self.toggle_global_dns_checkbox) # Start with all disabled, then they will be enabled later. self.chkbox_static_ip.set_active(False) self.chkbox_static_dns.set_active(False) def set_defaults(self, widget=None, event=None): """ Put some default values into entries to help the user out. """ ipAddress = self.txt_ip.get_text() # For easy typing :) netmask = self.txt_netmask gateway = self.txt_gateway ip_parts = misc.IsValidIP(ipAddress) if ip_parts: if stringToNone(gateway.get_text()) is None: # Make sure the gateway box is blank # Fill it in with a .1 at the end gateway.set_text('.'.join(ip_parts[0:3]) + '.1') if stringToNone(netmask.get_text()) is None: # Make sure the netmask is blank netmask.set_text('255.255.255.0') # Fill in the most common one elif ipAddress != "": error(None, "Invalid IP Address Entered.") def reset_static_checkboxes(self): # Enable the right stuff if stringToNone(self.txt_ip.get_text()): self.chkbox_static_ip.set_active(True) self.chkbox_static_dns.set_active(True) self.chkbox_static_dns.set_sensitive(False) else: self.chkbox_static_ip.set_active(False) self.chkbox_static_dns.set_sensitive(True) if stringToNone(self.txt_dns_1.get_text()) or \ self.chkbox_global_dns.get_active(): self.chkbox_static_dns.set_active(True) else: self.chkbox_static_dns.set_active(False) # This will properly disable unused boxes. self.toggle_ip_checkbox() self.toggle_dns_checkbox() self.toggle_global_dns_checkbox() def toggle_ip_checkbox(self, widget=None): """Toggle entries/checkboxes based on the static IP checkbox. """ # Should disable the static IP text boxes, and also enable the DNS # checkbox when disabled and disable when enabled. if self.chkbox_static_ip.get_active(): self.chkbox_static_dns.set_active(True) self.chkbox_static_dns.set_sensitive(False) else: self.chkbox_static_dns.set_sensitive(True) self.txt_ip.set_sensitive(self.chkbox_static_ip.get_active()) self.txt_netmask.set_sensitive(self.chkbox_static_ip.get_active()) self.txt_gateway.set_sensitive(self.chkbox_static_ip.get_active()) def toggle_dns_checkbox(self, widget=None): """ Toggle entries and checkboxes based on the static dns checkbox. """ # Should disable the static DNS boxes if self.chkbox_static_ip.get_active(): self.chkbox_static_dns.set_active(True) self.chkbox_static_dns.set_sensitive(False) self.chkbox_global_dns.set_sensitive(self.chkbox_static_dns. get_active()) l = [self.txt_dns_1, self.txt_dns_2, self.txt_dns_3, self.txt_domain, self.txt_search_dom] if self.chkbox_static_dns.get_active(): # If global dns is on, don't use local dns for w in l: w.set_sensitive(not self.chkbox_global_dns.get_active()) else: for w in l: w.set_sensitive(False) self.chkbox_global_dns.set_active(False) def toggle_global_dns_checkbox(self, widget=None): """ Set the DNS entries' sensitivity based on the Global checkbox. """ global_dns_active = daemon.GetUseGlobalDNS() if not global_dns_active and self.chkbox_global_dns.get_active(): error(None, language['global_dns_not_enabled']) self.chkbox_global_dns.set_active(False) if daemon.GetUseGlobalDNS() and self.chkbox_static_dns.get_active(): for w in [self.txt_dns_1, self.txt_dns_2, self.txt_dns_3, self.txt_domain, self.txt_search_dom]: w.set_sensitive(not self.chkbox_global_dns.get_active()) def destroy_called(self, *args): """ Clean up everything. """ super(AdvancedSettingsDialog, self).destroy() self.destroy() del self def save_settings(self): """ Save settings common to wired and wireless settings dialogs. """ if self.chkbox_static_ip.get_active(): self.set_net_prop("ip", noneToString(self.txt_ip.get_text())) self.set_net_prop("netmask", noneToString(self.txt_netmask.get_text())) self.set_net_prop("gateway", noneToString(self.txt_gateway.get_text())) else: self.set_net_prop("ip", '') self.set_net_prop("netmask", '') self.set_net_prop("gateway", '') if self.chkbox_static_dns.get_active() and \ not self.chkbox_global_dns.get_active(): self.set_net_prop('use_static_dns', True) self.set_net_prop('use_global_dns', False) self.set_net_prop('dns_domain', noneToString(self.txt_domain.get_text())) self.set_net_prop("search_domain", noneToString(self.txt_search_dom.get_text())) self.set_net_prop("dns1", noneToString(self.txt_dns_1.get_text())) self.set_net_prop("dns2", noneToString(self.txt_dns_2.get_text())) self.set_net_prop("dns3", noneToString(self.txt_dns_3.get_text())) elif self.chkbox_static_dns.get_active() and \ self.chkbox_global_dns.get_active(): self.set_net_prop('use_static_dns', True) self.set_net_prop('use_global_dns', True) else: self.set_net_prop('use_static_dns', False) self.set_net_prop('use_global_dns', False) self.set_net_prop('dns_domain', '') self.set_net_prop("search_domain", '') self.set_net_prop("dns1", '') self.set_net_prop("dns2", '') self.set_net_prop("dns3", '') class WiredSettingsDialog(AdvancedSettingsDialog): def __init__(self, name): """ Build the wired settings dialog. """ AdvancedSettingsDialog.__init__(self) self.des = self.connect("destroy", self.destroy_called) self.script_button.connect("button-press-event", self.edit_scripts) self.prof_name = name def set_net_prop(self, option, value): """ Sets the given option to the given value for this network. """ wired.SetWiredProperty(option, value) def edit_scripts(self, widget=None, event=None): """ Launch the script editting dialog. """ profile = self.prof_name cmdend = [os.path.join(wpath.lib, "configscript.py"), profile, "wired"] if os.getuid() != 0: cmdbase = misc.get_sudo_cmd(language['scripts_need_pass'], prog_num=daemon.GetSudoApp()) if not cmdbase: error(None, language["no_sudo_prog"]) return cmdbase.extend(cmdend) misc.LaunchAndWait(cmdbase) else: misc.LaunchAndWait(cmdend) def set_values(self): """ Fill in the Gtk.Entry objects with the correct values. """ self.txt_ip.set_text(self.format_entry("ip")) self.txt_netmask.set_text(self.format_entry("netmask")) self.txt_gateway.set_text(self.format_entry("gateway")) self.txt_dns_1.set_text(self.format_entry("dns1")) self.txt_dns_2.set_text(self.format_entry("dns2")) self.txt_dns_3.set_text(self.format_entry("dns3")) self.txt_domain.set_text(self.format_entry("dns_domain")) self.txt_search_dom.set_text(self.format_entry("search_domain")) self.chkbox_global_dns.set_active(bool(wired.GetWiredProperty("use_global_dns"))) self.reset_static_checkboxes() def save_settings(self): AdvancedSettingsDialog.save_settings(self) wired.SaveWiredNetworkProfile(self.prof_name) return True def format_entry(self, label): """ Helper method to fetch and format wired properties. """ return noneToBlankString(wired.GetWiredProperty(label)) def destroy_called(self, *args): """ Clean up everything. """ self.disconnect(self.des) super(WiredSettingsDialog, self).destroy_called() self.destroy() del self class WirelessSettingsDialog(AdvancedSettingsDialog): def __init__(self, networkID): """ Build the wireless settings dialog. """ AdvancedSettingsDialog.__init__(self) # Set up encryption stuff self.networkID = networkID self.combo_encryption = gtk.combo_box_new_text() self.chkbox_encryption = gtk.CheckButton(language['use_encryption']) self.chkbox_global_settings = gtk.CheckButton(language['global_settings']) # Make the vbox to hold the encryption stuff. self.vbox_encrypt_info = gtk.VBox(False, 0) self.toggle_encryption() self.chkbox_encryption.set_active(False) self.combo_encryption.set_sensitive(False) self.encrypt_types = misc.LoadEncryptionMethods() information_button = gtk.Button(stock=gtk.STOCK_INFO) self.button_hbox.pack_start(information_button, False, False) information_button.connect('clicked', lambda *a, **k: WirelessInformationDialog(networkID)) information_button.show() # Build the encryption menu activeID = -1 # Set the menu to this item when we are done for x, enc_type in enumerate(self.encrypt_types): self.combo_encryption.append_text(enc_type['name']) if enc_type['type'] == wireless.GetWirelessProperty(networkID, "enctype"): activeID = x self.combo_encryption.set_active(activeID) if activeID != -1: self.chkbox_encryption.set_active(True) self.combo_encryption.set_sensitive(True) self.vbox_encrypt_info.set_sensitive(True) else: self.combo_encryption.set_active(0) self.change_encrypt_method() self.vbox.pack_start(self.chkbox_global_settings, False, False) self.vbox.pack_start(self.chkbox_encryption, False, False) self.vbox.pack_start(self.combo_encryption, False, False) self.vbox.pack_start(self.vbox_encrypt_info, False, False) # Connect signals. self.chkbox_encryption.connect("toggled", self.toggle_encryption) self.combo_encryption.connect("changed", self.change_encrypt_method) self.script_button.connect("button-press-event", self.edit_scripts) self.des = self.connect("destroy", self.destroy_called) def destroy_called(self, *args): """ Clean up everything. """ self.disconnect(self.des) super(WirelessSettingsDialog, self).destroy_called() self.destroy() del self def edit_scripts(self, widget=None, event=None): """ Launch the script editting dialog. """ cmdend = [os.path.join(wpath.lib, "configscript.py"), str(self.networkID), "wireless"] if os.getuid() != 0: cmdbase = misc.get_sudo_cmd(language['scripts_need_pass'], prog_num=daemon.GetSudoApp()) if not cmdbase: error(None, language["no_sudo_prog"]) return cmdbase.extend(cmdend) misc.LaunchAndWait(cmdbase) else: misc.LaunchAndWait(cmdend) def set_net_prop(self, option, value): """ Sets the given option to the given value for this network. """ wireless.SetWirelessProperty(self.networkID, option, value) def set_values(self): """ Set the various network settings to the right values. """ networkID = self.networkID self.txt_ip.set_text(self.format_entry(networkID,"ip")) self.txt_netmask.set_text(self.format_entry(networkID,"netmask")) self.txt_gateway.set_text(self.format_entry(networkID,"gateway")) self.chkbox_global_dns.set_active(bool(wireless.GetWirelessProperty(networkID, 'use_global_dns'))) self.chkbox_static_dns.set_active(bool(wireless.GetWirelessProperty(networkID, 'use_static_dns'))) self.txt_dns_1.set_text(self.format_entry(networkID, "dns1")) self.txt_dns_2.set_text(self.format_entry(networkID, "dns2")) self.txt_dns_3.set_text(self.format_entry(networkID, "dns3")) self.txt_domain.set_text(self.format_entry(networkID, "dns_domain")) self.txt_search_dom.set_text(self.format_entry(networkID, "search_domain")) self.reset_static_checkboxes() self.chkbox_encryption.set_active(bool(wireless.GetWirelessProperty(networkID, 'encryption'))) self.chkbox_global_settings.set_active(bool(wireless.GetWirelessProperty(networkID, 'use_settings_globally'))) activeID = -1 # Set the menu to this item when we are done user_enctype = wireless.GetWirelessProperty(networkID, "enctype") for x, enc_type in enumerate(self.encrypt_types): if enc_type['type'] == user_enctype: activeID = x self.combo_encryption.set_active(activeID) if activeID != -1: self.chkbox_encryption.set_active(True) self.combo_encryption.set_sensitive(True) self.vbox_encrypt_info.set_sensitive(True) else: self.combo_encryption.set_active(0) self.change_encrypt_method() def save_settings(self, networkid): # Check encryption info if self.chkbox_encryption.get_active(): print "setting encryption info..." encrypt_info = self.encryption_info encrypt_methods = self.encrypt_types self.set_net_prop("enctype", encrypt_methods[self.combo_encryption.get_active()]['type']) # Make sure all required fields are filled in. for entry_info in encrypt_info.itervalues(): if entry_info[0].entry.get_text() == "" and \ entry_info[1] == 'required': error(self, "%s (%s)" % (language['encrypt_info_missing'], entry_info[0].label.get_label()) ) return False # Now save all the entries. for entry_key, entry_info in encrypt_info.iteritems(): self.set_net_prop(entry_key, noneToString(entry_info[0].entry.get_text())) elif not self.chkbox_encryption.get_active() and \ wireless.GetWirelessProperty(networkid, "encryption"): # Encrypt checkbox is off, but the network needs it. error(self, language['enable_encryption']) return False else: print "no encryption specified..." self.set_net_prop("enctype", "None") for entry in encrypt_info.iterkeys(): self.set_net_prop(entry[0].entry, "") AdvancedSettingsDialog.save_settings(self) if self.chkbox_global_settings.get_active(): self.set_net_prop('use_settings_globally', True) else: self.set_net_prop('use_settings_globally', False) wireless.RemoveGlobalEssidEntry(networkid) wireless.SaveWirelessNetworkProfile(networkid) return True def format_entry(self, networkid, label): """ Helper method for fetching/formatting wireless properties. """ return noneToBlankString(wireless.GetWirelessProperty(networkid, label)) def toggle_encryption(self, widget=None): """ Toggle the encryption combobox based on the encryption checkbox. """ active = self.chkbox_encryption.get_active() self.vbox_encrypt_info.set_sensitive(active) self.combo_encryption.set_sensitive(active) def change_encrypt_method(self, widget=None): """ Load all the entries for a given encryption method. """ for z in self.vbox_encrypt_info: z.destroy() # Remove stuff in there already ID = self.combo_encryption.get_active() methods = self.encrypt_types self.encryption_info = {} # If nothing is selected, select the first entry. if ID == -1: self.combo_encryption.set_active(0) ID = 0 for type_ in ['required', 'optional']: fields = methods[ID][type_] for field in fields: if language.has_key(field[1]): box = LabelEntry(language[field[1].lower().replace(' ','_')]) else: box = LabelEntry(field[1].replace('_',' ')) box.set_auto_hidden(True) self.vbox_encrypt_info.pack_start(box) # Add the data to a dict, so that the information # can be easily accessed by giving the name of the wanted # data. self.encryption_info[field[0]] = [box, type_] box.entry.set_text(noneToBlankString( wireless.GetWirelessProperty(self.networkID, field[0]))) self.vbox_encrypt_info.show_all() class NetworkEntry(gtk.HBox): def __init__(self): """ Base network entry class. Provides gtk objects used by both the WiredNetworkEntry and WirelessNetworkEntry classes. """ setup_dbus() gtk.HBox.__init__(self, False, 2) self.image = gtk.Image() self.pack_start(self.image, False, False) # Create an HBox to hold the buttons self.buttons_hbox = gtk.HBox(False, 6) # Set up the Connect button self.connect_button = gtk.Button(stock=gtk.STOCK_CONNECT) self.connect_hbox = gtk.HBox(False, 2) self.connect_hbox.pack_start(self.connect_button, False, False) self.connect_hbox.show() # Set up the Disconnect button self.disconnect_button = gtk.Button(stock=gtk.STOCK_DISCONNECT) self.connect_hbox.pack_start(self.disconnect_button, False, False) # Create a label to hold the name of the entry self.name_label = gtk.Label() self.name_label.set_alignment(0, 0.5) # Set up the VBox that goes in the gtk.Expander self.expander_vbox = gtk.VBox(False, 1) self.expander_vbox.show() self.pack_end(self.expander_vbox) # Set up the advanced settings button self.advanced_button = gtk.Button() self.advanced_image = gtk.Image() self.advanced_image.set_from_stock(gtk.STOCK_EDIT, 4) self.advanced_image.set_padding(4, 0) self.advanced_button.set_alignment(.5, .5) self.advanced_button.set_label(language['properties']) self.advanced_button.set_image(self.advanced_image) self.buttons_hbox.pack_start(self.connect_hbox, False, False) self.buttons_hbox.pack_start(self.advanced_button, False, False) self.vbox_top = gtk.VBox(False, 0) self.expander_vbox.pack_start(self.name_label) self.expander_vbox.pack_start(self.vbox_top) self.expander_vbox.pack_start(self.buttons_hbox) def destroy_called(self, *args): """ Clean up everything. """ super(NetworkEntry, self).destroy() self.destroy() del self class WiredNetworkEntry(NetworkEntry): def __init__(self): """ Load the wired network entry. """ NetworkEntry.__init__(self) # Center the picture and pad it a bit self.image.set_padding(0, 0) self.image.set_alignment(.5, .5) self.image.set_size_request(60, -1) self.image.set_from_file(wpath.images + "wired-gui.svg") self.image.show() self.connect_button.show() self.name_label.set_label(language['wired_network']) self.is_full_gui = True self.button_add = gtk.Button(stock=gtk.STOCK_ADD) self.button_delete = gtk.Button(stock=gtk.STOCK_DELETE) self.profile_help = gtk.Label(language['wired_network_instructions']) self.chkbox_default_profile = gtk.CheckButton(language['default_wired']) self.combo_profile_names = gtk.combo_box_new_text() # Format the profile help label. self.profile_help.set_justify(gtk.JUSTIFY_LEFT) self.profile_help.set_line_wrap(True) # Pack the various VBox objects. self.hbox_temp = gtk.HBox(False, 0) self.hbox_def = gtk.HBox(False, 0) self.vbox_top.pack_start(self.profile_help, True, True) self.vbox_top.pack_start(self.hbox_def) self.vbox_top.pack_start(self.hbox_temp) self.hbox_temp.pack_start(self.combo_profile_names, True, True) self.hbox_temp.pack_start(self.button_add, False, False) self.hbox_temp.pack_start(self.button_delete, False, False) self.hbox_def.pack_start(self.chkbox_default_profile, False, False) # Connect events self.button_add.connect("clicked", self.add_profile) self.button_delete.connect("clicked", self.remove_profile) self.chkbox_default_profile.connect("toggled", self.toggle_default_profile) self.combo_profile_names.connect("changed", self.change_profile) # Build profile list. self.profile_list = wired.GetWiredProfileList() default_prof = wired.GetDefaultWiredNetwork() if self.profile_list: starting_index = 0 for x, prof in enumerate(self.profile_list): self.combo_profile_names.append_text(prof) if default_prof == prof: starting_index = x self.combo_profile_names.set_active(starting_index) else: print "no wired profiles found" self.profile_help.show() self.advanced_dialog = WiredSettingsDialog(self.combo_profile_names.get_active_text()) # Show everything, but hide the profile help label. self.show_all() self.profile_help.hide() # Toggle the default profile checkbox to the correct state. if to_bool(wired.GetWiredProperty("default")): self.chkbox_default_profile.set_active(True) else: self.chkbox_default_profile.set_active(False) self.check_enable() self.wireddis = self.connect("destroy", self.destroy_called) def destroy_called(self, *args): """ Clean up everything. """ self.disconnect(self.wireddis) self.advanced_dialog.destroy_called() del self.advanced_dialog super(WiredNetworkEntry, self).destroy_called() self.destroy() del self def save_wired_settings(self): """ Save wired network settings. """ return self.advanced_dialog.save_settings() def check_enable(self): """ Disable objects if the profile list is empty. """ profile_list = wired.GetWiredProfileList() if not profile_list: self.button_delete.set_sensitive(False) self.connect_button.set_sensitive(False) self.advanced_button.set_sensitive(False) def update_connect_button(self, state, apbssid=None): """ Update the connection/disconnect button for this entry. """ if state == misc.WIRED: self.disconnect_button.show() self.connect_button.hide() else: self.disconnect_button.hide() self.connect_button.show() def add_profile(self, widget): """ Add a profile to the profile list. """ print "adding profile" response = string_input("Enter a profile name", "The profile name " + "will not be used by the computer. It " + "allows you to " + "easily distinguish between different network " + "profiles.", "Profile name:") # if response is "" or None if not response: return profile_name = response profile_list = wired.GetWiredProfileList() if profile_list: if profile_name in profile_list: return False self.profile_help.hide() wired.CreateWiredNetworkProfile(profile_name, False) self.combo_profile_names.prepend_text(profile_name) self.combo_profile_names.set_active(0) self.advanced_dialog.prof_name = profile_name if self.is_full_gui: self.button_delete.set_sensitive(True) self.connect_button.set_sensitive(True) self.advanced_button.set_sensitive(True) def remove_profile(self, widget): """ Remove a profile from the profile list. """ print "removing profile" profile_name = self.combo_profile_names.get_active_text() wired.DeleteWiredNetworkProfile(profile_name) self.combo_profile_names.remove_text(self.combo_profile_names. get_active()) self.combo_profile_names.set_active(0) self.advanced_dialog.prof_name = self.combo_profile_names.get_active_text() if not wired.GetWiredProfileList(): self.profile_help.show() entry = self.combo_profile_names.child entry.set_text("") if self.is_full_gui: self.button_delete.set_sensitive(False) self.advanced_button.set_sensitive(False) self.connect_button.set_sensitive(False) else: self.profile_help.hide() def toggle_default_profile(self, widget): """ Change the default profile. """ if self.chkbox_default_profile.get_active(): # Make sure there is only one default profile at a time wired.UnsetWiredDefault() wired.SetWiredProperty("default", self.chkbox_default_profile.get_active()) wired.SaveWiredNetworkProfile(self.combo_profile_names.get_active_text()) def change_profile(self, widget): """ Called when a new profile is chosen from the list. """ # Make sure the name doesn't change everytime someone types something if self.combo_profile_names.get_active() > -1: if not self.is_full_gui: return profile_name = self.combo_profile_names.get_active_text() wired.ReadWiredNetworkProfile(profile_name) if hasattr(self, 'advanced_dialog'): self.advanced_dialog.prof_name = profile_name self.advanced_dialog.set_values() is_default = wired.GetWiredProperty("default") self.chkbox_default_profile.set_active(to_bool(is_default)) def format_entry(self, label): """ Help method for fetching/formatting wired properties. """ return noneToBlankString(wired.GetWiredProperty(label)) class WirelessNetworkEntry(NetworkEntry): def __init__(self, networkID): """ Build the wireless network entry. """ NetworkEntry.__init__(self) self.networkID = networkID self.image.set_padding(0, 0) self.image.set_alignment(.5, .5) self.image.set_size_request(60, -1) self.image.show() self.essid = noneToBlankString(wireless.GetWirelessProperty(networkID, "essid")) self.lbl_strength = GreyLabel() self.lbl_encryption = GreyLabel() self.lbl_channel = GreyLabel() print "ESSID : " + self.essid self.chkbox_autoconnect = gtk.CheckButton(language['automatic_connect']) self.set_signal_strength(wireless.GetWirelessProperty(networkID, 'quality'), wireless.GetWirelessProperty(networkID, 'strength')) self.set_encryption(wireless.GetWirelessProperty(networkID, 'encryption'), wireless.GetWirelessProperty(networkID, 'encryption_method')) self.set_channel(wireless.GetWirelessProperty(networkID, 'channel')) self.name_label.set_use_markup(True) self.name_label.set_label("%s %s %s %s" % (self._escape(self.essid), self.lbl_strength.get_label(), self.lbl_encryption.get_label(), self.lbl_channel.get_label(), ) ) # Add the wireless network specific parts to the NetworkEntry # VBox objects. self.vbox_top.pack_start(self.chkbox_autoconnect, False, False) if to_bool(self.format_entry(networkID, "automatic")): self.chkbox_autoconnect.set_active(True) else: self.chkbox_autoconnect.set_active(False) # Connect signals. self.chkbox_autoconnect.connect("toggled", self.update_autoconnect) # Show everything self.show_all() self.advanced_dialog = WirelessSettingsDialog(networkID) self.wifides = self.connect("destroy", self.destroy_called) def _escape(self, val): """ Escapes special characters so they're displayed correctly. """ return val.replace("&", "&").replace("<", "<").\ replace(">",">").replace("'", "'").replace('"', """) def save_wireless_settings(self, networkid): """ Save wireless network settings. """ return self.advanced_dialog.save_settings(networkid) def update_autoconnect(self, widget=None): """ Called when the autoconnect checkbox is toggled. """ wireless.SetWirelessProperty(self.networkID, "automatic", noneToString(self.chkbox_autoconnect. get_active())) wireless.SaveWirelessNetworkProperty(self.networkID, "automatic") def destroy_called(self, *args): """ Clean up everything. """ self.disconnect(self.wifides) self.advanced_dialog.destroy_called() del self.advanced_dialog super(WirelessNetworkEntry, self).destroy_called() self.destroy() del self def update_connect_button(self, state, apbssid): """ Update the connection/disconnect button for this entry. """ if not apbssid: apbssid = wireless.GetApBssid() if state == misc.WIRELESS and \ apbssid == wireless.GetWirelessProperty(self.networkID, "bssid"): self.disconnect_button.show() self.connect_button.hide() else: self.disconnect_button.hide() self.connect_button.show() def set_signal_strength(self, strength, dbm_strength): """ Set the signal strength displayed in the WirelessNetworkEntry. """ if strength: strength = int(strength) else: strength = -1 if dbm_strength: dbm_strength = int(dbm_strength) else: dbm_strength = -100 display_type = daemon.GetSignalDisplayType() if daemon.GetWPADriver() == 'ralink legacy' or display_type == 1: # Use the -xx dBm signal strength to display a signal icon # I'm not sure how accurately the dBm strength is being # "converted" to strength bars, so suggestions from people # for a better way would be welcome. if dbm_strength >= -60: signal_img = 'signal-100.png' elif dbm_strength >= -70: signal_img = 'signal-75.png' elif dbm_strength >= -80: signal_img = 'signal-50.png' else: signal_img = 'signal-25.png' ending = "dBm" disp_strength = str(dbm_strength) else: # Uses normal link quality, should be fine in most cases if strength > 75: signal_img = 'signal-100.png' elif strength > 50: signal_img = 'signal-75.png' elif strength > 25: signal_img = 'signal-50.png' else: signal_img = 'signal-25.png' ending = "%" disp_strength = str(strength) self.image.set_from_file(wpath.images + signal_img) self.lbl_strength.set_label(disp_strength + ending) self.image.show() def set_encryption(self, on, ttype): """ Set the encryption value for the WirelessNetworkEntry. """ if on and ttype: self.lbl_encryption.set_label(str(ttype)) if on and not ttype: self.lbl_encryption.set_label(language['secured']) if not on: self.lbl_encryption.set_label(language['unsecured']) def set_channel(self, channel): """ Set the channel value for the WirelessNetworkEntry. """ self.lbl_channel.set_label(language['channel'] + ' ' + str(channel)) def format_entry(self, networkid, label): """ Helper method for fetching/formatting wireless properties. """ return noneToBlankString(wireless.GetWirelessProperty(networkid, label)) class WirelessInformationDialog(gtk.Dialog): def __init__(self, networkID): gtk.Dialog.__init__(self) # Make the combo box. self.lbl_strength = gtk.Label() self.lbl_strength.set_alignment(0, 0.5) self.lbl_encryption = gtk.Label() self.lbl_encryption.set_alignment(0, 0.5) self.lbl_mac = gtk.Label() self.lbl_mac.set_alignment(0, 0.5) self.lbl_channel = gtk.Label() self.lbl_channel.set_alignment(0, 0.5) self.lbl_mode = gtk.Label() self.lbl_mode.set_alignment(0, 0.5) self.hbox_status = gtk.HBox(False, 5) # Set the values of the network info labels. self.set_signal_strength(wireless.GetWirelessProperty(networkID, 'quality'), wireless.GetWirelessProperty(networkID, 'strength')) self.set_mac_address(wireless.GetWirelessProperty(networkID, 'bssid')) self.set_mode(wireless.GetWirelessProperty(networkID, 'mode')) self.set_channel(wireless.GetWirelessProperty(networkID, 'channel')) self.set_encryption(wireless.GetWirelessProperty(networkID, 'encryption'), wireless.GetWirelessProperty(networkID, 'encryption_method')) self.set_title('Network Information') vbox = self.vbox self.set_has_separator(False) table = gtk.Table(5, 2) table.set_col_spacings(12) vbox.pack_start(table) # Pack the network status HBox. table.attach(LeftAlignedLabel('Signal strength:'), 0, 1, 0, 1) table.attach(self.lbl_strength, 1, 2, 0, 1) table.attach(LeftAlignedLabel('Encryption type:'), 0, 1, 1, 2) table.attach(self.lbl_encryption, 1, 2, 1, 2) table.attach(LeftAlignedLabel('Access point address:'), 0, 1, 2, 3) table.attach(self.lbl_mac, 1, 2, 2, 3) table.attach(LeftAlignedLabel('Mode:'), 0, 1, 3, 4) table.attach(self.lbl_mode, 1, 2, 3, 4) table.attach(LeftAlignedLabel('Channel:'), 0, 1, 4, 5) table.attach(self.lbl_channel, 1, 2, 4, 5) vbox.show_all() self.add_button(gtk.STOCK_CLOSE, gtk.RESPONSE_CLOSE) self.show() self.run() self.destroy() def set_signal_strength(self, strength, dbm_strength): """ Set the signal strength displayed in the WirelessNetworkEntry. """ if strength is not None: strength = int(strength) else: strength = -1 if dbm_strength is not None: dbm_strength = int(dbm_strength) else: dbm_strength = -100 display_type = daemon.GetSignalDisplayType() if daemon.GetWPADriver() == 'ralink legacy' or display_type == 1: # Use the -xx dBm signal strength to display a signal icon # I'm not sure how accurately the dBm strength is being # "converted" to strength bars, so suggestions from people # for a better way would be welcome. if dbm_strength >= -60: signal_img = 'signal-100.png' elif dbm_strength >= -70: signal_img = 'signal-75.png' elif dbm_strength >= -80: signal_img = 'signal-50.png' else: signal_img = 'signal-25.png' ending = "dBm" disp_strength = str(dbm_strength) else: # Uses normal link quality, should be fine in most cases if strength > 75: signal_img = 'signal-100.png' elif strength > 50: signal_img = 'signal-75.png' elif strength > 25: signal_img = 'signal-50.png' else: signal_img = 'signal-25.png' ending = "%" disp_strength = str(strength) self.lbl_strength.set_label(disp_strength + ending) def set_mac_address(self, address): """ Set the MAC address for the WirelessNetworkEntry. """ self.lbl_mac.set_label(str(address)) def set_encryption(self, on, ttype): """ Set the encryption value for the WirelessNetworkEntry. """ if on and ttype: self.lbl_encryption.set_label(str(ttype)) if on and not ttype: self.lbl_encryption.set_label(language['secured']) if not on: self.lbl_encryption.set_label(language['unsecured']) def set_channel(self, channel): """ Set the channel value for the WirelessNetworkEntry. """ self.lbl_channel.set_label(language['channel'] + ' ' + str(channel)) def set_mode(self, mode): """ Set the mode value for the WirelessNetworkEntry. """ self.lbl_mode.set_label(str(mode)) def format_entry(self, networkid, label): """ Helper method for fetching/formatting wireless properties. """ return noneToBlankString(wireless.GetWirelessProperty(networkid, label))