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_ids() 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.
        draw_func, draw_func_param = self.low_level_renderer(layer)

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

            if field is None:
                group = defaultGroup
            else:
                record = table.ReadRowAsDict(i)
                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)

            draw_func(draw_func_param, i, pen, brush)

    def layer_ids(self, layer):
        """Return the shape ids of the given layer that have to be drawn.

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

    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
        (func, param) where 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, rawshape, pen, brush)

        where rawshape is currently the shapeid. 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. 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 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, shapeid):
        """Return the projected coordinates of shape shapeid in layer.

        Read the shape from the layer through its Shape method and
        transform all the points in the list of lists of coordinate
        pairs returned by the shape's Points method.

        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
        shape = layer.Shape(shapeid)
        points = []
        scale = self.scale
        offx, offy = self.offset
        make_point = self.make_point
        for part in shape.Points():
            points.append([])
            for x, y in part:
                if inverse:
                    x, y = inverse(x, y)
                if forward:
                    x, y = forward(x, y)
                points[-1].append(make_point(x * scale + offx,
                                             -y * scale + offy))
        return points

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

        The shape is indicated by its id (index) and the layer. The
        coordinates in the DC's coordinate system are determined with
        self.projected_points.
        """
        points = self.projected_points(layer, index)

        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, index, pen, brush):
        """Draw an arc shape with the given brush and pen

        The shape is indicated by its id (index) and the layer. The
        coordinates in the DC's coordinate system are determined with
        self.projected_points.
        """
        points = self.projected_points(layer, index)
        self.dc.SetBrush(brush)
        self.dc.SetPen(pen)
        for part in points:
            self.dc.DrawLines(part)

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

        The shape is indicated by its id (index) and the layer. 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, index)
        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_ids() and draw them, using low-level
144	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	draw_func, draw_func_param = self.low_level_renderer(layer)
164
165	# Iterate through all shapes that have to be drawn.
166	for i in self.layer_ids(layer):
167
168	if field is None:
169	group = defaultGroup
170	else:
171	record = table.ReadRowAsDict(i)
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	draw_func(draw_func_param, i, pen, brush)
188
189	def layer_ids(self, layer):
190	"""Return the shape ids of the given layer that have to be drawn.
191
192	The default implementation simply returns all ids in the layer.
193	Override in derived classes to be more precise.
194	"""
195	return range(layer.NumShapes())
196
197	def low_level_renderer(self, layer):
198	"""Return the low-level renderer for the layer for draw_shape_layer
199
200	The low level renderer to be returned by this method is a tuple
201	(func, param) where func is a callable object and param is
202	passed as the first parameter to func. The draw_shape_layer
203	method will call func like this:
204
205	func(param, rawshape, pen, brush)
206
207	where rawshape is currently the shapeid. pen and brush are the
208	pen and brush to use to draw the shape on the dc.
209
210	The default implementation returns one of
211	self.draw_polygon_shape, self.draw_arc_shape or
212	self.draw_point_shape as func and layer as param. Derived
213	classes can override this method to return more efficient low
214	level renderers.
215	"""
216	shapetype = layer.ShapeType()
217	if shapetype == SHAPETYPE_POINT:
218	func = self.draw_point_shape
219	elif shapetype == SHAPETYPE_ARC:
220	func = self.draw_arc_shape
221	else:
222	func = self.draw_polygon_shape
223	return func, layer
224
225	def make_point(self, x, y):
226	"""Convert (x, y) to a point object.
227
228	Derived classes must override this method.
229	"""
230	raise NotImplementedError
231
232	def projected_points(self, layer, shapeid):
233	"""Return the projected coordinates of shape shapeid in layer.
234
235	Read the shape from the layer through its Shape method and
236	transform all the points in the list of lists of coordinate
237	pairs returned by the shape's Points method.
238
239	The transformation applies the inverse of the layer's projection
240	if any, then the map's projection if any and finally applies
241	self.scale and self.offset.
242
243	The returned list has the same structure as the one returned the
244	shape's Points method.
245	"""
246	proj = self.map.GetProjection()
247	if proj is not None:
248	forward = proj.Forward
249	else:
250	forward = None
251	proj = layer.GetProjection()
252	if proj is not None:
253	inverse = proj.Inverse
254	else:
255	inverse = None
256	shape = layer.Shape(shapeid)
257	points = []
258	scale = self.scale
259	offx, offy = self.offset
260	make_point = self.make_point
261	for part in shape.Points():
262	points.append([])
263	for x, y in part:
264	if inverse:
265	x, y = inverse(x, y)
266	if forward:
267	x, y = forward(x, y)
268	points[-1].append(make_point(x * scale + offx,
269	-y * scale + offy))
270	return points
271
272	def draw_polygon_shape(self, layer, index, pen, brush):
273	"""Draw a polygon shape with the given brush and pen
274
275	The shape is indicated by its id (index) and the layer. The
276	coordinates in the DC's coordinate system are determined with
277	self.projected_points.
278	"""
279	points = self.projected_points(layer, index)
280
281	if brush is not self.TRANSPARENT_BRUSH:
282	polygon = []
283	for part in points:
284	polygon.extend(part)
285
286	insert_index = len(polygon)
287	for part in points[:-1]:
288	polygon.insert(insert_index, part[0])
289
290	self.dc.SetBrush(brush)
291	self.dc.SetPen(self.TRANSPARENT_PEN)
292	self.dc.DrawPolygon(polygon)
293
294	if pen is not self.TRANSPARENT_PEN:
295	# At last draw the boundarys of the simple polygons
296	self.dc.SetBrush(self.TRANSPARENT_BRUSH)
297	self.dc.SetPen(pen)
298	for part in points:
299	self.dc.DrawLines(part)
300
301	def draw_arc_shape(self, layer, index, pen, brush):
302	"""Draw an arc shape with the given brush and pen
303
304	The shape is indicated by its id (index) and the layer. The
305	coordinates in the DC's coordinate system are determined with
306	self.projected_points.
307	"""
308	points = self.projected_points(layer, index)
309	self.dc.SetBrush(brush)
310	self.dc.SetPen(pen)
311	for part in points:
312	self.dc.DrawLines(part)
313
314	def draw_point_shape(self, layer, index, pen, brush):
315	"""Draw a point shape with the given brush and pen
316
317	The shape is indicated by its id (index) and the layer. The
318	coordinates in the DC's coordinate system are determined with
319	self.projected_points.
320
321	The point is drawn as a circle centered on the point.
322	"""
323	points = self.projected_points(layer, index)
324	if not points:
325	return
326
327	radius = self.resolution * 5
328	self.dc.SetBrush(brush)
329	self.dc.SetPen(pen)
330	for part in points:
331	for p in part:
332	self.dc.DrawEllipse(p.x - radius, p.y - radius,
333	2 * radius, 2 * radius)
334
335	def draw_raster_layer(self, layer):
336	"""Draw the raster layer
337
338	This implementation does the projection and scaling of the data
339	as required by the layer's and map's projections and the scale
340	and offset of the renderer and then hands the transformed data
341	to self.draw_raster_data() which has to be implemented in
342	derived classes.
343	"""
344	offx, offy = self.offset
345	width, height = self.dc.GetSizeTuple()
346
347	in_proj = ""
348	proj = layer.GetProjection()
349	if proj is not None:
350	for p in proj.GetAllParameters():
351	in_proj += "+" + p + " "
352
353	out_proj = ""
354	proj = self.map.GetProjection()
355	if proj is not None:
356	for p in proj.GetAllParameters():
357	out_proj += "+" + p + " "
358
359	xmin = (0 - offx) / self.scale
360	ymin = (offy - height) / self.scale
361	xmax = (width - offx) / self.scale
362	ymax = (offy - 0) / self.scale
363
364	try:
365	data = ProjectRasterFile(layer.GetImageFilename(),
366	in_proj, out_proj,
367	(xmin, ymin, xmax, ymax), "",
368	(width, height))
369	except (IOError, AttributeError, ValueError):
370	# Why does this catch AttributeError and ValueError?
371	# FIXME: The exception should be communicated to the user
372	# better.
373	traceback.print_exc()
374	else:
375	self.draw_raster_data(data)
376
377	def draw_raster_data(self, data):
378	"""Draw the raster image in data onto the DC
379
380	The raster image data is a string holding the data in BMP
381	format. The data is exactly the size of the dc and covers it
382	completely.
383
384	This method has to be implemented by derived classes.
385	"""
386	raise NotImplementedError
387
388	def label_font(self):
389	"""Return the font object for the label layer"""
390	raise NotImplementedError
391
392	def draw_label_layer(self, layer):
393	"""Draw the label layer
394
395	All labels are draw in the font returned by self.label_font().
396	"""
397	scale = self.scale
398	offx, offy = self.offset
399
400	self.dc.SetFont(self.label_font())
401
402	map_proj = self.map.projection
403	if map_proj is not None:
404	forward = map_proj.Forward
405	else:
406	forward = None
407
408	for label in layer.Labels():
409	x = label.x
410	y = label.y
411	text = label.text
412	if forward:
413	x, y = forward(x, y)
414	x = x * scale + offx
415	y = -y * scale + offy
416	width, height = self.dc.GetTextExtent(text)
417	if label.halign == ALIGN_LEFT:
418	# nothing to be done
419	pass
420	elif label.halign == ALIGN_RIGHT:
421	x = x - width
422	elif label.halign == ALIGN_CENTER:
423	x = x - width/2
424	if label.valign == ALIGN_TOP:
425	# nothing to be done
426	pass
427	elif label.valign == ALIGN_BOTTOM:
428	y = y - height
429	elif label.valign == ALIGN_CENTER:
430	y = y - height/2
431	self.dc.DrawText(text, x, y)
Name	Value
svn:eol-style	native
svn:keywords	Author Date Id Revision