def populate_well_listWidget(self):
survey_file = CONF.survey_dir / '.survey'
if survey_file.exists():
for name in get_data_files(CONF.well_dir):
new_item = QListWidgetItem(name, self.wells_listWidget)
new_item.setFlags(new_item.flags() | Qt.ItemIsUserCheckable)
new_item.setCheckState(Qt.Unchecked)
def refreshAnnotations(self):
for annotation in self.getAnnotations():
if annotation not in self.annotations:
self.annotations.append(annotation)
self.annotationsName.append('Annotation')
i = 0
to_del = []
for annotation in self.annotations:
if annotation not in self.getAnnotations():
to_del.append(i)
i += 1
i = 0
for index in to_del:
self.annotations.pop(index)
self.annotationsName.pop(index)
self.annotationList.clearSelection()
self.annotationList.clear()
# argh
for annotation in self.annotations:
item = QListWidgetItem(self.annotationsName[i])
if annotation.isVisible():
item.setCheckState(Qt.Checked)
else:
item.setCheckState(Qt.Unchecked)
item.setFlags(item.flags() | Qt.ItemIsEditable)
self.annotationList.addItem(item)
i += 1
def load_data_list(self):
folder_path = Path(CONF.data_root) / \
CONF.current_survey / "Seismics"
for name in get_data_files(folder_path):
new_item = QListWidgetItem(name, self.data_list_Widget)
new_item.setFlags(new_item.flags() | Qt.ItemIsUserCheckable)
new_item.setCheckState(Qt.Unchecked)
def __init__(self, rawImageLayer, objectImageLayer, featureTableNames, imagePerObject=True, \
imagePerTime = True, parent=None):
QDialog.__init__(self, parent)
self.setWindowTitle("Export to Knime")
ui_class, widget_class = uic.loadUiType(
os.path.split(__file__)[0] + "/exportToKnimeDialog.ui")
self.ui = ui_class()
self.ui.setupUi(self)
itemRaw = QListWidgetItem(rawImageLayer.name)
self.ui.rawList.addItem(itemRaw)
itemObjects = QListWidgetItem(objectImageLayer.name)
self.ui.objectList.addItem(itemObjects)
self.imagePerObject = imagePerObject
self.imagePerTime = imagePerTime
#FIXME: assume for now tht the feature table is a dict
try:
for plugin, feature_dict in featureTableNames.iteritems():
print plugin
for feature_name in feature_dict.keys():
print "adding feature:", feature_name
item = QListWidgetItem(feature_name)
item.setFlags(item.flags() | Qt.ItemIsUserCheckable)
item.setCheckState(Qt.Unchecked)
self.ui.featureList.addItem(item)
except:
print "hahaha, doesn't work!"
def __init__(self, rawImageLayer, objectImageLayer, featureTableNames, imagePerObject=True, \
imagePerTime = True, parent=None):
QDialog.__init__(self, parent)
self.setWindowTitle("Export to Knime")
ui_class, widget_class = uic.loadUiType(os.path.split(__file__)[0] + "/exportToKnimeDialog.ui")
self.ui = ui_class()
self.ui.setupUi(self)
itemRaw = QListWidgetItem(rawImageLayer.name)
self.ui.rawList.addItem(itemRaw)
itemObjects = QListWidgetItem(objectImageLayer.name)
self.ui.objectList.addItem(itemObjects)
self.imagePerObject = imagePerObject
self.imagePerTime = imagePerTime
#FIXME: assume for now tht the feature table is a dict
try:
for plugin, feature_dict in featureTableNames.iteritems():
print plugin
for feature_name in feature_dict.keys():
print "adding feature:", feature_name
item = QListWidgetItem(feature_name)
item.setFlags(item.flags() | Qt.ItemIsUserCheckable)
item.setCheckState(Qt.Unchecked)
self.ui.featureList.addItem(item)
except:
print "hahaha, doesn't work!"
def refreshPeers(self):
self.ui.peerList.clear()
for peer in self.communicator.peers:
peer = self.communicator.peers[peer]
peerName = QListWidgetItem(self.ui.peerList)
peerName.peer = peer
nameFont = QtGui.QFont()
nameFont.setPointSize(14)
peerDetails = QListWidgetItem(self.ui.peerList)
peerDetails.peer = peer
detailsFont = QtGui.QFont()
detailsFont.setPointSize(10)
name = peer.name
details = ""
if peer.publicKey is None:
details += "Unpaired, "
else:
details += "Paired, "
if peer.lastKnownIP is None:
details += "unavailable"
else:
details += "available: " + peer.lastKnownIP
peerName.setFont(nameFont)
peerName.setText(name)
peerDetails.setFont(detailsFont)
peerDetails.setText(details)
self.ui.peerList.addItem(peerName)
self.ui.peerList.addItem(peerDetails)
separatorItem = QListWidgetItem(self.ui.peerList)
separatorItem.guid = peer.guid
separatorItem.peer = None
separatorItem.setFlags(QtCore.Qt.NoItemFlags)
self.ui.peerList.addItem(separatorItem)
def writeModeData(self,data):
item = QListWidgetItem()
item.setText(data)
item.setSizeHint(QSize(27,27))
item.setFlags(Qt.ItemIsEnabled | Qt.ItemIsEditable | Qt.ItemIsSelectable)
self.insertItem(self.count()+1,item)
self.scrollToBottom()
def update(self, subject):
action, key = subject
if action == "add":
movie = self._moviemodel.data()[-1]
item = QListWidgetItem(movie.to_string())
item.setFlags(item.flags() | QtCore.Qt.ItemIsEditable)
self.addItem(item)
self.item_to_movie[item] = movie
self.movie_to_item[movie] = item
if action == "remove":
item = self.movie_to_item[key]
self.takeItem(self.row(item))
self.item_to_movie.pop(item)
self.movie_to_item.pop(key)
if action == "update":
item = self.movie_to_item[key]
item.setText(key.to_string())
if key.has_been_saved():
if key.has_changed():
key.set_saved(False)
self.apply_item_style(key, item)
if item in self.selectedItems():
self.emit(QtCore.SIGNAL("currentItemChanged(QListWidgetItem *,QListWidgetItem *)"), item, item)
if action == "clear":
item = self.movie_to_item[key]
item.setText(key.get_title())
key.set_modified(False)
key.set_saved(False)
self.apply_item_style(key, item)
def initializePage(self):
super(InterfacePage, self).initializePage()
exsits = []
for key in app.g_configurations.interfaces:
if app.g_configurations.interfaces[key]:
exsits.append(key)
for interface in app.g_configurations.config['interfaces']:
litem = QListWidgetItem(interface['name'])
litem.setToolTip(interface['description'])
litem.setFlags(Qt.ItemIsUserCheckable | Qt.ItemIsEnabled)
if app.g_configurations.initialized:
if interface['name'] in exsits:
litem.setCheckState(Qt.Checked)
else:
litem.setCheckState(Qt.Unchecked)
else:
isdefault = False
if app.g_configurations.component_type == "window":
if interface['default'] & 2:
isdefault = True
else:
if interface['default'] & 1:
isdefault = True
if isdefault:
litem.setCheckState(Qt.Checked)
else:
litem.setCheckState(Qt.Unchecked)
self.lw_interface.addItem(litem)
def initializePage(self):
super(InterfacePage, self).initializePage()
exsits = []
for key in app.g_configurations.interfaces:
if app.g_configurations.interfaces[key]:
exsits.append(key)
for interface in app.g_configurations.config['interfaces']:
litem = QListWidgetItem(interface['name'])
litem.setToolTip(interface['description'])
litem.setFlags(Qt.ItemIsUserCheckable | Qt.ItemIsEnabled)
if app.g_configurations.initialized:
if interface['name'] in exsits:
litem.setCheckState(Qt.Checked)
else:
litem.setCheckState(Qt.Unchecked)
else:
isdefault = False
if app.g_configurations.component_type == "window":
if interface['default'] & 2:
isdefault = True
else:
if interface['default'] & 1:
isdefault = True
if isdefault:
litem.setCheckState(Qt.Checked)
else:
litem.setCheckState(Qt.Unchecked)
self.lw_interface.addItem(litem)
def populate_field_list(self, excluded_fields=None):
"""Helper to add field of the layer to the list.
:param excluded_fields: List of field that want to be excluded.
:type excluded_fields: list
"""
# Populate fields list
if excluded_fields is None:
excluded_fields = []
self.field_list.clear()
for field in self.layer.dataProvider().fields():
# Skip if it's excluded
if field.name() in excluded_fields:
continue
# Skip if it's not number (float, int, etc)
if field.type() not in qvariant_numbers:
continue
field_item = QListWidgetItem(self.field_list)
field_item.setFlags(
Qt.ItemIsEnabled |
Qt.ItemIsSelectable |
Qt.ItemIsDragEnabled)
field_item.setData(Qt.UserRole, field.name())
field_item.setText(field.name())
self.field_list.addItem(field_item)
def update(self, subject):
action, key = subject
if action == "add":
movie = self._moviemodel.data()[-1]
item = QListWidgetItem(movie.to_string())
item.setFlags(item.flags() | QtCore.Qt.ItemIsEditable)
self.addItem(item)
self.item_to_movie[item] = movie
self.movie_to_item[movie] = item
if action == "remove":
item = self.movie_to_item[key]
self.takeItem(self.row(item))
self.item_to_movie.pop(item)
self.movie_to_item.pop(key)
if action == "update":
item = self.movie_to_item[key]
item.setText(key.to_string())
if key.has_been_saved():
if key.has_changed():
key.set_saved(False)
self.apply_item_style(key, item)
if item in self.selectedItems():
self.emit(QtCore.SIGNAL(\
"currentItemChanged(QListWidgetItem *,QListWidgetItem *)"),
item, item)
if action == "clear":
item = self.movie_to_item[key]
item.setText(key.get_title())
key.set_modified(False)
key.set_saved(False)
self.apply_item_style(key, item)
def __init__(self, mainwin, pdfs):
KDialog.__init__(self, mainwin)
self.mainwin = mainwin
self.setAttribute(Qt.WA_DeleteOnClose)
self.setButtons(KDialog.ButtonCode(
KDialog.User1 | KDialog.Ok | KDialog.Cancel))
self.setButtonGuiItem(KDialog.Ok, KStandardGuiItem.print_())
self.setButtonIcon(KDialog.User1, KIcon("edit-select-all"))
self.setButtonText(KDialog.User1, i18n("Select all"))
self.setCaption(i18n("Print documents"))
b = KVBox(self)
b.setSpacing(4)
QLabel(i18n("Please select the files you want to print:"), b)
fileList = QListWidget(b)
fileList.setIconSize(QSize(22, 22))
fileList.setWhatsThis(i18n(
"These are the PDF documents that are up-to-date (i.e. newer than "
"the LilyPond source document). "
"Check the documents you want to send to the printer."))
for pdf in pdfs:
i = QListWidgetItem(KIcon("application-pdf"), os.path.basename(pdf),
fileList)
i.setFlags(Qt.ItemIsEnabled | Qt.ItemIsSelectable |
Qt.ItemIsUserCheckable)
i.setCheckState(Qt.Unchecked)
fileList.item(0).setCheckState(Qt.Checked)
self.fileList = fileList
self.setMainWidget(b)
self.resize(350, 200)
self.pdfs = pdfs
self.user1Clicked.connect(self.selectAll)
def writeModeData(self,data):
item = QListWidgetItem()
item.setText(data)
item.setSizeHint(QSize(27,27))
item.setFlags(Qt.ItemIsEnabled | Qt.ItemIsEditable | Qt.ItemIsSelectable)
self.insertItem(self.count()+1,item)
self.scrollToBottom()
def set_widgets(self):
"""Set widgets on the Field tab."""
self.clear_further_steps()
purpose = self.parent.step_kw_purpose.selected_purpose()
subcategory = self.parent.step_kw_subcategory.selected_subcategory()
unit = self.parent.step_kw_unit.selected_unit()
if purpose == layer_purpose_aggregation:
question_text = field_question_aggregation
elif self.parent.step_kw_layermode.\
selected_layermode() == layer_mode_continuous and unit:
subcategory_unit_relation = get_question_text(
'%s_%s_question' % (subcategory['key'], unit['key']))
if 'MISSING' in subcategory_unit_relation:
subcategory_unit_relation = self.tr(
'{subcategory} in {unit} unit').format(
subcategory=subcategory['name'].lower(),
unit=unit['plural_name'])
question_text = field_question_subcategory_unit % (
purpose['name'],
subcategory['name'],
unit['name'],
subcategory_unit_relation)
else:
question_text = field_question_subcategory_classified % (
subcategory['name'])
self.lblSelectField.setText(question_text)
self.lstFields.clear()
default_item = None
for field in self.parent.layer.dataProvider().fields():
field_name = field.name()
item = QListWidgetItem(field_name, self.lstFields)
item.setData(QtCore.Qt.UserRole, field_name)
# Select the item if it match the unit's default_attribute
if unit and 'default_attribute' in unit \
and field_name == unit['default_attribute']:
default_item = item
# For continuous data, gray out id, gid, fid and text fields
if self.parent.step_kw_layermode.\
selected_layermode() == layer_mode_continuous and unit:
field_type = field.type()
if field_type > 9 or re.match(
'.{0,2}id$', field_name, re.I):
item.setFlags(item.flags() & ~QtCore.Qt.ItemIsEnabled)
if default_item:
self.lstFields.setCurrentItem(default_item)
self.lblDescribeField.clear()
# Set values based on existing keywords (if already assigned)
field_keyword = self.parent.field_keyword_for_the_layer()
inasafe_field = self.parent.get_existing_keyword('inasafe_fields')
if inasafe_field:
field = inasafe_field.get(field_keyword)
if field:
fields = []
for index in xrange(self.lstFields.count()):
fields.append(str(self.lstFields.item(index).text()))
if field in fields:
self.lstFields.setCurrentRow(fields.index(field))
self.auto_select_one_item(self.lstFields)
def load_data_list(self):
for name in get_data_files(
Path(CONF.data_root, CONF.current_survey, "Seismics")):
# only initialize this way can it be set checkable
new_item = QListWidgetItem(name,
self.control_widget.data_listWidget)
new_item.setFlags(new_item.flags() | Qt.ItemIsUserCheckable)
new_item.setCheckState(Qt.Unchecked)
def reload_key_list(self):
while self.key_list.count() > 0:
self.key_list.takeItem(0)
for key in sorted(self._keys.keys()):
item = QListWidgetItem(unicode(key))
item.setFlags(Qt.ItemIsEnabled | Qt.ItemIsEditable)
item.setData(Qt.UserRole, unicode(key))
self.key_list.addItem(item)
def update_well_listWidget(self):
survey_file = CONF.survey_dir / '.survey'
if survey_file.exists():
dnames = get_data_files(CONF.well_dir)
# self.well_listWidget.addItems(dnames)
for name in dnames:
new_item = QListWidgetItem(name, self.well_listWidget)
new_item.setFlags(new_item.flags() | Qt.ItemIsUserCheckable)
new_item.setCheckState(Qt.Unchecked)
def provide(self, search):
if search.startswith('define ') and search != 'define ':
item = QListWidgetItem(
subprocess.check_output('dict {}; exit 0'.format(search[7:]),
stderr=subprocess.STDOUT, shell=True))
item.setFlags(item.flags() & ~Qt.ItemIsSelectable)
yield item
yield True
yield False
def update_list(self):
"""Update path list"""
self.listwidget.clear()
for name in self.pathlist + self.ro_pathlist:
item = QListWidgetItem(name)
item.setIcon(get_std_icon('DirClosedIcon'))
if name in self.ro_pathlist:
item.setFlags(Qt.NoItemFlags)
self.listwidget.addItem(item)
self.refresh()
def getNewCompo(self, w, cView):
"""Function that finds new composer to be added to the list."""
nameCompo = cView.composerWindow().windowTitle()
if not w.findItems(nameCompo, Qt.MatchExactly):
item = QListWidgetItem()
item.setFlags(item.flags() | Qt.ItemIsUserCheckable)
item.setCheckState(Qt.Unchecked)
item.setText(nameCompo)
w.addItem(item)
def populate_log_listWidget(self):
self.logs_listWidget.clear()
well = ppp.Well(
str(CONF.well_dir /
".{}".format(self.well_comboBox.currentText())))
# self.logs_listWidget.addItems(well.logs)
for name in well.logs:
new_item = QListWidgetItem(name, self.logs_listWidget)
new_item.setFlags(new_item.flags() | Qt.ItemIsUserCheckable)
new_item.setCheckState(Qt.Unchecked)
def item(icon, fileName):
""" Add item to the fileList list widget. """
directory, name = os.path.split(fileName)
if directory != basedir:
name += " ({0})".format(os.path.normpath(directory))
i = QListWidgetItem(KIcon(icon), name, fileList)
i.setFlags(Qt.ItemIsEnabled | Qt.ItemIsSelectable | Qt.ItemIsUserCheckable)
i.ext = os.path.splitext(fileName)[1]
i.url = KUrl.fromPath(fileName).url()
i.setCheckState(Qt.Checked if i.ext in exts else Qt.Unchecked)
def update_list(self):
"""Update path list"""
self.listwidget.clear()
for name in self.pathlist+self.ro_pathlist:
item = QListWidgetItem(name)
item.setIcon(get_std_icon('DirClosedIcon'))
if name in self.ro_pathlist:
item.setFlags(Qt.NoItemFlags)
self.listwidget.addItem(item)
self.refresh()
def handleItemChecked(self):
well_names = []
for idx in range(self.well_listWidget.count()):
item = self.well_listWidget.item(idx)
if item.checkState() == Qt.Checked:
well_names.append(item.text())
# first well
if well_names:
vlog_list = []
obp_log_list = []
nct_list = []
n_list = []
first_well = ppp.Well(str(CONF.well_dir / ".{}".format(well_names[0])))
for log in first_well.logs:
if "Velocity" in log:
vlog_list.append(log)
if "Overburden" in log:
obp_log_list.append(log)
# for key in first_well.params.keys():
# if "nct" in key:
# nct_list.append(key)
# if "eaton" in key:
# n_list.append(key)
pres_list = ["DST", "MDT", "EMW", "loading", "unloading", "MP"]
for w_name in well_names:
well = ppp.Well(str(CONF.well_dir / ".{}".format(w_name)))
for log in vlog_list:
if log not in well.logs:
vlog_list.remove(log)
for log in obp_log_list:
if log not in well.logs:
obp_log_list.remove(log)
key_to_remove = []
for key in pres_list:
if key not in well.params.keys():
key_to_remove.append(key)
for key in key_to_remove:
pres_list.remove(key)
self.velocity_comboBox.clear()
self.velocity_comboBox.addItems(vlog_list)
self.obp_comboBox.clear()
self.obp_comboBox.addItems(obp_log_list)
# self.nct_comboBox.clear()
# self.nct_comboBox.addItems(nct_list)
# self.n_comboBox.clear()
# self.n_comboBox.addItems(n_list)
self.pres_listWidget.clear()
for name in pres_list:
new_item = QListWidgetItem(name, self.pres_listWidget)
new_item.setFlags(new_item.flags() | Qt.ItemIsUserCheckable)
new_item.setCheckState(Qt.Unchecked)
else:
self.pres_listWidget.clear()
def refresh_list(self):
self._input.clear()
if not self._parameter.ordering == InputListParameter.NotOrdered:
self._value_cache.sort()
if self._parameter.ordering == InputListParameter.DescendingOrder:
self._value_cache.reverse()
for opt in self._value_cache:
item = QListWidgetItem()
item.setText(str(opt))
item.setFlags(item.flags() | Qt.ItemIsEditable)
self._input.addItem(item)
def on_pf_add_start_byte_clicked(self):
(text, ok) = QInputDialog.getText(\
self,
self.trUtf8("Start byte"),
self.trUtf8("Insert start byte in hex form:"),
QLineEdit.Normal,
self.trUtf8("0x00"))
if ok and text: # TODO: check hex form with regexp
item = QListWidgetItem(str(text))
item.setFlags(item.flags() | Qt.ItemIsEditable)
self.pf_start_bytes.addItem(item)
def on_domainListWidget_currentRowChanged(self, idx):
curItem = self.domainListWidget.item(idx)
self.filterListWidget.clear()
if curItem:
self.domainName = curItem.data(0)
self.domainDict = self.abstractDb.getDomainDictV2('dominios.'+self.domainName)
for codeName in self.domainDict.keys():
newItem = QListWidgetItem(codeName)
newItem.setFlags(QtCore.Qt.ItemIsEnabled | QtCore.Qt.ItemIsTristate | QtCore.Qt.ItemIsUserCheckable)
newItem.setCheckState(QtCore.Qt.Unchecked)
self.filterListWidget.addItem(newItem)
def _load_labels(self):
self.LabelsListWidget.clear()
if self.selected_provider:
labels = self.selected_provider.get_labels()
for label in labels:
icon = utils.colored_icon(label['color'])
item = QListWidgetItem(icon, label['name'], self.LabelsListWidget)
item.setFlags(item.flags() | Qt.ItemIsUserCheckable)
item.setCheckState(Qt.Unchecked)
self.LabelsListWidget.addItem(item)
self.LabelsListWidget.sortItems()
def refresh_list(self):
self._input.clear()
if not self._parameter.ordering == InputListParameter.NotOrdered:
self._value_cache.sort()
if self._parameter.ordering == InputListParameter.DescendingOrder:
self._value_cache.reverse()
for opt in self._value_cache:
item = QListWidgetItem()
item.setText(str(opt))
item.setFlags(item.flags() | Qt.ItemIsEditable)
self._input.addItem(item)
def insertCheckableItem(self, index, label, state, isBonus=False):
"""
Fügt einen Eintrag an der angegebenen Indexposition ein.
"""
item = QListWidgetItem()
item.setText(label)
item.setCheckState(state)
if isBonus:
item.setData(Qt.ForegroundRole, QColor(Config.COLOR_BONUS))
item.setFlags(item.flags() & Qt.ItemIsUserCheckable)
self.insertItem(index, item)
def __init__(self, parameter, parent=None):
"""Constructor
.. versionadded:: 2.2
:param parameter: A ListParameter object.
:type parameter: ListParameter
"""
super(ListParameterWidget, self).__init__(parameter, parent)
self._input = QListWidget()
self._input.setSelectionMode(QAbstractItemView.MultiSelection)
if self._parameter.maximum_item_count != \
self._parameter.minimum_item_count:
tool_tip = 'Select between %d and %d items' % (
self._parameter.minimum_item_count,
self._parameter.maximum_item_count)
else:
tool_tip = 'Select exactly %d items' % (
self._parameter.maximum_item_count)
self._input.setToolTip(tool_tip)
for opt in self._parameter.options_list:
item = QListWidgetItem()
item.setFlags(item.flags() | Qt.ItemIsEditable)
item.setText(str(opt))
self._input.addItem(item)
if opt in self._parameter.value:
item.setSelected(True)
self.inner_input_layout.addWidget(self._input)
# override self._input_layout arrangement to make the label at the top
# reset the layout
self.input_layout.setParent(None)
self.help_layout.setParent(None)
self.label.setParent(None)
self.inner_input_layout.setParent(None)
self.input_layout = QVBoxLayout()
self.input_layout.setSpacing(0)
# put element into layout
self.input_layout.addWidget(self.label)
self.input_layout.addLayout(self.inner_input_layout)
self.main_layout.addLayout(self.input_layout)
self.main_layout.addLayout(self.help_layout)
def populate_classified_values(self, unassigned_values, assigned_values,
default_classes):
"""Populate lstUniqueValues and treeClasses.from the parameters.
:param unassigned_values: List of values that haven't been assigned
to a class. It will be put in self.lstUniqueValues.
:type unassigned_values: list
:param assigned_values: Dictionary with class as the key and list of
value as the value of the dictionary. It will be put in
self.treeClasses.
:type assigned_values: dict
:param default_classes: Default classes from unit.
:type default_classes: list
"""
# Populate the unique values list
self.lstUniqueValues.clear()
self.lstUniqueValues.setSelectionMode(
QAbstractItemView.ExtendedSelection)
for value in unassigned_values:
value_as_string = value is not None and unicode(value) or 'NULL'
list_item = QListWidgetItem(self.lstUniqueValues)
list_item.setFlags(Qt.ItemIsEnabled | Qt.ItemIsSelectable
| Qt.ItemIsDragEnabled)
list_item.setData(Qt.UserRole, value)
list_item.setText(value_as_string)
self.lstUniqueValues.addItem(list_item)
# Populate assigned values tree
self.treeClasses.clear()
self.treeClasses.invisibleRootItem().setFlags(Qt.ItemIsEnabled)
for default_class in default_classes:
# Create branch for class
tree_branch = QTreeWidgetItem(self.treeClasses)
tree_branch.setFlags(Qt.ItemIsDropEnabled | Qt.ItemIsEnabled)
tree_branch.setExpanded(True)
tree_branch.setFont(0, bold_font)
if 'name' in default_class:
default_class_name = default_class['name']
else:
default_class_name = default_class['key']
tree_branch.setText(0, default_class_name)
tree_branch.setData(0, Qt.UserRole, default_class['key'])
if 'description' in default_class:
tree_branch.setToolTip(0, default_class['description'])
# Assign known values
for value in assigned_values[default_class['key']]:
string_value = value is not None and unicode(value) or 'NULL'
tree_leaf = QTreeWidgetItem(tree_branch)
tree_leaf.setFlags(Qt.ItemIsEnabled | Qt.ItemIsSelectable
| Qt.ItemIsDragEnabled)
tree_leaf.setData(0, Qt.UserRole, value)
tree_leaf.setText(0, string_value)
def __init__(self, parameter, parent=None):
"""Constructor
.. versionadded:: 2.2
:param parameter: A ListParameter object.
:type parameter: ListParameter
"""
super(ListParameterWidget, self).__init__(parameter, parent)
self._input = QListWidget()
self._input.setSelectionMode(QAbstractItemView.MultiSelection)
if self._parameter.maximum_item_count != \
self._parameter.minimum_item_count:
tool_tip = 'Select between %d and %d items' % (
self._parameter.minimum_item_count,
self._parameter.maximum_item_count)
else:
tool_tip = 'Select exactly %d items' % (
self._parameter.maximum_item_count)
self._input.setToolTip(tool_tip)
for opt in self._parameter.options_list:
item = QListWidgetItem()
item.setFlags(item.flags() | Qt.ItemIsEditable)
item.setText(str(opt))
self._input.addItem(item)
if opt in self._parameter.value:
item.setSelected(True)
self._inner_input_layout.addWidget(self._input)
# override self._input_layout arrangement to make the label at the top
# reset the layout
self._input_layout.setParent(None)
self._help_layout.setParent(None)
self._label.setParent(None)
self._inner_input_layout.setParent(None)
self._input_layout = QVBoxLayout()
self._input_layout.setSpacing(0)
# put element into layout
self._input_layout.addWidget(self._label)
self._input_layout.addLayout(self._inner_input_layout)
self._main_layout.addLayout(self._input_layout)
self._main_layout.addLayout(self._help_layout)
def set_widgets(self):
"""Set widgets on the Field tab."""
self.clear_further_steps()
purpose = self.parent.step_kw_purpose.selected_purpose()
subcategory = self.parent.step_kw_subcategory.selected_subcategory()
unit = self.parent.step_kw_unit.selected_unit()
if purpose == layer_purpose_aggregation:
question_text = field_question_aggregation
elif self.parent.step_kw_layermode.\
selected_layermode() == layer_mode_continuous and unit:
# unique values, continuous or categorical data
subcategory_unit_relation = get_question_text(
'%s_%s_question' % (subcategory['key'], unit['key']))
question_text = field_question_subcategory_unit % (
purpose['name'],
subcategory['name'],
unit['name'],
subcategory_unit_relation)
else:
question_text = field_question_subcategory_classified % (
subcategory['name'])
self.lblSelectField.setText(question_text)
self.lstFields.clear()
default_item = None
for field in self.parent.layer.dataProvider().fields():
field_name = field.name()
item = QListWidgetItem(field_name, self.lstFields)
item.setData(QtCore.Qt.UserRole, field_name)
# Select the item if it match the unit's default_attribute
if unit and 'default_attribute' in unit \
and field_name == unit['default_attribute']:
default_item = item
# For continuous data, gray out id, gid, fid and text fields
if self.parent.step_kw_layermode.\
selected_layermode() == layer_mode_continuous and unit:
field_type = field.type()
if field_type > 9 or re.match(
'.{0,2}id$', field_name, re.I):
item.setFlags(item.flags() & ~QtCore.Qt.ItemIsEnabled)
if default_item:
self.lstFields.setCurrentItem(default_item)
self.lblDescribeField.clear()
# Set values based on existing keywords (if already assigned)
field_keyword = self.parent.field_keyword_for_the_layer()
field = self.parent.get_existing_keyword(field_keyword)
if field:
fields = []
for index in xrange(self.lstFields.count()):
fields.append(str(self.lstFields.item(index).text()))
if field in fields:
self.lstFields.setCurrentRow(fields.index(field))
self.auto_select_one_item(self.lstFields)
def update_horizon_listWidget(self):
self.horizon_listWidget.clear()
well_name = self.well_comboBox.currentText()
well = ppp.Well(str(CONF.well_dir / ".{}".format(well_name)))
try:
horizons = well.params['horizon'].keys()
for name in horizons:
new_item = QListWidgetItem(name, self.horizon_listWidget)
new_item.setFlags(new_item.flags() | Qt.ItemIsUserCheckable)
new_item.setCheckState(Qt.Unchecked)
except KeyError as e:
print(e.message)
def showAttr(self):
self.dlg.attributeList.clear()
current = self.dlg.fileListWidget.currentItem()
attributes = current.attributes
for attr in attributes:
item = QListWidgetItem(attr[0], self.dlg.attributeList)
item.setFlags(item.flags() & ~Qt.ItemIsSelectable)
if attr[1] == 0:
item.setCheckState(Qt.Unchecked)
else:
item.setCheckState(Qt.Checked)
self.dlg.attributeList.addItem(item)
def addEntry(self):
item = QListWidgetItem(tr("New category"))
item.setFlags(Qt.ItemIsEditable | Qt.ItemIsEnabled | Qt.ItemIsSelectable)
self.window.categories_list.addItem(item)
name = ""
i = 0
while name == "" or name in self.categories_order:
name = "category%i" % i
i += 1
self.categories_order.append(name)
self.categories[name] = tr("New category")
def moveDown(self):
item = self.window.categories_list.currentItem()
row = self.window.categories_list.currentRow()
name = self.categories_order[row]
if row < len(self.categories_order) - 1:
self.window.categories_list.model().removeRow(row)
item = QListWidgetItem(self.categories[name])
item.setFlags(Qt.ItemIsEditable | Qt.ItemIsEnabled | Qt.ItemIsSelectable)
self.window.categories_list.insertItem(row + 1, item)
self.categories_order.remove(name)
self.categories_order.insert(row + 1, name)
self.window.categories_list.setCurrentRow(row + 1)
def add_page(self, widget):
self.connect(self, SIGNAL('check_settings()'), widget.check_settings)
self.connect(widget, SIGNAL('show_this_page()'),
lambda row=self.contents_widget.count():
self.contents_widget.setCurrentRow(row))
self.connect(widget, SIGNAL("apply_button_enabled(bool)"),
self.apply_btn.setEnabled)
self.pages_widget.addWidget(widget)
item = QListWidgetItem(self.contents_widget)
item.setIcon(widget.get_icon())
item.setText(widget.get_name())
item.setFlags(Qt.ItemIsSelectable|Qt.ItemIsEnabled)
item.setSizeHint(QSize(0, 25))
def create_plugin_view(self, showAll = True):
for p_name, p_info in self.p_info.iteritems():
item = QListWidgetItem(p_info["name"], self.ui.pluginView)
item.setToolTip(p_name)
item.setCheckState(Qt.Checked if p_info["activated"] else Qt.Unchecked)
if p_info["forced"]:
item.setForeground(Qt.gray)
flags = item.flags()
flags &= ~Qt.ItemIsUserCheckable
item.setFlags(flags)
item.setHidden(not showAll and p_info["forced"])
self.ui.pluginView.addItem(item)
def add_page(self, widget):
self.connect(self, SIGNAL('check_settings()'), widget.check_settings)
self.connect(widget,
SIGNAL('show_this_page()'),
lambda row=self.contents_widget.count(): self.
contents_widget.setCurrentRow(row))
self.connect(widget, SIGNAL("apply_button_enabled(bool)"),
self.apply_btn.setEnabled)
self.pages_widget.addWidget(widget)
item = QListWidgetItem(self.contents_widget)
item.setIcon(widget.get_icon())
item.setText(widget.get_name())
item.setFlags(Qt.ItemIsSelectable | Qt.ItemIsEnabled)
item.setSizeHint(QSize(0, 25))
def initList(self):
self.notebookList.clear()
notebooks = Mikibook.read()
for nb in notebooks:
item = QListWidgetItem()
item.setData(Qt.DisplayRole, nb[0])
item.setData(Qt.UserRole, nb[1])
lockPath = os.path.join(nb[1], '.mikidown_lock')
if os.path.exists(lockPath):
item.setFlags(Qt.NoItemFlags)
self.notebookList.addItem(item)
self.updateUi(len(notebooks) != 0)
self.notebookList.setCurrentRow(0)
def updateOrder(self):
self.listbox.clear()
self.macros = self.loadMacros()
cparser = PuddleConfig()
to_check = cparser.get('actions', 'checked', [])
for i, m in sorted(self.macros.items()):
func_name = m.name
item = QListWidgetItem(func_name)
item.setFlags(item.flags() | Qt.ItemIsEditable)
if func_name in to_check:
item.setCheckState(Qt.Checked)
else:
item.setCheckState(Qt.Unchecked)
self.listbox.addItem(item)
def initList(self):
self.notebookList.clear()
notebooks = Mikibook.read()
for nb in notebooks:
item = QListWidgetItem()
item.setData(Qt.DisplayRole, nb[0])
item.setData(Qt.UserRole, nb[1])
lockPath = os.path.join(nb[1], '.mikidown_lock')
if os.path.exists(lockPath):
item.setFlags(Qt.NoItemFlags)
self.notebookList.addItem(item)
self.updateUi(len(notebooks) != 0)
self.notebookList.setCurrentRow(0)
def add_item(self, text, edit_item=False, select_item=False):
item = QListWidgetItem(text)
item.setFlags(item.flags() | Qt.ItemIsEditable)
self.list_items.addItem(item)
if edit_item:
self.list_items.setCurrentItem(item)
self.list_items.setFocus()
self.list_items.editItem(item)
elif select_item:
self.list_items.setCurrentItem(item)
self.list_items.setFocus()
self.update_ui_state()
def __init__(self, name = None, attributes = [], selectedAttributes = []):
QListWidget.__init__(self)
self.menu = AttributeSelectorMenu(self)
self.setSelectionMode(QAbstractItemView.ExtendedSelection)
if name:
self.name = name
self.attributes = attributes
for attribute in self.attributes:
item = QListWidgetItem(attribute)
item.setFlags(Qt.ItemIsSelectable | Qt.ItemIsUserCheckable | Qt.ItemIsEnabled)
if attribute in selectedAttributes:
item.setCheckState(Qt.Checked)
else:
item.setCheckState(Qt.Unchecked)
self.addItem(item)
def createIcons(self):
vectorButton = QListWidgetItem(self.contentsWidget)
vectorButton.setIcon(QIcon(":custom-vector.svg"))
vectorButton.setText("Vector Layer")
vectorButton.setTextAlignment(Qt.AlignHCenter)
vectorButton.setFlags(Qt.ItemIsSelectable | Qt.ItemIsEnabled)
rasterButton = QListWidgetItem(self.contentsWidget)
rasterButton.setIcon(QIcon(":custom-raster.svg"))
rasterButton.setText("Raster Layer")
rasterButton.setTextAlignment(Qt.AlignHCenter)
rasterButton.setFlags(Qt.ItemIsSelectable | Qt.ItemIsEnabled)
self.connect(self.contentsWidget,
SIGNAL("currentItemChanged(QListWidgetItem*, QListWidgetItem*)"),
self.changePage)
def addListItem(self, component, title, valid=True, checked=True):
item = QListWidgetItem(title)
item.component = component
item.setFlags(item.flags() | Qt.ItemIsUserCheckable)
if valid:
pass
else:
item.setForeground(QColor('gray'))
if checked:
item.setCheckState(Qt.Checked)
else:
item.setCheckState(Qt.Unchecked)
self.components_list.addItem(item)
def loadComposers(self):
self.lstComposers.clear()
self.composers = {
c.composerWindow().windowTitle(): c
for c in self.iface.activeComposers()
}
if len(self.composers) > 0:
self.lstComposers.addItems(self.composers.keys())
self.lstComposers.sortItems()
else:
item = QListWidgetItem(self.tr("No composers found"))
item.setFlags(item.flags() ^ Qt.ItemIsEnabled)
self.lstComposers.addItem(item)
self.toggleButtons()
def add_new_item(self, name, project, is_new=False, is_valid=True):
item = QListWidgetItem(self.moduleList, QListWidgetItem.UserType)
item.setData(QListWidgetItem.UserType, project)
item.setSizeHint(QSize(150, 150))
if not is_valid:
item.setFlags(item.flags() & ~Qt.ItemIsEnabled)
projectwidget = ProjectWidget(self.moduleList, project, is_new=is_new)
projectwidget.install_project.connect(self.projectInstall.emit)
projectwidget.update_project.connect(self.projectUpdate.emit)
projectwidget.setEnabled(is_valid)
self.moduleList.addItem(item)
self.moduleList.setItemWidget(item, projectwidget)
self.projectitems[name] = item
def add_new_item(self, name, project, is_new=False, is_valid=True):
item = QListWidgetItem(self.moduleList, QListWidgetItem.UserType)
item.setData(QListWidgetItem.UserType, project)
item.setSizeHint(QSize(150, 150))
if not is_valid:
item.setFlags(item.flags() & ~Qt.ItemIsEnabled)
projectwidget = ProjectWidget(self.moduleList, project, is_new=is_new)
projectwidget.install_project.connect(self.projectInstall.emit)
projectwidget.update_project.connect(self.projectUpdate.emit)
projectwidget.setEnabled(is_valid)
self.moduleList.addItem(item)
self.moduleList.setItemWidget(item, projectwidget)
self.projectitems[name] = item
def update_pres_listWidget(self):
pres_list = ["DST", "MDT", "EMW", "loading", "unloading", "MP"]
well_name = self.well_comboBox.currentText()
well = ppp.Well(str(CONF.well_dir / ".{}".format(well_name)))
key_to_remove = []
for key in pres_list:
if key not in well.params.keys():
key_to_remove.append(key)
for key in key_to_remove:
pres_list.remove(key)
self.pres_listWidget.clear()
for name in pres_list:
new_item = QListWidgetItem(name, self.pres_listWidget)
new_item.setFlags(new_item.flags() | Qt.ItemIsUserCheckable)
new_item.setCheckState(Qt.Unchecked)
def modelChanged(self):
self._list.clear()
items = self._model.getList()
for item in items:
list_item = QListWidgetItem(item)
list_item.setFlags(list_item.flags() | Qt.ItemIsUserCheckable)
if self._model.isValueSelected(item):
list_item.setCheckState(Qt.Checked)
else:
list_item.setCheckState(Qt.Unchecked)
self._list.addItem(list_item)
self.filterList(self._search_box.filter())
def set_project_id(self, prjId = None):
self.sectionListWidget.clear()
if prjId is not None:
self.projectId = prjId
if self.projectId is None:
return
for s_id, section in self.data[prjId]['Sections'].items():
title = '{0}: de {1} a {2}'.format(section['Counter'], section['StartNode'], section['EndNode'])
item = QListWidgetItem(warning_icon, title)
item.setData(Qt.UserRole, s_id)
item.setFlags(Qt.ItemIsEnabled | Qt.ItemIsSelectable | Qt.ItemIsUserCheckable)
item.setCheckState(Qt.Checked if section['Import'] else Qt.Unchecked)
self.sectionListWidget.addItem(item)
self.update_status()
def addIcon(self, page="Main"):
button = QListWidgetItem()
if page == "Main":
button.setIcon(QIcon(":gconf-editor"))
button.setText("Main")
elif page == "Configure":
button.setIcon(QIcon(":preferences-system"))
button.setText("Configure")
elif page == "Plot Options":
button.setIcon(QIcon(":applications-graphics"))
button.setText("Plot Options")
else:
button.setIcon(QIcon(":applications-debugging"))
button.setText(page)
button.setTextAlignment(Qt.AlignHCenter)
button.setFlags(Qt.ItemIsSelectable | Qt.ItemIsEnabled)
self.contentsWidget.addItem(button)
def __addListItems(self): i = 0 for key in self.__statistics.keys(): name = self.sender().getProjectName(key) if name is None: name = key color = self.__colors[i] item = QListWidgetItem(name) item.setData(Qt.DecorationRole, QVariant(QColor(color))) item.setData(Qt.UserRole, QVariant(key)) item.setFlags(Qt.ItemIsSelectable|Qt.ItemIsUserCheckable|Qt.ItemIsEnabled) item.setCheckState(Qt.Checked) self.__projectsList.addItem(item) i = i + 1 if i >= len(self.__colors): i = 0
