Did some more string format conversions.

Tue, 27 Jul 2010 09:10:10 +0200

author
Detlev Offenbach <detlev@die-offenbachs.de>
date
Tue, 27 Jul 2010 09:10:10 +0200
changeset 411
99409cddaaa9
parent 410
e5d1addeb90c
child 412
569efd7f2716

Did some more string format conversions.

E5XML/DebuggerPropertiesWriter.py file | annotate | diff | comparison | revisions
E5XML/HighlightingStylesWriter.py file | annotate | diff | comparison | revisions
E5XML/MultiProjectWriter.py file | annotate | diff | comparison | revisions
E5XML/ProjectHandler.py file | annotate | diff | comparison | revisions
E5XML/ProjectWriter.py file | annotate | diff | comparison | revisions
E5XML/SessionWriter.py file | annotate | diff | comparison | revisions
E5XML/ShortcutsWriter.py file | annotate | diff | comparison | revisions
diff -r e5d1addeb90c -r 99409cddaaa9 E5XML/DebuggerPropertiesWriter.py
--- a/E5XML/DebuggerPropertiesWriter.py	Tue Jul 27 08:25:53 2010 +0200
+++ b/E5XML/DebuggerPropertiesWriter.py	Tue Jul 27 09:10:10 2010 +0200
@@ -39,53 +39,54 @@
         """
         XMLWriterBase.writeXML(self)
         
-        self._write('<!DOCTYPE DebuggerProperties SYSTEM "DebuggerProperties-%s.dtd">' % \
-            debuggerPropertiesFileFormatVersion)
+        self._write('<!DOCTYPE DebuggerProperties SYSTEM "DebuggerProperties-{0}.dtd">'\
+            .format(debuggerPropertiesFileFormatVersion))
         
         # add some generation comments
-        self._write("<!-- eric5 debugger properties file for project %s -->" % self.name)
+        self._write("<!-- eric5 debugger properties file for project {0} -->"\
+            .format(self.name))
         self._write("<!-- This file was generated automatically, do not edit. -->")
         if Preferences.getProject("XMLTimestamp"):
-            self._write("<!-- Saved: %s -->" % time.strftime('%Y-%m-%d, %H:%M:%S'))
+            self._write("<!-- Saved: {0} -->".format(time.strftime('%Y-%m-%d, %H:%M:%S')))
         
         # add the main tag
-        self._write('<DebuggerProperties version="%s">' % \
-            debuggerPropertiesFileFormatVersion) 
+        self._write('<DebuggerProperties version="{0}">'.format(
+            debuggerPropertiesFileFormatVersion))
         
-        self._write('  <Interpreter>%s</Interpreter>' % \
-            self.project.debugProperties["INTERPRETER"])
+        self._write('  <Interpreter>{0}</Interpreter>'.format(
+            self.project.debugProperties["INTERPRETER"]))
         
-        self._write('  <DebugClient>%s</DebugClient>' % \
-            self.project.debugProperties["DEBUGCLIENT"])
+        self._write('  <DebugClient>{0}</DebugClient>'.format(
+            self.project.debugProperties["DEBUGCLIENT"]))
         
-        self._write('  <Environment override="%d">%s</Environment>' % \
-            (self.project.debugProperties["ENVIRONMENTOVERRIDE"],
-             self.escape(self.project.debugProperties["ENVIRONMENTSTRING"])))
+        self._write('  <Environment override="{0:d}">{1}</Environment>'.format(
+            self.project.debugProperties["ENVIRONMENTOVERRIDE"],
+            self.escape(self.project.debugProperties["ENVIRONMENTSTRING"])))
         
-        self._write('  <RemoteDebugger on="%d">' % \
-            self.project.debugProperties["REMOTEDEBUGGER"])
-        self._write('    <RemoteHost>%s</RemoteHost>' % \
-            self.project.debugProperties["REMOTEHOST"])
-        self._write('    <RemoteCommand>%s</RemoteCommand>' % \
-            self.escape(self.project.debugProperties["REMOTECOMMAND"]))
+        self._write('  <RemoteDebugger on="{0:d}">'.format(
+            self.project.debugProperties["REMOTEDEBUGGER"]))
+        self._write('    <RemoteHost>{0}</RemoteHost>'.format(
+            self.project.debugProperties["REMOTEHOST"]))
+        self._write('    <RemoteCommand>{0}</RemoteCommand>'.format(
+            self.escape(self.project.debugProperties["REMOTECOMMAND"])))
         self._write('  </RemoteDebugger>')
         
-        self._write('  <PathTranslation on="%d">' % \
-            self.project.debugProperties["PATHTRANSLATION"])
-        self._write('    <RemotePath>%s</RemotePath>' % \
-            self.project.debugProperties["REMOTEPATH"])
-        self._write('    <LocalPath>%s</LocalPath>' % \
-            self.project.debugProperties["LOCALPATH"])
+        self._write('  <PathTranslation on="{0:d}">'.format(
+            self.project.debugProperties["PATHTRANSLATION"]))
+        self._write('    <RemotePath>{0}</RemotePath>'.format(
+            self.project.debugProperties["REMOTEPATH"]))
+        self._write('    <LocalPath>{0}</LocalPath>'.format(
+            self.project.debugProperties["LOCALPATH"]))
         self._write('  </PathTranslation>')
         
-        self._write('  <ConsoleDebugger on="%d">%s</ConsoleDebugger>' % \
-            (self.project.debugProperties["CONSOLEDEBUGGER"],
-             self.escape(self.project.debugProperties["CONSOLECOMMAND"])))
+        self._write('  <ConsoleDebugger on="{0:d}">{1}</ConsoleDebugger>'.format(
+            self.project.debugProperties["CONSOLEDEBUGGER"],
+            self.escape(self.project.debugProperties["CONSOLECOMMAND"])))
         
-        self._write('  <Redirect on="%d" />' % \
-            self.project.debugProperties["REDIRECT"])
+        self._write('  <Redirect on="{0:d}" />'.format(
+            self.project.debugProperties["REDIRECT"]))
         
-        self._write('  <Noencoding on="%d" />' % \
-            self.project.debugProperties["NOENCODING"])
+        self._write('  <Noencoding on="{0:d}" />'.format(
+            self.project.debugProperties["NOENCODING"]))
         
         self._write("</DebuggerProperties>", newline = False)
diff -r e5d1addeb90c -r 99409cddaaa9 E5XML/HighlightingStylesWriter.py
--- a/E5XML/HighlightingStylesWriter.py	Tue Jul 27 08:25:53 2010 +0200
+++ b/E5XML/HighlightingStylesWriter.py	Tue Jul 27 09:10:10 2010 +0200
@@ -36,26 +36,26 @@
         """
         XMLWriterBase.writeXML(self)
         
-        self._write('<!DOCTYPE HighlightingStyles SYSTEM "HighlightingStyles-%s.dtd">' % \
-            highlightingStylesFileFormatVersion)
+        self._write('<!DOCTYPE HighlightingStyles SYSTEM "HighlightingStyles-{0}.dtd">'\
+            .format(highlightingStylesFileFormatVersion))
         
         # add some generation comments
         self._write("<!-- Eric5 highlighting styles -->")
-        self._write("<!-- Saved: %s -->" % time.strftime('%Y-%m-%d, %H:%M:%S'))
-        self._write("<!-- Author: %s -->" % self.escape("%s" % self.email))
+        self._write("<!-- Saved: {0} -->".format(time.strftime('%Y-%m-%d, %H:%M:%S')))
+        self._write("<!-- Author: {0} -->".format(self.escape("{0}".format(self.email))))
         
         # add the main tag
-        self._write('<HighlightingStyles version="%s">' % \
-            highlightingStylesFileFormatVersion)
+        self._write('<HighlightingStyles version="{0}">'.format(
+            highlightingStylesFileFormatVersion))
         
         for lexer in self.lexers:
-            self._write('  <Lexer name="%s">' % lexer.language())
+            self._write('  <Lexer name="{0}">'.format(lexer.language()))
             for style in lexer.descriptions:
-                self._write('    <Style style="%d" '
-                            'color="%s" paper="%s" font="%s" eolfill="%d">%s</Style>' % \
-                            (style, lexer.color(style).name(), lexer.paper(style).name(), 
-                             lexer.font(style).toString(), lexer.eolFill(style), 
-                             self.escape(lexer.description(style)))
+                self._write('    <Style style="{0:d}" '
+                    'color="{1}" paper="{2}" font="{3}" eolfill="{4:d}">{5}</Style>'\
+                    .format(style, lexer.color(style).name(), lexer.paper(style).name(), 
+                            lexer.font(style).toString(), lexer.eolFill(style), 
+                            self.escape(lexer.description(style)))
                 )
             self._write('  </Lexer>')
         
diff -r e5d1addeb90c -r 99409cddaaa9 E5XML/MultiProjectWriter.py
--- a/E5XML/MultiProjectWriter.py	Tue Jul 27 08:25:53 2010 +0200
+++ b/E5XML/MultiProjectWriter.py	Tue Jul 27 09:10:10 2010 +0200
@@ -38,32 +38,33 @@
         """
         XMLWriterBase.writeXML(self)
         
-        self._write('<!DOCTYPE MultiProject SYSTEM "MultiProject-%s.dtd">' % \
-            multiProjectFileFormatVersion)
+        self._write('<!DOCTYPE MultiProject SYSTEM "MultiProject-{0}.dtd">'\
+            .format(multiProjectFileFormatVersion))
         
         # add some generation comments
-        self._write("<!-- eric5 multi project file for multi project %s -->" % self.name)
+        self._write("<!-- eric5 multi project file for multi project {0} -->"\
+            .format(self.name))
         if Preferences.getMultiProject("XMLTimestamp"):
-            self._write("<!-- Saved: %s -->" % time.strftime('%Y-%m-%d, %H:%M:%S'))
-            self._write("<!-- Copyright (C) %s -->" % time.strftime('%Y'))
+            self._write("<!-- Saved: {0} -->".format(time.strftime('%Y-%m-%d, %H:%M:%S')))
+            self._write("<!-- Copyright (C) {0} -->".format(time.strftime('%Y')))
         
         # add the main tag
-        self._write('<MultiProject version="%s">' % multiProjectFileFormatVersion)
+        self._write('<MultiProject version="{0}">'.format(multiProjectFileFormatVersion))
         
         # do description
-        self._write("  <Description>%s</Description>" % \
-            self.escape(self.encodedNewLines(self.multiProject.description)))
+        self._write("  <Description>{0}</Description>".format(
+            self.escape(self.encodedNewLines(self.multiProject.description))))
         
         # do the projects
         self._write("  <Projects>")
         for project in self.multiProject.getProjects():
-            self._write('    <Project isMaster="%s">' % project['master'])
-            self._write("      <ProjectName>%s</ProjectName>" % \
-                self.escape(project['name']))
-            self._write("      <ProjectFile>%s</ProjectFile>" % \
-                Utilities.fromNativeSeparators(project['file']))
-            self._write("      <ProjectDescription>%s</ProjectDescription>" % \
-                self.escape(self.encodedNewLines(project['name'])))
+            self._write('    <Project isMaster="{0}">'.format(project['master']))
+            self._write("      <ProjectName>{0}</ProjectName>".format(
+                self.escape(project['name'])))
+            self._write("      <ProjectFile>{0}</ProjectFile>".format(
+                Utilities.fromNativeSeparators(project['file'])))
+            self._write("      <ProjectDescription>{0}</ProjectDescription>".format(
+                self.escape(self.encodedNewLines(project['name']))))
             self._write("    </Project>")
         self._write("  </Projects>")
         
diff -r e5d1addeb90c -r 99409cddaaa9 E5XML/ProjectHandler.py
--- a/E5XML/ProjectHandler.py	Tue Jul 27 08:25:53 2010 +0200
+++ b/E5XML/ProjectHandler.py	Tue Jul 27 09:10:10 2010 +0200
@@ -584,8 +584,8 @@
         else:
             path = self.__buildPath()
         if not path.endswith("_"):
-            path = "%s_" % path
-        self.project.pdata["TRANSLATIONPATTERN"].append("%s%%language%%.ts" % path)
+            path = "{0}_".format(path)
+        self.project.pdata["TRANSLATIONPATTERN"].append("{0}%language%.ts".format(path))
         
     def startEric4DocParams(self, attrs):
         """
diff -r e5d1addeb90c -r 99409cddaaa9 E5XML/ProjectWriter.py
--- a/E5XML/ProjectWriter.py	Tue Jul 27 08:25:53 2010 +0200
+++ b/E5XML/ProjectWriter.py	Tue Jul 27 09:10:10 2010 +0200
@@ -39,125 +39,126 @@
         """
         XMLWriterBase.writeXML(self)
         
-        self._write('<!DOCTYPE Project SYSTEM "Project-%s.dtd">' % \
-            projectFileFormatVersion)
+        self._write('<!DOCTYPE Project SYSTEM "Project-{0}.dtd">'.format(
+            projectFileFormatVersion))
         
         # add some generation comments
-        self._write("<!-- eric5 project file for project %s -->" % self.name)
+        self._write("<!-- eric5 project file for project {0} -->".format(self.name))
         if Preferences.getProject("XMLTimestamp"):
-            self._write("<!-- Saved: %s -->" % time.strftime('%Y-%m-%d, %H:%M:%S'))
-            self._write("<!-- Copyright (C) %s %s, %s -->" % \
-                    (time.strftime('%Y'), 
-                     self.escape(self.pdata["AUTHOR"][0]), 
-                     self.escape(self.pdata["EMAIL"][0])))
+            self._write("<!-- Saved: {0} -->".format(time.strftime('%Y-%m-%d, %H:%M:%S')))
+            self._write("<!-- Copyright (C) {0} {1}, {2} -->".format(
+                    time.strftime('%Y'), 
+                    self.escape(self.pdata["AUTHOR"][0]), 
+                    self.escape(self.pdata["EMAIL"][0])))
         
         # add the main tag
-        self._write('<Project version="%s">' % projectFileFormatVersion)
+        self._write('<Project version="{0}">'.format(projectFileFormatVersion))
         
         # do the language (used for spell checking)
-        self._write('  <Language>%s</Language>' % self.pdata["SPELLLANGUAGE"][0])
+        self._write('  <Language>{0}</Language>'.format(self.pdata["SPELLLANGUAGE"][0]))
         if len(self.pdata["SPELLWORDS"][0]) > 0:
-            self._write("  <ProjectWordList>%s</ProjectWordList>" % \
-                Utilities.fromNativeSeparators(self.pdata["SPELLWORDS"][0]))
+            self._write("  <ProjectWordList>{0}</ProjectWordList>".format(
+                Utilities.fromNativeSeparators(self.pdata["SPELLWORDS"][0])))
         if len(self.pdata["SPELLEXCLUDES"][0]) > 0:
-            self._write("  <ProjectExcludeList>%s</ProjectExcludeList>" % \
-                Utilities.fromNativeSeparators(self.pdata["SPELLEXCLUDES"][0]))
+            self._write("  <ProjectExcludeList>{0}</ProjectExcludeList>".format(
+                Utilities.fromNativeSeparators(self.pdata["SPELLEXCLUDES"][0])))
         
         # do the hash
-        self._write('  <Hash>%s</Hash>' % self.pdata["HASH"][0])
+        self._write('  <Hash>{0}</Hash>'.format(self.pdata["HASH"][0]))
         
         # do the programming language
-        self._write('  <ProgLanguage mixed="%d">%s</ProgLanguage>' % \
-            (self.pdata["MIXEDLANGUAGE"][0], self.pdata["PROGLANGUAGE"][0]))
+        self._write('  <ProgLanguage mixed="{0:d}">{1}</ProgLanguage>'.format(
+            self.pdata["MIXEDLANGUAGE"][0], self.pdata["PROGLANGUAGE"][0]))
         
         # do the UI type
-        self._write('  <ProjectType>%s</ProjectType>' % self.pdata["PROJECTTYPE"][0])
+        self._write('  <ProjectType>{0}</ProjectType>'.format(
+            self.pdata["PROJECTTYPE"][0]))
         
         # do description
         if self.pdata["DESCRIPTION"]:
-            self._write("  <Description>%s</Description>" % \
-                self.escape(self.encodedNewLines(self.pdata["DESCRIPTION"][0])))
+            self._write("  <Description>{0}</Description>".format(
+                self.escape(self.encodedNewLines(self.pdata["DESCRIPTION"][0]))))
         
         # do version, author and email
         for key in ["VERSION", "AUTHOR", "EMAIL"]:
             element = key.capitalize()
             if self.pdata[key]:
-                self._write("  <%s>%s</%s>" % \
-                    (element, self.escape(self.pdata[key][0]), element))
+                self._write("  <{0}>{1}</{0}>".format(
+                    element, self.escape(self.pdata[key][0])))
             
         # do the translation pattern
         if self.pdata["TRANSLATIONPATTERN"]:
-            self._write("  <TranslationPattern>%s</TranslationPattern>" % \
-                Utilities.fromNativeSeparators(self.pdata["TRANSLATIONPATTERN"][0]))
+            self._write("  <TranslationPattern>{0}</TranslationPattern>".format(
+                Utilities.fromNativeSeparators(self.pdata["TRANSLATIONPATTERN"][0])))
         
         # do the binary translations path
         if self.pdata["TRANSLATIONSBINPATH"]:
-            self._write("  <TranslationsBinPath>%s</TranslationsBinPath>" % \
-                Utilities.fromNativeSeparators(self.pdata["TRANSLATIONSBINPATH"][0]))
+            self._write("  <TranslationsBinPath>{0}</TranslationsBinPath>".format(
+                Utilities.fromNativeSeparators(self.pdata["TRANSLATIONSBINPATH"][0])))
         
         # do the eol setting
         if self.pdata["EOL"] and self.pdata["EOL"][0]:
-            self._write('  <Eol index="%d" />' % self.pdata["EOL"][0])
+            self._write('  <Eol index="{0:d}" />'.format(self.pdata["EOL"][0]))
         
         # do the sources
         self._write("  <Sources>")
         for name in self.pdata["SOURCES"]:
-            self._write("    <Source>%s</Source>" % \
-                Utilities.fromNativeSeparators(name))
+            self._write("    <Source>{0}</Source>".format(
+                Utilities.fromNativeSeparators(name)))
         self._write("  </Sources>")
         
         # do the forms
         self._write("  <Forms>")
         for name in self.pdata["FORMS"]:
-            self._write("    <Form>%s</Form>" % \
-                Utilities.fromNativeSeparators(name))
+            self._write("    <Form>{0}</Form>".format(
+                Utilities.fromNativeSeparators(name)))
         self._write("  </Forms>")
         
         # do the translations
         self._write("  <Translations>")
         for name in self.pdata["TRANSLATIONS"]:
-            self._write("    <Translation>%s</Translation>" % \
-                Utilities.fromNativeSeparators(name))
+            self._write("    <Translation>{0}</Translation>".format(
+                Utilities.fromNativeSeparators(name)))
         self._write("  </Translations>")
         
         # do the translation exceptions
         if self.pdata["TRANSLATIONEXCEPTIONS"]:
             self._write("  <TranslationExceptions>")
             for name in self.pdata["TRANSLATIONEXCEPTIONS"]:
-                self._write("    <TranslationException>%s</TranslationException>" % \
-                    Utilities.fromNativeSeparators(name))
+                self._write("    <TranslationException>{0}</TranslationException>".format(
+                    Utilities.fromNativeSeparators(name)))
             self._write("  </TranslationExceptions>")
         
         # do the resources
         self._write("  <Resources>")
         for name in self.pdata["RESOURCES"]:
-            self._write("    <Resource>%s</Resource>" % \
-                Utilities.fromNativeSeparators(name))
+            self._write("    <Resource>{0}</Resource>".format(
+                Utilities.fromNativeSeparators(name)))
         self._write("  </Resources>")
         
         # do the interfaces (IDL)
         self._write("  <Interfaces>")
         for name in self.pdata["INTERFACES"]:
-            self._write("    <Interface>%s</Interface>" % \
-                Utilities.fromNativeSeparators(name))
+            self._write("    <Interface>{0}</Interface>".format(
+                Utilities.fromNativeSeparators(name)))
         self._write("  </Interfaces>")
         
         # do the others
         self._write("  <Others>")
         for name in self.pdata["OTHERS"]:
-            self._write("    <Other>%s</Other>" % \
-                Utilities.fromNativeSeparators(name))
+            self._write("    <Other>{0}</Other>".format(
+                Utilities.fromNativeSeparators(name)))
         self._write("  </Others>")
         
         # do the main script
         if self.pdata["MAINSCRIPT"]:
-            self._write("  <MainScript>%s</MainScript>" % \
-                Utilities.fromNativeSeparators(self.pdata["MAINSCRIPT"][0]))
+            self._write("  <MainScript>{0}</MainScript>".format(
+                Utilities.fromNativeSeparators(self.pdata["MAINSCRIPT"][0])))
         
         # do the vcs stuff
         self._write("  <Vcs>")
         if self.pdata["VCS"]:
-            self._write("    <VcsType>%s</VcsType>" % self.pdata["VCS"][0])
+            self._write("    <VcsType>{0}</VcsType>".format(self.pdata["VCS"][0]))
         if self.pdata["VCSOPTIONS"]:
             self._write("    <VcsOptions>")
             self._writeBasics(self.pdata["VCSOPTIONS"][0], 3)
@@ -171,16 +172,16 @@
         # do the filetype associations
         self._write("  <FiletypeAssociations>")
         for pattern, filetype in list(self.pdata["FILETYPES"].items()):
-            self._write('    <FiletypeAssociation pattern="%s" type="%s" />' % \
-                (pattern, filetype))
+            self._write('    <FiletypeAssociation pattern="{0}" type="{1}" />'.format(
+                pattern, filetype))
         self._write("  </FiletypeAssociations>")
         
         # do the lexer associations
         if self.pdata["LEXERASSOCS"]:
             self._write("  <LexerAssociations>")
             for pattern, lexer in list(self.pdata["LEXERASSOCS"].items()):
-                self._write('    <LexerAssociation pattern="%s" lexer="%s" />' % \
-                    (pattern, lexer))
+                self._write('    <LexerAssociation pattern="{0}" lexer="{1}" />'.format(
+                    pattern, lexer))
             self._write("  </LexerAssociations>")
         
         # do the extra project data stuff
diff -r e5d1addeb90c -r 99409cddaaa9 E5XML/SessionWriter.py
--- a/E5XML/SessionWriter.py	Tue Jul 27 08:25:53 2010 +0200
+++ b/E5XML/SessionWriter.py	Tue Jul 27 09:10:10 2010 +0200
@@ -45,27 +45,27 @@
         
         XMLWriterBase.writeXML(self)
         
-        self._write('<!DOCTYPE Session SYSTEM "Session-%s.dtd">' % \
-            sessionFileFormatVersion)
+        self._write('<!DOCTYPE Session SYSTEM "Session-{0}.dtd">'.format(
+            sessionFileFormatVersion))
         
         # add some generation comments
         if not isGlobal:
-            self._write("<!-- eric5 session file for project %s -->" % self.name)
+            self._write("<!-- eric5 session file for project {0} -->".format(self.name))
         self._write("<!-- This file was generated automatically, do not edit. -->")
         if Preferences.getProject("XMLTimestamp") or isGlobal:
-            self._write("<!-- Saved: %s -->" % time.strftime('%Y-%m-%d, %H:%M:%S'))
+            self._write("<!-- Saved: {0} -->".format(time.strftime('%Y-%m-%d, %H:%M:%S')))
         
         # add the main tag
-        self._write('<Session version="%s">' % sessionFileFormatVersion) 
+        self._write('<Session version="{0}">'.format(sessionFileFormatVersion))
         
         # step 0: save open multi project and project for the global session
         if isGlobal:
             if self.multiProject.isOpen():
-                self._write('    <MultiProject>%s</MultiProject>' % \
-                    self.multiProject.getMultiProjectFile())
+                self._write('    <MultiProject>{0}</MultiProject>'.format(
+                    self.multiProject.getMultiProjectFile()))
             if self.project.isOpen():
-                self._write('    <Project>%s</Project>' % \
-                    self.project.getProjectFile())
+                self._write('    <Project>{0}</Project>'.format(
+                    self.project.getProjectFile()))
         
         # step 1: save all open (project) filenames and the active window
         allOpenFiles = self.vm.getOpenFilenames()
@@ -81,9 +81,9 @@
                     line, index = 0, 0
                     folds = ''
                     zoom = -9999
-                self._write('    <Filename cline="%d" cindex="%d" folds="%s" zoom="%d">'
-                            '%s</Filename>' % \
-                    (line, index, folds, zoom, of))
+                self._write(
+                    '    <Filename cline="{0:d}" cindex="{1:d}" folds="{2}" zoom="{3:d}">'
+                    '{4}</Filename>'.format(line, index, folds, zoom, of))
         self._write("  </Filenames>")
         
         aw = self.vm.getActiveName()
@@ -93,8 +93,8 @@
                 line, index = ed.getCursorPosition()
             else:
                 line, index = 0, 0
-            self._write('  <ActiveWindow cline="%d" cindex="%d">%s</ActiveWindow>' % \
-                (line, index, aw))
+            self._write('  <ActiveWindow cline="{0:d}" cindex="{1:d}">{2}</ActiveWindow>'\
+                .format(line, index, aw))
         
         # step 2a: save all breakpoints
         allBreaks = Preferences.getProject("SessionAllBreakpoints")
@@ -107,12 +107,13 @@
                 bpModel.getBreakPointByIndex(index)[:6]
             if isGlobal or allBreaks or fname in projectFiles:
                 self._write("    <Breakpoint>")
-                self._write("      <BpFilename>%s</BpFilename>" % fname)
-                self._write('      <Linenumber value="%d" />' % lineno)
-                self._write("      <Condition>%s</Condition>" % self.escape(str(cond)))
-                self._write('      <Temporary value="%s" />' % temp)
-                self._write('      <Enabled value="%s" />' % enabled)
-                self._write('      <Count value="%d" />' % count)
+                self._write("      <BpFilename>{0}</BpFilename>".format(fname))
+                self._write('      <Linenumber value="{0:d}" />'.format(lineno))
+                self._write("      <Condition>{0}</Condition>".format(
+                    self.escape(str(cond))))
+                self._write('      <Temporary value="{0}" />'.format(temp))
+                self._write('      <Enabled value="{0}" />'.format(enabled))
+                self._write('      <Count value="{0:d}" />'.format(count))
                 self._write("    </Breakpoint>")
         self._write("  </Breakpoints>")
         
@@ -123,11 +124,11 @@
             index = wpModel.index(row, 0)
             cond, temp, enabled, count, special = wpModel.getWatchPointByIndex(index)[:5]
             self._write('    <Watchexpression>')
-            self._write("      <Condition>%s</Condition>" % self.escape(str(cond)))
-            self._write('      <Temporary value="%s" />' % temp)
-            self._write('      <Enabled value="%s" />' % enabled)
-            self._write('      <Count value="%d" />' % count)
-            self._write('      <Special>%s</Special>' % special)
+            self._write("      <Condition>{0}</Condition>".format(self.escape(str(cond))))
+            self._write('      <Temporary value="{0}" />'.format(temp))
+            self._write('      <Enabled value="{0}" />'.format(enabled))
+            self._write('      <Count value="{0:d}" />'.format(count))
+            self._write('      <Special>{0}</Special>'.format(special))
             self._write('    </Watchexpression>')
         self._write('  </Watchexpressions>')
         
@@ -146,45 +147,48 @@
                 dbgEnv = self.dbg.envHistory[0]
             else:
                 dbgEnv = ""
-            self._write("    <CommandLine>%s</CommandLine>" % self.escape(dbgCmdline))
-            self._write("    <WorkingDirectory>%s</WorkingDirectory>" % dbgWd)
-            self._write("    <Environment>%s</Environment>" % dbgEnv)
-            self._write('    <ReportExceptions value="%s" />' % self.dbg.exceptions)
+            self._write("    <CommandLine>{0}</CommandLine>"\
+                .format(self.escape(dbgCmdline)))
+            self._write("    <WorkingDirectory>{0}</WorkingDirectory>".format(dbgWd))
+            self._write("    <Environment>{0}</Environment>".format(dbgEnv))
+            self._write('    <ReportExceptions value="{0}" />'\
+                .format(self.dbg.exceptions))
             self._write("    <Exceptions>")
             for exc in self.dbg.excList:
-                self._write("      <Exception>%s</Exception>" % exc)
+                self._write("      <Exception>{0}</Exception>".format(exc))
             self._write("    </Exceptions>")
             self._write("    <IgnoredExceptions>")
             for iexc in self.dbg.excIgnoreList:
-                self._write("      <IgnoredException>%s</IgnoredException>" % iexc)
+                self._write("      <IgnoredException>{0}</IgnoredException>".format(iexc))
             self._write("    </IgnoredExceptions>")
-            self._write('    <AutoClearShell value="%s" />' % self.dbg.autoClearShell)
-            self._write('    <TracePython value="%s" />' % self.dbg.tracePython)
-            self._write('    <AutoContinue value="%s" />' % self.dbg.autoContinue)
+            self._write('    <AutoClearShell value="{0}" />'\
+                .format(self.dbg.autoClearShell))
+            self._write('    <TracePython value="{0}" />'.format(self.dbg.tracePython))
+            self._write('    <AutoContinue value="{0}" />'.format(self.dbg.autoContinue))
             self._write("    <CovexcPattern></CovexcPattern>")  # kept for compatibility
         else:
-            self._write("    <CommandLine>%s</CommandLine>" % \
-                self.escape(str(self.project.dbgCmdline)))
-            self._write("    <WorkingDirectory>%s</WorkingDirectory>" % \
-                self.project.dbgWd)
-            self._write("    <Environment>%s</Environment>" % \
-                self.project.dbgEnv)
-            self._write('    <ReportExceptions value="%s" />' % \
-                self.project.dbgReportExceptions)
+            self._write("    <CommandLine>{0}</CommandLine>".format(
+                self.escape(str(self.project.dbgCmdline))))
+            self._write("    <WorkingDirectory>{0}</WorkingDirectory>".format(
+                self.project.dbgWd))
+            self._write("    <Environment>{0}</Environment>".format(
+                self.project.dbgEnv))
+            self._write('    <ReportExceptions value="{0}" />'.format(
+                self.project.dbgReportExceptions))
             self._write("    <Exceptions>")
             for exc in self.project.dbgExcList:
-                self._write("      <Exception>%s</Exception>" % exc)
+                self._write("      <Exception>{0}</Exception>".format(exc))
             self._write("    </Exceptions>")
             self._write("    <IgnoredExceptions>")
             for iexc in self.project.dbgExcIgnoreList:
-                self._write("      <IgnoredException>%s</IgnoredException>" % iexc)
+                self._write("      <IgnoredException>{0}</IgnoredException>".format(iexc))
             self._write("    </IgnoredExceptions>")
-            self._write('    <AutoClearShell value="%s" />' % \
-                self.project.dbgAutoClearShell)
-            self._write('    <TracePython value="%s" />' % \
-                self.project.dbgTracePython)
-            self._write('    <AutoContinue value="%s" />' % \
-                self.project.dbgAutoContinue)
+            self._write('    <AutoClearShell value="{0}" />'.format(
+                self.project.dbgAutoClearShell))
+            self._write('    <TracePython value="{0}" />'.format(
+                self.project.dbgTracePython))
+            self._write('    <AutoContinue value="{0}" />'.format(
+                self.project.dbgAutoContinue))
             self._write("    <CovexcPattern></CovexcPattern>")  # kept for compatibility
         self._write("  </DebugInfo>")
         
@@ -195,8 +199,8 @@
                 editor = self.vm.getOpenEditor(of)
                 for bookmark in editor.getBookmarks():
                     self._write("    <Bookmark>")
-                    self._write("      <BmFilename>%s</BmFilename>" % of)
-                    self._write('      <Linenumber value="%d" />' % bookmark)
+                    self._write("      <BmFilename>{0}</BmFilename>".format(of))
+                    self._write('      <Linenumber value="{0:d}" />'.format(bookmark))
                     self._write("    </Bookmark>")
         self._write("  </Bookmarks>")
         
diff -r e5d1addeb90c -r 99409cddaaa9 E5XML/ShortcutsWriter.py
--- a/E5XML/ShortcutsWriter.py	Tue Jul 27 08:25:53 2010 +0200
+++ b/E5XML/ShortcutsWriter.py	Tue Jul 27 09:10:10 2010 +0200
@@ -36,124 +36,124 @@
         """
         XMLWriterBase.writeXML(self)
         
-        self._write('<!DOCTYPE Shortcuts SYSTEM "Shortcuts-%s.dtd">' % \
-            shortcutsFileFormatVersion)
+        self._write('<!DOCTYPE Shortcuts SYSTEM "Shortcuts-{0}.dtd">'.format(
+            shortcutsFileFormatVersion))
         
         # add some generation comments
         self._write("<!-- Eric5 keyboard shortcuts -->")
-        self._write("<!-- Saved: %s -->" % time.strftime('%Y-%m-%d, %H:%M:%S'))
-        self._write("<!-- Author: %s -->" % self.escape("%s" % self.email))
+        self._write("<!-- Saved: {0} -->".format(time.strftime('%Y-%m-%d, %H:%M:%S')))
+        self._write("<!-- Author: {0} -->".format(self.escape("{0}".format(self.email))))
         
         # add the main tag
-        self._write('<Shortcuts version="%s">' % shortcutsFileFormatVersion)
+        self._write('<Shortcuts version="{0}">'.format(shortcutsFileFormatVersion))
         
         for act in e5App().getObject("Project").getActions():
             self._write('  <Shortcut category="Project">')
-            self._write('    <Name>%s</Name>' % act.objectName())
-            self._write('    <Accel>%s</Accel>' % \
-                self.escape("%s" % act.shortcut().toString()))
-            self._write('    <AltAccel>%s</AltAccel>' \
-                % self.escape("%s" % act.alternateShortcut().toString()))
+            self._write('    <Name>{0}</Name>'.format(act.objectName()))
+            self._write('    <Accel>{0}</Accel>'.format(
+                self.escape("{0}".format(act.shortcut().toString()))))
+            self._write('    <AltAccel>{0}</AltAccel>' \
+               .format(self.escape("{0}".format(act.alternateShortcut().toString()))))
             self._write('  </Shortcut>')
         
         for act in e5App().getObject("UserInterface").getActions('ui'):
             self._write('  <Shortcut category="General">')
-            self._write('    <Name>%s</Name>' % act.objectName())
-            self._write('    <Accel>%s</Accel>' % \
-                self.escape("%s" % act.shortcut().toString()))
-            self._write('    <AltAccel>%s</AltAccel>' % \
-                self.escape("%s" % act.alternateShortcut().toString()))
+            self._write('    <Name>{0}</Name>'.format(act.objectName()))
+            self._write('    <Accel>{0}</Accel>'.format(
+                self.escape("{0}".format(act.shortcut().toString()))))
+            self._write('    <AltAccel>{0}</AltAccel>'.format(
+                self.escape("{0}".format(act.alternateShortcut().toString()))))
             self._write('  </Shortcut>')
         
         for act in e5App().getObject("UserInterface").getActions('wizards'):
             self._write('  <Shortcut category="Wizards">')
-            self._write('    <Name>%s</Name>' % act.objectName())
-            self._write('    <Accel>%s</Accel>' % \
-                self.escape("%s" % act.shortcut().toString()))
-            self._write('    <AltAccel>%s</AltAccel>' % \
-                self.escape("%s" % act.alternateShortcut().toString()))
+            self._write('    <Name>{0}</Name>'.format(act.objectName()))
+            self._write('    <Accel>{0}</Accel>'.format(
+                self.escape("{0}".format(act.shortcut().toString()))))
+            self._write('    <AltAccel>{0}</AltAccel>'.format(
+                self.escape("{0}".format(act.alternateShortcut().toString()))))
             self._write('  </Shortcut>')
         
         for act in e5App().getObject("DebugUI").getActions():
             self._write('  <Shortcut category="Debug">')
-            self._write('    <Name>%s</Name>' % act.objectName())
-            self._write('    <Accel>%s</Accel>' % \
-                self.escape("%s" % act.shortcut().toString()))
-            self._write('    <AltAccel>%s</AltAccel>' % \
-                self.escape("%s" % act.alternateShortcut().toString()))
+            self._write('    <Name>{0}</Name>'.format(act.objectName()))
+            self._write('    <Accel>{0}</Accel>'.format(
+                self.escape("{0}".format(act.shortcut().toString()))))
+            self._write('    <AltAccel>{0}</AltAccel>'.format(
+                self.escape("{0}".format(act.alternateShortcut().toString()))))
             self._write('  </Shortcut>')
         
         for act in e5App().getObject("ViewManager").getActions('edit'):
             self._write('  <Shortcut category="Edit">')
-            self._write('    <Name>%s</Name>' % act.objectName())
-            self._write('    <Accel>%s</Accel>' % \
-                self.escape("%s" % act.shortcut().toString()))
-            self._write('    <AltAccel>%s</AltAccel>' % \
-                self.escape("%s" % act.alternateShortcut().toString()))
+            self._write('    <Name>{0}</Name>'.format(act.objectName()))
+            self._write('    <Accel>{0}</Accel>'.format(
+                self.escape("{0}".format(act.shortcut().toString()))))
+            self._write('    <AltAccel>{0}</AltAccel>'.format(
+                self.escape("{0}".format(act.alternateShortcut().toString()))))
             self._write('  </Shortcut>')
         
         for act in e5App().getObject("ViewManager").getActions('file'):
             self._write('  <Shortcut category="File">')
-            self._write('    <Name>%s</Name>' % act.objectName())
-            self._write('    <Accel>%s</Accel>' % \
-                self.escape("%s" % act.shortcut().toString()))
-            self._write('    <AltAccel>%s</AltAccel>' % \
-                self.escape("%s" % act.alternateShortcut().toString()))
+            self._write('    <Name>{0}</Name>'.format(act.objectName()))
+            self._write('    <Accel>{0}</Accel>'.format(
+                self.escape("{0}".format(act.shortcut().toString()))))
+            self._write('    <AltAccel>{0}</AltAccel>'.format(
+                self.escape("{0}".format(act.alternateShortcut().toString()))))
             self._write('  </Shortcut>')
         
         for act in e5App().getObject("ViewManager").getActions('search'):
             self._write('  <Shortcut category="Search">')
-            self._write('    <Name>%s</Name>' % act.objectName())
-            self._write('    <Accel>%s</Accel>' % \
-                self.escape("%s" % act.shortcut().toString()))
-            self._write('    <AltAccel>%s</AltAccel>' % \
-                self.escape("%s" % act.alternateShortcut().toString()))
+            self._write('    <Name>{0}</Name>'.format(act.objectName()))
+            self._write('    <Accel>{0}</Accel>'.format(
+                self.escape("{0}".format(act.shortcut().toString()))))
+            self._write('    <AltAccel>{0}</AltAccel>'.format(
+                self.escape("{0}".format(act.alternateShortcut().toString()))))
             self._write('  </Shortcut>')
         
         for act in e5App().getObject("ViewManager").getActions('view'):
             self._write('  <Shortcut category="View">')
-            self._write('    <Name>%s</Name>' % act.objectName())
-            self._write('    <Accel>%s</Accel>' % \
-                self.escape("%s" % act.shortcut().toString()))
-            self._write('    <AltAccel>%s</AltAccel>' % \
-                self.escape("%s" % act.alternateShortcut().toString()))
+            self._write('    <Name>{0}</Name>'.format(act.objectName()))
+            self._write('    <Accel>{0}</Accel>'.format(
+                self.escape("{0}".format(act.shortcut().toString()))))
+            self._write('    <AltAccel>{0}</AltAccel>'.format(
+                self.escape("{0}".format(act.alternateShortcut().toString()))))
             self._write('  </Shortcut>')
         
         for act in e5App().getObject("ViewManager").getActions('macro'):
             self._write('  <Shortcut category="Macro">')
-            self._write('    <Name>%s</Name>' % act.objectName())
-            self._write('    <Accel>%s</Accel>' % \
-                self.escape("%s" % act.shortcut().toString()))
-            self._write('    <AltAccel>%s</AltAccel>' % \
-                self.escape("%s" % act.alternateShortcut().toString()))
+            self._write('    <Name>{0}</Name>'.format(act.objectName()))
+            self._write('    <Accel>{0}</Accel>'.format(
+                self.escape("{0}".format(act.shortcut().toString()))))
+            self._write('    <AltAccel>{0}</AltAccel>'.format(
+                self.escape("{0}".format(act.alternateShortcut().toString()))))
             self._write('  </Shortcut>')
         
         for act in e5App().getObject("ViewManager").getActions('bookmark'):
             self._write('  <Shortcut category="Bookmarks">')
-            self._write('    <Name>%s</Name>' % act.objectName())
-            self._write('    <Accel>%s</Accel>' % \
-                self.escape("%s" % act.shortcut().toString()))
-            self._write('    <AltAccel>%s</AltAccel>' % \
-                self.escape("%s" % act.alternateShortcut().toString()))
+            self._write('    <Name>{0}</Name>'.format(act.objectName()))
+            self._write('    <Accel>{0}</Accel>'.format(
+                self.escape("{0}".format(act.shortcut().toString()))))
+            self._write('    <AltAccel>{0}</AltAccel>'.format(
+                self.escape("{0}".format(act.alternateShortcut().toString()))))
             self._write('  </Shortcut>')
         
         for act in e5App().getObject("ViewManager").getActions('spelling'):
             self._write('  <Shortcut category="Spelling">')
-            self._write('    <Name>%s</Name>' % act.objectName())
-            self._write('    <Accel>%s</Accel>' % \
-                self.escape("%s" % act.shortcut().toString()))
-            self._write('    <AltAccel>%s</AltAccel>' % \
-                self.escape("%s" % act.alternateShortcut().toString()))
+            self._write('    <Name>{0}</Name>'.format(act.objectName()))
+            self._write('    <Accel>{0}</Accel>'.format(
+                self.escape("{0}".format(act.shortcut().toString()))))
+            self._write('    <AltAccel>{0}</AltAccel>'.format(
+                self.escape("{0}".format(act.alternateShortcut().toString()))))
             self._write('  </Shortcut>')
         
         actions = e5App().getObject("ViewManager").getActions('window')
         for act in actions:
             self._write('  <Shortcut category="Window">')
-            self._write('    <Name>%s</Name>' % act.objectName())
-            self._write('    <Accel>%s</Accel>' % \
-                self.escape("%s" % act.shortcut().toString()))
-            self._write('    <AltAccel>%s</AltAccel>' % \
-                self.escape("%s" % act.alternateShortcut().toString()))
+            self._write('    <Name>{0}</Name>'.format(act.objectName()))
+            self._write('    <Accel>{0}</Accel>'.format(
+                self.escape("{0}".format(act.shortcut().toString()))))
+            self._write('    <AltAccel>{0}</AltAccel>'.format(
+                self.escape("{0}".format(act.alternateShortcut().toString()))))
             self._write('  </Shortcut>')
         
         for category, ref in e5App().getPluginObjects():
@@ -162,22 +162,23 @@
                 for act in actions:
                     if act.objectName():
                         # shortcuts are only exported, if their objectName is set
-                        self._write('  <Shortcut category="%s">' % category)
-                        self._write('    <Name>%s</Name>' % act.objectName())
-                        self._write('    <Accel>%s</Accel>' % \
-                            self.escape("%s" % act.shortcut().toString()))
-                        self._write('    <AltAccel>%s</AltAccel>' % \
-                            self.escape("%s" % act.alternateShortcut().toString()))
+                        self._write('  <Shortcut category="{0}">'.format(category))
+                        self._write('    <Name>{0}</Name>'.format(act.objectName()))
+                        self._write('    <Accel>{0}</Accel>'.format(
+                            self.escape("{0}".format(act.shortcut().toString()))))
+                        self._write('    <AltAccel>{0}</AltAccel>'\
+                            .format(self.escape("{0}".format(
+                                act.alternateShortcut().toString()))))
                         self._write('  </Shortcut>')
     
         for act in e5App().getObject("DummyHelpViewer").getActions():
             self._write('  <Shortcut category="HelpViewer">')
-            self._write('    <Name>%s</Name>' % act.objectName())
-            self._write('    <Accel>%s</Accel>' % \
-                self.escape("%s" % act.shortcut().toString()))
-            self._write('    <AltAccel>%s</AltAccel>' \
-                % self.escape("%s" % act.alternateShortcut().toString()))
+            self._write('    <Name>{0}</Name>'.format(act.objectName()))
+            self._write('    <Accel>{0}</Accel>'.format(
+                self.escape("{0}".format(act.shortcut().toString()))))
+            self._write('    <AltAccel>{0}</AltAccel>' \
+               .format(self.escape("{0}".format(act.alternateShortcut().toString()))))
             self._write('  </Shortcut>')
     
         # add the main end tag
-        self._write("</Shortcuts>", newline = False)
\ No newline at end of file
+        self._write("</Shortcuts>", newline = False)

eric ide

mercurial