def map_value_to_row(qt_model: QAbstractItemModel, column):
'''
qt_modelの各行（row）に対して、{引数column列目の値: row}からなる辞書を返します。
Parameters:
qt_model -- QAbstractItemModel型
e.g.
Fruit | Color
------+------
0 Apple | Red
1 Berry | Blue
column -- int型 列番号
e.g. 0
return: dict型
e.g. {'Apple': 0, 'Berry': 1}
'''
number_of_rows = qt_model.rowCount()
value_row_pair = {}
for row in range(number_of_rows):
index = qt_model.index(row, column)
value = qt_model.data(index)
if not value in value_row_pair.keys():
value_row_pair[value] = row
return value_row_pair
def __init__(self, parent):
QAbstractItemModel.__init__(self, parent)
self.rootItem = outlineItem(self, title="root", ID="0")
# Stores removed item, in order to remove them on disk when saving, depending on the file format.
self.removed = []
def __init__(self, parent: 'ElectrumWindow'):
QAbstractItemModel.__init__(self, parent)
Logger.__init__(self)
self.parent = parent
self.view = None # type: TokenHistoryList
self.transactions = OrderedDictWithIndex()
self.tx_status_cache = {} # type: Dict[str, Tuple[int, str]]
def __init__(self, parent):
QAbstractItemModel.__init__(self, parent)
Logger.__init__(self)
self.parent = parent
self.view = None # type: HistoryList
self.transactions = dict()
self.tx_tree = list()
self.expanded_groups = set()
self.tx_status_cache = {} # type: Dict[str, Tuple[int, str]]
self.group_ps = self.parent.wallet.psman.group_history
# read tx group control icons
self.tx_group_expand_icn = read_QIcon('tx_group_expand.png')
self.tx_group_collapse_icn = read_QIcon('tx_group_collapse.png')
# setup bg thread to get updated data
self.data_ready.connect(self.on_get_data, Qt.QueuedConnection)
self.get_data_thread = GetDataThread(self, self.get_history_data,
self.data_ready, self)
self.get_data_thread.data_call_args = (self.group_ps, )
self.get_data_thread.start()
# sort keys methods for columns
self.SORT_KEYS = {
HistoryColumns.TX_GROUP: self.sort_ix,
HistoryColumns.STATUS: self.sort_status,
HistoryColumns.DIP2: self.sort_dip2,
HistoryColumns.DESCRIPTION: self.sort_label,
HistoryColumns.AMOUNT: self.sort_coin_value,
HistoryColumns.BALANCE: self.sort_running_coin_balance,
HistoryColumns.FIAT_VALUE: self.sort_fiat_value,
HistoryColumns.FIAT_ACQ_PRICE: self.sort_fiat_acq_price,
HistoryColumns.FIAT_CAP_GAINS: self.sort_fiat_cap_gains,
HistoryColumns.TXID: self.sort_txid,
}
def __init__(self, parent):
"""Constructor of SearchResultsModel class
"""
QAbstractItemModel.__init__(self, parent)
self._replaceMode = False
self.fileResults = [] # list of FileResults
def setModelData(self, editor: QComboBox, model: QAbstractItemModel,
index: QModelIndex) -> None:
if index.column() == 0:
model.setData(index, editor.currentText())
else:
return super(ComboBoxDelegate,
self).setModelData(editor, model, index)
def __init__(self, parent=None):
QAbstractItemModel.__init__(self, parent)
self._all_root = Node(data=None, parent=None)
self._root = self._all_root.clone()
self._selected_node = None
self._language_filter = []
self._treeview = None
def draw_grid(self, data):
item_model = QAbstractItemModel()
i = 0
for key in data:
item_model.setData(i, {key: data[key]})
table_view.setModel(item_model)
table_view.show()
def setModelData(self, widget: QtWidgets.QWidget,
model: QtCore.QAbstractItemModel, index):
if isinstance(widget, options.CustomItemWidget):
model.setData(index, widget.data)
return
super().setModelData(widget, model, index)
def setModelData(self, editor: QWidget, model: QAbstractItemModel, index: QModelIndex):
if isinstance(editor, ExternalProgramWidget):
model.setData(index, editor.extProgramLineEdit.text(), Qt.EditRole)
elif isinstance(editor, RandomValueWidget):
model.setData(index, [editor.spinBoxRandomMin.value(), editor.spinBoxRandomMax.value()], Qt.EditRole)
else:
super().setModelData(editor, model, index)
def setModelData(self, editor: QWidget, model: QAbstractItemModel,
index: QModelIndex):
# change the state of the checkbox, i.e. if the current state is
# unchecked send the value 1 to the model.setData, otherwise send 0
model.setData(
index, 1 if index.data(Qt.CheckStateRole) == Qt.Unchecked else 0,
Qt.EditRole)
def setModelData(self, editor: QWidget, model: QAbstractItemModel,
qindex: QModelIndex):
if isinstance(editor, QComboBox):
value = editor.currentData(Qt.UserRole)
model.setData(qindex, value, Qt.EditRole)
else:
super().setModelData(editor, model, qindex)
def __init__(self, parentObject):
QAbstractItemModel.__init__(self, parentObject)
self._manuallySorted = False
self._workspace = parentObject.parent()
self._workspace.documentOpened.connect(self._onDocumentOpened)
self._workspace.documentClosed.connect(self._onDocumentClosed)
self._workspace.modificationChanged.connect(self._onDocumentDataChanged)
def __init__(self, parent):
QAbstractItemModel.__init__(self, parent)
self.rootItem = outlineItem(self, title="root", ID="0")
# Stores removed item, in order to remove them on disk when saving, depending on the file format.
self.removed = []
def __init__(
self,
root,
checkbox_columns=None,
editable_columns=None,
alignment=None,
parent=None,
):
QAbstractItemModel.__init__(self, parent=parent)
self.root = root
self.checkbox_columns = checkbox_columns
self.editable_columns = editable_columns
if alignment is not None:
self.alignment = alignment
else:
self.alignment = Qt.AlignTop | Qt.AlignLeft
self.index_from_node_cache = weakref.WeakKeyDictionary()
self.role_functions = {
Qt.DisplayRole: self.data_display,
epyqlib.utils.qt.UserRoles.sort: self.data_display,
epyqlib.utils.qt.UserRoles.unique: self.data_unique,
epyqlib.utils.qt.UserRoles.raw: self.data_display,
Qt.TextAlignmentRole: lambda index: int(self.alignment),
Qt.CheckStateRole: self.data_check_state,
Qt.EditRole: self.data_edit,
Qt.BackgroundRole: self.data_background,
Qt.ForegroundRole: self.data_foreground,
Qt.DecorationRole: self.data_decoration,
Qt.ToolTipRole: self.data_tool_tip,
Qt.FontRole: self.data_font,
}
def __init__(self, parent=None):
QAbstractItemModel.__init__(self, parent)
self.root = Node('')
self.selectedNode = None
self.languageFilter = None
self.videoResultsBackup = []
self.moviesResultsBackup = None
def setModelData(
self,
editor: QtWidgets.QComboBox,
model: QtCore.QAbstractItemModel,
index: QtCore.QModelIndex,
) -> None:
model.setData(index, editor.currentText(), Qt.EditRole)
def setModel(self, model: QAbstractItemModel):
super().setModel(model)
for row in range(model.rowCount()):
for col in range(model.columnCount()):
span = model.span(model.index(row, col))
if span.height() > 1 or span.width() > 1:
self.setSpan(row, col, span.height(), span.width())
def __init__(self, parent=None):
QAbstractItemModel.__init__(self, parent)
self.root = Node("")
self.selectedNode = None
self.languageFilter = None
self.videoResultsBackup = None
self.moviesResultsBackup = None
def __init__(self, parent):
QAbstractItemModel.__init__(self, parent)
self.nextAvailableID = 1
# Stores removed item, in order to remove them on disk when saving, depending on the file format.
self.removed = []
self._removingRows = False
def setModelData(self, widget: QtWidgets.QComboBox,
model: QtCore.QAbstractItemModel,
index: QtCore.QModelIndex):
record: collection.PackageObject = model.data(index, role=Qt.UserRole)
record.component_metadata[
collection.Metadata.TITLE_PAGE] = widget.currentText()
model.setData(index, record, role=Qt.UserRole)
def __init__(self, *args, **kwargs):
QAbstractItemModel.__init__(self, *args, **kwargs)
self._root = scriptTreeNode(None)
self._data = []
self.refresh()
def setModelData(self, editor: QWidget, model: QAbstractItemModel,
index: QModelIndex):
if index.column() > 0:
data = editor.currentData()
index.model().setData(index, data, Qt.EditRole)
model.clear456(index.row())
if data:
self.Dialog.fieldChange(index, data)
def setModelData( # pylint: disable=C0103
self, widget: QtWidgets.QWidget, model: QtCore.QAbstractItemModel,
index: QtCore.QModelIndex) -> None:
if isinstance(widget, widgets.CustomItemWidget):
model.setData(index, widget.data)
return
super().setModelData(widget, model, index)
def __init__(self, parent):
QAbstractItemModel.__init__(self, parent)
Logger.__init__(self)
self.parent = parent
self.view = None # type: HistoryList
self.transactions = OrderedDictWithIndex()
self.tx_status_cache = {} # type: Dict[str, Tuple[int, str]]
self.summary = None
def setModelData(self, editor: QWidget, model: QAbstractItemModel,
index: QModelIndex) -> None:
if index.column() == 0:
editor.interpretText()
model.setData(index, editor.value(), Qt.EditRole)
else:
return super(SpinBoxDelegate,
self).setModelData(editor, model, index)
def __init__(self, parentObject):
QAbstractItemModel.__init__(self, parentObject)
self._manuallySorted = False
self._workspace = parentObject.parent()
self._workspace.documentOpened.connect(self._onDocumentOpened)
self._workspace.documentClosed.connect(self._onDocumentClosed)
self._workspace.modificationChanged.connect(
self._onDocumentDataChanged)
def setModelData(self, editor: QWidget, model: QtCore.QAbstractItemModel,
index: QtCore.QModelIndex):
print("setModelData works")
if editor.text() != "":
model.setData(index, editor.text(), Qt.EditRole)
else:
model.removeRows(index.row())
def setModelData(self, editor: QWidget, model: QAbstractItemModel, index: QModelIndex) -> None:
# if index.data():
# model.setData(index, str(self.mTxt_address.text()))
# print(index.data())
if isinstance(editor, FileAddressEditor):
model.setData(index, editor.text())
else:
super(addressTableDelegate, self).setModelData(editor, model, index)
def __init__(self, parent):
QAbstractItemModel.__init__(self, parent)
Logger.__init__(self)
self.parent = parent
self.view = None # type: HistoryList
self.transactions = OrderedDictWithIndex()
self.tx_status_cache = {} # type: Dict[str, Tuple[int, str]]
self.summary = None
def setModelData(self, editor: QtWidgets.QWidget, treeview_model: QtCore.QAbstractItemModel,
index: QtCore.QModelIndex) -> None:
(amount, range_amount), ok = self._editor.amount()
if ok:
unit_string = self._editor.unitComboBox.currentText().strip()
treeview_model.setData(index, ((amount, range_amount), unit_string), QtCore.Qt.UserRole)
else:
self.illegalValue.emit(self._editor.amountLineEdit.text())
def setModelData( # pylint: disable=C0103,R0201
self, widget: QtWidgets.QWidget, model: QtCore.QAbstractItemModel,
index: QtCore.QModelIndex) -> None:
"""Set model data."""
record: collection.PackageObject = model.data(index, role=Qt.UserRole)
record.component_metadata[
collection.Metadata.TITLE_PAGE] = widget.currentText()
model.setData(index, record, role=Qt.UserRole)
def setModelData(self, editor: QWidget, model: QAbstractItemModel,
index: QModelIndex) -> None:
if isinstance(editor, FileAddressEditor):
model.setData(index, editor.text())
elif isinstance(editor, QComboBox):
model.setData(index, editor.currentText())
# print(editor.currentText())
else:
super(xyfieldDelegate, self).setModelData(editor, model, index)
def __init__(self, view, parent=None):
QAbstractItemModel.__init__(self, parent)
self._view = view
self._db_session = get_database_session()
self._categories = self._db_session.query(TCategories).all()
self._root = {}
self._category_dict = {}
#构造数据
self._build_data()
def __init__(self, annotations, parent=None):
QAbstractItemModel.__init__(self, parent)
start = time.time()
self._annotations = annotations
self._dirty = False
self._root = RootModelItem(self, annotations)
diff = time.time() - start
LOG.info("Created AnnotationModel in %.2fs" % (diff, ))
self.dataChanged.connect(self.onDataChanged)
self.rowsInserted.connect(self.onDataChanged)
self.rowsRemoved.connect(self.onDataChanged)
def setModelData(self, editor: QWidget,
model: QAbstractItemModel,
model_index: QModelIndex):
column = model_index.column()
if column == NAME_COL: # Part Name
text_QString = editor.text()
model.setData(model_index, text_QString, Qt.EditRole)
# elif column == VISIBLE_COL: # Visibility
# value = editor.isChecked()
# model.setData(model_index, value, Qt.EditRole)
elif column == COLOR_COL: # Color
color = editor.currentColor()
model.setData(model_index, color.name(), Qt.EditRole)
else:
QStyledItemDelegate.setModelData(self, editor, model, model_index)
def __init__(self, *args):
QAbstractItemModel.__init__(self, *args)
self._tags = []
self._currentTagIndex = QModelIndex()
defBaseColor = QApplication.instance().palette().base().color()
# yellow or maroon
brightBg = QColor('#ffff80') if defBaseColor.lightnessF() > 0.5 else QColor('#800000')
self._currentTagBrush = QBrush(brightBg)
core.workspace().cursorPositionChanged.connect(self._onCursorPositionChanged)
self._updateCurrentTagTimer = QTimer(self)
self._updateCurrentTagTimer.setInterval(300)
self._updateCurrentTagTimer.timeout.connect(self._updateCurrentTagAndEmitSignal)
def flags(self, index):
rc = QAbstractItemModel.flags(index)
validParent = index.parent().isValid()
if ((not validParent and index.column() == 0) or # can edit stamp names
(validParent and index.column() == 1)): # and variation probability
rc |= Qt.ItemIsEditable
return rc
def flags(self, index):
"""See QAbstractItemModel docs
"""
flags = QAbstractItemModel.flags(self, index)
if self._replaceMode:
flags |= Qt.ItemIsUserCheckable
return flags
def __init__(self, parent, topLevelOperator):
"""
:param topLevelOperator: An instance of OpMultiLaneDataSelectionGroup
"""
# super does not work here in Python 2.x, decorated class confuses it
QAbstractItemModel.__init__(self, parent)
self._op = topLevelOperator
def handleNewLane( multislot, laneIndex):
assert multislot is self._op.DatasetGroup
self.beginInsertRows( QModelIndex(), laneIndex, laneIndex )
self.endInsertRows()
def handleDatasetInfoChanged(slot):
# Get the row of this slot
laneSlot = slot.operator
laneIndex = laneSlot.operator.index( laneSlot )
# FIXME: For now, we update the whole row.
# Later, update only the columns that correspond to this dataset.
firstIndex = self.createIndex(laneIndex, 0)
lastIndex = self.createIndex(laneIndex, self.columnCount()-1)
self.dataChanged.emit(firstIndex, lastIndex)
def handleNewDatasetInserted(mslot, index):
mslot[index].notifyDirty( bind(handleDatasetInfoChanged) )
for laneIndex, datasetMultiSlot in enumerate(self._op.DatasetGroup):
datasetMultiSlot.notifyInserted( bind(handleNewDatasetInserted) )
for roleIndex, datasetSlot in enumerate(datasetMultiSlot):
handleNewDatasetInserted( datasetMultiSlot, roleIndex )
self._op.DatasetGroup.notifyInserted( bind(handleNewLane) )
def handleLaneRemoved( multislot, laneIndex ):
assert multislot is self._op.DatasetGroup
self.beginRemoveRows( QModelIndex(), laneIndex, laneIndex )
self.endRemoveRows()
self._op.DatasetGroup.notifyRemoved( bind(handleLaneRemoved) )
# Any lanes that already exist must be added now.
for laneIndex, slot in enumerate(self._op.DatasetGroup):
handleNewLane( self._op.DatasetGroup, laneIndex )
def headerData(self, section, orientation, role):
if orientation == Qt.Horizontal:
if role == Qt.DisplayRole or role == Qt.ToolTipRole:
if section == ActionModel.Action:
return tr("Action")
elif section == ActionModel.Shortcut:
return tr("Shortcut")
elif section == ActionModel.DefaultShortcut:
return tr("Default Shortcut")
return QAbstractItemModel.headerData(self, section, orientation, role)
def __init__(self, parent, topLevelOperator, roleIndex):
"""
:param topLevelOperator: An instance of OpMultiLaneDataSelectionGroup
"""
# super does not work here in Python 2.x, decorated class confuses it
QAbstractItemModel.__init__(self, parent)
self.threadRouter = ThreadRouter(self)
self._op = topLevelOperator
self._roleIndex = roleIndex
self._currently_inserting = False
self._currently_removing = False
self._op.DatasetGroup.notifyInsert( self.prepareForNewLane ) # pre
self._op.DatasetGroup.notifyInserted( self.handleNewLane ) # post
self._op.DatasetGroup.notifyRemove( self.handleLaneRemove ) # pre
self._op.DatasetGroup.notifyRemoved( self.handleLaneRemoved ) # post
# Any lanes that already exist must be added now.
for laneIndex, slot in enumerate(self._op.DatasetGroup):
self.prepareForNewLane( self._op.DatasetGroup, laneIndex )
self.handleNewLane( self._op.DatasetGroup, laneIndex )
def headerData(self, section, orientation, role=Qt.DisplayRole):
"""
Public method to get the header data.
@param section section number (integer)
@param orientation header orientation (Qt.Orientation)
@param role data role (integer)
@return header data
"""
if orientation == Qt.Horizontal and role == Qt.DisplayRole:
try:
return self.__headers[section]
except IndexError:
pass
return QAbstractItemModel.headerData(self, section, orientation, role)
def flags(self, index):
# FIXME when dragging folders, sometimes flags is not called
flags = QAbstractItemModel.flags(self, index) | Qt.ItemIsEditable
if index.isValid() and index.internalPointer().isFolder() and index.column() == 0:
flags |= Qt.ItemIsDragEnabled | Qt.ItemIsDropEnabled
elif index.isValid() and index.column() == 0:
flags |= Qt.ItemIsDragEnabled
elif not index.isValid():
flags |= Qt.ItemIsDropEnabled
if index.isValid() and index.column() == Outline.compile.value:
flags |= Qt.ItemIsUserCheckable
if index.column() in [i.value for i in [Outline.wordCount, Outline.goalPercentage]]:
flags &= ~ Qt.ItemIsEditable
return flags
def __init__(self, parent):
QAbstractItemModel.__init__(self, parent)
# CharacterItems are stored in this list
self.characters = []
def __init__(self, *args, **kwargs):
QAbstractItemModel.__init__(self, *args, **kwargs)
self._rootIndex = QModelIndex()
self._artists = SortedDict()
def flags(self, index):
if index.parent().isValid():
return QAbstractItemModel.flags(self, index) | Qt.ItemIsEditable
else:
return QAbstractItemModel.flags(self, index)
def __init__(self):
QAbstractItemModel.__init__(self)
self.completer = None
def __init__(self, wordSet):
QAbstractItemModel.__init__(self)
self._wordSet = wordSet
def reset(self):
self.rootNodes = self._getRootNodes()
QAbstractItemModel.reset(self)
def setModelData(self, editor: QWidget, model: QAbstractItemModel, index: QModelIndex):
model.setData(index, editor.currentText(), Qt.EditRole)
def flags(self, index):
flags = QAbstractItemModel.flags(self, index)
if not self.completer.isSelectable(index.row(), index.column()):
flags = flags & ~Qt.ItemIsEnabled
return flags
def __init__(self, data):
QAbstractItemModel.__init__(self)
self.__data = data
def setModelData(self, editor: QCheckBox, model: QAbstractItemModel, index: QModelIndex):
model.setData(index, editor.isChecked(), Qt.EditRole)
def __init__(self, project_finder):
QAbstractItemModel.__init__(self)
self.project_finder = project_finder
self.project_finder.fileChanged.connect(self.fileChanged)
def __init__(self, manager):
QAbstractItemModel.__init__(self, manager)
self._manager = manager
self._indexCache = {}
