class XDFStreamsDialog(QDialog):
def __init__(self, parent, rows, selected=None, disabled=None):
super().__init__(parent)
self.setWindowTitle("Select XDF Stream")
self.model = QStandardItemModel()
self.model.setHorizontalHeaderLabels(
["ID", "Name", "Type", "Channels", "Format", "Sampling Rate"])
for index, stream in enumerate(rows):
items = []
for item in stream:
tmp = QStandardItem()
tmp.setData(item, Qt.DisplayRole)
items.append(tmp)
for item in items:
item.setEditable(False)
if disabled is not None and index in disabled:
item.setFlags(Qt.NoItemFlags)
self.model.appendRow(items)
self.view = QTableView()
self.view.setModel(self.model)
self.view.verticalHeader().setVisible(False)
self.view.horizontalHeader().setStretchLastSection(True)
self.view.setShowGrid(False)
self.view.setSelectionMode(QAbstractItemView.SingleSelection)
self.view.setSelectionBehavior(QAbstractItemView.SelectRows)
if selected is not None:
self.view.selectRow(selected)
self.view.setSortingEnabled(True)
self.view.sortByColumn(0, Qt.AscendingOrder)
vbox = QVBoxLayout(self)
vbox.addWidget(self.view)
self.buttonbox = QDialogButtonBox(QDialogButtonBox.Ok
| QDialogButtonBox.Cancel)
vbox.addWidget(self.buttonbox)
self.buttonbox.accepted.connect(self.accept)
self.buttonbox.rejected.connect(self.reject)
self.resize(775, 650)
self.view.setColumnWidth(0, 100)
self.view.setColumnWidth(1, 200)
self.view.setColumnWidth(2, 120)
class ChannelPropertiesDialog(QDialog):
def __init__(self, parent, info, title="Channel Properties"):
super().__init__(parent)
self.setWindowTitle(title)
self.model = QStandardItemModel(info["nchan"], 4)
self.model.setHorizontalHeaderLabels(["#", "Label", "Type", "Bad"])
for index, ch in enumerate(info["chs"]):
item = QStandardItem()
item.setData(index, Qt.DisplayRole)
item.setFlags(item.flags() & ~Qt.ItemIsEditable)
self.model.setItem(index, 0, item)
self.model.setItem(index, 1, QStandardItem(ch["ch_name"]))
kind = channel_type(info, index).upper()
self.model.setItem(index, 2, QStandardItem(str(kind)))
bad = QStandardItem()
bad.setData(ch["ch_name"] in info["bads"], Qt.UserRole)
bad.setCheckable(True)
bad.setEditable(False)
checked = ch["ch_name"] in info["bads"]
bad.setCheckState(Qt.Checked if checked else Qt.Unchecked)
self.model.setItem(index, 3, bad)
self.model.itemChanged.connect(bad_changed)
self.proxymodel = MySortFilterProxyModel()
self.proxymodel.setDynamicSortFilter(False)
self.proxymodel.setSourceModel(self.model)
self.view = QTableView()
self.view.setModel(self.proxymodel)
self.view.setItemDelegateForColumn(2, ComboBoxDelegate(self.view))
self.view.setEditTriggers(QAbstractItemView.AllEditTriggers)
self.view.verticalHeader().setVisible(False)
self.view.horizontalHeader().setStretchLastSection(True)
self.view.setShowGrid(False)
self.view.setSelectionMode(QAbstractItemView.NoSelection)
self.view.setSortingEnabled(True)
self.view.sortByColumn(0, Qt.AscendingOrder)
vbox = QVBoxLayout(self)
vbox.addWidget(self.view)
self.buttonbox = QDialogButtonBox(QDialogButtonBox.Ok
| QDialogButtonBox.Cancel)
vbox.addWidget(self.buttonbox)
self.buttonbox.accepted.connect(self.accept)
self.buttonbox.rejected.connect(self.reject)
self.resize(475, 650)
self.view.setColumnWidth(0, 70)
self.view.setColumnWidth(1, 155)
self.view.setColumnWidth(2, 90)
class MxDataWidget(QWidget):
"""
Dialog for displaying and editing DataFrame and related objects.
Based on the gtabview project (ExtTableView).
For more information please see:
https://github.com/wavexx/gtabview/blob/master/gtabview/viewer.py
Signals
-------
sig_option_changed(str, object): Raised if an option is changed.
Arguments are name of option and its new value.
"""
sig_option_changed = Signal(str, object)
def __init__(self, parent=None, data=DataFrame()):
QWidget.__init__(self, parent)
# Destroying the C++ object right after closing the dialog box,
# otherwise it may be garbage-collected in another QThread
# (e.g. the editor's analysis thread in Spyder), thus leading to
# a segmentation fault on UNIX or an application crash on Windows
self.setAttribute(Qt.WA_DeleteOnClose)
self.is_series = False
self.layout = None
self.setup_and_check(data)
def setup_and_check(self, data, title=''):
"""
Setup DataFrameEditor:
return False if data is not supported, True otherwise.
Supported types for data are DataFrame, Series and Index.
"""
self._selection_rec = False
self._model = None
self.layout = QGridLayout()
self.layout.setSpacing(0)
self.layout.setContentsMargins(0, 0, 0, 0)
self.setLayout(self.layout)
self.setWindowIcon(ima.icon('arredit'))
if title:
title = to_text_string(title) + " - %s" % data.__class__.__name__
else:
title = _("%s editor") % data.__class__.__name__
if isinstance(data, Series):
self.is_series = True
data = data.to_frame()
elif isinstance(data, Index):
data = DataFrame(data)
self.setWindowTitle(title)
# self.resize(600, 500)
self.hscroll = QScrollBar(Qt.Horizontal)
self.vscroll = QScrollBar(Qt.Vertical)
# Create the view for the level
self.create_table_level()
# Create the view for the horizontal header
self.create_table_header()
# Create the view for the vertical index
self.create_table_index()
# Create the model and view of the data
self.dataModel = MxDataModel(data, parent=self)
# self.dataModel.dataChanged.connect(self.save_and_close_enable)
self.create_data_table()
self.layout.addWidget(self.hscroll, 2, 0, 1, 2)
self.layout.addWidget(self.vscroll, 0, 2, 2, 1)
# autosize columns on-demand
self._autosized_cols = set()
self._max_autosize_ms = None
self.dataTable.installEventFilter(self)
avg_width = self.fontMetrics().averageCharWidth()
self.min_trunc = avg_width * 8 # Minimum size for columns
self.max_width = avg_width * 64 # Maximum size for columns
self.setLayout(self.layout)
# Make the dialog act as a window
# self.setWindowFlags(Qt.Window)
self.setModel(self.dataModel)
self.resizeColumnsToContents()
return True
def create_table_level(self):
"""Create the QTableView that will hold the level model."""
self.table_level = QTableView()
self.table_level.setEditTriggers(QTableWidget.NoEditTriggers)
self.table_level.setHorizontalScrollBarPolicy(Qt.ScrollBarAlwaysOff)
self.table_level.setVerticalScrollBarPolicy(Qt.ScrollBarAlwaysOff)
self.table_level.setFrameStyle(QFrame.Plain)
self.table_level.horizontalHeader().sectionResized.connect(
self._index_resized)
self.table_level.verticalHeader().sectionResized.connect(
self._header_resized)
# self.table_level.setItemDelegate(QItemDelegate())
self.layout.addWidget(self.table_level, 0, 0)
self.table_level.setContentsMargins(0, 0, 0, 0)
self.table_level.horizontalHeader().sectionClicked.connect(
self.sortByIndex)
def create_table_header(self):
"""Create the QTableView that will hold the header model."""
self.table_header = QTableView()
self.table_header.verticalHeader().hide()
self.table_header.setEditTriggers(QTableWidget.NoEditTriggers)
self.table_header.setHorizontalScrollBarPolicy(Qt.ScrollBarAlwaysOff)
self.table_header.setVerticalScrollBarPolicy(Qt.ScrollBarAlwaysOff)
self.table_header.setHorizontalScrollMode(QTableView.ScrollPerPixel)
self.table_header.setHorizontalScrollBar(self.hscroll)
self.table_header.setFrameStyle(QFrame.Plain)
self.table_header.horizontalHeader().sectionResized.connect(
self._column_resized)
# self.table_header.setItemDelegate(QItemDelegate())
self.layout.addWidget(self.table_header, 0, 1)
def create_table_index(self):
"""Create the QTableView that will hold the index model."""
self.table_index = QTableView()
self.table_index.horizontalHeader().hide()
self.table_index.setEditTriggers(QTableWidget.NoEditTriggers)
self.table_index.setHorizontalScrollBarPolicy(Qt.ScrollBarAlwaysOff)
self.table_index.setVerticalScrollBarPolicy(Qt.ScrollBarAlwaysOff)
self.table_index.setVerticalScrollMode(QTableView.ScrollPerPixel)
self.table_index.setVerticalScrollBar(self.vscroll)
self.table_index.setFrameStyle(QFrame.Plain)
self.table_index.verticalHeader().sectionResized.connect(
self._row_resized)
# self.table_index.setItemDelegate(QItemDelegate())
self.layout.addWidget(self.table_index, 1, 0)
self.table_index.setContentsMargins(0, 0, 0, 0)
def create_data_table(self):
"""Create the QTableView that will hold the data model."""
self.dataTable = MxDataTable(self, self.dataModel,
self.table_header.horizontalHeader(),
self.hscroll, self.vscroll)
self.dataTable.verticalHeader().hide()
self.dataTable.horizontalHeader().hide()
self.dataTable.setHorizontalScrollBarPolicy(Qt.ScrollBarAlwaysOff)
self.dataTable.setVerticalScrollBarPolicy(Qt.ScrollBarAlwaysOff)
self.dataTable.setHorizontalScrollMode(QTableView.ScrollPerPixel)
self.dataTable.setVerticalScrollMode(QTableView.ScrollPerPixel)
self.dataTable.setFrameStyle(QFrame.Plain)
# self.dataTable.setItemDelegate(QItemDelegate())
self.layout.addWidget(self.dataTable, 1, 1)
self.setFocusProxy(self.dataTable)
self.dataTable.sig_sort_by_column.connect(self._sort_update)
self.dataTable.sig_fetch_more_columns.connect(self._fetch_more_columns)
self.dataTable.sig_fetch_more_rows.connect(self._fetch_more_rows)
def sortByIndex(self, index):
"""Implement a Index sort."""
self.table_level.horizontalHeader().setSortIndicatorShown(True)
sort_order = self.table_level.horizontalHeader().sortIndicatorOrder()
self.table_index.model().sort(index, sort_order)
self._sort_update()
def model(self):
"""Get the model of the dataframe."""
return self._model
def _column_resized(self, col, old_width, new_width):
"""Update the column width."""
self.dataTable.setColumnWidth(col, new_width)
self._update_layout()
def _row_resized(self, row, old_height, new_height):
"""Update the row height."""
self.dataTable.setRowHeight(row, new_height)
self._update_layout()
def _index_resized(self, col, old_width, new_width):
"""Resize the corresponding column of the index section selected."""
self.table_index.setColumnWidth(col, new_width)
self._update_layout()
def _header_resized(self, row, old_height, new_height):
"""Resize the corresponding row of the header section selected."""
self.table_header.setRowHeight(row, new_height)
self._update_layout()
def _update_layout(self):
"""Set the width and height of the QTableViews and hide rows."""
h_width = max(self.table_level.verticalHeader().sizeHint().width(),
self.table_index.verticalHeader().sizeHint().width())
self.table_level.verticalHeader().setFixedWidth(h_width)
self.table_index.verticalHeader().setFixedWidth(h_width)
last_row = self._model.header_shape[0] - 1
if last_row < 0:
hdr_height = self.table_level.horizontalHeader().height()
else:
# Check if the header shape has only one row (which display the
# same info than the horizontal header).
if last_row == 0:
self.table_level.setRowHidden(0, True)
self.table_header.setRowHidden(0, True)
else:
self.table_level.setRowHidden(0, False)
self.table_header.setRowHidden(0, False)
hdr_height = self.table_level.rowViewportPosition(last_row) + \
self.table_level.rowHeight(last_row) + \
self.table_level.horizontalHeader().height()
self.table_header.setFixedHeight(hdr_height)
self.table_level.setFixedHeight(hdr_height)
last_col = self._model.header_shape[1] - 1
if last_col < 0:
idx_width = self.table_level.verticalHeader().width()
else:
idx_width = self.table_level.columnViewportPosition(last_col) + \
self.table_level.columnWidth(last_col) + \
self.table_level.verticalHeader().width()
self.table_index.setFixedWidth(idx_width)
self.table_level.setFixedWidth(idx_width)
self._resizeVisibleColumnsToContents()
def _reset_model(self, table, model):
"""Set the model in the given table."""
old_sel_model = table.selectionModel()
table.setModel(model)
if old_sel_model:
del old_sel_model
def setAutosizeLimit(self, limit_ms):
"""Set maximum size for columns."""
self._max_autosize_ms = limit_ms
def setModel(self, model, relayout=True):
"""Set the model for the data, header/index and level views."""
self._model = model
# sel_model = self.dataTable.selectionModel()
# sel_model.currentColumnChanged.connect(
# self._resizeCurrentColumnToContents)
self._reset_model(self.dataTable, model)
# Asociate the models (level, vertical index and horizontal header)
# with its corresponding view.
self._reset_model(
self.table_level,
DataFrameLevelModel(model, self.palette(), self.font()))
self._reset_model(self.table_header,
DataFrameHeaderModel(model, 0, self.palette()))
self._reset_model(self.table_index,
DataFrameHeaderModel(model, 1, self.palette()))
# Needs to be called after setting all table models
if relayout:
self._update_layout()
def setCurrentIndex(self, y, x):
"""Set current selection."""
self.dataTable.selectionModel().setCurrentIndex(
self.dataTable.model().index(y, x),
QItemSelectionModel.ClearAndSelect)
def _sizeHintForColumn(self, table, col, limit_ms=None):
"""Get the size hint for a given column in a table."""
max_row = table.model().rowCount()
lm_start = time.perf_counter()
lm_row = 64 if limit_ms else max_row
max_width = 0
for row in range(max_row):
v = table.sizeHintForIndex(table.model().index(row, col))
max_width = max(max_width, v.width())
if row > lm_row:
lm_now = time.perf_counter()
lm_elapsed = (lm_now - lm_start) * 1000
if lm_elapsed >= limit_ms:
break
lm_row = int((row / lm_elapsed) * limit_ms)
return max_width
def _resizeColumnToContents(self, header, data, col, limit_ms):
"""Resize a column by its contents."""
hdr_width = self._sizeHintForColumn(header, col, limit_ms)
data_width = self._sizeHintForColumn(data, col, limit_ms)
if data_width > hdr_width:
width = min(self.max_width, data_width)
elif hdr_width > data_width * 2:
width = max(min(hdr_width, self.min_trunc),
min(self.max_width, data_width))
else:
width = min(self.max_width, hdr_width)
header.setColumnWidth(col, width)
def _resizeColumnsToContents(self, header, data, limit_ms):
"""Resize all the colummns to its contents."""
max_col = data.model().columnCount()
if limit_ms is None:
max_col_ms = None
else:
max_col_ms = limit_ms / max(1, max_col)
for col in range(max_col):
self._resizeColumnToContents(header, data, col, max_col_ms)
def eventFilter(self, obj, event):
"""Override eventFilter to catch resize event."""
if obj == self.dataTable and event.type() == QEvent.Resize:
self._resizeVisibleColumnsToContents()
return False
def _resizeVisibleColumnsToContents(self):
"""Resize the columns that are in the view."""
index_column = self.dataTable.rect().topLeft().x()
start = col = self.dataTable.columnAt(index_column)
width = self._model.shape[1]
end = self.dataTable.columnAt(self.dataTable.rect().bottomRight().x())
end = width if end == -1 else end + 1
if self._max_autosize_ms is None:
max_col_ms = None
else:
max_col_ms = self._max_autosize_ms / max(1, end - start)
while col < end:
resized = False
if col not in self._autosized_cols:
self._autosized_cols.add(col)
resized = True
self._resizeColumnToContents(self.table_header, self.dataTable,
col, max_col_ms)
col += 1
if resized:
# As we resize columns, the boundary will change
index_column = self.dataTable.rect().bottomRight().x()
end = self.dataTable.columnAt(index_column)
end = width if end == -1 else end + 1
if max_col_ms is not None:
max_col_ms = self._max_autosize_ms / max(1, end - start)
def _resizeCurrentColumnToContents(self, new_index, old_index):
"""Resize the current column to its contents."""
if new_index.column() not in self._autosized_cols:
# Ensure the requested column is fully into view after resizing
self._resizeVisibleColumnsToContents()
self.dataTable.scrollTo(new_index)
def resizeColumnsToContents(self):
"""Resize the columns to its contents."""
self._autosized_cols = set()
self._resizeColumnsToContents(self.table_level, self.table_index,
self._max_autosize_ms)
self._update_layout()
self.table_level.resizeColumnsToContents()
def change_format(self):
"""
Ask user for display format for floats and use it.
This function also checks whether the format is valid and emits
`sig_option_changed`.
"""
format, valid = QInputDialog.getText(self, _('Format'),
_("Float formatting"),
QLineEdit.Normal,
self.dataModel.get_format())
if valid:
format = str(format)
try:
format % 1.1
except:
msg = _("Format ({}) is incorrect").format(format)
QMessageBox.critical(self, _("Error"), msg)
return
if not format.startswith('%'):
msg = _("Format ({}) should start with '%'").format(format)
QMessageBox.critical(self, _("Error"), msg)
return
self.dataModel.set_format(format)
self.sig_option_changed.emit('dataframe_format', format)
def get_value(self):
"""Return modified Dataframe -- this is *not* a copy"""
# It is import to avoid accessing Qt C++ object as it has probably
# already been destroyed, due to the Qt.WA_DeleteOnClose attribute
df = self.dataModel.get_data()
if self.is_series:
return df.iloc[:, 0]
else:
return df
def _update_header_size(self):
"""Update the column width of the header."""
column_count = self.table_header.model().columnCount()
for index in range(0, column_count):
if index < column_count:
column_width = self.dataTable.columnWidth(index)
self.table_header.setColumnWidth(index, column_width)
else:
break
def _sort_update(self):
"""
Update the model for all the QTableView objects.
Uses the model of the dataTable as the base.
"""
self.setModel(self.dataTable.model())
def _fetch_more_columns(self):
"""Fetch more data for the header (columns)."""
self.table_header.model().fetch_more()
def _fetch_more_rows(self):
"""Fetch more data for the index (rows)."""
self.table_index.model().fetch_more()
def resize_to_contents(self):
QApplication.setOverrideCursor(QCursor(Qt.WaitCursor))
self.dataTable.resizeColumnsToContents()
self.dataModel.fetch_more(columns=True)
self.dataTable.resizeColumnsToContents()
self._update_header_size()
QApplication.restoreOverrideCursor()
# --- mx specific ---
def process_remote_view(self, data):
if data is None:
data = DataFrame() # Empty DataFrame
self.setModel(MxDataModel(data, parent=self))
class DownloadBibleMp3Dialog(QDialog):
def __init__(self, parent):
super().__init__()
self.bibles = {
"BBE (British accent)":
("BBE", "otseng/UniqueBible_MP3_BBE_british", "british"),
"KJV (American accent)":
("KJV", "otseng/UniqueBible_MP3_KJV", "default"),
"KJV (American soft music)":
("KJV", "otseng/UniqueBible_MP3_KJV_soft_music", "soft-music"),
"NHEB (Indian accent)":
("NHEB", "otseng/UniqueBible_MP3_NHEB_indian", "indian"),
"WEB (American accent)": ("WEB", "otseng/UniqueBible_MP3_WEB",
"default"),
"CUV (Chinese)": ("CUV", "otseng/UniqueBible_MP3_CUV", "default"),
"HHBD (Hindi)": ("HHBD", "otseng/UniqueBible_MP3_HHBD", "default"),
"RVA (Spanish)": ("RVA", "otseng/UniqueBible_MP3_RVA", "default"),
"TR (Modern Greek)": ("TR", "otseng/UniqueBible_MP3_TR", "modern"),
}
self.parent = parent
self.setWindowTitle(config.thisTranslation["gitHubBibleMp3Files"])
self.setMinimumSize(150, 450)
self.selectedRendition = None
self.selectedText = None
self.selectedRepo = None
self.selectedDirectory = None
self.settingBibles = False
self.thread = None
self.setupUI()
def setupUI(self):
mainLayout = QVBoxLayout()
title = QLabel(config.thisTranslation["gitHubBibleMp3Files"])
mainLayout.addWidget(title)
self.versionsLayout = QVBoxLayout()
self.renditionsList = QListWidget()
self.renditionsList.itemClicked.connect(self.selectItem)
for rendition in self.bibles.keys():
self.renditionsList.addItem(rendition)
self.renditionsList.setMaximumHeight(100)
self.versionsLayout.addWidget(self.renditionsList)
mainLayout.addLayout(self.versionsLayout)
self.downloadTable = QTableView()
self.downloadTable.setEnabled(False)
self.downloadTable.setFocusPolicy(Qt.StrongFocus)
self.downloadTable.setEditTriggers(QAbstractItemView.NoEditTriggers)
self.downloadTable.setSortingEnabled(True)
self.dataViewModel = QStandardItemModel(self.downloadTable)
self.downloadTable.setModel(self.dataViewModel)
mainLayout.addWidget(self.downloadTable)
buttonsLayout = QHBoxLayout()
selectAllButton = QPushButton(config.thisTranslation["selectAll"])
selectAllButton.setFocusPolicy(Qt.StrongFocus)
selectAllButton.clicked.connect(self.selectAll)
buttonsLayout.addWidget(selectAllButton)
selectNoneButton = QPushButton(config.thisTranslation["selectNone"])
selectNoneButton.setFocusPolicy(Qt.StrongFocus)
selectNoneButton.clicked.connect(self.selectNone)
buttonsLayout.addWidget(selectNoneButton)
otButton = QPushButton("1-39")
otButton.setFocusPolicy(Qt.StrongFocus)
otButton.clicked.connect(self.selectOT)
buttonsLayout.addWidget(otButton)
ntButton = QPushButton("40-66")
ntButton.setFocusPolicy(Qt.StrongFocus)
ntButton.clicked.connect(self.selectNT)
buttonsLayout.addWidget(ntButton)
# buttonsLayout.addStretch()
mainLayout.addLayout(buttonsLayout)
self.downloadButton = QPushButton(config.thisTranslation["download"])
self.downloadButton.setFocusPolicy(Qt.StrongFocus)
self.downloadButton.setAutoDefault(True)
self.downloadButton.setFocus()
self.downloadButton.clicked.connect(self.download)
mainLayout.addWidget(self.downloadButton)
self.status = QLabel("")
mainLayout.addWidget(self.status)
buttonLayout = QHBoxLayout()
self.closeButton = QPushButton(config.thisTranslation["close"])
self.closeButton.setFocusPolicy(Qt.StrongFocus)
self.closeButton.clicked.connect(self.closeDialog)
buttonLayout.addWidget(self.closeButton)
mainLayout.addLayout(buttonLayout)
self.setLayout(mainLayout)
self.renditionsList.item(0).setSelected(True)
bible = self.renditionsList.item(0).text()
self.selectRendition(bible)
self.downloadButton.setDefault(True)
QTimer.singleShot(0, self.downloadButton.setFocus)
def selectItem(self, item):
self.selectRendition(item.text())
def selectRendition(self, rendition):
from util.GithubUtil import GithubUtil
self.selectedRendition = rendition
self.downloadTable.setEnabled(True)
self.selectedText, self.selectedRepo, self.selectedDirectory = self.bibles[
self.selectedRendition]
self.github = GithubUtil(self.selectedRepo)
self.repoData = self.github.getRepoData()
self.settingBibles = True
self.dataViewModel.clear()
rowCount = 0
for file in self.repoData.keys():
if len(str(file)) > 3:
engFullBookName = file[3:]
else:
engFullBookName = BibleBooks().eng[str(int(file))][1]
item = QStandardItem(file[:3].strip())
folder = os.path.join("audio", "bibles", self.selectedText,
self.selectedDirectory, file)
folderWithName = os.path.join("audio", "bibles", self.selectedText,
self.selectedDirectory,
file + " " + engFullBookName)
if os.path.exists(folder) or os.path.exists(folderWithName):
item.setCheckable(False)
item.setCheckState(Qt.Unchecked)
item.setEnabled(False)
else:
item.setCheckable(True)
item.setCheckState(Qt.Checked)
item.setEnabled(True)
self.dataViewModel.setItem(rowCount, 0, item)
item = QStandardItem(engFullBookName)
self.dataViewModel.setItem(rowCount, 1, item)
if os.path.exists(folder) or os.path.exists(folderWithName):
item = QStandardItem("Installed")
self.dataViewModel.setItem(rowCount, 2, item)
else:
item = QStandardItem("")
self.dataViewModel.setItem(rowCount, 2, item)
rowCount += 1
self.dataViewModel.setHorizontalHeaderLabels([
config.thisTranslation["menu_book"],
config.thisTranslation["name"], ""
])
self.downloadTable.setColumnWidth(0, 90)
self.downloadTable.setColumnWidth(1, 125)
self.downloadTable.setColumnWidth(2, 125)
# self.downloadTable.resizeColumnsToContents()
self.settingBibles = False
def selectAll(self):
for index in range(self.dataViewModel.rowCount()):
item = self.dataViewModel.item(index)
if item.isEnabled():
item.setCheckState(Qt.Checked)
def selectNone(self):
for index in range(self.dataViewModel.rowCount()):
item = self.dataViewModel.item(index)
item.setCheckState(Qt.Unchecked)
def selectOT(self):
for index in range(self.dataViewModel.rowCount()):
item = self.dataViewModel.item(index)
bookNum = int(item.text())
if bookNum <= 39:
if item.isEnabled():
item.setCheckState(Qt.Checked)
else:
item.setCheckState(Qt.Unchecked)
else:
item.setCheckState(Qt.Unchecked)
def selectNT(self):
for index in range(self.dataViewModel.rowCount()):
item = self.dataViewModel.item(index)
bookNum = int(item.text())
if bookNum >= 40:
if item.isEnabled():
item.setCheckState(Qt.Checked)
else:
item.setCheckState(Qt.Unchecked)
else:
item.setCheckState(Qt.Unchecked)
def download(self):
self.downloadButton.setEnabled(False)
self.setStatus(config.thisTranslation["message_installing"])
self.closeButton.setEnabled(False)
folder = os.path.join("audio", "bibles")
if not os.path.exists(folder):
os.mkdir(folder)
folder = os.path.join("audio", "bibles", self.selectedText)
if not os.path.exists(folder):
os.mkdir(folder)
folder = os.path.join("audio", "bibles", self.selectedText,
self.selectedDirectory)
if not os.path.exists(folder):
os.mkdir(folder)
self.thread = QThread()
self.worker = DownloadFromGitHub(self.github, self.repoData,
self.dataViewModel, self.selectedText,
self.selectedDirectory)
self.worker.moveToThread(self.thread)
self.thread.started.connect(self.worker.run)
self.worker.finished.connect(self.thread.quit)
self.worker.finished.connect(self.worker.deleteLater)
self.thread.finished.connect(self.worker.deleteLater)
self.worker.finished.connect(self.finishedDownloading)
self.worker.progress.connect(self.setStatus)
self.thread.start()
def finishedDownloading(self, count):
self.selectRendition(self.selectedRendition)
self.setStatus("")
self.downloadButton.setEnabled(True)
self.closeButton.setEnabled(True)
if count > 0:
self.parent.displayMessage(
config.thisTranslation["message_installed"])
def setStatus(self, message):
self.status.setText(message)
QApplication.processEvents()
def closeDialog(self):
if self.thread:
if self.thread.isRunning():
self.thread.quit()
self.close()
class BasePlotCurveEditorDialog(QDialog):
"""QDialog that is used in Qt Designer to edit the properties of the
curves in a waveform plot. This dialog is shown when you double-click
the plot, or when you right click it and choose 'edit curves'.
This thing is mostly just a wrapper for a table view, with a couple
buttons to add and remove curves, and a button to save the changes."""
TABLE_MODEL_CLASS = BasePlotCurvesModel
def __init__(self, plot, parent=None):
super(BasePlotCurveEditorDialog, self).__init__(parent)
self.plot = plot
self.setup_ui()
self.table_model = self.TABLE_MODEL_CLASS(self.plot)
self.table_view.setModel(self.table_model)
self.table_model.plot = plot
# self.table_view.resizeColumnsToContents()
self.add_button.clicked.connect(self.addCurve)
self.remove_button.clicked.connect(self.removeSelectedCurve)
self.remove_button.setEnabled(False)
self.table_view.selectionModel().selectionChanged.connect(
self.handleSelectionChange)
self.table_view.doubleClicked.connect(self.handleDoubleClick)
self.resize(800, 300)
def setup_ui(self):
self.vertical_layout = QVBoxLayout(self)
self.table_view = QTableView(self)
self.table_view.setEditTriggers(QAbstractItemView.DoubleClicked)
self.table_view.setProperty("showDropIndicator", False)
self.table_view.setDragDropOverwriteMode(False)
self.table_view.setSelectionMode(QAbstractItemView.SingleSelection)
self.table_view.setSelectionBehavior(QAbstractItemView.SelectRows)
self.table_view.setSortingEnabled(False)
self.table_view.horizontalHeader().setStretchLastSection(True)
self.table_view.verticalHeader().setVisible(False)
self.table_view.setColumnWidth(0, 160)
self.table_view.setColumnWidth(1, 160)
self.table_view.setColumnWidth(2, 160)
self.vertical_layout.addWidget(self.table_view)
self.add_remove_layout = QHBoxLayout()
spacer = QSpacerItem(40, 20, QSizePolicy.Expanding,
QSizePolicy.Minimum)
self.add_remove_layout.addItem(spacer)
self.add_button = QPushButton("Add Curve", self)
self.add_remove_layout.addWidget(self.add_button)
self.remove_button = QPushButton("Remove Curve", self)
self.add_remove_layout.addWidget(self.remove_button)
self.vertical_layout.addLayout(self.add_remove_layout)
self.button_box = QDialogButtonBox(self)
self.button_box.setOrientation(Qt.Horizontal)
self.button_box.addButton("Done", QDialogButtonBox.AcceptRole)
self.vertical_layout.addWidget(self.button_box)
self.button_box.accepted.connect(self.saveChanges)
self.button_box.rejected.connect(self.reject)
self.setWindowTitle("Waveform Curve Editor")
def setup_delegate_columns(self, index=2):
symbol_delegate = SymbolColumnDelegate(self)
self.table_view.setItemDelegateForColumn(index+3, symbol_delegate)
line_delegate = LineColumnDelegate(self)
self.table_view.setItemDelegateForColumn(index+1, line_delegate)
color_delegate = ColorColumnDelegate(self)
self.table_view.setItemDelegateForColumn(index, color_delegate)
@Slot()
def addCurve(self):
self.table_model.append()
@Slot()
def removeSelectedCurve(self):
self.table_model.removeAtIndex(self.table_view.currentIndex())
@Slot(QItemSelection, QItemSelection)
def handleSelectionChange(self, selected, deselected):
self.remove_button.setEnabled(
self.table_view.selectionModel().hasSelection())
@Slot(QModelIndex)
def handleDoubleClick(self, index):
if self.table_model.needsColorDialog(index):
# The table model returns a QBrush for BackgroundRole, not a QColor
init_color = self.table_model.data(index,
Qt.BackgroundRole).color()
color = QColorDialog.getColor(init_color, self)
if color.isValid():
self.table_model.setData(index, color, role=Qt.EditRole)
@Slot()
def saveChanges(self):
formWindow = QDesignerFormWindowInterface.findFormWindow(self.plot)
if formWindow:
formWindow.cursor().setProperty("curves", self.plot.curves)
self.accept()
class FreezeTableWidget(QTableView):
def __init__(self, parent=None, *args):
QTableView.__init__(self, parent, *args)
self.setMinimumSize(800, 600)
# set the table model
tm = MyTableModel(self)
# set the proxy model
pm = QSortFilterProxyModel(self)
pm.setSourceModel(tm)
self.setModel(pm)
self.frozenTableView = QTableView(self)
self.frozenTableView.setModel(pm)
self.frozenTableView.verticalHeader().hide()
self.frozenTableView.setFocusPolicy(Qt.NoFocus)
# self.frozenTableView.horizontalHeader().setSectionResizeMode(QHeaderView.Fixed)
self.frozenTableView.setStyleSheet(
'''border: none; background-color: #CCC''')
self.frozenTableView.setSelectionModel(
QAbstractItemView.selectionModel(self))
self.frozenTableView.setHorizontalScrollBarPolicy(
Qt.ScrollBarAlwaysOff)
self.frozenTableView.setVerticalScrollBarPolicy(Qt.ScrollBarAlwaysOff)
self.viewport().stackUnder(self.frozenTableView)
self.setEditTriggers(QAbstractItemView.SelectedClicked)
# hide grid
self.setShowGrid(False)
self.setStyleSheet('font: 10pt "Courier New"')
hh = self.horizontalHeader()
hh.setDefaultAlignment(Qt.AlignCenter)
hh.setStretchLastSection(True)
# self.resizeColumnsToContents()
ncol = tm.columnCount(self)
for col in range(ncol):
if col == 0:
self.horizontalHeader().resizeSection(col, 60)
# self.horizontalHeader().setSectionResizeMode(col, QHeaderView.Fixed)
self.frozenTableView.setColumnWidth(col, self.columnWidth(col))
elif col == 1:
self.horizontalHeader().resizeSection(col, 150)
# self.horizontalHeader().setSectionResizeMode(col, QHeaderView.Fixed)
self.frozenTableView.setColumnWidth(col, self.columnWidth(col))
else:
self.horizontalHeader().resizeSection(col, 100)
self.frozenTableView.setColumnHidden(col, True)
self.frozenTableView.setSortingEnabled(True)
self.frozenTableView.sortByColumn(0, Qt.AscendingOrder)
self.setAlternatingRowColors(True)
vh = self.verticalHeader()
vh.setDefaultSectionSize(25)
vh.setDefaultAlignment(Qt.AlignCenter)
vh.setVisible(True)
self.frozenTableView.verticalHeader().setDefaultSectionSize(
vh.defaultSectionSize())
# nrows = tm.rowCount(self)
# for row in range(nrows):
# self.setRowHeight(row, 25)
self.frozenTableView.show()
self.updateFrozenTableGeometry()
self.setHorizontalScrollMode(QAbstractItemView.ScrollPerPixel)
self.setVerticalScrollMode(QAbstractItemView.ScrollPerPixel)
self.frozenTableView.setVerticalScrollMode(
QAbstractItemView.ScrollPerPixel)
# connect the headers and scrollbars of both tableviews together
self.horizontalHeader().sectionResized.connect(self.updateSectionWidth)
self.verticalHeader().sectionResized.connect(self.updateSectionHeight)
self.frozenTableView.verticalScrollBar().valueChanged.connect(
self.verticalScrollBar().setValue)
self.verticalScrollBar().valueChanged.connect(
self.frozenTableView.verticalScrollBar().setValue)
def updateSectionWidth(self, logicalIndex, oldSize, newSize):
if logicalIndex == 0 or logicalIndex == 1:
self.frozenTableView.setColumnWidth(logicalIndex, newSize)
self.updateFrozenTableGeometry()
def updateSectionHeight(self, logicalIndex, oldSize, newSize):
self.frozenTableView.setRowHeight(logicalIndex, newSize)
def resizeEvent(self, event):
QTableView.resizeEvent(self, event)
self.updateFrozenTableGeometry()
def scrollTo(self, index, hint):
if index.column() > 1:
QTableView.scrollTo(self, index, hint)
def updateFrozenTableGeometry(self):
if self.verticalHeader().isVisible():
self.frozenTableView.setGeometry(
self.verticalHeader().width() + self.frameWidth(),
self.frameWidth(),
self.columnWidth(0) + self.columnWidth(1),
self.viewport().height() + self.horizontalHeader().height())
else:
self.frozenTableView.setGeometry(
self.frameWidth(), self.frameWidth(),
self.columnWidth(0) + self.columnWidth(1),
self.viewport().height() + self.horizontalHeader().height())
def moveCursor(self, cursorAction, modifiers):
current = QTableView.moveCursor(self, cursorAction, modifiers)
x = self.visualRect(current).topLeft().x()
frozen_width = self.frozenTableView.columnWidth(
0) + self.frozenTableView.columnWidth(1)
if cursorAction == self.MoveLeft and current.column(
) > 1 and x < frozen_width:
new_value = self.horizontalScrollBar().value() + x - frozen_width
self.horizontalScrollBar().setValue(new_value)
return current
class BasePlotCurveEditorDialog(QDialog):
"""QDialog that is used in Qt Designer to edit the properties of the
curves in a waveform plot. This dialog is shown when you double-click
the plot, or when you right click it and choose 'edit curves'.
This thing is mostly just a wrapper for a table view, with a couple
buttons to add and remove curves, and a button to save the changes."""
TABLE_MODEL_CLASS = BasePlotCurvesModel
def __init__(self, plot, parent=None):
super(BasePlotCurveEditorDialog, self).__init__(parent)
self.plot = plot
self.setup_ui()
self.table_model = self.TABLE_MODEL_CLASS(self.plot)
self.table_view.setModel(self.table_model)
self.table_model.plot = plot
# self.table_view.resizeColumnsToContents()
self.add_button.clicked.connect(self.addCurve)
self.remove_button.clicked.connect(self.removeSelectedCurve)
self.remove_button.setEnabled(False)
self.table_view.selectionModel().selectionChanged.connect(
self.handleSelectionChange)
self.table_view.doubleClicked.connect(self.handleDoubleClick)
self.resize(800, 300)
def setup_ui(self):
self.vertical_layout = QVBoxLayout(self)
self.table_view = QTableView(self)
self.table_view.setEditTriggers(QAbstractItemView.DoubleClicked)
self.table_view.setProperty("showDropIndicator", False)
self.table_view.setDragDropOverwriteMode(False)
self.table_view.setSelectionMode(QAbstractItemView.SingleSelection)
self.table_view.setSelectionBehavior(QAbstractItemView.SelectRows)
self.table_view.setSortingEnabled(False)
self.table_view.horizontalHeader().setStretchLastSection(True)
self.table_view.verticalHeader().setVisible(False)
self.table_view.setColumnWidth(0, 160)
self.table_view.setColumnWidth(1, 160)
self.table_view.setColumnWidth(2, 160)
self.vertical_layout.addWidget(self.table_view)
self.add_remove_layout = QHBoxLayout()
spacer = QSpacerItem(40, 20, QSizePolicy.Expanding,
QSizePolicy.Minimum)
self.add_remove_layout.addItem(spacer)
self.add_button = QPushButton("Add Curve", self)
self.add_remove_layout.addWidget(self.add_button)
self.remove_button = QPushButton("Remove Curve", self)
self.add_remove_layout.addWidget(self.remove_button)
self.vertical_layout.addLayout(self.add_remove_layout)
self.button_box = QDialogButtonBox(self)
self.button_box.setOrientation(Qt.Horizontal)
self.button_box.addButton("Done", QDialogButtonBox.AcceptRole)
self.vertical_layout.addWidget(self.button_box)
self.button_box.accepted.connect(self.saveChanges)
self.button_box.rejected.connect(self.reject)
self.setWindowTitle("Waveform Curve Editor")
def setup_delegate_columns(self, index=2):
symbol_delegate = SymbolColumnDelegate(self)
self.table_view.setItemDelegateForColumn(index + 3, symbol_delegate)
line_delegate = LineColumnDelegate(self)
self.table_view.setItemDelegateForColumn(index + 1, line_delegate)
color_delegate = ColorColumnDelegate(self)
self.table_view.setItemDelegateForColumn(index, color_delegate)
@Slot()
def addCurve(self):
self.table_model.append()
@Slot()
def removeSelectedCurve(self):
self.table_model.removeAtIndex(self.table_view.currentIndex())
@Slot(QItemSelection, QItemSelection)
def handleSelectionChange(self, selected, deselected):
self.remove_button.setEnabled(
self.table_view.selectionModel().hasSelection())
@Slot(QModelIndex)
def handleDoubleClick(self, index):
if self.table_model.needsColorDialog(index):
# The table model returns a QBrush for BackgroundRole, not a QColor
init_color = self.table_model.data(index,
Qt.BackgroundRole).color()
color = QColorDialog.getColor(init_color, self)
if color.isValid():
self.table_model.setData(index, color, role=Qt.EditRole)
@Slot()
def saveChanges(self):
formWindow = QDesignerFormWindowInterface.findFormWindow(self.plot)
if formWindow:
formWindow.cursor().setProperty("curves", self.plot.curves)
self.accept()
