wxGUI/mapdisp: test module for mapdisplay and mapwindow

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

gui/wxpython/mapdisp/test_mapdisp.py

@@ -0,0 +1,363 @@
+#!/usr/bin/env python
+
+############################################################################
+#
+# MODULE:    Map window and mapdisplay test module
+# AUTHOR(S): Vaclav Petras
+# PURPOSE:   Test functionality using small GUI applications.
+# COPYRIGHT: (C) 2013 by Vaclav Petras, and the GRASS Development Team
+#
+#  This program is free software; you can redistribute it and/or modify
+#  it under the terms of the GNU General Public License as published by
+#  the Free Software Foundation; either version 2 of the License, or
+#  (at your option) any later version.
+#
+#  This program is distributed in the hope that it will be useful,
+#  but WITHOUT ANY WARRANTY; without even the implied warranty of
+#  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+#  GNU General Public License for more details.
+#
+############################################################################
+
+#%module
+#% description: Georectifies a map and allows to manage Ground Control Points.
+#% keywords: general
+#% keywords: GUI
+#% keywords: georectification
+#%end
+#%option
+#% key: test
+#% description: Test to run
+#% options: mapwindow,mapdisplay,apitest,distance,profile
+#% descriptions: mapwindow;Opens map window ;mapdisplay;Opens map display; apitest;Open an application to test API of map window; distance;Starts map window with distance measurement activated; profile;Starts map window with profile tool activated
+#% required: yes
+#%end
+#%option G_OPT_R_INPUT
+#% key: raster
+#% multiple: yes
+#% required: no
+#%end
+#%option G_OPT_V_INPUT
+#% key: vector
+#% multiple: yes
+#% required: no
+#%end
+
+"""
+Module to run test map window (BufferedWidnow) and map display (MapFrame).
+
+@author Vaclav Petras  <wenzeslaus gmail.com>
+"""
+
+import os
+import sys
+import wx
+
+import grass.script as grass
+
+# adding a path to wxGUI modules
+if __name__ == '__main__':
+    WXGUIBASE = os.path.join(os.getenv('GISBASE'), 'etc', 'gui', 'wxpython')
+    if WXGUIBASE not in sys.path:
+        sys.path.append(WXGUIBASE)
+
+import core.utils as utils
+from core.utils import _
+from core.settings import UserSettings
+from core.globalvar import CheckWxVersion
+from core.giface import StandaloneGrassInterface
+from gui_core.mapwindow import MapWindowProperties
+from mapdisp.mapwindow import BufferedWindow
+from mapdisp.frame import MapFrame
+from core.render import Map
+
+
+# TODO: same classes as in dmon
+class Layer(object):
+    def __init__(self, maplayer):
+        self._maplayer = maplayer
+
+    def __getattr__(self, name):
+        if name == 'cmd':
+            return utils.CmdTupleToList(self._maplayer.GetCmd())
+        elif hasattr(self._maplayer, name):
+            return getattr(self._maplayer, name)
+        elif name == 'maplayer':
+            return self._maplayer
+        elif name == 'type':
+            return self._maplayer.GetType()
+            #elif name == 'ctrl':
+        elif name == 'label':
+            return self._maplayer.GetName()
+            #elif name == 'maplayer' : None,
+            #elif name == 'propwin':
+
+
+class LayerList(object):
+    def __init__(self, map_):
+        self._map = map_
+
+    def GetSelectedLayers(self, checkedOnly=True):
+        # hidden and selected vs checked and selected
+        items = self._map.GetListOfLayers()
+        layers = []
+        for item in items:
+            layer = Layer(item)
+            layers.append(layer)
+        return layers
+
+
+class MapdispGrassInterface(StandaloneGrassInterface):
+    """!@implements GrassInterface"""
+    def __init__(self, map_):
+        StandaloneGrassInterface.__init__(self)
+        self._map = map_
+        self.mapWindow = None
+
+    def GetLayerList(self):
+        return LayerList(self._map)
+
+    def GetMapWindow(self):
+        return self.mapWindow
+
+
+# this is a copy of method from some frame class
+def copyOfInitMap(map_, width, height):
+    """!Initialize map display, set dimensions and map region
+    """
+    if not grass.find_program('g.region', '--help'):
+        sys.exit(_("GRASS module '%s' not found. Unable to start map "
+                   "display window.") % 'g.region')
+    map_.ChangeMapSize((width, height))
+    map_.region = map_.GetRegion()  # g.region -upgc
+    # self.Map.SetRegion() # adjust region to match display window
+
+
+class TextShower(object):
+    def __init__(self, parent, title):
+        self._cf = wx.Frame(parent=parent, title=title)
+        self._cp = wx.Panel(parent=self._cf, id=wx.ID_ANY)
+        self._cs = wx.BoxSizer(wx.VERTICAL)
+        self._cl = wx.StaticText(parent=self._cp, id=wx.ID_ANY, label="No text set yet")
+        self._cs.Add(item=self._cl, proportion=1, flag=wx.EXPAND | wx.ALL, border=5)
+        self._cp.SetSizer(self._cs)
+        self._cp.Layout()
+        self._cf.Show()
+
+    def SetLabel(self, text):
+        self._cl.SetLabel(text)
+
+
+class Tester(object):
+    def _listenToAllMapWindowSignals(self, window):
+        output = sys.stderr
+        # will make bad thigs after it is closed but who cares
+        coordinatesShower = TextShower(window, "Coordinates")
+
+        window.zoomChanged.connect(lambda: output.write("zoomChanged\n"))
+        window.zoomHistoryUnavailable.connect(lambda: output.write("zoomHistoryUnavailable\n"))
+        window.zoomHistoryAvailable.connect(lambda: output.write("zoomHistoryAvailable\n"))
+
+        window.mapQueried.connect(lambda: output.write("mapQueried\n"))
+        window.mouseEntered.connect(lambda: output.write("mouseEntered\n"))
+        window.mouseLeftUpPointer.connect(lambda: output.write("mouseLeftUpPointer\n"))
+        window.mouseLeftUp.connect(lambda: output.write("mouseLeftUp\n"))
+        window.mouseMoving.connect(lambda x, y: coordinatesShower.SetLabel("%s , %s" % (x, y)))
+        window.mouseHandlerRegistered.connect(lambda: output.write("mouseHandlerRegistered\n"))
+        window.mouseHandlerUnregistered.connect(lambda: output.write("mouseHandlerUnregistered\n"))
+
+    def testMapWindow(self, giface, map_):
+        self.frame = wx.Frame(parent=None, title=_("Map window test frame"))
+        panel = wx.Panel(parent=self.frame, id=wx.ID_ANY)
+        sizer = wx.BoxSizer(wx.VERTICAL)
+        mapWindowProperties = MapWindowProperties()
+        mapWindowProperties.setValuesFromUserSettings()
+        width, height = self.frame.GetClientSize()
+        copyOfInitMap(map_, width, height)
+        window = BufferedWindow(parent=panel, giface=giface, Map=map_,
+                                properties=mapWindowProperties, frame=self.frame)
+        sizer.Add(item=window, proportion=1, flag=wx.EXPAND | wx.ALL, border=5)
+        panel.SetSizer(sizer)
+        panel.Layout()
+        self.frame.Show()
+
+    def testMapDisplay(self, giface, map_):
+        # known issues (should be similar with d.mon):
+        # * opening map in digitizer ends with: vdigit/toolbars.py:723: 'selection' referenced before assignment
+        # * nviz start fails (closes window? segfaults?) after mapdisp/frame.py:306: 'NoneType' object has no attribute 'GetLayerNotebook'
+        frame = MapFrame(parent=None, title=_("Map display test"),
+                         giface=giface, Map=map_)
+        # this is questionable: how complete the giface when creating objects
+        # which are in giface
+        giface.mapWindow = frame.GetMapWindow()
+        frame.GetMapWindow().ZoomToMap()
+        frame.Show()
+
+    def testMapWindowApi(self, giface, map_):
+        self.frame = wx.Frame(parent=None, title=_("Map window API test frame"))
+        panel = wx.Panel(parent=self.frame, id=wx.ID_ANY)
+        sizer = wx.BoxSizer(wx.VERTICAL)
+
+        mapWindowProperties = MapWindowProperties()
+        mapWindowProperties.setValuesFromUserSettings()
+        mapWindowProperties.showRegion = True
+
+        width, height = self.frame.GetClientSize()
+        copyOfInitMap(map_, width, height)
+        window = BufferedWindow(parent=panel, giface=giface, Map=map_,
+                                properties=mapWindowProperties, frame=self.frame)
+
+        giface.mapWindow = window
+
+        sizer.Add(item=window, proportion=1, flag=wx.EXPAND | wx.ALL, border=5)
+        panel.SetSizer(sizer)
+        panel.Layout()
+
+        window.ZoomToWind()
+
+        from mapdisp.frame import MeasureController
+        self.measureController = MeasureController(giface)
+        self.measureController.StartMeasurement()
+        self._listenToAllMapWindowSignals(window)
+
+        self.frame.Show()
+
+    def testMapWindowDistance(self, giface, map_):
+        self.frame = wx.Frame(parent=None,
+                              title=_("Map window distance measurement test frame"))
+        panel = wx.Panel(parent=self.frame, id=wx.ID_ANY)
+        sizer = wx.BoxSizer(wx.VERTICAL)
+
+        mapWindowProperties = MapWindowProperties()
+        mapWindowProperties.setValuesFromUserSettings()
+        mapWindowProperties.showRegion = True
+
+        width, height = self.frame.GetClientSize()
+        copyOfInitMap(map_, width, height)
+        window = BufferedWindow(parent=panel, giface=giface, Map=map_,
+                                properties=mapWindowProperties, frame=self.frame)
+
+        giface.mapWindow = window
+
+        sizer.Add(item=window, proportion=1, flag=wx.EXPAND | wx.ALL, border=5)
+        panel.SetSizer(sizer)
+        panel.Layout()
+
+        window.ZoomToWind()
+
+        self._listenToAllMapWindowSignals(window)
+
+        self.frame.Show()
+
+        from mapdisp.analysis import MeasureDistanceController
+        self.controller = MeasureDistanceController(giface, window)
+        self.controller.Start()
+
+    def testMapWindowProfile(self, giface, map_):
+        self.frame = wx.Frame(parent=None,
+                              title=_("Map window profile tool test frame"))
+        panel = wx.Panel(parent=self.frame, id=wx.ID_ANY)
+        sizer = wx.BoxSizer(wx.VERTICAL)
+
+        mapWindowProperties = MapWindowProperties()
+        mapWindowProperties.setValuesFromUserSettings()
+        mapWindowProperties.showRegion = True
+
+        width, height = self.frame.GetClientSize()
+        copyOfInitMap(map_, width, height)
+        window = BufferedWindow(parent=panel, giface=giface, Map=map_,
+                                properties=mapWindowProperties, frame=self.frame)
+
+        giface.mapWindow = window
+
+        sizer.Add(item=window, proportion=1, flag=wx.EXPAND | wx.ALL, border=5)
+        panel.SetSizer(sizer)
+        panel.Layout()
+
+        window.ZoomToWind()
+
+        self._listenToAllMapWindowSignals(window)
+
+        self.frame.Show()
+
+        from mapdisp.analysis import ProfileController
+        self.controller = ProfileController(giface, window)
+        self.controller.Start()
+
+        rasters = []
+        for layer in giface.GetLayerList().GetSelectedLayers():
+            if layer.maplayer.GetType() == 'raster':
+                rasters.append(layer.maplayer.GetName())
+
+        from wxplot.profile import ProfileFrame
+        profileWindow = ProfileFrame(parent=self.frame,
+                                     controller=self.controller,
+                                     units=map_.projinfo['units'],
+                                     rasterList=rasters)
+        profileWindow.CentreOnParent()
+        profileWindow.Show()
+        # Open raster select dialog to make sure that a raster (and
+        # the desired raster) is selected to be profiled
+        profileWindow.OnSelectRaster(None)
+
+
+def main():
+    """!Sets the GRASS display driver
+    """
+    driver = UserSettings.Get(group='display', key='driver', subkey='type')
+    if driver == 'png':
+        os.environ['GRASS_RENDER_IMMEDIATE'] = 'png'
+    else:
+        os.environ['GRASS_RENDER_IMMEDIATE'] = 'cairo'
+
+    # TODO: message format should not be GUI
+    # TODO: should messages here be translatable?
+    # (for test its great, for translator not)
+
+    options, flags = grass.parser()
+    test = options['test']
+
+    app = wx.PySimpleApp()
+    if not CheckWxVersion([2, 9]):
+        wx.InitAllImageHandlers()
+
+    map_ = Map()
+
+    if options['raster']:
+        names = options['raster']
+        for name in names.split(','):
+            cmdlist = ['d.rast', 'map=%s' % name]
+            map_.AddLayer(ltype='raster', command=cmdlist, active=True,
+                          name=name, hidden=False, opacity=1.0,
+                          render=True)
+    if options['vector']:
+        names = options['vector']
+        for name in names.split(','):
+            cmdlist = ['d.vect', 'map=%s' % name]
+            map_.AddLayer(ltype='vector', command=cmdlist, active=True,
+                          name=name, hidden=False, opacity=1.0,
+                          render=True)
+
+    giface = MapdispGrassInterface(map_=map_)
+    tester = Tester()
+
+    if test == 'mapwindow':
+        tester.testMapWindow(giface, map_)
+    elif test == 'mapdisplay':
+        tester.testMapDisplay(giface, map_)
+    elif test == 'apitest':
+        tester.testMapWindowApi(giface, map_)
+    elif test == 'distance':
+        tester.testMapWindowDistance(giface, map_)
+    elif test == 'profile':
+        tester.testMapWindowProfile(giface, map_)
+    else:
+        # TODO: this should not happen but happens
+        import grass.script as sgrass
+        sgrass.fatal(_("Unknown value %s of test parameter." % test))
+
+    app.MainLoop()
+
+
+if __name__ == '__main__':
+    main()