         }
         else if(stroke.scaleMode != LineScaleMode.NORMAL)
         {
-        	var strokeWeight:Number = stroke.weight;
-        	if (stroke.scaleMode == LineScaleMode.HORIZONTAL)
-        	{
-        		setActualScale(w / (bw + strokeWeight),(h - strokeWeight) / bh);
+            var strokeWeight:Number = stroke.weight;
+            if (stroke.scaleMode == LineScaleMode.HORIZONTAL)
+            {
+                setActualScale(w / (bw + strokeWeight),(h - strokeWeight) / bh);
             }
             else if(stroke.scaleMode == LineScaleMode.VERTICAL)
             {
-                setActualScale((w - strokeWeight) / bw,h / (bh + strokeWeight));        		
-        	}
-        	else // LineScaleMode.NONE
-        	{
-        		setActualScale((w - strokeWeight) / bw,(h - strokeWeight) / bh);
-        	}
+                setActualScale((w - strokeWeight) / bw,h / (bh + strokeWeight));                
+            }
+            else // LineScaleMode.NONE
+            {
+                setActualScale((w - strokeWeight) / bw,(h - strokeWeight) / bh);
+            }
         }
         else
         {
-	        var t:Number = stroke.weight;
-	        t = t * t / 2;
-	        var t1:Number = t / ( bw * bw);
-	
-	        // TODO EGeorige: the following equations don't 
-	        // account for skew components of the matrix.
-	        // Also, this can be greatly optimized.            
-	
-	        // (1) w = bw * x + sqrt( x^2 * t + y^2 * t)
-	        // (2) h = bh * y + sqrt( x^2 * t + y^2 * t)
-	        // (1) - (2):
-	        // w - h = bw * x - bh * y
-	        // x = ( w - h + bh * y ) / bw
-	        // substitute back in (2):
-	        // h - bh * y = sqrt( (w - h + bh * y )^2 * t / bw^2 + y^2 * t )
-	        // h^2 - 2*h*bh*y +bh^2 * y^2 = ((w - h)^2 + 2 * (w-h) * bh * y + bh^2 * y^2 ) * t / bw^2 + y^2 * t
-	        // bh^2 * y^2 - 2*h*bh*y  + h ^2 = t1 * (w - h)^2 + 2 * t1 * (w-h) * bh * y + t1 * bh^2 * y^2 + t * y^2
-	        // bh^2 * y^2 - 2*h*bh*y  + h^2 = t1*(w-h)^2 + 2*t1*(w-h)*bh* y + (t1*bh^2 + t)*y^2
-	        // (bh^2 - t1*bh^2 - t) * y^2 -(2*h*bh +2*t1*(w-h)*bh) * y + (h^2 - t1*(w-h)^2) = 0 
-	        
-	        if( bw != 0 && bh != 0)
-	        {
-	            var A:Number = bh * bh - t1 * bh * bh - t;   
-	            var B:Number = -2 *h * bh - 2 * t1 * (w-h) * bh;            
-	            var C:Number = h * h - t1 * (w-h) * (w-h);                
-	
-	            var D:Number = B * B - 4 * A * C;
-	            if (D >= 0)
-	            {
-	                var y1:Number = (-B + Math.sqrt(D)) / (2 * A);
-	                var y2:Number = (-B - Math.sqrt(D)) / (2 * A);
-	                
-	                var x1:Number = ( w - h + bh * y1 ) / bw;
-	                var x2:Number = ( w - h + bh * y2 ) / bw;
-	                
-	                if (Math.abs(h - bh * y1 - Math.sqrt(x1 * x1 * t + y1 * y1 * t)) < 0.5 &&
-	                    Math.abs(w - bw * x1 - Math.sqrt(x1 * x1 * t + y1 * y1 * t)) < 0.5)
-	                {
-	                    setActualScale(x1,y1);
-	                }
-	                else
-	                if (Math.abs(h - bh * y2 - Math.sqrt(x2 * x2 * t + y2 *y2 * t)) < 0.5 &&
-	                    Math.abs(w - bw * x2 - Math.sqrt(x2 * x2 * t + y2 *y2 * t)) < 0.5)
-	                {
-	                    setActualScale(x2,y2);
-	                }
-	            }
-	        }
+            var t:Number = stroke.weight;
+            t = t * t / 2;
+            var t1:Number = t / ( bw * bw);
+    
+            // TODO EGeorige: the following equations don't 
+            // account for skew components of the matrix.
+            // Also, this can be greatly optimized.            
+    
+            // (1) w = bw * x + sqrt( x^2 * t + y^2 * t)
+            // (2) h = bh * y + sqrt( x^2 * t + y^2 * t)
+            // (1) - (2):
+            // w - h = bw * x - bh * y
+            // x = ( w - h + bh * y ) / bw
+            // substitute back in (2):
+            // h - bh * y = sqrt( (w - h + bh * y )^2 * t / bw^2 + y^2 * t )
+            // h^2 - 2*h*bh*y +bh^2 * y^2 = ((w - h)^2 + 2 * (w-h) * bh * y + bh^2 * y^2 ) * t / bw^2 + y^2 * t
+            // bh^2 * y^2 - 2*h*bh*y  + h ^2 = t1 * (w - h)^2 + 2 * t1 * (w-h) * bh * y + t1 * bh^2 * y^2 + t * y^2
+            // bh^2 * y^2 - 2*h*bh*y  + h^2 = t1*(w-h)^2 + 2*t1*(w-h)*bh* y + (t1*bh^2 + t)*y^2
+            // (bh^2 - t1*bh^2 - t) * y^2 -(2*h*bh +2*t1*(w-h)*bh) * y + (h^2 - t1*(w-h)^2) = 0 
+            
+            if( bw != 0 && bh != 0)
+            {
+                var A:Number = bh * bh - t1 * bh * bh - t;   
+                var B:Number = -2 *h * bh - 2 * t1 * (w-h) * bh;            
+                var C:Number = h * h - t1 * (w-h) * (w-h);                
+    
+                var D:Number = B * B - 4 * A * C;
+                if (D >= 0)
+                {
+                    var y1:Number = (-B + Math.sqrt(D)) / (2 * A);
+                    var y2:Number = (-B - Math.sqrt(D)) / (2 * A);
+                    
+                    var x1:Number = ( w - h + bh * y1 ) / bw;
+                    var x2:Number = ( w - h + bh * y2 ) / bw;
+                    
+                    if (Math.abs(h - bh * y1 - Math.sqrt(x1 * x1 * t + y1 * y1 * t)) < 0.5 &&
+                        Math.abs(w - bw * x1 - Math.sqrt(x1 * x1 * t + y1 * y1 * t)) < 0.5)
+                    {
+                        setActualScale(x1,y1);
+                    }
+                    else
+                    if (Math.abs(h - bh * y2 - Math.sqrt(x2 * x2 * t + y2 *y2 * t)) < 0.5 &&
+                        Math.abs(w - bw * x2 - Math.sqrt(x2 * x2 * t + y2 *y2 * t)) < 0.5)
+                    {
+                        setActualScale(x2,y2);
+                    }
+                }
+            }
         }
 
         if (super.scaleX != lastActualScaleX || super.scaleY != lastActualScaleY)

        _winding = value;
    }
    
    public function get winding():String 
    {
        return _winding; 

        invalidateSize();
    }
   
    /**
     * @private
     */
    private function clearBounds():void
    {
        _bounds = null;
