/* <copyright>
Copyright (c) 2012, Motorola Mobility LLC.
All Rights Reserved.

Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions are met:

* Redistributions of source code must retain the above copyright notice,
  this list of conditions and the following disclaimer.

* Redistributions in binary form must reproduce the above copyright notice,
  this list of conditions and the following disclaimer in the documentation
  and/or other materials provided with the distribution.

* Neither the name of Motorola Mobility LLC nor the names of its
  contributors may be used to endorse or promote products derived from this
  software without specific prior written permission.

THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
POSSIBILITY OF SUCH DAMAGE.
</copyright> */

///////////////////////////////////////////////////////////////////////
// Class DrawUtils
//      Overlay drawing utility functions
///////////////////////////////////////////////////////////////////////
var Montage = require("montage/core/core").Montage,
    Component = require("montage/ui/component").Component;

var vecUtils = require("js/helper-classes/3D/vec-utils").VecUtils;
var Rectangle = require("js/helper-classes/3D/rectangle").Rectangle;
var StageLine = require("js/helper-classes/3D/StageLine").StageLine;


var DrawUtils = exports.DrawUtils = Montage.create(Component, {
    ///////////////////////////////////////////////////////////////////////
    // Instance variables
    ///////////////////////////////////////////////////////////////////////
    viewUtils: { value: null, writable: true },
    snapManager: { value: null },
    ElementPlanes : { value: null, writable: true },

    // the drawing surface (a canvas)
    _drawingSurfaceElt : { value: null, writable: true },
    _drawingContext : { value: null, writable: true },

    // color to draw the lines
    _lineColor : { value: "black", writable: true},

    // define a stack for quickly setting graphics states and restoring them
    _stateArray : { value: [], writable: true },

    // save references to the grid lines for quick redraw
    _gridLineArray : {value: [], writable: true },

    // state for moveTo, lineTo
    _curPt : { value: null, writable: true },
    _curVis : { value: null, writable: true },

    // the element that defines the coordinate system for the displayed lines
    _sourceSpaceElt  : { value: null, writable: true },

    // maintain a list of objects to hide against
    _eltArray : {value: [], writable: true },

    // maintain a list of the planes to test against
    _planesArray : {value: [], writable: true },

    // the working plane.
    // a grid may be drawn aligned with this working plane
    _workingPlane : { value: null, writable: true },

    // save some parameters about the grid.
    // these parameters are set when the grid is drawn
    _gridHorizontalSpacing : {value: 50, writable: true },
    _gridVerticalSpacing : {value: 50, writable: true },
    _gridHorizontalLineCount : {value:10, writable: true },
    _gridVerticalLineCount : {value:0, writable: true },
    _gridOrigin : {value: null, writable: true },

    drawXY : {value: false, writable: true },
    drawXZ : {value: false, writable: true },
    drawYZ : {value: false, writable: true },

    drawElementN : {value: false, writable: true },

    _selectionCtr : {value: null, writable: true },

    // Properties that require element planes to be updated
    _updatePlaneProps : {value: ["matrix", "left", "top", "width", "height", "border", "border-width", "border-style", "-webkit-transform"], writable: false },
    _recalculateScrollOffsets : { value: false },

    ///////////////////////////////////////////////////////////////////////
    // Property accessors
    ///////////////////////////////////////////////////////////////////////
    setDrawingSurfaceElement : { value: function( s ) {  this._drawingSurfaceElt = s;  if (s)  this._drawingContext = s.getContext("2d");     }},
    getDrawingSurfaceElement : { value: function()          {  return this._drawingSurfaceElt;      }},

    getDrawingContext : { value: function()            {  return this._drawingContext;            }},

    setSourceSpaceElement : { value: function(ss)          {  this._sourceSpaceElt = ss;           }},
    getSourceSpaceElement : { value: function()            {  return this._sourceSpaceElt;         }},

    getWorkingPlane : { value: function()            {  return this._workingPlane;           }},
    setWorkingPlane : { value: function (wp)            { this._workingPlane = wp;                }},

    getGridHorizontalSpacing : { value: function()    {  return this._gridHorizontalSpacing;        }},
    getGridVerticalSpacing : { value: function()    {  return this._gridVerticalSpacing;        }},
    getGridHorizontalLineCount : { value: function()    {  return this._gridHorizontalLineCount;    }},
    getGridVerticalLineCount : { value: function()    {  return this._gridVerticalLineCount;    }},
    getGridOrigin : { value: function()    {  return this._gridOrigin.slice(0);            }},

    isDrawingGrid : { value: function()            {  return this.drawXY || this.drawYZ || this.drawXZ;    }},
    isDrawingElementNormal : { value: function()            {  return this.drawElementN    }},

    getLineColor : { value: function()            {  return this._lineColor;                    }},
    setLineColor : { value: function( color )        {  this._lineColor = color;                    }},

    getLineWidth : { value: function()            {  return this._drawingContext.lineWidth;    }},
    setLineWidth : { value: function( w )            {  this._drawingContext.lineWidth = w;        }},


    initialize: {
        value: function() {
            this._gridOrigin = [0,0];    // 2D plane space point

            this.eventManager.addEventListener("elementAdded", this, false);
            this.eventManager.addEventListener("elementsRemoved", this, false);
            this.eventManager.addEventListener("elementChange", this, false);
            this.eventManager.addEventListener("elementChanging", this, false);
            this.eventManager.addEventListener("elementReplaced", this, false);
        }
    },

    initializeFromDocument:{
        value:function(adjustScrollOffsets, useStageValues){
            var i,
                documentRootChildren = this.application.ninja.currentDocument.model.views.design.getLiveNodeList(true),
                stage = this.application.ninja.stage,
                len = documentRootChildren.length;
            //initialize with current document
            this._eltArray = [];
            this._planesArray = [];
            this.setDrawingSurfaceElement(stage.gridCanvas);
            this.setSourceSpaceElement( this.application.ninja.currentDocument.model.documentRoot);
            this.setWorkingPlane( [0,0,1,0] );

            //Loop through all the top-level children of the current document and call drawUtils.addElement on them
            if(len > 0) {
                var initL = 0,
                    initT = 0,
                    minLeft = 0,
                    minTop = 0,
                    docLeft = stage.documentOffsetLeft,
                    docTop = stage.documentOffsetTop,
                    l,
                    t,
                    plane,
                    elt;
                if(useStageValues) {
                    initL = stage.userPaddingLeft;
                    initT = stage.userPaddingTop;
                    minLeft = stage.templateLeft;
                    minTop = stage.templateTop;
                    this._recalculateScrollOffsets = false;
                }
                for(i=0; i<len; i++) {
                    elt = documentRootChildren[i];
                    plane = this.addElement(elt);
                    if(adjustScrollOffsets) {
                        l = plane._rect.m_left - docLeft;
                        t = plane._rect.m_top - docTop;
                        if(l < minLeft) {
                            minLeft = l;
                            stage.minLeftElement = elt;
                        }
                        if(t < minTop) {
                            minTop = t;
                            stage.minTopElement = elt;
                        }
                    }
                }
                if(minLeft !== initL) {
                    stage.userPaddingLeft = (minLeft < 0) ? minLeft : 0;
                }
                if(minTop !== initT) {
                    stage.userPaddingTop = (minTop < 0) ? minTop : 0;
                }
            }
        }
    },

    handleElementAdded: {
        value: function(event) {
            var elements = event.detail;

            if(Array.isArray(elements)) {
                elements.forEach(function(element) {
                    this.addElement(element);
                }, this);
            } else {
                this.addElement(elements);
            }

            // Redraw stage only once after all addition is completed
            var stage = this.application.ninja.stage;
            stage.drawLayout = true;
            stage.updatePlanes = true;
            stage.draw3DInfo = true;
            stage.needsDrawSelection = true;
        }
    },

    handleElementsRemoved: {
        value: function(event) {
            var elements = event.detail;

            if(Array.isArray(elements)) {
                elements = Array.prototype.slice.call(elements, 0);
                elements.forEach(function(element) {
                    this.removeElement(element);
                }, this);
            } else {
                this.removeElement(elements);
            }

            // Redraw stage only once after all deletion is completed
            var stage = this.application.ninja.stage;
            stage.drawLayout = true;
            stage.updatePlanes = true;
            stage.draw3DInfo = true;
            stage.needsDrawSelection = true;
        }
    },

    handleElementReplaced: {
        value: function(event) {
            var oldElement = event.detail.data.oldChild;
            var newElement = event.detail.data.newChild;

            // check if we already know about this object
            var n = this._eltArray.length,
                plane;
            for (var i=0;  i<n;  i++) {
                if (oldElement === this._eltArray[i]) {
                    this._eltArray[i] = newElement;
                    plane = this._planesArray[i];
                    break;
                }
            }

            if(!plane) {
                this._eltArray.push( newElement );
                plane = Object.create(this.ElementPlanes, {});
                this._planesArray.push( plane );
            }

            plane.setElement( newElement );
            plane.init();
            newElement.elementModel.props3D.elementPlane = plane;
        }
    },

    _shouldUpdatePlanes: {
        value: function(props) {
            if(!props) {
                return false;
            } else if (typeof props === "string") {
                return (this._updatePlaneProps.indexOf(props) !== -1);
            }

            for (var p in props) {
                if(this._updatePlaneProps.indexOf(p) !== -1) {
                    return true;
                }
            }

            return false;
        }
    },

    // TODO - Check why handleElementChange is being fired before handleAddElement
    handleElementChange: {
        value: function(event) {
            this._elementChangeHelper(event, false);
        }
    },

    handleElementChanging: {
        value: function(event) {
            this._elementChangeHelper(event, true);
        }
    },

    _elementChangeHelper: {
        value: function(event, isChanging) {
            if(!event.detail || !event.detail.data) {
                return;
            }
            var els = event.detail.data.els;
            if(els && this._shouldUpdatePlanes(event.detail.data.prop)) {
                var len = els.length,
                    stage = this.application.ninja.stage,
                    minLeft = stage.userPaddingLeft,
                    minTop = stage.userPaddingTop,
                    docLeft = stage.userContentLeft,
                    docTop = stage.userContentTop,
                    l,
                    t,
                    plane,
                    changed = false,
                    elt,
                    eltModel,
                    adjustStagePadding = !isChanging || (event.detail.data.prop !== "matrix");
                for(var i=0; i < len; i++) {
                    elt = els[i];
                    eltModel = elt.elementModel;
                    eltModel.setProperty("offsetCache", false);

                    if(eltModel.pi !== "bodyPi") {
                        if(isChanging) {
                            eltModel.props3D.matrix3d = null;
                        } else {
                            eltModel.props3D.init(elt, false);
                        }
                    }
                    plane = elt.elementModel.props3D.elementPlane;
                    if(plane) {
                        plane.init();
                        if(adjustStagePadding) {
                            l = plane._rect.m_left - docLeft;
                            t = plane._rect.m_top - docTop;
                            if(l < minLeft) {
                                minLeft = l;
                                stage.minLeftElement = elt;
                            } else if((elt === stage.minLeftElement) && (l > minLeft)) {
                                this._recalculateScrollOffsets = true;
                            }

                            if(t < minTop) {
                                minTop = t;
                                stage.minTopElement = elt;
                            } else if((elt === stage.minTopElement) && (t > minTop)) {
                                this._recalculateScrollOffsets = true;
                            }
                        }
                    }
                }

                if(adjustStagePadding) {
                    if(this._recalculateScrollOffsets && !isChanging) {
                        this.initializeFromDocument(true, true);
                        changed = true;
                    } else {
                        if(minLeft !== stage.userPaddingLeft) {
                            stage.userPaddingLeft = minLeft;
                            changed = true;
                        }
                        if(minTop !== stage.userPaddingTop) {
                            stage.userPaddingTop = minTop;
                            changed = true;
                        }
                    }
                }

                if(!changed) {
                    // If we didn't already set userPaddingTop or userPaddingLeft, force stage to redraw
                    //this.snapManager._isCacheInvalid = true;
//                    stage.draw3DInfo = true;
                    stage.needsDraw = true;
                }

                // TODO - Remove this once all stage drawing is consolidated into a single draw cycle
                if(!isChanging && this.application.ninja.toolsData.selectedToolInstance.captureSelectionDrawn) {
                    this.application.ninja.toolsData.selectedToolInstance.captureSelectionDrawn(null);
                }
            }
        }
    },

    ///////////////////////////////////////////////////////////////////////
    // Methods
    ///////////////////////////////////////////////////////////////////////

    addElement: {
        value: function( elt ) {
            // check if we already know about this object
            var n = this._eltArray.length;
            for (var i=0;  i<n;  i++) {
                if (elt == this._eltArray[i]) {
                    return;
                }
            }

            this._eltArray.push( elt );

            // create the planes for this element
            var plane = Object.create(this.ElementPlanes, {});
            plane.setElement( elt );
            plane.init();
            this._planesArray.push( plane );
            elt.elementModel.props3D.elementPlane = plane;
            return plane;
        }
    },

    removeElement: {
        value: function(element) {
            // check if object exists
            var _elements = this._eltArray.length;
            for (var i=0;  i < _elements;  i++) {
                if (element === this._eltArray[i]) {
                    // First remove the planes for this element
                    this._planesArray.splice(i, 1);
                    // Then remove the element
                    this._eltArray.splice(i, 1);

                    // TODO - May need to delete props3D and elementPlane as well
                    return;
                }
            }
        }
    },

    clear : {
        value: function() {
            if (this._drawingContext)
                this._drawingContext.clearRect( 0, 0, this._drawingSurfaceElt.width,  this._drawingSurfaceElt.height );
        }
    },

    updatePlanes : {
        value: function() {
            var n = this._planesArray.length;

            for (var i=0;  i<n;  i++)
            {
                var plane = this._planesArray[i];
                plane.init();
            }
        }
    },

    getVisibilityAtPoint:
    {
        value: function( targetPt )
        {
            // duplicate the point and make sure it has the correct dimension (2)
            var pt = targetPt.slice(0);
            while (pt.length > 3)  pt.pop();

            var z = pt[2];
            var n = this._planesArray.length;
            var vis = 0;
            for (var i=0;  i<n;  i++)
            {
                var plane = this._planesArray[i];

                // ignore if the point is in front of the polygon
                if (z > plane.getZMax())  continue;

                // test for containment in the polygon bounds
                var contain = MathUtils.boundaryContainsPoint( plane.getBoundaryPoints(),  pt,  plane.isBackFacing() );
                if (contain == MathUtils.OUTSIDE)  continue;
                if (contain == MathUtils.ON)       continue;

                // shoot a ray from the point in the +Z direction to get the z value of the plane
                var vec = [0,0,1];
                var planeEq = plane.getPlaneEq();
                var ptOnPlane = MathUtils.vecIntersectPlane( pt, vec, planeEq );
                if (ptOnPlane)
                {
                    // in keeping with the convention that a point "on" a face is outside the element,
                    // check that case.
                    //if (MathUtils.fpCmp(pt[2], ptOnPlane[2]) == 0)  continue;

                    // if the point is behind the plane, increase the visibility
                    if (MathUtils.fpCmp(pt[2],ptOnPlane[2]) <= 0)  vis++;
                }
            }

            return vis;
        }
    },

    moveTo : {
        value: function( pt ) {
            if (this._sourceSpaceElt)
                pt = this.viewUtils.localToGlobal( pt, this._sourceSpaceElt );

            this._curPt = pt.slice(0);
            this._curVis = this.getVisibilityAtPoint( pt );
        }
    },

    lineTo :
    {
        value: function( pt )
        {
            if (this._sourceSpaceElt)
                pt = this.viewUtils.localToGlobal( pt, this._sourceSpaceElt );

            var line = Object.create(StageLine, {});
            line.setPoints( this._curPt, pt );
            line.setVisibility( this._curVis );

            // find all the plane intersections
            this.getLineIntersections( line );

            // draw the line
            this._curVis = this.drawIntersectedLine( line, this._drawingContext );
            this._curPt = pt.slice(0);
        }
    },


    drawLine :
    {
        value: function( pt0, pt1 )
        {
            if (this._drawingContext)
            {
                // transform the points from local object space to world space
                if (this._sourceSpaceElt)
                {
                    pt0 = this.viewUtils.localToGlobal( pt0, this._sourceSpaceElt );
                    pt1 = this.viewUtils.localToGlobal( pt1, this._sourceSpaceElt );
                }

                // create the line structure
                var line = Object.create(StageLine, {});
                line.setPoints( pt0, pt1 );

                // find all the plane intersections
                this.getLineIntersections( line );

                // get the starting visibility
                var vis = this.getVisibilityAtPoint( pt0 );
                line.setVisibility( vis );

                // draw the line
                this._curVis = this.drawIntersectedLine( line, this._drawingContext );
            }
        }
    },

    drawIntersectedLine :
    {
        value: function( line )
        {
            this._drawingContext.strokeStyle = this._lineColor;
            this._drawingContext.beginPath();

            //  get the 2 enpoints of the line
            var pt0 = line.getPoint0(),
                pt1 = line.getPoint1();

            // find the visibility at the start point
            var vis = line.getVisibility();
            if (vis == 0)
            {
                this._drawingContext.strokeStyle = this._lineColor;
                this._drawingContext.beginPath();
                this._drawingContext.moveTo( pt0[0], pt0[1] );
            }

            // go through each intersection
            var n = line.getIntersectionCount();
            var t = 0.0;
            var iRec = line.getIntersectionList();
            for (var i=0;  i<n;  i++)
            {
                var tNext = iRec.getT();
                var dv = iRec.getDeltaVis();

                var tPt = MathUtils.interpolateLine3D( pt0, pt1, tNext );

                if (vis == 0)
                {
                    this._drawingContext.lineTo( tPt[0], tPt[1] );
                    this._drawingContext.closePath();
                    this._drawingContext.stroke();
                }
                else
                {
                    this._drawingContext.beginPath();
                    this._drawingContext.moveTo( tPt[0], tPt[1] );
                }

                vis += dv;
                iRec = iRec.getNext();
            }

            // handle the end of the line
            if (vis == 0)
            {
                this._drawingContext.lineTo( pt1[0], pt1[1] );

                // draw the line
                this._drawingContext.closePath();
                this._drawingContext.stroke();
            }

            return vis;
        }
    },

    getLineIntersections:
    {
        value: function( line )
        {
            // clip the line against all polygons in the scene
            var n = this._planesArray.length;
            for (var i=0;  i<n;  i++)
            {
                var plane = this._planesArray[i];
                line.intersectWithPlane( plane );
            }
        }
    },

    getPlaneToWorldMatrix:
    {
        value: function (normal, ptOnPlane)
        {
            // 3 coordinate axes for the plane
            var zAxis = normal.slice(0);
            MathUtils.makeDimension3(zAxis);
            zAxis = vecUtils.vecNormalize(3, zAxis);

            // special case the coordinate axes followed by general case
            var tmp;
            var xAxis, yAxis;
            if (MathUtils.fpCmp(Math.abs(zAxis[0]), 1.0) == 0) {
                yAxis = [0, 1, 0];
                xAxis = vecUtils.vecCross(3, yAxis, zAxis);
            }
            else if (MathUtils.fpCmp(Math.abs(zAxis[1]), 1.0) == 0) {
                yAxis = [0, 0, 1];
                //xAxis = yAxis.cross(zAxis);
                xAxis = vecUtils.vecCross(3, yAxis, zAxis );
            }
            else if (MathUtils.fpCmp(Math.abs(zAxis[2]), 1.0) == 0) {
                yAxis = [0, 1, 0];
                //xAxis = yAxis.cross(zAxis);
                xAxis = vecUtils.vecCross(3, yAxis, zAxis );
            }
            else
            {
                if (Math.abs(zAxis[0]) < Math.abs(zAxis[1]))
                {
                    if (Math.abs(zAxis[0]) < Math.abs(zAxis[2]))
                        tmp = [1, 0, 0];
                    else
                        tmp = [0, 0, 1];
                }
                else
                {
                    if (Math.abs(zAxis[1]) < Math.abs(zAxis[2]))
                        tmp = [0, 1, 0];
                    else
                        tmp = [0, 0, 1];
                }
                //xAxis = tmp.cross(zAxis);
                xAxis = vecUtils.vecCross(3, tmp, zAxis);
                //yAxis = zAxis.cross(xAxis);
                yAxis = vecUtils.vecCross(3, zAxis, xAxis);
            }

            // create the matrix
            var mat = Matrix.create(
                [
                    [xAxis[0], yAxis[0], zAxis[0], ptOnPlane[0]],
                    [xAxis[1], yAxis[1], zAxis[1], ptOnPlane[1]],
                    [xAxis[2], yAxis[2], zAxis[2], ptOnPlane[2]],
                    [0, 0, 0, 1]
                ]
            );

            return mat;
        }
    },

    clearDefaultGridOffset : {
        value: function() {
            this.setDefaultGridOffset( [0,0,0] );
        }
    },

    drawWorkingPlane:
    {
        value: function ()
        {
            this.application.ninja.stage.clearGridCanvas();
            this.drawStageOutline();
            if (this.isDrawingGrid()) {
                var saveContext = this.getDrawingSurfaceElement();
                this.setDrawingSurfaceElement(this.application.ninja.stage.gridCanvas);

                // 3 coordinate axes for the plane
                var zAxis = [this._workingPlane[0], this._workingPlane[1], this._workingPlane[2]];

                // get a point that lies on the plane
                var ptOnPlane = MathUtils.getPointOnPlane(this._workingPlane);

                // define the grid parameters
                var width = this.snapManager.getStageWidth(),
                    height = this.snapManager.getStageHeight(),
                    nLines = 10;

                // get a matrix from working plane space to the world
                var mat = this.getPlaneToWorldMatrix(zAxis, ptOnPlane);
                var tMat = Matrix.Translation( [0.5*width, 0.5*height, 0] );
                //mat = tMat.multiply(mat);
                glmat4.multiply( tMat, mat, mat);

                // the positioning of the grid may depend on the view direction.
                var stage = this.snapManager.getStage();
                var viewMat = this.viewUtils.getMatrixFromElement(stage);
                var viewDir = [viewMat[8], viewMat[9], viewMat[10]];

                var dx, dy, delta, pt0, pt1;
                dx = this._gridVerticalSpacing;
                dy = this._gridHorizontalSpacing;
                nLines = Math.floor(width / dx) + 1;
                if (MathUtils.fpCmp(dx*nLines,width) == 0)  nLines--;

                var saveColor = this._lineColor;
                var saveLineWidth = this._drawingContext.lineWidth;

                // reset the line cache
                this._gridLineArray = new Array();

                if (this.drawXY) this._lineColor = "red";
                if (this.drawYZ) this._lineColor = "green";
                if (this.drawXZ) this._lineColor = "blue";
                this._drawingContext.lineWidth = 0.25;

                // get the two endpoints of the first line with constant X
                pt0 = [-width / 2.0, height / 2.0, 0];
                pt1 = [-width / 2.0, -height / 2.0, 0];
                delta = [dx, 0, 0];

                this._gridVerticalLineCount = nLines;
                this._gridOrigin = pt1.slice(0);

                // draw the lines with constant X
                this.drawGridLines(pt0, pt1, delta, mat, nLines);

                // get the two endpoints of the first line with constant Y
                pt0 = [-width / 2.0, -height / 2.0, 0];
                pt1 = [width / 2.0, -height / 2.0, 0];

                delta = [0, dy, 0];
                nLines = Math.floor(height / dy) + 1;
                if (MathUtils.fpCmp(dy*nLines,height) == 0)  nLines--;

                this._gridHorizontalLineCount = nLines;

                // draw the lines with constant Y
                this.drawGridLines(pt0, pt1, delta, mat, nLines);

                this._lineColor = saveColor;
                this._drawingContext.lineWidth = saveLineWidth;

                // draw the lines
                this.redrawGridLines();

                this.setDrawingSurfaceElement(saveContext);
            }
            this.draw3DCompass();
        }
    },

    drawGridLines : {
        value: function (pt0, pt1, delta, mat, nLines) {
            // get the drawing context
            if (this._drawingContext) {
                var p0 = pt0.slice(0), p1 = pt1.slice(0); // duplicate so we don't change the input.
                p0[3] = 1; p1[3] = 1;
                var d = delta.slice(0); d[3] = 1;

                //var lineArray = new Array;
                var offset = this.viewUtils.getElementOffset(this._sourceSpaceElt);
                offset[2] = 0;
                this.viewUtils.setViewportObj(this._sourceSpaceElt);
                var sourceSpaceMat = this.viewUtils.getLocalToGlobalMatrix( this._sourceSpaceElt );
                for (var i = 0; i < nLines; i++) {
                    // transform the points from working plane space to world space
                    var t0 = glmat4.multiplyVec3( mat, p0, [] ),
                        t1 = glmat4.multiplyVec3( mat, p1, [] );

                    // transform from world space to global screen space
                    if (this._sourceSpaceElt) {
                        t0 = this.viewUtils.localToGlobal2(t0, sourceSpaceMat);
                        t1 = this.viewUtils.localToGlobal2(t1, sourceSpaceMat);
                    }

                    // create a line from the endpoints
                    var line = Object.create(StageLine, {});
                    line.setPoints(t0, t1);
                    this._gridLineArray.push(line);

                    // find all the intersections
                    this.getLineIntersections(line);

                    // get the visibility at the start point
                    var vis = this.getVisibilityAtPoint(line.getPoint0());
                    line.setVisibility(vis);

                    // increment the points to the next position
                    p0 = vecUtils.vecAdd(4, p0, d); p0[3] = 1.0;
                    p1 = vecUtils.vecAdd(4, p1, d); p1[3] = 1.0;
                }
            }
        }
    },

    refreshDisplay : {
        value: function() {
            this.redrawGridLines();
            this.snapManager.drawLastHit();
        }
    },

    pushState : {
        value: function() {
            var obj = new Object();
            obj._lineColor = this._lineColor;
            obj._lineWidth = this._drawingContext.lineWidth;

            this._stateArray.push( obj );
        }
    },

    popState  : {
        value: function() {
            if (this._stateArray.length <= 0)
            {
                throw new Error( "state stack underflow" );
                return;
            }

            var obj = this._stateArray.pop();
            this._lineColor = obj._lineColor;
            this._drawingContext.lineWidth = obj._lineWidth;
            this._drawingContext.strokeStyle = obj._lineColor;
        }
    },


    redrawGridLines : {
        value: function() {
            if (!this.isDrawingGrid()) return;

            this.pushState();

            if (this.drawXY) this._lineColor = "red";
            if (this.drawYZ) this._lineColor = "green";
            if (this.drawXZ) this._lineColor = "blue";
            this._drawingContext.lineWidth = 0.25;

            // draw the lines
            var line,
                nLines = this._gridLineArray.length;

            for (var i = 0; i < nLines; i++) {
                line = this._gridLineArray[i];
                this.drawIntersectedLine(line, this._drawingContext);
            }

            this.popState();
        }
    },

    /**
     * Draws selection highlight and reg. point for a given element
     */
    drawElementBoundingBox: {
        value: function(elt, context, stageInfo) {
            this.viewUtils.pushViewportObj( elt );
            var bounds3D = this.viewUtils.getElementViewBounds3D( elt );

            var tmpMat = this.viewUtils.getLocalToGlobalMatrix( elt );
            for (var j=0;  j<4;  j++) {
                var localPt = bounds3D[j];
                var tmpPt = this.viewUtils.localToGlobal2(localPt, tmpMat);

                if(stageInfo) {
                    tmpPt = vecUtils.vecScale(3, tmpPt, stageInfo.zoomFactor);
                    tmpPt[0] += stageInfo.scrollLeft;
                    tmpPt[1] += stageInfo.scrollTop;
                }
                bounds3D[j] = tmpPt;
            }
            this.viewUtils.popViewportObj();

            // draw it
            context.beginPath();
            context.moveTo( bounds3D[3][0] + 0.5 ,  bounds3D[3][1] - 0.5 );

            // This more granular approach lets us specify different gaps for the selection around the element
            context.lineTo( bounds3D[0][0] - 0.5 ,  bounds3D[0][1] - 0.5 );
            context.lineTo( bounds3D[1][0] - 0.5 ,  bounds3D[1][1] + 0.5 );
            context.lineTo( bounds3D[2][0] + 0.5  ,  bounds3D[2][1] + 0.5 );
            context.lineTo( bounds3D[3][0] + 0.5  ,  bounds3D[3][1] + 0.5 );

            context.closePath();
            context.stroke();

            return bounds3D;
        }
    },

    drawSelectionBounds : {
        value: function(eltArray, drawSelectionCube) {
            this._selectionCtr = null;
            var len = eltArray.length,
                i,
                j,
                bounds,
                bounds3D,
                pt,
                tmpPt,
                ssMat,
                ssMatInv,
                elt,
                dir,
                ctr,
                stageInfo,
                stageComponent = this.application.ninja.stage,
                context;
            
            if (len === 0)  return;
            context = stageComponent.context;
            if(!context) return;
            // TODO - Get values from app settings
            context.strokeStyle = "#46a1ff";
            context.lineWidth = 1;

            // for drawing, we need scrollLeft, scrollTop, and zoom factor from the stage
            var zoomFactor = stageComponent.zoomFactor;
            if(zoomFactor !== 1) {
                stageInfo = {zoomFactor: zoomFactor, scrollLeft: stageComponent._scrollLeft*(zoomFactor - 1), scrollTop: stageComponent._scrollTop*(zoomFactor - 1)};
            }

            // handle the single element case
            // TODO - Currently, the stage draws its own selection bounds for single selection case
            if (len === 1)
            {
//                console.log( "single selection" );
                elt = eltArray[0];
                bounds3D = this.drawElementBoundingBox(elt, context, stageInfo);
                this._selectionCtr = [0,0,0];
                dir = vecUtils.vecSubtract(2, bounds3D[1], bounds3D[3]);
                ctr = vecUtils.vecNormalize(2, dir, vecUtils.vecDist(2, bounds3D[1], bounds3D[3])/2);

                this._selectionCtr[0] += ctr[0] - this.application.ninja.stage.userContentLeft;
                this._selectionCtr[1] += ctr[1] - this.application.ninja.stage.userContentTop;
            }
            else
            {
                // get the plane from the first element to compare against the other elements
                var dot;
                var flat = true;
                var plane = this.viewUtils.getUnprojectedElementPlane( eltArray[0] );
                for (i=1;  i<len;  i++)
                {
                    elt = eltArray[i];
                    var plane2 = this.viewUtils.getUnprojectedElementPlane( elt );
                    dot = Math.abs( MathUtils.dot3(plane,plane2) );
                    if (MathUtils.fpCmp(dot, 1) != 0)
                    {
                        flat = false;
                        break;
                    }

                    // check the offset
                    var d = plane[3],  d2 = plane2[3];
                    if (MathUtils.fpCmp(d,d2) != 0)
                    {
                        flat = false;
                        break;
                    }
                }

                // if all of the planes are aligned, check if they are aligned with the view direction
                if (flat)
                {
                    var stage = this.application.ninja.currentDocument.model.documentRoot;
                    var stageMat = this.viewUtils.getMatrixFromElement(stage);
                    var viewDir = [ stageMat[8], stageMat[9], stageMat[10] ];
                    viewDir = vecUtils.vecNormalize( 3, viewDir );
                    dot = Math.abs( MathUtils.dot3(plane,viewDir) );
                    if (MathUtils.fpCmp(dot, 1) != 0)
                        flat = false;
                }
//                console.log( "drawSelectionBounds, flat: " + flat );

                // if all the elements share the same plane, draw the 2D rectangle
                if (flat)
                {
                    // make a 2D rectangle on the plane
                    var rect;
                    for (i=0;  i<len;  i++)
                    {
                        elt = eltArray[i];

                        bounds = this.drawElementBoundingBox(elt, context, stageInfo);

                        if(drawSelectionCube) {
                            for (j=0;  j<4;  j++)
                            {
                                pt = bounds[j];
                                if (!rect)
                                {
                                    rect = Object.create(Rectangle, {});
                                    rect.setToPoint( pt )
                                }
                                else
                                {
                                    rect.unionPoint( pt );
                                }
                            }
                        }
                    }

                    if(rect) {
                        context.lineWidth = 2;
                        // draw the multi-selection rectangle
                        context.beginPath();

                        pt = MathUtils.makeDimension3(rect.getPoint(3));

                        bounds3D = [[0,0], [0,0], [0,0], [0,0]];
                        this._selectionCtr = pt.slice(0);

                        context.moveTo( pt[0],  pt[1] );
                        for (i=0;  i<4;  i++) {
                            pt = rect.getPoint(i);
                            context.lineTo( pt[0],  pt[1] );
                            bounds3D[i] = pt.slice(0);
                        }
                        context.closePath();
                        context.stroke();

                        dir = vecUtils.vecSubtract(2, bounds3D[1], bounds3D[3]);
                        ctr = vecUtils.vecNormalize(2, dir, vecUtils.vecDist(2, bounds3D[1], bounds3D[3])/2);

                        this._selectionCtr[0] += ctr[0] - this.application.ninja.stage.userContentLeft;
                        this._selectionCtr[1] += ctr[1] - this.application.ninja.stage.userContentTop;
                    }
                }
                else
                {
                    if(drawSelectionCube) {
                        var minPt, maxPt, x, y, z,
                            saveRoot = this.viewUtils.getRootElement();

                        // we set the root to "the world".
                        this.viewUtils.setRootElement( this.viewUtils.getStageElement() );
                        ssMat = this.viewUtils.getLocalToGlobalMatrix( this._sourceSpaceElt );  // stageToGlobal
                        ssMatInv = glmat4.inverse(ssMat, []);   // globalToStageWorld
                        this.viewUtils.setRootElement( saveRoot );

                        for (i=0;  i<len;  i++) {
                            elt = eltArray[i];
                            bounds = this.drawElementBoundingBox(elt, context, stageInfo);
                            for (j=0;  j<4;  j++) {
                                pt = MathUtils.transformAndDivideHomogeneousPoint( bounds[j], ssMatInv );

                                if (!minPt) {
                                    minPt = pt.slice(0);
                                    maxPt = pt.slice(0);
                                } else {
                                    x = pt[0];
                                    y = pt[1];
                                    z = pt[2];

                                    if (x < minPt[0])    minPt[0] = x;
                                    if (x > maxPt[0])    maxPt[0] = x;

                                    if (y < minPt[1])    minPt[1] = y;
                                    if (y > maxPt[1])    maxPt[1] = y;

                                    if (z < minPt[2])    minPt[2] = z;
                                    if (z > maxPt[2])    maxPt[2] = z;
                                }
                            }
                        }

                        context.beginPath();
                        var x0 = minPt[0],  y0 = minPt[1],  z0 = minPt[2],
                            x1 = maxPt[0],  y1 = maxPt[1],  z1 = maxPt[2];

                        var stageWorldCtr = [ 0.5*(x0 + x1),  0.5*(y0 + y1), 0.5*(z0 + z1) ];
                        this._selectionCtr = MathUtils.transformAndDivideHomogeneousPoint( stageWorldCtr, ssMat );

                        // get the 8 corners of the parallelpiped in world space
                        var wc = new Array();   // wc == world cube
                        wc.push(  this.viewUtils.localToGlobal2( [x0,y0,z1], ssMat ) );
                        wc.push(  this.viewUtils.localToGlobal2( [x0,y1,z1], ssMat ) );
                        wc.push(  this.viewUtils.localToGlobal2( [x1,y1,z1], ssMat ) );
                        wc.push(  this.viewUtils.localToGlobal2( [x1,y0,z1], ssMat ) );
                        wc.push(  this.viewUtils.localToGlobal2( [x0,y0,z0], ssMat ) );
                        wc.push(  this.viewUtils.localToGlobal2( [x0,y1,z0], ssMat ) );
                        wc.push(  this.viewUtils.localToGlobal2( [x1,y1,z0], ssMat ) );
                        wc.push(  this.viewUtils.localToGlobal2( [x1,y0,z0], ssMat ) );

                        // determine the signs of the normals of the faces relative to the view direction.
                        var front    = -MathUtils.fpSign( vecUtils.vecCross(3, vecUtils.vecSubtract(3,wc[2],wc[1]), vecUtils.vecSubtract(3,wc[0],wc[1]))[2] ),
                            right   = -MathUtils.fpSign( vecUtils.vecCross(3, vecUtils.vecSubtract(3,wc[6],wc[2]), vecUtils.vecSubtract(3,wc[3],wc[2]))[2] ),
                            back    = -MathUtils.fpSign( vecUtils.vecCross(3, vecUtils.vecSubtract(3,wc[5],wc[6]), vecUtils.vecSubtract(3,wc[7],wc[6]))[2] ),
                            left    = -MathUtils.fpSign( vecUtils.vecCross(3, vecUtils.vecSubtract(3,wc[1],wc[5]), vecUtils.vecSubtract(3,wc[4],wc[5]))[2] ),
                            top     = -MathUtils.fpSign( vecUtils.vecCross(3, vecUtils.vecSubtract(3,wc[3],wc[0]), vecUtils.vecSubtract(3,wc[4],wc[0]))[2] ),
                            bottom  = -MathUtils.fpSign( vecUtils.vecCross(3, vecUtils.vecSubtract(3,wc[5],wc[1]), vecUtils.vecSubtract(3,wc[2],wc[1]))[2] );

                        // draw the side faces
                        var p;

                        //context.strokeStyle = ((front > 0) || (right > 0)) ? dark : light;  context.beginPath();
                        if ((front > 0) || (right > 0)) {
                            context.beginPath();
                            p = this.viewUtils.localToGlobal2( [x1, y0, z1], ssMat );  context.moveTo( p[0], p[1] );
                            p = this.viewUtils.localToGlobal2( [x1, y1, z1], ssMat );  context.lineTo( p[0], p[1] );
                            context.closePath();  context.stroke();
                        }

                        //context.strokeStyle = ((right > 0) || (back > 0)) ? dark : light;  context.beginPath();
                        if ((right > 0) || (back > 0)) {
                            context.beginPath();
                            p = this.viewUtils.localToGlobal2( [x1, y0, z0], ssMat );  context.moveTo( p[0], p[1] );
                            p = this.viewUtils.localToGlobal2( [x1, y1, z0], ssMat );  context.lineTo( p[0], p[1] );
                            context.closePath();  context.stroke();
                        }

                        //context.strokeStyle = ((back > 0) || (left > 0)) ? dark : light;  context.beginPath();
                        if ((back > 0) || (left > 0)) {
                            context.beginPath();
                            p = this.viewUtils.localToGlobal2( [x0, y0, z0], ssMat );  context.moveTo( p[0], p[1] );
                            p = this.viewUtils.localToGlobal2( [x0, y1, z0], ssMat );  context.lineTo( p[0], p[1] );
                            context.closePath();  context.stroke();
                        }

                        //context.strokeStyle = ((left > 0) || (front > 0)) ? dark : light;  context.beginPath();
                        if ((left > 0) || (front > 0)) {
                            context.beginPath();
                            p = this.viewUtils.localToGlobal2( [x0, y0, z1], ssMat );  context.moveTo( p[0], p[1] );
                            p = this.viewUtils.localToGlobal2( [x0, y1, z1], ssMat );  context.lineTo( p[0], p[1] );
                            context.closePath();  context.stroke();
                        }

                        // draw the top and bottom faces
                        //context.strokeStyle = ((front > 0) || (top > 0)) ? dark : light;  context.beginPath();
                        if ((front > 0) || (top > 0)) {
                            context.beginPath();
                            p = this.viewUtils.localToGlobal2( [x0, y0, z1], ssMat );  context.moveTo( p[0], p[1] );
                            p = this.viewUtils.localToGlobal2( [x1, y0, z1], ssMat );  context.lineTo( p[0], p[1] );
                            context.closePath();  context.stroke();
                        }

                        //context.strokeStyle = ((top > 0) || (back > 0)) ? dark : light;  context.beginPath();
                        if ((top > 0) || (back > 0)) {
                            context.beginPath();
                            p = this.viewUtils.localToGlobal2( [x0, y0, z0], ssMat );  context.moveTo( p[0], p[1] );
                            p = this.viewUtils.localToGlobal2( [x1, y0, z0], ssMat );  context.lineTo( p[0], p[1] );
                            context.closePath();  context.stroke();
                        }

                        //context.strokeStyle = ((back > 0) || (bottom > 0)) ? dark : light;  context.beginPath();
                        if ((back > 0) || (bottom > 0)) {
                            context.beginPath();
                            p = this.viewUtils.localToGlobal2( [x0, y1, z0], ssMat );  context.moveTo( p[0], p[1] );
                            p = this.viewUtils.localToGlobal2( [x1, y1, z0], ssMat );  context.lineTo( p[0], p[1] );
                            context.closePath();  context.stroke();
                        }

                        //context.strokeStyle = ((bottom > 0) || (front > 0)) ? dark : light;  context.beginPath();
                        if ((bottom > 0) || (front > 0)) {
                            context.beginPath();
                            p = this.viewUtils.localToGlobal2( [x0, y1, z1], ssMat );  context.moveTo( p[0], p[1] );
                            p = this.viewUtils.localToGlobal2( [x1, y1, z1], ssMat );  context.lineTo( p[0], p[1] );
                            context.closePath();  context.stroke();
                        }

                        // and the remaining lines - varying Z
                        if ((top > 0) || (right > 0)) {
                            context.beginPath();
                            p = this.viewUtils.localToGlobal2( [x1, y0, z0], ssMat );  context.moveTo( p[0], p[1] );
                            p = this.viewUtils.localToGlobal2( [x1, y0, z1], ssMat );  context.lineTo( p[0], p[1] );
                            context.closePath();  context.stroke();
                        }

                        //context.strokeStyle = ((right > 0) || (bottom > 0)) ? dark : light;  context.beginPath();
                        if ((right > 0) || (bottom > 0)) {
                            context.beginPath();
                            p = this.viewUtils.localToGlobal2( [x1, y1, z0], ssMat );  context.moveTo( p[0], p[1] );
                            p = this.viewUtils.localToGlobal2( [x1, y1, z1], ssMat );  context.lineTo( p[0], p[1] );
                            context.closePath();  context.stroke();
                        }

                        //context.strokeStyle = ((bottom > 0) || (left > 0)) ? dark : light;  context.beginPath();
                        if ((bottom > 0) || (left > 0)) {
                            context.beginPath();
                            p = this.viewUtils.localToGlobal2( [x0, y1, z0], ssMat );  context.moveTo( p[0], p[1] );
                            p = this.viewUtils.localToGlobal2( [x0, y1, z1], ssMat );  context.lineTo( p[0], p[1] );
                            context.closePath();  context.stroke();
                        }

                        //context.strokeStyle = ((left > 0) || (top > 0)) ? dark : light;  context.beginPath();
                        if ((left > 0) || (top > 0)) {
                            context.beginPath();
                            p = this.viewUtils.localToGlobal2( [x0, y0, z0], ssMat );  context.moveTo( p[0], p[1] );
                            p = this.viewUtils.localToGlobal2( [x0, y0, z1], ssMat );  context.lineTo( p[0], p[1] );
                            context.closePath();  context.stroke();
                        }
                    } else {
                        for (i=0;  i<len;  i++) {
                            elt = eltArray[i];
                            bounds = this.drawElementBoundingBox(elt, context, stageInfo);
                        }
                    }
                }
            }
        }
    },

    /* Currently, we are not drawing the element normal indicator. */
    drawElementNormal:
    {
        value: function( elt )
        {
            if (!this.isDrawingElementNormal()) return;

            // set the element to be the viewport object - temporarily
            this.viewUtils.pushViewportObj( elt );

            // save the source space object and set to the target object
            var saveSource = this._sourceSpaceElt;
            this._sourceSpaceElt = elt;

            // temporarily set the line color
            var saveColor = this._lineColor;
            this._lineColor = "blue";

            var base = this.viewUtils.getCenterOfProjection();
            base[2] = 1;   // Z - make it just off the plane to avoid numerical issues
            var zAxis = base.slice(0);
            zAxis[2] += 50;
            this.moveTo( base );
            this.lineTo( zAxis );

            // draw the arrowhead
            var headWidth = 6;
            var head = MathUtils.interpolateLine3D( base, zAxis, 0.7 );
            var p0 = head.slice(0);  p0[1] += headWidth;  this.drawLine( zAxis, p0 );
            var p1 = head.slice(0);  p1[0] += headWidth;  this.drawLine( zAxis, p1 );
            var p2 = head.slice(0);  p2[1] -= headWidth;  this.drawLine( zAxis, p2 );
            var p3 = head.slice(0);  p3[0] -= headWidth;  this.drawLine( zAxis, p3 );

            this.moveTo( p0 );
            this.lineTo( p1 );
            this.lineTo( p2 );
            this.lineTo( p3 );
            this.lineTo( p0 );

            // restore the state
            this.viewUtils.popViewportObj();
            this._lineColor = saveColor;
            this._sourceSpaceElt = saveSource;
        }
    },

    drawStageOutline : {
        value: function() {
//            console.log("drawStageOutline");
            var context = this.application.ninja.stage.gridContext;
            var stage = this.application.ninja.stage;
            var stageRoot = this.application.ninja.currentDocument.model.documentRoot;

            // draw an outline around the template body if stage has any transforms
            if(stage.currentDocument.model.views.design._template && !MathUtils.isIdentityMatrix(this.viewUtils.getMatrixFromElement(stageRoot))) {
                var saveContext = this.getDrawingSurfaceElement();
                this.setDrawingSurfaceElement(this.application.ninja.stage.gridCanvas);

                var stagePt = MathUtils.getPointOnPlane([0,0,1,0]);
                var stageMat = this.getPlaneToWorldMatrix([0,0,1], stagePt);
                var width = this.snapManager.getStageWidth(),
                    height = this.snapManager.getStageHeight(),
                    pt0 = [0, 0, 0],
                    pt1 = [0, height, 0],
                    delta = [width, 0, 0];

                this._gridLineArray.length = 0;
                this.drawGridLines(pt0, pt1, delta, stageMat, 2);

                pt0 = [0, 0, 0];
                pt1 = [width, 0, 0];
                delta = [0, height, 0];
                this.drawGridLines(pt0, pt1, delta, stageMat, 2);

                this._lineColor = "red";
                for (var i = 0; i < 4; i++) {
                    this.drawIntersectedLine(this._gridLineArray[i], this._drawingContext);
                }

                this.setDrawingSurfaceElement(saveContext);
            }

            // draw reference lines across origin
            var bounds3D = this.viewUtils.getElementBoundsInGlobal(stageRoot);
            var l = MathUtils.segSegIntersection2D(bounds3D[0], bounds3D[3], [0, 0, 0], [0, stage.canvas.height, 0], 0.1);
            if(!l) return;
            var r = MathUtils.segSegIntersection2D(bounds3D[0], bounds3D[3], [stage.canvas.width, 0, 0], [stage.canvas.width, stage.canvas.height, 0], 0.1);
            if(!r) return;

            var t = MathUtils.segSegIntersection2D(bounds3D[0], bounds3D[1], [0, 0, 0], [stage.canvas.width, 0, 0], 0.1);
            if(!t) return;
            var b = MathUtils.segSegIntersection2D(bounds3D[0], bounds3D[1], [0, stage.canvas.height, 0], [stage.canvas.width, stage.canvas.height, 0], 0.1);
            if(!b) return;

            context.save();
            context.strokeStyle = "#333";
            context.lineWidth = 0.5;

            context.beginPath();

            context.moveTo(l[0], l[1]);
            context.lineTo(r[0], r[1]);

            context.moveTo(t[0], t[1]);
            context.lineTo(b[0], b[1]);

            context.closePath();
            context.stroke();

            context.fillText("(0, 0)", bounds3D[0][0] + 4, bounds3D[0][1] - 6);
            context.restore();
        }
    },

    draw3DCompass : {
        value: function() {
//            console.log("draw3DCompass");
            var tmpCanvas = this.application.ninja.stage.layoutCanvas;
            var tmpStage = this.application.ninja.currentDocument.model.documentRoot;

            // save the source space object and set to the target object
            var saveSource = this._sourceSpaceElt;
            this._sourceSpaceElt = tmpStage;

            // temporarily set the line color
            var saveColor = this._lineColor;
            var saveLineWidth = this._lineWidth;

            var origLeft = 60;
            var origTop = tmpCanvas.height - 60;

            var mat = this.viewUtils.getMatrixFromElement( this._sourceSpaceElt );
            var tMat = Matrix.Translation([origLeft,origTop,0]);

            mat[12] = 0;
            mat[13] = 0;
            mat[14] = 0;

            //var resMat = tMat.multiply(mat);
            var resMat = glmat4.multiply( tMat, mat, [] );
            var origin = [0,0,0,1];

            var zoomFactor = this.application.ninja.documentBar.zoomFactor/100.0;
            var arrowSize = 50 / zoomFactor;
            var xAxis = [arrowSize,0,0,1];
            //var rO = resMat.multiply(origin);
            var rO = glmat4.multiplyVec3( resMat, origin, []);  
            //var xO = resMat.multiply(xAxis);
            var xO = glmat4.multiplyVec3( resMat, xAxis, []);

            var yAxis = [0,arrowSize,0,1];
            var yO = glmat4.multiplyVec3( resMat, yAxis, []);

            var zAxis = [0,0,arrowSize,1];
            var zO = glmat4.multiplyVec3( resMat, zAxis, []);

            var saveContext = this.getDrawingSurfaceElement();
            this.setDrawingSurfaceElement(this.application.ninja.stage.gridCanvas);
            // clear just the 3d compass area
            this._drawingContext.save();
            this._drawingContext.rect(10, origTop-60, 100, 110);
            this._drawingContext.clip();

            this._drawingContext.lineWidth = 2.0;

            this._drawingContext.beginPath();
            this._drawingContext.strokeStyle = "red";
            this._drawingContext.moveTo(rO[0], rO[1]);
            this._drawingContext.lineTo(xO[0], xO[1]);
            this._drawingContext.closePath();
            this._drawingContext.stroke();
            this.drawArrowHead(rO, xO);

            this._drawingContext.beginPath();
            this._drawingContext.strokeStyle = "green";
            this._drawingContext.moveTo(rO[0], rO[1]);
            this._drawingContext.lineTo(yO[0], yO[1]);
            this._drawingContext.closePath();
            this._drawingContext.stroke();
            this.drawArrowHead(rO, yO);

            this._drawingContext.beginPath();
            this._drawingContext.strokeStyle = "blue";
            this._drawingContext.moveTo(rO[0], rO[1]);
            this._drawingContext.lineTo(zO[0], zO[1]);
            this._drawingContext.closePath();
            this._drawingContext.stroke();
            this.drawArrowHead(rO, zO);

            // restore the state
            this._drawingContext.restore();
            this.setDrawingSurfaceElement(saveContext);
            this._lineColor = saveColor;
            this._lineWidth = saveLineWidth;
            this._sourceSpaceElt = saveSource;
        }
    },

    drawArrowHead : {
        value: function(base, onAxis) {
            var headWidth = 6;

            // draw the arrowhead
            var head = MathUtils.interpolateLine3D( base, onAxis, 0.7 );
            p0 = head.slice(0);  p0[1] += headWidth;
            p1 = head.slice(0);  p1[0] += headWidth;
            p2 = head.slice(0);  p2[1] -= headWidth;
            p3 = head.slice(0);  p3[0] -= headWidth;

            this._drawingContext.beginPath();

            this._drawingContext.moveTo(base[0], base[1]);
            this._drawingContext.lineTo(onAxis[0], onAxis[1]);

            this._drawingContext.moveTo(onAxis[0], onAxis[1]);
            this._drawingContext.lineTo(p0[0], p0[1]);
            this._drawingContext.moveTo(onAxis[0], onAxis[1]);
            this._drawingContext.lineTo(p1[0], p1[1]);
            this._drawingContext.moveTo(onAxis[0], onAxis[1]);
            this._drawingContext.lineTo(p2[0], p2[1]);
            this._drawingContext.moveTo(onAxis[0], onAxis[1]);
            this._drawingContext.lineTo(p3[0], p3[1]);

            this._drawingContext.moveTo( p0[0], p0[1] );
            this._drawingContext.lineTo( p1[0], p1[1] );
            this._drawingContext.lineTo( p2[0], p2[1] );
            this._drawingContext.lineTo( p3[0], p3[1] );
            this._drawingContext.lineTo( p0[0], p0[1] );

            this._drawingContext.closePath();

            this._drawingContext.stroke();
        }
    },

    drawGridAxes : {
        value: function (ctr, width, height, headSize) {
            this._drawingContext.lineWidth = 2.0;

            this._lineColor = "red";
            var pt0 = ctr.slice(0), pt1 = pt0.slice(0);
            pt1[0] += width;
            this.moveTo(pt0);
            this.lineTo(pt1);
            var pt2 = pt1.slice(0);
            pt2[0] -= headSize;
            pt2[1] += headSize;
            this.lineTo(pt2);
            //this.moveTo(pt1);
            pt2[1] -= 2 * headSize;
            this.lineTo(pt2);
            this.lineTo(pt1);

            this._lineColor = "green";
            pt1 = pt0.slice(0);
            pt1[1] += height;
            this.moveTo(pt0);
            this.lineTo(pt1);
            pt2 = pt1.slice(0);
            pt2[1] -= headSize;
            pt2[0] += headSize;
            this.lineTo(pt2);
            //this.moveTo(pt1);
            pt2[0] -= 2 * headSize;
            this.lineTo(pt2);
            this.lineTo(pt1);

            this._lineColor = "blue";
            pt1 = pt0.slice(0);
            pt1[2] += height < width ? height : width;
            this.moveTo(pt0);
            this.lineTo(pt1);
            pt2 = pt1.slice(0);
            pt2[2] -= headSize;
            pt2[1] += headSize;
            this.lineTo(pt2);
            //this.moveTo(pt1);
            pt2[1] -= 2 * headSize;
            this.lineTo(pt2);
            this.lineTo(pt1);
        }
    }
});