def get_editor(self):
"""
Return an editor object based on QScintilla if available.
Else, return a standard editor.
"""
try:
from PyQt4.Qsci import QsciScintilla, QsciLexerPython, QsciAPIs
textedit = QsciScintilla(self)
textedit.setAutoIndent(True)
textedit.setAutoCompletionThreshold(2)
textedit.setAutoCompletionSource(QsciScintilla.AcsDocument)
# API
lex = QsciLexerPython(textedit)
textedit.setLexer(lex)
# apis = QsciAPIs(lex)
# apis.prepare()
textedit.setMinimumWidth(250)
textedit.setMinimumHeight(250)
except ImportError:
textedit = qt.QtGui.QTextEdit(self)
textedit.setLineWrapMode(qt.QtGui.QTextEdit.NoWrap)
textedit.setMinimumWidth(200)
textedit.setMinimumHeight(200)
return textedit
class ScriptManager(MDialog):
def __init__(self, _parent):
MDialog.__init__(self, _parent)
from PyQt4.Qsci import QsciScintilla, QsciLexerPython, QsciAPIs
if isActivePyKDE4:
self.setButtons(MDialog.NoDefault)
self.sciCommand = QsciScintilla()
self.sciCommand.setUtf8(True)
self.sciCommand.setAutoIndent(True)
self.sciCommand.setIndentationGuides(True)
self.sciCommand.setIndentationsUseTabs(True)
self.sciCommand.setCaretLineVisible(True)
self.sciCommand.setAutoCompletionThreshold(2)
self.sciCommand.setAutoCompletionSource(QsciScintilla.AcsDocument)
self.sciCommand.setLexer(QsciLexerPython(self))
self.sciCommand.setMarginLineNumbers(1, True)
self.sciCommand.setMarginWidth(1, '0000')
self.sciCommand.setEolMode(QsciScintilla.EolUnix)
self.sciCommand.setWrapMode(QsciScintilla.WrapWord)
lblScriptList = MLabel(translate("ScriptManager", "Script List : "))
self.currentScriptFileName = None
self.lwScriptList = Options.MyListWidget(self, [], _currentRowChanged=self.getFromScriptList)
self.refreshScriptList()
pbtnCreate = MPushButton(translate("ScriptManager", "Create"))
pbtnDelete = MPushButton(translate("ScriptManager", "Delete"))
pbtnSave = MPushButton(translate("ScriptManager", "Save"))
pbtnScriptManagerAndClose = MPushButton(translate("ScriptManager", "Run And Close"))
pbtnScriptManager = MPushButton(translate("ScriptManager", "Run"))
pbtnClose = MPushButton(translate("ScriptManager", "Close"))
pbtnClear = MPushButton(translate("ScriptManager", "Clear"))
self.cckbIsAutoSaveScripts = Options.MyCheckBox(self, translate("ScriptManager", "Auto Save"), 2,
"isAutoSaveScripts")
self.connect(pbtnCreate, SIGNAL("clicked()"), self.create)
self.connect(pbtnDelete, SIGNAL("clicked()"), self.delete)
self.connect(pbtnSave, SIGNAL("clicked()"), self.save)
self.connect(pbtnScriptManagerAndClose, SIGNAL("clicked()"), self.runScriptAndClose)
self.connect(pbtnScriptManager, SIGNAL("clicked()"), self.runScript)
self.connect(pbtnClose, SIGNAL("clicked()"), self.close)
self.connect(pbtnClear, SIGNAL("clicked()"), self.clear)
pnlMain = MWidget(self)
vblMain = MVBoxLayout(pnlMain)
vbox = MVBoxLayout()
vbox.addWidget(lblScriptList)
vbox.addWidget(self.lwScriptList)
hbox2 = MHBoxLayout()
hbox2.addWidget(pbtnCreate)
hbox2.addWidget(pbtnDelete)
vbox.addLayout(hbox2)
hbox0 = MHBoxLayout()
hbox0.addLayout(vbox)
hbox0.addWidget(self.sciCommand)
hbox1 = MHBoxLayout()
hbox1.addWidget(self.cckbIsAutoSaveScripts)
hbox1.addStretch(1)
hbox1.addWidget(pbtnClear, 1)
hbox1.addWidget(pbtnSave, 1)
hbox1.addWidget(pbtnScriptManager, 1)
hbox1.addWidget(pbtnScriptManagerAndClose, 1)
hbox1.addWidget(pbtnClose, 1)
vblMain.addLayout(hbox0)
vblMain.addLayout(hbox1)
if isActivePyKDE4:
self.setMainWidget(pnlMain)
else:
self.setLayout(vblMain)
self.setWindowTitle(translate("ScriptManager", "Script Manager"))
self.setWindowIcon(MIcon("Images:scriptManager.png"))
self.lwScriptList.setMaximumWidth(150)
self.setMinimumWidth(650)
self.setMinimumHeight(450)
self.show()
def closeEvent(self, _event):
if self.checkForSave() is False:
_event.ignore()
@staticmethod
def checkScriptManager(_isAlertIfNotAvailable=True):
try:
from PyQt4.Qsci import QsciScintilla
return True
except:
if _isAlertIfNotAvailable:
Dialogs.showError(translate("MenuBar", "Qsci Is Not Installed"),
translate("MenuBar",
"Qsci is not installed on your systems.<br>Please install Qsci on your system and try again."))
return False
def getFromScriptList(self, _index=None):
try:
if self.checkForSave():
self.currentScriptFileName = self.scriptList[self.lwScriptList.currentRow()]
codes = Scripts.getScript(fu.joinPath(Scripts.pathOfScripsDirectory, self.currentScriptFileName))
self.sciCommand.setText(str(codes))
except:
ReportBug.ReportBug()
def runScriptAndClose(self):
try:
if self.runScript():
self.close()
except:
ReportBug.ReportBug()
def runScript(self):
try:
return Scripts.runScript(str(self.sciCommand.text()))
except:
ReportBug.ReportBug()
def checkForSave(self):
try:
if self.currentScriptFileName is not None:
if fu.isFile(fu.joinPath(Scripts.pathOfScripsDirectory, self.currentScriptFileName)):
codes = Scripts.getScript(fu.joinPath(Scripts.pathOfScripsDirectory, self.currentScriptFileName))
if str(codes) != str(self.sciCommand.text()):
if self.cckbIsAutoSaveScripts.checkState() == Mt.Checked:
self.save()
else:
answer = Dialogs.ask(translate("ScriptManager", "Do You Wish To Save Your Codes?"),
translate("ScriptManager",
"Do you wish to save your codes so that you can continue later?"),
True)
if answer == Dialogs.Yes:
self.save()
elif answer == Dialogs.Cancel:
return False
return True
except:
ReportBug.ReportBug()
def save(self):
try:
codes = Scripts.getScript(fu.joinPath(Scripts.pathOfScripsDirectory, self.currentScriptFileName))
Scripts.saveScript(fu.joinPath(Scripts.pathOfScripsDirectory, self.currentScriptFileName),
str(self.sciCommand.text()))
except:
ReportBug.ReportBug()
def clear(self):
try:
answer = Dialogs.ask(translate("ScriptManager", "Your Codes Will Be Deleted!.."),
translate("ScriptManager",
"Your codes will be deleted and the default codes will be installed. Do you wish to clear the current codes?"))
if answer == Dialogs.Yes:
Scripts.clearScript(fu.joinPath(Scripts.pathOfScripsDirectory, self.currentScriptFileName))
except:
ReportBug.ReportBug()
def delete(self):
try:
answer = Dialogs.ask(translate("ScriptManager", "Your Script Will Be Deleted!.."),
translate("ScriptManager",
"Your script will be deleted. Are you sure you want to delete current script?"))
if answer == Dialogs.Yes:
fu.removeFile(fu.joinPath(Scripts.pathOfScripsDirectory, self.currentScriptFileName))
self.refreshScriptList()
except:
ReportBug.ReportBug()
def create(self):
try:
newScriptFileName = Scripts.createNewScript()
self.refreshScriptList()
self.lwScriptList.setCurrentRow(self.scriptList.index(newScriptFileName))
except:
ReportBug.ReportBug()
def refreshScriptList(self):
try:
self.scriptList = Scripts.getScriptList()
self.lwScriptList.refresh(self.scriptList)
scriptFileName = None
if len(self.scriptList) > 0:
scriptFileName = self.scriptList[self.lwScriptList.currentRow()]
self.currentScriptFileName = scriptFileName
except:
ReportBug.ReportBug()
editor = QsciScintilla()
## Choose a lexer
## This can be any Scintilla lexer, but the original example used Python
lexer = QsciLexerPython()
## Create an API for us to populate with our autocomplete terms
api = Qsci.QsciAPIs(lexer)
## Add autocompletion strings
api.add("aLongString")
api.add("aLongerString")
api.add("aDifferentString")
api.add("sOmethingElse")
## Compile the api for use in the lexer
api.prepare()
editor.setLexer(lexer)
## Set the length of the string before the editor tries to autocomplete
## In practise this would be higher than 1
## But its set lower here to make the autocompletion more obvious
editor.setAutoCompletionThreshold(1)
## Tell the editor we are using a QsciAPI for the autocompletion
editor.setAutoCompletionSource(QsciScintilla.AcsAPIs)
## Render on screen
editor.show()
## Show this file in the editor
editor.setText(open("simple_editor.py").read())
sys.exit(app.exec_())
class FromWidget(QWidget):
def __init__(self, parent):
super(FromWidget, self).__init__(parent)
#add the text editor to the widget.
self.text = QsciScintilla(self)
self.text.setGeometry(10,100,500,500)
#set the code to be read to Python code
self.lexer = QsciLexerPython()
## Create an API for us to populate with our autocomplete terms
self.generate_code = Qsci.QsciAPIs(self.lexer)
## Add autocompletion strings
self.generate_code.add("set_image")
self.generate_code.add("draw_actor")
# Compile the api for use in the lexer
self.generate_code.prepare()
#sets the program code in the text editor to the generated code
self.open_generated_code()
#set the lext
self.text.setLexer(self.lexer)
#Set the length of the string before the editor tries to autocomplete
self.text.setAutoCompletionThreshold(1)
#Tell the editor we are using a QsciAPI for the autocompletion
self.text.setAutoCompletionSource(QsciScintilla.AcsAPIs)
#set the background and foreground colour of the margin
self.text.setMarginsBackgroundColor(QColor(34,139,34))
self.text.setMarginsForegroundColor(QColor(0,0,0))
#set the line numbers from 1
self.text.setMarginLineNumbers(1,True)
self.text.setAutoIndent(True)
self.text.setIndentationsUseTabs(False)
#allow the user to collapse code
self.text.setFolding(1)
self.create_buttons()
self.buttons_controler()
#function to creat buttons
def create_buttons(self):
#create runcode button and add it to the widget
self.runcodebutton = QtGui.QPushButton("Run Code",self)
self.runcodebutton.setGeometry(100,610,70,30)
#create generatecode button and add it to the widget
self.generatecodebutton = QtGui.QPushButton("Generate Template",self)
self.generatecodebutton.setGeometry(400,5,100,30)
#create savecode button and add it to the widget
self.savecodebutton = QtGui.QPushButton("Save Code",self)
self.savecodebutton.setGeometry(10,610,70,30)
#signals which connects buttons to actions
def buttons_controler(self):
self.runcodebutton.clicked.connect(self.run_code_button_clicked)
self.generatecodebutton.clicked.connect(self.gen_code_button_clicked)
self.savecodebutton.clicked.connect(self.askQuestion)
#opens the generated program code
def open_generated_code(self):
self.filename ='marioexample2.py'
f = open(self.filename, 'r')
filedata = f.read()
self.text.setText(filedata)
f.close()
#performs action for run code button
def run_code_button_clicked(self):
interpreter = InteractiveInterpreter()
interpreter.runcode(self.text.text())
#perfoms action for generate code button
def gen_code_button_clicked(self):
#ask if user is sure theu could like to regenerate code, in dialogue
quit_msg = "Are you sure you would like to regenerate your program code, your current\ncode will be overidden unless you save your code."
answer = QtGui.QMessageBox.question(self, 'Pygame Simplfied message',
quit_msg, QtGui.QMessageBox.Yes, QtGui.QMessageBox.No)
#if the users answer is yes, regenerate the code
if answer == QtGui.QMessageBox.Yes:
self.filename ='marioexample2.py'
f = open(self.filename, 'r')
filedata = f.read()
self.text.setText(filedata)
f.close()
#if the user clicks the save button, the code is saved
def save(self):
f = open('mygame.py', 'w')
#gets the text from the text editor
filedata = self.text.text()
f.write(filedata)
f.close()
#check if user wants to save their program
def askQuestion(self, event):
quit_msg = "Are you would like to save your program?\nthis will save as mygame.py"
answer = QtGui.QMessageBox.question(self, 'Pygame Simplfied message',
quit_msg, QtGui.QMessageBox.Yes, QtGui.QMessageBox.No)
if answer == QtGui.QMessageBox.Yes:
self.save()
def createNewTab(self, filename, msg, lexer):
if type(msg) is bytes:
msg = msg.decode(encoding='utf-8')
if str(msg).find("\r\n") >= 0:
msg = msg.replace('\n', '')
elif str(msg).find("\n") >= 0 and str(msg).find("\r") < 0:
msg = msg.replace("\n", "\r")
else:
print("creatNewTab has other endswith.")
editor = QsciScintilla()
editor.setUtf8(True)
editor.setLexer(lexer)
editor.setMarginsBackgroundColor(QColor(220, 220, 220))
editor.setAutoCompletionThreshold(2)
editor.setAutoCompletionSource(QsciScintilla.AcsAll)
editor.setEolMode(QsciScintilla.EolUnix)
if str(filename).find("/") >= 0:
tabname = filename.split("/")
tabname = tabname[-1]
elif str(filename) == "untitled":
tabname = "untitled"
else:
tabname = filename
self.addTab(editor, tabname)
self.setTabToolTip(self.count() - 1, filename)
if filename == "untitled":
self.tabBar().setTabTextColor(self.count() - 1, QColor(Qt.red))
self.setTabIcon(self.count() - 1, QIcon(':/pc.png'))
if self.ui.currentBoard == "microbit":
msg = "from microbit import *\r#write your program:\r"
elif str(filename).find(":") > 0:
self.tabBar().setTabTextColor(self.count() - 1, QColor(Qt.red))
self.setTabIcon(self.count() - 1, QIcon(':/pc.png'))
else:
self.tabBar().setTabTextColor(self.count() - 1, QColor(Qt.blue))
self.setTabIcon(self.count() - 1, QIcon(':/ic.png'))
editor.setText(msg)
editor.setContextMenuPolicy(Qt.CustomContextMenu)
self.connect(editor,
SIGNAL("customContextMenuRequested(const QPoint&)"),
self.slotEditorRightClickMenu)
if self.editorRightMenu == None:
self.editorRightMenu = QMenu(self)
self.editorRightMenu.setStyleSheet(
"QMenu::item{padding:4px 16px;}"
"QMenu::item::selected{background-color:rgb(135,206,255);}")
undo = QAction(self.tr("Undo"), self)
undo.setShortcut("Ctrl+Z")
self.connect(undo, SIGNAL("triggered()"), self.slotUndo)
redo = QAction(self.tr("Redo"), self)
redo.setShortcut("Ctrl+Y")
self.connect(redo, SIGNAL("triggered()"), self.slotRedo)
cut = QAction(self.tr("Cut"), self)
cut.setShortcut("Ctrl+X")
self.connect(cut, SIGNAL("triggered()"), self.slotCut)
copy = QAction(self.tr("Copy"), self)
copy.setShortcut("Ctrl+C")
self.connect(copy, SIGNAL("triggered()"), self.slotCopy)
paste = QAction(self.tr("Paste"), self)
paste.setShortcut("Ctrl+V")
self.connect(paste, SIGNAL("triggered()"), self.slotPaste)
self.editorRightMenu.addAction(undo)
self.editorRightMenu.addAction(redo)
self.editorRightMenu.addAction(cut)
self.editorRightMenu.addAction(copy)
self.editorRightMenu.addAction(paste)
#set brace match
editor.setBraceMatching(editor.StrictBraceMatch)
#set indent replace 4 space
editor.setIndentationsUseTabs(False)
editor.setTabWidth(2)
#The line number display area
editor.setMarginType(0, QsciScintilla.NumberMargin)
editor.setMarginLineNumbers(0, True)
editor.setMarginWidth(0, 30)
#set auto indentation
editor.setAutoIndent(True)
#syntax check
editor.setMarginType(1, QsciScintilla.SymbolMargin)
editor.setMarginLineNumbers(1, False)
editor.setMarginWidth(1, 5)
editor.setMarginSensitivity(1, False)
editor.setMarginMarkerMask(1, 0x1FFFFFF)
editor.markerDefine(QsciScintilla.Background, 1)
#Automatic folding area
editor.setFolding(QsciScintilla.CircledFoldStyle)
#set tab's stylesheet
editor.setStyleSheet(
"QWidget{font-size:20px;border: 1px solid white;border-radius:1px}"
)
self.setCurrentWidget(editor)
if filename != "untitled":
self.fileitem.size += 1
self.fileitem.list.append(filename)
self.connect(editor, SIGNAL("textChanged()"), self.editorTextChange)
self.connect(editor, SIGNAL("selectionChanged()"),
self.selectionChanged)
self.connect(editor, SIGNAL("linesChanged()"), self.linesChanged)
self.connect(editor, SIGNAL("cursorPositionChanged(int,int)"),
self.cursorPositionChanged)
self.connect(editor, SIGNAL("userListActivated(int,const QString)"),
self.userListActivated)
editor.setCaretLineVisible(True)
editor.setCaretLineBackgroundColor(QtGui.QColor("#CDA869"))
## Margins colors
# line numbers margin
editor.setMarginsBackgroundColor(QtGui.QColor("#333333"))
editor.setMarginsForegroundColor(QtGui.QColor("#CCCCCC"))
# folding margin colors (foreground,background)
editor.setFoldMarginColors(QtGui.QColor("#99CC66"),
QtGui.QColor("#333300"))
## Choose a lexer
lexer = QsciLexerPython1()
lexer.setDefaultFont(font)
editor.setLexer(lexer)
myApis = QsciAPIs(lexer)
myApis.add(QtCore.QString("SDR"))
myApis.add(QtCore.QString("sdr"))
myApis.prepare()
editor.setAutoCompletionSource(QsciScintilla.AcsAll)
editor.setAutoCompletionCaseSensitivity(False)
editor.setAutoCompletionThreshold(1)
## Render on screen
editor.show()
## Show this file in the editor
editor.setText(open("chardet.txt").read())
sys.exit(app.exec_())