wxGUI/giface: using giface in vnet and thus extending giface

git-svn-id: https://svn.osgeo.org/grass/grass/trunk@57434 15284696-431f-4ddb-bdfa-cd5b030d7da7

gui/wxpython/core/giface.py

@@ -36,6 +36,7 @@ class Layer(object):
     Current implementations only provides all attributes of existing layer
     as used in lmgr.
     """
+    pass
 
 
 class LayerList(object):
@@ -71,6 +72,25 @@ class LayerList(object):
         """
         raise NotImplementedError()
 
+    def GetLayersByName(self, name):
+        """!Returns list of layers with a given name.
+
+        @param name fully qualified map name
+
+        @todo if common usage is just to check the presence of layer,
+        intoroduce a new method ContainsLayerByName(name)
+        """
+        raise NotImplementedError()
+
+    def GetLayerByData(self, key, value):
+        """!Returns layer with specified.
+
+        @note Returns only one layer. This might change.
+
+        @warning Avoid using this method, it might be removed in the future.
+        """
+        raise NotImplementedError()
+
 
 class GrassInterface:
     """!GrassInterface provides the functionality which should be available

gui/wxpython/lmgr/giface.py

@@ -33,7 +33,7 @@ class Layer(object):
     def __dir__(self):
         return self._pydata[0].keys()
 
-    def __repr__(self):
+    def __str__(self):
         return self.maplayer.name
 
 
@@ -94,9 +94,35 @@ class LayerList(object):
         self._tree.AddLayer(ltype=ltype, lname=name, lchecked=checked,
                             lopacity=opacity, lcmd=cmd)
 
+    def GetLayersByName(self, name):
+        items = self._tree.FindItemByData(key='name', value=name)
+        if items is None:
+            return []
+        else:
+            layers = []
+            for item in items:
+                layer = Layer(self._tree.GetPyData(item))
+                layers.append(layer)
+            return layers
+
+    def GetLayerByData(self, key, value):
+        """!Returns layer with specified.
+
+        Returns only one layer.
+        Avoid using this method, it might be removed in the future.
+        """
+        if key == 'name':
+            print "giface.GetLayerByData(): Do not with use key='name',"
+            " use GetLayersByName instead."
+        item = self._tree.FindItemByData(key=key, value=value)
+        if item is None:
+            return None
+        else:
+            return Layer(self._tree.GetPyData(item))
+
 
 class LayerManagerGrassInterface(object):
-    """!@implements GrassInterface"""
+    """!@implements core::giface::GrassInterface"""
     def __init__(self, lmgr):
         """!Costructor is specific to the current implementation.
 
@@ -160,6 +186,8 @@ class LayerManagerGrassInterface(object):
 class LayerManagerGrassInterfaceForMapDisplay(object):
     """!Provides reference only to the given layer list (according to tree),
         not to the current.
+
+        @implements core::giface::GrassInterface
     """
     def __init__(self, giface, tree):
         """!

gui/wxpython/mapdisp/main.py

@@ -223,11 +223,13 @@ class DMonMap(Map):
         del os.environ["GRASS_RENDER_IMMEDIATE"]
 
         RunCommand('g.gisenv',
-                    set = 'MONITOR=%s' % currMon)
-        
+                   set='MONITOR=%s' % currMon)
+
         return layer
 
+
 class Layer(object):
+    """!@implements core::giface::Layer"""
     def __init__(self, maplayer):
         self._maplayer = maplayer
 
@@ -243,19 +245,15 @@ class Layer(object):
             #elif name == 'ctrl':
         elif name == 'label':
             return self._maplayer.GetName()
-            #elif name == 'maplayer' : None,
             #elif name == 'propwin':
 
 
 class LayerList(object):
     def __init__(self, map, giface):
+        """!@implements core::giface::LayerList"""
         self._map = map
         self._giface = giface
 
-#    def __iter__(self):
-#        for in :
-#            yield
-
     def GetSelectedLayers(self, checkedOnly=True):
         # hidden and selected vs checked and selected
         items = self._map.GetListOfLayers()
@@ -285,7 +283,7 @@ class LayerList(object):
         @param opacity layer opacity level
         @param cmd command (given as a list)
         """
-        self._map.AddLayer(ltype="vector", command=cmd,
+        self._map.AddLayer(ltype=ltype, command=cmd,
                            name=name, active=True,
                            opacity=opacity, render=True,
                            pos=-1)
@@ -294,6 +292,27 @@ class LayerList(object):
         # alternative is some observer list)
         self._giface.updateMap.emit(render=True, renderVector=True)
 
+    def GetLayersByName(self, name):
+        items = self._map.GetListOfLayers()
+        layers = []
+        for item in items:
+            if item.GetName() == name:
+                layer = Layer(item)
+                layers.append(layer)
+        return layers
+
+    def GetLayerByData(self, key, value):
+        # TODO: implementation was not tested
+        items = self._map.GetListOfLayers()
+        for item in items:
+            layer = Layer(item)
+            try:
+                if getattr(layer, key) == value:
+                    return layer
+            except AttributeError:
+                pass
+        return None
+
 
 class DMonGrassInterface(StandaloneGrassInterface):
     """!@implements GrassInterface"""

gui/wxpython/vnet/vnet_core.py

@@ -349,29 +349,16 @@ class VNETManager:
                     overwrite = True,
                     vect = [self.results["vect_map"].GetVectMapName(), mapName])
 
-        # TODO: this is a workaround: usage of parent
-        # use giface/LayerList instead (needs to be extended first, please do,
-        # don't forget on abstract giface in core/giface.py and dmon's giface)
-        tree = None
-        try:
-            # map display (MapFrame) should still have tree
-            tree = self.mapWin.parent.tree
-        except:
-            pass
-
-        if tree is None:
-            return
-
-        if tree.FindItemByData(key='name', value=mapName) is None:
+        if len(self.giface.GetLayerList().GetLayersByName(mapName)) == 0:
             # TODO: get rid of insert
             cmd, cmd_colors = self.vnet_data.GetLayerStyle()
             cmd.insert(0, 'd.vect')
             cmd.append('map=%s' % mapName)
 
-            tree.AddLayer(ltype = "vector",
-                          lname = mapName,
-                          lcmd = cmd,
-                          lchecked = True)
+            self.giface.GetLayerList().AddLayer(ltype="vector",
+                                                name=mapName,
+                                                cmd=cmd,
+                                                checked=True)
             if cmd_colors:
                 layerStyleVnetColors = utils.CmdToTuple(cmd_colors)