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 )