4764756866

Build Type

push

github

Committed by GitHub

Commit Message

Merge pull request #728 from terrestris/ol7-fixes

Run Details

1014 of 3980 branches covered (25.48%)

16 of 16 new or added lines in 2 files covered. (100.0%)

2595 of 8244 relevant lines covered (31.48%)

4.72 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

25.88

/src/plugin/HoverClick.js

Ext.define('BasiGX.plugin.HoverClick', {
    extend: 'BasiGX.plugin.Hover',

    alias: 'plugin.hoverClick',
    pluginId: 'hoverClick',

    inheritableStatics: {
        /**
         * The property of a layer that holds a boolean value which indicates
         * whether this layer qualifies for clicking.
         */
        LAYER_CLICKABLE_PROPERTY_NAME: 'clickable'
    },

    config: {
        /**
         * Enable/Disable hovering globally. If false, the plugin will not
         * listen to any hover event, regardless if a layer has a truthy
         * hoverable property.
         */
        hoverable: true,
        /**
         * Enable/Disable clicking globally. If false, the plugin will not
         * listen to any click event, regardless if a layer has a truthy
         * clickable property.
         */
        clickable: true,

        /**
         * Control state of click event on the map. If the underlying HSI button
         * gets untoggled, click interaction on the map should be deactivated.
         */
        clickActive: true
    },

    init: function (cmp) {
        var me = this;

        me.checkSelectEventOrigin();

        me.addHoverVectorLayerSource();
        me.addHoverVectorLayer();

        if (me.getEnableHoverSelection() && me.getClickable()) {
            me.addHoverVectorLayerInteraction();
        }

        me.setupMapEventListeners();
        me.setCmp(cmp);

        cmp.setPointerRest(me.getPointerRest());
        cmp.setPointerRestInterval(me.getPointerRestInterval());
        cmp.setPointerRestPixelTolerance(me.getPointerRestPixelTolerance());

        if (me.getHoverable()) {
            cmp.on('pointerrest', me.onPointerRest, me);
            cmp.on('pointerrestout', me.cleanupHoverArtifacts, me);
        }
    },

    /**
     * Adds the onClick event to the registered super events,
     * if clickable is true.
     *
     * @private
     */
    setupMapEventListeners: function () {
        var me = this;
        me.callParent();

        if (me.getClickable() && me.getClickActive()) {
            var mapComponent = me.getCmp();
            var map = mapComponent.getMap();
            map.on('click', me.onClick.bind(me));
        }
    },

    /**
     *
     */
    addHoverVectorLayerInteraction: function () {
        var me = this;
        var mapComponent = me.getCmp();
        var map = mapComponent.getMap();

        if (!me.getHoverVectorLayerInteraction()) {
            var interaction = new ol.interaction.Select({
                multi: me.selectMulti,
                style: me.selectStyleFunction,
                layers: [me.getHoverVectorLayer()],
                filter: me.clickable ? me.filterClickableFeatures : undefined
            });
            if (me.selectEventOrigin === 'collection') {
                var featureCollection = interaction.getFeatures();
                featureCollection.on('add', me.onFeatureClicked.bind(me));
            } else {
                interaction.on('select', me.onFeatureClicked.bind(me));
            }
            map.addInteraction(interaction);
            me.setHoverVectorLayerInteraction(interaction);
        }
    },

    /**
     * Overwrites the hover.js onFeatureClicked method to
     * a noop method, as this function does not fit into
     * the hoverClick concept with separate workflows
     * for hovering and clicking.
     *
     * @return {undefined}
     */
    onFeatureClicked: function () {
        return;
    },

    /**
     * Filters the clickable features by checking the
     * isClickable property.
     *
     * @param {ol.feature} feature the feature to check.
     * @return {Boolean} Whether the feature is clickable.
     */
    filterClickableFeatures: function (feature) {
        return feature.isClickable;
    },

    /**
     * The handler for the click event on the map.
     *
     * @param {MouseEvent.onClick} evt The onClick event
     */
    onClick: function (evt) {

        var me = this;

        if (!me.getClickActive()) {
            return;
        }

        var mapComponent = me.getCmp();
        var map = mapComponent.getMap();
        var mapView = map.getView();
        var allLayers = map.getAllLayers();
        var pixel = evt.pixel;
        var hoverFeaturesRevertProp = me.self.LAYER_HOVER_FEATURES_REVERT_NAME;
        var clickableProp = me.self.LAYER_CLICKABLE_PROPERTY_NAME;
        var hoverLayers = [];
        var hoverFeatures = [];

        me.cleanupHoverArtifacts();

        var callback = function(layer, pixelValues) {
            if (!layer.get(clickableProp)) {
                return;
            }

            var source = layer.getSource();
            var resolution = mapView.getResolution();
            var projCode = mapView.getProjection().getCode();
            var hoverFeaturesRevert = layer.get(hoverFeaturesRevertProp);

            if (source instanceof ol.source.TileWMS
                    || source instanceof ol.source.ImageWMS) {

                var url = source.getFeatureInfoUrl(
                    evt.coordinate,
                    resolution,
                    projCode,
                    {
                        'INFO_FORMAT': 'application/json',
                        'FEATURE_COUNT': me.getFeatureInfoCount()
                    }
                );

                me.requestAsynchronously(url, function(resp) {
                    // TODO: replace evt/coords with real response geometry
                    var respFeatures = (new ol.format.GeoJSON())
                        .readFeatures(resp.responseText);
                    var respProjection = (new ol.format.GeoJSON())
                        .readProjection(resp.responseText);

                    me.showHoverFeature(
                        layer, respFeatures, respProjection
                    );

                    Ext.each(respFeatures, function(feature) {
                        feature.set('layer', layer);
                        var featureStyle = me.highlightStyleFunction(
                            feature, resolution, pixelValues);
                        feature.setStyle(featureStyle);
                        hoverFeatures.push(feature);
                    });
                    if (hoverFeaturesRevert) {
                        hoverFeatures.reverse();
                    }

                    hoverLayers.push(layer);
                    mapComponent.fireEvent('hoverfeaturesclick', hoverFeatures);
                });
            } else if (source instanceof ol.source.Vector) {
                // VECTOR!
                map.forEachFeatureAtPixel(pixel, function(feat) {
                    if (layer.get('type') === 'WFS' ||
                            layer.get('type') === 'WFSCluster') {
                        var hvl = me.getHoverVectorLayer();
                        // TODO This should be dynamically generated
                        // from the clusterStyle
                        hvl.setStyle(me.highlightStyleFunction);
                    }
                    if (!Ext.Array.contains(hoverLayers, layer)) {
                        hoverLayers.push(layer);
                    }
                    if (feat.get('layer') === layer) {
                        var clone = feat.clone();
                        clone.setId(feat.getId());

                        var hoverFeaturesIds = Ext.Array.map(hoverFeatures,
                            function(hoverFeat) {
                                return hoverFeat.getId();
                            });
                        if (!Ext.Array.contains(hoverFeaturesIds,
                            feat.getId())) {
                            var style = me.highlightStyleFunction(
                                clone, resolution, pixel);
                            clone.setStyle(style);
                            hoverFeatures.push(clone);
                        }
                    }
                    me.showHoverFeature(layer, hoverFeatures);
                    me.currentHoverTarget = feat;
                    mapComponent.fireEvent('hoverfeaturesclick', hoverFeatures);
                }, {
                    layerFilter: function(vectorCand) {
                        return vectorCand === layer;
                    }
                });
            }
        };

        allLayers.forEach(function(lyr) {
            var layerData = lyr.getData(pixel);
            if (layerData) {
                var alphaValue = layerData.at(3);
                if (alphaValue > 0 && me.clickLayerFilter(lyr)) {
                    callback(lyr, layerData);
                }
            }
        });

    },

    /**
     * @param {ol.layer.Base} candidate The layer to check.
     * @return {Boolean} Whether the passed layer should be clickable.
     */
    clickLayerFilter: function (candidate) {
        var me = this;
        var clickableProp = me.self.LAYER_CLICKABLE_PROPERTY_NAME;

        if (candidate.get(clickableProp) ||
                candidate.get('type') === 'WFSCluster') {
            return true;
        } else {
            return false;
        }
    },

    /**
     * Adds the passed features to the hover vector layer.
     *
     * @param {ol.layer.Layer} layer The layer. Currently unused in the method.
     * @param {Array<ol.Feature>} features The features to hover by adding them
     *     to the source of the hover vector layer.
     * @param {ol.Projection} projection The projection of the features.
     */
    showHoverFeature: function(layer, features, projection) {
        var me = this;
        var mapComponent = me.getCmp();
        var map = mapComponent.getMap();
        var proj = me.getFeatureInfoEpsg();
        var clickableProp = me.self.LAYER_CLICKABLE_PROPERTY_NAME;
        var clickable = layer.get(clickableProp);

        if (projection) {
            proj = projection;
        }
        var source = me.getHoverVectorLayerSource();
        Ext.each(features, function(feat) {
            feat.isClickable = clickable;
            var g = feat.getGeometry();
            if (g) {
                g.transform(proj, map.getView().getProjection());
            }
            if (!Ext.Array.contains(source.getFeatures(),
                feat)) {
                source.addFeature(feat);
            }
        });
    }

});

1	Ext.define('BasiGX.plugin.HoverClick', {	1✔
2	extend: 'BasiGX.plugin.Hover',
3
4	alias: 'plugin.hoverClick',
5	pluginId: 'hoverClick',
6
7	inheritableStatics: {
8	/**
9	* The property of a layer that holds a boolean value which indicates
10	* whether this layer qualifies for clicking.
11	*/
12	LAYER_CLICKABLE_PROPERTY_NAME: 'clickable'
13	},
14
15	config: {
16	/**
17	* Enable/Disable hovering globally. If false, the plugin will not
18	* listen to any hover event, regardless if a layer has a truthy
19	* hoverable property.
20	*/
21	hoverable: true,
22	/**
23	* Enable/Disable clicking globally. If false, the plugin will not
24	* listen to any click event, regardless if a layer has a truthy
25	* clickable property.
26	*/
27	clickable: true,
28
29	/**
30	* Control state of click event on the map. If the underlying HSI button
31	* gets untoggled, click interaction on the map should be deactivated.
32	*/
33	clickActive: true
34	},
35
36	init: function (cmp) {
37	var me = this;	8✔
38
39	me.checkSelectEventOrigin();	8✔
40
41	me.addHoverVectorLayerSource();	8✔
42	me.addHoverVectorLayer();	8✔
43
44	if (me.getEnableHoverSelection() && me.getClickable()) {	8✔
45	me.addHoverVectorLayerInteraction();	6✔
46	}
47
48	me.setupMapEventListeners();	8✔
49	me.setCmp(cmp);	8✔
50
51	cmp.setPointerRest(me.getPointerRest());	8✔
52	cmp.setPointerRestInterval(me.getPointerRestInterval());	8✔
53	cmp.setPointerRestPixelTolerance(me.getPointerRestPixelTolerance());	8✔
54
55	if (me.getHoverable()) {	8✔
56	cmp.on('pointerrest', me.onPointerRest, me);	6✔
57	cmp.on('pointerrestout', me.cleanupHoverArtifacts, me);	6✔
58	}
59	},
60
61	/**
62	* Adds the onClick event to the registered super events,
63	* if clickable is true.
64	*
65	* @private
66	*/
67	setupMapEventListeners: function () {
68	var me = this;	8✔
69	me.callParent();	8✔
70
71	if (me.getClickable() && me.getClickActive()) {	8✔
72	var mapComponent = me.getCmp();	6✔
73	var map = mapComponent.getMap();	6✔
74	map.on('click', me.onClick.bind(me));	6✔
75	}
76	},
77
78	/**
79	*
80	*/
81	addHoverVectorLayerInteraction: function () {
82	var me = this;	6✔
83	var mapComponent = me.getCmp();	6✔
84	var map = mapComponent.getMap();	6✔
85
86	if (!me.getHoverVectorLayerInteraction()) {	6!
87	var interaction = new ol.interaction.Select({	6✔
88	multi: me.selectMulti,
89	style: me.selectStyleFunction,
90	layers: [me.getHoverVectorLayer()],
91	filter: me.clickable ? me.filterClickableFeatures : undefined	6!
92	});
93	if (me.selectEventOrigin === 'collection') {	6!
94	var featureCollection = interaction.getFeatures();	6✔
95	featureCollection.on('add', me.onFeatureClicked.bind(me));	6✔
96	} else {
97	interaction.on('select', me.onFeatureClicked.bind(me));	×
98	}
99	map.addInteraction(interaction);	6✔
100	me.setHoverVectorLayerInteraction(interaction);	6✔
101	}
102	},
103
104	/**
105	* Overwrites the hover.js onFeatureClicked method to
106	* a noop method, as this function does not fit into
107	* the hoverClick concept with separate workflows
108	* for hovering and clicking.
109	*
110	* @return {undefined}
111	*/
112	onFeatureClicked: function () {
113	return;	×
114	},
115
116	/**
117	* Filters the clickable features by checking the
118	* isClickable property.
119	*
120	* @param {ol.feature} feature the feature to check.
121	* @return {Boolean} Whether the feature is clickable.
122	*/
123	filterClickableFeatures: function (feature) {
124	return feature.isClickable;	×
125	},
126
127	/**
128	* The handler for the click event on the map.
129	*
130	* @param {MouseEvent.onClick} evt The onClick event
131	*/
132	onClick: function (evt) {
133
134	var me = this;	×
135
136	if (!me.getClickActive()) {	×
137	return;	×
138	}
139
140	var mapComponent = me.getCmp();	×
141	var map = mapComponent.getMap();	×
142	var mapView = map.getView();	×
143	var allLayers = map.getAllLayers();	×
144	var pixel = evt.pixel;	×
145	var hoverFeaturesRevertProp = me.self.LAYER_HOVER_FEATURES_REVERT_NAME;	×
146	var clickableProp = me.self.LAYER_CLICKABLE_PROPERTY_NAME;	×
147	var hoverLayers = [];	×
148	var hoverFeatures = [];	×
149
150	me.cleanupHoverArtifacts();	×
151
152	var callback = function(layer, pixelValues) {	×
153	if (!layer.get(clickableProp)) {	×
154	return;	×
155	}
156
157	var source = layer.getSource();	×
158	var resolution = mapView.getResolution();	×
159	var projCode = mapView.getProjection().getCode();	×
160	var hoverFeaturesRevert = layer.get(hoverFeaturesRevertProp);	×
161
162	if (source instanceof ol.source.TileWMS	×
163	\|\| source instanceof ol.source.ImageWMS) {
164
165	var url = source.getFeatureInfoUrl(	×
166	evt.coordinate,
167	resolution,
168	projCode,
169	{
170	'INFO_FORMAT': 'application/json',
171	'FEATURE_COUNT': me.getFeatureInfoCount()
172	}
173	);
174
175	me.requestAsynchronously(url, function(resp) {	×
176	// TODO: replace evt/coords with real response geometry
177	var respFeatures = (new ol.format.GeoJSON())	×
178	.readFeatures(resp.responseText);
179	var respProjection = (new ol.format.GeoJSON())	×
180	.readProjection(resp.responseText);
181
182	me.showHoverFeature(	×
183	layer, respFeatures, respProjection
184	);
185
186	Ext.each(respFeatures, function(feature) {	×
187	feature.set('layer', layer);	×
188	var featureStyle = me.highlightStyleFunction(	×
189	feature, resolution, pixelValues);
190	feature.setStyle(featureStyle);	×
191	hoverFeatures.push(feature);	×
192	});
193	if (hoverFeaturesRevert) {	×
194	hoverFeatures.reverse();	×
195	}
196
197	hoverLayers.push(layer);	×
198	mapComponent.fireEvent('hoverfeaturesclick', hoverFeatures);	×
199	});
200	} else if (source instanceof ol.source.Vector) {	×
201	// VECTOR!
202	map.forEachFeatureAtPixel(pixel, function(feat) {	×
203	if (layer.get('type') === 'WFS' \|\|	×
204	layer.get('type') === 'WFSCluster') {
205	var hvl = me.getHoverVectorLayer();	×
206	// TODO This should be dynamically generated
207	// from the clusterStyle
208	hvl.setStyle(me.highlightStyleFunction);	×
209	}
210	if (!Ext.Array.contains(hoverLayers, layer)) {	×
211	hoverLayers.push(layer);	×
212	}
213	if (feat.get('layer') === layer) {	×
214	var clone = feat.clone();	×
215	clone.setId(feat.getId());	×
216
217	var hoverFeaturesIds = Ext.Array.map(hoverFeatures,	×
218	function(hoverFeat) {
219	return hoverFeat.getId();	×
220	});
221	if (!Ext.Array.contains(hoverFeaturesIds,	×
222	feat.getId())) {
223	var style = me.highlightStyleFunction(	×
224	clone, resolution, pixel);
225	clone.setStyle(style);	×
226	hoverFeatures.push(clone);	×
227	}
228	}
229	me.showHoverFeature(layer, hoverFeatures);	×
230	me.currentHoverTarget = feat;	×
231	mapComponent.fireEvent('hoverfeaturesclick', hoverFeatures);	×
232	}, {
233	layerFilter: function(vectorCand) {
234	return vectorCand === layer;	×
235	}
236	});
237	}
238	};
239
240	allLayers.forEach(function(lyr) {	×
241	var layerData = lyr.getData(pixel);	×
242	if (layerData) {	×
243	var alphaValue = layerData.at(3);	×
244	if (alphaValue > 0 && me.clickLayerFilter(lyr)) {	×
245	callback(lyr, layerData);	×
246	}
247	}
248	});
249
250	},
251
252	/**
253	* @param {ol.layer.Base} candidate The layer to check.
254	* @return {Boolean} Whether the passed layer should be clickable.
255	*/
256	clickLayerFilter: function (candidate) {
257	var me = this;	×
258	var clickableProp = me.self.LAYER_CLICKABLE_PROPERTY_NAME;	×
259
260	if (candidate.get(clickableProp) \|\|	×
261	candidate.get('type') === 'WFSCluster') {
262	return true;	×
263	} else {
264	return false;	×
265	}
266	},
267
268	/**
269	* Adds the passed features to the hover vector layer.
270	*
271	* @param {ol.layer.Layer} layer The layer. Currently unused in the method.
272	* @param {Array<ol.Feature>} features The features to hover by adding them
273	* to the source of the hover vector layer.
274	* @param {ol.Projection} projection The projection of the features.
275	*/
276	showHoverFeature: function(layer, features, projection) {
277	var me = this;	×
278	var mapComponent = me.getCmp();	×
279	var map = mapComponent.getMap();	×
280	var proj = me.getFeatureInfoEpsg();	×
281	var clickableProp = me.self.LAYER_CLICKABLE_PROPERTY_NAME;	×
282	var clickable = layer.get(clickableProp);	×
283
284	if (projection) {	×
285	proj = projection;	×
286	}
287	var source = me.getHoverVectorLayerSource();	×
288	Ext.each(features, function(feat) {	×
289	feat.isClickable = clickable;	×
290	var g = feat.getGeometry();	×
291	if (g) {	×
292	g.transform(proj, map.getView().getProjection());	×
293	}
294	if (!Ext.Array.contains(source.getFeatures(),	×
295	feat)) {
296	source.addFeature(feat);	×
297	}
298	});
299	}
300
301	});

terrestris / BasiGX / 4764756866

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous