/server/src/main/java/com/vaadin/ui/components/

* // Component for which the locale is meaningful * InlineDateField date = new InlineDateField("Datum"); * * // German language specified with ISO 639-1 language * // code and ISO 3166-1 alpha-2 country code. * date.setLocale(new Locale("de", "DE")); * * date.setResolution(DateField.RESOLUTION_DAY); * layout.addComponent(date); *

* Button enabled = new Button("Enabled"); * enabled.setEnabled(true); // The default * layout.addComponent(enabled); * * Button disabled = new Button("Disabled"); * disabled.setEnabled(false); * layout.addComponent(disabled); *

* RichTextArea area = new RichTextArea(); * area.setCaption("You can edit stuff here"); * area.setValue("<h1>Helpful Heading</h1>" * + "<p>All this is for you to edit.</p>"); *

* // Component with an icon from a custom theme * TextField name = new TextField("Name"); * name.setIcon(new ThemeResource("icons/user.png")); * layout.addComponent(name); * * // Component with an icon from another theme ('runo') * Button ok = new Button("OK"); * ok.setIcon(new ThemeResource("../runo/icons/16/ok.png")); * layout.addComponent(ok); *

* public class AttachExample extends CustomComponent { * public AttachExample() { * // ERROR: We can't access the application object yet. * ClassResource r = new ClassResource("smiley.jpg", * getApplication()); * Embedded image = new Embedded("Image:", r); * setCompositionRoot(image); * } * } *

* public class AttachExample extends CustomComponent { * public AttachExample() { * } * * @Override * public void attach() { * super.attach(); // Must call. * * // Now we know who ultimately owns us. * ClassResource r = new ClassResource("smiley.jpg", * getApplication()); * Embedded image = new Embedded("Image:", r); * setCompositionRoot(image); * } * } *

* Button button = new Button("Click Me!"); * button.addListener(new Button.ClickListener() { * public void buttonClick(ClickEvent event) { * getWindow().showNotification("Thank You!"); * } * }); * layout.addComponent(button); *

* class Listening extends CustomComponent implements Listener { * Button ok; // Stored for determining the source of an event * * Label status; // For displaying info about the event * * public Listening() { * VerticalLayout layout = new VerticalLayout(); * * // Some miscellaneous component * TextField name = new TextField("Say it all here"); * name.addListener(this); * layout.addComponent(name); * * // Handle button clicks as generic events instead * // of Button.ClickEvent events * ok = new Button("OK"); * ok.addListener(this); * layout.addComponent(ok); * * // For displaying information about an event * status = new Label(""); * layout.addComponent(status); * * setCompositionRoot(layout); * } * * public void componentEvent(Event event) { * // Act according to the source of the event * if (event.getSource() == ok * && event.getClass() == Button.ClickEvent.class) * getWindow().showNotification("Click!"); * * // Display source component and event class names * status.setValue( * "Event from " + event.getSource().getClass().getName() * + ": " + event.getClass().getName()); * } * } * * Listening listening = new Listening(); * layout.addComponent(listening); *

* public void componentEvent(Event event) { * // Act according to the source of the event * if (event.getSource() == ok * && event.getClass() == Button.ClickEvent.class) * getWindow().showNotification("Click!"); * * // Display source component and event class names * status.setValue( * "Event from " + event.getSource().getClass().getName() + ": " * + event.getClass().getName()); * } *

* class Listening extends CustomComponent implements Listener { * // Stored for determining the source of an event * Button ok; * * Label status; // For displaying info about the event * * public Listening() { * VerticalLayout layout = new VerticalLayout(); * * // Some miscellaneous component * TextField name = new TextField("Say it all here"); * name.addListener(this); * layout.addComponent(name); * * // Handle button clicks as generic events instead * // of Button.ClickEvent events * ok = new Button("OK"); * ok.addListener(this); * layout.addComponent(ok); * * // For displaying information about an event * status = new Label(""); * layout.addComponent(status); * * setCompositionRoot(layout); * } * * public void componentEvent(Event event) { * // Act according to the source of the event * if (event.getSource() == ok) * getWindow().showNotification("Click!"); * * status.setValue( * "Event from " + event.getSource().getClass().getName() * + ": " + event.getClass().getName()); * } * } * * Listening listening = new Listening(); * layout.addComponent(listening); *

* FormLayout loginBox = new FormLayout(); * loginBox.setCaption("Login"); * layout.addComponent(loginBox); * * // Create the first field which will be focused * TextField username = new TextField("User name"); * loginBox.addComponent(username); * * // Set focus to the user name * username.focus(); * * TextField password = new TextField("Password"); * loginBox.addComponent(password); * * Button login = new Button("Login"); * loginBox.addComponent(login); *

* Form loginBox = new Form(); * loginBox.setCaption("Login"); * layout.addComponent(loginBox); * * // Create the first field which will be focused * TextField username = new TextField("User name"); * loginBox.addField("username", username); * * // Set focus to the user name * username.focus(); * * TextField password = new TextField("Password"); * loginBox.addField("password", password); * * Button login = new Button("Login"); * loginBox.getFooter().addComponent(login); * * // An additional component which natural focus order would * // be after the button. * CheckBox remember = new CheckBox("Remember me"); * loginBox.getFooter().addComponent(remember); * * username.setTabIndex(1); * password.setTabIndex(2); * remember.setTabIndex(3); // Different than natural place * login.setTabIndex(4); *

* For internal use only. * * @param customComponent * the custom component or composite * @param component * the component to assign as composition root */ public static void setRoot(Component customComponent, Component component) { if (customComponent instanceof CustomComponent) { ((CustomComponent) customComponent).setCompositionRoot(component); } else if (customComponent instanceof Composite) { ((Composite) customComponent).setCompositionRoot(component); } else { throw new IllegalArgumentException( "Parameter is of an unsupported type: " + customComponent.getClass().getName()); } } /** * Checks if the given custom component or composite may accept a root * component. *

* For internal use only. * * @param customComponent * the custom component or composite * @return * @since 8.4 * */ public static boolean canSetRoot(Component customComponent) { if (customComponent instanceof CustomComponent) { return true; } if (customComponent instanceof Composite) { return ((Composite) customComponent).getCompositionRoot() == null; } return false; } } X-Content-Type-Options: nosniff Content-Security-Policy: default-src 'none' Content-Type: text/plain; charset=UTF-8 Content-Length: 10214 Content-Disposition: inline; filename="Composite.java" Last-Modified: Sun, 27 Apr 2025 23:49:14 GMT Expires: Sun, 27 Apr 2025 23:54:14 GMT ETag: "7836eb9e60045d3c7b87d9bde6ca96a5630c2b41" /* * Copyright 2000-2022 Vaadin Ltd. * * 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.vaadin.ui; import java.util.Collections; import java.util.Iterator; import java.util.Objects; import com.vaadin.server.ErrorMessage; import com.vaadin.server.Resource; import com.vaadin.server.SerializableFunction; import com.vaadin.shared.ui.ContentMode; import com.vaadin.shared.ui.composite.CompositeState; /** * Composite allows creating new UI components by composition of existing * server-side components. *

* A composite is created by extending the Composite class and setting the * composition root component using {@link #setCompositionRoot(Component)}. *

* The composition root itself can contain more components. The advantage of * wrapping it in a composite is that the details of the composition root, such * as its public API, are hidden from the users of the composite. *

* A composite itself does not contribute to the DOM in any way (contrary to * {@link CustomComponent} which adds a {@code

} to the DOM. *

* * @author Vaadin Ltd. * @since 8.1 */ public class Composite extends AbstractComponent implements HasComponents { /** * The contained component. */ private Component root = null; /** * Constructs a new empty composite. *

* Use {@link #setCompositionRoot(Component)} to define the contents of the * composite. */ public Composite() { } /** * Constructs a new composite containing the given component. * * @param compositionRoot * the root of the composition component tree. It must not be * null. */ public Composite(AbstractComponent compositionRoot) { this(); Objects.requireNonNull(compositionRoot); setCompositionRoot(compositionRoot); } /** * Returns the composition root. * * @return the Component Composition root. */ protected Component getCompositionRoot() { return root; } /** * Sets the component contained in the composite. *

* You must set the composition root to a non-null value before the * component can be used. It cannot be changed. *

* * @param compositionRoot * the root of the composition component tree. */ protected void setCompositionRoot(Component compositionRoot) { if (root != null) { throw new IllegalStateException( "Composition root cannot be changed"); } if (compositionRoot == null) { throw new IllegalArgumentException( "Composition root cannot be null"); } // set new component if (compositionRoot.getParent() != null) { // If the component already has a parent, try to remove it AbstractSingleComponentContainer.removeFromParent(compositionRoot); } compositionRoot.setParent(this); root = compositionRoot; markAsDirty(); } /* Basic component features ------------------------------------------ */ @Override public Iterator iterator() { if (getCompositionRoot() != null) { return Collections.singletonList(getCompositionRoot()).iterator(); } else { return Collections. emptyList().iterator(); } } @Override protected CompositeState getState() { return (CompositeState) super.getState(); } @Override protected CompositeState getState(boolean markAsDirty) { return (CompositeState) super.getState(markAsDirty); } @Override public void beforeClientResponse(boolean initial) { super.beforeClientResponse(initial); if (getCompositionRoot() == null) { throw new IllegalStateException( "A composite must always have a composition root"); } } @Override public String getStyleName() { Component root = getCompositionRoot(); return root == null ? "" : root.getStyleName(); } @Override public void setStyleName(String style) { getRootOrThrow().setStyleName(style); } @Override public void setStyleName(String style, boolean add) { getRootAbstractComponentOrThrow().setStyleName(style, add); } @Override public void addStyleName(String style) { getRootOrThrow().addStyleName(style); } @Override public void removeStyleName(String style) { getRootOrThrow().removeStyleName(style); } @Override public String getPrimaryStyleName() { return getRootAbstractComponentPropertyOrNull( AbstractComponent::getPrimaryStyleName); } @Override public void setPrimaryStyleName(String style) { getRootOrThrow().setPrimaryStyleName(style); } private Component getRootOrThrow() { Component root = getCompositionRoot(); if (root == null) { throw new IllegalStateException( "Composition root has not been set"); } return root; } private AbstractComponent getRootAbstractComponentOrThrow() { Component root = getRootOrThrow(); if (!(root instanceof AbstractComponent)) { throw new IllegalStateException( "Composition root is not AbstractComponent"); } return (AbstractComponent) root; } private T getRootPropertyOrNull( SerializableFunction getter) { Component root = getCompositionRoot(); return root == null ? null : getter.apply(root); } private T getRootAbstractComponentPropertyOrNull( SerializableFunction getter) { Component root = getCompositionRoot(); if (root instanceof AbstractComponent) { return getter.apply((AbstractComponent) root); } return null; } @Override public void setEnabled(boolean enabled) { getRootOrThrow().setEnabled(enabled); } @Override public boolean isEnabled() { return getRootOrThrow().isEnabled(); } @Override public float getWidth() { return getRootOrThrow().getWidth(); } @Override public float getHeight() { return getRootOrThrow().getHeight(); } @Override public Unit getWidthUnits() { return getRootOrThrow().getWidthUnits(); } @Override public Unit getHeightUnits() { return getRootOrThrow().getHeightUnits(); } @Override public void setHeight(String height) { getRootOrThrow().setHeight(height); } @Override public void setWidth(float width, Unit unit) { getRootOrThrow().setWidth(width, unit); } @Override public void setHeight(float height, Unit unit) { getRootOrThrow().setHeight(height, unit); } @Override public void setWidth(String width) { getRootOrThrow().setWidth(width); } @Override public void setSizeFull() { getRootOrThrow().setSizeFull(); } @Override public void setSizeUndefined() { getRootOrThrow().setSizeUndefined(); } @Override public void setWidthUndefined() { getRootOrThrow().setWidthUndefined(); } @Override public void setHeightUndefined() { getRootOrThrow().setHeightUndefined(); } @Override public void setId(String id) { getRootOrThrow().setId(id); } @Override public String getId() { return getRootPropertyOrNull(Component::getId); } @Override public void setDebugId(String id) { getRootAbstractComponentOrThrow().setDebugId(id); } @Override public String getDebugId() { return getRootAbstractComponentPropertyOrNull( AbstractComponent::getDebugId); } @Override public String getCaption() { return getRootPropertyOrNull(Component::getCaption); } @Override public void setCaption(String caption) { getRootOrThrow().setCaption(caption); } @Override public void setCaptionAsHtml(boolean captionAsHtml) { getRootAbstractComponentOrThrow().setCaptionAsHtml(captionAsHtml); } @Override public boolean isCaptionAsHtml() { return getRootAbstractComponentPropertyOrNull( AbstractComponent::isCaptionAsHtml); } @Override public Resource getIcon() { return getRootPropertyOrNull(Component::getIcon); } @Override public void setIcon(Resource icon) { getRootOrThrow().setIcon(icon); } @Override public String getDescription() { return getRootOrThrow().getDescription(); } @Override public void setDescription(String description) { getRootAbstractComponentOrThrow().setDescription(description); } @Override public void setDescription(String description, ContentMode mode) { getRootAbstractComponentOrThrow().setDescription(description, mode); } @Override public ErrorMessage getErrorMessage() { return getRootAbstractComponentPropertyOrNull( AbstractComponent::getErrorMessage); } @Override public ErrorMessage getComponentError() { return getRootAbstractComponentPropertyOrNull( AbstractComponent::getComponentError); } @Override public void setComponentError(ErrorMessage componentError) { getRootAbstractComponentOrThrow().setComponentError(componentError); } } X-Content-Type-Options: nosniff Content-Security-Policy: default-src 'none' Content-Type: text/plain; charset=UTF-8 Content-Length: 35968 Content-Disposition: inline; filename="ConnectorTracker.java" Last-Modified: Sun, 27 Apr 2025 23:49:14 GMT Expires: Sun, 27 Apr 2025 23:54:14 GMT ETag: "f555deeedcebb5f83204ca52491f0b1d56f91455" /* * Copyright 2000-2022 Vaadin Ltd. * * 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.vaadin.ui; import java.io.IOException; import java.io.ObjectInputStream; import java.io.ObjectOutputStream; import java.io.Serializable; import java.util.ArrayList; import java.util.Collection; import java.util.HashMap; import java.util.HashSet; import java.util.Iterator; import java.util.LinkedList; import java.util.List; import java.util.Map; import java.util.Set; import java.util.UUID; import java.util.logging.Level; import java.util.logging.Logger; import com.vaadin.event.MarkedAsDirtyConnectorEvent; import com.vaadin.event.MarkedAsDirtyListener; import com.vaadin.server.AbstractClientConnector; import com.vaadin.server.ClientConnector; import com.vaadin.server.DragAndDropService; import com.vaadin.server.GlobalResourceHandler; import com.vaadin.server.LegacyCommunicationManager; import com.vaadin.server.StreamVariable; import com.vaadin.server.VaadinRequest; import com.vaadin.server.VaadinService; import com.vaadin.server.communication.ConnectorHierarchyWriter; import com.vaadin.shared.Registration; import elemental.json.Json; import elemental.json.JsonException; import elemental.json.JsonObject; /** * A class which takes care of book keeping of {@link ClientConnector}s for a * UI. *

* Provides {@link #getConnector(String)} which can be used to lookup a * connector from its id. This is for framework use only and should not be * needed in applications. *

* Tracks which {@link ClientConnector}s are dirty so they can be updated to the * client when the following response is sent. A connector is dirty when an * operation has been performed on it on the server and as a result of this * operation new information needs to be sent to its * {@link com.vaadin.client.ServerConnector}. *

* * @author Vaadin Ltd * @since 7.0.0 * */ public class ConnectorTracker implements Serializable { /** * Cache whether FINE messages are loggable. This is done to avoid * excessively calling getLogger() which might be slightly slow in some * specific environments. Please note that we're not caching the logger * instance itself because of * https://github.com/vaadin/framework/issues/2092. */ private static final boolean fineLogging = getLogger() .isLoggable(Level.FINE); private final Map connectorIdToConnector = new HashMap<>(); private final Set dirtyConnectors = new HashSet<>(); private final Set uninitializedConnectors = new HashSet<>(); private List markedDirtyListeners = new ArrayList<>( 0); /** * Connectors that have been unregistered and should be cleaned up the next * time {@link #cleanConnectorMap(boolean)} is invoked unless they have been * registered again. */ private final Set unregisteredConnectors = new HashSet<>(); private boolean writingResponse = false; private final UI uI; private transient Map diffStates = new HashMap<>(); /** Maps connectorIds to a map of named StreamVariables */ private Map> pidToNameToStreamVariable; private Map streamVariableToSeckey; private int currentSyncId = 0; /** * Gets a logger for this class * * @return A logger instance for logging within this class * */ private static Logger getLogger() { return Logger.getLogger(ConnectorTracker.class.getName()); } /** * Creates a new ConnectorTracker for the given uI. A tracker is always * attached to a uI and the uI cannot be changed during the lifetime of a * {@link ConnectorTracker}. * * @param uI * The uI to attach to. Cannot be null. */ public ConnectorTracker(UI uI) { this.uI = uI; } /** * Register the given connector. *

* The lookup method {@link #getConnector(String)} only returns registered * connectors. *

* * @param connector * The connector to register. */ public void registerConnector(ClientConnector connector) { boolean wasUnregistered = unregisteredConnectors.remove(connector); String connectorId = connector.getConnectorId(); ClientConnector previouslyRegistered = connectorIdToConnector .get(connectorId); if (previouslyRegistered == null) { connectorIdToConnector.put(connectorId, connector); uninitializedConnectors.add(connector); if (fineLogging) { getLogger().log(Level.FINE, "Registered {0} ({1})", new Object[] { connector.getClass().getSimpleName(), connectorId }); } } else if (previouslyRegistered != connector) { throw new RuntimeException("A connector with id " + connectorId + " is already registered!"); } else if (!wasUnregistered) { getLogger().log(Level.WARNING, "An already registered connector was registered again: {0} ({1})", new Object[] { connector.getClass().getSimpleName(), connectorId }); } dirtyConnectors.add(connector); } /** * Unregister the given connector. * *

* The lookup method {@link #getConnector(String)} only returns registered * connectors. *

* * @param connector * The connector to unregister */ public void unregisterConnector(ClientConnector connector) { String connectorId = connector.getConnectorId(); if (!connectorIdToConnector.containsKey(connectorId)) { getLogger().log(Level.WARNING, "Tried to unregister {0} ({1}) which is not registered", new Object[] { connector.getClass().getSimpleName(), connectorId }); return; } if (connectorIdToConnector.get(connectorId) != connector) { throw new RuntimeException("The given connector with id " + connectorId + " is not the one that was registered for that id"); } dirtyConnectors.remove(connector); if (!isClientSideInitialized(connector)) { // Client side has never known about this connector so there is no // point in tracking it removeUnregisteredConnector(connector, uI.getSession().getGlobalResourceHandler(false)); } else if (unregisteredConnectors.add(connector)) { // Client side knows about the connector, track it for a while if it // becomes reattached if (fineLogging) { getLogger().log(Level.FINE, "Unregistered {0} ({1})", new Object[] { connector.getClass().getSimpleName(), connectorId }); } } else { getLogger().log(Level.WARNING, "Unregistered {0} ({1}) that was already unregistered.", new Object[] { connector.getClass().getSimpleName(), connectorId }); } } /** * Checks whether the given connector has already been initialized in the * browser. The given connector should be registered with this connector * tracker. * * @param connector * the client connector to check * @return true if the initial state has previously been sent * to the browser, false if the client-side doesn't * already know anything about the connector. */ public boolean isClientSideInitialized(ClientConnector connector) { assert connectorIdToConnector.get(connector .getConnectorId()) == connector : "Connector should be registered with this ConnectorTracker"; return !uninitializedConnectors.contains(connector); } /** * Marks the given connector as initialized, meaning that the client-side * state has been initialized for the connector. * * @see #isClientSideInitialized(ClientConnector) * * @param connector * the connector that should be marked as initialized */ public void markClientSideInitialized(ClientConnector connector) { uninitializedConnectors.remove(connector); } /** * Marks all currently registered connectors as uninitialized. This should * be done when the client-side has been reset but the server-side state is * retained. * * @see #isClientSideInitialized(ClientConnector) */ public void markAllClientSidesUninitialized() { uninitializedConnectors.addAll(connectorIdToConnector.values()); diffStates.clear(); } /** * Gets a connector by its id. * * @param connectorId * The connector id to look for * @return The connector with the given id or null if no connector has the * given id */ public ClientConnector getConnector(String connectorId) { ClientConnector connector = connectorIdToConnector.get(connectorId); // Ignore connectors that have been unregistered but not yet cleaned up if (unregisteredConnectors.contains(connector)) { return null; } else if (connector != null) { return connector; } else { DragAndDropService service = uI.getSession() .getDragAndDropService(); if (connectorId.equals(service.getConnectorId())) { return service; } } return null; } /** * Cleans the connector map from all connectors that are no longer attached * to the application if there are dirty connectors or the force flag is * true. This should only be called by the framework. * * @param force * {@code true} to force cleaning * @since 8.2 */ public void cleanConnectorMap(boolean force) { if (force || !dirtyConnectors.isEmpty()) { cleanConnectorMap(); } } /** * Cleans the connector map from all connectors that are no longer attached * to the application. This should only be called by the framework. * * @deprecated use {@link #cleanConnectorMap(boolean)} instead */ @Deprecated public void cleanConnectorMap() { removeUnregisteredConnectors(); cleanStreamVariables(); // Do this expensive check only with assertions enabled assert isHierarchyComplete() : "The connector hierarchy is corrupted. " + "Check for missing calls to super.setParent(), super.attach() and super.detach() " + "and that all custom component containers call child.setParent(this) when a child is added and child.setParent(null) when the child is no longer used. " + "See previous log messages for details."; Iterator iterator = connectorIdToConnector.values() .iterator(); GlobalResourceHandler globalResourceHandler = uI.getSession() .getGlobalResourceHandler(false); while (iterator.hasNext()) { ClientConnector connector = iterator.next(); assert connector != null; if (connector.getUI() != uI) { // If connector is no longer part of this uI, // remove it from the map. If it is re-attached to the // application at some point it will be re-added through // registerConnector(connector) // This code should never be called as cleanup should take place // in detach() getLogger().log(Level.WARNING, "cleanConnectorMap unregistered connector {0}. This should have been done when the connector was detached.", getConnectorAndParentInfo(connector)); if (globalResourceHandler != null) { globalResourceHandler.unregisterConnector(connector); } uninitializedConnectors.remove(connector); diffStates.remove(connector); iterator.remove(); } else if (!uninitializedConnectors.contains(connector) && !LegacyCommunicationManager .isConnectorVisibleToClient(connector)) { // Connector was visible to the client but is no longer (e.g. // setVisible(false) has been called or SelectiveRenderer tells // it's no longer shown) -> make sure that the full state is // sent again when/if made visible uninitializedConnectors.add(connector); diffStates.remove(connector); assert isRemovalSentToClient(connector) : "Connector " + connector + " (id = " + connector.getConnectorId() + ") is no longer visible to the client, but no corresponding hierarchy change was sent."; if (fineLogging) { getLogger().log(Level.FINE, "cleanConnectorMap removed state for {0} as it is not visible", getConnectorAndParentInfo(connector)); } } } } private boolean isRemovalSentToClient(ClientConnector connector) { VaadinRequest request = VaadinService.getCurrentRequest(); if (request == null) { // Probably run from a unit test without normal request handling return true; } String attributeName = ConnectorHierarchyWriter.class.getName() + ".hierarchyInfo"; Object hierarchyInfoObj = request.getAttribute(attributeName); if (hierarchyInfoObj instanceof JsonObject) { JsonObject hierachyInfo = (JsonObject) hierarchyInfoObj; ClientConnector firstVisibleParent = findFirstVisibleParent( connector); if (firstVisibleParent == null) { // Connector is detached, not our business return true; } if (!hierachyInfo.hasKey(firstVisibleParent.getConnectorId())) { /* * No hierarchy change about to be sent, but this might be * because of an optimization that omits explicit hierarchy * changes for empty connectors that have state changes. */ if (hasVisibleChild(firstVisibleParent)) { // Not the optimization case if the parent has visible // children return false; } attributeName = ConnectorHierarchyWriter.class.getName() + ".stateUpdateConnectors"; Object stateUpdateConnectorsObj = request .getAttribute(attributeName); if (stateUpdateConnectorsObj instanceof Set) { Set stateUpdateConnectors = (Set) stateUpdateConnectorsObj; if (!stateUpdateConnectors .contains(firstVisibleParent.getConnectorId())) { // Not the optimization case if the parent is not marked // as dirty return false; } } else { getLogger().warning("Request attribute " + attributeName + " is not a Set"); } } } else { getLogger().warning("Request attribute " + attributeName + " is not a JsonObject"); } return true; } private static boolean hasVisibleChild(ClientConnector parent) { Iterable iterable = AbstractClientConnector .getAllChildrenIterable(parent); for (ClientConnector child : iterable) { if (LegacyCommunicationManager.isConnectorVisibleToClient(child)) { return true; } } return false; } private ClientConnector findFirstVisibleParent(ClientConnector connector) { while (connector != null) { connector = connector.getParent(); if (LegacyCommunicationManager .isConnectorVisibleToClient(connector)) { return connector; } } return null; } /** * Removes all references and information about connectors marked as * unregistered. * */ private void removeUnregisteredConnectors() { GlobalResourceHandler globalResourceHandler = uI.getSession() .getGlobalResourceHandler(false); for (ClientConnector connector : unregisteredConnectors) { removeUnregisteredConnector(connector, globalResourceHandler); } unregisteredConnectors.clear(); } /** * Removes all references and information about the given connector, which * must not be registered. * * @param connector * @param globalResourceHandler */ private void removeUnregisteredConnector(ClientConnector connector, GlobalResourceHandler globalResourceHandler) { ClientConnector removedConnector = connectorIdToConnector .remove(connector.getConnectorId()); assert removedConnector == connector; if (globalResourceHandler != null) { globalResourceHandler.unregisterConnector(connector); } uninitializedConnectors.remove(connector); diffStates.remove(connector); } /** * Checks that the connector hierarchy is consistent. * * @return true if the hierarchy is consistent, * false otherwise * @since 8.1 */ private boolean isHierarchyComplete() { boolean noErrors = true; Set danglingConnectors = new HashSet<>( connectorIdToConnector.values()); LinkedList stack = new LinkedList<>(); stack.add(uI); while (!stack.isEmpty()) { ClientConnector connector = stack.pop(); danglingConnectors.remove(connector); Iterable children = AbstractClientConnector .getAllChildrenIterable(connector); for (ClientConnector child : children) { stack.add(child); if (!connector.equals(child.getParent())) { noErrors = false; getLogger().log(Level.WARNING, "{0} claims that {1} is its child, but the child claims {2} is its parent.", new Object[] { getConnectorString(connector), getConnectorString(child), getConnectorString(child.getParent()) }); } } } for (ClientConnector dangling : danglingConnectors) { noErrors = false; getLogger().log(Level.WARNING, "{0} claims that {1} is its parent, but the parent does not acknowledge the parenthood.", new Object[] { getConnectorString(dangling), getConnectorString(dangling.getParent()) }); } return noErrors; } /** * Mark the connector as dirty and notifies any marked as dirty listeners. * This should not be done while the response is being written. * * @see #getDirtyConnectors() * @see #isWritingResponse() * * @param connector * The connector that should be marked clean. */ public void markDirty(ClientConnector connector) { if (isWritingResponse()) { throw new IllegalStateException( "A connector should not be marked as dirty while a response is being written."); } if (fineLogging && !isDirty(connector)) { getLogger().log(Level.FINE, "{0} is now dirty", getConnectorAndParentInfo(connector)); } if (!isDirty(connector)) { notifyMarkedAsDirtyListeners(connector); } dirtyConnectors.add(connector); } /** * Mark the connector as clean. * * @param connector * The connector that should be marked clean. */ public void markClean(ClientConnector connector) { if (fineLogging && dirtyConnectors.contains(connector)) { getLogger().log(Level.FINE, "{0} is no longer dirty", getConnectorAndParentInfo(connector)); } dirtyConnectors.remove(connector); } /** * Returns {@link #getConnectorString(ClientConnector)} for the connector * and its parent (if it has a parent). * * @param connector * The connector * @return A string describing the connector and its parent */ private String getConnectorAndParentInfo(ClientConnector connector) { String message = getConnectorString(connector); if (connector.getParent() != null) { message += " (parent: " + getConnectorString(connector.getParent()) + ")"; } return message; } /** * Returns a string with the connector name and id. Useful mostly for * debugging and logging. * * @param connector * The connector * @return A string that describes the connector */ private String getConnectorString(ClientConnector connector) { if (connector == null) { return "(null)"; } String connectorId; try { connectorId = connector.getConnectorId(); } catch (RuntimeException e) { // This happens if the connector is not attached to the application. // SHOULD not happen in this case but theoretically can. connectorId = "@" + Integer.toHexString(connector.hashCode()); } return connector.getClass().getName() + "(" + connectorId + ")"; } /** * Mark all connectors in this uI as dirty. */ public void markAllConnectorsDirty() { markConnectorsDirtyRecursively(uI); if (fineLogging) { getLogger().fine("All connectors are now dirty"); } } /** * Mark all connectors in this uI as clean. */ public void markAllConnectorsClean() { dirtyConnectors.clear(); if (fineLogging) { getLogger().fine("All connectors are now clean"); } } /** * Marks all visible connectors dirty, starting from the given connector and * going downwards in the hierarchy. * * @param c * The component to start iterating downwards from */ private void markConnectorsDirtyRecursively(ClientConnector c) { if (c instanceof Component && !((Component) c).isVisible()) { return; } markDirty(c); for (ClientConnector child : AbstractClientConnector .getAllChildrenIterable(c)) { markConnectorsDirtyRecursively(child); } } /** * Returns a collection of all connectors which have been marked as dirty. *

* The state and pending RPC calls for dirty connectors are sent to the * client in the following request. *

* * @return A collection of all dirty connectors for this uI. This list may * contain invisible connectors. */ public Collection getDirtyConnectors() { return dirtyConnectors; } /** * Checks if there a dirty connectors. * * @return true if there are dirty connectors, false otherwise */ public boolean hasDirtyConnectors() { return !getDirtyConnectors().isEmpty(); } /** * Returns a collection of those {@link #getDirtyConnectors() dirty * connectors} that are actually visible to the client. * * @return A list of dirty and visible connectors. */ public ArrayList getDirtyVisibleConnectors() { Collection dirtyConnectors = getDirtyConnectors(); ArrayList dirtyVisibleConnectors = new ArrayList<>( dirtyConnectors.size()); for (ClientConnector c : dirtyConnectors) { if (LegacyCommunicationManager.isConnectorVisibleToClient(c)) { dirtyVisibleConnectors.add(c); } } return dirtyVisibleConnectors; } public JsonObject getDiffState(ClientConnector connector) { assert getConnector(connector.getConnectorId()) == connector; return diffStates.get(connector); } public void setDiffState(ClientConnector connector, JsonObject diffState) { assert getConnector(connector.getConnectorId()) == connector; diffStates.put(connector, diffState); } public boolean isDirty(ClientConnector connector) { return dirtyConnectors.contains(connector); } /** * Checks whether the response is currently being written. Connectors can * not be marked as dirty when a response is being written. * * @see #setWritingResponse(boolean) * @see #markDirty(ClientConnector) * * @return true if the response is currently being written, * false if outside the response writing phase. */ public boolean isWritingResponse() { return writingResponse; } /** * Sets the current response write status. Connectors can not be marked as * dirty when the response is written. *

* This method has a side-effect of incrementing the sync id by one (see * {@link #getCurrentSyncId()}), if {@link #isWritingResponse()} returns * true and writingResponse is set to * false. * * @param writingResponse * the new response status. * * @see #markDirty(ClientConnector) * @see #isWritingResponse() * @see #getCurrentSyncId() * * @throws IllegalArgumentException * if the new response status is the same as the previous value. * This is done to help detecting problems caused by missed * invocations of this method. */ public void setWritingResponse(boolean writingResponse) { if (this.writingResponse == writingResponse) { throw new IllegalArgumentException( "The old value is same as the new value"); } /* * the right hand side of the && is unnecessary here because of the * if-clause above, but rigorous coding is always rigorous coding. */ if (!writingResponse && this.writingResponse) { // Bump sync id when done writing - the client is not expected to // know about anything happening after this moment. currentSyncId++; } this.writingResponse = writingResponse; } /* Special serialization to JsonObjects which are not serializable */ private void writeObject(ObjectOutputStream out) throws IOException { out.defaultWriteObject(); // Convert JsonObjects in diff state to String representation as // JsonObject is not serializable Map stringDiffStates = new HashMap<>( diffStates.size() * 2); for (ClientConnector key : diffStates.keySet()) { stringDiffStates.put(key, diffStates.get(key).toString()); } out.writeObject(stringDiffStates); } /* Special serialization to JsonObjects which are not serializable */ private void readObject(ObjectInputStream in) throws IOException, ClassNotFoundException { in.defaultReadObject(); // Read String versions of JsonObjects and parse into JsonObjects as // JsonObject is not serializable diffStates = new HashMap<>(); @SuppressWarnings("unchecked") Map stringDiffStates = (HashMap) in .readObject(); diffStates = new HashMap<>(stringDiffStates.size() * 2); for (ClientConnector key : stringDiffStates.keySet()) { try { diffStates.put(key, Json.parse(stringDiffStates.get(key))); } catch (JsonException e) { throw new IOException(e); } } } /** * Checks if the indicated connector has a StreamVariable of the given name * and returns the variable if one is found. * * @param connectorId * @param variableName * @return variable if a matching one exists, otherwise null */ public StreamVariable getStreamVariable(String connectorId, String variableName) { if (pidToNameToStreamVariable == null) { return null; } Map map = pidToNameToStreamVariable .get(connectorId); if (map == null) { return null; } StreamVariable streamVariable = map.get(variableName); return streamVariable; } /** * Adds a StreamVariable of the given name to the indicated connector. * * @param connectorId * @param variableName * @param variable */ public void addStreamVariable(String connectorId, String variableName, StreamVariable variable) { assert getConnector(connectorId) != null; if (pidToNameToStreamVariable == null) { pidToNameToStreamVariable = new HashMap<>(); } Map nameToStreamVariable = pidToNameToStreamVariable .get(connectorId); if (nameToStreamVariable == null) { nameToStreamVariable = new HashMap<>(); pidToNameToStreamVariable.put(connectorId, nameToStreamVariable); } nameToStreamVariable.put(variableName, variable); if (streamVariableToSeckey == null) { streamVariableToSeckey = new HashMap<>(); } String seckey = streamVariableToSeckey.get(variable); if (seckey == null) { /* * Despite section 6 of RFC 4122, this particular use of UUID *is* * adequate for security capabilities. Type 4 UUIDs contain 122 bits * of random data, and UUID.randomUUID() is defined to use a * cryptographically secure random generator. */ seckey = UUID.randomUUID().toString(); streamVariableToSeckey.put(variable, seckey); } } /** * Removes StreamVariables that belong to connectors that are no longer * attached to the session. */ private void cleanStreamVariables() { if (pidToNameToStreamVariable != null) { ConnectorTracker connectorTracker = uI.getConnectorTracker(); Iterator iterator = pidToNameToStreamVariable.keySet() .iterator(); while (iterator.hasNext()) { String connectorId = iterator.next(); if (connectorTracker.getConnector(connectorId) == null) { // Owner is no longer attached to the session Map removed = pidToNameToStreamVariable .get(connectorId); for (String key : removed.keySet()) { streamVariableToSeckey.remove(removed.get(key)); } iterator.remove(); } } } } /** * Removes any StreamVariable of the given name from the indicated * connector. * * @param connectorId * @param variableName */ public void cleanStreamVariable(String connectorId, String variableName) { if (pidToNameToStreamVariable == null) { return; } Map nameToStreamVar = pidToNameToStreamVariable .get(connectorId); if (nameToStreamVar != null) { StreamVariable streamVar = nameToStreamVar.remove(variableName); streamVariableToSeckey.remove(streamVar); if (nameToStreamVar.isEmpty()) { pidToNameToStreamVariable.remove(connectorId); } } } /** * Returns the security key associated with the given StreamVariable. * * @param variable * @return matching security key if one exists, null otherwise */ public String getSeckey(StreamVariable variable) { if (streamVariableToSeckey == null) { return null; } return streamVariableToSeckey.get(variable); } /** * Gets the most recently generated server sync id. *

* The sync id is incremented by one whenever a new response is being * written. This id is then sent over to the client. The client then adds * the most recent sync id to each communication packet it sends back to the * server. This way, the server knows at what state the client is when the * packet is sent. If the state has changed on the server side since that, * the server can try to adjust the way it handles the actions from the * client side. *

* The sync id value -1 is ignored to facilitate testing with * pre-recorded requests. * * @see #setWritingResponse(boolean) * @see #connectorWasPresentAsRequestWasSent(String, long) * @since 7.2 * @return the current sync id */ public int getCurrentSyncId() { return currentSyncId; } /** * Add a marked as dirty listener that will be called when a client * connector is marked as dirty. * * @param listener * listener to add * @since 8.4 * @return registration for removing listener registration */ public Registration addMarkedAsDirtyListener( MarkedAsDirtyListener listener) { markedDirtyListeners.add(listener); return () -> markedDirtyListeners.remove(listener); } /** * Notify all registered MarkedAsDirtyListeners the given client connector * has been marked as dirty. * * @param connector * client connector marked as dirty * @since 8.4 */ public void notifyMarkedAsDirtyListeners(ClientConnector connector) { MarkedAsDirtyConnectorEvent event = new MarkedAsDirtyConnectorEvent( connector, uI); new ArrayList<>(markedDirtyListeners).forEach(listener -> { listener.connectorMarkedAsDirty(event); }); } } X-Content-Type-Options: nosniff Content-Security-Policy: default-src 'none' Content-Type: text/plain; charset=UTF-8 Content-Length: 12693 Content-Disposition: inline; filename="CssLayout.java" Last-Modified: Sun, 27 Apr 2025 23:49:14 GMT Expires: Sun, 27 Apr 2025 23:54:14 GMT ETag: "dc7ae07f31ed67d2348fee1fd78498085d9a3258" /* * Copyright 2000-2022 Vaadin Ltd. * * 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.vaadin.ui; import java.util.Collections; import java.util.Iterator; import java.util.LinkedList; import org.jsoup.nodes.Element; import com.vaadin.event.LayoutEvents.LayoutClickEvent; import com.vaadin.event.LayoutEvents.LayoutClickListener; import com.vaadin.event.LayoutEvents.LayoutClickNotifier; import com.vaadin.shared.Connector; import com.vaadin.shared.EventId; import com.vaadin.shared.MouseEventDetails; import com.vaadin.shared.Registration; import com.vaadin.shared.ui.csslayout.CssLayoutServerRpc; import com.vaadin.shared.ui.csslayout.CssLayoutState; import com.vaadin.ui.declarative.DesignContext; /** * CssLayout is a layout component that can be used in browser environment only. * It simply renders components and their captions into a same div element. * Component layout can then be adjusted with css. *

* In comparison to {@link HorizontalLayout} and {@link VerticalLayout} *

rather similar server side api *
no spacing, alignment or expand ratios *
much simpler DOM that can be styled by skilled web developer *
no abstraction of browser differences (developer must ensure that the * result works properly on each browser) *
different kind of handling for relative sizes (that are set from server * side) (*) *
noticeably faster rendering time in some situations as we rely more on * the browser's rendering engine. *

* With {@link CustomLayout} one can often achieve similar results (good looking * layouts with web technologies), but with CustomLayout developer needs to work * with fixed templates. *

* By extending CssLayout one can also inject some css rules straight to child * components using {@link #getCss(Component)}. * *

* (*) Relative sizes (set from server side) are treated bit differently than in * other layouts in Vaadin. In cssLayout the size is calculated relatively to * CSS layouts content area which is pretty much as in html and css. In other * layouts the size of component is calculated relatively to the "slot" given by * layout. *

* Also note that client side framework in Vaadin modifies inline style * properties width and height. This happens on each update to component. If one * wants to set component sizes with CSS, component must have undefined size on * server side (which is not the default for all components) and the size must * be defined with class styles - not by directly injecting width and height. * * @since 6.1 brought in from "FastLayouts" incubator project * */ public class CssLayout extends AbstractLayout implements LayoutClickNotifier { private CssLayoutServerRpc rpc = (MouseEventDetails mouseDetails, Connector clickedConnector) -> fireEvent( LayoutClickEvent.createEvent(CssLayout.this, mouseDetails, clickedConnector)); /** * Custom layout slots containing the components. */ protected LinkedList components = new LinkedList<>(); /** * Constructs an empty CssLayout. */ public CssLayout() { registerRpc(rpc); } /** * Constructs a CssLayout with the given components in the given order. * * @see #addComponents(Component...) * * @param children * Components to add to the container. */ public CssLayout(Component... children) { this(); addComponents(children); } /** * Add a component into this container. The component is added to the right * or below the previous component. * * @param c * the component to be added. */ @Override public void addComponent(Component c) { // Add to components before calling super.addComponent // so that it is available to AttachListeners components.add(c); try { super.addComponent(c); } catch (IllegalArgumentException e) { components.remove(c); throw e; } } /** * Adds a component into this container. The component is added to the left * or on top of the other components. * * @param c * the component to be added. */ public void addComponentAsFirst(Component c) { // If c is already in this, we must remove it before proceeding // see ticket #7668 if (equals(c.getParent())) { removeComponent(c); } components.addFirst(c); try { super.addComponent(c); } catch (IllegalArgumentException e) { components.remove(c); throw e; } } /** * Adds a component into indexed position in this container. * * @param c * the component to be added. * @param index * the index of the component position. The components currently * in and after the position are shifted forwards. */ public void addComponent(Component c, int index) { // If c is already in this, we must remove it before proceeding // see ticket #7668 if (equals(c.getParent())) { // When c is removed, all components after it are shifted down if (index > getComponentIndex(c)) { index--; } removeComponent(c); } components.add(index, c); try { super.addComponent(c); } catch (IllegalArgumentException e) { components.remove(c); throw e; } } /** * Removes the component from this container. * * @param c * the component to be removed. */ @Override public void removeComponent(Component c) { components.remove(c); super.removeComponent(c); } /** * Gets the component container iterator for going trough all the components * in the container. * * @return the Iterator of the components inside the container. */ @Override public Iterator iterator() { return Collections.unmodifiableCollection(components).iterator(); } /** * Gets the number of contained components. Consistent with the iterator * returned by {@link #getComponentIterator()}. * * @return the number of contained components */ @Override public int getComponentCount() { return components.size(); } @Override public void beforeClientResponse(boolean initial) { super.beforeClientResponse(initial); // This is an obsolete hack that was required before Map // was supported. The workaround is to instead use a Map with // the connector id as the key, but that can only be used once the // connector has been attached. getState().childCss.clear(); for (Iterator ci = getComponentIterator(); ci.hasNext();) { Component child = ci.next(); String componentCssString = getCss(child); if (componentCssString != null) { getState().childCss.put(child, componentCssString); } } } @Override protected CssLayoutState getState() { return (CssLayoutState) super.getState(); } @Override protected CssLayoutState getState(boolean markAsDirty) { return (CssLayoutState) super.getState(markAsDirty); } /** * Returns styles to be applied to given component. Override this method to * inject custom style rules to components. * *

* Note that styles are injected over previous styles before actual child * rendering. Previous styles are not cleared, but overridden. * *

* Note that one most often achieves better code style, by separating * styling to theme (with custom theme and {@link #addStyleName(String)}. * With own custom styles it is also very easy to break browser * compatibility. * * @param c * the component * @return css rules to be applied to component */ protected String getCss(Component c) { return null; } /* Documented in superclass */ @Override public void replaceComponent(Component oldComponent, Component newComponent) { // Gets the locations int oldLocation = -1; int newLocation = -1; int location = 0; for (final Component component : components) { if (component == oldComponent) { oldLocation = location; } if (component == newComponent) { newLocation = location; } location++; } if (oldLocation == -1) { addComponent(newComponent); } else if (newLocation == -1) { removeComponent(oldComponent); addComponent(newComponent, oldLocation); } else { if (oldLocation > newLocation) { components.remove(oldComponent); components.add(newLocation, oldComponent); components.remove(newComponent); components.add(oldLocation, newComponent); } else { components.remove(newComponent); components.add(oldLocation, newComponent); components.remove(oldComponent); components.add(newLocation, oldComponent); } markAsDirty(); } } @Override public Registration addLayoutClickListener(LayoutClickListener listener) { return addListener(EventId.LAYOUT_CLICK_EVENT_IDENTIFIER, LayoutClickEvent.class, listener, LayoutClickListener.clickMethod); } @Override @Deprecated public void removeLayoutClickListener(LayoutClickListener listener) { removeListener(EventId.LAYOUT_CLICK_EVENT_IDENTIFIER, LayoutClickEvent.class, listener); } /** * Returns the index of the given component. * * @param component * The component to look up. * @return The index of the component or -1 if the component is not a child. */ public int getComponentIndex(Component component) { return components.indexOf(component); } /** * Returns the component at the given position. * * @param index * The position of the component. * @return The component at the given index. * @throws IndexOutOfBoundsException * If the index is out of range. */ public Component getComponent(int index) throws IndexOutOfBoundsException { return components.get(index); } /* * (non-Javadoc) * * @see com.vaadin.ui.AbstractComponent#readDesign(org.jsoup.nodes .Element, * com.vaadin.ui.declarative.DesignContext) */ @Override public void readDesign(Element design, DesignContext designContext) { // process default attributes super.readDesign(design, designContext); // handle children for (Element childComponent : design.children()) { Component newChild = designContext.readDesign(childComponent); addComponent(newChild); } } /* * (non-Javadoc) * * @see com.vaadin.ui.AbstractComponent#writeDesign(org.jsoup.nodes.Element * , com.vaadin.ui.declarative.DesignContext) */ @Override public void writeDesign(Element design, DesignContext designContext) { // write default attributes super.writeDesign(design, designContext); CssLayout def = designContext.getDefaultInstance(this); // handle children if (!designContext.shouldWriteChildren(this, def)) { return; } Element designElement = design; for (Component child : this) { Element childNode = designContext.createElement(child); designElement.appendChild(childNode); } } } X-Content-Type-Options: nosniff Content-Security-Policy: default-src 'none' Content-Type: text/plain; charset=UTF-8 Content-Length: 4913 Content-Disposition: inline; filename="CustomComponent.java" Last-Modified: Sun, 27 Apr 2025 23:49:14 GMT Expires: Sun, 27 Apr 2025 23:54:14 GMT ETag: "0bd3fa27607793fe472866ba1961d086cc4210d1" /* * Copyright 2000-2022 Vaadin Ltd. * * 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.vaadin.ui; import java.util.Collections; import java.util.Iterator; import com.vaadin.shared.customcomponent.CustomComponentState; /** * Custom component provides a simple implementation of the {@link Component} * interface to allow creating new UI components by composition of existing * server-side components. * *

* The component is used by inheriting the CustomComponent class and setting the * composition root component. The composition root must be set with * {@link #setCompositionRoot(Component)} before the CustomComponent is used, * such as by adding it to a layout, so it is preferable to set it in the * constructor. *

* *

* The composition root itself can contain more components. The advantage of * wrapping it in a CustomComponent is that its details, such as interfaces, are * hidden from the users of the component, thereby contributing to information * hiding. *

* *

* The CustomComponent does not display the caption of the composition root, so * if you want to have it shown in the layout where the custom component is * contained, you need to set it as caption of the CustomComponent. *

* *

* The component expands horizontally and has undefined height by default. *

* * @author Vaadin Ltd. * @since 3.0 */ @SuppressWarnings("serial") public class CustomComponent extends AbstractComponent implements HasComponents { /** * The root component implementing the custom component. */ private Component root = null; /** * Constructs a new custom component. * *

* Note that you must set the composition root before the component can be * used, preferably in the constructor. *

*/ public CustomComponent() { // Expand horizontally by default setWidth(100, Unit.PERCENTAGE); } /** * Constructs a new custom component. * * @param compositionRoot * the root of the composition component tree. It must not be * null. */ public CustomComponent(Component compositionRoot) { this(); setCompositionRoot(compositionRoot); } /** * Returns the composition root. * * @return the Component Composition root. */ protected Component getCompositionRoot() { return root; } /** * Sets the composition root for the component. * *

* You must set the composition root to a non-null value before the * component can be used. You can change it later. *

* * @param compositionRoot * the root of the composition component tree. */ protected void setCompositionRoot(Component compositionRoot) { if (compositionRoot != root) { if (root != null && equals(root.getParent())) { // remove old component root.setParent(null); } if (compositionRoot != null) { // set new component if (compositionRoot.getParent() != null) { // If the component already has a parent, try to remove it AbstractSingleComponentContainer .removeFromParent(compositionRoot); } compositionRoot.setParent(this); } root = compositionRoot; markAsDirty(); } } /* Basic component features ------------------------------------------ */ @Override public Iterator iterator() { if (getCompositionRoot() != null) { return Collections.singletonList(getCompositionRoot()).iterator(); } else { return Collections. emptyList().iterator(); } } /** * Gets the number of contained components. * * @return the number of contained components (zero or one) */ public int getComponentCount() { return (root != null ? 1 : 0); } @Override protected CustomComponentState getState() { return (CustomComponentState) super.getState(); } @Override protected CustomComponentState getState(boolean markAsDirty) { return (CustomComponentState) super.getState(markAsDirty); } } X-Content-Type-Options: nosniff Content-Security-Policy: default-src 'none' Content-Type: text/plain; charset=UTF-8 Content-Length: 5762 Content-Disposition: inline; filename="CustomField.java" Last-Modified: Sun, 27 Apr 2025 23:49:14 GMT Expires: Sun, 27 Apr 2025 23:54:14 GMT ETag: "9aec5e3c716ed31e0001255a7c7a1cff4557d6a3" /* * Copyright 2000-2022 Vaadin Ltd. * * 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.vaadin.ui; import java.util.Collections; import java.util.Iterator; import com.vaadin.data.HasValue; import com.vaadin.shared.ui.customfield.CustomFieldState; /** * A {@link HasValue} whose UI content can be constructed by the user, enabling * the creation of e.g. form fields by composing Vaadin components. * Customization of both the visual presentation and the logic of the field is * possible. *

* Subclasses must implement {@link #initContent()}. *

* Most custom fields can simply compose a user interface that calls the methods * {@link #doSetValue(Object)} and {@link #getValue()} when necessary. * * @param * field value type * * @since 8.0 */ public abstract class CustomField extends AbstractField implements HasComponents { /** * The root component implementing the custom component. */ private Component root = null; /** * Constructs a new custom field. * *

* The component is implemented by wrapping the methods of the composition * root component given as parameter. The composition root must be set * before the component can be used. *

*/ public CustomField() { // expand horizontally by default setWidth(100, Unit.PERCENTAGE); } /** * Constructs the content and notifies it that the {@link CustomField} is * attached to a window. * * @see com.vaadin.ui.Component#attach() */ @Override public void attach() { // First call super attach to notify all children (none if content has // not yet been created) super.attach(); // If the content has not yet been created, create and attach it at // this point by calling getContent() getContent(); } /** * Returns the content (UI) of the custom component. * * @return Component */ protected Component getContent() { if (null == root) { root = initContent(); root.setParent(this); } return root; } /** * Create the content component or layout for the field. Subclasses of * {@link CustomField} should implement this method. * * Note that this method is called when the CustomField is attached to a * layout or when {@link #getContent()} is called explicitly for the first * time. It is only called once for a {@link CustomField}. * * @return {@link Component} representing the UI of the CustomField */ protected abstract Component initContent(); // Size related methods // TODO might not be necessary to override but following the pattern from // AbstractComponentContainer @Override public void setHeight(float height, Unit unit) { super.setHeight(height, unit); markAsDirtyRecursive(); } @Override public void setWidth(float width, Unit unit) { super.setWidth(width, unit); markAsDirtyRecursive(); } @Override protected CustomFieldState getState() { return (CustomFieldState) super.getState(); } @Override protected CustomFieldState getState(boolean markAsDirty) { return (CustomFieldState) super.getState(markAsDirty); } // ComponentContainer methods @Override public Iterator iterator() { // Can't use getContent() here as this will cause an infinite loop if // initContent happens to all iterator(). This happens if you do // setWidth... if (root != null) { return Collections.singletonList(root).iterator(); } else { return Collections. emptyList().iterator(); } } /** * Sets the component to which all methods from the {@link Focusable} * interface should be delegated. *

* Set this to a wrapped field to include that field in the tabbing order, * to make it receive focus when {@link #focus()} is called and to make it * be correctly focused when used as a Grid editor component. *

* By default, {@link Focusable} events are handled by the super class and * ultimately ignored. * * @param focusDelegate * the focusable component to which focus events are redirected */ public void setFocusDelegate(Focusable focusDelegate) { getState().focusDelegate = focusDelegate; } private Focusable getFocusable() { return (Focusable) getState(false).focusDelegate; } @Override public void focus() { if (getFocusable() != null) { getFocusable().focus(); } else { super.focus(); } } @Override public int getTabIndex() { if (getFocusable() != null) { return getFocusable().getTabIndex(); } else { return super.getTabIndex(); } } @Override public void setTabIndex(int tabIndex) { if (getFocusable() != null) { getFocusable().setTabIndex(tabIndex); } else { super.setTabIndex(tabIndex); } } } X-Content-Type-Options: nosniff Content-Security-Policy: default-src 'none' Content-Type: text/plain; charset=UTF-8 Content-Length: 11325 Content-Disposition: inline; filename="CustomLayout.java" Last-Modified: Sun, 27 Apr 2025 23:49:14 GMT Expires: Sun, 27 Apr 2025 23:54:14 GMT ETag: "17fa00fca576c25b228983c2c915e8c7e00b45e7" /* * Copyright 2000-2022 Vaadin Ltd. * * 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.vaadin.ui; import static java.nio.charset.StandardCharsets.UTF_8; import java.io.BufferedReader; import java.io.IOException; import java.io.InputStream; import java.io.InputStreamReader; import java.util.Collections; import java.util.HashMap; import java.util.Iterator; import java.util.Map; import java.util.Map.Entry; import java.util.Set; import org.jsoup.nodes.Element; import com.vaadin.server.JsonPaintTarget; import com.vaadin.server.PaintException; import com.vaadin.server.PaintTarget; import com.vaadin.shared.ui.customlayout.CustomLayoutState; import com.vaadin.ui.declarative.DesignContext; /** *

* A container component with freely designed layout and style. The layout * consists of items with textually represented locations. Each item contains * one sub-component, which can be any Vaadin component, such as a layout. The * adapter and theme are responsible for rendering the layout with a given style * by placing the items in the defined locations. *

* *

* The placement of the locations is not fixed - different themes can define the * locations in a way that is suitable for them. One typical example would be to * create visual design for a web site as a custom layout: the visual design * would define locations for "menu", "body", and "title", for example. The * layout would then be implemented as an HTML template for each theme. *

* *

* A location is identified with the attribute "data-location" or "location" * which has the location name as its value. *

* *

* The default theme handles the styles that are not defined by drawing the * subcomponents just as in OrderedLayout. *

* * @author Vaadin Ltd. * @since 3.0 */ @SuppressWarnings("serial") public class CustomLayout extends AbstractLayout implements LegacyComponent { private static final int BUFFER_SIZE = 10000; /** * Custom layout slots containing the components. */ private final Map slots = new HashMap<>(); /** * Default constructor only used by subclasses. Subclasses are responsible * for setting the appropriate fields. Either * {@link #setTemplateName(String)}, that makes layout fetch the template * from theme, or {@link #setTemplateContents(String)}. * * @since 7.5.0 */ public CustomLayout() { setWidth(100, Unit.PERCENTAGE); } /** * Constructs a custom layout with the template given in the stream. * * @param templateStream * Stream containing template data. Must be using UTF-8 encoding. * To use a String as a template use for instance new * ByteArrayInputStream("<template>".getBytes()). * @throws IOException */ public CustomLayout(InputStream templateStream) throws IOException { this(); initTemplateContentsFromInputStream(templateStream); } /** * Constructor for custom layout with given template name. Template file is * fetched from "<theme>/layouts/<templateName>". */ public CustomLayout(String template) { this(); setTemplateName(template); } protected void initTemplateContentsFromInputStream( InputStream templateStream) throws IOException { BufferedReader reader = new BufferedReader( new InputStreamReader(templateStream, UTF_8)); StringBuilder builder = new StringBuilder(BUFFER_SIZE); try { char[] cbuf = new char[BUFFER_SIZE]; int nRead; while ((nRead = reader.read(cbuf, 0, BUFFER_SIZE)) > 0) { builder.append(cbuf, 0, nRead); } } finally { reader.close(); } setTemplateContents(builder.toString()); } @Override protected CustomLayoutState getState() { return (CustomLayoutState) super.getState(); } @Override protected CustomLayoutState getState(boolean markAsDirty) { return (CustomLayoutState) super.getState(markAsDirty); } /** * Adds the component into this container to given location. If the location * is already populated, the old component is removed. * * @param c * the component to be added. * @param location * the location of the component. */ public void addComponent(Component c, String location) { final Component old = slots.get(location); if (old != null) { removeComponent(old); } slots.put(location, c); getState().childLocations.put(c, location); super.addComponent(c); } /** * Adds the component into this container. The component is added without * specifying the location (empty string is then used as location). Only one * component can be added to the default "" location and adding more * components into that location overwrites the old components. * * @param c * the component to be added. */ @Override public void addComponent(Component c) { this.addComponent(c, ""); } /** * Removes the component from this container. * * @param c * the component to be removed. */ @Override public void removeComponent(Component c) { if (c == null) { return; } slots.values().remove(c); getState().childLocations.remove(c); super.removeComponent(c); } /** * Removes the component from this container from given location. * * @param location * the Location identifier of the component. */ public void removeComponent(String location) { this.removeComponent(slots.get(location)); } /** * Gets the component container iterator for going trough all the components * in the container. * * @return the Iterator of the components inside the container. */ @Override public Iterator iterator() { return Collections.unmodifiableCollection(slots.values()).iterator(); } /** * Gets the number of contained components. Consistent with the iterator * returned by {@link #getComponentIterator()}. * * @return the number of contained components */ @Override public int getComponentCount() { return slots.values().size(); } /** * Gets the child-component by its location. * * @param location * the name of the location where the requested component * resides. * @return the Component in the given location or null if not found. */ public Component getComponent(String location) { return slots.get(location); } /* Documented in superclass */ @Override public void replaceComponent(Component oldComponent, Component newComponent) { // Gets the locations String oldLocation = null; String newLocation = null; for (final String location : slots.keySet()) { final Component component = slots.get(location); if (component == oldComponent) { oldLocation = location; } if (component == newComponent) { newLocation = location; } } if (oldLocation == null) { addComponent(newComponent); } else if (newLocation == null) { removeComponent(oldLocation); addComponent(newComponent, oldLocation); } else { slots.put(newLocation, oldComponent); slots.put(oldLocation, newComponent); getState().childLocations.put(newComponent, oldLocation); getState().childLocations.put(oldComponent, newLocation); } } /** Get the name of the template. */ public String getTemplateName() { return getState(false).templateName; } /** Get the contents of the template. */ public String getTemplateContents() { return getState(false).templateContents; } /** * Set the name of the template used to draw custom layout. * * With GWT-adapter, the template with name 'templatename' is loaded from * VAADIN/themes/themename/layouts/templatename.html. If the theme has not * been set (with Application.setTheme()), themename is 'default'. * * @param templateName */ public void setTemplateName(String templateName) { getState().templateName = templateName; getState().templateContents = null; } /** * Set the contents of the template used to draw the custom layout. * * Note: setTemplateContents can be applied only before CustomLayout * instance has been attached. * * @param templateContents */ public void setTemplateContents(String templateContents) { getState().templateContents = templateContents; getState().templateName = null; } @Override public void changeVariables(Object source, Map variables) { // Nothing to see here } @Override public void paintContent(PaintTarget target) throws PaintException { // Workaround to make the CommunicationManager read the template file // and send it to the client String templateName = getState(false).templateName; if (templateName != null && !templateName.isEmpty()) { Set

Tag	Description	Example
<b>	bold	bold text
<i>	italic	italic text
<u>	underlined	underlined text
<br>	linebreak	N/A
<ul> * <li>item1 * <li>item1 * </ul>	item list	* * item1 * item2 * *

Tag	Description	Example
<b>	bold	bold text
<i>	italic	italic text
<u>	underlined	underlined text
<br>	linebreak	N/A
<ul> * <li>item1 * <li>item1 * </ul>	item list	* * item1 * item2 * *

/server/src/main/java/com/vaadin/ui/components/

/server/src/main/java/com/vaadin/ui/declarative/

/server/src/main/java/com/vaadin/ui/dnd/

/server/src/main/java/com/vaadin/ui/renderers/

/server/src/main/java/com/vaadin/ui/themes/