root/lang/legacy-actionscript/as2draw/Drawable.as

class Drawable
{
        public static var UNDO_LIMIT = 3;
        
        private var mBGColor:Number;
        private var mMC:MovieClip;
        private var mMStack:MovieClipStack;
        private var mCurrentDrawingMC:MovieClip;
        private var mSize:Object;
        private var mPixBuf:PixelBuffer;

        private var mDragData;
        private var mCurrentPen:Pen;

        public function Drawable(aContainer:MovieClip, aBGColor:Number, aW:Number, aH:Number)
        {
                mCurrentPen = new Pen();
                mDragData = {dragging: false, prevX: 0, prevY: 0, count: 0, startX: 0, startY: 0, startLayer: null};
                mMC = aContainer.createEmptyMovieClip("drawable_mc", 1);
                mMC._quality = "LOW";
                
                mMStack = new MovieClipStack(mMC);
                mCurrentDrawingMC = null;
                
                mPixBuf = new PixelBuffer(aW, aH, mMC);
                mBGColor = aBGColor;

                mSize = {w: aW, h:aH};
                clear();

                var _this = this;
                mMC.onPress     = function(){ _this.onPress();     };
                mMC.onMouseUp   = function(){ _this.onMouseUp();   };
                mMC.onMouseMove = function(){ _this.onMouseMove(); };
                mMC.useHandCursor = false;
        }

        public function getCurrentPen():Pen
        {
                return mCurrentPen;
        }

        public function setY(y:Number):Void
        {
                mMC._y = y;
        }
        
        public function removeTopLayer():Void
        {
                //mPixBuf.dumpBuffer();
                mMStack.pop();
        }

        public function onPress()
        {
                mDragData.dragging = true;
                mDragData.count = 0;
                mDragData.prevX = Math.floor(mMC._xmouse);
                mDragData.prevY = Math.floor(mMC._ymouse);
                
                mDragData.startX = mDragData.prevX;
                mDragData.startY = mDragData.prevY;
                
                renderLine(mDragData.prevX, mDragData.prevY, mDragData.prevX, mDragData.prevY);
                mDragData.startLayer = mCurrentDrawingMC;
        
        }

        public function onMouseUp()
        {
                mDragData.dragging = false;
                /*if (mDragData.count > 0)
                        smooth(mMC._xmouse, mMC._ymouse);*/
                commit();
        }
        
        private static var PEN_OFFSET_1:Array = [0,-1, 1,0, 0,1, -1,0];
/*      
        private static var PEN_OFFSET_2:Array = [
                        -1, -2,  0, -2,  1, -2,
                -2, -1, -1, -1,  0, -1,  1, -1, 2, -1,
                -2,  0, -1,  0,  0,  0,  1,  0, 2,  0,
                -2,  1, -1,  1,  0,  1,  1,  1, 2,  1,
                        -1,  2,  0,  2,  1,  2
        ];*/
        private function renderLine(x1:Number, y1:Number, x2:Number, y2:Number)
        {
                var color:Number = mCurrentPen.color;
                var g:MovieClip;
                
                if (!mCurrentDrawingMC)
                        mCurrentDrawingMC = mMStack.pushNew();
                
                g = mCurrentDrawingMC;
        
                var ofs:Array = PEN_OFFSET_1;
                var l:Number = ofs.length>>1;
                var dx:Number = 0;
                var dy:Number = 0;
                
                for (var i:Number = -1;i < l;i++)
                {
                        if (i >= 0)
                        {
                                dx = ofs[i<<1];
                                dy = ofs[(i<<1)+1];
                        }
/*                      
                        mPixBuf.setOut(g);
*/
                        g.stackData.log.push(new LineData(x1+dx, y1+dy, x2+dx, y2+dy, color, mCurrentPen.color_index));
                        drawNativeLine(g, x1+dx, y1+dy, x2+dx, y2+dy, color);
                }
        }

        public function drawPixBufferLine(x1:Number, y1:Number, x2:Number, y2:Number, color:Number)
        {
                mPixBuf.drawLine(
                        x1, y1,
                        x2, y2, color, 0);
        }
        
        public function drawNativeLine(g:MovieClip, x1:Number, y1:Number, x2:Number, y2:Number, color:Number)
        {
                var DX:Number = Math.abs(x2 - x1);
                var DY:Number = Math.abs(y2 - y1);
                
                g.lineStyle(0, color);
                g.moveTo(x1, y1);
                g.lineTo(x2, y2);
                
                if (!(DX > DY && x1 < x2 && y1 < y2))
                        g.lineTo(x2+1, y2);
        }

        public function onMouseMove()
        {
                if (mDragData.dragging)
                {
                        /*if (++mDragData.count == 5)
                        {
                                smooth(mMC._xmouse, mMC._ymouse);
                                mDragData.count = 0;
                        }
                        else*/
                        {
                                var x:Number = Math.floor(mMC._xmouse);
                                var y:Number = Math.floor(mMC._ymouse);
                                renderLine(mDragData.prevX, mDragData.prevY, x, y);
                        
                                mDragData.prevX = x;
                                mDragData.prevY = y;
                        }
                }
        }
        
        public function smooth(x:Number, y:Number)
        {
                x = Math.floor(x);
                y = Math.floor(y);
                
                if (mDragData.startLayer == mCurrentDrawingMC)
                        mCurrentDrawingMC.clear();
                else
                        mMStack.pop();
                
                mCurrentDrawingMC = mDragData.startLayer;
                renderLine(mDragData.startX, mDragData.startY, x, y);
                mCurrentDrawingMC = null;
                
                mDragData.startX = x;
                mDragData.startY = y;
                mDragData.prevX = x;
                mDragData.prevY = y;

        }

        public function clear()
        {
                mMC.beginFill(mBGColor);
                U.rect(mMC, 0, 0, mSize.w, mSize.h);
                mMC.endFill();
        }
        
        private function commit()
        {
                if (mMStack.size() > UNDO_LIMIT)
                {
                        mMStack.fixBottom(mMC, this);
                }
                
                mCurrentDrawingMC = null;
        }
}