Thuban/UI/view.py

# Copyright (c) 2001, 2002 by Intevation GmbH
# Authors:
# Bernhard Herzog <[email protected]>
#
# This program is free software under the GPL (>=v2)
# Read the file COPYING coming with Thuban for details.

"""
Classes for display of a map and interaction with it
"""

__version__ = "$Revision$"

from math import hypot

from wxPython.wx import wxWindow,\
     wxPaintDC, wxColour, wxClientDC, wxINVERT, wxTRANSPARENT_BRUSH, wxFont,\
     EVT_PAINT, EVT_LEFT_DOWN, EVT_LEFT_UP, EVT_MOTION, EVT_LEAVE_WINDOW


from wxPython import wx

from wxproj import point_in_polygon_shape, shape_centroid


from Thuban.Model.messages import MAP_PROJECTION_CHANGED, \
     LAYERS_CHANGED, LAYER_LEGEND_CHANGED, LAYER_VISIBILITY_CHANGED
from Thuban.Model.layer import SHAPETYPE_POLYGON, SHAPETYPE_ARC, \
     SHAPETYPE_POINT
from Thuban.Model.label import ALIGN_CENTER, ALIGN_TOP, ALIGN_BOTTOM, \
     ALIGN_LEFT, ALIGN_RIGHT
from Thuban.Lib.connector import Publisher

from renderer import ScreenRenderer, PrinterRender

import labeldialog

from messages import SELECTED_SHAPE, VIEW_POSITION


#
#   The tools
#

class Tool:

    """
    Base class for the interactive tools
    """

    def __init__(self, view):
        """Intitialize the tool. The view is the canvas displaying the map"""
        self.view = view
        self.start = self.current = None
        self.dragging = 0
        self.drawn = 0

    def Name(self):
        """Return the tool's name"""
        return ''

    def drag_start(self, x, y):
        self.start = self.current = x, y
        self.dragging = 1

    def drag_move(self, x, y):
        self.current = x, y

    def drag_stop(self, x, y):
        self.current = x, y
        self.dragging = 0

    def Show(self, dc):
        if not self.drawn:
            self.draw(dc)
        self.drawn = 1

    def Hide(self, dc):
        if self.drawn:
            self.draw(dc)
        self.drawn = 0

    def draw(self, dc):
        pass

    def MouseDown(self, event):
        self.drag_start(event.m_x, event.m_y)

    def MouseMove(self, event):
        if self.dragging:
            self.drag_move(event.m_x, event.m_y)

    def MouseUp(self, event):
        if self.dragging:
            self.drag_move(event.m_x, event.m_y)

    def Cancel(self):
        self.dragging = 0


class RectTool(Tool):

    """Base class for tools that draw rectangles while dragging"""

    def draw(self, dc):
        sx, sy = self.start
        cx, cy = self.current
        dc.DrawRectangle(sx, sy, cx - sx, cy - sy)

class ZoomInTool(RectTool):

    """The Zoom-In Tool"""

    def Name(self):
        return "ZoomInTool"

    def proj_rect(self):
        """return the rectangle given by start and current in projected
        coordinates"""
        sx, sy = self.start
        cx, cy = self.current
        left, top = self.view.win_to_proj(sx, sy)
        right, bottom = self.view.win_to_proj(cx, cy)
        return (min(left, right), min(top, bottom),
                max(left, right), max(top, bottom))

    def MouseUp(self, event):
        if self.dragging:
            Tool.MouseUp(self, event)
            sx, sy = self.start
            cx, cy = self.current
            if sx == cx and sy == cy:
                # Just a mouse click. Simply zoom in by a factor of two
                self.view.ZoomFactor(2, center = (cx, cy))
            else:
                # A drag. Zoom in to the rectangle
                self.view.FitRectToWindow(self.proj_rect())


class ZoomOutTool(RectTool):

    """The Zoom-Out Tool"""
    
    def Name(self):
        return "ZoomOutTool"

    def MouseUp(self, event):
        if self.dragging:
            Tool.MouseUp(self, event)
            sx, sy = self.start
            cx, cy = self.current
            if sx == cx and sy == cy:
                # Just a mouse click. Simply zoom out by a factor of two
                self.view.ZoomFactor(0.5, center = (cy, cy))
            else:
                # A drag. Zoom out to the rectangle
                self.view.ZoomOutToRect((min(sx, cx), min(sy, cy),
                                         max(sx, cx), max(sy, cy)))


class PanTool(Tool):

    """The Pan Tool"""

    def Name(self):
        return "PanTool"

    def MouseMove(self, event):
        if self.dragging:
            x0, y0 = self.current
            Tool.MouseMove(self, event)
            x, y = self.current
            width, height = self.view.GetSizeTuple()
            dc = self.view.drag_dc
            dc.Blit(0, 0, width, height, dc, x0 - x, y0 - y)

    def MouseUp(self, event):
        if self.dragging:
            Tool.MouseUp(self, event)
            sx, sy = self.start
            cx, cy = self.current
            self.view.Translate(cx - sx, cy - sy)
        
class IdentifyTool(Tool):

    """The "Identify" Tool"""
    
    def Name(self):
        return "IdentifyTool"

    def MouseUp(self, event):
        self.view.SelectShapeAt(event.m_x, event.m_y)


class LabelTool(Tool):

    """The "Label" Tool"""

    def Name(self):
        return "LabelTool"

    def MouseUp(self, event):
        self.view.LabelShapeAt(event.m_x, event.m_y)


class MapPrintout(wx.wxPrintout):

    """
    wxPrintout class for printing Thuban maps
    """

    def __init__(self, map):
        wx.wxPrintout.__init__(self)
        self.map = map

    def GetPageInfo(self):
        return (1, 1, 1, 1)

    def HasPage(self, pagenum):
        return pagenum == 1

    def OnPrintPage(self, pagenum):
        if pagenum == 1:
            self.draw_on_dc(self.GetDC())

    def draw_on_dc(self, dc):
        width, height = self.GetPageSizePixels()
        llx, lly, urx, ury = self.map.ProjectedBoundingBox()
        scalex = width / (urx - llx)
        scaley = height / (ury - lly)
        scale = min(scalex, scaley)
        offx = 0.5 * (width - (urx + llx) * scale)
        offy = 0.5 * (height + (ury + lly) * scale)

        resx, resy = self.GetPPIPrinter()
        renderer = PrinterRender(dc, scale, (offx, offy), resolution = resx)
        renderer.RenderMap(self.map)
        return wx.true
        

class MapCanvas(wxWindow, Publisher):

    """A widget that displays a map and offers some interaction"""

    def __init__(self, parent, winid, interactor):
        wxWindow.__init__(self, parent, winid)
        self.SetBackgroundColour(wxColour(255, 255, 255))

        # the map displayed in this canvas. Set with SetMap()
        self.map = None

        # scale and offset describe the transformation from projected
        # coordinates to window coordinates.
        self.scale = 1.0
        self.offset = (0, 0)

        # whether the user is currently dragging the mouse, i.e. moving
        # the mouse while pressing a mouse button
        self.dragging = 0

        # the currently active tool
        self.tool = None

        # The current mouse position of the last OnMotion event or None
        # if the mouse is outside the window.
        self.current_position = None


        # If true, OnIdle will call do_redraw to do the actual
        # redrawing. Set by OnPaint to avoid some unnecessary redraws.
        # To force a redraw call full_redraw().
        self.redraw_on_idle = 0

        # the bitmap serving as backing store
        self.bitmap = None

        # the interactor
        self.interactor = interactor
        self.interactor.Subscribe(SELECTED_SHAPE, self.shape_selected)

        # subscribe the WX events we're interested in
        EVT_PAINT(self, self.OnPaint)
        EVT_LEFT_DOWN(self, self.OnLeftDown)
        EVT_LEFT_UP(self, self.OnLeftUp)
        EVT_MOTION(self, self.OnMotion)
        EVT_LEAVE_WINDOW(self, self.OnLeaveWindow)
        wx.EVT_SIZE(self, self.OnSize)
        wx.EVT_IDLE(self, self.OnIdle)

    def __del__(self):
        wxWindow.__del__(self)
        Publisher.__del__(self)

    def OnPaint(self, event):
        dc = wxPaintDC(self)
        if self.map is not None and self.map.HasLayers():
            # We have a non-empty map. Redraw it in idle time
            self.redraw_on_idle = 1
        else:
            # If we've got no map or if the map is empty, simply clear
            # the screen.
            
            # XXX it's probably possible to get rid of this. The
            # background color of the window is already white and the
            # only thing we may have to do is to call self.Refresh()
            # with a true argument in the right places.
            dc.BeginDrawing()
            dc.Clear()            
            dc.EndDrawing()

    def do_redraw(self):
        # This should only be called if we have a non-empty map. We draw
        # it into a memory DC and then blit it to the screen.

        width, height = self.GetSizeTuple()

        # If self.bitmap's still there, reuse it. Otherwise redraw it
        if self.bitmap is not None:
            bitmap = self.bitmap
        else:
            bitmap = wx.wxEmptyBitmap(width, height)
            dc = wx.wxMemoryDC()
            dc.SelectObject(bitmap)
            dc.BeginDrawing()

            # clear the background
            dc.SetBrush(wx.wxWHITE_BRUSH)
            dc.SetPen(wx.wxTRANSPARENT_PEN)
            dc.DrawRectangle(0, 0, width, height)

            if 1: #self.interactor.selected_map is self.map:
                selected_layer = self.interactor.selected_layer
                selected_shape = self.interactor.selected_shape
            else:
                selected_layer = None
                selected_shape = None

            # draw the map into the bitmap
            renderer = ScreenRenderer(dc, self.scale, self.offset)
            renderer.RenderMap(self.map, selected_layer, selected_shape)

            dc.EndDrawing()
            dc.SelectObject(wx.wxNullBitmap)
            self.bitmap = bitmap

        # blit the bitmap to the screen
        dc = wx.wxMemoryDC()
        dc.SelectObject(bitmap)
        clientdc = wxClientDC(self)
        clientdc.BeginDrawing()
        clientdc.Blit(0, 0, width, height, dc, 0, 0)
        clientdc.EndDrawing()

    def Print(self):
        printer = wx.wxPrinter()
        printout = MapPrintout(self.map)
        printer.Print(self, printout, wx.true)
        printout.Destroy()
        
    def SetMap(self, map):
        redraw_channels = (LAYERS_CHANGED, LAYER_LEGEND_CHANGED,
                           LAYER_VISIBILITY_CHANGED)
        if self.map is not None:
            for channel in redraw_channels:
                self.map.Unsubscribe(channel, self.full_redraw)
            self.map.Unsubscribe(MAP_PROJECTION_CHANGED,
                                 self.projection_changed)
        self.map = map
        if self.map is not None:
            for channel in redraw_channels:
                self.map.Subscribe(channel, self.full_redraw)
            self.map.Subscribe(MAP_PROJECTION_CHANGED, self.projection_changed)
        self.FitMapToWindow()
        # force a redraw. If map is not empty, it's already been called
        # by FitMapToWindow but if map is empty it hasn't been called
        # yet so we have to explicitly call it.
        self.full_redraw()

    def Map(self):
        return self.map

    def redraw(self, *args):
        self.Refresh(0)

    def full_redraw(self, *args):
        self.bitmap = None
        self.redraw()

    def projection_changed(self, *args):
        self.FitMapToWindow()
        self.full_redraw()

    def set_view_transform(self, scale, offset):
        self.scale = scale
        self.offset = offset
        self.full_redraw()

    def proj_to_win(self, x, y):
        """\
        Return the point in  window coords given by projected coordinates x y
        """
        offx, offy = self.offset
        return (self.scale * x + offx, -self.scale * y + offy)

    def win_to_proj(self, x, y):
        """\
        Return the point in projected coordinates given by window coords x y
        """
        offx, offy = self.offset
        return ((x - offx) / self.scale, (offy - y) / self.scale)

    def FitRectToWindow(self, rect):
        width, height = self.GetSizeTuple()
        llx, lly, urx, ury = rect
        if llx == urx or lly == ury:
            # zero with or zero height. Do Nothing
            return
        scalex = width / (urx - llx)
        scaley = height / (ury - lly)
        scale = min(scalex, scaley)
        offx = 0.5 * (width - (urx + llx) * scale)
        offy = 0.5 * (height + (ury + lly) * scale)
        self.set_view_transform(scale, (offx, offy))

    def FitMapToWindow(self):
        """\
        Set the scale and offset so that the map is centered in the
        window
        """
        bbox = self.map.ProjectedBoundingBox()
        if bbox is not None:
            self.FitRectToWindow(bbox)

    def ZoomFactor(self, factor, center = None):
        """Multiply the zoom by factor and center on center.

        The optional parameter center is a point in window coordinates
        that should be centered. If it is omitted, it defaults to the
        center of the window
        """
        width, height = self.GetSizeTuple()
        scale = self.scale * factor
        offx, offy = self.offset
        if center is not None:
            cx, cy = center
        else:
            cx = width / 2
            cy = height / 2
        offset = (factor * (offx - cx) + width / 2,
                  factor * (offy - cy) + height / 2)
        self.set_view_transform(scale, offset)

    def ZoomOutToRect(self, rect):
        # rect is given in window coordinates

        # determine the bbox of the displayed region in projected
        # coordinates
        width, height = self.GetSizeTuple()
        llx, lly = self.win_to_proj(0, height - 1)
        urx, ury = self.win_to_proj(width - 1, 0)

        sx, sy, ex, ey = rect
        scalex = (ex - sx) / (urx - llx)
        scaley = (ey - sy) / (ury - lly)
        scale = min(scalex, scaley)

        offx = 0.5 * ((ex + sx) - (urx + llx) * scale)
        offy = 0.5 * ((ey + sy) + (ury + lly) * scale)
        self.set_view_transform(scale, (offx, offy))

    def Translate(self, dx, dy):
        offx, offy = self.offset
        self.set_view_transform(self.scale, (offx + dx, offy + dy))

    def ZoomInTool(self):
        self.tool = ZoomInTool(self)

    def ZoomOutTool(self):
        self.tool = ZoomOutTool(self)

    def PanTool(self):
        self.tool = PanTool(self)

    def IdentifyTool(self):
        self.tool = IdentifyTool(self)

    def LabelTool(self):
        self.tool = LabelTool(self)

    def CurrentTool(self):
        return self.tool and self.tool.Name() or None

    def CurrentPosition(self):
        """Return current position of the mouse in projected coordinates.

        The result is a 2-tuple of floats with the coordinates. If the
        mouse is not in the window, the result is None.
        """
        if self.current_position is not None:
            x, y = self.current_position
            return self.win_to_proj(x, y)
        else:
            return None

    def set_current_position(self, event):
        """Set the current position from event

        Should be called by all events that contain mouse positions
        especially EVT_MOTION. The event paramete may be None to
        indicate the the pointer left the window.
        """
        if event is not None:
            self.current_position = (event.m_x, event.m_y)
        else:
            self.current_position = None
        self.issue(VIEW_POSITION)

    def OnLeftDown(self, event):
        self.set_current_position(event)
        if self.tool is not None:
            self.drag_dc = wxClientDC(self)
            self.drag_dc.SetLogicalFunction(wxINVERT)
            self.drag_dc.SetBrush(wxTRANSPARENT_BRUSH)
            self.CaptureMouse()
            self.tool.MouseDown(event)
            self.tool.Show(self.drag_dc)
            self.dragging = 1
        
    def OnLeftUp(self, event):
        self.ReleaseMouse()
        self.set_current_position(event)
        if self.dragging:
            self.tool.Hide(self.drag_dc)
            self.tool.MouseUp(event)
            self.drag_dc = None
        self.dragging = 0

    def OnMotion(self, event):
        self.set_current_position(event)
        if self.dragging:
            self.tool.Hide(self.drag_dc)
            self.tool.MouseMove(event)
            self.tool.Show(self.drag_dc)

    def OnLeaveWindow(self, event):
        self.set_current_position(None)

    def OnIdle(self, event):
        if self.redraw_on_idle:
            self.do_redraw()
        self.redraw_on_idle = 0

    def OnSize(self, event):
        # the window's size has changed. We have to get a new bitmap. If
        # we want to be clever we could try to get by without throwing
        # everything away. E.g. when the window gets smaller, we could
        # either keep the bitmap or create the new one from the old one.
        # Even when the window becomes larger some parts of the bitmap
        # could be reused.
        self.full_redraw()

    def shape_selected(self, layer, shape):
        self.full_redraw()

    def find_shape_at(self, px, py, select_labels = 0, selected_layer = 1):
        """Determine the shape at point px, py in window coords

        Return the shape and the corresponding layer as a tuple (layer,
        shape).

        If the optional parameter select_labels is true (default false)
        search through the labels. If a label is found return it's index
        as the shape and None as the layer.

        If the optional parameter selected_layer is true (default), only
        search in the currently selected layer.
        """
        map_proj = self.map.projection
        if map_proj is not None:
            forward = map_proj.Forward
        else:
            forward = None

        scale = self.scale
        offx, offy = self.offset

        if select_labels:
            labels = self.map.LabelLayer().Labels()
            
            if labels:
                dc = wxClientDC(self)
                font = wxFont(10, wx.wxSWISS, wx.wxNORMAL, wx.wxNORMAL)
                dc.SetFont(font)
                for i in range(len(labels) - 1, -1, -1):
                    label = labels[i]
                    x = label.x
                    y = label.y
                    text = label.text
                    if forward:
                        x, y = forward(x, y)
                    x = x * scale + offx
                    y = -y * scale + offy
                    width, height = dc.GetTextExtent(text)
                    if label.halign == ALIGN_LEFT:
                        # nothing to be done
                        pass
                    elif label.halign == ALIGN_RIGHT:
                        x = x - width
                    elif label.halign == ALIGN_CENTER:
                        x = x - width/2
                    if label.valign == ALIGN_TOP:
                        # nothing to be done
                        pass
                    elif label.valign == ALIGN_BOTTOM:
                        y = y - height
                    elif label.valign == ALIGN_CENTER:
                        y = y - height/2
                    if x <= px < x + width and y <= py <= y + height:
                        return None, i

        if selected_layer:
            layer = self.interactor.SelectedLayer()
            if layer is not None:
                layers = [layer]
            else:
                # no layer selected. Use an empty list to effectively
                # ignore all layers.
                layers = []
        else:
            layers = self.map.Layers()

        for layer_index in range(len(layers) - 1, -1, -1):
            layer = layers[layer_index]

            # search only in visible layers
            if not layer.Visible():
                continue

            filled = layer.fill is not None
            stroked = layer.stroke is not None
                
            layer_proj = layer.projection
            if layer_proj is not None:
                inverse = layer_proj.Inverse
            else:
                inverse = None
                
            shapetype = layer.ShapeType()

            select_shape = -1
            if shapetype == SHAPETYPE_POLYGON:
                for i in range(layer.NumShapes() - 1, -1, -1):
                    result = point_in_polygon_shape(layer.shapefile.cobject(),
                                                    i,
                                                    filled, stroked,
                                                    map_proj, layer_proj,
                                                    scale, -scale, offx, offy,
                                                    px, py)
                    if result:
                        select_shape = i
                        break
            elif shapetype == SHAPETYPE_ARC:
                for i in range(layer.NumShapes() - 1, -1, -1):
                    result = point_in_polygon_shape(layer.shapefile.cobject(),
                                                    i, 0, 1,
                                                    map_proj, layer_proj,
                                                    scale, -scale, offx, offy,
                                                    px, py)
                    if result < 0:
                        select_shape = i
                        break
            elif shapetype == SHAPETYPE_POINT:
                for i in range(layer.NumShapes() - 1, -1, -1):
                    shape = layer.Shape(i)
                    x, y = shape.Points()[0]
                    if inverse:
                        x, y = inverse(x, y)
                    if forward:
                        x, y = forward(x, y)
                    x = x * scale + offx
                    y = -y * scale + offy
                    if hypot(px - x, py - y) < 5:
                        select_shape = i
                        break

            if select_shape >= 0:
                return layer, select_shape
        return None, None

    def SelectShapeAt(self, x, y):
        layer, shape = self.find_shape_at(x, y, selected_layer = 0)
        # If layer is None, then shape will also be None. We don't want
        # to deselect the currently selected layer, so we simply select
        # the already selected layer again.
        if layer is None:
            layer = self.interactor.SelectedLayer()
        self.interactor.SelectLayerAndShape(layer, shape)

    def LabelShapeAt(self, x, y):
        ox = x; oy = y
        label_layer = self.map.LabelLayer()
        layer, shape_index = self.find_shape_at(x, y, select_labels = 1)
        if layer is None and shape_index is not None:
            # a label was selected
            label_layer.RemoveLabel(shape_index)
        elif layer is not None:
            text = labeldialog.run_label_dialog(self, layer.table, shape_index)
            if text:
                proj = self.map.projection
                if proj is not None:
                    map_proj = proj
                else:
                    map_proj = None
                proj = layer.projection
                if proj is not None:
                    layer_proj = proj
                else:
                    layer_proj = None

                shapetype = layer.ShapeType()
                if shapetype == SHAPETYPE_POLYGON:
                    x, y = shape_centroid(layer.shapefile.cobject(),
                                          shape_index,
                                          map_proj, layer_proj, 1, 1, 0, 0)
                    if map_proj is not None:
                        x, y = map_proj.Inverse(x, y)
                else:
                    shape = layer.Shape(shape_index)
                    if shapetype == SHAPETYPE_POINT:
                        x, y = shape.Points()[0]
                    else:
                        # assume SHAPETYPE_ARC
                        points = shape.Points()
                        x, y = points[len(points) / 2]
                    if layer_proj is not None:
                        x, y = layer_proj.Inverse(x, y)
                if shapetype == SHAPETYPE_POINT:
                    halign = ALIGN_LEFT
                    valign = ALIGN_CENTER
                elif shapetype == SHAPETYPE_POLYGON:
                    halign = ALIGN_CENTER
                    valign = ALIGN_CENTER
                elif shapetype == SHAPETYPE_ARC:
                    halign = ALIGN_LEFT
                    valign = ALIGN_CENTER
                label_layer.AddLabel(x, y, text,
                                     halign = halign, valign = valign)
1	bh	78	# Copyright (c) 2001, 2002 by Intevation GmbH
2	bh	6	# Authors:
3			# Bernhard Herzog <[email protected]>
4			#
5			# This program is free software under the GPL (>=v2)
6			# Read the file COPYING coming with Thuban for details.
7
8			"""
9			Classes for display of a map and interaction with it
10			"""
11
12			__version__ = "$Revision$"
13
14			from math import hypot
15
16			from wxPython.wx import wxWindow,\
17			wxPaintDC, wxColour, wxClientDC, wxINVERT, wxTRANSPARENT_BRUSH, wxFont,\
18	bh	122	EVT_PAINT, EVT_LEFT_DOWN, EVT_LEFT_UP, EVT_MOTION, EVT_LEAVE_WINDOW
19	bh	6
20
21			from wxPython import wx
22
23			from wxproj import point_in_polygon_shape, shape_centroid
24
25
26			from Thuban.Model.messages import MAP_PROJECTION_CHANGED, \
27			LAYERS_CHANGED, LAYER_LEGEND_CHANGED, LAYER_VISIBILITY_CHANGED
28			from Thuban.Model.layer import SHAPETYPE_POLYGON, SHAPETYPE_ARC, \
29			SHAPETYPE_POINT
30			from Thuban.Model.label import ALIGN_CENTER, ALIGN_TOP, ALIGN_BOTTOM, \
31			ALIGN_LEFT, ALIGN_RIGHT
32	bh	122	from Thuban.Lib.connector import Publisher
33	bh	6
34			from renderer import ScreenRenderer, PrinterRender
35
36			import labeldialog
37
38	bh	122	from messages import SELECTED_SHAPE, VIEW_POSITION
39	bh	6
40
41			#
42			# The tools
43			#
44
45			class Tool:
46
47			"""
48			Base class for the interactive tools
49			"""
50
51			def __init__(self, view):
52			"""Intitialize the tool. The view is the canvas displaying the map"""
53			self.view = view
54			self.start = self.current = None
55			self.dragging = 0
56			self.drawn = 0
57
58			def Name(self):
59			"""Return the tool's name"""
60			return ''
61
62			def drag_start(self, x, y):
63			self.start = self.current = x, y
64			self.dragging = 1
65
66			def drag_move(self, x, y):
67			self.current = x, y
68
69			def drag_stop(self, x, y):
70			self.current = x, y
71			self.dragging = 0
72
73			def Show(self, dc):
74			if not self.drawn:
75			self.draw(dc)
76			self.drawn = 1
77
78			def Hide(self, dc):
79			if self.drawn:
80			self.draw(dc)
81			self.drawn = 0
82
83			def draw(self, dc):
84			pass
85
86			def MouseDown(self, event):
87			self.drag_start(event.m_x, event.m_y)
88
89			def MouseMove(self, event):
90			if self.dragging:
91			self.drag_move(event.m_x, event.m_y)
92
93			def MouseUp(self, event):
94			if self.dragging:
95			self.drag_move(event.m_x, event.m_y)
96
97			def Cancel(self):
98			self.dragging = 0
99
100
101			class RectTool(Tool):
102
103			"""Base class for tools that draw rectangles while dragging"""
104
105			def draw(self, dc):
106			sx, sy = self.start
107			cx, cy = self.current
108			dc.DrawRectangle(sx, sy, cx - sx, cy - sy)
109
110			class ZoomInTool(RectTool):
111
112			"""The Zoom-In Tool"""
113
114			def Name(self):
115			return "ZoomInTool"
116
117			def proj_rect(self):
118			"""return the rectangle given by start and current in projected
119			coordinates"""
120			sx, sy = self.start
121			cx, cy = self.current
122			left, top = self.view.win_to_proj(sx, sy)
123			right, bottom = self.view.win_to_proj(cx, cy)
124			return (min(left, right), min(top, bottom),
125			max(left, right), max(top, bottom))
126
127			def MouseUp(self, event):
128			if self.dragging:
129			Tool.MouseUp(self, event)
130	bh	57	sx, sy = self.start
131			cx, cy = self.current
132			if sx == cx and sy == cy:
133			# Just a mouse click. Simply zoom in by a factor of two
134			self.view.ZoomFactor(2, center = (cx, cy))
135			else:
136			# A drag. Zoom in to the rectangle
137			self.view.FitRectToWindow(self.proj_rect())
138	bh	6
139
140			class ZoomOutTool(RectTool):
141
142			"""The Zoom-Out Tool"""
143
144			def Name(self):
145			return "ZoomOutTool"
146
147			def MouseUp(self, event):
148			if self.dragging:
149			Tool.MouseUp(self, event)
150			sx, sy = self.start
151			cx, cy = self.current
152	bh	57	if sx == cx and sy == cy:
153			# Just a mouse click. Simply zoom out by a factor of two
154			self.view.ZoomFactor(0.5, center = (cy, cy))
155			else:
156			# A drag. Zoom out to the rectangle
157			self.view.ZoomOutToRect((min(sx, cx), min(sy, cy),
158			max(sx, cx), max(sy, cy)))
159	bh	6
160
161			class PanTool(Tool):
162
163			"""The Pan Tool"""
164
165			def Name(self):
166			return "PanTool"
167
168			def MouseMove(self, event):
169			if self.dragging:
170			x0, y0 = self.current
171			Tool.MouseMove(self, event)
172			x, y = self.current
173			width, height = self.view.GetSizeTuple()
174			dc = self.view.drag_dc
175			dc.Blit(0, 0, width, height, dc, x0 - x, y0 - y)
176
177			def MouseUp(self, event):
178			if self.dragging:
179			Tool.MouseUp(self, event)
180			sx, sy = self.start
181			cx, cy = self.current
182			self.view.Translate(cx - sx, cy - sy)
183
184			class IdentifyTool(Tool):
185
186			"""The "Identify" Tool"""
187
188			def Name(self):
189			return "IdentifyTool"
190
191			def MouseUp(self, event):
192			self.view.SelectShapeAt(event.m_x, event.m_y)
193
194
195			class LabelTool(Tool):
196
197			"""The "Label" Tool"""
198
199			def Name(self):
200			return "LabelTool"
201
202			def MouseUp(self, event):
203			self.view.LabelShapeAt(event.m_x, event.m_y)
204
205
206
207
208			class MapPrintout(wx.wxPrintout):
209
210			"""
211			wxPrintout class for printing Thuban maps
212			"""
213
214			def __init__(self, map):
215			wx.wxPrintout.__init__(self)
216			self.map = map
217
218			def GetPageInfo(self):
219			return (1, 1, 1, 1)
220
221			def HasPage(self, pagenum):
222			return pagenum == 1
223
224			def OnPrintPage(self, pagenum):
225			if pagenum == 1:
226			self.draw_on_dc(self.GetDC())
227
228			def draw_on_dc(self, dc):
229			width, height = self.GetPageSizePixels()
230			llx, lly, urx, ury = self.map.ProjectedBoundingBox()
231			scalex = width / (urx - llx)
232			scaley = height / (ury - lly)
233			scale = min(scalex, scaley)
234			offx = 0.5 * (width - (urx + llx) * scale)
235			offy = 0.5 * (height + (ury + lly) * scale)
236
237			resx, resy = self.GetPPIPrinter()
238			renderer = PrinterRender(dc, scale, (offx, offy), resolution = resx)
239			renderer.RenderMap(self.map)
240			return wx.true
241
242
243	bh	122	class MapCanvas(wxWindow, Publisher):
244	bh	6
245			"""A widget that displays a map and offers some interaction"""
246
247	bh	23	def __init__(self, parent, winid, interactor):
248	bh	6	wxWindow.__init__(self, parent, winid)
249			self.SetBackgroundColour(wxColour(255, 255, 255))
250	bh	125
251			# the map displayed in this canvas. Set with SetMap()
252	bh	6	self.map = None
253	bh	125
254			# scale and offset describe the transformation from projected
255			# coordinates to window coordinates.
256	bh	6	self.scale = 1.0
257			self.offset = (0, 0)
258	bh	125
259			# whether the user is currently dragging the mouse, i.e. moving
260			# the mouse while pressing a mouse button
261	bh	6	self.dragging = 0
262	bh	125
263			# the currently active tool
264	bh	6	self.tool = None
265	bh	125
266			# The current mouse position of the last OnMotion event or None
267			# if the mouse is outside the window.
268			self.current_position = None
269
270
271			# If true, OnIdle will call do_redraw to do the actual
272			# redrawing. Set by OnPaint to avoid some unnecessary redraws.
273			# To force a redraw call full_redraw().
274	bh	6	self.redraw_on_idle = 0
275	bh	125
276			# the bitmap serving as backing store
277			self.bitmap = None
278
279			# the interactor
280			self.interactor = interactor
281			self.interactor.Subscribe(SELECTED_SHAPE, self.shape_selected)
282
283			# subscribe the WX events we're interested in
284	bh	6	EVT_PAINT(self, self.OnPaint)
285			EVT_LEFT_DOWN(self, self.OnLeftDown)
286			EVT_LEFT_UP(self, self.OnLeftUp)
287			EVT_MOTION(self, self.OnMotion)
288	bh	122	EVT_LEAVE_WINDOW(self, self.OnLeaveWindow)
289	bh	125	wx.EVT_SIZE(self, self.OnSize)
290	bh	6	wx.EVT_IDLE(self, self.OnIdle)
291
292	bh	122	def __del__(self):
293			wxWindow.__del__(self)
294			Publisher.__del__(self)
295
296	bh	6	def OnPaint(self, event):
297			dc = wxPaintDC(self)
298	bh	57	if self.map is not None and self.map.HasLayers():
299			# We have a non-empty map. Redraw it in idle time
300			self.redraw_on_idle = 1
301			else:
302			# If we've got no map or if the map is empty, simply clear
303			# the screen.
304
305			# XXX it's probably possible to get rid of this. The
306			# background color of the window is already white and the
307			# only thing we may have to do is to call self.Refresh()
308			# with a true argument in the right places.
309			dc.BeginDrawing()
310			dc.Clear()
311			dc.EndDrawing()
312	bh	6
313			def do_redraw(self):
314	bh	57	# This should only be called if we have a non-empty map. We draw
315			# it into a memory DC and then blit it to the screen.
316	bh	125
317	bh	6	width, height = self.GetSizeTuple()
318
319	bh	125	# If self.bitmap's still there, reuse it. Otherwise redraw it
320			if self.bitmap is not None:
321			bitmap = self.bitmap
322	bh	6	else:
323	bh	125	bitmap = wx.wxEmptyBitmap(width, height)
324			dc = wx.wxMemoryDC()
325			dc.SelectObject(bitmap)
326			dc.BeginDrawing()
327	bh	57
328	bh	125	# clear the background
329			dc.SetBrush(wx.wxWHITE_BRUSH)
330			dc.SetPen(wx.wxTRANSPARENT_PEN)
331			dc.DrawRectangle(0, 0, width, height)
332	bh	6
333	bh	125	if 1: #self.interactor.selected_map is self.map:
334			selected_layer = self.interactor.selected_layer
335			selected_shape = self.interactor.selected_shape
336			else:
337			selected_layer = None
338			selected_shape = None
339	bh	57
340	bh	125	# draw the map into the bitmap
341			renderer = ScreenRenderer(dc, self.scale, self.offset)
342			renderer.RenderMap(self.map, selected_layer, selected_shape)
343
344			dc.EndDrawing()
345			dc.SelectObject(wx.wxNullBitmap)
346			self.bitmap = bitmap
347
348	bh	57	# blit the bitmap to the screen
349	bh	125	dc = wx.wxMemoryDC()
350			dc.SelectObject(bitmap)
351	bh	6	clientdc = wxClientDC(self)
352			clientdc.BeginDrawing()
353			clientdc.Blit(0, 0, width, height, dc, 0, 0)
354			clientdc.EndDrawing()
355
356			def Print(self):
357			printer = wx.wxPrinter()
358			printout = MapPrintout(self.map)
359			printer.Print(self, printout, wx.true)
360			printout.Destroy()
361
362			def SetMap(self, map):
363			redraw_channels = (LAYERS_CHANGED, LAYER_LEGEND_CHANGED,
364			LAYER_VISIBILITY_CHANGED)
365			if self.map is not None:
366			for channel in redraw_channels:
367	bh	125	self.map.Unsubscribe(channel, self.full_redraw)
368	bh	6	self.map.Unsubscribe(MAP_PROJECTION_CHANGED,
369			self.projection_changed)
370			self.map = map
371			if self.map is not None:
372			for channel in redraw_channels:
373	bh	125	self.map.Subscribe(channel, self.full_redraw)
374	bh	6	self.map.Subscribe(MAP_PROJECTION_CHANGED, self.projection_changed)
375			self.FitMapToWindow()
376	bh	57	# force a redraw. If map is not empty, it's already been called
377			# by FitMapToWindow but if map is empty it hasn't been called
378			# yet so we have to explicitly call it.
379	bh	125	self.full_redraw()
380	bh	6
381			def Map(self):
382			return self.map
383
384			def redraw(self, *args):
385			self.Refresh(0)
386
387	bh	125	def full_redraw(self, *args):
388			self.bitmap = None
389			self.redraw()
390
391	bh	6	def projection_changed(self, *args):
392			self.FitMapToWindow()
393	bh	125	self.full_redraw()
394	bh	6
395			def set_view_transform(self, scale, offset):
396			self.scale = scale
397			self.offset = offset
398	bh	125	self.full_redraw()
399	bh	6
400			def proj_to_win(self, x, y):
401			"""\
402			Return the point in window coords given by projected coordinates x y
403			"""
404			offx, offy = self.offset
405			return (self.scale * x + offx, -self.scale * y + offy)
406
407			def win_to_proj(self, x, y):
408			"""\
409			Return the point in projected coordinates given by window coords x y
410			"""
411			offx, offy = self.offset
412			return ((x - offx) / self.scale, (offy - y) / self.scale)
413
414			def FitRectToWindow(self, rect):
415			width, height = self.GetSizeTuple()
416			llx, lly, urx, ury = rect
417	bh	45	if llx == urx or lly == ury:
418			# zero with or zero height. Do Nothing
419			return
420	bh	6	scalex = width / (urx - llx)
421			scaley = height / (ury - lly)
422			scale = min(scalex, scaley)
423			offx = 0.5 * (width - (urx + llx) * scale)
424			offy = 0.5 * (height + (ury + lly) * scale)
425			self.set_view_transform(scale, (offx, offy))
426
427			def FitMapToWindow(self):
428			"""\
429			Set the scale and offset so that the map is centered in the
430			window
431			"""
432			bbox = self.map.ProjectedBoundingBox()
433			if bbox is not None:
434			self.FitRectToWindow(bbox)
435
436	bh	57	def ZoomFactor(self, factor, center = None):
437			"""Multiply the zoom by factor and center on center.
438
439			The optional parameter center is a point in window coordinates
440			that should be centered. If it is omitted, it defaults to the
441			center of the window
442			"""
443	bh	6	width, height = self.GetSizeTuple()
444			scale = self.scale * factor
445			offx, offy = self.offset
446	bh	57	if center is not None:
447			cx, cy = center
448			else:
449			cx = width / 2
450			cy = height / 2
451			offset = (factor * (offx - cx) + width / 2,
452			factor * (offy - cy) + height / 2)
453	bh	6	self.set_view_transform(scale, offset)
454
455			def ZoomOutToRect(self, rect):
456			# rect is given in window coordinates
457
458			# determine the bbox of the displayed region in projected
459			# coordinates
460			width, height = self.GetSizeTuple()
461			llx, lly = self.win_to_proj(0, height - 1)
462			urx, ury = self.win_to_proj(width - 1, 0)
463
464			sx, sy, ex, ey = rect
465			scalex = (ex - sx) / (urx - llx)
466			scaley = (ey - sy) / (ury - lly)
467			scale = min(scalex, scaley)
468
469			offx = 0.5 * ((ex + sx) - (urx + llx) * scale)
470			offy = 0.5 * ((ey + sy) + (ury + lly) * scale)
471			self.set_view_transform(scale, (offx, offy))
472
473			def Translate(self, dx, dy):
474			offx, offy = self.offset
475			self.set_view_transform(self.scale, (offx + dx, offy + dy))
476
477			def ZoomInTool(self):
478			self.tool = ZoomInTool(self)
479
480			def ZoomOutTool(self):
481			self.tool = ZoomOutTool(self)
482
483			def PanTool(self):
484			self.tool = PanTool(self)
485
486			def IdentifyTool(self):
487			self.tool = IdentifyTool(self)
488
489			def LabelTool(self):
490			self.tool = LabelTool(self)
491
492			def CurrentTool(self):
493			return self.tool and self.tool.Name() or None
494
495	bh	122	def CurrentPosition(self):
496			"""Return current position of the mouse in projected coordinates.
497
498			The result is a 2-tuple of floats with the coordinates. If the
499			mouse is not in the window, the result is None.
500			"""
501			if self.current_position is not None:
502			x, y = self.current_position
503			return self.win_to_proj(x, y)
504			else:
505			return None
506
507			def set_current_position(self, event):
508			"""Set the current position from event
509
510			Should be called by all events that contain mouse positions
511			especially EVT_MOTION. The event paramete may be None to
512			indicate the the pointer left the window.
513			"""
514			if event is not None:
515			self.current_position = (event.m_x, event.m_y)
516			else:
517			self.current_position = None
518			self.issue(VIEW_POSITION)
519
520	bh	6	def OnLeftDown(self, event):
521	bh	122	self.set_current_position(event)
522	bh	6	if self.tool is not None:
523			self.drag_dc = wxClientDC(self)
524			self.drag_dc.SetLogicalFunction(wxINVERT)
525			self.drag_dc.SetBrush(wxTRANSPARENT_BRUSH)
526			self.CaptureMouse()
527			self.tool.MouseDown(event)
528			self.tool.Show(self.drag_dc)
529			self.dragging = 1
530
531			def OnLeftUp(self, event):
532			self.ReleaseMouse()
533	bh	122	self.set_current_position(event)
534	bh	6	if self.dragging:
535			self.tool.Hide(self.drag_dc)
536			self.tool.MouseUp(event)
537			self.drag_dc = None
538			self.dragging = 0
539
540			def OnMotion(self, event):
541	bh	122	self.set_current_position(event)
542	bh	6	if self.dragging:
543			self.tool.Hide(self.drag_dc)
544			self.tool.MouseMove(event)
545			self.tool.Show(self.drag_dc)
546
547	bh	122	def OnLeaveWindow(self, event):
548			self.set_current_position(None)
549
550	bh	6	def OnIdle(self, event):
551			if self.redraw_on_idle:
552			self.do_redraw()
553			self.redraw_on_idle = 0
554
555	bh	125	def OnSize(self, event):
556			# the window's size has changed. We have to get a new bitmap. If
557			# we want to be clever we could try to get by without throwing
558			# everything away. E.g. when the window gets smaller, we could
559			# either keep the bitmap or create the new one from the old one.
560			# Even when the window becomes larger some parts of the bitmap
561			# could be reused.
562			self.full_redraw()
563
564	bh	6	def shape_selected(self, layer, shape):
565	bh	125	self.full_redraw()
566	bh	6
567	bh	43	def find_shape_at(self, px, py, select_labels = 0, selected_layer = 1):
568			"""Determine the shape at point px, py in window coords
569
570			Return the shape and the corresponding layer as a tuple (layer,
571			shape).
572
573			If the optional parameter select_labels is true (default false)
574			search through the labels. If a label is found return it's index
575			as the shape and None as the layer.
576
577			If the optional parameter selected_layer is true (default), only
578			search in the currently selected layer.
579			"""
580	bh	6	map_proj = self.map.projection
581			if map_proj is not None:
582			forward = map_proj.Forward
583			else:
584			forward = None
585
586			scale = self.scale
587			offx, offy = self.offset
588
589			if select_labels:
590			labels = self.map.LabelLayer().Labels()
591
592			if labels:
593			dc = wxClientDC(self)
594			font = wxFont(10, wx.wxSWISS, wx.wxNORMAL, wx.wxNORMAL)
595			dc.SetFont(font)
596	bh	60	for i in range(len(labels) - 1, -1, -1):
597	bh	6	label = labels[i]
598			x = label.x
599			y = label.y
600			text = label.text
601			if forward:
602			x, y = forward(x, y)
603			x = x * scale + offx
604			y = -y * scale + offy
605			width, height = dc.GetTextExtent(text)
606			if label.halign == ALIGN_LEFT:
607			# nothing to be done
608			pass
609			elif label.halign == ALIGN_RIGHT:
610			x = x - width
611			elif label.halign == ALIGN_CENTER:
612			x = x - width/2
613			if label.valign == ALIGN_TOP:
614			# nothing to be done
615			pass
616			elif label.valign == ALIGN_BOTTOM:
617			y = y - height
618			elif label.valign == ALIGN_CENTER:
619			y = y - height/2
620			if x <= px < x + width and y <= py <= y + height:
621			return None, i
622	bh	43
623			if selected_layer:
624			layer = self.interactor.SelectedLayer()
625			if layer is not None:
626			layers = [layer]
627			else:
628			# no layer selected. Use an empty list to effectively
629			# ignore all layers.
630			layers = []
631			else:
632			layers = self.map.Layers()
633
634	bh	6	for layer_index in range(len(layers) - 1, -1, -1):
635			layer = layers[layer_index]
636
637			# search only in visible layers
638			if not layer.Visible():
639			continue
640
641			filled = layer.fill is not None
642			stroked = layer.stroke is not None
643
644			layer_proj = layer.projection
645			if layer_proj is not None:
646			inverse = layer_proj.Inverse
647			else:
648			inverse = None
649
650			shapetype = layer.ShapeType()
651
652			select_shape = -1
653			if shapetype == SHAPETYPE_POLYGON:
654	bh	60	for i in range(layer.NumShapes() - 1, -1, -1):
655	bh	6	result = point_in_polygon_shape(layer.shapefile.cobject(),
656			i,
657			filled, stroked,
658			map_proj, layer_proj,
659			scale, -scale, offx, offy,
660			px, py)
661			if result:
662			select_shape = i
663			break
664			elif shapetype == SHAPETYPE_ARC:
665	bh	60	for i in range(layer.NumShapes() - 1, -1, -1):
666	bh	6	result = point_in_polygon_shape(layer.shapefile.cobject(),
667			i, 0, 1,
668			map_proj, layer_proj,
669			scale, -scale, offx, offy,
670			px, py)
671			if result < 0:
672			select_shape = i
673			break
674			elif shapetype == SHAPETYPE_POINT:
675	bh	60	for i in range(layer.NumShapes() - 1, -1, -1):
676	bh	6	shape = layer.Shape(i)
677			x, y = shape.Points()[0]
678			if inverse:
679			x, y = inverse(x, y)
680			if forward:
681			x, y = forward(x, y)
682			x = x * scale + offx
683			y = -y * scale + offy
684			if hypot(px - x, py - y) < 5:
685			select_shape = i
686			break
687
688			if select_shape >= 0:
689			return layer, select_shape
690			return None, None
691
692			def SelectShapeAt(self, x, y):
693	bh	78	layer, shape = self.find_shape_at(x, y, selected_layer = 0)
694	bh	43	# If layer is None, then shape will also be None. We don't want
695			# to deselect the currently selected layer, so we simply select
696			# the already selected layer again.
697			if layer is None:
698			layer = self.interactor.SelectedLayer()
699	bh	6	self.interactor.SelectLayerAndShape(layer, shape)
700
701			def LabelShapeAt(self, x, y):
702			ox = x; oy = y
703			label_layer = self.map.LabelLayer()
704			layer, shape_index = self.find_shape_at(x, y, select_labels = 1)
705			if layer is None and shape_index is not None:
706			# a label was selected
707			label_layer.RemoveLabel(shape_index)
708			elif layer is not None:
709			text = labeldialog.run_label_dialog(self, layer.table, shape_index)
710			if text:
711			proj = self.map.projection
712			if proj is not None:
713			map_proj = proj
714			else:
715			map_proj = None
716			proj = layer.projection
717			if proj is not None:
718			layer_proj = proj
719			else:
720			layer_proj = None
721
722			shapetype = layer.ShapeType()
723			if shapetype == SHAPETYPE_POLYGON:
724			x, y = shape_centroid(layer.shapefile.cobject(),
725			shape_index,
726			map_proj, layer_proj, 1, 1, 0, 0)
727			if map_proj is not None:
728			x, y = map_proj.Inverse(x, y)
729			else:
730			shape = layer.Shape(shape_index)
731			if shapetype == SHAPETYPE_POINT:
732			x, y = shape.Points()[0]
733			else:
734			# assume SHAPETYPE_ARC
735			points = shape.Points()
736			x, y = points[len(points) / 2]
737			if layer_proj is not None:
738			x, y = layer_proj.Inverse(x, y)
739			if shapetype == SHAPETYPE_POINT:
740			halign = ALIGN_LEFT
741			valign = ALIGN_CENTER
742			elif shapetype == SHAPETYPE_POLYGON:
743			halign = ALIGN_CENTER
744			valign = ALIGN_CENTER
745			elif shapetype == SHAPETYPE_ARC:
746			halign = ALIGN_LEFT
747			valign = ALIGN_CENTER
748			label_layer.AddLabel(x, y, text,
749			halign = halign, valign = valign)
Name	Value
svn:eol-style	native
svn:keywords	Author Date Id Revision