def get_vector_layers(self):
vector_layers_names = opt_value(self.plugin.metadata,
'vector_layers.layers', {}).keys()
return [
layer for layer in self.plugin.layers_list()
if layer.name() in vector_layers_names
]
def initialize(self):
# import vector layers configuration from lastly published
# metadata if exists
last_vector_config = opt_value(self.plugin.last_metadata,
'vector_layers.layers', {})
current_vector_config = self.plugin.metadata['vector_layers']['layers']
for layer_name, layer_config in last_vector_config.iteritems():
if not current_vector_config.get(layer_name):
current_vector_config[layer_name] = layer_config
def get_vector_layers(self):
vector_layers_names = opt_value(
self.plugin.metadata,
'vector_layers.layers',
{}
).keys()
return [
layer for layer in self.plugin.layers_list()
if layer.name() in vector_layers_names
]
def initialize(self):
# import vector layers configuration from lastly published
# metadata if exists
last_vector_config = opt_value(
self.plugin.last_metadata,
'vector_layers.layers',
{}
)
current_vector_config = self.plugin.metadata['vector_layers']['layers']
for layer_name, layer_config in last_vector_config.iteritems():
if not current_vector_config.get(layer_name):
current_vector_config[layer_name] = layer_config
def on_show(self):
tree = self.dialog.tree_project_files
create_formatted_tree(tree, list(self.project_files()))
tree.expandAll()
# Data sources
self._datasources = {}
vector_data_file = opt_value(self.plugin.metadata,
'vector_layers.filename')
if vector_data_file:
self._datasources['Vector layers'] = [
os.path.join(os.path.dirname(self.plugin.project.fileName()),
vector_data_file)
]
def collect_layers_datasources(layer_node):
for index in range(layer_node.rowCount()):
collect_layers_datasources(layer_node.child(index))
layer = layer_node.data(Qt.UserRole)
if layer and layer_node.checkState() == Qt.Checked:
layer_provider = layer.dataProvider()
if isinstance(layer_provider, QgsVectorDataProvider):
storage_type = layer_provider.storageType()
elif isinstance(layer_provider, QgsRasterDataProvider):
storage_type = 'Raster'
else:
storage_type = 'Other'
datasource_uri = QgsDataSourceURI(
layer_provider.dataSourceUri())
datasource_db = datasource_uri.database()
if datasource_db:
datasource_db = os.path.normpath(datasource_db)
if storage_type not in self._datasources:
self._datasources[storage_type] = dict(
) if datasource_db else set()
if datasource_db:
if datasource_db not in self._datasources[storage_type]:
self._datasources[storage_type][datasource_db] = []
if datasource_uri.schema():
table_name = '{0}.{1}'.format(datasource_uri.schema(),
datasource_uri.table())
else:
table_name = datasource_uri.table()
table_item = [
"{0} ({1})".format(table_name,
datasource_uri.geometryColumn())
]
self._datasources[storage_type][datasource_db].append(
table_item)
if datasource_uri.sql():
table_item.append(
["SQL: {}".format(datasource_uri.sql())])
else:
dsfile = layer_provider.dataSourceUri().split(
'|')[0].strip()
self._datasources[storage_type].add(
os.path.normpath(dsfile))
collect_layers_datasources(
self.dialog.treeView.model().invisibleRootItem())
tree = self.dialog.tree_data_sources
create_formatted_tree(tree, self._datasources)
tree.expandAll()
def on_show(self):
tree = self.dialog.tree_project_files
create_formatted_tree(tree,
list(self.project_files())
)
tree.expandAll()
# Publish directory
if self.plugin.run_in_gislab:
self.dialog.label_publish_dir.setText(
"Publish directory: ~/Publish/{0}".format(
os.environ['USER']
)
)
self.dialog.label_gislab_url.setText(
"Visit GIS.lab User page <a href=\"{0}/user\">{0}/user</a>"
" to launch this project in GIS.lab Web.".format(
GISLAB_WEB_URL
)
)
# Data sources
self._datasources = {}
vector_data_file = opt_value(self.plugin.metadata, 'vector_layers.filename')
if vector_data_file:
self._datasources['Vector layers'] = [
os.path.join(
os.path.dirname(
self.plugin.project.fileName()
),
vector_data_file
)
]
def collect_layers_datasources(layer_node):
for index in range(layer_node.rowCount()):
collect_layers_datasources(
layer_node.child(index)
)
layer = layer_node.data(Qt.UserRole)
if layer and layer_node.checkState() == Qt.Checked:
layer_provider = layer.dataProvider()
if isinstance(layer_provider, QgsVectorDataProvider):
storage_type = layer_provider.storageType()
elif isinstance(layer_provider, QgsRasterDataProvider):
storage_type = 'Raster'
else:
storage_type = 'Other'
datasource_uri = QgsDataSourceURI( layer_provider.dataSourceUri() )
datasource_db = datasource_uri.database()
if storage_type not in self._datasources:
self._datasources[storage_type] = dict() if datasource_db else set()
if datasource_db:
if datasource_db not in self._datasources[storage_type]:
self._datasources[storage_type][datasource_db] = []
if datasource_uri.schema():
table_name = '{0}.{1}'.format(datasource_uri.schema(), datasource_uri.table())
else:
table_name = datasource_uri.table()
table_item = [
"{0} ({1})".format(table_name, datasource_uri.geometryColumn())
]
self._datasources[storage_type][datasource_db].append(table_item)
if datasource_uri.sql():
table_item.append(["SQL: {}".format(datasource_uri.sql())])
else:
dsfile = layer_provider.dataSourceUri().split('|')[0].strip()
self._datasources[storage_type].add(dsfile)
collect_layers_datasources(
self.dialog.treeView.model().invisibleRootItem()
)
tree = self.dialog.tree_data_sources
create_formatted_tree(tree, self._datasources)
tree.expandAll()
def on_show(self):
tree = self.dialog.tree_project_files
create_formatted_tree(tree,
list(self.project_files())
)
tree.expandAll()
# Data sources
self._datasources = {}
vector_data_file = opt_value(self.plugin.metadata, 'vector_layers.filename')
if vector_data_file:
self._datasources['Vector layers'] = [
os.path.join(
os.path.dirname(
self.plugin.project.fileName()
),
vector_data_file
)
]
def collect_layers_datasources(layer_node):
for index in range(layer_node.rowCount()):
collect_layers_datasources(
layer_node.child(index)
)
layer = layer_node.data(Qt.UserRole)
if layer and layer_node.checkState() == Qt.Checked:
layer_provider = layer.dataProvider()
if isinstance(layer_provider, QgsVectorDataProvider):
storage_type = layer_provider.storageType()
elif isinstance(layer_provider, QgsRasterDataProvider):
storage_type = 'Raster'
else:
storage_type = 'Other'
datasource_uri = QgsDataSourceURI( layer_provider.dataSourceUri() )
datasource_db = datasource_uri.database()
if datasource_db:
datasource_db = os.path.normpath(datasource_db)
if storage_type not in self._datasources:
self._datasources[storage_type] = dict() if datasource_db else set()
if datasource_db:
if datasource_db not in self._datasources[storage_type]:
self._datasources[storage_type][datasource_db] = []
if datasource_uri.schema():
table_name = '{0}.{1}'.format(datasource_uri.schema(), datasource_uri.table())
else:
table_name = datasource_uri.table()
table_item = [
"{0} ({1})".format(table_name, datasource_uri.geometryColumn())
]
self._datasources[storage_type][datasource_db].append(table_item)
if datasource_uri.sql():
table_item.append(["SQL: {}".format(datasource_uri.sql())])
else:
dsfile = layer_provider.dataSourceUri().split('|')[0].strip()
self._datasources[storage_type].add(os.path.normpath(dsfile))
collect_layers_datasources(
self.dialog.treeView.model().invisibleRootItem()
)
tree = self.dialog.tree_data_sources
create_formatted_tree(tree, self._datasources)
tree.expandAll()
def on_show(self):
datasources = []
vector_data_file = opt_value(self.plugin.metadata, 'vector_layers.filename')
if vector_data_file:
datasources.append(
os.path.join(
os.path.dirname(
self.plugin.project.fileName()
),
vector_data_file
)
)
def collect_layers_datasources(layer_node):
for index in range(layer_node.rowCount()):
collect_layers_datasources(
layer_node.child(index)
)
layer = layer_node.data(Qt.UserRole)
if layer and layer_node.checkState() == Qt.Checked:
layer_datasource = layer.source()
if layer_datasource not in datasources:
datasources.append(layer_datasource)
collect_layers_datasources(
self.dialog.treeView.model().invisibleRootItem()
)
project_filename = os.path.splitext(self.plugin.project.fileName())[0]
publish_timestamp = str(self.plugin.metadata['publish_date_unix'])
published_project_filename = "{0}_{1}.qgs".format(
project_filename,
publish_timestamp
)
published_metadata_filename = "{0}_{1}.meta".format(
project_filename,
publish_timestamp
)
html = u"""<html>
<head>{0}</head>
<body>
<p><h4>Project '{1}' was successfully published.</h4></p>
<p>Copy all project files to '~/Publish/{5}' folder on GIS.lab server and visit GIS.lab User page <a href="{6}/user">{6}/user</a> to launch this project in GIS.lab Web.</p>
<p><h4>Project files:</h4></p>
<ul>
<li><label>Project file:</label> {2}</li>
<li><label>Project META file:</label> {3}</li>
</ul>
<p><h4>Data sources:</h4></p>
<ul>{4}</ul>
</body>
</html>
""".format(CSS_STYLE,
self.plugin.metadata['title'],
published_project_filename,
published_metadata_filename,
''.join(
['<li>{0}</li>'.format(datasource) for datasource in datasources]
),
os.environ['USER'],
GISLAB_WEB_URL
)
self.dialog.confirmation_info.setHtml(html)
def get_metadata(self):
"""Generate project's metadata (dictionary)."""
dialog = self.dialog
project = self.plugin.project
map_canvas = self.plugin.iface.mapCanvas()
project_keyword_list = project.readListEntry("WMSKeywordList", "/")[0]
metadata = {
'title': dialog.project_title.text(),
'abstract': project.readEntry("WMSServiceAbstract", "/")[0],
'contact_person': project.readEntry("WMSContactPerson", "/")[0],
'contact_organization': project.readEntry("WMSContactOrganization", "/")[0],
'contact_mail': project.readEntry("WMSContactMail", "/")[0],
'contact_phone': project.readEntry("WMSContactPhone", "/")[0],
'online_resource': project.readEntry("WMSOnlineResource", "/")[0],
'fees': project.readEntry("WMSFees", "/")[0],
'access_constrains': project.readEntry("WMSAccessConstraints", "/")[0],
'keyword_list':project_keyword_list if project_keyword_list != [u''] else [],
'authentication': AUTHENTICATION_OPTIONS[dialog.authentication.currentIndex()],
'use_mapcache': dialog.use_mapcache.isChecked()
}
metadata['expiration'] = ""
if self.dialog.enable_expiration.isChecked():
metadata['expiration'] = self.dialog.expiration.date().toString("dd.MM.yyyy")
try:
map_settings = map_canvas.mapSettings()
except:
map_settings = map_canvas.mapRenderer()
selection_color = map_settings.selectionColor()
canvas_color = map_canvas.canvasColor()
project_extent = dialog.extent_layer.itemData(dialog.extent_layer.currentIndex())
extent_buffer = dialog.extent_buffer.value()
if extent_buffer != 0:
project_extent = [
project_extent[0]-extent_buffer,
project_extent[1]-extent_buffer,
project_extent[2]+extent_buffer,
project_extent[3]+extent_buffer
]
project_crs = map_settings.destinationCrs()
metadata.update({
'extent': project_extent,
'extent_buffer': extent_buffer,
'zoom_extent': [
round(coord, 3) for coord in map_canvas.extent().toRectF().getCoords()
],
'projection': {
'code': project_crs.authid(),
'is_geographic': project_crs.geographicFlag(),
'proj4': project_crs.toProj4()
},
'units': self.plugin.map_units(),
'selection_color': '{0}{1:02x}'.format(selection_color.name(), selection_color.alpha()),
'canvas_color': '{0}{1:02x}'.format(canvas_color.name(), canvas_color.alpha()),
'measure_ellipsoid': project.readEntry("Measure", "/Ellipsoid", "")[0],
'position_precision': {
'automatic': project.readBoolEntry("PositionPrecision", "/Automatic")[0],
'decimal_places': project.readNumEntry("PositionPrecision", "/DecimalPlaces")[0]
}
})
special_base_layers = []
if dialog.blank.isChecked():
special_base_layers.append({'title': 'Blank', 'name': 'BLANK', 'type': 'Blank'})
if metadata['projection']['code'].upper() == 'EPSG:3857':
if dialog.osm.isChecked():
special_base_layers.append(dict(OSM_LAYER))
if dialog.mapbox.isChecked():
special_base_layers.append(dict(MAPBOX_LAYER))
if dialog.bing.isChecked() > 0:
special_base_layers.append(dict(BING_LAYERS[dialog.bing_style.currentIndex()]))
min_resolution = self.dialog.min_scale.itemData(self.dialog.min_scale.currentIndex())
max_resolution = self.dialog.max_scale.itemData(self.dialog.max_scale.currentIndex())
def publish_resolutions(resolutions, min_resolution=min_resolution, max_resolution=max_resolution):
return filter(lambda res: res >= min_resolution and res <= max_resolution, resolutions)
project_tile_resolutions = set(self.plugin.project_layers_resolutions())
# collect set of all resolutions from special base layers and WMSC base layers
for special_base_layer in special_base_layers:
resolutions = special_base_layer.get('resolutions')
if resolutions:
project_tile_resolutions.update(resolutions)
if not project_tile_resolutions:
project_tile_resolutions = self.plugin.scales_to_resolutions(DEFAULT_PROJECT_SCALES)
project_tile_resolutions = set(publish_resolutions(project_tile_resolutions))
project_tile_resolutions = sorted(project_tile_resolutions, reverse=True)
metadata['tile_resolutions'] = project_tile_resolutions
metadata['scales'] = self.plugin.resolutions_to_scales(project_tile_resolutions)
# create base layers metadata
default_baselayer = self.dialog.default_baselayer.itemData(
self.dialog.default_baselayer.currentIndex()
)
def base_layers_data(node):
if node.children:
sublayers_data = []
for child in node.children:
sublayer_data = base_layers_data(child)
if sublayer_data:
sublayers_data.append(sublayer_data)
if sublayers_data:
return {
'name': node.name,
'layers': sublayers_data
}
else:
try:
map_settings = map_canvas.mapSettings()
except:
map_settings = map_canvas.mapRenderer()
layer = node.layer
source_params = parse_qs(layer.source())
layer_data = {
'name': layer.name(),
'provider_type': layer.providerType(),
'visible': layer.name() == default_baselayer,
'extent': map_settings.layerExtentToOutputExtent(
layer,
layer.extent()
).toRectF().getCoords(),
'wms_layers': source_params['layers'][0].split(','),
'projection': source_params['crs'][0],
'format': source_params['format'][0],
'url': source_params['url'][0],
'dpi': layer.dataProvider().dpi(),
'metadata': {
'title': layer.title(),
'abstract': layer.abstract(),
'keyword_list': layer.keywordList()
}
}
if layer.attribution():
layer_data['attribution'] = {
'title': layer.attribution(),
'url': layer.attributionUrl()
}
layer_resolutions = layer.dataProvider().property('resolutions')
if layer_resolutions:
layer_resolutions = publish_resolutions(
self.plugin.wmsc_layer_resolutions(layer)
)
if not layer_resolutions:
return None
min_resolution = layer_resolutions[-1]
max_resolution = layer_resolutions[0]
upper_resolutions = filter(
lambda res: res > max_resolution,
project_tile_resolutions
)
lower_resolutions = filter(
lambda res: res < min_resolution,
project_tile_resolutions
)
layer_data.update({
'type': 'WMSC',
'min_resolution': min_resolution,
'max_resolution': max_resolution,
'resolutions': upper_resolutions + layer_resolutions + lower_resolutions,
'tile_size': [
layer.dataProvider().property('tileWidth') or 256,
layer.dataProvider().property('tileHeight') or 256
]
})
else:
layer_data.update({
'type': 'WMS',
'resolutions': project_tile_resolutions
})
if layer.hasScaleBasedVisibility():
layer_visible_resolutions = self.plugin.filter_visible_resolutions(
layer_data['resolutions'],
layer
)
if layer_visible_resolutions:
layer_data.update({
'min_resolution': layer_visible_resolutions[-1],
'max_resolution': layer_visible_resolutions[0],
})
return layer_data
if self.base_layers_tree:
base_layers_metadata = base_layers_data(self.base_layers_tree)
else:
base_layers_metadata = {'layers': []}
# insert special base layers metadata
for special_base_layer in reversed(special_base_layers):
special_base_layer['visible'] = special_base_layer['name'] == default_baselayer
if 'resolutions' not in special_base_layer:
special_base_layer['resolutions'] = project_tile_resolutions
else:
layer_resolutions = special_base_layer['resolutions']
visible_resolutions = publish_resolutions(special_base_layer['resolutions'])
special_base_layer['resolutions'] = visible_resolutions
special_base_layer['min_zoom_level'] = layer_resolutions.index(visible_resolutions[0])
special_base_layer['max_zoom_level'] = layer_resolutions.index(visible_resolutions[-1])
if 'extent' not in special_base_layer:
special_base_layer['extent'] = metadata['extent']
if special_base_layer['name'] == 'MAPBOX':
mapid = special_base_layer['mapid'] = dialog.mapbox_mapid.currentText()
special_base_layer['apikey'] = dialog.mapbox_apikey.text()
if mapid.startswith('mapbox.'):
prefix, title = mapid.split('.', 1)
title = ' '.join(map(lambda x: x.title(), title.split('-')))
special_base_layer['title'] += ' {}'.format(title)
elif special_base_layer['name'].startswith('BING'):
special_base_layer['apikey'] = dialog.bing_apikey.text()
base_layers_metadata['layers'].insert(0, special_base_layer)
metadata['base_layers'] = base_layers_metadata.get('layers')
non_identifiable_layers = project.readListEntry("Identify", "/disabledLayers")[0] or []
overlays_order = [
layer.id() for layer in self.plugin.layers_list()
if self.plugin.is_overlay_layer_for_publish(layer)
]
def create_overlays_data(node):
sublayers = []
for child in node.children:
sublayer = create_overlays_data(child)
if sublayer:
sublayers.append(sublayer)
if sublayers:
return {
'name': node.name,
'layers': sublayers
}
elif node.layer:
layer = node.layer
layers_model = dialog.treeView.model()
layer_widget = layers_model.findItems(
layer.name(),
Qt.MatchExactly | Qt.MatchRecursive
)[0]
if layer_widget.checkState() == Qt.Unchecked or \
layers_model.columnItem(layer_widget, 1).checkState() == Qt.Checked:
return None
if layer.extent().isFinite() and not layer.extent().isEmpty():
try:
map_settings = map_canvas.mapSettings()
except:
map_settings = map_canvas.mapRenderer()
layer_extent = map_settings.layerExtentToOutputExtent(
layer,
layer.extent()
).toRectF().getCoords()
else:
layer_extent = project_extent
layer_data = {
'name': layer.name(),
'provider_type': layer.providerType(),
'extent': layer_extent,
'projection': layer.crs().authid(),
'visible': self.plugin.iface.legendInterface().isLayerVisible(layer),
'queryable': layer.id() not in non_identifiable_layers,
'hidden': layers_model.columnItem(layer_widget, 3).checkState() == Qt.Checked,
'export_to_drawings': layers_model.columnItem(layer_widget, 2).checkState() == Qt.Checked,
'drawing_order': overlays_order.index(layer.id()),
'metadata': {
'title': layer.title(),
'abstract': layer.abstract(),
'keyword_list': layer.keywordList()
}
}
if layer.attribution():
layer_data['attribution'] = {
'title': layer.attribution(),
'url': layer.attributionUrl()
}
if layer.hasScaleBasedVisibility():
layer_data['visibility_scale_min'] = max(layer.minimumScale(), metadata['scales'][-1])
layer_data['visibility_scale_max'] = min(layer.maximumScale(), metadata['scales'][0])
if layer.type() == QgsMapLayer.VectorLayer:
layer_data['type'] = 'vector'
layer_label_settings = QgsPalLayerSettings()
layer_label_settings.readFromLayer(layer)
layer_data['labels'] = layer_label_settings.enabled
if layer.hasGeometryType():
layer_data['geom_type'] = ('POINT', 'LINE', 'POLYGON')[layer.geometryType()]
fields = layer.pendingFields()
attributes_data = []
excluded_attributes = layer.excludeAttributesWMS()
for field in fields:
if field.name() in excluded_attributes:
continue
attribute_data = {
'name': field.name(),
'type': field.typeName(),
#'length': field.length(),
#'precision': field.precision()
}
if field.comment():
attribute_data['comment'] = field.comment()
alias = layer.attributeAlias(fields.indexFromName(field.name()))
if alias:
attribute_data['alias'] = alias
attributes_data.append(attribute_data)
layer_data['attributes'] = attributes_data
layer_data['pk_attributes'] = [
fields.at(index).name() for index in layer.dataProvider().pkAttributeIndexes()
]
else:
layer_data['type'] = 'raster'
return layer_data
metadata['overlays'] = []
if self.overlay_layers_tree:
overlays_data = create_overlays_data(self.overlay_layers_tree)
if overlays_data:
metadata['overlays'] = overlays_data.get('layers')
vector_layers_data = opt_value(self.plugin.metadata, 'vector_layers.layers', {})
vector_layers = self.get_published_layers(vector=True)
new_vector_layers_data = {}
for vector_layer in vector_layers:
new_vector_layers_data[vector_layer.name()] = vector_layers_data.get(vector_layer.name(), {})
metadata['vector_layers'] = {
'layers': new_vector_layers_data
}
composer_templates = []
for composer in self.plugin.iface.activeComposers():
composition = composer.composition()
map_composer = composition.getComposerMapById(0)
map_rect = map_composer.rect()
composer_templates.append({
# cannot get composer name other way
'name': composer.composerWindow().windowTitle(),
'width': composition.paperWidth(),
'height': composition.paperHeight(),
'map': {
'name': 'map0',
'x': map_composer.x(),
'y': map_composer.y(),
'width': map_rect.width(),
'height': map_rect.height()
},
'labels': [
item.id() for item in composition.items()
if isinstance(item, QgsComposerLabel) and item.id()
]
})
metadata['composer_templates'] = composer_templates
metadata['message'] = None
message_text = dialog.message_text.toPlainText()
if message_text:
metadata['message'] = {
'text': message_text,
'valid_until': dialog.message_valid_until.date().toString("dd.MM.yyyy")
}
return metadata
def setup_page(self, metadata):
"""Setup page (GUI components) from already existing metadata.
Args:
metadata (Dict[str, Any]): metadata object
"""
dialog = self.dialog
title = metadata.get('title')
if title:
dialog.project_title.setText(title)
message = metadata.get('message')
if message:
dialog.message_text.insertPlainText(message.get('text', ''))
valid_until = message.get('valid_until')
dialog.message_valid_until.setDate(
datetime.datetime.strptime(valid_until, "%d.%m.%Y")
)
expiration = metadata.get('expiration')
if expiration:
dialog.enable_expiration.setChecked(True)
dialog.expiration.setDate(
datetime.datetime.strptime(expiration, "%d.%m.%Y")
)
authentication = metadata.get('authentication')
if authentication:
try:
auth_index = AUTHENTICATION_OPTIONS.index(authentication)
except ValueError:
auth_index = 1
dialog.authentication.setCurrentIndex(auth_index)
project_extent = list(metadata['extent'])
extent_buffer = metadata.get('extent_buffer', 0)
if extent_buffer != 0:
project_extent = [
project_extent[0]+extent_buffer,
project_extent[1]+extent_buffer,
project_extent[2]-extent_buffer,
project_extent[3]-extent_buffer
]
extent_index = dialog.extent_layer.findData(project_extent)
if extent_index < 0:
extent_index = 0
dialog.extent_layer.setCurrentIndex(extent_index)
dialog.use_mapcache.setChecked(metadata.get('use_mapcache') is True)
dialog.extent_buffer.setValue(extent_buffer)
# create list of all layers from layers metadata tree structure
def extract_layers(layers_data, layers=None):
if layers is None:
layers = []
for layer_data in layers_data:
if 'layers' in layer_data:
extract_layers(layer_data['layers'], layers)
else:
layers.append(layer_data)
return layers
if metadata.get('base_layers'):
for base_layer in extract_layers(metadata['base_layers']):
if base_layer['type'] == 'Blank':
dialog.blank.setChecked(True)
elif base_layer['type'] == 'OSM':
dialog.osm.setChecked(True)
elif base_layer['type'] == 'MapBox':
dialog.mapbox.setChecked(True)
if 'mapid' in base_layer:
index = dialog.mapbox_mapid.findText(base_layer['mapid'])
if index >= 0:
dialog.mapbox_mapid.setCurrentIndex(index)
if 'apikey' in base_layer:
dialog.mapbox_apikey.setText(base_layer['apikey'])
elif base_layer['type'] == 'Bing':
dialog.bing.setChecked(True)
for index, glayer in enumerate(BING_LAYERS):
if glayer['name'] == base_layer['name']:
dialog.bing_style.setCurrentIndex(index)
break
if 'apikey' in base_layer:
dialog.bing_apikey.setText(base_layer['apikey'])
else:
# at least one base layer must be enabled (default is Blank)
dialog.blank.setChecked(True)
if base_layer['visible']:
dialog.default_baselayer.setCurrentIndex(
dialog.default_baselayer.findData(base_layer['name'])
)
else:
# at least one base layer must be enabled (default is Blank)
dialog.blank.setChecked(True)
overlays_data = extract_layers(metadata['overlays'])
geojson_overlays = opt_value(metadata, 'vector_layers.layers', {}).keys()
project_overlays = [layer_data['name'] for layer_data in overlays_data]
project_overlays.extend(geojson_overlays)
hidden_overlays = [
layer_data['name'] for layer_data in overlays_data
if layer_data.get('hidden')
]
overlays_with_export_to_drawings = [
layer_data['name'] for layer_data in overlays_data
if layer_data.get('export_to_drawings')
]
# Recursively setup layer widgets from prevoius info about layers types
def load_layers_settings(group_item):
for index in range(group_item.rowCount()):
child_item = group_item.child(index)
if child_item.data(Qt.UserRole):
layer_name = child_item.text()
child_item.setCheckState(
Qt.Checked if layer_name in project_overlays else Qt.Unchecked
)
layers_model = child_item.model()
vector_item = layers_model.columnItem(child_item, 1)
export_item = layers_model.columnItem(child_item, 2)
if vector_item.isCheckable():
vector_item.setCheckState(
Qt.Checked if layer_name in geojson_overlays else Qt.Unchecked
)
if export_item.isCheckable():
export_item.setCheckState(
Qt.Checked if layer_name in overlays_with_export_to_drawings else \
Qt.Unchecked
)
layers_model.columnItem(child_item, 3).setCheckState(
Qt.Checked if layer_name in hidden_overlays else Qt.Unchecked
)
else:
load_layers_settings(child_item)
load_layers_settings(dialog.treeView.model().invisibleRootItem())
max_res = metadata['tile_resolutions'][0]
min_res = metadata['tile_resolutions'][-1]
min_scale, max_scale = self.plugin.resolutions_to_scales(
to_decimal_array([min_res, max_res])
)
min_scale_index = dialog.min_scale.findText("1:{0}".format(min_scale))
max_scale_index = dialog.max_scale.findText("1:{0}".format(max_scale))
dialog.min_scale.setCurrentIndex(
min_scale_index if min_scale_index != -1 else dialog.min_scale.count() - 1
)
dialog.max_scale.setCurrentIndex(
max_scale_index if min_scale_index != -1 else 0
)
