Add composer and mediator methods

Author: pcastornii

README.md

@@ -17,7 +17,7 @@ As a real example of using this framework, see [TabShell](https://github.com/tec
     * [Component Structure](#component-structure)
     * [Component Lifecycle](#component-lifecycle)
     * [Component Hierarchy](#component-hierarchy)
-    * [Composite Component](#composite-component)
+    * [Component Composer](#component-composer)
     * [When to Create a Component?](#when-to-create-component)
     * [When not to Create a Component?](#when-not-to-create-component)
 * [Requirements](#requirements)
@@ -144,8 +144,9 @@ exclusively between the `ComponentViewModel` and the `ComponentHistory`. When th
 transitions to `DEINITIALIZED`, data from the `ComponentViewModel` is saved back to the `ComponentHistory`. The volume
 of state information that is restored and persisted is defined by the `HistoryPolicy` enum.
 
-The `ComponentComposer` is responsible for managing child components and their composition, while the `ComponentMediator`
-allows `ComponentViewModel` to interact with the `ComponentComposer` (see [Composite Component](#composite-component)).
+The `ComponentComposer` is responsible for managing child and derived components and their composition, while the
+`ComponentMediator` allows `ComponentViewModel` to interact with the `ComponentComposer`
+(see [Component Composer](#component-composer)).
 
 ### Component Lifecycle <a name="component-lifecycle"></a>
 
@@ -194,15 +195,17 @@ between the presentation (`View`) and logic (`ViewModel`) layers. This design en
 across the component tree without violating the Unidirectional Hierarchy Rule (UHR), as the relationships are strictly
 hierarchical and non-cyclic.
 
-### Composite Component <a name="composite-component"></a>
+### Component Composer<a name="component-composer"></a>
 
-Components can be either simple or composite. A simple component has no child components. A composite component has
-one or more child components. The use of `Composer` and `Mediator` is required only for components that manage children
-or dynamically create other components, such as dialogs, panels, or complex containers. Working with a composite
-component is one of the most challenging parts of using the platform for the following reasons:
+The `ComponentComposer` is responsible for:
+1. Creating, positioning, and managing child components (those that will reside directly inside this component).
+2. Creating and positioning derived components (those that will be provided to another component after creation,
+e.g., dialogs, tabs, system notifications, etc.).
 
-1. MVVM Gap. MVVM does not specify how child components should be created, how their lifecycle should be managed, or
-how they should be composed.
+Working with a composite component is one of the most challenging parts of using the platform for the following reasons:
+
+1. MVVM Gap. MVVM does not specify how child and derived components should be created, how their lifecycle should be
+managed, or how they should be composed.
 2. Architectural Conflict. According to MVVM, the `ViewModel` must not know about the `View`, yet the `ViewModel` may
 need to initiate the creation of new components (for example, opening a dialog) and their composition — which is
 impossible without interacting with the `View`.
@@ -213,12 +216,11 @@ since names like `SomeComponentViewComposer` and `SomeComponentViewModelComposer
 must be created: `ChildView` extends `ParentView`, `ChildViewModel` extends `ParentViewModel`, `ChildComposer` extends
 `ParentComposer` etc.
 
-In MVVM4FX, the solution for working with composite components is implemented using two classes: `Composer` and `Mediator`:
+In MVVM4FX, the solution is implemented using two classes: `ComponentComposer` and `ComponentMediator`:
 
-`Mediator`. This is the interface that the `ViewModel` uses to interact with the `Composer`. The need for an
-interface is driven by two factors: first, it allows the `ViewModel` to be tested independently of other components;
-second, the `Composer` must know about both the `View` and the `ViewModel`, while the `ViewModel` must not know about
-the `View`.
+`Mediator`. This is the interface that the `ViewModel` uses to interact with the `Composer`. This interface is needed
+for two reasons: first, it allows the `ViewModel` to be tested independently; second, it allows the `Composer` to
+access both the `View` and the `ViewModel`, without exposing the `View` to the `ViewModel`.
 
 ```java
 public interface FooMediator extends ChildMediator {
@@ -237,7 +239,7 @@ public class FooViewModel extends AbstractChildViewModel {
 }
 ```
 
-`Composer`. This class contains the methods that manage the entire lifecycle of child components, as well as the
+`Composer`. This class contains the methods to work with child and derived components, as well as the
 methods the `View` uses to interact with the `Composer`. In addition, it defines a non-static inner class that
 implements the corresponding `Mediator`.
 
@@ -248,6 +250,11 @@ public class FooComposer extends AbstractChildComposer<FooView> {
 
     ...
 
+    @Override
+    public FooMediator getMediator() {
+        return (FooMediator) super.Mediator();
+    }
+
     @Override
     protected FooMediator createMediator() {
         return new FooComposer.Mediator();
@@ -273,8 +280,7 @@ public class FooView extends AbstractChildView<FooViewModel> {
 Composer Creation and Initialization. The `Composer` is created during the component’s pre-initialization phase via
 the protected `AbstractComponentView#createComposer()` method. Creating the composer at this stage ensures that both
 the `View` and the `ViewModel` are fully constructed, allowing the composer to immediately access and interact with
-their properties and methods. The composer is also initialized during the pre-initialization phase, while its
-deinitialization takes place in the component’s post-deinitialization phase.
+their properties and methods. The composer is initialized before the `ViewModel` and deinitialized after the `ViewModel`.
 
 Advantages of this approach:
 

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

@@ -34,4 +34,7 @@ public AbstractChildComposer(T view) {
     public ChildMediator getMediator() {
         return (ChildMediator) super.getMediator();
     }
+
+    @Override
+    protected abstract ChildMediator createMediator();
 }

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

@@ -59,6 +59,11 @@ protected void addListeners(T viewModel) {
         });
     }
 
+    @Override
+    protected ChildComposer<?> createComposer() {
+        return (ChildComposer<?>) super.createComposer();
+    }
+
     /**
      * Sets the parent component for this component.
      * <p>

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

@@ -52,6 +52,9 @@ public final void initialize() {
             }
             preInitialize(viewModel);
             descriptor.stateWrapper().set(ComponentState.INITIALIZING);
+            if (this.composer != null) {
+                this.composer.initialize();
+            }
             viewModel.initialize();
             build(viewModel);
             bind(viewModel);
@@ -82,6 +85,9 @@ public final void deinitialize() {
             unbind(viewModel);
             unbuild(viewModel);
             viewModel.deinitialize();
+            if (this.composer != null) {
+                this.composer.deinitialize();
+            }
             descriptor.stateWrapper().set(ComponentState.DEINITIALIZED);
             logger.debug("{} Deinitialized component", descriptor.getLogPrefix());
             postDeinitialize(viewModel);
@@ -90,6 +96,7 @@ public final void deinitialize() {
         }
     }
 
+    @Override
     public ComponentComposer<?> getComposer() {
         return composer;
     }
@@ -125,7 +132,6 @@ protected void preInitialize(T viewModel) {
         this.composer = createComposer();
         if (this.composer != null) {
             viewModel.setMediator(this.composer.getMediator());
-            this.composer.initialize();
         }
     }
 
@@ -210,8 +216,6 @@ protected void unbuild(T viewModel) {
      * The last method called in deinitialization.
      */
     protected void postDeinitialize(T viewModel) {
-        if (this.composer != null) {
-            this.composer.deinitialize();
-        }
+
     }
 }

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

@@ -109,14 +109,15 @@ public HistoryProvider getHistoryProvider() {
         return historyProvider;
     }
 
-    public void setHistoryProvider(HistoryProvider historyProvider) {
-        this.historyProvider = historyProvider;
-    }
-
+    @Override
     public ComponentMediator getMediator() {
         return this.mediator;
     }
 
+    public void setHistoryProvider(HistoryProvider historyProvider) {
+        this.historyProvider = historyProvider;
+    }
+
     protected void initialize() {
 
     }

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

@@ -34,4 +34,7 @@ public AbstractParentComposer(T view) {
     public ParentMediator getMediator() {
         return (Mediator) super.getMediator();
     }
+
+    @Override
+    protected abstract ParentMediator createMediator();
 }

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

@@ -87,4 +87,9 @@ protected void addListeners(T viewModel) {
             }
         });
     }
+
+    @Override
+    protected ParentComposer<?> createComposer() {
+        return (ParentComposer<?>) super.createComposer();
+    }
 }

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

@@ -51,4 +51,7 @@ public interface ChildView<T extends ChildViewModel> extends ParentView<T> {
      * @return
      */
     Object getNode();
+
+    @Override
+    ChildComposer<?> getComposer();
 }

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

@@ -39,4 +39,6 @@ public interface ChildViewModel extends ParentViewModel {
      */
     ParentViewModel getParent();
 
+    @Override
+    ChildMediator getMediator();
 }

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

@@ -28,4 +28,11 @@ public interface ComponentView<T extends ComponentViewModel> extends Lifecycle {
      * @return
      */
     T getViewModel();
+
+    /**
+     * Returns component composer.
+     *
+     * @return the composer or {@code null}
+     */
+    ComponentComposer<?> getComposer();
 }