sclass JConceptsTable<A extends Concept> implements Swingable {

  Class<? extends A> conceptClass;

  Concepts concepts;

  JTable table;

  // options

  MapSO filters; // fields to filter by/add to new objects

  S hID = "ID"; // Column header for concept ID

  settable LS dropFields;

  IF1<L> postProcess;

  Runnable afterUpdate;

  bool latestFirst;

  IF1<Cl<A>> sorter = lambda1 defaultSort;

  int idWidth = 50;

  settable int updateInterval = 100;

  int firstUpdateInterval = 100;

  bool humanizeFieldNames = true;

  Float tableFontSize;

  Int tableRowHeight;

  settable bool addCountToEnclosingTab;

  settable bool useNewChangeHandler;

  AWTOnConceptChanges changeHandler;

  AWTOnConceptChangesByClass newChangeHandler;

  *() {}

  *(Class<? extends A> *conceptClass) {}

  *(Concepts *concepts, Class<? extends A> *conceptClass) {}

  swappable MapSO itemToMap(A a) {

    ret putAll(specialFieldsForItem(a), mapValues renderForTable_noStruct(itemToMap_inner2(a)));

  }

  swappable MapSO itemToMap_inner2(A a) {

    ret allConceptFieldsAsMapExcept(a, dropFields);

  }

  // shown on the left (usually)

  swappable MapSO specialFieldsForItem(A a) {

    MapSO map = litorderedmap(hID, str(a.id));

    mapPut(map, "Java Class", javaClassDescForItem(a));

    ret map;

  }

  S javaClassDescForItem(A a) {

    S className = dynShortClassName(a);

    if (neq(className, shortClassName(conceptClass))) {

      S text = className;

      S realClass = shortClassName(a);

      if (neq(className, realClass))

        text += " as " + realClass;

      ret text;

    }

    null;

  }

  S defaultTitle() {

    ret plural(shortClassName(conceptClass));

  }

  void showAsFrame(S title default defaultTitle()) {

    makeTable();

    showFrame(title, table);

  }

  void makeTable {

    if (table != null) ret;

    if (concepts == null) concepts = db_mainConcepts();

    table = sexyTable();

    if (tableFontSize != null) {

      setTableFontSizes(tableFontSize, table);

      if (tableRowHeight == null)

        tableRowHeight = iround(tableFontSize*1.5);

    }

    if (tableRowHeight != null) setRowHeight(table, tableRowHeight);

    if (useNewChangeHandler) {

      newChangeHandler = new AWTOnConceptChangesByClass(concepts, conceptClass, table, lambda0 _update)

       .delay(updateInterval)

       .firstDelay(firstUpdateInterval);

      newChangeHandler.install();

    } else {

      changeHandler = new AWTOnConceptChanges(concepts, table, lambda0 _update)

        .delay(updateInterval)

        .firstDelay(firstUpdateInterval);

      changeHandler.install();

    }

  }

  // e.g. to update enclosing tab when hidden

  void update {

    swing { _update(); }

  }

  void _update {

    if (table == null) ret;

    new L<Map> data;

    Set<Long> selection = toSet(selectedConceptIDs());

    Cl<? extends A> l = conceptsWhere(concepts, conceptClass, mapToParams(filters));

    l = postProcess(sorter, l);

    for (A c : l)

      addIfNotNull(data, itemToMap(c));

    if (latestFirst) reverseInPlace(data);

    data = (L) postProcess(postProcess, data);

    dataToTable_uneditable(data, table);

    if (humanizeFieldNames)

      humanizeTableColumns();

    tableColumnMaxWidth(table, 0, idWidth);

    restoreSelection(selection);

    if (addCountToEnclosingTab)

      updateEnclosingTabTitle();

    pcallF(afterUpdate);

  }

  void updateEnclosingTabTitle {

    updateEnclosingTabTitleWithCount(table, countConcepts(concepts, conceptClass));

  }

  void humanizeTableColumns {

    int n = tableColumnCount(table);

    for i to n:

      setColumnName(table, i, humanizeFormLabel(getColumnName(table, i)));

  };

  visual table();

  JTable table() {

    makeTable();

    ret table;

  }

  A selectedConcept() {

    ret (A) concepts.getConcept(toLong(selectedTableCell(table, 0)));

  }

  A selected() { ret selectedConcept(); }

  long getItemID(int row) {

    ret toLong(getTableCell(table, row, 0));

  }

  A getItem(int row) {

    ret (A) concepts.getConcept(getItemID(row));

  }

  int indexOfConcept(final A c) {

    if (c == null) ret -1;

    ret swing(func -> int {

      int n = tableRowCount(table);

      for row to n:

        if (toLong(getTableCell(table, row, 0)) == c.id)

          ret row;

      ret -1;

    });

  }

  L<A> selectedConcepts() {

    ret swing(-> {

      int[] rows = table.getSelectedRows();

      new L<A> l;

      for (int row : rows)

        l.add(getItem(row));

      ret l;

    });

  }

  L<Long> selectedConceptIDs() {

    ret swing(-> {

      int[] rows = table.getSelectedRows();

      L<Long> l = emptyList(l(rows));

      for (int row : rows)

        l.add(getItemID(row));

      ret l;

    });

  }

  void restoreSelection(Set<Long> selection) swing {

    int n = tableRowCount(table);

    new IntBuffer toSelect;

    for row to n:

      if (selection.contains(getItemID(row)))

        toSelect.add(row);

    selectTableRows(table, toSelect.toIntArray());

  }

  Cl<A> defaultSort(Cl<A> l) {

    ret sortByConceptID(l);

  }

  selfType addFilter(S field, O value) {

    filters = orderedMapPutOrCreate(filters, field, value);

    this;

  }

  // call AFTER table was made

  void onSelectionChanged(Runnable r) {

    if (table == null) warn("Call onSelectionChanged after making table");

    onTableSelectionChanged(table, r);

  }

  void onSelectionChangedAndNow(Runnable r) {

    if (r == null) ret;

    onSelectionChanged(r);

    r.run();

  }

}