def populateTableViews(self, polarity):
frags, adds = self.getFragAddData(polarity)
self.adductsModel, self.fragsModel = QStandardItemModel(), QStandardItemModel()
self.adductsModel.setHorizontalHeaderLabels(["Adducts(name, mass, nmol)"])
self.fragsModel.setHorizontalHeaderLabels(["Fragments(name, mass, nmol)"])
for i, adduct in enumerate(adds.keys()):
item =QStandardItem(', '.join(map(str, adduct)))
item.setCheckable(True)
if adds[adduct]:
item.setCheckState(2)
else:
item.setCheckState(0)
self.adductsModel.setItem(i, 0, item)
self.view.adductsTable.setModel(self.adductsModel)
for i, frag in enumerate(frags.keys()):
item = QStandardItem(', '.join(map(str, frag)))
item.setCheckable(True)
if frags[frag]:
item.setCheckState(2)
else:
item.setCheckState(0)
self.fragsModel.setItem(i, 0, item)
self.view.fragTable.setModel(self.fragsModel)
def populateProjects(self): row = 0 for project in getProjects(): projectitem = QStandardItem(project.name) projectitem.setCheckable(True) self.projectsmodel.insertRow(row, projectitem) row += 1
def populateForms(self): row = 0 for form in getForms(): formitem = QStandardItem(form) formitem.setCheckable(True) self.formmodel.insertRow(row, formitem) row += 1
def setupChecklist(widget, names, checks = None):
tp = type(widget)
# Prepare checks
if checks is None:
checks = []
for name in names:
checks.append(Qt.Unchecked)
else:
newChecks = []
for check in checks:
if check: newChecks.append(Qt.Checked)
else: newChecks.append(Qt.Unchecked)
checks = newChecks
## QListView
if tp is QListView:
model = QStandardItemModel()
for i in xrange(len(names)):
item = QStandardItem(names[i])
item.setCheckable(True)
item.setCheckState(checks[i])
model.appendRow(item)
widget.setModel(model)
## QListWidget
elif tp is QListWidget:
for i in xrange(len(names)):
item = QListWidgetItem(names[i])
item.setFlags(Qt.ItemFlags(48)) # 48 = checkable(16), enabled(32)
item.setCheckState(checks[i])
widget.addItem(item)
## NOT SUPPORTED
else: raise TypeError('Class ' + str(tp) + ' is not supported.')
def fillScalars(self):
scalars = [ 'absorbance (%)',
'reflectance (%)',
'transmittance (%)',
'absorbance (mA/cm²)',
'reflectance (mA/cm²)',
'transmittance (mA/cm²)',
'generation',
'Jmax (mA/cm²)',
'absorption layerwise (%)',
'absorption layerwise (mA/cm²)',
'collection layerwise (%)',
'collection layerwise (mA/cm²)',
'calc. time (s)'
]
self.scalarListModel = QStandardItemModel()
scalarsToShow = self.defaults['defaultScalars']
for value in scalars:
item = QStandardItem(value)
check = Qt.Checked if value in scalarsToShow else Qt.Unchecked
item.setCheckState(check)
item.setCheckable(True)
self.scalarListModel.appendRow(item)
self.scalarListView.setModel(self.scalarListModel)
def on_ions_updated(self, new_ions):
qmodel = QStandardItemModel()
qmodel.setColumnCount(2)
qmodel.setHorizontalHeaderItem(0, QStandardItem('Ion'))
qmodel.setHorizontalHeaderItem(1, QStandardItem('Abundance (%)'))
root = qmodel.invisibleRootItem()
element_keyfunc = lambda x: x.isotope.element
sorted_ions = sorted(new_ions, key=element_keyfunc)
for element, ions in itertools.groupby(sorted_ions, key=element_keyfunc):
element_item = QStandardItem(element)
element_item.setCheckable(True)
element_item.setCheckState(2)
root.appendRow(element_item)
for ion in ions:
ion_name = QStandardItem(ion.name)
ion_name.setData(ion,32)
ion_name.emitDataChanged()
ion_abundance = QStandardItem(str(ion.isotope.abundance))
element_item.appendRow([ion_name, ion_abundance])
self.ionlistTree.setModel(qmodel)
self.ionlistTree.expandAll()
self.addionsButton.setEnabled(True)
self._qmodel=qmodel
def _guiUpdate_table(self,uuid):
""
self.dbconn=DbConn()
# self.uuid=self.dbconn.get_uuid()
uuid=''
self.meta=self.dbconn.get_meta_kv()[uuid]
keys=self.meta.keys()
model=QStandardItemModel()
model.setHorizontalHeaderItem(0,QStandardItem("Attribute"))
model.setHorizontalHeaderItem(1,QStandardItem("Value"))
for k in keys:
name=self.meta[k]['Attribute']
item1 = QStandardItem(k)
item2 = QStandardItem(name)
item1.setCheckable(True)
model.appendRow([item1,item2])
# model.itemChanged.connect(lambda: on_item_changed())
self.model=model
self.ui.metaeditor.setModel(model)
self.ui.metaeditor.setEditTriggers(QAbstractItemView.NoEditTriggers)
self.ui.metaeditor.sortByColumn(1)
self.ui.metaeditor.resizeColumnsToContents()
def populateList(self):
model = QStandardItemModel()
for i, option in enumerate(self.options):
item = QStandardItem(option)
item.setCheckState(Qt.Checked if i in self.selectedoptions else Qt.Unchecked)
item.setCheckable(True)
model.appendRow(item)
self.lstLayers.setModel(model)
def _add_entity(self, entity):
# Add entity item to view
item = QStandardItem(
QIcon(':/plugins/stdm/images/icons/table.png'),
entity.short_name
)
item.setCheckable(True)
item.setCheckState(Qt.Unchecked)
self._model.appendRow(item)
def get_coloured_root_item(filepath, color, colorr):
root = QStandardItem(filepath)
gradient = QLinearGradient(-100, -100, 100, 100)
gradient.setColorAt(0.7, colorr)
gradient.setColorAt(1, color)
root.setBackground(QBrush(gradient))
root.setEditable(False)
root.setCheckState(Qt.Checked)
root.setCheckable(True)
return root
def add_type(self):
text, ok = QInputDialog.getText(self, 'Add new type', 'Postfix:')
if ok:
catType = QStandardItem(text)
catType.setCheckable(True)
index = self.treeView.selectedIndexes()[0]
if self.model.itemFromIndex(index).hasChildren():
self.model.itemFromIndex(index).appendRow(catType)
else:
self.model.itemFromIndex(index).parent().appendRow(catType)
def _load_item(self, values, checked_values):
"""Load item list"""
for v in values:
item = QStandardItem(str(v))
if v in checked_values:
item.setCheckState(Qt.Checked)
else:
item.setCheckState(Qt.Unchecked)
item.setCheckable(True)
self.m_sim.appendRow(item)
def populateList(self):
model = QStandardItemModel()
for i, option in enumerate(self.options):
item = QStandardItem(option)
item.setCheckState(Qt.Checked if i in
self.selectedoptions else Qt.Unchecked)
item.setCheckable(True)
model.appendRow(item)
self.lstLayers.setModel(model)
def populateRightListView(self, rightDataList):
assert all(isinstance(item, str) for item in rightDataList)
model = self.rightListView.model()
if model is None:
model = QStandardItemModel(self.rightListView)
for data in rightDataList:
item = QStandardItem(data)
# disable checkbox as is confusing
item.setCheckable(False)
model.appendRow(item)
self.rightListView.setModel(model)
def getColouredRootItem(sample):
"""stable, may be subdivised in sub routines """
root = QStandardItem(sample.shortName())
#root.setIcon(QIcon(QPixmap(os.path.normpath('gui/icons/formula.png'))))
color =QColor.fromRgbF(sample.color[0],sample.color[1], sample.color[2],1.)
colorr=QColor.fromRgbF(sample.color[0],sample.color[1], sample.color[2],.5)
gradient=QLinearGradient(-100, -100, 100, 100)
gradient.setColorAt(0.7, colorr);gradient.setColorAt(1, color)
root.setBackground(QBrush(gradient))
root.setEditable(False)
root.setCheckState(Qt.Checked)
root.setCheckable(True)
return root
def _add_item(self, id, value):
"""
Adds a row corresponding to id and corresponding value from a lookup
table.
:param id: Primary key of a lookup record.
:type id: int
:param value: Lookup value
:type value: str
"""
value_item = QStandardItem(value)
value_item.setCheckable(True)
id_item = QStandardItem(str(id))
self._item_model.appendRow([value_item, id_item])
def get_attributes(self):
"""Place excludable attributes in model list"""
# Model Structure used from Tutorial at
# http://pythoncentral.io/pyside-pyqt-tutorial-qlistview-and-qstandarditemmodel/
self.model = QStandardItemModel(self.listTblAttrib)
self.hasGeometry = self.iface.activeLayer().hasGeometryType()
self.provider = self.iface.activeLayer().dataProvider()
fields = self.iface.activeLayer().pendingFields()
for field in fields:
item = QStandardItem(field.name())
item.setCheckable(True)
self.model.appendRow(item)
self.listTblAttrib.setModel(self.model)
def Add(self, caption, isCheckedFlag=False):
captionStr = ""
if isinstance(caption, str) or isinstance(caption, QString):
captionStr = caption
else:
captionStr = caption.ToString()
self.hasObject = True
self.objList.append([self.stdModel.rowCount(), caption])
item = QStandardItem(captionStr)
item.setCheckable(True)
if isCheckedFlag:
item.setCheckState(Qt.Checked)
else:
item.setCheckState(Qt.Unchecked)
self.stdModel.setItem(self.stdModel.rowCount(), item)
def addGroup(self, name = None, metadata = None):
model = self.model()
group_item = QStandardItem(name or 'New Group')
group_item.setFlags(Qt.ItemIsSelectable|Qt.ItemIsEditable)
group_item.setEnabled(True)
if metadata:
group_item.setText('Metadata')
group_item.setDropEnabled(True)
group_item.setDragEnabled(True)
group_item.setCheckable(True)
group_item.setCheckState(Qt.Checked)
group_item.setIcon(QIcon(os.path.join(os.path.dirname(__file__),"group.png")))
model.appendRow([group_item])
if not name:
self.setCurrentIndex(model.indexFromItem(group_item))
return group_item
def getColouredRootItem(sample):
"""stable, may be subdivised in sub routines """
root = QStandardItem(sample.shortName())
#root.setIcon(QIcon(QPixmap(os.path.normpath('gui/icons/formula.png'))))
color = QColor.fromRgbF(sample.color[0], sample.color[1],
sample.color[2], 1.)
colorr = QColor.fromRgbF(sample.color[0], sample.color[1],
sample.color[2], .5)
gradient = QLinearGradient(-100, -100, 100, 100)
gradient.setColorAt(0.7, colorr)
gradient.setColorAt(1, color)
root.setBackground(QBrush(gradient))
root.setEditable(False)
root.setCheckState(Qt.Checked)
root.setCheckable(True)
return root
def _loadAttrs(self, attrMapping):
"""
Loads display mapping into the list view.
"""
self._attrModel.clear()
self._attrModel.setColumnCount(2)
for attrName, displayName in attrMapping.iteritems():
#Exclude row ID in the list, other unique identifier attributes in the model can be used
if attrName != "id":
displayNameItem = QStandardItem(displayName)
displayNameItem.setCheckable(True)
attrNameItem = QStandardItem(attrName)
self._attrModel.appendRow([displayNameItem, attrNameItem])
self.setModel(self._attrModel)
def _loadAttrs(self,attrMapping):
"""
Loads display mapping into the list view.
"""
self._attrModel.clear()
self._attrModel.setColumnCount(2)
for attrName,displayName in attrMapping.iteritems():
#Exclude row ID in the list, other unique identifier attributes in the model can be used
if attrName != "id":
displayNameItem = QStandardItem(displayName)
displayNameItem.setCheckable(True)
attrNameItem = QStandardItem(attrName)
self._attrModel.appendRow([displayNameItem,attrNameItem])
self.setModel(self._attrModel)
def populate_columns_list(self):
"""
Populate the columns view.
:return:
:rtype:
"""
options = {}
options['type'] = 'combobox'
delegate = GenericDelegate(
self.separators, options, self.column_code_view)
# Set delegate to add widget
self.column_code_view.setItemDelegate(
delegate
)
self.column_code_view.setItemDelegateForColumn(
1, delegate
)
model = QStandardItemModel(2, 2)
i = 0
for row, col in enumerate(self._columns):
column_item = QStandardItem(self._entity.columns[col].header())
column_item.setCheckable(True)
model.setItem(i, 0, column_item)
column_item.setData(col)
self.column_code_view.setModel(model)
i = i + 1
for col in self._entity.columns.values():
if col.name == 'id':
continue
if col.name not in self._columns:
# Correct row by reducing by one due to removal of id
column_item = QStandardItem(col.header())
column_item.setCheckable(True)
model.setItem(i, 0, column_item)
column_item.setData(col.name)
self.column_code_view.setModel(model)
i = i + 1
def __init__(self, parent=None):
QStandardItemModel.__init__(self, parent)
self._settings = QSettings()
for pluginobject in PluginLoader("ALL").plugins:
# Changed the plugin viewable name to the UserString value
# as it looks better for the user.
#item = QStandardItem(pluginobject.pluginName)
item = QStandardItem(pluginobject.pluginUserString)
check = Qt.Unchecked
valueString = "plugins/" + pluginobject.pluginName + "/load"
if self._settings.value(valueString).toString() == "True":
check = Qt.Checked
item.setCheckState(check)
item.setCheckable(True)
item.setEditable(False)
item.plugin = pluginobject
self.appendRow(item)
def __init__(self, parent = None):
QStandardItemModel.__init__(self, parent)
self._settings = QSettings()
for pluginobject in PluginLoader("ALL").plugins:
# Changed the plugin viewable name to the UserString value
# as it looks better for the user.
#item = QStandardItem(pluginobject.pluginName)
item = QStandardItem(pluginobject.pluginUserString)
check = Qt.Unchecked
valueString = "plugins/" + pluginobject.pluginName + "/load"
if self._settings.value(valueString).toString() == "True":
check = Qt.Checked
item.setCheckState(check)
item.setCheckable(True)
item.setEditable(False)
item.plugin = pluginobject
self.appendRow(item)
def fillCalculations(self):
self.calculations = [
'Stack optics (A,R,T)', 'Ellipsometry', 'Field intensity',
'Layerwise optics (absorption, collection, QE)', 'Generation'
]
self.calcListModel = QStandardItemModel()
calculationsToShow = self.defaults['defaultCalculations']
for value in self.calculations:
item = QStandardItem(value)
check = Qt.Checked if value in calculationsToShow else Qt.Unchecked
item.setCheckState(check)
item.setCheckable(True)
#item.setEnabled(False)
self.calcListModel.appendRow(item)
self.calculationsListView.setModel(self.calcListModel)
def model_init(self):
categories = {}
if not categories:
with open('categories.json') as f:
categories = load(f)
for element in categories:
catItem = QStandardItem(element.keys()[0])
catItem.setCheckable(True)
catItem.setCheckState(element[element.keys()[0]])
for type_name, check_state in element["Types"].items():
typeItem = QStandardItem(type_name)
typeItem.setCheckable(True)
typeItem.setCheckState(check_state)
catItem.appendRow(typeItem)
self.model.appendRow(catItem)
self.treeView.setModel(self.model)
self.submit_file_types()
def fillCalculations(self):
self.calculations = ['Stack optics (A,R,T)',
'Ellipsometry',
'Field intensity',
'Layerwise optics (absorption, collection, QE)',
'Generation'
]
self.calcListModel = QStandardItemModel()
calculationsToShow = self.defaults['defaultCalculations']
for value in self.calculations:
item = QStandardItem(value)
check = Qt.Checked if value in calculationsToShow else Qt.Unchecked
item.setCheckState(check)
item.setCheckable(True)
#item.setEnabled(False)
self.calcListModel.appendRow(item)
self.calculationsListView.setModel(self.calcListModel)
def fillScalars(self):
scalars = [
'absorbance (%)', 'reflectance (%)', 'transmittance (%)',
'absorbance (mA/cm²)', 'reflectance (mA/cm²)',
'transmittance (mA/cm²)', 'generation', 'Jmax (mA/cm²)',
'absorption layerwise (%)', 'absorption layerwise (mA/cm²)',
'collection layerwise (%)', 'collection layerwise (mA/cm²)',
'calc. time (s)'
]
self.scalarListModel = QStandardItemModel()
scalarsToShow = self.defaults['defaultScalars']
for value in scalars:
item = QStandardItem(value)
check = Qt.Checked if value in scalarsToShow else Qt.Unchecked
item.setCheckState(check)
item.setCheckable(True)
self.scalarListModel.appendRow(item)
self.scalarListView.setModel(self.scalarListModel)
def initListView(self):
"""Init status table"""
# List Box model
model = QStandardItemModel()
# Init list objects
for i, frame in enumerate(self.task.videoLabelHandler.files):
item = QStandardItem(frame + "\t{0} Objects".format(len(self.task.videoLabelHandler.objects)))
item.setCheckState(Qt.Checked)
item.setCheckable(True)
model.appendRow(item)
if self.segmentation_mode:
model.item(0).setEnabled(False)
else:
model.item(i).setCheckState(Qt.Unchecked)
model.item(i).setEnabled(False)
# Set model
self.view.setModel(model)
def add_column(self, column_name, display_name, order=NOT_SET):
"""
Adds a new column row to the model and sets the sort order.
:param column_name: Column name in the data source.
:type column_name: str
:param display_name: Friendly column display name.
:type display_name: str
:param order: Sort order.
:type order: int
"""
col_item = QStandardItem(display_name)
col_item.setCheckable(True)
col_item.setData(column_name, DATA_ROLE)
sort_item = QStandardItem()
sort_txt = SORT_ORDER_NAME.get(order, '')
sort_item.setText(sort_txt)
sort_item.setData(order, DATA_ROLE)
self.appendRow([col_item, sort_item])
def fillPlots(self):
plots = [
'total A,R,T', # requires calc [0]
'Ellipsometry', # requires nothing
'absorption (layerwise)', # requires calc [2]
'collection (layerwise)', # requires calc [2]
'QE', # requires calc [2]
'reflection (interfacewise)',
'generation' # requires calc [3]
]
self.plotListModel = QStandardItemModel()
plotsToShow = self.defaults['defaultPlots']
for value in plots:
item = QStandardItem(value)
check = Qt.Checked if value in plotsToShow else Qt.Unchecked
item.setCheckState(check)
item.setCheckable(True)
self.plotListModel.appendRow(item)
self.plotListView.setModel(self.plotListModel)
def _loadAttrs(self, attrMapping, sort=False):
"""
Loads display mapping into the list view.
Specify to sort display names in ascending order once items have been
added to the model.
"""
self._attrModel.clear()
self._attrModel.setColumnCount(2)
for attrName,displayName in attrMapping.iteritems():
#Exclude row ID in the list, other unique identifier attributes in the model can be used
if attrName != "id":
displayNameItem = QStandardItem(displayName)
displayNameItem.setCheckable(True)
attrNameItem = QStandardItem(attrName)
self._attrModel.appendRow([displayNameItem,attrNameItem])
self.setModel(self._attrModel)
if sort:
self._attrModel.sort(0)
def appendRepository(self, path, active, autoUpdate, canAutoUpdate = None):
activeItem = QStandardItem()
activeItem.setEditable(False)
activeItem.setCheckState(Qt.Checked if active else Qt.Unchecked)
activeItem.setCheckable(True)
pathItem = QStandardItem()
pathItem.setData(path, Qt.DisplayRole)
pathItem.setEditable(False)
autoUpdateItem = QStandardItem()
autoUpdateItem.setEditable(False)
if canAutoUpdate == None:
canAutoUpdate = self._gitHandler.hasGit(path)
if canAutoUpdate:
autoUpdateItem.setCheckState(Qt.Checked if autoUpdate else Qt.Unchecked)
autoUpdateItem.setCheckable(True)
statusItem = QStandardItem()
self._updateStatusItem(statusItem, path)
self._reposModel.appendRow([activeItem, pathItem, autoUpdateItem, statusItem])
def fillPlots(self):
plots = [ 'total A,R,T', # requires calc [0]
'Ellipsometry', # requires nothing
'absorption (layerwise)', # requires calc [2]
'collection (layerwise)', # requires calc [2]
'QE', # requires calc [2]
'reflection (interfacewise)',
'generation' # requires calc [3]
]
self.plotListModel = QStandardItemModel()
plotsToShow = self.defaults['defaultPlots']
for value in plots:
item = QStandardItem(value)
check = Qt.Checked if value in plotsToShow else Qt.Unchecked
item.setCheckState(check)
item.setCheckable(True)
self.plotListModel.appendRow(item)
self.plotListView.setModel(self.plotListModel)
def _loadAttrs(self, attrMapping, sort=False):
"""
Loads display mapping into the list view.
Specify to sort display names in ascending order once items have been
added to the model.
"""
self._attrModel.clear()
self._attrModel.setColumnCount(2)
for attrName,displayName in attrMapping.iteritems():
#Exclude row ID in the list, other unique identifier attributes in the model can be used
if attrName != "id":
displayNameItem = QStandardItem(displayName)
displayNameItem.setCheckable(True)
attrNameItem = QStandardItem(attrName)
self._attrModel.appendRow([displayNameItem,attrNameItem])
self.setModel(self._attrModel)
if sort:
self._attrModel.sort(0)
def populate_uuid(self):
""
self.dbconn=DbConn()
self.uuid=self.dbconn.get_uuid()
keys=self.uuid.keys()
model=QStandardItemModel()
model.setHorizontalHeaderItem(0,QStandardItem("UUID"))
model.setHorizontalHeaderItem(1,QStandardItem("Path"))
def on_item_changed():
i = 0
list=[]
while model.item(i):
if not model.item(i,0).checkState():
""
# return
else:
# print model.item(i,0).text()
list.append(model.item(i,0).text())
i += 1
self.UUIDList=list
for key in keys:
name=self.uuid[key]['Path']
item1 = QStandardItem(key)
item2 = QStandardItem(name)
item1.setCheckable(True)
model.appendRow([item1,item2])
model.itemChanged.connect(lambda: on_item_changed())
self.ui.inUUIDList.setModel(model)
self.ui.inUUIDList.setEditTriggers(QAbstractItemView.NoEditTriggers)
self.ui.inUUIDList.sortByColumn(1)
self.ui.inUUIDList.resizeColumnsToContents()
def fillCheckboxes(self, layers, name):
"""
Function for filling listView with checkboxes
:param layers: layers from Qgis legend
:param name: name of current layer from comboBox
:return:
"""
layer = None
model = QStandardItemModel()
self.dlg.listView.reset()
for layer in layers:
if layer.name() == name:
fields = layer.pendingFields()
fieldNames = [field.name() for field in fields]
for fieldName in fieldNames:
item = QStandardItem(fieldName)
item.setCheckable(True)
item.setText(fieldName)
model.appendRow(item)
self.dlg.listView.setModel(model)
def load_document_types(self):
"""
Load all document types to the list view and enable/check the items
for those types that have been found.
"""
self._attr_model.clear()
self._attr_model.setColumnCount(2)
file_infos = self._dir.entryInfoList(
QDir.Readable | QDir.Files,
QDir.Name
)
# Index file info based on name
idx_file_infos = {fi.completeBaseName().lower(): fi for fi in file_infos}
for d in self._doc_types:
doc_type_item = QStandardItem(d)
doc_type_item.setCheckable(True)
path_item = QStandardItem()
item_enabled = False
check_state = Qt.Unchecked
dl = d.lower()
if dl in idx_file_infos:
item_enabled = True
check_state = Qt.Checked
path = idx_file_infos[dl].filePath()
path_item.setText(path)
doc_type_item.setToolTip(path)
doc_type_item.setEnabled(item_enabled)
doc_type_item.setCheckState(check_state)
self._attr_model.appendRow([doc_type_item, path_item])
self.lst_docs.setModel(self._attr_model)
def comboProjectChanged(self):
if len(self.ui.comboProject.currentText()) > 0:
self.project_id = self.projects_id[self.ui.comboProject.currentText()]
#get project tasks
qsubtasks = QStandardItemModel()
for proj_tasks in self.asana_api.tasks.find_by_project(self.project_id, { 'completed_since': 'now'}):
item = QStandardItem(proj_tasks['name'])
item.setEditable(True)
item.setToolTip('Double click to edit')
if not proj_tasks['name'].endswith(':'):
check = Qt.Unchecked
item.setCheckState(check)
item.setCheckable(True)
self.projects_id[proj_tasks['name']] = proj_tasks['id']
item.setStatusTip(str(proj_tasks['id']))
else:
font = QFont()
font.setWeight(QFont.Bold)
item.setFont(font)
#populate the listview
qsubtasks.appendRow(item)
self.ui.listTasks.setModel(qsubtasks)
QApplication.setOverrideCursor(QCursor(Qt.ArrowCursor))
qsubtasks.itemChanged.connect(self.checkTasks)
def setColumnCombos(self, cols, quotedCols):
# get sensible default columns. do this before sorting in case there's hints in the column order (eg, id is more likely to be first)
try:
defaultGeomCol = next(col for col in cols if col in ['geom', 'geometry', 'the_geom', 'way'])
except:
defaultGeomCol = None
try:
defaultUniqueCol = [col for col in cols if 'id' in col][0]
except:
defaultUniqueCol = None
colNames = sorted(zip(cols, quotedCols))
newItems = []
uniqueIsFilled = False
for (col, quotedCol) in colNames:
item = QStandardItem(col)
item.setData(quotedCol)
item.setEnabled(True)
item.setCheckable(self.allowMultiColumnPk)
item.setSelectable(not self.allowMultiColumnPk)
if self.allowMultiColumnPk:
matchingItems = self.uniqueModel.findItems(col)
if matchingItems:
item.setCheckState(matchingItems[0].checkState())
uniqueIsFilled = uniqueIsFilled or matchingItems[0].checkState() == Qt.Checked
else:
item.setCheckState(Qt.Unchecked)
newItems.append(item)
if self.allowMultiColumnPk:
self.uniqueModel.clear()
self.uniqueModel.appendColumn(newItems)
self.uniqueChanged()
else:
previousUniqueColumn = self.uniqueCombo.currentText()
self.uniqueModel.clear()
self.uniqueModel.appendColumn(newItems)
if self.uniqueModel.findItems(previousUniqueColumn):
self.uniqueCombo.setEditText(previousUniqueColumn)
uniqueIsFilled = True
oldGeometryColumn = self.geomCombo.currentText()
self.geomCombo.clear()
self.geomCombo.addItems(cols)
self.geomCombo.setCurrentIndex(self.geomCombo.findText(oldGeometryColumn, Qt.MatchExactly))
# set sensible default columns if the columns are not already set
try:
if self.geomCombo.currentIndex() == -1:
self.geomCombo.setCurrentIndex(cols.index(defaultGeomCol))
except:
pass
items = self.uniqueModel.findItems(defaultUniqueCol)
if items and not uniqueIsFilled:
if self.allowMultiColumnPk:
items[0].setCheckState(Qt.Checked)
else:
self.uniqueCombo.setEditText(defaultUniqueCol)
try:
pass
except:
pass
def setColumnCombos(self, cols, quotedCols):
# get sensible default columns. do this before sorting in case there's hints in the column order (eg, id is more likely to be first)
try:
defaultGeomCol = next(col for col in cols if col in ['geom', 'geometry', 'the_geom', 'way'])
except:
defaultGeomCol = None
try:
defaultUniqueCol = [col for col in cols if 'id' in col][0]
except:
defaultUniqueCol = None
colNames = sorted(zip(cols, quotedCols))
newItems = []
uniqueIsFilled = False
for (col, quotedCol) in colNames:
item = QStandardItem(col)
item.setData(quotedCol)
item.setEnabled(True)
item.setCheckable(self.allowMultiColumnPk)
item.setSelectable(not self.allowMultiColumnPk)
if self.allowMultiColumnPk:
matchingItems = self.uniqueModel.findItems(col)
if matchingItems:
item.setCheckState(matchingItems[0].checkState())
uniqueIsFilled = uniqueIsFilled or matchingItems[0].checkState() == Qt.Checked
else:
item.setCheckState(Qt.Unchecked)
newItems.append(item)
if self.allowMultiColumnPk:
self.uniqueModel.clear()
self.uniqueModel.appendColumn(newItems)
self.uniqueChanged()
else:
previousUniqueColumn = self.uniqueCombo.currentText()
self.uniqueModel.clear()
self.uniqueModel.appendColumn(newItems)
if self.uniqueModel.findItems(previousUniqueColumn):
self.uniqueCombo.setEditText(previousUniqueColumn)
uniqueIsFilled = True
oldGeometryColumn = self.geomCombo.currentText()
self.geomCombo.clear()
self.geomCombo.addItems(cols)
self.geomCombo.setCurrentIndex(self.geomCombo.findText(oldGeometryColumn, Qt.MatchExactly))
# set sensible default columns if the columns are not already set
try:
if self.geomCombo.currentIndex() == -1:
self.geomCombo.setCurrentIndex(cols.index(defaultGeomCol))
except:
pass
items = self.uniqueModel.findItems(defaultUniqueCol)
if items and not uniqueIsFilled:
if self.allowMultiColumnPk:
items[0].setCheckState(Qt.Checked)
else:
self.uniqueCombo.setEditText(defaultUniqueCol)
try:
pass
except:
pass
def __init__(self, template, character, parent=None):
super(SubPowerWidget, self).__init__(parent)
self.__storage = template
self.__character = character
self.__model = QStandardItemModel()
# Das ungenutzte Model dient dazu, alle Unterkräfte aufzunehmen, die ich nicht darstellen möchte. Ist einfacher, als diese im View zu verstecken.
self.__modelUnused = QStandardItemModel()
self._layout = QVBoxLayout()
self.setLayout( self._layout )
self.__view = QTreeView()
self.__view.setHeaderHidden(True)
self.__view.setModel( self.__model)
self._layout.addWidget(self.__view)
self._typ = "Subpower"
categories = self.__storage.categories(self._typ)
self.__items = {}
self.__rootItem = QStandardItem()
self.__rootItem = self.__model.invisibleRootItem()
self.__rootItemUnused = QStandardItem()
self.__rootItemUnused = self.__modelUnused.invisibleRootItem()
for item in categories:
categoryItem = QStandardItem(item)
self.__rootItem.appendRow(categoryItem)
## Ich benötige diese Items auch im ungenutzten Model.
categoryItemUnused = QStandardItem(item)
self.__rootItemUnused.appendRow(categoryItemUnused)
traitList = list( self.__character.traits[self._typ][item].items() )
traitList.sort()
for trait in traitList:
traitItem = QStandardItem(trait[1].name)
traitItem.setCheckable(True)
## Unhashable Type
self.__items[trait[1]] = traitItem
categoryItem.appendRow(traitItem)
## Funktioniert mit PySide nicht:
#trait[1].availableChanged.connect(traitItem.setEnabled)
## Funktioniert auch mit PySide:
trait[1].availableChanged.connect(
lambda enable, item=traitItem: item.setEnabled(enable)
)
trait[1].valueChanged.connect(
lambda val, trait=trait[1], item=traitItem: self.__setItemValue(trait, item)
)
self.__model.itemChanged.connect(self.__getItemValue)
self.__character.speciesChanged.connect(self.hideOrShowToolPage)
self.__character.breedChanged.connect(self.hideOrShowToolPage)
self.__character.factionChanged.connect(self.hideOrShowToolPage)
def __setupUi(self):
"""Set up the UI.
"""
if self.__macUnified:
self.tab = QToolBar()
self.addToolBar(Qt.TopToolBarArea, self.tab)
self.setUnifiedTitleAndToolBarOnMac(True)
# This does not seem to work
self.setWindowFlags(self.windowFlags() & \
~Qt.MacWindowToolBarButtonHint)
self.tab.actionTriggered[QAction].connect(
self.__macOnToolBarAction)
central = QStackedWidget()
central.setSizePolicy(QSizePolicy.Fixed, QSizePolicy.Fixed)
else:
self.tab = central = QTabWidget(self)
# Add a close button to the bottom of the dialog
# (to satisfy GNOME 3 which shows the dialog without a title bar).
container = container_widget_helper()
container.layout().addWidget(central)
buttonbox = QDialogButtonBox(QDialogButtonBox.Close)
buttonbox.rejected.connect(self.close)
container.layout().addWidget(buttonbox)
self.setCentralWidget(container)
self.stack = central
# General Tab
tab = QWidget()
self.addTab(tab,
self.tr("General"),
toolTip=self.tr("General Options"))
form = QFormLayout()
tab.setSizePolicy(QSizePolicy.Fixed, QSizePolicy.Fixed)
nodes = QWidget(self, objectName="nodes")
nodes.setLayout(QVBoxLayout())
nodes.layout().setContentsMargins(0, 0, 0, 0)
cb_anim = QCheckBox(self.tr("Enable node animations"),
objectName="enable-node-animations",
toolTip=self.tr(
"Enable shadow and ping animations for node "
"items in the scheme."))
self.bind(cb_anim, "checked", "schemeedit/enable-node-animations")
nodes.layout().addWidget(cb_anim)
form.addRow(self.tr("Nodes"), nodes)
links = QWidget(self, objectName="links")
links.setLayout(QVBoxLayout())
links.layout().setContentsMargins(0, 0, 0, 0)
cb_show = QCheckBox(self.tr("Show channel names between widgets"),
objectName="show-channel-names",
toolTip=self.tr(
"Show source and sink channel names "
"over the links."))
self.bind(cb_show, "checked", "schemeedit/show-channel-names")
links.layout().addWidget(cb_show)
form.addRow(self.tr("Links"), links)
quickmenu = QWidget(self, objectName="quickmenu-options")
quickmenu.setLayout(QVBoxLayout())
quickmenu.layout().setContentsMargins(0, 0, 0, 0)
cb1 = QCheckBox(self.tr("On double click"),
toolTip=self.tr("Open quick menu on a double click "
"on an empty spot in the canvas"))
cb2 = QCheckBox(self.tr("On right click"),
toolTip=self.tr("Open quick menu on a right click "
"on an empty spot in the canvas"))
cb3 = QCheckBox(self.tr("On space key press"),
toolTip=self.tr("On Space key press while the mouse"
"is hovering over the canvas."))
cb4 = QCheckBox(self.tr("On any key press"),
toolTip=self.tr("On any key press while the mouse"
"is hovering over the canvas."))
self.bind(cb1, "checked", "quickmenu/trigger-on-double-click")
self.bind(cb2, "checked", "quickmenu/trigger-on-right-click")
self.bind(cb3, "checked", "quickmenu/trigger-on-space-key")
self.bind(cb4, "checked", "quickmenu/trigger-on-any-key")
quickmenu.layout().addWidget(cb1)
quickmenu.layout().addWidget(cb2)
quickmenu.layout().addWidget(cb3)
quickmenu.layout().addWidget(cb4)
form.addRow(self.tr("Open quick menu on"), quickmenu)
startup = QWidget(self, objectName="startup-group")
startup.setLayout(QVBoxLayout())
startup.layout().setContentsMargins(0, 0, 0, 0)
cb_splash = QCheckBox(self.tr("Show splash screen"),
self,
objectName="show-splash-screen")
cb_welcome = QCheckBox(self.tr("Show welcome screen"),
self,
objectName="show-welcome-screen")
self.bind(cb_splash, "checked", "startup/show-splash-screen")
self.bind(cb_welcome, "checked", "startup/show-welcome-screen")
startup.layout().addWidget(cb_splash)
startup.layout().addWidget(cb_welcome)
form.addRow(self.tr("On startup"), startup)
toolbox = QWidget(self, objectName="toolbox-group")
toolbox.setLayout(QVBoxLayout())
toolbox.layout().setContentsMargins(0, 0, 0, 0)
exclusive = QCheckBox(self.tr("Only one tab can be open at a time"))
self.bind(exclusive, "checked", "mainwindow/toolbox-dock-exclusive")
toolbox.layout().addWidget(exclusive)
form.addRow(self.tr("Tool box"), toolbox)
tab.setLayout(form)
# Output Tab
tab = QWidget()
self.addTab(tab, self.tr("Output"), toolTip="Output Redirection")
form = QFormLayout()
box = QWidget(self, objectName="streams")
layout = QVBoxLayout()
layout.setContentsMargins(0, 0, 0, 0)
cb1 = QCheckBox(self.tr("Standard output"))
cb2 = QCheckBox(self.tr("Standard error"))
self.bind(cb1, "checked", "output/redirect-stdout")
self.bind(cb2, "checked", "output/redirect-stderr")
layout.addWidget(cb1)
layout.addWidget(cb2)
box.setLayout(layout)
form.addRow(self.tr("Redirect output"), box)
box = QWidget()
layout = QVBoxLayout()
layout.setContentsMargins(0, 0, 0, 0)
combo = QComboBox()
combo.addItems([
self.tr("Critical"),
self.tr("Error"),
self.tr("Warn"),
self.tr("Info"),
self.tr("Debug")
])
cb = QCheckBox(self.tr("Show output on 'Error'"),
objectName="focus-on-error")
self.bind(combo, "currentIndex", "logging/level")
self.bind(cb, "checked", "output/show-on-error")
layout.addWidget(combo)
layout.addWidget(cb)
box.setLayout(layout)
form.addRow(self.tr("Logging"), box)
box = QWidget()
layout = QVBoxLayout()
layout.setContentsMargins(0, 0, 0, 0)
cb1 = QCheckBox(self.tr("Stay on top"), objectName="stay-on-top")
cb2 = QCheckBox(self.tr("Dockable"), objectName="output-dockable")
self.bind(cb1, "checked", "output/stay-on-top")
self.bind(cb2, "checked", "output/dockable")
layout.addWidget(cb1)
layout.addWidget(cb2)
box.setLayout(layout)
form.addRow(self.tr("Output window"), box)
box = QWidget()
layout = QVBoxLayout()
layout.setContentsMargins(0, 0, 0, 0)
cb1 = QCheckBox(self.tr("Open in external browser"),
objectName="open-in-external-browser")
cb2 = QCheckBox(self.tr("Stay on top"), objectName="help-stay-on-top")
cb3 = QCheckBox(self.tr("Dockable"), objectName="help-dockable")
self.bind(cb1, "checked", "help/open-in-external-browser")
self.bind(cb2, "checked", "help/stay-on-top")
self.bind(cb3, "checked", "help/dockable")
layout.addWidget(cb1)
layout.addWidget(cb2)
layout.addWidget(cb3)
box.setLayout(layout)
form.addRow(self.tr("Help window"), box)
tab.setLayout(form)
# Categories Tab
tab = QWidget()
layout = QVBoxLayout()
view = QListView()
from .. import registry
reg = registry.global_registry()
model = QStandardItemModel()
settings = QSettings()
for cat in reg.categories():
item = QStandardItem()
item.setText(cat.name)
item.setCheckable(True)
visible, _ = category_state(cat, settings)
item.setCheckState(Qt.Checked if visible else Qt.Unchecked)
model.appendRow([item])
view.setModel(model)
layout.addWidget(view)
tab.setLayout(layout)
model.itemChanged.connect(lambda item: save_category_state(
reg.category(str(item.text())),
_State(item.checkState() == Qt.Checked, -1), settings))
self.addTab(tab, "Categories")
if self.__macUnified:
# Need some sensible size otherwise mac unified toolbar 'takes'
# the space that should be used for layout of the contents
self.adjustSize()
def __setupUi(self):
"""Set up the UI.
"""
if self.__macUnified:
self.tab = QToolBar()
self.addToolBar(Qt.TopToolBarArea, self.tab)
self.setUnifiedTitleAndToolBarOnMac(True)
# This does not seem to work
self.setWindowFlags(self.windowFlags() & \
~Qt.MacWindowToolBarButtonHint)
self.tab.actionTriggered[QAction].connect(
self.__macOnToolBarAction
)
central = QStackedWidget()
central.setSizePolicy(QSizePolicy.Fixed, QSizePolicy.Fixed)
else:
self.tab = central = QTabWidget(self)
# Add a close button to the bottom of the dialog
# (to satisfy GNOME 3 which shows the dialog without a title bar).
container = container_widget_helper()
container.layout().addWidget(central)
buttonbox = QDialogButtonBox(QDialogButtonBox.Close)
buttonbox.rejected.connect(self.close)
container.layout().addWidget(buttonbox)
self.setCentralWidget(container)
self.stack = central
# General Tab
tab = QWidget()
self.addTab(tab, self.tr("General"),
toolTip=self.tr("General Options"))
form = QFormLayout()
tab.setSizePolicy(QSizePolicy.Fixed, QSizePolicy.Fixed)
nodes = QWidget(self, objectName="nodes")
nodes.setLayout(QVBoxLayout())
nodes.layout().setContentsMargins(0, 0, 0, 0)
cb_anim = QCheckBox(
self.tr("Enable node animations"),
objectName="enable-node-animations",
toolTip=self.tr("Enable shadow and ping animations for node "
"items in the scheme.")
)
self.bind(cb_anim, "checked", "schemeedit/enable-node-animations")
nodes.layout().addWidget(cb_anim)
form.addRow(self.tr("Nodes"), nodes)
links = QWidget(self, objectName="links")
links.setLayout(QVBoxLayout())
links.layout().setContentsMargins(0, 0, 0, 0)
cb_show = QCheckBox(
self.tr("Show channel names between widgets"),
objectName="show-channel-names",
toolTip=self.tr("Show source and sink channel names "
"over the links.")
)
self.bind(cb_show, "checked", "schemeedit/show-channel-names")
links.layout().addWidget(cb_show)
form.addRow(self.tr("Links"), links)
quickmenu = QWidget(self, objectName="quickmenu-options")
quickmenu.setLayout(QVBoxLayout())
quickmenu.layout().setContentsMargins(0, 0, 0, 0)
cb1 = QCheckBox(self.tr("On double click"),
toolTip=self.tr("Open quick menu on a double click "
"on an empty spot in the canvas"))
cb2 = QCheckBox(self.tr("On right click"),
toolTip=self.tr("Open quick menu on a right click "
"on an empty spot in the canvas"))
cb3 = QCheckBox(self.tr("On space key press"),
toolTip=self.tr("On Space key press while the mouse"
"is hovering over the canvas."))
cb4 = QCheckBox(self.tr("On any key press"),
toolTip=self.tr("On any key press while the mouse"
"is hovering over the canvas."))
self.bind(cb1, "checked", "quickmenu/trigger-on-double-click")
self.bind(cb2, "checked", "quickmenu/trigger-on-right-click")
self.bind(cb3, "checked", "quickmenu/trigger-on-space-key")
self.bind(cb4, "checked", "quickmenu/trigger-on-any-key")
quickmenu.layout().addWidget(cb1)
quickmenu.layout().addWidget(cb2)
quickmenu.layout().addWidget(cb3)
quickmenu.layout().addWidget(cb4)
form.addRow(self.tr("Open quick menu on"), quickmenu)
startup = QWidget(self, objectName="startup-group")
startup.setLayout(QVBoxLayout())
startup.layout().setContentsMargins(0, 0, 0, 0)
cb_splash = QCheckBox(self.tr("Show splash screen"), self,
objectName="show-splash-screen")
cb_welcome = QCheckBox(self.tr("Show welcome screen"), self,
objectName="show-welcome-screen")
self.bind(cb_splash, "checked", "startup/show-splash-screen")
self.bind(cb_welcome, "checked", "startup/show-welcome-screen")
startup.layout().addWidget(cb_splash)
startup.layout().addWidget(cb_welcome)
form.addRow(self.tr("On startup"), startup)
toolbox = QWidget(self, objectName="toolbox-group")
toolbox.setLayout(QVBoxLayout())
toolbox.layout().setContentsMargins(0, 0, 0, 0)
exclusive = QCheckBox(self.tr("Only one tab can be open at a time"))
self.bind(exclusive, "checked", "mainwindow/toolbox-dock-exclusive")
toolbox.layout().addWidget(exclusive)
form.addRow(self.tr("Tool box"), toolbox)
tab.setLayout(form)
# Output Tab
tab = QWidget()
self.addTab(tab, self.tr("Output"),
toolTip="Output Redirection")
form = QFormLayout()
box = QWidget(self, objectName="streams")
layout = QVBoxLayout()
layout.setContentsMargins(0, 0, 0, 0)
cb1 = QCheckBox(self.tr("Standard output"))
cb2 = QCheckBox(self.tr("Standard error"))
self.bind(cb1, "checked", "output/redirect-stdout")
self.bind(cb2, "checked", "output/redirect-stderr")
layout.addWidget(cb1)
layout.addWidget(cb2)
box.setLayout(layout)
form.addRow(self.tr("Redirect output"), box)
box = QWidget()
layout = QVBoxLayout()
layout.setContentsMargins(0, 0, 0, 0)
combo = QComboBox()
combo.addItems([self.tr("Critical"),
self.tr("Error"),
self.tr("Warn"),
self.tr("Info"),
self.tr("Debug")])
cb = QCheckBox(self.tr("Show output on 'Error'"),
objectName="focus-on-error")
self.bind(combo, "currentIndex", "logging/level")
self.bind(cb, "checked", "output/show-on-error")
layout.addWidget(combo)
layout.addWidget(cb)
box.setLayout(layout)
form.addRow(self.tr("Logging"), box)
box = QWidget()
layout = QVBoxLayout()
layout.setContentsMargins(0, 0, 0, 0)
cb1 = QCheckBox(self.tr("Stay on top"),
objectName="stay-on-top")
cb2 = QCheckBox(self.tr("Dockable"),
objectName="output-dockable")
self.bind(cb1, "checked", "output/stay-on-top")
self.bind(cb2, "checked", "output/dockable")
layout.addWidget(cb1)
layout.addWidget(cb2)
box.setLayout(layout)
form.addRow(self.tr("Output window"), box)
box = QWidget()
layout = QVBoxLayout()
layout.setContentsMargins(0, 0, 0, 0)
cb1 = QCheckBox(self.tr("Open in external browser"),
objectName="open-in-external-browser")
cb2 = QCheckBox(self.tr("Stay on top"),
objectName="help-stay-on-top")
cb3 = QCheckBox(self.tr("Dockable"),
objectName="help-dockable")
self.bind(cb1, "checked", "help/open-in-external-browser")
self.bind(cb2, "checked", "help/stay-on-top")
self.bind(cb3, "checked", "help/dockable")
layout.addWidget(cb1)
layout.addWidget(cb2)
layout.addWidget(cb3)
box.setLayout(layout)
form.addRow(self.tr("Help window"), box)
tab.setLayout(form)
# Categories Tab
tab = QWidget()
layout = QVBoxLayout()
view = QListView()
from .. import registry
reg = registry.global_registry()
model = QStandardItemModel()
settings = QSettings()
for cat in reg.categories():
item = QStandardItem()
item.setText(cat.name)
item.setCheckable(True)
visible, _ = category_state(cat, settings)
item.setCheckState(Qt.Checked if visible else Qt.Unchecked)
model.appendRow([item])
view.setModel(model)
layout.addWidget(view)
tab.setLayout(layout)
model.itemChanged.connect(
lambda item:
save_category_state(
reg.category(str(item.text())),
_State(item.checkState() == Qt.Checked, -1),
settings
)
)
self.addTab(tab, "Categories")
if self.__macUnified:
# Need some sensible size otherwise mac unified toolbar 'takes'
# the space that should be used for layout of the contents
self.adjustSize()
def addFieldDef(self, fieldDef, recover=None):
self.defOrder = [
'fieldName', 'fieldMap', 'fieldLabel', 'fieldType', 'fieldHint',
'fieldRequired', 'fieldDefault', 'fieldQtype', 'fieldWidget',
'fieldChoices', 'fieldAppearance', 'fieldReadOnly',
'fieldCalculation'
]
row = []
self.setIcon(
QIcon(os.path.join(os.path.dirname(__file__), "field.png")))
if not 'fieldReadOnly' in fieldDef:
fieldDef['fieldReadOnly'] = ''
if not 'fieldCalculation' in fieldDef:
fieldDef['fieldCalculation'] = ''
if recover: #backup dict provided if recovering fields state
for fdef in self.defOrder:
if fdef == 'fieldName':
sub_item = QStandardItem(None)
elif fdef == 'fieldRequired':
sub_item = QStandardItem(None)
sub_item.setCheckable(True)
if fieldDef['fieldRequired']:
sub_item.setCheckState(Qt.Checked)
else:
sub_item.setCheckState(Qt.Unchecked)
else:
sub_item = QStandardItem(fieldDef[fdef])
row.append(sub_item)
self.appendRow(row)
self.setCheckable(True)
if fieldDef['fieldEnabled']:
self.setCheckState(Qt.Checked)
else:
self.setCheckState(Qt.Unchecked)
else:
fieldDef['fieldType'] = self.getODKType(fieldDef)
if fieldDef['fieldType'] in appearanceDef.keys():
fieldDef['fieldAppearance'] = appearanceDef[
fieldDef['fieldType']][0]
else:
fieldDef['fieldAppearance'] = 'default'
for fdef in self.defOrder:
if fdef == 'fieldName':
sub_item = QStandardItem(None)
elif fdef == 'fieldRequired':
sub_item = QStandardItem(None)
sub_item.setCheckable(True)
if fieldDef['fieldRequired']:
sub_item.setCheckState(Qt.Checked)
else:
sub_item.setCheckState(Qt.Unchecked)
elif fdef == 'fieldChoices':
sub_item = QStandardItem(json.dumps(fieldDef[fdef]))
else:
sub_item = QStandardItem(fieldDef[fdef] or '')
sub_item.setDropEnabled(False)
sub_item.setDragEnabled(False)
row.append(sub_item)
self.appendRow(row)
self.setCheckable(True)
if fieldDef['fieldEnabled']:
self.setCheckState(Qt.Checked)
else:
self.setCheckState(Qt.Unchecked)
def scan(self):
#self.treeViewComputer.setEnabled(False)
#self.fileTypesButton.setEnabled(False)
self.files_found = {}
self.category_number_length = {}
self.threads = []
self.stop = False
if not self.selected_file_types:
dialog = FileTypes()
dialog.setModal(True)
self.selected_file_types, ok = dialog.call()
if not ok:
return
files_found_dialog = FilesFound(self)
files_found_dialog.setModal(True)
files_found_dialog.show()
header_counter = 0
for element in self.selected_file_types:
selected = []
for _type, state in element["Types"].items():
if state == Qt.Checked:
selected.append(_type)
if selected:
cat = QStandardItem(
element.keys()[0]) # WARNING! it may be unordered
self.files_found_model.setHorizontalHeaderItem(
header_counter, cat)
self.category_number_length.update(
{element.keys()[0]: [header_counter, 0]})
self.files_found_tree.setColumnWidth(header_counter - 1, 200)
header_counter += 1
for index, state in self.model_computer.checks.items():
self.files_found.update({element.keys()[0]: []})
print("start tread for %s" % element.keys()[0])
th = Thread(target=self.model_computer.exportChecked,
args=(self, {
index: state
}, element.keys()[0], selected,
self.files_found))
th.start()
self.threads.append(th)
status = map(Thread.isAlive, self.threads)
start_time = int(time.time())
while any(status):
qApp.processEvents()
status = map(Thread.isAlive, self.threads)
self.filesFoundLabel.setText("Scanning...")
if (int(time.time()) - start_time) % 2 == 0:
if self.files_found:
self.lock.acquire()
for cat, (num,
length) in self.category_number_length.items():
files = self.files_found[cat]
for i in range(length, len(files)):
fileItem = QStandardItem(
self.files_found[cat][i].split(sep)[-1])
fileItem.setCheckable(True)
fileItem.setCheckState(2)
fileItem.setToolTip(self.files_found[cat][i])
self.files_found_model.invisibleRootItem(
).setChild(i, num, fileItem)
self.category_number_length[cat][1] = len(files)
self.lock.release()
if self.stop:
self.filesFoundLabel.setText("Scanning was stopped by user")
self.files_found = {}
self.threads = []
else:
for cat, (num, length) in self.category_number_length.items():
if self.files_found:
files = self.files_found[cat]
for i in range(length, len(files)):
fileItem = QStandardItem(
self.files_found[cat][i].split(sep)[-1])
fileItem.setCheckable(True)
fileItem.setCheckState(2)
fileItem.setToolTip(self.files_found[cat][i])
self.files_found_model.invisibleRootItem().setChild(
i, num, fileItem)
self.category_number_length[cat][1] = len(files)
self.filesFoundLabel.setText(
"Scanning finished! Files found %s. Click on the Storage tab" %
sum(len(v) for k, v in self.files_found.items()))
self.files_found_bar.setMaximum(1)
self.files_found_bar.setValue(1)
self.files_found_ok_enable.setEnabled(True)
def __setitem__(self, key, value):
item = QStandardItem(key)
#item.setCheckState(Qt.Checked)
item.setCheckable(True)
self.app_list.model.appendRow(item)
self.actionDict[key] = value
def new_ui_item(self, key):
ui_item = QStandardItem(key)
ui_item.setCheckable(True)
self.ui_widget.model.appendRow(ui_item)
return ui_item
