← Back to branch summary

~ubuntu-branches/ubuntu/saucy/mapserver/saucy-security

« back to all changes in this revision

Viewing changes to mapkml.cpp

  • Committer: Package Import Robot
  • Author(s): Francesco Paolo Lovergine
  • Date: 2011-12-23 14:02:06 UTC
  • mfrom: (26.1.2 sid)
  • Revision ID: package-import@ubuntu.com-20111223140206-n3h9t2hsa8hyslmu
Tags: 6.0.1-2
Added missed stuff for libmapscript-perl.

Show diffs side-by-side

added added

removed removed

Lines of Context:
mapkml.cpp
 
1
/******************************************************************************
 
2
 * $Id: mapkml.cpp 11506 2011-04-07 21:08:48Z assefa $ 
 
3
 *
 
4
 * Project:  MapServer
 
5
 * Purpose:  Headers for mapkml.cpp Google Earth KML output
 
6
 * Author:   David Kana and the MapServer team
 
7
 *
 
8
 ******************************************************************************
 
9
 * Copyright (c) 1996-2009 Regents of the University of Minnesota.
 
10
 *
 
11
 * Permission is hereby granted, free of charge, to any person obtaining a
 
12
 * copy of this software and associated documentation files (the "Software"),
 
13
 * to deal in the Software without restriction, including without limitation
 
14
 * the rights to use, copy, modify, merge, publish, distribute, sublicense,
 
15
 * and/or sell copies of the Software, and to permit persons to whom the
 
16
 * Software is furnished to do so, subject to the following conditions:
 
17
 *
 
18
 * The above copyright notice and this permission notice shall be included in 
 
19
 * all copies of this Software or works derived from this Software.
 
20
 *
 
21
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
 
22
 * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 
23
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
 
24
 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 
25
 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
 
26
 * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
 
27
 * DEALINGS IN THE SOFTWARE.
 
28
 *****************************************************************************/
 
29
#include "mapserver.h"
 
30
 
 
31
#ifdef USE_KML
 
32
 
 
33
#include "mapkmlrenderer.h"
 
34
 
 
35
#ifdef __cplusplus
 
36
extern "C" {
 
37
#endif
 
38
 
 
39
KmlRenderer* getKmlRenderer(imageObj* img)
 
40
{
 
41
    return (KmlRenderer*) img->img.plugin;
 
42
}
 
43
 
 
44
imageObj* msCreateImageKml(int width, int height, outputFormatObj *format, colorObj* bg)
 
45
{
 
46
    imageObj *image = NULL;
 
47
 
 
48
    image = (imageObj*)malloc(sizeof(imageObj));
 
49
    MS_CHECK_ALLOC(image, sizeof(imageObj), NULL);
 
50
    memset(image, 0, sizeof(imageObj));
 
51
 
 
52
    KmlRenderer *ren = new KmlRenderer(width, height, format, bg);
 
53
    image->img.plugin = (void *) ren;
 
54
 
 
55
    return image;
 
56
}
 
57
 
 
58
int msSaveImageKml(imageObj *img, FILE *fp, outputFormatObj *format)
 
59
{
 
60
    KmlRenderer* renderer = getKmlRenderer(img);
 
61
    return renderer->saveImage(img, fp, format);
 
62
}
 
63
 
 
64
int msRenderLineKml(imageObj *img, shapeObj *p, strokeStyleObj *style)
 
65
{
 
66
    KmlRenderer* renderer = getKmlRenderer(img);
 
67
    renderer->renderLine(img, p, style);
 
68
    return MS_SUCCESS;
 
69
}
 
70
 
 
71
int msRenderPolygonKml(imageObj *img, shapeObj *p, colorObj *color)
 
72
{
 
73
    KmlRenderer* renderer = getKmlRenderer(img);
 
74
    renderer->renderPolygon(img, p, color);
 
75
    return MS_SUCCESS;
 
76
}
 
77
 
 
78
int msRenderPolygonTiledKml(imageObj *img, shapeObj *p,  imageObj *tile)
 
79
{
 
80
    /*KmlRenderer* renderer = getKmlRenderer(img);*/
 
81
    return MS_SUCCESS;
 
82
}
 
83
 
 
84
int msRenderLineTiledKml(imageObj *img, shapeObj *p, imageObj *tile)
 
85
{
 
86
    return MS_SUCCESS;
 
87
}
 
88
 
 
89
int msRenderGlyphsKml(imageObj *img, double x, double y,
 
90
                      labelStyleObj *style, char *text)
 
91
{
 
92
    KmlRenderer* renderer = getKmlRenderer(img);
 
93
    renderer->renderGlyphs(img, x, y, style, text);
 
94
    return MS_SUCCESS;
 
95
}
 
96
 
 
97
int msRenderVectorSymbolKml(imageObj *img, double x, double y,
 
98
                            symbolObj *symbol, symbolStyleObj *style)
 
99
{
 
100
    KmlRenderer* renderer = getKmlRenderer(img);
 
101
    renderer->renderVectorSymbol(img, x, y, symbol, style);
 
102
    return MS_SUCCESS;
 
103
}
 
104
 
 
105
int msRenderPixmapSymbolKml(imageObj *img, double x, double y,
 
106
                            symbolObj *symbol, symbolStyleObj *style)
 
107
{
 
108
    KmlRenderer* renderer = getKmlRenderer(img);
 
109
    renderer->renderPixmapSymbol(img, x, y, symbol, style);
 
110
    return MS_SUCCESS;
 
111
}
 
112
 
 
113
int msRenderEllipseSymbolKml(imageObj *image, double x, double y, 
 
114
                             symbolObj *symbol, symbolStyleObj *style)
 
115
{
 
116
    KmlRenderer* renderer = getKmlRenderer(image);
 
117
    renderer->renderEllipseSymbol(image, x, y, symbol, style);
 
118
    return MS_SUCCESS;
 
119
}
 
120
 
 
121
int msRenderTruetypeSymbolKml(imageObj *image, double x, double y,
 
122
                              symbolObj *symbol, symbolStyleObj *style)
 
123
{
 
124
    KmlRenderer* renderer = getKmlRenderer(image);
 
125
    renderer->renderTruetypeSymbol(image, x, y, symbol, style);
 
126
    return MS_SUCCESS;
 
127
}
 
128
 
 
129
 
 
130
int msRenderTileKml(imageObj *img, imageObj *tile, double x, double y)
 
131
{
 
132
    return MS_SUCCESS;
 
133
}
 
134
 
 
135
int msGetRasterBufferKml(imageObj *img,rasterBufferObj *rb)
 
136
{
 
137
    return MS_FAILURE; //not supported for kml
 
138
}
 
139
 
 
140
 
 
141
int msGetTruetypeTextBBoxKml(rendererVTableObj *r,char *font, double size, char *string,
 
142
                rectObj *rect, double **advances)
 
143
{
 
144
   rect->minx=0.0;
 
145
   rect->maxx=0.0;
 
146
   rect->miny=0.0;
 
147
   rect->maxy=0.0;
 
148
   if (advances) {
 
149
         int numglyphs = msGetNumGlyphs(string);
 
150
         *advances = (double*) msSmallMalloc(numglyphs * sizeof (double));
 
151
         for(int i=0;i<numglyphs;i++) {
 
152
            (*advances)[i] = size;
 
153
         }
 
154
   }
 
155
   return MS_SUCCESS;
 
156
}
 
157
 
 
158
int msStartNewLayerKml(imageObj *img, mapObj *map, layerObj *layer)
 
159
{
 
160
    KmlRenderer* renderer = getKmlRenderer(img);
 
161
    return renderer->startNewLayer(img, layer);
 
162
}
 
163
 
 
164
int msCloseNewLayerKml(imageObj *img, mapObj *map, layerObj *layer)
 
165
{
 
166
    KmlRenderer* renderer = getKmlRenderer(img);
 
167
    return renderer->closeNewLayer(img, layer);
 
168
}
 
169
 
 
170
int msFreeImageKml(imageObj *image)
 
171
{
 
172
    KmlRenderer* renderer = getKmlRenderer(image);
 
173
    if (renderer)
 
174
    {
 
175
        delete renderer;
 
176
    }
 
177
    image->img.plugin=NULL;
 
178
    return MS_SUCCESS;
 
179
}
 
180
 
 
181
int msFreeSymbolKml(symbolObj *symbol)
 
182
{
 
183
    return MS_SUCCESS;
 
184
}
 
185
 
 
186
int msStartShapeKml(imageObj *img, shapeObj *shape)
 
187
{
 
188
    KmlRenderer* renderer = getKmlRenderer(img);
 
189
    renderer->startShape(img, shape);
 
190
    return MS_SUCCESS;
 
191
}
 
192
 
 
193
int msEndShapeKml(imageObj *img, shapeObj *shape)
 
194
{
 
195
    KmlRenderer* renderer = getKmlRenderer(img);
 
196
    renderer->endShape(img, shape);
 
197
    return MS_SUCCESS;
 
198
}
 
199
 
 
200
int msMergeRasterBufferKml(imageObj *dest, rasterBufferObj *overlay, double opacity, int srcX, 
 
201
                           int srcY, int dstX, int dstY, int width, int height) {
 
202
    KmlRenderer* renderer = getKmlRenderer(dest);
 
203
    return renderer->mergeRasterBuffer(dest,overlay);
 
204
}
 
205
 
 
206
#ifdef __cplusplus
 
207
}
 
208
#endif
 
209
 
 
210
 
 
211
#endif /*USE_KML*/
 
212
 
 
213
int aggInitializeRasterBuffer(rasterBufferObj *rb, int width, int height, int mode);
 
214
 
 
215
int msPopulateRendererVTableKML( rendererVTableObj *renderer )
 
216
{
 
217
#ifdef USE_KML
 
218
 
 
219
    renderer->supports_transparent_layers = 1;
 
220
    renderer->supports_pixel_buffer = 0;
 
221
    renderer->supports_bitmap_fonts = 0;
 
222
    renderer->supports_clipping = 0;
 
223
    renderer->use_imagecache = 0;
 
224
    renderer->default_transform_mode = MS_TRANSFORM_NONE;
 
225
 
 
226
    renderer->startLayer = msStartNewLayerKml;
 
227
    renderer->endLayer = msCloseNewLayerKml;
 
228
    renderer->renderLine=&msRenderLineKml;
 
229
    renderer->createImage=&msCreateImageKml;
 
230
    renderer->saveImage=&msSaveImageKml;
 
231
    renderer->renderPolygon=&msRenderPolygonKml;
 
232
    renderer->renderGlyphs=&msRenderGlyphsKml;
 
233
    renderer->renderEllipseSymbol = &msRenderEllipseSymbolKml;
 
234
    renderer->renderVectorSymbol = &msRenderVectorSymbolKml;
 
235
    renderer->renderPixmapSymbol = &msRenderPixmapSymbolKml;
 
236
    renderer->renderTruetypeSymbol = &msRenderTruetypeSymbolKml;
 
237
    renderer->mergeRasterBuffer = &msMergeRasterBufferKml;
 
238
    renderer->loadImageFromFile = msLoadMSRasterBufferFromFile;
 
239
    renderer->initializeRasterBuffer = aggInitializeRasterBuffer;
 
240
    renderer->getTruetypeTextBBox = &msGetTruetypeTextBBoxKml;
 
241
    renderer->renderTile = &msRenderTileKml;
 
242
    renderer->renderPolygonTiled = &msRenderPolygonTiledKml;
 
243
    renderer->renderLineTiled = NULL;
 
244
    renderer->freeSymbol = &msFreeSymbolKml;
 
245
    renderer->freeImage=&msFreeImageKml;
 
246
    renderer->mergeRasterBuffer = msMergeRasterBufferKml;
 
247
 
 
248
    renderer->startShape=&msStartShapeKml;
 
249
    renderer->endShape=&msEndShapeKml;
 
250
 
 
251
    return MS_SUCCESS;
 
252
#else
 
253
    msSetError(MS_MISCERR, "KML Driver requested but is not built in", 
 
254
               "msPopulateRendererVTableKML()");
 
255
    return MS_FAILURE;
 
256
#endif
 
257
}
 
258