def testThemeChanged(self):
"""
Test that the mapTheme(s)Changed signals are correctly emitted in all relevant situations
"""
project = QgsProject()
collection = QgsMapThemeCollection(project)
record = QgsMapThemeCollection.MapThemeRecord()
theme_changed_spy = QSignalSpy(collection.mapThemeChanged)
themes_changed_spy = QSignalSpy(collection.mapThemesChanged)
collection.insert('theme1', record)
self.assertEqual(len(theme_changed_spy), 1)
self.assertEqual(theme_changed_spy[-1][0], 'theme1')
self.assertEqual(len(themes_changed_spy), 1)
# reinsert
collection.insert('theme1', record)
self.assertEqual(len(theme_changed_spy), 2)
self.assertEqual(theme_changed_spy[-1][0], 'theme1')
self.assertEqual(len(themes_changed_spy), 2)
# update
collection.update('theme1', record)
self.assertEqual(len(theme_changed_spy), 3)
self.assertEqual(theme_changed_spy[-1][0], 'theme1')
self.assertEqual(len(themes_changed_spy), 3)
# remove invalid
collection.removeMapTheme('i wish i was a slave to an age old trade... like riding around on rail cars and working long days')
self.assertEqual(len(theme_changed_spy), 3)
self.assertEqual(len(themes_changed_spy), 3)
# remove valid
collection.removeMapTheme('theme1')
self.assertEqual(len(theme_changed_spy), 3) # not changed - removed!
self.assertEqual(len(themes_changed_spy), 4)
# reinsert
collection.insert('theme1', record)
self.assertEqual(len(theme_changed_spy), 4)
self.assertEqual(len(themes_changed_spy), 5)
# clear
collection.clear()
self.assertEqual(len(theme_changed_spy), 4) # not changed - removed!
self.assertEqual(len(themes_changed_spy), 6)
# check that mapThemeChanged is emitted if layer is removed
layer = QgsVectorLayer("Point?field=fldtxt:string",
"layer1", "memory")
layer2 = QgsVectorLayer("Point?field=fldtxt:string",
"layer2", "memory")
project.addMapLayers([layer, layer2])
# record for layer1
record.addLayerRecord(QgsMapThemeCollection.MapThemeLayerRecord(layer))
collection.insert('theme1', record)
self.assertEqual(len(theme_changed_spy), 5)
self.assertEqual(len(themes_changed_spy), 7)
# now kill layer 2
project.removeMapLayer(layer2)
self.assertEqual(len(theme_changed_spy), 5) # signal should not be emitted - layer is not in record
# now kill layer 1
project.removeMapLayer(layer)
app.processEvents()
self.assertEqual(len(theme_changed_spy), 6) # signal should be emitted - layer is in record
def testMapTheme(self):
canvas = QgsMapCanvas()
canvas.setDestinationCrs(QgsCoordinateReferenceSystem(4326))
canvas.setFrameStyle(0)
canvas.resize(600, 400)
self.assertEqual(canvas.width(), 600)
self.assertEqual(canvas.height(), 400)
layer = QgsVectorLayer("Polygon?crs=epsg:4326&field=fldtxt:string",
"layer", "memory")
# add a polygon to layer
f = QgsFeature()
f.setGeometry(QgsGeometry.fromRect(QgsRectangle(5, 25, 25, 45)))
self.assertTrue(layer.dataProvider().addFeatures([f]))
# create a style
sym1 = QgsFillSymbol.createSimple({'color': '#ffb200'})
renderer = QgsSingleSymbolRenderer(sym1)
layer.setRenderer(renderer)
canvas.setLayers([layer])
canvas.setExtent(QgsRectangle(10, 30, 20, 35))
canvas.show()
# need to wait until first redraw can occur (note that we first need to wait till drawing starts!)
while not canvas.isDrawing():
app.processEvents()
canvas.waitWhileRendering()
self.assertTrue(self.canvasImageCheck('theme1', 'theme1', canvas))
# add some styles
layer.styleManager().addStyleFromLayer('style1')
sym2 = QgsFillSymbol.createSimple({'color': '#00b2ff'})
renderer2 = QgsSingleSymbolRenderer(sym2)
layer.setRenderer(renderer2)
layer.styleManager().addStyleFromLayer('style2')
canvas.refresh()
canvas.waitWhileRendering()
self.assertTrue(self.canvasImageCheck('theme2', 'theme2', canvas))
layer.styleManager().setCurrentStyle('style1')
canvas.refresh()
canvas.waitWhileRendering()
self.assertTrue(self.canvasImageCheck('theme1', 'theme1', canvas))
# OK, so all good with setting/rendering map styles
# try setting canvas to a particular theme
# make some themes...
theme1 = QgsMapThemeCollection.MapThemeRecord()
record1 = QgsMapThemeCollection.MapThemeLayerRecord(layer)
record1.currentStyle = 'style1'
record1.usingCurrentStyle = True
theme1.setLayerRecords([record1])
theme2 = QgsMapThemeCollection.MapThemeRecord()
record2 = QgsMapThemeCollection.MapThemeLayerRecord(layer)
record2.currentStyle = 'style2'
record2.usingCurrentStyle = True
theme2.setLayerRecords([record2])
QgsProject.instance().mapThemeCollection().insert('theme1', theme1)
QgsProject.instance().mapThemeCollection().insert('theme2', theme2)
canvas.setTheme('theme2')
canvas.refresh()
canvas.waitWhileRendering()
self.assertTrue(self.canvasImageCheck('theme2', 'theme2', canvas))
canvas.setTheme('theme1')
canvas.refresh()
canvas.waitWhileRendering()
self.assertTrue(self.canvasImageCheck('theme1', 'theme1', canvas))
# add another layer
layer2 = QgsVectorLayer("Polygon?crs=epsg:4326&field=fldtxt:string",
"layer2", "memory")
f = QgsFeature()
f.setGeometry(QgsGeometry.fromRect(QgsRectangle(5, 25, 25, 45)))
self.assertTrue(layer2.dataProvider().addFeatures([f]))
# create a style
sym1 = QgsFillSymbol.createSimple({'color': '#b2ff00'})
renderer = QgsSingleSymbolRenderer(sym1)
layer2.setRenderer(renderer)
# rerender canvas - should NOT show new layer
canvas.refresh()
canvas.waitWhileRendering()
self.assertTrue(self.canvasImageCheck('theme1', 'theme1', canvas))
# test again - this time refresh all layers
canvas.refreshAllLayers()
canvas.waitWhileRendering()
self.assertTrue(self.canvasImageCheck('theme1', 'theme1', canvas))
# add layer 2 to theme1
record3 = QgsMapThemeCollection.MapThemeLayerRecord(layer2)
theme1.setLayerRecords([record3])
QgsProject.instance().mapThemeCollection().update('theme1', theme1)
canvas.refresh()
canvas.waitWhileRendering()
self.assertTrue(self.canvasImageCheck('theme3', 'theme3', canvas))
# change the appearance of an active style
layer2.styleManager().addStyleFromLayer('original')
layer2.styleManager().addStyleFromLayer('style4')
record3.currentStyle = 'style4'
record3.usingCurrentStyle = True
theme1.setLayerRecords([record3])
QgsProject.instance().mapThemeCollection().update('theme1', theme1)
canvas.refresh()
canvas.waitWhileRendering()
self.assertTrue(self.canvasImageCheck('theme3', 'theme3', canvas))
layer2.styleManager().setCurrentStyle('style4')
sym3 = QgsFillSymbol.createSimple({'color': '#b200b2'})
layer2.renderer().setSymbol(sym3)
canvas.refresh()
canvas.waitWhileRendering()
self.assertTrue(self.canvasImageCheck('theme4', 'theme4', canvas))
# try setting layers while a theme is in place
canvas.setLayers([layer])
canvas.refresh()
# should be no change... setLayers should be ignored if canvas is following a theme!
canvas.waitWhileRendering()
self.assertTrue(self.canvasImageCheck('theme4', 'theme4', canvas))
# setLayerStyleOverrides while theme is in place
canvas.setLayerStyleOverrides({layer2.id(): 'original'})
# should be no change... setLayerStyleOverrides should be ignored if canvas is following a theme!
canvas.refresh()
canvas.waitWhileRendering()
self.assertTrue(self.canvasImageCheck('theme4', 'theme4', canvas))
# clear theme
canvas.setTheme('')
canvas.refresh()
canvas.waitWhileRendering()
# should be different - we should now render project layers
self.assertFalse(self.canvasImageCheck('theme4', 'theme4', canvas))
def testMasterLayerOrder(self):
""" test master layer order"""
prj = QgsProject.instance()
prj.clear()
layer = QgsVectorLayer("Point?field=fldtxt:string", "layer1", "memory")
layer2 = QgsVectorLayer("Point?field=fldtxt:string", "layer2",
"memory")
layer3 = QgsVectorLayer("Point?field=fldtxt:string", "layer3",
"memory")
prj.addMapLayers([layer, layer2, layer3])
prj.layerTreeRoot().setHasCustomLayerOrder(True)
prj.layerTreeRoot().setCustomLayerOrder([layer2, layer])
self.assertEqual(prj.mapThemeCollection().masterLayerOrder(),
[layer2, layer])
prj.layerTreeRoot().setCustomLayerOrder([layer, layer2, layer3])
# make some themes...
theme1 = QgsMapThemeCollection.MapThemeRecord()
theme1.setLayerRecords([
QgsMapThemeCollection.MapThemeLayerRecord(layer3),
QgsMapThemeCollection.MapThemeLayerRecord(layer)
])
theme2 = QgsMapThemeCollection.MapThemeRecord()
theme2.setLayerRecords([
QgsMapThemeCollection.MapThemeLayerRecord(layer3),
QgsMapThemeCollection.MapThemeLayerRecord(layer2),
QgsMapThemeCollection.MapThemeLayerRecord(layer)
])
theme3 = QgsMapThemeCollection.MapThemeRecord()
theme3.setLayerRecords([
QgsMapThemeCollection.MapThemeLayerRecord(layer2),
QgsMapThemeCollection.MapThemeLayerRecord(layer)
])
prj.mapThemeCollection().insert('theme1', theme1)
prj.mapThemeCollection().insert('theme2', theme2)
prj.mapThemeCollection().insert('theme3', theme3)
# order of layers in theme should respect master order
self.assertEqual(
prj.mapThemeCollection().mapThemeVisibleLayers('theme1'),
[layer, layer3])
self.assertEqual(
prj.mapThemeCollection().mapThemeVisibleLayers('theme2'),
[layer, layer2, layer3])
self.assertEqual(
prj.mapThemeCollection().mapThemeVisibleLayers('theme3'),
[layer, layer2])
# also check ids!
self.assertEqual(
prj.mapThemeCollection().mapThemeVisibleLayerIds('theme1'),
[layer.id(), layer3.id()])
self.assertEqual(
prj.mapThemeCollection().mapThemeVisibleLayerIds('theme2'),
[layer.id(), layer2.id(), layer3.id()])
self.assertEqual(
prj.mapThemeCollection().mapThemeVisibleLayerIds('theme3'),
[layer.id(), layer2.id()])
# reset master order
prj.layerTreeRoot().setCustomLayerOrder([layer2, layer3, layer])
self.assertEqual(
prj.mapThemeCollection().mapThemeVisibleLayers('theme1'),
[layer3, layer])
self.assertEqual(
prj.mapThemeCollection().mapThemeVisibleLayers('theme2'),
[layer2, layer3, layer])
self.assertEqual(
prj.mapThemeCollection().mapThemeVisibleLayers('theme3'),
[layer2, layer])
self.assertEqual(
prj.mapThemeCollection().mapThemeVisibleLayerIds('theme1'),
[layer3.id(), layer.id()])
self.assertEqual(
prj.mapThemeCollection().mapThemeVisibleLayerIds('theme2'),
[layer2.id(), layer3.id(), layer.id()])
self.assertEqual(
prj.mapThemeCollection().mapThemeVisibleLayerIds('theme3'),
[layer2.id(), layer.id()])
# check that layers include those hidden in the layer tree
canvas = QgsMapCanvas()
bridge = QgsLayerTreeMapCanvasBridge(prj.layerTreeRoot(), canvas)
root = prj.layerTreeRoot()
layer_node = root.findLayer(layer2.id())
layer_node.setItemVisibilityChecked(False)
app.processEvents()
prj.layerTreeRoot().setHasCustomLayerOrder(False)
self.assertEqual(prj.mapThemeCollection().masterLayerOrder(),
[layer, layer2, layer3])
self.assertEqual(
prj.mapThemeCollection().mapThemeVisibleLayers('theme1'),
[layer, layer3])
self.assertEqual(
prj.mapThemeCollection().mapThemeVisibleLayers('theme2'),
[layer, layer2, layer3])
self.assertEqual(
prj.mapThemeCollection().mapThemeVisibleLayers('theme3'),
[layer, layer2])
self.assertEqual(
prj.mapThemeCollection().mapThemeVisibleLayerIds('theme1'),
[layer.id(), layer3.id()])
self.assertEqual(
prj.mapThemeCollection().mapThemeVisibleLayerIds('theme2'),
[layer.id(), layer2.id(), layer3.id()])
self.assertEqual(
prj.mapThemeCollection().mapThemeVisibleLayerIds('theme3'),
[layer.id(), layer2.id()])
def testThemeChanged(self):
"""
Test that the mapTheme(s)Changed signals are correctly emitted in all relevant situations
"""
project = QgsProject()
collection = QgsMapThemeCollection(project)
record = QgsMapThemeCollection.MapThemeRecord()
theme_changed_spy = QSignalSpy(collection.mapThemeChanged)
themes_changed_spy = QSignalSpy(collection.mapThemesChanged)
collection.insert('theme1', record)
self.assertEqual(len(theme_changed_spy), 1)
self.assertEqual(theme_changed_spy[-1][0], 'theme1')
self.assertEqual(len(themes_changed_spy), 1)
# reinsert
collection.insert('theme1', record)
self.assertEqual(len(theme_changed_spy), 2)
self.assertEqual(theme_changed_spy[-1][0], 'theme1')
self.assertEqual(len(themes_changed_spy), 2)
# update
collection.update('theme1', record)
self.assertEqual(len(theme_changed_spy), 3)
self.assertEqual(theme_changed_spy[-1][0], 'theme1')
self.assertEqual(len(themes_changed_spy), 3)
# remove invalid
collection.removeMapTheme(
'i wish i was a slave to an age old trade... like riding around on rail cars and working long days'
)
self.assertEqual(len(theme_changed_spy), 3)
self.assertEqual(len(themes_changed_spy), 3)
# remove valid
collection.removeMapTheme('theme1')
self.assertEqual(len(theme_changed_spy), 3) # not changed - removed!
self.assertEqual(len(themes_changed_spy), 4)
# reinsert
collection.insert('theme1', record)
self.assertEqual(len(theme_changed_spy), 4)
self.assertEqual(len(themes_changed_spy), 5)
# clear
collection.clear()
self.assertEqual(len(theme_changed_spy), 4) # not changed - removed!
self.assertEqual(len(themes_changed_spy), 6)
# check that mapThemeChanged is emitted if layer is removed
layer = QgsVectorLayer("Point?field=fldtxt:string", "layer1", "memory")
layer2 = QgsVectorLayer("Point?field=fldtxt:string", "layer2",
"memory")
project.addMapLayers([layer, layer2])
# record for layer1
record.addLayerRecord(QgsMapThemeCollection.MapThemeLayerRecord(layer))
collection.insert('theme1', record)
self.assertEqual(len(theme_changed_spy), 5)
self.assertEqual(len(themes_changed_spy), 7)
# now kill layer 2
project.removeMapLayer(layer2)
self.assertEqual(
len(theme_changed_spy),
5) # signal should not be emitted - layer is not in record
# now kill layer 1
project.removeMapLayer(layer)
app.processEvents()
self.assertEqual(len(theme_changed_spy),
6) # signal should be emitted - layer is in record
def testLegendRenderWithMapTheme(self):
"""Test rendering legends linked to map themes"""
QgsProject.instance().removeAllMapLayers()
point_path = os.path.join(TEST_DATA_DIR, 'points.shp')
point_layer = QgsVectorLayer(point_path, 'points', 'ogr')
line_path = os.path.join(TEST_DATA_DIR, 'lines.shp')
line_layer = QgsVectorLayer(line_path, 'lines', 'ogr')
QgsProject.instance().clear()
QgsProject.instance().addMapLayers([point_layer, line_layer])
marker_symbol = QgsMarkerSymbol.createSimple({'color': '#ff0000', 'outline_style': 'no', 'size': '5'})
point_layer.setRenderer(QgsSingleSymbolRenderer(marker_symbol))
point_layer.styleManager().addStyleFromLayer("red")
line_symbol = QgsLineSymbol.createSimple({'color': '#ff0000', 'line_width': '2'})
line_layer.setRenderer(QgsSingleSymbolRenderer(line_symbol))
line_layer.styleManager().addStyleFromLayer("red")
red_record = QgsMapThemeCollection.MapThemeRecord()
point_red_record = QgsMapThemeCollection.MapThemeLayerRecord(point_layer)
point_red_record.usingCurrentStyle = True
point_red_record.currentStyle = 'red'
red_record.addLayerRecord(point_red_record)
line_red_record = QgsMapThemeCollection.MapThemeLayerRecord(line_layer)
line_red_record.usingCurrentStyle = True
line_red_record.currentStyle = 'red'
red_record.addLayerRecord(line_red_record)
QgsProject.instance().mapThemeCollection().insert('red', red_record)
marker_symbol1 = QgsMarkerSymbol.createSimple({'color': '#0000ff', 'outline_style': 'no', 'size': '5'})
marker_symbol2 = QgsMarkerSymbol.createSimple(
{'color': '#0000ff', 'name': 'diamond', 'outline_style': 'no', 'size': '5'})
marker_symbol3 = QgsMarkerSymbol.createSimple(
{'color': '#0000ff', 'name': 'rectangle', 'outline_style': 'no', 'size': '5'})
point_layer.setRenderer(QgsCategorizedSymbolRenderer('Class', [QgsRendererCategory('B52', marker_symbol1, ''),
QgsRendererCategory('Biplane', marker_symbol2,
''),
QgsRendererCategory('Jet', marker_symbol3, ''),
]))
point_layer.styleManager().addStyleFromLayer("blue")
line_symbol = QgsLineSymbol.createSimple({'color': '#0000ff', 'line_width': '2'})
line_layer.setRenderer(QgsSingleSymbolRenderer(line_symbol))
line_layer.styleManager().addStyleFromLayer("blue")
blue_record = QgsMapThemeCollection.MapThemeRecord()
point_blue_record = QgsMapThemeCollection.MapThemeLayerRecord(point_layer)
point_blue_record.usingCurrentStyle = True
point_blue_record.currentStyle = 'blue'
blue_record.addLayerRecord(point_blue_record)
line_blue_record = QgsMapThemeCollection.MapThemeLayerRecord(line_layer)
line_blue_record.usingCurrentStyle = True
line_blue_record.currentStyle = 'blue'
blue_record.addLayerRecord(line_blue_record)
QgsProject.instance().mapThemeCollection().insert('blue', blue_record)
layout = QgsLayout(QgsProject.instance())
layout.initializeDefaults()
map1 = QgsLayoutItemMap(layout)
map1.attemptSetSceneRect(QRectF(20, 20, 80, 80))
map1.setFrameEnabled(True)
map1.setLayers([point_layer, line_layer])
layout.addLayoutItem(map1)
map1.setExtent(point_layer.extent())
map1.setFollowVisibilityPreset(True)
map1.setFollowVisibilityPresetName('red')
map2 = QgsLayoutItemMap(layout)
map2.attemptSetSceneRect(QRectF(20, 120, 80, 80))
map2.setFrameEnabled(True)
map2.setLayers([point_layer, line_layer])
layout.addLayoutItem(map2)
map2.setExtent(point_layer.extent())
map2.setFollowVisibilityPreset(True)
map2.setFollowVisibilityPresetName('blue')
legend = QgsLayoutItemLegend(layout)
legend.setTitle("Legend")
legend.attemptSetSceneRect(QRectF(120, 20, 80, 80))
legend.setFrameEnabled(True)
legend.setFrameStrokeWidth(QgsLayoutMeasurement(2))
legend.setBackgroundColor(QColor(200, 200, 200))
legend.setTitle('')
layout.addLayoutItem(legend)
legend.setLinkedMap(map1)
legend2 = QgsLayoutItemLegend(layout)
legend2.setTitle("Legend")
legend2.attemptSetSceneRect(QRectF(120, 120, 80, 80))
legend2.setFrameEnabled(True)
legend2.setFrameStrokeWidth(QgsLayoutMeasurement(2))
legend2.setBackgroundColor(QColor(200, 200, 200))
legend2.setTitle('')
layout.addLayoutItem(legend2)
legend2.setLinkedMap(map2)
checker = QgsLayoutChecker(
'composer_legend_theme', layout)
checker.setControlPathPrefix("composer_legend")
result, message = checker.testLayout()
TestQgsLayoutItemLegend.report += checker.report()
self.assertTrue(result, message)
QgsProject.instance().clear()
def makeAtlas(qptChapter,
qptDivision,
qptForm,
zl_layer,
zl_field,
di_layer,
di_field,
di_name,
scale,
form_file=None,
form=False,
project_name='',
root_out='',
pbar=False,
isTest=True):
root_code = os.path.dirname(os.path.realpath(__file__))
## getpapersize
template_file = open(qptDivision, 'r')
template_content = template_file.read()
template_file.close()
document = QDomDocument()
document.setContent(template_content)
p = QgsProject().instance()
composition = QgsLayout(p)
composition.loadFromTemplate(document, QgsReadWriteContext())
map_item = composition.itemById('mapa')
paper = [
map_item.sizeWithUnits().width(),
map_item.sizeWithUnits().height()
]
##get visible layers
visibleLayers = p.mapThemeCollection().masterVisibleLayers()
## get project srid...
crs = zl_layer.dataProvider().sourceCrs().authid()
## zones 1 layer
zvl = zl_layer.clone()
global ZVL
ZVL = zvl.id()
QgsProject.instance().addMapLayer(zvl)
#pr = zvl.dataProvider()
QgsProject.instance().mapLayer(ZVL).loadNamedStyle(
root_code + '/templates/layerstyles/zones.qml')
## divisions 1 layer
dvl = QgsVectorLayer("Polygon?crs=" + crs, "divisions_layer", "memory")
global DVL
DVL = dvl.id()
QgsProject.instance().addMapLayer(dvl)
#pr = dvl.dataProvider()
QgsProject.instance().mapLayer(DVL).startEditing()
QgsProject.instance().mapLayer(DVL).loadNamedStyle(
root_code + '/templates/layerstyles/div1.qml')
pr_dvl = QgsProject.instance().mapLayer(DVL).dataProvider()
pr_dvl.addAttributes([
QgsField('id', QVariant.String),
QgsField('name', QVariant.String),
QgsField('ang', QVariant.String),
QgsField('x', QVariant.String),
QgsField('y', QVariant.String),
])
QgsProject.instance().mapLayer(DVL).commitChanges()
## divisions 2 layer
dvl2 = QgsVectorLayer("Polygon?crs=" + crs, "divisions_layer", "memory")
global DVL2
DVL2 = dvl2.id()
QgsProject.instance().addMapLayer(dvl2)
#pr = dvl2.dataProvider()
QgsProject.instance().mapLayer(DVL2).startEditing()
QgsProject.instance().mapLayer(DVL2).loadNamedStyle(
root_code + '/templates/layerstyles/div2.qml')
pr_dvl2 = QgsProject.instance().mapLayer(DVL2).dataProvider()
pr_dvl2.addAttributes([
QgsField('id', QVariant.String),
QgsField('name', QVariant.String),
QgsField('ang', QVariant.String),
QgsField('x', QVariant.String),
QgsField('y', QVariant.String),
])
QgsProject.instance().mapLayer(DVL2).commitChanges()
debug('>> layers setted')
##makestyles::
p = QgsProject.instance()
#_zona_big
p.mapThemeCollection().removeMapTheme('_zona_big')
rec = QgsMapThemeCollection().MapThemeRecord()
recList = []
vl = visibleLayers
for v in vl:
recList.append(QgsMapThemeCollection().MapThemeLayerRecord(v))
recList.append(QgsMapThemeCollection().MapThemeLayerRecord(zvl))
recList.append(QgsMapThemeCollection().MapThemeLayerRecord(dvl))
recList.append(QgsMapThemeCollection().MapThemeLayerRecord(dvl2))
rec.setLayerRecords(recList)
p.mapThemeCollection().insert('_zona_big', rec)
#_zona_small
p.mapThemeCollection().removeMapTheme('_zona_small')
rec = QgsMapThemeCollection().MapThemeRecord()
recList = []
vl = visibleLayers
for v in vl:
recList.append(QgsMapThemeCollection().MapThemeLayerRecord(v))
if di_layer not in vl:
recList.append(QgsMapThemeCollection().MapThemeLayerRecord(di_layer))
recList.append(QgsMapThemeCollection().MapThemeLayerRecord(zvl))
rec.setLayerRecords(recList)
p.mapThemeCollection().insert('_zona_small', rec)
#_szona_big
p.mapThemeCollection().removeMapTheme('_szona_big')
rec = QgsMapThemeCollection().MapThemeRecord()
recList = []
vl = visibleLayers
for v in vl:
recList.append(QgsMapThemeCollection().MapThemeLayerRecord(v))
if di_layer not in vl:
recList.append(QgsMapThemeCollection().MapThemeLayerRecord(di_layer))
recList.append(QgsMapThemeCollection().MapThemeLayerRecord(zvl))
rec.setLayerRecords(recList)
p.mapThemeCollection().insert('_szona_big', rec)
#_szona_small
p.mapThemeCollection().removeMapTheme('_szona_small')
rec = QgsMapThemeCollection().MapThemeRecord()
recList = []
vl = visibleLayers
for v in vl:
recList.append(QgsMapThemeCollection().MapThemeLayerRecord(v))
if di_layer not in vl:
recList.append(QgsMapThemeCollection().MapThemeLayerRecord(di_layer))
recList.append(QgsMapThemeCollection().MapThemeLayerRecord(zvl))
recList.append(QgsMapThemeCollection().MapThemeLayerRecord(dvl))
recList.append(QgsMapThemeCollection().MapThemeLayerRecord(dvl2))
rec.setLayerRecords(recList)
p.mapThemeCollection().insert('_szona_small', rec)
global mapL
mapLmake()
##se puede agilizar
#Lz = zl_layer #QgsProject.instance().mapLayer(mapL['zones'])
#Lb = QgsProject.instance().mapLayer(mapL['bounds'])
#Ld = QgsProject.instance().mapLayer(mapL['divisions'])
###########################################################################
x = 0
global pag
pag = 1
#for b in Lb.getFeatures():
fr = 0
zones_f = [zzz for zzz in zl_layer.getFeatures()]
if pbar:
pbar.setValue(1)
for b in zones_f:
if pbar:
pbar.setValue(100 / len(zones_f) * fr)
fr += 1
debug('>>>> chapter: ')
debug(b.attributes())
#isTest
#self.dlg.progressBar.setValue(int(10))
szs = getSubzones(b, paper, scale)
mkChapter(b, qptChapter, project_name, root_out, zl_layer, zl_field,
di_layer, di_field, di_name)
szfr = 0
for sz in szs:
szfr += 1
if pbar:
pbar.setValue(100 / len(zones_f) * fr +
100 / len(zones_f) / len(szs) * szfr)
debug('>>>> division: ')
mkDiv(sz, b.geometry(), qptDivision, project_name, root_out,
zl_layer, zl_field, di_layer, di_field, di_name)
if form:
mkForm(sz, qptForm, form_file, project_name, root_out,
zl_layer, zl_field, di_layer, di_field, di_name)
if isTest:
break
if isTest:
break
x += 1
#emptyTemp()
# #remove styles
p.mapThemeCollection().removeMapTheme('_zona_big')
p.mapThemeCollection().removeMapTheme('_zona_small')
p.mapThemeCollection().removeMapTheme('_szona_big')
p.mapThemeCollection().removeMapTheme('_szona_small')
#remove layers
QgsProject.instance().removeMapLayer(ZVL)
QgsProject.instance().removeMapLayer(DVL)
QgsProject.instance().removeMapLayer(DVL2)
debug('end')
return
