def testSnapPointToItems(self):
        p = QgsProject()
        l = QgsLayout(p)
        page = QgsLayoutItemPage(l)
        page.setPageSize('A4')
        #l.pageCollection().addPage(page)
        s = QgsLayoutSnapper(l)
        guides = l.guides()

        s.setSnapToItems(True)
        s.setSnapTolerance(1)

        # no items
        point, snapped = s.snapPointToItems(0.5, Qt.Horizontal, 1, [])
        self.assertFalse(snapped)

        line = QGraphicsLineItem()
        line.setVisible(True)
        point, snapped = s.snapPointToItems(0.5, Qt.Horizontal, 1, [], line)
        self.assertFalse(line.isVisible())

        guides.addGuide(
            QgsLayoutGuide(Qt.Vertical, QgsLayoutMeasurement(1), page))

        # add an item
        item1 = QgsLayoutItemMap(l)
        item1.attemptMove(QgsLayoutPoint(4, 8, QgsUnitTypes.LayoutMillimeters))
        item1.attemptResize(
            QgsLayoutSize(18, 12, QgsUnitTypes.LayoutMillimeters))
        l.addItem(item1)

        point, snapped = s.snapPointToItems(3.5, Qt.Horizontal, 1, [], line)
        self.assertTrue(snapped)
        self.assertEqual(point, 4)
        self.assertTrue(line.isVisible())
        point, snapped = s.snapPointToItems(4.5, Qt.Horizontal, 1, [])
        self.assertTrue(snapped)
        self.assertEqual(point, 4)

        # ignoring item
        point, snapped = s.snapPointToItems(4.5, Qt.Horizontal, 1, [item1])
        self.assertFalse(snapped)

        # outside tolerance
        point, snapped = s.snapPointToItems(5.5, Qt.Horizontal, 1, [], line)
        self.assertFalse(snapped)
        self.assertFalse(line.isVisible())

        # snap to center
        point, snapped = s.snapPointToItems(12.5, Qt.Horizontal, 1, [])
        self.assertTrue(snapped)
        self.assertEqual(point, 13)

        # snap to right
        point, snapped = s.snapPointToItems(22.5, Qt.Horizontal, 1, [])
        self.assertTrue(snapped)
        self.assertEqual(point, 22)

        #snap to top
        point, snapped = s.snapPointToItems(7.5, Qt.Vertical, 1, [], line)
        self.assertTrue(snapped)
        self.assertEqual(point, 8)
        self.assertTrue(line.isVisible())
        point, snapped = s.snapPointToItems(8.5, Qt.Vertical, 1, [])
        self.assertTrue(snapped)
        self.assertEqual(point, 8)

        # outside tolerance
        point, snapped = s.snapPointToItems(5.5, Qt.Vertical, 1, [], line)
        self.assertFalse(snapped)
        self.assertFalse(line.isVisible())

        # snap to center
        point, snapped = s.snapPointToItems(13.5, Qt.Vertical, 1, [])
        self.assertTrue(snapped)
        self.assertEqual(point, 14)

        # snap to bottom
        point, snapped = s.snapPointToItems(20.5, Qt.Vertical, 1, [])
        self.assertTrue(snapped)
        self.assertEqual(point, 20)

        # snapping off
        s.setSnapToItems(False)
        line.setVisible(True)
        point, snapped = s.snapPointToItems(20.5, Qt.Vertical, 1, [], line)
        self.assertFalse(snapped)
        self.assertFalse(line.isVisible())

        # with different pixel scale
        s.setSnapToItems(True)
        point, snapped = s.snapPointToItems(20.5, Qt.Vertical, 3, [])
        self.assertFalse(snapped)
    def testUpdateGuide(self):
        p = QgsProject()
        l = QgsLayout(p)
        l.initializeDefaults()  # add a page
        # add a second page
        page2 = QgsLayoutItemPage(l)
        page2.setPageSize('A5')
        l.pageCollection().addPage(page2)

        g = QgsLayoutGuide(
            Qt.Horizontal,
            QgsLayoutMeasurement(5, QgsUnitTypes.LayoutCentimeters),
            l.pageCollection().page(0))
        g.setLayout(l)
        g.update()

        self.assertTrue(g.item().isVisible())
        self.assertEqual(g.item().line().x1(), 0)
        self.assertEqual(g.item().line().y1(), 50)
        self.assertEqual(g.item().line().x2(), 297)
        self.assertEqual(g.item().line().y2(), 50)
        self.assertEqual(g.layoutPosition(), 50)

        g.setPosition(QgsLayoutMeasurement(15, QgsUnitTypes.LayoutMillimeters))
        g.update()
        self.assertTrue(g.item().isVisible())
        self.assertEqual(g.item().line().x1(), 0)
        self.assertEqual(g.item().line().y1(), 15)
        self.assertEqual(g.item().line().x2(), 297)
        self.assertEqual(g.item().line().y2(), 15)
        self.assertEqual(g.layoutPosition(), 15)

        # guide on page2
        g1 = QgsLayoutGuide(
            Qt.Horizontal,
            QgsLayoutMeasurement(5, QgsUnitTypes.LayoutCentimeters),
            l.pageCollection().page(1))
        g1.setLayout(l)
        g1.update()
        g1.setPosition(QgsLayoutMeasurement(15,
                                            QgsUnitTypes.LayoutMillimeters))
        g1.update()
        self.assertTrue(g1.item().isVisible())
        self.assertEqual(g1.item().line().x1(), 0)
        self.assertEqual(g1.item().line().y1(), 235)
        self.assertEqual(g1.item().line().x2(), 148)
        self.assertEqual(g1.item().line().y2(), 235)
        self.assertEqual(g1.layoutPosition(), 235)

        # vertical guide
        g2 = QgsLayoutGuide(
            Qt.Vertical, QgsLayoutMeasurement(5,
                                              QgsUnitTypes.LayoutCentimeters),
            l.pageCollection().page(0))
        g2.setLayout(l)
        g2.update()
        self.assertTrue(g2.item().isVisible())
        self.assertEqual(g2.item().line().x1(), 50)
        self.assertEqual(g2.item().line().y1(), 0)
        self.assertEqual(g2.item().line().x2(), 50)
        self.assertEqual(g2.item().line().y2(), 210)
        self.assertEqual(g2.layoutPosition(), 50)

        g.setPage(None)
        g.update()
        self.assertFalse(g.item().isVisible())

        g.setPage(l.pageCollection().page(0))
        g.update()
        self.assertTrue(g.item().isVisible())

        #throw it off the bottom of the page
        g.setPosition(
            QgsLayoutMeasurement(1115, QgsUnitTypes.LayoutMillimeters))
        g.update()
        self.assertFalse(g.item().isVisible())

        # guide on page2
        g3 = QgsLayoutGuide(
            Qt.Vertical, QgsLayoutMeasurement(5,
                                              QgsUnitTypes.LayoutCentimeters),
            l.pageCollection().page(1))
        g3.setLayout(l)
        g3.update()
        self.assertTrue(g3.item().isVisible())
        self.assertEqual(g3.item().line().x1(), 50)
        self.assertEqual(g3.item().line().y1(), 220)
        self.assertEqual(g3.item().line().x2(), 50)
        self.assertEqual(g3.item().line().y2(), 430)
        self.assertEqual(g3.layoutPosition(), 50)
    def testCollection(self):
        p = QgsProject()
        l = QgsLayout(p)
        l.initializeDefaults()  # add a page
        guides = l.guides()

        # no guides initially
        self.assertEqual(guides.rowCount(QModelIndex()), 0)
        self.assertFalse(
            guides.data(QModelIndex(),
                        QgsLayoutGuideCollection.OrientationRole))
        self.assertFalse(guides.guides(Qt.Horizontal))
        self.assertFalse(guides.guides(Qt.Vertical))

        # add a guide
        g1 = QgsLayoutGuide(
            Qt.Horizontal,
            QgsLayoutMeasurement(5, QgsUnitTypes.LayoutCentimeters),
            l.pageCollection().page(0))
        guides.addGuide(g1)
        self.assertEqual(guides.rowCount(QModelIndex()), 1)
        self.assertEqual(
            guides.data(guides.index(0, 0),
                        QgsLayoutGuideCollection.OrientationRole),
            Qt.Horizontal)
        self.assertEqual(
            guides.data(guides.index(0, 0),
                        QgsLayoutGuideCollection.PositionRole), 5)
        self.assertEqual(
            guides.data(guides.index(0, 0),
                        QgsLayoutGuideCollection.UnitsRole),
            QgsUnitTypes.LayoutCentimeters)
        self.assertEqual(
            guides.data(guides.index(0, 0), QgsLayoutGuideCollection.PageRole),
            0)
        self.assertEqual(guides.guides(Qt.Horizontal), [g1])
        self.assertFalse(guides.guides(Qt.Vertical))
        self.assertEqual(guides.guidesOnPage(0), [g1])
        self.assertEqual(guides.guidesOnPage(1), [])

        g2 = QgsLayoutGuide(Qt.Horizontal, QgsLayoutMeasurement(15),
                            l.pageCollection().page(0))
        guides.addGuide(g2)
        self.assertEqual(guides.rowCount(QModelIndex()), 2)
        self.assertEqual(
            guides.data(guides.index(1, 0),
                        QgsLayoutGuideCollection.OrientationRole),
            Qt.Horizontal)
        self.assertEqual(
            guides.data(guides.index(1, 0),
                        QgsLayoutGuideCollection.PositionRole), 15)
        self.assertEqual(
            guides.data(guides.index(1, 0),
                        QgsLayoutGuideCollection.UnitsRole),
            QgsUnitTypes.LayoutMillimeters)
        self.assertEqual(
            guides.data(guides.index(1, 0), QgsLayoutGuideCollection.PageRole),
            0)
        self.assertEqual(guides.guides(Qt.Horizontal), [g1, g2])
        self.assertFalse(guides.guides(Qt.Vertical))
        self.assertEqual(guides.guidesOnPage(0), [g1, g2])

        page2 = QgsLayoutItemPage(l)
        page2.setPageSize('A3')
        l.pageCollection().addPage(page2)
        g3 = QgsLayoutGuide(Qt.Vertical, QgsLayoutMeasurement(35),
                            l.pageCollection().page(1))
        guides.addGuide(g3)
        self.assertEqual(guides.rowCount(QModelIndex()), 3)
        self.assertEqual(
            guides.data(guides.index(2, 0),
                        QgsLayoutGuideCollection.OrientationRole), Qt.Vertical)
        self.assertEqual(
            guides.data(guides.index(2, 0),
                        QgsLayoutGuideCollection.PositionRole), 35)
        self.assertEqual(
            guides.data(guides.index(2, 0),
                        QgsLayoutGuideCollection.UnitsRole),
            QgsUnitTypes.LayoutMillimeters)
        self.assertEqual(
            guides.data(guides.index(2, 0), QgsLayoutGuideCollection.PageRole),
            1)
        self.assertEqual(guides.guides(Qt.Horizontal), [g1, g2])
        self.assertEqual(guides.guides(Qt.Horizontal, 0), [g1, g2])
        self.assertEqual(guides.guides(Qt.Horizontal, 1), [])
        self.assertEqual(guides.guides(Qt.Vertical), [g3])
        self.assertEqual(guides.guides(Qt.Vertical, 0), [])
        self.assertEqual(guides.guides(Qt.Vertical, 1), [g3])
        self.assertEqual(guides.guides(Qt.Vertical, 2), [])
        self.assertEqual(guides.guidesOnPage(0), [g1, g2])
        self.assertEqual(guides.guidesOnPage(1), [g3])
Exemple #4
0
    def testReadWriteXml(self):
        p = QgsProject()
        l = QgsPrintLayout(p)
        l.setName('my layout')
        l.setUnits(QgsUnitTypes.LayoutInches)
        collection = l.pageCollection()

        # add a page
        page = QgsLayoutItemPage(l)
        page.setPageSize('A6')
        collection.addPage(page)

        grid = l.gridSettings()
        grid.setResolution(QgsLayoutMeasurement(5, QgsUnitTypes.LayoutPoints))

        g1 = QgsLayoutGuide(
            Qt.Horizontal,
            QgsLayoutMeasurement(5, QgsUnitTypes.LayoutCentimeters),
            l.pageCollection().page(0))
        l.guides().addGuide(g1)

        snapper = l.snapper()
        snapper.setSnapTolerance(7)

        # add some items
        item1 = QgsLayoutItemMap(l)
        item1.setId('xxyyxx')
        l.addItem(item1)
        item2 = QgsLayoutItemMap(l)
        item2.setId('zzyyzz')
        l.addItem(item2)

        l.setReferenceMap(item2)

        doc = QDomDocument("testdoc")
        elem = l.writeXml(doc, QgsReadWriteContext())

        l2 = QgsPrintLayout(p)
        self.assertTrue(l2.readXml(elem, doc, QgsReadWriteContext()))
        self.assertEqual(l2.name(), 'my layout')
        self.assertEqual(l2.units(), QgsUnitTypes.LayoutInches)

        collection2 = l2.pageCollection()
        self.assertEqual(collection2.pageCount(), 1)
        self.assertAlmostEqual(collection2.page(0).pageSize().width(), 105, 4)
        self.assertEqual(collection2.page(0).pageSize().height(), 148)
        self.assertEqual(l2.gridSettings().resolution().length(), 5.0)
        self.assertEqual(l2.gridSettings().resolution().units(),
                         QgsUnitTypes.LayoutPoints)
        self.assertEqual(l2.guides().guidesOnPage(0)[0].orientation(),
                         Qt.Horizontal)
        self.assertEqual(l2.guides().guidesOnPage(0)[0].position().length(),
                         5.0)
        self.assertEqual(l2.guides().guidesOnPage(0)[0].position().units(),
                         QgsUnitTypes.LayoutCentimeters)
        self.assertEqual(l2.snapper().snapTolerance(), 7)

        # check restored items
        new_item1 = l2.itemByUuid(item1.uuid())
        self.assertTrue(new_item1)
        self.assertEqual(new_item1.id(), 'xxyyxx')
        new_item2 = l2.itemByUuid(item2.uuid())
        self.assertTrue(new_item2)
        self.assertEqual(new_item2.id(), 'zzyyzz')
        self.assertEqual(l2.referenceMap().id(), 'zzyyzz')
Exemple #5
0
    def testSnapRect(self):
        p = QgsProject()
        l = QgsLayout(p)
        page = QgsLayoutItemPage(l)
        page.setPageSize('A4')
        l.pageCollection().addPage(page)
        s = QgsLayoutSnapper(l)
        guides = l.guides()

        # first test snapping to grid
        l.gridSettings().setResolution(
            QgsLayoutMeasurement(5, QgsUnitTypes.LayoutMillimeters))
        s.setSnapToItems(False)
        s.setSnapToGrid(True)
        s.setSnapTolerance(1)

        rect, snapped = s.snapRect(QRectF(1, 1, 2, 1), 1)
        self.assertTrue(snapped)
        self.assertEqual(rect, QRectF(0, 0, 2, 1))
        rect, snapped = s.snapRect(QRectF(1, 1, 3.5, 3.5), 1)
        self.assertTrue(snapped)
        self.assertEqual(rect, QRectF(1.5, 1.5, 3.5, 3.5))

        s.setSnapToItems(False)
        s.setSnapToGrid(False)
        rect, snapped = s.snapRect(QRectF(1, 1, 3.5, 3.5), 1)
        self.assertFalse(snapped)
        self.assertEqual(rect, QRectF(1, 1, 3.5, 3.5))

        # test that guide takes precedence
        s.setSnapToGrid(True)
        s.setSnapToGuides(True)
        guides.addGuide(
            QgsLayoutGuide(Qt.Horizontal, QgsLayoutMeasurement(0.5), page))
        rect, snapped = s.snapRect(QRectF(1, 1, 2, 3), 1)
        self.assertTrue(snapped)
        self.assertEqual(rect, QRectF(0.0, 0.5, 2.0, 3.0))

        # add an item
        item1 = QgsLayoutItemMap(l)
        item1.attemptMove(
            QgsLayoutPoint(121, 1.1, QgsUnitTypes.LayoutMillimeters))
        l.addItem(item1)

        # test that guide takes precedence over item
        s.setSnapToGrid(True)
        s.setSnapToGuides(True)
        s.setSnapToItems(True)
        rect, snapped = s.snapRect(QRectF(1, 1, 2, 3), 1)
        self.assertTrue(snapped)
        self.assertEqual(rect, QRectF(0.0, 0.5, 2.0, 3.0))
        # but items take precedence over grid
        s.setSnapToGuides(False)
        rect, snapped = s.snapRect(QRectF(1, 1, 2, 3), 1)
        self.assertTrue(snapped)
        self.assertEqual(rect, QRectF(0.0, 1.1, 2.0, 3.0))

        # ... unless item is ignored!
        rect, snapped = s.snapRect(QRectF(1, 1, 2, 3), 1, None, None, [item1])
        self.assertTrue(snapped)
        self.assertEqual(rect, QRectF(0.0, 0.0, 2.0, 3.0))
    def testResizeToContents(self):
        p = QgsProject()
        l = QgsLayout(p)

        shape1 = QgsLayoutItemShape(l)
        shape1.attemptResize(QgsLayoutSize(90, 50))
        shape1.attemptMove(QgsLayoutPoint(90, 50))
        shape1.setItemRotation(45, False)
        l.addLayoutItem(shape1)
        shape2 = QgsLayoutItemShape(l)
        shape2.attemptResize(QgsLayoutSize(110, 50))
        shape2.attemptMove(QgsLayoutPoint(100, 150), True, False, 0)
        l.addLayoutItem(shape2)
        shape3 = QgsLayoutItemShape(l)
        l.addLayoutItem(shape3)
        shape3.attemptResize(QgsLayoutSize(50, 100))
        shape3.attemptMove(QgsLayoutPoint(210, 250), True, False, 0)
        shape4 = QgsLayoutItemShape(l)
        l.addLayoutItem(shape4)
        shape4.attemptResize(QgsLayoutSize(50, 30))
        shape4.attemptMove(QgsLayoutPoint(10, 340), True, False, 0)
        shape4.setVisibility(False)

        # resize with no existing pages
        l.pageCollection().resizeToContents(QgsMargins(1, 2, 3, 4),
                                            QgsUnitTypes.LayoutCentimeters)
        self.assertEqual(l.pageCollection().pageCount(), 1)

        self.assertAlmostEqual(
            l.pageCollection().page(0).sizeWithUnits().width(), 290.3, 2)
        self.assertAlmostEqual(
            l.pageCollection().page(0).sizeWithUnits().height(), 380.36, 2)
        self.assertAlmostEqual(
            l.pageCollection().page(0).sizeWithUnits().units(),
            QgsUnitTypes.LayoutMillimeters)

        self.assertAlmostEqual(shape1.positionWithUnits().x(), 90.15, 2)
        self.assertAlmostEqual(shape1.positionWithUnits().y(), 20.21, 2)
        self.assertAlmostEqual(shape2.positionWithUnits().x(), 100.15, 2)
        self.assertAlmostEqual(shape2.positionWithUnits().y(), 120.21, 2)
        self.assertAlmostEqual(shape3.positionWithUnits().x(), 210.15, 2)
        self.assertAlmostEqual(shape3.positionWithUnits().y(), 220.21, 2)
        self.assertAlmostEqual(shape4.positionWithUnits().x(), 10.15, 2)
        self.assertAlmostEqual(shape4.positionWithUnits().y(), 310.21, 2)

        # add a second page
        page2 = QgsLayoutItemPage(l)
        page2.setPageSize("A4", QgsLayoutItemPage.Landscape)
        l.pageCollection().addPage(page2)

        # add some guides
        g1 = QgsLayoutGuide(
            Qt.Horizontal,
            QgsLayoutMeasurement(2.5, QgsUnitTypes.LayoutCentimeters),
            l.pageCollection().page(0))
        l.guides().addGuide(g1)
        g2 = QgsLayoutGuide(
            Qt.Vertical,
            QgsLayoutMeasurement(4.5, QgsUnitTypes.LayoutCentimeters),
            l.pageCollection().page(0))
        l.guides().addGuide(g2)

        # second page should be removed
        l.pageCollection().resizeToContents(QgsMargins(0, 0, 0, 0),
                                            QgsUnitTypes.LayoutCentimeters)
        self.assertEqual(l.pageCollection().pageCount(), 1)

        self.assertAlmostEqual(
            l.pageCollection().page(0).sizeWithUnits().width(), 250.3, 2)
        self.assertAlmostEqual(
            l.pageCollection().page(0).sizeWithUnits().height(), 320.36, 2)
        self.assertAlmostEqual(
            l.pageCollection().page(0).sizeWithUnits().units(),
            QgsUnitTypes.LayoutMillimeters)

        self.assertAlmostEqual(g1.position().length(), 0.5, 2)
        self.assertAlmostEqual(g2.position().length(), 3.5, 2)