]> git.mxchange.org Git - friendica.git/blob - view/theme/diabook/js/jquery.mapquery.core.js
Merge pull request #2193 from fabrixxm/changelog
[friendica.git] / view / theme / diabook / js / jquery.mapquery.core.js
1 /* Copyright (c) 2011 by MapQuery Contributors (see AUTHORS for
2  * full list of contributors). Published under the MIT license.
3  * See https://github.com/mapquery/mapquery/blob/master/LICENSE for the
4  * full text of the license. */
5 (function ($) {
6 /**
7 # jquery.mapquery.core.js
8 The main MapQuery file. It contains the MapQuery constructor, the MapQuery.Map
9 constructor and the MapQuery.Layer constructor.
10
11
12 ### *$('selector')*.`mapQuery([options])`
13 _version added 0.1_
14 ####**Description**: initialise MapQuery and associate it with
15 the matched element
16
17 **options**  an object of key-value pairs with options for the map. Possible
18 pairs are:
19
20  * **layers** (array of MapQuery.Layer *or* MapQuery.Layer): Either an array 
21  or a single layer that should be added to the map
22  * **center** ({position: [x,y], zoom: z(int), box: [llx,lly,urx,ury]}):
23  Initially go to a certain location. At least one layer (in the `layers`
24  option) needs to be specified.
25
26 > Returns: $('selector') (jQuery object)
27
28
29 We can initialise MapQuery without any options, or for instance pass in a layer
30 object. The mapQuery function returns a jQuery object, to access the mapQuery object retrieve
31 the 'mapQuery' data object.
32
33      var map = $('#map').mapQuery(); //create an empty map
34      var map = $('#map').mapQuery({layers:[{type:'osm'}]); //create a map with osm
35
36      var mq = map.data('mapQuery'); //get the MapQuery object
37  */
38 $.MapQuery = $.MapQuery || {};
39
40 /**
41
42 ---
43
44 #MapQuery.Map
45
46 The MapQuery.Map object. It is automatically constructed from the options
47 given in the `mapQuery([options])` constructor. The Map object is refered
48 to as _map_ in the documentation.
49  */
50 $.MapQuery.Map = function(element, options) {
51     var self = this;
52     //If there are a maxExtent and a projection other than Spherical Mercator
53     //automagically set maxResolution if it is not set
54     //TODO smo 20110614: put maxExtent and maxResolution setting in the
55     //proper option building routine
56     if(options){
57     if(!options.maxResolution&&options.maxExtent&&options.projection){
58         options.maxResolution = (options.maxExtent[2]-options.maxExtent[0])/256;
59     }}
60     this.options = $.extend({}, new $.fn.mapQuery.defaults.map(), options);
61
62     this.element = element;
63     // TODO vmx 20110609: do proper options building
64     // TODO SMO 20110616: make sure that all projection strings are uppercase
65     // smo 20110620: you need the exact map options in the overviewmap widget
66     // as such we need to preserve them
67     this.olMapOptions = $.extend({}, this.options);
68     delete this.olMapOptions.layers;
69     delete this.olMapOptions.maxExtent;
70     delete this.olMapOptions.zoomToMaxExtent;
71     delete this.olMapOptions.center;
72
73     //TODO SMO20110630 the maxExtent is in mapprojection, decide whether or
74     //not we need to change it to displayProjection
75     this.maxExtent = this.options.maxExtent;
76     this.olMapOptions.maxExtent = new OpenLayers.Bounds(
77     this.maxExtent[0],this.maxExtent[1],this.maxExtent[2],this.maxExtent[3]);
78
79
80     this.projection = this.options.projection;
81     this.displayProjection = this.options.displayProjection;
82
83     OpenLayers.IMAGE_RELOAD_ATTEMPTS = 3;
84     OpenLayers.Util.onImageLoadErrorColor = "transparent";
85
86     // create the OpenLayers Map
87     this.olMap = new OpenLayers.Map(this.element[0], this.olMapOptions);
88
89     //OpenLayers doesn't want to return a maxExtent when there is no baselayer
90     //set (eg on an empty map, so we create a fake baselayer
91     this.olMap.addLayer(new OpenLayers.Layer('fake', {baseLayer: true}));
92
93     // Keep IDs of vector layer for select feature control
94     this.vectorLayers = [];
95     this.selectFeatureControl = null;
96     // Counts up to create unique IDs
97     this.idCounter = 0;
98
99     element.data('mapQuery', this);
100     this.layersList = {};
101
102     // To bind and trigger jQuery events
103     this.events = $({});
104
105     this.handlers = {
106         // Triggers the jQuery events, after the OpenLayers events
107         // happened without any further processing
108         simple: function(data) {
109             this.trigger(data.type);
110         }
111     };
112
113     // MapQuery doesn't bind all OpenLayers events automatically,
114     // but just the ones that make sense.
115     // Events that are left out intensionally are:
116     //  - changebaselayer: MapQuery doesn't have the concept of base layers
117     //  - mouseover, mouseout, mousemove: Handle those with jQuery on the
118     //        DOM level
119     // Some events can be triggered by MapQuery without listening to the
120     // OpenLayers events. This only works for events that are triggered
121     // by functionality that MapQuery implements in some custom way, e.g.
122     // (pre)addlayer, (pre)removelayer, changelayer.
123     // TODO vmx 20120309: Proper docs for the events, here's some quickly
124     // written info:
125     //  - generally spoken, the map events follow the OpeLayer events
126     //  - preaddlayer, movestart, move, moveend, zoomend: no additional
127     //        argument
128     //  - addlayer, preremovelayer, removelayer: layer as additional argument
129     //  - changelayer: layer and the property that changed as additional
130     //        argument. Possible values for the property are: position (in
131     //        the layer stack), opacity, visibility
132     //        Currently this event is always fired, even if the property
133     //        was only meant to be changed, but wasn't exctually changed.
134     //        I.e. that the event is fired even if you call
135     //        `layer.visible(true)` although the layer is already visible.
136     //        I'm (vmx) not sure if we want to change that :)
137     this.olMap.events.on({
138         scope: this,
139         movestart: this.handlers.simple,
140         move: this.handlers.simple,
141         moveend: this.handlers.simple,
142         zoomend: this.handlers.simple
143     });
144
145     // Add layers to the map
146     if (this.options.layers!==undefined) {
147         this.layers(this.options.layers);
148         // You can only go to some location if there were layers added
149         if (this.options.center!==undefined) {
150             this.center(this.options.center);
151         }
152     }
153
154     // zoom to the maxExtent of the map if no precise location was specified
155     if (this.options.zoomToMaxExtent && this.options.center===undefined) {
156         this.olMap.zoomToMaxExtent();
157     }
158 };
159
160 $.MapQuery.Map.prototype = {
161  /**
162 ###*map*.`layers([options])`
163 _version added 0.1_
164 ####**Description**: get/set the layers of the map
165
166 **options** an object of key-value pairs with options to create one or
167 more layers
168
169 >Returns: [layer] (array of MapQuery.Layer) _or_ false
170
171
172 The `.layers()` method allows us to attach layers to a mapQuery object. It takes
173 an options object with layer options. To add multiple layers, create an array of
174 layer options objects. If an options object is given, it will return the
175 resulting layer(s). We can also use it to retrieve all layers currently attached
176 to the map.
177
178 When adding layers, those are returned. If the creation is cancled by returning
179 `false` in the `preaddlayer` event, this function returns `false` to
180 intentionally break the chain instead of hiding errors subtly).
181
182
183      var osm = map.layers({type:'osm'}); //add an osm layer to the map
184      var layers = map.layers(); //get all layers of the map
185
186      */
187     layers: function(options) {
188         //var o = $.extend({}, options);
189         var self = this;
190         switch(arguments.length) {
191         case 0:
192             return this._allLayers();
193         case 1:
194             if (!$.isArray(options)) {
195                 return this._addLayer(options);
196             }
197             else {
198                 return $.map(options, function(layer) {
199                     return self._addLayer(layer);
200                 }).reverse();
201             }
202             break;
203         default:
204             throw('wrong argument number');
205         }
206     },
207     // Returns all layers as an array, sorted by there order in the map. First
208     // element in the array is the topmost layer
209     _allLayers: function() {
210         var layers = [];
211         $.each(this.layersList, function(id, layer) {
212             var item = [layer.position(), layer];
213             layers.push(item);
214         });
215         var sorted = layers.sort( function compare(a, b) {
216             return a[0] - b[0];
217         });
218         var result = $.map(sorted, function(item) {
219             return item[1];
220         });
221         return result.reverse();
222     },
223     _addLayer: function(options) {
224         var id = this._createId();
225         var layer = new $.MapQuery.Layer(this, id, options);
226         // NOTE vmx 20120305: Not sure if this is a good idea, or if it would
227         //     be better to include `options` with the preaddlayer event
228         if (this._triggerReturn('preaddlayer', [layer])===false) {
229             return false;
230         }
231         this.olMap.addLayer(layer.olLayer);
232
233         this.layersList[id] = layer;
234         if (layer.isVector) {
235             this.vectorLayers.push(id);
236         }
237         this._updateSelectFeatureControl(this.vectorLayers);
238
239         layer.trigger('addlayer');
240         return layer;
241     },
242     // Creates a new unique ID for a layer
243     _createId: function() {
244         return 'mapquery_' + this.idCounter++;
245     },
246     _removeLayer: function(id) {
247         var layer = this.layersList[id];
248         if (this._triggerReturn('preremovelayer', [layer])===false) {
249             return false;
250         }
251
252         // remove id from vectorlayer if it is there list
253         this.vectorLayers = $.grep(this.vectorLayers, function(elem) {
254             return elem != id;
255         });
256         this._updateSelectFeatureControl(this.vectorLayers);
257         this.olMap.removeLayer(layer.olLayer);
258
259         // XXX vmx: shouldn't the layer be destroyed() properly?
260         delete this.layersList[id];
261
262         layer.trigger('removelayer');
263         return this;
264     },
265 /**
266  ###*map*.`center([options])`
267 _version added 0.1_
268 ####**Description**: get/set the extent, zoom and position of the map
269
270  * **position** the position as [x,y] in displayProjection (default EPSG:4326)
271 to center the map at
272  * **zoom** the zoomlevel as integer to zoom the map to
273  * **box** an array with the lower left x, lower left y, upper right x,
274 upper right y to zoom the map to,
275 this will take precedent when conflicting with any of the above values
276  * **projection** the projection the coordinates are in, default is
277 the displayProjection
278
279 >Returns: {position: [x,y], zoom: z(int), box: [llx,lly,urx,ury]}
280
281
282 The `.center()` method allows us to move to map to a specific zoom level,
283 specific position or a specific extent. We can specify the projection of the
284 coordinates to override the displayProjection. For instance you want to show
285 the coordinates in 4326, but you have a dataset in EPSG:28992
286 (dutch projection). We can also retrieve the current zoomlevel, position and
287 extent from the map. The coordinates are returned in displayProjection.
288
289
290      var center = map.center(); //get the current zoom, position and extent
291      map.center({zoom:4}); //zoom to zoomlevel 4
292      map.center({position:[5,52]}); //pan to point 5,52
293      map.center(box:[-180,-90,180,90]); //zoom to the box -180,-900,180,90
294      //pan to point 125000,485000 in dutch projection
295      map.center({position:[125000,485000],projection:'EPSG:28992'});
296  */
297     center: function (options) {
298         var position;
299         var mapProjection = new OpenLayers.Projection(this.projection);
300         // Determine source projection
301         var sourceProjection = null;
302         var zoom;
303         var box;
304         if(options && options.projection) {
305             sourceProjection = options.projection.CLASS_NAME ===
306             'OpenLayers.Projection' ? options.projection :
307             new OpenLayers.Projection(options.projection);
308         } else {
309             var displayProjection = this.displayProjection;
310             if(!displayProjection) {
311                 // source == target
312                 sourceProjection = new OpenLayers.Projection('EPSG:4326');
313             } else {
314                 sourceProjection = displayProjection.CLASS_NAME ===
315             'OpenLayers.Projection' ? displayProjection :
316             new OpenLayers.Projection(displayProjection);
317             }
318         }
319
320         // Get the current position
321         if (arguments.length===0) {
322             position = this.olMap.getCenter();
323             zoom = this.olMap.getZoom();
324             box = this.olMap.getExtent();
325
326             if (!mapProjection.equals(sourceProjection)) {
327                 position.transform(mapProjection, sourceProjection);
328             }
329             box.transform(mapProjection,sourceProjection);
330             box = box!==null ? box.toArray() : [];
331             return {
332                 position: [position.lon, position.lat],
333                 zoom: this.olMap.getZoom(),
334                 box: box
335             };
336         }
337
338         // Zoom to the extent of the box
339         if (options.box!==undefined) {
340             box = new OpenLayers.Bounds(
341                 options.box[0], options.box[1],options.box[2], options.box[3]);
342             if (!mapProjection.equals(sourceProjection)) {
343                 box.transform(sourceProjection,mapProjection);
344             }
345             this.olMap.zoomToExtent(box);
346
347         }
348         // Only zoom is given
349         else if (options.position===undefined) {
350             this.olMap.zoomTo(options.zoom);
351         }
352         // Position is given, zoom maybe as well
353         else {
354             position = new OpenLayers.LonLat(options.position[0],
355                                              options.position[1]);
356             if (!mapProjection.equals(sourceProjection)) {
357                 position.transform(sourceProjection, mapProjection);
358             }
359             // options.zoom might be undefined, so we are good to
360             // pass it on
361             this.olMap.setCenter(position, options.zoom);
362         }
363     },
364     _updateSelectFeatureControl: function(layerIds) {
365         var vectorLayers = [];
366         var layersList = this.layersList;
367         if (this.selectFeatureControl!==null) {
368             this.selectFeatureControl.deactivate();
369             this.selectFeatureControl.destroy();
370         }
371         $.each(layerIds, function() {
372             vectorLayers.push(layersList[this].olLayer);
373         });
374         this.selectFeatureControl = new OpenLayers.Control.SelectFeature(
375             vectorLayers);
376         this.olMap.addControl(this.selectFeatureControl);
377         this.selectFeatureControl.activate();
378     },
379     // This function got a bit too clever. The reason is, that jQuery's
380     // bind() is overloaded with so many possible combinations of arguments.
381     // And, of course, MapQuery wants to support them all
382     // The essence of the function is to wrap the original callback into
383     // the correct scope
384     bind: function(types, data, fn) {
385         var self = this;
386
387         // A map of event/handle pairs, wrap each of them
388         if(arguments.length===1) {
389             var wrapped = {};
390             $.each(types, function(type, fn) {
391                 wrapped[type] = function() {
392                     return fn.apply(self, arguments);
393                 };
394             });
395             this.events.bind.apply(this.events, [wrapped]);
396         }
397         else {
398             var args = [types];
399             // Only callback given, but no data (types, fn), hence
400             // `data` is the function
401             if(arguments.length===2) {
402                 fn = data;
403             }
404             else {
405                 if (!$.isFunction(fn)) {
406                     throw('bind: you might have a typo in the function name');
407                 }
408                 // Callback and data given (types, data, fn), hence include
409                 // the data in the argument list
410                 args.push(data);
411             }
412
413             args.push(function() {
414                 return fn.apply(self, arguments);
415             });
416
417             this.events.bind.apply(this.events, args);
418         }
419
420         //this.events.bind.call(this.events, types, function() {
421         //    data.apply(self, arguments);
422         //});
423         //this.events.bind.call(this.events, types, function() {
424         //    data.apply(self, arguments);
425         //});
426
427         //this.events.bind.apply(this.events, arguments);
428         //this.events.bind.call(this.events, types, $.proxy(data, self));
429         //this.events.bind.apply(this.events, arguments);//.bind(this);
430         //this.events.bind.apply(this.events, $.proxy(arguments));//.bind(this);
431         //this.events.bind.apply(this.events, $.proxy(arguments));//.bind(this);
432         //this.events.bind(types, data, fn);//.bind(this);
433         //this.events.bind.call(this.events, types, data, fn);//.bind(this);
434         return this;
435     },
436 /**
437 ###*map*.`trigger(name [, parameters])`
438 _version added 0.2_
439 ####**Description**: triggers an event on the map
440
441  * **name** the name of the event
442  * **parameters** additional parameters that will be passed on with the event
443
444 >Returns: map (MapQuery.Map)
445
446 To subscribe to the triggered events, you need to bind to the mapuuu.
447
448      map.bind('myEvent', function(evt) {
449          console.log('the values are: ' + evt.data[0] + ' and ' + evt.data[1])
450      });
451      map.trigger('myEvent', 'some', 'values');
452 */
453     trigger: function() {
454         // There is no point in using trigger() insted of triggerHandler(), as
455         // we don't fire native events
456         this.events.triggerHandler.apply(this.events, arguments);
457         return this;
458     },
459     // Basically a trigger that returns the return value of the last listener
460     _triggerReturn: function() {
461         return this.events.triggerHandler.apply(this.events, arguments);
462     },
463     destroy: function() {
464         this.olMap.destroy();
465         this.element.removeData('mapQuery');
466     }
467 };
468 /**
469
470 ---
471
472 #MapQuery.Layer
473
474 The MapQuery.Layer object. It is constructed with layer options object in the
475 map.`layers([options])` function or by passing a `layer:{options}` object in
476 the `mapQuery()` constructor. The Layer object is refered to as _layer_ in the
477 documentation.
478  */
479 $.MapQuery.Layer = function(map, id, options) {
480
481     var self = this;
482     // apply default options that are not specific to a layer
483
484     this.id = id;
485     this.label = options.label || this.id;
486     // a reference to the map object is needed as it stores e.g. the list
487     // of all layers (and we need to keep track of it, if we delete a
488     // layer)
489     this.map = map;
490
491     // true if this layer is a vector layer
492     this.isVector = false;
493
494     // to bind and trigger jQuery events
495     this.events = $({});
496
497     this.handlers = {
498         // Triggers the jQuery events, after the OpenLayers events
499         // happened without any further processing
500         simple: function(data) {
501             this.trigger(data.type);
502         },
503         // All OpenLayers events that are triggered by user interaction,
504         // like clicking somewhere or selecting a feature, need to be
505         // handled in a special way. Those OpenLayers events will then be
506         // triggered by MapQuery as well
507         // In case of the "featureselected" event, this means that the
508         // logic of handling the event is completely within the event
509         // handler. When ".select()" on a feature is called, it will just
510         // trigger the OpenLayers "featureselected" event, whose handler
511         // will then trigger the corresponding jQuery event.
512         includeFeature: function(data) {
513             var feature = new $.MapQuery.Feature(this, {olFeature:
514                                                         data.feature});
515             this.trigger(data.type, [feature]);
516         },
517         prependLayer: function(data) {
518             this.trigger('layer' + data.type);
519         }
520     };
521
522
523     // create the actual layer based on the options
524     // Returns layer and final options for the layer (for later re-use,
525     // e.g. zoomToMaxExtent).
526     var res = $.MapQuery.Layer.types[options.type.toLowerCase()].call(
527         this, options);
528     this.olLayer = res.layer;
529     this.options = res.options;
530
531     // Some good documentation for the events is needed. Here is a short
532     // description on how the current events compare to the OpenLayer
533     // events on the layer:
534     // - added, remove: not needed, there's addlayer and removelayer
535     // - visibilitychanged: not needed, there's the changelayer event
536     // - move, moveend: not needed as you get them from the map, not the layer
537     // - loadstart, loadend: renamed to layerloadstart, layerloadend
538     this.olLayer.events.on({
539         scope: this,
540         loadstart: this.handlers.prependLayer,
541         loadend: this.handlers.prependLayer,
542         featureselected: this.handlers.includeFeature,
543         featureunselected: this.handlers.includeFeature,
544         featureremoved: this.handlers.includeFeature
545     });
546
547     // To be able to retreive the MapQuery layer, when we only have the
548     // OpenLayers layer available. For example on the layeradded event.
549     // NOTE vmx 2012-02-26: Any nicer solution is welcome
550     this.olLayer.mapQueryId = this.id;
551 };
552
553 $.MapQuery.Layer.prototype = {
554 /**
555 ###*layer*.`down([delta])`
556 _version added 0.1_
557 ####**Description**: move the layer down in the layer stack of the map
558
559  * **delta** the amount of layers the layer has to move down in the layer
560 stack (default 1)
561
562 >Returns layer (MapQuery.Layer)
563
564
565 The `.down()` method is a shortcut method for `.position(pos)` which makes
566 it easier to move a layer down in the layerstack relative to its current
567 position. It takes an integer and will try to move the layer down the number of
568 places given. If delta is bigger than the current position in the stack, it
569 will put the layer at the bottom.
570
571
572      layer.down();  //move layer 1 place down
573      layer.down(3); //move layer 3 places down
574
575  */
576     down: function(delta) {
577         delta = delta || 1;
578         var pos = this.position();
579         pos = pos - delta;
580         if (pos<0) {pos = 0;}
581         this.position(pos);
582         return this;
583     },
584     // NOTE vmx: this would be pretty cool, but it's not easily possible
585     // you could use $.each($.geojq.layer())) instead, this is for pure
586     // convenience.
587     each: function () {},
588 /**
589 ###*layer*.`remove()`
590 _version added 0.2_
591 ####**Description**: remove the layer from the map
592
593 >Returns: map (MapQuery.Map) or false
594
595
596 The `.remove()` method allows us to remove a layer from the map.
597 It returns the `map` object if the layer was removed, or `false` if the
598 removal was prevented in the preremovelayer event.
599
600      var id = layer.remove(); //remove this layer
601
602
603  */
604     remove: function() {
605         // remove references to this layer that are stored in the
606         // map object
607         return this.map._removeLayer(this.id);
608     },
609 /**
610 ###*layer*.`position([position])`
611 _version added 0.1_
612 ####**Description**: get/set the `position` of the layer in the layer
613 stack of the map
614
615  * **position** an integer setting the new position of the layer in the layer stack
616
617 >Returns: position (integer) _or_ layer (MapQuery.Layer)
618
619
620 The `.position()` method allows us to change the position of the layer in the
621 layer stack. It will take into account the hidden baselayer that is used by
622 OpenLayers. The lowest layer is position 0. If no position is given, it will
623 return the current postion.
624
625
626      var pos =  layer.position(); //get position of layer in the layer stack
627      layer.position(2); //put layer on position 2 in the layer stack
628
629  */
630     position: function(pos) {
631         if (pos===undefined) {
632             return this.map.olMap.getLayerIndex(this.olLayer)-1;
633         }
634         else {
635             this.map.olMap.setLayerIndex(this.olLayer, pos+1);
636             this.trigger('changelayer', ['position']);
637             return this;
638         }
639     },
640 /**
641 ###*layer*.`up([delta])`
642 _version added 0.1_
643 ####**Description**: move the layer up in the layer stack of the map
644
645  * **delta** the amount of layers the layer has to move up in the layer
646 stack (default 1)
647
648 >Returns: layer (MapQuery.Layer)
649
650
651 The `.up()` method is a shortcut method for `.position(pos)` which makes
652 it easier to move a layer up in the layerstack relative to its current
653 position. It takes an integer and will move the layer up the number of places
654 given.
655
656
657
658      layer.up();  //move layer 1 place up
659      layer.up(3); //move layer 3 places up
660 */
661     up: function(delta) {
662         delta = delta || 1;
663         var pos = this.position();
664         pos = pos + delta;
665         this.position(pos);
666         return this;
667     },
668 /**
669 ###*layer*.`visible([visible])`
670 _version added 0.1_
671 ####**Description**: get/set the `visible` state of the layer
672
673  * **visible** a boolean setting the visibility of the layer
674
675 >Returns: visible (boolean)
676
677
678 The `.visible()` method allows us to change the visibility of the layer.
679 If no visible is given, it will return the current visibility.
680
681
682      var vis =  layer.visible(); //get the visibility of layer
683      layer.visible(true); //set visibility of layer to true
684
685  */
686     visible: function(vis) {
687         if (vis===undefined) {
688             return this.olLayer.getVisibility();
689         }
690         else {
691             this.olLayer.setVisibility(vis);
692             this.trigger('changelayer', ['visibility']);
693             return this;
694         }
695     },
696 /**
697 ###*layer*.`opacity([opacity])`
698 _version added 0.1_
699 ####**Description**: get/set the `opacity` of the layer
700
701  * **position** a float [0-1] setting the opacity of the layer
702
703 >Returns: opacity (float) _or_ layer (MapQuery.Layer)
704
705
706 The `.opacity()` method allows us to change the opacity of the layer.
707 If no opacity is given, it will return the current opacity.
708
709
710      var opac =  layer.opacity(); //get opacity of layer
711      layer.opacity(0.7); //set opacity of layer to 0.7
712
713  */
714     opacity: function(opac) {
715         if (opac===undefined) {
716             // this.olLayer.opacity can be null if never
717             // set so return the visibility
718             var value = this.olLayer.opacity ?
719             this.olLayer.opacity : this.olLayer.getVisibility();
720             return value;
721         }
722         else {
723             this.olLayer.setOpacity(opac);
724             this.trigger('changelayer', ['opacity']);
725             return this;
726         }
727     },
728     // every event gets the layer passed in
729     bind: function() {
730         // Use the same bind function as for the map
731         this.map.bind.apply(this, arguments);
732         return this;
733     },
734 /**
735 ###*layer*.`trigger(name [, parameters])`
736 _version added 0.2_
737 ####**Description**: triggers an event on the layer and map
738
739  * **name** the name of the event
740  * **parameters** additional parameters that will be passed on with the event
741
742 >Returns: layer (MapQuery.Layer)
743
744 The events get triggered on the layer as well as on the map. To subscribe to
745 the triggered events, you can either bind to the layer or the map. If bound
746 to the map, the second argument in the bind will be the layer the event
747 came from
748
749      layer.bind('myEvent', function(evt) {
750          console.log('the values are: ' + evt.data[0] + ' and ' + evt.data[1])
751      });
752      map.bind('myEvent', function(evt, layer) {
753          console.log('the values are: ' + evt.data[0] + ' and ' + evt.data[1])
754      });
755      layer.trigger('myEvent', 'some', 'values');
756 */
757     trigger: function() {
758         var args = Array.prototype.slice.call(arguments);
759         this.events.triggerHandler.apply(this.events, args);
760
761         this._addLayerToArgs(args);
762
763         this.map.events.triggerHandler.apply(this.map.events, args);
764         return this;
765     },
766     // Basically a trigger that returns the return value of the last listener
767     _triggerReturn: function() {
768         var args = Array.prototype.slice.call(arguments);
769         var ret = this.events.triggerHandler.apply(this.events, args);
770         if (ret !== undefined) {
771             return ret;
772         }
773
774         this._addLayerToArgs(args);
775         return this.events.triggerHandler.apply(this.map.events, args);
776     },
777     // Adds the current layer to the event arguments, so that it is included
778     // in the event on the map
779     _addLayerToArgs: function(args) {
780         // Add layer for the map event
781         if (args.length===1) {
782             args.push([this]);
783         }
784         else {
785             args[1].unshift(this);
786         }
787     },
788 /**
789 ###*layer*.`features([options])`
790 _version added 0.2.0_
791 ####**Description**: get/set the features of a (vector) layer
792
793 **options** an object of key-value pairs with options to create one or
794 more features
795
796 >Returns: [features] (array of MapQuery.Feature)
797
798
799 The `.features()` method allows us to attach features to a mapQuery layer
800 object. It takes an options object with feature options. To add multiple
801 features, create an array of feature options objects. If an options object
802 is given, it will return the resulting feature(s). We can also use it to
803 retrieve all features currently attached to the layer.
804
805
806      // add an (vector) json layer to the map
807      var jsonlayer = map.layers({type:'json'});
808      // add a feature to the layer
809      jsonlayer.features({geometry: {type: "Point", coordinates: [5.3, 7.4]}});
810      // get all features of a layer (sorted with first added feature at the beginning
811      var features = jsonlayer.features();
812 */
813     features: function(options) {
814         var self = this;
815         switch(arguments.length) {
816         // return all features
817         case 0:
818             return this._allFeatures();
819         // add new feature(s)
820         case 1:
821             if (!$.isArray(options)) {
822                 return this._addFeature(options);
823             }
824             else {
825                 return $.map(options, function(feature) {
826                     return self._addFeature(feature);
827                 });
828             }
829             break;
830         default:
831             throw('wrong argument number');
832         }
833     },
834     _allFeatures: function() {
835         var layer = this;
836         return $.map(layer.olLayer.features, function(feature) {
837             return new $.MapQuery.Feature(layer, {olFeature: feature});
838         });
839     },
840     _addFeature: function(options) {
841         var feature = new $.MapQuery.Feature(this, options);
842         // NOTE vmx 2012-04-19: Not sure if this is a good idea, or if it would
843         //     be better to include `options` with the preaddfeature event
844         if (this._triggerReturn('preaddfeature', [feature])===false) {
845             return false;
846         }
847         this.olLayer.addFeatures(feature.olFeature);
848         this.trigger('addfeature', [feature]);
849         return feature;
850     }
851 };
852
853 /**
854 #MapQuery.Feature
855
856 The MapQuery.Feature object. It is constructed with a feature options object
857 in the layer.`features([options])` function. The Feautre object is refered to
858 as _feature_ in the documentation.
859
860 TODO vmx 20110905: Support other geometry types than GeoJSON
861 options:
862  * geometry: A GeoJSON geometry
863  * properties: Properties for the feature
864 */
865 // Not in the pulic API docs: You can pass in as options:
866 //  * olFeature: This will wrap the olFeature in a MapQuery feature
867 $.MapQuery.Feature = function(layer, options) {
868     // The ID is the
869     this._id = layer.map._createId();
870     this.layer = layer;
871
872     // Feature already exists on the layer, it just needs to be wrapped
873     // to an MapQuery feature
874     if (options.olFeature) {
875         this.olFeature = options.olFeature;
876     }
877     else {
878         // XXX vmx 20110905: Different feature types might make sense:
879         //     (Geo)JSON, KML, WKT
880         // vmx 2012-04-14: I changed my mind quite some time ago. We should onlu
881         //     support GeoJSON and let the user easily transfrom their format
882         //     (e.g. KML) to GeoJSON, before they add a feature to the layer
883         var GeoJSON = new OpenLayers.Format.GeoJSON();
884         var geometry = GeoJSON.parseGeometry(options.geometry);
885         geometry.transform(
886             new OpenLayers.Projection(this.layer.map.displaProjection),
887             new OpenLayers.Projection(this.layer.map.projection));
888
889         this.olFeature = new OpenLayers.Feature.Vector(geometry,
890             options.properties);
891     }
892
893     // Modify the features to be more practical
894     // e.g. copy properties that should be easily accessed from the
895     // outside, out of the olLayer and to the feature level
896     this.properties = $.extend(true, {}, this.olFeature.attributes);
897     this.geometry = $.parseJSON(
898         new OpenLayers.Format.GeoJSON().write(this.olFeature.geometry));
899
900     return this;
901 };
902
903 $.MapQuery.Feature.prototype = {
904 /**
905 ###*feature*.`remove()`
906 _version added 0.2.0_
907 ####**Description**: remove the feature from the layer
908
909 >Returns: layer (layer) or false
910
911
912 The `.remove()` method allows us to remove a feature from the layer.
913 It returns the `layer` object if the feature was removed, or `false` if the
914 removal was prevented in the preremovefeature event.
915
916      // add a feature to a layer
917      var feature = layer.features({geometry: {type: "Point", coordinates: [5.3, 7.4]}});
918      // remove the feature again
919      feature.remove();
920 */
921     remove: function() {
922         if (this.layer._triggerReturn('preremovefeature', [this])===false) {
923             return false;
924         }
925         this.layer.olLayer.removeFeatures(this.olFeature);
926         // The `removefeature` event is triggered by an OpenLayes event handler
927         return this.layer;
928     },
929 /**
930 ###*feature*.`select(exclusive)`
931 _version added 0.2.0_
932 ####**Description**: select a feature
933
934 **exclusive** (boolean, default: true) True means that all other features get
935 deselectd
936
937 >Returns: layer (layer)
938
939
940 The `.select()` method allows us to select a feature from the layer.
941 A `featureselected` will be fired.
942
943      // add a feature to a layer
944      var feature = layer.features({geometry: {type: "Point", coordinates: [5.3, 7.4]}});
945      // select the feature again
946      feature.select();
947 */
948     select: function(exclusive) {
949         if (exclusive===undefined || exclusive===true) {
950             this.layer.map.selectFeatureControl.unselectAll();
951         }
952         this.layer.map.selectFeatureControl.select(this.olFeature);
953     },
954 /**
955 ###*feature*.`unselect()`
956 _version added 0.2.0_
957 ####**Description**: unselect a feature
958
959 >Returns: layer (layer)
960
961
962 The `.unselect()` method allows us to unselect a feature from the layer.
963 A `featureunselected` will be fired.
964
965      // add a feature to a layer
966      var feature = layer.features({geometry: {type: "Point", coordinates: [5.3, 7.4]}});
967      // select the feature
968      feature.select();
969      // unselect the feature again
970      feature.unselect();
971 */
972     unselect: function() {
973         this.layer.map.selectFeatureControl.unselect(this.olFeature);
974     }
975 };
976
977 $.fn.mapQuery = function(options) {
978     return this.each(function() {
979         var instance = $.data(this, 'mapQuery');
980         if (!instance) {
981             $.data(this, 'mapQuery', new $.MapQuery.Map($(this), options));
982         }
983     });
984 };
985
986 $.extend($.MapQuery.Layer, {
987     types: {
988 /**
989 ###*layer* `{type:bing}`
990 _version added 0.1_
991 ####**Description**: create a Bing maps layer
992
993  * **view** a string ['road','hybrid','satellite'] to define which Bing maps
994 layer to use (default road)   
995  * **key** Bing Maps API key for your application. Get you own at
996 http://bingmapsportal.com/ 
997  * **label** string with the name of the layer
998
999
1000       layers:[{
1001             type:'bing',      //create a bing maps layer
1002             view:'satellite', //use the bing satellite layer
1003             key:'ArAGGPJ16xm0RX' //the Bing maps API key
1004             }]
1005
1006 */
1007         bing: function(options) {
1008             var o = $.extend(true, {}, $.fn.mapQuery.defaults.layer.all,
1009                 $.fn.mapQuery.defaults.layer.bing,
1010                 options);
1011             var view = o.view;
1012             switch(view){
1013                 case 'road':
1014                     view = 'Road'; break;
1015                 case 'hybrid':
1016                     view = 'AerialWithLabels'; break;
1017                 case 'satellite':
1018                     view = 'Aerial'; break;
1019             }
1020             return {
1021                 layer: new OpenLayers.Layer.Bing({type:view,key:o.key}),
1022                 options: o
1023             };
1024         },
1025         //Not sure this one is worth pursuing works with ecwp:// & jpip:// urls
1026         //See ../lib/NCSOpenLayersECWP.js
1027         ecwp: function(options) {
1028             var o = $.extend(true, {}, $.fn.mapQuery.defaults.layer.all,
1029                     $.fn.mapQuery.defaults.layer.raster,
1030                     options);
1031             return {
1032                 layer: new OpenLayers.Layer.ECWP(o.label, o.url, o),
1033                 options: o
1034             };
1035         },
1036 /**
1037 ###*layer* `{type:google}`
1038 _version added 0.1_
1039 ####**Description**: create a Google maps layer
1040
1041  * **view** a string ['road','hybrid','satellite'] to define which Google maps
1042 layer to use (default road)
1043  * **label** string with the name of the layer
1044
1045
1046 *Note* you need to include the google maps v3 API in your application by adding
1047 `<script src="http://maps.google.com/maps/api/js?v=3.5&amp;sensor=false"type="text/javascript"></script>`
1048
1049
1050       layers:[{
1051             type:'google',      //create a google maps layer
1052             view:'hybrid' //use the google hybridlayer
1053             }]
1054
1055 */
1056         google: function(options) {
1057             var o = $.extend(true, {}, $.fn.mapQuery.defaults.layer.all,
1058                     $.fn.mapQuery.defaults.layer.google,
1059                     options);
1060             var view = o.view;
1061             switch(view){
1062                 case 'road':
1063                     view = google.maps.MapTypeId.ROADMAP; break;
1064                 case 'terrain':
1065                     view = google.maps.MapTypeId.TERRAIN; break;
1066                 case 'hybrid':
1067                     view = google.maps.MapTypeId.HYBRID; break;
1068                 case 'satellite':
1069                     view = google.maps.MapTypeId.SATELLITE; break;
1070             }
1071             return {
1072                 layer: new OpenLayers.Layer.Google({type:view}),
1073                 options: o
1074             };
1075         },
1076 /**
1077 ###*layer* `{type:vector}`
1078 _version added 0.1_
1079 ####**Description**: create a vector layer
1080
1081  * **label** string with the name of the layer
1082
1083
1084       layers:[{
1085             type:'vector'     //create a vector layer
1086             }]
1087
1088 */
1089         vector: function(options) {
1090             var o = $.extend(true, {}, $.fn.mapQuery.defaults.layer.all,
1091                     $.fn.mapQuery.defaults.layer.vector,
1092                     options);
1093             this.isVector = true;
1094             return {
1095                 layer: new OpenLayers.Layer.Vector(o.label),
1096                 options: o
1097             };
1098         },
1099 /**
1100 ###*layer* `{type:json}`
1101 _version added 0.1_
1102 ####**Description**: create a JSON layer
1103
1104  * **url** a string pointing to the location of the JSON data
1105  * **strategies** a string ['bbox','cluster','filter','fixed','paging','refresh','save']
1106 stating which update strategy should be used (default fixed)
1107 (see also http://dev.openlayers.org/apidocs/files/OpenLayers/Strategy-js.html)
1108  * **projection** a string with the projection of the JSON data (default EPSG:4326)
1109  * **styleMap** {object} the style to be used to render the JSON data    
1110  * **label** string with the name of the layer
1111
1112
1113       layers:[{
1114             type: 'JSON',
1115             url: 'data/reservate.json',
1116             label: 'reservate'
1117             }]
1118
1119 */
1120         json: function(options) {
1121             var o = $.extend(true, {}, $.fn.mapQuery.defaults.layer.all,
1122                 $.fn.mapQuery.defaults.layer.vector,
1123                 options);
1124             this.isVector = true;
1125             var strategies = [];
1126             for (var i in o.strategies) {
1127                 if(o.strategies.hasOwnProperty(i)) {
1128                     switch(o.strategies[i].toLowerCase()) {
1129                     case 'bbox':
1130                         strategies.push(new OpenLayers.Strategy.BBOX());
1131                    break;
1132                     case 'cluster':
1133                         strategies.push(new OpenLayers.Strategy.Cluster());
1134                    break;
1135                     case 'filter':
1136                         strategies.push(new OpenLayers.Strategy.Filter());
1137                    break;
1138                     case 'fixed':
1139                         strategies.push(new OpenLayers.Strategy.Fixed());
1140                    break;
1141                     case 'paging':
1142                         strategies.push(new OpenLayers.Strategy.Paging());
1143                    break;
1144                     case 'refresh':
1145                         strategies.push(new OpenLayers.Strategy.Refresh());
1146                    break;
1147                     case 'save':
1148                         strategies.push(new OpenLayers.Strategy.Save());
1149                    break;
1150                     }
1151                 }
1152             }
1153             var protocol;
1154
1155             var params = {
1156                 strategies: strategies,
1157                 projection: o.projection || 'EPSG:4326',
1158                 styleMap: o.styleMap
1159             };
1160
1161             if (o.url) {
1162                 // only use JSONP if we use http(s)
1163                 if (o.url.match(/^https?:\/\//)!==null &&
1164                     !$.MapQuery.util.sameOrigin(o.url)) {
1165                     protocol = 'Script';
1166                 }
1167                 else {
1168                     protocol = 'HTTP';
1169                 }
1170                 params.protocol = new OpenLayers.Protocol[protocol]({
1171                     url: o.url,
1172                     format: new OpenLayers.Format.GeoJSON()
1173                 });
1174             };
1175
1176             var layer = new OpenLayers.Layer.Vector(o.label, params);
1177             return {
1178                 layer: layer,
1179                 options: o
1180             };
1181         },
1182 /**
1183 ###*layer* `{type:osm}`
1184 _version added 0.1_
1185 ####**Description**: create an OpenStreetMap layer
1186
1187  
1188  * **label** string with the name of the layer   
1189  * **url** A single URL (string) or an array of URLs to OSM-like server like 
1190 Cloudmade   
1191  * **attribution** A string to put some attribution on the map
1192
1193       layers:[{
1194         type: 'osm',
1195         url: [
1196           'http://a.tile.cloudmade.com/<yourapikey>/999/256/${z}/${x}/${y}.png',
1197           'http://b.tile.cloudmade.com/<yourapikey>/999/256/${z}/${x}/${y}.png',
1198           'http://c.tile.cloudmade.com/<yourapikey>/999/256/${z}/${x}/${y}.png'
1199         ],
1200         attribution: "Data &copy; 2009 <a href='http://openstreetmap.org/'>
1201           OpenStreetMap</a>. Rendering &copy; 2009 
1202           <a href='http://cloudmade.com'>CloudMade</a>."
1203         }]
1204
1205 */
1206         osm: function(options) {
1207             var o = $.extend(true, {}, $.fn.mapQuery.defaults.layer.all,
1208                 $.fn.mapQuery.defaults.layer.osm,
1209                 options);
1210             var label = options.label || undefined;
1211             var url = options.url || undefined;
1212             return {
1213                 layer: new OpenLayers.Layer.OSM(label, url, o),
1214                 options: o
1215             };
1216         },
1217 /**
1218 ###*layer* `{type:tms}`
1219 _version added 0.1_
1220 ####**Description**: create an OpenStreetMap layer
1221
1222  
1223  * **label** string with the name of the layer   
1224  * **url** A single URL (string) or an array of URLs to the TMS end point
1225  * **layer** The identifier for the <TileMap> as advertised by the service. 
1226  For example, if the service advertises a <TileMap> with ‘href=”http://tms.osgeo.org/1.0.0/vmap0”’, 
1227  the layer property would be set to “vmap0”.
1228  * **format** The image format (default png)
1229
1230       layers:[{
1231         type: 'tms',
1232         url: 'http://tilecache.osgeo.org/wms-c/Basic.py/',
1233         layer: 'basic'
1234         }]
1235
1236 */        
1237         tms: function(options) {
1238             var o = $.extend(true, {}, $.fn.mapQuery.defaults.layer.all,
1239                 $.fn.mapQuery.defaults.layer.tms,
1240                 options);
1241             var label = options.label || undefined;
1242             var url = options.url || undefined;
1243             var params = {
1244                 layername: o.layer,
1245                 type: o.format
1246             };
1247             return {
1248                 layer: new OpenLayers.Layer.TMS(label, url, params),
1249                 options: o
1250             };
1251         },
1252 /**
1253 ###*layer* `{type:wms}`
1254 _version added 0.1_
1255 ####**Description**: create a WMS layer
1256
1257  * **url** a string pointing to the location of the WMS service
1258  * **layers** a string with the name of the WMS layer(s)
1259  * **format** a string with format of the WMS image (default image/jpeg)
1260  * **transparent** a boolean for requesting images with transparency
1261  * **label** string with the name of the layer
1262  * **wms_parameters** an hashtable of extra GetMap query string parameters and parameter values
1263
1264
1265       layers:[{
1266             type:'wms',
1267             url:'http://vmap0.tiles.osgeo.org/wms/vmap0',
1268             layers:'basic'
1269             }]
1270
1271 */
1272         wms: function(options) {
1273             var o = $.extend(true, {}, $.fn.mapQuery.defaults.layer.all,
1274                     $.fn.mapQuery.defaults.layer.raster,
1275                     options);
1276             var params = {
1277                 layers: o.layers,
1278                 transparent: o.transparent,
1279                 format: o.format
1280             };
1281             if(typeof o.wms_parameters != "undefined"){
1282                 params = $.extend(params, o.wms_parameters);
1283             }
1284             return {
1285                 layer: new OpenLayers.Layer.WMS(o.label, o.url, params, o),
1286                 options: o
1287             };
1288         },
1289 //TODO complete this documentation
1290 /**
1291 ###*layer* `{type:wmts}`
1292 _version added 0.1_
1293 ####**Description**: create a WMTS (tiling) layer
1294
1295  * **url** a string pointing to the location of the WMTS service
1296  * **layer** a string with the name of the WMTS layer
1297  * **matrixSet** a string with one of the advertised matrix set identifiers
1298  * **style** a string with one of the advertised layer styles    
1299  * **label** string with the name of the layer
1300
1301
1302       layers:[{
1303             type:'wmts'
1304             }]
1305
1306 */
1307         wmts: function(options) {
1308             var o = $.extend(true, {}, $.fn.mapQuery.defaults.layer.all,
1309                     $.fn.mapQuery.defaults.layer.wmts);
1310             //smo 20110614 the maxExtent is set here with OpenLayers.Bounds
1311             if (options.sphericalMercator===true) {
1312                 $.extend(true, o, {
1313                     maxExtent: new OpenLayers.Bounds(
1314                         -128 * 156543.0339, -128 * 156543.0339,
1315                         128 * 156543.0339, 128 * 156543.0339),
1316                     maxResolution: 156543.0339,
1317                     numZoomLevels: 19,
1318                     projection: 'EPSG:900913',
1319                     units: 'm'
1320                 });
1321             }
1322             $.extend(true, o, options);
1323             // use by default all options that were passed in for the final
1324             // openlayers layer consrtuctor
1325             var params = $.extend(true, {}, o);
1326
1327             // remove trailing slash
1328             if (params.url.charAt(params.url.length-1)==='/') {
1329                 params.url = params.url.slice(0, params.url.length-1);
1330             }
1331             // if no options that influence the URL where set, extract them
1332             // from the given URL
1333             if (o.layer===undefined && o.matrixSet===undefined &&
1334                     o.style===undefined) {
1335                 var url = $.MapQuery.util.parseUri(params.url);
1336                 var urlParts = url.path.split('/');
1337                 var wmtsPath = urlParts.slice(urlParts.length-3);
1338                 params.url = url.protocol ? url.protocol + '//' : '';
1339                 params.url += url.authority +
1340                     // remove WMTS version (1.0.0) as well
1341                     urlParts.slice(0, urlParts.length-4).join('/');
1342                 params.layer = wmtsPath[0];
1343                 params.style = wmtsPath[1];
1344                 params.matrixSet = wmtsPath[2];
1345             }
1346             return {
1347                 layer: new OpenLayers.Layer.WMTS(params),
1348                 options: o
1349             };
1350         }
1351     }
1352 });
1353
1354 // default options for the map and layers
1355 $.fn.mapQuery.defaults = {
1356     // The controls for the map are per instance, therefore it need to
1357     // be an function that can be initiated per instance
1358     map: function() {
1359         return {
1360             // Remove quirky moveTo behavior, probably not a good idea in the
1361             // long run
1362             allOverlays: true,
1363             controls: [
1364                 // Since OL2.11 the Navigation control includes touch navigation as well
1365                 new OpenLayers.Control.Navigation({
1366                     documentDrag: true,
1367                     dragPanOptions: {
1368                         interval: 1,
1369                         enableKinetic: true
1370                     }
1371                 }),
1372                 new OpenLayers.Control.ArgParser(),
1373                 new OpenLayers.Control.Attribution(),
1374                 new OpenLayers.Control.KeyboardDefaults()
1375             ],
1376             format: 'image/png',
1377             maxExtent: [-128*156543.0339,
1378                 -128*156543.0339,
1379                 128*156543.0339,
1380                 128*156543.0339],
1381             maxResolution: 156543.0339,
1382             numZoomLevels: 19,
1383             projection: 'EPSG:900913',
1384             displayProjection: 'EPSG:4326',
1385             zoomToMaxExtent: true,
1386             units: 'm'
1387         };
1388     },
1389     layer: {
1390         all: {
1391             isBaseLayer: false,
1392         //in general it is kinda pointless to load tiles outside a maxextent
1393             displayOutsideMaxExtent: false
1394         },
1395         bing: {
1396             transitionEffect: 'resize',
1397             view: 'road',
1398             sphericalMercator: true
1399         },
1400         google: {
1401             transitionEffect: 'resize',
1402             view: 'road',
1403             sphericalMercator: true
1404         },
1405         osm: {
1406             transitionEffect: 'resize',
1407             sphericalMercator: true
1408         },
1409         tms: {
1410             transitionEffect: 'resize',
1411             format: 'png'
1412         },
1413         raster: {
1414             // options for raster layers
1415             transparent: true
1416         },
1417         vector: {
1418             // options for vector layers
1419             strategies: ['bbox']
1420         },
1421         wmts: {
1422             format: 'image/jpeg',
1423             requestEncoding: 'REST',
1424             sphericalMercator: false
1425         }
1426     }
1427 };
1428
1429 // Some utility functions
1430
1431 $.MapQuery.util = {};
1432 // http://blog.stevenlevithan.com/archives/parseuri (2010-12-18)
1433 // parseUri 1.2.2
1434 // (c) Steven Levithan <stevenlevithan.com>
1435 // MIT License
1436 // Edited to include the colon in the protocol, just like it is
1437 // with window.location.protocol
1438 $.MapQuery.util.parseUri = function (str) {
1439     var o = $.MapQuery.util.parseUri.options,
1440         m = o.parser[o.strictMode ? "strict" : "loose"].exec(str),
1441         uri = {},
1442         i = 14;
1443
1444     while (i--) {uri[o.key[i]] = m[i] || "";}
1445
1446     uri[o.q.name] = {};
1447     uri[o.key[12]].replace(o.q.parser, function ($0, $1, $2) {
1448         if ($1) {uri[o.q.name][$1] = $2;}
1449     });
1450
1451     return uri;
1452 };
1453 $.MapQuery.util.parseUri.options = {
1454     strictMode: false,
1455     key: ["source", "protocol", "authority", "userInfo", "user",
1456             "password", "host", "port", "relative", "path", "directory",
1457             "file", "query", "anchor"],
1458     q: {
1459         name: "queryKey",
1460         parser: /(?:^|&)([^&=]*)=?([^&]*)/g
1461     },
1462     parser: {
1463         strict: /^(?:([^:\/?#]+:))?(?:\/\/((?:(([^:@]*)(?::([^:@]*))?)?@)?([^:\/?#]*)(?::(\d*))?))?((((?:[^?#\/]*\/)*)([^?#]*))(?:\?([^#]*))?(?:#(.*))?)/,
1464         loose:  /^(?:(?![^:@]+:[^:@\/]*@)([^:\/?#.]+:))?(?:\/\/)?((?:(([^:@]*)(?::([^:@]*))?)?@)?([^:\/?#]*)(?::(\d*))?)(((\/(?:[^?#](?![^?#\/]*\.[^?#\/.]+(?:[?#]|$)))*\/?)?([^?#\/]*))(?:\?([^#]*))?(?:#(.*))?)/
1465         }
1466 };
1467 // Checks whether a URL conforms to the same origin policy or not
1468 $.MapQuery.util.sameOrigin = function(url) {
1469     var parsed = $.MapQuery.util.parseUri(url);
1470     parsed.protocol = parsed.protocol || 'file:';
1471     parsed.port = parsed.port || "80";
1472
1473     var current = {
1474         domain: document.domain,
1475         port: window.location.port,
1476         protocol: window.location.protocol
1477     };
1478     current.port = current.port || "80";
1479
1480     return parsed.protocol===current.protocol &&
1481         parsed.port===current.port &&
1482         // the current domain is a suffix of the parsed domain
1483         parsed.host.match(current.domain + '$')!==null;
1484 };
1485 })(jQuery);