geojs 1.9.3 → 1.10.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "geojs",
-  "version": "1.9.3",
+  "version": "1.10.1",
   "description": "JavaScript Geo Visualization and Analysis Library",
   "homepage": "https://github.com/OpenGeoscience/geojs",
   "license": "Apache-2.0",

package/src/action.js

@@ -16,11 +16,9 @@ var geo_action = {
   zoomrotate: 'geo_action_zoom_rotate',
   zoomselect: 'geo_action_zoomselect',
 
-  // annotation actions
-  annotation_line: 'geo_annotation_line',
-  annotation_polygon: 'geo_annotation_polygon',
-  annotation_rectangle: 'geo_annotation_rectangle',
-  annotation_edit_handle: 'geo_annotation_edit_handle'
+  // annotation actions -- some are also added by the registry
+  annotation_edit_handle: 'geo_annotation_edit_handle',
+  annotation_cursor: 'geo_annotation_cursor'
 };
 
 module.exports = geo_action;

package/src/annotation/annotation.js

@@ -15,7 +15,8 @@ var annotationState = {
   create: 'create',
   done: 'done',
   highlight: 'highlight',
-  edit: 'edit'
+  edit: 'edit',
+  cursor: 'cursor'
 };
 
 var annotationActionOwner = 'annotationAction';
@@ -151,6 +152,17 @@ var annotation = function (type, args) {
     return m_id;
   };
 
+  /**
+   * Assign a new id to this annotation.
+   *
+   * @returns {this}
+   */
+  this.newId = function () {
+    annotationId += 1;
+    m_id = annotationId;
+    return m_this;
+  };
+
   /**
    * Get or set the name of this annotation.
    *
@@ -300,6 +312,27 @@ var annotation = function (type, args) {
     return m_this;
   };
 
+  this._cursorHandleMousemove = function (evt) {
+    m_this.layer()._handleMouseMoveModifiers(evt);
+    const center = m_this._cursorCenter;
+    const delta = {
+      x: evt.mapgcs.x - center.x,
+      y: evt.mapgcs.y - center.y
+    };
+    if (delta.x || delta.y) {
+      const curPts = m_this._coordinates();
+      var pts = m_this._coordinatesMapFunc(curPts, function (elem) {
+        return {x: elem.x + delta.x, y: elem.y + delta.y};
+      });
+      m_this._coordinates(pts);
+      m_this._cursorCenter = evt.mapgcs;
+      m_this.modified();
+      m_this.draw();
+      return true;
+    }
+    return false;
+  };
+
   /**
    * Get or set the state of this annotation.
    *
@@ -320,6 +353,17 @@ var annotation = function (type, args) {
           annotation: m_this
         });
       }
+      if (m_this.layer()) {
+        m_this.layer().geoOff(geo_event.mousemove, m_this._cursorHandleMousemove);
+      }
+      switch (m_state) {
+        case annotationState.cursor:
+          m_this._cursorCenter = util.centerFromPerimeter(m_this._coordinates());
+          if (m_this.layer()) {
+            m_this.layer().geoOn(geo_event.mousemove, m_this._cursorHandleMousemove);
+          }
+          break;
+      }
     }
     return m_this;
   };
@@ -348,6 +392,18 @@ var annotation = function (type, args) {
           owner: annotationActionOwner,
           input: 'pan'
         }];
+      case annotationState.cursor:
+        return [{
+          action: geo_action.annotation_cursor,
+          name: 'annotation cursor',
+          owner: annotationActionOwner,
+          input: 'pan'
+        }, {
+          action: geo_action.annotation_cursor,
+          name: 'annotation cursor',
+          owner: annotationActionOwner,
+          input: 'left'
+        }];
       default:
         return [];
     }
@@ -471,7 +527,7 @@ var annotation = function (type, args) {
       /* For style objects, re-extend them without recursion.  This allows
        * setting colors without an opacity field, for instance. */
       ['style', 'createStyle', 'editStyle', 'editHandleStyle', 'labelStyle',
-        'highlightStyle'
+        'highlightStyle', 'cursorStyle'
       ].forEach(function (key) {
         if (arg1[key] !== undefined) {
           $.extend(m_options[key], arg1[key]);
@@ -520,8 +576,8 @@ var annotation = function (type, args) {
    *    current style with the values in the specified object.
    * @param {*} [arg2] If `arg1` is a string, the new value for that style.
    * @param {string} [styleType='style'] The name of the style type, such as
-   *    `createStyle`, `editStyle`, `editHandleStyle`, `labelStyle`, or
-   *    `highlightStyle`.
+   *    `createStyle`, `editStyle`, `editHandleStyle`, `labelStyle`,
+   *    `highlightStyle`, or `cursorStyle`.
    * @returns {object|this} Either the entire style object, the value of a
    *    specific style, or the current class instance.
    */
@@ -570,12 +626,18 @@ var annotation = function (type, args) {
    * @instance
    */
   /**
-   * Calls {@link geo.annotation#style} with `styleType='highlightHandleStyle'`.
-   * @function highlightHandleStyle
+   * Calls {@link geo.annotation#style} with `styleType='highlightStyle'`.
+   * @function highlightStyle
    * @memberof geo.annotation
    * @instance
    */
-  ['createStyle', 'editStyle', 'editHandleStyle', 'labelStyle', 'highlightStyle'
+  /**
+   * Calls {@link geo.annotation#style} with `styleType='cursorStyle'`.
+   * @function cursorStyle
+   * @memberof geo.annotation
+   * @instance
+   */
+  ['createStyle', 'editStyle', 'editHandleStyle', 'labelStyle', 'highlightStyle', 'cursorStyle'
   ].forEach(function (styleType) {
     m_this[styleType] = function (arg1, arg2) {
       return m_this.style(arg1, arg2, styleType);
@@ -600,6 +662,10 @@ var annotation = function (type, args) {
       return $.extend({}, m_options.style, m_options.editStyle,
                       m_options[state + 'Style']);
     }
+    if (state === annotationState.cursor) {
+      return $.extend({}, m_options.style, m_options.editStyle,
+                      m_options.createStyle, m_options[state + 'Style']);
+    }
     return m_options[state + 'Style'] || m_options.style || {};
   };
 

package/src/annotation/polygonAnnotation.js

@@ -3,6 +3,7 @@ const inherit = require('../inherit');
 const registerAnnotation = require('../registry').registerAnnotation;
 const lineFeature = require('../lineFeature');
 const polygonFeature = require('../polygonFeature');
+const util = require('../util');
 
 const annotation = require('./annotation').annotation;
 const annotationState = require('./annotation').state;
@@ -61,6 +62,9 @@ var polygonAnnotation = function (args) {
         }
         return m_this.options('vertices')[i];
       }
+    },
+    cursorStyle: {
+      position: util.identityFunction
     }
   }, args);
   args.vertices = args.vertices || args.coordinates || [];
@@ -332,6 +336,13 @@ polygonAnnotation.defaults = $.extend({}, annotation.defaults, {
     stroke: false,
     strokeColor: {r: 0, g: 0, b: 1}
   },
+  cursorStyle: {
+    closed: true,
+    fillColor: {r: 0.3, g: 0.3, b: 0.3},
+    fillOpacity: 0.25,
+    stroke: true,
+    strokeColor: {r: 0, g: 0, b: 1}
+  },
   allowBooleanOperations: true
 });
 

package/src/annotationLayer.js

@@ -184,6 +184,15 @@ var annotationLayer = function (arg) {
             }
           }
           break;
+        case m_this.modes.cursor:
+          m_this.currentAnnotation._cursorHandleMousemove(evt.mouse);
+          update = m_this.currentAnnotation.processAction(evt);
+          m_this.geoTrigger(geo_event.annotation.cursor_action, {
+            annotation: m_this.currentAnnotation,
+            operation: m_this.currentBooleanOperation(),
+            evt: evt
+          });
+          break;
         default:
           update = m_this.currentAnnotation.processAction(evt);
           break;
@@ -261,7 +270,7 @@ var annotationLayer = function (arg) {
    * @param {geo.event} evt The mouse move or click event.
    */
   this._handleMouseMoveModifiers = function (evt) {
-    if (m_this.mode() !== m_this.modes.edit && m_this.currentAnnotation.options('allowBooleanOperations') && m_this.currentAnnotation._coordinates().length < 2) {
+    if (m_this.mode() !== m_this.modes.edit && m_this.currentAnnotation.options('allowBooleanOperations') && (m_this.currentAnnotation._coordinates().length < 2 || m_this.mode() === m_this.modes.cursor)) {
       if (evt.modifiers) {
         const mod = (evt.modifiers.shift ? 's' : '') + (evt.modifiers.ctrl ? 'c' : '') + (evt.modifiers.meta || evt.modifiers.alt ? 'a' : '');
         if (m_this._currentBooleanClass === m_this._booleanClasses[mod]) {
@@ -392,6 +401,13 @@ var annotationLayer = function (arg) {
       update = m_this.currentAnnotation.mouseClick(evt);
       m_this._updateFromEvent(update);
       retrigger = !m_this.mode();
+      if (m_this.mode() === m_this.modes.cursor) {
+        m_this.geoTrigger(geo_event.annotation.cursor_click, {
+          annotation: m_this.currentAnnotation,
+          operation: m_this.currentBooleanOperation(),
+          evt: evt
+        });
+      }
     } else if (!m_this.mode() && !m_this.currentAnnotation && m_this.options('clickToEdit')) {
       var highlighted = m_this.annotations().filter(function (ann) {
         return ann.state() === geo_annotation.state.highlight;
@@ -481,6 +497,9 @@ var annotationLayer = function (arg) {
   this.addAnnotation = function (annotation, gcs, update) {
     var pos = $.inArray(annotation, m_annotations);
     if (pos < 0) {
+      while (m_this.annotationById(annotation.id())) {
+        annotation.newId();
+      }
       m_this.geoTrigger(geo_event.annotation.add_before, {
         annotation: annotation
       });
@@ -588,7 +607,8 @@ var annotationLayer = function (arg) {
 
   /* A list of special modes */
   this.modes = {
-    edit: 'edit'
+    edit: 'edit',
+    cursor: 'cursor'
   };
 
   /* Keys are short-hand for preferred event modifiers.  Values are classes to
@@ -605,11 +625,13 @@ var annotationLayer = function (arg) {
    *
    * @param {string|null} [arg] `undefined` to get the current mode, `null` to
    *    stop creating/editing, `this.modes.edit` (`'edit'`) plus an annotation
-   *    to switch to edit mode, or the name of the type of annotation to
-   *    create.  Available annotations can listed via
+   *    to switch to edit mode, `this.modes.cursor` plus an annotation to
+   *    switch to using the annotation as a cursor, or the name of the type of
+   *    annotation to create.  Available annotations can listed via
    *    {@link geo.listAnnotations}.
-   * @param {geo.annotation} [editAnnotation] If `arg === this.modes.edit`,
-   *    this is the annotation that should be edited.
+   * @param {geo.annotation} [editAnnotation] If `arg === this.modes.edit` or
+   *    `arg === this.modes.cursor`, this is the annotation that should be
+   *    edited or used.
    * @param {object} [options] Additional options to pass when creating an
    *    annotation.
    * @returns {string|null|this} The current mode or the layer.
@@ -619,11 +641,14 @@ var annotationLayer = function (arg) {
     if (arg === undefined) {
       return m_mode;
     }
-    if (arg !== m_mode || (arg === m_this.modes.edit && editAnnotation !== m_this.editAnnotation) || (arg !== m_this.modes.edit && arg && !m_this.currentAnnotation)) {
+    if (arg !== m_mode ||
+        ((arg === m_this.modes.edit || arg === m_this.modes.cursor) && editAnnotation !== m_this.editAnnotation) ||
+        (arg !== m_this.modes.edit && arg !== m_this.modes.cursor && arg && !m_this.currentAnnotation)
+    ) {
       var createAnnotation, actions,
           mapNode = m_this.map().node(), oldMode = m_mode;
       m_mode = arg;
-      mapNode.toggleClass('annotation-input', !!(m_mode && m_mode !== m_this.modes.edit));
+      mapNode.toggleClass('annotation-input', !!(m_mode && m_mode !== m_this.modes.edit && m_mode !== m_this.modes.cursor));
       if (!m_mode || m_mode === m_this.modes.edit) {
         Object.values(m_this._booleanClasses).forEach((c) => mapNode.toggleClass(c, false));
         m_this._currentBooleanClass = undefined;
@@ -646,6 +671,12 @@ var annotationLayer = function (arg) {
             m_this.modified();
             m_this.draw();
             break;
+          case geo_annotation.state.cursor:
+            m_this.currentAnnotation.state(geo_annotation.state.done);
+            m_this.modified();
+            m_this.draw();
+            m_this.map().node().toggleClass('annotation-cursor', false);
+            break;
         }
         m_this.currentAnnotation = null;
       }
@@ -653,6 +684,12 @@ var annotationLayer = function (arg) {
         m_this.currentAnnotation = editAnnotation;
         m_this.currentAnnotation.state(geo_annotation.state.edit);
         m_this.modified();
+      } else if (m_mode === m_this.modes.cursor) {
+        m_this.currentAnnotation = editAnnotation;
+        m_this.currentAnnotation.state(geo_annotation.state.cursor);
+        m_this.modified();
+        m_this.map().node().toggleClass('annotation-cursor', true);
+        actions = m_this.currentAnnotation.actions(geo_annotation.state.cursor);
       } else if (registry.registries.annotations[m_mode]) {
         createAnnotation = registry.registries.annotations[m_mode].func;
       }
@@ -666,13 +703,15 @@ var annotationLayer = function (arg) {
         m_this.currentAnnotation = createAnnotation(options);
         m_this.addAnnotation(m_this.currentAnnotation, null);
         actions = m_this.currentAnnotation.actions(geo_annotation.state.create);
+      }
+      if (actions) {
         $.each(actions, function (idx, action) {
           m_this.map().interactor().addAction(action);
         });
       }
       m_this.geoTrigger(geo_event.annotation.mode, {
         mode: m_mode, oldMode: oldMode});
-      if (oldMode === m_this.modes.edit) {
+      if (oldMode === m_this.modes.edit || oldMode === m_this.modes.cursor) {
         m_this.modified();
       }
     }
@@ -1258,11 +1297,15 @@ var annotationLayer = function (arg) {
   this.toPolygonList = function (opts) {
     const poly = [];
     opts = opts || {};
-    opts.annotationIndices = [];
+    const indices = [];
+    if (!opts.annotationIndices) {
+      opts.annotationIndices = {};
+    }
+    opts.annotationIndices[m_this.id()] = indices;
     m_annotations.forEach((annotation, idx) => {
       if (annotation.toPolygonList) {
         annotation.toPolygonList(opts).forEach((p) => poly.push(p));
-        opts.annotationIndices.push(idx);
+        indices.push(idx);
       }
     });
     return poly;
@@ -1285,14 +1328,15 @@ var annotationLayer = function (arg) {
     const keepIds = {};
     const reusedIds = {};
     let correspond, exact, annot;
-    if (opts.annotationIndices && opts.correspond && opts.correspond.poly1 && opts.annotationIndices.length === opts.correspond.poly1.length) {
+    const indices = (opts.annotationIndices || {})[m_this.id()];
+    if (indices && opts.correspond && opts.correspond.poly1 && indices.length === opts.correspond.poly1.length) {
       correspond = opts.correspond.poly1;
       exact = opts.correspond.exact1;
       annot = m_this.annotations();
     }
-    if (keep !== 'all' && keep !== 'none') {
+    if (keep !== 'all' && keep !== 'none' && annot) {
       annot.forEach((oldAnnot, idx) => {
-        if (opts.annotationIndices.indexOf(idx) < 0) {
+        if (indices.indexOf(idx) < 0) {
           keepIds[oldAnnot.id()] = true;
         }
       });
@@ -1306,7 +1350,7 @@ var annotationLayer = function (arg) {
       if (correspond) {
         for (let i = 0; i < correspond.length; i += 1) {
           if (correspond[i] && correspond[i].indexOf(idx) >= 0) {
-            const orig = annot[opts.annotationIndices[i]];
+            const orig = annot[indices[i]];
             if (keep !== 'all' && keep !== 'none' && exact && exact[i] && exact[i].indexOf(idx) >= 0) {
               keepIds[orig.id()] = true;
               return;
@@ -1343,7 +1387,7 @@ var annotationLayer = function (arg) {
     }
     // add new annotations
     polyAnnot.forEach((p) => {
-      m_this.addAnnotation(registry.createAnnotation('polygon', p), m_this.gcs(), false);
+      m_this.addAnnotation(registry.createAnnotation('polygon', p), m_this.map().gcs(), false);
       update = true;
     });
     if (update) {

package/src/event.js

@@ -706,4 +706,32 @@ geo_event.annotation.mode = 'geo_annotation_mode';
  */
 geo_event.annotation.boolean = 'geo_annotation_boolean';
 
+/**
+ * Triggered when an annotation is in cursor mode and the mouse is clicked.
+ *
+ * @event geo.event.annotation.cursor_click
+ * @type {geo.event.base}
+ * @property {geo.annotation} annotation The annotation that is being operated
+ *      on.
+ * @property {string} operation The operation being performed.
+ * @property {boolean} [cancel] If the handle sets this to false, don't apply
+ *      the operation to the annotation layer.
+ * @property {object} event The triggering event.
+ */
+geo_event.annotation.cursor_click = 'geo_annotation_cursor_click';
+
+/**
+ * Triggered when an annotation is in cursor mode and an action occurs.
+ *
+ * @event geo.event.annotation.cursor_action
+ * @type {geo.event.base}
+ * @property {geo.annotation} annotation The annotation that is being operated
+ *      on.
+ * @property {string} operation The operation being performed.
+ * @property {boolean} [cancel] If the handle sets this to false, don't apply
+ *      the operation to the annotation layer.
+ * @property {object} event The triggering event.
+ */
+geo_event.annotation.cursor_action = 'geo_annotation_cursor_action';
+
 module.exports = geo_event;

package/src/main.styl

@@ -58,6 +58,17 @@
     &.annotation-xor
       cursor embedurl("./css/cursor-crosshair-xor.svg") 12 12,crosshair
 
+  &.annotation-cursor
+    cursor crosshair
+    &.annotation-intersect
+      cursor embedurl("./css/cursor-crosshair-intersect.svg") 12 12,crosshair
+    &.annotation-difference
+      cursor embedurl("./css/cursor-crosshair-difference.svg") 12 12,crosshair
+    &.annotation-union
+      cursor embedurl("./css/cursor-crosshair-union.svg") 12 12,crosshair
+    &.annotation-xor
+      cursor embedurl("./css/cursor-crosshair-xor.svg") 12 12,crosshair
+
   &.highlight-focus
     &:after
       content ""

package/src/map.js

@@ -407,18 +407,22 @@ var map = function (arg) {
    *    center.
    * @param {boolean} [ignoreDiscreteZoom] If `true`, ignore the discreteZoom
    *    option when determining the new view.
+   * @param {boolean} [ignoreClampBounds] If `true`, ignore the clampBounds
+   *    option when determining the new view.
    * @returns {number|this}
    * @fires geo.event.zoom
    * @fires geo.event.pan
    */
-  this.zoom = function (val, origin, ignoreDiscreteZoom) {
+  this.zoom = function (val, origin, ignoreDiscreteZoom, ignoreClampBounds) {
     if (val === undefined) {
       return m_zoom;
     }
     var evt, bounds;
     /* If we are zooming around a point, ignore the clamp bounds */
     var aroundPoint = (origin && (origin.mapgcs || origin.geo) && origin.map);
-    var ignoreClampBounds = aroundPoint;
+    if (aroundPoint) {
+      ignoreClampBounds = true;
+    }
 
     /* The ignoreDiscreteZoom flag is intended to allow non-integer zoom values
      * during animation. */
@@ -446,7 +450,7 @@ var map = function (arg) {
       m_this.pan({x: origin.map.x - shifted.x, y: origin.map.y - shifted.y},
                  ignoreDiscreteZoom, true);
     } else {
-      m_this.pan({x: 0, y: 0}, ignoreDiscreteZoom);
+      m_this.pan({x: 0, y: 0}, ignoreDiscreteZoom, ignoreClampBounds);
     }
     return m_this;
   };
@@ -1101,6 +1105,8 @@ var map = function (arg) {
    *    a value based on what canceled a transition, `transition`: the current
    *    transition that just completed, `next`: a boolean if another transition
    *    follows immediately.
+   * @param {boolean} [opts.endClamp=true] If `false`, the last center change
+   *    will not clamp to the bounds and zoom values.
    * @param {string|geo.transform|null} [gcs] Input gcs.  `undefined` to use
    *    the interface gcs, `null` to use the map gcs, or any other transform.
    *    Applies only to `opts.center` and to converting zoom values to height,
@@ -1205,7 +1211,8 @@ var map = function (arg) {
       zCoord: opts.zCoord,
       done: opts.done,
       duration: opts.duration,
-      zoomOrigin: opts.zoomOrigin
+      zoomOrigin: opts.zoomOrigin,
+      endClamp: opts.endClamp
     };
 
     m_transition.interp = opts.interp([
@@ -1260,9 +1267,10 @@ var map = function (arg) {
         if (!next) {
           if (m_transition.end.center) {
             var needZoom = m_zoom !== m_this._fix_zoom(m_transition.end.zoom);
-            m_this.center(m_transition.end.center, null, needZoom, needZoom);
+            var noEndClamp = needZoom || opts.endClamp === false;
+            m_this.center(m_transition.end.center, null, noEndClamp, noEndClamp);
           }
-          m_this.zoom(m_transition.end.zoom, m_transition.zoomOrigin);
+          m_this.zoom(m_transition.end.zoom, m_transition.zoomOrigin, opts.endClamp === false, opts.endClamp === false);
           m_this.rotation(fix_rotation(m_transition.end.rotation));
         }
 
@@ -1297,7 +1305,7 @@ var map = function (arg) {
         }, null, true, true);
       } else {
         m_center = m_this.gcsToWorld({x: p[0], y: p[1]}, null);
-        m_this.zoom(p[2], m_transition.zoomOrigin, true);
+        m_this.zoom(p[2], m_transition.zoomOrigin, true, true);
       }
       m_this.rotation(p[3], undefined, true);
 

package/src/mapInteractor.js

@@ -25,8 +25,8 @@ var Mousetrap = require('mousetrap');
  *      event must occur within this time in milliseconds of the mouse down
  *      event for it to be considered a click.
  * @property {boolean|number} [click.cancelOnMove=true] If true, don't generate
- *      click events if the mouse moved at all.  If a positive number, the distance
- *      at which to cancel click events when the mouse moves.
+ *      click events if the mouse moved at all.  If a positive number, the
+ *      distance at which to cancel click events when the mouse moves.
  * @property {object} [keyboard] An object describing which keyboard events are
  *      handled.
  * @property {object} [keyboard.actions] An object with different actions that
@@ -39,6 +39,9 @@ var Mousetrap = require('mousetrap');
  *      an object with keys of the meta keys that are required to be down or
  *      up for that scale action to trigger.  If the value of the meta key is
  *      truthy, it must be down.  If `false`, it must be up.
+ * @property {string[]} [keyboard.metakeyMouseEvents] A list of meta keys
+ * *    that, when typed singly, trigger a repeat of the last mousemove or
+ *      actionmove event so that listeners can  update metakey information.
  * @property {boolean} [keyboard.focusHighlight=true] If truthy, when the map
  *      gains focus, a highlight style is shown around it.  This gives an
  *      indicator that keyboard events will affect the map, but may not be
@@ -131,6 +134,7 @@ var mapInteractor = function (args) {
       m_boundKeys,
       m_touchHandler,
       m_state,
+      m_nextStateId = 0,
       m_queue,
       $node,
       m_selectionLayer = null,
@@ -294,6 +298,10 @@ var mapInteractor = function (args) {
           1: {shift: true, ctrl: true},
           2: {shift: true, ctrl: false}
         },
+        /* This is a list of meta keys that when typed singly trigger a repeat
+         * of the last mousemove or actionmove event so that listeners can
+         * update metakey information. */
+        metakeyMouseEvents: ['shift', 'ctrl', 'shift+ctrl', 'shift+alt', 'shift+meta'],
         /* if focusHighlight is truthy, then a class is added to the map such
          * that when the map gets focus, it is indicated inside the border of
          * the map -- browsers usually show focus on the outside, which isn't
@@ -648,6 +656,35 @@ var mapInteractor = function (args) {
     }
   };
 
+  /**
+   * Repeat a mousemove or actionmove event with new metakey information.
+   *
+   * @param {event} [evt] A Mousetrap event with the key change.
+   * @fires geo.event.mousemove
+   * @fires geo.event.actionmove
+   */
+  this._repeatMouseMoveEvent = function (evt) {
+    if (!m_mouse || !m_mouse.modifiers) {
+      return;
+    }
+    const old = {
+      alt: m_mouse.modifiers.alt,
+      ctrl: m_mouse.modifiers.ctrl,
+      meta: m_mouse.modifiers.meta,
+      shift: m_mouse.modifiers.shift
+    };
+    m_this._getMouseModifiers(evt);
+    if (m_mouse.modifiers.alt === old.alt && m_mouse.modifiers.ctrl === old.ctrl && m_mouse.modifiers.meta === old.meta && m_mouse.modifiers.shift === old.shift) {
+      return;
+    }
+    if (m_state.boundDocumentHandlers) {
+      m_this.map().geoTrigger(geo_event.actionmove, {
+        state: m_this.state(), mouse: m_this.mouse(), event: evt});
+    } else {
+      m_this.map().geoTrigger(geo_event.mousemove, m_this.mouse());
+    }
+  };
+
   /**
    * Retrigger a mouse movement with the current mouse state.
    * @fires geo.event.mousemove
@@ -711,6 +748,13 @@ var mapInteractor = function (args) {
           bound = bound.concat(m_options.keyboard.actions[keyAction]);
         }
       }
+      if (m_options.keyboard.metakeyMouseEvents) {
+        m_options.keyboard.metakeyMouseEvents.forEach((meta) => {
+          m_keyHandler.bind(meta, m_this._repeatMouseMoveEvent, 'keydown');
+          m_keyHandler.bind(meta, m_this._repeatMouseMoveEvent, 'keyup');
+          bound.push(meta);
+        });
+      }
       m_boundKeys = bound;
     }
     $node.toggleClass(
@@ -1074,6 +1118,7 @@ var mapInteractor = function (args) {
       };
 
       // store the state object
+      m_nextStateId += 1;
       m_state = {
         action: action,
         actionRecord: actionRecord,
@@ -1081,6 +1126,7 @@ var mapInteractor = function (args) {
         initialZoom: map.zoom(),
         initialRotation: map.rotation(),
         initialEventRotation: evt.rotation,
+        stateId: m_nextStateId,
         delta: {x: 0, y: 0}
       };
 
@@ -2095,7 +2141,7 @@ var mapInteractor = function (args) {
         preventDefault: function () {},
         simulated: true
       };
-      m_keyHandler.trigger(keys);
+      m_keyHandler.trigger(keys, options.event);
       return;
     }
 

package/src/registry.js

@@ -1,4 +1,6 @@
 var $ = require('jquery');
+var geo_action = require('./action');
+
 var widgets = {
   dom: {}
 };
@@ -398,6 +400,7 @@ util.registerAnnotation = function (name, func, features) {
     console.warn('The ' + name + ' annotation is already registered');
   }
   annotations[name] = {func: func, features: features || {}};
+  geo_action['annotation_' + name] = 'geo_annotation_' + name;
   return old;
 };
 

package/src/util/polyops.js

@@ -327,16 +327,19 @@ function generateCorrespondence(poly1, poly2, newpoly, results) {
     results[ekey] = Array(poly.length);
     poly.forEach((p, idx) => {
       const found = {};
+      let missed = 0;
       p.forEach((h) => h.forEach((pt) => {
         const key = '_' + pt[0] + '_' + pt[1];
         if (pts[key]) {
           pts[key].forEach((val) => {
             found[val] = (found[val] || 0) + 1;
           });
+        } else {
+          missed += 1;
         }
       }));
       Object.keys(found).forEach((nidx) => {
-        if (found[nidx] === counts[+nidx]) {
+        if (found[nidx] === counts[+nidx] && !missed && p.length === newpoly[+nidx].length) {
           if (!results[ekey][idx]) {
             results[ekey][idx] = [];
           }