class AllMoviesView(QWidget):
def __init__(self, parent):
super().__init__(parent)
self.ui = Ui_allMovies_window()
self.ui.setupUi(self)
self.labels = ['Id', 'Title', 'Film director', 'Genre', 'Status']
self.ui.allMovies_tableView.clicked.connect(self.movie_details)
self.show()
def loadData(self):
results = movie_session.query(Movie, Film_director, Genre, MovieStatus).select_from(Movie).join(Film_director).join(Genre).join(MovieStatus).all()
self.model = QStandardItemModel(len(results), len(self.labels))
self.model.setHorizontalHeaderLabels(self.labels)
self.filter_proxy_model = QSortFilterProxyModel()
self.filter_proxy_model.setFilterKeyColumn(-1)
self.filter_proxy_model.setSourceModel(self.model)
for row, (movie, film_director, genre, movie_status) in enumerate(results):
movie_id = QStandardItem(str(movie.id))
movie_id.setTextAlignment(Qt.AlignCenter)
movie_title = QStandardItem(movie.title)
movie_title.setTextAlignment(Qt.AlignCenter)
filmDirector = QStandardItem(film_director.name + " " + film_director.surname)
filmDirector.setTextAlignment(Qt.AlignCenter)
genreI = QStandardItem(genre.name)
genreI.setTextAlignment(Qt.AlignCenter)
status = QStandardItem(movie_status.name)
status.setTextAlignment(Qt.AlignCenter)
status.setForeground(QBrush(getColorStatus(movie.status_id, movie)))
self.model.setItem(row, 0, movie_id)
self.model.setItem(row, 1, movie_title)
self.model.setItem(row, 2, filmDirector)
self.model.setItem(row, 3, genreI)
self.model.setItem(row, 4, status)
self.ui.allMovies_tableView.setModel(self.filter_proxy_model)
self.ui.allMovies_tableView.setColumnHidden(0, True)
self.ui.searchMovie_lineEdit.textChanged.connect(self.filter_proxy_model.setFilterRegExp)
def movie_details(self):
row = self.ui.allMovies_tableView.selectionModel().selectedRows()[0].row()
id = self.filter_proxy_model.index(row, 0).data()
result = movie_session.query(Movie, Film_director, Genre, MovieStatus).select_from(Movie).filter_by(id=id).join(Film_director).join(Genre).join(MovieStatus).first()
movie, film_director, genre, status = result
movie_view = self.parent().findChild(QWidget, 'movie_window')
movie_view.updateValues(movie, film_director, genre, status)
self.parent().setCurrentWidget(movie_view)
class SpellingDictionaryEditDialog(QDialog, Ui_SpellingDictionaryEditDialog):
"""
Class implementing a dialog to edit the various spell checking
dictionaries.
"""
def __init__(self, data, info, parent=None):
"""
Constructor
@param data contents to be edited (string)
@param info info string to show at the header (string)
@param parent reference to the parent widget (QWidget)
"""
super(SpellingDictionaryEditDialog, self).__init__(parent)
self.setupUi(self)
self.infoLabel.setText(info)
self.__model = QStringListModel(
[line.strip() for line in data.splitlines() if line.strip()], self)
self.__model.sort(0)
self.__proxyModel = QSortFilterProxyModel(self)
self.__proxyModel.setFilterCaseSensitivity(Qt.CaseInsensitive)
self.__proxyModel.setDynamicSortFilter(True)
self.__proxyModel.setSourceModel(self.__model)
self.wordList.setModel(self.__proxyModel)
self.searchEdit.textChanged.connect(
self.__proxyModel.setFilterFixedString)
self.removeButton.clicked.connect(self.wordList.removeSelected)
self.removeAllButton.clicked.connect(self.wordList.removeAll)
@pyqtSlot()
def on_addButton_clicked(self):
"""
Private slot to handle adding an entry.
"""
self.__model.insertRow(self.__model.rowCount())
self.wordList.edit(
self.__proxyModel.index(self.__model.rowCount() - 1, 0))
def getData(self):
"""
Public method to get the data.
@return data of the dialog (string)
"""
return os.linesep.join([
line.strip() for line in self.__model.stringList() if line.strip()
]) + os.linesep
class SpellingDictionaryEditDialog(QDialog, Ui_SpellingDictionaryEditDialog):
"""
Class implementing a dialog to edit the various spell checking
dictionaries.
"""
def __init__(self, data, info, parent=None):
"""
Constructor
@param data contents to be edited (string)
@param info info string to show at the header (string)
@param parent reference to the parent widget (QWidget)
"""
super(SpellingDictionaryEditDialog, self).__init__(parent)
self.setupUi(self)
self.infoLabel.setText(info)
self.__model = QStringListModel(data.splitlines(), self)
self.__model.sort(0)
self.__proxyModel = QSortFilterProxyModel(self)
self.__proxyModel.setFilterCaseSensitivity(Qt.CaseInsensitive)
self.__proxyModel.setDynamicSortFilter(True)
self.__proxyModel.setSourceModel(self.__model)
self.wordList.setModel(self.__proxyModel)
self.searchEdit.textChanged.connect(
self.__proxyModel.setFilterFixedString)
self.removeButton.clicked.connect(self.wordList.removeSelected)
self.removeAllButton.clicked.connect(self.wordList.removeAll)
@pyqtSlot()
def on_addButton_clicked(self):
"""
Private slot to handle adding an entry.
"""
self.__model.insertRow(self.__model.rowCount())
self.wordList.edit(
self.__proxyModel.index(self.__model.rowCount() - 1, 0))
def getData(self):
"""
Public method to get the data.
@return data of the dialog (string)
"""
return os.linesep.join(
[line for line in self.__model.stringList() if line])
class AllFilmDirectorsView(QWidget):
def __init__(self, parent):
super().__init__(parent)
self.ui = Ui_AllFilmDirectors_window()
self.ui.setupUi(self)
self.labels = ['Id', 'Name', 'Surname']
self.ui.allFilmDirectors_tableView.clicked.connect(
self.filmDirector_details)
self.show()
def loadData(self):
filmDirectors = movie_session.query(Film_director).all()
self.model = QStandardItemModel(len(filmDirectors), len(self.labels))
self.model.setHorizontalHeaderLabels(self.labels)
self.filter_proxy_model = QSortFilterProxyModel()
self.filter_proxy_model.setFilterKeyColumn(-1)
self.filter_proxy_model.setSourceModel(self.model)
for row, filmDirector in enumerate(filmDirectors):
filmDirector_id = QStandardItem(str(filmDirector.id))
filmDirector_id.setTextAlignment(Qt.AlignCenter)
filmDirector_name = QStandardItem(filmDirector.name)
filmDirector_name.setTextAlignment(Qt.AlignCenter)
filmDirector_surname = QStandardItem(filmDirector.surname)
filmDirector_surname.setTextAlignment(Qt.AlignCenter)
self.model.setItem(row, 0, filmDirector_id)
self.model.setItem(row, 1, filmDirector_name)
self.model.setItem(row, 2, filmDirector_surname)
self.ui.allFilmDirectors_tableView.setModel(self.filter_proxy_model)
self.ui.allFilmDirectors_tableView.setColumnHidden(0, True)
self.ui.searchFilmDirector_lineEdit.textChanged.connect(
self.filter_proxy_model.setFilterRegExp)
def filmDirector_details(self):
row = self.ui.allFilmDirectors_tableView.selectionModel().selectedRows(
)[0].row()
id = self.filter_proxy_model.index(row, 0).data()
filmDirector = movie_session.query(Film_director).filter_by(
id=id).first()
filmDirector_view = self.parent().findChild(QWidget,
'filmDirector_window')
filmDirector_view.updateValues(filmDirector)
self.parent().setCurrentWidget(filmDirector_view)
class TagChooser(Ui_Form, QWidget):
def __init__(self, *args, **kwargs):
super(TagChooser, self).__init__(*args, **kwargs)
self.setupUi(self)
with open_db() as db:
self.tags_model = CheckableTagsListModel(db, parent=self)
self.filter_model = QSortFilterProxyModel(self)
self.filter_model.setSourceModel(self.tags_model)
self.tagsList.setModel(self.filter_model)
self.filterEdit.textEdited.connect(self.tags_model.setNewTagItem)
self.filterEdit.textEdited.connect(
self.filter_model.setFilterFixedString)
self.filterEdit.textEdited.connect(self.selectAtLeastOne)
self.filterEdit.installEventFilter(self)
self.selectAtLeastOne()
def setCheckedTags(self, tags, semi=()):
self.tags_model.set_checked(tags, semi)
def checkedTags(self):
return self.tags_model.get_checked()
@Slot()
def selectAtLeastOne(self):
if not self.tagsList.selectionModel().hasSelection():
self.tagsList.selectionModel().setCurrentIndex(
self.filter_model.index(0, 0),
QItemSelectionModel.ClearAndSelect | QItemSelectionModel.Rows)
def eventFilter(self, target, event):
if target is not self.filterEdit:
return super(TagChooser, self).eventFilter(target, event)
elif event.type() != event.KeyPress:
return False
elif event.key() in (Qt.Key_Up, Qt.Key_Down):
self.tagsList.event(event)
return True
elif event.key() == Qt.Key_Space:
self.tagsList.event(event)
return True
return False
class AllGenresView(QWidget):
def __init__(self, parent):
super().__init__(parent)
self.ui = Ui_allGenres_window()
self.ui.setupUi(self)
self.labels = ['Id', 'Name']
self.ui.allGenres_tableView.clicked.connect(self.editGenre)
self.show()
def loadData(self):
genres = movie_session.query(Genre).all()
self.model = QStandardItemModel(len(genres), len(self.labels))
self.model.setHorizontalHeaderLabels(self.labels)
self.filter_proxy_model = QSortFilterProxyModel()
self.filter_proxy_model.setFilterKeyColumn(-1)
self.filter_proxy_model.setSourceModel(self.model)
for row, genre in enumerate(genres):
genre_id = QStandardItem(str(genre.id))
genre_id.setTextAlignment(Qt.AlignCenter)
genre_name = QStandardItem(genre.name)
genre_name.setTextAlignment(Qt.AlignCenter)
self.model.setItem(row, 0, genre_id)
self.model.setItem(row, 1, genre_name)
self.ui.allGenres_tableView.setModel(self.filter_proxy_model)
self.ui.allGenres_tableView.setColumnHidden(0, True)
self.ui.searchGenre_lineEdit.textChanged.connect(
self.filter_proxy_model.setFilterRegExp)
def editGenre(self):
row = self.ui.allGenres_tableView.selectionModel().selectedRows(
)[0].row()
id = self.filter_proxy_model.index(row, 0).data()
genre = movie_session.query(Genre).filter_by(id=id).first()
genre_view = self.parent().findChild(QWidget, 'genre_window')
genre_view.updateValues(genre)
self.parent().setCurrentWidget(genre_view)
class MinibufferInput(QLineEdit):
completion_activated = Signal(QModelIndex)
FuzzyMatch = Prompt.FuzzyMatch
SimpleMatch = Prompt.SimpleMatch
def __init__(self, parent, window):
QLineEdit.__init__(self, parent)
self._completer_model = None
self._popup = Popup(window, self)
self.textEdited.connect(self._show_completions)
self._popup.installEventFilter(self)
self.installEventFilter(self)
self._eat_focusout = False
self._proxy_model = QSortFilterProxyModel(self)
self._proxy_model.setFilterKeyColumn(-1)
self._popup.setModel(self._proxy_model)
self._popup.activated.connect(self._on_completion_activated)
self._popup.selectionModel().currentRowChanged.connect(
self._on_row_changed)
self._right_italic_text = ""
self._mark = False
self.configure_completer({})
from ..keyboardhandler import LOCAL_KEYMAP_SETTER
LOCAL_KEYMAP_SETTER.register_minibuffer_input(self)
def configure_completer(self, opts):
self._popup._max_visible_items = opts.get("max-visible-items", 10)
self._match = opts.get("match", self.SimpleMatch)
self._autocomplete_single = opts.get("autocomplete-single", True)
self._autocomplete = opts.get("autocomplete", False)
if self._autocomplete:
self._autocomplete_single = False
self._complete_empty = opts.get("complete-empty", False)
def keymap(self):
prompt = self.parent()._prompt
if prompt and prompt.keymap:
return prompt.keymap
return KEYMAP
def eventFilter(self, obj, event):
etype = event.type()
if etype == QEvent.FocusOut and obj == self and self._eat_focusout \
and self._popup.isVisible():
# keep the focus on the line edit
return True
elif etype == QEvent.MouseButtonPress:
# if we've clicked in the widget (or its descendant), let it handle
# the click
pos = obj.mapToGlobal(event.pos())
target = QApplication.widgetAt(pos)
if target and (self.isAncestorOf(target) or target == self):
if not self._popup.underMouse():
self._popup.hide()
target.event(event)
return True
if not self._popup.underMouse():
self._popup.hide()
return True
elif etype in (QEvent.KeyPress, QEvent.KeyRelease):
# send event to the line edit
self._eat_focusout = True
self.event(event)
self._eat_focusout = False
return True
return QLineEdit.eventFilter(self, obj, event)
def set_completer_model(self, completer_model):
self._proxy_model.setSourceModel(completer_model)
def completer_model(self):
return self._proxy_model.sourceModel()
def set_match(self, type):
self._match = type
if self._popup.isVisible():
self._show_completions(self.text)
def _on_row_changed(self, current, old):
if self._autocomplete:
self.complete(hide_popup=False)
def _show_completions(self, txt, force=False):
force = force or self._complete_empty
if self._match == self.SimpleMatch:
pattern = "^" + QRegExp.escape(txt)
else:
pattern = ".*".join(QRegExp.escape(t) for t in txt.split())
self._proxy_model.setFilterRegExp(QRegExp(pattern, Qt.CaseInsensitive))
if self._proxy_model.rowCount() == 0:
self._popup.hide()
elif not txt and not force:
self._popup.hide()
else:
self._popup.popup()
def show_completions(self):
self._show_completions(self.text(), True)
def _on_completion_activated(self, index, hide_popup=True):
if hide_popup:
self._popup.hide()
model = index.model()
if index.column() != 0:
index = model.index(index.row(), 0)
self.setText(model.data(index))
self.completion_activated.emit(model.mapToSource(index))
def popup(self):
return self._popup
def complete(self, hide_popup=True):
if not self._popup.isVisible():
return
index = self._popup.selectionModel().currentIndex()
if index.isValid():
self._on_completion_activated(index, hide_popup=hide_popup)
elif self._autocomplete_single and self._proxy_model.rowCount() == 1:
self._on_completion_activated(self._proxy_model.index(0, 0),
hide_popup=hide_popup)
def select_next_completion(self, forward=True):
model = self._proxy_model
entries = model.rowCount()
if entries == 0:
return
selection = self._popup.selectionModel().currentIndex()
if not selection.isValid():
row = 0 if forward else (entries - 1)
else:
row = selection.row()
if forward:
row = row + 1
if row >= entries:
row = 0
else:
row = row - 1
if row < 0:
row = (entries - 1)
self._popup.selectRow(row)
def mark(self):
return self._mark
def set_mark(self, value=None):
if value is None:
value = not self._mark
self._mark = value
return self._mark
def reinit(self):
self.setText("")
self.setEchoMode(self.Normal)
self.setValidator(None)
self._right_italic_text = ""
def set_right_italic_text(self, text):
self._right_italic_text = text
self.update()
def paintEvent(self, event):
QLineEdit.paintEvent(self, event)
if not self._right_italic_text:
return
painter = QPainter(self)
font = painter.font()
font.setItalic(True)
painter.setFont(font)
painter.setRenderHint(QPainter.Antialiasing, True)
painter.drawText(self.rect().adjusted(0, 0, -10, 0), Qt.AlignRight,
self._right_italic_text)
class MasternodesWidget(QWidget):
"""Widget that displays masternodes."""
def __init__(self, manager, parent=None):
super(MasternodesWidget, self).__init__(parent)
self.manager = manager
self.model = MasternodesModel(self.manager)
self.proxy_model = QSortFilterProxyModel()
self.proxy_model.setSourceModel(self.model)
self.view = QTableView()
self.view.setModel(self.proxy_model)
for header in [self.view.horizontalHeader(), self.view.verticalHeader()]:
header.setHighlightSections(False)
header = self.view.horizontalHeader()
header.setSectionResizeMode(MasternodesModel.ALIAS, QHeaderView.ResizeToContents)
header.setSectionResizeMode(MasternodesModel.VIN, QHeaderView.Stretch)
header.setSectionResizeMode(MasternodesModel.COLLATERAL, QHeaderView.ResizeToContents)
header.setSectionResizeMode(MasternodesModel.DELEGATE, QHeaderView.ResizeToContents)
self.view.verticalHeader().setVisible(False)
self.view.setSelectionMode(QAbstractItemView.SingleSelection)
self.view.setSelectionBehavior(QAbstractItemView.SelectRows)
self.view.setSortingEnabled(True)
self.view.sortByColumn(self.model.ALIAS, Qt.AscendingOrder)
vbox = QVBoxLayout()
vbox.setContentsMargins(0, 0, 0, 0)
vbox.addWidget(self.view)
self.setLayout(vbox)
def select_masternode(self, alias):
"""Select the row that represents alias."""
self.view.clearSelection()
for i in range(self.proxy_model.rowCount()):
idx = self.proxy_model.index(i, 0)
mn_alias = str(self.proxy_model.data(idx))
if mn_alias == alias:
self.view.selectRow(i)
break
def populate_collateral_key(self, row):
"""Fill in the collateral key for a masternode based on its collateral output.
row refers to the desired row in the proxy model, not the actual model.
"""
mn = self.masternode_for_row(row)
self.manager.populate_masternode_output(mn.alias)
# Emit dataChanged for the collateral key.
index = self.model.index(row, self.model.COLLATERAL)
self.model.dataChanged.emit(index, index)
def refresh_items(self):
self.model.dataChanged.emit(QModelIndex(), QModelIndex())
def add_masternode(self, masternode, save = True):
self.model.add_masternode(masternode, save=save)
def remove_masternode(self, alias, save = True):
self.model.remove_masternode(alias, save=save)
def masternode_for_row(self, row):
idx = self.proxy_model.mapToSource(self.proxy_model.index(row, 0))
return self.model.masternode_for_row(idx.row())
def import_masternode_conf_lines(self, conf_lines, pw):
return self.model.import_masternode_conf_lines(conf_lines, pw)
class MainWindow(QMainWindow):
def __init__(self):
super().__init__()
self.filename = None
self.data_changed = False
self.file_data = None
self.open_file_dir = os.path.expanduser('~')
self.ui = loadUi('gui/MainWindow.ui', self)
self.ui.action_Open.triggered.connect(self.menu_open)
self.ui.action_Save.triggered.connect(self.menu_save)
self.ui.action_Close.triggered.connect(self.menu_close)
self.ui.action_Exit.triggered.connect(qApp.quit)
self.ui.action_ShowMap.triggered.connect(self.show_map)
self.ui.action_BoltChecker.triggered.connect(self.show_boltchecker)
self.datamodel = QSortFilterProxyModel()
self.datamodel.setFilterCaseSensitivity(Qt.CaseInsensitive)
self.datamodel.setSortCaseSensitivity(Qt.CaseInsensitive)
self.ui.treeView.setSortingEnabled(False)
self.ui.treeView.setModel(self.datamodel)
self.ui.treeView.setSortingEnabled(True)
self.ui.treeView.doubleClicked.connect(self.treeView_doubleClicked)
self.ui.treeView.selectionModel().selectionChanged.connect(
self.treeView_selectionChanged)
self.ui.searchField.textChanged.connect(self.searchField_textChanged)
def menu_open(self):
fname = QFileDialog.getOpenFileName(self, 'Open file',
self.open_file_dir)
if fname[0]:
self.open_file(fname[0])
def open_file(self, filename):
self.filename = filename
self.open_file_dir = os.path.dirname(self.filename)
with open(filename, 'rb') as f:
reader = ES2Reader(f)
self.file_data = reader.read_all()
self.update_tree(self.file_data)
self.set_changed(False)
self.ui.action_Close.setEnabled(True)
def set_changed(self, changed=True):
self.data_changed = changed
self.ui.action_Save.setEnabled(self.data_changed)
def menu_save(self):
for i in range(100):
backup_filename = '{}.{}'.format(self.filename, i)
if not os.path.exists(backup_filename):
shutil.copy2(self.filename, backup_filename)
break
else:
raise Exception('Too many backups!')
with open(self.filename, 'wb') as f:
writer = ES2Writer(f)
for k, v in self.file_data.items():
writer.save(k, v)
writer.save_all()
self.set_changed(False)
def menu_close(self):
self.ui.action_Save.setEnabled(False)
self.ui.action_Close.setEnabled(False)
self.filename = None
self.file_data = None
self.update_tree(None)
def update_tree(self, file_data=None):
self.datamodel.setSourceModel(TreeModel(file_data))
self.ui.treeView.sortByColumn(0, Qt.AscendingOrder)
self.ui.treeView.resizeColumnToContents(0)
def treeView_selectionChanged(self):
pass
# indexes = self.ui.treeView.selectionModel().selection().indexes()
# if len(indexes) > 0:
# index = indexes[0]
# tag = self.datamodel.data(index)
# print('selectionChanged')
# print(self.file_data[item].header.value_type)
# print(self.file_data[item].value)
def treeView_doubleClicked(self):
index = self.ui.treeView.selectionModel().selection().indexes()[0]
self.edit_index(index)
def edit_index(self, index):
tag = index.data()
dialog = EditDialog(tag, self.file_data[tag], self)
result = dialog.exec_()
if result == QDialog.Accepted:
dialog_result = dialog.get_value()
if self.file_data[tag].value == dialog_result:
return
self.set_changed()
self.file_data[tag].value = dialog_result
value_index = self.datamodel.index(index.row(), 2)
self.datamodel.setData(value_index, dialog_result)
def searchField_textChanged(self, text):
self.datamodel.setFilterWildcard(text)
def show_map(self):
dialog = MapViewDialog(self.file_data, self)
dialog.exec_()
def show_boltchecker(self):
dialog = BoltCheckerDialog(self.file_data, self)
dialog.exec_()
class FileChooser(BaseFileChooser):
def __init__(self, **kwargs):
super(FileChooser, self).__init__(**kwargs)
self.options = PropDict()
self.edit.textEdited.connect(self._onTextEdited)
self.view.activated.connect(self._onActivated)
# models
self.rootChanger = RootChangerProxy()
fsModel = QFileSystemModel(self)
self.setModel(fsModel)
self.filter = QSortFilterProxyModel()
self.filter.setSourceModel(self.rootChanger)
self.view.setModel(self.filter)
def setModel(self, model):
self.baseModel = model
self.rootChanger.setSourceModel(self.baseModel)
@Slot(str)
def setRoot(self, path):
self.root = path
srcIdx = self.baseModel.setRootPath(path)
self.rootChanger.setRootSource(srcIdx)
self.view.setRootIndex(QModelIndex())
@Slot(str)
def _onTextEdited(self, txt):
elems = txt.rsplit('/', 1)
if len(elems) == 2:
dir, base = elems
else:
dir, base = '', elems[0]
path = os.path.join(self.root, dir)
self.rootChanger.setRootSource(self.baseModel.index(path))
self.filter.setFilterRegExp(QRegExp(base, Qt.CaseInsensitive, QRegExp.Wildcard))
if self.options.get('autosuggest'):
names = [self.filter.data(self.filter.index(i, 0)).toString()
for i in range(self.filter.rowCount(QModelIndex()))]
names = [n[len(base):] for n in names]
add = commonPrefix(names)
cursor = self.edit.cursorPosition()
self.edit.setText(self.edit.text()[:cursor] + add)
self.edit.setSelection(cursor, len(self.edit.text()))
@Slot(QModelIndex)
def _onActivated(self, idx):
idx = self.filter.mapToSource(idx)
idx = self.rootChanger.mapToSource(idx)
info = self.baseModel.fileInfo(idx)
if info.isDir():
return
path = info.absoluteFilePath()
self.openFile(path)
class AllBooksView(QWidget):
def __init__(self, parent):
super().__init__(parent)
self.ui = Ui_allBooks_window()
self.ui.setupUi(self)
self.labels = ['Id', 'Title', 'ISBN', 'Author', 'Genre', 'Status']
self.ui.allBooks_tableView.clicked.connect(self.book_details)
self.show()
"""def createRangeSlider(self):
slider = QLabeledRangeSlider(Qt.Horizontal)
self.ui.verticalLayout_2.addWidget(slider)
slider.setHandleLabelPosition(QLabeledRangeSlider.LabelPosition.LabelsAbove)
return slider
def updateValues(self):
books = book_session.query(Book).all()
minPages, maxPages = books[0].pages, books[0].pages
for i in range(1, len(books)):
book = books[i]
if book.pages < minPages: minPages = book.pages
if book.pages > maxPages: maxPages = book.pages
self.pagesSlider.setMaximum(maxPages)
self.pagesSlider.setMinimum(minPages)
self.pagesSlider.setValue((minPages + (maxPages - minPages) / 5, maxPages - (maxPages - minPages) / 5))
self.yearSlider.setMaximum(ACTUAL_YEAR)
self.yearSlider.setMinimum(FIRST_YEAR_BOOK)
self.yearSlider.setValue((FIRST_YEAR_BOOK + (ACTUAL_YEAR - FIRST_YEAR_BOOK) / 5, ACTUAL_YEAR - (ACTUAL_YEAR - FIRST_YEAR_BOOK) / 5))"""
def loadData(self):
results = book_session.query(
Book, Author, Genre, BookStatus).select_from(Book).join(
Author).join(Genre).join(BookStatus).all()
self.model = QStandardItemModel(len(results), len(self.labels))
self.model.setHorizontalHeaderLabels(self.labels)
self.filter_proxy_model = QSortFilterProxyModel()
self.filter_proxy_model.setFilterKeyColumn(
-1) # LETTURA DA TUTTE LE COLONNE
self.filter_proxy_model.setSourceModel(self.model)
for row, (book, author, genre, status) in enumerate(results):
book_id = QStandardItem(str(book.id))
book_id.setTextAlignment(Qt.AlignCenter)
book_title = QStandardItem(book.title)
book_title.setTextAlignment(Qt.AlignCenter)
book_isbn = QStandardItem(book.isbn)
book_isbn.setTextAlignment(Qt.AlignCenter)
authorI = QStandardItem(author.name + " " + author.surname)
authorI.setTextAlignment(Qt.AlignCenter)
genreI = QStandardItem(genre.name)
genreI.setTextAlignment(Qt.AlignCenter)
status = QStandardItem(status.name)
status.setTextAlignment(Qt.AlignCenter)
status.setForeground(QBrush(getColorStatus(book.status_id, book)))
self.model.setItem(row, 0, book_id)
self.model.setItem(row, 1, book_title)
self.model.setItem(row, 2, book_isbn)
self.model.setItem(row, 3, authorI)
self.model.setItem(row, 4, genreI)
self.model.setItem(row, 5, status)
self.ui.allBooks_tableView.setModel(self.filter_proxy_model)
self.ui.allBooks_tableView.setColumnHidden(0, True)
self.ui.searchBook_lineEdit.textChanged.connect(
self.filter_proxy_model.setFilterRegExp)
def book_details(self):
row = self.ui.allBooks_tableView.selectionModel().selectedRows(
)[0].row()
id = self.filter_proxy_model.index(row, 0).data()
result = book_session.query(
Book, Author, Genre, BookStatus).select_from(Book).filter_by(
id=id).join(Author).join(Genre).join(BookStatus).first()
print(result)
book, author, genre, status = result
print(book.id, author.id, genre.id, status.id)
book_view = self.parent().findChild(QWidget, 'book_window')
book_view.updateValues(book, author, genre, status)
self.parent().setCurrentWidget(book_view)
class FileChooser(BaseFileChooser):
def __init__(self, **kwargs):
super(FileChooser, self).__init__(**kwargs)
self.options = PropDict()
self.edit.textEdited.connect(self._onTextEdited)
self.view.activated.connect(self._onActivated)
# models
self.rootChanger = RootChangerProxy()
fsModel = QFileSystemModel(self)
self.setModel(fsModel)
self.filter = QSortFilterProxyModel()
self.filter.setSourceModel(self.rootChanger)
self.view.setModel(self.filter)
def setModel(self, model):
self.baseModel = model
self.rootChanger.setSourceModel(self.baseModel)
@Slot(str)
def setRoot(self, path):
self.root = path
srcIdx = self.baseModel.setRootPath(path)
self.rootChanger.setRootSource(srcIdx)
self.view.setRootIndex(QModelIndex())
@Slot(str)
def _onTextEdited(self, txt):
elems = txt.rsplit('/', 1)
if len(elems) == 2:
dir, base = elems
else:
dir, base = '', elems[0]
path = os.path.join(self.root, dir)
self.rootChanger.setRootSource(self.baseModel.index(path))
self.filter.setFilterRegExp(QRegExp(base, Qt.CaseInsensitive, QRegExp.Wildcard))
if self.options.get('autosuggest'):
names = [self.filter.data(self.filter.index(i, 0)).toString()
for i in range(self.filter.rowCount(QModelIndex()))]
names = [n[len(base):] for n in names]
add = commonPrefix(names)
cursor = self.edit.cursorPosition()
self.edit.setText(self.edit.text()[:cursor] + add)
self.edit.setSelection(cursor, len(self.edit.text()))
@Slot(QModelIndex)
def _onActivated(self, idx):
idx = self.filter.mapToSource(idx)
idx = self.rootChanger.mapToSource(idx)
info = self.baseModel.fileInfo(idx)
if info.isDir():
return
path = info.absoluteFilePath()
self.openFile(path)
