sclass JLeftArrowScriptIDE > MetaWithChangeListeners is Swingable {

  settable IVarWithNotify<S> lvScript = stringLiveValue();

  settable S sectionTitle = "Left arrow script";

  settable bool withResultPanel = true;

  // how long to wait before compiling after text is changed (seconds)

  settable double compileDelay = 0.1;

  sS helpText = !include string #1034045;

  transient settableWithVar LASCompileResult compileResult;

  transient volatile RSyntaxTextAreaWithSearch taScript;

  transient new RSTADummyParser dummyParser; // for error highlighting

  transient ReliableSingleThread rstCompile = new(l0 compile);

  transient gettable JPanel buttons = jline();

  transient JButton btnRun;

  transient CollapsibleLeftPanel collapsibleResultPanel;

  transient G22ScriptResultPanel resultPanel;

  transient JPopDownButton popDownButton;

  transient LeftArrowCompletionProvider completionProvider;

  settable transient G22Utils g22utils;

  settable double scriptTimeout = 10.0;

  settable transient bool showTitle = true;

  // set by client

  settable transient O sourceInfo;

  transient Runnable rRecompileIfError = l0 recompileIfError;

  transient swappable GazelleV_LeftArrowScriptParser makeParser() {

    ret g22utils.leftArrowParser().sourceInfo(sourceInfo);

  }

  interface GoToDefinitionHandler {

    Runnable get(TokPtr tokPtr);

  }

  transient gettable L<GoToDefinitionHandler> goToDefinitionHandlers = syncL();

  class LeftArrowCompletionProvider extends DefaultCompletionProvider {

    @Override

    public L<Completion> getCompletionsImpl(JTextComponent comp) {

      try {

        S text = main getText(comp);

        GazelleV_LeftArrowScriptParser parser = makeParser();

        LeftArrowScriptAutoCompleter completer = new(g22utils, parser);

        completer.onAdaptingSearcher(-> g22utils.addingAdditionalAutoCompletes(completer));

        //enableScaffolding(completer);

        completer.seek(text, getCaretPosition(comp));

        ret map(completer.searcher().withScores(), completion -> {

          BasicCompletion c = new(this, completion!);

          c.setRelevance((int) completion.score());

          ret c;

        });

      } catch print e { ret ll(); }

    }

  }

  void goToPosition_noFocus(LineAndColumn lineAndCol) {

    if (lineAndCol == null) ret;

    try {

      moveCaretAndScroll(textArea(), lineAndCol);

    } catch e {

      print("Trying again: " + e);

      awtLater(1.0, -> {

        moveCaretAndScroll(textArea(), lineAndCol);

      });

    }

  }

  void goToPosition(LineAndColumn lineAndCol) {

    focus(textArea());

    goToPosition_noFocus(lineAndCol);

  }

  JComponent wrapStatusLabel(JComponent lbl) {

    onLeftClick(lbl, -> goToPosition(compileResult?.errorLineAndCol()));

    popDownButton = swing(-> new JPopDownButton("Help"));

    popDownButton.onFillingMenu(menu -> addMenuItems(menu,

      "Show Scripting Help", rThread {

        showTextWordWrapped("Gazelle 'Left arrow script' Help", helpText)

      },

      "Show Global Class Names", rThread showGlobalClassNames,

      "Convert to Java", rThread convertToJava,

    ));

    ret

      centerAndEastWithMargin(

        jBorderlessHigherScrollPane(lbl),

        jfullcenter(buttons));

  }

  cachedVisual swing(-> {

    taScript = g22utils.newSyntaxTextArea(l1 wrapStatusLabel);

    bindToComponent(textArea(),

      -> g22utils.masterStuff().onNewClassesDefined(rRecompileIfError),

      -> g22utils.masterStuff().removeNewClassesDefinedListener(rRecompileIfError));

    bindTextComponentToVarWithNotify_noInitialUndo(textArea(), lvScript);

    dummyParser.install(textArea());

    //onCtrlEnter(textArea(), rThread runScript);

    // F5 to run!

    addKeyListener(textArea(), functionKeyListener(5, rThread runScript);

    // Ctrl+B to go to definition

    addKeyListener(textArea(), ctrlLetterKeyListener('b', rThread goToDefinition);

    // Permanent auto-compile on any text input

    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" := rThread runScript)),

      popDownButton);

    if (withResultPanel) {

      resultPanel = new G22ScriptResultPanel;

      collapsibleResultPanel = new CollapsibleLeftPanel(false, "Output", resultPanel.visualize(), vis);

      collapsibleResultPanel.sidePanelMargins = c -> withTopAndLeftMargin(c);

      ret collapsibleResultPanel.visualize();

    } else

      ret vis;

  });

  swappable JComponent wrapSection(JComponent c) { ret c; }

  RSyntaxTextArea textArea() {

    if (taScript == null) visualize();

    ret taScript.textArea();

  }

  void setText(S text) { main setText(textArea(), text); }

  private void compile {

    var script = lvScript!;

    var result = compileResult;

    if (!g22utils().compileResultValid(result, script)) {

      result = newCompileResult();

      result.script = script;

      result.makeParser = l0 makeParser;

      result.compile();

      compileResult(result);

      showStatus(str(compileResult));

      updateRunButtonState();

      // send errors to highlighter

      L<RSTADummyParser.Error> errors = new L;

      if (result.compileError != null) {

        LineAndColumn lineAndCol = result.errorLineAndCol();

        if (lineAndCol != null)

          errors.add(new RSTADummyParser.Error()

            .msg(result.errorToString())

            .start(lineAndCol)

            .end(LineAndColumn(lineAndCol.line+1, 1)));

      }

      dummyParser.setErrors(result.script, errors, textArea());

    }

  }

  void updateRunButtonState() {

    setEnabled(btnRun, runButtonShouldBeEnabled());

  }

  swappable bool runButtonShouldBeEnabled() {

    ret compileResult != null && compileResult.runnable();

  }

  LASCompileResult freshCompileResult() {

    rstCompile.triggerAndWait();

    ret compileResult;

  }

  GazelleV_LeftArrowScript.Script parsedScript() {

    ret freshCompileResult().parsedScript;

  }

  swappable void runScript() {

    var result = freshCompileResult();

    if (result.parsedScript != null) {

      var value = runResultWithTimestamps(-> callCompiledObjectWithTimeout(result.parsedScript));

      showScriptResult(value);

    }

  }

  void showScriptResult(OKOrError result) {

    if (result cast RunResultWithTimestamps)

      resultPanel?.logView.setText(str(result.printOutput()));

    if (result.isOK()) {

      setStatus(shorten(g22utils.stringify(result!)));

      var objVisualizer = makeObjectVisualizer(result!);

      if (result cast RunResultWithTimestamps) {

        var duration = result.duration();

        //print(+duration);

        if (duration != null) {

          long nanos = result.duration().toNanos();

          //printVars(+nanos, +objVisualizer);

          objVisualizer.nanos(nanos);

        }

      }

      if (collapsibleResultPanel != null)

        objVisualizer.withTypeAndTime(false);

      resultPanel?.scpResult.set(objVisualizer);

      if (collapsibleResultPanel != null)

        collapsibleResultPanel.sidePanelName("Output" + appendBracketed(objVisualizer.objectInfos()));

    } else {

      setStatus(

        //exceptionToStringShorter_dontDropOuterExceptions

        exceptionToStringShorter

        (result.error()));

      resultPanel?.scpResult.set(jErrorView(result.getError()));

    }

    collapsibleResultPanel?.expand();

  }

  /* compile result used to include result of execution

  class CompileResult > LASCompileResult {

    OKOrError result;

  }*/

  void setStatus aka showStatus(S status) {

    taScript?.setStatus(" " + unnull(status));

  }

  void showRuntimeError(Throwable e) {

    showStatus(exceptionToStringShorter(e));

  }

  swappable VarContext makeVarContextForExecution() { ret new FlexibleVarContext; }

  O callCompiledObjectWithTimeout(double timeoutSeconds default scriptTimeout,

    GazelleV_LeftArrowScript.Script script,

    VarContext ctx default makeVarContextForExecution()) {

    ret g22utils.evalRegisteredCode(timeoutSeconds, str(script),

      -> script.get(ctx));

  }

  /*GazelleV_LeftArrowScriptParser makeParser2() {

    var parser = makeParser();

    print("Function containers: " + parser.functionContainers);

    ret parser;

  }*/

  void showGlobalClassNames() {

    showText("Global Class Names", pnlToString(toCIMap(makeParser().globalClassNames())));

  }

  // only after visualize

  void setEditable(bool b) {

    main setEditable(textArea(), b);

  }

  swappable LASCompileResult newCompileResult() { ret new LASCompileResult; }

  void convertToJava {

    pcall-infobox {

      new ConvertLASToJava converter;

      //enableScaffolding(converter);

      showText("Java conversion - " + sectionTitle(),

        strOrNull(converter.get(parsedScript(), true)));

    }

  }

  void goToDefinition {

    S text, int iChar = unpair textAndCaretPosition(textArea());

    LS tok = lasTok(text);

    int iTok = charToTokenIndex_left(tok, iChar);

    TokPtr tokPtr = new(tok, iTok);

    var action = goToDefinitionAction(tokPtr);

    if (action != null)

      pcallF(action);

    else

      flatInfoBox("No definition found");

  }

  Runnable goToDefinitionAction(TokPtr tokPtr) {

    for (handler : cloneList(goToDefinitionHandlers()))

      try object handler.get(tokPtr);

    LS tok = tokPtr.list();

    int iTok = tokPtr.idx();

    S id = lastIdentifier(subList(tok, iTok-2, iTok+1));

    //printVars("goToDefinition", +iTok, token := quote(token));

    if (id != null) {

      S name = lookupStandardFunctionOrClassNameIC(id);

      if (name != null) {

        S snippetID = sfOrSCSnippet(id);

        if (snippetID != null) { // Should always be true

          ret -> {

            infoBox("Opening " + quote(name));

            g22utils.openInBrowser(snippetURL(snippetID));

          };

        }

      }

    }

    null;

  }

  void recompile {

    compileResult = null;

    rstCompile.trigger();

  }

  void recompileIfError {

    var result = compileResult;

    //print("JLeftArrowScriptIDE.recompileIfError " + result);

    if (result != null && result.hasError())

      recompile();

  }

  swappable G22JavaObjectVisualizer makeObjectVisualizer(O result) {

    ret G22JavaObjectVisualizer(g22utils, result)

      .allowDescendingIntoListElements(true);

  }

  void addGoToDefinitionHandler(GoToDefinitionHandler handler) {

    goToDefinitionHandlers.add(handler);

  }

  bool visible aka isShowing() {

    var ta = taScript;

    ret ta != null && main isShowing(ta.textArea);

  }

  S getText() {

    var ta = taScript;

    if (ta == null) null;

    ret main getText(ta.textArea);

  }

}