From 57c373259fb22a6c20248ef338dc2766a364ac59 Mon Sep 17 00:00:00 2001
From: Pushkar Joshi
Date: Fri, 27 Apr 2012 15:38:17 -0700
Subject: scale the brush stroke according to the input width and height

Fixes: 1444 Brush: Unable to scale brushstroke using the Transform handles
---
 js/lib/geom/brush-stroke.js | 62 ++++++++++++++++++++++++++++++++++++++++++---
 1 file changed, 58 insertions(+), 4 deletions(-)

(limited to 'js/lib')

diff --git a/js/lib/geom/brush-stroke.js b/js/lib/geom/brush-stroke.js
index 1fae0c1d..d5d9a893 100755
--- a/js/lib/geom/brush-stroke.js
+++ b/js/lib/geom/brush-stroke.js
@@ -264,13 +264,67 @@ var BrushStroke = function GLBrushStroke() {
         this._strokeStyle = s;
     };
 
-    this.setWidth = function () {
+    this.setWidth = function (newW) {
+        if (newW<1) {
+            newW=1; //clamp minimum width to 1
+        }
+
+        //scale the contents of this subpath to lie within this width
+        //determine the scale factor by comparing with the old width
+        var oldWidth = this._BBoxMax[0]-this._BBoxMin[0];
+        if (oldWidth<1) {
+            oldWidth=1;
+        }
+
+        var scaleX = newW/oldWidth;
+        if (scaleX===1) {
+            return; //no need to do anything
+        }
+
+        //scale the local point positions such that the width of the bbox is the newW
+        var origX = this._BBoxMin[0];
+        var numPoints = this._LocalPoints.length;
+        for (var i=0;i<numPoints;i++){
+            //compute the distance from the bboxMin
+            var oldW = this._LocalPoints[i][0] - origX;
+            this._LocalPoints[i] = [(origX + oldW*scaleX),this._LocalPoints[i][1],this._LocalPoints[i][2]];
+
+            oldW = this._OrigLocalPoints[i][0] - origX;
+            this._OrigLocalPoints[i] = [(origX + oldW*scaleX),this._OrigLocalPoints[i][1],this._OrigLocalPoints[i][2]];
+        }
+        this._isDirty = true;
+    };
 
-    };//NO-OP for now
+    this.setHeight = function (newH) {
+        if (newH<1) {
+            newH=1; //clamp minimum width to 1
+        }
 
-    this.setHeight = function () {
+        //scale the contents of this subpath to lie within this height
+        //determine the scale factor by comparing with the old height
+        var oldHeight = this._BBoxMax[1]-this._BBoxMin[1];
+        if (oldHeight<1) {
+            oldHeight=1;
+        }
+
+        var scaleY = newH/oldHeight;
+        if (scaleY===1) {
+            return; //no need to do anything
+        }
 
-    };//NO-OP for now
+        //scale the local point positions such that the width of the bbox is the newW
+        var origY = this._BBoxMin[1];
+        var numPoints = this._LocalPoints.length;
+        for (var i=0;i<numPoints;i++){
+            //compute the distance from the bboxMin
+            var oldH = this._LocalPoints[i][1] - origY;
+            this._LocalPoints[i] = [this._LocalPoints[i][0],(origY + oldH*scaleY),this._LocalPoints[i][2]];
+
+            oldH = this._OrigLocalPoints[i][1] - origY;
+            this._OrigLocalPoints[i] = [this._OrigLocalPoints[i][0],(origY + oldH*scaleY),this._OrigLocalPoints[i][2]];
+        }
+        this._isDirty = true;
+    };
 
     this.getWidth = function() {
         if (this._isDirty){
-- 
cgit v1.2.3


From f32420d51258f1caf048ac387985ee84f019604c Mon Sep 17 00:00:00 2001
From: Pushkar Joshi
Date: Tue, 1 May 2012 09:06:34 -0700
Subject: prevent alpha values from accumulating over 1 due to rounding...fixes
 1443 Brush: Odd painting behavior when Hardness is 99%. A solid outline is
 shown on the brushstroke.

---
 js/lib/geom/brush-stroke.js | 12 +++++++++++-
 1 file changed, 11 insertions(+), 1 deletion(-)

(limited to 'js/lib')

diff --git a/js/lib/geom/brush-stroke.js b/js/lib/geom/brush-stroke.js
index d5d9a893..27d12f03 100755
--- a/js/lib/geom/brush-stroke.js
+++ b/js/lib/geom/brush-stroke.js
@@ -704,7 +704,7 @@ var BrushStroke = function GLBrushStroke() {
             ctx.lineCap = "round";
             ctx.lineJoin="round";
             var minStrokeWidth = (this._strokeHardness*this._strokeWidth)/100; //the hardness is the percentage of the stroke width that's fully opaque
-            var numlayers = 1 + (this._strokeWidth-minStrokeWidth)/2;
+            var numlayers = 1 + Math.ceil((this._strokeWidth-minStrokeWidth)*0.5);
             var alphaVal = 1.0/(numlayers); //this way the alpha at the first path will be 1
             ctx.strokeStyle="rgba("+parseInt(255*this._strokeColor[0])+","+parseInt(255*this._strokeColor[1])+","+parseInt(255*this._strokeColor[2])+","+alphaVal+")";
             for (var l=0;l<numlayers;l++){
@@ -732,6 +732,16 @@ var BrushStroke = function GLBrushStroke() {
                     ctx.lineTo(p[0],p[1]);
                 }
                 ctx.lineWidth=2*l+minStrokeWidth;
+
+
+                //experiments with shadows
+                /*
+                ctx.shadowOffsetX = 10;
+                ctx.shadowOffsetY = 10;
+                ctx.shadowBlur    = 10;
+                ctx.shadowColor   = //"rgb("+parseInt(255*this._strokeColor[0])+","+parseInt(255*this._strokeColor[1])+","+parseInt(255*this._strokeColor[2])+")";
+                    "#FF6666";  //or use rgb(red, green, blue)
+                 */
                 ctx.stroke();
             }//for every layer l
         } //if there is no calligraphic stroke
-- 
cgit v1.2.3


From 14e101e3822da595baaaaeaf91e9a00c79ac4b38 Mon Sep 17 00:00:00 2001
From: Pushkar Joshi
Date: Tue, 1 May 2012 10:21:36 -0700
Subject: Fixed 1436 Brush: Calligraphic brushstroke is slightly thicker than
 the round tip brushstroke

---
 js/lib/geom/brush-stroke.js | 13 ++++++++-----
 1 file changed, 8 insertions(+), 5 deletions(-)

(limited to 'js/lib')

diff --git a/js/lib/geom/brush-stroke.js b/js/lib/geom/brush-stroke.js
index 27d12f03..574cead1 100755
--- a/js/lib/geom/brush-stroke.js
+++ b/js/lib/geom/brush-stroke.js
@@ -657,11 +657,8 @@ var BrushStroke = function GLBrushStroke() {
             ctx.lineCap="butt";
             ctx.globalCompositeOperation = 'source-over';
             ctx.globalAlpha = this._strokeColor[3];
-            //todo figure out the correct formula for the line width
-            ctx.lineWidth=2;
-            if (t===numTraces-1){
-                ctx.lineWidth = 1;
-            }
+
+
             for (t=0;t<numTraces;t++){
                 var disp = [brushStamp[t][0], brushStamp[t][1]];
                 var alphaVal = 1.0;
@@ -671,6 +668,12 @@ var BrushStroke = function GLBrushStroke() {
                     alphaVal *= 1.0/ctx.lineWidth; //factor that accounts for lineWidth !== 1
                 }
                 ctx.save();
+                if (t === (numTraces-1)){
+                    ctx.lineWidth = 1;
+                } else {
+                     //todo figure out the correct formula for the line width
+                    ctx.lineWidth=2;
+                }
                 ctx.strokeStyle="rgba("+parseInt(255*this._strokeColor[0])+","+parseInt(255*this._strokeColor[1])+","+parseInt(255*this._strokeColor[2])+","+alphaVal+")";
                 //linearly interpolate between the two stroke colors
                 var currStrokeColor = VecUtils.vecInterpolate(4, this._strokeColor, this._secondStrokeColor, t/numTraces);
-- 
cgit v1.2.3


From 42b0fe45cded043f2c210f263a3eb2ba2dbd09c2 Mon Sep 17 00:00:00 2001
From: Pushkar Joshi
Date: Tue, 1 May 2012 15:10:14 -0700
Subject: small code changes (mostly re-org)

---
 js/lib/geom/brush-stroke.js | 10 +++++-----
 1 file changed, 5 insertions(+), 5 deletions(-)

(limited to 'js/lib')

diff --git a/js/lib/geom/brush-stroke.js b/js/lib/geom/brush-stroke.js
index 574cead1..a1746d95 100755
--- a/js/lib/geom/brush-stroke.js
+++ b/js/lib/geom/brush-stroke.js
@@ -637,7 +637,7 @@ var BrushStroke = function GLBrushStroke() {
             //build the stamp for the brush stroke
             var t=0;
             var numTraces = this._strokeWidth;
-            var halfNumTraces = numTraces/2;
+            var halfNumTraces = numTraces*0.5;
             var opaqueRegionHalfWidth = 0.5*this._strokeHardness*numTraces*0.01; //the 0.01 is to convert the strokeHardness from [0,100] to [0,1]
             var maxTransparentRegionHalfWidth = halfNumTraces-opaqueRegionHalfWidth;
 
@@ -658,21 +658,21 @@ var BrushStroke = function GLBrushStroke() {
             ctx.globalCompositeOperation = 'source-over';
             ctx.globalAlpha = this._strokeColor[3];
 
-
             for (t=0;t<numTraces;t++){
                 var disp = [brushStamp[t][0], brushStamp[t][1]];
                 var alphaVal = 1.0;
                 var distFromOpaqueRegion = Math.abs(t-halfNumTraces) - opaqueRegionHalfWidth;
                 if (distFromOpaqueRegion>0) {
-                    alphaVal = 1.0 - distFromOpaqueRegion/maxTransparentRegionHalfWidth;
-                    alphaVal *= 1.0/ctx.lineWidth; //factor that accounts for lineWidth !== 1
+                    var transparencyFactor = distFromOpaqueRegion/maxTransparentRegionHalfWidth;
+                    alphaVal = 1.0 - transparencyFactor;//(transparencyFactor*transparencyFactor);//the square term produces nonlinearly varying alpha values
                 }
                 ctx.save();
-                if (t === (numTraces-1)){
+                if (t === (numTraces-1) || t === 0){
                     ctx.lineWidth = 1;
                 } else {
                      //todo figure out the correct formula for the line width
                     ctx.lineWidth=2;
+                    alphaVal *= 0.5; //factor that accounts for lineWidth == 2
                 }
                 ctx.strokeStyle="rgba("+parseInt(255*this._strokeColor[0])+","+parseInt(255*this._strokeColor[1])+","+parseInt(255*this._strokeColor[2])+","+alphaVal+")";
                 //linearly interpolate between the two stroke colors
-- 
cgit v1.2.3


From b9262c831952e77135b79c2de7c455d5e7ff0589 Mon Sep 17 00:00:00 2001
From: Pushkar Joshi
Date: Tue, 1 May 2012 17:00:40 -0700
Subject: undo some previous change that was halving the alpha value of the
 stroke

---
 js/lib/geom/brush-stroke.js | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'js/lib')

diff --git a/js/lib/geom/brush-stroke.js b/js/lib/geom/brush-stroke.js
index a1746d95..519e0433 100755
--- a/js/lib/geom/brush-stroke.js
+++ b/js/lib/geom/brush-stroke.js
@@ -665,6 +665,7 @@ var BrushStroke = function GLBrushStroke() {
                 if (distFromOpaqueRegion>0) {
                     var transparencyFactor = distFromOpaqueRegion/maxTransparentRegionHalfWidth;
                     alphaVal = 1.0 - transparencyFactor;//(transparencyFactor*transparencyFactor);//the square term produces nonlinearly varying alpha values
+                    alphaVal *= 0.5; //factor that accounts for lineWidth == 2
                 }
                 ctx.save();
                 if (t === (numTraces-1) || t === 0){
@@ -672,7 +673,6 @@ var BrushStroke = function GLBrushStroke() {
                 } else {
                      //todo figure out the correct formula for the line width
                     ctx.lineWidth=2;
-                    alphaVal *= 0.5; //factor that accounts for lineWidth == 2
                 }
                 ctx.strokeStyle="rgba("+parseInt(255*this._strokeColor[0])+","+parseInt(255*this._strokeColor[1])+","+parseInt(255*this._strokeColor[2])+","+alphaVal+")";
                 //linearly interpolate between the two stroke colors
-- 
cgit v1.2.3


From de9f718b739ef2b31a161d9dac6e81d614fab853 Mon Sep 17 00:00:00 2001
From: Pushkar Joshi
Date: Fri, 11 May 2012 08:55:07 -0700
Subject: code cleanup and starting the subtool functionality

---
 js/lib/geom/sub-path.js | 5 ++++-
 1 file changed, 4 insertions(+), 1 deletion(-)

(limited to 'js/lib')

diff --git a/js/lib/geom/sub-path.js b/js/lib/geom/sub-path.js
index 56c94df3..24acb2b0 100755
--- a/js/lib/geom/sub-path.js
+++ b/js/lib/geom/sub-path.js
@@ -166,6 +166,8 @@ var GLSubpath = function GLSubpath() {
     };
 
     this.setWidth = function (newW) {
+        var strokeWidth = this._strokeWidth;
+        var halfStrokeWidth = strokeWidth*0.5;
         if (newW<1) {
             newW=1; //clamp minimum width to 1
         }
@@ -183,7 +185,7 @@ var GLSubpath = function GLSubpath() {
         }
 
         //scale the anchor point positions such that the width of the bbox is the newW
-        var origX = this._BBoxMin[0];
+        var origX = this._BBoxMin[0]; //this should always be zero since we only deal with local coordinates
         var numAnchors = this._Anchors.length;
         for (var i=0;i<numAnchors;i++){
             //compute the distance from the bboxMin
@@ -196,6 +198,7 @@ var GLSubpath = function GLSubpath() {
             this._Anchors[i].setNextPos(origX + nextW*scaleX,this._Anchors[i].getNextY(),this._Anchors[i].getNextZ());
         }
         this.makeDirty();
+        this.computeBoundingBox(true, false);
     };
 
     this.setHeight = function (newH) {
-- 
cgit v1.2.3


From 75a862d305bc4502e22bc5aa65fa271143b8cf6c Mon Sep 17 00:00:00 2001
From: Pushkar Joshi
Date: Thu, 31 May 2012 12:18:43 -0700
Subject: move all the subpath functions to its prototype, and first version of
 the pen path runtime

---
 js/lib/geom/sub-path.js | 311 ++++++++++++++++++++++++------------------------
 1 file changed, 156 insertions(+), 155 deletions(-)

(limited to 'js/lib')

diff --git a/js/lib/geom/sub-path.js b/js/lib/geom/sub-path.js
index a9034def..db115655 100755
--- a/js/lib/geom/sub-path.js
+++ b/js/lib/geom/sub-path.js
@@ -68,178 +68,179 @@ var GLSubpath = function GLSubpath() {
     this._selectedAnchorIndex = -1;
 
     this._SAMPLING_EPSILON = 0.5; //epsilon used for sampling the curve
+}; //function GLSubpath ...class definition
 
-    // (current GeomObj complains if buildBuffers/render is added to GLSubpath prototype)
-    //buildBuffers
-    //  Build the stroke vertices, normals, textures and colors
-    //  Add that array data to the GPU using OpenGL data binding
-    this.buildBuffers = function () {
-        // return; //no need to do anything for now
-    };
-
-    //render
-    //  specify how to render the subpath in Canvas2D
-    this.render = function () {
-        // get the world
-        var world = this.getWorld();
-        if (!world)  throw( "null world in subpath render" );
-        if (!this._canvas){
-            //set the canvas by querying the world
-            this._canvas = this.getWorld().getCanvas();
-        }
-        // get the context
-        var ctx = world.get2DContext();
-        if (!ctx)  throw ("null context in subpath render");
-
-        var numAnchors = this.getNumAnchors();
-        if (numAnchors === 0) {
-            return; //nothing to do for empty paths
-        }
-        this.createSamples(false); //dirty bit checked in this function...will generate a polyline representation
+GLSubpath.prototype = Object.create(GeomObj, {});
 
-        var numPoints = this._Samples.length;
-        if (numPoints === 0){
-            return; //nothing to do for empty paths
-        }
-        
-        //figure the size of the area we will draw into
-        var bboxWidth=0, bboxHeight=0;
-        bboxWidth = this._BBoxMax[0] - this._BBoxMin[0];
-        bboxHeight = this._BBoxMax[1] - this._BBoxMin[1];
-
-        ctx.save();
-        ctx.clearRect(0, 0, bboxWidth, bboxHeight);
-
-        ctx.lineWidth = this._strokeWidth;
-        ctx.strokeStyle = "black";
-        if (this._strokeColor) {
-            //ctx.strokeStyle = MathUtils.colorToHex( this._strokeColor );
-            var strokeColorStr = "rgba("+parseInt(255*this._strokeColor[0])+","+parseInt(255*this._strokeColor[1])+","+parseInt(255*this._strokeColor[2])+","+this._strokeColor[3]+")";
-            ctx.strokeStyle = strokeColorStr;
-        }
+//buildBuffers
+GLSubpath.prototype.buildBuffers = function () {
+    //no need to do anything for now (no WebGL)
+};
 
-        ctx.fillStyle = "white";
-        if (this._fillColor){
-            //ctx.fillStyle = MathUtils.colorToHex( this._fillColor );
-            var fillColorStr = "rgba("+parseInt(255*this._fillColor[0])+","+parseInt(255*this._fillColor[1])+","+parseInt(255*this._fillColor[2])+","+this._fillColor[3]+")";
-            ctx.fillStyle = fillColorStr;
-        }
-        var lineCap = ['butt','round','square'];
-        ctx.lineCap = lineCap[1];
-        var lineJoin = ['round','bevel','miter'];
-        ctx.lineJoin = lineJoin[0];
-
-        /*
-        commenting this out for now because of Chrome bug where coincident endpoints of bezier curve cause the curve to not be rendered
-        ctx.beginPath();
-        var prevAnchor = this.getAnchor(0);
-        ctx.moveTo(prevAnchor.getPosX()-bboxMin[0],prevAnchor.getPosY()-bboxMin[1]);
-        for (var i = 1; i < numAnchors; i++) {
-            var currAnchor = this.getAnchor(i);
-            ctx.bezierCurveTo(prevAnchor.getNextX()-bboxMin[0],prevAnchor.getNextY()-bboxMin[1], currAnchor.getPrevX()-bboxMin[0], currAnchor.getPrevY()-bboxMin[1], currAnchor.getPosX()-bboxMin[0], currAnchor.getPosY()-bboxMin[1]);
-            prevAnchor = currAnchor;
-        }
-        if (this._isClosed === true) {
-            var currAnchor = this.getAnchor(0);
-            ctx.bezierCurveTo(prevAnchor.getNextX()-bboxMin[0],prevAnchor.getNextY()-bboxMin[1], currAnchor.getPrevX()-bboxMin[0], currAnchor.getPrevY()-bboxMin[1], currAnchor.getPosX()-bboxMin[0], currAnchor.getPosY()-bboxMin[1]);
-            prevAnchor = currAnchor;
-            ctx.fill();
-        }
-        */
+//render
+//  specify how to render the subpath in Canvas2D
+GLSubpath.prototype.render = function () {
+    // get the world
+    var world = this.getWorld();
+    if (!world)  throw( "null world in subpath render" );
+    if (!this._canvas){
+        //set the canvas by querying the world
+        this._canvas = this.getWorld().getCanvas();
+    }
+    // get the context
+    var ctx = world.get2DContext();
+    if (!ctx)  throw ("null context in subpath render");
 
+    var numAnchors = this.getNumAnchors();
+    if (numAnchors === 0) {
+        return; //nothing to do for empty paths
+    }
+    this.createSamples(false); //dirty bit checked in this function...will generate a polyline representation
 
-        ctx.beginPath();
-        ctx.moveTo(this._Samples[0][0],this._Samples[0][1]);
-        for (var i=0;i<numPoints;i++){
-            ctx.lineTo(this._Samples[i][0],this._Samples[i][1]);
-        }
-        if (this._isClosed === true) {
-            ctx.lineTo(this._Samples[0][0],this._Samples[0][1]);
-        }
-        ctx.fill();
-        ctx.stroke();
-        ctx.restore();
-    }; //render()
-
-    this.geomType = function () {
-        return this.GEOM_TYPE_CUBIC_BEZIER;
-    };
-
-    this.setWidth = function (newW) {
-        var strokeWidth = this._strokeWidth;
-        var halfStrokeWidth = strokeWidth*0.5;
-        if (newW<1) {
-            newW=1; //clamp minimum width to 1
-        }
+    var numPoints = this._Samples.length;
+    if (numPoints === 0){
+        return; //nothing to do for empty paths
+    }
 
-        //scale the contents of this subpath to lie within this width
-        //determine the scale factor by comparing with the old width
-        var oldWidth = this._BBoxMax[0]-this._BBoxMin[0];
-        if (oldWidth<1) {
-            oldWidth=1;
-        }
+    //figure the size of the area we will draw into
+    var bboxWidth=0, bboxHeight=0;
+    bboxWidth = this._BBoxMax[0] - this._BBoxMin[0];
+    bboxHeight = this._BBoxMax[1] - this._BBoxMin[1];
 
-        var scaleX = newW/oldWidth;
-        if (scaleX===1) {
-            return; //no need to do anything
-        }
+    ctx.save();
+    ctx.clearRect(0, 0, bboxWidth, bboxHeight);
 
-        //scale the anchor point positions such that the width of the bbox is the newW
-        var origX = this._BBoxMin[0]; //this should always be zero since we only deal with local coordinates
-        var numAnchors = this._Anchors.length;
-        for (var i=0;i<numAnchors;i++){
-            //compute the distance from the bboxMin
-            var oldW = this._Anchors[i].getPosX() - origX;
-            var prevW = this._Anchors[i].getPrevX() - origX;
-            var nextW = this._Anchors[i].getNextX() - origX;
-
-            this._Anchors[i].setPos(origX + oldW*scaleX,this._Anchors[i].getPosY(),this._Anchors[i].getPosZ());
-            this._Anchors[i].setPrevPos(origX + prevW*scaleX,this._Anchors[i].getPrevY(),this._Anchors[i].getPrevZ());
-            this._Anchors[i].setNextPos(origX + nextW*scaleX,this._Anchors[i].getNextY(),this._Anchors[i].getNextZ());
-        }
-        this.makeDirty();
-        this.computeBoundingBox(true, false);
-    };
+    ctx.lineWidth = this._strokeWidth;
+    ctx.strokeStyle = "black";
+    if (this._strokeColor) {
+        //ctx.strokeStyle = MathUtils.colorToHex( this._strokeColor );
+        var strokeColorStr = "rgba("+parseInt(255*this._strokeColor[0])+","+parseInt(255*this._strokeColor[1])+","+parseInt(255*this._strokeColor[2])+","+this._strokeColor[3]+")";
+        ctx.strokeStyle = strokeColorStr;
+    }
 
-    this.setHeight = function (newH) {
-        if (newH<1) {
-            newH=1; //clamp minimum width to 1
-        }
-        //scale the contents of this subpath to lie within this height
-        //determine the scale factor by comparing with the old height
-        var oldHeight = this._BBoxMax[1]-this._BBoxMin[1];
-        if (oldHeight<1){
-            oldHeight=1;
-        }
+    ctx.fillStyle = "white";
+    if (this._fillColor){
+        //ctx.fillStyle = MathUtils.colorToHex( this._fillColor );
+        var fillColorStr = "rgba("+parseInt(255*this._fillColor[0])+","+parseInt(255*this._fillColor[1])+","+parseInt(255*this._fillColor[2])+","+this._fillColor[3]+")";
+        ctx.fillStyle = fillColorStr;
+    }
+    var lineCap = ['butt','round','square'];
+    ctx.lineCap = lineCap[1];
+    var lineJoin = ['round','bevel','miter'];
+    ctx.lineJoin = lineJoin[0];
+
+
+    //commenting this out for now because of Chrome bug where coincident endpoints of bezier curve cause the curve to not be rendered
+    /*
+    ctx.beginPath();
+    var prevAnchor = this.getAnchor(0);
+    ctx.moveTo(prevAnchor.getPosX(),prevAnchor.getPosY());
+    for (var i = 1; i < numAnchors; i++) {
+        var currAnchor = this.getAnchor(i);
+        ctx.bezierCurveTo(prevAnchor.getNextX(),prevAnchor.getNextY(), currAnchor.getPrevX(), currAnchor.getPrevY(), currAnchor.getPosX(), currAnchor.getPosY());
+        prevAnchor = currAnchor;
+    }
+    if (this._isClosed === true) {
+        var currAnchor = this.getAnchor(0);
+        ctx.bezierCurveTo(prevAnchor.getNextX(),prevAnchor.getNextY(), currAnchor.getPrevX(), currAnchor.getPrevY(), currAnchor.getPosX(), currAnchor.getPosY());
+        prevAnchor = currAnchor;
+    }
+    ctx.fill();
+    ctx.stroke();
+    */
 
-        var scaleY = newH/oldHeight;
-        if (scaleY===1){
-            return; //no need to do anything
-        }
 
-        //scale the anchor point positions such that the height of the bbox is the newH
-        var origY = this._BBoxMin[1];
-        var numAnchors = this._Anchors.length;
-        for (var i=0;i<numAnchors;i++){
-            //compute the distance from the bboxMin
-            var oldW = this._Anchors[i].getPosY() - origY;
-            var prevW = this._Anchors[i].getPrevY() - origY;
-            var nextW = this._Anchors[i].getNextY() - origY;
-
-            this._Anchors[i].setPos(this._Anchors[i].getPosX(), origY + oldW*scaleY,this._Anchors[i].getPosZ());
-            this._Anchors[i].setPrevPos(this._Anchors[i].getPrevX(), origY + prevW*scaleY,this._Anchors[i].getPrevZ());
-            this._Anchors[i].setNextPos(this._Anchors[i].getNextX(), origY + nextW*scaleY,this._Anchors[i].getNextZ());
-        }
-        this.makeDirty();
+    ctx.beginPath();
+    ctx.moveTo(this._Samples[0][0],this._Samples[0][1]);
+    for (var i=0;i<numPoints;i++){
+        ctx.lineTo(this._Samples[i][0],this._Samples[i][1]);
     }
+    if (this._isClosed === true) {
+        ctx.lineTo(this._Samples[0][0],this._Samples[0][1]);
+    }
+    ctx.fill();
+    ctx.stroke();
 
-}; //function GLSubpath ...class definition
-
-GLSubpath.prototype = Object.create(GeomObj, {});
+    ctx.restore();
+}; //render()
 
 /////////////////////////////////////////////////////////
 // Property Accessors/Setters
 /////////////////////////////////////////////////////////
+
+
+GLSubpath.prototype.geomType = function () {
+    return this.GEOM_TYPE_CUBIC_BEZIER;
+};
+
+GLSubpath.prototype.setWidth = function (newW) {
+    var strokeWidth = this._strokeWidth;
+    var halfStrokeWidth = strokeWidth*0.5;
+    if (newW<1) {
+        newW=1; //clamp minimum width to 1
+    }
+
+    //scale the contents of this subpath to lie within this width
+    //determine the scale factor by comparing with the old width
+    var oldWidth = this._BBoxMax[0]-this._BBoxMin[0];
+    if (oldWidth<1) {
+        oldWidth=1;
+    }
+
+    var scaleX = newW/oldWidth;
+    if (scaleX===1) {
+        return; //no need to do anything
+    }
+
+    //scale the anchor point positions such that the width of the bbox is the newW
+    var origX = this._BBoxMin[0]; //this should always be zero since we only deal with local coordinates
+    var numAnchors = this._Anchors.length;
+    for (var i=0;i<numAnchors;i++){
+        //compute the distance from the bboxMin
+        var oldW = this._Anchors[i].getPosX() - origX;
+        var prevW = this._Anchors[i].getPrevX() - origX;
+        var nextW = this._Anchors[i].getNextX() - origX;
+
+        this._Anchors[i].setPos(origX + oldW*scaleX,this._Anchors[i].getPosY(),this._Anchors[i].getPosZ());
+        this._Anchors[i].setPrevPos(origX + prevW*scaleX,this._Anchors[i].getPrevY(),this._Anchors[i].getPrevZ());
+        this._Anchors[i].setNextPos(origX + nextW*scaleX,this._Anchors[i].getNextY(),this._Anchors[i].getNextZ());
+    }
+    this.makeDirty();
+    this.computeBoundingBox(true, false);
+};
+
+GLSubpath.prototype.setHeight = function (newH) {
+    if (newH<1) {
+        newH=1; //clamp minimum width to 1
+    }
+    //scale the contents of this subpath to lie within this height
+    //determine the scale factor by comparing with the old height
+    var oldHeight = this._BBoxMax[1]-this._BBoxMin[1];
+    if (oldHeight<1){
+        oldHeight=1;
+    }
+
+    var scaleY = newH/oldHeight;
+    if (scaleY===1){
+        return; //no need to do anything
+    }
+
+    //scale the anchor point positions such that the height of the bbox is the newH
+    var origY = this._BBoxMin[1];
+    var numAnchors = this._Anchors.length;
+    for (var i=0;i<numAnchors;i++){
+        //compute the distance from the bboxMin
+        var oldW = this._Anchors[i].getPosY() - origY;
+        var prevW = this._Anchors[i].getPrevY() - origY;
+        var nextW = this._Anchors[i].getNextY() - origY;
+
+        this._Anchors[i].setPos(this._Anchors[i].getPosX(), origY + oldW*scaleY,this._Anchors[i].getPosZ());
+        this._Anchors[i].setPrevPos(this._Anchors[i].getPrevX(), origY + prevW*scaleY,this._Anchors[i].getPrevZ());
+        this._Anchors[i].setNextPos(this._Anchors[i].getNextX(), origY + nextW*scaleY,this._Anchors[i].getNextZ());
+    }
+    this.makeDirty();
+};
+
 GLSubpath.prototype.setWorld = function (world) {
     this._world = world;
 };
-- 
cgit v1.2.3


From 0dd045b574a27233a452e87ca8ce3d65d725bbfe Mon Sep 17 00:00:00 2001
From: Pushkar Joshi
Date: Tue, 5 Jun 2012 09:40:59 -0700
Subject: enable gradients for pen stroke and fill

---
 js/lib/geom/sub-path.js | 43 +++++++++++++++++++++++++++++++++++++------
 1 file changed, 37 insertions(+), 6 deletions(-)

(limited to 'js/lib')

diff --git a/js/lib/geom/sub-path.js b/js/lib/geom/sub-path.js
index db115655..f765b715 100755
--- a/js/lib/geom/sub-path.js
+++ b/js/lib/geom/sub-path.js
@@ -77,6 +77,37 @@ GLSubpath.prototype.buildBuffers = function () {
     //no need to do anything for now (no WebGL)
 };
 
+//buildColor returns the fillStyle or strokeStyle for the Canvas 2D context
+GLSubpath.prototype.buildColor = function(ctx,          //the 2D rendering context (for creating gradients if necessary)
+                                          ipColor,      //color string, also encodes whether there's a gradient and of what type
+                                          w,            //width of the region of color
+                                          h,            //height of the region of color
+                                          lw)           //linewidth (i.e. stroke width/size)
+{
+    if (ipColor.gradientMode){
+        var position, gradient, cs, inset; //vars used in gradient calculations
+        inset = Math.ceil( lw ) - 0.5;
+
+        if(ipColor.gradientMode === "radial") {
+            var ww = w - 2*lw,  hh = h - 2*lw;
+            gradient = ctx.createRadialGradient(w/2, h/2, 0, w/2, h/2, Math.max(ww, hh)/2);
+        } else {
+            gradient = ctx.createLinearGradient(inset, h/2, w-inset, h/2);
+        }
+        var colors = ipColor.color;
+
+        var len = colors.length;
+        for(n=0; n<len; n++) {
+            position = colors[n].position/100;
+            cs = colors[n].value;
+            gradient.addColorStop(position, "rgba(" + cs.r + "," + cs.g + "," + cs.b + "," + cs.a + ")");
+        }
+        return gradient;
+    } else {
+        var c = "rgba(" + 255*ipColor[0] + "," + 255*ipColor[1] + "," + 255*ipColor[2] + "," + ipColor[3] + ")";
+        return c;
+    }
+};
 //render
 //  specify how to render the subpath in Canvas2D
 GLSubpath.prototype.render = function () {
@@ -112,17 +143,17 @@ GLSubpath.prototype.render = function () {
 
     ctx.lineWidth = this._strokeWidth;
     ctx.strokeStyle = "black";
+
+    //vars used for the gradient computation in buildColor
+    var w = world.getViewportWidth(), h = world.getViewportHeight();
+
     if (this._strokeColor) {
-        //ctx.strokeStyle = MathUtils.colorToHex( this._strokeColor );
-        var strokeColorStr = "rgba("+parseInt(255*this._strokeColor[0])+","+parseInt(255*this._strokeColor[1])+","+parseInt(255*this._strokeColor[2])+","+this._strokeColor[3]+")";
-        ctx.strokeStyle = strokeColorStr;
+        ctx.strokeStyle = this.buildColor(ctx, this._strokeColor, w,h, this._strokeWidth);
     }
 
     ctx.fillStyle = "white";
     if (this._fillColor){
-        //ctx.fillStyle = MathUtils.colorToHex( this._fillColor );
-        var fillColorStr = "rgba("+parseInt(255*this._fillColor[0])+","+parseInt(255*this._fillColor[1])+","+parseInt(255*this._fillColor[2])+","+this._fillColor[3]+")";
-        ctx.fillStyle = fillColorStr;
+        ctx.fillStyle = this.buildColor(ctx, this._fillColor, w, h, this._strokeWidth);
     }
     var lineCap = ['butt','round','square'];
     ctx.lineCap = lineCap[1];
-- 
cgit v1.2.3


From e28eb9158a50d7e6d97dbc68066e591ac600c241 Mon Sep 17 00:00:00 2001
From: Valerio Virgillito
Date: Tue, 5 Jun 2012 21:40:44 -0700
Subject: removing all model creators.

The elementModel is now a getter that will create a new model when needed.

Signed-off-by: Valerio Virgillito <valerio@motorola.com>
---
 js/lib/NJUtils.js | 120 ------------------------------------------------------
 1 file changed, 120 deletions(-)

(limited to 'js/lib')

diff --git a/js/lib/NJUtils.js b/js/lib/NJUtils.js
index 7dd4c9e8..0dec6345 100755
--- a/js/lib/NJUtils.js
+++ b/js/lib/NJUtils.js
@@ -90,30 +90,6 @@ exports.NJUtils = Montage.create(Component, {
         }
     },
 
-    createModel: {
-        value: function(el) {
-            el.elementModel = Montage.create(ElementModel).initialize(el);
-        }
-    },
-
-    createModelWithShape: {
-        value: function(el, selection) {
-            el.elementModel = Montage.create(ElementModel).initialize(el, true, selection);
-        }
-    },
-
-    createModelWithSelection: {
-        value: function(el, selection) {
-            el.elementModel = Montage.create(ElementModel).initialize(el, false, selection);
-        }
-    },
-
-    createModelForComponent: {
-        value: function(el, selection) {
-            el.elementModel = Montage.create(ElementModel).initialize(el, false, selection, true);
-        }
-    },
-
     // TODO: Find a better place for this method
     stylesFromDraw: {
         value: function(element, width, height, drawData, pos) {
@@ -166,102 +142,6 @@ exports.NJUtils = Montage.create(Component, {
         }
     },
 
-    ///// Element Model creation for existing elements
-    ///// TODO: find a different place for this function
-    makeElementModel: {
-        value: function(el, selection, controller, isShape) {
-            var p3d = Montage.create(Properties3D);
-
-            var shapeProps = null;
-            var pi = controller + "Pi";
-
-            if(isShape) {
-                shapeProps = Montage.create(ShapeModel);
-            }
-
-            if(el.controller) {
-
-                var componentInfo = Montage.getInfoForObject(el.controller);
-                var componentName = componentInfo.objectName.toLowerCase();
-
-                controller  = "component";
-                isShape = false;
-
-                switch(componentName) {
-                    case "feedreader":
-                        selection = "Feed Reader";
-                        pi = "FeedReaderPi";
-                        break;
-                    case "map":
-                        selection = "Map";
-                        pi = "MapPi";
-                        break;
-                    case "youtubechannel":
-                        selection = "Youtube Channel";
-                        pi = "YoutubeChannelPi";
-                        break;
-                    case "picasacarousel":
-                        selection = "Picasa Carousel";
-                        pi = "PicasaCarouselPi";
-                        break;
-                }
-            }
-
-            el.elementModel = Montage.create(ElementModel, {
-                    type:       { value: el.nodeName},
-                    selection:  { value: selection},
-                    controller: { value: ControllerFactory.getController(controller)},
-                    pi:         { value: pi},
-                    props3D:    { value: p3d},
-                    shapeModel: { value: shapeProps},
-                    isShape:    { value: isShape}
-            });
-
-
-        }
-    },
-
-    ///// Element Model creation for existing elements based on element type.
-    ///// TODO: Selection and model should be based on the element type
-    makeModelFromElement: {
-        value: function(el) {
-            var selection = "div",
-                controller = "block",
-                isShape = false;
-            switch(el.nodeName.toLowerCase())
-            {
-                case "div":
-                    break;
-                case "img":
-                    selection = "image";
-                    controller = "image";
-                    break;
-                case "video":
-                    selection = "video";
-                    controller = "video";
-                    break;
-                case "canvas":
-                    isShape = el.getAttribute("data-RDGE-id");
-                    if(isShape) {
-                        // TODO - Need more info about the shape
-                        selection = "canvas";
-                        controller = "shape";
-                        isShape = true;
-                    } else {
-                        selection = "canvas";
-                        controller = "canvas";
-                    }
-                    break;
-                case "shape":
-                    break;
-            }
-            this.makeElementModel(el, selection, controller, isShape);
-            if(el.elementModel && el.elementModel.props3D) {
-                el.elementModel.props3D.init(el, (selection === "Stage"));
-            }
-        }
-    },
-
     ///// Removes all child nodes and returns node
     ///// Accepts a single node, or an array of dom nodes
     empty : {
-- 
cgit v1.2.3


From 2dca8a0aa69981bc2a81c4a68f9061aef861f0ea Mon Sep 17 00:00:00 2001
From: Pushkar Joshi
Date: Wed, 6 Jun 2012 15:01:10 -0700
Subject: enable gradients for brush stroke (in authoring as well as runtime)

---
 js/lib/geom/brush-stroke.js | 1406 ++++++++++++++++++++++---------------------
 1 file changed, 732 insertions(+), 674 deletions(-)

(limited to 'js/lib')

diff --git a/js/lib/geom/brush-stroke.js b/js/lib/geom/brush-stroke.js
index 09a7023c..b2e56149 100755
--- a/js/lib/geom/brush-stroke.js
+++ b/js/lib/geom/brush-stroke.js
@@ -65,777 +65,835 @@ var BrushStroke = function GLBrushStroke() {
     this._planeMatInv = null;
     this._planeCenter = null;
     this._dragPlane = null;
+}; //BrushStroke class defition
 
-    /////////////////////////////////////////////////////////
-    // Property Accessors/Setters
-    /////////////////////////////////////////////////////////
-    this.setCanvas = function(c) {
-        this._canvas = c;
+BrushStroke.prototype = Object.create(GeomObj, {});
+
+/////////////////////////////////////////////////////////
+// Property Accessors/Setters
+/////////////////////////////////////////////////////////
+BrushStroke.prototype.setCanvas = function(c) {
+    this._canvas = c;
+};
+
+BrushStroke.prototype.setWorld = function (world) {
+    this._world = world;
+};
+
+BrushStroke.prototype.getWorld = function () {
+    return this._world;
+};
+
+BrushStroke.prototype.geomType = function () {
+    return this.GEOM_TYPE_BRUSH_STROKE;
+};
+
+BrushStroke.prototype.setDrawingTool = function (tool) {
+    this._drawingTool = tool;
+};
+
+BrushStroke.prototype.getDrawingTool = function () {
+    return this._drawingTool;
+};
+
+BrushStroke.prototype.setPlaneMatrix = function(planeMat){
+    this._planeMat = planeMat;
+};
+
+BrushStroke.prototype.setPlaneMatrixInverse = function(planeMatInv){
+    this._planeMatInv = planeMatInv;
+};
+
+BrushStroke.prototype.setPlaneCenter = function(pc){
+    this._planeCenter = pc;
+};
+
+BrushStroke.prototype.setDragPlane = function(p){
+    this._dragPlane = p;
+};
+
+BrushStroke.prototype.getNumPoints = function () {
+    if (this._LocalPoints.length)
+        return this._LocalPoints.length;
+    else
+        return this._Points.length;
+};
+
+BrushStroke.prototype.getPoint = function (index) {
+    return this._Points[index].slice(0);
+};
+
+BrushStroke.prototype.addPoint = function (pt) {
+    //add the point only if it is some epsilon away from the previous point
+    var numPoints = this._Points.length;
+    if (numPoints>0) {
+        var threshold = this._MIN_SAMPLE_DISTANCE_THRESHOLD;
+        var prevPt = this._Points[numPoints-1];
+        var diffPt = [prevPt[0]-pt[0], prevPt[1]-pt[1]];
+        var diffPtMag = Math.sqrt(diffPt[0]*diffPt[0] + diffPt[1]*diffPt[1]);
+        if (diffPtMag>threshold){
+            this._Points.push(pt);
+            this._isDirty=true;
+            this._isInit = false;
+        }
+    } else {
+        this._Points.push(pt);
+        this._isDirty=true;
+        this._isInit = false;
     }
+};
 
-    this.setWorld = function (world) {
-        this._world = world;
-    };
+BrushStroke.prototype.insertPoint = function(pt, index){
+    this._Points.splice(index, 0, pt);
+    this._isDirty=true;
+    this._isInit = false;
+};
 
-    this.getWorld = function () {
-        return this._world;
-    };
+BrushStroke.prototype.isDirty = function(){
+    return this._isDirty;
+};
 
-    this.geomType = function () {
-        return this.GEOM_TYPE_BRUSH_STROKE;
-    };
+BrushStroke.prototype.makeDirty = function(){
+    this._isDirty=true;
+};
 
-    this.setDrawingTool = function (tool) {
-        this._drawingTool = tool;
-    };
+BrushStroke.prototype.getStageWorldCenter = function() {
+    return this._stageWorldCenter;
+};
 
-    this.getDrawingTool = function () {
-        return this._drawingTool;
-    };
+BrushStroke.prototype.getBBoxMin = function () {
+    return this._BBoxMin;
+};
 
-    this.setPlaneMatrix = function(planeMat){
-        this._planeMat = planeMat;
-    };
+BrushStroke.prototype.getBBoxMax = function () {
+    return this._BBoxMax;
+};
 
-    this.setPlaneMatrixInverse = function(planeMatInv){
-        this._planeMatInv = planeMatInv;
-    };
+BrushStroke.prototype.getStrokeWidth = function () {
+    return this._strokeWidth;
+};
 
-    this.setPlaneCenter = function(pc){
-        this._planeCenter = pc;
-    };
+BrushStroke.prototype.setStrokeWidth = function (w) {
+    this._strokeWidth = w;
+    if (this._strokeWidth<1) {
+        this._strokeWidth = 1;
+    }
+    this._isDirty=true;
+};
 
-    this.setDragPlane = function(p){
-        this._dragPlane = p;
-    };
+BrushStroke.prototype.getStrokeMaterial = function () {
+    return this._strokeMaterial;
+};
 
-    this.getNumPoints = function () {
-        if (this._LocalPoints.length)
-            return this._LocalPoints.length;
-        else
-            return this._Points.length;
-    };
+BrushStroke.prototype.setStrokeMaterial = function (m) {
+    this._strokeMaterial = m; this._isDirty = true;
+};
 
-    this.getPoint = function (index) {
-        return this._Points[index].slice(0);
-    };
+BrushStroke.prototype.getStrokeColor = function () {
+    return this._strokeColor;
+};
 
-    this.addPoint = function (pt) {
-        //add the point only if it is some epsilon away from the previous point
-        var numPoints = this._Points.length;
-        if (numPoints>0) {
-            var threshold = this._MIN_SAMPLE_DISTANCE_THRESHOLD;
-            var prevPt = this._Points[numPoints-1];
-            var diffPt = [prevPt[0]-pt[0], prevPt[1]-pt[1]];
-            var diffPtMag = Math.sqrt(diffPt[0]*diffPt[0] + diffPt[1]*diffPt[1]);
-            if (diffPtMag>threshold){
-                this._Points.push(pt);
-                this._isDirty=true;
-                this._isInit = false;
-            }
-        } else {
-            this._Points.push(pt);
-            this._isDirty=true;
-            this._isInit = false;
-        }
-    };
-    
-    this.insertPoint = function(pt, index){
-        this._Points.splice(index, 0, pt);
-        this._isDirty=true;
-        this._isInit = false;
-    };
+BrushStroke.prototype.setStrokeColor = function (c) {
+    this._strokeColor = c; this._isDirty = true;
+};
 
-    this.isDirty = function(){
-        return this._isDirty;
-    };
+BrushStroke.prototype.setFillColor = function(c){
+    return;
+}; //NO-OP for now as we have no fill region
 
-    this.makeDirty = function(){
-        this._isDirty=true;
-    };
+BrushStroke.prototype.setSecondStrokeColor = function(c){
+    this._secondStrokeColor=c; this._isDirty = true;
+};
 
-    this.getStageWorldCenter = function() {
-        return this._stageWorldCenter;
-    };
+BrushStroke.prototype.setStrokeHardness = function(h){
+    if (this._strokeHardness!==h){
+        this._strokeHardness=h;
+        this._isDirty = true;
+    }
+};
+BrushStroke.prototype.getStrokeHardness = function(){
+    return this._strokeHardness;
+};
+
+BrushStroke.prototype.setDoSmoothing = function(s){
+    if (this._strokeDoSmoothing!==s) {
+        this._strokeDoSmoothing = s;
+        this._isDirty = true;
+    }
+};
 
-    this.getBBoxMin = function () {
-        return this._BBoxMin;
-    };
+BrushStroke.prototype.getDoSmoothing = function(){
+    return this._strokeDoSmoothing;
+};
 
-    this.getBBoxMax = function () {
-        return this._BBoxMax;
-    };
+BrushStroke.prototype.setSmoothingAmount = function(a){
+    if (this._strokeAmountSmoothing!==a) {
+        this._strokeAmountSmoothing = a;
+        this._isDirty = true;
+    }
+};
 
-    this.getStrokeWidth = function () {
-        return this._strokeWidth;
-    };
+BrushStroke.prototype.getSmoothingAmount = function(){
+    return this._strokeAmountSmoothing;
+};
 
-    this.setStrokeWidth = function (w) {
-        this._strokeWidth = w;
-        if (this._strokeWidth<1) {
-            this._strokeWidth = 1;
-        }
-        this._isDirty=true;
-    };
+BrushStroke.prototype.setStrokeUseCalligraphic = function(c){
+    if (this._strokeUseCalligraphic!==c){
+        this._strokeUseCalligraphic = c;
+        this._isDirty = true;
+    }
+};
 
-    this.getStrokeMaterial = function () {
-        return this._strokeMaterial;
+BrushStroke.prototype.setStrokeAngle = function(a){
+    if (this._strokeAngle!==a){
+        this._strokeAngle = a;
+        this._isDirty = true;
     };
+};
 
-    this.setStrokeMaterial = function (m) {
-        this._strokeMaterial = m; this._isDirty = true;
-    };
+BrushStroke.prototype.getStrokeUseCalligraphic = function(){
+    return this._strokeUseCalligraphic;
+};
 
-    this.getStrokeColor = function () {
-        return this._strokeColor;
-    };
+BrushStroke.prototype.getStrokeAngle = function(){
+    return this._strokeAngle;
+};
 
-    this.setStrokeColor = function (c) {
-        this._strokeColor = c; this._isDirty = true;
-    };
+BrushStroke.prototype.getStrokeStyle = function () {
+    return this._strokeStyle;
+};
 
-    this.setFillColor = function(c){
-        return;
-    }; //NO-OP for now as we have no fill region
+BrushStroke.prototype.setStrokeStyle = function (s) {
+    this._strokeStyle = s;
+};
 
-    this.setSecondStrokeColor = function(c){
-        this._secondStrokeColor=c; this._isDirty = true;
+BrushStroke.prototype.setWidth = function (newW) {
+    if (newW<1) {
+        newW=1; //clamp minimum width to 1
     }
 
-    this.setStrokeHardness = function(h){
-        if (this._strokeHardness!==h){
-            this._strokeHardness=h;
-            this._isDirty = true;
-        }
-    }
-    this.getStrokeHardness = function(){
-        return this._strokeHardness;
+    //scale the contents of this subpath to lie within this width
+    //determine the scale factor by comparing with the old width
+    var oldWidth = this._BBoxMax[0]-this._BBoxMin[0];
+    if (oldWidth<1) {
+        oldWidth=1;
     }
 
-    this.setDoSmoothing = function(s){
-        if (this._strokeDoSmoothing!==s) {
-            this._strokeDoSmoothing = s;
-            this._isDirty = true;
-        }
+    var scaleX = newW/oldWidth;
+    if (scaleX===1) {
+        return; //no need to do anything
     }
 
-    this.getDoSmoothing = function(){
-        return this._strokeDoSmoothing;
-    }
+    //scale the local point positions such that the width of the bbox is the newW
+    var origX = this._BBoxMin[0];
+    var numPoints = this._LocalPoints.length;
+    for (var i=0;i<numPoints;i++){
+        //compute the distance from the bboxMin
+        var oldW = this._LocalPoints[i][0] - origX;
+        this._LocalPoints[i] = [(origX + oldW*scaleX),this._LocalPoints[i][1],this._LocalPoints[i][2]];
 
-    this.setSmoothingAmount = function(a){
-        if (this._strokeAmountSmoothing!==a) {
-            this._strokeAmountSmoothing = a;
-            this._isDirty = true;
-        }
+        oldW = this._OrigLocalPoints[i][0] - origX;
+        this._OrigLocalPoints[i] = [(origX + oldW*scaleX),this._OrigLocalPoints[i][1],this._OrigLocalPoints[i][2]];
     }
+    this._isDirty = true;
+};
 
-    this.getSmoothingAmount = function(){
-        return this._strokeAmountSmoothing;
+BrushStroke.prototype.setHeight = function (newH) {
+    if (newH<1) {
+        newH=1; //clamp minimum width to 1
     }
 
-    this.setStrokeUseCalligraphic = function(c){
-        if (this._strokeUseCalligraphic!==c){
-            this._strokeUseCalligraphic = c;
-            this._isDirty = true;
-        }
+    //scale the contents of this subpath to lie within this height
+    //determine the scale factor by comparing with the old height
+    var oldHeight = this._BBoxMax[1]-this._BBoxMin[1];
+    if (oldHeight<1) {
+        oldHeight=1;
     }
 
-    this.setStrokeAngle = function(a){
-        if (this._strokeAngle!==a){
-            this._strokeAngle = a;
-            this._isDirty = true;
-        };
+    var scaleY = newH/oldHeight;
+    if (scaleY===1) {
+        return; //no need to do anything
     }
 
-    this.getStrokeUseCalligraphic = function(){
-        return this._strokeUseCalligraphic;
-    }
+    //scale the local point positions such that the width of the bbox is the newW
+    var origY = this._BBoxMin[1];
+    var numPoints = this._LocalPoints.length;
+    for (var i=0;i<numPoints;i++){
+        //compute the distance from the bboxMin
+        var oldH = this._LocalPoints[i][1] - origY;
+        this._LocalPoints[i] = [this._LocalPoints[i][0],(origY + oldH*scaleY),this._LocalPoints[i][2]];
 
-    this.getStrokeAngle = function(){
-        return this._strokeAngle;
+        oldH = this._OrigLocalPoints[i][1] - origY;
+        this._OrigLocalPoints[i] = [this._OrigLocalPoints[i][0],(origY + oldH*scaleY),this._OrigLocalPoints[i][2]];
     }
+    this._isDirty = true;
+};
 
-    this.getStrokeStyle = function () {
-        return this._strokeStyle;
-    };
-
-    this.setStrokeStyle = function (s) {
-        this._strokeStyle = s;
-    };
-
-    this.setWidth = function (newW) {
-        if (newW<1) {
-            newW=1; //clamp minimum width to 1
-        }
-
-        //scale the contents of this subpath to lie within this width
-        //determine the scale factor by comparing with the old width
-        var oldWidth = this._BBoxMax[0]-this._BBoxMin[0];
-        if (oldWidth<1) {
-            oldWidth=1;
-        }
-
-        var scaleX = newW/oldWidth;
-        if (scaleX===1) {
-            return; //no need to do anything
-        }
-
-        //scale the local point positions such that the width of the bbox is the newW
-        var origX = this._BBoxMin[0];
-        var numPoints = this._LocalPoints.length;
-        for (var i=0;i<numPoints;i++){
-            //compute the distance from the bboxMin
-            var oldW = this._LocalPoints[i][0] - origX;
-            this._LocalPoints[i] = [(origX + oldW*scaleX),this._LocalPoints[i][1],this._LocalPoints[i][2]];
-
-            oldW = this._OrigLocalPoints[i][0] - origX;
-            this._OrigLocalPoints[i] = [(origX + oldW*scaleX),this._OrigLocalPoints[i][1],this._OrigLocalPoints[i][2]];
-        }
-        this._isDirty = true;
-    };
-
-    this.setHeight = function (newH) {
-        if (newH<1) {
-            newH=1; //clamp minimum width to 1
-        }
-
-        //scale the contents of this subpath to lie within this height
-        //determine the scale factor by comparing with the old height
-        var oldHeight = this._BBoxMax[1]-this._BBoxMin[1];
-        if (oldHeight<1) {
-            oldHeight=1;
-        }
+BrushStroke.prototype.getWidth = function() {
+    if (this._isDirty){
+        this.update();
+    }
+    return this._BBoxMax[0]-this._BBoxMin[0];
+};
 
-        var scaleY = newH/oldHeight;
-        if (scaleY===1) {
-            return; //no need to do anything
+BrushStroke.prototype.getHeight = function() {
+    if (this._isDirty){
+        this.update();
+    }
+    return this._BBoxMax[1]-this._BBoxMin[1];
+};
+
+//remove all the points
+BrushStroke.prototype.clear = function () {
+    this._Points = [];
+    this._OrigLocalPoints    = [];
+    this._isDirty=true;
+    this._isInit = false;
+};
+
+BrushStroke.prototype._addSamples = function() {
+    //**** add samples to the long sections of the path --- Catmull-Rom spline interpolation *****
+    // instead of the following, may use 4-point subdivision iterations over continuous regions of 'long' segments
+    // look at http://www.gvu.gatech.edu/~jarek/Split&Tweak/ for formula
+
+    var numPoints = this._Points.length;
+    var numInsertedPoints = 0;
+    var newSampledPoints = [];
+    var threshold = this._MAX_SAMPLE_DISTANCE_THRESHOLD;//this determines whether a segment between two sample too long
+    var prevPt = this._Points[0];
+    newSampledPoints.push(this._Points[0]);
+    for (var i=1;i<numPoints;i++) {
+        var pt = this._Points[i];
+        var diff = [pt[0]-prevPt[0], pt[1]-prevPt[1]];
+        var distance = Math.sqrt(diff[0]*diff[0]+diff[1]*diff[1]);
+        if (distance>threshold){
+            //build the control polygon for the Catmull-Rom spline (prev. 2 points and next 2 points)
+            var prev = (i===1) ? i-1 : i-2;
+            var next = (i===numPoints-1) ? i : i+1;
+            var ctrlPts = [this._Points[prev], this._Points[i-1], this._Points[i], this._Points[next]];
+            //insert points along the prev. to current point
+            var numNewPoints = Math.floor(distance/threshold);
+            for (var j=0;j<numNewPoints;j++){
+                var param = (j+1)/(numNewPoints+1);
+                var newpt = this._CatmullRomSplineInterpolate(ctrlPts, param);
+                newSampledPoints.push(newpt);
+                numInsertedPoints++;
+            }
         }
+        newSampledPoints.push(pt);
+        prevPt=pt;
 
-        //scale the local point positions such that the width of the bbox is the newW
-        var origY = this._BBoxMin[1];
-        var numPoints = this._LocalPoints.length;
-        for (var i=0;i<numPoints;i++){
-            //compute the distance from the bboxMin
-            var oldH = this._LocalPoints[i][1] - origY;
-            this._LocalPoints[i] = [this._LocalPoints[i][0],(origY + oldH*scaleY),this._LocalPoints[i][2]];
-
-            oldH = this._OrigLocalPoints[i][1] - origY;
-            this._OrigLocalPoints[i] = [this._OrigLocalPoints[i][0],(origY + oldH*scaleY),this._OrigLocalPoints[i][2]];
+        //end this function if the numPoints has gone above the max. size specified
+        if (numPoints> this._MAX_ALLOWED_SAMPLES){
+            console.log("leaving the resampling because numPoints is greater than limit:"+this._MAX_ALLOWED_SAMPLES);
+            break;
         }
-        this._isDirty = true;
-    };
+    }
+    this._Points = newSampledPoints.slice(0);
+    newSampledPoints = [];
+};
 
-    this.getWidth = function() {
-        if (this._isDirty){
-            this.update();
-        }
-        return this._BBoxMax[0]-this._BBoxMin[0];
-    };
+BrushStroke.prototype.init = function(){
+    if (!this._isInit){
+        // **** add samples to the _Points in stageworld space ****
+        this._addSamples();
 
-    this.getHeight = function() {
-        if (this._isDirty){
-            this.update();
-        }
-        return this._BBoxMax[1]-this._BBoxMin[1];
-    };
+        // **** compute the 2D (canvas space) coord. of the _Points  ****
+        this._buildLocalCoordFromStageWorldCoord();
 
-    //remove all the points
-    this.clear = function () {
-        this._Points = [];
-        this._OrigLocalPoints    = [];
-        this._isDirty=true;
-        this._isInit = false;
-    };
+        // **** turn off the init. flag ****
+        this._isInit = true;
+        this._isDirty= true;
+    }
 
-    this._addSamples = function() {
-        //**** add samples to the long sections of the path --- Catmull-Rom spline interpolation *****
-        // instead of the following, may use 4-point subdivision iterations over continuous regions of 'long' segments
-        // look at http://www.gvu.gatech.edu/~jarek/Split&Tweak/ for formula
-
-        var numPoints = this._Points.length;
-        var numInsertedPoints = 0;
-        var newSampledPoints = [];
-        var threshold = this._MAX_SAMPLE_DISTANCE_THRESHOLD;//this determines whether a segment between two sample too long
-        var prevPt = this._Points[0];
-        newSampledPoints.push(this._Points[0]);
-        for (var i=1;i<numPoints;i++) {
-            var pt = this._Points[i];
-            var diff = [pt[0]-prevPt[0], pt[1]-prevPt[1]];
-            var distance = Math.sqrt(diff[0]*diff[0]+diff[1]*diff[1]);
-            if (distance>threshold){
-                //build the control polygon for the Catmull-Rom spline (prev. 2 points and next 2 points)
-                var prev = (i===1) ? i-1 : i-2;
-                var next = (i===numPoints-1) ? i : i+1;
-                var ctrlPts = [this._Points[prev], this._Points[i-1], this._Points[i], this._Points[next]];
-                //insert points along the prev. to current point
-                var numNewPoints = Math.floor(distance/threshold);
-                for (var j=0;j<numNewPoints;j++){
-                    var param = (j+1)/(numNewPoints+1);
-                    var newpt = this._CatmullRomSplineInterpolate(ctrlPts, param);
-                    newSampledPoints.push(newpt);
-                    numInsertedPoints++;
-                }
+    // **** update the current brush stroke ****
+    // smoothing, re-compute bounding box, etc.
+    this.update();
+};
+
+BrushStroke.prototype._unprojectPt = function(pt, pespectiveDist){
+    var retPt = pt.slice(0);
+    if (MathUtils.fpCmp(pespectiveDist,-pt[2]) !== 0){
+        z = pt[2]*pespectiveDist/(pespectiveDist + pt[2]);
+        var x = pt[0]*(pespectiveDist - z)/pespectiveDist,
+            y = pt[1]*(pespectiveDist - z)/pespectiveDist;
+        retPt[0] = x;  retPt[1] = y;  retPt[2] = z;
+    }
+    return retPt;
+};
+
+BrushStroke.prototype._buildLocalCoordFromStageWorldCoord = function() {
+    var stage = ViewUtils.getStage();
+    var stageOffset = ViewUtils.getElementOffset(stage);
+    ViewUtils.setViewportObj(stage);
+
+    var numPoints = this._Points.length;
+    var i;
+
+    // ***** compute center of bbox based on stage world coords *****
+    var bboxMin = [Infinity, Infinity, Infinity];
+    var bboxMax = [-Infinity, -Infinity, -Infinity];
+    for (i=0;i<numPoints;i++){
+        var pt = this._Points[i];
+        for (var d = 0; d < 3; d++) {
+            if (bboxMin[d] > pt[d]) {
+                bboxMin[d] = pt[d];
             }
-            newSampledPoints.push(pt);
-            prevPt=pt;
-
-            //end this function if the numPoints has gone above the max. size specified
-            if (numPoints> this._MAX_ALLOWED_SAMPLES){
-                console.log("leaving the resampling because numPoints is greater than limit:"+this._MAX_ALLOWED_SAMPLES);
-                break;
+            if (bboxMax[d] < pt[d]) {
+                bboxMax[d] = pt[d];
             }
         }
-        this._Points = newSampledPoints.slice(0);
-        newSampledPoints = [];
-    };
+    }
+    //save the center of the bbox for later use (while constructing the canvas)
+    this._stageWorldCenter = VecUtils.vecInterpolate(3, bboxMin, bboxMax, 0.5);
+
+    // ***** center the input stageworld data about the center of the bbox *****
+    this._LocalPoints = [];
+    for (i=0;i<numPoints;i++){
+        var localPoint = [this._Points[i][0],this._Points[i][1],this._Points[i][2]];
+        localPoint[0]-= this._stageWorldCenter[0];
+        localPoint[1]-= this._stageWorldCenter[1];
+
+        // ***** unproject all the centered points and convert them to 2D (plane space)*****
+        // (undo the projection step performed by the browser)
+        //localPoint = this._unprojectPt(localPoint, 1400); //todo get the perspective distance from the canvas
+        localPoint = MathUtils.transformPoint(localPoint, this._planeMatInv);
+
+        //add to the list of local points
+        this._LocalPoints.push(localPoint);
+    }
 
-    this.init = function(){
-        if (!this._isInit){
-            // **** add samples to the _Points in stageworld space ****
-            this._addSamples();
+    // ***** compute width, height, and midpoint position (in stage world position) of the canvas
+    this._updateBoundingBox(); //compute the bbox to obtain the width and height used below
+    var halfwidth = 0.5*(this._BBoxMax[0]-this._BBoxMin[0]);
+    var halfheight = 0.5*(this._BBoxMax[1]-this._BBoxMin[1]);
+    this._OrigLocalPoints    = [];
+    for (i=0;i<numPoints;i++) {
+        this._LocalPoints[i][0]+= halfwidth;
+        this._LocalPoints[i][1]+= halfheight;
+
+        //store the original points
+        this._OrigLocalPoints.push([this._LocalPoints[i][0],this._LocalPoints[i][1],this._LocalPoints[i][2]]);
+    }
+    //update the bbox with the same adjustment as was made for the local points above
+    this._BBoxMax[0]+= halfwidth;this._BBoxMin[0]+= halfwidth;
+    this._BBoxMax[1]+= halfheight;this._BBoxMin[1]+= halfheight;
+};
 
-            // **** compute the 2D (canvas space) coord. of the _Points  ****
-            this._buildLocalCoordFromStageWorldCoord();
+BrushStroke.prototype.update = function() {
+    if (this._isDirty){
+        // **** do smoothing if necessary ****
+        this._doSmoothing();
 
-            // **** turn off the init. flag ****
-            this._isInit = true;
-            this._isDirty= true;
-        }
+        // **** recompute the bounding box ****
+        this._updateBoundingBox();
 
-        // **** update the current brush stroke ****
-        // smoothing, re-compute bounding box, etc.
-        this.update();
-    };
+        // **** offset the local coords to account for the change in bbox ****
+        this._offsetLocalCoord(-this._BBoxMin[0], -this._BBoxMin[1]);
 
-    this._unprojectPt = function(pt, pespectiveDist){
-        var retPt = pt.slice(0);
-        if (MathUtils.fpCmp(pespectiveDist,-pt[2]) !== 0){
-            z = pt[2]*pespectiveDist/(pespectiveDist + pt[2]);
-            var x = pt[0]*(pespectiveDist - z)/pespectiveDist,
-                y = pt[1]*(pespectiveDist - z)/pespectiveDist;
-            retPt[0] = x;  retPt[1] = y;  retPt[2] = z;
-        }
-        return retPt;
-    };
-
-    this._buildLocalCoordFromStageWorldCoord = function() {
-        var stage = ViewUtils.getStage();
-        var stageOffset = ViewUtils.getElementOffset(stage);
-        ViewUtils.setViewportObj(stage);
-
-        var numPoints = this._Points.length;
-        var i;
+        // **** turn off the dirty flag ****
+        this._isDirty = false;
+    }
+};
 
-        // ***** compute center of bbox based on stage world coords *****
-        var bboxMin = [Infinity, Infinity, Infinity];
-        var bboxMax = [-Infinity, -Infinity, -Infinity];
-        for (i=0;i<numPoints;i++){
-            var pt = this._Points[i];
+BrushStroke.prototype._offsetLocalCoord = function(deltaW, deltaH){
+    var numPoints = this._LocalPoints.length;
+    for (var i=0;i<numPoints;i++) {
+        this._LocalPoints[i][0]+= deltaW;
+        this._LocalPoints[i][1]+= deltaH;
+    }
+};
+
+//I had to write this function to do a deep copy because I think slice(0) creates a copy by reference
+BrushStroke.prototype._copyCoordinates3D = function(srcCoord, destCoord){
+    var i=0;
+    var numPoints = srcCoord.length;
+    for (i=0;i<numPoints;i++){
+        destCoord[i] = [srcCoord[i][0],srcCoord[i][1],srcCoord[i][2]];
+    }
+};
+BrushStroke.prototype._doSmoothing = function() {
+    var numPoints = this._LocalPoints.length;
+    if (this._strokeDoSmoothing && numPoints>1) {
+        this._copyCoordinates3D(this._OrigLocalPoints   , this._LocalPoints);
+        //iterations of Laplacian smoothing (setting the points to the average of their neighbors)
+        var numLaplacianIterations = this._strokeAmountSmoothing;
+        for (var n=0;n<numLaplacianIterations;n++){
+            var newPoints = this._LocalPoints.slice(0); //I think this performs a copy by reference, which would make the following a SOR step
+            for (var i=1;i<numPoints-1;i++) {
+                var avgPos = [  0.5*(this._LocalPoints[i-1][0] + this._LocalPoints[i+1][0]),
+                                0.5*(this._LocalPoints[i-1][1] + this._LocalPoints[i+1][1]),
+                                0.5*(this._LocalPoints[i-1][2] + this._LocalPoints[i+1][2])] ;
+                newPoints[i] = avgPos;
+            }
+            this._LocalPoints = newPoints.slice(0);
+        }
+    }
+};
+
+BrushStroke.prototype._updateBoundingBox = function() {
+    // *** compute the bounding box *********
+    var points = this._LocalPoints;
+    var numPoints = points.length;
+
+    this._BBoxMin = [Infinity, Infinity, Infinity];
+    this._BBoxMax = [-Infinity, -Infinity, -Infinity];
+    if (numPoints === 0) {
+        this._BBoxMin = [0, 0, 0];
+        this._BBoxMax = [0, 0, 0];
+    } else {
+        for (var i=0;i<numPoints;i++){
+            var pt = points[i];
             for (var d = 0; d < 3; d++) {
-                if (bboxMin[d] > pt[d]) {
-                    bboxMin[d] = pt[d];
+                if (this._BBoxMin[d] > pt[d]) {
+                    this._BBoxMin[d] = pt[d];
                 }
-                if (bboxMax[d] < pt[d]) {
-                    bboxMax[d] = pt[d];
+                if (this._BBoxMax[d] < pt[d]) {
+                    this._BBoxMax[d] = pt[d];
                 }
-            }
-        }
-        //save the center of the bbox for later use (while constructing the canvas)
-        this._stageWorldCenter = VecUtils.vecInterpolate(3, bboxMin, bboxMax, 0.5);
-
-        // ***** center the input stageworld data about the center of the bbox *****
-        this._LocalPoints = [];
-        for (i=0;i<numPoints;i++){
-            var localPoint = [this._Poi