eric: comparison QScintilla/Editor.py

-:b0996e4a289e
+:1d8dd9706f46
 from PyQt4.QtCore import *
 from PyQt4.QtGui import *
 from E4Gui.E4Application import e4App
-import Exporters
+from . import Exporters
-import Lexers
+from . import Lexers
-import TypingCompleters
+from . import TypingCompleters
-from QsciScintillaCompat import QsciScintillaCompat, QSCINTILLA_VERSION
+from .QsciScintillaCompat import QsciScintillaCompat, QSCINTILLA_VERSION
-from SpellChecker import SpellChecker
+from .SpellChecker import SpellChecker
-from SpellCheckingDialog import SpellCheckingDialog
+from .SpellCheckingDialog import SpellCheckingDialog
 from Debugger.EditBreakpointDialog import EditBreakpointDialog
-from DebugClients.Python.coverage import coverage
+from DebugClients.Python3.coverage import coverage
 from DataViews.CodeMetricsDialog import CodeMetricsDialog
 from DataViews.PyCoverageDialog import PyCoverageDialog
 from DataViews.PyProfileDialog import PyProfileDialog
-from Printer import Printer
+from .Printer import Printer
 import Preferences
 import Utilities
 import UI.PixmapCache
 self.__setEolMode()
 self.isResourcesFile = False
 if editor is None:
 if self.fileName is not None:
-if (QFileInfo(self.fileName).size() / 1024) > \
+if (QFileInfo(self.fileName).size() // 1024) > \
 Preferences.getEditor("WarnFilesize"):
 res = QMessageBox.warning(None,
 self.trUtf8("Open File"),
 self.trUtf8("""<p>The size of the file <b>{0}</b>"""
 """ is <b>{1} KB</b>."""
 """ Do you really want to load it?</p>""")\
 .format(self.fileName,
-QFileInfo(self.fileName).size() / 1024),
+QFileInfo(self.fileName).size() // 1024),
 QMessageBox.StandardButtons(\
 QMessageBox.No | \
 QMessageBox.Yes),
 QMessageBox.No)
 if res == QMessageBox.No or res == QMessageBox.Cancel:
 self.languagesActGrp.addAction(self.noLanguageAct)
 menu.addSeparator()
 self.supportedLanguages = {}
 supportedLanguages = Lexers.getSupportedLanguages()
-languages = supportedLanguages.keys()
+languages = sorted(list(supportedLanguages.keys()))
-languages.sort()
 for language in languages:
 if language != "Guessed":
 self.supportedLanguages[language] = supportedLanguages[language][:]
 act = menu.addAction(self.supportedLanguages[language][0])
 act.setCheckable(True)
 Private method used to setup the Exporters context sub menu.
 """
 menu = QMenu(self.trUtf8("Export as"))
 supportedExporters = Exporters.getSupportedFormats()
-exporters = supportedExporters.keys()
+exporters = sorted(list(supportedExporters.keys()))
-exporters.sort()
 for exporter in exporters:
 act = menu.addAction(supportedExporters[exporter])
 act.setData(exporter)
 self.connect(menu, SIGNAL('triggered(QAction *)'), self.__exportMenuTriggered)
 This method checks, if lines have been inserted or removed in order to
 update the breakpoints.
 """
 if self.breaks:
 bps = []    # list of breakpoints
-for handle, (ln, cond, temp, enabled, ignorecount) in self.breaks.items():
+for handle, (ln, cond, temp, enabled, ignorecount) in list(self.breaks.items()):
 line = self.markerLine(handle) + 1
 bps.append((ln, line, (cond, temp, enabled, ignorecount)))
 self.markerDeleteHandle(handle)
 self.breaks = {}
 for bp in bps:
 def __restoreBreakpoints(self):
 """
 Private method to restore the breakpoints.
 """
-for handle in self.breaks.keys():
+for handle in list(self.breaks.keys()):
 self.markerDeleteHandle(handle)
 self.__addBreakPoints(QModelIndex(), 0, self.breakpointModel.rowCount() - 1)
 def __deleteBreakPoints(self, parentIndex, start, end):
 """
 Note: This doesn't clear the breakpoint in the debugger,
 it just deletes it from the editor internal list of breakpoints.
 @param line linenumber of the breakpoint (integer)
 """
-for handle, (ln, _, _, _, _) in self.breaks.items():
+for handle, (ln, _, _, _, _) in list(self.breaks.items()):
 if self.markerLine(handle) == line-1:
 break
 else:
 # not found, simply ignore it
 return
 Private method to toggle a breakpoint.
 @param line line number of the breakpoint (integer)
 @param temporary flag indicating a temporary breakpoint (boolean)
 """
-for handle, (ln, _, _, _, _) in self.breaks.items():
+for handle, (ln, _, _, _, _) in list(self.breaks.items()):
 if self.markerLine(handle) == line - 1:
 # delete breakpoint or toggle it to the next state
 index = self.breakpointModel.getBreakPointIndex(self.fileName, line)
 if Preferences.getDebugger("ThreeStateBreakPoints") and \
 not self.breakpointModel.isBreakPointTemporaryByIndex(index):
 """
 Private method to toggle a breakpoints enabled status.
 @param line line number of the breakpoint (integer)
 """
-for handle, (ln, cond, temp, enabled, ignorecount) in self.breaks.items():
+for handle, (ln, cond, temp, enabled, ignorecount) in list(self.breaks.items()):
 if self.markerLine(handle) == line - 1:
 break
 else:
 # no breakpoint found on that line
 return
 if line is not None:
 self.line = line - 1
 if self.line < 0:
 self.line, index = self.getCursorPosition()
 found = False
-for handle, (ln, cond, temp, enabled, ignorecount) in self.breaks.items():
+for handle, (ln, cond, temp, enabled, ignorecount) in list(self.breaks.items()):
 if self.markerLine(handle) == self.line:
 found = True
 break
 if found:
 def __clearBreakpoints(self, fileName):
 """
 Private slot to clear all breakpoints.
 """
 idxList = []
-for handle, (ln, _, _, _, _) in self.breaks.items():
+for handle, (ln, _, _, _, _) in list(self.breaks.items()):
 index = self.breakpointModel.getBreakPointIndex(fileName, ln)
 if index.isValid():
 idxList.append(index)
 if idxList:
 self.breakpointModel.deleteBreakPoints(idxList)
 one doesn't exist (boolean)
 @return first line of the file (string)
 """
 try:
 if createIt and not os.path.exists(fn):
-f = open(fn, "wb")
+f = open(fn, "w")
 f.close()
-f = open(fn, 'rb')
+f = open(fn, 'r')
-except IOError:
+except IOError as why:
 QMessageBox.critical(self.vm, self.trUtf8('Open File'),
-self.trUtf8('<p>The file <b>{0}</b> could not be opened.</p>')
+self.trUtf8('<p>The file <b>{0}</b> could not be opened.</p>'
-.format(fn))
+'<p>Reason: {1}</p>')
+.format(fn, str(why)))
 raise
-txt = f.readline()
+try:
+txt = f.readline()
+except UnicodeDecodeError as why:
+QMessageBox.critical(self.vm, self.trUtf8('Open File'),
+self.trUtf8('<p>The file <b>{0}</b> could not be opened.</p>'
+'<p>Reason: {1}</p>')
+.format(fn, str(why)))
+raise
 f.close()
 return txt
 def readFile(self, fn, createIt = False):
 """
 @param createIt flag indicating the creation of a new file, if the given
 one doesn't exist (boolean)
 """
 try:
 if createIt and not os.path.exists(fn):
-f = open(fn, "wb")
+f = open(fn, "w")
 f.close()
-f = open(fn, 'rb')
+f = open(fn, 'r')
-except IOError:
+except IOError as why:
 QMessageBox.critical(self.vm, self.trUtf8('Open File'),
-self.trUtf8('<p>The file <b>{0}</b> could not be opened.</p>')
+self.trUtf8('<p>The file <b>{0}</b> could not be opened.</p>'
-.format(fn))
+'<p>Reason: {1}</p>')
+.format(fn, str(why)))
 raise
 QApplication.setOverrideCursor(QCursor(Qt.WaitCursor))
-if fn.endswith('.ts') or fn.endswith('.ui'):
+##        if fn.endswith('.ts') or fn.endswith('.ui'):
-# special treatment for Qt-Linguist and Qt-Designer files
+##            # special treatment for Qt-Linguist and Qt-Designer files
+##            txt = f.read()
+##            self.encoding = 'latin-1'
+##        else:
+##            txt, self.encoding = f.read(), "utf-8" #Utilities.decode(f.read())
+try:
 txt = f.read()
-self.encoding = 'latin-1'
+except UnicodeDecodeError as why:
-else:
+QApplication.restoreOverrideCursor()
-txt, self.encoding = Utilities.decode(f.read())
+QMessageBox.critical(self.vm, self.trUtf8('Open File'),
+self.trUtf8('<p>The file <b>{0}</b> could not be opened.</p>'
+'<p>Reason: {1}</p>')
+.format(fn, str(why)))
+QApplication.restoreOverrideCursor()
+raise
+self.encoding = f.encoding.lower()
 f.close()
 fileEol = self.detectEolString(txt)
 modified = False
 if (not Preferences.getEditor("TabForIndentation")) and \
 if len(txt) >= len(eol):
 if txt[-len(eol):] != eol:
 txt += eol
 else:
 txt += eol
-try:
+##        try:
-txt, self.encoding = Utilities.encode(txt, self.encoding)
+##            txt, self.encoding = Utilities.encode(txt, self.encoding)
-except Utilities.CodingError, e:
+##        except Utilities.CodingError as e:
-QMessageBox.critical(self, self.trUtf8('Save File'),
+##            QMessageBox.critical(self, self.trUtf8('Save File'),
-self.trUtf8('<p>The file <b>{0}</b> could not be saved.<br/>'
+##                self.trUtf8('<p>The file <b>{0}</b> could not be saved.<br/>'
-'Reason: {1}</p>')
+##                            'Reason: {1}</p>')
-.format(fn, unicode(e)))
+##                    .format(fn, str(e)))
-return False
+##            return False
+##
 # create a backup file, if the option is set
 createBackup = Preferences.getEditor("CreateBackupFile")
 if createBackup:
 if os.path.islink(fn):
 fn = os.path.realpath(fn)
 # if there was an error, ignore it
 pass
 # now write text to the file fn
 try:
-f = open(fn, 'wb')
+f = open(fn, 'w', encoding = self.encoding)
 f.write(txt)
 f.close()
 if createBackup and perms_valid:
 os.chmod(fn, permissions)
 return True
-except IOError, why:
+except IOError as why:
 QMessageBox.critical(self, self.trUtf8('Save File'),
 self.trUtf8('<p>The file <b>{0}</b> could not be saved.<br/>'
 'Reason: {1}</p>')
-.format(fn, unicode(why)))
+.format(fn, str(why)))
 return False
 def saveFile(self, saveas = False, path = None):
 """
 Public slot to save the text to a file.
 Public slot called to handle the user entering a character.
 @param charNumber value of the character entered (integer)
 """
 if self.isListActive():
-char = unichr(charNumber)
+char = chr(charNumber)
 if self.__isStartChar(char):
 self.cancelList()
 self.autoComplete(auto = True, context = True)
 return
 elif char == '(':
 self.cancelList()
 if self.callTipsStyle() != QsciScintilla.CallTipsNone and \
-self.lexer_ is not None and unichr(charNumber) in '()':
+self.lexer_ is not None and chr(charNumber) in '()':
 self.callTip()
 if not self.isCallTipActive():
-char = unichr(charNumber)
+char = chr(charNumber)
 if self.__isStartChar(char):
 self.autoComplete(auto = True, context = True)
 return
 line, col = self.getCursorPosition()
 """
 Private method to perform an automatic syntax check of the file.
 """
 if Preferences.getEditor("AutoCheckSyntax"):
 self.clearSyntaxError()
-if self.isPyFile():
+if self.isPy3File():
 syntaxError, _fn, errorline, _code, _error = \
 Utilities.compile(self.fileName, self.text())
 if syntaxError:
 self.toggleSyntaxError(int(errorline), 1, _error)
 if not (markers & (1 << self.syntaxerror)):
 handle = self.markerAdd(line - 1, self.syntaxerror)
 self.syntaxerrors[handle] = msg
 self.emit(SIGNAL('syntaxerrorToggled'), self)
 else:
-for handle in self.syntaxerrors.keys():
+for handle in list(self.syntaxerrors.keys()):
 if self.markerLine(handle) == line - 1:
 del self.syntaxerrors[handle]
 self.markerDeleteHandle(handle)
 self.emit(SIGNAL('syntaxerrorToggled'), self)
 @return sorted list of all lines containing a syntax error
 (list of integer)
 """
 selist = []
-for handle in self.syntaxerrors.keys():
+for handle in list(self.syntaxerrors.keys()):
 selist.append(self.markerLine(handle) + 1)
 selist.sort()
 return selist
 def clearSyntaxError(self):
 """
 Public slot to handle the 'Clear all syntax error' context menu action.
 """
-for handle in self.syntaxerrors.keys():
+for handle in list(self.syntaxerrors.keys()):
 line = self.markerLine(handle) + 1
 self.toggleSyntaxError(line, False)
 def __showSyntaxError(self, line = -1):
 """
 @param line line number to show the syntax error for (integer)
 """
 if line == -1:
 line = self.line
-for handle in self.syntaxerrors.keys():
+for handle in list(self.syntaxerrors.keys()):
 if self.markerLine(handle) == line:
 QMessageBox.critical(None,
 self.trUtf8("Syntax Error"),
 self.syntaxerrors[handle])
 break
 @return Tuple of macro name and a flag, indicating, if the user pressed ok or
 canceled the operation. (string, boolean)
 """
 qs = []
-for s in self.macros.keys():
+for s in list(self.macros.keys()):
 qs.append(s)
 qs.sort()
 return QInputDialog.getItem(\
 self,
 self.trUtf8("Macro Name"),
 if not fname:
 return  # user aborted
 try:
-f = open(fname, "rb")
+f = open(fname, "r")
 lines = f.readlines()
 f.close()
 except IOError:
 QMessageBox.critical(self,
 self.trUtf8("Error loading macro"),
 if res == QMessageBox.Abort or res == QMessageBox.Cancel:
 return
 fname = Utilities.toNativeSeparators(fname)
 try:
-f = open(fname, "wb")
+f = open(fname, "w")
 f.write("%s%s" % (name, os.linesep))
 f.write(self.macros[name].save())
 f.close()
 except IOError:
 QMessageBox.critical(self,
 # clear syntax error markers
 self.clearSyntaxError()
 # clear breakpoint markers
-for handle in self.breaks.keys():
+for handle in list(self.breaks.keys()):
 self.markerDeleteHandle(handle)
 self.breaks = {}
 # reread the file
 try:
 Public slot called to handle the user entering a character.
 @param charNumber value of the character entered (integer)
 """
 if self.spell:
-if not unichr(charNumber).isalnum():
+if not chr(charNumber).isalnum():
 self.spell.checkWord(self.positionBefore(self.currentPosition()), True)
 elif self.hasIndicator(self.spellingIndicator, self.currentPosition()):
 self.spell.checkWord(self.currentPosition())
 def checkSpelling(self):

Mercurial Repositories > eric / file comparison

comparison: QScintilla/Editor.py

QScintilla/Editor.py