@Param method option

annotation-processor/src/main/java/org/fulib/fx/FxClassGenerator.java

@@ -12,10 +12,7 @@
 import org.fulib.fx.util.ControllerUtil;
 
 import javax.annotation.processing.ProcessingEnvironment;
-import javax.lang.model.element.ExecutableElement;
-import javax.lang.model.element.Modifier;
-import javax.lang.model.element.TypeElement;
-import javax.lang.model.element.VariableElement;
+import javax.lang.model.element.*;
 import javax.lang.model.type.DeclaredType;
 import javax.lang.model.type.ExecutableType;
 import javax.lang.model.type.TypeMirror;
@@ -30,16 +27,6 @@ public class FxClassGenerator {
     private final ProcessingEnvironment processingEnv;
     private final ProcessingHelper helper;
 
-    /**
-     * The (erased) `javafx.beans.value.WritableValue` type.
-     */
-    private final TypeMirror writableValue;
-
-    /**
-     * The `setValue` method of `javafx.beans.value.WritableValue`.
-     */
-    private final ExecutableElement genericSetValue;
-
     /**
      * The `javafx.scene.Parent` type.
      */
@@ -53,17 +40,6 @@ public FxClassGenerator(ProcessingHelper helper, ProcessingEnvironment processin
         this.helper = helper;
         this.processingEnv = processingEnv;
 
-        final TypeElement writableValue = processingEnv.getElementUtils().getTypeElement("javafx.beans.value.WritableValue");
-        this.writableValue = processingEnv.getTypeUtils().erasure(writableValue.asType());
-
-        genericSetValue = writableValue.getEnclosedElements()
-            .stream()
-            .filter(e -> e instanceof ExecutableElement)
-            .map(e -> (ExecutableElement) e)
-            .filter(e -> "setValue".equals(e.getSimpleName().toString()))
-            .findFirst()
-            .orElseThrow();
-
         parent = processingEnv.getElementUtils().getTypeElement("javafx.scene.Parent").asType();
         pane = processingEnv.getElementUtils().getTypeElement("javafx.scene.layout.Pane").asType();
     }
@@ -154,29 +130,20 @@ private void generateParametersIntoFields(PrintWriter out, TypeElement component
             out.printf("    if (params.containsKey(%s)) {%n", paramNameLiteral);
 
             // TODO field must be public, package-private or protected -- add a diagnostic if it's private
-            if (processingEnv.getTypeUtils().isAssignable(field.asType(), writableValue)) {
-                // We use the `setValue` method to infer the actual type of the field,
-                // E.g. if the field is a `StringProperty` which extends `WritableValue<String>`,
-                // we can infer that the actual type is `String`.
-                final ExecutableType asMemberOf = (ExecutableType) processingEnv.getTypeUtils().asMemberOf((DeclaredType) field.asType(), genericSetValue);
-                final TypeMirror typeArg = asMemberOf.getParameterTypes().get(0);
-                final String writableType = typeArg.toString();
-                if (field.getModifiers().contains(Modifier.FINAL)) {
-                    out.printf("      instance.%s.setValue((%s) params.get(%s));%n", fieldName, writableType, paramNameLiteral);
-                } else {
-                    // final Object param = params.get(<paramNameLiteral>);
-                    // if (param instanceof <writableValue>) {
-                    //   instance.<fieldName> = (<fieldType>) param);
-                    // } else {
-                    //   instance.<fieldName>.setValue((<writableType>) param);
-                    // }
-                    out.printf("      final Object param = params.get(%s);%n", paramNameLiteral);
-                    out.printf("      if (param instanceof %s) {%n", writableValue);
-                    out.printf("        instance.%s = (%s) param;%n", fieldName, fieldType);
-                    out.println("      } else {");
-                    out.printf("        instance.%s.setValue((%s) param);%n", fieldName, writableType);
-                    out.println("      }");
-                }
+            final String methodName = param.method();
+            if (methodName != null && !methodName.isEmpty()) {
+                // this is some hacky way to get the @Param().type().
+                // param.type() does not work because we cannot access the Class<?> instance at compile time.
+                // So we have to read the AnnotationMirror.
+                final AnnotationMirror paramMirror = field.getAnnotationMirrors().stream()
+                    .filter(a -> "org.fulib.fx.annotation.param.Param".equals(a.getAnnotationType().toString()))
+                    .findFirst().orElseThrow();
+                final String methodParamType = paramMirror.getElementValues().values().stream()
+                    .map(Object::toString)
+                    .filter(s -> s.endsWith(".class"))
+                    .map(s -> s.substring(0, s.length() - 6)) // remove ".class"
+                    .findFirst().orElse("Object"); // else case also happens when type is not specified in the annotation (default Object)
+                out.printf("      instance.%s.%s((%s) params.get(%s));%n", fieldName, methodName, methodParamType, paramNameLiteral);
             } else {
                 out.printf("      instance.%s = (%s) params.get(%s);%n", fieldName, fieldType, paramNameLiteral);
             }

docs/controller/4-parameters.md

@@ -4,15 +4,11 @@ To pass parameters to a controller, an additional argument can be provided to th
 strings and objects. The strings specify the argument's name and the objects are the value of the argument. For example,
 `show("/route/to/controller", Map.of("key", value, "key2", value2))` will pass the value `value` to the argument `key`.
 
-To use a passed argument in a field or method, you have to annotate it with `@Param("key")`. The name of the parameter
-will be used to match it to the map of parameters passed to the `show()` method. If the annotation is used on a field,
-the field will be injected with the value of the parameter before the controller is initialized. If the annotation is used
-on a method, the method will be called with the value of the parameter before the controller is initialized. If the
-annotation is used on a method parameter of a render/init method, the method will be called with the value of the parameter.
-
-If `@Param` is used on a field containing a `WriteableValue` (e.g. a `StringProperty`), its value will be set to the
-parameter's value if the parameter has the correct type (e.g. a `String` for a `StringProperty`). If the parameter is
-a `WritableValue` as well, the logic will be the same as for a normal field.
+To use a passed argument in a field or method, you have to annotate it with `@Param("key")`.
+The name of the parameter will be used to match it to the map of parameters passed to the `show()` method.
+If the annotation is used on a field, the field will be injected with the value of the parameter before the controller is initialized.
+If the annotation is used on a method, the method will be called with the value of the parameter before the controller is initialized.
+If the annotation is used on a method parameter of a render/init method, the method will be called with the value of the parameter.
 
 Instead of accessing the parameters one by one, you can also use the `@ParamsMap` annotation to inject a map of all parameters.
 This annotation can be used for fields and method parameters of type `Map<String, Object>`. If the annotated field is final,
@@ -34,9 +30,10 @@ public class FooController {
     @Param("baba")
     private Bar bar;
 
-    // The set method of the writable value will be called with the parameter 'fofo'
-    @Param("fofo")
-    private ObjectProperty<Foo> foo = new SimpleObjectProperty<>();
+    // The setValue(T) method of the ObjectProperty will be called with the parameter named 'fofo'
+    // Note that the erased parameter type of ObjectProperty.setValue is Object, so we specify that as the type.
+    @Param(value = "fofo", method = "setValue", type = Object.class)
+    private final ObjectProperty<Foo> foo = new SimpleObjectProperty<>();
 
     // This field will be injected with a map of all parameters before the controller is initialized
     @ParamsMap

docs/tutorial/data-flow.md

@@ -119,18 +119,36 @@ Instead of defining a Runnable or Consumer directly, you can create a Property a
 ```java
 @Component
 public class MyComponent {
-
-  @Param("colorChange")
+  // option 1: The subcomponent reuses the parent's property instance.
+  @Param("color")
   ObjectProperty<Color> color;
 
-  @Param("colorBind")
-  // As this field is final, bind() will be used instead
-  final ObjectProperty<Color> otherColor = new SimpleObjectProperty<>();
+  // Option 2: The subcomponent uses its own property instance and binds it to the parent's property.
+  // Writing to this property will NOT update the parent's property.
+  // We have to unbind using destroy.
+  @Param(value = "color", method = "bind", type = Object.class)
+  final ObjectProperty<Color> colorBind = new SimpleObjectProperty<>();
+
+  // Option 3: The subcomponent uses its own property instance and binds it to the parent's property bidirectionally.
+  // Writing to this property will update the parent's property.
+  // We have to manually bind using subscriber to allow for unbinding.
+  final ObjectProperty<Color> colorBindBidi = new SimpleObjectProperty<>();
+  Subscriber subscriber = ...;
+
+  @OnInit
+  void init(@Param("color") ObjectProperty<Color> color) {
+    subscriber.bindBidirectional(colorBindBidi, color);
+  }
 
   void onButtonClicked() {
     Color newColor = ...;
     color.set(newColor);
   }
+
+  @OnDestroy
+  void destroy() {
+    colorBind.unbind();
+  }
 }
 ```
 
@@ -143,8 +161,7 @@ public class MyController {
   @OnRender
   void createSubs() {
     ObjectProperty<Color> color = new SimpleObjectProperty(Color.WHITE);
-    ObjectProperty<Color> colorBind = new SimpleObjectProperty(Color.WHITE);
-    MyComponent component = app.initAndRender(new MyComponent(), Map.of("colorChange", color, "colorBind", colorBind));
+    MyComponent component = app.initAndRender(new MyComponent(), Map.of("color", color));
     subscriber.listen(color, (observable, oldValue, newValue) -> { // Use subscribers to prevent memory leaks
       System.out.println(newValue);
     });

framework/src/main/java/org/fulib/fx/annotation/param/Param.java

@@ -31,4 +31,16 @@
      */
     String value();
 
+    /**
+     * The method of the field's class that will be called with the parameter's value.
+     * Useful for {@code final} fields or {@link javafx.beans.property.Property} fields.
+     * @return the method name
+     */
+    String method() default "";
+
+    /**
+     * When using {@link #method()}, this specifies the type of the first (and only) parameter of that method.
+     * @return the type of the method parameter
+     */
+    Class<?> type() default Object.class;
 }

framework/src/main/java/org/fulib/fx/controller/internal/ReflectionSidecar.java

@@ -1,6 +1,5 @@
 package org.fulib.fx.controller.internal;
 
-import javafx.beans.value.WritableValue;
 import javafx.event.EventHandler;
 import javafx.event.EventType;
 import javafx.scene.Node;
@@ -146,17 +145,18 @@ private void fillParametersIntoFields(@NotNull Object instance, @NotNull Map<@No
                 Object value = parameters.get(param);
                 Object fieldValue = field.get(instance);
 
-                // If the field is a WriteableValue, use the setValue method
-                if (WritableValue.class.isAssignableFrom(fieldType) && !(value instanceof WritableValue)) {
+                String method = paramAnnotation.method();
+                if (method != null && !method.isEmpty()) {
 
-                    // We cannot call setValue on a non-existing property
+                    // We cannot call the method on a non-existing property
                     if (fieldValue == null) {
                         throw new RuntimeException(error(4001).formatted(param, field.getName(), instance.getClass().getName()));
                     }
 
                     try {
-                        ((WritableValue<Object>) field.get(instance)).setValue(value);
-                    } catch (ClassCastException e) {
+                        final Method methodName = field.getType().getMethod(method, paramAnnotation.type());
+                        methodName.invoke(fieldValue, value);
+                    } catch (ClassCastException | ReflectiveOperationException e) {
                         throw new RuntimeException(error(4007).formatted(param, field.getName(), instance.getClass().getName(), fieldType.getName(), value == null ? "null" : value.getClass().getName()));
                     }
                 }

framework/src/test/java/org/fulib/fx/app/controller/ParamController.java

@@ -21,7 +21,7 @@ public class ParamController {
     private String setterParam;
     @Param("integer")
     int fieldParam;
-    @Param("string")
+    @Param(value = "string", method = "set", type = String.class)
     final StringProperty fieldPropertyParam = new SimpleStringProperty();
 
     private Map<String, Object> onInitParamsMap;