def testAddComposition(self):
project = QgsProject()
composition = QgsComposition(project)
composition.setName('test composition')
manager = QgsLayoutManager(project)
composition_about_to_be_added_spy = QSignalSpy(manager.compositionAboutToBeAdded)
composition_added_spy = QSignalSpy(manager.compositionAdded)
self.assertTrue(manager.addComposition(composition))
self.assertEqual(len(composition_about_to_be_added_spy), 1)
self.assertEqual(composition_about_to_be_added_spy[0][0], 'test composition')
self.assertEqual(len(composition_added_spy), 1)
self.assertEqual(composition_added_spy[0][0], 'test composition')
# adding it again should fail
self.assertFalse(manager.addComposition(composition))
# try adding a second composition
composition2 = QgsComposition(project)
composition2.setName('test composition2')
self.assertTrue(manager.addComposition(composition2))
self.assertEqual(len(composition_added_spy), 2)
self.assertEqual(composition_about_to_be_added_spy[1][0], 'test composition2')
self.assertEqual(len(composition_about_to_be_added_spy), 2)
self.assertEqual(composition_added_spy[1][0], 'test composition2')
# adding a composition with duplicate name should fail
composition3 = QgsComposition(project)
composition3.setName('test composition2')
self.assertFalse(manager.addComposition(composition3))
def testReadWriteXml(self):
"""
Test reading and writing layout manager state to XML
"""
project = QgsProject()
manager = QgsLayoutManager(project)
# add a bunch of layouts
layout = QgsPrintLayout(project)
layout.setName('test layout')
layout2 = QgsPrintLayout(project)
layout2.setName('test layout2')
layout3 = QgsPrintLayout(project)
layout3.setName('test layout3')
manager.addLayout(layout)
manager.addLayout(layout2)
manager.addLayout(layout3)
# save to xml
doc = QDomDocument("testdoc")
elem = manager.writeXml(doc)
doc.appendChild(elem)
# restore from xml
project2 = QgsProject()
manager2 = QgsLayoutManager(project2)
self.assertTrue(manager2.readXml(elem, doc))
self.assertEqual(len(manager2.layouts()), 3)
names = [c.name() for c in manager2.layouts()]
self.assertCountEqual(names, ['test layout', 'test layout2', 'test layout3'])
def testAddLayout(self):
project = QgsProject()
layout = QgsPrintLayout(project)
layout.setName('test layout')
manager = QgsLayoutManager(project)
layout_about_to_be_added_spy = QSignalSpy(manager.layoutAboutToBeAdded)
layout_added_spy = QSignalSpy(manager.layoutAdded)
self.assertTrue(manager.addLayout(layout))
self.assertEqual(len(layout_about_to_be_added_spy), 1)
self.assertEqual(layout_about_to_be_added_spy[0][0], 'test layout')
self.assertEqual(len(layout_added_spy), 1)
self.assertEqual(layout_added_spy[0][0], 'test layout')
# adding it again should fail
self.assertFalse(manager.addLayout(layout))
# try adding a second layout
layout2 = QgsPrintLayout(project)
layout2.setName('test layout2')
self.assertTrue(manager.addLayout(layout2))
self.assertEqual(len(layout_added_spy), 2)
self.assertEqual(layout_about_to_be_added_spy[1][0], 'test layout2')
self.assertEqual(len(layout_about_to_be_added_spy), 2)
self.assertEqual(layout_added_spy[1][0], 'test layout2')
# adding a layout with duplicate name should fail
layout3 = QgsPrintLayout(project)
layout3.setName('test layout2')
self.assertFalse(manager.addLayout(layout3))
def testReadWriteXml(self):
"""
Test reading and writing layout manager state to XML
"""
project = QgsProject()
manager = QgsLayoutManager(project)
# add a bunch of compositions
composition = QgsComposition(project)
composition.setName('test composition')
composition2 = QgsComposition(project)
composition2.setName('test composition2')
composition3 = QgsComposition(project)
composition3.setName('test composition3')
manager.addComposition(composition)
manager.addComposition(composition2)
manager.addComposition(composition3)
# save to xml
doc = QDomDocument("testdoc")
elem = manager.writeXml(doc)
doc.appendChild(elem)
# restore from xml
project2 = QgsProject()
manager2 = QgsLayoutManager(project2)
self.assertTrue(manager2.readXml(elem, doc))
self.assertEqual(len(manager2.compositions()), 3)
names = [c.name() for c in manager2.compositions()]
self.assertEqual(set(names), {'test composition', 'test composition2', 'test composition3'})
def testCombo(self):
project = QgsProject()
manager = QgsLayoutManager(project)
layout = QgsPrintLayout(project)
layout.setName('ccc')
self.assertTrue(manager.addLayout(layout))
layout2 = QgsPrintLayout(project)
layout2.setName('bbb')
self.assertTrue(manager.addLayout(layout2))
r = QgsReport(project)
r.setName('ddd')
manager.addLayout(r)
combo = QgsLayoutComboBox(None, manager)
spy = QSignalSpy(combo.layoutChanged)
self.assertEqual(combo.count(), 3)
self.assertEqual(combo.itemText(0), 'bbb')
self.assertEqual(combo.itemText(1), 'ccc')
self.assertEqual(combo.itemText(2), 'ddd')
self.assertEqual(combo.layout(0), layout2)
self.assertEqual(combo.layout(1), layout)
self.assertEqual(combo.layout(2), r)
combo.setCurrentLayout(None)
self.assertEqual(combo.currentLayout(), None)
self.assertEqual(len(spy), 1)
combo.setCurrentLayout(layout)
self.assertEqual(combo.currentLayout(), layout)
self.assertEqual(len(spy), 2)
combo.setCurrentLayout(r)
self.assertEqual(combo.currentLayout(), r)
self.assertEqual(len(spy), 3)
combo.setCurrentLayout(layout2)
self.assertEqual(combo.currentLayout(), layout2)
self.assertEqual(len(spy), 4)
combo.setAllowEmptyLayout(True)
self.assertEqual(combo.count(), 4)
self.assertEqual(combo.itemText(0), '')
self.assertEqual(combo.itemText(1), 'bbb')
self.assertEqual(combo.itemText(2), 'ccc')
self.assertEqual(combo.itemText(3), 'ddd')
combo.setCurrentLayout(None)
self.assertEqual(combo.currentIndex(), 0)
combo.setFilters(QgsLayoutManagerProxyModel.FilterPrintLayouts)
self.assertEqual(combo.count(), 3)
self.assertEqual(combo.itemText(0), '')
self.assertEqual(combo.itemText(1), 'bbb')
self.assertEqual(combo.itemText(2), 'ccc')
combo.setFilters(QgsLayoutManagerProxyModel.FilterReports)
self.assertEqual(combo.filters(), QgsLayoutManagerProxyModel.FilterReports)
self.assertEqual(combo.count(), 2)
self.assertEqual(combo.itemText(0), '')
self.assertEqual(combo.itemText(1), 'ddd')
def testSaveAsTemplate(self):
"""
Test saving composition as template
"""
project = QgsProject()
manager = QgsLayoutManager(project)
doc = QDomDocument("testdoc")
self.assertFalse(manager.saveAsTemplate('not in manager', doc))
composition = QgsComposition(project)
composition.setName('test composition')
manager.addComposition(composition)
self.assertTrue(manager.saveAsTemplate('test composition', doc))
def testLayouts(self):
project = QgsProject()
manager = QgsLayoutManager(project)
layout = QgsPrintLayout(project)
layout.setName('test layout')
layout2 = QgsPrintLayout(project)
layout2.setName('test layout2')
layout3 = QgsPrintLayout(project)
layout3.setName('test layout3')
manager.addLayout(layout)
self.assertEqual(manager.layouts(), [layout])
manager.addLayout(layout2)
self.assertEqual(set(manager.layouts()), {layout, layout2})
manager.addLayout(layout3)
self.assertEqual(set(manager.layouts()), {layout, layout2, layout3})
def testCompositions(self):
project = QgsProject()
manager = QgsLayoutManager(project)
composition = QgsComposition(project)
composition.setName('test composition')
composition2 = QgsComposition(project)
composition2.setName('test composition2')
composition3 = QgsComposition(project)
composition3.setName('test composition3')
manager.addComposition(composition)
self.assertEqual(manager.compositions(), [composition])
manager.addComposition(composition2)
self.assertEqual(set(manager.compositions()), {composition, composition2})
manager.addComposition(composition3)
self.assertEqual(set(manager.compositions()), {composition, composition2, composition3})
def testRemoveLayout(self):
project = QgsProject()
layout = QgsPrintLayout(project)
layout.setName('test layout')
self.manager = QgsLayoutManager(project)
layout_removed_spy = QSignalSpy(self.manager.layoutRemoved)
layout_about_to_be_removed_spy = QSignalSpy(self.manager.layoutAboutToBeRemoved)
# tests that layout still exists when layoutAboutToBeRemoved is fired
self.manager.layoutAboutToBeRemoved.connect(self.layoutAboutToBeRemoved)
# not added, should fail
self.assertFalse(self.manager.removeLayout(layout))
self.assertEqual(len(layout_removed_spy), 0)
self.assertEqual(len(layout_about_to_be_removed_spy), 0)
self.assertTrue(self.manager.addLayout(layout))
self.assertEqual(self.manager.layouts(), [layout])
self.assertTrue(self.manager.removeLayout(layout))
self.assertEqual(len(self.manager.layouts()), 0)
self.assertEqual(len(layout_removed_spy), 1)
self.assertEqual(layout_removed_spy[0][0], 'test layout')
self.assertEqual(len(layout_about_to_be_removed_spy), 1)
self.assertEqual(layout_about_to_be_removed_spy[0][0], 'test layout')
self.assertTrue(self.aboutFired)
self.manager = None
def testRemoveComposition(self):
project = QgsProject()
composition = QgsComposition(project)
composition.setName('test composition')
self.manager = QgsLayoutManager(project)
composition_removed_spy = QSignalSpy(self.manager.compositionRemoved)
composition_about_to_be_removed_spy = QSignalSpy(self.manager.compositionAboutToBeRemoved)
# tests that composition still exists when compositionAboutToBeRemoved is fired
self.manager.compositionAboutToBeRemoved.connect(self.aboutToBeRemoved)
# not added, should fail
self.assertFalse(self.manager.removeComposition(composition))
self.assertEqual(len(composition_removed_spy), 0)
self.assertEqual(len(composition_about_to_be_removed_spy), 0)
self.assertTrue(self.manager.addComposition(composition))
self.assertEqual(self.manager.compositions(), [composition])
self.assertTrue(self.manager.removeComposition(composition))
self.assertEqual(len(self.manager.compositions()), 0)
self.assertEqual(len(composition_removed_spy), 1)
self.assertEqual(composition_removed_spy[0][0], 'test composition')
self.assertEqual(len(composition_about_to_be_removed_spy), 1)
self.assertEqual(composition_about_to_be_removed_spy[0][0], 'test composition')
self.assertTrue(self.aboutFired)
self.manager = None
def testRenameSignal(self):
project = QgsProject()
manager = QgsLayoutManager(project)
layout = QgsPrintLayout(project)
layout.setName('c1')
manager.addLayout(layout)
layout2 = QgsPrintLayout(project)
layout2.setName('c2')
manager.addLayout(layout2)
layout_renamed_spy = QSignalSpy(manager.layoutRenamed)
layout.setName('d1')
self.assertEqual(len(layout_renamed_spy), 1)
# self.assertEqual(layout_renamed_spy[0][0], layout)
self.assertEqual(layout_renamed_spy[0][1], 'd1')
layout2.setName('d2')
self.assertEqual(len(layout_renamed_spy), 2)
# self.assertEqual(layout_renamed_spy[1][0], layout2)
self.assertEqual(layout_renamed_spy[1][1], 'd2')
def testRenameSignal(self):
project = QgsProject()
manager = QgsLayoutManager(project)
composition = QgsComposition(project)
composition.setName('c1')
manager.addComposition(composition)
composition2 = QgsComposition(project)
composition2.setName('c2')
manager.addComposition(composition2)
composition_renamed_spy = QSignalSpy(manager.compositionRenamed)
composition.setName('d1')
self.assertEqual(len(composition_renamed_spy), 1)
self.assertEqual(composition_renamed_spy[0][0], composition)
self.assertEqual(composition_renamed_spy[0][1], 'd1')
composition2.setName('d2')
self.assertEqual(len(composition_renamed_spy), 2)
self.assertEqual(composition_renamed_spy[1][0], composition2)
self.assertEqual(composition_renamed_spy[1][1], 'd2')
def testLayoutsByName(self):
project = QgsProject()
manager = QgsLayoutManager(project)
# add a bunch of layouts
layout = QgsPrintLayout(project)
layout.setName('test layout')
layout2 = QgsPrintLayout(project)
layout2.setName('test layout2')
layout3 = QgsPrintLayout(project)
layout3.setName('test layout3')
manager.addLayout(layout)
manager.addLayout(layout2)
manager.addLayout(layout3)
self.assertFalse(manager.layoutByName('asdf'))
self.assertEqual(manager.layoutByName('test layout'), layout)
self.assertEqual(manager.layoutByName('test layout2'), layout2)
self.assertEqual(manager.layoutByName('test layout3'), layout3)
def testCompositionByName(self):
project = QgsProject()
manager = QgsLayoutManager(project)
# add a bunch of compositions
composition = QgsComposition(project)
composition.setName('test composition')
composition2 = QgsComposition(project)
composition2.setName('test composition2')
composition3 = QgsComposition(project)
composition3.setName('test composition3')
manager.addComposition(composition)
manager.addComposition(composition2)
manager.addComposition(composition3)
self.assertFalse(manager.compositionByName('asdf'))
self.assertEqual(manager.compositionByName('test composition'), composition)
self.assertEqual(manager.compositionByName('test composition2'), composition2)
self.assertEqual(manager.compositionByName('test composition3'), composition3)
def testClear(self):
project = QgsProject()
manager = QgsLayoutManager(project)
# add a bunch of compositions
composition = QgsComposition(project)
composition.setName('test composition')
composition2 = QgsComposition(project)
composition2.setName('test composition2')
composition3 = QgsComposition(project)
composition3.setName('test composition3')
manager.addComposition(composition)
manager.addComposition(composition2)
manager.addComposition(composition3)
composition_removed_spy = QSignalSpy(manager.compositionRemoved)
composition_about_to_be_removed_spy = QSignalSpy(manager.compositionAboutToBeRemoved)
manager.clear()
self.assertEqual(len(manager.compositions()), 0)
self.assertEqual(len(composition_removed_spy), 3)
self.assertEqual(len(composition_about_to_be_removed_spy), 3)
def testClear(self):
project = QgsProject()
manager = QgsLayoutManager(project)
# add a bunch of layouts
layout = QgsPrintLayout(project)
layout.setName('test layout')
layout2 = QgsPrintLayout(project)
layout2.setName('test layout2')
layout3 = QgsPrintLayout(project)
layout3.setName('test layout3')
manager.addLayout(layout)
manager.addLayout(layout2)
manager.addLayout(layout3)
layout_removed_spy = QSignalSpy(manager.layoutRemoved)
layout_about_to_be_removed_spy = QSignalSpy(manager.layoutAboutToBeRemoved)
manager.clear()
self.assertEqual(len(manager.layouts()), 0)
self.assertEqual(len(layout_removed_spy), 3)
self.assertEqual(len(layout_about_to_be_removed_spy), 3)
def testDuplicateLayout(self):
"""
Test duplicating layouts
"""
project = QgsProject()
manager = QgsLayoutManager(project)
doc = QDomDocument("testdoc")
self.assertFalse(manager.duplicateLayout(None, 'dest'))
layout = QgsPrintLayout(project)
layout.setName('test layout')
layout.initializeDefaults()
manager.addLayout(layout)
# duplicate name
self.assertFalse(manager.duplicateLayout(layout, 'test layout'))
result = manager.duplicateLayout(layout, 'dupe layout')
self.assertTrue(result)
# make sure result in stored in manager
self.assertEqual(result, manager.layoutByName('dupe layout'))
self.assertEqual(result.name(), 'dupe layout')
self.assertEqual(result.pageCollection().pageCount(), 1)
def testDuplicateComposition(self):
"""
Test duplicating compositions
"""
project = QgsProject()
manager = QgsLayoutManager(project)
doc = QDomDocument("testdoc")
self.assertFalse(manager.duplicateComposition('not in manager', 'dest'))
composition = QgsComposition(project)
composition.setName('test composition')
composition.setPaperSize(100, 200)
manager.addComposition(composition)
# duplicate name
self.assertFalse(manager.duplicateComposition('test composition', 'test composition'))
result = manager.duplicateComposition('test composition', 'dupe composition')
self.assertTrue(result)
# make sure result in stored in manager
self.assertEqual(result, manager.compositionByName('dupe composition'))
self.assertEqual(result.name(), 'dupe composition')
self.assertEqual(result.paperHeight(), 200)
self.assertEqual(result.paperWidth(), 100)
class TestQgsLayoutManager(unittest.TestCase):
def setUp(self):
"""Run before each test."""
self.manager = None
self.aboutFired = False
def tearDown(self):
"""Run after each test."""
pass
def testAddLayout(self):
project = QgsProject()
layout = QgsPrintLayout(project)
layout.setName('test layout')
manager = QgsLayoutManager(project)
layout_about_to_be_added_spy = QSignalSpy(manager.layoutAboutToBeAdded)
layout_added_spy = QSignalSpy(manager.layoutAdded)
self.assertTrue(manager.addLayout(layout))
self.assertEqual(len(layout_about_to_be_added_spy), 1)
self.assertEqual(layout_about_to_be_added_spy[0][0], 'test layout')
self.assertEqual(len(layout_added_spy), 1)
self.assertEqual(layout_added_spy[0][0], 'test layout')
# adding it again should fail
self.assertFalse(manager.addLayout(layout))
# try adding a second layout
layout2 = QgsPrintLayout(project)
layout2.setName('test layout2')
self.assertTrue(manager.addLayout(layout2))
self.assertEqual(len(layout_added_spy), 2)
self.assertEqual(layout_about_to_be_added_spy[1][0], 'test layout2')
self.assertEqual(len(layout_about_to_be_added_spy), 2)
self.assertEqual(layout_added_spy[1][0], 'test layout2')
# adding a layout with duplicate name should fail
layout3 = QgsPrintLayout(project)
layout3.setName('test layout2')
self.assertFalse(manager.addLayout(layout3))
def testLayouts(self):
project = QgsProject()
manager = QgsLayoutManager(project)
layout = QgsPrintLayout(project)
layout.setName('test layout')
layout2 = QgsPrintLayout(project)
layout2.setName('test layout2')
layout3 = QgsPrintLayout(project)
layout3.setName('test layout3')
manager.addLayout(layout)
self.assertEqual(manager.layouts(), [layout])
manager.addLayout(layout2)
self.assertEqual(set(manager.layouts()), {layout, layout2})
manager.addLayout(layout3)
self.assertEqual(set(manager.layouts()), {layout, layout2, layout3})
def aboutToBeRemoved(self, name):
# composition should still exist at this time
self.assertEqual(name, 'test composition')
self.assertTrue(self.manager.compositionByName('test composition'))
self.aboutFired = True
def layoutAboutToBeRemoved(self, name):
# layout should still exist at this time
self.assertEqual(name, 'test layout')
self.assertTrue(self.manager.layoutByName('test layout'))
self.aboutFired = True
def testRemoveLayout(self):
project = QgsProject()
layout = QgsPrintLayout(project)
layout.setName('test layout')
self.manager = QgsLayoutManager(project)
layout_removed_spy = QSignalSpy(self.manager.layoutRemoved)
layout_about_to_be_removed_spy = QSignalSpy(
self.manager.layoutAboutToBeRemoved)
# tests that layout still exists when layoutAboutToBeRemoved is fired
self.manager.layoutAboutToBeRemoved.connect(
self.layoutAboutToBeRemoved)
# not added, should fail
self.assertFalse(self.manager.removeLayout(layout))
self.assertEqual(len(layout_removed_spy), 0)
self.assertEqual(len(layout_about_to_be_removed_spy), 0)
self.assertTrue(self.manager.addLayout(layout))
self.assertEqual(self.manager.layouts(), [layout])
self.assertTrue(self.manager.removeLayout(layout))
self.assertEqual(len(self.manager.layouts()), 0)
self.assertEqual(len(layout_removed_spy), 1)
self.assertEqual(layout_removed_spy[0][0], 'test layout')
self.assertEqual(len(layout_about_to_be_removed_spy), 1)
self.assertEqual(layout_about_to_be_removed_spy[0][0], 'test layout')
self.assertTrue(self.aboutFired)
self.manager = None
def testClear(self):
project = QgsProject()
manager = QgsLayoutManager(project)
# add a bunch of layouts
layout = QgsPrintLayout(project)
layout.setName('test layout')
layout2 = QgsPrintLayout(project)
layout2.setName('test layout2')
layout3 = QgsPrintLayout(project)
layout3.setName('test layout3')
manager.addLayout(layout)
manager.addLayout(layout2)
manager.addLayout(layout3)
layout_removed_spy = QSignalSpy(manager.layoutRemoved)
layout_about_to_be_removed_spy = QSignalSpy(
manager.layoutAboutToBeRemoved)
manager.clear()
self.assertEqual(len(manager.layouts()), 0)
self.assertEqual(len(layout_removed_spy), 3)
self.assertEqual(len(layout_about_to_be_removed_spy), 3)
def testLayoutsByName(self):
project = QgsProject()
manager = QgsLayoutManager(project)
# add a bunch of layouts
layout = QgsPrintLayout(project)
layout.setName('test layout')
layout2 = QgsPrintLayout(project)
layout2.setName('test layout2')
layout3 = QgsPrintLayout(project)
layout3.setName('test layout3')
manager.addLayout(layout)
manager.addLayout(layout2)
manager.addLayout(layout3)
self.assertFalse(manager.layoutByName('asdf'))
self.assertEqual(manager.layoutByName('test layout'), layout)
self.assertEqual(manager.layoutByName('test layout2'), layout2)
self.assertEqual(manager.layoutByName('test layout3'), layout3)
def testReadWriteXml(self):
"""
Test reading and writing layout manager state to XML
"""
project = QgsProject()
manager = QgsLayoutManager(project)
# add a bunch of layouts
layout = QgsPrintLayout(project)
layout.setName('test layout')
layout2 = QgsPrintLayout(project)
layout2.setName('test layout2')
layout3 = QgsPrintLayout(project)
layout3.setName('test layout3')
manager.addLayout(layout)
manager.addLayout(layout2)
manager.addLayout(layout3)
# save to xml
doc = QDomDocument("testdoc")
elem = manager.writeXml(doc)
doc.appendChild(elem)
# restore from xml
project2 = QgsProject()
manager2 = QgsLayoutManager(project2)
self.assertTrue(manager2.readXml(elem, doc))
self.assertEqual(len(manager2.layouts()), 3)
names = [c.name() for c in manager2.layouts()]
self.assertCountEqual(names,
['test layout', 'test layout2', 'test layout3'])
def testDuplicateLayout(self):
"""
Test duplicating layouts
"""
project = QgsProject()
manager = QgsLayoutManager(project)
doc = QDomDocument("testdoc")
self.assertFalse(manager.duplicateLayout(None, 'dest'))
layout = QgsPrintLayout(project)
layout.setName('test layout')
layout.initializeDefaults()
manager.addLayout(layout)
# duplicate name
self.assertFalse(manager.duplicateLayout(layout, 'test layout'))
result = manager.duplicateLayout(layout, 'dupe layout')
self.assertTrue(result)
# make sure result in stored in manager
self.assertEqual(result, manager.layoutByName('dupe layout'))
self.assertEqual(result.name(), 'dupe layout')
self.assertEqual(result.pageCollection().pageCount(), 1)
def testGenerateUniqueTitle(self):
project = QgsProject()
manager = QgsLayoutManager(project)
self.assertEqual(
manager.generateUniqueTitle(QgsMasterLayoutInterface.PrintLayout),
'Layout 1')
self.assertEqual(
manager.generateUniqueTitle(QgsMasterLayoutInterface.Report),
'Report 1')
layout = QgsPrintLayout(project)
layout.setName(manager.generateUniqueTitle())
manager.addLayout(layout)
self.assertEqual(manager.generateUniqueTitle(), 'Layout 2')
self.assertEqual(
manager.generateUniqueTitle(QgsMasterLayoutInterface.Report),
'Report 1')
layout2 = QgsPrintLayout(project)
layout2.setName(manager.generateUniqueTitle())
manager.addLayout(layout2)
self.assertEqual(manager.generateUniqueTitle(), 'Layout 3')
report1 = QgsReport(project)
report1.setName(
manager.generateUniqueTitle(QgsMasterLayoutInterface.Report))
manager.addLayout(report1)
self.assertEqual(
manager.generateUniqueTitle(QgsMasterLayoutInterface.Report),
'Report 2')
manager.clear()
self.assertEqual(manager.generateUniqueTitle(), 'Layout 1')
self.assertEqual(
manager.generateUniqueTitle(QgsMasterLayoutInterface.Report),
'Report 1')
def testRenameSignal(self):
project = QgsProject()
manager = QgsLayoutManager(project)
layout = QgsPrintLayout(project)
layout.setName('c1')
manager.addLayout(layout)
layout2 = QgsPrintLayout(project)
layout2.setName('c2')
manager.addLayout(layout2)
layout_renamed_spy = QSignalSpy(manager.layoutRenamed)
layout.setName('d1')
self.assertEqual(len(layout_renamed_spy), 1)
# self.assertEqual(layout_renamed_spy[0][0], layout)
self.assertEqual(layout_renamed_spy[0][1], 'd1')
layout2.setName('d2')
self.assertEqual(len(layout_renamed_spy), 2)
# self.assertEqual(layout_renamed_spy[1][0], layout2)
self.assertEqual(layout_renamed_spy[1][1], 'd2')
def testGenerateUniqueTitle(self):
project = QgsProject()
manager = QgsLayoutManager(project)
self.assertEqual(manager.generateUniqueTitle(QgsMasterLayoutInterface.PrintLayout), 'Layout 1')
self.assertEqual(manager.generateUniqueTitle(QgsMasterLayoutInterface.Report), 'Report 1')
layout = QgsPrintLayout(project)
layout.setName(manager.generateUniqueTitle())
manager.addLayout(layout)
self.assertEqual(manager.generateUniqueTitle(), 'Layout 2')
self.assertEqual(manager.generateUniqueTitle(QgsMasterLayoutInterface.Report), 'Report 1')
layout2 = QgsPrintLayout(project)
layout2.setName(manager.generateUniqueTitle())
manager.addLayout(layout2)
self.assertEqual(manager.generateUniqueTitle(), 'Layout 3')
report1 = QgsReport(project)
report1.setName(manager.generateUniqueTitle(QgsMasterLayoutInterface.Report))
manager.addLayout(report1)
self.assertEqual(manager.generateUniqueTitle(QgsMasterLayoutInterface.Report), 'Report 2')
manager.clear()
self.assertEqual(manager.generateUniqueTitle(), 'Layout 1')
self.assertEqual(manager.generateUniqueTitle(QgsMasterLayoutInterface.Report), 'Report 1')
def testLayouts(self):
project = QgsProject()
manager = QgsLayoutManager(project)
layout = QgsPrintLayout(project)
layout.setName('test layout')
layout2 = QgsPrintLayout(project)
layout2.setName('test layout2')
layout3 = QgsPrintLayout(project)
layout3.setName('test layout3')
manager.addLayout(layout)
self.assertEqual(manager.layouts(), [layout])
manager.addLayout(layout2)
self.assertEqual(set(manager.layouts()), {layout, layout2})
manager.addLayout(layout3)
self.assertEqual(set(manager.layouts()), {layout, layout2, layout3})
def testGenerateUniqueTitle(self):
project = QgsProject()
manager = QgsLayoutManager(project)
self.assertEqual(manager.generateUniqueTitle(), 'Composer 1')
composition = QgsComposition(project)
composition.setName(manager.generateUniqueTitle())
manager.addComposition(composition)
self.assertEqual(manager.generateUniqueTitle(), 'Composer 2')
composition2 = QgsComposition(project)
composition2.setName(manager.generateUniqueTitle())
manager.addComposition(composition2)
self.assertEqual(manager.generateUniqueTitle(), 'Composer 3')
manager.clear()
self.assertEqual(manager.generateUniqueTitle(), 'Composer 1')
def testGenerateUniqueTitle(self):
project = QgsProject()
manager = QgsLayoutManager(project)
self.assertEqual(manager.generateUniqueTitle(), 'Layout 1')
layout = QgsLayout(project)
layout.setName(manager.generateUniqueTitle())
manager.addLayout(layout)
self.assertEqual(manager.generateUniqueTitle(), 'Layout 2')
layout2 = QgsLayout(project)
layout2.setName(manager.generateUniqueTitle())
manager.addLayout(layout2)
self.assertEqual(manager.generateUniqueTitle(), 'Layout 3')
manager.clear()
self.assertEqual(manager.generateUniqueTitle(), 'Layout 1')
def testReadWriteXml(self):
"""
Test reading and writing layout manager state to XML
"""
project = QgsProject()
manager = QgsLayoutManager(project)
# add a bunch of layouts
layout = QgsPrintLayout(project)
layout.setName('test layout')
layout2 = QgsPrintLayout(project)
layout2.setName('test layout2')
layout3 = QgsPrintLayout(project)
layout3.setName('test layout3')
manager.addLayout(layout)
manager.addLayout(layout2)
manager.addLayout(layout3)
# save to xml
doc = QDomDocument("testdoc")
elem = manager.writeXml(doc)
doc.appendChild(elem)
# restore from xml
project2 = QgsProject()
manager2 = QgsLayoutManager(project2)
self.assertTrue(manager2.readXml(elem, doc))
self.assertEqual(len(manager2.layouts()), 3)
names = [c.name() for c in manager2.layouts()]
self.assertCountEqual(names,
['test layout', 'test layout2', 'test layout3'])
def testModel(self):
project = QgsProject()
manager = QgsLayoutManager(project)
model = QgsLayoutManagerModel(manager)
self.assertEqual(model.rowCount(QModelIndex()), 0)
self.assertEqual(model.data(model.index(0, 0, QModelIndex()), Qt.DisplayRole), None)
self.assertEqual(model.data(model.index(0, 0, QModelIndex()), QgsLayoutManagerModel.LayoutRole), None)
self.assertEqual(model.layoutFromIndex(model.index(0, 0, QModelIndex())), None)
self.assertEqual(model.indexFromLayout(None), QModelIndex())
layout = QgsPrintLayout(project)
layout.setName('test layout')
self.assertEqual(model.indexFromLayout(layout), QModelIndex())
self.assertTrue(manager.addLayout(layout))
self.assertEqual(model.rowCount(QModelIndex()), 1)
self.assertEqual(model.data(model.index(0, 0, QModelIndex()), Qt.DisplayRole), 'test layout')
self.assertEqual(model.data(model.index(0, 0, QModelIndex()), QgsLayoutManagerModel.LayoutRole), layout)
self.assertEqual(model.layoutFromIndex(model.index(0, 0, QModelIndex())), layout)
self.assertEqual(model.indexFromLayout(layout), model.index(0, 0, QModelIndex()))
self.assertEqual(model.data(model.index(1, 0, QModelIndex()), Qt.DisplayRole), None)
self.assertEqual(model.data(model.index(1, 0, QModelIndex()), QgsLayoutManagerModel.LayoutRole), None)
self.assertEqual(model.layoutFromIndex(model.index(1, 0, QModelIndex())), None)
layout.setName('test Layout')
self.assertEqual(model.data(model.index(0, 0, QModelIndex()), Qt.DisplayRole), 'test Layout')
layout2 = QgsPrintLayout(project)
layout2.setName('test layout2')
self.assertTrue(manager.addLayout(layout2))
self.assertEqual(model.rowCount(QModelIndex()), 2)
self.assertEqual(model.data(model.index(0, 0, QModelIndex()), Qt.DisplayRole), 'test Layout')
self.assertEqual(model.data(model.index(0, 0, QModelIndex()), QgsLayoutManagerModel.LayoutRole), layout)
self.assertEqual(model.layoutFromIndex(model.index(0, 0, QModelIndex())), layout)
self.assertEqual(model.indexFromLayout(layout), model.index(0, 0, QModelIndex()))
self.assertEqual(model.data(model.index(1, 0, QModelIndex()), Qt.DisplayRole), 'test layout2')
self.assertEqual(model.data(model.index(1, 0, QModelIndex()), QgsLayoutManagerModel.LayoutRole), layout2)
self.assertEqual(model.layoutFromIndex(model.index(1, 0, QModelIndex())), layout2)
self.assertEqual(model.indexFromLayout(layout2), model.index(1, 0, QModelIndex()))
manager.removeLayout(layout)
self.assertEqual(model.rowCount(QModelIndex()), 1)
self.assertEqual(model.data(model.index(0, 0, QModelIndex()), Qt.DisplayRole), 'test layout2')
self.assertEqual(model.data(model.index(0, 0, QModelIndex()), QgsLayoutManagerModel.LayoutRole), layout2)
self.assertEqual(model.data(model.index(1, 0, QModelIndex()), Qt.DisplayRole), None)
self.assertEqual(model.data(model.index(1, 0, QModelIndex()), QgsLayoutManagerModel.LayoutRole), None)
self.assertEqual(model.layoutFromIndex(model.index(0, 0, QModelIndex())), layout2)
self.assertEqual(model.layoutFromIndex(model.index(1, 0, QModelIndex())), None)
self.assertEqual(model.indexFromLayout(layout2), model.index(0, 0, QModelIndex()))
manager.clear()
self.assertEqual(model.rowCount(QModelIndex()), 0)
self.assertEqual(model.data(model.index(0, 0, QModelIndex()), Qt.DisplayRole), None)
self.assertEqual(model.data(model.index(0, 0, QModelIndex()), QgsLayoutManagerModel.LayoutRole), None)
self.assertEqual(model.layoutFromIndex(model.index(0, 0, QModelIndex())), None)
# with empty row
model.setAllowEmptyLayout(True)
self.assertEqual(model.rowCount(QModelIndex()), 1)
self.assertEqual(model.data(model.index(0, 0, QModelIndex()), Qt.DisplayRole), None)
self.assertEqual(model.data(model.index(0, 0, QModelIndex()), QgsLayoutManagerModel.LayoutRole), None)
self.assertEqual(model.layoutFromIndex(model.index(0, 0, QModelIndex())), None)
layout = QgsPrintLayout(project)
layout.setName('test layout')
self.assertTrue(manager.addLayout(layout))
self.assertEqual(model.rowCount(QModelIndex()), 2)
self.assertEqual(model.data(model.index(0, 0, QModelIndex()), Qt.DisplayRole), None)
self.assertEqual(model.data(model.index(0, 0, QModelIndex()), QgsLayoutManagerModel.LayoutRole), None)
self.assertEqual(model.data(model.index(1, 0, QModelIndex()), Qt.DisplayRole), 'test layout')
self.assertEqual(model.data(model.index(1, 0, QModelIndex()), QgsLayoutManagerModel.LayoutRole), layout)
self.assertEqual(model.data(model.index(2, 0, QModelIndex()), Qt.DisplayRole), None)
self.assertEqual(model.data(model.index(2, 0, QModelIndex()), QgsLayoutManagerModel.LayoutRole), None)
self.assertEqual(model.layoutFromIndex(model.index(0, 0, QModelIndex())), None)
self.assertEqual(model.layoutFromIndex(model.index(1, 0, QModelIndex())), layout)
self.assertEqual(model.indexFromLayout(layout), model.index(1, 0, QModelIndex()))
layout2 = QgsPrintLayout(project)
layout2.setName('test layout2')
self.assertTrue(manager.addLayout(layout2))
self.assertEqual(model.rowCount(QModelIndex()), 3)
self.assertEqual(model.data(model.index(0, 0, QModelIndex()), Qt.DisplayRole), None)
self.assertEqual(model.data(model.index(0, 0, QModelIndex()), QgsLayoutManagerModel.LayoutRole), None)
self.assertEqual(model.data(model.index(1, 0, QModelIndex()), Qt.DisplayRole), 'test layout')
self.assertEqual(model.data(model.index(1, 0, QModelIndex()), QgsLayoutManagerModel.LayoutRole), layout)
self.assertEqual(model.data(model.index(2, 0, QModelIndex()), Qt.DisplayRole), 'test layout2')
self.assertEqual(model.data(model.index(2, 0, QModelIndex()), QgsLayoutManagerModel.LayoutRole), layout2)
self.assertEqual(model.layoutFromIndex(model.index(0, 0, QModelIndex())), None)
self.assertEqual(model.layoutFromIndex(model.index(1, 0, QModelIndex())), layout)
self.assertEqual(model.layoutFromIndex(model.index(2, 0, QModelIndex())), layout2)
self.assertEqual(model.indexFromLayout(layout), model.index(1, 0, QModelIndex()))
self.assertEqual(model.indexFromLayout(layout2), model.index(2, 0, QModelIndex()))
manager.clear()
self.assertEqual(model.rowCount(QModelIndex()), 1)
self.assertEqual(model.data(model.index(0, 0, QModelIndex()), Qt.DisplayRole), None)
self.assertEqual(model.data(model.index(0, 0, QModelIndex()), QgsLayoutManagerModel.LayoutRole), None)
self.assertEqual(model.layoutFromIndex(model.index(0, 0, QModelIndex())), None)
def testProxyModel(self):
project = QgsProject()
manager = QgsLayoutManager(project)
model = QgsLayoutManagerModel(manager)
proxy = QgsLayoutManagerProxyModel()
proxy.setSourceModel(model)
self.assertEqual(proxy.rowCount(QModelIndex()), 0)
self.assertEqual(proxy.data(model.index(0, 0, QModelIndex()), Qt.DisplayRole), None)
self.assertEqual(proxy.data(model.index(0, 0, QModelIndex()), QgsLayoutManagerModel.LayoutRole), None)
layout = QgsPrintLayout(project)
layout.setName('ccc')
self.assertTrue(manager.addLayout(layout))
self.assertEqual(proxy.rowCount(QModelIndex()), 1)
self.assertEqual(proxy.data(proxy.index(0, 0, QModelIndex()), Qt.DisplayRole), 'ccc')
self.assertEqual(proxy.data(proxy.index(0, 0, QModelIndex()), QgsLayoutManagerModel.LayoutRole), layout)
self.assertEqual(proxy.data(proxy.index(1, 0, QModelIndex()), Qt.DisplayRole), None)
self.assertEqual(proxy.data(proxy.index(1, 0, QModelIndex()), QgsLayoutManagerModel.LayoutRole), None)
layout2 = QgsPrintLayout(project)
layout2.setName('bbb')
self.assertTrue(manager.addLayout(layout2))
self.assertEqual(proxy.rowCount(QModelIndex()), 2)
self.assertEqual(proxy.data(proxy.index(0, 0, QModelIndex()), Qt.DisplayRole), 'bbb')
self.assertEqual(proxy.data(proxy.index(0, 0, QModelIndex()), QgsLayoutManagerModel.LayoutRole), layout2)
self.assertEqual(proxy.data(proxy.index(1, 0, QModelIndex()), Qt.DisplayRole), 'ccc')
self.assertEqual(proxy.data(proxy.index(1, 0, QModelIndex()), QgsLayoutManagerModel.LayoutRole), layout)
layout.setName('aaa')
self.assertEqual(proxy.data(proxy.index(0, 0, QModelIndex()), Qt.DisplayRole), 'aaa')
self.assertEqual(proxy.data(proxy.index(0, 0, QModelIndex()), QgsLayoutManagerModel.LayoutRole), layout)
self.assertEqual(proxy.data(proxy.index(1, 0, QModelIndex()), Qt.DisplayRole), 'bbb')
self.assertEqual(proxy.data(proxy.index(1, 0, QModelIndex()), QgsLayoutManagerModel.LayoutRole), layout2)
model.setAllowEmptyLayout(True)
self.assertEqual(proxy.rowCount(QModelIndex()), 3)
self.assertEqual(proxy.data(proxy.index(0, 0, QModelIndex()), Qt.DisplayRole), None)
self.assertEqual(proxy.data(proxy.index(0, 0, QModelIndex()), QgsLayoutManagerModel.LayoutRole), None)
self.assertEqual(proxy.data(proxy.index(1, 0, QModelIndex()), Qt.DisplayRole), 'aaa')
self.assertEqual(proxy.data(proxy.index(1, 0, QModelIndex()), QgsLayoutManagerModel.LayoutRole), layout)
self.assertEqual(proxy.data(proxy.index(2, 0, QModelIndex()), Qt.DisplayRole), 'bbb')
self.assertEqual(proxy.data(proxy.index(2, 0, QModelIndex()), QgsLayoutManagerModel.LayoutRole), layout2)
r = QgsReport(project)
r.setName('ddd')
manager.addLayout(r)
self.assertEqual(proxy.rowCount(QModelIndex()), 4)
self.assertEqual(proxy.data(proxy.index(0, 0, QModelIndex()), Qt.DisplayRole), None)
self.assertEqual(proxy.data(proxy.index(0, 0, QModelIndex()), QgsLayoutManagerModel.LayoutRole), None)
self.assertEqual(proxy.data(proxy.index(1, 0, QModelIndex()), Qt.DisplayRole), 'aaa')
self.assertEqual(proxy.data(proxy.index(1, 0, QModelIndex()), QgsLayoutManagerModel.LayoutRole), layout)
self.assertEqual(proxy.data(proxy.index(2, 0, QModelIndex()), Qt.DisplayRole), 'bbb')
self.assertEqual(proxy.data(proxy.index(2, 0, QModelIndex()), QgsLayoutManagerModel.LayoutRole), layout2)
self.assertEqual(proxy.data(proxy.index(3, 0, QModelIndex()), Qt.DisplayRole), 'ddd')
self.assertEqual(proxy.data(proxy.index(3, 0, QModelIndex()), QgsLayoutManagerModel.LayoutRole), r)
proxy.setFilters(QgsLayoutManagerProxyModel.FilterPrintLayouts)
self.assertEqual(proxy.filters(), QgsLayoutManagerProxyModel.FilterPrintLayouts)
self.assertEqual(proxy.rowCount(QModelIndex()), 3)
self.assertEqual(proxy.data(proxy.index(0, 0, QModelIndex()), Qt.DisplayRole), None)
self.assertEqual(proxy.data(proxy.index(0, 0, QModelIndex()), QgsLayoutManagerModel.LayoutRole), None)
self.assertEqual(proxy.data(proxy.index(1, 0, QModelIndex()), Qt.DisplayRole), 'aaa')
self.assertEqual(proxy.data(proxy.index(1, 0, QModelIndex()), QgsLayoutManagerModel.LayoutRole), layout)
self.assertEqual(proxy.data(proxy.index(2, 0, QModelIndex()), Qt.DisplayRole), 'bbb')
self.assertEqual(proxy.data(proxy.index(2, 0, QModelIndex()), QgsLayoutManagerModel.LayoutRole), layout2)
proxy.setFilters(QgsLayoutManagerProxyModel.FilterReports)
self.assertEqual(proxy.filters(), QgsLayoutManagerProxyModel.FilterReports)
self.assertEqual(proxy.rowCount(QModelIndex()), 2)
self.assertEqual(proxy.data(proxy.index(0, 0, QModelIndex()), Qt.DisplayRole), None)
self.assertEqual(proxy.data(proxy.index(0, 0, QModelIndex()), QgsLayoutManagerModel.LayoutRole), None)
self.assertEqual(proxy.data(proxy.index(1, 0, QModelIndex()), Qt.DisplayRole), 'ddd')
self.assertEqual(proxy.data(proxy.index(1, 0, QModelIndex()), QgsLayoutManagerModel.LayoutRole), r)
proxy.setFilters(QgsLayoutManagerProxyModel.FilterPrintLayouts | QgsLayoutManagerProxyModel.FilterReports)
self.assertEqual(proxy.filters(), QgsLayoutManagerProxyModel.FilterPrintLayouts | QgsLayoutManagerProxyModel.FilterReports)
self.assertEqual(proxy.rowCount(QModelIndex()), 4)
class TestQgsLayoutManager(unittest.TestCase):
def setUp(self):
"""Run before each test."""
self.manager = None
self.aboutFired = False
def tearDown(self):
"""Run after each test."""
pass
def testAddComposition(self):
project = QgsProject()
composition = QgsComposition(project)
composition.setName('test composition')
manager = QgsLayoutManager(project)
composition_about_to_be_added_spy = QSignalSpy(manager.compositionAboutToBeAdded)
composition_added_spy = QSignalSpy(manager.compositionAdded)
self.assertTrue(manager.addComposition(composition))
self.assertEqual(len(composition_about_to_be_added_spy), 1)
self.assertEqual(composition_about_to_be_added_spy[0][0], 'test composition')
self.assertEqual(len(composition_added_spy), 1)
self.assertEqual(composition_added_spy[0][0], 'test composition')
# adding it again should fail
self.assertFalse(manager.addComposition(composition))
# try adding a second composition
composition2 = QgsComposition(project)
composition2.setName('test composition2')
self.assertTrue(manager.addComposition(composition2))
self.assertEqual(len(composition_added_spy), 2)
self.assertEqual(composition_about_to_be_added_spy[1][0], 'test composition2')
self.assertEqual(len(composition_about_to_be_added_spy), 2)
self.assertEqual(composition_added_spy[1][0], 'test composition2')
# adding a composition with duplicate name should fail
composition3 = QgsComposition(project)
composition3.setName('test composition2')
self.assertFalse(manager.addComposition(composition3))
def testCompositions(self):
project = QgsProject()
manager = QgsLayoutManager(project)
composition = QgsComposition(project)
composition.setName('test composition')
composition2 = QgsComposition(project)
composition2.setName('test composition2')
composition3 = QgsComposition(project)
composition3.setName('test composition3')
manager.addComposition(composition)
self.assertEqual(manager.compositions(), [composition])
manager.addComposition(composition2)
self.assertEqual(set(manager.compositions()), {composition, composition2})
manager.addComposition(composition3)
self.assertEqual(set(manager.compositions()), {composition, composition2, composition3})
def aboutToBeRemoved(self, name):
# composition should still exist at this time
self.assertEqual(name, 'test composition')
self.assertTrue(self.manager.compositionByName('test composition'))
self.aboutFired = True
def testRemoveComposition(self):
project = QgsProject()
composition = QgsComposition(project)
composition.setName('test composition')
self.manager = QgsLayoutManager(project)
composition_removed_spy = QSignalSpy(self.manager.compositionRemoved)
composition_about_to_be_removed_spy = QSignalSpy(self.manager.compositionAboutToBeRemoved)
# tests that composition still exists when compositionAboutToBeRemoved is fired
self.manager.compositionAboutToBeRemoved.connect(self.aboutToBeRemoved)
# not added, should fail
self.assertFalse(self.manager.removeComposition(composition))
self.assertEqual(len(composition_removed_spy), 0)
self.assertEqual(len(composition_about_to_be_removed_spy), 0)
self.assertTrue(self.manager.addComposition(composition))
self.assertEqual(self.manager.compositions(), [composition])
self.assertTrue(self.manager.removeComposition(composition))
self.assertEqual(len(self.manager.compositions()), 0)
self.assertEqual(len(composition_removed_spy), 1)
self.assertEqual(composition_removed_spy[0][0], 'test composition')
self.assertEqual(len(composition_about_to_be_removed_spy), 1)
self.assertEqual(composition_about_to_be_removed_spy[0][0], 'test composition')
self.assertTrue(self.aboutFired)
self.manager = None
def testClear(self):
project = QgsProject()
manager = QgsLayoutManager(project)
# add a bunch of compositions
composition = QgsComposition(project)
composition.setName('test composition')
composition2 = QgsComposition(project)
composition2.setName('test composition2')
composition3 = QgsComposition(project)
composition3.setName('test composition3')
manager.addComposition(composition)
manager.addComposition(composition2)
manager.addComposition(composition3)
composition_removed_spy = QSignalSpy(manager.compositionRemoved)
composition_about_to_be_removed_spy = QSignalSpy(manager.compositionAboutToBeRemoved)
manager.clear()
self.assertEqual(len(manager.compositions()), 0)
self.assertEqual(len(composition_removed_spy), 3)
self.assertEqual(len(composition_about_to_be_removed_spy), 3)
def testCompositionByName(self):
project = QgsProject()
manager = QgsLayoutManager(project)
# add a bunch of compositions
composition = QgsComposition(project)
composition.setName('test composition')
composition2 = QgsComposition(project)
composition2.setName('test composition2')
composition3 = QgsComposition(project)
composition3.setName('test composition3')
manager.addComposition(composition)
manager.addComposition(composition2)
manager.addComposition(composition3)
self.assertFalse(manager.compositionByName('asdf'))
self.assertEqual(manager.compositionByName('test composition'), composition)
self.assertEqual(manager.compositionByName('test composition2'), composition2)
self.assertEqual(manager.compositionByName('test composition3'), composition3)
def testReadWriteXml(self):
"""
Test reading and writing layout manager state to XML
"""
project = QgsProject()
manager = QgsLayoutManager(project)
# add a bunch of compositions
composition = QgsComposition(project)
composition.setName('test composition')
composition2 = QgsComposition(project)
composition2.setName('test composition2')
composition3 = QgsComposition(project)
composition3.setName('test composition3')
manager.addComposition(composition)
manager.addComposition(composition2)
manager.addComposition(composition3)
# save to xml
doc = QDomDocument("testdoc")
elem = manager.writeXml(doc)
doc.appendChild(elem)
# restore from xml
project2 = QgsProject()
manager2 = QgsLayoutManager(project2)
self.assertTrue(manager2.readXml(elem, doc))
self.assertEqual(len(manager2.compositions()), 3)
names = [c.name() for c in manager2.compositions()]
self.assertEqual(set(names), {'test composition', 'test composition2', 'test composition3'})
def testSaveAsTemplate(self):
"""
Test saving composition as template
"""
project = QgsProject()
manager = QgsLayoutManager(project)
doc = QDomDocument("testdoc")
self.assertFalse(manager.saveAsTemplate('not in manager', doc))
composition = QgsComposition(project)
composition.setName('test composition')
manager.addComposition(composition)
self.assertTrue(manager.saveAsTemplate('test composition', doc))
def testDuplicateComposition(self):
"""
Test duplicating compositions
"""
project = QgsProject()
manager = QgsLayoutManager(project)
doc = QDomDocument("testdoc")
self.assertFalse(manager.duplicateComposition('not in manager', 'dest'))
composition = QgsComposition(project)
composition.setName('test composition')
composition.setPaperSize(100, 200)
manager.addComposition(composition)
# duplicate name
self.assertFalse(manager.duplicateComposition('test composition', 'test composition'))
result = manager.duplicateComposition('test composition', 'dupe composition')
self.assertTrue(result)
# make sure result in stored in manager
self.assertEqual(result, manager.compositionByName('dupe composition'))
self.assertEqual(result.name(), 'dupe composition')
self.assertEqual(result.paperHeight(), 200)
self.assertEqual(result.paperWidth(), 100)
def testGenerateUniqueTitle(self):
project = QgsProject()
manager = QgsLayoutManager(project)
self.assertEqual(manager.generateUniqueTitle(), 'Composer 1')
composition = QgsComposition(project)
composition.setName(manager.generateUniqueTitle())
manager.addComposition(composition)
self.assertEqual(manager.generateUniqueTitle(), 'Composer 2')
composition2 = QgsComposition(project)
composition2.setName(manager.generateUniqueTitle())
manager.addComposition(composition2)
self.assertEqual(manager.generateUniqueTitle(), 'Composer 3')
manager.clear()
self.assertEqual(manager.generateUniqueTitle(), 'Composer 1')
def testRenameSignal(self):
project = QgsProject()
manager = QgsLayoutManager(project)
composition = QgsComposition(project)
composition.setName('c1')
manager.addComposition(composition)
composition2 = QgsComposition(project)
composition2.setName('c2')
manager.addComposition(composition2)
composition_renamed_spy = QSignalSpy(manager.compositionRenamed)
composition.setName('d1')
self.assertEqual(len(composition_renamed_spy), 1)
self.assertEqual(composition_renamed_spy[0][0], composition)
self.assertEqual(composition_renamed_spy[0][1], 'd1')
composition2.setName('d2')
self.assertEqual(len(composition_renamed_spy), 2)
self.assertEqual(composition_renamed_spy[1][0], composition2)
self.assertEqual(composition_renamed_spy[1][1], 'd2')
class TestQgsLayoutManager(unittest.TestCase):
def setUp(self):
"""Run before each test."""
self.manager = None
self.aboutFired = False
def tearDown(self):
"""Run after each test."""
pass
def testAddComposition(self):
project = QgsProject()
composition = QgsComposition(project)
composition.setName('test composition')
manager = QgsLayoutManager(project)
composition_about_to_be_added_spy = QSignalSpy(
manager.compositionAboutToBeAdded)
composition_added_spy = QSignalSpy(manager.compositionAdded)
self.assertTrue(manager.addComposition(composition))
self.assertEqual(len(composition_about_to_be_added_spy), 1)
self.assertEqual(composition_about_to_be_added_spy[0][0],
'test composition')
self.assertEqual(len(composition_added_spy), 1)
self.assertEqual(composition_added_spy[0][0], 'test composition')
# adding it again should fail
self.assertFalse(manager.addComposition(composition))
# try adding a second composition
composition2 = QgsComposition(project)
composition2.setName('test composition2')
self.assertTrue(manager.addComposition(composition2))
self.assertEqual(len(composition_added_spy), 2)
self.assertEqual(composition_about_to_be_added_spy[1][0],
'test composition2')
self.assertEqual(len(composition_about_to_be_added_spy), 2)
self.assertEqual(composition_added_spy[1][0], 'test composition2')
# adding a composition with duplicate name should fail
composition3 = QgsComposition(project)
composition3.setName('test composition2')
self.assertFalse(manager.addComposition(composition3))
def testCompositions(self):
project = QgsProject()
manager = QgsLayoutManager(project)
composition = QgsComposition(project)
composition.setName('test composition')
composition2 = QgsComposition(project)
composition2.setName('test composition2')
composition3 = QgsComposition(project)
composition3.setName('test composition3')
manager.addComposition(composition)
self.assertEqual(manager.compositions(), [composition])
manager.addComposition(composition2)
self.assertEqual(set(manager.compositions()),
{composition, composition2})
manager.addComposition(composition3)
self.assertEqual(set(manager.compositions()),
{composition, composition2, composition3})
def aboutToBeRemoved(self, name):
# composition should still exist at this time
self.assertEqual(name, 'test composition')
self.assertTrue(self.manager.compositionByName('test composition'))
self.aboutFired = True
def testRemoveComposition(self):
project = QgsProject()
composition = QgsComposition(project)
composition.setName('test composition')
self.manager = QgsLayoutManager(project)
composition_removed_spy = QSignalSpy(self.manager.compositionRemoved)
composition_about_to_be_removed_spy = QSignalSpy(
self.manager.compositionAboutToBeRemoved)
# tests that composition still exists when compositionAboutToBeRemoved is fired
self.manager.compositionAboutToBeRemoved.connect(self.aboutToBeRemoved)
# not added, should fail
self.assertFalse(self.manager.removeComposition(composition))
self.assertEqual(len(composition_removed_spy), 0)
self.assertEqual(len(composition_about_to_be_removed_spy), 0)
self.assertTrue(self.manager.addComposition(composition))
self.assertEqual(self.manager.compositions(), [composition])
self.assertTrue(self.manager.removeComposition(composition))
self.assertEqual(len(self.manager.compositions()), 0)
self.assertEqual(len(composition_removed_spy), 1)
self.assertEqual(composition_removed_spy[0][0], 'test composition')
self.assertEqual(len(composition_about_to_be_removed_spy), 1)
self.assertEqual(composition_about_to_be_removed_spy[0][0],
'test composition')
self.assertTrue(self.aboutFired)
self.manager = None
def testClear(self):
project = QgsProject()
manager = QgsLayoutManager(project)
# add a bunch of compositions
composition = QgsComposition(project)
composition.setName('test composition')
composition2 = QgsComposition(project)
composition2.setName('test composition2')
composition3 = QgsComposition(project)
composition3.setName('test composition3')
manager.addComposition(composition)
manager.addComposition(composition2)
manager.addComposition(composition3)
composition_removed_spy = QSignalSpy(manager.compositionRemoved)
composition_about_to_be_removed_spy = QSignalSpy(
manager.compositionAboutToBeRemoved)
manager.clear()
self.assertEqual(len(manager.compositions()), 0)
self.assertEqual(len(composition_removed_spy), 3)
self.assertEqual(len(composition_about_to_be_removed_spy), 3)
def testCompositionByName(self):
project = QgsProject()
manager = QgsLayoutManager(project)
# add a bunch of compositions
composition = QgsComposition(project)
composition.setName('test composition')
composition2 = QgsComposition(project)
composition2.setName('test composition2')
composition3 = QgsComposition(project)
composition3.setName('test composition3')
manager.addComposition(composition)
manager.addComposition(composition2)
manager.addComposition(composition3)
self.assertFalse(manager.compositionByName('asdf'))
self.assertEqual(manager.compositionByName('test composition'),
composition)
self.assertEqual(manager.compositionByName('test composition2'),
composition2)
self.assertEqual(manager.compositionByName('test composition3'),
composition3)
def testReadWriteXml(self):
"""
Test reading and writing layout manager state to XML
"""
project = QgsProject()
manager = QgsLayoutManager(project)
# add a bunch of compositions
composition = QgsComposition(project)
composition.setName('test composition')
composition2 = QgsComposition(project)
composition2.setName('test composition2')
composition3 = QgsComposition(project)
composition3.setName('test composition3')
manager.addComposition(composition)
manager.addComposition(composition2)
manager.addComposition(composition3)
# save to xml
doc = QDomDocument("testdoc")
elem = manager.writeXml(doc)
doc.appendChild(elem)
# restore from xml
project2 = QgsProject()
manager2 = QgsLayoutManager(project2)
self.assertTrue(manager2.readXml(elem, doc))
self.assertEqual(len(manager2.compositions()), 3)
names = [c.name() for c in manager2.compositions()]
self.assertEqual(
set(names),
{'test composition', 'test composition2', 'test composition3'})
def testSaveAsTemplate(self):
"""
Test saving composition as template
"""
project = QgsProject()
manager = QgsLayoutManager(project)
doc = QDomDocument("testdoc")
self.assertFalse(manager.saveAsTemplate('not in manager', doc))
composition = QgsComposition(project)
composition.setName('test composition')
manager.addComposition(composition)
self.assertTrue(manager.saveAsTemplate('test composition', doc))
def testDuplicateComposition(self):
"""
Test duplicating compositions
"""
project = QgsProject()
manager = QgsLayoutManager(project)
doc = QDomDocument("testdoc")
self.assertFalse(manager.duplicateComposition('not in manager',
'dest'))
composition = QgsComposition(project)
composition.setName('test composition')
composition.setPaperSize(100, 200)
manager.addComposition(composition)
# duplicate name
self.assertFalse(
manager.duplicateComposition('test composition',
'test composition'))
result = manager.duplicateComposition('test composition',
'dupe composition')
self.assertTrue(result)
# make sure result in stored in manager
self.assertEqual(result, manager.compositionByName('dupe composition'))
self.assertEqual(result.name(), 'dupe composition')
self.assertEqual(result.paperHeight(), 200)
self.assertEqual(result.paperWidth(), 100)
def testGenerateUniqueTitle(self):
project = QgsProject()
manager = QgsLayoutManager(project)
self.assertEqual(manager.generateUniqueTitle(), 'Composer 1')
composition = QgsComposition(project)
composition.setName(manager.generateUniqueTitle())
manager.addComposition(composition)
self.assertEqual(manager.generateUniqueTitle(), 'Composer 2')
composition2 = QgsComposition(project)
composition2.setName(manager.generateUniqueTitle())
manager.addComposition(composition2)
self.assertEqual(manager.generateUniqueTitle(), 'Composer 3')
manager.clear()
self.assertEqual(manager.generateUniqueTitle(), 'Composer 1')
def testRenameSignal(self):
project = QgsProject()
manager = QgsLayoutManager(project)
composition = QgsComposition(project)
composition.setName('c1')
manager.addComposition(composition)
composition2 = QgsComposition(project)
composition2.setName('c2')
manager.addComposition(composition2)
composition_renamed_spy = QSignalSpy(manager.compositionRenamed)
composition.setName('d1')
self.assertEqual(len(composition_renamed_spy), 1)
self.assertEqual(composition_renamed_spy[0][0], composition)
self.assertEqual(composition_renamed_spy[0][1], 'd1')
composition2.setName('d2')
self.assertEqual(len(composition_renamed_spy), 2)
self.assertEqual(composition_renamed_spy[1][0], composition2)
self.assertEqual(composition_renamed_spy[1][1], 'd2')
def testGenerateUniqueTitle(self):
project = QgsProject()
manager = QgsLayoutManager(project)
self.assertEqual(
manager.generateUniqueTitle(QgsMasterLayoutInterface.PrintLayout),
'Layout 1')
self.assertEqual(
manager.generateUniqueTitle(QgsMasterLayoutInterface.Report),
'Report 1')
layout = QgsPrintLayout(project)
layout.setName(manager.generateUniqueTitle())
manager.addLayout(layout)
self.assertEqual(manager.generateUniqueTitle(), 'Layout 2')
self.assertEqual(
manager.generateUniqueTitle(QgsMasterLayoutInterface.Report),
'Report 1')
layout2 = QgsPrintLayout(project)
layout2.setName(manager.generateUniqueTitle())
manager.addLayout(layout2)
self.assertEqual(manager.generateUniqueTitle(), 'Layout 3')
report1 = QgsReport(project)
report1.setName(
manager.generateUniqueTitle(QgsMasterLayoutInterface.Report))
manager.addLayout(report1)
self.assertEqual(
manager.generateUniqueTitle(QgsMasterLayoutInterface.Report),
'Report 2')
manager.clear()
self.assertEqual(manager.generateUniqueTitle(), 'Layout 1')
self.assertEqual(
manager.generateUniqueTitle(QgsMasterLayoutInterface.Report),
'Report 1')
def testReadWriteXml(self):
"""
Test reading and writing layout manager state to XML
"""
project = QgsProject()
manager = QgsLayoutManager(project)
# add a bunch of compositions
composition = QgsComposition(project)
composition.setName('test composition')
composition2 = QgsComposition(project)
composition2.setName('test composition2')
composition3 = QgsComposition(project)
composition3.setName('test composition3')
manager.addComposition(composition)
manager.addComposition(composition2)
manager.addComposition(composition3)
# save to xml
doc = QDomDocument("testdoc")
elem = manager.writeXml(doc)
doc.appendChild(elem)
# restore from xml
project2 = QgsProject()
manager2 = QgsLayoutManager(project2)
self.assertTrue(manager2.readXml(elem, doc))
self.assertEqual(len(manager2.compositions()), 3)
names = [c.name() for c in manager2.compositions()]
self.assertEqual(
set(names),
{'test composition', 'test composition2', 'test composition3'})
def testProxyModel(self):
project = QgsProject()
manager = QgsLayoutManager(project)
model = QgsLayoutManagerModel(manager)
proxy = QgsLayoutManagerProxyModel()
proxy.setSourceModel(model)
self.assertEqual(proxy.rowCount(QModelIndex()), 0)
self.assertEqual(
proxy.data(model.index(0, 0, QModelIndex()), Qt.DisplayRole), None)
self.assertEqual(
proxy.data(model.index(0, 0, QModelIndex()),
QgsLayoutManagerModel.LayoutRole), None)
layout = QgsPrintLayout(project)
layout.setName('ccc')
self.assertTrue(manager.addLayout(layout))
self.assertEqual(proxy.rowCount(QModelIndex()), 1)
self.assertEqual(
proxy.data(proxy.index(0, 0, QModelIndex()), Qt.DisplayRole),
'ccc')
self.assertEqual(
proxy.data(proxy.index(0, 0, QModelIndex()),
QgsLayoutManagerModel.LayoutRole), layout)
self.assertEqual(
proxy.data(proxy.index(1, 0, QModelIndex()), Qt.DisplayRole), None)
self.assertEqual(
proxy.data(proxy.index(1, 0, QModelIndex()),
QgsLayoutManagerModel.LayoutRole), None)
layout2 = QgsPrintLayout(project)
layout2.setName('bbb')
self.assertTrue(manager.addLayout(layout2))
self.assertEqual(proxy.rowCount(QModelIndex()), 2)
self.assertEqual(
proxy.data(proxy.index(0, 0, QModelIndex()), Qt.DisplayRole),
'bbb')
self.assertEqual(
proxy.data(proxy.index(0, 0, QModelIndex()),
QgsLayoutManagerModel.LayoutRole), layout2)
self.assertEqual(
proxy.data(proxy.index(1, 0, QModelIndex()), Qt.DisplayRole),
'ccc')
self.assertEqual(
proxy.data(proxy.index(1, 0, QModelIndex()),
QgsLayoutManagerModel.LayoutRole), layout)
layout.setName('aaa')
self.assertEqual(
proxy.data(proxy.index(0, 0, QModelIndex()), Qt.DisplayRole),
'aaa')
self.assertEqual(
proxy.data(proxy.index(0, 0, QModelIndex()),
QgsLayoutManagerModel.LayoutRole), layout)
self.assertEqual(
proxy.data(proxy.index(1, 0, QModelIndex()), Qt.DisplayRole),
'bbb')
self.assertEqual(
proxy.data(proxy.index(1, 0, QModelIndex()),
QgsLayoutManagerModel.LayoutRole), layout2)
model.setAllowEmptyLayout(True)
self.assertEqual(proxy.rowCount(QModelIndex()), 3)
self.assertEqual(
proxy.data(proxy.index(0, 0, QModelIndex()), Qt.DisplayRole), None)
self.assertEqual(
proxy.data(proxy.index(0, 0, QModelIndex()),
QgsLayoutManagerModel.LayoutRole), None)
self.assertEqual(
proxy.data(proxy.index(1, 0, QModelIndex()), Qt.DisplayRole),
'aaa')
self.assertEqual(
proxy.data(proxy.index(1, 0, QModelIndex()),
QgsLayoutManagerModel.LayoutRole), layout)
self.assertEqual(
proxy.data(proxy.index(2, 0, QModelIndex()), Qt.DisplayRole),
'bbb')
self.assertEqual(
proxy.data(proxy.index(2, 0, QModelIndex()),
QgsLayoutManagerModel.LayoutRole), layout2)
r = QgsReport(project)
r.setName('ddd')
manager.addLayout(r)
self.assertEqual(proxy.rowCount(QModelIndex()), 4)
self.assertEqual(
proxy.data(proxy.index(0, 0, QModelIndex()), Qt.DisplayRole), None)
self.assertEqual(
proxy.data(proxy.index(0, 0, QModelIndex()),
QgsLayoutManagerModel.LayoutRole), None)
self.assertEqual(
proxy.data(proxy.index(1, 0, QModelIndex()), Qt.DisplayRole),
'aaa')
self.assertEqual(
proxy.data(proxy.index(1, 0, QModelIndex()),
QgsLayoutManagerModel.LayoutRole), layout)
self.assertEqual(
proxy.data(proxy.index(2, 0, QModelIndex()), Qt.DisplayRole),
'bbb')
self.assertEqual(
proxy.data(proxy.index(2, 0, QModelIndex()),
QgsLayoutManagerModel.LayoutRole), layout2)
self.assertEqual(
proxy.data(proxy.index(3, 0, QModelIndex()), Qt.DisplayRole),
'ddd')
self.assertEqual(
proxy.data(proxy.index(3, 0, QModelIndex()),
QgsLayoutManagerModel.LayoutRole), r)
proxy.setFilters(QgsLayoutManagerProxyModel.FilterPrintLayouts)
self.assertEqual(proxy.filters(),
QgsLayoutManagerProxyModel.FilterPrintLayouts)
self.assertEqual(proxy.rowCount(QModelIndex()), 3)
self.assertEqual(
proxy.data(proxy.index(0, 0, QModelIndex()), Qt.DisplayRole), None)
self.assertEqual(
proxy.data(proxy.index(0, 0, QModelIndex()),
QgsLayoutManagerModel.LayoutRole), None)
self.assertEqual(
proxy.data(proxy.index(1, 0, QModelIndex()), Qt.DisplayRole),
'aaa')
self.assertEqual(
proxy.data(proxy.index(1, 0, QModelIndex()),
QgsLayoutManagerModel.LayoutRole), layout)
self.assertEqual(
proxy.data(proxy.index(2, 0, QModelIndex()), Qt.DisplayRole),
'bbb')
self.assertEqual(
proxy.data(proxy.index(2, 0, QModelIndex()),
QgsLayoutManagerModel.LayoutRole), layout2)
proxy.setFilters(QgsLayoutManagerProxyModel.FilterReports)
self.assertEqual(proxy.filters(),
QgsLayoutManagerProxyModel.FilterReports)
self.assertEqual(proxy.rowCount(QModelIndex()), 2)
self.assertEqual(
proxy.data(proxy.index(0, 0, QModelIndex()), Qt.DisplayRole), None)
self.assertEqual(
proxy.data(proxy.index(0, 0, QModelIndex()),
QgsLayoutManagerModel.LayoutRole), None)
self.assertEqual(
proxy.data(proxy.index(1, 0, QModelIndex()), Qt.DisplayRole),
'ddd')
self.assertEqual(
proxy.data(proxy.index(1, 0, QModelIndex()),
QgsLayoutManagerModel.LayoutRole), r)
proxy.setFilters(QgsLayoutManagerProxyModel.FilterPrintLayouts
| QgsLayoutManagerProxyModel.FilterReports)
self.assertEqual(
proxy.filters(), QgsLayoutManagerProxyModel.FilterPrintLayouts
| QgsLayoutManagerProxyModel.FilterReports)
self.assertEqual(proxy.rowCount(QModelIndex()), 4)
def testCompositions(self):
project = QgsProject()
manager = QgsLayoutManager(project)
composition = QgsComposition(project)
composition.setName('test composition')
composition2 = QgsComposition(project)
composition2.setName('test composition2')
composition3 = QgsComposition(project)
composition3.setName('test composition3')
manager.addComposition(composition)
self.assertEqual(manager.compositions(), [composition])
manager.addComposition(composition2)
self.assertEqual(set(manager.compositions()),
{composition, composition2})
manager.addComposition(composition3)
self.assertEqual(set(manager.compositions()),
{composition, composition2, composition3})
def testGenerateUniqueTitle(self):
project = QgsProject()
manager = QgsLayoutManager(project)
self.assertEqual(manager.generateUniqueTitle(), 'Layout 1')
layout = QgsLayout(project)
layout.setName(manager.generateUniqueTitle())
manager.addLayout(layout)
self.assertEqual(manager.generateUniqueTitle(), 'Layout 2')
layout2 = QgsLayout(project)
layout2.setName(manager.generateUniqueTitle())
manager.addLayout(layout2)
self.assertEqual(manager.generateUniqueTitle(), 'Layout 3')
manager.clear()
self.assertEqual(manager.generateUniqueTitle(), 'Layout 1')
class TestQgsLayoutManager(unittest.TestCase):
def setUp(self):
"""Run before each test."""
self.manager = None
self.aboutFired = False
def tearDown(self):
"""Run after each test."""
pass
def testAddLayout(self):
project = QgsProject()
layout = QgsPrintLayout(project)
layout.setName('test layout')
manager = QgsLayoutManager(project)
layout_about_to_be_added_spy = QSignalSpy(manager.layoutAboutToBeAdded)
layout_added_spy = QSignalSpy(manager.layoutAdded)
self.assertTrue(manager.addLayout(layout))
self.assertEqual(len(layout_about_to_be_added_spy), 1)
self.assertEqual(layout_about_to_be_added_spy[0][0], 'test layout')
self.assertEqual(len(layout_added_spy), 1)
self.assertEqual(layout_added_spy[0][0], 'test layout')
# adding it again should fail
self.assertFalse(manager.addLayout(layout))
# try adding a second layout
layout2 = QgsPrintLayout(project)
layout2.setName('test layout2')
self.assertTrue(manager.addLayout(layout2))
self.assertEqual(len(layout_added_spy), 2)
self.assertEqual(layout_about_to_be_added_spy[1][0], 'test layout2')
self.assertEqual(len(layout_about_to_be_added_spy), 2)
self.assertEqual(layout_added_spy[1][0], 'test layout2')
# adding a layout with duplicate name should fail
layout3 = QgsPrintLayout(project)
layout3.setName('test layout2')
self.assertFalse(manager.addLayout(layout3))
def testLayouts(self):
project = QgsProject()
manager = QgsLayoutManager(project)
layout = QgsPrintLayout(project)
layout.setName('test layout')
layout2 = QgsPrintLayout(project)
layout2.setName('test layout2')
layout3 = QgsPrintLayout(project)
layout3.setName('test layout3')
manager.addLayout(layout)
self.assertEqual(manager.layouts(), [layout])
manager.addLayout(layout2)
self.assertEqual(set(manager.layouts()), {layout, layout2})
manager.addLayout(layout3)
self.assertEqual(set(manager.layouts()), {layout, layout2, layout3})
def aboutToBeRemoved(self, name):
# composition should still exist at this time
self.assertEqual(name, 'test composition')
self.assertTrue(self.manager.compositionByName('test composition'))
self.aboutFired = True
def layoutAboutToBeRemoved(self, name):
# layout should still exist at this time
self.assertEqual(name, 'test layout')
self.assertTrue(self.manager.layoutByName('test layout'))
self.aboutFired = True
def testRemoveLayout(self):
project = QgsProject()
layout = QgsPrintLayout(project)
layout.setName('test layout')
self.manager = QgsLayoutManager(project)
layout_removed_spy = QSignalSpy(self.manager.layoutRemoved)
layout_about_to_be_removed_spy = QSignalSpy(self.manager.layoutAboutToBeRemoved)
# tests that layout still exists when layoutAboutToBeRemoved is fired
self.manager.layoutAboutToBeRemoved.connect(self.layoutAboutToBeRemoved)
# not added, should fail
self.assertFalse(self.manager.removeLayout(layout))
self.assertEqual(len(layout_removed_spy), 0)
self.assertEqual(len(layout_about_to_be_removed_spy), 0)
self.assertTrue(self.manager.addLayout(layout))
self.assertEqual(self.manager.layouts(), [layout])
self.assertTrue(self.manager.removeLayout(layout))
self.assertEqual(len(self.manager.layouts()), 0)
self.assertEqual(len(layout_removed_spy), 1)
self.assertEqual(layout_removed_spy[0][0], 'test layout')
self.assertEqual(len(layout_about_to_be_removed_spy), 1)
self.assertEqual(layout_about_to_be_removed_spy[0][0], 'test layout')
self.assertTrue(self.aboutFired)
self.manager = None
def testClear(self):
project = QgsProject()
manager = QgsLayoutManager(project)
# add a bunch of layouts
layout = QgsPrintLayout(project)
layout.setName('test layout')
layout2 = QgsPrintLayout(project)
layout2.setName('test layout2')
layout3 = QgsPrintLayout(project)
layout3.setName('test layout3')
manager.addLayout(layout)
manager.addLayout(layout2)
manager.addLayout(layout3)
layout_removed_spy = QSignalSpy(manager.layoutRemoved)
layout_about_to_be_removed_spy = QSignalSpy(manager.layoutAboutToBeRemoved)
manager.clear()
self.assertEqual(len(manager.layouts()), 0)
self.assertEqual(len(layout_removed_spy), 3)
self.assertEqual(len(layout_about_to_be_removed_spy), 3)
def testLayoutsByName(self):
project = QgsProject()
manager = QgsLayoutManager(project)
# add a bunch of layouts
layout = QgsPrintLayout(project)
layout.setName('test layout')
layout2 = QgsPrintLayout(project)
layout2.setName('test layout2')
layout3 = QgsPrintLayout(project)
layout3.setName('test layout3')
manager.addLayout(layout)
manager.addLayout(layout2)
manager.addLayout(layout3)
self.assertFalse(manager.layoutByName('asdf'))
self.assertEqual(manager.layoutByName('test layout'), layout)
self.assertEqual(manager.layoutByName('test layout2'), layout2)
self.assertEqual(manager.layoutByName('test layout3'), layout3)
def testReadWriteXml(self):
"""
Test reading and writing layout manager state to XML
"""
project = QgsProject()
manager = QgsLayoutManager(project)
# add a bunch of layouts
layout = QgsPrintLayout(project)
layout.setName('test layout')
layout2 = QgsPrintLayout(project)
layout2.setName('test layout2')
layout3 = QgsPrintLayout(project)
layout3.setName('test layout3')
manager.addLayout(layout)
manager.addLayout(layout2)
manager.addLayout(layout3)
# save to xml
doc = QDomDocument("testdoc")
elem = manager.writeXml(doc)
doc.appendChild(elem)
# restore from xml
project2 = QgsProject()
manager2 = QgsLayoutManager(project2)
self.assertTrue(manager2.readXml(elem, doc))
self.assertEqual(len(manager2.layouts()), 3)
names = [c.name() for c in manager2.layouts()]
self.assertCountEqual(names, ['test layout', 'test layout2', 'test layout3'])
def testDuplicateLayout(self):
"""
Test duplicating layouts
"""
project = QgsProject()
manager = QgsLayoutManager(project)
doc = QDomDocument("testdoc")
self.assertFalse(manager.duplicateLayout(None, 'dest'))
layout = QgsPrintLayout(project)
layout.setName('test layout')
layout.initializeDefaults()
manager.addLayout(layout)
# duplicate name
self.assertFalse(manager.duplicateLayout(layout, 'test layout'))
result = manager.duplicateLayout(layout, 'dupe layout')
self.assertTrue(result)
# make sure result in stored in manager
self.assertEqual(result, manager.layoutByName('dupe layout'))
self.assertEqual(result.name(), 'dupe layout')
self.assertEqual(result.pageCollection().pageCount(), 1)
def testGenerateUniqueTitle(self):
project = QgsProject()
manager = QgsLayoutManager(project)
self.assertEqual(manager.generateUniqueTitle(QgsMasterLayoutInterface.PrintLayout), 'Layout 1')
self.assertEqual(manager.generateUniqueTitle(QgsMasterLayoutInterface.Report), 'Report 1')
layout = QgsPrintLayout(project)
layout.setName(manager.generateUniqueTitle())
manager.addLayout(layout)
self.assertEqual(manager.generateUniqueTitle(), 'Layout 2')
self.assertEqual(manager.generateUniqueTitle(QgsMasterLayoutInterface.Report), 'Report 1')
layout2 = QgsPrintLayout(project)
layout2.setName(manager.generateUniqueTitle())
manager.addLayout(layout2)
self.assertEqual(manager.generateUniqueTitle(), 'Layout 3')
report1 = QgsReport(project)
report1.setName(manager.generateUniqueTitle(QgsMasterLayoutInterface.Report))
manager.addLayout(report1)
self.assertEqual(manager.generateUniqueTitle(QgsMasterLayoutInterface.Report), 'Report 2')
manager.clear()
self.assertEqual(manager.generateUniqueTitle(), 'Layout 1')
self.assertEqual(manager.generateUniqueTitle(QgsMasterLayoutInterface.Report), 'Report 1')
def testRenameSignal(self):
project = QgsProject()
manager = QgsLayoutManager(project)
layout = QgsPrintLayout(project)
layout.setName('c1')
manager.addLayout(layout)
layout2 = QgsPrintLayout(project)
layout2.setName('c2')
manager.addLayout(layout2)
layout_renamed_spy = QSignalSpy(manager.layoutRenamed)
layout.setName('d1')
self.assertEqual(len(layout_renamed_spy), 1)
# self.assertEqual(layout_renamed_spy[0][0], layout)
self.assertEqual(layout_renamed_spy[0][1], 'd1')
layout2.setName('d2')
self.assertEqual(len(layout_renamed_spy), 2)
# self.assertEqual(layout_renamed_spy[1][0], layout2)
self.assertEqual(layout_renamed_spy[1][1], 'd2')
def testGenerateUniqueTitle(self):
project = QgsProject()
manager = QgsLayoutManager(project)
self.assertEqual(manager.generateUniqueTitle(), 'Composer 1')
composition = QgsComposition(project)
composition.setName(manager.generateUniqueTitle())
manager.addComposition(composition)
self.assertEqual(manager.generateUniqueTitle(), 'Composer 2')
composition2 = QgsComposition(project)
composition2.setName(manager.generateUniqueTitle())
manager.addComposition(composition2)
self.assertEqual(manager.generateUniqueTitle(), 'Composer 3')
manager.clear()
self.assertEqual(manager.generateUniqueTitle(), 'Composer 1')
def testClear(self):
project = QgsProject()
manager = QgsLayoutManager(project)
# add a bunch of compositions
composition = QgsComposition(project)
composition.setName('test composition')
composition2 = QgsComposition(project)
composition2.setName('test composition2')
composition3 = QgsComposition(project)
composition3.setName('test composition3')
# add a bunch of layouts
layout = QgsLayout(project)
layout.setName('test layout')
layout2 = QgsLayout(project)
layout2.setName('test layout2')
layout3 = QgsLayout(project)
layout3.setName('test layout3')
manager.addComposition(composition)
manager.addComposition(composition2)
manager.addComposition(composition3)
manager.addLayout(layout)
manager.addLayout(layout2)
manager.addLayout(layout3)
composition_removed_spy = QSignalSpy(manager.compositionRemoved)
composition_about_to_be_removed_spy = QSignalSpy(manager.compositionAboutToBeRemoved)
layout_removed_spy = QSignalSpy(manager.layoutRemoved)
layout_about_to_be_removed_spy = QSignalSpy(manager.layoutAboutToBeRemoved)
manager.clear()
self.assertEqual(len(manager.compositions()), 0)
self.assertEqual(len(composition_removed_spy), 3)
self.assertEqual(len(composition_about_to_be_removed_spy), 3)
self.assertEqual(len(manager.layouts()), 0)
self.assertEqual(len(layout_removed_spy), 3)
self.assertEqual(len(layout_about_to_be_removed_spy), 3)
def testModel(self):
project = QgsProject()
manager = QgsLayoutManager(project)
model = QgsLayoutManagerModel(manager)
self.assertEqual(model.rowCount(QModelIndex()), 0)
self.assertEqual(
model.data(model.index(0, 0, QModelIndex()), Qt.DisplayRole), None)
self.assertEqual(
model.data(model.index(0, 0, QModelIndex()),
QgsLayoutManagerModel.LayoutRole), None)
self.assertEqual(
model.layoutFromIndex(model.index(0, 0, QModelIndex())), None)
self.assertEqual(model.indexFromLayout(None), QModelIndex())
layout = QgsPrintLayout(project)
layout.setName('test layout')
self.assertEqual(model.indexFromLayout(layout), QModelIndex())
self.assertTrue(manager.addLayout(layout))
self.assertEqual(model.rowCount(QModelIndex()), 1)
self.assertEqual(
model.data(model.index(0, 0, QModelIndex()), Qt.DisplayRole),
'test layout')
self.assertEqual(
model.data(model.index(0, 0, QModelIndex()),
QgsLayoutManagerModel.LayoutRole), layout)
self.assertEqual(
model.layoutFromIndex(model.index(0, 0, QModelIndex())), layout)
self.assertEqual(model.indexFromLayout(layout),
model.index(0, 0, QModelIndex()))
self.assertEqual(
model.data(model.index(1, 0, QModelIndex()), Qt.DisplayRole), None)
self.assertEqual(
model.data(model.index(1, 0, QModelIndex()),
QgsLayoutManagerModel.LayoutRole), None)
self.assertEqual(
model.layoutFromIndex(model.index(1, 0, QModelIndex())), None)
layout.setName('test Layout')
self.assertEqual(
model.data(model.index(0, 0, QModelIndex()), Qt.DisplayRole),
'test Layout')
layout2 = QgsPrintLayout(project)
layout2.setName('test layout2')
self.assertTrue(manager.addLayout(layout2))
self.assertEqual(model.rowCount(QModelIndex()), 2)
self.assertEqual(
model.data(model.index(0, 0, QModelIndex()), Qt.DisplayRole),
'test Layout')
self.assertEqual(
model.data(model.index(0, 0, QModelIndex()),
QgsLayoutManagerModel.LayoutRole), layout)
self.assertEqual(
model.layoutFromIndex(model.index(0, 0, QModelIndex())), layout)
self.assertEqual(model.indexFromLayout(layout),
model.index(0, 0, QModelIndex()))
self.assertEqual(
model.data(model.index(1, 0, QModelIndex()), Qt.DisplayRole),
'test layout2')
self.assertEqual(
model.data(model.index(1, 0, QModelIndex()),
QgsLayoutManagerModel.LayoutRole), layout2)
self.assertEqual(
model.layoutFromIndex(model.index(1, 0, QModelIndex())), layout2)
self.assertEqual(model.indexFromLayout(layout2),
model.index(1, 0, QModelIndex()))
manager.removeLayout(layout)
self.assertEqual(model.rowCount(QModelIndex()), 1)
self.assertEqual(
model.data(model.index(0, 0, QModelIndex()), Qt.DisplayRole),
'test layout2')
self.assertEqual(
model.data(model.index(0, 0, QModelIndex()),
QgsLayoutManagerModel.LayoutRole), layout2)
self.assertEqual(
model.data(model.index(1, 0, QModelIndex()), Qt.DisplayRole), None)
self.assertEqual(
model.data(model.index(1, 0, QModelIndex()),
QgsLayoutManagerModel.LayoutRole), None)
self.assertEqual(
model.layoutFromIndex(model.index(0, 0, QModelIndex())), layout2)
self.assertEqual(
model.layoutFromIndex(model.index(1, 0, QModelIndex())), None)
self.assertEqual(model.indexFromLayout(layout2),
model.index(0, 0, QModelIndex()))
manager.clear()
self.assertEqual(model.rowCount(QModelIndex()), 0)
self.assertEqual(
model.data(model.index(0, 0, QModelIndex()), Qt.DisplayRole), None)
self.assertEqual(
model.data(model.index(0, 0, QModelIndex()),
QgsLayoutManagerModel.LayoutRole), None)
self.assertEqual(
model.layoutFromIndex(model.index(0, 0, QModelIndex())), None)
# with empty row
model.setAllowEmptyLayout(True)
self.assertEqual(model.rowCount(QModelIndex()), 1)
self.assertEqual(
model.data(model.index(0, 0, QModelIndex()), Qt.DisplayRole), None)
self.assertEqual(
model.data(model.index(0, 0, QModelIndex()),
QgsLayoutManagerModel.LayoutRole), None)
self.assertEqual(
model.layoutFromIndex(model.index(0, 0, QModelIndex())), None)
layout = QgsPrintLayout(project)
layout.setName('test layout')
self.assertTrue(manager.addLayout(layout))
self.assertEqual(model.rowCount(QModelIndex()), 2)
self.assertEqual(
model.data(model.index(0, 0, QModelIndex()), Qt.DisplayRole), None)
self.assertEqual(
model.data(model.index(0, 0, QModelIndex()),
QgsLayoutManagerModel.LayoutRole), None)
self.assertEqual(
model.data(model.index(1, 0, QModelIndex()), Qt.DisplayRole),
'test layout')
self.assertEqual(
model.data(model.index(1, 0, QModelIndex()),
QgsLayoutManagerModel.LayoutRole), layout)
self.assertEqual(
model.data(model.index(2, 0, QModelIndex()), Qt.DisplayRole), None)
self.assertEqual(
model.data(model.index(2, 0, QModelIndex()),
QgsLayoutManagerModel.LayoutRole), None)
self.assertEqual(
model.layoutFromIndex(model.index(0, 0, QModelIndex())), None)
self.assertEqual(
model.layoutFromIndex(model.index(1, 0, QModelIndex())), layout)
self.assertEqual(model.indexFromLayout(layout),
model.index(1, 0, QModelIndex()))
layout2 = QgsPrintLayout(project)
layout2.setName('test layout2')
self.assertTrue(manager.addLayout(layout2))
self.assertEqual(model.rowCount(QModelIndex()), 3)
self.assertEqual(
model.data(model.index(0, 0, QModelIndex()), Qt.DisplayRole), None)
self.assertEqual(
model.data(model.index(0, 0, QModelIndex()),
QgsLayoutManagerModel.LayoutRole), None)
self.assertEqual(
model.data(model.index(1, 0, QModelIndex()), Qt.DisplayRole),
'test layout')
self.assertEqual(
model.data(model.index(1, 0, QModelIndex()),
QgsLayoutManagerModel.LayoutRole), layout)
self.assertEqual(
model.data(model.index(2, 0, QModelIndex()), Qt.DisplayRole),
'test layout2')
self.assertEqual(
model.data(model.index(2, 0, QModelIndex()),
QgsLayoutManagerModel.LayoutRole), layout2)
self.assertEqual(
model.layoutFromIndex(model.index(0, 0, QModelIndex())), None)
self.assertEqual(
model.layoutFromIndex(model.index(1, 0, QModelIndex())), layout)
self.assertEqual(
model.layoutFromIndex(model.index(2, 0, QModelIndex())), layout2)
self.assertEqual(model.indexFromLayout(layout),
model.index(1, 0, QModelIndex()))
self.assertEqual(model.indexFromLayout(layout2),
model.index(2, 0, QModelIndex()))
manager.clear()
self.assertEqual(model.rowCount(QModelIndex()), 1)
self.assertEqual(
model.data(model.index(0, 0, QModelIndex()), Qt.DisplayRole), None)
self.assertEqual(
model.data(model.index(0, 0, QModelIndex()),
QgsLayoutManagerModel.LayoutRole), None)
self.assertEqual(
model.layoutFromIndex(model.index(0, 0, QModelIndex())), None)
