sclass JConceptsTable<A extends Concept> is 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;

  settable bool noSubclasses;

  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;

  settable IVF1<A> defaultAction;

  bool pauseUpdates;

  int count;

  event selectionChanged;

  event singleSelectionChanged;

  // internal

  AWTOnConceptChanges changeHandler;

  AWTOnConceptChangesByClass newChangeHandler;

  bool updatingList;

  settable A selectAfterUpdate;

  A lastSelected;

  *() {}

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

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

  swappable MapSO itemToMap(A a) {

    MapSO map = specialFieldsForItem(a);

    try {

      putAll(map, mapValues renderValue(itemToMap_inner2(a)));

    } catch print e {

      map.put("Error", str(e));

    }

    ret map;

  }

  swappable O renderValue(O o) {

    ret renderForTable_noStruct(o);

  }

  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, l0 _update)

       .delay(updateInterval)

       .firstDelay(firstUpdateInterval);

      newChangeHandler.install();

    } else {

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

        .delay(updateInterval)

        .firstDelay(firstUpdateInterval);

      changeHandler.install();

    }

    onTableSelectionChanged(table, -> {

      if (updatingList) ret;

      selectionChanged();

    });

    onSelectionChanged(-> {

      var a = selected();

      if (a != lastSelected) {

        lastSelected = a;

        singleSelectionChanged();

      }

    });

    onDoubleClickOrEnter(table, -> {

      A a = selected();

      if (a != null && defaultAction != null)

        pcallF(defaultAction, a);

    });

  }

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

  void update {

    swing { _update(); }

  }

  // run in Swing thread

  void _update {

    if (table == null || pauseUpdates) ret;

    set updatingList;

    bool allRestored;

    A selectAfterUpdate = selectAfterUpdate();

    try {

      new L<Map> data;

      Set<Long> selection;

      if (selectAfterUpdate != null) {

        selection = litset(selectAfterUpdate._conceptID());

        selectAfterUpdate(null);

      } else

        selection = toSet(selectedConceptIDs());

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

      if (noSubclasses) l = filter(l, x -> x.getClass() == conceptClass);

      l = postProcess(sorter, l);

      for (A c : l)

        addIfNotNull(data, itemToMap(c));

      if (latestFirst) reverseInPlace(data);

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

      count = l(data);

      dataToTable_uneditable(data, table);

      if (humanizeFieldNames)

        humanizeTableColumns();

      tableColumnMaxWidth(table, 0, idWidth);

      allRestored = restoreSelection(selection);

      if (addCountToEnclosingTab)

        updateEnclosingTabTitle();

    } finally {

      updatingList = false;

    }

    pcallF(afterUpdate);

    if (!allRestored || selectAfterUpdate != null)

      selectionChanged();

  }

  void updateEnclosingTabTitle {

    updateEnclosingTabTitleWithCount(table, count);

  }

  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));

  }

  L<A> getList() swing {

    ret countIteratorAsList(size(), row -> getItem(row));

  }

  A getItem(int row) {

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

  }

  int size() { ret tableRowCount(table); }

  int indexOfConcept(final A c) {

    if (c == null) ret -1;

    ret swing(func -> int {

      int n = size();

      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;

    });

  }

  // returns true if all selected items still exist

  bool restoreSelection(Set<Long> selection) {

    ret swing(-> {

      int n = size();

      new IntBuffer toSelect;

      for row to n:

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

          toSelect.add(row);

      selectTableRows(table, toSelect.toIntArray());

      ret toSelect.size() == selection.size();

    });

  }

  void setSelected(A a) {

    selectRow(table(), indexOfConcept(a));

  }

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

    ret sortByConceptID(l);

  }

  selfType addFilter(S field, O value) {

    filters = orderedMapPutOrCreate(filters, field, value);

    this;

  }

  void onSelectionChangedAndWhenShowing(Runnable r) {

    bindToComponent(table(), r);

    onSelectionChanged(r);

  }

  void onSelectionChangedAndNow(Runnable r) {

    if (r == null) ret;

    onSelectionChanged(r);

    r.run();

  }

  selfType updateInterval(double seconds) {

    ret updateInterval(toMS_int(seconds));

  }

  selfType pauseUpdates(bool b) {

    swing {

      if (pauseUpdates != b) {

        if (!(pauseUpdates = b))

          _update();

      }

    }

    this;

  }

}