sclass JConceptsTable<A extends Concept> implements Swingable {
  Class<? extends A> conceptClass;
  Concepts concepts;
  JTable table;
  
  // options
  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;
  int updateInterval = 100;
  int firstUpdateInterval = 100;
  bool humanizeFieldNames = true;
  Float tableFontSize;
  Int tableRowHeight;
  settable bool addCountToEnclosingTab;
  
  AWTOnConceptChanges changeHandler;
  
  *() {}
  *(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);
    
    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 {
    new L<Map> data;
    Cl<? extends A> l = list(concepts, conceptClass);
    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);
 
    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(); }
  
  A getItem(int row) {
    ret (A) concepts.getConcept(toLong(getTableCell(table, row, 0)));
  }
  
  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() {
    int[] rows = table.getSelectedRows();
    new L<A> l;
    for (int row : rows)
      l.add(getItem(row));
    ret l;
  }
  
  Cl<A> defaultSort(Cl<A> l) {
    ret sortByConceptID(l);
  }
  
  /*void dropFields(S... fields) {
    dropFields = asList(fields);
  }*/
}