eric: comparison eric6/MicroPython/MicroPythonReplWidget.py

-:d5f340dfb986
+:8e10acb1cd85
 from __future__ import unicode_literals
 import re
-from PyQt5.QtCore import (
+from PyQt5.QtCore import pyqtSlot, pyqtSignal, Qt, QPoint, QEvent
-pyqtSlot, pyqtSignal, Qt, QPoint, QEvent, QIODevice, QTimer
+from PyQt5.QtGui import QColor, QKeySequence, QTextCursor, QBrush
-)
-from PyQt5.QtGui import (
-QColor, QKeySequence, QTextCursor, QBrush
-)
 from PyQt5.QtWidgets import (
 QWidget, QMenu, QApplication, QHBoxLayout, QSpacerItem, QSizePolicy
 )
-try:
-from PyQt5.QtSerialPort import QSerialPort
-HAS_QTSERIALPORT = True
-except ImportError:
-HAS_QTSERIALPORT = False
 from E5Gui.E5ZoomWidget import E5ZoomWidget
 from E5Gui import E5MessageBox, E5FileDialog
 from E5Gui.E5Application import e5App
 from .MicroPythonGraphWidget import MicroPythonGraphWidget
 HAS_QTCHART = True
 except ImportError:
 HAS_QTCHART = False
 from .MicroPythonFileManagerWidget import MicroPythonFileManagerWidget
+try:
+from .MicroPythonCommandsInterface import MicroPythonCommandsInterface
+HAS_QTSERIALPORT = True
+except ImportError:
+HAS_QTSERIALPORT = False
 import Globals
 import UI.PixmapCache
 import Preferences
 17: QBrush(QColor(255, 255, 255)),
 },
 }
+# TODO: make wrapping an option for the repl edit
+# TODO: add a connect button or make the disconnect button with changing icon (see IRC)
 class MicroPythonReplWidget(QWidget, Ui_MicroPythonReplWidget):
 """
 Class implementing the MicroPython REPL widget.
 @signal dataReceived(data) emitted to send data received via the serial
 self.__zoomWidget.setMinimum(self.ZoomMin)
 self.__zoomWidget.setMaximum(self.ZoomMax)
 self.__zoomWidget.valueChanged.connect(self.__doZoom)
 self.__currentZoom = 0
-self.__serial = None
+self.__fileManagerWidget = None
+self.__interface = MicroPythonCommandsInterface(self)
 self.__device = None
+self.__connected = False
 self.setConnected(False)
+# TODO: replace these by checking the button states
 self.__replRunning = False
 self.__plotterRunning = False
 self.__fileManagerRunning = False
 if not HAS_QTSERIALPORT:
 self.replEdit.installEventFilter(self)
 self.replEdit.customContextMenuRequested.connect(
 self.__showContextMenu)
 self.__ui.preferencesChanged.connect(self.__handlePreferencesChanged)
+self.__ui.preferencesChanged.connect(
+self.__interface.handlePreferencesChanged)
 self.__handlePreferencesChanged()
 charFormat = self.replEdit.currentCharFormat()
 self.DefaultForeground = charFormat.foreground()
 self.__font = Preferences.getEditorOtherFonts("MonospacedFont")
 self.replEdit.setFontFamily(self.__font.family())
 self.replEdit.setFontPointSize(self.__font.pointSize())
+def commandsInterface(self):
+"""
+Public method to get a reference to the commands interface object.
+@return reference to the commands interface object
+@rtype MicroPythonCommandsInterface
+"""
+return self.__interface
 @pyqtSlot(int)
 def on_deviceTypeComboBox_activated(self, index):
 """
 Private slot handling the selection of a device type.
 Public method to set the connection status LED.
 @param connected connection state
 @type bool
 """
-if connected:
+self.__connected = connected
-self.deviceConnectedLed.setColor(QColor(Qt.green))
-else:
+self.deviceConnectedLed.setOn(connected)
-self.deviceConnectedLed.setColor(QColor(Qt.red))
+if self.__fileManagerWidget:
+self.__fileManagerWidget.deviceConnectedLed.setOn(connected)
 self.deviceTypeComboBox.setEnabled(not connected)
 self.disconnectButton.setEnabled(connected)
 """ of MicroPython (or CircuitPython) flashed onto"""
 """ it before anything will work.\n\nFinally press"""
 """ the device's reset button and wait a few seconds"""
 """ before trying again."""))
-@pyqtSlot()
+@pyqtSlot(bool)
-def on_replButton_clicked(self):
+def on_replButton_clicked(self, checked):
 """
-Private slot to connect to the selected device and start a REPL.
+Private slot to connect to enable or disable the REPL widget connecting
+or disconnecting from the device.
+@param checked state of the button
+@type bool
 """
 if not self.__device:
 self.__showNoDeviceMessage()
 return
-if self.__replRunning:
+if checked:
-self.dataReceived.disconnect(self.__processData)
-if not self.__plotterRunning:
-self.__disconnectSerial()
-self.__replRunning = False
-self.__device.setRepl(False)
-else:
 ok, reason = self.__device.canStartRepl()
 if not ok:
 E5MessageBox.warning(
 self,
 self.tr("Start REPL"),
 self.tr("""<p>The REPL cannot be started.</p><p>Reason:"""
 """ {0}</p>""").format(reason))
 return
 self.replEdit.clear()
-self.dataReceived.connect(self.__processData)
+self.__interface.dataReceived.connect(self.__processData)
-if not self.__serial:
+if not self.__interface.isConnected():
-self.__openSerialLink()
+self.__connectToDevice()
-if self.__serial:
+if self.__device.forceInterrupt():
-if self.__device.forceInterrupt():
+# send a Ctrl-B (exit raw mode)
-# send a Ctrl-B (exit raw mode)
+self.__interface.write(b'\x02')
-self.__serial.write(b'\x02')
+# send Ctrl-C (keyboard interrupt)
-# send Ctrl-C (keyboard interrupt)
+self.__interface.write(b'\x03')
-self.__serial.write(b'\x03')
 self.__replRunning = True
 self.__device.setRepl(True)
 self.replEdit.setFocus(Qt.OtherFocusReason)
+else:
+self.__interface.dataReceived.disconnect(self.__processData)
+if not self.__plotterRunning and not self.__fileManagerRunning:
+self.__disconnectFromDevice()
+self.__replRunning = False
+self.__device.setRepl(False)
+self.replButton.setChecked(checked)
 @pyqtSlot()
 def on_disconnectButton_clicked(self):
 """
 Private slot to disconnect from the currently connected device.
 """
-if self.__replRunning:
+self.__disconnectFromDevice()
-self.on_replButton_clicked()
-if self.__plotterRunning:
-self.on_chartButton_clicked()
-def __disconnectSerial(self):
-"""
-Private slot to disconnect the serial connection.
-"""
-self.__closeSerialLink()
-self.setConnected(False)
 @pyqtSlot()
 def __clear(self):
 """
 Private slot to clear the REPL pane.
 """
 self.replEdit.clear()
-self.__serial and self.__serial.write(b"\r")
+self.__interface.isConnected() and self.__interface.write(b"\r")
 @pyqtSlot()
 def __paste(self):
 """
 Private slot to perform a paste operation.
 if clipboard:
 pasteText = clipboard.text()
 if pasteText:
 pasteText = pasteText.replace('\n\r', '\r')
 pasteText = pasteText.replace('\n', '\r')
-self.__serial and self.__serial.write(
+self.__interface.isConnected() and self.__interface.write(
 pasteText.encode("utf-8"))
 def eventFilter(self, obj, evt):
 """
 Public method to process events for the REPL pane.
 msg = b''
 elif key in (Qt.Key_Return, Qt.Key_Enter):
 tc = self.replEdit.textCursor()
 tc.movePosition(QTextCursor.EndOfLine)
 self.replEdit.setTextCursor(tc)
-self.__serial and self.__serial.write(msg)
+self.__interface.isConnected() and self.__interface.write(msg)
 return True
 else:
 # standard event processing
 return super(MicroPythonReplWidget, self).eventFilter(obj, evt)
 tc.removeSelectedText()
 self.replEdit.setTextCursor(tc)
 elif action == "m":
 self.__setCharFormat(match.group(0)[:-1].split(";"),
 tc)
-##            elif data[index] == 10:     # \n
-##                tc.movePosition(QTextCursor.End)
-##                self.replEdit.setTextCursor(tc)
-##                self.replEdit.insertPlainText(chr(data[index]))
-##                self.__setCharFormat(["0"], tc)     # reset format after a \n
 else:
 tc.deleteChar()
 self.replEdit.setTextCursor(tc)
 self.replEdit.insertPlainText(chr(data[index]))
 return portName
 else:
 # return with device path prepended
 return "/dev/{0}".format(portName)
-def __openSerialLink(self):
+def __connectToDevice(self):
 """
-Private method to open a serial link to the selected device.
+Private method to connect to the selected device.
 """
 port = self.__getCurrentPort()
-self.__serial = QSerialPort()
+if self.__interface.connectToDevice(port):
-self.__serial.setPortName(port)
-if self.__serial.open(QIODevice.ReadWrite):
-self.__serial.setDataTerminalReady(True)
-# 115.200 baud, 8N1
-self.__serial.setBaudRate(115200)
-self.__serial.setDataBits(QSerialPort.Data8)
-self.__serial.setParity(QSerialPort.NoParity)
-self.__serial.setStopBits(QSerialPort.OneStop)
-self.__serial.readyRead.connect(self.__readSerial)
 self.setConnected(True)
 else:
 E5MessageBox.warning(
 self,
 self.tr("Serial Device Connect"),
 self.tr("""<p>Cannot connect to device at serial port"""
 """ <b>{0}</b>.</p>""").format(port))
-self.__serial = None
+def __disconnectFromDevice(self):
-def __closeSerialLink(self):
+"""
-"""
+Private method to disconnect from the device.
-Private method to close the open serial connection.
+"""
-"""
+self.__interface.disconnectFromDevice()
-if self.__serial:
+self.setConnected(False)
-self.__serial.close()
-self.__serial = None
-@pyqtSlot()
-def __readSerial(self):
-"""
-Private slot to read all available serial data and emit it with the
-"dataReceived" signal for further processing.
-"""
-data = bytes(self.__serial.readAll())
-self.dataReceived.emit(data)
-def execute(self, commandsList):
-"""
-Public method to execute a series of commands over a period of time.
-@param commandsList list of commands to be execute on the device
-@type list of bytes
-"""
-def remainingTask(commands):
-self.execute(commands)
-if commandsList:
-command = commandsList[0]
-self.__serial.write(command)
-remainder = commandsList[1:]
-QTimer.singleShot(2, lambda: remainingTask(remainder))
 @pyqtSlot()
 def on_runButton_clicked(self):
 """
 Private slot to execute the script of the active editor on the
 self.tr("""<p>Cannot run script.</p><p>Reason:"""
 """ {0}</p>""").format(reason))
 return
 if not self.__replRunning:
-self.on_replButton_clicked()
+# switch on the REPL
+self.on_replButton_clicked(True)
 if self.__replRunning:
 self.__device.runScript(script)
 @pyqtSlot()
 def on_openButton_clicked(self):
 workspace = self.__device.getWorkspace()
 aw = e5App().getObject("ViewManager").activeWindow()
 if aw:
 aw.saveFileAs(workspace)
-@pyqtSlot()
+@pyqtSlot(bool)
-def on_chartButton_clicked(self):
+def on_chartButton_clicked(self, checked):
 """
 Private slot to open a chart view to plot data received from the
 connected device.
+@param checked state of the button
+@type bool
 """
 if not HAS_QTCHART:
 # QtChart not available => fail silently
 return
 if not self.__device:
 self.__showNoDeviceMessage()
 return
-if self.__plotterRunning:
+if checked:
+ok, reason = self.__device.canStartPlotter()
+if not ok:
+E5MessageBox.warning(
+self,
+self.tr("Start Chart"),
+self.tr("""<p>The Chart cannot be started.</p><p>Reason:"""
+""" {0}</p>""").format(reason))
+return
+self.__chartWidget = MicroPythonGraphWidget(self)
+self.__interface.dataReceived.connect(
+self.__chartWidget.processData)
+self.__chartWidget.dataFlood.connect(
+self.handleDataFlood)
+self.__ui.addSideWidget(self.__ui.BottomSide, self.__chartWidget,
+UI.PixmapCache.getIcon("chart"),
+self.tr("μPy Chart"))
+self.__ui.showSideWidget(self.__chartWidget)
+if not self.__interface.isConnected():
+self.__connectToDevice()
+if self.__device.forceInterrupt():
+# send a Ctrl-B (exit raw mode)
+self.__interface.write(b'\x02')
+# send Ctrl-C (keyboard interrupt)
+self.__interface.write(b'\x03')
+self.__plotterRunning = True
+self.__device.setPlotter(True)
+else:
 if self.__chartWidget.isDirty():
 res = E5MessageBox.okToClearData(
 self,
 self.tr("Unsaved Chart Data"),
 self.tr("""The chart contains unsaved data."""),
 self.__chartWidget.saveData)
 if not res:
 # abort
 return
-self.dataReceived.disconnect(self.__chartWidget.processData)
+self.__interface.dataReceived.disconnect(
-self.__chartWidget.dataFlood.disconnect(self.handleDataFlood)
+self.__chartWidget.processData)
+self.__chartWidget.dataFlood.disconnect(
-if not self.__replRunning:
+self.handleDataFlood)
-self.__disconnectSerial()
+if not self.__replRunning and not self.__fileManagerRunning:
+self.__disconnectFromDevice()
 self.__plotterRunning = False
 self.__device.setPlotter(False)
 self.__ui.removeSideWidget(self.__chartWidget)
-else:
-ok, reason = self.__device.canStartPlotter()
+self.__chartWidget.deleteLater()
-if not ok:
+self.__chartWidget = None
-E5MessageBox.warning(
-self,
+self.chartButton.setChecked(checked)
-self.tr("Start Chart"),
-self.tr("""<p>The Chart cannot be started.</p><p>Reason:"""
-""" {0}</p>""").format(reason))
-return
-self.__chartWidget = MicroPythonGraphWidget(self)
-self.dataReceived.connect(self.__chartWidget.processData)
-self.__chartWidget.dataFlood.connect(self.handleDataFlood)
-self.__ui.addSideWidget(self.__ui.BottomSide, self.__chartWidget,
-UI.PixmapCache.getIcon("chart"),
-self.tr("μPy Chart"))
-self.__ui.showSideWidget(self.__chartWidget)
-if not self.__serial:
-self.__openSerialLink()
-if self.__serial:
-if self.__device.forceInterrupt():
-# send a Ctrl-B (exit raw mode)
-self.__serial.write(b'\x02')
-# send Ctrl-C (keyboard interrupt)
-self.__serial.write(b'\x03')
-self.__plotterRunning = True
-self.__device.setPlotter(True)
 @pyqtSlot()
 def handleDataFlood(self):
 """
 Public slot handling a data flood from the device.
 """
 self.on_disconnectButton_clicked()
 self.__device.handleDataFlood()
-@pyqtSlot()
+@pyqtSlot(bool)
-def on_filesButton_clicked(self):
+def on_filesButton_clicked(self, checked):
 """
 Private slot to open a file manager window to the connected device.
+@param checked state of the button
+@type bool
 """
 if not self.__device:
 self.__showNoDeviceMessage()
 return
-if self.__fileManagerRunning:
+if checked:
-self.__fileManagerWidget.stop()
-self.__ui.removeSideWidget(self.__fileManagerWidget)
-self.__device.setFileManager(False)
-self.__fileManagerRunning = False
-else:
 ok, reason = self.__device.canStartFileManager()
 if not ok:
 E5MessageBox.warning(
 self,
 self.tr("Start File Manager"),
 self.tr("""<p>The File Manager cannot be started.</p>"""
 """<p>Reason: {0}</p>""").format(reason))
 return
-port = self.__getCurrentPort()
+if not self.__interface.isConnected():
-self.__fileManagerWidget = MicroPythonFileManagerWidget(port, self)
+self.__connectToDevice()
+self.__fileManagerWidget = MicroPythonFileManagerWidget(
+self.__interface, self)
 self.__ui.addSideWidget(self.__ui.BottomSide,
 self.__fileManagerWidget,
 UI.PixmapCache.getIcon("filemanager"),
 self.tr("μPy Files"))
 self.__device.setFileManager(True)
 self.__fileManagerRunning = True
 self.__fileManagerWidget.start()
+else:
+self.__fileManagerWidget.stop()
+self.__ui.removeSideWidget(self.__fileManagerWidget)
+self.__device.setFileManager(False)
+self.__fileManagerRunning = False
+self.__fileManagerWidget.deleteLater()
+self.__fileManagerWidget = None

Mercurial Repositories > eric / file comparison

comparison: eric6/MicroPython/MicroPythonReplWidget.py

eric6/MicroPython/MicroPythonReplWidget.py