def select_task(self, task):
"""Select a task by name.
If the task does not exist in the current model then selection is only
cleared.
Args:
task (str): Name of the task to select.
"""
# Clear selection
view = self.widgets["view"]
model = view.model()
selection_model = view.selectionModel()
selection_model.clearSelection()
# Select the task
mode = selection_model.Select | selection_model.Rows
for row in range(model.rowCount(QtCore.QModelIndex())):
index = model.index(row, 0, QtCore.QModelIndex())
name = index.data(QtCore.Qt.DisplayRole)
if name == task:
selection_model.select(index, mode)
# Set the currently active index
view.setCurrentIndex(index)
def parent(self, index):
if not index.isValid():
print "parent index.isValue() FALSE"
return QtCore.QModelIndex()
node = index.internalPointer()
if node != None and node.parent() is None:
ss
return QtCore.QModelIndex()
else:
return self.createIndex(0, 0, None)
return self.createIndex(node.parent.row, 0, node.parent)
print "parent", child.row(), child.column(), child #, child.parent()
#return None
if False: #child.isValid():
ip = child.internalPointer()
print "parent not valid", ip
if ip:
print "return"
#return child.internalPointer().parent()
return self.createIndex(ip.parent().row(), 0, ip.parent())
#return QtCore.QModelIndex()
#return self.createIndex(child.row(), child.column(), None)
return QtCore.QModelIndex()
def indexForPlug(self, plug):
rowPlug = plug.ancestor(Gaffer.Spreadsheet.RowPlug)
if rowPlug is None:
return QtCore.QModelIndex()
rowIndex = rowPlug.parent().children().index(rowPlug)
columnIndex = None
if plug == rowPlug["name"]:
columnIndex = 0
elif plug == rowPlug["enabled"]:
columnIndex = 1
else:
cellPlug = plug if isinstance(
plug, Gaffer.Spreadsheet.CellPlug) else plug.ancestor(
Gaffer.Spreadsheet.CellPlug)
columnIndex = rowPlug["cells"].children().index(
cellPlug) + 2 if cellPlug is not None else None
if columnIndex is None:
return QtCore.QModelIndex()
return self.index(rowIndex, columnIndex)
def parent(self, index=QtCore.QModelIndex(), *args, **kwargs):
"""
Get invalid parent index (no valid parent indexes in a list model).
:return: Invalid parent index.
:rtype: QtCore.QModelIndex
"""
return QtCore.QModelIndex()
def index(self, row, column, parent):
parentNode = self.getNode(parent)
if row < 0 and row >= parentNode.childCount():
return QtCore.QModelIndex()
childItem = parentNode.child(row)
if childItem:
return self.createIndex(row, column, childItem)
return QtCore.QModelIndex()
def setTesterItems(self, testerItems):
self.beginRemoveRows(QtCore.QModelIndex(), 0, len(self.__tester_items))
self.__tester_items = []
self.endRemoveRows()
self.beginInsertRows(QtCore.QModelIndex(), 0, len(testerItems))
self.__tester_items = testerItems
self.endInsertRows()
def setReportItems(self, report_items):
self.beginRemoveRows(QtCore.QModelIndex(), 0, len(self.__report_items))
self.__report_items = []
self.endRemoveRows()
self.beginInsertRows(QtCore.QModelIndex(), 0, len(report_items))
self.__report_items = report_items
self.endInsertRows()
def changeOrder(self):
# index = self.model.index(2,0)
# self.model.setData(index,QtGui.QColor(100,233,255))
# print(self.model.getColors())
# colors = self.model.getColors()
# colors.insert(0,QtGui.QColor(0,233,255))
# self.model.setColors(colors)
# self.model.setData([])
self.model.dataChanged.emit(QtCore.QModelIndex(), QtCore.QModelIndex())
def parent(self, index):
node = self.getNode(index) # index.internalPointer()
parentNode = node.parent()
if parentNode == self._rootNode:
return QtCore.QModelIndex()
if parentNode is None:
return QtCore.QModelIndex()
row = parentNode.row()
return self.createIndex(row, 0, parentNode)
def parent(self, index):
if not index.isValid():
return QtCore.QModelIndex()
item = index.internalPointer()
if item.parent is None:
return QtCore.QModelIndex()
else:
return self.createIndex(item.parent.index(), 0, item.parent)
def set_entities(self, entities):
# first remove all rows
self.beginRemoveRows(QtCore.QModelIndex(), 0, len(self._entities) - 1)
self._entities = []
self.endRemoveRows()
# now set new rows
self.beginInsertRows(QtCore.QModelIndex(), 0, len(entities) - 1)
self._entities = entities
self.endInsertRows()
def parent(self, index):
if not index.isValid():
return QtCore.QModelIndex()
childItem = index.internalPointer()
parentItem = childItem.parent()
if parentItem == self._rootItem:
return QtCore.QModelIndex()
return self.createIndex(parentItem.row(), 0, parentItem)
def mapFromSource(self, index):
if not index.isValid():
return QtCore.QModelIndex()
parent_index = index.parent()
if not parent_index.isValid():
return QtCore.QModelIndex()
parent_idx = self.mapping_from[parent_index.row()]
my_row = parent_idx[index.row()]
return self.index(my_row, index.column())
def setTesterItems(self, testerItems, sortTesters=True):
self.beginRemoveRows(QtCore.QModelIndex(), 0, len(self.__tester_items))
self.__tester_items = []
self.endRemoveRows()
self.beginInsertRows(QtCore.QModelIndex(), 0, len(testerItems))
self.__tester_items = testerItems
if sortTesters:
self.__tester_items = self.sort(self.__tester_items)
self.endInsertRows()
def _updateCachedNodeList(self):
"""
Perform the node list in maya and cache the results
"""
try:
nodes = pm.cmds.ls('*', **self.getFullNodeKwargs())
except:
nodes = []
self.cachedNodeList = sorted(nodes)
# emitting data change even though it might be called again later
# because we want accurate status text, etc
self.dataChanged.emit(QtCore.QModelIndex(), QtCore.QModelIndex(), None)
def testModelChangingData(self):
root = {
"a": 10,
}
widget = GafferUI.PathListingWidget(
path=Gaffer.DictPath(root, "/"),
columns=[
GafferUI.PathListingWidget.defaultNameColumn,
GafferUI.PathListingWidget.StandardColumn(
"Value", "dict:value")
],
)
_GafferUI._pathListingWidgetAttachTester(
GafferUI._qtAddress(widget._qtWidget()))
# Do initial query and wait for async update.
model = widget._qtWidget().model()
self.assertEqual(model.rowCount(), 0)
_GafferUI._pathModelWaitForPendingUpdates(GafferUI._qtAddress(model))
self.assertEqual(model.rowCount(), 1)
self.assertEqual(model.data(model.index(0, 1, QtCore.QModelIndex())),
10)
# Set up change tracking.
changes = []
def dataChanged(*args):
changes.append(args)
model.dataChanged.connect(dataChanged)
# Change value in column 1. Check that `dataChanged` is emitted
# and we can query the new value.
root["a"] = 20
self.__emitPathChanged(widget)
self.assertEqual(len(changes), 1)
self.assertEqual(model.data(model.index(0, 1, QtCore.QModelIndex())),
20)
# Trigger an artificial update and assert that the data has not changed,
# and `dataChanged` has not been emitted.
self.__emitPathChanged(widget)
self.assertEqual(len(changes), 1)
self.assertEqual(model.data(model.index(0, 1, QtCore.QModelIndex())),
20)
def index(self, row, column, parent=QtCore.QModelIndex()):
if not self.hasIndex(row, column, parent):
return QtCore.QModelIndex()
if not parent.isValid():
parentItem = self._rootItem
else:
parentItem = parent.internalPointer()
childItem = parentItem.child(row)
if childItem:
return self.createIndex(row, column, childItem)
else:
return QtCore.QModelIndex()
def mapFromSource(self, sourceIndex):
if not sourceIndex.isValid():
return QtCore.QModelIndex()
row = sourceIndex.row() - self.__startRow
column = sourceIndex.column() - self.__startColumn
if row < 0 or row >= self.rowCount():
return QtCore.QModelIndex()
if column < 0 or column >= self.columnCount():
return QtCore.QModelIndex()
return self.index(row, column)
def parent(self, index):
if not index.isValid():
return QtCore.QModelIndex()
child_item = index.internalPointer()
parent_item = get_obj_value(child_item, "_parent")
if parent_item is None:
return QtCore.QModelIndex()
grand_item = get_obj_value(parent_item, "_parent")
if grand_item is None:
return QtCore.QModelIndex()
parent_list = get_obj_value(grand_item, "children")
return self.createIndex(parent_list.index(parent_item), 0, parent_item)
def parent(self, child_index):
"""Returns model index that represents the parent of the layer at
given `child_index`
Part of QAbstractItemModel
"""
if not child_index.isValid():
return QtCore.QModelIndex()
layer = child_index.internalPointer()
if not layer:
return QtCore.QModelIndex()
parent_layer = layer.parent_layer
if not parent_layer:
return QtCore.QModelIndex()
parent_row = LayerModel.find_layer_index_in_parent(parent_layer)
return self.createIndex(parent_row, 0, parent_layer)
def change_dir(self, flag):
path = ini.get_data('RootDir', flag) + assets_dir
self.splitter_window.splitter_left.new_path = path
self.splitter_window.splitter_left.model.setRootPath(path)
self.splitter_window.splitter_left.setRootIndex(
QtCore.QModelIndex(
self.splitter_window.splitter_left.model.index(path)))
def rowCount(self, parent=QtCore.QModelIndex()):
"""
return len asset
"""
if self._items:
return len(self._items)
return 0
def __init__(self, dbcon, parent=None):
super(ProjectBar, self).__init__(parent)
self.dbcon = dbcon
self.model = ProjectModel(self.dbcon)
self.model.hide_invisible = True
self.project_combobox = QtWidgets.QComboBox()
self.project_combobox.setModel(self.model)
self.project_combobox.setRootModelIndex(QtCore.QModelIndex())
layout = QtWidgets.QHBoxLayout(self)
layout.setContentsMargins(0, 0, 0, 0)
layout.addWidget(self.project_combobox)
self.setSizePolicy(QtWidgets.QSizePolicy.MinimumExpanding,
QtWidgets.QSizePolicy.Maximum)
# Initialize
self.refresh()
# Signals
self.project_combobox.currentIndexChanged.connect(self.project_changed)
# Set current project by default if it's set.
project_name = self.dbcon.Session.get("AVALON_PROJECT")
if project_name:
self.set_project(project_name)
def index(self, row, column, parent):
parent_node = self.getNode(parent)
child_item = parent_node.child(row)
if child_item:
return self.createIndex(row, column, child_item)
else:
return QtCore.QModelIndex()
def __onActionReceived__(self, action, phase):
history = self.obj()
if history is not None:
if action.sender is history and phase is POST:
change = action.change
if isinstance(change, Update) and "index" in change.new_values:
old_index = change.old_values["index"]
new_index = change.new_values["index"]
first_index = min((old_index, new_index))
last_index = len(history.changes) - 1
self.__model.dataChanged.emit(
self.__model.index(first_index, 0,
QtCore.QModelIndex()),
self.__model.index(last_index, 0,
QtCore.QModelIndex()),
)
def fetchMore(self, parent): # override
numRemaining = len(self.results) - self.numItemsDisplayed
fetchCount = min(self.numItemsToFetch, numRemaining)
self.beginInsertRows(QtCore.QModelIndex(), self.numItemsDisplayed,
self.numItemsDisplayed + fetchCount)
self.numItemsDisplayed += fetchCount
self.endInsertRows()
def _updateResultsInternal(self, forceEmitChange=False):
"""
Update the current list of results by calling _updateResults.
Returns True if the results have changed.
"""
lastResults = self.results
if not self.query:
self.results = []
else:
self._updateResults()
if self.results != lastResults or forceEmitChange:
self.numItemsDisplayed = min(len(self.results),
self.numItemsInitiallyDisplayed)
self.dataChanged.emit(QtCore.QModelIndex(), QtCore.QModelIndex(),
None)
def delServiceLineBtnClicked(self):
"""Removes the currently selected service line of this service"""
if not self.serviceLinesView.selectionModel().hasSelection():
self.statusBar().showMessage(
self.tr("Select a service line to remove"),
timeout=2,
warn=True)
return
service = self.serviceLinesView.model().service
rowIndexes = self.serviceLinesView.selectionModel().selectedRows()
if len(rowIndexes) != 0:
rowIndex = rowIndexes[0]
model = self.editor.serviceLinesModel
code = model.data(rowIndex, 0)
if QtWidgets.QMessageBox.question(
self, self.tr("Delete service"),
self.tr("Are you sure you want "
"to delete the line at %s?") % code,
QtWidgets.QMessageBox.Yes
| QtWidgets.QMessageBox.No) == QtWidgets.QMessageBox.Yes:
model.beginRemoveRows(QtCore.QModelIndex(), rowIndex.row(),
rowIndex.row())
self.editor.deleteServiceLine(service, rowIndex.row())
model.endRemoveRows()
self.setDirty("Deleted service line")
def flags(self, index=QtCore.QModelIndex(), *args, **kwargs):
"""
Get flags.
:param index: Index.
:type index: QtCore.QModelIndex
:return: Flags.
:rtype: QtCore.Qt.ItemFlag
"""
obj = self.obj()
if obj is None:
return QtCore.Qt.NoItemFlags
row = index.row()
column = index.column()
header = self.headersObj()[column]
flags = header.flags(obj, row)
if hasattr(QtCore.Qt, "ItemNeverHasChildren"):
flags |= QtCore.Qt.ItemNeverHasChildren
mime_type = self.mimeType()
if mime_type:
flags |= QtCore.Qt.ItemIsDragEnabled | QtCore.Qt.ItemIsDropEnabled
return flags
def removeRows(self, position, rows, parent=QtCore.QModelIndex()):
self.beginRemoveRows(parent, position, position + rows - 1)
success = None
for row in range(rows):
success = self._node_list.pop(position)
self.endRemoveRows()
return success
