diff --git a/curses/configscript_curses.py b/curses/configscript_curses.py index 64c2ddc..29f6087 100755 --- a/curses/configscript_curses.py +++ b/curses/configscript_curses.py @@ -12,21 +12,20 @@ Also recycles a lot of configscript.py, too. :-) # it under the terms of the GNU General Public License as published by # the Free Software Foundation; either version 2 of the License, or # (at your option) any later version. -# +# # 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, write to the Free Software # Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, # MA 02110-1301, USA. -from wicd import misc from wicd.translations import _ -import configscript -from configscript import write_scripts, get_script_info, get_val + +from configscript import write_scripts, get_script_info from configscript import none_to_blank, blank_to_none import urwid @@ -41,6 +40,7 @@ post_entry = None pre_disconnect_entry = None post_disconnect_entry = None + def main(argv): """ Main function. """ global ui, frame @@ -54,17 +54,17 @@ def main(argv): ('focus', 'dark magenta', 'light gray'), ('editcp', 'default', 'default', 'standout'), ('editbx', 'light gray', 'dark blue'), - ('editfc', 'white','dark blue', 'bold'), + ('editfc', 'white', 'dark blue', 'bold'), ]) network = argv[1] network_type = argv[2] - + script_info = get_script_info(network, network_type) blank = urwid.Text('') pre_entry_t = ('body', _('Pre-connection Script') + ': ') - post_entry_t = ('body', _('Post-connection Script') + ': ') + post_entry_t = ('body', _('Post-connection Script') + ': ') pre_disconnect_entry_t = ('body', _('Pre-disconnection Script') + ': ') post_disconnect_entry_t = ('body', _('Post-disconnection Script') + ': ') @@ -74,23 +74,23 @@ def main(argv): 'editbx', 'editfc') post_entry = urwid.AttrWrap(urwid.Edit(post_entry_t, none_to_blank(script_info.get('post_entry'))), - 'editbx','editfc') + 'editbx', 'editfc') pre_disconnect_entry = urwid.AttrWrap(urwid.Edit(pre_disconnect_entry_t, none_to_blank(script_info.get('pre_disconnect_entry'))), 'editbx', 'editfc') post_disconnect_entry = urwid.AttrWrap(urwid.Edit(post_disconnect_entry_t, none_to_blank(script_info.get('post_disconnect_entry'))), - 'editbx','editfc') + 'editbx', 'editfc') # The buttons ok_button = urwid.AttrWrap( urwid.Button(_('OK'), ok_callback), - 'body','focus' + 'body', 'focus' ) cancel_button = urwid.AttrWrap( urwid.Button(_('Cancel'), cancel_callback), - 'body','focus' + 'body', 'focus' ) button_cols = urwid.Columns([ok_button, cancel_button], dividechars=1) @@ -101,12 +101,12 @@ def main(argv): ('fixed', 2, urwid.Filler(pre_disconnect_entry)), ('fixed', 2, urwid.Filler(post_disconnect_entry)), #blank, blank, blank, blank, blank, - urwid.Filler(button_cols,'bottom') + urwid.Filler(button_cols, 'bottom') ]) frame = urwid.Frame(lbox) result = ui.run_wrapper(run) - - if result == True: + + if result: script_info["pre_entry"] = blank_to_none(pre_entry.get_edit_text()) script_info["post_entry"] = blank_to_none(post_entry.get_edit_text()) script_info["pre_disconnect_entry"] = \ @@ -117,13 +117,22 @@ def main(argv): OK_PRESSED = False CANCEL_PRESSED = False + + def ok_callback(button_object, user_data=None): + """ Callback. """ global OK_PRESSED OK_PRESSED = True + + def cancel_callback(button_object, user_data=None): + """ Callback. """ global CANCEL_PRESSED CANCEL_PRESSED = True + + def run(): + """ Run the UI. """ dim = ui.get_cols_rows() ui.set_mouse_tracking() diff --git a/curses/curses_misc.py b/curses/curses_misc.py index 1bd30b6..b958d94 100644 --- a/curses/curses_misc.py +++ b/curses/curses_misc.py @@ -1,7 +1,7 @@ #!/usr/bin/env python # -* coding: utf-8 -*- -""" curses_misc.py: Module for various widgets that are used throughout +""" curses_misc.py: Module for various widgets that are used throughout wicd-curses. """ @@ -11,12 +11,12 @@ wicd-curses. # it under the terms of the GNU General Public License as published by # the Free Software Foundation; either version 2 of the License, or # (at your option) any later version. -# +# # 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, write to the Free Software # Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, @@ -26,6 +26,7 @@ import urwid from wicd.translations import _ + # Uses code that is towards the bottom def error(ui, parent, message): """Shows an error dialog (or something that resembles one)""" @@ -35,6 +36,7 @@ def error(ui, parent, message): dialog = TextDialog(message, 6, 40, ('important', 'ERROR')) return dialog.run(ui, parent) + class SelText(urwid.Text): """A selectable text widget. See urwid.Text.""" @@ -46,11 +48,13 @@ class SelText(urwid.Text): """Don't handle any keys.""" return key + class NSelListBox(urwid.ListBox): """ Non-selectable ListBox. """ def selectable(self): return False + # This class is annoying. :/ class DynWrap(urwid.AttrWrap): """ @@ -62,8 +66,8 @@ class DynWrap(urwid.AttrWrap): attrs = tuple of (attr_sens,attr_not_sens) attrfoc = attributes when in focus, defaults to nothing """ - - def __init__(self, w, sensitive=True, attrs=('editbx', 'editnfc'), \ + # pylint: disable-msg=W0231 + def __init__(self, w, sensitive=True, attrs=('editbx', 'editnfc'), focus_attr='editfc'): self._attrs = attrs self._sensitive = sensitive @@ -73,11 +77,13 @@ class DynWrap(urwid.AttrWrap): else: cur_attr = attrs[1] + # pylint: disable-msg=E1101 self.__super.__init__(w, cur_attr, focus_attr) def get_sensitive(self): """ Getter for sensitive property. """ return self._sensitive + def set_sensitive(self, state): """ Setter for sensitive property. """ if state: @@ -90,6 +96,7 @@ class DynWrap(urwid.AttrWrap): def get_attrs(self): """ Getter for attrs property. """ return self._attrs + def set_attrs(self, attrs): """ Setter for attrs property. """ self._attrs = attrs @@ -98,36 +105,47 @@ class DynWrap(urwid.AttrWrap): def selectable(self): return self._sensitive + class DynEdit(DynWrap): """ Edit DynWrap'ed to the most common specifications. """ + # pylint: disable-msg=W0231 def __init__(self, caption='', edit_text='', sensitive=True, attrs=('editbx', 'editnfc'), focus_attr='editfc'): caption = ('editcp', caption + ': ') edit = urwid.Edit(caption, edit_text) + # pylint: disable-msg=E1101 self.__super.__init__(edit, sensitive, attrs, focus_attr) + class DynIntEdit(DynWrap): """ IntEdit DynWrap'ed to the most common specifications. """ + # pylint: disable-msg=W0231 def __init__(self, caption='', edit_text='', sensitive=True, attrs=('editbx', 'editnfc'), focus_attr='editfc'): caption = ('editcp', caption + ':') edit = urwid.IntEdit(caption, edit_text) + # pylint: disable-msg=E1101 self.__super.__init__(edit, sensitive, attrs, focus_attr) + class DynRadioButton(DynWrap): """ RadioButton DynWrap'ed to the most common specifications. """ + # pylint: disable-msg=W0231 def __init__(self, group, label, state='first True', on_state_change=None, user_data=None, sensitive=True, attrs=('body', 'editnfc'), focus_attr='body'): #caption = ('editcp', caption + ':') button = urwid.RadioButton(group, label, state, on_state_change, user_data) + # pylint: disable-msg=E1101 self.__super.__init__(button, sensitive, attrs, focus_attr) + class MaskingEditException(Exception): """ Custom exception. """ pass + # Password-style edit class MaskingEdit(urwid.Edit): """ @@ -135,37 +153,47 @@ class MaskingEdit(urwid.Edit): "always" : everything is a '*' all of the time "no_focus" : everything is a '*' only when not in focus "off" : everything is always unmasked - mask_char = the single character that masks all other characters in the field + mask_char = the single character that masks all other characters in the + field """ - def __init__(self, caption = "", edit_text = "", multiline = False, - align = 'left', wrap = 'space', allow_tab = False, - edit_pos = None, layout=None, mask_mode="always",mask_char='*'): + # pylint: disable-msg=W0231 + def __init__(self, caption="", edit_text="", multiline=False, align='left', + wrap='space', allow_tab=False, edit_pos=None, layout=None, + mask_mode="always", mask_char='*'): self.mask_mode = mask_mode if len(mask_char) > 1: - raise MaskingEditException('Masks of more than one character are' +\ + raise MaskingEditException('Masks of more than one character are' + ' not supported!') self.mask_char = mask_char + # pylint: disable-msg=E1101 self.__super.__init__(caption, edit_text, multiline, align, wrap, allow_tab, edit_pos, layout) def get_caption(self): + """ Return caption. """ return self.caption + def get_mask_mode(self): + """ Getter for mask_mode property. """ return self.mask_mode + def set_mask_mode(self, mode): + """ Setter for mask_mode property.""" self.mask_mode = mode def get_masked_text(self): - return self.mask_char*len(self.get_edit_text()) + """ Get masked out text. """ + return self.mask_char * len(self.get_edit_text()) def render(self, (maxcol, ), focus=False): - """ + """ Render edit widget and return canvas. Include cursor when in focus. """ # If we aren't masking anything ATM, then act like an Edit. # No problems. if self.mask_mode == "off" or (self.mask_mode == 'no_focus' and focus): + # pylint: disable-msg=E1101 canv = self.__super.render((maxcol, ), focus) # The cache messes this thing up, because I am totally changing what # is displayed. @@ -173,7 +201,7 @@ class MaskingEdit(urwid.Edit): return canv # Else, we have a slight mess to deal with... - self._shift_view_to_cursor = not not focus # force bool + self._shift_view_to_cursor = not not focus # force bool text, attr = self.get_text() text = text[:len(self.caption)] + self.get_masked_text() @@ -186,6 +214,7 @@ class MaskingEdit(urwid.Edit): return canv + class TabColumns(urwid.WidgetWrap): """ Tabbed interface, mostly for use in the Preferences Dialog @@ -195,13 +224,14 @@ class TabColumns(urwid.WidgetWrap): attrsel = attribute when active """ # FIXME Make the bottom_part optional + # pylint: disable-msg=W0231 def __init__(self, tab_str, tab_wid, title, bottom_part=None, attr=('body', 'focus'), attrsel='tab active', attrtitle='header'): #self.bottom_part = bottom_part #title_wid = urwid.Text((attrtitle, title), align='right') column_list = [] for w in tab_str: - text, _ = w.get_text() + text, trash = w.get_text() column_list.append(('fixed', len(text), w)) column_list.append(urwid.Text((attrtitle, title), align='right')) @@ -212,6 +242,7 @@ class TabColumns(urwid.WidgetWrap): #self.listbox = urwid.ListBox(walker) self.gen_pile(tab_wid[0], True) self.frame = urwid.Frame(self.pile) + # pylint: disable-msg=E1101 self.__super.__init__(self.frame) def gen_pile(self, lbox, firstrun=False): @@ -271,6 +302,7 @@ class ComboBoxException(Exception): """ Custom exception. """ pass + # A "combo box" of SelTexts # I based this off of the code found here: # http://excess.org/urwid/browser/contrib/trunk/rbreu_menus.py @@ -281,6 +313,7 @@ class ComboBox(urwid.WidgetWrap): """A ComboBox of text objects""" class ComboSpace(urwid.WidgetWrap): """The actual menu-like space that comes down from the ComboBox""" + # pylint: disable-msg=W0231 def __init__(self, l, body, ui, show_first, pos=(0, 0), attr=('body', 'focus')): """ @@ -291,7 +324,7 @@ class ComboBox(urwid.WidgetWrap): pos : a tuple of (row,col) where to put the list attr : a tuple of (attr_no_focus,attr_focus) """ - + #Calculate width and height of the menu widget: height = len(l) width = 0 @@ -305,13 +338,14 @@ class ComboBox(urwid.WidgetWrap): overlay = urwid.Overlay(self._listbox, body, ('fixed left', pos[0]), width + 2, ('fixed top', pos[1]), height) + # pylint: disable-msg=E1101 self.__super.__init__(overlay) def show(self, ui, display): """ Show widget. """ dim = ui.get_cols_rows() keys = True - + #Event loop: while True: if keys: @@ -334,11 +368,12 @@ class ComboBox(urwid.WidgetWrap): #def get_size(self): - def __init__(self, label='', l=[], attrs=('body', 'editnfc'), + # pylint: disable-msg=W0231 + def __init__(self, label='', l=None, attrs=('body', 'editnfc'), focus_attr='focus', use_enter=True, focus=0, callback=None, user_args=None): """ - label : bit of text that preceeds the combobox. If it is "", then + label : bit of text that preceeds the combobox. If it is "", then ignore it l : stuff to include in the combobox body : parent widget @@ -348,14 +383,16 @@ class ComboBox(urwid.WidgetWrap): callback : function that takes (combobox,sel_index,user_args=None) user_args : user_args in the callback """ - + self.DOWN_ARROW = ' vvv' self.label = urwid.Text(label) self.attrs = attrs self.focus_attr = focus_attr + if l is None: + l = [] self.list = l - s, _ = self.label.get_text() + s, trash = self.label.get_text() self.overlay = None self.cbox = DynWrap(SelText(self.DOWN_ARROW), attrs=attrs, @@ -368,6 +405,7 @@ class ComboBox(urwid.WidgetWrap): ) else: w = urwid.Columns([self.cbox]) + # pylint: disable-msg=E1101 self.__super.__init__(w) # We need this to pick our keypresses @@ -387,9 +425,11 @@ class ComboBox(urwid.WidgetWrap): self.row = None def set_list(self, l): + """ Populate widget list. """ self.list = l def set_focus(self, index): + """ Set widget focus. """ if urwid.VERSION < (1, 1, 0): self.focus = index else: @@ -407,15 +447,17 @@ class ComboBox(urwid.WidgetWrap): self.overlay._listbox.set_focus(index) def rebuild_combobox(self): + """ Rebuild combobox. """ self.build_combobox(self.parent, self.ui, self.row) def build_combobox(self, parent, ui, row): - s, _ = self.label.get_text() + """ Build combobox. """ + s, trash = self.label.get_text() if urwid.VERSION < (1, 1, 0): index = self.focus else: - index = self._w.focus_position + index = self._w.focus_position # pylint: disable-msg=E1103 self.cbox = DynWrap(SelText([self.list[index] + self.DOWN_ARROW]), attrs=self.attrs, focus_attr=self.focus_attr) @@ -437,45 +479,57 @@ class ComboBox(urwid.WidgetWrap): # If we press space or enter, be a combo box! def keypress(self, size, key): + """ Handle keypresses. """ activate = key == ' ' if self.use_enter: activate = activate or key == 'enter' if activate: # Die if the user didn't prepare the combobox overlay - if self.overlay == None: + if self.overlay is None: raise ComboBoxException('ComboBox must be built before use!') retval = self.overlay.show(self.ui, self.parent) - if retval != None: + if retval is not None: self.set_focus(self.list.index(retval)) #self.cbox.set_w(SelText(retval+' vvv')) - if self.callback != None: + if self.callback is not None: self.callback(self, self.overlay._listbox.get_focus()[1], self.user_args) return self._w.keypress(size, key) def selectable(self): + """ Return whether the widget is selectable. """ return self.cbox.selectable() def get_focus(self): + """ Return widget focus. """ if self.overlay: return self.overlay._listbox.get_focus() else: if urwid.VERSION < (1, 1, 0): return None, self.focus else: - return None, self._w.focus_position + return None, self._w.focus_position # pylint: disable-msg=E1103 def get_sensitive(self): + """ Return widget sensitivity. """ return self.cbox.get_sensitive() + def set_sensitive(self, state): + """ Set widget sensitivity. """ self.cbox.set_sensitive(state) + # This is a h4x3d copy of some of the code in Ian Ward's dialog.py example. class DialogExit(Exception): + """ Custom exception. """ pass + class Dialog2(urwid.WidgetWrap): - def __init__(self, text, height, width, body=None ): + """ Base class for other dialogs. """ + def __init__(self, text, height, width, body=None): + self.buttons = None + self.width = int(width) if width <= 0: self.width = ('relative', 80) @@ -499,6 +553,7 @@ class Dialog2(urwid.WidgetWrap): # buttons: tuple of name,exitcode def add_buttons(self, buttons): + """ Add buttons. """ l = [] maxlen = 0 for name, exitcode in buttons: @@ -507,7 +562,7 @@ class Dialog2(urwid.WidgetWrap): b = urwid.AttrWrap(b, 'body', 'focus') l.append(b) maxlen = max(len(name), maxlen) - maxlen += 4 # because of '< ... >' + maxlen += 4 # because of '< ... >' self.buttons = urwid.GridFlow(l, maxlen, 3, 1, 'center') self.frame.footer = urwid.Pile([ urwid.Divider(), @@ -515,9 +570,11 @@ class Dialog2(urwid.WidgetWrap): ], focus_item=1) def button_press(self, button): + """ Handle button press. """ raise DialogExit(button.exitcode) def run(self, ui, parent): + """ Run the UI. """ ui.set_mouse_tracking() size = ui.get_cols_rows() overlay = urwid.Overlay( @@ -551,15 +608,18 @@ class Dialog2(urwid.WidgetWrap): self.unhandled_key(size, k) except DialogExit, e: return self.on_exit(e.args[0]) - + def on_exit(self, exitcode): + """ Handle dialog exit. """ return exitcode, "" def unhandled_key(self, size, key): + """ Handle keypresses. """ pass -# Simple dialog with text in it and "OK" + class TextDialog(Dialog2): + """ Simple dialog with text and "OK" button. """ def __init__(self, text, height, width, header=None, align='left', buttons=(_('OK'), 1)): l = [urwid.Text(text)] @@ -573,23 +633,27 @@ class TextDialog(Dialog2): self.add_buttons([buttons]) def unhandled_key(self, size, k): + """ Handle keys. """ if k in ('up', 'page up', 'down', 'page down'): self.frame.set_focus('body') - self.view.keypress( size, k ) + self.view.keypress(size, k) self.frame.set_focus('footer') + class InputDialog(Dialog2): + """ Simple dialog with text and entry. """ def __init__(self, text, height, width, ok_name=_('OK'), edit_text=''): self.edit = urwid.Edit(wrap='clip', edit_text=edit_text) body = urwid.ListBox([self.edit]) body = urwid.AttrWrap(body, 'editbx', 'editfc') - + Dialog2.__init__(self, text, height, width, body) - + self.frame.set_focus('body') self.add_buttons([(ok_name, 0), (_('Cancel'), -1)]) - + def unhandled_key(self, size, k): + """ Handle keys. """ if k in ('up', 'page up'): self.frame.set_focus('body') if k in ('down', 'page down'): @@ -598,28 +662,36 @@ class InputDialog(Dialog2): # pass enter to the "ok" button self.frame.set_focus('footer') self.view.keypress(size, k) - + def on_exit(self, exitcode): + """ Handle dialog exit. """ return exitcode, self.edit.get_edit_text() class ClickCols(urwid.WidgetWrap): + """ Clickable menubar. """ + # pylint: disable-msg=W0231 def __init__(self, items, callback=None, args=None): cols = urwid.Columns(items) + # pylint: disable-msg=E1101 self.__super.__init__(cols) self.callback = callback self.args = args + def mouse_event(self, size, event, button, x, y, focus): + """ Handle mouse events. """ if event == "mouse press": # The keypress dealie in wicd-curses.py expects a list of keystrokes self.callback([self.args]) -# htop-style menu menu-bar on the bottom of the screen + class OptCols(urwid.WidgetWrap): + """ Htop-style menubar on the bottom of the screen. """ # tuples = [(key,desc)], on_event gets passed a key # attrs = (attr_key,attr_desc) # handler = function passed the key of the "button" pressed # mentions of 'left' and right will be converted to <- and -> respectively + # pylint: disable-msg=W0231 def __init__(self, tuples, handler, attrs=('body', 'infobar'), debug=False): # Find the longest string. Keys for this bar should be no greater than # 2 characters long (e.g., -> for left) @@ -628,18 +700,18 @@ class OptCols(urwid.WidgetWrap): # newmax = len(i[0])+len(i[1]) # if newmax > maxlen: # maxlen = newmax - + # Construct the texts textList = [] i = 0 # callbacks map the text contents to its assigned callback. self.callbacks = [] for cmd in tuples: - key = reduce(lambda s, (f, t): s.replace(f, t), [ \ - ('ctrl ', 'Ctrl+'), ('meta ', 'Alt+'), \ - ('left', '<-'), ('right', '->'), \ - ('page up', 'Page Up'), ('page down', 'Page Down'), \ - ('esc', 'ESC'), ('enter', 'Enter'), ('f10','F10')], cmd[0]) + key = reduce(lambda s, (f, t): s.replace(f, t), [ + ('ctrl ', 'Ctrl+'), ('meta ', 'Alt+'), + ('left', '<-'), ('right', '->'), + ('page up', 'Page Up'), ('page down', 'Page Down'), + ('esc', 'ESC'), ('enter', 'Enter'), ('f10', 'F10')], cmd[0]) if debug: callback = self.debugClick @@ -657,12 +729,17 @@ class OptCols(urwid.WidgetWrap): if debug: self.debug = urwid.Text("DEBUG_MODE") textList.append(('fixed', 10, self.debug)) - + cols = urwid.Columns(textList) + + # pylint: disable-msg=E1101 self.__super.__init__(cols) + def debugClick(self, args): + """ Debug clicks. """ self.debug.set_text(args) def mouse_event(self, size, event, button, x, y, focus): + """ Handle mouse events. """ # Widgets are evenly long (as of current), so... return self._w.mouse_event(size, event, button, x, y, focus) diff --git a/curses/netentry_curses.py b/curses/netentry_curses.py index ec6bcc9..6df7731 100644 --- a/curses/netentry_curses.py +++ b/curses/netentry_curses.py @@ -10,19 +10,19 @@ # it under the terms of the GNU General Public License as published by # the Free Software Foundation; either version 2 of the License, or # (at your option) any later version. -# +# # 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, write to the Free Software # Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, # MA 02110-1301, USA. import urwid -from curses_misc import TextDialog,DynWrap,MaskingEdit,ComboBox,error +from curses_misc import DynWrap, MaskingEdit, ComboBox, error import wicd.misc as misc from wicd.misc import noneToString, stringToNone, noneToBlankString, to_bool @@ -32,88 +32,124 @@ import os daemon = None wired = None wireless = None + + # Call this first! def dbus_init(dbus_ifaces): - global daemon,wired,wireless + """ Initialize DBus interfaces. """ + global daemon, wired, wireless daemon = dbus_ifaces['daemon'] wired = dbus_ifaces['wired'] wireless = dbus_ifaces['wireless'] -# Both the wired and the wireless settings preferences dialogs use some of the -# same fields. -# This will be used to produce the individual network settings dialogs way far below + class AdvancedSettingsDialog(urwid.WidgetWrap): + """ + Settings dialog. + + Both the wired and the wireless settings preferences dialogs use some of the + same fields. + This will be used to produce the individual network settings dialogs way far + below. + """ + # pylint: disable-msg=W0231 def __init__(self): - self.ui=None + self.ui = None + self.body = None + + self.wired = None + self.networkid = None + + self.encryption_info = None + self.encryption_combo = None + self.encrypt_types = None + self.encryption_chkbox = None static_ip_t = _('Use Static IPs') - ip_t = ('editcp',_('IP')+': ') - netmask_t = ('editcp',_('Netmask')+':') - gateway_t = ('editcp',_('Gateway')+':') + ip_t = ('editcp', _('IP') + ': ') + netmask_t = ('editcp', _('Netmask') + ':') + gateway_t = ('editcp', _('Gateway') + ':') use_static_dns_t = _('Use Static DNS') use_global_dns_t = _('Use global DNS servers') - dns_dom_t = ('editcp',_('DNS domain')+': ') - search_dom_t = ('editcp',_('Search domain')+':') - dns1_t = ('editcp',_('DNS server')+ ' 1'+':'+' '*8) - dns2_t = ('editcp',_('DNS server')+ ' 2'+':'+' '*8) - dns3_t = ('editcp',_('DNS server')+ ' 3'+':'+' '*8) - + dns_dom_t = ('editcp', _('DNS domain') + ': ') + search_dom_t = ('editcp', _('Search domain') + ':') + dns1_t = ('editcp', _('DNS server') + ' 1' + ':' + ' ' * 8) + dns2_t = ('editcp', _('DNS server') + ' 2' + ':' + ' ' * 8) + dns3_t = ('editcp', _('DNS server') + ' 3' + ':' + ' ' * 8) + use_dhcp_h_t = _('Use DHCP Hostname') - dhcp_h_t = ('editcp',_('DHCP Hostname')+': ') - + dhcp_h_t = ('editcp', _('DHCP Hostname') + ': ') + cancel_t = _('Cancel') ok_t = _('OK') - + self.static_ip_cb = urwid.CheckBox(static_ip_t, on_state_change=self.static_ip_toggle) - self.ip_edit = DynWrap(urwid.Edit(ip_t),False) - self.netmask_edit = DynWrap(urwid.Edit(netmask_t),False) - self.gateway_edit = DynWrap(urwid.Edit(gateway_t),False) + self.ip_edit = DynWrap(urwid.Edit(ip_t), False) + self.netmask_edit = DynWrap(urwid.Edit(netmask_t), False) + self.gateway_edit = DynWrap(urwid.Edit(gateway_t), False) + self.static_dns_cb = DynWrap( + urwid.CheckBox(use_static_dns_t, on_state_change=self.dns_toggle), + True, + ('body', 'editnfc'), + None + ) + self.global_dns_cb = DynWrap( + urwid.CheckBox(use_global_dns_t, on_state_change=self.dns_toggle), + False, + ('body', 'editnfc'), + None + ) + self.checkb_cols = urwid.Columns([ + self.static_dns_cb, + self.global_dns_cb + ]) + self.dns_dom_edit = DynWrap(urwid.Edit(dns_dom_t), False) + self.search_dom_edit = DynWrap(urwid.Edit(search_dom_t), False) + self.dns1 = DynWrap(urwid.Edit(dns1_t), False) + self.dns2 = DynWrap(urwid.Edit(dns2_t), False) + self.dns3 = DynWrap(urwid.Edit(dns3_t), False) - self.static_dns_cb = DynWrap(urwid.CheckBox(use_static_dns_t, - on_state_change=self.dns_toggle),True,('body','editnfc'),None) - self.global_dns_cb = DynWrap(urwid.CheckBox(use_global_dns_t, - on_state_change=self.dns_toggle),False,('body','editnfc'),None) - self.checkb_cols = urwid.Columns([self.static_dns_cb, - self.global_dns_cb]) - self.dns_dom_edit = DynWrap(urwid.Edit(dns_dom_t) ,False) - self.search_dom_edit = DynWrap(urwid.Edit(search_dom_t),False) - self.dns1 = DynWrap(urwid.Edit(dns1_t) ,False) - self.dns2 = DynWrap(urwid.Edit(dns2_t) ,False) - self.dns3 = DynWrap(urwid.Edit(dns3_t) ,False) - - self.use_dhcp_h = urwid.CheckBox(use_dhcp_h_t,False,on_state_change=self.use_dhcp_h_toggle) - self.dhcp_h = DynWrap(urwid.Edit(dhcp_h_t),False) + self.use_dhcp_h = urwid.CheckBox( + use_dhcp_h_t, + False, + on_state_change=self.use_dhcp_h_toggle + ) + self.dhcp_h = DynWrap(urwid.Edit(dhcp_h_t), False) _blank = urwid.Text('') - walker = urwid.SimpleListWalker([self.static_ip_cb, - self.ip_edit, - self.netmask_edit, - self.gateway_edit, - _blank, - self.checkb_cols, - self.dns_dom_edit,self.search_dom_edit, - self.dns1,self.dns2,self.dns3, - _blank, - self.use_dhcp_h, - self.dhcp_h, - _blank - ]) - - + walker = urwid.SimpleListWalker([ + self.static_ip_cb, + self.ip_edit, + self.netmask_edit, + self.gateway_edit, + _blank, + self.checkb_cols, + self.dns_dom_edit, + self.search_dom_edit, + self.dns1, self.dns2, self.dns3, + _blank, + self.use_dhcp_h, + self.dhcp_h, + _blank + ]) self._listbox = urwid.ListBox(walker) self._frame = urwid.Frame(self._listbox) + + # pylint: disable-msg=E1101 self.__super.__init__(self._frame) - - def use_dhcp_h_toggle(self,checkb,new_state,user_data=None): + + def use_dhcp_h_toggle(self, checkb, new_state, user_data=None): + """ Set sensitivity of widget. """ self.dhcp_h.set_sensitive(new_state) - def static_ip_toggle(self,checkb,new_state,user_data=None): - for w in [ self.ip_edit,self.netmask_edit,self.gateway_edit ]: + def static_ip_toggle(self, checkb, new_state, user_data=None): + """ Set sensitivity of widget. """ + for w in [self.ip_edit, self.netmask_edit, self.gateway_edit]: w.set_sensitive(new_state) self.static_dns_cb.set_state(new_state) self.static_dns_cb.set_sensitive(not new_state) @@ -122,31 +158,46 @@ class AdvancedSettingsDialog(urwid.WidgetWrap): else: self.checkb_cols.set_focus(self.static_dns_cb) - - def dns_toggle(self,checkb,new_state,user_data=None): + def dns_toggle(self, checkb, new_state, user_data=None): + """ Set sensitivity of widget. """ if checkb == self.static_dns_cb.get_w(): - for w in [ self.dns_dom_edit,self.search_dom_edit, - self.dns1,self.dns2,self.dns3 ]: + for w in [ + self.dns_dom_edit, + self.search_dom_edit, + self.dns1, + self.dns2, + self.dns3 + ]: w.set_sensitive(new_state) if not new_state: - self.global_dns_cb.set_state(False,do_callback=False) + self.global_dns_cb.set_state(False, do_callback=False) self.global_dns_cb.set_sensitive(new_state) # use_global_dns_cb is DynWrapped if checkb == self.global_dns_cb.get_w(): - for w in [self.dns_dom_edit,self.search_dom_edit, - self.dns1,self.dns2,self.dns3 ]: + for w in [self.dns_dom_edit, self.search_dom_edit, + self.dns1, self.dns2, self.dns3 ]: w.set_sensitive(not new_state) + def set_net_prop(self, option, value): + """ Set network property. MUST BE OVERRIDEN. """ + raise NotImplementedError + # Code totally yanked from netentry.py def save_settings(self): """ Save settings common to wired and wireless settings dialogs. """ if self.static_ip_cb.get_state(): - for i in [self.ip_edit,self.netmask_edit,self.gateway_edit]: + for i in [ + self.ip_edit, + self.netmask_edit, + self.gateway_edit + ]: i.set_edit_text(i.get_edit_text().strip()) self.set_net_prop("ip", noneToString(self.ip_edit.get_edit_text())) - self.set_net_prop("netmask", noneToString(self.netmask_edit.get_edit_text())) - self.set_net_prop("gateway", noneToString(self.gateway_edit.get_edit_text())) + self.set_net_prop("netmask", + noneToString(self.netmask_edit.get_edit_text())) + self.set_net_prop("gateway", + noneToString(self.gateway_edit.get_edit_text())) else: self.set_net_prop("ip", '') self.set_net_prop("netmask", '') @@ -157,11 +208,18 @@ class AdvancedSettingsDialog(urwid.WidgetWrap): self.set_net_prop('use_static_dns', True) self.set_net_prop('use_global_dns', False) # Strip addressses before checking them in the daemon. - for i in [self.dns1, self.dns2, - self.dns3,self.dns_dom_edit, self.search_dom_edit]: + for i in [ + self.dns1, + self.dns2, + self.dns3, + self.dns_dom_edit, + self.search_dom_edit + ]: i.set_edit_text(i.get_edit_text().strip()) - self.set_net_prop('dns_domain', noneToString(self.dns_dom_edit.get_edit_text())) - self.set_net_prop("search_domain", noneToString(self.search_dom_edit.get_edit_text())) + self.set_net_prop('dns_domain', + noneToString(self.dns_dom_edit.get_edit_text())) + self.set_net_prop("search_domain", + noneToString(self.search_dom_edit.get_edit_text())) self.set_net_prop("dns1", noneToString(self.dns1.get_edit_text())) self.set_net_prop("dns2", noneToString(self.dns2.get_edit_text())) self.set_net_prop("dns3", noneToString(self.dns3.get_edit_text())) @@ -177,28 +235,32 @@ class AdvancedSettingsDialog(urwid.WidgetWrap): self.set_net_prop("dns1", '') self.set_net_prop("dns2", '') self.set_net_prop("dns3", '') - self.set_net_prop('dhcphostname',self.dhcp_h.get_edit_text()) - self.set_net_prop('usedhcphostname',self.use_dhcp_h.get_state()) + self.set_net_prop('dhcphostname', self.dhcp_h.get_edit_text()) + self.set_net_prop('usedhcphostname', self.use_dhcp_h.get_state()) # Prevent comboboxes from dying. - def ready_widgets(self,ui,body): + def ready_widgets(self, ui, body): + """ Build comboboxes. """ self.ui = ui self.body = body - self.encryption_combo.build_combobox(body,ui,14) + self.encryption_combo.build_combobox(body, ui, 14) self.change_encrypt_method() - def combo_on_change(self,combobox,new_index,user_data=None): + def combo_on_change(self, combobox, new_index, user_data=None): + """ Handle change of item in the combobox. """ self.change_encrypt_method() - + # More or less ripped from netentry.py def change_encrypt_method(self): + """ Change encrypt method based on combobox. """ #self.lbox_encrypt = urwid.ListBox() self.encryption_info = {} - wid,ID = self.encryption_combo.get_focus() + wid, ID = self.encryption_combo.get_focus() methods = self.encrypt_types + # pylint: disable-msg=E0203 if self._w.body.body.__contains__(self.pile_encrypt): - self._w.body.body.pop(self._w.body.body.__len__()-1) + self._w.body.body.pop(self._w.body.body.__len__() - 1) # If nothing is selected, select the first entry. if ID == -1: @@ -210,16 +272,17 @@ class AdvancedSettingsDialog(urwid.WidgetWrap): fields = methods[ID][type_] for field in fields: try: - edit = MaskingEdit(('editcp',language[field[1].lower().replace(' ','_')]+': ')) + text = language[field[1].lower().replace(' ', '_')] except KeyError: - edit = MaskingEdit(('editcp',field[1].replace(' ','_')+': ')) + text = field[1].replace(' ', '_') + edit = MaskingEdit(('editcp', text + ': ')) edit.set_mask_mode('no_focus') theList.append(edit) # Add the data to any array, so that the information # can be easily accessed by giving the name of the wanted # data. self.encryption_info[field[0]] = [edit, type_] - + if self.wired: edit.set_edit_text(noneToBlankString( wired.GetWiredProperty(field[0]))) @@ -229,78 +292,100 @@ class AdvancedSettingsDialog(urwid.WidgetWrap): #FIXME: This causes the entire pile to light up upon use. # Make this into a listbox? - self.pile_encrypt = DynWrap(urwid.Pile(theList),attrs=('editbx','editnfc')) - + self.pile_encrypt = DynWrap( + urwid.Pile(theList), + attrs=('editbx', 'editnfc') + ) + self.pile_encrypt.set_sensitive(self.encryption_chkbox.get_state()) - - self._w.body.body.insert(self._w.body.body.__len__(),self.pile_encrypt) + + self._w.body.body.insert(self._w.body.body.__len__(), self.pile_encrypt) #self._w.body.body.append(self.pile_encrypt) - - def encryption_toggle(self,chkbox,new_state,user_data=None): + + def encryption_toggle(self, chkbox, new_state, user_data=None): + """ Set sensitivity of widget. """ self.encryption_combo.set_sensitive(new_state) self.pile_encrypt.set_sensitive(new_state) + class WiredSettingsDialog(AdvancedSettingsDialog): - def __init__(self,name,parent): - global wired, daemon + """ Settings dialog for wired interface. """ + def __init__(self, name, parent): AdvancedSettingsDialog.__init__(self) self.wired = True - - self.set_default = urwid.CheckBox(_('Use as default profile (overwrites any previous default)')) - #self.cur_default = + + self.set_default = urwid.CheckBox( + _('Use as default profile (overwrites any previous default)') + ) + #self.cur_default = # Add widgets to listbox self._w.body.body.append(self.set_default) - + self.parent = parent encryption_t = _('Use Encryption') - - self.encryption_chkbox = urwid.CheckBox(encryption_t,on_state_change=self.encryption_toggle) + + self.encryption_chkbox = urwid.CheckBox( + encryption_t, + on_state_change=self. + encryption_toggle + ) self.encryption_combo = ComboBox(callback=self.combo_on_change) self.pile_encrypt = None - # _w is a Frame, _w.body is a ListBox, _w.body.body is the ListWalker :-) + # _w is a Frame, _w.body is a ListBox, _w.body.body is the ListWalker + # pylint: disable-msg=E1103 self._listbox.body.append(self.encryption_chkbox) + # pylint: disable-msg=E1103 self._listbox.body.append(self.encryption_combo) - self.encrypt_types = misc.LoadEncryptionMethods(wired = True) + self.encrypt_types = misc.LoadEncryptionMethods(wired=True) self.set_values() - + self.prof_name = name - title = _('Configuring preferences for wired profile "$A"').replace('$A',self.prof_name) - self._w.header = urwid.Text( ('header',title),align='right' ) + title = _('Configuring preferences for wired profile "$A"'). \ + replace('$A', self.prof_name) + self._w.header = urwid.Text(('header', title), align='right') self.set_values() - def set_net_prop(self,option,value): - wired.SetWiredProperty(option,value) + + def set_net_prop(self, option, value): + """ Set network property. """ + wired.SetWiredProperty(option, value) + def set_values(self): + """ Load saved values. """ self.ip_edit.set_edit_text(self.format_entry("ip")) self.netmask_edit.set_edit_text(self.format_entry("netmask")) self.gateway_edit.set_edit_text(self.format_entry("gateway")) - self.global_dns_cb.set_state(bool(wired.GetWiredProperty('use_global_dns'))) - self.static_dns_cb.set_state(bool(wired.GetWiredProperty('use_static_dns'))) - + self.global_dns_cb.set_state( + bool(wired.GetWiredProperty('use_global_dns')) + ) + self.static_dns_cb.set_state( + bool(wired.GetWiredProperty('use_static_dns')) + ) + # Set static ip checkbox. Forgot to do this the first time. if stringToNone(self.ip_edit.get_edit_text()): self.static_ip_cb.set_state(True) - self.dns1.set_edit_text(self.format_entry( "dns1")) - self.dns2.set_edit_text(self.format_entry( "dns2")) - self.dns3.set_edit_text(self.format_entry( "dns3")) + self.dns1.set_edit_text(self.format_entry("dns1")) + self.dns2.set_edit_text(self.format_entry("dns2")) + self.dns3.set_edit_text(self.format_entry("dns3")) self.dns_dom_edit.set_edit_text(self.format_entry("dns_domain")) self.search_dom_edit.set_edit_text(self.format_entry("search_domain")) self.set_default.set_state(to_bool(wired.GetWiredProperty("default"))) # Throw the encryption stuff into a list - list = [] + l = [] activeID = -1 # Set the menu to this item when we are done for x, enc_type in enumerate(self.encrypt_types): - list.append(enc_type['name']) + l.append(enc_type['name']) if enc_type['type'] == wired.GetWiredProperty("enctype"): activeID = x - self.encryption_combo.set_list(list) + self.encryption_combo.set_list(l) self.encryption_combo.set_focus(activeID) if wired.GetWiredProperty("encryption_enabled"): - self.encryption_chkbox.set_state(True,do_callback=False) + self.encryption_chkbox.set_state(True, do_callback=False) self.encryption_combo.set_sensitive(True) #self.lbox_encrypt_info.set_sensitive(True) else: @@ -313,26 +398,34 @@ class WiredSettingsDialog(AdvancedSettingsDialog): if dhcphname is None: dhcphname = os.uname()[1] - self.use_dhcp_h.set_state(bool(wired.GetWiredProperty('usedhcphostname'))) + self.use_dhcp_h.set_state( + bool(wired.GetWiredProperty('usedhcphostname')) + ) self.dhcp_h.set_sensitive(self.use_dhcp_h.get_state()) self.dhcp_h.set_edit_text(unicode(dhcphname)) def save_settings(self): + """ Save settings to disk. """ # Check encryption info if self.encryption_chkbox.get_state(): encrypt_info = self.encryption_info encrypt_methods = self.encrypt_types - self.set_net_prop("enctype", - encrypt_methods[self.encryption_combo.get_focus()[1] ]['type']) + self.set_net_prop( + "enctype", + encrypt_methods[self.encryption_combo.get_focus()[1]]['type']) self.set_net_prop("encryption_enabled", True) # Make sure all required fields are filled in. for entry_info in encrypt_info.itervalues(): if entry_info[0].get_edit_text() == "" \ - and entry_info[1] == 'required': - error(self.ui, self.parent,"%s (%s)" \ - % (_('Required encryption information is missing.'), - entry_info[0].get_caption()[0:-2] ) - ) + and entry_info[1] == 'required': + error( + self.ui, + self.parent, + "%s (%s)" % ( + _('Required encryption information is missing.'), + entry_info[0].get_caption()[0:-2] + ) + ) return False for entry_key, entry_info in encrypt_info.iteritems(): @@ -341,121 +434,157 @@ class WiredSettingsDialog(AdvancedSettingsDialog): else: self.set_net_prop("enctype", "None") self.set_net_prop("encryption_enabled", False) - + AdvancedSettingsDialog.save_settings(self) if self.set_default.get_state(): wired.UnsetWiredDefault() if self.set_default.get_state(): - bool = True + set_default = True else: - bool = False - wired.SetWiredProperty("default",bool) + set_default = False + wired.SetWiredProperty("default", set_default) 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 prerun(self,ui,dim,display): + + def prerun(self, ui, dim, display): pass -######################################## class WirelessSettingsDialog(AdvancedSettingsDialog): - def __init__(self,networkID,parent): - global wireless, daemon + """ Settings dialog for wireless interfaces. """ + def __init__(self, networkID, parent): AdvancedSettingsDialog.__init__(self) self.wired = False - + + self.bitrates = None + self.networkid = networkID self.parent = parent - global_settings_t = _('Use these settings for all networks sharing this essid') + global_settings_t = \ + _('Use these settings for all networks sharing this essid') encryption_t = _('Use Encryption') autoconnect_t = _('Automatically connect to this network') bitrate_t = _('Wireless bitrate') allow_lower_bitrates_t = _('Allow lower bitrates') - + self.global_settings_chkbox = urwid.CheckBox(global_settings_t) - self.encryption_chkbox = urwid.CheckBox(encryption_t,on_state_change=self.encryption_toggle) + self.encryption_chkbox = urwid.CheckBox( + encryption_t, + on_state_change=self. + encryption_toggle + ) self.encryption_combo = ComboBox(callback=self.combo_on_change) self.autoconnect_chkbox = urwid.CheckBox(autoconnect_t) self.bitrate_combo = ComboBox(bitrate_t) - self.allow_lower_bitrates_chkbox = urwid.CheckBox(allow_lower_bitrates_t) + self.allow_lower_bitrates_chkbox = \ + urwid.CheckBox(allow_lower_bitrates_t) self.pile_encrypt = None - # _w is a Frame, _w.body is a ListBox, _w.body.body is the ListWalker :-) + # _w is a Frame, _w.body is a ListBox, _w.body.body is the ListWalker + # pylint: disable-msg=E1103 self._listbox.body.append(self.bitrate_combo) + # pylint: disable-msg=E1103 self._listbox.body.append(self.allow_lower_bitrates_chkbox) + # pylint: disable-msg=E1103 self._listbox.body.append(urwid.Text('')) + # pylint: disable-msg=E1103 self._listbox.body.append(self.global_settings_chkbox) + # pylint: disable-msg=E1103 self._listbox.body.append(self.autoconnect_chkbox) + # pylint: disable-msg=E1103 self._listbox.body.append(self.encryption_chkbox) + # pylint: disable-msg=E1103 self._listbox.body.append(self.encryption_combo) self.encrypt_types = misc.LoadEncryptionMethods() self.set_values() - title = _('Configuring preferences for wireless network "$A" ($B)').replace('$A',wireless.GetWirelessProperty(networkID,'essid')).replace('$B',wireless.GetWirelessProperty(networkID,'bssid')) - self._w.header = urwid.Text(('header',title),align='right' ) + title = _('Configuring preferences for wireless network "$A" ($B)'). \ + replace('$A', wireless.GetWirelessProperty(networkID, 'essid')). \ + replace('$B', wireless.GetWirelessProperty(networkID, 'bssid')) + self._w.header = urwid.Text(('header', title), align='right') def set_values(self): """ Set the various network settings to the right values. """ networkID = self.networkid - self.ip_edit.set_edit_text(self.format_entry(networkID,"ip")) - self.netmask_edit.set_edit_text(self.format_entry(networkID,"netmask")) - self.gateway_edit.set_edit_text(self.format_entry(networkID,"gateway")) + self.ip_edit.set_edit_text(self.format_entry(networkID, "ip")) + self.netmask_edit.set_edit_text(self.format_entry(networkID, "netmask")) + self.gateway_edit.set_edit_text(self.format_entry(networkID, "gateway")) + + self.global_dns_cb.set_state( + bool(wireless.GetWirelessProperty(networkID, 'use_global_dns'))) + self.static_dns_cb.set_state( + bool(wireless.GetWirelessProperty(networkID, 'use_static_dns'))) - self.global_dns_cb.set_state(bool(wireless.GetWirelessProperty(networkID, - 'use_global_dns'))) - self.static_dns_cb.set_state(bool(wireless.GetWirelessProperty(networkID, - 'use_static_dns'))) - if stringToNone(self.ip_edit.get_edit_text()): self.static_ip_cb.set_state(True) self.dns1.set_edit_text(self.format_entry(networkID, "dns1")) self.dns2.set_edit_text(self.format_entry(networkID, "dns2")) self.dns3.set_edit_text(self.format_entry(networkID, "dns3")) - self.dns_dom_edit.set_edit_text(self.format_entry(networkID, "dns_domain")) - self.search_dom_edit.set_edit_text(self.format_entry(networkID, "search_domain")) - - self.autoconnect_chkbox.set_state(to_bool(self.format_entry(networkID, "automatic"))) + self.dns_dom_edit.set_edit_text( + self.format_entry(networkID, "dns_domain") + ) + self.search_dom_edit.set_edit_text( + self.format_entry(networkID, "search_domain") + ) + + self.autoconnect_chkbox.set_state( + to_bool(self.format_entry(networkID, "automatic")) + ) self.bitrates = wireless.GetAvailableBitrates() self.bitrates.append('auto') self.bitrate_combo.set_list(self.bitrates) - self.bitrate_combo.set_focus(self.bitrates.index(wireless.GetWirelessProperty(networkID, 'bitrate'))) - self.allow_lower_bitrates_chkbox.set_state(to_bool(self.format_entry(networkID, 'allow_lower_bitrates'))) + self.bitrate_combo.set_focus( + self.bitrates.index( + wireless.GetWirelessProperty(networkID, 'bitrate') + ) + ) + self.allow_lower_bitrates_chkbox.set_state( + to_bool(self.format_entry(networkID, 'allow_lower_bitrates')) + ) #self.reset_static_checkboxes() - self.encryption_chkbox.set_state(bool(wireless.GetWirelessProperty(networkID, - 'encryption')),do_callback=False) - self.global_settings_chkbox.set_state(bool(wireless.GetWirelessProperty(networkID - ,'use_settings_globally'))) + self.encryption_chkbox.set_state( + bool(wireless.GetWirelessProperty(networkID, 'encryption')), + do_callback=False) + self.global_settings_chkbox.set_state( + bool(wireless.GetWirelessProperty( + networkID, + 'use_settings_globally') + ) + ) # Throw the encryption stuff into a list - list = [] + l = [] activeID = -1 # Set the menu to this item when we are done for x, enc_type in enumerate(self.encrypt_types): - list.append(enc_type['name']) - if enc_type['type'] == wireless.GetWirelessProperty(networkID, "enctype"): + l.append(enc_type['name']) + if enc_type['type'] == \ + wireless.GetWirelessProperty(networkID, "enctype"): activeID = x - self.encryption_combo.set_list(list) + self.encryption_combo.set_list(l) self.encryption_combo.set_focus(activeID) if activeID != -1: - self.encryption_chkbox.set_state(True,do_callback=False) + self.encryption_chkbox.set_state(True, do_callback=False) self.encryption_combo.set_sensitive(True) #self.lbox_encrypt_info.set_sensitive(True) else: self.encryption_combo.set_focus(0) self.change_encrypt_method() - dhcphname = wireless.GetWirelessProperty(networkID,"dhcphostname") + dhcphname = wireless.GetWirelessProperty(networkID, "dhcphostname") if dhcphname is None: dhcphname = os.uname()[1] - self.use_dhcp_h.set_state(bool(wireless.GetWirelessProperty(networkID,'usedhcphostname'))) + self.use_dhcp_h.set_state( + bool(wireless.GetWirelessProperty(networkID, 'usedhcphostname')) + ) self.dhcp_h.set_sensitive(self.use_dhcp_h.get_state()) self.dhcp_h.set_edit_text(unicode(dhcphname)) - def set_net_prop(self, option, value): """ Sets the given option to the given value for this network. """ @@ -467,20 +596,27 @@ class WirelessSettingsDialog(AdvancedSettingsDialog): # Ripped from netentry.py def save_settings(self): + """ Save settings to disk. """ # Check encryption info if self.encryption_chkbox.get_state(): encrypt_info = self.encryption_info encrypt_methods = self.encrypt_types - self.set_net_prop("enctype", - encrypt_methods[self.encryption_combo.get_focus()[1] ]['type']) + self.set_net_prop( + "enctype", + encrypt_methods[self.encryption_combo.get_focus()[1]]['type'] + ) # Make sure all required fields are filled in. for entry_info in encrypt_info.itervalues(): if entry_info[0].get_edit_text() == "" \ and entry_info[1] == 'required': - error(self.ui, self.parent,"%s (%s)" \ - % (_('Required encryption information is missing.'), - entry_info[0].get_caption()[0:-2] ) - ) + error( + self.ui, + self.parent, + "%s (%s)" % ( + _('Required encryption information is missing.'), + entry_info[0].get_caption()[0:-2] + ) + ) return False for entry_key, entry_info in encrypt_info.iteritems(): @@ -489,7 +625,11 @@ class WirelessSettingsDialog(AdvancedSettingsDialog): elif not self.encryption_chkbox.get_state() and \ wireless.GetWirelessProperty(self.networkid, "encryption"): # Encrypt checkbox is off, but the network needs it. - error(self.ui, self.parent, _('This network requires encryption to be enabled.')) + error( + self.ui, + self.parent, + _('This network requires encryption to be enabled.') + ) return False else: self.set_net_prop("enctype", "None") @@ -497,20 +637,27 @@ class WirelessSettingsDialog(AdvancedSettingsDialog): # Save the autoconnect setting. This is not where it originally was # in the GTK UI. - self.set_net_prop("automatic",self.autoconnect_chkbox.get_state()) - + self.set_net_prop("automatic", self.autoconnect_chkbox.get_state()) + if self.global_settings_chkbox.get_state(): self.set_net_prop('use_settings_globally', True) else: self.set_net_prop('use_settings_globally', False) wireless.RemoveGlobalEssidEntry(self.networkid) - self.set_net_prop('bitrate', self.bitrates[self.bitrate_combo.get_focus()[1]]) - self.set_net_prop('allow_lower_bitrates', self.allow_lower_bitrates_chkbox.get_state()) + self.set_net_prop( + 'bitrate', + self.bitrates[self.bitrate_combo.get_focus()[1]] + ) + self.set_net_prop( + 'allow_lower_bitrates', + self.allow_lower_bitrates_chkbox.get_state() + ) wireless.SaveWirelessNetworkProfile(self.networkid) return True def ready_widgets(self, ui, body): + """ Build comboboxes. """ AdvancedSettingsDialog.ready_widgets(self, ui, body) self.ui = ui self.body = body diff --git a/curses/prefs_curses.py b/curses/prefs_curses.py index f71d149..e04aaae 100644 --- a/curses/prefs_curses.py +++ b/curses/prefs_curses.py @@ -8,12 +8,12 @@ # it under the terms of the GNU General Public License as published by # the Free Software Foundation; either version 2 of the License, or # (at your option) any later version. -# +# # 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, write to the Free Software # Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, @@ -23,25 +23,30 @@ import urwid import urwid.curses_display from wicd import misc -from wicd import dbusmanager from wicd.translations import _ -from curses_misc import SelText,DynWrap,DynRadioButton,ComboBox,TabColumns +from curses_misc import SelText, DynWrap, DynRadioButton, ComboBox, TabColumns daemon = None wireless = None wired = None -from wicd.translations import language class PrefsDialog(urwid.WidgetWrap): + """ Preferences dialog. """ + # pylint: disable-msg=W0231 def __init__(self, body, pos, ui, dbus=None): global daemon, wireless, wired + self.thebackends = None + self.backends = None + self.wpadrivers = None + self.thedrivers = None + daemon = dbus['daemon'] wireless = dbus['wireless'] wired = dbus['wired'] - width,height = ui.get_cols_rows() + width, height = ui.get_cols_rows() height -= 3 #width = 80 #height = 20 @@ -53,7 +58,7 @@ class PrefsDialog(urwid.WidgetWrap): self.header0 = urwid.AttrWrap(SelText(header0_t), 'tab active', 'focus') self.header1 = urwid.AttrWrap(SelText(header1_t), 'body', 'focus') self.header2 = urwid.AttrWrap(SelText(header2_t), 'body', 'focus') - title = _('Preferences') + title = ('Preferences') # Blank line _blank = urwid.Text('') @@ -63,22 +68,21 @@ class PrefsDialog(urwid.WidgetWrap): #### # General Settings - net_cat_t = ('header', _('Network Interfaces')) - wired_t = ('editcp', _('Wired Interface')+': ') - wless_t = ('editcp', _('Wireless Interface')+':') - always_show_wired_t = _('''Always show wired interface''') - prefer_wired_t = _('''Always switch to wired connection when available''') + net_cat_t = ('header', ('Network Interfaces')) + wired_t = ('editcp', ('Wired Interface') + ': ') + wless_t = ('editcp', ('Wireless Interface') + ':') + always_show_wired_t = _('Always show wired interface') + prefer_wired_t = _('Always switch to wired connection when available') global_dns_cat_t = ('header', _('Global DNS servers')) - global_dns_t = ('editcp', _('Use global DNS servers')) - dns_dom_t = ('editcp', ' '+_('DNS domain')+': ') - search_dom_t = ('editcp', ' '+_('Search domain')+':') - dns1_t = ('editcp', ' '+_('DNS server')+' 1: ') - dns2_t = ('editcp', ' '+_('DNS server')+' 2: ') - dns3_t = ('editcp', ' '+_('DNS server')+' 3: ') + global_dns_t = ('editcp', _('Use global DNS servers')) + dns_dom_t = ('editcp', ' ' + _('DNS domain') + ': ') + search_dom_t = ('editcp', ' ' + _('Search domain') + ':') + dns1_t = ('editcp', ' ' + _('DNS server') + ' 1: ') + dns2_t = ('editcp', ' ' + _('DNS server') + ' 2: ') + dns3_t = ('editcp', ' ' + _('DNS server') + ' 3: ') - - wired_auto_cat_t= ('header', _('Wired Autoconnect Settings')) + wired_auto_cat_t = ('header', _('Wired Autoconnect Settings')) wired_auto_1_t = _('Use default profile on wired autoconnect') wired_auto_2_t = _('Prompt for profile on wired autoconnect') wired_auto_3_t = _('Use last used profile on wired autoconnect') @@ -91,86 +95,90 @@ class PrefsDialog(urwid.WidgetWrap): dhcp_header_t = ('header', _('DHCP Client')) # Automatic - dhcp1_t = 'dhclient' - dhcp2_t = 'dhcpcd' - dhcp3_t = 'pump' - dhcp4_t = 'udhcpc' + dhcp1_t = 'dhclient' + dhcp2_t = 'dhcpcd' + dhcp3_t = 'pump' + dhcp4_t = 'udhcpc' wired_detect_header_t = ('header', _('Wired Link Detection')) - wired1_t = 'ethtool' - wired2_t = 'mii-tool' + wired1_t = 'ethtool' + wired2_t = 'mii-tool' flush_header_t = ('header', _('Route Table Flushing')) - flush1_t = 'ip' - flush2_t = 'route' - + flush1_t = 'ip' + flush2_t = 'route' + #### Advanced Settings - wpa_cat_t=('header', _('WPA Supplicant')) - wpa_t=('editcp','Driver:') + wpa_cat_t = ('header', _('WPA Supplicant')) + wpa_t = ('editcp', 'Driver:') wpa_list = [] - wpa_warn_t = ('important', _('You should almost always use wext as the WPA supplicant driver')) - + wpa_warn_t = ('important', + _('You should almost always use wext as the WPA supplicant driver')) + backend_cat_t = ('header', _('Backend')) - backend_t = _('Backend')+':' + backend_t = _('Backend') + ':' backend_list = [] - + debug_cat_t = ('header', _('Debugging')) debug_mode_t = _('Enable debug mode') wless_cat_t = ('header', _('Wireless Interface')) use_dbm_t = _('Use dBm to measure signal strength') - verify_ap_t = _('Ping static gateways after connecting to verify association') - - + verify_ap_t = \ + _('Ping static gateways after connecting to verify association') #### #### UI Widgets #### # General Settings - self.net_cat = urwid.Text(net_cat_t) - self.wired_edit = urwid.AttrWrap(urwid.Edit(wired_t),'editbx','editfc') - self.wless_edit = urwid.AttrWrap(urwid.Edit(wless_t),'editbx','editfc') + self.net_cat = urwid.Text(net_cat_t) + self.wired_edit = \ + urwid.AttrWrap(urwid.Edit(wired_t), 'editbx', 'editfc') + self.wless_edit = \ + urwid.AttrWrap(urwid.Edit(wless_t), 'editbx', 'editfc') self.prefer_wired_chkbx = urwid.CheckBox(prefer_wired_t) self.global_dns_cat = urwid.Text(global_dns_cat_t) # Default the global DNS settings to off. They will be reenabled later # if so required. global_dns_state = False - self.global_dns_checkb = urwid.CheckBox(global_dns_t, global_dns_state, - on_state_change=self.global_dns_trigger) + self.global_dns_checkb = urwid.CheckBox(global_dns_t, + global_dns_state, + on_state_change=self.global_dns_trigger + ) self.search_dom = DynWrap(urwid.Edit(search_dom_t), global_dns_state) - self.dns_dom = DynWrap(urwid.Edit(dns_dom_t), global_dns_state) - self.dns1 = DynWrap(urwid.Edit(dns1_t), global_dns_state) - self.dns2 = DynWrap(urwid.Edit(dns2_t), global_dns_state) - self.dns3 = DynWrap(urwid.Edit(dns3_t), global_dns_state) - + self.dns_dom = DynWrap(urwid.Edit(dns_dom_t), global_dns_state) + self.dns1 = DynWrap(urwid.Edit(dns1_t), global_dns_state) + self.dns2 = DynWrap(urwid.Edit(dns2_t), global_dns_state) + self.dns3 = DynWrap(urwid.Edit(dns3_t), global_dns_state) self.always_show_wired_checkb = urwid.CheckBox(always_show_wired_t) - self.wired_auto_l = [] - self.wired_auto_cat= urwid.Text(wired_auto_cat_t) - self.wired_auto_1 = urwid.RadioButton(self.wired_auto_l,wired_auto_1_t) - self.wired_auto_2 = urwid.RadioButton(self.wired_auto_l,wired_auto_2_t) - self.wired_auto_3 = urwid.RadioButton(self.wired_auto_l,wired_auto_3_t) + self.wired_auto_l = [] + self.wired_auto_cat = urwid.Text(wired_auto_cat_t) + self.wired_auto_1 = urwid.RadioButton(self.wired_auto_l, wired_auto_1_t) + self.wired_auto_2 = urwid.RadioButton(self.wired_auto_l, wired_auto_2_t) + self.wired_auto_3 = urwid.RadioButton(self.wired_auto_l, wired_auto_3_t) - self.auto_reconn_cat = urwid.Text(auto_reconn_cat_t) + self.auto_reconn_cat = urwid.Text(auto_reconn_cat_t) self.auto_reconn_checkb = urwid.CheckBox(auto_reconn_t) - generalLB = urwid.ListBox([self.net_cat, - self.wless_edit,#_blank, - self.wired_edit, - self.always_show_wired_checkb, - self.prefer_wired_chkbx,_blank, - self.global_dns_cat, - self.global_dns_checkb,#_blank, - self.search_dom,self.dns_dom, - self.dns1,self.dns2,self.dns3,_blank, - self.wired_auto_cat, - self.wired_auto_1, - self.wired_auto_2, - self.wired_auto_3, _blank, - self.auto_reconn_cat, - self.auto_reconn_checkb - ]) + generalLB = urwid.ListBox([ + self.net_cat, + self.wless_edit, # _blank, + self.wired_edit, + self.always_show_wired_checkb, + self.prefer_wired_chkbx, _blank, + self.global_dns_cat, + self.global_dns_checkb, # _blank, + self.search_dom, self.dns_dom, + self.dns1, self.dns2, self.dns3, _blank, + self.wired_auto_cat, + self.wired_auto_1, + self.wired_auto_2, + self.wired_auto_3, _blank, + self.auto_reconn_cat, + self.auto_reconn_checkb + ]) #### External Programs tab automatic_t = _('Automatic (recommended)') @@ -179,81 +187,84 @@ class PrefsDialog(urwid.WidgetWrap): self.dhcp_l = [] # Order of these is flipped in the actual interface, - # (2,3,1 -> dhcpcd, pump, dhclient), because dhclient often doesn't like - # to work on several distros. - self.dhcp0 = urwid.RadioButton(self.dhcp_l ,automatic_t) - self.dhcp1 = DynRadioButton(self.dhcp_l, dhcp1_t) - self.dhcp2 = DynRadioButton(self.dhcp_l, dhcp2_t) - self.dhcp3 = DynRadioButton(self.dhcp_l, dhcp3_t) - self.dhcp4 = DynRadioButton(self.dhcp_l, dhcp4_t) - self.dhcp_l = [self.dhcp0,self.dhcp1,self.dhcp2,self.dhcp3,self.dhcp4] + # (2, 3, 1 -> dhcpcd, pump, dhclient), because dhclient often doesn't + # like to work on several distros. + self.dhcp0 = urwid.RadioButton(self.dhcp_l, automatic_t) + self.dhcp1 = DynRadioButton(self.dhcp_l, dhcp1_t) + self.dhcp2 = DynRadioButton(self.dhcp_l, dhcp2_t) + self.dhcp3 = DynRadioButton(self.dhcp_l, dhcp3_t) + self.dhcp4 = DynRadioButton(self.dhcp_l, dhcp4_t) + self.dhcp_l = [ + self.dhcp0, self.dhcp1, self.dhcp2, self.dhcp3, self.dhcp4 + ] self.wired_l = [] self.wired_detect_header = urwid.Text(wired_detect_header_t) - self.wired0 = urwid.RadioButton(self.wired_l, automatic_t) - self.wired1 = DynRadioButton(self.wired_l, wired1_t) - self.wired2 = DynRadioButton(self.wired_l, wired2_t) + self.wired0 = urwid.RadioButton(self.wired_l, automatic_t) + self.wired1 = DynRadioButton(self.wired_l, wired1_t) + self.wired2 = DynRadioButton(self.wired_l, wired2_t) self.wired_l = [self.wired0, self.wired1, self.wired2] self.flush_l = [] - self.flush_header = urwid.Text(flush_header_t) - self.flush0 = urwid.RadioButton(self.flush_l,automatic_t) - self.flush1 = DynRadioButton(self.flush_l,flush1_t) - self.flush2 = DynRadioButton(self.flush_l,flush2_t) - self.flush_l = [self.flush0,self.flush1,self.flush2] - - externalLB = urwid.ListBox([self.dhcp_header, - self.dhcp0,self.dhcp2,self.dhcp3,self.dhcp1, - self.dhcp4, - _blank, - self.wired_detect_header, - self.wired0,self.wired1,self.wired2, - _blank, - self.flush_header, - self.flush0,self.flush1,self.flush2 - ]) + self.flush_header = urwid.Text(flush_header_t) + self.flush0 = urwid.RadioButton(self.flush_l, automatic_t) + self.flush1 = DynRadioButton(self.flush_l, flush1_t) + self.flush2 = DynRadioButton(self.flush_l, flush2_t) + self.flush_l = [self.flush0, self.flush1, self.flush2] + externalLB = urwid.ListBox([ + self.dhcp_header, + self.dhcp0, self.dhcp2, self.dhcp3, self.dhcp1, self.dhcp4, + _blank, + self.wired_detect_header, + self.wired0, self.wired1, self.wired2, + _blank, + self.flush_header, + self.flush0, self.flush1, self.flush2 + ]) #### Advanced settings - self.wpa_cat = urwid.Text(wpa_cat_t) - self.wpa_cbox = ComboBox(wpa_t) - self.wpa_warn = urwid.Text(wpa_warn_t) - - self.backend_cat = urwid.Text(backend_cat_t) - self.backend_cbox = ComboBox(backend_t) - - self.debug_cat = urwid.Text(debug_cat_t) - self.debug_mode_checkb = urwid.CheckBox(debug_mode_t) + self.wpa_cat = urwid.Text(wpa_cat_t) + self.wpa_cbox = ComboBox(wpa_t) + self.wpa_warn = urwid.Text(wpa_warn_t) - self.wless_cat = urwid.Text(wless_cat_t) - self.use_dbm_checkb = urwid.CheckBox(use_dbm_t) + self.backend_cat = urwid.Text(backend_cat_t) + self.backend_cbox = ComboBox(backend_t) + + self.debug_cat = urwid.Text(debug_cat_t) + self.debug_mode_checkb = urwid.CheckBox(debug_mode_t) + + self.wless_cat = urwid.Text(wless_cat_t) + self.use_dbm_checkb = urwid.CheckBox(use_dbm_t) self.verify_ap_checkb = urwid.CheckBox(verify_ap_t) + advancedLB = urwid.ListBox([ + self.wpa_cat, + self.wpa_cbox, self.wpa_warn, _blank, + self.backend_cat, + self.backend_cbox, _blank, + self.debug_cat, + self.debug_mode_checkb, _blank, + self.wless_cat, + self.use_dbm_checkb, _blank, + self.verify_ap_checkb, _blank + ]) - advancedLB = urwid.ListBox([self.wpa_cat, - self.wpa_cbox,self.wpa_warn,_blank, - self.backend_cat, - self.backend_cbox,_blank, - self.debug_cat, - self.debug_mode_checkb, _blank, - self.wless_cat, - self.use_dbm_checkb, _blank, - self.verify_ap_checkb, _blank - ]) - - - headerList = [self.header0,self.header1,self.header2] - lbList = [generalLB,externalLB,advancedLB] - self.tab_map = {self.header0 : generalLB, - self.header1 : externalLB, - self.header2 : advancedLB} + headerList = [self.header0, self.header1, self.header2] + lbList = [generalLB, externalLB, advancedLB] + self.tab_map = { + self.header0: generalLB, + self.header1: externalLB, + self.header2: advancedLB + } #self.load_settings() - self.tabs = TabColumns(headerList,lbList,_('Preferences')) + self.tabs = TabColumns(headerList, lbList, _('Preferences')) + # pylint: disable-msg=E1101 self.__super.__init__(self.tabs) - - def load_settings(self): + def load_settings(self): + """ Load settings to be used in the dialog. """ ### General Settings # ComboBox does not like dbus.Strings as text markups. My fault. :/ wless_iface = unicode(daemon.GetWirelessInterface()) @@ -269,15 +280,16 @@ class PrefsDialog(urwid.WidgetWrap): theDNS = daemon.GetGlobalDNSAddresses() i = 0 - for w in self.dns1,self.dns2,self.dns3,self.dns_dom,self.search_dom : + for w in self.dns1, self.dns2, self.dns3, self.dns_dom, self.search_dom: w.set_edit_text(misc.noneToBlankString(theDNS[i])) - i+=1 + i += 1 # Wired Automatic Connection - self.wired_auto_l[daemon.GetWiredAutoConnectMethod()-1] + self.wired_auto_l[daemon.GetWiredAutoConnectMethod() - 1] self.auto_reconn_checkb.set_state(daemon.GetAutoReconnect()) def find_avail(apps): + """ Find available apps. """ for app in apps[1:]: app.set_sensitive(daemon.GetAppAvailable(app.get_label())) @@ -285,7 +297,7 @@ class PrefsDialog(urwid.WidgetWrap): find_avail(self.dhcp_l) dhcp_method = daemon.GetDHCPClient() self.dhcp_l[dhcp_method].set_state(True) - + find_avail(self.wired_l) wired_link_method = daemon.GetLinkDetectionTool() self.wired_l[wired_link_method].set_state(True) @@ -302,17 +314,17 @@ class PrefsDialog(urwid.WidgetWrap): # Same as above with the dbus.String self.thedrivers = [unicode(w) for w in self.wpadrivers] self.wpa_cbox.set_list(self.thedrivers) - + # Pick where to begin first: def_driver = daemon.GetWPADriver() try: self.wpa_cbox.set_focus(self.wpadrivers.index(def_driver)) except ValueError: - pass # It defaults to 0 anyway (I hope) + pass # It defaults to 0 anyway (I hope) self.backends = daemon.GetBackendList() - self.thebackends= [unicode(w) for w in self.backends] - self.backend_cbox.set_list(self.thebackends) + self.thebackends = [unicode(w) for w in self.backends] + self.backend_cbox.set_list(self.thebackends) cur_backend = daemon.GetSavedBackend() try: self.backend_cbox.set_focus(self.thebackends.index(cur_backend)) @@ -329,17 +341,25 @@ class PrefsDialog(urwid.WidgetWrap): This exact order is found in prefs.py""" daemon.SetUseGlobalDNS(self.global_dns_checkb.get_state()) - for i in [self.dns1, self.dns2, - self.dns3,self.dns_dom, self.search_dom, self.dns_dom]: + for i in [ + self.dns1, self.dns2, self.dns3, + self.dns_dom, self.search_dom, self.dns_dom + ]: i.set_edit_text(i.get_edit_text().strip()) - daemon.SetGlobalDNS(self.dns1.get_edit_text(), self.dns2.get_edit_text(), - self.dns3.get_edit_text(), self.dns_dom.get_edit_text(), - self.search_dom.get_edit_text()) + daemon.SetGlobalDNS( + self.dns1.get_edit_text(), + self.dns2.get_edit_text(), + self.dns3.get_edit_text(), + self.dns_dom.get_edit_text(), + self.search_dom.get_edit_text() + ) daemon.SetWirelessInterface(self.wless_edit.get_edit_text()) daemon.SetWiredInterface(self.wired_edit.get_edit_text()) daemon.SetWPADriver(self.wpadrivers[self.wpa_cbox.get_focus()[1]]) - daemon.SetAlwaysShowWiredInterface(self.always_show_wired_checkb.get_state()) + daemon.SetAlwaysShowWiredInterface( + self.always_show_wired_checkb.get_state() + ) daemon.SetAutoReconnect(self.auto_reconn_checkb.get_state()) daemon.SetDebugMode(self.debug_mode_checkb.get_state()) daemon.SetSignalDisplayType(int(self.use_dbm_checkb.get_state())) @@ -353,7 +373,7 @@ class PrefsDialog(urwid.WidgetWrap): daemon.SetWiredAutoConnectMethod(1) daemon.SetBackend(self.backends[self.backend_cbox.get_focus()[1]]) - + # External Programs Tab if self.dhcp0.get_state(): dhcp_client = misc.AUTO @@ -366,7 +386,7 @@ class PrefsDialog(urwid.WidgetWrap): else: dhcp_client = misc.UDHCPC daemon.SetDHCPClient(dhcp_client) - + if self.wired0.get_state(): link_tool = misc.AUTO elif self.wired1.get_state(): @@ -374,7 +394,7 @@ class PrefsDialog(urwid.WidgetWrap): else: link_tool = misc.MIITOOL daemon.SetLinkDetectionTool(link_tool) - + if self.flush0.get_state(): flush_tool = misc.AUTO elif self.flush1.get_state(): @@ -383,11 +403,12 @@ class PrefsDialog(urwid.WidgetWrap): flush_tool = misc.ROUTE daemon.SetFlushTool(flush_tool) - # DNS CheckBox callback - def global_dns_trigger(self,check_box,new_state,user_data=None): - for w in self.dns1,self.dns2,self.dns3,self.dns_dom,self.search_dom: + def global_dns_trigger(self, check_box, new_state, user_data=None): + """ DNS CheckBox callback. """ + for w in self.dns1, self.dns2, self.dns3, self.dns_dom, self.search_dom: w.set_sensitive(new_state) - def ready_widgets(self,ui,body): - self.wpa_cbox.build_combobox(body,ui,4) - self.backend_cbox.build_combobox(body,ui,8) + def ready_widgets(self, ui, body): + """ Build comboboxes. """ + self.wpa_cbox.build_combobox(body, ui, 4) + self.backend_cbox.build_combobox(body, ui, 8) diff --git a/curses/wicd-curses.py b/curses/wicd-curses.py index 491f076..0e36f44 100755 --- a/curses/wicd-curses.py +++ b/curses/wicd-curses.py @@ -14,35 +14,37 @@ at least get a network connection. Or those who don't like using X and/or GTK. # it under the terms of the GNU General Public License as published by # the Free Software Foundation; either version 2 of the License, or # (at your option) any later version. -# +# # 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, write to the Free Software # Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, # MA 02110-1301, USA. -""" - This contains/will contain A LOT of code from the other parts of wicd. - This is probably due to the fact that I did not really know what I was doing - when I started writing this. It works, so I guess that's all that matters. +# This contains/will contain A LOT of code from the other parts of wicd. +# +# This is probably due to the fact that I did not really know what I was doing +# when I started writing this. It works, so I guess that's all that matters. +# +# Comments, criticisms, patches, bug reports all welcome! - Comments, criticisms, patches, bug reports all welcome! -""" # Filter out a confusing urwid warning in python 2.6. # This is valid as of urwid version 0.9.8.4 -import warnings -warnings.filterwarnings("ignore","The popen2 module is deprecated. Use the subprocess module.") +import warnings +warnings.filterwarnings( + "ignore", + "The popen2 module is deprecated. Use the subprocess module." +) # UI stuff import urwid # DBus communication stuff from dbus import DBusException -from dbus import version as dbus_version # It took me a while to figure out that I have to use this. import gobject @@ -53,66 +55,73 @@ from wicd import dbusmanager # Internal Python stuff import sys -from time import sleep, strftime, ctime # Curses UIs for other stuff -from curses_misc import * +from curses_misc import ComboBox, Dialog2, NSelListBox, SelText, OptCols +from curses_misc import TextDialog, InputDialog, error, DynEdit, DynIntEdit from prefs_curses import PrefsDialog -import netentry_curses -from netentry_curses import WirelessSettingsDialog, WiredSettingsDialog,AdvancedSettingsDialog +import netentry_curses +from netentry_curses import WirelessSettingsDialog, WiredSettingsDialog from optparse import OptionParser -from os import system # Stuff about getting the script configurer running #from grp import getgrgid -#from os import getgroups,system +#from os import getgroups, system #import logging #import logging.handler -CURSES_REV=wpath.curses_revision +CURSES_REV = wpath.curses_revision # Fix strings in wicd-curses -from wicd.translations import language +#from wicd.translations import language from wicd.translations import _ +ui = None +loop = None +bus = daemon = wireless = wired = None + ######################################## ##### SUPPORT CLASSES ######################################## # Yay for decorators! def wrap_exceptions(func): + """ Decorator to wrap exceptions. """ def wrapper(*args, **kargs): - try: - return func(*args, **kargs) - except KeyboardInterrupt: - #gobject.source_remove(redraw_tag) - loop.quit() - ui.stop() - print >> sys.stderr, "\n"+_('Terminated by user') - #raise - except DBusException: - loop.quit() - ui.stop() - print >> sys.stderr,"\n"+_('DBus failure! '\ - 'This is most likely caused by the wicd daemon stopping while wicd-curses is running. '\ - 'Please restart the daemon, and then restart wicd-curses.') - raise - except : - # Quit the loop - #if 'loop' in locals(): - loop.quit() - # Zap the screen - ui.stop() - # Print out standard notification: - # This message was far too scary for humans, so it's gone now. - # print >> sys.stderr, "\n" + _('EXCEPTION! Please report this to the maintainer and file a bug report with the backtrace below:') - # Flush the buffer so that the notification is always above the - # backtrace - sys.stdout.flush() - # Raise the exception - raise + try: + return func(*args, **kargs) + except KeyboardInterrupt: + #gobject.source_remove(redraw_tag) + loop.quit() + ui.stop() + print >> sys.stderr, "\n" + _('Terminated by user') + #raise + except DBusException: + loop.quit() + ui.stop() + print >> sys.stderr, "\n" + _('DBus failure! ' + 'This is most likely caused by the wicd daemon ' + 'stopping while wicd-curses is running. ' + 'Please restart the daemon, and then restart wicd-curses.') + raise + except: + # Quit the loop + #if 'loop' in locals(): + loop.quit() + # Zap the screen + ui.stop() + # Print out standard notification: + # This message was far too scary for humans, so it's gone now. + # print >> sys.stderr, "\n" + _('EXCEPTION! Please report this ' + # 'to the maintainer and file a bug report with the backtrace ' + # 'below:') + # Flush the buffer so that the notification is always above the + # backtrace + sys.stdout.flush() + # Raise the exception + raise wrapper.__name__ = func.__name__ wrapper.__module__ = func.__module__ @@ -120,6 +129,7 @@ def wrap_exceptions(func): wrapper.__doc__ = func.__doc__ return wrapper + ######################################## ##### SUPPORT FUNCTIONS ######################################## @@ -127,14 +137,17 @@ def wrap_exceptions(func): # Look familiar? These two functions are clones of functions found in wicd's # gui.py file, except that now set_status is a function passed to them. @wrap_exceptions -def check_for_wired(wired_ip,set_status): +def check_for_wired(wired_ip, set_status): """ Determine if wired is active, and if yes, set the status. """ if wired_ip and wired.CheckPluggedIn(): - set_status(_('Connected to wired network (IP: $A)').replace('$A',wired_ip)) + set_status( + _('Connected to wired network (IP: $A)').replace('$A',wired_ip) + ) return True else: return False + @wrap_exceptions def check_for_wireless(iwconfig, wireless_ip, set_status): """ Determine if wireless is active, and if yes, set the status. """ @@ -167,79 +180,94 @@ def check_for_wireless(iwconfig, wireless_ip, set_status): # DBUS interfaces do. :P # Whatever calls this must be exception-wrapped if it is run if the UI is up def gen_network_list(): + """ Generate the list of networks. """ wiredL = wired.GetWiredProfileList() wlessL = [] # This one makes a list of NetLabels for network_id in range(0, wireless.GetNumberOfNetworks()): - is_active = wireless.GetCurrentSignalStrength("") != 0 and wireless.GetCurrentNetworkID(wireless.GetIwconfig())==network_id and wireless.GetWirelessIP('') != None + is_active = \ + wireless.GetCurrentSignalStrength("") != 0 and \ + wireless.GetCurrentNetworkID(wireless.GetIwconfig()) == network_id \ + and wireless.GetWirelessIP('') is not None - label = NetLabel(network_id,is_active) + label = NetLabel(network_id, is_active) wlessL.append(label) - return (wiredL,wlessL) + return (wiredL, wlessL) + def about_dialog(body): + """ About dialog. """ # This looks A LOT better when it is actually displayed. I promise :-). # The ASCII Art "Wicd" was made from the "smslant" font on one of those # online ASCII big text generators. theText = [ -('green'," /// \\\\\\")," _ ___ __\n", -('green'," /// \\\\\\")," | | /| / (_)______/ /\n", -('green'," /// \\\\\\")," | |/ |/ / / __/ _ / \n", -('green',"/|| // \\\\ ||\\")," |__/|__/_/\__/\_,_/ \n", -('green',"||| ||"),"(|^|)",('green',"|| |||"), -" ($VERSION) \n".replace("$VERSION",daemon.Hello()), +('green', " /// \\\\\\"), " _ ___ __\n", +('green', " /// \\\\\\"), " | | /| / (_)______/ /\n", +('green', " /// \\\\\\"), " | |/ |/ / / __/ _ / \n", +('green', "/|| // \\\\ ||\\"), " |__/|__/_/\__/\_,_/ \n", +('green', "||| ||"), "(|^|)", ('green', "|| |||"), +" ($VERSION) \n".replace("$VERSION", daemon.Hello()), -('green',"\\|| \\\\")," |+| ",('green',"// ||/ \n"), -('green'," \\\\\\")," |+| ",('green',"///")," http://wicd.net\n", -('green'," \\\\\\")," |+| ",('green',"///")," ",_('Brought to you by:'),"\n", -('green'," \\\\\\")," |+| ",('green',"///")," Adam Blackburn\n", +('green', "\\|| \\\\"), " |+| ", ('green', "// ||/ \n"), +('green', " \\\\\\"), " |+| ", ('green', "///"), + " http://wicd.net\n", +('green', " \\\\\\"), " |+| ", ('green', "///"), " ", + _('Brought to you by:'), "\n", +('green', " \\\\\\"), " |+| ", ('green', "///"), " Adam Blackburn\n", " ___|+|___ Dan O'Reilly\n", " ____|+|____ Andrew Psaltis\n", " |-----------| David Paleino\n", "-----------------------------------------------------"] - about = TextDialog(theText,16,55,header=('header',_('About Wicd'))) - about.run(ui,body) + about = TextDialog(theText, 16, 55, header=('header', _('About Wicd'))) + about.run(ui, body) + # Modeled after htop's help def help_dialog(body): - textT = urwid.Text(('header',_('wicd-curses help')),'right') - textSH = urwid.Text(['This is ',('blue','wicd-curses-'+CURSES_REV),' using wicd ',unicode(daemon.Hello()),'\n']) + """ Help dialog. """ + textT = urwid.Text(('header', _('wicd-curses help')), 'right') + textSH = urwid.Text([ + 'This is ', ('blue', 'wicd-curses-' + CURSES_REV), + ' using wicd ', unicode(daemon.Hello()), '\n' + ]) textH = urwid.Text([ -_('For more detailed help, consult the wicd-curses(8) man page.')+"\n", -('bold','->'),' and ',('bold','<-')," are the right and left arrows respectively.\n"]) +_('For more detailed help, consult the wicd-curses(8) man page.') + "\n", +('bold', '->'), ' and ', ('bold', '<-'), +" are the right and left arrows respectively.\n" + ]) text1 = urwid.Text([ -('bold',' H h ?'),": "+_('Display this help dialog')+"\n", -('bold','enter C'),": "+_('Connect to selected network')+"\n", -('bold',' D'),": "+_('Disconnect from all networks')+"\n", -('bold',' ESC'),": "+_('Stop a connection in progress')+"\n", -('bold',' F5 R'),": "+_('Refresh network list')+"\n", -('bold',' P'),": "+_('Preferences dialog')+"\n", +('bold', ' H h ?'), ": " + _('Display this help dialog') + "\n", +('bold', 'enter C'), ": " + _('Connect to selected network') + "\n", +('bold', ' D'), ": " + _('Disconnect from all networks') + "\n", +('bold', ' ESC'), ": " + _('Stop a connection in progress') + "\n", +('bold', ' F5 R'), ": " + _('Refresh network list') + "\n", +('bold', ' P'), ": " + _('Preferences dialog') + "\n", ]) text2 = urwid.Text([ -('bold',' I'),": "+_('Scan for hidden networks')+"\n", -('bold',' S'),": "+_('Select scripts')+"\n", -('bold',' O'),": "+_('Set up Ad-hoc network')+"\n", -('bold',' X'),": "+_('Remove settings for saved networks')+"\n", -('bold',' ->'),": "+_('Configure selected network')+"\n", -('bold',' A'),": "+_("Display 'about' dialog")+"\n", -('bold',' F8 q Q'),": "+_('Quit wicd-curses')+"\n", +('bold', ' I'), ": " + _('Scan for hidden networks') + "\n", +('bold', ' S'), ": " + _('Select scripts') + "\n", +('bold', ' O'), ": " + _('Set up Ad-hoc network') + "\n", +('bold', ' X'), ": " + _('Remove settings for saved networks') + "\n", +('bold', ' ->'), ": " + _('Configure selected network') + "\n", +('bold', ' A'), ": " + _("Display 'about' dialog") + "\n", +('bold', ' F8 q Q'), ": " + _('Quit wicd-curses') + "\n", ]) textF = urwid.Text(_('Press any key to return.')) - - # textJ = urwid.Text(('important','Nobody expects the Spanish Inquisition!')) + + #textJ = urwid.Text(('important', 'Nobody expects the Spanish Inquisition!')) blank = urwid.Text('') - cols = urwid.Columns([text1,text2]) - pile = urwid.Pile([textH,cols]) + cols = urwid.Columns([text1, text2]) + pile = urwid.Pile([textH, cols]) fill = urwid.Filler(pile) - frame = urwid.Frame(fill,header=urwid.Pile([textT,textSH]),footer=textF) + frame = urwid.Frame(fill, header=urwid.Pile([textT, textSH]), footer=textF) dim = ui.get_cols_rows() while True: ui.draw_screen(dim, frame.render(dim, True)) - + keys = ui.get_input() # Don't stop because someone let go of the mouse on the frame mouse_release = False @@ -251,173 +279,207 @@ _('For more detailed help, consult the wicd-curses(8) man page.')+"\n", if check_mouse_event(k) and k[0] == "mouse release": mouse_release = True break - if mouse_release : + if mouse_release: continue if 'window resize' in keys: dim = ui.get_cols_rows() elif keys: break -def run_configscript(parent,netname,nettype): - configfile = wpath.etc+netname+'-settings.conf' + +def run_configscript(parent, netname, nettype): + """ Run configuration script. """ + configfile = wpath.etc + netname + '-settings.conf' if nettype != 'wired': header = 'profile' else: - header ='BSSID' + header = 'BSSID' if nettype == 'wired': profname = nettype else: - profname = wireless.GetWirelessProperty( int(netname),'bssid') + profname = wireless.GetWirelessProperty(int(netname), 'bssid') theText = [ - _('To avoid various complications, wicd-curses does not support directly editing the scripts. '\ - 'However, you can edit them manually. First, (as root), open the "$A" config file, and look '\ - 'for the section labeled by the $B in question. In this case, this is:'). - replace('$A', configfile).replace('$B', header), -"\n\n["+profname+"]\n\n", - _('You can also configure the wireless networks by looking for the "[]" field in the config file.'), - _('Once there, you can adjust (or add) the "beforescript", "afterscript", "predisconnectscript" '\ - 'and "postdisconnectscript" variables as needed, to change the preconnect, postconnect, '\ - 'predisconnect and postdisconnect scripts respectively. Note that you will be specifying '\ - 'the full path to the scripts - not the actual script contents. You will need to add/edit '\ - 'the script contents separately. Refer to the wicd manual page for more information.') +_('To avoid various complications, wicd-curses does not support directly ' +'editing the scripts. However, you can edit them manually. First, (as root), ' +'open the "$A" config file, and look for the section labeled by the $B in ' +'question. In this case, this is:'). +replace('$A', configfile).replace('$B', header), +"\n\n[" + profname + "]\n\n", +_('You can also configure the wireless networks by looking for the "[]" ' +'field in the config file.'), +_('Once there, you can adjust (or add) the "beforescript", "afterscript", ' +'"predisconnectscript" and "postdisconnectscript" variables as needed, to ' +'change the preconnect, postconnect, predisconnect and postdisconnect scripts ' +'respectively. Note that you will be specifying the full path to the scripts ' +'- not the actual script contents. You will need to add/edit the script ' +'contents separately. Refer to the wicd manual page for more information.') ] - dialog = TextDialog(theText,20,80) - dialog.run(ui,parent) + dialog = TextDialog(theText, 20, 80) + dialog.run(ui, parent) # This code works with many distributions, but not all of them. So, to # limit complications, it has been deactivated. If you want to run it, # be my guest. Be sure to deactivate the above stuff first. - """ - loop.quit() - ui.stop() - argv = netname + ' ' +nettype - #cmd = '/usr/lib/configscript_curses.py '+argv - cmd = wpath.lib+'configscript_curses.py '+argv - # Check whether we can sudo. Hopefully this is complete - glist = [] - for i in getgroups(): - glist.append(getgrgid(i)[0]) - if 'root' in glist: - precmd = '' - precmdargv = '' - postcmd = '' - elif 'admin' in glist or 'wheel' in glist or 'sudo' in glist: - precmd = 'sudo' - precmdargv = '' - postcmd = '' - else: - precmd = 'su' - precmdargv = ' -c "' - postcmd = '"' - print "Calling command: " + precmd + precmdargv + cmd + postcmd - sys.stdout.flush() - system(precmd+precmdargv+cmd+postcmd) - raw_input("Press enter!") - main() - """ + #loop.quit() + #ui.stop() + #argv = netname + ' ' +nettype + + ##cmd = '/usr/lib/configscript_curses.py '+argv + #cmd = wpath.lib+'configscript_curses.py '+argv + ## Check whether we can sudo. Hopefully this is complete + #glist = [] + #for i in getgroups(): + #glist.append(getgrgid(i)[0]) + #if 'root' in glist: + #precmd = '' + #precmdargv = '' + #postcmd = '' + #elif 'admin' in glist or 'wheel' in glist or 'sudo' in glist: + #precmd = 'sudo' + #precmdargv = '' + #postcmd = '' + #else: + #precmd = 'su' + #precmdargv = ' -c "' + #postcmd = '"' + #print "Calling command: " + precmd + precmdargv + cmd + postcmd + #sys.stdout.flush() + #system(precmd+precmdargv+cmd+postcmd) + #raw_input("Press enter!") + #main() + def gen_list_header(): + """ Generate header. """ if daemon.GetSignalDisplayType() == 0: # Allocate 25 cols for the ESSID name essidgap = 25 else: # Need 3 more to accomodate dBm strings essidgap = 28 - return 'C %s %*s %9s %17s %6s %s' % ('STR ',essidgap,'ESSID','ENCRYPT','BSSID','MODE','CHNL') + return 'C %s %*s %9s %17s %6s %s' % \ + ('STR ', essidgap, 'ESSID', 'ENCRYPT', 'BSSID', 'MODE', 'CHNL') + ######################################## ##### URWID SUPPORT CLASSES ######################################## -# Wireless network label class NetLabel(urwid.WidgetWrap): - def __init__(self, id, is_active): + """ Wireless network label. """ + # pylint: disable-msg=W0231 + def __init__(self, i, is_active): # Pick which strength measure to use based on what the daemon says # gap allocates more space to the first module if daemon.GetSignalDisplayType() == 0: strenstr = 'quality' - gap = 4 # Allow for 100% + gap = 4 # Allow for 100% else: strenstr = 'strength' - gap = 7 # -XX dbm = 7 - self.id = id + gap = 7 # -XX dbm = 7 + self.id = i # All of that network property stuff self.stren = daemon.FormatSignalForPrinting( - str(wireless.GetWirelessProperty(id, strenstr))) - self.essid = wireless.GetWirelessProperty(id, 'essid') - self.bssid = wireless.GetWirelessProperty(id, 'bssid') + str(wireless.GetWirelessProperty(self.id, strenstr))) + self.essid = wireless.GetWirelessProperty(self.id, 'essid') + self.bssid = wireless.GetWirelessProperty(self.id, 'bssid') - if wireless.GetWirelessProperty(id, 'encryption'): - self.encrypt = wireless.GetWirelessProperty(id,'encryption_method') + if wireless.GetWirelessProperty(self.id, 'encryption'): + self.encrypt = \ + wireless.GetWirelessProperty(self.id, 'encryption_method') else: self.encrypt = _('Unsecured') - self.mode = wireless.GetWirelessProperty(id, 'mode') # Master, Ad-Hoc - self.channel = wireless.GetWirelessProperty(id, 'channel') - theString = ' %-*s %25s %9s %17s %6s %4s' % (gap, - self.stren,self.essid,self.encrypt,self.bssid,self.mode,self.channel) + self.mode = \ + wireless.GetWirelessProperty(self.id, 'mode') # Master, Ad-Hoc + self.channel = wireless.GetWirelessProperty(self.id, 'channel') + theString = ' %-*s %25s %9s %17s %6s %4s' % \ + (gap, self.stren, self.essid, self.encrypt, self.bssid, self.mode, + self.channel) if is_active: - theString = '>'+theString[1:] - w = urwid.AttrWrap(SelText(theString),'connected','connected focus') + theString = '>' + theString[1:] + w = urwid.AttrWrap( + SelText(theString), + 'connected', + 'connected focus' + ) else: - w = urwid.AttrWrap(SelText(theString),'body','focus') + w = urwid.AttrWrap(SelText(theString), 'body', 'focus') + # pylint: disable-msg=E1101 self.__super.__init__(w) + def selectable(self): + """ Return whether the widget is selectable. """ return True - def keypress(self,size,key): - return self._w.keypress(size,key) + + def keypress(self, size, key): + """ Handle keypresses. """ + return self._w.keypress(size, key) + def connect(self): + """ Execute connection. """ wireless.ConnectWireless(self.id) - + + class WiredComboBox(ComboBox): """ list : the list of wired network profiles. The rest is self-explanitory. """ - def __init__(self,list): - self.ADD_PROFILE = '---'+_('Add a new profile')+'---' + # pylint: disable-msg=W0231 + def __init__(self, l): + self.ADD_PROFILE = '---' + _('Add a new profile') + '---' + # pylint: disable-msg=E1101 self.__super.__init__(use_enter=False) - self.set_list(list) + self.theList = [] + self.set_list(l) - def set_list(self,list): - self.theList = list - id=0 - wiredL=[] - is_active = wireless.GetWirelessIP('') == None and wired.GetWiredIP('') != None - for profile in list: - theString = '%4s %25s' % (id, profile) + def set_list(self, l): + """ Set contents of the combobox. """ + self.theList = l + i = 0 + wiredL = [] + is_active = \ + wireless.GetWirelessIP('') is None and \ + wired.GetWiredIP('') is not None + for profile in l: + theString = '%4s %25s' % (i, profile) # Tag if no wireless IP present, and wired one is if is_active: - theString = '>'+theString[1:] - + theString = '>' + theString[1:] + wiredL.append(theString) - id+=1 + i += 1 wiredL.append(self.ADD_PROFILE) if is_active: - self.attrs = ('connected','editnfc') + self.attrs = ('connected', 'editnfc') self.focus_attr = 'connected focus' - else : - self.attrs = ('body','editnfc') + else: + self.attrs = ('body', 'editnfc') self.focus_attr = 'focus' self.list = wiredL if self.theList != []: wired.ReadWiredNetworkProfile(self.get_selected_profile()) - def keypress(self,size,key): + def keypress(self, size, key): + """ Handle keypresses. """ prev_focus = self.get_focus()[1] - key = ComboBox.keypress(self,size,key) + key = ComboBox.keypress(self, size, key) if key == ' ': - if self.get_focus()[1] == len(self.list)-1: - dialog = InputDialog(('header',_('Add a new wired profile')),7,30) - exitcode,name = dialog.run(ui,self.parent) + if self.get_focus()[1] == len(self.list) - 1: + dialog = InputDialog( + ('header', _('Add a new wired profile')), + 7, 30 + ) + exitcode, name = dialog.run(ui, self.parent) if exitcode == 0: name = name.strip() if not name: - error(ui,self.parent,'Invalid profile name') + error(ui, self.parent, 'Invalid profile name') self.set_focus(prev_focus) return key - wired.CreateWiredNetworkProfile(name,False) + wired.CreateWiredNetworkProfile(name, False) self.set_list(wired.GetWiredProfileList()) self.rebuild_combobox() self.set_focus(prev_focus) @@ -425,22 +487,32 @@ class WiredComboBox(ComboBox): wired.ReadWiredNetworkProfile(self.get_selected_profile()) if key == 'delete': if len(self.theList) == 1: - error(self.ui,self.parent,_('wicd-curses does not support deleting the last wired profile. Try renaming it ("F2")')) + error( + self.ui, + self.parent, + _('wicd-curses does not support deleting the last wired ' + 'profile. Try renaming it ("F2")') + ) return key wired.DeleteWiredNetworkProfile(self.get_selected_profile()) # Return to the top of the list if something is deleted. - if wired.GetDefaultWiredNetwork() != None: - self.set_focus(self.theList.index(wired.GetDefaultWiredNetwork())) + if wired.GetDefaultWiredNetwork() is not None: + self.set_focus( + self.theList.index(wired.GetDefaultWiredNetwork()) + ) else: prev_focus -= 1 self.set_focus(prev_focus) self.set_list(wired.GetWiredProfileList()) self.rebuild_combobox() if key == 'f2': - dialog = InputDialog(('header',_('Rename wired profile')),7,30, - edit_text=unicode(self.get_selected_profile())) - exitcode,name = dialog.run(ui,self.parent) + dialog = InputDialog( + ('header', _('Rename wired profile')), + 7, 30, + edit_text=unicode(self.get_selected_profile()) + ) + exitcode, name = dialog.run(ui, self.parent) if exitcode == 0: # Save the new one, then kill the old one wired.SaveWiredNetworkProfile(name) @@ -455,20 +527,21 @@ class WiredComboBox(ComboBox): loc = self.get_focus()[1] return self.theList[loc] -# Dialog2 that initiates an Ad-Hoc network connection + class AdHocDialog(Dialog2): + """ Dialog2 that initiates an Ad-Hoc network connection. """ def __init__(self): essid_t = _('ESSID') ip_t = _('IP') channel_t = _('Channel') key_t = " " + _('Key') - use_ics_t = _('Activate Internet Connection Sharing') + use_ics_t = _('Activate Internet Connection Sharing') use_encrypt_t = _('Use Encryption (WEP only)') self.essid_edit = DynEdit(essid_t) self.ip_edit = DynEdit(ip_t) self.channel_edit = DynIntEdit(channel_t) - self.key_edit = DynEdit(key_t,sensitive=False) + self.key_edit = DynEdit(key_t, sensitive=False) self.use_ics_chkb = urwid.CheckBox(use_ics_t) self.use_encrypt_chkb = urwid.CheckBox(use_encrypt_t, @@ -481,45 +554,54 @@ class AdHocDialog(Dialog2): self.ip_edit.set_edit_text("169.254.12.10") self.channel_edit.set_edit_text("3") - l = [self.essid_edit,self.ip_edit,self.channel_edit,blank, - self.use_ics_chkb,self.use_encrypt_chkb,self.key_edit] + l = [self.essid_edit, self.ip_edit, self.channel_edit, blank, + self.use_ics_chkb, self.use_encrypt_chkb, self.key_edit] body = urwid.ListBox(l) header = ('header', _('Create an Ad-Hoc Network')) Dialog2.__init__(self, header, 15, 50, body) - self.add_buttons([(_('OK'),1),(_('Cancel'),-1)]) + self.add_buttons([(_('OK'), 1), (_('Cancel'), -1)]) self.frame.set_focus('body') - def encrypt_callback(self,chkbox,new_state,user_info=None): + def encrypt_callback(self, chkbox, new_state, user_info=None): + """ Set widget sensitivity. """ self.key_edit.set_sensitive(new_state) def unhandled_key(self, size, k): - if k in ('up','page up'): + """ Handle keypresses. """ + if k in ('up', 'page up'): self.frame.set_focus('body') - if k in ('down','page down'): + if k in ('down', 'page down'): self.frame.set_focus('footer') if k == 'enter': # pass enter to the "ok" button self.frame.set_focus('footer') self.buttons.set_focus(0) - self.view.keypress( size, k ) - def on_exit(self,exitcode): - data = ( self.essid_edit.get_edit_text(), - self.ip_edit.get_edit_text().strip(), - self.channel_edit.get_edit_text(), - self.use_ics_chkb.get_state(), - self.use_encrypt_chkb.get_state(), - self.key_edit.get_edit_text()) + self.view.keypress(size, k) + + def on_exit(self, exitcode): + """ Handle dialog exit. """ + data = (self.essid_edit.get_edit_text(), + self.ip_edit.get_edit_text().strip(), + self.channel_edit.get_edit_text(), + self.use_ics_chkb.get_state(), + self.use_encrypt_chkb.get_state(), + self.key_edit.get_edit_text()) return exitcode, data + # TODO class ForgetDialog(Dialog2): + """ Dialog2 that removes/forgets a network. """ def __init__(self): self.to_remove = dict(essid=[], bssid=[]) - header = urwid.AttrWrap(urwid.Text(' %20s %20s' % ('ESSID', 'BSSID')), 'listbar') + header = urwid.AttrWrap( + urwid.Text(' %20s %20s' % ('ESSID', 'BSSID')), + 'listbar' + ) title = urwid.Text(_('Please select the networks to forget')) - l = [ title, header ] + l = [title, header] for entry in wireless.GetSavedWirelessNetworks(): label = '%20s %20s' if entry[1] != 'None': @@ -529,16 +611,21 @@ class ForgetDialog(Dialog2): label = label % (entry[0], 'global') data = (entry[0], 'essid:' + entry[0]) - cb = urwid.CheckBox(label, on_state_change=self.update_to_remove, user_data=data) + cb = urwid.CheckBox( + label, + on_state_change=self.update_to_remove, + user_data=data + ) l.append(cb) body = urwid.ListBox(l) header = ('header', _('List of saved networks')) Dialog2.__init__(self, header, 15, 50, body) - self.add_buttons([(_('Remove'),1),(_('Cancel'),-1)]) + self.add_buttons([(_('Remove'), 1), (_('Cancel'), -1)]) self.frame.set_focus('body') def update_to_remove(self, widget, checked, data): + """ Update list of removable networks. """ if checked: self.to_remove['essid'].append(data[0]) self.to_remove['bssid'].append(data[1]) @@ -547,9 +634,10 @@ class ForgetDialog(Dialog2): self.to_remove['bssid'].remove(data[1]) def unhandled_key(self, size, k): - if k in ('up','page up'): + """ Handle unhandled keys. """ + if k in ('up', 'page up'): self.frame.set_focus('body') - if k in ('down','page down'): + if k in ('down', 'page down'): self.frame.set_focus('footer') if k == 'enter': # pass enter to the "ok" button @@ -558,8 +646,10 @@ class ForgetDialog(Dialog2): self.view.keypress(size, k) def on_exit(self, exitcode): + """ Handle dialog exit. """ return exitcode, self.to_remove + ######################################## ##### APPLICATION INTERFACE CLASS ######################################## @@ -567,72 +657,89 @@ class ForgetDialog(Dialog2): class appGUI(): """The UI itself, all glory belongs to it!""" def __init__(self): - global loop + self.conn_status = False + self.tcount = 0 # Counter for connection twirl indicator + self.size = ui.get_cols_rows() # Happy screen saying that you can't do anything because we're scanning # for networks. :-) - self.screen_locker = urwid.Filler(urwid.Text(('important',_('Scanning networks... stand by...')), align='center')) - self.no_wlan = urwid.Filler(urwid.Text(('important',_('No wireless networks found.')), align='center')) + self.screen_locker = urwid.Filler( + urwid.Text( + ('important', _('Scanning networks... stand by...')), + align='center' + ) + ) + self.no_wlan = urwid.Filler( + urwid.Text( + ('important', _('No wireless networks found.')), + align='center' + ) + ) self.TITLE = _('Wicd Curses Interface') self.WIRED_IDX = 1 self.WLESS_IDX = 3 - header = urwid.AttrWrap(urwid.Text(self.TITLE,align='right'), 'header') - self.wiredH=urwid.Filler(urwid.Text(_('Wired Networks'))) - self.list_header=urwid.AttrWrap(urwid.Text(gen_list_header()),'listbar') - self.wlessH=NSelListBox([urwid.Text(_('Wireless Networks')),self.list_header]) + header = urwid.AttrWrap(urwid.Text(self.TITLE, align='right'), 'header') + self.wiredH = urwid.Filler(urwid.Text(_('Wired Networks'))) + self.list_header = urwid.AttrWrap( + urwid.Text(gen_list_header()), 'listbar' + ) + self.wlessH = NSelListBox([ + urwid.Text(_('Wireless Networks')), + self.list_header + ]) # Init this earlier to make update_status happy self.update_tag = None # FIXME: This should be two variables - self.focusloc = [1,0] + self.focusloc = [1, 0] # These are empty to make sure that things go my way. - wiredL,wlessL = [],[] + wiredL, wlessL = [], [] self.frame = None self.diag = None self.wiredCB = urwid.Filler(WiredComboBox(wiredL)) self.wlessLB = urwid.ListBox(wlessL) - self.update_netlist(force_check=True,firstrun=True) - + self.update_netlist(force_check=True, firstrun=True) + # Keymappings proposed by nanotube in #wicd keys = [ - ('H' ,_('Help'),None), - ('right',_('Config'),None), - #(' ',' ',None), - ('K' , _('RfKill'),None), - ('C' ,_('Connect'),None), - ('D' ,_('Disconn'),None), - ('R' ,_('Refresh'),None), - ('P' ,_('Prefs'),None), - ('I' ,_('Hidden'),None), - ('A' ,_('About'),None), - ('Q' ,_('Quit'),loop.quit) - ] + ('H', _('Help'), None), + ('right', _('Config'), None), + #(' ', ' ', None), + ('K', _('RfKill'), None), + ('C', _('Connect'), None), + ('D', _('Disconn'), None), + ('R', _('Refresh'), None), + ('P', _('Prefs'), None), + ('I', _('Hidden'), None), + ('A', _('About'), None), + ('Q', _('Quit'), loop.quit) + ] - self.primaryCols = OptCols(keys,self.handle_keys) - self.status_label = urwid.AttrWrap(urwid.Text(''),'important') + self.primaryCols = OptCols(keys, self.handle_keys) + self.status_label = urwid.AttrWrap(urwid.Text(''), 'important') self.footer2 = urwid.Columns([self.status_label]) - self.footerList = urwid.Pile([self.primaryCols,self.footer2]) + self.footerList = urwid.Pile([self.primaryCols, self.footer2]) self.frame = urwid.Frame(self.thePile, header=header, footer=self.footerList) - self.wiredCB.get_body().build_combobox(self.frame,ui,3) + self.wiredCB.get_body().build_combobox(self.frame, ui, 3) # Init the other columns used in the program self.init_other_optcols() self.frame.set_body(self.thePile) # Booleans gallore! - self.prev_state = False - self.connecting = False + self.prev_state = False + self.connecting = False self.screen_locked = False - self.do_diag_lock = False #Whether the screen is locked beneath a dialog - self.diag_type = 'none' # The type of dialog that is up + self.do_diag_lock = False # Whether the screen is locked beneath a dialog + self.diag_type = 'none' # The type of dialog that is up self.scanning = False self.pref = None @@ -642,20 +749,25 @@ class appGUI(): #self.max_wait = ui.max_wait def doScan(self, sync=False): + """ Start wireless scan. """ self.scanning = True wireless.Scan(False) def init_other_optcols(self): - # The "tabbed" preferences dialog - self.prefCols = OptCols( [ ('f10',_('OK')), - ('page up',_('Tab Left'),), - ('page down', _('Tab Right')), - ('esc',_('Cancel')) ], self.handle_keys) - self.confCols = OptCols( [ ('f10',_('OK')), - ('esc',_('Cancel')) ],self.handle_keys) + """ Init "tabbed" preferences dialog. """ + self.prefCols = OptCols([ + ('f10', _('OK')), + ('page up', _('Tab Left'), ), + ('page down', _('Tab Right')), + ('esc', _('Cancel')) + ], self.handle_keys) + self.confCols = OptCols([ + ('f10', _('OK')), + ('esc', _('Cancel')) + ], self.handle_keys) - # Does what it says it does def lock_screen(self): + """ Lock the screen. """ if self.diag_type == 'pref': self.do_diag_lock = True return True @@ -664,6 +776,7 @@ class appGUI(): self.update_ui() def unlock_screen(self): + """ Unlock the screen. """ if self.do_diag_lock: self.do_diag_lock = False return True @@ -674,35 +787,45 @@ class appGUI(): self.update_ui() def raise_hidden_network_dialog(self): - dialog = InputDialog(('header',_('Select Hidden Network ESSID')),7,30,_('Scan')) - exitcode,hidden = dialog.run(ui,self.frame) + """ Show hidden network dialog. """ + dialog = InputDialog( + ('header', _('Select Hidden Network ESSID')), + 7, 30, _('Scan') + ) + exitcode, hidden = dialog.run(ui, self.frame) if exitcode != -1: # That dialog will sit there for a while if I don't get rid of it self.update_ui() wireless.SetHiddenNetworkESSID(misc.noneToString(hidden)) wireless.Scan(False) wireless.SetHiddenNetworkESSID("") - + def update_focusloc(self): - # Location of last known focus is remapped to current location. + """ + Update focus location. + + Location of last known focus is remapped to current location. + """ # This might need to be cleaned up later. - if self.thePile.get_focus() == self.wiredCB: + if self.thePile.get_focus() == self.wiredCB: wlessorwired = self.WIRED_IDX where = self.thePile.get_focus().get_body().get_focus()[1] - else: #self.thePile.get_focus() == self.wlessLB : + else: # self.thePile.get_focus() == self.wlessLB : wlessorwired = self.WLESS_IDX if self.wlessLB == self.no_wlan: where = None - else: + else: where = self.thePile.get_focus().get_focus()[1] #where = self.wlessLB.get_focus()[1] - self.focusloc = [wlessorwired,where] - + self.focusloc = [wlessorwired, where] + # Be clunky until I get to a later stage of development. # Update the list of networks. Usually called by DBus. @wrap_exceptions - def update_netlist(self,state=None, x=None, force_check=False,firstrun=False): + def update_netlist(self, state=None, x=None, force_check=False, + firstrun=False): + """ Update the list of networks. """ # Don't even try to do this if we are running a dialog if self.diag: return @@ -711,14 +834,14 @@ class appGUI(): if not firstrun: self.update_focusloc() self.list_header.set_text(gen_list_header()) - """ Updates the overall network list.""" + # Updates the overall network list. if not state: - state, x = daemon.GetConnectionStatus() + state, trash = daemon.GetConnectionStatus() if force_check or self.prev_state != state: - wiredL,wlessL = gen_network_list() + wiredL, wlessL = gen_network_list() self.wiredCB.get_body().set_list(wiredL) - self.wiredCB.get_body().build_combobox(self.frame,ui,3) + self.wiredCB.get_body().build_combobox(self.frame, ui, 3) if len(wlessL) != 0: if self.wlessLB == self.no_wlan: self.wlessLB = urwid.ListBox(wlessL) @@ -727,26 +850,32 @@ class appGUI(): else: self.wlessLB = self.no_wlan if daemon.GetAlwaysShowWiredInterface() or wired.CheckPluggedIn(): - self.thePile = urwid.Pile([('fixed',1,self.wiredH), - ('fixed',1,self.wiredCB), - ('fixed',2,self.wlessH), - self.wlessLB] ) + self.thePile = urwid.Pile([ + ('fixed', 1, self.wiredH), + ('fixed', 1, self.wiredCB), + ('fixed', 2, self.wlessH), + self.wlessLB] + ) if not firstrun: self.frame.body = self.thePile self.thePile.set_focus(self.focusloc[0]) if self.focusloc[0] == self.WIRED_IDX: - self.thePile.get_focus().get_body().set_focus(self.focusloc[1]) + self.thePile.get_focus(). \ + get_body().set_focus(self.focusloc[1]) else: if self.wlessLB != self.no_wlan: self.thePile.get_focus().set_focus(self.focusloc[1]) else: self.thePile.set_focus(self.wiredCB) else: - self.thePile = urwid.Pile([('fixed',2,self.wlessH),self.wlessLB] ) + self.thePile = urwid.Pile([ + ('fixed', 2, self.wlessH), + self.wlessLB + ]) if not firstrun: self.frame.body = self.thePile - if self.focusloc[1] == None: + if self.focusloc[1] is None: self.focusloc[1] = 0 if self.wlessLB != self.no_wlan: self.wlessLB.set_focus(self.focusloc[1]) @@ -755,25 +884,28 @@ class appGUI(): if not firstrun: self.update_ui() if firstrun: - if wired.GetDefaultWiredNetwork() != None: - self.wiredCB.get_body().set_focus(wired.GetWiredProfileList().index(wired.GetDefaultWiredNetwork())) + if wired.GetDefaultWiredNetwork() is not None: + self.wiredCB.get_body().set_focus( + wired.GetWiredProfileList().index( + wired.GetDefaultWiredNetwork() + ) + ) - # Update the footer/status bar - conn_status = False @wrap_exceptions def update_status(self): + """ Update the footer / statusbar. """ wired_connecting = wired.CheckIfWiredConnecting() wireless_connecting = wireless.CheckIfWirelessConnecting() self.connecting = wired_connecting or wireless_connecting - + fast = not daemon.NeedsExternalCalls() - if self.connecting: + if self.connecting: if not self.conn_status: self.conn_status = True - gobject.timeout_add(250,self.set_connecting_status,fast) + gobject.timeout_add(250, self.set_connecting_status, fast) return True else: - if check_for_wired(wired.GetWiredIP(''),self.set_status): + if check_for_wired(wired.GetWiredIP(''), self.set_status): return True if not fast: iwconfig = wireless.GetIwconfig() @@ -787,7 +919,8 @@ class appGUI(): self.update_ui() return True - def set_connecting_status(self,fast): + def set_connecting_status(self, fast): + """ Set connecting status. """ wired_connecting = wired.CheckIfWiredConnecting() wireless_connecting = wireless.CheckIfWirelessConnecting() if wireless_connecting: @@ -802,35 +935,38 @@ class appGUI(): return self.set_status(_('Wired Network') + ': ' + wired.CheckWiredConnectingMessage(), True) else: - self.conn_status=False + self.conn_status = False return False - # Cheap little indicator stating that we are actually connecting - twirl = ['|','/','-','\\'] - tcount = 0 # Counter for said indicator - def set_status(self,text,from_idle=False): + def set_status(self, text, from_idle=False): + """ Set the status text. """ # Set the status text, usually called by the update_status method # from_idle : a check to see if we are being called directly from the # mainloop # If we are being called as the result of trying to connect to # something, and we aren't connecting to something, return False # immediately. + + # Cheap little indicator stating that we are actually connecting + twirl = ['|', '/', '-', '\\'] + if from_idle and not self.connecting: self.update_status() - self.conn_status=False + self.conn_status = False return False toAppend = '' # If we are connecting and being called from the idle function, spin # the wheel. if from_idle and self.connecting: # This is probably the wrong way to do this, but it works for now. - self.tcount+=1 - toAppend=self.twirl[self.tcount % 4] - self.status_label.set_text(text+' '+toAppend) + self.tcount += 1 + toAppend = twirl[self.tcount % 4] + self.status_label.set_text(text + ' ' + toAppend) self.update_ui() return True def dbus_scan_finished(self): + """ Handle DBus scan finish. """ # I'm pretty sure that I'll need this later. #if not self.connecting: # gobject.idle_add(self.refresh_networks, None, False, None) @@ -838,12 +974,14 @@ class appGUI(): self.scanning = False def dbus_scan_started(self): + """ Handle DBus scan start. """ self.scanning = True if self.diag_type == 'conf': self.restore_primary() self.lock_screen() def restore_primary(self): + """ Restore screen. """ self.diag_type = 'none' if self.do_diag_lock or self.scanning: self.frame.set_body(self.screen_locker) @@ -851,10 +989,11 @@ class appGUI(): else: self.frame.set_body(self.thePile) self.diag = None - self.frame.set_footer(urwid.Pile([self.primaryCols,self.footer2])) + self.frame.set_footer(urwid.Pile([self.primaryCols, self.footer2])) self.update_ui() - def handle_keys(self,keys): + def handle_keys(self, keys): + """ Handle keys. """ if not self.diag: # Handle keystrokes if "f8" in keys or 'Q' in keys or 'q' in keys: @@ -873,16 +1012,21 @@ class appGUI(): if 'right' in keys: if not self.scanning: focus = self.thePile.get_focus() - self.frame.set_footer(urwid.Pile([self.confCols,self.footer2])) + self.frame.set_footer( + urwid.Pile([self.confCols, self.footer2]) + ) if focus == self.wiredCB: - self.diag = WiredSettingsDialog(self.wiredCB.get_body().get_selected_profile(),self.frame) - self.diag.ready_widgets(ui,self.frame) + self.diag = WiredSettingsDialog( + self.wiredCB.get_body().get_selected_profile(), + self.frame + ) + self.diag.ready_widgets(ui, self.frame) self.frame.set_body(self.diag) else: # wireless list only other option - wid,pos = self.thePile.get_focus().get_focus() - self.diag = WirelessSettingsDialog(pos,self.frame) - self.diag.ready_widgets(ui,self.frame) + trash, pos = self.thePile.get_focus().get_focus() + self.diag = WirelessSettingsDialog(pos, self.frame) + self.diag.ready_widgets(ui, self.frame) self.frame.set_body(self.diag) self.diag_type = 'conf' if "enter" in keys or 'C' in keys: @@ -890,12 +1034,12 @@ class appGUI(): focus = self.frame.body.get_focus() if focus == self.wiredCB: self.special = focus - self.connect("wired",0) + self.connect("wired", 0) else: # wless list only other option, if it is around if self.wlessLB != self.no_wlan: - wid,pos = self.thePile.get_focus().get_focus() - self.connect("wireless",pos) + wid, pos = self.thePile.get_focus().get_focus() + self.connect("wireless", pos) if "esc" in keys: # Force disconnect here if connection in progress if self.connecting: @@ -904,11 +1048,15 @@ class appGUI(): daemon.SetForcedDisconnect(True) if "P" in keys: if not self.pref: - self.pref = PrefsDialog(self.frame,(0,1),ui, - dbusmanager.get_dbus_ifaces()) + self.pref = PrefsDialog( + self.frame, + (0, 1), + ui, + dbusmanager.get_dbus_ifaces() + ) self.pref.load_settings() - self.pref.ready_widgets(ui,self.frame) - self.frame.set_footer(urwid.Pile([self.prefCols,self.footer2])) + self.pref.ready_widgets(ui, self.frame) + self.frame.set_footer(urwid.Pile([self.prefCols, self.footer2])) self.diag = self.pref self.diag_type = 'pref' self.frame.set_body(self.diag) @@ -931,27 +1079,32 @@ class appGUI(): else: nettype = 'wireless' netname = str(self.wlessLB.get_focus()[1]) - run_configscript(self.frame,netname,nettype) + run_configscript(self.frame, netname, nettype) if "O" in keys: - exitcode,data = AdHocDialog().run(ui,self.frame) + exitcode, data = AdHocDialog().run(ui, self.frame) #data = (essid,ip,channel,use_ics,use_encrypt,key_edit) if exitcode == 1: - wireless.CreateAdHocNetwork(data[0], - data[2], - data[1], "WEP", - data[5], - data[4], False) + wireless.CreateAdHocNetwork( + data[0], + data[2], + data[1], + "WEP", + data[5], + data[4], + False + ) if 'X' in keys: exitcode, data = ForgetDialog().run(ui, self.frame) if exitcode == 1: - text = _('Are you sure you want to discard settings for ' + + text = _('Are you sure you want to discard settings for ' 'the selected networks?') text += '\n\n' + '\n'.join(data['essid']) - confirm, useless = TextDialog(text, 20, 50, + confirm, trash = TextDialog(text, 20, 50, buttons=[(_('OK'), 1), (_('Cancel'), -1)], ).run(ui, self.frame) if confirm == 1: - map(wireless.DeleteWirelessNetwork, data['bssid']) + for x in data['bssid']: + wireless.DeleteWirelessNetwork(x) for k in keys: if urwid.VERSION < (1, 0, 0): @@ -960,11 +1113,10 @@ class appGUI(): check_mouse_event = urwid.util.is_mouse_event if check_mouse_event(k): event, button, col, row = k - self.frame.mouse_event( self.size, - event, button, col, row, - focus=True) + self.frame.mouse_event( + self.size, event, button, col, row, focus=True) continue - k = self.frame.keypress(self.size,k) + k = self.frame.keypress(self.size, k) if self.diag: if k == 'esc' or k == 'q' or k == 'Q': self.restore_primary() @@ -977,13 +1129,15 @@ class appGUI(): self.size = ui.get_cols_rows() continue - def call_update_ui(self,source,cb_condition): - self.update_ui(True) - return True - + def call_update_ui(self, source, cb_condition): + """ Update UI. """ + self.update_ui(True) + return True + # Redraw the screen @wrap_exceptions - def update_ui(self,from_key=False): + def update_ui(self, from_key=False): + """ Redraw the screen. """ if not ui._started: return False @@ -992,10 +1146,10 @@ class appGUI(): self.handle_keys(input_data[1]) # Update the screen - canvas = self.frame.render( (self.size),True ) - ui.draw_screen((self.size),canvas) + canvas = self.frame.render((self.size), True) + ui.draw_screen((self.size), canvas) # Get the input data - if self.update_tag != None: + if self.update_tag is not None: gobject.source_remove(self.update_tag) #if from_key: return False @@ -1008,16 +1162,16 @@ class appGUI(): wired.ConnectWired() self.update_status() + ######################################## ##### INITIALIZATION FUNCTIONS ######################################## - def main(): + """ Main function. """ global ui, dlogger # We are not python. misc.RenameProcess('wicd-curses') - import urwid.raw_display ui = urwid.raw_display.Screen() #if options.debug: @@ -1031,34 +1185,37 @@ def main(): # Thanks to nanotube on #wicd for helping with this ui.register_palette([ - ('body','default','default'), - ('focus','black','light gray'), - ('header','light blue','default'), - ('important','light red','default'), - ('connected','dark green','default'), - ('connected focus','black','dark green'), + ('body', 'default', 'default'), + ('focus', 'black', 'light gray'), + ('header', 'light blue', 'default'), + ('important', 'light red', 'default'), + ('connected', 'dark green', 'default'), + ('connected focus', 'black', 'dark green'), ('editcp', 'default', 'default', 'standout'), ('editbx', 'light gray', 'dark blue'), - ('editfc', 'white','dark blue', 'bold'), - ('editnfc','brown','default','bold'), - ('tab active','dark green','light gray'), - ('infobar','light gray','dark blue'), - ('listbar','light blue','default'), + ('editfc', 'white', 'dark blue', 'bold'), + ('editnfc', 'brown', 'default', 'bold'), + ('tab active', 'dark green', 'light gray'), + ('infobar', 'light gray', 'dark blue'), + ('listbar', 'light blue', 'default'), # Simple colors around text - ('green','dark green','default'), - ('blue','light blue','default'), - ('red','dark red','default'), - ('bold','white','black','bold')]) + ('green', 'dark green', 'default'), + ('blue', 'light blue', 'default'), + ('red', 'dark red', 'default'), + ('bold', 'white', 'black', 'bold') + ]) # This is a wrapper around a function that calls another a function that # is a wrapper around a infinite loop. Fun. urwid.set_encoding('utf8') ui.run_wrapper(run) + @wrap_exceptions def run(): + """ Run the UI. """ global loop loop = gobject.MainLoop() - + ui.set_mouse_tracking() app = appGUI() @@ -1071,22 +1228,25 @@ def run(): bus.add_signal_receiver(app.update_netlist, 'StatusChanged', 'org.wicd.daemon') # Update the connection status on the bottom every 2 s. - gobject.timeout_add(2000,app.update_status) + gobject.timeout_add(2000, app.update_status) # Get input file descriptors and add callbacks to the ui-updating function fds = ui.get_input_descriptors() for fd in fds: - gobject.io_add_watch(fd, gobject.IO_IN,app.call_update_ui) + gobject.io_add_watch(fd, gobject.IO_IN, app.call_update_ui) app.update_ui() loop.run() + # Mostly borrowed from gui.py def setup_dbus(force=True): + """ Initialize DBus. """ global bus, daemon, wireless, wired try: dbusmanager.connect_to_dbus() except DBusException: - print >> sys.stderr, _("Can't connect to the daemon, trying to start it automatically...") + print >> sys.stderr, \ + _("Can't connect to the daemon, trying to start it automatically...") bus = dbusmanager.get_bus() dbus_ifaces = dbusmanager.get_dbus_ifaces() daemon = dbus_ifaces['daemon'] @@ -1094,7 +1254,8 @@ def setup_dbus(force=True): wired = dbus_ifaces['wired'] if not daemon: - print 'Error connecting to wicd via D-Bus. Please make sure the wicd service is running.' + print 'Error connecting to wicd via D-Bus. ' \ + 'Please make sure the wicd service is running.' sys.exit(3) netentry_curses.dbus_init(dbus_ifaces) @@ -1107,17 +1268,21 @@ setup_dbus() ######################################## if __name__ == '__main__': try: - parser = OptionParser(version="wicd-curses-%s (using wicd %s)" % (CURSES_REV,daemon.Hello()), prog="wicd-curses") + parser = OptionParser( + version="wicd-curses-%s (using wicd %s)" % + (CURSES_REV, daemon.Hello()), + prog="wicd-curses" + ) except Exception, e: if "DBus.Error.AccessDenied" in e.get_dbus_name(): - print _('ERROR: wicd-curses was denied access to the wicd daemon: '\ - 'please check that your user is in the "$A" group.').\ - replace('$A','\033[1;34m' + wpath.wicd_group + '\033[0m') + print _('ERROR: wicd-curses was denied access to the wicd daemon: ' + 'please check that your user is in the "$A" group.'). \ + replace('$A', '\033[1;34m' + wpath.wicd_group + '\033[0m') sys.exit(1) else: raise - #parser.add_option("-d", "--debug",action="store_true" - # ,dest='debug',help="enable logging of wicd-curses (currently does nothing)") + #parser.add_option("-d", "--debug", action="store_true", dest='debug', + # help="enable logging of wicd-curses (currently does nothing)") - (options,args) = parser.parse_args() + (options, args) = parser.parse_args() main() diff --git a/gtk/configscript.py b/gtk/configscript.py index 75e3d66..0cdccfd 100755 --- a/gtk/configscript.py +++ b/gtk/configscript.py @@ -47,10 +47,10 @@ wired_conf = wpath.etc + 'wired-settings.conf' def none_to_blank(text): """ Converts special string cases to a blank string. - + If text is None, 'None', or '' then this method will return '', otherwise it will just return str(text). - + """ if text in (None, "None", ""): return "" @@ -63,7 +63,7 @@ def blank_to_none(text): return "None" else: return str(text) - + def get_script_info(network, network_type): """ Read script info from disk and load it into the configuration dialog """ info = {} @@ -72,16 +72,20 @@ def get_script_info(network, network_type): if con.has_section(network): info["pre_entry"] = con.get(network, "beforescript", None) info["post_entry"] = con.get(network, "afterscript", None) - info["pre_disconnect_entry"] = con.get(network, "predisconnectscript", None) - info["post_disconnect_entry"] = con.get(network, "postdisconnectscript", None) + info["pre_disconnect_entry"] = con.get(network, + "predisconnectscript", None) + info["post_disconnect_entry"] = con.get(network, + "postdisconnectscript", None) else: bssid = wireless.GetWirelessProperty(int(network), "bssid") con = ConfigManager(wireless_conf) if con.has_section(bssid): info["pre_entry"] = con.get(bssid, "beforescript", None) info["post_entry"] = con.get(bssid, "afterscript", None) - info["pre_disconnect_entry"] = con.get(bssid, "predisconnectscript", None) - info["post_disconnect_entry"] = con.get(bssid, "postdisconnectscript", None) + info["pre_disconnect_entry"] = con.get(bssid, + "predisconnectscript", None) + info["post_disconnect_entry"] = con.get(bssid, + "postdisconnectscript", None) return info def write_scripts(network, network_type, script_info): @@ -90,8 +94,10 @@ def write_scripts(network, network_type, script_info): con = ConfigManager(wired_conf) con.set(network, "beforescript", script_info["pre_entry"]) con.set(network, "afterscript", script_info["post_entry"]) - con.set(network, "predisconnectscript", script_info["pre_disconnect_entry"]) - con.set(network, "postdisconnectscript", script_info["post_disconnect_entry"]) + con.set(network, "predisconnectscript", + script_info["pre_disconnect_entry"]) + con.set(network, "postdisconnectscript", + script_info["post_disconnect_entry"]) con.write() wired.ReloadConfig() wired.ReadWiredNetworkProfile(network) @@ -101,8 +107,10 @@ def write_scripts(network, network_type, script_info): con = ConfigManager(wireless_conf) con.set(bssid, "beforescript", script_info["pre_entry"]) con.set(bssid, "afterscript", script_info["post_entry"]) - con.set(bssid, "predisconnectscript", script_info["pre_disconnect_entry"]) - con.set(bssid, "postdisconnectscript", script_info["post_disconnect_entry"]) + con.set(bssid, "predisconnectscript", + script_info["pre_disconnect_entry"]) + con.set(bssid, "postdisconnectscript", + script_info["post_disconnect_entry"]) con.write() wireless.ReloadConfig() wireless.ReadWirelessNetworkProfile(int(network)) @@ -114,12 +122,12 @@ def main (argv): if len(argv) < 2: print 'Network id to configure is missing, aborting.' sys.exit(1) - + network = argv[1] network_type = argv[2] - + script_info = get_script_info(network, network_type) - + gladefile = os.path.join(wpath.gtk, "wicd.ui") wTree = gtk.Builder() wTree.set_translation_domain('wicd') @@ -127,33 +135,39 @@ def main (argv): dialog = wTree.get_object("configure_script_dialog") wTree.get_object("pre_label").set_label(_('Pre-connection Script') + ":") wTree.get_object("post_label").set_label(_('Post-connection Script') + ":") - wTree.get_object("pre_disconnect_label").set_label(_('Pre-disconnection Script') - + ":") - wTree.get_object("post_disconnect_label").set_label(_('Post-disconnection Script') - + ":") + wTree.get_object("pre_disconnect_label").\ + set_label(_('Pre-disconnection Script') + ":") + wTree.get_object("post_disconnect_label").\ + set_label(_('Post-disconnection Script') + ":") wTree.get_object("window1").hide() - + pre_entry = wTree.get_object("pre_entry") post_entry = wTree.get_object("post_entry") pre_disconnect_entry = wTree.get_object("pre_disconnect_entry") post_disconnect_entry = wTree.get_object("post_disconnect_entry") - + pre_entry.set_text(none_to_blank(script_info.get("pre_entry"))) post_entry.set_text(none_to_blank(script_info.get("post_entry"))) - pre_disconnect_entry.set_text(none_to_blank(script_info.get("pre_disconnect_entry"))) - post_disconnect_entry.set_text(none_to_blank(script_info.get("post_disconnect_entry"))) + pre_disconnect_entry.set_text( + none_to_blank(script_info.get("pre_disconnect_entry")) + ) + post_disconnect_entry.set_text( + none_to_blank(script_info.get("post_disconnect_entry")) + ) dialog.show_all() - + result = dialog.run() if result == 1: script_info["pre_entry"] = blank_to_none(pre_entry.get_text()) script_info["post_entry"] = blank_to_none(post_entry.get_text()) - script_info["pre_disconnect_entry"] = blank_to_none(pre_disconnect_entry.get_text()) - script_info["post_disconnect_entry"] = blank_to_none(post_disconnect_entry.get_text()) + script_info["pre_disconnect_entry"] = \ + blank_to_none(pre_disconnect_entry.get_text()) + script_info["post_disconnect_entry"] = \ + blank_to_none(post_disconnect_entry.get_text()) write_scripts(network, network_type, script_info) dialog.destroy() - + if __name__ == '__main__': if os.getuid() != 0: diff --git a/gtk/gui.py b/gtk/gui.py index aafd97e..39faa14 100644 --- a/gtk/gui.py +++ b/gtk/gui.py @@ -27,7 +27,6 @@ import os import sys import time import gobject -import pango import gtk from itertools import chain from dbus import DBusException @@ -49,22 +48,30 @@ if __name__ == '__main__': proxy_obj = daemon = wireless = wired = bus = None DBUS_AVAIL = False + def setup_dbus(force=True): + """ Initialize DBus. """ global bus, daemon, wireless, wired, DBUS_AVAIL try: dbusmanager.connect_to_dbus() except DBusException: if force: - print "Can't connect to the daemon, trying to start it automatically..." + print "Can't connect to the daemon, ' + \ + 'trying to start it automatically..." if not misc.PromptToStartDaemon(): - print "Failed to find a graphical sudo program, cannot continue." + print "Failed to find a graphical sudo program, ' + \ + 'cannot continue." return False try: dbusmanager.connect_to_dbus() except DBusException: - error(None, _("Could not connect to wicd's D-Bus interface. Check the wicd log for error messages.")) + error( + None, + _("Could not connect to wicd's D-Bus interface. " + "Check the wicd log for error messages.") + ) return False - else: + else: return False prefs.setup_dbus() netentry.setup_dbus() @@ -74,18 +81,26 @@ def setup_dbus(force=True): wireless = dbus_ifaces['wireless'] wired = dbus_ifaces['wired'] DBUS_AVAIL = True - + return True + def handle_no_dbus(from_tray=False): + """ Handle the case where no DBus is available. """ global DBUS_AVAIL DBUS_AVAIL = False - if from_tray: return False + if from_tray: + return False print "Wicd daemon is shutting down!" - error(None, _('The wicd daemon has shut down. The UI will not function properly until it is restarted.'), block=False) + error( + None, + _('The wicd daemon has shut down. The UI will not function ' + 'properly until it is restarted.'), + block=False + ) return False - + class WiredProfileChooser: """ Class for displaying the wired profile chooser. """ def __init__(self): @@ -94,14 +109,19 @@ class WiredProfileChooser: # functions and widgets it uses. wired_net_entry = WiredNetworkEntry() - dialog = gtk.Dialog(title = _('Wired connection detected'), - flags = gtk.DIALOG_MODAL, - buttons = (gtk.STOCK_CONNECT, 1, - gtk.STOCK_CANCEL, 2)) + dialog = gtk.Dialog( + title=_('Wired connection detected'), + flags=gtk.DIALOG_MODAL, + buttons=(gtk.STOCK_CONNECT, 1, gtk.STOCK_CANCEL, 2) + ) dialog.set_has_separator(False) dialog.set_size_request(400, 150) - instruct_label = gtk.Label(_('Select or create a wired profile to connect with') + ':\n') - stoppopcheckbox = gtk.CheckButton(_('Stop Showing Autoconnect pop-up temporarily')) + instruct_label = gtk.Label( + _('Select or create a wired profile to connect with') + ':\n' + ) + stoppopcheckbox = gtk.CheckButton( + _('Stop Showing Autoconnect pop-up temporarily') + ) wired_net_entry.is_full_gui = False instruct_label.set_alignment(0, 0) @@ -112,15 +132,19 @@ class WiredProfileChooser: wired_net_entry.vbox_top.remove(wired_net_entry.hbox_temp) wired_net_entry.vbox_top.remove(wired_net_entry.profile_help) + # pylint: disable-msg=E1101 dialog.vbox.pack_start(instruct_label, fill=False, expand=False) + # pylint: disable-msg=E1101 dialog.vbox.pack_start(wired_net_entry.profile_help, False, False) + # pylint: disable-msg=E1101 dialog.vbox.pack_start(wired_net_entry.hbox_temp, False, False) + # pylint: disable-msg=E1101 dialog.vbox.pack_start(stoppopcheckbox, False, False) dialog.show_all() wired_profiles = wired_net_entry.combo_profile_names wired_net_entry.profile_help.hide() - if wired_net_entry.profile_list != None: + if wired_net_entry.profile_list is not None: wired_profiles.set_active(0) print "wired profiles found" else: @@ -139,6 +163,7 @@ class WiredProfileChooser: def get_wireless_prop(net_id, prop): + """ Get wireless property. """ return wireless.GetWirelessProperty(net_id, prop) class appGui(object): @@ -170,18 +195,19 @@ class appGui(object): width = 530 self.window.resize(width, int(gtk.gdk.screen_height() / 1.7)) - dic = { "refresh_clicked" : self.refresh_clicked, - "quit_clicked" : self.exit, - "rfkill_clicked" : self.switch_rfkill, - "disconnect_clicked" : self.disconnect_all, - "main_exit" : self.exit, - "cancel_clicked" : self.cancel_connect, - "hidden_clicked" : self.connect_hidden, - "preferences_clicked" : self.settings_dialog, - "about_clicked" : self.about_dialog, - "create_adhoc_clicked" : self.create_adhoc_network, - "forget_network_clicked" : self.forget_network, - } + dic = { + "refresh_clicked": self.refresh_clicked, + "quit_clicked": self.exit, + "rfkill_clicked": self.switch_rfkill, + "disconnect_clicked": self.disconnect_all, + "main_exit": self.exit, + "cancel_clicked": self.cancel_connect, + "hidden_clicked": self.connect_hidden, + "preferences_clicked": self.settings_dialog, + "about_clicked": self.about_dialog, + "create_adhoc_clicked": self.create_adhoc_network, + "forget_network_clicked": self.forget_network, + } self.wTree.connect_signals(dic) # Set some strings in the GUI - they may be translated @@ -207,7 +233,9 @@ class appGui(object): self.status_area.hide_all() if os.path.exists(os.path.join(wpath.images, "wicd.png")): - self.window.set_icon_from_file(os.path.join(wpath.images, "wicd.png")) + self.window.set_icon_from_file( + os.path.join(wpath.images, "wicd.png") + ) self.statusID = None self.first_dialog_load = True self.is_visible = True @@ -236,32 +264,36 @@ class appGui(object): 'org.wicd.daemon') bus.add_signal_receiver(self.handle_connection_results, 'ConnectResultsSent', 'org.wicd.daemon') - bus.add_signal_receiver(lambda: setup_dbus(force=False), + bus.add_signal_receiver(lambda: setup_dbus(force=False), "DaemonStarting", "org.wicd.daemon") bus.add_signal_receiver(self._do_statusbar_update, 'StatusChanged', 'org.wicd.daemon') if standalone: - bus.add_signal_receiver(handle_no_dbus, "DaemonClosing", + bus.add_signal_receiver(handle_no_dbus, "DaemonClosing", "org.wicd.daemon") - + self._do_statusbar_update(*daemon.GetConnectionStatus()) self.wait_for_events(0.1) self.update_cb = misc.timeout_add(2, self.update_statusbar) self.refresh_clicked() - + def handle_connection_results(self, results): + """ Handle connection results. """ if results not in ['success', 'aborted'] and self.is_visible: error(self.window, language[results], block=False) def create_adhoc_network(self, widget=None): """ Shows a dialog that creates a new adhoc network. """ print "Starting the Ad-Hoc Network Creation Process..." - dialog = gtk.Dialog(title = _('Create an Ad-Hoc Network'), - flags = gtk.DIALOG_MODAL, - buttons=(gtk.STOCK_CANCEL, 2, gtk.STOCK_OK, 1)) + dialog = gtk.Dialog( + title=_('Create an Ad-Hoc Network'), + flags=gtk.DIALOG_MODAL, + buttons=(gtk.STOCK_CANCEL, 2, gtk.STOCK_OK, 1) + ) dialog.set_has_separator(False) dialog.set_size_request(400, -1) - self.chkbox_use_encryption = gtk.CheckButton(_('Use Encryption (WEP only)')) + self.chkbox_use_encryption = \ + gtk.CheckButton(_('Use Encryption (WEP only)')) self.chkbox_use_encryption.set_active(False) ip_entry = LabelEntry(_('IP') + ':') essid_entry = LabelEntry(_('ESSID') + ':') @@ -270,7 +302,8 @@ class appGui(object): self.key_entry.set_auto_hidden(True) self.key_entry.set_sensitive(False) - chkbox_use_ics = gtk.CheckButton( _('Activate Internet Connection Sharing')) + chkbox_use_ics = \ + gtk.CheckButton(_('Activate Internet Connection Sharing')) self.chkbox_use_encryption.connect("toggled", self.toggle_encrypt_check) @@ -283,22 +316,30 @@ class appGui(object): vbox_ah.pack_start(self.chkbox_use_encryption, False, False) vbox_ah.pack_start(self.key_entry, False, False) vbox_ah.show() + # pylint: disable-msg=E1101 dialog.vbox.pack_start(essid_entry) + # pylint: disable-msg=E1101 dialog.vbox.pack_start(ip_entry) + # pylint: disable-msg=E1101 dialog.vbox.pack_start(channel_entry) + # pylint: disable-msg=E1101 dialog.vbox.pack_start(chkbox_use_ics) + # pylint: disable-msg=E1101 dialog.vbox.pack_start(vbox_ah) + # pylint: disable-msg=E1101 dialog.vbox.set_spacing(5) dialog.show_all() response = dialog.run() if response == 1: - wireless.CreateAdHocNetwork(essid_entry.entry.get_text(), - channel_entry.entry.get_text(), - ip_entry.entry.get_text().strip(), - "WEP", - self.key_entry.entry.get_text(), - self.chkbox_use_encryption.get_active(), - False) #chkbox_use_ics.get_active()) + wireless.CreateAdHocNetwork( + essid_entry.entry.get_text(), + channel_entry.entry.get_text(), + ip_entry.entry.get_text().strip(), + "WEP", + self.key_entry.entry.get_text(), + self.chkbox_use_encryption.get_active(), + False # chkbox_use_ics.get_active()) + ) dialog.destroy() def forget_network(self, widget=None): @@ -307,9 +348,11 @@ class appGui(object): delete them. """ wireless.ReloadConfig() - dialog = gtk.Dialog(title = _('List of saved networks'), - flags = gtk.DIALOG_MODAL, - buttons=(gtk.STOCK_DELETE, 1, gtk.STOCK_OK, 2)) + dialog = gtk.Dialog( + title=_('List of saved networks'), + flags=gtk.DIALOG_MODAL, + buttons=(gtk.STOCK_DELETE, 1, gtk.STOCK_OK, 2) + ) dialog.set_has_separator(True) dialog.set_size_request(400, 200) @@ -324,16 +367,18 @@ class appGui(object): cell = gtk.CellRendererText() - column = gtk.TreeViewColumn(_('ESSID'), cell, text = 0) + column = gtk.TreeViewColumn(_('ESSID'), cell, text=0) tree.append_column(column) - column = gtk.TreeViewColumn(_('BSSID'), cell, text = 1) + column = gtk.TreeViewColumn(_('BSSID'), cell, text=1) tree.append_column(column) scroll = gtk.ScrolledWindow() scroll.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_AUTOMATIC) scroll.add(tree) + # pylint: disable-msg=E1101 dialog.vbox.pack_start(scroll) + # pylint: disable-msg=E1101 dialog.vbox.set_spacing(5) dialog.show_all() response = dialog.run() @@ -342,21 +387,24 @@ class appGui(object): to_remove = dict(essid=[], bssid=[]) if pathlist: for row in pathlist: - iter = model.get_iter(path=row) - to_remove['essid'].append(misc.noneToString(model.get_value(iter, 0))) - to_remove['bssid'].append(model.get_value(iter, 1)) + it = model.get_iter(path=row) + to_remove['essid'].append( + misc.noneToString(model.get_value(it, 0)) + ) + to_remove['bssid'].append(model.get_value(it, 1)) confirm = gtk.MessageDialog( - flags = gtk.DIALOG_MODAL, - type = gtk.MESSAGE_INFO, - buttons = gtk.BUTTONS_YES_NO, - message_format = _('Are you sure you want to discard' + - ' settings for the selected networks?') - ) + flags=gtk.DIALOG_MODAL, + type=gtk.MESSAGE_INFO, + buttons=gtk.BUTTONS_YES_NO, + message_format=_('Are you sure you want to discard' + + ' settings for the selected networks?') + ) confirm.format_secondary_text('\n'.join(to_remove['essid'])) response = confirm.run() if response == gtk.RESPONSE_YES: - map(wireless.DeleteWirelessNetwork, to_remove['bssid']) + for x in to_remove['bssid']: + wireless.DeleteWirelessNetwork(x) wireless.ReloadConfig() confirm.destroy() dialog.destroy() @@ -379,7 +427,7 @@ class appGui(object): """ Disconnects from any active network. """ def handler(*args): gobject.idle_add(self.all_network_list.set_sensitive, True) - + self.all_network_list.set_sensitive(False) daemon.Disconnect(reply_handler=handler, error_handler=handler) @@ -388,17 +436,22 @@ class appGui(object): dialog = gtk.AboutDialog() dialog.set_name("Wicd") dialog.set_version(daemon.Hello()) - dialog.set_authors([ "Adam Blackburn", "Dan O'Reilly", "Andrew Psaltis", "David Paleino"]) + dialog.set_authors([ + "Adam Blackburn", + "Dan O'Reilly", + "Andrew Psaltis", + "David Paleino" + ]) dialog.set_website("http://wicd.sourceforge.net") dialog.run() dialog.destroy() - - def key_event (self, widget, event=None): + + def key_event(self, widget, event=None): """ Handle key-release-events. """ if event.state & gtk.gdk.CONTROL_MASK and \ gtk.gdk.keyval_name(event.keyval) in ["w", "q"]: self.exit() - + def settings_dialog(self, widget, event=None): """ Displays a general settings dialog. """ if not self.pref: @@ -411,13 +464,17 @@ class appGui(object): def connect_hidden(self, widget): """ Prompts the user for a hidden network, then scans for it. """ - dialog = gtk.Dialog(title=('Hidden Network'), - flags=gtk.DIALOG_MODAL, - buttons=(gtk.STOCK_CONNECT, 1, gtk.STOCK_CANCEL, 2)) + dialog = gtk.Dialog( + title=('Hidden Network'), + flags=gtk.DIALOG_MODAL, + buttons=(gtk.STOCK_CONNECT, 1, gtk.STOCK_CANCEL, 2) + ) dialog.set_has_separator(False) lbl = gtk.Label(_('Hidden Network ESSID')) textbox = gtk.Entry() + # pylint: disable-msg=E1101 dialog.vbox.pack_start(lbl) + # pylint: disable-msg=E1101 dialog.vbox.pack_start(textbox) dialog.show_all() button = dialog.run() @@ -454,18 +511,19 @@ class appGui(object): """ Triggers a status update in wicd-monitor. """ if not self.is_visible: return True - + daemon.UpdateState() if self.connecting: # If we're connecting, don't wait for the monitor to send # us a signal, since it won't until the connection is made. self._do_statusbar_update(*daemon.GetConnectionStatus()) return True - + def _do_statusbar_update(self, state, info): + """ Actually perform the statusbar update. """ if not self.is_visible: return True - + if state == misc.WIRED: return self.set_wired_state(info) elif state == misc.WIRELESS: @@ -475,15 +533,19 @@ class appGui(object): elif state in (misc.SUSPENDED, misc.NOT_CONNECTED): return self.set_not_connected_state(info) return True - + def set_wired_state(self, info): + """ Set wired state. """ if self.connecting: # Adjust our state from connecting->connected. self._set_not_connecting_state() - self.set_status(_('Connected to wired network (IP: $A)').replace('$A', info[0])) + self.set_status( + _('Connected to wired network (IP: $A)').replace('$A', info[0]) + ) return True - + def set_wireless_state(self, info): + """ Set wireless state. """ if self.connecting: # Adjust our state from connecting->connected. self._set_not_connecting_state() @@ -492,15 +554,17 @@ class appGui(object): ('$B', daemon.FormatSignalForPrinting(info[2])).replace ('$C', info[0])) return True - + def set_not_connected_state(self, info): + """ Set not connected state. """ if self.connecting: # Adjust our state from connecting->not-connected. self._set_not_connecting_state() self.set_status(_('Not connected')) return True - + def _set_not_connecting_state(self): + """ Set not-connecting state. """ if self.connecting: if self.update_cb: gobject.source_remove(self.update_cb) @@ -512,12 +576,13 @@ class appGui(object): gobject.idle_add(self.status_area.hide_all) if self.statusID: gobject.idle_add(self.status_bar.remove_message, 1, self.statusID) - + def set_connecting_state(self, info): + """ Set connecting state. """ if not self.connecting: if self.update_cb: gobject.source_remove(self.update_cb) - self.update_cb = misc.timeout_add(500, self.update_statusbar, + self.update_cb = misc.timeout_add(500, self.update_statusbar, milli=True) self.connecting = True if not self.pulse_active: @@ -531,56 +596,60 @@ class appGui(object): stat = wireless.CheckWirelessConnectingMessage() gobject.idle_add(self.set_status, "%s: %s" % (info[1], stat)) elif info[0] == "wired": - gobject.idle_add(self.set_status, _('Wired Network') + ': ' \ + gobject.idle_add(self.set_status, _('Wired Network') + ': ' + wired.CheckWiredConnectingMessage()) return True - + def update_connect_buttons(self, state=None, x=None, force_check=False): """ Updates the connect/disconnect buttons for each network entry. If force_check is given, update the buttons even if the current network state is the same as the previous. - + """ - if not DBUS_AVAIL: return + if not DBUS_AVAIL: + return if not state: state, x = daemon.GetConnectionStatus() - + if self.prev_state != state or force_check: apbssid = wireless.GetApBssid() for entry in chain(self.network_list, self.wired_network_box): if hasattr(entry, "update_connect_button"): entry.update_connect_button(state, apbssid) self.prev_state = state - + def set_status(self, msg): """ Sets the status bar message for the GUI. """ self.statusID = self.status_bar.push(1, msg) - + def dbus_scan_finished(self): """ Calls for a non-fresh update of the gui window. - + This method is called after a wireless scan is completed. - + """ - if not DBUS_AVAIL: return + if not DBUS_AVAIL: + return gobject.idle_add(self.refresh_networks, None, False, None) - + def dbus_scan_started(self): """ Called when a wireless scan starts. """ - if not DBUS_AVAIL: return + if not DBUS_AVAIL: + return self.network_list.set_sensitive(False) def _remove_items_from_vbox(self, vbox): + """ Remove items fro a VBox. """ for z in vbox: vbox.remove(z) z.destroy() del z - def refresh_clicked(self, widget=None): """ Kick off an asynchronous wireless scan. """ - if not DBUS_AVAIL or self.connecting: return + if not DBUS_AVAIL or self.connecting: + return self.refreshing = True # Remove stuff already in there. @@ -598,7 +667,7 @@ class appGui(object): wirednet.disconnect_button.connect("clicked", self.disconnect, "wired", 0, wirednet) wirednet.advanced_button.connect("clicked", - self.edit_advanced, "wired", 0, + self.edit_advanced, "wired", 0, wirednet) state, x = daemon.GetConnectionStatus() wirednet.update_connect_button(state) @@ -611,13 +680,13 @@ class appGui(object): def refresh_networks(self, widget=None, fresh=True, hidden=None): """ Refreshes the network list. - + If fresh=True, scans for wireless networks and displays the results. If a ethernet connection is available, or the user has chosen to, displays a Wired Network entry as well. If hidden isn't None, will scan for networks after running iwconfig essid . - + """ if fresh: if hidden: @@ -637,7 +706,9 @@ class appGui(object): skip_never_connect = not daemon.GetShowNeverConnect() instruct_label.show() for x in xrange(0, num_networks): - if skip_never_connect and misc.to_bool(get_wireless_prop(x,'never')): continue + if skip_never_connect and \ + misc.to_bool(get_wireless_prop(x, 'never')): + continue if printLine: sep = gtk.HSeparator() self.network_list.pack_start(sep, padding=10, fill=False, @@ -673,17 +744,17 @@ class appGui(object): entry = networkentry.advanced_dialog opt_entlist = [] req_entlist = [] - + # First make sure all the Addresses entered are valid. if entry.chkbox_static_ip.get_active(): req_entlist = [entry.txt_ip, entry.txt_netmask] opt_entlist = [entry.txt_gateway] - + if entry.chkbox_static_dns.get_active() and \ not entry.chkbox_global_dns.get_active(): for ent in [entry.txt_dns_1, entry.txt_dns_2, entry.txt_dns_3]: opt_entlist.append(ent) - + # Required entries. for lblent in req_entlist: lblent.set_text(lblent.get_text().strip()) @@ -691,7 +762,7 @@ class appGui(object): error(self.window, _('Invalid address in $A entry.'). replace('$A', lblent.label.get_label())) return False - + # Optional entries, only check for validity if they're entered. for lblent in opt_entlist: lblent.set_text(lblent.get_text().strip()) @@ -708,17 +779,17 @@ class appGui(object): elif nettype == "wired": if not networkentry.save_wired_settings(): return False - + return True def edit_advanced(self, widget, ttype, networkid, networkentry): """ Display the advanced settings dialog. - + Displays the advanced settings dialog and saves any changes made. If errors occur in the settings, an error message will be displayed and the user won't be able to save the changes until the errors are fixed. - + """ dialog = networkentry.advanced_dialog dialog.set_values() @@ -727,13 +798,13 @@ class appGui(object): if self.run_settings_dialog(dialog, ttype, networkid, networkentry): break dialog.hide() - + def run_settings_dialog(self, dialog, nettype, networkid, networkentry): """ Runs the settings dialog. - + Runs the settings dialog and returns True if settings are saved successfully, and false otherwise. - + """ result = dialog.run() if result == gtk.RESPONSE_ACCEPT: @@ -742,7 +813,7 @@ class appGui(object): else: return False return True - + def check_encryption_valid(self, networkid, entry): """ Make sure that encryption settings are properly filled in. """ # Make sure no entries are left blank @@ -751,18 +822,25 @@ class appGui(object): for entry_info in encryption_info.itervalues(): if entry_info[0].entry.get_text() == "" and \ entry_info[1] == 'required': - error(self.window, "%s (%s)" % (_('Required encryption information is missing.'), - entry_info[0].label.get_label()) - ) + error( + self.window, + "%s (%s)" % + (_('Required encryption information is missing.'), + entry_info[0].label.get_label()) + ) return False # Make sure the checkbox is checked when it should be elif not entry.chkbox_encryption.get_active() and \ wireless.GetWirelessProperty(networkid, "encryption"): - error(self.window, _('This network requires encryption to be enabled.')) + error( + self.window, + _('This network requires encryption to be enabled.') + ) return False return True def _wait_for_connect_thread_start(self): + """ Wait for the connect thread to start. """ self.wTree.get_object("progressbar").pulse() if not self._connect_thread_started: return True @@ -770,19 +848,22 @@ class appGui(object): misc.timeout_add(2, self.update_statusbar) self.update_statusbar() return False - + def connect(self, widget, nettype, networkid, networkentry): """ Initiates the connection process in the daemon. """ def handler(*args): self._connect_thread_started = True def setup_interface_for_connection(): + """ Initialize interface for connection. """ cancel_button = self.wTree.get_object("cancel_button") cancel_button.set_sensitive(True) self.all_network_list.set_sensitive(False) if self.statusID: - gobject.idle_add(self.status_bar.remove_message, 1, self.statusID) - gobject.idle_add(self.set_status, _('Disconnecting active connections...')) + gobject.idle_add( + self.status_bar.remove_message, 1, self.statusID) + gobject.idle_add( + self.set_status, _('Disconnecting active connections...')) gobject.idle_add(self.status_area.show_all) self.wait_for_events() self._connect_thread_started = False @@ -798,25 +879,25 @@ class appGui(object): elif nettype == "wired": setup_interface_for_connection() wired.ConnectWired(reply_handler=handler, error_handler=handler) - + gobject.source_remove(self.update_cb) misc.timeout_add(100, self._wait_for_connect_thread_start, milli=True) - + def disconnect(self, widget, nettype, networkid, networkentry): """ Disconnects from the given network. - + Keyword arguments: widget -- The disconnect button that was pressed. event -- unused nettype -- "wired" or "wireless", depending on the network entry type. networkid -- unused networkentry -- The NetworkEntry containing the disconnect button. - + """ def handler(*args): gobject.idle_add(self.all_network_list.set_sensitive, True) gobject.idle_add(self.network_list.set_sensitive, True) - + widget.hide() networkentry.connect_button.show() daemon.SetForcedDisconnect(True) @@ -824,16 +905,16 @@ class appGui(object): if nettype == "wired": wired.DisconnectWired(reply_handler=handler, error_handler=handler) else: - wireless.DisconnectWireless(reply_handler=handler, + wireless.DisconnectWireless(reply_handler=handler, error_handler=handler) - + def wait_for_events(self, amt=0): - """ Wait for any pending gtk events to finish before moving on. + """ Wait for any pending gtk events to finish before moving on. Keyword arguments: amt -- a number specifying the number of ms to wait before checking for pending events. - + """ time.sleep(amt) while gtk.events_pending(): @@ -843,7 +924,7 @@ class appGui(object): """ Hide the wicd GUI. This method hides the wicd GUI and writes the current window size - to disc for later use. This method normally does NOT actually + to disc for later use. This method normally does NOT actually destroy the GUI, it just hides it. """ @@ -864,11 +945,11 @@ class appGui(object): return True def show_win(self): - """ Brings the GUI out of the hidden state. - + """ Brings the GUI out of the hidden state. + Method to show the wicd GUI, alert the daemon that it is open, and refresh the network list. - + """ self.window.present() self.window.deiconify() diff --git a/gtk/guiutil.py b/gtk/guiutil.py index 2a97538..797792a 100644 --- a/gtk/guiutil.py +++ b/gtk/guiutil.py @@ -30,22 +30,27 @@ try: except ImportError: print "Importing pynotify failed, notifications disabled." HAS_NOTIFY = False - + print "Has notifications support", HAS_NOTIFY if wpath.no_use_notifications: print 'Notifications disabled during setup.py configure' - + + def can_use_notify(): + """ Check whether WICD is allowed to use notifications. """ use_notify = os.path.exists(os.path.join(os.path.expanduser('~/.wicd'), 'USE_NOTIFICATIONS') ) return use_notify and HAS_NOTIFY and not wpath.no_use_notifications - -def error(parent, message, block=True): + + +def error(parent, message, block=True): """ Shows an error dialog. """ - def delete_event(dialog, id): + def delete_event(dialog, i): + """ Handle dialog destroy. """ dialog.destroy() + if can_use_notify() and not block: notification = pynotify.Notification("ERROR", message, "error") notification.show() @@ -59,11 +64,14 @@ def error(parent, message, block=True): else: dialog.run() dialog.destroy() - -def alert(parent, message, block=True): + + +def alert(parent, message, block=True): """ Shows an warning dialog. """ - def delete_event(dialog, id): + def delete_event(dialog, i): + """ Handle dialog destroy. """ dialog.destroy() + dialog = gtk.MessageDialog(parent, gtk.DIALOG_MODAL, gtk.MESSAGE_WARNING, gtk.BUTTONS_OK) dialog.set_markup(message) @@ -74,11 +82,14 @@ def alert(parent, message, block=True): dialog.run() dialog.destroy() + def string_input(prompt, secondary, textbox_label): + """ Dialog with a label and an entry. """ # based on a version of a PyGTK text entry from # http://ardoris.wordpress.com/2008/07/05/pygtk-text-entry-dialog/ def dialog_response(entry, dialog, response): + """ Handle dialog response. """ dialog.response(response) dialog = gtk.MessageDialog( @@ -103,6 +114,7 @@ def string_input(prompt, secondary, textbox_label): hbox.pack_start(entry) # pack the boxes and show the dialog + # pylint: disable-msg=E1101 dialog.vbox.pack_end(hbox, True, True, 0) dialog.show_all() @@ -114,19 +126,24 @@ def string_input(prompt, secondary, textbox_label): dialog.destroy() return None + class SmallLabel(gtk.Label): + """ Small GtkLabel. """ def __init__(self, text=''): gtk.Label.__init__(self, text) self.set_size_request(50, -1) - + + class LeftAlignedLabel(gtk.Label): + """GtkLabel with text aligned to left. """ def __init__(self, label=None): gtk.Label.__init__(self, label) self.set_alignment(0.0, 0.5) + class LabelEntry(gtk.HBox): """ A label on the left with a textbox on the right. """ - def __init__(self,text): + def __init__(self, text): gtk.HBox.__init__(self) self.entry = gtk.Entry() self.entry.set_size_request(200, -1) @@ -143,27 +160,31 @@ class LabelEntry(gtk.HBox): self.show() def set_text(self, text): + """ Set text of the GtkEntry. """ # For compatibility... self.entry.set_text(text) def get_text(self): + """ Get text of the GtkEntry. """ return self.entry.get_text() def set_auto_hidden(self, value): + """ Set auto-hide of the text of GtkEntry. """ self.entry.set_visibility(False) self.auto_hide_text = value def show_characters(self, widget=None, event=None): - # When the box has focus, show the characters + """ When the box has focus, show the characters. """ if self.auto_hide_text and widget: self.entry.set_visibility(True) def set_sensitive(self, value): + """ Set sensitivity of the widget. """ self.entry.set_sensitive(value) self.label.set_sensitive(value) def hide_characters(self, widget=None, event=None): - # When the box looses focus, hide them + """ When the box looses focus, hide them. """ if self.auto_hide_text and widget: self.entry.set_visibility(False) @@ -202,24 +223,30 @@ class ProtectedLabelEntry(gtk.HBox): self.show() def set_entry_text(self, text): + """ Set text of the GtkEntry. """ # For compatibility... self.entry.set_text(text) def get_entry_text(self): + """ Get text of the GtkEntry. """ return self.entry.get_text() def set_sensitive(self, value): + """ Set sensitivity of the widget. """ self.entry.set_sensitive(value) self.label.set_sensitive(value) self.check.set_sensitive(value) def click_handler(self, widget=None, event=None): + """ Handle clicks. """ active = self.check.get_active() self.entry.set_visibility(active) + class LabelCombo(gtk.HBox): """ A label on the left with a combobox on the right. """ - def __init__(self,text): + + def __init__(self, text): gtk.HBox.__init__(self) self.combo = gtk.ComboBox() self.combo.set_size_request(200, -1) @@ -236,20 +263,26 @@ class LabelCombo(gtk.HBox): self.show() def get_active(self): + """ Return the selected item in the GtkComboBox. """ return self.combo.get_active() def set_active(self, index): + """ Set given item in the GtkComboBox. """ self.combo.set_active(index) def get_active_text(self): + """ Return the selected item's text in the GtkComboBox. """ return self.combo.get_active_text() def get_model(self): + """ Return the GtkComboBox's model. """ return self.combo.get_model() def set_model(self, model=None): + """ Set the GtkComboBox's model. """ self.combo.set_model(model) def set_sensitive(self, value): + """ Set sensitivity of the widget. """ self.combo.set_sensitive(value) self.label.set_sensitive(value) diff --git a/gtk/netentry.py b/gtk/netentry.py index 183a3e6..0d7d43c 100644 --- a/gtk/netentry.py +++ b/gtk/netentry.py @@ -31,7 +31,8 @@ import wicd.misc as misc import wicd.wpath as wpath import wicd.dbusmanager as dbusmanager from wicd.misc import noneToString, stringToNone, noneToBlankString, to_bool -from guiutil import error, LabelEntry, GreyLabel, LeftAlignedLabel, string_input, ProtectedLabelEntry, LabelCombo +from guiutil import error, LabelEntry, GreyLabel, LeftAlignedLabel +from guiutil import string_input, ProtectedLabelEntry, LabelCombo from wicd.translations import language, _ @@ -39,20 +40,24 @@ from wicd.translations import language, _ daemon = None wired = None wireless = None - + + def setup_dbus(): + """ Initialize DBus. """ global daemon, wireless, wired daemon = dbusmanager.get_interface('daemon') wireless = dbusmanager.get_interface('wireless') wired = dbusmanager.get_interface('wired') - + + class AdvancedSettingsDialog(gtk.Dialog): + """ Advanced settings dialog. """ def __init__(self, network_name=None): """ 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. - + """ # if no network name was passed, just use Properties as the title if network_name: @@ -60,11 +65,17 @@ class AdvancedSettingsDialog(gtk.Dialog): else: title = _('Properties') - gtk.Dialog.__init__(self, title=title, - flags=gtk.DIALOG_MODAL, buttons=(gtk.STOCK_CANCEL, - gtk.RESPONSE_REJECT, - gtk.STOCK_OK, - gtk.RESPONSE_ACCEPT)) + gtk.Dialog.__init__( + self, + title=title, + flags=gtk.DIALOG_MODAL, + buttons=( + gtk.STOCK_CANCEL, + gtk.RESPONSE_REJECT, + gtk.STOCK_OK, + gtk.RESPONSE_ACCEPT + ) + ) self.set_default_size() @@ -83,7 +94,8 @@ class AdvancedSettingsDialog(gtk.Dialog): dhcp_hostname_hbox = gtk.HBox(False, 0) self.chkbox_use_dhcp_hostname = gtk.CheckButton() self.txt_dhcp_hostname = LabelEntry("DHCP Hostname") - dhcp_hostname_hbox.pack_start(self.chkbox_use_dhcp_hostname, fill=False, expand=False) + dhcp_hostname_hbox.pack_start( + self.chkbox_use_dhcp_hostname, fill=False, expand=False) dhcp_hostname_hbox.pack_start(self.txt_dhcp_hostname) self.chkbox_static_ip = gtk.CheckButton(_('Use Static IPs')) self.chkbox_static_dns = gtk.CheckButton(_('Use Static DNS')) @@ -91,7 +103,7 @@ class AdvancedSettingsDialog(gtk.Dialog): 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() @@ -100,9 +112,10 @@ class AdvancedSettingsDialog(gtk.Dialog): #self.script_button.set_alignment(.5, .5) self.script_button.set_image(script_image) self.script_button.set_label(_('Scripts')) - + self.button_hbox = gtk.HBox(False, 2) - self.button_hbox.pack_start(self.script_button, fill=False, expand=False) + self.button_hbox.pack_start( + self.script_button, fill=False, expand=False) self.button_hbox.show() self.swindow = gtk.ScrolledWindow() @@ -112,8 +125,9 @@ class AdvancedSettingsDialog(gtk.Dialog): self.cvbox = gtk.VBox() self.viewport.add(self.cvbox) self.swindow.add(self.viewport) + # pylint: disable-msg=E1101 self.vbox.pack_start(self.swindow) - + assert(isinstance(self.cvbox, gtk.VBox)) self.cvbox.pack_start(self.chkbox_static_ip, fill=False, expand=False) self.cvbox.pack_start(self.txt_ip, fill=False, expand=False) @@ -126,21 +140,25 @@ class AdvancedSettingsDialog(gtk.Dialog): self.cvbox.pack_start(self.txt_dns_2, fill=False, expand=False) self.cvbox.pack_start(self.txt_dns_3, fill=False, expand=False) self.cvbox.pack_start(dhcp_hostname_hbox, fill=False, expand=False) - self.cvbox.pack_end(self.button_hbox, fill=False, expand=False, padding=5) - + self.cvbox.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) - self.chkbox_use_dhcp_hostname.connect('toggled', - self.toggle_dhcp_hostname_checkbox) - + self.chkbox_global_dns.connect( + "toggled", self.toggle_global_dns_checkbox) + self.chkbox_use_dhcp_hostname.connect( + 'toggled', + self.toggle_dhcp_hostname_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_default_size(self): + """ Set default window size. """ width, height = self.get_size() s_height = gtk.gdk.screen_height() if s_height < 768: @@ -148,7 +166,7 @@ class AdvancedSettingsDialog(gtk.Dialog): else: height = 600 self.resize(int(width), int(height)) - + def set_defaults(self, widget=None, event=None): """ Put some default values into entries to help the user out. """ self.txt_ip.set_text(self.txt_ip.get_text().strip()) @@ -158,17 +176,20 @@ class AdvancedSettingsDialog(gtk.Dialog): if misc.IsValidIP(ip): # Only do these things if it's IPv4 if misc.IsValidIPv4(ip): - if stringToNone(gateway.get_text()) is None: # Make sure the gateway box is blank + # Make sure the gateway box is blank + if stringToNone(gateway.get_text()) is None: # Fill it in with a .1 at the end gateway.set_text(ip[:ip.rindex('.')] + '.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 + # Make sure the netmask is blank + if stringToNone(netmask.get_text()) is None: + # Fill in the most common one + netmask.set_text('255.255.255.0') elif ip != '': error(None, _('Invalid IP address entered.')) def reset_static_checkboxes(self): - # Enable the right stuff + """ 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) @@ -211,7 +232,7 @@ class AdvancedSettingsDialog(gtk.Dialog): 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(): @@ -224,6 +245,7 @@ class AdvancedSettingsDialog(gtk.Dialog): self.chkbox_global_dns.set_active(False) def toggle_dhcp_hostname_checkbox(self, widget=None): + """ Set widget sensitivity. """ self.txt_dhcp_hostname.set_sensitive( self.chkbox_use_dhcp_hostname.get_active()) @@ -231,31 +253,36 @@ class AdvancedSettingsDialog(gtk.Dialog): """ 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, _('Global DNS has not been enabled in general preferences.')) + error( + None, + _('Global DNS has not been enabled in general preferences.') + ) 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, + 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 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 destroy_called(self, *args): """ Clean up everything. """ super(AdvancedSettingsDialog, self).destroy() self.destroy() del self - def save_settings(self): + def save_settings(self, networkid=None): """ 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())) + 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", '') @@ -265,8 +292,10 @@ class AdvancedSettingsDialog(gtk.Dialog): 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( + '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())) @@ -284,7 +313,8 @@ class AdvancedSettingsDialog(gtk.Dialog): self.set_net_prop("dns3", '') self.set_net_prop('usedhcphostname', self.chkbox_use_dhcp_hostname.get_active()) - self.set_net_prop("dhcphostname",noneToString(self.txt_dhcp_hostname.get_text())) + self.set_net_prop( + "dhcphostname",noneToString(self.txt_dhcp_hostname.get_text())) def change_encrypt_method(self, widget=None): """ Load all the entries for a given encryption method. """ @@ -293,7 +323,7 @@ class AdvancedSettingsDialog(gtk.Dialog): 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) @@ -303,9 +333,9 @@ class AdvancedSettingsDialog(gtk.Dialog): fields = methods[ID][type_] for field in fields: try: - field_text = language[field[1].lower().replace(' ','_')] + field_text = language[field[1].lower().replace(' ', '_')] except KeyError: - field_text = field[1].replace(' ','_') + field_text = field[1].replace(' ', '_') if field in methods[ID]['protected']: box = ProtectedLabelEntry(field_text) @@ -317,7 +347,7 @@ class AdvancedSettingsDialog(gtk.Dialog): # can be easily accessed by giving the name of the wanted # data. self.encryption_info[field[0]] = [box, type_] - + if self.wired: box.entry.set_text(noneToBlankString( wired.GetWiredProperty(field[0]))) @@ -326,25 +356,29 @@ class AdvancedSettingsDialog(gtk.Dialog): wireless.GetWirelessProperty(self.networkID, field[0]))) self.vbox_encrypt_info.show_all() - + class WiredSettingsDialog(AdvancedSettingsDialog): + """ Wired settings dialog. """ def __init__(self, name): """ Build the wired settings dialog. """ AdvancedSettingsDialog.__init__(self, _('Wired Network')) - - # So we can test if we are wired or wireless (for change_encrypt_method()) + + # So we can test if we are wired or wireless (for + # change_encrypt_method()) self.wired = True - - ## This section is largely copied from WirelessSettingsDialog, but with some changes + + ## This section is largely copied from WirelessSettingsDialog, but with + ## some changes # Set up encryption stuff self.combo_encryption = gtk.combo_box_new_text() self.chkbox_encryption = gtk.CheckButton(_('Use Encryption')) # Make the vbox to hold the encryption stuff. self.vbox_encrypt_info = gtk.VBox(False, 0) - self.chkbox_encryption.set_active(bool(wired.GetWiredProperty('encryption_enabled'))) + self.chkbox_encryption.set_active( + bool(wired.GetWiredProperty('encryption_enabled'))) self.combo_encryption.set_sensitive(False) - self.encrypt_types = misc.LoadEncryptionMethods(wired = True) - + self.encrypt_types = misc.LoadEncryptionMethods(wired=True) + # Build the encryption menu for x, enc_type in enumerate(self.encrypt_types): self.combo_encryption.append_text(enc_type['name']) @@ -355,36 +389,41 @@ class WiredSettingsDialog(AdvancedSettingsDialog): self.cvbox.pack_start(self.chkbox_encryption, False, False) self.cvbox.pack_start(self.combo_encryption, False, False) self.cvbox.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.des = self.connect("destroy", self.destroy_called) self.script_button.connect("clicked", 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.gtk, "configscript.py"), profile, "wired"] if os.getuid() != 0: - cmdbase = misc.get_sudo_cmd(_('You must enter your password to configure scripts'), - prog_num=daemon.GetSudoApp()) + cmdbase = misc.get_sudo_cmd( + _('You must enter your password to configure scripts'), + prog_num=daemon.GetSudoApp() + ) if not cmdbase: - error(None, _('Could not find a graphical sudo program. '\ - 'The script editor could not be launched. '\ - "You'll have to edit scripts directly your configuration file.")) + error(None, + _('Could not find a graphical sudo program. ' + 'The script editor could not be launched. ' + "You'll have to edit scripts directly your configuration " + "file.") + ) 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")) @@ -396,7 +435,8 @@ class WiredSettingsDialog(AdvancedSettingsDialog): 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.chkbox_global_dns.set_active( + bool(wired.GetWiredProperty("use_global_dns"))) dhcphname = wired.GetWiredProperty("dhcphostname") if dhcphname is None: @@ -404,37 +444,43 @@ class WiredSettingsDialog(AdvancedSettingsDialog): self.txt_dhcp_hostname.set_text(dhcphname) self.reset_static_checkboxes() - - self.chkbox_encryption.set_active(bool(wired.GetWiredProperty('encryption_enabled'))) + + self.chkbox_encryption.set_active( + bool(wired.GetWiredProperty('encryption_enabled'))) self.change_encrypt_method() self.toggle_encryption() - - def save_settings(self): + + def save_settings(self, networkid=None): + """ Save settings to disk. """ # Check encryption info encrypt_info = self.encryption_info - self.set_net_prop("encryption_enabled", self.chkbox_encryption.get_active()) + self.set_net_prop( + "encryption_enabled", + self.chkbox_encryption.get_active() + ) if self.chkbox_encryption.get_active(): print "setting encryption info..." encrypt_methods = self.encrypt_types - self.set_net_prop("enctype", - encrypt_methods[self.combo_encryption.get_active()]['type']) + 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)" % (_('Required encryption information is missing.'), - entry_info[0].label.get_label()) - ) + error( + self, + "%s (%s)" % ( + _('Required encryption information is 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, + self.set_net_prop(entry_key, noneToString(entry_info[0].entry.get_text())) - elif not wired and not self.chkbox_encryption.get_active() and \ - wireless.GetWirelessProperty(networkid, "encryption"): - # Encrypt checkbox is off, but the network needs it. - error(self, _('This network requires encryption to be enabled.')) - return False else: print "no encryption specified..." self.set_net_prop("enctype", "None") @@ -445,7 +491,7 @@ class WiredSettingsDialog(AdvancedSettingsDialog): 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) @@ -453,19 +499,23 @@ class WiredSettingsDialog(AdvancedSettingsDialog): self.destroy() del self - + class WirelessSettingsDialog(AdvancedSettingsDialog): + """ Wireless settings dialog. """ def __init__(self, networkID): """ Build the wireless settings dialog. """ - AdvancedSettingsDialog.__init__(self, wireless.GetWirelessProperty(networkID, 'essid')) - # So we can test if we are wired or wireless (for change_encrypt_method()) + AdvancedSettingsDialog.__init__( + self, wireless.GetWirelessProperty(networkID, 'essid')) + # So we can test if we are wired or wireless (for + # change_encrypt_method()) self.wired = False - + # Set up encryption stuff self.networkID = networkID self.combo_encryption = gtk.combo_box_new_text() self.chkbox_encryption = gtk.CheckButton(_('Use Encryption')) - self.chkbox_global_settings = gtk.CheckButton(_('Use these settings for all networks sharing this essid')) + self.chkbox_global_settings = gtk.CheckButton( + _('Use these settings for all networks sharing this essid')) rate_vbox = gtk.VBox(False, 0) @@ -481,22 +531,26 @@ class WirelessSettingsDialog(AdvancedSettingsDialog): rate_vbox.pack_start(self.chkbox_lower_rate) # Make the vbox to hold the encryption stuff. - self.vbox_encrypt_info = gtk.VBox(False, 0) + 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, self)) + information_button.connect( + 'clicked', + lambda *a, **k: WirelessInformationDialog(networkID, self) + ) 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"): + if enc_type['type'] == \ + wireless.GetWirelessProperty(networkID, "enctype"): activeID = x self.combo_encryption.set_active(activeID) if activeID != -1: @@ -512,7 +566,7 @@ class WirelessSettingsDialog(AdvancedSettingsDialog): self.cvbox.pack_start(self.chkbox_encryption, False, False) self.cvbox.pack_start(self.combo_encryption, False, False) self.cvbox.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) @@ -525,57 +579,67 @@ class WirelessSettingsDialog(AdvancedSettingsDialog): 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.gtk, "configscript.py"), str(self.networkID), "wireless"] if os.getuid() != 0: - cmdbase = misc.get_sudo_cmd(_('You must enter your password to configure scripts'), - prog_num=daemon.GetSudoApp()) + cmdbase = misc.get_sudo_cmd( + _('You must enter your password to configure scripts'), + prog_num=daemon.GetSudoApp() + ) if not cmdbase: - error(None, _('Could not find a graphical sudo program. '\ - 'The script editor could not be launched. '\ - "You'll have to edit scripts directly your configuration file.")) + error( + None, + _('Could not find a graphical sudo program. ' + 'The script editor could not be launched. ' + "You'll have to edit scripts directly your " + "configuration file.") + ) 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.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.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.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'))) + self.chkbox_encryption.set_active( + bool(wireless.GetWirelessProperty(networkID, 'encryption'))) + self.chkbox_global_settings.set_active( + bool( + wireless.GetWirelessProperty(networkID, 'use_settings_globally') + ) + ) self.chkbox_use_dhcp_hostname.set_active( bool(wireless.GetWirelessProperty(networkID, 'usedhcphostname'))) - dhcphname = wireless.GetWirelessProperty(networkID,"dhcphostname") + dhcphname = wireless.GetWirelessProperty(networkID, "dhcphostname") if dhcphname is None: dhcphname = os.uname()[1] self.txt_dhcp_hostname.set_text(dhcphname) @@ -587,15 +651,18 @@ class WirelessSettingsDialog(AdvancedSettingsDialog): if chosen_bitrate not in self.bitrates: chosen_bitrate = 'auto' self.combo_rate.set_active(self.bitrates.index(chosen_bitrate)) - self.chkbox_lower_rate.set_active(bool(wireless.GetWirelessProperty(networkID, - 'allow_lower_bitrates'))) + self.chkbox_lower_rate.set_active( + bool( + wireless.GetWirelessProperty(networkID, 'allow_lower_bitrates') + ) + ) 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) @@ -604,26 +671,32 @@ class WirelessSettingsDialog(AdvancedSettingsDialog): else: self.combo_encryption.set_active(0) self.change_encrypt_method() - - def save_settings(self, networkid): + + def save_settings(self, networkid=None): # Check encryption info encrypt_info = self.encryption_info if self.chkbox_encryption.get_active(): print "setting encryption info..." encrypt_methods = self.encrypt_types - self.set_net_prop("enctype", - encrypt_methods[self.combo_encryption.get_active()]['type']) + 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)" % (_('Required encryption information is missing.'), - entry_info[0].label.get_label()) - ) + error( + self, + "%s (%s)" % ( + _('Required encryption information is 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, + 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"): @@ -634,7 +707,7 @@ class WirelessSettingsDialog(AdvancedSettingsDialog): print "no encryption specified..." self.set_net_prop("enctype", "None") AdvancedSettingsDialog.save_settings(self) - + if self.chkbox_global_settings.get_active(): self.set_net_prop('use_settings_globally', True) else: @@ -644,23 +717,30 @@ class WirelessSettingsDialog(AdvancedSettingsDialog): if self.combo_rate.get_active() == -1: self.set_net_prop('bitrate', 'auto') else: - self.set_net_prop('bitrate', self.bitrates[self.combo_rate.get_active()]) - self.set_net_prop('allow_lower_bitrates', bool(self.chkbox_lower_rate.get_active())) + self.set_net_prop( + 'bitrate', + self.bitrates[self.combo_rate.get_active()] + ) + self.set_net_prop( + 'allow_lower_bitrates', + bool(self.chkbox_lower_rate.get_active()) + ) wireless.SaveWirelessNetworkProfile(networkid) return True def format_entry(self, networkid, label): """ Helper method for fetching/formatting wireless properties. """ return noneToBlankString(wireless.GetWirelessProperty(networkid, label)) - - + + class NetworkEntry(gtk.HBox): + """ Network entry. """ 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) @@ -669,13 +749,13 @@ class NetworkEntry(gtk.HBox): # 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) @@ -683,12 +763,12 @@ class NetworkEntry(gtk.HBox): # 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() @@ -697,7 +777,7 @@ class NetworkEntry(gtk.HBox): self.advanced_button.set_alignment(.5, .5) self.advanced_button.set_label(_('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) @@ -705,15 +785,16 @@ class NetworkEntry(gtk.HBox): 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): + """ Wired network entry. """ def __init__(self): """ Load the wired network entry. """ NetworkEntry.__init__(self) @@ -727,15 +808,20 @@ class WiredNetworkEntry(NetworkEntry): self.name_label.set_use_markup(True) self.name_label.set_label("" + _('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(_('To connect to a wired network, you must create a network profile. To create a network profile, type a name that describes this network, and press Add.')) - self.chkbox_default_profile = gtk.CheckButton(_('Use as default profile (overwrites any previous default)')) - self.combo_profile_names = gtk.combo_box_new_text() - + self.profile_help = gtk.Label( + _('To connect to a wired network, you must create a network ' + 'profile. To create a network profile, type a name that describes ' + 'this network, and press Add.') + ) + self.chkbox_default_profile = gtk.CheckButton( + _('Use as default profile (overwrites any previous default)')) + 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) @@ -757,7 +843,7 @@ class WiredNetworkEntry(NetworkEntry): 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() @@ -771,13 +857,14 @@ class WiredNetworkEntry(NetworkEntry): else: print "no wired profiles found" self.profile_help.show() - - self.advanced_dialog = WiredSettingsDialog(self.combo_profile_names.get_active_text()) + + 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) @@ -786,7 +873,7 @@ class WiredNetworkEntry(NetworkEntry): self.check_enable() self.wireddis = self.connect("destroy", self.destroy_called) - + def destroy_called(self, *args): """ Clean up everything. """ self.disconnect(self.wireddis) @@ -795,7 +882,7 @@ class WiredNetworkEntry(NetworkEntry): super(WiredNetworkEntry, self).destroy_called() self.destroy() del self - + def save_wired_settings(self): """ Save wired network settings. """ return self.advanced_dialog.save_settings() @@ -807,7 +894,7 @@ class WiredNetworkEntry(NetworkEntry): 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: @@ -816,14 +903,15 @@ class WiredNetworkEntry(NetworkEntry): else: self.disconnect_button.hide() self.connect_button.show() - + def add_profile(self, widget): """ Add a profile to the profile list. """ - 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:").strip() + 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:" + ).strip() # if response is "" or None if not response: @@ -854,7 +942,8 @@ class WiredNetworkEntry(NetworkEntry): 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() + 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 @@ -873,7 +962,8 @@ class WiredNetworkEntry(NetworkEntry): wired.UnsetWiredDefault() wired.SetWiredProperty("default", self.chkbox_default_profile.get_active()) - wired.SaveWiredNetworkProfile(self.combo_profile_names.get_active_text()) + wired.SaveWiredNetworkProfile( + self.combo_profile_names.get_active_text()) def change_profile(self, widget): """ Called when a new profile is chosen from the list. """ @@ -881,14 +971,14 @@ class WiredNetworkEntry(NetworkEntry): 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)) @@ -898,6 +988,7 @@ class WiredNetworkEntry(NetworkEntry): class WirelessNetworkEntry(NetworkEntry): + """ Wireless network entry. """ def __init__(self, networkID): """ Build the wireless network entry. """ NetworkEntry.__init__(self) @@ -907,32 +998,36 @@ class WirelessNetworkEntry(NetworkEntry): self.image.set_alignment(.5, .5) self.image.set_size_request(60, -1) self.image.show() - self.essid = noneToBlankString(wireless.GetWirelessProperty(networkID, - "essid")) + 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(_('Automatically connect to this network')) - self.chkbox_neverconnect = gtk.CheckButton(_('Never connect to this network')) - - 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.chkbox_autoconnect = gtk.CheckButton( + _('Automatically connect to this network')) + self.chkbox_neverconnect = gtk.CheckButton( + _('Never connect to this network')) + + 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(), - ) - ) + 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) @@ -942,7 +1037,7 @@ class WirelessNetworkEntry(NetworkEntry): self.chkbox_autoconnect.set_active(True) else: self.chkbox_autoconnect.set_active(False) - + if to_bool(self.format_entry(networkID, "never")): self.chkbox_autoconnect.set_sensitive(False) self.connect_button.set_sensitive(False) @@ -953,7 +1048,7 @@ class WirelessNetworkEntry(NetworkEntry): # Connect signals. self.chkbox_autoconnect.connect("toggled", self.update_autoconnect) self.chkbox_neverconnect.connect("toggled", self.update_neverconnect) - + # Show everything self.show_all() self.advanced_dialog = WirelessSettingsDialog(networkID) @@ -961,24 +1056,32 @@ class WirelessNetworkEntry(NetworkEntry): def _escape(self, val): """ Escapes special characters so they're displayed correctly. """ - return val.replace("&", "&").replace("<", "<").\ - replace(">",">").replace("'", "'").replace('"', """) - + 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.SetWirelessProperty( + self.networkID, + "automatic", + noneToString(self.chkbox_autoconnect. get_active()) + ) wireless.SaveWirelessNetworkProperty(self.networkID, "automatic") def update_neverconnect(self, widget=None): """ Called when the neverconnect checkbox is toggled. """ - wireless.SetWirelessProperty(self.networkID, "never", - noneToString(self.chkbox_neverconnect.get_active())) + wireless.SetWirelessProperty( + self.networkID, + "never", + noneToString(self.chkbox_neverconnect.get_active()) + ) wireless.SaveWirelessNetworkProperty(self.networkID, "never") if self.chkbox_neverconnect.get_active(): self.chkbox_autoconnect.set_sensitive(False) @@ -995,7 +1098,7 @@ class WirelessNetworkEntry(NetworkEntry): 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 to_bool(self.format_entry(self.networkID, "never")): @@ -1009,7 +1112,7 @@ class WirelessNetworkEntry(NetworkEntry): 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: @@ -1051,16 +1154,16 @@ class WirelessNetworkEntry(NetworkEntry): 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: + if on and not ttype: self.lbl_encryption.set_label(_('Secured')) if not on: self.lbl_encryption.set_label(_('Unsecured')) - + def set_channel(self, channel): """ Set the channel value for the WirelessNetworkEntry. """ self.lbl_channel.set_label(_('Channel') + ' ' + str(channel)) @@ -1069,11 +1172,12 @@ class WirelessNetworkEntry(NetworkEntry): """ Helper method for fetching/formatting wireless properties. """ return noneToBlankString(wireless.GetWirelessProperty(networkid, label)) - + class WirelessInformationDialog(gtk.Dialog): + """ Wireless information dialog. """ def __init__(self, networkID, parent): - gtk.Dialog.__init__(self,parent=parent) - + gtk.Dialog.__init__(self, parent=parent) + # Make the combo box. self.lbl_strength = gtk.Label() self.lbl_strength.set_alignment(0, 0.5) @@ -1086,27 +1190,28 @@ class WirelessInformationDialog(gtk.Dialog): 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_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_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) + table.set_col_spacings(12) + # pylint: disable-msg=E1101 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) @@ -1123,13 +1228,14 @@ class WirelessInformationDialog(gtk.Dialog): table.attach(LeftAlignedLabel('Channel:'), 0, 1, 4, 5) table.attach(self.lbl_channel, 1, 2, 4, 5) + # pylint: disable-msg=E1101 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: @@ -1178,7 +1284,7 @@ class WirelessInformationDialog(gtk.Dialog): """ Set the encryption value for the WirelessNetworkEntry. """ if on and ttype: self.lbl_encryption.set_label(str(ttype)) - if on and not ttype: + if on and not ttype: self.lbl_encryption.set_label(_('Secured')) if not on: self.lbl_encryption.set_label(_('Unsecured')) diff --git a/gtk/prefs.py b/gtk/prefs.py index c1e1257..bbd2ee1 100644 --- a/gtk/prefs.py +++ b/gtk/prefs.py @@ -26,7 +26,6 @@ handles recieving/sendings the settings from/to the daemon. import gtk import gobject -#import pango import os from wicd import misc @@ -39,25 +38,75 @@ daemon = None wireless = None wired = None -from wicd.translations import language - USER_SETTINGS_DIR = os.path.expanduser('~/.wicd/') + def setup_dbus(): + """ Initialize 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.ethtoolradio = None + self.miitoolradio = None + + self.wpadrivercombo = None + self.wpadrivers = None + self.backends = None + self.backendcombo = None + self.be_descriptions = None + self.preferwiredcheckbox = None + self.useGlobalDNSCheckbox = None + self.displaytypecheckbox = None + self.verifyapcheckbox = None + self.debugmodecheckbox = None + self.wiredcheckbox = None + self.showneverconnectcheckbox = None + self.reconnectcheckbox = None + self.notificationscheckbox = None + + self.usedefaultradiobutton = None + self.lastusedradiobutton = None + self.showlistradiobutton = None + + self.kdesuradio = None + self.gksudoradio = None + self.sudoautoradio = None + self.ktsussradio = None + + self.dhclientradio = None + self.dhcpautoradio = None + self.pumpradio = None + self.udhcpcradio = None + self.dhcpcdradio = None + + self.linkautoradio = None + self.routeflushradio = None + self.ipflushradio = None + self.flushautoradio = None + + self.dialog = None + self.entryWiredInterface = None + self.entryWirelessInterface = None + + self.dns1Entry = None + self.dns2Entry = None + self.dns3Entry = None + self.searchDomEntry = None + self.dnsDomEntry = None + 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. @@ -71,10 +120,10 @@ class PreferencesDialog(object): # 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()) @@ -82,28 +131,30 @@ class PreferencesDialog(object): self.verifyapcheckbox.set_active(daemon.GetShouldVerifyAp()) self.preferwiredcheckbox.set_active(daemon.GetPreferWiredNetwork()) self.showneverconnectcheckbox.set_active(daemon.GetShowNeverConnect()) - - dhcp_list = [self.dhcpautoradio, self.dhclientradio, self.dhcpcdradio, + + dhcp_list = [self.dhcpautoradio, self.dhclientradio, self.dhcpcdradio, self.pumpradio, self.udhcpcradio] - self._setup_external_app_radios(dhcp_list, daemon.GetDHCPClient, - daemon.SetDHCPClient) - + 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) + 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) - + 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) - + 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) @@ -111,7 +162,7 @@ class PreferencesDialog(object): 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()) @@ -121,10 +172,14 @@ class PreferencesDialog(object): except ValueError: self.wpadrivercombo.set_active(0) - self.useGlobalDNSCheckbox.connect("toggled", checkboxTextboxToggle, - (self.dns1Entry, self.dns2Entry, - self.dns3Entry, self.dnsDomEntry, - self.searchDomEntry)) + 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()) @@ -140,7 +195,7 @@ class PreferencesDialog(object): 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)) @@ -164,24 +219,25 @@ class PreferencesDialog(object): self.notificationscheckbox.set_active(False) self.notificationscheckbox.hide() self.wTree.get_object('label2').hide() - + self.wTree.get_object("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): + """ Destroy dialog. """ 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()) @@ -189,9 +245,13 @@ class PreferencesDialog(object): 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.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()]) @@ -200,8 +260,10 @@ class PreferencesDialog(object): 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())) - daemon.SetShowNeverConnect(bool(self.showneverconnectcheckbox.get_active())) + daemon.SetPreferWiredNetwork( + bool(self.preferwiredcheckbox.get_active())) + daemon.SetShowNeverConnect( + bool(self.showneverconnectcheckbox.get_active())) if self.showlistradiobutton.get_active(): daemon.SetWiredAutoConnectMethod(2) elif self.lastusedradiobutton.get_active(): @@ -210,7 +272,7 @@ class PreferencesDialog(object): daemon.SetWiredAutoConnectMethod(1) daemon.SetBackend(self.backends[self.backendcombo.get_active()]) - + # External Programs Tab if self.dhcpautoradio.get_active(): dhcp_client = misc.AUTO @@ -223,7 +285,7 @@ class PreferencesDialog(object): else: dhcp_client = misc.UDHCPC daemon.SetDHCPClient(dhcp_client) - + if self.linkautoradio.get_active(): link_tool = misc.AUTO elif self.ethtoolradio.get_active(): @@ -231,7 +293,7 @@ class PreferencesDialog(object): else: link_tool = misc.MIITOOL daemon.SetLinkDetectionTool(link_tool) - + if self.flushautoradio.get_active(): flush_tool = misc.AUTO elif self.ipflushradio.get_active(): @@ -239,7 +301,7 @@ class PreferencesDialog(object): else: flush_tool = misc.ROUTE daemon.SetFlushTool(flush_tool) - + if self.sudoautoradio.get_active(): sudo_tool = misc.AUTO elif self.gksudoradio.get_active(): @@ -251,7 +313,7 @@ class PreferencesDialog(object): daemon.SetSudoApp(sudo_tool) [width, height] = self.dialog.get_size() - + not_path = os.path.join(USER_SETTINGS_DIR, 'USE_NOTIFICATIONS') if self.notificationscheckbox.get_active(): if not os.path.exists(not_path): @@ -268,7 +330,7 @@ class PreferencesDialog(object): def set_label(self, glade_str, label): """ Sets the label for the given widget in wicd.glade. """ self.wTree.get_object(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): @@ -281,7 +343,7 @@ class PreferencesDialog(object): 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_object(name) @@ -290,7 +352,7 @@ class PreferencesDialog(object): if widget is None: raise ValueError('widget %s does not exist' % name) return widget - + # External Programs tab # self.wTree.get_object("gen_settings_label").set_label(_('General Settings')) # self.wTree.get_object("ext_prog_label").set_label(_('External Programs')) @@ -298,14 +360,14 @@ class PreferencesDialog(object): # self.wTree.get_object("wired_detect_label").set_label(_('Wired Link Detection')) # self.wTree.get_object("route_flush_label").set_label(_('Route Table Flushing')) # self.wTree.get_object("pref_backend_label").set_label(_('Backend') + ":") - + # entryWiredAutoMethod = self.wTree.get_object("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 1" % _('DNS server')) # self.set_label("pref_dns2_label", "%s 2" % _('DNS server')) # self.set_label("pref_dns3_label", "%s 3" % _('DNS server')) @@ -313,62 +375,82 @@ class PreferencesDialog(object): # self.set_label("pref_wifi_label", "%s:" % _('Wireless Interface')) # self.set_label("pref_wired_label", "%s:" % _('Wired Interface')) # self.set_label("pref_driver_label", "%s:" % _('WPA Supplicant Driver')) - + self.dialog = self.wTree.get_object("pref_dialog") self.dialog.set_title(_('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")) + self.dialog.set_icon_from_file( + os.path.join(wpath.images, "wicd.png")) 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", _('''Always show wired interface''')) + + self.wiredcheckbox = setup_label( + "pref_always_check", + _('''Always show wired interface''') + ) self.preferwiredcheckbox = setup_label("pref_prefer_wired_check", "prefer_wired") self.reconnectcheckbox = setup_label("pref_auto_check", _('Automatically reconnect on connection loss')) - self.showneverconnectcheckbox = setup_label("pref_show_never_connect_check", - _('Show never connect networks')) + self.showneverconnectcheckbox = setup_label( + "pref_show_never_connect_check", + _('Show never connect networks') + ) self.debugmodecheckbox = setup_label("pref_debug_check", _('Enable debug mode')) - self.displaytypecheckbox = setup_label("pref_dbm_check", - _('Use dBm to measure signal strength')) - self.verifyapcheckbox = setup_label("pref_verify_ap_check", - _('Ping static gateways after connecting to verify association')) - self.usedefaultradiobutton = setup_label("pref_use_def_radio", - _('Use default profile on wired autoconnect')) - self.showlistradiobutton = setup_label("pref_prompt_radio", - _('Prompt for profile on wired autoconnect')) - self.lastusedradiobutton = setup_label("pref_use_last_radio", - _('Use last used profile on wired autoconnect')) + self.displaytypecheckbox = setup_label( + "pref_dbm_check", + _('Use dBm to measure signal strength') + ) + self.verifyapcheckbox = setup_label( + "pref_verify_ap_check", + _('Ping static gateways after connecting to verify association') + ) + self.usedefaultradiobutton = setup_label( + "pref_use_def_radio", + _('Use default profile on wired autoconnect') + ) + self.showlistradiobutton = setup_label( + "pref_prompt_radio", + _('Prompt for profile on wired autoconnect') + ) + self.lastusedradiobutton = setup_label( + "pref_use_last_radio", + _('Use last used profile on wired autoconnect') + ) - - self.notificationscheckbox = setup_label("pref_use_libnotify", - _('Display notifications about connection status')) + self.notificationscheckbox = setup_label( + "pref_use_libnotify", + _('Display notifications about connection status') + ) # DHCP Clients - self.dhcpautoradio = setup_label("dhcp_auto_radio", _('Automatic (recommended)')) + self.dhcpautoradio = setup_label( + "dhcp_auto_radio", _('Automatic (recommended)')) self.dhclientradio = self.wTree.get_object("dhclient_radio") self.pumpradio = self.wTree.get_object("pump_radio") self.dhcpcdradio = self.wTree.get_object("dhcpcd_radio") self.udhcpcradio = self.wTree.get_object("udhcpc_radio") - + # Wired Link Detection Apps - self.linkautoradio = setup_label("link_auto_radio", _('Automatic (recommended)')) + self.linkautoradio = setup_label( + "link_auto_radio", _('Automatic (recommended)')) 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", _('Automatic (recommended)')) self.ipflushradio = setup_label("ip_flush_radio") self.routeflushradio = setup_label("route_flush_radio") - + # Graphical Sudo Apps - self.sudoautoradio = setup_label("sudo_auto_radio", _('Automatic (recommended)')) + self.sudoautoradio = setup_label( + "sudo_auto_radio", _('Automatic (recommended)')) self.gksudoradio = setup_label("gksudo_radio") self.kdesuradio = setup_label("kdesu_radio") self.ktsussradio = setup_label("ktsuss_radio") @@ -384,7 +466,7 @@ class PreferencesDialog(object): self.entryWirelessInterface = self.wTree.get_object("pref_wifi_entry") self.entryWiredInterface = self.wTree.get_object("pref_wired_entry") - + # Set up global DNS stuff self.useGlobalDNSCheckbox = setup_label("pref_global_check", 'use_global_dns') @@ -393,19 +475,19 @@ class PreferencesDialog(object): self.dns1Entry = self.wTree.get_object("pref_dns1_entry") self.dns2Entry = self.wTree.get_object("pref_dns2_entry") self.dns3Entry = self.wTree.get_object("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: if x == 'ioctl': x = 'ioctl NOT SUPPORTED' self.backendcombo.append_text(x) - + def be_combo_changed(self, combo): """ Update the description label for the given backend. """ self.backendcombo.set_tooltip_text( diff --git a/gtk/wicd-client.py b/gtk/wicd-client.py index f5909db..20cdaed 100644 --- a/gtk/wicd-client.py +++ b/gtk/wicd-client.py @@ -3,7 +3,7 @@ """ wicd - wireless connection daemon frontend implementation This module implements a usermode frontend for wicd. It updates connection -information, provides an (optional) tray icon, and allows for launching of +information, provides an (optional) tray icon, and allows for launching of the wicd GUI and Wired Profile Chooser. class TrayIcon() -- Parent class of TrayIconGUI and IconConnectionInfo. @@ -11,7 +11,7 @@ class TrayIcon() -- Parent class of TrayIconGUI and IconConnectionInfo. and updates connection status. class TrayIconGUI() -- Child class of TrayIcon which implements the tray. icon itself. Parent class of StatusTrayIconGUI and EggTrayIconGUI. - class StatusTrayIconGUI() -- Implements the tray icon using a + class StatusTrayIconGUI() -- Implements the tray icon using a gtk.StatusIcon. class EggTrayIconGUI() -- Implements the tray icon using egg.trayicon. def usage() -- Prints usage information. @@ -42,7 +42,6 @@ import gobject import getopt import os import pango -import time import atexit from dbus import DBusException @@ -74,27 +73,37 @@ if not hasattr(gtk, "StatusIcon"): import egg.trayicon USE_EGG = True except ImportError: - print 'Unable to load tray icon: Missing both egg.trayicon and gtk.StatusIcon modules.' + print 'Unable to load tray icon: Missing both egg.trayicon and ' + \ + 'gtk.StatusIcon modules.' ICON_AVAIL = False misc.RenameProcess("wicd-client") if __name__ == '__main__': wpath.chdir(__file__) - + daemon = wireless = wired = lost_dbus_id = None DBUS_AVAIL = False theme = gtk.icon_theme_get_default() theme.append_search_path(wpath.images) + def catchdbus(func): + """ Decorator to catch DBus exceptions. """ def wrapper(*args, **kwargs): try: return func(*args, **kwargs) except DBusException, e: - if e.get_dbus_name() != None and "DBus.Error.AccessDenied" in e.get_dbus_name(): - error(None, _('Unable to contact the Wicd daemon due to an access denied error from DBus. Please check that your user is in the $A group.').replace("$A",""+wpath.wicd_group+"")) + if e.get_dbus_name() is not None and \ + "DBus.Error.AccessDenied" in e.get_dbus_name(): + error( + None, + _('Unable to contact the Wicd daemon due to an access ' + 'denied error from DBus. Please check that your user is ' + 'in the $A group.'). + replace("$A", "" + wpath.wicd_group + "") + ) #raise raise DBusException(e) else: @@ -105,9 +114,10 @@ def catchdbus(func): wrapper.__dict__ = func.__dict__ wrapper.__doc__ = func.__doc__ return wrapper - + class NetworkMenuItem(gtk.ImageMenuItem): + """ Network menu item. """ def __init__(self, lbl, is_active=False): gtk.ImageMenuItem.__init__(self) self.label = gtk.Label(lbl) @@ -119,13 +129,13 @@ class NetworkMenuItem(gtk.ImageMenuItem): self.label.set_alignment(0, 0) self.add(self.label) self.label.show() - + class TrayIcon(object): """ Base Tray Icon class. - + Base Class for implementing a tray icon to display network status. - + """ def __init__(self, animate, displaytray=True, displayapp=False): self.cur_sndbytes = -1 @@ -145,13 +155,13 @@ class TrayIcon(object): self.tr.icon_info = self.icon_info print 'displaytray %s' % displaytray self.tr.visible(displaytray) - + def is_embedded(self): if USE_EGG: raise NotImplementedError() else: - return self.tr.is_embedded() - + return self.tr.is_embedded() # pylint: disable-msg=E1103 + def get_bandwidth_bytes(self): """ Gets the amount of byte sent sine the last time I checked """ dev_dir = '/sys/class/net/' @@ -161,13 +171,15 @@ class TrayIcon(object): if fldr == iface: dev_dir = dev_dir + fldr + "/statistics/" break - + try: - self.cur_rcvbytes = int(open(dev_dir + "rx_bytes", "r").read().strip()) - self.cur_sndbytes = int(open(dev_dir + "tx_bytes", "r").read().strip()) - except: - self.cur_sndbytes = -1 - self.cur_rcvbytes = -1 + self.cur_rcvbytes = int( + open(dev_dir + "rx_bytes", "r").read().strip()) + self.cur_sndbytes = int( + open(dev_dir + "tx_bytes", "r").read().strip()) + except (IOError, OSError, ValueError): + self.cur_sndbytes = -1 + self.cur_rcvbytes = -1 class TrayConnectionInfo(object): """ Class for updating the tray icon status. """ @@ -234,8 +246,8 @@ class TrayIcon(object): if self.should_notify: try: if not self._last_bubble: - self._last_bubble = pynotify.Notification(title, details, - image) + self._last_bubble = pynotify.Notification( + title, details, image) self._last_bubble.show() else: self._last_bubble.clear_actions() @@ -258,20 +270,20 @@ class TrayIcon(object): """ Launch the wired profile chooser. """ gui.WiredProfileChooser() daemon.SetNeedWiredProfileChooser(False) - + def set_wired_state(self, info): """ Sets the icon info for a wired state. """ wired_ip = info[0] self.network_addr = str(info[0]) self.network_type = "wired" self.tr.set_from_name('wired') - # status_string = _('Connected to wired network (IP: $A)').replace('$A', - #wired_ip) - # self.tr.set_tooltip(status_string) + #status_string = _('Connected to wired network (IP: $A)'). \ + # replace('$A',wired_ip) + #self.tr.set_tooltip(status_string) self._show_notification(_('Wired Network'), _('Connection established'), 'network-wired') - + self.update_tooltip() @catchdbus @@ -289,22 +301,21 @@ class TrayIcon(object): self.network_str = sig_string self.network_br = info[4] self.set_signal_image(int(info[2]), lock) - + if wireless.GetWirelessProperty(cur_net_id, "encryption"): lock = "-lock" # status_string = (_('Connected to $A at $B (IP: $C)') #.replace('$A', self.network) # .replace('$B', sig_string) - # .replace('$C', str(wireless_ip))) + # .replace('$C', str(wireless_ip))) #self.tr.set_tooltip(status_string) self.set_signal_image(int(strength), lock) self._show_notification(self.network, _('Connection established'), 'network-wireless') - - + self.update_tooltip() - + def set_connecting_state(self, info): """ Sets the icon info for a connecting state. """ wired = False @@ -327,7 +338,6 @@ class TrayIcon(object): _('Establishing connection...'), 'network-wireless') - @catchdbus def set_not_connected_state(self, info=None): """ Set the icon info for the not connected state. """ @@ -335,7 +345,7 @@ class TrayIcon(object): if not DBUS_AVAIL: status = _('Wicd daemon unreachable') elif wireless.GetKillSwitchEnabled(): - status = (_('Not connected') + " (" + + status = (_('Not connected') + " (" + _('Wireless Kill Switch Enabled') + ")") else: status = _('Not connected') @@ -346,17 +356,18 @@ class TrayIcon(object): @catchdbus def update_tray_icon(self, state=None, info=None): """ Updates the tray icon and current connection status. """ - if not DBUS_AVAIL: return False + if not DBUS_AVAIL: + return False if not state or not info: [state, info] = daemon.GetConnectionStatus() # should this state change display a notification? - self.should_notify = (can_use_notify() and + self.should_notify = (can_use_notify() and self.last_state != state) self.last_state = state - + if state == misc.WIRED: self.set_wired_state(info) elif state == misc.WIRELESS: @@ -398,13 +409,13 @@ class TrayIcon(object): signal_img = "bad-signal" img_name = ''.join([prefix, signal_img, lock]) self.tr.set_from_name(img_name) - + @catchdbus def get_bandwidth_activity(self): """ Determines what network activity state we are in. """ transmitting = False receiving = False - + dev_dir = '/sys/class/net/' wiface = daemon.GetWirelessInterface() for fldr in os.listdir(dev_dir): @@ -417,26 +428,26 @@ class TrayIcon(object): except IOError: sndbytes = None rcvbytes = None - + if not rcvbytes or not sndbytes: return 'idle-' - + # Figure out receiving data info. - activity = self.is_network_active(self.parent.cur_rcvbytes, + activity = self.is_network_active(self.parent.cur_rcvbytes, self.parent.max_rcv_gain, self.parent.last_rcvbytes) receiving = activity[0] self.parent.max_rcv_gain = activity[1] self.parent.last_rcvbytes = activity[2] - + # Figure out out transmitting data info. - activity = self.is_network_active(self.parent.cur_sndbytes, + activity = self.is_network_active(self.parent.cur_sndbytes, self.parent.max_snd_gain, self.parent.last_sndbytes) transmitting = activity[0] self.parent.max_snd_gain = activity[1] self.parent.last_sndbytes = activity[2] - + if transmitting and receiving: return 'both-' elif transmitting: @@ -445,21 +456,21 @@ class TrayIcon(object): return 'receiving-' else: return 'idle-' - + def is_network_active(self, bytes, max_gain, last_bytes): """ Determines if a network is active. - + Determines if a network is active by looking at the number of bytes sent since the previous check. This method is generic, and can be used to determine activity in both the sending and receiving directions. - + Returns: A tuple containing three elements: 1) a boolean specifying if the network is active. 2) an int specifying the maximum gain the network has had. 3) an int specifying the last recorded number of bytes sent. - + """ active = False if last_bytes == -1: @@ -467,21 +478,24 @@ class TrayIcon(object): elif bytes > (last_bytes + float(max_gain / 20.0)): last_bytes = bytes active = True - + gain = bytes - last_bytes if gain > max_gain: max_gain = gain return (active, max_gain, last_bytes) - class TrayIconGUI(object): """ Base Tray Icon UI class. - + Implements methods and variables used by both egg/StatusIcon tray icons. """ def __init__(self, parent): + self.list = [] + self.label = None + self.data = None + menu = """ @@ -496,13 +510,13 @@ class TrayIcon(object): """ actions = [ - ('Menu', None, 'Menu'), + ('Menu', None, 'Menu'), ('Connect', gtk.STOCK_CONNECT, _('Connect')), ('Info', gtk.STOCK_INFO, _('_Connection Info'), None, - _('Information about the current connection'), - self.on_conn_info), - ('Quit',gtk.STOCK_QUIT,_('_Quit'),None,_('Quit wicd-tray-icon'), - self.on_quit), + _('Information about the current connection'), + self.on_conn_info), + ('Quit', gtk.STOCK_QUIT, _('_Quit'), None, + _('Quit wicd-tray-icon'), self.on_quit), ] actg = gtk.ActionGroup('Actions') actg.add_actions(actions) @@ -516,30 +530,34 @@ class TrayIcon(object): self._is_scanning = False net_menuitem = self.manager.get_widget("/Menubar/Menu/Connect/") net_menuitem.connect("activate", self.on_net_menu_activate) - + self.parent = parent self.time = 2 # Time between updates self.cont = 'Stop' self.conn_info_txt = '' - + def tray_scan_started(self): """ Callback for when a wireless scan is started. """ - if not DBUS_AVAIL: return + if not DBUS_AVAIL: + return self._is_scanning = True self.init_network_menu() - + def tray_scan_ended(self): """ Callback for when a wireless scan finishes. """ - if not DBUS_AVAIL: return + if not DBUS_AVAIL: + return self._is_scanning = False self.populate_network_menu() - + def on_activate(self, data=None): """ Opens the wicd GUI. """ if DBUS_AVAIL: self.toggle_wicd_gui() else: - # error(None, _('The wicd daemon is unavailable, so your request cannot be completed')) + #error(None, + #_('The wicd daemon is unavailable, so your request ' + # 'cannot be completed')) pass def on_quit(self, widget=None): @@ -558,8 +576,13 @@ class TrayIcon(object): def on_conn_info(self, data=None): """ Opens the Connection Information Dialog """ - window = gtk.Dialog("Wicd Connection Info", None, 0, (gtk.STOCK_OK, gtk.RESPONSE_CLOSE)) - + window = gtk.Dialog( + "Wicd Connection Info", + None, + 0, + (gtk.STOCK_OK, gtk.RESPONSE_CLOSE) + ) + # Create labels self.label = gtk.Label() self.data = gtk.Label() @@ -571,43 +594,43 @@ class TrayIcon(object): self.list.append(self.label) # Setup table - table = gtk.Table(1,2) + table = gtk.Table(1, 2) table.set_col_spacings(12) table.attach(self.label, 0, 1, 0, 1) - table.attach(self.data, 1, 2, 0 ,1) + table.attach(self.data, 1, 2, 0, 1) # Setup Window content = window.get_content_area() content.pack_start(table, True, True, 0) content.show_all() - + # Start updates self.cont = 'Go' gobject.timeout_add(5000, self.update_conn_info_win, self.list) self.update_conn_info_win(self.list) - + window.run() - + # Destroy window and stop updates window.destroy() self.cont = 'Stop' - - def update_conn_info_win(self, list): + + def update_conn_info_win(self, l): """ Updates the information in the connection summary window """ if (self.cont == "Stop"): return False - + [state, info] = daemon.GetConnectionStatus() [rx, tx] = self.get_current_bandwidth() - + # Choose info for the data if state == misc.WIRED: text = (_('''$A $B KB/s $C KB/s''') - .replace('$A', str(info[0])) #IP - .replace('$B', str(rx)) #RX - .replace('$C', str(tx))) #TX + .replace('$A', str(info[0])) # IP + .replace('$B', str(rx)) # RX + .replace('$C', str(tx))) # TX elif state == misc.WIRELESS: text = (_('''$A $B @@ -615,10 +638,11 @@ $C $D $E KB/s $F KB/s''') - .replace('$A', str(info[1])) #SSID - .replace('$B', str(info[4])) #Speed - .replace('$C', str(info[0])) #IP - .replace('$D', daemon.FormatSignalForPrinting(str(info[2]))) + .replace('$A', str(info[1])) # SSID + .replace('$B', str(info[4])) # Speed + .replace('$C', str(info[0])) # IP + .replace('$D', + daemon.FormatSignalForPrinting(str(info[2]))) .replace('$E', str(rx)) .replace('$F', str(tx))) else: @@ -643,11 +667,11 @@ TX:''')) self.list[1].set_text(_('Connecting')) elif state in (misc.SUSPENDED, misc.NOT_CONNECTED): self.list[1].set_text(_('Disconnected')) - - return True - + + return True + def get_current_bandwidth(self): - """ + """ Calculates the current bandwidth based on sent/received bytes divided over time. Unit is in KB/s """ @@ -660,10 +684,10 @@ TX:''')) rx_rate = float(rxb / (self.time * 1024)) tx_rate = float(txb / (self.time * 1024)) - + return (rx_rate, tx_rate) - - def _add_item_to_menu(self, net_menu, lbl, type_, n_id, is_connecting, + + def _add_item_to_menu(self, net_menu, lbl, type_, n_id, is_connecting, is_active): """ Add an item to the network list submenu. """ def network_selected(widget, net_type, net_id): @@ -672,10 +696,10 @@ TX:''')) wired.ConnectWired() else: wireless.ConnectWireless(net_id) - + item = NetworkMenuItem(lbl, is_active) image = gtk.Image() - + if type_ == "__wired__": image.set_from_icon_name("network-wired", 2) else: @@ -686,19 +710,19 @@ TX:''')) net_menu.append(item) item.show() if is_connecting: - item.set_sensitive(False) + item.set_sensitive(False) del item - + @catchdbus def _get_img(self, net_id): """ Determines which image to use for the wireless entries. """ def fix_strength(val, default): """ Assigns given strength to a default value if needed. """ return val and int(val) or default - + def get_prop(prop): return wireless.GetWirelessProperty(net_id, prop) - + strength = fix_strength(get_prop("quality"), -1) dbm_strength = fix_strength(get_prop('strength'), -100) @@ -722,26 +746,27 @@ TX:''')) else: signal_img = 'signal-25' return signal_img - + @catchdbus def on_net_menu_activate(self, item): - """ Trigger a background scan to populate the network menu. - + """ Trigger a background scan to populate the network menu. + Called when the network submenu is moused over. We sleep briefly, clear pending gtk events, and if we're still being moused over we trigger a scan. This is to prevent scans when the user is just mousing past the menu to select another menu item. - + """ - def dummy(x=None): pass - + def dummy(x=None): + pass + if self._is_scanning: return True - + self.init_network_menu() gobject.timeout_add(800, self._trigger_scan_if_needed, item) - + @catchdbus def _trigger_scan_if_needed(self, item): """ Trigger a scan if the network menu is being hovered over. """ @@ -751,7 +776,7 @@ TX:''')) return True wireless.Scan(False) return False - + @catchdbus def populate_network_menu(self, data=None): """ Populates the network list submenu. """ @@ -768,7 +793,7 @@ TX:''')) is_connecting = daemon.CheckIfConnecting() num_networks = wireless.GetNumberOfNetworks() [status, info] = daemon.GetConnectionStatus() - + if daemon.GetAlwaysShowWiredInterface() or \ wired.CheckPluggedIn(): if status == misc.WIRED: @@ -780,11 +805,13 @@ TX:''')) sep = gtk.SeparatorMenuItem() submenu.append(sep) sep.show() - + if num_networks > 0: skip_never_connect = not daemon.GetShowNeverConnect() for x in xrange(0, num_networks): - if skip_never_connect and misc.to_bool(get_prop(x,"never")): continue + if skip_never_connect and \ + misc.to_bool(get_prop(x,"never")): + continue essid = get_prop(x, "essid") if status == misc.WIRELESS and info[1] == essid: is_active = True @@ -800,7 +827,7 @@ TX:''')) submenu.reposition() net_menuitem.show() - + def init_network_menu(self): """ Set the right-click network menu to the scanning state. """ net_menuitem = self.manager.get_widget("/Menubar/Menu/Connect/") @@ -812,13 +839,13 @@ TX:''')) loading_item.show() submenu.append(loading_item) net_menuitem.show() - + def _clear_menu(self, menu): """ Clear the right-click menu. """ for item in menu.get_children(): menu.remove(item) item.destroy() - + def toggle_wicd_gui(self): """ Toggles the wicd GUI. """ if not self.gui_win: @@ -828,16 +855,15 @@ TX:''')) else: self.gui_win.exit() return True - if USE_EGG: class EggTrayIconGUI(TrayIconGUI): """ Tray Icon for gtk < 2.10. - + Uses the deprecated egg.trayicon module to implement the tray icon. Since it relies on a deprecated module, this class is only used for machines running versions of GTK < 2.10. - + """ def __init__(self, parent): """Initializes the tray icon""" @@ -864,11 +890,15 @@ TX:''')) def set_from_file(self, val=None): """ Calls set_from_file on the gtk.Image for the tray icon. """ - self.pic.set_from_file(os.path.join(wpath.images, 'hicolor/22x22/status/%s.png' % val)) + self.pic.set_from_file( + os.path.join( + wpath.images, 'hicolor/22x22/status/%s.png' % val + ) + ) def set_tooltip(self, val): """ Set the tooltip for this tray icon. - + Sets the tooltip for the gtk.ToolTips associated with this tray icon. @@ -887,13 +917,12 @@ TX:''')) else: self.tray.hide_all() - if hasattr(gtk, "StatusIcon"): class StatusTrayIconGUI(gtk.StatusIcon, TrayIconGUI): """ Class for creating the wicd tray icon on gtk > 2.10. - + Uses gtk.StatusIcon to implement a tray icon. - + """ def __init__(self, parent): TrayIcon.TrayIconGUI.__init__(self, parent) @@ -930,7 +959,7 @@ TX:''')) def usage(): """ Print usage information. """ print """ -wicd %s +wicd %s wireless (and wired) connection daemon front-end. Arguments: @@ -941,23 +970,29 @@ Arguments: \t-o\t--only-notifications\tDon't display anything except notifications. """ % wpath.version + def setup_dbus(force=True): + """ Initialize DBus. """ global daemon, wireless, wired, DBUS_AVAIL, lost_dbus_id print "Connecting to daemon..." try: dbusmanager.connect_to_dbus() except DBusException: if force: - print "Can't connect to the daemon, trying to start it automatically..." + print "Can't connect to the daemon, trying to start it " + \ + "automatically..." misc.PromptToStartDaemon() try: dbusmanager.connect_to_dbus() except DBusException: - error(None, _("Could not connect to wicd's D-Bus interface. Check the wicd log for error messages.")) + error(None, + _("Could not connect to wicd's D-Bus interface. Check " + "the wicd log for error messages.") + ) return False - else: + else: return False - + if lost_dbus_id: gobject.source_remove(lost_dbus_id) lost_dbus_id = None @@ -969,23 +1004,32 @@ def setup_dbus(force=True): print "Connected." return True + def on_exit(): + """ Handle GUI exit. """ if DBUS_AVAIL: try: daemon.SetGUIOpen(False) except DBusException: pass + def handle_no_dbus(): """ Called when dbus announces its shutting down. """ global DBUS_AVAIL, lost_dbus_id DBUS_AVAIL = False gui.handle_no_dbus(from_tray=True) print "Wicd daemon is shutting down!" - lost_dbus_id = misc.timeout_add(5, lambda:error(None, _('The wicd daemon has shut down. The UI will not function properly until it is restarted.'), - block=False)) + lost_dbus_id = misc.timeout_add(5, + lambda: error(None, + _('The wicd daemon has shut down. The UI will not function ' + 'properly until it is restarted.'), + block=False + ) + ) return False + @catchdbus def main(argv): """ The main frontend program. @@ -995,10 +1039,11 @@ def main(argv): """ try: - opts, args = getopt.getopt(sys.argv[1:], 'tnhao', ['help', 'no-tray', - 'tray', - 'no-animate', - 'only-notifications']) + opts, args = getopt.getopt( + sys.argv[1:], + 'tnhao', + ['help', 'no-tray', 'tray', 'no-animate', 'only-notifications'] + ) except getopt.GetoptError: # Print help information and exit usage() @@ -1024,13 +1069,13 @@ def main(argv): else: usage() sys.exit(2) - + print 'Loading...' setup_dbus() atexit.register(on_exit) if display_app and not use_tray or not ICON_AVAIL: - the_gui = gui.appGui(standalone=True) + gui.appGui(standalone=True) mainloop = gobject.MainLoop() mainloop.run() sys.exit(0) @@ -1043,7 +1088,7 @@ def main(argv): if DBUS_AVAIL and daemon.GetNeedWiredProfileChooser(): daemon.SetNeedWiredProfileChooser(False) tray_icon.icon_info.wired_profile_chooser() - + bus = dbusmanager.get_bus() bus.add_signal_receiver(tray_icon.icon_info.wired_profile_chooser, 'LaunchChooser', 'org.wicd.daemon') @@ -1053,9 +1098,13 @@ def main(argv): 'org.wicd.daemon.wireless') bus.add_signal_receiver(tray_icon.tr.tray_scan_started, 'SendStartScanSignal', 'org.wicd.daemon.wireless') - bus.add_signal_receiver(lambda: (handle_no_dbus() or - tray_icon.icon_info.set_not_connected_state()), - "DaemonClosing", 'org.wicd.daemon') + bus.add_signal_receiver( + lambda: ( + handle_no_dbus() or tray_icon.icon_info.set_not_connected_state() + ), + "DaemonClosing", + 'org.wicd.daemon' + ) bus.add_signal_receiver(lambda: setup_dbus(force=False), "DaemonStarting", "org.wicd.daemon") print 'Done loading.'