/** * Render this property as given <code>renderType</code> if a suitable {@link PropertyRenderer} for given rendering * type is available from the {@link PropertyRendererRegistry} obtained from current {@link Context} or from the * default one for current ClassLoader. * @param <R> Rendered object type * @param renderType Render type * @return Rendered property as given render type, or an empty Optional if a suitable PropertyRenderer is not * available */ default <R> Optional<R> renderIfAvailable(Class<R> renderType) { return PropertyRendererRegistry.get().getRenderer(renderType, this).map(r -> r.render(this)); }
/** * Bind a {@link PropertyRenderer} to the given property. The renderer will be provided when the property to render * is the same as the given property. * @param <R> Rendering type * @param <T> Property base type * @param property The property to render (not null) * @param renderer The PropertyRenderer to register (not null) */ default <R, T> void forProperty(Property<? extends T> property, PropertyRenderer<R, T> renderer) { ObjectUtils.argumentNotNull(property, "Property must be not null"); register(p -> property.equals(p), renderer); }
public void input5() { final NumericProperty<Integer> MY_PROPERTY = NumericProperty.integerType("my_property"); // tag::input5[] PropertyRendererRegistry.getDefault() // <1> .forProperty(MY_PROPERTY, InputPropertyRenderer.create(property -> new MyInput())); // <2> // end::input5[] }
@SuppressWarnings("unchecked") public void renderers2() { // tag::renderers2[] final PathProperty<String> TEXT = PathProperty.create("text", String.class); InputPropertyRenderer<String> textAreaInputRenderer = p -> Components.input.string(true).build(); // <1> PropertyRendererRegistry.get().register(p -> p == TEXT, textAreaInputRenderer); // <2> Input<String> input = TEXT.render(Input.class); // <3> // end::renderers2[] }
@SuppressWarnings("unchecked") @Override protected <V> Optional<Input<V>> buildPropertyEditor(ItemListingColumn<Property<?>, PropertyBox, V> configuration) { final Property<V> property = (Property<V>) configuration.getProperty(); // check custom renderer Optional<Input<V>> component = configuration.getEditorInputRenderer().map(r -> r.render(property)); if (component.isPresent()) { return component; } // check specific registry if (getPropertyRendererRegistry().isPresent()) { return getPropertyRendererRegistry().get().getRenderer(Input.class, property).map(r -> r.render(property)); } else { // use default return property.renderIfAvailable(Input.class).map(c -> (Input<V>) c); } }
/** * Gets the current {@link PropertyRendererRegistry} instance. * @return The {@link Context}-bound PropertyRendererRegistry instance, if available using {@link #CONTEXT_KEY} as * context key, or the default instance for the default ClassLoader obtained through {@link #getDefault()}. */ static PropertyRendererRegistry get() { return Context.get().resource(CONTEXT_KEY, PropertyRendererRegistry.class).orElse(getDefault()); }
public void render() { PropertyRenderer<MyRenderingType, Object> myRenderer = PropertyRenderer.create(MyRenderingType.class, p -> new MyRenderingType(p.getType())); // <2> PropertyRendererRegistry.get().register(p -> true, myRenderer); // <3> final PathProperty<Long> ID = PathProperty.create("id", Long.class); MyRenderingType rendered = ID.render(MyRenderingType.class); // <4> } // end::renderer[]
@SuppressWarnings("unchecked") @Override protected <V> Optional<Input<V>> buildPropertyEditor(ItemListingColumn<String, T, V> configuration) { return propertySet.getProperty(configuration.getProperty()).flatMap(p -> { final Property<V> property = (Property<V>) p; // check custom renderer Optional<Input<V>> component = configuration.getEditorInputRenderer().map(r -> r.render(property)); if (component.isPresent()) { return component; } // check specific registry if (getPropertyRendererRegistry().isPresent()) { return getPropertyRendererRegistry().get().getRenderer(Input.class, property) .map(r -> r.render(property)); } else { // use default return property.renderIfAvailable(Input.class).map(c -> (Input<V>) c); } }); }
@SuppressWarnings("unchecked") public void renderers2() { // tag::renderers2[] final PathProperty<String> TEXT = PathProperty.create("text", String.class); InputPropertyRenderer<String> textAreaInputRenderer = p -> Components.input.string(true).build(); // <1> PropertyRendererRegistry.get().register(p -> p == TEXT, textAreaInputRenderer); // <2> Input<String> input = TEXT.render(Input.class); // <3> InputFieldPropertyRenderer<String> fieldRenderer = p -> new TextArea(); // <4> // end::renderers2[] }
@Override public Input render(Property<? extends T> property) { ObjectUtils.argumentNotNull(property, "Property must be not null"); @SuppressWarnings("unchecked") final Property<T> p = (Property<T>) property; // try to render as Field and convert to Input return PropertyRendererRegistry.get().getRenderer(Field.class, p).map(r -> r.render(p)) .map(field -> asInput(field)).orElse(null); }
/** * Render given property configuration as a {@link ViewComponent}. * @param <T> Property type * @param propertyConfiguration Property configuration * @return Optional rendered component */ @SuppressWarnings("unchecked") protected <T> Optional<Input<T>> render(InputPropertyConfiguration<T> propertyConfiguration) { // check custom renderer Optional<Input<T>> component = propertyConfiguration.getRenderer() .map(r -> r.render(propertyConfiguration.getProperty())); if (component.isPresent()) { return component; } // check specific registry if (getPropertyRendererRegistry().isPresent()) { return getPropertyRendererRegistry().get().getRenderer(Input.class, propertyConfiguration.getProperty()) .map(r -> r.render(propertyConfiguration.getProperty())); } else { // use default return propertyConfiguration.getProperty().renderIfAvailable(Input.class).map(c -> (Input<T>) c); } }
/** * Bind a {@link PropertyRenderer} to the given property configuration value. The renderer will be provided when the * property has the given <code>configurationProperty</code> and its value equals to given <code>value</code>. * @param <R> Rendering type * @param <T> Property base type * @param <C> Configuration property type * @param configurationProperty The configuration property to check (not null) * @param value The configuration property value to check (may be null) * @param renderer The PropertyRenderer to register (not null) */ default <R, T, C> void forPropertyConfiguration(ConfigProperty<C> configurationProperty, C value, PropertyRenderer<R, T> renderer) { ObjectUtils.argumentNotNull(configurationProperty, "Configuration property must be not null"); register(p -> p.getConfiguration().getParameter(configurationProperty).map(v -> Objects.equals(v, value)) .orElse(Boolean.FALSE), renderer); }
public void listing25() { // tag::listing25[] PropertyRendererRegistry.getDefault().forProperty(NAME, // <1> InputPropertyRenderer.create(property -> Input.stringArea().build())); PropertyListing.builder(SUBJECT).editable().build(); // <2> // end::listing25[] }
@Override public Input render(Property<? extends T> property) { ObjectUtils.argumentNotNull(property, "Property must be not null"); @SuppressWarnings("unchecked") final Property<T> p = (Property<T>) property; // try to render as Field and convert to Input return PropertyRendererRegistry.get().getRenderer(Field.class, p).map(r -> r.render(p)) .map(field -> asInput(field)).orElse(null); }
/** * Render given property configuration as a {@link ViewComponent}. * @param <T> Property type * @param propertyConfiguration Property configuration * @return Optional rendered component */ @SuppressWarnings("unchecked") protected <T> Optional<ViewComponent<T>> render(ViewComponentPropertyConfiguration<T> propertyConfiguration) { // check custom renderer Optional<ViewComponent<T>> component = propertyConfiguration.getRenderer() .map(r -> r.render(propertyConfiguration.getProperty())); if (component.isPresent()) { return component; } // check specific registry if (getPropertyRendererRegistry().isPresent()) { return getPropertyRendererRegistry().get() .getRenderer(ViewComponent.class, propertyConfiguration.getProperty()) .map(r -> r.render(propertyConfiguration.getProperty())); } else { // use default return propertyConfiguration.getProperty().renderIfAvailable(ViewComponent.class) .map(c -> (ViewComponent<T>) c); } }