def __init__(self, tag_number):
super().__init__()
print('processing query...')
qry = QSqlQuery(db)
query = 'SELECT name, ename, startno, starttime FROM name WHERE ecard = %i OR ecard2 = %i' % (
tag_number, tag_number)
qry.prepare(query)
qry.exec()
model = QSqlQueryModel()
model.setQuery(qry)
print(model.rowCount())
mapper = QDataWidgetMapper()
form = QFormLayout()
layout = QVBoxLayout()
first_name = QLineEdit()
start_number = QLineEdit()
form.addRow(QLabel("Startnummer"), start_number)
form.addRow(QLabel("Fornavn"), first_name)
mapper.setModel(model)
mapper.addMapping(first_name, 0)
mapper.addMapping(start_number, 2)
mapper.toFirst()
layout.addLayout(form)
widget = QWidget()
widget.setLayout(layout)
self.setCentralWidget(widget)
#controls = QHBoxLayout()
'''
def _biaocaozuo(self):
self.model = QtSql.QSqlTableModel()
self.model.setTable('BookData')
self.model.setEditStrategy(QSqlTableModel.OnManualSubmit) # 设置保存策略
self.table_view.setModel(self.model)
self.model.select()
self.model.setHeaderData(0, Qt.Horizontal, 'ISBN')
self.model.setHeaderData(1, Qt.Horizontal, '书名')
self.model.setHeaderData(2, Qt.Horizontal, '作者')
self.model.setHeaderData(3, Qt.Horizontal, '出版社')
self.model.setHeaderData(4, Qt.Horizontal, '出版日期')
self.model.setHeaderData(5, Qt.Horizontal, '评分')
self.model.setHeaderData(6, Qt.Horizontal, '照片')
self.table_view.setColumnHidden(6, True)
self.mapper = QDataWidgetMapper()
self.mapper.setModel(self.model)
self.mapper.setSubmitPolicy(QDataWidgetMapper.AutoSubmit)
self.mapper.addMapping(self.lineEdit_ISBN, 0)
self.mapper.addMapping(self.lineEdit_shuming, 1)
self.mapper.addMapping(self.lineEdit_zuozhe, 2)
self.mapper.addMapping(self.lineEdit_chubanshe, 3)
self.mapper.addMapping(self.lineEdit_chubanriqi, 4)
self.mapper.addMapping(self.lineEdit_pingfen, 5)
self.mapper.toFirst()
self.selModel = QItemSelectionModel(self.model) # 选择模型
self.table_view.setSelectionModel(self.selModel)
self.selModel.currentChanged.connect(
self.do_currentChanged) # 当前项变化时触发
self.selModel.currentRowChanged.connect(
self.do_currentRowChanged) # 选择行变化时
def threadSizeInit(self, index = 0):
self.sizeMapper = QDataWidgetMapper(self)
self.sizeModel = QSqlQueryModel(self)
form = self.threadFormLbl.text()
threadClass = self.threadClassLbl.text()
sizeSelect = "SELECT size, pitch, major_dia, \
min_major_dia, max_minor_dia, min_minor_dia, \
max_pitch_dia, min_pitch_dia FROM internal_threads WHERE form \
= '{}' AND class = '{}'".format(form, threadClass)
self.sizeModel.setQuery(sizeSelect)
self.sizeMapper.setModel(self.sizeModel)
self.sizeMapper.addMapping(self.threadSizeLbl, 0, b'text')
self.sizeMapper.addMapping(self.threadTPILbl, 1, b'text')
self.sizeMapper.addMapping(self.threadMajorDiaLbl, 2, b'text')
self.sizeMapper.addMapping(self.minMajorDiaLbl, 3, b'text')
self.sizeMapper.addMapping(self.maxMinorDiaLbl, 4, b'text')
self.sizeMapper.addMapping(self.minMinorDiaLbl, 5, b'text')
self.sizeMapper.addMapping(self.maxPitchDiaLbl, 6, b'text')
self.sizeMapper.addMapping(self.minPitchDiaLbl, 7, b'text')
self.sizeMapper.toLast()
self.sizeLast = self.sizeMapper.currentIndex()
self.sizeMapper.setCurrentIndex(index)
self.drillSizeInit()
self.threadSizeCalc()
self.numPassesCalc()
self.threadHeightCalc()
def __init__(self,
parent: QWidget,
tableName: str,
filter: str = None,
db=QtSql.QSqlDatabase()):
'''用于窗体模式进行数据编辑时的主窗体数据模型。\n
会自动增加数据映射器，但是外键字段要使用addComboBoxData方法增加列表文字。
最后要调用tofirst()方法定位编辑的记录。\n
注：数据映射器不能增删记录，只能编辑
'''
super().__init__(parent=parent, db=db)
self.parent = parent
self.setTable(tableName)
if filter:
self.setFilter(filter)
self.select()
rec = self.record()
self.mapper = QDataWidgetMapper(parent)
self.mapper.setModel(self)
self.mapper.setItemDelegate(_JPRelationalDelegate(parent, self.mapper))
self.mapper.setSubmitPolicy(QDataWidgetMapper.ManualSubmit)
for i in range(rec.count()):
widget = parent.findChild(self._tp, rec.fieldName(i))
if widget:
if not isinstance(widget, QComboBox):
self.mapper.addMapping(widget, i)
def __init__(self, employee_model, employee_controller, main_window):
super().__init__()
self.setupUi(self)
self.employee_model: EmployeeModel = employee_model
self.employee_controller: EmployeeController = employee_controller
self.main_window: MainWindowView = main_window
self.mapper = QDataWidgetMapper()
self.set_employee_editor()
def setup_treemodel(self, treerootNode=None, treetype='FsTree'):
if treetype=='FsTree':
treemodel = FsTreeModel(treerootNode)
else:
treemodel = VnTreeModel(treerootNode)
self.setModel(treemodel)
self.dataMapper = QDataWidgetMapper()
self.dataMapper.setModel(treemodel)
def __init__(self, student_model, student_controller, main_window):
super().__init__()
self.setupUi(self)
self.student_model: StudentModel = student_model
self.student_controller: StudentController = student_controller
self.main_window: MainWindowView = main_window
self.mapper = QDataWidgetMapper()
self.set_student_editor()
def __init__(self, parent):
super(MasternodeOutputsTab, self).__init__(parent)
self.dialog = parent
self.manager = parent.manager
include_frozen_checkbox = QCheckBox(_('Include frozen addresses'))
include_frozen_checkbox.setChecked(False)
self.scan_outputs_button = QPushButton(_('Scan For Masternode Outputs'))
def on_scan_outputs():
"""Call scan_for_outputs() with whether to include frozen addresses."""
self.scan_for_outputs(include_frozen_checkbox.isChecked())
self.scan_outputs_button.clicked.connect(on_scan_outputs)
self.status_edit = QLineEdit()
self.status_edit.setReadOnly(True)
self.valid_outputs_list = MasternodeOutputsWidget()
self.valid_outputs_list.outputSelected.connect(self.set_output)
self.collateral_edit = PrevOutWidget()
self.collateral_edit.setReadOnly(True)
self.mapper = QDataWidgetMapper()
self.mapper.setSubmitPolicy(QDataWidgetMapper.ManualSubmit)
self.mapper.setModel(self.dialog.masternodes_widget.proxy_model)
model = self.dialog.masternodes_widget.model
self.mapper.addMapping(self.collateral_edit, model.VIN, b'string')
self.save_output_button = QPushButton(_('Save'))
self.save_output_button.setEnabled(False)
self.save_output_button.clicked.connect(self.save_output)
vbox = QVBoxLayout()
desc = ' '.join(['Use this tab to scan for and choose a collateral payment for your masternode.',
'A valid collateral payment is exactly 1000 AXE.'])
desc = QLabel(_(desc))
desc.setWordWrap(True)
vbox.addWidget(desc)
status_box = QHBoxLayout()
status_box.setContentsMargins(0, 0, 0, 0)
status_box.addWidget(QLabel(_('Status:')))
status_box.addWidget(self.status_edit, stretch=1)
vbox.addLayout(status_box)
valid_outputs_box = QVBoxLayout()
valid_outputs_box.setContentsMargins(0, 0, 0, 0)
valid_outputs_box.addWidget(QLabel(_('Masternode Outputs:')))
valid_outputs_box.addWidget(self.valid_outputs_list)
vbox.addLayout(util.Buttons(include_frozen_checkbox, self.scan_outputs_button))
vbox.addLayout(valid_outputs_box)
vbox.addWidget(self.collateral_edit)
vbox.addLayout(util.Buttons(self.save_output_button))
self.setLayout(vbox)
def __init__(self, current_index, model):
super().__init__()
# uic.loadUi('editForm.ui', self)
self.setupUi(self)
# self.db = database
self.db_map = QDataWidgetMapper(self)
self.db_map.setModel(model)
self.db_map.setSubmitPolicy(QDataWidgetMapper.ManualSubmit)
self.db_map.addMapping(self.lineEdit_name, 1)
self.db_map.addMapping(self.lineEdit_inv_number, 2)
self.db_map.addMapping(self.textEdit_comments, 3)
self.db_map.addMapping(self.checkBox_on_balance,
model.fieldIndex('is_on_balance'))
relModel_status = model.relationModel(5)
self.comboBox_status.setModel(relModel_status)
self.comboBox_status.setModelColumn(
relModel_status.fieldIndex("status_name"))
self.db_map.setItemDelegate(QSqlRelationalDelegate(self))
self.db_map.addMapping(self.comboBox_status, 5)
relModel_type = model.relationModel(6)
self.comboBox_type.setModel(relModel_type)
self.comboBox_type.setModelColumn(
relModel_type.fieldIndex("goods_type_name"))
self.db_map.setItemDelegate(QSqlRelationalDelegate(self))
self.db_map.addMapping(self.comboBox_type, 6)
relModel_subtype = model.relationModel(7)
self.comboBox_subtype.setModel(relModel_subtype)
self.comboBox_subtype.setModelColumn(
relModel_subtype.fieldIndex("goods_subtype_name"))
self.db_map.setItemDelegate(QSqlRelationalDelegate(self))
self.db_map.addMapping(self.comboBox_subtype, 7)
relModel_location = model.relationModel(8)
self.comboBox_location.setModel(relModel_location)
self.comboBox_location.setModelColumn(
relModel_location.fieldIndex("location_name"))
self.db_map.setItemDelegate(QSqlRelationalDelegate(self))
self.db_map.addMapping(self.comboBox_location, 8)
relModel_responsible = model.relationModel(9)
self.comboBox_responsible.setModel(relModel_responsible)
self.comboBox_responsible.setModelColumn(
relModel_responsible.fieldIndex("FIO"))
self.db_map.setItemDelegate(QSqlRelationalDelegate(self))
self.db_map.addMapping(self.comboBox_responsible, 9)
self.pushBtn_save.clicked.connect(self.save_item)
self.pushBtn_cancel.clicked.connect(self.cancel)
self.pushBtn_next.clicked.connect(self.db_map.toNext)
self.pushBtn_prev.clicked.connect(self.db_map.toPrevious)
self.pushBtn_close.clicked.connect(self.close)
self.db_map.setCurrentIndex(current_index.row())
def setUpMapper(self):
self.mapper = QDataWidgetMapper(self)
self.mapper.setModel(self.model)
# self.mapper.addMapping(self.table,1,b'currentIndex')
self.mapper.addMapping(self.table, 1)
# self.mapper.addMapping(self.combo,0,b'currentIndex')
self.mapper.addMapping(self.combo, 0)
self.mapper.currentIndexChanged.connect(self.updateButtons)
self.mapper.toFirst()
def plot(self, modelIndex):
self.mapper = QDataWidgetMapper(self)
self.mapper.setModel(self.imageListModel)
self.mapper.addMapping(self.ui.lineEditFile, 1)
self.mapper.addMapping(self.ui.lineEditHash, 2)
self.mapper.addMapping(self.ui.lineEditTarget, 3)
self.mapper.addMapping(self.ui.lineEditFrame, 4)
self.mapper.addMapping(self.ui.lineEditFilter, 5)
self.mapper.addMapping(self.ui.lineEditExposure, 6)
self.mapper.addMapping(self.ui.lineEditTemp, 7)
self.mapper.addMapping(self.ui.lineEditXbinning, 8)
self.mapper.addMapping(self.ui.lineEditYbinning, 9)
self.mapper.addMapping(self.ui.lineEditSiteLat, 10)
self.mapper.addMapping(self.ui.lineEditSiteLong, 11)
self.mapper.addMapping(self.ui.lineEditRa, 12)
self.mapper.addMapping(self.ui.lineEditDec, 13)
self.mapper.addMapping(self.ui.lineEditAlt, 14)
self.mapper.addMapping(self.ui.lineEditAz, 15)
self.mapper.addMapping(self.ui.lineEditDate, 16)
self.mapper.addMapping(self.ui.lineEditGain, 17)
self.mapper.addMapping(self.ui.lineEditOffset, 18)
self.mapper.addMapping(self.ui.lineEditSubframeScale, 19)
self.mapper.addMapping(self.ui.lineEditCameraGain, 20)
self.mapper.addMapping(self.ui.lineEditCameraResolution, 21)
self.mapper.addMapping(self.ui.lineEditScaleUnit, 22)
self.mapper.addMapping(self.ui.lineEditDataUnit, 23)
self.mapper.addMapping(self.ui.lineEditCsvFile, 24)
self.mapper.addMapping(self.ui.lineEditFwhm, 25)
self.mapper.addMapping(self.ui.lineEditEccentricity, 26)
self.mapper.addMapping(self.ui.lineEditSnrWeight, 27)
self.mapper.addMapping(self.ui.lineEditNoise, 28)
self.mapper.setCurrentIndex(modelIndex.row())
self.ui.lineEditRaF.setText(
self.convertCoord(self.ui.lineEditRa.text(), "hms"))
self.ui.lineEditDecF.setText(
self.convertCoord(self.ui.lineEditDec.text(), "dms"))
self.ui.lineEditSiteLatF.setText(
self.convertCoord(self.ui.lineEditSiteLat.text(), "lat"))
self.ui.lineEditSiteLongF.setText(
self.convertCoord(self.ui.lineEditSiteLong.text(), "long"))
self.ui.lineEditAltF.setText(
self.convertCoord(self.ui.lineEditAlt.text(), "dms"))
self.ui.lineEditAzF.setText(
self.convertCoord(self.ui.lineEditAz.text(), "dms"))
cr = self.imageListModel.index(modelIndex.row(), 1)
t = self.imageListModel.data(cr, QtCore.Qt.DisplayRole)
self.mplwidget = MatplotlibWidget(self.ui.MplWidget)
self.mplwidget.setFileName(t)
self.mplwidget.plot()
try:
self.resize(self.app.settings.value("sizeDetailW"))
self.move(self.app.settings.value("posDetailW"))
except Exception as e:
self.logger.error(f"{e}")
self.show()
def __init__(self, parent=None):
super().__init__(parent)
self.setupUi(self)
self.model = None
self.parts_tree_model = ArmorSetTreeModel()
self.skill_model = SkillTranslationModel()
self.armor_item_mapper = QDataWidgetMapper(self)
self.armor_item_mapper.setItemDelegate(ItemDelegate())
self.armor_item_mapper.setModel(self.parts_tree_model)
self.parts_tree_view.setModel(self.parts_tree_model)
self.parts_tree_view.activated.connect(
self.handle_parts_tree_activated)
self.import_export_manager = ImportExportManager(self.parts_tree_view)
self.import_export_manager.connect_custom_context_menu()
for it in ("set_skill1_value", "set_skill2_value", "skill1_value",
"skill2_value", "skill3_value"):
getattr(self, it).setModel(self.skill_model)
mappings = [
(self.id_value, Column.id, b"text"),
(self.name_value, Column.gmd_name_index, b"text"),
(self.description_value, Column.gmd_desc_index, b"text"),
(self.setid_value, Column.set_id),
(self.set_group_value, Column.set_group),
(self.type_value, Column.type, b"currentIndex"),
(self.order_value, Column.order),
(self.variant_value, Column.variant, b"currentIndex"),
(self.equip_slot_value, Column.equip_slot, b"currentIndex"),
(self.gender_value, Column.gender, b"currentIndex"),
(self.mdl_main_id_value, Column.mdl_main_id),
(self.mdl_secondary_id_value, Column.mdl_secondary_id),
(self.icon_color_value, Column.icon_color),
(self.defense_value, Column.defense),
(self.rarity_value, Column.rarity),
(self.cost_value, Column.cost),
(self.fire_res_value, Column.fire_res),
(self.water_res_value, Column.water_res),
(self.thunder_res_value, Column.thunder_res),
(self.ice_res_value, Column.ice_res),
(self.dragon_res_value, Column.dragon_res),
(self.set_skill1_value, Column.set_skill1),
(self.set_skill1_lvl_value, Column.set_skill1_lvl),
(self.set_skill2_value, Column.set_skill2),
(self.set_skill2_lvl_value, Column.set_skill2_lvl),
(self.skill1_value, Column.skill1),
(self.skill1_lvl_value, Column.skill1_lvl),
(self.skill2_value, Column.skill2),
(self.skill2_lvl_value, Column.skill2_lvl),
(self.skill3_value, Column.skill3),
(self.skill3_lvl_value, Column.skill3_lvl),
(self.num_gem_slots, Column.num_gem_slots),
(self.gem_slot1_lvl_value, Column.gem_slot1_lvl),
(self.gem_slot2_lvl_value, Column.gem_slot2_lvl),
(self.gem_slot3_lvl_value, Column.gem_slot3_lvl),
]
for mapping in mappings:
self.armor_item_mapper.addMapping(*mapping)
def __init__(self, model=None, ui_file: str = None) -> None:
super().__init__()
loadUi(ui_file or self.ui_file, self)
self.row = None
self.record = None
self.new_record = False
self.parent_view = None
self.sub_views = []
if self.window_title:
self.setWindowTitle(self.window_title)
if self.window_icon:
self.setWindowIcon(QIcon(self.window_icon))
# allow passing a model class or instances
model = model or self.model
if inspect.isclass(model):
self.data_model = model()
else:
self.data_model = model
# update subviews on row change
self.data_mapper = QDataWidgetMapper()
self.data_mapper.setModel(self.data_model)
self.data_mapper.currentIndexChanged.connect(self._update_subviews)
# auto map fields to db columns
for field in self.data_model.fields:
if hasattr(self, field.name):
self.data_mapper.addMapping(getattr(self, field.name),
field.index)
# setup subviews
for view_name, view_cls in self.subviews.items():
placeholder_name = '{0}_placeholder'.format(view_name)
try:
placeholder = getattr(self, placeholder_name)
except AttributeError:
raise ImproperlyConfigured(
'Unable to find subview placeholder ' + placeholder_name)
view = view_cls()
self.sub_views.append(view)
view.set_parent_view(self)
layout = placeholder.layout()
if not layout:
layout = QVBoxLayout(placeholder)
layout.setContentsMargins(0, 0, 0, 0)
layout.addWidget(view)
setattr(self, view_name, view)
if hasattr(self, 'setup_ui'):
self.setup_ui()
def __init__(self, parent=None):
super().__init__(parent)
self.setupUi(self)
self.model = None
self.skill_model = SkillTranslationModel()
self.table_model = WpDatTableModel(self)
self.weapon_tree_view.activated.connect(
self.handle_weapon_tree_view_activated)
self.kire_widget.set_model(KireGaugeModelEntryAdapter())
self.mapper = QDataWidgetMapper(self)
self.mapper.setItemDelegate(ItemDelegate())
self.mapper.setModel(self.table_model)
self.skill_id_value.setModel(self.skill_model)
self.import_export_manager = ImportExportManager(self.weapon_tree_view)
self.import_export_manager.connect_custom_context_menu()
mappings = [
(self.id_value, WpDatEntry.id.index, b"text"),
(self.name_value, WpDatEntry.gmd_name_index.index, b"text"),
(self.description_value, WpDatEntry.gmd_description_index.index,
b"text"),
(self.order_value, WpDatEntry.order.index),
(self.tree_id_value, WpDatEntry.tree_id.index),
(self.tree_position_value, WpDatEntry.tree_position.index),
(self.is_fixed_upgrade_value, WpDatEntry.is_fixed_upgrade.index,
b"checked"),
(self.base_model_id_value, WpDatEntry.base_model_id.index),
(self.part1_id_value, WpDatEntry.part1_id.index),
(self.part2_id_value, WpDatEntry.part2_id.index),
(self.color_value, WpDatEntry.color.index),
(self.rarity_value, WpDatEntry.rarity.index),
(self.cost_value, WpDatEntry.crafting_cost.index),
(self.raw_damage_value, WpDatEntry.raw_damage.index),
(self.affinity_value, WpDatEntry.affinity.index),
(self.defense_value, WpDatEntry.defense.index),
(self.handicraft_value, WpDatEntry.handicraft.index,
b"currentIndex"),
(self.element_id_value, WpDatEntry.element_id.index,
b"currentIndex"),
(self.element_damage_value, WpDatEntry.element_damage.index),
(self.hidden_element_id_value, WpDatEntry.hidden_element_id.index,
b"currentIndex"),
(self.hidden_element_damage_value,
WpDatEntry.hidden_element_damage.index),
(self.elderseal_value, WpDatEntry.elderseal.index,
b"currentIndex"),
(self.num_gem_slots, WpDatEntry.num_gem_slots.index),
(self.gem_slot1_lvl_value, WpDatEntry.gem_slot1_lvl.index),
(self.gem_slot2_lvl_value, WpDatEntry.gem_slot2_lvl.index),
(self.gem_slot3_lvl_value, WpDatEntry.gem_slot3_lvl.index),
(self.skill_id_value, WpDatEntry.skill_id.index),
(self.wep1_id_value, WpDatEntry.wep1_id.index),
(self.wep2_id_value, WpDatEntry.wep2_id.index),
(self.kire_widget, WpDatEntry.kire_id.index),
]
for mapping in mappings:
self.mapper.addMapping(*mapping)
def init_model(self, model):
self.__model = model
self.__mapper = QDataWidgetMapper(self)
self.__mapper.setModel(self.__model)
self.__mapper.setSubmitPolicy(QDataWidgetMapper.ManualSubmit)
self.__mapper.addMapping(self.titleEdit, 1)
self.__mapper.addMapping(self.plannedDateTimeEdit, 2)
self.__mapper.addMapping(self.contentEdit, 3)
def threadFormInit(self):
self.formMapper = QDataWidgetMapper(self)
self.formModel = QSqlQueryModel(self)
self.formModel.setQuery('SELECT DISTINCT form FROM internal_threads')
self.formMapper.setModel(self.formModel)
self.formMapper.addMapping(self.threadFormLbl, 0, b'text')
self.formMapper.toLast()
self.formsLast = self.formMapper.currentIndex()
self.formMapper.toFirst()
self.threadClassInit()
def schema_ui_map(schema, model, form):
"""Construct a QDataWidgetMapper from the given ``schema`` class.
(Function 4)
:param schema: The schema to create field-to-widget mappings from.
:param model: The model that the QDataWidgetMapper observes.
:param form: The UI widget containing stuff to bind to. It is also set as
the parent for the widget mapper.
"""
assert isinstance(model, QAbstractItemModel)
mapper = QDataWidgetMapper(form)
mapper.setModel(model)
s = schema()
for i, (name, field) in enumerate(s.fields.items()):
try:
widget_classes = _widget_type(type(field))
widget = form.findChild(widget_classes, name)
if not widget:
raise ValueError
prop = _widget_property(type(widget))
log.debug("adding map from (`%s', col = %d) to %s (prop = `%s')",
name, i, widget, prop)
mapper.addMapping(widget, i, bytes(prop, encoding='utf8'))
assert mapper.mappedWidgetAt(i) == widget
except KeyError:
log.error("unknown field type %s", type(field))
except ValueError: # FIXME: is this the correct exception type?
log.error("failed to find widget for field `%s'", name)
mapper.toFirst()
return mapper
def __init__(self, main_widget, parent=None):
super(ProposalEditor, self).__init__(parent)
self.main_widget = main_widget
self.name_edit = QLineEdit()
self.url_edit = QLineEdit()
self.start_block_edit = QLineEdit()
self.end_block_edit = QLineEdit()
self.amount_edit = QLineEdit()
self.address_edit = QLineEdit()
self.txid_edit = QLineEdit()
for i in [
self.name_edit, self.url_edit, self.start_block_edit,
self.end_block_edit, self.amount_edit, self.address_edit,
self.txid_edit
]:
i.setReadOnly(True)
self.mapper = QDataWidgetMapper()
self.mapper.setModel(self.main_widget.proxy_model)
self.mapper.setSubmitPolicy(QDataWidgetMapper.ManualSubmit)
self.mapper.addMapping(self.name_edit, ProposalsModel.NAME)
self.mapper.addMapping(self.url_edit, ProposalsModel.URL)
self.mapper.addMapping(self.start_block_edit,
ProposalsModel.START_BLOCK)
self.mapper.addMapping(self.end_block_edit, ProposalsModel.END_BLOCK)
self.mapper.addMapping(self.amount_edit, ProposalsModel.AMOUNT)
self.mapper.addMapping(self.address_edit, ProposalsModel.ADDRESS)
self.mapper.addMapping(self.txid_edit, ProposalsModel.TXID)
block_hbox = QHBoxLayout()
block_hbox.addWidget(self.start_block_edit)
block_hbox.addWidget(QLabel(' - '))
block_hbox.addWidget(self.end_block_edit)
self.vote_combo = QComboBox()
self.vote_combo.addItem(_('Yes'))
self.vote_combo.addItem(_('No'))
self.vote_button = QPushButton(_('Vote'))
self.vote_button.clicked.connect(self.cast_vote)
vote_hbox = util.Buttons(self.vote_combo, self.vote_button)
form = QFormLayout()
form.addRow(_('Name:'), self.name_edit)
form.addRow(_('URL:'), self.url_edit)
form.addRow(_('Blocks:'), block_hbox)
form.addRow(_('Monthly Payment:'), self.amount_edit)
form.addRow(_('Payment Address:'), self.address_edit)
form.addRow(_('Fee TxID:'), self.txid_edit)
form.addRow(_('Vote:'), vote_hbox)
self.setLayout(form)
def formModelInit(self):
self.formMapper = QDataWidgetMapper(self)
self.formModel = QSqlQueryModel(self)
self.formModel.setQuery('SELECT DISTINCT form FROM threads')
self.formMapper.setModel(self.formModel)
self.formMapper.addMapping(self.formLbl, 0, b'text')
self.formMapper.currentIndexChanged.connect(self.formChanged)
self.formMapper.toLast()
self.formsLast = self.formMapper.currentIndex()
self.formMapper.toFirst()
self.formIndexLbl.setText('{}'.format(self.formMapper.currentIndex()))
self.classModelInit()
def threadClassInit(self):
self.classMapper = QDataWidgetMapper(self)
self.classModel = QSqlQueryModel(self)
form = self.threadFormLbl.text()
classSelect = "SELECT DISTINCT class FROM internal_threads \
WHERE form = '{}'".format(form)
self.classModel.setQuery(classSelect)
self.classMapper.setModel(self.classModel)
self.classMapper.addMapping(self.threadClassLbl, 0, b'text')
self.classMapper.toLast()
self.classLast = self.classMapper.currentIndex()
self.classMapper.toFirst()
self.threadSizeInit()
def sptmSizeInit(self):
self.sptmMapper = QDataWidgetMapper(self)
self.sptmModel = QSqlQueryModel(self)
self.sptmModel.setQuery('SELECT * FROM sptm')
self.sptmMapper.setModel(self.sptmModel)
self.sptmMapper.addMapping(self.sptmSizeLbl, 0, b'text')
self.sptmMapper.addMapping(self.sptmDiaLbl, 1, b'text')
self.sptmMapper.addMapping(self.sptmCrestLbl, 2, b'text')
self.sptmMapper.addMapping(self.sptmMaxDepthLbl, 3, b'text')
self.sptmMapper.addMapping(self.sptmFlutesLbl, 4, b'text')
self.sptmMapper.addMapping(self.sptmNeckDiaLbl, 5, b'text')
self.sptmMapper.toLast()
self.sptmLast = self.sptmMapper.currentIndex()
self.sptmMapper.toFirst()
def mapWidget2Model(self):
self.mapper = QDataWidgetMapper(self)
self.model = MovieInfoModel()
self.mapper.setModel(self.model)
index = 0
for key, ctrl in self.controls.items():
if 'genre' == key or 'actor' == key or 'rating' == key:
self.mapper.addMapping(ctrl[self.ID_CTRL], index, b'Value')
else:
self.mapper.addMapping(ctrl[self.ID_CTRL], index)
index += 1
self.mapper.addMapping(self.poster, index)
index += 1
self.mapper.addMapping(self.fanart, index)
self.mapper.setItemDelegate(MovieInfoDelegate())
class VnTreeView(QTreeView):
tree_clicked = pyqtSignal(str)
def __init__(self, parent=None, treerootNode=None):
super().__init__(parent)
self.setHeaderHidden(True)
self.rootIsDecorated = True
#self.setup_treemodel(treerootNode)
def setup_treemodel(self, treerootNode=None, treetype='FsTree'):
if treetype=='FsTree':
treemodel = FsTreeModel(treerootNode)
else:
treemodel = VnTreeModel(treerootNode)
self.setModel(treemodel)
self.dataMapper = QDataWidgetMapper()
self.dataMapper.setModel(treemodel)
def __init__(self, model=None, ui_file: str = None) -> None:
super().__init__()
loadUi(ui_file or self.ui_file, self)
self.model = model or self.model
self.data_mapper = QDataWidgetMapper()
self.data_mapper.setModel(self.model)
for field in model.fields:
if hasattr(self, field.name):
self.data_mapper.addMapping(getattr(self, field.name),
field.index)
if hasattr(self, 'setup_ui'):
self.setup_ui()
def _create_form_groupbox(self):
imageLabel = QLabel("Name:")
self.image = imageEdit = QLineEdit()
imageLabel.setBuddy(imageEdit)
commandLabel = QLabel("Service:")
commandEdit = QLineEdit()
commandLabel.setBuddy(commandEdit)
environmentLabel = QLabel("Options:")
environmentEdit = QLineEdit()
environmentLabel.setBuddy(environmentEdit)
self.mapper = mapper = QDataWidgetMapper(self)
mapper.setSubmitPolicy(QDataWidgetMapper.AutoSubmit)
mapper.setModel(self.model)
mapper.addMapping(imageEdit, StepItem.Cols.IMAGE.value)
mapper.addMapping(commandEdit, StepItem.Cols.COMMAND.value)
mapper.addMapping(environmentEdit, StepItem.Cols.ENVIRONMENT.value)
self.groupbox = config = QGroupBox()
config_layout = QGridLayout()
config_layout.addWidget(imageLabel, 0, 0)
config_layout.addWidget(imageEdit, 0, 1)
config_layout.addWidget(commandLabel, 1, 0)
config_layout.addWidget(commandEdit, 1, 1)
config_layout.addWidget(environmentLabel, 2, 0)
config_layout.addWidget(environmentEdit, 2, 1)
config.setLayout(config_layout)
self.all_fields = [
imageEdit,
commandEdit,
environmentEdit,
]
def __init__(self, parent=None):
super(Window, self).__init__(parent)
# Set up the model.
self.setupModel()
# Set up the widgets.
nameLabel = QLabel("Na&me:")
nameEdit = QLineEdit()
addressLabel = QLabel("&Address:")
addressEdit = QTextEdit()
typeLabel = QLabel("&Type:")
typeComboBox = QComboBox()
self.nextButton = QPushButton("&Next")
self.previousButton = QPushButton("&Previous")
nameLabel.setBuddy(nameEdit)
addressLabel.setBuddy(addressEdit)
typeLabel.setBuddy(typeComboBox)
typeComboBox.setModel(self.typeModel)
# Set up the mapper.
self.mapper = QDataWidgetMapper(self)
self.mapper.setModel(self.model)
self.mapper.addMapping(nameEdit, 0)
self.mapper.addMapping(addressEdit, 1)
self.mapper.addMapping(typeComboBox, 2, b'currentIndex')
# Set up connections and layouts.
self.previousButton.clicked.connect(self.mapper.toPrevious)
self.nextButton.clicked.connect(self.mapper.toNext)
self.mapper.currentIndexChanged.connect(self.updateButtons)
layout = QGridLayout()
layout.addWidget(nameLabel, 0, 0, 1, 1)
layout.addWidget(nameEdit, 0, 1, 1, 1)
layout.addWidget(self.previousButton, 0, 2, 1, 1)
layout.addWidget(addressLabel, 1, 0, 1, 1)
layout.addWidget(addressEdit, 1, 1, 2, 1)
layout.addWidget(self.nextButton, 1, 2, 1, 1)
layout.addWidget(typeLabel, 3, 0, 1, 1)
layout.addWidget(typeComboBox, 3, 1, 1, 1)
self.setLayout(layout)
self.setWindowTitle("Delegate Widget Mapper")
self.mapper.toFirst()
def __init__(self, parent):
super(SignAnnounceWidget, self).__init__(parent)
self.dialog = parent
self.manager = parent.manager
# Displays the status of the masternode.
self.status_edit = QLineEdit()
self.status_edit.setReadOnly(True)
self.alias_edit = QLineEdit()
self.collateral_edit = PrevOutWidget()
self.delegate_edit = QLineEdit()
self.delegate_edit.setFont(QFont(util.MONOSPACE_FONT))
for i in [self.alias_edit, self.collateral_edit, self.delegate_edit]:
i.setReadOnly(True)
self.mapper = QDataWidgetMapper()
self.mapper.setSubmitPolicy(QDataWidgetMapper.ManualSubmit)
self.mapper.setModel(self.dialog.masternodes_widget.proxy_model)
model = self.dialog.masternodes_widget.model
self.mapper.addMapping(self.alias_edit, model.ALIAS)
self.mapper.addMapping(self.collateral_edit, model.VIN, b'string')
self.mapper.addMapping(self.delegate_edit, model.DELEGATE)
self.sign_button = QPushButton(_('Activate Masternode'))
self.sign_button.setEnabled(False)
self.sign_button.clicked.connect(self.sign_announce)
status_box = QHBoxLayout()
status_box.setContentsMargins(0, 0, 0, 0)
status_box.addWidget(QLabel(_('Status:')))
status_box.addWidget(self.status_edit, stretch=1)
vbox = QVBoxLayout()
vbox.addLayout(status_box)
form = QFormLayout()
form.addRow(_('Alias:'), self.alias_edit)
form.addRow(_('Collateral vestx Output:'), self.collateral_edit)
form.addRow(_('Masternode Private Key:'), self.delegate_edit)
vbox.addLayout(form)
vbox.addLayout(util.Buttons(self.sign_button))
self.setLayout(vbox)
def classModelInit(self):
print('class update')
self.classMapper = QDataWidgetMapper(self)
self.classModel = QSqlQueryModel(self)
form = self.formLbl.text()
print(form)
classSelect = "SELECT DISTINCT class FROM threads WHERE form = '{}'".format(
form)
self.classModel.setQuery(classSelect)
self.classMapper.setModel(self.classModel)
self.classMapper.addMapping(self.classLbl, 0, b'text')
#self.classMapper.currentIndexChanged.connect(self.formChanged)
self.classMapper.toLast()
self.classLast = self.classMapper.currentIndex()
self.classMapper.toFirst()
self.classIndexLbl.setText('{}'.format(
self.classMapper.currentIndex()))
self.sizeModelInit()
def init_model(self, model):
self.__model = model
self.__mapper = QDataWidgetMapper(self)
self.__mapper.setModel(self.__model)
self.__mapper.setSubmitPolicy(QDataWidgetMapper.ManualSubmit)
self.__mapper.addMapping(self.titleEdit, 1)
self.__mapper.addMapping(self.plannedDateTimeEdit, 2)
self.__mapper.addMapping(self.contentEdit, 3)
class CommitterFilterEditor(QWidget, Ui_CommitterFilterProperties):
def __init__(self, parent=None):
super().__init__(parent)
self.setupUi(self)
self._data_mapper = QDataWidgetMapper()
def setModel(self, model):
self._model = model
self._data_mapper.setModel(model)
self._data_mapper.addMapping(self.uiCommitterName, 2)
self._data_mapper.addMapping(self.uiCommitterEmail, 3)
def setSelection(self, current: QModelIndex) -> None:
parent = current.parent()
self._data_mapper.setRootIndex(parent)
self._data_mapper.setCurrentModelIndex(current)
def toolTypeInit(parent):
parent.toolTypeMapper = QDataWidgetMapper(parent)
parent.toolTypeModel = QSqlQueryModel(parent)
parent.toolTypeModel.setQuery('SELECT DISTINCT material FROM end_mills')
parent.toolTypeMapper.setModel(parent.toolTypeModel)
parent.toolTypeMapper.addMapping(parent.endMillMaterialLbl, 0, b'text')
parent.toolTypeMapper.toLast()
parent.toolTypeLast = parent.toolTypeMapper.currentIndex()
print('current index {}'.format(parent.toolTypeMapper.currentIndex()))
parent.toolTypeMapper.toFirst()
def __init__(self, model):
super().__init__()
self.header = QLabel('')
self.desc = QLineEdit()
self.date = QDateEdit()
self.time = QTimeEdit()
self.init_ui()
self.mapper = QDataWidgetMapper()
self.mapper.setModel(model)
self.mapper.setSubmitPolicy(QDataWidgetMapper.ManualSubmit)
self.mapper.addMapping(self.desc, TaskModel.col_desc)
self.mapper.addMapping(self.date, TaskModel.col_date)
self.mapper.addMapping(self.time, TaskModel.col_time)
def __init__(self, parent=None):
super(Window, self).__init__(parent)
# Set up the model.
self.setupModel()
# Set up the widgets.
nameLabel = QLabel("Na&me:")
nameEdit = QLineEdit()
addressLabel = QLabel("&Address:")
addressEdit = QTextEdit()
typeLabel = QLabel("&Type:")
typeComboBox = QComboBox()
self.nextButton = QPushButton("&Next")
self.previousButton = QPushButton("&Previous")
nameLabel.setBuddy(nameEdit)
addressLabel.setBuddy(addressEdit)
typeLabel.setBuddy(typeComboBox)
typeComboBox.setModel(self.typeModel)
# Set up the mapper.
self.mapper = QDataWidgetMapper(self)
self.mapper.setModel(self.model)
self.mapper.addMapping(nameEdit, 0)
self.mapper.addMapping(addressEdit, 1)
self.mapper.addMapping(typeComboBox, 2, 'currentIndex')
# Set up connections and layouts.
self.previousButton.clicked.connect(self.mapper.toPrevious)
self.nextButton.clicked.connect(self.mapper.toNext)
self.mapper.currentIndexChanged.connect(self.updateButtons)
layout = QGridLayout()
layout.addWidget(nameLabel, 0, 0, 1, 1)
layout.addWidget(nameEdit, 0, 1, 1, 1)
layout.addWidget(self.previousButton, 0, 2, 1, 1)
layout.addWidget(addressLabel, 1, 0, 1, 1)
layout.addWidget(addressEdit, 1, 1, 2, 1)
layout.addWidget(self.nextButton, 1, 2, 1, 1)
layout.addWidget(typeLabel, 3, 0, 1, 1)
layout.addWidget(typeComboBox, 3, 1, 1, 1)
self.setLayout(layout)
self.setWindowTitle("Delegate Widget Mapper")
self.mapper.toFirst()
class MainWindow(QMainWindow):
"""
The main window class
"""
def __init__(self, parent=None):
QMainWindow.__init__(self, parent)
self.ui = uic.loadUi("gui/main_window.ui")
self.timestamp_filename = None
self.video_filename = None
self.media_start_time = None
self.media_end_time = None
self.restart_needed = False
self.timer_period = 100
self.is_full_screen = False
self.media_started_playing = False
self.media_is_playing = False
self.original_geometry = None
self.mute = False
self.timestamp_model = TimestampModel(None, self)
self.proxy_model = QSortFilterProxyModel(self)
self.ui.list_timestamp.setModel(self.timestamp_model)
self.ui.list_timestamp.doubleClicked.connect(
lambda event: self.ui.list_timestamp.indexAt(event.pos()).isValid()
and self.run()
)
self.timer = QTimer()
self.timer.timeout.connect(self.update_ui)
self.timer.timeout.connect(self.timer_handler)
self.timer.start(self.timer_period)
self.vlc_instance = vlc.Instance()
self.media_player = self.vlc_instance.media_player_new()
# if sys.platform == "darwin": # for MacOS
# self.ui.frame_video = QMacCocoaViewContainer(0)
self.ui.frame_video.doubleClicked.connect(self.toggle_full_screen)
self.ui.frame_video.wheel.connect(self.wheel_handler)
self.ui.frame_video.keyPressed.connect(self.key_handler)
# Set up buttons
self.ui.button_run.clicked.connect(self.run)
self.ui.button_timestamp_browse.clicked.connect(
self.browse_timestamp_handler
)
self.ui.button_video_browse.clicked.connect(
self.browse_video_handler
)
self.play_pause_model = ToggleButtonModel(None, self)
self.play_pause_model.setStateMap(
{
True: {
"text": "",
"icon": qta.icon("fa.play", scale_factor=0.7)
},
False: {
"text": "",
"icon": qta.icon("fa.pause", scale_factor=0.7)
}
}
)
self.ui.button_play_pause.setModel(self.play_pause_model)
self.ui.button_play_pause.clicked.connect(self.play_pause)
self.mute_model = ToggleButtonModel(None, self)
self.mute_model.setStateMap(
{
True: {
"text": "",
"icon": qta.icon("fa.volume-up", scale_factor=0.8)
},
False: {
"text": "",
"icon": qta.icon("fa.volume-off", scale_factor=0.8)
}
}
)
self.ui.button_mute_toggle.setModel(self.mute_model)
self.ui.button_mute_toggle.clicked.connect(self.toggle_mute)
self.ui.button_full_screen.setIcon(
qta.icon("ei.fullscreen", scale_factor=0.6)
)
self.ui.button_full_screen.setText("")
self.ui.button_full_screen.clicked.connect(self.toggle_full_screen)
self.ui.button_speed_up.clicked.connect(self.speed_up_handler)
self.ui.button_speed_up.setIcon(
qta.icon("fa.arrow-circle-o-up", scale_factor=0.8)
)
self.ui.button_speed_up.setText("")
self.ui.button_slow_down.clicked.connect(self.slow_down_handler)
self.ui.button_slow_down.setIcon(
qta.icon("fa.arrow-circle-o-down", scale_factor=0.8)
)
self.ui.button_slow_down.setText("")
self.ui.button_mark_start.setIcon(
qta.icon("fa.quote-left", scale_factor=0.7)
)
self.ui.button_mark_start.setText("")
self.ui.button_mark_end.setIcon(
qta.icon("fa.quote-right", scale_factor=0.7)
)
self.ui.button_mark_end.setText("")
self.ui.button_add_entry.clicked.connect(self.add_entry)
self.ui.button_remove_entry.clicked.connect(self.remove_entry)
self.ui.button_mark_start.clicked.connect(
lambda: self.set_mark(start_time=int(
self.media_player.get_position() *
self.media_player.get_media().get_duration()))
)
self.ui.button_mark_end.clicked.connect(
lambda: self.set_mark(end_time=int(
self.media_player.get_position() *
self.media_player.get_media().get_duration()))
)
self.ui.slider_progress.setTracking(False)
self.ui.slider_progress.valueChanged.connect(self.set_media_position)
self.ui.slider_volume.valueChanged.connect(self.set_volume)
self.ui.entry_description.setReadOnly(True)
# Mapper between the table and the entry detail
self.mapper = QDataWidgetMapper()
self.mapper.setSubmitPolicy(QDataWidgetMapper.ManualSubmit)
self.ui.button_save.clicked.connect(self.mapper.submit)
# Set up default volume
self.set_volume(self.ui.slider_volume.value())
self.vlc_events = self.media_player.event_manager()
self.vlc_events.event_attach(
vlc.EventType.MediaPlayerTimeChanged, self.media_time_change_handler
)
# Let our application handle mouse and key input instead of VLC
self.media_player.video_set_mouse_input(False)
self.media_player.video_set_key_input(False)
self.ui.show()
def add_entry(self):
if not self.timestamp_filename:
self._show_error("You haven't chosen a timestamp file yet")
row_num = self.timestamp_model.rowCount()
self.timestamp_model.insertRow(row_num)
start_cell = self.timestamp_model.index(row_num, 0)
end_cell = self.timestamp_model.index(row_num, 1)
self.timestamp_model.setData(start_cell, TimestampDelta.from_string(""))
self.timestamp_model.setData(end_cell, TimestampDelta.from_string(""))
def remove_entry(self):
if not self.timestamp_filename:
self._show_error("You haven't chosen a timestamp file yet")
selected = self.ui.list_timestamp.selectionModel().selectedIndexes()
if len(selected) == 0:
return
self.proxy_model.removeRow(selected[0].row()) and self.mapper.submit()
def set_media_position(self, position):
percentage = position / 10000.0
self.media_player.set_position(percentage)
absolute_position = percentage * \
self.media_player.get_media().get_duration()
if absolute_position > self.media_end_time:
self.media_end_time = -1
def set_mark(self, start_time=None, end_time=None):
if len(self.ui.list_timestamp.selectedIndexes()) == 0:
blankRowIndex = self.timestamp_model.blankRowIndex()
if not blankRowIndex.isValid():
self.add_entry()
else:
index = self.proxy_model.mapFromSource(blankRowIndex)
self.ui.list_timestamp.selectRow(index.row())
selectedIndexes = self.ui.list_timestamp.selectedIndexes()
if start_time:
self.proxy_model.setData(selectedIndexes[0],
TimestampDelta.string_from_int(
start_time))
if end_time:
self.proxy_model.setData(selectedIndexes[1],
TimestampDelta.string_from_int(
end_time))
def update_ui(self):
self.ui.slider_progress.blockSignals(True)
self.ui.slider_progress.setValue(
self.media_player.get_position() * 10000
)
# When the video finishes
self.ui.slider_progress.blockSignals(False)
if self.media_started_playing and \
self.media_player.get_media().get_state() == vlc.State.Ended:
self.play_pause_model.setState(True)
# Apparently we need to reset the media, otherwise the player
# won't play at all
self.media_player.set_media(self.media_player.get_media())
self.set_volume(self.ui.slider_volume.value())
self.media_is_playing = False
self.media_started_playing = False
self.run()
def timer_handler(self):
"""
This is a workaround, because for some reason we can't call set_time()
inside the MediaPlayerTimeChanged handler (as the video just stops
playing)
"""
if self.restart_needed:
self.media_player.set_time(self.media_start_time)
self.restart_needed = False
def key_handler(self, event):
if event.key() == Qt.Key_Escape and self.is_full_screen:
self.toggle_full_screen()
if event.key() == Qt.Key_F:
self.toggle_full_screen()
if event.key() == Qt.Key_Space:
self.play_pause()
def wheel_handler(self, event):
self.modify_volume(1 if event.angleDelta().y() > 0 else -1)
def toggle_mute(self):
self.media_player.audio_set_mute(not self.media_player.audio_get_mute())
self.mute = not self.mute
self.mute_model.setState(not self.mute)
def modify_volume(self, delta_percent):
new_volume = self.media_player.audio_get_volume() + delta_percent
if new_volume < 0:
new_volume = 0
elif new_volume > 40:
new_volume = 40
self.media_player.audio_set_volume(new_volume)
self.ui.slider_volume.setValue(self.media_player.audio_get_volume())
def set_volume(self, new_volume):
self.media_player.audio_set_volume(new_volume)
def speed_up_handler(self):
self.modify_rate(0.1)
def slow_down_handler(self):
self.modify_rate(-0.1)
def modify_rate(self, delta_percent):
new_rate = self.media_player.get_rate() + delta_percent
if new_rate < 0.2 or new_rate > 2.0:
return
self.media_player.set_rate(new_rate)
def media_time_change_handler(self, _):
if self.media_end_time == -1:
return
if self.media_player.get_time() > self.media_end_time:
self.restart_needed = True
def update_slider_highlight(self):
if self.ui.list_timestamp.selectionModel().hasSelection():
selected_row = self.ui.list_timestamp.selectionModel(). \
selectedRows()[0]
self.media_start_time = self.ui.list_timestamp.model().data(
selected_row.model().index(selected_row.row(), 0),
Qt.UserRole
)
self.media_end_time = self.ui.list_timestamp.model().data(
selected_row.model().index(selected_row.row(), 1),
Qt.UserRole
)
duration = self.media_player.get_media().get_duration()
self.media_end_time = self.media_end_time \
if self.media_end_time != 0 else duration
if self.media_start_time > self.media_end_time:
raise ValueError("Start time cannot be later than end time")
if self.media_start_time > duration:
raise ValueError("Start time not within video duration")
if self.media_end_time > duration:
raise ValueError("End time not within video duration")
slider_start_pos = (self.media_start_time / duration) * \
(self.ui.slider_progress.maximum() -
self.ui.slider_progress.minimum())
slider_end_pos = (self.media_end_time / duration) * \
(self.ui.slider_progress.maximum() -
self.ui.slider_progress.minimum())
self.ui.slider_progress.setHighlight(
int(slider_start_pos), int(slider_end_pos)
)
else:
self.media_start_time = 0
self.media_end_time = -1
def run(self):
"""
Execute the loop
"""
if self.timestamp_filename is None:
self._show_error("No timestamp file chosen")
return
if self.video_filename is None:
self._show_error("No video file chosen")
return
try:
self.update_slider_highlight()
self.media_player.play()
self.media_player.set_time(self.media_start_time)
self.media_started_playing = True
self.media_is_playing = True
self.play_pause_model.setState(False)
except Exception as ex:
self._show_error(str(ex))
print(traceback.format_exc())
def play_pause(self):
"""Toggle play/pause status
"""
if not self.media_started_playing:
self.run()
return
if self.media_is_playing:
self.media_player.pause()
else:
self.media_player.play()
self.media_is_playing = not self.media_is_playing
self.play_pause_model.setState(not self.media_is_playing)
def toggle_full_screen(self):
if self.is_full_screen:
# TODO Artifacts still happen some time when exiting full screen
# in X11
self.ui.frame_media.showNormal()
self.ui.frame_media.restoreGeometry(self.original_geometry)
self.ui.frame_media.setParent(self.ui.widget_central)
self.ui.layout_main.addWidget(self.ui.frame_media, 2, 3, 3, 1)
# self.ui.frame_media.ensurePolished()
else:
self.ui.frame_media.setParent(None)
self.ui.frame_media.setWindowFlags(Qt.FramelessWindowHint |
Qt.CustomizeWindowHint)
self.original_geometry = self.ui.frame_media.saveGeometry()
desktop = QApplication.desktop()
rect = desktop.screenGeometry(desktop.screenNumber(QCursor.pos()))
self.ui.frame_media.setGeometry(rect)
self.ui.frame_media.showFullScreen()
self.ui.frame_media.show()
self.ui.frame_video.setFocus()
self.is_full_screen = not self.is_full_screen
def browse_timestamp_handler(self):
"""
Handler when the timestamp browser button is clicked
"""
tmp_name, _ = QFileDialog.getOpenFileName(
self, "Choose Timestamp file", None,
"Timestamp File (*.tmsp);;All Files (*)"
)
if not tmp_name:
return
self.set_timestamp_filename(QDir.toNativeSeparators(tmp_name))
def _sort_model(self):
self.ui.list_timestamp.sortByColumn(0, Qt.AscendingOrder)
def _select_blank_row(self, parent, start, end):
self.ui.list_timestamp.selectRow(start)
def set_timestamp_filename(self, filename):
"""
Set the timestamp file name
"""
if not os.path.isfile(filename):
self._show_error("Cannot access timestamp file " + filename)
return
try:
self.timestamp_model = TimestampModel(filename, self)
self.timestamp_model.timeParseError.connect(
lambda err: self._show_error(err)
)
self.proxy_model.setSortRole(Qt.UserRole)
self.proxy_model.dataChanged.connect(self._sort_model)
self.proxy_model.dataChanged.connect(self.update_slider_highlight)
self.proxy_model.setSourceModel(self.timestamp_model)
self.proxy_model.rowsInserted.connect(self._sort_model)
self.proxy_model.rowsInserted.connect(self._select_blank_row)
self.ui.list_timestamp.setModel(self.proxy_model)
self.timestamp_filename = filename
self.ui.entry_timestamp.setText(self.timestamp_filename)
self.mapper.setModel(self.proxy_model)
self.mapper.addMapping(self.ui.entry_start_time, 0)
self.mapper.addMapping(self.ui.entry_end_time, 1)
self.mapper.addMapping(self.ui.entry_description, 2)
self.ui.list_timestamp.selectionModel().selectionChanged.connect(
self.timestamp_selection_changed)
self._sort_model()
directory = os.path.dirname(self.timestamp_filename)
basename = os.path.basename(self.timestamp_filename)
timestamp_name_without_ext = os.path.splitext(basename)[0]
for file_in_dir in os.listdir(directory):
current_filename = os.path.splitext(file_in_dir)[0]
found_video = (current_filename == timestamp_name_without_ext
and file_in_dir != basename)
if found_video:
found_video_file = os.path.join(directory, file_in_dir)
self.set_video_filename(found_video_file)
break
except ValueError as err:
self._show_error("Timestamp file is invalid")
def timestamp_selection_changed(self, selected, deselected):
if len(selected) > 0:
self.mapper.setCurrentModelIndex(selected.indexes()[0])
self.ui.button_save.setEnabled(True)
self.ui.button_remove_entry.setEnabled(True)
self.ui.entry_start_time.setReadOnly(False)
self.ui.entry_end_time.setReadOnly(False)
self.ui.entry_description.setReadOnly(False)
else:
self.mapper.setCurrentModelIndex(QModelIndex())
self.ui.button_save.setEnabled(False)
self.ui.button_remove_entry.setEnabled(False)
self.ui.entry_start_time.clear()
self.ui.entry_end_time.clear()
self.ui.entry_description.clear()
self.ui.entry_start_time.setReadOnly(True)
self.ui.entry_end_time.setReadOnly(True)
self.ui.entry_description.setReadOnly(True)
def set_video_filename(self, filename):
"""
Set the video filename
"""
if not os.path.isfile(filename):
self._show_error("Cannot access video file " + filename)
return
self.video_filename = filename
media = self.vlc_instance.media_new(self.video_filename)
media.parse()
if not media.get_duration():
self._show_error("Cannot play this media file")
self.media_player.set_media(None)
self.video_filename = None
else:
self.media_player.set_media(media)
if sys.platform.startswith('linux'): # for Linux using the X Server
self.media_player.set_xwindow(self.ui.frame_video.winId())
elif sys.platform == "win32": # for Windows
self.media_player.set_hwnd(self.ui.frame_video.winId())
elif sys.platform == "darwin": # for MacOS
self.media_player.set_nsobject(self.ui.frame_video.winId())
self.ui.entry_video.setText(self.video_filename)
self.media_started_playing = False
self.media_is_playing = False
self.set_volume(self.ui.slider_volume.value())
self.play_pause_model.setState(True)
def browse_video_handler(self):
"""
Handler when the video browse button is clicked
"""
tmp_name, _ = QFileDialog.getOpenFileName(
self, "Choose Video file", None,
"All Files (*)"
)
if not tmp_name:
return
self.set_video_filename(QDir.toNativeSeparators(tmp_name))
def _show_error(self, message, title="Error"):
QMessageBox.warning(self, title, message)
class Window(QWidget):
def __init__(self, parent=None):
super(Window, self).__init__(parent)
# Set up the model.
self.setupModel()
# Set up the widgets.
nameLabel = QLabel("Na&me:")
nameEdit = QLineEdit()
addressLabel = QLabel("&Address:")
addressEdit = QTextEdit()
typeLabel = QLabel("&Type:")
typeComboBox = QComboBox()
self.nextButton = QPushButton("&Next")
self.previousButton = QPushButton("&Previous")
nameLabel.setBuddy(nameEdit)
addressLabel.setBuddy(addressEdit)
typeLabel.setBuddy(typeComboBox)
typeComboBox.setModel(self.typeModel)
# Set up the mapper.
self.mapper = QDataWidgetMapper(self)
self.mapper.setModel(self.model)
self.mapper.addMapping(nameEdit, 0)
self.mapper.addMapping(addressEdit, 1)
self.mapper.addMapping(typeComboBox, 2, 'currentIndex')
# Set up connections and layouts.
self.previousButton.clicked.connect(self.mapper.toPrevious)
self.nextButton.clicked.connect(self.mapper.toNext)
self.mapper.currentIndexChanged.connect(self.updateButtons)
layout = QGridLayout()
layout.addWidget(nameLabel, 0, 0, 1, 1)
layout.addWidget(nameEdit, 0, 1, 1, 1)
layout.addWidget(self.previousButton, 0, 2, 1, 1)
layout.addWidget(addressLabel, 1, 0, 1, 1)
layout.addWidget(addressEdit, 1, 1, 2, 1)
layout.addWidget(self.nextButton, 1, 2, 1, 1)
layout.addWidget(typeLabel, 3, 0, 1, 1)
layout.addWidget(typeComboBox, 3, 1, 1, 1)
self.setLayout(layout)
self.setWindowTitle("Delegate Widget Mapper")
self.mapper.toFirst()
def setupModel(self):
items = ("Home", "Work", "Other")
self.typeModel = QStringListModel(items, self)
self.model = QStandardItemModel(5, 3, self)
names = ("Alice", "Bob", "Carol", "Donald", "Emma")
addresses = ("<qt>123 Main Street<br/>Market Town</qt>",
"<qt>PO Box 32<br/>Mail Handling Service"
"<br/>Service City</qt>",
"<qt>The Lighthouse<br/>Remote Island</qt>",
"<qt>47338 Park Avenue<br/>Big City</qt>",
"<qt>Research Station<br/>Base Camp<br/>Big Mountain</qt>")
types = ("0", "1", "2", "0", "2")
for row, name in enumerate(names):
item = QStandardItem(name)
self.model.setItem(row, 0, item)
item = QStandardItem(addresses[row])
self.model.setItem(row, 1, item)
item = QStandardItem(types[row])
self.model.setItem(row, 2, item)
def updateButtons(self, row):
self.previousButton.setEnabled(row > 0)
self.nextButton.setEnabled(row < self.model.rowCount() - 1)
def __init__(self, parent=None):
QMainWindow.__init__(self, parent)
self.ui = uic.loadUi("gui/main_window.ui")
self.timestamp_filename = None
self.video_filename = None
self.media_start_time = None
self.media_end_time = None
self.restart_needed = False
self.timer_period = 100
self.is_full_screen = False
self.media_started_playing = False
self.media_is_playing = False
self.original_geometry = None
self.mute = False
self.timestamp_model = TimestampModel(None, self)
self.proxy_model = QSortFilterProxyModel(self)
self.ui.list_timestamp.setModel(self.timestamp_model)
self.ui.list_timestamp.doubleClicked.connect(
lambda event: self.ui.list_timestamp.indexAt(event.pos()).isValid()
and self.run()
)
self.timer = QTimer()
self.timer.timeout.connect(self.update_ui)
self.timer.timeout.connect(self.timer_handler)
self.timer.start(self.timer_period)
self.vlc_instance = vlc.Instance()
self.media_player = self.vlc_instance.media_player_new()
# if sys.platform == "darwin": # for MacOS
# self.ui.frame_video = QMacCocoaViewContainer(0)
self.ui.frame_video.doubleClicked.connect(self.toggle_full_screen)
self.ui.frame_video.wheel.connect(self.wheel_handler)
self.ui.frame_video.keyPressed.connect(self.key_handler)
# Set up buttons
self.ui.button_run.clicked.connect(self.run)
self.ui.button_timestamp_browse.clicked.connect(
self.browse_timestamp_handler
)
self.ui.button_video_browse.clicked.connect(
self.browse_video_handler
)
self.play_pause_model = ToggleButtonModel(None, self)
self.play_pause_model.setStateMap(
{
True: {
"text": "",
"icon": qta.icon("fa.play", scale_factor=0.7)
},
False: {
"text": "",
"icon": qta.icon("fa.pause", scale_factor=0.7)
}
}
)
self.ui.button_play_pause.setModel(self.play_pause_model)
self.ui.button_play_pause.clicked.connect(self.play_pause)
self.mute_model = ToggleButtonModel(None, self)
self.mute_model.setStateMap(
{
True: {
"text": "",
"icon": qta.icon("fa.volume-up", scale_factor=0.8)
},
False: {
"text": "",
"icon": qta.icon("fa.volume-off", scale_factor=0.8)
}
}
)
self.ui.button_mute_toggle.setModel(self.mute_model)
self.ui.button_mute_toggle.clicked.connect(self.toggle_mute)
self.ui.button_full_screen.setIcon(
qta.icon("ei.fullscreen", scale_factor=0.6)
)
self.ui.button_full_screen.setText("")
self.ui.button_full_screen.clicked.connect(self.toggle_full_screen)
self.ui.button_speed_up.clicked.connect(self.speed_up_handler)
self.ui.button_speed_up.setIcon(
qta.icon("fa.arrow-circle-o-up", scale_factor=0.8)
)
self.ui.button_speed_up.setText("")
self.ui.button_slow_down.clicked.connect(self.slow_down_handler)
self.ui.button_slow_down.setIcon(
qta.icon("fa.arrow-circle-o-down", scale_factor=0.8)
)
self.ui.button_slow_down.setText("")
self.ui.button_mark_start.setIcon(
qta.icon("fa.quote-left", scale_factor=0.7)
)
self.ui.button_mark_start.setText("")
self.ui.button_mark_end.setIcon(
qta.icon("fa.quote-right", scale_factor=0.7)
)
self.ui.button_mark_end.setText("")
self.ui.button_add_entry.clicked.connect(self.add_entry)
self.ui.button_remove_entry.clicked.connect(self.remove_entry)
self.ui.button_mark_start.clicked.connect(
lambda: self.set_mark(start_time=int(
self.media_player.get_position() *
self.media_player.get_media().get_duration()))
)
self.ui.button_mark_end.clicked.connect(
lambda: self.set_mark(end_time=int(
self.media_player.get_position() *
self.media_player.get_media().get_duration()))
)
self.ui.slider_progress.setTracking(False)
self.ui.slider_progress.valueChanged.connect(self.set_media_position)
self.ui.slider_volume.valueChanged.connect(self.set_volume)
self.ui.entry_description.setReadOnly(True)
# Mapper between the table and the entry detail
self.mapper = QDataWidgetMapper()
self.mapper.setSubmitPolicy(QDataWidgetMapper.ManualSubmit)
self.ui.button_save.clicked.connect(self.mapper.submit)
# Set up default volume
self.set_volume(self.ui.slider_volume.value())
self.vlc_events = self.media_player.event_manager()
self.vlc_events.event_attach(
vlc.EventType.MediaPlayerTimeChanged, self.media_time_change_handler
)
# Let our application handle mouse and key input instead of VLC
self.media_player.video_set_mouse_input(False)
self.media_player.video_set_key_input(False)
self.ui.show()
class MainWindow(QMainWindow):
def __init__(self, data):
super().__init__()
self.resize(400, 600)
self.setWindowTitle('Logger Skeleton')
self.statusBar().showMessage("Ready", 2000)
# Make widgets ####################################
self.tabs = QTabWidget(self)
self.setCentralWidget(self.tabs)
# Add tabs
self.table_tab = QWidget(self)
self.stats_tab = QWidget(self)
self.tabs.addTab(self.table_tab, "Table")
self.tabs.addTab(self.stats_tab, "Stats")
# Table tab ###########################################################
self.table_view = QTableView(self.table_tab)
self.text_edit = QPlainTextEdit()
self.btn_add_row = QPushButton("Add a row")
#self.btn_remove_row = QPushButton("Remove selected rows")
table_tab_vbox = QVBoxLayout()
table_tab_vbox.addWidget(self.table_view)
table_tab_vbox.addWidget(self.text_edit)
table_tab_vbox.addWidget(self.btn_add_row)
#table_tab_vbox.addWidget(self.btn_remove_row)
self.table_tab.setLayout(table_tab_vbox)
# Set model #######################################
my_model = DataQtModel(data, parent=self) # TODO: right use of "parent" ?
# Proxy model #####################################
proxy_model = QSortFilterProxyModel(parent=self) # TODO: right use of "parent" ?
proxy_model.setSourceModel(my_model)
self.table_view.setModel(proxy_model)
#self.table_view.setModel(my_model)
# Set the view ####################################
self.table_view.setSelectionBehavior(QAbstractItemView.SelectRows) # Select the full row when a cell is selected (See http://doc.qt.io/qt-5/qabstractitemview.html#selectionBehavior-prop )
#self.table_view.setSelectionMode(QAbstractItemView.SingleSelection) # Set selection mode. See http://doc.qt.io/qt-5/qabstractitemview.html#selectionMode-prop
self.table_view.setAlternatingRowColors(True)
self.table_view.setSortingEnabled(True)
self.table_view.setColumnWidth(0, 200) # TODO: automatically get the best width
self.table_view.horizontalHeader().setSectionResizeMode(QHeaderView.Stretch) # https://stackoverflow.com/q/17535563
self.table_view.setColumnHidden(COMMENT_COLUMN_INDEX, True)
delegate = Delegate()
self.table_view.setItemDelegate(delegate)
# Set key shortcut ################################
# see https://stackoverflow.com/a/17631703 and http://doc.qt.io/qt-5/qaction.html#details
# Add row action
add_action = QAction(self.table_view)
add_action.setShortcut(Qt.CTRL | Qt.Key_N)
add_action.triggered.connect(self.add_row_btn_callback)
self.table_view.addAction(add_action)
# Delete action
del_action = QAction(self.table_view)
del_action.setShortcut(Qt.Key_Delete)
del_action.triggered.connect(self.remove_row_callback)
self.table_view.addAction(del_action)
# Set QDataWidgetMapper ###########################
self.mapper = QDataWidgetMapper()
self.mapper.setModel(proxy_model) # WARNING: do not use `my_model` here otherwise the index mapping will be wrong!
self.mapper.addMapping(self.text_edit, COMMENT_COLUMN_INDEX)
self.mapper.toFirst() # TODO: is it a good idea ?
self.table_view.selectionModel().selectionChanged.connect(self.update_selection)
# Set slots #######################################
self.btn_add_row.clicked.connect(self.add_row_btn_callback)
#self.btn_remove_row.clicked.connect(self.remove_row_callback)
#self.table_view.setColumnHidden(1, True)
# Stats tab ###########################################################
# See https://matplotlib.org/examples/user_interfaces/embedding_in_qt5.html
stats_tab_layout = QVBoxLayout(self.stats_tab)
self.plot_canvas = PlotCanvas(data, self.stats_tab, width=5, height=4, dpi=100)
stats_tab_layout.addWidget(self.plot_canvas)
###################################################
#proxy_model.dataChanged.connect(plot_canvas.update_figure)
#proxy_model.rowsInserted.connect(plot_canvas.update_figure) # TODO
#proxy_model.rowsRemoved.connect(plot_canvas.update_figure) # TODO
self.tabs.currentChanged.connect(self.updatePlot) # Update the stats plot when the tabs switch to the stats tab
# Show ############################################
self.show()
def update_selection(self, selected, deselected):
index = self.table_view.selectionModel().currentIndex()
self.mapper.setCurrentIndex(index.row())
print("Index: ", index.row())
def updatePlot(self, index):
"""
Parameters
----------
index
Returns
-------
"""
if index == self.tabs.indexOf(self.stats_tab):
self.plot_canvas.update_figure()
def add_row_btn_callback(self):
parent = QModelIndex() # More useful with e.g. tree structures
#row_index = 0 # Insert new rows to the begining
row_index = self.table_view.model().rowCount(parent) # Insert new rows to the end
self.table_view.model().insertRows(row_index, 1, parent)
def remove_row_callback(self):
parent = QModelIndex() # More useful with e.g. tree structures
# See http://doc.qt.io/qt-5/model-view-programming.html#handling-selections-in-item-views
#current_index = self.table_view.selectionModel().currentIndex()
#print("Current index:", current_index.row(), current_index.column())
selection_index_list = self.table_view.selectionModel().selectedRows()
selected_row_list = [selection_index.row() for selection_index in selection_index_list]
print("Current selection:", selected_row_list)
#row_index = 0 # Remove the first row
#row_index = self.table_view.model().rowCount(parent) - 1 # Remove the last row
# WARNING: the list of rows to remove MUST be sorted in reverse order
# otherwise the index of rows to remove may change at each iteration of the for loop!
# TODO: there should be a lock mechanism to avoid model modifications from external sources while iterating this loop...
# Or as a much simpler alternative, modify the ItemSelectionMode to forbid the non contiguous selection of rows and remove the following for loop
for row_index in sorted(selected_row_list, reverse=True):
# Remove rows one by one to allow the removql of non-contiguously selected rows (e.g. "rows 0, 2 and 3")
success = self.table_view.model().removeRows(row_index, 1, parent)
if not success:
raise Exception("Unknown error...") # TODO
def __init__(self, data):
super().__init__()
self.resize(400, 600)
self.setWindowTitle('Logger Skeleton')
self.statusBar().showMessage("Ready", 2000)
# Make widgets ####################################
self.tabs = QTabWidget(self)
self.setCentralWidget(self.tabs)
# Add tabs
self.table_tab = QWidget(self)
self.stats_tab = QWidget(self)
self.tabs.addTab(self.table_tab, "Table")
self.tabs.addTab(self.stats_tab, "Stats")
# Table tab ###########################################################
self.table_view = QTableView(self.table_tab)
self.text_edit = QPlainTextEdit()
self.btn_add_row = QPushButton("Add a row")
#self.btn_remove_row = QPushButton("Remove selected rows")
table_tab_vbox = QVBoxLayout()
table_tab_vbox.addWidget(self.table_view)
table_tab_vbox.addWidget(self.text_edit)
table_tab_vbox.addWidget(self.btn_add_row)
#table_tab_vbox.addWidget(self.btn_remove_row)
self.table_tab.setLayout(table_tab_vbox)
# Set model #######################################
my_model = DataQtModel(data, parent=self) # TODO: right use of "parent" ?
# Proxy model #####################################
proxy_model = QSortFilterProxyModel(parent=self) # TODO: right use of "parent" ?
proxy_model.setSourceModel(my_model)
self.table_view.setModel(proxy_model)
#self.table_view.setModel(my_model)
# Set the view ####################################
self.table_view.setSelectionBehavior(QAbstractItemView.SelectRows) # Select the full row when a cell is selected (See http://doc.qt.io/qt-5/qabstractitemview.html#selectionBehavior-prop )
#self.table_view.setSelectionMode(QAbstractItemView.SingleSelection) # Set selection mode. See http://doc.qt.io/qt-5/qabstractitemview.html#selectionMode-prop
self.table_view.setAlternatingRowColors(True)
self.table_view.setSortingEnabled(True)
self.table_view.setColumnWidth(0, 200) # TODO: automatically get the best width
self.table_view.horizontalHeader().setSectionResizeMode(QHeaderView.Stretch) # https://stackoverflow.com/q/17535563
self.table_view.setColumnHidden(COMMENT_COLUMN_INDEX, True)
delegate = Delegate()
self.table_view.setItemDelegate(delegate)
# Set key shortcut ################################
# see https://stackoverflow.com/a/17631703 and http://doc.qt.io/qt-5/qaction.html#details
# Add row action
add_action = QAction(self.table_view)
add_action.setShortcut(Qt.CTRL | Qt.Key_N)
add_action.triggered.connect(self.add_row_btn_callback)
self.table_view.addAction(add_action)
# Delete action
del_action = QAction(self.table_view)
del_action.setShortcut(Qt.Key_Delete)
del_action.triggered.connect(self.remove_row_callback)
self.table_view.addAction(del_action)
# Set QDataWidgetMapper ###########################
self.mapper = QDataWidgetMapper()
self.mapper.setModel(proxy_model) # WARNING: do not use `my_model` here otherwise the index mapping will be wrong!
self.mapper.addMapping(self.text_edit, COMMENT_COLUMN_INDEX)
self.mapper.toFirst() # TODO: is it a good idea ?
self.table_view.selectionModel().selectionChanged.connect(self.update_selection)
# Set slots #######################################
self.btn_add_row.clicked.connect(self.add_row_btn_callback)
#self.btn_remove_row.clicked.connect(self.remove_row_callback)
#self.table_view.setColumnHidden(1, True)
# Stats tab ###########################################################
# See https://matplotlib.org/examples/user_interfaces/embedding_in_qt5.html
stats_tab_layout = QVBoxLayout(self.stats_tab)
self.plot_canvas = PlotCanvas(data, self.stats_tab, width=5, height=4, dpi=100)
stats_tab_layout.addWidget(self.plot_canvas)
###################################################
#proxy_model.dataChanged.connect(plot_canvas.update_figure)
#proxy_model.rowsInserted.connect(plot_canvas.update_figure) # TODO
#proxy_model.rowsRemoved.connect(plot_canvas.update_figure) # TODO
self.tabs.currentChanged.connect(self.updatePlot) # Update the stats plot when the tabs switch to the stats tab
# Show ############################################
self.show()
class SettingsController(QObject, LogMixin):
settingsClosed = pyqtSignal() # send after model or backend data has been updated
def __init__(self, parent):
"""
Initiate settings editing
Signals
* settingsClosed
:param parent: parent window of settings dialog
:return:
"""
super().__init__(parent)
self._parent = parent
print("controller/SettingsController parent: ", self._parent, " -> self: ", self) if oPB.PRINTHIER else None
self.logger.debug("Initialize settings dialog")
self.model = None # data models
self.datamapper = None # QDataWidgetMapper object for field mapping
self._modelDataChanged = False # is connect via model_data_changed function to itemChanged Signal of QStandardItemModel, will be reset in close_project()
# create main window and logic
self.ui = SettingsDialog(self._parent)
# build special button groups for False/True choice
self.optionGroupSrvVersion = SpecialOptionButtonGroup(self.ui.rdOpsiSrvNew, self.ui.rdOpsiSrvOld,
[self.ui.rdSUDOWithPass, self.ui.rdSUDOWithoutPass],
[self.ui.inpRootPass])
self.optionGroupSUDO = SpecialOptionButtonGroup(self.ui.rdSUDOWithPass, self.ui.rdSUDOWithoutPass)
self.optionGroupEditorTyp = SpecialOptionButtonGroup(self.ui.rdEditorInternal, self.ui.rdEditorExternal,
[self.ui.chkSyntaxHighlight, self.ui.chkCodeFolding],
[self.ui.btnExternalEditor, self.ui.inpExternalEditor])
self.optionGroupDepotFuncs = SpecialOptionButtonGroup(self.ui.chkUseDepotFunctions, None, [],
[self.ui.inpInstallCommand, self.ui.inpInstSetupCommand,
self.ui.inpUninstallCommand, self.ui.inpUploadCommand])
self.optionGroupProxy = SpecialOptionButtonGroup(self.ui.chkUseProxy, None,
[self.ui.inpProxyServer, self.ui.inpProxyPort,
self.ui.inpProxyUser, self.ui.inpProxyPass], [])
self.optionGroupSSHKeyFile = SpecialOptionButtonGroup(self.ui.chkUseKeyFile, None,
[self.ui.btnSetKeyFile, self.ui.inpKeyFile], [])
self.optionGroupLogFile = SpecialOptionButtonGroup(self.ui.chkWriteLog, None,
[self.ui.btnLogFile, self.ui.inpLogFile, self.ui.cmbLogLevel], [])
self.generate_model()
self.connect_signals()
# open modal dialog
self.ui.tabWidget.setCurrentIndex(0)
def generate_model(self):
"""Create data models and assign field mappings"""
self.logger.debug("Generate configuration model")
self.model = QtGui.QStandardItemModel(self.ui)
self.model.setItem(0, 0, QtGui.QStandardItem(ConfigHandler.cfg.opsi_server))
self.model.setItem(0, 1, QtGui.QStandardItem(ConfigHandler.cfg.opsi_user))
self.model.setItem(0, 2, QtGui.QStandardItem(ConfigHandler.cfg.opsi_pass))
self.model.setItem(0, 3, QtGui.QStandardItem(ConfigHandler.cfg.root_pass))
self.model.setItem(0, 4, QtGui.QStandardItem(ConfigHandler.cfg.usenetdrive))
self.model.setItem(0, 5, QtGui.QStandardItem(ConfigHandler.cfg.age))
self.model.setItem(0, 6, QtGui.QStandardItem(ConfigHandler.cfg.sudo))
self.model.setItem(0, 7, QtGui.QStandardItem(ConfigHandler.cfg.sshport))
self.model.setItem(0, 8, QtGui.QStandardItem(ConfigHandler.cfg.usekeyfile))
self.model.setItem(0, 9, QtGui.QStandardItem(ConfigHandler.cfg.keyfilename))
self.model.setItem(0, 10, QtGui.QStandardItem(ConfigHandler.cfg.packagemaintainer))
self.model.setItem(0, 11, QtGui.QStandardItem(ConfigHandler.cfg.mailaddress))
self.model.setItem(0, 12, QtGui.QStandardItem(ConfigHandler.cfg.dev_dir))
self.model.setItem(0, 13, QtGui.QStandardItem(ConfigHandler.cfg.buildcommand))
self.model.setItem(0, 14, QtGui.QStandardItem(ConfigHandler.cfg.installcommand))
self.model.setItem(0, 15, QtGui.QStandardItem(ConfigHandler.cfg.uninstallcommand))
self.model.setItem(0, 16, QtGui.QStandardItem(ConfigHandler.cfg.showoutput))
self.model.setItem(0, 17, QtGui.QStandardItem(ConfigHandler.cfg.reload_for_at))
self.model.setItem(0, 18, QtGui.QStandardItem(ConfigHandler.cfg.wol_lead_time))
self.model.setItem(0, 19, QtGui.QStandardItem(ConfigHandler.cfg.uploadcommand))
self.model.setItem(0, 20, QtGui.QStandardItem(ConfigHandler.cfg.instsetupcommand))
self.model.setItem(0, 21, QtGui.QStandardItem(ConfigHandler.cfg.use_depot_funcs))
self.model.setItem(0, 22, QtGui.QStandardItem(ConfigHandler.cfg.use_extended_changelog))
self.model.setItem(0, 23, QtGui.QStandardItem(ConfigHandler.cfg.scripteditor))
self.model.setItem(0, 24, QtGui.QStandardItem(ConfigHandler.cfg.chlog_block_marker))
self.model.setItem(0, 25, QtGui.QStandardItem(ConfigHandler.cfg.editor_intern))
self.model.setItem(0, 26, QtGui.QStandardItem(ConfigHandler.cfg.editor_use_styling))
self.model.setItem(0, 27, QtGui.QStandardItem(ConfigHandler.cfg.editor_use_folding))
self.model.setItem(0, 28, QtGui.QStandardItem(ConfigHandler.cfg.chlog_on_build))
self.model.setItem(0, 29, QtGui.QStandardItem(ConfigHandler.cfg.chlog_on_save))
self.model.setItem(0, 30, QtGui.QStandardItem(ConfigHandler.cfg.no_error_msg))
self.model.setItem(0, 31, QtGui.QStandardItem(ConfigHandler.cfg.no_warning_msg))
self.model.setItem(0, 32, QtGui.QStandardItem(ConfigHandler.cfg.no_info_msg))
self.model.setItem(0, 33, QtGui.QStandardItem(ConfigHandler.cfg.no_at_warning_msg))
self.model.setItem(0, 34, QtGui.QStandardItem(ConfigHandler.cfg.language))
self.model.setItem(0, 35, QtGui.QStandardItem(ConfigHandler.cfg.useproxy))
self.model.setItem(0, 36, QtGui.QStandardItem(ConfigHandler.cfg.updatecheck))
self.model.setItem(0, 37, QtGui.QStandardItem(ConfigHandler.cfg.proxy_server))
self.model.setItem(0, 38, QtGui.QStandardItem(ConfigHandler.cfg.proxy_port))
self.model.setItem(0, 39, QtGui.QStandardItem(ConfigHandler.cfg.proxy_user))
self.model.setItem(0, 40, QtGui.QStandardItem(ConfigHandler.cfg.proxy_pass))
self.model.setItem(0, 41, QtGui.QStandardItem(ConfigHandler.cfg.log_always))
self.model.setItem(0, 42, QtGui.QStandardItem(ConfigHandler.cfg.log_file))
self.model.setItem(0, 43, QtGui.QStandardItem(ConfigHandler.cfg.log_level))
self.logger.debug("Create data widget mapper")
self.datamapper = QDataWidgetMapper(self.ui)
self.datamapper.setModel(self.model)
self.datamapper.addMapping(self.ui.inpConfigServer, 0)
self.datamapper.addMapping(self.ui.inpOpsiUser, 1)
self.datamapper.addMapping(self.ui.inpOpsiPass, 2)
self.datamapper.addMapping(self.ui.inpRootPass, 3)
self.datamapper.addMapping(self.ui.chkUseNetworkDrive, 4, "checked")
self.datamapper.addMapping(self.optionGroupSrvVersion, 5, "checked")
self.datamapper.addMapping(self.optionGroupSUDO, 6, "checked")
self.datamapper.addMapping(self.ui.inpSSHPort, 7)
self.datamapper.addMapping(self.optionGroupSSHKeyFile, 8, "checked")
self.datamapper.addMapping(self.ui.inpKeyFile, 9)
self.datamapper.addMapping(self.ui.inpMaintainer, 10)
self.datamapper.addMapping(self.ui.inpMailAddress, 11)
self.datamapper.addMapping(self.ui.inpDevFolder, 12)
self.datamapper.addMapping(self.ui.inpBuildCommand, 13)
self.datamapper.addMapping(self.ui.inpInstallCommand, 14)
self.datamapper.addMapping(self.ui.inpUninstallCommand, 15)
self.datamapper.addMapping(self.ui.chkShowOutput, 16, "checked")
self.datamapper.addMapping(self.ui.chkAlwaysReload, 17, "checked")
self.datamapper.addMapping(self.ui.inpWOLLeadTime, 18)
self.datamapper.addMapping(self.ui.inpUploadCommand, 19)
self.datamapper.addMapping(self.ui.inpInstSetupCommand, 20)
#self.datamapper.addMapping(self.settings.chkUseDepotFunctions, 21, "checked")
self.datamapper.addMapping(self.optionGroupDepotFuncs, 21, "checked")
self.datamapper.addMapping(self.ui.chkExtendedEditor, 22, "checked")
self.datamapper.addMapping(self.ui.inpExternalEditor, 23)
self.datamapper.addMapping(self.ui.inpBlockMarker, 24)
self.datamapper.addMapping(self.optionGroupEditorTyp, 25, "checked")
self.datamapper.addMapping(self.ui.chkSyntaxHighlight, 26, "checked")
self.datamapper.addMapping(self.ui.chkCodeFolding, 27, "checked")
self.datamapper.addMapping(self.ui.chkForceEntryBuild, 28, "checked")
self.datamapper.addMapping(self.ui.chkForceEntrySave, 29, "checked")
self.datamapper.addMapping(self.ui.chkMsgError, 30, "checked")
self.datamapper.addMapping(self.ui.chkMsgWarning, 31, "checked")
self.datamapper.addMapping(self.ui.chkMsgInfo, 32, "checked")
self.datamapper.addMapping(self.ui.chkMsgAT, 33, "checked")
self.datamapper.addMapping(self.ui.cmbLanguage, 34, "currentText")
self.datamapper.addMapping(self.optionGroupProxy, 35, "checked")
self.datamapper.addMapping(self.ui.chkUpdates, 36, "checked")
self.datamapper.addMapping(self.ui.inpProxyServer, 37)
self.datamapper.addMapping(self.ui.inpProxyPort, 38)
self.datamapper.addMapping(self.ui.inpProxyUser, 39)
self.datamapper.addMapping(self.ui.inpProxyPass, 40)
self.datamapper.addMapping(self.optionGroupLogFile, 41, "checked")
self.datamapper.addMapping(self.ui.inpLogFile, 42)
self.datamapper.addMapping(self.ui.cmbLogLevel, 43)
self.datamapper.toFirst()
def connect_signals(self):
"""Connect signals"""
self.logger.debug("Connect signals")
self.model.itemChanged.connect(self.model_data_changed)
self.ui.btnSave.clicked.connect(self.save_config)
self.ui.dataChanged.connect(self.datamapper.submit)
self.ui.settingsAboutToBeClosed.connect(self.close_dialog)
self.ui.rdOpsiSrvNew.clicked.connect(self.set_model_data)
self.ui.rdOpsiSrvOld.clicked.connect(self.set_model_data)
self.ui.rdSUDOWithPass.clicked.connect(self.set_model_data)
self.ui.rdSUDOWithoutPass.clicked.connect(self.set_model_data)
self.ui.rdEditorInternal.clicked.connect(self.set_model_data)
self.ui.rdEditorExternal.clicked.connect(self.set_model_data)
self.ui.chkUseDepotFunctions.clicked.connect(self.set_model_data)
self.ui.chkUseProxy.clicked.connect(self.set_model_data)
self.ui.chkUseKeyFile.clicked.connect(self.set_model_data)
self.ui.chkWriteLog.clicked.connect(self.set_model_data)
@pyqtSlot()
def model_data_changed(self):
"""Update model changed marker"""
self.logger.debug("Model data changed")
self._modelDataChanged = True
@pyqtSlot()
def set_model_data(self):
"""Whenever a special radio button or checkbox is clicked,
the corresponding model data element will be set accordingly.
This has to be done like so, because radio buttons and checkboxes are not directly linked
to the model, but via a SpecialOptionButtonGroup object.
"""
self.logger.debug("Set model data values from button: " + self.sender().objectName())
# radio buttons
if self.sender().objectName() == "rdOpsiSrvNew":
if self.ui.rdOpsiSrvNew.isChecked():
self.model.item(0, 5).setText("True")
if self.sender().objectName() == "rdOpsiSrvOld":
if self.ui.rdOpsiSrvOld.isChecked():
self.model.item(0, 5).setText("False")
if self.sender().objectName() == "rdSUDOWithPass":
if self.ui.rdSUDOWithPass.isChecked():
self.model.item(0, 6).setText("True")
if self.sender().objectName() == "rdSUDOWithoutPass":
if self.ui.rdSUDOWithoutPass.isChecked():
self.model.item(0, 6).setText("False")
if self.sender().objectName() == "rdEditorInternal":
if self.ui.rdEditorInternal.isChecked():
self.model.item(0, 25).setText("True")
if self.sender().objectName() == "rdEditorExternal":
if self.ui.rdEditorExternal.isChecked():
self.model.item(0, 25).setText("False")
# check boxes
if self.sender().objectName() == "chkUseKeyFile":
if self.ui.chkUseKeyFile.isChecked():
self.model.item(0, 8).setText("True")
else:
self.model.item(0, 8).setText("False")
if self.sender().objectName() == "chkUseDepotFunctions":
if self.ui.chkUseDepotFunctions.isChecked():
self.model.item(0, 21).setText("True")
else:
self.model.item(0, 21).setText("False")
if self.sender().objectName() == "chkUseProxy":
if self.ui.chkUseProxy.isChecked():
self.model.item(0, 35).setText("True")
else:
self.model.item(0, 35).setText("False")
if self.sender().objectName() == "chkWriteLog":
if self.ui.chkWriteLog.isChecked():
self.model.item(0, 41).setText("True")
else:
self.model.item(0, 41).setText("False")
def update_backend_data(self):
self.logger.debug("Update config backend")
ConfigHandler.cfg.opsi_server = self.model.item(0, 0).text()
ConfigHandler.cfg.opsi_user = self.model.item(0, 1).text()
ConfigHandler.cfg.opsi_pass = self.model.item(0, 2).text()
ConfigHandler.cfg.root_pass = self.model.item(0, 3).text()
ConfigHandler.cfg.usenetdrive = self.model.item(0, 4).text().title()
ConfigHandler.cfg.age = self.model.item(0, 5).text().title()
ConfigHandler.cfg.sudo = self.model.item(0, 6).text().title()
ConfigHandler.cfg.cfg.sshport = self.model.item(0, 7).text()
ConfigHandler.cfg.usekeyfile = self.model.item(0, 8).text().title()
ConfigHandler.cfg.keyfilename = self.model.item(0, 9).text()
ConfigHandler.cfg.packagemaintainer = self.model.item(0, 10).text()
ConfigHandler.cfg.mailaddress = self.model.item(0, 11).text()
ConfigHandler.cfg.dev_dir = self.model.item(0, 12).text()
ConfigHandler.cfg.buildcommand = self.model.item(0, 13).text()
ConfigHandler.cfg.installcommand = self.model.item(0, 14).text()
ConfigHandler.cfg.uninstallcommand = self.model.item(0, 15).text()
ConfigHandler.cfg.showoutput = self.model.item(0, 16).text().title()
ConfigHandler.cfg.reload_for_at = self.model.item(0, 17).text().title()
ConfigHandler.cfg.wol_lead_time = self.model.item(0, 18).text()
ConfigHandler.cfg.uploadcommand = self.model.item(0, 19).text()
ConfigHandler.cfg.instsetupcommand = self.model.item(0, 20).text()
ConfigHandler.cfg.use_depot_funcs = self.model.item(0, 21).text().title()
ConfigHandler.cfg.use_extended_changelog = self.model.item(0, 22).text().title()
ConfigHandler.cfg.scripteditor = self.model.item(0, 23).text()
ConfigHandler.cfg.chlog_block_marker = self.model.item(0, 24).text()
ConfigHandler.cfg.editor_intern = self.model.item(0, 25).text().title()
ConfigHandler.cfg.editor_use_styling = self.model.item(0, 26).text().title()
ConfigHandler.cfg.editor_use_folding = self.model.item(0, 27).text().title()
ConfigHandler.cfg.chlog_on_build = self.model.item(0, 28).text().title()
ConfigHandler.cfg.chlog_on_save = self.model.item(0, 29).text().title()
ConfigHandler.cfg.no_error_msg = self.model.item(0, 30).text().title()
ConfigHandler.cfg.no_warning_msg = self.model.item(0, 31).text().title()
ConfigHandler.cfg.no_info_msg = self.model.item(0, 32).text().title()
ConfigHandler.cfg.no_at_warning_msg = self.model.item(0, 33).text().title()
ConfigHandler.cfg.language = self.model.item(0, 34).text()
ConfigHandler.cfg.useproxy = self.model.item(0, 35).text().title()
ConfigHandler.cfg.updatecheck = self.model.item(0, 36).text().title()
ConfigHandler.cfg.proxy_server = self.model.item(0, 37).text()
ConfigHandler.cfg.proxy_port = self.model.item(0, 38).text()
ConfigHandler.cfg.proxy_user = self.model.item(0, 39).text()
ConfigHandler.cfg.proxy_pass = self.model.item(0, 40).text()
ConfigHandler.cfg.log_always = self.model.item(0, 41).text().title()
ConfigHandler.cfg.log_file = self.model.item(0, 42).text()
ConfigHandler.cfg.log_level = self.model.item(0, 43).text()
def close_dialog(self):
"""Close settings dialog"""
ignoreChanges = True
if self._modelDataChanged == True:
retval = QMessageBox.question(None, translate("settingsController", "Question"), translate("settingsController", "There are unsaved changes! Do you really want to continue?"), QMessageBox.Yes, QMessageBox.No)
if retval == QMessageBox.No:
self.logger.debug("Unsaved changes have been ignored.")
ignoreChanges = False
if ignoreChanges:
self.logger.debug("Close settings dialog")
self.ui.close()
self.logger.debug("Emit signal settingsClosed")
self.settingsClosed.emit()
@pyqtSlot()
def save_config(self):
"""Get field values and initiate saving of configuration"""
if self._modelDataChanged:
self.update_backend_data()
ConfigHandler.cfg.save()
self._modelDataChanged = None
self.close_dialog()
class TaskView(QWidget):
close = pyqtSignal()
def __init__(self, model):
super().__init__()
self.header = QLabel('')
self.desc = QLineEdit()
self.date = QDateEdit()
self.time = QTimeEdit()
self.init_ui()
self.mapper = QDataWidgetMapper()
self.mapper.setModel(model)
self.mapper.setSubmitPolicy(QDataWidgetMapper.ManualSubmit)
self.mapper.addMapping(self.desc, TaskModel.col_desc)
self.mapper.addMapping(self.date, TaskModel.col_date)
self.mapper.addMapping(self.time, TaskModel.col_time)
def set_task(self, index):
self.mapper.setCurrentIndex(index)
self.header.setText('РЕДАКТИРОВАНИЕ ЗАДАЧИ')
# text = 'НОВАЯ ЗАДАЧА'
# self.date.setDate(QDate().currentDate())
def create_date(self):
self.date.setDisplayFormat('dd.MM.yyyy')
self.date.setCalendarPopup(True)
self.date.setFixedWidth(120)
return self.date
def create_time(self):
self.time.setDisplayFormat('hh.mm')
self.time.setFixedWidth(120)
return self.time
def create_date_buttons(self):
date_lt = QHBoxLayout()
btn_now = QPushButton('сегодня')
btn_now.clicked.connect(lambda: self.date.setDate(QDate().currentDate()))
date_lt.addWidget(btn_now, 0, Qt.AlignCenter)
btn_tomorrow = QPushButton('завтра')
btn_tomorrow.clicked.connect(lambda: self.date.setDate(QDate().currentDate().addDays(1)))
date_lt.addWidget(btn_tomorrow, 0, Qt.AlignCenter)
btn_week_later = QPushButton('через неделю')
btn_week_later.clicked.connect(lambda: self.date.setDate(QDate().currentDate().addDays(7)))
date_lt.addWidget(btn_week_later, 0, Qt.AlignCenter)
return date_lt
# def create_time_choice(self):
# self.time.setMaxVisibleItems(15)
# self.time.setStyleSheet('QComboBox { combobox-popup: 0; }')
# for it in range(24):
# self.time.insertItem(it * 2 + 0, '%.2d:00' % it)
# self.time.insertItem(it * 2 + 1, '%.2d:30' % it)
#
# return self.time
def save(self):
print('save', self.mapper.submit())
self.close.emit()
def cancel(self):
self.close.emit()
def remove(self):
self.mapper.model().removeRow(self.mapper.currentIndex())
self.close.emit()
def create_control_buttons(self):
control_lt = QHBoxLayout()
btn_save = QPushButton('Сохранить')
btn_save.clicked.connect(self.save)
control_lt.addWidget(btn_save, 0, Qt.AlignCenter)
btn_cancel = QPushButton('Отменить')
btn_cancel.clicked.connect(self.cancel)
control_lt.addWidget(btn_cancel, 0, Qt.AlignCenter)
btn_remove = QPushButton('Удалить')
btn_remove.clicked.connect(self.remove)
control_lt.addWidget(btn_remove, 1, Qt.AlignRight)
return control_lt
def create_main_form(self):
fm = QFormLayout()
fm.addRow(self.header)
fm.addRow(QLabel(''))
fm.addRow(self.desc)
fm.addRow(QLabel(''))
fm.addRow(QLabel('Когда это нужно сделать?'))
fm.addRow(self.create_date())
fm.addRow(self.create_date_buttons())
fm.addRow(QLabel(''))
fm.addRow(QLabel('Во сколько?'))
fm.addRow(self.create_time())
return fm
def init_ui(self):
layout = QVBoxLayout()
layout.addLayout(self.create_main_form())
layout.addStretch()
layout.addLayout(self.create_control_buttons())
self.setLayout(layout)
def generate_model(self):
"""Create data models and assign field mappings"""
self.logger.debug("Generate configuration model")
self.model = QtGui.QStandardItemModel(self.ui)
self.model.setItem(0, 0, QtGui.QStandardItem(ConfigHandler.cfg.opsi_server))
self.model.setItem(0, 1, QtGui.QStandardItem(ConfigHandler.cfg.opsi_user))
self.model.setItem(0, 2, QtGui.QStandardItem(ConfigHandler.cfg.opsi_pass))
self.model.setItem(0, 3, QtGui.QStandardItem(ConfigHandler.cfg.root_pass))
self.model.setItem(0, 4, QtGui.QStandardItem(ConfigHandler.cfg.usenetdrive))
self.model.setItem(0, 5, QtGui.QStandardItem(ConfigHandler.cfg.age))
self.model.setItem(0, 6, QtGui.QStandardItem(ConfigHandler.cfg.sudo))
self.model.setItem(0, 7, QtGui.QStandardItem(ConfigHandler.cfg.sshport))
self.model.setItem(0, 8, QtGui.QStandardItem(ConfigHandler.cfg.usekeyfile))
self.model.setItem(0, 9, QtGui.QStandardItem(ConfigHandler.cfg.keyfilename))
self.model.setItem(0, 10, QtGui.QStandardItem(ConfigHandler.cfg.packagemaintainer))
self.model.setItem(0, 11, QtGui.QStandardItem(ConfigHandler.cfg.mailaddress))
self.model.setItem(0, 12, QtGui.QStandardItem(ConfigHandler.cfg.dev_dir))
self.model.setItem(0, 13, QtGui.QStandardItem(ConfigHandler.cfg.buildcommand))
self.model.setItem(0, 14, QtGui.QStandardItem(ConfigHandler.cfg.installcommand))
self.model.setItem(0, 15, QtGui.QStandardItem(ConfigHandler.cfg.uninstallcommand))
self.model.setItem(0, 16, QtGui.QStandardItem(ConfigHandler.cfg.showoutput))
self.model.setItem(0, 17, QtGui.QStandardItem(ConfigHandler.cfg.reload_for_at))
self.model.setItem(0, 18, QtGui.QStandardItem(ConfigHandler.cfg.wol_lead_time))
self.model.setItem(0, 19, QtGui.QStandardItem(ConfigHandler.cfg.uploadcommand))
self.model.setItem(0, 20, QtGui.QStandardItem(ConfigHandler.cfg.instsetupcommand))
self.model.setItem(0, 21, QtGui.QStandardItem(ConfigHandler.cfg.use_depot_funcs))
self.model.setItem(0, 22, QtGui.QStandardItem(ConfigHandler.cfg.use_extended_changelog))
self.model.setItem(0, 23, QtGui.QStandardItem(ConfigHandler.cfg.scripteditor))
self.model.setItem(0, 24, QtGui.QStandardItem(ConfigHandler.cfg.chlog_block_marker))
self.model.setItem(0, 25, QtGui.QStandardItem(ConfigHandler.cfg.editor_intern))
self.model.setItem(0, 26, QtGui.QStandardItem(ConfigHandler.cfg.editor_use_styling))
self.model.setItem(0, 27, QtGui.QStandardItem(ConfigHandler.cfg.editor_use_folding))
self.model.setItem(0, 28, QtGui.QStandardItem(ConfigHandler.cfg.chlog_on_build))
self.model.setItem(0, 29, QtGui.QStandardItem(ConfigHandler.cfg.chlog_on_save))
self.model.setItem(0, 30, QtGui.QStandardItem(ConfigHandler.cfg.no_error_msg))
self.model.setItem(0, 31, QtGui.QStandardItem(ConfigHandler.cfg.no_warning_msg))
self.model.setItem(0, 32, QtGui.QStandardItem(ConfigHandler.cfg.no_info_msg))
self.model.setItem(0, 33, QtGui.QStandardItem(ConfigHandler.cfg.no_at_warning_msg))
self.model.setItem(0, 34, QtGui.QStandardItem(ConfigHandler.cfg.language))
self.model.setItem(0, 35, QtGui.QStandardItem(ConfigHandler.cfg.useproxy))
self.model.setItem(0, 36, QtGui.QStandardItem(ConfigHandler.cfg.updatecheck))
self.model.setItem(0, 37, QtGui.QStandardItem(ConfigHandler.cfg.proxy_server))
self.model.setItem(0, 38, QtGui.QStandardItem(ConfigHandler.cfg.proxy_port))
self.model.setItem(0, 39, QtGui.QStandardItem(ConfigHandler.cfg.proxy_user))
self.model.setItem(0, 40, QtGui.QStandardItem(ConfigHandler.cfg.proxy_pass))
self.model.setItem(0, 41, QtGui.QStandardItem(ConfigHandler.cfg.log_always))
self.model.setItem(0, 42, QtGui.QStandardItem(ConfigHandler.cfg.log_file))
self.model.setItem(0, 43, QtGui.QStandardItem(ConfigHandler.cfg.log_level))
self.logger.debug("Create data widget mapper")
self.datamapper = QDataWidgetMapper(self.ui)
self.datamapper.setModel(self.model)
self.datamapper.addMapping(self.ui.inpConfigServer, 0)
self.datamapper.addMapping(self.ui.inpOpsiUser, 1)
self.datamapper.addMapping(self.ui.inpOpsiPass, 2)
self.datamapper.addMapping(self.ui.inpRootPass, 3)
self.datamapper.addMapping(self.ui.chkUseNetworkDrive, 4, "checked")
self.datamapper.addMapping(self.optionGroupSrvVersion, 5, "checked")
self.datamapper.addMapping(self.optionGroupSUDO, 6, "checked")
self.datamapper.addMapping(self.ui.inpSSHPort, 7)
self.datamapper.addMapping(self.optionGroupSSHKeyFile, 8, "checked")
self.datamapper.addMapping(self.ui.inpKeyFile, 9)
self.datamapper.addMapping(self.ui.inpMaintainer, 10)
self.datamapper.addMapping(self.ui.inpMailAddress, 11)
self.datamapper.addMapping(self.ui.inpDevFolder, 12)
self.datamapper.addMapping(self.ui.inpBuildCommand, 13)
self.datamapper.addMapping(self.ui.inpInstallCommand, 14)
self.datamapper.addMapping(self.ui.inpUninstallCommand, 15)
self.datamapper.addMapping(self.ui.chkShowOutput, 16, "checked")
self.datamapper.addMapping(self.ui.chkAlwaysReload, 17, "checked")
self.datamapper.addMapping(self.ui.inpWOLLeadTime, 18)
self.datamapper.addMapping(self.ui.inpUploadCommand, 19)
self.datamapper.addMapping(self.ui.inpInstSetupCommand, 20)
#self.datamapper.addMapping(self.settings.chkUseDepotFunctions, 21, "checked")
self.datamapper.addMapping(self.optionGroupDepotFuncs, 21, "checked")
self.datamapper.addMapping(self.ui.chkExtendedEditor, 22, "checked")
self.datamapper.addMapping(self.ui.inpExternalEditor, 23)
self.datamapper.addMapping(self.ui.inpBlockMarker, 24)
self.datamapper.addMapping(self.optionGroupEditorTyp, 25, "checked")
self.datamapper.addMapping(self.ui.chkSyntaxHighlight, 26, "checked")
self.datamapper.addMapping(self.ui.chkCodeFolding, 27, "checked")
self.datamapper.addMapping(self.ui.chkForceEntryBuild, 28, "checked")
self.datamapper.addMapping(self.ui.chkForceEntrySave, 29, "checked")
self.datamapper.addMapping(self.ui.chkMsgError, 30, "checked")
self.datamapper.addMapping(self.ui.chkMsgWarning, 31, "checked")
self.datamapper.addMapping(self.ui.chkMsgInfo, 32, "checked")
self.datamapper.addMapping(self.ui.chkMsgAT, 33, "checked")
self.datamapper.addMapping(self.ui.cmbLanguage, 34, "currentText")
self.datamapper.addMapping(self.optionGroupProxy, 35, "checked")
self.datamapper.addMapping(self.ui.chkUpdates, 36, "checked")
self.datamapper.addMapping(self.ui.inpProxyServer, 37)
self.datamapper.addMapping(self.ui.inpProxyPort, 38)
self.datamapper.addMapping(self.ui.inpProxyUser, 39)
self.datamapper.addMapping(self.ui.inpProxyPass, 40)
self.datamapper.addMapping(self.optionGroupLogFile, 41, "checked")
self.datamapper.addMapping(self.ui.inpLogFile, 42)
self.datamapper.addMapping(self.ui.cmbLogLevel, 43)
self.datamapper.toFirst()
class NoteEditDialog(QDialog, Ui_Dialog):
ready = pyqtSignal(bool, int, name='ready')
def __init__(self, model, row=None, *args, **kwargs):
super().__init__(*args, **kwargs)
self.init_ui()
self.init_model(model)
if row is None:
# работаем в режиме добавления
self.__model.insertRow(self.__model.rowCount())
self.__mapper.toLast()
else:
# работаем в режиме редактирования
self.__mapper.setCurrentIndex(row)
def init_ui(self):
# loadUi('ui/notes_edit_dialog.ui', self)
self.setupUi(self)
self.plannedDateTimeEdit.setMinimumDate(
QDateTime.currentDateTime().date()
)
self.plannedDateTimeEdit.setDateTime(
QDateTime.currentDateTime()
)
def init_model(self, model):
self.__model = model
self.__mapper = QDataWidgetMapper(self)
self.__mapper.setModel(self.__model)
self.__mapper.setSubmitPolicy(QDataWidgetMapper.ManualSubmit)
self.__mapper.addMapping(self.titleEdit, 1)
self.__mapper.addMapping(self.plannedDateTimeEdit, 2)
self.__mapper.addMapping(self.contentEdit, 3)
def accept(self): # это стандартный метод
super().accept()
self.__mapper.submit() # отправляем данные в модель
state = self.__model.submitAll() # отправить изменения в БД
self.ready.emit(state, self.__mapper.currentIndex())
def reject(self): # это стандартный метод
super().reject()
self.__mapper.revert()
self.__model.revertAll()
