Thuban/UI/viewport.py

# Copyright (c) 2001, 2002, 2003 by Intevation GmbH
# Authors:
# Bernhard Herzog <[email protected]>
# Frank Koormann <[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 wxproj import point_in_polygon_shape, shape_centroid

from Thuban.Model.messages import MAP_PROJECTION_CHANGED, \
     LAYER_PROJECTION_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 Thuban.Model.color import Transparent

from selection import Selection

from messages import LAYER_SELECTED, SHAPES_SELECTED, VIEW_POSITION, \
                     SCALE_CHANGED, MAP_REPLACED

#
#   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 __del__(self):
        del self.view

    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_stop(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 or sy == cy:
                # Just a mouse click or a degenerate rectangle. Simply
                # zoom in by a factor of two
                # FIXME: For a click this is the desired behavior but should we
                # really do this for degenrate rectagles as well or
                # should we ignore them?
                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 or sy == cy:
                # Just a mouse click or a degenerate rectangle. Simply
                # zoom out by a factor of two.
                # FIXME: For a click this is the desired behavior but should we
                # really do this for degenrate rectagles as well or
                # should we ignore them?
                self.view.ZoomFactor(0.5, center = (cx, 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:
            Tool.MouseMove(self, event)

    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 ViewPort(Publisher):

    """An abstract view of the main window"""

    # Some messages that can be subscribed/unsubscribed directly through
    # the MapCanvas come in fact from other objects. This is a dict
    # mapping those messages to the names of the instance variables they
    # actually come from. The delegation is implemented in the Subscribe
    # and Unsubscribe methods
    delegated_messages = {LAYER_SELECTED: "selection",
                          SHAPES_SELECTED: "selection"}

    # Methods delegated to some instance variables. The delegation is
    # implemented in the __getattr__ method.
    delegated_methods = {"SelectLayer": "selection",
                         "SelectShapes": "selection",
                         "SelectedLayer": "selection",
                         "HasSelectedLayer": "selection",
                         "HasSelectedShapes": "selection",
                         "SelectedShapes": "selection"}

    def __init__(self, size = (400, 300)):

        self.size = size

        # 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

        # the selection
        self.selection = Selection()
        self.selection.Subscribe(SHAPES_SELECTED, self.shape_selected)

        # keep track of which layers/shapes are selected to make sure we
        # only redraw when necessary
        self.last_selected_layer = None
        self.last_selected_shape = None

    def Destroy(self):
        self.map = None
        self.selection.Destroy()
        self.tool = None
        #self.selection.Unsubscribe(SHAPES_SELECTED, self.shape_selected)

    def Subscribe(self, channel, *args):
        """Extend the inherited method to handle delegated messages.

        If channel is one of the delegated messages call the appropriate
        object's Subscribe method. Otherwise just call the inherited
        method.
        """
        if channel in self.delegated_messages:
            object = getattr(self, self.delegated_messages[channel])
            object.Subscribe(channel, *args)
        else:
            Publisher.Subscribe(self, channel, *args)

    def Unsubscribe(self, channel, *args):
        """Extend the inherited method to handle delegated messages.

        If channel is one of the delegated messages call the appropriate
        object's Unsubscribe method. Otherwise just call the inherited
        method.
        """
        if channel in self.delegated_messages:
            object = getattr(self, self.delegated_messages[channel])
            object.Unsubscribe(channel, *args)
        else:
            Publisher.Unsubscribe(self, channel, *args)

    def __getattr__(self, attr):
        if attr in self.delegated_methods:
            return getattr(getattr(self, self.delegated_methods[attr]), attr)
        raise AttributeError(attr)

    def SetMap(self, map):
        if self.map is not None:
            self.map.Unsubscribe(MAP_PROJECTION_CHANGED,
                                 self.map_projection_changed)
            self.map.Unsubscribe(LAYER_PROJECTION_CHANGED,
                                 self.layer_projection_changed)
        changed = self.map is not map
        self.map = map
        self.selection.ClearSelection()
        if self.map is not None:
            self.map.Subscribe(MAP_PROJECTION_CHANGED,
                               self.map_projection_changed)
            self.map.Subscribe(LAYER_PROJECTION_CHANGED,
                               self.layer_projection_changed)
        self.FitMapToWindow()
        self.issue(MAP_REPLACED)

    def Map(self):
        """Return the map displayed by this canvas"""
        return self.map

    def map_projection_changed(self, map, old_proj):

        proj = self.map.GetProjection()

        bbox = None

        if old_proj is not None and proj is not None:
            width, height = self.GetPortSizeTuple()
            llx, lly = self.win_to_proj(0, height)
            urx, ury = self.win_to_proj(width, 0)
            bbox = old_proj.Inverse(llx, lly) + old_proj.Inverse(urx, ury)
            bbox = proj.ForwardBBox(bbox)

        if bbox is not None:
            self.FitRectToWindow(bbox)
        else:
            self.FitMapToWindow()

    def layer_projection_changed(self, *args):
        pass

    def calc_min_max_scales(self, scale = None):

        if scale is None:
            scale = self.scale

        llx, lly, urx, ury = bbox = self.map.ProjectedBoundingBox()
        pwidth = float(urx - llx)
        pheight = float(ury - lly)

        # width/height of the window
        wwidth, wheight = self.GetPortSizeTuple()

        # The window coordinates used when drawing the shapes must fit
        # into 16bit signed integers.
        max_len = max(pwidth, pheight)
        if max_len:
            max_scale = 32767.0 / max_len
        else:
            # FIXME: What to do in this case? The bbox is effectively
            # empty so any scale should work.
            max_scale = scale

        # The minimal scale is somewhat arbitrarily set to half that of
        # the bbox fit into the window
        scales = []
        if pwidth:
            scales.append(wwidth / pwidth)
        if pheight:
            scales.append(wheight / pheight)
        if scales:
            min_scale = 0.5 * min(scales)
        else:
            min_scale = scale

        return min_scale, max_scale

    def set_view_transform(self, scale, offset):
        # width/height of the window
        wwidth, wheight = self.GetPortSizeTuple()

        # The window's center in projected coordinates assuming the new
        # scale/offset
        pcenterx = (wwidth/2 - offset[0]) / scale
        pcentery = (offset[1] - wheight/2) / scale

        min_scale, max_scale = self.calc_min_max_scales(scale)

        if scale > max_scale:
            scale = max_scale
        elif scale < min_scale:
            scale = min_scale

        self.scale = scale

        # determine new offset to preserve the center
        self.offset = (wwidth/2 - scale * pcenterx,
                       wheight/2 + scale * pcentery)
        self.issue(SCALE_CHANGED, scale)

    def GetPortSizeTuple(self):
        return self.size

    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):
        """Fit the rectangular region given by rect into the window.

        Set scale so that rect (in projected coordinates) just fits into
        the window and center it.
        """
        width, height = self.GetPortSizeTuple()
        llx, lly, urx, ury = rect
        if llx == urx or lly == ury:
            # zero width 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):
        """Fit the map to the window

        Set the scale so that the map fits exactly into the window and
        center it in the window.
        """
        if self.map is not None:
            bbox = self.map.ProjectedBoundingBox()
            if bbox is not None:
                self.FitRectToWindow(bbox)

    def FitLayerToWindow(self, layer):
        """Fit the given layer to the window.

        Set the scale so that the layer fits exactly into the window and
        center it in the window.
        """
        
        bbox = layer.LatLongBoundingBox()
        if bbox is not None:
            proj = self.map.GetProjection()
            if proj is not None:
                bbox = proj.ForwardBBox(bbox)

            if bbox is not None:
                self.FitRectToWindow(bbox)

    def FitSelectedToWindow(self):
        layer = self.selection.SelectedLayer()
        shapes = self.selection.SelectedShapes()

        bbox = layer.ShapesBoundingBox(shapes)
        if bbox is not None:
            proj = self.map.GetProjection()
            if proj is not None:
                bbox = proj.ForwardBBox(bbox)

            if bbox is not None:
                if len(shapes) == 1 and layer.ShapeType() == SHAPETYPE_POINT:
                    self.ZoomFactor(self.calc_min_max_scales()[1] / self.scale, 
                                    self.proj_to_win(bbox[0], bbox[1]))
                else:
                    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.GetPortSizeTuple()
        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):
        """Zoom out to fit the currently visible region into rect.

        The rect parameter is given in window coordinates
        """
        # determine the bbox of the displayed region in projected
        # coordinates
        width, height = self.GetPortSizeTuple()
        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):
        """Move the map by dx, dy pixels"""
        offx, offy = self.offset
        self.set_view_transform(self.scale, (offx + dx, offy + dy))

    def SelectTool(self, tool):
        """Make tool the active tool.

        The parameter should be an instance of Tool or None to indicate
        that no tool is active.
        """
        self.tool = tool

    def ZoomInTool(self):
        """Start the zoom in tool"""
        self.SelectTool(ZoomInTool(self))

    def ZoomOutTool(self):
        """Start the zoom out tool"""
        self.SelectTool(ZoomOutTool(self))

    def PanTool(self):
        """Start the pan tool"""
        self.SelectTool(PanTool(self))

    def IdentifyTool(self):
        """Start the identify tool"""
        self.SelectTool(IdentifyTool(self))

    def LabelTool(self):
        """Start the label tool"""
        self.SelectTool(LabelTool(self))

    def CurrentTool(self):
        """Return the name of the current tool or None if no tool is active"""
        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 parameter 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 MouseLeftDown(self, event):
        self.set_current_position(event)
        if self.tool is not None:
            self.tool.MouseDown(event)

    def MouseLeftUp(self, event):
        self.set_current_position(event)
        if self.tool is not None:
            self.tool.MouseUp(event)

    def MouseMove(self, event):
        self.set_current_position(event)
        if self.tool is not None:
            self.tool.MouseMove(event)

    def shape_selected(self, layer, shape):
        """Receiver for the SHAPES_SELECTED messages. Redraw the map."""
        # The selection object takes care that it only issues
        # SHAPES_SELECTED messages when the set of selected shapes has
        # actually changed, so we can do a full redraw unconditionally.
        # FIXME: We should perhaps try to limit the redraw to the are
        # actually covered by the shapes before and after the selection
        # change.
        pass

    def unprojected_rect_around_point(self, x, y, dist):
        """Return a rect dist pixels around (x, y) in unprojected coordinates

        The return value is a tuple (minx, miny, maxx, maxy) suitable a
        parameter to a layer's ShapesInRegion method.
        """
        map_proj = self.map.projection
        if map_proj is not None:
            inverse = map_proj.Inverse
        else:
            inverse = None

        xs = []
        ys = []
        for dx, dy in ((-1, -1), (1, -1), (1, 1), (-1, 1)):
            px, py = self.win_to_proj(x + dist * dx, y + dist * dy)
            if inverse:
                px, py = inverse(px, py)
            xs.append(px)
            ys.append(py)
        return (min(xs), min(ys), max(xs), max(ys))

    def GetTextExtent(self, text):
        # arbitrary numbers, really just so the tests pass
        return 40, 20

    def find_shape_at(self, px, py, select_labels = 0, searched_layer = None):
        """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 searched_layer is given (or not None
        which it defaults to), only search in that 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:
                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 = self.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 searched_layer:
            layers = [searched_layer]
        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() or not layer.HasShapes():
                continue

            table = layer.ShapeStore().Table()
            lc = layer.GetClassification()
            field = layer.GetClassificationColumn()

            # defaults to fall back on
            filled = lc.GetDefaultFill() is not Transparent
            stroked = lc.GetDefaultLineColor() is not Transparent

            layer_proj = layer.projection
            if layer_proj is not None:
                inverse = layer_proj.Inverse
            else:
                inverse = None

            shapetype = layer.ShapeType()

            select_shape = -1

            # Determine the ids of the shapes that overlap a tiny area
            # around the point. For layers containing points we have to
            # choose a larger size of the box we're testing agains so
            # that we take the size of the markers into account
            # FIXME: Once the markers are more flexible this part has to
            # become more flexible too, of course
            if shapetype == SHAPETYPE_POINT:
                box = self.unprojected_rect_around_point(px, py, 5)
            else:
                box = self.unprojected_rect_around_point(px, py, 1)
            shape_ids = layer.ShapesInRegion(box)
            shape_ids.reverse()

            if shapetype == SHAPETYPE_POLYGON:
                for i in shape_ids:
                    shapefile = layer.ShapeStore().Shapefile().cobject()
                    if field:
                        record = table.ReadRowAsDict(i)
                        group = lc.FindGroup(record[field])
                        props = group.GetProperties()
                        filled = props.GetFill() is not Transparent
                        stroked = props.GetLineColor() is not Transparent
                    result = point_in_polygon_shape(shapefile, 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 shape_ids:
                    shapefile = layer.ShapeStore().Shapefile().cobject()
                    if field:
                        record = table.ReadRowAsDict(i)
                        group = lc.FindGroup(record[field])
                        props = group.GetProperties()
                        stroked = props.GetLineColor() is not Transparent
                    result = point_in_polygon_shape(shapefile,
                                                    i, 0, stroked,
                                                    map_proj, layer_proj,
                                                    scale, -scale, offx, offy,
                                                    px, py)
                    if result < 0:
                        select_shape = i
                        break
            elif shapetype == SHAPETYPE_POINT:
                for i in shape_ids:
                    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 field:
                        record = table.ReadRowAsDict(i)
                        group = lc.FindGroup(record[field])
                        props = group.GetProperties()
                        filled = props.GetFill() is not Transparent
                        stroked = props.GetLineColor() is not Transparent

                    if hypot(px - x, py - y) < 5 and (filled or stroked):
                        select_shape = i
                        break

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

    def SelectShapeAt(self, x, y, layer = None):
        """\
        Select and return the shape and its layer at window position (x, y)

        If layer is given, only search in that layer. If no layer is
        given, search through all layers.

        Return a tuple (layer, shapeid). If no shape is found, return
        (None, None).
        """
        layer, shape = result = self.find_shape_at(x, y, searched_layer=layer)
        # 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.selection.SelectedLayer()
            shapes = []
        else:
            shapes = [shape]
        self.selection.SelectShapes(layer, shapes)
        return result

    def LabelShapeAt(self, x, y, text = None):
        """Add or remove a label at window position x, y.

        If there's a label at the given position, remove it. Otherwise
        determine the shape at the position and add a label.

        Return True is an action was performed, False otherwise.
        """
        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)
            return True
        elif layer is not None and 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:
                shapefile = layer.ShapeStore().Shapefile().cobject()
                x, y = shape_centroid(shapefile, 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)
            return True
        return False

def output_transform(canvas_scale, canvas_offset, canvas_size, device_extend):
    """Calculate dimensions to transform canvas content to output device."""
    width, height = device_extend

    # Only 80 % of the with are available for the map
    width = width * 0.8

    # Define the distance of the map from DC border
    distance = 20

    if height < width:
        # landscape
        map_height = height - 2*distance
        map_width = map_height
    else:
        # portrait, recalibrate width (usually the legend width is too
        # small
        width = width * 0.9
        map_height = width - 2*distance
        map_width = map_height
    
    mapregion = (distance, distance, 
                 distance+map_width, distance+map_height)

    canvas_width, canvas_height = canvas_size
    
    scalex = map_width / (canvas_width/canvas_scale)
    scaley = map_height / (canvas_height/canvas_scale)
    scale = min(scalex, scaley)
    canvas_offx, canvas_offy = canvas_offset
    offx = scale*canvas_offx/canvas_scale
    offy = scale*canvas_offy/canvas_scale

    return scale, (offx, offy), mapregion
Name	Value
svn:eol-style	native
svn:keywords	Author Date Id Revision