please include function myInnerClasses.

static abstract class DynModule extends DynamicObject is Enterable, ChangeTriggerable

ifdef DynModule_NewChangeEvent , IHasChangeListeners endifdef {

  // we really shouldn't have used up these variable names

  // (subclasses can't overload them due to how the persistence works)

  S name, toolTip; // module name, module tool tip in task bar

  PersistableThrowable _error;

  Map<S, Collection<S>> mechLists;

  Map<S, Bool> _persistenceInfo;

  transient O _host; // pointer to this module's stem

  transient Map<O, IVF1> timers = newWeakHashMap(); // all kinds of resources actually; value is closer helper

  transient Set<AutoCloseable> _resources = synchroHashSet();

  transient Lock lock; // set by stem

  transient bool persistOnChangedField = true;

  transient int changeCount;

  transient new O changeCountSync;

  transient L onChange;

  transient L onTransientChange;

  transient bool verboseTimers;

  transient ReliableSingleThread rstUpdate;

  transient Set<S> componentFieldsToKeep;

  // TODO: use DynamicObject for this

  transient MapSO transientGeneralMap = synchroHashMap();

  transient Q q; // module command queue

  transient L onFieldChange; // also for non-persistent fields. L<voidfunc(S field)>

  transient bool _hasPreviousBounds;

  transient new StringBuffer _printLog;

  transient bool deleted;

  *() {

    if (useErrorHandling())

      dm_initErrorHandling();

    // TODO: DynModule is now shared between modules, so not good

    setMainDesktopPane((JDesktopPane) getCreatorOpt('desktop));

  }

  bool useErrorHandling() { true; }

  bool isVisible() { ret isTrue(getOpt(_host, 'visible)); }

  S moduleName() { ret name; }

  void setModuleName(S name) {

    S oldName = this.name;

    if (!eq(name, oldName)) {

      setField(+name);

      possiblyInternalFrameTitle(vis(), name);

      vmBus_send('moduleNameChange, this, oldName, name);

    }

  }

  void setModuleToolTip(S toolTip) {

    this.toolTip = toolTip;

  }

  JComponent vis() {

    ret (JComponent) getOpt(_host, 'vis);

  }

  <A extends AutoCloseable> A ownResource(A a) {

    if (a != null)

      _resources.add(a);

    ret a;

  }

  <A> A ownTimer(A timer) {

    if (timer cast AutoCloseable)

      ownResource(timer);

    else

      ownTimer(timer, lambda1 cancelTimerOrInterruptThread);

    ret timer;

  }

  void ownTimer(O timer, IVF1 closerHelper) {

    timers.put(timer, closerHelper);

  }

  void singleTimer(java.util.Timer timer) {

    stopAllTimers();

    ownTimer(timer);

  }

  void stopAllTimers() {

    for (AutoCloseable resource : getAndClearList(_resources)) {

      if (verboseTimers)

        print("Releasing resource: " + resource);

      pcall { resource.close(); }

    }

    for (O timer, IVF1 closerHelper : getAndClearMap(timers)) {

      if (verboseTimers)

        print("Stopping timer: " + closerHelper + " / " + timer);

      pcallF(closerHelper, timer);

    }

  }

  bool isDeleted() { ret deleted; }

  bool deleted() { ret deleted; }

  void cleanMeUp_dynModule {

    set deleted;

    dispose q;

    stopAllTimers();

  }

  void persistMe {

    synchronized(changeCountSync) { ++changeCount; }

    pcallFAll(onChange); callOpt(_host, '_change);

    updateMe();

  }

  void fireChangeWithoutPersisting {

    pcallFAll(onChange);

  }

  void fireTransientChange {

    pcallFAll(onTransientChange);

  }

  final void _change { persistMe(); }

  final public void change { persistMe(); }

  void updateMe {

    rstUpdate().trigger();

  }

  void changeAndUpdate { _change(); updateMe(); }

  bool setField_noPersist(S name, O value) {

    ret setField(name, value, true);

  }

  bool _setField(S name, O value) {

    ret setField(name, value);

  }

  bool setField(S name, O value, bool noPersist default false) {

    temp enter();

    pcall { // some really weird classes fail on equals() (BCEL JavaClass, I'm looking at you)

      if (eq(get(this, name), value)) false;

    }

    ret setField_noCheck(name, value, noPersist);

  }

  // always set even if equal

  bool setField_noCheck(S name, O value, bool noPersist default false) enter {

    //set(this, name, value); 

    setOpt(this, name, value); // XXX allow virtual fields

    pcallFAll(onFieldChange, name);

    // XXX - new check for transient field

    if (!noPersist && dm_isPersistentField(me(), name))

      _change();

    true;

  }

  <A> A setFieldAndReturn(S name, A value) {

    setField(name, value);

    ret value;

  }

  bool setFields(O... params) {

    bool change = false;

    for (int i = 0; i < l(params); i += 2)

      if (setField((S) params[i], params[i+1])) change = true;

    ret change;

  }

  void start {

    _hasPreviousBounds = dm_getBounds() != null;

    if (hasMethod_onTypes(this, 'onTopInput, S))

      dm_onTopInput_q(voidfunc(S s) { call(module(), 'onTopInput, s) });

  }

  void revisualize {

    call(dm_os(), 'revisualizeModule, _host);

  }

  bool useEnterShortcut() { false; }

  public AutoCloseable enter() {

    AutoCloseable c = tempSetBetterThreadLocalIfNecessary_weakRef(dm_current_generic_tl(), this);

    /// XXX shortcut, testing now (doesn't seem to work yet)

    if (c == null && useEnterShortcut()) null; // assume we are entered (so the rest of what we do in this function is also done)

    O realMC = getMainClass(this);

    if (printToModule())

      c = combineAutoCloseables(c, tempInterceptPrintIfNotIntercepted(_printToModuleInterceptor()));

    if (realMC != mc()) {

      if (printToModule())

        c = combineAutoCloseables(c, (AutoCloseable) callOpt(realMC, 'tempInterceptPrintIfNotIntercepted, _printToModuleInterceptor()));

      else

        c = combineAutoCloseables(c, tempInterceptPrintIfNotIntercepted(func(S s) -> bool {

          ret false with call(realMC, 'print, s);

        }));

      c = combineAutoCloseables(c, tempSetTL(realMC_tl(), realMC));

    }

    ret c;

  }

  F1<S, Bool> _printToModuleInterceptor() {

    ret func(S s) -> bool {

      if (print_preprocess != null) s = (S) callF(print_preprocess, s);

      s = fixNewLines(s);

      Appendable loc = _printLog;

      Appendable buf = print_log;

      int loc_max = print_log_max;

      if (buf != loc && buf != null) {

        print_append(buf, s, print_log_max);

        loc_max = local_log_max;

      }

      if (loc != null) 

        print_append(loc, s, loc_max);

      if (printAlsoToSystemOut)

        System.out.print(s);

      false;

    };

  }

  bool printToModule() { true; } // on by default now

  AutoCloseable enterAndLock() {

    ret combineAutoCloseables(enter(), tempLock(lock));

  }

  bool setError(Throwable e) {

    setField(_error := persistableThrowable(e));

    true;

  }

  void clearError {

    setField(_error := null);

  }

  ifdef DynModule_NewChangeEvent

    public selfType onChange(Runnable r) {

      lock lock;

      if (onChange == null) onChange = synchroList();

      addIfNotThere(onChange, r);

      this;

    }

    public selfType removeChangeListener(Runnable r) {

      remove(onChange, r);

      this;

    }

  endifdef

  ifndef DynModule_NewChangeEvent

    void onChange(Runnable r) {

      lock lock;

      if (onChange == null) onChange = synchroList();

      addIfNotThere(onChange, r);

    }

    public void removeChangeListener(Runnable r) {

      remove(onChange, r);

    }

  endifndef

  void onFieldChange(VF1<S> r) {

    lock lock;

    if (onFieldChange == null) onFieldChange = synchroList();

    addIfNotThere(onFieldChange, r);

  }

  void removeFieldChangeListener(VF1<S> r) {

    remove(onFieldChange, r);

  }

  ifndef DynModule_NewChangeEvent

    void onChangeAndNow(Runnable r) {

      onChange(r);

      callF(r);

    }

  endifndef

  // forward to main class

  void onChangeAndNow(JComponent c, O r) {

    onUpdateAndNow(c, r);

  }

  void onChangeAndNow(L<? extends JComponent> l, O r) {

    main onChangeAndNow(l, r);

  }

  void onChangeAndNow(JTextComponent c, IVF1<S> r) {

    onUpdateAndNow(c, r);

  }

  /*static*/ <A extends JComponent> A onChange(A tc, O r) {

    onUpdate(tc, r);

    ret tc;

  }

  void update() {}

  void unvisualize() {

    zeroAllFieldsOfTypeExcept(this, Component, componentFieldsToKeep);

  }

  // return L<AbstractAction> (legacy)

  // or litobjectarray(text, Runnable, text, Runnable, ...)

  O menuItems() {

    null;

  }

  void enhanceFrame(Container f) {

    ifndef NoMenuItems

    O items = menuItems();

    if (items instanceof O[])

      items = paramsToAbstractActions((O[]) items);

    internalFramePopupMenuFromActions_threaded(f, (L) items);

    endifndef

    ifndef NoSwitchableFields

    S switchableFields = cast callOpt(this, 'switchableFields);

    Set<S> set = asLinkedHashSet(splitAtSpace(switchableFields));

    new Matches m;

    for (S field : allFields(getClass()))

      if (startsWith(field, "_switchableField_", m))

        set.add(m.rest());

    for (S field : set) {

      Class type = fieldType(this, field);

      if (eq(bool.class, type))

        dm_boolFieldMenuItem(f, field);

      else if (eq(int.class, type))

        dm_intFieldMenuItem(f, field);

      else if (eq(long.class, type))

        dm_longFieldMenuItem(f, field);

      else if (eq(double.class, type))

        dm_doubleFieldMenuItem(f, field);

      else if (eq(float.class, type))

        dm_floatFieldMenuItem(f, field);

      else if (eq(S, type))

        dm_stringFieldMenuItem(f, field);

      else if (eq(File.class, type))

        dm_fileFieldMenuItem(f, field);

    }

    endifndef

  }

  // assume this is called in start(), so no locking

  ReliableSingleThread rstUpdate() {

    if (rstUpdate == null) rstUpdate = dm_rst(this, r enter { update(); });

    ret rstUpdate;

  }

  Q q() enter {

    if (q == null) {

      lock lock;

      if (q == null) q = dm_startQ();

    }

    ret q;

  }

  <A> A withUpdate(A a) {

    rstUpdate().trigger();

    ret a;

  }

  DynModule module() { this; }

  DynModule me() { this; }

  JComponent visualize() {

    ret dm_noVisualisation();

  }

  S programTitle_cache;

  S programTitle() {

    if (programTitle_cache == null)

      programTitle_cache = snippetTitle(programID(mainClass(this)));

    ret programTitle_cache;

  }

  // field must be non-transient

  void doPersist(S field) {

    _persistenceInfo = mapMinus(_persistenceInfo, field);

  }

  void dontPersist(S field) {

    _persistenceInfo = mapPlus(_persistenceInfo, field := false);

  }

  Appendable _actualPrintLog() { ret printToModule() ? _printLog : print_log; }

  O getHost() { ret _host; }

  !include #1031423 // DynModule convenience methods

} // end of DynModule

static void _registerTimer(java.util.Timer timer) {

  _registerTimer_original(timer);

  var mod = dm_currentModule();

  mod?.ownTimer(timer);

}

!include once #1023504