ashatora/openlayers
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

Remove old ol.Feature

Browse Source
This commit is contained in:
Tom Payne
2014-01-18 20:15:25 +01:00
parent eefb909c86
commit c74f0ba0e3
3 changed files with 0 additions and 543 deletions
Download Patch File Download Diff File Expand all files Collapse all files

6
old/src/ol/feature.exports
View File

@@ -1,6 +0,0 @@
@exportSymbol ol.Feature
@exportProperty ol.Feature.prototype.getAttributes
@exportProperty ol.Feature.prototype.getId
@exportProperty ol.Feature.prototype.getGeometry
@exportProperty ol.Feature.prototype.set
@exportProperty ol.Feature.prototype.setGeometry

268
old/src/ol/feature.js
View File

@@ -1,268 +0,0 @@
goog.provide('ol.Feature');
goog.provide('ol.FeatureEvent');
goog.provide('ol.FeatureEventType');
goog.provide('ol.FeatureRenderIntent');
goog.require('goog.events');
goog.require('goog.events.Event');
goog.require('goog.events.EventType');
goog.require('ol.Object');
goog.require('ol.geom.Geometry');
/**
* Create a new feature. A feature is the base entity for vectors and has
* attributes, including normally a geometry attribute.
*
* Example:
*
* var feature = new ol.Feature({'foo': 'bar'});
* feature.setGeometry(new ol.geom.Point([100, 500]));
*
* @constructor
* @extends {ol.Object}
* @param {Object.<string, *>=} opt_values Attributes.
* @todo stability experimental
*/
ol.Feature = function(opt_values) {
/**
* @type {ol.Extent}
* @private
*/
this.geometryExtent_ = null;
goog.base(this, opt_values);
/**
* @type {string|undefined}
* @private
*/
this.featureId_;
/**
* @type {string|undefined}
* @private
*/
this.geometryName_;
/**
* The render intent for this feature.
* @type {ol.FeatureRenderIntent|string}
* @private
*/
this.renderIntent_ = ol.FeatureRenderIntent.DEFAULT;
/**
* @type {Array.<ol.style.Symbolizer>}
* @private
*/
this.symbolizers_ = null;
};
goog.inherits(ol.Feature, ol.Object);
/**
* Gets a copy of the attributes of this feature.
* @param {boolean=} opt_nonGeometry Don't include any geometry attributes
* (by default geometry attributes are returned).
* @return {Object.<string, *>} Attributes object.
* @todo stability experimental
*/
ol.Feature.prototype.getAttributes = function(opt_nonGeometry) {
var keys = this.getKeys(),
includeGeometry = !opt_nonGeometry,
len = keys.length,
attributes = {},
i, value, key;
for (i = 0; i < len; ++ i) {
key = keys[i];
value = this.get(key);
if (includeGeometry || !(value instanceof ol.geom.Geometry)) {
attributes[key] = value;
}
}
return attributes;
};
/**
* Returns the feature's commonly used identifier. This identifier is usually
* the unique id in the source store.
*
* @return {string|undefined} The feature's identifier.
* @todo stability experimental
*/
ol.Feature.prototype.getId = function() {
return this.featureId_;
};
/**
* Get the geometry associated with this feature.
* @return {ol.geom.Geometry} The geometry (or null if none).
* @todo stability experimental
*/
ol.Feature.prototype.getGeometry = function() {
return goog.isDef(this.geometryName_) ?
/** @type {ol.geom.Geometry} */ (this.get(this.geometryName_)) :
null;
};
/**
* Get any symbolizers set directly on the feature.
* @return {Array.<ol.style.Symbolizer>} Symbolizers (or null if none).
*/
ol.Feature.prototype.getSymbolizers = function() {
return this.symbolizers_;
};
/**
* Listener for geometry change events.
* @param {goog.events.Event} evt Change event.
* @private
*/
ol.Feature.prototype.handleGeometryChange_ = function(evt) {
var oldExtent = this.geometryExtent_;
this.geometryExtent_ = this.getGeometry().getBounds();
this.dispatchEvent(new ol.FeatureEvent(
ol.FeatureEventType.CHANGE, this, oldExtent));
};
/**
* @inheritDoc
* @param {string} key Key.
* @param {*} value Value.
* @todo stability experimental
*/
ol.Feature.prototype.set = function(key, value) {
var geometry = this.getGeometry();
var oldExtent = this.geometryExtent_;
if (goog.isDefAndNotNull(geometry)) {
if (key === this.geometryName_) {
this.geometryExtent_ = null;
goog.events.unlisten(geometry, goog.events.EventType.CHANGE,
this.handleGeometryChange_, false, this);
}
}
if (value instanceof ol.geom.Geometry) {
if (!goog.isDef(this.geometryName_)) {
this.geometryName_ = key;
}
if (key === this.geometryName_) {
this.geometryExtent_ = value.getBounds();
goog.events.listen(value, goog.events.EventType.CHANGE,
this.handleGeometryChange_, false, this);
}
}
goog.base(this, 'set', key, value);
this.dispatchEvent(new ol.FeatureEvent(
ol.FeatureEventType.CHANGE, this, oldExtent));
};
/**
* Set the feature's commonly used identifier. This identifier is usually the
* unique id in the source store.
*
* @param {string|undefined} featureId The feature's identifier.
*/
ol.Feature.prototype.setId = function(featureId) {
this.featureId_ = featureId;
};
/**
* Set the geometry to be associated with this feature after its creation.
* @param {ol.geom.Geometry} geometry The geometry.
* @todo stability experimental
*/
ol.Feature.prototype.setGeometry = function(geometry) {
if (!goog.isDef(this.geometryName_)) {
this.geometryName_ = ol.Feature.DEFAULT_GEOMETRY;
}
this.set(this.geometryName_, geometry);
};
/**
* Gets the renderIntent for this feature.
* @return {string} Render intent.
*/
ol.Feature.prototype.getRenderIntent = function() {
return this.renderIntent_;
};
/**
* Changes the renderIntent for this feature.
* @param {string} renderIntent Render intent.
*/
ol.Feature.prototype.setRenderIntent = function(renderIntent) {
this.renderIntent_ = renderIntent;
var geometry = this.getGeometry();
if (!goog.isNull(geometry)) {
this.dispatchEvent(new ol.FeatureEvent(
ol.FeatureEventType.INTENTCHANGE, this, geometry.getBounds()));
}
};
/**
* Set the symbolizers to be used for this feature.
* @param {Array.<ol.style.Symbolizer>} symbolizers Symbolizers for this
* feature. If set, these take precedence over layer style.
*/
ol.Feature.prototype.setSymbolizers = function(symbolizers) {
this.symbolizers_ = symbolizers;
};
/**
* @const
* @type {string}
*/
ol.Feature.DEFAULT_GEOMETRY = 'geometry';
/**
* @enum {string}
*/
ol.FeatureRenderIntent = {
DEFAULT: 'default',
FUTURE: 'future',
HIDDEN: 'hidden',
SELECTED: 'selected',
TEMPORARY: 'temporary'
};
/**
* @enum {string}
*/
ol.FeatureEventType = {
CHANGE: 'featurechange',
INTENTCHANGE: 'featureintentchange'
};
/**
* Constructor for feature events.
* @constructor
* @extends {goog.events.Event}
* @param {string} type Event type.
* @param {ol.Feature} target The target feature.
* @param {ol.Extent} oldExtent The previous geometry extent.
*/
ol.FeatureEvent = function(type, target, oldExtent) {
goog.base(this, type, target);
this.oldExtent = oldExtent;
};
goog.inherits(ol.FeatureEvent, goog.events.Event);

269
old/test/spec/ol/feature.test.js
View File

@@ -1,269 +0,0 @@
goog.provide('ol.test.Feature');
describe('ol.Feature', function() {
describe('constructor', function() {
it('creates a new feature', function() {
var feature = new ol.Feature();
expect(feature).to.be.a(ol.Feature);
});
it('takes attribute values', function() {
var feature = new ol.Feature({
foo: 'bar'
});
expect(feature.get('foo')).to.be('bar');
});
it('can store the feature\'s commonly used id', function() {
var feature = new ol.Feature();
feature.setId('foo');
expect(feature.getId()).to.be('foo');
});
it('will set the default geometry', function() {
var feature = new ol.Feature({
loc: new ol.geom.Point([10, 20]),
foo: 'bar'
});
var geometry = feature.getGeometry();
expect(geometry).to.be.a(ol.geom.Point);
expect(feature.get('loc')).to.be(geometry);
});
});
describe('#get()', function() {
it('returns values set at construction', function() {
var feature = new ol.Feature({
a: 'first',
b: 'second'
});
expect(feature.get('a')).to.be('first');
expect(feature.get('b')).to.be('second');
});
it('returns undefined for unset attributes', function() {
var feature = new ol.Feature();
expect(feature.get('a')).to.be(undefined);
});
it('returns values set by set', function() {
var feature = new ol.Feature();
feature.set('a', 'b');
expect(feature.get('a')).to.be('b');
});
});
describe('#getAttributes()', function() {
it('returns an object with all attributes', function() {
var point = new ol.geom.Point([15, 30]);
var feature = new ol.Feature({
foo: 'bar',
ten: 10,
loc: point
});
var attributes = feature.getAttributes();
var keys = goog.object.getKeys(attributes);
expect(keys.sort()).to.eql(['foo', 'loc', 'ten']);
expect(attributes.foo).to.be('bar');
expect(attributes.loc).to.be(point);
expect(attributes.ten).to.be(10);
});
it('returns an object with all attributes except geometry', function() {
var point = new ol.geom.Point([15, 30]);
var feature = new ol.Feature({
foo: 'bar',
ten: 10,
loc: point
});
var attributes = feature.getAttributes(true);
var keys = goog.object.getKeys(attributes);
expect(keys.sort()).to.eql(['foo', 'ten']);
expect(attributes.foo).to.be('bar');
expect(attributes.ten).to.be(10);
});
});
describe('#getGeometry()', function() {
var point = new ol.geom.Point([15, 30]);
it('returns null for no geometry', function() {
var feature = new ol.Feature();
expect(feature.getGeometry()).to.be(null);
});
it('gets the geometry set at construction', function() {
var feature = new ol.Feature({
geom: point
});
expect(feature.getGeometry()).to.be(point);
});
it('gets any geometry set by setGeometry', function() {
var feature = new ol.Feature();
feature.setGeometry(point);
expect(feature.getGeometry()).to.be(point);
var point2 = new ol.geom.Point([1, 2]);
feature.setGeometry(point2);
expect(feature.getGeometry()).to.be(point2);
});
it('gets the first geometry set by set', function() {
var feature = new ol.Feature();
feature.set('foo', point);
expect(feature.getGeometry()).to.be(point);
feature.set('bar', new ol.geom.Point([1, 2]));
expect(feature.getGeometry()).to.be(point);
});
});
describe('#set()', function() {
it('sets values', function() {
var feature = new ol.Feature({
a: 'first',
b: 'second'
});
feature.set('a', 'new');
expect(feature.get('a')).to.be('new');
});
it('can be used to set the geometry', function() {
var point = new ol.geom.Point([3, 4]);
var feature = new ol.Feature({
loc: new ol.geom.Point([1, 2])
});
feature.set('loc', point);
expect(feature.get('loc')).to.be(point);
expect(feature.getGeometry()).to.be(point);
});
it('can be used to set attributes with arbitrary names', function() {
var feature = new ol.Feature();
feature.set('toString', 'string');
expect(feature.get('toString')).to.be('string');
expect(typeof feature.toString).to.be('function');
feature.set('getGeometry', 'x');
expect(feature.get('getGeometry')).to.be('x');
feature.set('geom', new ol.geom.Point([1, 2]));
expect(feature.getGeometry()).to.be.a(ol.geom.Point);
});
it('triggers a featurechange event', function(done) {
var feature = new ol.Feature();
goog.events.listen(feature, 'featurechange', function(evt) {
expect(evt.target).to.be(feature);
expect(evt.oldExtent).to.be(null);
done();
});
feature.set('foo', 'bar');
});
it('triggers a featurechange event with oldExtent', function(done) {
var feature = new ol.Feature({
geom: new ol.geom.Point([15, 30])
});
goog.events.listen(feature, 'featurechange', function(evt) {
expect(evt.target).to.be(feature);
expect(evt.oldExtent).to.eql([15, 30, 15, 30]);
done();
});
feature.setGeometry(new ol.geom.Point([1, 2]));
});
});
describe('#setGeometry()', function() {
var point = new ol.geom.Point([15, 30]);
it('sets the default geometry', function() {
var feature = new ol.Feature();
feature.setGeometry(point);
expect(feature.get(ol.Feature.DEFAULT_GEOMETRY)).to.be(point);
});
it('replaces previous default geometry', function() {
var feature = new ol.Feature({
geom: point
});
expect(feature.getGeometry()).to.be(point);
var point2 = new ol.geom.Point([1, 2]);
feature.setGeometry(point2);
expect(feature.getGeometry()).to.be(point2);
});
it('gets any geometry set by setGeometry', function() {
var feature = new ol.Feature();
feature.setGeometry(point);
expect(feature.getGeometry()).to.be(point);
var point2 = new ol.geom.Point([1, 2]);
feature.setGeometry(point2);
expect(feature.getGeometry()).to.be(point2);
});
it('gets the first geometry set by set', function() {
var feature = new ol.Feature();
feature.set('foo', point);
expect(feature.getGeometry()).to.be(point);
feature.set('bar', new ol.geom.Point([1, 2]));
expect(feature.getGeometry()).to.be(point);
});
it('triggers a featurechange event', function(done) {
var feature = new ol.Feature();
goog.events.listen(feature, 'featurechange', function(evt) {
expect(evt.target).to.be(feature);
done();
});
feature.setGeometry('foo', point);
});
it('triggers a featurechange event with old extent', function(done) {
var first = new ol.geom.Point([10, 20]);
var feature = new ol.Feature({geom: first});
var second = new ol.geom.Point([20, 30]);
goog.events.listen(feature, 'featurechange', function(evt) {
expect(evt.target).to.be(feature);
expect(evt.target.getGeometry()).to.be(second);
expect(evt.oldExtent).to.eql(first.getBounds());
done();
});
feature.setGeometry(second);
});
});
});
goog.require('goog.events');
goog.require('goog.object');
goog.require('ol.Feature');
goog.require('ol.geom.Point');