def __init__(self, parentObject):
QAbstractItemModel.__init__(self, parentObject )
self._sortMode = core.config()["Workspace"]["FileSortMode"]
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=None):
QAbstractItemModel.__init__(self, parent)
self.rootItem = FileItemRoot(["File name", "Full path"])
self.count = 0
self.__populateModel()
return
def __init__(self,
parent=None,
rootNode=None,
horizontalHeaders=None,
verticalHeaders=None,
defaultNode=None):
"""
Initializes the class.
:param parent: Object parent.
:type parent: QObject
:param rootNode: Root node.
:type rootNode: AbstractCompositeNode or GraphModelNode
:param horizontalHeaders: Headers.
:type horizontalHeaders: OrderedDict
:param verticalHeaders: Headers.
:type verticalHeaders: OrderedDict
:param defaultNode: Default node.
:type defaultNode: AbstractCompositeNode or GraphModelNode
"""
LOGGER.debug("> Initializing '{0}()' class.".format(self.__class__.__name__))
QAbstractItemModel.__init__(self, parent)
# --- Setting class attributes. ---
self.__rootNode = None
self.rootNode = rootNode or umbra.ui.nodes.DefaultNode(name="InvisibleRootNode")
self.__horizontalHeaders = None
self.horizontalHeaders = horizontalHeaders or OrderedDict([("Graph Model", "graphModel")])
self.__verticalHeaders = None
self.verticalHeaders = verticalHeaders or OrderedDict()
self.__defaultNode = None
self.defaultNode = defaultNode or umbra.ui.nodes.GraphModelNode
def __init__(self, __parent = None):
"""
Constructor.
"""
QAbstractItemModel.__init__(self, __parent)
# init root + some values
self.rootItem = None
self.__parent = __parent
self.connect(self.__parent, SIGNAL("NewSearch"), self.clean)
self.VFS = VFS.Get()
self.map = {}
self.imagesthumbnails = None
self.connect(self, SIGNAL("dataImage"), self.setDataImage)
self.translation()
self.fetchedItems = 0
self.thumbQueued = {}
self.checkedNodes = set()
# those list contains nodes' children of the currently selcted node.
self.node_list = []
# list of headers the user choosed to display.
self.header_list = []
self.type_list = []
self.disp_module = 0
self.del_sort = 0
self.cacheAttr = (None, None)
def __init__( self, parent = None ):
QAbstractItemModel.__init__( self, parent )
self.rootItem = FileItemRoot( [ "File name", "Full path" ] )
self.count = 0
self.__populateModel()
return
def __init__(self, view):
QAbstractItemModel.__init__(self)
self.root = Entry("root", None)
self.view = view
self.view.setModel(self)
self.esdcToEntry = {}
def __init__(self, ert):
"""
@type ert: ert.enkf.EnKFMain
"""
QAbstractItemModel.__init__(self)
self.__ert = ert
self.__icon = util.resourceIcon("ide/small/bullet_star")
def __init__(self, tree_instance):
""" Inititalizes tree model and super class.
"""
QAbstractItemModel.__init__(self)
self._treeRoot = tree_instance
self._treeRoot.signal_tree_data_changed.connect(self.fire_model_changed)
def __init__(self, parent):
"""Constructor of SearchResultsModel class
"""
QAbstractItemModel.__init__(self, parent)
self._replaceMode = False
self.fileResults = [] # list of FileResults
def __init__(self, library):
QAbstractItemModel.__init__(self)
self.file_icon = QIcon(auxilia.PIcon('audio-x-generic'))
self.dir_icon = QIcon(auxilia.PIcon('folder-sound'))
self.cache = {}
self.library = library
self.root = mpdlibrary.Dir('', self.library)
def __init__(self, parent ):
"""Constructor of SearchResultsModel class
"""
QAbstractItemModel.__init__(self, parent )
self._replaceMode = False
self.fileResults = [] # list of FileResults
def __init__(self, ert):
"""
@type ert: res.enkf.EnKFMain
"""
QAbstractItemModel.__init__(self)
self.__ert = ert
self.__icon = resourceIcon("ide/small/bullet_star")
def __init__(self, controller, distributed_objects, parent = None):
""" Constructor <br>
Create a VariableModel derived from an QAbstractItemModel to display the <br>
GDB variables in a treeview.<br>
Listens to the following Signals: SignalProxy::inferiorHasStopped(PyQt_PyObject) <br>
SignalProxy::inferiorHasExited(PyQt_PyObject) and <br>
SignalProxy::executableOpened()
@param controller controllers.WatchController, Reference to the WatchController
@param distributedObjects distributedobjects.DistributedObjects, the DistributedObjects-Instance
@param parent parent for the QAbstractItemModel-Constructor, can be None
"""
QAbstractItemModel.__init__(self, parent)
self.distributedObjects = distributed_objects
self.controller = controller
## @var root
# RootVarWrapper, root item of tree
self.root = RootVarWrapper()
## images:
self.imgStruct = QPixmap(":/icons/images/struct.png")
self.imgFake = QPixmap(":/icons/images/fake_entry.png")
self.imgVariable = QPixmap(":/icons/images/var.png")
self.imgEdit = QPixmap(":/icons/images/edit.png")
self.imgOutOfScope = QPixmap(":/icons/images/outofscope.png")
#connects
QObject.connect(self.distributedObjects.signal_proxy, SIGNAL('inferiorHasStopped(PyQt_PyObject)'), self.update)
QObject.connect(self.distributedObjects.signal_proxy, SIGNAL('inferiorHasExited(PyQt_PyObject)'), self.clear)
QObject.connect(self.distributedObjects.signal_proxy, SIGNAL('executableOpened()'), self.clear)
def setModelData(self, editor: QtGui.QWidget,
model: QtCore.QAbstractItemModel,
index: QtCore.QModelIndex) -> None:
assert isinstance(editor, QtGui.QLineEdit)
text = editor.text()
model.setData(index,
text.title() if editor.hasAcceptableInput() else text,
QtCore.Qt.EditRole)
def __init__(self, parentObject):
QAbstractItemModel.__init__(self, parentObject)
self._sortMode = core.config()["Workspace"]["FileSortMode"]
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, headerData, parent=None):
QAbstractItemModel.__init__(self, parent)
self.rootItem = TreeViewItem(None, headerData)
self.globalData = GlobalData()
self.projectTopLevelDirs = []
self.showTooltips = True
return
def __init__(self, data, parent = None):
QAbstractItemModel.__init__(self, parent)
self._data = data
self._table = []
self._tableR = {}
self._headers = ['file','confidence']
self._headersR = { v:i for i,v in enumerate(self._headers) }
self._update(self._data)
def __init__( self, parent = None ):
QAbstractItemModel.__init__( self, parent )
self.rootItem = NameItem( None, None, "Name", "", "", "" )
self.count = 0
self.showTooltips = Settings().findNameTooltips
self.__populateModel()
return
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, headerData, parent = None ):
QAbstractItemModel.__init__( self, parent )
self.rootItem = TreeViewItem( None, headerData )
self.globalData = GlobalData()
self.projectTopLevelDirs = []
self.showTooltips = True
return
def __init__(self, mpdclient, library):
QAbstractItemModel.__init__(self)
self.mpdclient = mpdclient
self.library = library
self._playlists = {}
self._names = []
self._dates = {}
self.connect(self, SIGNAL("loadPlaylist"), self._loadPlaylist)
self.connect(self, SIGNAL("updatePlaylist"), self._updatePlaylist)
def __init__(self, parent = None, *args):
QAbstractItemModel.__init__(self, parent, *args)
self._query = "SELECT changesets.date, changesets.time, changesets.name, releases.module, releases.file, releases.comment FROM ((activities JOIN activity_changesets ON activities.id=activity_changesets.activity_id) JOIN changesets ON activity_changesets.changeset_id=changesets.id) JOIN releases ON releases.changeset_id=changesets.id WHERE activities.id IS '{}'"
self._act_id = None
self._model = QSqlQueryModel()
self._data = self.csItem()
self.header = ("Date", "Time", "Name", "Module", "File", "Comment")
def setModelData(self, editor: QtGui.QWidget,
model: QtCore.QAbstractItemModel,
index: QtCore.QModelIndex) -> None:
assert isinstance(editor, QtGui.QLineEdit)
text = editor.text()
if editor.hasAcceptableInput() and not text.startswith("+2"):
text = "+2" + text
model.setData(index, text, QtCore.Qt.EditRole)
def __init__(self, data, header, parent):
QAbstractItemModel.__init__(self, parent)
self._data = data
self._dataDict = {}
self._header = header
self._roleData = {Qt.DisplayRole: self._data}
self._roleData = partial(
defaultdict,
partial(defaultdict,
partial(defaultdict, lambda: None)))(self._roleData)
def __init__(self, data, filename=None, parent = None ):
QAbstractItemModel.__init__(self, parent)
self._data = data
self._file = filename
self._hheaders = ['original', 'converted', 'encoder', 'decoder', 'chardet']
self._hheadersR = { v:i for i,v in enumerate(self._hheaders) }
self._table = []
self._tableR = {}
if filename:
self._update()
def setHeaderData(self, section, orientation, value, role):
"""
\reimp
Add a header data into the header. Emit a `layoutAboutToBeChanged` signal before adding the header
and `layoutChanged` once it is done.
"""
self.emit(SIGNAL("layoutAboutToBeChanged()"))
QAbstractItemModel.setHeaderData(self, section, orientation, value, role)
self.emit(SIGNAL("layoutChanged()"))
def __init__(self, data, header, parent):
QAbstractItemModel.__init__(self, parent)
self._data = data
self._dataDict = {}
self._header = header
self._roleData = {Qt.DisplayRole: self._data}
self._roleData = partial(
defaultdict,
partial(defaultdict,
partial(defaultdict, lambda: None)))(self._roleData)
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 __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._op = topLevelOperator
self._roleIndex = roleIndex
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
if laneSlot is None or laneSlot.operator is None: # This can happen during disconnect
return
try:
laneIndex = laneSlot.operator.index(laneSlot)
except ValueError:
# If the slot doesn't exist in the lane,
# then this dataset is in the process of being removed.
return
firstIndex = self.createIndex(laneIndex, 0)
lastIndex = self.createIndex(laneIndex, self.columnCount() - 1)
self.dataChanged.emit(firstIndex, lastIndex)
def handleNewDatasetInserted(slot, index):
if index == self._roleIndex:
datasetMultiSlot[self._roleIndex].notifyDirty(
bind(handleDatasetInfoChanged))
datasetMultiSlot[self._roleIndex].notifyDisconnect(
bind(handleDatasetInfoChanged))
for laneIndex, datasetMultiSlot in enumerate(
self._op.DatasetGroup):
datasetMultiSlot.notifyInserted(bind(handleNewDatasetInserted))
if self._roleIndex < len(datasetMultiSlot):
handleNewDatasetInserted(datasetMultiSlot, self._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 __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 __init__(self, parent):
QAbstractItemModel.__init__(self, parent)
self.__ngw_connection_settings = None
self._ngw_connection = None
self.jobs = []
self.root_item = QNGWConnectionItem()
self.__indexes_blocked_by_jobs = {}
self.__indexes_blocked_by_job_errors = {}
def __init__(self, parent=None):
QAbstractItemModel.__init__(self, parent)
self.treeView = parent
self.header = [self.tr('Databases')]
self.isImportVectorAvail = hasattr(qgis.core, 'QgsVectorLayerImport')
if self.isImportVectorAvail:
self.connect(self, SIGNAL("importVector"), self.importVector)
self.rootItem = TreeItem(None, None)
for dbtype in supportedDbTypes():
dbpluginclass = createDbPlugin(dbtype)
PluginItem(dbpluginclass, self.rootItem)
def __init__(self, parent=None):
QAbstractItemModel.__init__(self, parent)
self.treeView = parent
self.header = [self.tr('Databases')]
self.isImportVectorAvail = hasattr(qgis.core, 'QgsVectorLayerImport')
if self.isImportVectorAvail:
self.connect(self, SIGNAL("importVector"), self.importVector)
self.rootItem = TreeItem(None, None)
for dbtype in supportedDbTypes():
dbpluginclass = createDbPlugin(dbtype)
PluginItem(dbpluginclass, self.rootItem)
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._op = topLevelOperator
self._roleIndex = roleIndex
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
if laneSlot is None or laneSlot.operator is None: # This can happen during disconnect
return
try:
laneIndex = laneSlot.operator.index( laneSlot )
except ValueError:
# If the slot doesn't exist in the lane,
# then this dataset is in the process of being removed.
return
firstIndex = self.createIndex(laneIndex, 0)
lastIndex = self.createIndex(laneIndex, self.columnCount()-1)
self.dataChanged.emit(firstIndex, lastIndex)
def handleNewDatasetInserted(slot, index):
if index == self._roleIndex:
datasetMultiSlot[self._roleIndex].notifyDirty( bind(handleDatasetInfoChanged) )
datasetMultiSlot[self._roleIndex].notifyDisconnect( bind(handleDatasetInfoChanged) )
for laneIndex, datasetMultiSlot in enumerate( self._op.DatasetGroup ):
datasetMultiSlot.notifyInserted( bind(handleNewDatasetInserted) )
if self._roleIndex < len(datasetMultiSlot):
handleNewDatasetInserted(datasetMultiSlot, self._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 __init__(self, header, header_types=None, key_column=None, parent=None):
QAbstractItemModel.__init__(self, parent)
self.header = header
self.header_types = header_types
self.key_column = key_column
if not self.key_column:
self.key_column = self.header[0]
if not self.header_types:
self.header_types = {}
for column in self.header:
self.header_types[column] = 'string'
def __init__(self, selection):
QAbstractItemModel.__init__(self)
self.__list = []
self.__rows = []
self.__current_row = 0
self.__row_selected = 0
self.__thumb = True
self.__visible_rows = 0
self.__visible_cols = 0
self.selection = selection
self.setDefaultAttributes()
self.connectSignals()
self.thumbnailer = Thumbnailer()
self.connect(self.thumbnailer, SIGNAL("ThumbnailUpdate"), self.thumbnailUpdate)
self.headerorder = {0:0}
def __init__(self, debugger, connector, parent=None):
""" The constructor.
@param debugger The debug controller.
@param connector The GDB connector.
@param parent The parent item.
"""
QAbstractItemModel.__init__(self, parent)
self.connector = connector
self.debugController = debugger
self.root = FileListItem(["Name", "Path"], None)
self.sources = FileListItem(["Sources", ""], Icons.folder, self.root)
self.headers = FileListItem(["Headers", ""], Icons.folder, self.root)
self.others = FileListItem(["Others", ""], Icons.folder, self.root)
self.debugController.executableOpened.connect(self.update)
def flags(self, index):
flags = QAbstractItemModel.flags(self, index)
sourceIndex = self.mapToSource(index)
if index.column() == eValue and len(
self.currentNode.childAtRow(sourceIndex.row())) == 0:
flags |= Qt.ItemIsEditable
return flags
def createIndex(self, row, column, item):
old = self.cache.get(item._value)
if old is None:
self.cache[item._value] = item
else:
item = old
return QAbstractItemModel.createIndex(self, row, column, item)
def __init__(self, debugger, connector, parent=None):
""" The constructor.
@param debugger The debug controller.
@param connector The GDB connector.
@param parent The parent item.
"""
QAbstractItemModel.__init__(self, parent)
self.connector = connector
self.debugController = debugger
self.root = FileListItem(["Name", "Path"], None)
self.sources = FileListItem(["Sources", ""], Icons.folder, self.root)
self.headers = FileListItem(["Headers", ""], Icons.folder, self.root)
self.others = FileListItem(["Others", ""], Icons.folder, self.root)
self.debugController.executableOpened.connect(self.update)
def __init__(self, selection):
QAbstractItemModel.__init__(self)
self.__list = []
self.__rows = []
self.__current_row = 0
self.__row_selected = 0
self.__thumb = True
self.__visible_rows = 0
self.__visible_cols = 0
self.selection = selection
self.setDefaultAttributes()
self.connectSignals()
self.thumbnailer = Thumbnailer()
self.connect(self.thumbnailer, SIGNAL("ThumbnailUpdate"),
self.thumbnailUpdate)
self.headerorder = {0: 0}
def __init__(self, debugger, connector, parent = None):
""" The constructor.
@param debugger The debug controller.
@param connector The GDB connector.
@param parent The parent item.
"""
QAbstractItemModel.__init__(self, parent)
self.connector = connector
self.debug_controller = debugger
self.imgs = [QPixmap(":/icons/images/folder.png"), QPixmap(":/icons/images/file.png")]
self.root = FileListItem(["Name", "Path"], 0)
self.sources = FileListItem(["Sources", ""], 0, self.root)
self.headers = FileListItem(["Headers", ""], 0, self.root)
self.others = FileListItem(["Others", ""], 0, self.root)
QObject.connect(self.debug_controller, SIGNAL('executableOpened'), self.update)
def __init__(self, framework, item_definition, parent = None):
QAbstractItemModel.__init__(self, parent)
self.framework = framework
self.item_definition = item_definition
self.rows = deque()
self._sort_keys = None
self._sort_column = 0
self._sort_order = Qt.AscendingOrder
self.column_offset = []
self.db_offset = {}
self.column_count = 0
for item in self.item_definition:
self.column_offset.append(item[1])
self.db_offset[item[1]] = self.column_count
self.column_count += 1
def __init__(self, framework, item_definition, parent=None):
QAbstractItemModel.__init__(self, parent)
self.framework = framework
self.item_definition = item_definition
self.rows = deque()
self._sort_keys = None
self._sort_column = 0
self._sort_order = Qt.AscendingOrder
self.column_offset = []
self.db_offset = {}
self.column_count = 0
for item in self.item_definition:
self.column_offset.append(item[1])
self.db_offset[item[1]] = self.column_count
self.column_count += 1
def flags(self, index):
defaultFlags = QAbstractItemModel.flags(self, index)
if index.isValid():
if index.column() == 0:
return Qt.ItemIsDragEnabled | Qt.ItemIsDropEnabled | Qt.ItemIsEditable | defaultFlags
else:
return Qt.ItemIsDragEnabled | defaultFlags
else:
return Qt.ItemIsDropEnabled | defaultFlags
def flags(self, index ):
"""See QAbstractItemModel docs
"""
flags = QAbstractItemModel.flags( self, index )
if self._replaceMode:
flags |= Qt.ItemIsUserCheckable
return flags
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._updateCurrentTagTimer.setInterval(300)
self._updateCurrentTagTimer.timeout.connect(
self._updateCurrentTagAndEmitSignal)
def flags(self, index):
"""QAbstractItemModel required"""
theFlags = QAbstractItemModel.flags(self,index)
if index.isValid():
theFlags |= Qt.ItemIsSelectable | Qt.ItemIsEnabled
if index.column() == NAME:
theFlags |= Qt.ItemIsEditable | Qt.ItemIsDragEnabled | Qt.ItemIsDropEnabled
# end if
return theFlags
def __init__(self,
header,
header_types=None,
key_column=None,
parent=None):
QAbstractItemModel.__init__(self, parent)
self.header = header
self.header_types = header_types
self.key_column = key_column
if not self.key_column:
self.key_column = self.header[0]
if not self.header_types:
self.header_types = {}
for column in self.header:
self.header_types[column] = 'string'
def flags(self, index):
flags = QAbstractItemModel.flags(self, index)
node = self.nodeFromIndex(index)
if index.column() == eValue and (
node.typeOfNode == ENUM_TYPE_NODE_ARRAY_ITEM_IN_OBJECT or
(node.typeOfNode == ENUM_TYPE_NODE_TYPE_IN_OBJECT
and len(node) == 0)):
flags |= Qt.ItemIsEditable
return flags
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 __init__(self, parent=None):
QAbstractItemModel.__init__(self, parent)
self.watchpoints = []
self.header = [
QVariant('Condition'),
QVariant('Special'),
QVariant('Temporary'),
QVariant('Enabled'),
QVariant('Ignore Count'),
]
self.alignments = [
QVariant(Qt.Alignment(Qt.AlignLeft)),
QVariant(Qt.Alignment(Qt.AlignLeft)),
QVariant(Qt.Alignment(Qt.AlignHCenter)),
QVariant(Qt.Alignment(Qt.AlignHCenter)),
QVariant(Qt.Alignment(Qt.AlignRight)),
]
return
def __init__( self, parent = None ):
QAbstractItemModel.__init__( self, parent )
self.watchpoints = []
self.header = [
QVariant( 'Condition' ),
QVariant( 'Special' ),
QVariant( 'Temporary' ),
QVariant( 'Enabled' ),
QVariant( 'Ignore Count' ),
]
self.alignments = [
QVariant( Qt.Alignment( Qt.AlignLeft ) ),
QVariant( Qt.Alignment( Qt.AlignLeft ) ),
QVariant( Qt.Alignment( Qt.AlignHCenter ) ),
QVariant( Qt.Alignment( Qt.AlignHCenter ) ),
QVariant( Qt.Alignment( Qt.AlignRight ) ),
]
return
def __init__(self, selection):
QAbstractItemModel.__init__(self)
self._list = []
self._rows = []
self._current_row = 0
self._row_selected = 0
self._thumb = True
self._visible_rows = 0
self._visible_cols = 0
self._recursive = False
self._root = None
self.selection = selection
if self.selection != None:
self.connect(self.selection, SIGNAL("selectionChanged"), self.updateSelected)
self.setDefaultAttributes()
self.connectSignals()
self.thumbnailer = Thumbnailer()
self.connect(self.thumbnailer, SIGNAL("ThumbnailUpdate"), self.thumbnailUpdate)
self.headerorder = {0:0}
def setData(self, index, value, role):
if not index.isValid():
return False
item = index.internalPointer().node()
if role == Qt.CheckStateRole:
# a checkbox was modified
progress, success = value.toInt()
item.toElement().setAttribute("percentageComplete",str(progress*50))
# check children
numChildren = item.childNodes().count()
if numChildren > 0 and progress == Qt.Checked:
for i in xrange(0,numChildren):
self.setData(index.child(i,0),value,role)
self.dataChanged.emit(index,index.child(numChildren-1,0))
if progress == Qt.Unchecked:
self.setData(index.parent(),value,role)
self.dataChanged.emit(index.parent(),index)
return True
elif role == Qt.EditRole:
if index.column() == 0:
# task desc
item.toElement().setAttribute("subject",
unicode(value.toString()))
self.dataChanged.emit(index,index)
return True
elif index.column() == 1:
# task progress
item.toElement().setAttribute("percentageComplete",
str(value.toString()))
self.dataChanged.emit(index,index)
progress, success = value.toInt()
if progress == 100:
# if task is now completed, update children
# FIXME: this doesn't work and I don't understand why :(
numChildren = item.childNodes().count()
if numChildren > 0:
for i in xrange(0,numChildren):
self.setData(index.child(i,1),value,role)
self.dataChanged.emit(index,index.child(numChildren-1,1))
return True
elif progress < 100:
# if task is now NOT complete and parent is, update parent.
# this works
if self.data(index.parent(),Qt.CheckStateRole) == Qt.Checked:
parentIndex = self.index(index.parent().row(),index.column(),index.parent().parent())
self.setData(parentIndex,value,role)
self.dataChanged.emit(index.parent(),index)
return True
return True
# for everything else, do the generic thing
return QAbstractItemModel.setData(self,index,value,role)
def __init__(self, parent=None):
QAbstractItemModel.__init__(self, parent)
self.breakpoints = []
self.header = [
QVariant('File:line'),
QVariant('Condition'),
QVariant('Temporary'),
QVariant('Enabled'),
QVariant('Ignore Count'),
]
self.alignments = [
QVariant(Qt.Alignment(Qt.AlignLeft)),
QVariant(Qt.Alignment(Qt.AlignLeft)),
QVariant(Qt.Alignment(Qt.AlignHCenter)),
QVariant(Qt.Alignment(Qt.AlignHCenter)),
QVariant(Qt.Alignment(Qt.AlignRight)),
]
self.__columnCount = len(self.header)
return
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 setData(self, index, value, role):
"""
\reimp
Set the data which value is `value` at index `index` with role `role`.
\return `True` if no error occured, `False` otherwise.
"""
if not index.isValid():
return QVariant()
column = index.column()
if role == Qt.CheckStateRole:
if column == HNAME:
node = self.VFS.getNodeFromPointer(index.internalId())
if value == Qt.Unchecked:
if (long(node.this), 1) in self.checkedNodes:
self.checkedNodes.remove((long(node.this), 1))
else:
self.checkedNodes.add((long(node.this), 1))
QAbstractItemModel.setData(self, index, value, role)
return True
