def testSplitToLines(self):
self.assertEqual(QgsPalLabeling.splitToLines('', ''), [''])
self.assertEqual(QgsPalLabeling.splitToLines('abc def', ''),
['abc def'])
self.assertEqual(QgsPalLabeling.splitToLines('abc def', ' '),
['abc', 'def'])
self.assertEqual(QgsPalLabeling.splitToLines('abc\ndef', ' '),
['abc', 'def'])
def sync_map_settings(self):
"""
Sync custom test QgsMapSettings to Project file
"""
pal = QgsPalLabeling()
pal.loadEngineSettings()
pal.init(self._TestMapSettings)
pal.saveEngineSettings()
def setUpClass(cls):
"""Run before all tests"""
# Store/load the FreeSansQGIS labeling test font
myFontDB = QFontDatabase()
cls._testFontID = myFontDB.addApplicationFont(
os.path.join(TEST_DATA_DIR, 'font', 'FreeSansQGIS.ttf'))
myMessage = ('\nCould not store test font in font database, '
'skipping test suite')
assert cls._testFontID != -1, myMessage
cls._testFont = myFontDB.font('FreeSansQGIS', 'Medium', 12)
myAppFont = QApplication.font()
myMessage = ('\nCould not load test font from font database, '
'skipping test suite')
assert cls._testFont.toString() != myAppFont.toString(), myMessage
# initialize class MapRegistry, Canvas, MapRenderer, Map and PAL
cls._MapRegistry = QgsMapLayerRegistry.instance()
cls._Canvas = CANVAS
# to match render test comparisons background
cls._Canvas.setCanvasColor(QColor(152, 219, 249))
cls._Map = cls._Canvas.map()
cls._Map.resize(QSize(600, 400))
cls._MapRenderer = cls._Canvas.mapRenderer()
cls._MapRenderer.setOutputSize(QSize(600, 400), 72)
cls._Pal = QgsPalLabeling()
cls._MapRenderer.setLabelingEngine(cls._Pal)
cls._PalEngine = cls._MapRenderer.labelingEngine()
myMessage = ('\nCould initialize PAL labeling engine, '
'skipping test suite')
assert cls._PalEngine, myMessage
def __init__(self, parent=None):
QMainWindow.__init__(self, parent)
PyQt4.uic.loadUi(os.path.join(basepath, 'canvas.ui'), self)
self.canvas.setCanvasColor(Qt.white)
self.canvas.enableAntiAliasing(True)
pal = QgsPalLabeling()
self.canvas.mapRenderer().setLabelingEngine(pal)
QgsProject.instance().readProject.connect(self.readProject)
def test_layer_pal_activated(self):
# Verify, via engine, that PAL labeling can be activated for layer
lyr = self.defaultLayerSettings()
self.layer.setLabeling(QgsVectorLayerSimpleLabeling(lyr))
msg = '\nLayer labeling not activated, as reported by labelingEngine'
self.assertTrue(QgsPalLabeling.staticWillUseLayer(self.layer), msg)
# also test for vector tile layer
tile_layer = QgsVectorTileLayer('x', 'y')
self.assertFalse(QgsPalLabeling.staticWillUseLayer(tile_layer))
st = QgsVectorTileBasicLabelingStyle()
st.setStyleName("st1")
st.setLayerName("place")
st.setFilterExpression("rank = 1 AND class = 'country'")
st.setGeometryType(QgsWkbTypes.PointGeometry)
labeling = QgsVectorTileBasicLabeling()
labeling.setStyles([st])
tile_layer.setLabeling(labeling)
self.assertTrue(QgsPalLabeling.staticWillUseLayer(tile_layer))
def _initRenderer(self):
# set up a renderer
labeling = QgsPalLabeling()
renderer = QgsMapRenderer()
renderer.setDestinationCrs(self.exportSettings.crs)
renderer.setProjectionsEnabled(True)
renderer.setLabelingEngine(labeling)
# save renderer
self._labeling = labeling
self._renderer = renderer
def setUpClass(cls):
"""Run before all tests"""
# qgis instances
cls._QgisApp, cls._Canvas, cls._Iface, cls._Parent = \
QGISAPP, CANVAS, IFACE, PARENT
# verify that spatialite provider is available
msg = ('\nSpatialite provider not found, ' 'SKIPPING TEST SUITE')
res = 'spatialite' in QgsProviderRegistry.instance().providerList()
assert res, msg
# load the FreeSansQGIS labeling test font
fontdb = QFontDatabase()
cls._TestFontID = fontdb.addApplicationFont(
os.path.join(cls._TestDataDir, 'font', 'FreeSansQGIS.ttf'))
msg = ('\nCould not store test font in font database, '
'SKIPPING TEST SUITE')
assert cls._TestFontID != -1, msg
cls._TestFont = fontdb.font('FreeSansQGIS', 'Medium', 48)
appfont = QApplication.font()
msg = ('\nCould not load test font from font database, '
'SKIPPING TEST SUITE')
assert cls._TestFont.toString() != appfont.toString(), msg
cls._TestFunction = ''
cls._TestGroup = ''
cls._TestGroupPrefix = ''
cls._TestGroupAbbr = ''
# initialize class MapRegistry, Canvas, MapRenderer, Map and PAL
cls._MapRegistry = QgsMapLayerRegistry.instance()
# set color to match render test comparisons background
cls._Canvas.setCanvasColor(QColor(152, 219, 249))
cls._Map = cls._Canvas.map()
cls._Map.resize(QSize(600, 400))
cls._MapRenderer = cls._Canvas.mapRenderer()
crs = QgsCoordinateReferenceSystem()
# default for labeling test data sources: WGS 84 / UTM zone 13N
crs.createFromSrid(32613)
cls._MapRenderer.setDestinationCrs(crs)
# use platform's native logical output dpi for QgsMapRenderer on launch
cls._Pal = QgsPalLabeling()
cls._MapRenderer.setLabelingEngine(cls._Pal)
cls._PalEngine = cls._MapRenderer.labelingEngine()
msg = ('\nCould not initialize PAL labeling engine, '
'SKIPPING TEST SUITE')
assert cls._PalEngine, msg
def __init__(self, parent=None):
super(MapWidget, self).__init__(parent)
self.setupUi(self)
self.canvas.setCanvasColor(Qt.white)
self.canvas.enableAntiAliasing(True)
self.canvas.setWheelAction(QgsMapCanvas.WheelZoomToMouseCursor)
self.canvas.mapRenderer().setLabelingEngine(QgsPalLabeling())
self.style = QgsStyleV2.defaultStyle()
self.styledlg = None
self.bridge = QgsLayerTreeMapCanvasBridge(QgsProject.instance().layerTreeRoot(), self.canvas)
self.bridge.setAutoSetupOnFirstLayer(False)
QgsProject.instance().writeProject.connect(self.bridge.writeProject)
QgsProject.instance().readProject.connect(self.bridge.readProject)
self.applyStyleButton.pressed.connect(self.apply_style)
def setUpClass(cls):
"""Run before all tests"""
# qgis instances
cls._QgisApp, cls._Canvas, cls._Iface, cls._Parent = \
QGISAPP, CANVAS, IFACE, PARENT
# verify that spatialite provider is available
msg = '\nSpatialite provider not found, SKIPPING TEST SUITE'
res = 'spatialite' in QgsProviderRegistry.instance().providerList()
assert res, msg
# load the FreeSansQGIS labeling test font
msg = '\nCould not load test font, SKIPPING TEST SUITE'
assert TESTFONT is not None, msg
cls._TestFunction = ''
cls._TestGroup = ''
cls._TestGroupPrefix = ''
cls._TestGroupAbbr = ''
cls._TestImage = ''
# initialize class MapRegistry, Canvas, MapRenderer, Map and PAL
cls._MapRegistry = QgsMapLayerRegistry.instance()
# set color to match render test comparisons background
cls._Canvas.setCanvasColor(QColor(152, 219, 249))
cls._Map = cls._Canvas.map()
cls._Map.resize(QSize(600, 400))
cls._MapRenderer = cls._Canvas.mapRenderer()
cls._CRS = QgsCoordinateReferenceSystem()
# default for labeling test data sources: WGS 84 / UTM zone 13N
cls._CRS.createFromSrid(32613)
cls._MapRenderer.setDestinationCrs(cls._CRS)
# use platform's native logical output dpi for QgsMapRenderer on launch
cls._Pal = QgsPalLabeling()
cls._MapRenderer.setLabelingEngine(cls._Pal)
cls._PalEngine = cls._MapRenderer.labelingEngine()
msg = ('\nCould not initialize PAL labeling engine, '
'SKIPPING TEST SUITE')
assert cls._PalEngine, msg
def __init__(self, parent=None):
super(ProjectWidget, self).__init__(parent)
self.setupUi(self)
self.project = None
self.mapisloaded = False
self.bar = None
self.roamapp = None
menu = QMenu()
self.canvas.setCanvasColor(Qt.white)
self.canvas.enableAntiAliasing(True)
self.canvas.setWheelAction(QgsMapCanvas.WheelZoomToMouseCursor)
self.canvas.mapRenderer().setLabelingEngine(QgsPalLabeling())
# self.roamVersionLabel.setText("You are running IntraMaps Roam version {}".format(roam.__version__))
self.openProjectFolderButton.pressed.connect(self.openprojectfolder)
self.openinQGISButton.pressed.connect(self.openinqgis)
self.depolyProjectButton.pressed.connect(self.deploy_project)
self.depolyInstallProjectButton.pressed.connect(
functools.partial(self.deploy_project, True))
self.filewatcher = QFileSystemWatcher()
self.filewatcher.fileChanged.connect(self.qgisprojectupdated)
self.projectupdatedlabel.linkActivated.connect(self.reloadproject)
self.projectupdatedlabel.hide()
# self.setpage(4)
self.currentnode = None
self.form = None
qgislocation = r'C:\OSGeo4W\bin\qgis.bat'
qgislocation = roam.config.settings.setdefault('configmanager', {}) \
.setdefault('qgislocation', qgislocation)
self.qgispathEdit.setText(qgislocation)
self.qgispathEdit.textChanged.connect(self.save_qgis_path)
self.filePickerButton.pressed.connect(self.set_qgis_path)
def test_partials_labels_activate(self):
pal = QgsPalLabeling()
# Enable partials labels
pal.setShowingPartialsLabels(True)
self.assertTrue(pal.isShowingPartialsLabels())
def test_partials_labels_deactivate(self):
pal = QgsPalLabeling()
# Disable partials labels
pal.setShowingPartialsLabels(False)
self.assertFalse(pal.isShowingPartialsLabels())
def setDefaultEngineSettings(cls):
"""Restore default settings for pal labeling"""
cls._Pal = QgsPalLabeling()
def test_default_partials_labels_enabled(self):
# Verify ShowingPartialsLabels is enabled for PAL by default
pal = QgsPalLabeling()
self.assertTrue(pal.isShowingPartialsLabels())
def __init__(self, parent=None):
super(ProjectWidget, self).__init__(parent)
self.setupUi(self)
self.project = None
self.mapisloaded = False
self.bar = None
self.canvas.setCanvasColor(Qt.white)
self.canvas.enableAntiAliasing(True)
self.canvas.setWheelAction(QgsMapCanvas.WheelZoomToMouseCursor)
self.canvas.mapRenderer().setLabelingEngine(QgsPalLabeling())
self.fieldsmodel = QgsFieldModel()
self.widgetmodel = WidgetsModel()
self.possiblewidgetsmodel = QStandardItemModel()
self.formlayersmodel = QgsLayerModel(watchregistry=False)
self.formlayers = CaptureLayerFilter()
self.formlayers.setSourceModel(self.formlayersmodel)
self.selectlayermodel = CaptureLayersModel(watchregistry=False)
self.selectlayerfilter = LayerTypeFilter()
self.selectlayerfilter.setSourceModel(self.selectlayermodel)
self.selectlayermodel.dataChanged.connect(self.selectlayerschanged)
self.layerCombo.setModel(self.formlayers)
self.widgetCombo.setModel(self.possiblewidgetsmodel)
self.selectLayers.setModel(self.selectlayerfilter)
self.selectLayers_2.setModel(self.selectlayerfilter)
self.fieldList.setModel(self.fieldsmodel)
self.widgetlist.setModel(self.widgetmodel)
self.widgetlist.selectionModel().currentChanged.connect(self.updatecurrentwidget)
self.widgetmodel.rowsRemoved.connect(self.setwidgetconfigvisiable)
self.widgetmodel.rowsInserted.connect(self.setwidgetconfigvisiable)
self.widgetmodel.modelReset.connect(self.setwidgetconfigvisiable)
self.titleText.textChanged.connect(self.updatetitle)
QgsProject.instance().readProject.connect(self._readproject)
self.loadwidgettypes()
self.addWidgetButton.pressed.connect(self.newwidget)
self.removeWidgetButton.pressed.connect(self.removewidget)
self.roamVersionLabel.setText("You are running IntraMaps Roam version {}".format(roam.__version__))
self.openProjectFolderButton.pressed.connect(self.openprojectfolder)
self.openinQGISButton.pressed.connect(self.openinqgis)
self.filewatcher = QFileSystemWatcher()
self.filewatcher.fileChanged.connect(self.qgisprojectupdated)
self.formfolderLabel.linkActivated.connect(self.openformfolder)
self.projectupdatedlabel.linkActivated.connect(self.reloadproject)
self.projectupdatedlabel.hide()
self.formtab.currentChanged.connect(self.formtabchanged)
self.expressionButton.clicked.connect(self.opendefaultexpression)
self.fieldList.currentIndexChanged.connect(self.updatewidgetname)
self.fieldwarninglabel.hide()
for item, data in readonlyvalues:
self.readonlyCombo.addItem(item, data)
self.setpage(4)
self.form = None
def setDefaultEngineSettings(cls):
"""Restore default settings for pal labelling"""
cls._Pal = QgsPalLabeling()
cls._MapRenderer.setLabelingEngine(cls._Pal)
cls._PalEngine = cls._MapRenderer.labelingEngine()
def test_default_partials_labels_enabled(self):
# Verify ShowingPartialsLabels is enabled for PAL by default
pal = QgsPalLabeling()
self.assertTrue(pal.isShowingPartialsLabels())
def test_partials_labels_deactivate(self):
pal = QgsPalLabeling()
# Disable partials labels
pal.setShowingPartialsLabels(False)
self.assertFalse(pal.isShowingPartialsLabels())
def test_layer_pal_activated(self):
# Verify, via engine, that PAL labeling can be activated for layer
lyr = self.defaultLayerSettings()
lyr.writeToLayer(self.layer)
msg = "\nLayer labeling not activated, as reported by labelingEngine"
self.assertTrue(QgsPalLabeling.staticWillUseLayer(self.layer), msg)
def __init__(self):
super(MainWindow, self).__init__()
self.setupUi(self)
self.canvaslayers = []
self.layerbuttons = []
self.project = None
self.selectionbands = defaultdict(partial(QgsRubberBand, self.canvas))
self.canvas.setCanvasColor(Qt.white)
self.canvas.enableAntiAliasing(True)
self.canvas.setWheelAction(QgsMapCanvas.WheelZoomToMouseCursor)
self.bar = roam.messagebaritems.MessageBar(self.centralwidget)
self.actionMap.setVisible(False)
self.actionLegend.setVisible(False)
pal = QgsPalLabeling()
self.canvas.mapRenderer().setLabelingEngine(pal)
self.canvas.setFrameStyle(QFrame.NoFrame)
self.menuGroup = QActionGroup(self)
self.menuGroup.setExclusive(True)
self.menuGroup.addAction(self.actionMap)
self.menuGroup.addAction(self.actionDataEntry)
self.menuGroup.addAction(self.actionLegend)
self.menuGroup.addAction(self.actionProject)
self.menuGroup.addAction(self.actionSync)
self.menuGroup.addAction(self.actionSettings)
self.menuGroup.addAction(self.actionGPS)
self.menuGroup.triggered.connect(self.updatePage)
self.editgroup = QActionGroup(self)
self.editgroup.setExclusive(True)
self.editgroup.addAction(self.actionPan)
self.editgroup.addAction(self.actionZoom_In)
self.editgroup.addAction(self.actionZoom_Out)
self.editgroup.addAction(self.actionInfo)
self.actionLegend.triggered.connect(self.updatelegend)
self.actionGPS = GPSAction(":/icons/gps", self.canvas, self)
self.projecttoolbar.addAction(self.actionGPS)
self.projectwidget.requestOpenProject.connect(self.loadProject)
QgsProject.instance().readProject.connect(self._readProject)
self.gpswidget.setgps(GPS)
self.actionSettings.toggled.connect(
self.settingswidget.populateControls)
self.actionSettings.toggled.connect(self.settingswidget.readSettings)
self.settingswidget.settingsupdated.connect(self.settingsupdated)
self.dataentrywidget = DataEntryWidget(self.canvas, self.bar)
self.widgetpage.layout().addWidget(self.dataentrywidget)
self.dataentrywidget.rejected.connect(self.formrejected)
self.dataentrywidget.featuresaved.connect(self.featureSaved)
self.dataentrywidget.featuredeleted.connect(self.featuredeleted)
self.dataentrywidget.failedsave.connect(self.failSave)
self.dataentrywidget.helprequest.connect(self.showhelp)
def createSpacer(width=0, height=0):
widget = QWidget()
widget.setMinimumWidth(width)
widget.setMinimumHeight(height)
return widget
gpsspacewidget = createSpacer(30)
sidespacewidget = createSpacer(30)
sidespacewidget2 = createSpacer(height=20)
sidespacewidget.setSizePolicy(QSizePolicy.Expanding,
QSizePolicy.Expanding)
sidespacewidget2.setSizePolicy(QSizePolicy.Fixed, QSizePolicy.Fixed)
gpsspacewidget.setSizePolicy(QSizePolicy.Expanding,
QSizePolicy.Expanding)
self.topspaceraction = self.projecttoolbar.insertWidget(
self.actionGPS, gpsspacewidget)
def createlabel(text):
style = """
QLabel {
color: #706565;
font: 14px "Calibri" ;
}"""
label = QLabel(text)
label.setStyleSheet(style)
return label
self.projectlabel = createlabel("Project: {project}")
self.userlabel = createlabel(
"User: {user}".format(user=getpass.getuser()))
self.positionlabel = createlabel('')
self.gpslabel = createlabel("GPS: Not active")
self.statusbar.addWidget(self.projectlabel)
self.statusbar.addWidget(self.userlabel)
spacer = createSpacer()
spacer2 = createSpacer()
spacer.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Fixed)
spacer2.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Fixed)
self.statusbar.addWidget(spacer)
self.statusbar.addWidget(self.positionlabel)
self.statusbar.addWidget(spacer2)
self.statusbar.addWidget(self.gpslabel)
self.menutoolbar.insertWidget(self.actionQuit, sidespacewidget2)
self.menutoolbar.insertWidget(self.actionProject, sidespacewidget)
self.panels = []
self.connectButtons()
self.currentfeatureband = QgsRubberBand(self.canvas)
self.currentfeatureband.setIconSize(20)
self.currentfeatureband.setWidth(10)
self.currentfeatureband.setColor(QColor(186, 93, 212, 76))
self.canvas_page.layout().insertWidget(0, self.projecttoolbar)
self.dataentryselection = QAction(self.projecttoolbar)
self.dataentryaction = self.projecttoolbar.insertAction(
self.topspaceraction, self.dataentryselection)
self.dataentryselection.triggered.connect(self.selectdataentry)
self.centralwidget.layout().addWidget(self.statusbar)
self.actionGPSFeature.setProperty('dataentry', True)
self.infodock = InfoDock(self.canvas)
self.infodock.featureupdated.connect(self.highlightfeature)
self.infodock.hide()
self.hidedataentry()
self.canvas.extentsChanged.connect(self.updatestatuslabel)
RoamEvents.openimage.connect(self.openimage)
RoamEvents.openurl.connect(self.viewurl)
RoamEvents.openfeatureform.connect(self.openForm)
RoamEvents.openkeyboard.connect(self.openkeyboard)
RoamEvents.selectioncleared.connect(self.clearselection)
RoamEvents.editgeometry.connect(self.addforedit)
RoamEvents.editgeometry_complete.connect(self.on_geometryedit)
RoamEvents.onShowMessage.connect(self.showUIMessage)
RoamEvents.selectionchanged.connect(self.highlightselection)
RoamEvents.selectionchanged.connect(self.showInfoResults)
GPS.gpspostion.connect(self.updatecanvasfromgps)
GPS.firstfix.connect(self.gpsfirstfix)
GPS.gpsdisconnected.connect(self.gpsdisconnected)
self.lastgpsposition = None
self.marker = GPSMarker(self.canvas)
self.marker.hide()
self.legendpage.showmap.connect(self.showmap)
self.editfeaturestack = []
self.currentselection = {}
def __init__(self, parent=None):
super(MapWidget, self).__init__(parent)
self.setupUi(self)
self.snapping = True
icon = roam_style.iconsize()
self.projecttoolbar.setIconSize(QSize(icon, icon))
self.current_form = None
self.last_form = None
self.firstshow = True
self.layerbuttons = []
self.editfeaturestack = []
self.lastgpsposition = None
self.project = None
self.gps = None
self.gpslogging = None
self.selectionbands = defaultdict(partial(QgsRubberBand, self.canvas))
self.bridge = QgsLayerTreeMapCanvasBridge(
QgsProject.instance().layerTreeRoot(), self.canvas)
self.bridge.setAutoSetupOnFirstLayer(False)
QgsProject.instance().writeProject.connect(self.bridge.writeProject)
QgsProject.instance().readProject.connect(self.bridge.readProject)
# self.canvas.setInteractive(False)
self.canvas.setCanvasColor(Qt.white)
self.canvas.enableAntiAliasing(True)
self.canvas.setWheelAction(QgsMapCanvas.WheelZoomToMouseCursor)
self.snappingutils = SnappingUtils(self.canvas, self)
self.canvas.setSnappingUtils(self.snappingutils)
QgsProject.instance().readProject.connect(
self.snappingutils.readConfigFromProject)
if hasattr(self.canvas, 'setParallelRenderingEnabled'):
threadcount = QThread.idealThreadCount()
threadcount = 2 if threadcount > 2 else 1
QgsApplication.setMaxThreads(threadcount)
self.canvas.setParallelRenderingEnabled(True)
pal = QgsPalLabeling()
self.canvas.mapRenderer().setLabelingEngine(pal)
self.canvas.setFrameStyle(QFrame.NoFrame)
self.editgroup = QActionGroup(self)
self.editgroup.setExclusive(True)
self.editgroup.addAction(self.actionPan)
self.editgroup.addAction(self.actionZoom_In)
self.editgroup.addAction(self.actionZoom_Out)
self.editgroup.addAction(self.actionInfo)
self.actionGPS = GPSAction(":/icons/gps", self.canvas, self)
self.projecttoolbar.addAction(self.actionGPS)
if roam.config.settings.get('north_arrow', False):
self.northarrow = NorthArrow(":/icons/north", self.canvas)
self.northarrow.setPos(10, 10)
self.canvas.scene().addItem(self.northarrow)
smallmode = roam.config.settings.get("smallmode", False)
self.projecttoolbar.setSmallMode(smallmode)
self.scalebar_enabled = roam.config.settings.get('scale_bar', False)
if self.scalebar_enabled:
self.scalebar = ScaleBarItem(self.canvas)
self.canvas.scene().addItem(self.scalebar)
self.projecttoolbar.setContextMenuPolicy(Qt.CustomContextMenu)
gpsspacewidget = QWidget()
gpsspacewidget.setMinimumWidth(30)
gpsspacewidget.setSizePolicy(QSizePolicy.Expanding,
QSizePolicy.Expanding)
self.topspaceraction = self.projecttoolbar.insertWidget(
self.actionGPS, gpsspacewidget)
self.dataentryselection = QAction(self.projecttoolbar)
self.dataentryaction = self.projecttoolbar.insertAction(
self.topspaceraction, self.dataentryselection)
self.dataentryselection.triggered.connect(self.select_data_entry)
self.marker = GPSMarker(self.canvas)
self.marker.hide()
self.currentfeatureband = CurrentSelection(self.canvas)
self.currentfeatureband.setIconSize(30)
self.currentfeatureband.setWidth(10)
self.currentfeatureband.setColor(QColor(186, 93, 212, 50))
self.currentfeatureband.setOutlineColour(QColor(186, 93, 212))
self.gpsband = QgsRubberBand(self.canvas)
self.gpsband.setColor(QColor(165, 111, 212, 75))
self.gpsband.setWidth(5)
RoamEvents.editgeometry.connect(self.queue_feature_for_edit)
RoamEvents.selectioncleared.connect(self.clear_selection)
RoamEvents.selectionchanged.connect(self.highlight_selection)
RoamEvents.openfeatureform.connect(self.feature_form_loaded)
RoamEvents.sync_complete.connect(self.refresh_map)
RoamEvents.snappingChanged.connect(self.snapping_changed)
self.snappingbutton = QToolButton()
self.snappingbutton.setText("Snapping: On")
self.snappingbutton.setAutoRaise(True)
self.snappingbutton.pressed.connect(self.toggle_snapping)
spacer = QWidget()
spacer2 = QWidget()
spacer.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Fixed)
spacer2.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Fixed)
self.scalewidget = QgsScaleComboBox()
self.scalebutton = QToolButton()
self.scalebutton.setAutoRaise(True)
self.scalebutton.setMaximumHeight(self.statusbar.height())
self.scalebutton.pressed.connect(self.selectscale)
self.scalebutton.setText("Scale")
self.scalelist = BigList(parent=self.canvas,
centeronparent=True,
showsave=False)
self.scalelist.hide()
self.scalelist.setlabel("Map Scale")
self.scalelist.setmodel(self.scalewidget.model())
self.scalelist.closewidget.connect(self.scalelist.close)
self.scalelist.itemselected.connect(self.update_scale_from_item)
self.scalelist.itemselected.connect(self.scalelist.close)
self.positionlabel = QLabel('')
self.gpslabel = QLabel("GPS: Not active")
self.gpslabelposition = QLabel("")
self.statusbar.addWidget(self.snappingbutton)
self.statusbar.addWidget(spacer2)
self.statusbar.addWidget(self.gpslabel)
self.statusbar.addWidget(self.gpslabelposition)
self.statusbar.addPermanentWidget(self.scalebutton)
self.canvas.extentsChanged.connect(self.updatestatuslabel)
self.canvas.scaleChanged.connect(self.updatestatuslabel)
GPS.gpsposition.connect(self.update_gps_label)
GPS.gpsdisconnected.connect(self.gps_disconnected)
self.connectButtons()
def __init__(self, parent=None):
super(MapWidget, self).__init__(parent)
self.setupUi(self)
icon = roam_style.iconsize()
self.projecttoolbar.setIconSize(QSize(icon, icon))
self.firstshow = True
self.layerbuttons = []
self.editfeaturestack = []
self.lastgpsposition = None
self.project = None
self.gps = None
self.gpslogging = None
self.selectionbands = defaultdict(partial(QgsRubberBand, self.canvas))
# self.canvas.setInteractive(False)
self.canvas.setCanvasColor(Qt.white)
self.canvas.enableAntiAliasing(True)
self.canvas.setWheelAction(QgsMapCanvas.WheelZoomToMouseCursor)
if hasattr(self.canvas, 'setParallelRenderingEnabled'):
threadcount = QThread.idealThreadCount()
threadcount = 2 if threadcount > 2 else 1
QgsApplication.setMaxThreads(threadcount)
self.canvas.setParallelRenderingEnabled(True)
pal = QgsPalLabeling()
self.canvas.mapRenderer().setLabelingEngine(pal)
self.canvas.setFrameStyle(QFrame.NoFrame)
self.editgroup = QActionGroup(self)
self.editgroup.setExclusive(True)
self.editgroup.addAction(self.actionPan)
self.editgroup.addAction(self.actionZoom_In)
self.editgroup.addAction(self.actionZoom_Out)
self.editgroup.addAction(self.actionInfo)
self.actionGPS = GPSAction(":/icons/gps", self.canvas, self)
self.projecttoolbar.addAction(self.actionGPS)
if roam.config.settings.get('north_arrow', False):
self.northarrow = NorthArrow(":/icons/north", self.canvas)
self.northarrow.setPos(10, 10)
self.canvas.scene().addItem(self.northarrow)
self.scalebar_enabled = roam.config.settings.get('scale_bar', False)
if self.scalebar_enabled:
self.scalebar = ScaleBarItem(self.canvas)
self.canvas.scene().addItem(self.scalebar)
self.projecttoolbar.setContextMenuPolicy(Qt.CustomContextMenu)
gpsspacewidget = QWidget()
gpsspacewidget.setMinimumWidth(30)
gpsspacewidget.setSizePolicy(QSizePolicy.Expanding,
QSizePolicy.Expanding)
self.topspaceraction = self.projecttoolbar.insertWidget(
self.actionGPS, gpsspacewidget)
self.dataentryselection = QAction(self.projecttoolbar)
self.dataentryaction = self.projecttoolbar.insertAction(
self.topspaceraction, self.dataentryselection)
self.dataentryselection.triggered.connect(self.select_data_entry)
self.marker = GPSMarker(self.canvas)
self.marker.hide()
self.currentfeatureband = CurrentSelection(self.canvas)
self.currentfeatureband.setIconSize(30)
self.currentfeatureband.setWidth(10)
self.currentfeatureband.setColor(QColor(186, 93, 212, 50))
self.currentfeatureband.setOutlineColour(QColor(186, 93, 212))
self.gpsband = QgsRubberBand(self.canvas)
self.gpsband.setColor(QColor(165, 111, 212, 75))
self.gpsband.setWidth(5)
RoamEvents.editgeometry.connect(self.queue_feature_for_edit)
RoamEvents.selectioncleared.connect(self.clear_selection)
RoamEvents.selectionchanged.connect(self.highlight_selection)
RoamEvents.openfeatureform.connect(self.feature_form_loaded)
RoamEvents.sync_complete.connect(self.refresh_map)
self.connectButtons()
def generate_report(self):
# Generate pdf report from impact/hazard
if not self.impact_exists:
# Cannot generate report when no impact layer present
return
project_path = os.path.join(self.report_path,
'project-%s.qgs' % self.locale)
project_instance = QgsProject.instance()
project_instance.setFileName(project_path)
project_instance.read()
# Set up the map renderer that will be assigned to the composition
map_renderer = CANVAS.mapRenderer()
# Set the labelling engine for the canvas
labelling_engine = QgsPalLabeling()
map_renderer.setLabelingEngine(labelling_engine)
# Enable on the fly CRS transformations
map_renderer.setProjectionsEnabled(True)
default_crs = map_renderer.destinationCrs()
crs = QgsCoordinateReferenceSystem('EPSG:4326')
map_renderer.setDestinationCrs(crs)
# get layer registry
layer_registry = QgsMapLayerRegistry.instance()
layer_registry.removeAllMapLayers()
# add impact layer
population_affected_layer = read_qgis_layer(
self.population_aggregate_path, self.tr('People Affected'))
layer_registry.addMapLayer(population_affected_layer, True)
# add boundary mask
boundary_mask = read_qgis_layer(
self.flood_fixtures_dir('boundary-mask.shp'))
layer_registry.addMapLayer(boundary_mask, False)
# add hazard layer
hazard_layer = read_qgis_layer(self.hazard_path,
self.tr('Flood Depth (cm)'))
layer_registry.addMapLayer(hazard_layer, True)
# add boundary layer
boundary_layer = read_qgis_layer(
self.flood_fixtures_dir('boundary-5.shp'))
layer_registry.addMapLayer(boundary_layer, False)
CANVAS.setExtent(boundary_layer.extent())
CANVAS.refresh()
# add basemap layer
# this code uses OpenlayersPlugin
base_map = QgsRasterLayer(self.flood_fixtures_dir('jakarta.jpg'))
layer_registry.addMapLayer(base_map, False)
CANVAS.refresh()
template_path = self.flood_fixtures_dir('realtime-flood.qpt')
with open(template_path) as f:
template_content = f.read()
document = QDomDocument()
document.setContent(template_content)
# set destination CRS to Jakarta CRS
# EPSG:32748
# This allows us to use the scalebar in meter unit scale
crs = QgsCoordinateReferenceSystem('EPSG:32748')
map_renderer.setDestinationCrs(crs)
# Now set up the composition
composition = QgsComposition(map_renderer)
subtitution_map = self.event_dict()
LOGGER.debug(subtitution_map)
# load composition object from template
result = composition.loadFromTemplate(document, subtitution_map)
if not result:
LOGGER.exception('Error loading template %s with keywords\n %s',
template_path, subtitution_map)
raise MapComposerError
# get main map canvas on the composition and set extent
map_canvas = composition.getComposerItemById('map-canvas')
if map_canvas:
map_canvas.setNewExtent(map_canvas.currentMapExtent())
map_canvas.renderModeUpdateCachedImage()
else:
LOGGER.exception('Map canvas could not be found in template %s',
template_path)
raise MapComposerError
# get map legend on the composition
map_legend = composition.getComposerItemById('map-legend')
if map_legend:
# show only legend for Flood Depth
# ''.star
# showed_legend = [layer_id for layer_id in map_renderer.layerSet()
# if layer_id.startswith('Flood_Depth')]
# LOGGER.info(showed_legend)
# LOGGER.info(map_renderer.layerSet())
# LOGGER.info(hazard_layer.id())
# map_legend.model().setLayerSet(showed_legend)
# map_legend.modelV2().clear()
# print dir(map_legend.modelV2())
# map_legend.setLegendFilterByMapEnabled(True)
map_legend.model().setLayerSet(
[hazard_layer.id(),
population_affected_layer.id()])
else:
LOGGER.exception('Map legend could not be found in template %s',
template_path)
raise MapComposerError
content_analysis = composition.getComposerItemById(
'content-analysis-result')
if not content_analysis:
message = 'Content analysis composer item could not be found'
LOGGER.exception(message)
raise MapComposerError(message)
content_analysis_html = content_analysis.multiFrame()
if content_analysis_html:
# set url to generated html
analysis_html_path = self.generate_analysis_result_html()
# We're using manual HTML to avoid memory leak and segfault
# happened when using Url Mode
content_analysis_html.setContentMode(QgsComposerHtml.ManualHtml)
with open(analysis_html_path) as f:
content_analysis_html.setHtml(f.read())
content_analysis_html.loadHtml()
else:
message = 'Content analysis HTML not found in template'
LOGGER.exception(message)
raise MapComposerError(message)
# save a pdf
composition.exportAsPDF(self.map_report_path)
project_instance.write(QFileInfo(project_path))
layer_registry.removeAllMapLayers()
map_renderer.setDestinationCrs(default_crs)
map_renderer.setProjectionsEnabled(False)
def test_partials_labels_activate(self):
pal = QgsPalLabeling()
# Enable partials labels
pal.setShowingPartialsLabels(True)
self.assertTrue(pal.isShowingPartialsLabels())
def __init__(self, parent=None):
super(MapWidget, self).__init__(parent)
self.setupUi(self)
self.firstshow = True
self.layerbuttons = []
self.editfeaturestack = []
self.lastgpsposition = None
self.project = None
self.gps = None
self.gpslogging = None
self.selectionbands = defaultdict(partial(QgsRubberBand, self.canvas))
self.canvas.setCanvasColor(Qt.white)
self.canvas.enableAntiAliasing(True)
self.canvas.setWheelAction(QgsMapCanvas.WheelZoomToMouseCursor)
if hasattr(self.canvas, 'setParallelRenderingEnabled'):
self.canvas.setParallelRenderingEnabled(True)
pal = QgsPalLabeling()
self.canvas.mapRenderer().setLabelingEngine(pal)
self.canvas.setFrameStyle(QFrame.NoFrame)
self.editgroup = QActionGroup(self)
self.editgroup.setExclusive(True)
self.editgroup.addAction(self.actionPan)
self.editgroup.addAction(self.actionZoom_In)
self.editgroup.addAction(self.actionZoom_Out)
self.editgroup.addAction(self.actionInfo)
self.actionGPS = GPSAction(":/icons/gps", self.canvas, self)
self.projecttoolbar.addAction(self.actionGPS)
gpsspacewidget = QWidget()
gpsspacewidget.setMinimumWidth(30)
gpsspacewidget.setSizePolicy(QSizePolicy.Expanding,
QSizePolicy.Expanding)
self.topspaceraction = self.projecttoolbar.insertWidget(
self.actionGPS, gpsspacewidget)
self.dataentryselection = QAction(self.projecttoolbar)
self.dataentryaction = self.projecttoolbar.insertAction(
self.topspaceraction, self.dataentryselection)
self.dataentryselection.triggered.connect(self.select_data_entry)
self.marker = GPSMarker(self.canvas)
self.marker.hide()
self.currentfeatureband = QgsRubberBand(self.canvas)
self.currentfeatureband.setIconSize(20)
self.currentfeatureband.setWidth(10)
self.currentfeatureband.setColor(QColor(186, 93, 212, 76))
self.gpsband = QgsRubberBand(self.canvas)
self.gpsband.setColor(QColor(0, 0, 212, 76))
self.gpsband.setWidth(5)
RoamEvents.editgeometry.connect(self.queue_feature_for_edit)
RoamEvents.selectioncleared.connect(self.clear_selection)
RoamEvents.selectionchanged.connect(self.highlight_selection)
RoamEvents.featureformloaded.connect(self.feature_form_loaded)
self.connectButtons()
def test_layer_pal_activated(self):
# Verify, via engine, that PAL labeling can be activated for layer
lyr = self.defaultLayerSettings()
lyr.writeToLayer(self.layer)
msg = '\nLayer labeling not activated, as reported by labelingEngine'
self.assertTrue(QgsPalLabeling.staticWillUseLayer(self.layer), msg)
def test_layer_pal_activated(self):
# Verify, via engine, that PAL labeling can be activated for layer
lyr = self.defaultLayerSettings()
self.layer.setLabeling(QgsVectorLayerSimpleLabeling(lyr))
msg = '\nLayer labeling not activated, as reported by labelingEngine'
self.assertTrue(QgsPalLabeling.staticWillUseLayer(self.layer), msg)
