Changeset 6127
- Timestamp:
- 02/08/08 14:41:49 (1 year ago)
- Files:
-
- sandbox/euzuro/pop/doc/authors.txt (modified) (1 diff)
- sandbox/euzuro/pop/examples/animated_panning.html (added)
- sandbox/euzuro/pop/lib/OpenLayers/Control.js (modified) (1 diff)
- sandbox/euzuro/pop/lib/OpenLayers/Control/DragFeature.js (modified) (10 diffs)
- sandbox/euzuro/pop/lib/OpenLayers/Control/ModifyFeature.js (modified) (7 diffs)
- sandbox/euzuro/pop/lib/OpenLayers/Control/Navigation.js (modified) (8 diffs)
- sandbox/euzuro/pop/lib/OpenLayers/Control/OverviewMap.js (modified) (7 diffs)
- sandbox/euzuro/pop/lib/OpenLayers/Format/SLD.js (modified) (3 diffs)
- sandbox/euzuro/pop/lib/OpenLayers/Map.js (modified) (6 diffs)
- sandbox/euzuro/pop/lib/OpenLayers/Rule.js (modified) (2 diffs)
- sandbox/euzuro/pop/lib/OpenLayers/Rule/Comparison.js (modified) (6 diffs)
- sandbox/euzuro/pop/lib/OpenLayers/Rule/FeatureId.js (modified) (1 diff)
- sandbox/euzuro/pop/lib/OpenLayers/Rule/Logical.js (modified) (6 diffs)
- sandbox/euzuro/pop/lib/OpenLayers/Style.js (modified) (7 diffs)
- sandbox/euzuro/pop/tests/Control/test_DragFeature.html (modified) (6 diffs)
- sandbox/euzuro/pop/tests/Control/test_ModifyFeature.html (modified) (2 diffs)
- sandbox/euzuro/pop/tests/Control/test_Navigation.html (modified) (1 diff)
- sandbox/euzuro/pop/tests/Control/test_OverviewMap.html (modified) (4 diffs)
- sandbox/euzuro/pop/tests/Control/test_PanZoom.html (modified) (8 diffs)
- sandbox/euzuro/pop/tests/Control/test_Permalink.html (modified) (6 diffs)
- sandbox/euzuro/pop/tests/Layer/test_Grid.html (modified) (1 diff)
- sandbox/euzuro/pop/tests/Layer/test_KaMap.html (modified) (1 diff)
- sandbox/euzuro/pop/tests/Rule/test_Logical.html (modified) (2 diffs)
- sandbox/euzuro/pop/tests/test_Map.html (modified) (1 diff)
- sandbox/euzuro/pop/tests/test_Style.html (modified) (1 diff)
Legend:
- Unmodified
- Added
- Removed
- Modified
- Copied
- Moved
sandbox/euzuro/pop/doc/authors.txt
r6105 r6127 35 35 Some portions of OpenLayers are used under the MIT license, availabie in 36 36 doc/licenses/MIT-LICENSE.txt. 37 38 Some portions of OpenLayers are Copyright 2001 Robert Penner, and are used 39 under the BSD license, available in doc/licenses/BSD-LICENSE.txt sandbox/euzuro/pop/lib/OpenLayers/Control.js
r5910 r6127 140 140 this.handler = null; 141 141 } 142 if(this.handlers) { 143 for(var key in this.handlers) { 144 if(this.handlers.hasOwnProperty(key) && 145 typeof this.handlers[key].destroy == "function") { 146 this.handlers[key].destroy(); 147 } 148 } 149 this.handlers = null; 150 } 142 151 if (this.map) { 143 152 this.map.removeControl(this); sandbox/euzuro/pop/lib/OpenLayers/Control/DragFeature.js
r5614 r6127 78 78 79 79 /** 80 * Property: dragHandler81 * {<OpenLayers.Handler.Drag>}82 */83 dragHandler: null,84 85 /**86 80 * Property: dragCallbacks 87 81 * {Object} The functions that are sent to the drag handler for callback. 88 82 */ 89 83 dragCallbacks: {}, 90 91 /**92 * Property: featureHandler93 * {<OpenLayers.Handler.Feature>}94 */95 featureHandler: null,96 84 97 85 /** … … 120 108 OpenLayers.Control.prototype.initialize.apply(this, [options]); 121 109 this.layer = layer; 122 this.dragCallbacks = OpenLayers.Util.extend({down: this.downFeature, 123 move: this.moveFeature, 124 up: this.upFeature, 125 out: this.cancel, 126 done: this.doneDragging 127 }, this.dragCallbacks); 128 this.dragHandler = new OpenLayers.Handler.Drag(this, this.dragCallbacks); 129 this.featureCallbacks = OpenLayers.Util.extend({over: this.overFeature, 130 out: this.outFeature 131 }, this.featureCallbacks); 132 var handlerOptions = {geometryTypes: this.geometryTypes}; 133 this.featureHandler = new OpenLayers.Handler.Feature(this, this.layer, 134 this.featureCallbacks, 135 handlerOptions); 110 this.handlers = { 111 drag: new OpenLayers.Handler.Drag( 112 this, OpenLayers.Util.extend({ 113 down: this.downFeature, 114 move: this.moveFeature, 115 up: this.upFeature, 116 out: this.cancel, 117 done: this.doneDragging 118 }, this.dragCallbacks) 119 ), 120 feature: new OpenLayers.Handler.Feature( 121 this, this.layer, OpenLayers.Util.extend({ 122 over: this.overFeature, 123 out: this.outFeature 124 }, this.featureCallbacks), 125 {geometryTypes: this.geometryTypes} 126 ) 127 }; 136 128 }, 137 129 … … 142 134 destroy: function() { 143 135 this.layer = null; 144 this.dragHandler.destroy();145 this.featureHandler.destroy();146 136 OpenLayers.Control.prototype.destroy.apply(this, []); 147 137 }, … … 155 145 */ 156 146 activate: function() { 157 return (this. featureHandler.activate() &&147 return (this.handlers.feature.activate() && 158 148 OpenLayers.Control.prototype.activate.apply(this, arguments)); 159 149 }, … … 168 158 deactivate: function() { 169 159 // the return from the handlers is unimportant in this case 170 this. dragHandler.deactivate();171 this. featureHandler.deactivate();160 this.handlers.drag.deactivate(); 161 this.handlers.feature.deactivate(); 172 162 this.feature = null; 173 163 this.dragging = false; … … 185 175 */ 186 176 overFeature: function(feature) { 187 if(!this. dragHandler.dragging) {177 if(!this.handlers.drag.dragging) { 188 178 this.feature = feature; 189 this. dragHandler.activate();179 this.handlers.drag.activate(); 190 180 this.over = true; 191 181 // TBD replace with CSS classes … … 239 229 upFeature: function(pixel) { 240 230 if(!this.over) { 241 this. dragHandler.deactivate();231 this.handlers.drag.deactivate(); 242 232 this.feature = null; 243 233 // TBD replace with CSS classes … … 266 256 */ 267 257 outFeature: function(feature) { 268 if(!this. dragHandler.dragging) {258 if(!this.handlers.drag.dragging) { 269 259 this.over = false; 270 this. dragHandler.deactivate();260 this.handlers.drag.deactivate(); 271 261 // TBD replace with CSS classes 272 262 this.map.div.style.cursor = "default"; … … 284 274 */ 285 275 cancel: function() { 286 this. dragHandler.deactivate();276 this.handlers.drag.deactivate(); 287 277 this.over = false; 288 278 }, … … 296 286 */ 297 287 setMap: function(map) { 298 this. dragHandler.setMap(map);299 this. featureHandler.setMap(map);288 this.handlers.drag.setMap(map); 289 this.handlers.feature.setMap(map); 300 290 OpenLayers.Control.prototype.setMap.apply(this, arguments); 301 291 }, sandbox/euzuro/pop/lib/OpenLayers/Control/ModifyFeature.js
r5974 r6127 84 84 85 85 /** 86 * Property: keyboardHandler87 * { <OpenLayers.Handler.Keyboard>}88 */ 89 keyboardHandler: null,86 * Property: handlers 87 * {Object} 88 */ 89 handlers: null, 90 90 91 91 /** … … 217 217 keypress: this.handleKeypress 218 218 }; 219 this. keyboardHandler = new OpenLayers.Handler.Keyboard(220 this, keyboardOptions221 );219 this.handlers = { 220 keyboard: new OpenLayers.Handler.Keyboard(this, keyboardOptions) 221 }; 222 222 }, 223 223 … … 230 230 this.selectControl.destroy(); 231 231 this.dragControl.destroy(); 232 this.keyboardHandler.destroy();233 232 OpenLayers.Control.prototype.destroy.apply(this, []); 234 233 }, … … 243 242 activate: function() { 244 243 return (this.selectControl.activate() && 245 this. keyboardHandler.activate() &&244 this.handlers.keyboard.activate() && 246 245 OpenLayers.Control.prototype.activate.apply(this, arguments)); 247 246 }, … … 267 266 } 268 267 this.selectControl.deactivate(); 269 this. keyboardHandler.deactivate();268 this.handlers.keyboard.deactivate(); 270 269 deactivated = true; 271 270 } … … 353 352 [feature]); 354 353 this.dragControl.lastPixel = pixel; 355 this.dragControl. dragHandler.started = true;356 this.dragControl. dragHandler.start = pixel;357 this.dragControl. dragHandler.last = pixel;354 this.dragControl.handlers.drag.started = true; 355 this.dragControl.handlers.drag.start = pixel; 356 this.dragControl.handlers.drag.last = pixel; 358 357 } 359 358 } … … 487 486 if(vertex && 488 487 OpenLayers.Util.indexOf(this.vertices, vertex) != -1 && 489 !this.dragControl. dragHandler.dragging &&488 !this.dragControl.handlers.drag.dragging && 490 489 vertex.geometry.parent) { 491 490 // remove the vertex sandbox/euzuro/pop/lib/OpenLayers/Control/Navigation.js
r5990 r6127 37 37 zoomBox: null, 38 38 39 /**40 * Property: wheelHandler41 * {<OpenLayers.Handler.MouseWheel>}42 */43 wheelHandler: null,44 45 39 /** 46 40 * Constructor: OpenLayers.Control.Navigation … … 52 46 */ 53 47 initialize: function(options) { 48 this.handlers = {}; 54 49 OpenLayers.Control.prototype.initialize.apply(this, arguments); 55 50 }, … … 62 57 */ 63 58 destroy: function() { 64 OpenLayers.Control.prototype.destroy.apply(this,arguments);65 66 59 this.deactivate(); 67 60 … … 71 64 this.dragPan = null; 72 65 73 if (this.wheelHandler) {74 this.wheelHandler.destroy();75 }76 this.wheelHandler = null;77 78 if (this.clickHandler) {79 this.clickHandler.destroy();80 }81 this.clickHandler = null;82 83 66 if (this.zoomBox) { 84 67 this.zoomBox.destroy(); 85 68 } 86 69 this.zoomBox = null; 70 OpenLayers.Control.prototype.destroy.apply(this,arguments); 87 71 }, 88 72 … … 92 76 activate: function() { 93 77 this.dragPan.activate(); 94 this. wheelHandler.activate();95 this. clickHandler.activate();78 this.handlers.wheel.activate(); 79 this.handlers.click.activate(); 96 80 this.zoomBox.activate(); 97 81 return OpenLayers.Control.prototype.activate.apply(this,arguments); … … 104 88 this.zoomBox.deactivate(); 105 89 this.dragPan.deactivate(); 106 this. clickHandler.deactivate();107 this. wheelHandler.deactivate();90 this.handlers.click.deactivate(); 91 this.handlers.wheel.deactivate(); 108 92 return OpenLayers.Control.prototype.deactivate.apply(this,arguments); 109 93 }, … … 113 97 */ 114 98 draw: function() { 115 this. clickHandler= new OpenLayers.Handler.Click(this,99 this.handlers.click = new OpenLayers.Handler.Click(this, 116 100 { 'dblclick': this.defaultDblClick }, 117 101 { … … 124 108 this.dragPan.draw(); 125 109 this.zoomBox.draw(); 126 this. wheelHandler= new OpenLayers.Handler.MouseWheel(110 this.handlers.wheel = new OpenLayers.Handler.MouseWheel( 127 111 this, {"up" : this.wheelUp, 128 112 "down": this.wheelDown} ); sandbox/euzuro/pop/lib/OpenLayers/Control/OverviewMap.js
r6083 r6127 99 99 100 100 /** 101 * Property: dragHandler102 * { <OpenLayers.Handler.Drag>} A handler for dragging the extent rectangle.103 */ 104 dragHandler: null,101 * Property: handlers 102 * {Object} 103 */ 104 handlers: null, 105 105 106 106 /** … … 115 115 initialize: function(options) { 116 116 this.layers = []; 117 this.handlers = {}; 117 118 OpenLayers.Control.prototype.initialize.apply(this, [options]); 118 119 }, … … 126 127 return; 127 128 } 128 this.dragHandler.destroy(); 129 this.clickHandler.destroy(); 129 this.handlers.click.destroy(); 130 130 131 131 this.mapDiv.removeChild(this.extentRectangle); … … 281 281 */ 282 282 rectDrag: function(px) { 283 var deltaX = this. dragHandler.last.x - px.x;284 var deltaY = this. dragHandler.last.y - px.y;283 var deltaX = this.handlers.drag.last.x - px.x; 284 var deltaY = this.handlers.drag.last.y - px.y; 285 285 if(deltaX != 0 || deltaY != 0) { 286 286 var rectTop = this.rectPxBounds.top; … … 457 457 this.hComp = (this.hComp) ? this.hComp : 2; 458 458 459 this. dragHandler= new OpenLayers.Handler.Drag(459 this.handlers.drag = new OpenLayers.Handler.Drag( 460 460 this, {move: this.rectDrag, done: this.updateMapToRect}, 461 461 {map: this.ovmap} 462 462 ); 463 this. clickHandler= new OpenLayers.Handler.Click(463 this.handlers.click = new OpenLayers.Handler.Click( 464 464 this, { 465 465 "click": this.mapDivClick … … 471 471 } 472 472 ); 473 this. clickHandler.activate();473 this.handlers.click.activate(); 474 474 475 475 this.rectEvents = new OpenLayers.Events(this, this.extentRectangle, 476 476 null, true); 477 477 this.rectEvents.register("mouseover", this, function(e) { 478 if(!this. dragHandler.active && !this.map.dragging) {479 this. dragHandler.activate();478 if(!this.handlers.drag.active && !this.map.dragging) { 479 this.handlers.drag.activate(); 480 480 } 481 481 }); 482 482 this.rectEvents.register("mouseout", this, function(e) { 483 if(!this. dragHandler.dragging) {484 this. dragHandler.deactivate();483 if(!this.handlers.drag.dragging) { 484 this.handlers.drag.deactivate(); 485 485 } 486 486 }); … … 512 512 updateMapToRect: function() { 513 513 var lonLatBounds = this.getMapBoundsFromRectBounds(this.rectPxBounds); 514 this.map. setCenter(lonLatBounds.getCenterLonLat(), this.map.zoom);514 this.map.panTo(lonLatBounds.getCenterLonLat()); 515 515 }, 516 516 sandbox/euzuro/pop/lib/OpenLayers/Format/SLD.js
r5978 r6127 344 344 for (var i=0; i<filters.length; i++) { 345 345 if (filters[i].nodeType == 1) { 346 rule. children.push(this.parseFilter(filters[i]));346 rule.rules.push(this.parseFilter(filters[i])); 347 347 } 348 348 } … … 358 358 for (var i=0; i<filters.length; i++) { 359 359 if (filters[i].nodeType == 1) { 360 rule. children.push(this.parseFilter(filters[i]));360 rule.rules.push(this.parseFilter(filters[i])); 361 361 } 362 362 } … … 369 369 var rule = new OpenLayers.Rule.Logical( 370 370 {type: OpenLayers.Rule.Logical.NOT}); 371 rule. children.push(this.parseFilter(filter[0]));371 rule.rules.push(this.parseFilter(filter[0])); 372 372 return rule; 373 373 } sandbox/euzuro/pop/lib/OpenLayers/Map.js
r6104 r6127 374 374 // Note that this is ok, as updateSize() does nothing if the 375 375 // map's size has not actually changed. 376 this.updateSizeDestroy = OpenLayers.Function.bind(this.updateSize, 377 this); 376 378 OpenLayers.Event.observe(window, 'resize', 377 OpenLayers.Function.bind(this.updateSize, this));379 this.updateSizeDestroy); 378 380 } 379 381 … … 435 437 */ 436 438 unloadDestroy: null, 439 440 /** 441 * Method: updateSizeDestroy 442 * When the map is destroyed, we need to stop listening to updateSize 443 * events: this method stores the function we need to unregister in 444 * non-IE browsers. 445 */ 446 updateSizeDestroy: null, 437 447 438 448 /** … … 449 459 OpenLayers.Event.stopObserving(window, 'unload', this.unloadDestroy); 450 460 this.unloadDestroy = null; 461 462 if (this.updateSizeDestroy) { 463 OpenLayers.Event.stopObserving(window, 'resize', 464 this.updateSizeDestroy); 465 } else { 466 this.events.unregister("resize", this, this.updateSize); 467 } 451 468 452 469 if (this.layers != null) { … … 1230 1247 * dx - {Integer} 1231 1248 * dy - {Integer} 1232 */ 1233 pan: function(dx, dy) { 1234 1249 * options - {Object} Only one at this time: "animate", which uses 1250 * panTo instead of setCenter. Default is true. 1251 */ 1252 pan: function(dx, dy, options) { 1253 1254 if (!options) { 1255 options = {} 1256 } 1235 1257 // getCenter 1236 1258 var centerPx = this.getViewPortPxFromLonLat(this.getCenter()); … … 1242 1264 if (!newCenterPx.equals(centerPx)) { 1243 1265 var newCenterLonLat = this.getLonLatFromViewPortPx(newCenterPx); 1244 this.setCenter(newCenterLonLat); 1266 if (options.animate) { 1267 this.panTo(newCenterLonLat); 1268 } else { 1269 this.setCenter(newCenterLonLat); 1270 } 1245 1271 } 1246 1272 1247 1273 }, 1274 1275 /** 1276 * APIMethod: panTo 1277 * Allows user to pan to a new lonlat 1278 * If the new lonlat is in the current extent the map will slide smoothly 1279 * 1280 * Parameters: 1281 * lonlat - {<OpenLayers.Lonlat>} 1282 */ 1283 panTo: function(lonlat) { 1284 if (this.getExtent().containsLonLat(lonlat)) { 1285 if (!this.panTween) { 1286 this.panTween = new OpenLayers.Tween(OpenLayers.Easing.Expo.easeOut); 1287 } 1288 var center = this.getCenter(); 1289 var from = { 1290 lon: center.lon, 1291 lat: center.lat 1292 }; 1293 var to = { 1294 lon: lonlat.lon, 1295 lat: lonlat.lat 1296 }; 1297 this.panTween.start(from, to, 50, { 1298 callbacks: { 1299 start: OpenLayers.Function.bind(function(lonlat) { 1300 this.events.triggerEvent("movestart"); 1301 }, this), 1302 eachStep: OpenLayers.Function.bind(function(lonlat) { 1303 var lonlat = new OpenLayers.LonLat(lonlat.lon, lonlat.lat); 1304 this.moveTo(lonlat, this.zoom, true); 1305 }, this), 1306 done: OpenLayers.Function.bind(function(lonlat) { 1307 this.events.triggerEvent("moveend"); 1308 }, this) 1309 } 1310 }); 1311 } else { 1312 this.setCenter(lonlat); 1313 } 1314 }, 1248 1315 1249 1316 /** … … 1286 1353 // noEvent is false by default 1287 1354 var noEvent = options.noEvent; 1355 1356 if (this.panTween && options.caller == "setCenter") { 1357 this.panTween.stop(); 1358 } 1288 1359 1289 1360 if (!this.center && !this.isValidLonLat(lonlat)) { sandbox/euzuro/pop/lib/OpenLayers/Rule.js
r5978 r6127 20 20 */ 21 21 name: 'default', 22 23 /** 24 * Property: context 25 * {Object} An optional object with properties that the rule and its 26 * symbolizers' property values should be evaluatad against. If no 27 * context is specified, feature.attributes will be used 28 */ 29 context: null, 22 30 23 31 /** … … 94 102 */ 95 103 evaluate: function(feature) { 96 // Default rule always applies. Subclasses will want to override this. 97 return true; 104 var context = this.getContext(feature); 105 var applies = true; 106 107 if (this.minScaleDenominator || this.maxScaleDenominator) { 108 var scale = feature.layer.map.getScale(); 109 } 110 111 // check if within minScale/maxScale bounds 112 if (this.minScaleDenominator) { 113 applies = scale >= OpenLayers.Style.createLiteral( 114 this.minScaleDenominator, context); 115 } 116 if (applies && this.maxScaleDenominator) { 117 applies = scale < OpenLayers.Style.createLiteral( 118 this.maxScaleDenominator, context); 119 } 120 121 return applies; 98 122 }, 99 123 124 /** 125 * Method: getContext 126 * Gets the context for evaluating this rule 127 * 128 * Paramters: 129 * feature - {<OpenLayers.Feature>} feature to take the context from if 130 * none is specified. 131 */ 132 getContext: function(feature) { 133 var context = this.context; 134 if (!context) { 135 context = feature.attributes || feature.data; 136 } 137 return context; 138 }, 139 100 140 CLASS_NAME: "OpenLayers.Rule" 101 141 }); sandbox/euzuro/pop/lib/OpenLayers/Rule/Comparison.js
r5614 r6127 34 34 * APIProperty: property 35 35 * {String} 36 * name of the feature attributeto compare36 * name of the context property to compare 37 37 */ 38 38 property: null, … … 85 85 /** 86 86 * APIMethod: evaluate 87 * evaluates this rule for a specific feature88 * 89 * Parameters: 90 * feature - {<OpenLayers.Feature>} featureto apply the rule to.87 * evaluates this rule for a specific context 88 * 89 * Parameters: 90 * context - {Object} context to apply the rule to. 91 91 * 92 92 * Returns: … … 94 94 */ 95 95 evaluate: function(feature) { 96 var attributes = feature.attributes || feature.data; 96 if (!OpenLayers.Rule.prototype.evaluate.apply(this, arguments)) { 97 return false; 98 } 99 var context = this.getContext(feature); 97 100 switch(this.type) { 98 101 case OpenLayers.Rule.Comparison.EQUAL_TO: … … 101 104 case OpenLayers.Rule.Comparison.LESS_THAN_OR_EQUAL_TO: 102 105 case OpenLayers.Rule.Comparison.GREATER_THAN_OR_EQUAL_TO: 103 return this.binaryCompare( feature, this.property, this.value);106 return this.binaryCompare(context, this.property, this.value); 104 107 105 108 case OpenLayers.Rule.Comparison.BETWEEN: 106 109 var result = 107 attributes[this.property] > this.lowerBoundary;110 context[this.property] > this.lowerBoundary; 108 111 result = result && 109 attributes[this.property] < this.upperBoundary;112 context[this.property] < this.upperBoundary; 110 113 return result; 111 114 case OpenLayers.Rule.Comparison.LIKE: 112 115 var regexp = new RegExp(this.value, 113 116 "gi"); 114 return regexp.test( attributes[this.property]);117 return regexp.test(context[this.property]); 115 118 } 116 119 }, … … 166 169 * 167 170 * Parameters: 168 * feature - {<OpenLayers.Feature>}171 * context - {Object} 169 172 * property - {String} or {Number} 170 173 * value - {String} or {Number}, same as property … … 173 176 * {boolean} 174 177 */ 175 binaryCompare: function(feature, property, value) { 176 var attributes = feature.attributes || feature.data; 178 binaryCompare: function(context, property, value) { 177 179 switch (this.type) { 178 180 case OpenLayers.Rule.Comparison.EQUAL_TO: 179 return attributes[property] == value;181 return context[property] == value; 180 182 case OpenLayers.Rule.Comparison.NOT_EQUAL_TO: 181 return attributes[property] != value;183 return context[property] != value; 182 184 case OpenLayers.Rule.Comparison.LESS_THAN: 183 return attributes[property] < value;185 return context[property] < value; 184 186 case OpenLayers.Rule.Comparison.GREATER_THAN: 185 return attributes[property] > value;187 return context[property] > value; 186 188 case OpenLayers.Rule.Comparison.LESS_THAN_OR_EQUAL_TO: 187 return attributes[property] <= value;189 return context[property] <= value; 188 190 case OpenLayers.Rule.Comparison.GREATER_THAN_OR_EQUAL_TO: 189 return attributes[property] >= value;191 return context[property] >= value; 190 192 } 191 193 }, sandbox/euzuro/pop/lib/OpenLayers/Rule/FeatureId.js
r5614 r6127 54 54 */ 55 55 evaluate: function(feature) { 56 if (!OpenLayers.Rule.prototype.evaluate.apply(this, arguments)) { 57 return false; 58 } 56 59 for (var i=0; i<this.fids.length; i++) { 57 60 var fid = feature.fid || feature.id; sandbox/euzuro/pop/lib/OpenLayers/Rule/Logical.js
r5614 r6127 21 21 * {Array(<OpenLayers.Rule>)} child rules for this rule 22 22 */ 23 children: null,23 rules: null, 24 24 25 25 /** … … 44 44 */ 45 45 initialize: function(options) { 46 this. children= [];46 this.rules = []; 47 47 OpenLayers.Rule.prototype.initialize.apply(this, [options]); 48 48 }, … … 53 53 */ 54 54 destroy: function() { 55 for (var i=0; i<this. children.length; i++) {56 this. children[i].destroy();55 for (var i=0; i<this.rules.length; i++) { 56 this.rules[i].destroy(); 57 57 } 58 this. children= null;58 this.rules = null; 59 59 OpenLayers.Rule.prototype.destroy.apply(this, arguments); 60 60 }, … … 71 71 */ 72 72 evaluate: function(feature) { 73 if (!OpenLayers.Rule.prototype.evaluate.apply(this, arguments)) { 74 return false; 75 } 73 76 switch(this.type) { 74 77 case OpenLayers.Rule.Logical.AND: 75 for (var i=0; i<this. children.length; i++) {76 if (this. children[i].evaluate(feature) == false) {78 for (var i=0; i<this.rules.length; i++) { 79 if (this.rules[i].evaluate(feature) == false) { 77 80 return false; 78 81 } … … 81 84 82 85 case OpenLayers.Rule.Logical.OR: 83 for (var i=0; i<this. children.length; i++) {84 if (this. children[i].evaluate(feature) == true) {86 for (var i=0; i<this.rules.length; i++) { 87 if (this.rules[i].evaluate(feature) == true) { 85 88 return true; 86 89 } … … 89 92 90 93 case OpenLayers.Rule.Logical.NOT: 91 return (!this. children[0].evaluate(feature));94 return (!this.rules[0].evaluate(feature)); 92 95 } 93 96 }, sandbox/euzuro/pop/lib/OpenLayers/Style.js
r5978 r6127 113 113 var rules = this.rules; 114 114 115 var rule ;115 var rule, context; 116 116 var elseRules = []; 117 117 var appliedRules = false; 118 118 for(var i=0; i<rules.length; i++) { 119 119 rule = rules[i]; 120 context = rule.context; 121 if (!context) { 122 context = feature.attributes || feature.data; 123 } 120 124 // does the rule apply? 121 125 var applies = rule.evaluate(feature); 122 126 123 if (rule.minScaleDenominator || rule.maxScaleDenominator) {124 var scale = feature.layer.map.getScale();125 }126 127 // check if within minScale/maxScale bounds128 if (rule.minScaleDenominator) {129 applies = scale >= OpenLayers.Style.createLiteral(130 rule.minScaleDenominator, feature);131 }132 if (applies && rule.maxScaleDenominator) {133 applies = scale < OpenLayers.Style.createLiteral(134 rule.maxScaleDenominator, feature);135 }136 137 127 if(applies) { 138 128 if(rule instanceof OpenLayers.Rule && rule.elseFilter) { … … 140 130 } else { 141 131 appliedRules = true; 142 this.applySymbolizer(rule, style, feature );132 this.applySymbolizer(rule, style, feature, context); 143 133 } 144 134 } … … 149 139 appliedRules = true; 150 140 for(var i=0; i<elseRules.length; i++) { 151 this.applySymbolizer(elseRules[i], style, feature); 152 } 153 } 154 155 // calculate literals for all styles in the propertyStyles cache 156 this.createLiterals(style, feature); 141 this.applySymbolizer(elseRules[i], style, feature, context); 142 } 143 } 157 144 158 145 // don't display if there were rules but none applied … … 173 160 * style - {Object} 174 161 * feature - {<OpenLayer.Feature.Vector>} 162 * context - {Object} 175 163 * 176 164 * Returns: 177 165 * {Object} A style with new symbolizer applied. 178 166 */ 179 applySymbolizer: function(rule, style, feature ) {167 applySymbolizer: function(rule, style, feature, context) { 180 168 var symbolizerPrefix = feature.geometry ? 181 169 this.getSymbolizerPrefix(feature.geometry) : 182 170 OpenLayers.Style.SYMBOLIZER_PREFIXES[0]; 183 171 172 var symbolizer = rule.symbolizer[symbolizerPrefix]; 173 184 174 // merge the style with the current style 185 var symbolizer = rule.symbolizer[symbolizerPrefix];186 return OpenLayers.Util.extend(style, symbolizer);175 return this.createLiterals( 176 OpenLayers.Util.extend(style, symbolizer), context); 187 177 }, 188 178 … … 195 185 * style - {Object} style to create literals for. Will be modified 196 186 * inline. 197 * feature - {<OpenLayers.Feature.Vector>} feature to take properties from 187 * context - {Object} context to take property values from. Defaults to 188 * feature.attributes (or feature.data, if attributes are not
