Merge lp:~andreambu/phatch/pep8 into lp:phatch

[Andrea Ambu]

PEP8 conversion complete ;D

=== modified file 'phatch/lib/__init__.py'
--- phatch/lib/__init__.py	2010-03-02 05:29:41 +0000
+++ phatch/lib/__init__.py	2010-03-07 00:55:24 +0000
@@ -12,5 +12,5 @@
 #
 # You should have received a copy of the GNU General Public License
 # along with this program.  If not, see http://www.gnu.org/licenses/
-
+#
 # Follows PEP8

=== modified file 'phatch/lib/pyWx/__init__.py'
--- phatch/lib/pyWx/__init__.py	2008-01-01 15:05:58 +0000
+++ phatch/lib/pyWx/__init__.py	2010-03-07 00:55:24 +0000
@@ -9,6 +9,8 @@
 # but WITHOUT ANY WARRANTY; without even the implied warranty of
 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 # GNU General Public License for more details.
-# 
+#
 # You should have received a copy of the GNU General Public License
-# along with this program.  If not, see http://www.gnu.org/licenses/
\ No newline at end of file
+# along with this program.  If not, see http://www.gnu.org/licenses/
+#
+# Follow PEP8

=== modified file 'phatch/lib/pyWx/paint.py'
--- phatch/lib/pyWx/paint.py	2010-03-06 18:44:33 +0000
+++ phatch/lib/pyWx/paint.py	2010-03-07 00:55:24 +0000
@@ -14,6 +14,8 @@
 #
 # You should have received a copy of the GNU General Public License
 # along with this program.  If not, see http://www.gnu.org/licenses/
+#
+# Follow PEP8
 
 import wx
 from compatible import GCDC, FONT_SIZE

=== modified file 'phatch/lib/pyWx/screenshot.py'
--- phatch/lib/pyWx/screenshot.py	2010-02-24 21:00:07 +0000
+++ phatch/lib/pyWx/screenshot.py	2010-03-07 00:55:24 +0000
@@ -12,52 +12,58 @@
 #
 # You should have received a copy of the GNU General Public License
 # along with this program.  If not, see http://www.gnu.org/licenses/
+#
+# Follow PEP8
 
 import os
 import wx
 
+
 def get(rect):
     """ Takes a screenshot of the screen at give pos & size (rect). """
 
-    #Create a DC for the whole screen area
+    # Create a DC for the whole screen area.
     dcScreen = wx.ScreenDC()
 
-    #Create a Bitmap that will later on hold the screenshot image
-    #Note that the Bitmap must have a size big enough to hold the screenshot
-    #-1 means using the current default color depth
+    # Create a Bitmap that will later on hold the screenshot image.
+    # Note that the Bitmap must have a size big enough to hold the screenshot.
+    # -1 means using the current default color depth.
     bmp = wx.EmptyBitmap(rect.width, rect.height)
 
-    #Create a memory DC that will be used for actually taking the screenshot
+    # Create a memory DC that will be used for actually taking the screenshot.
     memDC = wx.MemoryDC()
 
-    #Tell the memory DC to use our Bitmap
-    #all drawing action on the memory DC will go to the Bitmap now
+    # Tell the memory DC to use our Bitmap
+    # all drawing action on the memory DC will go to the Bitmap now.
     memDC.SelectObject(bmp)
 
-    #Blit (in this case copy) the actual screen on the memory DC
-    #and thus the Bitmap
-    memDC.Blit( 0, #Copy to this X coordinate
-        0, #Copy to this Y coordinate
-        rect.width, #Copy this width
-        rect.height, #Copy this height
-        dcScreen, #From where do we copy?
-        rect.x, #What's the X offset in the original DC?
-        rect.y  #What's the Y offset in the original DC?
+    # Blit (in this case copy) the actual screen on the memory DC
+    # and thus the Bitmap
+    memDC.Blit(0,  # Copy to this X coordinate.
+        0,  # Copy to this Y coordinate.
+        rect.width,  # Copy this width.
+        rect.height,  # Copy this height.
+        dcScreen,  # From where do we copy?
+        rect.x,  # What's the X offset in the original DC?
+        rect.y  # What's the Y offset in the original DC?
         )
 
-    #Select the Bitmap out of the memory DC by selecting a new
-    #uninitialized Bitmap
+    # Select the Bitmap out of the memory DC by selecting a new
+    # uninitialized Bitmap.
     memDC.SelectObject(wx.NullBitmap)
 
     return bmp
 
+
 def get_window(window):
     return get(window.GetRect())
 
-def save(rect,filename):
+
+def save(rect, filename):
     ext = os.path.splitext(filename)[-1][1:].upper()
-    typ = getattr(wx,'BITMAP_TYPE_' + ext)
+    typ = getattr(wx, 'BITMAP_TYPE_' + ext)
     return get(rect).SaveFile(filename, typ)
 
+
 def save_window(window, filename):
     return save(window.GetRect(), filename)

=== modified file 'phatch/lib/pyWx/shell.py'
--- phatch/lib/pyWx/shell.py	2009-09-22 17:10:51 +0000
+++ phatch/lib/pyWx/shell.py	2010-03-07 00:55:24 +0000
@@ -12,6 +12,8 @@
 #
 # You should have received a copy of the GNU General Public License
 # along with this program.  If not, see http://www.gnu.org/licenses/
+#
+# Follow PEP8
 
 try:
     _
@@ -27,19 +29,21 @@
 
 TRANSLATE = _
 
+
 class Frame(wx.Frame):
     def __init__(self, parent, title='Shell', intro='', values={}, icon=None,
             **kw):
-        wx.Frame.__init__(self, parent, -1, title = title, **kw)
+        wx.Frame.__init__(self, parent, -1, title=title, **kw)
         self.shell = wx.py.crust.Crust(self, -1, intro=intro)
-        pp  = self.shell.shell.interp.locals['pp']
+        pp = self.shell.shell.interp.locals['pp']
         self.shell.shell.interp.locals.clear()
         self.shell.shell.interp.locals.update(values)
         self.shell.shell.interp.locals['pp'] = pp
-        if icon: self.SetIcon(icon)
-        self.Bind(wx.EVT_CLOSE,self.on_close,self)
+        if icon:
+            self.SetIcon(icon)
+        self.Bind(wx.EVT_CLOSE, self.on_close, self)
 
-        shell                   = self.shell.shell
+        shell = self.shell.shell
         shell.Unbind(wx.EVT_IDLE)
         shell.Bind(wx.EVT_IDLE, self.OnIdle)
 
@@ -50,9 +54,8 @@
         if self.shell.shell.waiting:
             time.sleep(0.05)
 
-
-    def on_close(self,event):
-        parent          = self.GetParent()
-        parent.menu_tools.Check(parent.menu_tools_python_shell.GetId(),False)
-        parent.shell    = None
+    def on_close(self, event):
+        parent = self.GetParent()
+        parent.menu_tools.Check(parent.menu_tools_python_shell.GetId(), False)
+        parent.shell = None
         event.Skip()

=== modified file 'phatch/lib/pyWx/treeDragDrop.py'
--- phatch/lib/pyWx/treeDragDrop.py	2010-03-06 20:35:59 +0000
+++ phatch/lib/pyWx/treeDragDrop.py	2010-03-07 00:55:24 +0000
@@ -12,7 +12,8 @@
 #
 # You should have received a copy of the GNU General Public License
 # along with this program.  If not, see http://www.gnu.org/licenses/
-
+#
+# Follow PEP8
 import wx
 
 

=== modified file 'phatch/lib/pyWx/treeEdit.py'
--- phatch/lib/pyWx/treeEdit.py	2010-03-06 01:30:28 +0000
+++ phatch/lib/pyWx/treeEdit.py	2010-03-07 00:55:24 +0000
@@ -12,13 +12,15 @@
 #
 # You should have received a copy of the GNU General Public License
 # along with this program.  If not, see http://www.gnu.org/licenses/
+#
+# Follow PEP8
 
-#---import modules
+# ---import modules
 
 # gui-indepedent
 if __name__ == '__main__':
     import sys
-    sys.path.insert(0,'..')
+    sys.path.insert(0, '..')
 
 from lib import formField
 from lib import metadata
@@ -30,284 +32,292 @@
 import treeDragDrop
 
 if __name__ == '__main__':
-    sys.path.insert(0,'../..')
+    sys.path.insert(0, '../..')
 
 from lib.unicoding import exception_to_unicode
 
 FIELD_DELIMITER = ': '
-WX_ENCODING     = wx.GetDefaultPyEncoding()
+WX_ENCODING = wx.GetDefaultPyEncoding()
 IMAGE_TEST_INFO = metadata.InfoTest()
 
-#---functions
+# ---functions
 
-#---tree
+# ---tree
 ITEM_HEIGHT = 28
-ICON_SIZE   = (ITEM_HEIGHT,ITEM_HEIGHT)
-TR_DEFAULT_STYLE   = wx.TR_HAS_BUTTONS | wx.TR_NO_LINES | wx.TR_FULL_ROW_HIGHLIGHT | wx.TR_HIDE_ROOT | wx.TR_DEFAULT_STYLE | wx.SUNKEN_BORDER
-
-def _do_nothing(*args,**keyw):
+ICON_SIZE = (ITEM_HEIGHT, ITEM_HEIGHT)
+TR_DEFAULT_STYLE = wx.TR_HAS_BUTTONS | wx.TR_NO_LINES | \
+            wx.TR_FULL_ROW_HIGHLIGHT | wx.TR_HIDE_ROOT | \
+            wx.TR_DEFAULT_STYLE | wx.SUNKEN_BORDER
+
+
+def _do_nothing(*args, **keyw):
     pass
 
-def rescale(image,x,y,filter=None):
+
+def rescale(image, x, y, filter=None):
     """For compatibility with wxPython 2.6"""
-    if filter is None and hasattr(wx,'IMAGE_QUALITY_HIGH'):
-        filter  = wx.IMAGE_QUALITY_HIGH
+    if filter is None and hasattr(wx, 'IMAGE_QUALITY_HIGH'):
+        filter = wx.IMAGE_QUALITY_HIGH
     if filter is None:
-        image.Rescale(x,y)
+        image.Rescale(x, y)
     else:
-        image.Rescale(x,y,filter)
-
-def get_index(li,index,n=3):
+        image.Rescale(x, y, filter)
+
+
+def get_index(li, index, n=3):
     try:
         return li[index]
     except IndexError:
-        return (None,)*n
+        return (None, ) * n
+
 
 class TreeMixin(treeDragDrop.Mixin):
     """
     - form is like an action
     """
-    def __init__(self,form_factory={},CtrlMixin=[],
-        icon_size=(28,28),show_error=_do_nothing,set_dirty=_do_nothing):
+    def __init__(self, form_factory={}, CtrlMixin=[],
+        icon_size=(28, 28), show_error=_do_nothing, set_dirty=_do_nothing):
         if wx.Platform == "__WXGTK__":
-            #indentation
-            self.SetIndent(int(self.GetIndent()*1.5))
-##        elif wx.Platform == "__WXMSW__":#doesn't work
-##            self.SetIndent(int(self.GetIndent() / 2))
-        #form factory
-        self.form_factory       = form_factory
-        self.CtrlMixin          = CtrlMixin
-        #popup
-        self.popup              = None
-        self.popup_item         = None
-        self._field_selected    = False
-        #methods
-        self.show_error         = show_error
-        self.set_dirty          = set_dirty
-        #image list
+            # indentation
+            self.SetIndent(int(self.GetIndent() * 1.5))
+# #        elif wx.Platform == "__WXMSW__":  # doesn't work
+# #            self.SetIndent(int(self.GetIndent() / 2))
+        # form factory
+        self.form_factory = form_factory
+        self.CtrlMixin = CtrlMixin
+        # popup
+        self.popup = None
+        self.popup_item = None
+        self._field_selected = False
+        # methods
+        self.show_error = show_error
+        self.set_dirty = set_dirty
+        # image list
         self.CreateImageList(icon_size)
-        #drag & drop
+        # drag & drop
         self.EnableDrag(dragTo=self.get_form_item)
-        #collapse
+        # collapse
         self.collapse_automatic = False
         self.evt_leave_window = False
-        #clear
+        # clear
         self.delete_all_forms()
-        #events
+        # events
         self.events()
 
-    def CreateImageList(self,icon_size):
+    def CreateImageList(self, icon_size):
         self.image_list = wx.ImageList(*icon_size)
-        icon_disabled   = graphics.bitmap(ICON_DISABLED)
+        icon_disabled = graphics.bitmap(ICON_DISABLED)
         for form in self.form_factory.values():
-            self._AddFormToImageList(form,icon_size,icon_disabled)
+            self._AddFormToImageList(form, icon_size, icon_disabled)
         self.SetImageList(self.image_list)
 
-    def _AddFormToImageList(self,form,icon_size,icon_disabled):
-        wx_image             = graphics.image(form.icon,icon_size)
-        form.icon_bitmap  = wx.BitmapFromImage(wx_image)
-        #rescale(image,icon_size[0],icon_size[1])
+    def _AddFormToImageList(self, form, icon_size, icon_disabled):
+        wx_image = graphics.image(form.icon, icon_size)
+        form.icon_bitmap = wx.BitmapFromImage(wx_image)
+        # rescale(image, icon_size[0], icon_size[1])
         import Image
         from wxPil import pil_wxImage, wxImage_pil
-        wx_image=pil_wxImage(wxImage_pil(wx_image).resize(icon_size,Image.ANTIALIAS))
-        form.icon_tree    = wx.BitmapFromImage(wx_image)
-        form.icon_tree_disabled   = icon_disabled
-        form.icon_tree_id         = (
+        wx_image = pil_wxImage(wxImage_pil(wx_image).resize(icon_size,\
+                                                        Image.ANTIALIAS))
+        form.icon_tree = wx.BitmapFromImage(wx_image)
+        form.icon_tree_disabled = icon_disabled
+        form.icon_tree_id = (
             self.image_list.Add(form.icon_tree_disabled),
             self.image_list.Add(form.icon_tree))
 
-    def set_item_image(self,x,image):
-        self.SetItemImage(x,image,wx.TreeItemIcon_Normal)
+    def set_item_image(self, x, image):
+        self.SetItemImage(x, image, wx.TreeItemIcon_Normal)
 
-    def tree_label(self,name,value):
-        return ''.join([_(name),FIELD_DELIMITER,
+    def tree_label(self, name, value):
+        return ''.join([_(name), FIELD_DELIMITER,
             self.CtrlMixin._to_local(value)])
 
     def delete_all_forms(self):
         self.DeleteAllItems()
         self.AddRoot('')
 
-    #---forms
+    # ---forms
     def append_form(self, form, item=-1):
-        root    = self.GetRootItem()
+        root = self.GetRootItem()
         if item is -1:
-            item    = self.AppendItem(root,_(form.label))
+            item = self.AppendItem(root, _(form.label))
         else:
-            item    = self.InsertItem(root,item,_(form.label))
-        self.set_item_image(item,form.icon_tree_id[True])
-        self.SetItemBold(item,True)
-        self.import_form(item,form)
+            item = self.InsertItem(root, item, _(form.label))
+        self.set_item_image(item, form.icon_tree_id[True])
+        self.SetItemBold(item, True)
+        self.import_form(item, form)
         self.SelectItem(item)
         return item
 
-    def append_forms(self,forms):
-        collapse = len(forms)>4
-        for form in forms[:-1]:
+    def append_forms(self, forms):
+        collapse = len(forms) > 4
+        for form in forms[: -1]:
             item = self.append_form(form)
             if collapse:
                 self.Collapse(item)
         self.append_form(forms[-1])
         return forms
 
-    def append_form_by_label(self,item,label):
-        return self.append_form(self.form_factory[label](),item)
+    def append_form_by_label(self, item, label):
+        return self.append_form(self.form_factory[label](), item)
 
     def collapse_forms(self):
-        root    = self.GetRootItem()
+        root = self.GetRootItem()
         for child in self.GetItemChildren(root):
             self.Collapse(child)
 
-    def enable_form(self,item, bool):
-        self.enable_form_item(self.get_form_item(item),bool)
+    def enable_form(self, item, bool):
+        self.enable_form_item(self.get_form_item(item), bool)
 
-    def enable_form_item(self,item,bool):
-        form              = self.GetPyData(item)
-        self.set_item_image(item,form.icon_tree_id[bool])
-        self.SetItemTextColour(item,(wx.RED,wx.GREEN)[bool])
+    def enable_form_item(self, item, bool):
+        form = self.GetPyData(item)
+        self.set_item_image(item, form.icon_tree_id[bool])
+        self.SetItemTextColour(item, (wx.RED, wx.GREEN)[bool])
         if bool:
             self.Expand(item)
         else:
             self.Collapse(item)
 
     def expand_forms(self):
-        root    = self.GetRootItem()
+        root = self.GetRootItem()
         for child in self.GetItemChildren(root):
             self.Expand(child)
 
-    def export_form(self,item,label=None):
-        form              = self.GetPyData(item)
+    def export_form(self, item, label=None):
+        form = self.GetPyData(item)
         for field in self.GetItemChildren(item):
-            label, value_as_string  = self.GetPyData(field)
-            form.set_field_as_string(label,value_as_string)
-        form.set_field('__enabled__',self.is_form_enabled(item))
+            label, value_as_string = self.GetPyData(field)
+            form.set_field_as_string(label, value_as_string)
+        form.set_field('__enabled__', self.is_form_enabled(item))
         return form
 
     def export_forms(self):
-        root    = self.GetRootItem()
+        root = self.GetRootItem()
         forms = []
         for child in self.GetItemChildren(root):
             forms.append(self.export_form(child))
         return forms
 
-    def import_form(self,item,form):
-        self.SetPyData(item,form)
+    def import_form(self, item, form):
+        self.SetPyData(item, form)
         self.DeleteChildren(item)
         fields = form._get_fields()
         if not self.update_form_relevance(item):
             for label, field in fields.items():
                 if field.visible:
-                    self.append_field(item,label,field)
+                    self.append_field(item, label, field)
         enabled_field = form._get_fields()['__enabled__']
-        self.enable_form_item(item,enabled_field.get())
+        self.enable_form_item(item, enabled_field.get())
 
-    def append_field(self,parent,label,field,method=None,item=None):
+    def append_field(self, parent, label, field, method=None, item=None):
         value_as_string = field.get_as_string()
         if method is None:
             new_item = self.AppendItem(parent,
-                            self.tree_label(label,value_as_string))
+                            self.tree_label(label, value_as_string))
         else:
-            #print method,parent,item, self.tree_label(label,value_as_string)
-            #print
-            new_item = method(parent,item,
-                            self.tree_label(label,value_as_string))
-        self.SetPyData(new_item,(label,value_as_string))
+            # print method, parent, item, self.tree_label(label,\
+            #                                       value_as_string)
+            # print
+            new_item = method(parent, item,
+                            self.tree_label(label, value_as_string))
+        self.SetPyData(new_item, (label, value_as_string))
         return new_item
 
-    def get_form(self,item,label=None):
-        return self.export_form(self.get_form_item(item),label)
+    def get_form(self, item, label=None):
+        return self.export_form(self.get_form_item(item), label)
 
-    def get_form_item(self,item):
+    def get_form_item(self, item):
         return self.GetRootChild(item)
 
-    def get_form_field(self,item):
-        label, value_as_string  = self.GetPyData(item)
-        return self.get_form(item,label)._get_field(label)
+    def get_form_field(self, item):
+        label, value_as_string = self.GetPyData(item)
+        return self.get_form(item, label)._get_field(label)
 
-    def get_form_fields_visible(self,item, form):
+    def get_form_fields_visible(self, item, form):
         """Retrieves the visible fields and their values. If a field
         is dirty, its value will be overwritten with the newly given
         value.
 
         Very important: this handles the dirty fields.
         """
-        form    = self.GetPyData(item)
-        fields  = []
-        for index,ui_field in enumerate(self.GetItemChildren(item)):
-            label, value_as_string  = self.GetPyData(ui_field)
+        form = self.GetPyData(item)
+        fields = []
+        for index, ui_field in enumerate(self.GetItemChildren(item)):
+            label, value_as_string = self.GetPyData(ui_field)
             field = form._get_field(label)
             if field.dirty:
-                #overrule if dirty
+                # overrule if dirty
                 value_as_string = field.get_as_string()
                 self.SetItemText(ui_field,
                     self.tree_label(label, value_as_string))
                 self.SetPyData(ui_field, (label, value_as_string))
                 field.dirty = False
-            fields.append((ui_field,label,value_as_string))
+            fields.append((ui_field, label, value_as_string))
         return fields
 
     def has_forms(self):
         return self.GetCount()
 
     def toggle_form_item(self, item, event):
-        root        = self.GetRootItem()
+        root = self.GetRootItem()
         if item == root:
             event.Skip()
         else:
-            parent  = self.GetItemParent(item)
+            parent = self.GetItemParent(item)
             if parent == root:
-                image   =  self.GetItemImage(item,wx.TreeItemIcon_Normal)
+                image = self.GetItemImage(item, wx.TreeItemIcon_Normal)
                 if image != -1:
                     self.enable_form_item(item,
                         not self.is_form_enabled(item))
                     self.set_dirty(True)
 
-    def set_form_field_value(self,item, value_as_string):
-        label, old      = self.GetPyData(item)
-        form            = self.get_form(item,label)
-        field           = form._get_field(label)
+    def set_form_field_value(self, item, value_as_string):
+        label, old = self.GetPyData(item)
+        form = self.get_form(item, label)
+        field = form._get_field(label)
         value_as_string = field.fix_string(value_as_string)
         if value_as_string != old:
-            #test-validate the user input (see formField.Field.get)
+            # test-validate the user input (see formField.Field.get)
             try:
-                if isinstance(field,formField.PixelField):
-                    field.get_size(IMAGE_TEST_INFO, 100, 100,label,
+                if isinstance(field, formField.PixelField):
+                    field.get_size(IMAGE_TEST_INFO, 100, 100, label,
                         value_as_string)
-                    #100 is just some dummy value for base, dpi
+                    # 100 is just some dummy value for base, dpi
                 else:
                     field.get(IMAGE_TEST_INFO, label=label,
                         value_as_string=value_as_string, test=True)
                 self.set_dirty(True)
             except formField.ValidationError, details:
-                reason  = exception_to_unicode(details,WX_ENCODING)
+                reason = exception_to_unicode(details, WX_ENCODING)
                 self.show_error(reason)
                 if formField.Field.safe:
                     return
             if value_as_string == '':
-                #hack, fix me
+                # hack, fix me
                 value_as_string = ' '
-            self.SetPyData(item,(label,value_as_string))
-            self.SetItemText(item,self.tree_label(label,value_as_string))
-            form.set_field_as_string(label,value_as_string)
+            self.SetPyData(item, (label, value_as_string))
+            self.SetItemText(item, self.tree_label(label, value_as_string))
+            form.set_field_as_string(label, value_as_string)
 
-    def set_form_field_value_selected(self,value):
-        item    = self.GetSelection()
+    def set_form_field_value_selected(self, value):
+        item = self.GetSelection()
         if self.GetItemParent(item) == self.GetRootItem():
             return
         if item and self.GetPyData(item):
             field = self.get_form_field(item)
-            if not (isinstance(field,formField.ChoiceField) \
-                or  isinstance(field,formField.BooleanField) \
-                or  isinstance(field,formField.ColorField) \
-                or  isinstance(field,formField.SliderField)):
-                self.set_form_field_value(item,value)
+            if not (isinstance(field, formField.ChoiceField) \
+                or  isinstance(field, formField.BooleanField) \
+                or  isinstance(field, formField.ColorField) \
+                or  isinstance(field, formField.SliderField)):
+                self.set_form_field_value(item, value)
 
-    #---selected form
-    def append_form_by_label_to_selected(self,label):
-        item    = self.get_form_selected()
-        return self.append_form_by_label(item,label)
+    # ---selected form
+    def append_form_by_label_to_selected(self, label):
+        item = self.get_form_selected()
+        return self.append_form_by_label(item, label)
 
     def enable_selected_form(self, bool):
-        self.enable_form_item(self.get_form_selected(),bool)
+        self.enable_form_item(self.get_form_selected(), bool)
 
     def get_form_selected(self):
         if self.has_forms():
@@ -320,121 +330,124 @@
     def move_form_selected_up(self):
         self.MoveChildUp(self.get_form_selected())
 
-    def update_form_relevance(self,field_item):
+    def update_form_relevance(self, field_item):
         """Conditional form"""
-        item        = self.get_form_item(field_item)
-        form        = self.GetPyData(item)
-        if not hasattr(form,'get_relevant_field_labels'):
+        item = self.get_form_item(field_item)
+        form = self.GetPyData(item)
+        if not hasattr(form, 'get_relevant_field_labels'):
             return False
-        all         = form._get_fields()
-        relevant    = form.get_relevant_field_labels()
-        ui_index    = 0
-        ui          = self.get_form_fields_visible(item, form)
-        ui_labels                               = [f[1] for f in ui]
-        ui_field,ui_label,ui_value_as_string    = get_index(ui,ui_index)
-        ui_field_prev                           = None
-        #print '_'*40
+        all = form._get_fields()
+        relevant = form.get_relevant_field_labels()
+        ui_index = 0
+        ui = self.get_form_fields_visible(item, form)
+        ui_labels = [f[1] for f in ui]
+        ui_field, ui_label, ui_value_as_string = get_index(ui, ui_index)
+        ui_field_prev = None
+        # print '_'*40
         for label, field in all.items():
             if not field.visible:
                 continue
-            #print 'item=',item, ', label=',label, ', ui_field=',field, ', ui_label=',ui_label, ', child =',self.ItemHasChildren(item), ', prev =',ui_field_prev
-            #print
+            # print 'item=', item, ', label=', label, ', ui_field=', field, ',\
+            #   ui_label=', ui_label, ', child =', self.ItemHasChildren(item),\
+            #   ', prev =', ui_field_prev
+            # print
             next_ui = False
             deleted = False
-            #relevant
+            # relevant
             if label in relevant:
                 if label == ui_label:
-                    #already there
+                    # already there
                     next_ui = True
                 elif ui_field_prev:
-                    #insert after previous ui field
-                    #print 'prev value',self.GetPyData(ui_field_prev)
-                    ui_field_prev = self.append_field(item,label,field,
+                    # insert after previous ui field
+                    # print 'prev value', self.GetPyData(ui_field_prev)
+                    ui_field_prev = self.append_field(item, label, field,
                         self.InsertItem, ui_field_prev)
                 elif self.ItemHasChildren(item):
-                    #insert before first ui field
-                    ui_field_prev = self.append_field(item,label,field,
-                        self.InsertItemBefore,self.GetFirstChild(item))
+                    # insert before first ui field
+                    ui_field_prev = self.append_field(item, label, field,
+                        self.InsertItemBefore, self.GetFirstChild(item))
                 else:
-                    #append as first element
-                    ui_field_prev = self.append_field(item,label,field)
-            #not relevant
+                    # append as first element
+                    ui_field_prev = self.append_field(item, label, field)
+            # not relevant
             elif label in ui_labels:
-                #save values
-                form.set_field_as_string(ui_label,ui_value_as_string)
-                #remove
+                # save values
+                form.set_field_as_string(ui_label, ui_value_as_string)
+                # remove
                 self.Delete(ui_field)
                 next_ui = True
                 deleted = True
-            #next ui
+            # next ui
             if next_ui:
                 if ui_field and not deleted:
-                    #deleted: we don't want to reference to dead objects
+                    # deleted: we don't want to reference to dead objects
                     ui_field_prev = ui_field
                 ui_index += 1
-                ui_field,ui_label,ui_value_as_string = \
-                    get_index(ui,ui_index)
+                ui_field, ui_label, ui_value_as_string = \
+                    get_index(ui, ui_index)
         return True
 
     def remove_selected_form(self):
-        form  = self.get_form_selected()
+        form = self.get_form_selected()
         if form is -1:
             return False
         else:
             self.Delete(form)
             return True
 
-    #---last form
-    def append_form_by_label_to_last(self,label):
-        item    = self.get_last_form()
-        self.append_form_by_label(item,label)
+    # ---last form
+    def append_form_by_label_to_last(self, label):
+        item = self.get_last_form()
+        self.append_form_by_label(item, label)
 
     def get_last_form(self):
         return self.GetLastChild(self.GetRootItem())
 
-    #---popup
-    def create_popup(self,item):
+    # ---popup
+    def create_popup(self, item):
         """Connect formField.field to popup.Ctrl (VIP!)"""
-        field               = self.get_form_field(item)
-        label, value        = self.GetItemText(item).split(FIELD_DELIMITER,1)
-        pos, offset, size   = self.get_popup_pos_offset_size(item)
-        typ                 = field.__class__.__name__.replace('Field','')
+        field = self.get_form_field(item)
+        label, value = self.GetItemText(item).split(FIELD_DELIMITER, 1)
+        pos, offset, size = self.get_popup_pos_offset_size(item)
+        typ = field.__class__.__name__.replace('Field', '')
+
         def on_change(value_as_string):
             field.set_as_string(value_as_string)
             self.update_form_relevance(item)
-        if isinstance(field,formField.SliderField):
-            extra   = {'minValue' : field.min, 'maxValue' : field.max}
-        elif isinstance(field,formField.ChoiceField):
-            extra   = {'choices' : field.choices, 'on_change':on_change}
-            typ     = 'Choice'
-        elif isinstance(field,formField.DictionaryReadFileField):
+        if isinstance(field, formField.SliderField):
+            extra = {'minValue': field.min, 'maxValue': field.max}
+        elif isinstance(field, formField.ChoiceField):
+            extra = {'choices': field.choices, 'on_change': on_change}
+            typ = 'Choice'
+        elif isinstance(field, formField.DictionaryReadFileField):
             if field.dictionary is None:
                 field.init_dictionary()
-            extra   = {'extensions' : field.extensions,
+            extra = {'extensions': field.extensions,
                         'dictionary': field.dictionary}
-            if isinstance(field,formField.ImageDictionaryField):
+            if isinstance(field, formField.ImageDictionaryField):
                 extra['show_path'] = False
                 extra['on_change'] = on_change
-            if isinstance(field,formField.ImageDictionaryReadFileField):
+            if isinstance(field, formField.ImageDictionaryReadFileField):
                 typ = 'ImageDictionaryFile'
                 extra['dialog'] = field.dialog
                 extra['icon_size'] = field.icon_size
-            elif not isinstance(field,formField.FontFileField):
+            elif not isinstance(field, formField.FontFileField):
                 typ = 'DictionaryFile'
-        elif isinstance(field,formField.FileField):
-            extra   = {'extensions' : field.extensions}
-            typ     = 'LabelFile'
-        elif hasattr(field,'choices'):
-            extra   = {'choices' : field.choices, 'on_change':on_change}
-        elif isinstance(field,formField.BooleanField):
-            extra   = {'on_change':on_change}
+        elif isinstance(field, formField.FileField):
+            extra = {'extensions': field.extensions}
+            typ = 'LabelFile'
+        elif hasattr(field, 'choices'):
+            extra = {'choices': field.choices, 'on_change': on_change}
+        elif isinstance(field, formField.BooleanField):
+            extra = {'on_change': on_change}
         else:
-            extra   = {}
-        self.popup_item     = item
-        self.popup          = popup.EditPanel(self, pos = pos, offset = offset,
-                                size = size, label = _(label) + FIELD_DELIMITER,
-                                value = value, extra = extra, typ = typ,
-                                border = 1, CtrlMixin   = self.CtrlMixin)
+            extra = {}
+        self.popup_item = item
+        self.popup = popup.EditPanel(self, pos=pos, offset=offset,
+                                size=size, label=_(label) + FIELD_DELIMITER,
+                                value=value, extra=extra, typ=typ,
+                                border=1, CtrlMixin=self.CtrlMixin)
         self.popup.Show()
         self.resize_popup()
         if not isinstance(field, formField.FontFileField):
@@ -443,12 +456,12 @@
             self.evt_leave_window = True
 
     def create_popup_selected(self):
-        item    = self.GetSelection()
+        item = self.GetSelection()
         if self.GetItemParent(item) == self.GetRootItem():
             return
         self.create_popup(item)
 
-    def close_popup(self,event=None):
+    def close_popup(self, event=None):
         frame = wx.GetTopLevelParent(self)
         if frame and self.evt_leave_window:
             frame.Unbind(wx.EVT_LEAVE_WINDOW)
@@ -456,48 +469,49 @@
         if self.popup:
             value_as_string = self.popup.Close()
             self.set_form_field_value(self.popup_item, value_as_string)
-            #self.update_form_relevance(self.popup_item)
-        self.popup  = self.popup_item = None
-
-##    This would be logical but only works in wxPython2.6
-##    def get_popup_pos_offset_size(self, item):
-##        text_only_rect  = self.GetBoundingRect(item,textOnly=True)
-##        rect            = self.GetBoundingRect(item,textOnly=False)
-##        pos             = rect.GetPosition()
-##        size            = rect.GetSize()
-##        offset          = text_only_rect.GetPosition()[0] - pos[0]
-##        print self.GetClientSize(),self.GetSize(),self.GetRect(),text_only_rect,rect
-##        return pos, offset, size
-##
-
-    #A bit unlogical but works both in wxPython2.6 and 2.8
+            # self.update_form_relevance(self.popup_item)
+        self.popup = self.popup_item = None
+
+# #    This would be logical but only works in wxPython2.6
+# #    def get_popup_pos_offset_size(self, item):
+# #        text_only_rect = self.GetBoundingRect(item, textOnly=True)
+# #        rect = self.GetBoundingRect(item, textOnly=False)
+# #        pos = rect.GetPosition()
+# #        size = rect.GetSize()
+# #        offset = text_only_rect.GetPosition()[0] - pos[0]
+# #        print self.GetClientSize(), self.GetSize(), self.GetRect(),\
+# #                                                text_only_rect, rect
+# #        return pos, offset, size
+# #
+
+    # A bit unlogical but works both in wxPython2.6 and 2.8
     def get_popup_pos_offset_size(self, item):
-        text_only_rect  = self.GetBoundingRect(item,textOnly=True)
-        rect            = self.GetRect()
-        pos             = rect[0],text_only_rect[1]
-        offset          = text_only_rect[0]-rect[0]
-        size            = self.GetClientSize()[0],text_only_rect.GetSize()[1]
+        text_only_rect = self.GetBoundingRect(item, textOnly=True)
+        rect = self.GetRect()
+        pos = rect[0], text_only_rect[1]
+        offset = text_only_rect[0] - rect[0]
+        size = self.GetClientSize()[0], text_only_rect.GetSize()[1]
         return pos, offset, size
 
     def resize_popup(self):
         if not(self.popup is None):
-            item                = self.GetSelection()
-            pos, offset, size   = self.get_popup_pos_offset_size(item)
-            popup               = self.popup
+            item = self.GetSelection()
+            pos, offset, size = self.get_popup_pos_offset_size(item)
+            popup = self.popup
             popup.Freeze()
             popup.SetSize(size)
             popup.SetPosition(pos)
             popup.Layout()
             popup.Thaw()
 
-    #---events
+    # ---events
     def events(self):
-        #events
+        # events
         self.Bind(wx.EVT_TREE_SEL_CHANGING, self.on_sel_changing, self)
         self.Bind(wx.EVT_TREE_SEL_CHANGED, self.on_sel_changed, self)
         self.Bind(wx.EVT_TREE_ITEM_ACTIVATED, self.on_item_activated, self)
-        self.Bind(wx.EVT_TREE_ITEM_RIGHT_CLICK,self.on_select,self)
-        self.Bind(wx.EVT_LEFT_DOWN,self.on_left_down,self)
+        self.Bind(wx.EVT_TREE_ITEM_RIGHT_CLICK, self.on_select, self)
+        self.Bind(wx.EVT_LEFT_DOWN, self.on_left_down, self)
 
     def enable_collapse_automatic(self, state):
         if state:
@@ -516,135 +530,139 @@
             if child != item and self.IsExpanded(child):
                 self.Collapse(child)
 
-    def on_left_down(self,event):
+    def on_left_down(self, event):
         self.close_popup()
         event.Skip()
 
-    def on_item_activated(self,event):
-        item        = event.GetItem()
+    def on_item_activated(self, event):
+        item = event.GetItem()
         if self.is_form(item):
             self.toggle_form_item(item, event)
         else:
             self.on_sel_changed(event)
 
-    def on_sel_changing(self,event):
+    def on_sel_changing(self, event):
         self.close_popup()
 
-    def on_sel_changed(self,event):
+    def on_sel_changed(self, event):
         self.close_popup()
-        item                    = event.GetItem()
-        self._field_selected    = self.is_field(item)
+        item = event.GetItem()
+        self._field_selected = self.is_field(item)
         if self._field_selected:
             self.create_popup(item)
         elif self.collapse_automatic:
-            #maybe better always
+            # maybe better always
             self.Expand(item)
 
-    def on_select(self,event):
+    def on_select(self, event):
         self.on_sel_changing(event)
-        self.SelectItem(event.GetItem(),True)
+        self.SelectItem(event.GetItem(), True)
         event.Skip()
 
-    #---checks
-    def is_field(self,item):
-        return self.GetItemParent(item)!= self.GetRootItem() and \
+    # ---checks
+    def is_field(self, item):
+        return self.GetItemParent(item) != self.GetRootItem() and \
                 item != self.GetRootItem()
 
     def is_field_selected(self):
         return self._field_selected
 
-    def is_form(self,item):
-        return self.GetItemParent(item)== self.GetRootItem()
+    def is_form(self, item):
+        return self.GetItemParent(item) == self.GetRootItem()
 
-    def is_form_enabled(self,item):
-        form              = self.GetPyData(item)
-        return self.GetItemImage(item,wx.TreeItemIcon_Normal) == form.icon_tree_id[True]
+    def is_form_enabled(self, item):
+        form = self.GetPyData(item)
+        return self.GetItemImage(item, wx.TreeItemIcon_Normal) ==\
+                                            form.icon_tree_id[True]
 
     def is_form_selected(self):
         return not self._field_selected
 
+
 def example():
     global _
     _ = str
     import sys
 
     class Form1(formField.Form):
-        label   = 'form1'
+        label = 'form1'
+
         def __init__(self):
             formField.Form.__init__(self,
-                foo1=formField.ChoiceField(value='a',choices=('a','b')))
+                foo1=formField.ChoiceField(value='a', choices=('a', 'b')))
 
     class Form2(formField.Form):
-        label   = 'form2'
+        label = 'form2'
+
         def __init__(self):
             formField.Form.__init__(self,
                 foo2=formField.PixelField(value='100'))
 
     class Form3(formField.Form):
-        label   = 'form3'
+        label = 'form3'
+
         def __init__(self):
             formField.Form.__init__(self,
                 foo2=formField.FileSizeField(value='100'))
 
-    form_factory    = {
-        'form1' : Form1,
-        'form2' : Form2,
-        'form3' : Form3,
+    form_factory = {
+        'form1': Form1,
+        'form2': Form2,
+        'form3': Form3,
     }
-    form4   = formField.Form(foo3=formField.SliderField(value='100',
-                    minValue=0,maxValue=100))
-    forms   = [x() for x in form_factory.values()] #+ [form4]
-
-    class Tree(wx.TreeCtrl,TreeMixin):
-
-        def __init__(self,parent,form_factory,*args,**keyw):
+    form4 = formField.Form(foo3=formField.SliderField(value='100',
+                    minValue=0, maxValue=100))
+    forms = [x() for x in form_factory.values()]  # + [form4]
+
+    class Tree(wx.TreeCtrl, TreeMixin):
+
+        def __init__(self, parent, form_factory, *args, **keyw):
 
             class I18n_CtrlMixin:
                 """Fake example of a Mixin"""
-                _to_local   = str
+                _to_local = str
                 _to_english = str
-                _to_local   = staticmethod(_to_local)
+                _to_local = staticmethod(_to_local)
                 _to_english = staticmethod(_to_english)
 
-            wx.TreeCtrl.__init__(self,parent,style=TR_DEFAULT_STYLE,*args,**keyw)
+            wx.TreeCtrl.__init__(self, parent, style=TR_DEFAULT_STYLE, *args,\
+                                                                        **keyw)
             TreeMixin.__init__(self,
-                form_factory= form_factory,
-                CtrlMixin   = I18n_CtrlMixin,
-                icon_size   = (28,28),
-                show_error  = parent.show_error,
-                set_dirty   = parent.set_dirty,
-            )
+                form_factory=form_factory,
+                CtrlMixin=I18n_CtrlMixin,
+                icon_size=(28, 28),
+                show_error=parent.show_error,
+                set_dirty=parent.set_dirty,)
 
     class Frame(wx.Frame):
-        def show_error(self,message):
+        def show_error(self, message):
             sys.stdout.write(message + '\n')
 
-        def set_dirty(self,bool):
-            self.SetTitle(['','*'][bool] + 'treeEdit test')
+        def set_dirty(self, bool):
+            self.SetTitle(['', '*'][bool] + 'treeEdit test')
 
     class App(wx.App):
-        def OnInit(self,*args,**keyw):
-            frame       = Frame(None)
+        def OnInit(self, *args, **keyw):
+            frame = Frame(None)
             frame.set_dirty(False)
 
-            sizer       = wx.BoxSizer(wx.VERTICAL)
-            self.tree   = Tree(frame,form_factory)
+            sizer = wx.BoxSizer(wx.VERTICAL)
+            self.tree = Tree(frame, form_factory)
             self.tree.append_forms(forms)
-            sizer.Add(self.tree,proportion=1, flag=wx.EXPAND)
+            sizer.Add(self.tree, proportion=1, flag=wx.EXPAND)
             frame.SetSizer(sizer)
             sizer.Fit(frame)
 
-            frame.SetSize((300,300))
+            frame.SetSize((300, 300))
             frame.Layout()
             frame.Show()
             self.SetTopWindow(frame)
             return True
 
-
     app = App(0)
     app.MainLoop()
 
-#---disabled
+# ---disabled
 ICON_DISABLED = \
 'x\xda\x01I\x03\xb6\xfc\x89PNG\r\n\x1a\n\x00\x00\x00\rIHDR\x00\x00\x00\x1c\
 \x00\x00\x00\x1c\x08\x06\x00\x00\x00r\r\xdf\x94\x00\x00\x00\x04sBIT\x08\x08\

=== modified file 'phatch/lib/pyWx/wildcard.py'
--- phatch/lib/pyWx/wildcard.py	2010-03-06 18:12:03 +0000
+++ phatch/lib/pyWx/wildcard.py	2010-03-07 00:55:24 +0000
@@ -12,7 +12,8 @@
 #
 # You should have received a copy of the GNU General Public License
 # along with this program.  If not, see http://www.gnu.org/licenses/
-
+#
+# Follow PEP8
 import sys
 
 

=== modified file 'phatch/lib/pyWx/wxcheck.py'
--- phatch/lib/pyWx/wxcheck.py	2010-02-24 21:00:07 +0000
+++ phatch/lib/pyWx/wxcheck.py	2010-03-07 00:55:24 +0000
@@ -9,22 +9,26 @@
 # but WITHOUT ANY WARRANTY; without even the implied warranty of
 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 # GNU General Public License for more details.
-# 
+#
 # You should have received a copy of the GNU General Public License
 # along with this program.  If not, see http://www.gnu.org/licenses/
+#
+# Follow PEP8
 
 import os
 import sys
 from subprocess import call
 from lib.unicoding import ENCODING
 
+
 def _t(x):
-    return _(x).encode(ENCODING,'replace')
-
-def ensure(recommended,minimal):
+    return _(x).encode(ENCODING, 'replace')
+
+
+def ensure(recommended, minimal):
     """Ensures the minimal version of wxPython is installed.
     - minimal: as string (eg. '2.6')"""
-    
+
     #wxversion
     try:
         import wxversion
@@ -36,31 +40,42 @@
         return wx
     except ImportError:
         sys.stdout.write(_t('Warning: python-wxversion is not installed.\n'))
-        
+
     #wxversion failed, import wx anyway
-    params = {'recommended':recommended, 'minimal':minimal} 
+    params = {'recommended': recommended, 'minimal': minimal}
     try:
         import wx
     except ImportError:
-        message = _t('Error: wxPython %(recommended)s (or at least %(minimal)s) can not be found, but is required.')%params +\
+        message = _t('Error: wxPython %(recommended)s' + \
+                                ' (or at least %(minimal)s) can not' + \
+                                ' be found, but is required.'
+                            ) % params +\
             '\n\n' + _t('Please (re)install it.')
         sys.stderr.write(message)
         if sys.platform.startswith('linux') and \
                 os.path.exists('/usr/bin/zenity'):
-            call('''zenity --error --text="%s"\n\n'''%message +\
-                _t('''This application needs 'python-wxversion' and 'python-wxgtk%(recommended)s' (or at least 'python-wxgtk%(minimal)s').''')%params,shell=True)
+            call('''zenity --error --text="%s"\n\n''' % message + \
+                _t('''This application needs 'python-wxversion' ''' + \
+                    '''and 'python-wxgtk%(recommended)s' ''' + \
+                    '''(or at least 'python-wxgtk%(minimal)s').'''
+                    ) % params, shell=True)
         sys.exit()
-        
+
     #wxversion failed but wx is available, check version again
-    params['version']   = wx.VERSION_STRING
-    if wx.VERSION_STRING < minimal: 
+    params['version'] = wx.VERSION_STRING
+    if wx.VERSION_STRING < minimal:
+
         class MyApp(wx.App):
             def OnInit(self):
                 result = wx.MessageBox(
-                    _t("This application is known to be compatible with\nwxPython version(s) %(recommended)s (or at least %(minimal)s),\nbut you have %(version)s installed.")%params + "\n\n" +\
+                    _t("This application is known to be compatible" + \
+                        " with\nwxPython version(s) %(recommended)s" + \
+                        " (or at least %(minimal)s),\nbut you have " + \
+                        "%(version)s installed."
+                        ) % params + "\n\n" +\
                     _t("Please upgrade your wxPython."),
                     _t("wxPython Version Error"),
-                    style   = wx.ICON_ERROR)
+                    style=wx.ICON_ERROR)
                 return False
         app = MyApp()
         app.MainLoop()

=== modified file 'phatch/pyWx/__init__.py'
--- phatch/pyWx/__init__.py	2010-03-06 17:13:56 +0000
+++ phatch/pyWx/__init__.py	2010-03-07 00:55:24 +0000
@@ -15,3 +15,5 @@
 # along with this program.  If not, see http://www.gnu.org/licenses/
 #
 # Phatch recommends SPE (http://pythonide.stani.be) for editing python files.
+#
+# Follow PEP8

=== modified file 'phatch/pyWx/images.py'
--- phatch/pyWx/images.py	2010-03-06 17:40:31 +0000
+++ phatch/pyWx/images.py	2010-03-07 00:55:24 +0000
@@ -15,7 +15,7 @@
 # along with this program.  If not, see http://www.gnu.org/licenses/
 #
 # Phatch recommends SPE (http://pythonide.stani.be) for editing python files.
-
+# Follow PEP8
 # Embedded images are specially designed by Igor Kekeljevic for Phatch.
 
 import sys

=== modified file 'phatch/pyWx/nuovext.py'
--- phatch/pyWx/nuovext.py	2010-03-06 17:13:32 +0000
+++ phatch/pyWx/nuovext.py	2010-03-07 00:55:24 +0000
@@ -21,6 +21,8 @@
 # - Icon download: http://www.gnome-look.org/content/download.php?
 # content=26448&id=1&tan=15504822&PHPSESSID=34ec3de1af33e253ee03357a124bfbeb
 # - License: GPL
+#
+# Follow PEP8
 
 import wx
 from lib.pyWx import graphics

=== modified file 'phatch/pyWx/plugin.py'
--- phatch/pyWx/plugin.py	2010-03-06 17:10:25 +0000
+++ phatch/pyWx/plugin.py	2010-03-07 00:55:24 +0000
@@ -17,6 +17,9 @@
 # along with this program.  If not, see http://www.gnu.org/licenses/
 #
 # Phatch recommends SPE (http://pythonide.stani.be) for editing python files.
+#
+# Follow PEP8
+
 import os
 import sys
 import wx

=== modified file 'phatch/pyWx/wxGlade/__init__.py'
--- phatch/pyWx/wxGlade/__init__.py	2010-03-06 17:14:22 +0000
+++ phatch/pyWx/wxGlade/__init__.py	2010-03-07 00:55:24 +0000
@@ -15,3 +15,5 @@
 # along with this program.  If not, see http://www.gnu.org/licenses/
 #
 # Phatch recommends SPE (http://pythonide.stani.be) for editing python files.
+#
+# Follow PEP8