Warning: session_start(): open(/var/lib/php/sessions/sess_9t7d60vvvtvl9ht965sp19vq5u, O_RDWR) failed: No space left on device (28) in /var/www/tb-usercake/models/config.php on line 51
Warning: session_start(): Failed to read session data: files (path: /var/lib/php/sessions) in /var/www/tb-usercake/models/config.php on line 51
import java.util.*;
import java.util.zip.*;
import java.util.List;
import java.util.regex.*;
import java.util.concurrent.*;
import java.util.concurrent.atomic.*;
import java.util.concurrent.locks.*;
import java.util.function.*;
import javax.swing.*;
import javax.swing.event.*;
import javax.swing.text.*;
import javax.swing.table.*;
import java.io.*;
import java.net.*;
import java.lang.reflect.*;
import java.lang.ref.*;
import java.lang.management.*;
import java.security.*;
import java.security.spec.*;
import java.awt.*;
import java.awt.event.*;
import java.awt.image.*;
import java.awt.geom.*;
import javax.imageio.*;
import java.math.*;
import java.time.Duration;
import java.lang.invoke.VarHandle;
import java.lang.invoke.MethodHandles;
import static x30_pkg.x30_util.DynamicObject;
import java.nio.file.*;
import static java.nio.file.StandardWatchEventKinds.*;
import org.fife.ui.autocomplete.*;
import org.fife.rsta.ui.CollapsibleSectionPanel;
import org.fife.rsta.ui.GoToDialog;
import org.fife.rsta.ui.SizeGripIcon;
import org.fife.rsta.ui.search.FindDialog;
import org.fife.rsta.ui.search.ReplaceDialog;
import org.fife.rsta.ui.search.ReplaceToolBar;
import org.fife.rsta.ui.search.SearchEvent;
import org.fife.rsta.ui.search.SearchListener;
import org.fife.rsta.ui.search.FindToolBar;
import org.fife.ui.rsyntaxtextarea.ErrorStrip;
import org.fife.ui.rsyntaxtextarea.RSyntaxTextArea;
import org.fife.ui.rsyntaxtextarea.SyntaxConstants;
import org.fife.ui.rtextarea.RTextScrollPane;
import org.fife.ui.rtextarea.SearchContext;
import org.fife.ui.rtextarea.SearchEngine;
import org.fife.ui.rtextarea.SearchResult;
import org.fife.ui.rsyntaxtextarea.RSyntaxDocument;
import org.fife.ui.rsyntaxtextarea.SyntaxScheme;
import org.apache.bcel.classfile.ClassParser;
import org.apache.bcel.classfile.JavaClass;
import org.apache.bcel.Const;
import org.apache.bcel.generic.*;
import java.lang.reflect.Type;
import java.text.*;
import java.util.jar.*;
import java.awt.datatransfer.*;
import java.awt.dnd.*;
import javax.swing.border.*;
import javax.swing.border.TitledBorder;
import java.nio.file.Path;
import javax.swing.event.AncestorListener;
import javax.swing.event.AncestorEvent;
import javax.swing.Timer;
import org.fife.ui.rsyntaxtextarea.*;
import java.awt.datatransfer.StringSelection;
import java.awt.datatransfer.Transferable;
import java.awt.datatransfer.DataFlavor;
import java.awt.geom.*;
import javax.swing.undo.UndoManager;
import java.text.SimpleDateFormat;
import java.text.NumberFormat;
import javax.imageio.metadata.*;
import javax.imageio.stream.*;
import java.nio.charset.Charset;
import java.util.TimeZone;
import java.awt.datatransfer.UnsupportedFlavorException;
import javax.swing.Icon;
public class main {
public interface G22ProjectActions {
public void openObjectInProject(long id);
public boolean openPathInProject(String path);
public void editProjectStory();
public void editScripts();
public void editScript(G22LeftArrowScript script);
public void openUIURL(String url);
public IVarWithNotify varShowCasedScript();
public G22DatabasesPanel databasesPanel();
public void closeProject();
public G22Utils g22utils();
public DynamicVStack topStack();
public void saveAsNewScript(String text);
public Set projectLibs();
public G22SelfTests selfTests();
public List projectErrors();
public void goToSource(TokenRangeWithSrc src);
}
public interface IVarWithNotify extends IVar, IF0WithChangeListeners {
default public IVarWithNotify onChange(IVF1 r) {
if (r == null)
return this;
onChange(() -> r.get(get()));
return this;
}
default public IVarWithNotify onChangeAndNow(IVF1 r) {
if (r == null)
return this;
onChangeAndNow(() -> r.get(get()));
return this;
}
}
static public class G22SelfTests implements IFieldsToList {
public G22Utils g22utils;
public G22SelfTests() {
}
public G22SelfTests(G22Utils g22utils) {
this.g22utils = g22utils;
}
public String toString() {
return shortClassName_dropNumberPrefix(this) + "(" + g22utils + ")";
}
public Object[] _fieldsToList() {
return new Object[] { g22utils };
}
volatile public boolean started = false;
volatile public OKOrError result;
public void run() {
try {
started = true;
result = okOrError(() -> runImpl());
String msg = "Self Tests " + status();
if (result.isOK())
print(msg);
else
infoBox(msg);
} catch (Exception __e) {
throw rethrow(__e);
}
}
public void runImpl() {
G22LAScriptIDE.selfTest(g22utils);
}
public String status() {
return !started ? "Not started" : result == null ? "Running" : result.isOK() ? "OK" : "Failed";
}
}
static public class TokenRangeWithSrc extends TokenRange {
public List tok;
final public TokenRangeWithSrc setSourceInfo(Object sourceInfo) {
return sourceInfo(sourceInfo);
}
public TokenRangeWithSrc sourceInfo(Object sourceInfo) {
this.sourceInfo = sourceInfo;
return this;
}
final public Object getSourceInfo() {
return sourceInfo();
}
public Object sourceInfo() {
return sourceInfo;
}
public Object sourceInfo;
public TokenRangeWithSrc() {
}
public TokenRangeWithSrc(List tok, int start) {
this.start = start;
end = start;
}
public TokenRangeWithSrc(List tok, int start, int end) {
this.end = end;
this.start = start;
}
public TokenRangeWithSrc(ListAndIndex startPtr, ListAndIndex endPtr) {
assertNotNull("startPtr", startPtr);
assertNotNull("endPtr", endPtr);
assertSame(tok = startPtr.list(), endPtr.list());
start = startPtr.idx();
end = endPtr.idx();
}
public ListAndIndex startPtr() {
return new ListAndIndex(tok, start);
}
public ListAndIndex endPtr() {
return new ListAndIndex(tok, end);
}
public LineAndColumn startLineAndCol() {
return tokenToLineAndColumn(startPtr());
}
public LineAndColumn endLineAndCol() {
return tokenToLineAndColumn(endPtr());
}
public String text() {
return joinSubList(tok, start, end);
}
public String renderRange() {
return renderLineAndColumnRange(startLineAndCol(), endLineAndCol());
}
public String toString() {
return spaceCombine(sourceInfo(), renderRange());
}
public String fullSourceText() {
return join(tok);
}
}
static public class G22DatabasesPanel implements IFieldsToList {
public G22Utils g22utils;
public G22DatabasesPanel() {
}
public G22DatabasesPanel(G22Utils g22utils) {
this.g22utils = g22utils;
}
public Object[] _fieldsToList() {
return new Object[] { g22utils };
}
public JObjectTable table;
public FileWatchService dirWatcher;
public ReliableSingleThread rstUpdate = new ReliableSingleThread(new Runnable() {
public void run() {
try {
_updateTable();
} catch (Exception __e) {
throw rethrow(__e);
}
}
public String toString() {
return "_updateTable();";
}
});
public transient JComponent visualize_cache;
public JComponent visualize() {
if (visualize_cache == null)
visualize_cache = visualize_load();
return visualize_cache;
}
public JComponent visualize_load() {
return markVisualizer(this, visualize_impl());
}
public JComponent visualize_impl() {
table = swing(() -> new JObjectTable());
table.defaultAction(runnableToIVF1(runnableThread(new Runnable() {
public void run() {
try {
openDB();
} catch (Exception __e) {
throw rethrow(__e);
}
}
public String toString() {
return "openDB();";
}
})));
table.itemToMap = db -> {
IG22LoadedDB loaded = db.loadedDB();
return litorderedmap("Name", db.name, "Directory", f2s(db.dir), "Loaded", loaded == null ? "No" : (loaded.hidden() ? "Yes (hidden)" : "Yes"));
};
var tbl = table.visualize();
bindToComponent(tbl, () -> {
dirWatcher = new FileWatchService();
dirWatcher.addNonRecursiveListener(g22utils.databasesMotherDir(), file -> {
rstUpdate.get();
});
g22utils.masterStuff().onLoadedDBsChange(rstUpdate);
rstUpdate.get();
}, () -> {
g22utils.masterStuff().removeLoadedDBsChangeListener(rstUpdate);
{
cleanUp(dirWatcher);
dirWatcher = null;
}
});
return withTopAndBottomMargin(jCenteredRaisedSection("Gazelle projects on this computer", northAndCenterWithMargins(jline(toolTip("Create a new Gazelle project", jbutton("New project...", runnableThread(new Runnable() {
public void run() {
try {
newDatabase();
} catch (Exception __e) {
throw rethrow(__e);
}
}
public String toString() {
return "newDatabase();";
}
})))), centerAndEastWithMargin(tbl, jscroll_vertical_borderless(vstackWithSpacing_fixed(new DefaultButtonBorder(toolTip("Open selected project, keep other projects open too", tableDependentButton(table.table, "Open project", runnableThread(new Runnable() {
public void run() {
try {
openDB();
} catch (Exception __e) {
throw rethrow(__e);
}
}
public String toString() {
return "openDB();";
}
})))), toolTip("Open selected project in hidden mode [without a window]", tableDependentButton(table.table, "Open hidden", runnableThread(new Runnable() {
public void run() {
try {
openDBHidden();
} catch (Exception __e) {
throw rethrow(__e);
}
}
public String toString() {
return "openDBHidden();";
}
}))), toolTip("Open selected project, close all other projects", tableDependentButton(table.table, "Switch to project", runnableThread(new Runnable() {
public void run() {
try {
switchToDB();
} catch (Exception __e) {
throw rethrow(__e);
}
}
public String toString() {
return "switchToDB();";
}
}))), tableDependentButton(table.table, "Close project", runnableThread(new Runnable() {
public void run() {
try {
closeDB();
} catch (Exception __e) {
throw rethrow(__e);
}
}
public String toString() {
return "closeDB();";
}
})), tableDependentButton(table.table, "Rename project", runnableThread(new Runnable() {
public void run() {
try {
renameDB();
} catch (Exception __e) {
throw rethrow(__e);
}
}
public String toString() {
return "renameDB();";
}
})), tableDependentButton(table.table, "Delete project...", runnableThread(new Runnable() {
public void run() {
try {
deleteDB();
} catch (Exception __e) {
throw rethrow(__e);
}
}
public String toString() {
return "deleteDB();";
}
})), tableDependentButton(table.table, "Browse files", runnableThread(new Runnable() {
public void run() {
try {
browse();
} catch (Exception __e) {
throw rethrow(__e);
}
}
public String toString() {
return "browse();";
}
})), tableDependentButton(table.table, "Export project as zip...", runnableThread(new Runnable() {
public void run() {
try {
exportAsZip();
} catch (Exception __e) {
throw rethrow(__e);
}
}
public String toString() {
return "exportAsZip();";
}
})), jThreadedButton("Import project from zip...", runnableThread(new Runnable() {
public void run() {
try {
importZip();
} catch (Exception __e) {
throw rethrow(__e);
}
}
public String toString() {
return "importZip();";
}
}))))))));
}
public void newDatabase() {
AutoCloseable __1 = g22utils.enter();
try {
var tf = jtextfield();
var lblDir = jlabel(" ");
var lblStatus = jlabel(" ");
var button = jThreadedButton("Create project", () -> {
AutoCloseable __2 = g22utils.enter();
try {
String name = trim(tf.getText());
File dir = newFile(g22utils.databasesMotherDir(), name);
createEmptyConceptsFileInDir(dir);
disposeFrame(tf);
g22utils.masterStuff().openDatabase(dir);
} finally {
_close(__2);
}
});
disableButton(button);
onEnter(tf, button);
onChange(tf, new Runnable() {
public void run() {
try {
String name = trim(tf.getText());
boolean ok = false;
String status = " ", path = " ";
if (isValidFileName(name)) {
File dir = newFile(g22utils.databasesMotherDir(), name);
path = f2s(dir);
if (dirExists(dir))
status = "A project with that name exists";
else
ok = true;
} else if (!empty(name))
status = "Project name must be a valid file name";
setEnabled(button, ok);
setText(lblStatus, status);
setText(lblDir, path);
} catch (Exception __e) {
throw rethrow(__e);
}
}
public String toString() {
return "String name = trim(tf.getText());\r\n boolean ok;\r\n String status = \"...";
}
});
showForm_makeFrame("New Gazelle Project", vstackWithSpacing(withLabel("Name for new project", tf), lblDir, lblStatus, button));
} finally {
_close(__1);
}
}
public void _updateTable() {
table.setData_force(g22utils.gazelleDBs());
}
public void browse() {
desktopOpen(table.selected().dir);
}
public void openDB() {
g22utils.masterStuff().openDatabase(table.selected().dir);
}
public void openDBHidden() {
g22utils.masterStuff().openDatabase(table.selected().dir, true);
}
public void switchToDB() {
g22utils.masterStuff().switchToDatabase(table.selected().dir);
}
public void closeDB() {
g22utils.masterStuff().closeDatabase(table.selected().dir);
}
public void deleteDB() {
var db = table.selected();
if (db == null)
return;
var dir = db.dir();
if (g22utils.isConceptsDir(dir)) {
messageBox("Can't delete current project");
return;
}
g22utils.masterStuff().closeDatabase(dir);
new DeleteFilesDialog("Delete Gazelle project " + db.name()).wholeDirectory(dir).show();
}
public void exportAsZip() {
File dir = table.selected().dir;
JFileChooser fileChooser = new JFileChooser();
fileChooser.setDialogTitle("Export project as zip");
fileChooser.setSelectedFile(javaxBackupDir(dir.getName() + "-" + ymdMinusHMS() + ".zip"));
if (fileChooser.showSaveDialog(visualize()) == JFileChooser.APPROVE_OPTION) {
File zip = fileChooser.getSelectedFile();
dir2zip(dir, zip, dir.getName() + "/");
fileSavedInfoBox(zip);
desktopOpen(dirOfFile(zip));
}
}
public void importZip() {
try {
JFileChooser fc = new JFileChooser();
fc.setDialogTitle("Import project from zip");
fc.setCurrentDirectory(javaxBackupDir());
if (fc.showOpenDialog(visualize()) == JFileChooser.APPROVE_OPTION) {
File zip = fc.getSelectedFile();
g22utils.importProjectFromZip(zip);
}
} catch (Throwable __e) {
messageBox(__e);
}
}
public void renameDB() {
File dir = table.selected().dir;
inputText("New name", fileName(dir), newName -> {
assertValidFileName(newName);
if (!eq(newName, fileName(dir))) {
boolean open = g22utils.masterStuff().isConceptDirLoaded(dir);
if (open)
g22utils.masterStuff().closeDatabase(dir);
renameFileVerbose(dir, newName);
if (open)
g22utils.masterStuff().openDatabase(dir);
}
});
}
}
static public class PersistableThrowable extends DynamicObject {
public String className;
public String msg;
public String stacktrace;
final public PersistableThrowable setActualThrowable(Throwable actualThrowable) {
return actualThrowable(actualThrowable);
}
public PersistableThrowable actualThrowable(Throwable actualThrowable) {
this.actualThrowable = actualThrowable;
return this;
}
final public Throwable getActualThrowable() {
return actualThrowable();
}
public Throwable actualThrowable() {
return actualThrowable;
}
transient public Throwable actualThrowable;
public PersistableThrowable() {
}
public PersistableThrowable(Throwable e) {
actualThrowable = e;
if (e == null)
className = "Crazy Null Error";
else {
className = getClassName(e).replace('/', '.');
msg = e.getMessage();
stacktrace = getStackTrace_noRecord(e);
}
}
public String toString() {
return nempty(msg) ? className + ": " + msg : className;
}
public RuntimeException asRuntimeException() {
if (actualThrowable != null)
return main.asRuntimeException(actualThrowable);
return new Fail(this);
}
}
static public class G22Utils_Base {
transient public Set> onProjectFileChanged;
public G22Utils_Base onProjectFileChanged(IVF1 f) {
onProjectFileChanged = createOrAddToSyncLinkedHashSet(onProjectFileChanged, f);
return this;
}
public G22Utils_Base removeProjectFileChangedListener(IVF1 f) {
main.remove(onProjectFileChanged, f);
return this;
}
public void projectFileChanged(File file) {
if (onProjectFileChanged != null)
for (var listener : onProjectFileChanged) pcallF_typed(listener, file);
}
}
static public class G22Utils extends G22Utils_Base implements AutoCloseable, TransientObject {
final public G22Utils setBackgroundProcessesUI(IBackgroundProcesses backgroundProcessesUI) {
return backgroundProcessesUI(backgroundProcessesUI);
}
public G22Utils backgroundProcessesUI(IBackgroundProcesses backgroundProcessesUI) {
this.backgroundProcessesUI = backgroundProcessesUI;
return this;
}
final public IBackgroundProcesses getBackgroundProcessesUI() {
return backgroundProcessesUI();
}
public IBackgroundProcesses backgroundProcessesUI() {
return backgroundProcessesUI;
}
public IBackgroundProcesses backgroundProcessesUI;
final public G22Utils setModule(Enterable module) {
return module(module);
}
public G22Utils module(Enterable module) {
this.module = module;
return this;
}
final public Enterable getModule() {
return module();
}
public Enterable module() {
return module;
}
public Enterable module;
final public G22Utils setMasterStuff(G22MasterStuff masterStuff) {
return masterStuff(masterStuff);
}
public G22Utils masterStuff(G22MasterStuff masterStuff) {
this.masterStuff = masterStuff;
return this;
}
final public G22MasterStuff getMasterStuff() {
return masterStuff();
}
public G22MasterStuff masterStuff() {
return masterStuff;
}
public G22MasterStuff masterStuff;
final public G22Utils setConcepts(Concepts concepts) {
return concepts(concepts);
}
public G22Utils concepts(Concepts concepts) {
this.concepts = concepts;
return this;
}
final public Concepts getConcepts() {
return concepts();
}
public Concepts concepts() {
return concepts;
}
public Concepts concepts;
final public G22Utils setProjectActions(G22ProjectActions projectActions) {
return projectActions(projectActions);
}
public G22Utils projectActions(G22ProjectActions projectActions) {
this.projectActions = projectActions;
return this;
}
final public G22ProjectActions getProjectActions() {
return projectActions();
}
public G22ProjectActions projectActions() {
return projectActions;
}
public G22ProjectActions projectActions;
final public G22AutoStarter getAutoStarter() {
return autoStarter();
}
public G22AutoStarter autoStarter() {
return autoStarter;
}
public G22AutoStarter autoStarter = new G22AutoStarter(this);
final public G22Utils setFunctionTimings(FunctionTimings functionTimings) {
return functionTimings(functionTimings);
}
public G22Utils functionTimings(FunctionTimings functionTimings) {
this.functionTimings = functionTimings;
return this;
}
final public FunctionTimings getFunctionTimings() {
return functionTimings();
}
public FunctionTimings functionTimings() {
return functionTimings;
}
public FunctionTimings functionTimings = new FunctionTimings();
final public Map getProjectWideFunctionDefs() {
return projectWideFunctionDefs();
}
public Map projectWideFunctionDefs() {
return projectWideFunctionDefs;
}
public Map projectWideFunctionDefs = syncMap();
final public Map getProjectWideClassDefs() {
return projectWideClassDefs();
}
public Map projectWideClassDefs() {
return projectWideClassDefs;
}
public Map projectWideClassDefs = syncMap();
public Timestamp recompileDate;
final public Set getAutoClosingResources() {
return autoClosingResources();
}
public Set autoClosingResources() {
return autoClosingResources;
}
public Set autoClosingResources = syncLinkedHashSet();
public FileWatchService fileWatcher;
public boolean projectFileListenerInitiated = false;
final public CombinedStringifier getStringifier() {
return stringifier();
}
public CombinedStringifier stringifier() {
return stringifier;
}
public CombinedStringifier stringifier = new CombinedStringifier(o -> o instanceof BufferedImage ? "Image (" + ((BufferedImage) o).getWidth() + "*" + ((BufferedImage) o).getHeight() + " px)" : null);
public ILASClassLoader lasClassLoader() {
return masterStuff == null ? null : masterStuff.lasClassLoader();
}
final public G22Utils setConfirmProjectReplacements(boolean confirmProjectReplacements) {
return confirmProjectReplacements(confirmProjectReplacements);
}
public G22Utils confirmProjectReplacements(boolean confirmProjectReplacements) {
this.confirmProjectReplacements = confirmProjectReplacements;
return this;
}
final public boolean getConfirmProjectReplacements() {
return confirmProjectReplacements();
}
public boolean confirmProjectReplacements() {
return confirmProjectReplacements;
}
public boolean confirmProjectReplacements = false;
public ImageSurface stdImageSurface_noToolTip() {
return stdImageSurface_noToolTip(imageSurface());
}
public ImageSurface stdImageSurface_noToolTip(ImageSurface is) {
imageSurface_pixelated(is);
is.setAutoZoomToDisplay(true).repaintInThread(false);
is.defaultImageDir = () -> dbDir();
is.specialPurposed = true;
return is;
}
public ImageSurface stdImageSurface() {
return stdImageSurface(imageSurface());
}
public ImageSurface stdImageSurface(ImageSurface is) {
stdImageSurface_noToolTip(is);
new ImageSurface_PositionToolTip(is);
return is;
}
public List stdImageSurfaces(Collection images) {
return map(__52 -> stdImageSurface(__52), toBufferedImages(images));
}
public ImageSurface stdImageSurface(MakesBufferedImage img) {
return stdImageSurface(toBufferedImage(img));
}
public ImageSurface stdImageSurface(BufferedImage img) {
var is = stdImageSurface();
is.setImage(img);
return is;
}
public ImageSurface stdImageSurface(File file) {
var is = stdImageSurface();
is.setImage(file);
return is;
}
public ImageSurface stdImageSurface(G22GalleryImage img) {
return stdImageSurface(img == null ? null : img.path);
}
public ImageSurface stdImageSurfaceWithSelection(MakesBufferedImage img, Rect selection) {
return stdImageSurfaceWithSelection(toBufferedImage(img), selection);
}
public ImageSurface stdImageSurfaceWithSelection(BufferedImage img, Rect selection) {
var is = stdImageSurface(img);
is.setSelection(selection);
return is;
}
public String stringify(Object o) {
return stringifier.toString(o);
}
transient public Set> onBigVariableLoaded;
public G22Utils onBigVariableLoaded(IVF1 f) {
onBigVariableLoaded = createOrAddToSyncLinkedHashSet(onBigVariableLoaded, f);
return this;
}
public G22Utils removeBigVariableLoadedListener(IVF1 f) {
main.remove(onBigVariableLoaded, f);
return this;
}
public void bigVariableLoaded(G22Variable var) {
if (onBigVariableLoaded != null)
for (var listener : onBigVariableLoaded) pcallF_typed(listener, var);
}
transient public Set> onSettingUpParser;
public G22Utils onSettingUpParser(IVF1 f) {
onSettingUpParser = createOrAddToSyncLinkedHashSet(onSettingUpParser, f);
return this;
}
public G22Utils removeSettingUpParserListener(IVF1 f) {
main.remove(onSettingUpParser, f);
return this;
}
public void settingUpParser(GazelleV_LeftArrowScriptParser parser) {
if (onSettingUpParser != null)
for (var listener : onSettingUpParser) pcallF_typed(listener, parser);
}
transient public Set> onSettingUpScriptIDE;
public G22Utils onSettingUpScriptIDE(IVF1 f) {
onSettingUpScriptIDE = createOrAddToSyncLinkedHashSet(onSettingUpScriptIDE, f);
return this;
}
public G22Utils removeSettingUpScriptIDEListener(IVF1 f) {
main.remove(onSettingUpScriptIDE, f);
return this;
}
public void settingUpScriptIDE(JLeftArrowScriptIDE ide) {
if (onSettingUpScriptIDE != null)
for (var listener : onSettingUpScriptIDE) pcallF_typed(listener, ide);
}
public GazelleV_LeftArrowScriptParser leftArrowParser() {
GazelleV_LeftArrowScriptParser parser = new GazelleV_LeftArrowScriptParser();
parser.classNameResolver(classNameResolver());
parser.lasClassLoader(lasClassLoader());
settingUpParser(parser);
parser.addClassAlias("BollingerBands", "LiveBollingerBands");
parser.addClassAlias("Freq", "Frequency");
parser.addClassAlias("PriceDigitizer", "PriceDigitizer2");
parser.addClassAlias("MRUAndAllTimeTop", "MRUAndAllTimeTop_optimized");
parser.findExternalObject2 = name -> {
{
var __2 = projectWideClassDefs.get(name);
if (__2 != null)
return __2;
}
return parser.findExternalObject2_base(name);
};
parser.addFunctionDefs(projectWideFunctionDefs);
return parser;
}
public Object leftArrow(String script) {
return leftArrowParse(script).get();
}
public GazelleV_LeftArrowScript.Script leftArrowParse(String script) {
return leftArrowParser().parse(script);
}
public Object leftArrowWithVars(String script, Object... vars) {
var parser = leftArrowParser();
for (int i = 0; i < l(vars); i += 2) parser.addVar((String) vars[i], or(_getClass(vars[i + 1]), Object.class), true);
var parsed = parser.parse(script);
FlexibleVarContext varContext = new FlexibleVarContext();
for (int i = 0; i < l(vars); i += 2) varContext.set((String) vars[i], vars[i + 1]);
return parsed.get(varContext);
}
public void basicParserTest() {
var parser = leftArrowParser();
print("classContainerPrefixes", parser.classContainerPrefixes());
assertEquals(pair(1, 2), parser.parse("new Pair 1 2").get());
}
final public JLeftArrowScriptIDE leftArrowScriptIDE() {
return leftArrowIDE();
}
public JLeftArrowScriptIDE leftArrowIDE() {
JLeftArrowScriptIDE ide = new JLeftArrowScriptIDE();
ide.g22utils(this);
ide.scriptTimeout(projectWideScriptTimeout());
settingUpScriptIDE(ide);
return ide;
}
public File byteCodePath() {
return assertNotNull(getBytecodePathForClass(this));
}
public ClassNameResolver classNameResolver_cache;
public ClassNameResolver classNameResolver() {
if (classNameResolver_cache == null)
classNameResolver_cache = classNameResolver_load();
return classNameResolver_cache;
}
public ClassNameResolver classNameResolver_load() {
return new ClassNameResolver().byteCodePath(byteCodePath()).init();
}
public File databasesMotherDir() {
return masterStuff.databasesMotherDir();
}
public File dirOfProjectNamed(String name) {
assertNempty(name);
return newFile(databasesMotherDir(), name);
}
public AutoCloseable enter() {
return module == null ? null : module.enter();
}
public String defaultDBName() {
return "Default";
}
public File lastOpenedDBsFile() {
return newFile(databasesMotherDir(), "Last Opened");
}
public File recentlyOpenedDBsFile() {
return newFile(databasesMotherDir(), "Recently Opened");
}
public File autoUpdateFile() {
return newFile(databasesMotherDir(), "Auto-Update");
}
public boolean autoUpdateEnabled() {
return fileExists(autoUpdateFile());
}
public void setAutoUpdate(boolean b) {
createOrRemoveFile(autoUpdateFile(), b);
}
public List dbsToOpen() {
return loadRecentProjectsFile(lastOpenedDBsFile());
}
public List dbNamesRecentlyOpened() {
return loadRecentProjectsFile(recentlyOpenedDBsFile());
}
public void addToRecentDBNames(String dbName, boolean hidden) {
List list = dbNamesRecentlyOpened();
List list2 = cloneList(list);
removeAll(list2, dbName, "*" + dbName);
list2.add(0, hidden ? "*" + dbName : dbName);
truncateList(list2, 100);
if (!eq(list, list2))
saveTextFile(recentlyOpenedDBsFile(), lines(list2));
}
public List loadRecentProjectsFile(File file) {
List dbNames = new ArrayList();
for (String name : tlft(loadTextFile(file))) {
String name2 = dropPrefix("*", name);
if (fileExists(newFile(databasesMotherDir(), name2)))
dbNames.add(name);
}
if (empty(dbNames))
dbNames.add(defaultDBName());
return dbNames;
}
public void setOpenDBs(Collection dbs) {
List dbNames = new ArrayList();
for (var db : dbs) {
var dbDir = conceptsDir(db.concepts());
if (sameFile(databasesMotherDir(), dirOfFile(dbDir)))
dbNames.add((db.hidden() ? "*" : "") + fileName(dbDir));
}
saveTextFile(lastOpenedDBsFile(), lines(dbNames));
}
public void setupScriptCRUD(SimpleCRUD_v2 crud) {
setupScriptCRUD(crud, false);
}
public void setupScriptCRUD(SimpleCRUD_v2 crud, boolean allowRunOnProjectOpen) {
crud.useNewChangeHandler(true);
crud.editableFieldsForItem = x -> llNonNulls("description", allowRunOnProjectOpen ? "runOnProjectOpen" : null, allowRunOnProjectOpen ? "runOrder" : null);
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");
}
public Map scriptToMap(G22LeftArrowScript c) {
return scriptToMap(c, false);
}
public Map scriptToMap(G22LeftArrowScript c, boolean allowRunOnProjectOpen) {
return litorderedmap("Description", c.description(), "Status", renderScriptStatus(c), "LoC", renderScriptLoC(c), "Import note", c.importNote, "Run on project open", c.renderRunOnProjectOpenStatus());
}
public String renderScriptStatus(G22LeftArrowScript c) {
return or2_rev("Empty", joinNemptiesWithSpacedPlus(c.isClearForAutoRun() ? "Clear for auto-run" : null, c.isSavedDistinctFromAutoRunVersion() ? "Saved (not cleared)" : null, c.isEditing() ? "Editing" : null));
}
public String renderScriptLoC(G22LeftArrowScript c) {
return n2(intMax(mapLL(__53 -> linesOfCode_javaTok(__53), c.editingText, c.text, c.codeForAutoRun())));
}
public List labelsForFile(File file) {
if (file == null)
return null;
File labelsFile = appendToFileName(file, ".labels");
List labels = tlft(loadTextFile(labelsFile));
return map(__54 -> getLabel(__54), labels);
}
public File labelsFile(File file) {
if (file == null)
return null;
return appendToFileName(file, ".labels");
}
public void setLabelsForFile(File file, List labels) {
List list = map(labels, label -> label.name);
File f = labelsFile(file);
saveTextFile(f, lines(list));
print("Saved " + nLabels(list) + " (" + joinWithComma(list) + ") to " + f);
}
public G22Label getLabel(String name) {
if (empty(name))
return null;
if (containsNewLine(name))
throw fail("No newlines in label names allowed: " + name);
return uniqCI(concepts, G22Label.class, "name", name);
}
final public File projectDir() {
return dbDir();
}
public File dbDir() {
return conceptsDir(concepts);
}
final public File projectFile(String name) {
return fileInDbDir(name);
}
public File fileInDbDir(String name) {
return newFile(dbDir(), name);
}
public class GazelleDB implements IFieldsToList {
public String name;
public File dir;
public GazelleDB() {
}
public GazelleDB(String name, File dir) {
this.dir = dir;
this.name = name;
}
public String toString() {
return shortClassName_dropNumberPrefix(this) + "(" + name + ", " + dir + ")";
}
public boolean equals(Object o) {
if (!(o instanceof GazelleDB))
return false;
GazelleDB __0 = (GazelleDB) o;
return eq(name, __0.name) && eq(dir, __0.dir);
}
public int hashCode() {
int h = 1669530526;
h = boostHashCombine(h, _hashCode(name));
h = boostHashCombine(h, _hashCode(dir));
return h;
}
public Object[] _fieldsToList() {
return new Object[] { name, dir };
}
public String name() {
return name;
}
public File dir() {
return dir;
}
public boolean loaded() {
return loadedDB() != null;
}
public IG22LoadedDB loadedDB_cache;
public IG22LoadedDB loadedDB() {
if (loadedDB_cache == null)
loadedDB_cache = loadedDB_load();
return loadedDB_cache;
}
public IG22LoadedDB loadedDB_load() {
return masterStuff.getLoadedDBForConceptDir(dir);
}
public File conceptsFile() {
return conceptsFileIn(dir);
}
}
public List gazelleDBs() {
List dbs = new ArrayList();
for (File dir : listDirsContainingFileNamed(databasesMotherDir(), "concepts.structure.gz")) dbs.add(new GazelleDB(fileName(dir), dir));
return dbs;
}
public IterableIterator peekAllProjectsConcepts() {
var classFinder = masterStuff.makeClassFinder();
return mapI_pcall(gazelleDBs(), db -> {
var cc = newConceptsWithClassFinder(db.conceptsFile(), classFinder);
cc.loadFromDisk();
return cc;
});
}
public RSyntaxTextAreaWithSearch newSyntaxTextArea() {
return newSyntaxTextArea((IF1) null);
}
public RSyntaxTextAreaWithSearch newSyntaxTextArea(IF1 wrapStatusLabel) {
RSyntaxTextAreaWithSearch ta = new RSyntaxTextAreaWithSearch(wrapStatusLabel);
ta.textArea().setHighlightCurrentLine(false);
ta.menuLessOperation();
return ta;
}
public RSyntaxTextAreaWithSearch newSyntaxTextArea(String text) {
var ta = newSyntaxTextArea();
ta.setText(text);
return ta;
}
public File projectStoryTextFile() {
return newFile(dbDir(), "story.txt");
}
public String projectName() {
return fileName(dbDir());
}
public void close() {
try {
autoStarter.close();
closeAndClear(autoClosingResources);
{
cleanUp(fileWatcher);
fileWatcher = null;
}
} catch (Exception __e) {
throw rethrow(__e);
}
}
public void close(AutoCloseable c) {
main.close(c);
}
public G22Variable findProjectVar(String name) {
return conceptWhereCI(concepts, G22Variable.class, "name", name);
}
public Collection projectVarNames() {
return collect("name", list(concepts, G22Variable.class));
}
public Object getProjectVar(String name) {
G22Variable var = findProjectVar(name);
return var == null ? null : var.value();
}
public Object getBigProjectVarOnce(String name) {
G22Variable var = findProjectVar(name);
return var == null ? null : var.getOnce();
}
public Object getMandatoryProjectVar(String name) {
return assertNotNull(name, getProjectVar(name));
}
public Object getOrSetTransientProjectVar(String name, IF0 f) {
{
var __3 = getProjectVar(name);
if (__3 != null)
return __3;
}
return setTransientProjectVarAndReturn(name, f.get());
}
public Object getProjectVarOrCallScript(String name, long scriptID) {
{
var __4 = getProjectVar(name);
if (__4 != null)
return __4;
}
return callScript(scriptID);
}
public Object getProjectVarSetByScript(String name, long scriptID) {
{
var __5 = getProjectVar(name);
if (__5 != null)
return __5;
}
callScript(scriptID);
return getProjectVar(name);
}
public Object getProjectVarFromAnyProject(String name) {
for (var project : masterStuff().openProjects()) {
var __6 = project.g22utils().getProjectVar(name);
if (__6 != null)
return __6;
}
return null;
}
final public List getVarFromAnyProject(String name) {
return getProjectVarFromAllProjects(name);
}
public List getProjectVarFromAllProjects(String name) {
return nonNulls(masterStuff().openProjects(), project -> project.g22utils().getProjectVar(name));
}
public G22Variable projectVarConcept(String name) {
return optimizedUniqCI(concepts, G22Variable.class, "name", name);
}
public Object waitForProjectVar(String name) {
return waitForProjectVar(infinity(), name);
}
public Object waitForProjectVar(double timeoutSeconds, String name) {
G22Variable var = projectVarConcept(name);
return waitForCalculatedValueUsingChangeListener(timeoutSeconds, () -> var.value(), var);
}
public void setBigProjectVar(boolean persistent, String name, Object value) {
if (persistent)
setBigProjectVar(name, value);
else
setTransientProjectVar(name, value);
}
public G22Variable setProjectVar(boolean persistent, String name, Object value) {
G22Variable var = projectVarConcept(name);
if (!persistent)
var.persistent(persistent);
var.value(value);
if (persistent)
var.persistent(persistent);
return var;
}
public void unloadProjectVar(String name) {
var var = findProjectVar(name);
{
if (var != null)
var.unload();
}
}
public A setBigProjectVar(String name, A value) {
setPersistentProjectVar(name, value);
G22Variable var = projectVarConcept(name);
var.makeBig();
return value;
}
public Object getCachedProjectVar(String name) {
var var = findProjectVar(name);
return var == null ? null : var.cachedValue();
}
public boolean isBigProjectVar(String name) {
var v = findProjectVar(name);
return v != null && v.big();
}
public A setPersistentProjectVar(String name, A value) {
setProjectVar(true, name, value);
return value;
}
public G22Variable setTransientProjectVar(String name, Object value) {
return setProjectVar(false, name, value);
}
public A setTransientProjectVarAndReturn(String name, A value) {
setProjectVar(false, name, value);
return value;
}
public void setAutoClosingProjectVar(String name, Object value) {
setTransientProjectVar(name, value).autoClose(true);
}
public void deleteProjectVar(String name) {
deleteConcept(findProjectVar(name));
}
final public Object getOrCreateTransientProjectVar(String name, IF0 maker) {
return getOrCreateProjectVar(name, maker);
}
public Object getOrCreateProjectVar(String name, IF0 maker) {
return getOrCreateProjectVar(projectVarConcept(name), maker);
}
public Object getOrCreatePersistentProjectVar(String name, IF0 maker) {
var var = projectVarConcept(name);
Object value = getOrCreateProjectVar(var, maker);
var.persistent(true);
return value;
}
public Object getOrCreateBigProjectVar(String name, IF0 maker) {
var var = projectVarConcept(name);
Object value = getOrCreateProjectVar(var, maker);
var.makeBig();
return value;
}
public Object getOrCreateAutoClosingProjectVar(String name, IF0 maker) {
var var = projectVarConcept(name);
Object value = getOrCreateProjectVar(var, maker);
var.autoClose(true);
return value;
}
public boolean projectVarIsNotNull(String name) {
var var = findProjectVar(name);
return var != null && var.has();
}
public Object getOrCreateProjectVar(G22Variable var, IF0 maker) {
if (!var.has()) {
Object value = maker.get();
if (value != null)
var.setValueIfNull(value);
}
return var.get();
}
public IVarWithNotify liveProjectVar(String name) {
return liveProjectVar(name, null);
}
public IVarWithNotify liveProjectVar(String name, Object defaultValue) {
G22Variable var = projectVarConcept(name);
var.persistent(true);
var.setValueIfNull(defaultValue);
return var.varValue();
}
public IVarWithNotify liveTransientProjectVar(String name) {
return liveTransientProjectVar(name, null);
}
public IVarWithNotify liveTransientProjectVar(String name, Object defaultValue) {
G22Variable var = projectVarConcept(name);
var.persistent(false);
var.setValueIfNull(defaultValue);
return var.varValue();
}
public void replaceCloseableProjectVar(String name, IF0 calc) {
Object value = getProjectVar(name);
if (value instanceof AutoCloseable) {
main.close((AutoCloseable) value);
deleteProjectVar(name);
}
setTransientProjectVar(name, calc == null ? null : calc.get());
}
public void projectVarChanged(String name) {
var var = findProjectVar(name);
{
if (var != null)
var.changeInsideOfValue();
}
}
public Collection projectVarChanged(Object value) {
var vars = conceptsWhere(concepts, G22Variable.class, "value", value);
for (var var : vars) var.change();
return vars;
}
public double defaultScriptTimeout() {
return 10.0;
}
public double projectWideScriptTimeout() {
return or(toDoubleOrNull(getProjectVar("!Script Timeout")), defaultScriptTimeout());
}
public G22Analyzer getAnalyzer(long id) {
var a = getConcept(concepts, G22Analyzer.class, id);
if (a == null)
throw fail("Analyzer not found: " + id);
return a;
}
public G22LeftArrowScript getScript(long id) {
var a = getConcept(concepts, G22LeftArrowScript.class, id);
if (a == null)
throw fail("Script not found: " + id);
return a;
}
public Object callScript(long id) {
var script = getScript(id);
return script.evaluateWithoutTimeout();
}
public Object callAutoRunnableScript(long id) {
var script = getScript(id);
return script.evaluateAutoRunWithoutTimeout();
}
public double defaultTimeout() {
return infinity();
}
public A evalRegisteredCode(String processName, IF0 code) {
return evalRegisteredCode(defaultTimeout(), processName, code);
}
public A evalRegisteredCode(double timeoutSeconds, String processName, IF0 code) {
if (code == null)
return null;
return evalWithTimeoutOrTypedException(timeoutSeconds, () -> useThisThreadAsBackgroundProcess(processName, code));
}
public Thread startAsRegisteredThread(String processName, Runnable r) {
if (r == null)
return null;
return startThread(processName, () -> useThisThreadAsBackgroundProcess(processName, toIF0(r)));
}
public A useThisThreadAsBackgroundProcess(String processName, IF0 code) {
AutoCloseable __8 = enter();
try {
var process = backgroundProcessesUI.tempAdd(processName);
try {
Thread myThread = currentThread();
process.setInterruptAction(new Runnable() {
public void run() {
try {
cancelThread(myThread);
} catch (Exception __e) {
throw rethrow(__e);
}
}
public String toString() {
return "cancelThread(myThread)";
}
});
return code.get();
} finally {
_close(process);
}
} finally {
_close(__8);
}
}
public Object host() {
AutoCloseable __9 = enter();
try {
return dm_os();
} finally {
_close(__9);
}
}
public A timeFunction(String name, IF0 f) {
return functionTimings.get(name, f);
}
public boolean isConceptsDir(File dir) {
return isSameFile(conceptsDir(concepts), dir);
}
synchronized public FileWatchService fileWatcher() {
{
if (fileWatcher == null)
fileWatcher = new FileWatchService();
return fileWatcher;
}
}
synchronized public G22Utils onProjectFileChanged(IVF1 listener) {
super.onProjectFileChanged(listener);
if (!projectFileListenerInitiated) {
projectFileListenerInitiated = true;
fileWatcher().addRecursiveListener(dbDir(), __10 -> projectFileChanged(__10));
}
return this;
}
public G22ProjectInfo projectInfo_cache;
public G22ProjectInfo projectInfo() {
if (projectInfo_cache == null)
projectInfo_cache = projectInfo_load();
return projectInfo_cache;
}
public G22ProjectInfo projectInfo_load() {
return optimizedUniq(concepts, G22ProjectInfo.class);
}
public RunnablesReferenceQueue runnablesReferenceQueue() {
return masterStuff.runnablesReferenceQueue();
}
public EphemeralObjectIDs ephemeralObjectIDs() {
return masterStuff.ephemeralObjectIDs();
}
public Object eph(long id) {
return ephemeralObjectIDs().get(id);
}
public void openInBrowser(String url) {
main.openPlatformBrowser(url);
}
public String compilationDate() {
return or2(compilationDateFromClassPath(this), "unknown");
}
public String projectID() {
return projectInfo().projectID();
}
public IG22LoadedDB getLoadedDB() {
return masterStuff.getLoadedDB(concepts);
}
public ConceptsComboBox galleryImagesComboBox() {
return swing(() -> new ConceptsComboBox(concepts, G22GalleryImage.class));
}
public IBackgroundProcess tempAddBackgroundProcess(String name) {
return backgroundProcessesUI == null ? null : backgroundProcessesUI.tempAdd(name);
}
public IF1 classFinder() {
var master = masterStuff.makeClassFinder();
return name -> {
{
var __7 = projectWideClassDefs().get(dropPrefix("main$", name));
if (__7 != null)
return __7;
}
return master.get(name);
};
}
public Object restructure(Object o) {
return unstructure(structure(o), false, concepts.classFinder);
}
public G22ProjectActions project() {
return projectActions();
}
public boolean openPathInProject(String path) {
return projectActions().openPathInProject(path);
}
final public void showUIURL(String url) {
openUIURL(url);
}
final public void goToURIURL(String url) {
openUIURL(url);
}
public void openUIURL(String url) {
projectActions().openUIURL(url);
}
public BufferedImage loadProjectImage(String fileName) {
return loadImage2(projectFile(fileName));
}
public IG22LoadedDB openDB(String name) {
return openDB(name, false);
}
public IG22LoadedDB openDB(String name, boolean hidden) {
return masterStuff().openDB(name, hidden);
}
public G22Utils getProject(String name) {
return openDB(name, true).g22utils();
}
public G22Utils getProjectIfOpen(String name) {
var db = first(openProjects(), p -> eqic(p.g22utils().projectName(), name));
return db == null ? null : db.g22utils();
}
final public G22JavaObjectVisualizer visualizeJavaObject(Object o) {
return visualizeObject(o);
}
public G22JavaObjectVisualizer visualizeObject(Object o) {
return new G22JavaObjectVisualizer(this, o);
}
final public G22JavaObjectVisualizer visualizeJavaObjectWithoutType(Object o) {
return visualizeObjectWithoutType(o);
}
public G22JavaObjectVisualizer visualizeObjectWithoutType(Object o) {
return visualizeObject(o).withTypeAndTime(false);
}
transient public IF0 makeVariablesPanel;
public G22VariablesPanel makeVariablesPanel() {
return makeVariablesPanel != null ? makeVariablesPanel.get() : makeVariablesPanel_base();
}
final public G22VariablesPanel makeVariablesPanel_fallback(IF0 _f) {
return _f != null ? _f.get() : makeVariablesPanel_base();
}
public G22VariablesPanel makeVariablesPanel_base() {
return new G22VariablesPanel().g22utils(this);
}
transient public IF0 jGazelleLogo;
public JComponent jGazelleLogo() {
return jGazelleLogo != null ? jGazelleLogo.get() : jGazelleLogo_base();
}
final public JComponent jGazelleLogo_fallback(IF0 _f) {
return _f != null ? _f.get() : jGazelleLogo_base();
}
public JComponent jGazelleLogo_base() {
return main.jGazelleLogo();
}
public boolean devMode() {
return masterStuff().devMode();
}
public List list(Class type) {
return list(type, concepts());
}
public List list(Class type, Concepts cc) {
return main.list(cc, type);
}
public List list(Concepts concepts, Class type) {
return main.list(type, concepts);
}
public G22GalleryImage galleryImageForMD5(String md5) {
return firstThat(list(concepts, G22GalleryImage.class), img -> cic(fileName(img.path), md5));
}
public JComponent wrapImageSurface(ImageSurface is) {
return is == null ? null : jscroll_centered_borderless(is);
}
public JComponent wrap(Object o) {
var c = main.wrap(o);
if (c instanceof ImageSurface)
return wrapImageSurface((ImageSurface) c);
return c;
}
transient public IF0 byUser;
public String byUser() {
return byUser != null ? byUser.get() : byUser_base();
}
final public String byUser_fallback(IF0 _f) {
return _f != null ? _f.get() : byUser_base();
}
public String byUser_base() {
return "";
}
final public Collection openProjects() {
return getLoadedDBs();
}
public Collection getLoadedDBs() {
return masterStuff().openProjects();
}
public List listInOpenProjects(Class type) {
return concatMap(openProjects(), db -> db.g22utils().list(type));
}
transient public PicturesByMD5 picturesByMD5_cache;
public PicturesByMD5 picturesByMD5() {
if (picturesByMD5_cache == null)
picturesByMD5_cache = picturesByMD5_load();
return picturesByMD5_cache;
}
public PicturesByMD5 picturesByMD5_load() {
return new PicturesByMD5(projectFile("Images")).extension(".qoi");
}
public JButton reloadButton(String toolTip, Runnable action) {
return jimageButton("#1101440", toolTip, action);
}
public void registerConcept(Concept c) {
main.registerConcept(concepts, c);
}
public void registerConcept(Concepts cc, Concept c) {
main.registerConcept(cc, c);
}
public void addingAdditionalAutoCompletes(LeftArrowScriptAutoCompleter autoCompleter) {
String token = autoCompleter.prevToken();
if (isIdentifier(token) && contains(token, "ProjectVar"))
autoCompleter.addToSearcher(quoteAll(projectVarNames()));
autoCompleter.addToSearcher(keys(projectWideClassDefs()));
}
public boolean addLibrary(String library) {
if (!main.addLibrary(library))
return false;
print("Loaded library: " + library);
masterStuff().newClassesDefined();
return true;
}
public boolean addLibrary(File library) {
if (!main.addLibrary(library))
return false;
print("Loaded library: " + library);
masterStuff().newClassesDefined();
return true;
}
public WrappedCloseable addResource(A resource) {
if (resource == null)
return null;
autoClosingResources.add(resource);
return new WrappedCloseable<>(resource) {
@Override
public void beforeClose() {
autoClosingResources.remove(resource);
}
};
}
public Object callFunctionFromScript(int scriptID, String functionName, Object... args) {
return callFunctionFromScript((long) scriptID, functionName, args);
}
public Object callLatestFunctionFromScript(int scriptID, String functionName, Object... args) {
var function = getScript(scriptID).latestCompileResult().get().getFunction(functionName);
return function.callFromOutside(args);
}
public Object callSavedFunctionFromScript(int scriptID, String functionName, Object... args) {
var function = getScript(scriptID).compileSaved().get().getFunction(functionName);
return function.callFromOutside(args);
}
public Object callFunctionFromScript(long scriptID, String functionName, Object... args) {
var function = getScript(scriptID).safestCompileResult().get().getFunction(functionName);
return function.callFromOutside(args);
}
public JComponent visualizeAutoRunnableScript(long scriptID) {
return visualizeAutoRunnableScript(getScript(scriptID));
}
public JComponent visualizeAutoRunnableScript(G22LeftArrowScript script) {
if (script == null)
return null;
if (!script.isClearForAutoRun())
return jcenteredlabel("Script not clear for auto-run");
try {
Object result = script.evaluateAutoRunWithoutTimeout();
var objVisualizer = new G22JavaObjectVisualizer(this, result).withType(false);
return objVisualizer.visualize();
} catch (Throwable e) {
printStackTrace(e);
return jErrorView(e);
}
}
public void importProjectFromZip(File zipFile, String baseDirInZip, String projectName) {
File dir = dirOfProjectNamed(projectName);
if (isConceptsDir(dir)) {
if (eqic(projectName(), "Default")) {
infoMessage("Sorry dude");
return;
}
IG22LoadedDB defaultDB = masterStuff().getLoadedDBForConceptDir(dirOfProjectNamed("Default"));
IG22LoadedDB preloadedDefaultDB = defaultDB;
if (defaultDB == null)
defaultDB = openDB("Default");
project().closeProject();
defaultDB.g22utils().importProjectFromZip(zipFile, baseDirInZip, projectName);
if (preloadedDefaultDB == null)
defaultDB.projectActions().closeProject();
return;
}
if (!directoryIsEmpty(dir)) {
if (confirmProjectReplacements && !swingConfirm("Archive and overwrite existing project " + projectName + "?"))
return;
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);
}
public void importProjectFromZip(File zipFile) {
String baseDir = baseDirInZip(zipFile);
String projectName = takeFirst(baseDir, smartIndexOf(baseDir, '/'));
if (empty(projectName)) {
{
inputText("Please enter name for imported project", name -> {
if (!validFileName(name)) {
infoBox("Invalid name, use simpler characters");
importProjectFromZip(zipFile);
return;
}
importProjectFromZip(zipFile, "", name);
});
return;
}
}
assertValidFileName(projectName);
importProjectFromZip(zipFile, baseDir, projectName);
}
public Class export(Class c) {
if (c != null) {
projectWideClassDefs.put(dropHashFromClassName(shortClassName(c)), c);
newFunctionsDefined();
}
return c;
}
final public GazelleV_LeftArrowScript.FunctionDef export(GazelleV_LeftArrowScript.FunctionDef def) {
return exportFunction(def);
}
public GazelleV_LeftArrowScript.FunctionDef exportFunction(GazelleV_LeftArrowScript.FunctionDef def) {
return def == null ? null : exportFunction(def.name, def);
}
final public GazelleV_LeftArrowScript.FunctionDef export(String name, GazelleV_LeftArrowScript.FunctionDef def) {
return exportFunction(name, def);
}
public GazelleV_LeftArrowScript.FunctionDef exportFunction(String name, GazelleV_LeftArrowScript.FunctionDef def) {
projectWideFunctionDefs.put(name, def);
newFunctionsDefined();
return def;
}
final public GazelleV_LeftArrowScript.FunctionDef unexport(String name) {
return unexportFunction(name);
}
public GazelleV_LeftArrowScript.FunctionDef unexportFunction(String name) {
GazelleV_LeftArrowScript.FunctionDef f = projectWideFunctionDefs.remove(name);
if (f != null) {
print("Undefined function " + name);
newFunctionsDefined();
}
return f;
}
public void newFunctionsDefined() {
masterStuff().newClassesDefined();
recompileDate = tsNow();
}
public boolean shouldRecompile(LASCompileResult cr) {
return recompileDate != null && cr.compilationStart() != null && cr.compilationStart().compareTo(recompileDate) < 0;
}
public boolean compileResultValid(LASCompileResult cr, String code) {
return cr != null && eq(cr.script, code) && !shouldRecompile(cr);
}
public String toString() {
return "G22Utils for " + projectName();
}
public void editScript(G22LeftArrowScript script) {
projectActions().editScript(script);
}
public JButton editButton(String toolTip, Runnable action) {
return jimageButtonScaledToWidth(16, "#1103068", toolTip, action);
}
public JButton editScriptButton(G22LeftArrowScript script) {
return editButton("Edit script", () -> projectActions().editScript(script));
}
public G22ScriptView scriptView(long scriptID) {
return new G22ScriptView(getScript(scriptID));
}
public File gazelleJar() {
return getBytecodePathForClass(this);
}
public List projectErrors() {
return projectActions().projectErrors();
}
public JComponent jErrorView(Throwable e) {
var view = main.jErrorView(e);
var scriptErrors = instancesOf(GazelleV_LeftArrowScript.ScriptError.class, allCausesIncludingSelf(e));
var sources = mapNotNulls(scriptErrors, __11 -> __11.tokenRangeWithSrc());
if (empty(sources))
return view;
sources = uniquifySources(sources);
return centerAndEastWithMargin(view, jline(map(sources, src -> jThreadedButton(str_shorten(src, 40), () -> projectActions().goToSource(src)))));
}
public List uniquifySources(List sources) {
return uniquifyWith(sources, src -> pair(src.sourceInfo, src.renderRange()));
}
public structure_Data makeStructureData() {
return concepts().makeStructureData();
}
public String g22struct(Object o) {
return struct(o, makeStructureData());
}
public Object g22unstruct(String struct) {
return unstructure(struct, classFinder());
}
}
static public class DynamicVStack extends DynamicStack {
transient public IF0 _componentConstraints;
public GridBagConstraints _componentConstraints() {
return _componentConstraints != null ? _componentConstraints.get() : _componentConstraints_base();
}
final public GridBagConstraints _componentConstraints_fallback(IF0 _f) {
return _f != null ? _f.get() : _componentConstraints_base();
}
public GridBagConstraints _componentConstraints_base() {
return gridBagConstraints_vstack_1(spacing);
}
public GridBagConstraints _fillerConstraints() {
return gridBagConstraints_vstack_rest();
}
}
static public class G22LeftArrowScript extends ConceptWithChangeListeners {
static final public String _fieldOrder = "description text clearedForAutoRun editingText importNote runOnProjectOpen runOrder runCount lastResultByMode supercededBy metaCode compileResultForAutoRun compileResultForSaved compileResultForEditing";
public transient FieldVar varDescription_cache;
public FieldVar varDescription() {
if (varDescription_cache == null)
varDescription_cache = varDescription_load();
return varDescription_cache;
}
public FieldVar varDescription_load() {
return new FieldVar(this, "description", () -> description(), description -> description(description));
}
final public G22LeftArrowScript setDescription(String description) {
return description(description);
}
public G22LeftArrowScript description(String description) {
if (!eq(this.description, description)) {
this.description = description;
change();
}
return this;
}
final public String getDescription() {
return description();
}
public String description() {
return description;
}
public String description;
public transient FieldVar varText_cache;
public FieldVar varText() {
if (varText_cache == null)
varText_cache = varText_load();
return varText_cache;
}
public FieldVar varText_load() {
return new FieldVar(this, "text", () -> text(), text -> text(text));
}
final public G22LeftArrowScript setText(String text) {
return text(text);
}
public G22LeftArrowScript text(String text) {
if (!eq(this.text, text)) {
this.text = text;
change();
}
return this;
}
final public String getText() {
return text();
}
public String text() {
return text;
}
public String text;
public transient FieldVar> varClearedForAutoRun_cache;
public FieldVar> varClearedForAutoRun() {
if (varClearedForAutoRun_cache == null)
varClearedForAutoRun_cache = varClearedForAutoRun_load();
return varClearedForAutoRun_cache;
}
public FieldVar> varClearedForAutoRun_load() {
return new FieldVar>(this, "clearedForAutoRun", () -> clearedForAutoRun(), clearedForAutoRun -> clearedForAutoRun(clearedForAutoRun));
}
final public G22LeftArrowScript setClearedForAutoRun(ClearForAutoRun clearedForAutoRun) {
return clearedForAutoRun(clearedForAutoRun);
}
public G22LeftArrowScript clearedForAutoRun(ClearForAutoRun clearedForAutoRun) {
if (!eq(this.clearedForAutoRun, clearedForAutoRun)) {
this.clearedForAutoRun = clearedForAutoRun;
change();
}
return this;
}
final public ClearForAutoRun getClearedForAutoRun() {
return clearedForAutoRun();
}
public ClearForAutoRun clearedForAutoRun() {
return clearedForAutoRun;
}
public ClearForAutoRun clearedForAutoRun;
public transient FieldVar varEditingText_cache;
public FieldVar varEditingText() {
if (varEditingText_cache == null)
varEditingText_cache = varEditingText_load();
return varEditingText_cache;
}
public FieldVar varEditingText_load() {
return new FieldVar(this, "editingText", () -> editingText(), editingText -> editingText(editingText));
}
final public G22LeftArrowScript setEditingText(String editingText) {
return editingText(editingText);
}
public G22LeftArrowScript editingText(String editingText) {
if (!eq(this.editingText, editingText)) {
this.editingText = editingText;
change();
}
return this;
}
final public String getEditingText() {
return editingText();
}
public String editingText() {
return editingText;
}
public String editingText;
public transient FieldVar varImportNote_cache;
public FieldVar varImportNote() {
if (varImportNote_cache == null)
varImportNote_cache = varImportNote_load();
return varImportNote_cache;
}
public FieldVar varImportNote_load() {
return new FieldVar(this, "importNote", () -> importNote(), importNote -> importNote(importNote));
}
final public G22LeftArrowScript setImportNote(String importNote) {
return importNote(importNote);
}
public G22LeftArrowScript importNote(String importNote) {
if (!eq(this.importNote, importNote)) {
this.importNote = importNote;
change();
}
return this;
}
final public String getImportNote() {
return importNote();
}
public String importNote() {
return importNote;
}
public String importNote;
public transient FieldVar varRunOnProjectOpen_cache;
public FieldVar varRunOnProjectOpen() {
if (varRunOnProjectOpen_cache == null)
varRunOnProjectOpen_cache = varRunOnProjectOpen_load();
return varRunOnProjectOpen_cache;
}
public FieldVar varRunOnProjectOpen_load() {
return new FieldVar(this, "runOnProjectOpen", () -> runOnProjectOpen(), runOnProjectOpen -> runOnProjectOpen(runOnProjectOpen));
}
final public G22LeftArrowScript setRunOnProjectOpen(boolean runOnProjectOpen) {
return runOnProjectOpen(runOnProjectOpen);
}
public G22LeftArrowScript runOnProjectOpen(boolean runOnProjectOpen) {
if (!eq(this.runOnProjectOpen, runOnProjectOpen)) {
this.runOnProjectOpen = runOnProjectOpen;
change();
}
return this;
}
final public boolean getRunOnProjectOpen() {
return runOnProjectOpen();
}
public boolean runOnProjectOpen() {
return runOnProjectOpen;
}
public boolean runOnProjectOpen = false;
public transient FieldVar varRunOrder_cache;
public FieldVar varRunOrder() {
if (varRunOrder_cache == null)
varRunOrder_cache = varRunOrder_load();
return varRunOrder_cache;
}
public FieldVar varRunOrder_load() {
return new FieldVar(this, "runOrder", () -> runOrder(), runOrder -> runOrder(runOrder));
}
final public G22LeftArrowScript setRunOrder(String runOrder) {
return runOrder(runOrder);
}
public G22LeftArrowScript runOrder(String runOrder) {
if (!eq(this.runOrder, runOrder)) {
this.runOrder = runOrder;
change();
}
return this;
}
final public String getRunOrder() {
return runOrder();
}
public String runOrder() {
return runOrder;
}
public String runOrder;
public long runCount;
public Map>> lastResultByMode;
public Ref supercededBy = new Ref();
public transient FieldVar varMetaCode_cache;
public FieldVar varMetaCode() {
if (varMetaCode_cache == null)
varMetaCode_cache = varMetaCode_load();
return varMetaCode_cache;
}
public FieldVar varMetaCode_load() {
return new FieldVar(this, "metaCode", () -> metaCode(), metaCode -> metaCode(metaCode));
}
final public G22LeftArrowScript setMetaCode(String metaCode) {
return metaCode(metaCode);
}
public G22LeftArrowScript metaCode(String metaCode) {
if (!eq(this.metaCode, metaCode)) {
this.metaCode = metaCode;
change();
}
return this;
}
final public String getMetaCode() {
return metaCode();
}
public String metaCode() {
return metaCode;
}
public String metaCode;
public void _doneLoading2() {
super._doneLoading2();
cMigrateField(this, "code", "text");
}
public String myType() {
return dropPrefix("G22", shortClassName(this));
}
public String toString() {
if (empty(description))
return myType() + " " + id;
else
return "Script " + id + ": " + description;
}
public void initEditingText() {
editingText(unnull(or(editingText, text)));
}
public void receiveEditingText(String text) {
editingText(text);
}
public String stableText() {
return text;
}
final public void save() {
completeEdit();
}
public void completeEdit() {
String t = editingText;
if (t != null) {
setTextWithHistory(t);
}
}
public void setTextWithHistory(String text) {
if (eq(this.text, text))
return;
text(text);
saveTextToHistory();
}
public void discardEdit() {
String text = editedText();
if (text == null)
return;
saveFieldToHistory("discardingEdit", text);
editingText(null);
}
public String textForEditing() {
initEditingText();
return editingText;
}
public File historyFile() {
return fileInConceptsDir("History/" + shortDynName(this) + id + ".history");
}
public void saveTextToHistory() {
saveFieldToHistory("text", text);
}
public void saveFieldToHistory(String field, String value) {
File historyFile = historyFile();
if (historyFile == null)
return;
String contents = value == null ? " empty" : " (" + nLines(value) + ", " + nChars(value) + "):\n" + indentx(value) + "\n" + "\n";
appendToTextFile(historyFile, "\n===\n" + "Concept ID: " + id + "\n" + "Date: " + dateWithMSUTC() + "\n" + firstToUpper(field) + contents + "===" + "\n");
}
public boolean isSaved() {
return text != null;
}
public boolean isSavedDistinctFromAutoRunVersion() {
return isSaved() && !eq(text, codeForAutoRun());
}
public boolean isEditing() {
return editedText() != null;
}
public boolean isClearForAutoRun() {
return clearedForAutoRun != null;
}
public String editedText() {
return eq(editingText, text) ? null : editingText;
}
public String codeForAutoRun() {
return getVar(clearedForAutoRun());
}
public String safestCode() {
return or(codeForAutoRun(), stableText());
}
public void clearForAutoRun() {
if (!isSaved())
return;
String text = text();
saveFieldToHistory("Auto-runnable code", text);
clearedForAutoRun(new ClearForAutoRun(text));
}
public void forgetAutoRunCode() {
if (!isClearForAutoRun())
return;
saveFieldToHistory("Auto-runnable code", null);
clearedForAutoRun(null);
compileResultForAutoRun = null;
}
public void forgetCompileResults() {
compileResultForAutoRun = compileResultForSaved = null;
}
public G22Utils g22utils() {
return assertNotNull("g22utils", main.g22utils(_concepts()));
}
public GazelleV_LeftArrowScriptParser makeParser() {
return g22utils().leftArrowParser().sourceInfo(this);
}
public LASCompileResult newCompileResult() {
return new LASCompileResult();
}
public LASCompileResult returnOrCompile(LASCompileResult lastCompileResult, String code) {
if (g22utils().compileResultValid(lastCompileResult, code))
return lastCompileResult;
var cr = newCompileResult();
cr.script(code);
var parser = makeParser();
cr.parser(parser);
cr.compile();
return cr;
}
transient public LASCompileResult compileResultForAutoRun;
public LASCompileResult compileForAutoRun() {
String code = codeForAutoRun();
if (code == null)
return null;
var cr = returnOrCompile(compileResultForAutoRun, code);
return compileResultForAutoRun = cr;
}
transient public LASCompileResult compileResultForSaved;
public LASCompileResult compileSaved() {
String code = stableText();
if (code == null)
return null;
var cr = returnOrCompile(compileResultForSaved, code);
return compileResultForSaved = cr;
}
transient public LASCompileResult compileResultForEditing;
public LASCompileResult compileEditing() {
String code = editingText();
if (code == null)
return null;
var cr = returnOrCompile(compileResultForEditing, code);
return compileResultForEditing = cr;
}
public LASCompileResult safestCompileResult() {
{
var __1 = compileForAutoRun();
if (__1 != null)
return __1;
}
return compileSaved();
}
public LASCompileResult latestCompileResult() {
{
var __2 = compileEditing();
if (__2 != null)
return __2;
}
{
var __3 = compileSaved();
if (__3 != null)
return __3;
}
return compileForAutoRun();
}
public LASCompileResult latestRunnableCompileResult() {
var cr = compileEditing();
if (cr != null && cr.runnable())
return cr;
cr = compileSaved();
if (cr != null && cr.runnable())
return cr;
cr = compileForAutoRun();
if (cr != null && cr.runnable())
return cr;
return null;
}
public Object evaluateWithoutTimeout() {
var cr = safestCompileResult();
if (cr == null)
throw fail("Not saved: " + this);
AutoCloseable __4 = g22utils().enter();
try {
return cr.parsedScriptMandatory().get();
} finally {
_close(__4);
}
}
public Object evaluateAutoRunWithoutTimeout() {
var cr = compileForAutoRun();
if (cr == null)
throw fail("Not cleared for auto-run: " + this);
AutoCloseable __5 = g22utils().enter();
try {
return cr.parsedScriptMandatory().get();
} finally {
_close(__5);
}
}
public String renderRunOnProjectOpenStatus() {
return runOnProjectOpen ? "Yes" + appendBracketed(appendPrefixIfNempty("prio ", runOrder)) : null;
}
public Set allTexts() {
return asSet(llNonNulls(text(), editedText(), codeForAutoRun()));
}
}
static public class LASCompileResult {
final public LASCompileResult setScript(String script) {
return script(script);
}
public LASCompileResult script(String script) {
this.script = script;
return this;
}
final public String getScript() {
return script();
}
public String script() {
return script;
}
public String script;
final public LASCompileResult setParser(GazelleV_LeftArrowScriptParser parser) {
return parser(parser);
}
public LASCompileResult parser(GazelleV_LeftArrowScriptParser parser) {
this.parser = parser;
return this;
}
final public GazelleV_LeftArrowScriptParser getParser() {
return parser();
}
public GazelleV_LeftArrowScriptParser parser() {
return parser;
}
public GazelleV_LeftArrowScriptParser parser;
final public LASCompileResult setCompileError(Throwable compileError) {
return compileError(compileError);
}
public LASCompileResult compileError(Throwable compileError) {
this.compileError = compileError;
return this;
}
final public Throwable getCompileError() {
return compileError();
}
public Throwable compileError() {
return compileError;
}
public Throwable compileError;
public GazelleV_LeftArrowScript.Script parsedScript;
public RunResultWithTimestamps compileLog;
public String toString() {
if (compileError != null)
return errorToString();
if (parsedScript == null)
return "Not compiled yet";
return "Compiled OK" + (compileLog == null ? "" : " in " + n2(max(1, compileLog.duration().toMillis())) + " ms");
}
public boolean hasError() {
return compileError != null;
}
public String errorToString() {
return exceptionToStringShorter_dontDropOuterExceptions(compileError);
}
public boolean runnable() {
return parsedScript != null;
}
public void compile() {
compileLog = runResultWithTimestamps_dontPrintStackTrace(() -> {
if (parser == null)
parser = makeParser();
return parsedScript = parser.parse(script);
});
if (compileLog.isError()) {
var e = compileLog.getError();
compileError(e);
}
}
final public GazelleV_LeftArrowScript.Script get() {
return parsedScript();
}
public GazelleV_LeftArrowScript.Script parsedScript() {
return parsedScript;
}
public GazelleV_LeftArrowScript.Script parsedScriptMandatory() {
if (compileError != null)
throw fail(compileError);
return parsedScript;
}
transient public IF0 makeParser;
public GazelleV_LeftArrowScriptParser makeParser() {
return makeParser != null ? makeParser.get() : makeParser_base();
}
final public GazelleV_LeftArrowScriptParser makeParser_fallback(IF0 _f) {
return _f != null ? _f.get() : makeParser_base();
}
public GazelleV_LeftArrowScriptParser makeParser_base() {
return null;
}
public LineAndColumn errorLineAndCol() {
return parseLineAndColumn(str(compileError));
}
public Timestamp compilationStart() {
return compileLog == null ? null : compileLog.started;
}
}
public interface IF0WithChangeListeners extends IF0, IHasChangeListeners {
}
static public class ClassNameResolver {
final public ClassNameResolver setByteCodePath(File byteCodePath) {
return byteCodePath(byteCodePath);
}
public ClassNameResolver byteCodePath(File byteCodePath) {
this.byteCodePath = byteCodePath;
return this;
}
final public File getByteCodePath() {
return byteCodePath();
}
public File byteCodePath() {
return byteCodePath;
}
public File byteCodePath = byteCodePathForClass(getClass());
public List importedPackages = itemPlusList("java.lang", endingWith_dropSuffix(standardImports(), ".*"));
public Set allFullyQualifiedClassNames_cache;
public Set allFullyQualifiedClassNames() {
if (allFullyQualifiedClassNames_cache == null)
allFullyQualifiedClassNames_cache = allFullyQualifiedClassNames_load();
return allFullyQualifiedClassNames_cache;
}
public Set allFullyQualifiedClassNames_load() {
Set set = new HashSet();
assertNotNull(byteCodePath);
set.addAll(classNamesInJarOrDir(byteCodePath));
printVars("ClassNameResolver", "byteCodePath", byteCodePath, "classesFound", l(set));
set.addAll(classNamesInLoadedJigsawModules());
return set;
}
public ClassNameResolver init() {
allFullyQualifiedClassNames();
return this;
}
public String findClass(String name) {
for (String pkg : importedPackages) {
String fullName = pkg + "." + name;
if (allFullyQualifiedClassNames().contains(fullName))
return fullName;
}
return null;
}
public void printMe() {
printVars("ClassNameResolver", "byteCodePath", byteCodePath);
print("importedPackages", importedPackages);
}
}
static public class G22GalleryImage extends ConceptWithChangeListeners {
public transient FieldVar varPath_cache;
public FieldVar varPath() {
if (varPath_cache == null)
varPath_cache = varPath_load();
return varPath_cache;
}
public FieldVar varPath_load() {
return new FieldVar(this, "path", () -> path(), path -> path(path));
}
final public G22GalleryImage setPath(File path) {
return path(path);
}
public G22GalleryImage path(File path) {
if (!eq(this.path, path)) {
this.path = path;
change();
}
return this;
}
final public File getPath() {
return path();
}
public File path() {
return path;
}
public File path;
public String toString() {
return fileName(path);
}
public boolean imageExists() {
return fileExists(path);
}
final public BufferedImage image() {
return load();
}
final public BufferedImage getImage() {
return load();
}
public BufferedImage load() {
return loadImage2(path);
}
public File imageFile() {
return path;
}
}
static public class G22ProjectInfo extends Concept {
static final public String _fieldOrder = "projectID projectDir defaultMaskSize compilationDate historicalProjectDirs useFirefox";
final public String getProjectID() {
return projectID();
}
public String projectID() {
return projectID;
}
public String projectID = aGlobalID();
public File projectDir;
final public G22MaskSize getDefaultMaskSize() {
return defaultMaskSize();
}
public G22MaskSize defaultMaskSize() {
return defaultMaskSize;
}
public G22MaskSize defaultMaskSize = new G22MaskSize();
public String compilationDate;
public List historicalProjectDirs = new ArrayList();
final public boolean getUseFirefox() {
return useFirefox();
}
public boolean useFirefox() {
return useFirefox;
}
public boolean useFirefox = false;
public void addHistoricalProjectDir(File dir) {
if (syncSetAdd(historicalProjectDirs, dir))
change();
}
}
static public class ImageSurface extends Surface {
public BufferedImage image;
public double zoomX = 1, zoomY = 1, zoomFactor = 1.5;
public Rectangle selection;
public List tools = new ArrayList();
public Object overlay;
public List overlays = syncL();
public Runnable onSelectionChange;
final public ImageSurface setVerbose(boolean verbose) {
return verbose(verbose);
}
public ImageSurface verbose(boolean verbose) {
this.verbose = verbose;
return this;
}
final public boolean getVerbose() {
return verbose();
}
public boolean verbose() {
return verbose;
}
public boolean verbose = false;
public boolean noMinimumSize = true;
public String titleForUpload;
public Object onZoom;
public boolean specialPurposed = false;
final public ImageSurface setAllowPaste(boolean allowPaste) {
return allowPaste(allowPaste);
}
public ImageSurface allowPaste(boolean allowPaste) {
this.allowPaste = allowPaste;
return this;
}
final public boolean getAllowPaste() {
return allowPaste();
}
public boolean allowPaste() {
return allowPaste;
}
public boolean allowPaste = false;
final public ImageSurface setZoomable(boolean zoomable) {
return zoomable(zoomable);
}
public ImageSurface zoomable(boolean zoomable) {
this.zoomable = zoomable;
return this;
}
final public boolean getZoomable() {
return zoomable();
}
public boolean zoomable() {
return zoomable;
}
public boolean zoomable = true;
public boolean noAlpha = false;
public Object interpolationMode = RenderingHints.VALUE_INTERPOLATION_BILINEAR;
public Object onNewImage;
public BufferedImage imageToDraw;
public File file;
public boolean autoZoomToDisplay = false;
final public ImageSurface setRepaintInThread(boolean repaintInThread) {
return repaintInThread(repaintInThread);
}
public ImageSurface repaintInThread(boolean repaintInThread) {
this.repaintInThread = repaintInThread;
return this;
}
final public boolean getRepaintInThread() {
return repaintInThread();
}
public boolean repaintInThread() {
return repaintInThread;
}
public boolean repaintInThread = false;
public BoolVar showingVar;
public Pt mousePosition;
transient public Set onMousePositionChanged;
public ImageSurface onMousePositionChanged(Runnable r) {
onMousePositionChanged = createOrAddToSyncLinkedHashSet(onMousePositionChanged, r);
return this;
}
public ImageSurface removeMousePositionChangedListener(Runnable r) {
main.remove(onMousePositionChanged, r);
return this;
}
public void mousePositionChanged() {
if (onMousePositionChanged != null)
for (var listener : onMousePositionChanged) pcallF_typed(listener);
}
transient public Set onImageChanged;
public ImageSurface onImageChanged(Runnable r) {
onImageChanged = createOrAddToSyncLinkedHashSet(onImageChanged, r);
return this;
}
public ImageSurface removeImageChangedListener(Runnable r) {
main.remove(onImageChanged, r);
return this;
}
public void imageChanged() {
if (onImageChanged != null)
for (var listener : onImageChanged) pcallF_typed(listener);
}
transient public Set> onUserModifiedImage;
public ImageSurface onUserModifiedImage(IVF1 f) {
onUserModifiedImage = createOrAddToSyncLinkedHashSet(onUserModifiedImage, f);
return this;
}
public ImageSurface removeUserModifiedImageListener(IVF1 f) {
main.remove(onUserModifiedImage, f);
return this;
}
public void userModifiedImage(BufferedImage image) {
if (onUserModifiedImage != null)
for (var listener : onUserModifiedImage) pcallF_typed(listener, image);
}
public ImageSurface() {
this(dummyImage());
}
static public BufferedImage dummyImage() {
return whiteImage(1);
}
public ImageSurface(File file) {
setImage(file);
}
public ImageSurface(MakesBufferedImage image) {
this(image != null ? image.getBufferedImage() : dummyImage());
}
public ImageSurface(BufferedImage image) {
setImage(image);
clearSurface = false;
bindToComponent(this, () -> performAutoZoom(), null);
onResize(this, () -> performAutoZoom());
onEnclosingScrollPaneResize(this, () -> performAutoZoom());
componentPopupMenu2(this, ImageSurface_popupMenuMaker());
new ImageSurfaceSelector(this);
jHandleFileDrop(this, new VF1() {
public void get(File f) {
try {
setImage(loadBufferedImage(f));
} catch (Exception __e) {
throw rethrow(__e);
}
}
public String toString() {
return "setImage(loadBufferedImage(f))";
}
});
imageSurfaceOnHover(this, p -> {
mousePosition = p;
mousePositionChanged();
});
}
public ImageSurface(RGBImage image, double zoom) {
this(image);
setZoom(zoom);
}
public void fillPopupMenu(JPopupMenu menu, final Point point) {
if (zoomable) {
JMenuItem miZoomReset = new JMenuItem("Zoom 100%");
miZoomReset.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent evt) {
setZoom(1.0);
centerPoint(point);
}
});
menu.add(miZoomReset);
JMenuItem miZoomIn = new JMenuItem("Zoom in");
miZoomIn.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent evt) {
zoomIn(zoomFactor);
centerPoint(point);
}
});
menu.add(miZoomIn);
JMenuItem miZoomOut = new JMenuItem("Zoom out");
miZoomOut.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent evt) {
zoomOut(zoomFactor);
centerPoint(point);
}
});
menu.add(miZoomOut);
menu.add(jMenuItemStayCheckedOnClick("Zoom to window", () -> autoZoomToDisplay, () -> setAutoZoomToDisplay(true)));
addMenuItem(menu, "Show full screen", new Runnable() {
public void run() {
try {
showFullScreen();
} catch (Exception __e) {
throw rethrow(__e);
}
}
public String toString() {
return "showFullScreen()";
}
});
addMenuItem(menu, "Point: " + point.x + "," + point.y + " (image: " + w() + "*" + h() + ")", null);
menu.addSeparator();
}
if (!specialPurposed)
addMenuItem(menu, "Load image...", new Runnable() {
public void run() {
try {
selectFile("Load image", new VF1() {
public void get(File f) {
try {
setImage(loadImage2(f));
} catch (Exception __e) {
throw rethrow(__e);
}
}
public String toString() {
return "setImage(loadImage2(f))";
}
});
} catch (Exception __e) {
throw rethrow(__e);
}
}
public String toString() {
return "selectFile(\"Load image\",\r\n new VF1() { public void get(File f) c...";
}
});
addMenuItem(menu, "Save image...", new Runnable() {
public void run() {
try {
saveImage();
} catch (Exception __e) {
throw rethrow(__e);
}
}
public String toString() {
return "saveImage()";
}
});
addMenuItem(menu, "Copy image to clipboard", new Runnable() {
public void run() {
try {
copyImageToClipboard(getImage());
} catch (Exception __e) {
throw rethrow(__e);
}
}
public String toString() {
return "copyImageToClipboard(getImage())";
}
});
if (!specialPurposed || allowPaste)
addMenuItem(menu, "Paste image from clipboard", new Runnable() {
public void run() {
try {
loadFromClipboard();
} catch (Exception __e) {
throw rethrow(__e);
}
}
public String toString() {
return "loadFromClipboard()";
}
});
if (!specialPurposed)
addMenuItem(menu, "Load image snippet...", new Runnable() {
public void run() {
try {
selectImageSnippet(new VF1() {
public void get(String imageID) {
try {
setImage(loadImage2(imageID));
} catch (Exception __e) {
throw rethrow(__e);
}
}
public String toString() {
return "setImage(loadImage2(imageID))";
}
});
} catch (Exception __e) {
throw rethrow(__e);
}
}
public String toString() {
return "selectImageSnippet(new VF1() { public void get(String imageID) ctex {...";
}
});
if (selection != null)
addMenuItem(menu, "Crop", new Runnable() {
public void run() {
try {
crop();
} catch (Exception __e) {
throw rethrow(__e);
}
}
public String toString() {
return "crop()";
}
});
if (!specialPurposed)
addMenuItem(menu, "No image", new Runnable() {
public void run() {
try {
noImage();
} catch (Exception __e) {
throw rethrow(__e);
}
}
public String toString() {
return "noImage()";
}
});
}
public void noImage() {
setImage((BufferedImage) null);
}
public void crop() {
if (selection == null)
return;
BufferedImage img = cloneClipBufferedImage(getImage(), selection);
selection = null;
setUserModifiedImage(img);
}
public void setUserModifiedImage(BufferedImage img) {
setImage(img);
userModifiedImage(img);
}
public void loadFromClipboard() {
BufferedImage img = getImageFromClipboard();
if (img != null)
setUserModifiedImage(img);
}
transient public IF0 defaultImageDir;
public File defaultImageDir() {
return defaultImageDir != null ? defaultImageDir.get() : defaultImageDir_base();
}
final public File defaultImageDir_fallback(IF0 _f) {
return _f != null ? _f.get() : defaultImageDir_base();
}
public File defaultImageDir_base() {
return getProgramDir();
}
public void saveImage() {
var image = getImage();
JFileChooser fileChooser = new JFileChooser(defaultImageDir());
if (fileChooser.showSaveDialog(this) == JFileChooser.APPROVE_OPTION) {
try {
main.saveImage(image, file = fileChooser.getSelectedFile());
} catch (Throwable e) {
popup(e);
}
}
}
public void drawImageItself(int w, int h, Graphics2D g) {
int iw = getZoomedWidth(), ih = getZoomedHeight();
if (interpolationMode == RenderingHints.VALUE_INTERPOLATION_NEAREST_NEIGHBOR || zoomX >= 1 || zoomY >= 1) {
g.drawImage(image, 0, 0, iw, ih, null);
} else
g.drawImage(resizeImage(image, iw, ih), 0, 0, null);
}
transient public IVF3 drawBackground;
public void drawBackground(int w, int h, Graphics2D g) {
if (drawBackground != null)
drawBackground.get(w, h, g);
else
drawBackground_base(w, h, g);
}
final public void drawBackground_fallback(IVF3 _f, int w, int h, Graphics2D g) {
if (_f != null)
_f.get(w, h, g);
else
drawBackground_base(w, h, g);
}
public void drawBackground_base(int w, int h, Graphics2D g) {
g.setColor(or(getBackground(), Color.white));
g.fillRect(0, 0, w, h);
}
public void render(int w, int h, Graphics2D g) {
if (verbose)
_print("render");
g.setRenderingHint(RenderingHints.KEY_INTERPOLATION, interpolationMode);
drawBackground(w, h, g);
BufferedImage image = or(imageToDraw, this.image);
if (!hasImage())
drawBackground(w, h, g);
else {
boolean alpha = !noAlpha && hasTransparency(image);
if (alpha)
drawBackground(w, h, g);
drawImageItself(w, h, g);
int iw = getZoomedWidth(), ih = getZoomedHeight();
if (!alpha) {
g.fillRect(iw, 0, w - iw, h);
g.fillRect(0, ih, iw, h - ih);
}
}
if (overlay != null) {
if (verbose)
_print("render overlay");
pcallF(overlay, g);
}
for (var overlay : cloneList(overlays)) {
try {
overlay.drawOn(cloneGraphics(g));
} catch (Throwable __e) {
pcallFail(__e);
}
}
if (selection != null) {
if (verbose)
_print("render selection");
drawSelectionRect(g, selection, Color.green, Color.white);
}
}
public void drawSelectionRect(Graphics2D g, Rectangle selection, Color green, Color white) {
drawSelectionRect(g, selection, green, white, zoomX, zoomY);
}
public void drawSelectionRect(Graphics2D g, Rectangle selection, Color green, Color white, double zoomX, double zoomY) {
g.setColor(green);
int top = (int) (selection.y * zoomY);
int bottom = (int) ((selection.y + selection.height) * zoomY);
int left = (int) (selection.x * zoomX);
int right = (int) ((selection.x + selection.width) * zoomX);
g.drawRect(left - 1, top - 1, right - left + 1, bottom - top + 1);
g.setColor(white);
g.drawRect(left - 2, top - 2, right - left + 3, bottom - top + 3);
}
public ImageSurface setZoom(double zoom) {
setZoom(zoom, zoom);
return this;
}
public void setZoom(double zoomX, double zoomY) {
autoZoomToDisplay = false;
setZoom_dontChangeAutoZoom(zoomX, zoomY);
}
public void setZoom_dontChangeAutoZoom(double zoomX) {
setZoom_dontChangeAutoZoom(zoomX, zoomX);
}
public void setZoom_dontChangeAutoZoom(double zoomX, double zoomY) {
if (this.zoomX == zoomX && this.zoomY == zoomY)
return;
if (verbose)
_print("Setting zoom");
this.zoomX = zoomX;
this.zoomY = zoomY;
revalidateMe();
repaint();
centerPoint(new Point(getImage().getWidth() / 2, getImage().getHeight() / 2));
pcallF(onZoom);
}
public Dimension getMinimumSize() {
if (metaGet("scaffolding") != null)
scaffoldCalled(this, "getMinimumSize");
if (noMinimumSize)
return new Dimension(1, 1);
int w = getZoomedWidth();
int h = getZoomedHeight();
Dimension min = super.getMinimumSize();
return printIfScaffoldingEnabled(this, new Dimension(Math.max(w, min.width), Math.max(h, min.height)));
}
public int getZoomedHeight() {
return (int) (h() * zoomY);
}
public int getZoomedWidth() {
return (int) (w() * zoomX);
}
public boolean isShowing_quick() {
if (showingVar == null) {
swing(() -> {
if (showingVar == null)
showingVar = componentShowingVar(ImageSurface.this);
});
}
return showingVar.get();
}
public void setImageIfShowing_thisThread(MakesBufferedImage image) {
setImageIfShowing_thisThread(toBufferedImage(image));
}
public void setImageIfShowing_thisThread(BufferedImage image) {
if (isShowing_quick())
setImage_thisThread(image);
}
public void setImage(File file) {
setFile(file);
setImage(loadImage2(file));
}
public void setImage(MakesBufferedImage image) {
swing(() -> {
setImage_thisThread(image);
});
}
public void setImage(BufferedImage img) {
swing(() -> {
setImage_thisThread(img);
});
}
public void setImage_thisThread(MakesBufferedImage img) {
setImage_thisThread(toBufferedImage(img));
}
public void setImage_thisThread(BufferedImage img) {
BufferedImage newImage = img != null ? img : dummyImage();
BufferedImage oldImage = image;
image = newImage;
if (verbose)
print("Old image size:" + imageSize(oldImage) + ", new image size: " + imageSize(newImage));
boolean sameSize = imagesHaveSameSize(oldImage, newImage);
if (!sameSize) {
if (verbose)
_print("New image size");
revalidateMe();
}
quickRepaint();
pcallF(onNewImage);
if (!sameSize && autoZoomToDisplay)
zoomToDisplaySize();
imageChanged();
}
public void setImageAndZoomToDisplay(BufferedImage img) {
setImage(img);
zoomToDisplaySize();
}
public BufferedImage getImage() {
return image;
}
public double getZoomX() {
return zoomX;
}
public double getZoomY() {
return zoomY;
}
public Dimension getPreferredSize() {
if (metaGet("scaffolding") != null)
scaffoldCalled(this, "getPreferredSize");
return printIfScaffoldingEnabled(this, new Dimension(getZoomedWidth(), getZoomedHeight()));
}
public JScrollPane makeScrollPane() {
JScrollPane scrollPane = new JScrollPane(this);
scrollPane.getViewport().setScrollMode(JViewport.BACKINGSTORE_SCROLL_MODE);
return scrollPane;
}
public void zoomToWindow() {
zoomToDisplaySize();
}
public void zoomToDisplaySize() {
swing(() -> {
if (!hasImage())
return;
Dimension display = getDisplaySize();
if (display.width == 0 || display.height == 0)
return;
int w = w(), h = h();
double xRatio = (display.width - 5) / (double) w;
double yRatio = (display.height - 5) / (double) h;
if (scaffoldingEnabled(this))
printVars("zoomToDisplaySize", "display", display, "w", w, "h", h, "xRatio", xRatio, "yRatio", yRatio);
setZoom_dontChangeAutoZoom(min(xRatio, yRatio));
revalidateMe();
});
}
private Dimension getDisplaySize() {
if (metaGet("scaffolding") != null)
scaffoldCalled(this, "getDisplaySize");
Container c = getParent();
while (c != null) {
if (c instanceof JScrollPane)
return c.getSize();
c = c.getParent();
}
return getSize();
}
public void setSelection(Rect r) {
setSelection(toRectangle(r));
}
public void setSelection(Rectangle r) {
if (neq(selection, r)) {
selection = r;
pcallF(onSelectionChange);
quickRepaint();
}
}
public Rectangle getSelection() {
return selection;
}
public RGBImage getRGBImage() {
return new RGBImage(getImage());
}
public void centerPoint(Point p) {
JScrollPane sp = enclosingScrollPane(this);
if (sp == null)
return;
p = new Point((int) (p.x * getZoomX()), (int) (p.y * getZoomY()));
final JViewport viewport = sp.getViewport();
Dimension viewSize = viewport.getExtentSize();
int x = max(0, p.x - viewSize.width / 2);
int y = max(0, p.y - viewSize.height / 2);
p = new Point(x, y);
final Point _p = p;
awtLater(new Runnable() {
public void run() {
try {
viewport.setViewPosition(_p);
} catch (Exception __e) {
throw rethrow(__e);
}
}
public String toString() {
return "viewport.setViewPosition(_p);";
}
});
}
public Pt pointFromEvent(MouseEvent e) {
return pointFromComponentCoordinates(new Pt(e.getX(), e.getY()));
}
public Pt pointFromComponentCoordinates(Pt p) {
return new Pt((int) (p.x / zoomX), (int) (p.y / zoomY));
}
public Pt pointToComponentCoordinates(double x, double y) {
return new Pt((int) (x * zoomX), (int) (y * zoomY));
}
public void uploadTheImage() {
}
public void showFullScreen() {
showFullScreenImageSurface(getImage());
}
public void zoomIn(double f) {
setZoom(getZoomX() * f, getZoomY() * f);
}
public void zoomOut(double f) {
setZoom(getZoomX() / f, getZoomY() / f);
}
public ImageSurface setFile(File f) {
file = f;
return this;
}
public void setOverlay(IVF1 overlay) {
this.overlay = overlay;
}
public boolean hasImage() {
return image != null;
}
public int w() {
return image.getWidth();
}
public int h() {
return image.getHeight();
}
final public void pixelate(boolean b) {
setPixelated(b);
}
public void setPixelated(boolean b) {
assertTrue(b);
imageSurface_pixelated(this);
}
final public ImageSurface autoZoomToDisplay(boolean b) {
return setAutoZoomToDisplay(b);
}
public ImageSurface setAutoZoomToDisplay(boolean b) {
if (autoZoomToDisplay = b)
zoomToDisplaySize();
return this;
}
public void quickRepaint() {
if (repaintInThread)
paintImmediately(0, 0, getWidth(), getHeight());
else
repaint();
}
public void setTool(ImageSurfaceMouseHandler tool) {
swing(() -> {
removeAllTools();
addTool(tool);
});
}
public boolean hasTool(AutoCloseable tool) {
return swing(() -> tools.contains(tool));
}
public void addTool(ImageSurfaceMouseHandler tool) {
swing(() -> {
if (!tools.contains(tool))
tool.register(this);
});
}
public void removeTool(AutoCloseable tool) {
swing(() -> {
if (tools.contains(tool)) {
close(tool);
tools.remove(tool);
}
});
}
final public void clearTools() {
removeAllTools();
}
public void removeAllTools() {
closeAllAndClear(tools);
}
public void performAutoZoom() {
if (autoZoomToDisplay)
zoomToDisplaySize();
}
public void revalidateMe() {
revalidateIncludingFullCenterContainer(this);
}
public void addOverlay(G2Drawable overlay) {
overlays.add(overlay);
repaint();
}
public void clearOverlays() {
if (nempty(overlays)) {
overlays.clear();
repaint();
}
}
public void setOverlay(G2Drawable overlay) {
clearOverlays();
if (overlay != null)
addOverlay(overlay);
}
public void loadImage(File f) {
setImage(loadImage2(f));
}
public JComponent visualize() {
return jscroll_center_borderless(this);
}
public void standardZoom() {
setZoom(1.0);
}
public A print(A a) {
return print("", a);
}
public A print(String msg, A a) {
return _print(msg, a);
}
}
static public VF2 ImageSurface_popupMenuMaker() {
return new VF2() {
public void get(ImageSurface is, JPopupMenu menu) {
try {
Point p = is.pointFromEvent(componentPopupMenu_mouseEvent.get()).getPoint();
is.fillPopupMenu(menu, p);
} catch (Exception __e) {
throw rethrow(__e);
}
}
public String toString() {
return "Point p = is.pointFromEvent(componentPopupMenu_mouseEvent.get()).getPoint();\r...";
}
};
}
static public class CombinedStringifier implements IStringifier {
public CopyOnWriteArrayList> stringifiers = new CopyOnWriteArrayList();
public IStringifier defaultStringifier = new Stringifier_ToString();
public CombinedStringifier(IPartialStringifier... stringifiers) {
addAll(this.stringifiers, stringifiers);
}
public String toString(A o) {
for (var stringifier : stringifiers) {
String s = stringifier.toStringOpt(o);
if (s != null)
return s;
}
return defaultStringifier.toString(o);
}
public String toString() {
return formatFunctionCall("CombinedStringifier", listPlus((List) stringifiers, defaultStringifier));
}
}
static public class WrappedCloseable implements IAutoCloseableF0 {
public WrappedCloseable() {
}
public A closeable;
public WrappedCloseable(A closeable) {
this.closeable = closeable;
}
public A get() {
return closeable;
}
public void close() {
try {
beforeClose();
main.close(closeable);
} catch (Exception __e) {
throw rethrow(__e);
}
}
public void beforeClose() {
}
}
static public class ConceptWithChangeListeners extends Concept implements IHasChangeListeners, ChangeTriggerable {
transient public Set onChange;
public ConceptWithChangeListeners onChange(Runnable r) {
onChange = createOrAddToSyncLinkedHashSet(onChange, r);
return this;
}
public ConceptWithChangeListeners removeChangeListener(Runnable r) {
main.remove(onChange, r);
return this;
}
public void fireChange() {
if (onChange != null)
for (var listener : onChange) pcallF_typed(listener);
}
public void _onChange() {
super._onChange();
fireChange();
}
public void change() {
super.change();
}
}
static public class FieldVar extends VarWithNotify {
public IHasChangeListeners containingObject;
public String fieldName;
public IF0 getter;
public IVF1 setter;
public FieldVar(IHasChangeListeners containingObject, String fieldName, IF0 getter, IVF1 setter) {
this.setter = setter;
this.getter = getter;
this.fieldName = fieldName;
this.containingObject = containingObject;
containingObject.onChangeAndNow(() -> _updateFromObject());
}
public void _updateFromObject() {
set(getter.get());
}
public void fireChange() {
setter.get(get());
super.fireChange();
}
public FieldVar onChange(IVF1 r) {
if (r != null)
onChange(() -> r.get(get()));
return this;
}
}
static public class ListAndIndex implements IFieldsToList {
static final public String _fieldOrder = "list idx";
public List list;
public int idx;
public ListAndIndex() {
}
public ListAndIndex(List list, int idx) {
this.idx = idx;
this.list = list;
}
public boolean equals(Object o) {
if (!(o instanceof ListAndIndex))
return false;
ListAndIndex __1 = (ListAndIndex) o;
return eq(list, __1.list) && idx == __1.idx;
}
public int hashCode() {
int h = 276903961;
h = boostHashCombine(h, _hashCode(list));
h = boostHashCombine(h, _hashCode(idx));
return h;
}
public Object[] _fieldsToList() {
return new Object[] { list, idx };
}
public boolean atEnd() {
return idx >= l(list);
}
public A get() {
return _get(list, idx);
}
public int size() {
return l(list);
}
public String toString() {
return subList(list, 0, idx) + ", then " + subList(list, idx);
}
public ListAndIndex plus(int ofs) {
return new ListAndIndex(list, idx + ofs);
}
public ListAndIndex minus(int ofs) {
return new ListAndIndex(list, idx - ofs);
}
public List list() {
return list;
}
final public int idx() {
return index();
}
public int index() {
return idx;
}
public ListAndIndex mapIdx(IF1_IntToInt f) {
return new ListAndIndex(list, f.get(idx));
}
}
static public class ReliableSingleThread implements Runnable {
public boolean _isTransient() {
return true;
}
public Object runnable;
public String name = "Single Thread";
public boolean cancelBeforeTrigger = false;
public boolean waitBetweenCancelAndTrigger = false;
public F0 enter;
public int cancelTimeOut = 10000;
public boolean trigger = false;
public Thread thread;
public WeakReference threadBeingCancelled;
public List inserts = syncL();
public ReliableSingleThread() {
}
public ReliableSingleThread(Object runnable) {
this.runnable = runnable;
}
public ReliableSingleThread(Runnable runnable) {
this.runnable = runnable;
}
public void trigger() {
go();
}
synchronized public void go() {
if (cancelBeforeTrigger)
cancelAndPossiblyWait();
trigger = true;
if (!running()) {
AutoCloseable __1 = callF(enter);
try {
thread = startThread(name, new Runnable() {
public void run() {
try {
AutoCloseable __2 = callF(enter);
try {
_run();
} finally {
_close(__2);
}
} catch (Exception __e) {
throw rethrow(__e);
}
}
public String toString() {
return "temp callF(enter);\r\n _run();";
}
});
} finally {
_close(__1);
}
}
}
public void run() {
go();
}
public void get() {
go();
}
synchronized public boolean running() {
return thread != null;
}
public void triggerAndWait() {
trigger();
waitUntilDone();
}
public void waitUntilDone() {
while (running()) sleep(1);
}
transient public Runnable preSleep;
public void preSleep() {
if (preSleep != null)
preSleep.run();
else
preSleep_base();
}
final public void preSleep_fallback(Runnable _f) {
if (_f != null)
_f.run();
else
preSleep_base();
}
public void preSleep_base() {
}
public void _run() {
try {
while (licensed()) {
preSleep();
Thread oldThread;
synchronized (this) {
var currentInserts = syncGetAndClear(inserts);
pcallFAll(currentInserts);
if (!trigger) {
thread = null;
break;
}
oldThread = getWeakRef(threadBeingCancelled);
trigger = false;
}
if (oldThread != null && oldThread != currentThread())
oldThread.join(cancelTimeOut);
pcallF(runnable);
}
} catch (Exception __e) {
throw rethrow(__e);
}
}
synchronized public void cancel() {
if (thread == null)
return;
threadBeingCancelled = new WeakReference(thread);
cancelAndInterruptThread(thread);
thread = null;
}
public void cancelAndWait() {
Thread _thread;
synchronized (this) {
if (thread == null)
return;
_thread = thread;
threadBeingCancelled = new WeakReference(thread);
thread = null;
}
cancelAndInterruptThread(_thread);
}
public void cancelAndTrigger() {
cancelAndPossiblyWait();
trigger();
}
synchronized public boolean triggered() {
return trigger;
}
public void cleanMeUp() {
cancel();
}
public ReliableSingleThread cancelBeforeTrigger() {
cancelBeforeTrigger = true;
return this;
}
public void cancelAndPossiblyWait() {
if (waitBetweenCancelAndTrigger)
cancel();
}
public void insert(Runnable r) {
inserts.add(r);
trigger();
}
synchronized public boolean hasThread() {
return thread != null;
}
public ReliableSingleThread action(Runnable r) {
runnable = r;
return this;
}
}
static public class Fail extends RuntimeException implements IFieldsToList {
public Object[] objects;
public Fail() {
}
public Fail(Object... objects) {
this.objects = objects;
}
public Object[] _fieldsToList() {
return new Object[] { objects };
}
public Fail(Throwable cause, Object... objects) {
super(cause);
this.objects = objects;
}
public String toString() {
return joinNemptiesWithColon("Fail", getMessage());
}
public String getMessage() {
return commaCombine(getCause(), objects);
}
}
static public class Rect implements WidthAndHeight, IFieldsToList {
static final public String _fieldOrder = "x y w h";
public int x;
public int y;
public int w;
public int h;
public Rect() {
}
public Rect(int x, int y, int w, int h) {
this.h = h;
this.w = w;
this.y = y;
this.x = x;
}
public boolean equals(Object o) {
if (!(o instanceof Rect))
return false;
Rect __1 = (Rect) o;
return x == __1.x && y == __1.y && w == __1.w && h == __1.h;
}
public int hashCode() {
int h = 2543108;
h = boostHashCombine(h, _hashCode(x));
h = boostHashCombine(h, _hashCode(y));
h = boostHashCombine(h, _hashCode(w));
h = boostHashCombine(h, _hashCode(h));
return h;
}
public Object[] _fieldsToList() {
return new Object[] { x, y, w, h };
}
public Rect(Rectangle r) {
x = r.x;
y = r.y;
w = r.width;
h = r.height;
}
public Rect(Pt p, int w, int h) {
this.h = h;
this.w = w;
x = p.x;
y = p.y;
}
public Rect(Rect r) {
x = r.x;
y = r.y;
w = r.w;
h = r.h;
}
final public Rectangle getRectangle() {
return new Rectangle(x, y, w, h);
}
public String toString() {
return x + "," + y + " / " + w + "," + h;
}
final public int x1() {
return x;
}
final public int y1() {
return y;
}
final public int x2() {
return x + w;
}
final public int y2() {
return y + h;
}
final public boolean contains(Pt p) {
return contains(p.x, p.y);
}
final public boolean contains(int _x, int _y) {
return _x >= x && _y >= y && _x < x + w && _y < y + h;
}
final public boolean contains(Rectangle r) {
return rectContains(this, r);
}
final public boolean empty() {
return w <= 0 || h <= 0;
}
final public int getWidth() {
return w;
}
final public int getHeight() {
return h;
}
final public int area() {
return w * h;
}
final public int x() {
return x;
}
final public int y() {
return y;
}
public WidthAndHeight widthAndHeight() {
return main.widthAndHeight(w, h);
}
}
static public class FunctionTimings {
public Map data = syncMap();
final public void timeCtex(A function, RunnableWithExceptions r) {
doCtex(function, r);
}
public void doCtex(A function, RunnableWithExceptions r) {
try {
if (r == null)
return;
long time = nanoTime();
try {
r.run();
} finally {
time = nanoTime() - time;
saveTiming(function, time);
}
} catch (Exception __e) {
throw rethrow(__e);
}
}
public B get(A function, IF0 f) {
if (f == null)
return null;
Var var = new Var();
time(function, () -> var.set(f.get()));
return var.get();
}
final public void time(A function, Runnable r) {
dO(function, r);
}
public void dO(A function, Runnable r) {
if (r == null)
return;
long time = nanoTime();
try {
r.run();
} finally {
time = nanoTime() - time;
saveTiming(function, time);
}
}
public void saveTiming(A function, long time) {
Average avg = syncMapGetOrCreate(data, function, () -> new Average());
avg.add(time);
}
public Map get() {
return cloneMap(data);
}
final public void clear() {
reset();
}
public void reset() {
data.clear();
}
final public String toString() {
return render();
}
public String render() {
return lines(renderedEntries());
}
public List renderedEntries() {
return ciSorted(map(get(), (f, avg) -> functionToString(f) + ": " + n2(iround(nsToMicroseconds(avg.get()))) + " " + microSymbol() + "s (" + n2(iround(avg.n())) + ")"));
}
public String toStringSingleLine() {
return joinWithComma(renderedEntries());
}
public String functionToString(A f) {
return firstToUpper(str(f));
}
}
static public class LeftArrowScriptAutoCompleter extends Meta implements IFieldsToList {
public GazelleV_LeftArrowScriptParser parser;
public LeftArrowScriptAutoCompleter() {
}
public LeftArrowScriptAutoCompleter(GazelleV_LeftArrowScriptParser parser) {
this.parser = parser;
}
public String toString() {
return shortClassName_dropNumberPrefix(this) + "(" + parser + ")";
}
public Object[] _fieldsToList() {
return new Object[] { parser };
}
public List tok;
public CharInToken cursor;
public String typedCharacters;
public ScoredStringSearcher searcher;
final public LeftArrowScriptAutoCompleter setG22utils(G22Utils g22utils) {
return g22utils(g22utils);
}
public LeftArrowScriptAutoCompleter g22utils(G22Utils g22utils) {
this.g22utils = g22utils;
return this;
}
final public G22Utils getG22utils() {
return g22utils();
}
public G22Utils g22utils() {
return g22utils;
}
public G22Utils g22utils;
public TreeMap> knownVarsByTokenIdx = new TreeMap();
public Map typeHooks = new HashMap();
transient public Set onAdaptingSearcher;
public LeftArrowScriptAutoCompleter onAdaptingSearcher(Runnable r) {
onAdaptingSearcher = createOrAddToSyncLinkedHashSet(onAdaptingSearcher, r);
return this;
}
public LeftArrowScriptAutoCompleter removeAdaptingSearcherListener(Runnable r) {
main.remove(onAdaptingSearcher, r);
return this;
}
public void adaptingSearcher() {
if (onAdaptingSearcher != null)
for (var listener : onAdaptingSearcher) pcallF_typed(listener);
}
public LeftArrowScriptAutoCompleter(G22Utils g22utils, GazelleV_LeftArrowScriptParser parser) {
this.parser = parser;
this.g22utils = g22utils;
}
public void seekEnd(String text) {
seek(text, l(text));
}
public void seek(String text, int iChar) {
if (tok != null)
throw fail("Don't reuse instance");
parser.setText(text);
parser.init();
tok = parser.tok;
cursor = charIndexToCharInToken(tok, iChar);
if (even(cursor.iTok) && cursor.iTok > 0 && cursor.iChar == 0) {
cursor.iTok--;
cursor.iChar = l(token());
}
if (cursor.iTok > 1 && cursor.iChar == 0 && empty(space())) {
cursor.iTok -= 2;
cursor.iChar = l(token());
}
typedCharacters = takeFirst(cursor.token(), cursor.iChar);
parser.onKnownVarsSnapshot(knownVars -> knownVarsByTokenIdx.put(parser.tokIdx(), cloneKeys(knownVars)));
parser.onTypeHook(type -> typeHooks.put(parser.tokIdx(), type));
try {
parser.parse();
} catch (Throwable __e) {
print(exceptionToStringShort(__e));
}
}
public String typedCharacters() {
return typedCharacters;
}
public String space() {
return get(tok, cursor.iTok - 1);
}
public String token() {
return get(tok, cursor.iTok);
}
public String prevToken() {
return get(tok, cursor.iTok - 2);
}
public boolean beginningOfCmd() {
return eqOneOf(prevToken(), ";", "{", "}") || containsNewLine(space());
}
public Collection getCompletions() {
return searcher().get_transformListWithinScore(__1 -> stringsSortedByLength(__1));
}
public ScoredStringSearcher searcher() {
searcher = new ScoredStringSearcher(typedCharacters);
searcher.uniquify(true);
if (empty(typedCharacters))
searcher.returnAll = true;
String prev = prevToken();
if (scaffoldingEnabled(this))
printVars("LeftArrowScriptAutoCompleter", "beginningOfCmd", beginningOfCmd(), "prev", prev, "cursor", cursor, "typedCharacters", typedCharacters, "globalClassNames", l(parser.globalClassNames()));
LASValueDescriptor typeHook = typeHooks.get(cursor.iTok);
if (typeHook != null && !beginningOfCmd()) {
Class c = typeHook.javaClass();
if (c == null)
c = Object.class;
addToSearcher(methodNames(c));
addToSearcher(fieldNames(c));
} else {
if (beginningOfCmd() || !isIdentifier(prev) || eqOneOf(prev, "if", "else"))
addToSearcher(globalMethodNames());
addToSearcher(keys(parser.globalClassNames()));
addToSearcher(predefinedExpressions());
Collection knownVars = floorValue(knownVarsByTokenIdx, cursor.iTok);
addToSearcher(knownVars);
}
adaptingSearcher();
return searcher;
}
public Collection predefinedExpressions() {
return ll("true", "false", "null");
}
transient public IF0> globalMethodNames;
public Collection globalMethodNames() {
return globalMethodNames != null ? globalMethodNames.get() : globalMethodNames_base();
}
final public Collection globalMethodNames_fallback(IF0> _f) {
return _f != null ? _f.get() : globalMethodNames_base();
}
public Collection globalMethodNames_base() {
List names = new ArrayList();
for (var fc : parser.functionContainers) addAll(names, methodNames(fc));
addAll(names, keys(parser.functionDefs));
return names;
}
public void addToSearcher(String... l) {
addToSearcher(asList(l));
}
public void addToSearcher(Iterable l) {
for (var s : unnullForIteration(l)) if (!eq(s, typedCharacters))
searcher.add(s);
}
}
static public class PersistableOKOrError implements IF0 {
public A value;
final public PersistableThrowable getError() {
return error();
}
public PersistableThrowable error() {
return error;
}
public PersistableThrowable error;
public PersistableOKOrError() {
}
public PersistableOKOrError(A value) {
this.value = value;
}
public PersistableOKOrError(boolean dummy, PersistableThrowable error) {
this.error = error;
assertNotNull(error);
}
final public boolean isOK() {
return ok();
}
public boolean ok() {
return error == null;
}
public String toString() {
return ok() ? str(value) : "Error: " + str(error);
}
public A get() {
return !ok() ? null : value;
}
public A getMandatory() {
if (!ok())
throw error.asRuntimeException();
return value;
}
static public PersistableOKOrError ok(A a) {
return new PersistableOKOrError(a);
}
static public PersistableOKOrError error(PersistableThrowable error) {
return new PersistableOKOrError(false, error);
}
}
static public class DefaultButtonBorder extends JPanel {
public JButton button;
public DefaultButtonBorder(JButton button) {
super(new BorderLayout());
this.button = button;
setBorder(makeBorder());
add(button);
onEnabledChanged(button, () -> setBorder(makeBorder()));
}
public Border makeBorder() {
return BorderFactory.createLineBorder(main.isEnabled(button) ? Color.black : Color.lightGray);
}
}
static abstract public class IterableIterator implements Iterator, Iterable {
public Iterator iterator() {
return this;
}
public void remove() {
unsupportedOperation();
}
}
static public interface MakesBufferedImage extends WidthAndHeight {
public BufferedImage getBufferedImage();
public default void drawAt(Graphics2D g, int x, int y) {
g.drawImage(getBufferedImage(), x, y, null);
}
default public int getWidth() {
return getBufferedImage().getWidth();
}
default public int getHeight() {
return getBufferedImage().getHeight();
}
}
static public class G22AutoStarter extends MetaWithChangeListeners implements AutoCloseable, IFieldsToList {
public G22Utils g22utils;
public G22AutoStarter() {
}
public G22AutoStarter(G22Utils g22utils) {
this.g22utils = g22utils;
}
public Object[] _fieldsToList() {
return new Object[] { g22utils };
}
public transient FieldVar varEnabled_cache;
public FieldVar varEnabled() {
if (varEnabled_cache == null)
varEnabled_cache = varEnabled_load();
return varEnabled_cache;
}
public FieldVar varEnabled_load() {
return new FieldVar(this, "enabled", () -> enabled(), enabled -> enabled(enabled));
}
final public G22AutoStarter setEnabled(boolean enabled) {
return enabled(enabled);
}
public G22AutoStarter enabled(boolean enabled) {
if (!eq(this.enabled, enabled)) {
this.enabled = enabled;
change();
}
return this;
}
final public boolean getEnabled() {
return enabled();
}
public boolean enabled() {
return enabled;
}
volatile public boolean enabled = true;
public transient FieldVar varInitialDelay_cache;
public FieldVar varInitialDelay() {
if (varInitialDelay_cache == null)
varInitialDelay_cache = varInitialDelay_load();
return varInitialDelay_cache;
}
public FieldVar varInitialDelay_load() {
return new FieldVar(this, "initialDelay", () -> initialDelay(), initialDelay -> initialDelay(initialDelay));
}
final public G22AutoStarter setInitialDelay(int initialDelay) {
return initialDelay(initialDelay);
}
public G22AutoStarter initialDelay(int initialDelay) {
if (!eq(this.initialDelay, initialDelay)) {
this.initialDelay = initialDelay;
change();
}
return this;
}
final public int getInitialDelay() {
return initialDelay();
}
public int initialDelay() {
return initialDelay;
}
volatile public int initialDelay = 1;
public transient FieldVar varNScriptsRun_cache;
public FieldVar varNScriptsRun() {
if (varNScriptsRun_cache == null)
varNScriptsRun_cache = varNScriptsRun_load();
return varNScriptsRun_cache;
}
public FieldVar varNScriptsRun_load() {
return new FieldVar(this, "nScriptsRun", () -> nScriptsRun(), nScriptsRun -> nScriptsRun(nScriptsRun));
}
final public G22AutoStarter setNScriptsRun(int nScriptsRun) {
return nScriptsRun(nScriptsRun);
}
public G22AutoStarter nScriptsRun(int nScriptsRun) {
if (!eq(this.nScriptsRun, nScriptsRun)) {
this.nScriptsRun = nScriptsRun;
change();
}
return this;
}
final public int getNScriptsRun() {
return nScriptsRun();
}
public int nScriptsRun() {
return nScriptsRun;
}
volatile public int nScriptsRun;
public transient FieldVar varCurrentScript_cache;
public FieldVar varCurrentScript() {
if (varCurrentScript_cache == null)
varCurrentScript_cache = varCurrentScript_load();
return varCurrentScript_cache;
}
public FieldVar varCurrentScript_load() {
return new FieldVar(this, "currentScript", () -> currentScript(), currentScript -> currentScript(currentScript));
}
final public G22AutoStarter setCurrentScript(AutoStartScript currentScript) {
return currentScript(currentScript);
}
public G22AutoStarter currentScript(AutoStartScript currentScript) {
if (!eq(this.currentScript, currentScript)) {
this.currentScript = currentScript;
change();
}
return this;
}
final public AutoStartScript getCurrentScript() {
return currentScript();
}
public AutoStartScript currentScript() {
return currentScript;
}
volatile public AutoStartScript currentScript;
public transient FieldVar varCancelOnCtrl_cache;
public FieldVar varCancelOnCtrl() {
if (varCancelOnCtrl_cache == null)
varCancelOnCtrl_cache = varCancelOnCtrl_load();
return varCancelOnCtrl_cache;
}
public FieldVar varCancelOnCtrl_load() {
return new FieldVar(this, "cancelOnCtrl", () -> cancelOnCtrl(), cancelOnCtrl -> cancelOnCtrl(cancelOnCtrl));
}
final public G22AutoStarter setCancelOnCtrl(boolean cancelOnCtrl) {
return cancelOnCtrl(cancelOnCtrl);
}
public G22AutoStarter cancelOnCtrl(boolean cancelOnCtrl) {
if (!eq(this.cancelOnCtrl, cancelOnCtrl)) {
this.cancelOnCtrl = cancelOnCtrl;
change();
}
return this;
}
final public boolean getCancelOnCtrl() {
return cancelOnCtrl();
}
public boolean cancelOnCtrl() {
return cancelOnCtrl;
}
volatile public boolean cancelOnCtrl = false;
transient public Set onDone;
public G22AutoStarter onDone(Runnable r) {
onDone = createOrAddToSyncLinkedHashSet(onDone, r);
return this;
}
public G22AutoStarter removeDoneListener(Runnable r) {
main.remove(onDone, r);
return this;
}
public void fireDone() {
if (onDone != null)
for (var listener : onDone) pcallF_typed(listener);
}
public Flag started = new Flag();
public Flag waited = new Flag();
public Flag ctrlPressed = new Flag();
public List scripts = syncL();
public AutoCloseable ctrlListener;
public ReliableSingleThread rst = rst(() -> _run());
public JComponent topStackComponent;
public JProgressBar progressBar;
public class AutoStartScript extends RunResultWithTimestamps implements IFieldsToList {
public G22LeftArrowScript script;
public AutoStartScript() {
}
public AutoStartScript(G22LeftArrowScript script) {
this.script = script;
}
public Object[] _fieldsToList() {
return new Object[] { script };
}
public void run() {
try {
LASCompileResult cr = script.compileForAutoRun();
if (cr == null)
cr = script.compileSaved();
var _cr_2 = cr;
run(() -> {
G22AutoStarter.this.change();
if (_cr_2 == null)
throw fail("Script is not saved: " + script);
var parsed = _cr_2.parsedScriptMandatory();
return parsed.get();
});
} catch (Exception __e) {
throw rethrow(__e);
}
}
public String toString() {
return str(script);
}
}
public void init() {
if (ctrlListener != null)
return;
scripts.clear();
var scripts = conceptsWhere(g22utils.concepts, G22LeftArrowScript.class, "runOnProjectOpen", true);
var sorted = sortByCalculatedFieldAlphaNumIC(scripts, s -> s.runOrder);
for (var script : sorted) this.scripts.add(new AutoStartScript(script));
change();
ctrlListener = tempAddGlobalCtrlKeyListener(b -> {
if (cancelOnCtrl && b) {
ctrlPressed.raise();
cancel();
}
});
}
public void start() {
print("G22AutoStarter: Start");
if (enabled) {
var topStack = g22utils.projectActions().topStack();
progressBar = jProgressBarWithText(l(scripts));
topStackComponent = withTopMargin(jCenteredSection("Booting project", centerAndEastWithMargin(progressBar, jThreadedButton("Cancel", () -> {
disableButton(heldButton());
cancel();
}))));
topStack.addComponent(topStackComponent);
rst.get();
}
}
public void _run() {
if (!enabled)
return;
AutoCloseable __1 = g22utils.backgroundProcessesUI.tempAdd("Auto-Start Scripts");
try {
if (started.raise())
change();
if (!waited.get()) {
print("G22AutoStarter: Sleeping");
while (initialDelay > 0) {
sleepSeconds(1);
initialDelay(initialDelay - 1);
}
waited.raise();
change();
print("G22AutoStarter: Slept");
}
while (enabled && !done()) {
var script = scripts.get(nScriptsRun);
currentScript(script);
setProgressBarValue(progressBar, nScriptsRun);
setProgressBarText(progressBar, str(script));
change();
script.run();
nScriptsRun(nScriptsRun + 1);
currentScript(null);
change();
}
var topStack = g22utils.projectActions().topStack();
topStack.removeComponent(topStackComponent);
topStackComponent = null;
progressBar = null;
fireDone();
change();
close();
} finally {
_close(__1);
}
}
public boolean done() {
return nScriptsRun >= l(scripts);
}
public boolean waitedAndDone() {
return waited.get() && done();
}
public void cancel() {
setEnabled(false);
}
public boolean canResume() {
return !done() && !enabled;
}
public void resume() {
if (done()) {
infoBox("Nothing to resume - auto-start is done");
return;
}
if (enabled) {
infoBox("Already running");
return;
}
infoBox("Resuming auto-start");
setEnabled(true);
rst.get();
}
public String status() {
return !enabled ? ctrlPressed.get() ? "Cancelled due to ctrl key" : "Cancelled" : done() ? "Done" : waited.get() ? "Started" : started.get() ? "Pre-start wait (" + formatDouble1(initialDelay) + "s)" : "Not started";
}
public String stats() {
return status() + ". " + scriptsRunStats();
}
public String scriptsRunStats() {
return "Scripts run: " + nScriptsRun() + "/" + l(scripts);
}
public String currentScriptStats() {
var s = currentScript;
if (s == null)
return "";
return "Running: " + s.script;
}
public void close() {
try {
if (ctrlListener != null) {
{
cleanUp(ctrlListener);
ctrlListener = null;
}
change();
}
} catch (Exception __e) {
throw rethrow(__e);
}
}
public void waitUntilDone() {
waitForVarPredicate(varNScriptsRun(), () -> done());
}
public boolean ctrlEnabled() {
return ctrlListener != null;
}
public boolean cancelled() {
return !enabled;
}
}
static public class JLeftArrowScriptIDE extends MetaWithChangeListeners implements Swingable {
final public JLeftArrowScriptIDE setLvScript(IVarWithNotify lvScript) {
return lvScript(lvScript);
}
public JLeftArrowScriptIDE lvScript(IVarWithNotify lvScript) {
this.lvScript = lvScript;
return this;
}
final public IVarWithNotify getLvScript() {
return lvScript();
}
public IVarWithNotify lvScript() {
return lvScript;
}
public IVarWithNotify lvScript = stringLiveValue();
final public JLeftArrowScriptIDE setSectionTitle(String sectionTitle) {
return sectionTitle(sectionTitle);
}
public JLeftArrowScriptIDE sectionTitle(String sectionTitle) {
this.sectionTitle = sectionTitle;
return this;
}
final public String getSectionTitle() {
return sectionTitle();
}
public String sectionTitle() {
return sectionTitle;
}
public String sectionTitle = "Left arrow script";
final public JLeftArrowScriptIDE setWithResultPanel(boolean withResultPanel) {
return withResultPanel(withResultPanel);
}
public JLeftArrowScriptIDE withResultPanel(boolean withResultPanel) {
this.withResultPanel = withResultPanel;
return this;
}
final public boolean getWithResultPanel() {
return withResultPanel();
}
public boolean withResultPanel() {
return withResultPanel;
}
public boolean withResultPanel = true;
final public JLeftArrowScriptIDE setCompileDelay(double compileDelay) {
return compileDelay(compileDelay);
}
public JLeftArrowScriptIDE compileDelay(double compileDelay) {
this.compileDelay = compileDelay;
return this;
}
final public double getCompileDelay() {
return compileDelay();
}
public double compileDelay() {
return compileDelay;
}
public double compileDelay = 0.1;
static public String helpText = "Gazelle 22 \"Left Arrow Script\"\r\n------------------------------\r\n\r\n\"Left arrow script\" is one of Gazelle 22's two scripting languages. It is the powerful one of the two. It can do anything Java can do except for defining classes or lambdas.\r\n\r\n-Usually, you write one command per line\r\n-Each command contains at most one action and at most one assignment\r\n-The language is case-sensitive\r\n-You can add comments like in Java with /* */ or //\r\n-You can write multiple commands in one line by separating them with a semicolon\r\n-Arguments to functions are separated by spaces\r\n-You can use integer and string literals like in Java\r\n-You can use true, false and null\r\n\r\nIt's called \"left arrow script\" because the left arrow (variable assignment) is its only actual operator (not counting ; and {}).\r\n\r\n\r\nOperations\r\n----------\r\n\r\nYou can call any global function defined in Gazelle. Example:\r\n\r\n infoBox \"hello\" // show a popup with the text \"hello\"\r\n \r\nYou can assign the result of a function call to a variable:\r\n\r\n time <- tsNow // get current time as a Timestamp object\r\n infoBox time // show as popup\r\n \r\nNote that this script requires 2 lines because only one operation is allowed per command.\r\n \r\nVariables can be overwritten and don't have to be declared.\r\n\r\n\r\nCreating objects\r\n----------------\r\n\r\nYou can create an instance of any Java class and call methods on the object:\r\n\r\n list <- new ArrayList\r\n list add \"hello\"\r\n list add \"world\"\r\n infoBox list // shows [hello, world]\r\n \r\n(Currently you can also say \"list <- ArrayList\", but this is ambiguous and may be removed in a future version.)\r\n \r\nYou can pass parameters to the constructor:\r\n\r\n pair <- new Pair \"hello\" \"world\"\r\n infoBox pair // shows \r\n \r\n\r\nJava operators (+, * etc)\r\n-------------------------\r\n \r\nJava operators can't be used directly but we have functions that do the same thing (if we don't, we'll add them):\r\n\r\n x <- plus 1 2\r\n infoBox x\r\n\r\n\r\nFunction definitions\r\n--------------------\r\n\r\nYou can define functions in your script, with arguments. The function can return a value (which is the result of the last command in the function).\r\n\r\n def doubleMe x { mul x 2 }\r\n\r\n x <- doubleMe 5\r\n infoBox x // shows 10\r\n";
public transient FieldVar varCompileResult_cache;
public FieldVar varCompileResult() {
if (varCompileResult_cache == null)
varCompileResult_cache = varCompileResult_load();
return varCompileResult_cache;
}
public FieldVar varCompileResult_load() {
return new FieldVar(this, "compileResult", () -> compileResult(), compileResult -> compileResult(compileResult));
}
final public JLeftArrowScriptIDE setCompileResult(LASCompileResult compileResult) {
return compileResult(compileResult);
}
public JLeftArrowScriptIDE compileResult(LASCompileResult compileResult) {
if (!eq(this.compileResult, compileResult)) {
this.compileResult = compileResult;
change();
}
return this;
}
final public LASCompileResult getCompileResult() {
return compileResult();
}
public LASCompileResult compileResult() {
return compileResult;
}
transient public LASCompileResult compileResult;
transient volatile public RSyntaxTextAreaWithSearch taScript;
transient public RSTADummyParser dummyParser = new RSTADummyParser();
transient public ReliableSingleThread rstCompile = new ReliableSingleThread(() -> compile());
final public JPanel getButtons() {
return buttons();
}
public JPanel buttons() {
return buttons;
}
transient public JPanel buttons = jline();
transient public JButton btnRun;
transient public CollapsibleLeftPanel collapsibleResultPanel;
transient public G22ScriptResultPanel resultPanel;
transient public JPopDownButton popDownButton;
transient public LeftArrowCompletionProvider completionProvider;
final public JLeftArrowScriptIDE setG22utils(G22Utils g22utils) {
return g22utils(g22utils);
}
public JLeftArrowScriptIDE g22utils(G22Utils g22utils) {
this.g22utils = g22utils;
return this;
}
final public G22Utils getG22utils() {
return g22utils();
}
public G22Utils g22utils() {
return g22utils;
}
transient public G22Utils g22utils;
final public JLeftArrowScriptIDE setScriptTimeout(double scriptTimeout) {
return scriptTimeout(scriptTimeout);
}
public JLeftArrowScriptIDE scriptTimeout(double scriptTimeout) {
this.scriptTimeout = scriptTimeout;
return this;
}
final public double getScriptTimeout() {
return scriptTimeout();
}
public double scriptTimeout() {
return scriptTimeout;
}
public double scriptTimeout = 10.0;
final public JLeftArrowScriptIDE setShowTitle(boolean showTitle) {
return showTitle(showTitle);
}
public JLeftArrowScriptIDE showTitle(boolean showTitle) {
this.showTitle = showTitle;
return this;
}
final public boolean getShowTitle() {
return showTitle();
}
public boolean showTitle() {
return showTitle;
}
transient public boolean showTitle = true;
final public JLeftArrowScriptIDE setSourceInfo(Object sourceInfo) {
return sourceInfo(sourceInfo);
}
public JLeftArrowScriptIDE sourceInfo(Object sourceInfo) {
this.sourceInfo = sourceInfo;
return this;
}
final public Object getSourceInfo() {
return sourceInfo();
}
public Object sourceInfo() {
return sourceInfo;
}
transient public Object sourceInfo;
transient public Runnable rRecompileIfError = () -> recompileIfError();
transient public IF0 makeParser;
public GazelleV_LeftArrowScriptParser makeParser() {
return makeParser != null ? makeParser.get() : makeParser_base();
}
final public GazelleV_LeftArrowScriptParser makeParser_fallback(IF0 _f) {
return _f != null ? _f.get() : makeParser_base();
}
public GazelleV_LeftArrowScriptParser makeParser_base() {
return g22utils.leftArrowParser().sourceInfo(sourceInfo);
}
public interface GoToDefinitionHandler {
public Runnable get(ListAndIndex tokPtr);
}
final public List getGoToDefinitionHandlers() {
return goToDefinitionHandlers();
}
public List goToDefinitionHandlers() {
return goToDefinitionHandlers;
}
transient public List goToDefinitionHandlers = syncL();
public class LeftArrowCompletionProvider extends DefaultCompletionProvider {
@Override
public List getCompletionsImpl(JTextComponent comp) {
try {
String text = main.getText(comp);
GazelleV_LeftArrowScriptParser parser = makeParser();
LeftArrowScriptAutoCompleter completer = new LeftArrowScriptAutoCompleter(g22utils, parser);
completer.onAdaptingSearcher(() -> g22utils.addingAdditionalAutoCompletes(completer));
enableScaffolding(completer);
completer.seek(text, getCaretPosition(comp));
return map(completer.searcher().withScores(), completion -> {
BasicCompletion c = new BasicCompletion(this, completion.get());
c.setRelevance((int) completion.score());
return c;
});
} catch (Throwable e) {
printStackTrace(e);
return ll();
}
}
}
public void goToPosition_noFocus(LineAndColumn lineAndCol) {
if (lineAndCol == null)
return;
try {
moveCaretAndScroll(textArea(), lineAndCol);
} catch (Throwable e) {
print("Trying again: " + e);
awtLater(1.0, () -> {
moveCaretAndScroll(textArea(), lineAndCol);
});
}
}
public void goToPosition(LineAndColumn lineAndCol) {
focus(textArea());
goToPosition_noFocus(lineAndCol);
}
public JComponent wrapStatusLabel(JComponent lbl) {
onLeftClick(lbl, () -> goToPosition(compileResult == null ? null : compileResult.errorLineAndCol()));
popDownButton = swing(() -> new JPopDownButton("Help"));
popDownButton.onFillingMenu(menu -> addMenuItems(menu, "Show Scripting Help", runnableThread(new Runnable() {
public void run() {
try {
showTextWordWrapped("Gazelle 'Left arrow script' Help", helpText);
} catch (Exception __e) {
throw rethrow(__e);
}
}
public String toString() {
return "showTextWordWrapped(\"Gazelle 'Left arrow script' Help\", helpText)";
}
}), "Show Global Class Names", runnableThread(new Runnable() {
public void run() {
try {
showGlobalClassNames();
} catch (Exception __e) {
throw rethrow(__e);
}
}
public String toString() {
return "showGlobalClassNames();";
}
}), "Convert to Java", runnableThread(new Runnable() {
public void run() {
try {
convertToJava();
} catch (Exception __e) {
throw rethrow(__e);
}
}
public String toString() {
return "convertToJava();";
}
})));
return centerAndEastWithMargin(jBorderlessHigherScrollPane(lbl), jfullcenter(buttons));
}
public transient JComponent visualize_cache;
public JComponent visualize() {
if (visualize_cache == null)
visualize_cache = visualize_load();
return visualize_cache;
}
public JComponent visualize_load() {
return markVisualizer(this, visualize_impl());
}
public JComponent visualize_impl() {
return swing(() -> {
taScript = g22utils.newSyntaxTextArea(__3 -> wrapStatusLabel(__3));
bindToComponent(textArea(), () -> g22utils.masterStuff().onNewClassesDefined(rRecompileIfError), () -> g22utils.masterStuff().removeNewClassesDefinedListener(rRecompileIfError));
bindTextComponentToVarWithNotify_noInitialUndo(textArea(), lvScript);
dummyParser.install(textArea());
addKeyListener(textArea(), functionKeyListener(5, runnableThread(new Runnable() {
public void run() {
try {
runScript();
} catch (Exception __e) {
throw rethrow(__e);
}
}
public String toString() {
return "runScript();";
}
})));
addKeyListener(textArea(), ctrlLetterKeyListener('b', runnableThread(new Runnable() {
public void run() {
try {
goToDefinition();
} catch (Exception __e) {
throw rethrow(__e);
}
}
public String toString() {
return "goToDefinition();";
}
})));
awtCalcEvery(textArea(), compileDelay, rstCompile);
installCompletionProvider(completionProvider = new LeftArrowCompletionProvider(), textArea());
JComponent vis = taScript.visualize();
if (showTitle)
vis = jCenteredSection(sectionTitle, vis);
vis = wrapSection(vis);
addAll(buttons, btnRun = toolTip("Run script (F5)", jbutton("Run", runnableThread(new Runnable() {
public void run() {
try {
runScript();
} catch (Exception __e) {
throw rethrow(__e);
}
}
public String toString() {
return "runScript();";
}
}))), popDownButton);
if (withResultPanel) {
resultPanel = new G22ScriptResultPanel();
collapsibleResultPanel = new CollapsibleLeftPanel(false, "Output", resultPanel.visualize(), vis);
collapsibleResultPanel.sidePanelMargins = c -> withTopAndLeftMargin(c);
return collapsibleResultPanel.visualize();
} else
return vis;
});
}
transient public IF1 wrapSection;
public JComponent wrapSection(JComponent c) {
return wrapSection != null ? wrapSection.get(c) : wrapSection_base(c);
}
final public JComponent wrapSection_fallback(IF1 _f, JComponent c) {
return _f != null ? _f.get(c) : wrapSection_base(c);
}
public JComponent wrapSection_base(JComponent c) {
return c;
}
public RSyntaxTextArea textArea() {
if (taScript == null)
visualize();
return taScript.textArea();
}
public void setText(String text) {
main.setText(textArea(), text);
}
private void compile() {
var script = lvScript.get();
var result = compileResult;
if (!g22utils().compileResultValid(result, script)) {
result = newCompileResult();
result.script = script;
result.makeParser = () -> makeParser();
result.compile();
compileResult(result);
showStatus(str(compileResult));
updateRunButtonState();
List errors = new ArrayList();
if (result.compileError != null) {
LineAndColumn lineAndCol = result.errorLineAndCol();
if (lineAndCol != null)
errors.add(new RSTADummyParser.Error().msg(result.errorToString()).start(lineAndCol).end(new LineAndColumn(lineAndCol.line + 1, 1)));
}
dummyParser.setErrors(result.script, errors, textArea());
}
}
public void updateRunButtonState() {
setEnabled(btnRun, runButtonShouldBeEnabled());
}
transient public IF0 runButtonShouldBeEnabled;
public boolean runButtonShouldBeEnabled() {
return runButtonShouldBeEnabled != null ? runButtonShouldBeEnabled.get() : runButtonShouldBeEnabled_base();
}
final public boolean runButtonShouldBeEnabled_fallback(IF0 _f) {
return _f != null ? _f.get() : runButtonShouldBeEnabled_base();
}
public boolean runButtonShouldBeEnabled_base() {
return compileResult != null && compileResult.runnable();
}
public LASCompileResult freshCompileResult() {
rstCompile.triggerAndWait();
return compileResult;
}
public GazelleV_LeftArrowScript.Script parsedScript() {
return freshCompileResult().parsedScript;
}
transient public Runnable runScript;
public void runScript() {
if (runScript != null)
runScript.run();
else
runScript_base();
}
final public void runScript_fallback(Runnable _f) {
if (_f != null)
_f.run();
else
runScript_base();
}
public void runScript_base() {
var result = freshCompileResult();
if (result.parsedScript != null) {
var value = runResultWithTimestamps(() -> callCompiledObjectWithTimeout(result.parsedScript));
showScriptResult(value);
}
}
public void showScriptResult(OKOrError result) {
if (result instanceof RunResultWithTimestamps) {
if (resultPanel != null)
resultPanel.logView.setText(str(((RunResultWithTimestamps) result).printOutput()));
}
if (result.isOK()) {
setStatus(shorten(g22utils.stringify(result.get())));
var objVisualizer = makeObjectVisualizer(result.get());
if (result instanceof RunResultWithTimestamps) {
var duration = ((RunResultWithTimestamps) result).duration();
if (duration != null) {
long nanos = ((RunResultWithTimestamps) result).duration().toNanos();
objVisualizer.nanos(nanos);
}
}
if (collapsibleResultPanel != null)
objVisualizer.withTypeAndTime(false);
{
if (resultPanel != null)
resultPanel.scpResult.set(objVisualizer);
}
if (collapsibleResultPanel != null)
collapsibleResultPanel.sidePanelName("Output" + appendBracketed(objVisualizer.objectInfos()));
} else {
setStatus(exceptionToStringShorter(result.error()));
{
if (resultPanel != null)
resultPanel.scpResult.set(jErrorView(result.getError()));
}
}
{
if (collapsibleResultPanel != null)
collapsibleResultPanel.expand();
}
}
final public void showStatus(String status) {
setStatus(status);
}
public void setStatus(String status) {
{
if (taScript != null)
taScript.setStatus(" " + unnull(status));
}
}
public void showRuntimeError(Throwable e) {
showStatus(exceptionToStringShorter(e));
}
transient public IF0 makeVarContextForExecution;
public VarContext makeVarContextForExecution() {
return makeVarContextForExecution != null ? makeVarContextForExecution.get() : makeVarContextForExecution_base();
}
final public VarContext makeVarContextForExecution_fallback(IF0 _f) {
return _f != null ? _f.get() : makeVarContextForExecution_base();
}
public VarContext makeVarContextForExecution_base() {
return new FlexibleVarContext();
}
public Object callCompiledObjectWithTimeout(GazelleV_LeftArrowScript.Script script) {
return callCompiledObjectWithTimeout(scriptTimeout, script);
}
public Object callCompiledObjectWithTimeout(double timeoutSeconds, GazelleV_LeftArrowScript.Script script) {
return callCompiledObjectWithTimeout(timeoutSeconds, script, makeVarContextForExecution());
}
public Object callCompiledObjectWithTimeout(GazelleV_LeftArrowScript.Script script, VarContext ctx) {
return callCompiledObjectWithTimeout(scriptTimeout, script, ctx);
}
public Object callCompiledObjectWithTimeout(double timeoutSeconds, GazelleV_LeftArrowScript.Script script, VarContext ctx) {
return g22utils.evalRegisteredCode(timeoutSeconds, str(script), () -> script.get(ctx));
}
public void showGlobalClassNames() {
showText("Global Class Names", pnlToString(toCIMap(makeParser().globalClassNames())));
}
public void setEditable(boolean b) {
main.setEditable(textArea(), b);
}
transient public IF0 newCompileResult;
public LASCompileResult newCompileResult() {
return newCompileResult != null ? newCompileResult.get() : newCompileResult_base();
}
final public LASCompileResult newCompileResult_fallback(IF0 _f) {
return _f != null ? _f.get() : newCompileResult_base();
}
public LASCompileResult newCompileResult_base() {
return new LASCompileResult();
}
public void convertToJava() {
try {
ConvertLASToJava converter = new ConvertLASToJava();
enableScaffolding(converter);
showText("Java conversion - " + sectionTitle(), strOrNull(converter.get(parsedScript(), true)));
} catch (Throwable __e) {
infoBox(__e);
}
}
public void goToDefinition() {
String text;
int iChar;
Pair __2 = textAndCaretPosition(textArea());
text = __2.a;
iChar = __2.b;
List tok = lasTok(text);
int iTok = charToTokenIndex_left(tok, iChar);
ListAndIndex tokPtr = new ListAndIndex(tok, iTok);
var action = goToDefinitionAction(tokPtr);
if (action != null)
pcallF(action);
else
flatInfoBox("No definition found");
}
public Runnable goToDefinitionAction(ListAndIndex tokPtr) {
for (var handler : cloneList(goToDefinitionHandlers())) {
var __1 = handler.get(tokPtr);
if (__1 != null)
return __1;
}
List tok = tokPtr.list();
int iTok = tokPtr.idx();
String id = lastIdentifier(subList(tok, iTok - 2, iTok + 1));
if (id != null) {
String name = lookupStandardFunctionOrClassNameIC(id);
if (name != null) {
String snippetID = sfOrSCSnippet(id);
if (snippetID != null) {
return () -> {
infoBox("Opening " + quote(name));
g22utils.openInBrowser(snippetURL(snippetID));
};
}
}
}
return null;
}
public void recompile() {
compileResult = null;
rstCompile.trigger();
}
public void recompileIfError() {
var result = compileResult;
if (result != null && result.hasError())
recompile();
}
transient public IF1 makeObjectVisualizer;
public G22JavaObjectVisualizer makeObjectVisualizer(Object result) {
return makeObjectVisualizer != null ? makeObjectVisualizer.get(result) : makeObjectVisualizer_base(result);
}
final public G22JavaObjectVisualizer makeObjectVisualizer_fallback(IF1 _f, Object result) {
return _f != null ? _f.get(result) : makeObjectVisualizer_base(result);
}
public G22JavaObjectVisualizer makeObjectVisualizer_base(Object result) {
return new G22JavaObjectVisualizer(g22utils, result).allowDescendingIntoListElements(true);
}
public void addGoToDefinitionHandler(GoToDefinitionHandler handler) {
goToDefinitionHandlers.add(handler);
}
final public boolean isShowing() {
return visible();
}
public boolean visible() {
var ta = taScript;
return ta != null && main.isShowing(ta.textArea);
}
public String getText() {
var ta = taScript;
if (ta == null)
return null;
return main.getText(ta.textArea);
}
}
static public class DeleteFilesDialog {
final public DeleteFilesDialog setTitle(String title) {
return title(title);
}
public DeleteFilesDialog title(String title) {
this.title = title;
return this;
}
final public String getTitle() {
return title();
}
public String title() {
return title;
}
public String title = "Delete files";
public LinkedHashSet filesToDelete = new LinkedHashSet();
public DeleteFilesDialog() {
}
public DeleteFilesDialog(String title) {
this.title = title;
}
public DeleteFilesDialog wholeDirectory(File dir) {
if (!isDirectory(dir))
return this;
filesToDelete.addAll(reversed(findAllFiles(dir)));
filesToDelete.add(dir);
return this;
}
public void show() {
renameSubmitButton("DELETE " + upper(nFiles(filesToDelete)), showFormTitled3(title, "Files to delete", jscroll(uneditableTextArea(lines(filesToDelete))), null, runnableThread(new Runnable() {
public void run() {
try {
doIt();
} catch (Exception __e) {
throw rethrow(__e);
}
}
public String toString() {
return "doIt();";
}
})).visualize());
}
public void doIt() {
int successes = 0;
for (File f : filesToDelete) if (deleteFile(f)) {
print("DELETED: " + f);
++successes;
} else
print("COULDN'T DELETE: " + f);
int failures = l(filesToDelete) - successes;
String msg = "Deleted " + nFiles(successes);
if (failures == 0)
infoBox(msg);
else
messageBox(msg + ", but couldn't delete " + n2(failures));
}
}
static public int concepts_internStringsLongerThan = 10;
static public ThreadLocal concepts_unlisted = new ThreadLocal();
static public boolean concepts_unlistedByDefault = true;
public interface IConceptIndex {
public void update(Concept c);
public void remove(Concept c);
}
public interface IFieldIndex {
public Collection getAll(Val val);
public List allValues();
public MultiSet allValues_multiSet();
public IterableIterator objectIterator();
}
static public class ConceptsChange {
}
static public class ConceptCreate extends ConceptsChange implements IFieldsToList {
public Concept c;
public ConceptCreate() {
}
public ConceptCreate(Concept c) {
this.c = c;
}
public String toString() {
return shortClassName_dropNumberPrefix(this) + "(" + c + ")";
}
public boolean equals(Object o) {
if (!(o instanceof ConceptCreate))
return false;
ConceptCreate __3 = (ConceptCreate) o;
return eq(c, __3.c);
}
public int hashCode() {
int h = -1751266972;
h = boostHashCombine(h, _hashCode(c));
return h;
}
public Object[] _fieldsToList() {
return new Object[] { c };
}
}
static public class ConceptChange extends ConceptsChange implements IFieldsToList {
public Concept c;
public ConceptChange() {
}
public ConceptChange(Concept c) {
this.c = c;
}
public String toString() {
return shortClassName_dropNumberPrefix(this) + "(" + c + ")";
}
public boolean equals(Object o) {
if (!(o instanceof ConceptChange))
return false;
ConceptChange __4 = (ConceptChange) o;
return eq(c, __4.c);
}
public int hashCode() {
int h = -1760609256;
h = boostHashCombine(h, _hashCode(c));
return h;
}
public Object[] _fieldsToList() {
return new Object[] { c };
}
}
static public class ConceptDelete extends ConceptsChange implements IFieldsToList {
static final public String _fieldOrder = "id c";
public long id;
public Concept c;
public ConceptDelete() {
}
public ConceptDelete(long id, Concept c) {
this.c = c;
this.id = id;
}
public String toString() {
return shortClassName_dropNumberPrefix(this) + "(" + id + ", " + c + ")";
}
public boolean equals(Object o) {
if (!(o instanceof ConceptDelete))
return false;
ConceptDelete __5 = (ConceptDelete) o;
return id == __5.id && eq(c, __5.c);
}
public int hashCode() {
int h = -1734431213;
h = boostHashCombine(h, _hashCode(id));
h = boostHashCombine(h, _hashCode(c));
return h;
}
public Object[] _fieldsToList() {
return new Object[] { id, c };
}
}
static public class FullChange extends ConceptsChange implements IFieldsToList {
public FullChange() {
}
public String toString() {
return shortClassName_dropNumberPrefix(this);
}
public boolean equals(Object o) {
return o instanceof FullChange;
}
public int hashCode() {
int h = 733452095;
return h;
}
public Object[] _fieldsToList() {
return null;
}
}
static public class Concepts implements AutoCloseable {
public SortedMap concepts = synchroTreeMap();
final public long getIdCounter() {
return idCounter();
}
public long idCounter() {
return idCounter;
}
public long idCounter;
transient public HashMap perClassData;
transient public Map miscMap;
transient public String programID;
transient public File conceptsFile;
transient public Concepts parent;
transient volatile public long changes, changesWritten, lastChange;
transient volatile public java.util.Timer autoSaver;
transient volatile public boolean dontSave = false;
transient volatile public boolean savingConcepts, noXFullGrab;
transient public boolean vmBusSend = true;
transient public boolean initialSave = false;
transient public int autoSaveInterval = -1000;
transient public boolean useGZIP = true, quietSave;
transient public ReentrantLock lock = new ReentrantLock(true);
transient public ReentrantLock saverLock = new ReentrantLock(true);
transient public long lastSaveTook = -1, lastSaveWas, loadTook, uncompressedSize;
transient public float maxAutoSavePercentage = 10;
transient public List conceptIndices;
transient public Map, Map> fieldIndices;
transient public Map, Map> ciFieldIndices;
transient public List preSave;
transient public Object classFinder = _defaultClassFinder();
transient public List onAllChanged = synchroList();
transient public Set onChange = new HashSet();
transient public Object saveWrapper;
final public Concepts setModifyOnCreate(boolean modifyOnCreate) {
return modifyOnCreate(modifyOnCreate);
}
public Concepts modifyOnCreate(boolean modifyOnCreate) {
this.modifyOnCreate = modifyOnCreate;
return this;
}
final public boolean getModifyOnCreate() {
return modifyOnCreate();
}
public boolean modifyOnCreate() {
return modifyOnCreate;
}
transient public boolean modifyOnCreate = false;
transient public boolean modifyOnBackRef = false;
transient public boolean useFileLock = true;
final public Concepts setGrabThroughSocket(boolean grabThroughSocket) {
return grabThroughSocket(grabThroughSocket);
}
public Concepts grabThroughSocket(boolean grabThroughSocket) {
this.grabThroughSocket = grabThroughSocket;
return this;
}
final public boolean getGrabThroughSocket() {
return grabThroughSocket();
}
public boolean grabThroughSocket() {
return grabThroughSocket;
}
transient public boolean grabThroughSocket = true;
transient public FileBasedLock fileLock;
transient public boolean storeBaseClassesInStructure = false;
transient public boolean useBackRefsForSearches = false;
transient public boolean defunct = false;
transient public int newBackupEveryXMinutes = 60;
final public Concepts setCloseConceptsOnExit(boolean closeConceptsOnExit) {
return closeConceptsOnExit(closeConceptsOnExit);
}
public Concepts closeConceptsOnExit(boolean closeConceptsOnExit) {
this.closeConceptsOnExit = closeConceptsOnExit;
return this;
}
final public boolean getCloseConceptsOnExit() {
return closeConceptsOnExit();
}
public boolean closeConceptsOnExit() {
return closeConceptsOnExit;
}
transient public boolean closeConceptsOnExit = false;
public Concepts() {
}
public Concepts(String programID) {
this.programID = programID;
}
public Concepts(File conceptsFile) {
this.conceptsFile = conceptsFile;
}
synchronized public long internalID() {
do {
++idCounter;
} while (hasConcept(idCounter));
return idCounter;
}
synchronized public HashMap perClassData() {
if (perClassData == null)
perClassData = new HashMap();
return perClassData;
}
public void initProgramID() {
if (programID == null)
programID = getDBProgramID();
}
public Concepts load(String structure) {
return load(structure, false);
}
public Concepts load(String structure, boolean allDynamic) {
clearConcepts();
Map