Python QgsMapLayerStore.addMapLayer方法代码示例

# 需要导入模块: from qgis.core import QgsMapLayerStore [as 别名]
# 或者: from qgis.core.QgsMapLayerStore import addMapLayer [as 别名]
    def testTransferLayers(self):
        # test transferring all layers from another store
        store1 = QgsMapLayerStore()
        store2 = QgsMapLayerStore()

        # empty stores
        store1.transferLayersFromStore(store2)

        # silly behavior checks
        store1.transferLayersFromStore(None)
        store1.transferLayersFromStore(store1)

        l1 = createLayer('l1')
        l2 = createLayer('l2')
        store1.addMapLayer(l1)
        store1.addMapLayer(l2)

        l3 = createLayer('l3')
        store2.addMapLayer(l3)

        store2.transferLayersFromStore(store1)
        self.assertFalse(store1.mapLayers()) # no layers left
        self.assertEqual(len(store2.mapLayers()), 3)
        self.assertEqual(store2.mapLayers(), {l1.id(): l1, l2.id(): l2, l3.id(): l3})

        store1.transferLayersFromStore(store2)
        self.assertFalse(store2.mapLayers()) # no layers left
        self.assertEqual(len(store1.mapLayers()), 3)
        self.assertEqual(store1.mapLayers(), {l1.id(): l1, l2.id(): l2, l3.id(): l3})

# 需要导入模块: from qgis.core import QgsMapLayerStore [as 别名]
# 或者: from qgis.core.QgsMapLayerStore import addMapLayer [as 别名]
    def testTakeLayer(self):
        # test taking ownership of a layer from the store
        l1 = createLayer('l1')
        l2 = createLayer('l2')
        store = QgsMapLayerStore()

        # add one layer to store
        store.addMapLayer(l1)
        self.assertEqual(store.mapLayers(), {l1.id(): l1})
        self.assertEqual(l1.parent(), store)

        # try taking some layers which don't exist in store
        self.assertFalse(store.takeMapLayer(None))
        self.assertFalse(store.takeMapLayer(l2))
        # but l2 should still exist..
        self.assertTrue(l2.isValid())

        # take layer from store
        self.assertEqual(store.takeMapLayer(l1), l1)
        self.assertFalse(store.mapLayers()) # no layers left
        # but l1 should still exist
        self.assertTrue(l1.isValid())
        # layer should have no parent now
        self.assertFalse(l1.parent())

        # destroy store
        store = None
        self.assertTrue(l1.isValid())

# 需要导入模块: from qgis.core import QgsMapLayerStore [as 别名]
# 或者: from qgis.core.QgsMapLayerStore import addMapLayer [as 别名]
    def test_mapLayersByName(self):
        """ test retrieving map layer by name """
        store = QgsMapLayerStore()

        # test no crash with empty store
        self.assertEqual(store.mapLayersByName('bad'), [])
        self.assertEqual(store.mapLayersByName(None), [])

        l1 = createLayer('test')
        l2 = createLayer('test2')

        store.addMapLayers([l1, l2])

        self.assertEqual(store.mapLayersByName('bad'), [])
        self.assertEqual(store.mapLayersByName(None), [])
        self.assertEqual(store.mapLayersByName('test'), [l1])
        self.assertEqual(store.mapLayersByName('test2'), [l2])

        #duplicate name

        # little bit of a hack - we don't want a duplicate ID and since IDs are currently based on time we wait a bit here
        sleep(0.1)
        l3 = createLayer('test')

        store.addMapLayer(l3)
        self.assertEqual(set(store.mapLayersByName('test')), {l1, l3})

# 需要导入模块: from qgis.core import QgsMapLayerStore [as 别名]
# 或者: from qgis.core.QgsMapLayerStore import addMapLayer [as 别名]
    def test_addMapLayerAlreadyAdded(self):
        """ test that already added layers can't be readded to store """
        store = QgsMapLayerStore()

        l1 = createLayer('test')
        store.addMapLayer(l1)
        self.assertEqual(len(store.mapLayersByName('test')), 1)
        self.assertEqual(store.count(), 1)
        self.assertEqual(store.addMapLayer(l1), None)
        self.assertEqual(len(store.mapLayersByName('test')), 1)
        self.assertEqual(store.count(), 1)
        self.assertEqual(len(store), 1)

# 需要导入模块: from qgis.core import QgsMapLayerStore [as 别名]
# 或者: from qgis.core.QgsMapLayerStore import addMapLayer [as 别名]
    def test_addMapLayerInvalid(self):
        """ test that invalid map layers can't be added to store """
        store = QgsMapLayerStore()

        self.assertEqual(store.addMapLayer(QgsVectorLayer("Point?field=x:string", 'test', "xxx")), None)
        self.assertEqual(len(store.mapLayersByName('test')), 0)
        self.assertEqual(store.count(), 0)

# 需要导入模块: from qgis.core import QgsMapLayerStore [as 别名]
# 或者: from qgis.core.QgsMapLayerStore import addMapLayer [as 别名]
    def test_addMapLayer(self):
        """ test adding individual map layers to store"""
        store = QgsMapLayerStore()

        l1 = createLayer('test')
        self.assertEqual(store.addMapLayer(l1), l1)
        self.assertEqual(len(store.mapLayersByName('test')), 1)
        self.assertEqual(store.count(), 1)
        self.assertEqual(len(store), 1)

        # adding a second layer should leave existing layers intact
        l2 = createLayer('test2')
        self.assertEqual(store.addMapLayer(l2), l2)
        self.assertEqual(len(store.mapLayersByName('test')), 1)
        self.assertEqual(len(store.mapLayersByName('test2')), 1)
        self.assertEqual(store.count(), 2)
        self.assertEqual(len(store), 2)

# 需要导入模块: from qgis.core import QgsMapLayerStore [as 别名]
# 或者: from qgis.core.QgsMapLayerStore import addMapLayer [as 别名]
    def test_addMapLayerSignals(self):
        """ test that signals are correctly emitted when adding map layer"""

        store = QgsMapLayerStore()

        layer_was_added_spy = QSignalSpy(store.layerWasAdded)
        layers_added_spy = QSignalSpy(store.layersAdded)

        l1 = createLayer('test')
        store.addMapLayer(l1)

        # can't seem to actually test the data which was emitted, so best we can do is test
        # the signal count
        self.assertEqual(len(layer_was_added_spy), 1)
        self.assertEqual(len(layers_added_spy), 1)

        store.addMapLayer(createLayer('test2'))
        self.assertEqual(len(layer_was_added_spy), 2)
        self.assertEqual(len(layers_added_spy), 2)

        # try readding a layer already in the store
        store.addMapLayer(l1)
        # should be no extra signals emitted
        self.assertEqual(len(layer_was_added_spy), 2)
        self.assertEqual(len(layers_added_spy), 2)