Thuban/UI/baserenderer.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.

"""Basic rendering logic for Thuban maps

The code in this module is completely independend of wx so that it can
be tested reasonably easily and it could make it easier to write non-wx
renderers.
"""

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

import traceback

from Thuban.Model.layer import Layer, RasterLayer
from Thuban.Model.data import SHAPETYPE_ARC, SHAPETYPE_POINT
from Thuban.Model.label import ALIGN_CENTER, ALIGN_TOP, ALIGN_BOTTOM, \
     ALIGN_LEFT, ALIGN_RIGHT

import Thuban.Model.resource

if Thuban.Model.resource.has_gdal_support():
    from gdalwarp import ProjectRasterFile


class BaseRenderer:

    """Basic Renderer Infrastructure for Thuban Maps

    This class can't be used directly to render because it doesn't know
    anything about real DCs such as how to create pens or brushes. That
    functionality has to be provided by derived classes. The reason for
    this is that it makes the BaseRenderer completely independend of wx
    and thus it's quite easy to write test cases for it.
    """
    # If true the render honors the visibility flag of the layers
    honor_visibility = 1

    # Transparent brushes and pens. Derived classes should define these
    # as appropriate.
    TRANSPARENT_PEN = None
    TRANSPARENT_BRUSH = None

    def __init__(self, dc, scale, offset, resolution = 72.0,
                 honor_visibility = None):
        """Inititalize the renderer.

        dc -- the device context to render on.

        scale, offset -- the scale factor and translation to convert
                between projected coordinates and the DC coordinates

        resolution -- the assumed resolution of the DC. Used to convert
                absolute lengths like font sizes to DC coordinates. The
                defauult is 72.0

        honor_visibility -- boolean. If true, honor the visibility flag
                of the layers, otherwise draw all layers. If None (the
                default), use the renderer's default.
        """
        # resolution in pixel/inch

        self.dc = dc
        self.scale = scale
        self.offset = offset
        if honor_visibility is not None:
            self.honor_visibility = honor_visibility
        # store the resolution in pixel/point because it's more useful
        # later.
        self.resolution = resolution / 72.0

    def tools_for_property(self, prop):
        """Return a suitable pen and brush for the property

        This method must be implemented in derived classes. The return
        value should be a tuple (pen, brush).
        """
        raise NotImplementedError

    def render_map(self, map):
        """Render the map onto the DC the renderer was instantiated with

        Iterate through all layers and draw them. Layers containing
        vector data are drawn with the draw_shape_layer method, raster
        layers are drawn with draw_raster_layer. The label layer is
        drawn last with draw_label_layer.

        During execution of this method, the map is bound to self.map so
        that methods especially in derived classes have access to the
        map if necessary.
        """
        # Some method have to have access to the map so we store it in
        # self.map.
        self.map = map

        # Whether the raster layer has already been drawn. See below for
        # the optimization this is used for
        seenRaster = True

        self.dc.BeginDrawing()

        try:
            #
            # This is only a good optimization if there is only one
            # raster layer and the image covers the entire window (as
            # it currently does). We note if there is a raster layer
            # and only begin drawing layers once we have drawn it.
            # That way we avoid drawing layers that won't be seen.
            #
            if Thuban.Model.resource.has_gdal_support():
                for layer in map.Layers():
                    if isinstance(layer, RasterLayer) and layer.Visible():
                        seenRaster = False
                        break

            for layer in map.Layers():
                # if honor_visibility is true, only draw visible layers,
                # otherwise draw all layers
                if not self.honor_visibility or layer.Visible():
                    if isinstance(layer, Layer) and seenRaster:
                        self.draw_shape_layer(layer)
                    elif isinstance(layer, RasterLayer) \
                        and Thuban.Model.resource.has_gdal_support():
                        self.draw_raster_layer(layer)
                        seenRaster = True

            self.draw_label_layer(map.LabelLayer())
        finally:
            self.dc.EndDrawing()

    def draw_shape_layer(self, layer):
        """Draw the shape layer layer onto the map.

        Automatically called by render_map. Iterate through all shapes
        as indicated by self.layer_shapes() and draw them, using
        low-level renderers returned by self.low_level_renderer().
        """
        scale = self.scale
        offx, offy = self.offset

        map_proj = self.map.projection
        layer_proj = layer.projection

        brush = self.TRANSPARENT_BRUSH
        pen   = self.TRANSPARENT_PEN

        old_prop = None
        old_group = None
        lc = layer.GetClassification()
        field = layer.GetClassificationColumn()
        defaultGroup = lc.GetDefaultGroup()
        table = layer.ShapeStore().Table()

        # Determine which render function to use.
        useraw, draw_func, draw_func_param = self.low_level_renderer(layer)

        # Iterate through all shapes that have to be drawn.
        for shape in self.layer_shapes(layer):

            if field is None:
                group = defaultGroup
            else:
                record = table.ReadRowAsDict(shape.ShapeID())
                assert record is not None
                group = lc.FindGroup(record[field])

            if not group.IsVisible():
                continue

            # don't recreate new objects if they are the same as before
            if group is not old_group:
                old_group = group

                prop = group.GetProperties()

                if prop != old_prop:
                    pen, brush = self.tools_for_property(prop)

            if useraw:
                data = shape.RawData()
            else:
                data = shape.Points()
            draw_func(draw_func_param, data, pen, brush)

    def layer_shapes(self, layer):
        """Return an iterable over the shapes to be drawn from the given layer.

        The default implementation simply returns all ids in the layer.
        Override in derived classes to be more precise.
        """
        return layer.ShapeStore().AllShapes()

    def low_level_renderer(self, layer):
        """Return the low-level renderer for the layer for draw_shape_layer

        The low level renderer to be returned by this method is a tuple
        (useraw, func, param) where useraw is a boolean indicating
        whether the function uses the raw shape data, func is a callable
        object and param is passed as the first parameter to func. The
        draw_shape_layer method will call func like this:

            func(param, shapedata, pen, brush)

        where shapedata is the return value of the RawData method of the
        shape object if useraw is true or the return value of the Points
        method if it's false. pen and brush are the pen and brush to use
        to draw the shape on the dc.

        The default implementation returns one of
        self.draw_polygon_shape, self.draw_arc_shape or
        self.draw_point_shape as func and layer as param. None of the
        method use the raw shape data. Derived classes can override this
        method to return more efficient low level renderers.
        """
        shapetype = layer.ShapeType()
        if shapetype == SHAPETYPE_POINT:
            func = self.draw_point_shape
        elif shapetype == SHAPETYPE_ARC:
            func = self.draw_arc_shape
        else:
            func = self.draw_polygon_shape
        return False, func, layer

    def make_point(self, x, y):
        """Convert (x, y) to a point object.

        Derived classes must override this method.
        """
        raise NotImplementedError

    def projected_points(self, layer, points):
        """Return the projected coordinates of the points taken from layer.

        Transform all the points in the list of lists of coordinate
        pairs in points.

        The transformation applies the inverse of the layer's projection
        if any, then the map's projection if any and finally applies
        self.scale and self.offset.

        The returned list has the same structure as the one returned the
        shape's Points method.
        """
        proj = self.map.GetProjection()
        if proj is not None:
            forward = proj.Forward
        else:
            forward = None
        proj = layer.GetProjection()
        if proj is not None:
            inverse = proj.Inverse
        else:
            inverse = None
        result = []
        scale = self.scale
        offx, offy = self.offset
        make_point = self.make_point
        for part in points:
            result.append([])
            for x, y in part:
                if inverse:
                    x, y = inverse(x, y)
                if forward:
                    x, y = forward(x, y)
                result[-1].append(make_point(x * scale + offx,
                                             -y * scale + offy))
        return result

    def draw_polygon_shape(self, layer, points, pen, brush):
        """Draw a polygon shape from layer with the given brush and pen

        The shape is given by points argument which is a the return
        value of the shape's Points() method. The coordinates in the
        DC's coordinate system are determined with
        self.projected_points.
        """
        points = self.projected_points(layer, points)

        if brush is not self.TRANSPARENT_BRUSH:
            polygon = []
            for part in points:
                polygon.extend(part)

            insert_index = len(polygon)
            for part in points[:-1]:
                polygon.insert(insert_index, part[0])

            self.dc.SetBrush(brush)
            self.dc.SetPen(self.TRANSPARENT_PEN)
            self.dc.DrawPolygon(polygon)

        if pen is not self.TRANSPARENT_PEN:
            # At last draw the boundarys of the simple polygons
            self.dc.SetBrush(self.TRANSPARENT_BRUSH)
            self.dc.SetPen(pen)
            for part in points:
                self.dc.DrawLines(part)

    def draw_arc_shape(self, layer, points, pen, brush):
        """Draw an arc shape from layer with the given brush and pen

        The shape is given by points argument which is a the return
        value of the shape's Points() method. The coordinates in the
        DC's coordinate system are determined with
        self.projected_points.
        """
        points = self.projected_points(layer, points)
        self.dc.SetBrush(brush)
        self.dc.SetPen(pen)
        for part in points:
            self.dc.DrawLines(part)

    def draw_point_shape(self, layer, points, pen, brush):
        """Draw a point shape from layer with the given brush and pen

        The shape is given by points argument which is a the return
        value of the shape's Points() method. The coordinates in the
        DC's coordinate system are determined with
        self.projected_points.

        The point is drawn as a circle centered on the point.
        """
        points = self.projected_points(layer, points)
        if not points:
            return

        radius = self.resolution * 5
        self.dc.SetBrush(brush)
        self.dc.SetPen(pen)
        for part in points:
            for p in part:
                self.dc.DrawEllipse(p.x - radius, p.y - radius,
                                    2 * radius, 2 * radius)

    def draw_raster_layer(self, layer):
        """Draw the raster layer

        This implementation does the projection and scaling of the data
        as required by the layer's and map's projections and the scale
        and offset of the renderer and then hands the transformed data
        to self.draw_raster_data() which has to be implemented in
        derived classes.
        """
        offx, offy = self.offset
        width, height = self.dc.GetSizeTuple()

        in_proj = ""
        proj = layer.GetProjection()
        if proj is not None:
            for p in proj.GetAllParameters():
                in_proj += "+" + p + " "

        out_proj = ""
        proj = self.map.GetProjection()
        if proj is not None:
            for p in proj.GetAllParameters():
                out_proj += "+" + p + " "

        xmin = (0 - offx) / self.scale
        ymin = (offy - height) / self.scale
        xmax = (width - offx) / self.scale
        ymax = (offy - 0) / self.scale

        try:
            data = ProjectRasterFile(layer.GetImageFilename(),
                                     in_proj, out_proj,
                                     (xmin, ymin, xmax, ymax), "",
                                     (width, height))
        except (IOError, AttributeError, ValueError):
            # Why does this catch AttributeError and ValueError?
            # FIXME: The exception should be communicated to the user
            # better.
            traceback.print_exc()
        else:
            self.draw_raster_data(data)

    def draw_raster_data(self, data):
        """Draw the raster image in data onto the DC

        The raster image data is a string holding the data in BMP
        format. The data is exactly the size of the dc and covers it
        completely.

        This method has to be implemented by derived classes.
        """
        raise NotImplementedError

    def label_font(self):
        """Return the font object for the label layer"""
        raise NotImplementedError

    def draw_label_layer(self, layer):
        """Draw the label layer

        All labels are draw in the font returned by self.label_font().
        """
        scale = self.scale
        offx, offy = self.offset

        self.dc.SetFont(self.label_font())

        map_proj = self.map.projection
        if map_proj is not None:
            forward = map_proj.Forward
        else:
            forward = None

        for label in layer.Labels():
            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.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
            self.dc.DrawText(text, x, y)
1	# Copyright (c) 2001, 2002, 2003 by Intevation GmbH
2	# Authors:
3	# Bernhard Herzog <[email protected]>
4	# Jonathan Coles <[email protected]>
5	# Frank Koormann <[email protected]>
6	#
7	# This program is free software under the GPL (>=v2)
8	# Read the file COPYING coming with Thuban for details.
9
10	"""Basic rendering logic for Thuban maps
11
12	The code in this module is completely independend of wx so that it can
13	be tested reasonably easily and it could make it easier to write non-wx
14	renderers.
15	"""
16
17	__version__ = "$Revision$"
18	# $Source$
19	# $Id$
20
21	import traceback
22
23	from Thuban.Model.layer import Layer, RasterLayer
24	from Thuban.Model.data import SHAPETYPE_ARC, SHAPETYPE_POINT
25	from Thuban.Model.label import ALIGN_CENTER, ALIGN_TOP, ALIGN_BOTTOM, \
26	ALIGN_LEFT, ALIGN_RIGHT
27
28	import Thuban.Model.resource
29
30	if Thuban.Model.resource.has_gdal_support():
31	from gdalwarp import ProjectRasterFile
32
33
34	class BaseRenderer:
35
36	"""Basic Renderer Infrastructure for Thuban Maps
37
38	This class can't be used directly to render because it doesn't know
39	anything about real DCs such as how to create pens or brushes. That
40	functionality has to be provided by derived classes. The reason for
41	this is that it makes the BaseRenderer completely independend of wx
42	and thus it's quite easy to write test cases for it.
43	"""
44	# If true the render honors the visibility flag of the layers
45	honor_visibility = 1
46
47	# Transparent brushes and pens. Derived classes should define these
48	# as appropriate.
49	TRANSPARENT_PEN = None
50	TRANSPARENT_BRUSH = None
51
52	def __init__(self, dc, scale, offset, resolution = 72.0,
53	honor_visibility = None):
54	"""Inititalize the renderer.
55
56	dc -- the device context to render on.
57
58	scale, offset -- the scale factor and translation to convert
59	between projected coordinates and the DC coordinates
60
61	resolution -- the assumed resolution of the DC. Used to convert
62	absolute lengths like font sizes to DC coordinates. The
63	defauult is 72.0
64
65	honor_visibility -- boolean. If true, honor the visibility flag
66	of the layers, otherwise draw all layers. If None (the
67	default), use the renderer's default.
68	"""
69	# resolution in pixel/inch
70
71	self.dc = dc
72	self.scale = scale
73	self.offset = offset
74	if honor_visibility is not None:
75	self.honor_visibility = honor_visibility
76	# store the resolution in pixel/point because it's more useful
77	# later.
78	self.resolution = resolution / 72.0
79
80	def tools_for_property(self, prop):
81	"""Return a suitable pen and brush for the property
82
83	This method must be implemented in derived classes. The return
84	value should be a tuple (pen, brush).
85	"""
86	raise NotImplementedError
87
88	def render_map(self, map):
89	"""Render the map onto the DC the renderer was instantiated with
90
91	Iterate through all layers and draw them. Layers containing
92	vector data are drawn with the draw_shape_layer method, raster
93	layers are drawn with draw_raster_layer. The label layer is
94	drawn last with draw_label_layer.
95
96	During execution of this method, the map is bound to self.map so
97	that methods especially in derived classes have access to the
98	map if necessary.
99	"""
100	# Some method have to have access to the map so we store it in
101	# self.map.
102	self.map = map
103
104	# Whether the raster layer has already been drawn. See below for
105	# the optimization this is used for
106	seenRaster = True
107
108	self.dc.BeginDrawing()
109
110	try:
111	#
112	# This is only a good optimization if there is only one
113	# raster layer and the image covers the entire window (as
114	# it currently does). We note if there is a raster layer
115	# and only begin drawing layers once we have drawn it.
116	# That way we avoid drawing layers that won't be seen.
117	#
118	if Thuban.Model.resource.has_gdal_support():
119	for layer in map.Layers():
120	if isinstance(layer, RasterLayer) and layer.Visible():
121	seenRaster = False
122	break
123
124	for layer in map.Layers():
125	# if honor_visibility is true, only draw visible layers,
126	# otherwise draw all layers
127	if not self.honor_visibility or layer.Visible():
128	if isinstance(layer, Layer) and seenRaster:
129	self.draw_shape_layer(layer)
130	elif isinstance(layer, RasterLayer) \
131	and Thuban.Model.resource.has_gdal_support():
132	self.draw_raster_layer(layer)
133	seenRaster = True
134
135	self.draw_label_layer(map.LabelLayer())
136	finally:
137	self.dc.EndDrawing()
138
139	def draw_shape_layer(self, layer):
140	"""Draw the shape layer layer onto the map.
141
142	Automatically called by render_map. Iterate through all shapes
143	as indicated by self.layer_shapes() and draw them, using
144	low-level renderers returned by self.low_level_renderer().
145	"""
146	scale = self.scale
147	offx, offy = self.offset
148
149	map_proj = self.map.projection
150	layer_proj = layer.projection
151
152	brush = self.TRANSPARENT_BRUSH
153	pen = self.TRANSPARENT_PEN
154
155	old_prop = None
156	old_group = None
157	lc = layer.GetClassification()
158	field = layer.GetClassificationColumn()
159	defaultGroup = lc.GetDefaultGroup()
160	table = layer.ShapeStore().Table()
161
162	# Determine which render function to use.
163	useraw, draw_func, draw_func_param = self.low_level_renderer(layer)
164
165	# Iterate through all shapes that have to be drawn.
166	for shape in self.layer_shapes(layer):
167
168	if field is None:
169	group = defaultGroup
170	else:
171	record = table.ReadRowAsDict(shape.ShapeID())
172	assert record is not None
173	group = lc.FindGroup(record[field])
174
175	if not group.IsVisible():
176	continue
177
178	# don't recreate new objects if they are the same as before
179	if group is not old_group:
180	old_group = group
181
182	prop = group.GetProperties()
183
184	if prop != old_prop:
185	pen, brush = self.tools_for_property(prop)
186
187	if useraw:
188	data = shape.RawData()
189	else:
190	data = shape.Points()
191	draw_func(draw_func_param, data, pen, brush)
192
193	def layer_shapes(self, layer):
194	"""Return an iterable over the shapes to be drawn from the given layer.
195
196	The default implementation simply returns all ids in the layer.
197	Override in derived classes to be more precise.
198	"""
199	return layer.ShapeStore().AllShapes()
200
201	def low_level_renderer(self, layer):
202	"""Return the low-level renderer for the layer for draw_shape_layer
203
204	The low level renderer to be returned by this method is a tuple
205	(useraw, func, param) where useraw is a boolean indicating
206	whether the function uses the raw shape data, func is a callable
207	object and param is passed as the first parameter to func. The
208	draw_shape_layer method will call func like this:
209
210	func(param, shapedata, pen, brush)
211
212	where shapedata is the return value of the RawData method of the
213	shape object if useraw is true or the return value of the Points
214	method if it's false. pen and brush are the pen and brush to use
215	to draw the shape on the dc.
216
217	The default implementation returns one of
218	self.draw_polygon_shape, self.draw_arc_shape or
219	self.draw_point_shape as func and layer as param. None of the
220	method use the raw shape data. Derived classes can override this
221	method to return more efficient low level renderers.
222	"""
223	shapetype = layer.ShapeType()
224	if shapetype == SHAPETYPE_POINT:
225	func = self.draw_point_shape
226	elif shapetype == SHAPETYPE_ARC:
227	func = self.draw_arc_shape
228	else:
229	func = self.draw_polygon_shape
230	return False, func, layer
231
232	def make_point(self, x, y):
233	"""Convert (x, y) to a point object.
234
235	Derived classes must override this method.
236	"""
237	raise NotImplementedError
238
239	def projected_points(self, layer, points):
240	"""Return the projected coordinates of the points taken from layer.
241
242	Transform all the points in the list of lists of coordinate
243	pairs in points.
244
245	The transformation applies the inverse of the layer's projection
246	if any, then the map's projection if any and finally applies
247	self.scale and self.offset.
248
249	The returned list has the same structure as the one returned the
250	shape's Points method.
251	"""
252	proj = self.map.GetProjection()
253	if proj is not None:
254	forward = proj.Forward
255	else:
256	forward = None
257	proj = layer.GetProjection()
258	if proj is not None:
259	inverse = proj.Inverse
260	else:
261	inverse = None
262	result = []
263	scale = self.scale
264	offx, offy = self.offset
265	make_point = self.make_point
266	for part in points:
267	result.append([])
268	for x, y in part:
269	if inverse:
270	x, y = inverse(x, y)
271	if forward:
272	x, y = forward(x, y)
273	result[-1].append(make_point(x * scale + offx,
274	-y * scale + offy))
275	return result
276
277	def draw_polygon_shape(self, layer, points, pen, brush):
278	"""Draw a polygon shape from layer with the given brush and pen
279
280	The shape is given by points argument which is a the return
281	value of the shape's Points() method. The coordinates in the
282	DC's coordinate system are determined with
283	self.projected_points.
284	"""
285	points = self.projected_points(layer, points)
286
287	if brush is not self.TRANSPARENT_BRUSH:
288	polygon = []
289	for part in points:
290	polygon.extend(part)
291
292	insert_index = len(polygon)
293	for part in points[:-1]:
294	polygon.insert(insert_index, part[0])
295
296	self.dc.SetBrush(brush)
297	self.dc.SetPen(self.TRANSPARENT_PEN)
298	self.dc.DrawPolygon(polygon)
299
300	if pen is not self.TRANSPARENT_PEN:
301	# At last draw the boundarys of the simple polygons
302	self.dc.SetBrush(self.TRANSPARENT_BRUSH)
303	self.dc.SetPen(pen)
304	for part in points:
305	self.dc.DrawLines(part)
306
307	def draw_arc_shape(self, layer, points, pen, brush):
308	"""Draw an arc shape from layer with the given brush and pen
309
310	The shape is given by points argument which is a the return
311	value of the shape's Points() method. The coordinates in the
312	DC's coordinate system are determined with
313	self.projected_points.
314	"""
315	points = self.projected_points(layer, points)
316	self.dc.SetBrush(brush)
317	self.dc.SetPen(pen)
318	for part in points:
319	self.dc.DrawLines(part)
320
321	def draw_point_shape(self, layer, points, pen, brush):
322	"""Draw a point shape from layer with the given brush and pen
323
324	The shape is given by points argument which is a the return
325	value of the shape's Points() method. The coordinates in the
326	DC's coordinate system are determined with
327	self.projected_points.
328
329	The point is drawn as a circle centered on the point.
330	"""
331	points = self.projected_points(layer, points)
332	if not points:
333	return
334
335	radius = self.resolution * 5
336	self.dc.SetBrush(brush)
337	self.dc.SetPen(pen)
338	for part in points:
339	for p in part:
340	self.dc.DrawEllipse(p.x - radius, p.y - radius,
341	2 * radius, 2 * radius)
342
343	def draw_raster_layer(self, layer):
344	"""Draw the raster layer
345
346	This implementation does the projection and scaling of the data
347	as required by the layer's and map's projections and the scale
348	and offset of the renderer and then hands the transformed data
349	to self.draw_raster_data() which has to be implemented in
350	derived classes.
351	"""
352	offx, offy = self.offset
353	width, height = self.dc.GetSizeTuple()
354
355	in_proj = ""
356	proj = layer.GetProjection()
357	if proj is not None:
358	for p in proj.GetAllParameters():
359	in_proj += "+" + p + " "
360
361	out_proj = ""
362	proj = self.map.GetProjection()
363	if proj is not None:
364	for p in proj.GetAllParameters():
365	out_proj += "+" + p + " "
366
367	xmin = (0 - offx) / self.scale
368	ymin = (offy - height) / self.scale
369	xmax = (width - offx) / self.scale
370	ymax = (offy - 0) / self.scale
371
372	try:
373	data = ProjectRasterFile(layer.GetImageFilename(),
374	in_proj, out_proj,
375	(xmin, ymin, xmax, ymax), "",
376	(width, height))
377	except (IOError, AttributeError, ValueError):
378	# Why does this catch AttributeError and ValueError?
379	# FIXME: The exception should be communicated to the user
380	# better.
381	traceback.print_exc()
382	else:
383	self.draw_raster_data(data)
384
385	def draw_raster_data(self, data):
386	"""Draw the raster image in data onto the DC
387
388	The raster image data is a string holding the data in BMP
389	format. The data is exactly the size of the dc and covers it
390	completely.
391
392	This method has to be implemented by derived classes.
393	"""
394	raise NotImplementedError
395
396	def label_font(self):
397	"""Return the font object for the label layer"""
398	raise NotImplementedError
399
400	def draw_label_layer(self, layer):
401	"""Draw the label layer
402
403	All labels are draw in the font returned by self.label_font().
404	"""
405	scale = self.scale
406	offx, offy = self.offset
407
408	self.dc.SetFont(self.label_font())
409
410	map_proj = self.map.projection
411	if map_proj is not None:
412	forward = map_proj.Forward
413	else:
414	forward = None
415
416	for label in layer.Labels():
417	x = label.x
418	y = label.y
419	text = label.text
420	if forward:
421	x, y = forward(x, y)
422	x = x * scale + offx
423	y = -y * scale + offy
424	width, height = self.dc.GetTextExtent(text)
425	if label.halign == ALIGN_LEFT:
426	# nothing to be done
427	pass
428	elif label.halign == ALIGN_RIGHT:
429	x = x - width
430	elif label.halign == ALIGN_CENTER:
431	x = x - width/2
432	if label.valign == ALIGN_TOP:
433	# nothing to be done
434	pass
435	elif label.valign == ALIGN_BOTTOM:
436	y = y - height
437	elif label.valign == ALIGN_CENTER:
438	y = y - height/2
439	self.dc.DrawText(text, x, y)
Name	Value
svn:eol-style	native
svn:keywords	Author Date Id Revision