Python core.QgsAuxiliaryStorage类代码示例

    def testClear(self):
        s = QgsAuxiliaryStorage()
        self.assertTrue(s.isValid())

        # Create a new auxiliary layer with 'pk' as key
        vl = createLayer()
        pkf = vl.fields().field(vl.fields().indexOf('pk'))
        al = s.createAuxiliaryLayer(pkf, vl)
        self.assertTrue(al.isValid())
        vl.setAuxiliaryLayer(al)

        # Add a field in auxiliary layer
        p = QgsPropertyDefinition('myprop', QgsPropertyDefinition.DataTypeNumeric, '', '', 'me')
        self.assertFalse(al.exists(p))
        self.assertTrue(al.addAuxiliaryField(p))
        self.assertTrue(al.exists(p))

        # Count auxiliary features
        self.assertEqual(al.featureCount(), 0)

        # Set value for auxiliary fields
        req = QgsFeatureRequest().setFilterExpression("name = 'Honey'")
        f = QgsFeature()
        vl.getFeatures(req).nextFeature(f)
        self.assertTrue(f.isValid())
        afName = QgsAuxiliaryLayer.nameFromProperty(p, True)
        index = vl.fields().indexOf(afName)
        vl.changeAttributeValue(f.id(), index, 333)

        # Count auxiliary features
        self.assertEqual(al.featureCount(), 1)

        # Clear and count
        al.clear()
        self.assertEqual(al.featureCount(), 0)

    def testCreateSaveOpenStorageWithProject(self):
        # New project without fileName
        p = QgsProject()

        # Create storage
        s0 = QgsAuxiliaryStorage(p)
        self.assertTrue(s0.isValid())

        # saveAs should be used instead of save in case of an empty string
        # given to the constructor of QgsAuxiliaryStorage
        self.assertEqual(s0.fileName(), "")
        self.assertFalse(s0.save())

        # saveAs
        f = tmpPath()
        self.assertTrue(s0.saveAs(f))

    def testSetAuxiliaryLayer(self):
        s = QgsAuxiliaryStorage()
        self.assertTrue(s.isValid())

        # Create a new auxiliary layer with 'pk' as key
        vl = createLayer()
        pkf = vl.fields().field(vl.fields().indexOf('pk'))
        al = s.createAuxiliaryLayer(pkf, vl)
        self.assertTrue(al.isValid())
        vl.setAuxiliaryLayer(al)

        self.assertIsNotNone(vl.auxiliaryLayer())

        # Clear auxiliary layer
        al.clear()
        # Remove auxiliary layer
        vl.setAuxiliaryLayer()

        self.assertIsNone(vl.auxiliaryLayer())

    def testCreateProperty(self):
        s = QgsAuxiliaryStorage()
        self.assertTrue(s.isValid())

        # Create a new auxiliary layer with 'pk' as key
        vl = createLayer()
        pkf = vl.fields().field(vl.fields().indexOf('pk'))
        al = s.createAuxiliaryLayer(pkf, vl)
        self.assertTrue(al.isValid())
        vl.setAuxiliaryLayer(al)

        # Create a new labeling property on layer without labels
        key = QgsPalLayerSettings.PositionX
        index = QgsAuxiliaryLayer.createProperty(key, vl)
        self.assertEqual(index, -1)

        vl.setLabeling(QgsVectorLayerSimpleLabeling(QgsPalLayerSettings()))
        index = QgsAuxiliaryLayer.createProperty(key, vl)

        p = QgsPalLayerSettings.propertyDefinitions()[key]
        afName = QgsAuxiliaryLayer.nameFromProperty(p, True)
        afIndex = vl.fields().indexOf(afName)
        self.assertEqual(index, afIndex)

    def testCreateSaveOpenStorageWithString(self):
        # Empty string in copy mode. A new database is created in a temporary
        # file.
        s0 = QgsAuxiliaryStorage()
        self.assertTrue(s0.isValid())

        # saveAs should be used instead of save in case of an empty string
        # given to the constructor of QgsAuxiliaryStorage
        self.assertEqual(s0.fileName(), "")
        self.assertFalse(s0.save())

        # Create a new auxiliary layer with 'pk' as key
        vl0 = createLayer()
        pkf = vl0.fields().field(vl0.fields().indexOf('pk'))
        al0 = s0.createAuxiliaryLayer(pkf, vl0)
        self.assertTrue(al0.isValid())

        # Test the auxiliary key
        key = al0.joinInfo().targetFieldName()
        self.assertEqual(key, 'pk')

        # Add a field in auxiliary layer
        p = QgsPropertyDefinition('propName', QgsPropertyDefinition.DataTypeNumeric, '', '', 'user')
        self.assertTrue(al0.addAuxiliaryField(p))

        # saveAs without saving the auxiliary layer, the auxiliary field is lost
        f = tmpPath()
        self.assertTrue(s0.saveAs(f))

        # Open the previous database.
        s1 = QgsAuxiliaryStorage(f)
        self.assertTrue(s1.isValid())

        # Load the auxiliary layer from auxiliary storage
        self.assertTrue(vl0.loadAuxiliaryLayer(s1, key))

        # As the vl0 has not been saved before saving the storage, there
        # shouldn't have auxiliary fields
        self.assertEqual(len(vl0.auxiliaryLayer().auxiliaryFields()), 0)

        # Save the layer before saving the storage
        self.assertTrue(al0.save())
        self.assertTrue(s0.saveAs(f))

        # Open the previous database.
        s2 = QgsAuxiliaryStorage(f)
        self.assertTrue(s2.isValid())

        # Load the auxiliary layer from auxiliary storage
        self.assertTrue(vl0.loadAuxiliaryLayer(s2, key))

        # As the vl0 has been saved before saving the storage, there
        # should have 1 auxiliary field
        self.assertEqual(len(vl0.auxiliaryLayer().auxiliaryFields()), 1)

        # save is available on s2
        self.assertTrue(s2.save())

    def testAuxiliaryFieldWidgets(self):
        # Init storage
        s = QgsAuxiliaryStorage()
        self.assertTrue(s.isValid())

        # Create a new auxiliary layer with 'pk' as key
        vl = createLayer()
        pkf = vl.fields().field(vl.fields().indexOf('pk'))
        al = s.createAuxiliaryLayer(pkf, vl)
        self.assertTrue(al.isValid())

        # Set the auxiliary layer to the vector layer
        vl.setAuxiliaryLayer(al)

        # Add a visible property
        p = QgsPropertyDefinition('propName', QgsPropertyDefinition.DataTypeNumeric, '', '', 'user')
        self.assertTrue(al.addAuxiliaryField(p))

        index = al.indexOfPropertyDefinition(p)
        self.assertFalse(al.isHiddenProperty(index))

        afName = QgsAuxiliaryLayer.nameFromProperty(p, True)
        index = vl.fields().indexOf(afName)
        setup = vl.editorWidgetSetup(index)
        self.assertEqual(setup.type(), '')

        tested = False
        for c in vl.attributeTableConfig().columns():
            if c.name == afName:
                self.assertFalse(c.hidden)
                tested = True
                break
        self.assertTrue(tested)

        # Add a hidden property
        p = QgsPalLayerSettings.propertyDefinitions()[QgsPalLayerSettings.PositionX]
        self.assertTrue(al.addAuxiliaryField(p))

        index = al.indexOfPropertyDefinition(p)
        self.assertTrue(al.isHiddenProperty(index))

        afName = QgsAuxiliaryLayer.nameFromProperty(p, True)
        index = vl.fields().indexOf(afName)
        setup = vl.editorWidgetSetup(index)
        self.assertEqual(setup.type(), 'Hidden')

        tested = False
        for c in vl.attributeTableConfig().columns():
            if c.name == afName:
                self.assertTrue(c.hidden)
                tested = True
                break
        self.assertTrue(tested)

        # Add a color property
        p = QgsSymbolLayer.propertyDefinitions()[QgsSymbolLayer.PropertyFillColor]
        self.assertTrue(al.addAuxiliaryField(p))

        index = al.indexOfPropertyDefinition(p)
        self.assertFalse(al.isHiddenProperty(index))

        afName = QgsAuxiliaryLayer.nameFromProperty(p, True)
        index = vl.fields().indexOf(afName)
        setup = vl.editorWidgetSetup(index)
        self.assertEqual(setup.type(), 'Color')