#!/usr/bin/python """ prefs -- Wicd Preferences Dialog. Displays the main settings dialog window for wicd and handles recieving/sendings the settings from/to the daemon. """ # # Copyright (C) 2008-2009 Adam Blackburn # Copyright (C) 2008-2009 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 gobject #import pango import os import gtk.glade from wicd import misc from wicd import wpath from wicd import dbusmanager from wicd.misc import checkboxTextboxToggle, noneToBlankString daemon = None wireless = None wired = None from wicd.translations import language USER_SETTINGS_DIR = os.path.expanduser('~/.wicd/') def setup_dbus(): global daemon, wireless, wired daemon = dbusmanager.get_interface('daemon') wireless = dbusmanager.get_interface('wireless') wired = dbusmanager.get_interface('wired') class PreferencesDialog(object): """ Class for handling the wicd preferences dialog window. """ def __init__(self, parent, wTree): setup_dbus() self.parent = parent self.wTree = wTree self.prep_settings_diag() self.load_preferences_diag() def _setup_external_app_radios(self, radio_list, get_method, set_method): """ Generic function for setting up external app radios. """ # Disable radios for apps that aren't installed. for app in radio_list[1:]: app.set_sensitive(daemon.GetAppAvailable(app.get_label())) selected_app = get_method() # Make sure the app we want to select is actually available. if radio_list[selected_app].get_property("sensitive"): radio_list[selected_app].set_active(True) else: # If it isn't, default to Automatic. set_method(misc.AUTO) radio_list[misc.AUTO].set_active(True) def load_preferences_diag(self): """ Loads data into the preferences Dialog. """ self.wiredcheckbox.set_active(daemon.GetAlwaysShowWiredInterface()) self.reconnectcheckbox.set_active(daemon.GetAutoReconnect()) self.debugmodecheckbox.set_active(daemon.GetDebugMode()) self.displaytypecheckbox.set_active(daemon.GetSignalDisplayType()) self.verifyapcheckbox.set_active(daemon.GetShouldVerifyAp()) self.preferwiredcheckbox.set_active(daemon.GetPreferWiredNetwork()) dhcp_list = [self.dhcpautoradio, self.dhclientradio, self.dhcpcdradio, self.pumpradio, self.udhcpcradio] self._setup_external_app_radios(dhcp_list, daemon.GetDHCPClient, daemon.SetDHCPClient) wired_link_list = [self.linkautoradio, self.ethtoolradio, self.miitoolradio] self._setup_external_app_radios(wired_link_list, daemon.GetLinkDetectionTool, daemon.SetLinkDetectionTool) flush_list = [self.flushautoradio, self.ipflushradio, self.routeflushradio] self._setup_external_app_radios(flush_list, daemon.GetFlushTool, daemon.SetFlushTool) sudo_list = [self.sudoautoradio, self.gksudoradio, self.kdesuradio, self.ktsussradio] self._setup_external_app_radios(sudo_list, daemon.GetSudoApp, daemon.SetSudoApp) auto_conn_meth = daemon.GetWiredAutoConnectMethod() if auto_conn_meth == 1: self.usedefaultradiobutton.set_active(True) elif auto_conn_meth == 2: self.showlistradiobutton.set_active(True) elif auto_conn_meth == 3: self.lastusedradiobutton.set_active(True) self.entryWirelessInterface.set_text(daemon.GetWirelessInterface()) self.entryWiredInterface.set_text(daemon.GetWiredInterface()) def_driver = daemon.GetWPADriver() try: self.wpadrivercombo.set_active(self.wpadrivers.index(def_driver)) except ValueError: self.wpadrivercombo.set_active(0) self.useGlobalDNSCheckbox.connect("toggled", checkboxTextboxToggle, (self.dns1Entry, self.dns2Entry, self.dns3Entry, self.dnsDomEntry, self.searchDomEntry)) dns_addresses = daemon.GetGlobalDNSAddresses() self.useGlobalDNSCheckbox.set_active(daemon.GetUseGlobalDNS()) self.dns1Entry.set_text(noneToBlankString(dns_addresses[0])) self.dns2Entry.set_text(noneToBlankString(dns_addresses[1])) self.dns3Entry.set_text(noneToBlankString(dns_addresses[2])) self.dnsDomEntry.set_text(noneToBlankString(dns_addresses[3])) self.searchDomEntry.set_text(noneToBlankString(dns_addresses[4])) if not daemon.GetUseGlobalDNS(): self.searchDomEntry.set_sensitive(False) self.dnsDomEntry.set_sensitive(False) self.dns1Entry.set_sensitive(False) self.dns2Entry.set_sensitive(False) self.dns3Entry.set_sensitive(False) cur_backend = daemon.GetSavedBackend() try: self.backendcombo.set_active(self.backends.index(cur_backend)) except ValueError: self.backendcombo.set_active(0) self.notificationscheckbox.set_active( os.path.exists( os.path.join(USER_SETTINGS_DIR, 'USE_NOTIFICATIONS') )) # if pynotify isn't installed disable the option try: import pynotify except ImportError: self.notificationscheckbox.set_active(False) self.notificationscheckbox.set_sensitive(False) # if notifications were disabled with the configure flag if wpath.no_use_notifications: self.notificationscheckbox.set_active(False) self.notificationscheckbox.hide() self.wTree.get_widget('label2').hide() self.wTree.get_widget("notebook2").set_current_page(0) def run(self): """ Runs the preferences dialog window. """ return self.dialog.run() def hide(self): """ Hides the preferences dialog window. """ self.dialog.hide() def destroy(self): self.dialog.destroy() def show_all(self): """ Shows the preferences dialog window. """ self.dialog.show() def save_results(self): """ Pushes the selected settings to the daemon. """ daemon.SetUseGlobalDNS(self.useGlobalDNSCheckbox.get_active()) # Strip whitespace from DNS entries for i in [self.dns1Entry, self.dns2Entry, self.dns3Entry, self.dnsDomEntry, self.searchDomEntry]: i.set_text(i.get_text().strip()) daemon.SetGlobalDNS(self.dns1Entry.get_text(), self.dns2Entry.get_text(), self.dns3Entry.get_text(), self.dnsDomEntry.get_text(), self.searchDomEntry.get_text()) daemon.SetWirelessInterface(self.entryWirelessInterface.get_text()) daemon.SetWiredInterface(self.entryWiredInterface.get_text()) daemon.SetWPADriver(self.wpadrivers[self.wpadrivercombo.get_active()]) daemon.SetAlwaysShowWiredInterface(self.wiredcheckbox.get_active()) daemon.SetAutoReconnect(self.reconnectcheckbox.get_active()) daemon.SetDebugMode(self.debugmodecheckbox.get_active()) daemon.SetSignalDisplayType(int(self.displaytypecheckbox.get_active())) daemon.SetShouldVerifyAp(bool(self.verifyapcheckbox.get_active())) daemon.SetPreferWiredNetwork(bool(self.preferwiredcheckbox.get_active())) if self.showlistradiobutton.get_active(): daemon.SetWiredAutoConnectMethod(2) elif self.lastusedradiobutton.get_active(): daemon.SetWiredAutoConnectMethod(3) else: daemon.SetWiredAutoConnectMethod(1) daemon.SetBackend(self.backends[self.backendcombo.get_active()]) # External Programs Tab if self.dhcpautoradio.get_active(): dhcp_client = misc.AUTO elif self.dhclientradio.get_active(): dhcp_client = misc.DHCLIENT elif self.dhcpcdradio.get_active(): dhcp_client = misc.DHCPCD elif self.pumpradio.get_active(): dhcp_client = misc.PUMP else: dhcp_client = misc.UDHCPC daemon.SetDHCPClient(dhcp_client) if self.linkautoradio.get_active(): link_tool = misc.AUTO elif self.ethtoolradio.get_active(): link_tool = misc.ETHTOOL else: link_tool = misc.MIITOOL daemon.SetLinkDetectionTool(link_tool) if self.flushautoradio.get_active(): flush_tool = misc.AUTO elif self.ipflushradio.get_active(): flush_tool = misc.IP else: flush_tool = misc.ROUTE daemon.SetFlushTool(flush_tool) if self.sudoautoradio.get_active(): sudo_tool = misc.AUTO elif self.gksudoradio.get_active(): sudo_tool = misc.GKSUDO elif self.kdesuradio.get_active(): sudo_tool = misc.KDESU else: sudo_tool = misc.KTSUSS daemon.SetSudoApp(sudo_tool) [width, height] = self.dialog.get_size() daemon.WriteWindowSize(width, height, "pref") not_path = os.path.join(USER_SETTINGS_DIR, 'USE_NOTIFICATIONS') if self.notificationscheckbox.get_active(): if not os.path.exists(not_path): open(not_path, 'w') else: if os.path.exists(not_path): os.remove(not_path) # if this GUI was started by a tray icon, # instantly change the notifications there if self.parent.tray: self.parent.tray.icon_info.use_notify = \ self.notificationscheckbox.get_active() def set_label(self, glade_str, label): """ Sets the label for the given widget in wicd.glade. """ self.wTree.get_widget(glade_str).set_label(label) def prep_settings_diag(self): """ Set up anything that doesn't have to be persisted later. """ def build_combobox(lbl): """ Sets up a ComboBox using the given widget name. """ liststore = gtk.ListStore(gobject.TYPE_STRING) combobox = self.wTree.get_widget(lbl) combobox.clear() combobox.set_model(liststore) cell = gtk.CellRendererText() combobox.pack_start(cell, True) combobox.add_attribute(cell, 'text', 0) return combobox def setup_label(name, lbl=""): """ Sets up a label for the given widget name. """ widget = self.wTree.get_widget(name) # if lbl: # widget.set_label(language[lbl]) if widget is None: raise ValueError('widget %s does not exist' % name) return widget # External Programs tab # self.wTree.get_widget("gen_settings_label").set_label(language["gen_settings"]) # self.wTree.get_widget("ext_prog_label").set_label(language["ext_programs"]) # self.wTree.get_widget("dhcp_client_label").set_label(language["dhcp_client"]) # self.wTree.get_widget("wired_detect_label").set_label(language["wired_detect"]) # self.wTree.get_widget("route_flush_label").set_label(language["route_flush"]) # self.wTree.get_widget("pref_backend_label").set_label(language["backend"] + ":") # entryWiredAutoMethod = self.wTree.get_widget("pref_wired_auto_label") # entryWiredAutoMethod.set_label('Wired Autoconnect Setting:') # entryWiredAutoMethod.set_alignment(0, 0) # atrlist = pango.AttrList() # atrlist.insert(pango.AttrWeight(pango.WEIGHT_BOLD, 0, 50)) # entryWiredAutoMethod.set_attributes(atrlist) # self.set_label("pref_dns1_label", "%s %s" % (language['dns'], language['1'])) # self.set_label("pref_dns2_label", "%s %s" % (language['dns'], language['2'])) # self.set_label("pref_dns3_label", "%s %s" % (language['dns'], language['3'])) # self.set_label("pref_search_dom_label", "%s:" % language['search_domain']) # self.set_label("pref_wifi_label", "%s:" % language['wireless_interface']) # self.set_label("pref_wired_label", "%s:" % language['wired_interface']) # self.set_label("pref_driver_label", "%s:" % language['wpa_supplicant_driver']) self.dialog = self.wTree.get_widget("pref_dialog") self.dialog.set_title(language['preferences']) if os.path.exists(os.path.join(wpath.images, "wicd.png")): self.dialog.set_icon_from_file(os.path.join(wpath.images, "wicd.png")) size = daemon.ReadWindowSize("pref") width = size[0] height = size[1] if width > -1 and height > -1: self.dialog.resize(int(width), int(height)) else: width = int(gtk.gdk.screen_width() / 2.4) if width > 450: width = 450 self.dialog.resize(width, int(gtk.gdk.screen_height() / 2)) self.wiredcheckbox = setup_label("pref_always_check", 'wired_always_on') self.preferwiredcheckbox = setup_label("pref_prefer_wired_check", "prefer_wired") self.reconnectcheckbox = setup_label("pref_auto_check", 'auto_reconnect') self.debugmodecheckbox = setup_label("pref_debug_check", 'use_debug_mode') self.displaytypecheckbox = setup_label("pref_dbm_check", 'display_type_dialog') self.verifyapcheckbox = setup_label("pref_verify_ap_check", 'verify_ap_dialog') self.usedefaultradiobutton = setup_label("pref_use_def_radio", 'use_default_profile') self.showlistradiobutton = setup_label("pref_prompt_radio", 'show_wired_list') self.lastusedradiobutton = setup_label("pref_use_last_radio", 'use_last_used_profile') self.notificationscheckbox = setup_label("pref_use_libnotify", 'display_notifications') # DHCP Clients self.dhcpautoradio = setup_label("dhcp_auto_radio", "wicd_auto_config") self.dhclientradio = self.wTree.get_widget("dhclient_radio") self.pumpradio = self.wTree.get_widget("pump_radio") self.dhcpcdradio = self.wTree.get_widget("dhcpcd_radio") self.udhcpcradio = self.wTree.get_widget("udhcpc_radio") # Wired Link Detection Apps self.linkautoradio = setup_label("link_auto_radio", 'wicd_auto_config') self.linkautoradio = setup_label("link_auto_radio") self.ethtoolradio = setup_label("ethtool_radio") self.miitoolradio = setup_label("miitool_radio") # Route Flushing Apps self.flushautoradio = setup_label("flush_auto_radio", 'wicd_auto_config') self.ipflushradio = setup_label("ip_flush_radio") self.routeflushradio = setup_label("route_flush_radio") # Graphical Sudo Apps self.sudoautoradio = setup_label("sudo_auto_radio", "wicd_auto_config") self.gksudoradio = setup_label("gksudo_radio") self.kdesuradio = setup_label("kdesu_radio") self.ktsussradio = setup_label("ktsuss_radio") # Replacement for the combo box hack self.wpadrivercombo = build_combobox("pref_wpa_combobox") self.wpadrivers = wireless.GetWpaSupplicantDrivers() self.wpadrivers.append("ralink_legacy") for x in self.wpadrivers: self.wpadrivercombo.append_text(x) self.entryWirelessInterface = self.wTree.get_widget("pref_wifi_entry") self.entryWiredInterface = self.wTree.get_widget("pref_wired_entry") # Set up global DNS stuff self.useGlobalDNSCheckbox = setup_label("pref_global_check", 'use_global_dns') self.searchDomEntry = self.wTree.get_widget("pref_search_dom_entry") self.dnsDomEntry = self.wTree.get_widget("pref_dns_dom_entry") self.dns1Entry = self.wTree.get_widget("pref_dns1_entry") self.dns2Entry = self.wTree.get_widget("pref_dns2_entry") self.dns3Entry = self.wTree.get_widget("pref_dns3_entry") self.backendcombo = build_combobox("pref_backend_combobox") self.backendcombo.connect("changed", self.be_combo_changed) # Load backend combobox self.backends = daemon.GetBackendList() self.be_descriptions = daemon.GetBackendDescriptionDict() for x in self.backends: if x: self.backendcombo.append_text(x) def be_combo_changed(self, combo): """ Update the description label for the given backend. """ self.backendcombo.set_tooltip_text( self.be_descriptions[combo.get_active_text()] )