abstract sclass DynObjectTable<A> extends DynModule {

  new L<A> data;

  transient JTable table;

  transient F1<A, Map> itemToMap;

  transient VF1<A> defaultAction;

  transient bool debug, fieldsInOrder = true, withSearcher;

  transient TableSearcher searcher;

  transient L onListChanged;

  transient Set<S> hideFields;

  transient bool useStruct = false; // possible breaking change for older modules

  start {

    itemToMap = func(A a) -> Map {

      if (a instanceof S) ret litorderedmap("" := (S) a);

      Map map = humanizeKeys(fieldsInOrder ? objectToMap_inOrder_withoutFields(a, hideFields) : objectToMap(a));

      if (!useStruct) map = mapValues strOrEmpty(map);

      ret map;

    };

    onChange(r updateTable);

  }

  void onListChanged(Runnable r) {

    if (r == null) ret;

    onListChanged = addDyn_sync(onListChanged, r);

  }

  void onListChangedAndNow(Runnable r) {

    if (r == null) ret;

    onListChanged(r);

    r.run();

  }

  void addCountToName {

    onListChangedAndNow(r addCountToNameNow);

  }

  void addCountToNameNow() enter {

    setModuleName(programTitle() + " (" + count() + ")");

  }

  visualize {

    L<Map> l = map(itemToMap, data);

    table = dataToTable_uneditable(sexyTable(), l);

    onDoubleClickOrEnter(table, voidfunc(int row) {

      temp enter();

      A a = _get(data, row);

      if (a != null) onDoubleClick(a);

    });

    if (withSearcher)

      ret (searcher = tableWithSearcher2(table)).panel;

    ret table;

  }

  void unvisualize() { super.unvisualize(); searcher = null; }

  void onDoubleClick(A line) { callF(defaultAction, line); }

  void updateTable() enter {

    if (table != null) swing {

      Point scrollPosition = enclosingViewPosition(table);

      if (debug) print("Scroll position: " + scrollPosition);

      dataToTable_uneditable(table, map(itemToMap, data));

      setEnclosingViewPosition(table, scrollPosition);

      if (searcher != null) searcher.rowIndices = null;

      if (debug) print("dataToTable done, alerting " + n2(onListChanged, "listener"));

    }

    pcallFAll(onListChanged);

  }

  /*TODO void itemChanged(int row, A entry) {

    if (getRow(row) != entry) {

      fireDataChanged();

      warn("Item index mismatch, recreating table");

    }

    rows.add(dataToTable_makeRow(x, cols));

  }*/

  void dontPersist() { _persistenceInfo = mapPlus(_persistenceInfo, data := false); }

  void clear() { syncClear(data); fireDataChanged(); }

  void add(A a) { syncAdd(data, a); fireDataChanged(); }

  A addAndReturn(A a) { add(a); ret a; }

  void add(int idx, A a) { syncAdd(data, idx, a); fireDataChanged(); }

  void addAll(Collection<A> l) { if (empty(l)) ret; syncAddAll(data, l); fireDataChanged(); }

  void addAndScrollDown(A a) { add(a); scrollDown(); }

  void remove(A a) { syncRemove(data, a); fireDataChanged(); }

  void removeAll(L<A> a) { syncRemoveAll(data, a); fireDataChanged(); }

  void setList(Iterable<A> data) { setData(data); }

  void removeSelected() { removeAll(allSelected()); }

  // rare legacy binary compatibility workaround

  void setData(Collection<A> data) { setData((Iterable) data); }

  void setData(Iterable<A> data) {

    setData(data, false);

  }

  void setData(Iterable<A> data, bool force) {

    // ATTN: new logic. test if it works in all cases

    swing {

      //int selection = selectedIndex();

      int[] selection = selectedTableRows_array(table);

      L<A> cloned = cloneList(data);

      if (setField(data := cloned) || force) {

        updateTable();

        dm_vmBus_send listChanged(module(), cloned);

      }

      if (force) change();

      //selectRow(table, selection);

      selectTableRows(table, selection);

    }

  }

  int count() { ret syncL(data); }

  void setData_force(Collection<A> data) {

    setData(data, true);

  }

  // tries to keep selection

  void fireDataChanged() {

    setData_force(data);

  }

  int rowFromSearcher(int i) {

    ret searcher == null || searcher.rowIndices == null ? i : or(get(searcher.rowIndices, i), -1);

  }

  A selected() { ret syncGet(data, rowFromSearcher(selectedTableRowInModel(table))); }

  L<A> allSelected() { ret syncListGetMulti(data, selectedIndices()); }

  int selectedIndex() { ret selectedTableRow(table); }

  L<Int> selectedIndices() { ret map(i -> rowFromSearcher(i), selectedTableRowsInModel(table)); }

  bool selectItem(A a) { int i = indexOf(data, a); selectRow(table, i); ret i >= 0; } // true if item exists

  void doubleClickItem(A a) { if (selectItem(a)) onDoubleClick(a); }

  // r : Runnable or VF1<A>

  // run only in visualize()!

  void popupMenuItem(S text, O r) {

    tablePopupMenuItemsThreaded(table, text, _convertRunnable(r));

  }

  void popupMenuItem_top(S text, O r) {

    tablePopupMenuItemsThreaded_top(table, text, _convertRunnable(r));

  }

  // row index => element

  O _convertRunnable(fO r) {

    if (r == null || r instanceof Runnable) ret r;

    ret voidfunc(int idx) { callF(r, syncGet(data, idx)) };

  }

  JTable table() { ret table; }

  void hideFields(S... fields) {

    if (hideFields == null) hideFields = new Set;

    _addAll(hideFields, fields);

  }

  A getRow(int row) { ret get(data, row); }

  void scrollDown { scrollTableDownNow(table); }

  // API

  L<A> getData() { ret data; } // data is usually immutable

  L<A> data() { ret getData(); }

  L<A> list() { ret getData(); }

  L<A> getList() { ret getData(); }

  L<A> clonedList() { ret cloneList(data); }

  // log list (and whole module) contents somewhere

  File quickBackup() {

    File f = programFile("backup-" + ymd_minus_hms_minus_millis() + ".gz");

    saveGZStructToFile(f, module());

    printFileInfo(f);

    ret f;

  }

}