Renderer (Vaadin Platform (vaadin-platform-javadoc) 14.13-SNAPSHOT API)

java.lang.Object
- com.vaadin.flow.data.renderer.Renderer<SOURCE>

Type Parameters:

SOURCE - the type of the input object used inside the template

SOURCE - the object model type

All Implemented Interfaces:

Serializable

Direct Known Subclasses:

ColumnPathRenderer, ComponentRenderer, EditorRenderer, TemplateRenderer
```
public class Renderer<SOURCE>
extends Object
implements Serializable
```
Base class for all renderers - classes that take a given model object as input and outputs a set of elements that represents that item in the UI.
The default renderer only supports template based rendering. For component support, check ComponentRenderer.

Since:

1.0.

Author:

Vaadin Ltd

See Also:

ValueProvider, ComponentRenderer, TemplateRenderer, https://www.polymer-project.org/2.0/docs/devguide/templates, Serialized Form

Constructor Summary

Constructors
Modifier Constructor and Description

protected Renderer()
Default constructor.

protected Renderer(String template)
Builds a renderer with the specified template.

Constructors
Modifier	Constructor and Description
`protected`	`Renderer()` Default constructor.
`protected`	`Renderer(String template)` Builds a renderer with the specified template.

Method Summary

All Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`Map<String,SerializableConsumer<SOURCE>>`	`getEventHandlers()` Gets the event handlers linked to this renderer.
`Map<String,ValueProvider<SOURCE,?>>`	`getValueProviders()` Gets the property mapped to `ValueProvider`s in this renderer.
`Rendering<SOURCE>`	`render(Element container, DataKeyMapper<SOURCE> keyMapper)` Handles the rendering of the model objects by creating a new `<template>` element in the given container.
`Rendering<SOURCE>`	`render(Element container, DataKeyMapper<SOURCE> keyMapper, Element contentTemplate)` Handles the rendering of the model objects by using the given `<template>` element in the given container.
`protected void`	`setEventHandler(String handlerName, SerializableConsumer<SOURCE> handler)` Sets an event handler for events from elements inside the template.
`protected void`	`setProperty(String property, ValueProvider<SOURCE,?> provider)` Sets a property to be used inside the template.

Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

- Constructor Detail
  - Renderer
```
protected Renderer()
```
    Default constructor.
  - Renderer
```
protected Renderer(String template)
```
    Builds a renderer with the specified template.
    
    Parameters:
    
    template - the template used by the renderer
- Method Detail
  - setProperty
```
protected void setProperty(String property,
                           ValueProvider<SOURCE,?> provider)
```
    Sets a property to be used inside the template. Each property is referenced inside the template by using the [[item.property]] syntax.
    Examples:
```
 
 // Regular property
 TemplateRenderer.<Person> of("<div>Name: [[item.name]]</div>")
          .withProperty("name", Person::getName);

 // Property that uses a bean. Note that in this case the entire "Address" object will be sent to the template.
 // Note that even properties of the bean which are not used in the template are sent to the client, so use
 // this feature with caution.
 TemplateRenderer.<Person> of("<span>Street: [[item.address.street]]</span>")
          .withProperty("address", Person::getAddress);

 // In this case only the street field inside the Address object is sent
 TemplateRenderer.<Person> of("<span>Street: [[item.street]]</span>")
          .withProperty("street", person -> person.getAddress().getStreet());
 
 
```
    Any types supported by the JsonSerializer are valid types for the Renderer.
    Parameters:
    
    property - the name of the property used inside the template, not null
    
    provider - a ValueProvider that provides the actual value for the property, not null
  - setEventHandler
```
protected void setEventHandler(String handlerName,
                               SerializableConsumer<SOURCE> handler)
```
    Sets an event handler for events from elements inside the template. Each event is referenced inside the template by using the on-event syntax.
    Examples:
```
 
 // Standard event
 TemplateRenderer.of("<button on-click='handleClick'>Click me</button>")
          .withEventHandler("handleClick", object -> doSomething());

 // You can handle custom events from webcomponents as well, using the same syntax
 TemplateRenderer.of("<my-webcomponent on-customevent=
    'onCustomEvent'></my-webcomponent>")
          .withEventHandler("onCustomEvent", object -> doSomething());
 
 
```
    The name of the function used on the on-event attribute should be the name used at the handlerName parameter. This name must be a valid Javascript function name.
    Parameters:
    
    handlerName - the name of the handler used inside the on-event="handlerName", not null
    
    handler - the handler executed when the event is triggered, not null
    
    See Also:
    
    https://www.polymer-project.org/2.0/docs/devguide/events
  - render
```
public Rendering<SOURCE> render(Element container,
                                DataKeyMapper<SOURCE> keyMapper)
```
    Handles the rendering of the model objects by creating a new <template> element in the given container.
    
    Parameters:
    
    container - the element in which the template will be attached to
    
    keyMapper - mapper used internally to fetch items by key and to provide keys for given items. It is required when either event handlers or DataGenerator are supported
    
    Returns:
    
    the context of the rendering, that can be used by the components to provide extra customization
  - render
```
public Rendering<SOURCE> render(Element container,
                                DataKeyMapper<SOURCE> keyMapper,
                                Element contentTemplate)
```
    Handles the rendering of the model objects by using the given <template> element in the given container.
    Subclasses of Renderer usually override this method to provide additional features.
    
    Parameters:
    
    container - the element in which the template will be attached to, not null
    
    keyMapper - mapper used internally to fetch items by key and to provide keys for given items. It is required when either event handlers or DataGenerator are supported
    
    contentTemplate - the <template> element to be used for rendering in the container, not null
    
    Returns:
    
    the context of the rendering, that can be used by the components to provide extra customization
  - getValueProviders
```
public Map<String,ValueProvider<SOURCE,?>> getValueProviders()
```
    Gets the property mapped to ValueProviders in this renderer. The returned map is immutable.
    
    Returns:
    
    the mapped properties, never null
  - getEventHandlers
```
public Map<String,SerializableConsumer<SOURCE>> getEventHandlers()
```
    Gets the event handlers linked to this renderer. The returned map is immutable.
    
    Returns:
    
    the mapped event handlers, never null
    
    See Also:
    
    setEventHandler(String, SerializableConsumer)

Class Renderer<SOURCE>

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Constructor Detail

Renderer

Renderer

Method Detail

setProperty

setEventHandler

render

render

getValueProviders

getEventHandlers