def createListWidget(self):
listWidget = QListWidget()
w, h = self.ITEM_SIZE
scroll_size = 16
listWidget.setFixedWidth(w + scroll_size)
listWidget.setAttribute(Qt.WA_MacShowFocusRect, False)
for x in xrange(self._min_size, self._max_size):
h = max(x + self.MARGIN * 2.0, h)
pixmap = QPixmap(w, h)
pixmap.fill(Qt.transparent)
painter = QPainter(pixmap)
center = h / 2.0
painter.fillRect(QRectF(self.MARGIN, center - x / 2.0,
w - self.MARGIN * 2.0, x), Qt.black)
painter.end()
label = QLabel()
label.setPixmap(pixmap)
item = QListWidgetItem(listWidget)
item.setSizeHint(QSize(w, h))
item.setData(Qt.UserRole, x)
listWidget.addItem(item)
listWidget.setItemWidget(item, label)
if self._size == x:
listWidget.setCurrentItem(item)
return listWidget
def __init__(self, parent=None):
super(MainWindow, self).__init__(parent)
self.centralWidget = QWidget()
self.setCentralWidget(self.centralWidget)
self.createGroupBox()
listWidget = QListWidget()
for le in MainWindow.listEntries:
listWidget.addItem(self.tr(le))
mainLayout = QVBoxLayout()
mainLayout.addWidget(self.groupBox)
mainLayout.addWidget(listWidget)
self.centralWidget.setLayout(mainLayout)
exitAction = QAction(self.tr("E&xit"), self,
triggered=QApplication.instance().quit)
fileMenu = self.menuBar().addMenu(self.tr("&File"))
fileMenu.setPalette(QPalette(Qt.red))
fileMenu.addAction(exitAction)
self.setWindowTitle(self.tr("Language: %s") % self.tr("English"))
self.statusBar().showMessage(self.tr("Internationalization Example"))
if self.tr("LTR") == "RTL":
self.setLayoutDirection(Qt.RightToLeft)
def __init__(self, opPixelClassification, parent):
super( QDialog, self ).__init__(parent=parent)
self._op = opPixelClassification
classifier_listwidget = QListWidget(parent=self)
classifier_listwidget.setSelectionMode( QListWidget.SingleSelection )
classifier_factories = self._get_available_classifier_factories()
for name, classifier_factory in list(classifier_factories.items()):
item = QListWidgetItem( name )
item.setData( Qt.UserRole, classifier_factory )
classifier_listwidget.addItem(item)
buttonbox = QDialogButtonBox( Qt.Horizontal, parent=self )
buttonbox.setStandardButtons( QDialogButtonBox.Ok | QDialogButtonBox.Cancel )
buttonbox.accepted.connect( self.accept )
buttonbox.rejected.connect( self.reject )
layout = QVBoxLayout()
layout.addWidget( classifier_listwidget )
layout.addWidget( buttonbox )
self.setLayout(layout)
self.setWindowTitle( "Select Classifier Type" )
# Save members
self._classifier_listwidget = classifier_listwidget
def initUI(self):
main_layout = QVBoxLayout(self)
sub_layout = QHBoxLayout()
# Left Panel
left_panel = QListWidget()
left_panel.setViewMode(left_panel.ListMode)
#left_panel.setIconSize(QSize(40,40))
left_panel.setTextElideMode(Qt.ElideRight)
left_panel.setMaximumWidth(200)
left_panel.itemClicked.connect(self.change)
#web.setText('Web')
self.application = QListWidgetItem()
self.application.setText('Application')
self.web = QListWidgetItem()
self.web.setText('Web')
self.visual = QListWidgetItem()
self.visual.setText('Visual')
self.advanced = QListWidgetItem()
self.advanced.setText('Advanced')
self.about = QListWidgetItem()
self.about.setText('About')
#main.setIcon(QIcon(os.path.join(app_constants.static_dir, 'plus2.png')))
left_panel.addItem(self.application)
left_panel.addItem(self.web)
left_panel.addItem(self.visual)
left_panel.addItem(self.advanced)
left_panel.addItem(self.about)
left_panel.setMaximumWidth(100)
# right panel
self.right_panel = QStackedLayout()
self.init_right_panel()
# bottom
bottom_layout = QHBoxLayout()
ok_btn = QPushButton('Ok')
ok_btn.clicked.connect(self.accept)
cancel_btn = QPushButton('Cancel')
cancel_btn.clicked.connect(self.close)
info_lbl = QLabel()
info_lbl.setText('<a href="https://github.com/Pewpews/happypanda">'+
'Visit GitHub Repo</a> | Options marked with * requires application restart.')
info_lbl.setTextFormat(Qt.RichText)
info_lbl.setTextInteractionFlags(Qt.TextBrowserInteraction)
info_lbl.setOpenExternalLinks(True)
self.spacer = QWidget()
self.spacer.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Preferred)
bottom_layout.addWidget(info_lbl, 0, Qt.AlignLeft)
bottom_layout.addWidget(self.spacer)
bottom_layout.addWidget(ok_btn, 0, Qt.AlignRight)
bottom_layout.addWidget(cancel_btn, 0, Qt.AlignRight)
sub_layout.addWidget(left_panel)
sub_layout.addLayout(self.right_panel)
main_layout.addLayout(sub_layout)
main_layout.addLayout(bottom_layout)
self.restore_options()
class MainWidget(QWidget):
"""
MainWidget class
Main widget for the main window
"""
def __init__(self, parent):
super(MainWidget, self).__init__(parent)
self.layout = QVBoxLayout(self)
self.load_button = QPushButton("Load data")
self.load_button.clicked.connect(self.scrape_data)
self.layout.addWidget(self.load_button)
self.status_label = QLabel()
self.layout.addWidget(self.status_label)
self.list_widget = QListWidget()
self.list_widget.itemClicked.connect(self.item_clicked)
self.layout.addWidget(self.list_widget)
# Load the data from the database
self.load_data()
self.setLayout(self.layout)
def scrape_data(self):
"""
Scrape the data and load it into the list widget
"""
scrape_and_save()
self.load_data()
self.status_label.setText("Data loaded")
def load_data(self):
"""
Load the data from the database into the list widget
"""
self.list_widget.clear()
data = Database.load_data_from_db()
for item in data:
self.list_widget.addItem(item.date + " : " + item.title + " - " +
item.image)
def item_clicked(self, item):
"""
When a user clicks on the item in the list widget get the url for the
item image and open it in the browser
:param item: List widget item
"""
text = item.text()
image = text.split(' - ')
image = image[1]
import webbrowser
webbrowser.open(image)
class GanttConfigure(QDialog):
def __init__(self, sim, start, end):
QDialog.__init__(self)
#self.setCaption("Gantt configuration")
self.layout = QVBoxLayout(self)
# self._slider = QxtSpanSliderWidget(
# sim.observe_window[0] // sim.cycles_per_ms,
# min(sim.now(), sim.observe_window[1]) // sim.cycles_per_ms,
# self)
self._slider = QxtSpanSliderWidget(
0,
min(sim.now(), sim.duration) // sim.cycles_per_ms,
self)
self._slider.setSpan(start, end)
self.layout.addWidget(self._slider)
self._list_elements = QListWidget(self)
for processor in sim.processors:
item = QListWidgetItem(processor.name, self._list_elements)
item.setData(Qt.UserRole, processor)
self._list_elements.addItem(item)
for task in sim.task_list:
item = QListWidgetItem(task.name, self._list_elements)
item.setData(Qt.UserRole, task)
self._list_elements.addItem(item)
#self._list_elements.setDragDropMode(QListWidget.InternalMove)
for row in range(0, self._list_elements.count()):
self._list_elements.item(row).setCheckState(Qt.Checked)
self.layout.addWidget(self._list_elements)
buttons = QWidget(self)
buttons_layout = QHBoxLayout()
buttons.setLayout(buttons_layout)
buttons_layout.addStretch()
ok_button = QPushButton("Ok")
cancel_button = QPushButton("Cancel")
ok_button.clicked.connect(self.accept)
cancel_button.clicked.connect(self.reject)
buttons_layout.addWidget(ok_button)
buttons_layout.addWidget(cancel_button)
self.layout.addWidget(buttons)
def get_start_date(self):
return self._slider.lowerValue
def get_end_date(self):
return self._slider.upperValue
def get_selected_items(self):
res = []
for row in range(0, self._list_elements.count()):
if self._list_elements.item(row).checkState() == Qt.Checked:
data = self._list_elements.item(row).data(Qt.UserRole)
res.append(data)
return res
class PatchesPage(QtWidgets.QWizardPage):
def __init__(self, Wizard, parent=None):
super(PatchesPage, self).__init__(parent)
self.base = Wizard.base
self.setTitle(self.tr("Patches page"))
self.setSubTitle(self.tr("Select patches"))
self.addButton = QPushButton("+")
self.removeButton = QPushButton("-")
patchesLabel = QLabel("Patches")
self.listPatches = QListWidget()
self.addButton.setMaximumWidth(68)
self.addButton.setMaximumHeight(60)
self.addButton.clicked.connect(self.openPatchesPageFileDialog)
self.removeButton.setMaximumWidth(68)
self.removeButton.setMaximumHeight(60)
self.removeButton.clicked.connect(self.removeItemFromListWidget)
grid = QGridLayout()
grid.addWidget(patchesLabel, 0, 0)
grid.addWidget(self.addButton, 0, 1,)
grid.addWidget(self.removeButton, 0, 2)
grid.addWidget(self.listPatches, 1, 0, 1, 0)
self.setLayout(grid)
def removeItemFromListWidget(self):
self.item = self.listPatches.takeItem(self.listPatches.currentRow())
self.item = None
def openPatchesPageFileDialog(self):
brows = QFileDialog()
self.getPath = brows.getOpenFileName(self,
"Choose patches",
"/home",
"All files (*)")
self.newPath = self.getPath[0]
self.listPatches.addItem(self.newPath)
def validatePage(self):
self.itemsCount = self.listPatches.count()
self.pathes = []
for i in range(0, self.itemsCount):
self.pathes.append(self.listPatches.item(i).text())
self.base.apply_patches(self.pathes)
self.base.run_patched_sources_analysis()
return True
def nextId(self):
return Wizard.PageScripts
class CustomFieldsEditor(QDialog):
def __init__(self, parent, fields):
QDialog.__init__(self, parent)
layout = QVBoxLayout(self)
self._list_elements = QListWidget(self)
self._fields = dict(fields)
for field, ftype in fields.items():
self._list_elements.addItem(field + ' (' + ftype + ')')
self._list_elements.setSelectionMode(
QAbstractItemView.ExtendedSelection)
layout.addWidget(self._list_elements)
add_remove = AddRemoveButtonBar(self, 'Remove selected field(s)',
self.remove, 'Add field', self.add)
layout.addWidget(add_remove)
buttons = QWidget(self)
buttons_layout = QHBoxLayout()
buttons.setLayout(buttons_layout)
buttons_layout.addStretch()
ok_button = QPushButton("Ok")
cancel_button = QPushButton("Cancel")
ok_button.clicked.connect(self.accept)
cancel_button.clicked.connect(self.reject)
buttons_layout.addWidget(ok_button)
buttons_layout.addWidget(cancel_button)
layout.addWidget(buttons)
self.setLayout(layout)
def remove(self):
res = []
for item in self._list_elements.selectedItems():
del self._fields[str(item.text()).split(' ')[0]]
res.append(self._list_elements.row(item))
for row in sorted(res, key=lambda x: -x):
self._list_elements.takeItem(row)
def add(self):
dialog = AddFieldDialog(self)
if dialog.exec_():
self._fields[str(dialog.name)] = dialog.ftype
self._list_elements.addItem(
dialog.name + ' (' + dialog.ftype + ')')
def get_fields(self):
return self._fields
class PopupThing(QWidget):
def __init__(self, parent):
super().__init__(parent,
Qt.Window |
Qt.WindowStaysOnTopHint |
Qt.X11BypassWindowManagerHint |
Qt.FramelessWindowHint)
vbox = QVBoxLayout()
self.listwidget = QListWidget()
self.listwidget.addItem("Test")
vbox.addWidget(self.listwidget)
vbox.setContentsMargins(4, 4, 4, 4)
self.setLayout(vbox)
def skipped_gs(s_list):
"Skipped galleries"
msg_box = QMessageBox(self)
msg_box.setIcon(QMessageBox.Question)
msg_box.setText('Do you want to view skipped paths?')
msg_box.setStandardButtons(QMessageBox.Yes | QMessageBox.No)
msg_box.setDefaultButton(QMessageBox.No)
if msg_box.exec() == QMessageBox.Yes:
list_wid = QListWidget(self)
for g in s_list:
list_wid.addItem(g)
list_wid.setWindowTitle('{} skipped paths'.format(len(s_list)))
list_wid.setWindowFlags(Qt.Window)
list_wid.resize(500,500)
list_wid.show()
class AddFriendDialog(QDialog):
def __init__(self, client_socket):
super().__init__()
self.client_socket = client_socket
self.client_socket.recv_user_search.connect(self.recvUserSearch)
self.selected_user = None
self.initUI()
def initUI(self):
self.grid = QGridLayout(self)
self.search_box_label = QLabel("Search:")
self.grid.addWidget(self.search_box_label, 0, 0, 1, 1)
self.search_box = QLineEdit()
self.grid.addWidget(self.search_box, 0, 1, 1, 2)
self.search_button = QPushButton("Search")
self.search_button.pressed.connect(self.searchUser)
self.grid.addWidget(self.search_button, 0, 3, 1, 1)
self.search_result = QListWidget()
self.grid.addWidget(self.search_result, 1, 0, 2, 2)
#TODO get user avatars to work
self.add_friend_button = QPushButton("Add Friend")
self.add_friend_button.pressed.connect(self.addFriend)
self.grid.addWidget(self.add_friend_button, 1, 2, 1, 2)
self.cancel_button = QPushButton("Cancel")
self.cancel_button.pressed.connect(self.cancel)
self.grid.addWidget(self.cancel_button, 2, 2, 1, 2)
def searchUser(self):
self.client_socket.searchUser(self.search_box.text())
def recvUserSearch(self, found_users):
self.search_result.clear()
for user in found_users:
self.search_result.addItem(QListWidgetItem(user))
def addFriend(self):
self.selected_user = self.search_result.selectedItems()[0].text()
config.friends[self.selected_user] = {}
self.close()
def cancel(self):
self.close()
class LogWidget(QWidget):
def __init__(self):
super().__init__()
self.initUI()
self.show()
def initUI(self):
self.btnclear = QPushButton("Clear messages", self)
self.btnclear.clicked.connect(self._clearClicked)
self.lwmessages = QListWidget(self)
for _, msgtype, msgtext in Log.getLogMessages():
self.addLogItem(msgtype, msgtext)
self.hboxlayout = QHBoxLayout()
self.hboxlayout.addWidget(self.btnclear)
self.hboxlayout.addStretch()
self.vboxlayout = QVBoxLayout()
self.vboxlayout.addLayout(self.hboxlayout)
self.vboxlayout.addWidget(self.lwmessages)
self.setLayout(self.vboxlayout)
# Make sure this widget listens to new logevents
Log.setNewMessageCallBack(self._newMessageAddedToLog)
def _clearClicked(self):
self.lwmessages.clear()
Log.clearMessages()
def _newMessageAddedToLog(self, msgtype, msgtext):
self.addLogItem(msgtype, msgtext)
def addLogItem(self, msgtype, msgtext):
if msgtype == Log.INFO:
icon = QIcon('images/information.png')
elif msgtype == Log.WARNING:
icon = QIcon('images/warning.png')
else:
icon = QIcon('images/error.png')
item = QListWidgetItem(icon, msgtext)
self.lwmessages.addItem(item)
def create_settings(self):
"""Create the widget, organized in two parts.
Notes
-----
When you add widgets in config, remember to update show_settings too
"""
bbox = QDialogButtonBox(QDialogButtonBox.Ok | QDialogButtonBox.Apply |
QDialogButtonBox.Cancel)
self.idx_ok = bbox.button(QDialogButtonBox.Ok)
self.idx_apply = bbox.button(QDialogButtonBox.Apply)
self.idx_cancel = bbox.button(QDialogButtonBox.Cancel)
bbox.clicked.connect(self.button_clicked)
page_list = QListWidget()
page_list.setSpacing(1)
page_list.currentRowChanged.connect(self.change_widget)
pages = ['General', 'Overview', 'Signals', 'Channels', 'Spectrum',
'Notes', 'Video']
for one_page in pages:
page_list.addItem(one_page)
self.stacked = QStackedWidget()
self.stacked.addWidget(self.config)
self.stacked.addWidget(self.parent.overview.config)
self.stacked.addWidget(self.parent.traces.config)
self.stacked.addWidget(self.parent.channels.config)
self.stacked.addWidget(self.parent.spectrum.config)
self.stacked.addWidget(self.parent.notes.config)
self.stacked.addWidget(self.parent.video.config)
hsplitter = QSplitter()
hsplitter.addWidget(page_list)
hsplitter.addWidget(self.stacked)
btnlayout = QHBoxLayout()
btnlayout.addStretch(1)
btnlayout.addWidget(bbox)
vlayout = QVBoxLayout()
vlayout.addWidget(hsplitter)
vlayout.addLayout(btnlayout)
self.setLayout(vlayout)
class SessionManager(QMainWindow):
def __init__(self, parent=None):
QListWidget.__init__(self, parent)
self.setWindowTitle(tr("Saved Sessions"))
self.setWindowFlags(Qt.Dialog)
hideAction = QAction(self)
hideAction.setShortcuts(["Esc", "Ctrl+W"])
hideAction.triggered.connect(self.hide)
self.addAction(hideAction)
self.sessionList = QListWidget(self)
self.sessionList.itemActivated.connect(self.loadSession)
self.setCentralWidget(self.sessionList)
self.toolBar = QToolBar(self)
self.toolBar.setMovable(False)
self.toolBar.setContextMenuPolicy(Qt.CustomContextMenu)
self.addToolBar(Qt.BottomToolBarArea, self.toolBar)
self.loadButton = QPushButton(tr("&Load"), self)
self.loadButton.clicked.connect(lambda: self.loadSession(self.sessionList.currentItem()))
self.toolBar.addWidget(self.loadButton)
self.saveButton = QPushButton(tr("&Save"), self)
self.saveButton.clicked.connect(saveSessionManually)
self.saveButton.clicked.connect(self.refresh)
self.toolBar.addWidget(self.saveButton)
deleteAction = QAction(self)
deleteAction.setShortcut("Del")
deleteAction.triggered.connect(self.delete)
self.addAction(deleteAction)
def refresh(self):
self.sessionList.clear()
if os.path.exists(settings.session_folder):
sessions = os.listdir(settings.session_folder)
for session in sessions:
self.sessionList.addItem(session)
def delete(self):
if self.sessionList.hasFocus():
try: os.remove(os.path.join(settings.session_folder, self.sessionList.currentItem().text()))
except: pass
self.refresh()
def show(self):
self.refresh()
QMainWindow.show(self)
def loadSession(self, item):
if os.path.exists(settings.session_folder):
loadSession(os.path.join(settings.session_folder, item.text()))
self.hide()
class TabGroup(QWidget, itab_item.ITabItem):
def __init__(self, project, name, actions):
super(TabGroup, self).__init__()
vbox = QVBoxLayout(self)
self.actions = actions
self.project = project
self.ID = self.project
self.name = name
self.tabs = []
self.listWidget = QListWidget()
hbox = QHBoxLayout()
btnExpand = QPushButton(_translate("TabGroup", "Expand this Files"))
btnExpandAll = QPushButton(_translate("TabGroup", "Expand all Groups"))
hbox.addWidget(btnExpandAll)
hbox.addSpacerItem(QSpacerItem(20, 20, QSizePolicy.Expanding))
hbox.addWidget(btnExpand)
vbox.addLayout(hbox)
vbox.addWidget(self.listWidget)
btnExpand.clicked['bool'].connect(self.expand_this)
btnExpandAll.clicked['bool'].connect(self.actions.deactivate_tabs_groups)
def add_widget(self, widget):
self.tabs.append(widget)
self.listWidget.addItem(widget.ID)
def expand_this(self):
self.actions.group_tabs_together()
for tab in self.tabs:
tabName = file_manager.get_basename(tab.ID)
self.actions.ide.mainContainer.add_tab(tab, tabName)
index = self.actions.ide.mainContainer._tabMain.indexOf(self)
self.actions.ide.mainContainer._tabMain.removeTab(index)
self.tabs = []
self.listWidget.clear()
def only_expand(self):
for tab in self.tabs:
tabName = file_manager.get_basename(tab.ID)
self.actions.ide.mainContainer.add_tab(tab, tabName)
index = self.actions.ide.mainContainer._tabMain.indexOf(self)
self.actions.ide.mainContainer._tabMain.removeTab(index)
self.tabs = []
self.listWidget.clear()
class PeersDiscoveryDialog(QDialog):
def __init__(self):
super().__init__()
self.setWindowModality(Qt.ApplicationModal)
self.setLayout(QVBoxLayout())
self.setMaximumSize(300, 200)
self.setMinimumSize(300, 200)
self.resize(300, 200)
self.listWidget = QListWidget(self)
self.listWidget.setAlternatingRowColors(True)
self.listWidget.setSelectionMode(self.listWidget.MultiSelection)
self.layout().addWidget(self.listWidget)
self.dialogButton = QDialogButtonBox(self)
self.dialogButton.setStandardButtons(self.dialogButton.Ok)
self.dialogButton.accepted.connect(self.accept)
self.layout().addWidget(self.dialogButton)
self.retranslateUi()
self._discoverer = Discoverer()
self._discoverer.discovered.connect(self._new_peer)
def retranslateUi(self):
self.setWindowTitle("Discovering peers ...")
def accept(self):
self._discoverer.stop()
return super().accept()
def exec_(self):
self._discoverer.start()
return super().exec_()
def get_peers(self):
return [item.adders for item in self.listWidget.selectedItems()]
def _new_peer(self, peer):
item = QListWidgetItem(peer[1] + ' at ' + peer[0])
item.adders = peer[0]
self.listWidget.addItem(item)
class AdremoverSettingsPanel(SettingsPanel):
def __init__(self, parent=None):
super(AdremoverSettingsPanel, self).__init__(parent)
filterEntryRow = custom_widgets.LineEditRow(tr("Add filter:"), self)
self.filterEntry = filterEntryRow.lineEdit
self.filterEntry.returnPressed.connect(self.addFilter)
self.layout().addWidget(filterEntryRow)
self.addFilterButton = QPushButton(tr("Add"))
self.addFilterButton.clicked.connect(self.addFilter)
filterEntryRow.layout().addWidget(self.addFilterButton)
# Ad Remover filter list.
self.filterList = QListWidget(self)
self.layout().addWidget(self.filterList)
self.removeFilterButton = QPushButton(tr("Remove"))
self.removeFilterButton.clicked.connect(lambda: self.removeFilter(True))
self.layout().addWidget(self.removeFilterButton)
self.removeAction = QAction(self)
self.removeAction.setShortcut("Del")
self.removeAction.triggered.connect(self.removeFilter)
self.addAction(self.removeAction)
def removeFilter(self, forceFocus=False):
if self.filterList.hasFocus() or forceFocus:
self.filterList.takeItem(self.filterList.row(self.filterList.currentItem()))
def addFilter(self):
self.filterList.addItem(self.filterEntry.text())
self.filterEntry.clear()
def loadSettings(self):
settings.load_adremover_filters()
self.filterList.clear()
for f in settings.adremover_filters:
self.filterList.addItem(f)
def saveSettings(self):
settings.adremover_filters = [self.filterList.item(f).text() for f in range(0, self.filterList.count())]
settings.save_adremover_filters()
class JavaScriptExceptionsPanel(SettingsPanel):
def __init__(self, parent=None):
super(JavaScriptExceptionsPanel, self).__init__(parent)
domainEntryRow = custom_widgets.LineEditRow(tr("Add domain:"), self)
self.domainEntry = domainEntryRow.lineEdit
self.domainEntry.returnPressed.connect(self.addDomain)
self.layout().addWidget(domainEntryRow)
self.addDomainButton = QPushButton(tr("Add"))
self.addDomainButton.clicked.connect(self.addDomain)
domainEntryRow.layout().addWidget(self.addDomainButton)
self.domainList = QListWidget(self)
self.layout().addWidget(self.domainList)
self.removeDomainButton = QPushButton(tr("Remove"))
self.removeDomainButton.clicked.connect(lambda: self.removeDomain(True))
self.layout().addWidget(self.removeDomainButton)
self.removeAction = QAction(self)
self.removeAction.setShortcut("Del")
self.removeAction.triggered.connect(self.removeDomain)
self.addAction(self.removeAction)
def removeDomain(self, forceFocus=False):
if self.domainList.hasFocus() or forceFocus:
self.domainList.takeItem(self.domainList.row(self.domainList.currentItem()))
def addDomain(self):
self.domainList.addItem(self.domainEntry.text())
self.domainEntry.clear()
def loadSettings(self):
settings.js_exceptions = settings.setting_to_list("content/JavaScriptExceptions")
self.domainList.clear()
for f in settings.js_exceptions:
self.domainList.addItem(f)
def saveSettings(self):
settings.js_exceptions = [self.domainList.item(f).text() for f in range(0, self.domainList.count())]
settings.settings.setValue("content/JavaScriptExceptions", settings.js_exceptions)
settings.settings.sync()
class MatchDlg(QDialog):
def __init__(self, blocks, fileText, parent=None):
super().__init__(parent)
self.setWindowTitle("Approximate matches")
self.setGeometry(100, 300, 1000, 200)
NContext = 30
self.listWidget = QListWidget(self)
for row, block in enumerate(blocks):
item = QListWidgetItem()
before = fileText[block["start"]-NContext:block["start"]]
after = fileText[block["end"]:block["end"]+NContext]
item.setSizeHint(QSize(1000, 50))
textEdit = TextEdit(row, self)
textEdit.insertHtml('{}<b>{}</b>{}'.format(before, block["candidate"], after))
self.listWidget.addItem(item)
self.listWidget.setItemWidget(item, textEdit)
textEdit.clicked.connect(self.selectText)
self.listWidget.showMaximized()
self.listWidget.setSelectionBehavior(QAbstractItemView.SelectRows)
self.listWidget.setSelectionMode(QAbstractItemView.SingleSelection)
layout = QVBoxLayout()
layout.addWidget(QLabel('The text to annotate has not been found. Similar entries are listed below. Please choose correct one.', self))
layout.addWidget(self.listWidget)
self.setLayout(layout)
self.blocks = blocks
self.chosenBlock = None
@pyqtSlot(int)
def selectText(self, row):
self.chosenBlock = self.blocks[row]
self.accept()
class Template(QWidget):
def __init__(self):
super().__init__()
self.list = QListWidget(self)
for s in ['alpha', 'beta', 'gamma']:
self.list.addItem(s)
self.list.currentItemChanged.connect(self.updateMe)
self.setGeometry(300, 300, 200, 100)
self.show()
# def updateMe(self, item):
# print(item.text())
def updateMe(self, curr, prev):
if prev:
print(f'curr={curr.text()}, prev={prev.text()}')
else:
print(f'curr={curr.text()}, prev=None')
class PythonDetectDialog(QDialog):
def __init__(self, suggested, parent=None):
super(PythonDetectDialog, self).__init__(parent, Qt.Dialog)
self.setMaximumSize(QSize(0, 0))
self.setWindowTitle("Configure Python Path")
vbox = QVBoxLayout(self)
msg_str = ("We have detected that you are using "
"Windows,\nplease choose the proper "
"Python application for you:")
lblMessage = QLabel(self.tr(msg_str))
vbox.addWidget(lblMessage)
self.listPaths = QListWidget()
self.listPaths.setSelectionMode(QListWidget.SingleSelection)
vbox.addWidget(self.listPaths)
hbox = QHBoxLayout()
hbox.addSpacerItem(QSpacerItem(1, 0, QSizePolicy.Expanding))
btnCancel = QPushButton(self.tr("Cancel"))
btnAccept = QPushButton(self.tr("Accept"))
hbox.addWidget(btnCancel)
hbox.addWidget(btnAccept)
vbox.addLayout(hbox)
btnAccept.clicked['bool'].connect(self._set_python_path)
btnCancel.clicked['bool'].connect(self.close)
for path in suggested:
self.listPaths.addItem(path)
self.listPaths.setCurrentRow(0)
def _set_python_path(self):
python_path = self.listPaths.currentItem().text()
qsettings = QSettings(resources.SETTINGS_PATH, QSettings.IniFormat)
settings.PYTHON_PATH = python_path
settings.PYTHON_EXEC = python_path
settings.PYTHON_EXEC_CONFIGURED_BY_USER = True
qsettings.setValue('preferences/execution/pythonExec', python_path)
qsettings.setValue('preferences/execution/pythonExecConfigured', True)
self.close()
class MessageBoxWithList(QMessageBox):
def __init__(self, parent = None):
super().__init__(parent)
self._listWidget = QListWidget(self)
self.layout().addWidget(self._listWidget, 3, 1)
self._listWidget.hide()
def addToList(self, val):
self._listWidget.addItem(val)
def listCount(self):
return self._listWidget.count()
def exec(self):
if self._listWidget.count() > 0:
self._listWidget.show()
else:
self._listWidget.hide()
super().exec()
class MultipleChoiceDialog(QDialog):
def __init__(self, parent, title, text, items):
QDialog.__init__(self, parent)
self.setWindowTitle(title)
self.layout = QVBoxLayout()
label = QLabel(text)
self.layout.addWidget(label)
self.listwidget = QListWidget(self)
self.listwidget.setSelectionMode(QAbstractItemView.ExtendedSelection)
for item in items:
self.listwidget.addItem(item)
self.layout.addWidget(self.listwidget)
buttonBox = QDialogButtonBox(QDialogButtonBox.Ok|QDialogButtonBox.Cancel)
buttonBox.accepted.connect(self.accept)
buttonBox.rejected.connect(self.reject)
self.layout.addWidget(buttonBox)
self.setLayout(self.layout)
def selectedItems(self):
return self.listwidget.selectedItems()
class SingleGalleryChoices(BasePopup):
"""
Represent a single gallery with a list of choices below.
Pass a gallery and a list of tuple/list where the first index is a string in each
if text is passed, the text will be shown alongside gallery, else gallery be centered
"""
USER_CHOICE = pyqtSignal(tuple)
def __init__(self, gallery, tuple_first_idx, text=None, parent = None):
super().__init__(parent, flags= Qt.Dialog | Qt.FramelessWindowHint)
main_layout = QVBoxLayout()
self.main_widget.setLayout(main_layout)
g_showcase = GalleryShowcaseWidget()
g_showcase.set_gallery(gallery, (170//1.40, 170))
if text:
t_layout = QHBoxLayout()
main_layout.addLayout(t_layout)
t_layout.addWidget(g_showcase, 1)
info = QLabel(text)
info.setWordWrap(True)
t_layout.addWidget(info)
else:
main_layout.addWidget(g_showcase, 0, Qt.AlignCenter)
self.list_w = QListWidget(self)
main_layout.addWidget(self.list_w, 3)
main_layout.addLayout(self.buttons_layout)
for t in tuple_first_idx:
item = GalleryListItem(t)
item.setText(t[0])
self.list_w.addItem(item)
buttons = self.add_buttons('Choose')
buttons[0].clicked.connect(self.finish)
self.resize(400, 400)
self.show()
def finish(self):
item = self.list_w.selectedItems()
if item:
item = item[0]
self.USER_CHOICE.emit(item.gallery)
self.close()
def displayall(self):
clearLayout(self.lay)
listof = QListWidget()
stat = copy.deepcopy(self.clientresult)
stat = sorted(stat)
stat = stat[::-1]
for i in stat:
if type(i[1]) == str:
i[1], i[0] = i[0], i[1]
i[1] = str(i[1]) + ' WPM'
a = ' '.join(i)
a = QListWidgetItem(a)
listof.addItem(a)
self.lay.addWidget(listof)
goback = QPushButton('Back to chat')
goback.clicked.connect(self.startserver)
self.lay.addWidget(goback)
self.counter = 0
self.errorcount = 0
self.countlength = 0
self.before = ''
self.typing = []
def initUI(self):
but_add_dictionary = QPushButton("Добавить в словарь")
but_exit = QPushButton("Выход")
leb1 = QLabel("Ключевые слова")
leb2 = QLabel("Кандидаты на добавление")
list_keywords1 = QListWidget()
list_keywords1.resize(300, 120)
list_keywords1.addItem("паралельные вычисления");
list_keywords1.addItem("дисковые массивы");
list_keywords1.addItem("сертификация");
list_keywords1.addItem("тестирование");
list_keywords2 = QListWidget()
list_keywords2.resize(300, 120)
list_keywords2.addItem("открытое татистическое исследование");
list_keywords2.addItem("статистическое исследование");
grid = QGridLayout()
grid.setSpacing(10)
grid.addWidget(leb1, 1, 0)
grid.addWidget(leb2, 1, 1)
grid.addWidget(list_keywords1, 2, 0)
grid.addWidget(list_keywords2, 2, 1)
grid.addWidget(but_add_dictionary, 3, 0)
grid.addWidget(but_exit, 3, 1)
self.setLayout(grid)
self.setGeometry(300, 300, 700, 400)
self.setWindowTitle('Добавлеие ключевых слов в словарь')
self.show()
class LanguageChooser(QDialog):
newQM = QtCore.pyqtSignal(str)
supportedLanguages = {'Español': 'es_ES',
'English': 'en_GB', 'Català': 'ca_ES'}
def __init__(self, parent=None):
super(LanguageChooser, self).__init__(parent)
self.initUI()
def initUI(self):
self.setWindowTitle(i18n(
"LanguageChooser", "Language"))
self.widgetLayout = QVBoxLayout(self)
self.infoLabel = QLabel(self)
self.infoLabel.setText(i18n(
"LanguageChooser", "Select the desired language:"))
self.widgetLayout.addWidget(self.infoLabel)
self.languageListWidget = QListWidget(self)
self.widgetLayout.addWidget(self.languageListWidget)
for language in self.supportedLanguages.keys():
self.languageListWidget.addItem(language)
self.buttonBox = QDialogButtonBox(
QDialogButtonBox.Ok | QDialogButtonBox.Cancel,
QtCore.Qt.Horizontal, self)
self.buttonBox.accepted.connect(self.changeLanguage)
self.buttonBox.rejected.connect(self.close)
self.widgetLayout.addWidget(self.buttonBox)
def changeLanguage(self):
ci = self.languageListWidget.currentItem()
if ci:
selected = ci.text()
fname = self.supportedLanguages[selected]
self.newQM.emit(fname)
self.close()
class BWPassengerWindow(QMdiSubWindow):
def __init__(self, *args, **kwargs):
super().__init__(*args, **kwargs)
self.setBaseSize(400, 400)
self.centralwidget = QWidget(self)
self.setWidget(self.centralwidget)
layout = QHBoxLayout(self.centralwidget)
self.passengerlist = QListWidget(self.centralwidget)
layout.addWidget(self.passengerlist)
self.setWindowTitle("Passengers")
def reset(self):
self.passengerlist.clearSelection()
self.passengerlist.clear()
def add_passenger(self, passenger_name, passenger_id):
item = BWEntityEntry(passenger_id,
passenger_name)
self.passengerlist.addItem(item)
def set_title(self, entityname):
self.setWindowTitle("Passengers - {0}".format(entityname))
class UIColorSpace(object):
def __init__(self):
self.mainDialog = colorspacedialog.ColorSpaceDialog()
self.mainLayout = QVBoxLayout(self.mainDialog)
self.formLayout = QFormLayout()
self.documentLayout = QVBoxLayout()
self.refreshButton = QPushButton(QIcon(':/icons/refresh.svg'),
"Refresh")
self.widgetDocuments = QListWidget()
self.colorModelComboBox = colormodelcombobox.ColorModelComboBox(self)
self.colorDepthComboBox = colordepthcombobox.ColorDepthComboBox(self)
self.colorProfileComboBox = colorprofilecombobox.ColorProfileComboBox(
self)
self.buttonBox = QDialogButtonBox(QDialogButtonBox.Ok
| QDialogButtonBox.Cancel)
self.kritaInstance = krita.Krita.instance()
self.documentsList = []
self.colorModelsList = []
self.colorDepthsList = []
self.colorProfilesList = []
self.refreshButton.clicked.connect(self.refreshButtonClicked)
self.buttonBox.accepted.connect(self.confirmButton)
self.buttonBox.rejected.connect(self.mainDialog.close)
self.mainDialog.setWindowModality(Qt.NonModal)
self.widgetDocuments.setSelectionMode(QAbstractItemView.MultiSelection)
self.widgetDocuments.setSizeAdjustPolicy(
QAbstractScrollArea.AdjustToContents)
def initialize(self):
self.loadDocuments()
self.loadColorModels()
self.loadColorDepths()
self.loadColorProfiles()
self.documentLayout.addWidget(self.widgetDocuments)
self.documentLayout.addWidget(self.refreshButton)
self.formLayout.addRow('Documents', self.documentLayout)
self.formLayout.addRow('Color Model', self.colorModelComboBox)
self.formLayout.addRow('Color Depth', self.colorDepthComboBox)
self.formLayout.addRow('Color Profile', self.colorProfileComboBox)
self.line = QFrame()
self.line.setFrameShape(QFrame.HLine)
self.line.setFrameShadow(QFrame.Sunken)
self.mainLayout.addLayout(self.formLayout)
self.mainLayout.addWidget(self.line)
self.mainLayout.addWidget(self.buttonBox)
self.mainDialog.resize(500, 300)
self.mainDialog.setWindowTitle("Color Space")
self.mainDialog.setSizeGripEnabled(True)
self.mainDialog.show()
self.mainDialog.activateWindow()
def loadColorModels(self):
self.colorModelsList = sorted(self.kritaInstance.colorModels())
self.colorModelComboBox.addItems(self.colorModelsList)
def loadColorDepths(self):
self.colorDepthComboBox.clear()
colorModel = self.colorModelComboBox.currentText()
self.colorDepthsList = sorted(
self.kritaInstance.colorDepths(colorModel))
self.colorDepthComboBox.addItems(self.colorDepthsList)
def loadColorProfiles(self):
self.colorProfileComboBox.clear()
colorModel = self.colorModelComboBox.currentText()
colorDepth = self.colorDepthComboBox.currentText()
self.colorProfilesList = sorted(
self.kritaInstance.profiles(colorModel, colorDepth))
self.colorProfileComboBox.addItems(self.colorProfilesList)
def loadDocuments(self):
self.widgetDocuments.clear()
self.documentsList = [
document for document in self.kritaInstance.documents()
if document.fileName()
]
for document in self.documentsList:
self.widgetDocuments.addItem(document.fileName())
def refreshButtonClicked(self):
self.loadDocuments()
def confirmButton(self):
selectedPaths = [
item.text() for item in self.widgetDocuments.selectedItems()
]
selectedDocuments = [
document for document in self.documentsList
for path in selectedPaths if path == document.fileName()
]
self.msgBox = QMessageBox(self.mainDialog)
if selectedDocuments:
self.convertColorSpace(selectedDocuments)
self.msgBox.setText("The selected documents has been converted.")
else:
self.msgBox.setText("Select at least one document.")
self.msgBox.exec_()
def convertColorSpace(self, documents):
for document in documents:
document.setColorSpace(self.colorModelComboBox.currentText(),
self.colorDepthComboBox.currentText(),
self.colorProfileComboBox.currentText())
class MediaPlayer(QMainWindow):
def __init__(self):
super().__init__()
self.initUI()
def initUI(self):
self.setGeometry(300, 300, 400, 300)
self.setWindowTitle('MediaPlayer')
# Создание центрального виджета и настройка лайоута для поддержания формы интерфейса
self.centerWindow = QWidget()
self.mainGridLayout = QGridLayout()
self.setCentralWidget(self.centerWindow)
self.centralWidget().setLayout(self.mainGridLayout)
# кнопки добавления и удаления трека
self.addBtn = QPushButton('Add File', self)
self.addBtn.clicked.connect(self.addFile)
self.removeBtn = QPushButton('Remove File', self)
self.removeBtn.clicked.connect(self.removeFile)
self.mainGridLayout.addWidget(self.addBtn, 1, 0)
self.mainGridLayout.addWidget(self.removeBtn, 1, 1)
# Кнопка prev
self.prevBtn = QPushButton('', self)
prevIcon = QIcon()
prevIcon.addFile('prev.png')
# Назначаем иконку кнопке
self.prevBtn.setIcon(prevIcon)
# Размещаем кнопку на макете (лайоуте)
self.mainGridLayout.addWidget(self.prevBtn, 3, 0)
self.prevBtn.clicked.connect(self.PreviousTrack)
# Кнопка play
self.playBtn = QPushButton('', self)
playIcon = QIcon()
playIcon.addFile('play.png')
self.playBtn.setIcon(playIcon)
self.mainGridLayout.addWidget(self.playBtn, 3, 1)
self.playBtn.clicked.connect(self.PlayMusic)
# Кнопка pause
self.pause = QPushButton('', self)
pauseIcon = QIcon()
pauseIcon.addFile('pause.png')
self.pause.setIcon(pauseIcon)
self.mainGridLayout.addWidget(self.pause, 3, 2)
self.pause.clicked.connect(self.PauseMusic)
# Кнопка next
self.nextBtn = QPushButton('', self)
nextIcon = QIcon()
nextIcon.addFile('next.png')
self.nextBtn.setIcon(nextIcon)
self.mainGridLayout.addWidget(self.nextBtn, 3, 3)
self.nextBtn.clicked.connect(self.NextTrack)
# создание и настройка таймера и слайдеров
self.timer = QTimer()
self.timer.setInterval(100)
self.timer.timeout.connect(self.Timercheck)
self.timer.start()
# Таймлайн
self.TimeLine = QSlider(Qt.Horizontal, self)
self.mainGridLayout.addWidget(self.TimeLine, 2, 0, 1, 4)
self.TimeLine.sliderPressed.connect(self.TLPress)
self.TimeLine.sliderReleased.connect(self.TLRelease)
# Громкость
self.Volume = QSlider(Qt.Vertical, self)
self.Volume.setValue(50)
self.mainGridLayout.addWidget(self.Volume, 1, 4, 3, 1)
self.Volume.valueChanged[int].connect(self.changeVolume)
# создаем экземпляр медиаплеера
self.player = QMediaPlayer()
self.player.stateChanged.connect(self.media_status_changed)
# Создаем QListWidget() в котором будут хранится имена фалов
self.listbox = QListWidget()
self.listbox.doubleClicked.connect(self.PlayMusic)
# Добавляем наш листбокс в макет addWidget(ОБЪЕКТ, СТРОКА, СТОЛБЕЦ, в высоту, в ширину )
self.mainGridLayout.addWidget(self.listbox, 0, 0, 1, 0)
self.LoopCheckbox = QCheckBox('Зациклить', self)
self.mainGridLayout.addWidget(self.LoopCheckbox, 1, 2)
self.LoopCheckbox.stateChanged.connect(self.CheckboxState)
# Создаем список в котором будут хранится имена и пути файлов в список будем добавлять объекты типа plItem
self.playList = []
# Признак зацикленности плейлиста и флаг изменения состояния плеера
self.loop = True
self.IgnoreStateChange = False
def CheckboxState(self, state):
if state == Qt.Checked:
self.IgnoreStateChange = True
else:
self.IgnoreStateChange = False
# функционал таймера, кнопок и ползунков
def addFile(self):
# Получаем полное имя (с путём)
fullFileName = QFileDialog.getOpenFileName(
self, 'Add File', '', "Music files (*.mp3 *.ogg)")[0]
# Разбиваем на части, используя re.split(r'[\\/]') из библиотеки работы с регулярными выражениями
# регулярное выражение r'[\\/]' для того, что бы и виндовс и линукс нормально разбивало путь вин \, лин /
splittedFileName = re.split(r'[\\/]', fullFileName)
# Получаем имя файла
shortFileName = splittedFileName[splittedFileName.__len__() - 1]
# Добавляем в плейлист (который список) имя и соответсвующий ему полый путь с именем
self.playList.append(plItem(fullFileName, shortFileName))
# Добавляем в listbox только имя файла
self.listbox.addItem(shortFileName)
# Удаление файла из листбокса
def removeFile(self):
if self.listbox.selectedItems():
self.playList.pop(self.listbox.currentIndex().row())
self.listbox.takeItem(self.listbox.currentIndex().row())
# Зависимости таймера и таймлайна
def TLPress(self):
self.timer.stop()
self.player.setPosition(
(self.player.duration() / 100) * self.TimeLine.value())
def TLRelease(self):
self.player.setPosition(
(self.player.duration() / 100) * self.TimeLine.value())
self.timer.start()
def TLMoved(self):
self.player.setPosition(
(self.player.duration() / 100) * self.TimeLine.value())
def Timercheck(self):
if self.player.duration() != 0:
pos = self.player.position() / (self.player.duration() / 100)
self.TimeLine.setValue(pos.__int__())
# Предыдущий трэк
def PreviousTrack(self):
if self.listbox.selectedItems() and (self.listbox.currentRow() != 0):
self.IgnoreStateChange = True
self.listbox.setCurrentRow(self.listbox.currentIndex().row() - 1)
self.PlayMusic()
self.IgnoreStateChange = False
elif self.listbox.selectedItems() and (self.listbox.currentRow() == 0):
self.IgnoreStateChange = True
self.listbox.setCurrentRow(self.listbox.__len__() - 1)
self.PlayMusic()
self.IgnoreStateChange = False
# Следующий трэк
def NextTrack(self):
if self.listbox.selectedItems() and (self.listbox.currentRow() !=
self.listbox.__len__() - 1):
self.IgnoreStateChange = True
self.listbox.setCurrentRow(self.listbox.currentIndex().row() + 1)
self.PlayMusic()
self.IgnoreStateChange = False
elif self.listbox.selectedItems() and (self.listbox.currentRow()
== self.listbox.__len__() - 1):
self.IgnoreStateChange = True
self.listbox.setCurrentRow(0)
self.PlayMusic()
self.IgnoreStateChange = False
# громкость, play, pause
def changeVolume(self, value):
self.player.setVolume(value)
def PauseMusic(self):
self.player.pause()
def PlayMusic(self):
if self.listbox.selectedItems():
file = QUrl.fromLocalFile(
self.playList[self.listbox.currentIndex().row()].fPath)
content = QMediaContent(file)
self.player.setMedia(content)
self.player.setVolume(self.Volume.value())
self.player.play()
elif self.listbox.__len__() > 0:
self.listbox.setCurrentRow(0)
file = QUrl.fromLocalFile(
self.playList[self.listbox.currentIndex().row()].fPath)
content = QMediaContent(file)
self.player.setMedia(content)
self.player.setVolume(self.Volume.value())
self.player.play()
# Переход на след трек
def media_status_changed(self, status):
if not self.IgnoreStateChange:
if status == QMediaPlayer.StoppedState:
if (self.listbox.currentIndex().row()
== self.listbox.__len__() - 1) and self.loop:
self.listbox.setCurrentRow(0)
file = QUrl.fromLocalFile(
self.playList[self.listbox.currentIndex().row()].fPath)
content = QMediaContent(file)
self.player.setMedia(content)
self.player.play()
elif self.listbox.currentIndex().row(
) < self.listbox.__len__() - 1:
self.listbox.setCurrentRow(
self.listbox.currentIndex().row() + 1)
file = QUrl.fromLocalFile(
self.playList[self.listbox.currentIndex().row()].fPath)
content = QMediaContent(file)
self.player.setMedia(content)
self.player.play()
if self.IgnoreStateChange:
self.player.play()
class MyTestsWindow(QWidget):
""" shows the list of user`s tests """
def __init__(self):
super().__init__()
self.setWindowIcon(QIcon(os.path.join(os.pardir, "res", "img", "logo.png")))
self.setWindowTitle("QUIZZO LEARN")
self.resize(900, 650)
center(self)
self.load_ui()
def init_ui(self):
self.show()
def load_ui(self):
box = QVBoxLayout()
back_button = QPushButton("<= WRÓĆ")
back_button.setStyleSheet("background-color: YellowGreen; color:purple")
back_button.clicked.connect(self.back_button_act)
font = QFont("Serif", 20)
label = QLabel("MOJE TESTY:")
label.setFont(font)
label.setStyleSheet("color:AntiqueWhite; background-color:darkorange")
self.QList = QListWidget()
self.QList.setStyleSheet("background-color:PeachPuff ")
hbox2 = QHBoxLayout()
hbox2.addWidget(back_button)
hbox2.addStretch(4)
box.addWidget(label, 1)
box.addLayout(hbox2, 1)
box.addWidget(self.QList, 8)
self.setLayout(box)
self.load_tests()
def back_button_act(self):
self.close()
menu_window.show()
def load_tests(self):
tests = quizzo_learn.files_interactions.list_of_tests(os.path.join(os.pardir, "res", "my_tests"))
for test in tests:
item = QListWidgetItem()
item.name = test
test_widget = QItemTest(test)
item.setSizeHint(test_widget.sizeHint())
self.QList.addItem(item)
self.QList.setItemWidget(item, test_widget)
def refresh(self):
self.QList.clear()
self.load_tests()
def deleting(self, name):
i = 0
i2 = self.QList.count()
while i < i2:
item = self.QList.item(i)
if item.name == name:
self.QList.removeItemWidget(item)
quizzo_learn.files_interactions.delete_file(
os.path.join(os.pardir, "res", "my_tests", name + ".test"))
build_big_test_window.refresh()
break
i += 1
def start_test(self, name):
dicts_of_questions = quizzo_learn.files_interactions.read_test(
os.path.join(os.pardir, "res", "my_tests", name + ".test"))
self.close()
start_window.label.setText(name)
start_window.init_ui(dicts_of_questions)
def addItem(self, code, text):
self.__rowCode.appendRowCode(self.count(), code)
QListWidget.addItem(self, text)
class QuotesDialog(QDialog):
selectedQuote = ""
def __init__(self, theParent=None, currentQuote="\""):
QDialog.__init__(self, parent=theParent)
self.mainConf = nw.CONFIG
self.outerBox = QVBoxLayout()
self.innerBox = QHBoxLayout()
self.labelBox = QVBoxLayout()
self.selectedQuote = currentQuote
qMetrics = QFontMetrics(self.font())
pxW = 7 * qMetrics.boundingRectChar("M").width()
pxH = 7 * qMetrics.boundingRectChar("M").height()
pxH = 7 * qMetrics.boundingRectChar("M").height()
lblFont = self.font()
lblFont.setPointSizeF(4 * lblFont.pointSizeF())
# Preview Label
self.previewLabel = QLabel(currentQuote)
self.previewLabel.setFont(lblFont)
self.previewLabel.setFixedSize(QSize(pxW, pxH))
self.previewLabel.setAlignment(Qt.AlignCenter)
self.previewLabel.setFrameStyle(QFrame.Box | QFrame.Plain)
# Quote Symbols
self.listBox = QListWidget()
self.listBox.itemSelectionChanged.connect(self._selectedSymbol)
minSize = 100
for sKey, sLabel in nwQuotes.SYMBOLS.items():
theText = "[ %s ] %s" % (sKey, sLabel)
minSize = max(minSize, qMetrics.boundingRect(theText).width())
qtItem = QListWidgetItem(theText)
qtItem.setData(Qt.UserRole, sKey)
self.listBox.addItem(qtItem)
if sKey == currentQuote:
self.listBox.setCurrentItem(qtItem)
self.listBox.setMinimumWidth(minSize + self.mainConf.pxInt(40))
self.listBox.setMinimumHeight(self.mainConf.pxInt(150))
# Buttons
self.buttonBox = QDialogButtonBox(QDialogButtonBox.Ok
| QDialogButtonBox.Cancel)
self.buttonBox.accepted.connect(self._doAccept)
self.buttonBox.rejected.connect(self._doReject)
# Assemble
self.labelBox.addWidget(self.previewLabel, 0, Qt.AlignTop)
self.labelBox.addStretch(1)
self.innerBox.addLayout(self.labelBox)
self.innerBox.addWidget(self.listBox)
self.outerBox.addLayout(self.innerBox)
self.outerBox.addWidget(self.buttonBox)
self.setLayout(self.outerBox)
return
##
# Slots
##
def _selectedSymbol(self):
"""Update the preview label and the selected quote style.
"""
selItems = self.listBox.selectedItems()
if selItems:
theSymbol = selItems[0].data(Qt.UserRole)
self.previewLabel.setText(theSymbol)
self.selectedQuote = theSymbol
return
def _doAccept(self):
"""Ok button clicked.
"""
self.accept()
return
def _doReject(self):
"""Cancel button clicked.
"""
self.reject()
return
class RSSReaderWidget(QWidget):
def __init__(self):
super(RSSReaderWidget, self).__init__()
self.feed_file_path = os.path.expanduser(
"~/.emacs.d/eaf/rss-reader/feeds.json")
self.feed_area = QWidget()
self.feed_list = QListWidget()
self.feed_list.setStyleSheet("""QListWidget{background: #4D5250;}""")
panel_layout = QVBoxLayout()
panel_layout.setSpacing(0)
panel_layout.setContentsMargins(0, 0, 0, 0)
panel_layout.addWidget(self.feed_list)
self.feed_area.setLayout(panel_layout)
self.article_area = QWidget()
self.article_list = QListWidget()
self.article_list.verticalScrollBar().setStyleSheet(
"QScrollBar {width:0px;}")
article_layout = QVBoxLayout()
article_layout.setSpacing(0)
article_layout.setContentsMargins(0, 0, 0, 0)
self.browser = BrowserView()
article_layout.addWidget(self.article_list)
article_layout.addWidget(self.browser)
article_layout.setStretchFactor(self.article_list, 1)
article_layout.setStretchFactor(self.browser, 3)
self.article_area.setLayout(article_layout)
self.welcome_page = QWidget()
self.welcome_page_box = QVBoxLayout()
self.welcome_page_box.setSpacing(10)
self.welcome_page_box.setContentsMargins(0, 0, 0, 0)
welcome_title_label = QLabel("Welcome to EAF RSS Reader!")
welcome_title_label.setFont(QFont('Arial', 24))
welcome_title_label.setStyleSheet(
"QLabel {color: black; font-weight: bold; margin: 20px;}")
welcome_title_label.setAlignment(Qt.AlignHCenter)
add_subscription_label = QLabel("Press key 'a' to add subscription")
add_subscription_label.setFont(QFont('Arial', 20))
add_subscription_label.setStyleSheet("QLabel {color: #333;}")
add_subscription_label.setAlignment(Qt.AlignHCenter)
self.welcome_page_box.addStretch(1)
self.welcome_page_box.addWidget(welcome_title_label)
self.welcome_page_box.addWidget(add_subscription_label)
self.welcome_page_box.addStretch(1)
self.welcome_page.setLayout(self.welcome_page_box)
self.right_area = QStackedWidget()
self.right_area.addWidget(self.welcome_page)
self.right_area.addWidget(self.article_area)
self.right_area.setCurrentIndex(0)
hbox = QHBoxLayout()
hbox.setSpacing(0)
hbox.setContentsMargins(0, 0, 0, 0)
hbox.addWidget(self.feed_area)
hbox.addWidget(self.right_area)
hbox.setStretchFactor(self.feed_area, 1)
hbox.setStretchFactor(self.right_area, 3)
self.setLayout(hbox)
self.feed_list.itemActivated.connect(self.handle_feed)
self.article_list.itemActivated.connect(self.handle_article)
self.feed_object_dict = {}
self.fetch_feeds()
def fetch_feeds(self):
if os.path.exists(self.feed_file_path):
try:
with open(self.feed_file_path, "r") as feed_file:
feed_dict = json.loads(feed_file.read())
for index, feed_link in enumerate(feed_dict):
self.fetch_feed(feed_link, index == 0)
except Exception:
pass
def handle_feed(self, feed_item):
if feed_item.feed_link in self.feed_object_dict:
self.update_article_area(
self.feed_object_dict[feed_item.feed_link])
def handle_article(self, article_item):
self.browser.setUrl(QUrl(article_item.post_link))
def fetch_feed(self, feed_link, refresh_ui):
fetchThread = FetchRSSThread(feed_link)
fetchThread.fetch_rss.connect(
lambda f_object, f_link, f_title: self.handle_rss(
f_object, f_link, f_title, refresh_ui))
fetchThread.invalid_rss.connect(self.handle_invalid_rss)
object_name = "feed_thread_" + feed_link
setattr(self, object_name, fetchThread)
getattr(self, object_name).start()
def add_subscription(self, feed_link):
if not self.feed_is_exits(feed_link):
self.fetch_feed(feed_link, True)
else:
self.message_to_emacs.emit("Feed has exists: " + feed_link)
def feed_is_exits(self, feed_link):
if not os.path.exists(self.feed_file_path):
return False
try:
with open(self.feed_file_path, "r") as feed_file:
feed_dict = json.loads(feed_file.read())
return feed_link in feed_dict
except Exception:
import traceback
traceback.print_exc()
return False
def save_feed(self, feed_link, feed_title):
if not os.path.exists(self.feed_file_path):
basedir = os.path.dirname(self.feed_file_path)
if not os.path.exists(basedir):
os.makedirs(basedir)
with open(self.feed_file_path, "a"):
os.utime(self.feed_file_path, None)
try:
with open(self.feed_file_path, "r") as feed_file:
feed_dict = json.loads(feed_file.read())
if feed_link not in feed_dict:
feed_dict[feed_link] = {"title": feed_title}
with open(self.feed_file_path, "w") as f:
f.write(json.dumps(feed_dict))
self.message_to_emacs.emit("Add feed: " + feed_link)
except Exception:
import traceback
traceback.print_exc()
with open(self.feed_file_path, "w") as f:
f.write(json.dumps({feed_link: {"title": feed_title}}))
self.message_to_emacs.emit("Add feed: " + feed_link)
def handle_rss(self, feed_object, feed_link, feed_title, refresh_ui):
self.feed_object_dict[feed_link] = feed_object
self.save_feed(feed_link, feed_title)
self.right_area.setCurrentIndex(1)
feed_item = QListWidgetItem(self.feed_list)
feed_item.feed_link = feed_link
feed_item_widget = RSSFeedItem(feed_object, len(feed_object.entries))
feed_item.setSizeHint(feed_item_widget.sizeHint())
self.feed_list.addItem(feed_item)
self.feed_list.setItemWidget(feed_item, feed_item_widget)
if refresh_ui:
self.update_article_area(feed_object)
def update_article_area(self, feed_object):
self.browser.setUrl(QUrl(feed_object.entries[0].link))
self.article_list.clear()
for post in feed_object.entries:
item_widget = RSSArticleItem(post)
item = QListWidgetItem(self.article_list)
item.post_link = item_widget.post_link
item.setSizeHint(item_widget.sizeHint())
self.article_list.addItem(item)
self.article_list.setItemWidget(item, item_widget)
def handle_invalid_rss(self, feed_link):
self.message_to_emacs.emit("Invalid feed link: " + feed_link)
class Plotter(QWidget):
def __init__(self, parent=None):
super(Plotter, self).__init__(parent)
self.header = []
self.data = []
self.xvar = QListWidget(self)
self.yvar = QListWidget(self)
self.figure = plt.figure()
self.canvas = FigureCanvas(self.figure)
self.toolbar = NavigationToolbar(self.canvas, self)
self.btn_clear = QPushButton("Clear data", self)
self.xvar.itemClicked.connect(self.plot)
self.yvar.itemClicked.connect(self.plot)
self.btn_clear.clicked.connect(self.clear)
# set the layout
configpanelayout = QGridLayout()
configpanelayout.addWidget(QLabel('<b>X variable:</b>'), 0, 0)
configpanelayout.addWidget(self.xvar, 1, 0)
configpanelayout.addWidget(QLabel('<b>Y variable:</b>'), 0, 1)
configpanelayout.addWidget(self.yvar, 1, 1)
toolbarlayout = QHBoxLayout()
toolbarlayout.addWidget(self.toolbar)
toolbarlayout.addWidget(self.btn_clear)
layout = QVBoxLayout()
layout.addLayout(configpanelayout)
layout.addLayout(toolbarlayout)
layout.addWidget(self.canvas)
layout.setStretch(0, 1)
layout.setStretch(2, 2)
self.setLayout(layout)
@pyqtSlot()
def clear(self):
self.data = []
self.plot()
@pyqtSlot()
def plot(self):
# clear the plotting window
ax = self.figure.add_subplot(111)
ax.clear()
# check if data to plot is available
if self.data != []:
# check if the user chose valid variables to plot
ix = self.xvar.currentRow()
iy = self.yvar.currentRow()
if ix >= 0 and iy >= 0:
# if yes, plot stuff and update axes lables
ax.plot(np.asarray(self.data).T[ix], np.asarray(self.data).T[iy], '*-')
ax.set_xlabel(self.header[ix])
ax.set_ylabel(self.header[iy])
self.canvas.draw()
@pyqtSlot(list)
def set_header(self, header):
self.header = header
self.xvar.clear()
self.yvar.clear()
ax = self.figure.add_subplot(111)
ax.clear()
self.canvas.draw()
for col in header:
self.xvar.addItem(col)
self.yvar.addItem(col)
@pyqtSlot(list)
def new_data_handler(self, row):
self.data.append(row)
self.plot()
class ConfDialog(QWidget):
"""config dialog"""
def __init__(self, mainwin):
super(ConfDialog, self).__init__()
self._app = QApplication.instance() # 获取app实例
self.setWindowFlags(Qt.Tool | Qt.WindowStaysOnTopHint)
self.win = mainwin
self.initUI()
def initUI(self):
mainLayout = QVBoxLayout()
layH1 = QHBoxLayout()
layH2 = QHBoxLayout()
self.conflist = QListWidget()
self.stack = QStackedWidget()
layH1.addWidget(self.conflist)
layH1.addWidget(self.stack)
self.okbtn = QPushButton(self.tr("OK"))
self.cancelbtn = QPushButton(self.tr("Cancel"))
layH2.addStretch(1)
layH2.addWidget(self.okbtn)
layH2.addWidget(self.cancelbtn)
mainLayout.addLayout(layH1)
mainLayout.addLayout(layH2)
self.setLayout(mainLayout)
# list
self.conflist.addItem(self.tr("General"))
self.conflist.addItem(self.tr("Editor"))
self.conflist.setMaximumWidth(150)
# general
w = QWidget()
layw = QVBoxLayout()
g = QGroupBox(self.tr("General"))
glayout = QFormLayout()
label1 = QLabel(self.tr("select UI language:"))
self.langCombo = QComboBox()
self.setLangItems(self.langCombo) # .addItems(self.getLangList())
self.langCombo.setMinimumWidth(150)
label2 = QLabel(self.tr("Number of recent files:"))
self.recentcountspin = QSpinBox()
self.recentcountspin.setMinimum(1)
self.recentcountspin.setMaximum(30)
label3 = QLabel(self.tr("Font Size:"))
self.fontsizespin = QSpinBox()
self.fontsizespin.setMinimum(1)
self.fontsizespin.setMaximum(30)
glayout.addRow(label1, self.langCombo)
glayout.addRow(label2, self.recentcountspin)
glayout.addRow(label3, self.fontsizespin)
g.setLayout(glayout)
layw.addWidget(g)
layw.addStretch(1)
w.setLayout(layw)
self.stack.addWidget(w)
# editor
from ui.editor.settings import EditorSettings
w = EditorSettings(self.win.editor)
self.stack.addWidget(w)
self.conflist.currentRowChanged.connect(self.stack.setCurrentIndex)
self.cancelbtn.clicked.connect(self.close)
self.cancelbtn.setVisible(False)
self.okbtn.clicked.connect(self.close)
# action
self.fontsizespin.valueChanged.connect(
self.win.editor.font().setPointSize)
def setCount(x):
self.win.recent.maxcount = x
self.recentcountspin.valueChanged.connect(setCount)
self.langCombo.currentIndexChanged.connect(self.chLang)
def setLangItems(self, combo):
from i18n.language import Language
langs = Language.getLangs()
for l in langs:
combo.addItem(l["nativename"], l["lang"])
return True
def chLang(self):
# print("Change language to "+lang)
# try:
# if lang.lower()=="english":
# self._app.removeTranslator(self.win.trans)
# return
# self.win.trans.load("i18n-"+lang+".qm")
# self._app.installTranslator(self.win.trans)
# #self._app.retranslateUi(self)# 重新翻译界面
# except Exception as Argument:
# print(Argument)
lang = self.langCombo.currentData()
print("Setting Language to " + lang)
self.win.config.getSec("general")["language"] = lang
print("restart soft to enable.")
def show(self):
# default value
self.fontsizespin.setValue(self.win.editor.font().pointSize())
self.recentcountspin.setValue(self.win.recent.maxcount)
lang = self.win.config.getSec("general").get("language", None)
if lang is None:
lang = "en"
from i18n.language import Language
for l in Language.getLangs():
if l["lang"] == lang:
self.langCombo.setCurrentText(l["nativename"])
break
super().show()
class Commision_Tab(QWidget):
def __init__(self):
super().__init__()
# Widedgets
self.info_label = QLabel('Please choose the spectrum, angular distribution and spatial distribution files '
'of your beam.')
self.files_group = QGroupBox('Browse Files')
self.spectrum_button = QPushButton('Choose Spectrum File')
self.spectrum_line = QLineEdit()
self.angular_button = QPushButton('Choose Angular File')
self.angular_line = QLineEdit()
self.spatial_button = QPushButton('Choose Spatial File')
self.spatial_line = QLineEdit()
self.notice_label = QLabel('Attention: This operation will only generate a temporary beam in the input')
self.commission_group = QGroupBox('Change Commissioned Beams')
self.commission_text = QListWidget()
self.organize_widget = QWidget()
self.load_button = QPushButton('Load Beam')
self.load_button.setDisabled(True)
self.add_button = QPushButton('Add Beam')
self.delete_button = QPushButton('Delete Beam')
self.delete_button.setDisabled(True)
self.new_beam_label = QLabel('New Beam Name')
self.new_beam_line = QLineEdit()
# Layouts
self.main_layout = QVBoxLayout()
self.files_layout = QGridLayout()
self.organize_layout = QGridLayout()
self.commission_layout = QHBoxLayout()
self.layout_init()
self.pushbutton_init()
self.listwidget_init()
def layout_init(self):
self.files_layout.addWidget(self.spectrum_button, 0, 0)
self.files_layout.addWidget(self.spectrum_line, 0, 1)
self.files_layout.addWidget(self.angular_button, 1, 0)
self.files_layout.addWidget(self.angular_line, 1, 1)
self.files_layout.addWidget(self.spatial_button, 2, 0)
self.files_layout.addWidget(self.spatial_line, 2, 1)
self.files_group.setLayout(self.files_layout)
self.commission_layout.addWidget(self.commission_text)
self.commission_layout.addWidget(self.organize_widget)
self.commission_group.setLayout(self.commission_layout)
self.organize_layout.addWidget(self.load_button, 0, 0)
self.organize_layout.addWidget(self.delete_button, 0, 1)
self.organize_layout.addWidget(self.add_button, 2, 0)
self.organize_layout.addWidget(self.new_beam_label, 1, 0)
self.organize_layout.addWidget(self.new_beam_line, 1, 1)
self.organize_widget.setLayout(self.organize_layout)
self.main_layout.addWidget(self.info_label)
self.main_layout.addWidget(self.files_group)
self.main_layout.addWidget(self.notice_label)
self.main_layout.addWidget(self.commission_group)
self.setLayout(self.main_layout)
def pushbutton_init(self):
self.spectrum_button.clicked.connect(self.get_spectrum)
self.angular_button.clicked.connect(self.get_angular)
self.spatial_button.clicked.connect(self.get_spatial)
self.add_button.clicked.connect(self.add_new_beam)
self.delete_button.clicked.connect(self.delete_beam)
self.load_button.clicked.connect(self.load_beam)
def listwidget_init(self):
self.beam_list = beam_dict.list_beams()
for i in range(len(self.beam_list)):
QListWidgetItem(self.beam_list[i], self.commission_text)
self.commission_text.itemSelectionChanged.connect(self.beam_selected)
def beam_init(self):
glv.set_value('spectrum file', self.spectrum_line.text())
glv.set_value('angular file', self.angular_line.text())
glv.set_value('spatial file', self.spatial_line.text())
glv.set_value('new beam name', self.new_beam_line.text())
def get_spectrum(self):
try:
f = Finddir().find_beam_file()
if f == '':
pass
else:
self.spectrum_line.setText(str(f))
except TypeError:
pass
def get_angular(self):
try:
f = Finddir().find_beam_file()
if f == '':
pass
else:
self.angular_line.setText(str(f))
except TypeError:
pass
def get_spatial(self):
try:
f = Finddir().find_beam_file()
if f == '':
pass
else:
self.spatial_line.setText(str(f))
except TypeError:
pass
def beam_selected(self):
self.delete_button.setDisabled(False)
self.load_button.setDisabled(False)
def load_beam(self):
beam_list = beam_dict.list_beams()
selected_index = self.commission_text.currentRow()
beam_load = beam_list[selected_index]
beam_feature = beam_dict.get_beam(beam_load)
self.spectrum_line.setText(beam_feature[0])
self.angular_line.setText(beam_feature[1])
self.spatial_line.setText(beam_feature[2])
def delete_beam(self):
# need to reload the beam list, otherwise the list index can be used only once
beam_list = beam_dict.list_beams()
selected_index = self.commission_text.currentRow()
beam_delete = beam_list[selected_index]
beam_dict.delete_beam(beam_delete)
beam_dict.update_beam()
beam_dict.update_list()
self.commission_text.takeItem(self.commission_text.currentRow())
def add_new_beam(self):
self.beam_init()
if Beam_Check().add_new_check():
name = glv.get_value('new beam name')
spectrum = glv.get_value('spectrum file')
angular = glv.get_value('angular file')
spatial = glv.get_value('spatial file')
beam_features = [spectrum, angular, spatial]
beam_dict.add_beam(name, beam_features)
self.commission_text.addItem(name)
beam_dict.update_beam()
beam_dict.update_list()
else:
pass
class GuiDocSplit(QDialog):
def __init__(self, theParent, theProject):
QDialog.__init__(self, theParent)
logger.debug("Initialising GuiDocSplit ...")
self.mainConf = nw.CONFIG
self.theParent = theParent
self.theProject = theProject
self.sourceItem = None
self.outerBox = QHBoxLayout()
self.innerBox = QVBoxLayout()
self.setWindowTitle("Split Document")
self.setLayout(self.outerBox)
self.guiDeco = self.theParent.theTheme.loadDecoration("split",(64,64))
self.outerBox.addWidget(self.guiDeco, 0, Qt.AlignTop)
self.outerBox.addLayout(self.innerBox)
self.doMergeForm = QGridLayout()
self.doMergeForm.setContentsMargins(0,0,0,0)
self.listBox = QListWidget()
self.listBox.setDragDropMode(QAbstractItemView.NoDragDrop)
self.splitLevel = QComboBox(self)
self.splitLevel.addItem("Split on Header Level 1 (Title)", 1)
self.splitLevel.addItem("Split up to Header Level 2 (Chapter)", 2)
self.splitLevel.addItem("Split up to Header Level 3 (Scene)", 3)
self.splitLevel.addItem("Split up to Header Level 4 (Section)", 4)
self.splitLevel.setCurrentIndex(2)
self.splitLevel.currentIndexChanged.connect(self._populateList)
self.splitButton = QPushButton("Split")
self.splitButton.clicked.connect(self._doSplit)
self.closeButton = QPushButton("Close")
self.closeButton.clicked.connect(self._doClose)
self.doMergeForm.addWidget(self.listBox, 0, 0, 1, 3)
self.doMergeForm.addWidget(self.splitLevel, 1, 0, 1, 3)
self.doMergeForm.addWidget(self.splitButton, 2, 1)
self.doMergeForm.addWidget(self.closeButton, 2, 2)
self.innerBox.addLayout(self.doMergeForm)
self.rejected.connect(self._doClose)
self.show()
self._populateList()
logger.debug("GuiDocSplit initialisation complete")
return
##
# Buttons
##
def _doSplit(self):
"""Perform the split of the file, create a new folder in the
same parent folder, and multiple files depending on split level
settings. The old file is not removed in the merge process, and
must be deleted manually.
"""
logger.verbose("GuiDocSplit split button clicked")
if self.sourceItem is None:
self.theParent.makeAlert((
"No source document selected. Nothing to do."
), nwAlert.ERROR)
return
srcItem = self.theProject.getItem(self.sourceItem)
if srcItem is None:
self.theParent.makeAlert((
"Could not parse source document."
), nwAlert.ERROR)
return
theDoc = NWDoc(self.theProject, self.theParent)
theText = theDoc.openDocument(self.sourceItem, False)
theLines = theText.splitlines()
nLines = len(theLines)
theLines.insert(0, "%Split Doc")
logger.debug(
"Splitting document %s with %d lines" % (self.sourceItem,nLines)
)
finalOrder = []
for i in range(self.listBox.count()):
listItem = self.listBox.item(i)
wTitle = listItem.text()
lineNo = listItem.data(Qt.UserRole)
finalOrder.append([wTitle, lineNo, nLines])
if i > 0:
finalOrder[i-1][2] = lineNo
if len(finalOrder) == 0:
self.theParent.makeAlert((
"No headers found. Nothing to do."
), nwAlert.ERROR)
return
fHandle = self.theProject.newFolder(srcItem.itemName, srcItem.itemClass, srcItem.parHandle)
self.theParent.treeView.revealTreeItem(fHandle)
logger.verbose("Creating folder %s" % fHandle)
for wTitle, iStart, iEnd in finalOrder:
itemLayout = nwItemLayout.NOTE
if srcItem.itemClass == nwItemClass.NOVEL:
if wTitle.startswith("# "):
itemLayout = nwItemLayout.PARTITION
elif wTitle.startswith("## "):
itemLayout = nwItemLayout.CHAPTER
elif wTitle.startswith("### "):
itemLayout = nwItemLayout.SCENE
elif wTitle.startswith("#### "):
itemLayout = nwItemLayout.PAGE
wTitle = wTitle.lstrip("#")
wTitle = wTitle.strip()
nHandle = self.theProject.newFile(wTitle, srcItem.itemClass, fHandle)
newItem = self.theProject.getItem(nHandle)
newItem.setLayout(itemLayout)
logger.verbose(
"Creating new document %s with text from line %d to %d" % (nHandle, iStart, iEnd-1)
)
theText = "\n".join(theLines[iStart:iEnd])
theDoc.openDocument(nHandle, False)
theDoc.saveDocument(theText)
theDoc.clearDocument()
self.theParent.treeView.revealTreeItem(nHandle)
self.close()
return
def _doClose(self):
"""Close the dialog window without doing anything.
"""
logger.verbose("GuiDocSplit close button clicked")
self.close()
return
##
# Internal Functions
##
def _populateList(self):
"""Get the item selected in the tree, check that it is a folder,
and try to find all files associated with it. The valid files
are then added to the list view in order. The list itself can be
reordered by the user.
"""
if self.sourceItem is None:
self.sourceItem = self.theParent.treeView.getSelectedHandle()
if self.sourceItem is None:
return
nwItem = self.theProject.getItem(self.sourceItem)
if nwItem is None:
return
if nwItem.itemType is not nwItemType.FILE:
self.theParent.makeAlert((
"Element selected in the project tree must be a file."
), nwAlert.ERROR)
return
self.listBox.clear()
theDoc = NWDoc(self.theProject, self.theParent)
theText = theDoc.openDocument(self.sourceItem, False)
spLevel = self.splitLevel.currentData()
logger.debug("Scanning document %s for headings level <= %d" % (self.sourceItem, spLevel))
lineNo = 0
for aLine in theText.splitlines():
lineNo += 1
onLine = 0
if aLine.startswith("# ") and spLevel >= 1:
onLine = lineNo
elif aLine.startswith("## ") and spLevel >= 2:
onLine = lineNo
elif aLine.startswith("### ") and spLevel >= 3:
onLine = lineNo
elif aLine.startswith("#### ") and spLevel >= 4:
onLine = lineNo
if onLine > 0:
newItem = QListWidgetItem()
newItem.setText(aLine.strip())
newItem.setData(Qt.UserRole, onLine)
self.listBox.addItem(newItem)
return
class NetworksBrowserWindow(MainWindow):
def __init__(self):
super(NetworksBrowserWindow, self).__init__()
self.browserEngineView = WebEngineView()
self.browserEngineView.setUrl(Url(homePageUrl))
self.setCentralWidget(self.browserEngineView)
self.showMaximized()
self.createNavBar()
self.createDockWidget()
self.browserEngineView.urlChanged.connect(self.updateUrl)
def createDockWidget(self) -> None:
dockWidget = DockWidget("Executed Operations", self)
self.addDockWidget(Qt.RightDockWidgetArea, dockWidget)
self.listWidget = ListWidget()
dockWidget.setWidget(self.listWidget)
dockWidget.setFloating(False)
self.listWidget.setSpacing(10)
def createNavBar(self) -> None:
navbar = NavBar()
self.addToolBar(navbar)
self.addToolBarBreak()
backButton = Action("Go Back", self)
backButton.triggered.connect(self.browserEngineView.back)
forwardButton = Action("Go Forward", self)
forwardButton.triggered.connect(self.browserEngineView.forward)
reloadButton = Action("Reload Page", self)
reloadButton.triggered.connect(self.browserEngineView.reload)
homeButton = Action("Go to Home", self)
homeButton.triggered.connect(self.navigateHome)
networkDetailsButton = Action("Network Details", self)
networkDetailsButton.triggered.connect(self.fetchNetworkDetails)
ipConfigButton = Action("IP Config", self)
ipConfigButton.triggered.connect(self.fetchIpConfig)
navbar.addActions([
backButton,
forwardButton,
reloadButton,
homeButton,
networkDetailsButton,
ipConfigButton,
])
self.urlBar = LineEdit()
self.urlBar.returnPressed.connect(self.navigateToUrl)
navbar.addWidget(self.urlBar)
def navigateHome(self) -> None:
self.listWidget.addItem("Navigating Back to Home")
self.browserEngineView.setUrl(Url(homePageUrl))
self.listWidget.addItem("Navigation Back to Home Ended")
def navigateToUrl(self) -> None:
self.listWidget.addItem("Navigating to given url")
windowUrl = self.urlBar.text()
self.browserEngineView.setUrl(Url(windowUrl))
self.listWidget.addItem("Navigation to given url Ended")
def updateUrl(self, query: Any) -> None:
self.listWidget.addItem("Updating url")
self.urlBar.setText(query.toString())
self.listWidget.addItem("Update operation on url Ended")
def fetchIpConfig(self) -> None:
self.listWidget.addItem("Fetching System's IP Config")
executeSystemCommand("ipconfig")
def fetchNetworkDetails(self) -> None:
self.listWidget.addItem("Fetching Network Details")
try:
ipAddress = fetchHostIpAddress()
print("\nWindow IP address is :\t", ipAddress)
windowUrl = self.urlBar.text()
formattedUrl = windowUrl[windowUrl.find("www.") +
4:windowUrl.rfind("/")]
tracertWithUrl = "tracert " + formattedUrl
self.listWidget.addItem("Executing '" + tracertWithUrl + "'")
executeSystemCommand(tracertWithUrl)
except:
self.listWidget.addItem("Could not Fetch Network Details")
class CityListDlg(QDialog):
citieslist_signal = pyqtSignal([list])
def __init__(self, citylist, accurate_url, appid, parent=None):
super(CityListDlg, self).__init__(parent)
self.citylist = citylist
self.accurate_url = accurate_url
self.appid = appid
self.listWidget = QListWidget()
self.listWidget.addItems(self.citylist)
buttonLayout = QVBoxLayout()
self.buttonBox = QDialogButtonBox()
self.buttonBox.setOrientation(Qt.Horizontal)
self.buttonBox.setStandardButtons(QDialogButtonBox.Ok | QDialogButtonBox.Cancel)
self.buttonBox.rejected.connect(self.reject)
self.buttonBox.accepted.connect(self.accept)
layoutT = QVBoxLayout()
layout = QHBoxLayout()
layout.addWidget(self.listWidget)
layout.addLayout(buttonLayout)
for text, slot in ((self.tr("&Add..."), self.add),
(self.tr("&Remove..."), self.remove),
(self.tr("&Up"), self.up),
(self.tr("&Down"), self.down),
(self.tr("De&fault"), self.default),
(self.tr("&Sort"), self.listWidget.sortItems)):
button = QPushButton(text)
buttonLayout.addWidget(button)
button.clicked.connect(slot)
buttonLayout.addWidget(self.buttonBox)
self.status = QLabel()
layoutT.addLayout(layout)
layoutT.addWidget(self.status)
self.setLayout(layoutT)
self.checklength()
def add(self):
self.status.setText('')
lista = []
newitem = ''
self.citytoadd = ''
self.countrytoadd = ''
self._idtoadd = ''
dialog = searchcity.SearchCity(self.accurate_url, self.appid, self)
dialog.id_signal.connect(self.addcity)
dialog.city_signal.connect(self.addcity)
dialog.country_signal.connect(self.addcity)
if dialog.exec_() == 1:
newitem = (self.citytoadd + '_' + self.countrytoadd + '_' +
self._idtoadd)
for row in range(self.listWidget.count()):
lista.append(self.listWidget.item(row).text())
if newitem in lista:
self.status.setText(QCoreApplication.translate('Status bar message',
'The city already exists in the list', 'Cities list dialogue'))
return
else:
self.listWidget.addItem(newitem)
self.checklength()
def addcity(self, what):
self.status.setText('')
if what[0] == 'ID':
self._idtoadd = what[1]
elif what[0] == 'City':
self.citytoadd = what[1]
elif what[0] == 'Country':
self.countrytoadd = what[1]
def remove(self):
self.status.setText('')
if self.listWidget.count() == 0:
self.status.setText(self.tr('The list is empty'))
return
row = self.listWidget.currentRow()
item = self.listWidget.item(row)
if item is None:
return
message = self.tr('The city "{0}" has been removed').format(
self.listWidget.item(row).text())
item = self.listWidget.takeItem(row)
del item
self.status.setText(message)
def up(self):
self.status.setText('')
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):
self.status.setText('')
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 default(self):
self.status.setText('')
row = self.listWidget.currentRow()
if row >= 1:
item = self.listWidget.takeItem(row)
self.listWidget.insertItem(0, item)
self.listWidget.setCurrentItem(item)
def checklength(self):
listtosend = []
for row in range(self.listWidget.count()):
listtosend.append(self.listWidget.item(row).text())
if len(listtosend) == 0:
return
self.listWidget.setMinimumWidth(self.listWidget.sizeHintForColumn(0))
def accept(self):
listtosend = []
for row in range(self.listWidget.count()):
listtosend.append(self.listWidget.item(row).text())
self.citieslist_signal[list].emit(listtosend)
QDialog.accept(self)
class TabMain_gui(QWidget):
def __init__(self, caller, *args, **kwargs):
QWidget.__init__(self)
self.caller = caller
###-- Initialize
self.loadIcons()
self.initGlobalButtons()
self.initBody()
###-- Compose layout
mainVertical = QVBoxLayout()
mainVertical.setSpacing(10)
mainVertical.addLayout(self.globalButtons)
mainVertical.addWidget(self.body)
###-- Set Layout
self.setLayout(mainVertical)
def initGlobalButtons(self):
###-- Global Buttons
globalButtons = QHBoxLayout()
self.button_startAll = QPushButton("Start All Masternodes")
globalButtons.addWidget(self.button_startAll)
self.button_getAllStatus = QPushButton("Get Status of All Masternodes")
globalButtons.addWidget(self.button_getAllStatus)
self.button_sweepAllRewards = QPushButton("Sweep All Rewards")
globalButtons.addWidget(self.button_sweepAllRewards)
self.globalButtons = globalButtons
def initBody(self):
###-- CENTRAL PART
self.body = QGroupBox()
self.body.setTitle("My Masternodes")
# masternode list
self.myList = QListWidget()
self.myList.setUpdatesEnabled(True)
self.myList.setDragDropMode(QAbstractItemView.InternalMove)
self.myList.setDefaultDropAction(Qt.MoveAction)
self.current_mn = {}
self.mnLed = {}
self.mnLabel = {}
self.mnBalance = {}
self.btn_details = {}
self.mnStatusLabel = {}
self.mnStatusProgress = {}
self.btn_remove = {}
self.btn_edit = {}
self.btn_start = {}
self.btn_rewards = {}
for masternode in self.caller.masternode_list:
name = masternode['name']
self.insert_mn_list(name, masternode['ip'], masternode['port'], isHardware=masternode['isHardware'])
vBox = QVBoxLayout()
vBox.addWidget(self.myList)
self.button_addMasternode = QPushButton("New Masternode")
vBox.addWidget(self.button_addMasternode)
vBox.stretch(1)
self.body.setLayout(vBox)
def insert_mn_list(self, name, ip, port, row=None, isHardware=True):
mnRow = QWidget()
mnRow.alias = name
if isHardware:
mnRow.setToolTip("Drag rows to re-order.")
else:
mnRow.setToolTip("EXTERNAL MASTERNODE - Drag rows to re-order.")
mnRowLayout = QHBoxLayout()
##--- Led
self.mnLed[name] = QLabel()
self.mnLed[name].setPixmap(self.caller.ledGrayV_icon)
mnRowLayout.addWidget(self.mnLed[name])
##--- Label & Balance
self.mnLabel[name] = QLabel()
if isHardware:
self.mnLabel[name].setText("%s [<i>%s</i>]" % (name, ip))
else:
self.mnLabel[name].setText("<span style='color: orange'>%s</span> [<i>%s</i>]" % (name, ip))
mnRowLayout.addWidget(self.mnLabel[name])
self.mnBalance[name] = QLabel()
mnRowLayout.addWidget(self.mnBalance[name])
self.mnBalance[name].hide()
mnRowLayout.addStretch(1)
##--- Status Label
self.mnStatusLabel[name] = QLabel()
mnRowLayout.addWidget(self.mnStatusLabel[name])
self.mnStatusLabel[name].hide()
##--- Rank bar
self.mnStatusProgress[name] = QProgressBar()
self.mnStatusProgress[name].setMaximumHeight(15)
self.mnStatusProgress[name].setMaximumWidth(40)
self.mnStatusProgress[name].setTextVisible(False)
mnRowLayout.addWidget(self.mnStatusProgress[name])
self.mnStatusProgress[name].hide()
##--- Details button
self.btn_details[name] = QToolButton()
self.btn_details[name].setIcon(self.details_icon)
self.btn_details[name].setToolTip('Check status details of masternode "%s"' % name)
mnRowLayout.addWidget(self.btn_details[name])
self.btn_details[name].hide()
##--- Rewards button
self.btn_rewards[name] = QPushButton()
self.btn_rewards[name].setToolTip('Transfer rewards from "%s"' % name)
self.btn_rewards[name].setIcon(self.rewards_icon)
self.btn_rewards[name].alias = name
if not isHardware:
self.btn_rewards[name].setDisabled(True)
self.btn_rewards[name].setToolTip("EXTERNAL MN: unable to move rewards with SPMT")
mnRowLayout.addWidget(self.btn_rewards[name])
##--- Start button
self.btn_start[name] = QPushButton()
self.btn_start[name].setToolTip('Start masternode "%s"' % name)
self.btn_start[name].setIcon(self.startMN_icon)
self.btn_start[name].alias = name
if not isHardware:
self.btn_start[name].setDisabled(True)
self.btn_start[name].setToolTip("EXTERNAL MN: unable to start with SPMT")
mnRowLayout.addWidget(self.btn_start[name])
##--- Edit button
self.btn_edit[name] = QPushButton()
self.btn_edit[name].setToolTip('Edit masternode "%s"' % name)
self.btn_edit[name].setIcon(self.editMN_icon)
self.btn_edit[name].alias = name
if not isHardware:
self.btn_edit[name].setDisabled(True)
self.btn_edit[name].setToolTip("EXTERNAL MN: to edit, delete entry and load new 'masternode.conf'")
mnRowLayout.addWidget(self.btn_edit[name])
##--- Remove button
self.btn_remove[name] = QPushButton()
self.btn_remove[name].setToolTip('Delete masternode "%s"' % name)
self.btn_remove[name].setIcon(self.removeMN_icon)
self.btn_remove[name].alias = name
mnRowLayout.addWidget(self.btn_remove[name])
##--- Three Dots
threeDots = QLabel()
threeDots.setPixmap(self.threeDots_icon.scaledToHeight(20, Qt.SmoothTransformation))
mnRowLayout.addWidget(threeDots)
##--- Set Row Layout
mnRow.setLayout(mnRowLayout)
##--- Append Row
self.current_mn[name] = QListWidgetItem()
#self.current_mn[name].setFlags(Qt.ItemIsSelectable)
self.current_mn[name].setSizeHint(mnRow.sizeHint())
if row is not None:
self.myList.insertItem(row, self.current_mn[name])
else:
self.myList.addItem(self.current_mn[name])
self.myList.setItemWidget(self.current_mn[name], mnRow)
def loadIcons(self):
self.removeMN_icon = QIcon(os.path.join(self.caller.imgDir, 'icon_delete.png'))
self.editMN_icon = QIcon(os.path.join(self.caller.imgDir, 'icon_edit.png'))
self.startMN_icon = QIcon(os.path.join(self.caller.imgDir, 'icon_rocket.png'))
self.rewards_icon = QIcon(os.path.join(self.caller.imgDir, 'icon_money.png'))
self.details_icon = QIcon(os.path.join(self.caller.imgDir, 'icon_search.png'))
self.ledgerImg = QPixmap(os.path.join(self.caller.imgDir, 'ledger.png'))
self.trezorImg = QPixmap(os.path.join(self.caller.imgDir, 'trezorModT.png'))
self.trezorOneImg = QPixmap(os.path.join(self.caller.imgDir, 'trezorOne.png'))
self.coldStaking_icon = QIcon(os.path.join(self.caller.imgDir, 'icon_coldstaking.png'))
self.threeDots_icon = QPixmap(os.path.join(self.caller.imgDir, 'icon_3dots.png'))
class UserCenter(QWidget):
avatar_changed = pyqtSignal(str)
psd_changed = pyqtSignal(bool)
def __init__(self, user_id, *args, **kwargs):
super(UserCenter, self).__init__(*args, **kwargs)
self.user_id = user_id
self.set_new_avatar = False
layout = QVBoxLayout() # 总布局
layout.setContentsMargins(QMargins(100, 10, 100, 10))
middle_layout = QHBoxLayout() # 中间布局
# 左侧显示头像和菜单
left_layout = QVBoxLayout() # 左侧布局
self.avatar = CAvatar(size=QSize(180, 180))
self.avatar.clicked.connect(self.modify_user_avatar)
left_layout.addWidget(self.avatar, alignment=Qt.AlignCenter)
machine_code = settings.app_dawn.value('machine')
code_label = QLineEdit(machine_code, parent=self)
code_label.setMaximumWidth(250)
code_label.setCursor(QCursor(Qt.ArrowCursor))
code_label.setAlignment(Qt.AlignCenter)
code_label.setFocusPolicy(Qt.NoFocus)
left_layout.addWidget(code_label)
# 菜单
self.left_list = QListWidget(clicked=self.menu_clicked, parent=self)
self.left_list.setMaximumWidth(250)
item1 = QListWidgetItem('基本资料', self.left_list)
item2 = QListWidgetItem('修改密码', self.left_list)
item1.setTextAlignment(Qt.AlignCenter)
item2.setTextAlignment(Qt.AlignCenter)
self.left_list.addItem(item1)
self.left_list.addItem(item2)
left_layout.addWidget(self.left_list)
middle_layout.addLayout(left_layout)
# 右侧显示具体窗口
self.right_win = LoadedPage(self)
self.right_win.remove_borders()
middle_layout.addWidget(self.right_win)
layout.addLayout(middle_layout)
self.setLayout(layout)
code_label.setObjectName('machineCode')
self.left_list.setObjectName('leftList')
self.setStyleSheet("""
#machineCode{
border: none;
background:rgb(240,240,240);
}
#leftList{
outline:none;
border:none;
background-color: rgb(240,240,240);
}
#leftList::item{
height:25px;
}
#leftList::item:selected{
color:rgb(100,180,230);
background-color:rgb(240,240,240);
}
#leftList::item:hover{
color:rgb(150,180,230);
background-color:rgb(240,240,240);
}
""")
self.left_list.setCurrentRow(0)
self.menu_clicked()
def setAvatar(self, avatar_url):
if avatar_url:
url = settings.STATIC_PREFIX + avatar_url
self.avatar.setUrl(url)
self.avatar_changed.emit(url)
else:
self.avatar.setUrl('media/avatar.png')
def password_changed(self):
self.psd_changed.emit(True)
# 修改用户头像
def modify_user_avatar(self):
popup = EditUserAvatar(user_id=self.user_id,
current_url=self.avatar.url,
parent=self)
popup.new_avatar_url.connect(self.setAvatar)
popup.exec_()
# 点击左侧菜单
def menu_clicked(self):
current_item = self.left_list.currentItem()
text = current_item.text()
if text == '基本资料':
frame_page = BaseInfo(uid=self.user_id)
frame_page.avatar_url.connect(self.setAvatar)
frame_page.on_load_info() # 获取基本信息
elif text == '修改密码':
frame_page = ModifyPassword(user_id=self.user_id)
frame_page.new_password.connect(self.password_changed)
else:
frame_page = QLabel()
self.right_win.clear()
self.right_win.addWidget(frame_page)
class Window(QtWidgets.QWidget):
def __init__(self, parent=None):
super(Window, self).__init__(parent)
self.user_interface()
def item_click(self, item):
number = self.view.currentRow()
if self.shuffled == False:
self.playlist.setCurrentIndex(number)
self.player.play()
elif self.shuffled == True:
pass
def item_doubleclick(self, item):
self.current_item_song = item
menu = QtWidgets.QMenu()
createPlaylist = QAction('Create New Playlist')
createPlaylist.triggered.connect(self.create_playlist)
menu.addAction(createPlaylist)
addToPlaylist = QAction('Add To Playlist')
addToPlaylist.triggered.connect(self.add_to_playlist)
menu.addAction(addToPlaylist)
menu.exec_()
def user_interface(self):
self.all_song_button = QtWidgets.QPushButton("All songs")
self.play_button = QtWidgets.QPushButton()
self.play_button.setIcon(self.style().standardIcon(
QStyle.SP_MediaPlay))
self.next_button = QtWidgets.QPushButton()
self.next_button.setIcon(self.style().standardIcon(
QStyle.SP_MediaSeekForward))
self.prev_button = QtWidgets.QPushButton()
self.prev_button.setIcon(self.style().standardIcon(
QStyle.SP_MediaSeekBackward))
self.shuffle_button = QtWidgets.QPushButton("🔀")
self.min_volumn = QtWidgets.QLabel("🔈")
self.max_volumn = QtWidgets.QLabel("🔊")
self.l_playlists = QtWidgets.QLabel("Playlists:")
self.l_current_song = QtWidgets.QLabel("Current song:")
self.songs = QtWidgets.QLabel("Songs:\n")
self.view = QListWidget()
self.viewPlaylists = QListWidget()
self.all_songs = self.load_songs()
self.all_playlists = self.load_playlists()
self.viewPlaylists.adjustSize()
self.view.adjustSize()
self.view.itemClicked.connect(self.item_click)
self.view.itemDoubleClicked.connect(self.item_doubleclick)
self.view.installEventFilter(self)
self.set_playlist()
self.line_edit = QtWidgets.QLineEdit()
self.line_edit.setText("")
self.search_button = QtWidgets.QPushButton("search")
# scroll are for list of songs
self.songs_scroll_area = QtWidgets.QScrollArea()
self.songs_scroll_area.setWidget(self.view)
self.songs_scroll_area.setWidgetResizable(True)
# scroll area for list of playlists
self.playlists_scroll_area = QtWidgets.QScrollArea()
self.playlists_scroll_area.setWidget(self.viewPlaylists)
self.playlists_scroll_area.setWidgetResizable(True)
# self.playlists_scroll_bar = QtWidgets.QScrollBar()
# self.playlists_scroll_area.setVerticalScrollBar(self.playlists_scroll_bar)
# self.playlists_scroll_area.setVerticalScrollBarPolicy(C.Qt.ScrollBarAlwaysOn)
# set area for current song box
self.current_song_area = QtWidgets.QScrollArea()
self.current_song_area.setWidget(self.l_current_song)
# set volumn slider
self.volumn_slider = QtWidgets.QSlider(C.Qt.Horizontal)
self.volumn_slider.setMaximum(100)
self.volumn_slider.setMinimum(0)
self.volumn_slider.setValue(50)
self.volumn_slider.setTickPosition(QtWidgets.QSlider.TicksRight)
self.volumn_slider.setTickInterval(10)
self.seekSlider = QtWidgets.QSlider()
self.seekSlider.setMinimum(0)
self.seekSlider.setMaximum(100)
self.seekSlider.setRange(0, self.player.duration() / 1000)
self.seekSlider.setOrientation(C.Qt.Horizontal)
self.seekSlider.setTracking(False)
seekSliderLabel1 = QtWidgets.QLabel('0.00')
seekSliderLabel2 = QtWidgets.QLabel('0.00')
self.set_playlist()
self.volume_change()
# self.list_view = QtWidgets.QListView(self.all_songs)
h_box = QtWidgets.QHBoxLayout()
v_box = QtWidgets.QVBoxLayout()
self.h_box4 = QtWidgets.QHBoxLayout()
# h_box.addWidget(backGround)
v_box.addWidget(self.all_song_button)
v_box.addWidget(self.playlists_scroll_area)
v_box.addWidget(self.current_song_area)
self.h_box4.addWidget(seekSliderLabel1)
self.h_box4.addWidget(self.seekSlider)
self.h_box4.addWidget(seekSliderLabel2)
h_box.addLayout(v_box)
v_box1 = QtWidgets.QVBoxLayout()
v_box1.addWidget(self.line_edit)
v_box2 = QtWidgets.QVBoxLayout()
v_box2.addWidget(self.songs_scroll_area)
h_box.addLayout(v_box1)
h_box1 = QtWidgets.QHBoxLayout()
h_box1.addWidget(self.shuffle_button)
h_box1.addWidget(self.prev_button)
h_box1.addWidget(self.play_button)
h_box1.addWidget(self.next_button)
h_box3 = QtWidgets.QHBoxLayout()
h_box3.addWidget(self.min_volumn)
h_box3.addWidget(self.volumn_slider)
h_box3.addWidget(self.max_volumn)
h_box2 = QtWidgets.QHBoxLayout()
h_box2.addWidget(self.search_button)
v_box1.addLayout(h_box2)
v_box1.addLayout(v_box2)
v_box1.addLayout(self.h_box4)
v_box1.addLayout(h_box1)
v_box1.addLayout(h_box3)
self.setLayout(h_box)
self.setWindowTitle("Music Player")
self.setGeometry(100, 100, 800, 600)
self.show()
self.play_button.setShortcut(' ')
self.next_button.setShortcut('Alt+Right')
self.prev_button.setShortcut('Alt+Left')
self.search_button.setShortcut('Return')
self.play_button.clicked.connect(self.play)
self.next_button.clicked.connect(self.next)
self.prev_button.clicked.connect(self.back)
self.shuffle_button.clicked.connect(self.shuffle)
self.search_button.clicked.connect(self.search)
self.volumn_slider.valueChanged.connect(self.volume_change)
self.all_song_button.clicked.connect(self.load_songs)
self.player.currentMediaChanged.connect(self.current_song)
self.player.positionChanged.connect(self.qmp_positionChanged)
self.player.durationChanged.connect(self.change_duration)
self.all_song_button.clicked.connect(self.show_all_songs)
self.shuffled = False
def add_to_playlist(self):
menu = QtWidgets.QMenu()
for item in self.all_playlists:
menuItemTask = menu.addAction(item)
menuItemTask.triggered.connect(self.picked_playlist)
menu.addAction(menuItemTask)
menu.exec_()
def picked_playlist(self):
print(self.current_item_song)
# file = open(item, 'w')
# file.write(self.current_item)
# file.close()
def create_playlist(self):
root = C.QFileInfo(__file__).absolutePath()
spot = (root + '/songs/')
playlistName = self.getText()
completeName = os.path.join(spot, f'{playlistName}.m3u')
file = open(completeName, 'w')
file.close()
self.all_playlists.clear()
self.playlists_scroll_area.update()
self.all_playlists = self.load_playlists()
self.playlists_scroll_area.update()
def getText(self):
text, okPressed = QInputDialog.getText(self, "New Playlist",
"Playlist Name:",
QLineEdit.Normal, "")
if okPressed and text != '':
return text
def load_playlists(self):
playlists = []
root = C.QFileInfo(__file__).absolutePath()
songs = os.listdir(root + "/songs")
for item in songs:
if str(item[-4:]) == '.m3u':
self.viewPlaylists.addItem(item[:-4])
print(root + "/songs" + item)
playlists.append(root + "/songs" + item)
return playlists
def show_all_songs(self):
self.view.clear()
self.playlist.clear()
root = C.QFileInfo(__file__).absolutePath()
songs = os.listdir(root + "/songs")
s = "Songs:\n"
for item in songs:
if item.endswith('.mp3'):
url = C.QUrl.fromLocalFile(item)
content = M.QMediaContent(url)
s = (str(item[:-4]))
self.view.addItem(s)
self.playlist.addMedia(content)
def current_song(self, media):
name = media.canonicalUrl()
name = name.toString()
name = name.split('/')
url = name[-1]
url = url[:-4]
self.l_current_song.setText('Current Song:\n\n' + url)
self.l_current_song.adjustSize()
def change_duration(self):
self.seekSlider.setRange(0, self.player.duration() / 1000)
def qmp_positionChanged(self, position):
if self.shuffled == False:
sliderLayout = self.h_box4.layout()
sliderLayout.itemAt(0).widget().setText(
'%d:%02d' % (int(position / 60000), int(
(position / 1000) % 60)))
self.seekSlider.setValue(position / 1000)
sliderLayout.itemAt(2).widget().setText(
'%d:%02d' % (int(self.player.duration() / 60000),
int((self.player.duration() / 1000) % 60)))
elif self.shuffled == True:
sliderLayout = self.h_box4.layout()
sliderLayout.itemAt(0).widget().setText(
'%d:%02d' % (int(position / 60000), int(
(position / 1000) % 60)))
self.seekSlider.setValue(position / 1000)
sliderLayout.itemAt(2).widget().setText(
'%d:%02d' % (int(self.player.duration() / 60000),
int((self.player.duration() / 1000) % 60)))
def load_songs(self):
songList = []
s = 'Songs:\n\n'
root = C.QFileInfo(__file__).absolutePath()
songs = os.listdir(root + "/songs")
for item in songs:
if item.endswith('.mp3'):
s += (str(item[:-4]) + '\n')
self.view.addItem(str(item[:-4]))
song = (root + '/songs/' + item + '\n')
songList.append(song)
self.songs.setText(s)
return songList
def set_playlist(self):
self.player = M.QMediaPlayer(self)
self.player2 = M.QMediaPlayer(self)
self.playlist = M.QMediaPlaylist(self.player)
self.playlist2 = M.QMediaPlaylist(self.player2)
for song in self.all_songs:
url = C.QUrl.fromLocalFile(song[:-1])
content = M.QMediaContent(url)
self.playlist.addMedia(content)
self.playlist2.addMedia(content)
self.playlist.setCurrentIndex(0)
self.playlist2.shuffle()
self.playlist2.setCurrentIndex(0)
self.player.setPlaylist(self.playlist)
self.player2.setPlaylist(self.playlist2)
def play(self):
if self.shuffled == False:
if self.player.state() == 0 or self.player.state() == 2:
self.play_button.setIcon(self.style().standardIcon(
QStyle.SP_MediaPause))
self.player.play()
else:
self.player.pause()
self.play_button.setIcon(self.style().standardIcon(
QStyle.SP_MediaPlay))
else:
if self.player2.state() == 0 or self.player2.state() == 2:
self.play_button.setIcon(self.style().standardIcon(
QStyle.SP_MediaPause))
self.player2.play()
else:
self.player2.pause()
self.play_button.setIcon(self.style().standardIcon(
QStyle.SP_MediaPlay))
def next(self):
if self.shuffled == False:
numb = self.playlist.currentIndex()
self.playlist.setCurrentIndex(numb + 1)
self.player.play()
else:
numb = self.playlist2.currentIndex()
self.playlist2.setCurrentIndex(numb + 1)
self.player2.play()
def back(self):
if self.shuffled == False:
numb = self.playlist.currentIndex()
self.playlist.setCurrentIndex(numb - 1)
self.player.play()
else:
numb = self.playlist2.currentIndex()
self.playlist2.setCurrentIndex(numb - 1)
self.player2.play()
def shuffle(self):
if self.shuffled == False:
self.player.stop()
self.playlist2.shuffle()
self.playlist2.setCurrentIndex(0)
self.player2.play()
self.shuffled = True
elif self.shuffled == True:
self.player2.stop()
self.playlist.setCurrentIndex(0)
self.player.play()
self.shuffled = False
def volume_change(self):
numb = self.volumn_slider.value()
self.player.setVolume(numb)
self.player2.setVolume(numb)
def display_song_list(self, list_of_songs):
self.view.clear()
if self.shuffled == False:
self.playlist.clear()
else:
self.playlist2.clear()
s = 'Songs:\n\n'
for item in list_of_songs:
url = C.QUrl.fromLocalFile(item)
content = M.QMediaContent(url)
if self.shuffled == False:
self.playlist.addMedia(content)
else:
self.playlist2.addMedia(content)
s += (str(item[:-4]) + '\n')
self.view.addItem(s)
def search(self):
s_term = self.line_edit.text()
filtered_list_of_songs = []
root = C.QFileInfo(__file__).absolutePath()
songs = os.listdir(root + "/songs")
# search through each song in all_songs...if it matches add to filtered_list_of_songs
for song in songs:
if song.lower().find(s_term.lower()) > -1:
filtered_list_of_songs.append(song)
self.display_song_list(filtered_list_of_songs)
class ListEdit(QWidget):
"""A widget to edit a list of items (e.g. a list of directories)."""
# emitted when anything changed in the listbox.
changed = pyqtSignal()
def __init__(self, *args, **kwargs):
QWidget.__init__(self, *args, **kwargs)
layout = QGridLayout(self)
self.setLayout(layout)
self.addButton = QPushButton(icons.get('list-add'), '')
self.editButton = QPushButton(icons.get('document-edit'), '')
self.removeButton = QPushButton(icons.get('list-remove'), '')
self.listBox = QListWidget()
layout.setContentsMargins(1, 1, 1, 1)
layout.setSpacing(0)
layout.addWidget(self.listBox, 0, 0, 8, 1)
layout.addWidget(self.addButton, 0, 1)
layout.addWidget(self.editButton, 1, 1)
layout.addWidget(self.removeButton, 2, 1)
def updateSelection():
selected = bool(self.listBox.currentItem())
self.editButton.setEnabled(selected)
self.removeButton.setEnabled(selected)
self.changed.connect(updateSelection)
self.listBox.itemSelectionChanged.connect(updateSelection)
updateSelection()
self.connectSlots()
app.translateUI(self)
def connectSlots(self):
self.addButton.clicked.connect(self.addClicked)
self.editButton.clicked.connect(self.editClicked)
self.removeButton.clicked.connect(self.removeClicked)
self.listBox.itemDoubleClicked.connect(self.itemDoubleClicked)
self.listBox.model().layoutChanged.connect(self.changed)
def translateUI(self):
self.addButton.setText(_("&Add..."))
self.editButton.setText(_("&Edit..."))
self.removeButton.setText(_("&Remove"))
def addClicked(self, button):
item = self.createItem()
if self.openEditor(item):
self.addItem(item)
def editClicked(self, button):
item = self.listBox.currentItem()
item and self.editItem(item)
def removeClicked(self, button):
item = self.listBox.currentItem()
if item:
self.removeItem(item)
def itemDoubleClicked(self, item):
item and self.editItem(item)
def createItem(self):
return QListWidgetItem()
def addItem(self, item):
self.listBox.addItem(item)
self.itemChanged(item)
self.changed.emit()
def removeItem(self, item):
self.listBox.takeItem(self.listBox.row(item))
self.changed.emit()
def editItem(self, item):
if self.openEditor(item):
self.itemChanged(item)
self.changed.emit()
def setCurrentItem(self, item):
self.listBox.setCurrentItem(item)
def setCurrentRow(self, row):
self.listBox.setCurrentRow(row)
def openEditor(self, item):
"""Opens an editor (dialog) for the item.
Returns True if the dialog was accepted and the item edited.
Returns False if the dialog was cancelled (the item must be left
unedited).
"""
pass
def itemChanged(self, item):
"""Called after an item has been added or edited.
Re-implement to do something at this moment if needed, e.g. alter the
text or display of other items.
"""
pass
def setValue(self, strings):
"""Sets the listbox to a list of strings."""
self.listBox.clear()
self.listBox.addItems(strings)
self.changed.emit()
def value(self):
"""Returns the list of paths in the listbox."""
return [
self.listBox.item(i).text() for i in range(self.listBox.count())
]
def setItems(self, items):
"""Sets the listbox to a list of items."""
self.listBox.clear()
for item in items:
self.listBox.addItem(item)
self.itemChanged(item)
self.changed.emit()
def items(self):
"""Returns the list of items in the listbox."""
return [self.listBox.item(i) for i in range(self.listBox.count())]
def clear(self):
"""Clears the listbox."""
self.listBox.clear()
self.changed.emit()
class CoTrafficWidget(QMainWindow):
pair_clicked = QtCore.pyqtSignal(TrackPair)
msd_clicked = QtCore.pyqtSignal(list, str)
# Channel, vtk_on, show_ied, show_alfa_table
show_channel = QtCore.pyqtSignal(Channel, bool, bool, bool)
show_bin_total = QtCore.pyqtSignal(dict, str)
def __init__(self, data, radius, title='Untitled', parent=None):
QMainWindow.__init__(self, parent)
self.list_widget = QListWidget()
self.data = data
self.radius = radius
self.pairs = dict()
self.title = title
self.min_time_points = 4
self.bin_value = 0
self.channel_a = None
self.channel_b = None
# for pair in self.data:
# list_item = QListWidgetItem()
# list_item.setText(f'{pair.name} - ({len(pair.time)})')
# list_item.setData(QtCore.Qt.UserRole + 1, pair.name)
# self.list_widget.addItem(list_item)
# self.pairs[pair.name] = pair
#
# self.list_widget.itemClicked.connect(self.__track_clicked)
#
# self.setCentralWidget(self.list_widget)
# self.tool_bar_top = self.addToolBar('CoTraffic toolbar')
# self.filter_box = QSpinBox()
# self.filter_box.setPrefix('Min Time')
# self.filter_box.setMinimum(self.min_time_points)
# self.tool_bar_top.addWidget(self.filter_box)
# flt_action = QAction('Apply Filter', self)
# flt_action.triggered.connect(self.__apply_filter)
# self.tool_bar_top.addAction(flt_action)
#
# self.tool_bar_top.addSeparator()
# self.bin_box = QSpinBox()
# self.bin_box.setPrefix('Time Bin')
# self.bin_box.setMinimum(10)
# self.tool_bar_top.addWidget(self.bin_box)
#
# self.addToolBarBreak(QtCore.Qt.TopToolBarArea)
self.tool_bar = self.addToolBar('CoTraffic toolbar Buttons')
msd_action = QAction('Plot MSD', self)
msd_action.triggered.connect(self.__plot_msd)
self.tool_bar.addAction(msd_action)
self.__extract_channels(extract_tracks=False)
ca_action = QAction(f'Show {self.channel_a.suffix}', self)
ca_action.triggered.connect(self.__show_ca)
self.tool_bar.addAction(ca_action)
cb_action = QAction(f'Show {self.channel_b.suffix}', self)
cb_action.triggered.connect(self.__show_cb)
self.tool_bar.addAction(cb_action)
self.apply_filter()
def apply_filter(self, filter_value=4):
self.min_time_points = filter_value
self.list_widget = QListWidget()
self.pairs = dict()
for pair in self.data:
if len(pair.time) >= self.min_time_points:
list_item = QListWidgetItem()
list_item.setText(f'{pair.name} - ({len(pair.time)})')
list_item.setData(QtCore.Qt.UserRole + 1, pair.name)
self.list_widget.addItem(list_item)
self.pairs[pair.name] = pair
self.list_widget.itemClicked.connect(self.__track_clicked)
self.setCentralWidget(self.list_widget)
def __show_ca(self):
self.__extract_channels()
self.show_channel.emit(self.channel_a, True, True, True)
self._display_bin(self.channel_a, self.bin_value)
def __show_cb(self):
self.__extract_channels()
self.show_channel.emit(self.channel_b, True, True, True)
self._display_bin(self.channel_b, self.bin_value)
def bin_updated(self, bin_value=0):
self.bin_value = bin_value
def _display_bin(self, channel, bin_value):
channels, total_dict = channel.bin_tracks(bin_value=bin_value,
radius=self.radius)
for _channel in channels:
self.show_channel.emit(_channel, True, True, True)
self.show_bin_total.emit(
total_dict,
f'CT {bin_value}-{self.radius:.1f}-{channel.suffix}-{self.bin_value}'
)
def _get_tracks_for_meta(self):
pair_pick = self.data[0]
return [pair_pick.track_a, pair_pick.track_b]
def __track_clicked(self, item):
pair_id = item.data(QtCore.Qt.UserRole + 1)
self.pair_clicked.emit(self.pairs[pair_id])
def __plot_msd(self):
tracks = []
for _, pair in self.pairs.items():
if len(pair.time) > 3:
tracks.append(pair.track_a)
tracks.append(pair.track_b)
self.msd_clicked.emit(tracks, self.title)
def __extract_channels(self, extract_tracks=True):
# get the channel suffix
tracks = self._get_tracks_for_meta()
self.channel_a = Channel(
channel_name=f'CT {self.radius:.1f}{tracks[0].suffix}',
suffix=tracks[0].suffix,
color=tracks[0].color)
self.channel_b = Channel(
channel_name=f'CT {self.radius:.1f}{tracks[1].suffix}',
suffix=tracks[1].suffix,
color=tracks[1].color)
self.channel_a.filter_size = self.min_time_points
self.channel_b.filter_size = self.min_time_points
self.channel_a.bin_value = self.bin_value
self.channel_b.bin_value = self.bin_value
channel_a_tracks = []
channel_b_tracks = []
if extract_tracks:
for _, pair in self.pairs.items():
if pair.track_a.suffix == self.channel_a.suffix:
channel_a_tracks.append(pair.track_a)
channel_b_tracks.append(pair.track_b)
else:
channel_a_tracks.append(pair.track_b)
channel_b_tracks.append(pair.track_a)
self.channel_a.set_track(channel_a_tracks)
self.channel_b.set_track(channel_b_tracks)
class Gui(QMainWindow):
def __init__(self):
super().__init__()
self.initUI()
def initUI(self):
self.toolbar = self.addToolBar('Things')
self.addBtn('video-display', 'Toggle Visibility',
self.ipcToggleVisibility, self.toolbar)
self.addBtn('media-playback-start', 'Toggle Play', self.ipcTogglePlay,
self.toolbar)
self.addBtn('view-fullscreen', 'Toggle Fullscreen',
self.ipcToggleFullscreen, self.toolbar)
self.toolbar.addSeparator()
self.targetBox = QComboBox()
self.targetBox.addItems(targetsList)
self.toolbar.addWidget(self.targetBox)
self.toolbar.addSeparator()
self.addBtn('reload', 'Refresh', self.funRefresh, self.toolbar)
self.addBtn('preferences', 'Settings', self.funComms, self.toolbar)
self.toolbar.addSeparator()
self.addBtn('exit', 'Exit', qApp.quit, self.toolbar)
self.list = QListWidget(self)
self.list.setIconSize(QSize(120, 120))
#self.list.resize(300, 200)
self.setCentralWidget(self.list)
self.resize(QSize(600, 500))
self.setWindowTitle('Toolbar')
self.show()
def addBtn(self, icon, tip, action, toolbar):
act = QAction(QIcon.fromTheme(icon), tip, self)
act.triggered.connect(action)
toolbar.addAction(act)
def funComms(self):
comms.send('test')
def funRefresh(self):
self.list.clear()
target = self.targetBox.currentIndex() + 1
print(target)
data = fetchListData(target)
for k in data:
item = QListWidgetItem(
QIcon(os.path.join(imageDir,
str(k['ID']) + '.jpg')),
k['Description'] + '\n' + k['Duration'])
item.setFlags(item.flags()
| Qt.ItemIsUserCheckable) # set checkable flag
item.setCheckState(Qt.Checked) # AND initialize check state
self.list.addItem(item)
def ipcToggleFullscreen(self):
comms.send('toggle-fullscreen')
def ipcTogglePlay(self):
comms.send('toggle-play')
def ipcToggleVisibility(self):
comms.send('toggle-visibility')
def ipcScreenEnable(self):
comms.send('screen-enable')
def ipcScreenBlack(self):
comms.send('screen-black')
def ipcFullscreen(self):
comms.send('fullscreen')
def ipcWindowed(self):
comms.send('windowed')
def ipcPlay(self):
comms.send('play')
def ipcPause(self):
comms.send('pause')
def ipcNext(self):
comms.send('next')
def ipcPrev(self):
comms.send('prev')
def ipcRefresh(self):
comms.send('refresh')
def ipcGet(self, item):
comms.send('get-' + item)
def ipcTarget(self, target):
comms.send('target-' + target)
def ipcDisable(self, listItemId):
comms.send('disable-' + listItemId)
def ipcEnable(self, listItemId):
comms.send('enable-' + listItemId)
class SearchWindow(QWidget):
def __init__(self):
super().__init__()
self.tmp = {}
self.textbox = QLineEdit(self)
self.textbox.returnPressed.connect(self.search)
self.searchResultLabel = QLabel()
self.searchResultLabel.setText("Search Results")
self.searchResultLabel.setStyleSheet('color: white')
self.currentVideo = QLabel()
self.currentVideoLabel = QLabel("Currently Playing: ")
self.currentVideoLabel.setStyleSheet('color: white')
self.currentVideo.setStyleSheet('color: white')
self.currentVideoHBox = QHBoxLayout()
self.currentVideoHBox.addWidget(self.currentVideoLabel)
self.currentVideoHBox.addWidget(self.currentVideo)
self.queueLabel = QLabel("Coming up next:")
self.queueLabel.setStyleSheet('color: white')
self.searchResultsList = QListView()
self.searchResultsList.setIconSize(QSize(90, 90))
self.model = QStandardItemModel(self.searchResultsList)
self.searchResultsList.clicked.connect(self.clicked_item)
self.queueList = QListWidget()
self.queueList.setIconSize(QSize(90, 90))
self.button = QPushButton('Search', self)
self.button.clicked.connect(self.search)
self.hbox = QHBoxLayout()
self.hbox.addWidget(self.textbox)
self.hbox.addWidget(self.button)
self.hbox.setSpacing(10)
self.hbox.setContentsMargins(5, 5, 5, 5)
self.qr_icon = QLabel(self)
img = ImageQt("./src/main/resources/qr.jpg")
pixmap = QPixmap.fromImage(img).scaledToWidth(96)
self.qr_icon.setPixmap(pixmap)
self.qr_icon.setAlignment(Qt.AlignCenter)
self.url_label = QLabel(URL)
self.vbox = QVBoxLayout()
self.vbox.addLayout(self.hbox)
self.vbox.addWidget(self.searchResultLabel)
self.vbox.addWidget(self.searchResultsList)
self.vbox.addLayout(self.currentVideoHBox)
self.vbox.addWidget(self.queueLabel)
self.vbox.addWidget(self.queueList)
self.vbox.addWidget(self.qr_icon)
self.vbox.addWidget(self.url_label)
self.vbox.setSpacing(0)
self.vbox.setContentsMargins(5, 5, 5, 5)
self.setLayout(self.vbox)
def start_listener(self):
self.listener_thread = WebSocketListener()
self.listener_thread.queue.connect(self.on_data_ready)
self.listener_thread.start()
def on_data_ready(self, content):
self.setupQueue(content['queue'])
self.currentVideo.setText(content['currentVideo'])
def search(self):
textboxValue = self.textbox.text()
results = youtube.search(textboxValue)
self.build_list(results)
def build_list(self, results):
self.model.clear()
for item in results:
title = youtube.get_title(item)
thumbnail = youtube.get_thumbnail(item)
pixmap = QPixmap()
pixmap.loadFromData(thumbnail)
image = QIcon(pixmap)
qItem = QStandardItem()
qItem.setText(title)
qItem.setIcon(image)
self.model.appendRow(qItem)
self.tmp[title] = youtube.get_id(item)
self.searchResultsList.setModel(self.model)
def clicked_item(self, item):
title = self.model.itemFromIndex(item).text()
data = {'title': title, 'video_id': self.tmp[title]}
body = urllib.parse.urlencode(data)
self.send_request(body, '/add')
def setupQueue(self, queue):
self.queueList.clear()
for i in range(0, len(queue)):
list_item = CustomListItem()
list_item.setTitle(queue[i])
list_item.remove_button.clicked.connect(
partial(self.remove, index=i))
q_list_widget_item = QListWidgetItem(self.queueList)
q_list_widget_item.setSizeHint(list_item.sizeHint())
self.queueList.addItem(q_list_widget_item)
self.queueList.setItemWidget(q_list_widget_item, list_item)
def remove(self, index):
body = urllib.parse.urlencode({'index': index})
self.send_request(body, '/remove')
def send_request(self, body, endpoint):
http_client = HTTPClient()
try:
res = http_client.fetch(URL + endpoint,
method='POST',
headers=None,
body=body)
content = json.loads(res.body.decode("utf-8"))
self.setupQueue(content['queue'])
self.currentVideo.setText(content['currentVideo'])
except Exception as e:
print(str(e))
class SpeciesTab(QWidget):
def __init__(self, parent):
super().__init__()
self.parent = parent
self.main_layout = QVBoxLayout()
list_style = """
QListWidget#species_list{
}
QListWidget#species_list::item {
padding: 10px;
}
QListWidget#species_list::item:selected {
padding: 0px;
background-color: #3577dd;
color: white;
}
"""
self.setStyleSheet(list_style)
self.species_list = QListWidget()
self.species_list.setFont(QFont("Oxygen", 14))
self.species_list.setObjectName("species_list")
self.update_ui()
self.buttons_layout = QHBoxLayout()
self._init_buttons()
self.main_layout.addWidget(
QLabel("Species of the network and their initial concentration."))
self.main_layout.addWidget(self.species_list)
self.main_layout.addLayout(self.buttons_layout)
self.main_layout.setObjectName("main_layout")
self.setLayout(self.main_layout)
def _init_buttons(self):
self.add_button = QPushButton("Add")
self.add_button.clicked.connect(self._add_species_click_handler)
self.remove_button = QPushButton("Remove")
self.remove_button.clicked.connect(self._remove_species_click_handler)
self.buttons_layout.addWidget(self.add_button)
self.buttons_layout.addWidget(self.remove_button)
def update_ui(self):
self.species_list.clear()
for s in GenePresenter.get_instance().get_species():
self.species_list.addItem(
s + ": " + str(GenePresenter.get_instance().get_species()[s]))
def _add_species_click_handler(self):
(text, ok) = QInputDialog.getText(
self, "Add Species", "Write species and initial "
"concentration in this format: \n"
"species1: 20.0, species2: 30.0")
if ok:
for pair in text.split(','):
split = pair.strip().split(':')
species_name = split[0].strip()
species_concent = float(split[1].strip())
GenePresenter.get_instance().add_species(
species_name, species_concent)
self.update_ui()
self.parent.reactions_tab.update_ui()
def _remove_species_click_handler(self):
text = self.species_list.item(self.species_list.currentRow()).text()
species = text.split(':')[0]
GenePresenter.get_instance().remove_species(species)
self.update_ui()
self.parent.reactions_tab.update_ui()
class RSSReaderWidget(QWidget):
def __init__(self, buffer_id, config_dir):
super(RSSReaderWidget, self).__init__()
self.feed_file_path = os.path.join(config_dir, "rss-reader",
"feeds.json")
self.feed_area = QWidget()
self.feed_list = QListWidget()
self.feed_list.setStyleSheet(
"""QListView {background: #4D5250; show-decoration-selected: 1; selection-background-color: #464646;}"""
)
panel_layout = QVBoxLayout()
panel_layout.setSpacing(0)
panel_layout.setContentsMargins(0, 0, 0, 0)
panel_layout.addWidget(self.feed_list)
self.feed_area.setLayout(panel_layout)
self.article_area = QWidget()
self.article_list = QListWidget()
self.article_list.setStyleSheet(
"""QListView {background: #FFF; show-decoration-selected: 1; selection-background-color: #EEE;}"""
)
self.article_list.verticalScrollBar().setStyleSheet(
"QScrollBar {width:0px;}")
article_layout = QVBoxLayout()
article_layout.setSpacing(0)
article_layout.setContentsMargins(0, 0, 0, 0)
self.browser = BrowserView(buffer_id, config_dir)
article_layout.addWidget(self.article_list)
article_layout.addWidget(self.browser)
article_layout.setStretchFactor(self.article_list, 1)
article_layout.setStretchFactor(self.browser, 3)
self.article_area.setLayout(article_layout)
self.welcome_page = QWidget()
self.welcome_page_box = QVBoxLayout()
self.welcome_page_box.setSpacing(10)
self.welcome_page_box.setContentsMargins(0, 0, 0, 0)
welcome_title_label = QLabel("Welcome to EAF RSS Reader!")
welcome_title_label.setFont(QFont('Arial', 24))
welcome_title_label.setStyleSheet(
"QLabel {color: #333; font-weight: bold; margin: 20px;}")
welcome_title_label.setAlignment(Qt.AlignHCenter)
add_subscription_label = QLabel("Press 'a' to subscribe to a feed!")
add_subscription_label.setFont(QFont('Arial', 20))
add_subscription_label.setStyleSheet("QLabel {color: #grey;}")
add_subscription_label.setAlignment(Qt.AlignHCenter)
self.welcome_page_box.addStretch(1)
self.welcome_page_box.addWidget(welcome_title_label)
self.welcome_page_box.addWidget(add_subscription_label)
self.welcome_page_box.addStretch(1)
self.welcome_page.setLayout(self.welcome_page_box)
self.right_area = QStackedWidget()
self.right_area.addWidget(self.welcome_page)
self.right_area.addWidget(self.article_area)
if self.has_feed():
self.right_area.setCurrentIndex(1)
else:
self.right_area.setCurrentIndex(0)
hbox = QHBoxLayout()
hbox.setSpacing(0)
hbox.setContentsMargins(0, 0, 0, 0)
hbox.addWidget(self.feed_area)
hbox.addWidget(self.right_area)
hbox.setStretchFactor(self.feed_area, 1)
hbox.setStretchFactor(self.right_area, 3)
self.setLayout(hbox)
self.feed_list.itemActivated.connect(self.handle_feed)
self.article_list.itemActivated.connect(self.handle_article)
self.feed_object_dict = {}
self.init_select_line = False
self.fetch_feeds()
def has_feed(self):
if os.path.exists(self.feed_file_path):
try:
with open(self.feed_file_path, "r") as feed_file:
feed_dict = json.loads(feed_file.read())
return len(feed_dict.keys()) > 0
except Exception:
return False
return False
def fetch_feeds(self):
if os.path.exists(self.feed_file_path):
try:
with open(self.feed_file_path, "r") as feed_file:
feed_dict = json.loads(feed_file.read())
for index, feed_link in enumerate(feed_dict):
self.fetch_feed(feed_link, index == 0)
except Exception:
pass
def handle_feed(self, feed_item):
if feed_item.feed_link in self.feed_object_dict:
self.init_article_area(self.feed_object_dict[feed_item.feed_link])
def handle_article(self, article_item):
article_item.mark_as_read()
self.browser.setUrl(QUrl(article_item.post_link))
def fetch_feed(self, feed_link, refresh_ui):
fetchThread = FetchRSSThread(feed_link)
fetchThread.fetch_rss.connect(
lambda f_object, f_link, f_title: self.handle_rss(
f_object, f_link, f_title, refresh_ui))
fetchThread.invalid_rss.connect(self.handle_invalid_rss)
object_name = "feed_thread_" + feed_link
setattr(self, object_name, fetchThread)
getattr(self, object_name).start()
def add_subscription(self, feed_link):
if not self.feed_exists(feed_link):
self.fetch_feed(feed_link, True)
else:
self.buffer.message_to_emacs.emit("Feed already exists: " +
feed_link)
def delete_subscription(self):
feed_count = self.feed_list.count()
current_row = self.feed_list.currentRow()
feed_link = self.feed_list.currentItem().feed_link
feed_title = self.feed_list.currentItem().feed_title
self.feed_list.takeItem(current_row)
with open(self.feed_file_path, "r") as feed_file:
feed_dict = json.loads(feed_file.read())
if feed_link in feed_dict:
del feed_dict[feed_link]
with open(self.feed_file_path, "w") as f:
f.write(json.dumps(feed_dict))
if feed_count <= 1:
self.feed_list.clear()
self.article_list.clear()
self.browser.setUrl(QUrl(""))
self.right_area.setCurrentIndex(0)
else:
if current_row < feed_count - 1:
self.feed_list.setCurrentRow(current_row)
else:
self.feed_list.setCurrentRow(feed_count - 2)
self.handle_feed(self.feed_list.currentItem())
self.buffer.message_to_emacs.emit("Removed feed: " + feed_title)
def feed_exists(self, feed_link):
if not os.path.exists(self.feed_file_path):
return False
try:
with open(self.feed_file_path, "r") as feed_file:
feed_dict = json.loads(feed_file.read())
return feed_link in feed_dict
except Exception:
import traceback
traceback.print_exc()
return False
def save_feed(self, feed_object, feed_link, feed_title):
touch(self.feed_file_path)
article_ids = list(
map(lambda post: post.id
if hasattr(post, 'id') else post.link, feed_object.entries))
try:
with open(self.feed_file_path, "r") as feed_file:
feed_dict = json.loads(feed_file.read())
if feed_link not in feed_dict:
feed_dict[feed_link] = {
"title": feed_title,
"unread_articles": article_ids
}
self.save_feed_dict(feed_dict)
self.buffer.message_to_emacs.emit("Add feed: " + feed_link)
except Exception:
import traceback
traceback.print_exc()
self.save_feed_dict({
feed_link: {
"title": feed_title,
"unread_articles": article_ids
}
})
self.buffer.message_to_emacs.emit("Add feed: " + feed_link)
def save_feed_dict(self, feed_dict):
with open(self.feed_file_path, "w") as f:
f.write(json.dumps(feed_dict))
def handle_rss(self, feed_object, feed_link, feed_title, refresh_ui):
feed_object.feed_link = feed_link
self.feed_object_dict[feed_link] = feed_object
self.save_feed(feed_object, feed_link, feed_title)
self.right_area.setCurrentIndex(1)
feed_item = QListWidgetItem(self.feed_list)
feed_item.feed_link = feed_link
feed_item.feed_title = feed_title
feed_item_widget = RSSFeedItem(feed_object, len(feed_object.entries))
feed_item.update_article_num = feed_item_widget.update_article_num
feed_item.setSizeHint(feed_item_widget.sizeHint())
self.feed_list.addItem(feed_item)
self.feed_list.setItemWidget(feed_item, feed_item_widget)
unread_articles = []
with open(self.feed_file_path, "r") as feed_file:
feed_dict = json.loads(feed_file.read())
if feed_object.feed_link in feed_dict:
if "unread_articles" in feed_dict[feed_object.feed_link]:
unread_articles = ["unread_articles"]
for index in range(self.feed_list.count()):
feed_item = self.feed_list.item(index)
if feed_item.feed_link == feed_object.feed_link:
feed_item.update_article_num(len(unread_articles))
break
if refresh_ui:
self.init_article_area(feed_object)
def init_article_area(self, feed_object):
self.browser.setUrl(QUrl(feed_object.entries[0].link))
self.article_list.clear()
unread_articles = []
with open(self.feed_file_path, "r") as feed_file:
feed_dict = json.loads(feed_file.read())
if feed_object.feed_link in feed_dict and "unread_articles" in feed_dict[
feed_object.feed_link]:
unread_articles = feed_dict[
feed_object.feed_link]["unread_articles"]
for index, post in enumerate(feed_object.entries):
item_widget = RSSArticleItemWidget(feed_object, post,
unread_articles)
item = QListWidgetItem(self.article_list)
item.mark_as_read = item_widget.mark_as_read
item.post_link = item_widget.post_link
item.setSizeHint(item_widget.sizeHint())
item_widget.mark_article_read.connect(self.mark_article_read)
self.article_list.addItem(item)
self.article_list.setItemWidget(item, item_widget)
if index == 0:
item.mark_as_read()
self.article_list.setCurrentRow(0)
if not self.init_select_line:
self.init_select_line = True
self.feed_list.setCurrentRow(0)
def handle_invalid_rss(self, feed_link):
self.buffer.message_to_emacs.emit("Invalid feed link: " + feed_link)
def mark_article_read(self, feed_link, post_link):
if os.path.exists(self.feed_file_path):
try:
with open(self.feed_file_path, "r") as feed_file:
feed_dict = json.loads(feed_file.read())
if feed_link in feed_dict:
unread_articles = feed_dict[feed_link][
"unread_articles"]
if post_link in unread_articles:
unread_articles.remove(post_link)
feed_dict[feed_link][
"unread_articles"] = unread_articles
with open(self.feed_file_path, "w") as f:
f.write(json.dumps(feed_dict))
for index in range(self.feed_list.count()):
feed_item = self.feed_list.item(index)
if feed_item.feed_link == feed_link:
feed_item.update_article_num(
len(unread_articles))
break
except Exception:
pass
@interactive()
def next_subscription(self):
feed_count = self.feed_list.count()
current_row = self.feed_list.currentRow()
if current_row < feed_count - 1:
self.feed_list.setCurrentRow(current_row + 1)
self.feed_list.scrollToItem(self.feed_list.currentItem())
self.handle_feed(self.feed_list.currentItem())
else:
self.buffer.message_to_emacs.emit("End of subscribed feeds")
@interactive()
def prev_subscription(self):
current_row = self.feed_list.currentRow()
if current_row > 0:
self.feed_list.setCurrentRow(current_row - 1)
self.feed_list.scrollToItem(self.feed_list.currentItem())
self.handle_feed(self.feed_list.currentItem())
else:
self.buffer.message_to_emacs.emit("Beginning of subscribed feeds")
@interactive()
def first_subscription(self):
self.feed_list.setCurrentRow(0)
self.feed_list.scrollToItem(self.feed_list.currentItem())
self.handle_feed(self.feed_list.currentItem())
@interactive()
def last_subscription(self):
feed_count = self.feed_list.count()
self.feed_list.setCurrentRow(feed_count - 1)
self.feed_list.scrollToItem(self.feed_list.currentItem())
self.handle_feed(self.feed_list.currentItem())
@interactive()
def next_article(self):
article_count = self.article_list.count()
current_row = self.article_list.currentRow()
if current_row < article_count - 1:
self.article_list.setCurrentRow(current_row + 1)
self.article_list.scrollToItem(self.article_list.currentItem())
self.handle_article(self.article_list.currentItem())
else:
self.buffer.message_to_emacs.emit("End of articles")
@interactive()
def prev_article(self):
current_row = self.article_list.currentRow()
if current_row > 0:
self.article_list.setCurrentRow(current_row - 1)
self.article_list.scrollToItem(self.article_list.currentItem())
self.handle_article(self.article_list.currentItem())
else:
self.buffer.message_to_emacs.emit("Beginning of articles")
@interactive()
def first_article(self):
self.article_list.setCurrentRow(0)
self.article_list.scrollToItem(self.article_list.currentItem())
self.handle_article(self.article_list.currentItem())
@interactive()
def last_article(self):
article_count = self.article_list.count()
self.article_list.setCurrentRow(article_count - 1)
self.article_list.scrollToItem(self.article_list.currentItem())
self.handle_article(self.article_list.currentItem())
class ExtendedLineEdit(QLineEdit):
signal_send_movie = pyqtSignal(list)
signal_search_movie = pyqtSignal(str)
signal_request_movie_data = pyqtSignal(int)
signal_set_loading = pyqtSignal(str, bool)
DEBUG = False
def __init__(self, parent=None):
super(ExtendedLineEdit, self).__init__(parent)
self.movies = []
self.completer_lw = QListWidget()
self.model = self.completer_lw.model()
self.completer = QCompleter(self.model, self)
self.completer.setPopup(self.completer_lw)
self.completer.setCompletionMode(QCompleter.UnfilteredPopupCompletion)
self.completer.setCompletionRole(
Qt.UserRole
) # Change role because default EditRole is paited to list somehow
self.setCompleter(self.completer)
self.textEdited.connect(self.text_edited)
#self.completer.activated[QModelIndex].connect(self.on_completer_activated)
#self.completer.activated[str].connect(self.on_completer_activated_str)
self.completer_lw.itemClicked.connect(self.item_clicked)
self.installEventFilter(self)
def eventFilter(self, obj, event):
if event.type() == QEvent.MouseButtonPress:
if event.button() == Qt.LeftButton:
self.completer.complete()
return super(ExtendedLineEdit, self).eventFilter(obj, event)
def setText(self, text: str) -> None:
if self.DEBUG: print('setText', text, self.sender())
super(ExtendedLineEdit, self).setText(text)
if not isinstance(self.sender(), QCompleter) and text:
self.text_edited(text)
@pyqtSlot(list)
def update_movies_list(self, result):
if self.DEBUG: print('update_movies_list', result[0], len(result) - 1)
type = result.pop(0)
if type == 'db':
self.movies = [x + [
type,
] for x in result]
self.completer_lw.clear()
self.completer.complete()
else:
for item in result:
self.movies.append(item + [
type,
])
for item in result:
cwidget = MyWidget()
cwidget.label_movie_name.setText(item[1] if item[1] else item[2])
cwidget.label_original_name.setText(item[2])
cwidget.label_source.setText(type)
cwidget.label_year.setText(str(item[3]))
completer_myQListWidgetItem = QListWidgetItem(self.completer_lw)
completer_myQListWidgetItem.setSizeHint(cwidget.sizeHint())
completer_myQListWidgetItem.setData(Qt.UserRole, item[1])
self.completer_lw.addItem(completer_myQListWidgetItem)
self.completer_lw.setItemWidget(completer_myQListWidgetItem,
cwidget)
if self.hasFocus() and not self.completer_lw.isVisible() and len(
self.movies) > 0:
self.completer.complete()
@pyqtSlot(str)
def text_edited(self, text):
if self.DEBUG: print('text_edited', text, self.sender())
if text and isinstance(self.sender(), ExtendedLineEdit):
self.signal_search_movie.emit(text)
@pyqtSlot(str)
def on_completer_activated_str(self, name: str):
if self.DEBUG: print('on_completer_activated_str', name)
@pyqtSlot(QModelIndex)
def on_completer_activated(self, index: QModelIndex):
if self.DEBUG: print('on_completer_activated', index.row())
item = self.movies[index.row()]
if len(item) > 13:
self.signal_send_movie.emit(item[:13])
self.signal_request_movie_data.emit(item[13])
else:
self.signal_send_movie.emit(item)
@pyqtSlot(QListWidgetItem)
def item_clicked(self, item: QListWidgetItem):
if self.DEBUG: print('item_clicked', item, [i[1] for i in self.movies])
index = self.completer_lw.indexFromItem(item)
item = self.movies[index.row()]
type = item[-1]
if type == 'db':
self.signal_send_movie.emit(item)
else:
self.signal_set_loading.emit('movie', True)
if len(item) > 13:
self.signal_send_movie.emit(item[:13])
self.signal_request_movie_data.emit(item[13])
else:
self.signal_send_movie.emit(item)
def reset(self):
if self.DEBUG: print('reset')
self.completer_lw.clear()
self.clearFocus()
class ContactCards(QWidget):
def __init__(self, context: ListContext, parent: Any = None) -> None:
super().__init__(parent)
self._context = context
self._layout = QVBoxLayout()
self._layout.setContentsMargins(0, 0, 0, 0)
self._layout.setSpacing(0)
self._empty_label = None
self._list = None
contact_identities = self._context.wallet_api.get_identities()
if len(contact_identities) > 0:
for contact, identity in sorted(contact_identities,
key=lambda t: t[0].label):
self._add_identity(contact, identity)
else:
self._add_empty_label()
self.setLayout(self._layout)
self._context.wallet_api.contact_changed.connect(
self._on_contact_changed)
def _add_identity(self, contact: ContactEntry,
identity: ContactIdentity) -> None:
self._remove_empty_label()
if self._list is None:
self._list = QListWidget(self)
self._list.setSortingEnabled(True)
self._layout.addWidget(self._list)
test_card = ContactCard(self._context, contact, identity)
test_card.setSizePolicy(QSizePolicy.MinimumExpanding,
QSizePolicy.Minimum)
list_item = QListWidgetItem()
list_item.setText(contact.label)
# The item won't display unless it gets a size hint. It seems to resize horizontally
# but unless the height is a minimal amount it won't do anything proactive..
list_item.setSizeHint(QSize(256, 130))
self._list.addItem(list_item)
self._list.setItemWidget(list_item, test_card)
def _remove_identity(self, contact: ContactEntry,
identity: ContactIdentity) -> None:
removal_entries = []
for i in range(self._list.count() - 1, -1, -1):
item = self._list.item(i)
widget = self._list.itemWidget(item)
if identity is None and widget._contact.contact_id == contact.contact_id:
self._list.takeItem(i)
elif widget._identity.identity_id == identity.identity_id:
self._list.takeItem(i)
if self._list.count() == 0:
# Remove the list.
self._list.setParent(None)
self._list = None
# Replace it with the placeholder label.
self._add_empty_label()
def _on_contact_changed(self, added: bool, contact: ContactEntry,
identity: ContactIdentity) -> None:
if added:
self._add_identity(contact, identity)
else:
self._remove_identity(contact, identity)
def _add_empty_label(self) -> None:
self._empty_label = QLabel(
_("You do not currently have any contacts."))
self._empty_label.setAlignment(Qt.AlignHCenter | Qt.AlignVCenter)
self._layout.addWidget(self._empty_label)
def _remove_empty_label(self) -> None:
if self._empty_label is not None:
self._empty_label.setParent(None)
self._empty_label = None
class MainWindow(QWidget):
def __init__(self):
super(QWidget, self).__init__()
self.setWindowIcon(QIcon(os.path.join(path, "img", 'icon.ico')))
self.setGeometry(200, 200, 600, 600)
self.setWindowTitle("Focus")
self.DB = DBEngine()
self.initUI()
def initUI(self):
self.gridLayout = QGridLayout(self)
self.label = QLabel("Мои задания")
self.gridLayout.addWidget(self.label, 0, 0, 1, 1)
self.gridLayout.addItem(
QSpacerItem(87, 20, QSizePolicy.Expanding, QSizePolicy.Minimum), 0,
1, 1, 1)
self.status_label = QLabel("Состояние:")
self.status_label.setMinimumSize(QtCore.QSize(100, 20))
self.gridLayout.addWidget(self.status_label, 0, 2, 1, 1)
self.status_box = QComboBox(self)
self.status_box.setMinimumSize(QtCore.QSize(100, 0))
self.status_box.addItem("В процессе")
self.status_box.addItem("Сделано")
self.status_box.addItem("Просрочено")
self.status_box.addItem("Все")
self.status_box.setCurrentIndex(3)
self.gridLayout.addWidget(self.status_box, 0, 3, 1, 3)
self.status_box.currentIndexChanged.connect(self.customize_table)
self.listWidget = QListWidget(self)
self.load_table(self.DB.get_data(), clear_data=True)
self.gridLayout.addWidget(self.listWidget, 1, 0, 1, 6)
self.new_task_btn = QPushButton(text="Новое задание")
self.new_task_btn.setMinimumSize(QtCore.QSize(100, 50))
self.gridLayout.addWidget(self.new_task_btn, 2, 0, 1, 2)
self.new_task_btn.clicked.connect(self.new_task_action)
self.mark_as_btn = QPushButton(text="Отметить как выполненное")
self.mark_as_btn.setMinimumSize(QtCore.QSize(200, 50))
self.gridLayout.addWidget(self.mark_as_btn, 2, 2, 1, 2)
self.mark_as_btn.clicked.connect(self.mark_as_action)
self.delete_btn = QPushButton(text="Удалить выделенное")
self.delete_btn.setMinimumSize(QtCore.QSize(150, 50))
self.gridLayout.addWidget(self.delete_btn, 2, 4, 1, 2)
self.delete_btn.clicked.connect(self.delete_action)
def new_task_action(self):
item = ToDoWidget(Task(), self)
item.edit_btn.click()
if item.is_created:
item.is_added_to_List = True
widget_item = QListWidgetItem(self.listWidget)
widget_item.setSizeHint(item.sizeHint())
self.listWidget.addItem(widget_item)
self.listWidget.setItemWidget(widget_item, item)
self.customize_table()
def mark_as_action(self):
widget = self.listWidget.itemWidget(self.listWidget.currentItem())
if widget is not None:
widget.task.status_id = 1
widget.display()
self.customize_table()
def delete_action(self):
self.listWidget.takeItem(self.listWidget.currentRow())
def load_table(self, data, clear_data=False):
self.listWidget.clear()
for task in data:
item = ToDoWidget(task, self)
widget_item = QListWidgetItem(self.listWidget)
widget_item.setSizeHint(item.sizeHint())
self.listWidget.addItem(widget_item)
self.listWidget.setItemWidget(widget_item, item)
if clear_data:
self.DB.clear_data()
def customize_table(self):
index = self.status_box.currentIndex()
self.save_changes()
data = self.DB.get_data()
if index == 3:
self.load_table(data, clear_data=True)
else:
self.load_table(filter(lambda x: x.status_id == index, data))
self.DB.update_data(
list(filter(lambda x: x.status_id != index, data)))
def save_changes(self):
self.DB.update_data([
self.listWidget.itemWidget(self.listWidget.item(i)).task
for i in range(self.listWidget.count())
],
mode="a")
def closeEvent(self, event):
self.save_changes()
self.DB.close()
super(MainWindow, self).closeEvent(event)
class NewTestWindow(QWidget):
""" allows to create a new test """
def __init__(self):
super().__init__()
self.setWindowIcon(QIcon(os.path.join(os.pardir, "res", "img", "logo.png")))
self.setWindowTitle("QUIZZO LEARN")
self.resize(900, 650)
center(self)
self.load_ui()
def init_ui(self, test_name):
self.test_name = test_name
self.number_of_frases = 0
self.QList.clear()
self.show()
def load_ui(self):
back_button = QPushButton("<= WRÓĆ")
back_button.setStyleSheet("background-color: YellowGreen; color:purple")
back_button.clicked.connect(self.back_button_act)
add_button = QPushButton()
add_button.setIcon(QIcon(os.path.join(os.pardir, "res", "img", "add-icon.png")))
add_button.setIconSize(QSize(100, 100))
add_button.setSizePolicy(QSizePolicy.Expanding,
QSizePolicy.Preferred)
add_button.clicked.connect(self.add)
OK_button = QPushButton("ZAPISZ I \nROZPOCZNIJ \n TEST")
OK_button.setSizePolicy(QSizePolicy.Expanding,
QSizePolicy.Preferred)
OK_button.setStyleSheet("background-color: LimeGreen; color:AntiqueWhite")
font = QFont("Serif", 15)
OK_button.setFont(font)
OK_button.clicked.connect(self.save)
vbox = QVBoxLayout()
vbox.addStretch(2)
vbox.addWidget(add_button, 2)
vbox.addStretch(2)
vbox.addWidget(OK_button, 3)
hbox2 = QHBoxLayout()
hbox2.addWidget(back_button)
hbox2.addStretch(4)
self.QList = QListWidget()
self.QList.setStyleSheet("background-color:PeachPuff ")
vbox2 = QVBoxLayout()
vbox2.addLayout(hbox2)
vbox2.addWidget(self.QList)
hbox = QHBoxLayout()
hbox.addLayout(vbox2, 7)
hbox.addLayout(vbox, 1)
self.setLayout(hbox)
def back_button_act(self):
alert = QMessageBox().warning(self, "JESTEŚ PEWIEN ??",
"UWAGA !!! \n STRACISZ WPROWADZONE SŁOWA \n JESTEŚ PEWIEN ??", QMessageBox.Yes,
QMessageBox.No)
if alert == QMessageBox.Yes:
self.close()
menu_window.show()
def add(self):
frase1 = text_dialog(self, "FRAZA 1", " PODAJ PROSZĘ FRAZĘ 1")
if frase1 is None:
QMessageBox.warning(self, "PUSTE", "Prosze podać jakąś fraze", QMessageBox.Ok)
return None
frase2 = text_dialog(self, "FRAZA 2", " PODAJ PROSZĘ FRAZĘ 2")
if frase2 is None:
QMessageBox.warning(self, "PUSTE", "Prosze podać jakąś fraze", QMessageBox.Ok)
return None
item = QListWidgetItem()
item.id = self.number_of_frases
item.frase1 = frase1
item.frase2 = frase2
item.is_empty = False
widget_item = QItemQuestion(self.number_of_frases, frase1, frase2)
item.setSizeHint(widget_item.sizeHint())
self.number_of_frases += 1
self.QList.addItem(item)
self.QList.setItemWidget(item, widget_item)
def save(self):
dict_of_questions = {} # yeah it is something like LIST OF GOD
reversed_dict_of_questions = {}
i = 0
i2 = self.QList.count()
while i < i2:
item = self.QList.item(i)
if not item.is_empty:
dict_of_questions[item.frase1] = item.frase2
reversed_dict_of_questions[item.frase2] = item.frase1
i += 1
if len(dict_of_questions) < 1:
QMessageBox.warning(self, "PUSTE", "NIE DA RADY STWORZYĆ PUSTEGO TESTU !!!", QMessageBox.Ok)
return None
quizzo_learn.files_interactions.save_test(dict_of_questions,
os.path.join(os.pardir, "res", "my_tests", self.test_name + ".test"))
self.close()
start_window.label.setText(self.test_name)
start_window.init_ui([dict_of_questions, reversed_dict_of_questions])
my_tests_window.refresh()
build_big_test_window.refresh()
def deleting(self, id):
i = 0
i2 = self.QList.count()
while i < i2:
item = self.QList.item(i)
if item.id == id:
self.QList.removeItemWidget(item)
item.is_empty = True
i += 1
class PlotSplitter(QSplitter):
"""Pyqt5 widget to show data in plots and lists."""
# Signals
msg2statusbar = pyqtSignal(str)
msg2TextArea = pyqtSignal(str)
def __init__(self):
"""
Constructor
"""
super().__init__()
# Instance variables
self.wf = WaterFrame() # pylint: disable=C0103
# List of PlotWidget, to control them in any case
self.plot_widget_list = []
self.init_ui()
def init_ui(self):
"""UI creator"""
# Lists
self.data_list = QListWidget(self)
self.data_list.setSelectionMode(QAbstractItemView.ExtendedSelection)
self.data_list.itemClicked.connect(self.data_list_click)
self.graph_list = QListWidget(self)
self.graph_list.itemClicked.connect(self.graph_click)
# PlainTextEdit
self.other_info_plain_text = QPlainTextEdit(self)
self.metadata_plain_text = QPlainTextEdit(self)
# Labels
metadata_label = QLabel("Metadata")
data_label = QLabel("Data")
graph_label = QLabel("Graph")
info_label = QLabel("Other information")
# DropWidget
self.drop_widget = DropWidget()
self.drop_widget.list2drop[list, list, bool].connect(self.drop_data)
self.drop_widget.hide()
# Group Box
plot_group_box = QGroupBox("Plot properties", self)
v_plot_group_box = QVBoxLayout()
# - RadioButton
self.auto_plot_radio_button = QRadioButton("Time series plot", self)
self.auto_plot_radio_button.setChecked(True)
self.multiple_parameter_radio_button = QRadioButton(
"Multiparameter", self)
self.correlation_radio_button = QRadioButton("Correlation", self)
self.histogram_radio_button = QRadioButton("Histogram", self)
self.parameter_qc_radio_button = QRadioButton("QC of the parameter",
self)
v_plot_group_box.addWidget(self.auto_plot_radio_button)
v_plot_group_box.addWidget(self.histogram_radio_button)
v_plot_group_box.addWidget(self.multiple_parameter_radio_button)
v_plot_group_box.addWidget(self.correlation_radio_button)
v_plot_group_box.addWidget(self.parameter_qc_radio_button)
plot_group_box.setLayout(v_plot_group_box)
# QCWidget
self.qc_widget = QCWidget()
self.qc_widget.list2qc[list].connect(self.apply_qc)
self.qc_widget.hide()
# RenameWidget
self.rename_widget = RenameWidget()
self.rename_widget.key2change[str, str].connect(self.apply_rename)
self.rename_widget.hide()
# ResampleWidget
self.resample_widget = ResampleWidget()
self.resample_widget.resampleRule[str].connect(self.apply_resample)
self.resample_widget.hide()
# SliceWidget
self.slice_widget = SliceWidget()
self.slice_widget.sliceTimes[str, str].connect(self.apply_slice)
self.slice_widget.hide()
# Splitters
self.v_data_splitter = QSplitter(Qt.Vertical)
# Custom Widget Metadata
self.v_metadata_widget = QWidget()
# Buttons
# - For metadata area
hide_metadata_button = QPushButton("Hide")
hide_metadata_button.clicked.connect(self.v_metadata_widget.hide)
# - For data Area
plot_button = QPushButton("Plot")
plot_button.clicked.connect(self.add_plot)
hide_data_button = QPushButton("Hide")
hide_data_button.clicked.connect(self.v_data_splitter.hide)
# Custom Widget Data
# - Data Widget
parameter_widget = QWidget()
# -- Layout
v_data = QVBoxLayout()
v_data.addWidget(data_label)
v_data.addWidget(self.data_list)
v_data.addWidget(plot_group_box)
v_data.addWidget(plot_button)
parameter_widget.setLayout(v_data)
# - Graph Widget
graph_widget = QWidget()
# -- Layout
v_graph = QVBoxLayout()
v_graph.addWidget(graph_label)
v_graph.addWidget(self.graph_list)
v_graph.addWidget(hide_data_button)
graph_widget.setLayout(v_graph)
# - Data splitter
self.v_data_splitter.addWidget(parameter_widget)
self.v_data_splitter.addWidget(graph_widget)
# Layouts
# - Metadata -
v_metadata = QVBoxLayout()
v_metadata.addWidget(metadata_label)
v_metadata.addWidget(self.metadata_plain_text)
v_metadata.addWidget(info_label)
v_metadata.addWidget(self.other_info_plain_text)
v_metadata.addWidget(hide_metadata_button)
self.v_metadata_widget.setLayout(v_metadata)
# Splitter (self)
# - Layout for actions
v_actions_widget = QWidget()
v_actions = QVBoxLayout()
v_actions.addWidget(self.rename_widget)
v_actions.addWidget(self.resample_widget)
v_actions.addWidget(self.drop_widget)
v_actions.addWidget(self.slice_widget)
v_actions.addStretch()
v_actions_widget.setLayout(v_actions)
# - Add to self (splitter)
self.addWidget(self.qc_widget)
self.addWidget(v_actions_widget)
self.addWidget(self.v_metadata_widget)
self.addWidget(self.v_data_splitter)
def data_list_click(self):
"""Action on lick item of data_list"""
if (self.auto_plot_radio_button.isChecked()
or self.histogram_radio_button.isChecked()):
self.add_plot()
def add_plot(self):
"""It creates a FigureCanvas with the input figure"""
self.msg2statusbar.emit("Making the figure")
# Create key list
keys = [item.text() for item in self.data_list.selectedItems()]
# If nothing is selected, go out
if not keys:
self.msg2statusbar.emit("Ready")
return
# Check if it is a QC plot
if self.parameter_qc_radio_button.isChecked():
keys = [keys[0] + "_QC"]
# Check if it is a correlation
if self.correlation_radio_button.isChecked():
plot_widget = ScatterMatrixPlotWidget(wf=self.wf, keys=keys)
self.addWidget(plot_widget)
self.msg2statusbar.emit("Ready")
return
# Create name of the plot
name = '_'.join(keys)
if self.histogram_radio_button.isChecked():
name = "hist_" + name
# Check if plot is done
new = True
for plot_widget in self.plot_widget_list:
if plot_widget.name == name:
if ~plot_widget.isVisible():
plot_widget.refresh_plot()
plot_widget.show()
new = False
break
# Create the plot if is new
if new:
if len(keys) == 1 and "_QC" in keys[0]:
plot_widget = QCPlotWidget(wf=self.wf, key=keys[0])
else:
if self.histogram_radio_button.isChecked():
plot_widget = HistoPlotWidget(wf=self.wf, keys=keys)
else:
plot_widget = TSPlotWidget(wf=self.wf, keys=keys)
plot_widget.msg2statusbar[str].connect(self.msg2statusbar.emit)
self.addWidget(plot_widget)
# Add the widget to the list
self.plot_widget_list.append(plot_widget)
self.msg2statusbar.emit("Ready")
def add_qc_bar_plot(self):
"""
It creates a FigureCanvas with the input figure (QC)
"""
self.msg2statusbar.emit("Making the figure")
# Check if the plot exists
plot_widget = None
for plot_widget_ in self.plot_widget_list:
if plot_widget_.name == "QC":
plot_widget = plot_widget_
plot_widget.wf = self.wf
plot_widget.refresh_plot()
plot_widget.show()
break
if plot_widget is None:
plot_widget = QCBarPlotWidget(wf=self.wf)
self.addWidget(plot_widget)
# Add the widget to the list
self.plot_widget_list.append(plot_widget)
self.msg2statusbar.emit("Ready")
def add_spectro_plot(self):
"""It ads the SpectroplotWidget to the screen"""
self.msg2statusbar.emit("Making the figure")
# Check if the plot exists
plot_widget = None
for plot_widget_ in self.plot_widget_list:
if plot_widget_.name == "Spectrogram":
plot_widget = plot_widget_
plot_widget.wf = self.wf
plot_widget.refresh_plot()
plot_widget.show()
break
if plot_widget is None:
plot_widget = SpectrogramPlotWidget(wf=self.wf)
self.addWidget(plot_widget)
# Add the widget to the list
self.plot_widget_list.append(plot_widget)
self.msg2statusbar.emit("Ready")
def open_data(self, path, concat=False):
"""
It opens the netcdf of the path.
Parameters
----------
path: str or WaterFrame
Path where the file is or WaterFrame object.
concat: bool, optional (concat = False)
It adds the new dataframe to the current dataframe.
Returns
-------
True/False: bool
It indicates if the operation is ok.
"""
debug = True # Variable for debug reasons
if debug:
print("In PlotSplitter.open_data():")
print(" - Emit msg2statusbar: Opening data")
self.msg2statusbar.emit("Opening data")
if isinstance(path, str):
if debug:
print(" - path is a string:", path)
# Obtain type of file
extension = path.split(".")[-1]
# Init ok
ok = False # pylint: disable=C0103
wf_new = WaterFrame()
if extension == "nc":
ok = wf_new.from_netcdf(path) # pylint: disable=C0103
elif extension == "pkl":
ok = wf_new.from_pickle(path) # pylint: disable=C0103
if ok:
# Check if we want actual data
if not concat:
self.new_waterframe()
self.wf.concat(wf_new)
self.msg2TextArea.emit("Working with file {}".format(path))
# Add metadata information into metadataList
self.add_metadata(self.wf.metadata)
# Add other information
self.other_info_plain_text.setPlainText(repr(self.wf))
# Add data information into data_list
self.add_data(self.wf.data)
# Plot QC
self.add_qc_bar_plot()
self.msg2statusbar.emit("Ready")
if debug:
print(" - Emit msg2statusbar: Ready")
print(" - Exit from PlotSplitter.open_data()")
return True
else:
self.msg2statusbar.emit("Error opening data")
if debug:
print(" - Emit msg2statusbar: Error opening data")
print(" - Exit from PlotSplitter.open_data()")
return False
else:
# Path is a WaterFrame
if debug:
print(" - path is a WaterFrame")
print(path)
# Check if there is no data in the waterframe
if path.data.empty:
return False
# Check if it is a dataframe of an acoustic data.
# In this case, we are going to delete the previous dataframe.
if "Sequence" in self.wf.data.keys():
self.wf.clear()
self.wf.concat(path)
# Add data information into data_list
self.add_data(self.wf.data)
self.add_metadata(self.wf.metadata)
# Add other information
self.other_info_plain_text.setPlainText(repr(self.wf))
# Plot QC
self.add_qc_bar_plot()
return True
def add_metadata(self, metadata_dict):
"""
Add Metadata information into self.metadata_plain_text
:param metadata_dict: WaterFrame Metadata Dictionary
"""
# Clear the list
self.metadata_plain_text.clear()
items = []
msg = "\nMetadata:"
for key, value in metadata_dict.items():
items.append("{}: {}".format(key, value))
msg += "\n- {}: {}".format(key, value)
self.metadata_plain_text.setPlainText(msg[11:])
# Send a message to the text area
self.msg2TextArea.emit(msg)
def add_data(self, data):
"""
Add data names into self.data_list
:param data: WaterFrame data variable
"""
def is_acoustic_data(a): # pylint: disable=C0103
# will be True also for 'NaN'
if a == "Sequence":
return True
elif a == "Data Points":
return True
try:
float(a)
return True
except ValueError:
return False
# Clear the list
self.data_list.clear()
# Parameter keys (without QC)
# NO DEPTH in nc files, NO TIME
keys_to_work = [
key for key in data.keys() if 'TIME' not in key
if not is_acoustic_data(key) if key + "_QC" in data.keys()
]
self.data_list.addItems(keys_to_work)
# Add graphs
self.graph_list.clear()
self.graph_list.addItem("QC")
# Check if we have acoustic data
for key in data.keys():
if is_acoustic_data(key):
self.graph_list.addItem("Spectrogram")
break
# Add tooltip
msg = "\nData:"
for i in range(self.data_list.count()):
if "_QC" in self.data_list.item(i).text():
self.data_list.item(i).setToolTip('QC flags of {}'.format(
self.data_list.item(i).text()[:-3]))
else:
try:
self.data_list.item(i).setToolTip('{} ({})'.format(
self.wf.meaning[self.data_list.item(i).text()]
['long_name'], self.wf.meaning[self.data_list.item(
i).text()]['units']))
msg += "\n- {}: {} ({})".format(
self.data_list.item(i).text(), self.wf.meaning[
self.data_list.item(i).text()]['long_name'],
self.wf.meaning[self.data_list.item(
i).text()]['units'])
except KeyError:
pass
# Send a message to the text area
self.msg2TextArea.emit(msg)
# Send the labels to the drop_widget
self.drop_widget.add_labels(keys_to_work)
self.qc_widget.add_labels(keys_to_work)
self.rename_widget.add_labels(keys_to_work)
self.slice_widget.refresh(self.wf.data.index[0],
self.wf.data.index[-1])
def save_data(self, path):
"""
Save current data into a pickle file
:param path: File path
:return: Bool
"""
self.msg2statusbar.emit("Saving data")
extension = path.split(".")[-1]
# Init ok
ok = False # pylint: disable=C0103
if extension == "nc":
pass
elif extension == "pkl":
ok = self.wf.to_pickle(path) # pylint: disable=C0103
elif extension == "csv":
ok = self.wf.to_csv(path) # pylint: disable=C0103
if ok:
self.msg2TextArea.emit("Data saved on file {}".format(path))
self.msg2statusbar.emit("Ready")
return ok
def drop_data(self, labels, flag_list, drop_nan):
"""
Delete some parameters from self.wf and refresh the lists
:param labels: list of labels to drop
:param flag_list: list of flags to drop
:return:
"""
self.msg2TextArea.emit("Deleting data")
# This is a trick, delete the list if is a list of None
if flag_list[0] is None:
flag_list = None
if flag_list:
self.wf.use_only(parameters=labels, flags=[0, 1], dropnan=drop_nan)
else:
# Delete the parameters
self.wf.drop(keys=labels, flags=flag_list)
# Refresh the lists
self.add_data(self.wf.data)
# Delete plots with the key
for label in labels:
for plot_widget in self.plot_widget_list:
if plot_widget.name == "QC":
plot_widget.refresh_plot()
if label == plot_widget.name or label+"_" in \
plot_widget.name or "_"+label in plot_widget.name:
plot_widget.deleteLater()
self.plot_widget_list.remove(plot_widget)
# Send message
msg = ""
if flag_list is None:
for label in labels:
if '_QC' in label:
continue
msg += "{} ".format(label)
msg += "deleted"
else:
msg += "Data with QC Flags "
for flag in flag_list:
msg += "{}, ".format(flag)
msg += "from "
for label in labels:
if '_QC' in label:
continue
msg += "{}, ".format(label)
msg += "deleted"
self.msg2TextArea.emit("\n{}".format(msg))
self.msg2statusbar.emit(msg)
def apply_qc(self, list_qc):
"""
Apply the QC procedures
:param list_qc:
:return:
"""
def do_it(key_in):
"""
Common part, to not repeat code
:param key_in: key to apply QC tests
"""
if '_QC' in key_in:
return
if list_qc[0]:
# Reset flags
self.msg2statusbar.emit("Setting flags from {} to {}".format(
key_in, list_qc[0]))
self.wf.reset_flag(parameters=key_in, flag=int(list_qc[0]))
self.msg2statusbar.emit("Ready")
if list_qc[3]:
# Spike test
threshold = float(list_qc[4].replace(',', '.'))
self.msg2statusbar.emit(
"Applying spike test to "
"{}, with rolling window {} and threshold {}".format(
key_in, list_qc[5], threshold))
self.wf.spike_test(parameters=key_in,
window=int(list_qc[5]),
threshold=threshold,
flag=int(list_qc[3]))
self.msg2statusbar.emit("Ready")
if list_qc[1]:
# Range test
self.msg2statusbar.emit(
"Applying range test to {}".format(key_in))
self.wf.range_test(parameters=key_in, flag=int(list_qc[1]))
self.msg2statusbar.emit("Ready")
if list_qc[2]:
# Flat test
self.msg2statusbar.emit("Applying flat test to"
" {}, with rolling window {}".format(
key_in, list_qc[5]))
self.wf.flat_test(parameters=key_in,
window=int(list_qc[5]),
flag=int(list_qc[2]))
self.msg2statusbar.emit("Ready")
if list_qc[6]:
# Flag to flag
self.msg2statusbar.emit("Changing flags of "
"{} from {} to {}".format(
key_in, list_qc[6], list_qc[7]))
self.wf.flag2flag(parameters=key_in,
original_flag=int(list_qc[6]),
translated_flag=int(list_qc[7]))
self.msg2statusbar.emit("Ready")
self.msg2statusbar.emit("Creating QC flags")
if list_qc[8] == 'all':
for key in self.wf.parameters():
do_it(key_in=key)
else:
for i in range(8, len(list_qc)):
key = list_qc[i]
do_it(key_in=key)
self.msg2statusbar.emit("Updating graphs")
# Refresh the QC graph
for plot_widget in self.plot_widget_list:
if "QC" in plot_widget.name:
if plot_widget.isVisible():
plot_widget.refresh_plot()
# Show the QCBarPlot
elif plot_widget.name == "QC":
plot_widget.refresh_plot()
plot_widget.show()
self.msg2statusbar.emit("Ready")
def apply_rename(self, original_key, new_key):
"""It renames keys from a WaterFrame"""
# Rename key from the Waterframe
self.msg2statusbar.emit("Changing name {} to {}".format(
original_key, new_key))
self.wf.rename(original_key, new_key)
# Rename the key of the plotWidgets if it process
for plot_widget in self.plot_widget_list:
if isinstance(plot_widget.key, list):
for i, key in enumerate(plot_widget.key):
if key == original_key:
plot_widget.key[i] = new_key
plot_widget.name = plot_widget.name.replace(
original_key, new_key)
plot_widget.refresh_plot()
else:
if plot_widget.name == "QC":
plot_widget.refresh_plot()
elif plot_widget.key == original_key:
plot_widget.key = new_key
plot_widget.name = new_key
plot_widget.refresh_plot()
# Add data information into data_list
self.add_data(self.wf.data)
self.msg2statusbar.emit("Ready")
self.msg2TextArea.emit("Key name {} changed to {}.".format(
original_key, new_key))
def apply_resample(self, rule):
"""
It applies the resample function to self.waterframe
:param rule: Rule to resample.
"""
self.msg2statusbar.emit("Resampling data")
self.wf.resample(rule)
self.msg2statusbar.emit("Ready")
self.msg2statusbar.emit("Updating graphs")
# Refresh the QC graph
for plot_widget in self.plot_widget_list:
if "QC" in plot_widget.name:
if plot_widget.isVisible():
plot_widget.refresh_plot()
# Show the QCBarPlot
elif plot_widget.name == "QC":
plot_widget.refresh_plot()
plot_widget.show()
self.msg2statusbar.emit("Ready")
def apply_slice(self, start, stop):
"""
It applies the resample function to self.waterframe
:param start: Start time.
:param stop: Stop time
"""
self.msg2statusbar.emit("Slicing data")
self.wf.slice_time(start, stop)
self.add_data(self.wf.data)
self.refresh_plots()
self.msg2statusbar.emit("Ready")
self.msg2TextArea.emit("Dataframe sliced from {} to {}.".format(
start, stop))
def graph_click(self, item):
"""Function on click the plot button"""
if item.text() == "QC":
self.add_qc_bar_plot()
elif item.text() == "Spectrogram":
self.add_spectro_plot()
def new_waterframe(self):
"""Create a new WaterFrame object and clean all screens."""
self.wf = WaterFrame()
# Delete all plots
for plot_widget in self.plot_widget_list:
plot_widget.deleteLater()
self.plot_widget_list.clear()
# Hide the widget
self.hide()
def refresh_plots(self):
"""It refresh all plots"""
self.msg2statusbar.emit("Refreshing plots")
for plot_widget in self.plot_widget_list:
try:
plot_widget.refresh_plot()
except KeyError:
self.plot_widget_list.remove(plot_widget)
plot_widget.hide()
plot_widget.deleteLater()
self.msg2statusbar.emit("Ready")
class EasyQListSuite(QWidget):
"""
Provide a window that has a QListWidget with 'Add' and 'Remove' button.
"""
def __init__(self, *__args):
super(EasyQListSuite, self).__init__(*__args)
self.__item_list = []
self.__list_main = QListWidget(self)
self.__button_add = QPushButton('Add')
self.__button_remove = QPushButton('Remove')
self.__init_ui()
self.__config_ui()
def update_item(self, items: [(str, any)]):
"""
Specify a (key, value) tuple list.
Key will be displayed as list item.
Value can be retrieved by get_select_items()
:param items: Specify a (key, value) tuple list.
:return: None
"""
self.__item_list.clear()
for item in items:
if isinstance(item, (list, tuple)):
if len(item) == 0:
continue
elif len(item) == 1:
self.__item_list.append((str(item[0]), item[0]))
else:
self.__item_list.append((str(item[0]), item[1]))
else:
self.__item_list.append((str(item), item))
self.__update_list()
def get_select_items(self) -> [any]:
"""
Get the value of the items that user selected.
:return: The value of the items that user selected.
"""
return [
item.data(Qt.UserRole)
for item in self.__list_main.selectedItems()
]
def set_add_handler(self, handler):
"""
Add a handler for 'Add' button clicking
:param handler: The handler that connects to the button clicked signal
:return:
"""
self.__button_add.clicked.connect(handler)
def set_remove_handler(self, handler):
"""
Add a handler for 'Remove' button clicking
:param handler: The handler that connects to the button clicked signal
:return:
"""
self.__button_remove.clicked.connect(handler)
# ---------------------------------------- Private ----------------------------------------
def __init_ui(self):
main_layout = QVBoxLayout()
self.setLayout(main_layout)
line_layout = QHBoxLayout()
line_layout.addWidget(self.__button_add)
line_layout.addWidget(self.__button_remove)
main_layout.addWidget(self.__list_main)
main_layout.addLayout(line_layout)
def __config_ui(self):
pass
def __update_list(self):
self.__list_main.clear()
for text, obj in self.__item_list:
item = QListWidgetItem()
item.setText(text)
item.setData(Qt.UserRole, obj)
self.__list_main.addItem(item)
class GuiDocMerge(QDialog):
def __init__(self, theParent, theProject):
QDialog.__init__(self, theParent)
logger.debug("Initialising GuiDocMerge ...")
self.setObjectName("GuiDocMerge")
self.mainConf = nw.CONFIG
self.theParent = theParent
self.theProject = theProject
self.sourceItem = None
self.outerBox = QVBoxLayout()
self.setWindowTitle(self.tr("Merge Documents"))
self.headLabel = QLabel("<b>%s</b>" % self.tr("Documents to Merge"))
self.helpLabel = QHelpLabel(
self.tr("Drag and drop items to change the order."),
self.theParent.theTheme.helpText)
self.listBox = QListWidget()
self.listBox.setDragDropMode(QAbstractItemView.InternalMove)
self.listBox.setMinimumWidth(self.mainConf.pxInt(400))
self.listBox.setMinimumHeight(self.mainConf.pxInt(180))
self.buttonBox = QDialogButtonBox(QDialogButtonBox.Ok
| QDialogButtonBox.Cancel)
self.buttonBox.accepted.connect(self._doMerge)
self.buttonBox.rejected.connect(self._doClose)
self.outerBox.setSpacing(0)
self.outerBox.addWidget(self.headLabel)
self.outerBox.addWidget(self.helpLabel)
self.outerBox.addSpacing(self.mainConf.pxInt(8))
self.outerBox.addWidget(self.listBox)
self.outerBox.addSpacing(self.mainConf.pxInt(12))
self.outerBox.addWidget(self.buttonBox)
self.setLayout(self.outerBox)
self.rejected.connect(self._doClose)
self._populateList()
logger.debug("GuiDocMerge initialisation complete")
return
##
# Buttons
##
def _doMerge(self):
"""Perform the merge of the files in the selected folder, and
create a new file in the same parent folder. The old files are
not removed in the merge process, and must be deleted manually.
"""
logger.verbose("GuiDocMerge merge button clicked")
finalOrder = []
for i in range(self.listBox.count()):
finalOrder.append(self.listBox.item(i).data(Qt.UserRole))
if len(finalOrder) == 0:
self.theParent.makeAlert(
self.tr("No source documents found. Nothing to do."),
nwAlert.ERROR)
return
theDoc = NWDoc(self.theProject, self.theParent)
theText = ""
for tHandle in finalOrder:
theText += theDoc.openDocument(tHandle, False).rstrip("\n")
theText += "\n\n"
if self.sourceItem is None:
self.theParent.makeAlert(
self.tr("No source document selected. Nothing to do."),
nwAlert.ERROR)
return
srcItem = self.theProject.projTree[self.sourceItem]
if srcItem is None:
self.theParent.makeAlert(
self.tr("Could not parse source document."), nwAlert.ERROR)
return
nHandle = self.theProject.newFile(srcItem.itemName, srcItem.itemClass,
srcItem.itemParent)
newItem = self.theProject.projTree[nHandle]
newItem.setStatus(srcItem.itemStatus)
theDoc.openDocument(nHandle, False)
theDoc.saveDocument(theText)
self.theParent.treeView.revealNewTreeItem(nHandle)
self.theParent.openDocument(nHandle, doScroll=True)
self._doClose()
return
def _doClose(self):
"""Close the dialog window without doing anything.
"""
self.close()
return
##
# Internal Functions
##
def _populateList(self):
"""Get the item selected in the tree, check that it is a folder,
and try to find all files associated with it. The valid files
are then added to the list view in order. The list itself can be
reordered by the user.
"""
tHandle = self.theParent.treeView.getSelectedHandle()
self.sourceItem = tHandle
if tHandle is None:
return
nwItem = self.theProject.projTree[tHandle]
if nwItem is None:
return
if nwItem.itemType is not nwItemType.FOLDER:
self.theParent.makeAlert(
self.tr(
"Element selected in the project tree must be a folder."),
nwAlert.ERROR)
return
for sHandle in self.theParent.treeView.getTreeFromHandle(tHandle):
newItem = QListWidgetItem()
nwItem = self.theProject.projTree[sHandle]
if nwItem.itemType is not nwItemType.FILE:
continue
newItem.setText(nwItem.itemName)
newItem.setData(Qt.UserRole, sHandle)
self.listBox.addItem(newItem)
return
class WelcomeDialog(QDialog):
onSessionSelected = pyqtSignal(str, name='onSessionSelected')
onUpdateComplete = pyqtSignal(name='onUpdateComplete')
onIsNewerVersion = pyqtSignal(name='onIsNewerVersion')
def __init__(self, parent=None):
super(WelcomeDialog, self).__init__(parent=parent)
self._prefs = parent.prefs
self.recent_list = QListWidget(self)
# setup size and remove/disable titlebuttons
self.setFixedSize(800, 400)
self.setSizeGripEnabled(False)
self.setSizePolicy(QSizePolicy.Fixed, QSizePolicy.Fixed)
self.setWindowFlag(Qt.WindowContextHelpButtonHint, False)
self.setWindowFlag(Qt.WindowCloseButtonHint, True)
self.setModal(True)
# setup ui elements
self.setup_ui()
self.update_commits_thread = DwarfCommitsThread(parent)
self.update_commits_thread.on_update_available.connect(self._on_dwarf_isupdate)
self.update_commits_thread.start()
# center
self.setGeometry(QStyle.alignedRect(Qt.LeftToRight, Qt.AlignCenter, self.size(), qApp.desktop().availableGeometry()))
saved_sessions = self._prefs.get('dwarf_mru', '{}')
saved_sessions = json.loads(saved_sessions)
for saved in saved_sessions:
self.recent_list.addItem(QListWidgetItem(saved['path']))
def setup_ui(self):
""" Setup Ui
"""
main_wrap = QVBoxLayout()
main_wrap.setContentsMargins(0, 0, 0, 0)
# updatebar on top
self.update_bar = UpdateBar(self)
self.update_bar.onUpdateNowClicked.connect(self._update_dwarf)
self.update_bar.setVisible(False)
main_wrap.addWidget(self.update_bar)
# main content
h_box = QHBoxLayout()
h_box.setContentsMargins(15, 15, 15, 15)
wrapper = QVBoxLayout()
#wrapper.setGeometry(QRect(0, 0, 400, 200))
head = QHBoxLayout()
# dwarf icon
icon = QLabel()
icon.setContentsMargins(100, 0, 20, 0)
icon.setPixmap(QPixmap(utils.resource_path('assets/dwarf.png')))
head.addWidget(icon)
# main title
title = QLabel('Dwarf')
title.setFont(QFont('Anton', 85, QFont.Bold))
title.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Preferred)
head.addWidget(title)
wrapper.addLayout(head)
recent = QLabel('Last saved Sessions')
font = recent.font()
font.setBold(True)
font.setPointSize(10)
recent.setFont(font)
wrapper.addWidget(recent)
wrapper.addWidget(self.recent_list)
h_box.addLayout(wrapper, stretch=False)
buttonSpacer = QSpacerItem(15, 100, QSizePolicy.Fixed, QSizePolicy.Minimum)
h_box.addItem(buttonSpacer)
wrapper = QVBoxLayout()
btn = QPushButton()
ico = QIcon(QPixmap(utils.resource_path('assets/android.png')))
btn.setIconSize(QSize(75, 75))
btn.setIcon(ico)
btn.setToolTip('New Android Session')
btn.clicked.connect(self._on_android_button)
wrapper.addWidget(btn)
btn = QPushButton()
ico = QIcon(QPixmap(utils.resource_path('assets/apple.png')))
btn.setIconSize(QSize(75, 75))
btn.setIcon(ico)
btn.setToolTip('New iOS Session')
wrapper.addWidget(btn)
btn = QPushButton()
ico = QIcon(QPixmap(utils.resource_path('assets/local.png')))
btn.setIconSize(QSize(75, 75))
btn.setIcon(ico)
btn.setToolTip('New Local Session')
btn.clicked.connect(self._on_local_button)
wrapper.addWidget(btn)
btn = QPushButton()
ico = QIcon(QPixmap(utils.resource_path('assets/remote.png')))
btn.setIconSize(QSize(75, 75))
btn.setIcon(ico)
btn.setToolTip('New Remote Session')
wrapper.addWidget(btn)
h_box.addLayout(wrapper, stretch=False)
main_wrap.addLayout(h_box)
self.setLayout(main_wrap)
def _on_dwarf_isupdate(self):
self.update_bar.setVisible(True)
self.onIsNewerVersion.emit()
def _update_dwarf(self):
self._update_thread = DwarfUpdateThread(self)
self._update_thread.on_finished.connect(self._update_finished)
if not self._update_thread.isRunning():
self._update_thread.start()
def _update_finished(self):
self.onUpdateComplete.emit()
def _on_android_button(self):
self.onSessionSelected.emit('Android')
self.close()
def _on_local_button(self):
self.onSessionSelected.emit('Local')
self.close()
class Window(QWidget):
def __init__(self):
super().__init__()
self.title = 'Graphy'
self.left = 10
self.top = 10
self.width = 810
self.height = 610
self.functionList = []
self.initUI()
def initUI(self):
self.setWindowTitle(self.title)
self.setGeometry(self.left, self.top, self.width, self.height)
self.createWidgets()
self.initGridLayout()
self.initEvent()
self.show()
def createWidgets(self):
self.glWidget = openGL(self)
self.glWidget.resize(800, 600)
self.textbox = QLineEdit(self)
self.functionListW = QListWidget(self)
self.addEqButton = QPushButton('Add')
def initGridLayout(self):
layout = QGridLayout()
layout.setColumnStretch(0, 10)
layout.setRowStretch(0, 10)
layout.addWidget(self.glWidget, 0, 0)
layout.addWidget(self.textbox, 1, 0)
layout.addWidget(self.addEqButton, 1, 1)
layout.addWidget(self.functionListW, 0, 1)
self.setLayout(layout)
def initEvent(self):
self.addEqButton.clicked.connect(self.onAddClick)
def addElementToList(self):
i = self.glWidget.getElementsSize() - 1
item = QListWidgetItem(self.functionListW)
customWidget = functionListQT.FunctionListQT(self.glWidget.getFunction(i).getFunction(), self, i, item,
self.deleteFunction)
item.setSizeHint(customWidget.sizeHint())
self.functionListW.addItem(item)
self.functionListW.setItemWidget(item, customWidget)
def deleteFunction(self, i, item):
self.functionListW.takeItem(self.functionListW.row(item))
# self.functionListW.removeItemWidget( item )
# widget.deleteLater()
self.glWidget.removeFunction(i)
pass
def processExpresion(self, str):
"""
:param str: str
:return:
"""
fullExp = str.split(":")
exp = fullExp[0]
if (len(fullExp) > 1):
if fullExp[1].replace(" ", "") == "Parametric":
type = Function.Types.PARAMETRIC
elif fullExp[1].replace(" ", "") == "VField":
type = Function.Types.VECTOR
else:
type = Function.Types.MULT_FUNC
return (exp, type)
@pyqtSlot()
def onAddClick(self):
textboxValue = self.textbox.text()
try:
exp, type = self.processExpresion(textboxValue)
self.glWidget.addFunction(exp, type)
self.addElementToList()
finally:
self.textbox.setText("")
class ListEdit(QWidget):
"""A widget to edit a list of items (e.g. a list of directories)."""
# emitted when anything changed in the listbox.
changed = pyqtSignal()
def __init__(self, *args, **kwargs):
QWidget.__init__(self, *args, **kwargs)
layout = QGridLayout(self)
self.setLayout(layout)
self.addButton = QPushButton(icons.get('list-add'), '')
self.editButton = QPushButton(icons.get('document-edit'), '')
self.removeButton = QPushButton(icons.get('list-remove'), '')
self.listBox = QListWidget()
layout.setContentsMargins(1, 1, 1, 1)
layout.setSpacing(0)
layout.addWidget(self.listBox, 0, 0, 8, 1)
layout.addWidget(self.addButton, 0, 1)
layout.addWidget(self.editButton, 1, 1)
layout.addWidget(self.removeButton, 2, 1)
@self.addButton.clicked.connect
def addClicked():
item = self.createItem()
if self.openEditor(item):
self.addItem(item)
@self.editButton.clicked.connect
def editClicked():
item = self.listBox.currentItem()
item and self.editItem(item)
@self.removeButton.clicked.connect
def removeClicked():
item = self.listBox.currentItem()
if item:
self.removeItem(item)
@self.listBox.itemDoubleClicked.connect
def itemDoubleClicked(item):
item and self.editItem(item)
self.listBox.model().layoutChanged.connect(self.changed)
def updateSelection():
selected = bool(self.listBox.currentItem())
self.editButton.setEnabled(selected)
self.removeButton.setEnabled(selected)
self.changed.connect(updateSelection)
self.listBox.itemSelectionChanged.connect(updateSelection)
updateSelection()
app.translateUI(self)
def translateUI(self):
self.addButton.setText(_("&Add..."))
self.editButton.setText(_("&Edit..."))
self.removeButton.setText(_("&Remove"))
def createItem(self):
return QListWidgetItem()
def addItem(self, item):
self.listBox.addItem(item)
self.itemChanged(item)
self.changed.emit()
def removeItem(self, item):
self.listBox.takeItem(self.listBox.row(item))
self.changed.emit()
def editItem(self, item):
if self.openEditor(item):
self.itemChanged(item)
self.changed.emit()
def setCurrentItem(self, item):
self.listBox.setCurrentItem(item)
def setCurrentRow(self, row):
self.listBox.setCurrentRow(row)
def openEditor(self, item):
"""Opens an editor (dialog) for the item.
Returns True if the dialog was accepted and the item edited.
Returns False if the dialog was cancelled (the item must be left
unedited).
"""
pass
def itemChanged(self, item):
"""Called after an item has been added or edited.
Re-implement to do something at this moment if needed, e.g. alter the
text or display of other items.
"""
pass
def setValue(self, strings):
"""Sets the listbox to a list of strings."""
self.listBox.clear()
self.listBox.addItems(strings)
self.changed.emit()
def value(self):
"""Returns the list of paths in the listbox."""
return [self.listBox.item(i).text()
for i in range(self.listBox.count())]
def setItems(self, items):
"""Sets the listbox to a list of items."""
self.listBox.clear()
for item in items:
self.listBox.addItem(item)
self.itemChanged(item)
self.changed.emit()
def items(self):
"""Returns the list of items in the listbox."""
return [self.listBox.item(i)
for i in range(self.listBox.count())]
def clear(self):
"""Clears the listbox."""
self.listBox.clear()
self.changed.emit()
class MessengerNotifGui(QDialog):
def __init__(self):
super().__init__()
self.__mutex = Lock() #TODO useless?
self.unreadMessageFetcher = UnreadMessageFetcher(
getMessengerUserName(), getMessengerPassword())
self.__list = QListWidget()
self.UpdateNotificationList()
##Public method to return notifications widget to the application class' instance for fill the notification's
# scrollable area by returning all the notification widgets into a single widget list containing all the
# notifications.
#
# arg: none
#
# return: __list: a QListWidget (a list for QWidget objects) containing all the notifications.
def getWidget(self):
return (self.__list)
##Public method used by the application class' instance to actualise the content of the thread list and the
# notification dictionnary list.
#
# arg: none
#
# return: none
def UpdateLists(self):
self.unreadMessageFetcher.setLists()
##Public method to update the content of the graphical version of the notification list.
# The method uses the size of __unreadMessageDictionnaryList and the value of __newUnreadMessageNb
# deduce the new unread messages' indexes and loop into the new values add into the
# __unreadMessageDictionnaryList to fetch the informations contained into the new dictionnaries of
# the list.
#
# arg: none
#
# return: none
def UpdateNotificationList(self):
totalListSize = self.unreadMessageFetcher.getTotalUnreadMessageNumber()
newListElementNb = self.unreadMessageFetcher.getNewUnreadMessageNumber(
)
for i in range(newListElementNb):
index = ((totalListSize - newListElementNb) + i)
notificationLayout = QHBoxLayout()
messageLayout = QVBoxLayout()
messageTextLayout = QVBoxLayout()
authorLayout = QVBoxLayout()
messageLabel = QLabel(self.unreadMessageFetcher.getMessage(index))
messageLabel.setWordWrap(True)
authorLabel = QLabel(
self.unreadMessageFetcher.getAuthorName(index))
conversationPicURL = self.unreadMessageFetcher.getConversationPic(
index)
conversationPic = QtGui.QImage()
conversationPic.loadFromData(
urllib.request.urlopen(conversationPicURL).read())
pixmap = QPixmap(conversationPic)
pixmap.scaled(50, 50)
conversationPicLabel = QLabel()
conversationPicLabel.setPixmap(pixmap)
authorLayout.addWidget(authorLabel)
messageTextLayout.addWidget(messageLabel)
if (i < (newListElementNb - 1)):
separatorLine = QFrame()
separatorLine.setFrameShape(QFrame.HLine)
separatorLine.setSizePolicy(QSizePolicy.Minimum,
QSizePolicy.Expanding)
messageTextLayout.addWidget(separatorLine)
messageLayout.addLayout(authorLayout)
messageLayout.addLayout(messageTextLayout)
notificationLayout.addWidget(conversationPicLabel)
notificationLayout.addLayout(messageLayout)
notificationWidget = QWidget()
notificationWidget.setLayout(notificationLayout)
notificationItem = QListWidgetItem()
notificationItem.setSizeHint(notificationWidget.sizeHint())
self.__list.addItem(notificationItem)
self.__list.setItemWidget(notificationItem, notificationWidget)
#Esthetics
messageLabel.setAlignment(Qt.AlignLeft)
authorLabel.setAlignment(Qt.AlignLeft)
messageLayout.setAlignment(Qt.AlignLeft)
font = QtGui.QFont()
font.setBold(True)
authorLabel.setFont(font)
self.unreadMessageFetcher.resetNewUnreadMessageNb()
##Public method used by the application class' instance to empty the graphical and the data notification
# structures from the MessengerNotifGui and UnreadMessageFetcher class instances.
# notification dictionnary list.
#
# arg: none
#
# return: none
def DeleteNotifications(self):
emptyListsThread = Thread(target=self.unreadMessageFetcher.EmptyLists)
emptyListsThread.start()
self.__list.clear()
