First commit of Ninja to ninja-internal

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

1 files changed, 673 insertions, 0 deletions

diff --git a/js/tools/drawing-tool-base.js b/js/tools/drawing-tool-base.js
new file mode 100644
index 00000000..6fc34911
--- /dev/null
+++ b/js/tools/drawing-tool-base.js
@@ -0,0 +1,673 @@
+/* <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;
+var Component = require("montage/ui/component").Component;
+
+var snapManager = require("js/helper-classes/3D/snap-manager").SnapManager;
+var viewUtils = require("js/helper-classes/3D/view-utils").ViewUtils;
+var vecUtils = require("js/helper-classes/3D/vec-utils").VecUtils;
+var Properties3D = require("js/helper-classes/Properties3D").Properties3D;
+var drawUtils = require("js/helper-classes/3D/draw-utils").DrawUtils;
+
+exports.DrawingToolBase = Montage.create(Montage, {
+
+    //!!!! HACK
+    // TODO: Need to find a better way to address this
+    stage: {
+        value: null
+    },
+
+    stageComponent: {
+        value: null
+    },
+
+    /**
+     * Used on the initial MouseDown for Drawing Tools
+     * 
+     * Returns: An array containing:
+     *          0 - HitRec point
+     *          1 - X value converted to screen point
+     *          2 - Y value converted to screen point
+     */
+    getInitialSnapPoint: {
+        value: function(x,y) {
+            // update the snap settings
+                        snapManager.enableSnapAlign( snapManager.snapAlignEnabledAppLevel() );
+                        snapManager.enableElementSnap( snapManager.elementSnapEnabledAppLevel() );
+                        snapManager.enableGridSnap( snapManager.gridSnapEnabledAppLevel() );
+
+                        // do the snap
+                        var hitRec = snapManager.snap(x, y,  true);
+                        if (hitRec) {
+                                // set up the working plane and convert the hit record to be working plane relative
+                                var dragPlane = snapManager.setupDragPlanes( hitRec );
+                                var wpHitRec = hitRec.convertToWorkingPlane( dragPlane );
+
+                                var pt = hitRec.getScreenPoint();
+
+                return( [wpHitRec, pt[0], pt[1]] );
+                        }
+        }
+    },
+
+    /**
+     * Used on the Mouse Move to calculate new snap point.
+     */
+    getUpdatedSnapPoint: {
+        value: function(x,y, snap3d, downHitRec) {
+            // update the snap settings
+                        snapManager.enableSnapAlign( snapManager.snapAlignEnabledAppLevel() );
+                        snapManager.enableElementSnap( snapManager.elementSnapEnabledAppLevel() );
+                        snapManager.enableGridSnap( snapManager.gridSnapEnabledAppLevel() );
+
+
+                        // do the first snap
+                        var hitRec = snapManager.snap(x, y, snap3d );
+                        if (hitRec) {
+                                if ((hitRec.getType() !== hitRec.SNAP_TYPE_STAGE) && !hitRec.isSomeGridTypeSnap()) {
+                                        hitRec = hitRec.convertToWorkingPlane( snapManager.getDragPlane() );
+                                }
+
+                                if(downHitRec !== null) {
+                                        // if we are working off-plane, do a snap to the projected locations of the geometry
+                                        var thePlane = workingPlane;
+                                        if (snapManager.hasDragPlane())
+                                        {
+                                                thePlane = snapManager.getDragPlane();
+                                        }
+
+                    // Return the up HitRec
+                    return hitRec;
+                                } else {
+                    return null;
+                }
+            }
+        }
+    },
+
+    getUpdatedSnapPointNoAppLevelEnabling: {
+        value: function(x,y, snap3d, downHitRec) {
+
+
+                        // do the first snap
+                        var hitRec = snapManager.snap(x, y, snap3d );
+                        if (hitRec) {
+                                if ((hitRec.getType() !== hitRec.SNAP_TYPE_STAGE) && !hitRec.isSomeGridTypeSnap()) {
+                                        hitRec = hitRec.convertToWorkingPlane( snapManager.getDragPlane() );
+                                }
+
+                                if(downHitRec !== null) {
+                                        // if we are working off-plane, do a snap to the projected locations of the geometry
+                                        var thePlane = workingPlane;
+                                        if (snapManager.hasDragPlane())
+                                        {
+                                                thePlane = snapManager.getDragPlane();
+                                        }
+
+                    // Return the up HitRec
+                    return hitRec;
+                                } else {
+                    return null;
+                }
+            }
+        }
+    },
+
+
+    setDownHitRec: {
+                value: function (x, y, do3DSnap) {
+                        var hitRec = snapManager.snap(x, y, do3DSnap );
+                        if (hitRec) {
+                                if ((hitRec.getType() != hitRec.SNAP_TYPE_STAGE) && !hitRec.isSomeGridTypeSnap()) {
+                                        //hitRec = hitRec.convertToWorkingPlane( workingPlane );
+                                        snapManager.setupDragPlanes(hitRec);
+                                        hitRec = hitRec.convertToWorkingPlane( snapManager.getDragPlane() );
+                                }
+
+                    return hitRec;
+
+                        }
+                }
+        },
+
+    drawSnapLastHit: {
+        value: function() {
+            snapManager.drawLastHit();
+        }
+    },
+
+    getHitRecPos: {
+        value: function (hitRec) {
+            if (!hitRec)
+                return null;
+
+            // get the hit rec. points in plane space
+            var psPos = hitRec.getLocalPoint();
+
+            var stage = this.stage;
+            var stageOffset = viewUtils.getElementOffset(stage);
+            viewUtils.setViewportObj(stage);
+
+            // get the matrix taking the local hit point in plane space
+            // to world space of whatever element it is in.
+            var planeMat = hitRec.getPlaneMatrix();
+
+            // get the center of the circle in stage world space
+            var swPos = viewUtils.postViewToStageWorld(MathUtils.transformPoint(psPos, hitRec.getPlaneMatrix()), hitRec.getElt());
+
+            // the stage world space point is now relative to the center of the 3D space.  To
+            // calculate the left and top offsets, this must be offset by the stage dimensions
+            swPos[0] += snapManager.getStageWidth() / 2.0;
+            swPos[1] += snapManager.getStageHeight() / 2.0;
+
+            return swPos;
+        }
+    },
+
+    getCompletePoints: {
+        value: function(hitRec0, hitRec1) {
+                        if (hitRec0 && hitRec1) {
+
+                                // get the 2 snap points in plane space
+                                var p0 = hitRec0.getLocalPoint(),
+                                        p1 = hitRec1.getLocalPoint();
+
+                                var stage = this.stage;
+                                var stageOffset = viewUtils.getElementOffset(stage);
+                                viewUtils.setViewportObj(stage);
+
+                                // get the matrix taking the local hit point in plane space
+                                // to world space of whatever element it is in.
+                                var planeMat = hitRec0.getPlaneMatrix();
+
+                                // get the center of the circle in stage world space
+                                var s0 = viewUtils.postViewToStageWorld( MathUtils.transformPoint(p0,hitRec0.getPlaneMatrix()), hitRec0.getElt() ),
+                                        s1 = viewUtils.postViewToStageWorld( MathUtils.transformPoint(p1,hitRec1.getPlaneMatrix()), hitRec1.getElt() );
+
+                                // apply the projected snap points
+                                var s0Proj = false,  s1Proj = false;
+
+                                // find a "reasonable" plane
+                                var thePlane = workingPlane.slice(0);
+                                if (snapManager.hasDragPlane())  {
+                                        thePlane = snapManager.getDragPlane();
+                                }
+
+                                var d0 = vecUtils.vecDot( 3, thePlane, s0 ) + thePlane[3],
+                                        d1 = vecUtils.vecDot( 3, thePlane, s1 ) + thePlane[3];
+                                var sign0 = MathUtils.fpSign( d0 ),  sign1 = MathUtils.fpSign( d1 );
+                                if ((sign0 !== 0) || (sign1 !== 0)) {
+                                        // we need to pick a different plane
+                                        if ( MathUtils.fpCmp(d0,d1) === 0 ) {
+                                                thePlane[3] = -vecUtils.vecDot(3, thePlane, s0);
+                                        } else {
+                                                var vec = vecUtils.vecSubtract(3,  s1, s0 );
+                                                var yAxis = Vector.create([0,1,0]);
+                                                var tmp = vecUtils.vecCross( 3,  vec, yAxis  );
+                                                var mag = vecUtils.vecMag(3, tmp);
+                                                if (MathUtils.fpSign(mag) === 0) {
+                                                        thePlane = Vector.create( [0,0,1] );
+                                                        thePlane[3] = -vecUtils.vecDot(3, thePlane, s0);
+                                                } else {
+                                                        var xAxis = vecUtils.vecCross( 3,  yAxis, tmp );
+                                                        thePlane  = vecUtils.vecCross( 3,  xAxis, yAxis );
+                                                        vecUtils.vecNormalize(3, thePlane, 1.0 );
+                                                        thePlane[3] = -vecUtils.vecDot(3, thePlane, s0);
+                                                }
+                                        }
+
+                                        // recompute the plane matrix
+                                        planeMat = drawUtils.getPlaneToWorldMatrix(thePlane, MathUtils.getPointOnPlane(thePlane));
+                                }