// optional parameters

static ThreadLocal<L<S>> showConceptsTable_dropFields = new ThreadLocal;

static new ThreadLocal showConceptsTable_postProcess; // func(L) -> L

static new ThreadLocal showConceptsTable_afterUpdate; // voidfunc(JTable)

static new ThreadLocal<Concepts> showConceptsTable_concepts;

static new ThreadLocal<Bool> showConceptsTable_latestFirst;

static new ThreadLocal<O> showConceptsTable_sorter; // func(Cl<Concept>) -> Cl<Concept>

static int makeConceptsTable_idWidth = 50;

static JTable showConceptsTable(Class<? extends Concept> c) {

  JTable table = makeConceptsTable(c);

  showFrame(plural(shortClassName(c)), table);

  ret table;

}

static JTable makeConceptsTable(Class<? extends Concept> c) {

  LS dropFields = getAndClearThreadLocal(showConceptsTable_dropFields);

  O pp = getAndClearThreadLocal(showConceptsTable_postProcess);

  O afterUpdate = optParam(showConceptsTable_afterUpdate);

  Concepts concepts = optParam(showConceptsTable_concepts, db_mainConcepts());

  bool latestFirst = boolParam(showConceptsTable_latestFirst);

  O sorter = optParam(showConceptsTable_sorter);

  bool useStruct = boolParam(dataToTable_useStruct);

  final L<S> fields = listMinusList(concatLists(ll("id"), conceptFieldsInOrder(c)), dropFields);

  final JTable table = sexyTable();

  tablePopupMenu(table, voidfunc(JPopupMenu menu, final int row) {

    addMenuItem(menu, "Delete", r {

      final long id = toLong(getTableCell(table, row, 0));

      deleteConcept_sync(concepts, id);

    });

  });

  temp tempSetTL(awtOnConceptChanges_concepts, concepts);

  awtOnConceptChanges(table, r {

    //print("Updating concept table");

    new L<L> data;

    Cl<? extends Concept> l = list(concepts, c);

    if (sorter != null) l = (Cl) callF(sorter, l);

    for (Concept cc : l)

      data.add(map(func(S field) {

        O value = cget(cc, field);

        ret useStruct ? renderForTable(value)

                      : renderForTable_noStruct(value);

      }, fields));

    if (latestFirst) reverseInPlace(data);

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

    fillTableWithData(table, data, map humanizeFormLabel(fields));

    if (table.getColumnCount() > 0)

      table.getColumnModel().getColumn(0).setMaxWidth(makeConceptsTable_idWidth);

    pcallF(afterUpdate, table);

  }, true);

  ret table;

}

// renderer takes a concept and makes a map for display

static <A extends Concept> JTable makeConceptsTable(final Class<A> cClass, final O renderer) {

  if (renderer == null) ret makeConceptsTable(cClass);

  fO pp = optParam(showConceptsTable_postProcess);

  fO afterUpdate = optParam(showConceptsTable_afterUpdate);

  final Concepts concepts = optParam(showConceptsTable_concepts, db_mainConcepts());

  fbool latestFirst = boolParam(showConceptsTable_latestFirst);

  O sorter = optParam(showConceptsTable_sorter);

  bool useStruct = boolParam(dataToTable_useStruct);

  final JTable table = sexyTable();

  temp tempSetTL(awtOnConceptChanges_concepts, concepts);

  awtOnConceptChanges(table, 1000, r {

    new L<Map> data;

    Cl<A> l = list(concepts, cClass);

    if (sorter != null) l = (Cl) callF(sorter, l);

    for (A c : l)

      addIfNotNull(data, (Map) pcallF(renderer, c));

    if (latestFirst) reverseInPlace(data);

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

    ifdef makeConceptsTable_debug

      printVars makeConceptsTable(+useStruct);

    endifdef

    temp tempSetTL(dataToTable_useStruct, useStruct);

    dataToTable_uneditable(data, table);

    pcallF(afterUpdate, table);

  });

  ret table;

}

static <A extends Concept> JTable showConceptsTable(final Class<A> c, final O f) {

  JTable table = makeConceptsTable(c, f);

  showFrame(plural(shortClassName(c)), table);

  ret table;

}

static <A extends Concept> JTable showConceptsTable(S title, Class<A> cClass, O f) {

  ret setFrameTitle(title, showConceptsTable(cClass, f));

}