eric: comparison Templates/TemplateViewer.py

-:1b59c4ba121e
+:8cd4d08fa9f6
 from E5XML.TemplatesReader import TemplatesReader
 from E5XML.TemplatesWriter import TemplatesWriter
 import UI.PixmapCache
 import Utilities
 class TemplateGroup(QTreeWidgetItem):
 """
 Class implementing a template group.
 """
-def __init__(self, parent, name, language = "All"):
+def __init__(self, parent, name, language="All"):
 """
 Constructor
 @param parent parent widget of the template group (QWidget)
 @param name name of the group (string)
 @return language of the group (string)
 """
 return self.language
-def addEntry(self, name, description, template, quiet = False):
+def addEntry(self, name, description, template, quiet=False):
 """
 Public method to add a template entry to this group.
 @param name name of the entry (string)
 @param description description of the entry to add (string)
 except KeyError:
 return None
 def getEntryNames(self, beginning):
 """
 Public method to get the names of all entries, who's name starts with the
 given string.
 @param beginning string denoting the beginning of the template name
 (string)
 @return list of entry names found (list of strings)
 Public method to retrieve all entries.
 @return list of all entries (list of TemplateEntry)
 """
 return list(self.entries.values())
 class TemplateEntry(QTreeWidgetItem):
 """
 Class immplementing a template entry.
 """
 """
 Public method to get the template text with all variables expanded.
 @param varDict dictionary containing the texts of each variable
 with the variable name as key.
 @param indent indentation of the line receiving he expanded
 template text (string)
 @return a tuple of the expanded template text (string), the
 number of lines (integer) and the length of the last line (integer)
 """
 txt = self.template
 ind = line.find(var)
 if ind >= 0:
 format = var[1:-1].split(':', 1)[1]
 if format == 'rl':
 prefix = line[:ind]
-postfix = line [ind + len(var):]
+postfix = line[ind + len(var):]
 for v in val.splitlines():
 t = "{0}{1}{2}{3}{4}".format(t, os.linesep, prefix, v, postfix)
 elif format == 'ml':
 indent = line.replace(line.lstrip(), "")
 prefix = line[:ind]
 if not var in self.variables:
 self.variables.append(var)
 if var.find(':') >= 0 and not var in self.formatedVariables:
 self.formatedVariables.append(var)
 class TemplateViewer(QTreeWidget):
 """
 Class implementing the template viewer.
 """
 def __init__(self, parent, viewmanager):
 """
 Private method to resort the tree.
 """
 self.sortItems(self.sortColumn(), self.header().sortIndicatorOrder())
-def __templateItemActivated(self, itm = None, col = 0):
+def __templateItemActivated(self, itm=None, col=0):
 """
 Private slot to handle the activation of an item.
 @param itm reference to the activated item (QTreeWidgetItem)
 @param col column the item was activated in (integer)
 """
 itm = self.currentItem()
 txt = "'Insertion and selection can not be in template together'"
 if "i_n_s_e_r_t_i_o_n" in txt:
 lines = 1
 for aline in txt.splitlines():
-count =  aline.find("i_n_s_e_r_t_i_o_n")
+count = aline.find("i_n_s_e_r_t_i_o_n")
 if count >= 0:
 txt = txt.replace("i_n_s_e_r_t_i_o_n",  "")
 if lines == 1:
 count += index
 else:
 setselect = False
 if "s_e_l_e_c_t_s_t_a_r_t" in txt and "s_e_l_e_c_t_e_n_d" in txt:
 setselect = True
 linea = 1
 for aline in txt.splitlines():
-posa =  aline.find("s_e_l_e_c_t_s_t_a_r_t")
+posa = aline.find("s_e_l_e_c_t_s_t_a_r_t")
 if posa >= 0:
 txt = txt.replace("s_e_l_e_c_t_s_t_a_r_t",  "")
 break
 else:
 linea += 1
 lineb = 1
 for aline in txt.splitlines():
-posb =  aline.find("s_e_l_e_c_t_e_n_d")
+posb = aline.find("s_e_l_e_c_t_e_n_d")
 if posb >= 0:
 txt = txt.replace("s_e_l_e_c_t_e_n_d",  "")
 break
 else:
 lineb += 1
 editor.insert(txt)
 if setselect:
 editor.setSelection(line + linea - 1, posa, line + lineb - 1, posb)
 template = group.getEntry(templateName)
 if template is not None:
 self.applyTemplate(template)
 break
-def addEntry(self, groupName, name, description, template, quiet = False):
+def addEntry(self, groupName, name, description, template, quiet=False):
 """
 Public method to add a template entry.
 @param groupName name of the group to add to (string)
 @param name name of the entry to add (string)
 @param description description of the entry to add (string)
 @param template template text of the entry (string)
 @param quiet flag indicating quiet operation (boolean)
 """
-self.groups[groupName].addEntry(name, description, template, quiet = quiet)
+self.groups[groupName].addEntry(name, description, template, quiet=quiet)
 self.__resort()
-def addGroup(self, name, language = "All"):
+def addGroup(self, name, language="All"):
 """
 Public method to add a group.
 @param name name of the group to be added (string)
 @param language programming language for the group (string)
 """
 if name not in self.groups:
 self.groups[name] = TemplateGroup(self, name, language)
 self.__resort()
-def changeGroup(self, oldname, newname, language = "All"):
+def changeGroup(self, oldname, newname, language="All"):
 """
 Public method to rename a group.
 @param oldname old name of the group (string)
 @param newname new name of the group (string)
 tmpl = self.groups[groupName].getEntry(name)
 tmpl.setDescription(description)
 tmpl.setTemplateText(template)
 self.__resort()
-def writeTemplates(self, filename = None):
+def writeTemplates(self, filename=None):
 """
 Public method to write the templates data to an XML file (.e4c).
 @param filename name of a templates file to read (string)
 """
 return
 TemplatesWriter(f, self).writeXML()
 f.close()
-def readTemplates(self, filename = None):
+def readTemplates(self, filename=None):
 """
 Public method to read in the templates file (.e4c)
 @param filename name of a templates file to read (string)
 """
 if not os.path.exists(filename):
 return
 f = QFile(filename)
 if f.open(QIODevice.ReadOnly):
-reader = TemplatesReader(f, viewer = self)
+reader = TemplatesReader(f, viewer=self)
 reader.readXML()
 f.close()
 else:
 E5MessageBox.critical(self,
 self.trUtf8("Read templates"),

Mercurial Repositories > eric / file comparison

comparison: Templates/TemplateViewer.py

Templates/TemplateViewer.py