eric: comparison QScintilla/Shell.py

-:6411ee48fe91
+:9487c08b6a23
 from __future__ import unicode_literals
 import sys
 import re
+try:
+from enum import Enum
+except ImportError:
+from ThirdParty.enum import Enum
 from PyQt5.QtCore import pyqtSignal, QFileInfo, Qt, QEvent
 from PyQt5.QtGui import QClipboard, QPalette, QFont
 from PyQt5.QtWidgets import QDialog, QInputDialog, QApplication, QMenu, \
 QWidget, QHBoxLayout, QVBoxLayout, QShortcut
 @return reference to the shell widget (Shell)
 """
 return self.__shell
+class ShellHistoryStyle(Enum):
+"""
+Class defining the shell history styles.
+"""
+Disabled = 0
+LinuxStyle = 1
+WindowsStyle = 2
 class Shell(QsciScintillaCompat):
 """
 Class implementing a graphical Python shell.
 A user can enter commands that are executed in the remote
 Python interpreter.
-@signal searchStringFound(found) emitted to indicate the search
+@signal searchStringFound(bool) emitted to indicate the search
-result (boolean)
+result
+@signal historyStyleChanged(ShellHistoryStyle) emitted to indicate a
+change of the history style
 """
 searchStringFound = pyqtSignal(bool)
+historyStyleChanged = pyqtSignal(ShellHistoryStyle)
 def __init__(self, dbs, vm, windowedVariant, parent=None):
 """
 Constructor
 if self.__windowed:
 self.setWhatsThis(self.tr(
 """<b>The Shell Window</b>"""
 """<p>You can use the cursor keys while entering commands."""
 """ There is also a history of commands that can be recalled"""
-""" using the up and down cursor keys. Pressing the up or"""
+""" using the up and down cursor keys while holding down the"""
-""" down key after some text has been entered will start an"""
+""" Ctrl-key. This can be switched to just the up and down"""
-""" incremental search.</p>"""
+""" cursor keys on the Shell page of the configuration"""
+""" dialog. Pressing these keys after some text has been"""
+""" entered will start an incremental search.</p>"""
 """<p>The shell has some special commands. 'reset' kills the"""
 """ shell and starts a new one. 'clear' clears the display"""
 """ of the shell window. 'start' is used to switch the shell"""
 """ language and must be followed by a supported language."""
 """ Supported languages are listed by the 'languages'"""
 """ interpreter is the one that is used to run the program"""
 """ being debugged. This means that you can execute any"""
 """ command while the program being debugged is running.</p>"""
 """<p>You can use the cursor keys while entering commands."""
 """ There is also a history of commands that can be recalled"""
-""" using the up and down cursor keys. Pressing the up or"""
+""" using the up and down cursor keys while holding down the"""
-""" down key after some text has been entered will start an"""
+""" Ctrl-key. This can be switched to just the up and down"""
-""" incremental search.</p>"""
+""" cursor keys on the Shell page of the configuration"""
+""" dialog. Pressing these keys after some text has been"""
+""" entered will start an incremental search.</p>"""
 """<p>The shell has some special commands. 'reset' kills the"""
 """ shell and starts a new one. 'clear' clears the display"""
 """ of the shell window. 'start' is used to switch the shell"""
 """ language and must be followed by a supported language."""
 """ Supported languages are listed by the 'languages'"""
 self.prcol = 0
 self.inDragDrop = False
 self.lexer_ = None
 self.completionText = ""
+self.clientType = ''
 # Initialize history
-self.historyLists = {}
+self.__historyLists = {}
-self.maxHistoryEntries = Preferences.getShell("MaxHistoryEntries")
+self.__maxHistoryEntries = Preferences.getShell("MaxHistoryEntries")
-self.history = []
+self.__historyStyle = Preferences.getShell("HistoryStyle")
-self.histidx = -1
+self.__historyWrap = Preferences.getShell("HistoryWrap")
+self.__history = []
+self.__setHistoryIndex()
 # remove obsolete shell histories (Python and Ruby)
 for clientType in ["Python", "Ruby"]:
 Preferences.Prefs.settings.remove("Shell/Histories/" + clientType)
-self.clientType = ''
 # clear QScintilla defined keyboard commands
 # we do our own handling through the view manager
 self.clearAlternateKeys()
 self.clearKeys()
 # Create a little context menu
 self.menu = QMenu(self)
 self.menu.addAction(self.tr('Cut'), self.cut)
 self.menu.addAction(self.tr('Copy'), self.copy)
 self.menu.addAction(self.tr('Paste'), self.paste)
-self.menu.addMenu(self.hmenu)
+self.menu.addMenu(self.hmenu).setEnabled(self.isHistoryEnabled())
 self.menu.addSeparator()
 self.menu.addAction(self.tr('Find'), self.__find)
 self.menu.addSeparator()
 self.menu.addAction(self.tr('Clear'), self.clear)
 self.menu.addAction(self.tr('Reset'), self.__reset)
 QsciScintilla.SCI_CHARRIGHT: self.__QScintillaCharRight,
 QsciScintilla.SCI_WORDLEFT: self.__QScintillaWordLeft,
 QsciScintilla.SCI_WORDRIGHT: self.__QScintillaWordRight,
 QsciScintilla.SCI_VCHOME: self.__QScintillaVCHome,
 QsciScintilla.SCI_LINEEND: self.__QScintillaLineEnd,
-QsciScintilla.SCI_LINEUP: self.__QScintillaCommand,
-QsciScintilla.SCI_LINEDOWN: self.__QScintillaCommand,
-QsciScintilla.SCI_LINESCROLLUP: self.__QScintillaHistoryUp,
-QsciScintilla.SCI_LINESCROLLDOWN: self.__QScintillaHistoryDown,
 QsciScintilla.SCI_PAGEUP: self.__QScintillaAutoCompletionCommand,
 QsciScintilla.SCI_PAGEDOWN: self.__QScintillaAutoCompletionCommand,
 QsciScintilla.SCI_CANCEL: self.__QScintillaAutoCompletionCommand,
 QsciScintilla.SCI_CHARRIGHTEXTEND: self.extendSelectionRight,
 QsciScintilla.SCI_WORDLEFTEXTEND: self.__QScintillaWordLeftExtend,
 QsciScintilla.SCI_WORDRIGHTEXTEND: self.extendSelectionWordRight,
 QsciScintilla.SCI_VCHOMEEXTEND: self.__QScintillaVCHomeExtend,
 QsciScintilla.SCI_LINEENDEXTEND: self.extendSelectionToEOL,
+QsciScintilla.SCI_CANCEL: self.__QScintillaCancel,
 }
+self.__setupCursorKeys()
 self.grabGesture(Qt.PinchGesture)
+def __setupCursorKeys(self):
+"""
+Private method to setup the cursor up and down mode.
+"""
+if Preferences.getShell("HistoryNavigateByCursor"):
+self.supportedEditorCommands.update({
+QsciScintilla.SCI_LINEUP: self.__QScintillaHistoryUp,
+QsciScintilla.SCI_LINEDOWN: self.__QScintillaHistoryDown,
+QsciScintilla.SCI_LINESCROLLUP: self.__QScintillaLineUp,
+QsciScintilla.SCI_LINESCROLLDOWN: self.__QScintillaLineDown,
+})
+else:
+self.supportedEditorCommands.update({
+QsciScintilla.SCI_LINEUP: self.__QScintillaLineUp,
+QsciScintilla.SCI_LINEDOWN: self.__QScintillaLineDown,
+QsciScintilla.SCI_LINESCROLLUP: self.__QScintillaHistoryUp,
+QsciScintilla.SCI_LINESCROLLDOWN: self.__QScintillaHistoryDown,
+})
 def __showLanguageMenu(self):
 """
 Private slot to prepare the language submenu.
 """
 self.lmenu.clear()
 def closeShell(self):
 """
 Public method to shutdown the shell.
 """
-for clientType in self.historyLists:
+for clientType in self.__historyLists:
 self.saveHistory(clientType)
 def __bindLexer(self, language='Python3'):
 """
 Private slot to set the lexer.
 @param clType type of the debug client (string)
 """
 self.clientCapabilities = cap
 if clType != self.clientType:
 self.clientType = clType
-self.__bindLexer(clType)
+self.__bindLexer(self.clientType)
 self.__setTextDisplay()
 self.__setMargin0()
-self.__setAutoCompletion(clType)
+self.__setAutoCompletion(self.clientType)
-self.__setCallTips(clType)
+self.__setCallTips(self.clientType)
 self.racEnabled = \
 Preferences.getShell("AutoCompletionEnabled") and \
 (cap & HasCompleter) > 0
-if clType not in self.historyLists:
+if self.clientType not in self.__historyLists:
 # load history list
-self.loadHistory(clType)
+self.loadHistory(self.clientType)
-self.history = self.historyLists[clType]
+self.__history = self.__historyLists[self.clientType]
-self.histidx = -1
+self.__setHistoryIndex()
+def __setHistoryIndex(self, index=None):
+"""
+Private method to set the initial history index.
+@param index index value to be set
+@type int or None
+"""
+if index is None:
+# determine based on history style
+if self.clientType and \
+self.__historyStyle == ShellHistoryStyle.WindowsStyle:
+idx = int(Preferences.Prefs.settings.value(
+"Shell/HistoryIndexes/" + self.clientType, -1))
+if idx >= len(self.__history):
+idx = -1
+self.__histidx = idx
+else:
+self.__histidx = -1
+else:
+self.__histidx = index
+if self.__histidx >= len(self.__history):
+self.__histidx = -1
+if self.clientType and \
+self.__historyStyle == ShellHistoryStyle.WindowsStyle:
+Preferences.Prefs.settings.setValue(
+"Shell/HistoryIndexes/" + self.clientType, self.__histidx)
+def __isHistoryIndexValid(self):
+"""
+Private method to test, if the history index is valid.
+@return flag indicating validity
+@rtype bool
+"""
+return (0 <= self.__histidx < len(self.__history))
+def getHistoryIndex(self):
+"""
+Public method to get the current value of the history index.
+@return history index
+@rtype int
+"""
+return self.__histidx
 def loadHistory(self, clientType):
 """
 Public method to load the history for the given client type.
 @param clientType type of the debug client (string)
 """
 hl = Preferences.Prefs.settings.value("Shell/Histories/" + clientType)
 if hl is not None:
-self.historyLists[clientType] = hl[-self.maxHistoryEntries:]
+self.__historyLists[clientType] = hl[-self.__maxHistoryEntries:]
 else:
-self.historyLists[clientType] = []
+self.__historyLists[clientType] = []
 def reloadHistory(self):
 """
 Public method to reload the history of the currently selected client
 type.
 """
 self.loadHistory(self.clientType)
-self.history = self.historyLists[self.clientType]
+self.__history = self.__historyLists[self.clientType]
-self.histidx = -1
+self.__setHistoryIndex()
 def saveHistory(self, clientType):
 """
 Public method to save the history for the given client type.
 @param clientType type of the debug client (string)
 """
-if clientType in self.historyLists:
+if clientType in self.__historyLists:
 Preferences.Prefs.settings.setValue(
-"Shell/Histories/" + clientType, self.historyLists[clientType])
+"Shell/Histories/" + clientType,
+self.__historyLists[clientType])
 def getHistory(self, clientType):
 """
 Public method to get the history for the given client type.
 @param clientType type of the debug client (string).
 If it is None, the current history is returned.
 @return reference to the history list (list of strings)
 """
 if clientType is None:
-return self.history
+return self.__history
-elif clientType in self.historyLists:
+elif clientType in self.__historyLists:
-return self.historyLists[clientType]
+return self.__historyLists[clientType]
 else:
 return []
 def clearHistory(self):
 """
 Public slot to clear the current history.
 """
 if self.clientType:
-self.historyLists[self.clientType] = []
+self.__historyLists[self.clientType] = []
-self.history = self.historyLists[self.clientType]
+self.__history = self.__historyLists[self.clientType]
 else:
-self.history = []
+self.__history = []
-self.histidx = -1
+self.__setHistoryIndex(index=-1)
 def selectHistory(self):
 """
 Public slot to select a history entry to execute.
 """
+current = self.__histidx
+if current == -1:
+current = len(self.__history) - 1
 cmd, ok = QInputDialog.getItem(
 self,
 self.tr("Select History"),
 self.tr("Select the history entry to execute"
 " (most recent shown last)."),
-self.history,
+self.__history,
-0, False)
+current, False)
 if ok:
 self.__insertHistory(cmd)
 def showHistory(self):
 """
 Public slot to show the shell history dialog.
 """
 from .ShellHistoryDialog import ShellHistoryDialog
-dlg = ShellHistoryDialog(self.history, self.vm, self)
+dlg = ShellHistoryDialog(self.__history, self.vm, self)
 if dlg.exec_() == QDialog.Accepted:
-self.historyLists[self.clientType] = dlg.getHistory()
+self.__historyLists[self.clientType], idx = dlg.getHistory()
-self.history = self.historyLists[self.clientType]
+self.__history = self.__historyLists[self.clientType]
-self.histidx = -1
+self.__setHistoryIndex(index=idx)
 def clearAllHistories(self):
 """
 Public method to clear all available histories and sync them.
 """
 Preferences.Prefs.settings.beginGroup("Shell/Histories")
 for clientType in Preferences.Prefs.settings.childKeys():
-self.historyLists[clientType] = []
+self.__historyLists[clientType] = []
 self.saveHistory(clientType)
 Preferences.Prefs.settings.endGroup()
 self.clearHistory()
 Private method to handle the middle mouse button press.
 """
 lines = QApplication.clipboard().text(QClipboard.Selection)
 self.executeLines(lines)
-def executeLines(self, lines):
+def executeLines(self, lines, historyIndex=None):
 """
 Public method to execute a set of lines as multiple commands.
-@param lines multiple lines of text to be executed as single
+@param lines multiple lines of text to be executed as
-commands (string)
+single commands
+@type str
+@param historyIndex history index to be set
+@type int
 """
 for line in lines.splitlines(True):
 if line.endswith("\r\n"):
 fullline = True
 cmd = line[:-2]
 if cmd.startswith(sys.ps1):
 cmd = cmd[len(sys.ps1):]
 elif cmd.startswith(sys.ps2):
 cmd = cmd[len(sys.ps2):]
-self.__executeCommand(cmd)
+self.__executeCommand(cmd, historyIndex=historyIndex)
 if self.interruptCommandExecution:
 self.__executeCommand("")
 break
 def __clearCurrentLine(self):
 """
 if self.isListActive():
 self.SendScintilla(cmd)
 elif self.__isCursorOnLastLine():
 self.moveCursorToEOL()
+def __QScintillaLineUp(self, cmd):
+"""
+Private method to handle the cursor up command.
+@param cmd QScintilla command
+"""
+self.SendScintilla(QsciScintilla.SCI_LINEUP)
+def __QScintillaLineDown(self, cmd):
+"""
+Private method to handle the cursor down command.
+@param cmd QScintilla command
+"""
+self.SendScintilla(QsciScintilla.SCI_LINEDOWN)
 def __QScintillaHistoryUp(self, cmd):
 """
-Private method to handle the Ctrl+Up key.
+Private method to handle the history up command.
 @param cmd QScintilla command
 """
-line, col = self.__getEndPos()
+if self.isHistoryEnabled():
-buf = self.text(line)
+line, col = self.__getEndPos()
-if buf.startswith(sys.ps1):
+buf = self.text(line)
-buf = buf.replace(sys.ps1, "")
+if buf.startswith(sys.ps1):
-if buf.startswith(sys.ps2):
+buf = buf.replace(sys.ps1, "")
-buf = buf.replace(sys.ps2, "")
+if buf.startswith(sys.ps2):
-if buf and self.incrementalSearchActive:
+buf = buf.replace(sys.ps2, "")
-if self.incrementalSearchString:
+if buf and self.incrementalSearchActive:
-idx = self.__rsearchHistory(self.incrementalSearchString,
+if self.incrementalSearchString and \
-self.histidx)
+buf.startswith(self.incrementalSearchString):
-if idx >= 0:
+idx, found = self.__rsearchHistory(
-self.histidx = idx
+self.incrementalSearchString, self.__histidx)
+if found and idx >= 0:
+self.__setHistoryIndex(index=idx)
+self.__useHistory()
+else:
+idx, found = self.__rsearchHistory(buf)
+if found and idx >= 0:
+self.__setHistoryIndex(index=idx)
+self.incrementalSearchString = buf
+self.__useHistory()
+else:
+if self.__historyWrap:
+if self.__histidx < 0:
+# wrap around
+self.__setHistoryIndex(index=len(self.__history) - 1)
+else:
+self.__setHistoryIndex(index=self.__histidx - 1)
 self.__useHistory()
+else:
+if self.__histidx < 0:
+self.__setHistoryIndex(index=len(self.__history) - 1)
+self.__useHistory()
+elif self.__histidx > 0:
+self.__setHistoryIndex(index=self.__histidx - 1)
+self.__useHistory()
+def __QScintillaHistoryDown(self, cmd):
+"""
+Private method to handle the history down command.
+@param cmd QScintilla command
+"""
+if self.isHistoryEnabled():
+line, col = self.__getEndPos()
+buf = self.text(line)
+if buf.startswith(sys.ps1):
+buf = buf.replace(sys.ps1, "")
+if buf.startswith(sys.ps2):
+buf = buf.replace(sys.ps2, "")
+if buf and self.incrementalSearchActive:
+if self.incrementalSearchString and \
+buf.startswith(self.incrementalSearchString):
+idx, found = self.__searchHistory(
+self.incrementalSearchString, self.__histidx)
+if found and idx >= 0:
+self.__setHistoryIndex(index=idx)
+self.__useHistory()
+else:
+idx, found = self.__searchHistory(buf)
+if found and idx >= 0:
+self.__setHistoryIndex(index=idx)
+self.incrementalSearchString = buf
+self.__useHistory()
 else:
-idx = self.__rsearchHistory(buf)
+if self.__historyWrap:
-if idx >= 0:
+if self.__histidx >= len(self.__history) - 1:
-self.histidx = idx
+# wrap around
-self.incrementalSearchString = buf
+self.__setHistoryIndex(index=0)
+else:
+self.__setHistoryIndex(index=self.__histidx + 1)
 self.__useHistory()
 else:
-if self.histidx < 0:
+if self.__isHistoryIndexValid():
-self.histidx = len(self.history)
+self.__setHistoryIndex(index=self.__histidx + 1)
-if self.histidx > 0:
+self.__useHistory()
-self.histidx = self.histidx - 1
-self.__useHistory()
+def __QScintillaCancel(self):
+"""
-def __QScintillaHistoryDown(self, cmd):
+Private method to handle the ESC command.
 """
-Private method to handle the Ctrl+Down key.
+if self.incrementalSearchActive:
+self.__resetIncrementalHistorySearch()
-@param cmd QScintilla command
+self.__insertHistory("")
-"""
-line, col = self.__getEndPos()
-buf = self.text(line)
-if buf.startswith(sys.ps1):
-buf = buf.replace(sys.ps1, "")
-if buf.startswith(sys.ps2):
-buf = buf.replace(sys.ps2, "")
-if buf and self.incrementalSearchActive:
-if self.incrementalSearchString:
-idx = self.__searchHistory(
-self.incrementalSearchString, self.histidx)
-if idx >= 0:
-self.histidx = idx
-self.__useHistory()
-else:
-idx = self.__searchHistory(buf)
-if idx >= 0:
-self.histidx = idx
-self.incrementalSearchString = buf
-self.__useHistory()
-else:
-if self.histidx >= 0 and self.histidx < len(self.history):
-self.histidx += 1
-self.__useHistory()
 def __QScintillaCharLeftExtend(self):
 """
 Private method to handle the Extend Selection Left command.
 """
 self.__QScintillaLeftCommand(self.extendSelectionLeft, True)
 @param cmd QScintilla command
 """
 if self.isListActive() or self.isCallTipActive():
 self.SendScintilla(cmd)
-def __executeCommand(self, cmd):
+def __executeCommand(self, cmd, historyIndex=None):
 """
 Private slot to execute a command.
-@param cmd command to be executed by debug client (string)
+@param cmd command to be executed by debug client
+@type str
+@param historyIndex history index to be set
+@type int
 """
 if not self.inRawMode:
 self.inCommandExecution = True
 self.interruptCommandExecution = False
 if not cmd:
+# make sure cmd is a string
 cmd = ''
-if len(self.history) == 0 or self.history[-1] != cmd:
-if len(self.history) == self.maxHistoryEntries:
+# History Handling
-del self.history[0]
+if self.isHistoryEnabled():
-self.history.append(cmd)
+if cmd != "" and (
-self.histidx = -1
+len(self.__history) == 0 or self.__history[-1] != cmd):
+if len(self.__history) == self.__maxHistoryEntries:
+del self.__history[0]
+self.__history.append(cmd)
+if self.__historyStyle == ShellHistoryStyle.LinuxStyle:
+self.__setHistoryIndex(index=-1)
+elif self.__historyStyle == ShellHistoryStyle.WindowsStyle:
+if historyIndex is None:
+if cmd != self.__history[self.__histidx - 1]:
+self.__setHistoryIndex(index=-1)
+else:
+self.__setHistoryIndex(historyIndex)
 if cmd.startswith('start '):
 if not self.passive:
 cmdList = cmd.split(None, 1)
 if len(cmdList) < 2:
 self.dbs.startClient(False)  # same as reset
 def __useHistory(self):
 """
 Private method to display a command from the history.
 """
-if self.histidx < len(self.history):
+if self.__isHistoryIndexValid():
-cmd = self.history[self.histidx]
+cmd = self.__history[self.__histidx]
 else:
 cmd = ""
-self.incrementalSearchString = ""
+self.__resetIncrementalHistorySearch()
-self.incrementalSearchActive = False
 self.__insertHistory(cmd)
 def __insertHistory(self, cmd):
 """
 self.setCursorPosition(self.prline, self.prcol)
 self.setSelection(self.prline, self.prcol,
 self.prline, self.lineLength(self.prline))
 self.removeSelectedText()
 self.__insertText(cmd)
+def __resetIncrementalHistorySearch(self):
+"""
+Private method to reset the incremental history search.
+"""
+self.incrementalSearchString = ""
+self.incrementalSearchActive = False
 def __searchHistory(self, txt, startIdx=-1):
 """
 Private method used to search the history.
-@param txt text to match at the beginning (string)
+@param txt text to match at the beginning
-@param startIdx index to start search from (integer)
+@type str
-@return index of found entry (integer)
+@param startIdx index to start search from
+@type int
+@return tuple containing the index of found entry and a flag indicating
+that something was found
+@rtype tuple of (int, bool)
 """
 if startIdx == -1:
 idx = 0
 else:
 idx = startIdx + 1
-while idx < len(self.history) and \
+while idx < len(self.__history) and \
-not self.history[idx].startswith(txt):
+not self.__history[idx].startswith(txt):
 idx += 1
-return idx
+found = (idx < len(self.__history) and
+self.__history[idx].startswith(txt))
+return idx, found
 def __rsearchHistory(self, txt, startIdx=-1):
 """
 Private method used to reverse search the history.
-@param txt text to match at the beginning (string)
+@param txt text to match at the beginning
-@param startIdx index to start search from (integer)
+@type str
-@return index of found entry (integer)
+@param startIdx index to start search from
+@type int
+@return tuple containing the index of found entry and a flag indicating
+that something was found
+@rtype tuple of (int, bool)
 """
 if startIdx == -1:
-idx = len(self.history) - 1
+idx = len(self.__history) - 1
 else:
 idx = startIdx - 1
 while idx >= 0 and \
-not self.history[idx].startswith(txt):
+not self.__history[idx].startswith(txt):
 idx -= 1
-return idx
+found = idx >= 0 and self.__history[idx].startswith(txt)
+return idx, found
 def focusNextPrevChild(self, nextChild):
 """
 Public method to stop Tab moving to the next window.
 # set the autocompletion and calltips function
 self.__setAutoCompletion()
 self.__setCallTips()
 # do the history related stuff
-self.maxHistoryEntries = Preferences.getShell("MaxHistoryEntries")
+self.__maxHistoryEntries = Preferences.getShell("MaxHistoryEntries")
-for key in list(self.historyLists.keys()):
+for key in list(self.__historyLists.keys()):
-self.historyLists[key] = \
+self.__historyLists[key] = \
-self.historyLists[key][-self.maxHistoryEntries:]
+self.__historyLists[key][-self.__maxHistoryEntries:]
+self.__historyStyle = Preferences.getShell("HistoryStyle")
+self.__historyWrap = Preferences.getShell("HistoryWrap")
+self.__setHistoryIndex()
+if not self.__windowed:
+self.hmenu.menuAction().setEnabled(self.isHistoryEnabled())
+self.__setupCursorKeys()
+self.historyStyleChanged.emit(self.__historyStyle)
 # do stdout /stderr stuff
 showStdOutErr = Preferences.getShell("ShowStdOutErr")
 if self.__showStdOutErr != showStdOutErr:
 if showStdOutErr:
 line, index = -1, -1
 ok = self.findFirst(
 txt, False, caseSensitive, wholeWord, False,
 forward=False, line=line, index=index)
 self.searchStringFound.emit(ok)
+def historyStyle(self):
+"""
+Public method to get the shell history style.
+@return shell history style
+@rtype ShellHistoryStyle
+"""
+return self.__historyStyle
+def isHistoryEnabled(self):
+"""
+Public method to check, if the history is enabled.
+@return flag indicating if history is enabled
+@rtype bool
+"""
+return self.__historyStyle != ShellHistoryStyle.Disabled

Mercurial Repositories > eric / file comparison

comparison: QScintilla/Shell.py

QScintilla/Shell.py