geokernel-electron 1.1.36 → 1.1.37

package/package.json

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

package/src/native-signatures.js

@@ -274,13 +274,31 @@ const SIGNATURES = Object.freeze({
   "GeoKernelViewer_ZoomToLayer": ["bool", ["void_p", "int"]],
   "GeoKernelViewer_ZoomToScreenRect": ["void", ["void_p", "int", "int", "int", "int"]],
   "GeoKernelViewer_ZoomToSelectedFeatures": ["bool", ["void_p"]],
+  "GeoKernelWindow_AddCancellableLayerLoadToolbar": ["bool", ["void_p", "void_p", "wchar_p"]],
+  "GeoKernelWindow_AddCommandToolbar": ["bool", ["void_p", "wchar_p", "command_callback", "void_p"]],
+  "GeoKernelWindow_AddControlPanel": ["bool", ["void_p", "wchar_p", "control_callback", "void_p"]],
   "GeoKernelWindow_AddLayerManagementToolbar": ["bool", ["void_p", "void_p", "wchar_p"]],
+  "GeoKernelWindow_AddLayerPanel": ["bool", ["void_p", "void_p", "int"]],
+  "GeoKernelWindow_AddLayerSelector": ["bool", ["void_p", "void_p", "int"]],
+  "GeoKernelWindow_AddLayerStyleToolbar": ["bool", ["void_p", "void_p", "wchar_p"]],
+  "GeoKernelWindow_AddLegendPanel": ["bool", ["void_p", "wchar_p"]],
+  "GeoKernelWindow_AddLogPanel": ["bool", ["void_p", "wchar_p"]],
   "GeoKernelWindow_AddMeasureToolbar": ["void", ["void_p", "void_p"]],
   "GeoKernelWindow_AddNavigationToolbar": ["void", ["void_p", "void_p"]],
+  "GeoKernelWindow_AddSpatialIndexBenchmarkToolbar": ["bool", ["void_p", "void_p", "wchar_p"]],
+  "GeoKernelWindow_AddViewerPane": ["void_p", ["void_p", "wchar_p"]],
+  "GeoKernelWindow_AppendLog": ["void", ["void_p", "wchar_p"]],
+  "GeoKernelWindow_ClearLog": ["void", ["void_p"]],
   "GeoKernelWindow_Create": ["void_p", ["int", "int", "wchar_p"]],
   "GeoKernelWindow_Destroy": ["void", ["void_p"]],
+  "GeoKernelWindow_GetSelectedLayerIndex": ["int", ["void_p"]],
   "GeoKernelWindow_IsVisible": ["bool", ["void_p"]],
   "GeoKernelWindow_SetCentralViewer": ["void_p", ["void_p"]],
+  "GeoKernelWindow_SetControlValue": ["bool", ["void_p", "int", "double", "wchar_p"]],
+  "GeoKernelWindow_SetLegendItemsJson": ["bool", ["void_p", "wchar_p"]],
+  "GeoKernelWindow_SetLegendTitle": ["bool", ["void_p", "wchar_p"]],
+  "GeoKernelWindow_SetLegendWidth": ["bool", ["void_p", "int"]],
+  "GeoKernelWindow_SetStatusText": ["void", ["void_p", "wchar_p"]],
   "GeoKernelWindow_Show": ["void", ["void_p"]],
 });
 

package/src/native-types.js

@@ -59,6 +59,18 @@ const GeoKernelViewerSpatialIndexStateCallback = koffi.proto(
   ["int", "void *"],
 );
 
+const GeoKernelWindowCommandCallback = koffi.proto(
+  "GeoKernelWindowCommandCallback",
+  "void",
+  ["int", "void *"],
+);
+
+const GeoKernelWindowControlCallback = koffi.proto(
+  "GeoKernelWindowControlCallback",
+  "void",
+  ["int", "double", "str16", "void *"],
+);
+
 const TYPES = Object.freeze({
   void: "void",
   void_p: "void *",
@@ -86,6 +98,8 @@ const TYPES = Object.freeze({
   progress_callback: koffi.pointer(GeoKernelViewerLayerLoadProgressCallback),
   cancel_callback: koffi.pointer(GeoKernelViewerLayerLoadCancellationCallback),
   index_state_callback: koffi.pointer(GeoKernelViewerSpatialIndexStateCallback),
+  command_callback: koffi.pointer(GeoKernelWindowCommandCallback),
+  control_callback: koffi.pointer(GeoKernelWindowControlCallback),
 });
 
 module.exports = {
@@ -97,5 +111,7 @@ module.exports = {
   GeoKernelViewerRouteSummary,
   GeoKernelViewerScreenRectangle,
   GeoKernelViewerSpatialIndexStateCallback,
+  GeoKernelWindowCommandCallback,
+  GeoKernelWindowControlCallback,
   TYPES,
 };

package/src/types.js

@@ -13,6 +13,37 @@ const ViewerTool = Object.freeze({
   EDIT_VERTICES: 9,
 });
 
+const ViewerEventType = Object.freeze({
+  ACTIVE_TOOL_CHANGED: 1,
+  LAYERS_CHANGED: 2,
+  LAYER_ADDED: 3,
+  LAYER_REMOVED: 4,
+  LAYER_VISIBILITY_CHANGED: 5,
+  LAYER_EDIT_STATE_CHANGED: 6,
+  LAYER_EDIT_SESSION_STARTED: 7,
+  LAYER_EDIT_SESSION_COMMITTED: 8,
+  LAYER_EDIT_SESSION_ROLLED_BACK: 9,
+  LAYER_ORDER_CHANGED: 10,
+  SELECTION_CHANGED: 11,
+  VISIBLE_EXTENT_CHANGED: 12,
+  ZOOM_CHANGED: 13,
+  VIEW_CHANGED: 14,
+  BUSY_CHANGED: 15,
+  PROJECT_OPENED: 16,
+  PROJECT_CLOSED: 17,
+  MAP_SELECTION_BOX_FINISHED: 18,
+  MOUSE_COORDINATES_CHANGED: 19,
+  MAP_MOUSE_DOWN: 20,
+  MAP_MOUSE_MOVE: 21,
+  MAP_MOUSE_UP: 22,
+  LAYER_ADDING: 23,
+  LAYER_REMOVING: 24,
+  INDEX_CREATING: 25,
+  INDEX_CREATED: 26,
+  INDEX_LOADED: 27,
+  RENDER_BACKEND_CHANGED: 28,
+});
+
 const ShapeType = Object.freeze({
   UNKNOWN: 0,
   POINT: 1,
@@ -114,6 +145,7 @@ module.exports = {
   SpatialIndexType,
   SymbolStyleTarget,
   ViewerTool,
+  ViewerEventType,
   extent,
   point,
   routeSummary,

package/src/viewer.js

@@ -1,6 +1,8 @@
 "use strict";
 
 const fs = require("fs");
+const koffi = require("koffi");
+const { GeoKernelViewerEventData, TYPES } = require("./native-types");
 
 const { createNativeLibrary } = require("./native");
 const { MAP_STYLES, argb } = require("./styles");
@@ -63,10 +65,20 @@ class ViewerWindow {
       throw new Error("GeoKernelWindow_Create failed.");
     }
 
-    this.viewerHandle = this.library.windowSetCentralViewer(this.windowHandle);
-    if (!this.viewerHandle) {
+    const paneTitles = Array.isArray(options.viewerPanes) ? options.viewerPanes : null;
+    const paneHandles = paneTitles?.map((paneTitle) =>
+      this.library.function("GeoKernelWindow_AddViewerPane")(this.windowHandle, paneTitle));
+    this.viewerHandle = paneHandles?.[0] ?? this.library.windowSetCentralViewer(this.windowHandle);
+    if (!this.viewerHandle || paneHandles?.some((handle) => !handle)) {
       this.library.windowDestroy(this.windowHandle);
-      throw new Error("GeoKernelWindow_SetCentralViewer failed.");
+      throw new Error(paneTitles
+        ? "GeoKernelWindow_AddViewerPane failed."
+        : "GeoKernelWindow_SetCentralViewer failed.");
+    }
+
+    this.paneFacades = [];
+    if (paneHandles) {
+      this.paneFacades = paneHandles.slice(1).map((handle) => this._createPaneFacade(handle));
     }
 
     if (options.navigationToolbar !== false) {
@@ -81,15 +93,49 @@ class ViewerWindow {
       this.addLayerManagementToolbar(options.layerManagementToolbar);
     }
 
+    if (options.layerPanel) {
+      this.addLayerPanel(options.layerPanel);
+    }
+    if (options.layerSelector) {
+      this.addLayerSelector(options.layerSelector);
+    }
+    if (options.layerStyleToolbar) {
+      this.addLayerStyleToolbar(options.layerStyleToolbar);
+    }
+
     this.interval = null;
     this.visibleOnce = false;
     this.startedAt = 0;
+    this.commandCallbacks = [];
+    this.controlCallbacks = [];
+    this.eventCallbacks = [];
   }
 
   setActivationType(value) {
     this.library.setActivationType(this.viewerHandle, value);
   }
 
+  pane(index) {
+    if (index === 0) return this;
+    return this.paneFacades[index - 1] ?? null;
+  }
+
+  _createPaneFacade(viewerHandle) {
+    const pane = Object.create(ViewerWindow.prototype);
+    pane.library = this.library;
+    pane.windowHandle = this.windowHandle;
+    pane.viewerHandle = viewerHandle;
+    pane.interval = null;
+    pane.visibleOnce = false;
+    pane.startedAt = 0;
+    pane.commandCallbacks = [];
+    pane.controlCallbacks = [];
+    pane.eventCallbacks = [];
+    pane.paneFacades = [];
+    pane.isPaneFacade = true;
+    return pane;
+  }
+
   setLicenseManagerUrl(value) {
     this.library.setLicenseManagerUrl(this.viewerHandle, value ?? "");
   }
@@ -113,6 +159,148 @@ class ViewerWindow {
     }
   }
 
+  addLayerPanel(options = {}) {
+    const features =
+      (options.allowReorder === true ? 1 : 0) |
+      (options.allowVisibility === true ? 2 : 0);
+    const ok = this.library.function("GeoKernelWindow_AddLayerPanel")(
+      this.windowHandle,
+      this.viewerHandle,
+      features,
+    );
+    if (!ok) {
+      throw new Error("GeoKernelWindow_AddLayerPanel failed.");
+    }
+  }
+
+  addLayerSelector(options = {}) {
+    const actions = { zoom: 1 };
+    const action = actions[options.action] ?? 0;
+    const ok = this.library.function("GeoKernelWindow_AddLayerSelector")(
+      this.windowHandle,
+      this.viewerHandle,
+      action,
+    );
+    if (!ok) {
+      throw new Error("GeoKernelWindow_AddLayerSelector failed.");
+    }
+  }
+
+  addLayerStyleToolbar(options = {}) {
+    const ok = this.library.function("GeoKernelWindow_AddLayerStyleToolbar")(
+      this.windowHandle,
+      this.viewerHandle,
+      jsonText(options),
+    );
+    if (!ok) {
+      throw new Error("GeoKernelWindow_AddLayerStyleToolbar failed.");
+    }
+  }
+
+  addSpatialIndexBenchmarkToolbar(options = {}) {
+    const ok = this.library.function("GeoKernelWindow_AddSpatialIndexBenchmarkToolbar")(
+      this.windowHandle,
+      this.viewerHandle,
+      jsonText(options),
+    );
+    if (!ok) throw new Error("GeoKernelWindow_AddSpatialIndexBenchmarkToolbar failed.");
+  }
+
+  addCancellableLayerLoadToolbar(options = {}) {
+    const ok = this.library.function("GeoKernelWindow_AddCancellableLayerLoadToolbar")(
+      this.windowHandle, this.viewerHandle, jsonText(options),
+    );
+    if (!ok) throw new Error("GeoKernelWindow_AddCancellableLayerLoadToolbar failed.");
+  }
+
+  addCommandToolbar(commands, onCommand) {
+    const callback = koffi.register((commandId) => onCommand(commandId), TYPES.command_callback);
+    this.commandCallbacks.push(callback);
+    const ok = this.library.function("GeoKernelWindow_AddCommandToolbar")(
+      this.windowHandle, jsonText({ commands }), callback, null,
+    );
+    if (!ok) throw new Error("GeoKernelWindow_AddCommandToolbar failed.");
+  }
+
+  addControlPanel(configuration, onChange) {
+    const callback = koffi.register(
+      (controlId, numericValue, textValue) => onChange(controlId, numericValue, textValue ?? ""),
+      TYPES.control_callback,
+    );
+    this.controlCallbacks.push(callback);
+    const ok = this.library.function("GeoKernelWindow_AddControlPanel")(
+      this.windowHandle, jsonText(configuration), callback, null,
+    );
+    if (!ok) throw new Error("GeoKernelWindow_AddControlPanel failed.");
+  }
+
+  setControlValue(controlId, value) {
+    const numericValue = typeof value === "number" ? value : 0;
+    const textValue = typeof value === "string" ? value : null;
+    return this.library.function("GeoKernelWindow_SetControlValue")(
+      this.windowHandle, Number(controlId), numericValue, textValue,
+    );
+  }
+
+  setStatusText(text) {
+    this.library.function("GeoKernelWindow_SetStatusText")(this.windowHandle, text ?? "");
+  }
+
+  addLogPanel(title = "Event log") {
+    const ok = this.library.function("GeoKernelWindow_AddLogPanel")(this.windowHandle, title);
+    if (!ok) throw new Error("GeoKernelWindow_AddLogPanel failed.");
+  }
+
+  addLegendPanel(title = "Legend") {
+    const ok = this.library.function("GeoKernelWindow_AddLegendPanel")(this.windowHandle, title);
+    if (!ok) throw new Error("GeoKernelWindow_AddLegendPanel failed.");
+  }
+
+  setLegendTitle(title) {
+    return this.library.function("GeoKernelWindow_SetLegendTitle")(this.windowHandle, title);
+  }
+
+  setLegendWidth(width) {
+    return this.library.function("GeoKernelWindow_SetLegendWidth")(this.windowHandle, Number(width));
+  }
+
+  setLegendItems(items) {
+    return this.library.function("GeoKernelWindow_SetLegendItemsJson")(
+      this.windowHandle, jsonText(items),
+    );
+  }
+
+  appendLog(text) {
+    this.library.function("GeoKernelWindow_AppendLog")(this.windowHandle, text ?? "");
+  }
+
+  clearLog() {
+    this.library.function("GeoKernelWindow_ClearLog")(this.windowHandle);
+  }
+
+  selectedLayerIndex() {
+    return this.library.function("GeoKernelWindow_GetSelectedLayerIndex")(this.windowHandle);
+  }
+
+  setEventCallback(onEvent) {
+    this.library.function("GeoKernelViewer_SetEventCallback")(this.viewerHandle, null, null);
+    for (const callback of this.eventCallbacks) koffi.unregister(callback);
+    this.eventCallbacks = [];
+    if (typeof onEvent !== "function") return;
+
+    const callback = koffi.register((dataPointer, text) => {
+      const data = koffi.decode(dataPointer, GeoKernelViewerEventData);
+      onEvent({
+        ...data,
+        extent: { ...data.extent },
+        screenRectangle: { ...data.screenRectangle },
+        text: text ?? "",
+      });
+    }, TYPES.event_callback);
+    this.eventCallbacks.push(callback);
+    this.library.function("GeoKernelViewer_SetEventCallback")(this.viewerHandle, callback, null);
+  }
+
   getTool() {
     return this._call("GeoKernelViewer_GetTool");
   }
@@ -208,11 +396,42 @@ class ViewerWindow {
     return this._call("GeoKernelViewer_AddEmptyVectorLayer", name, Number(shapeType), jsonText(style));
   }
 
+  beginEditLayer(index) { return this._call("GeoKernelViewer_BeginEditLayer", Number(index)); }
+  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)); }
+  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) {
+    const xy = xyArray(points);
+    return this._call("GeoKernelViewer_AddPolylineToEditLayer", Number(index), xy, xy.length / 2);
+  }
+  addPolygonToEditLayer(index, points) {
+    const xy = xyArray(points);
+    return this._call("GeoKernelViewer_AddPolygonToEditLayer", Number(index), xy, xy.length / 2);
+  }
+
   addPointLayer(name, points, style) {
     const xy = xyArray(points);
     return this._call("GeoKernelViewer_AddPointLayer", name, xy, xy.length / 2, jsonText(style));
   }
 
+  addAttributedPointLayer(name, points, attributes, style, sourceEpsg = 4326) {
+    if (!Array.isArray(attributes) || attributes.length !== points.length) {
+      throw new Error("Attributed point layers require one attribute object per point.");
+    }
+    const xy = xyArray(points);
+    return this._call(
+      "GeoKernelViewer_AddAttributedPointLayer",
+      name,
+      xy,
+      xy.length / 2,
+      jsonText(attributes),
+      jsonText(style),
+      Number(sourceEpsg),
+    );
+  }
+
   addPolylineLayer(name, parts, style) {
     const arrays = partsArrays(parts);
     return this._call("GeoKernelViewer_AddPolylineLayer", name, arrays.xy, arrays.counts, arrays.counts.length, jsonText(style));
@@ -227,6 +446,10 @@ class ViewerWindow {
     this.library.setMapBackgroundColor(this.viewerHandle, argb(color));
   }
 
+  invalidateRenderCache(clearTileCache = false, clearLayerCache = false) {
+    this._call("GeoKernelViewer_InvalidateRenderCache", Boolean(clearTileCache), Boolean(clearLayerCache));
+  }
+
   getBackground() {
     return this._call("GeoKernelViewer_GetMapBackgroundColor");
   }
@@ -345,7 +568,7 @@ class ViewerWindow {
       options.colorRampName ?? "Unique",
       options.categoryLimit ?? 64,
       options.reverseColorRamp ?? false,
-      options.sampleLimit ?? 0,
+      options.sampleLimit ?? 5000,
       options.styleTarget ?? 0,
       options.startSize ?? 4.0,
       options.endSize ?? 14.0,
@@ -366,7 +589,7 @@ class ViewerWindow {
       breaks.length,
       options.colorRampMode ?? 0,
       options.reverseColorRamp ?? false,
-      options.sampleLimit ?? 0,
+      options.sampleLimit ?? 5000,
       options.styleTarget ?? 0,
       options.startSize ?? 4.0,
       options.endSize ?? 18.0,
@@ -521,6 +744,14 @@ class ViewerWindow {
     this._call("GeoKernelViewer_ClearShapes");
   }
 
+  clearSelectedFeatures() {
+    this._call("GeoKernelViewer_ClearSelectedFeatures");
+  }
+
+  selectedFeatureCount() {
+    return this._call("GeoKernelViewer_GetSelectedFeatureCount");
+  }
+
   clearLayers() {
     this._call("GeoKernelViewer_ClearLayers");
   }
@@ -566,6 +797,27 @@ class ViewerWindow {
       this.interval = null;
     }
 
+    for (const pane of this.paneFacades) {
+      if (pane.viewerHandle) {
+        pane.library.function("GeoKernelViewer_SetEventCallback")(pane.viewerHandle, null, null);
+        for (const callback of pane.eventCallbacks) koffi.unregister(callback);
+        pane.eventCallbacks = [];
+        pane.clearAll();
+        pane.viewerHandle = null;
+      }
+    }
+    this.paneFacades = [];
+
+    if (this.viewerHandle) {
+      this.library.function("GeoKernelViewer_SetEventCallback")(this.viewerHandle, null, null);
+    }
+    for (const callback of this.eventCallbacks) koffi.unregister(callback);
+    this.eventCallbacks = [];
+    for (const callback of this.commandCallbacks) koffi.unregister(callback);
+    this.commandCallbacks = [];
+    for (const callback of this.controlCallbacks) koffi.unregister(callback);
+    this.controlCallbacks = [];
+
     if (this.viewerHandle) {
       this.clearAll();
       this.viewerHandle = null;