First commit of Ninja to ninja-internal

Signed-off-by: Valerio Virgillito <rmwh84@motorola.com>

1 files changed, 1007 insertions, 0 deletions

diff --git a/js/tools/modifier-tool-base.js b/js/tools/modifier-tool-base.js
new file mode 100644
index 00000000..f78e99c8
--- /dev/null
+++ b/js/tools/modifier-tool-base.js
@@ -0,0 +1,1007 @@
+/* <copyright>
+This file contains proprietary software owned by Motorola Mobility, Inc.<br/>
+No rights, expressed or implied, whatsoever to this software are provided by Motorola Mobility, Inc. hereunder.<br/>
+(c) Copyright 2011 Motorola Mobility, Inc.  All Rights Reserved.
+</copyright> */
+
+var Montage = require("montage/core/core").Montage,
+    DrawingTool = require("js/tools/drawing-tool").DrawingTool,
+    snapManager = require("js/helper-classes/3D/snap-manager").SnapManager,
+    viewUtils = require("js/helper-classes/3D/view-utils").ViewUtils,
+    vecUtils = require("js/helper-classes/3D/vec-utils").VecUtils,
+    drawUtils = require("js/helper-classes/3D/draw-utils").DrawUtils,
+    Properties3D = ("js/models/properties-3d").Properties3D;
+
+exports.ModifierToolBase = Montage.create(DrawingTool, {
+
+    //-------------------------------------------------------------------------
+    // Drawing Mode Info
+    drawingFeedback: { value: { mode: "Draw3D", type: "rectangle" } },
+
+    //-------------------------------------------------------------------------
+    // Snapping-specific properties
+    _canSnap: { value: true },
+    _dragPlane: { value: null },
+        _snapParam: { value: null },
+        _snapIndex: { value: -1 },
+        _useQuadPt: { value: false },
+
+        // we set snapping capabilities depending on the tool.
+        // The following variables are set in a tool's initializeSnapping method called on mouse down.
+        _snapToElements: { value: true },
+        _snapToGrid: { value: true },
+
+    _clickedObject : {value : null },
+    clickedObject:
+        {
+                get: function () {
+                        return this._clickedObject;
+                },
+                set: function (value) {
+                        if(value === this.application.ninja.currentDocument.documentRoot)
+                        {
+                                this._clickedObject = this._target;
+                        }
+                        else
+                        {
+                                this._clickedObject = value;
+                        }
+
+                        if(value)
+                        {
+                                this._startMat = viewUtils.getMatrixFromElement(this._clickedObject);
+                        }
+                        else
+                        {
+                                this._startMat = null;
+                        }
+                }
+        },
+    
+    _getObjectBeingTracked :
+    {
+        value: function(hitRec)
+        {
+            var elt = hitRec.getElt();
+            if(elt === this.application.ninja.currentDocument.documentRoot)
+            {
+                elt = this._target;
+            }
+
+            return elt;
+        }
+    },
+
+    drawWithoutSnapping:
+    {
+        value: function(event)
+        {
+            // override in subclasses
+        }
+    },
+    
+    initializeSnapping:
+    {
+        value: function(event)
+        {
+            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;
+            var do3DSnap = true;
+
+//            if(this._handleMode === null)
+//            {
+//                if(!this._activateOriginHandle)
+//                {
+//                    this.doSelection(event);
+
+                    snapManager.enableElementSnap       ( true  );
+//                    snapManager.enableGridSnap                ( true  );
+//                }
+//            }
+//            else
+//            {
+//                this._matL = this._handles[this._handleMode]._matL.slice(0);
+//                this._planeEq = this._handles[this._handleMode]._planeEq.slice(0);
+//                this._dirVecL = this._handles[this._handleMode]._dirVecL.slice(0);
+//                this.m_startPoint = MathUtils.getLocalPoint(event.layerX, event.layerY, this._planeEq, this._matL);
+//                if(!this.m_startPoint)
+//                {
+//                    this.m_startPoint = [this.m_xStart, this.m_yStart];
+//                }
+//            }
+
+
+            if(this._targets)
+            {
+                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);
+
+                // 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() );
+                                        }
+
+                                        // parameterize the snap point on the target
+                                        this._snapParam = this.parameterizeSnap( hitRec );
+
+                    if(!this._dragPlane)
+                    {
+//                        if( this._inLocalMode && (this._startMatArray.length === 1) )
+//                        {
+//                            this._dragPlane = viewUtils.getUnprojectedElementPlane(this._clickedObject);
+//                            snapManager.setupDragPlaneFromPlane(this._dragPlane);
+//                        }
+//                        else
+//                        {
+                            this._dragPlane = snapManager.setupDragPlanes( hitRec );
+//                        }
+                    }
+
+                                        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];
+
+                    snapManager.drawLastHit();
+
+                    snapManager.enableSnapAlign( snapManager.snapAlignEnabledAppLevel() );
+                    snapManager.enableElementSnap( snapManager.elementSnapEnabledAppLevel() );
+                    snapManager.enableGridSnap( snapManager.gridSnapEnabledAppLevel() );
+                                }
+            }
+            else
+            {
+                this.target = null;
+            }
+        }
+    },
+    
+        /*
+         *  The parameterization is based on the position of the
+         *  snap point in pre-transformed element screen space
+         */
+        parameterizeSnap:
+        {
+                value: function( hitRec )
+                {
+                        var paramPt = [0,0,0];
+            var elt = this._getObjectBeingTracked(hitRec);
+                        if (elt)
+                        {
+                this.clickedObject = elt;
+
+                var worldPt = hitRec.calculateStageWorldPoint();
+                MathUtils.makeDimension4( worldPt );
+                var mat = viewUtils.getObjToStageWorldMatrix( elt, true );
+                if(mat)
+                {
+                    var invMat = glmat4.inverse(mat, []);
+                    var scrPt = MathUtils.transformHomogeneousPoint( worldPt, invMat );
+                    scrPt = MathUtils.applyHomogeneousCoordinate( scrPt );
+
+                                        var bounds = viewUtils.getElementViewBounds3D( elt );
+                                        var x0 = bounds[0][0],  x1 = bounds[3][0],
+                                                y0 = bounds[0][1],  y1 = bounds[1][1];
+                                        var dx = x1 - x0,   dy = y1 - y0;
+                                        var u = 0, v = 0;
+                                        if (MathUtils.fpSign(dx) != 0)
+                                                u = (scrPt[0] - x0) / dx;
+                                        if (MathUtils.fpSign(dy) != 0)
+                                                v = (scrPt[1] - y0) / dy;
+
+                                        paramPt[0] = u;
+                                        paramPt[1] = v;
+                                        paramPt[2] = scrPt[2];