Download as
Browse Code »

Commit b9a99284f31ff92dfa7f24366b7401b3edf8207c

Authored by Edmar Moretti
1 parent 17aeead2
Exists in master and in 7 other branches composer, doc-root, docker, guia, licenca, readme, unmaintened

Atualização do pacote wiket

Showing 3 changed files with 0 additions and 759 deletions   Show diff stats
pacotes/wicket/wicket-gmap3.src.js
View file @17aeead
@@ -1,313 +0,0 @@ @@ -1,313 +0,0 @@
1 -/*global Wkt, google, document, window, console*/  
2 -google.maps.Marker.prototype.type = 'marker';  
3 -google.maps.Polyline.prototype.type = 'polyline';  
4 -google.maps.Polygon.prototype.type = 'polygon';  
5 -google.maps.Rectangle.prototype.type = 'rectangle';  
6 -google.maps.Circle.prototype.type = 'circle';  
7 -  
8 -/**  
9 - * An object of framework-dependent construction methods used to generate  
10 - * objects belonging to the various geometry classes of the framework.  
11 - */  
12 -Wkt.Wkt.prototype.construct = {  
13 - /**  
14 - * Creates the framework's equivalent point geometry object.  
15 - * @param config {Object} An optional properties hash the object should use  
16 - * @param component {Object} An optional component to build from  
17 - * @return {google.maps.Marker}  
18 - */  
19 - 'point': function (config, component) {  
20 - var c = component || this.components;  
21 -  
22 - config = config || {};  
23 -  
24 - config.position = new google.maps.LatLng(c[0].y, c[0].x);  
25 -  
26 - return new google.maps.Marker(config);  
27 - },  
28 -  
29 - /**  
30 - * Creates the framework's equivalent multipoint geometry object.  
31 - * @param config {Object} An optional properties hash the object should use  
32 - * @return {Array} Array containing multiple google.maps.Marker  
33 - */  
34 - 'multipoint': function (config) {  
35 - var i, c, arr;  
36 -  
37 - c = this.components;  
38 -  
39 - config = config || {};  
40 -  
41 - arr = [];  
42 -  
43 - for (i = 0; i < c.length; i += 1) {  
44 - arr.push(this.construct.point(config, c[i]));  
45 - }  
46 -  
47 - return arr;  
48 - },  
49 -  
50 - /**  
51 - * Creates the framework's equivalent multipoint geometry object.  
52 - * @param config {Object} An optional properties hash the object should use  
53 - * @param component {Object} An optional component to build from  
54 - * @return {google.maps.Polyline}  
55 - */  
56 - 'linestring': function (config, component) {  
57 - var i, c;  
58 -  
59 - c = component || this.components;  
60 -  
61 - config = config || {  
62 - editable: false  
63 - };  
64 -  
65 - config.path = [];  
66 -  
67 - for (i = 0; i < c.length; i += 1) {  
68 - config.path.push(new google.maps.LatLng(c[i].y, c[i].x));  
69 - }  
70 -  
71 - return new google.maps.Polyline(config);  
72 - },  
73 -  
74 - /**  
75 - * Creates the framework's equivalent multilinestring geometry object.  
76 - * @param config {Object} An optional properties hash the object should use  
77 - * @return {Array} Array containing multiple google.maps.Polyline instances  
78 - */  
79 - 'multilinestring': function (config) {  
80 - var i, c, arr;  
81 -  
82 - c = this.components;  
83 -  
84 - config = config || {  
85 - editable: false  
86 - };  
87 -  
88 - config.path = [];  
89 -  
90 - arr = [];  
91 -  
92 - for (i = 0; i < c.length; i += 1) {  
93 - arr.push(this.construct.linestring(config, c[i]));  
94 - }  
95 -  
96 - return arr;  
97 - },  
98 -  
99 - /**  
100 - * Creates the framework's equivalent polygon geometry object.  
101 - * @param config {Object} An optional properties hash the object should use  
102 - * @return {google.maps.Polygon}  
103 - */  
104 - 'polygon': function (config) {  
105 - var j, k, c, rings, verts;  
106 -  
107 - c = this.components;  
108 -  
109 - config = config || {  
110 - editable: false // Editable geometry off by default  
111 - };  
112 -  
113 - config.paths = [];  
114 -  
115 - rings = [];  
116 - for (j = 0; j < c.length; j += 1) { // For each ring...  
117 -  
118 - verts = [];  
119 - for (k = 0; k < c[j].length; k += 1) { // For each vertex...  
120 - verts.push(new google.maps.LatLng(c[j][k].y, c[j][k].x));  
121 -  
122 - } // eo for each vertex  
123 -  
124 - if (j !== 0) { // Reverse the order of coordinates in inner rings  
125 - if (config.reverseInnerPolygons == null || config.reverseInnerPolygons) {  
126 - verts.reverse();  
127 - }  
128 - }  
129 -  
130 - rings.push(verts);  
131 - } // eo for each ring  
132 -  
133 - config.paths = config.paths.concat(rings);  
134 -  
135 - if (this.isRectangle) {  
136 - console.log('Rectangles are not yet supported; set the isRectangle property to false (default).');  
137 - } else {  
138 - return new google.maps.Polygon(config);  
139 - }  
140 - },  
141 -  
142 - /**  
143 - * Creates the framework's equivalent multipolygon geometry object.  
144 - * @param config {Object} An optional properties hash the object should use  
145 - * @return {Array} Array containing multiple google.maps.Polygon  
146 - */  
147 - 'multipolygon': function (config) {  
148 - var i, j, k, c, rings, verts;  
149 -  
150 - c = this.components;  
151 -  
152 - config = config || {  
153 - editable: false // Editable geometry off by default  
154 - };  
155 -  
156 - config.paths = []; // Must ensure this property is available  
157 -  
158 - for (i = 0; i < c.length; i += 1) { // For each polygon...  
159 -  
160 - rings = [];  
161 - for (j = 0; j < c[i].length; j += 1) { // For each ring...  
162 -  
163 - verts = [];  
164 - for (k = 0; k < c[i][j].length; k += 1) { // For each vertex...  
165 - verts.push(new google.maps.LatLng(c[i][j][k].y, c[i][j][k].x));  
166 -  
167 - } // eo for each vertex  
168 -  
169 -/* // This is apparently not needed in multipolygon cases  
170 - if (j !== 0) { // Reverse the order of coordinates in inner rings  
171 - verts.reverse();  
172 - }  
173 -*/  
174 - rings.push(verts);  
175 - } // eo for each ring  
176 -  
177 - config.paths = config.paths.concat(rings);  
178 -  
179 - } // eo for each polygon  
180 -  
181 - return new google.maps.Polygon(config);  
182 - }  
183 -  
184 -};  
185 -  
186 -/**  
187 - * A framework-dependent deconstruction method used to generate internal  
188 - * geometric representations from instances of framework geometry. This method  
189 - * uses object detection to attempt to classify members of framework geometry  
190 - * classes into the standard WKT types.  
191 - * @param obj {Object} An instance of one of the framework's geometry classes  
192 - * @return {Object} A hash of the 'type' and 'components' thus derived  
193 - */  
194 -Wkt.Wkt.prototype.deconstruct = function (obj) {  
195 - var i, j, verts, rings, tmp;  
196 -  
197 - // google.maps.Marker //////////////////////////////////////////////////////  
198 - if (obj.getPosition && typeof obj.getPosition === 'function') {  
199 - // Only Markers, among all overlays, have the getPosition property  
200 -  
201 - return {  
202 - type: 'point',  
203 - components: [{  
204 - x: obj.getPosition().lng(),  
205 - y: obj.getPosition().lat()  
206 - }]  
207 - };  
208 -  
209 - // google.maps.Polyline ////////////////////////////////////////////////////  
210 - } else if (obj.getPath && !obj.getPaths) {  
211 - // Polylines have a single path (getPath) not paths (getPaths)  
212 -  
213 - verts = [];  
214 - for (i = 0; i < obj.getPath().length; i += 1) {  
215 - tmp = obj.getPath().getAt(i);  
216 - verts.push({  
217 - x: tmp.lng(),  
218 - y: tmp.lat()  
219 - });  
220 - }  
221 -  
222 - return {  
223 - type: 'linestring',  
224 - components: verts  
225 - };  
226 -  
227 - // google.maps.Polygon /////////////////////////////////////////////////////  
228 - } else if (obj.getPaths) {  
229 - // Polygon is the only class with the getPaths property  
230 -  
231 - // TODO Polygons with holes cannot be distinguished from multipolygons  
232 - rings = [];  
233 - for (i = 0; i < obj.getPaths().length; i += 1) { // For each polygon (ring)...  
234 - tmp = obj.getPaths().getAt(i);  
235 -  
236 - verts = [];  
237 - for (j = 0; j < obj.getPaths().getAt(i).length; j += 1) { // For each vertex...  
238 - verts.push({  
239 - x: tmp.getAt(j).lng(),  
240 - y: tmp.getAt(j).lat()  
241 - });  
242 - }  
243 -  
244 - verts.push({ // Add the first coordinate again for closure  
245 - x: tmp.getAt(0).lng(),  
246 - y: tmp.getAt(0).lat()  
247 - });  
248 -  
249 - // Since we can't distinguish between single polygons with holes  
250 - // and multipolygons, we always create multipolygons  
251 - if (obj.getPaths().length > 1) {  
252 - verts = [verts]; // Wrap multipolygons once more (collection)  
253 - }  
254 -  
255 - rings.push(verts);  
256 - }  
257 -  
258 - return {  
259 - type: 'polygon',  
260 - components: rings  
261 - };  
262 -  
263 - // google.maps.Rectangle ///////////////////////////////////////////////////  
264 - } else if (obj.getBounds && !obj.getRadius) {  
265 - // Rectangle is only overlay class with getBounds property and not getRadius property  
266 -  
267 - tmp = obj.getBounds();  
268 - return {  
269 - type: 'polygon',  
270 - isRectangle: true,  
271 - components: [  
272 - [  
273 - { // NW corner  
274 - x: tmp.getSouthWest().lng(),  
275 - y: tmp.getNorthEast().lat()  
276 - },  
277 - { // NE corner  
278 - x: tmp.getNorthEast().lng(),  
279 - y: tmp.getNorthEast().lat()  
280 - },  
281 - { // SE corner  
282 - x: tmp.getNorthEast().lng(),  
283 - y: tmp.getSouthWest().lat()  
284 - },  
285 - { // SW corner  
286 - x: tmp.getSouthWest().lng(),  
287 - y: tmp.getSouthWest().lat()  
288 - },  
289 - { // NW corner (again, for closure)  
290 - x: tmp.getSouthWest().lng(),  
291 - y: tmp.getNorthEast().lat()  
292 - }  
293 - ]  
294 - ]  
295 - };  
296 -  
297 - // google.maps.Circle //////////////////////////////////////////////////////  
298 - } else if (obj.getBounds && obj.getRadius) {  
299 - // Circle is the only overlay class with both the getBounds and getRadius properties  
300 -  
301 - console.log('Deconstruction of google.maps.Circle objects is not yet supported');  
302 -  
303 - } else {  
304 - console.log('The passed object does not have any recognizable properties.');  
305 - }  
306 -  
307 -};  
308 -  
309 -/**  
310 - * A framework-dependent flag, set for each Wkt.Wkt() instance, that indicates  
311 - * whether or not a closed polygon geometry should be interpreted as a rectangle.  
312 - */  
313 -Wkt.Wkt.prototype.isRectangle = false;  
pacotes/wicket/wicket-leaflet.src.js
View file @17aeead
@@ -1,61 +0,0 @@ @@ -1,61 +0,0 @@
1 -Wkt.Wkt.prototype.isRectangle = false;  
2 -  
3 -Wkt.Wkt.prototype.construct = {  
4 - point: function (config, component) {  
5 - var coord = component || this.components;  
6 - if (coord instanceof Array) {  
7 - coord = coord[0];  
8 - }  
9 -  
10 - return L.marker(this.coordsToLatLng(coord), config);  
11 - },  
12 -  
13 - multipoint: function (config) {  
14 - var layers = [],  
15 - coords = this.components,  
16 - latlng;  
17 -  
18 - for (var i = 0, len = coords.length; i < len; i++) {  
19 - layers.push(this.construct.point.call(this, config, coords[i]));  
20 - }  
21 -  
22 - return L.featureGroup(layers, config);  
23 - },  
24 -  
25 - linestring: function (config, component) {  
26 - var coords = component || this.components,  
27 - latlngs = this.coordsToLatLngs(coords);  
28 -  
29 - return L.polyLine(latlngs);  
30 - },  
31 -  
32 - multilinestring: function (config) {  
33 - var coords = this.components,  
34 - latlngs = this.coordsToLatLngs(coords, 1);  
35 -  
36 - return L.multiPolyline(latlngs);  
37 - },  
38 -  
39 - polygon: function (config) {  
40 - var coords = this.components,  
41 - latlngs = this.coordsToLatLngs(coords, 1);  
42 - return L.polygon(latlngs);  
43 - },  
44 -  
45 - multipolygon: function (config) {  
46 - var coords = this.components,  
47 - latlngs = this.coordsToLatLngs(coords, 2);  
48 -  
49 - return L.multiPolygon(latlngs);  
50 - }  
51 -};  
52 -  
53 -L.Util.extend(Wkt.Wkt.prototype, {  
54 - coordsToLatLngs: L.GeoJSON.coordsToLatLngs,  
55 - coordsToLatLng: function (coords, reverse) {  
56 - var lat = reverse ? coords.x : coords.y,  
57 - lng = reverse ? coords.y : coords.x;  
58 -  
59 - return L.latLng(lat, lng, true);  
60 - }  
61 -});  
pacotes/wicket/wicket.src.js
View file @17aeead
@@ -1,385 +0,0 @@ @@ -1,385 +0,0 @@
1 -/*global console, document, window*/  
2 -/**  
3 - * @author K. Arthur Endsley <arthur.endsley@gmail.com>  
4 - */  
5 -var Wkt = (function () { // Execute function immediately  
6 -  
7 - return {  
8 - // The default delimiter for separating components of atomic geometry (coordinates)  
9 - delimiter: ' ',  
10 -  
11 - isArray: function (obj) {  
12 - return !!(obj && obj.constructor == Array);  
13 - },  
14 -  
15 - /**  
16 - * An object for reading WKT strings and writing geographic features  
17 - * @param {String} An optional WKT string for immediate read  
18 - * @param {Wkt.Wkt} A WKT object  
19 - */  
20 - Wkt: function (initializer) {  
21 - var beginsWith, endsWith, trim;  
22 -  
23 - /**  
24 - * @private  
25 - */  
26 - beginsWith = function (str, sub) {  
27 - return str.substring(0, sub.length) === sub;  
28 - };  
29 -  
30 - /**  
31 - * @private  
32 - */  
33 - endsWith = function (str, sub) {  
34 - return str.substring(str.length - sub.length) === sub;  
35 - };  
36 -  
37 - /**  
38 - * @private  
39 - */  
40 - trim = function (str, sub) {  
41 - sub = sub || ' '; // Defaults to trimming spaces  
42 - // Trim beginning spaces  
43 - while (beginsWith(str, sub)) {  
44 - str = str.substring(1);  
45 - }  
46 - // Trim ending spaces  
47 - while (endsWith(str, sub)) {  
48 - str = str.substring(0, str.length - 1);  
49 - }  
50 - return str;  
51 - };  
52 -  
53 - /**  
54 - * The default delimiter between X and Y coordinates.  
55 - */  
56 - this.delimiter = Wkt.delimiter;  
57 -  
58 - /**  
59 - * Some regular expressions copied from OpenLayers.Format.WKT.js  
60 - */  
61 - this.regExes = {  
62 - 'typeStr': /^\s*(\w+)\s*\(\s*(.*)\s*\)\s*$/,  
63 - 'spaces': /\s+|\+/, // Matches the '+' or the empty space  
64 - 'numeric': /-*\d+\.*\d+/,  
65 - 'comma': /\s*,\s*/,  
66 - 'parenComma': /\)\s*,\s*\(/,  
67 - 'doubleParenComma': /\)\s*\)\s*,\s*\(\s*\(/,  
68 - 'trimParens': /^\s*\(?(.*?)\)?\s*$/  
69 - };  
70 -  
71 - /**  
72 - * Returns true if the internal geometry is a collection of geometries.  
73 - * @return {Boolean} Returns true when it is a collection  
74 - */  
75 - this.isCollection = function () {  
76 - switch (this.type.slice(0, 5)) {  
77 - case 'multi':  
78 - // Trivial; any multi-geometry is a collection  
79 - return true;  
80 - case 'polyg':  
81 - // Polygons with holes are "collections" of rings  
82 - return true;  
83 - default:  
84 - // Any other geometry is not a collection  
85 - return false;  
86 - }  
87 - };  
88 -  
89 - /**  
90 - * The internal representation of geometry--the "components" of geometry.  
91 - */  
92 - this.components = undefined;  
93 -  
94 - /**  
95 - * Sets internal geometry (components) from framework geometry (e.g.  
96 - * Google Polygon objects or google.maps.Polygon).  
97 - * @param obj {Object} The framework-dependent geometry representation  
98 - * @return {Wkt.Wkt} The object itself  
99 - */  
100 - this.fromObject = function (obj) {  
101 - var result = this.deconstruct.call(this, obj);  
102 - this.components = result.components;  
103 - this.isRectangle = result.isRectangle || false;  
104 - this.type = result.type;  
105 - return this;  
106 - };  
107 -  
108 - /**  
109 - * Creates external geometry objects based on a plug-in framework's  
110 - * construction methods and available geometry classes.  
111 - * @param config {Object} An optional framework-dependent properties specification  
112 - * @return {Object} The framework-dependent geometry representation  
113 - */  
114 - this.toObject = function (config) {  
115 - return this.construct[this.type].call(this, config);  
116 - };  
117 -  
118 - /**  
119 - * Reads a WKT string, validating and incorporating it.  
120 - * @param wkt {String} A WKT string  
121 - * @return {Array} An Array of internal geometry objects  
122 - */  
123 - this.read = function (wkt) {  
124 - var matches;  
125 - matches = this.regExes.typeStr.exec(wkt);  
126 - if (matches) {  
127 - this.type = matches[1].toLowerCase();  
128 - this.base = matches[2];  
129 - if (this.ingest[this.type]) {  
130 - this.components = this.ingest[this.type].apply(this, [this.base]);  
131 - }  
132 - } else {  
133 - console.log("Invalid WKT string provided to read()");  
134 - throw {  
135 - name: "WKTError",  
136 - message: "Invalid WKT string provided to read()"  
137 - }  
138 - }  
139 - return this.components;  
140 - }; // eo readWkt  
141 -  
142 - /**  
143 - * Writes a WKT string.  
144 - * @param components {Array} An Array of internal geometry objects  
145 - * @return {String} The corresponding WKT representation  
146 - */  
147 - this.write = function (components) {  
148 - var i, pieces, data;  
149 -  
150 - components = components || this.components;  
151 -  
152 - pieces = [];  
153 -  
154 - pieces.push(this.type.toUpperCase() + '(');  
155 -  
156 - for (i = 0; i < components.length; i += 1) {  
157 - if (this.isCollection() && i > 0) {  
158 - pieces.push(',');  
159 - }  
160 -  
161 - // There should be an extract function for the named type  
162 - if (!this.extract[this.type]) {  
163 - return null;  
164 - }  
165 -//original  
166 -//data = this.extract[this.type].apply(this, [components[i]]);  
167 -//alterado por edmar  
168 - if(components[i].length == 1){  
169 - data = this.extract[this.type].apply(this, [components[i][0]]);  
170 - }  
171 - else{  
172 - data = this.extract[this.type].apply(this, [components[i]]);  
173 - }  
174 - if (this.isCollection()) {  
175 - pieces.push('(' + data + ')');  
176 - } else {  
177 - pieces.push(data);  
178 - // If not at the end of the components, add a comma  
179 - if (i !== components.length - 1) {  
180 - pieces.push(',');  
181 - }  
182 - }  
183 - }  
184 -  
185 - pieces.push(')');  
186 -  
187 - return pieces.join('');  
188 - };  
189 -  
190 - /**  
191 - * This object contains functions as property names that extract WKT  
192 - * strings from the internal representation.  
193 - */  
194 - this.extract = {  
195 - /**  
196 - * Return a WKT string representing atomic (point) geometry  
197 - * @param point {Object} An object with x and y properties  
198 - * @return {String} The WKT representation  
199 - */  
200 - 'point': function (point) {  
201 - return point.x + this.delimiter + point.y;  
202 - },  
203 - /**  
204 - * Return a WKT string representing multiple atoms (points)  
205 - * @param point {Array} Multiple x-and-y objects  
206 - * @return {String} The WKT representation  
207 - */  
208 - 'multipoint': function (multipoint) {  
209 - var i, parts = [];  
210 - for (i = 0; i < multipoint.length; i += 1) {  
211 - parts.push(this.extract.point.apply(this, [multipoint[i]]));  
212 - }  
213 - return parts.join(',');  
214 - },  
215 - /**  
216 - * Return a WKT string representing a chain (linestring) of atoms  
217 - * @param point {Array} Multiple x-and-y objects  
218 - * @return {String} The WKT representation  
219 - */  
220 - 'linestring': function (linestring) {  
221 - // Extraction of linestrings is the same as for points  
222 - return this.extract.point.apply(this, [linestring]);  
223 - },  
224 - /**  
225 - * Return a WKT string representing multiple chains (multilinestring) of atoms  
226 - * @param point {Array} Multiple of multiple x-and-y objects  
227 - * @return {String} The WKT representation  
228 - */  
229 - 'multilinestring': function (multilinestring) {  
230 - var i, parts = [];  
231 - for (i = 0; i < multilinestring.length; i += 1) {  
232 - parts.push('(' + this.extract.linestring.apply(this, [multilinestring[i]]) + ')');  
233 - }  
234 - return parts.join(',');  
235 - },  
236 - /**  
237 - * Return a WKT string representing multiple atoms in closed series (polygon)  
238 - * @param point {Array} Collection of ordered x-and-y objects  
239 - * @return {String} The WKT representation  
240 - */  
241 - 'polygon': function (polygon) {  
242 - // Extraction of polygons is the same as for multipoints  
243 - return this.extract.multipoint.apply(this, [polygon]);  
244 - },  
245 - /**  
246 - * Return a WKT string representing multiple closed series (multipolygons) of multiple atoms  
247 - * @param point {Array} Collection of ordered x-and-y objects  
248 - * @return {String} The WKT representation  
249 - */  
250 - 'multipolygon': function (multipolygon) {  
251 - var i, parts = [];  
252 - for (i = 0; i < multipolygon.length; i += 1) {  
253 - parts.push('(' + this.extract.polygon.apply(this, [multipolygon[i]]) + ')');  
254 - }  
255 - return parts.join(',');  
256 - }  
257 - };  
258 -  
259 - /**  
260 - * This object contains functions as property names that ingest WKT  
261 - * strings into the internal representation.  
262 - */  
263 - this.ingest = {  
264 -  
265 - /**  
266 - * Return point feature given a point WKT fragment.  
267 - * @param str {String} A WKT fragment representing the point  
268 - */  
269 - 'point': function (str) {  
270 - var coords = trim(str).split(this.regExes.spaces);  
271 - // In case a parenthetical group of coordinates is passed...  
272 - return [{ // ...Search for numeric substrings  
273 - x: parseFloat(this.regExes.numeric.exec(coords[0])[0]),  
274 - y: parseFloat(this.regExes.numeric.exec(coords[1])[0])  
275 - }];  
276 - },  
277 -  
278 - /**  
279 - * Return a multipoint feature given a multipoint WKT fragment.  
280 - * @param str {String} A WKT fragment representing the multipoint  
281 - */  
282 - 'multipoint': function (str) {  
283 - var i, components, points;  
284 - components = [];  
285 - points = trim(str).split(this.regExes.comma);  
286 - for (i = 0; i < points.length; i += 1) {  
287 - components.push(this.ingest.point.apply(this, [points[i]]));  
288 - }  
289 - return components;  
290 - },  
291 -  
292 - /**  
293 - * Return a linestring feature given a linestring WKT fragment.  
294 - * @param str {String} A WKT fragment representing the linestring  
295 - */  
296 - 'linestring': function (str) {  
297 - var i, multipoints, components;  
298 -  
299 - // In our x-and-y representation of components, parsing  
300 - // multipoints is the same as parsing linestrings  
301 - multipoints = this.ingest.multipoint.apply(this, [str]);  
302 -  
303 - // However, the points need to be joined  
304 - components = [];  
305 - for (i = 0; i < multipoints.length; i += 1) {  
306 - components = components.concat(multipoints[i]);  
307 - }  
308 - return components;  
309 - },  
310 -  
311 - /**  
312 - * Return a multilinestring feature given a multilinestring WKT fragment.  
313 - * @param str {String} A WKT fragment representing the multilinestring  
314 - */  
315 - 'multilinestring': function (str) {  
316 - var i, components, line, lines;  
317 - components = [];  
318 - lines = trim(str).split(this.regExes.parenComma);  
319 - for (i = 0; i < lines.length; i += 1) {  
320 - line = lines[i].replace(this.regExes.trimParens, '$1');  
321 - components.push(this.ingest.linestring.apply(this, [line]));  
322 - }  
323 - return components;  
324 - },  
325 -  
326 - /**  
327 - * Return a polygon feature given a polygon WKT fragment.  
328 - * @param str {String} A WKT fragment representing the polygon  
329 - */  
330 - 'polygon': function (str) {  
331 - var i, j, components, subcomponents, ring, rings;  
332 - rings = trim(str).split(this.regExes.parenComma);  
333 - components = []; // Holds one or more rings  
334 - for (i = 0; i < rings.length; i += 1) {  
335 - ring = rings[i].replace(this.regExes.trimParens, '$1').split(this.regExes.comma);  
336 - subcomponents = []; // Holds the outer ring and any inner rings (holes)  
337 - for (j = 0; j < ring.length; j += 1) {  
338 - // Split on the empty space or '+' character (between coordinates)  
339 - subcomponents.push({  
340 - x: parseFloat(ring[j].split(this.regExes.spaces)[0]),  
341 - y: parseFloat(ring[j].split(this.regExes.spaces)[1])  
342 - });  
343 - }  
344 - components.push(subcomponents);  
345 - }  
346 - return components;  
347 - },  
348 -  
349 - /**  
350 - * Return a multipolygon feature given a multipolygon WKT fragment.  
351 - * @param str {String} A WKT fragment representing the multipolygon  
352 - */  
353 - 'multipolygon': function (str) {  
354 - var i, components, polygon, polygons;  
355 - components = [];  
356 - polygons = trim(str).split(this.regExes.doubleParenComma);  
357 - for (i = 0; i < polygons.length; i += 1) {  
358 - polygon = polygons[i].replace(this.regExes.trimParens, '$1');  
359 - components.push(this.ingest.polygon.apply(this, [polygon]));  
360 - }  
361 - return components;  
362 - },  
363 -  
364 - /**  
365 - * Return an array of features given a geometrycollection WKT fragment.  
366 - * @param str {String} A WKT fragment representing the geometry collection  
367 - */  
368 - 'geometrycollection': function (str) {  
369 - console.log('The geometrycollection WKT type is not yet supported.');  
370 - }  
371 -  
372 - }; // eo ingest  
373 -  
374 - // An initial WKT string may be provided  
375 - if (initializer && typeof initializer === 'string') {  
376 - this.read(initializer);  
377 - } else if (this.fromGeometry) { // Or, an initial geometry object to be read  
378 - this.fromGeometry(initializer);  
379 - }  
380 -  
381 - } // eo WKt.Wkt  
382 -  
383 - }; // eo return  
384 -  
385 -}()); // eo Wkt