geokernel-electron 1.1.36 → 1.1.38

package/package.json

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

package/src/native-signatures.js

@@ -274,13 +274,33 @@ 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_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"]],
+  "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,
@@ -25,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,
@@ -104,6 +143,7 @@ function routeSummary(value) {
 }
 
 module.exports = {
+  AttributeType,
   ClassificationMethod,
   ColorRampMode,
   MeasureMode,
@@ -114,6 +154,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,164 @@ 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 ?? "");
+  }
+
+  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.");
+  }
+
+  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 +412,154 @@ 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)); }
+  canEditLayer(index) { return this._call("GeoKernelViewer_CanEditLayer", Number(index)); }
+  setActiveEditLayerIndex(index) { return this._call("GeoKernelViewer_SetActiveEditLayerIndex", Number(index)); }
+  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, 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);
     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 +574,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 +696,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 +717,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,
@@ -400,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];
@@ -474,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);
@@ -521,6 +977,34 @@ class ViewerWindow {
     this._call("GeoKernelViewer_ClearShapes");
   }
 
+  clearSelectedFeatures() {
+    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");
   }
@@ -566,6 +1050,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;
@@ -592,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.");