@loveluthien/carta-frontend 6.0.0-dev

package/schemas/preferences_schema_2.json

@@ -0,0 +1,421 @@
+{
+    "$schema": "http://json-schema.org/draft-07/schema#",
+    "title": "Preferences",
+    "description": "Schema for CARTA Preferences (Version 2)",
+    "$id": "https://cartavis.org/schemas/preferences_schema_2.json",
+    "type": "object",
+    "required": ["version"],
+    "properties": {
+        "version": {
+            "description": "The version of the preferences contained",
+            "type": "integer",
+            "minimum": 1,
+            "maximum": 2
+        },
+        "theme": {
+            "enum": ["auto", "light", "dark"]
+        },
+        "autoLaunch": {
+            "type": "boolean"
+        },
+        "fileSortingString": {
+            "type": "string",
+            "pattern": "^([+\\-])(date|filename|type|size)$"
+        },
+        "fileFilteringType": {
+            "enum": ["fuzzy", "unix", "regex"]
+        },
+        "layout": {
+            "type": "string"
+        },
+        "cursorPosition": {
+            "enum": ["fixed", "tracking"]
+        },
+        "zoomMode": {
+            "enum": ["fit", "full"]
+        },
+        "zoomPoint": {
+            "enum": ["cursor", "center"]
+        },
+        "dragPanning": {
+            "type": "boolean"
+        },
+        "spectralMatchingType": {
+            "enum": ["VRAD", "VOPT", "FREQ", "WAVE", "AWAV", "CHANNEL"]
+        },
+        "transparentImageBackground": {
+            "type": "boolean"
+        },
+        "scaling": {
+            "type": "integer",
+            "minimum": 0,
+            "maximum": 7
+        },
+        "colormap": {
+            "type": "string"
+        },
+        "percentile": {
+            "type": "number",
+            "minimum": 0,
+            "maximum": 100
+        },
+        "scalingAlpha": {
+            "type": "number",
+            "minimum": 0.1,
+            "maximum": 1000000
+        },
+        "scalingGamma": {
+            "type": "number",
+            "minimum": 0.1,
+            "maximum": 2
+        },
+        "nanColorHex": {
+            "type": "string",
+            "description": "TODO: validate color string"
+        },
+        "nanAlpha": {
+            "type": "number",
+            "minimum": 0,
+            "maximum": 1
+        },
+        "useSmoothedBiasContrast": {
+            "type": "boolean"
+        },
+        "contourGeneratorType": {
+            "enum": ["start-step-multiplier", "min-max-scaling", "percentages-ref.value", "mean-sigma-list"]
+        },
+        "contourSmoothingMode": {
+            "type": "integer",
+            "minimum": 0,
+            "maximum": 2
+        },
+        "contourSmoothingFactor": {
+            "type": "integer",
+            "minimum": 1,
+            "maximum": 33
+        },
+        "contourNumLevels": {
+            "type": "integer",
+            "minimum": 1,
+            "maximum": 15
+        },
+        "contourThickness": {
+            "type": "number",
+            "minimum": 0.5,
+            "maximum": 10
+        },
+        "contourColormapEnabled": {
+            "type": "boolean"
+        },
+        "contourColor": {
+            "type": "string",
+            "description": "TODO: validate color string"
+        },
+        "contourColormap": {
+            "type": "string"
+        },
+        "vectorOverlayPixelAveraging": {
+            "type": "number",
+            "minimum": 0,
+            "maximum": 64,
+            "default": 4
+        },
+        "vectorOverlayFractionalIntensity": {
+            "type": "boolean",
+            "default": false
+        },
+        "vectorOverlayThickness": {
+            "type": "number",
+            "minimum": 0.5,
+            "maximum": 10
+        },
+        "vectorOverlayColormapEnabled": {
+            "type": "boolean"
+        },
+        "vectorOverlayColor": {
+            "type": "string",
+            "description": "TODO: validate color string",
+            "default": "#ffffff"
+        },
+        "vectorOverlayColormap": {
+            "type": "string",
+            "default": "viridis"
+        },
+        "astColor": {
+            "type": "string",
+            "description": "TODO: validate color string"
+        },
+        "astGridVisible": {
+            "type": "boolean"
+        },
+        "astLabelsVisible": {
+            "type": "boolean"
+        },
+        "wcsType": {
+            "enum": ["automatic", "degrees", "sexagesimal"]
+        },
+        "colorbarVisible": {
+            "type": "boolean"
+        },
+        "colorbarInteractive": {
+            "type": "boolean"
+        },
+        "colorbarPosition": {
+            "enum": ["right", "top", "bottom"]
+        },
+        "colorbarWidth": {
+            "type": "integer",
+            "minimum": 1,
+            "maximum": 100
+        },
+        "colorbarTicksDensity": {
+            "type": "number",
+            "minimum": 0.2,
+            "maximum": 20
+        },
+        "colorbarLabelVisible": {
+            "type": "boolean"
+        },
+        "beamVisible": {
+            "type": "boolean"
+        },
+        "beamColor": {
+            "type": "string"
+        },
+        "beamType": {
+            "enum": ["open", "solid"]
+        },
+        "beamWidth": {
+            "type": "number",
+            "minimum": 0.5,
+            "maximum": 10
+        },
+        "regionColor": {
+            "type": "string",
+            "description": "TODO: validate color string"
+        },
+        "regionLineWidth": {
+            "type": "number",
+            "minimum": 0.5,
+            "maximum": 10
+        },
+        "regionDashLength": {
+            "type": "integer",
+            "minimum": 0,
+            "maximum": 50
+        },
+        "regionType": {
+            "enum": [0, 1, 2, 3, 4, 6]
+        },
+        "regionCreationMode": {
+            "enum": ["center", "corner"]
+        },
+        "regionSize": {
+            "type": "number",
+            "minimum": 10,
+            "maximum": 100
+        },
+        "imageCompressionQuality": {
+            "type": "integer",
+            "minimum": 1,
+            "maximum": 32
+        },
+        "animationCompressionQuality": {
+            "type": "integer",
+            "minimum": 1,
+            "maximum": 32
+        },
+        "GPUTileCache": {
+            "type": "integer",
+            "multipleOf": 256,
+            "minimum": 256
+        },
+        "systemTileCache": {
+            "type": "integer",
+            "multipleOf": 256,
+            "minimum": 256
+        },
+        "contourDecimation": {
+            "type": "integer",
+            "minimum": 1,
+            "maximum": 32
+        },
+        "contourCompressionLevel": {
+            "type": "integer",
+            "minimum": 0,
+            "maximum": 19
+        },
+        "contourChunkSize": {
+            "type": "integer",
+            "minimum": 1000
+        },
+        "contourControlMapWidth": {
+            "type": "integer",
+            "multipleOf": 128,
+            "minimum": 128
+        },
+        "streamContoursWhileZooming": {
+            "type": "boolean"
+        },
+        "lowBandwidthMode": {
+            "type": "boolean"
+        },
+        "stopAnimationPlaybackMinutes": {
+            "type": "number",
+            "minimum": 0
+        },
+        "pixelGridVisible": {
+            "type": "boolean"
+        },
+        "pixelGridColor": {
+            "type": "string"
+        },
+        "codeSnippetsEnabled": {
+            "type": "boolean"
+        },
+        "limitOverlayRedraw": {
+            "type": "boolean",
+            "default": true
+        },
+        "cursorInfoVisible": {
+            "enum": ["always", "activeImage", "hideTiled", "never"],
+            "default": "activeImage"
+        },
+        "keepLastUsedFolder": {
+            "type": "boolean",
+            "default": false
+        },
+        "lastUsedFolder": {
+            "type": "string",
+            "default": ""
+        },
+        "imageMultiPanelEnabled": {
+            "type": "boolean",
+            "default": false
+        },
+        "imagePanelMode": {
+            "enum": ["dynamic", "fixed"],
+            "default": "dynamic"
+        },
+        "imagePanelColumns": {
+            "type": "number",
+            "minimum": 1,
+            "default": 2
+        },
+        "imagePanelRows": {
+            "type": "number",
+            "minimum": 1,
+            "default": 2
+        },
+        "statsPanelEnabled": {
+            "type": "boolean",
+            "default": false
+        },
+        "statsPanelMode": {
+            "type": "integer",
+            "minimum": 0,
+            "default": 0
+        },
+        "telemetryUuid": {
+            "type": "string"
+        },
+        "telemetryMode": {
+            "enum": ["none", "minimal", "usage"],
+            "default": "usage"
+        },
+        "telemetryConsentShown": {
+            "type": "boolean",
+            "default": false
+        },
+        "telemetryLogging": {
+            "type": "boolean",
+            "default": false
+        },
+        "fileFilterMode": {
+            "enum": ["content", "extension", "all"],
+            "default": "content"
+        },
+        "pvAxesOrderReverse": {
+            "type": "boolean"
+        },
+        "autoWCSMatching": {
+            "type": "integer",
+            "minimum": 0,
+            "maximum": 7
+        },
+        "colormapHex": {
+            "type": "string"
+        },
+        "colormapHexStart": {
+            "type": "string"
+        },
+        "dynamicLayoutEnable": {
+            "type": "boolean"
+        },
+        "isHighDimPriority": {
+            "type": "boolean"
+        },
+        "dynamicLayout": {
+            "type": "object"
+        },
+        "annotationColor": {
+            "type": "string"
+        },
+        "annotationLineWidth": {
+            "type": "number",
+            "minimum": 0.5,
+            "maximum": 10
+        },
+        "annotationDashLength": {
+            "type": "number",
+            "minimum": 0,
+            "maximum": 50
+        },
+        "pointAnnotationShape": {
+            "type": "integer",
+            "minimum": 0,
+            "maximum": 7
+        },
+        "pointAnnotationWidth": {
+            "type": "number",
+            "minimum": 1,
+            "maximum": 100
+        },
+        "textAnnotationLineWidth": {
+            "type": "number",
+            "minimum": 0.5,
+            "maximum": 10
+        },
+        "pvPreviewCubeSizeLimit": {
+            "type": "number",
+            "minimum": 0.1,
+            "description": "PV preview cube size limit, in GB."
+        },
+        "pvPreviewCubeSizeLimitUnit": {
+            "enum": ["TB", "GB", "MB", "kB", "B"],
+            "description": "This is a deprecated preference."
+        },
+        "logEventList": {
+            "type": "array",
+            "items": {
+                "type": "number"
+            }
+        },
+        "catalogDisplayedColumnSize": {
+            "type": "number",
+            "minimum": 1
+        },
+        "catalogTableSeparatorPosition": {
+            "type": "string"
+        },
+        "checkNewRelease": {
+            "type": "boolean"
+        },
+        "latestRelease": {
+            "type": "string"
+        },
+        "compatibilityAipsBeamSupport": {
+            "type": "boolean"
+        }
+    }
+}

package/schemas/schemacompiler.c

@@ -0,0 +1,200 @@
+/* This program converts a schema file into a header which can be included in 
+the CARTA backend at compile time. The header contains an unsigned char array 
+containing the raw data, an unsigned int containing the array length, and a 
+std::string constructed from these variables.
+
+Based on: https://github.com/mortie/strliteral
+*/
+
+#include <stdlib.h>
+#include <stdio.h>
+#include <stdint.h>
+#include <string.h>
+#include <ctype.h>
+
+static void make_identifier(char *str) {
+    char c;
+    size_t i;
+    for (i = 0; (c = str[i]) != '\0'; ++i) {
+        if (c == '.') {
+            str[i] = '\0';
+            return;
+        } else if (!(
+                (c >= '0' && c <= '9') ||
+                (c >= 'a' && c <= 'z') ||
+                (c >= 'A' && c <= 'Z'))) {
+            str[i] = '_';
+        }
+    }
+}
+
+static void make_headername(char *str) {
+    char c;
+    size_t i;
+    for (i = 0; (c = str[i]) != '\0'; ++i) {
+        if (c >= 'a' && c <= 'z') {
+            str[i] = toupper((unsigned char) c);
+        }
+    }
+}
+
+/* strdup is actually a POSIX thing, not a C thing, so don't use it */
+static char *dupstr(char *str) {
+    size_t len = strlen(str);
+    char *dup = malloc(len + 1);
+    strcpy(dup, str);
+    dup[len] = '\0';
+    return dup;
+}
+
+int main(int argc, char **argv) {
+    int ret = 0;
+    char *inp = "stdin", *outp = "stdout";
+    FILE *inf = stdin, *outf = stdout;
+    char *inbase = NULL;
+    char *ident = NULL;
+    char *headername = NULL;
+    char *buffer = NULL;
+    char *conststr = "const ";
+    int alwaysescape = 0;
+    size_t maxlength = 100;
+
+    if (argc < 3) {
+        fprintf(stderr, "USAGE: schemacompiler <input> <output>\n");
+        goto fail;
+    }
+
+    inp = argv[1];
+    inf = fopen(inp, "rb");
+    if (inf == NULL) {
+        perror(inp);
+        goto fail;
+    }
+
+    (inbase = strrchr(inp, '/')) ? ++inbase : (inbase = inp);
+    ident = dupstr(inbase);
+    make_identifier(ident);
+    
+    headername = dupstr(ident);
+    make_headername(headername);
+
+    outp = argv[2];
+    outf = fopen(outp, "w");
+    if (outf == NULL) {
+        perror(outp);
+        goto fail;
+    }
+    
+    if (fprintf(outf, "#ifndef _%s\n#define _%s\n\nnamespace CARTASCHEMA {\n\n",
+                headername, headername) < 0) {
+        perror("write header");
+        goto fail;
+    }
+
+    if (fprintf(outf, "%sunsigned char %s_char[] =\n\t\"", conststr, ident) < 0) {
+        perror("write char header");
+        goto fail;
+    }
+
+    buffer = malloc(maxlength + 4);
+
+    size_t linechar = 0;
+    size_t length = 0;
+    int c;
+    while ((c = fgetc(inf)) != EOF) {
+        if (alwaysescape) {
+            buffer[linechar++] = '\\';
+            buffer[linechar++] = '0' + ((c & 0700) >> 6);
+            buffer[linechar++] = '0' + ((c & 0070) >> 3);
+            buffer[linechar++] = '0' + ((c & 0007) >> 0);
+        } else if (c >= 32 && c <= 126 && c != '"' && c != '\\' && c != '?' && c != ':' && c != '%') {
+            buffer[linechar++] = (char)c;
+        } else if (c == '\r') {
+            buffer[linechar++] = '\\';
+            buffer[linechar++] = 'r';
+        } else if (c == '\n') {
+            buffer[linechar++] = '\\';
+            buffer[linechar++] = 'n';
+        } else if (c == '\t') {
+            buffer[linechar++] = '\\';
+            buffer[linechar++] = 't';
+        } else if (c == '\"') {
+            buffer[linechar++] = '\\';
+            buffer[linechar++] = '"';
+        } else if (c == '\\') {
+            buffer[linechar++] = '\\';
+            buffer[linechar++] = '\\';
+        } else {
+            buffer[linechar++] = '\\';
+            buffer[linechar++] = '0' + ((c & 0700) >> 6);
+            buffer[linechar++] = '0' + ((c & 0070) >> 3);
+            buffer[linechar++] = '0' + ((c & 0007) >> 0);
+        }
+
+        length += 1;
+
+        if (linechar >= maxlength) {
+            if (fwrite(buffer, 1, linechar, outf) != linechar) {
+                perror("write");
+                goto fail;
+            }
+
+            if (fwrite("\"\n\t\"", 1, 4, outf) != 4) {
+                perror("write");
+                goto fail;
+            }
+
+            linechar = 0;
+        }
+    }
+
+    if (linechar >= 1) {
+        if (fwrite(buffer, 1, linechar, outf) != linechar) {
+            perror("write buffer");
+            goto fail;
+        }
+    }
+
+    if (ferror(inf)) {
+        perror("read");
+        goto fail;
+    }
+
+    if (fprintf(outf, "\";\n\n%sunsigned int %s_len = %u;\n",
+                conststr, ident, (unsigned int)length) < 0) {
+        perror("write char footer");
+        goto fail;
+    }
+
+    if (fprintf(outf, "\ninline std::string_view %s(reinterpret_cast<%schar*>(%s_char), %s_len);\n",
+               ident, conststr, ident, ident) < 0) {
+        perror("write string");
+        goto fail;
+    }
+
+    if (fprintf(outf, "\n} // CARTASCHEMA\n#endif // _%s\n",
+                headername) < 0) {
+        perror("write footer");
+        goto fail;
+    }
+
+    if (fclose(inf) == EOF) {
+        perror("close");
+        goto fail;
+    }
+
+    if (fclose(outf) == EOF) {
+        perror("close");
+        goto fail;
+    }
+
+exit:
+    free(ident);
+    free(headername);
+    free(buffer);
+    return ret;
+
+fail:
+    ret = 1;
+    goto exit;
+}

package/schemas/snippet_schema_1.json

@@ -0,0 +1,45 @@
+{
+    "$schema": "http://json-schema.org/draft-07/schema#",
+    "title": "Snippet",
+    "description": "Schema for CARTA Snippet (Version 1)",
+    "$id": "https://cartavis.org/schemas/snippet_schema_1.json",
+    "type": "object",
+    "required": ["snippetVersion", "frontendVersion", "code"],
+    "properties": {
+        "snippetVersion": {
+            "description": "The version of the snippet contained",
+            "type": "integer",
+            "minimum": 1,
+            "maximum": 1
+        },
+        "frontendVersion": {
+            "description": "The version of the frontend targeted by this snippet",
+            "type": "string"
+        },
+        "code": {
+            "description": "Snippet source code",
+            "type": "string"
+        },
+        "tags": {
+            "description": "List of tags associated with this snippet",
+            "type": "array",
+            "items": {
+                "type": "string"
+            }
+        },
+        "categories": {
+            "description": "List of categories under which to place this snippet",
+            "type": "array",
+            "items": {
+                "type": "string"
+            }
+        },
+        "requires": {
+            "description": "List of snippets (by name) which need to be run before running this snippet",
+            "type": "array",
+            "items": {
+                "type": "string"
+            }
+        }
+    }
+}