Python QgsCompositionChecker.setControlPathPrefix方法代码示例

# 需要导入模块: from qgscompositionchecker import QgsCompositionChecker [as 别名]
# 或者: from qgscompositionchecker.QgsCompositionChecker import setControlPathPrefix [as 别名]
    def testGrid(self):
        """Test that we can create a grid for a map."""
        myRectangle = QgsRectangle(781662.375, 3339523.125,
                                   793062.375, 3345223.125)
        self.mComposerMap.setNewExtent(myRectangle)
        self.mComposerMap.grid().setEnabled(True)
        self.mComposerMap.grid().setIntervalX(2000)
        self.mComposerMap.grid().setIntervalY(2000)
        self.mComposerMap.grid().setAnnotationEnabled(True)
        self.mComposerMap.grid().setGridLineColor(QColor(0, 255, 0))
        self.mComposerMap.grid().setGridLineWidth(0.5)
        self.mComposerMap.grid().setAnnotationFont(QgsFontUtils.getStandardTestFont())
        self.mComposerMap.grid().setAnnotationPrecision(0)
        self.mComposerMap.grid().setAnnotationDisplay(QgsComposerMapGrid.HideAll, QgsComposerMapGrid.Left)
        self.mComposerMap.grid().setAnnotationPosition(QgsComposerMapGrid.OutsideMapFrame, QgsComposerMapGrid.Right)
        self.mComposerMap.grid().setAnnotationDisplay(QgsComposerMapGrid.HideAll, QgsComposerMapGrid.Top)
        self.mComposerMap.grid().setAnnotationPosition(QgsComposerMapGrid.OutsideMapFrame, QgsComposerMapGrid.Bottom)
        self.mComposerMap.grid().setAnnotationDirection(QgsComposerMapGrid.Horizontal, QgsComposerMapGrid.Right)
        self.mComposerMap.grid().setAnnotationDirection(QgsComposerMapGrid.Horizontal, QgsComposerMapGrid.Bottom)
        self.mComposerMap.grid().setAnnotationFontColor(QColor(255, 0, 0, 150))
        self.mComposerMap.grid().setBlendMode(QPainter.CompositionMode_Overlay)
        self.mComposerMap.updateBoundingRect()

        checker = QgsCompositionChecker('composermap_grid', self.mComposition)
        checker.setControlPathPrefix("composer_mapgrid")
        myTestResult, myMessage = checker.testComposition()
        self.mComposerMap.grid().setEnabled(False)
        self.mComposerMap.grid().setAnnotationEnabled(False)

        assert myTestResult, myMessage

# 需要导入模块: from qgscompositionchecker import QgsCompositionChecker [as 别名]
# 或者: from qgscompositionchecker.QgsCompositionChecker import setControlPathPrefix [as 别名]
    def testTableMultiFrame(self):
        """Test we can render to multiframes."""
        composerHtml = QgsComposerHtml(self.mComposition, False)
        htmlFrame = QgsComposerFrame(self.mComposition, composerHtml,
                                     10, 10, 100, 50)
        composerHtml.addFrame(htmlFrame)
        composerHtml.setResizeMode(
            QgsComposerMultiFrame.RepeatUntilFinished)
        composerHtml.setUseSmartBreaks(False)
        composerHtml.setUrl(self.htmlUrl())
        composerHtml.frame(0).setFrameEnabled(True)

        print("Checking page 1")
        myPage = 0
        checker1 = QgsCompositionChecker('composerhtml_multiframe1', self.mComposition)
        checker1.setControlPathPrefix("composer_html")
        myTestResult, myMessage = checker1.testComposition(myPage)
        assert myTestResult, myMessage

        print("Checking page 2")
        myPage = 1
        checker2 = QgsCompositionChecker('composerhtml_multiframe2', self.mComposition)
        checker2.setControlPathPrefix("composer_html")
        myTestResult, myMessage = checker2.testComposition(myPage)
        assert myTestResult, myMessage

        self.mComposition.removeMultiFrame(composerHtml)
        composerHtml = None

        assert myTestResult, myMessage

# 需要导入模块: from qgscompositionchecker import QgsCompositionChecker [as 别名]
# 或者: from qgscompositionchecker.QgsCompositionChecker import setControlPathPrefix [as 别名]
    def testDefaultStyle(self):
        """Test polygon rendering with default style."""

        self.mComposerPolygon.setDisplayNodes(False)
        checker = QgsCompositionChecker("composerpolygon_defaultstyle", self.mComposition)
        checker.setControlPathPrefix("composer_polygon")
        myTestResult, myMessage = checker.testComposition()
        assert myTestResult, myMessage

# 需要导入模块: from qgscompositionchecker import QgsCompositionChecker [as 别名]
# 或者: from qgscompositionchecker.QgsCompositionChecker import setControlPathPrefix [as 别名]
    def testResizeZoom(self):
        """Test picture resize zoom mode."""
        self.composerPicture.setResizeMode(QgsComposerPicture.Zoom)

        checker = QgsCompositionChecker('composerpicture_resize_zoom', self.composition)
        checker.setControlPathPrefix("composer_picture")
        testResult, message = checker.testComposition()

        assert testResult, message

# 需要导入模块: from qgscompositionchecker import QgsCompositionChecker [as 别名]
# 或者: from qgscompositionchecker.QgsCompositionChecker import setControlPathPrefix [as 别名]
    def testTriangle(self):
        """Test triangle composer shape"""

        self.mComposerShape.setShapeType(QgsComposerShape.Triangle)

        checker = QgsCompositionChecker('composershapes_triangle', self.mComposition)
        checker.setControlPathPrefix("composer_shapes")
        myTestResult, myMessage = checker.testComposition()

        assert myTestResult, myMessage

# 需要导入模块: from qgscompositionchecker import QgsCompositionChecker [as 别名]
# 或者: from qgscompositionchecker.QgsCompositionChecker import setControlPathPrefix [as 别名]
    def testRemoteImage(self):
        """Test fetching remote picture."""
        self.composerPicture.setPicturePath('http://localhost:' + str(TestQgsComposerPicture.port) + '/qgis_local_server/logo.png')

        checker = QgsCompositionChecker('composerpicture_remote', self.composition)
        checker.setControlPathPrefix("composer_picture")
        testResult, message = checker.testComposition()

        self.composerPicture.setPicturePath(self.pngImage)
        assert testResult, message

# 需要导入模块: from qgscompositionchecker import QgsCompositionChecker [as 别名]
# 或者: from qgscompositionchecker.QgsCompositionChecker import setControlPathPrefix [as 别名]
    def testRemoveNode(self):
        """Test removeNode method"""

        rc = self.mComposerPolygon.removeNode(100)
        self.assertEqual(rc, False)

        checker = QgsCompositionChecker("composerpolygon_defaultstyle", self.mComposition)
        checker.setControlPathPrefix("composer_polygon")
        myTestResult, myMessage = checker.testComposition()
        assert myTestResult, myMessage

        self.assertEqual(self.mComposerPolygon.nodesSize(), 4)

# 需要导入模块: from qgscompositionchecker import QgsCompositionChecker [as 别名]
# 或者: from qgscompositionchecker.QgsCompositionChecker import setControlPathPrefix [as 别名]
    def testRoundedRectangle(self):
        """Test rounded rectangle composer shape"""

        self.mComposerShape.setShapeType(QgsComposerShape.Rectangle)
        self.mComposerShape.setCornerRadius(30)

        checker = QgsCompositionChecker('composershapes_roundedrect', self.mComposition)
        checker.setControlPathPrefix("composer_shapes")
        myTestResult, myMessage = checker.testComposition()

        self.mComposerShape.setCornerRadius(0)
        assert myTestResult, myMessage

# 需要导入模块: from qgscompositionchecker import QgsCompositionChecker [as 别名]
# 或者: from qgscompositionchecker.QgsCompositionChecker import setControlPathPrefix [as 别名]
    def testMoveNode(self):
        """Test moveNode method"""

        rc = self.mComposerPolygon.moveNode(30, QPointF(100.0, 300.0))
        self.assertEqual(rc, False)

        rc = self.mComposerPolygon.moveNode(3, QPointF(100.0, 150.0))
        self.assertEqual(rc, True)

        checker = QgsCompositionChecker("composerpolygon_movenode", self.mComposition)
        checker.setControlPathPrefix("composer_polygon")
        myTestResult, myMessage = checker.testComposition()
        assert myTestResult, myMessage

# 需要导入模块: from qgscompositionchecker import QgsCompositionChecker [as 别名]
# 或者: from qgscompositionchecker.QgsCompositionChecker import setControlPathPrefix [as 别名]
    def testDisplayNodes(self):
        """Test displayNodes method"""

        self.mComposerPolygon.setDisplayNodes(True)
        checker = QgsCompositionChecker("composerpolygon_displaynodes", self.mComposition)
        checker.setControlPathPrefix("composer_polygon")
        myTestResult, myMessage = checker.testComposition()
        assert myTestResult, myMessage

        self.mComposerPolygon.setDisplayNodes(False)
        checker = QgsCompositionChecker("composerpolygon_defaultstyle", self.mComposition)
        checker.setControlPathPrefix("composer_polygon")
        myTestResult, myMessage = checker.testComposition()
        assert myTestResult, myMessage

# 需要导入模块: from qgscompositionchecker import QgsCompositionChecker [as 别名]
# 或者: from qgscompositionchecker.QgsCompositionChecker import setControlPathPrefix [as 别名]
 def testOverviewMapCenter(self):
     overviewMap = QgsComposerMap(self.mComposition, 20, 130, 70, 70)
     overviewMap.setFrameEnabled(True)
     self.mComposition.addComposerMap(overviewMap)
     # zoom in
     myRectangle = QgsRectangle(192, -288, 320, -224)
     self.mComposerMap.setNewExtent(myRectangle)
     myRectangle2 = QgsRectangle(0, -256, 256, 0)
     overviewMap.setNewExtent(myRectangle2)
     overviewMap.overview().setFrameMap(self.mComposerMap.id())
     overviewMap.overview().setInverted(False)
     overviewMap.overview().setCentered(True)
     checker = QgsCompositionChecker('composermap_overview_center', self.mComposition)
     checker.setControlPathPrefix("composer_mapoverview")
     myTestResult, myMessage = checker.testComposition()
     self.mComposition.removeComposerItem(overviewMap)
     assert myTestResult, myMessage

# 需要导入模块: from qgscompositionchecker import QgsCompositionChecker [as 别名]
# 或者: from qgscompositionchecker.QgsCompositionChecker import setControlPathPrefix [as 别名]
 def testOverviewMapBlend(self):
     overviewMap = QgsComposerMap(self.mComposition, 20, 130, 70, 70)
     overviewMap.setFrameEnabled(True)
     overviewMap.setLayers([self.raster_layer])
     self.mComposition.addComposerMap(overviewMap)
     # zoom in
     myRectangle = QgsRectangle(96, -152, 160, -120)
     self.mComposerMap.setNewExtent(myRectangle)
     myRectangle2 = QgsRectangle(0, -256, 256, 0)
     overviewMap.setNewExtent(myRectangle2)
     overviewMap.overview().setFrameMap(self.mComposerMap.id())
     overviewMap.overview().setBlendMode(QPainter.CompositionMode_Multiply)
     checker = QgsCompositionChecker('composermap_overview_blending', self.mComposition)
     checker.setControlPathPrefix("composer_mapoverview")
     myTestResult, myMessage = checker.testComposition()
     self.mComposition.removeComposerItem(overviewMap)
     assert myTestResult, myMessage

# 需要导入模块: from qgscompositionchecker import QgsCompositionChecker [as 别名]
# 或者: from qgscompositionchecker.QgsCompositionChecker import setControlPathPrefix [as 别名]
    def fixedscale_render_test(self):
        self.mAtlasMap.setNewExtent(QgsRectangle(209838.166, 6528781.020, 610491.166, 6920530.620))
        self.mAtlasMap.setAtlasDriven(True)
        self.mAtlasMap.setAtlasScalingMode(QgsComposerMap.Fixed)

        self.mAtlas.beginRender()

        for i in range(0, 2):
            self.mAtlas.prepareForFeature(i)
            self.mLabel1.adjustSizeToText()

            checker = QgsCompositionChecker('atlas_fixedscale%d' % (i + 1), self.mComposition)
            checker.setControlPathPrefix("atlas")
            myTestResult, myMessage = checker.testComposition(0, 200)

            assert myTestResult
        self.mAtlas.endRender()

# 需要导入模块: from qgscompositionchecker import QgsCompositionChecker [as 别名]
# 或者: from qgscompositionchecker.QgsCompositionChecker import setControlPathPrefix [as 别名]
    def testTable(self):
        """Test we can render a html table in a single frame."""
        composerHtml = QgsComposerHtml(self.mComposition, False)
        htmlFrame = QgsComposerFrame(self.mComposition, composerHtml, 0, 0, 100, 200)
        htmlFrame.setFrameEnabled(True)
        composerHtml.addFrame(htmlFrame)
        composerHtml.setUrl(self.htmlUrl())

        checker = QgsCompositionChecker("composerhtml_table", self.mComposition)
        checker.setControlPathPrefix("composer_html")
        myTestResult, myMessage = checker.testComposition()

        qDebug(myMessage)
        self.mComposition.removeMultiFrame(composerHtml)
        composerHtml = None

        assert myTestResult, myMessage

# 需要导入模块: from qgscompositionchecker import QgsCompositionChecker [as 别名]
# 或者: from qgscompositionchecker.QgsCompositionChecker import setControlPathPrefix [as 别名]
    def testSelectedNode(self):
        """Test selectedNode and unselectNode methods"""

        self.mComposerPolygon.setDisplayNodes(True)

        self.mComposerPolygon.setSelectedNode(3)
        checker = QgsCompositionChecker("composerpolygon_selectednode", self.mComposition)
        checker.setControlPathPrefix("composer_polygon")
        myTestResult, myMessage = checker.testComposition()
        assert myTestResult, myMessage

        self.mComposerPolygon.unselectNode()
        self.mComposerPolygon.setDisplayNodes(False)
        checker = QgsCompositionChecker("composerpolygon_defaultstyle", self.mComposition)
        checker.setControlPathPrefix("composer_polygon")
        myTestResult, myMessage = checker.testComposition()
        assert myTestResult, myMessage