Navigation

← Previous Changeset
Next Changeset →

Changeset 6818

Timestamp:

04/07/08 20:13:45 (5 months ago)

Author:

tschaub

Message:

With dramatic flourish, I'm modifying 21 files with 1033 insertions and 815 deletions between release candidates. This moves all rule subclasses to a more natural home as filter subclasses. Also adds tests for SLD write and corrects a handful of issues there. Apologies to all who lose sleep over this sort of thing. r=ahocevar,crschmidt (closes #1492)

Files:

trunk/openlayers/examples/georss-flickr.html (modified) (1 diff)
trunk/openlayers/lib/OpenLayers.js (modified) (1 diff)
trunk/openlayers/lib/OpenLayers/Filter (added)
trunk/openlayers/lib/OpenLayers/Filter.js (added)
trunk/openlayers/lib/OpenLayers/Filter/Comparison.js (added)
trunk/openlayers/lib/OpenLayers/Filter/FeatureId.js (added)
trunk/openlayers/lib/OpenLayers/Filter/Logical.js (added)
trunk/openlayers/lib/OpenLayers/Format/SLD/v1.js (modified) (8 diffs)
trunk/openlayers/lib/OpenLayers/Rule.js (modified) (3 diffs)
trunk/openlayers/lib/OpenLayers/Rule/Comparison.js (deleted)
trunk/openlayers/lib/OpenLayers/Rule/FeatureId.js (deleted)
trunk/openlayers/lib/OpenLayers/Rule/Logical.js (deleted)
trunk/openlayers/tests/Filter (added)
trunk/openlayers/tests/Filter.html (added)
trunk/openlayers/tests/Filter/Comparison.html (added)
trunk/openlayers/tests/Filter/FeatureId.html (added)
trunk/openlayers/tests/Filter/Logical.html (added)
trunk/openlayers/tests/Format/SLD (added)
trunk/openlayers/tests/Format/SLD/v1_0_0.html (added)
trunk/openlayers/tests/Rule (deleted)
trunk/openlayers/tests/Style.html (modified) (2 diffs)
trunk/openlayers/tests/list-tests.html (modified) (2 diffs)

Legend:

: Unmodified
: Added
: Removed
: Modified
: Copied
: Moved

trunk/openlayers/examples/georss-flickr.html

r6240	r6818
32	32	style = new OpenLayers.Style({externalGraphic: "${thumbnail}"});
33	33
34		~~// make the thumbnails larger when we select them~~
35		~~selectStyle = new OpenLayers.Style({pointRadius: 35});~~
36
37	34	// create a rule with a point symbolizer that will make the thumbnail
38	35	// larger if the title of the rss item conatins "powder"
39		var rule = new OpenLayers.Rule.Comparison({
40		type: OpenLayers.Rule.Comparison.LIKE,
	36	var rule = new OpenLayers.Rule({
	37	symbolizer: {pointRadius: 30},
	38	filter: new OpenLayers.Filter.Comparison({
	39	type: OpenLayers.Filter.Comparison.LIKE,
41	40	property: "title",
42		value: "powder",
43		symbolizer: {"Point": {pointRadius: 30}}});
44		rule.value2regex("*");
	41	value: "powder"
	42	})
	43	});
	44	rule.filter.value2regex("*");
45	45
46	46	// If the above rule does not apply, use a smaller pointRadius.
47	47	var elseRule = new OpenLayers.Rule({
48		elseFilter: true,
49		symbolizer: {"Point": {pointRadius: 20}}});
	48	elseFilter: true,
	49	symbolizer: {pointRadius: 20}
	50	});
50	51
51	52	style.addRules([rule, elseRule]);
52	53
53		markerLayer = new OpenLayers.Layer.Vector("", {styleMap: new OpenLayers.StyleMap({
54		"default": style,
55		"select": selectStyle})});
	54	// Create a layer with a style map. Giving the style map keys
	55	// for "default" and "select" rendering intent.
	56	markerLayer = new OpenLayers.Layer.Vector("", {
	57	styleMap: new OpenLayers.StyleMap({
	58	"default": style,
	59	"select": new OpenLayers.Style({pointRadius: 35})
	60	})
	61	});
56	62	map.addLayer(markerLayer);
57	63

trunk/openlayers/lib/OpenLayers.js

r6718	r6818
184	184	"OpenLayers/StyleMap.js",
185	185	"OpenLayers/Rule.js",
186		"OpenLayers/Rule/FeatureId.js",
187		"OpenLayers/Rule/Logical.js",
188		"OpenLayers/Rule/Comparison.js",
	186	"OpenLayers/Filter.js",
	187	"OpenLayers/Filter/FeatureId.js",
	188	"OpenLayers/Filter/Logical.js",
	189	"OpenLayers/Filter/Comparison.js",
189	190	"OpenLayers/Format.js",
190	191	"OpenLayers/Format/XML.js",

trunk/openlayers/lib/OpenLayers/Format/SLD/v1.js

r6748	r6818
143	143	},
144	144	"Rule": function(node, obj) {
145		// Rule elements are represented as OpenLayers.Rule instances.
146		// Filter elements are represented as instances of
147		// OpenLayers.Rule subclasses.
148		var config = {
149		rules: [],
150		symbolizer: {}
151		};
152		this.readChildNodes(node, config);
153		// Now we've either got zero or one rules (from filters)
154		var rule;
155		if(config.rules.length == 0) {
156		delete config.rules;
157		rule = new OpenLayers.Rule(config);
158		} else {
159		rule = config.rules[0];
160		delete config.rules;
161		OpenLayers.Util.extend(rule, config);
162		}
	145	var rule = new OpenLayers.Rule();
	146	this.readChildNodes(node, rule);
163	147	obj.rules.push(rule);
164	148	},
…	…
284	268	"ogc": {
285	269	"Filter": function(node, rule) {
286		// Filters correspond to subclasses of OpenLayers.~~Rule~~.
	270	// Filters correspond to subclasses of OpenLayers.Filter.
287	271	// Since they contain information we don't persist, we
288		// create a temporary object and then pass on the ~~rules~~
	272	// create a temporary object and then pass on the filter
289	273	// (ogc:Filter) to the parent rule (sld:Rule).
290		var ~~filter~~ = {
	274	var obj = {
291	275	fids: [],
292		~~rule~~s: []
	276	filters: []
293	277	};
294		this.readChildNodes(node, filter);
295		if(filter.fids.length > 0) {
296		rule.rules.push(new OpenLayers.Rule.FeatureId({
297		fids: filter.fids
298		}));
299		}
300		if(filter.rules.length > 0) {
301		rule.rules = rule.rules.concat(filter.rules);
302		}
303		},
304		"FeatureId": function(node, filter) {
	278	this.readChildNodes(node, obj);
	279	if(obj.fids.length > 0) {
	280	rule.filter = new OpenLayers.Filter.FeatureId({
	281	fids: obj.fids
	282	});
	283	} else if(obj.filters.length > 0) {
	284	rule.filter = obj.filters[0];
	285	}
	286	},
	287	"FeatureId": function(node, obj) {
305	288	var fid = node.getAttribute("fid");
306	289	if(fid) {
307		filter.fids.push(fid);
308		}
309		},
310		"And": function(node, filter) {
311		var rule = new OpenLayers.Rule.Logical({
312		type: OpenLayers.Rule.Logical.AND
313		});
314		// since FeatureId rules may be nested here, make room for them
315		rule.fids = [];
316		this.readChildNodes(node, rule);
317		if(rule.fids.length > 0) {
318		rule.rules.push(new OpenLayers.Rule.FeatureId({
319		fids: rule.fids
320		}));
321		}
322		delete rule.fids;
323		filter.rules.push(rule);
324		},
325		"Or": function(node, filter) {
326		var rule = new OpenLayers.Rule.Logical({
327		type: OpenLayers.Rule.Logical.OR
328		});
329		// since FeatureId rules may be nested here, make room for them
330		rule.fids = [];
331		this.readChildNodes(node, rule);
332		if(rule.fids.length > 0) {
333		rule.rules.push(new OpenLayers.Rule.FeatureId({
334		fids: rule.fids
335		}));
336		}
337		delete rule.fids;
338		filter.rules.push(rule);
339		},
340		"Not": function(node, filter) {
341		var rule = new OpenLayers.Rule.Logical({
342		type: OpenLayers.Rule.Logical.NOT
343		});
344		// since FeatureId rules may be nested here, make room for them
345		rule.fids = [];
346		this.readChildNodes(node, rule);
347		if(rule.fids.length > 0) {
348		rule.rules.push(new OpenLayers.Rule.FeatureId({
349		fids: rule.fids
350		}));
351		}
352		delete rule.fids;
353		filter.rules.push(rule);
354		},
355		"PropertyIsEqualTo": function(node, filter) {
356		var rule = new OpenLayers.Rule.Comparison({
357		type: OpenLayers.Rule.Comparison.EQUAL_TO
358		});
359		this.readChildNodes(node, rule);
360		filter.rules.push(rule);
361		},
362		"PropertyIsNotEqualTo": function(node, filter) {
363		var rule = new OpenLayers.Rule.Comparison({
364		type: OpenLayers.Rule.Comparison.NOT_EQUAL_TO
365		});
366		this.readChildNodes(node, rule);
367		filter.rules.push(rule);
368		},
369		"PropertyIsLessThan": function(node, filter) {
370		var rule = new OpenLayers.Rule.Comparison({
371		type: OpenLayers.Rule.Comparison.LESS_THAN
372		});
373		this.readChildNodes(node, rule);
374		filter.rules.push(rule);
375		},
376		"PropertyIsGreaterThan": function(node, filter) {
377		var rule = new OpenLayers.Rule.Comparison({
378		type: OpenLayers.Rule.Comparison.GREATER_THAN
379		});
380		this.readChildNodes(node, rule);
381		filter.rules.push(rule);
382		},
383		"PropertyIsLessThanOrEqualTo": function(node, filter) {
384		var rule = new OpenLayers.Rule.Comparison({
385		type: OpenLayers.Rule.Comparison.LESS_THAN_OR_EQUAL_TO
386		});
387		this.readChildNodes(node, rule);
388		filter.rules.push(rule);
389		},
390		"PropertyIsGreaterThanOrEqualTo": function(node, filter) {
391		var rule = new OpenLayers.Rule.Comparison({
392		type: OpenLayers.Rule.Comparison.GREATER_THAN_OR_EQUAL_TO
393		});
394		this.readChildNodes(node, rule);
395		filter.rules.push(rule);
396		},
397		"PropertyIsBetween": function(node, filter) {
398		var rule = new OpenLayers.Rule.Comparison({
399		type: OpenLayers.Rule.Comparison.BETWEEN
400		});
401		this.readChildNodes(node, rule);
402		filter.rules.push(rule);
403		},
404		"PropertyIsLike": function(node, filter) {
405		var rule = new OpenLayers.Rule.Comparison({
406		type: OpenLayers.Rule.Comparison.LIKE
407		});
408		this.readChildNodes(node, rule);
	290	obj.fids.push(fid);
	291	}
	292	},
	293	"And": function(node, obj) {
	294	var filter = new OpenLayers.Filter.Logical({
	295	type: OpenLayers.Filter.Logical.AND
	296	});
	297	this.readChildNodes(node, filter);
	298	obj.filters.push(filter);
	299	},
	300	"Or": function(node, obj) {
	301	var filter = new OpenLayers.Filter.Logical({
	302	type: OpenLayers.Filter.Logical.OR
	303	});
	304	this.readChildNodes(node, filter);
	305	obj.filters.push(filter);
	306	},
	307	"Not": function(node, obj) {
	308	var filter = new OpenLayers.Filter.Logical({
	309	type: OpenLayers.Filter.Logical.NOT
	310	});
	311	this.readChildNodes(node, filter);
	312	obj.filters.push(filter);
	313	},
	314	"PropertyIsEqualTo": function(node, obj) {
	315	var filter = new OpenLayers.Filter.Comparison({
	316	type: OpenLayers.Filter.Comparison.EQUAL_TO
	317	});
	318	this.readChildNodes(node, filter);
	319	obj.filters.push(filter);
	320	},
	321	"PropertyIsNotEqualTo": function(node, obj) {
	322	var filter = new OpenLayers.Filter.Comparison({
	323	type: OpenLayers.Filter.Comparison.NOT_EQUAL_TO
	324	});
	325	this.readChildNodes(node, filter);
	326	obj.filters.push(filter);
	327	},
	328	"PropertyIsLessThan": function(node, obj) {
	329	var filter = new OpenLayers.Filter.Comparison({
	330	type: OpenLayers.Filter.Comparison.LESS_THAN
	331	});
	332	this.readChildNodes(node, filter);
	333	obj.filters.push(filter);
	334	},
	335	"PropertyIsGreaterThan": function(node, obj) {
	336	var filter = new OpenLayers.Filter.Comparison({
	337	type: OpenLayers.Filter.Comparison.GREATER_THAN
	338	});
	339	this.readChildNodes(node, filter);
	340	obj.filters.push(filter);
	341	},
	342	"PropertyIsLessThanOrEqualTo": function(node, obj) {
	343	var filter = new OpenLayers.Filter.Comparison({
	344	type: OpenLayers.Filter.Comparison.LESS_THAN_OR_EQUAL_TO
	345	});
	346	this.readChildNodes(node, filter);
	347	obj.filters.push(filter);
	348	},
	349	"PropertyIsGreaterThanOrEqualTo": function(node, obj) {
	350	var filter = new OpenLayers.Filter.Comparison({
	351	type: OpenLayers.Filter.Comparison.GREATER_THAN_OR_EQUAL_TO
	352	});
	353	this.readChildNodes(node, filter);
	354	obj.filters.push(filter);
	355	},
	356	"PropertyIsBetween": function(node, obj) {
	357	var filter = new OpenLayers.Filter.Comparison({
	358	type: OpenLayers.Filter.Comparison.BETWEEN
	359	});
	360	this.readChildNodes(node, filter);
	361	obj.filters.push(filter);
	362	},
	363	"PropertyIsLike": function(node, obj) {
	364	var filter = new OpenLayers.Filter.Comparison({
	365	type: OpenLayers.Filter.Comparison.LIKE
	366	});
	367	this.readChildNodes(node, filter);
409	368	var wildCard = node.getAttribute("wildCard");
410	369	var singleChar = node.getAttribute("singleChar");
411	370	var esc = node.getAttribute("escape");
412		~~rule~~.value2regex(wildCard, singleChar, esc);
413		~~filter.rules.push(rule~~);
	371	filter.value2regex(wildCard, singleChar, esc);
	372	obj.filters.push(filter);
414	373	},
415	374	"Literal": function(node, obj) {
416	375	obj.value = this.getChildValue(node);
417	376	},
418		"PropertyName": function(node, ~~rule~~) {
419		~~rule~~.property = this.getChildValue(node);
420		},
421		"LowerBoundary": function(node, ~~rule~~) {
422		~~rule~~.lowerBoundary = this.readOgcExpression(node);
423		},
424		"UpperBoundary": function(node, ~~rule~~) {
425		~~rule~~.upperBoundary = this.readOgcExpression(node);
	377	"PropertyName": function(node, filter) {
	378	filter.property = this.getChildValue(node);
	379	},
	380	"LowerBoundary": function(node, filter) {
	381	filter.lowerBoundary = this.readOgcExpression(node);
	382	},
	383	"UpperBoundary": function(node, filter) {
	384	filter.upperBoundary = this.readOgcExpression(node);
426	385	}
427	386	}
…	…
683	642	if(rule.elseFilter) {
684	643	this.writeNode(node, "ElseFilter");
685		} else if(rule.~~CLASS_NAME != "OpenLayers.Rule"~~) {
686		this.writeNode(node, "ogc:Filter", rule);
	644	} else if(rule.filter) {
	645	this.writeNode(node, "ogc:Filter", rule.filter);
687	646	}
688	647
…	…
868	827	},
869	828	"ogc": {
870		"Filter": function(~~rule~~) {
	829	"Filter": function(filter) {
871	830	var node = this.createElementNSPlus("ogc:Filter");
872		var sub = ~~rule~~.CLASS_NAME.split(".").pop();
	831	var sub = filter.CLASS_NAME.split(".").pop();
873	832	if(sub == "FeatureId") {
874		for(var i=0; i<~~rule~~.fids.length; ++i) {
875		this.writeNode(node, "FeatureId", ~~rule~~.fids[i]);
	833	for(var i=0; i<filter.fids.length; ++i) {
	834	this.writeNode(node, "FeatureId", filter.fids[i]);
876	835	}
877	836	} else {
878		this.writeNode(node, this.getFilterType(~~rule), rule~~);
	837	this.writeNode(node, this.getFilterType(filter), filter);
879	838	}
880	839	return node;
…	…
885	844	});
886	845	},
887		"And": function(~~rule~~) {
	846	"And": function(filter) {
888	847	var node = this.createElementNSPlus("ogc:And");
889		var child~~Rule~~;
890		for(var i=0; i<~~rule.rule~~s.length; ++i) {
891		child~~Rule = rule.rule~~s[i];
	848	var childFilter;
	849	for(var i=0; i<filter.filters.length; ++i) {
	850	childFilter = filter.filters[i];
892	851	this.writeNode(
893		node, this.getFilterType(child~~Rule), childRule~~
	852	node, this.getFilterType(childFilter), childFilter
894	853	);
895	854	}
896	855	return node;
897	856	},
898		"Or": function(~~rule~~) {
	857	"Or": function(filter) {
899	858	var node = this.createElementNSPlus("ogc:Or");
900		var child~~Rule~~;
901		for(var i=0; i<~~rule.rule~~s.length; ++i) {
902		child~~Rule = rule.rule~~s[i];
	859	var childFilter;
	860	for(var i=0; i<filter.filters.length; ++i) {
	861	childFilter = filter.filters[i];
903	862	this.writeNode(
904		node, this.getFilterType(child~~Rule), childRule~~
	863	node, this.getFilterType(childFilter), childFilter
905	864	);
906	865	}
907	866	return node;
908	867	},
909		"Not": function(~~rule~~) {
	868	"Not": function(filter) {
910	869	var node = this.createElementNSPlus("ogc:Not");
911		var child~~Rule = rule.rule~~s[0];
	870	var childFilter = filter.filters[0];
912	871	this.writeNode(
913		node, this.getFilterType(child~~Rule), childRule~~
	872	node, this.getFilterType(childFilter), childFilter
914	873	);
915	874	return node;
916	875	},
917		"PropertyIsEqualTo": function(~~rule~~) {
	876	"PropertyIsEqualTo": function(filter) {
918	877	var node = this.createElementNSPlus("ogc:PropertyIsEqualTo");
919	878	// no ogc:expression handling for now
920		this.writeNode(node, "PropertyName", ~~rule~~);
921		this.writeNode(node, "Literal", ~~rul~~e);
922		return node;
923		},
924		"PropertyIsNotEqualTo": function(~~rule~~) {
	879	this.writeNode(node, "PropertyName", filter);
	880	this.writeNode(node, "Literal", filter.value);
	881	return node;
	882	},
	883	"PropertyIsNotEqualTo": function(filter) {
925	884	var node = this.createElementNSPlus("ogc:PropertyIsNotEqualTo");
926	885	// no ogc:expression handling for now
927		this.writeNode(node, "PropertyName", ~~rule~~);
928		this.writeNode(node, "Literal", ~~rul~~e);
929		return node;
930		},
931		"PropertyIsLessThan": function(~~rule~~) {
	886	this.writeNode(node, "PropertyName", filter);
	887	this.writeNode(node, "Literal", filter.value);
	888	return node;
	889	},
	890	"PropertyIsLessThan": function(filter) {
932	891	var node = this.createElementNSPlus("ogc:PropertyIsLessThan");
933	892	// no ogc:expression handling for now
934		this.writeNode(node, "PropertyName", ~~rule~~);
935		this.writeNode(node, "Literal", ~~rul~~e);
936		return node;
937		},
938		"PropertyIsGreaterThan": function(~~rule~~) {
	893	this.writeNode(node, "PropertyName", filter);
	894	this.writeNode(node, "Literal", filter.value);
	895	return node;
	896	},
	897	"PropertyIsGreaterThan": function(filter) {
939	898	var node = this.createElementNSPlus("ogc:PropertyIsGreaterThan");
940	899	// no ogc:expression handling for now
941		this.writeNode(node, "PropertyName", ~~rule~~);
942		this.writeNode(node, "Literal", ~~rul~~e);
943		return node;
944		},
945		"PropertyIsLessThanOrEqualTo": function(~~rule~~) {
	900	this.writeNode(node, "PropertyName", filter);
	901	this.writeNode(node, "Literal", filter.value);
	902	return node;
	903	},
	904	"PropertyIsLessThanOrEqualTo": function(filter) {
946	905	var node = this.createElementNSPlus("ogc:PropertyIsLessThanOrEqualTo");
947	906	// no ogc:expression handling for now
948		this.writeNode(node, "PropertyName", ~~rule~~);
949		this.writeNode(node, "Literal", ~~rul~~e);
950		return node;
951		},
952		"PropertyIsGreaterThanOrEqualTo": function(~~rule~~) {
	907	this.writeNode(node, "PropertyName", filter);
	908	this.writeNode(node, "Literal", filter.value);
	909	return node;
	910	},
	911	"PropertyIsGreaterThanOrEqualTo": function(filter) {
953	912	var node = this.createElementNSPlus("ogc:PropertyIsGreaterThanOrEqualTo");
954	913	// no ogc:expression handling for now
955		this.writeNode(node, "PropertyName", ~~rule~~);
956		this.writeNode(node, "Literal", ~~rul~~e);
957		return node;
958		},
959		"PropertyIsBetween": function(~~rule~~) {
	914	this.writeNode(node, "PropertyName", filter);
	915	this.writeNode(node, "Literal", filter.value);
	916	return node;
	917	},
	918	"PropertyIsBetween": function(filter) {
960	919	var node = this.createElementNSPlus("ogc:PropertyIsBetween");
961	920	// no ogc:expression handling for now
962		this.writeNode(node, "PropertyName", ~~rule~~);
963		this.writeNode(node, "LowerBoundary", ~~rule~~);
964		this.writeNode(node, "UpperBoundary", ~~rule~~);
965		return node;
966		},
967		"PropertyIsLike": function(~~rule~~) {
	921	this.writeNode(node, "PropertyName", filter);
	922	this.writeNode(node, "LowerBoundary", filter);
	923	this.writeNode(node, "UpperBoundary", filter);
	924	return node;
	925	},
	926	"PropertyIsLike": function(filter) {
968	927	var node = this.createElementNSPlus("ogc:PropertyIsLike", {
969	928	attributes: {
…	…
972	931	});
973	932	// no ogc:expression handling for now
974		this.writeNode(node, "PropertyName", ~~rule~~);
	933	this.writeNode(node, "PropertyName", filter);
975	934	// convert regex string to ogc string
976		this.writeNode(node, "Literal", ~~{value: rule.regex2value()}~~);
977		return node;
978		},
979		"PropertyName": function(~~rule~~) {
	935	this.writeNode(node, "Literal", filter.regex2value());
	936	return node;
	937	},
	938	"PropertyName": function(filter) {
980	939	// no ogc:expression handling for now
981	940	return this.createElementNSPlus("ogc:PropertyName", {
982		value: ~~rule~~.property
983		});
984		},
985		"Literal": function(~~rul~~e) {
	941	value: filter.property
	942	});
	943	},
	944	"Literal": function(value) {
986	945	// no ogc:expression handling for now
987	946	return this.createElementNSPlus("ogc:Literal", {
988		value: ~~rule.~~value
989		});
990		},
991		"LowerBoundary": function(~~rule~~) {
	947	value: value
	948	});
	949	},
	950	"LowerBoundary": function(filter) {
992	951	// no ogc:expression handling for now
993	952	var node = this.createElementNSPlus("ogc:LowerBoundary");
994		this.writeNode(node, "Literal", ~~rule~~.lowerBoundary);
995		return node;
996		},
997		"UpperBoundary": function(~~rule~~) {
	953	this.writeNode(node, "Literal", filter.lowerBoundary);
	954	return node;
	955	},
	956	"UpperBoundary": function(filter) {
998	957	// no ogc:expression handling for now
999	958	var node = this.createElementNSPlus("ogc:UpperBoundary");
1000		this.writeNode(node, "Literal", ~~rule~~.upperBoundary);
	959	this.writeNode(node, "Literal", filter.upperBoundary);
1001	960	return node;
1002	961	}
…	…
1007	966	* Method: getFilterType
1008	967	*/
1009		getFilterType: function(~~rule~~) {
1010		var filterType = this.filterMap[~~rule~~.type];
	968	getFilterType: function(filter) {
	969	var filterType = this.filterMap[filter.type];
1011	970	if(!filterType) {
1012		throw "SLD writing not supported for rule type: " + ~~rule~~.type;
	971	throw "SLD writing not supported for rule type: " + filter.type;
1013	972	}
1014	973	return filterType;
…	…
1017	976	/**
1018	977	* Property: filterMap
1019		* {Object} Contains a member for each ~~rule~~ type. Values are node names
	978	* {Object} Contains a member for each filter type. Values are node names
1020	979	* for corresponding OGC Filter child elements.
1021	980	*/

trunk/openlayers/lib/OpenLayers/Rule.js

r6645	r6818
11	11	/**
12	12	* Class: OpenLayers.Rule
13		* This class represents a ~~OGC~~ Rule, as being used for rule-based SLD styling.
	13	* This class represents an SLD Rule, as being used for rule-based SLD styling.
14	14	*/
15	15	OpenLayers.Rule = OpenLayers.Class({
…	…
46	46	*/
47	47	context: null,
	48
	49	/**
	50	* Property: filter
	51	* {<OpenLayers.Filter>} Optional filter for the rule.
	52	*/
	53	filter: null,
48	54
49	55	/**
…	…
137	143	this.maxScaleDenominator, context);
138	144	}
	145
	146	// check if optional filter applies
	147	if(applies && this.filter) {
	148	// feature id filters get the feature, others get the context
	149	if(this.filter.CLASS_NAME == "OpenLayers.Filter.FeatureId") {
	150	applies = this.filter.evaluate(feature);
	151	} else {
	152	applies = this.filter.evaluate(context);
	153	}
	154	}
139	155
140	156	return applies;

trunk/openlayers/tests/Style.html

r6719	r6818
28	28	var style = new OpenLayers.Style(baseStyle);
29	29
30		var rule1 = new OpenLayers.Rule.FeatureId({
31		fids: ["1"],
32		symbolizer: {"Point": {fillColor: "green"}},
33		maxScaleDenominator: 500000});
34		var rule2 = new OpenLayers.Rule.FeatureId({
35		fids: ["1"],
36		symbolizer: {"Point": {fillColor: "yellow"}},
37		minScaleDenominator: 500000,
38		maxScaleDenominator: 1000000});
39		var rule3 = new OpenLayers.Rule.FeatureId({
40		fids: ["1"],
41		symbolizer: {"Point": {fillColor: "red"}},
42		minScaleDenominator: 1000000,
43		maxScaleDenominator: 2500000});
	30	var rule1 = new OpenLayers.Rule({
	31	symbolizer: {"Point": {fillColor: "green"}},
	32	maxScaleDenominator: 500000,
	33	filter: new OpenLayers.Filter.FeatureId({
	34	fids: ["1"]
	35	})
	36	});
	37	var rule2 = new OpenLayers.Rule({
	38	symbolizer: {"Point": {fillColor: "yellow"}},
	39	minScaleDenominator: 500000,
	40	maxScaleDenominator: 1000000,
	41	filter: new OpenLayers.Filter.FeatureId({
	42	fids: ["1"]
	43	})
	44	});
	45	var rule3 = new OpenLayers.Rule({
	46	symbolizer: {"Point": {fillColor: "red"}},
	47	minScaleDenominator: 1000000,
	48	maxScaleDenominator: 2500000,
	49	filter: new OpenLayers.Filter.FeatureId({
	50	fids: ["1"]
	51	})
	52	});
44	53
45	54	var feature = new OpenLayers.Feature.Vector(
…	…
120	129	function test_Style_context(t) {
121	130	t.plan(1);
122		var rule = new OpenLayers.Rule.Comparison({
123		type: OpenLayers.Rule.Comparison.LESS_THAN,
124		property: "size",
125		value: 11,
126		symbolizer: {"Point": {externalGraphic: "${img1}"}}});
	131	var rule = new OpenLayers.Rule({
	132	symbolizer: {"Point": {externalGraphic: "${img1}"}},
	133	filter: new OpenLayers.Filter.Comparison({
	134	type: OpenLayers.Filter.Comparison.LESS_THAN,
	135	property: "size",
	136	value: 11
	137	})
	138	});
127	139	var style = new OpenLayers.Style();
128	140	style.context = {

trunk/openlayers/tests/list-tests.html

r6765	r6818
30	30	<li>Format/KML.html</li>
31	31	<li>Format/SLD.html</li>
	32	<li>Format/SLD/v1_0_0.html</li>
32	33	<li>Format/WKT.html</li>
33	34	<li>Format/WMC.html</li>
…	…
47	48	<li>StyleMap.html</li>
48	49	<li>Rule.html</li>
49		<li>Rule/Comparison.html</li>
50		<li>Rule/FeatureId.html</li>
51		<li>Rule/Logical.html</li>
	50	<li>Filter.html</li>
	51	<li>Filter/Comparison.html</li>
	52	<li>Filter/FeatureId.html</li>
	53	<li>Filter/Logical.html</li>
52	54	<li>Events.html</li>
53	55	<li>Util.html</li>