1 files changed, 370 insertions, 0 deletions

diff --git a/js/tools/drawing-tool.js b/js/tools/drawing-tool.js
new file mode 100644
index 00000000..603f63a3
--- /dev/null
+++ b/js/tools/drawing-tool.js
@@ -0,0 +1,370 @@
+/* <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,
+    ToolBase = require("js/tools/ToolBase").toolBase,
+    DrawingToolBase = require("js/tools/drawing-tool-base").DrawingToolBase,
+    Keyboard = require("js/mediators/keyboard-mediator").Keyboard;
+
+exports.DrawingTool = Montage.create(ToolBase, {
+    drawingFeedback: { value: { mode: "Draw2D", type: "" } },    // Default Value
+    _canOperateOnStage: { value: true },
+
+    _canDraw: { value: true },
+    _isDrawing: { value: false },
+    _hasDraw: { value: false },
+    _isSpace: { value: false },
+
+    _downPoint: { value: { "x": null, "y": null} },
+    _upPoint: { value: { "x": null, "y": null} },
+
+    _mouseDownHitRec: { value: null },
+    _mouseUpHitRec: { value: null },
+
+    _currentX: { value: null },
+    _currentY: { value: null },
+    _currentDX: { value: 0 },
+    _currentDY: { value: 0 },
+
+    isDrawing: {
+        get: function () { return this._isDrawing; },
+        set: function (value) { this._isDrawing = value; }
+    },
+
+    downPoint: {
+        get: function () { return this._downPoint; },
+        set: function (value) { this._downPoint = value; }
+    },
+
+    upPoint: {
+        get: function () { return this._upPoint; },
+        set: function (value) { this._upPoint = value; }
+    },
+
+    mouseDownHitRec: {
+        get: function () { return this._mouseDownHitRec; },
+        set: function (value) { this._mouseDownHitRec = value; }
+    },
+
+    mouseUpHitRec: {
+        get: function () { return this._mouseUpHitRec; },
+        set: function (value) { this._mouseUpHitRec = value; }
+    },
+
+    currentX: {
+        get: function () { return this._currentX; },
+        set: function (value) { this._currentX = value; }
+    },
+
+    currentY: {
+        get: function () { return this._currentY; },
+        set: function (value) { this._currentY = value; }
+    },
+
+    /**
+    * PUBLIC METHODS
+    */
+    startDraw: {
+        value: function (event) {
+            var snapData, point;
+
+            this._isDrawing = true;
+            this.mouseUpHitRec = null;
+
+            point = webkitConvertPointFromPageToNode(this.application.ninja.stage.canvas, new WebKitPoint(event.pageX, event.pageY));
+            snapData = DrawingToolBase.getInitialSnapPoint(point.x, point.y); //event.layerX, event.layerY);
+            this.mouseDownHitRec = snapData[0];
+            this.downPoint.x = snapData[1];
+            this.downPoint.y = snapData[2];
+        }
+    },
+
+    /**
+    * This base method will perform stage feedback drawing if the mouse is down.
+    * Otherwise it will only perform the snapping feedback
+    */
+    doDraw: {
+        value: function (event) {
+            var point;
+            point = webkitConvertPointFromPageToNode(this.application.ninja.stage.canvas, new WebKitPoint(event.pageX, event.pageY));
+            
+            if (this.drawingFeedback.mode === "Draw3D") {
+                var do3DSnap;
+                this.application.ninja.stage.clearDrawingCanvas();
+
+                do3DSnap = false;
+
+                if (this._isSpace) {
+                    this._currentDX = point.x - this._currentX;
+                    this._currentDY = point.y - this._currentY;
+                    this.HandleSpaceKeyDown();
+                } else {
+                    this._currentX = point.x;
+                    this._currentY = point.y;
+                }
+
+                if (event.shiftKey) {
+                    this.HandleShiftKeyDown();
+                } else if (event.altKey) {
+                    this.HandleAltKeyDown();
+                } else {
+                    do3DSnap = event.ctrlKey || event.metaKey;
+                    this.mouseUpHitRec = DrawingToolBase.getUpdatedSnapPoint(point.x, point.y, do3DSnap, this.mouseDownHitRec);
+                    this._doDraw();
+                }
+
+                DrawingToolBase.drawSnapLastHit();
+            } else if (this.drawingFeedback.mode === "Draw2D") {
+                if(this._isSpace) {
+                    this._currentDX = point.x - this._currentX;
+                    this._currentDY = point.y - this._currentY;
+
+                    this.downPoint.x += this._currentDX;
+                                this.downPoint.y += this._currentDY;
+                    this.currentX += this._currentDX;
+                                this.currentY += this._currentDY;
+                    
+                    DrawingToolBase.draw2DRectangle(this.downPoint.x,this.downPoint.y,this.currentX - this.downPoint.x,this.currentY - this.downPoint.y);
+                } else {
+                    this._currentX = point.x;
+                    this._currentY = point.y;
+               
+                    DrawingToolBase.draw2DRectangle(this.downPoint.x,this.downPoint.y,point.x - this.downPoint.x,point.y - this.downPoint.y);
+                }
+
+            }
+
+        }
+    },
+
+    _doDraw: {
+        value: function () {
+            if (this.mouseDownHitRec !== null) {
+                DrawingToolBase.stageComponent = this.application.ninja.stage;
+                DrawingToolBase.drawRectangle(this.mouseDownHitRec, this.mouseUpHitRec);
+            }
+        }
+    },
+
+    endDraw: {
+        value: function (event) {
+            this.application.ninja.stage.clearDrawingCanvas();
+
+            this.mouseDownHitRec = null;
+            this.mouseUpHitRec = null;
+            this.downPoint.x = null;
+            this.downPoint.y = null;
+            this._isDrawing = false;
+
+            if (this.drawingFeedback.mode === "Draw3D") {
+                DrawingToolBase.cleanupSnap();
+            }
+        }
+    },
+
+    // Used when ESC is hit to cancel the current drawing.
+    cancelDraw: {
+        value: function() {
+            this.application.ninja.stage.clearDrawingCanvas();
+
+            if(this.drawingFeedback.mode === "Draw3D") {
+                this._isDrawing = false;
+                DrawingToolBase.cleanupSnap();
+            }
+        }
+    },
+
+    doSnap: {
+        value: function (event) {
+            var point;
+            point = webkitConvertPointFromPageToNode(this.application.ninja.stage.canvas, new WebKitPoint(event.pageX, event.pageY));
+            this.application.ninja.stage.clearDrawingCanvas();
+            this.mouseUpHitRec = DrawingToolBase.getUpdatedSnapPoint(point.x, point.y, true, this.mouseDownHitRec);
+        }
+    },
+
+    drawLastSnap: {
+        value: function () {
+            DrawingToolBase.drawSnapLastHit();
+        }
+    },
+
+    getMouseDownPos: {
+        value: function () {
+            return DrawingToolBase.getHitRecPos(this.mouseDownHitRec);
+        }
+    },
+
+    getMouseUpPos: {
+        value: function () {
+            return DrawingToolBase.getHitRecPos(this.mouseUpHitRec);
+        }
+    },
+    
+    getDrawingData: {
+        value: function (event) {
+            return DrawingToolBase.getCompletePoints(this.mouseDownHitRec, this.mouseUpHitRec);
+        }
+    },
+
+    /**
+    * SHIFT/ALT/SPACE Key Handlers
+    */
+    HandleKeyPress: {
+        value: function(event) {
+            if(event.shiftKey) {
+                this.HandleShiftKeyDown(event);
+            } else if(event.altKey) {
+                this.HandleAltKeyDown(event);
+            } else if (event.keyCode === Keyboard.SPACE) {
+                event.preventDefault();
+                this.HandleSpaceKeyDown(event);
+            }
+        }
+    },
+
+    HandleKeyUp: {
+        value: function(event) {
+            if(event.keyCode === 16) {
+                this.HandleShiftKeyUp(event);
+            } else if(event.keyCode === 18) {
+                this.HandleAltKeyUp(event);
+            } else if (event.keyCode === Keyboard.SPACE) {
+                event.preventDefault();
+                this.HandleSpaceUp(event);
+            }
+        }
+    },
+
+    HandleShiftKeyDown: {
+        value: function (event) {
+            if (this._isDrawing) {
+                var square = this.toSquare(this.downPoint.x, this.currentX, this.downPoint.y, this.currentY);
+                this.mouseUpHitRec = DrawingToolBase.getUpdatedSnapPoint(square[0] + square[2], square[1] + square[3], false, this.mouseDownHitRec);
+                this._doDraw();
+            }