class HyphenDialog(QDialog):
def __init__(self, mainwindow):
super(HyphenDialog, self).__init__(mainwindow)
self.setWindowModality(Qt.WindowModal)
layout = QVBoxLayout()
self.setLayout(layout)
self.topLabel = QLabel()
self.listWidget = QListWidget()
layout.addWidget(self.topLabel)
layout.addWidget(self.listWidget)
layout.addWidget(widgets.Separator())
self.buttons = b = QDialogButtonBox()
layout.addWidget(b)
b.setStandardButtons(QDialogButtonBox.Ok | QDialogButtonBox.Cancel)
help.addButton(b, lyrics_help)
b.rejected.connect(self.reject)
b.accepted.connect(self.accept)
self.load()
app.translateUI(self)
qutil.saveDialogSize(self, "hyphenation/dialog/size")
def translateUI(self):
self.setWindowTitle(app.caption(_("Hyphenate Lyrics Text")))
self.topLabel.setText(_("Please select a language:"))
def load(self):
self._langs = [(language_names.languageName(lang, po.setup.current()), lang, dic)
for lang, dic in findDicts().iteritems()]
self._langs.sort()
for name, lang, dic in self._langs:
self.listWidget.addItem("{0} ({1})".format(name, lang))
def select():
lastused = settings().value("lastused", "", type(""))
if lastused:
yield lastused
lang = po.setup.preferred()[0]
yield lang
yield lang.split('_')[0]
langs = [item[1] for item in self._langs]
for preselect in select():
try:
self.listWidget.setCurrentRow(langs.index(preselect))
break
except ValueError:
continue
def hyphenator(self):
if self.exec_() and self._langs:
lang, dic = self._langs[self.listWidget.currentRow()][1:]
result = hyphenator.Hyphenator(dic)
settings().setValue("lastused", lang)
else:
result = None
self.deleteLater()
return result
class BookView(QSplitter):
def __init__(self, parent=None):
super(BookView, self).__init__(parent=parent)
self.create_layout()
self.create_connections()
def create_layout(self):
self.web_view = QWebView()
self.chapter_list = QListWidget()
self.next_button = QPushButton("Next chapter")
self.previous_button = QPushButton("Previous chapter")
hbox = QHBoxLayout()
hbox.addStretch()
hbox.addWidget(self.previous_button)
hbox.addWidget(self.next_button)
vbox = QVBoxLayout()
vbox.addWidget(QLabel("Chapters"))
vbox.addWidget(self.chapter_list)
vbox.addLayout(hbox)
widget = QWidget()
widget.setLayout(vbox)
self.addWidget(self.web_view)
self.addWidget(widget)
def create_connections(self):
chlist = self.chapter_list
self.connect(
self.next_button, SIGNAL("clicked()"),
lambda: chlist.setCurrentRow(0 if chlist.currentRow(
) == chlist.count() - 1 else chlist.currentRow() + 1))
self.connect(
self.previous_button, SIGNAL("clicked()"),
lambda: chlist.setCurrentRow(chlist.count(
) - 1 if chlist.currentRow() == 0 else chlist.currentRow() - 1))
self.connect(self.chapter_list, SIGNAL("currentRowChanged(int)"),
self.set_chapter)
page = self.web_view.page()
page.setLinkDelegationPolicy(QWebPage.DelegateAllLinks)
def set_chapter(self, num=None):
if num is None:
num = self.chapter_list.currentRow()
if num < 0:
num = len(self.book.chapters) - 1
elif num >= len(self.book.chapters):
num = 0
self.web_view.setHtml(
self.book.get_chapter(num).decode(encoding="utf-8"))
def load_book(self, book_id):
self.book = Book(book_id)
self.chapter_list.clear()
for chapter in self.book.chapters:
self.chapter_list.addItem(chapter[0])
self.chapter_list.setCurrentRow(0)
class BookView(QSplitter):
def __init__(self, parent=None):
super(BookView, self).__init__(parent=parent)
self.create_layout()
self.create_connections()
def create_layout(self):
self.web_view = QWebView()
self.chapter_list = QListWidget()
self.next_button = QPushButton("Next chapter")
self.previous_button = QPushButton("Previous chapter")
hbox = QHBoxLayout()
hbox.addStretch()
hbox.addWidget(self.previous_button)
hbox.addWidget(self.next_button)
vbox = QVBoxLayout()
vbox.addWidget(QLabel("Chapters"))
vbox.addWidget(self.chapter_list)
vbox.addLayout(hbox)
widget = QWidget()
widget.setLayout(vbox)
self.addWidget(self.web_view)
self.addWidget(widget)
def create_connections(self):
chlist = self.chapter_list
self.connect(self.next_button, SIGNAL("clicked()"), lambda:
chlist.setCurrentRow(0
if chlist.currentRow() == chlist.count() - 1
else chlist.currentRow() + 1))
self.connect(self.previous_button, SIGNAL("clicked()"), lambda:
chlist.setCurrentRow(chlist.count() - 1
if chlist.currentRow() == 0
else chlist.currentRow() - 1))
self.connect(self.chapter_list, SIGNAL("currentRowChanged(int)"),
self.set_chapter)
page = self.web_view.page()
page.setLinkDelegationPolicy(QWebPage.DelegateAllLinks)
def set_chapter(self, num=None):
if num is None:
num = self.chapter_list.currentRow()
if num < 0:
num = len(self.book.chapters) - 1
elif num >= len(self.book.chapters):
num = 0
self.web_view.setHtml(self.book.get_chapter(num).decode(encoding="utf-8"))
def load_book(self, book_id):
self.book = Book(book_id)
self.chapter_list.clear()
for chapter in self.book.chapters:
self.chapter_list.addItem(chapter[0])
self.chapter_list.setCurrentRow(0)
class ProfilesLoader(QDialog):
def __init__(self, load_func, profiles, parent=None):
QDialog.__init__(self, parent, Qt.Dialog)
self.setMinimumWidth(400)
self._profiles = profiles
self.load_function = load_func
vbox = QVBoxLayout(self)
self.profileList = QListWidget()
self.profileList.addItems([key for key in profiles])
self.contentList = QListWidget()
self.contentList.setSortingEnabled(True)
self.btnDelete = QPushButton(self.tr("Delete Profile"))
self.btnDelete.setSizePolicy(QSizePolicy.Fixed, QSizePolicy.Fixed)
self.btnOpen = QPushButton(self.tr("Open Profile"))
self.btnOpen.setSizePolicy(QSizePolicy.Fixed, QSizePolicy.Fixed)
self.btnOpen.setDefault(True)
hbox = QHBoxLayout()
hbox.addWidget(self.btnDelete)
hbox.addWidget(self.btnOpen)
vbox.addWidget(self.profileList)
vbox.addWidget(self.contentList)
vbox.addLayout(hbox)
self.connect(self.profileList, SIGNAL("itemSelectionChanged()"),
self.load_profile_content)
self.connect(self.btnOpen, SIGNAL("clicked()"), self.open_profile)
self.connect(self.btnDelete, SIGNAL("clicked()"), self.delete_profile)
def load_profile_content(self):
item = self.profileList.currentItem()
self.contentList.clear()
key = unicode(item.text())
content = self._profiles[key]
self.contentList.addItems(content)
def open_profile(self):
if self.profileList.currentItem():
key = unicode(self.profileList.currentItem().text())
self.load_function(key)
self.close()
def delete_profile(self):
if self.profileList.currentItem():
key = unicode(self.profileList.currentItem().text())
self._profiles.pop(key)
self.profileList.takeItem(self.profileList.currentRow())
self.contentList.clear()
class TagsWidget(QWidget):
tagsChanged = pyqtSignal(list)
def __init__(self, parent=None):
super(TagsWidget, self).__init__(parent)
self.lineEdit = TagLineEdit(self)
self.lineEdit.returnPressed.connect(
lambda: QTimer.singleShot(0, self.addTag))
self.listWidget = QListWidget(self)
l = QVBoxLayout(self)
l.addWidget(self.lineEdit)
l.addWidget(self.listWidget)
self.availableTags = []
self.reload()
def reload(self):
tags = Session.query(Tag.name, Tag.id).all()
self.tagsdict = dict(tags)
self.availableTags = self.tagsdict.keys()
for i in xrange(self.listWidget.count()):
tag = self.listWidget.item(i).text()
if tag in self.availableTags:
self.availableTags.remove(tag)
self.lineEdit.completer().model().setStringList(self.availableTags)
def addTag(self):
text = self.lineEdit.text()
if text in self.availableTags:
self.availableTags.remove(text)
self.lineEdit.completer().model().setStringList(self.availableTags)
self.listWidget.addItem(text)
self.lineEdit.clear()
self.tagsChanged.emit(self.tags())
def tags(self):
tags = [
self.tagsdict[self.listWidget.item(i).text()]
for i in xrange(self.listWidget.count())
]
return tags
def keyPressEvent(self, event):
if event.key() == Qt.Key_Delete:
self.listWidget.takeItem(self.listWidget.currentRow())
self.tagsChanged.emit(self.tags())
else:
super(TagsWidget, self).keyPressEvent(event)
class TagsWidget(QWidget):
tagsChanged = pyqtSignal(list)
def __init__(self, parent=None):
super(TagsWidget, self).__init__(parent)
self.lineEdit = TagLineEdit(self)
self.lineEdit.returnPressed.connect(
lambda: QTimer.singleShot(0, self.addTag))
self.listWidget = QListWidget(self)
l = QVBoxLayout(self)
l.addWidget(self.lineEdit)
l.addWidget(self.listWidget)
self.availableTags = []
self.reload()
def reload(self):
tags = Session.query(Tag.name, Tag.id).all()
self.tagsdict = dict(tags)
self.availableTags = self.tagsdict.keys()
for i in xrange(self.listWidget.count()):
tag = self.listWidget.item(i).text()
if tag in self.availableTags:
self.availableTags.remove(tag)
self.lineEdit.completer().model().setStringList(self.availableTags)
def addTag(self):
text = self.lineEdit.text()
if text in self.availableTags:
self.availableTags.remove(text)
self.lineEdit.completer().model().setStringList(self.availableTags)
self.listWidget.addItem(text)
self.lineEdit.clear()
self.tagsChanged.emit(self.tags())
def tags(self):
tags = [self.tagsdict[self.listWidget.item(i).text()]
for i in xrange(self.listWidget.count())]
return tags
def keyPressEvent(self, event):
if event.key() == Qt.Key_Delete:
self.listWidget.takeItem(self.listWidget.currentRow())
self.tagsChanged.emit(self.tags())
else:
super(TagsWidget, self).keyPressEvent(event)
class LateralWidget(QDockWidget):
def __init__(self):
super(LateralWidget, self).__init__()
self._list_widget = QListWidget()
self.setWidget(self._list_widget)
Pireal.load_service("lateral", self)
self._list_widget.setContextMenuPolicy(Qt.CustomContextMenu)
self.connect(self._list_widget, SIGNAL("currentRowChanged(int)"),
self._change_item)
self.connect(self._list_widget,
SIGNAL("customContextMenuRequested(const QPoint)"),
self.__show_context_menu)
def __show_context_menu(self, point):
""" Context menu """
menu = QMenu()
remove_table_act = menu.addAction(QIcon(":img/remove-rel"),
self.tr("Eliminar Relación"))
self.connect(remove_table_act, SIGNAL("triggered()"),
self.remove_table)
menu.exec_(self.mapToGlobal(point))
def _change_item(self, index):
table = Pireal.get_service("container").table_widget
table.stacked.setCurrentIndex(index)
def add_item_list(self, items):
for i in items:
item = QListWidgetItem(i)
item.setTextAlignment(Qt.AlignHCenter)
self._list_widget.addItem(item)
def remove_table(self):
table_widget = Pireal.get_service("container").table_widget
current_index = self._list_widget.currentRow()
table_widget.remove_table(current_index)
self._list_widget.takeItem(current_index)
class EpisodeSelector(QDialog):
def __init__(self, feed):
super(EpisodeSelector, self).__init__()
layout = QVBoxLayout()
layout.addWidget(QLabel(feed['title']))
self.eplist = QListWidget()
self.eps = sorted(feed['entries'], key = lambda x: x['updated'])
selectionIndex = -1
i = 0
for ep in self.eps:
self.eplist.addItem(QString(ep['title']))
if ep['updated'] == feed['lastUpdate']:
selectionIndex = i
i += 1
self.eplist.setCurrentRow(selectionIndex)
layout.addWidget(self.eplist)
cancelButton = QPushButton('Cancel')
okButton = QPushButton('Set as last episode')
self.connect(cancelButton, SIGNAL('clicked()'),
self.reject)
self.connect(okButton, SIGNAL('clicked()'),
self.acceptLocal)
buttonsLayout = QHBoxLayout()
buttonsLayout.addStretch()
buttonsLayout.addWidget(cancelButton)
buttonsLayout.addWidget(okButton)
layout.addLayout(buttonsLayout)
self.setLayout(layout)
def acceptLocal(self):
self.lastUpdate = self.eps[self.eplist.currentRow()]['updated']
self.accept()
def hyphenate(text, mainwindow):
"""
Ask the user which language to use.
Returns None if the user cancels the dialog or no hyphenation pattern files
could be found.
"""
if not hyphdicts:
KMessageBox.sorry(mainwindow, i18n(
"Could not find any hyphenation dictionaries.\n\n"
"Please install a package containing some and/or or configure the "
"search path to find them in the Frescobaldi settings under "
"\"Paths.\""))
return
conf = config("hyphenation")
lang = conf.readEntry("lastused", "")
langs = list(sorted(hyphdicts.keys()))
index = lang in langs and langs.index(lang) or 0
d = KDialog(mainwindow)
d.setButtons(KDialog.ButtonCode(KDialog.Ok | KDialog.Cancel | KDialog.Help))
d.setCaption(i18n("Hyphenate Lyrics Text"))
d.setHelp("lyrics")
layout = QVBoxLayout()
d.mainWidget().setLayout(layout)
layout.addWidget(QLabel(i18n("Please select a language:")))
listbox = QListWidget()
layout.addWidget(listbox)
listbox.addItems(langs)
listbox.setCurrentRow(index)
listbox.setFocus()
if d.exec_():
lang = langs[listbox.currentRow()]
conf.writeEntry("lastused", lang)
conf.sync()
# get hyphenator
h = Hyphenator(hyphdicts[lang])
return ly.rx.lyric_word.sub(lambda m: h.inserted(m.group(), ' -- '), text)
class RunsDialog(QtHelper.EnhancedQDialog):
"""
Runs several dialog
"""
RefreshRepository = pyqtSignal(str)
def __init__(self, dialogName, parent = None, iRepo=None, lRepo=None, rRepo=None):
"""
Constructor
"""
QtHelper.EnhancedQDialog.__init__(self, parent)
self.name = self.tr("Prepare a group of runs")
self.projectReady = False
self.iRepo = iRepo
self.lRepo = lRepo
self.rRepo = rRepo
self.createDialog()
self.createConnections()
def createDialog(self):
"""
Create qt dialog
"""
self.setWindowTitle( self.name )
mainLayout = QHBoxLayout()
layoutTests = QHBoxLayout()
layoutRepoTest = QVBoxLayout()
self.prjCombo = QComboBox(self)
self.prjCombo.setEnabled(False)
self.repoTests = QTreeWidget(self)
self.repoTests.setFrameShape(QFrame.NoFrame)
if USE_PYQT5:
self.repoTests.header().setSectionResizeMode(QHeaderView.Stretch)
else:
self.repoTests.header().setResizeMode(QHeaderView.Stretch)
self.repoTests.setHeaderHidden(True)
self.repoTests.setContextMenuPolicy(Qt.CustomContextMenu)
self.repoTests.setIndentation(10)
layoutRepoTest.addWidget(self.prjCombo)
layoutRepoTest.addWidget(self.repoTests)
self.testsList = QListWidget(self)
layoutTests.addLayout( layoutRepoTest )
layoutTests.addWidget( self.testsList )
mainLayout.addLayout( layoutTests )
buttonLayout = QVBoxLayout()
self.okButton = QPushButton(self.tr("Execute All"), self)
self.okButton.setEnabled(False)
self.cancelButton = QPushButton(self.tr("Cancel"), self)
self.upButton = QPushButton(self.tr("UP"), self)
self.upButton.setEnabled(False)
self.downButton = QPushButton(self.tr("DOWN"), self)
self.downButton.setEnabled(False)
self.clearButton = QPushButton(self.tr("Remove All"), self)
self.delButton = QPushButton(self.tr("Remove"), self)
self.delButton.setEnabled(False)
self.runSimultaneous = QCheckBox(self.tr("Simultaneous Run"))
self.schedImmed = QRadioButton(self.tr("Run Immediately"))
self.schedImmed.setChecked(True)
self.schedAt = QRadioButton(self.tr("Run At:"))
self.schedAtDateTimeEdit = QDateTimeEdit(QDateTime.currentDateTime())
self.schedAtDateTimeEdit.setEnabled(False)
buttonLayout.addWidget(self.okButton)
buttonLayout.addWidget(self.runSimultaneous)
buttonLayout.addWidget(self.schedImmed)
buttonLayout.addWidget(self.schedAt)
buttonLayout.addWidget(self.schedAtDateTimeEdit)
buttonLayout.addWidget( self.upButton )
buttonLayout.addWidget( self.downButton )
buttonLayout.addWidget( self.delButton )
buttonLayout.addWidget( self.clearButton )
buttonLayout.addWidget(self.cancelButton)
mainLayout.addLayout(buttonLayout)
self.setMinimumHeight(400)
self.setMinimumWidth(750)
self.setLayout(mainLayout)
def initProjects(self, projects=[], defaultProject=1):
"""
Initialize projects
"""
# init date and time
self.schedAtDateTimeEdit.setDateTime(QDateTime.currentDateTime())
self.projectReady = False
self.repoTests.clear()
self.prjCombo.clear()
self.testsList.clear()
self.prjCombo.setEnabled(True)
# insert data
pname = ''
for p in projects:
self.prjCombo.addItem ( p['name'] )
if defaultProject == p['project_id']:
pname = p['name']
for i in xrange(self.prjCombo.count()):
item_text = self.prjCombo.itemText(i)
if str(pname) == str(item_text):
self.prjCombo.setCurrentIndex(i)
self.projectReady = True
self.RefreshRepository.emit(pname)
def initializeTests(self, listing):
"""
Initialize tests
"""
self.repoTests.clear()
self.testRoot = self.rRepo.Item(repo = self.iRepo.remote(),
parent = self.repoTests, txt = "Root",
type = QTreeWidgetItem.UserType+10,
isRoot = True )
self.testRoot.setSelected(True)
self.createRepository(listing=listing, parent=self.testRoot,fileincluded=True)
self.repoTests.sortItems(0, Qt.AscendingOrder)
self.hideItems(hideTsx=False, hideTpx=False, hideTcx=True, hideTdx=True, hideTxt=True, hidePy=True,
hideTux=False, hidePng=True, hideTgx=False, hideTax=False)
def createRepository(self, listing, parent, fileincluded=True):
"""
Create repository
@param listing:
@type listing: list
@param parent:
@type parent:
@param fileincluded:
@type fileincluded: boolean
"""
try:
for dct in listing:
if dct["type"] == "folder":
item = self.rRepo.Item(repo = self.iRepo.remote(), parent = parent,
txt = dct["name"], propertiesFile=dct )
self.createRepository( dct["content"] , item, fileincluded )
else:
if fileincluded:
if dct["type"] == "file":
pname = self.iRepo.remote().getProjectName(dct["project"])
# {'modification': 1342259500, 'type': 'file', 'name': '__init__.py', 'size': '562 }
item = self.rRepo.Item(repo = self.iRepo.remote(), parent = parent, txt = dct["name"] ,
propertiesFile=dct, type = QTreeWidgetItem.UserType+0,
projectId=dct["project"], projectName=pname )
except Exception as e:
self.error( "unable to create tree for runs: %s" % e )
def onProjectChanged(self, projectItem):
"""
Called when the project changed on the combo box
"""
if self.projectReady:
item_text = self.prjCombo.itemText(projectItem)
self.RefreshRepository.emit(item_text)
def createConnections (self):
"""
create qt connections
* ok
* cancel
"""
self.prjCombo.currentIndexChanged.connect(self.onProjectChanged)
self.okButton.clicked.connect( self.acceptClicked )
self.cancelButton.clicked.connect( self.reject )
self.upButton.clicked.connect(self.upTest)
self.downButton.clicked.connect(self.downTest)
self.clearButton.clicked.connect(self.clearList)
self.delButton.clicked.connect(self.delTest)
self.testsList.itemClicked.connect(self.onItemSelected)
self.testsList.itemSelectionChanged.connect(self.onItemSelectionChanged)
self.schedAt.toggled.connect(self.onSchedAtActivated)
self.repoTests.itemDoubleClicked.connect( self.onTestDoucleClicked )
def onSchedAtActivated(self, toggled):
"""
On sched at button activated
"""
if toggled:
self.schedAtDateTimeEdit.setEnabled(True)
else:
self.schedAtDateTimeEdit.setEnabled(False)
def onItemSelectionChanged(self):
"""
Called on item selection changed
"""
self.onItemSelected(itm=None)
def onItemSelected(self, itm):
"""
Call on item selected
"""
selectedItems = self.testsList.selectedItems()
if len(selectedItems):
self.delButton.setEnabled(True)
self.upButton.setEnabled(True)
self.downButton.setEnabled(True)
else:
self.delButton.setEnabled(False)
self.upButton.setEnabled(False)
self.downButton.setEnabled(False)
if not self.testsList.count():
self.okButton.setEnabled(False)
def upTest(self):
"""
Up test
"""
currentRow = self.testsList.currentRow()
currentItem = self.testsList.takeItem(currentRow)
self.testsList.insertItem(currentRow - 1, currentItem)
def downTest(self):
"""
Down test
"""
currentRow = self.testsList.currentRow()
currentItem = self.testsList.takeItem(currentRow)
self.testsList.insertItem(currentRow + 1, currentItem)
def delTest(self):
"""
Del test
"""
currentRow = self.testsList.currentRow()
currentItem = self.testsList.takeItem(currentRow)
def clearList(self):
"""
Clear test
"""
self.testsList.clear()
self.delButton.setEnabled(False)
self.upButton.setEnabled(False)
self.downButton.setEnabled(False)
self.okButton.setEnabled(False)
def iterateTree(self, item, hideTsx, hideTpx, hideTcx, hideTdx, hideTxt,
hidePy, hideTux, hidePng, hideTgx, hideTax):
"""
Iterate tree
"""
child_count = item.childCount()
for i in range(child_count):
subitem = item.child(i)
subchild_count = subitem.childCount()
if subchild_count > 0:
self.iterateTree(item=subitem, hideTsx=hideTsx,
hideTpx=hideTpx, hideTcx=hideTcx,
hideTdx=hideTdx, hideTxt=hideTxt,
hidePy=hidePy, hideTux=hideTux,
hidePng=hidePng, hideTgx=hideTgx, hideTax=hideTax)
else:
if hideTux and subitem.getExtension() == self.rRepo.EXTENSION_TUX:
subitem.setHidden (True)
elif hideTpx and subitem.getExtension() == self.rRepo.EXTENSION_TPX:
subitem.setHidden (True)
elif hideTgx and subitem.getExtension() == self.rRepo.EXTENSION_TGX:
subitem.setHidden (True)
elif hideTcx and subitem.getExtension() == self.rRepo.EXTENSION_TCX:
subitem.setHidden (True)
elif hideTsx and subitem.getExtension() == self.rRepo.EXTENSION_TSX:
subitem.setHidden (True)
elif hideTdx and subitem.getExtension() == self.rRepo.EXTENSION_TDX:
subitem.setHidden (True)
elif hideTxt and subitem.getExtension() == self.rRepo.EXTENSION_TXT:
subitem.setHidden (True)
elif hidePy and subitem.getExtension() == self.rRepo.EXTENSION_PY:
subitem.setHidden (True)
elif hidePng and subitem.getExtension() == self.rRepo.EXTENSION_PNG:
subitem.setHidden (True)
elif hideTax and subitem.getExtension() == self.rRepo.EXTENSION_TAx:
subitem.setHidden (True)
else:
subitem.setHidden(False)
def hideItems(self, hideTsx=False, hideTpx=False, hideTcx=False, hideTdx=False, hideTxt=False, hidePy=False,
hideTux=False, hidePng=False, hideTgx=False, hideTax=False):
"""
Hide items
"""
root = self.repoTests.invisibleRootItem()
self.iterateTree(item=root, hideTsx=hideTsx, hideTpx=hideTpx, hideTcx=hideTcx,
hideTdx=hideTdx, hideTxt=hideTxt, hidePy=hidePy,
hideTux=hideTux, hidePng=hidePng, hideTgx=hideTgx, hideTax=hideTax)
def onTestDoucleClicked(self, testItem):
"""
On tests double clicked
"""
if testItem.type() != QTreeWidgetItem.UserType+0:
return
self.okButton.setEnabled(True)
currentProject = self.prjCombo.currentText()
testName = "%s:%s" % (str(currentProject),testItem.getPath(withFileName = True))
testItem = QListWidgetItem(testName )
if testName.endswith(self.rRepo.EXTENSION_TUX):
testItem.setIcon(QIcon(":/tux.png"))
if testName.endswith(self.rRepo.EXTENSION_TSX):
testItem.setIcon(QIcon(":/tsx.png"))
if testName.endswith(self.rRepo.EXTENSION_TPX):
testItem.setIcon(QIcon(":/tpx.png"))
if testName.endswith(self.rRepo.EXTENSION_TGX):
testItem.setIcon(QIcon(":/tgx.png"))
if testName.endswith(self.rRepo.EXTENSION_TAX):
testItem.setIcon(QIcon(":/tax.png"))
self.testsList.addItem( testItem )
def acceptClicked (self):
"""
Called on accept button
"""
self.accept()
def getTests(self):
"""
Returns all tests in the list
"""
tests = []
for i in xrange(self.testsList.count()):
testItem = self.testsList.item(i)
tests.append( str(testItem.text()) )
runSimultaneous = False
if self.runSimultaneous.isChecked(): runSimultaneous = True
if self.schedImmed.isChecked():
runAt = (0,0,0,0,0,0)
return (tests, False, runAt, runSimultaneous)
else:
pydt = self.schedAtDateTimeEdit.dateTime().toPyDateTime()
runAt = (pydt.year, pydt.month, pydt.day, pydt.hour, pydt.minute, pydt.second)
return (tests, True, runAt, runSimultaneous)
class NotebookListDialog(QDialog):
""" Functions to display, create, remove, modify notebookList """
def __init__(self, parent=None):
super(NotebookListDialog, self).__init__(parent)
self.notebookList = QListWidget()
self.moveUp = QPushButton('<<')
self.moveDown = QPushButton('>>')
self.add = QPushButton('Add')
self.remove = QPushButton('Remove')
self.buttonBox = QDialogButtonBox(QDialogButtonBox.Ok
| QDialogButtonBox.Cancel)
self.buttonBox.button(QDialogButtonBox.Ok).setEnabled(False)
layout = QGridLayout()
layout.addWidget(self.notebookList, 0, 0, 4, 6)
layout.addWidget(self.moveUp, 1, 6)
layout.addWidget(self.moveDown, 2, 6)
layout.addWidget(self.add, 4, 0)
layout.addWidget(self.remove, 4, 1)
layout.addWidget(self.buttonBox, 4, 5, 1, 2)
self.setLayout(layout)
self.notebookList.setItemDelegate(ListDelegate(self.notebookList))
self.notebookList.currentRowChanged.connect(self.updateUi)
self.add.clicked.connect(self.actionAdd)
self.remove.clicked.connect(self.actionRemove)
self.moveUp.clicked.connect(self.moveItemUp)
self.moveDown.clicked.connect(self.moveItemDown)
self.buttonBox.accepted.connect(self.accept)
self.buttonBox.rejected.connect(self.reject)
self.initList()
def initList(self):
self.notebookList.clear()
notebooks = Mikibook.read()
for nb in notebooks:
item = QListWidgetItem()
item.setData(Qt.DisplayRole, nb[0])
item.setData(Qt.UserRole, nb[1])
self.notebookList.addItem(item)
self.updateUi(len(notebooks) != 0)
self.notebookList.setCurrentRow(0)
# QListWidgetItem(nb, self.notebookList)
def updateUi(self, row):
flag = (row != -1)
self.buttonBox.button(QDialogButtonBox.Ok).setEnabled(flag)
self.remove.setEnabled(flag)
self.moveUp.setEnabled(flag)
self.moveDown.setEnabled(flag)
def actionAdd(self):
Mikibook.create()
self.initList()
count = self.notebookList.count()
self.notebookList.setCurrentRow(count - 1)
def actionRemove(self):
item = self.notebookList.currentItem()
row = self.notebookList.currentRow()
name = item.data(Qt.DisplayRole)
path = item.data(Qt.UserRole)
self.notebookList.takeItem(row)
Mikibook.remove(name, path)
def moveItemUp(self):
item = self.notebookList.currentItem()
row = self.notebookList.currentRow()
if row != 0:
# self.notebookList.removeItemWidget(item)
self.notebookList.takeItem(row)
self.notebookList.insertItem(row - 1, item)
self.notebookList.setCurrentRow(row - 1)
def moveItemDown(self):
item = self.notebookList.currentItem()
row = self.notebookList.currentRow()
count = self.notebookList.count()
if row != count - 1:
self.notebookList.takeItem(row)
self.notebookList.insertItem(row + 1, item)
self.notebookList.setCurrentRow(row + 1)
def accept(self):
notebookPath = self.notebookList.currentItem().data(Qt.UserRole)
notebookName = self.notebookList.currentItem().data(Qt.DisplayRole)
settings = Setting([[notebookName, notebookPath]])
window = mikidown.MikiWindow(settings)
window.show()
count = self.notebookList.count()
notebooks = []
for i in range(count):
name = self.notebookList.item(i).data(Qt.DisplayRole)
path = self.notebookList.item(i).data(Qt.UserRole)
notebooks.append([name, path])
Mikibook.write(notebooks)
QDialog.accept(self)
class ProfilesLoader(QDialog):
def __init__(self, load_func, create_func, save_func,
profiles, parent=None):
QDialog.__init__(self, parent, Qt.Dialog)
self.setMinimumWidth(400)
self._profiles = profiles
self.load_function = load_func
self.create_function = create_func
self.save_function = save_func
self.ide = parent
vbox = QVBoxLayout(self)
self.profileList = QListWidget()
self.profileList.addItems([key for key in profiles])
self.profileList.setCurrentRow(0)
self.contentList = QListWidget()
self.btnDelete = QPushButton(self.tr("Delete Profile"))
self.btnDelete.setSizePolicy(QSizePolicy.Fixed, QSizePolicy.Fixed)
self.btnUpdate = QPushButton(self.tr("Update Profile"))
self.btnUpdate.setSizePolicy(QSizePolicy.Fixed, QSizePolicy.Fixed)
self.btnCreate = QPushButton(self.tr("Create New Profile"))
self.btnCreate.setSizePolicy(QSizePolicy.Fixed, QSizePolicy.Fixed)
self.btnOpen = QPushButton(self.tr("Open Profile"))
self.btnOpen.setSizePolicy(QSizePolicy.Fixed, QSizePolicy.Fixed)
self.btnOpen.setDefault(True)
hbox = QHBoxLayout()
hbox.addWidget(self.btnDelete)
hbox.addWidget(self.btnUpdate)
hbox.addWidget(self.btnCreate)
hbox.addWidget(self.btnOpen)
vbox.addWidget(self.profileList)
vbox.addWidget(self.contentList)
vbox.addLayout(hbox)
self.connect(self.profileList, SIGNAL("itemSelectionChanged()"),
self.load_profile_content)
self.connect(self.btnOpen, SIGNAL("clicked()"), self.open_profile)
self.connect(self.btnUpdate, SIGNAL("clicked()"), self.save_profile)
self.connect(self.btnCreate, SIGNAL("clicked()"), self.create_profile)
self.connect(self.btnDelete, SIGNAL("clicked()"), self.delete_profile)
def load_profile_content(self):
item = self.profileList.currentItem()
self.contentList.clear()
if item is not None:
key = unicode(item.text())
files = [self.tr('Files:')] + \
[file[0] for file in self._profiles[key][0]]
projects = [self.tr('Projects:')] + self._profiles[key][1]
content = files + projects
self.contentList.addItems(content)
def create_profile(self):
profileName = self.create_function()
self.ide.Profile = profileName
self.close()
def save_profile(self):
if self.profileList.currentItem():
profileName = unicode(self.profileList.currentItem().text())
self.save_function(profileName)
self.ide.show_status_message(self.tr("Profile %1 Updated!").arg(
profileName))
self.load_profile_content()
def open_profile(self):
if self.profileList.currentItem():
key = unicode(self.profileList.currentItem().text())
self.load_function(key)
self.ide.Profile = key
self.close()
def delete_profile(self):
if self.profileList.currentItem():
key = unicode(self.profileList.currentItem().text())
self._profiles.pop(key)
self.profileList.takeItem(self.profileList.currentRow())
self.contentList.clear()
class Theme(QWidget):
"""Theme widget class."""
def __init__(self, parent):
super(Theme, self).__init__()
self._preferences, vbox = parent, QVBoxLayout(self)
vbox.addWidget(QLabel(self.tr("<b>Select Theme:</b>")))
self.list_skins = QListWidget()
self.list_skins.setSelectionMode(QListWidget.SingleSelection)
vbox.addWidget(self.list_skins)
self.btn_delete = QPushButton(self.tr("Delete Theme"))
self.btn_preview = QPushButton(self.tr("Preview Theme"))
self.btn_create = QPushButton(self.tr("Create Theme"))
hbox = QHBoxLayout()
hbox.addWidget(self.btn_delete)
hbox.addSpacerItem(
QSpacerItem(10, 0, QSizePolicy.Expanding, QSizePolicy.Fixed))
hbox.addWidget(self.btn_preview)
hbox.addWidget(self.btn_create)
vbox.addLayout(hbox)
self._refresh_list()
self.connect(self.btn_preview, SIGNAL("clicked()"), self.preview_theme)
self.connect(self.btn_delete, SIGNAL("clicked()"), self.delete_theme)
self.connect(self.btn_create, SIGNAL("clicked()"), self.create_theme)
self.connect(self._preferences, SIGNAL("savePreferences()"), self.save)
def delete_theme(self):
if self.list_skins.currentRow() != 0:
file_name = ("%s.qss" % self.list_skins.currentItem().text())
qss_file = file_manager.create_path(resources.NINJA_THEME_DOWNLOAD,
file_name)
file_manager.delete_file(qss_file)
self._refresh_list()
def create_theme(self):
designer = preferences_theme_editor.ThemeEditor(self)
designer.exec_()
self._refresh_list()
def showEvent(self, event):
self._refresh_list()
super(Theme, self).showEvent(event)
def _refresh_list(self):
self.list_skins.clear()
self.list_skins.addItem("Default")
files = sorted([
file_manager.get_file_name(filename)
for filename in file_manager.get_files_from_folder(
resources.NINJA_THEME_DOWNLOAD, "qss")
])
self.list_skins.addItems(files)
if settings.NINJA_SKIN in files:
index = files.index(settings.NINJA_SKIN)
self.list_skins.setCurrentRow(index + 1)
else:
self.list_skins.setCurrentRow(0)
def save(self):
qsettings = IDE.ninja_settings()
settings.NINJA_SKIN = self.list_skins.currentItem().text()
qsettings.setValue("preferences/theme/skin", settings.NINJA_SKIN)
self.preview_theme()
def preview_theme(self):
if self.list_skins.currentRow() == 0:
qss_file = resources.NINJA_THEME
else:
file_name = ("%s.qss" % self.list_skins.currentItem().text())
qss_file = file_manager.create_path(resources.NINJA_THEME_DOWNLOAD,
file_name)
with open(qss_file) as f:
qss = f.read()
QApplication.instance().setStyleSheet(qss)
class RunLilyPondDialog(KDialog):
"""
A dialog where a DocumentJob can be configured before it's started.
"""
def __init__(self, mainwin):
self.mainwin = mainwin
KDialog.__init__(self, mainwin)
self.setCaption(i18n("Run LilyPond"))
self.setButtons(KDialog.ButtonCode(
KDialog.Help | KDialog.Ok | KDialog.Cancel ))
self.setButtonText(KDialog.Ok, i18n("Run LilyPond"))
self.setButtonIcon(KDialog.Ok, KIcon("run-lilypond"))
self.setHelp("running")
layout = QVBoxLayout(self.mainWidget())
layout.addWidget(QLabel(i18n(
"Select which LilyPond version you want to run:")))
self.lilypond = QListWidget()
self.lilypond.setIconSize(QSize(22, 22))
self.lilypond.setSpacing(4)
layout.addWidget(self.lilypond)
self.preview = QCheckBox(i18n(
"Run LilyPond in preview mode (with Point and Click)"))
layout.addWidget(self.preview)
self.verbose = QCheckBox(i18n("Run LilyPond with verbose output"))
layout.addWidget(self.verbose)
def configureJob(self, job, doc=None):
"""Configure a job, belonging to document.
If the document is not given, it is expected to live in the document
attribute of the job. If there is already a job running, we just display,
but disable the Run button, until the old job finishes.
"""
doc = doc or job.document
# populate the dialog based on remembered settings for this document
self.lilypond.clear()
# find the configured lilypond versions
conf = config("lilypond")
paths = conf.readEntry("paths", ["lilypond"]) or ["lilypond"]
default = conf.readEntry("default", "lilypond")
import ly.version
# get all versions
ver = dict((path, lilyPondVersion(path)) for path in paths)
# default
if default not in paths:
default = paths[0]
# Sort on version
paths.sort(key=ver.get)
versions = [format(ver.get(p)) for p in paths]
# Determine automatic version (lowest possible)
autopath = None
docVersion = doc.lilyPondVersion()
if docVersion:
autopath = automaticLilyPondCommand(docVersion)
def addItem(version, path, icon, title, tooltip):
item = QListWidgetItem(self.lilypond)
item.setIcon(KIcon(icon))
item.setText("{0}\n{1}: {2}".format(title, i18n("Command"), path))
item.setToolTip(tooltip)
version or item.setFlags(Qt.NoItemFlags)
# Add all available LilyPond versions:
for path in paths:
if ver[path]:
title = i18n("LilyPond %1", format(ver[path]))
tooltip = i18n("Use LilyPond version %1", format(ver[path]))
addenda, tips = [], []
if path == default:
addenda.append(i18n("default"))
tips.append(i18n("Default LilyPond Version."))
if path == autopath:
addenda.append(i18n("automatic"))
tips.append(i18n("Automatic LilyPond Version (determined from document)."))
if addenda:
title += " [{0}]".format(", ".join(addenda))
tooltip += "\n{0}".format("\n".join(tips))
addItem(format(ver[path]), path, "run-lilypond", title,
tooltip + "\n" + i18n("Path: %1",
ly.version.LilyPondInstance(path).command() or path))
else:
addItem("", path, "dialog-error",
i18n("LilyPond (version unknown)"),
i18n("Use LilyPond (version unknown)\nPath: %1",
ly.version.LilyPondInstance(path).command() or path))
# Copy the settings from the document:
self.preview.setChecked(doc.metainfo["custom preview"])
self.verbose.setChecked(doc.metainfo["custom verbose"])
try:
self.lilypond.setCurrentRow(versions.index(
doc.metainfo["custom lilypond version"]))
except ValueError:
cmd = autopath if autopath and conf.readEntry("automatic version",
False) else default
self.lilypond.setCurrentRow(paths.index(cmd))
# Focus our listbox:
self.lilypond.setFocus()
# Disable the Run button if a job is running for this document
oldjob = self.mainwin.jobManager().job(doc)
self.enableButtonOk(not oldjob)
if oldjob:
enable = lambda: self.enableButtonOk(True)
oldjob.done.connect(enable)
# Wait for user interaction:
result = self.exec_()
# If a job was running, don't listen to it anymore
if oldjob:
oldjob.done.disconnect(enable)
if not result:
return False # cancelled
# Save the settings in the document's metainfo and configure job:
doc.metainfo["custom preview"] = job.preview = self.preview.isChecked()
doc.metainfo["custom verbose"] = job.verbose = self.verbose.isChecked()
index = self.lilypond.currentRow()
doc.metainfo["custom lilypond version"] = versions[index]
job.command = paths[index]
return True
class CodeCompletionWidget(QFrame):
def __init__(self, editor):
super(CodeCompletionWidget, self).__init__(
None, Qt.FramelessWindowHint | Qt.ToolTip)
self._editor = editor
self._revision = 0
self._block = 0
self.stack_layout = QStackedLayout(self)
self.stack_layout.setContentsMargins(0, 0, 0, 0)
self.stack_layout.setSpacing(0)
self.completion_list = QListWidget()
self.completion_list.setMinimumHeight(200)
self.completion_list.setAlternatingRowColors(True)
self._list_index = self.stack_layout.addWidget(self.completion_list)
self._icons = {'a': resources.IMAGES['attribute'],
'f': resources.IMAGES['function'],
'c': resources.IMAGES['class'],
'm': resources.IMAGES['module']}
self.cc = code_completion.CodeCompletion()
self._completion_results = {}
self._prefix = u''
self.setVisible(False)
self.source = ''
self._key_operations = {
Qt.Key_Up: self._select_previous_row,
Qt.Key_Down: self._select_next_row,
Qt.Key_PageUp: (lambda: self._select_previous_row(6)),
Qt.Key_PageDown: (lambda: self._select_next_row(6)),
Qt.Key_Right: lambda: None,
Qt.Key_Left: lambda: None,
Qt.Key_Enter: self.pre_key_insert_completion,
Qt.Key_Return: self.pre_key_insert_completion,
Qt.Key_Tab: self.pre_key_insert_completion,
Qt.Key_Space: self.hide_completer,
Qt.Key_Escape: self.hide_completer,
Qt.Key_Backtab: self.hide_completer,
Qt.NoModifier: self.hide_completer,
Qt.ShiftModifier: self.hide_completer,
}
self.desktop = QApplication.instance().desktop()
self.connect(self.completion_list,
SIGNAL("itemClicked(QListWidgetItem*)"),
self.pre_key_insert_completion)
self.connect(self._editor.document(),
SIGNAL("cursorPositionChanged(QTextCursor)"),
self.update_metadata)
def _select_next_row(self, move=1):
new_row = self.completion_list.currentRow() + move
if new_row < self.completion_list.count():
self.completion_list.setCurrentRow(new_row)
else:
self.completion_list.setCurrentRow(0)
return True
def _select_previous_row(self, move=1):
new_row = self.completion_list.currentRow() - move
if new_row >= 0:
self.completion_list.setCurrentRow(new_row)
else:
self.completion_list.setCurrentRow(
self.completion_list.count() - move)
return True
def update_metadata(self, cursor):
if settings.CODE_COMPLETION:
if self._editor.document().revision() != self._revision and \
cursor.block().blockNumber() != self._block:
source = self._editor.get_text()
source = source.encode(self._editor.encoding)
self.cc.analyze_file(self._editor.ID, source)
self._revision = self._editor.document().revision()
self._block = cursor.block().blockNumber()
def insert_completion(self, insert, type_=ord('a')):
if insert != self._prefix:
closing = ''
if type_ in (ord('f'), ord('c')):
closing = '()'
extra = len(self._prefix) - len(insert)
insertion = '%s%s' % (insert[extra:], closing)
self._editor.textCursor().insertText(insertion)
self.hide_completer()
def _get_geometry(self):
cr = self._editor.cursorRect()
desktop_geometry = self.desktop.availableGeometry(self._editor)
point = self._editor.mapToGlobal(cr.topLeft())
cr.moveTopLeft(point)
#Check new position according desktop geometry
width = (self.completion_list.sizeHintForColumn(0) +
self.completion_list.verticalScrollBar().sizeHint().width() + 10)
height = 200
orientation = (point.y() + height) < desktop_geometry.height()
if orientation:
cr.moveTop(cr.bottom())
cr.setWidth(width)
cr.setHeight(height)
if not orientation:
cr.moveBottom(cr.top())
xpos = desktop_geometry.width() - (point.x() + width)
if xpos < 0:
cr.moveLeft(cr.left() + xpos)
return cr
def complete(self, results):
self.add_list_items(results)
self.completion_list.setCurrentRow(0)
cr = self._get_geometry()
self.setGeometry(cr)
self.completion_list.updateGeometries()
self.show()
def add_list_items(self, proposals):
self.completion_list.clear()
for p in proposals:
self.completion_list.addItem(
QListWidgetItem(
QIcon(self._icons.get(p[0], resources.IMAGES['attribute'])),
p[1], type=ord(p[0])))
def set_completion_prefix(self, prefix, valid=True):
self._prefix = prefix
proposals = []
proposals += [('m', item)
for item in self._completion_results.get('modules', [])
if item.startswith(prefix)]
proposals += [('c', item)
for item in self._completion_results.get('classes', [])
if item.startswith(prefix)]
proposals += [('a', item)
for item in self._completion_results.get('attributes', [])
if item.startswith(prefix)]
proposals += [('f', item)
for item in self._completion_results.get('functions', [])
if item.startswith(prefix)]
if proposals and valid:
self.complete(proposals)
else:
self.hide_completer()
def _invalid_completion_position(self):
result = False
cursor = self._editor.textCursor()
cursor.movePosition(QTextCursor.StartOfLine,
QTextCursor.KeepAnchor)
selection = unicode(cursor.selectedText())[:-1].split(' ')
if len(selection) == 0 or selection[-1] == '' or \
selection[-1].isdigit():
result = True
return result
def fill_completer(self, force_completion=False):
if not force_completion and (self._editor.cursor_inside_string() or
self._editor.cursor_inside_comment() or
self._invalid_completion_position()):
return
source = self._editor.get_text()
source = source.encode(self._editor.encoding)
offset = self._editor.textCursor().position()
results = self.cc.get_completion(source, offset)
self._completion_results = results
if force_completion:
cursor = self._editor.textCursor()
cursor.movePosition(QTextCursor.StartOfWord,
QTextCursor.KeepAnchor)
prefix = cursor.selectedText()
else:
prefix = self._editor._text_under_cursor()
self.set_completion_prefix(prefix)
def hide_completer(self):
self._prefix = ''
self.hide()
def pre_key_insert_completion(self):
type_ = ord('a')
current = self.completion_list.currentItem()
insert = unicode(current.text())
if not insert.endswith(')'):
type_ = current.type()
self.insert_completion(insert, type_)
self.hide_completer()
return True
def process_pre_key_event(self, event):
if not self.isVisible() or self._editor.lang != "python":
return False
skip = self._key_operations.get(event.key(), lambda: False)()
self._key_operations.get(event.modifiers(), lambda: False)()
if skip is None:
skip = False
return skip
def process_post_key_event(self, event):
if not settings.CODE_COMPLETION or self._editor.lang != "python":
return
if self.isVisible():
source = self._editor.get_text()
source = source.encode(self._editor.encoding)
offset = self._editor.textCursor().position()
prefix, valid = self.cc.get_prefix(source, offset)
self.set_completion_prefix(prefix, valid)
self.completion_list.setCurrentRow(0)
force_completion = (event.key() == Qt.Key_Space and
event.modifiers() == Qt.ControlModifier)
if event.key() == Qt.Key_Period or force_completion:
self.fill_completer(force_completion)
class NewSessionPagePermutations(QWizardPage):
def __init__(self):
super(NewSessionPagePermutations, self).__init__()
self.setTitle(_('Configuration of permutations'))
self.setSubTitle(
_('Select the position of each question'
' and its choices in every model of the exam.'))
layout = QGridLayout()
self.question_list = QListWidget()
self.permutation_grid = QGridLayout()
self.alternatives_rows = {}
layout.addWidget(QLabel(_('Questions of model A')), 0, 0, 1, 1)
layout.addWidget(self.question_list, 1, 0, 1, 1)
layout.addWidget(QLabel(_('Model equivalence')), 0, 1, 1, 5)
self.permutation_grid.setVerticalSpacing(20)
layout.addLayout(self.permutation_grid, 1, 1, 1, 5)
layout.setColumnStretch(0, 1)
layout.setColumnStretch(1, 5)
self.setLayout(layout)
def initializePage(self):
paramNAlts = int(self.field("paramNAlts").toString())
paramNPerm = int(self.field("paramNPerm").toString())
self.question_list.clear()
# Creation of the list section
paramNCols_array = self.field("paramNCols").toString().split(',')
total_questions = 1 + (int(paramNCols_array[0]) \
if len(paramNCols_array) == 1 \
else reduce(lambda x, y: int(x) + int(y),
paramNCols_array))
for i in range(1, total_questions):
questions_list = QListWidgetItem(_('Question ') + str(i))
questions_list.setData(Qt.UserRole,
widgets.ItemList(
optionName=_('Question ') + str(i),
optionNumber=i)) # Custom item list
self.question_list.addItem(questions_list)
self.question_list.setCurrentRow(0)
self.question_list.itemClicked.connect(self._on_item_changed)
# Creation of the grid section
add_header = True # Header of the columns (Name of alternatives)
for j in range(0, paramNPerm):
self.permutation_grid.addWidget( \
QLabel(_('Model ') + chr(97 + j).upper()), j, 1)
self.alternatives_rows[j] = {}
for k in range(0, paramNAlts):
if add_header:
if k == 0:
self.permutation_grid.addWidget(QLabel(''), 0, 1)
self.permutation_grid.addWidget( \
QLabel(chr(97 + k).upper()), 0, k + 2)
self.alternatives_rows[j][k] = \
widgets.InputComboBox(self, c_type='alternative',
form=j, alternative=k)
self.alternatives_rows[j][k].addItems( \
[chr(97+x).upper() for x in range(0,paramNAlts)])
self.alternatives_rows[j][k].setCurrentIndex(0)
self.permutation_grid.addWidget(self.alternatives_rows[j][k],
j, k + 2)
add_header = False
self.alternatives_rows[j][k + 1] = \
widgets.InputComboBox(self, c_type='question', form=j,
alternative=self.question_list.\
currentItem().\
data(Qt.UserRole).toPyObject().\
get_question_number())
self.alternatives_rows[j][k + 1].addItems( \
[str(x) for x in range(1,total_questions)])
self.alternatives_rows[j][k + 1].setCurrentIndex(0)
self.permutation_grid.addWidget(QLabel(_('Question Number')), j,
k + 3)
self.permutation_grid.addWidget(self.alternatives_rows[j][k + 1],
j, k + 4)
button_save = QPushButton(_('Save values'))
self.permutation_grid.addWidget(button_save, j + 1, 1, 1, k + 4)
button_save.clicked.connect(self._save_values)
def _on_item_changed(self, arg=None):
permutation = arg.data(Qt.UserRole).toPyObject().get_permutation()
for k, v in self.alternatives_rows.iteritems():
for sk, sv in v.iteritems():
if not permutation:
sv.setCurrentIndex(0)
else:
sv.setCurrentIndex( \
[x for x in permutation \
if (x['altr'] == sv.alternative
and x['form'] == sv.form
and x['c_type'] == sv.c_type)][0]['perm'] - 1)
return True
def _save_values(self):
localItem = self.question_list.currentItem()
formatted_grid = self._get_formatted_permutation_grid()
if self._validate_grid(formatted_grid):
localItem.setBackgroundColor(QColor(0, 255, 68))
localItem.data(Qt.UserRole).toPyObject()\
.set_permutation(formatted_grid)
self._reset_permutation_grid()
QMessageBox.information(
self, _('Information status'),
_('The values for the question have been successfully saved'))
return True
else:
QMessageBox.critical(self, _('Error in grid'),
_('There is an inconsistence in the options'))
return False
def _get_formatted_permutation_grid(self):
local_alternatives_rows = []
for k, v in self.alternatives_rows.iteritems():
for sk, sv in v.iteritems():
alternative = {
'c_type': sv.c_type,
'form': sv.form,
'altr': sv.alternative,
'perm': sv.currentIndex() + 1
}
local_alternatives_rows.append(alternative)
return local_alternatives_rows
def _validate_grid(self, grid):
#validate current grid and questions number
forms = {}
for row in grid:
if row['c_type'] == 'alternative':
if row['form'] not in forms:
forms[row['form']] = []
if row['perm'] in forms[row['form']]:
return False
else:
forms[row['form']].append(row['perm'])
if row['c_type'] == 'question':
for i in xrange(self.question_list.count()):
if i == self.question_list.currentRow():
continue
perm = self.question_list.item(i).data(Qt.UserRole)\
.toPyObject().get_permutation()
for perm_row in perm:
if (perm_row['c_type'] == 'question'
and perm_row['form'] == row['form']
and perm_row['perm'] == row['perm']):
return False
return True
def _reset_permutation_grid(self):
for k, v in self.alternatives_rows.iteritems():
for sk, sv in v.iteritems():
sv.setCurrentIndex(0)
def _get_values(self):
formated_permutation = {}
formated_permutation_m = {}
for i in xrange(self.question_list.count()):
permutations = self.question_list.item(i).data(Qt.UserRole)\
.toPyObject().get_permutation()
a = {}
for p in permutations:
if p['form'] not in formated_permutation:
formated_permutation[p['form']] = []
if p['form'] not in a:
a[p['form']] = []
if p['c_type'] == 'alternative':
a[p['form']].append(p['perm'])
if p['c_type'] == 'question':
formated_permutation[p['form']].append( \
"%s{%s}" % (p['perm'], ','.join(str(x) \
for x in a[p['form']])))
for k, v in formated_permutation.iteritems():
formated_permutation_m[chr(97 + k).upper()] = '/'.join(v)
return formated_permutation_m
def validatePage(self):
valid = True
msg = ''
for i in xrange(self.question_list.count()):
if not self.question_list.item(i).data(Qt.UserRole)\
.toPyObject().get_permutation():
valid = False
msg = _('You must select all permutations for all questions')
break
if not valid:
QMessageBox.critical(self, _('Error'), msg)
else:
current_permutations = self._get_values()
for k, v in current_permutations.iteritems():
self.wizard().exam_config.set_permutations(k, v)
return valid
def nextId(self):
return WizardNewSession.PageIdFiles
class mainwindow(QtGui.QMainWindow):
'''主窗体'''
def __init__(self):
super(mainwindow, self).__init__()
self.setWindowTitle('组件设计工具')
self.setWindowIcon(QIcon(':/image/组件设计工具.png'))
self.setMinimumWidth(1024)
self.setMinimumHeight(800)
self.showMaximized()
self.menuBar().show()
self.createMenus()
#self.setWindowFlags(QtCore.Qt.WindowMinimizeButtonHint)
labelSizePolicy = QSizePolicy(QSizePolicy.Fixed, QSizePolicy.Fixed)
editSizePolicy = QSizePolicy(QSizePolicy.Preferred, QSizePolicy.Fixed)
cwVLayout = QVBoxLayout()
cwHLayout = QHBoxLayout()
lLayout = QVBoxLayout()
rLayout = QVBoxLayout()
self.lw = QListWidget()
self.lw.setSelectionMode(QAbstractItemView.SingleSelection)
lLayout.addWidget(self.lw)
self.lw.itemSelectionChanged.connect(self.on_select)
lGroup = QGroupBox('项目列表')
lGroup.setLayout(lLayout)
cwHLayout.addWidget(lGroup, 2)
lGroup.setContentsMargins(0, 12, 0, 22)
tLayout = QVBoxLayout()
bLayout = QHBoxLayout()
self.tGroup = QGroupBox('配置信息')
self.bGroup = QGroupBox('生成代码')
self.tGroup.setLayout(tLayout)
self.tGroup.setEnabled(False)
self.bGroup.setLayout(bLayout)
self.bGroup.setEnabled(False)
cwHLayout.addWidget(self.tGroup, 8)
cwVLayout.addLayout(cwHLayout)
cwVLayout.addWidget(self.bGroup)
self.tw_config = QTreeWidget()
headerLabels = QStringList()
headerLabels.append(' 项目')
headerLabels.append(' 值')
self.tw_config.setHeaderLabels(headerLabels)
self.tw_config.setColumnWidth(0, 312)
self.tw_config.setColumnWidth(1, 660)
thLayout = QHBoxLayout()
thLayout.setContentsMargins(0, 6, 0, 0)
thLayout.addSpacing(10)
modify_btn = QPushButton('') #修改
modify_btn.setObjectName('modify_btn')
modify_btn.clicked.connect(self.on_modify)
del_btn = QPushButton('') #删除
del_btn.setObjectName('del_btn')
del_btn.clicked.connect(self.on_del)
thLayout.addWidget(modify_btn)
thLayout.addWidget(del_btn)
thLayout.addStretch(0)
tLayout.addLayout(thLayout)
tLayout.addWidget(self.tw_config)
bhLayout = QHBoxLayout()
lable1 = QLabel('工程名称：')
lable1.setSizePolicy(labelSizePolicy)
self.et_project_name = QLineEdit()
self.et_project_name.setSizePolicy(editSizePolicy)
bhLayout.addWidget(lable1)
bhLayout.addWidget(self.et_project_name)
bhLayout.addSpacing(16)
lable2 = QLabel('工程位置：')
lable2.setSizePolicy(labelSizePolicy)
self.et_project_location = QLineEdit()
self.et_project_location.setReadOnly(True)
self.et_project_location.setSizePolicy(editSizePolicy)
btn_location = QPushButton('') #打开
btn_location.setObjectName('btn_location')
btn_location.setSizePolicy(labelSizePolicy)
btn_location.clicked.connect(self.getProjectLocation)
bhLayout.addWidget(lable2)
bhLayout.addWidget(self.et_project_location)
bhLayout.addSpacing(10)
bhLayout.addWidget(btn_location)
#bhLayout.addStretch(0)
gen_btn = QPushButton('') # 生成
gen_btn.setObjectName('gen_btn')
gen_btn.setSizePolicy(labelSizePolicy)
gen_btn.clicked.connect(self.on_gen)
bhLayout.addSpacing(45)
bhLayout.addWidget(gen_btn)
bLayout.addLayout(bhLayout)
bLayout.setContentsMargins(10, 24, 22, 34)
statusBar = self.statusBar()
sBH = QHBoxLayout()
copyright = QLabel('')
copyright.setAlignment(QtCore.Qt.AlignCenter)
copyright.setStyleSheet("color:#acacac")
statusBar.setMinimumHeight(30)
statusBar.addWidget(copyright, 10)
cw = QWidget()
cw.setLayout(cwVLayout)
self.setCentralWidget(cw)
self._initByConfig()
self.setMinimumSize(400, 200)
def _initByConfig(self):
'''初始化'''
pass
def createMenus(self):
'''创建菜单'''
self.ToolBar = self.addToolBar('')
self.ToolBar.setMinimumHeight(54)
newBtn = QToolButton()
newBtn.setText('创建项目')
newBtn.setIcon(QIcon(':/image/创建项目.png'))
newBtn.setToolButtonStyle(3)
newBtn.setFixedWidth(99)
OpenBtn = QToolButton()
OpenBtn.setText('打开项目')
OpenBtn.setIcon(QIcon(':/image/打开.png'))
OpenBtn.setToolButtonStyle(3)
OpenBtn.setFixedWidth(99)
AboutBtn = QToolButton()
AboutBtn.setText('关于')
AboutBtn.setIcon(QIcon(':/image/关于.png'))
AboutBtn.setToolButtonStyle(3)
AboutBtn.setFixedWidth(99)
HelpBtn = QToolButton()
HelpBtn.setText('帮助')
HelpBtn.setIcon(QIcon(':/image/帮助.png'))
HelpBtn.setToolButtonStyle(3)
HelpBtn.setFixedWidth(99)
newBtn.clicked.connect(self.on_new)
OpenBtn.clicked.connect(self.on_open)
AboutBtn.clicked.connect(self.on_about)
HelpBtn.clicked.connect(self.on_help)
self.ToolBar.addWidget(newBtn)
self.ToolBar.addWidget(OpenBtn)
self.ToolBar.addWidget(AboutBtn)
self.ToolBar.addWidget(HelpBtn)
self.ToolBar.setMovable(False)
self.ToolBar.setVisible(True)
def on_help(self):
app.g_pwd = os.getcwd()
if not (QtGui.QDesktopServices.openUrl(
QUrl.fromLocalFile(app.g_pwd + os.sep + 'image' + os.sep +
'help.pdf'))):
print app.g_pwd + os.sep + '/image/help.pdf'
QMessageBox.critical(None, "Failure", "Cannot open help manual")
def on_about(self):
abt = AboutDlg()
abt.exec_()
def on_new(self):
'''新建向导'''
app.g_configurations = Configuration() # 用来渲染的配置数据
dlg = wizard.MyWizard()
if dlg.exec_():
app.g_configurations.initialized = True
app.g_projects.append(app.g_configurations)
content = app.g_configurations.toJson()
self.path = QFileDialog.getSaveFileName(
self, "选择模板保存的路径",
app.g_pwd + os.sep + "configurations" + os.sep +
app.g_configurations.project_name.encode('utf-8') + ".json",
"Config (*.json)")
fileInfo = QFileInfo(self.path)
if not self.path.isEmpty():
path = app.QString2str(self.path)
with open(path, 'w+') as f:
f.write(content)
self.addConfig(fileInfo.baseName(), fileInfo.filePath(),
content)
#self.lw.addItem(app.g_configurations.project_name)
def getProjectLocation(self):
'''获取项目路径'''
path = QFileDialog.getExistingDirectory()
path = QDir.fromNativeSeparators(path)
self.et_project_location.setText(path)
def on_open(self):
'''打开现有配置'''
fileName = QFileDialog.getOpenFileName(
self, "选择现有模板", app.g_pwd + os.sep + "configurations",
"Config (*.json)")
if fileName.isEmpty():
return
self.path = fileName
with open(app.QString2str(fileName), 'r') as f:
content = f.read()
fileInfo = QFileInfo(fileName)
if not fileInfo.exists():
return
config = Configuration()
config.fromJson(content)
config.allone_dir = os.getenv('ALLONEDIR', '../..').replace('\\', '/')
self.addConfig(fileInfo.baseName(), fileInfo.filePath(), content)
self.on_select()
def on_del(self):
self.tw_config.clear()
self.bGroup.setEnabled(False)
self.tGroup.setEnabled(False)
index = self.lw.currentRow()
self.lw.takeItem(index)
def on_select(self):
'''选取配置'''
item = self.lw.currentItem()
if item != None:
content = item.data(QtCore.Qt.UserRole).toString()
config = Configuration()
config.fromJson(app.QString2str(content))
self.currentConfig = config
self.showConfigInfo(self.currentConfig)
self.bGroup.setEnabled(True)
self.path = item.data(QtCore.Qt.UserRole + 1).toString()
# index = self.lw.currentRow()
# if index < len(app.g_projects):
# self.currentConfig = app.g_projects[index]
# self.showConfigInfo(self.currentConfig)
# self.bGroup.setEnabled(True)
def addConfig(self, fileName, filePath, config):
item = QListWidgetItem(fileName)
item.setData(QtCore.Qt.UserRole, config)
item.setData(QtCore.Qt.UserRole + 1, filePath)
self.lw.addItem(item)
self.lw.setCurrentRow(0)
def showConfigInfo(self, cf):
'''显示配置信息'''
self.tw_config.clear()
self.et_project_name.setText(cf.project_name)
self.et_project_location.setText(cf.project_location)
sr = QStringList()
sr.append('信息')
root1 = QTreeWidgetItem(sr)
sr = QStringList()
sr.append('Qt库')
root2 = QTreeWidgetItem(sr)
sr = QStringList()
sr.append('模块')
root3a = QTreeWidgetItem(sr)
sr = QStringList()
sr.append('第三方库')
root3b = QTreeWidgetItem(sr)
sr = QStringList()
sr.append('接口')
root4 = QTreeWidgetItem(sr)
self.tw_config.addTopLevelItem(root1)
self.tw_config.addTopLevelItem(root2)
self.tw_config.addTopLevelItem(root3a)
self.tw_config.addTopLevelItem(root3b)
self.tw_config.addTopLevelItem(root4)
sr1c00 = QStringList()
sr1c00.append("项目名称")
sr1c00.append(cf.project_name)
r1c00 = QTreeWidgetItem(sr1c00)
root1.addChild(r1c00)
# sr1c0 = QStringList()
# sr1c0.append("项目位置")
# sr1c0.append(cf.project_location)
# r1c0 = QTreeWidgetItem(sr1c0)
# root1.addChild(r1c0)
sr1c1 = QStringList()
sr1c1.append("组件类型")
sr1c1.append(cf.component_type)
r1c1 = QTreeWidgetItem(sr1c1)
root1.addChild(r1c1)
sr1c2 = QStringList()
sr1c2.append("源模板")
sr1c2.append(cf.template_source)
r1c2 = QTreeWidgetItem(sr1c2)
root1.addChild(r1c2)
sr1c3 = QStringList()
sr1c3.append("平台类型")
tmp_pt = ""
if cf.platform_type & configuration.PT_WIN32:
tmp_pt += "win32;"
if cf.platform_type & configuration.PT_LINUX:
tmp_pt += "linux"
sr1c3.append(tmp_pt)
r1c3 = QTreeWidgetItem(sr1c3)
root1.addChild(r1c3)
sr1c4 = QStringList()
sr1c4.append("平台级别")
sr1c4.append(cf.platform_version)
r1c4 = QTreeWidgetItem(sr1c4)
root1.addChild(r1c4)
sr1c5 = QStringList()
sr1c5.append("资源文件")
if cf.resourcesFile == "True":
sr1c5.append("添加")
else:
sr1c5.append("未添加")
r1c5 = QTreeWidgetItem(sr1c5)
root1.addChild(r1c5)
sr1c6 = QStringList()
sr1c6.append("翻译文件")
if cf.translateFile == "True":
sr1c6.append("添加")
else:
sr1c6.append("未添加")
r1c6 = QTreeWidgetItem(sr1c6)
root1.addChild(r1c6)
for qt in cf.qt_libs:
sr2 = QStringList()
sr2.append(qt['name'])
sr2.append(qt['qt'])
r2 = QTreeWidgetItem(sr2)
root2.addChild(r2)
for module in cf.modules:
sr3a = QStringList()
sr3a.append(module['name'])
sr3a.append(module['description'])
r3a = QTreeWidgetItem(sr3a)
root3a.addChild(r3a)
# sr3b = QStringList()
# sr3b.append('ALLONE_DIR')
# sr3b.append(os.getenv('ALLONEDIR','../..')) # 第二个参数是默认值
# r3b = QTreeWidgetItem(sr3b)
# root3b.addChild(r3b)
for info in cf.thirdpart_lib:
sr3b = QStringList()
sr3b.append(info['libname'])
sr3b.append(info['libpath'])
r3b = QTreeWidgetItem(sr3b)
root3b.addChild(r3b)
for key in cf.interfaces.keys():
sr4 = QStringList()
sr4.append(key)
if cf.interfaces[key]:
sr4.append('实现')
else:
sr4.append('未实现')
r4 = QTreeWidgetItem(sr4)
root4.addChild(r4)
self.tw_config.expandAll()
self.tw_config.header().resizeSection(0, 300)
self.tGroup.setEnabled(True)
def on_modify(self):
'''修改配置'''
if self.currentConfig:
app.g_configurations = copy.copy(self.currentConfig)
dlg = wizard.MyWizard()
if dlg.exec_():
item = self.lw.currentItem()
if item != None:
content = app.g_configurations.toJson()
item.setData(QtCore.Qt.UserRole, content)
path = item.data(QtCore.Qt.UserRole + 1).toString()
if not path.isEmpty():
path = app.QString2str(path)
with open(path, 'w+') as f:
f.write(content)
self.on_select()
def on_gen(self):
'''生成工程'''
if not self.currentConfig:
return
#获取工程名及有效路径
project_name = self.et_project_name.text()
project_location = self.et_project_location.text()
qdir = QDir(project_location)
if not qdir.exists():
if not qdir.mkpath(project_location):
QMessageBox.warning(self, '警告', '路径无效！')
return
project_location = qdir.absolutePath()
if not project_location.endsWith(
'/') and not project_location.endsWith('\\'):
project_location += os.sep
project_location.replace('\\', '/')
if project_name.isEmpty() or project_location.isEmpty():
QMessageBox.warning(self, '警告', '项目名称或路径不能为空！')
return
self.currentConfig.project_name = app.QString2str(project_name)
self.currentConfig.project_location = app.QString2str(project_location)
content = self.currentConfig.toJson()
fileInfo = QFileInfo(self.path)
if not self.path.isEmpty():
path = app.QString2str(self.path)
with open(path, 'w+') as f:
f.write(content)
item = self.lw.currentItem()
item.setData(QtCore.Qt.UserRole, content)
template_name = self.currentConfig.template_source
template_dir = app.g_pwd + os.sep + 'templates' + os.sep + template_name.encode(
'utf-8')
with open(template_dir + os.sep + 'config.json', 'r') as f:
self.currentConfig.config_content = f.read()
ret_json = app.render(self.currentConfig.config_content,
config=self.currentConfig)
self.currentConfig.config = json.loads(ret_json)
for file in self.currentConfig.config['files']:
sourcepath = template_dir + os.sep + file['source'].encode('utf-8')
targetdir = self.currentConfig.project_location + self.currentConfig.project_name
targetpath = targetdir + os.sep + file['target']
fi = QFileInfo(targetpath)
qdir = fi.absoluteDir()
if not qdir.exists():
qdir.mkpath(fi.absolutePath())
with open(sourcepath, 'r') as f:
content = f.read()
content = app.render(content, config=self.currentConfig) #渲染文件
with open(targetpath, 'w+') as f:
f.write(content.encode('utf-8'))
QMessageBox.information(self, '提示', '生成成功！')
class KeywordList(HelpedWidget):
"""Shows a list of keywords. The data structure expected and sent to the getter and setter is an array of values."""
def __init__(self, model, list_label="", help_link=""):
HelpedWidget.__init__(self, list_label, help_link)
assert isinstance(model, ListModelMixin)
self.model = model
self.keyword_list = []
self.list = QListWidget(self)
self.list.setMinimumHeight(100)
self.list.setMaximumHeight(150)
self.default_selection_mode = self.list.selectionMode()
self.addWidget(self.list)
self.addRemoveWidget = AddRemoveWidget(self.addItem, self.removeItem)
self.addWidget(self.addRemoveWidget)
self.title = "New keyword"
self.description = "Enter name of keyword:"
self.model.observable().attach(ListModelMixin.LIST_CHANGED_EVENT,
self.modelChanged)
self.modelChanged()
def setSelectable(self, selectable):
if selectable:
self.list.setSelectionMode(self.default_selection_mode)
else:
self.list.setSelectionMode(QAbstractItemView.NoSelection)
def setPopupLabels(self, title, description):
"""Change the labels of the default popup."""
self.title = title
self.description = description
def newKeywordPopup(self, keyword_list):
"""
Pops up a message box asking for a new keyword.
Override this and return a string to customize the input dialog - Empty string equals canceled.
The provided list are the already defined keywords
"""
new_keyword, ok = QInputDialog.getText(self, self.tr(self.title),
self.tr(self.description),
QLineEdit.Normal)
if ok:
return str(new_keyword).strip()
else:
return ""
def addItem(self):
"""Called by the add button to insert a new keyword"""
new_keyword = self.newKeywordPopup(self.keyword_list)
if not new_keyword == "":
self.model.addItem(new_keyword)
def removeItem(self):
"""Called by the remove button to remove a selected keyword"""
if not self.list.currentItem() is None:
row = self.list.currentRow()
try:
self.model.removeItem(self.keyword_list[row])
except NotImplementedError:
message = "Support for removal of items has not been implemented!"
QMessageBox.information(self, "Not implemented!", message)
def modelChanged(self):
"""Retrieves data from the model and inserts it into the list"""
keywords = self.model.getList()
self.list.clear()
self.keyword_list = keywords
for keyword in keywords:
self.list.addItem(keyword)
def cleanup(self):
self.model.observable().detach(ListModelMixin.LIST_CHANGED_EVENT,
self.modelChanged)
class ConfigDialog(QDialog):
"""Spyder configuration ('Preferences') dialog box"""
def __init__(self, parent=None):
QDialog.__init__(self, parent)
# Destroying the C++ object right after closing the dialog box,
# otherwise it may be garbage-collected in another QThread
# (e.g. the editor's analysis thread in Spyder), thus leading to
# a segmentation fault on UNIX or an application crash on Windows
self.setAttribute(Qt.WA_DeleteOnClose)
self.contents_widget = QListWidget()
self.contents_widget.setMovement(QListView.Static)
self.contents_widget.setSpacing(1)
bbox = QDialogButtonBox(QDialogButtonBox.Ok|QDialogButtonBox.Apply
|QDialogButtonBox.Cancel)
self.apply_btn = bbox.button(QDialogButtonBox.Apply)
self.connect(bbox, SIGNAL("accepted()"), SLOT("accept()"))
self.connect(bbox, SIGNAL("rejected()"), SLOT("reject()"))
self.connect(bbox, SIGNAL("clicked(QAbstractButton*)"),
self.button_clicked)
self.pages_widget = QStackedWidget()
self.connect(self.pages_widget, SIGNAL("currentChanged(int)"),
self.current_page_changed)
self.connect(self.contents_widget, SIGNAL("currentRowChanged(int)"),
self.pages_widget.setCurrentIndex)
self.contents_widget.setCurrentRow(0)
hsplitter = QSplitter()
hsplitter.addWidget(self.contents_widget)
hsplitter.addWidget(self.pages_widget)
btnlayout = QHBoxLayout()
btnlayout.addStretch(1)
btnlayout.addWidget(bbox)
vlayout = QVBoxLayout()
vlayout.addWidget(hsplitter)
vlayout.addLayout(btnlayout)
self.setLayout(vlayout)
self.setWindowTitle(_("Preferences"))
self.setWindowIcon(get_icon("configure.png"))
def get_current_index(self):
"""Return current page index"""
return self.contents_widget.currentRow()
def set_current_index(self, index):
"""Set current page index"""
self.contents_widget.setCurrentRow(index)
def get_page(self, index=None):
"""Return page widget"""
if index is None:
widget = self.pages_widget.currentWidget()
else:
widget = self.pages_widget.widget(index)
return widget.widget()
def accept(self):
"""Reimplement Qt method"""
for index in range(self.pages_widget.count()):
configpage = self.get_page(index)
if not configpage.is_valid():
return
configpage.apply_changes()
QDialog.accept(self)
def button_clicked(self, button):
if button is self.apply_btn:
# Apply button was clicked
configpage = self.get_page()
if not configpage.is_valid():
return
configpage.apply_changes()
def current_page_changed(self, index):
widget = self.get_page(index)
self.apply_btn.setVisible(widget.apply_callback is not None)
self.apply_btn.setEnabled(widget.is_modified)
def add_page(self, widget):
self.connect(self, SIGNAL('check_settings()'), widget.check_settings)
self.connect(widget, SIGNAL('show_this_page()'),
lambda row=self.contents_widget.count():
self.contents_widget.setCurrentRow(row))
self.connect(widget, SIGNAL("apply_button_enabled(bool)"),
self.apply_btn.setEnabled)
scrollarea = QScrollArea(self)
scrollarea.setWidgetResizable(True)
scrollarea.setWidget(widget)
self.pages_widget.addWidget(scrollarea)
item = QListWidgetItem(self.contents_widget)
item.setIcon(widget.get_icon())
item.setText(widget.get_name())
item.setFlags(Qt.ItemIsSelectable|Qt.ItemIsEnabled)
item.setSizeHint(QSize(0, 25))
def check_all_settings(self):
"""This method is called to check all configuration page settings
after configuration dialog has been shown"""
self.emit(SIGNAL('check_settings()'))
def resizeEvent(self, event):
"""
Reimplement Qt method to be able to save the widget's size from the
main application
"""
QDialog.resizeEvent(self, event)
self.emit(SIGNAL("size_change(QSize)"), self.size())
class ListBox(QWidget):
def __init__(self, parent):
QWidget.__init__(self, parent)
while not isinstance(parent, QDialog):
parent = parent.parent()
self.setObjectName("ListBox" + str(len(parent.findChildren(ListBox))))
self.hLayoutBoxPanel = QHBoxLayout(self)
self.hLayoutBoxPanel.setSpacing(0)
self.hLayoutBoxPanel.setContentsMargins(3, 3, 3, 3)
self.hLayoutBoxPanel.setObjectName(("hLayoutBoxPanel"))
self.frameBoxPanel = QFrame(self)
sizePolicy = QSizePolicy(QSizePolicy.Preferred, QSizePolicy.Fixed)
sizePolicy.setHorizontalStretch(0)
sizePolicy.setVerticalStretch(0)
sizePolicy.setHeightForWidth(
self.frameBoxPanel.sizePolicy().hasHeightForWidth())
self.frameBoxPanel.setSizePolicy(sizePolicy)
self.frameBoxPanel.setFrameShape(QFrame.NoFrame)
self.frameBoxPanel.setFrameShadow(QFrame.Raised)
self.frameBoxPanel.setObjectName(("frameBoxPanel"))
self.hLayoutframeBoxPanel = QHBoxLayout(self.frameBoxPanel)
self.hLayoutframeBoxPanel.setSpacing(0)
self.hLayoutframeBoxPanel.setMargin(0)
self.hLayoutframeBoxPanel.setObjectName(("hLayoutframeBoxPanel"))
self.captionLabel = QLabel(self.frameBoxPanel)
sizePolicy = QSizePolicy(QSizePolicy.Fixed, QSizePolicy.Fixed)
sizePolicy.setHorizontalStretch(0)
sizePolicy.setVerticalStretch(0)
sizePolicy.setHeightForWidth(
self.captionLabel.sizePolicy().hasHeightForWidth())
self.captionLabel.setSizePolicy(sizePolicy)
self.captionLabel.setMinimumSize(QSize(200, 0))
self.captionLabel.setMaximumSize(QSize(200, 16777215))
font = QFont()
font.setBold(False)
font.setWeight(50)
self.captionLabel.setFont(font)
self.captionLabel.setObjectName(("captionLabel"))
self.hLayoutframeBoxPanel.addWidget(self.captionLabel)
self.listBox = QListWidget(self.frameBoxPanel)
self.listBox.setEnabled(True)
font = QFont()
font.setBold(False)
font.setWeight(50)
self.listBox.setFont(font)
self.listBox.setObjectName(("listBox"))
# self.listBox.setText("0.0")
self.hLayoutframeBoxPanel.addWidget(self.listBox)
self.imageButton = QToolButton(self.frameBoxPanel)
self.imageButton.setText((""))
icon = QIcon()
icon.addPixmap(QPixmap(("Resource/convex_hull.png")), QIcon.Normal,
QIcon.Off)
self.imageButton.setIcon(icon)
self.imageButton.setObjectName(("imageButton"))
self.imageButton.setVisible(False)
self.hLayoutframeBoxPanel.addWidget(self.imageButton)
self.hLayoutBoxPanel.addWidget(self.frameBoxPanel)
self.listBox.currentRowChanged.connect(self.listBoxChanged)
self.imageButton.clicked.connect(self.imageButtonClicked)
self.captionUnits = ""
self.hasObject = False
self.objectList = []
self.captionLabel.setVisible(False)
def get_Count(self):
return self.listBox.count()
Count = property(get_Count, None, None, None)
def method_3(self, string_0):
return self.listBox.row(self.listBox.findItems(string_0)[0])
def method_11(self, string_0):
if (self.IsEmpty):
return "%s%s\t" % (string_0, self.Caption)
return "%s%s\t%s %s" % (string_0, self.Caption, self.Value,
self.CaptionUnits)
def listBoxChanged(self, index):
i = index
self.emit(SIGNAL("Event_0"), self)
def IndexOf(self, item):
if isinstance(item, str):
return self.listBox.row(self.listBox.findItems(item)[0])
else:
return self.listBox.row(
self.listBox.findItems(item.ToString())[0])
def Contains(self, item):
compStr = None
if isinstance(item, str):
compStr = item
elif isinstance(item, float) or isinstance(item, int):
compStr = str(item)
else:
compStr = item.ToString()
for i in range(self.listBox.count()):
comboItemstr = self.listBox.item(i).text()
if compStr == comboItemstr:
return True
return False
def Clear(self):
self.listBox.clear()
self.objectList = []
self.hasObject = False
def Add(self, item):
if not isinstance(item, str) and not isinstance(item, QString):
self.listBox.addItem(item.ToString())
self.objectList.append(item)
self.hasObject = True
return
self.listBox.addItem(item)
self.hasObject = False
return self.listBox.count() - 1
def Insert(self, index, item):
if not isinstance(item, str):
self.listBox.insertItem(index, item.ToString())
self.objectList.insert(index, item)
self.hasObject = True
return
self.listBox.insertItem(index, item)
self.hasObject = False
def imageButtonClicked(self):
self.emit(SIGNAL("Event_3"), self)
def get_Caption(self):
caption = self.captionLabel.text()
findIndex = caption.indexOf("(")
if findIndex > 0:
val = caption.left(findIndex)
return val
return caption
def set_Caption(self, captionStr):
if captionStr == "":
self.captionLabel.setText("")
self.LabelWidth = 0
return
if self.CaptionUnits != "" and self.CaptionUnits != None:
self.captionLabel.setText(captionStr + "(" +
str(self.CaptionUnits) + ")" + ":")
else:
self.captionLabel.setText(captionStr + ":")
Caption = property(get_Caption, set_Caption, None, None)
def get_CaptionUnits(self):
return self.captionUnits
def set_CaptionUnits(self, captionUnits):
self.captionUnits = captionUnits
CaptionUnits = property(get_CaptionUnits, set_CaptionUnits, None, None)
def set_ButtonVisible(self, bool):
self.imageButton.setVisible(bool)
ButtonVisible = property(None, set_ButtonVisible, None, None)
# def get_Value(self):
# return self.listBox.currentIndex()
#
# def set_Value(self, value):
# try:
# self.listBox.setCurrentIndex(value)
# except:
# self.textBox.setText("")
# Value = property(get_Value, set_Value, None, None)
# def get_IsEmpty(self):
# return self.listBox.currentText() == "" or self.listBox.currentIndex() == -1
# IsEmpty = property(get_IsEmpty, None, None, None)
# def get_ReadOnly(self):
# return self.listBox.isReadOnly()
# # def set_ReadOnly(self, bool):
# # self.listBox.setR.setReadOnly(bool)
# # ReadOnly = property(get_ReadOnly, set_ReadOnly, None, None)
def set_LabelWidth(self, width):
self.captionLabel.setMinimumSize(QSize(width, 0))
self.captionLabel.setMaximumSize(QSize(width, 16777215))
LabelWidth = property(None, set_LabelWidth, None, None)
def set_Width(self, width):
self.listBox.setMinimumSize(QSize(width, 0))
self.listBox.setMaximumSize(QSize(width, 16777215))
Width = property(None, set_Width, None, None)
def set_Button(self, imageName):
if imageName == None or imageName == "":
self.imageButton.setVisible(False)
return
icon = QIcon()
icon.addPixmap(QPixmap(("Resource/" + imageName)), QIcon.Normal,
QIcon.Off)
self.imageButton.setIcon(icon)
self.imageButton.setVisible(True)
Button = property(None, set_Button, None, None)
def get_SelectedIndex(self):
try:
return self.listBox.currentRow()
except:
return 0
def set_SelectedIndex(self, index):
if self.listBox.count() == 0:
return
if index > self.listBox.count() - 1:
self.listBox.setCurrentRow(0)
else:
self.listBox.setCurrentRow(index)
SelectedIndex = property(get_SelectedIndex, set_SelectedIndex, None, None)
# def get_Value(self):
# return self.listBox.currentIndex()
# def set_Value(self, valueStr):
# if self.listBox.count() == 0:
# return
# self.listBox.setCurrentIndex(self.listBox.findText(valueStr))
# Value = property(get_Value, set_Value, None, None)
def get_Items(self):
if self.hasObject:
return self.objectList
itemList = []
if self.listBox.count() > 0:
for i in range(self.listBox.count()):
itemList.append(self.listBox.item(i).text())
return itemList
def set_AddItems(self, strList):
if len(strList) != 0 and not isinstance(
strList[0], str) and not isinstance(strList[0], QString):
for obj in strList:
self.listBox.addItem(obj.ToString())
self.objectList.append(obj)
self.hasObject = True
return
self.listBox.addItems(strList)
Items = property(get_Items, set_AddItems, None, None)
def get_Enabled(self):
return self.listBox.isEnabled()
def set_Enabled(self, bool):
self.listBox.setEnabled(bool)
Enabled = property(get_Enabled, set_Enabled, None, None)
def get_Visible(self):
return self.isVisible()
def set_Visible(self, bool):
self.setVisible(bool)
Visible = property(get_Visible, set_Visible, None, None)
def get_SelectedItem(self):
if self.listBox.count() == 0:
return None
if self.hasObject:
return self.objectList[self.SelectedIndex]
return self.listBox.currentItem().text()
# def set_SelectedItem(self, val):
# index = self.listBox.findText(val)
# self.listBox.setCurrentIndex(index)
SelectedItem = property(get_SelectedItem, None, None, None)
class Ui_MainWindow(object):
# plot visualization variable
present = None
timer = None
buffer = 16384
linecolor = "green"
# setting for pyaudio
rate = 44100
p = pyaudio.PyAudio()
chunks = []
inStream = None
recThread = None
addThread = None
xlimit = 10000
ylimit = 1000000
savename = None
displayTime = None
data = None
capFlag = 0
mlFlag = 0
fth = True
sth = False
tth = False
dapper = [0.00, 0.00, 0.00]
avgper = 0.00
ndapper = [0.00, 0.00, 0.00]
navgper = 0.00
# namePre=None
# ratePre=None
# spectrumPre=None
# freqPre=None
#nsamPre=None
#
def stream(self):
while True:
if self.inStream is not None:
self.chunks.append(self.inStream.read(self.buffer))
def record(self):
self.inStream = self.p.open(format=pyaudio.paInt16,
channels=1,
rate=self.rate,
input=True,
frames_per_buffer=self.buffer)
self.addThread = threading.Thread(target=self.stream)
self.addThread.start()
# a figure instance to plot on
figure = None
# this is the Canvas Widget that displays the `figure`
canvas = None
# this is the Navigation widget
# it takes the Canvas widget and a parent
toolbar = None
def setupUi(self, MainWindow):
screen_resolution = app.desktop().screenGeometry()
width, height = screen_resolution.width(), screen_resolution.height()
MainWindow.setObjectName(_fromUtf8("MainWindow"))
MainWindow.resize(width / 1.5, height / 1.5)
# MainWindow.setMinimumSize(QtCore.QSize(1024, 768))
# MainWindow.setMaximumSize(QtCore.QSize(width / 1.5, height / 1.5))
self.centralwidget = QtGui.QWidget(MainWindow)
self.centralwidget.setObjectName(_fromUtf8("centralwidget"))
# self.plotlayout = QtGui.QVBoxLayout(self.centralwidget)
self.gridlayout = QtGui.QGridLayout(self.centralwidget)
# a figure instance to plot on
self.figure = plt.figure()
# this is the Canvas Widget that displays the `figure`
self.canvas = FigureCanvas(self.figure)
cid = self.canvas.mpl_connect('button_press_event', self.plotClick)
# this is the Navigation widget
# it takes the Canvas widget and a parent
self.toolbar = NavigationToolbar(self.canvas, self.centralwidget)
self.inGridlayout = QtGui.QGridLayout()
self.inBoxlayout = QtGui.QHBoxLayout()
self.list = QListWidget(self.centralwidget)
# self.gridlayout.addLayout(self.list, 1)
# inGridlayout has toolbar, button, ...etc
# inBoxlayout has button6, button5, button4
# self.gridLayout.addWidget(self.toolbar)
self.gridlayout.addWidget(self.toolbar, 0, 0)
self.gridlayout.addWidget(self.canvas, 1, 0)
self.gridlayout.addLayout(self.inGridlayout, 3, 0)
self.gridlayout.addLayout(self.inBoxlayout, 2, 0)
self.gridlayout.addLayout(self.inBoxlayout, 0, 3)
self.gridlayout.addWidget(self.list, 0, 1, 4, 4)
# self.inBoxlayout.addWidget(self.toolbar,0)
self.gridlayout.setObjectName(_fromUtf8("griddisplay"))
# self.centralwidget.setLayout(self.plotlayout)
palettegl = QtGui.QPalette()
palettegl.setBrush(QtGui.QPalette.Light, QtCore.Qt.black)
"""
self.lineEdit = QtGui.QTextEdit(self.centralwidget)
# self.lineEdit.setGeometry(QtCore.QRect(10, 475, 800, 105))
self.gridlayout.addWidget(self.lineEdit, 0, 3, 4, 4)
self.lineEdit.setObjectName(_fromUtf8("lineEdit"))
self.lineEdit.setReadOnly(True)
"""
self.qlabeldap = QtGui.QLabel(self.centralwidget)
self.qlabeldap.setText("Estimated Payloaded DAP Percentage")
self.inGridlayout.addWidget(self.qlabeldap, 1, 0, 1, 1)
self.leftBoundary_1 = QtGui.QPushButton(self.centralwidget)
self.leftBoundary_1.setGeometry(QtCore.QRect(340, 668, 91, 38))
self.leftBoundary_1.setObjectName(_fromUtf8("leftBoundary_1"))
self.leftBoundary_1.clicked.connect(self.lbnd1f)
# self.leftBoundary_1.setPalette(palettegl)
# self.leftBoundary_1.display("00:00")
self.inGridlayout.addWidget(self.leftBoundary_1, 1, 1, 1, 1)
self.rightBoundary_1 = QtGui.QPushButton(self.centralwidget)
self.rightBoundary_1.setGeometry(QtCore.QRect(340, 668, 91, 38))
self.rightBoundary_1.setObjectName(_fromUtf8("rightBoundary_1"))
self.rightBoundary_1.clicked.connect(self.rbnd1f)
# self.rightBoundary_1.setPalette(palettegl)
# self.rightBoundary_1.display("00:00")
self.inGridlayout.addWidget(self.rightBoundary_1, 1, 2, 1, 1)
self.threshold_1 = QtGui.QPushButton(self.centralwidget)
self.threshold_1.setGeometry(QtCore.QRect(340, 668, 91, 38))
self.threshold_1.setObjectName(_fromUtf8("threshold_1"))
self.threshold_1.clicked.connect(self.th1f)
# self.threshold_1.setPalette(palettegl)
# self.threshold_1.display("00:00")
self.inGridlayout.addWidget(self.threshold_1, 1, 3, 1, 1)
# self.qLabelChunk1 = QtGui.QLabel(self.centralwidget)
# self.qLabelChunk1.setText("labelChunk1")
# self.inGridlayout.addWidget(self.qLabelChunk1,2,0,1,1)
self.Dapp = QtGui.QLCDNumber(self.centralwidget)
self.Dapp.setGeometry(QtCore.QRect(340, 668, 91, 38))
self.Dapp.setObjectName(_fromUtf8("Dapp"))
self.Dapp.setPalette(palettegl)
self.Dapp.display("00.00")
self.inGridlayout.addWidget(self.Dapp, 2, 0, 1, 1)
self.lbnd1 = QtGui.QSpinBox(self.centralwidget)
self.lbnd1.setRange(0, 20000)
self.lbnd1.setValue(1000)
self.lbnd1.setGeometry(QtCore.QRect(740, 668, 55, 38))
self.lbnd1.setObjectName(_fromUtf8("lbnd1size"))
self.inGridlayout.addWidget(self.lbnd1, 2, 1, 1, 1)
self.rbnd1 = QtGui.QSpinBox(self.centralwidget)
self.rbnd1.setRange(0, 20000)
self.rbnd1.setValue(2500)
self.rbnd1.setGeometry(QtCore.QRect(740, 668, 55, 38))
self.rbnd1.setObjectName(_fromUtf8("rbnd1size"))
self.inGridlayout.addWidget(self.rbnd1, 2, 2, 1, 1)
self.th1 = QtGui.QSpinBox(self.centralwidget)
self.th1.setRange(200000, 100000000)
self.th1.setValue(200000)
self.th1.setGeometry(QtCore.QRect(740, 668, 55, 38))
self.th1.setObjectName(_fromUtf8("th1size"))
self.inGridlayout.addWidget(self.th1, 2, 3, 1, 1)
self.qLabelLCD2 = QtGui.QLabel(self.centralwidget)
self.qLabelLCD2.setText("Estimated Non Payloaded DAP Percentage")
self.inGridlayout.addWidget(self.qLabelLCD2, 3, 0, 1, 1)
self.leftBoundary_2 = QtGui.QPushButton(self.centralwidget)
self.leftBoundary_2.setGeometry(QtCore.QRect(340, 668, 91, 38))
self.leftBoundary_2.setObjectName(_fromUtf8("leftBoundary_2"))
self.leftBoundary_2.clicked.connect(self.lbnd2f)
# self.leftBoundary_2.setPalette(palettegl)
# self.leftBoundary_2.display("00:00")
self.inGridlayout.addWidget(self.leftBoundary_2, 3, 1, 1, 1)
self.rightBoundary_2 = QtGui.QPushButton(self.centralwidget)
self.rightBoundary_2.setGeometry(QtCore.QRect(340, 668, 91, 38))
self.rightBoundary_2.setObjectName(_fromUtf8("rightBoundary_2"))
self.rightBoundary_2.clicked.connect(self.rbnd2f)
# self.rightBoundary_2.setPalette(palettegl)
# self.rightBoundary_2.display("00:00")
self.inGridlayout.addWidget(self.rightBoundary_2, 3, 2, 1, 1)
self.threshold_2 = QtGui.QPushButton(self.centralwidget)
self.threshold_2.setGeometry(QtCore.QRect(340, 668, 91, 38))
self.threshold_2.setObjectName(_fromUtf8("threshold_2"))
self.threshold_2.clicked.connect(self.th2f)
# self.threshold_2.setPalette(palettegl)
# self.threshold_2.display("00:00")
self.inGridlayout.addWidget(self.threshold_2, 3, 3, 1, 1)
# self.qLabelChunk2 = QtGui.QLabel(self.centralwidget)
# self.qLabelChunk2.setText("labelChunk2")
# self.inGridlayout.addWidget(self.qLabelChunk2,4,0,1,1)
self.nDapp = QtGui.QLCDNumber(self.centralwidget)
self.nDapp.setGeometry(QtCore.QRect(340, 668, 91, 38))
self.nDapp.setObjectName(_fromUtf8("nDapp"))
self.nDapp.setPalette(palettegl)
self.nDapp.display("00.00")
self.inGridlayout.addWidget(self.nDapp, 4, 0, 1, 1)
self.lbnd2 = QtGui.QSpinBox(self.centralwidget)
self.lbnd2.setRange(0, 20000)
self.lbnd2.setValue(2500)
self.lbnd2.setGeometry(QtCore.QRect(740, 668, 55, 38))
self.lbnd2.setObjectName(_fromUtf8("lbnd2size"))
self.inGridlayout.addWidget(self.lbnd2, 4, 1, 1, 1)
self.lbnd2.setEnabled(False)
self.rbnd2 = QtGui.QSpinBox(self.centralwidget)
self.rbnd2.setRange(0, 20000)
self.rbnd2.setValue(6000)
self.rbnd2.setGeometry(QtCore.QRect(740, 668, 55, 38))
self.rbnd2.setObjectName(_fromUtf8("rbnd2size"))
self.inGridlayout.addWidget(self.rbnd2, 4, 2, 1, 1)
self.rbnd2.setEnabled(False)
self.th2 = QtGui.QSpinBox(self.centralwidget)
self.th2.setRange(200000, 100000000)
self.th2.setValue(200000)
self.th2.setGeometry(QtCore.QRect(740, 668, 55, 38))
self.th2.setObjectName(_fromUtf8("th2size"))
self.inGridlayout.addWidget(self.th2, 4, 3, 1, 1)
self.th2.setEnabled(False)
self.qLabelLCD3 = QtGui.QLabel(self.centralwidget)
self.qLabelLCD3.setText("Payloaded Drone/Non PD Detection Count")
self.inGridlayout.addWidget(self.qLabelLCD3, 5, 0, 1, 1)
self.leftBoundary_3 = QtGui.QPushButton(self.centralwidget)
self.leftBoundary_3.setGeometry(QtCore.QRect(340, 668, 91, 38))
self.leftBoundary_3.setObjectName(_fromUtf8("leftBoundary_3"))
self.leftBoundary_3.clicked.connect(self.lbnd3f)
# self.leftBoundary_3.setPalette(palettegl)
# self.leftBoundary_3.display("00:00")
self.inGridlayout.addWidget(self.leftBoundary_3, 5, 1, 1, 1)
self.rightBoundary_3 = QtGui.QPushButton(self.centralwidget)
self.rightBoundary_3.setGeometry(QtCore.QRect(340, 668, 91, 38))
self.rightBoundary_3.setObjectName(_fromUtf8("rightBoundary_3"))
self.rightBoundary_3.clicked.connect(self.rbnd3f)
# self.lcdNumber3_2.setPalette(palettegl)
# self.lcdNumber3_2.display("00:00")
self.inGridlayout.addWidget(self.rightBoundary_3, 5, 2, 1, 1)
self.threshold_3 = QtGui.QPushButton(self.centralwidget)
self.threshold_3.setGeometry(QtCore.QRect(340, 668, 91, 38))
self.threshold_3.setObjectName(_fromUtf8("threshold_3"))
self.threshold_3.clicked.connect(self.th3f)
# self.threshold_3.setPalette(palettegl)
# self.threshold_3.display("00:00")
self.inGridlayout.addWidget(self.threshold_3, 5, 3, 1, 1)
# self.qLabelChunk3 = QtGui.QLabel(self.centralwidget)
# self.qLabelChunk3.setText("labelChunk3")
# self.inGridlayout.addWidget(self.qLabelChunk3, 6, 0, 1, 1)
self.CntLcd = QtGui.QLCDNumber(self.centralwidget)
self.CntLcd.setGeometry(QtCore.QRect(340, 668, 91, 38))
self.CntLcd.setObjectName(_fromUtf8("CntLcd"))
self.CntLcd.setPalette(palettegl)
self.CntLcd.display("00:00")
self.inGridlayout.addWidget(self.CntLcd, 6, 0, 1, 1)
self.lbnd3 = QtGui.QSpinBox(self.centralwidget)
self.lbnd3.setRange(0, 20000)
self.lbnd3.setValue(6000)
self.lbnd3.setGeometry(QtCore.QRect(740, 668, 55, 38))
self.lbnd3.setObjectName(_fromUtf8("lbnd3size"))
self.inGridlayout.addWidget(self.lbnd3, 6, 1, 1, 1)
self.lbnd3.setEnabled(False)
self.rbnd3 = QtGui.QSpinBox(self.centralwidget)
self.rbnd3.setRange(0, 20000)
self.rbnd3.setValue(9000)
self.rbnd3.setGeometry(QtCore.QRect(740, 668, 55, 38))
self.rbnd3.setObjectName(_fromUtf8("rbnd3size"))
self.inGridlayout.addWidget(self.rbnd3, 6, 2, 1, 1)
self.rbnd3.setEnabled(False)
self.th3 = QtGui.QSpinBox(self.centralwidget)
self.th3.setRange(200000, 100000000)
self.th3.setValue(200000)
self.th3.setGeometry(QtCore.QRect(740, 668, 55, 38))
self.th3.setObjectName(_fromUtf8("th3size"))
self.inGridlayout.addWidget(self.th3, 6, 3, 1, 1)
self.th3.setEnabled(False)
self.lcdNumber = QtGui.QLCDNumber(self.centralwidget)
self.lcdNumber.setGeometry(QtCore.QRect(340, 668, 91, 38))
self.lcdNumber.setObjectName(_fromUtf8("lcdNumber"))
self.lcdNumber.setPalette(palettegl)
self.lcdNumber.display("00:00")
self.inBoxlayout.addWidget(self.lcdNumber, 1)
self.analyzeButton = QtGui.QPushButton(self.centralwidget)
self.analyzeButton.setGeometry(QtCore.QRect(440, 668, 91, 38))
self.analyzeButton.setObjectName(_fromUtf8("analyzeButton"))
self.analyzeButton.clicked.connect(self.start)
self.inBoxlayout.addWidget(self.analyzeButton, 2)
self.analyzeButton.connect(
QtGui.QShortcut(QtGui.QKeySequence(QtCore.Qt.Key_F1),
self.centralwidget), QtCore.SIGNAL('activated()'),
self.start)
# self.inGridlayout.addWidget(self.analyzeButton)
self.stopButton = QtGui.QPushButton(self.centralwidget)
self.stopButton.setGeometry(QtCore.QRect(540, 668, 91, 38))
self.stopButton.setObjectName(_fromUtf8("stopButton"))
self.stopButton.clicked.connect(self.stop)
self.inBoxlayout.addWidget(self.stopButton, 3)
self.stopButton.connect(
QtGui.QShortcut(QtGui.QKeySequence(QtCore.Qt.Key_F2),
self.centralwidget), QtCore.SIGNAL('activated()'),
self.stop)
# self.inGridlayout.addWidget(self.stopButton)
self.recordButton = QtGui.QPushButton(self.centralwidget)
self.recordButton.setGeometry(QtCore.QRect(640, 668, 91, 38))
self.recordButton.setObjectName(_fromUtf8("recordButton"))
self.recordButton.clicked.connect(self.save)
self.inBoxlayout.addWidget(self.recordButton, 4)
self.recordButton.connect(
QtGui.QShortcut(QtGui.QKeySequence(QtCore.Qt.Key_F3),
self.centralwidget), QtCore.SIGNAL('activated()'),
self.save)
self.chunksize = QtGui.QSpinBox(self.centralwidget)
self.chunksize.setRange(10, 17)
self.chunksize.setValue(14)
self.chunksize.setGeometry(QtCore.QRect(740, 668, 55, 38))
self.chunksize.setObjectName(_fromUtf8("chunksize"))
self.inBoxlayout.addWidget(self.chunksize, 5)
self.chunksize.valueChanged.connect(self.intchanged)
# self.inGridlayout.addWidget(self.recordButton)
self.horizontalSlider = QtGui.QSlider(self.centralwidget)
self.horizontalSlider.setRange(200, 20000)
self.horizontalSlider.setValue(10000)
self.horizontalSlider.valueChanged.connect(self.hsvhandler)
self.horizontalSlider.setGeometry(QtCore.QRect(800, 668, 71, 38))
self.inBoxlayout.addWidget(self.horizontalSlider, 6)
self.horizontalSlider.setOrientation(QtCore.Qt.Horizontal)
self.horizontalSlider.setObjectName(_fromUtf8("horizontalSlider"))
# self.inGridlayout.addWidget(self.horizontalSlider)
self.verticallSlider = QtGui.QSlider(self.centralwidget)
self.verticallSlider.setRange(1000000, 100000000)
self.verticallSlider.setValue(1000000)
self.verticallSlider.valueChanged.connect(self.vsvhandler)
self.verticallSlider.setGeometry(QtCore.QRect(880, 668, 71, 38))
self.verticallSlider.setOrientation(QtCore.Qt.Vertical)
self.inBoxlayout.addWidget(self.verticallSlider, 7)
self.verticallSlider.setObjectName(_fromUtf8("verticalSlider"))
# self.inGridlayout.addWidget(self.verticallSlider, 7, 0, 7, 2)
# self.inGridlayout.addWidget(self.verticallSlider)
MainWindow.setCentralWidget(self.centralwidget)
self.menubar = QtGui.QMenuBar(MainWindow)
self.menubar.setGeometry(QtCore.QRect(0, 0, 1024, 26))
self.menubar.setObjectName(_fromUtf8("menubar"))
self.menuFFT_Mode = QtGui.QMenu(self.menubar)
self.menuFFT_Mode.setObjectName(_fromUtf8("menuDegree"))
self.menuCross = QtGui.QMenu(self.menubar)
self.menuCross.setObjectName(_fromUtf8("menuCross"))
self.menuCapture = QtGui.QMenu(self.menubar)
self.menuCapture.setObjectName(_fromUtf8("menuCapture"))
self.menuThreshold = QtGui.QMenu(self.menubar)
self.menuThreshold.setObjectName(_fromUtf8("menuThreshold"))
self.menuConnection = QtGui.QMenu(self.menubar)
self.menuConnection.setObjectName(_fromUtf8("menuConnection"))
self.menuConsole = QtGui.QMenu(self.menubar)
self.menuConsole.setObjectName(_fromUtf8("menuConsole"))
self.menuHelp = QtGui.QMenu(self.menubar)
self.menuHelp.setObjectName(_fromUtf8("menuHelp"))
MainWindow.setMenuBar(self.menubar)
self.statusbar = QtGui.QStatusBar(MainWindow)
self.statusbar.setObjectName(_fromUtf8("statusbar"))
MainWindow.setStatusBar(self.statusbar)
ag = QtGui.QActionGroup(MainWindow, exclusive=True)
self.actionDrone = ag.addAction(
QtGui.QAction(MainWindow, checkable=True))
self.actionDrone.setChecked(True)
self.actionDrone.triggered.connect(self.green)
self.actionDrone.setObjectName(_fromUtf8("zero"))
self.actionOthers = ag.addAction(
QtGui.QAction(MainWindow, checkable=True))
self.actionOthers.triggered.connect(self.red)
self.actionOthers.setObjectName(_fromUtf8("sixty"))
self.menuFFT_Mode.addAction(self.actionDrone)
self.menuFFT_Mode.addAction(self.actionOthers)
self.menubar.addAction(self.menuFFT_Mode.menuAction())
ag2 = QtGui.QActionGroup(MainWindow, exclusive=True)
self.scr = ag2.addAction(QtGui.QAction(MainWindow, checkable=True))
self.scr.setChecked(True)
self.scr.triggered.connect(self.scrmode)
self.scr.setObjectName(_fromUtf8("scrOnly"))
self.rec = ag2.addAction(QtGui.QAction(MainWindow, checkable=True))
self.rec.triggered.connect(self.recmode)
self.rec.setObjectName(_fromUtf8("recOnly"))
self.scrnrec = ag2.addAction(QtGui.QAction(MainWindow, checkable=True))
self.scrnrec.triggered.connect(self.scrnrecmode)
self.scrnrec.setObjectName(_fromUtf8("scrNrec"))
self.menuCapture.addAction(self.scr)
self.menuCapture.addAction(self.rec)
self.menuCapture.addAction(self.scrnrec)
self.menubar.addAction(self.menuCapture.menuAction())
ag3 = QtGui.QActionGroup(MainWindow, exclusive=True)
self.autopilot = ag3.addAction(
QtGui.QAction(MainWindow, checkable=True))
self.autopilot.triggered.connect(self.automode)
self.autopilot.setObjectName(_fromUtf8("autopilot"))
self.supervise = ag3.addAction(
QtGui.QAction(MainWindow, checkable=True))
self.supervise.triggered.connect(self.manualmode)
self.supervise.setObjectName(_fromUtf8("supervise"))
self.thonly = ag3.addAction(QtGui.QAction(MainWindow, checkable=True))
self.thonly.triggered.connect(self.thmode)
self.thonly.setObjectName(_fromUtf8("thonly"))
self.thonly.setChecked(True)
self.menuCross.addAction(self.autopilot)
self.menuCross.addAction(self.supervise)
self.menuCross.addAction(self.thonly)
self.menubar.addAction(self.menuCross.menuAction())
ag4 = QtGui.QActionGroup(MainWindow, exclusive=False)
self.fir = ag4.addAction(QtGui.QAction(MainWindow, checkable=True))
self.fir.setChecked(True)
self.fir.setObjectName(_fromUtf8("First"))
self.fir.triggered.connect(self.chkfir)
self.sec = ag4.addAction(QtGui.QAction(MainWindow, checkable=True))
self.sec.setObjectName(_fromUtf8("Second"))
self.sec.triggered.connect(self.chksec)
self.thi = ag4.addAction(QtGui.QAction(MainWindow, checkable=True))
self.thi.setObjectName(_fromUtf8("Third"))
self.thi.triggered.connect(self.chkthi)
self.menuThreshold.addAction(self.fir)
self.menuThreshold.addAction(self.sec)
self.menuThreshold.addAction(self.thi)
self.menubar.addAction(self.menuThreshold.menuAction())
ag5 = QtGui.QActionGroup(MainWindow, exclusive=True)
self.con = ag5.addAction(QtGui.QAction(MainWindow, checkable=True))
self.con.setChecked(True)
self.con.setObjectName(_fromUtf8("Connect"))
self.discon = ag5.addAction(QtGui.QAction(MainWindow, checkable=True))
self.discon.setObjectName(_fromUtf8("Disconnect"))
self.menuConnection.addAction(self.con)
self.menuConnection.addAction(self.discon)
self.menubar.addAction(self.menuConnection.menuAction())
ag6 = QtGui.QActionGroup(MainWindow)
self.write = ag6.addAction(QtGui.QAction(MainWindow))
self.write.setChecked(True)
self.write.setObjectName(_fromUtf8("Write"))
self.clear = ag6.addAction(QtGui.QAction(MainWindow))
self.clear.setObjectName(_fromUtf8("Clear"))
self.menuConsole.addAction(self.write)
self.menuConsole.addAction(self.clear)
self.menubar.addAction(self.menuConsole.menuAction())
ag7 = QtGui.QActionGroup(MainWindow)
self.dev = ag7.addAction(QtGui.QAction(MainWindow))
self.dev.setChecked(True)
# self.dev.triggered.connect(self.help)
self.dev.setObjectName(_fromUtf8("Developers"))
self.about = ag7.addAction(QtGui.QAction(MainWindow))
self.about.setObjectName(_fromUtf8("About"))
self.menuHelp.addAction(self.dev)
self.menuHelp.addAction(self.about)
self.menubar.addAction(self.menuHelp.menuAction())
self.retranslateUi(MainWindow)
QtCore.QMetaObject.connectSlotsByName(MainWindow)
def retranslateUi(self, MainWindow):
MainWindow.setWindowTitle(
_translate(
"MainWindow",
"Realtime Fast Fourier Transform Analyzer For Caputuring Payloaded Drone Frequency-Made by Kiefer Kim",
None))
self.recordButton.setText(_translate("MainWindow", "Record(F3)", None))
self.stopButton.setText(_translate("MainWindow", "Stop(F2)", None))
self.analyzeButton.setText(
_translate("MainWindow", "Analyze(F1)", None))
# leftBoundary_1 etc
self.leftBoundary_1.setText(
_translate("MainWindow", "1st Minimum Frequency", None))
self.rightBoundary_1.setText(
_translate("MainWindow", "1st Maximum Frequency", None))
self.threshold_1.setText(
_translate("MainWindow", "1st Threshold", None))
self.leftBoundary_2.setText(
_translate("MainWindow", "2nd Minimum Frequency", None))
self.rightBoundary_2.setText(
_translate("MainWindow", "2nd Maximum Frequency", None))
self.threshold_2.setText(
_translate("MainWindow", "2nd Threshold", None))
self.leftBoundary_3.setText(
_translate("MainWindow", "3rd Minimum Frequency", None))
self.rightBoundary_3.setText(
_translate("MainWindow", "3rd Maximum Frequency", None))
self.threshold_3.setText(
_translate("MainWindow", "3rd Threshold", None))
self.menuFFT_Mode.setTitle(
_translate("MainWindow", "Object Type", None))
self.actionDrone.setText(
_translate("MainWindow", "Payloaded Drone", None))
self.actionOthers.setText(_translate("MainWindow", "Others", None))
self.menuCross.setTitle(
_translate("MainWindow", "Machine Learning", None))
self.autopilot.setText(_translate("MainWindow", "Self Learn", None))
self.supervise.setText(_translate("MainWindow", "Validation", None))
self.thonly.setText(_translate("MainWindow", "Deactivate", None))
self.menuCapture.setTitle(_translate("MainWindow", "Record", None))
self.scr.setText(_translate("MainWindow", "Plot.png Only", None))
self.rec.setText(_translate("MainWindow", "Record.wav Only", None))
self.scrnrec.setText(
_translate("MainWindow", "Plot.png+Record.wav", None))
self.menuThreshold.setTitle(_translate("MainWindow", "Threshold",
None))
self.fir.setText(_translate("MainWindow", "First", None))
self.sec.setText(_translate("MainWindow", "Second", None))
self.thi.setText(_translate("MainWindow", "Third", None))
self.menuConnection.setTitle(
_translate("MainWindow", "Connection", None))
self.con.setText(_translate("MainWindow", "Connect", None))
self.discon.setText(_translate("MainWindow", "Disconnect", None))
#
self.menuConsole.setTitle(_translate("MainWindow", "Console", None))
self.write.setText(_translate("MainWindow", "Write", None))
self.clear.setText(_translate("MainWindow", "Clear", None))
self.menuHelp.setTitle(_translate("MainWindow", "Help", None))
self.dev.setText(_translate("MainWindow", "Developers", None))
self.about.setText(_translate("MainWindow", "About", None))
def tick(self):
now = datetime.datetime.now()
minutes, seconds = divmod((now - self.present).total_seconds(), 60)
self.displayTime = QtCore.QTime(0, minutes, round(seconds))
self.lcdNumber.display(self.displayTime.toString('mm:ss'))
if len(self.chunks) > 0:
X = self.chunks.pop(0)
self.data = scipy.array(struct.unpack("%dB" % (self.buffer * 2),
X))
# print "RECORDED",len(self.data)/float(self.rate),"SEC"
# ffty = scipy.fftpack.fft(self.data)
# fftx = scipy.fftpack.rfftfreq(self.buffer * 2, 1.0 / self.rate)
spectrum = scipy.fftpack.fft(self.data)
freq = scipy.fftpack.fftfreq(len(self.data), d=0.5 / self.rate)
#if self.mlFlag is 0:
ax2 = self.figure.add_subplot(111)
ax2.plot(freq, abs(spectrum), color=self.linecolor)
if self.fir.isChecked():
l1 = self.lbnd1.value() * self.buffer / self.rate
r1 = self.rbnd1.value() * self.buffer / self.rate
max1 = np.amax(abs(spectrum[l1:r1]))
for index, xy in enumerate(zip(freq, abs(spectrum))):
if xy[1] == max1:
plt.annotate('(%s, %s)' % (int(xy[0]), int(xy[1])),
xy=xy)
if max1 >= self.th1.value() and xy[0] > 0:
temp = self.capFlag
self.capFlag = -1
self.save()
if self.actionDrone.isChecked():
self.lineEdit.append(u'드론모드 th1 검출:')
if self.thonly.isChecked():
self.dapper[0] = max1 / self.th1.value(
) * 100
if self.dapper[0] > 100.00:
self.dapper[0] = 100.00
else:
self.lineEdit.append(u'기타모드 th1 검출:')
self.lineEdit.append(self.savename + ":" +
str(xy) + ">=" +
str(self.th1.value()))
self.capFlag = temp
if self.sec.isChecked():
l2 = self.lbnd2.value() * self.buffer / self.rate
r2 = self.rbnd2.value() * self.buffer / self.rate
max2 = np.amax(abs(spectrum[l2:r2]))
for index, xy in enumerate(zip(freq, abs(spectrum))):
if xy[1] == max2:
plt.annotate('(%s, %s)' % (int(xy[0]), int(xy[1])),
xy=xy)
if max2 >= self.th2.value() and xy[0] > 0:
temp = self.capFlag
self.capFlag = -1
self.save()
if self.actionDrone.isChecked():
self.lineEdit.append(u'드론모드 th2 검출:')
if self.thonly.isChecked():
self.dapper[1] = max2 / self.th2.value(
) * 100
if self.dapper[1] > 100.00:
self.dapper[1] = 100.00
else:
self.lineEdit.append(u'기타모드 th2 검출:')
self.lineEdit.append(self.savename + ":" +
str(xy) + ">=" +
str(self.th2.value()))
self.capFlag = temp
if self.thi.isChecked():
l3 = self.lbnd3.value() * self.buffer / self.rate
r3 = self.rbnd3.value() * self.buffer / self.rate
max3 = np.amax(abs(spectrum[l3:r3]))
for index, xy in enumerate(zip(freq, abs(spectrum))):
if xy[1] == max3:
plt.annotate('(%s, %s)' % (int(xy[0]), int(xy[1])),
xy=xy)
if max3 >= self.th3.value() and xy[0] > 0:
temp = self.capFlag
self.capFlag = -1
self.save()
if self.actionDrone.isChecked():
self.lineEdit.append(u'드론모드 th3 검출:')
if self.thonly.isChecked():
self.dapper[2] = max3 / self.th3.value(
) * 100
if self.dapper[2] > 100.00:
self.dapper[2] = 100.00
else:
self.lineEdit.append(u'기타모드 th3 검출:')
self.lineEdit.append(self.savename + ":" +
str(xy) + ">=" +
str(self.th3.value()))
self.capFlag = temp
self.calcdap()
#print np.alen(abs(spectrum))
#print np.alen(freq)
#for xy in zip(freq, abs(spectrum)):
# if maxamplitude == xy[1]:
# plt.annotate('(%s, %s)' % xy, xy=xy, textcoords='data')
ax2.set_xlim(0, self.xlimit)
ax2.set_ylim(0, self.ylimit)
ax2.set_xlabel("frequency [Hz]")
#ax2.set_title("Recorded Chunk Sec: " + str(len(self.data) / float(self.rate)))
# ax2.yaxis.set_major_formatter(mtick.FormatStrFormatter('%.1e'))
ax2.grid(True)
ax2.hold(False)
plt.title("Recorded Chunk Sec: " +
str(len(self.data) / float(self.rate)))
self.canvas.draw()
#elif self.mlFlag is 1 and self.namePre:
'''
data = [random.random() for i in range(10)]
# create an axis
ax = self.figure.add_subplot(111)
# discards the old graph
ax.hold(True)
# plot data
ax.plot(data, '*-')
# refresh canvas
self.canvas.draw()
'''
# 리스트에 CustomWidget의 객체들을 삽입
def create(self):
for i in range(0, 3):
wid = Ui_MainWindow.CustomWidget(
"abcdefghijklmnopqrstu") # 매개변수가 log 값이 되어야함
wid2 = QtGui.QListWidgetItem()
wid2.setSizeHint(QtCore.QSize(100, 60))
self.list.addItem(wid2)
self.list.setItemWidget(wid2, wid)
self.list.setStyleSheet(
"QListWidget::item { border-bottom: 1px solid black; }")
# 리스트에 있는 CustomWidget의 객체들을 삭제
def remove(self):
self.list.takeItem(self.list.currentRow())
def tongtong(self):
print "When I look into your eyes"
def start(self):
if self.timer is None:
self.recThread = threading.Thread(target=self.record)
self.recThread.start()
self.present = datetime.datetime.now()
self.timer = QtCore.QTimer()
self.timer.timeout.connect(self.tick)
self.timer.start(10)
self.chunksize.setDisabled(True)
self.statusbar.showMessage("Analyzing Started")
def stop(self):
if self.timer is not None:
self.statusbar.showMessage("Analyzing Stopped")
self.timer.stop()
self.timer = None
self.addThread = None
self.recThread = None
self.inStream = None
self.chunks = []
self.chunksize.setEnabled(True)
def save(self):
if self.figure:
now = datetime.datetime.now()
self.savename = now.isoformat().replace("T", "-").replace(
":", "-") + "+" + self.displayTime.toString('mm-ss')
if self.capFlag is 0:
if self.displayTime:
self.figure.savefig("%s.png" % self.savename,
bbox_inches='tight')
self.statusbar.showMessage(
self.savename + ".png Saved on Current Directory")
elif self.capFlag is 1:
if self.data is not None:
scipy.io.wavfile.write("%s.wav" % self.savename, self.rate,
self.data)
self.statusbar.showMessage(
self.savename + ".wav Saved on Current Directory")
elif self.capFlag is 2:
if self.data is not None and self.displayTime:
self.figure.savefig("%s.png" % self.savename,
bbox_inches='tight')
scipy.io.wavfile.write("%s.wav" % self.savename, self.rate,
self.data)
self.statusbar.showMessage(
self.savename + ".png and " + self.savename +
".wav Saved on Current Directory")
def intchanged(self):
self.buffer = 2**self.chunksize.value()
self.statusbar.showMessage(
"Current Buffer Size Changed: " + str(self.buffer * 2) +
" Change will be affected on further analysis ")
def green(self):
self.linecolor = "green"
self.statusbar.showMessage(
"Fast Fourier Transform Mode Changed to Payloaded Drone")
def red(self):
self.linecolor = "red"
self.statusbar.showMessage(
"Fast Fourier Transform Mode Changed to Others")
def hsvhandler(self, value):
self.xlimit = self.horizontalSlider.value()
self.statusbar.showMessage("X-limit Changed to: " + str(self.xlimit))
def vsvhandler(self, value):
self.ylimit = self.verticallSlider.value()
self.statusbar.showMessage("Y-limit Changed to: " + str(self.ylimit))
def scrmode(self):
self.capFlag = 0
self.statusbar.showMessage("Recording Mode Changed to Plot Only")
def recmode(self):
self.capFlag = 1
self.statusbar.showMessage("Recording Mode Changed to Wave Only")
def scrnrecmode(self):
self.capFlag = 2
self.statusbar.showMessage("Recording Mode Changed to Plot+Wave")
def automode(self):
self.mlFlag = 0
self.statusbar.showMessage(
"Machine Learning Mode Changed to Autopilot")
def manualmode(self):
self.mlFlag = 1
self.statusbar.showMessage("Machine Learning Mode Changed to Manual")
#name = QtGui.QFileDialog.getOpenself.savenames(None, u'녹음 파일 선택 - wav확장자를 가진 파일 하나를 열어주세요',QtGui.QDesktopServices.storageLocation(QtGui.QDesktopServices.MusicLocation),"Record (*.wav)");
#name = QtGui.QFileDialog.getOpenself.savenames(None, u'녹음 파일 선택 - wav확장자를 가진 파일 하나를 열어주세요',"./","Record (*.wav)");
'''
if not name:
return
else:
self.namePre=name[0]
self.ratePre, X = scipy.io.wavfile.read(self.namePre)
fnarray=self.namePre.split("\\")
self.namePre=fnarray[len(fnarray)-1]
self.spectrumPre = scipy.fftpack.fft(X)
self.freqPre=scipy.fftpack.fftfreq(len(X), d=1.0 / self.ratePre)
self.nsamPre=X.shape[0]
'''
def thmode(self):
'''
for file in os.listdir("./X"):
if file.endswith(".wav"):
fnarray = file.split("/")
tt=fnarray[len(fnarray) - 1]
self.ratePre, X = scipy.io.wavfile.read("./X/"+file)
self.spectrumPre = scipy.fftpack.fft(X)
self.freqPre = scipy.fftpack.fftfreq(len(X), d=1.0 / self.ratePre)
ax2 = self.figure.add_subplot(111)
ax2.plot(self.freqPre, abs(self.spectrumPre), color=self.linecolor)
ax2.set_xlim(1000, self.xlimit)
ax2.set_ylim(0, 10000000)
ax2.set_xlabel("frequency [Hz]")
# ax2.set_title("Recorded Chunk Sec: " + str(len(self.data) / float(self.rate)))
# ax2.yaxis.set_major_formatter(mtick.FormatStrFormatter('%.1e'))
ax2.set_title(tt)
ax2.grid(True)
#self.canvas.draw()
print tt
plt.savefig("%s.png" % tt, bbox_inches='tight')
'''
self.mlFlag = 2
self.statusbar.showMessage(
"Machine Learning Mode Deactivated. Using Preset Threshold")
def chkfir(self):
if self.fir.isChecked() == False:
self.lbnd1.setEnabled(False)
self.rbnd1.setEnabled(False)
self.th1.setEnabled(False)
else:
self.lbnd1.setEnabled(True)
self.rbnd1.setEnabled(True)
self.th1.setEnabled(True)
def chksec(self):
if self.sec.isChecked() == False:
self.lbnd2.setEnabled(False)
self.rbnd2.setEnabled(False)
self.th2.setEnabled(False)
else:
self.lbnd2.setEnabled(True)
self.rbnd2.setEnabled(True)
self.th2.setEnabled(True)
def chkthi(self):
if self.thi.isChecked() == False:
self.lbnd3.setEnabled(False)
self.rbnd3.setEnabled(False)
self.th3.setEnabled(False)
else:
self.lbnd3.setEnabled(True)
self.rbnd3.setEnabled(True)
self.th3.setEnabled(True)
def lbnd1f(self):
self.leftBoundary_1.setEnabled(False)
self.leftBoundary_2.setEnabled(True)
self.leftBoundary_3.setEnabled(True)
self.rightBoundary_1.setEnabled(True)
self.rightBoundary_2.setEnabled(True)
self.rightBoundary_3.setEnabled(True)
self.threshold_1.setEnabled(True)
self.threshold_2.setEnabled(True)
self.threshold_3.setEnabled(True)
self.lbnd1.setFocus(True)
def lbnd2f(self):
self.leftBoundary_1.setEnabled(True)
self.leftBoundary_2.setEnabled(False)
self.leftBoundary_3.setEnabled(True)
self.rightBoundary_1.setEnabled(True)
self.rightBoundary_2.setEnabled(True)
self.rightBoundary_3.setEnabled(True)
self.threshold_1.setEnabled(True)
self.threshold_2.setEnabled(True)
self.threshold_3.setEnabled(True)
self.lbnd2.setFocus(True)
def lbnd3f(self):
self.leftBoundary_1.setEnabled(True)
self.leftBoundary_2.setEnabled(True)
self.leftBoundary_3.setEnabled(False)
self.rightBoundary_1.setEnabled(True)
self.rightBoundary_2.setEnabled(True)
self.rightBoundary_3.setEnabled(True)
self.threshold_1.setEnabled(True)
self.threshold_2.setEnabled(True)
self.threshold_3.setEnabled(True)
self.lbnd3.setFocus(True)
def rbnd1f(self):
self.leftBoundary_1.setEnabled(True)
self.leftBoundary_2.setEnabled(True)
self.leftBoundary_3.setEnabled(True)
self.rightBoundary_1.setEnabled(False)
self.rightBoundary_2.setEnabled(True)
self.rightBoundary_3.setEnabled(True)
self.threshold_1.setEnabled(True)
self.threshold_2.setEnabled(True)
self.threshold_3.setEnabled(True)
self.rbnd1.setFocus(True)
def rbnd2f(self):
self.leftBoundary_1.setEnabled(True)
self.leftBoundary_2.setEnabled(True)
self.leftBoundary_3.setEnabled(True)
self.rightBoundary_1.setEnabled(True)
self.rightBoundary_2.setEnabled(False)
self.rightBoundary_3.setEnabled(True)
self.threshold_1.setEnabled(True)
self.threshold_2.setEnabled(True)
self.threshold_3.setEnabled(True)
self.rbnd2.setFocus(True)
def rbnd3f(self):
self.leftBoundary_1.setEnabled(True)
self.leftBoundary_2.setEnabled(True)
self.leftBoundary_3.setEnabled(True)
self.rightBoundary_1.setEnabled(True)
self.rightBoundary_2.setEnabled(True)
self.rightBoundary_3.setEnabled(False)
self.threshold_1.setEnabled(True)
self.threshold_2.setEnabled(True)
self.threshold_3.setEnabled(True)
self.rbnd3.setFocus(True)
def th1f(self):
self.leftBoundary_1.setEnabled(True)
self.leftBoundary_2.setEnabled(True)
self.leftBoundary_3.setEnabled(True)
self.rightBoundary_1.setEnabled(True)
self.rightBoundary_2.setEnabled(True)
self.rightBoundary_3.setEnabled(True)
self.threshold_1.setEnabled(False)
self.threshold_2.setEnabled(True)
self.threshold_3.setEnabled(True)
self.th1.setFocus(True)
def th2f(self):
self.leftBoundary_1.setEnabled(True)
self.leftBoundary_2.setEnabled(True)
self.leftBoundary_3.setEnabled(True)
self.rightBoundary_1.setEnabled(True)
self.rightBoundary_2.setEnabled(True)
self.rightBoundary_3.setEnabled(True)
self.threshold_1.setEnabled(True)
self.threshold_2.setEnabled(False)
self.threshold_3.setEnabled(True)
self.th2.setFocus(True)
def th3f(self):
self.leftBoundary_1.setEnabled(True)
self.leftBoundary_2.setEnabled(True)
self.leftBoundary_3.setEnabled(True)
self.rightBoundary_1.setEnabled(True)
self.rightBoundary_2.setEnabled(True)
self.rightBoundary_3.setEnabled(True)
self.threshold_1.setEnabled(True)
self.threshold_2.setEnabled(True)
self.threshold_3.setEnabled(False)
self.th3.setFocus(True)
def calcdap(self):
nzerocnt = 0
avgdap = 0.00
for per in self.dapper:
if per > 0:
nzerocnt += 1
avgdap += per
if nzerocnt > 0:
self.avgper = avgdap / float(nzerocnt)
self.Dapp.display(self.avgper)
else:
self.Dapp.display(0.00)
def calcndap(self):
nzerocnt = 0
avgndap = 0.00
for per in self.ndapper:
if per > 0:
nzerocnt += 1
avgndap += per
if nzerocnt > 0:
self.navgper = avgndap / float(nzerocnt)
self.nDapp.display(self.navgper)
else:
self.nDapp.display(0.00)
def plotClick(self, value):
if not str(value).__contains__("(None,None)"):
arr = str(value).split("=")[2].lstrip("(").replace(") button",
"").split(",")
xflt = float(arr[0])
x = int(xflt)
yflt = float(arr[1])
y = int(yflt)
if self.leftBoundary_1.isEnabled() is False:
if x < self.rbnd1.value():
self.lbnd1.setValue(x)
self.leftBoundary_1.setEnabled(True)
elif self.leftBoundary_2.isEnabled() is False:
if x < self.rbnd2.value():
self.lbnd2.setValue(x)
self.leftBoundary_2.setEnabled(True)
elif self.leftBoundary_3.isEnabled() is False:
if x < self.rbnd3.value():
self.lbnd3.setValue(x)
self.leftBoundary_3.setEnabled(True)
elif self.rightBoundary_1.isEnabled() is False:
if x > self.lbnd1.value():
self.rbnd1.setValue(x)
self.rightBoundary_1.setEnabled(True)
elif self.rightBoundary_2.isEnabled() is False:
if x > self.lbnd2.value():
self.rbnd2.setValue(x)
self.rightBoundary_2.setEnabled(True)
elif self.rightBoundary_3.isEnabled() is False:
if x > self.lbnd3.value():
self.rbnd3.setValue(x)
self.rightBoundary_3.setEnabled(True)
elif self.threshold_1.isEnabled() is False:
self.th1.setValue(y)
self.threshold_1.setEnabled(True)
elif self.threshold_2.isEnabled() is False:
self.th2.setValue(y)
self.threshold_2.setEnabled(True)
elif self.threshold_3.isEnabled() is False:
self.th3.setValue(y)
self.threshold_3.setEnabled(True)
#if event.xdata is not None:
# print('button=%d, x=%d, y=%d, xdata=%f, ydata=%f' % (event.button, event.x, event.y, event.xdata, event.ydata))
def listItemRightClicked(self, QPos):
self.listMenu = QtGui.QMenu()
menu_item = self.listMenu.addAction("Remove Item")
# self.connect(menu_item, QtCore.SIGNAL("triggered()"), self.menuItemClicked)
parentPosition = self.list.mapToGlobal(QtCore.QPoint(0, 0))
self.listMenu.move(parentPosition + QPos)
self.listMenu.show()
def menuItemClicked(self):
currentItemName = str(
self.listWidget_extractedmeters.currentItem().text())
print(currentItemName)
class CustomWidget(QtGui.QWidget):
downloadRequest = QtCore.pyqtSignal(str)
def __init__(self, log):
QtGui.QWidget.__init__(self)
self.label = QtGui.QLabel(self)
self.label.setText(log)
self.button1 = QtGui.QPushButton('1', self)
self.button1.setFixedSize(20, 20)
#self.button1.clicked.connect(Ui_MainWindow.tongtong)
self.button2 = QtGui.QPushButton('2', self)
self.button2.setFixedSize(20, 20)
self.button2.clicked.connect(self.handleButton)
self.button3 = QtGui.QPushButton('3', self)
self.button3.setFixedSize(20, 20)
self.button3.clicked.connect(self.handleButton)
self.button4 = QtGui.QPushButton('4', self)
self.button4.setFixedSize(20, 20)
self.button4.clicked.connect(self.handleButton)
self.button5 = QtGui.QPushButton('5', self)
self.button5.setFixedSize(20, 20)
self.button5.clicked.connect(self.handleButton)
self.layout = QtGui.QVBoxLayout(self)
self.layout2 = QtGui.QHBoxLayout(self)
self.layout.addWidget(self.label)
self.layout.addLayout(self.layout2, 1)
self.layout2.addWidget(self.button1)
self.layout2.addWidget(self.button2)
self.layout2.addWidget(self.button3)
self.layout2.addWidget(self.button4)
self.layout2.addWidget(self.button5)
def handleButton(self):
url = self.edit.text().strip()
if url and not self._thread.isRunning():
self.viewer.clear()
self._thread.start()
# safely communicate with worker via signal
self.downloadRequest.emit(url)
class SessionsManager(QDialog):
"""Session Manager, to load different configurations of ninja."""
def __init__(self, parent=None):
super(SessionsManager, self).__init__(parent, Qt.Dialog)
self._ide = parent
self.setWindowTitle(translations.TR_SESSIONS_TITLE)
self.setMinimumWidth(400)
vbox = QVBoxLayout(self)
vbox.addWidget(QLabel(translations.TR_SESSIONS_DIALOG_BODY))
self.sessionList = QListWidget()
self.sessionList.addItems([key for key in settings.SESSIONS])
self.sessionList.setCurrentRow(0)
self.contentList = QListWidget()
self.btnDelete = QPushButton(translations.TR_SESSIONS_BTN_DELETE)
self.btnDelete.setSizePolicy(QSizePolicy.Fixed, QSizePolicy.Fixed)
self.btnUpdate = QPushButton(translations.TR_SESSIONS_BTN_UPDATE)
self.btnUpdate.setSizePolicy(QSizePolicy.Fixed, QSizePolicy.Fixed)
self.btnCreate = QPushButton(translations.TR_SESSIONS_BTN_CREATE)
self.btnCreate.setSizePolicy(QSizePolicy.Fixed, QSizePolicy.Fixed)
self.btnOpen = QPushButton(translations.TR_SESSIONS_BTN_ACTIVATE)
self.btnOpen.setSizePolicy(QSizePolicy.Fixed, QSizePolicy.Fixed)
self.btnOpen.setDefault(True)
hbox = QHBoxLayout()
hbox.addWidget(self.btnDelete)
hbox.addWidget(self.btnUpdate)
hbox.addWidget(self.btnCreate)
hbox.addWidget(self.btnOpen)
vbox.addWidget(self.sessionList)
vbox.addWidget(self.contentList)
vbox.addLayout(hbox)
self.connect(self.sessionList, SIGNAL("itemSelectionChanged()"),
self.load_session_content)
self.connect(self.btnOpen, SIGNAL("clicked()"), self.open_session)
self.connect(self.btnUpdate, SIGNAL("clicked()"), self.save_session)
self.connect(self.btnCreate, SIGNAL("clicked()"), self.create_session)
self.connect(self.btnDelete, SIGNAL("clicked()"), self.delete_session)
self.load_session_content()
def load_session_content(self):
"""Load the selected session, replacing the current session."""
item = self.sessionList.currentItem()
self.contentList.clear()
if item is not None:
key = item.text()
files = [self.tr('Files:')] + \
[file[0] for file in settings.SESSIONS[key][0]]
projects = [self.tr('Projects:')] + settings.SESSIONS[key][1]
content = files + projects
self.contentList.addItems(content)
def create_session(self):
"""Create a new Session."""
sessionInfo = QInputDialog.getText(
None, translations.TR_SESSIONS_CREATE_TITLE,
translations.TR_SESSIONS_CREATE_BODY)
if sessionInfo[1]:
sessionName = sessionInfo[0]
if not sessionName or sessionName in settings.SESSIONS:
QMessageBox.information(self,
translations.TR_SESSIONS_MESSAGE_TITLE,
translations.TR_SESSIONS_MESSAGE_BODY)
return
SessionsManager.save_session_data(sessionName, self._ide)
self._ide.Session = sessionName
self.close()
@classmethod
def save_session_data(cls, sessionName, ide):
"""Save the updates from a session."""
openedFiles = ide.filesystem.get_files()
files_info = []
for path in openedFiles:
editable = ide.get_or_create_editable(path)
if editable.is_dirty:
stat_value = 0
else:
stat_value = os.stat(path).st_mtime
files_info.append(
[path, editable.editor.get_cursor_position(), stat_value])
projects_obj = ide.filesystem.get_projects()
projects = [projects_obj[proj].path for proj in projects_obj]
settings.SESSIONS[sessionName] = [files_info, projects]
qsettings = ide.data_settings()
qsettings.setValue('ide/sessions', settings.SESSIONS)
def save_session(self):
if self.sessionList.currentItem():
sessionName = self.sessionList.currentItem().text()
SessionsManager.save_session_data(sessionName, self._ide)
self._ide.show_message(
translations.TR_SESSIONS_UPDATED_NOTIF %
{'session': sessionName}, 2000)
self.load_session_content()
def open_session(self):
if self.sessionList.currentItem():
key = self.sessionList.currentItem().text()
self._load_session_data(key)
self._ide.Session = key
self.close()
def delete_session(self):
if self.sessionList.currentItem():
key = self.sessionList.currentItem().text()
settings.SESSIONS.pop(key)
self.sessionList.takeItem(self.sessionList.currentRow())
self.contentList.clear()
qsettings = self._ide.data_settings()
qsettings.setValue('ide/sessions', settings.SESSIONS)
def _load_session_data(self, key):
"""Activate the selected session, closing the current files/projects"""
main_container = self._ide.get_service('main_container')
projects_explorer = self._ide.get_service('projects_explorer')
if projects_explorer and main_container:
projects_explorer.close_opened_projects()
for fileData in settings.SESSIONS[key][0]:
path, line, stat_value = fileData
if file_manager.file_exists(path):
mtime = os.stat(path).st_mtime
ignore_checkers = (mtime == stat_value)
main_container.open_file(path,
line,
ignore_checkers=ignore_checkers)
if projects_explorer:
projects_explorer.load_session_projects(
settings.SESSIONS[key][1])
class NotebookSettingsDialog(QDialog):
"""GUI for adjusting notebook settings"""
def __init__(self, parent=None):
super(NotebookSettingsDialog, self).__init__(parent)
#widgets for tab 1
self.mdExts = QListWidget()
self.mjEdit = QLineEdit()
self.moveUp = QPushButton('<<')
self.moveDown = QPushButton('>>')
self.configureExtension = QPushButton('Edit Settings for this extension')
self.tmpdict = deepcopy(self.parent().settings.extcfg)
#widgets for tab 2
self.fExtEdit = QLineEdit()
self.attImgEdit = QLineEdit()
self.attDocEdit = QLineEdit()
# mandatory button box
self.buttonBox = QDialogButtonBox(QDialogButtonBox.Ok |
QDialogButtonBox.Cancel)
#tab panels
tabs = QTabWidget()
markupTab = QWidget()
fileExtsTab = QWidget()
tabs.addTab(markupTab, "Markdown")
tabs.addTab(fileExtsTab, "File extensions")
#initialization functions
self.initExtList()
self.mdExts.setDragDropMode(QAbstractItemView.InternalMove)
self.mjEdit.setText(self.parent().settings.mathjax)
self.attImgEdit.setText(', '.join(self.parent().settings.attachmentImage))
self.attDocEdit.setText(', '.join(self.parent().settings.attachmentDocument))
self.fExtEdit.setText(self.parent().settings.fileExt)
#set up tab 1
layout=QGridLayout(markupTab)
layout.addWidget(QLabel("Markdown extensions"),0,0,1,4)
layout.addWidget(self.mdExts,1,0,1,4)
layout.addWidget(self.moveUp,2,0,1,1)
layout.addWidget(self.moveDown,2,1,1,1)
layout.addWidget(self.configureExtension,2,2,1,2)
layout.addWidget(QLabel("MathJax Location"),3,0,1,1)
layout.addWidget(self.mjEdit,3,1,1,3)
#set up tab 2
layout=QGridLayout(fileExtsTab)
layout.addWidget(QLabel("Note file extension"),0,0,1,1)
layout.addWidget(QLabel("Image file extension"),1,0,1,1)
layout.addWidget(QLabel("Document file extension"),2,0,1,1)
layout.addWidget(self.fExtEdit,0,1,1,1)
layout.addWidget(self.attImgEdit,1,1,1,1)
layout.addWidget(self.attDocEdit,2,1,1,1)
#put it together
vlayout = QVBoxLayout(self)
vlayout.addWidget(tabs)
vlayout.addWidget(self.buttonBox)
#setup signal handlers
self.moveUp.clicked.connect(self.moveItemUp)
self.configureExtension.clicked.connect(self.configExt)
self.moveDown.clicked.connect(self.moveItemDown)
self.buttonBox.accepted.connect(self.accept)
self.buttonBox.rejected.connect(self.reject)
def configExt(self, checked=False, ext=None):
if ext is None:
ext = self.mdExts.currentItem().text()
cfg = self.tmpdict.get(ext,[])
dialog = NotebookExtSettingsDialog(cfg_list=cfg)
done = dialog.exec()
if done:
self.tmpdict[ext] = dialog.configToList()
def initExtList(self):
extset=set(self.parent().settings.extensions)
#for easier performance in checking
for ext in self.parent().settings.extensions:
item = QListWidgetItem(ext, self.mdExts)
item.setFlags(item.flags() | Qt.ItemIsUserCheckable)
item.setCheckState(Qt.Checked)
for ext in self.parent().settings.faulty_exts:
item = QListWidgetItem(ext, self.mdExts)
item.setFlags(item.flags() | Qt.ItemIsUserCheckable)
item.setBackground(QBrush(QColor('red')))
item.setForeground(QBrush(QColor('black')))
item.setCheckState(Qt.Checked)
for ext in allMDExtensions():
if ext in extset: continue
item = QListWidgetItem(ext, self.mdExts)
item.setFlags(item.flags() | Qt.ItemIsUserCheckable)
item.setCheckState(Qt.Unchecked)
#self.mdExts.addItem(item)
def moveItemUp(self):
item = self.mdExts.currentItem()
row = self.mdExts.currentRow()
if row != 0:
# self.mdExts.removeItemWidget(item)
self.mdExts.takeItem(row)
self.mdExts.insertItem(row-1, item)
self.mdExts.setCurrentRow(row-1)
def moveItemDown(self):
item = self.mdExts.currentItem()
row = self.mdExts.currentRow()
count = self.mdExts.count()
if row != count-1:
self.mdExts.takeItem(row)
self.mdExts.insertItem(row+1, item)
self.mdExts.setCurrentRow(row+1)
def accept(self):
#write to settings first
msettings = self.parent().settings
nbsettings = msettings.qsettings
nbsettings.setValue('mathJax', self.mjEdit.text())
extlist = []
for i in range(self.mdExts.count()):
item = self.mdExts.item(i)
if item.checkState() == Qt.Checked:
extlist.append(item.text())
writeListToSettings(nbsettings, 'extensions', extlist)
writeListToSettings(nbsettings, 'attachmentImage', self.attImgEdit.text().split(", "))
writeListToSettings(nbsettings, 'attachmentDocument', self.attDocEdit.text().split(", "))
writeDictToSettings(nbsettings, 'extensionsConfig', self.tmpdict)
#then to memory
msettings.extensions = extlist
msettings.mathjax = self.mjEdit.text()
msettings.attachmentDocument = readListFromSettings(nbsettings, 'attachmentDocument')
msettings.attachmentImage = readListFromSettings(nbsettings, 'attachmentImage')
msettings.extcfg.update(self.tmpdict)
msettings.md = markdown.Markdown(msettings.extensions, extension_configs=msettings.extcfg)
#then make mikidown use these settings NOW
curitem=self.parent().notesTree.currentItem()
self.parent().currentItemChangedWrapper(curitem, curitem)
QDialog.accept(self)
class TagsDialog(QDialog):
def __init__(self, dockwidget, parent, params):
QDialog.__init__(self, parent)
main_lay = QVBoxLayout(self)
self.dockwidget = dockwidget
self.params = params
self.setWindowTitle('Tags editor')
# Top frame
self.fra_top = QFrame()
fra_top_lay = QVBoxLayout(self.fra_top)
self.lst_main = QListWidget(self)
self.btn_add = QPushButton('Add tag')
self.btn_add.clicked.connect(self.add_tag)
self.btn_remove = QPushButton('Remove tag')
self.btn_remove.clicked.connect(self.remove_tag)
fra_top_lay.addWidget(self.lst_main)
fra_top_lay.addWidget(self.btn_add)
fra_top_lay.addWidget(self.btn_remove)
# Bottom frame
self.fra_bottom = QFrame()
fra_bottom_lay = QHBoxLayout(self.fra_bottom)
btb_main = QDialogButtonBox(QDialogButtonBox.Ok
| QDialogButtonBox.Cancel)
btb_main.accepted.connect(self.ok)
btb_main.rejected.connect(self.reject)
fra_bottom_lay.addWidget(btb_main)
# Main
main_lay.addWidget(self.fra_top)
main_lay.addWidget(self.fra_bottom)
self.initialize()
def initialize(self):
for tag_name in self.params.tag_names:
self.lst_main.insertItem(self.lst_main.count(),
QListWidgetItem(tag_name, self.lst_main))
def ok(self):
tag_names = []
for r in range(self.lst_main.count()):
tag_names.append(self.lst_main.item(r).text())
self.params.tag_names = tag_names
self.setVisible(False)
def reject(self):
self.setVisible(False)
def add_tag(self):
tag_name_dialog = TagNameDialog(self.dockwidget, self)
tag_name_dialog.exec_()
tag_name = tag_name_dialog.get_tag_name()
if tag_name is not None:
current_row = self.lst_main.currentRow()
if current_row is None:
current_row = self.lst_main.count()
self.lst_main.insertItem(current_row,
QListWidgetItem(tag_name, self.lst_main))
def remove_tag(self):
sel_items = self.lst_main.selectedItems()
for sel_item in sel_items:
self.lst_main.takeItem(self.lst_main.row(sel_item))
class CodeCompletionWidget(QFrame):
def __init__(self, editor):
super(CodeCompletionWidget,
self).__init__(None, Qt.FramelessWindowHint | Qt.ToolTip)
self._editor = editor
self.stack_layout = QStackedLayout(self)
self.stack_layout.setContentsMargins(0, 0, 0, 0)
self.stack_layout.setSpacing(0)
self.completion_list = QListWidget()
self.completion_list.setMinimumHeight(200)
self.completion_list.setAlternatingRowColors(True)
self._list_index = self.stack_layout.addWidget(self.completion_list)
self._icons = {
'a': resources.IMAGES['attribute'],
'f': resources.IMAGES['function'],
'c': resources.IMAGES['class'],
'm': resources.IMAGES['module']
}
self.cc = code_completion.CodeCompletion()
self._completion_results = {}
self._prefix = u''
self.setVisible(False)
self.source = ''
self._key_operations = {
Qt.Key_Up: self._select_previous_row,
Qt.Key_Down: self._select_next_row,
Qt.Key_PageUp: (lambda: self._select_previous_row(6)),
Qt.Key_PageDown: (lambda: self._select_next_row(6)),
Qt.Key_Right: lambda: None,
Qt.Key_Left: lambda: None,
Qt.Key_Enter: self.pre_key_insert_completion,
Qt.Key_Return: self.pre_key_insert_completion,
Qt.Key_Tab: self.pre_key_insert_completion,
Qt.Key_Space: self.hide_completer,
Qt.Key_Escape: self.hide_completer,
Qt.Key_Backtab: self.hide_completer,
Qt.NoModifier: self.hide_completer,
Qt.ShiftModifier: self.hide_completer,
}
desktop = QApplication.instance().desktop()
self._desktop_geometry = desktop.availableGeometry()
self.connect(self._editor.document(), SIGNAL("blockCountChanged(int)"),
self.update_metadata)
def _select_next_row(self, move=1):
new_row = self.completion_list.currentRow() + move
if new_row < self.completion_list.count():
self.completion_list.setCurrentRow(new_row)
else:
self.completion_list.setCurrentRow(0)
return True
def _select_previous_row(self, move=1):
new_row = self.completion_list.currentRow() - move
if new_row >= 0:
self.completion_list.setCurrentRow(new_row)
else:
self.completion_list.setCurrentRow(self.completion_list.count() -
move)
return True
def update_metadata(self):
source = self._editor.get_text()
source = source.encode(self._editor.encoding)
self.cc.analyze_file('', source)
def insert_completion(self, insert):
if insert != self._prefix:
extra = len(self._prefix) - len(insert)
self._editor.textCursor().insertText(insert[extra:])
self.hide_completer()
def _get_geometry(self):
cr = self._editor.cursorRect()
point = self._editor.mapToGlobal(cr.topLeft())
cr.moveTopLeft(point)
#Check new position according desktop geometry
width = (self.completion_list.sizeHintForColumn(0) + \
self.completion_list.verticalScrollBar().sizeHint().width() + 10)
height = 200
orientation = (point.y() + height) < self._desktop_geometry.height()
if orientation:
cr.moveTop(cr.bottom())
cr.setWidth(width)
cr.setHeight(height)
if not orientation:
cr.moveBottom(cr.top())
xpos = self._desktop_geometry.width() - (point.x() + width)
if xpos < 0:
cr.moveLeft(cr.left() + xpos)
return cr
def complete(self, results):
self.add_list_items(results)
self.completion_list.setCurrentRow(0)
cr = self._get_geometry()
self.setGeometry(cr)
self.completion_list.updateGeometries()
self.show()
def add_list_items(self, proposals):
self.completion_list.clear()
for p in proposals:
self.completion_list.addItem(
QListWidgetItem(
QIcon(self._icons.get(p[0],
resources.IMAGES['attribute'])),
p[1]))
def set_completion_prefix(self, prefix, valid=True):
self._prefix = prefix
proposals = []
proposals += [('m', item) \
for item in self._completion_results.get('modules', []) \
if item.startswith(prefix)]
proposals += [('c', item) \
for item in self._completion_results.get('classes', []) \
if item.startswith(prefix)]
proposals += [('a', item) \
for item in self._completion_results.get('attributes', []) \
if item.startswith(prefix)]
proposals += [('f', item) \
for item in self._completion_results.get('functions', []) \
if item.startswith(prefix)]
if proposals and valid:
self.complete(proposals)
else:
self.hide_completer()
def fill_completer(self):
source = self._editor.get_text()
source = source.encode(self._editor.encoding)
offset = self._editor.textCursor().position()
results = self.cc.get_completion(source, offset)
self._completion_results = results
prefix = self._editor._text_under_cursor()
self.set_completion_prefix(prefix)
def hide_completer(self):
self._prefix = ''
self.hide()
def pre_key_insert_completion(self):
insert = unicode(self.completion_list.currentItem().text())
self.insert_completion(insert)
self.hide_completer()
return True
def process_pre_key_event(self, event):
if not self.isVisible() or self._editor.lang != "python":
return False
skip = self._key_operations.get(event.key(), lambda: False)()
self._key_operations.get(event.modifiers(), lambda: False)()
if skip is None:
skip = False
return skip
def process_post_key_event(self, event):
if not settings.CODE_COMPLETION or self._editor.lang != "python":
return
if self.isVisible():
source = self._editor.get_text()
source = source.encode(self._editor.encoding)
offset = self._editor.textCursor().position()
prefix, valid = self.cc.get_prefix(source, offset)
self.set_completion_prefix(prefix, valid)
self.completion_list.setCurrentRow(0)
if event.key() == Qt.Key_Period or (event.key() == Qt.Key_Space and \
event.modifiers() == Qt.ControlModifier):
self.fill_completer()
class PreferencesDialog(QDialog):
def __init__(self, mainwindow):
super(PreferencesDialog, self).__init__(mainwindow)
self.setWindowModality(Qt.WindowModal)
if mainwindow:
self.addAction(mainwindow.actionCollection.help_whatsthis)
layout = QVBoxLayout()
layout.setSpacing(10)
self.setLayout(layout)
# listview to the left, stacked widget to the right
top = QHBoxLayout()
layout.addLayout(top)
self.pagelist = QListWidget(self)
self.stack = QStackedWidget(self)
top.addWidget(self.pagelist, 0)
top.addWidget(self.stack, 2)
layout.addWidget(widgets.Separator(self))
b = self.buttons = QDialogButtonBox(self)
b.setStandardButtons(
QDialogButtonBox.Ok
| QDialogButtonBox.Cancel
| QDialogButtonBox.Apply
| QDialogButtonBox.Reset
| QDialogButtonBox.Help)
layout.addWidget(b)
b.accepted.connect(self.accept)
b.rejected.connect(self.reject)
b.button(QDialogButtonBox.Apply).clicked.connect(self.saveSettings)
b.button(QDialogButtonBox.Reset).clicked.connect(self.loadSettings)
b.button(QDialogButtonBox.Help).clicked.connect(self.showHelp)
b.button(QDialogButtonBox.Help).setShortcut(QKeySequence.HelpContents)
b.button(QDialogButtonBox.Apply).setEnabled(False)
# fill the pagelist
self.pagelist.setIconSize(QSize(32, 32))
self.pagelist.setSpacing(2)
for item in pageorder():
self.pagelist.addItem(item())
self.pagelist.currentItemChanged.connect(self.slotCurrentItemChanged)
app.translateUI(self, 100)
# read our size and selected page
qutil.saveDialogSize(self, "preferences/dialog/size", QSize(500, 300))
self.pagelist.setCurrentRow(_prefsindex)
def translateUI(self):
self.pagelist.setFixedWidth(self.pagelist.sizeHintForColumn(0) + 12)
self.setWindowTitle(app.caption(_("Preferences")))
def done(self, result):
if result and self.buttons.button(QDialogButtonBox.Apply).isEnabled():
self.saveSettings()
# save our size and selected page
global _prefsindex
_prefsindex = self.pagelist.currentRow()
super(PreferencesDialog, self).done(result)
def pages(self):
"""Yields the settings pages that are already instantiated."""
for n in range(self.stack.count()):
yield self.stack.widget(n)
def showHelp(self):
userguide.show(self.pagelist.currentItem().help)
def loadSettings(self):
"""Loads the settings on reset."""
for page in self.pages():
page.loadSettings()
page.hasChanges = False
self.buttons.button(QDialogButtonBox.Apply).setEnabled(False)
def saveSettings(self):
"""Saves the settings and applies them."""
for page in self.pages():
if page.hasChanges:
page.saveSettings()
page.hasChanges = False
self.buttons.button(QDialogButtonBox.Apply).setEnabled(False)
# emit the signal
app.settingsChanged()
def slotCurrentItemChanged(self, item):
item.activate()
def changed(self):
"""Call this to enable the Apply button."""
self.buttons.button(QDialogButtonBox.Apply).setEnabled(True)
class PathManager(QDialog):
def __init__(self,
parent=None,
pathlist=None,
ro_pathlist=None,
sync=True):
QDialog.__init__(self, parent)
# Destroying the C++ object right after closing the dialog box,
# otherwise it may be garbage-collected in another QThread
# (e.g. the editor's analysis thread in Spyder), thus leading to
# a segmentation fault on UNIX or an application crash on Windows
self.setAttribute(Qt.WA_DeleteOnClose)
assert isinstance(pathlist, list)
self.pathlist = pathlist
if ro_pathlist is None:
ro_pathlist = []
self.ro_pathlist = ro_pathlist
self.last_path = os.getcwdu()
self.setWindowTitle(_("PYTHONPATH manager"))
self.setWindowIcon(get_icon('pythonpath.png'))
self.resize(500, 300)
self.selection_widgets = []
layout = QVBoxLayout()
self.setLayout(layout)
top_layout = QHBoxLayout()
layout.addLayout(top_layout)
self.toolbar_widgets1 = self.setup_top_toolbar(top_layout)
self.listwidget = QListWidget(self)
self.connect(self.listwidget, SIGNAL("currentRowChanged(int)"),
self.refresh)
layout.addWidget(self.listwidget)
bottom_layout = QHBoxLayout()
layout.addLayout(bottom_layout)
self.sync_button = None
self.toolbar_widgets2 = self.setup_bottom_toolbar(bottom_layout, sync)
# Buttons configuration
bbox = QDialogButtonBox(QDialogButtonBox.Close)
self.connect(bbox, SIGNAL("rejected()"), SLOT("reject()"))
bottom_layout.addWidget(bbox)
self.update_list()
self.refresh()
def _add_widgets_to_layout(self, layout, widgets):
layout.setAlignment(Qt.AlignLeft)
for widget in widgets:
layout.addWidget(widget)
def setup_top_toolbar(self, layout):
toolbar = []
movetop_button = create_toolbutton(
self,
text=_("Move to top"),
icon=get_icon('2uparrow.png'),
triggered=lambda: self.move_to(absolute=0),
text_beside_icon=True)
toolbar.append(movetop_button)
moveup_button = create_toolbutton(
self,
text=_("Move up"),
icon=get_icon('1uparrow.png'),
triggered=lambda: self.move_to(relative=-1),
text_beside_icon=True)
toolbar.append(moveup_button)
movedown_button = create_toolbutton(
self,
text=_("Move down"),
icon=get_icon('1downarrow.png'),
triggered=lambda: self.move_to(relative=1),
text_beside_icon=True)
toolbar.append(movedown_button)
movebottom_button = create_toolbutton(
self,
text=_("Move to bottom"),
icon=get_icon('2downarrow.png'),
triggered=lambda: self.move_to(absolute=1),
text_beside_icon=True)
toolbar.append(movebottom_button)
self.selection_widgets.extend(toolbar)
self._add_widgets_to_layout(layout, toolbar)
return toolbar
def setup_bottom_toolbar(self, layout, sync=True):
toolbar = []
add_button = create_toolbutton(self,
text=_("Add path"),
icon=get_icon('edit_add.png'),
triggered=self.add_path,
text_beside_icon=True)
toolbar.append(add_button)
remove_button = create_toolbutton(self,
text=_("Remove path"),
icon=get_icon('edit_remove.png'),
triggered=self.remove_path,
text_beside_icon=True)
toolbar.append(remove_button)
self.selection_widgets.append(remove_button)
self._add_widgets_to_layout(layout, toolbar)
layout.addStretch(1)
if os.name == 'nt' and sync:
self.sync_button = create_toolbutton(
self,
text=_("Synchronize..."),
icon=get_icon('synchronize.png'),
triggered=self.synchronize,
tip=_("Synchronize Spyder's path list with PYTHONPATH "
"environment variable"),
text_beside_icon=True)
layout.addWidget(self.sync_button)
return toolbar
def synchronize(self):
"""
Synchronize Spyder's path list with PYTHONPATH environment variable
Only apply to: current user, on Windows platforms
"""
answer = QMessageBox.question(
self, _("Synchronize"),
_("This will synchronize Spyder's path list with "
"<b>PYTHONPATH</b> environment variable for current user, "
"allowing you to run your Python modules outside Spyder "
"without having to configure sys.path. "
"<br>Do you want to clear contents of PYTHONPATH before "
"adding Spyder's path list?"),
QMessageBox.Yes | QMessageBox.No | QMessageBox.Cancel)
if answer == QMessageBox.Cancel:
return
elif answer == QMessageBox.Yes:
remove = True
else:
remove = False
from SMlib.utils.environ import (get_user_env, set_user_env,
listdict2envdict)
env = get_user_env()
if remove:
ppath = self.pathlist + self.ro_pathlist
else:
ppath = env.get('PYTHONPATH', [])
if not isinstance(ppath, list):
ppath = [ppath]
ppath = [
path for path in ppath
if path not in (self.pathlist + self.ro_pathlist)
]
ppath.extend(self.pathlist + self.ro_pathlist)
env['PYTHONPATH'] = ppath
set_user_env(listdict2envdict(env), parent=self)
def get_path_list(self):
"""Return path list (does not include the read-only path list)"""
return self.pathlist
def update_list(self):
"""Update path list"""
self.listwidget.clear()
for name in self.pathlist + self.ro_pathlist:
item = QListWidgetItem(name)
item.setIcon(get_std_icon('DirClosedIcon'))
if name in self.ro_pathlist:
item.setFlags(Qt.NoItemFlags)
self.listwidget.addItem(item)
self.refresh()
def refresh(self, row=None):
"""Refresh widget"""
for widget in self.selection_widgets:
widget.setEnabled(self.listwidget.currentItem() is not None)
not_empty = self.listwidget.count() > 0
if self.sync_button is not None:
self.sync_button.setEnabled(not_empty)
def move_to(self, absolute=None, relative=None):
index = self.listwidget.currentRow()
if absolute is not None:
if absolute:
new_index = len(self.pathlist) - 1
else:
new_index = 0
else:
new_index = index + relative
new_index = max(0, min(len(self.pathlist) - 1, new_index))
path = self.pathlist.pop(index)
self.pathlist.insert(new_index, path)
self.update_list()
self.listwidget.setCurrentRow(new_index)
def remove_path(self):
answer = QMessageBox.warning(
self, _("Remove path"),
_("Do you really want to remove selected path?"),
QMessageBox.Yes | QMessageBox.No)
if answer == QMessageBox.Yes:
self.pathlist.pop(self.listwidget.currentRow())
self.update_list()
def add_path(self):
self.emit(SIGNAL('redirect_stdio(bool)'), False)
directory = getexistingdirectory(self, _("Select directory"),
self.last_path)
self.emit(SIGNAL('redirect_stdio(bool)'), True)
if directory:
directory = osp.abspath(directory)
self.last_path = directory
if directory in self.pathlist:
answer = QMessageBox.question(
self, _("Add path"),
_("This directory is already included in Spyder path "
"list.<br>Do you want to move it to the top of "
"the list?"), QMessageBox.Yes | QMessageBox.No)
if answer == QMessageBox.Yes:
self.pathlist.remove(directory)
else:
return
self.pathlist.insert(0, directory)
self.update_list()
class FiltersDialog(Window):
def __init__(self, base):
Window.__init__(self, base, i18n.get('filters'))
self.setFixedSize(280, 360)
self.expression = QLineEdit()
self.expression.returnPressed.connect(self.__new_filter)
self.new_button = QPushButton(i18n.get('add_filter'))
self.new_button.setToolTip(i18n.get('create_a_new_filter'))
self.new_button.clicked.connect(self.__new_filter)
expression_box = QHBoxLayout()
expression_box.addWidget(self.expression)
expression_box.addWidget(self.new_button)
self.list_ = QListWidget()
self.list_.clicked.connect(self.__filter_clicked)
self.delete_button = QPushButton(i18n.get('delete'))
self.delete_button.setEnabled(False)
self.delete_button.setToolTip(i18n.get('delete_selected_filter'))
self.delete_button.clicked.connect(self.__delete_filter)
self.clear_button = QPushButton(i18n.get('delete_all'))
self.clear_button.setEnabled(False)
self.clear_button.setToolTip(i18n.get('delete_all_filters'))
self.clear_button.clicked.connect(self.__delete_all)
button_box = QHBoxLayout()
button_box.addStretch(1)
button_box.addWidget(self.clear_button)
button_box.addWidget(self.delete_button)
layout = QVBoxLayout()
layout.addLayout(expression_box)
layout.addWidget(self.list_, 1)
layout.addLayout(button_box)
layout.setSpacing(5)
layout.setContentsMargins(5, 5, 5, 5)
self.setLayout(layout)
self.__update()
self.show()
def __update(self):
row = 0
self.expression.setText('')
self.list_.clear()
for expression in self.base.core.list_filters():
self.list_.addItem(expression)
row += 1
self.__enable(True)
self.delete_button.setEnabled(False)
if row == 0:
self.clear_button.setEnabled(False)
self.expression.setFocus()
def __filter_clicked(self, point):
self.delete_button.setEnabled(True)
self.clear_button.setEnabled(True)
def __new_filter(self):
expression = str(self.expression.text())
self.list_.addItem(expression)
self.__save_filters()
def __delete_filter(self):
self.list_.takeItem(self.list_.currentRow())
self.__save_filters()
def __delete_all(self):
self.__enable(False)
message = i18n.get('clear_filters_confirm')
confirmation = self.base.show_confirmation_message(
i18n.get('confirm_delete'), message)
if not confirmation:
self.__enable(True)
return
self.list_.clear()
self.__save_filters()
def __enable(self, value):
self.list_.setEnabled(value)
self.delete_button.setEnabled(value)
self.clear_button.setEnabled(value)
def __save_filters(self):
filters = []
for i in range(self.list_.count()):
filters.append(str(self.list_.item(i).text()))
self.base.save_filters(filters)
self.__update()
class LateralWidget(QDockWidget):
def __init__(self):
super(LateralWidget, self).__init__()
self._list_widget = QListWidget()
self.setWidget(self._list_widget)
Pireal.load_service("lateral", self)
self._list_widget.setContextMenuPolicy(Qt.CustomContextMenu)
self.connect(self._list_widget, SIGNAL("currentRowChanged(int)"),
self._change_item)
self.connect(self._list_widget,
SIGNAL("customContextMenuRequested(const QPoint)"),
self.__show_context_menu)
def __show_context_menu(self, point):
""" Context menu """
menu = QMenu()
remove_table_act = menu.addAction(QIcon(":img/remove-rel"),
self.tr("Eliminar Relación"))
self.connect(remove_table_act, SIGNAL("triggered()"),
self.remove_table)
menu.exec_(self.mapToGlobal(point))
def _change_item(self, index):
table = Pireal.get_service("container").table_widget
table.stacked.setCurrentIndex(index)
def add_item_list(self, items):
if not self.isVisible():
self.show()
for i in items:
item = QListWidgetItem(i)
item.setTextAlignment(Qt.AlignHCenter)
self._list_widget.addItem(item)
def remove_table(self):
container = Pireal.get_service("container")
container.remove_relation()
def clear_items(self):
""" Remove all items and selections in the view """
self._list_widget.clear()
def get_relation_name(self):
""" Returns the text of the item """
item = self._list_widget.currentItem()
if item is None:
return False
return item.text()
def current_index(self):
""" Returns the current index """
return self._list_widget.currentRow()
def remove_item(self, index):
""" Removes the item from the given index in the list widget"""
self._list_widget.takeItem(index)
class SessionsManager(QDialog):
"""Session Manager, to load different configurations of ninja."""
def __init__(self, parent=None):
super(SessionsManager, self).__init__(parent, Qt.Dialog)
self._ide = parent
self.setWindowTitle(translations.TR_SESSIONS_TITLE)
self.setMinimumWidth(400)
vbox = QVBoxLayout(self)
vbox.addWidget(QLabel(translations.TR_SESSIONS_DIALOG_BODY))
self.sessionList = QListWidget()
self.sessionList.addItems([key for key in settings.SESSIONS])
self.sessionList.setCurrentRow(0)
self.contentList = QListWidget()
self.btnDelete = QPushButton(translations.TR_SESSIONS_BTN_DELETE)
self.btnDelete.setSizePolicy(QSizePolicy.Fixed, QSizePolicy.Fixed)
self.btnUpdate = QPushButton(translations.TR_SESSIONS_BTN_UPDATE)
self.btnUpdate.setSizePolicy(QSizePolicy.Fixed, QSizePolicy.Fixed)
self.btnCreate = QPushButton(translations.TR_SESSIONS_BTN_CREATE)
self.btnCreate.setSizePolicy(QSizePolicy.Fixed, QSizePolicy.Fixed)
self.btnOpen = QPushButton(translations.TR_SESSIONS_BTN_ACTIVATE)
self.btnOpen.setSizePolicy(QSizePolicy.Fixed, QSizePolicy.Fixed)
self.btnOpen.setDefault(True)
hbox = QHBoxLayout()
hbox.addWidget(self.btnDelete)
hbox.addWidget(self.btnUpdate)
hbox.addWidget(self.btnCreate)
hbox.addWidget(self.btnOpen)
vbox.addWidget(self.sessionList)
vbox.addWidget(self.contentList)
vbox.addLayout(hbox)
self.connect(self.sessionList, SIGNAL("itemSelectionChanged()"), self.load_session_content)
self.connect(self.btnOpen, SIGNAL("clicked()"), self.open_session)
self.connect(self.btnUpdate, SIGNAL("clicked()"), self.save_session)
self.connect(self.btnCreate, SIGNAL("clicked()"), self.create_session)
self.connect(self.btnDelete, SIGNAL("clicked()"), self.delete_session)
self.load_session_content()
def load_session_content(self):
"""Load the selected session, replacing the current session."""
item = self.sessionList.currentItem()
self.contentList.clear()
if item is not None:
key = item.text()
files = [translations.TR_FILES] + [file[0] for file in settings.SESSIONS[key][0]]
projects = [translations.TR_PROJECT] + settings.SESSIONS[key][1]
content = files + projects
self.contentList.addItems(content)
def create_session(self):
"""Create a new Session."""
sessionInfo = QInputDialog.getText(
None, translations.TR_SESSIONS_CREATE_TITLE, translations.TR_SESSIONS_CREATE_BODY
)
if sessionInfo[1]:
sessionName = sessionInfo[0]
if not sessionName or sessionName in settings.SESSIONS:
QMessageBox.information(
self, translations.TR_SESSIONS_MESSAGE_TITLE, translations.TR_SESSIONS_MESSAGE_BODY
)
return
SessionsManager.save_session_data(sessionName, self._ide)
self._ide.Session = sessionName
self.close()
@classmethod
def save_session_data(cls, sessionName, ide):
"""Save the updates from a session."""
openedFiles = ide.filesystem.get_files()
files_info = []
for path in openedFiles:
editable = ide.get_or_create_editable(path)
if editable.is_dirty:
stat_value = 0
else:
stat_value = os.stat(path).st_mtime
files_info.append([path, editable.editor.getCursorPosition(), stat_value])
projects_obj = ide.filesystem.get_projects()
projects = [projects_obj[proj].path for proj in projects_obj]
settings.SESSIONS[sessionName] = [files_info, projects]
qsettings = ide.data_settings()
qsettings.setValue("ide/sessions", settings.SESSIONS)
def save_session(self):
"""Save current session"""
if self.sessionList.currentItem():
sessionName = self.sessionList.currentItem().text()
SessionsManager.save_session_data(sessionName, self._ide)
self._ide.show_message(translations.TR_SESSIONS_UPDATED_NOTIF % {"session": sessionName}, 2000)
self.load_session_content()
def open_session(self):
"""Open a saved session"""
if self.sessionList.currentItem():
key = self.sessionList.currentItem().text()
self._load_session_data(key)
self._ide.Session = key
self.close()
def delete_session(self):
"""Delete a session"""
if self.sessionList.currentItem():
key = self.sessionList.currentItem().text()
settings.SESSIONS.pop(key)
self.sessionList.takeItem(self.sessionList.currentRow())
self.contentList.clear()
qsettings = self._ide.data_settings()
qsettings.setValue("ide/sessions", settings.SESSIONS)
def _load_session_data(self, key):
"""Activate the selected session, closing the current files/projects"""
main_container = self._ide.get_service("main_container")
projects_explorer = self._ide.get_service("projects_explorer")
if projects_explorer and main_container:
projects_explorer.close_opened_projects()
for fileData in settings.SESSIONS[key][0]:
path, line, stat_value = fileData
if file_manager.file_exists(path):
mtime = os.stat(path).st_mtime
ignore_checkers = mtime == stat_value
main_container.open_file(path, line, ignore_checkers=ignore_checkers)
if projects_explorer:
projects_explorer.load_session_projects(settings.SESSIONS[key][1])
class EditorGeneral(QWidget):
"""EditorGeneral widget class."""
def __init__(self, parent):
super(EditorGeneral, self).__init__()
self._preferences, vbox = parent, QVBoxLayout(self)
self.original_style = copy.copy(resources.CUSTOM_SCHEME)
self.current_scheme, self._modified_editors = 'default', []
self._font = settings.FONT
groupBoxMini = QGroupBox(
translations.TR_PREFERENCES_EDITOR_GENERAL_MINIMAP)
groupBoxTypo = QGroupBox(
translations.TR_PREFERENCES_EDITOR_GENERAL_TYPOGRAPHY)
groupBoxScheme = QGroupBox(
translations.TR_PREFERENCES_EDITOR_GENERAL_SCHEME)
#Minimap
formMini = QGridLayout(groupBoxMini)
formMini.setContentsMargins(5, 15, 5, 5)
self._checkShowMinimap = QCheckBox(
translations.TR_PREFERENCES_EDITOR_GENERAL_ENABLE_MINIMAP)
self._spinMaxOpacity = QSpinBox()
self._spinMaxOpacity.setRange(0, 100)
self._spinMaxOpacity.setSuffix("% Max.")
self._spinMinOpacity = QSpinBox()
self._spinMinOpacity.setRange(0, 100)
self._spinMinOpacity.setSuffix("% Min.")
self._spinSize = QSpinBox()
self._spinSize.setMaximum(100)
self._spinSize.setMinimum(0)
self._spinSize.setSuffix(
translations.TR_PREFERENCES_EDITOR_GENERAL_AREA_MINIMAP)
formMini.addWidget(self._checkShowMinimap, 0, 1)
formMini.addWidget(QLabel(
translations.TR_PREFERENCES_EDITOR_GENERAL_SIZE_MINIMAP), 1, 0,
Qt.AlignRight)
formMini.addWidget(self._spinSize, 1, 1)
formMini.addWidget(QLabel(
translations.TR_PREFERENCES_EDITOR_GENERAL_OPACITY), 2, 0,
Qt.AlignRight)
formMini.addWidget(self._spinMinOpacity, 2, 1)
formMini.addWidget(self._spinMaxOpacity, 2, 2)
#Typo
gridTypo = QGridLayout(groupBoxTypo)
gridTypo.setContentsMargins(5, 15, 5, 5)
self._btnEditorFont = QPushButton('')
gridTypo.addWidget(QLabel(
translations.TR_PREFERENCES_EDITOR_GENERAL_EDITOR_FONT), 0, 0,
Qt.AlignRight)
gridTypo.addWidget(self._btnEditorFont, 0, 1)
#Scheme
vboxScheme = QVBoxLayout(groupBoxScheme)
vboxScheme.setContentsMargins(5, 15, 5, 5)
self._listScheme = QListWidget()
vboxScheme.addWidget(self._listScheme)
hbox = QHBoxLayout()
btnDownload = QPushButton(
translations.TR_PREFERENCES_EDITOR_DOWNLOAD_SCHEME)
btnDownload.setSizePolicy(QSizePolicy.Fixed, QSizePolicy.Fixed)
self.connect(btnDownload, SIGNAL("clicked()"),
self._open_schemes_manager)
hbox.addWidget(btnDownload)
btnAdd = QPushButton(QIcon(":img/add"),
translations.TR_EDITOR_CREATE_SCHEME)
btnAdd.setIconSize(QSize(16, 16))
btnAdd.setSizePolicy(QSizePolicy.Fixed, QSizePolicy.Fixed)
self.connect(btnAdd, SIGNAL("clicked()"), self._open_schemes_designer)
btnRemove = QPushButton(QIcon(":img/delete"),
translations.TR_EDITOR_REMOVE_SCHEME)
btnRemove.setIconSize(QSize(16, 16))
btnRemove.setSizePolicy(QSizePolicy.Fixed, QSizePolicy.Fixed)
self.connect(btnRemove, SIGNAL("clicked()"), self._remove_scheme)
hbox.addSpacerItem(QSpacerItem(1, 0, QSizePolicy.Expanding))
hbox.addWidget(btnAdd)
hbox.addWidget(btnRemove)
vboxScheme.addLayout(hbox)
vbox.addWidget(groupBoxMini)
vbox.addWidget(groupBoxTypo)
vbox.addWidget(groupBoxScheme)
#Settings
qsettings = IDE.ninja_settings()
qsettings.beginGroup('preferences')
qsettings.beginGroup('editor')
self._checkShowMinimap.setChecked(settings.SHOW_MINIMAP)
if settings.IS_MAC_OS:
self._spinMinOpacity.setValue(100)
self._spinMaxOpacity.setValue(100)
self._spinMinOpacity.setDisabled(True)
self._spinMaxOpacity.setDisabled(True)
else:
self._spinMinOpacity.setValue(settings.MINIMAP_MIN_OPACITY * 100)
self._spinMaxOpacity.setValue(settings.MINIMAP_MAX_OPACITY * 100)
self._spinSize.setValue(settings.SIZE_PROPORTION * 100)
btnText = ', '.join(self._font.toString().split(',')[0:2])
self._btnEditorFont.setText(btnText)
self._listScheme.clear()
self._listScheme.addItem('default')
self._schemes = json_manager.load_editor_skins()
for item in self._schemes:
self._listScheme.addItem(item)
items = self._listScheme.findItems(
qsettings.value('scheme', defaultValue='',
type='QString'), Qt.MatchExactly)
if items:
self._listScheme.setCurrentItem(items[0])
else:
self._listScheme.setCurrentRow(0)
qsettings.endGroup()
qsettings.endGroup()
#Signals
self.connect(self._btnEditorFont,
SIGNAL("clicked()"), self._load_editor_font)
self.connect(self._listScheme, SIGNAL("itemSelectionChanged()"),
self._preview_style)
self.connect(self._preferences, SIGNAL("savePreferences()"), self.save)
def _open_schemes_manager(self):
ninjaide = IDE.get_service("ide")
ninjaide.show_schemes()
# refresh schemes
def _open_schemes_designer(self):
name = self._listScheme.currentItem().text()
scheme = self._schemes.get(name, resources.COLOR_SCHEME)
designer = preferences_editor_scheme_designer.EditorSchemeDesigner(
scheme, self)
designer.exec_()
if designer.saved:
scheme_name = designer.line_name.text()
scheme = designer.original_style
self._schemes[scheme_name] = scheme
result = self._listScheme.findItems(scheme_name, Qt.MatchExactly)
if not result:
self._listScheme.addItem(scheme_name)
def _remove_scheme(self):
name = self._listScheme.currentItem().text()
fileName = ('{0}.color'.format(
file_manager.create_path(resources.EDITOR_SKINS, name)))
file_manager.delete_file(fileName)
item = self._listScheme.takeItem(self._listScheme.currentRow())
del item
def hideEvent(self, event):
super(EditorGeneral, self).hideEvent(event)
resources.CUSTOM_SCHEME = self.original_style
for editorWidget in self._modified_editors:
try:
editorWidget.restyle(editorWidget.lang)
except RuntimeError:
print('the editor has been removed')
def _preview_style(self):
scheme = self._listScheme.currentItem().text()
if scheme == self.current_scheme:
return
main_container = IDE.get_service('main_container')
if not main_container:
return
editorWidget = main_container.get_current_editor()
if editorWidget is not None:
resources.CUSTOM_SCHEME = self._schemes.get(
scheme,
resources.COLOR_SCHEME)
editorWidget.restyle(editorWidget.lang)
self._modified_editors.append(editorWidget)
self.current_scheme = scheme
def _load_editor_font(self):
try:
font, ok = QFontDialog.getFont(self._font, self)
if ok:
self._font = font
btnText = ', '.join(self._font.toString().split(',')[0:2])
self._btnEditorFont.setText(btnText)
except:
QMessageBox.warning(
self,
translations.TR_PREFERENCES_EDITOR_GENERAL_FONT_MESSAGE_TITLE,
translations.TR_PREFERENCES_EDITOR_GENERAL_FONT_MESSAGE_BODY)
def save(self):
qsettings = IDE.ninja_settings()
settings.FONT = self._font
qsettings.setValue('preferences/editor/font', settings.FONT)
settings.SHOW_MINIMAP = self._checkShowMinimap.isChecked()
settings.MINIMAP_MAX_OPACITY = self._spinMaxOpacity.value() / 100.0
settings.MINIMAP_MIN_OPACITY = self._spinMinOpacity.value() / 100.0
settings.SIZE_PROPORTION = self._spinSize.value() / 100.0
qsettings.setValue('preferences/editor/minimapMaxOpacity',
settings.MINIMAP_MAX_OPACITY)
qsettings.setValue('preferences/editor/minimapMinOpacity',
settings.MINIMAP_MIN_OPACITY)
qsettings.setValue('preferences/editor/minimapSizeProportion',
settings.SIZE_PROPORTION)
qsettings.setValue('preferences/editor/minimapShow',
settings.SHOW_MINIMAP)
scheme = self._listScheme.currentItem().text()
resources.CUSTOM_SCHEME = self._schemes.get(scheme,
resources.COLOR_SCHEME)
qsettings.setValue('preferences/editor/scheme', scheme)
class NotebookListDialog(QDialog):
""" Funtions to display, create, remove, modify notebookList """
def __init__(self, parent=None):
super(NotebookListDialog, self).__init__(parent)
self.notebookList = QListWidget()
self.moveUp = QPushButton('<<')
self.moveDown = QPushButton('>>')
self.add = QPushButton('Add')
self.remove = QPushButton('Remove')
self.buttonBox = QDialogButtonBox(QDialogButtonBox.Ok |
QDialogButtonBox.Cancel)
self.buttonBox.button(QDialogButtonBox.Ok).setEnabled(False)
layout = QGridLayout()
layout.addWidget(self.notebookList, 0, 0, 4, 6)
layout.addWidget(self.moveUp, 1, 6)
layout.addWidget(self.moveDown, 2, 6)
layout.addWidget(self.add, 4, 0)
layout.addWidget(self.remove, 4, 1)
layout.addWidget(self.buttonBox, 4, 5, 1, 2)
self.setLayout(layout)
self.notebookList.setItemDelegate(ListDelegate(self.notebookList))
self.notebookList.currentRowChanged.connect(self.updateUi)
self.add.clicked.connect(self.actionAdd)
self.remove.clicked.connect(self.actionRemove)
self.moveUp.clicked.connect(self.moveItemUp)
self.moveDown.clicked.connect(self.moveItemDown)
self.buttonBox.accepted.connect(self.accept)
self.buttonBox.rejected.connect(self.reject)
self.initList()
def initList(self):
self.notebookList.clear()
notebooks = Mikibook.read()
for nb in notebooks:
item = QListWidgetItem()
item.setData(Qt.DisplayRole, nb[0])
item.setData(Qt.UserRole, nb[1])
self.notebookList.addItem(item)
self.updateUi(len(notebooks) != 0)
self.notebookList.setCurrentRow(0)
# QListWidgetItem(nb, self.notebookList)
def updateUi(self, row):
flag = (row != -1)
self.buttonBox.button(QDialogButtonBox.Ok).setEnabled(flag)
self.remove.setEnabled(flag)
self.moveUp.setEnabled(flag)
self.moveDown.setEnabled(flag)
def actionAdd(self):
Mikibook.create()
self.initList()
count = self.notebookList.count()
self.notebookList.setCurrentRow(count-1)
def actionRemove(self):
item = self.notebookList.currentItem()
row = self.notebookList.currentRow()
name = item.data(Qt.DisplayRole)
path = item.data(Qt.UserRole)
self.notebookList.takeItem(row)
Mikibook.remove(name, path)
def moveItemUp(self):
item = self.notebookList.currentItem()
row = self.notebookList.currentRow()
if row != 0:
# self.notebookList.removeItemWidget(item)
self.notebookList.takeItem(row)
self.notebookList.insertItem(row-1, item)
self.notebookList.setCurrentRow(row-1)
def moveItemDown(self):
item = self.notebookList.currentItem()
row = self.notebookList.currentRow()
count = self.notebookList.count()
if row != count-1:
self.notebookList.takeItem(row)
self.notebookList.insertItem(row+1, item)
self.notebookList.setCurrentRow(row+1)
def accept(self):
notebookPath = self.notebookList.currentItem().data(Qt.UserRole)
notebookName = self.notebookList.currentItem().data(Qt.DisplayRole)
settings = Setting([[notebookName, notebookPath]])
window = mikidown.MikiWindow(settings)
window.show()
count = self.notebookList.count()
notebooks = []
for i in range(count):
name = self.notebookList.item(i).data(Qt.DisplayRole)
path = self.notebookList.item(i).data(Qt.UserRole)
notebooks.append([name, path])
Mikibook.write(notebooks)
QDialog.accept(self)
class Theme(QWidget):
"""Theme widget class."""
def __init__(self, parent):
super(Theme, self).__init__()
self._preferences, vbox = parent, QVBoxLayout(self)
vbox.addWidget(QLabel(self.tr("<b>Select Theme:</b>")))
self.list_skins = QListWidget()
self.list_skins.setSelectionMode(QListWidget.SingleSelection)
vbox.addWidget(self.list_skins)
self.btn_delete = QPushButton(self.tr("Delete Theme"))
self.btn_preview = QPushButton(self.tr("Preview Theme"))
self.btn_create = QPushButton(self.tr("Create Theme"))
hbox = QHBoxLayout()
hbox.addWidget(self.btn_delete)
hbox.addSpacerItem(QSpacerItem(10, 0, QSizePolicy.Expanding,
QSizePolicy.Fixed))
hbox.addWidget(self.btn_preview)
hbox.addWidget(self.btn_create)
vbox.addLayout(hbox)
self._refresh_list()
self.connect(self.btn_preview, SIGNAL("clicked()"), self.preview_theme)
self.connect(self.btn_delete, SIGNAL("clicked()"), self.delete_theme)
self.connect(self.btn_create, SIGNAL("clicked()"), self.create_theme)
self.connect(self._preferences, SIGNAL("savePreferences()"), self.save)
def delete_theme(self):
if self.list_skins.currentRow() != 0:
file_name = ("%s.qss" % self.list_skins.currentItem().text())
qss_file = file_manager.create_path(resources.NINJA_THEME_DOWNLOAD,
file_name)
file_manager.delete_file(qss_file)
self._refresh_list()
def create_theme(self):
designer = preferences_theme_editor.ThemeEditor(self)
designer.exec_()
self._refresh_list()
def showEvent(self, event):
self._refresh_list()
super(Theme, self).showEvent(event)
def _refresh_list(self):
self.list_skins.clear()
self.list_skins.addItem("Default")
files = [file_manager.get_file_name(filename) for filename in
file_manager.get_files_from_folder(
resources.NINJA_THEME_DOWNLOAD, "qss")]
files.sort()
self.list_skins.addItems(files)
if settings.NINJA_SKIN in files:
index = files.index(settings.NINJA_SKIN)
self.list_skins.setCurrentRow(index + 1)
else:
self.list_skins.setCurrentRow(0)
def save(self):
qsettings = IDE.ninja_settings()
settings.NINJA_SKIN = self.list_skins.currentItem().text()
qsettings.setValue("preferences/theme/skin", settings.NINJA_SKIN)
self.preview_theme()
def preview_theme(self):
if self.list_skins.currentRow() == 0:
qss_file = resources.NINJA_THEME
else:
file_name = ("%s.qss" % self.list_skins.currentItem().text())
qss_file = file_manager.create_path(resources.NINJA_THEME_DOWNLOAD,
file_name)
with open(qss_file) as f:
qss = f.read()
QApplication.instance().setStyleSheet(qss)
class CodeCompletionWidget(QFrame):
def __init__(self, editor):
super(CodeCompletionWidget, self).__init__(None, Qt.FramelessWindowHint | Qt.ToolTip)
self._editor = editor
self.stack_layout = QStackedLayout(self)
self.stack_layout.setContentsMargins(0, 0, 0, 0)
self.stack_layout.setSpacing(0)
self.completion_list = QListWidget()
self.completion_list.setMinimumHeight(200)
self.completion_list.setAlternatingRowColors(True)
self._list_index = self.stack_layout.addWidget(self.completion_list)
self._icons = {
"a": resources.IMAGES["attribute"],
"f": resources.IMAGES["function"],
"c": resources.IMAGES["class"],
}
self.cc = code_completion.CodeCompletion()
self._completion_results = []
self._prefix = u""
self.setVisible(False)
self.source = ""
self._key_operations = {
Qt.Key_Up: self._select_previous_row,
Qt.Key_Down: self._select_next_row,
Qt.Key_PageUp: (lambda: self._select_previous_row(6)),
Qt.Key_PageDown: (lambda: self._select_next_row(6)),
Qt.Key_Right: lambda: None,
Qt.Key_Left: lambda: None,
Qt.Key_Enter: self.pre_key_insert_completion,
Qt.Key_Return: self.pre_key_insert_completion,
Qt.Key_Tab: self.pre_key_insert_completion,
Qt.Key_Space: self.hide_completer,
Qt.Key_Escape: self.hide_completer,
Qt.Key_Backtab: self.hide_completer,
Qt.NoModifier: self.hide_completer,
Qt.ShiftModifier: self.hide_completer,
}
desktop = QApplication.instance().desktop()
self._desktop_geometry = desktop.availableGeometry()
self.connect(self._editor.document(), SIGNAL("blockCountChanged(int)"), self.update_metadata)
def _select_next_row(self, move=1):
new_row = self.completion_list.currentRow() + move
if new_row < self.completion_list.count():
self.completion_list.setCurrentRow(new_row)
else:
self.completion_list.setCurrentRow(0)
return True
def _select_previous_row(self, move=1):
new_row = self.completion_list.currentRow() - move
if new_row >= 0:
self.completion_list.setCurrentRow(new_row)
else:
self.completion_list.setCurrentRow(self.completion_list.count() - move)
return True
def update_metadata(self):
source = self._editor.get_text()
source = source.encode(self._editor.encoding)
self.cc.analyze_file("", source)
def insert_completion(self, insert):
if insert != self._prefix:
extra = len(self._prefix) - len(insert)
self._editor.textCursor().insertText(insert[extra:])
self.hide_completer()
def _get_geometry(self):
cr = self._editor.cursorRect()
point = self._editor.mapToGlobal(cr.topLeft())
cr.moveTopLeft(point)
# Check new position according desktop geometry
width = (
self.completion_list.sizeHintForColumn(0) + self.completion_list.verticalScrollBar().sizeHint().width() + 10
)
height = 200
orientation = (point.y() + height) < self._desktop_geometry.height()
if orientation:
cr.moveTop(cr.bottom())
cr.setWidth(width)
cr.setHeight(height)
if not orientation:
cr.moveBottom(cr.top())
xpos = self._desktop_geometry.width() - (point.x() + width)
if xpos < 0:
cr.moveLeft(cr.left() + xpos)
return cr
def complete(self, results):
self.add_list_items(results)
self.completion_list.setCurrentRow(0)
cr = self._get_geometry()
self.setGeometry(cr)
self.completion_list.updateGeometries()
self.show()
def add_list_items(self, proposals):
self.completion_list.clear()
for p in proposals:
self.completion_list.addItem(
QListWidgetItem(QIcon(self._icons.get(p[0], resources.IMAGES["attribute"])), p[1])
)
def set_completion_prefix(self, prefix):
self._prefix = prefix
proposals = []
proposals += [("c", item) for item in self.completion_results.get("classes", []) if item.startswith(prefix)]
proposals += [("a", item) for item in self.completion_results.get("attributes", []) if item.startswith(prefix)]
proposals += [("f", item) for item in self.completion_results.get("functions", []) if item.startswith(prefix)]
if proposals:
self.complete(proposals)
else:
self.hide_completer()
def fill_completer(self):
source = self._editor.get_text()
source = source.encode(self._editor.encoding)
offset = self._editor.textCursor().position()
results = self.cc.get_completion(source, offset)
self.completion_results = results
prefix = self._editor._text_under_cursor()
self.set_completion_prefix(prefix)
def hide_completer(self):
self._prefix = ""
self.hide()
def pre_key_insert_completion(self):
insert = unicode(self.completion_list.currentItem().text())
self.insert_completion(insert)
self.hide_completer()
return True
def process_pre_key_event(self, event):
if not self.isVisible():
return False
skip = self._key_operations.get(event.key(), lambda: False)()
self._key_operations.get(event.modifiers(), lambda: False)()
if skip is None:
skip = False
return skip
def process_post_key_event(self, event):
if not settings.CODE_COMPLETION or self._editor.lang != "python":
return
if self.isVisible():
source = self._editor.get_text()
source = source.encode(self._editor.encoding)
offset = self._editor.textCursor().position()
prefix = self.cc.get_prefix(source, offset)
self.set_completion_prefix(prefix)
self.completion_list.setCurrentRow(0)
if event.key() == Qt.Key_Period or (event.key() == Qt.Key_Space and event.modifiers() == Qt.ControlModifier):
self.fill_completer()
class BookView(QSplitter):
def __init__(self, parent=None):
super(BookView, self).__init__(parent=parent)
self.create_layout()
self.create_connections()
def create_layout(self):
self.web_view = QWebView()
self.chapter_list = QListWidget()
self.next_button = QPushButton("Next chapter")
self.previous_button = QPushButton("Previous chapter")
hbox = QHBoxLayout()
hbox.addStretch()
hbox.addWidget(self.previous_button)
hbox.addWidget(self.next_button)
vbox = QVBoxLayout()
vbox.addWidget(QLabel("Chapters"))
vbox.addWidget(self.chapter_list)
vbox.addLayout(hbox)
widget = QWidget()
widget.setLayout(vbox)
self.addWidget(self.web_view)
self.addWidget(widget)
def create_connections(self):
chlist = self.chapter_list
self.connect(self.next_button, SIGNAL("clicked()"), lambda:
chlist.setCurrentRow(0
if chlist.currentRow() == chlist.count() - 1
else chlist.currentRow() + 1))
self.connect(self.previous_button, SIGNAL("clicked()"), lambda:
chlist.setCurrentRow(chlist.count() - 1
if chlist.currentRow() == 0
else chlist.currentRow() - 1))
self.connect(self.chapter_list, SIGNAL("currentRowChanged(int)"),
self.set_chapter)
page = self.web_view.page()
page.setLinkDelegationPolicy(QWebPage.DelegateAllLinks)
self.connect(page, SIGNAL("linkClicked(const QUrl&)"),
self.link_clicked)
def load_book(self, book_id):
self.book = Book(book_id)
self.chapter_list.clear()
for chapter in self.book.chapters:
self.chapter_list.addItem(chapter[0])
self.chapter_list.setCurrentRow(0)
def set_chapter(self, num=None):
if num is None:
num = self.chapter_list.currentRow()
if num < 0:
num = len(self.book.chapters) - 1
elif num >= len(self.book.chapters):
num = 0
self.web_view.setHtml(self.book.get_chapter(num))
def link_clicked(self, url):
surl = str(url.toString())
if surl.endswith('.epub'):
progress = QProgressDialog("Downloding the book...", "Abort", 0, -1,
self)
progress.show()
book_id = FeedBooks().download(surl[:-5])
progress.close()
if not book_id:
QMessageBox.critical(self, 'Error', 'Could not download the '
'book')
elif book_id != -1:
book = Book(book_id)
insert_library(book)
self.parent().library.refresh()
else:
book_id = surl[surl.rfind('/')+1:-5]
if book_id:
self.load_book(book_id)
else:
webbrowser.open_new_tab(surl)
class AnnotationManager:
def __init__(self, iface):
locale = QSettings().value('locale/userLocale')[0:2]
locale_path = os.path.join(os.path.dirname(__file__), 'i18n',
'annotationManager_{}.qm'.format(locale))
self.translator = None
if os.path.exists(locale_path):
self.translator = QTranslator()
self.translator.load(locale_path)
QCoreApplication.installTranslator(self.translator)
self.iface = iface
self.iface.projectRead.connect(self.projectOpen)
self.dock = QDockWidget(self.tr('Annotations manager'))
self.manager = QWidget()
toolbar = QToolBar()
self.annotationList = QListWidget()
self.annotationList.itemClicked.connect(self.selectAnnotation)
self.annotationList.itemChanged.connect(self.checkItem)
action_refresh = QAction(
QIcon(':/plugins/annotationManager/resources/mActionDraw.png'),
self.tr('Refresh the annotations list'), self.manager)
action_refresh.triggered.connect(self.refreshAnnotations)
action_remove = QAction(
QIcon(
':/plugins/annotationManager/resources/mActionRemoveAnnotation.png'
), self.tr('Remove the selected annotation'), self.manager)
action_remove.triggered.connect(self.removeAnnotation)
toolbar.addAction(action_refresh)
toolbar.addAction(action_remove)
toolbar.setIconSize(QSize(16, 16))
p1_vertical = QVBoxLayout()
p1_vertical.setContentsMargins(0, 0, 0, 0)
p1_vertical.addWidget(toolbar)
p1_vertical.addWidget(self.annotationList)
self.manager.setLayout(p1_vertical)
self.dock.setWidget(self.manager)
self.dock.setAllowedAreas(Qt.LeftDockWidgetArea
| Qt.RightDockWidgetArea)
self.iface.addDockWidget(Qt.LeftDockWidgetArea, self.dock)
self.rb = QgsRubberBand(self.iface.mapCanvas(), QGis.Polygon)
self.annotations = []
self.annotationsName = []
def checkItem(self, item):
row = self.annotationList.row(item)
self.annotationsName[row] = item.text()
if item.checkState() == Qt.Checked:
self.annotations[row].show()
else:
self.annotations[row].hide()
if item.isSelected():
item.setSelected(False)
self.rb.reset()
def selectAnnotation(self):
index = self.annotationList.currentRow()
self.rb.reset()
self.rb.setColor(QColor(0, 0, 255, 128))
mapTool = QgsMapTool(self.iface.mapCanvas())
point = self.annotations[index].pos().toPoint()
pt1 = mapTool.toMapCoordinates(QPoint(point.x() - 10, point.y() - 10))
pt2 = mapTool.toMapCoordinates(QPoint(point.x() + 10, point.y() + 10))
rect = QgsRectangle(pt1, pt2)
poly = QgsGeometry().fromRect(rect)
self.rb.setToGeometry(poly, None)
def unload(self):
del self.dock
def tr(self, message):
return QCoreApplication.translate('AnnotationManager', message)
def getAnnotations(self):
annotations = []
items = self.iface.mapCanvas().items()
for item in items:
if item.data(0) == 'AnnotationItem':
annotations.append(item)
return annotations
def refreshAnnotations(self):
for annotation in self.getAnnotations():
if annotation not in self.annotations:
self.annotations.append(annotation)
self.annotationsName.append('Annotation')
i = 0
to_del = []
for annotation in self.annotations:
if annotation not in self.getAnnotations():
to_del.append(i)
i += 1
i = 0
for index in to_del:
self.annotations.pop(index)
self.annotationsName.pop(index)
self.annotationList.clearSelection()
self.annotationList.clear()
# argh
for annotation in self.annotations:
item = QListWidgetItem(self.annotationsName[i])
if annotation.isVisible():
item.setCheckState(Qt.Checked)
else:
item.setCheckState(Qt.Unchecked)
item.setFlags(item.flags() | Qt.ItemIsEditable)
self.annotationList.addItem(item)
i += 1
# fin argh
def removeAnnotation(self):
if len(self.annotationList.selectedItems()) > 0:
index = self.annotationList.currentRow()
self.annotationList.takeItem(index)
self.annotationList.clearSelection()
self.annotationList.clearFocus()
self.iface.mapCanvas().scene().removeItem(self.annotations[index])
self.annotations.pop(index)
self.annotationsName.pop(index)
self.rb.reset()
def projectOpen(self):
del self.annotations[:]
del self.annotationsName[:]
self.refreshAnnotations()
def initGui(self):
self.refreshAnnotations()
class KeywordList(HelpedWidget):
"""Shows a list of keywords. The data structure expected and sent to the getter and setter is an array of values."""
def __init__(self, model, list_label="", help_link=""):
HelpedWidget.__init__(self, list_label, help_link)
assert isinstance(model, ListModelMixin)
self.model = model
self.keyword_list = []
self.list = QListWidget(self)
self.list.setMinimumHeight(100)
self.list.setMaximumHeight(150)
self.default_selection_mode = self.list.selectionMode()
self.addWidget(self.list)
self.addRemoveWidget = AddRemoveWidget(self.addItem, self.removeItem)
self.addWidget(self.addRemoveWidget)
self.title = "New keyword"
self.description = "Enter name of keyword:"
self.model.observable().attach(ListModelMixin.LIST_CHANGED_EVENT, self.modelChanged)
self.modelChanged()
def setSelectable(self, selectable):
if selectable:
self.list.setSelectionMode(self.default_selection_mode)
else:
self.list.setSelectionMode(QAbstractItemView.NoSelection)
def setPopupLabels(self, title, description):
"""Change the labels of the default popup."""
self.title = title
self.description = description
def newKeywordPopup(self, keyword_list):
"""
Pops up a message box asking for a new keyword.
Override this and return a string to customize the input dialog - Empty string equals canceled.
The provided list are the already defined keywords
"""
new_keyword, ok = QInputDialog.getText(self, self.tr(self.title), self.tr(self.description), QLineEdit.Normal)
if ok:
return str(new_keyword).strip()
else:
return ""
def addItem(self):
"""Called by the add button to insert a new keyword"""
new_keyword = self.newKeywordPopup(self.keyword_list)
if not new_keyword == "":
self.model.addItem(new_keyword)
def removeItem(self):
"""Called by the remove button to remove a selected keyword"""
if not self.list.currentItem() is None:
row = self.list.currentRow()
try:
self.model.removeItem(self.keyword_list[row])
except NotImplementedError:
message = "Support for removal of items has not been implemented!"
QMessageBox.information(self, "Not implemented!", message)
def modelChanged(self):
"""Retrieves data from the model and inserts it into the list"""
keywords = self.model.getList()
self.list.clear()
self.keyword_list = keywords
for keyword in keywords:
self.list.addItem(keyword)
class GraphDialog(QDialog):
edit_patterns = 0
edit_curves = 1
titles = {edit_patterns: 'Pattern editor', edit_curves: 'Curve editor'}
labels = {edit_patterns: 'Patterns', edit_curves: 'Curves'}
def __init__(self, dockwidget, parent, params, edit_type):
QDialog.__init__(self, parent)
main_lay = QVBoxLayout(self)
self.dockwidget = dockwidget
self.params = params
self.edit_type = edit_type
self.x_label = ''
self.y_label = ''
self.setMinimumWidth(600)
self.setMinimumHeight(400)
self.setWindowTitle(self.titles[edit_type]) # TODO: softcode
self.setWindowModality(QtCore.Qt.ApplicationModal)
self.current = None
self.current_saved = False
# File
self.lbl_file = QLabel('File:')
self.fra_file = QFrame()
self.fra_file.setContentsMargins(0, 0, 0, 0)
fra_file_lay = QHBoxLayout(self.fra_file)
if edit_type == self.edit_patterns:
self.txt_file = QLineEdit(self.params.patterns_file)
elif edit_type == self.edit_curves:
self.txt_file = QLineEdit(self.params.curves_file)
self.txt_file.setReadOnly(True)
self.txt_file.setAlignment(QtCore.Qt.AlignLeft
| QtCore.Qt.AlignVCenter)
self.txt_file.setSizePolicy(QSizePolicy.MinimumExpanding,
QSizePolicy.Minimum)
fra_file_lay.addWidget(self.txt_file)
self.btn_file = QPushButton('Change') # TODO: softcode
self.btn_file.clicked.connect(self.import_file)
fra_file_lay.addWidget(self.btn_file)
fra_file_lay.setContentsMargins(0, 0, 0, 0)
self.lbl_list = QLabel(self.labels[edit_type])
self.lst_list = QListWidget()
self.lst_list.currentItemChanged.connect(self.list_item_changed)
# Form
self.fra_form = QFrame()
fra_form1_lay = QFormLayout(self.fra_form)
fra_form1_lay.setContentsMargins(0, 0, 0, 0)
fra_form1_lay.addRow(self.lbl_list, self.lst_list)
# Buttons
self.fra_buttons = QFrame()
fra_buttons_lay = QHBoxLayout(self.fra_buttons)
fra_buttons_lay.setContentsMargins(0, 0, 0, 0)
if self.edit_type == self.edit_patterns:
ele_name = 'pattern'
elif self.edit_type == self.edit_curves:
ele_name = 'curve'
self.btn_new = QPushButton('New ' + ele_name) # TODO: softcode
self.btn_new.clicked.connect(self.new_element)
fra_buttons_lay.addWidget(self.btn_new)
self.btn_import = QPushButton('Import ' + ele_name +
's') # TODO: softcode
self.btn_import.clicked.connect(self.import_file)
fra_buttons_lay.addWidget(self.btn_import)
self.btn_save = QPushButton('Save current ' +
ele_name) # TODO: softcode
self.btn_save.clicked.connect(self.save)
fra_buttons_lay.addWidget(self.btn_save)
self.btn_del = QPushButton('Delete current ' +
ele_name) # TODO: softcode
self.btn_del.clicked.connect(self.del_item)
fra_buttons_lay.addWidget(self.btn_del)
# ID
self.lbl_id = QLabel('ID:')
self.txt_id = QLineEdit()
self.txt_id.setSizePolicy(QSizePolicy.Maximum,
QSizePolicy.MinimumExpanding)
self.lbl_desc = QLabel('Desc.:')
self.txt_desc = QLineEdit()
self.fra_id = QFrame()
fra_id_lay = QHBoxLayout(self.fra_id)
fra_id_lay.addWidget(self.lbl_id)
fra_id_lay.addWidget(self.txt_id)
fra_id_lay.addWidget(self.lbl_desc)
fra_id_lay.addWidget(self.txt_desc)
# Table form
self.table = QTableWidget(self)
self.rows_nr = 24
self.cols_nr = 2
self.table.setRowCount(self.rows_nr)
self.table.setColumnCount(self.cols_nr)
self.table.verticalHeader().setVisible(False)
# Initialize empty table
self.clear_table()
self.table.itemChanged.connect(self.data_changed)
self.fra_table = QFrame()
fra_table_lay = QVBoxLayout(self.fra_table)
fra_table_lay.setContentsMargins(0, 0, 0, 0)
if edit_type == self.edit_curves:
self.fra_pump_type = QFrame()
fra_pump_type_lay = QFormLayout(self.fra_pump_type)
self.lbl_pump_type = QLabel('Curve type:') # TODO: softcode
self.cbo_pump_type = QComboBox()
for key, name in Curve.type_names.iteritems():
self.cbo_pump_type.addItem(name, key)
fra_pump_type_lay.addRow(self.lbl_pump_type, self.cbo_pump_type)
fra_table_lay.addWidget(self.fra_pump_type)
self.cbo_pump_type.activated.connect(self.cbo_pump_type_activated)
fra_table_lay.addWidget(self.table)
self.btn_add_row = QPushButton('Add row')
self.btn_add_row.clicked.connect(self.add_row)
fra_table_lay.addWidget(self.btn_add_row)
# Graph canvas
self.fra_graph = QFrame()
self.static_canvas = StaticMplCanvas(self.fra_graph,
width=5,
height=4,
dpi=100)
fra_graph_lay = QVBoxLayout(self.fra_graph)
fra_graph_lay.addWidget(self.static_canvas)
# Top frame
self.fra_top = QFrame()
fra_top_lay = QVBoxLayout(self.fra_top)
fra_top_lay.addWidget(self.fra_form)
fra_top_lay.addWidget(self.fra_id)
fra_top_lay.addWidget(self.fra_buttons)
# Bottom frame
self.fra_bottom = QFrame()
fra_bottom_lay = QHBoxLayout(self.fra_bottom)
fra_bottom_lay.addWidget(self.fra_table)
fra_bottom_lay.addWidget(self.fra_graph)
# Main
main_lay.addWidget(self.fra_top)
main_lay.addWidget(self.fra_bottom)
# Get existing patterns/curves
self.need_to_update_graph = False
if self.edit_type == self.edit_patterns:
for pattern_id, pattern in self.params.patterns.iteritems():
self.lst_list.addItem(pattern.id)
elif self.edit_type == self.edit_curves:
for curve_id, curve in self.params.curves.iteritems():
self.lst_list.addItem(curve.id)
if self.lst_list.count() > 0:
self.lst_list.setCurrentRow(0)
self.txt_id.setEnabled(True)
self.txt_desc.setEnabled(True)
self.btn_save.setEnabled(True)
self.btn_del.setEnabled(True)
self.table.setEnabled(True)
self.table.setEditTriggers(QAbstractItemView.AllEditTriggers)
else:
self.txt_id.setEnabled(False)
self.txt_desc.setEnabled(False)
self.btn_save.setEnabled(False)
self.btn_del.setEnabled(False)
self.table.setEnabled(False)
self.table.setEditTriggers(QAbstractItemView.NoEditTriggers)
self.new_dialog = None
self.need_to_update_graph = True
def cbo_pump_type_activated(self):
self.update_table_headers()
self.update_graph()
def add_row(self):
row_pos = self.table.rowCount()
self.table.insertRow(row_pos)
col = 0
item = QTableWidgetItem(str(row_pos))
if self.edit_type == self.edit_patterns:
self.table.setItem(row_pos, col, item)
item.setFlags(QtCore.Qt.ItemIsSelectable)
def setVisible(self, bool):
QDialog.setVisible(self, bool)
self.update_table_headers()
self.update_graph()
def list_item_changed(self):
p_index = self.lst_list.currentRow()
flags = Qt.ItemFlags()
flags != Qt.ItemIsEnabled
# Clear table
self.clear_table()
self.need_to_update_graph = False
if p_index >= 0:
self.table.setRowCount(0)
if self.edit_type == self.edit_patterns:
self.current = self.params.patterns[
self.lst_list.currentItem().text()]
for v in range(len(self.current.values)):
row_pos = self.table.rowCount()
self.table.insertRow(row_pos)
item = QTableWidgetItem(str(v))
item.setFlags(flags)
self.table.setItem(v, 0, item)
self.table.setItem(
v, 1, QTableWidgetItem(str(self.current.values[v])))
elif self.edit_type == self.edit_curves:
self.current = self.params.curves[
self.lst_list.currentItem().text()]
for v in range(len(self.current.xs)):
row_pos = self.table.rowCount()
self.table.insertRow(row_pos)
self.table.setItem(
v, 0, QTableWidgetItem(str(self.current.xs[v])))
self.table.setItem(
v, 1, QTableWidgetItem(str(self.current.ys[v])))
curve_type = self.current.type
self.cbo_pump_type.setCurrentIndex(curve_type)
# Update GUI
self.txt_id.setText(self.current.id)
self.txt_desc.setText(self.current.desc)
self.update_table_headers()
# Update graph
self.need_to_update_graph = True
self.update_graph()
else:
# No curves
self.txt_id.setText('')
self.txt_desc.setText('')
# Update table and chart
self.need_to_update_graph = False
for v in range(self.table.columnCount()):
self.table.setItem(v, 1, QTableWidgetItem(''))
self.need_to_update_graph = True
self.update_graph()
def import_file(self):
config_file = ConfigFile(Parameters.config_file_path)
directory = None
if self.edit_type == GraphDialog.edit_curves:
directory = self.params.last_curves_dir
elif self.edit_type == GraphDialog.edit_patterns:
directory = self.params.last_patterns_dir
if directory is None:
directory = self.params.last_project_dir
file_path = QFileDialog.getOpenFileName(self, 'Select file', directory,
'Files (*.txt *.inp)')
if file_path is None or file_path == '':
return
else:
if self.edit_type == GraphDialog.edit_patterns:
# Save patterns file path in configuration file
config_file.set_patterns_file_path(file_path)
Parameters.patterns_file = file_path
elif self.edit_type == GraphDialog.edit_curves:
# Save curve file path in configuration file
config_file.set_curves_file_path(file_path)
Parameters.curves_file = file_path
self.read(file_path)
def read(self, file_path):
self.lst_list.clear()
if self.edit_type == self.edit_patterns:
InpFile.read_patterns(self.params, file_path)
for pattern_id, pattern in self.params.patterns.iteritems():
# desc = ' (' + pattern.desc + ')' if pattern.desc is not None else ''
self.lst_list.addItem(pattern.id)
self.params.patterns[pattern.id] = pattern
elif self.edit_type == self.edit_curves:
InpFile.read_curves(self.params, file_path)
for curve_id, curve in self.params.curves.iteritems():
# desc = ' (' + curve.desc + ')' if curve.desc is not None else ''
self.lst_list.addItem(curve.id)
self.params.curves[curve.id] = curve
if self.lst_list.count() > 0:
self.lst_list.setCurrentRow(0)
def new_element(self):
old_ids = []
if self.edit_type == self.edit_patterns:
for pattern in self.params.patterns.itervalues():
old_ids.append(pattern.id)
elif self.edit_type == self.edit_curves:
for curve in self.params.curves.itervalues():
old_ids.append(curve.id)
self.new_dialog = NewIdDialog(self, old_ids)
self.new_dialog.exec_()
new_id = self.new_dialog.get_newid()
description = self.new_dialog.get_description()
if new_id is None or description is None:
return
if self.edit_type == self.edit_patterns:
new_pattern = Pattern(new_id, description)
self.params.patterns[new_pattern.id] = new_pattern
self.lst_list.addItem(new_pattern.id)
elif self.edit_type == self.edit_curves:
curve_type = self.cbo_pump_type.itemData(
self.cbo_pump_type.currentIndex())
new_curve = Curve(new_id, curve_type, desc=description)
self.params.curves[new_curve.id] = new_curve
self.lst_list.addItem(new_curve.id)
self.lst_list.setCurrentRow(self.lst_list.count() - 1)
self.txt_id.setText(new_id)
self.txt_desc.setText(description)
# Clear table
self.clear_table()
self.static_canvas.axes.clear()
self.txt_id.setEnabled(True)
self.txt_desc.setEnabled(True)
self.btn_save.setEnabled(True)
self.btn_del.setEnabled(True)
self.table.setEnabled(True)
self.table.setEditTriggers(QAbstractItemView.AllEditTriggers)
def save(self):
self.need_to_update_graph = False
# Check for ID
if not self.txt_id.text():
QMessageBox.warning(
self,
Parameters.plug_in_name,
u'Please specify the ID.', # TODO: softcode
QMessageBox.Ok)
return
if self.edit_type == GraphDialog.edit_patterns:
values = []
for row in range(self.table.rowCount()):
item = self.table.item(row, 1)
if item is not None and item.text() != '':
values.append(self.from_item_to_val(item))
else:
values.append('0')
pattern = Pattern(self.txt_id.text(), self.txt_desc.text(), values)
old_patterns = self.params.patterns
old_patterns[pattern.id] = pattern
self.params.patterns = old_patterns
self.lst_list.currentItem().setText(pattern.id)
elif self.edit_type == GraphDialog.edit_curves:
# Check for ID unique
xs = []
ys = []
for row in range(self.table.rowCount()):
item_x = self.table.item(row, 0)
item_y = self.table.item(row, 1)
if item_x.text() != '' and item_y.text() != '':
xs.append(self.from_item_to_val(item_x))
ys.append(self.from_item_to_val(item_y))
curve_type = self.cbo_pump_type.itemData(
self.cbo_pump_type.currentIndex())
curve = Curve(self.txt_id.text(), curve_type, self.txt_desc.text())
for v in range(len(xs)):
curve.append_xy(xs[v], ys[v])
old_curves = self.params.curves
old_curves[curve.id] = curve
self.params.curves = old_curves
self.lst_list.currentItem().setText(curve.id)
# Update GUI
self.dockwidget.update_curves_combo()
# self.read()
self.need_to_update_graph = True
def clear_table(self):
self.need_to_update_graph = False
for r in range(self.table.rowCount()):
self.table.setItem(r, 0, QTableWidgetItem(None))
self.table.setItem(r, 1, QTableWidgetItem(None))
for row in range(self.rows_nr):
for col in range(self.cols_nr):
if self.edit_type == self.edit_patterns:
if col == 0:
item = QTableWidgetItem(str(row))
self.table.setItem(row, col, item)
item.setFlags(QtCore.Qt.ItemIsSelectable)
# elif col == 1 and row == 0:
# item = QTableWidgetItem(str(1))
# self.table.setItem(row, col, item)
# item.setFlags(QtCore.Qt.ItemIsSelectable | QtCore.Qt.ItemIsEnabled)
# elif self.edit_type == self.edit_curves:
# if row == 0:
# item = QTableWidgetItem(str(0))
# self.table.setItem(row, 0, item)
# item = QTableWidgetItem(str(1))
# self.table.setItem(row, 1, item)
# item.setFlags(QtCore.Qt.ItemIsSelectable | QtCore.Qt.ItemIsEnabled)
self.need_to_update_graph = True
def del_item(self):
selected_row = self.lst_list.currentRow()
name = self.lst_list.currentItem().text()
if selected_row < 0:
return
self.lst_list.takeItem(selected_row)
if self.lst_list.count() == 0:
self.txt_id.setEnabled(False)
self.txt_desc.setEnabled(False)
self.btn_save.setEnabled(False)
self.btn_del.setEnabled(False)
self.table.setEnabled(False)
self.table.setEditTriggers(QAbstractItemView.NoEditTriggers)
if self.edit_type == GraphDialog.edit_curves:
del self.params.curves[name]
# Update GUI
self.dockwidget.update_curves_combo()
elif self.edit_type == GraphDialog.edit_patterns:
del self.params.patterns[name]
# Update GUI
self.dockwidget.update_patterns_combo()
def data_changed(self):
if self.need_to_update_graph:
self.update_graph()
def update_table_headers(self):
if self.edit_type == self.edit_patterns:
self.x_label = 'Time period'
self.y_label = 'Multiplier'
elif self.edit_type == self.edit_curves:
cbo_data = self.cbo_pump_type.itemData(
self.cbo_pump_type.currentIndex())
if cbo_data == Curve.type_efficiency:
self.x_label = 'Flow ' + '[' + self.params.options.flow_units + ']'
self.y_label = 'Efficiency ' + '[' + self.params.options.units_deltaz[
self.params.options.units] + ']'
if cbo_data == Curve.type_headloss:
self.x_label = 'Flow ' + '[' + self.params.options.flow_units + ']'
self.y_label = 'Headloss ' + '[' + self.params.options.units_deltaz[
self.params.options.units] + ']'
if cbo_data == Curve.type_pump:
self.x_label = 'Flow ' + '[' + self.params.options.flow_units + ']'
self.y_label = 'Head ' + '[' + self.params.options.units_deltaz[
self.params.options.units] + ']'
if cbo_data == Curve.type_volume:
self.x_label = 'Height ' + '[' + self.params.options.flow_units + ']'
self.y_label = 'Volume ' + '[' + self.params.options.units_deltaz[
self.params.options.units] + ']'
self.table.setHorizontalHeaderLabels([self.x_label,
self.y_label]) # TODO: softcode
def update_graph(self):
if not self.need_to_update_graph:
return
xs = []
ys = []
for row in range(self.table.rowCount()):
item = self.table.item(row, 0)
x = self.from_item_to_val(item)
item = self.table.item(row, 1)
y = self.from_item_to_val(item)
if x is not None:
xs.append(float(x))
if y is not None:
ys.append(float(y))
if len(xs) == 0 or len(ys) == 0:
self.static_canvas.clear()
return
xys_t = zip(xs, ys)
xys_t.sort()
xys = zip(*xys_t)
xs = xys[0]
ys = xys[1]
if self.edit_type == self.edit_patterns:
y_axis_label = 'Mult. avg.: ' + '{0:.2f}'.format(
(numpy.average(ys)))
self.static_canvas.draw_bars_graph(
ys,
time_period=self.params.times.pattern_timestep,
y_axes_label=y_axis_label)
elif self.edit_type == self.edit_curves:
# Account for different types of curves
cbo_data = self.cbo_pump_type.itemData(
self.cbo_pump_type.currentIndex())
series_length = min(len(xs), len(ys))
# Need to account for different types of curves
if cbo_data == Curve.type_efficiency or cbo_data == Curve.type_headloss or cbo_data == Curve.type_volume:
self.static_canvas.draw_line_graph(xs[:series_length],
ys[:series_length],
self.x_label, self.y_label)
elif cbo_data == Curve.type_pump:
if series_length == 1 or series_length == 3:
if series_length == 1:
# 3 curve points
curve_xs = [0, xs[0], xs[0] * 2]
curve_ys = [ys[0] * 1.33, ys[0], 0]
# y = a * x^2 + b * x + c
elif series_length == 3:
# 3 curve points
curve_xs = [xs[0], xs[1], xs[2]]
curve_ys = [ys[0], ys[1], ys[2]]
(a, b, c) = numpy.polyfit(curve_xs, curve_ys, 2)
# Create a few interpolated values
interp_xs = []
interp_ys = []
n_vals = 30
for v in range(n_vals + 1):
x = (curve_xs[2] - curve_xs[0]) / n_vals * v
interp_xs.append(x)
y = a * x**2 + b * x + c
interp_ys.append(y)
self.static_canvas.draw_line_graph(interp_xs, interp_ys,
self.x_label,
self.y_label)
else:
self.static_canvas.draw_line_graph(xs[:series_length],
ys[:series_length],
self.x_label,
self.y_label)
def from_item_to_val(self, item):
if item is None:
value = None
else:
value = item.text()
try:
value = float(value)
value = max(value, 0)
except:
value = None
return value
class SolverGenerator(QWidget):
def __init__(self):
super().__init__()
self._init_info_base()
self._init_ui()
def _init_info_base(self):
f = open('base')
lines = [line for line in f.readlines() if line.split()]
count = int(lines[0])
self._names = {}
for line in lines[1:1 + count]:
line = line.split(' ', 1)
self._names[line[1].rstrip()] = line[0]
model = [Formula(info=line1, code=line2) for line1, line2 in
zip(lines[1 + count::2], lines[2 + count::2])]
self._info_base = InfoBase(model)
def _init_ui(self):
main = QVBoxLayout(self)
up_label = QLabel('Входные параметры:')
up_label.setAlignment(Qt.AlignCenter)
main.addWidget(up_label)
up = QHBoxLayout(self)
self.up_left = QListWidget(self)
self.up_left.addItems(list(self._names.keys()))
self.up_left.sortItems()
up.addWidget(self.up_left)
up_buttons = QVBoxLayout(self)
up_to_right = QPushButton('>')
self.connect(up_to_right, SIGNAL('pressed()'), self._up_to_right)
up_buttons.addWidget(up_to_right)
up_to_left = QPushButton('<')
self.connect(up_to_left, SIGNAL('pressed()'), self._up_to_left)
up_buttons.addWidget(up_to_left)
up_buttons.setAlignment(Qt.AlignCenter)
up.addLayout(up_buttons)
self.up_right = QListWidget(self)
up.addWidget(self.up_right)
self.up_right.sortItems()
main.addLayout(up)
down_label = QLabel('Выходные параметры:')
down_label.setAlignment(Qt.AlignCenter)
main.addWidget(down_label)
down = QHBoxLayout(self)
self.down_left = QListWidget(self)
self.down_left.addItems(list(self._names.keys()))
self.down_left.sortItems()
down.addWidget(self.down_left)
down_buttons = QVBoxLayout(self)
down_to_right = QPushButton('>')
self.connect(down_to_right, SIGNAL('pressed()'), self._down_to_right)
down_buttons.addWidget(down_to_right)
down_to_left = QPushButton('<')
self.connect(down_to_left, SIGNAL('pressed()'), self._down_to_left)
down_buttons.addWidget(down_to_left)
down_buttons.setAlignment(Qt.AlignCenter)
down.addLayout(down_buttons)
self.down_right = QListWidget(self)
down.addWidget(self.down_right)
self.down_right.sortItems()
main.addLayout(down)
solve = QPushButton('Решить')
self.connect(solve, SIGNAL('pressed()'), self._solve)
main.addWidget(solve)
self.setLayout(main)
self.setWindowTitle('SolverGenerator')
self.resize(600, 600)
self._center()
self.show()
def _solve(self):
input_definition = [self.up_right.item(i).text() for i in
range(self.up_right.count())]
input_params = [self._names[item] for item in input_definition]
output_definition = [self.down_right.item(i).text() for i in
range(self.down_right.count())]
output_params = [self._names[item] for item in output_definition]
algorithm = self._info_base.get_algorithm(input_params, output_params)
if algorithm:
self._generate_code(input_definition, input_params,
output_definition, output_params, algorithm)
else:
QMessageBox().warning(self, 'Решения нет',
'Для выбранных данных решения нет')
def _up_to_right(self):
item = self.up_left.takeItem(self.up_left.currentRow())
self.up_right.addItem(item)
self.up_right.sortItems()
def _up_to_left(self):
item = self.up_right.takeItem(self.up_right.currentRow())
self.up_left.addItem(item)
self.up_left.sortItems()
def _down_to_right(self):
item = self.down_left.takeItem(self.down_left.currentRow())
self.down_right.addItem(item)
self.down_right.sortItems()
def _down_to_left(self):
item = self.down_right.takeItem(self.down_right.currentRow())
self.down_left.addItem(item)
self.down_left.sortItems()
def _center(self):
qr = self.frameGeometry()
cp = QDesktopWidget().availableGeometry().center()
qr.moveCenter(cp)
self.move(qr.topLeft())
@staticmethod
def _generate_code(input_definition, input_params, output_definition,
output_params, algorithm):
code = []
if any('math' in formula.code for formula in algorithm):
code.append('import math')
for name, definition in zip(input_params, input_definition):
code.append(
'{0} = float(input("Введите {0} ({1}): "))'.format(name,
definition.lower()))
for formula in algorithm:
code.append(formula.code)
for name, definition in zip(output_params, output_definition):
code.append('print("{0} = %f" % {1})'.format(definition, name))
code.append('input("Нажмите Enter для завершения.")')
code.append('')
code = '\n'.join(code)
file = open('program.py', 'w')
file.write(code)
file.close()
xterm = sh.Command('xterm')
xterm('-e', 'python3 program.py')
class StringListDlg(QDialog):
acceptedList = Signal(QStringList)
def __init__(self, name, stringlist=None, parent=None):
super(StringListDlg, self).__init__(parent)
self.name = name
self.create_widgets(stringlist)
self.layout_widgets()
self.setWindowTitle("Edit {0} List".format(self.name))
def create_widgets(self, stringlist):
self.listWidget = QListWidget()
if stringlist is not None:
self.listWidget.addItems(stringlist)
self.listWidget.setCurrentRow(0)
def layout_widgets(self):
buttonLayout = QVBoxLayout()
for text, slot in (("&Add...", self.add),
("&Edit...", self.edit),
("&Remove...", self.remove),
("&Up", self.up),
("&Down", self.down),
("&Sort", self.listWidget.sortItems),
("Close", self.accept)):
button = QPushButton(text)
if not MAC:
button.setFocusPolicy(Qt.NoFocus)
if text == "Close":
buttonLayout.addStretch()
buttonLayout.addWidget(button)
button.clicked.connect(slot)
layout = QHBoxLayout()
layout.addWidget(self.listWidget)
layout.addLayout(buttonLayout)
self.setLayout(layout)
def add(self):
row = self.listWidget.currentRow()
title = "Add {0}".format(self.name)
string, ok = QInputDialog.getText(self, title, title)
if ok and not string.isEmpty():
self.listWidget.insertItem(row, string)
def edit(self):
row = self.listWidget.currentRow()
item = self.listWidget.item(row)
if item is not None:
title = "Edit {0}".format(self.name)
string, ok = QInputDialog.getText(self, title, title,
QLineEdit.Normal, item.text())
if ok and not string.isEmpty():
item.setText(string)
def remove(self):
row = self.listWidget.currentRow()
item = self.listWidget.item(row)
if item is None:
return
reply = QMessageBox.question(self, "Remove {0}".format(
self.name), "Remove {0} `{1}'?".format(
self.name, unicode(item.text())),
QMessageBox.Yes|QMessageBox.No)
if reply == QMessageBox.Yes:
item = self.listWidget.takeItem(row)
del item
def up(self):
row = self.listWidget.currentRow()
if row >= 1:
item = self.listWidget.takeItem(row)
self.listWidget.insertItem(row - 1, item)
self.listWidget.setCurrentItem(item)
def down(self):
row = self.listWidget.currentRow()
if row < self.listWidget.count() - 1:
item = self.listWidget.takeItem(row)
self.listWidget.insertItem(row + 1, item)
self.listWidget.setCurrentItem(item)
def reject(self):
self.accept()
def accept(self):
self.stringlist = QStringList()
for row in range(self.listWidget.count()):
self.stringlist.append(self.listWidget.item(row).text())
self.acceptedList.emit(self.stringlist)
QDialog.accept(self)
class ProjectPropertiesDialog( QDialog, object ):
""" project properties dialog implementation """
def __init__( self, project = None, parent = None ):
QDialog.__init__( self, parent )
# The dialog caller reads this member if the dialog was finished
# successfully.
self.absProjectFileName = None
self.__createLayout()
self.__project = project
if project is None:
# It a new project creation
self.setWindowTitle( "New Project Properties" )
userRecord = pwd.getpwuid( os.getuid() )
if not userRecord[ 5 ].endswith( os.path.sep ):
self.dirEdit.setText( userRecord[ 5 ] + os.path.sep )
else:
self.dirEdit.setText( userRecord[ 5 ] )
self.initialDirName = self.dirEdit.text()
self.lastProjectName = ""
if userRecord[ 4 ] != "":
self.authorEdit.setText( userRecord[ 4 ].split( ',' )[ 0 ].strip() )
else:
self.authorEdit.setText( userRecord[ 0 ] )
try:
self.emailEdit.setText( userRecord[ 0 ] +
"@" + socket.gethostname() )
except:
pass
self.versionEdit.setText( "0.0.1" )
self.licenseEdit.setText( "GPL v3" )
self.copyrightEdit.setText( "Copyright (c) " +
self.authorEdit.text() + ", " +
str( datetime.date.today().year ) )
self.creationDateEdit.setText( getLocaleDate() )
self.nameEdit.setFocus()
elif type( project ) == type( "" ):
self.setWindowTitle( "Viewing Project Properties" )
# This is viewing properties and the argument is the path to the
# project file
scriptName, importDirs, creationDate, author, lic, \
copy_right, description, \
version, email, uuid = getProjectProperties( project )
if not os.path.isabs( scriptName ) and scriptName != "":
scriptName = os.path.normpath( os.path.dirname( project ) +
os.path.sep + scriptName )
self.nameEdit.setText( os.path.basename( project ) )
self.nameEdit.setToolTip( "" )
self.dirEdit.setText( os.path.dirname( project ) )
self.dirEdit.setToolTip( "" )
self.scriptEdit.setText( scriptName )
self.versionEdit.setText( version )
self.authorEdit.setText( author )
self.emailEdit.setText( email )
self.licenseEdit.setText( lic )
self.copyrightEdit.setText( copy_right )
self.descriptionEdit.setText( description )
self.creationDateEdit.setText( creationDate )
self.uuidEdit.setText( str( uuid ) )
self.uuidEdit.setToolTip( settingsDir + str( uuid ) + os.path.sep +
" (double click to copy path)" )
for item in importDirs:
self.importDirList.addItem( item )
self.disableEditing()
else:
self.setWindowTitle( "Editing Project Properties" )
# This is editing the loaded project.
self.nameEdit.setText( os.path.basename( project.fileName ) )
self.nameEdit.setToolTip( "" )
self.dirEdit.setText( project.getProjectDir() )
self.dirEdit.setToolTip( "" )
self.scriptEdit.setText( project.getProjectScript() )
self.versionEdit.setText( project.version )
self.authorEdit.setText( project.author )
self.emailEdit.setText( project.email )
self.licenseEdit.setText( project.license )
self.copyrightEdit.setText( project.copyright )
self.descriptionEdit.setText( project.description )
self.creationDateEdit.setText( project.creationDate )
self.uuidEdit.setText( str( project.uuid ) )
self.uuidEdit.setToolTip( project.userProjectDir +
" (double click to copy path)" )
self.setReadOnly()
for item in project.importDirs:
self.importDirList.addItem( item )
if self.importDirList.count() > 0:
self.importDirList.setCurrentRow( 0 )
self.delImportDirButton.setEnabled( True )
# The project could be the one belonging to another user
# so there might be no write permissions.
if not os.access( project.fileName, os.W_OK ):
# Disable editing
self.setWindowTitle( "Viewing Project Properties (no write permissions)" )
self.disableEditing()
else:
self.scriptEdit.setFocus()
return
def __createLayout( self ):
""" Creates the dialog layout """
self.resize( 600, 400 )
self.setSizeGripEnabled( True )
verticalLayout = QVBoxLayout( self )
gridLayout = QGridLayout()
# Project name
nameLabel = QLabel( self )
nameLabel.setText( "Project name:" )
gridLayout.addWidget( nameLabel, 0, 0, 1, 1 )
self.nameEdit = QLineEdit( self )
self.nameEdit.setToolTip( "Type a project name without a path" )
self.nameEdit.installEventFilter( self )
gridLayout.addWidget( self.nameEdit, 0, 1, 1, 1 )
# Project dir
dirLabel = QLabel( self )
dirLabel.setText( "Project directory:" )
gridLayout.addWidget( dirLabel, 1, 0, 1, 1 )
self.dirEdit = QLineEdit( self )
self.dirEdit.setToolTip( "Not existed directories will be created" )
gridLayout.addWidget( self.dirEdit, 1, 1, 1, 1 )
self.dirButton = QPushButton( self )
self.dirButton.setText( "..." )
gridLayout.addWidget( self.dirButton, 1, 2, 1, 1 )
self.dirCompleter = DirCompleter( self.dirEdit )
# Project script
mainScriptLabel = QLabel( "Main script:", self )
gridLayout.addWidget( mainScriptLabel, 2, 0, 1, 1 )
self.scriptEdit = QLineEdit( self )
self.scriptEdit.setToolTip( "Project main script, "
"used when the project is run" )
gridLayout.addWidget( self.scriptEdit, 2, 1, 1, 1 )
self.scriptButton = QPushButton( "...", self )
gridLayout.addWidget( self.scriptButton, 2, 2, 1, 1 )
self.fileCompleter = FileCompleter( self.scriptEdit )
# Import dirs
importLabel = QLabel( self )
importLabel.setText( "Import directories:" )
importLabel.setAlignment( Qt.AlignTop )
gridLayout.addWidget( importLabel, 3, 0, 1, 1 )
self.importDirList = QListWidget( self )
self.importDirList.setAlternatingRowColors( True )
self.importDirList.setSelectionMode( QAbstractItemView.SingleSelection )
self.importDirList.setSelectionBehavior( QAbstractItemView.SelectRows )
self.importDirList.setItemDelegate( NoOutlineHeightDelegate( 4 ) )
self.importDirList.setToolTip( "Directories where to look for "
"project specific imports" )
gridLayout.addWidget( self.importDirList, 3, 1, 1, 1 )
self.addImportDirButton = QPushButton( self )
self.addImportDirButton.setText( "Add dir" )
self.delImportDirButton = QPushButton( self )
self.delImportDirButton.setText( "Delete dir" )
self.delImportDirButton.setEnabled( False )
vLayout = QVBoxLayout()
vLayout.addWidget( self.addImportDirButton )
vLayout.addWidget( self.delImportDirButton )
vLayout.addStretch( 0 )
gridLayout.addLayout( vLayout, 3, 2, 1, 1 )
# Version
versionLabel = QLabel( self )
versionLabel.setText( "Version:" )
gridLayout.addWidget( versionLabel, 4, 0, 1, 1 )
self.versionEdit = QLineEdit( self )
gridLayout.addWidget( self.versionEdit, 4, 1, 1, 1 )
# Author
authorLabel = QLabel( self )
authorLabel.setText( "Author:" )
gridLayout.addWidget( authorLabel, 5, 0, 1, 1 )
self.authorEdit = QLineEdit( self )
gridLayout.addWidget( self.authorEdit, 5, 1, 1, 1 )
# E-mail
emailLabel = QLabel( self )
emailLabel.setText( "E-mail:" )
gridLayout.addWidget( emailLabel, 6, 0, 1, 1 )
self.emailEdit = QLineEdit( self )
gridLayout.addWidget( self.emailEdit, 6, 1, 1, 1 )
# License
licenseLabel = QLabel( self )
licenseLabel.setText( "License:" )
gridLayout.addWidget( licenseLabel, 7, 0, 1, 1 )
self.licenseEdit = QLineEdit( self )
gridLayout.addWidget( self.licenseEdit, 7, 1, 1, 1 )
# Copyright
copyrightLabel = QLabel( self )
copyrightLabel.setText( "Copyright:" )
gridLayout.addWidget( copyrightLabel, 8, 0, 1, 1 )
self.copyrightEdit = QLineEdit( self )
gridLayout.addWidget( self.copyrightEdit, 8, 1, 1, 1 )
# Description
descriptionLabel = QLabel( self )
descriptionLabel.setText( "Description:" )
descriptionLabel.setAlignment( Qt.AlignTop )
gridLayout.addWidget( descriptionLabel, 9, 0, 1, 1 )
self.descriptionEdit = QTextEdit( self )
self.descriptionEdit.setTabChangesFocus( True )
self.descriptionEdit.setAcceptRichText( False )
gridLayout.addWidget( self.descriptionEdit, 9, 1, 1, 1 )
# Creation date
creationDateLabel = QLabel( self )
creationDateLabel.setText( "Creation date:" )
gridLayout.addWidget( creationDateLabel, 10, 0, 1, 1 )
self.creationDateEdit = FramedLabelWithDoubleClick()
self.creationDateEdit.setToolTip( "Double click to copy" )
gridLayout.addWidget( self.creationDateEdit, 10, 1, 1, 1 )
# Project UUID
uuidLabel = QLabel( self )
uuidLabel.setText( "UUID:" )
gridLayout.addWidget( uuidLabel, 11, 0, 1, 1 )
self.uuidEdit = FramedLabelWithDoubleClick( "", self.__copyProjectPath )
gridLayout.addWidget( self.uuidEdit, 11, 1, 1, 1 )
verticalLayout.addLayout( gridLayout )
# Buttons at the bottom
buttonBox = QDialogButtonBox( self )
buttonBox.setOrientation( Qt.Horizontal )
buttonBox.setStandardButtons( QDialogButtonBox.Cancel | \
QDialogButtonBox.Ok )
verticalLayout.addWidget( buttonBox )
nameLabel.setBuddy( self.nameEdit )
dirLabel.setBuddy( self.dirEdit )
versionLabel.setBuddy( self.versionEdit )
authorLabel.setBuddy( self.authorEdit )
emailLabel.setBuddy( self.emailEdit )
licenseLabel.setBuddy( self.licenseEdit )
copyrightLabel.setBuddy( self.copyrightEdit )
descriptionLabel.setBuddy( self.descriptionEdit )
buttonBox.accepted.connect( self.onOKButton )
buttonBox.rejected.connect( self.reject )
self.dirButton.clicked.connect( self.onDirButton )
self.scriptButton.clicked.connect( self.onScriptButton )
self.importDirList.currentRowChanged.connect( self.onImportDirRowChanged )
self.addImportDirButton.clicked.connect( self.onAddImportDir )
self.delImportDirButton.clicked.connect( self.onDelImportDir )
self.nameEdit.textEdited.connect( self.onProjectNameChanged )
self.setTabOrder( self.nameEdit, self.dirEdit )
self.setTabOrder( self.dirEdit, self.dirButton )
self.setTabOrder( self.dirButton, self.scriptEdit )
self.setTabOrder( self.scriptEdit, self.scriptButton )
self.setTabOrder( self.scriptButton, self.importDirList )
self.setTabOrder( self.importDirList, self.addImportDirButton )
self.setTabOrder( self.addImportDirButton, self.delImportDirButton )
self.setTabOrder( self.delImportDirButton, self.versionEdit )
self.setTabOrder( self.versionEdit, self.authorEdit )
self.setTabOrder( self.authorEdit, self.emailEdit )
self.setTabOrder( self.emailEdit, self.licenseEdit )
self.setTabOrder( self.licenseEdit, self.copyrightEdit )
self.setTabOrder( self.copyrightEdit, self.descriptionEdit )
self.setTabOrder( self.descriptionEdit, buttonBox )
return
def eventFilter( self, obj, event ):
" Event filter for the project name field "
# Do not allow path separators
if event.type() == QEvent.KeyPress:
if event.key() == ord( os.path.sep ):
return True
return QObject.eventFilter( self, obj, event )
def onDirButton( self ):
" Displays a directory selection dialog "
dirName = QFileDialog.getExistingDirectory( self,
"Select project directory",
self.dirEdit.text(),
QFileDialog.Options( QFileDialog.ShowDirsOnly ) )
if dirName:
self.dirEdit.setText( os.path.normpath( dirName ) )
return
def onScriptButton( self ):
" Displays a file selection dialog "
scriptName = QFileDialog.getOpenFileName( self,
"Select project main script",
self.dirEdit.text() )
if scriptName:
self.scriptEdit.setText( os.path.normpath( scriptName ) )
return
def onImportDirRowChanged( self, row ):
" Triggered when a current row in the import dirs is changed "
self.delImportDirButton.setEnabled( row != -1 )
return
def onAddImportDir( self ):
" Displays a directory selection dialog "
dirName = QFileDialog.getExistingDirectory( self,
"Select import directory",
self.dirEdit.text(),
QFileDialog.Options( QFileDialog.ShowDirsOnly ) )
if not dirName:
return
# There are 2 cases: new project or
# editing the existed project properties
if self.__project is None:
# It a new project; the project path could be editedd
dirToInsert = dirName
else:
# This is an existed project; no way the project path is changed
# Let's decide it a relative path should be used here
if self.__project.isProjectDir( dirName ):
dirToInsert = relpath( dirName, self.dirEdit.text() )
else:
dirToInsert = dirName
index = 0
while index < self.importDirList.count():
if self.importDirList.item( index ).text() == dirToInsert:
logging.warning( "The directory '" + dirName +
"' is already in the list of "
"imported directories and is not added." )
return
index += 1
self.importDirList.addItem( dirToInsert )
self.importDirList.setCurrentRow( self.importDirList.count() - 1 )
return
def onDelImportDir( self ):
" Triggered when an import dir should be deleted "
rowToDelete = self.importDirList.currentRow()
if rowToDelete == -1:
self.delImportDirButton.setEnabled( False )
return
self.importDirList.takeItem( rowToDelete )
if self.importDirList.count() == 0:
self.delImportDirButton.setEnabled( False )
else:
self.importDirList.setCurrentRow( self.importDirList.count() - 1 )
return
def onOKButton( self ):
" Checks that the mandatory fields are filled properly "
# The checks must be done for a new project only
if not self.nameEdit.isEnabled():
self.accept()
return
# Check that the project name does not have path separators and is not
# empty
if not self.nameEdit.text().strip():
QMessageBox.critical( self, "Error",
"The project name must not be empty" )
return
if os.path.sep in self.nameEdit.text():
QMessageBox.critical( self, "Error",
"The project name must not "
"contain path separators" )
return
# Check that the project directory is given
dirName = self.dirEdit.text().strip()
if not dirName:
QMessageBox.critical( self, "Error",
"The project directory must not be empty" )
return
dirName = os.path.abspath( dirName )
self.dirEdit.setText( dirName )
# Check that the project file does not exist
projectFileName = dirName
if not projectFileName.endswith( os.path.sep ):
projectFileName += os.path.sep
projectFileName += self.nameEdit.text().strip()
if not projectFileName.endswith( ".cdm" ):
projectFileName += ".cdm"
if os.path.exists( projectFileName ):
QMessageBox.critical( self, "Error",
"The project file " + projectFileName +
" exists. Please provide another "
"directory / project name." )
return
# Check that the project dir is not a file
if os.path.exists( dirName ):
# It might be a link, so read it first
dirName = os.path.realpath( dirName )
if not os.path.exists( dirName ):
QMessageBox.critical( self, "Error",
"Broken link: " + dirName )
return
if not os.path.isdir( dirName ):
QMessageBox.critical( self, "Error",
"The project directory "
"may not be a file" )
return
# Check that the dir is writable
if not os.access( dirName, os.W_OK ):
QMessageBox.critical( self, "Error",
"You don't have write permissions on " +
dirName )
return
else:
# Create the directory
try:
os.makedirs( dirName )
except OSError:
QMessageBox.critical( self, "Error",
"Cannot create the project directory" )
return
# Save the absolute file name for further reading it by the caller
self.absProjectFileName = projectFileName
# The minimum is provided so we can accept it
self.accept()
return
def onProjectNameChanged( self, newName ):
" Called when the project name changed "
if newName.endswith( ".cdm" ):
newName = newName[ :-4 ]
if self.dirEdit.text().strip() == (self.initialDirName +
self.lastProjectName):
self.dirEdit.setText( self.initialDirName + newName )
self.lastProjectName = newName
return
def setReadOnly( self ):
""" Disables editing some fields """
self.dirEdit.setReadOnly( True )
self.dirEdit.setFocusPolicy( Qt.NoFocus )
self.dirEdit.setDisabled( True )
self.dirButton.setDisabled( True )
self.dirButton.setFocusPolicy( Qt.NoFocus )
self.nameEdit.setReadOnly( True )
self.nameEdit.setFocusPolicy( Qt.NoFocus )
self.nameEdit.setDisabled( True )
return
def disableEditing( self ):
" Disables all the editing "
self.nameEdit.setDisabled( True )
self.dirEdit.setDisabled( True )
self.dirButton.setDisabled( True )
self.scriptEdit.setDisabled( True )
self.scriptButton.setDisabled( True )
self.importDirList.setDisabled( True )
self.addImportDirButton.setDisabled( True )
self.delImportDirButton.setDisabled( True )
self.versionEdit.setDisabled( True )
self.authorEdit.setDisabled( True )
self.emailEdit.setDisabled( True )
self.licenseEdit.setDisabled( True )
self.copyrightEdit.setDisabled( True )
self.descriptionEdit.setDisabled( True )
return
def __copyProjectPath( self ):
" Copies the project path when a label is double clicked "
text = self.uuidEdit.text().strip()
if text:
path = settingsDir + text + os.path.sep
QApplication.clipboard().setText( path )
return
class NotebookSettingsDialog(QDialog):
"""GUI for adjusting notebook settings"""
def __init__(self, parent=None):
super(NotebookSettingsDialog, self).__init__(parent)
#widgets for tab 1
self.mdExts = QListWidget()
self.mjEdit = QLineEdit()
self.moveUp = QPushButton('<<')
self.moveDown = QPushButton('>>')
self.configureExtension = QPushButton(
'Edit Settings for this extension')
self.tmpdict = deepcopy(self.parent().settings.extcfg)
#widgets for tab 2
self.fExtEdit = QLineEdit()
self.attImgEdit = QLineEdit()
self.attDocEdit = QLineEdit()
# mandatory button box
self.buttonBox = QDialogButtonBox(QDialogButtonBox.Ok
| QDialogButtonBox.Cancel)
#tab panels
tabs = QTabWidget()
markupTab = QWidget()
fileExtsTab = QWidget()
tabs.addTab(markupTab, "Markdown")
tabs.addTab(fileExtsTab, "File extensions")
#initialization functions
self.initExtList()
self.mdExts.setDragDropMode(QAbstractItemView.InternalMove)
self.mjEdit.setText(self.parent().settings.mathjax)
self.attImgEdit.setText(', '.join(
self.parent().settings.attachmentImage))
self.attDocEdit.setText(', '.join(
self.parent().settings.attachmentDocument))
self.fExtEdit.setText(self.parent().settings.fileExt)
#set up tab 1
layout = QGridLayout(markupTab)
layout.addWidget(QLabel("Markdown extensions"), 0, 0, 1, 4)
layout.addWidget(self.mdExts, 1, 0, 1, 4)
layout.addWidget(self.moveUp, 2, 0, 1, 1)
layout.addWidget(self.moveDown, 2, 1, 1, 1)
layout.addWidget(self.configureExtension, 2, 2, 1, 2)
layout.addWidget(QLabel("MathJax Location"), 3, 0, 1, 1)
layout.addWidget(self.mjEdit, 3, 1, 1, 3)
#set up tab 2
layout = QGridLayout(fileExtsTab)
layout.addWidget(QLabel("Note file extension"), 0, 0, 1, 1)
layout.addWidget(QLabel("Image file extension"), 1, 0, 1, 1)
layout.addWidget(QLabel("Document file extension"), 2, 0, 1, 1)
layout.addWidget(self.fExtEdit, 0, 1, 1, 1)
layout.addWidget(self.attImgEdit, 1, 1, 1, 1)
layout.addWidget(self.attDocEdit, 2, 1, 1, 1)
#put it together
vlayout = QVBoxLayout(self)
vlayout.addWidget(tabs)
vlayout.addWidget(self.buttonBox)
#setup signal handlers
self.moveUp.clicked.connect(self.moveItemUp)
self.configureExtension.clicked.connect(self.configExt)
self.moveDown.clicked.connect(self.moveItemDown)
self.buttonBox.accepted.connect(self.accept)
self.buttonBox.rejected.connect(self.reject)
def configExt(self, checked=False, ext=None):
if ext is None:
ext = self.mdExts.currentItem().text()
cfg = self.tmpdict.get(ext, [])
dialog = NotebookExtSettingsDialog(cfg_list=cfg)
done = dialog.exec()
if done:
self.tmpdict[ext] = dialog.configToList()
def initExtList(self):
extset = set(self.parent().settings.extensions)
#for easier performance in checking
for ext in self.parent().settings.extensions:
item = QListWidgetItem(ext, self.mdExts)
item.setFlags(item.flags() | Qt.ItemIsUserCheckable)
item.setCheckState(Qt.Checked)
for ext in self.parent().settings.faulty_exts:
item = QListWidgetItem(ext, self.mdExts)
item.setFlags(item.flags() | Qt.ItemIsUserCheckable)
item.setBackground(QBrush(QColor('red')))
item.setForeground(QBrush(QColor('black')))
item.setCheckState(Qt.Checked)
for ext in allMDExtensions():
if ext in extset: continue
item = QListWidgetItem(ext, self.mdExts)
item.setFlags(item.flags() | Qt.ItemIsUserCheckable)
item.setCheckState(Qt.Unchecked)
#self.mdExts.addItem(item)
def moveItemUp(self):
item = self.mdExts.currentItem()
row = self.mdExts.currentRow()
if row != 0:
# self.mdExts.removeItemWidget(item)
self.mdExts.takeItem(row)
self.mdExts.insertItem(row - 1, item)
self.mdExts.setCurrentRow(row - 1)
def moveItemDown(self):
item = self.mdExts.currentItem()
row = self.mdExts.currentRow()
count = self.mdExts.count()
if row != count - 1:
self.mdExts.takeItem(row)
self.mdExts.insertItem(row + 1, item)
self.mdExts.setCurrentRow(row + 1)
def accept(self):
#write to settings first
msettings = self.parent().settings
nbsettings = msettings.qsettings
nbsettings.setValue('mathJax', self.mjEdit.text())
extlist = []
for i in range(self.mdExts.count()):
item = self.mdExts.item(i)
if item.checkState() == Qt.Checked:
extlist.append(item.text())
writeListToSettings(nbsettings, 'extensions', extlist)
writeListToSettings(nbsettings, 'attachmentImage',
self.attImgEdit.text().split(", "))
writeListToSettings(nbsettings, 'attachmentDocument',
self.attDocEdit.text().split(", "))
writeDictToSettings(nbsettings, 'extensionsConfig', self.tmpdict)
#then to memory
msettings.extensions = extlist
msettings.mathjax = self.mjEdit.text()
msettings.attachmentDocument = readListFromSettings(
nbsettings, 'attachmentDocument')
msettings.attachmentImage = readListFromSettings(
nbsettings, 'attachmentImage')
msettings.extcfg.update(self.tmpdict)
msettings.md = markdown.Markdown(msettings.extensions,
extension_configs=msettings.extcfg)
#then make mikidown use these settings NOW
curitem = self.parent().notesTree.currentItem()
self.parent().currentItemChangedWrapper(curitem, curitem)
QDialog.accept(self)
class PathManager(QDialog):
def __init__(self, parent=None, pathlist=None):
QDialog.__init__(self, parent)
assert isinstance(pathlist, list)
self.pathlist = pathlist
self.last_path = os.getcwdu()
self.setWindowTitle(self.tr("Path manager"))
self.resize(500, 300)
self.selection_widgets = []
layout = QVBoxLayout()
self.setLayout(layout)
top_layout = QHBoxLayout()
layout.addLayout(top_layout)
self.toolbar_widgets1 = self.setup_top_toolbar(top_layout)
self.listwidget = QListWidget(self)
self.connect(self.listwidget, SIGNAL("currentRowChanged(int)"),
self.refresh)
layout.addWidget(self.listwidget)
bottom_layout = QHBoxLayout()
layout.addLayout(bottom_layout)
self.toolbar_widgets2 = self.setup_bottom_toolbar(bottom_layout)
# Buttons configuration
bbox = QDialogButtonBox(QDialogButtonBox.Close)
self.connect(bbox, SIGNAL("rejected()"), SLOT("reject()"))
bottom_layout.addWidget(bbox)
self.update_list()
self.refresh()
def _add_widgets_to_layout(self, layout, widgets):
layout.setAlignment(Qt.AlignLeft)
for widget in widgets:
layout.addWidget(widget)
def setup_top_toolbar(self, layout):
toolbar = []
movetop_button = create_toolbutton(self,
text=self.tr("Move to top"),
icon=get_icon('2uparrow.png'),
triggered=lambda: self.move_to(absolute=0))
toolbar.append(movetop_button)
moveup_button = create_toolbutton(self,
text=self.tr("Move up"),
icon=get_icon('1uparrow.png'),
triggered=lambda: self.move_to(relative=-1))
toolbar.append(moveup_button)
movedown_button = create_toolbutton(self,
text=self.tr("Move down"),
icon=get_icon('1downarrow.png'),
triggered=lambda: self.move_to(relative=1))
toolbar.append(movedown_button)
movebottom_button = create_toolbutton(self,
text=self.tr("Move to bottom"),
icon=get_icon('2downarrow.png'),
triggered=lambda: self.move_to(absolute=1))
toolbar.append(movebottom_button)
self.selection_widgets.extend(toolbar)
self._add_widgets_to_layout(layout, toolbar)
return toolbar
def setup_bottom_toolbar(self, layout):
toolbar = []
add_button = create_toolbutton(self, text=self.tr("Add path"),
icon=get_icon('edit_add.png'),
triggered=self.add_path)
toolbar.append(add_button)
remove_button = create_toolbutton(self, text=self.tr("Remove path"),
icon=get_icon('edit_remove.png'),
triggered=self.remove_path)
toolbar.append(remove_button)
self.selection_widgets.append(remove_button)
self._add_widgets_to_layout(layout, toolbar)
layout.addStretch(1)
if os.name == 'nt':
self.sync_button = create_toolbutton(self,
text=self.tr("Synchronize..."),
icon=get_icon('synchronize.png'), triggered=self.synchronize,
tip=self.tr("Synchronize Spyder's path list with PYTHONPATH "
"environment variable"))
layout.addWidget(self.sync_button)
return toolbar
def synchronize(self):
"""
Synchronize Spyder's path list with PYTHONPATH environment variable
Only apply to: current user, on Windows platforms
"""
answer = QMessageBox.question(self, self.tr("Synchronize"),
self.tr("This will synchronize Spyder's path list with "
"<b>PYTHONPATH</b> environment variable for current user, "
"allowing you to run your Python modules outside Spyder "
"without having to configure sys.path. "
"<br>Do you want to clear contents of PYTHONPATH before "
"adding Spyder's path list?"),
QMessageBox.Yes | QMessageBox.No | QMessageBox.Cancel)
if answer == QMessageBox.Cancel:
return
elif answer == QMessageBox.Yes:
remove = True
else:
remove = False
from spyderlib.utils.environ import (get_user_env, set_user_env,
listdict2envdict)
env = get_user_env()
if remove:
ppath = self.pathlist
else:
ppath = env.get('PYTHONPATH', [])
if not isinstance(ppath, list):
ppath = [ppath]
ppath = [path for path in ppath if path not in self.pathlist]
ppath.extend(self.pathlist)
env['PYTHONPATH'] = ppath
set_user_env( listdict2envdict(env) )
def get_path_list(self):
"""Return path list"""
return self.pathlist
def update_list(self):
"""Update path list"""
self.listwidget.clear()
for name in self.pathlist:
item = QListWidgetItem(name)
item.setIcon(get_std_icon('DirClosedIcon'))
self.listwidget.addItem(item)
self.refresh()
def refresh(self, row=None):
"""Refresh widget"""
for widget in self.selection_widgets:
widget.setEnabled(self.listwidget.currentItem() is not None)
not_empty = self.listwidget.count() > 0
if os.name == 'nt':
self.sync_button.setEnabled(not_empty)
def move_to(self, absolute=None, relative=None):
index = self.listwidget.currentRow()
if absolute is not None:
if absolute:
new_index = len(self.pathlist)-1
else:
new_index = 0
else:
new_index = index + relative
new_index = max(0, min(len(self.pathlist)-1, new_index))
path = self.pathlist.pop(index)
self.pathlist.insert(new_index, path)
self.update_list()
self.listwidget.setCurrentRow(new_index)
def remove_path(self):
answer = QMessageBox.warning(self, self.tr("Remove path"),
self.tr("Do you really want to remove selected path?"),
QMessageBox.Yes | QMessageBox.No)
if answer == QMessageBox.Yes:
self.pathlist.pop(self.listwidget.currentRow())
self.update_list()
def add_path(self):
self.emit(SIGNAL('redirect_stdio(bool)'), False)
directory = QFileDialog.getExistingDirectory(self,
self.tr("Select directory"), self.last_path)
self.emit(SIGNAL('redirect_stdio(bool)'), True)
if not directory.isEmpty():
directory = osp.abspath(unicode(directory))
self.last_path = directory
if directory in self.pathlist:
answer = QMessageBox.question(self, self.tr("Add path"),
self.tr("This directory is already included in Spyder path "
"list.<br>Do you want to move it to the top of "
"the list?"),
QMessageBox.Yes | QMessageBox.No)
if answer == QMessageBox.Yes:
self.pathlist.remove(directory)
else:
return
self.pathlist.insert(0, directory)
self.update_list()
class ProfilesLoader(QDialog):
def __init__(self,
load_func,
create_func,
save_func,
profiles,
parent=None):
QDialog.__init__(self, parent, Qt.Dialog)
self.setWindowTitle(self.tr("Profile Manager"))
self.setMinimumWidth(400)
self._profiles = profiles
self.load_function = load_func
self.create_function = create_func
self.save_function = save_func
self.ide = parent
vbox = QVBoxLayout(self)
vbox.addWidget(
QLabel(
self.tr("Save your opened files and projects "
"into a profile and change really quick\n"
"between projects and files sessions.\n"
"This allows you to save your working environment, "
"keep working in another\nproject and then go back "
"exactly where you left.")))
self.profileList = QListWidget()
self.profileList.addItems([key for key in profiles])
self.profileList.setCurrentRow(0)
self.contentList = QListWidget()
self.btnDelete = QPushButton(self.tr("Delete Profile"))
self.btnDelete.setSizePolicy(QSizePolicy.Fixed, QSizePolicy.Fixed)
self.btnUpdate = QPushButton(self.tr("Update Profile"))
self.btnUpdate.setSizePolicy(QSizePolicy.Fixed, QSizePolicy.Fixed)
self.btnCreate = QPushButton(self.tr("Create New Profile"))
self.btnCreate.setSizePolicy(QSizePolicy.Fixed, QSizePolicy.Fixed)
self.btnOpen = QPushButton(self.tr("Open Profile"))
self.btnOpen.setSizePolicy(QSizePolicy.Fixed, QSizePolicy.Fixed)
self.btnOpen.setDefault(True)
hbox = QHBoxLayout()
hbox.addWidget(self.btnDelete)
hbox.addWidget(self.btnUpdate)
hbox.addWidget(self.btnCreate)
hbox.addWidget(self.btnOpen)
vbox.addWidget(self.profileList)
vbox.addWidget(self.contentList)
vbox.addLayout(hbox)
self.connect(self.profileList, SIGNAL("itemSelectionChanged()"),
self.load_profile_content)
self.connect(self.btnOpen, SIGNAL("clicked()"), self.open_profile)
self.connect(self.btnUpdate, SIGNAL("clicked()"), self.save_profile)
self.connect(self.btnCreate, SIGNAL("clicked()"), self.create_profile)
self.connect(self.btnDelete, SIGNAL("clicked()"), self.delete_profile)
def load_profile_content(self):
item = self.profileList.currentItem()
self.contentList.clear()
if item is not None:
key = item.text()
files = [self.tr('Files:')] + \
[file[0] for file in self._profiles[key][0]]
projects = [self.tr('Projects:')] + self._profiles[key][1]
content = files + projects
self.contentList.addItems(content)
def create_profile(self):
profileName = self.create_function()
self.ide.Profile = profileName
self.close()
def save_profile(self):
if self.profileList.currentItem():
profileName = self.profileList.currentItem().text()
self.save_function(profileName)
self.ide.show_status_message(
self.tr("Profile %s Updated!" % profileName))
self.load_profile_content()
def open_profile(self):
if self.profileList.currentItem():
key = self.profileList.currentItem().text()
self.load_function(key)
self.ide.Profile = key
self.close()
def delete_profile(self):
if self.profileList.currentItem():
key = self.profileList.currentItem().text()
self._profiles.pop(key)
self.profileList.takeItem(self.profileList.currentRow())
self.contentList.clear()
class ConfigDialog(QDialog):
def __init__(self, parent=None):
QDialog.__init__(self, parent)
self.contents_widget = QListWidget()
self.contents_widget.setMovement(QListView.Static)
self.contents_widget.setMinimumWidth(120)
self.contents_widget.setMaximumWidth(120)
self.contents_widget.setSpacing(1)
bbox = QDialogButtonBox(QDialogButtonBox.Ok | QDialogButtonBox.Apply
| QDialogButtonBox.Cancel)
self.apply_btn = bbox.button(QDialogButtonBox.Apply)
self.connect(bbox, SIGNAL("accepted()"), SLOT("accept()"))
self.connect(bbox, SIGNAL("rejected()"), SLOT("reject()"))
self.connect(bbox, SIGNAL("clicked(QAbstractButton*)"),
self.button_clicked)
self.pages_widget = QStackedWidget()
self.connect(self.pages_widget, SIGNAL("currentChanged(int)"),
self.current_page_changed)
self.connect(self.contents_widget, SIGNAL("currentRowChanged(int)"),
self.pages_widget.setCurrentIndex)
self.contents_widget.setCurrentRow(0)
hlayout = QHBoxLayout()
hlayout.addWidget(self.contents_widget)
hlayout.addWidget(self.pages_widget)
hlayout.setStretch(1, 1)
btnlayout = QHBoxLayout()
btnlayout.addStretch(1)
btnlayout.addWidget(bbox)
vlayout = QVBoxLayout()
vlayout.addLayout(hlayout)
vlayout.addLayout(btnlayout)
self.setLayout(vlayout)
self.setWindowTitle("Preferences")
self.setWindowIcon(get_icon("configure.png"))
def get_current_index(self):
"""Return current page index"""
return self.contents_widget.currentRow()
def set_current_index(self, index):
"""Set current page index"""
self.contents_widget.setCurrentRow(index)
def accept(self):
"""Reimplement Qt method"""
for index in range(self.pages_widget.count()):
configpage = self.pages_widget.widget(index)
if not configpage.is_valid():
return
configpage.apply_changes()
QDialog.accept(self)
def button_clicked(self, button):
if button is self.apply_btn:
# Apply button was clicked
configpage = self.pages_widget.currentWidget()
if not configpage.is_valid():
return
configpage.apply_changes()
def current_page_changed(self, index):
widget = self.pages_widget.widget(index)
self.apply_btn.setVisible(widget.apply_callback is not None)
self.apply_btn.setEnabled(widget.is_modified)
def add_page(self, widget):
self.connect(self, SIGNAL('check_settings()'), widget.check_settings)
self.connect(widget,
SIGNAL('show_this_page()'),
lambda row=self.contents_widget.count(): self.
contents_widget.setCurrentRow(row))
self.connect(widget, SIGNAL("apply_button_enabled(bool)"),
self.apply_btn.setEnabled)
self.pages_widget.addWidget(widget)
item = QListWidgetItem(self.contents_widget)
item.setIcon(widget.get_icon())
item.setText(widget.get_name())
item.setFlags(Qt.ItemIsSelectable | Qt.ItemIsEnabled)
item.setSizeHint(QSize(0, 25))
def check_all_settings(self):
"""This method is called to check all configuration page settings
after configuration dialog has been shown"""
self.emit(SIGNAL('check_settings()'))
class HDFWidget(QWidget):
def __init__(self, parent=None):
super(HDFWidget, self).__init__(parent=parent)
self.parent = parent
self.main_layout = QVBoxLayout()
### Select Dataset and properties ###
self.layout = QHBoxLayout()
self.list = QListWidget()
self.textBox = QTextEdit()
self.textBox.resize(200, 200)
### Add button ###
self.button = QPushButton("Apply")
self.main_layout.addLayout(self.layout)
self.main_layout.addWidget(self.button)
self.setLayout(self.main_layout)
self.layout.addWidget(self.list)
self.layout.addWidget(self.textBox)
### Variables ###
self.settings = None
self.list.itemClicked.connect(self.item_clicked)
self.connect(self.button, QtCore.SIGNAL("clicked()"),
self.apply_settings)
def item_clicked(self, item):
"""Action triggered when an item is clicked. The content of the metadata is retrieved from its index and not from the file itself, avoiding clashes with the main program. """
i = self.list.currentRow()
self.settings = self.all_settings[i]
self.textBox.clear()
self.textBox.setText(self.settings)
# mdd = self.settings.split('\n')
# for t in mdd:
# self.textBox.append(t)
def add_items(self, name):
""" Adds the group items to the display.
The file is closed after extracting the metadata, to avoid conflicts with the main program.
:param name: Name of the HDF file to be opened.
:return: Null
"""
f = h5py.File(name, 'r')
self.settings = None
self.all_settings = []
self.list.clear()
for g in f:
self.all_settings.append(f[g + '/metadata'][()].decode('ascii'))
self.list.addItem(g)
f.close()
def apply_settings(self):
""" Triggered when the apply button is pressed. The settings are broadcasted as coming from the parent.
"""
if self.settings is not None:
self.parent.emit(QtCore.SIGNAL('settings'), self.settings)
class AutoComplete(PopupWidget):
def init_popup(self):
self.list = QListWidget(self)
self.connect(self.list, SIGNAL("itemClicked(QListWidgetItem*)"),
self.insertItem)
self.layout().addWidget(self.list)
self.items = []
def insertItem(self, item):
self.insert()
def insert(self):
completion = self.items[self.list.currentRow()].value
cursor = self.textedit.textCursor()
col = cursor.columnNumber()
line = unicode(cursor.block().text())
i = self.cursor_start_col
while i > 0:
#print `line[i:col]`
if completion.startswith(line[i:col]):
#print "break"
break
i -= 1
#print col,i
cursor.insertText(completion[col - i:])
self.hide()
def setItems(self, proposals):
proposals = sorted(proposals, cmp=lambda p1, p2: cmp(p1.name, p2.name))
del self.items[:]
self.list.clear()
for entry in proposals:
i = AutoCompleteItem(entry)
self.list.addItem(i)
self.items.append(i)
def keyPressEvent(self, event):
self.list.keyPressEvent(event)
key = event.key()
text = event.text()
if key in [Qt.Key_Right, Qt.Key_Enter, Qt.Key_Return]:
text = ""
cursor = self.textedit.textCursor()
line = unicode(cursor.block().text())
col = cursor.columnNumber()
prefix = line[self.cursor_start_col:col] + unicode(text)
found = False
for row, item in enumerate(self.items):
if item.value.startswith(prefix):
current = self.items[self.list.currentRow()].value
if not current.startswith(prefix):
self.list.setCurrentRow(row)
found = True
break
if not found:
self.hide()
return
if key in [Qt.Key_Up, Qt.Key_Down, Qt.Key_PageUp, Qt.Key_PageDown]:
return True
elif key in [Qt.Key_Tab, Qt.Key_Right, Qt.Key_Enter, Qt.Key_Return]:
self.insert()
return True
elif not text:
self.hide()
class ConfigDialog(QDialog):
def __init__(self, parent=None):
QDialog.__init__(self, parent)
self.contents_widget = QListWidget()
self.contents_widget.setMovement(QListView.Static)
self.contents_widget.setMinimumWidth(120)
self.contents_widget.setMaximumWidth(120)
self.contents_widget.setSpacing(1)
bbox = QDialogButtonBox(QDialogButtonBox.Ok|QDialogButtonBox.Apply
|QDialogButtonBox.Cancel)
self.apply_btn = bbox.button(QDialogButtonBox.Apply)
self.connect(bbox, SIGNAL("accepted()"), SLOT("accept()"))
self.connect(bbox, SIGNAL("rejected()"), SLOT("reject()"))
self.connect(bbox, SIGNAL("clicked(QAbstractButton*)"),
self.button_clicked)
self.pages_widget = QStackedWidget()
self.connect(self.pages_widget, SIGNAL("currentChanged(int)"),
self.current_page_changed)
self.connect(self.contents_widget, SIGNAL("currentRowChanged(int)"),
self.pages_widget.setCurrentIndex)
self.contents_widget.setCurrentRow(0)
hlayout = QHBoxLayout()
hlayout.addWidget(self.contents_widget)
hlayout.addWidget(self.pages_widget)
hlayout.setStretch(1,1)
btnlayout = QHBoxLayout()
btnlayout.addStretch(1)
btnlayout.addWidget(bbox)
vlayout = QVBoxLayout()
vlayout.addLayout(hlayout)
vlayout.addLayout(btnlayout)
self.setLayout(vlayout)
self.setWindowTitle("Preferences")
self.setWindowIcon(get_icon("configure.png"))
def get_current_index(self):
"""Return current page index"""
return self.contents_widget.currentRow()
def set_current_index(self, index):
"""Set current page index"""
self.contents_widget.setCurrentRow(index)
def accept(self):
"""Reimplement Qt method"""
for index in range(self.pages_widget.count()):
configpage = self.pages_widget.widget(index)
if not configpage.is_valid():
return
configpage.apply_changes()
QDialog.accept(self)
def button_clicked(self, button):
if button is self.apply_btn:
# Apply button was clicked
configpage = self.pages_widget.currentWidget()
if not configpage.is_valid():
return
configpage.apply_changes()
def current_page_changed(self, index):
widget = self.pages_widget.widget(index)
self.apply_btn.setVisible(widget.apply_callback is not None)
self.apply_btn.setEnabled(widget.is_modified)
def add_page(self, widget):
self.connect(self, SIGNAL('check_settings()'), widget.check_settings)
self.connect(widget, SIGNAL('show_this_page()'),
lambda row=self.contents_widget.count():
self.contents_widget.setCurrentRow(row))
self.connect(widget, SIGNAL("apply_button_enabled(bool)"),
self.apply_btn.setEnabled)
self.pages_widget.addWidget(widget)
item = QListWidgetItem(self.contents_widget)
item.setIcon(widget.get_icon())
item.setText(widget.get_name())
item.setFlags(Qt.ItemIsSelectable|Qt.ItemIsEnabled)
item.setSizeHint(QSize(0, 25))
def check_all_settings(self):
"""This method is called to check all configuration page settings
after configuration dialog has been shown"""
self.emit(SIGNAL('check_settings()'))
class HyphenDialog(QDialog):
def __init__(self, mainwindow):
super(HyphenDialog, self).__init__(mainwindow)
self.setWindowModality(Qt.WindowModal)
layout = QVBoxLayout()
self.setLayout(layout)
self.topLabel = QLabel()
self.listWidget = QListWidget()
layout.addWidget(self.topLabel)
layout.addWidget(self.listWidget)
layout.addWidget(widgets.Separator())
self.buttons = b = QDialogButtonBox()
layout.addWidget(b)
b.setStandardButtons(QDialogButtonBox.Ok | QDialogButtonBox.Cancel)
userguide.addButton(b, "lyrics")
b.rejected.connect(self.reject)
b.accepted.connect(self.accept)
self.load()
app.translateUI(self)
qutil.saveDialogSize(self, "hyphenation/dialog/size")
def translateUI(self):
self.setWindowTitle(app.caption(_("Hyphenate Lyrics Text")))
self.topLabel.setText(_("Please select a language:"))
def load(self):
current = po.setup.current()
self._langs = [(language_names.languageName(lang, current), lang, dic)
for lang, dic in findDicts().iteritems()]
self._langs.sort()
for name, lang, dic in self._langs:
self.listWidget.addItem("{0} ({1})".format(name, lang))
def select():
lastused = settings().value("lastused", "", type(""))
if lastused:
yield lastused
lang = po.setup.preferred()[0]
yield lang
yield lang.split('_')[0]
langs = [item[1] for item in self._langs]
for preselect in select():
try:
self.listWidget.setCurrentRow(langs.index(preselect))
break
except ValueError:
continue
def hyphenator(self):
if self.exec_() and self._langs:
lang, dic = self._langs[self.listWidget.currentRow()][1:]
result = hyphenator.Hyphenator(dic)
settings().setValue("lastused", lang)
else:
result = None
self.deleteLater()
return result
class EkdConfigBox(QDialog) :
"""
EkdConfigBox permet à l'utilisateur de configurer EkdConfig
"""
def __init__(self, w=550, h=480, titre=u"Configuration de Ekd", parent=None):
super(EkdConfigBox, self).__init__(parent)
self.resize(w,h)
self.w = w
self.h = h
self.setWindowTitle(titre)
self.layout = QVBoxLayout(self)
## Menu contient l'ensemble des sections à paramétrer
self.menu = QListWidget(self)
self.layout.addWidget(self.menu)
## Pour chaque section à paramétrer, on utilise un Stack d'objets
self.leftpart = QStackedLayout()
self.leftpart.setSizeConstraint(QLayout.SetNoConstraint)
self.layout.addLayout(self.leftpart)
## propWidget contient l'ensemble des objets propriété de toutes les section
## (il est nécessaire de les stocker pour être capable de les faire interagir)
self.propWidget=[]
wid = 0
## On crée les différentes parties de configuration qui ne sont pas inclues dans le tableau SECTION_MASK de EkdConfig
for section in EkdConfig.SECTIONS :
if not section in EkdConfig.SECTION_MASK :
self.menu.addItem(EkdConfig.SECTIONS[section])
allprops = EkdConfig.getAllProperties(EkdConfig.getConfigSection(section))
scroll = QScrollArea()
frame = QFrame()
frame.setMinimumSize(self.w-50, self.h/2) # Ajouté le 10/12/2009 Pour que la partie réglage prenne toute la place dispo.
frame.setMaximumSize(self.w, self.h)
linelayout = QGridLayout(frame)
linelayout.setSizeConstraint(QLayout.SetMinAndMaxSize)
row = 0
## Insertion des propriété de la section en fonction de son type
allkeys = allprops.keys()
found = False
for prop in allkeys :
if not prop in EkdConfig.PROPERTIES_MASK :
if prop in EkdConfig.PATH_PROPERTIES :
self.propWidget.append( EkdPathPropertie(prop, EkdConfig.PROPERTIES[prop], allprops[prop], section=section) )
linelayout.addWidget(self.propWidget[wid].label, row, 0)
linelayout.addWidget(self.propWidget[wid].widget, row, 1)
wid += 1
found = True
row += 1
for prop in allkeys :
if not prop in EkdConfig.PROPERTIES_MASK :
if prop in EkdConfig.STYLE_PROPERTIES :
self.propWidget.append( EkdStylePropertie(prop, EkdConfig.PROPERTIES[prop], allprops[prop], EkdConfig.STYLE_PROPERTIES[prop], section=section ) )
linelayout.addWidget(self.propWidget[wid].label, row, 0)
linelayout.addWidget(self.propWidget[wid].widget, row, 1)
wid += 1
found = True
row += 1
for prop in allkeys :
if not prop in EkdConfig.PROPERTIES_MASK :
if prop in EkdConfig.CODEC_PROPERTIES :
self.propWidget.append( EkdCodecPropertie(prop, EkdConfig.PROPERTIES[prop], allprops[prop], EkdConfig.CODEC_PROPERTIES[prop], section=section ) )
linelayout.addWidget(self.propWidget[wid].label, row, 0)
linelayout.addWidget(self.propWidget[wid].widget, row, 1)
wid += 1
found = True
row += 1
for prop in allkeys :
if not prop in EkdConfig.PROPERTIES_MASK :
if prop in EkdConfig.BOOLEAN_PROPERTIES :
self.propWidget.append( EkdBoolPropertie(prop, EkdConfig.PROPERTIES[prop], allprops[prop], section=section) )
linelayout.addWidget(self.propWidget[wid].widget, row, 0, 1, 2)
wid += 1
found = True
row += 1
for prop in allkeys :
if not prop in EkdConfig.PROPERTIES_MASK :
if prop in EkdConfig.NUM_PROPERTIES :
self.propWidget.append( EkdNumPropertie(prop, EkdConfig.PROPERTIES[prop], allprops[prop], section=section) )
linelayout.addWidget(self.propWidget[wid].label, row, 0)
linelayout.addWidget(self.propWidget[wid].widget, row, 1)
wid += 1
found = True
row += 1
for prop in allkeys :
if not prop in EkdConfig.PROPERTIES_MASK :
if prop in EkdConfig.TIME_PROPERTIES :
self.propWidget.append( EkdTimePropertie(prop, EkdConfig.PROPERTIES[prop], allprops[prop], section=section) )
linelayout.addWidget(self.propWidget[wid].label, row, 0)
linelayout.addWidget(self.propWidget[wid].widget, row, 1)
wid += 1
found = True
row += 1
for prop in allkeys :
if not prop in EkdConfig.PROPERTIES_MASK :
if prop in EkdConfig.COLOR_PROPERTIES :
self.propWidget.append( EkdColorPropertie(prop, EkdConfig.PROPERTIES[prop], allprops[prop], section=section) )
linelayout.addWidget(self.propWidget[wid].label, row, 0)
linelayout.addWidget(self.propWidget[wid].widget, row, 1)
wid += 1
found = True
elif not found:
line = QLineEdit(allprops[prop])
linelayout.addWidget(QLabel(prop), row, 0)
linelayout.addWidget(line, row, 1)
row += 1
frame.setLineWidth(0)
scroll.setWidget(frame)
self.leftpart.addWidget(scroll)
self.menu.setAlternatingRowColors(True)
# Define the size of the list depending of its content
self.menu.setFixedHeight(( self.menu.sizeHintForRow(0) + self.menu.verticalStepsPerItem() + 1)* self.menu.count())
self.menu.updateGeometries()
## Boutton pour fermer la boite de dialogue
self.fermer = QPushButton(_(u"Fermer"))
self.layout.addWidget(self.fermer)
## Lorsqu'on clique sur fermer, la fenêtre se ferme
self.connect(self.fermer, SIGNAL("clicked()"), self.close)
## Lorsqu'on selectionne un élément du menu, on met à jour la partie droite du menu
self.connect(self.menu, SIGNAL("currentItemChanged(QListWidgetItem *,QListWidgetItem *)"), self.updateMenu)
def updateMenu(self):
propriete = self.menu.currentRow()
self.leftpart.setCurrentIndex(propriete)
class Img2GifWidget(QDialog):
AppName = u"GIF生成工具"
def __init__(self, parent=None):
super(Img2GifWidget, self).__init__(parent)
self.setWindowTitle(Img2GifWidget.AppName)
self.listWidget = QListWidget()
self.listWidget.setMinimumSize(400, 300)
self.btnAdd = QPushButton("&Add")
self.btnUp = QPushButton("&Up")
self.btnDown = QPushButton("&Down")
self.btnDel = QPushButton("&Delete")
self.btnClear = QPushButton("&Clear")
topLeftLay = QVBoxLayout()
topLeftLay.addWidget(self.btnAdd)
topLeftLay.addWidget(self.btnUp)
topLeftLay.addWidget(self.btnDown)
topLeftLay.addWidget(self.btnDel)
topLeftLay.addWidget(self.btnClear)
topLeftLay.addStretch()
topLay = QHBoxLayout()
topLay.addWidget(self.listWidget)
topLay.addLayout(topLeftLay)
label = QLabel(u"Gif文件路径：")
self.txtGifPath = QLineEdit()
self.btnBrowser = QPushButton('...')
midLay = QHBoxLayout()
midLay.addWidget(label)
midLay.addWidget(self.txtGifPath)
midLay.addWidget(self.btnBrowser)
timeLabel = QLabel(u"时间间隔：")
self.spbTime = QDoubleSpinBox()
self.spbTime.setRange(0.001, 10)
self.spbTime.setSingleStep(0.001)
self.spbTime.setValue(1)
self.spbTime.setSuffix('s')
loopLabel = QLabel(u"循环：")
self.spbLoop = QDoubleSpinBox()
self.spbLoop = QSpinBox()
self.spbLoop.setRange(0, 1000)
self.spbLoop.setSingleStep(1)
self.spbLoop.setValue(0)
self.spbLoop.setToolTip(u"0次循环表示永久循环")
self.spbLoop.setSuffix(u"次")
self.btnBox = QDialogButtonBox(QDialogButtonBox.Ok | QDialogButtonBox.Cancel)
bottomLay = QHBoxLayout()
bottomLay.addWidget(timeLabel)
bottomLay.addWidget(self.spbTime)
bottomLay.addWidget(loopLabel)
bottomLay.addWidget(self.spbLoop)
bottomLay.addStretch()
bottomLay.addWidget(self.btnBox)
mainLay = QVBoxLayout()
mainLay.addLayout(topLay)
mainLay.addLayout(midLay)
mainLay.addLayout(bottomLay)
self.setLayout(mainLay)
self.btnAdd.clicked.connect(self.itemAdd)
self.btnUp.clicked.connect(self.itemUp)
self.btnDown.clicked.connect(self.itemDown)
self.btnDel.clicked.connect(self.itemDel)
self.btnClear.clicked.connect(self.listWidget.clear)
self.btnBrowser.clicked.connect(self.setGifPath)
self.btnBox.rejected.connect(self.close)
self.btnBox.accepted.connect(self.makeGif)
self.txtGifPath.returnPressed.connect(self.updateGifPath)
def itemAdd(self):
fileNames = QFileDialog.getOpenFileNames(None, u"{0} -- {1}".format(qApp.applicationName(), Img2GifWidget.AppName),
'.', u'所有文件(*.*);;BMP文件(*.bmp);;PNG文件(*.png);;JPG文件(*.jpg *.jpeg)')
for fn in fileNames:
f = QFileInfo(fn)
if unicode(f.suffix().toLower()) in ['jpg', 'png', 'bmp', 'jpeg']:
self.listWidget.addItem(fn)
def itemUp(self):
row = self.listWidget.currentRow()
if row <= 0:
return
item = self.listWidget.currentItem()
self.listWidget.takeItem(row)
self.listWidget.insertItem(row - 1, item)
self.listWidget.setCurrentRow(row - 1)
def itemDown(self):
rows = self.listWidget.count()
row = self.listWidget.currentRow()
if (row < 0) or (row == rows - 1):
return
item = self.listWidget.currentItem()
self.listWidget.takeItem(row)
self.listWidget.insertItem(row + 1, item)
self.listWidget.setCurrentRow(row + 1)
def itemDel(self):
row = self.listWidget.currentRow()
if row >= 0:
self.listWidget.takeItem(row)
def setGifPath(self):
filename = QFileDialog.getSaveFileName(self, u"{0} -- {1}".format(qApp.applicationName(), Img2GifWidget.AppName),
".", "Gif(*.gif)")
self.txtGifPath.setText(filename)
def updateGifPath(self):
fileName = self.txtGifPath.text()
f = QFileInfo(fileName)
if f.dir().exists and not f.baseName().isEmpty() and not f.suffix().isEmpty():
self.txtGifPath.setText(fileName)
return True
else:
QMessageBox.warning(self, u"{0} -- warning".format(Img2GifWidget.AppName),
u"要生成的GIF存储路径{0}不是有效的GIF文件".format(unicode(fileName)))
return False
def makeGif(self):
imgs = [unicode(self.listWidget.item(i).text()) for i in range(self.listWidget.count())]
if len(imgs) <= 1:
QMessageBox.warning(self, u"{0} - {1}".format(qApp.applicationName(), Img2GifWidget.AppName),
u"GIF动画文件必须要给定大于一张图片。")
return
if not self.updateGifPath():
return
durations = self.spbTime.value()
loops = self.spbLoop.value()
ok, msg = img2gif.images2gif(imgs, self.txtGifPath.text(), durations=durations, loops=loops)
if ok:
QMessageBox.about(self, u"{0} - {1}".format(qApp.applicationName(), Img2GifWidget.AppName),
u"Succeed!\n{0}".format(msg))
qApp.processEvents()
else:
QMessageBox.about(u"{0} - {1}".format(qApp.applicationName(), Img2GifWidget.AppName),
u"sorry! Failed to generate the {0}".format(unicode(self.txtGifPath)))
class ProfilesLoader(QDialog):
def __init__(self, load_func, create_func, save_func,
profiles, parent=None):
QDialog.__init__(self, parent, Qt.Dialog)
self.setWindowTitle(self.tr("Profile Manager"))
self.setMinimumWidth(400)
self._profiles = profiles
self.load_function = load_func
self.create_function = create_func
self.save_function = save_func
self.ide = parent
vbox = QVBoxLayout(self)
vbox.addWidget(QLabel(self.tr("Save your opened files and projects "
"into a profile and change really quick\n"
"between projects and files sessions.\n"
"This allows you to save your working environment, "
"keep working in another\nproject and then go back "
"exactly where you left.")))
self.profileList = QListWidget()
self.profileList.addItems([key for key in profiles])
self.profileList.setCurrentRow(0)
self.contentList = QListWidget()
self.btnDelete = QPushButton(self.tr("Delete Profile"))
self.btnDelete.setSizePolicy(QSizePolicy.Fixed, QSizePolicy.Fixed)
self.btnUpdate = QPushButton(self.tr("Update Profile"))
self.btnUpdate.setSizePolicy(QSizePolicy.Fixed, QSizePolicy.Fixed)
self.btnCreate = QPushButton(self.tr("Create New Profile"))
self.btnCreate.setSizePolicy(QSizePolicy.Fixed, QSizePolicy.Fixed)
self.btnOpen = QPushButton(self.tr("Open Profile"))
self.btnOpen.setSizePolicy(QSizePolicy.Fixed, QSizePolicy.Fixed)
self.btnOpen.setDefault(True)
hbox = QHBoxLayout()
hbox.addWidget(self.btnDelete)
hbox.addWidget(self.btnUpdate)
hbox.addWidget(self.btnCreate)
hbox.addWidget(self.btnOpen)
vbox.addWidget(self.profileList)
vbox.addWidget(self.contentList)
vbox.addLayout(hbox)
self.connect(self.profileList, SIGNAL("itemSelectionChanged()"),
self.load_profile_content)
self.connect(self.btnOpen, SIGNAL("clicked()"), self.open_profile)
self.connect(self.btnUpdate, SIGNAL("clicked()"), self.save_profile)
self.connect(self.btnCreate, SIGNAL("clicked()"), self.create_profile)
self.connect(self.btnDelete, SIGNAL("clicked()"), self.delete_profile)
def load_profile_content(self):
item = self.profileList.currentItem()
self.contentList.clear()
if item is not None:
key = unicode(item.text())
files = [self.tr('Files:')] + \
[file[0] for file in self._profiles[key][0]]
projects = [self.tr('Projects:')] + self._profiles[key][1]
content = files + projects
self.contentList.addItems(content)
def create_profile(self):
profileName = self.create_function()
self.ide.Profile = profileName
self.close()
def save_profile(self):
if self.profileList.currentItem():
profileName = unicode(self.profileList.currentItem().text())
self.save_function(profileName)
self.ide.show_status_message(self.tr("Profile %1 Updated!").arg(
profileName))
self.load_profile_content()
def open_profile(self):
if self.profileList.currentItem():
key = unicode(self.profileList.currentItem().text())
self.load_function(key)
self.ide.Profile = key
self.close()
def delete_profile(self):
if self.profileList.currentItem():
key = unicode(self.profileList.currentItem().text())
self._profiles.pop(key)
self.profileList.takeItem(self.profileList.currentRow())
self.contentList.clear()
class StringListDlg(QDialog):
acceptedList = Signal(QStringList)
def __init__(self, name, stringlist=None, parent=None):
super(StringListDlg, self).__init__(parent)
self.name = name
self.create_widgets(stringlist)
self.layout_widgets()
self.setWindowTitle("Edit {0} List".format(self.name))
def create_widgets(self, stringlist):
self.listWidget = QListWidget()
if stringlist is not None:
self.listWidget.addItems(stringlist)
self.listWidget.setCurrentRow(0)
def layout_widgets(self):
buttonLayout = QVBoxLayout()
for text, slot in (("&Add...", self.add), ("&Edit...", self.edit),
("&Remove...", self.remove), ("&Up", self.up),
("&Down", self.down), ("&Sort",
self.listWidget.sortItems),
("Close", self.accept)):
button = QPushButton(text)
if not MAC:
button.setFocusPolicy(Qt.NoFocus)
if text == "Close":
buttonLayout.addStretch()
buttonLayout.addWidget(button)
button.clicked.connect(slot)
layout = QHBoxLayout()
layout.addWidget(self.listWidget)
layout.addLayout(buttonLayout)
self.setLayout(layout)
def add(self):
row = self.listWidget.currentRow()
title = "Add {0}".format(self.name)
string, ok = QInputDialog.getText(self, title, title)
if ok and not string.isEmpty():
self.listWidget.insertItem(row, string)
def edit(self):
row = self.listWidget.currentRow()
item = self.listWidget.item(row)
if item is not None:
title = "Edit {0}".format(self.name)
string, ok = QInputDialog.getText(self, title, title,
QLineEdit.Normal, item.text())
if ok and not string.isEmpty():
item.setText(string)
def remove(self):
row = self.listWidget.currentRow()
item = self.listWidget.item(row)
if item is None:
return
reply = QMessageBox.question(
self, "Remove {0}".format(self.name),
"Remove {0} `{1}'?".format(self.name, unicode(item.text())),
QMessageBox.Yes | QMessageBox.No)
if reply == QMessageBox.Yes:
item = self.listWidget.takeItem(row)
del item
def up(self):
row = self.listWidget.currentRow()
if row >= 1:
item = self.listWidget.takeItem(row)
self.listWidget.insertItem(row - 1, item)
self.listWidget.setCurrentItem(item)
def down(self):
row = self.listWidget.currentRow()
if row < self.listWidget.count() - 1:
item = self.listWidget.takeItem(row)
self.listWidget.insertItem(row + 1, item)
self.listWidget.setCurrentItem(item)
def reject(self):
self.accept()
def accept(self):
self.stringlist = QStringList()
for row in range(self.listWidget.count()):
self.stringlist.append(self.listWidget.item(row).text())
self.acceptedList.emit(self.stringlist)
QDialog.accept(self)
class CodeCompletionWidget(QFrame):
def __init__(self, editor):
super(CodeCompletionWidget,
self).__init__(None, Qt.FramelessWindowHint | Qt.ToolTip)
self._editor = editor
self._revision = 0
self._block = 0
self.stack_layout = QStackedLayout(self)
self.stack_layout.setContentsMargins(0, 0, 0, 0)
self.stack_layout.setSpacing(0)
self.completion_list = QListWidget()
self.completion_list.setMinimumHeight(200)
self.completion_list.setAlternatingRowColors(True)
self._list_index = self.stack_layout.addWidget(self.completion_list)
self._icons = {
'a': resources.IMAGES['attribute'],
'f': resources.IMAGES['function'],
'c': resources.IMAGES['class'],
'm': resources.IMAGES['module']
}
self.cc = code_completion.CodeCompletion()
self._completion_results = {}
self._prefix = ''
self.setVisible(False)
self.source = ''
self._key_operations = {
Qt.Key_Up: self._select_previous_row,
Qt.Key_Down: self._select_next_row,
Qt.Key_PageUp: (lambda: self._select_previous_row(6)),
Qt.Key_PageDown: (lambda: self._select_next_row(6)),
Qt.Key_Right: lambda: None,
Qt.Key_Left: lambda: None,
Qt.Key_Enter: self.pre_key_insert_completion,
Qt.Key_Return: self.pre_key_insert_completion,
Qt.Key_Tab: self.pre_key_insert_completion,
Qt.Key_Space: self.hide_completer,
Qt.Key_Escape: self.hide_completer,
Qt.Key_Backtab: self.hide_completer,
Qt.NoModifier: self.hide_completer,
Qt.ShiftModifier: self.hide_completer,
}
self.desktop = QApplication.instance().desktop()
self.connect(self.completion_list,
SIGNAL("itemClicked(QListWidgetItem*)"),
self.pre_key_insert_completion)
self.connect(self._editor.document(),
SIGNAL("cursorPositionChanged(QTextCursor)"),
self.update_metadata)
def _select_next_row(self, move=1):
new_row = self.completion_list.currentRow() + move
if new_row < self.completion_list.count():
self.completion_list.setCurrentRow(new_row)
else:
self.completion_list.setCurrentRow(0)
return True
def _select_previous_row(self, move=1):
new_row = self.completion_list.currentRow() - move
if new_row >= 0:
self.completion_list.setCurrentRow(new_row)
else:
self.completion_list.setCurrentRow(self.completion_list.count() -
move)
return True
def update_metadata(self, cursor):
if settings.CODE_COMPLETION:
if self._editor.document().revision() != self._revision and \
cursor.block().blockNumber() != self._block:
source = self._editor.get_text()
source = source.encode(self._editor.encoding)
self.cc.analyze_file(self._editor.ID, source,
self._editor.indent, self._editor.useTabs)
self._revision = self._editor.document().revision()
self._block = cursor.block().blockNumber()
def insert_completion(self, insert, type_=ord('a')):
if insert != self._prefix:
closing = ''
if type_ in (ord('f'), ord('c')):
closing = '()'
extra = len(self._prefix) - len(insert)
insertion = '%s%s' % (insert[extra:], closing)
self._editor.textCursor().insertText(insertion)
self.hide_completer()
def _get_geometry(self):
cr = self._editor.cursorRect()
desktop_geometry = self.desktop.availableGeometry(self._editor)
point = self._editor.mapToGlobal(cr.topLeft())
cr.moveTopLeft(point)
#Check new position according desktop geometry
width = (self.completion_list.sizeHintForColumn(0) +
self.completion_list.verticalScrollBar().sizeHint().width() +
10)
height = 200
orientation = (point.y() + height) < desktop_geometry.height()
if orientation:
cr.moveTop(cr.bottom())
cr.setWidth(width)
cr.setHeight(height)
if not orientation:
cr.moveBottom(cr.top())
xpos = desktop_geometry.width() - (point.x() + width)
if xpos < 0:
cr.moveLeft(cr.left() + xpos)
return cr
def complete(self, results):
self.add_list_items(results)
self.completion_list.setCurrentRow(0)
cr = self._get_geometry()
self.setGeometry(cr)
self.completion_list.updateGeometries()
self.show()
def add_list_items(self, proposals):
self.completion_list.clear()
for p in proposals:
self.completion_list.addItem(
QListWidgetItem(QIcon(
self._icons.get(p[0], resources.IMAGES['attribute'])),
p[1],
type=ord(p[0])))
def set_completion_prefix(self, prefix, valid=True):
self._prefix = prefix
proposals = []
proposals += [('m', item)
for item in self._completion_results.get('modules', [])
if item.startswith(prefix)]
proposals += [('c', item)
for item in self._completion_results.get('classes', [])
if item.startswith(prefix)]
proposals += [
('a', item)
for item in self._completion_results.get('attributes', [])
if item.startswith(prefix)
]
proposals += [
('f', item)
for item in self._completion_results.get('functions', [])
if item.startswith(prefix)
]
if proposals and valid:
self.complete(proposals)
else:
self.hide_completer()
def _invalid_completion_position(self):
result = False
cursor = self._editor.textCursor()
cursor.movePosition(QTextCursor.StartOfLine, QTextCursor.KeepAnchor)
selection = cursor.selectedText()[:-1].split(' ')
if len(selection) == 0 or selection[-1] == '' or \
selection[-1].isdigit():
result = True
return result
def fill_completer(self, force_completion=False):
if not force_completion and (self._editor.cursor_inside_string()
or self._editor.cursor_inside_comment()
or self._invalid_completion_position()):
return
source = self._editor.get_text()
source = source.encode(self._editor.encoding)
offset = self._editor.textCursor().position()
results = self.cc.get_completion(source, offset)
self._completion_results = results
if force_completion:
cursor = self._editor.textCursor()
cursor.movePosition(QTextCursor.StartOfWord,
QTextCursor.KeepAnchor)
prefix = cursor.selectedText()
else:
prefix = self._editor._text_under_cursor()
self.set_completion_prefix(prefix)
def hide_completer(self):
self._prefix = ''
self.hide()
def pre_key_insert_completion(self):
type_ = ord('a')
current = self.completion_list.currentItem()
insert = current.text()
if not insert.endswith(')'):
type_ = current.type()
self.insert_completion(insert, type_)
self.hide_completer()
return True
def process_pre_key_event(self, event):
if not self.isVisible() or self._editor.lang != "python":
return False
skip = self._key_operations.get(event.key(), lambda: False)()
self._key_operations.get(event.modifiers(), lambda: False)()
if skip is None:
skip = False
return skip
def process_post_key_event(self, event):
if not settings.CODE_COMPLETION or self._editor.lang != "python":
return
if self.isVisible():
source = self._editor.get_text()
source = source.encode(self._editor.encoding)
offset = self._editor.textCursor().position()
prefix, valid = self.cc.get_prefix(source, offset)
self.set_completion_prefix(prefix, valid)
self.completion_list.setCurrentRow(0)
force_completion = (event.key() == Qt.Key_Space
and event.modifiers() == Qt.ControlModifier)
if event.key() == Qt.Key_Period or force_completion:
self.fill_completer(force_completion)
class FiltersDialog(Window):
def __init__(self, base):
Window.__init__(self, base, i18n.get('filters'))
self.setFixedSize(280, 360)
self.expression = QLineEdit()
self.expression.returnPressed.connect(self.__new_filter)
self.new_button = QPushButton(i18n.get('add_filter'))
self.new_button.setToolTip(i18n.get('create_a_new_filter'))
self.new_button.clicked.connect(self.__new_filter)
expression_box = QHBoxLayout()
expression_box.addWidget(self.expression)
expression_box.addWidget(self.new_button)
self.list_ = QListWidget()
self.list_.clicked.connect(self.__filter_clicked)
self.delete_button = QPushButton(i18n.get('delete'))
self.delete_button.setEnabled(False)
self.delete_button.setToolTip(i18n.get('delete_selected_filter'))
self.delete_button.clicked.connect(self.__delete_filter)
self.clear_button = QPushButton(i18n.get('delete_all'))
self.clear_button.setEnabled(False)
self.clear_button.setToolTip(i18n.get('delete_all_filters'))
self.clear_button.clicked.connect(self.__delete_all)
button_box = QHBoxLayout()
button_box.addStretch(1)
button_box.addWidget(self.clear_button)
button_box.addWidget(self.delete_button)
layout = QVBoxLayout()
layout.addLayout(expression_box)
layout.addWidget(self.list_, 1)
layout.addLayout(button_box)
layout.setSpacing(5)
layout.setContentsMargins(5, 5, 5, 5)
self.setLayout(layout)
self.__update()
self.show()
def __update(self):
row = 0
self.expression.setText('')
self.list_.clear()
for expression in self.base.core.list_filters():
self.list_.addItem(expression)
row += 1
self.__enable(True)
self.delete_button.setEnabled(False)
if row == 0:
self.clear_button.setEnabled(False)
self.expression.setFocus()
def __filter_clicked(self, point):
self.delete_button.setEnabled(True)
self.clear_button.setEnabled(True)
def __new_filter(self):
expression = str(self.expression.text())
self.list_.addItem(expression)
self.__save_filters()
def __delete_filter(self):
self.list_.takeItem(self.list_.currentRow())
self.__save_filters()
def __delete_all(self):
self.__enable(False)
message = i18n.get('clear_filters_confirm')
confirmation = self.base.show_confirmation_message(i18n.get('confirm_delete'),
message)
if not confirmation:
self.__enable(True)
return
self.list_.clear()
self.__save_filters()
def __enable(self, value):
self.list_.setEnabled(value)
self.delete_button.setEnabled(value)
self.clear_button.setEnabled(value)
def __save_filters(self):
filters = []
for i in range(self.list_.count()):
filters.append(str(self.list_.item(i).text()))
self.base.save_filters(filters)
self.__update()
class PreferencesDialog(QDialog):
def __init__(self, mainwindow):
super(PreferencesDialog, self).__init__(mainwindow)
self.setWindowModality(Qt.WindowModal)
self.addAction(mainwindow.actionCollection.help_whatsthis)
layout = QVBoxLayout()
layout.setSpacing(10)
self.setLayout(layout)
# listview to the left, stacked widget to the right
top = QHBoxLayout()
layout.addLayout(top)
self.pagelist = QListWidget(self)
self.stack = QStackedWidget(self)
top.addWidget(self.pagelist, 0)
top.addWidget(self.stack, 2)
layout.addWidget(widgets.Separator(self))
b = self.buttons = QDialogButtonBox(self)
b.setStandardButtons(
QDialogButtonBox.Ok
| QDialogButtonBox.Cancel
| QDialogButtonBox.Apply
| QDialogButtonBox.Reset
| QDialogButtonBox.Help)
layout.addWidget(b)
b.accepted.connect(self.accept)
b.rejected.connect(self.reject)
b.button(QDialogButtonBox.Apply).clicked.connect(self.saveSettings)
b.button(QDialogButtonBox.Reset).clicked.connect(self.loadSettings)
b.button(QDialogButtonBox.Help).clicked.connect(self.showHelp)
b.button(QDialogButtonBox.Help).setShortcut(QKeySequence.HelpContents)
b.button(QDialogButtonBox.Apply).setEnabled(False)
# fill the pagelist
self.pagelist.setIconSize(QSize(32, 32))
self.pagelist.setSpacing(2)
for item in pageorder():
self.pagelist.addItem(item())
self.pagelist.currentItemChanged.connect(self.slotCurrentItemChanged)
app.translateUI(self, 100)
# read our size and selected page
qutil.saveDialogSize(self, "preferences/dialog/size", QSize(500, 300))
self.pagelist.setCurrentRow(_prefsindex)
def translateUI(self):
self.pagelist.setFixedWidth(self.pagelist.sizeHintForColumn(0) + 12)
self.setWindowTitle(app.caption(_("Preferences")))
def done(self, result):
if result and self.buttons.button(QDialogButtonBox.Apply).isEnabled():
self.saveSettings()
# save our size and selected page
global _prefsindex
_prefsindex = self.pagelist.currentRow()
super(PreferencesDialog, self).done(result)
def pages(self):
"""Yields the settings pages that are already instantiated."""
for n in range(self.stack.count()):
yield self.stack.widget(n)
def showHelp(self):
userguide.show(self.pagelist.currentItem().help)
def loadSettings(self):
"""Loads the settings on reset."""
for page in self.pages():
page.loadSettings()
page.hasChanges = False
self.buttons.button(QDialogButtonBox.Apply).setEnabled(False)
def saveSettings(self):
"""Saves the settings and applies them."""
for page in self.pages():
if page.hasChanges:
page.saveSettings()
page.hasChanges = False
self.buttons.button(QDialogButtonBox.Apply).setEnabled(False)
# emit the signal
app.settingsChanged()
def slotCurrentItemChanged(self, item):
item.activate()
def changed(self):
"""Call this to enable the Apply button."""
self.buttons.button(QDialogButtonBox.Apply).setEnabled(True)
class MainQMainWindow(QMainWindow):
def __init__(self):
super(MainQMainWindow, self).__init__()
# Create QListWidget
self.setFixedSize(800, 500)
self.myQListWidget = QListWidget(self)
self.alerts = []
# [Alert(AlertInfo('2018-01-12 00:00:01', '1', '1'), 'alert'),
# Alert(AlertInfo('2018-01-12 00:01:01', '2', '2'), 'ignored'),
# Alert(AlertInfo('2018-01-12 00:02:01', '3', '3'), 'resolved')
# ]
# self.myQListWidget.setStyleSheet("QListWidget::item { border: 0px solid red }")
for alert in self.alerts[::-1]:
# Create QCustomQWidget
myQCustomQWidget = QCustomQWidget()
myQCustomQWidget.setItemFromAlert(alert)
# Create QListWidgetItem
myQListWidgetItem = QListWidgetItem(self.myQListWidget)
# Set size hint
myQListWidgetItem.setSizeHint(myQCustomQWidget.sizeHint())
# Add QListWidgetItem into QListWidget
self.myQListWidget.addItem(myQListWidgetItem)
self.myQListWidget.setItemWidget(myQListWidgetItem,
myQCustomQWidget)
self.myQListWidget.itemDoubleClicked.connect(self._handleDoubleClick)
self.setCentralWidget(self.myQListWidget)
#TODO: update 1 element
def updateValues(self, alerts):
self.myQListWidget.clear()
for alert in alerts[::-1]:
print(alert.state)
myQCustomQWidget = QCustomQWidget()
myQCustomQWidget.setItemFromAlert(alert)
# Create QListWidgetItem
myQListWidgetItem = QListWidgetItem(self.myQListWidget)
# Set size hint
myQListWidgetItem.setSizeHint(myQCustomQWidget.sizeHint())
# Add QListWidgetItem into QListWidget
self.myQListWidget.addItem(myQListWidgetItem)
self.myQListWidget.setItemWidget(myQListWidgetItem,
myQCustomQWidget)
self.alerts = alerts
@SimpleThread
def server(self, primaryText):
model_path = os.path.join('frozen_inference_graph.pb')
pipe = detectionPipeline(
args.filename,
'./config_ex.json',
# pipe = detectionPipeline('/Users/StasDon/Documents/Competitions/2018-19/HacknCode/data/videos/l_07_persons_1_01.mp4', './config_ex.json',
models_paths=[model_path],
gui=self)
pipe.processVideo()
##TODO: ADD HASHMAP
def search_for_alert(self, cam):
for idx, alert in enumerate(self.alerts):
if alert.state == 'alert' and alert.info.camera == cam:
return idx
return None
def _handleDoubleClick(self, item):
selected_index = self.myQListWidget.currentRow()
alerts = self.alerts[::-1].copy()
dialog = AlertInfoWindow(alert=alerts[selected_index], parent=self)
if dialog.exec_() == QDialog.Accepted:
alerts[selected_index].state = dialog.choice
self.updateValues(alerts[::-1])
dialog.deleteLater()
