[Commits] r1460 - in sandbox/opengeo/style/geoext: examples lib lib/GeoExt/widgets tests tests/lib/GeoExt/widgets
commits at geoext.org
commits at geoext.org
Tue Nov 17 02:48:14 CET 2009
Author: tschaub
Date: 2009-11-17 02:48:14 +0100 (Tue, 17 Nov 2009)
New Revision: 1460
Added:
sandbox/opengeo/style/geoext/examples/renderer.html
sandbox/opengeo/style/geoext/examples/renderer.js
sandbox/opengeo/style/geoext/lib/GeoExt/widgets/FeatureRenderer.js
sandbox/opengeo/style/geoext/tests/lib/GeoExt/widgets/FeatureRenderer.html
Modified:
sandbox/opengeo/style/geoext/lib/GeoExt.js
sandbox/opengeo/style/geoext/tests/list-tests.html
Log:
Applying patch for the feature renderer (#175).
Added: sandbox/opengeo/style/geoext/examples/renderer.html
===================================================================
--- sandbox/opengeo/style/geoext/examples/renderer.html (rev 0)
+++ sandbox/opengeo/style/geoext/examples/renderer.html 2009-11-17 01:48:14 UTC (rev 1460)
@@ -0,0 +1,97 @@
+<html>
+<head>
+ <title>GeoExt Feature Renderer</title>
+ <script type="text/javascript" src="http://extjs.cachefly.net/builds/ext-cdn-771.js"></script>
+ <link rel="stylesheet" type="text/css" href="http://extjs.cachefly.net/ext-2.2.1/resources/css/ext-all.css" />
+ <link rel="stylesheet" type="text/css" href="http://extjs.cachefly.net/ext-2.2.1/examples/shared/examples.css" />
+ <script src="http://openlayers.org/api/2.8/OpenLayers.js"></script>
+ <script type="text/javascript" src="../lib/GeoExt.js"></script>
+
+ <script src="renderer.js"></script>
+ <style type="text/css">
+ .x-window-body {
+ background-color: white;
+ }
+ #swatches {
+ padding: 1em;
+ }
+ #swatches td {
+ border: 1px solid #ccc;
+ text-align: center;
+ margin: 0 auto;
+ padding: 0.5em;
+ }
+ #swatches td div div {
+ text-align: left; /* IE centers VML in root otherwise */
+ }
+ #wkt {
+ width: 400px;
+ height: 100px;
+ }
+ #symbolizers {
+ width: 400px;
+ height: 150px;
+ }
+ </style>
+</head>
+<body>
+ <div id="panel"></div>
+ <h1>GeoExt.FeatureRenderer</h1>
+ <p>The FeatureRenderer renderers arbitrary OpenLayers.Feature.Vector objects
+ given a list of symbolizers. The FeatureRenderer component can be used
+ anywhere a box component is used.</p>
+
+ <p>The js is not minified so it is readable. See <a href="renderer.js">renderer.js</a>.</p>
+
+ <h2>Symbol Types</h2>
+ <p>If the feature renderer is not given a feature, it can be configured to
+ render a default feature based on geometry type alone.</p>
+ <table id="swatches">
+ <tbody>
+ <tr><td> </td><td>point</td><td>line</td><td>polygon</td></tr>
+ <tr>
+ <td>default</td>
+ <td id="point_default"></td>
+ <td id="line_default"></td>
+ <td id="poly_default"></td>
+ </tr><tr>
+ <td>blue</td>
+ <td id="point_blue"></td>
+ <td id="line_blue"></td>
+ <td id="poly_blue"></td>
+ </tr><tr>
+ <td>custom</td>
+ <td id="point_custom"></td>
+ <td id="line_custom"></td>
+ <td id="poly_custom"></td>
+ </tr>
+ </tr><tr>
+ <td>stacked</td>
+ <td id="point_stacked"></td>
+ <td id="line_stacked"></td>
+ <td id="poly_stacked"></td>
+ </tr>
+ </tbody>
+ </table>
+
+ <h2>Custom Feature Rendering</h2>
+ <p>You can render any OpenLayers.Feature.Vector object with a FeatureRenderer.
+ Use the inputs below to modify the well-known text and symbolizer. These
+ will be used to render a feature in a new window.</p><br>
+ <label for="wkt">Geometry Well-Known Text</label><br>
+ <textarea id="wkt">
+POLYGON((1 30, -33 10, -39 -21, 1 -41, 23 -22, 27 15, 1 30), (0 10, -14 0, -4 -24, 12 -8, 0 10))
+ </textarea><br><br>
+ <label for="symbolizers">Feature Symbolizers</label><br>
+ <textarea id="symbolizers">
+[{
+ fillColor: "yellow",
+ fillOpacity: 1,
+ strokeColor: "blue",
+ strokeWidth: 1,
+ pointRadius: 5
+}]
+ </textarea><br>
+ <button id="render">render</button>
+</body>
+</html>
Added: sandbox/opengeo/style/geoext/examples/renderer.js
===================================================================
--- sandbox/opengeo/style/geoext/examples/renderer.js (rev 0)
+++ sandbox/opengeo/style/geoext/examples/renderer.js 2009-11-17 01:48:14 UTC (rev 1460)
@@ -0,0 +1,172 @@
+/**
+ * Copyright (c) 2008-2009 The Open Source Geospatial Foundation
+ *
+ * Published under the BSD license.
+ * See http://svn.geoext.org/core/trunk/geoext/license.txt for the full text
+ * of the license.
+ */
+
+/** api: example[renderer]
+ * Feature Renderer
+ * ----------------
+ * Render a vector feature with multiple symbolizers in a box component.
+ */
+
+var blue = {
+ fillColor: "blue",
+ fillOpacity: 0.25,
+ strokeColor: "blue",
+ strokeWidth: 2,
+ pointRadius: 5
+};
+
+var custom = {
+ point: {
+ graphicName: "star",
+ pointRadius: 8,
+ fillColor: "yellow",
+ strokeColor: "red",
+ strokeWidth: 1
+ },
+ line: {
+ strokeColor: "#669900",
+ strokeWidth: 3
+ },
+ poly: {
+ fillColor: "olive",
+ fillOpacity: 0.25,
+ strokeColor: "#666666",
+ strokeWidth: 2,
+ strokeDashstyle: "dot"
+ }
+};
+
+var stacked = {
+ point: [{
+ pointRadius: 8,
+ fillColor: "white",
+ strokeColor: "red",
+ strokeWidth: 2
+ }, {
+ graphicName: "star",
+ pointRadius: 5,
+ fillColor: "red"
+ }],
+ line: [{
+ strokeColor: "red",
+ strokeWidth: 5
+ }, {
+ strokeColor: "#ff9933",
+ strokeWidth: 2
+ }],
+ poly: [{
+ strokeWidth: 3,
+ fillColor: "white",
+ strokeColor: "#669900"
+ }, {
+ strokeWidth: 2,
+ fillOpacity: 0,
+ strokeColor: "red",
+ strokeDashstyle: "dot"
+ }]
+};
+
+var configs = [{
+ symbolType: "Point",
+ renderTo: "point_default"
+}, {
+ symbolType: "Line",
+ renderTo: "line_default"
+}, {
+ symbolType: "Polygon",
+ renderTo: "poly_default"
+}, {
+ symbolType: "Point",
+ symbolizers: [blue],
+ renderTo: "point_blue"
+}, {
+ symbolType: "Line",
+ symbolizers: [blue],
+ renderTo: "line_blue"
+}, {
+ symbolType: "Polygon",
+ symbolizers: [blue],
+ renderTo: "poly_blue"
+}, {
+ symbolType: "Point",
+ symbolizers: [custom.point],
+ renderTo: "point_custom"
+}, {
+ symbolType: "Line",
+ symbolizers: [custom.line],
+ renderTo: "line_custom"
+}, {
+ symbolType: "Polygon",
+ symbolizers: [custom.poly],
+ renderTo: "poly_custom"
+}, {
+ symbolType: "Point",
+ symbolizers: stacked.point,
+ renderTo: "point_stacked"
+}, {
+ symbolType: "Line",
+ symbolizers: stacked.line,
+ renderTo: "line_stacked"
+}, {
+ symbolType: "Polygon",
+ symbolizers: stacked.poly,
+ renderTo: "poly_stacked"
+}];
+
+Ext.onReady(function() {
+ for(var i=0; i<configs.length; ++i) {
+ new GeoExt.FeatureRenderer(configs[i]);
+ }
+ $("render").onclick = render;
+});
+
+var format = new OpenLayers.Format.WKT();
+var renderer, win;
+function render() {
+ var wkt = $("wkt").value;
+ var feature;
+ try {
+ feature = format.read(wkt)
+ } catch(err) {
+ $("wkt").value = "Bad WKT: " + err;
+ }
+ var symbolizers;
+ try {
+ var value = $("symbolizers").value;
+ symbolizers = eval("(" + value + ")");
+ if (!symbolizers || symbolizers.constructor !== Array) {
+ throw "Must be an array literal";
+ }
+ } catch(err) {
+ $("symbolizers").value = "Bad symbolizers: " + err + "\n\n" + value;
+ symbolizers = null;
+ }
+ if(feature && symbolizers) {
+ if(!win) {
+ renderer = new GeoExt.FeatureRenderer({
+ feature: feature,
+ symbolizers: symbolizers,
+ width: 150,
+ style: {margin: 4}
+ });
+ win = new Ext.Window({
+ closeAction: "hide",
+ layout: "fit",
+ width: 175,
+ items: [renderer]
+ });
+ } else {
+ renderer.update({
+ feature: feature,
+ symbolizers: symbolizers
+ });
+ }
+ win.show();
+ }
+}
+
Added: sandbox/opengeo/style/geoext/lib/GeoExt/widgets/FeatureRenderer.js
===================================================================
--- sandbox/opengeo/style/geoext/lib/GeoExt/widgets/FeatureRenderer.js (rev 0)
+++ sandbox/opengeo/style/geoext/lib/GeoExt/widgets/FeatureRenderer.js 2009-11-17 01:48:14 UTC (rev 1460)
@@ -0,0 +1,342 @@
+/**
+ * Copyright (c) 2008-2009 The Open Source Geospatial Foundation
+ *
+ * Published under the BSD license.
+ * See http://svn.geoext.org/core/trunk/geoext/license.txt for the full text
+ * of the license.
+ */
+
+/** api: (define)
+ * module = GeoExt
+ * class = FeatureRenderer
+ * base_link = `Ext.Panel <http://extjs.com/deploy/dev/docs/?class=Ext.BoxComponent>`_
+ */
+Ext.namespace('GeoExt');
+
+GeoExt.FeatureRenderer = Ext.extend(Ext.BoxComponent, {
+
+ /** api: config[feature]
+ * ``OpenLayers.Feature.Vector``
+ * Optional vector to be drawn. If a feature is not provided,
+ * ``symbolType`` should be specified.
+ */
+ feature: undefined,
+
+ /** api: config[symbolizers]
+ * ``Array(Object)``
+ * An array of symbolizer objects (in painters order) for rendering a
+ * feature. If no symbolizers are provided, the OpenLayers default will be
+ * used.
+ */
+ symbolizers: [OpenLayers.Feature.Vector.style["default"]],
+
+ /** api: config[symbolType]
+ * ``String``
+ * One of ``"Point"``, ``"Line"``, or ``"Polygon"``. If ``feature``
+ * is provided, it will be preferred. Default is ``"Point"``.
+ */
+ symbolType: "Point",
+
+ /** private: property[resolution]
+ * ``Number``
+ * The resolution for the renderer.
+ */
+ resolution: 1,
+
+ /** private: property[minWidth]
+ * ``Number``
+ */
+ minWidth: 20,
+
+ /** private: property[minHeight]
+ * ``Number``
+ */
+ minHeight: 20,
+
+ /** private: property[renderers]
+ * ``Array(String)``
+ * List of supported Renderer classes. Add to this list to add support for
+ * additional renderers. The first renderer in the list that returns
+ * ``true`` for the ``supported`` method will be used, if not defined in
+ * the ``renderer`` config property.
+ */
+ renderers: ["SVG", "VML", "Canvas"],
+
+ /** private: property[rendererOptions]
+ * ``Object``
+ * Options for the renderer. See ``OpenLayers.Renderer`` for supported
+ * options.
+ */
+ rendererOptions: null,
+
+ /** private: property[pointFeature]
+ * ``OpenLayers.Feature.Vector``
+ * Feature with point geometry.
+ */
+ pointFeature: undefined,
+
+ /** private: property[lineFeature]
+ * ``OpenLayers.Feature.Vector``
+ * Feature with LineString geometry. Default zig-zag is provided.
+ */
+ lineFeature: undefined,
+
+ /** private: property[polygonFeature]
+ * ``OpenLayers.Feature.Vector``
+ * Feature with Polygon geometry. Default is a soft cornered rectangle.
+ */
+ polygonFeature: undefined,
+
+ /** private: property[renderer]
+ * ``OpenLayers.Renderer``
+ */
+ renderer: null,
+
+ /** private: method[initComponent]
+ */
+ initComponent: function() {
+ GeoExt.FeatureRenderer.superclass.initComponent.apply(this, arguments);
+ Ext.applyIf(this, {
+ pointFeature: new OpenLayers.Feature.Vector(
+ new OpenLayers.Geometry.Point(0, 0)
+ ),
+ lineFeature: new OpenLayers.Feature.Vector(
+ new OpenLayers.Geometry.LineString([
+ new OpenLayers.Geometry.Point(-8, -3),
+ new OpenLayers.Geometry.Point(-3, 3),
+ new OpenLayers.Geometry.Point(3, -3),
+ new OpenLayers.Geometry.Point(8, 3)
+ ])
+ ),
+ polygonFeature: new OpenLayers.Feature.Vector(
+ new OpenLayers.Geometry.Polygon([
+ new OpenLayers.Geometry.LinearRing([
+ new OpenLayers.Geometry.Point(-8, -4),
+ new OpenLayers.Geometry.Point(-6, -6),
+ new OpenLayers.Geometry.Point(6, -6),
+ new OpenLayers.Geometry.Point(8, -4),
+ new OpenLayers.Geometry.Point(8, 4),
+ new OpenLayers.Geometry.Point(6, 6),
+ new OpenLayers.Geometry.Point(-6, 6),
+ new OpenLayers.Geometry.Point(-8, 4)
+ ])
+ ])
+ )
+ });
+ if(!this.feature) {
+ this.setFeature(null, {draw: false});
+ }
+ this.addEvents(
+ /** api: event[click]
+ * Fires when the feature is clicked on.
+ *
+ * Listener arguments:
+ * * renderer - ``GeoExt.FeatureRenderer`` This feature renderer.
+ */
+ "click"
+ );
+ },
+
+ /** private: method[initCustomEvents]
+ */
+ initCustomEvents: function() {
+ this.clearCustomEvents();
+ this.el.on("click", this.onClick, this);
+ },
+
+ /** private: method[clearCustomEvents]
+ */
+ clearCustomEvents: function() {
+ if (this.el && this.el.removeAllListeners) {
+ this.el.removeAllListeners();
+ }
+ },
+
+ /** private: method[onClick]
+ */
+ onClick: function() {
+ this.fireEvent("click", this);
+ },
+
+ /** private: method[onRender]
+ */
+ onRender: function(ct, position) {
+ if(!this.el) {
+ this.el = document.createElement("div");
+ this.el.id = this.getId();
+ }
+ if(!this.renderer || !this.renderer.supported()) {
+ this.assignRenderer();
+ }
+ // monkey-patch renderer so we always get a resolution
+ this.renderer.map = {
+ getResolution: (function() {
+ return this.resolution;
+ }).createDelegate(this)
+ };
+
+ this.drawFeature();
+ GeoExt.FeatureRenderer.superclass.onRender.apply(this, arguments);
+ },
+
+ /** private: method[afterRender]
+ */
+ afterRender: function() {
+ GeoExt.FeatureRenderer.superclass.afterRender.apply(this, arguments);
+ this.initCustomEvents();
+ },
+
+ /** private: method[onResize]
+ */
+ onResize: function(w, h) {
+ this.setRendererDimensions();
+ GeoExt.FeatureRenderer.superclass.onResize.apply(this, arguments);
+ },
+
+ /** private: method[setRendererDimensions]
+ */
+ setRendererDimensions: function() {
+ var gb = this.feature.geometry.getBounds();
+ var gw = gb.getWidth();
+ var gh = gb.getHeight();
+ /**
+ * Determine resolution based on the following rules:
+ * 1) always use value specified in config
+ * 2) if not specified, use max res based on width or height of element
+ * 3) if no width or height, assume a resolution of 1
+ */
+ var resolution = this.initialConfig.resolution;
+ if(!resolution) {
+ resolution = Math.max(gw / this.width || 0, gh / this.height || 0) || 1;
+ }
+ this.resolution = resolution;
+ // determine height and width of element
+ var width = Math.max(this.width || this.minWidth, gw / resolution);
+ var height = Math.max(this.height || this.minHeight, gh / resolution);
+ // determine bounds of renderer
+ var center = gb.getCenterPixel();
+ var bhalfw = width * resolution / 2;
+ var bhalfh = height * resolution / 2;
+ var bounds = new OpenLayers.Bounds(
+ center.x - bhalfw, center.y - bhalfh,
+ center.x + bhalfw, center.y + bhalfh
+ );
+ this.renderer.setSize(new OpenLayers.Size(Math.round(width), Math.round(height)));
+ this.renderer.setExtent(bounds, true);
+ },
+
+ /** private: method[assignRenderer]
+ * Iterate through the available renderer implementations and selects
+ * and assign the first one whose ``supported`` method returns ``true``.
+ */
+ assignRenderer: function() {
+ for(var i=0, len=this.renderers.length; i<len; ++i) {
+ var Renderer = OpenLayers.Renderer[this.renderers[i]];
+ if(Renderer && Renderer.prototype.supported()) {
+ this.renderer = new Renderer(
+ this.el, this.rendererOptions
+ );
+ break;
+ }
+ }
+ },
+
+ /** api: method[setSymbolizers]
+ * :arg symbolizers: ``Array(Object)`` An array of symbolizers
+ * :arg options: ``Object``
+ *
+ * Update the symbolizers used to render the feature.
+ *
+ * Valid options:
+ * * draw - ``Boolean`` Draw the feature after setting it. Default is ``true``.
+ */
+ setSymbolizers: function(symbolizers, options) {
+ this.symbolizers = symbolizers;
+ if(!options || options.draw) {
+ this.drawFeature();
+ }
+ },
+
+ /** api: method[setSymbolType]
+ * :arg type: ``String`` One of the ``symbolType`` strings.
+ * :arg options: ``Object``
+ *
+ * Create a new feature based on the geometry type and render it.
+ *
+ * Valid options:
+ * * draw - ``Boolean`` Draw the feature after setting it. Default is ``true``.
+ */
+ setSymbolType: function(type, options) {
+ this.symbolType = type;
+ this.setFeature(null, options);
+ },
+
+ /** api: method[setFeature]
+ * :arg feature: ``OpenLayers.Feature.Vector`` The feature to be rendered.
+ * If none is provided, one will be created based on ``symbolType``.
+ * :arg options: ``Object``
+ *
+ * Update the feature and redraw.
+ *
+ * Valid options:
+ * * draw - ``Boolean`` Draw the feature after setting it. Default is ``true``.
+ */
+ setFeature: function(feature, options) {
+ this.feature = feature || this[this.symbolType.toLowerCase() + "Feature"];
+ if(!options || options.draw) {
+ this.drawFeature();
+ }
+ },
+
+ /** private: method[drawFeature]
+ * Render the feature with the symbolizers.
+ */
+ drawFeature: function() {
+ this.renderer.clear();
+ this.setRendererDimensions();
+ for (var i=0, len=this.symbolizers.length; i<len; ++i) {
+ this.renderer.drawFeature(
+ this.feature.clone(),
+ Ext.apply({}, this.symbolizers[i])
+ );
+ }
+ },
+
+ /** api: method[update]
+ * :arg options: ``Object`` Object with properties to be updated.
+ *
+ * Update the ``symbolType`` or ``feature`` and ``symbolizer`` and redraw
+ * the feature.
+ *
+ * Valid options:
+ * * feature - ``OpenLayers.Feature.Vector`` The new or updated feature.
+ * If provided, the feature gets precedence over ``symbolType``.
+ * * symbolType - ``String`` One of the allowed ``symbolType`` values.
+ * * symbolizers - ``Array(Object)`` An array of symbolizer objects.
+ */
+ update: function(options) {
+ options = options || {};
+ if(options.feature) {
+ this.setFeature(options.feature, {draw: false});
+ } else if(options.symbolType) {
+ this.setSymbolType(options.symbolType, {draw: false});
+ }
+ if(options.symbolizers) {
+ this.setSymbolizers(options.symbolizers, {draw: false});
+ }
+ this.drawFeature();
+ },
+
+ /** private: method[beforeDestroy]
+ * Private method called during the destroy sequence.
+ */
+ beforeDestroy: function() {
+ this.clearCustomEvents();
+ if (this.renderer) {
+ this.renderer.destroy();
+ }
+ }
+
+});
+
+Ext.reg('gx_renderer', GeoExt.FeatureRenderer);
Modified: sandbox/opengeo/style/geoext/lib/GeoExt.js
===================================================================
--- sandbox/opengeo/style/geoext/lib/GeoExt.js 2009-11-17 01:26:05 UTC (rev 1459)
+++ sandbox/opengeo/style/geoext/lib/GeoExt.js 2009-11-17 01:48:14 UTC (rev 1460)
@@ -82,6 +82,7 @@
"GeoExt/data/WMCReader.js",
"GeoExt/widgets/Action.js",
"GeoExt/data/ProtocolProxy.js",
+ "GeoExt/widgets/FeatureRenderer.js",
"GeoExt/widgets/MapPanel.js",
"GeoExt/widgets/Popup.js",
"GeoExt/widgets/form.js",
Added: sandbox/opengeo/style/geoext/tests/lib/GeoExt/widgets/FeatureRenderer.html
===================================================================
--- sandbox/opengeo/style/geoext/tests/lib/GeoExt/widgets/FeatureRenderer.html (rev 0)
+++ sandbox/opengeo/style/geoext/tests/lib/GeoExt/widgets/FeatureRenderer.html 2009-11-17 01:48:14 UTC (rev 1460)
@@ -0,0 +1,95 @@
+<html><head>
+<script src="../../../../../openlayers/lib/OpenLayers.js"></script>
+<script src="../../../../../ext/adapter/ext/ext-base.js"></script>
+<script src="../../../../../ext/ext-all-debug.js"></script>
+<script src="../../../../lib/GeoExt.js"></script>
+<script>
+
+function test_initialize(t) {
+
+ t.plan(3);
+
+ var renderer = new GeoExt.FeatureRenderer();
+
+ t.ok(renderer instanceof Ext.BoxComponent, "instanceof BoxComponent");
+
+ var feature = renderer.feature;
+ t.ok(feature, "renderer feature set by default");
+ t.ok(feature.geometry instanceof OpenLayers.Geometry.Point, "point feature by default");
+
+ renderer.destroy();
+
+}
+
+function test_drawFeature(t) {
+ t.plan(4);
+
+
+ var renderer = new GeoExt.FeatureRenderer({
+ renderTo: document.body
+ });
+
+ t.ok(renderer.rendered, "rendered");
+ t.ok(renderer.renderer instanceof OpenLayers.Renderer, "has an OL renderer");
+
+ var log = [];
+ renderer.renderer.drawFeature = function() {
+ log.push(arguments);
+ OpenLayers.Renderer.prototype.drawFeature.apply(this, arguments);
+ };
+
+ renderer.update({
+ symbolizers: [{pointRadius: 3}, {pointRadius: 2, fillColor: "white"}]
+ });
+ t.eq(log.length, 2, "drawFeature called twice for two symbolizers");
+ t.ok(log[0][0] !== log[1][0], "drawFeature called with unique features");
+
+ renderer.destroy();
+
+}
+
+function test_update(t) {
+
+ t.plan(6);
+
+ var renderer = new GeoExt.FeatureRenderer({
+ renderTo: document.body
+ });
+
+ var count = 0;
+ renderer.drawFeature = function() {
+ ++count;
+ GeoExt.FeatureRenderer.prototype.drawFeature.apply(this, arguments);
+ };
+
+ // update with new geometry type
+ renderer.update({geometryType: "Polygon"});
+ t.eq(count, 1, "drawFeature called when updating geometryType");
+ t.ok(renderer.feature.geometry instanceof OpenLayers.Geometry.Polygon, "polygon feature created when setting geometryType");
+
+ // update with a new feature
+ count = 0;
+ var feature = new OpenLayers.Feature.Vector(
+ OpenLayers.Geometry.fromWKT("LINESTRING(0 0, 1 1)")
+ );
+ renderer.update({feature: feature});
+ t.eq(count, 1, "drawFeature called when updating feature");
+ t.ok(renderer.feature === feature, "feature set when updating");
+
+ // update with new symbolizers
+ count = 0;
+ var symbolizers = [{
+ strokeWidth: 3, strokeColor: "red"
+ }, {
+ strokeWidth: 1, strokeColor: "blue"
+ }];
+ renderer.update({symbolizers: symbolizers});
+ t.eq(count, 1, "drawFeature called when updating symbolizers");
+ t.ok(renderer.symbolizers === symbolizers, "symbolizers set when updating");
+
+ renderer.destroy();
+
+}
+
+</script>
+</head><body></body></html>
\ No newline at end of file
Modified: sandbox/opengeo/style/geoext/tests/list-tests.html
===================================================================
--- sandbox/opengeo/style/geoext/tests/list-tests.html 2009-11-17 01:26:05 UTC (rev 1459)
+++ sandbox/opengeo/style/geoext/tests/list-tests.html 2009-11-17 01:48:14 UTC (rev 1460)
@@ -14,6 +14,7 @@
<li>lib/GeoExt/data/WMSDescribeLayerReader.html</li>
<li>lib/GeoExt/data/WMCReader.html</li>
<li>lib/GeoExt/widgets/Action.html</li>
+ <li>lib/GeoExt/widgets/FeatureRenderer.html</li>
<li>lib/GeoExt/widgets/LayerOpacitySlider.html</li>
<li>lib/GeoExt/widgets/MapPanel.html</li>
<li>lib/GeoExt/widgets/Popup.html</li>
More information about the Commits
mailing list