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 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()