Author: ayukhovich Date: 2007-08-14 09:12:54 -0400 (Tue, 14 Aug 2007) New Revision: 3117 Added: branches/jbosstools_xulrunner/vpe/plugins/org.jboss.tools.vpe.xulrunner/src/org/jboss/tools/vpe/xulrunner/editor/DOMElementUtils.java branches/jbosstools_xulrunner/vpe/plugins/org.jboss.tools.vpe.xulrunner/src/org/jboss/tools/vpe/xulrunner/editor/ElementPositionAndDimention.java branches/jbosstools_xulrunner/vpe/plugins/org.jboss.tools.vpe.xulrunner/src/org/jboss/tools/vpe/xulrunner/editor/IVpeResizeListener.java branches/jbosstools_xulrunner/vpe/plugins/org.jboss.tools.vpe.xulrunner/src/org/jboss/tools/vpe/xulrunner/editor/IVpeResizer.java branches/jbosstools_xulrunner/vpe/plugins/org.jboss.tools.vpe.xulrunner/src/org/jboss/tools/vpe/xulrunner/editor/VpeResizer.java branches/jbosstools_xulrunner/vpe/plugins/org.jboss.tools.vpe.xulrunner/src/org/jboss/tools/vpe/xulrunner/editor/VpeResizerMouseListener.java branches/jbosstools_xulrunner/vpe/plugins/org.jboss.tools.vpe.xulrunner/src/org/jboss/tools/vpe/xulrunner/editor/VpeResizerMouseMotionListener.java branches/jbosstools_xulrunner/vpe/plugins/org.jboss.tools.vpe.xulrunner/src/org/jboss/tools/vpe/xulrunner/editor/XulRunnerConstants.java Log: http://jira.jboss.com/jira/browse/EXIN-436 Add initial classes from protptype Added: branches/jbosstools_xulrunner/vpe/plugins/org.jboss.tools.vpe.xulrunner/src/org/jboss/tools/vpe/xulrunner/editor/DOMElementUtils.java =================================================================== --- branches/jbosstools_xulrunner/vpe/plugins/org.jboss.tools.vpe.xulrunner/src/org/jboss/tools/vpe/xulrunner/editor/DOMElementUtils.java (rev 0) +++ branches/jbosstools_xulrunner/vpe/plugins/org.jboss.tools.vpe.xulrunner/src/org/jboss/tools/vpe/xulrunner/editor/DOMElementUtils.java 2007-08-14 13:12:54 UTC (rev 3117) @@ -0,0 +1,29 @@ +package org.jboss.tools.vpe.xulrunner.editor; + +import org.mozilla.interfaces.nsIDOMElement; +import org.mozilla.interfaces.nsIDOMNSHTMLElement; + +/** + * @author A. Yukhovich + */ +public class DOMElementUtils { + + /** + * @param domElement + * @return + */ + static public ElementPositionAndDimention getElementPositionAndDimention(nsIDOMElement domElement) { + ElementPositionAndDimention elementPositionAndDimention = new ElementPositionAndDimention(); + + nsIDOMNSHTMLElement nsElement = (nsIDOMNSHTMLElement) domElement.queryInterface(nsIDOMNSHTMLElement.NS_IDOMNSHTMLELEMENT_IID); + + if (nsElement != null) { + elementPositionAndDimention.setWidth(nsElement.getOffsetWidth()); + elementPositionAndDimention.setHeight(nsElement.getOffsetHeight()); + elementPositionAndDimention.setTop(nsElement.getOffsetTop()); + elementPositionAndDimention.setLeft(nsElement.getOffsetLeft()); + } + + return elementPositionAndDimention; + } +} Added: branches/jbosstools_xulrunner/vpe/plugins/org.jboss.tools.vpe.xulrunner/src/org/jboss/tools/vpe/xulrunner/editor/ElementPositionAndDimention.java =================================================================== --- branches/jbosstools_xulrunner/vpe/plugins/org.jboss.tools.vpe.xulrunner/src/org/jboss/tools/vpe/xulrunner/editor/ElementPositionAndDimention.java (rev 0) +++ branches/jbosstools_xulrunner/vpe/plugins/org.jboss.tools.vpe.xulrunner/src/org/jboss/tools/vpe/xulrunner/editor/ElementPositionAndDimention.java 2007-08-14 13:12:54 UTC (rev 3117) @@ -0,0 +1,116 @@ +package org.jboss.tools.vpe.xulrunner.editor; + +/** + * @author A. Yukhovich + * + */ +public class ElementPositionAndDimention { + private int top; + private int left; + private int height; + private int width; + + private int borderLeft; + private int borderTop; + private int marginTop; + private int marginLeft; + + /** + * @return the top + */ + public int getTop() { + return top; + } + /** + * @param top the top to set + */ + public void setTop(int top) { + this.top = top; + } + /** + * @return the left + */ + public int getLeft() { + return left; + } + /** + * @param left the left to set + */ + public void setLeft(int left) { + this.left = left; + } + /** + * @return the height + */ + public int getHeight() { + return height; + } + /** + * @param height the height to set + */ + public void setHeight(int height) { + this.height = height; + } + /** + * @return the width + */ + public int getWidth() { + return width; + } + /** + * @param width the width to set + */ + public void setWidth(int width) { + this.width = width; + } + /** + * @return the borderLeft + */ + public int getBorderLeft() { + return borderLeft; + } + /** + * @param borderLeft the borderLeft to set + */ + public void setBorderLeft(int borderLeft) { + this.borderLeft = borderLeft; + } + /** + * @return the borderTop + */ + public int getBorderTop() { + return borderTop; + } + /** + * @param borderTop the borderTop to set + */ + public void setBorderTop(int borderTop) { + this.borderTop = borderTop; + } + /** + * @return the marginTop + */ + public int getMarginTop() { + return marginTop; + } + /** + * @param marginTop the marginTop to set + */ + public void setMarginTop(int marginTop) { + this.marginTop = marginTop; + } + /** + * @return the marginLeft + */ + public int getMarginLeft() { + return marginLeft; + } + /** + * @param marginLeft the marginLeft to set + */ + public void setMarginLeft(int marginLeft) { + this.marginLeft = marginLeft; + } + +} + Added: branches/jbosstools_xulrunner/vpe/plugins/org.jboss.tools.vpe.xulrunner/src/org/jboss/tools/vpe/xulrunner/editor/IVpeResizeListener.java =================================================================== --- branches/jbosstools_xulrunner/vpe/plugins/org.jboss.tools.vpe.xulrunner/src/org/jboss/tools/vpe/xulrunner/editor/IVpeResizeListener.java (rev 0) +++ branches/jbosstools_xulrunner/vpe/plugins/org.jboss.tools.vpe.xulrunner/src/org/jboss/tools/vpe/xulrunner/editor/IVpeResizeListener.java 2007-08-14 13:12:54 UTC (rev 3117) @@ -0,0 +1,21 @@ +package org.jboss.tools.vpe.xulrunner.editor; + +import org.mozilla.interfaces.nsIDOMElement; +import org.mozilla.interfaces.nsISupports; + +/** + * a IVpeResizeListener interface + * @author A. Yukhovich + */ +public interface IVpeResizeListener extends nsISupports { + /** + * Event handler for 'object end resizing' + * @param usedResizeMarkerHandle a used resize marker handle + * @param top a new top position + * @param left a new left position + * @param width a new width + * @param height a new height + * @param resizedDomElement a resized nsIDOMElement + */ + public void onEndResizing(int usedResizeMarkerHandle, int top, int left, int width, int height, nsIDOMElement resizedDomElement); +} Added: branches/jbosstools_xulrunner/vpe/plugins/org.jboss.tools.vpe.xulrunner/src/org/jboss/tools/vpe/xulrunner/editor/IVpeResizer.java =================================================================== --- branches/jbosstools_xulrunner/vpe/plugins/org.jboss.tools.vpe.xulrunner/src/org/jboss/tools/vpe/xulrunner/editor/IVpeResizer.java (rev 0) +++ branches/jbosstools_xulrunner/vpe/plugins/org.jboss.tools.vpe.xulrunner/src/org/jboss/tools/vpe/xulrunner/editor/IVpeResizer.java 2007-08-14 13:12:54 UTC (rev 3117) @@ -0,0 +1,84 @@ +package org.jboss.tools.vpe.xulrunner.editor; + +import org.mozilla.interfaces.nsIDOMDocument; +import org.mozilla.interfaces.nsIDOMElement; +import org.mozilla.interfaces.nsIDOMEvent; + +/** + * IVpeResize interface class + * @author A. Yukhovich + */ +public interface IVpeResizer { + /** RESIZER_MARKER_TOPLEFT */ + final static public int RESIZER_MARKER_TOPLEFT = 1; + + /** RESIZER_MARKER_TOP */ + final static public int RESIZER_MARKER_TOP = 2; + + /** RESIZER_MARKER_TOPRIGHT */ + final static public int RESIZER_MARKER_TOPRIGHT = 4; + + /** RESIZER_MARKER_LEFT */ + final static public int RESIZER_MARKER_LEFT = 8; + + /** RESIZER_MARKER_RIGHT */ + final static public int RESIZER_MARKER_RIGHT = 16; + + /** RESIZER_MARKER_BOTTOMLEFT */ + final static public int RESIZER_MARKER_BOTTOMLEFT = 32; + + /** RESIZER_MARKER_BOTTOM */ + final static public int RESIZER_MARKER_BOTTOM = 64; + + /** RESIZER_MARKER_BOTTOMRIGHT */ + final static public int RESIZER_MARKER_BOTTOMRIGHT = 128; + + + public void init(nsIDOMDocument domDocument); + + /** + * Show resize markers + * @param domElement + * @param resizers + */ + public void show(nsIDOMElement domElement, int resizers); + + /** + * Hide resize markers + */ + public void hide(); + + /** + * Event handler MouseDown + * @param clientX + * @param clientY + * @param domElement a target nsIDOMElement + */ + public void mouseDown(int clientX, int clientY, nsIDOMElement domElement); + + /** + * Event handler MouseMove + * @param event + */ + public void mouseMove(nsIDOMEvent event); + + /** + * Event handler MouseUp + * @param clientX + * @param clientY + * @param target a target nsIDOMElement + */ + public void mouseUp(int clientX, int clientY, nsIDOMElement target); + + /** + * add resize listener to queue + * @param aListener a IVpeResizeListener object + */ + public void addResizeListener(IVpeResizeListener aListener); + + /** + * remove resize listener from queue + * @param aListener a IVpeResizeListener object + */ + public void removeResizeListener(IVpeResizeListener aListener); +} Added: branches/jbosstools_xulrunner/vpe/plugins/org.jboss.tools.vpe.xulrunner/src/org/jboss/tools/vpe/xulrunner/editor/VpeResizer.java =================================================================== --- branches/jbosstools_xulrunner/vpe/plugins/org.jboss.tools.vpe.xulrunner/src/org/jboss/tools/vpe/xulrunner/editor/VpeResizer.java (rev 0) +++ branches/jbosstools_xulrunner/vpe/plugins/org.jboss.tools.vpe.xulrunner/src/org/jboss/tools/vpe/xulrunner/editor/VpeResizer.java 2007-08-14 13:12:54 UTC (rev 3117) @@ -0,0 +1,790 @@ +package org.jboss.tools.vpe.xulrunner.editor; + +import java.util.ArrayList; + +import org.mozilla.interfaces.nsIDOMCSSStyleDeclaration; +import org.mozilla.interfaces.nsIDOMDocument; +import org.mozilla.interfaces.nsIDOMElement; +import org.mozilla.interfaces.nsIDOMElementCSSInlineStyle; +import org.mozilla.interfaces.nsIDOMEvent; +import org.mozilla.interfaces.nsIDOMEventListener; +import org.mozilla.interfaces.nsIDOMEventTarget; +import org.mozilla.interfaces.nsIDOMHTMLDocument; +import org.mozilla.interfaces.nsIDOMHTMLElement; +import org.mozilla.interfaces.nsIDOMMouseEvent; +import org.mozilla.interfaces.nsIDOMNode; + +/** + * IVPEResizer implementation + * @author A. Yukhovich + */ +public class VpeResizer implements IVpeResizer { + /** COEFFICIENT_TYPE */ + enum COEFFICIENT_TYPE { X, Y, WIDTH, HEIGHT }; + + + /** RESIZER_MARKER_STRING_TOPLEFT */ + final static private String RESIZER_MARKER_STRING_TOPLEFT = "nw"; + + /** RESIZER_MARKER_STRING_TOP */ + final static private String RESIZER_MARKER_STRING_TOP = "n"; + + /** RESIZER_MARKER_STRING_TOPRIGHT */ + final static private String RESIZER_MARKER_STRING_TOPRIGHT = "ne"; + + /** RESIZER_MARKER_STRING_LEFT */ + final static private String RESIZER_MARKER_STRING_LEFT = "w"; + + /** RESIZER_MARKER_STRING_BOTTOMLEFT */ + final static private String RESIZER_MARKER_STRING_RIGHT = "e"; + + /** RESIZER_MARKER_STRING_BOTTOMLEFT */ + final static private String RESIZER_MARKER_STRING_BOTTOMLEFT = "sw"; + + /** RESIZER_MARKER_STRING_BOTTOM */ + final static private String RESIZER_MARKER_STRING_BOTTOM = "s"; + + /** RESIZER_MARKER_STRING_BOTTOMRIGHT */ + final static private String RESIZER_MARKER_STRING_BOTTOMRIGHT = "se"; + + /** MAX_SIZE */ + final static private int MAX_SIZE = 20000000; + + + nsIDOMEventListener mouseListener; + nsIDOMEventListener mouseMotionListener; + + + private ArrayList<IVpeResizeListener> objectResizeEventListeners = new ArrayList<IVpeResizeListener>(); + + private boolean isResizing; + private int originalX; + private int originalY; + + private int usedEResizeMarkerHandle; + + private int incrementFactorX; + private int incrementFactorY; + private int incrementFactorWidth; + private int incrementFactorHeight; + + + /** resizingObject */ + private nsIDOMElement resizingObject; + + /** resizingShadow */ + private nsIDOMElement resizingShadow; + + /** domDocument */ + private nsIDOMDocument domDocument; + + private nsIDOMElement activeHandle; + + private ElementPositionAndDimention elementPositionAndDimention; + + /** resizer marker top-left */ + private nsIDOMElement markerTopLeft = null; + + /** resizer marker top */ + private nsIDOMElement markerTop = null; + + /** resizer marker top-right */ + private nsIDOMElement markerTopRight = null; + + /** resizer marker left */ + private nsIDOMElement markerLeft = null; + + /** resizer marker right */ + private nsIDOMElement markerRight = null; + + /** resizer marker bottom */ + private nsIDOMElement markerBottom = null; + + /** resizer marker bottom-left */ + private nsIDOMElement markerBottomLeft = null; + + /** resizer marker bottom-right */ + private nsIDOMElement markerBottomRight = null; + + + /** + * + * @param domDocument + */ + public void init(nsIDOMDocument domDocument) + { + + this.domDocument = domDocument; + + mouseListener = new VpeResizerMouseListener(this); + } + + /* + * (non-Javadoc) + * + * @see org.jboss.vpe.mozilla.resizer.IVpeResizer#show(org.mozilla.interfaces.nsIDOMElement, + * int) + */ + public void show(nsIDOMElement domElement, int resizers) { + resizingObject = domElement; + + elementPositionAndDimention = DOMElementUtils.getElementPositionAndDimention(domElement); + + if ((elementPositionAndDimention.getWidth() <= 0) || + (elementPositionAndDimention.getWidth() > MAX_SIZE) || + (elementPositionAndDimention.getHeight() <= 0) || + (elementPositionAndDimention.getHeight() > MAX_SIZE)) return; + + nsIDOMElement bodyElement = getRootElement(); + + if (bodyElement == null ) return; + + if ((resizers & RESIZER_MARKER_TOPLEFT) == RESIZER_MARKER_TOPLEFT) { + markerTopLeft = createResizer( RESIZER_MARKER_STRING_TOPLEFT, bodyElement); + if (markerTopLeft == null) { + return ; + } + } + + if ((resizers & RESIZER_MARKER_TOP) == RESIZER_MARKER_TOP) { + markerTop = createResizer( RESIZER_MARKER_STRING_TOP, bodyElement); + if (markerTop == null) { + return ; + } + } + + if ((resizers & RESIZER_MARKER_TOPRIGHT) == RESIZER_MARKER_TOPRIGHT) { + markerTopRight = createResizer(RESIZER_MARKER_STRING_TOPRIGHT, bodyElement); + if (markerTopRight == null) { + return ; + } + } + + if ((resizers & RESIZER_MARKER_LEFT) == RESIZER_MARKER_LEFT) { + markerLeft = createResizer(RESIZER_MARKER_STRING_LEFT, bodyElement); + if (markerLeft == null) { + return ; + } + } + + if ((resizers & RESIZER_MARKER_RIGHT) == RESIZER_MARKER_RIGHT) { + markerRight = createResizer(RESIZER_MARKER_STRING_RIGHT, bodyElement); + if (markerRight == null) { + return ; + } + } + + if ((resizers & RESIZER_MARKER_BOTTOMLEFT) == RESIZER_MARKER_BOTTOMLEFT) { + markerBottomLeft = createResizer(RESIZER_MARKER_STRING_BOTTOMLEFT, bodyElement); + if (markerBottomLeft == null) { + return ; + } + } + + if ((resizers & RESIZER_MARKER_BOTTOM) == RESIZER_MARKER_BOTTOM) { + markerBottom = createResizer(RESIZER_MARKER_STRING_BOTTOM, bodyElement); + if (markerBottom == null) { + return ; + } + } + + if ((resizers & RESIZER_MARKER_BOTTOMRIGHT) == RESIZER_MARKER_BOTTOMRIGHT) { + markerBottomRight = createResizer(RESIZER_MARKER_STRING_BOTTOMRIGHT, bodyElement); + if (markerBottomRight == null) { + return ; + } + } + + setAllResizersPosition(); + + resizingShadow = createShadow(bodyElement, resizingObject); + + setShadowPosition(resizingShadow, elementPositionAndDimention.getLeft(), elementPositionAndDimention.getTop()); + } + + + /* (non-Javadoc) + * @see org.jboss.vpe.mozilla.resizer.IVpeResizer#hide() + */ + public void hide() + { + nsIDOMElement bodyElement; + + bodyElement = getRootElement(); + if ( bodyElement == null ) { + return; + } + + nsIDOMNode parentNode = (nsIDOMNode) bodyElement.queryInterface(nsIDOMNode.NS_IDOMNODE_IID); + + if ( parentNode == null) { + return; + } + + if ( markerTopLeft != null) { + parentNode.removeChild(markerTopLeft); + } + + if ( markerTop != null) { + parentNode.removeChild(markerTop); + } + + + if ( markerTopRight != null) { + parentNode.removeChild(markerTopRight); + } + + if ( markerLeft != null) { + parentNode.removeChild(markerLeft); + } + + if ( markerRight != null) { + parentNode.removeChild(markerRight); + } + + if ( markerBottomLeft != null) { + parentNode.removeChild(markerBottomLeft); + } + + if ( markerBottom != null) { + parentNode.removeChild(markerBottom); + } + + if ( markerBottomRight != null) { + parentNode.removeChild(markerBottomRight); + } + + + if ( resizingShadow != null ) { + parentNode.removeChild(resizingShadow); + } + + markerBottom = null; + markerTop = null; + markerLeft = null; + markerRight = null; + markerBottomRight = null; + markerBottomLeft = null; + markerTopRight = null; + markerTopLeft = null; + + resizingShadow = null; + resizingObject = null; + } + + + /* (non-Javadoc) + * @see org.jboss.vpe.mozilla.resizer.IVpeResizer#mouseDown(int, int, org.mozilla.interfaces.nsIDOMElement) + */ + public void mouseDown(int clientX, int clientY, nsIDOMElement domElement) { + + + if ( domElement != null ) { + + boolean isAnonElement = domElement.hasAttribute(XulRunnerConstants.STRING_MOZ_ANONCLASS); + + if (isAnonElement) { + String anonclass = domElement.getAttribute(XulRunnerConstants.STRING_MOZ_ANONCLASS); + + if ( anonclass != null ) { + if ( anonclass.equals(XulRunnerConstants.VPE_CLASSNAME_MOZ_RESIZER) ) { + originalX = clientX; + originalY = clientY; + startResizing(domElement); + } // if + } // if + } // if + } // if + } + + + /* (non-Javadoc) + * @see org.jboss.vpe.mozilla.resizer.IVpeResizer#mouseMove(org.mozilla.interfaces.nsIDOMEvent) + */ + public void mouseMove(nsIDOMEvent event) { + if (isResizing) { + nsIDOMMouseEvent mouseEvent = (nsIDOMMouseEvent)event.queryInterface(nsIDOMMouseEvent.NS_IDOMMOUSEEVENT_IID); + int clientX, clientY; + + clientX = mouseEvent.getClientX(); + clientY = mouseEvent.getClientY(); + + int newX = getNewResizingX(clientX, clientY); + int newY = getNewResizingY(clientX, clientY); + int newWidth = getNewResizingWidth(clientX, clientY); + int newHeight = getNewResizingHeight(clientX, clientY); + + setStylePropertyPixels(resizingShadow, XulRunnerConstants.HTML_ATTR_LEFT, newX); + setStylePropertyPixels(resizingShadow, XulRunnerConstants.HTML_ATTR_TOP, newY); + setStylePropertyPixels(resizingShadow, XulRunnerConstants.HTML_ATTR_WIDTH, newWidth); + setStylePropertyPixels(resizingShadow, XulRunnerConstants.HTML_ATTR_HEIGHT, newHeight); + } // if + } + + + /* (non-Javadoc) + * @see org.jboss.vpe.mozilla.resizer.IVpeResizer#mouseUp(int, int, org.mozilla.interfaces.nsIDOMElement) + */ + public void mouseUp(int aX, int aY, nsIDOMElement target) { + if (isResizing) { + isResizing = false; + + + hideShadow(); + endResizing(aX, aY); + + nsIDOMEventTarget erP = getDOMEventTarget(); + + if (erP != null) { + erP.removeEventListener(XulRunnerConstants.EVENT_NAME_MOUSEMOVE, mouseMotionListener, true); + erP.removeEventListener(XulRunnerConstants.EVENT_NAME_MOUSEUP, mouseListener, true); + mouseMotionListener = null; + } + } + } + + + + /* (non-Javadoc) + * @see org.jboss.vpe.mozilla.resizer.IVpeResizer#addResizeListener(org.jboss.vpe.mozilla.resizer.IVpeResizeListener) + */ + public void addResizeListener(IVpeResizeListener listener) { + if ( (objectResizeEventListeners.size() != 0 ) && + ( objectResizeEventListeners.indexOf(listener) != -1)) { + return; + } + objectResizeEventListeners.add(listener); + } + + + /* (non-Javadoc) + * @see org.jboss.vpe.mozilla.resizer.IVpeResizer#removeResizeListener(org.jboss.vpe.mozilla.resizer.IVpeResizeListener) + */ + public void removeResizeListener(IVpeResizeListener listener) { + if ( (objectResizeEventListeners.size() == 0 ) || + ( objectResizeEventListeners.indexOf(listener) == -1)) { + return; + } + objectResizeEventListeners.remove(listener); + } + + /** + * Setting a position of shadow + * @param shadowElement + * @param aOriginalObjectX + * @param aOriginalObjectY + */ + private void setShadowPosition(nsIDOMElement shadowElement, int aOriginalObjectX, int aOriginalObjectY) + { + setAnonymousElementPosition(aOriginalObjectX, aOriginalObjectY, shadowElement); + } + + + /** + * create a anonymous dom-element + * + * @param aTag + * a tag of dom element + * @param aParentNode + * @param aAnonClass + * @param isCreatedHidden + * @return + */ + private nsIDOMElement createAnonymousElement(String aTag, nsIDOMNode aParentNode, String aAnonClass, boolean isCreatedHidden) { + nsIDOMElement returnElement = null; + + returnElement = domDocument.createElement(aTag); + + // add the "hidden" class if needed + if (isCreatedHidden) { + returnElement.setAttribute(XulRunnerConstants.HTML_ATTR_CLASS, XulRunnerConstants.HTML_VALUE_HIDDEN); + } + + // add an _moz_anonclass attribute if needed + if ( aAnonClass.length() != 0 ) { + returnElement.setAttribute(XulRunnerConstants.STRING_MOZ_ANONCLASS, aAnonClass); + } + + aParentNode.appendChild(returnElement); + + return returnElement; + } + + /** + * + * @param parentNode + * @param originalObject + * @return + */ + private nsIDOMElement createShadow(nsIDOMNode parentNode, nsIDOMElement originalObject) { + nsIDOMElement returnElement = null; + + returnElement = createAnonymousElement(XulRunnerConstants.HTML_TAG_SPAN, parentNode, XulRunnerConstants.VPE_CLASS_NAME_MOZ_RESIZING_SHADOW, true ); + + return returnElement; + } + + /** + * + * @param domElement + */ + private void startResizing(nsIDOMElement domElement) { + isResizing = true; + + activeHandle = domElement; + activeHandle.setAttribute(XulRunnerConstants.STRING_MOZ_ACTIVATED, XulRunnerConstants.HTML_VALUE_TRUE); + + + String locationStr = activeHandle.getAttribute(XulRunnerConstants.HTML_ATTR_ANONLOCATION); + + if (locationStr == null ) { + return; + } + + if (locationStr.equals(RESIZER_MARKER_STRING_TOPLEFT)) { + usedEResizeMarkerHandle = RESIZER_MARKER_TOPLEFT; + setResizeIncrements(1, 1, -1, -1, false); + } else if (locationStr.equals(RESIZER_MARKER_STRING_TOP)) { + usedEResizeMarkerHandle = RESIZER_MARKER_TOP; + setResizeIncrements(0, 1, 0, -1, false); + } else if (locationStr.equals(RESIZER_MARKER_STRING_TOPRIGHT)) { + usedEResizeMarkerHandle = RESIZER_MARKER_TOPRIGHT; + setResizeIncrements(0, 1, 1, -1, false); + } else if (locationStr.equals(RESIZER_MARKER_STRING_LEFT)) { + usedEResizeMarkerHandle = RESIZER_MARKER_LEFT; + setResizeIncrements(1, 0, -1, 0, false); + } else if (locationStr.equals(RESIZER_MARKER_STRING_RIGHT)) { + usedEResizeMarkerHandle = RESIZER_MARKER_RIGHT; + setResizeIncrements(0, 0, 1, 0, false); + } else if (locationStr.equals(RESIZER_MARKER_STRING_BOTTOMLEFT)) { + usedEResizeMarkerHandle = RESIZER_MARKER_BOTTOMLEFT; + setResizeIncrements(1, 0, -1, 1, false); + } else if (locationStr.equals(RESIZER_MARKER_STRING_BOTTOM)) { + usedEResizeMarkerHandle = RESIZER_MARKER_BOTTOM; + setResizeIncrements(0, 0, 0, 1, false); + } else if (locationStr.equals(RESIZER_MARKER_STRING_BOTTOMRIGHT)) { + usedEResizeMarkerHandle = RESIZER_MARKER_BOTTOMRIGHT; + setResizeIncrements(0, 0, 1, 1, false); + } + + // make the shadow appear + resizingShadow.removeAttribute(XulRunnerConstants.HTML_ATTR_CLASS); + + // position it + setShadowPosition(resizingShadow, elementPositionAndDimention.getLeft(), elementPositionAndDimention.getTop()); + + setStylePropertyPixels(resizingShadow, XulRunnerConstants.HTML_ATTR_WIDTH, elementPositionAndDimention.getWidth() ); + setStylePropertyPixels(resizingShadow, XulRunnerConstants.HTML_ATTR_HEIGHT, elementPositionAndDimention.getTop() ); + + + if (mouseMotionListener != null) { + return; + } + + mouseMotionListener = new VpeResizerMouseMotionListener(this); + if ( mouseMotionListener != null ) { + return; + } + + nsIDOMEventTarget eventTarget = getDOMEventTarget(); + + if ( eventTarget != null ) { + eventTarget.addEventListener(XulRunnerConstants.EVENT_NAME_MOUSEMOVE, mouseMotionListener, true); + eventTarget.addEventListener(XulRunnerConstants.EVENT_NAME_MOUSEUP, mouseListener, true); + } + + return; + } + + /** + * getting a nsIDOMEventTarget from nsIDOMDocument + * @return nsIDOMEventTarget from nsIDOMDocument + */ + private nsIDOMEventTarget getDOMEventTarget() { + + nsIDOMEventTarget eventTarget = (nsIDOMEventTarget) domDocument.queryInterface(nsIDOMEventTarget.NS_IDOMEVENTTARGET_IID); + if (eventTarget == null) { + throw new RuntimeException("nsIDOMEventTarget is null"); + } + + return eventTarget; + } + + + /** + * + * @param aX + * @param aY + * @return + */ + private int getNewResizingX(int aX, int aY) + { + int resized = elementPositionAndDimention.getLeft() + getNewResizingIncrement(aX, aY, COEFFICIENT_TYPE.X) * incrementFactorX; + int max = elementPositionAndDimention.getLeft() + elementPositionAndDimention.getWidth(); + return Math.min(resized, max); + } + + /** + * + * @param aX + * @param aY + * @return + */ + private int getNewResizingY(int aX, int aY) + { + int resized = elementPositionAndDimention.getTop() + getNewResizingIncrement(aX, aY, COEFFICIENT_TYPE.Y) * incrementFactorY; + int max = elementPositionAndDimention.getTop() + elementPositionAndDimention.getHeight(); + return Math.min(resized, max); + } + + /** + * + * @param aX + * @param aY + * @return + */ + private int getNewResizingWidth(int aX, int aY) + { + int resized = elementPositionAndDimention.getWidth() + getNewResizingIncrement(aX, aY, COEFFICIENT_TYPE.WIDTH) * incrementFactorWidth; + return Math.max(resized, 1); + } + + /** + * + * @param aX + * @param aY + * @return + */ + private int getNewResizingHeight(int aX, int aY) + { + int resized = elementPositionAndDimention.getHeight() + getNewResizingIncrement(aX, aY, COEFFICIENT_TYPE.HEIGHT) * incrementFactorHeight; + return Math.max(resized, 1); + } + + /** + * + * @param aX + * @param aY + * @param coefficient_type + * @return + */ + private int getNewResizingIncrement(int aX, int aY, COEFFICIENT_TYPE coefficient_type) + { + int result = 0; + + switch (coefficient_type) { + case X: + case WIDTH: + result = aX - originalX; + break; + case Y: + case HEIGHT: + result = aY - originalY; + break; + } + return result; + } + + + /** + * Get root element + * + * @return root element + */ + private nsIDOMElement getRootElement() { + + nsIDOMElement bodyElement = null; + + nsIDOMHTMLDocument htmlDocument = (nsIDOMHTMLDocument) domDocument.queryInterface(nsIDOMHTMLDocument.NS_IDOMHTMLDOCUMENT_IID); + + if ( htmlDocument != null ) { + nsIDOMHTMLElement htmlBody = htmlDocument.getBody(); + + if ( htmlBody != null ) { + bodyElement = (nsIDOMElement) htmlBody.queryInterface(nsIDOMElement.NS_IDOMELEMENT_IID); + } // if + } // if + + return bodyElement; + } + + /** + * Create a new resizer element + * @param resizerMarkerString + * @param parentNode + * @return a new resizer element + */ + private nsIDOMElement createResizer(String resizerMarkerString, nsIDOMNode parentNode) { + nsIDOMElement aNewResizer = createAnonymousElement(XulRunnerConstants.HTML_TAG_SPAN, parentNode, XulRunnerConstants.VPE_CLASSNAME_MOZ_RESIZER, false ); + + nsIDOMEventTarget evtTarget = (nsIDOMEventTarget) aNewResizer.queryInterface(nsIDOMEventTarget.NS_IDOMEVENTTARGET_IID); + + evtTarget.addEventListener(XulRunnerConstants.EVENT_NAME_MOUSEDOWN, mouseListener, true); + + aNewResizer.setAttribute(XulRunnerConstants.HTML_ATTR_ANONLOCATION, resizerMarkerString); + + return aNewResizer; + } + + + /** + * Set all positions of resizer's markers + */ + private void setAllResizersPosition() { + int left = elementPositionAndDimention.getLeft(); + int top = elementPositionAndDimention.getTop(); + int width = elementPositionAndDimention.getWidth(); + int height = elementPositionAndDimention.getHeight(); + + int resizerWidth = 5; + int resizerHeight = 5; + + int rw = (int)((resizerWidth + 1) / 2); + int rh = (int)((resizerHeight+ 1) / 2); + + if (markerTopLeft != null) { + setAnonymousElementPosition(left-resizerWidth-2, top-resizerHeight-2, markerTopLeft); + } + + if (markerTop != null) { + setAnonymousElementPosition(left+width/2-rw, top-resizerHeight-2, markerTop); + } + + if (markerTopRight != null) { + setAnonymousElementPosition(left+width, top-resizerHeight-2, markerTopRight); + } + + if (markerLeft != null) { + setAnonymousElementPosition(left-resizerWidth-2, top+height/2-rh, markerLeft); + } + + if (markerRight != null) { + setAnonymousElementPosition(left+width, top+height/2-rh, markerRight); + } + + if (markerBottomLeft != null) { + setAnonymousElementPosition(left-resizerWidth-2, top+height, markerBottomLeft); + } + + if (markerBottom != null) { + setAnonymousElementPosition(left+width/2-rw, top+height, markerBottom); + } + + if (markerBottomRight != null) { + setAnonymousElementPosition(left+width, top+height, markerBottomRight); + } + + } + + /** + * + * @param left + * @param top + * @param domElement + */ + private void setAnonymousElementPosition(int left, int top,nsIDOMElement domElement) { + setStylePropertyPixels(domElement,XulRunnerConstants.HTML_ATTR_LEFT, left); + setStylePropertyPixels(domElement,XulRunnerConstants.HTML_ATTR_TOP, top); + } + + /** + * + * @param aElement + * @param aProperty + * @param aValue + */ + private void setStylePropertyPixels(nsIDOMElement aElement, String aProperty, int aValue) { + setStyle(aElement, aProperty, aValue + "px"); + } + + /** + * + * @param aX + * @param aY + * @param aW + * @param aH + * @param aPreserveRatio + */ + private void setResizeIncrements(int aX, int aY, int aW, int aH, boolean aPreserveRatio) { + incrementFactorX = aX; + incrementFactorY = aY; + incrementFactorWidth = aW; + incrementFactorHeight = aH; + // mPreserveRatio = aPreserveRatio; + } + + + /** + * Set style for nsIDOMElement + * @param domElement + * @param cssPropertyName + * @param cssPropertyValue + */ + private void setStyle(nsIDOMElement domElement, String cssPropertyName, String cssPropertyValue) { + nsIDOMElementCSSInlineStyle inlineStyles = (nsIDOMElementCSSInlineStyle) domElement.queryInterface(nsIDOMElementCSSInlineStyle.NS_IDOMELEMENTCSSINLINESTYLE_IID); + + if ( inlineStyles == null) { + return; + } + + nsIDOMCSSStyleDeclaration cssDecl = inlineStyles.getStyle(); + + if ( cssDecl == null) { + return; + } + + if (cssPropertyValue.length() == 0 ) { + // an empty value means we have to remove the property + cssDecl.removeProperty(cssPropertyName); + } else { + // let's recreate the declaration as it was + String priority = cssDecl.getPropertyPriority(cssPropertyName); + cssDecl.setProperty(cssPropertyName, cssPropertyValue, priority); + } + } + + + /** + * + * @param aClientX + * @param aClientY + */ + private void endResizing(int aClientX, int aClientY) + { + if (resizingShadow == null) { + return; + } + + if( activeHandle != null) { + activeHandle.removeAttribute(XulRunnerConstants.STRING_MOZ_ACTIVATED); + activeHandle = null; + } + + int left = getNewResizingX(aClientX, aClientY); + int top = getNewResizingY(aClientX, aClientY); + int width = getNewResizingWidth(aClientX, aClientY); + int height = getNewResizingHeight(aClientX, aClientY); + + int listenersCount = objectResizeEventListeners.size(); + if (listenersCount != 0) { + IVpeResizeListener listener; + int index; + for (index = 0; index < listenersCount; index++) { + listener = objectResizeEventListeners.get(index); + listener.onEndResizing(usedEResizeMarkerHandle,top,left,width,height,resizingObject); + } + } + + usedEResizeMarkerHandle = 0; + } + + /** + * Hide of shadow box + */ + private void hideShadow() { + if (resizingShadow != null ) { + resizingShadow.setAttribute(XulRunnerConstants.HTML_ATTR_CLASS, XulRunnerConstants.HTML_VALUE_HIDDEN); + } + } + +} Added: branches/jbosstools_xulrunner/vpe/plugins/org.jboss.tools.vpe.xulrunner/src/org/jboss/tools/vpe/xulrunner/editor/VpeResizerMouseListener.java =================================================================== --- branches/jbosstools_xulrunner/vpe/plugins/org.jboss.tools.vpe.xulrunner/src/org/jboss/tools/vpe/xulrunner/editor/VpeResizerMouseListener.java (rev 0) +++ branches/jbosstools_xulrunner/vpe/plugins/org.jboss.tools.vpe.xulrunner/src/org/jboss/tools/vpe/xulrunner/editor/VpeResizerMouseListener.java 2007-08-14 13:12:54 UTC (rev 3117) @@ -0,0 +1,133 @@ +package org.jboss.tools.vpe.xulrunner.editor; + +import org.eclipse.core.runtime.Platform; +import org.mozilla.interfaces.nsIDOMElement; +import org.mozilla.interfaces.nsIDOMEvent; +import org.mozilla.interfaces.nsIDOMEventListener; +import org.mozilla.interfaces.nsIDOMEventTarget; +import org.mozilla.interfaces.nsIDOMMouseEvent; +import org.mozilla.interfaces.nsIDOMNSEvent; +import org.mozilla.interfaces.nsISupports; +import org.mozilla.xpcom.Mozilla; + +/** + * + * @author A. Yukhovich + */ +public class VpeResizerMouseListener implements nsIDOMEventListener { + + private IVpeResizer vpeResizer; + + /** + * Default contructor + */ + public VpeResizerMouseListener(IVpeResizer vpeResizer) { + super(); + this.vpeResizer = vpeResizer; + } + + /* + * (non-Javadoc) + * + * @see org.mozilla.interfaces.nsIDOMEventListener#handleEvent(org.mozilla.interfaces.nsIDOMEvent) + */ + public void handleEvent(nsIDOMEvent event) { + nsIDOMMouseEvent mouseEvent = (nsIDOMMouseEvent) event + .queryInterface(nsIDOMMouseEvent.NS_IDOMMOUSEEVENT_IID); + + if (mouseEvent == null) { + return; + } + + if (XulRunnerConstants.EVENT_NAME_MOUSEDOWN.equals(mouseEvent.getType())) { + mouseDown(mouseEvent); + } else if (XulRunnerConstants.EVENT_NAME_MOUSEUP.equals(mouseEvent.getType())) { + mouseUp(mouseEvent); + } else if (XulRunnerConstants.EVENT_NAME_MOUSEMOVE.equals(mouseEvent.getType())) { + mouseMove(mouseEvent); + } + } + + /* + * (non-Javadoc) + * + * @see org.mozilla.interfaces.nsISupports#queryInterface(java.lang.String) + */ + public nsISupports queryInterface(String aIID) { + if (aIID.equals(nsIDOMEventListener.NS_IDOMEVENTLISTENER_IID)) { + return this; + } // if + + return Mozilla.queryInterface(this, aIID); + } + + /** + * processing event of mouseDown + * + * @param mouseEvent + * a nsIDOMMouseEvent object + */ + private void mouseDown(nsIDOMMouseEvent mouseEvent) { + boolean isContextClick = false; + + if (Platform.getOS().equals("SunOS")) { + isContextClick = mouseEvent.getCtrlKey(); + } else { + isContextClick = (mouseEvent.getButton() == 2); + } + + if (!isContextClick && (mouseEvent.getButton() == 0) + && (mouseEvent.getDetail() == 1)) { + nsIDOMNSEvent internalEvent = (nsIDOMNSEvent) mouseEvent + .queryInterface(nsIDOMNSEvent.NS_IDOMNSEVENT_IID); + if (internalEvent != null) { + org.mozilla.interfaces.nsIDOMEventTarget eventTarget = internalEvent + .getExplicitOriginalTarget(); + if (eventTarget != null) { + nsIDOMElement domElement = (nsIDOMElement) eventTarget + .queryInterface(nsIDOMElement.NS_IDOMELEMENT_IID); + if (domElement != null) { + System.out.println("ELEMENT IS: " + domElement.getNodeName()); + int clientX = mouseEvent.getClientX(); + int clientY = mouseEvent.getClientY(); + + vpeResizer.mouseDown(clientX, clientY, domElement); + } else { + System.out.println("ELEMENT IS NULL "); + } + + } // if + } // if + + } + } + + /** + * processing event of mouseUp + * + * @param mouseEvent + * a nsIDOMMouseEvent object + */ + private void mouseUp(nsIDOMMouseEvent mouseEvent) { + nsIDOMEventTarget target = mouseEvent.getTarget(); + + if (target != null ) { + nsIDOMElement domElement = (nsIDOMElement) target.queryInterface(nsIDOMElement.NS_IDOMELEMENT_IID); + if (domElement != null) { + int clientX = mouseEvent.getClientX(); + int clientY = mouseEvent.getClientY(); + vpeResizer.mouseUp(clientX, clientY, domElement); + } + } + } + + /** + * processing event of mouseMove + * + * @param mouseEvent + * a nsIDOMMouseEvent object + */ + private void mouseMove(nsIDOMMouseEvent mouseEvent) { + vpeResizer.mouseMove(mouseEvent); + } +} Added: branches/jbosstools_xulrunner/vpe/plugins/org.jboss.tools.vpe.xulrunner/src/org/jboss/tools/vpe/xulrunner/editor/VpeResizerMouseMotionListener.java =================================================================== --- branches/jbosstools_xulrunner/vpe/plugins/org.jboss.tools.vpe.xulrunner/src/org/jboss/tools/vpe/xulrunner/editor/VpeResizerMouseMotionListener.java (rev 0) +++ branches/jbosstools_xulrunner/vpe/plugins/org.jboss.tools.vpe.xulrunner/src/org/jboss/tools/vpe/xulrunner/editor/VpeResizerMouseMotionListener.java 2007-08-14 13:12:54 UTC (rev 3117) @@ -0,0 +1,56 @@ +package org.jboss.tools.vpe.xulrunner.editor; + +import org.mozilla.interfaces.nsIDOMEvent; +import org.mozilla.interfaces.nsIDOMEventListener; +import org.mozilla.interfaces.nsIDOMMouseEvent; +import org.mozilla.interfaces.nsISupports; +import org.mozilla.xpcom.Mozilla; + +/** + * @author A. Yukhovich + */ +public class VpeResizerMouseMotionListener implements nsIDOMEventListener { + /** vpeRezizer */ + private IVpeResizer vpeResizer; + + /** + * Default constructor + * @param vpeResizer a IVpeResizer object + */ + public VpeResizerMouseMotionListener(IVpeResizer vpeResizer) { + this.vpeResizer = vpeResizer; + } + + /** + * mouse move + * @param event a nsIDOMEvent object + */ + public void mouseMove(nsIDOMEvent event) { + nsIDOMMouseEvent mouseEvent = (nsIDOMMouseEvent) event.queryInterface(nsIDOMMouseEvent.NS_IDOMMOUSEEVENT_IID); + + if ( mouseEvent == null ) { + return; + } + + vpeResizer.mouseMove(mouseEvent); + } + + public void dragMove(nsIDOMEvent event) { + + } + + public void handleEvent(nsIDOMEvent event) { + if ("mousemove".equals(event.getType())) { + mouseMove(event); + } + } + + public nsISupports queryInterface(String aIID) { + if (aIID.equals(nsIDOMEventListener.NS_IDOMEVENTLISTENER_IID)) { + return this; + } // if + + return Mozilla.queryInterface(this, aIID); + } + +} Added: branches/jbosstools_xulrunner/vpe/plugins/org.jboss.tools.vpe.xulrunner/src/org/jboss/tools/vpe/xulrunner/editor/XulRunnerConstants.java =================================================================== --- branches/jbosstools_xulrunner/vpe/plugins/org.jboss.tools.vpe.xulrunner/src/org/jboss/tools/vpe/xulrunner/editor/XulRunnerConstants.java (rev 0) +++ branches/jbosstools_xulrunner/vpe/plugins/org.jboss.tools.vpe.xulrunner/src/org/jboss/tools/vpe/xulrunner/editor/XulRunnerConstants.java 2007-08-14 13:12:54 UTC (rev 3117) @@ -0,0 +1,73 @@ +package org.jboss.tools.vpe.xulrunner.editor; + +/** + * @author A. Yukhovich + * + */ +public class XulRunnerConstants { + /** HTML tags */ + + /** HTML_TAG_SPAN */ + public static final String HTML_TAG_SPAN = "span"; + + + /** HTML attributes */ + + /** HTML_ATTR_CLASS */ + public static final String HTML_ATTR_CLASS = "class"; + + /** HTML_ATTR_ANONLOCATION */ + public static final String HTML_ATTR_ANONLOCATION = "anonlocation"; + + + /** HTML_ATTR_LEFT */ + public static final String HTML_ATTR_LEFT = "left"; + + /** HTML_ATTR_TOP */ + public static final String HTML_ATTR_TOP = "top"; + + /** HTML_ATTR_WIDTH */ + public static final String HTML_ATTR_WIDTH = "width"; + + /** HTML_ATTR_HEIGHT */ + public static final String HTML_ATTR_HEIGHT = "height"; + + /** HTML values */ + + /** HTML_VALUE_HIDDEN */ + public static final String HTML_VALUE_HIDDEN = "hidden"; + + /** HTML_VALUE_TRUE */ + public static final String HTML_VALUE_TRUE = "true"; + + /** HTML_VALUE_FALSE */ + public static final String HTML_VALUE_FALSE = "false"; + + /** EVENT NAMES */ + + /** EVENT_NAME_MOUSEDOWN */ + public static final String EVENT_NAME_MOUSEDOWN = "mousedown"; + + /** EVENT_NAME_MOUSEUP */ + public static final String EVENT_NAME_MOUSEUP = "mouseup"; + + /** EVENT_NAME_MOUSEMOVE */ + public static final String EVENT_NAME_MOUSEMOVE = "mousemove"; + + /** */ + + /** STRING_MOZ_ACTIVATED */ + public static final String STRING_MOZ_ACTIVATED = "_moz_activated"; + + /** STRING_MOZ_ANONCLASS */ + public static final String STRING_MOZ_ANONCLASS = "_moz_anonclass"; + + /** VPE_CLASSNAME_MOZ_RESIZER */ + public static final String VPE_CLASSNAME_MOZ_RESIZER = "mozResizer"; + + /** VPE_CLASS_NAME_MOZ_RESIZING_SHADOW */ + public static final String VPE_CLASS_NAME_MOZ_RESIZING_SHADOW = "mozResizingShadow"; + + + +}