def setup_default_preset(self):
"""Setup the display of presets"""
preset_folder = resources_path('map_preset')
folders = os.listdir(preset_folder)
for folder_name in folders:
file_path = join(preset_folder, folder_name, folder_name + '.json')
with open(file_path, encoding='utf8') as json_file:
data = json.load(json_file, object_hook=as_enum)
item = QListWidgetItem(self.dialog.list_default_mp)
item.setFlags(Qt.ItemIsSelectable | Qt.ItemIsUserCheckable
| Qt.ItemIsEnabled)
self.dialog.list_default_mp.addItem(item)
widget = QFrame()
widget.setFrameStyle(QFrame.StyledPanel)
widget.setStyleSheet('QFrame { margin: 3px; };')
widget.setSizePolicy(QSizePolicy.Fixed, QSizePolicy.Fixed)
hbox = QHBoxLayout()
vbox = QVBoxLayout()
picture = QLabel()
icon_path = resources_path('map_preset', folder_name,
folder_name + '_icon.png')
if not os.path.isfile(icon_path):
icon_path = resources_path('icons', 'QuickOSM.svg')
icon = QPixmap(icon_path)
icon.scaled(QSize(150, 250), Qt.KeepAspectRatio)
picture.setPixmap(icon)
picture.setStyleSheet(
'max-height: 150px; max-width: 250px; margin-right: 50px;')
hbox.addWidget(picture)
title = QLabel(data['file_name'])
title.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Fixed)
title.setStyleSheet('font: bold 20px; margin-bottom: 25px;')
vbox.addWidget(title)
for label in data['description']:
if not label:
label = tr('No description')
real_label = QLabel(label)
real_label.setWordWrap(True)
vbox.addWidget(real_label)
hbox.addItem(vbox)
widget.setLayout(hbox)
item.setSizeHint(widget.minimumSizeHint())
self.dialog.list_default_mp.setItemWidget(item, widget)
def prepare_run(self):
"""Prepare the data before running the process."""
selection = self.dialog.list_default_mp.selectedIndexes()
try:
if selection:
preset = self.dialog.list_default_mp.item(selection[0].row())
preset_widget = self.dialog.list_default_mp.itemWidget(preset)
preset_label = preset_widget.layout().itemAt(1).itemAt(
0).widget().text()
preset_folder = resources_path('map_preset')
else:
selection = self.dialog.list_personal_preset_mp.selectedIndexes(
)
if not len(selection):
raise NoSelectedPreset
preset = self.dialog.list_personal_preset_mp.item(
selection[0].row())
preset_widget = self.dialog.list_personal_preset_mp.itemWidget(
preset)
preset_label = preset_widget.layout().itemAt(0).itemAt(
0).widget().text()
preset_folder = query_preset()
LOGGER.debug('Preset chosen: {}'.format(preset_label))
file_path = join(preset_folder, preset_label,
preset_label + '.json')
with open(file_path, encoding='utf8') as json_file:
data = json.load(json_file, object_hook=as_enum)
data['folder'] = os.path.dirname(file_path)
if not data['advanced']:
properties = self.gather_spatial_values({})
data['query_type'] = properties['query_type']
data['distance'] = self.dialog.spin_place_mp.value()
if data['query_type'] != QueryType.AroundArea:
data['distance'] = None
if data['query_type'] in [
QueryType.InArea, QueryType.AroundArea
] and properties['place']:
for k, _area in enumerate(data['area']):
data['area'][k] = properties['place']
elif data['query_type'] == QueryType.BBox and properties[
'bbox']:
for k, _bbox in enumerate(data['bbox']):
data['bbox'][k] = properties['bbox']
self.run_saved_query(data)
except QuickOsmException as error:
self.dialog.display_quickosm_exception(error)
def setup_panel(self):
super().setup_panel()
self.dialog.combo_query_type_q.addItem(tr('Canvas Extent'), 'canvas')
self.dialog.combo_query_type_q.addItem(tr('Layer Extent'), 'layer')
self.dialog.combo_query_type_q.currentIndexChanged.connect(
self.query_type_updated)
self.dialog.combo_extent_layer_q.layerChanged.connect(
self.query_type_updated)
self.highlighter = QueryHighlighter(self.dialog.text_query.document())
self.dialog.text_query.cursorPositionChanged.connect(
self.highlighter.rehighlight)
self.dialog.text_query.cursorPositionChanged.connect(
self.allow_nominatim_or_extent)
self.dialog.button_overpass_turbo.setIcon(
QIcon(resources_path('icons', 'turbo.png')))
self.dialog.button_overpass_turbo.clicked.connect(open_overpass_turbo)
# Setup menu for documentation
popup_menu = QMenu()
map_features_action = QAction('Map Features',
self.dialog.button_documentation)
# noinspection PyUnresolvedReferences
map_features_action.triggered.connect(open_plugin_documentation)
popup_menu.addAction(map_features_action)
overpass_action = QAction('Overpass', self.dialog.button_documentation)
# noinspection PyUnresolvedReferences
overpass_action.triggered.connect(open_doc_overpass)
popup_menu.addAction(overpass_action)
self.dialog.button_documentation.setMenu(popup_menu)
self.dialog.button_generate_query.setMenu(QMenu())
self.dialog.action_oql_q.triggered.connect(self.query_language_oql)
self.dialog.action_xml_q.triggered.connect(self.query_language_xml)
self.dialog.button_generate_query.menu().addAction(
self.dialog.action_oql_q)
self.dialog.button_generate_query.menu().addAction(
self.dialog.action_xml_q)
self.dialog.run_buttons[self.panel].clicked.connect(self.run)
self.dialog.button_generate_query.clicked.connect(
self.query_language_check)
self.dialog.button_box_q.button(
QDialogButtonBox.Reset).clicked.connect(self.dialog.reset_form)
self.allow_nominatim_or_extent()
self.query_type_updated()
def setup_preset(self):
"""Set up the preset"""
parser = PresetsParser()
self.preset_data = parser.parser()
keys_preset = list(self.preset_data.elements.keys())
keys_preset.append('')
keys_preset.sort()
keys_preset_completer = DiacriticFreeCompleter()
completer_model = DiactricFreeStringListModel()
keys_preset_completer.setModel(completer_model)
keys_preset_completer.setCompletionRole(
completer_model.diactricFreeRole())
completer_model.setStringList(keys_preset)
self.preset.addItems(keys_preset)
self.preset.addItem(keys_preset.pop(0))
if not os.getenv(
'CI') and self.panel and self.panel == Panels.QuickQuery:
for k, key in enumerate(keys_preset):
icon_path = self.preset_data.elements[key].icon
widget_item = QListWidgetItem(key)
if icon_path:
icon_path = resources_path('icons', "josm", icon_path)
if os.path.exists(icon_path):
icon = QPixmap(icon_path)
widget_item.setData(
Qt.DecorationRole,
icon.scaled(20, 20, Qt.KeepAspectRatio))
self.preset.setItemData(
k + 1, icon.scaled(20, 20, Qt.KeepAspectRatio),
Qt.DecorationRole)
self.preset_items.append(widget_item)
self.preset.setCompleter(keys_preset_completer)
self.preset.completer().setCompletionMode(QCompleter.PopupCompletion)
self.preset.completer().setFilterMode(Qt.MatchContains)
self.preset.completer().setCaseSensitivity(Qt.CaseInsensitive)
self.preset.activated.connect(self.choice_preset)
self.preset.lineEdit().setPlaceholderText(
tr('Not mandatory. Ex: bakery'))
osm_keys = parser.osm_keys_values()
self.set_couple(osm_keys)
def setup_panel(self):
self.dialog.radio_osm_conf.setChecked(False)
self.dialog.osm_conf.setEnabled(False)
# TODO self.edit_file_prefix_f.setDisabled(True)
self.dialog.osm_file.setDialogTitle(tr('Select an OSM/PBF file'))
self.dialog.osm_file.setFilter('OSM file (*.osm *.pbf)')
default_osm_conf = resources_path('ogr', 'to_be_modified_osmconf.ini')
if not isfile(default_osm_conf):
default_osm_conf = ''
self.dialog.osm_conf.setDialogTitle(tr('Select OSM conf file'))
self.dialog.osm_conf.setFilter('OSM conf (*.ini)')
self.dialog.osm_conf.lineEdit().setPlaceholderText(default_osm_conf)
self.dialog.osm_conf.fileChanged.connect(self.disable_run_file_button)
self.dialog.radio_osm_conf.toggled.connect(
self.disable_run_file_button)
# TODO
# self.output_directory.fileChanged.connect(self.disable_prefix_file)
self.dialog.run_buttons[self.panel].clicked.connect(self.run)
self.disable_run_file_button()
def osm_keys_values(self) -> dict:
""" Retrieval of key/value couple """
couple = {}
items = self.items.copy()
old_couple_file = resources_path('json', 'map_features.json')
with open(old_couple_file, encoding='utf8') as json_file:
data = json.load(json_file)
if not os.getenv('CI'):
items['old_file'] = data
key = []
for item in items:
for k in list(items[item].keys()):
value = items[item][k]
if k in key:
if isinstance(value, list):
for val in value:
if val not in couple[k]:
couple[k].append(val)
elif value not in couple[k]:
couple[k].append(value)
elif isinstance(value, str):
key.append(k)
couple[k] = [value]
elif isinstance(value, list):
key.append(k)
if value:
couple[k] = [value[0]]
for val in value[1:]:
couple[k].append(val)
else:
couple[k] = ['']
return couple
def __init__(self, iface=None, parent=None):
"""Constructor."""
QDialog.__init__(self, parent)
self.setupUi(self)
self._iface = iface
self.query_menu_index = 2
self.preset_menu_index = 0
# Table mapping
# Explaining quickly, these letters are referring to the panel
# in the UI:
# mp : Map preset
# qq : Quick Query
# q : Query
# f : file
self.external_panels = {
Panels.MapPreset: MapPresetPanel(self),
Panels.QuickQuery: QuickQueryPanel(self),
Panels.Query: QueryPanel(self),
Panels.File: OsmFilePanel(self),
Panels.Configuration: ConfigurationPanel(self),
}
self.places_edits = {
Panels.MapPreset: self.line_place_mp,
Panels.QuickQuery: self.line_place_qq,
Panels.Query: self.line_place_q,
}
self.query_type_buttons = {
Panels.MapPreset: self.combo_query_type_mp,
Panels.QuickQuery: self.combo_query_type_qq,
Panels.Query: self.combo_query_type_q,
}
self.layers_buttons = {
Panels.MapPreset: self.combo_extent_layer_mp,
Panels.QuickQuery: self.combo_extent_layer_qq,
Panels.Query: self.combo_extent_layer_q,
}
self.selection_features = {
Panels.MapPreset: self.checkbox_selection_mp,
Panels.QuickQuery: self.checkbox_selection_qq,
Panels.Query: self.checkbox_selection_q,
}
self.run_buttons = {
Panels.MapPreset: self.button_run_query_mp,
Panels.QuickQuery: self.button_run_query_qq,
Panels.Query: self.button_run_query_q,
Panels.File: self.button_run_file,
}
self.cancel_buttons = {
Panels.MapPreset: self.button_cancel_query_mp,
Panels.QuickQuery: self.button_cancel_query_qq,
Panels.Query: self.button_cancel_query_q,
Panels.File: self.button_cancel_file,
}
self.execute_buttons = {
Panels.MapPreset: self.stacked_execute_query_mp,
Panels.QuickQuery: self.stacked_execute_query_qq,
Panels.Query: self.stacked_execute_query_q,
Panels.File: self.stacked_execute_file,
}
self.output_buttons = {
Panels.MapPreset: [],
Panels.QuickQuery: [
self.checkbox_points_qq, self.checkbox_lines_qq,
self.checkbox_multilinestrings_qq,
self.checkbox_multipolygons_qq
],
Panels.Query: [
self.checkbox_points_q,
self.checkbox_lines_q,
self.checkbox_multilinestrings_q,
self.checkbox_multipolygons_q,
],
Panels.File: [
self.checkbox_points_f,
self.checkbox_lines_f,
self.checkbox_multilinestrings_f,
self.checkbox_multipolygons_f,
]
}
self.output_directories = {
Panels.MapPreset: None,
Panels.QuickQuery: self.output_directory_qq,
Panels.Query: self.output_directory_q,
Panels.File: self.output_directory_f
}
self.output_format = {
Panels.MapPreset: None,
Panels.QuickQuery: self.combo_format_qq,
Panels.Query: self.combo_format_q,
Panels.File: self.combo_format_f
}
self.prefix_edits = {
Panels.MapPreset: None,
Panels.QuickQuery: self.line_file_prefix_qq,
Panels.Query: self.line_file_prefix_q,
Panels.File: self.line_file_prefix_file,
}
self.advanced_panels = {
Panels.MapPreset: None,
Panels.QuickQuery: self.advanced_qq,
Panels.Query: self.advanced_q,
}
self.query_language = {
Panels.MapPreset: None,
Panels.QuickQuery: QueryLanguage.OQL,
Panels.Query: QueryLanguage.OQL,
}
self.action_oql_qq = QAction('OQL')
self.action_oql_q = QAction('OQL')
self.action_oql = {
Panels.QuickQuery: self.action_oql_qq,
Panels.Query: self.action_oql_q,
}
self.action_xml_qq = QAction('XML')
self.action_xml_q = QAction('XML')
self.action_xml = {
Panels.QuickQuery: self.action_xml_qq,
Panels.Query: self.action_xml_q,
}
icon = QIcon(resources_path('icons', 'QuickOSM.svg'))
self.reload_action = QAction(icon,
tr("Reload the query in a new file"),
self.iface)
actions = Actions(self)
reloader = partial(actions.pre_run_reload)
self.reload_action.triggered.connect(reloader)
self.iface.addCustomActionForLayerType(self.reload_action, "",
QgsMapLayer.VectorLayer, False)
self.feedback_process = QgsFeedback()
item = self.menu_widget.item(0)
item.setIcon(QIcon(resources_path('icons', 'map_tools.svg')))
item = self.menu_widget.item(1)
item.setIcon(QIcon(resources_path('icons', 'quick.png')))
item = self.menu_widget.item(2)
item.setIcon(QIcon(resources_path('icons', 'edit.png')))
item = self.menu_widget.item(3)
item.setIcon(QIcon(resources_path('icons', 'open.png')))
item = self.menu_widget.item(4)
item.setIcon(QIcon(resources_path('icons', 'general.svg')))
item = self.menu_widget.item(5)
item.setIcon(QIcon(resources_path('icons', 'info.png')))
self.label_gnu.setPixmap(QPixmap(resources_path('icons', 'gnu.png')))
# Set minimum width for the menu
self.menu_widget.setMinimumWidth(
self.menu_widget.sizeHintForColumn(0) + 10)
self.progress_text.setText('')
self.menu_widget.currentRowChanged['int'].connect(
self.stacked_panels_widget.setCurrentIndex)
for panel in self.external_panels.values():
panel.setup_panel()
self.menu_widget.setCurrentRow(1)
def setup_panel(self):
super().setup_panel()
"""Setup the UI for the QuickQuery."""
# Query type
self.dialog.combo_query_type_qq.addItem(tr('In'), 'in')
self.dialog.combo_query_type_qq.addItem(tr('Around'), 'around')
self.dialog.combo_query_type_qq.addItem(tr('Canvas Extent'), 'canvas')
self.dialog.combo_query_type_qq.addItem(tr('Layer Extent'), 'layer')
self.dialog.combo_query_type_qq.addItem(tr('Not Spatial'),
'attributes')
# self.cb_query_type_qq.setItemIcon(
# 0, QIcon(resources_path('in.svg')))
# self.cb_query_type_qq.setItemIcon(
# 1, QIcon(resources_path('around.svg')))
# self.cb_query_type_qq.setItemIcon(
# 2, QIcon(resources_path('map_canvas.svg')))
# self.cb_query_type_qq.setItemIcon(
# 3, QIcon(resources_path('extent.svg')))
# self.cb_query_type_qq.setItemIcon(
# 4, QIcon(resources_path('mIconTableLayer.svg')))
self.dialog.combo_query_type_qq.currentIndexChanged.connect(
self.query_type_updated)
self.dialog.line_file_prefix_qq.setDisabled(True)
self.dialog.button_run_query_qq.clicked.connect(self.run)
self.dialog.button_show_query.clicked.connect(self.show_query)
self.dialog.combo_key.editTextChanged.connect(self.key_edited)
self.dialog.button_map_features.clicked.connect(open_map_features)
self.dialog.button_box_qq.button(
QDialogButtonBox.Reset).clicked.connect(self.dialog.reset_form)
# setup callbacks for friendly-label-update only
self.dialog.combo_value.editTextChanged.connect(self.update_friendly)
self.dialog.line_place_qq.textChanged.connect(self.update_friendly)
self.dialog.spin_place_qq.valueChanged.connect(self.update_friendly)
self.dialog.combo_extent_layer_qq.layerChanged.connect(
self.update_friendly)
# Setup auto completion
map_features_json_file = resources_path('json', 'map_features.json')
if isfile(map_features_json_file):
with open(map_features_json_file) as f:
self.osm_keys = load(f)
keys = list(self.osm_keys.keys())
keys.append('') # All keys request #118
keys.sort()
keys_completer = QCompleter(keys)
self.dialog.combo_key.addItems(keys)
self.dialog.combo_key.setCompleter(keys_completer)
self.dialog.combo_key.completer().setCompletionMode(
QCompleter.PopupCompletion)
self.dialog.combo_key.lineEdit().setPlaceholderText(
tr('Query on all keys'))
self.dialog.combo_value.lineEdit().setPlaceholderText(
tr('Query on all values'))
self.key_edited()
self.query_type_updated()
self.init_nominatim_autofill()
self.update_friendly()
def add_actions(layer, keys):
"""Add actions on layer.
:param layer: The layer.
:type layer: QgsVectorLayer
:param keys: The list of keys in the layer.
:type keys: list
"""
actions = layer.actions()
title = tr('OpenStreetMap Browser')
osm_browser = QgsAction(
QgsAction.OpenUrl,
title,
'http://www.openstreetmap.org/browse/[% "osm_type" %]/[% "osm_id" %]',
'',
False,
title,
ACTIONS_VISIBILITY,
''
)
actions.addAction(osm_browser)
title = 'Mapillary'
mapillary = QgsAction(
QgsAction.GenericPython,
title,
ACTIONS_PATH + 'Actions.run("mapillary","[% "mapillary" %]")',
resources_path('icons', 'mapillary_logo.svg'),
False,
title,
ACTIONS_VISIBILITY,
''
)
actions.addAction(mapillary)
title = 'JOSM'
josm = QgsAction(
QgsAction.GenericPython,
title,
ACTIONS_PATH + 'Actions.run("josm","[% "full_id" %]")',
resources_path('icons', 'josm_icon.svg'),
False,
title,
ACTIONS_VISIBILITY,
''
)
actions.addAction(josm)
title = tr('User default editor')
default_editor = QgsAction(
QgsAction.OpenUrl,
title,
'http://www.openstreetmap.org/edit?[% "osm_type" %]=[% "osm_id" %]',
'',
False,
title,
ACTIONS_VISIBILITY,
''
)
actions.addAction(default_editor)
for link in ['url', 'website', 'wikipedia', 'wikidata', 'ref:UAI']:
if link in keys:
# Add an image to the action if available
image = ''
if link == 'wikipedia':
image = resources_path('icons', 'wikipedia.png')
elif link == 'wikidata':
image = resources_path('icons', 'wikidata.png')
elif link in ['url', 'website']:
image = resources_path('icons', 'external_link.png')
link = link.replace(":", "_")
generic = QgsAction(
QgsAction.GenericPython,
link,
(ACTIONS_PATH
+ 'Actions.run("{link}","[% "{link}" %]")'.format(link=link)),
image,
False,
link,
ACTIONS_VISIBILITY,
''
)
actions.addAction(generic)
if 'network' in keys and 'ref' in keys:
sketch_line = QgsAction(
QgsAction.GenericPython,
tr('Sketchline'),
(
ACTIONS_PATH +
'Actions.run_sketch_line("[% "network" %]","[% "ref" %]")'
),
'',
False,
'',
ACTIONS_VISIBILITY,
''
)
actions.addAction(sketch_line)
import collections as col
import json
import logging
import os
import re
import xml.dom.minidom as xml
from QuickOSM.qgis_plugin_tools.tools.i18n import setup_translation
from QuickOSM.qgis_plugin_tools.tools.resources import resources_path
__copyright__ = 'Copyright 2021, 3Liz'
__license__ = 'GPL version 3'
__email__ = '*****@*****.**'
PRESET_PATH = resources_path('JOSM_preset', 'josm_preset.xml')
LOGGER = logging.getLogger('QuickOSM')
class PresetsParser:
"""Management of the presets file."""
def __init__(self):
self.file = xml.parse(PRESET_PATH)
locale, translate_path = setup_translation(file_pattern="preset_{}.po")
if translate_path:
# LOGGER.info('Translation of presets to {}'.format(file_path))
self.translate = self.preset_translate(translate_path)
else:
# LOGGER.info('Translation of presets not found: {}'.format(locale))
self.translate = {}
def icon(self):
"""Return the icon."""
return QIcon(resources_path('icons', 'QuickOSM.svg'))
def svgIconPath(self) -> str:
"""Return the icon path."""
return resources_path('icons', 'QuickOSM.svg')
def svgIconPath(self):
return resources_path('icons', 'QuickOSM.svg')
def icon(self):
return QIcon(resources_path('icons', 'QuickOSM.svg'))
