def _saveLazyLoadingOnSettings(self, event):
"""Turn on lazy loading in settings"""
UserSettings.Set(
group="datacatalog", key="lazyLoading", subkey="enabled", value=True
)
UserSettings.Set(
group="datacatalog", key="lazyLoading", subkey="asked", value=True
)
self._saveLazyLoadingSettings()
event.Skip()
def _saveDontAskLazyLoadingSettings(self, event):
"""Save in settings that decision on lazy loading was done to not ask again"""
UserSettings.Set(
group="datacatalog", key="lazyLoading", subkey="asked", value=True
)
self._saveLazyLoadingSettings()
event.Skip()
def _postInit(self):
"""Post-initialization method
It sets internal user settings,
set choice's selection (from user settings) and does reposition.
It needs choice filled by items.
it is called automatically.
"""
UserSettings.Set(
group="display",
key="statusbarMode",
subkey="choices",
value=self.choice.GetItems(),
settings_type="internal",
)
if not self._modeIndexSet:
self.choice.SetSelection(
UserSettings.Get(
group="display", key="statusbarMode", subkey="selection"
)
)
self.Reposition()
self._postInitialized = True
def OnChangeLayer(self, event):
"""!Layer changed
"""
layer = event.GetInt()
if layer > 0:
UserSettings.Set(group = 'vdigit', key = 'layer', subkey = 'value', value = layer)
self.digit.SetCategory()
self.category.SetValue(UserSettings.Get(group = 'vdigit', key = 'category', subkey = 'value'))
event.Skip()
def UpdateSettings(self):
chanaged_setts = []
for settKey, sett in self.colorsSetts.iteritems():
col = tuple(self.settings[settKey].GetColour())
col_s = UserSettings.Get(group='scatt',
key=sett[0],
subkey=settKey)
if col_s != col:
UserSettings.Set(group='scatt',
key=sett[0],
subkey=settKey,
value=col)
chanaged_setts.append([settKey, sett[0]])
for settKey, sett in self.sizeSetts.iteritems():
val = self.settings[settKey].GetValue()
val_s = UserSettings.Get(group='scatt',
key=sett[0],
subkey=settKey)
if val_s != val:
UserSettings.Set(group='scatt',
key=sett[0],
subkey=settKey,
value=val)
chanaged_setts.append([settKey, sett[0]])
val = self.settings['show_ellips'].IsChecked()
val_s = UserSettings.Get(group='scatt',
key='ellipses',
subkey='show_ellips')
if val != val_s:
UserSettings.Set(group='scatt',
key='ellipses',
subkey='show_ellips',
value=val)
chanaged_setts.append(['ellipses', 'show_ellips'])
if chanaged_setts:
self.scatt_mgr.SettingsUpdated(chanaged_setts)
def UpdateSettings(self):
chanaged_setts = []
for settKey, sett in six.iteritems(self.colorsSetts):
col = tuple(self.settings[settKey].GetColour())
col_s = UserSettings.Get(group="scatt",
key=sett[0],
subkey=settKey)
if col_s != col:
UserSettings.Set(group="scatt",
key=sett[0],
subkey=settKey,
value=col)
chanaged_setts.append([settKey, sett[0]])
for settKey, sett in six.iteritems(self.sizeSetts):
val = self.settings[settKey].GetValue()
val_s = UserSettings.Get(group="scatt",
key=sett[0],
subkey=settKey)
if val_s != val:
UserSettings.Set(group="scatt",
key=sett[0],
subkey=settKey,
value=val)
chanaged_setts.append([settKey, sett[0]])
val = self.settings["show_ellips"].IsChecked()
val_s = UserSettings.Get(group="scatt",
key="ellipses",
subkey="show_ellips")
if val != val_s:
UserSettings.Set(group="scatt",
key="ellipses",
subkey="show_ellips",
value=val)
chanaged_setts.append(["ellipses", "show_ellips"])
if chanaged_setts:
self.scatt_mgr.SettingsUpdated(chanaged_setts)
def OnChangeLayer(self, event):
"""Layer changed"""
layer = event.GetInt()
if layer > 0:
UserSettings.Set(group="vdigit",
key="layer",
subkey="value",
value=layer)
self.digit.SetCategory()
self.category.SetValue(
UserSettings.Get(group="vdigit",
key="category",
subkey="value"))
event.Skip()
def OnChangeCategoryMode(self, event):
"""!Change category mode
"""
mode = event.GetSelection()
UserSettings.Set(group = 'vdigit', key = "categoryMode", subkey = 'selection', value = mode)
if mode == 1: # manual entry
self.category.Enable(True)
elif self.category.IsEnabled(): # disable
self.category.Enable(False)
if mode == 2 and self.addRecord.IsChecked(): # no category
self.addRecord.SetValue(False)
self.digit.SetCategory()
self.category.SetValue(UserSettings.Get(group = 'vdigit', key = 'category', subkey = 'value'))
def OnCopy(self, event):
"""Copy selected features from (background) vector map"""
if not self.digit:
GError(_("No vector map open for editing."), self.parent)
return
# select background map
dlg = VectorDialog(
self.parent,
title=_("Select background vector map"),
layerTree=self._giface.GetLayerTree(),
)
if dlg.ShowModal() != wx.ID_OK:
dlg.Destroy()
return
mapName = dlg.GetName(full=True)
dlg.Destroy()
# close open background map if any
bgMap = UserSettings.Get(
group="vdigit", key="bgmap", subkey="value", settings_type="internal"
)
if bgMap:
self.digit.CloseBackgroundMap()
self.editingBgMap.emit(mapName=bgMap, unset=True)
# open background map for reading
UserSettings.Set(
group="vdigit",
key="bgmap",
subkey="value",
value=str(mapName),
settings_type="internal",
)
self.digit.OpenBackgroundMap(mapName)
self.editingBgMap.emit(mapName=mapName)
if self.action["desc"] == "copyLine": # select previous action
self.ToggleTool(self.addPoint, True)
self.ToggleTool(self.additionalTools, False)
self.OnAddPoint(event)
return
Debug.msg(2, "Digittoolbar.OnCopy():")
self.action = {"desc": "copyLine", "id": self.additionalTools}
self.MapWindow.mouse["box"] = "box"
def _postInit(self):
"""!Post-initialization method
It sets internal user settings,
set choice's selection (from user settings) and does reposition.
It needs choice filled by items.
it is called automatically.
"""
UserSettings.Set(group='display',
key='statusbarMode',
subkey='choices',
value=self.choice.GetItems(),
internal=True)
self.choice.SetSelection(
UserSettings.Get(group='display',
key='statusbarMode',
subkey='selection'))
self.Reposition()
self._postInitialized = True
def _postInit(self):
"""Post-initialization method
It sets internal user settings,
set selection (from map display settings) and does reposition.
It is called automatically.
"""
UserSettings.Set(
group="display",
key="statusbarMode",
subkey="choices",
value=self.GetItemLabels(),
settings_type="internal",
)
if not self._modeIndexSet:
self.SetMode(
UserSettings.Get(group="display",
key="statusbarMode",
subkey="selection"))
self.mapFrame.mapWindowProperties.sbItem = UserSettings.Get(
group="display", key="statusbarMode", subkey="selection")
self.Reposition()
self._postInitialized = True
def UpdateSettings(self):
"""Update digitizer settings
.. todo::
Needs refactoring
"""
self._giface.workspaceChanged.emit()
# symbology
for key, (enabled, color) in six.iteritems(self.symbology):
if enabled:
UserSettings.Set(
group="vdigit",
key="symbol",
subkey=[key, "enabled"],
value=enabled.IsChecked(),
)
UserSettings.Set(
group="vdigit",
key="symbol",
subkey=[key, "color"],
value=tuple(color.GetColour()),
)
else:
UserSettings.Set(
group="vdigit",
key="symbol",
subkey=[key, "color"],
value=tuple(color.GetColour()),
)
# display
UserSettings.Set(
group="vdigit",
key="lineWidth",
subkey="value",
value=int(self.lineWidthValue.GetValue()),
)
# snapping
UserSettings.Set(
group="vdigit",
key="snapping",
subkey="value",
value=self.snappingValue.GetValue(),
)
UserSettings.Set(
group="vdigit",
key="snapping",
subkey="unit",
value=self.snappingUnit.GetSelection(),
)
UserSettings.Set(
group="vdigit",
key="snapToVertex",
subkey="enabled",
value=self.snapVertex.IsChecked(),
)
# digitize new feature
UserSettings.Set(
group="vdigit",
key="addRecord",
subkey="enabled",
value=self.addRecord.IsChecked(),
)
UserSettings.Set(
group="vdigit",
key="layer",
subkey="value",
value=int(self.layer.GetValue()),
)
UserSettings.Set(
group="vdigit",
key="category",
subkey="value",
value=int(self.category.GetValue()),
)
UserSettings.Set(
group="vdigit",
key="categoryMode",
subkey="selection",
value=self.categoryMode.GetSelection(),
)
# delete existing feature
UserSettings.Set(
group="vdigit",
key="delRecord",
subkey="enabled",
value=self.deleteRecord.IsChecked(),
)
# geometry attributes (workspace)
mapLayer = self.parent.toolbars["vdigit"].GetLayer()
tree = self._giface.GetLayerTree()
if tree:
item = tree.FindItemByData("maplayer", mapLayer)
else:
item = None
for key, val in six.iteritems(self.geomAttrb):
checked = self.FindWindowById(val["check"]).IsChecked()
column = self.FindWindowById(val["column"]).GetValue()
unitsIdx = self.FindWindowById(val["units"]).GetSelection()
if item and not tree.GetLayerInfo(item, key="vdigit"):
tree.SetLayerInfo(item,
key="vdigit",
value={"geomAttr": dict()})
if checked: # enable
if key == "area":
type = key
else:
type = "length"
unitsKey = Units.GetUnitsKey(type, unitsIdx)
tree.GetLayerInfo(item, key="vdigit")["geomAttr"][key] = {
"column": column,
"units": unitsKey,
}
else:
if (item and tree.GetLayerInfo(item, key="vdigit") and key
in tree.GetLayerInfo(item, key="vdigit")["geomAttr"]):
del tree.GetLayerInfo(item, key="vdigit")["geomAttr"][key]
# query tool
if self.queryLength.GetValue():
UserSettings.Set(group="vdigit",
key="query",
subkey="selection",
value=0)
else:
UserSettings.Set(group="vdigit",
key="query",
subkey="type",
value=1)
UserSettings.Set(group="vdigit",
key="query",
subkey="box",
value=self.queryBox.IsChecked())
UserSettings.Set(
group="vdigit",
key="queryLength",
subkey="than-selection",
value=self.queryLengthSL.GetSelection(),
)
UserSettings.Set(
group="vdigit",
key="queryLength",
subkey="thresh",
value=self.queryLengthValue.GetValue(),
)
UserSettings.Set(
group="vdigit",
key="queryDangle",
subkey="than-selection",
value=self.queryDangleSL.GetSelection(),
)
UserSettings.Set(
group="vdigit",
key="queryDangle",
subkey="thresh",
value=int(self.queryDangleValue.GetValue()),
)
# select features
for feature in ("point", "line", "centroid", "boundary"):
UserSettings.Set(
group="vdigit",
key="selectType",
subkey=[feature, "enabled"],
value=self.FindWindowById(
self.selectFeature[feature]).IsChecked(),
)
UserSettings.Set(
group="vdigit",
key="selectThresh",
subkey="value",
value=int(self.selectThreshValue.GetValue()),
)
UserSettings.Set(
group="vdigit",
key="checkForDupl",
subkey="enabled",
value=self.checkForDupl.IsChecked(),
)
UserSettings.Set(
group="vdigit",
key="selectInside",
subkey="enabled",
value=self.selectIn.IsChecked(),
)
# on-exit
UserSettings.Set(
group="vdigit",
key="saveOnExit",
subkey="enabled",
value=self.save.IsChecked(),
)
# break lines
UserSettings.Set(
group="vdigit",
key="breakLines",
subkey="enabled",
value=self.intersect.IsChecked(),
)
# close boundary
UserSettings.Set(
group="vdigit",
key="closeBoundary",
subkey="enabled",
value=self.closeBoundary.IsChecked(),
)
self.digit.UpdateSettings()
# redraw map if auto-rendering is enabled
if self.parent.IsAutoRendered():
self.parent.OnRender(None)
def StartEditing(self, mapLayer):
"""Start editing selected vector map layer.
:param mapLayer: MapLayer to be edited
"""
# check if topology is available (skip for hidden - temporary
# maps, see iclass for details)
if (
not mapLayer.IsHidden()
and grass.vector_info(mapLayer.GetName())["level"] != 2
):
dlg = wx.MessageDialog(
parent=self.MapWindow,
message=_(
"Topology for vector map <%s> is not available. "
"Topology is required by digitizer.\nDo you want to "
"rebuild topology (takes some time) and open the vector map "
"for editing?"
)
% mapLayer.GetName(),
caption=_("Digitizer error"),
style=wx.YES_NO | wx.YES_DEFAULT | wx.ICON_QUESTION | wx.CENTRE,
)
if dlg.ShowModal() == wx.ID_YES:
RunCommand("v.build", map=mapLayer.GetName())
else:
return
# deactive layer
self.Map.ChangeLayerActive(mapLayer, False)
# clean map canvas
self.MapWindow.EraseMap()
# unset background map if needed
if mapLayer:
if (
UserSettings.Get(
group="vdigit",
key="bgmap",
subkey="value",
settings_type="internal",
)
== mapLayer.GetName()
):
UserSettings.Set(
group="vdigit",
key="bgmap",
subkey="value",
value="",
settings_type="internal",
)
self.parent.SetStatusText(
_("Please wait, " "opening vector map <%s> for editing...")
% mapLayer.GetName(),
0,
)
self.MapWindow.pdcVector = PseudoDC()
self.digit = self.MapWindow.digit = self.digitClass(mapwindow=self.MapWindow)
self.mapLayer = mapLayer
# open vector map (assume that 'hidden' map layer is temporary vector
# map)
if self.digit.OpenMap(mapLayer.GetName(), tmp=mapLayer.IsHidden()) is None:
self.mapLayer = None
self.StopEditing()
return False
# check feature type (only for OGR layers)
self.fType = self.digit.GetFeatureType()
self.EnableAll()
self.EnableUndo(False)
self.EnableRedo(False)
if self.fType == "point":
for tool in (
self.addLine,
self.addArea,
self.moveVertex,
self.addVertex,
self.removeVertex,
self.editLine,
):
self.EnableTool(tool, False)
elif self.fType == "linestring":
for tool in (self.addPoint, self.addArea):
self.EnableTool(tool, False)
elif self.fType == "polygon":
for tool in (self.addPoint, self.addLine):
self.EnableTool(tool, False)
elif self.fType:
GError(
parent=self,
message=_(
"Unsupported feature type '%(type)s'. Unable to edit "
"OGR layer <%(layer)s>."
)
% {"type": self.fType, "layer": mapLayer.GetName()},
)
self.digit.CloseMap()
self.mapLayer = None
self.StopEditing()
return False
# update toolbar
if self.combo:
self.combo.SetValue(mapLayer.GetName())
if "map" in self.parent.toolbars:
self.parent.toolbars["map"].combo.SetValue(_("Vector digitizer"))
# here was dead code to enable vdigit button in toolbar
# with if to ignore iclass
# some signal (DigitizerStarted) can be emitted here
Debug.msg(4, "VDigitToolbar.StartEditing(): layer=%s" % mapLayer.GetName())
# change cursor
if self.MapWindow.mouse["use"] == "pointer":
self.MapWindow.SetNamedCursor("cross")
if not self.MapWindow.resize:
self.MapWindow.UpdateMap(render=True)
# respect opacity
opacity = mapLayer.GetOpacity()
if opacity < 1.0:
alpha = int(opacity * 255)
self.digit.GetDisplay().UpdateSettings(alpha=alpha)
# emit signal
layerTree = self._giface.GetLayerTree()
if layerTree:
item = layerTree.FindItemByData("maplayer", self.mapLayer)
else:
item = None
self.editingStarted.emit(
vectMap=mapLayer.GetName(), digit=self.digit, layerItem=item
)
return True
def UpdateSettings(self):
"""Update digitizer settings
.. todo::
Needs refactoring
"""
# TODO: it seems that it needs to be replaced by signal
# but if it makes sense generally for wxGUI it can be added to giface
if self.parent.GetLayerManager():
self.parent.GetLayerManager().WorkspaceChanged(
) # geometry attributes
# symbology
for key, (enabled, color) in self.symbology.iteritems():
if enabled:
UserSettings.Set(group='vdigit',
key='symbol',
subkey=[key, 'enabled'],
value=enabled.IsChecked())
UserSettings.Set(group='vdigit',
key='symbol',
subkey=[key, 'color'],
value=tuple(color.GetColour()))
else:
UserSettings.Set(group='vdigit',
key='symbol',
subkey=[key, 'color'],
value=tuple(color.GetColour()))
# display
UserSettings.Set(group='vdigit',
key="lineWidth",
subkey='value',
value=int(self.lineWidthValue.GetValue()))
# snapping
UserSettings.Set(group='vdigit',
key="snapping",
subkey='value',
value=int(self.snappingValue.GetValue()))
UserSettings.Set(group='vdigit',
key="snapping",
subkey='units',
value=self.snappingUnit.GetStringSelection())
UserSettings.Set(group='vdigit',
key="snapToVertex",
subkey='enabled',
value=self.snapVertex.IsChecked())
# digitize new feature
UserSettings.Set(group='vdigit',
key="addRecord",
subkey='enabled',
value=self.addRecord.IsChecked())
UserSettings.Set(group='vdigit',
key="layer",
subkey='value',
value=int(self.layer.GetValue()))
UserSettings.Set(group='vdigit',
key="category",
subkey='value',
value=int(self.category.GetValue()))
UserSettings.Set(group='vdigit',
key="categoryMode",
subkey='selection',
value=self.categoryMode.GetSelection())
# delete existing feature
UserSettings.Set(group='vdigit',
key="delRecord",
subkey='enabled',
value=self.deleteRecord.IsChecked())
# geometry attributes (workspace)
mapLayer = self.parent.toolbars['vdigit'].GetLayer()
tree = self._giface.GetLayerTree()
if tree:
item = tree.FindItemByData('maplayer', mapLayer)
else:
item = None
for key, val in self.geomAttrb.iteritems():
checked = self.FindWindowById(val['check']).IsChecked()
column = self.FindWindowById(val['column']).GetValue()
unitsIdx = self.FindWindowById(val['units']).GetSelection()
if item and not tree.GetLayerInfo(item, key='vdigit'):
tree.SetLayerInfo(item,
key='vdigit',
value={'geomAttr': dict()})
if checked: # enable
if key == 'area':
type = key
else:
type = 'length'
unitsKey = Units.GetUnitsKey(type, unitsIdx)
tree.GetLayerInfo(item, key='vdigit')['geomAttr'][key] = {
'column': column,
'units': unitsKey
}
else:
if item and tree.GetLayerInfo(item, key = 'vdigit') and \
key in tree.GetLayerInfo(item, key = 'vdigit')['geomAttr']:
del tree.GetLayerInfo(item, key='vdigit')['geomAttr'][key]
# query tool
if self.queryLength.GetValue():
UserSettings.Set(group='vdigit',
key="query",
subkey='selection',
value=0)
else:
UserSettings.Set(group='vdigit',
key="query",
subkey='type',
value=1)
UserSettings.Set(group='vdigit',
key="query",
subkey='box',
value=self.queryBox.IsChecked())
UserSettings.Set(group='vdigit',
key="queryLength",
subkey='than-selection',
value=self.queryLengthSL.GetSelection())
UserSettings.Set(group='vdigit',
key="queryLength",
subkey='thresh',
value=int(self.queryLengthValue.GetValue()))
UserSettings.Set(group='vdigit',
key="queryDangle",
subkey='than-selection',
value=self.queryDangleSL.GetSelection())
UserSettings.Set(group='vdigit',
key="queryDangle",
subkey='thresh',
value=int(self.queryDangleValue.GetValue()))
# select features
for feature in ('point', 'line', 'centroid', 'boundary'):
UserSettings.Set(group='vdigit',
key='selectType',
subkey=[feature, 'enabled'],
value=self.FindWindowById(
self.selectFeature[feature]).IsChecked())
UserSettings.Set(group='vdigit',
key="selectThresh",
subkey='value',
value=int(self.selectThreshValue.GetValue()))
UserSettings.Set(group='vdigit',
key="checkForDupl",
subkey='enabled',
value=self.checkForDupl.IsChecked())
UserSettings.Set(group='vdigit',
key="selectInside",
subkey='enabled',
value=self.selectIn.IsChecked())
# on-exit
UserSettings.Set(group='vdigit',
key="saveOnExit",
subkey='enabled',
value=self.save.IsChecked())
# break lines
UserSettings.Set(group='vdigit',
key="breakLines",
subkey='enabled',
value=self.intersect.IsChecked())
# close boundary
UserSettings.Set(group='vdigit',
key="closeBoundary",
subkey='enabled',
value=self.closeBoundary.IsChecked())
self.digit.UpdateSettings()
# redraw map if auto-rendering is enabled
if self.parent.IsAutoRendered():
self.parent.OnRender(None)
def StartEditing(self, mapLayer):
"""!Start editing selected vector map layer.
@param mapLayer MapLayer to be edited
"""
# deactive layer
self.mapcontent.ChangeLayerActive(mapLayer, False)
# clean map canvas
self.parent.MapWindow.EraseMap()
# unset background map if needed
if mapLayer:
if UserSettings.Get(group='vdigit',
key='bgmap',
subkey='value',
internal=True) == mapLayer.GetName():
UserSettings.Set(group='vdigit',
key='bgmap',
subkey='value',
value='',
internal=True)
self.parent.SetStatusText(
_("Please wait, "
"opening vector map <%s> for editing...") %
mapLayer.GetName(), 0)
self.parent.MapWindow.pdcVector = wx.PseudoDC()
self.digit = self.parent.MapWindow.digit = VDigit(
mapwindow=self.parent.MapWindow)
self.mapLayer = mapLayer
# open vector map
if self.digit.OpenMap(mapLayer.GetName()) is None:
self.mapLayer = None
self.StopEditing()
return False
# update toolbar
self.combo.SetValue(mapLayer.GetName())
self.parent.toolbars['map'].combo.SetValue(_('Digitize'))
lmgr = self.parent.GetLayerManager()
if lmgr:
lmgr.toolbars['tools'].Enable('vdigit', enable=False)
Debug.msg(
4, "VDigitToolbar.StartEditing(): layer=%s" % mapLayer.GetName())
# change cursor
if self.parent.MapWindow.mouse['use'] == 'pointer':
self.parent.MapWindow.SetCursor(self.parent.cursors["cross"])
if not self.parent.MapWindow.resize:
self.parent.MapWindow.UpdateMap(render=True)
# respect opacity
opacity = mapLayer.GetOpacity(float=True)
if opacity < 1.0:
alpha = int(opacity * 255)
self.digit.GetDisplay().UpdateSettings(alpha=alpha)
return True
def Load(self, filename):
"""Load layer tree definition stored in GRASS Workspace XML file (gxw)
.. todo::
Validate against DTD
:return: True on success
:return: False on error
"""
# parse workspace file
try:
gxwXml = ProcessWorkspaceFile(etree.parse(filename))
except Exception as e:
GError(
parent=self.lmgr,
message=_("Reading workspace file <%s> failed.\n"
"Invalid file, unable to parse XML document.") %
filename,
)
return False
if gxwXml.database and gxwXml.location and gxwXml.mapset:
if not self._tryToSwitchMapsetFromWorkspaceFile(gxwXml):
return False
# the really busy part starts here (mapset change is fast)
busy = wx.BusyInfo(_("Please wait, loading workspace..."),
parent=self.lmgr)
wx.GetApp().Yield()
#
# load layer manager window properties
#
if (UserSettings.Get(group="general",
key="workspace",
subkey=["posManager", "enabled"]) is False):
if gxwXml.layerManager["pos"]:
self.lmgr.SetPosition(gxwXml.layerManager["pos"])
if gxwXml.layerManager["size"]:
self.lmgr.SetSize(gxwXml.layerManager["size"])
if gxwXml.layerManager["cwd"]:
self.lmgr.cwdPath = gxwXml.layerManager["cwd"]
if os.path.isdir(self.lmgr.cwdPath):
os.chdir(self.lmgr.cwdPath)
#
# start map displays first (list of layers can be empty)
#
displayId = 0
mapdisplay = list()
for display in gxwXml.displays:
mapdisp = self.lmgr.NewDisplay(name=display["name"], show=False)
mapdisplay.append(mapdisp)
maptree = self.lmgr.notebookLayers.GetPage(displayId).maptree
# set windows properties
mapdisp.SetProperties(
render=display["render"],
mode=display["mode"],
showCompExtent=display["showCompExtent"],
alignExtent=display["alignExtent"],
constrainRes=display["constrainRes"],
projection=display["projection"]["enabled"],
)
if display["projection"]["enabled"]:
if display["projection"]["epsg"]:
UserSettings.Set(
group="display",
key="projection",
subkey="epsg",
value=display["projection"]["epsg"],
)
if display["projection"]["proj"]:
UserSettings.Set(
group="display",
key="projection",
subkey="proj4",
value=display["projection"]["proj"],
)
# set position and size of map display
if not UserSettings.Get(group="general",
key="workspace",
subkey=["posDisplay", "enabled"]):
if display["pos"]:
mapdisp.SetPosition(display["pos"])
if display["size"]:
mapdisp.SetSize(display["size"])
# set extent if defined
if display["extent"]:
w, s, e, n, b, t = display["extent"]
region = maptree.Map.region = maptree.Map.GetRegion(w=w,
s=s,
e=e,
n=n)
mapdisp.GetWindow().ResetZoomHistory()
mapdisp.GetWindow().ZoomHistory(region["n"], region["s"],
region["e"], region["w"])
if "showStatusbar" in display and not display["showStatusbar"]:
mapdisp.ShowStatusbar(False)
if "showToolbars" in display and not display["showToolbars"]:
for toolbar in mapdisp.GetToolbarNames():
mapdisp.RemoveToolbar(toolbar)
displayId += 1
mapdisp.Show() # show mapdisplay
# set render property to False to speed up loading layers
mapdisp.mapWindowProperties.autoRender = False
maptree = None
selectList = [] # list of selected layers
#
# load list of map layers
#
for layer in gxwXml.layers:
display = layer["display"]
maptree = self.lmgr.notebookLayers.GetPage(display).maptree
newItem = maptree.AddLayer(
ltype=layer["type"],
lname=layer["name"],
lchecked=layer["checked"],
lopacity=layer["opacity"],
lcmd=layer["cmd"],
lgroup=layer["group"],
lnviz=layer["nviz"],
lvdigit=layer["vdigit"],
loadWorkspace=True,
)
if "selected" in layer:
selectList.append((maptree, newItem, layer["selected"]))
for maptree, layer, selected in selectList:
if selected:
if not layer.IsSelected():
maptree.SelectItem(layer, select=True)
else:
maptree.SelectItem(layer, select=False)
del busy
# set render property again when all layers are loaded
for i, display in enumerate(gxwXml.displays):
mapdisplay[i].mapWindowProperties.autoRender = display["render"]
for overlay in gxwXml.overlays:
# overlay["cmd"][0] name of command e.g. d.barscale, d.legend
# overlay["cmd"][1:] parameters and flags
if overlay["display"] == i:
if overlay["cmd"][0] == "d.legend.vect":
mapdisplay[i].AddLegendVect(overlay["cmd"])
if overlay["cmd"][0] == "d.legend":
mapdisplay[i].AddLegendRast(overlay["cmd"])
if overlay["cmd"][0] == "d.barscale":
mapdisplay[i].AddBarscale(overlay["cmd"])
if overlay["cmd"][0] == "d.northarrow":
mapdisplay[i].AddArrow(overlay["cmd"])
if overlay["cmd"][0] == "d.text":
mapdisplay[i].AddDtext(overlay["cmd"])
# avoid double-rendering when loading workspace
# mdisp.MapWindow2D.UpdateMap()
# nviz
if gxwXml.displays[i]["viewMode"] == "3d":
mapdisplay[i].AddNviz()
self.lmgr.nvizUpdateState(
view=gxwXml.nviz_state["view"],
iview=gxwXml.nviz_state["iview"],
light=gxwXml.nviz_state["light"],
)
mapdisplay[i].MapWindow3D.constants = gxwXml.nviz_state[
"constants"]
for idx, constant in enumerate(
mapdisplay[i].MapWindow3D.constants):
mapdisplay[i].MapWindow3D.AddConstant(constant, i + 1)
for page in ("view", "light", "fringe", "constant", "cplane"):
self.lmgr.nvizUpdatePage(page)
self.lmgr.nvizUpdateSettings()
mapdisplay[i].toolbars["map"].combo.SetSelection(1)
self.workspaceFile = filename
return True
