Add composer

Author: pcastornii

README.md

@@ -20,15 +20,13 @@
  *
  * @author Pavel Castornii
  */
-public abstract class AbstractComponentMediator<T extends ParentView<?>> implements ComponentMediator {
+public abstract class AbstractChildComposer<T extends ChildView<?>> extends AbstractParentComposer<T> {
 
-    private final T view;
+    protected abstract class ViewModelComposer extends AbstractParentComposer.ViewModelComposer {
 
-    public AbstractComponentMediator(T view) {
-        this.view = view;
     }
 
-    protected final T getView() {
-        return view;
+    public AbstractChildComposer(T view) {
+        super(view);
     }
 }

…m4fx/core/AbstractComponentMediator.java …/mvvm4fx/core/AbstractChildComposer.javamvvm4fx-core/src/main/java/com/techsenger/mvvm4fx/core/AbstractComponentMediator.java renamed to mvvm4fx-core/src/main/java/com/techsenger/mvvm4fx/core/AbstractChildComposer.java mvvm4fx-core/src/main/java/com/techsenger/mvvm4fx/core/AbstractComponentMediator.java renamed to mvvm4fx-core/src/main/java/com/techsenger/mvvm4fx/core/AbstractChildComposer.java

@@ -0,0 +1,58 @@
+/*
+ * Copyright 2024-2025 Pavel Castornii.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.techsenger.mvvm4fx.core;
+
+/**
+ *
+ * @author Pavel Castornii
+ */
+public abstract class AbstractComponentComposer<T extends ComponentView<?>> implements ComponentComposer<T> {
+
+    protected abstract class ViewModelComposer implements ComponentViewModel.Composer {
+
+    }
+
+    private final T view;
+
+    private final ComponentViewModel.Composer viewModelComposer;
+
+    public AbstractComponentComposer(T view) {
+        this.view = view;
+        this.viewModelComposer = createViewModelComposer();
+    }
+
+    @Override
+    public ParentViewModel.Composer getViewModelComposer() {
+        return viewModelComposer;
+    }
+
+    @Override
+    public void initialize() {
+
+    }
+
+    @Override
+    public void deinitialize() {
+
+    }
+
+    protected final T getView() {
+        return view;
+    }
+
+    protected abstract ComponentViewModel.Composer createViewModelComposer();
+}

mvvm4fx-core/src/main/java/com/techsenger/mvvm4fx/core/AbstractComponentComposer.java

@@ -29,8 +29,15 @@ public abstract class AbstractComponentView<T extends AbstractComponentViewModel
 
     private T viewModel;
 
+    private ComponentView.Composer composer;
+
     public AbstractComponentView(T viewModel) {
         this.viewModel = viewModel;
+        var composer = createComposer();
+        this.composer = composer;
+        if (this.composer != null) {
+            viewModel.setComposer(composer.getViewModelComposer());
+        }
     }
 
     @Override
@@ -86,6 +93,29 @@ public final void deinitialize() {
         }
     }
 
+    public ComponentView.Composer getComposer() {
+        return composer;
+    }
+
+    public void setComposer(ComponentView.Composer composer) {
+        this.composer = composer;
+    }
+
+    /**
+     * Creates a new {@link ComponentComposer} instance for this component.
+     *
+     * <p>This method is invoked during the component's construction phase and allows subclasses to provide a custom
+     * composer implementation. However, this method should be used only if the component is the owner of the composer.
+     * Otherwise the component setter should be used.
+     *
+     * <p>The default implementation returns {@code null}, meaning the component does not create a composer by default.
+     *
+     * @return a newly created {@link ComponentComposer}, or {@code null} if none is required
+     */
+    protected ComponentComposer<?> createComposer() {
+        return null;
+    }
+
     /**
      * Returns the component descriptor for convenient access. This is a shortcut method that delegates to the
      * underlying ViewModel's descriptor.

mvvm4fx-core/src/main/java/com/techsenger/mvvm4fx/core/AbstractComponentView.java

@@ -37,6 +37,8 @@ public abstract class AbstractComponentViewModel implements ComponentViewModel {
 
     private ComponentHistory<?> history;
 
+    private ComponentViewModel.Composer composer;
+
     public AbstractComponentViewModel() {
         this.descriptor = createDescriptor();
         this.descriptor.stateProperty().addListener((ov, oldV, newV) -> {
@@ -111,6 +113,14 @@ public void setHistoryProvider(HistoryProvider historyProvider) {
         this.historyProvider = historyProvider;
     }
 
+    public Composer getComposer() {
+        return composer;
+    }
+
+    public void setComposer(Composer composer) {
+        this.composer = composer;
+    }
+
     protected void postHistoryRestore() {
 
     }

mvvm4fx-core/src/main/java/com/techsenger/mvvm4fx/core/AbstractComponentViewModel.java

@@ -0,0 +1,33 @@
+/*
+ * Copyright 2024-2025 Pavel Castornii.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.techsenger.mvvm4fx.core;
+
+/**
+ *
+ * @author Pavel Castornii
+ */
+public abstract class AbstractParentComposer<T extends ParentView<?>> extends AbstractComponentComposer<T> {
+
+    protected abstract class ViewModelComposer extends AbstractComponentComposer.ViewModelComposer {
+
+    }
+
+    public AbstractParentComposer(T view) {
+        super(view);
+    }
+
+}

mvvm4fx-core/src/main/java/com/techsenger/mvvm4fx/core/AbstractParentComposer.java

@@ -35,7 +35,6 @@ public abstract class AbstractParentView<T extends AbstractParentViewModel> exte
 
     public AbstractParentView(T viewModel) {
         super(viewModel);
-        viewModel.setMediator(createMediator());
         childrenSynchronizer = new ListSynchronizer<ChildView<?>, ChildViewModel>(children,
                 viewModel.getModifiableChildren(), (v) -> v.getViewModel());
     }
@@ -67,21 +66,6 @@ List<ParentView<?>> getChildren(ParentView<?> parent) {
         };
     }
 
-    /**
-     * Creates a new {@link ComponentMediator} instance for this component.
-     *
-     * <p>This method is invoked during the component's construction phase and allows subclasses to provide a custom
-     * mediator implementation that defines how the {@code ComponentViewModel} interacts with its {@code ComponentView}.
-     * The created mediator is then automatically assigned to the ViewModel.
-     *
-     * <p>The default implementation returns {@code null}, meaning the component does not use a mediator by default.
-     *
-     * @return a newly created {@code ComponentMediator}, or {@code null} if none is required
-     */
-    protected ComponentMediator createMediator() {
-        return null;
-    }
-
     @Override
     protected void addListeners(T viewModel) {
         super.addListeners(viewModel);
@@ -97,6 +81,5 @@ protected void addListeners(T viewModel) {
                 }
             }
         });
-
     }
 }

mvvm4fx-core/src/main/java/com/techsenger/mvvm4fx/core/AbstractParentView.java

@@ -31,17 +31,10 @@ public abstract class AbstractParentViewModel extends AbstractComponentViewModel
     private final ObservableList<ChildViewModel> children =
             FXCollections.unmodifiableObservableList(modifiableChildren);
 
-    private ComponentMediator mediator;
-
     public AbstractParentViewModel() {
         super();
     }
 
-    @Override
-    public ComponentMediator getMediator() {
-        return this.mediator;
-    }
-
     @Override
     public ObservableList<ChildViewModel> getChildren() {
         return children;
@@ -69,10 +62,6 @@ List<ParentViewModel> getChildren(ParentViewModel parent) {
         };
     }
 
-    public void setMediator(ComponentMediator mediator) {
-        this.mediator = mediator;
-    }
-
     ObservableList<ChildViewModel> getModifiableChildren() {
         return modifiableChildren;
     }

mvvm4fx-core/src/main/java/com/techsenger/mvvm4fx/core/AbstractParentViewModel.java

@@ -0,0 +1,26 @@
+/*
+ * Copyright 2024-2025 Pavel Castornii.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.techsenger.mvvm4fx.core;
+
+/**
+ *
+ * @author Pavel Castornii
+ */
+public interface ComponentComposer<T extends ComponentView<?>> extends ComponentView.Composer {
+
+    ComponentViewModel.Composer getViewModelComposer();
+}

mvvm4fx-core/src/main/java/com/techsenger/mvvm4fx/core/ComponentComposer.java

@@ -22,8 +22,8 @@
  * Represents a serializable snapshot of a component's {@code ViewModel} state. A history object stores only the
  * information that must persist between component sessions and excludes all transient or runtime aspects.
  *
- * <p>The {@code ViewModel} itself may contain both persistent and non-persistent values. It also defines default values
- * for all of its properties, regardless of whether they are stored in the history or used only at runtime. The
+ * <p>The {@code ViewModel} itself may contain both persistent and non-persistent values. It also defines default
+ * values for all of its properties, regardless of whether they are stored in the history or used only at runtime. The
  * {@code ViewModel} owns the meaning of those defaults, while the history is responsible solely for persisting and
  * restoring the subset of states that are marked as persistent.
  *