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 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 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 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 __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 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, 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 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 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_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 load_instrument(self, instrument):
self.clear_instrument()
self.instrument = instrument
# base info
self.instrument_name.setText(self.instrument.name)
self.instrument_short_name.setText(self.instrument.short_name)
self.byte_order.setCurrentIndex(self.byte_order.findText(self.instrument.byte_order))
# connection
self.conn_type.setCurrentIndex(self.conn_type.findText(self.instrument.connection.type))
self.load_connection()
# packet format
for i, field in enumerate(self.instrument.packet_format.rx_format):
combo_box = getattr(self, 'pf_rx_format_{0}'.format(i))
combo_box.setCurrentIndex(combo_box.findText(field))
for i, field in enumerate(self.instrument.packet_format.tx_format):
combo_box = getattr(self, 'pf_tx_format_{0}'.format(i))
combo_box.setCurrentIndex(combo_box.findText(field))
for start_byte in self.instrument.packet_format.start_bytes:
item = QListWidgetItem(hex(start_byte))
item.setFlags(item.flags() | Qt.ItemIsEditable)
self.pf_start_bytes.addItem(item)
for end_byte in self.instrument.packet_format.end_bytes:
item = QListWidgetItem(hex(end_byte))
item.setFlags(item.flags() | Qt.ItemIsEditable)
self.pf_end_bytes.addItem(item)
# rx packets
for num in self.instrument.rx_packets:
self.rx_packets_list.addItem(str(num))
if self.rx_packets_list.count():
self.rx_packets_list.setCurrentItem(self.rx_packets_list.item(0))
# tx packets
for num in self.instrument.tx_packets:
self.tx_packets_list.addItem(str(num))
if self.tx_packets_list.count():
self.tx_packets_list.setCurrentItem(self.tx_packets_list.item(0))
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 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 initExtList(self):
extset=set(self.parent().settings.extensions)
#for easier performance in checking
for ext in self.parent().settings.extensions:
item = QListWidgetItem(ext, self.mdExts)
item.setFlags(item.flags() | Qt.ItemIsUserCheckable)
item.setCheckState(Qt.Checked)
for ext in self.parent().settings.faulty_exts:
item = QListWidgetItem(ext, self.mdExts)
item.setFlags(item.flags() | Qt.ItemIsUserCheckable)
item.setBackground(QBrush(QColor('red')))
item.setForeground(QBrush(QColor('black')))
item.setCheckState(Qt.Checked)
for ext in allMDExtensions():
if ext in extset: continue
item = QListWidgetItem(ext, self.mdExts)
item.setFlags(item.flags() | Qt.ItemIsUserCheckable)
item.setCheckState(Qt.Unchecked)
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 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 _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 initExtList(self):
extset = set(self.parent().settings.extensions)
#for easier performance in checking
for ext in self.parent().settings.extensions:
item = QListWidgetItem(ext, self.mdExts)
item.setFlags(item.flags() | Qt.ItemIsUserCheckable)
item.setCheckState(Qt.Checked)
for ext in self.parent().settings.faulty_exts:
item = QListWidgetItem(ext, self.mdExts)
item.setFlags(item.flags() | Qt.ItemIsUserCheckable)
item.setBackground(QBrush(QColor('red')))
item.setForeground(QBrush(QColor('black')))
item.setCheckState(Qt.Checked)
for ext in allMDExtensions():
if ext in extset: continue
item = QListWidgetItem(ext, self.mdExts)
item.setFlags(item.flags() | Qt.ItemIsUserCheckable)
item.setCheckState(Qt.Unchecked)
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 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 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 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 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 __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 __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 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 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 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_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 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 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 populateElements(self, selectedElement=None, edit=False):
selected = None
self.ui.elementListWidget.clear()
slist = [(self.elements[key].name, key)
for key in self.elements.keys()]
slist.sort()
for name, el in slist:
item = QListWidgetItem(QString("%s" % name))
item.setData(Qt.UserRole, QVariant(self.elements[el].id))
item.setFlags(item.flags() | Qt.ItemIsEditable)
dirty = False
if hasattr(self.elements[el], "isDirty") \
and self.elements[el].isDirty():
dirty = True
if self.elements[el].instance is not None:
if hasattr(self.elements[el].instance, "isDirty") \
and self.elements[el].instance.isDirty():
dirty = True
if dirty:
item.setForeground(Qt.red)
else:
item.setForeground(Qt.black)
self.ui.elementListWidget.addItem(item)
if selectedElement is not None \
and selectedElement == self.elements[el].id:
selected = item
if self.elements[el].instance is not None \
and self.elements[el].instance.dialog is not None:
try:
if dirty:
self.elements[el].instance.dialog.\
setWindowTitle("%s [%s]*" % (name, self.clName))
else:
self.elements[el].instance.dialog.\
setWindowTitle("%s [%s]" % (name, self.clName))
except:
self.elements[el].instance.dialog = None
if selected is not None:
selected.setSelected(True)
self.ui.elementListWidget.setCurrentItem(selected)
if edit:
self.ui.elementListWidget.editItem(selected)
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 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 __init__(self, fieldNames):
QDialog.__init__(self)
self.ui = Ui_FieldChooser()
self.ui.setupUi(self)
self.items = []
self.ui.fieldList.clear()
for fieldName in fieldNames:
item = QListWidgetItem()
item.setText(fieldName)
item.setFlags(item.flags() | Qt.ItemIsUserCheckable)
item.setCheckState(Qt.Unchecked)
self.ui.fieldList.addItem(item)
self.items.append(item)
QObject.connect(self.ui.unselectAll, SIGNAL("clicked()"),
self.unselectAll)
QObject.connect(self.ui.selectAll, SIGNAL("clicked()"), self.selectAll)
def __init__(self, fieldNames):
QDialog.__init__(self)
self.ui = Ui_FieldChooser()
self.ui.setupUi(self)
self.items = []
self.ui.fieldList.clear()
for fieldName in fieldNames:
item = QListWidgetItem()
item.setText(fieldName)
item.setFlags(item.flags() | Qt.ItemIsUserCheckable)
item.setCheckState(Qt.Unchecked)
self.ui.fieldList.addItem(item)
self.items.append(item)
QObject.connect(self.ui.unselectAll,
SIGNAL("clicked()"), self.unselectAll)
QObject.connect(self.ui.selectAll,
SIGNAL("clicked()"), self.selectAll)
def __add_gstke(self, filter):
QApplication.setOverrideCursor(Qt.WaitCursor)
try:
self.ui.LST_GSTKE.clear()
#show them sorted
for gst, props in sorted(self.gstke.iteritems()):
item = None
if gst == 'EXCEPTION':
item = QListWidgetItem(props)
else:
if filter in gst:
item = QListWidgetItem(gst)
item.setData(Qt.UserRole, props)
if props != 'FEHLER':
item.setFlags(item.flags() | Qt.ItemIsUserCheckable)
#important! won't work otherwise
item.setCheckState(Qt.Unchecked)
if not item is None:
self.ui.LST_GSTKE.addItem(item)
finally:
QApplication.restoreOverrideCursor()
def showAttributes(self):
""" List unique values of the selected field from source layer and show them in widget"""
if not self.checkExistingVector():
return
listAttr = []
self.dlg.valuesList.clear()
lyr = myLayers[self.dlg.srcLayer.currentIndex()]
for feature in lyr.getFeatures():
# attrs = feature.attributes()
attr = feature.attributes()[self.dlg.fltField.currentIndex()]
if attr not in listAttr:
listAttr.append(attr)
listAttr.sort()
for value in listAttr:
value = str(value)
item = QListWidgetItem()
item.setFlags(item.flags() | Qt.ItemIsUserCheckable)
item.setCheckState(Qt.Unchecked)
item.setText(value)
self.dlg.valuesList.addItem(item)
def __add_gstke(self, filter):
QApplication.setOverrideCursor(Qt.WaitCursor)
try:
self.ui.LST_GSTKE.clear()
#show them sorted
for gst, props in sorted(self.gstke.iteritems()):
item = None
if gst == 'EXCEPTION':
item = QListWidgetItem(props)
else:
if filter in gst:
item = QListWidgetItem(gst)
item.setData(Qt.UserRole, props)
if props != 'FEHLER':
item.setFlags(item.flags()
| Qt.ItemIsUserCheckable)
#important! won't work otherwise
item.setCheckState(Qt.Unchecked)
if not item is None:
self.ui.LST_GSTKE.addItem(item)
finally:
QApplication.restoreOverrideCursor()
def showAttributes(self):
""" List unique values of the selected field from source layer and show them in widget"""
if not self.checkExistingVector():
return
listAttr = []
self.dlg.valuesList.clear()
lyr = myLayers[self.dlg.srcLayer.currentIndex()]
for feature in lyr.getFeatures():
# attrs = feature.attributes()
attr = feature.attributes()[self.dlg.fltField.currentIndex()]
if attr not in listAttr:
listAttr.append(attr)
listAttr.sort()
for value in listAttr:
value = str(value)
item = QListWidgetItem()
item.setFlags(item.flags() | Qt.ItemIsUserCheckable)
item.setCheckState(Qt.Unchecked)
item.setText(value)
self.dlg.valuesList.addItem(item)
def provide(self, search):
if not search.startswith('='):
yield False
if search.startswith('=='):
if self.sympy is None:
try:
import sympy
except ImportError:
logging.warn('"sympy" not found.')
yield QListWidgetItem('"sympy" not found.')
yield True
self.sympy = sympy
locals_ = {name: getattr(self.sympy, name) for name in
(attribute for attribute in dir(self.sympy)
if not attribute.startswith('_'))}
for variable in ('x', 'y', 'z'):
locals_[variable] = self.sympy.var(variable)
prettify = self.sympy_prettify
else:
locals_ = {name: getattr(math, name) for name in
(attribute for attribute in dir(math)
if not attribute.startswith('_'))}
for builtin in MATH_BUILTINS:
locals_[builtin] = getattr(__builtins__, builtin)
prettify = str
try:
locals_['ans'] = self.ans
self.ans = eval(search.lstrip('='), {'__builtins__': None},
locals_)
item = QListWidgetItem(prettify(self.ans))
item.setFlags(item.flags() & ~Qt.ItemIsSelectable)
item.setFont(QFont(config_options['monospace font']))
yield item
except Exception as err:
yield QListWidgetItem(str(err))
yield True
def add_item_list(self):
item = QListWidgetItem("item", self.ui.itemsList)
item.setFlags(item.flags() | Qt.ItemIsEditable)
self.ui.itemsList.addItem(item)
class QWMS:
"""QGIS Plugin Implementation."""
def __init__(self, iface):
"""Constructor.
:param iface: An interface instance that will be passed to this class
which provides the hook by which you can manipulate the QGIS
application at run time.
:type iface: QgsInterface
"""
# Save reference to the QGIS interface
self.iface = iface
# initialize plugin directory
self.plugin_dir = os.path.dirname(__file__)
# initialize locale
locale = QSettings().value('locale/userLocale')[0:2]
locale_path = os.path.join(self.plugin_dir, 'i18n',
'QWMS_{}.qm'.format(locale))
if os.path.exists(locale_path):
self.translator = QTranslator()
self.translator.load(locale_path)
if qVersion() > '4.3.3':
QCoreApplication.installTranslator(self.translator)
# Create the dialog (after translation) and keep reference, window on top
self.dlg = QWMSDialog(self.iface.mainWindow())
# Declare instance attributes
self.actions = []
self.menu = self.tr(u'&QWMS')
# TODO: We are going to let the user set this up in a future iteration
self.toolbar = self.iface.addToolBar(u'QWMS')
self.toolbar.setObjectName(u'QWMS')
# noinspection PyMethodMayBeStatic
def tr(self, message):
"""Get the translation for a string using Qt translation API.
We implement this ourselves since we do not inherit QObject.
:param message: String for translation.
:type message: str, QString
:returns: Translated version of message.
:rtype: QString
"""
# noinspection PyTypeChecker,PyArgumentList,PyCallByClass
return QCoreApplication.translate('QWMS', message)
def add_action(self,
icon_path,
text,
callback,
enabled_flag=True,
add_to_menu=True,
add_to_toolbar=True,
status_tip=None,
whats_this=None,
parent=None):
"""Add a toolbar icon to the toolbar.
:param icon_path: Path to the icon for this action. Can be a resource
path (e.g. ':/plugins/foo/bar.png') or a normal file system path.
:type icon_path: str
:param text: Text that should be shown in menu items for this action.
:type text: str
:param callback: Function to be called when the action is triggered.
:type callback: function
:param enabled_flag: A flag indicating if the action should be enabled
by default. Defaults to True.
:type enabled_flag: bool
:param add_to_menu: Flag indicating whether the action should also
be added to the menu. Defaults to True.
:type add_to_menu: bool
:param add_to_toolbar: Flag indicating whether the action should also
be added to the toolbar. Defaults to True.
:type add_to_toolbar: bool
:param status_tip: Optional text to show in a popup when mouse pointer
hovers over the action.
:type status_tip: str
:param parent: Parent widget for the new action. Defaults None.
:type parent: QWidget
:param whats_this: Optional text to show in the status bar when the
mouse pointer hovers over the action.
:returns: The action that was created. Note that the action is also
added to self.actions list.
:rtype: QAction
"""
icon = QIcon(icon_path)
action = QAction(icon, text, parent)
action.triggered.connect(callback)
action.setEnabled(enabled_flag)
if status_tip is not None:
action.setStatusTip(status_tip)
if whats_this is not None:
action.setWhatsThis(whats_this)
if add_to_toolbar:
self.toolbar.addAction(action)
if add_to_menu:
self.iface.addPluginToMenu(self.menu, action)
self.actions.append(action)
return action
def initGui(self):
"""Create the menu entries and toolbar icons inside the QGIS GUI."""
icon_path = ':/plugins/QWMS/icon.png'
self.add_action(icon_path,
text=self.tr(u'Get WMS'),
callback=self.run,
parent=self.iface.mainWindow())
def unload(self):
"""Removes the plugin menu item and icon from QGIS GUI."""
for action in self.actions:
self.iface.removePluginMenu(self.tr(u'&QWMS'), action)
self.iface.removeToolBarIcon(action)
# remove the toolbar
del self.toolbar
def approveChoice(self, i):
"""Returns index of WMS service"""
self.dlg.textEdit.clear()
self.selectedWMSIndex = self.dlg.comboBox.currentIndex()
return self.selectedWMSIndex
def selectedChoice(self):
"""Gets layers of selected WMS"""
## Execute GetCapabilities
if self.dlg.comboBox.currentIndex() == len(wmsList): # if GDOS
url_to_wms_getcaps = wms_getcap_gdos
else:
service = wmsLinks[self.dlg.comboBox.currentIndex()] # else
url_to_wms_getcaps = wms_getcap_geop % (service)
## Read the XML
try:
tree = ET.parse(urllib2.urlopen(url_to_wms_getcaps))
except:
self.dlg.textEdit.setPlainText('Server error')
root = tree.getroot()
self.layerDict = {} # User-friendly names
self.layerDictURL = {} # Names that URL parses
## Choose proper path and get available layers to dict
## depending on XML structure
layerID = 0
if root.findall(xmlStructureURL_3):
for layer in root.findall(xmlStructureURL_3):
if layer.tag == layerTagTitle:
self.layerDict[layerID - 1] = (layer.text)
if layer.tag == layerTagName:
self.layerDictURL[layerID] = (layer.text)
layerID += 1
else:
if root.findall(xmlStructureURL_2):
for layer in root.findall(xmlStructureURL_2):
if layer.tag == layerTagTitle:
self.layerDict[layerID - 1] = (layer.text)
if layer.tag == layerTagName:
self.layerDictURL[layerID] = (layer.text)
layerID += 1
else:
if root.findall(xmlStructureURL_1):
for layer in root.findall(xmlStructureURL_1):
if layer.tag == layerTagTitle:
self.layerDict[layerID - 1] = (layer.text)
if layer.tag == layerTagName:
self.layerDictURL[layerID] = (layer.text)
layerID += 1
else:
if root.findall(xmlStructureURL_4):
for layer in root.findall(xmlStructureURL_4):
if layer.tag == layerTagTitle:
self.layerDict[layerID - 1] = (layer.text)
if layer.tag == layerTagName:
self.layerDictURL[layerID] = (layer.text)
layerID += 1
else:
self.iface.messageBar().pushMessage(
"Error",
"Unknown metadata structure",
level=QgsMessageBar.WARNING,
duration=3)
## Gets available layers and adds them as checkboxes
self.dlg.listWidget.clear()
self.dlg.listWidget.setVisible(True)
for key, value in self.layerDict.iteritems():
self.layerToSelect = QListWidgetItem()
self.layerToSelect.setText(value)
self.layerToSelect.setFlags(self.layerToSelect.flags()
| QtCore.Qt.ItemIsUserCheckable)
if len(self.layerDict) <= 1: # if only one layer available
self.layerToSelect.setCheckState(QtCore.Qt.Checked)
self.dlg.listWidget.addItem(self.layerToSelect)
self.dlg.listWidget.setEnabled(False)
else: # if more than one available
self.layerToSelect.setCheckState(QtCore.Qt.Unchecked)
self.dlg.listWidget.addItem(self.layerToSelect)
self.dlg.listWidget.setEnabled(True)
self.dlg.pushButton_3.setEnabled(True)
self.dlg.pushButton_2.setEnabled(True)
return
def iterate(self):
"""Checks which layers have been selected and returns them"""
self.items = []
self.countChecked = 0
for index in xrange(self.dlg.listWidget.count()):
if self.dlg.listWidget.item(
index).checkState() == QtCore.Qt.Checked:
self.countChecked += 1
self.items.append(self.dlg.listWidget.item(index).text())
## Get IDs of chosen layers to query it from listDictURL dict
self.keysIDs = []
self.keysURL = []
self.indexStyles = []
for i in self.items:
for key, value in self.layerDict.iteritems():
if i == value:
self.keysIDs.append(key)
## Create 'styles' part of WMS URL depending on number of layers chosen
for i in self.keysIDs:
for key, value in self.layerDictURL.iteritems():
if i == key:
self.keysURL.append(value)
self.indexStyles.append(wms_styles)
return self.items
def textBox(self):
"""Shows URL to be queried in the text box"""
## Gets current EPSG
canvas = self.iface.mapCanvas()
currentEPSG = canvas.mapRenderer().destinationCrs().authid()
if currentEPSG not in availableEPSG:
currentEPSG = 'EPSG:4326'
## Get part of WMS URL corresponding to selected service
if self.dlg.comboBox.currentIndex() == len(wmsList):
wms_url = wms_url_gdos
else:
service = wmsLinks[self.dlg.comboBox.currentIndex()]
wms_url = wms_url_geop % (service)
self.iterate()
## If more than one layer selected
if self.countChecked > 1:
for selectedLayer in self.keysURL:
indexLayers = '&layers='.join(self.keysURL)
indexStyles = '&'.join(self.indexStyles)
self.urlWithParams = wms_separator.join(
(wms_url, wms_format, wms_layers + indexLayers, indexStyles,
wms_crs + currentEPSG))
## If one layer selected
elif self.countChecked == 1:
for selectedLayer in self.keysURL:
indexLayers = self.keysURL[0]
self.urlWithParams = wms_separator.join(
(wms_url, wms_format, wms_layers + indexLayers, wms_styles,
wms_crs + currentEPSG))
else:
self.urlWithParams = 'Error'
## Insert URL to be queried in TextBox
self.dlg.textEdit.setPlainText(self.urlWithParams)
return self.urlWithParams
def selectAllNone(self):
"""Selects or deselects all layers in checkbox list"""
if self.dlg.listWidget.item(0).checkState() == QtCore.Qt.Unchecked:
for index in xrange(self.dlg.listWidget.count()):
self.dlg.listWidget.item(index).setCheckState(
QtCore.Qt.Checked)
else:
for index in xrange(self.dlg.listWidget.count()):
self.dlg.listWidget.item(index).setCheckState(
QtCore.Qt.Unchecked)
def run(self):
""" Run the plugin """
self.dlg.pushButton_2.setEnabled(False)
self.dlg.pushButton_3.setEnabled(False)
## Show the dialog
self.dlg.show()
## Add services to the list:
if self.dlg.comboBox.count() == 0:
self.dlg.comboBox.addItems(wmsList)
self.dlg.comboBox.insertSeparator(39)
## Refreshes window after changing service
self.dlg.comboBox.currentIndexChanged.connect(self.approveChoice)
## Get layers of selected service
self.dlg.pushButton.clicked.connect(self.selectedChoice)
## Select all/none layers
self.dlg.pushButton_3.clicked.connect(self.selectAllNone)
## Get WMS address to be queried
self.dlg.pushButton_2.clicked.connect(self.textBox)
## Run the dialog event loop
result = self.dlg.exec_()
## After pressing OK do
if result:
if self.dlg.textEdit.toPlainText() == '':
self.textBox() # If Get WMS URL is not clicked
finalURL = self.dlg.textEdit.toPlainText()
if finalURL != 'Error':
## Add layer(s)
if self.dlg.comboBox.currentIndex() == len(wmsList): # if GDOS
rlayer = QgsRasterLayer(finalURL, wmsList[39], 'wms')
else:
rlayer = QgsRasterLayer(
finalURL, wmsList[self.dlg.comboBox.currentIndex()],
'wms')
if not rlayer.isValid():
self.iface.messageBar().pushMessage(
"Error",
"Layer failed to load",
level=QgsMessageBar.WARNING,
duration=3)
else:
QgsMapLayerRegistry.instance().addMapLayer(rlayer)
else:
self.iface.messageBar().pushMessage(
"Error",
"Error in querying available layers",
level=QgsMessageBar.WARNING,
duration=3)
class QWMS:
"""QGIS Plugin Implementation."""
def __init__(self, iface):
"""Constructor.
:param iface: An interface instance that will be passed to this class
which provides the hook by which you can manipulate the QGIS
application at run time.
:type iface: QgsInterface
"""
# Save reference to the QGIS interface
self.iface = iface
# initialize plugin directory
self.plugin_dir = os.path.dirname(__file__)
# initialize locale
locale = QSettings().value('locale/userLocale')[0:2]
locale_path = os.path.join(
self.plugin_dir,
'i18n',
'QWMS_{}.qm'.format(locale))
if os.path.exists(locale_path):
self.translator = QTranslator()
self.translator.load(locale_path)
if qVersion() > '4.3.3':
QCoreApplication.installTranslator(self.translator)
# Create the dialog (after translation) and keep reference, window on top
self.dlg = QWMSDialog(self.iface.mainWindow())
# Declare instance attributes
self.actions = []
self.menu = self.tr(u'&QWMS')
# TODO: We are going to let the user set this up in a future iteration
self.toolbar = self.iface.addToolBar(u'QWMS')
self.toolbar.setObjectName(u'QWMS')
# noinspection PyMethodMayBeStatic
def tr(self, message):
"""Get the translation for a string using Qt translation API.
We implement this ourselves since we do not inherit QObject.
:param message: String for translation.
:type message: str, QString
:returns: Translated version of message.
:rtype: QString
"""
# noinspection PyTypeChecker,PyArgumentList,PyCallByClass
return QCoreApplication.translate('QWMS', message)
def add_action(
self,
icon_path,
text,
callback,
enabled_flag=True,
add_to_menu=True,
add_to_toolbar=True,
status_tip=None,
whats_this=None,
parent=None):
"""Add a toolbar icon to the toolbar.
:param icon_path: Path to the icon for this action. Can be a resource
path (e.g. ':/plugins/foo/bar.png') or a normal file system path.
:type icon_path: str
:param text: Text that should be shown in menu items for this action.
:type text: str
:param callback: Function to be called when the action is triggered.
:type callback: function
:param enabled_flag: A flag indicating if the action should be enabled
by default. Defaults to True.
:type enabled_flag: bool
:param add_to_menu: Flag indicating whether the action should also
be added to the menu. Defaults to True.
:type add_to_menu: bool
:param add_to_toolbar: Flag indicating whether the action should also
be added to the toolbar. Defaults to True.
:type add_to_toolbar: bool
:param status_tip: Optional text to show in a popup when mouse pointer
hovers over the action.
:type status_tip: str
:param parent: Parent widget for the new action. Defaults None.
:type parent: QWidget
:param whats_this: Optional text to show in the status bar when the
mouse pointer hovers over the action.
:returns: The action that was created. Note that the action is also
added to self.actions list.
:rtype: QAction
"""
icon = QIcon(icon_path)
action = QAction(icon, text, parent)
action.triggered.connect(callback)
action.setEnabled(enabled_flag)
if status_tip is not None:
action.setStatusTip(status_tip)
if whats_this is not None:
action.setWhatsThis(whats_this)
if add_to_toolbar:
self.toolbar.addAction(action)
if add_to_menu:
self.iface.addPluginToMenu(
self.menu,
action)
self.actions.append(action)
return action
def initGui(self):
"""Create the menu entries and toolbar icons inside the QGIS GUI."""
icon_path = ':/plugins/QWMS/icon.png'
self.add_action(
icon_path,
text=self.tr(u'Get WMS'),
callback=self.run,
parent=self.iface.mainWindow())
def unload(self):
"""Removes the plugin menu item and icon from QGIS GUI."""
for action in self.actions:
self.iface.removePluginMenu(
self.tr(u'&QWMS'),
action)
self.iface.removeToolBarIcon(action)
# remove the toolbar
del self.toolbar
def approveChoice(self, i):
"""Returns index of WMS service"""
self.dlg.textEdit.clear()
self.selectedWMSIndex = self.dlg.comboBox.currentIndex()
return self.selectedWMSIndex
def selectedChoice(self):
"""Gets layers of selected WMS"""
## Execute GetCapabilities
if self.dlg.comboBox.currentIndex() == len(wmsList): # if GDOS
url_to_wms_getcaps = wms_getcap_gdos
else:
service = wmsLinks[self.dlg.comboBox.currentIndex()] # else
url_to_wms_getcaps = wms_getcap_geop % (service)
## Read the XML
try:
tree = ET.parse(urllib2.urlopen(url_to_wms_getcaps))
except:
self.dlg.textEdit.setPlainText('Server error')
root = tree.getroot()
self.layerDict = {} # User-friendly names
self.layerDictURL = {} # Names that URL parses
## Choose proper path and get available layers to dict
## depending on XML structure
layerID = 0
if root.findall(xmlStructureURL_3):
for layer in root.findall(xmlStructureURL_3):
if layer.tag == layerTagTitle:
self.layerDict[layerID-1] = (layer.text)
if layer.tag == layerTagName:
self.layerDictURL[layerID] = (layer.text)
layerID += 1
else:
if root.findall(xmlStructureURL_2):
for layer in root.findall(xmlStructureURL_2):
if layer.tag == layerTagTitle:
self.layerDict[layerID-1] = (layer.text)
if layer.tag == layerTagName:
self.layerDictURL[layerID] = (layer.text)
layerID += 1
else:
if root.findall(xmlStructureURL_1):
for layer in root.findall(xmlStructureURL_1):
if layer.tag == layerTagTitle:
self.layerDict[layerID-1] = (layer.text)
if layer.tag == layerTagName:
self.layerDictURL[layerID] = (layer.text)
layerID += 1
else:
if root.findall(xmlStructureURL_4):
for layer in root.findall(xmlStructureURL_4):
if layer.tag == layerTagTitle:
self.layerDict[layerID-1] = (layer.text)
if layer.tag == layerTagName:
self.layerDictURL[layerID] = (layer.text)
layerID += 1
else:
self.iface.messageBar().pushMessage("Error", "Unknown metadata structure", level=QgsMessageBar.WARNING, duration=3)
## Gets available layers and adds them as checkboxes
self.dlg.listWidget.clear()
self.dlg.listWidget.setVisible(True)
for key, value in self.layerDict.iteritems():
self.layerToSelect = QListWidgetItem()
self.layerToSelect.setText(value)
self.layerToSelect.setFlags(self.layerToSelect.flags() | QtCore.Qt.ItemIsUserCheckable)
if len(self.layerDict) <= 1: # if only one layer available
self.layerToSelect.setCheckState(QtCore.Qt.Checked)
self.dlg.listWidget.addItem(self.layerToSelect)
self.dlg.listWidget.setEnabled(False)
else: # if more than one available
self.layerToSelect.setCheckState(QtCore.Qt.Unchecked)
self.dlg.listWidget.addItem(self.layerToSelect)
self.dlg.listWidget.setEnabled(True)
self.dlg.pushButton_3.setEnabled(True)
self.dlg.pushButton_2.setEnabled(True)
return
def iterate(self):
"""Checks which layers have been selected and returns them"""
self.items = []
self.countChecked = 0
for index in xrange(self.dlg.listWidget.count()):
if self.dlg.listWidget.item(index).checkState() == QtCore.Qt.Checked:
self.countChecked += 1
self.items.append(self.dlg.listWidget.item(index).text())
## Get IDs of chosen layers to query it from listDictURL dict
self.keysIDs = []
self.keysURL = []
self.indexStyles = []
for i in self.items:
for key, value in self.layerDict.iteritems():
if i == value:
self.keysIDs.append(key)
## Create 'styles' part of WMS URL depending on number of layers chosen
for i in self.keysIDs:
for key, value in self.layerDictURL.iteritems():
if i == key:
self.keysURL.append(value)
self.indexStyles.append(wms_styles)
return self.items
def textBox(self):
"""Shows URL to be queried in the text box"""
## Gets current EPSG
canvas = self.iface.mapCanvas()
currentEPSG = canvas.mapRenderer().destinationCrs().authid()
if currentEPSG not in availableEPSG:
currentEPSG = 'EPSG:4326'
## Get part of WMS URL corresponding to selected service
if self.dlg.comboBox.currentIndex() == len(wmsList):
wms_url = wms_url_gdos
else:
service = wmsLinks[self.dlg.comboBox.currentIndex()]
wms_url = wms_url_geop % (service)
self.iterate()
## If more than one layer selected
if self.countChecked > 1:
for selectedLayer in self.keysURL:
indexLayers = '&layers='.join(self.keysURL)
indexStyles = '&'.join(self.indexStyles)
self.urlWithParams = wms_separator.join((wms_url,
wms_format,
wms_layers
+ indexLayers,
indexStyles,
wms_crs
+ currentEPSG))
## If one layer selected
elif self.countChecked == 1:
for selectedLayer in self.keysURL:
indexLayers = self.keysURL[0]
self.urlWithParams = wms_separator.join((wms_url,
wms_format,
wms_layers
+ indexLayers,
wms_styles,
wms_crs
+ currentEPSG))
else:
self.urlWithParams = 'Error'
## Insert URL to be queried in TextBox
self.dlg.textEdit.setPlainText(self.urlWithParams)
return self.urlWithParams
def selectAllNone(self):
"""Selects or deselects all layers in checkbox list"""
if self.dlg.listWidget.item(0).checkState() == QtCore.Qt.Unchecked:
for index in xrange(self.dlg.listWidget.count()):
self.dlg.listWidget.item(index).setCheckState(QtCore.Qt.Checked)
else:
for index in xrange(self.dlg.listWidget.count()):
self.dlg.listWidget.item(index).setCheckState(QtCore.Qt.Unchecked)
def run(self):
""" Run the plugin """
self.dlg.pushButton_2.setEnabled(False)
self.dlg.pushButton_3.setEnabled(False)
## Show the dialog
self.dlg.show()
## Add services to the list:
if self.dlg.comboBox.count() == 0:
self.dlg.comboBox.addItems(wmsList)
self.dlg.comboBox.insertSeparator(39)
## Refreshes window after changing service
self.dlg.comboBox.currentIndexChanged.connect(self.approveChoice)
## Get layers of selected service
self.dlg.pushButton.clicked.connect(self.selectedChoice)
## Select all/none layers
self.dlg.pushButton_3.clicked.connect(self.selectAllNone)
## Get WMS address to be queried
self.dlg.pushButton_2.clicked.connect(self.textBox)
## Run the dialog event loop
result = self.dlg.exec_()
## After pressing OK do
if result:
if self.dlg.textEdit.toPlainText() == '':
self.textBox() # If Get WMS URL is not clicked
finalURL = self.dlg.textEdit.toPlainText()
if finalURL != 'Error':
## Add layer(s)
if self.dlg.comboBox.currentIndex() == len(wmsList): # if GDOS
rlayer = QgsRasterLayer(finalURL, wmsList[39], 'wms')
else:
rlayer = QgsRasterLayer(finalURL, wmsList[self.dlg.comboBox.currentIndex()], 'wms')
if not rlayer.isValid():
self.iface.messageBar().pushMessage("Error", "Layer failed to load", level=QgsMessageBar.WARNING, duration=3)
else:
QgsMapLayerRegistry.instance().addMapLayer(rlayer)
else:
self.iface.messageBar().pushMessage("Error", "Error in querying available layers", level=QgsMessageBar.WARNING, duration=3)
def addEditableItem(self, item):
# Don't iterate over each character when a single item is passed:
newItem = QListWidgetItem(item)
newItem.setData(Qt.UserRole, item)
newItem.setFlags(newItem.flags() | Qt.ItemIsEditable)
self.classesListWidget.addItem(newItem)
def add_to_list(self, name, directory):
repo = QListWidgetItem(QIcon(dirname(main_window.__file__)+'/icons/Git-Icon-Black.png'), name, self.ui.listWidget)
repo.setStatusTip(directory)
repo.setData(Qt.UserRole, directory)
repo.setFlags(repo.flags() | Qt.ItemIsEditable)
