geokernel-electron 1.0.2

package/src/viewer.js

@@ -0,0 +1,524 @@
+"use strict";
+
+const fs = require("fs");
+
+const { createNativeLibrary } = require("./native");
+const { MAP_STYLES, argb } = require("./styles");
+const {
+  ViewerTool,
+  extent,
+  point,
+} = require("./types");
+const {
+  extentObject,
+  jsonText,
+  parseJson,
+  partsArrays,
+  readWideJson,
+  readWideText,
+  xyArray,
+} = require("./viewer-helpers");
+
+class GeoKernelLibrary {
+  constructor(binDir) {
+    this.native = createNativeLibrary(binDir);
+    this.bind();
+  }
+
+  bind() {
+    this.windowCreate = this.native.getFunction("GeoKernelWindow_Create");
+    this.windowDestroy = this.native.getFunction("GeoKernelWindow_Destroy");
+    this.windowShow = this.native.getFunction("GeoKernelWindow_Show");
+    this.windowIsVisible = this.native.getFunction("GeoKernelWindow_IsVisible");
+    this.windowSetCentralViewer = this.native.getFunction("GeoKernelWindow_SetCentralViewer");
+    this.windowAddNavigationToolbar = this.native.getFunction("GeoKernelWindow_AddNavigationToolbar");
+    this.processEvents = this.native.getFunction("GeoKernelViewer_ProcessEvents");
+    this.setActivationType = this.native.getFunction("GeoKernelViewer_SetActivationTypeName");
+    this.setLicenseKey = this.native.getFunction("GeoKernelViewer_SetLicenseKey");
+    this.setTool = this.native.getFunction("GeoKernelViewer_SetTool");
+    this.addLayerFile = this.native.getFunction("GeoKernelViewer_AddLayerFile");
+    this.setMapBackgroundColor = this.native.getFunction("GeoKernelViewer_SetMapBackgroundColor");
+    this.setLayerStyleJson = this.native.getFunction("GeoKernelViewer_SetLayerStyleJson");
+    this.fullExtent = this.native.getFunction("GeoKernelViewer_FullExtent");
+    this.zoomIn = this.native.getFunction("GeoKernelViewer_ZoomIn");
+    this.zoomOut = this.native.getFunction("GeoKernelViewer_ZoomOut");
+    this.refreshLayers = this.native.getFunction("GeoKernelViewer_RefreshLayers");
+    this.clearAll = this.native.getFunction("GeoKernelViewer_ClearAll");
+  }
+
+  function(name) {
+    return this.native.getFunction(name);
+  }
+}
+
+class ViewerWindow {
+  constructor(options = {}) {
+    const width = options.width ?? 1200;
+    const height = options.height ?? 800;
+    const title = options.title ?? "GeoKernel";
+    this.library = new GeoKernelLibrary(options.binDir);
+    this.windowHandle = this.library.windowCreate(width, height, title);
+    if (!this.windowHandle) {
+      throw new Error("GeoKernelWindow_Create failed.");
+    }
+
+    this.viewerHandle = this.library.windowSetCentralViewer(this.windowHandle);
+    if (!this.viewerHandle) {
+      this.library.windowDestroy(this.windowHandle);
+      throw new Error("GeoKernelWindow_SetCentralViewer failed.");
+    }
+
+    if (options.navigationToolbar !== false) {
+      this.library.windowAddNavigationToolbar(this.windowHandle, this.viewerHandle);
+    }
+
+    this.interval = null;
+    this.visibleOnce = false;
+    this.startedAt = 0;
+  }
+
+  setActivationType(value) {
+    this.library.setActivationType(this.viewerHandle, value);
+  }
+
+  setLicenseKey(value) {
+    this.library.setLicenseKey(this.viewerHandle, value);
+  }
+
+  setTool(tool) {
+    this.library.setTool(this.viewerHandle, tool);
+  }
+
+  getTool() {
+    return this._call("GeoKernelViewer_GetTool");
+  }
+
+  addLayerFile(filePath, options) {
+    if (!fs.existsSync(filePath)) {
+      throw new Error(`Layer file not found: ${filePath}`);
+    }
+
+    const ok = options === undefined
+      ? this.library.addLayerFile(this.viewerHandle, filePath)
+      : this._call("GeoKernelViewer_AddLayerFileWithOptionsJson", filePath, jsonText(options));
+    if (!ok) {
+      throw new Error(`GeoKernelViewer_AddLayerFile failed: ${filePath}`);
+    }
+  }
+
+  addLayer(filePath, options) {
+    this.addLayerFile(filePath, options);
+  }
+
+  addOpenStreetMapLayer(localCacheEnabled = true) {
+    return this._call("GeoKernelViewer_AddOpenStreetMapLayer", Boolean(localCacheEnabled));
+  }
+
+  addXyzLayer(options) {
+    return this._call(
+      "GeoKernelViewer_AddXyzLayer",
+      options.name,
+      options.urlTemplate,
+      options.minZoom ?? 0,
+      options.maxZoom ?? 19,
+      options.tileSize ?? 256,
+      options.attribution ?? "",
+      options.localCacheEnabled ?? true,
+      options.cacheDirectory ?? "",
+    );
+  }
+
+  addWmsLayer(options) {
+    return this._call(
+      "GeoKernelViewer_AddWmsLayer",
+      options.name,
+      options.serviceUrl,
+      options.layers,
+      options.styles ?? "",
+      options.version ?? "1.3.0",
+      options.crs ?? "EPSG:3857",
+      options.format ?? "image/png",
+      options.transparent ?? true,
+      options.minZoom ?? 0,
+      options.maxZoom ?? 19,
+      options.tileSize ?? 256,
+      options.attribution ?? "",
+      options.localCacheEnabled ?? true,
+      options.cacheDirectory ?? "",
+    );
+  }
+
+  addWmtsLayer(options) {
+    return this._call(
+      "GeoKernelViewer_AddWmtsLayer",
+      options.name,
+      options.serviceUrl,
+      options.layer,
+      options.style ?? "",
+      options.format ?? "image/png",
+      options.tileMatrixSet ?? "",
+      options.customUrlTemplate ?? "",
+      options.minZoom ?? 0,
+      options.maxZoom ?? 19,
+      options.tileSize ?? 256,
+      options.attribution ?? "",
+      options.localCacheEnabled ?? true,
+      options.cacheDirectory ?? "",
+    );
+  }
+
+  addWfsLayer(options) {
+    return this._call(
+      "GeoKernelViewer_AddWfsLayer",
+      options.name,
+      options.serviceUrl,
+      options.typeName,
+      options.version ?? "2.0.0",
+      options.srsName ?? "EPSG:4326",
+      options.outputFormat ?? "application/json",
+      options.maxFeatures ?? 0,
+    );
+  }
+
+  addEmptyVectorLayer(name, shapeType, style) {
+    return this._call("GeoKernelViewer_AddEmptyVectorLayer", name, Number(shapeType), jsonText(style));
+  }
+
+  addPointLayer(name, points, style) {
+    const xy = xyArray(points);
+    return this._call("GeoKernelViewer_AddPointLayer", name, xy, xy.length / 2, jsonText(style));
+  }
+
+  addPolylineLayer(name, parts, style) {
+    const arrays = partsArrays(parts);
+    return this._call("GeoKernelViewer_AddPolylineLayer", name, arrays.xy, arrays.counts, arrays.counts.length, jsonText(style));
+  }
+
+  addPolygonLayer(name, rings, style) {
+    const arrays = partsArrays(rings);
+    return this._call("GeoKernelViewer_AddPolygonLayer", name, arrays.xy, arrays.counts, arrays.counts.length, jsonText(style));
+  }
+
+  setBackground(color) {
+    this.library.setMapBackgroundColor(this.viewerHandle, argb(color));
+  }
+
+  getBackground() {
+    return this._call("GeoKernelViewer_GetMapBackgroundColor");
+  }
+
+  setLayerStyle(index, style) {
+    const payload = typeof style.toLayerStyleJson === "function" ? style.toLayerStyleJson() : style;
+    const ok = this.library.setLayerStyleJson(this.viewerHandle, index, jsonText(payload));
+    if (!ok) {
+      throw new Error(`GeoKernelViewer_SetLayerStyleJson failed for layer ${index}.`);
+    }
+  }
+
+  layerStyle(index) {
+    return this._readJson("GeoKernelViewer_GetLayerStyleJson", {}, Number(index));
+  }
+
+  setMapStyle(name, layerIndex = 0) {
+    const style = MAP_STYLES[name];
+    if (!style) {
+      throw new Error(`Unknown map style '${name}'. Available: ${Object.keys(MAP_STYLES).sort().join(", ")}`);
+    }
+
+    this.setBackground(style.background);
+    this.setLayerStyle(layerIndex, style);
+  }
+
+  setMapStyleName(themeName, applyToExistingLayers = true) {
+    const ok = this._call("GeoKernelViewer_SetMapStyleName", themeName, Boolean(applyToExistingLayers));
+    if (!ok) {
+      throw new Error(`GeoKernelViewer_SetMapStyleName failed: ${themeName}`);
+    }
+  }
+
+  setLayerSymbolRenderer(index, renderer) {
+    return this._call("GeoKernelViewer_SetLayerSymbolRendererJson", Number(index), jsonText(renderer));
+  }
+
+  layerSymbolRenderer(index) {
+    return this._readJson("GeoKernelViewer_GetLayerSymbolRendererJson", {}, Number(index));
+  }
+
+  clearLayerSymbolRenderer(index) {
+    return this._call("GeoKernelViewer_ClearLayerSymbolRenderer", Number(index));
+  }
+
+  colorRampNames() {
+    return this._readJson("GeoKernelViewer_GetColorRampNamesJson", []);
+  }
+
+  containsColorRamp(name) {
+    return this._call("GeoKernelViewer_ContainsColorRamp", name);
+  }
+
+  applyCategorizedRenderer(index, options) {
+    return this._call(
+      "GeoKernelViewer_ApplyLayerCategorizedRenderer",
+      Number(index),
+      options.fieldName,
+      options.colorRampName ?? "Unique",
+      options.categoryLimit ?? 64,
+      options.reverseColorRamp ?? false,
+      options.sampleLimit ?? 0,
+      options.styleTarget ?? 0,
+      options.startSize ?? 4.0,
+      options.endSize ?? 14.0,
+    );
+  }
+
+  applyGraduatedRenderer(index, options) {
+    const breaks = Float64Array.from(options.manualBreaks ?? []);
+    return this._call(
+      "GeoKernelViewer_ApplyLayerGraduatedRenderer",
+      Number(index),
+      options.fieldName,
+      options.method ?? 4,
+      options.classCount ?? 5,
+      options.colorRampName ?? "Viridis",
+      options.interval ?? 0.0,
+      breaks,
+      breaks.length,
+      options.colorRampMode ?? 0,
+      options.reverseColorRamp ?? false,
+      options.sampleLimit ?? 0,
+      options.styleTarget ?? 0,
+      options.startSize ?? 4.0,
+      options.endSize ?? 18.0,
+    );
+  }
+
+  show() {
+    this.library.windowShow(this.windowHandle);
+    this.processEvents();
+  }
+
+  openProject(projectPath) {
+    return this._call("GeoKernelViewer_OpenProject", projectPath);
+  }
+
+  saveProject(projectPath) {
+    return this._call("GeoKernelViewer_SaveProject", projectPath);
+  }
+
+  closeProject() {
+    this._call("GeoKernelViewer_CloseProject");
+  }
+
+  getViewExtent() {
+    const value = {};
+    const ok = this._call("GeoKernelViewer_GetViewExtent", value);
+    return ok ? extent(value.xMin, value.yMin, value.xMax, value.yMax) : null;
+  }
+
+  setViewExtent(value) {
+    this._call("GeoKernelViewer_SetViewExtent", extentObject(value));
+  }
+
+  worldToScreen(x, y) {
+    const screenX = [0];
+    const screenY = [0];
+    const ok = this._call("GeoKernelViewer_WorldToScreen", Number(x), Number(y), screenX, screenY);
+    return ok ? point(screenX[0], screenY[0]) : null;
+  }
+
+  screenToWorld(x, y) {
+    const worldX = [0];
+    const worldY = [0];
+    const ok = this._call("GeoKernelViewer_ScreenToWorld", Number(x), Number(y), worldX, worldY);
+    return ok ? point(worldX[0], worldY[0]) : null;
+  }
+
+  fullExtent() {
+    this.library.fullExtent(this.viewerHandle);
+  }
+
+  zoomIn(factor = 1.5) {
+    this.library.zoomIn(this.viewerHandle, factor);
+  }
+
+  zoomOut(factor = 1.5) {
+    this.library.zoomOut(this.viewerHandle, factor);
+  }
+
+  zoomAtPoint(screenX, screenY, factor = 1.5) {
+    this._call("GeoKernelViewer_ZoomAtPoint", Number(screenX), Number(screenY), Number(factor));
+  }
+
+  zoomToScreenRect(left, top, right, bottom) {
+    this._call("GeoKernelViewer_ZoomToScreenRect", Number(left), Number(top), Number(right), Number(bottom));
+  }
+
+  zoomToLayer(index) {
+    return this._call("GeoKernelViewer_ZoomToLayer", Number(index));
+  }
+
+  refreshLayers() {
+    this.library.refreshLayers(this.viewerHandle);
+  }
+
+  layerCount() {
+    return this._call("GeoKernelViewer_GetLayerCount");
+  }
+
+  layerInfo(index) {
+    return this._readJson("GeoKernelViewer_GetLayerInfoJson", {}, Number(index));
+  }
+
+  layerInfoByName(name) {
+    return this._readJson("GeoKernelViewer_GetLayerInfoByNameJson", {}, name);
+  }
+
+  layersInfo() {
+    return this._readJson("GeoKernelViewer_GetLayersInfoJson", []);
+  }
+
+  layerDisplayText(index) {
+    return this._readText("GeoKernelViewer_GetLayerDisplayText", Number(index));
+  }
+
+  layerAttributeDefinitions(index) {
+    return this._readJson("GeoKernelViewer_GetLayerAttributeDefinitionsJson", [], Number(index));
+  }
+
+  layerFeatureCount(index) {
+    return this._call("GeoKernelViewer_GetLayerFeatureCount", Number(index));
+  }
+
+  layerFeatureAttributes(index, rowIndex) {
+    return this._readJson("GeoKernelViewer_GetLayerFeatureAttributesJson", {}, Number(index), Number(rowIndex));
+  }
+
+  layerProjectedExtent(index) {
+    const value = {};
+    const ok = this._call("GeoKernelViewer_GetLayerProjectedExtent", Number(index), value);
+    return ok ? extent(value.xMin, value.yMin, value.xMax, value.yMax) : null;
+  }
+
+  layerShapeType(index) {
+    return this._call("GeoKernelViewer_GetLayerShapeType", Number(index));
+  }
+
+  moveLayer(fromIndex, toIndex) {
+    return this._call("GeoKernelViewer_MoveLayer", Number(fromIndex), Number(toIndex));
+  }
+
+  removeLayer(index) {
+    return this._call("GeoKernelViewer_RemoveLayer", Number(index));
+  }
+
+  removeLayerByName(name) {
+    return this._call("GeoKernelViewer_RemoveLayerByName", name);
+  }
+
+  setLayerName(index, name) {
+    return this._call("GeoKernelViewer_SetLayerName", Number(index), name);
+  }
+
+  setLayerVisible(index, visible) {
+    return this._call("GeoKernelViewer_SetLayerVisible", Number(index), Boolean(visible));
+  }
+
+  setLayerVisibleScaleRange(index, minVisibleScale, maxVisibleScale) {
+    return this._call(
+      "GeoKernelViewer_SetLayerVisibleScaleRange",
+      Number(index),
+      Number(minVisibleScale),
+      Number(maxVisibleScale),
+    );
+  }
+
+  clearLayerVisibleScaleRange(index) {
+    return this._call("GeoKernelViewer_ClearLayerVisibleScaleRange", Number(index));
+  }
+
+  clearShapes() {
+    this._call("GeoKernelViewer_ClearShapes");
+  }
+
+  clearLayers() {
+    this._call("GeoKernelViewer_ClearLayers");
+  }
+
+  clearAll() {
+    this._call("GeoKernelViewer_ClearAll");
+  }
+
+  processEvents() {
+    this.library.processEvents();
+  }
+
+  isVisible() {
+    return Boolean(this.library.windowIsVisible(this.windowHandle));
+  }
+
+  runUntilClosed(onClosed) {
+    if (this.interval) {
+      return;
+    }
+
+    this.startedAt = Date.now();
+    this.visibleOnce = false;
+    this.interval = setInterval(() => {
+      this.processEvents();
+      const visible = this.isVisible();
+      if (visible) {
+        this.visibleOnce = true;
+      }
+
+      if (!visible && (this.visibleOnce || Date.now() - this.startedAt > 1500)) {
+        this.close();
+        if (typeof onClosed === "function") {
+          onClosed();
+        }
+      }
+    }, 16);
+  }
+
+  close() {
+    if (this.interval) {
+      clearInterval(this.interval);
+      this.interval = null;
+    }
+
+    if (this.viewerHandle) {
+      this.clearAll();
+      this.viewerHandle = null;
+    }
+
+    if (this.windowHandle) {
+      this.library.windowDestroy(this.windowHandle);
+      this.windowHandle = null;
+    }
+  }
+
+  _call(name, ...args) {
+    this._requireViewer();
+    return this.library.function(name)(this.viewerHandle, ...args);
+  }
+
+  _readText(name, ...args) {
+    this._requireViewer();
+    return readWideText(this.library.function(name), this.viewerHandle, ...args);
+  }
+
+  _readJson(name, fallback, ...args) {
+    this._requireViewer();
+    return parseJson(readWideJson(this.library.function(name), this.viewerHandle, ...args), fallback);
+  }
+
+  _requireViewer() {
+    if (!this.viewerHandle) {
+      throw new Error("GeoKernel viewer is closed.");
+    }
+  }
+}
+
+module.exports = {
+  ViewerTool,
+  ViewerWindow,
+};