srecord noeq G22JavaObjectVisualizer(G22Utils g22utils) is Swingable {

  settable bool withTypeAndTime = true;

  settable bool singleLineLayout; // TODO

  settable int maxElements = 1000; // max elements of collection to show

  settable bool horizontal;

  settable int floatingPointDigits = 4;

  settable bool allowDescendingIntoListElements;

  settable double scriptTimeout = 10.0;

  settable int stringDisplayLength = 80;

  Set seen = identityHashSet();

  transient settable O object;

  transient settable long nanos = -1;

  transient SingleComponentPanel scp = scp();

  *(G22Utils *g22utils, O *object) {}

  // call after visualizeObject (so properties are filled)  

  S objectInfos(O object default this.object) {

    new LS infos;

    infos.add(str(shortClassName2(object))); // shows "null" for null value

    for (key, val : mainVisualizer().properties) {

      S s = n2OrStrOrNull(val);

      if (nempty(s))

        infos.add(key + " " + s);

    }

    if (nanos >= 0) {

      S timeDesc = nanos < 0 ? "" : formatElapsedTimeWithAppropriateUnit(nanosToSeconds(nanos));

      infos.add(timeDesc);

    }

    ret joinNemptiesWithComma(infos);

  }

  cachedVisualize {

    //printVars("Visualizing", +this, +withTypeAndTime);

    scp.set(visualizeObjectWithExtras(object));

    ret scp;

  }

  JComponent visualizeObject(O object) {

    ret mainVisualizer().visualize(object);

  }

  JComponent visualizeObjectWithExtras(O object, Component back default null) {

    JComponent c = visualizeObject(object);

    JButton btnBack = back == null ?: jimageButtonScaledToWidth(16, #1103102, -> scp.set(back));

    JComponent lblType = null;

    if (withTypeAndTime) {

      S type = objectInfos(object);

      lblType = withLabel("Type:", jlabel(type));

    }

    if (btnBack != null || lblType != null) {

      JComponent top = or(lblType, jpanel());

      if (btnBack != null)

        top = westAndCenterWithMargin(btnBack, top);

      ret northAndCenterWithMargins(top, c);

    }

    ret c;

  }

  simplyCached ObjectVisualizer mainVisualizer() {

    ret new ObjectVisualizer().recurse(true).bigFont(true).horizontal(horizontal);

  }

  class ObjectVisualizer {

    settable bool recurse;

    settable bool bigFont;

    settable bool horizontal;

    settable bool scrollable = true;

    new LinkedHashMap<S, O> properties;

    // only one recursion level so far

    ObjectVisualizer subVisualizer() {

      ret new ObjectVisualizer().horizontal(!horizontal);

    }

    ObjectVisualizer subVisualizerOnSameLevel() {

      ret new ObjectVisualizer().horizontal(horizontal)

        .recurse(recurse).bigFont(bigFont)

        .scrollable(false);

    }

    JComponent makeBig(JComponent c) {

      if (bigFont) ret fontSizePlus(10, c);

      ret c;

    }

    JComponent subVisualizeOnSameLevel(O o) {

      ret subVisualizerOnSameLevel().visualize(o);

    }

    JComponent visualize(O object) {

      try {

        ret visualize2(object);

      } catch e {

        ret g22utils.jErrorView(new RuntimeException("Visualization error", e));

      }

    }

    JComponent visualize2(O object) {

      // exception

      if (object cast Throwable)

        ret g22utils.jErrorView(object);

      // null or empty string

      if (object == null || eq(object, ""))

        ret jpanel();

      // array to list

      object = arrayToList(object);

      // Swing component

      if (object cast Swingable)

        object = object.visualize();

      if (object cast JComponent && getParent(object) == null)

        ret object;

      // number

      if (object cast Int) object = toLong(object);

      if (object cast Long)

        ret bigText(n2(object));

      if (object cast Double)

        ret toolTip(str(object), bigText(formatDouble(object, floatingPointDigits)));

      if (object cast Number)

        ret bigText(object);

      if (object cast Pair)

        ret visualizeTuple(pairToList(object));

      if (object cast T3)

        ret visualizeTuple(tripleToList(object));

      // image

      if (object cast MakesBufferedImage)      

        object = toBufferedImage(object);

      if (object cast BufferedImage) {

        var is = g22utils.stdImageSurface(object);

        if (!recurse) is.setAutoZoomToDisplay(false);

        ret jscroll_centered_borderless(is);

      }

      // FunctionDef

      if (object cast GazelleV_LeftArrowScript.FunctionDef) {

        var f = object;

        if (empty(f.args))

          ret centerAndEastWithMargin(visualizeAsText(f),

            jverticalCenter(jThreadedButton("Call", -> inspectElement(callFunctionDef(f)))));

      }

      if (recurse) {

        // TODO

        /*if (!seen.add(object))

          ret jlabel("Object already seen");*/

        // multi-map

        ifclass MultiMap

        if (object cast MultiMap) {

          propertyLength(l(object));

          propertyKeyCount(object.keyCount());

          object = multiMapToMapPairs(object);

        }

        endif

        ifclass MultiSetMap

        if (object cast MultiSetMap) {

          propertyLength(l(object));

          propertyKeyCount(object.keyCount());

          object = multiSetMapToMapPairs(object);

        }

        endif

        // map

        if (object cast Map) {

          propertyLength(l(object));

          object = mapToPairs(object);

        }

        // array / collection

        if (object cast Collection) {

          propertyLength(l(object));

          var sub = subVisualizer();

          var elements = map(cloneTakeFirst(maxElements, object),

            element -> {

              var elementVis = sub.visualize(element);

              if (allowDescendingIntoListElements)

                elementVis = centerAndEastWithMargin(

                  elementVis, new JPopDownButton().content("Inspect element" := rThread { inspectElement(element) }));

              ret elementVis;

            });

          ret stackElements(elements);

        }

      } // end of if recurse

      ret visualizeAsText(object);

    } // end of visualize2

    JComponent visualizeTuple(L tuple) {

      if (horizontal)

        ret jcenteredline(listCombine(

          jlabel("<"),

          intersperseF(-> jlabel(","), map visualize(tuple)),

          jlabel(">")));

      else

        ret stackElements(listCombine(

          map subVisualizeOnSameLevel(tuple)));

    }

    JComponent visualizeAsText(Object object) {

      if (object cast S) {

        propertyLength(l(object));

      }

      S string = str(object);

      if (containsNewLine(string))

        ret jscroll_borderless(wordWrapTypeWriterTextArea(string));

      if (recurse && l(string) > stringDisplayLength)

        ret jText(string);

      var lbl = jcenterNarrowLabel(shorten(string));

      if (l(string) <= 10)

        ret makeBig(lbl);

      ret lbl;

    } // end of visualizeAsText

    void propertyLength(int l) { properties.put("size", l); }

    void propertyKeyCount(int l) { properties.put("keys", l); }

    JComponent bigText(O o) { 

      ret makeBig(jcenteredLabel(str(o)));

    }

    O arrayToList(O object) {    

      if (isArray(object))

        object = wrapArrayAsImmutableList(object);

      ret object;

    }

    JComponent stackElements(L<? extends JComponent> elements) {    

      var c = horizontal ? hstackWithSpacing(elements)

        : vstackWithSpacing(elements);

      ret scrollable ? jscroll_centered_borderless(c) : c;

    }

  } // end of ObjectVisualizer

  selfType withType(bool b) {

    ret withTypeAndTime(b);

  }

  void inspectElement(O element) {

    var back = scp.getComponent();

    scp.set(visualizeObjectWithExtras(element, back));

  }

  O callFunctionDef(GazelleV_LeftArrowScript.FunctionDef f) {

    ret evalWithTimeoutOrFail(scriptTimeout, -> f.call(new FlexibleVarContext));

  }

}