geokernel-electron 1.1.37 → 1.1.38

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "geokernel-electron",
-  "version": "1.1.37",
+  "version": "1.1.38",
   "description": "Electron bindings for the GeoKernel GIS SDK.",
   "main": "src/index.js",
   "type": "commonjs",

package/src/native-signatures.js

@@ -294,6 +294,8 @@ const SIGNATURES = Object.freeze({
   "GeoKernelWindow_GetSelectedLayerIndex": ["int", ["void_p"]],
   "GeoKernelWindow_IsVisible": ["bool", ["void_p"]],
   "GeoKernelWindow_SetCentralViewer": ["void_p", ["void_p"]],
+  "GeoKernelWindow_SetCentralTextPanel": ["bool", ["void_p", "wchar_p"]],
+  "GeoKernelWindow_SetCentralText": ["bool", ["void_p", "wchar_p"]],
   "GeoKernelWindow_SetControlValue": ["bool", ["void_p", "int", "double", "wchar_p"]],
   "GeoKernelWindow_SetLegendItemsJson": ["bool", ["void_p", "wchar_p"]],
   "GeoKernelWindow_SetLegendTitle": ["bool", ["void_p", "wchar_p"]],

package/src/types.js

@@ -56,6 +56,14 @@ const ShapeType = Object.freeze({
   MULTI_POINT_Z: 18,
 });
 
+const AttributeType = Object.freeze({
+  STRING: 0,
+  INTEGER: 1,
+  DOUBLE: 2,
+  BOOLEAN: 3,
+  DATE_TIME: 4,
+});
+
 const SpatialIndexType = Object.freeze({
   LINEAR: 0,
   RTREE: 1,
@@ -135,6 +143,7 @@ function routeSummary(value) {
 }
 
 module.exports = {
+  AttributeType,
   ClassificationMethod,
   ColorRampMode,
   MeasureMode,

package/src/viewer.js

@@ -246,6 +246,22 @@ class ViewerWindow {
     this.library.function("GeoKernelWindow_SetStatusText")(this.windowHandle, text ?? "");
   }
 
+  setCentralTextPanel(text = "") {
+    const ok = this.library.function("GeoKernelWindow_SetCentralTextPanel")(
+      this.windowHandle,
+      text,
+    );
+    if (!ok) throw new Error("GeoKernelWindow_SetCentralTextPanel failed.");
+  }
+
+  setCentralText(text) {
+    const ok = this.library.function("GeoKernelWindow_SetCentralText")(
+      this.windowHandle,
+      text,
+    );
+    if (!ok) throw new Error("GeoKernelWindow_SetCentralText failed.");
+  }
+
   addLogPanel(title = "Event log") {
     const ok = this.library.function("GeoKernelWindow_AddLogPanel")(this.windowHandle, title);
     if (!ok) throw new Error("GeoKernelWindow_AddLogPanel failed.");
@@ -400,16 +416,128 @@ class ViewerWindow {
   commitEditLayer(index) { return this._call("GeoKernelViewer_CommitEditLayer", Number(index)); }
   rollbackEditLayer(index) { return this._call("GeoKernelViewer_RollbackEditLayer", Number(index)); }
   isLayerEditing(index) { return this._call("GeoKernelViewer_IsLayerEditing", Number(index)); }
+  canEditLayer(index) { return this._call("GeoKernelViewer_CanEditLayer", Number(index)); }
   setActiveEditLayerIndex(index) { return this._call("GeoKernelViewer_SetActiveEditLayerIndex", Number(index)); }
-  addPointToEditLayer(index, x, y) { return this._call("GeoKernelViewer_AddPointToEditLayer", Number(index), Number(x), Number(y)); }
-  addPolylineToEditLayer(index, points) {
+  addLayerAttributeDefinition(index, name, type, length = 0, decimalCount = 0) {
+    return this._call(
+      "GeoKernelViewer_AddLayerAttributeDefinition",
+      Number(index),
+      name,
+      Number(type),
+      Number(length),
+      Number(decimalCount),
+    );
+  }
+  addPointToEditLayer(index, x, y, attributes) {
+    if (attributes === undefined) {
+      return this._call("GeoKernelViewer_AddPointToEditLayer", Number(index), Number(x), Number(y));
+    }
+    return this._call(
+      "GeoKernelViewer_AddPointToEditLayerWithAttributes",
+      Number(index),
+      Number(x),
+      Number(y),
+      jsonText(attributes),
+    );
+  }
+  addPolylineToEditLayer(index, points, attributes) {
     const xy = xyArray(points);
+    if (attributes !== undefined) {
+      return this._call(
+        "GeoKernelViewer_AddPolylineToEditLayerWithAttributes",
+        Number(index),
+        xy,
+        xy.length / 2,
+        jsonText(attributes),
+      );
+    }
     return this._call("GeoKernelViewer_AddPolylineToEditLayer", Number(index), xy, xy.length / 2);
   }
-  addPolygonToEditLayer(index, points) {
+  addPolygonToEditLayer(index, points, attributes) {
     const xy = xyArray(points);
+    if (attributes !== undefined) {
+      return this._call(
+        "GeoKernelViewer_AddPolygonToEditLayerWithAttributes",
+        Number(index),
+        xy,
+        xy.length / 2,
+        jsonText(attributes),
+      );
+    }
     return this._call("GeoKernelViewer_AddPolygonToEditLayer", Number(index), xy, xy.length / 2);
   }
+  deleteShapeFromEditLayer(index, shapeId) {
+    return this._call("GeoKernelViewer_DeleteShapeFromEditLayer", Number(index), Number(shapeId));
+  }
+  deleteSelectedFeaturesFromEditLayer() {
+    return this._call("GeoKernelViewer_DeleteSelectedFeaturesFromEditLayer");
+  }
+  canMoveSelectedFeatures() {
+    return this._call("GeoKernelViewer_CanMoveSelectedFeatures");
+  }
+  canEditSelectedFeatures() {
+    return this._call("GeoKernelViewer_CanEditSelectedFeatures");
+  }
+  canEditSelectedVertices() {
+    return this._call("GeoKernelViewer_CanEditSelectedVertices");
+  }
+  deleteSelectedVertexFromEditLayer() {
+    return this._call("GeoKernelViewer_DeleteSelectedVertexFromEditLayer");
+  }
+  insertSelectedFeatureVertexInEditLayer(partIndex, insertIndex, worldX, worldY) {
+    return this._call(
+      "GeoKernelViewer_InsertSelectedFeatureVertexInEditLayer",
+      Number(partIndex),
+      Number(insertIndex),
+      Number(worldX),
+      Number(worldY),
+    );
+  }
+  deleteSelectedFeatureVertexInEditLayer(partIndex, vertexIndex) {
+    return this._call(
+      "GeoKernelViewer_DeleteSelectedFeatureVertexInEditLayer",
+      Number(partIndex),
+      Number(vertexIndex),
+    );
+  }
+  canUndoEditLayer(index) {
+    return this._call("GeoKernelViewer_CanUndoEditLayer", Number(index));
+  }
+  canRedoEditLayer(index) {
+    return this._call("GeoKernelViewer_CanRedoEditLayer", Number(index));
+  }
+  undoEditLayer(index) {
+    return this._call("GeoKernelViewer_UndoEditLayer", Number(index));
+  }
+  redoEditLayer(index) {
+    return this._call("GeoKernelViewer_RedoEditLayer", Number(index));
+  }
+  setShapeAttributesInEditLayer(index, shapeId, attributes) {
+    return this._call(
+      "GeoKernelViewer_SetShapeAttributesInEditLayerJson",
+      Number(index),
+      Number(shapeId),
+      jsonText(attributes),
+    );
+  }
+  editSnappingEnabled() {
+    return this._call("GeoKernelViewer_GetEditSnappingEnabled");
+  }
+  setEditSnappingEnabled(enabled) {
+    this._call("GeoKernelViewer_SetEditSnappingEnabled", Boolean(enabled));
+  }
+  editSnappingTolerancePixels() {
+    return this._call("GeoKernelViewer_GetEditSnappingTolerancePixels");
+  }
+  setEditSnappingTolerancePixels(tolerance) {
+    this._call("GeoKernelViewer_SetEditSnappingTolerancePixels", Number(tolerance));
+  }
+  isLayerDirty(index) {
+    return this._call("GeoKernelViewer_IsLayerDirty", Number(index));
+  }
+  moveSelectedFeaturesInEditLayer(deltaX, deltaY) {
+    return this._call("GeoKernelViewer_MoveSelectedFeaturesInEditLayer", Number(deltaX), Number(deltaY));
+  }
 
   addPointLayer(name, points, style) {
     const xy = xyArray(points);
@@ -623,6 +751,49 @@ class ViewerWindow {
     this._call("GeoKernelViewer_SetViewExtent", extentObject(value));
   }
 
+  setCoordinateSystemPreset(preset) {
+    return this._call("GeoKernelViewer_SetCoordinateSystemPreset", String(preset));
+  }
+
+  setLayerCoordinateSystemPreset(index, preset) {
+    return this._call(
+      "GeoKernelViewer_SetLayerCoordinateSystemPreset",
+      Number(index),
+      String(preset),
+    );
+  }
+
+  transformPoint(sourceEpsg, targetEpsg, x, y) {
+    const transformedX = [0];
+    const transformedY = [0];
+    const ok = this.library.function("GeoKernelViewer_TransformPoint")(
+      Number(sourceEpsg),
+      Number(targetEpsg),
+      Number(x),
+      Number(y),
+      transformedX,
+      transformedY,
+    );
+    return ok ? point(transformedX[0], transformedY[0]) : null;
+  }
+
+  coordinateSystemFromAuthority(authority, code) {
+    return this._readStaticJson(
+      "GeoKernelViewer_CoordinateSystemFromAuthorityJson",
+      {},
+      String(authority),
+      Number(code),
+    );
+  }
+
+  coordinateSystemFromEpsg(code) {
+    return this._readStaticJson(
+      "GeoKernelViewer_CoordinateSystemFromEpsgJson",
+      {},
+      Number(code),
+    );
+  }
+
   worldToScreen(x, y) {
     const screenX = [0];
     const screenY = [0];
@@ -697,6 +868,68 @@ class ViewerWindow {
     return this._readJson("GeoKernelViewer_GetLayerFeatureAttributesJson", {}, Number(index), Number(rowIndex));
   }
 
+  hitTestTopFeatureAt(screenX, screenY, pixelTolerance = 8) {
+    return this._readJson(
+      "GeoKernelViewer_HitTestTopFeatureAtJson",
+      null,
+      Number(screenX),
+      Number(screenY),
+      Number(pixelTolerance),
+    );
+  }
+
+  hitTestFeaturesAt(screenX, screenY, pixelTolerance = 8) {
+    return this._readJson(
+      "GeoKernelViewer_HitTestFeaturesAtJson",
+      [],
+      Number(screenX),
+      Number(screenY),
+      Number(pixelTolerance),
+    );
+  }
+
+  hitTestFeatures(worldX, worldY, worldTolerance) {
+    return this._readJson(
+      "GeoKernelViewer_HitTestFeaturesJson",
+      [],
+      Number(worldX),
+      Number(worldY),
+      Number(worldTolerance),
+    );
+  }
+
+  hitTestFeaturesInScreenRect(left, top, right, bottom) {
+    return this._readJson(
+      "GeoKernelViewer_HitTestFeaturesInScreenRectJson",
+      [],
+      Number(left),
+      Number(top),
+      Number(right),
+      Number(bottom),
+    );
+  }
+
+  selectFeaturesInScreenRect(left, top, right, bottom, selectionMode = 0) {
+    const x = Math.min(Number(left), Number(right));
+    const y = Math.min(Number(top), Number(bottom));
+    const width = Math.abs(Number(right) - Number(left)) + 1;
+    const height = Math.abs(Number(bottom) - Number(top)) + 1;
+    return this._call("GeoKernelViewer_SelectFeaturesInScreenRect", x, y, width, height, Number(selectionMode));
+  }
+
+  selectFeatureHit(hit, worldTolerance) {
+    if (!hit?.worldPoint) return false;
+    return this._call(
+      "GeoKernelViewer_SelectFeatureHit",
+      Number(hit.worldPoint.x),
+      Number(hit.worldPoint.y),
+      Number(worldTolerance),
+      Number(hit.layerIndex),
+      Number(hit.shapeId),
+      Number(hit.featureId),
+    );
+  }
+
   layerProjectedExtent(index) {
     const value = {};
     const ok = this._call("GeoKernelViewer_GetLayerProjectedExtent", Number(index), value);
@@ -748,10 +981,30 @@ class ViewerWindow {
     this._call("GeoKernelViewer_ClearSelectedFeatures");
   }
 
+  selectTopFeatureAt(screenX, screenY, pixelTolerance = 8) {
+    return this._call("GeoKernelViewer_SelectTopFeatureAt", Number(screenX), Number(screenY), Number(pixelTolerance));
+  }
+
+  addTopFeatureToSelectionAt(screenX, screenY, pixelTolerance = 8) {
+    return this._call("GeoKernelViewer_AddTopFeatureToSelectionAt", Number(screenX), Number(screenY), Number(pixelTolerance));
+  }
+
+  toggleTopFeatureSelectionAt(screenX, screenY, pixelTolerance = 8) {
+    return this._call("GeoKernelViewer_ToggleTopFeatureSelectionAt", Number(screenX), Number(screenY), Number(pixelTolerance));
+  }
+
+  selectedFeatures() {
+    return this._readJson("GeoKernelViewer_GetSelectedFeaturesJson", []);
+  }
+
   selectedFeatureCount() {
     return this._call("GeoKernelViewer_GetSelectedFeatureCount");
   }
 
+  zoomToSelectedFeatures() {
+    return this._call("GeoKernelViewer_ZoomToSelectedFeatures");
+  }
+
   clearLayers() {
     this._call("GeoKernelViewer_ClearLayers");
   }
@@ -844,6 +1097,21 @@ class ViewerWindow {
     return parseJson(readWideJson(this.library.function(name), this.viewerHandle, ...args), fallback);
   }
 
+  _readStaticJson(name, fallback, ...args) {
+    const fn = this.library.function(name);
+    let bufferLength = 4096;
+    for (let attempt = 0; attempt < 4; attempt += 1) {
+      const out = ["\0".repeat(bufferLength)];
+      const length = fn(...args, out, bufferLength);
+      if (length < 0) throw new Error(`${name} failed with result ${length}.`);
+      const nullIndex = out[0].indexOf("\0");
+      const text = nullIndex >= 0 ? out[0].slice(0, nullIndex) : out[0];
+      if (length < bufferLength - 1) return parseJson(text, fallback);
+      bufferLength = Math.max(bufferLength * 2, length + 1);
+    }
+    throw new Error(`${name} output exceeded the supported buffer size.`);
+  }
+
   _requireViewer() {
     if (!this.viewerHandle) {
       throw new Error("GeoKernel viewer is closed.");