def __init__(self, *args, **kwargs):
QWidget.__init__(self, *args, **kwargs)
self.setLayout(QVBoxLayout())
tv1 = QTableView(self)
tv2 = QTableView(self)
model = QStandardItemModel(8, 4, self)
proxy = SortFilterProxyModel(self)
proxy.setSourceModel(model)
tv1.setModel(model)
tv2.setModel(proxy)
self.layout().addWidget(tv1)
self.layout().addWidget(tv2)
for i in range(model.rowCount()):
for j in range(model.columnCount()):
item = QStandardItem()
item.setData(random_word(), Qt.DisplayRole)
model.setItem(i, j, item)
flayout = QFormLayout()
self.layout().addLayout(flayout)
for i in range(model.columnCount()):
le = QLineEdit(self)
flayout.addRow("column: {}".format(i), le)
le.textChanged.connect(lambda text, col=i: proxy.setFilterByColumn(
QRegExp(text, Qt.CaseSensitive, QRegExp.FixedString), col))
class MainWindow(QMainWindow):
def __init__(self):
super().__init__()
container = QWidget()
layout = QVBoxLayout()
self.search = QLineEdit()
self.search.textChanged.connect(self.update_filter)
self.table = QTableView()
layout.addWidget(self.search)
layout.addWidget(self.table)
container.setLayout(layout)
self.model = QSqlTableModel(db=db)
self.table.setModel(self.model)
self.model.setTable("Track")
self.model.select()
self.setMinimumSize(QSize(1024, 600))
self.setCentralWidget(container)
# tag::filter[]
def update_filter(self, s):
s = re.sub("[\W_]+", "", s)
filter_str = 'Name LIKE "%{}%"'.format(s)
self.model.setFilter(filter_str)
def view_fit_grains_results(self):
for result in self.fit_grains_results:
print(result)
# Build grains table
num_grains = len(self.fit_grains_results)
shape = (num_grains, 21)
grains_table = np.empty(shape)
gw = instrument.GrainDataWriter(array=grains_table)
for result in self.fit_grains_results:
gw.dump_grain(*result)
gw.close()
# Display grains table in popup dialog
dialog = QDialog(self.parent)
dialog.setWindowTitle('Fit Grains Results')
model = FitGrainsResultsModel(grains_table, dialog)
view = QTableView(dialog)
view.setModel(model)
view.verticalHeader().hide()
view.resizeColumnToContents(0)
layout = QVBoxLayout(dialog)
layout.addWidget(view)
dialog.setLayout(layout)
dialog.resize(960, 320)
dialog.exec_()
class widget(QWidget):
def __init__(self, data):
QWidget.__init__(self)
self.model = CustomTableModel(data)
self.table_view = QTableView()
self.table_view.setModel(self.model)
self.horizontal_header = self.table_view.horizontalHeader()
self.vertical_header = self.table_view.verticalHeader()
self.horizontal_header.setSectionResizeMode(
QHeaderView.ResizeToContents)
self.vertical_header.setSectionResizeMode(QHeaderView.ResizeToContents)
self.horizontal_header.setStretchLastSection(True)
self.main_layout = QHBoxLayout()
size = QSizePolicy(QSizePolicy.Preferred, QSizePolicy.Preferred)
size.setHorizontalStretch(1)
self.table_view.setSizePolicy(size)
self.main_layout.addWidget(self.table_view)
self.setLayout(self.main_layout)
class Widget(QWidget):
def __init__(self, data):
QWidget.__init__(self)
#Getting the Model
self.model = CustomTableModel(data)
#Creating a QTableView
self.table_view = QTableView()
self.table_view.setModel(self.model)
#QTableView Headers
self.horizontal_header = self.table_view.horizontalHeader()
self.vertical_header = self.table_view.verticalHeader()
self.horizontal_header.setSectionResizeMode(
QHeaderView.ResizeToContents)
self.vertical_header.setSectionResizeMode(QHeaderView.ResizeToContents)
self.horizontal_header.setStretchLastSection(True)
#QWidget Layout
self.main_layout = QHBoxLayout()
size = QSizePolicy(QSizePolicy.Preferred, QSizePolicy.Preferred)
#Left Layout
size.setHorizontalStretch(1)
self.table_view.setSizePolicy(size)
self.main_layout.addWidget(self.table_view)
# Set layout to QWidget
self.setLayout(self.main_layout)
class MainWindow(QMainWindow):
def __init__(self):
super().__init__()
self.table = QTableView()
self.model = QSqlTableModel(db=db)
self.table.setModel(self.model)
# tag::titles[]
self.model.setTable("Track")
column_titles = {
"Name": "Name",
"AlbumId": "Album (ID)",
"MediaTypeId": "Media Type (ID)",
"GenreId": "Genre (ID)",
"Composer": "Composer",
}
for n, t in column_titles.items():
idx = self.model.fieldIndex(n)
self.model.setHeaderData(idx, Qt.Horizontal, t)
self.model.select()
# end::titles[]
self.model.select()
self.setMinimumSize(QSize(1024, 600))
self.setCentralWidget(self.table)
def setupTabs(self):
""" Setup the various tabs in the AddressWidget. """
groups = ["ABC", "DEF", "GHI", "JKL", "MNO", "PQR", "STU", "VW", "XYZ"]
for group in groups:
proxyModel = QSortFilterProxyModel(self)
proxyModel.setSourceModel(self.tableModel)
proxyModel.setDynamicSortFilter(True)
tableView = QTableView()
tableView.setModel(proxyModel)
tableView.setSortingEnabled(True)
tableView.setSelectionBehavior(QAbstractItemView.SelectRows)
tableView.horizontalHeader().setStretchLastSection(True)
tableView.verticalHeader().hide()
tableView.setEditTriggers(QAbstractItemView.NoEditTriggers)
tableView.setSelectionMode(QAbstractItemView.SingleSelection)
# This here be the magic: we use the group name (e.g. "ABC") to
# build the regex for the QSortFilterProxyModel for the group's
# tab. The regex will end up looking like "^[ABC].*", only
# allowing this tab to display items where the name starts with
# "A", "B", or "C". Notice that we set it to be case-insensitive.
reFilter = "^[%s].*" % group
proxyModel.setFilterRegExp(QRegExp(reFilter, Qt.CaseInsensitive))
proxyModel.setFilterKeyColumn(0) # Filter on the "name" column
proxyModel.sort(0, Qt.AscendingOrder)
# This prevents an application crash (see: http://www.qtcentre.org/threads/58874-QListView-SelectionModel-selectionChanged-Crash)
viewselectionmodel = tableView.selectionModel()
tableView.selectionModel().selectionChanged.connect(
self.selectionChanged)
self.addTab(tableView, group)
def __init__(self):
super(MainWindow, self).__init__()
self.resize(1024, 600)
wood_model = WoodModel(list(db.get_all_wood_records()))
main_layout = QVBoxLayout()
table_view = QTableView(self)
table_view.setModel(wood_model)
main_layout.addWidget(table_view)
text_edit = QTextEdit(self)
main_layout.addWidget(text_edit)
message_label = QLabel("", self)
main_layout.addWidget(message_label)
add_button = QPushButton("Add", self)
main_layout.addWidget(add_button)
self.setLayout(main_layout)
def on_add(value):
records_to_add = text_edit.toPlainText().split("\n")
for record_to_add in records_to_add:
columns = record_to_add.split("\t")
try:
wood = db.Wood.from_text_columns(columns)
db.add_wood_record(wood)
wood_model.add_wood(wood)
except db.DwellingException as e:
print(e.message)
message_label.setText(e.message)
text_edit.clear()
add_button.clicked.connect(on_add)
class MainWindow(QMainWindow):
def __init__(self):
super().__init__()
self.view = QTableView()
self.view.horizontalHeader().hide()
self.view.verticalHeader().hide()
self.view.setGridStyle(Qt.NoPen)
delegate = PreviewDelegate()
self.view.setItemDelegate(delegate)
self.model = PreviewModel()
self.view.setModel(self.model)
self.setCentralWidget(self.view)
# Add a bunch of images.
image_files = glob.glob("*.jpg")
for n, fn in enumerate(image_files):
image = QImage(fn)
item = preview(n, fn, image)
self.model.previews.append(item)
self.model.layoutChanged.emit()
self.view.resizeRowsToContents()
self.view.resizeColumnsToContents()
def testSetModel(self):
model = VirtualList()
model._getItemCalled = False
table = QTableView()
table.setModel(model)
table.show()
self.assertFalse(model._getItemCalled)
def get_view_for_submodel(submodel):
main_widget = QWidget()
hbox_layout = QHBoxLayout(main_widget)
vbox_layout = QVBoxLayout()
table_view = QTableView()
table_view.setSelectionBehavior(QAbstractItemView.SelectRows)
table_view.setSelectionMode(QAbstractItemView.SingleSelection)
table_view.setModel(submodel)
add_button = QPushButton("+")
add_button.clicked.connect(lambda: add_item_to_model(submodel))
remove_button = QPushButton("-")
remove_button.clicked.connect(
lambda: remove_item_from_model(submodel, table_view))
vbox_layout.addWidget(add_button)
vbox_layout.addWidget(remove_button)
vbox_layout.addItem(
QSpacerItem(20, 40, QSizePolicy.Minimum, QSizePolicy.Expanding))
hbox_layout.addWidget(table_view)
hbox_layout.addLayout(vbox_layout)
return main_widget
class DataframeView(QWidget):
def __init__(self, parent: QWidget = None):
super().__init__(parent)
layout = QVBoxLayout(self)
self.inputCB = QComboBox(self)
self.dataView = QTableView(self)
layout.addWidget(self.inputCB)
layout.addWidget(self.dataView)
self._workbench: WorkbenchModel = None
def setWorkbench(self, w: WorkbenchModel) -> None:
self.inputCB.setModel(w)
self._workbench = w
self.inputCB.currentTextChanged.connect(self.setDataframe)
@Slot(str)
def setDataframe(self, name: str) -> None:
if not self.dataView.model():
self.dataView.setModel(IncrementalRenderFrameModel(parent=self))
self.dataView.horizontalScrollBar().valueChanged.connect(self.onHorizontalScroll)
self.dataView.verticalScrollBar().valueChanged.connect(self.onVerticalScroll)
# Get frame model and set it in the table
frameModel = self._workbench.getDataframeModelByName(name)
self.dataView.model().setSourceModel(frameModel)
@Slot(int)
def onVerticalScroll(self, *_) -> None:
self.dataView.model().setScrollMode('row')
@Slot(int)
def onHorizontalScroll(self, *_) -> None:
self.dataView.model().setScrollMode('column')
class CrosswordWidget(QWidget):
def __init__(self, crossword_index, grid_data, grid_cell_length):
QWidget.__init__(self)
self.grid_model = CrosswordGridModel(crossword_index, grid_data)
self.grid_delegate = CrosswordGridDelegate(grid_data)
self.grid_table_view = QTableView(self)
#sizePolicy = QSizePolicy(QSizePolicy.Minimum, QSizePolicy.Minimum)
#self.grid_table_view.setSizePolicy(sizePolicy)
self.grid_table_view.setModel(self.grid_model)
self.grid_table_view.setItemDelegate(self.grid_delegate)
self.grid_table_view.resizeColumnsToContents()
self.grid_table_view.setStyleSheet("background:transparent")
#self.grid_horizontal_header = self.grid_table_view.horizontalHeader()
#self.grid_horizontal_header.setSectionResizeMode(QHeaderView.Fixed)
#self.grid_horizontal_header.setDefaultSectionSize(grid_cell_length)
#self.grid_horizontal_header.hide()
#self.grid_vertical_header = self.grid_table_view.verticalHeader()
#self.grid_vertical_header.setSectionResizeMode(QHeaderView.Fixed)
#self.grid_vertical_header.setDefaultSectionSize(grid_cell_length * 1.3)
#self.grid_vertical_header.hide()
#self.main_layout = QHBoxLayout(self)
#self.main_layout.addWidget(self.grid_table_view)
#self.setLayout(self.main_layout)
#self.layout().addWidget(self.grid_table_view)
def save_solution(self):
if self.grid_model.save_solution():
status_bar.showMessage("Solution saved")
class WidgetPandas(QWidget):
def __init__(self, parent=None, df=None):
super().__init__(parent)
if df is None:
df = pd.DataFrame()
self.tablemodel = PandasDataFrameModel(df=df)
self.tableview = QTableView()
self.tableview.setModel(self.tablemodel)
tableboxlayout = QVBoxLayout()
self.tableview.setMinimumWidth(500)
self.tableview.setMinimumHeight(250)
self.tableview.setWordWrap(False)
self.tableview.setShowGrid(False)
tableboxlayout.addWidget(self.tableview)
self.setLayout(tableboxlayout)
@Slot(pd.DataFrame)
def setDataFrame(self, df: pd.DataFrame):
if df is None:
df = pd.DataFrame()
self.tablemodel.set_df(df)
@Slot()
def refreshTable(self):
self.tablemodel.beginResetModel()
self.tablemodel.endResetModel()
def setupTabs(self):
""" Setup the various tabs in the AddressWidget. """
groups = ["ABC", "DEF", "GHI", "JKL", "MNO", "PQR", "STU", "VW", "XYZ"]
for group in groups:
proxyModel = QSortFilterProxyModel(self)
proxyModel.setSourceModel(self.tableModel)
proxyModel.setDynamicSortFilter(True)
tableView = QTableView()
tableView.setModel(proxyModel)
tableView.setSortingEnabled(True)
tableView.setSelectionBehavior(QAbstractItemView.SelectRows)
tableView.horizontalHeader().setStretchLastSection(True)
tableView.verticalHeader().hide()
tableView.setEditTriggers(QAbstractItemView.NoEditTriggers)
tableView.setSelectionMode(QAbstractItemView.SingleSelection)
# This here be the magic: we use the group name (e.g. "ABC") to
# build the regex for the QSortFilterProxyModel for the group's
# tab. The regex will end up looking like "^[ABC].*", only
# allowing this tab to display items where the name starts with
# "A", "B", or "C". Notice that we set it to be case-insensitive.
reFilter = "^[%s].*" % group
proxyModel.setFilterRegExp(QRegExp(reFilter, Qt.CaseInsensitive))
proxyModel.setFilterKeyColumn(0) # Filter on the "name" column
proxyModel.sort(0, Qt.AscendingOrder)
# This prevents an application crash (see: http://www.qtcentre.org/threads/58874-QListView-SelectionModel-selectionChanged-Crash)
viewselectionmodel = tableView.selectionModel()
tableView.selectionModel().selectionChanged.connect(self.selectionChanged)
self.addTab(tableView, group)
def testSetModel(self):
model = VirtualList()
model._getItemCalled = False
table = QTableView()
table.setModel(model)
table.show()
self.assertFalse(model._getItemCalled)
class ArrayDatasetTableWidget(QWidget):
"""
Wrapper over a QTableView with buttons to add and delete rows/columns
"""
def __init__(self, type: np.dtype = np.byte, parent=None):
super().__init__(parent)
self.model = ArrayDatasetTableModel(dtype=type, parent=self)
self.view = QTableView()
self.view.setModel(self.model)
self.view.setSelectionMode(QAbstractItemView.SingleSelection)
self.view.setItemDelegate(ValueDelegate(type, parent))
self.setLayout(QGridLayout())
self.toolbox = QToolBar()
self.add_row_button = QAction(text="➕ Add Row")
self.add_row_button.triggered.connect(self.model.add_row)
self.remove_row_button = QAction(text="➖ Remove Row")
self.remove_row_button.triggered.connect(
partial(self.model.delete_index, True))
self.add_column_button = QAction(text="➕ Add Column")
self.add_column_button.triggered.connect(self.model.add_column)
self.remove_column_button = QAction(text="➖ Remove Column")
self.remove_column_button.triggered.connect(
partial(self.model.delete_index, False))
self.toolbox.addAction(self.add_row_button)
self.toolbox.addAction(self.remove_row_button)
self.toolbox.addAction(self.add_column_button)
self.toolbox.addAction(self.remove_column_button)
self.layout().addWidget(self.toolbox)
self.layout().addWidget(self.view)
class ScoresWidget(QDockWidget):
"""Widget that display a solution scores."""
def __init__(self, parent=None):
super().__init__(parent)
self.setWindowTitle("Scores")
# Build widgets
self.search_field = QLineEdit(self)
self.checkbox_positive = QCheckBox("Positive", self)
self.checkbox_positive.setChecked(True)
self.checkbox_negative = QCheckBox("Negative", self)
self.checkbox_negative.setChecked(True)
self.checkbox_neutral = QCheckBox("Neutral", self)
self.table = QTableView(self)
self.table.setSelectionBehavior(QAbstractItemView.SelectRows)
self.table.horizontalHeader().setSectionResizeMode(
QHeaderView.ResizeToContents)
self.table.horizontalHeader().setStretchLastSection(True)
self.table.verticalHeader().setVisible(False)
# Build layout
layout_header = QHBoxLayout()
layout_header.addWidget(self.search_field)
layout_header.addWidget(self.checkbox_positive)
layout_header.addWidget(self.checkbox_negative)
layout_header.addWidget(self.checkbox_neutral)
layout_main = QVBoxLayout()
layout_main.addLayout(layout_header)
layout_main.addWidget(self.table)
main_widget = QWidget(self)
main_widget.setLayout(layout_main)
self.setWidget(main_widget)
# Configure models
self.model = PointsTableModel(self)
self._proxy_model = ScoreProxyModel()
self._proxy_model.setSourceModel(self.model)
self._proxy_model.sort(
1, Qt.AscendingOrder) # sort by lowest score by default
# Configure table
self.table.setModel(self._proxy_model)
self.table.horizontalHeader().setSectionResizeMode(QHeaderView.Stretch)
# Connect signals
for signal, callback in (
(self.search_field.textChanged,
self._proxy_model.setFilterWildcard),
(self.checkbox_positive.stateChanged,
self._proxy_model.set_positive),
(self.checkbox_negative.stateChanged,
self._proxy_model.set_negative),
(self.checkbox_neutral.stateChanged,
self._proxy_model.set_neutral),
):
signal.connect(callback)
class AddressWidget(QDialog):
selectionChanged = Signal(QItemSelection)
def __init__(self, parent=None):
super(AddressWidget, self).__init__(parent)
self.tableModel = TableModel()
self.tableView = QTableView()
self.setupTable()
statusLabel = QLabel("Tabular data view demo")
layout = QVBoxLayout()
layout.addWidget(self.tableView)
layout.addWidget(statusLabel)
self.setLayout(layout)
self.setWindowTitle("Address Book")
self.resize(800,500)
# add test data
self.populateTestData()
def setupTable(self):
proxyModel = QSortFilterProxyModel(self)
proxyModel.setSourceModel(self.tableModel)
proxyModel.setDynamicSortFilter(True)
self.tableView.setModel(proxyModel)
self.tableView.setSortingEnabled(True)
self.tableView.setSelectionBehavior(QAbstractItemView.SelectRows)
self.tableView.horizontalHeader().setStretchLastSection(True)
self.tableView.verticalHeader().hide()
self.tableView.setEditTriggers(QAbstractItemView.NoEditTriggers)
self.tableView.setSelectionMode(QAbstractItemView.SingleSelection)
proxyModel.setFilterKeyColumn(0) # Filter on the "name" column
proxyModel.sort(0, Qt.AscendingOrder)
viewselectionmodel = self.tableView.selectionModel()
self.tableView.selectionModel().selectionChanged.connect(self.selectionChanged)
def populateTestData(self):
addresses = [{"name": "John Doe", "address": "Alameda"},
{"name": "Alan Turing", "address": "San Deigo"},
{"name": "Bjarne Stroutsup", "address": "Columbia"},
{"name": "Herb Sutter", "address": "Seattle"},
{"name": "Micheal Konin", "address": "Colorado"}]
for i in range(len(addresses)):
self.tableModel.insertRows(0)
ix = self.tableModel.index(0, 0, QModelIndex())
self.tableModel.setData(ix, addresses[i]["name"], Qt.EditRole)
ix = self.tableModel.index(0, 1, QModelIndex())
self.tableModel.setData(ix, addresses[i]["address"], Qt.EditRole)
self.tableView.resizeRowToContents(ix.row())
def _create_table_view(self, df):
if df is None:
df = pd.DataFrame()
model = PandasModel(df)
table_view = QTableView()
table_view.setModel(model)
table_view.horizontalHeader().setSectionResizeMode(QHeaderView.Stretch)
return table_view
class PodgladDanych(QDialog):
def __init__(self, model):
QDialog.__init__(self)
self.resize(QSize(1081, 750))
self.model = model
self.tableViewPodgladDanych = QTableView(self)
self.tableViewPodgladDanych.resize(QSize(1070, 740))
self.tableViewPodgladDanych.setModel(model)
def showdf(self, df):
model = PdQtClass.pandasModel(df)
view = QTableView()
view.setModel(model)
view.resize(800, 600)
self.w = QTableView()
self.w.setModel(model)
self.w.resize(480, 320)
self.w.show()
class TableWidget(QWidget):
def __init__(self):
QWidget.__init__(self)
self.model = CustomTableModel()
self.table_view = QTableView()
self.table_view.setModel(self.model)
self.table_view.horizontalHeader().setSectionResizeMode(QHeaderView.Stretch)
self.table_view.verticalHeader().setSectionResizeMode(QHeaderView.Stretch)
self.chart = QtCharts.QChart()
self.chart.setAnimationOptions(QtCharts.QChart.AllAnimations)
self.series = QtCharts.QLineSeries()
self.series.setName("Line 1")
self.mapper = QtCharts.QVXYModelMapper(self)
self.mapper.setXColumn(0)
self.mapper.setYColumn(1)
self.mapper.setSeries(self.series)
self.mapper.setModel(self.model)
self.chart.addSeries(self.series)
# for storing color hex from the series
seriesColorHex = "#000000"
# get the color of the series and use it for showing the mapped area
seriesColorHex = "{}".format(self.series.pen().color().name())
self.model.add_mapping(seriesColorHex, QRect(0, 0, 2, self.model.rowCount()))
# series 2
self.series = QtCharts.QLineSeries()
self.series.setName("Line 2")
self.mapper = QtCharts.QVXYModelMapper(self)
self.mapper.setXColumn(2)
self.mapper.setYColumn(3)
self.mapper.setSeries(self.series)
self.mapper.setModel(self.model)
self.chart.addSeries(self.series)
# get the color of the series and use it for showing the mapped area
seriesColorHex = "{}".format(self.series.pen().color().name())
self.model.add_mapping(seriesColorHex, QRect(2, 0, 2, self.model.rowCount()))
self.chart.createDefaultAxes()
self.chart_view = QtCharts.QChartView(self.chart)
self.chart_view.setRenderHint(QPainter.Antialiasing)
self.chart_view.setMinimumSize(640, 480)
# create main layout
self.main_layout = QGridLayout()
self.main_layout.addWidget(self.table_view, 1, 0)
self.main_layout.addWidget(self.chart_view, 1, 1)
self.main_layout.setColumnStretch(1, 1)
self.main_layout.setColumnStretch(0, 0)
self.setLayout(self.main_layout)
class TableWidget(QWidget):
def __init__(self):
QWidget.__init__(self)
self.model = CustomTableModel()
self.table_view = QTableView()
self.table_view.setModel(self.model)
self.table_view.horizontalHeader().setSectionResizeMode(QHeaderView.Stretch)
self.table_view.verticalHeader().setSectionResizeMode(QHeaderView.Stretch)
self.chart = QtCharts.QChart()
self.chart.setAnimationOptions(QtCharts.QChart.AllAnimations)
self.series = QtCharts.QLineSeries()
self.series.setName("Line 1")
self.mapper = QtCharts.QVXYModelMapper(self)
self.mapper.setXColumn(0)
self.mapper.setYColumn(1)
self.mapper.setSeries(self.series)
self.mapper.setModel(self.model)
self.chart.addSeries(self.series)
# for storing color hex from the series
seriesColorHex = "#000000"
# get the color of the series and use it for showing the mapped area
seriesColorHex = "{}".format(self.series.pen().color().name())
self.model.add_mapping(seriesColorHex, QRect(0, 0, 2, self.model.rowCount()))
# series 2
self.series = QtCharts.QLineSeries()
self.series.setName("Line 2")
self.mapper = QtCharts.QVXYModelMapper(self)
self.mapper.setXColumn(2)
self.mapper.setYColumn(3)
self.mapper.setSeries(self.series)
self.mapper.setModel(self.model)
self.chart.addSeries(self.series)
# get the color of the series and use it for showing the mapped area
seriesColorHex = "{}".format(self.series.pen().color().name())
self.model.add_mapping(seriesColorHex, QRect(2, 0, 2, self.model.rowCount()));
self.chart.createDefaultAxes()
self.chart_view = QtCharts.QChartView(self.chart)
self.chart_view.setRenderHint(QPainter.Antialiasing)
self.chart_view.setMinimumSize(640, 480)
# create main layout
self.main_layout = QGridLayout()
self.main_layout.addWidget(self.table_view, 1, 0)
self.main_layout.addWidget(self.chart_view, 1, 1)
self.main_layout.setColumnStretch(1, 1)
self.main_layout.setColumnStretch(0, 0)
self.setLayout(self.main_layout)
def __init__(self, crossword_index, grid_data, parent=None):
super(Form, self).__init__(parent)
self.setWindowTitle('{} {} {}'.format(
app_title,
bangla.convert_english_digit_to_bangla_digit(crossword_index),
date.today().strftime("%A, %d %B, %Y")))
self.setWindowFlags(self.windowFlags()
& ~Qt.WindowContextHelpButtonHint)
tableModel = CrosswordGridModel(crossword_index, grid_data, self)
tableView = QTableView(self)
tableView.horizontalHeader().hide()
tableView.verticalHeader().hide()
tableView.setModel(tableModel)
for i in range(grid_row_count):
tableView.setRowHeight(i, grid_cell_size)
for i in range(grid_column_count):
tableView.setColumnWidth(i, grid_cell_size)
generateIconFiles(icons_folder, tableView.columnWidth(0),
tableView.rowHeight(0))
right_label = QLabel(self)
right_pixmap = QPixmap('right_clues.png')
right_label.setPixmap(right_pixmap)
down_label = QLabel(self)
down_pixmap = QPixmap('down_clues.png')
down_label.setPixmap(down_pixmap)
saveButton = QPushButton('Save progress', self)
loadButton = QPushButton('Load progress', self)
clearButton = QPushButton('Clear progress', self)
saveButton.clicked.connect(tableModel.save_solution)
loadButton.clicked.connect(tableModel.load_solution)
clearButton.clicked.connect(tableModel.clear_solution)
bbox = QDialogButtonBox(self)
bbox.addButton(saveButton, QDialogButtonBox.AcceptRole)
bbox.addButton(loadButton, QDialogButtonBox.AcceptRole)
bbox.addButton(clearButton, QDialogButtonBox.AcceptRole)
layout = QGridLayout(self)
layout.addWidget(tableView, 0, 0)
layout.addWidget(right_label, 0, 1, Qt.AlignLeft | Qt.AlignTop)
layout.addWidget(down_label, 1, 0, Qt.AlignLeft | Qt.AlignTop)
layout.addWidget(bbox, 1, 1, Qt.AlignHCenter | Qt.AlignBottom)
self.setLayout(layout)
windowWidth = tableView.columnWidth(
0
) * grid_column_count + grid_column_count - 1 + right_clues_right - right_clues_left + layout.horizontalSpacing(
) + 27
windowHeight = tableView.rowHeight(
0
) * grid_row_count + grid_row_count - 1 + down_clues_bottom - down_clues_top + layout.verticalSpacing(
) + 10
self.setFixedSize(QSize(windowWidth, windowHeight))
class DebugBreakpointsWidget(QWidget, DockContextHandler):
def __init__(self, parent, name, data):
if not type(data) == binaryninja.binaryview.BinaryView:
raise Exception('expected widget data to be a BinaryView')
self.bv = data
QWidget.__init__(self, parent)
DockContextHandler.__init__(self, self, name)
self.actionHandler = UIActionHandler()
self.actionHandler.setupActionHandler(self)
self.table = QTableView(self)
self.model = DebugBreakpointsListModel(self.table, data)
self.table.setModel(self.model)
self.item_delegate = DebugBreakpointsItemDelegate(self)
self.table.setItemDelegate(self.item_delegate)
# self.table.setSortingEnabled(True)
self.table.setSelectionBehavior(QAbstractItemView.SelectionBehavior.SelectRows)
self.table.setSelectionMode(QAbstractItemView.ExtendedSelection)
self.table.verticalHeader().setSectionResizeMode(QHeaderView.ResizeToContents)
self.table.verticalHeader().setVisible(False)
self.table.setHorizontalScrollMode(QAbstractItemView.ScrollPerPixel)
self.table.setVerticalScrollMode(QAbstractItemView.ScrollPerPixel)
self.table.resizeColumnsToContents()
self.table.resizeRowsToContents()
for i in range(len(self.model.columns)):
self.table.setColumnWidth(i, self.item_delegate.sizeHint(self.table.viewOptions(), self.model.index(-1, i, QModelIndex())).width())
self.table.horizontalHeader().setSectionResizeMode(1, QHeaderView.Stretch)
layout = QVBoxLayout()
layout.setContentsMargins(0, 0, 0, 0)
layout.setSpacing(0)
layout.addWidget(self.table)
self.setLayout(layout)
def notifyOffsetChanged(self, offset):
pass
def notifyBreakpointsChanged(self, new_rows):
self.model.update_rows(new_rows)
def contextMenuEvent(self, event):
self.m_contextMenuManager.show(self.m_menu, self.actionHandler)
def shouldBeVisible(self, view_frame):
if view_frame is None:
return False
else:
return True
def testReferenceCountingWhenDeletingReferrer(self):
'''Tests reference count of model object referred by deceased view object.'''
model = TestModel()
refcount1 = getrefcount(model)
view = QTableView()
view.setModel(model)
self.assertEqual(getrefcount(view.model()), refcount1 + 1)
del view
self.assertEqual(getrefcount(model), refcount1)
def testReferenceCountingWhenDeletingReferrer(self):
'''Tests reference count of model object referred by deceased view object.'''
model = TestModel()
refcount1 = getrefcount(model)
view = QTableView()
view.setModel(model)
self.assertEqual(getrefcount(view.model()), refcount1 + 1)
del view
self.assertEqual(getrefcount(model), refcount1)
class Window(QtWidgets.QWidget):
"""
zmiana nagłówka działa tylko dla stylu fusion, działa tylko dla stylu 'fusion"
"""
def __init__(self):
super(Window, self).__init__()
self.table = QTableView()
self.sti = QStandardItemModel()
self.sti.setColumnCount(3)
self.table.setModel(self.sti)
self.sti.setRowCount(8)
#piersza możliwośc przez QStandardItem
# item1 = QStandardItem('Red')
# item1.setBackground(QBrush(Qt.red))
# self.sti.setHorizontalHeaderItem(1, item1)
#Druga możliwosć przez odwołanie modelu:
self.table.model().setHeaderData(0, Qt.Horizontal,
QBrush(QColor(121, 166, 210)),
Qt.BackgroundRole)
self.table.model().setHeaderData(0, Qt.Horizontal, "One",
Qt.DisplayRole)
self.mlayout = QHBoxLayout()
self.mlayout.addWidget(self.table)
self.setLayout(self.mlayout)
def contextMenuEvent(self, event):
contextMenu = QMenu(self)
newAction = contextMenu.addAction("New")
openAction = contextMenu.addAction("Open")
quitAction = contextMenu.addAction("Quit")
action = contextMenu.exec_(self.mapToGlobal(event.pos()))
if action == quitAction:
self.close()
if action == openAction:
# model = self.sti
# indices = self.table.selectionModel().selectedRows()
# for index in sorted(indices):
# model.removeRow(index.row())
index_list = []
for model_index in self.table.selectionModel().selectedRows():
index = QtCore.QPersistentModelIndex(model_index)
index_list.append(index)
for index in index_list:
self.sti.removeRow(index.row())
def __init__(self, data_list, header, *args):
QWidget.__init__(self, *args)
# setGeometry(x_pos, y_pos, width, height)
self.setGeometry(300, 200, 570, 450)
self.setWindowTitle('Click on column title to sort')
# Setup the model and view
'''tmodel = MyTableModel(self, data_list, header)
tview = QTableView()
tview.setModel(tmodel)
delegate = MyDelegate()
tview.setItemDelegate(delegate)'''
# Setup the proxy model for sorting and filtering
tmodel = MyTableModel(self, data_list, header)
pmodel = QSortFilterProxyModel()
pmodel.setSourceModel(tmodel)
tview = QTableView()
tview.setModel(pmodel)
delegate = MyDelegate()
tview.setItemDelegate(delegate)
# TableView properties
tview.resizeColumnsToContents() # set column width to fit contents
tview.setShowGrid(False) # hide gridlines
#tview.verticalHeader().hide() # row labels
#tview.horizontalHeader().hide() # column labels
# Select a single row at a time
tview.setSelectionBehavior(QTableView.SelectRows)
tview.setSelectionMode(QTableView.SingleSelection)
# Enable sorting
tview.setSortingEnabled(True)
# Drag and drop reordering using header labels
'''tview.verticalHeader().setSectionsMovable(True)
tview.verticalHeader().setDragEnabled(True)
tview.verticalHeader().setDragDropMode(QAbstractItemView.InternalMove)
tview.horizontalHeader().setSectionsMovable(True)
tview.horizontalHeader().setDragEnabled(True)
tview.horizontalHeader().setDragDropMode(QAbstractItemView.InternalMove)'''
# Drag and drop reordering using rows
tview.setDragEnabled(True)
tview.setAcceptDrops(True)
tview.setDragDropMode(QTableView.InternalMove)
tview.setDragDropOverwriteMode(False)
layout = QVBoxLayout(self)
layout.addWidget(tview)
self.setLayout(layout)
def createDomainTable(self, domainmodel):
domainTable = QTableView()
domainTable.setModel(domainmodel)
domainTable.setItemDelegate(DomainDelegate(domainTable))
domainTable.verticalHeader().setVisible(False)
domainTable.resizeColumnsToContents()
domainTable.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Expanding)
domainTable.horizontalHeader().setSectionResizeMode(1, QHeaderView.Stretch)
return domainTable
class SQLite(QSqlDatabase):
"""
Класс для инициализации и открытия базы данных каталога, полученный из Slot'а (openFile)
"""
def __init__(self, path=None):
"""
Инициализация экземпляра класса
:param path: путь до каталога, полученный изиз Slot'а (openFile)
"""
super().__init__()
self.path = path
self.width = 0
self.heigh = 0
self.db = QSqlDatabase.addDatabase('QSQLITE')
self.db.setDatabaseName(self.path)
self.db.open()
self.window = QWidget()
self.window.setWindowTitle("Каталог книг")
self.conn = sqlite3.connect(self.path)
cursor = self.conn.cursor()
sql = f'select * from sqlite_master where type = "table"' # получение имени таблицы(первая в списке), к которой будет
# осуществлено подключение
cursor.execute(sql)
self.search_result = cursor.fetchall()[0][1]
self.model = QSqlTableModel(parent=self.window, db=self.db)
self.model.setTable(self.search_result)
self.db_record = QSqlRecord(self.db.record(self.search_result))
self.tableView = QTableView()
def on(self):
"""
Метод для подключения и отображения подключенного каталога
:return: виджет self.window
"""
self.model.setEditStrategy(QSqlTableModel.OnManualSubmit)
self.model.select()
self.model.setHeaderData(-1, Qt.Horizontal,
self.db_record.fieldName(0))
vbox = QVBoxLayout()
self.tableView.setModel(self.model)
self.tableView.resizeColumnsToContents()
self.tableView.resizeRowsToContents()
for i in range(self.model.columnCount() + 2):
self.width += self.tableView.columnWidth(i)
for j in range(self.model.rowCount() + 1):
self.heigh += self.tableView.rowHeight(j)
self.tableView.resize(self.width + 50, self.heigh + 50)
vbox.addWidget(self.tableView)
self.window.setLayout(vbox)
self.window.resize(self.tableView.width() + 30,
self.tableView.height() + 120)
return self.window
class VernierUpdate(QWidget):
def __init__(self, parent=None):
super(VernierUpdate, self).__init__(parent)
wl_coarse = np.linspace(1480, 1600, 60001)
self.fig_coarse = FigureWithToolbar(width=7, height=4)
self.fig_coarse.set_limits(ylim=(-30, 5), auto_x=True, auto_y=False)
self.fig_coarse.set_labels('Wavelength [nm]', 'Transmission [dB]')
self.fig_coarse.plot_line(wl_coarse,
np.zeros_like(wl_coarse),
label='Vernier')
wl_fine = np.linspace(1540, 1541, 201)
self.fig_fine = FigureWithToolbar(width=7, height=4)
self.fig_fine.set_limits(ylim=(-1, 0), auto_x=True, auto_y=False)
self.fig_fine.set_labels('Wavelength [nm]', 'Transmission [dB]')
self.fig_fine.plot_line(wl_fine, np.zeros_like(wl_fine), label='MRR1')
self.fig_fine.plot_line(wl_fine, np.zeros_like(wl_fine), label='MRR2')
self.fig_fine.plot_line(wl_fine,
np.zeros_like(wl_fine),
label='Vernier')
self.peaks_model = PandasModel(
pd.DataFrame({
'Peak wl [nm]': np.full((5, ), fill_value=np.nan),
'Peak lvl [dB]': np.full((5, ), fill_value=np.nan)
}))
self.peaks_table = QTableView()
self.peaks_table.setModel(self.peaks_model)
self.peaks_table.setMinimumWidth(160)
layout = QHBoxLayout()
layout.addWidget(self.fig_coarse)
layout.addWidget(self.fig_fine)
layout.addWidget(self.peaks_table)
self.setLayout(layout)
@Slot(object, object)
def update_coarse(self, wl, transmission):
self.fig_coarse.update_in_place((wl, ), (transmission, ))
@Slot(float)
def update_fine(self, wl, fine_1, fine_2, fine_vernier):
# New fine wavelength range
self.fig_fine.update_in_place((wl, wl, wl),
(fine_1, fine_2, fine_vernier))
self.fig_fine.update_axes()
@Slot()
def update_table(self, df):
self.peaks_model.set_data(df)
self.peaks_table.updateGeometry()
class MainWindow(QMainWindow):
"""
Class responsible for displaying primary interface.
"""
def __init__(self):
super().__init__()
self.table = QTableView()
self.model = QSqlTableModel(db=db)
self.table.setModel(self.model)
self.model.setTable("hello")
self.model.select()
self.setCentralWidget(self.table)
class TableWidget(QWidget):
def __init__(self, data):
QWidget.__init__(self)
self.model = CustomTableModel(data)
self.table_view = QTableView()
self.table_view.setModel(self.model)
self.table_view.horizontalHeader().setSectionResizeMode(QHeaderView.Stretch)
self.table_view.verticalHeader().setSectionResizeMode(QHeaderView.Stretch)
self.table_view.setMinimumSize(400, 600)
self.chart = QtCharts.QChart()
self.chart.setAnimationOptions(QtCharts.QChart.AllAnimations)
self.init_data()
self.chart.createDefaultAxes()
self.chart_view = QtCharts.QChartView(self.chart)
self.chart_view.setRenderHint(QPainter.Antialiasing)
self.chart_view.setMinimumSize(800, 600)
# create main layout
self.main_layout = QGridLayout()
self.main_layout.addWidget(self.table_view, 1, 0)
self.main_layout.addWidget(self.chart_view, 1, 1)
self.main_layout.setColumnStretch(1, 2)
self.main_layout.setColumnStretch(0, 1)
self.setLayout(self.main_layout)
def add_series(self, name, columns):
self.series = QtCharts.QLineSeries()
self.series.setName(name)
self.mapper = QtCharts.QVXYModelMapper(self)
self.mapper.setXColumn(columns[0])
self.mapper.setYColumn(columns[1])
self.mapper.setSeries(self.series)
self.mapper.setModel(self.model)
self.chart.addSeries(self.series)
# for storing color hex from the series
seriesColorHex = "#000000"
# get the color of the series and use it for showing the mapped area
seriesColorHex = "{}".format(self.series.pen().color().name())
self.model.add_mapping(seriesColorHex,
QRect(columns[0], 0, 2, self.model.rowCount()))
def init_data(self):
for i in range(int(self.model.columnCount()/2)):
self.add_series("Line {}".format(i+1), [i*2, (i*2)+1])
def testReferenceCounting(self):
'''Tests reference count of model object referred by view objects.'''
model1 = TestModel()
refcount1 = getrefcount(model1)
view1 = QTableView()
view1.setModel(model1)
self.assertEqual(getrefcount(view1.model()), refcount1 + 1)
view2 = QTableView()
view2.setModel(model1)
self.assertEqual(getrefcount(view2.model()), refcount1 + 2)
model2 = TestModel()
view2.setModel(model2)
self.assertEqual(getrefcount(view1.model()), refcount1 + 1)
if __name__ == '__main__':
# Create the Qt Application
app = QApplication(sys.argv)
#get all ip adresses in the lan
host_list = get_neighbors()
print(host_list)
col_getter = [ {"Name": "Dev", "Getter": lambda aHostItem: aHostItem["dev"]},
{"Name": "Ip", "Getter": lambda aHostItem: aHostItem["ip"]},
{"Name": "Mac", "Getter": lambda aHostItem: aHostItem["mac"]}, ]
host_table = QTableView()
host_model = HostModel(host_list, col_getter, host_table)
host_table.setModel(host_model)
host_table.show()
# Run the main Qt loop
sys.exit(app.exec_())
def testModelWithParent(self):
view = QTableView()
model = TestModel(None)
view.setModel(model)
samemodel = view.model()
self.assertEqual(model, samemodel)
