fix Geometry cursor Not working properly

src/core/util/pick.js

@@ -0,0 +1,98 @@
+/**
+ *
+ * layer pick utils
+ * can use by PointLayer,LineStringLayer,PolygonLayer,VectorTileLayer,Geo3DTilesLayer,GLTFLayer etc
+ *
+ * @returns
+ */
+import Canvas from '../Canvas';
+
+export function isGLRenderLayer(layer) {
+    if (!layer) {
+        return false;
+    }
+    const renderer = layer.getRenderer && layer.getRenderer();
+    return !!(renderer && renderer.gl);
+}
+
+export function checkCanvasSize(targetCanvas, sourceCanvas) {
+    if (!targetCanvas || !sourceCanvas) {
+        return null;
+    }
+    const { width, height, style } = sourceCanvas;
+    if (targetCanvas.width !== width || targetCanvas.height !== height) {
+        targetCanvas.width = width;
+        targetCanvas.height = height;
+    }
+    if (targetCanvas.style.width !== style.width || targetCanvas.style.height !== style.height) {
+        targetCanvas.style.width = style.width;
+        targetCanvas.style.height = style.height;
+    }
+    return targetCanvas;
+}
+
+export function clearCanvas(canvas) {
+    if (!canvas) {
+        return null;
+    }
+    const ctx = Canvas.getCanvas2DContext(canvas);
+    Canvas.clearRect(ctx, 0, 0, canvas.width, canvas.height);
+    return ctx;
+}
+
+let tempCanvas;
+export function layerIsBlankInPoint(layer, containerPoint, tolerance = 1) {
+    if (!layer || !containerPoint) {
+        return true;
+    }
+    const renderer = layer.getRenderer && layer.getRenderer();
+    if (!renderer || !renderer.canvas) {
+        return true;
+    }
+    const map = layer.getMap();
+    if (!map) {
+        return true;
+    }
+    if (!tempCanvas) {
+        tempCanvas = Canvas.createCanvas(1, 1);
+        // document.body.appendChild(tempCanvas);
+    }
+    tempCanvas = checkCanvasSize(tempCanvas, renderer.canvas);
+    if (!tempCanvas) {
+        return true;
+    }
+    const ctx = clearCanvas(tempCanvas);
+    if (!ctx) {
+        return true;
+    }
+    tolerance = Math.max(layer.options.geometryEventTolerance || 1, tolerance);
+    tolerance = Math.abs(Math.round(tolerance));
+    tolerance = Math.max(1, tolerance);
+    const r = map.getDevicePixelRatio();
+    const { x, y } = containerPoint;
+    let left = x - tolerance, top = y - tolerance;
+    left = Math.round(left * r);
+    top = Math.round(top * r);
+    left = Math.max(0, left);
+    top = Math.max(0, top);
+    const size = tolerance * 2;
+    let imageData;
+    try {
+        ctx.drawImage(renderer.canvas, 0, 0);
+        imageData = ctx.getImageData(left, top, size, size);
+    } catch (error) {
+        console.warn('hit detect failed with tainted canvas, some geometries have external resources in another domain:\n', error);
+    }
+    if (!imageData) {
+        return false;
+    }
+    const data = imageData.data;
+    for (let i = 0, len = data.length; i < len; i += 4) {
+        const A = data[i + 3];
+        if (A > 0) {
+            return false;
+        }
+    }
+    return true;
+
+}

src/index.js

@@ -6,8 +6,10 @@ import * as Util from './core/util';
 import * as DomUtil from './core/util/dom';
 import * as StringUtil from './core/util/strings';
 import * as MapboxUtil from './core/mapbox';
+
 import * as MicroTask from './core/MicroTask';
 export { Util, DomUtil, StringUtil, MapboxUtil, MicroTask };
+
 export { default as LRUCache } from './core/util/LRUCache';
 export { default as Ajax } from './core/Ajax';
 export { default as Canvas } from './core/Canvas';

src/layer/OverlayLayer.js

@@ -56,26 +56,29 @@ class OverlayLayer extends Layer {
         }
     }
 
-    isGeometryListening(types) {
-        if (!this._geoList) {
-            return false;
-        }
-        if (!Array.isArray(types)) {
-            types = [types];
-        }
-        for (let i = 0, l = this._geoList.length; i < l; i++) {
-            const geometry = this._geoList[i];
-            if (!geometry) {
-                continue;
-            }
-            for (let j = 0; j < types.length; j++) {
-                if (geometry.listens(types[j])) {
-                    return true;
-                }
-            }
-        }
-        return false;
-    }
+    // isGeometryListening(types) {
+    //     if (!this._geoList) {
+    //         return false;
+    //     }
+    //     if (!Array.isArray(types)) {
+    //         types = [types];
+    //     }
+    //     for (let i = 0, l = this._geoList.length; i < l; i++) {
+    //         const geometry = this._geoList[i];
+    //         if (!geometry) {
+    //             continue;
+    //         }
+    //         if (geometry.options.cursor) {
+    //             return true;
+    //         }
+    //         for (let j = 0; j < types.length; j++) {
+    //             if (geometry.listens(types[j])) {
+    //                 return true;
+    //             }
+    //         }
+    //     }
+    //     return false;
+    // }
 
     /**
      * Get a geometry by its id
@@ -712,9 +715,16 @@ class OverlayLayer extends Layer {
         }
         const geos = this.getGeometries() || [];
         for (let i = 0, len = geos.length; i < len; i++) {
+            const geometry = geos[i];
+            if (!geometry) {
+                continue;
+            }
+            if (geometry.options.cursor) {
+                return true;
+            }
             for (let j = 0, len1 = eventTypes.length; j < len1; j++) {
                 const eventType = eventTypes[j];
-                const listens = geos[i].listens(eventType);
+                const listens = geometry.listens(eventType);
                 if (listens > 0) {
                     return true;
                 }

src/map/Map.Topo.js

@@ -1,5 +1,6 @@
 import { INTERNAL_LAYER_PREFIX } from '../core/Constants';
 import { isNil, isString, isArrayHasData, pushIn, isFunction } from '../core/util';
+import { isGLRenderLayer, layerIsBlankInPoint } from '../core/util/pick';
 import Coordinate from '../geo/Coordinate';
 import Point from '../geo/Point';
 import Map from './Map';
@@ -102,22 +103,29 @@ Map.include(/** @lends Map.prototype */ {
         const coordinate = this.containerPointToCoord(containerPoint);
         return this._identify(opts, callback, layer => {
             let result;
+            const containerPoint = opts.containerPoint;
             if (isMapGeometryEvent && !isNil(layer.options.geometryEventTolerance)) {
                 opts.tolerance = opts.tolerance || 0;
                 opts.tolerance += layer.options.geometryEventTolerance;
             }
-            if (layer.isGeometryListening && isMapGeometryEvent && opts.eventTypes.indexOf('mousemove') >= 0) {
-                if (!layer.isGeometryListening(opts.eventTypes)) {
+            //only gllayer,exclude canvas layer
+            const isGLLayer = isGLRenderLayer(layer);
+            const isBlank = isGLLayer && layerIsBlankInPoint(layer, containerPoint, opts.tolerance);
+            if (!isBlank && layer._hasGeoListeners && isMapGeometryEvent && opts.eventTypes.indexOf('mousemove') >= 0) {
+                if (!layer._hasGeoListeners(opts.eventTypes)) {
                     return [];
                 }
             }
-            if (layer.identifyAtPoint) {
+            if (isBlank) {
+                result = [];
+            } else if (layer.identifyAtPoint) {
                 result = layer.identifyAtPoint(containerPoint, opts);
             } else if (coordinate && layer.identify) {
                 result = layer.identify(coordinate, opts);
             } else {
                 result = [];
             }
+
             if (isMapGeometryEvent) {
                 if (isNil(tolerance)) {
                     delete opts.tolerance;

src/map/handler/Map.GeometryEvents.js

@@ -269,7 +269,7 @@ class MapGeometryEventsHandler extends Handler {
             }
             return false;
         });
-        map._setPriorityCursor(geometryCursorStyle);
+        // map._setPriorityCursor(geometryCursorStyle);
         if (!layers.length) {
             return;
         }

test/geometry/event/GeometryEventSpec.js

@@ -484,4 +484,27 @@ describe('Geometry.Events', function () {
             });
         }, 50);
     });
+
+    it('#2148 geometry cursor when listens is empty', function (done) {
+        var circle = new maptalks.Circle(map.getCenter(), 10, { cursor: 'zoom-in' });
+        circle.addTo(layer);
+        var domPosition = GET_PAGE_POSITION(container);
+        var point = map.coordinateToContainerPoint(center).add(domPosition);
+
+        happen.mousemove(eventContainer, {
+            'clientX': point.x,
+            'clientY': point.y
+        });
+        setTimeout(() => {
+            happen.mousemove(eventContainer, {
+                'clientX': point.x + 2,
+                'clientY': point.y + 2
+            });
+
+            setTimeout(() => {
+                expect(map._priorityCursor).to.be.eql('zoom-in');
+                done();
+            }, 100);
+        }, 16);
+    });
 });