1 files changed, 2247 insertions, 0 deletions

diff --git a/js/helper-classes/3D/snap-manager.js b/js/helper-classes/3D/snap-manager.js
new file mode 100644
index 00000000..3ed96082
--- /dev/null
+++ b/js/helper-classes/3D/snap-manager.js
@@ -0,0 +1,2247 @@
+/* <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> */
+
+///////////////////////////////////////////////////////////////////////
+// Class SnapManager
+//      Class to do hit testing of objects in the html page
+///////////////////////////////////////////////////////////////////////
+var Montage = require("montage/core/core").Montage,
+    Component = require("montage/ui/component").Component;
+
+var viewUtils = require("js/helper-classes/3D/view-utils").ViewUtils;
+var vecUtils = require("js/helper-classes/3D/vec-utils").VecUtils;
+var drawUtils = require("js/helper-classes/3D/draw-utils").DrawUtils;
+var HitRecord = require("js/helper-classes/3D/hit-record").HitRecord;
+var Snap2DRecord = require("js/helper-classes/3D/snap-2d-record").Snap2DRecord;
+var NJUtils = require("js/lib/NJUtils").NJUtils;
+
+var SnapManager = exports.SnapManager = Montage.create(Component, {
+        ///////////////////////////////////////////////////////////////////////
+        // Instance variables
+        ///////////////////////////////////////////////////////////////////////
+    currentStage: { value: null, writable: true },
+    drawingCanvas: { value: null, writable: true},
+    
+        // we keep a stack of working planes to facilitate working on other planes temporarily
+        _workingPlaneStack : { value: [], writable: true },
+
+        // snapping radii relative to a 25 pixel grid
+        GRID_VERTEX_HIT_RAD : { value: 10, writable: true },
+        GRID_EDGE_HIT_RAD : { value: 6, writable: true},
+
+        // these are the grid snapping tolerances scaled to the current grid spacing
+        _gridVertexHitRad : { value: this.GRID_VERTEX_HIT_RAD, writable: true },
+        _gridEdgeHitRad : { value: this.GRID_EDGE_HIT_RAD, writable: true },
+
+        ELEMENT_VERTEX_HIT_RAD : { value: 18, writable: true },
+        ELEMENT_EDGE_HIT_RAD : { value: 14, writable: true },
+
+        // keep a reference to the most recent hitRecord.  Used for drawing feedback on the stage
+        _lastHit : { value: null, writable: true },
+
+        // keep a list of objects to avoid snapping to
+        _avoidList : { value: [], writable: true },
+
+        // keep a cache of 2D elements to snap to
+        _elementCache : { value: null, writable: true },
+        _isCacheInvalid : { value: false, writable: true },
+
+        // the snap manager can handle a 2D plane for dragging.
+        // A call to initDragPlane sets these variables.
+        // a call to clearDragPlane MUST be called on the completion of a drag
+        _hasDragPlane : {value: false, writable: true },
+        _dragPlane : { value: null, writable: true },
+        _dragPlaneToWorld : { value: Matrix.I(4), writable: true },
+        _worldToDragPlane : { value: Matrix.I(4), writable: true },
+        _dragPlaneActive : {value: false, writable: true },
+
+        // cache the matrix linking stage world and global spaces
+        _stageWorldToGlobalMat : { value: Matrix.I(4), writable: true },
+        _globalToStageWorldMat : { value: Matrix.I(4), writable: true },
+
+        // various flags to enable snapping
+        _snapAlignEnabled : {value: true, writable: true },
+        _elementSnapEnabled : {value: true, writable: true },
+        _gridSnapEnabled : {value: true, writable: true },
+
+        // these represent the app level snap settings as set by the end user through
+        // the menus.  These should be stored somewhere else and serialized.  Putting them here for now...
+        _snapAlignEnabledAppLevel : {value: true, writable: true },
+        _elementSnapEnabledAppLevel : {value: true, writable: true },
+        _gridSnapEnabledAppLevel : {value: true, writable: true },
+
+    // App Model pointer
+    appModel: { value: null },
+
+
+        ///////////////////////////////////////////////////////////////////////
+        // Property accessors
+        ///////////////////////////////////////////////////////////////////////
+        pushWorkingPlane : { value: function (p)                { this._workingPlaneStack.push(workingPlane.slice(0)); workingPlane = p.slice(0); }},
+        popWorkingPlane : { value: function ()          { workingPlane = this._workingPlaneStack.pop(); return workingPlane; }},
+
+        getStageWidth : { value: function ()            {
+                return parseInt(this.currentStage.offsetWidth);
+        }},
+
+        getStageHeight : { value: function ()           {
+                return parseInt(this.currentStage.offsetHeight);
+        }},
+
+    getStage : { value: function()              {        return this.currentStage;    }},
+
+        getGridVertexHitRad : { value: function()               {  return this._gridVertexHitRad;                               }},
+        getGridEdgeHitRad : { value: function()         {  return this._gridEdgeHitRad;                                 }},
+
+        getLastHit : { value: function()                {  return this._lastHit;                                                }},
+        setLastHit : { value: function(h)               {  this._lastHit = h;                                                   }},
+
+        hasDragPlane : { value: function()              {  return this._hasDragPlane;                                   }},
+        getDragPlane : { value: function()              {  return this._dragPlane.slice(0);                             }},
+
+    has2DCache : { value: function()            {  return (this._elementCache && !this._isCacheInvalid);                }},
+
+        enableSnapAlign : { value: function(e)          {  this._snapAlignEnabled = e;                                  }},
+        snapAlignEnabled : { value: function()          {  return this._snapAlignEnabled;                               }},
+        enableElementSnap : { value: function(e)                {  this._elementSnapEnabled = e;                                }},
+        elementSnapEnabled : { value: function()                {  return this._elementSnapEnabled;                             }},
+        enableGridSnap : { value: function(e)           {  this._gridSnapEnabled = e;                                   }},
+        gridSnapEnabled : { value: function()           {  return this._gridSnapEnabled;                                }},
+
+        enableSnapAlignAppLevel : { value: function(e)          {  this._snapAlignEnabledAppLevel = e;                  }},
+        snapAlignEnabledAppLevel : { value: function()          {  return this._snapAlignEnabledAppLevel;               }},
+        enableElementSnapAppLevel : { value: function(e)                {  this._elementSnapEnabledAppLevel = e;                }},
+        elementSnapEnabledAppLevel : { value: function()                {  return this._elementSnapEnabledAppLevel;             }},
+        enableGridSnapAppLevel : { value: function(e)           {  this._gridSnapEnabledAppLevel = e;                   }},
+        gridSnapEnabledAppLevel : { value: function()           {  return this._gridSnapEnabledAppLevel;                }},
+
+        ///////////////////////////////////////////////////////////////////////
+        // Methods
+        ///////////////////////////////////////////////////////////////////////
+    initialize: {
+        value: function() {
+            this.eventManager.addEventListener("elementDeleted", this, false);
+        }
+    },
+
+    bindSnap: {
+        value: function() {
+            this.addEventListener("change@appModel.snap", this.toggleSnap, false);
+            this.addEventListener("change@appModel.snapGrid", this.toggleSnapGrid, false);
+            this.addEventListener("change@appModel.snapObjects", this.toggleSnapObjects, false);
+            this.addEventListener("change@appModel.snapAlign", this.toggleSnapAlign, false);
+        }
+    },
+
+    toggleSnap: {
+        value: function() {
+            this.enableSnapAlignAppLevel(this.appModel.snap);
+            this.enableElementSnapAppLevel(this.appModel.snap);
+            this.enableGridSnapAppLevel(this.appModel.snap);
+        }
+    },
+
+    toggleSnapGrid: {
+        value: function() {
+            this.enableGridSnapAppLevel(this.appModel.snapGrid);
+        }
+    },
+
+    toggleSnapObjects: {
+        value: function() {
+            this.enableElementSnapAppLevel(this.appModel.snapObjects);
+        }
+    },
+
+    toggleSnapAlign: {
+        value: function() {
+            this.enableSnapAlignAppLevel(this.appModel.snapAlign);
+        }
+    },
+
+
+    handleElementDeleted: {
+        value: function(event) {
+            this.removeElementFrom2DCache(event.detail);
+        }
+    },
+
+
+    setCurrentStage: {
+        value: function(stage) {
+            this.currentStage = stage;
+        }
+    },
+
+        snap : {
+                value: function (xScreen, yScreen, snap3D,  quadPt) 
+                {
+                        // force a 3D snap if a 2D snap is requested but the 2D cache has not been initialized
+                        if (!snap3D && !this._elementCache)  snap3D = true;
+
+                        // clear out the last hit record
+                        this.setLastHit( null );
+
+                        // snap to elements first, then the working plane
+                        var screenPt = [xScreen, yScreen];
+                        var hitRecArray = new Array();
+                        if (this.elementSnapEnabled())
+                        {
+                                if (snap3D)
+                                        this.snapToElements( screenPt, hitRecArray );
+
+                                // now always doing a 2D snap
+                                this.snapToCached2DElements( screenPt, hitRecArray );
+                        }
+
+                        // if we did not hit anything, and we are in 2D mode, try a snap align
+                        if (this.snapAlignEnabled())
+                        {
+                                //if (hitRecArray.length == 0)
+                                        this.snapAlign( screenPt, hitRecArray );
+                        }
+
+
+                        // if we did not find any objects to snap to, snap to the working plane and/or grid
+                        //if (hitRecArray.length == 0)
+                        {
+                                var stage = this.getStage();
+                                var parentPt;
+                                if (quadPt)
+                                        parentPt = Vector.create([quadPt[0], quadPt[1], 0.0]);
+                                else
+                                        parentPt = Vector.create([xScreen, yScreen, 0.0]);
+                                var vec = viewUtils.parentToChildVec(parentPt, stage);
+                                if (vec)
+                                {