org.eclipse.osbp.vaadin.addons.absolutelayout/src/org/eclipse/osbp/vaadin/addons/absolutelayout/client/OAbsoluteLayoutWidget.java

/**
 *                                                                            
 * Copyright (c) 2011, 2016 - Loetz GmbH&Co.KG (69115 Heidelberg, Germany)
 *                                                                            
 * All rights reserved. This program and the accompanying materials           
 * are made available under the terms of the Eclipse Public License v1.0       
 * which accompanies this distribution, and is available at                  
 * http://www.eclipse.org/legal/epl-v10.html                                 
 *                                                                            
 * Contributors:   
 * Florian Pirchner <florian.pirchner@gmail.com> - Initial implementation
 */
package org.eclipse.osbp.vaadin.addons.absolutelayout.client;

import java.math.BigDecimal;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

import com.google.gwt.dom.client.Element;
import com.google.gwt.dom.client.EventTarget;
import com.google.gwt.dom.client.NativeEvent;
import com.google.gwt.dom.client.Style;
import com.google.gwt.dom.client.Style.Unit;
import com.google.gwt.event.dom.client.KeyCodes;
import com.google.gwt.event.shared.HandlerRegistration;
import com.google.gwt.user.client.DOM;
import com.google.gwt.user.client.Event;
import com.google.gwt.user.client.Event.NativePreviewEvent;
import com.google.gwt.user.client.Event.NativePreviewHandler;
import com.google.gwt.user.client.EventListener;
import com.google.gwt.user.client.ui.Widget;
import com.google.gwt.user.client.ui.WidgetCollection;
import com.vaadin.client.ComponentConnector;
import com.vaadin.client.Util;
import com.vaadin.client.WidgetUtil;
import com.vaadin.client.ui.dd.VDragEvent;

import fi.jasoft.dragdroplayouts.client.ui.absolutelayout.VDDAbsoluteLayout;

// TODO: Auto-generated Javadoc
/**
 * Absolute layout widget that supports drag and drop, resizing and alignment.
 */
public class OAbsoluteLayoutWidget extends VDDAbsoluteLayout {

	/** The Constant CLASSNAME. */
	public static final String CLASSNAME = "o-absolutelayout";

	/** The resize listener. */
	protected OChildResizeListener resizeListener;

	/** The use resizing. */
	protected boolean useResizing;

	/**
	 * Instantiates a new o absolute layout widget.
	 */
	public OAbsoluteLayoutWidget() {
		addStyleName(CLASSNAME);
	}

	/* (non-Javadoc)
	 * @see fi.jasoft.dragdroplayouts.client.ui.absolutelayout.VDDAbsoluteLayout#postDropHook(com.vaadin.client.ui.dd.VDragEvent)
	 */
	@Override
	protected boolean postDropHook(VDragEvent drag) {
		boolean result = super.postDropHook(drag);

		OAlignmentManager.get().updateDropDetails(drag);
		OAlignmentManager.get().stop();

		return result;
	}

	/* (non-Javadoc)
	 * @see fi.jasoft.dragdroplayouts.client.ui.absolutelayout.VDDAbsoluteLayout#postEnterHook(com.vaadin.client.ui.dd.VDragEvent)
	 */
	@Override
	protected void postEnterHook(VDragEvent drag) {
		super.postEnterHook(drag);

		updateDrag(drag);
	}

	/* (non-Javadoc)
	 * @see fi.jasoft.dragdroplayouts.client.ui.absolutelayout.VDDAbsoluteLayout#postLeaveHook(com.vaadin.client.ui.dd.VDragEvent)
	 */
	@Override
	protected void postLeaveHook(VDragEvent drag) {
		super.postLeaveHook(drag);

		updateDrag(drag);
	}

	/* (non-Javadoc)
	 * @see fi.jasoft.dragdroplayouts.client.ui.absolutelayout.VDDAbsoluteLayout#postOverHook(com.vaadin.client.ui.dd.VDragEvent)
	 */
	@Override
	protected void postOverHook(VDragEvent drag) {
		super.postOverHook(drag);

		updateDrag(drag);
	}

	/**
	 * Updates the drag information and alignments.
	 *
	 * @param drag the drag
	 */
	private void updateDrag(VDragEvent drag) {
		if (!OAlignmentManager.get().isActive()) {
			OAlignmentManager.get().startDragAndDrop(this);
		}
		OAlignmentManager.get().updateAlignmentsForDrop(drag);
	}

	/**
	 * True, if alignments should be used. False otherwise.
	 *
	 * @param useAlignments the new use alignments
	 */
	public void setUseAlignments(boolean useAlignments) {
		OAlignmentManager.get().setUseAlignments(useAlignments);
	}

	/**
	 * True, if resizing should be used. False otherwise.
	 *
	 * @param useResizing the new use resizing
	 */
	public void setUseResizing(boolean useResizing) {
		this.useResizing = useResizing;

		for (Widget child : getChildren()) {
			if (child instanceof ResizableAbsoluteWrapper) {
				ResizableAbsoluteWrapper wrapper = (ResizableAbsoluteWrapper) child;
				wrapper.setResizable(useResizing);
			}
		}
	}

	/* (non-Javadoc)
	 * @see com.google.gwt.user.client.ui.ComplexPanel#getChildren()
	 */
	public WidgetCollection getChildren() {
		return super.getChildren();
	}

	/* (non-Javadoc)
	 * @see com.vaadin.client.ui.VAbsoluteLayout#add(com.google.gwt.user.client.ui.Widget)
	 */
	@Override
	public void add(Widget child) {
		ResizableAbsoluteWrapper wrapper = new ResizableAbsoluteWrapper(child);
		super.add(wrapper, canvas);
	}

	/**
	 * Returns true, if alignments are used. False otherwise.
	 *
	 * @return true, if is use alignments
	 */
	public boolean isUseAlignments() {
		return OAlignmentManager.get().isUseAlignments();
	}

	/**
	 * Sets the resize listener.
	 *
	 * @param resizeListener the new resize listener
	 */
	public void setResizeListener(OChildResizeListener resizeListener) {
		this.resizeListener = resizeListener;
	}

	/**
	 * The Class ResizeHandler.
	 */
	protected static class ResizeHandler implements EventListener {

		/** The wrapper. */
		protected final ResizableAbsoluteWrapper wrapper;

		/** The start client x. */
		protected int startClientX = 0;
		
		/** The start client y. */
		protected int startClientY = 0;
		
		/** The start width. */
		protected int startWidth = 0;
		
		/** The start height. */
		protected int startHeight = 0;
		
		/** The resizing x. */
		protected boolean resizingX;
		
		/** The revert x. */
		protected boolean revertX;
		
		/** The revert y. */
		protected boolean revertY;
		
		/** The resizing y. */
		protected boolean resizingY;

		/** The dragged element. */
		// TODO remove me later -> Same as wrapper?
		protected Element draggedElement;
		
		/** The waiting accept. */
		protected boolean waitingAccept;
		
		/** The cancel listener registration. */
		protected HandlerRegistration cancelListenerRegistration;
		
		/** The resize canceled. */
		protected boolean resizeCanceled;

		/** The keep aspect ratio. */
		protected boolean keepAspectRatio;

		/** The old width. */
		protected int oldWidth;
		
		/** The old height. */
		protected int oldHeight;
		
		/** The resize location. */
		protected OResizeLocation resizeLocation;

		/** The Constant locationToCursorMap. */
		@SuppressWarnings("serial")
		protected static final Map<OResizeLocation, String> locationToCursorMap = new HashMap<OResizeLocation, String>() {
			{
				// put(CResizeLocation.TOP_LEFT, "nwse-resize");
				put(OResizeLocation.TOP, "ns-resize");
				// put(CResizeLocation.TOP_RIGHT, "nesw-resize");
				put(OResizeLocation.RIGHT, "ew-resize");
				// put(CResizeLocation.BOTTOM_RIGHT, "nwse-resize");
				put(OResizeLocation.BOTTOM, "ns-resize");
				// put(CResizeLocation.BOTTOM_LEFT, "nesw-resize");
				put(OResizeLocation.LEFT, "ew-resize");
			}
		};

		/**
		 * Instantiates a new resize handler.
		 *
		 * @param wrapper the wrapper
		 */
		public ResizeHandler(ResizableAbsoluteWrapper wrapper) {
			this.wrapper = wrapper;
		}

		/* (non-Javadoc)
		 * @see com.google.gwt.user.client.EventListener#onBrowserEvent(com.google.gwt.user.client.Event)
		 */
		@Override
		public void onBrowserEvent(Event event) {
			final EventTarget currentTarget = event.getCurrentEventTarget();
			final Element target = currentTarget.cast();
			final Element targetParent = target.getParentElement();
			if (resizingX || resizingY || wrapper.getElement().equals(targetParent)
					|| (targetParent != null && wrapper.getElement().equals(targetParent.getParentElement()))) {
				switch (event.getTypeInt()) {
				case Event.ONMOUSEMOVE:
					onMouseMove(event);
					break;
				case Event.ONMOUSEDOWN:
					onResizeStart(event, target);
					break;
				case Event.ONMOUSEUP:
					onResizeEnd(event);
					break;
				default:
					break;
				}
			} else if (resizeCanceled && event.getTypeInt() == Event.ONMOUSEUP) {
				event.preventDefault();
				event.stopPropagation();
			}
		}

		/**
		 * On mouse move.
		 *
		 * @param event the event
		 */
		protected void onMouseMove(Event event) {
			if (!resizingX && !resizingY) {
				return;
			}

			double height = -1.0;
			double width = -1.0;

			if (resizingY) {
				int clientY = WidgetUtil.getTouchOrMouseClientY(event);
				if (!isInVerticalBoundary(event)) {
					// set the size to the edge of the boundary element
					clientY = clientY < wrapper.getElement().getAbsoluteTop()
							? (wrapper.getElement().getAbsoluteTop() + 2)
							: (wrapper.getElement().getAbsoluteBottom() - 2);
				}
				int extraScrollHeight = wrapper.getElement() == null ? 0 : wrapper.getElement().getScrollTop();
				height = startHeight + extraScrollHeight + (revertY ? startClientY - clientY : clientY - startClientY);
				event.stopPropagation();
			}

			if (resizingX) {
				int clientX = WidgetUtil.getTouchOrMouseClientX(event);
				if (!isInHorizontalBoundary(event)) {
					// set the size to the edge of the boundary element
					clientX = clientX < wrapper.getElement().getAbsoluteLeft()
							? (wrapper.getElement().getAbsoluteLeft() + 2)
							: (wrapper.getElement().getAbsoluteRight() - 2);
				}
				int extraScrollWidth = wrapper.getElement() == null ? 0 : wrapper.getElement().getScrollLeft();
				width = startWidth + extraScrollWidth + (revertX ? startClientX - clientX : clientX - startClientX);
				event.stopPropagation();
			}

			if (keepAspectRatio && (height > -1.0 || width > 1.0)) {
				final double wRatio = width / startWidth;
				final double hRatio = height / startHeight;

				if (height == -1.0) {
					height = startHeight * wRatio;
				} else if (width == -1.0) {
					width = startWidth * hRatio;
				} else {
					if (wRatio < hRatio) {
						height = startHeight * wRatio;
					} else {
						width = startWidth * hRatio;
					}

				}

				wrapper.dragOverlayElement.getStyle().setHeight(height, Unit.PX);
				wrapper.dragOverlayElement.getStyle().setWidth(width, Unit.PX);
			}

			if (height > -1.0) {
				wrapper.dragOverlayElement.getStyle().setHeight(height, Unit.PX);
			}
			if (width > -1.0) {
				wrapper.dragOverlayElement.getStyle().setWidth(width, Unit.PX);
			}

			// notify about resizing
			wrapper.notifyResizing((int) width, (int) height, oldWidth, oldHeight, resizeLocation, draggedElement,
					wrapper.dragOverlayElement);

		}

		/**
		 * Checks if is in horizontal boundary.
		 *
		 * @param event the event
		 * @return true, if is in horizontal boundary
		 */
		protected boolean isInHorizontalBoundary(Event event) {
			if (wrapper.getParent().getElement() != null) {
				int clientX = event.getClientX();
				int right = wrapper.getParent().getElement().getAbsoluteRight() - 1;
				int left = wrapper.getParent().getElement().getAbsoluteLeft() + 1;
				return clientX > left && clientX < right;
			}
			return true;
		}

		/**
		 * Checks if is in vertical boundary.
		 *
		 * @param event the event
		 * @return true, if is in vertical boundary
		 */
		protected boolean isInVerticalBoundary(Event event) {
			if (wrapper.getParent().getElement() != null) {
				int clientY = event.getClientY();
				int top = wrapper.getParent().getElement().getAbsoluteTop() + 1;
				int bottom = wrapper.getParent().getElement().getAbsoluteBottom() - 1;
				return clientY > top && clientY < bottom;
			}
			return true;
		}

		/**
		 * Override cursor.
		 *
		 * @param location the location
		 */
		protected void overrideCursor(OResizeLocation location) {
			String cursorValue = locationToCursorMap.get(location);
			if (wrapper.getElement() != null) {
				wrapper.getElement().getStyle().setProperty("cursor", cursorValue);
			}
			wrapper.dragOverlayElement.getStyle().setProperty("cursor", cursorValue);
		}

		/**
		 * Stop cursor override.
		 */
		protected void stopCursorOverride() {
			if (wrapper.getElement() != null) {
				wrapper.getElement().getStyle().clearCursor();
			}
			wrapper.dragOverlayElement.getStyle().clearCursor();
		}

		/**
		 * Mark boundary resizing.
		 */
		protected void markBoundaryResizing() {
			if (wrapper.getElement() != null) {
				wrapper.getElement().addClassName("resizing-child");
			}
		}

		/**
		 * Unmark boundary resizing.
		 */
		protected void unmarkBoundaryResizing() {
			if (wrapper.getElement() != null) {
				wrapper.getElement().removeClassName("resizing-child");
			}
		}

		/**
		 * Accept resize.
		 *
		 * @param accept the accept
		 */
		protected void acceptResize(boolean accept) {
			if (waitingAccept) {
				waitingAccept = false;
				OAlignmentManager.get().updateResizedWidget(accept, oldWidth, oldHeight);
				OAlignmentManager.get().stop();

				resizingX = false;
				resizingY = false;
				draggedElement = null;
				wrapper.dragOverlayElement.removeFromParent();
				Style style = wrapper.dragOverlayElement.getStyle();
				style.clearTop();
				style.clearRight();
				style.clearBottom();
				style.clearLeft();
				style.clearHeight();
				style.clearWidth();
				startClientX = 0;
				startClientY = 0;
				startHeight = 0;
				startWidth = 0;

				oldWidth = 0;
				oldHeight = 0;
				resizeLocation = null;

				wrapper.getElement().removeClassName("resizing");
			}
		}

		/**
		 * On resize end.
		 *
		 * @param event the event
		 */
		protected void onResizeEnd(Event event) {
			if (resizingX || resizingY) {
				resizingX = false;
				resizingY = false;
				waitingAccept = true;

				keepAspectRatio = false;

				Event.releaseCapture(draggedElement);
				event.stopPropagation();

				stopCursorOverride();
				unmarkBoundaryResizing();

				acceptResize(true);
			}
		}

		/**
		 * On resize start.
		 *
		 * @param event the event
		 * @param target the target
		 */
		protected void onResizeStart(Event event, Element target) {
			if (!(resizingX || resizingY || waitingAccept)) {
				resizeCanceled = false;
				keepAspectRatio = false;
				draggedElement = target;
				// startWidth =
				// WidgetUtil.getRequiredWidth(wrapper.getElement());
				// startHeight =
				// WidgetUtil.getRequiredHeight(wrapper.getElement());
				startWidth = wrapper.getElement().getOffsetWidth();
				startHeight = wrapper.getElement().getOffsetHeight();
				if (target.equals(wrapper.topEdge) || target.equals(wrapper.bottomEdge)) {
					resizeLocation = startVerticalResize(event, target);
				} else if (target.equals(wrapper.leftEdge) || target.equals(wrapper.rightEdge)) {
					resizeLocation = startHorizontalResize(event, target);
				}
				// else {
				// resizeLocation = startDiagonalResize(event, target);
				// }

				// initialize the old values
				oldWidth = wrapper.getElement().getOffsetWidth();
				oldHeight = wrapper.getElement().getOffsetHeight();

				wrapper.getElement().addClassName("resizing");
				wrapper.getElement().appendChild(wrapper.dragOverlayElement);
				Event.setCapture(draggedElement);
				event.stopPropagation();

				overrideCursor(resizeLocation);
				markBoundaryResizing();
				listenToKeyboard();

				OAlignmentManager.get().startResize((OAbsoluteLayoutWidget) wrapper.getParent(), wrapper,
						resizeLocation, wrapper.dragOverlayElement);
			}
		}

		/**
		 * Listen to keyboard.
		 */
		protected void listenToKeyboard() {
			cancelListenerRegistration = Event.addNativePreviewHandler(new NativePreviewHandler() {

				@Override
				public void onPreviewNativeEvent(NativePreviewEvent event) {
					if (event.getTypeInt() == Event.ONKEYDOWN && (resizingX || resizingY)) {
						final int keyCode = event.getNativeEvent().getKeyCode();
						if (keyCode == KeyCodes.KEY_ESCAPE) {
							onResizeCancel(event.getNativeEvent());
						} else if (keyCode == KeyCodes.KEY_SHIFT) {
							keepAspectRatio = true;
						}
					} else if (event.getTypeInt() == Event.ONKEYUP && (resizingX || resizingY)) {
						final int keyCode = event.getNativeEvent().getKeyCode();
						if (keyCode == KeyCodes.KEY_SHIFT) {
							keepAspectRatio = false;
						}
					}
				}
			});
		}

		/**
		 * On resize cancel.
		 *
		 * @param event the event
		 */
		protected void onResizeCancel(NativeEvent event) {
			if (cancelListenerRegistration != null) {
				cancelListenerRegistration.removeHandler();
			}
			Event.releaseCapture(draggedElement);
			event.stopPropagation();
			event.preventDefault();

			resizeCanceled = true;
			waitingAccept = true;
			acceptResize(false);

			keepAspectRatio = false;

			stopCursorOverride();
			unmarkBoundaryResizing();
		}

		// protected CResizeLocation startDiagonalResize(Event event, Element
		// target) {
		// CResizeLocation resizeLocation;
		// resizingX = true;
		// resizingY = true;
		//
		// Style style = wrapper.dragOverlayElement.getStyle();
		// startClientY = WidgetUtil.getTouchOrMouseClientY(event);
		// style.setHeight(startHeight, Unit.PX);
		// startClientX = WidgetUtil.getTouchOrMouseClientX(event);
		// style.setWidth(startWidth, Unit.PX);
		//
		// if (target.equals(wrapper.topLeftCorner) ||
		// target.equals(wrapper.topRightCorner)) {
		// revertY = true;
		// style.setBottom(0, Unit.PX);
		// resizeLocation = target.equals(wrapper.topLeftCorner) ?
		// CResizeLocation.TOP_LEFT
		// : CResizeLocation.TOP_RIGHT;
		// } else {
		// revertY = false;
		// style.setTop(0, Unit.PX);
		// resizeLocation = target.equals(wrapper.bottomRightCorner) ?
		// CResizeLocation.BOTTOM_RIGHT
		// : CResizeLocation.BOTTOM_LEFT;
		// }
		// if (target.equals(wrapper.topLeftCorner) ||
		// target.equals(wrapper.bottomLeftCorner)) {
		// revertX = true;
		// style.setRight(0, Unit.PX);
		// } else {
		// revertX = false;
		// style.setLeft(0, Unit.PX);
		// }
		// return resizeLocation;
		// }

		/**
		 * Start vertical resize.
		 *
		 * @param event the event
		 * @param target the target
		 * @return the o resize location
		 */
		protected OResizeLocation startVerticalResize(Event event, Element target) {
			OResizeLocation resizeLocation;
			resizingY = true;
			Style style = wrapper.dragOverlayElement.getStyle();
			startClientY = WidgetUtil.getTouchOrMouseClientY(event);
			style.setHeight(startHeight, Unit.PX);

			if (target.equals(wrapper.topEdge)) {
				revertY = true;
				style.setBottom(0, Unit.PX);
				resizeLocation = OResizeLocation.TOP;
			} else {
				revertY = false;
				style.setTop(0, Unit.PX);
				resizeLocation = OResizeLocation.BOTTOM;
			}
			style.setLeft(0, Unit.PX);
			style.setRight(0, Unit.PX);
			return resizeLocation;
		}

		/**
		 * Start horizontal resize.
		 *
		 * @param event the event
		 * @param target the target
		 * @return the o resize location
		 */
		protected OResizeLocation startHorizontalResize(Event event, Element target) {
			OResizeLocation resizeLocation;
			resizingX = true;
			Style style = wrapper.dragOverlayElement.getStyle();
			startClientX = WidgetUtil.getTouchOrMouseClientX(event);
			style.setWidth(startWidth, Unit.PX);

			if (target.equals(wrapper.leftEdge)) {
				revertX = true;
				style.setRight(0, Unit.PX);
				resizeLocation = OResizeLocation.LEFT;
			} else {
				revertX = false;
				style.setLeft(0, Unit.PX);
				resizeLocation = OResizeLocation.RIGHT;
			}
			style.setTop(0, Unit.PX);
			style.setBottom(0, Unit.PX);
			return resizeLocation;
		}

	}

	/**
	 * The Class ResizableAbsoluteWrapper.
	 */
	public class ResizableAbsoluteWrapper extends AbsoluteWrapper {

		/** The Constant O_RESIZABLE_STYLE_NAME. */
		protected static final String O_RESIZABLE_STYLE_NAME = "o-resizable";

		/** The Constant DEFAULT_DRAG_SIZE_PIXELS. */
		protected static final int DEFAULT_DRAG_SIZE_PIXELS = 10;

		// protected Element topLeftCorner;
		// protected Element topRightCorner;
		// protected Element bottomLeftCorner;
		/** The top edge. */
		// protected Element bottomRightCorner;
		protected Element topEdge;
		
		/** The right edge. */
		protected Element rightEdge;
		
		/** The bottom edge. */
		protected Element bottomEdge;
		
		/** The left edge. */
		protected Element leftEdge;
		
		/** The drag overlay element. */
		protected Element dragOverlayElement;

		/** The drag size pixels. */
		protected int dragSizePixels;

		/** The resizable. */
		protected boolean resizable;
		
		/** The resize handler. */
		protected ResizeHandler resizeHandler;

		/**
		 * Instantiates a new resizable absolute wrapper.
		 *
		 * @param child the child
		 */
		public ResizableAbsoluteWrapper(Widget child) {
			super(child);

			resizeHandler = new ResizeHandler(this);

			child.addStyleName(O_RESIZABLE_STYLE_NAME);
			// getElement().addClassName("resizable");

			initDOM();
			initListeners();
			setResizeLocationSize(DEFAULT_DRAG_SIZE_PIXELS);
		}

		/**
		 * Notify resized.
		 *
		 * @param width the width
		 * @param height the height
		 * @param oldWidth the old width
		 * @param oldHeight the old height
		 * @param location the location
		 */
		public void notifyResized(int width, int height, int oldWidth, int oldHeight, OResizeLocation location) {
			ComponentConnector c = Util.findConnectorFor(getWidget());
			resizeListener.resized(c, width, height, oldWidth, oldHeight, location);
			OAlignmentManager.get().resetAlignments();
		}

		/**
		 * Notify resizing.
		 *
		 * @param width the width
		 * @param height the height
		 * @param oldWidth the old width
		 * @param oldHeight the old height
		 * @param location the location
		 * @param draggedElement the dragged element
		 * @param dragOverlayElement the drag overlay element
		 */
		public void notifyResizing(int width, int height, int oldWidth, int oldHeight, OResizeLocation location,
				Element draggedElement, Element dragOverlayElement) {
			OAlignmentManager.get().updateAlignmentsForResize(draggedElement, dragOverlayElement);
		}

		/**
		 * Notify resizing cancel.
		 */
		public void notifyResizingCancel() {
			OAlignmentManager.get().resetAlignments();
		}

		/**
		 * Inits the dom.
		 */
		protected void initDOM() {
			// topLeftCorner = DOM.createDiv();
			// topLeftCorner.addClassName("tlc");
			// topLeftCorner.addClassName(ICConstants.RESIZE_DIV);
			// topRightCorner = DOM.createDiv();
			// topRightCorner.addClassName("trc");
			// topRightCorner.addClassName(ICConstants.RESIZE_DIV);
			// bottomLeftCorner = DOM.createDiv();
			// bottomLeftCorner.addClassName("blc");
			// bottomLeftCorner.addClassName(ICConstants.RESIZE_DIV);
			// bottomRightCorner = DOM.createDiv();
			// bottomRightCorner.addClassName("brc");
			// bottomRightCorner.addClassName(ICConstants.RESIZE_DIV);

			topEdge = DOM.createDiv();
			topEdge.addClassName("te");
			topEdge.addClassName(IOConstants.CSS_RESIZE_DIV);
			rightEdge = DOM.createDiv();
			rightEdge.addClassName("re");
			rightEdge.addClassName(IOConstants.CSS_RESIZE_DIV);
			bottomEdge = DOM.createDiv();
			bottomEdge.addClassName("be");
			bottomEdge.addClassName(IOConstants.CSS_RESIZE_DIV);
			leftEdge = DOM.createDiv();
			leftEdge.addClassName("le");
			leftEdge.addClassName(IOConstants.CSS_RESIZE_DIV);

			dragOverlayElement = DOM.createDiv();
			dragOverlayElement.addClassName("drag-overlay");

			// topEdge.appendChild(topLeftCorner);
			// topEdge.appendChild(topRightCorner);

			// bottomEdge.appendChild(bottomLeftCorner);
			// bottomEdge.appendChild(bottomRightCorner);

			setResizable(true);
		}

		/**
		 * Inits the listeners.
		 */
		protected void initListeners() {
			// Event.sinkEvents(topLeftCorner, Event.MOUSEEVENTS);
			// Event.sinkEvents(topRightCorner, Event.MOUSEEVENTS);
			// Event.sinkEvents(bottomLeftCorner, Event.MOUSEEVENTS);
			// Event.sinkEvents(bottomRightCorner, Event.MOUSEEVENTS);
			Event.sinkEvents(topEdge, Event.MOUSEEVENTS);
			Event.sinkEvents(rightEdge, Event.MOUSEEVENTS);
			Event.sinkEvents(bottomEdge, Event.MOUSEEVENTS);
			Event.sinkEvents(leftEdge, Event.MOUSEEVENTS);
		}

		/**
		 * Set the size of the resize locations in pixels. This will be the
		 * width&amp;height for the corner locations, width for the left&amp;right
		 * sides, and height for the top&amp;bottom sides.
		 * <p>
		 * Default size is {@value #DEFAULT_DRAG_SIZE_PIXELS}.
		 *
		 * @param resizeLocationSize the new resize location size
		 */
		public void setResizeLocationSize(int resizeLocationSize) {
			if (dragSizePixels != resizeLocationSize) {
				dragSizePixels = resizeLocationSize;
				// topLeftCorner.getStyle().setHeight(resizeLocationSize,
				// Unit.PX);
				// topLeftCorner.getStyle().setWidth(resizeLocationSize,
				// Unit.PX);
				// topRightCorner.getStyle().setHeight(resizeLocationSize,
				// Unit.PX);
				// topRightCorner.getStyle().setWidth(resizeLocationSize,
				// Unit.PX);
				// bottomLeftCorner.getStyle().setHeight(resizeLocationSize,
				// Unit.PX);
				// bottomLeftCorner.getStyle().setWidth(resizeLocationSize,
				// Unit.PX);
				// bottomRightCorner.getStyle().setHeight(resizeLocationSize,
				// Unit.PX);
				// bottomRightCorner.getStyle().setWidth(resizeLocationSize,
				// Unit.PX);

				topEdge.getStyle().setHeight(resizeLocationSize, Unit.PX);
				rightEdge.getStyle().setWidth(resizeLocationSize, Unit.PX);
				bottomEdge.getStyle().setHeight(resizeLocationSize, Unit.PX);
				leftEdge.getStyle().setWidth(resizeLocationSize, Unit.PX);

				int negativeMargin = new BigDecimal(resizeLocationSize).divideToIntegralValue(new BigDecimal(2))
						.negate().intValueExact();
				// topLeftCorner.getStyle().setMarginLeft(negativeMargin,
				// Unit.PX);
				// topRightCorner.getStyle().setMarginRight(negativeMargin,
				// Unit.PX);
				// bottomRightCorner.getStyle().setMarginRight(negativeMargin,
				// Unit.PX);
				// bottomLeftCorner.getStyle().setMarginLeft(negativeMargin,
				// Unit.PX);
				topEdge.getStyle().setMarginTop(negativeMargin, Unit.PX);
				rightEdge.getStyle().setMarginRight(negativeMargin, Unit.PX);
				bottomEdge.getStyle().setMarginBottom(negativeMargin, Unit.PX);
				leftEdge.getStyle().setMarginLeft(negativeMargin, Unit.PX);
			}
		}

		/**
		 * Trigger the resizable mode for the component.
		 *
		 * @param resizable the new resizable
		 */
		public void setResizable(boolean resizable) {
			if (this.resizable != resizable) {
				this.resizable = resizable;
				if (resizable) {
					enableResize(topEdge);
					enableResize(leftEdge);
					enableResize(rightEdge);
					enableResize(bottomEdge);
					getElement().addClassName(O_RESIZABLE_STYLE_NAME);
				} else {
					disableResize(topEdge);
					disableResize(leftEdge);
					disableResize(rightEdge);
					disableResize(bottomEdge);
					getElement().removeClassName(O_RESIZABLE_STYLE_NAME);
				}
			}
		}

		/**
		 * Enable resize.
		 *
		 * @param element the element
		 */
		protected void enableResize(Element element) {
			getElement().appendChild(element);
			Event.setEventListener(element, resizeHandler);
		}

		/**
		 * Disable resize.
		 *
		 * @param element the element
		 */
		protected void disableResize(Element element) {
			getElement().removeChild(element);
			Event.setEventListener(element, null);
		}

		/**
		 * Is the component in resizable mode.
		 *
		 * @return the resizable
		 */
		public boolean getResizable() {
			return resizable;
		}

		/* (non-Javadoc)
		 * @see com.vaadin.client.ui.VAbsoluteLayout.AbsoluteWrapper#setWrapperStyleNames(java.lang.String[])
		 */
		public void setWrapperStyleNames(String... stylenames) {
			List<String> styles = stylenames != null ? new ArrayList<String>(Arrays.asList(stylenames)) : new ArrayList<String>();
			styles.add(O_RESIZABLE_STYLE_NAME);
			super.setWrapperStyleNames(styles.toArray(new String[styles.size()]));
		}

		/* (non-Javadoc)
		 * @see com.vaadin.client.ui.VAbsoluteLayout.AbsoluteWrapper#destroy()
		 */
		public void destroy() {
			setResizable(false);

			super.destroy();
		}
	}
}