Merge branch 'master' into pentool

Conflicts:
	js/helper-classes/3D/view-utils.js

1 files changed, 344 insertions, 42 deletions

diff --git a/js/tools/Rotate3DToolBase.js b/js/tools/Rotate3DToolBase.js
index 2e121b0b..4fa8657e 100755
--- a/js/tools/Rotate3DToolBase.js
+++ b/js/tools/Rotate3DToolBase.js
@@ -25,6 +25,149 @@ exports.Rotate3DToolBase = Montage.create(ModifierToolBase, {
         value: false
     },
 
+    initializeSnapping : {
+        value : function(event)
+        {
+//            console.log( "initializeSnapping" );
+
+            var selectedElements = this.application.ninja.selectedElements;
+            if(this.rotateStage) {
+                selectedElements = [this.application.ninja.currentDocument.documentRoot];
+            }
+
+                        this._mouseDownHitRec = null;
+                        this._mouseUpHitRec   = null;
+
+                        snapManager.clearAvoidList();
+                        snapManager.clearDragPlane();
+
+                        // the translate tool does snap align to the bounds of the object only.
+                        // turn off snap align to the cursor.  This needs to be re-enabled in the mouse up method
+                        snapManager.enableSnapAlign( false );
+
+                        // snap to element and snap to grid are conditionally enabled based
+                        // on the snap results of the mouse down.  enable everything for the first snap
+                        this._snapToElements = snapManager.elementSnapEnabledAppLevel();
+                        this._snapToGrid = snapManager.gridSnapEnabledAppLevel();
+
+            this._dragPlane = null;
+            this._clickedOnStage = false;
+            var do3DSnap = true;
+
+            if(this._handleMode === null)
+            {
+                snapManager.enableElementSnap   ( true  );
+                                snapManager.enableGridSnap              ( true  );
+            }
+//            else
+//            {
+//                this._delta = null;
+                // special case for z-translation
+//                if(this._handleMode === 0)
+//                {
+//                    this._dragPlane = viewUtils.getNormalToUnprojectedElementPlane(this._target);
+//                    snapManager.setupDragPlaneFromPlane(this._dragPlane);
+//                    do3DSnap = false;
+
+//                    snapManager.enableElementSnap     ( false );
+//                    snapManager.enableGridSnap                ( false );
+//                }
+//            }
+
+            if (selectedElements.length)
+            {
+                var point = webkitConvertPointFromPageToNode(this.application.ninja.stage.canvas,
+                                                                new WebKitPoint(event.pageX, event.pageY));
+
+                                // do the snap before setting up the avoid list to allow
+                                // a snap on the mouse down
+                                var hitRec = snapManager.snap(point.x, point.y, do3DSnap);
+
+//                if(this._handleMode === 2)
+//                {
+//                    // translate z doesn't snap to element so hitRec's element will always be different
+//                    // from what the browser says we clicked on. So, skip this check.
+//                }
+//                else
+//                {
+//                    // Check that hitRec's element matches element that browser says we clicked on
+//                    // TODO - This is still not working when using a handle that is on top of an
+//                    // element that is not currently selected
+//                    var elt = this.application.ninja.stage.GetSelectableElement(event);
+//                    if(elt && (elt !== hitRec.getElement()))
+//                    {
+//                        hitRec = snapManager.findHitRecordForElement(elt);
+//                    }
+//                    if(elt === this.application.ninja.currentSelectedContainer)
+//                    {
+//                        this._clickedOnStage = true;
+//                    }
+//                }
+
+                // we don't want to snap to selected objects during the drag
+//                var len = this._targets.length;
+//                for(var i=0; i<len; i++)
+//                {
+//                    snapManager.addToAvoidList( this._targets[i].elt );
+//                }
+                                if (hitRec)
+                                {
+                                        // disable snap attributes
+                                        if (hitRec.getType() == hitRec.SNAP_TYPE_ELEMENT)
+                                        {
+                                                this._snapToElements = false;
+                                                this._snapToGrid = false;
+                                        }
+                                        else if (hitRec.getType() == hitRec.SNAP_TYPE_ELEMENT_CENTER)
+                                        {
+                                                snapManager.enableSnapAlign( snapManager.snapAlignEnabledAppLevel() );
+                                        }
+
+                    if(this._handleMode === 0)
+                        this.clickedObject = this._target;
+
+                    // parameterize the snap point on the target
+                    this._snapParam = this.parameterizeSnap( hitRec );
+
+                    if(!this._dragPlane)
+                    {
+                        if (selectedElements.length === 1)
+                        {
+                            this._dragPlane = viewUtils.getUnprojectedElementPlane(this._clickedObject);
+                            snapManager.setupDragPlaneFromPlane(this._dragPlane);
+                        }
+                        else
+                        {
+                            this._dragPlane = snapManager.setupDragPlanes( hitRec, true );
+                        }
+
+                    }
+
+                    // no quadrant snapping for the rotate tool
+                    this._shouldUseQuadPt = false;
+
+                                        var wpHitRec = hitRec.convertToWorkingPlane( this._dragPlane );
+                                        this._mouseDownHitRec = wpHitRec;
+                                        this._mouseUpHitRec = null;
+
+                                        var pt = hitRec.getScreenPoint();
+                                        this.downPoint.x = pt[0];
+                                        this.downPoint.y = pt[1];
+                                        this.downPoint.z = pt[2];
+
+                    // TODO - need to figure out snapManager dependency by drawUtils.
+                    // For now, bypassing by calling snapManager.drawLastHit();
+//                                      drawUtils.refreshDisplay();
+//                    snapManager.drawLastHit();
+                                }
+            }
+            else
+            {
+                this.target = null;
+            }
+        }
+    },
+
     drawWithoutSnapping:
     {
         value: function(event)
@@ -46,25 +189,76 @@ exports.Rotate3DToolBase = Montage.create(ModifierToolBase, {
         }
     },
 
+    HandleMouseMove: {
+        value: function(event) {
+            if(this._escape) {
+                this._escape = false;
+                this.isDrawing = true;
+            }
+
+            if(this.isDrawing) {
+                this._hasDraw = true;   // Flag for position of element
+                this.doDraw(event);
+            } else {
+                this._showFeedbackOnMouseMove(event);
+                if(this._canSnap)
+                {
+                    this.doSnap(event);
+                }
+            }
+
+                        this.DrawHandles(this._delta);
+            
+                        if(this._canSnap)
+            {
+                snapManager.drawLastHit();
+            }
+        }
+    },
+
     modifyElements: {
         value: function(data, event) {
-            var mat, angle, pt0 = data.pt0, pt1 = data.pt1;
-
-            if(this._handleMode !== null) {
-                if(this._activateOriginHandle) {
-                    // move the transform origin handle
-                    var dx = pt1.x - pt0.x;
-                    var dy = pt1.y - pt0.y;
-                    this._origin[0] += dx;
-                    this._origin[1] += dy;
-
-                    if( this.rotateStage || (this.application.ninja.selectedElements.length === 1)) {
-                        this._startOriginArray[0][0] += dx;
-                        this._startOriginArray[0][1] += dy;
+            var mat,
+                angle,
+                pt0 = data.pt0,
+                pt1 = data.pt1;
+
+            var selectedElements = this.application.ninja.selectedElements;
+            if(this.rotateStage) {
+                selectedElements = [this.application.ninja.currentDocument.documentRoot];
+            }
+
+            if(this._handleMode !== null)
+            {
+                if(this._activateOriginHandle)
+                {
+                    // move the transform origin handle directly to the snap point (pt1)
+                    this._origin[0] = pt1.x;
+                    this._origin[1] = pt1.y;
+                    this._origin[2] = pt1.z;
+
+                                        var sw2gMat = viewUtils.getStageWorldToGlobalMatrix();
+                                        var g2swMat = glmat4.inverse( sw2gMat, [] );
+                                        var swOrigin = MathUtils.transformAndDivideHomogeneousPoint( this._origin, g2swMat );
+                                        //console.log( "modifyElements, _origin: " + this._origin + ", in stageWorld: " + swOrigin );
+
+                    var len = selectedElements.length;
+                    if(len === 1)
+                    {
+                        var elt = selectedElements[0];
+                                                var g2lMat = elt.elementModel.getProperty("g2l");
+                                                var localOrigin = MathUtils.transformAndDivideHomogeneousPoint( this._origin, g2lMat );
+
+                                                viewUtils.pushViewportObj( elt );