Thuban/UI/renderer.py

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

from __future__ import generators

__version__ = "$Revision$"
# $Source$
# $Id$

import cStringIO

from Thuban import _

from wxPython.wx import wxPoint, wxRect, wxPen, wxBrush, wxFont, \
    wxTRANSPARENT_PEN, wxTRANSPARENT_BRUSH, \
    wxBLACK_PEN, wxBLACK, wxSOLID, wxCROSS_HATCH, wxSWISS, wxNORMAL, \
    wxBitmapFromImage, wxImageFromStream, wxBITMAP_TYPE_BMP, wxBITMAP_TYPE_JPEG

from wxproj import draw_polygon_shape, draw_polygon_init

from Thuban.UI.common import Color2wxColour
from Thuban.UI.classifier import ClassDataPreviewer
from Thuban.UI.scalebar import ScaleBar

from Thuban.Model.data import SHAPETYPE_POLYGON, SHAPETYPE_ARC, \
     SHAPETYPE_POINT, RAW_SHAPEFILE

from Thuban.Model.color import Transparent
import Thuban.Model.resource

from baserenderer import BaseRenderer


# Map the strings used for the format parameter of the draw_raster_data
# method to the appropriate wxWindows constants
raster_format_map = {
    "BMP": wxBITMAP_TYPE_BMP,
    "JPEG": wxBITMAP_TYPE_JPEG,
    }

class MapRenderer(BaseRenderer):

    """Class to render a map onto a wxDC"""

    TRANSPARENT_PEN = wxTRANSPARENT_PEN
    TRANSPARENT_BRUSH = wxTRANSPARENT_BRUSH

    make_point = wxPoint

    def tools_for_property(self, prop):
        fill = prop.GetFill()
        if fill is Transparent:
            brush = self.TRANSPARENT_BRUSH
        else:
            brush = wxBrush(Color2wxColour(fill), wxSOLID)

        stroke = prop.GetLineColor()
        if stroke is Transparent:
            pen = self.TRANSPARENT_PEN
        else:
            pen = wxPen(Color2wxColour(stroke), prop.GetLineWidth(), wxSOLID)
        return pen, brush

    def low_level_renderer(self, layer):
        """Override inherited method to provide more efficient renderers

        If the underlying data format is not a shapefile or the layer
        contains points shapes, simply use what the inherited method
        returns.

        Otherwise, i.e. for arc and polygon use the more efficient
        wxproj.draw_polygon_shape and its corresponding parameter
        created with wxproj.draw_polygon_init.
        """
        if (layer.ShapeStore().RawShapeFormat() == RAW_SHAPEFILE
            and layer.ShapeType() in (SHAPETYPE_ARC, SHAPETYPE_POLYGON)):
            offx, offy = self.offset
            return (True, draw_polygon_shape,
                    draw_polygon_init(layer.ShapeStore().Shapefile(),
                                      self.dc, self.map.projection,
                                      layer.projection,
                                      self.scale, -self.scale, offx, offy))
        else:
            return BaseRenderer.low_level_renderer(self, layer)

    def label_font(self):
        return wxFont(self.resolution * 10, wxSWISS, wxNORMAL, wxNORMAL)

    def draw_raster_data(self, data, format = 'BMP'):
        stream = cStringIO.StringIO(data)
        image = wxImageFromStream(stream, raster_format_map[format])
        bitmap = wxBitmapFromImage(image)
        self.dc.DrawBitmap(bitmap, 0, 0)


class ScreenRenderer(MapRenderer):

    # On the screen we want to see only visible layers by default
    honor_visibility = 1

    def RenderMap(self, selected_layer, selected_shapes):
        """Render the map.

        Only the given region (a tuple in window coordinates as returned
        by a wxrect's asTuple method) needs to be redrawn. Highlight the
        shapes given by the ids in selected_shapes in the
        selected_layer.
        """
        self.selected_layer = selected_layer
        self.selected_shapes = selected_shapes
        self.render_map()

    def RenderMapIncrementally(self):
        """Render the map.

        Only the given region (a tuple in window coordinates as returned
        by a wxrect's asTuple method) needs to be redrawn. Highlight the
        shapes given by the ids in selected_shapes in the
        selected_layer.
        """
        return self.render_map_incrementally()

    def draw_selection_incrementally(self, layer, selected_shapes):
        pen = wxPen(wxBLACK, 3, wxSOLID)
        brush = wxBrush(wxBLACK, wxCROSS_HATCH)

        shapetype = layer.ShapeType()
        useraw, func, param = self.low_level_renderer(layer)
        args = (pen, brush)
        count = 0
        for index in selected_shapes:
            count += 1
            shape = layer.Shape(index)
            if useraw:
                data = shape.RawData()
            else:
                data = shape.Points()
            func(param, data, *args)
            if count % 500 == 0:
                yield True

    def layer_shapes(self, layer):
        """Return the shapeids covered by the region that has to be redrawn

        Call the layer's ShapesInRegion method to determine the ids so
        that it can use the quadtree.
        """
        # FIXME: the quad-tree should be built from the projected
        # coordinates not the lat-long ones because it's not trivial to
        # determine an appropriate rectangle in lat-long for a given
        # rectangle in projected coordinates which we have to start from
        # here.
        proj = self.map.projection
        if proj is not None:
            inverse = proj.Inverse
        else:
            inverse = None

        scale = self.scale
        offx, offy = self.offset
        xs = []
        ys = []
        x, y, width, height = self.region
        for winx, winy in ((x, y), (x + width, y),
                           (x + width, y + height), (x, y + height)):
            px = (winx - offx) / scale
            py = -(winy - offy) / scale
            if inverse:
                px, py = inverse(px, py)
            xs.append(px)
            ys.append(py)
        left = min(xs)
        right = max(xs)
        top = max(ys)
        bottom = min(ys)

        return layer.ShapesInRegion((left, bottom, right, top))


class ExportRenderer(ScreenRenderer):

    honor_visibility = 1

    def __init__(self, *args, **kw):
        """Initialize the ExportRenderer.

        In addition to all parameters of the the ScreenRender
        constructor, this class requires and additional keyword argument
        destination_region with a tuple (minx, miny, maxx, maxy) giving
        the region in dc coordinates which is to contain the map.
        """
        self.destination_region = kw["destination_region"]
        del kw["destination_region"]
        ScreenRenderer.__init__(self, *args, **kw)

    def RenderMap(self, selected_layer, selected_shapes):
        """Render the map.

        The rendering device has been specified during initialisation.
        The device border distance was set in
        Thuban.UI.viewport.output_transform().

        RenderMap renders a frame set (one page frame, one around
        legend/scalebar and one around the map), the map, the legend and
        the scalebar on the given DC. The map is rendered with the
        region displayed in the canvas view, centered on the area
        available for map display.
        """

        self.selected_layer = selected_layer
        self.selected_shapes = selected_shapes

        # Get some dimensions
        llx, lly, urx, ury = self.region
        mminx, mminy, mmaxx, mmaxy = self.destination_region

        # Manipulate the offset to position the map
        offx, offy = self.offset
        # 1. Shift to corner of map drawing area
        offx = offx + mminx
        offy = offy + mminy

        # 2. Center the map on the map drawing area:
        # region identifies the region on the canvas view:
        # center of map drawing area - half the size of region: rendering origin
        self.shiftx = (mmaxx - mminx)*0.5 - (urx - llx)*0.5
        self.shifty = (mmaxy - mminy)*0.5 - (ury - lly)*0.5

        self.offset = (offx+self.shiftx, offy+self.shifty)

        # Draw the map
        self.dc.BeginDrawing()
        self.dc.DestroyClippingRegion()
        self.dc.SetClippingRegion(mminx+self.shiftx, mminy+self.shifty,
                                  urx, ury)
        self.render_map()
        self.dc.EndDrawing()

        # Draw the rest (frames, legend, scalebar)
        self.dc.BeginDrawing()
        self.dc.DestroyClippingRegion()

        # Force the font for Legend drawing
        font = wxFont(self.resolution * 10, wxSWISS, wxNORMAL, wxNORMAL)
        self.dc.SetFont(font)

        self.render_frame()
        self.render_legend()
        self.render_scalebar()
        self.dc.EndDrawing()

    def render_frame(self):
        """Render the frames for map and legend/scalebar."""

        dc = self.dc
        dc.SetPen(wxBLACK_PEN)
        dc.SetBrush(wxTRANSPARENT_BRUSH)

        # Dimension stuff
        width, height = dc.GetSizeTuple()
        mminx, mminy, mmaxx, mmaxy = self.destination_region

        # Page Frame
        dc.DrawRectangle(15,15,width-30, (mmaxy-mminy)+10)

        # Map Frame
        llx, lly, urx, ury = self.region
        dc.DrawRectangle(mminx + self.shiftx, mminy + self.shifty, urx, ury)

        # Legend Frame
        dc.DrawRectangle(mmaxx+10,mminy,(width-20) - (mmaxx+10), mmaxy-mminy)

        dc.DestroyClippingRegion()
        dc.SetClippingRegion(mmaxx+10,mminy,
                             (width-20) - (mmaxx+10), mmaxy-mminy)

    def render_legend(self):
        """Render the legend on the Map."""

        previewer = ClassDataPreviewer()
        dc = self.dc
        dc.SetPen(wxBLACK_PEN)
        dc.SetBrush(wxTRANSPARENT_BRUSH)

        # Dimension stuff
        width, height = dc.GetSizeTuple()
        mminx, mminy, mmaxx, mmaxy = self.destination_region
        textwidth, textheight = dc.GetTextExtent("0")
        iconwidth  = textheight
        iconheight = textheight
        stepy = textheight+3
        dx = 10
        posx = mmaxx + 10 + 5   # 10 pix distance mapframe/legend frame,
                                # 5 pix inside legend frame
        posy = mminy + 5        # 5 pix inside legend frame

        # Render the legend
        dc.SetTextForeground(wxBLACK)
        if self.map.HasLayers():
            layers = self.map.Layers()[:]
            layers.reverse()
            for l in layers:
                if l.Visible():
                    # Render title
                    dc.DrawText(l.Title(), posx, posy)
                    posy+=stepy
                    if l.HasClassification():
                        # Render classification
                        clazz = l.GetClassification()
                        shapeType = l.ShapeType()
                        for g in clazz:
                            if g.IsVisible():
                                previewer.Draw(dc,
                                    wxRect(posx+dx, posy,
                                           iconwidth, iconheight),
                                    g.GetProperties(), shapeType)
                                dc.DrawText(g.GetDisplayText(),
                                            posx+2*dx+iconwidth, posy)
                                posy+=stepy

    def render_scalebar(self):
        """Render the scalebar."""

        scalebar = ScaleBar(self.map)

        # Dimension stuff
        width, height = self.dc.GetSizeTuple()
        mminx, mminy, mmaxx, mmaxy = self.destination_region

        # Render the scalebar
        scalebar.DrawScaleBar(self.scale, self.dc,
                             (mmaxx+10+5, mmaxy-25),
                             ((width-15-5) - (mmaxx+10+5),20)
                            )
        # 10 pix between map and legend frame, 5 pix inside legend frame
        # 25 pix from the legend frame bottom line
        # Width: 15 pix from DC border, 5 pix inside frame, 10, 5 as above
        # Height: 20

class PrinterRenderer(ExportRenderer):

    # Printing as well as Export / Screen display only the visible layer.
    honor_visibility = 1

1	bh	424	# Copyright (c) 2001, 2002, 2003 by Intevation GmbH
2	bh	6	# Authors:
3			# Bernhard Herzog <[email protected]>
4	jonathan	416	# Jonathan Coles <[email protected]>
5	frank	909	# Frank Koormann <[email protected]>
6	bh	6	#
7			# This program is free software under the GPL (>=v2)
8			# Read the file COPYING coming with Thuban for details.
9
10	bh	1866	from __future__ import generators
11
12	bh	6	__version__ = "$Revision$"
13	bh	1866	# $Source$
14			# $Id$
15	bh	6
16	jonathan	938	import cStringIO
17
18	jonathan	882	from Thuban import _
19
20	bh	1552	from wxPython.wx import wxPoint, wxRect, wxPen, wxBrush, wxFont, \
21	frank	909	wxTRANSPARENT_PEN, wxTRANSPARENT_BRUSH, \
22	bh	1552	wxBLACK_PEN, wxBLACK, wxSOLID, wxCROSS_HATCH, wxSWISS, wxNORMAL, \
23	bh	1927	wxBitmapFromImage, wxImageFromStream, wxBITMAP_TYPE_BMP, wxBITMAP_TYPE_JPEG
24	bh	6
25	jonathan	676	from wxproj import draw_polygon_shape, draw_polygon_init
26	bh	6
27	jonathan	882	from Thuban.UI.common import Color2wxColour
28	frank	909	from Thuban.UI.classifier import ClassDataPreviewer
29			from Thuban.UI.scalebar import ScaleBar
30	jan	374
31	bh	1562	from Thuban.Model.data import SHAPETYPE_POLYGON, SHAPETYPE_ARC, \
32			SHAPETYPE_POINT, RAW_SHAPEFILE
33	bh	6
34	jonathan	1343	from Thuban.Model.color import Transparent
35	jonathan	1165	import Thuban.Model.resource
36	bh	6
37	bh	1552	from baserenderer import BaseRenderer
38	jonathan	1234
39	bh	1927
40			# Map the strings used for the format parameter of the draw_raster_data
41			# method to the appropriate wxWindows constants
42			raster_format_map = {
43			"BMP": wxBITMAP_TYPE_BMP,
44			"JPEG": wxBITMAP_TYPE_JPEG,
45			}
46
47	bh	1552	class MapRenderer(BaseRenderer):
48	bh	6
49			"""Class to render a map onto a wxDC"""
50
51	bh	1552	TRANSPARENT_PEN = wxTRANSPARENT_PEN
52			TRANSPARENT_BRUSH = wxTRANSPARENT_BRUSH
53	bh	6
54	bh	1552	make_point = wxPoint
55	bh	6
56	bh	1552	def tools_for_property(self, prop):
57			fill = prop.GetFill()
58			if fill is Transparent:
59			brush = self.TRANSPARENT_BRUSH
60	jonathan	798	else:
61	bh	1552	brush = wxBrush(Color2wxColour(fill), wxSOLID)
62	bh	1219
63	bh	1552	stroke = prop.GetLineColor()
64			if stroke is Transparent:
65			pen = self.TRANSPARENT_PEN
66	jonathan	938	else:
67	bh	1552	pen = wxPen(Color2wxColour(stroke), prop.GetLineWidth(), wxSOLID)
68			return pen, brush
69	jonathan	938
70	bh	1552	def low_level_renderer(self, layer):
71			"""Override inherited method to provide more efficient renderers
72	bh	686
73	bh	1562	If the underlying data format is not a shapefile or the layer
74			contains points shapes, simply use what the inherited method
75			returns.
76
77			Otherwise, i.e. for arc and polygon use the more efficient
78			wxproj.draw_polygon_shape and its corresponding parameter
79			created with wxproj.draw_polygon_init.
80	bh	144	"""
81	bh	1562	if (layer.ShapeStore().RawShapeFormat() == RAW_SHAPEFILE
82			and layer.ShapeType() in (SHAPETYPE_ARC, SHAPETYPE_POLYGON)):
83	bh	1552	offx, offy = self.offset
84	bh	1591	return (True, draw_polygon_shape,
85	bh	1562	draw_polygon_init(layer.ShapeStore().Shapefile(),
86			self.dc, self.map.projection,
87	bh	1552	layer.projection,
88	bh	1562	self.scale, -self.scale, offx, offy))
89			else:
90			return BaseRenderer.low_level_renderer(self, layer)
91	bh	6
92	bh	1552	def label_font(self):
93			return wxFont(self.resolution * 10, wxSWISS, wxNORMAL, wxNORMAL)
94	bh	6
95	bh	1927	def draw_raster_data(self, data, format = 'BMP'):
96	bh	1552	stream = cStringIO.StringIO(data)
97	bh	1927	image = wxImageFromStream(stream, raster_format_map[format])
98	bh	1552	bitmap = wxBitmapFromImage(image)
99			self.dc.DrawBitmap(bitmap, 0, 0)
100	jonathan	588
101
102	bh	6	class ScreenRenderer(MapRenderer):
103
104			# On the screen we want to see only visible layers by default
105			honor_visibility = 1
106	bh	1552
107	bh	1866	def RenderMap(self, selected_layer, selected_shapes):
108	bh	144	"""Render the map.
109
110	bh	148	Only the given region (a tuple in window coordinates as returned
111			by a wxrect's asTuple method) needs to be redrawn. Highlight the
112	bh	535	shapes given by the ids in selected_shapes in the
113			selected_layer.
114	bh	144	"""
115	bh	6	self.selected_layer = selected_layer
116	bh	535	self.selected_shapes = selected_shapes
117	bh	1866	self.render_map()
118	bh	6
119	bh	1866	def RenderMapIncrementally(self):
120			"""Render the map.
121	bh	535
122	bh	1866	Only the given region (a tuple in window coordinates as returned
123			by a wxrect's asTuple method) needs to be redrawn. Highlight the
124			shapes given by the ids in selected_shapes in the
125			selected_layer.
126			"""
127			return self.render_map_incrementally()
128	bh	535
129	bh	1866	def draw_selection_incrementally(self, layer, selected_shapes):
130			pen = wxPen(wxBLACK, 3, wxSOLID)
131			brush = wxBrush(wxBLACK, wxCROSS_HATCH)
132
133			shapetype = layer.ShapeType()
134			useraw, func, param = self.low_level_renderer(layer)
135			args = (pen, brush)
136			count = 0
137			for index in selected_shapes:
138			count += 1
139			shape = layer.Shape(index)
140			if useraw:
141			data = shape.RawData()
142			else:
143			data = shape.Points()
144			func(param, data, *args)
145			if count % 500 == 0:
146			yield True
147
148	bh	1593	def layer_shapes(self, layer):
149	bh	144	"""Return the shapeids covered by the region that has to be redrawn
150	bh	6
151	bh	144	Call the layer's ShapesInRegion method to determine the ids so
152			that it can use the quadtree.
153			"""
154			# FIXME: the quad-tree should be built from the projected
155			# coordinates not the lat-long ones because it's not trivial to
156			# determine an appropriate rectangle in lat-long for a given
157			# rectangle in projected coordinates which we have to start from
158			# here.
159			proj = self.map.projection
160			if proj is not None:
161			inverse = proj.Inverse
162			else:
163			inverse = None
164
165			scale = self.scale
166			offx, offy = self.offset
167			xs = []
168			ys = []
169	bh	1866	x, y, width, height = self.region
170	bh	144	for winx, winy in ((x, y), (x + width, y),
171			(x + width, y + height), (x, y + height)):
172			px = (winx - offx) / scale
173			py = -(winy - offy) / scale
174			if inverse:
175			px, py = inverse(px, py)
176			xs.append(px)
177			ys.append(py)
178			left = min(xs)
179			right = max(xs)
180			top = max(ys)
181			bottom = min(ys)
182
183			return layer.ShapesInRegion((left, bottom, right, top))
184
185
186	frank	909	class ExportRenderer(ScreenRenderer):
187	bh	6
188	frank	909	honor_visibility = 1
189	bh	1552
190	bh	1866	def __init__(self, args, *kw):
191			"""Initialize the ExportRenderer.
192
193			In addition to all parameters of the the ScreenRender
194			constructor, this class requires and additional keyword argument
195			destination_region with a tuple (minx, miny, maxx, maxy) giving
196			the region in dc coordinates which is to contain the map.
197			"""
198			self.destination_region = kw["destination_region"]
199			del kw["destination_region"]
200			ScreenRenderer.__init__(self, args, *kw)
201
202			def RenderMap(self, selected_layer, selected_shapes):
203	frank	909	"""Render the map.
204	bh	6
205	frank	909	The rendering device has been specified during initialisation.
206	bh	1866	The device border distance was set in
207			Thuban.UI.viewport.output_transform().
208	bh	1552
209	frank	909	RenderMap renders a frame set (one page frame, one around
210	bh	1866	legend/scalebar and one around the map), the map, the legend and
211			the scalebar on the given DC. The map is rendered with the
212			region displayed in the canvas view, centered on the area
213			available for map display.
214	frank	909	"""
215	bh	1552
216	frank	909	self.selected_layer = selected_layer
217			self.selected_shapes = selected_shapes
218
219	bh	1552	# Get some dimensions
220	bh	1866	llx, lly, urx, ury = self.region
221			mminx, mminy, mmaxx, mmaxy = self.destination_region
222	frank	909
223	bh	1552	# Manipulate the offset to position the map
224	frank	909	offx, offy = self.offset
225			# 1. Shift to corner of map drawing area
226	bh	1552	offx = offx + mminx
227	frank	909	offy = offy + mminy
228
229			# 2. Center the map on the map drawing area:
230	bh	1552	# region identifies the region on the canvas view:
231	frank	909	# center of map drawing area - half the size of region: rendering origin
232			self.shiftx = (mmaxx - mminx)0.5 - (urx - llx)0.5
233			self.shifty = (mmaxy - mminy)0.5 - (ury - lly)0.5
234
235			self.offset = (offx+self.shiftx, offy+self.shifty)
236
237			# Draw the map
238			self.dc.BeginDrawing()
239			self.dc.DestroyClippingRegion()
240	bh	1552	self.dc.SetClippingRegion(mminx+self.shiftx, mminy+self.shifty,
241	frank	909	urx, ury)
242	bh	1866	self.render_map()
243	frank	909	self.dc.EndDrawing()
244
245			# Draw the rest (frames, legend, scalebar)
246			self.dc.BeginDrawing()
247			self.dc.DestroyClippingRegion()
248
249			# Force the font for Legend drawing
250			font = wxFont(self.resolution * 10, wxSWISS, wxNORMAL, wxNORMAL)
251			self.dc.SetFont(font)
252
253	bh	1866	self.render_frame()
254			self.render_legend()
255			self.render_scalebar()
256	frank	909	self.dc.EndDrawing()
257
258	bh	1866	def render_frame(self):
259	frank	909	"""Render the frames for map and legend/scalebar."""
260
261			dc = self.dc
262			dc.SetPen(wxBLACK_PEN)
263			dc.SetBrush(wxTRANSPARENT_BRUSH)
264
265			# Dimension stuff
266			width, height = dc.GetSizeTuple()
267	bh	1866	mminx, mminy, mmaxx, mmaxy = self.destination_region
268	frank	909
269			# Page Frame
270			dc.DrawRectangle(15,15,width-30, (mmaxy-mminy)+10)
271	bh	1552
272	frank	909	# Map Frame
273	bh	1866	llx, lly, urx, ury = self.region
274	frank	909	dc.DrawRectangle(mminx + self.shiftx, mminy + self.shifty, urx, ury)
275	bh	1552
276	frank	909	# Legend Frame
277			dc.DrawRectangle(mmaxx+10,mminy,(width-20) - (mmaxx+10), mmaxy-mminy)
278
279			dc.DestroyClippingRegion()
280			dc.SetClippingRegion(mmaxx+10,mminy,
281			(width-20) - (mmaxx+10), mmaxy-mminy)
282
283	bh	1866	def render_legend(self):
284	frank	909	"""Render the legend on the Map."""
285
286			previewer = ClassDataPreviewer()
287			dc = self.dc
288			dc.SetPen(wxBLACK_PEN)
289			dc.SetBrush(wxTRANSPARENT_BRUSH)
290
291			# Dimension stuff
292			width, height = dc.GetSizeTuple()
293	bh	1866	mminx, mminy, mmaxx, mmaxy = self.destination_region
294	frank	909	textwidth, textheight = dc.GetTextExtent("0")
295			iconwidth = textheight
296			iconheight = textheight
297			stepy = textheight+3
298			dx = 10
299	bh	1552	posx = mmaxx + 10 + 5 # 10 pix distance mapframe/legend frame,
300	frank	909	# 5 pix inside legend frame
301			posy = mminy + 5 # 5 pix inside legend frame
302	bh	1552
303	frank	909	# Render the legend
304			dc.SetTextForeground(wxBLACK)
305	bh	1866	if self.map.HasLayers():
306			layers = self.map.Layers()[:]
307	frank	1324	layers.reverse()
308			for l in layers:
309	frank	909	if l.Visible():
310			# Render title
311			dc.DrawText(l.Title(), posx, posy)
312			posy+=stepy
313	jonathan	1298	if l.HasClassification():
314			# Render classification
315			clazz = l.GetClassification()
316			shapeType = l.ShapeType()
317			for g in clazz:
318			if g.IsVisible():
319	bh	1552	previewer.Draw(dc,
320			wxRect(posx+dx, posy,
321			iconwidth, iconheight),
322	jonathan	1298	g.GetProperties(), shapeType)
323	bh	1552	dc.DrawText(g.GetDisplayText(),
324	jonathan	1298	posx+2*dx+iconwidth, posy)
325			posy+=stepy
326	bh	1552
327	bh	1866	def render_scalebar(self):
328	frank	909	"""Render the scalebar."""
329
330	bh	1866	scalebar = ScaleBar(self.map)
331	frank	909
332			# Dimension stuff
333			width, height = self.dc.GetSizeTuple()
334	bh	1866	mminx, mminy, mmaxx, mmaxy = self.destination_region
335	bh	1552
336	frank	909	# Render the scalebar
337	bh	1552	scalebar.DrawScaleBar(self.scale, self.dc,
338	frank	909	(mmaxx+10+5, mmaxy-25),
339			((width-15-5) - (mmaxx+10+5),20)
340			)
341			# 10 pix between map and legend frame, 5 pix inside legend frame
342			# 25 pix from the legend frame bottom line
343			# Width: 15 pix from DC border, 5 pix inside frame, 10, 5 as above
344			# Height: 20
345
346			class PrinterRenderer(ExportRenderer):
347
348			# Printing as well as Export / Screen display only the visible layer.
349			honor_visibility = 1
350
Name	Value
svn:eol-style	native
svn:keywords	Author Date Id Revision