class MeasuredDataModel(QObject):
def __init__(self, calculator, parent=None):
super().__init__(parent)
self._project_dict = calculator.asDict()
self._headers_model = QStandardItemModel()
self._data_model = QStandardItemModel()
self._setModelsFromProjectDict()
def _setModelsFromProjectDict(self):
"""Create the model needed for GUI calculated data table and chart."""
self._data_model.setColumnCount(0) # faster than clear()
self._headers_model.setRowCount(0) # faster than clear()
for experiment_id, experiment_dict in self._project_dict[
'experiments'].items():
headers = []
for data_id, data_list in experiment_dict['measured'].items(
): # or measured_pattern as calculated_pattern in another class?
item = QStandardItem()
item.setData(data_id, Qt.DisplayRole)
headers.append(item)
column = []
for value in data_list:
item = QStandardItem()
item.setData(value, Qt.DisplayRole)
column.append(item)
self._data_model.appendColumn(column)
self._headers_model.appendRow(headers)
def asHeadersModel(self):
"""Return headers model."""
return self._headers_model
def asDataModel(self):
"""Return data model."""
return self._data_model
class QCampaignList(QListView):
def __init__(self):
super(QCampaignList, self).__init__()
self.model = QStandardItemModel(self)
self.setModel(self.model)
self.setMinimumWidth(250)
self.setMinimumHeight(350)
self.campaigns = []
self.setSelectionBehavior(QAbstractItemView.SelectItems)
self.setup_content()
def setup_content(self):
for i, campaign in enumerate(CAMPAIGNS):
self.campaigns.append(campaign)
item = QCampaignItem(*campaign)
self.model.appendRow(item)
self.setSelectedCampaign(0)
self.repaint()
def setSelectedCampaign(self, row):
self.selectionModel().clearSelection()
index = self.model.index(row, 0)
if not index.isValid():
index = self.model.index(0, 0)
self.selectionModel().setCurrentIndex(index,
QItemSelectionModel.Select)
self.repaint()
def clear_layout(self):
self.model.removeRows(0, self.model.rowCount())
class QCampaignList(QListView):
CampaignRole = Qt.UserRole
def __init__(self, campaigns: list[Campaign],
show_incompatible: bool) -> None:
super(QCampaignList, self).__init__()
self.campaign_model = QStandardItemModel(self)
self.setModel(self.campaign_model)
self.setMinimumWidth(250)
self.setMinimumHeight(350)
self.campaigns = campaigns
self.setSelectionBehavior(QAbstractItemView.SelectItems)
self.setup_content(show_incompatible)
@property
def selected_campaign(self) -> Campaign:
return self.currentIndex().data(QCampaignList.CampaignRole)
def setup_content(self, show_incompatible: bool) -> None:
self.selectionModel().blockSignals(True)
try:
self.campaign_model.clear()
for campaign in self.campaigns:
if show_incompatible or campaign.is_compatible:
item = QCampaignItem(campaign)
self.campaign_model.appendRow(item)
finally:
self.selectionModel().blockSignals(False)
self.selectionModel().setCurrentIndex(
self.campaign_model.index(0, 0, QModelIndex()),
QItemSelectionModel.Select)
class QInfoList(QListView):
def __init__(self, game: Game):
super(QInfoList, self).__init__()
self.model = QStandardItemModel(self)
self.setModel(self.model)
self.game = game
self.update_list()
self.selectionModel().setCurrentIndex(self.indexAt(QPoint(1, 1)),
QItemSelectionModel.Select)
self.selectionModel().selectionChanged.connect(
self.on_selected_info_changed)
def on_selected_info_changed(self):
index = self.selectionModel().currentIndex().row()
def update_list(self):
self.model.clear()
if self.game is not None:
for i, info in enumerate(reversed(self.game.informations)):
self.model.appendRow(QInfoItem(info))
self.selectionModel().setCurrentIndex(self.indexAt(QPoint(1, 1)),
QItemSelectionModel.Select)
def setGame(self, game):
self.game = game
self.update_list()
class FileListWidget(QWidget):
def __init__(self) -> None:
QWidget.__init__(self)
# self.index stores the index of the latest item which is clicked
self.index = None
self.model = QStandardItemModel()
file_view = QListView()
file_view.setModel(self.model)
file_view.setEditTriggers(QAbstractItemView.NoEditTriggers)
file_view.clicked.connect(self.onClicked)
file_view.doubleClicked.connect(self.onDoubleClicked)
open_file_button = QPushButton('Open')
open_file_button.clicked.connect(self.onOpenFile)
preview_file_button = QPushButton('Preview')
preview_file_button.clicked.connect(self.onPreviewFile)
layout = QGridLayout()
layout.addWidget(file_view, 0, 0, 1, 2)
layout.addWidget(open_file_button, 1, 0, 1, 1)
layout.addWidget(preview_file_button, 1, 1, 1, 1)
layout.setMargin(0)
self.setLayout(layout)
def clear(self):
self.model.clear()
def appendRow(self, item: QStandardItem):
self.model.appendRow(item)
def onDoubleClicked(self, index: QModelIndex):
# Update self.index and open the file in browser
self.index = index
item = self.model.itemFromIndex(self.index)
url = item.data(-1)
QDesktopServices.openUrl(url)
def onClicked(self, index: QModelIndex):
# Update self.index
self.index = index
def onOpenFile(self):
# Open file in browser
if self.index is not None:
item = self.model.itemFromIndex(self.index)
url = item.data(-1)
QDesktopServices.openUrl(url)
def onPreviewFile(self):
# User Office 365 Api to preview word/powerpoint/excel documents in browser
if self.index is not None:
item = self.model.itemFromIndex(self.index)
url = 'http://view.officeapps.live.com/op/view.aspx?src=' + item.data(
-1)
print(url)
QDesktopServices.openUrl(url)
def setTarget(self, target):
self.setTitle(target.name)
self.strike_target_infos = target
model = QStandardItemModel()
self.listView.setSelectionMode(QAbstractItemView.NoSelection)
if len(self.strike_target_infos.units) > 0:
dic = {}
for u in self.strike_target_infos.units:
if u.type in dic.keys():
dic[u.type] = dic[u.type] + 1
else:
dic[u.type] = 1
for k, v in dic.items():
model.appendRow(QStandardItem(k + " x " + str(v)))
print(k + " x " + str(v))
else:
dic = {}
for b in self.strike_target_infos.buildings:
id = b.dcs_identifier
if b.is_dead:
id = id + "[Destroyed]"
if id in dic.keys():
dic[id] = dic[id] + 1
else:
dic[id] = 1
for k, v in dic.items():
model.appendRow(QStandardItem(k + " x " + str(v)))
print(k + " x " + str(v))
self.listView.setModel(model)
def __init__(self, title, message, items, parent=None):
"""
Constructor of ListerView which creates a new dialog with
scrolled items which the user can mark
Args:
title (str): The dialog title that should appear
message (str): The message that the user will see at the top of the dialog
items ([str]): A list of strings that will be showns as options
"""
super(ListerView, self).__init__(parent=parent)
form = QFormLayout(self)
form.addRow(QLabel(message))
self.listView = QListView(self)
self.listView.clicked.connect(self.mouse_click_event)
form.addRow(self.listView)
model = QStandardItemModel(self.listView)
self.setWindowTitle(title)
for item in items:
standardItem = QStandardItem(item)
standardItem.setCheckable(True)
standardItem.setEditable(False)
model.appendRow(standardItem)
self.listView.setModel(model)
class MainWindow(QMainWindow, Ui_MainWindow):
"""Main application window for Qud Blueprint Explorer."""
def __init__(self, app: QApplication, *args, **kwargs):
super(MainWindow, self).__init__(*args, **kwargs)
self.app = app
self.setupUi(self)
icon = QIcon("spray_bottle.png")
self.setWindowIcon(icon)
self.qud_object_model = QStandardItemModel()
# We only need to add Object to the model, since all other Objects are loaded as children:
self.qud_object_model.appendRow(
self.init_qud_object(self.qud_object_model, qud_object_root))
self.treeView.setModel(self.qud_object_model)
self.treeView.clicked[QModelIndex].connect(self.tree_item_clicked)
def init_qud_object(self, model: QStandardItemModel,
qud_object: QudObject):
item = QStandardItem(qud_object.name)
if not qud_object.is_leaf:
for child in qud_object.children:
item.appendRow(self.init_qud_object(model, child))
if qud_object.is_specified('tag_BaseObject'):
item.setSelectable(False)
item.setData(qud_object)
return item
def tree_item_clicked(self, index):
item = self.qud_object_model.itemFromIndex(index)
qud_object = item.data()
text = pprint.pformat(qud_object.attributes)
self.plainTextEdit.setPlainText(text)
def set_data(self, object_icons, object_class_names, object_names,
object_names_dict):
for i, object_class_name in enumerate(object_class_names):
combo = QComboBox(self)
model = QStandardItemModel()
icon = object_icons[i]
qitem = QStandardItem(icon, object_class_name)
qitem.setFlags(~Qt.ItemIsSelectable)
model.appendRow(qitem)
all_object_names = object_names_dict[object_class_name]
for object_name in all_object_names:
qitem = QStandardItem(object_name)
model.appendRow(qitem)
combo.setModel(model)
combo.insertSeparator(1)
combo.activated.connect(
lambda index, i=i: self.remove_missing_dimension(i))
self.layout().addWidget(combo)
self.combos.append(combo)
try:
object_name = object_names[i]
except IndexError:
self.missing_dimensions.add(i)
continue
if object_name:
combo.setCurrentText(object_name)
else:
self.missing_dimensions.add(i)
def model(self) -> QStandardItemModel:
items: List[QTreeWidgetItem] = \
self.findItems('*', Qt.MatchWrap | Qt.MatchWildcard | Qt.MatchRecursive)
model = QStandardItemModel()
def standardItem(w: QTreeWidgetItem) -> QStandardItem:
s = QStandardItem()
s.setData(w.data(0, Qt.DisplayRole), Qt.DisplayRole)
s.setData(w.data(1, Qt.UserRole), Qt.UserRole)
s.setData(w.data(0, Qt.ToolTipRole), Qt.ToolTipRole)
return s
def filterItems(item: QTreeWidgetItem) -> bool:
op_class: type = item.data(1, Qt.UserRole)
keep: bool = bool(item.parent())
if keep and issubclass(op_class, GraphOperation):
keep &= op_class.minInputNumber() == op_class.maxInputNumber() == 1 \
and op_class.minOutputNumber() == 1
else:
keep &= item.isHidden()
return keep
items = list(map(standardItem, filter(filterItems, items)))
for i in items:
model.appendRow(i)
return model
def add_item2model(self, filename: str, model: QStandardItemModel):
"""sample listview code"""
list_item = QStandardItem(filename)
list_item.setCheckable(True)
list_item.setEditable(False)
list_item.setSelectable(False)
model.appendRow(list_item)
def __init__(self, model, tabWidget, parent=None):
super(ChartWidget, self).__init__(parent)
self.model = model
self.tabWidget = tabWidget
layout = QVBoxLayout(self)
chartGroupBox = QGroupBox("General Settings")
grid = QGridLayout(self)
grid.addWidget(QLabel("Name"), 0, 0)
self.nameLineEdit = QLineEdit()
self.nameLineEdit.setText(model.text())
self.nameLineEdit.textChanged.connect(self.updateText)
grid.addWidget(self.nameLineEdit, 0, 1)
self.typeComboBox = QComboBox()
self.typeComboBox.currentIndexChanged.connect(self.changeType)
grid.addWidget(self.typeComboBox, 1, 1)
chartGroupBox.setLayout(grid)
layout.addWidget(chartGroupBox)
self.chartWidget = QWidget()
layout.addWidget(self.chartWidget)
# using to dynamically add and remove chart settings/preview widgets
self.stackedWidget = QStackedWidget(self)
layout.addWidget(self.stackedWidget)
# layout.addStretch()
self.setLayout(layout)
# adding type values here is a violation of object-oriented design
# a more polymorphic implementation is desirable
chartTypesLst = [
('Bar Chart', "icons/chart-types/bar-chart.svg", BarChartModel),
('Box Plot', "icons/chart-types/box-plot.svg", None),
('Candlestick Chart', "icons/chart-types/candlestick-chart.svg",
None),
('Line Chart', "icons/chart-types/line-chart.svg", LineChartModel),
('Pie Chart', "icons/chart-types/pie-chart.svg", None),
('Scatter Chart', "icons/chart-types/scatter-chart.svg", None),
('Spline Chart', "icons/chart-types/spline-chart.svg", None)
]
s = QStandardItemModel()
for ct in chartTypesLst:
item = QStandardItem(ct[0])
item.setIcon(QIcon(ct[1]))
item.setData(ct[2])
s.appendRow(item)
self.typeComboBox.setModel(s)
def setTarget(self, target: SEADTargetInfo):
self.setTitle(target.name)
self.sead_target_infos = target
radar_list_model = QStandardItemModel()
self.radar_list.setSelectionMode(QAbstractItemView.NoSelection)
for r in self.sead_target_infos.radars:
radar_list_model.appendRow(QStandardItem(r.type))
self.radar_list.setModel(radar_list_model)
def read(self, index):
putanja = self.dock.model.filePath(index)
if os.path.isdir(putanja):
return
ista_putanja = False
for i in range(len(self.lista_putanja)):
if putanja == self.lista_putanja[i]:
ista_putanja = True
return
if not ista_putanja:
self.lista_putanja.append(putanja)
if putanja.find(".sql") != -1:
self.connection = mysql.connector.connect(user="******", password="******", host="127.0.0.1", database="projekat")
self.csor = self.connection.cursor()
putanja = "podaci\metaPodaci\projekat_meta_podaci.csv"
meta_podaci = citanje_meta_podataka(putanja, True)
self.imena_tabela = meta_podaci[4].split(",")
self.treeView = QTreeView()
self.treeView.setContextMenuPolicy(Qt.CustomContextMenu)
self.treeView.customContextMenuRequested.connect(self.dugme_baza)
model = QStandardItemModel(parent=self.dock.tree.sub_layout)
item = QStandardItem("zatvori")
item.setEditable(False)
model.appendRow(item)
for text in self.imena_tabela:
item = QStandardItem(text)
item.setEditable(False)
model.appendRow(item)
self.treeView.setModel(model)
self.treeView.clicked.connect(self.dugme_baza)
self.treeView.PositionAtBottom
si = self.dock.tree.sub_layout.sizeHint()
si.setWidth(self.dock.width())
si.setHeight(200)
self.treeView.setFixedSize(si.width(), si.height())
self.treeView.setHeaderHidden(True)
self.dock.tree.sub_layout.addWidget(self.treeView)
self.dock.tree.sub_layout.setAlignment(self.treeView, QtCore.Qt.AlignBottom)
return
tab = Tab(putanja, parent=self.central_widget)
tab.pocetna_strana = self
if putanja != "":
tab.read()
else:
tab.read(putanja)
tab.btn_down.clicked.connect(self.otvori_tabelu_dete)
tab.btn_up.clicked.connect(self.otvori_tabelu_roditelj)
tab.naziv = tab.meta_podaci[0]
self.central_widget.addTab(tab, tab.naziv)
self.central_widget.setCurrentIndex(self.central_widget.currentIndex()+1)
class TableViewAllStock(QTableView):
def __init__(self, parent=None):
super(TableViewAllStock, self).__init__(parent)
# self.mouseDoubleClickEvent()
self.doubleClicked.connect(self.slotDoubleClicked)
self.creatUI()
self.initData()
def creatUI(self):
self.model = QStandardItemModel()
self.setModel(self.model)
self.verticalHeader().setSectionResizeMode(QHeaderView.Fixed)
self.verticalHeader().setDefaultSectionSize(8)
self.verticalHeader().hide()
self.setSelectionBehavior(QAbstractItemView.SelectRows)
self.setEditTriggers(QTableView.NoEditTriggers)
self.setShowGrid(True)
arr = ["代码", "名称", "日期", "最新价", "涨跌幅", "涨跌额", "成交量(手)", "成交额", "振幅", "最高", "最低", "今开", "换手率"]
self.model.setColumnCount(len(arr))
for i in range(len(arr)):
self.model.setHeaderData(i, Qt.Horizontal, arr[i])
def Item(self, var):
item = QStandardItem(str(var))
item.setTextAlignment(Qt.AlignVCenter|Qt.AlignHCenter);
return item
def initData(self):
kline = Kline()
#kline.setYear(2021)
res = kline.getLatestKlineData()
for row in res:
items = []
items.append(self.Item(row['code']))
items.append(self.Item(row['SEC_NAME']))
items.append(self.Item(row['date']))
items.append(self.Item(row['close']))
items.append(self.Item(str(row['p_change'])+'%'))
items.append(self.Item(row['price_change']))
items.append(self.Item(row['amount']))
items.append(self.Item(row['turnover']))
items.append(self.Item(str(row['amplitude'])+'%'))
items.append(self.Item(row['high']))
items.append(self.Item(row['low']))
items.append(self.Item(row['open']))
items.append(self.Item(str(row['exchange'])+'%'))
self.model.appendRow(items)
# QModelIndex index
def slotDoubleClicked(self, index):
code = self.model.index(index.row(), 0).data();
name = self.model.index(index.row(), 1).data();
d = KlineWidget(self)
d.setWindowTitle("%s(%s)"%(code, name))
d.exec()
def fill_list_view(self):
values = c.get_all()
model = QStandardItemModel()
self.ui.listView.setModel(model)
for i, number, text in values:
line = "{}: {}, {}".format(i, number, text)
item = QStandardItem(line)
model.appendRow(item)
class MainWindow(QWidget):
def __init__(self):
super(MainWindow, self).__init__()
#self.setStyleSheet(GREEN)
self.layout = QVBoxLayout(self)
self.settings_dict = get_settings()
self.options_list = get_options()
self.init_ui()
def init_ui(self):
self.button = PButton("Generate...")
#settings = get_conan_config() # should be a tree?
self.recipeBox = RecipeBox("HPS")
self.settings = SettingsBox("Settings")
self.layout.addWidget(self.recipeBox)
self.options = OptionsBox("Options")
self.deps = DepsBox("Dependencies")
self.recipeBox.layout.addWidget(self.settings)
self.recipeBox.layout.addWidget(self.deps)
self.recipeBox.layout.addWidget(self.options)
for k, v in self.settings_dict.items():
self.settings.layout.addWidget(QLabel("%s : %s" % (k, v)))
option_list_view = QListView()
self.options_model = QStandardItemModel(option_list_view)
for item in self.options_list:
#TODO: Clean this up and get it out of ui init before it gets out of hand
opt = item.split(":")
v = opt.pop().strip()
k = ":".join(opt)
self.individual_option = QStandardItem(k)
self.individual_option.setCheckable(True)
self.individual_option.setEditable(False)
if v == "True":
self.individual_option.setCheckState(Qt.Checked)
self.options_model.appendRow(self.individual_option)
option_list_view.setModel(self.options_model)
option_list_view.setAlternatingRowColors(True)
self.options.layout.addWidget(option_list_view)
self.layout.addWidget(self.button)
self.setWindowTitle("PynCon")
self.button.clicked.connect(self.button_click)
self.show()
def button_click(self):
self.options.layout.addWidget(QLabel("poop"))
for index in range(self.options_model.rowCount()):
item = self.options_model.item(index)
if item.isCheckable() and item.checkState() == Qt.Checked:
USER_OPTIONS.update({item.text(): "True"})
else:
USER_OPTIONS.update({item.text(): "False"})
conan_command(USER_OPTIONS)
def add_prototype(window, parent_item: QtGui.QStandardItemModel, prot_name,
prot_class, parent_name):
prototype_name = QtGui.QStandardItem(QtGui.QIcon(window.gearIconLight),
prot_name)
prototype_name.setEditable(False)
prototype_class = QtGui.QStandardItem(prot_class)
prototype_class.setEditable(False)
prototype_parent = QtGui.QStandardItem(parent_name)
prototype_parent.setEditable(False)
parent_item.appendRow([prototype_name, prototype_class, prototype_parent])
class UrlCompleter(QCompleter):
def __init__(self, parent=None):
super(UrlCompleter, self).__init__(parent)
self.model = QStandardItemModel()
self.setModel(self.model)
self.setCompletionRole(Qt.EditRole)
self.setCaseSensitivity(Qt.CaseInsensitive)
def addItem(self, reqObject):
self.model.appendRow(QStandardItem(reqObject.url))
self.model.appendRow(QStandardItem(reqObject.buildUrl()))
def fillListView(self, listView, category):
items = self.graphManager.graphCategoryToNamesMap.get(category)
if items == None:
return
model = QStandardItemModel()
listView.setModel(model)
for item in items:
sItem = QStandardItem(item)
model.appendRow(sItem)
class ListDialogView(QDialog):
"""Property Dialog View"""
hover_index_changed = Signal(QModelIndex)
def __init__(self, dialog_model, dialog_controller):
settings = Qt.Window | Qt.FramelessWindowHint | Qt.WindowStaysOnTopHint
super(ListDialogView, self).__init__(None, settings)
self.setAttribute(Qt.WA_TranslucentBackground)
self._model = dialog_model
self._dialog_ctrl = dialog_controller
self._ui = Ui_ListDialog()
self._ui.setupUi(self)
delete_button_delegate = DeleteButtonDelegate(self)
self._commodity_model = QStandardItemModel(0, 2, self._ui.commodity_list)
for commodity in self._model:
self._commodity_model.appendRow([QStandardItem(str(commodity)), QStandardItem()])
"""connect widgets to controller"""
self._ui.button_add.clicked.connect(self.add_list_item)
self._ui.commodity_list.clicked.connect(self.remove_list_item)
self._ui.commodity_list.hover_index_changed.connect(delete_button_delegate.on_hover_index_changed)
self.accepted.connect(self.on_dialog_accepted)
self._ui.cancel_button.clicked.connect(self.reject)
self._ui.apply_button.clicked.connect(self.accept)
"""initialize view"""
self._ui.commodity_name.set_model(PropertyLineEdit(""))
self._ui.commodity_list.setModel(self._commodity_model)
self._ui.commodity_list.setItemDelegateForColumn(1, delete_button_delegate)
self._ui.commodity_list.horizontalHeader().setSectionResizeMode(0, QHeaderView.Stretch)
self._ui.commodity_list.horizontalHeader().setSectionResizeMode(1, QHeaderView.Fixed)
self._ui.commodity_list.setColumnWidth(1, 22)
def add_list_item(self):
if self._ui.commodity_name.text() != "":
self._commodity_model.appendRow([QStandardItem(self._ui.commodity_name.text()), QStandardItem()])
self._ui.commodity_name.set_model(PropertyLineEdit(""))
def remove_list_item(self, index):
if index.column() == 1:
self._commodity_model.removeRow(index.row())
def on_dialog_accepted(self):
"""transfer edited data to model"""
self._dialog_ctrl.transfer_data(self._commodity_model)
def keyPressEvent(self, event):
"""prevent dialog closing with enter or return key"""
if event.key() == Qt.Key_Enter or event.key() == Qt.Key_Return:
return
super().keyPressEvent(event)
def testIntDelegate(self):
"""PYSIDE-1250: When creating a QVariant, use int instead of long long
for anything that fits into a int. Verify by checking that a spin
box is created as item view editor for int."""
item = QStandardItem()
item.setData(123123, Qt.EditRole) # <-- QVariant conversion here
model = QStandardItemModel()
model.appendRow(item)
style_option = QStyleOptionViewItem()
delegate = QStyledItemDelegate()
editor = delegate.createEditor(None, style_option, model.index(0, 0))
self.assertEqual(type(editor), QSpinBox)
def run(self):
model = QStandardItemModel()
for image in self.getImageFolderContents(
self.folder.data(role=Qt.UserRole)):
url = os.path.join(ThemeManager.IMAGE_FOLDERS_PATH,
self.folder.data(role=Qt.UserRole), image)
item = QStandardItem(image)
item.setData(url, role=Qt.UserRole)
model.appendRow(item)
self.modelFinished.emit(model)
def _create_model(parent, serialized_bookmarks):
result = QStandardItemModel(0, 1, parent)
last_folder_item = None
for entry in serialized_bookmarks:
if len(entry) == 1:
last_folder_item = _create_folder_item(entry[0])
result.appendRow(last_folder_item)
else:
url = QUrl.fromUserInput(entry[0])
title = entry[1]
icon = QIcon(entry[2]) if len(entry) > 2 and entry[2] else None
last_folder_item.appendRow(_create_item(url, title, icon))
return result
class AircraftTypeList(QListView):
page_index_changed = Signal(int)
def __init__(self, air_wing: AirWing) -> None:
super().__init__()
self.setIconSize(QSize(91, 24))
self.setMinimumWidth(300)
self.item_model = QStandardItemModel(self)
self.setModel(self.item_model)
self.selectionModel().setCurrentIndex(self.item_model.index(0, 0),
QItemSelectionModel.Select)
self.selectionModel().selectionChanged.connect(
self.on_selection_changed)
for aircraft in air_wing.squadrons:
self.add_aircraft_type(aircraft)
def remove_aircraft_type(self, aircraft: AircraftType):
for item in self.item_model.findItems(aircraft.name):
self.item_model.removeRow(item.row())
self.page_index_changed.emit(
self.selectionModel().currentIndex().row())
def add_aircraft_type(self, aircraft: AircraftType):
aircraft_item = QStandardItem(aircraft.name)
icon = self.icon_for(aircraft)
if icon is not None:
aircraft_item.setIcon(icon)
aircraft_item.setEditable(False)
aircraft_item.setSelectable(True)
self.item_model.appendRow(aircraft_item)
def on_selection_changed(self, selected: QItemSelection,
_deselected: QItemSelection) -> None:
indexes = selected.indexes()
if len(indexes) > 1:
raise RuntimeError(
"Aircraft list should not allow multi-selection")
if not indexes:
return
self.page_index_changed.emit(indexes[0].row())
@staticmethod
def icon_for(aircraft: AircraftType) -> Optional[QIcon]:
name = aircraft.dcs_id
if name in AIRCRAFT_ICONS:
return QIcon(AIRCRAFT_ICONS[name])
return None
def __set_tableview(self, data: dict):
model = QStandardItemModel()
model.setColumnCount(2)
model.setHorizontalHeaderLabels(["Name", "Type"])
for single_name_data in data:
item_name = QStandardItem(single_name_data)
item_name.setEditable(False)
item_value = QStandardItem(str(data[single_name_data]))
item_value.setEditable(False)
model.appendRow([item_name, item_value])
self.ui.tableView_result_type_and_size.setModel(model)
def init_ui(self):
vbox = QVBoxLayout()
self.setLayout(vbox)
lv = QListView()
lv.clicked.connect(self.on_clicked)
vbox.addWidget(lv)
model = QStandardItemModel(lv)
lv.setModel(model)
for food in self.foods:
item = QStandardItem(food)
item.setCheckable(True)
model.appendRow(item)
class FolderList(QListView):
def __init__(self):
super().__init__()
# Objects
self.brush = QBrush()
self.folderModel = QStandardItemModel()
# Styling
self.setModel(self.folderModel)
self.setFrameStyle(QFrame.NoFrame)
self.setEditTriggers(QAbstractItemView.NoEditTriggers)
self.setHorizontalScrollBarPolicy(Qt.ScrollBarAlwaysOff)
self.setVerticalScrollBarPolicy(Qt.ScrollBarAlwaysOff)
self.setItemDelegate(ListDelegate.ListDelegate())
self.setAttribute(Qt.WA_TranslucentBackground)
self.brush.setColor(ThemeManager.BG_QC)
self.brush.setStyle(Qt.SolidPattern)
self.populate()
def populate(self):
for idx, folder in enumerate(self.getImageFolders()):
item = QStandardItem(folder)
item.setData(folder.replace('imgur', '').replace('reddit_sub', '').replace('_', ''), role=Qt.DisplayRole)
item.setData(folder, role=Qt.DisplayRole)
item.setData(os.path.join(ThemeManager.IMAGE_FOLDERS_PATH, folder), role=Qt.UserRole)
item.setData(folder, role=Qt.UserRole+1)
self.folderModel.appendRow(item)
def getImageFolders(self):
contents = map(lambda f: f.name, os.scandir(ThemeManager.IMAGE_FOLDERS_PATH))
yield from filter(lambda f: os.path.isdir(os.path.join(ThemeManager.IMAGE_FOLDERS_PATH, f)), contents)
def mouseReleaseEvent(self, event):
if event.button() == Qt.LeftButton:
index = self.indexAt(event.pos())
if index.isValid():
self.selectedFolderChanged.emit(index)
def paintEvent(self, event):
painter = QPainter(self.viewport())
painter.setBrush(self.brush)
painter.setPen(Qt.NoPen)
painter.drawRect(event.rect())
super().paintEvent(event)
selectedFolderChanged = Signal(object)
class QFlightWaypointList(QTableView):
def __init__(self, flight: Flight):
super(QFlightWaypointList, self).__init__()
self.model = QStandardItemModel(self)
self.setModel(self.model)
self.horizontalHeader().setSectionResizeMode(QHeaderView.Stretch)
self.model.setHorizontalHeaderLabels(["Name", "Alt"])
header = self.horizontalHeader()
header.setSectionResizeMode(0, QHeaderView.ResizeToContents)
self.flight = flight
if len(self.flight.points) > 0:
self.selectedPoint = self.flight.points[0]
self.update_list()
self.selectionModel().setCurrentIndex(self.indexAt(QPoint(1, 1)),
QItemSelectionModel.Select)
self.selectionModel().selectionChanged.connect(
self.on_waypoint_selected_changed)
def on_waypoint_selected_changed(self):
index = self.selectionModel().currentIndex().row()
def update_list(self):
self.model.clear()
self.model.setHorizontalHeaderLabels(["Name", "Alt"])
takeoff = FlightWaypoint(self.flight.from_cp.position.x,
self.flight.from_cp.position.y, 0)
takeoff.description = "Take Off"
takeoff.name = takeoff.pretty_name = "Take Off from " + self.flight.from_cp.name
self.model.appendRow(QWaypointItem(takeoff, 0))
item = QStandardItem("0 feet AGL")
item.setEditable(False)
self.model.setItem(0, 1, item)
for i, point in enumerate(self.flight.points):
self.model.insertRow(self.model.rowCount())
self.model.setItem(self.model.rowCount() - 1, 0,
QWaypointItem(point, i + 1))
item = QStandardItem(
str(meter_to_feet(point.alt)) + " ft " +
str(["AGL" if point.alt_type == "RADIO" else "MSL"][0]))
item.setEditable(False)
self.model.setItem(self.model.rowCount() - 1, 1, item)
self.selectionModel().setCurrentIndex(self.indexAt(QPoint(1, 1)),
QItemSelectionModel.Select)
class QPlannedFlightsView(QListView):
def __init__(self, game_model: GameModel, cp: ControlPoint) -> None:
super(QPlannedFlightsView, self).__init__()
self.game_model = game_model
self.cp = cp
self.model = QStandardItemModel(self)
self.setModel(self.model)
self.flight_items = []
self.setIconSize(QSize(91, 24))
self.setSelectionBehavior(QAbstractItemView.SelectItems)
self.set_flight_planner()
def setup_content(self):
self.flight_items = []
for package in self.game_model.ato_model.packages:
for flight in package.flights:
if flight.from_cp == self.cp:
item = QFlightItem(package.package, flight)
self.flight_items.append(item)
self.flight_items.sort(key=self.mission_start_for_flight)
for item in self.flight_items:
self.model.appendRow(item)
self.set_selected_flight(0)
def set_selected_flight(self, row):
self.selectionModel().clearSelection()
index = self.model.index(row, 0)
if not index.isValid():
index = self.model.index(0, 0)
self.selectionModel().setCurrentIndex(index,
QItemSelectionModel.Select)
self.repaint()
def clear_layout(self):
self.model.removeRows(0, self.model.rowCount())
def set_flight_planner(self) -> None:
self.clear_layout()
self.setup_content()
@staticmethod
def mission_start_for_flight(flight_item: QFlightItem) -> timedelta:
return TotEstimator(flight_item.package).mission_start_time(
flight_item.flight)
def testOperators(self):
model = QStandardItemModel()
for i in range(100):
model.appendRow(QStandardItem("Item: %d"%i))
first = model.index(0, 0)
second = model.index(10, 0)
third = model.index(20, 0)
fourth = model.index(30, 0)
sel = QItemSelection(first, second)
sel2 = QItemSelection()
sel2.select(third, fourth)
sel3 = sel + sel2 #check operator +
self.assertEqual(len(sel3), 2)
sel4 = sel
sel4 += sel2 #check operator +=
self.assertEqual(len(sel4), 2)
self.assertEqual(sel4, sel3)
