First commit of Ninja to ninja-internal

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

1 files changed, 357 insertions, 0 deletions

diff --git a/js/tools/Translate3DToolBase.js b/js/tools/Translate3DToolBase.js
new file mode 100644
index 00000000..cbf76830
--- /dev/null
+++ b/js/tools/Translate3DToolBase.js
@@ -0,0 +1,357 @@
+/* <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> */
+
+/* Base class for the 3D translate tools
+Subclass TranslateObject3DTool will translate the object that was clicked.
+*/
+var Montage = require("montage/core/core").Montage,
+    ModifierToolBase = require("js/tools/modifier-tool-base").ModifierToolBase,
+    toolHandleModule = require("js/stage/tool-handle"),
+    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,
+    ElementsMediator = require("js/mediators/element-mediator").ElementMediator;
+
+exports.Translate3DToolBase = Montage.create(ModifierToolBase,
+{
+        _inLocalMode: { value: true, enumerable: true },
+
+        HandleDoubleClick : {
+           value : function()
+           {
+           }
+        },
+
+    modifyElements : {
+                value : function(data, event)
+        {
+            // form the translation vector and post translate the matrix by it.
+            var delta = vecUtils.vecSubtract( 3, data.pt1, data.pt0 );
+            if(this._handleMode !== null)
+            {
+                switch(this._handleMode)
+                {
+                    case 0:
+                        delta[1] = 0;
+                        delta[2] = 0;
+                        break;
+                    case 1:
+                        delta[0] = 0;
+                        delta[2] = 0;
+                        break;
+                    case 2:
+                        delta[0] = 0;
+                        delta[1] = 0;
+                        break;
+                }
+
+                this._updateDelta(delta, this._handleMode);
+            }
+            else if(this._mode === 1)
+            {
+                delta[2] = delta[1];
+                delta[0] = 0;
+                delta[1] = 0;
+            }
+
+            var transMat = Matrix.Translation( delta );
+            if(this._inLocalMode && (this._targets.length === 1) )
+            {
+                this._translateLocally(transMat);
+            }
+            else
+            {
+                this._translateGlobally(transMat);
+            }
+        }
+        },
+
+
+        Reset : {
+                value : function()
+                {
+            var item,
+                elt,
+                mat,
+                dist,
+                newStyles = [],
+                previousStyles = [],
+                len = this._targets.length;
+            for(var i = 0; i < len; i++)
+            {
+                // Reset to the identity matrix but retain the rotation values
+                item = this._targets[i];
+                elt = item.elt;
+                mat = item.mat.slice(0);
+                mat[12] = 0;
+                mat[13] = 0;
+                mat[14] = 0;
+
+                dist = this._undoArray[i].dist;
+
+                var previousStyleStr = {dist:dist, mat:item.mat};
+
+                var newStyleStr = {dist:dist, mat:mat};
+
+                previousStyles.push(previousStyleStr);
+                newStyles.push(newStyleStr);
+            }
+
+            ElementsMediator.set3DProperties(this.application.ninja.selectedElements,
+                                            newStyles,
+                                            "Change",
+                                            "translateTool",
+                                            previousStyles
+                                          );
+
+                        this.isDrawing = false;
+            this.endDraw(event);
+
+//                      this.UpdateSelection(true);
+                        this.Configure(true);
+                }
+        },
+
+        // We will only translate single elements locally
+        _translateLocally: {
+                value: function (transMat) {
+                        var mat = glmat4.multiply(this._startMat, transMat, []);
+                        viewUtils.setMatrixForElement( this._target, mat, true );
+                        if(this._mode !== 1)
+                        {
+                                this._startMat = mat;
+                        }
+                }
+        },
+
+        _translateGlobally: {
+                value: function (transMat) {
+                        var len = this._targets.length,
+                                i = 0,
+                                item,
+                                elt,
+                                curMat,
+                matInv = glmat4.inverse(this._startMat, []),
+                nMat = glmat4.multiply(transMat, this._startMat, [] ),
+                            qMat = glmat4.multiply(matInv, nMat, []);
+
+                        var shouldUpdateStartMat = true;
+
+                        if(this._clickedObject === this.application.ninja.currentDocument.documentRoot)
+                        {
+                                shouldUpdateStartMat = false;
+                        }
+                        else if(this._mode !== 1)
+                        {
+                                this._startMat = nMat;
+                        }
+
+                        for(i = 0; i < len; i++)
+                        {
+                                item = this._targets[i];
+                                elt = item.elt;
+                                curMat = item.mat;
+
+                                glmat4.multiply(curMat, qMat, curMat);
+
+                                viewUtils.setMatrixForElement( elt, curMat, true);
+
+                                if(shouldUpdateStartMat)
+                                {
+                                        this._targets[i].mat = curMat;
+                                }
+                        }
+                }
+        },
+
+    _updateTargets: {
+                value: function(addToUndoStack) {
+            var newStyles = [],
+                previousStyles = [],
+                            len = this.application.ninja.selectedElements.length;
+                        this._targets = [];
+                        for(var i = 0; i < len; i++)
+                        {
+                                var elt = this.application.ninja.selectedElements[i]._element;
+
+                                var curMat = viewUtils.getMatrixFromElement(elt);
+                                var curMatInv = glmat4.inverse(curMat, []);
+
+                                this._targets.push({elt:elt, mat:curMat, matInv:curMatInv});
+                if(addToUndoStack)
+                {
+                    var previousStyleStr = {dist:this._undoArray[i].dist, mat:MathUtils.scientificToDecimal(this._undoArray[i].mat.slice(0), 5)};
+
+                    var newStyleStr = {dist:viewUtils.getPerspectiveDistFromElement(elt), mat:MathUtils.scientificToDecimal(curMat, 5)};
+
+                    previousStyles.push(previousStyleStr);
+                    newStyles.push(newStyleStr);
+                }
+                        }
+                        if(addToUndoStack)
+                        {
+                ElementsMediator.set3DProperties(this.application.ninja.selectedElements,
+                                                newStyles,
+                                                "Change",
+                                                "translateTool",
+                                                previousStyles
+                                              );
+            }
+            // Save previous value for undo/redo
+            this._undoArray = [];
+            for(i = 0, len = this._targets.length; i < len; i++)
+            {
+                var elt = this._targets[i].elt;
+                var _mat = viewUtils.getMatrixFromElement(elt);
+                var _dist = viewUtils.getPerspectiveDistFromElement(elt);
+                this._undoArray.push({mat:_mat, dist:_dist});
+            }
+
+                }
+        },
+
+        HandleAltKeyDown: {
+                value: function(event) {
+                        this._inLocalMode = !this._inLocalMode;
+                        this.DrawHandles();
+                }
+        },
+
+        HandleAltKeyUp: {
+                value: function(event) {
+                        this._inLocalMode = !this._inLocalMode;
+                        this.DrawHandles();
+                }
+        },
+
+        handleScroll: {