def build_tree(self):
"""Rebuilds model's contents."""
def append_filter_items(parent_item, filters, filter_type):
for id_, is_on in filters[filter_type].items():
filter_item = QStandardItem(
self._connection.id_to_name(id_, filter_type))
filter_item.setData(id_, self._ID_ROLE)
filter_item.setData(Qt.Checked if is_on else Qt.Unchecked,
Qt.CheckStateRole)
filter_item.setFlags(Qt.ItemIsEnabled | Qt.ItemIsSelectable
| Qt.ItemIsUserCheckable)
parent_item.appendRow(filter_item)
self.clear()
self._connection.fetch_database_items()
for resource_label, filters_by_type in self._connection.resource_filters.items(
):
root_item = QStandardItem(resource_label)
root_item.setFlags(Qt.ItemIsEnabled | Qt.ItemIsSelectable)
self.appendRow(root_item)
for name, type_ in self._FILTER_TYPES.items():
filter_parent = QStandardItem(name)
filter_parent.setFlags(Qt.ItemIsEnabled | Qt.ItemIsSelectable)
select_all_item = QStandardItem(self._SELECT_ALL)
select_all_item.setData(False, Qt.CheckStateRole)
select_all_item.setFlags(Qt.ItemIsEnabled | Qt.ItemIsSelectable
| Qt.ItemIsUserCheckable)
filter_parent.appendRow(select_all_item)
root_item.appendRow(filter_parent)
if type_ in filters_by_type:
append_filter_items(filter_parent, filters_by_type, type_)
self._set_all_selected_item(resource_label, filter_parent)
def search_shot(self, source_model, search_text):
'''
search shot
:param source_model: source model
:param search_text: text
:return:
'''
sequence_item_temp_list = []
for sequence_index in range(source_model.rowCount()):
sequence_item = source_model.item(sequence_index, 0)
sequence_item_temp = QStandardItem(sequence_item.text())
sequence_item_temp.setEditable(False)
for shot_name_index in range(sequence_item.rowCount()):
shot_name_item = sequence_item.child(shot_name_index, 0)
shot_name = shot_name_item.text()
if search_text in shot_name:
shot_name_item_temp = shot_name_item.clone()
retrieving = QStandardItem("Retrieving Tasks...")
retrieving.setEditable(False)
shot_name_item_temp.appendRow(retrieving)
shot_name_item_temp.setEditable(False)
sequence_item_temp.appendRow(shot_name_item_temp)
if sequence_item_temp.hasChildren():
sequence_item_temp_list.append(sequence_item_temp)
source_model.clear()
for item in sequence_item_temp_list:
source_model.appendRow(item)
def tab_asset_search_init(self):
'''
init asset list in treeView(Only for search!)
:return:
'''
self.source_asset_model.clear()
asset_type_list = [
'Chr', 'Env', 'Prp', 'Flg', 'Crd', 'Scn', 'Uif', 'Asb'
]
for asset_type in asset_type_list:
asset_type_item = QStandardItem(asset_type)
asset_type_item.setEditable(False)
asset_entity_list = self.sg.get_asset_list(self.project_name,
asset_type)
if asset_entity_list:
for asset_entity in asset_entity_list:
asset_name = asset_entity['code']
asset_name_chinesename = asset_entity['sg_chinesename']
if asset_name_chinesename:
asset_name = asset_name + "|" + asset_name_chinesename
asset_name_item = QStandardItem(asset_name)
asset_name_item.setEditable(False)
# append the next level item
retrieving = QStandardItem("Retrieving Tasks...")
retrieving.setEditable(False)
asset_name_item.appendRow(retrieving)
asset_type_item.appendRow(asset_name_item)
self.source_asset_model.appendRow(asset_type_item)
def tab_shot_search_init(self):
'''
init shot list in treeView(Only for search!)
:return:
'''
self.source_shot_model.clear()
sequence_entity_list = self.sg.get_sequence_list(self.project_name)
if sequence_entity_list:
for sequence_entity in sequence_entity_list:
sequence_name = sequence_entity['code']
sequence_name_item = QStandardItem(sequence_name)
sequence_name_item.setEditable(False)
# find the shot below sequence
shot_entity_list = self.sg.get_sequence_shot_list(
self.project_name, sequence_name)
if shot_entity_list:
for shot_entity in shot_entity_list:
shot_name = shot_entity['code']
shot_name_item = QStandardItem(shot_name)
shot_name_item.setEditable(False)
# append the next level item
retrieving = QStandardItem("Retrieving Tasks...")
retrieving.setEditable(False)
shot_name_item.appendRow(retrieving)
sequence_name_item.appendRow(shot_name_item)
self.source_shot_model.appendRow(sequence_name_item)
def search_asset(self, source_model, search_text):
'''
search asset
:param source_model: source model
:param search_text: text
:return:
'''
asset_type_item_temp_list = []
for asset_type_index in range(source_model.rowCount()):
asset_type_item = source_model.item(asset_type_index, 0)
asset_type_item_temp = QStandardItem(asset_type_item.text())
asset_type_item_temp.setEditable(False)
for asset_name_index in range(asset_type_item.rowCount()):
asset_name_item = asset_type_item.child(asset_name_index, 0)
asset_name = asset_name_item.text()
if search_text in asset_name:
asset_name_item_temp = asset_name_item.clone()
retrieving = QStandardItem("Retrieving Tasks...")
retrieving.setEditable(False)
asset_name_item_temp.appendRow(retrieving)
asset_name_item_temp.setEditable(False)
asset_type_item_temp.appendRow(asset_name_item_temp)
if asset_type_item_temp.hasChildren():
asset_type_item_temp_list.append(asset_type_item_temp)
source_model.clear()
for item in asset_type_item_temp_list:
source_model.appendRow(item)
def _add_morpheme(self, tree: QtGui.QStandardItem, morpheme: Morpheme):
text_item = MorphemeTextItem(morpheme)
gloss_item = MorphemeGlossItem(morpheme)
self.morpheme_text_items.update({morpheme.dict_id: text_item})
self.morpheme_gloss_items.update({morpheme.dict_id: gloss_item})
tree.appendRow([
text_item,
gloss_item,
RemoveButton(morpheme),
])
def add_existing_faction(self, faction):
self.dispos.factions.append(faction)
item = QStandardItem()
item.setText(faction.name)
item.setData(faction, QtCore.Qt.UserRole)
for spawn in faction.spawns:
spawn_item = QStandardItem()
self._set_item_name_and_decoration(spawn_item, spawn)
item.appendRow(spawn_item)
self.appendRow(item)
def init_qud_object(self, model: QStandardItemModel,
qud_object: QudObject):
item = QStandardItem(qud_object.name)
if not qud_object.is_leaf:
for child in qud_object.children:
item.appendRow(self.init_qud_object(model, child))
if qud_object.is_specified('tag_BaseObject'):
item.setSelectable(False)
item.setData(qud_object)
return item
def add_child(num_children, nesting_level):
result = []
if nesting_level == 0:
return result
for i in range(num_children):
child = QStandardItem("Child num {}, nesting Level {}".format(
i + 1, nesting_level))
if i == 0:
child.appendRow(add_child(num_children, nesting_level - 1))
result.append(child)
return result
def _populate_model_from_dispos(self, dispos):
self.clear()
for faction in dispos.factions:
item = QStandardItem()
item.setText(faction.name)
item.setData(faction, QtCore.Qt.UserRole)
for spawn in faction.spawns:
spawn_item = QStandardItem()
self._set_item_name_and_decoration(spawn_item, spawn)
item.appendRow(spawn_item)
self.appendRow(item)
def _update_data_for_item(item: QStandardItem):
if not item.data(_EXPANDABLE_ROLE):
return
if not item.data(_HAS_LOADED_DATA_ROLE):
node = item.data(_GET_NODE_ROLE)
for child, name, key in node.children():
if hasattr(child, "children"):
child_item = _create_expandable_item(child, name, key)
else:
child_item = _create_standard_item(child, name, key)
item.appendRow(child_item)
item.setData(True, _HAS_LOADED_DATA_ROLE)
def add_dict_item(key, val, parent):
if type(val) is dict:
child = QStandardItem('"' + key + '": { ... }')
for key, val in val.items():
add_dict_item(key, val, child)
elif type(val) is list:
child = QStandardItem('"' + key + '": [ ... ]')
for item in val:
child.appendRow(QStandardItem('"' + item + '"'))
else:
child = QStandardItem('"' + key + '": "' + str(val) + '"')
parent.appendRow(child)
def sequence_expanded(self, index):
'''
sequence treeView expanded
:param index: index of the model
:return:
'''
# dynamic load data from shotgun server database
item = self.source_sequence_model.itemFromIndex(index)
item.removeRows(0, item.rowCount())
sequence_level_struct_item = []
self.get_upper_level_item(self.source_sequence_model,
sequence_level_struct_item, index)
item_level = len(sequence_level_struct_item)
# search item from shotgun server
if item_level == 1:
# this is the top level
sequence_name = sequence_level_struct_item[0]
# find the step below sequence
sequence_task_list = self.sg.get_sequence_task_list(
self.project_name, sequence_name)
sequence_step_name_set = set()
if sequence_task_list:
for sequence_task in sequence_task_list:
sequence_task_step = sequence_task['step']
if sequence_task_step:
sequence_task_step_name = sequence_task_step['name']
# remove all duplicate name in step by using set()
sequence_step_name_set.add(sequence_task_step_name)
for step_name in sequence_step_name_set:
sequence_task_step_name_item = QStandardItem(step_name)
sequence_task_step_name_item.setEditable(False)
# append the next level item
retrieving = QStandardItem("Retrieving Tasks...")
retrieving.setEditable(False)
sequence_task_step_name_item.appendRow(retrieving)
item.appendRow(sequence_task_step_name_item)
sequence_level_struct_item.append(step_name)
elif item_level == 2:
sequence_name = sequence_level_struct_item[0]
sequence_step_name = sequence_level_struct_item[1]
sequence_task_list = self.sg.get_sequence_task_list(
self.project_name, sequence_name, sequence_step_name)
if sequence_task_list:
for sequence_task in sequence_task_list:
sequence_task_name = sequence_task['content']
sequence_task_name_item = QStandardItem(sequence_task_name)
sequence_task_name_item.setEditable(False)
item.appendRow(sequence_task_name_item)
def _build_item_for_tree_node(self, key, node):
item = QStandardItem()
if type(node) == dict:
# Node is a category.
item.setText(key)
for child_key, value in node.items():
child = self._build_item_for_tree_node(child_key, value)
item.appendRow(child)
else:
# Node is a module.
item.setText(key)
item.setData(node)
return item
def addCollectionItem(self, collection, item):
items = self.collectionsModel.findItems(collection)
if not items:
parent = QStandardItem(collection)
parent.setEditable(False)
parent.setIcon(self.folder_icon)
self.collectionsModel.appendRow(parent)
else:
parent = items.pop(0)
newItem = QStandardItem()
newItem.setText(item.method + " " + item.url)
newItem.setEditable(False)
newItem.setData(item, Qt.UserRole)
parent.appendRow(newItem)
def populate_template_model(self, populate):
"""Add all tool template specs to a single QTreeView.
If items is None or an empty list, model is cleared.
Args:
populate (bool): False to clear model, True to populate.
"""
self.template_model.clear()
self.template_model.setHorizontalHeaderItem(
0, QStandardItem("Template specification")) # Add header
# Add category items
source_file_category_item = QStandardItem("Source files")
input_category_item = QStandardItem("Input files")
opt_input_category_item = QStandardItem("Optional input files")
output_category_item = QStandardItem("Output files")
self.template_model.appendRow(source_file_category_item)
self.template_model.appendRow(input_category_item)
self.template_model.appendRow(opt_input_category_item)
self.template_model.appendRow(output_category_item)
if populate:
if self.source_file_model.rowCount() > 0:
for row in range(self.source_file_model.rowCount()):
text = self.source_file_model.item(row).data(
Qt.DisplayRole)
qitem = QStandardItem(text)
qitem.setFlags(~Qt.ItemIsEditable)
qitem.setData(QFileIconProvider().icon(QFileInfo(text)),
Qt.DecorationRole)
source_file_category_item.appendRow(qitem)
if self.input_file_model.rowCount() > 0:
for row in range(self.input_file_model.rowCount()):
text = self.input_file_model.item(row).data(Qt.DisplayRole)
qitem = QStandardItem(text)
qitem.setFlags(~Qt.ItemIsEditable)
qitem.setData(QFileIconProvider().icon(QFileInfo(text)),
Qt.DecorationRole)
input_category_item.appendRow(qitem)
if self.opt_input_file_model.rowCount() > 0:
for row in range(self.opt_input_file_model.rowCount()):
text = self.opt_input_file_model.item(row).data(
Qt.DisplayRole)
qitem = QStandardItem(text)
qitem.setFlags(~Qt.ItemIsEditable)
qitem.setData(QFileIconProvider().icon(QFileInfo(text)),
Qt.DecorationRole)
opt_input_category_item.appendRow(qitem)
if self.output_file_model.rowCount() > 0:
for row in range(self.output_file_model.rowCount()):
text = self.output_file_model.item(row).data(
Qt.DisplayRole)
qitem = QStandardItem(text)
qitem.setFlags(~Qt.ItemIsEditable)
qitem.setData(QFileIconProvider().icon(QFileInfo(text)),
Qt.DecorationRole)
output_category_item.appendRow(qitem)
def tab_shot_init(self):
'''
init shot list in treeView
:return:
'''
self.source_shot_model.clear()
sequence_entity_list = self.sg.get_sequence_list(self.project_name)
if sequence_entity_list:
for sequence_entity in sequence_entity_list:
sequence_name = sequence_entity['code']
sequence_name_item = QStandardItem(sequence_name)
sequence_name_item.setEditable(False)
retrieving = QStandardItem("Retrieving Tasks...")
retrieving.setEditable(False)
sequence_name_item.appendRow(retrieving)
self.source_shot_model.appendRow(sequence_name_item)
def setup_tree(self):
for name in self.main_dic:
if name != 'main dir':
base_name = self.main_dic[name]
base = QStandardItem(name)
if 'icon' in base_name:
icon = QIcon(base_name['icon'])
base.setIcon(icon)
if 'children' in base_name:
for child_dic in base_name['children']:
for child in child_dic:
child_item = QStandardItem(child)
if 'icon' in child_dic[child]:
icon = QIcon(child_dic[child]['icon'])
child_item.setIcon(icon)
child_item.setFlags(Qt.ItemIsSelectable
| Qt.ItemIsEnabled)
base.appendRow(child_item)
self.model.appendRow(base)
def tab_asset_init(self):
'''
init asset list in treeView
:return:
'''
self.source_asset_model.clear()
asset_type_list = [
'Chr', 'Env', 'Prp', 'Flg', 'Crd', 'Scn', 'Uif', 'Asb'
]
for asset_type in asset_type_list:
asset_type_item = QStandardItem(asset_type)
asset_type_item.setEditable(False)
# append the next level item
retrieving = QStandardItem("Retrieving Tasks...")
retrieving.setEditable(False)
asset_type_item.appendRow(retrieving)
self.source_asset_model.appendRow(asset_type_item)
def search_mytask(self, source_model, search_text):
'''
search mytask
:param source_model: source model
:param search_text: text
:return:
'''
mytask_type_item_temp_list = []
for mytask_type_index in range(source_model.rowCount()):
mytask_type_item = source_model.item(mytask_type_index, 0)
mytask_type_item_temp = QStandardItem(mytask_type_item.text())
mytask_type_item_temp.setEditable(False)
for mytask_name_index in range(mytask_type_item.rowCount()):
mytask_name_item = mytask_type_item.child(mytask_name_index, 0)
mytask_name = mytask_name_item.text()
if search_text in mytask_name:
mytask_name_item_temp = mytask_name_item.clone()
if mytask_name_item.hasChildren():
for mytask_name_index in range(
mytask_name_item.rowCount()):
mytask_step_item = mytask_name_item.child(
mytask_name_index, 0)
mytask_step_item_temp = mytask_step_item.clone()
if mytask_step_item.hasChildren():
for mytask_step_index in range(
mytask_step_item.rowCount()):
mytask_step_task_item = mytask_step_item.child(
mytask_step_index, 0)
mytask_step_task_item_temp = mytask_step_task_item.clone(
)
mytask_step_item_temp.appendRow(
mytask_step_task_item_temp)
mytask_name_item_temp.appendRow(
mytask_step_item_temp)
mytask_name_item_temp.setEditable(False)
mytask_type_item_temp.appendRow(mytask_name_item_temp)
if mytask_type_item_temp.hasChildren():
mytask_type_item_temp_list.append(mytask_type_item_temp)
source_model.clear()
for item in mytask_type_item_temp_list:
source_model.appendRow(item)
def updateTreeView(self):
self.model.clear()
self.model.setHorizontalHeaderLabels(self.tagName)
for i in range(self.noOfAddedData):
parent1 = QStandardItem('Samle No {}.'.format(i+1)) # sample no 1,2,3,----
showThisData = self.dataPoints[i]
maximumIteam = max(len(self.tagNameDict[self.tagName[0]]),len(self.tagNameDict[self.tagName[1]]),len(self.tagNameDict[self.tagName[2]]))
for j in range(maximumIteam):
currentRow=[]
for tn in self.tagName:
if(j<len(self.tagNameDict[tn])): # because 0 to len-1
x=str(self.tagNameDict[tn][j])
y=str(showThisData[tn][j])
child =QStandardItem((x+': {}').format(y))
else:
child =QStandardItem("")
currentRow.append(child)
parent1.appendRow(currentRow)
self.model.appendRow(parent1)
def parse_recipe(self, recipe):
self.clear()
self.setColumnCount(1)
#self.setHorizontalHeaderLabels(['item','detail'])
self.setHorizontalHeaderLabels(['Action'])
self.parentItem = self.invisibleRootItem()
parentItem = self.parentItem
for m, v in recipe.get('metadata', {}).items():
item = QStandardItem('{}: {}'.format(m, v))
parentItem.appendRow(item)
fp = FuturaRecipePrettifier(findMainWindow().loader)
for action in recipe.get('actions', []):
item = QStandardItem(sections[action['action']])
parentItem.appendRow(item)
for task in action['tasks']:
this_task = QStandardItem(fp.format(task))
item.appendRow(this_task)
def setup_openCL(self):
self.platforms = pyopencl.get_platforms()
self.devices = [platform.get_devices() for platform in self.platforms]
# populate treeview
self.treeView_model = QStandardItemModel()
self.treeView_model.setHorizontalHeaderLabels(["Platform"
]) # , 'Device'])
self.treeView_openCL.setModel(self.treeView_model)
self.treeView_openCL.setUniformRowHeights(True)
# connect command
# self.treeView_model.itemChanged.connect(self.create_run_command)
for i, platform in enumerate(self.platforms):
parent = QStandardItem(platform.name)
for d in self.devices[i]:
parent.appendRow(QStandardItem(d.name))
self.treeView_model.appendRow(parent)
# span container columns
self.treeView_openCL.setFirstColumnSpanned(
i, self.treeView_openCL.rootIndex(), True)
self.treeView_openCL.expandAll()
def add_store_path(self, path, parent=None):
if parent is None:
parent = self.model().invisibleRootItem()
store_icon_pixmap = QPixmap()
#hash = get_command_output('nix-hash --type sha1 --to-base16 '+path[11:11+32]).strip()
hash = ctypes_wrapper.nix_build_hash_base32_to_base16_c_str(
bytes(path[11:11 + 32], 'ascii'))[5:]
store_icon_pixmap.loadFromData(
pydenticon_generator.generate(hash.decode(), 20, 20))
#print(image)
store_path_icon = QIcon(store_icon_pixmap)
item = QStandardItem(
store_path_icon,
path[len('/nix/store/681354n3k44r8z90m35hm8945vsp95h1-'):])
#item.setIcon(colorify_icon(item.icon(), None))
item.setData(path)
if path in self.system_pkgs_store_paths:
font = QFont()
font.setBold(True)
item.setFont(font)
parent.appendRow(item)
dummy_item = QStandardItem('')
item.appendRow(dummy_item)
return item
def build(self):
for db_map in self.db_maps:
db_map_item = QStandardItem(db_map.codename)
self.appendRow(db_map_item)
for cmd in self.db_mngr.undo_stack[db_map].commands():
cmd_item = QStandardItem(cmd.text())
db_map_item.appendRow(cmd_item)
for key, items in cmd.data().items():
key_item = QStandardItem(str(key))
cmd_item.appendRow(key_item)
for item in items:
key_item.appendRow(QStandardItem(item))
def __init__(self, parent=None):
super().__init__(parent)
self.setColumnCount(1)
root = self.invisibleRootItem()
group1 = QStandardItem("group1")
group1.setText("group1")
value1 = QStandardItem("value1")
value1.setText("value1")
value2 = QStandardItem("value2")
value2.setText("value2")
group1.appendRow(value1)
group1.appendRow(value2)
subgroup1 = QStandardItem("subgroup1")
subgroup1.setText("subgroup1")
group1.appendRow(subgroup1)
sg1value1 = QStandardItem("sg1value1")
sg1value1.setText("sg1value1")
subgroup1.appendRow(sg1value1)
root.appendRow(group1)
class SummaryView(QTreeView):
def __init__(self, *args, **kwargs):
super().__init__(*args, **kwargs)
self.model = QStandardItemModel()
self.setModel(self.model)
self.setHeaderHidden(True)
self.expanded.connect(self.expanded__handler)
self.profiles = []
def update(self, store_path):
self.store_path = store_path
self.model.removeRows(0, self.model.rowCount())
self.model.invisibleRootItem().appendRow(
QStandardItem('Store path: {0}'.format(store_path)))
deps_item = QStandardItem('Dependencies')
self.model.invisibleRootItem().appendRow(deps_item)
direct_deps_item = QStandardItem('Direct')
deps_item.appendRow(direct_deps_item)
self.immediate_direct_deps_item = QStandardItem('Immediate')
direct_deps_item.appendRow(self.immediate_direct_deps_item)
dummy_item = QStandardItem('')
self.immediate_direct_deps_item.appendRow(dummy_item)
self.remote_direct_deps_item = QStandardItem('Remote')
direct_deps_item.appendRow(self.remote_direct_deps_item)
self.remote_direct_deps_item.appendRow(dummy_item)
reverse_deps_item = QStandardItem('Reverse')
deps_item.appendRow(reverse_deps_item)
self.immediate_reverse_deps_item = QStandardItem('Immediate')
reverse_deps_item.appendRow(self.immediate_reverse_deps_item)
self.immediate_reverse_deps_item.appendRow(dummy_item)
self.remote_reverse_deps_item = QStandardItem('Remote')
reverse_deps_item.appendRow(self.remote_reverse_deps_item)
self.remote_reverse_deps_item.appendRow(dummy_item)
def expanded__handler(self, index):
parent_item = self.model.itemFromIndex(index)
if parent_item is self.immediate_direct_deps_item:
self.immediate_direct_deps_item__load()
elif parent_item is self.immediate_reverse_deps_item:
self.immediate_reverse_deps_item__load()
elif parent_item is self.remote_direct_deps_item:
self.immediate_direct_deps_item__load()
self.remote_direct_deps_item__load()
elif parent_item is self.remote_reverse_deps_item:
self.immediate_reverse_deps_item__load()
self.remote_reverse_deps_item__load()
def immediate_direct_deps_item__load(self):
parent_item = self.immediate_direct_deps_item
parent_item.removeRows(0, parent_item.rowCount())
self.immediate_direct_deps = []
for dep in iter_command_output_lines(
'nix-store --query --references ' + self.store_path):
if dep == self.store_path:
continue
self.immediate_direct_deps.append(dep)
parent_item.appendRow(QStandardItem(dep))
def immediate_reverse_deps_item__load(self):
parent_item = self.immediate_reverse_deps_item
parent_item.removeRows(0, parent_item.rowCount())
self.immediate_reverse_deps = []
for dep in iter_command_output_lines('nix-store --query --referrers ' +
self.store_path):
if dep == self.store_path:
continue
self.immediate_reverse_deps.append(dep)
item = QStandardItem(dep)
if dep in self.profiles:
font = QFont()
font.setBold(True)
item.setFont(font)
parent_item.appendRow(item)
def remote_direct_deps_item__load(self):
parent_item = self.remote_direct_deps_item
parent_item.removeRows(0, parent_item.rowCount())
for dep in iter_command_output_lines(
'nix-store --query --requisites ' + self.store_path):
if dep == self.store_path or dep in self.immediate_direct_deps:
continue
self.immediate_direct_deps.append(dep)
parent_item.appendRow(QStandardItem(dep))
def remote_reverse_deps_item__load(self):
parent_item = self.remote_reverse_deps_item
parent_item.removeRows(0, parent_item.rowCount())
for dep in iter_command_output_lines(
'nix-store --query --referrers-closure ' + self.store_path):
if dep == self.store_path or dep in self.immediate_reverse_deps:
continue
self.immediate_reverse_deps.append(dep)
item = QStandardItem(dep)
if dep in self.profiles:
font = QFont()
font.setBold(True)
item.setFont(font)
parent_item.appendRow(item)
def asset_expanded(self, index):
'''
asset treeView expanded
:param index: index of the model
:return:
'''
item = self.source_asset_model.itemFromIndex(index)
asset_level_struct_item = []
self.get_upper_level_item(self.source_asset_model,
asset_level_struct_item, index)
item_level = len(asset_level_struct_item)
if item_level == 1:
search_text = self.lineEditAssetSearch.text()
if search_text:
return
item.removeRows(0, item.rowCount())
# this is the top level
_asset_type = asset_level_struct_item[0]
asset_entity_list = self.sg.get_asset_list(self.project_name,
_asset_type)
if asset_entity_list:
for asset_entity in asset_entity_list:
asset_name = asset_entity['code']
asset_name_chinesename = asset_entity['sg_chinesename']
if asset_name_chinesename:
asset_name = asset_name + "|" + asset_name_chinesename
asset_name_item = QStandardItem(asset_name)
asset_name_item.setEditable(False)
# append the next level item
retrieving = QStandardItem("Retrieving Tasks...")
retrieving.setEditable(False)
asset_name_item.appendRow(retrieving)
item.appendRow(asset_name_item)
else:
# if this level not item then show Retrieving Task...
retrieving = QStandardItem("Retrieving Tasks...")
retrieving.setEditable(False)
item.appendRow(retrieving)
elif item_level == 2:
item.removeRows(0, item.rowCount())
asset_name = asset_level_struct_item[1]
asset_task_list = self.sg.get_asset_task_list(
self.project_name, asset_name)
asset_step_name_set = set()
if asset_task_list:
for asset_task in asset_task_list:
asset_task_step = asset_task['step']
if asset_task_step:
asset_task_step_name = asset_task_step['name']
# remove all duplicate name in step by using set()
asset_step_name_set.add(asset_task_step_name)
for step_name in asset_step_name_set:
asset_task_step_name_item = QStandardItem(step_name)
asset_task_step_name_item.setEditable(False)
# append the next level item
retrieving = QStandardItem("Retrieving Tasks...")
retrieving.setEditable(False)
asset_task_step_name_item.appendRow(retrieving)
item.appendRow(asset_task_step_name_item)
asset_level_struct_item.append(step_name)
elif item_level == 3:
item.removeRows(0, item.rowCount())
asset_name = asset_level_struct_item[1]
asset_step_name = asset_level_struct_item[2]
asset_task_list = self.sg.get_asset_task_list(
self.project_name, asset_name, asset_step_name)
if asset_task_list:
for asset_task in asset_task_list:
asset_task_name = asset_task['content']
asset_task_name_item = QStandardItem(asset_task_name)
asset_task_name_item.setEditable(False)
item.appendRow(asset_task_name_item)
def update(self, store_path):
self.store_path = store_path
self.model.removeRows(0, self.model.rowCount())
self.model.invisibleRootItem().appendRow(
QStandardItem('Store path: {0}'.format(store_path)))
deps_item = QStandardItem('Dependencies')
self.model.invisibleRootItem().appendRow(deps_item)
direct_deps_item = QStandardItem('Direct')
deps_item.appendRow(direct_deps_item)
self.immediate_direct_deps_item = QStandardItem('Immediate')
direct_deps_item.appendRow(self.immediate_direct_deps_item)
dummy_item = QStandardItem('')
self.immediate_direct_deps_item.appendRow(dummy_item)
self.remote_direct_deps_item = QStandardItem('Remote')
direct_deps_item.appendRow(self.remote_direct_deps_item)
self.remote_direct_deps_item.appendRow(dummy_item)
reverse_deps_item = QStandardItem('Reverse')
deps_item.appendRow(reverse_deps_item)
self.immediate_reverse_deps_item = QStandardItem('Immediate')
reverse_deps_item.appendRow(self.immediate_reverse_deps_item)
self.immediate_reverse_deps_item.appendRow(dummy_item)
self.remote_reverse_deps_item = QStandardItem('Remote')
reverse_deps_item.appendRow(self.remote_reverse_deps_item)
self.remote_reverse_deps_item.appendRow(dummy_item)
return result
if __name__ == '__main__':
app = QApplication(sys.argv)
model_size = 100000
list = []
source_model = QStandardItemModel()
horizontal_header_list = [
"First Column with spacing", "Second Column with spacing"
]
source_model.setHorizontalHeaderLabels(horizontal_header_list)
for i in range(model_size):
first_item = QStandardItem("FancyTextNumber {}".format(i))
if i == 0:
first_item.appendRow(add_child(2, 2))
second_item = QStandardItem("FancyRow2TextNumber {}".format(i))
if i % 2 == 0:
first_item.setBackground(Qt.red)
row = [first_item, second_item]
source_model.invisibleRootItem().appendRow(row)
list.append("FancyTextNumber {}".format(i))
# Needed by QMLModelViewClient
role_names = {
Qt.DisplayRole: QByteArray(b'_text'),
Qt.BackgroundRole: QByteArray(b'_color')
}
source_model.setItemRoleNames(role_names)
roles = [Qt.DisplayRole, Qt.BackgroundRole]
