sclass JObjectTable<A> is Swingable {

  new L<A> data;

  transient IF1<A, Map> itemToMap;

  transient Set<S> hideFields;

  transient bool debug, fieldsInOrder = true, withSearcher;

  settable IVF1<A> defaultAction;

  transient gettable JTable table;

  transient TableSearcher searcher;

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

  event listChanged;

  *() {

    itemToMap = a -> {

      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;

    };

  }

  void onListChangedAndNow(Runnable r) {

    if (r == null) ret;

    onListChanged(r);

    r.run();

  }

  cachedVisualize {

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

    table = dataToTable_uneditable(sexyTable(), l);

    onDoubleClickOrEnter(table, voidfunc(int row) {

      A a = _get(data, row);

      if (a != null) defaultAction?.get(a);

    });

    if (withSearcher)

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

    ret jscroll(table);

  }

  void updateTable() {

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

    }

    listChanged();

  }

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

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

    swing {

      int[] selection = selectedTableRows_array(table);

      L<A> cloned = cloneList(data);

      if (force || !eq(this.data, cloned)) {

        this.data = cloned;

        updateTable();

      }

      selectTableRows(table, selection);

    }

  }

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

  void setData_force(Iterable<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)) defaultAction?.get(a); }

  // run only after visualized!

  void popupMenuItem(S text, IVF1<A> r) {

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

  }

  void popupMenuItem_top(S text, IVF1<A> r) {

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

  }

  // row index => element

  IVF1<Int> _convertRunnable(IVF1<A> r) {

    ret r == null ?: idx -> r.get(syncGet(data, idx));

  }

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

  void onSelect(IVF1<A> r) {

    visualize();

    onTableSelectionChanged(table, -> pcallF_typed(r, selected()));

  }

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

}