com.vaadin.ui.AbsoluteLayout Maven / Gradle / Ivy
/*
* Vaadin Framework 7
*
* Copyright (C) 2000-2024 Vaadin Ltd
*
* This program is available under Vaadin Commercial License and Service Terms.
*
* See for the full
* license.
*/
package com.vaadin.ui;
import java.io.Serializable;
import java.util.HashMap;
import java.util.Iterator;
import java.util.LinkedHashMap;
import java.util.Map;
import org.jsoup.nodes.Attributes;
import org.jsoup.nodes.Element;
import org.jsoup.nodes.Node;
import com.vaadin.event.LayoutEvents.LayoutClickEvent;
import com.vaadin.event.LayoutEvents.LayoutClickListener;
import com.vaadin.event.LayoutEvents.LayoutClickNotifier;
import com.vaadin.server.Sizeable;
import com.vaadin.shared.Connector;
import com.vaadin.shared.EventId;
import com.vaadin.shared.MouseEventDetails;
import com.vaadin.shared.ui.absolutelayout.AbsoluteLayoutServerRpc;
import com.vaadin.shared.ui.absolutelayout.AbsoluteLayoutState;
import com.vaadin.ui.declarative.DesignAttributeHandler;
import com.vaadin.ui.declarative.DesignContext;
/**
* AbsoluteLayout is a layout implementation that mimics html absolute
* positioning.
*
*/
@SuppressWarnings("serial")
public class AbsoluteLayout extends AbstractLayout
implements LayoutClickNotifier {
// constants for design attributes
private static final String ATTR_TOP = ":top";
private static final String ATTR_RIGHT = ":right";
private static final String ATTR_BOTTOM = ":bottom";
private static final String ATTR_LEFT = ":left";
private static final String ATTR_Z_INDEX = ":z-index";
private AbsoluteLayoutServerRpc rpc = new AbsoluteLayoutServerRpc() {
@Override
public void layoutClick(MouseEventDetails mouseDetails,
Connector clickedConnector) {
fireEvent(LayoutClickEvent.createEvent(AbsoluteLayout.this,
mouseDetails, clickedConnector));
}
};
// Maps each component to a position
private LinkedHashMap componentToCoordinates = new LinkedHashMap();
/**
* Creates an AbsoluteLayout with full size.
*/
public AbsoluteLayout() {
registerRpc(rpc);
setSizeFull();
}
@Override
protected AbsoluteLayoutState getState() {
return (AbsoluteLayoutState) super.getState();
}
/**
* Gets an iterator for going through all components enclosed in the
* absolute layout.
*/
@Override
public Iterator iterator() {
return componentToCoordinates.keySet().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 componentToCoordinates.size();
}
/**
* Replaces one component with another one. The new component inherits the
* old components position.
*/
@Override
public void replaceComponent(Component oldComponent,
Component newComponent) {
ComponentPosition position = getPosition(oldComponent);
removeComponent(oldComponent);
addComponent(newComponent, position);
}
/*
* (non-Javadoc)
*
* @see com.vaadin.ui.AbstractComponentContainer#addComponent(com.vaadin.ui.
* Component )
*/
@Override
public void addComponent(Component c) {
addComponent(c, new ComponentPosition());
}
/**
* Adds a component to the layout. The component can be positioned by
* providing a string formatted in CSS-format.
*
* For example the string "top:10px;left:10px" will position the component
* 10 pixels from the left and 10 pixels from the top. The identifiers:
* "top","left","right" and "bottom" can be used to specify the position.
*
*
* @param c
* The component to add to the layout
* @param cssPosition
* The css position string
*/
public void addComponent(Component c, String cssPosition) {
ComponentPosition position = new ComponentPosition();
position.setCSSString(cssPosition);
addComponent(c, position);
}
/**
* Adds the component using the given position. Ensures the position is only
* set if the component is added correctly.
*
* @param c
* The component to add
* @param position
* The position info for the component. Must not be null.
* @throws IllegalArgumentException
* If adding the component failed
*/
private void addComponent(Component c, ComponentPosition position)
throws IllegalArgumentException {
if (equals(c.getParent())) {
removeComponent(c);
}
/*
* Create position instance and add it to componentToCoordinates map. We
* need to do this before we call addComponent so the attachListeners
* can access this position. #6368
*/
internalSetPosition(c, position);
try {
super.addComponent(c);
} catch (IllegalArgumentException e) {
internalRemoveComponent(c);
throw e;
}
}
/**
* Removes the component from all internal data structures. Does not
* actually remove the component from the layout (this is assumed to have
* been done by the caller).
*
* @param c
* The component to remove
*/
private void internalRemoveComponent(Component c) {
componentToCoordinates.remove(c);
}
@Override
public void beforeClientResponse(boolean initial) {
super.beforeClientResponse(initial);
// This could be in internalRemoveComponent and internalSetComponent if
// Map was supported. We cannot get the child
// connectorId unless the component is attached to the application so
// the String->String map cannot be populated in internal* either.
Map connectorToPosition = new HashMap();
for (Iterator ci = getComponentIterator(); ci.hasNext();) {
Component c = ci.next();
connectorToPosition.put(c.getConnectorId(),
getPosition(c).getCSSString());
}
getState().connectorToCssPosition = connectorToPosition;
}
/*
* (non-Javadoc)
*
* @see
* com.vaadin.ui.AbstractComponentContainer#removeComponent(com.vaadin.ui
* .Component)
*/
@Override
public void removeComponent(Component c) {
internalRemoveComponent(c);
super.removeComponent(c);
}
/**
* Gets the position of a component in the layout. Returns null if component
* is not attached to the layout.
*
* Note that you cannot update the position by updating this object. Call
* {@link #setPosition(Component, ComponentPosition)} with the updated
* {@link ComponentPosition} object.
*
*
* @param component
* The component which position is needed
* @return An instance of ComponentPosition containing the position of the
* component, or null if the component is not enclosed in the
* layout.
*/
public ComponentPosition getPosition(Component component) {
return componentToCoordinates.get(component);
}
/**
* Sets the position of a component in the layout.
*
* @param component
* @param position
*/
public void setPosition(Component component, ComponentPosition position) {
if (!componentToCoordinates.containsKey(component)) {
throw new IllegalArgumentException(
"Component must be a child of this layout");
}
internalSetPosition(component, position);
}
/**
* Updates the position for a component. Caller must ensure component is a
* child of this layout.
*
* @param component
* The component. Must be a child for this layout. Not enforced.
* @param position
* New position. Must not be null.
*/
private void internalSetPosition(Component component,
ComponentPosition position) {
componentToCoordinates.put(component, position);
markAsDirty();
}
/**
* The CompontPosition class represents a components position within the
* absolute layout. It contains the attributes for left, right, top and
* bottom and the units used to specify them.
*/
public class ComponentPosition implements Serializable {
private int zIndex = -1;
private Float topValue = null;
private Float rightValue = null;
private Float bottomValue = null;
private Float leftValue = null;
private Unit topUnits = Unit.PIXELS;
private Unit rightUnits = Unit.PIXELS;
private Unit bottomUnits = Unit.PIXELS;
private Unit leftUnits = Unit.PIXELS;
/**
* Sets the position attributes using CSS syntax. Attributes not
* included in the string are reset to their unset states.
*
*
* setCSSString("top:10px;left:20%;z-index:16;");
*