// Some of the functions are dependent on the concepts field,

// others are global.

!include once #1035461 // Gazelle 22 Class synonyms Include

sclass G22Utils_Base {

  // event that is triggered every time a file or directory inside the

  // project changes. Starts the fileWatcher automatically when the

  // first listener is added.

  event projectFileChanged(File file);

}

sclass G22Utils > G22Utils_Base is AutoCloseable, TransientObject {

  delegate FunctionDef to GazelleV_LeftArrowScript.

  settable IBackgroundProcesses backgroundProcessesUI;

  settable Enterable module;

  settable G22MasterStuff masterStuff;

  settable Concepts concepts;

  settable G22ProjectActions projectActions;

  gettable G22AutoStarter autoStarter = new(this);

  settable new FunctionTimings<S> functionTimings;

  gettable Map<S, FunctionDef> projectWideFunctionDefs = syncMap();

  gettable Map<S, Class> projectWideClassDefs = syncMap();

  Timestamp recompileDate;

  gettable Set<AutoCloseable> autoClosingResources = syncLinkedHashSet();

  // TODO: set this to a few seconds if your variables are expensive to render

  // settable Seconds variableUpdateIntervalInUI;

  FileWatchService fileWatcher; // general file watch service

  bool projectFileListenerInitiated;

  gettable CombinedStringifier stringifier = new(

    o -> o cast BufferedImage ? "Image (" + o.getWidth() + "*" + o.getHeight() + " px)" : null

  );

  ILASClassLoader lasClassLoader() { ret masterStuff?.lasClassLoader(); }

  settable bool confirmProjectReplacements;

  // add fields here

  ImageSurface stdImageSurface_noToolTip(ImageSurface is default imageSurface()) {

    imageSurface_pixelated(is);

    is.setAutoZoomToDisplay(true).repaintInThread(false);

    is.defaultImageDir = -> dbDir();

    is.specialPurposed = true;

    ret is;

  }

  ImageSurface stdImageSurface(ImageSurface is default imageSurface()) {

    stdImageSurface_noToolTip(is);

    new ImageSurface_PositionToolTip(is);

    ret is;

  }

  L<ImageSurface> stdImageSurfaces(Cl images) {

    ret map stdImageSurface(toBufferedImages(images));

  }

  ImageSurface stdImageSurface(BufferedImage etc img) {

    var is = stdImageSurface();

    is.setImage(img);

    ret is;

  }

  ImageSurface stdImageSurface(File file) {

    var is = stdImageSurface();

    is.setImage(file);

    ret is;

  }

  ImageSurface stdImageSurface(G22GalleryImage img) {

    ret stdImageSurface(img?.path);

  }

  ImageSurface stdImageSurfaceWithSelection(BufferedImage etc img, Rect selection) {

    var is = stdImageSurface(img);

    is.setSelection(selection);

    ret is;

  }

  S stringify(O o) { ret stringifier.toString(o); }

  event bigVariableLoaded(G22Variable var);

  event settingUpParser(GazelleV_LeftArrowScriptParser parser);

  event settingUpScriptIDE(JLeftArrowScriptIDE ide);

  GazelleV_LeftArrowScriptParser leftArrowParser() {

    new GazelleV_LeftArrowScriptParser parser;

    parser.classNameResolver(classNameResolver());

    parser.lasClassLoader(lasClassLoader());

    settingUpParser(parser);

    parser.addClassAlias("Bool", "Boolean");

    parser.addClassAlias("BollingerBands", "LiveBollingerBands");

    parser.addClassAlias("Freq", "Frequency");

    parser.addClassAlias("PriceDigitizer", "PriceDigitizer2");

    parser.addClassAlias("MRUAndAllTimeTop", "MRUAndAllTimeTop_optimized");

    parser.findExternalObject2 = name -> {

      try object projectWideClassDefs.get(name);

      ret parser.findExternalObject2_base(name);

    };

    parser.addFunctionDefs(projectWideFunctionDefs);

    ret parser;

  }

  O leftArrow(S script) {

    ret leftArrowParse(script)!;

  }

  GazelleV_LeftArrowScript.Script leftArrowParse(S script) {

    ret leftArrowParser().parse(script);

  }

  O leftArrowWithVars(S script, O... vars) {

    var parser = leftArrowParser();

    for (int i = 0; i < l(vars); i += 2)

      parser.addVar((S) vars[i], or(_getClass(vars[i+1]), O), true);

    var parsed = parser.parse(script);

    FlexibleVarContext varContext = flexibleVarContextFromParams(vars);

    ret parsed.get(varContext);

  }

  void basicParserTest() {

    var parser = leftArrowParser();

    print(classContainerPrefixes := parser.classContainerPrefixes());

    assertEquals(pair(1, 2), parser.parse("new Pair 1 2")!);

  }

  ifclass JLeftArrowScriptIDE

  JLeftArrowScriptIDE leftArrowIDE aka leftArrowScriptIDE() {

    new JLeftArrowScriptIDE ide;

    ide.g22utils(this);

    ide.scriptTimeout(projectWideScriptTimeout());

    settingUpScriptIDE(ide);

    ret ide;

  }

  endif

  File byteCodePath() {

    ret assertNotNull(getBytecodePathForClass(this));

  }

  simplyCached ClassNameResolver classNameResolver() {

    ret new ClassNameResolver().byteCodePath(byteCodePath()).init();

  }

  File databasesMotherDir() {

    ret masterStuff.databasesMotherDir();

  }

  File dirOfProjectNamed(S name) {

    assertNempty(name);

    ret newFile(databasesMotherDir(), name);

  }

  AutoCloseable enter() { ret module?.enter(); }

  S defaultDBName() { ret "Default"; }

  File lastOpenedDBsFile() {

    ret newFile(databasesMotherDir(), "Last Opened");

  }

  File recentlyOpenedDBsFile() {

    ret newFile(databasesMotherDir(), "Recently Opened");

  }

  File autoUpdateFile() {

    ret newFile(databasesMotherDir(), "Auto-Update");

  }

  bool autoUpdateEnabled() {

    ret fileExists(autoUpdateFile());

  }

  void setAutoUpdate(bool b) {

    createOrRemoveFile(autoUpdateFile(), b);

  }

  LS dbsToOpen() {

    ret loadRecentProjectsFile(lastOpenedDBsFile());

  }

  LS dbNamesRecentlyOpened() {

    ret loadRecentProjectsFile(recentlyOpenedDBsFile());

  }

  void addToRecentDBNames(S dbName, bool hidden) {

    LS list = dbNamesRecentlyOpened();

    LS list2 = cloneList(list);

    removeAll(list2, dbName, "*" + dbName);

    list2.add(0, hidden ? "*" + dbName : dbName);

    truncateList(list2, 100);

    if (!eq(list, list2))

      saveTextFile(recentlyOpenedDBsFile(), lines(list2));

  }

  // returns project names with optional "*" prefix for hidden projects

  LS loadRecentProjectsFile(File file) {

    new LS dbNames;

    for (S name : tlft(loadTextFile(file))) {

      S name2 = dropPrefix("*", name);

      if (fileExists(newFile(databasesMotherDir(), name2)))

        dbNames.add(name);

    }

    if (empty(dbNames)) dbNames.add(defaultDBName());

    ret dbNames;

  }

  void setOpenDBs(Cl<? extends IG22LoadedDB> dbs) {

    new LS dbNames;

    for (db : dbs) {

      var dbDir = conceptsDir(db.concepts());

      if (sameFile(databasesMotherDir(), dirOfFile(dbDir)))

        dbNames.add((db.hidden() ? "*" : "") + fileName(dbDir));

    }

    saveTextFile(lastOpenedDBsFile(), lines(dbNames));

  }

  ifclass SimpleCRUD_v2

  <A extends G22LeftArrowScript> void setupScriptCRUD(SimpleCRUD_v2<A> crud, bool allowRunOnProjectOpen default false) {

    crud.useNewChangeHandler(true);

    crud.editableFieldsForItem = x -> llNonNulls("description",

      allowRunOnProjectOpen ? "runOnProjectOpen" : null,

      allowRunOnProjectOpen ? "runOrder" : null);

    //G22LeftArrowScript.f_description().getName());

    crud.multiLineField("text");

    crud.multiLineField("editingText");

    crud.makeTextArea = text -> jMinHeight(200, crud.makeTextArea_base(text));

    crud.humanizeFieldNames = false;

    crud.iconButtons(true);

    crud.itemToMap_inner2 = c -> scriptToMap(c, allowRunOnProjectOpen);

    crud.dontDuplicateFields = litset("runOnProjectOpen", /*"runOrder",*/ "runCount", "lastResultByMode");

  }

  endif

  MapSO scriptToMap(G22LeftArrowScript c, bool allowRunOnProjectOpen default false) {  

    ret litorderedmap(

      "Description" := c.description(),

      "Status" := renderScriptStatus(c),

      "LoC" := renderScriptLoC(c),

      "Import note" := c.importNote,

      "Run on project open" := c.renderRunOnProjectOpenStatus());

  }

  S renderScriptStatus(G22LeftArrowScript c) {

    ret or2_rev("Empty", joinNemptiesWithSpacedPlus(

      c.isClearForAutoRun() ? "Clear for auto-run" : null,

      c.isSavedDistinctFromAutoRunVersion() ? "Saved" /*"Saved (not cleared)"*/ : null,

      c.isEditing() ? "Editing" : null

    ));

  }

  S renderScriptLoC(G22LeftArrowScript c) {

    ret n2(intMax(mapLL linesOfCode_javaTok(

      c.editingText,

      c.text,

      c.codeForAutoRun())));

  }

  // e.g. for an image file

  L<G22Label> labelsForFile(File file) {

    if (file == null) null;

    File labelsFile = appendToFileName(file, ".labels");

    LS labels = tlft(loadTextFile(labelsFile));

    ret map getLabel(labels);

  }

  File labelsFile(File file) {  

    if (file == null) null;

    ret appendToFileName(file, ".labels");

  }

  void setLabelsForFile(File file, L<G22Label> labels) {

    LS list = map(labels, label -> label.name);

    File f = labelsFile(file);

    saveTextFile(f, lines(list));

    print("Saved " + nLabels(list) + " (" + joinWithComma(list) + ") to " + f);

  }

  G22Label getLabel(S name) {

    if (empty(name)) null;

    if (containsNewLine(name)) fail("No newlines in label names allowed: " + name);

    ret uniqCI(concepts, G22Label, +name);

  }

  File dbDir aka projectDir() { ret conceptsDir(concepts); }

  File fileInDbDir aka projectFile aka projectDir(S name) { ret newFile(dbDir(), name); }

  record GazelleDB(S name, File dir) {

    S name() { ret name; }

    File dir() { ret dir; }

    bool loaded() {

      ret loadedDB() != null;

    }

    simplyCached IG22LoadedDB loadedDB() {

      ret masterStuff.getLoadedDBForConceptDir(dir);

    }

    File conceptsFile() { ret conceptsFileIn(dir); }

  }

  L<GazelleDB> gazelleDBs() {

    new L<GazelleDB> dbs;

    for (File dir : listDirsContainingFileNamed(databasesMotherDir(),

      "concepts.structure.gz"))

      dbs.add(new GazelleDB(fileName(dir), dir));

    ret dbs;

  }

  ItIt<Concepts> peekAllProjectsConcepts() {

    var classFinder = masterStuff.makeClassFinder();

    ret mapI_pcall(gazelleDBs(), db -> {

      var cc = newConceptsWithClassFinder(db.conceptsFile(), classFinder);

      cc.loadFromDisk();

      ret cc;

    });

  }

  ifclass RSyntaxTextAreaWithSearch

    RSyntaxTextAreaWithSearch newSyntaxTextArea(IF1<JComponent> wrapStatusLabel default (IF1) null) {

      RSyntaxTextAreaWithSearch ta = new(wrapStatusLabel);

      ta.textArea().setHighlightCurrentLine(false);

      ta.menuLessOperation();

      ret ta;

    }

    RSyntaxTextAreaWithSearch newSyntaxTextArea(S text) {

      var ta = newSyntaxTextArea();

      ta.setText(text);

      ret ta;

    }

  endif

  File projectStoryTextFile() { ret newFile(dbDir(), "story.txt"); }

  S projectName() { ret fileName(dbDir()); }

  close {

    autoStarter.close();

    closeAndClear(autoClosingResources);

    dispose fileWatcher;

  }

  // solve shadowing problem in LAS

  void close(AutoCloseable c) {

    main close(c);

  }

  // project vars

  G22Variable findProjectVar(S name) {

    ret conceptWhereCI(concepts, G22Variable, +name);

  }

  Cl<S> projectVarNames() {

    ret collect name(list(concepts, G22Variable));

  }

  O getProjectVar(S name) {

    G22Variable var = findProjectVar(name);

    ret var?.value();

  }

  // If it's a big variable, load it just now and then forget

  // it again

  O getBigProjectVarOnce(S name) {

    G22Variable var = findProjectVar(name);

    ret var?.getOnce();

  }

  // fail if var doesn't exist or value is null

  O getMandatoryProjectVar(S name) {

    ret assertNotNull(name, getProjectVar(name));

  }

  O getOrSetTransientProjectVar(S name, IF0 f) {

    try object getProjectVar(name);

    ret setTransientProjectVarAndReturn(name, f!);

  }

  O getProjectVarOrCallScript(S name, long scriptID) {

    try object getProjectVar(name);

    ret callScript(scriptID);

  }

  O getProjectVarSetByScript(S name, long scriptID) {

    try object getProjectVar(name);

    callScript(scriptID);

    ret getProjectVar(name);

  }

  // gets first non-null value of project variable named "name"

  // in any open project (order not defined)

  O getProjectVarFromAnyProject(S name) {

    for (project : masterStuff().openProjects())

      try object project.g22utils().getProjectVar(name);

    null;

  }

  // gets all non-null values from project variable named "name"

  // in any open project

  L getProjectVarFromAllProjects aka getVarFromAnyProject(S name) {

    ret nonNulls(masterStuff().openProjects(),

      project -> project.g22utils().getProjectVar(name));

  }

  // Creates the variable if it's not there, otherwise

  // returns existing variable.

  G22Variable projectVarConcept(S name) {

    ret optimizedUniqCI(concepts, G22Variable, +name);

  }

  O waitForProjectVar(double timeoutSeconds default infinity(), S name) {

    G22Variable var = projectVarConcept(name);

    ret waitForCalculatedValueUsingChangeListener(timeoutSeconds, -> var.value(), var);

  }

  void setBigProjectVar(bool persistent, S name, O value) {

    if (persistent)

      setBigProjectVar(name, value);

    else

      setTransientProjectVar(name, value);

  }

  G22Variable setProjectVar(bool persistent, S name, O value) {

    G22Variable var = projectVarConcept(name);

    // defensive order

    if (!persistent) var.persistent(persistent);

    var.value(value);

    if (persistent) var.persistent(persistent);

    ret var;

  }

  // uncache a big project variable. Does not change the value

  void unloadProjectVar(S name) {

    var var = findProjectVar(name);

    var?.unload();

  }

  <A> A setBigProjectVar(S name, A value) {

    setPersistentProjectVar(name, value);

    G22Variable var = projectVarConcept(name);

    var.makeBig();

    ret value;

  }

  O getCachedProjectVar(S name) {

    var var = findProjectVar(name);

    ret var?.cachedValue();

  }

  bool isBigProjectVar(S name) {

    var v = findProjectVar(name);

    ret v != null && v.big();

  }

  <A> A setPersistentProjectVar(S name, A value) {

    setProjectVar(true, name, value);

    ret value;

  }

  G22Variable setTransientProjectVar(S name, O value) {

    ret setProjectVar(false, name, value);

  }

  <A> A setTransientProjectVarAndReturn(S name, A value) {

    setProjectVar(false, name, value);

    ret value;

  }

  void setAutoClosingProjectVar(S name, O value) {

    setTransientProjectVar(name, value).autoClose(true);

  }

  void clearProjectVar(S name) {

    var v = findProjectVar(name);

    v?.clear();

  }

  void deleteProjectVar(S name) {

    deleteConcept(findProjectVar(name));

  }

  // Note: unsynced. Wild west baby!

  O getOrCreateProjectVar aka getOrCreateTransientProjectVar(S name, IF0 maker) {

    ret getOrCreateProjectVar(projectVarConcept(name), maker);

  }

  O getOrCreatePersistentProjectVar(S name, IF0 maker) {

    var var = projectVarConcept(name);

    O value = getOrCreateProjectVar(var, maker);

    var.persistent(true);

    ret value;

  }

  O getOrCreateBigProjectVar(S name, IF0 maker) {

    var var = projectVarConcept(name);

    O value = getOrCreateProjectVar(var, maker);

    var.makeBig();

    ret value;

  }

  O getOrCreateAutoClosingProjectVar(S name, IF0 maker) {

    var var = projectVarConcept(name);

    O value = getOrCreateProjectVar(var, maker);

    var.autoClose(true);

    ret value;

  }

  G22Variable getOrCreateAutoClosingProjectVar_returnVar(S name, IF0 maker) {

    var var = projectVarConcept(name);

    getOrCreateProjectVar(var, maker);

    ret var.autoClose(true);

  }

  bool projectVarIsNotNull(S name) {

    var var = findProjectVar(name);

    ret var != null && var.has();

  }

  O getOrCreateProjectVar(G22Variable var, IF0 maker) {

    if (!var.has()) {

      O value = maker!;

      if (value != null)

        var.setValueIfNull(value);

    }

    ret var!;

  }

  // variable is made persistent

  IVarWithNotify liveProjectVar(S name, O defaultValue default null) {

    G22Variable var = projectVarConcept(name);

    var.persistent(true);

    var.setValueIfNull(defaultValue);

    ret var.varValue();

  }

  IVarWithNotify liveTransientProjectVar(S name, O defaultValue default null) {

    G22Variable var = projectVarConcept(name);

    var.persistent(false);

    var.setValueIfNull(defaultValue);

    ret var.varValue();

  }

  void replaceCloseableProjectVar(S name, IF0<? extends AutoCloseable> calc) {

    O value = getProjectVar(name);

    if (value cast AutoCloseable) {

      main close(value);

      deleteProjectVar(name);

    }

    setTransientProjectVar(name, calc?!);

  }

  // notify of internal changes in the variable

  // even though the value pointer may have stayed the same.

  void projectVarChanged aka saveProjectVar(S name) {

    var var = findProjectVar(name);

    var?.changeInsideOfValue();

  }

  // search by value

  Cl<G22Variable> projectVarChanged aka saveProjectVar(O value) {

    var vars = conceptsWhere(concepts, G22Variable, +value);

    for (var : vars)

      var.change();

    ret vars;

  }

  // timeouts

  double defaultScriptTimeout() { ret 10.0; }

  double projectWideScriptTimeout() {

    ret or(toDoubleOrNull(getProjectVar("!Script Timeout")),

      defaultScriptTimeout());

  }

  // getting objects

  G22Analyzer getAnalyzer(long id) {

    var a = getConcept(concepts, G22Analyzer, id);

    if (a == null) fail("Analyzer not found: " + id);

    ret a;

  }

  G22LeftArrowScript getScript(long id) {

    var a = getConcept(concepts, G22LeftArrowScript, id);

    if (a == null) fail("Script not found: " + id);

    ret a;

  }

  S textOfScript(long id) {

    ret getScript(id).latestText();

  }

  // calling scripts

  // This is meant to be called from within another script.

  // No timeout (timeout is handled by calling script)

  // Uses "safest" version available (auto-run or saved)

  O callScript(long id) {

    var script = getScript(id);

    ret script.evaluateWithoutTimeout();

  }

  // Like callScript, but only uses auto-run version

  O callAutoRunnableScript(long id) {

    var script = getScript(id);

    ret script.evaluateAutoRunWithoutTimeout();

  }

  O callScriptWithParams(long id, O... params) {

    ret callScriptWithParams(getScript(id), params);

  }

  O callScriptWithParams(G22LeftArrowScript script, O... params) {

    var compiledScript = script.compileSaved()!;

    ret compiledScript.get(flexibleVarContextFromParams(params));

  }

  // no timeout by default

  double defaultTimeout() { ret infinity(); }

  // evaluate

  // -with timeout

  // -registered in background processes

  // -with module entered

  <A> A evalRegisteredCode(double timeoutSeconds default defaultTimeout(), S processName, IF0<A> code) {

    if (code == null) null;

    ret evalWithTimeoutOrTypedException(timeoutSeconds, ->

      useThisThreadAsBackgroundProcess(processName, code)

    );

  }

  Thread startAsRegisteredThread(S processName default str_shorten(r), Runnable r) {

    if (r == null) null;

    ret startThread(processName, -> useThisThreadAsBackgroundProcess(processName, toIF0(r)));

  }

  <A> A useThisThreadAsBackgroundProcess(S processName, IF0<A> code) {

    temp enter();

    temp var process = backgroundProcessesUI.tempAdd(processName);

    Thread myThread = currentThread();

    process.setInterruptAction(r { cancelThread(myThread) });

    ret code!;

  }

  virtual GazelleHost host() {

    temp enter();

    ret dm_os();

  }

  <A> A timeFunction(S name, IF0<A> f) {

    ret functionTimings.get(name, f);

  }

  bool isConceptsDir(File dir) {

    ret isSameFile(conceptsDir(concepts), dir);

  }

  synchronized FileWatchService fileWatcher() {

    ret fileWatcher if null = new FileWatchService;

  }

  synchronized selfType onProjectFileChanged(IVF1<File> listener) {

    super.onProjectFileChanged(listener);

    if (!projectFileListenerInitiated) {

      set projectFileListenerInitiated;

      fileWatcher().addRecursiveListener(dbDir(), l1 projectFileChanged);

    }

    this;

  }

  simplyCached G22ProjectInfo projectInfo() {

    ret optimizedUniq(concepts, G22ProjectInfo);

  }

  RunnablesReferenceQueue runnablesReferenceQueue() {

    ret masterStuff.runnablesReferenceQueue();

  }

  EphemeralObjectIDs ephemeralObjectIDs() {

    ret masterStuff.ephemeralObjectIDs();

  }

  // get a remember ephemeral object by ID

  O eph(long id) { ret ephemeralObjectIDs().get(id); }

  void openInBrowser(S url) {

    main openPlatformBrowser(url);

    /*if (Desktop.getDesktop().isSupported(Desktop.Action.BROWSE))

      main openInBrowser(url);

    else {

      S cmd;

      if (projectInfo().useFirefox() && isOnPATH("firefox")) 

        cmd = "firefox";

      else {

        cmd = chromeCmd();

        if (isRoot())

          cmd += " -no-sandbox";

      }

      cmd += " " + platformQuote(url);

      nohup(cmd);

    }*/

  }

  S compilationDate() {

    ret or2(compilationDateFromClassPath(this), "unknown");

  }

  // Global ID for project

  S projectID() {

    ret projectInfo().projectID();

  }

  IG22LoadedDB getLoadedDB() {

    ret masterStuff.getLoadedDB(concepts);

  }

  ConceptsComboBox<GalleryImage> galleryImagesComboBox() {

    ret swing(->

      new ConceptsComboBox<GalleryImage>(concepts, GalleryImage));

  }

  IBackgroundProcess tempAddBackgroundProcess(S name) {

    ret backgroundProcessesUI?.tempAdd(name);

  }

  IF1<S, Class> classFinder() {

    var master = masterStuff.makeClassFinder();

    ret name -> {

      try object projectWideClassDefs().get(dropPrefix("main$", name));

      ret master.get(name);

    };

  }

  O restructure(O o) {

    ret unstructure(structure(o), false, concepts.classFinder);

  }

  G22ProjectActions project() { ret projectActions(); }

  bool openPathInProject(S path) {

    ret projectActions().openPathInProject(path);

  }

  void openUIURL aka showUIURL aka goToURIURL(S url) {

    projectActions().openUIURL(url);

  }

  BufferedImage loadProjectImage(S fileName) {

    ret loadImage2(projectFile(fileName));

  }

  IG22LoadedDB openDB(S name, bool hidden default false) {

    ret masterStuff().openDB(name, hidden);

  }

  // Hides project if it is opened by this call

  G22Utils getProject(S name) {

    ret openDB(name, true).g22utils();

  }

  G22Utils getProjectIfExists(S name) {

    ret !masterStuff().projectExists(name) ? null

      : getProject(name);

  }

  G22Utils getProjectIfOpen(S name) {

    var db = first(openProjects(), p -> eqic(p.g22utils().projectName(), name));

    ret db?.g22utils();

  }

  G22JavaObjectVisualizer visualizeObject aka visualizeJavaObject(O o) {

    ret new G22JavaObjectVisualizer(this, o);

  }

  G22JavaObjectVisualizer visualizeObjectWithoutType aka visualizeJavaObjectWithoutType(O o) {

    ret visualizeObject(o).withTypeAndTime(false);

  }

  swappable G22VariablesPanel makeVariablesPanel() {

    ret new G22VariablesPanel().g22utils(this);

  }

  swappable JComponent jGazelleLogo() {

    ret main jGazelleLogo();

  }

  bool devMode() {

    ret masterStuff().devMode();

  }

  // specialize list() for our concepts

  <A extends Concept> L<A> nuLike list(Class<A> type, Concepts cc default concepts()) {

    ret main list(cc, type);

  }

  <A extends Concept> L<A> list(Concepts concepts, Class<A> type) {

    ret main list(type, concepts);

  }

  G22GalleryImage galleryImageForMD5(S md5) {

    ret firstThat(list(concepts, G22GalleryImage),

      img -> cic(fileName(img.path), md5));

  }

  // add the right kind of scrollpane to an image surface

  JComponent wrapImageSurface(ImageSurface is) {

    ret is == null ?: jscroll_centered_borderless(is);

  }

  JComponent wrap(O o) {

    var c = main wrap(o);

    if (c cast ImageSurface)

      ret wrapImageSurface(c);

    ret c;

  }

  swappable S byUser() {

    ret "";

  }

  Cl<? extends IG22LoadedDB> getLoadedDBs aka openProjects() {

    ret masterStuff().openProjects();

  }

  <A extends Concept> L<A> nuLike listInOpenProjects(Class<A> type) {

    ret concatMap(openProjects(), db -> db.g22utils().list(type));

  }

  transient simplyCached PicturesByMD5 picturesByMD5() {

    ret new PicturesByMD5(projectFile("Images"))

      .extension(".qoi");

  }

  JButton reloadButton(S toolTip, Runnable action) {

    ret jimageButton(#1101440, toolTip, action);

  }

  void registerConcept(Concept c) {

    main registerConcept(concepts, c);

  }

  void registerConcept(Concepts cc, Concept c) {

    main registerConcept(cc, c);

  }

  void addingAdditionalAutoCompletes(LeftArrowScriptAutoCompleter autoCompleter) {

    // projectVar magic

    S token = autoCompleter.prevToken();

    if (isIdentifier(token) && cic(token, "ProjectVar"))

      autoCompleter.addToSearcher(quoteAll(projectVarNames()));

    // project-wide class defs

    autoCompleter.addToSearcher(keys(projectWideClassDefs()));

  }

  meta-for Lib as S, File {  

    bool addLibrary(Lib library) {

      if (!main addLibrary(library)) false;

      print("Loaded library: " + library);

      masterStuff().newClassesDefined();

      true;

    }

  }

  // add an auto-closing resource to the project

  <A extends AutoCloseable> WrappedCloseable<A> addResource(A resource) {

    if (resource == null) null; 

    autoClosingResources.add(resource);

    ret new WrappedCloseable<A>(resource) {

      @Override void beforeClose {

        autoClosingResources.remove(resource);

      }

    };

  }

  // TODO: Improve LAS to not need this anymore  

  O callFunctionFromScript(int scriptID, S functionName, O... args) {

    ret callFunctionFromScript((long) scriptID, functionName, args);

  }

  // This even returns the version being edited - very aggressive

  O callLatestFunctionFromScript(int scriptID, S functionName, O... args) {

    var function = getScript(scriptID).latestCompileResult().get().getFunction(functionName);

    ret function.callFromOutside(args);

  }

  // Uses "saved" version, not "cleared for auto-run"

  O callSavedFunctionFromScript(int scriptID, S functionName, O... args) {

    var function = getScript(scriptID).compileSaved().get().getFunction(functionName);

    ret function.callFromOutside(args);

  }

  O callFunctionFromScript(long scriptID, S functionName, O... args) {

    var function = getScript(scriptID).safestCompileResult().get().getFunction(functionName);

    ret function.callFromOutside(args);

  }

  O callProjectFunction(S functionName, O... args) {

    var function = projectWideFunctionDefs.get(functionName);

    if (function == null) fail("Function " + functionName + " not found in project " + projectName());

    ret function.callFromOutside(args);

  }

  JComponent visualizeAutoRunnableScript(long scriptID) {

    ret visualizeAutoRunnableScript(getScript(scriptID));

  }

  JComponent visualizeAutoRunnableScript(G22LeftArrowScript script) {

    if (script == null) null;

    if (!script.isClearForAutoRun())

      ret jcenteredlabel("Script not clear for auto-run");

    try {

      O result = script.evaluateAutoRunWithoutTimeout();

      var objVisualizer = G22JavaObjectVisualizer(this, result).withType(false);

      ret objVisualizer.visualize();

    } catch print e {

      ret jErrorView(e);

    }

  }

  JComponent visualizeSavedScript(long scriptID) {

    ret visualizeSavedScript(getScript(scriptID));

  }

  JComponent visualizeSavedScript(G22LeftArrowScript script) {

    if (script == null) null;

    if (!script.isSaved())

      ret jcenteredlabel("Script not saved");

    try {

      O result = script.evaluateWithoutTimeout();

      var objVisualizer = G22JavaObjectVisualizer(this, result).withType(false);

      ret objVisualizer.visualize();

    } catch print e {

      ret jErrorView(e);

    }

  }

  // projectName must match base dir in zip

  void importProjectFromZip(File zipFile, S baseDirInZip, S projectName) {

    File dir = dirOfProjectNamed(projectName);

    if (isConceptsDir(dir)) {

      if (eqic(projectName(), "Default"))

        ret with infoMessage("Sorry dude");

      IG22LoadedDB defaultDB = masterStuff().getLoadedDBForConceptDir(dirOfProjectNamed("Default"));

      IG22LoadedDB preloadedDefaultDB = defaultDB;

      if (defaultDB == null)

        defaultDB = openDB("Default");

      project().closeProject();

      defaultDB.g22utils().importProjectFromZip(zipFile, baseDirInZip, projectName);

      // Close default project again if only opened for this purpose

      if (preloadedDefaultDB == null)

        defaultDB.projectActions().closeProject();

      ret;

    }

    if (!directoryIsEmpty(dir)) {

      if (confirmProjectReplacements && !swingConfirm("Archive and overwrite existing project " + projectName + "?"))

        ret;

      File archiveDir = javaxBackupDir("Gazelle/" + projectName + "-" + computerID() + "-" + ymdMinusHMS());

      moveFile(dir, archiveDir);

      infoMessage("Archived project to: " + archiveDir);

    }

    zip2dir(zipFile, empty(baseDirInZip) ? dir : dir.getParentFile());

    infoBox("Imported project " + projectName);

    masterStuff().openDB(projectName);

  }

  void importProjectFromZip(File zipFile) {

    S baseDir = baseDirInZip(zipFile);

    S projectName = takeFirst(baseDir, smartIndexOf(baseDir, '/'));

    if (empty(projectName)) {

      ret with inputText("Please enter name for imported project",

        name -> {

          if (!validFileName(name)) {

            infoBox("Invalid name, use simpler characters");

            importProjectFromZip(zipFile);

            ret;

          }

          importProjectFromZip(zipFile, "", name);

        });

    }

    assertValidFileName(projectName);

    importProjectFromZip(zipFile, baseDir, projectName);

  }

  Class export(Class c) {

    if (c != null) {

      projectWideClassDefs.put(dropHashFromClassName(shortClassName(c)), c);

      newFunctionsDefined();

    }

    ret c;

  }

  FunctionDef exportFunction aka export(FunctionDef def) {

    ret def == null ?: exportFunction(def.name, def);

  }

  FunctionDef exportFunction aka export(S name, FunctionDef def) {

    projectWideFunctionDefs.put(name, def);

    //print("Defined function " + name);

    // Make sure all compiled scripts are forgotten

    newFunctionsDefined();

    ret def;

  }

  // return previous definition

  FunctionDef unexportFunction aka unexport(S name) {

    FunctionDef f = projectWideFunctionDefs.remove(name);

    if (f != null) {

      print("Undefined function " + name);

      newFunctionsDefined();

    }

    ret f;

  }

  void newFunctionsDefined {

    masterStuff().newClassesDefined();

    recompileDate = tsNow();

  }

  bool shouldRecompile(LASCompileResult cr) {  

    ret recompileDate != null && cr.compilationStart() != null

      && cr.compilationStart().compareTo(recompileDate) < 0;

  }

  bool compileResultValid(LASCompileResult cr, S code) {

    ret cr != null && eq(cr.script, code) && !shouldRecompile(cr);

  }

  toString {

    ret "G22Utils(" + quote(projectName()) + ")";

  }

  void editScript(G22LeftArrowScript script) {

    projectActions().editScript(script);

  }

  JButton editButton(S toolTip, Runnable action) {

    ret jimageButtonScaledToWidth(16, #1103068, toolTip, action);

  }

  JButton editScriptButton(G22LeftArrowScript script) {

    ret editButton("Edit script",

      -> projectActions().editScript(script));

  }

  G22ScriptView savedScriptView(long scriptID) {

    ret new G22ScriptView(getScript(scriptID)).mustBeAutoRunnable(false);

  }

  G22ScriptView scriptView(long scriptID) {

    ret new G22ScriptView(getScript(scriptID));

  }

  File gazelleJar() {

    ret getBytecodePathForClass(this);

  }

  L<PersistableThrowable> projectErrors() {

    ret projectActions().projectErrors();

  }

  JComponent jErrorView(Throwable e) {

    var view = main jErrorView(e);

    var scriptErrors = instancesOf(GazelleV_LeftArrowScript.ScriptError.class, allCausesIncludingSelf(e));

    var sources = mapNotNulls(scriptErrors, -> .tokenRangeWithSrc());

    if (empty(sources)) ret view;

    sources = uniquifySources(sources);

    ret centerAndEastWithMargin(view,

      jline(map(sources, src ->

        jThreadedButton(

          str_shorten(src, 40),

          -> projectActions().goToSource(src)))));

  }

  L<TokenRangeWithSrc> uniquifySources(L<TokenRangeWithSrc> sources) {

    ret uniquifyWith(sources, src -> pair(src.sourceInfo, src.renderRange()));

  }

  structure_Data makeStructureData() {

    ret concepts().makeStructureData();

  }

  S g22struct(O o) {

    ret struct(o, makeStructureData());

  }

  O g22unstruct(S struct) {

    ret unstructure(struct, classFinder());

  }

  O stem() {

    ret dm_stem(module());

  }

  void reloadProject {

    masterStuff().reopenDB(getLoadedDB());

  }

  File downloadProjectFromGazAI(GazAICredentials credentials, S projectName) ctex {

    var cred = credentials.asParams();

    var params = cloneMap(cred);

    params.put("asZip", 1);

    var url = "https://" + gazAIHost() + "/dl-authed/gazelle/" + spaceToPercent20(projectName) + "/";

    var conn = urlConnection(url);

    var file = javaxBackupDir(concat(projectName + " Downloaded ", ymdMinusHMS(), ".zip"));

    doPostBinaryToFile(makePostData(params), conn, file);

    if (!isZip(file))

      fail("Download failed, not authenticated for " + gazAIHost() + "?");

    fileSavedInfoBox(file);

    ret file;

  }

  public void waitForAutoStart() {

    autoStarter().waitUntilDone();

  }

  void adaptTextEditor(JSyntaxTextFileEditor editor) {

    editor.adaptSyntaxTextArea = textArea ->

      g22_adaptSyntaxTextAreaForHashRefs(textArea, this);

  }

  Window projectWindow() {

    ret (Window) call(stem(), "window");

  }

} // end of G22Utils